home *** CD-ROM | disk | FTP | other *** search
/ The Datafile PD-CD 4 / DATAFILE_PDCD4.iso / unix / armlinux / kernel_src / linux-1.3.,fff / linux-1.3.35-arm.diff
Encoding:
Text File  |  1996-03-03  |  152.0 KB  |  5,397 lines
  1. diff -urNwbB linux/Makefile linux.arm/Makefile
  2. --- linux/Makefile    Sun Mar  3 11:42:06 1996
  3. +++ linux.arm/Makefile    Sun Feb 11 13:47:34 1996
  4. @@ -2,7 +2,7 @@
  5.  PATCHLEVEL = 3
  6.  SUBLEVEL = 35
  7.  
  8. -ARCH = i386
  9. +ARCH = arm
  10.  
  11.  .EXPORT_ALL_VARIABLES:
  12.  
  13. @@ -86,13 +86,19 @@
  14.  # Include the make variables (CC, etc...)
  15.  #
  16.  
  17. +# Modified 11/02/96 by Russell King
  18. +#    - Doesn't include the drivers subdirectory as standard.
  19. +#    - Modified the 'nm' line in vmlinux so that we remove local and absolute symbols.
  20. +
  21.  ARCHIVES    =kernel/kernel.o mm/mm.o fs/fs.o ipc/ipc.o net/network.a
  22.  FILESYSTEMS    =fs/filesystems.a
  23. -DRIVERS        =drivers/block/block.a \
  24. +DRIVERS        =
  25. +LIBS        =$(TOPDIR)/lib/lib.a
  26. +SUBDIRS        =kernel mm fs net ipc lib
  27. +
  28. +DRIVERS :=drivers/block/block.a \
  29.           drivers/char/char.a \
  30.           drivers/net/net.a
  31. -LIBS        =$(TOPDIR)/lib/lib.a
  32. -SUBDIRS        =kernel drivers mm fs net ipc lib
  33.  
  34.  ifdef CONFIG_SCSI
  35.  DRIVERS := $(DRIVERS) drivers/scsi/scsi.a
  36. @@ -108,6 +114,10 @@
  37.  
  38.  include arch/$(ARCH)/Makefile
  39.  
  40. +ifndef CONFIG_ARM
  41. +SUBDIRS := drivers $(SUBDIRS)
  42. +endif
  43. +
  44.  .S.s:
  45.      $(CC) -D__ASSEMBLY__ -traditional -E -o $*.s $<
  46.  .S.o:
  47. @@ -125,7 +135,7 @@
  48.          $(FILESYSTEMS) \
  49.          $(DRIVERS) \
  50.          $(LIBS) -o vmlinux
  51. -    $(NM) vmlinux | grep -v '\(compiled\)\|\(\.o$$\)\|\( a \)' | sort > System.map
  52. +    $(NM) vmlinux | grep -v '\(compiled\)\|\(\.o$$\)\|\( a \)\|\( A \)\|\( t L\)' | sort > System.map
  53.  
  54.  symlinks:
  55.      rm -f include/asm
  56. diff -urNwbB linux/arch/arm/Makefile linux.arm/arch/arm/Makefile
  57. --- linux/arch/arm/Makefile    Thu Jan  1 01:00:00 1970
  58. +++ linux.arm/arch/arm/Makefile    Sat Feb 24 13:08:03 1996
  59. @@ -0,0 +1,70 @@
  60. +#
  61. +# arch/arm/Makefile
  62. +#
  63. +# This file is included by the global makefile so that you can add your own
  64. +# architecture-specific flags and dependencies. Remember to do have actions
  65. +# for "archclean" and "archdep" for cleaning up and making dependencies for
  66. +# this architecture
  67. +#
  68. +# This file is subject to the terms and conditions of the GNU General Public
  69. +# License.  See the file "COPYING" in the main directory of this archive
  70. +# for more details.
  71. +#
  72. +# Copyright (C) 1995 by Russell King
  73. +#
  74. +
  75. +#
  76. +# Set these to indicate how to link it..
  77. +# -qmagic (we need to remove the 32 byte header for bootup purposes)
  78. +#
  79. +
  80. +SUBARCH         = -m3
  81. +
  82. +CPP         = $(CC) -E $(SUBARCH)
  83. +CFLAGS        := $(CFLAGS:-fomit-frame-pointer=) $(SUBARCH)
  84. +LINKFLAGS     = -Ttext 0x01800000
  85. +ZLINKFLAGS     = -N -Ttext 0x01800000
  86. +
  87. +HEAD        := arch/arm/kernel/head.o
  88. +SUBDIRS        := arch/arm/drivers arch/arm/kernel arch/arm/mm arch/arm/lib $(SUBDIRS)
  89. +ARCHIVES    := arch/arm/kernel/kernel.o arch/arm/mm/mm.o arch/arm/lib/lib.o $(ARCHIVES)
  90. +LIBS        := $(LIBS) `gcc --print-libgcc-file-name`
  91. +
  92. +DRIVERS := arch/arm/drivers/block/block.a arch/arm/drivers/char/char.a \
  93. +           arch/arm/drivers/net/net.a
  94. +
  95. +ifdef CONFIG_SOUND
  96. +DRIVERS := $(DRIVERS) arch/arm/drivers/sound/sound.a
  97. +endif
  98. +
  99. +ifdef CONFIG_SCSI
  100. +DRIVERS := $(DRIVERS) arch/arm/drivers/scsi/scsi.a
  101. +endif
  102. +
  103. +
  104. +arch/arm/kernel: dummy
  105. +    $(MAKE) linuxsubdirs SUBDIRS=arch/arm/kernel
  106. +
  107. +arch/arm/mm: dummy
  108. +    $(MAKE) linuxsubdirs SUBDIRS=arch/arm/mm
  109. +
  110. +MAKEBOOT = $(MAKE) -C arch/$(ARCH)/boot
  111. +
  112. +install:
  113. +    @$(MAKEBOOT) install
  114. +
  115. +zinstall:
  116. +    @$(MAKEBOOT) zinstall
  117. +
  118. +zImage:
  119. +    @$(MAKEBOOT) zImage
  120. +
  121. +archclean:
  122. +    @$(MAKEBOOT) clean
  123. +    @$(MAKE) -C arch/$(ARCH)/drivers/block LINKCLEAN
  124. +    @$(MAKE) -C arch/$(ARCH)/drivers/char LINKCLEAN
  125. +    @$(MAKE) -C arch/$(ARCH)/drivers/net LINKCLEAN
  126. +    @$(MAKE) -C arch/$(ARCH)/drivers/scsi LINKCLEAN
  127. +
  128. +archdep:
  129. +    @$(MAKEBOOT) dep
  130. diff -urNwbB linux/arch/arm/boot/Makefile linux.arm/arch/arm/boot/Makefile
  131. --- linux/arch/arm/boot/Makefile    Thu Jan  1 01:00:00 1970
  132. +++ linux.arm/arch/arm/boot/Makefile    Sun Feb 11 21:59:54 1996
  133. @@ -0,0 +1,47 @@
  134. +#
  135. +# arch/i386/boot/Makefile
  136. +#
  137. +# This file is subject to the terms and conditions of the GNU General Public
  138. +# License.  See the file "COPYING" in the main directory of this archive
  139. +# for more details.
  140. +#
  141. +# Copyright (C) 1994 by Linus Torvalds
  142. +#
  143. +
  144. +Image:    $(CONFIGURE) tools/build $(TOPDIR)/vmlinux
  145. +    tools/build $(TOPDIR)/vmlinux > Image
  146. +    sync
  147. +
  148. +zImage:    $(CONFIGURE) tools/build compressed/vmlinux
  149. +    tools/build compressed/vmlinux > zImage
  150. +
  151. +compressed/vmlinux: $(TOPDIR)/vmlinux dep
  152. +    @$(MAKE) -C compressed vmlinux
  153. +
  154. +install: $(CONFIGURE) Image
  155. +    sh ./install.sh $(VERSION).$(PATCHLEVEL).$(SUBLEVEL) Image $(TOPDIR)/System.map "$(INSTALL_PATH)"
  156. +
  157. +zinstall: $(CONFIGURE) zImage
  158. +    sh ./install.sh $(VERSION).$(PATCHLEVEL).$(SUBLEVEL) zImage $(TOPDIR)/System.map "$(INSTALL_PATH)"
  159. +
  160. +tools/build: tools/build.c
  161. +    $(HOSTCC) $(CFLAGS) -o $@ $< -I$(TOPDIR)/include
  162. +
  163. +clean:
  164. +    rm -f Image zImage tools/build
  165. +    @$(MAKE) -C compressed clean
  166. +
  167. +dep:
  168. +
  169. +#zdisk: zImage
  170. +#    dd bs=8192 if=zImage of=/dev/fd0
  171. +
  172. +#zlilo: $(CONFIGURE) zImage
  173. +#    if [ -f $(INSTALL_PATH)/vmlinuz ]; then mv $(INSTALL_PATH)/vmlinuz $(INSTALL_PATH)/vmlinuz.old; fi
  174. +#    if [ -f $(INSTALL_PATH)/System.map ]; then mv $(INSTALL_PATH)/System.map $(INSTALL_PATH)/System.old; fi
  175. +#    cat zImage > $(INSTALL_PATH)/vmlinuz
  176. +#    cp $(TOPDIR)/System.map $(INSTALL_PATH)/
  177. +#    if [ -x /sbin/lilo ]; then /sbin/lilo; else /etc/lilo/install; fi
  178. +
  179. +#install: $(CONFIGURE) zImage
  180. +#    sh ./install.sh $(VERSION).$(PATCHLEVEL).$(SUBLEVEL) zImage $(TOPDIR)/System.map "$(INSTALL_PATH)"
  181. diff -urNwbB linux/arch/arm/boot/compressed/Makefile linux.arm/arch/arm/boot/compressed/Makefile
  182. --- linux/arch/arm/boot/compressed/Makefile    Thu Jan  1 01:00:00 1970
  183. +++ linux.arm/arch/arm/boot/compressed/Makefile    Sun Mar  3 13:35:37 1996
  184. @@ -0,0 +1,56 @@
  185. +#
  186. +# linux/arch/arm/boot/compressed/Makefile
  187. +#
  188. +# create a compressed vmlinux image from the original vmlinux
  189. +#
  190. +
  191. +CFLAGS = -O2 -DSTDC_HEADERS
  192. +LOADADDR = 0x01800000
  193. +RELADDR = 0x01960000
  194. +
  195. +SYSTEM = $(TOPDIR)/vmlinux
  196. +DECOMP_OBJS = inflate.o unzip.o misc.o ../../lib/ll_char_wr.o
  197. +
  198. +
  199. +all:        vmlinux
  200. +
  201. +vmlinux:    head.o piggy.o
  202. +        $(LD) -Ttext=$(LOADADDR) -o vmlinux head.o piggy.o
  203. +
  204. +head.o:     head.S
  205. +        $(CC) -traditional -DRELADDR=$(RELADDR) -c head.S
  206. +
  207. +piggy.o:    decomphead.o decompress.a compressed.o
  208. +        $(LD) -s -Ttext=$(RELADDR) -o a.out decomphead.o compressed.o decompress.a
  209. +        strip a.out
  210. +        ./piggyback < a.out > piggy.o
  211. +        rm -f a.out
  212. +
  213. +compressed.o:    $(SYSTEM) xtract piggyback
  214. +        ./xtract $(SYSTEM) | gzip -9 | ./piggyback > compressed.o
  215. +
  216. +
  217. +# rules for decompression part of kernel
  218. +
  219. +decompress.a:    $(DECOMP_OBJS)
  220. +        $(AR) $(ARFLAGS) decompress.a $(DECOMP_OBJS)
  221. +
  222. +decomphead.o:    decomphead.S
  223. +        $(CC) -traditional -DLOADADDR=$(LOADADDR) -c decomphead.S
  224. +
  225. +../../lib/ll_char_wr.o:
  226. +        make -C ../../lib ll_char_wr.o
  227. +
  228. +
  229. +# rules for extracting & piggybacking the kernel
  230. +
  231. +xtract:     xtract.c
  232. +        $(HOSTCC) $(CFLAGS) -o xtract xtract.c
  233. +
  234. +piggyback:    piggyback.c
  235. +        $(HOSTCC) $(CFLAGS) -o piggyback piggyback.c
  236. +
  237. +
  238. +clean:
  239. +        rm -f xtract piggyback vmlinux decompress.a a.out
  240. +
  241. diff -urNwbB linux/arch/arm/boot/compressed/crypt.h linux.arm/arch/arm/boot/compressed/crypt.h
  242. --- linux/arch/arm/boot/compressed/crypt.h    Thu Jan  1 01:00:00 1970
  243. +++ linux.arm/arch/arm/boot/compressed/crypt.h    Sun Feb 11 09:32:10 1996
  244. @@ -0,0 +1,12 @@
  245. +/* crypt.h (dummy version) -- do not perform encryption
  246. + * Hardly worth copyrighting :-)
  247. + */
  248. +
  249. +#ifdef CRYPT
  250. +#  undef CRYPT      /* dummy version */
  251. +#endif
  252. +
  253. +#define RAND_HEAD_LEN  12  /* length of encryption random header */
  254. +
  255. +#define zencode
  256. +#define zdecode
  257. diff -urNwbB linux/arch/arm/boot/compressed/decomphead.S linux.arm/arch/arm/boot/compressed/decomphead.S
  258. --- linux/arch/arm/boot/compressed/decomphead.S    Thu Jan  1 01:00:00 1970
  259. +++ linux.arm/arch/arm/boot/compressed/decomphead.S    Sun Feb 11 09:32:10 1996
  260. @@ -0,0 +1,25 @@
  261. +/*
  262. + *  linux/arch/arm/boot/decomphead.S
  263. + */
  264. +
  265. +.text
  266. +    .global    __stext
  267. +__stext:
  268. +    b    start
  269. +LC0:
  270. +    .word    __edata
  271. +    .word    __end
  272. +    .word    LOADADDR + 0x23
  273. +    .word    __stack_start+16384
  274. +start:
  275. +    adr    r1, LC0
  276. +    ldmia    r1, {r2, r3, r4, sp}
  277. +    mov    r1, #0
  278. +clrzlp:    str    r1, [r2], #4
  279. +    cmp    r2, r3
  280. +    blt    clrzlp
  281. +    bic    r0, r4, #3
  282. +    bl    _decompress_kernel
  283. +    mov    r0, #0
  284. +    mov    pc, r4
  285. +
  286. diff -urNwbB linux/arch/arm/boot/compressed/gzip.h linux.arm/arch/arm/boot/compressed/gzip.h
  287. --- linux/arch/arm/boot/compressed/gzip.h    Thu Jan  1 01:00:00 1970
  288. +++ linux.arm/arch/arm/boot/compressed/gzip.h    Sun Feb 11 09:32:10 1996
  289. @@ -0,0 +1,284 @@
  290. +/* gzip.h -- common declarations for all gzip modules
  291. + * Copyright (C) 1992-1993 Jean-loup Gailly.
  292. + * This is free software; you can redistribute it and/or modify it under the
  293. + * terms of the GNU General Public License, see the file COPYING.
  294. + */
  295. +
  296. +#if defined(__STDC__) || defined(PROTO)
  297. +#  define OF(args)  args
  298. +#else
  299. +#  define OF(args)  ()
  300. +#endif
  301. +
  302. +#ifdef __STDC__
  303. +   typedef void *voidp;
  304. +#else
  305. +   typedef char *voidp;
  306. +#endif
  307. +
  308. +/* I don't like nested includes, but the string functions are used too often */
  309. +#if defined(HAVE_STRING_H) || defined(STDC_HEADERS)
  310. +#  include <string.h>
  311. +#  define memzero(s, n)     memset ((s), 0, (n))
  312. +#else
  313. +#  include <strings.h>
  314. +#  define strchr            index 
  315. +#  define strrchr           rindex
  316. +#  define memcpy(d, s, n)   bcopy((s), (d), (n)) 
  317. +#  define memcmp(s1, s2, n) bcmp((s1), (s2), (n)) 
  318. +#  define memzero(s, n)     bzero((s), (n))
  319. +#endif
  320. +
  321. +#if !defined(STDC_HEADERS) && defined(HAVE_MEMORY_H)
  322. +#  include <memory.h>
  323. +#endif
  324. +
  325. +#ifndef RETSIGTYPE
  326. +#  define RETSIGTYPE void
  327. +#endif
  328. +
  329. +#define local static
  330. +
  331. +typedef unsigned char  uch;
  332. +typedef unsigned short ush;
  333. +typedef unsigned long  ulg;
  334. +
  335. +/* Return codes from gzip */
  336. +#define OK      0
  337. +#define ERROR   1
  338. +#define WARNING 2
  339. +
  340. +/* Compression methods (see algorithm.doc) */
  341. +#define STORED     0
  342. +#define COMPRESSED 1
  343. +#define PACKED     2
  344. +/* methods 3 to 7 reserved */
  345. +#define DEFLATED   8
  346. +extern int method;         /* compression method */
  347. +
  348. +/* To save memory for 16 bit systems, some arrays are overlayed between
  349. + * the various modules:
  350. + * deflate:  prev+head   window      d_buf  l_buf  outbuf
  351. + * unlzw:    tab_prefix  tab_suffix  stack  inbuf  outbuf
  352. + * inflate:              window             inbuf
  353. + * unpack:               window             inbuf
  354. + * For compression, input is done in window[]. For decompression, output
  355. + * is done in window except for unlzw.
  356. + */
  357. +
  358. +#ifndef    INBUFSIZ
  359. +#  define INBUFSIZ  0x8000  /* input buffer size */
  360. +#endif
  361. +#define INBUF_EXTRA  64     /* required by unlzw() */
  362. +
  363. +#ifndef    OUTBUFSIZ
  364. +#  define OUTBUFSIZ  16384  /* output buffer size */
  365. +#endif
  366. +#define OUTBUF_EXTRA 2048   /* required by unlzw() */
  367. +
  368. +#define DIST_BUFSIZE 0x8000 /* buffer for distances, see trees.c */
  369. +
  370. +#ifdef DYN_ALLOC
  371. +#  define EXTERN(type, array)  extern type * near array
  372. +#  define DECLARE(type, array, size)  type * near array
  373. +#  define ALLOC(type, array, size) { \
  374. +      array = (type*)fcalloc((unsigned)(((size)+1L)/2), 2*sizeof(type)); \
  375. +      if (array == NULL) error("insufficient memory"); \
  376. +   }
  377. +#  define FREE(array) {if (array != NULL) fcfree(array), array=NULL;}
  378. +#else
  379. +#  define EXTERN(type, array)  extern type array[]
  380. +#  define DECLARE(type, array, size)  type array[size]
  381. +#  define ALLOC(type, array, size)
  382. +#  define FREE(array)
  383. +#endif
  384. +
  385. +EXTERN(uch, inbuf);          /* input buffer */
  386. +EXTERN(uch, outbuf);         /* output buffer */
  387. +EXTERN(ush, d_buf);          /* buffer for distances, see trees.c */
  388. +EXTERN(uch, window);         /* Sliding window and suffix table (unlzw) */
  389. +#define tab_suffix window
  390. +#ifndef MAXSEG_64K
  391. +#  define tab_prefix prev    /* hash link (see deflate.c) */
  392. +#  define head (prev+WSIZE)  /* hash head (see deflate.c) */
  393. +   EXTERN(ush, tab_prefix);  /* prefix code (see unlzw.c) */
  394. +#else
  395. +#  define tab_prefix0 prev
  396. +#  define head tab_prefix1
  397. +   EXTERN(ush, tab_prefix0); /* prefix for even codes */
  398. +   EXTERN(ush, tab_prefix1); /* prefix for odd  codes */
  399. +#endif
  400. +
  401. +extern unsigned insize; /* valid bytes in inbuf */
  402. +extern unsigned inptr;  /* index of next byte to be processed in inbuf */
  403. +extern unsigned outcnt; /* bytes in output buffer */
  404. +
  405. +extern long bytes_in;   /* number of input bytes */
  406. +extern long bytes_out;  /* number of output bytes */
  407. +extern long overhead;   /* number of bytes in gzip header */
  408. +
  409. +#define isize bytes_in
  410. +/* for compatibility with old zip sources (to be cleaned) */
  411. +
  412. +extern int  ifd;        /* input file descriptor */
  413. +extern int  ofd;        /* output file descriptor */
  414. +extern char ifname[];   /* input filename or "stdin" */
  415. +extern char ofname[];   /* output filename or "stdout" */
  416. +
  417. +extern ulg time_stamp;  /* original time stamp (modification time) */
  418. +extern long ifile_size; /* input file size, -1 for devices (debug only) */
  419. +
  420. +extern int exit_code;   /* program exit code */
  421. +
  422. +typedef int file_t;     /* Do not use stdio */
  423. +#define NO_FILE  (-1)   /* in memory compression */
  424. +
  425. +
  426. +#define    GZIP_MAGIC     "\037\213" /* Magic header for gzip files, 1F 8B */
  427. +#define    OLD_GZIP_MAGIC "\037\236" /* Magic header for gzip 0.5 = freeze 1.x */
  428. +#define    PKZIP_MAGIC  "PK\003\004" /* Magic header for pkzip files */
  429. +#define    PACK_MAGIC     "\037\036" /* Magic header for packed files */
  430. +
  431. +/* gzip flag byte */
  432. +#define ASCII_FLAG   0x01 /* bit 0 set: file probably ascii text */
  433. +#define CONTINUATION 0x02 /* bit 1 set: continuation of multi-part gzip file */
  434. +#define EXTRA_FIELD  0x04 /* bit 2 set: extra field present */
  435. +#define ORIG_NAME    0x08 /* bit 3 set: original file name present */
  436. +#define COMMENT      0x10 /* bit 4 set: file comment present */
  437. +#define ENCRYPTED    0x20 /* bit 5 set: file is encrypted */
  438. +#define RESERVED     0xC0 /* bit 6,7:   reserved */
  439. +
  440. +/* internal file attribute */
  441. +#define UNKNOWN (-1)
  442. +#define BINARY  0
  443. +#define ASCII   1
  444. +
  445. +#ifndef WSIZE
  446. +#  define WSIZE 0x8000     /* window size--must be a power of two, and */
  447. +#endif                     /*  at least 32K for zip's deflate method */
  448. +
  449. +#define MIN_MATCH  3
  450. +#define MAX_MATCH  258
  451. +/* The minimum and maximum match lengths */
  452. +
  453. +#define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1)
  454. +/* Minimum amount of lookahead, except at the end of the input file.
  455. + * See deflate.c for comments about the MIN_MATCH+1.
  456. + */
  457. +
  458. +#define MAX_DIST  (WSIZE-MIN_LOOKAHEAD)
  459. +/* In order to simplify the code, particularly on 16 bit machines, match
  460. + * distances are limited to MAX_DIST instead of WSIZE.
  461. + */
  462. +
  463. +extern int decrypt;        /* flag to turn on decryption */
  464. +extern int save_orig_name; /* set if original name must be saved */
  465. +extern int verbose;        /* be verbose (-v) */
  466. +extern int level;          /* compression level */
  467. +extern int test;           /* check .z file integrity */
  468. +extern int to_stdout;      /* output to stdout (-c) */
  469. +
  470. +#define get_byte()  (inptr < insize ? inbuf[inptr++] : fill_inbuf())
  471. +
  472. +/* put_byte is used for the compressed output, put_char for the
  473. + * uncompressed output. However unlzw() uses window for its
  474. + * suffix table instead of its output buffer, so it does not use put_char.
  475. + * (to be cleaned up).
  476. + */
  477. +#define put_byte(c) {outbuf[outcnt++]=(uch)(c); if (outcnt==OUTBUFSIZ)\
  478. +   flush_outbuf();}
  479. +#define put_char(c) {window[outcnt++]=(uch)(c); if (outcnt==WSIZE)\
  480. +   flush_window();}
  481. +
  482. +/* Output a 16 bit value, lsb first */
  483. +#define put_short(w) \
  484. +{ if (outcnt < OUTBUFSIZ-2) { \
  485. +    outbuf[outcnt++] = (uch) ((w) & 0xff); \
  486. +    outbuf[outcnt++] = (uch) ((ush)(w) >> 8); \
  487. +  } else { \
  488. +    put_byte((uch)((w) & 0xff)); \
  489. +    put_byte((uch)((ush)(w) >> 8)); \
  490. +  } \
  491. +}
  492. +
  493. +/* Output a 32 bit value to the bit stream, lsb first */
  494. +#define put_long(n) { \
  495. +    put_short((n) & 0xffff); \
  496. +    put_short(((ulg)(n)) >> 16); \
  497. +}
  498. +
  499. +#define seekable()    0  /* force sequential output */
  500. +#define translate_eol 0  /* no option -a yet */
  501. +
  502. +#define tolow(c)  (isupper(c) ? (c)-'A'+'a' : (c))    /* force to lower case */
  503. +
  504. +/* Macros for getting two-byte and four-byte header values */
  505. +#define SH(p) ((ush)(uch)((p)[0]) | ((ush)(uch)((p)[1]) << 8))
  506. +#define LG(p) ((ulg)(SH(p)) | ((ulg)(SH((p)+2)) << 16))
  507. +
  508. +/* Diagnostic functions */
  509. +#ifdef DEBUG
  510. +#  define Assert(cond,msg) {if(!(cond)) error(msg);}
  511. +#  define Trace(x) fprintf x
  512. +#  define Tracev(x) {if (verbose) fprintf x ;}
  513. +#  define Tracevv(x) {if (verbose>1) fprintf x ;}
  514. +#  define Tracec(c,x) {if (verbose && (c)) fprintf x ;}
  515. +#  define Tracecv(c,x) {if (verbose>1 && (c)) fprintf x ;}
  516. +#else
  517. +#  define Assert(cond,msg)
  518. +#  define Trace(x)
  519. +#  define Tracev(x)
  520. +#  define Tracevv(x)
  521. +#  define Tracec(c,x)
  522. +#  define Tracecv(c,x)
  523. +#endif
  524. +
  525. +    /* in zip.c: */
  526. +extern void zip    OF((int in, int out));
  527. +extern int file_read  OF((char *buf,  unsigned size));
  528. +
  529. +    /* in unzip.c */
  530. +extern void unzip        OF((int in, int out));
  531. +extern int check_zipfile OF((int in));
  532. +
  533. +    /* in unpack.c */
  534. +extern void unpack        OF((int in, int out));
  535. +
  536. +    /* in gzip.c */
  537. +RETSIGTYPE abort_gzip   OF((void));
  538. +
  539. +        /* in deflate.c */
  540. +void lm_init OF((int pack_level, ush *flags));
  541. +ulg  deflate OF((void));
  542. +
  543. +        /* in trees.c */
  544. +void ct_init     OF((ush *attr, int *method));
  545. +int  ct_tally    OF((int dist, int lc));
  546. +ulg  flush_block OF((char *buf, ulg stored_len, int eof));
  547. +
  548. +        /* in bits.c */
  549. +void     bi_init    OF((file_t zipfile));
  550. +void     send_bits  OF((int value, int length));
  551. +unsigned bi_reverse OF((unsigned value, int length));
  552. +void     bi_windup  OF((void));
  553. +void     copy_block OF((char *buf, unsigned len, int header));
  554. +extern   int (*read_buf) OF((char *buf, unsigned size));
  555. +
  556. +    /* in util.c: */
  557. +extern ulg  updcrc        OF((uch *s, unsigned n));
  558. +extern void clear_bufs    OF((void));
  559. +extern int  fill_inbuf    OF((void));
  560. +extern void flush_outbuf  OF((void));
  561. +extern void flush_window  OF((void));
  562. +extern char *strlwr       OF((char *s));
  563. +extern char *basename     OF((char *fname));
  564. +extern char *add_envopt   OF((int *argcp, char ***argvp, char *env));
  565. +extern void error         OF((char *m));
  566. +extern void warn          OF((char *a, char *b));
  567. +extern void read_error    OF((void));
  568. +extern void write_error   OF((void));
  569. +extern void display_ratio OF((long num, long den));
  570. +extern voidp xmalloc      OF((unsigned int size));
  571. +
  572. +    /* in inflate.c */
  573. +extern int inflate OF((void));
  574. diff -urNwbB linux/arch/arm/boot/compressed/head.S linux.arm/arch/arm/boot/compressed/head.S
  575. --- linux/arch/arm/boot/compressed/head.S    Thu Jan  1 01:00:00 1970
  576. +++ linux.arm/arch/arm/boot/compressed/head.S    Sun Feb 11 09:32:10 1996
  577. @@ -0,0 +1,36 @@
  578. +        .text
  579. +        .align
  580. +
  581. +@ Entry point
  582. +@ r0 = kernel info page
  583. +@ r1 = kernel length (length of this code+data)
  584. +
  585. +        .global __stext
  586. +__stext:
  587. +        b    start
  588. +LC0:
  589. +        .word    _input_data
  590. +        .word    _input_end
  591. +        .word    RELADDR
  592. +start:
  593. +        teq    r0, #0
  594. +        beq    newparams
  595. +        mov    r4,     #0x02000000
  596. +        add    r4, r4, #0x0007C000    @ = 0x0207C000 [new param location]
  597. +        mov    r3,     #0x4000
  598. +        sub    r3, r3, #4
  599. +lp2:        ldmia    r0!, {r5, r6, r7, r8, r9, r10, r11, r12}
  600. +        stmia    r4!, {r5, r6, r7, r8, r9, r10, r11, r12}
  601. +        subs    r3, r3, #32
  602. +        bpl    lp2
  603. +newparams:    adr    r3, LC0
  604. +        ldmia    r3, {r2, r3, r4}
  605. +        sub    r3, r3, r2
  606. +        mov    r1, r4
  607. +lp:        ldmia    r2!, {r5, r6, r7, r8, r9, r10, r11, r12}
  608. +        stmia    r4!, {r5, r6, r7, r8, r9, r10, r11, r12}
  609. +        subs    r3, r3, #32
  610. +        bpl    lp
  611. +        ldr    r1, [r1, #0x14]
  612. +        mov    pc, r1
  613. +
  614. diff -urNwbB linux/arch/arm/boot/compressed/inflate.c linux.arm/arch/arm/boot/compressed/inflate.c
  615. --- linux/arch/arm/boot/compressed/inflate.c    Thu Jan  1 01:00:00 1970
  616. +++ linux.arm/arch/arm/boot/compressed/inflate.c    Sat Feb 24 09:36:43 1996
  617. @@ -0,0 +1,810 @@
  618. +#define DEBG(x)
  619. +#define DEBG1(x)
  620. +/* inflate.c -- Not copyrighted 1992 by Mark Adler
  621. +   version c10p1, 10 January 1993 */
  622. +
  623. +/* 
  624. + * Adapted for booting Linux by Hannu Savolainen 1993
  625. + * based on gzip-1.0.3 
  626. + */
  627. +
  628. +#ifndef lint
  629. +static char rcsid[] = "$Id: inflate.c,v 0.10 1993/02/04 13:21:06 jloup Exp $";
  630. +#endif
  631. +
  632. +#include "gzip.h"
  633. +#define slide window
  634. +
  635. +#if defined(STDC_HEADERS) || defined(HAVE_STDLIB_H)
  636. +#  include <sys/types.h>
  637. +#  include <stdlib.h>
  638. +#endif
  639. +
  640. +struct huft {
  641. +  uch e;                /* number of extra bits or operation */
  642. +  uch b;                /* number of bits in this code or subcode */
  643. +  union {
  644. +    ush n;              /* literal, length base, or distance base */
  645. +    struct huft *t;     /* pointer to next level of table */
  646. +  } v;
  647. +};
  648. +
  649. +
  650. +/* Function prototypes */
  651. +int huft_build OF((unsigned *, unsigned, unsigned, ush *, ush *,
  652. +                   struct huft **, int *));
  653. +int huft_free OF((struct huft *));
  654. +int inflate_codes OF((struct huft *, struct huft *, int, int));
  655. +int inflate_stored OF((void));
  656. +int inflate_fixed OF((void));
  657. +int inflate_dynamic OF((void));
  658. +int inflate_block OF((int *));
  659. +int inflate OF((void));
  660. +
  661. +
  662. +#define wp outcnt
  663. +#define flush_output(w) (wp=(w),flush_window())
  664. +
  665. +/* Tables for deflate from PKZIP's appnote.txt. */
  666. +static unsigned border[] = {    /* Order of the bit length code lengths */
  667. +        16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
  668. +static ush cplens[] = {         /* Copy lengths for literal codes 257..285 */
  669. +        3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
  670. +        35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0};
  671. +        /* note: see note #13 above about the 258 in this list. */
  672. +static ush cplext[] = {         /* Extra bits for literal codes 257..285 */
  673. +        0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,
  674. +        3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 99, 99}; /* 99==invalid */
  675. +static ush cpdist[] = {         /* Copy offsets for distance codes 0..29 */
  676. +        1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
  677. +        257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
  678. +        8193, 12289, 16385, 24577};
  679. +static ush cpdext[] = {         /* Extra bits for distance codes */
  680. +        0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6,
  681. +        7, 7, 8, 8, 9, 9, 10, 10, 11, 11,
  682. +        12, 12, 13, 13};
  683. +
  684. +
  685. +ulg bb;                         /* bit buffer */
  686. +unsigned bk;                    /* bits in bit buffer */
  687. +
  688. +ush mask_bits[] = {
  689. +    0x0000,
  690. +    0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff,
  691. +    0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff
  692. +};
  693. +
  694. +#ifdef CRYPT
  695. +  uch cc;
  696. +#  define NEXTBYTE() \
  697. +     (decrypt ? (cc = get_byte(), zdecode(cc), cc) : get_byte())
  698. +#else
  699. +#  define NEXTBYTE()  (uch)get_byte()
  700. +#endif
  701. +#define NEEDBITS(n) {while(k<(n)){b|=((ulg)NEXTBYTE())<<k;k+=8;}}
  702. +#define DUMPBITS(n) {b>>=(n);k-=(n);}
  703. +
  704. +int lbits = 9;          /* bits in base literal/length lookup table */
  705. +int dbits = 6;          /* bits in base distance lookup table */
  706. +
  707. +
  708. +/* If BMAX needs to be larger than 16, then h and x[] should be ulg. */
  709. +#define BMAX 16         /* maximum bit length of any code (16 for explode) */
  710. +#define N_MAX 288       /* maximum number of codes in any set */
  711. +
  712. +
  713. +unsigned hufts;         /* track memory usage */
  714. +
  715. +
  716. +int huft_build(b, n, s, d, e, t, m)
  717. +unsigned *b;            /* code lengths in bits (all assumed <= BMAX) */
  718. +unsigned n;             /* number of codes (assumed <= N_MAX) */
  719. +unsigned s;             /* number of simple-valued codes (0..s-1) */
  720. +ush *d;                 /* list of base values for non-simple codes */
  721. +ush *e;                 /* list of extra bits for non-simple codes */
  722. +struct huft **t;        /* result: starting table */
  723. +int *m;                 /* maximum lookup bits, returns actual */
  724. +/* Given a list of code lengths and a maximum table size, make a set of
  725. +   tables to decode that set of codes.  Return zero on success, one if
  726. +   the given code set is incomplete (the tables are still built in this
  727. +   case), two if the input is invalid (all zero length codes or an
  728. +   oversubscribed set of lengths), and three if not enough memory. */
  729. +{
  730. +  unsigned a;                   /* counter for codes of length k */
  731. +  unsigned c[BMAX+1];           /* bit length count table */
  732. +  unsigned f;                   /* i repeats in table every f entries */
  733. +  int g;                        /* maximum code length */
  734. +  int h;                        /* table level */
  735. +  register unsigned i;          /* counter, current code */
  736. +  register unsigned j;          /* counter */
  737. +  register int k;               /* number of bits in current code */
  738. +  int l;                        /* bits per table (returned in m) */
  739. +  register unsigned *p;         /* pointer into c[], b[], or v[] */
  740. +  register struct huft *q;      /* points to current table */
  741. +  struct huft r;                /* table entry for structure assignment */
  742. +  struct huft *u[BMAX];         /* table stack */
  743. +  unsigned v[N_MAX];            /* values in order of bit length */
  744. +  register int w;               /* bits before this table == (l * h) */
  745. +  unsigned x[BMAX+1];           /* bit offsets, then code stack */
  746. +  unsigned *xp;                 /* pointer into x */
  747. +  int y;                        /* number of dummy codes added */
  748. +  unsigned z;                   /* number of entries in current table */
  749. +
  750. +DEBG("huft1 ");
  751. +
  752. +  /* Generate counts for each bit length */
  753. +  memzero(c, sizeof(c));
  754. +  p = b;  i = n;
  755. +  do {
  756. +    c[*p++]++;                  /* assume all entries <= BMAX */
  757. +  } while (--i);
  758. +  if (c[0] == n)                /* null input--all zero length codes */
  759. +  {
  760. +    *t = (struct huft *)NULL;
  761. +    *m = 0;
  762. +    return 0;
  763. +  }
  764. +
  765. +DEBG("huft2 ");
  766. +
  767. +  /* Find minimum and maximum length, bound *m by those */
  768. +  l = *m;
  769. +  for (j = 1; j <= BMAX; j++)
  770. +    if (c[j])
  771. +      break;
  772. +  k = j;                        /* minimum code length */
  773. +  if ((unsigned)l < j)
  774. +    l = j;
  775. +  for (i = BMAX; i; i--)
  776. +    if (c[i])
  777. +      break;
  778. +  g = i;                        /* maximum code length */
  779. +  if ((unsigned)l > i)
  780. +    l = i;
  781. +  *m = l;
  782. +
  783. +DEBG("huft3 ");
  784. +
  785. +  /* Adjust last length count to fill out codes, if needed */
  786. +  for (y = 1 << j; j < i; j++, y <<= 1)
  787. +    if ((y -= c[j]) < 0)
  788. +      return 2;                 /* bad input: more codes than bits */
  789. +  if ((y -= c[i]) < 0)
  790. +    return 2;
  791. +  c[i] += y;
  792. +
  793. +DEBG("huft4 ");
  794. +
  795. +  /* Generate starting offsets into the value table for each length */
  796. +  x[1] = j = 0;
  797. +  p = c + 1;  xp = x + 2;
  798. +  while (--i) {                 /* note that i == g from above */
  799. +    *xp++ = (j += *p++);
  800. +  }
  801. +
  802. +DEBG("huft5 ");
  803. +
  804. +  /* Make a table of values in order of bit lengths */
  805. +  p = b;  i = 0;
  806. +  do {
  807. +    if ((j = *p++) != 0)
  808. +      v[x[j]++] = i;
  809. +  } while (++i < n);
  810. +
  811. +DEBG("h6 ");
  812. +
  813. +  /* Generate the Huffman codes and for each, make the table entries */
  814. +  x[0] = i = 0;                 /* first Huffman code is zero */
  815. +  p = v;                        /* grab values in bit order */
  816. +  h = -1;                       /* no tables yet--level -1 */
  817. +  w = -l;                       /* bits decoded == (l * h) */
  818. +  u[0] = (struct huft *)NULL;   /* just to keep compilers happy */
  819. +  q = (struct huft *)NULL;      /* ditto */
  820. +  z = 0;                        /* ditto */
  821. +DEBG("h6a ");
  822. +
  823. +  /* go through the bit lengths (k already is bits in shortest code) */
  824. +  for (; k <= g; k++)
  825. +  {
  826. +DEBG("h6b ");
  827. +    a = c[k];
  828. +    while (a--)
  829. +    {
  830. +DEBG("h6b1 ");
  831. +      /* here i is the Huffman code of length k bits for value *p */
  832. +      /* make tables up to required level */
  833. +      while (k > w + l)
  834. +      {
  835. +DEBG1("1 ");
  836. +        h++;
  837. +        w += l;                 /* previous table always l bits */
  838. +
  839. +        /* compute minimum size table less than or equal to l bits */
  840. +        z = (z = g - w) > (unsigned)l ? l : z;  /* upper limit on table size */
  841. +        if ((f = 1 << (j = k - w)) > a + 1)     /* try a k-w bit table */
  842. +        {                       /* too few codes for k-w bit table */
  843. +DEBG1("2 ");
  844. +          f -= a + 1;           /* deduct codes from patterns left */
  845. +          xp = c + k;
  846. +          while (++j < z)       /* try smaller tables up to z bits */
  847. +          {
  848. +            if ((f <<= 1) <= *++xp)
  849. +              break;            /* enough codes to use up j bits */
  850. +            f -= *xp;           /* else deduct codes from patterns */
  851. +          }
  852. +        }
  853. +DEBG1("3 ");
  854. +        z = 1 << j;             /* table entries for j-bit table */
  855. +
  856. +        /* allocate and link in new table */
  857. +        q = (struct huft *)malloc((z + 1)*sizeof(struct huft));
  858. +DEBG1("4 ");
  859. +        hufts += z + 1;         /* track memory usage */
  860. +        *t = q + 1;             /* link to list for huft_free() */
  861. +        *(t = &(q->v.t)) = (struct huft *)NULL;
  862. +        u[h] = ++q;             /* table starts after link */
  863. +
  864. +DEBG1("5 ");
  865. +        /* connect to last table, if there is one */
  866. +        if (h)
  867. +        {
  868. +          x[h] = i;             /* save pattern for backing up */
  869. +          r.b = (uch)l;         /* bits to dump before this table */
  870. +          r.e = (uch)(16 + j);  /* bits in this table */
  871. +          r.v.t = q;            /* pointer to this table */
  872. +          j = i >> (w - l);     /* (get around Turbo C bug) */
  873. +          u[h-1][j] = r;        /* connect to last table */
  874. +        }
  875. +DEBG1("6 ");
  876. +      }
  877. +DEBG("h6c ");
  878. +
  879. +      /* set up table entry in r */
  880. +      r.b = (uch)(k - w);
  881. +      if (p >= v + n)
  882. +        r.e = 99;               /* out of values--invalid code */
  883. +      else if (*p < s)
  884. +      {
  885. +        r.e = (uch)(*p < 256 ? 16 : 15);    /* 256 is end-of-block code */
  886. +        r.v.n = *p++;           /* simple code is just the value */
  887. +      }
  888. +      else
  889. +      {
  890. +        r.e = (uch)e[*p - s];   /* non-simple--look up in lists */
  891. +        r.v.n = d[*p++ - s];
  892. +      }
  893. +DEBG("h6d ");
  894. +
  895. +      /* fill code-like entries with r */
  896. +      f = 1 << (k - w);
  897. +      for (j = i >> w; j < z; j += f)
  898. +        q[j] = r;
  899. +
  900. +      /* backwards increment the k-bit code i */
  901. +      for (j = 1 << (k - 1); i & j; j >>= 1)
  902. +        i ^= j;
  903. +      i ^= j;
  904. +
  905. +      /* backup over finished tables */
  906. +      while ((i & ((1 << w) - 1)) != x[h])
  907. +      {
  908. +        h--;                    /* don't need to update q */
  909. +        w -= l;
  910. +      }
  911. +DEBG("h6e ");
  912. +    }
  913. +DEBG("h6f ");
  914. +  }
  915. +
  916. +DEBG("huft7 ");
  917. +
  918. +  /* Return true (1) if we were given an incomplete table */
  919. +  return y != 0 && g != 1;
  920. +}
  921. +
  922. +
  923. +
  924. +int huft_free(t)
  925. +struct huft *t;         /* table to free */
  926. +/* Free the malloc'ed tables built by huft_build(), which makes a linked
  927. +   list of the tables it made, with the links in a dummy first entry of
  928. +   each table. */
  929. +{
  930. +  register struct huft *p, *q;
  931. +
  932. +
  933. +  /* Go through linked list, freeing from the malloced (t[-1]) address. */
  934. +  p = t;
  935. +  while (p != (struct huft *)NULL)
  936. +  {
  937. +    q = (--p)->v.t;
  938. +    free(p);
  939. +    p = q;
  940. +  } 
  941. +  return 0;
  942. +}
  943. +
  944. +
  945. +int inflate_codes(tl, td, bl, bd)
  946. +struct huft *tl, *td;   /* literal/length and distance decoder tables */
  947. +int bl, bd;             /* number of bits decoded by tl[] and td[] */
  948. +/* inflate (decompress) the codes in a deflated (compressed) block.
  949. +   Return an error code or zero if it all goes ok. */
  950. +{
  951. +  register unsigned e;  /* table entry flag/number of extra bits */
  952. +  unsigned n, d;        /* length and index for copy */
  953. +  unsigned w;           /* current window position */
  954. +  struct huft *t;       /* pointer to table entry */
  955. +  unsigned ml, md;      /* masks for bl and bd bits */
  956. +  register ulg b;       /* bit buffer */
  957. +  register unsigned k;  /* number of bits in bit buffer */
  958. +
  959. +
  960. +  /* make local copies of globals */
  961. +  b = bb;                       /* initialize bit buffer */
  962. +  k = bk;
  963. +  w = wp;                       /* initialize window position */
  964. +
  965. +  /* inflate the coded data */
  966. +  ml = mask_bits[bl];           /* precompute masks for speed */
  967. +  md = mask_bits[bd];
  968. +  for (;;)                      /* do until end of block */
  969. +  {
  970. +    NEEDBITS((unsigned)bl)
  971. +    if ((e = (t = tl + ((unsigned)b & ml))->e) > 16)
  972. +      do {
  973. +        if (e == 99)
  974. +          return 1;
  975. +        DUMPBITS(t->b)
  976. +        e -= 16;
  977. +        NEEDBITS(e)
  978. +      } while ((e = (t = t->v.t + ((unsigned)b & mask_bits[e]))->e) > 16);
  979. +    DUMPBITS(t->b)
  980. +    if (e == 16)                /* then it's a literal */
  981. +    {
  982. +      slide[w++] = (uch)t->v.n;
  983. +      if (w == WSIZE)
  984. +      {
  985. +        flush_output(w);
  986. +        w = 0;
  987. +      }
  988. +    }
  989. +    else                        /* it's an EOB or a length */
  990. +    {
  991. +      /* exit if end of block */
  992. +      if (e == 15)
  993. +        break;
  994. +
  995. +      /* get length of block to copy */
  996. +      NEEDBITS(e)
  997. +      n = t->v.n + ((unsigned)b & mask_bits[e]);
  998. +      DUMPBITS(e);
  999. +
  1000. +      /* decode distance of block to copy */
  1001. +      NEEDBITS((unsigned)bd)
  1002. +      if ((e = (t = td + ((unsigned)b & md))->e) > 16)
  1003. +        do {
  1004. +          if (e == 99)
  1005. +            return 1;
  1006. +          DUMPBITS(t->b)
  1007. +          e -= 16;
  1008. +          NEEDBITS(e)
  1009. +        } while ((e = (t = t->v.t + ((unsigned)b & mask_bits[e]))->e) > 16);
  1010. +      DUMPBITS(t->b)
  1011. +      NEEDBITS(e)
  1012. +      d = w - t->v.n - ((unsigned)b & mask_bits[e]);
  1013. +      DUMPBITS(e)
  1014. +
  1015. +      /* do the copy */
  1016. +      do {
  1017. +        n -= (e = (e = WSIZE - ((d &= WSIZE-1) > w ? d : w)) > n ? n : e);
  1018. +#if !defined(NOMEMCPY) && !defined(DEBUG)
  1019. +        if (w - d >= e)         /* (this test assumes unsigned comparison) */
  1020. +        {
  1021. +          memcpy(slide + w, slide + d, e);
  1022. +          w += e;
  1023. +          d += e;
  1024. +        }
  1025. +        else                      /* do it slow to avoid memcpy() overlap */
  1026. +#endif /* !NOMEMCPY */
  1027. +          do {
  1028. +            slide[w++] = slide[d++];
  1029. +          } while (--e);
  1030. +        if (w == WSIZE)
  1031. +        {
  1032. +          flush_output(w);
  1033. +          w = 0;
  1034. +        }
  1035. +      } while (n);
  1036. +    }
  1037. +  }
  1038. +
  1039. +
  1040. +  /* restore the globals from the locals */
  1041. +  wp = w;                       /* restore global window pointer */
  1042. +  bb = b;                       /* restore global bit buffer */
  1043. +  bk = k;
  1044. +
  1045. +  /* done */
  1046. +  return 0;
  1047. +}
  1048. +
  1049. +
  1050. +
  1051. +int inflate_stored()
  1052. +/* "decompress" an inflated type 0 (stored) block. */
  1053. +{
  1054. +  unsigned n;           /* number of bytes in block */
  1055. +  unsigned w;           /* current window position */
  1056. +  register ulg b;       /* bit buffer */
  1057. +  register unsigned k;  /* number of bits in bit buffer */
  1058. +
  1059. +DEBG("<stor");
  1060. +
  1061. +  /* make local copies of globals */
  1062. +  b = bb;                       /* initialize bit buffer */
  1063. +  k = bk;
  1064. +  w = wp;                       /* initialize window position */
  1065. +
  1066. +
  1067. +  /* go to byte boundary */
  1068. +  n = k & 7;
  1069. +  DUMPBITS(n);
  1070. +
  1071. +
  1072. +  /* get the length and its complement */
  1073. +  NEEDBITS(16)
  1074. +  n = ((unsigned)b & 0xffff);
  1075. +  DUMPBITS(16)
  1076. +  NEEDBITS(16)
  1077. +  if (n != (unsigned)((~b) & 0xffff))
  1078. +    return 1;                   /* error in compressed data */
  1079. +  DUMPBITS(16)
  1080. +
  1081. +
  1082. +  /* read and output the compressed data */
  1083. +  while (n--)
  1084. +  {
  1085. +    NEEDBITS(8)
  1086. +    slide[w++] = (uch)b;
  1087. +    if (w == WSIZE)
  1088. +    {
  1089. +      flush_output(w);
  1090. +      w = 0;
  1091. +    }
  1092. +    DUMPBITS(8)
  1093. +  }
  1094. +
  1095. +
  1096. +  /* restore the globals from the locals */
  1097. +  wp = w;                       /* restore global window pointer */
  1098. +  bb = b;                       /* restore global bit buffer */
  1099. +  bk = k;
  1100. +
  1101. +  DEBG(">");
  1102. +  return 0;
  1103. +}
  1104. +
  1105. +
  1106. +
  1107. +int inflate_fixed()
  1108. +/* decompress an inflated type 1 (fixed Huffman codes) block.  We should
  1109. +   either replace this with a custom decoder, or at least precompute the
  1110. +   Huffman tables. */
  1111. +{
  1112. +  int i;                /* temporary variable */
  1113. +  struct huft *tl;      /* literal/length code table */
  1114. +  struct huft *td;      /* distance code table */
  1115. +  int bl;               /* lookup bits for tl */
  1116. +  int bd;               /* lookup bits for td */
  1117. +  unsigned l[288];      /* length list for huft_build */
  1118. +
  1119. +DEBG("<fix");
  1120. +
  1121. +  /* set up literal table */
  1122. +  for (i = 0; i < 144; i++)
  1123. +    l[i] = 8;
  1124. +  for (; i < 256; i++)
  1125. +    l[i] = 9;
  1126. +  for (; i < 280; i++)
  1127. +    l[i] = 7;
  1128. +  for (; i < 288; i++)          /* make a complete, but wrong code set */
  1129. +    l[i] = 8;
  1130. +  bl = 7;
  1131. +  if ((i = huft_build(l, 288, 257, cplens, cplext, &tl, &bl)) != 0)
  1132. +    return i;
  1133. +
  1134. +
  1135. +  /* set up distance table */
  1136. +  for (i = 0; i < 30; i++)      /* make an incomplete code set */
  1137. +    l[i] = 5;
  1138. +  bd = 5;
  1139. +  if ((i = huft_build(l, 30, 0, cpdist, cpdext, &td, &bd)) > 1)
  1140. +  {
  1141. +    huft_free(tl);
  1142. +
  1143. +    DEBG(">");
  1144. +    return i;
  1145. +  }
  1146. +
  1147. +
  1148. +  /* decompress until an end-of-block code */
  1149. +  if (inflate_codes(tl, td, bl, bd))
  1150. +    return 1;
  1151. +
  1152. +
  1153. +  /* free the decoding tables, return */
  1154. +  huft_free(tl);
  1155. +  huft_free(td);
  1156. +  return 0;
  1157. +}
  1158. +
  1159. +
  1160. +
  1161. +int inflate_dynamic()
  1162. +/* decompress an inflated type 2 (dynamic Huffman codes) block. */
  1163. +{
  1164. +  int i;                /* temporary variables */
  1165. +  unsigned j;
  1166. +  unsigned l;           /* last length */
  1167. +  unsigned m;           /* mask for bit lengths table */
  1168. +  unsigned n;           /* number of lengths to get */
  1169. +  struct huft *tl;      /* literal/length code table */
  1170. +  struct huft *td;      /* distance code table */
  1171. +  int bl;               /* lookup bits for tl */
  1172. +  int bd;               /* lookup bits for td */
  1173. +  unsigned nb;          /* number of bit length codes */
  1174. +  unsigned nl;          /* number of literal/length codes */
  1175. +  unsigned nd;          /* number of distance codes */
  1176. +#ifdef PKZIP_BUG_WORKAROUND
  1177. +  unsigned ll[288+32];  /* literal/length and distance code lengths */
  1178. +#else
  1179. +  unsigned ll[286+30];  /* literal/length and distance code lengths */
  1180. +#endif
  1181. +  register ulg b;       /* bit buffer */
  1182. +  register unsigned k;  /* number of bits in bit buffer */
  1183. +
  1184. +DEBG("<dyn");
  1185. +
  1186. +  /* make local bit buffer */
  1187. +  b = bb;
  1188. +  k = bk;
  1189. +
  1190. +
  1191. +  /* read in table lengths */
  1192. +  NEEDBITS(5)
  1193. +  nl = 257 + ((unsigned)b & 0x1f);      /* number of literal/length codes */
  1194. +  DUMPBITS(5)
  1195. +  NEEDBITS(5)
  1196. +  nd = 1 + ((unsigned)b & 0x1f);        /* number of distance codes */
  1197. +  DUMPBITS(5)
  1198. +  NEEDBITS(4)
  1199. +  nb = 4 + ((unsigned)b & 0xf);         /* number of bit length codes */
  1200. +  DUMPBITS(4)
  1201. +#ifdef PKZIP_BUG_WORKAROUND
  1202. +  if (nl > 288 || nd > 32)
  1203. +#else
  1204. +  if (nl > 286 || nd > 30)
  1205. +#endif
  1206. +    return 1;                   /* bad lengths */
  1207. +
  1208. +DEBG("dyn1 ");
  1209. +
  1210. +  /* read in bit-length-code lengths */
  1211. +  for (j = 0; j < nb; j++)
  1212. +  {
  1213. +    NEEDBITS(3)
  1214. +    ll[border[j]] = (unsigned)b & 7;
  1215. +    DUMPBITS(3)
  1216. +  }
  1217. +  for (; j < 19; j++)
  1218. +    ll[border[j]] = 0;
  1219. +
  1220. +DEBG("dyn2 ");
  1221. +
  1222. +  /* build decoding table for trees--single level, 7 bit lookup */
  1223. +  bl = 7;
  1224. +  if ((i = huft_build(ll, 19, 19, NULL, NULL, &tl, &bl)) != 0)
  1225. +  {
  1226. +    if (i == 1)
  1227. +      huft_free(tl);
  1228. +    return i;                   /* incomplete code set */
  1229. +  }
  1230. +
  1231. +DEBG("dyn3 ");
  1232. +
  1233. +  /* read in literal and distance code lengths */
  1234. +  n = nl + nd;
  1235. +  m = mask_bits[bl];
  1236. +  i = l = 0;
  1237. +  while ((unsigned)i < n)
  1238. +  {
  1239. +    NEEDBITS((unsigned)bl)
  1240. +    j = (td = tl + ((unsigned)b & m))->b;
  1241. +    DUMPBITS(j)
  1242. +    j = td->v.n;
  1243. +    if (j < 16)                 /* length of code in bits (0..15) */
  1244. +      ll[i++] = l = j;          /* save last length in l */
  1245. +    else if (j == 16)           /* repeat last length 3 to 6 times */
  1246. +    {
  1247. +      NEEDBITS(2)
  1248. +      j = 3 + ((unsigned)b & 3);
  1249. +      DUMPBITS(2)
  1250. +      if ((unsigned)i + j > n)
  1251. +        return 1;
  1252. +      while (j--)
  1253. +        ll[i++] = l;
  1254. +    }
  1255. +    else if (j == 17)           /* 3 to 10 zero length codes */
  1256. +    {
  1257. +      NEEDBITS(3)
  1258. +      j = 3 + ((unsigned)b & 7);
  1259. +      DUMPBITS(3)
  1260. +      if ((unsigned)i + j > n)
  1261. +        return 1;
  1262. +      while (j--)
  1263. +        ll[i++] = 0;
  1264. +      l = 0;
  1265. +    }
  1266. +    else                        /* j == 18: 11 to 138 zero length codes */
  1267. +    {
  1268. +      NEEDBITS(7)
  1269. +      j = 11 + ((unsigned)b & 0x7f);
  1270. +      DUMPBITS(7)
  1271. +      if ((unsigned)i + j > n)
  1272. +        return 1;
  1273. +      while (j--)
  1274. +        ll[i++] = 0;
  1275. +      l = 0;
  1276. +    }
  1277. +  }
  1278. +
  1279. +DEBG("dyn4 ");
  1280. +
  1281. +  /* free decoding table for trees */
  1282. +  huft_free(tl);
  1283. +
  1284. +DEBG("dyn5 ");
  1285. +
  1286. +  /* restore the global bit buffer */
  1287. +  bb = b;
  1288. +  bk = k;
  1289. +
  1290. +DEBG("dyn5a ");
  1291. +
  1292. +  /* build the decoding tables for literal/length and distance codes */
  1293. +  bl = lbits;
  1294. +  if ((i = huft_build(ll, nl, 257, cplens, cplext, &tl, &bl)) != 0)
  1295. +  {
  1296. +DEBG("dyn5b ");
  1297. +    if (i == 1) {
  1298. +      error(" incomplete literal tree\n");
  1299. +      huft_free(tl);
  1300. +    }
  1301. +    return i;                   /* incomplete code set */
  1302. +  }
  1303. +DEBG("dyn5c ");
  1304. +  bd = dbits;
  1305. +  if ((i = huft_build(ll + nl, nd, 0, cpdist, cpdext, &td, &bd)) != 0)
  1306. +  {
  1307. +DEBG("dyn5d ");
  1308. +    if (i == 1) {
  1309. +      error(" incomplete distance tree\n");
  1310. +#ifdef PKZIP_BUG_WORKAROUND
  1311. +      i = 0;
  1312. +    }
  1313. +#else
  1314. +      huft_free(td);
  1315. +    }
  1316. +    huft_free(tl);
  1317. +    return i;                   /* incomplete code set */
  1318. +#endif
  1319. +  }
  1320. +
  1321. +DEBG("dyn6 ");
  1322. +
  1323. +  /* decompress until an end-of-block code */
  1324. +  if (inflate_codes(tl, td, bl, bd))
  1325. +    return 1;
  1326. +
  1327. +DEBG("dyn7 ");
  1328. +
  1329. +  /* free the decoding tables, return */
  1330. +  huft_free(tl);
  1331. +  huft_free(td);
  1332. +
  1333. +  DEBG(">");
  1334. +  return 0;
  1335. +}
  1336. +
  1337. +
  1338. +
  1339. +int inflate_block(e)
  1340. +int *e;                 /* last block flag */
  1341. +/* decompress an inflated block */
  1342. +{
  1343. +  unsigned t;           /* block type */
  1344. +  register ulg b;       /* bit buffer */
  1345. +  register unsigned k;  /* number of bits in bit buffer */
  1346. +
  1347. +  DEBG("<blk");
  1348. +
  1349. +  /* make local bit buffer */
  1350. +  b = bb;
  1351. +  k = bk;
  1352. +
  1353. +
  1354. +  /* read in last block bit */
  1355. +  NEEDBITS(1)
  1356. +  *e = (int)b & 1;
  1357. +  DUMPBITS(1)
  1358. +
  1359. +
  1360. +  /* read in block type */
  1361. +  NEEDBITS(2)
  1362. +  t = (unsigned)b & 3;
  1363. +  DUMPBITS(2)
  1364. +
  1365. +
  1366. +  /* restore the global bit buffer */
  1367. +  bb = b;
  1368. +  bk = k;
  1369. +
  1370. +  /* inflate that block type */
  1371. +  if (t == 2)
  1372. +    return inflate_dynamic();
  1373. +  if (t == 0)
  1374. +    return inflate_stored();
  1375. +  if (t == 1)
  1376. +    return inflate_fixed();
  1377. +
  1378. +  DEBG(">");
  1379. +
  1380. +  /* bad block type */
  1381. +  return 2;
  1382. +}
  1383. +
  1384. +
  1385. +
  1386. +int inflate()
  1387. +/* decompress an inflated entry */
  1388. +{
  1389. +  int e;                /* last block flag */
  1390. +  int r;                /* result code */
  1391. +  unsigned h;           /* maximum struct huft's malloc'ed */
  1392. +
  1393. +
  1394. +  /* initialize window, bit buffer */
  1395. +  wp = 0;
  1396. +  bk = 0;
  1397. +  bb = 0;
  1398. +
  1399. +
  1400. +  /* decompress until the last block */
  1401. +  h = 0;
  1402. +  do {
  1403. +    hufts = 0;
  1404. +    if ((r = inflate_block(&e)) != 0)
  1405. +      return r;
  1406. +    if (hufts > h)
  1407. +      h = hufts;
  1408. +  } while (!e);
  1409. +
  1410. +  /* Undo too much lookahead. The next read will be byte aligned so we
  1411. +   * can discard unused bits in the last meaningful byte.
  1412. +   */
  1413. +  while (bk >= 8) {
  1414. +    bk -= 8;
  1415. +    inptr--;
  1416. +  }
  1417. +
  1418. +  /* flush out slide */
  1419. +  flush_output(wp);
  1420. +
  1421. +
  1422. +  /* return success */
  1423. +#ifdef DEBUG
  1424. +  fprintf(stderr, "<%u> ", h);
  1425. +#endif /* DEBUG */
  1426. +  return 0;
  1427. +}
  1428. diff -urNwbB linux/arch/arm/boot/compressed/lzw.h linux.arm/arch/arm/boot/compressed/lzw.h
  1429. --- linux/arch/arm/boot/compressed/lzw.h    Thu Jan  1 01:00:00 1970
  1430. +++ linux.arm/arch/arm/boot/compressed/lzw.h    Sun Feb 11 09:32:11 1996
  1431. @@ -0,0 +1,42 @@
  1432. +/* lzw.h -- define the lzw functions.
  1433. + * Copyright (C) 1992-1993 Jean-loup Gailly.
  1434. + * This is free software; you can redistribute it and/or modify it under the
  1435. + * terms of the GNU General Public License, see the file COPYING.
  1436. + */
  1437. +
  1438. +#if !defined(OF) && defined(lint)
  1439. +#  include "gzip.h"
  1440. +#endif
  1441. +
  1442. +#ifndef BITS
  1443. +#  define BITS 16
  1444. +#endif
  1445. +#define INIT_BITS 9              /* Initial number of bits per code */
  1446. +
  1447. +#define    LZW_MAGIC  "\037\235"   /* Magic header for lzw files, 1F 9D */
  1448. +
  1449. +#define BIT_MASK    0x1f /* Mask for 'number of compression bits' */
  1450. +/* Mask 0x20 is reserved to mean a fourth header byte, and 0x40 is free.
  1451. + * It's a pity that old uncompress does not check bit 0x20. That makes
  1452. + * extension of the format actually undesirable because old compress
  1453. + * would just crash on the new format instead of giving a meaningful
  1454. + * error message. It does check the number of bits, but it's more
  1455. + * helpful to say "unsupported format, get a new version" than
  1456. + * "can only handle 16 bits".
  1457. + */
  1458. +
  1459. +#define BLOCK_MODE  0x80
  1460. +/* Block compression: if table is full and compression rate is dropping,
  1461. + * clear the dictionary.
  1462. + */
  1463. +
  1464. +#define LZW_RESERVED 0x60 /* reserved bits */
  1465. +
  1466. +#define    CLEAR  256       /* flush the dictionary */
  1467. +#define FIRST  (CLEAR+1) /* first free entry */
  1468. +
  1469. +extern int maxbits;      /* max bits per code for LZW */
  1470. +extern int block_mode;   /* block compress mode -C compatible with 2.0 */
  1471. +
  1472. +extern void lzw    OF((int in, int out));
  1473. +extern void unlzw  OF((int in, int out));
  1474. diff -urNwbB linux/arch/arm/boot/compressed/misc.c linux.arm/arch/arm/boot/compressed/misc.c
  1475. --- linux/arch/arm/boot/compressed/misc.c    Thu Jan  1 01:00:00 1970
  1476. +++ linux.arm/arch/arm/boot/compressed/misc.c    Sun Feb 11 09:32:12 1996
  1477. @@ -0,0 +1,534 @@
  1478. +/*
  1479. + * misc.c
  1480. + * 
  1481. + * This is a collection of several routines from gzip-1.0.3 
  1482. + * adapted for Linux.
  1483. + *
  1484. + * malloc by Hannu Savolainen 1993 and Matthias Urlichs 1994
  1485. + * puts by Nick Holloway 1993
  1486. + */
  1487. +
  1488. +#include "gzip.h"
  1489. +#include "lzw.h"
  1490. +
  1491. +/*#include <asm/segment.h>*/
  1492. +
  1493. +/*
  1494. + * These are set up by the setup-routine at boot-time:
  1495. + */
  1496. +
  1497. +struct param_struct
  1498. +{
  1499. +    unsigned long page_size;
  1500. +    unsigned long nr_pages;
  1501. +    unsigned long ramdisk_size;
  1502. +    unsigned long mountrootrdonly;
  1503. +    unsigned long rootdev;
  1504. +    unsigned long video_num_cols;
  1505. +    unsigned long video_num_rows;
  1506. +    unsigned long video_x;
  1507. +    unsigned long video_y;
  1508. +    unsigned long memc_control_reg;
  1509. +    unsigned char sounddefault;
  1510. +    unsigned char adfsdrives;
  1511. +    unsigned char bytes_per_char_h;
  1512. +    unsigned char bytes_per_char_v;
  1513. +    unsigned long unused[256/4-11];
  1514. +    char paths[8][128];
  1515. +    char commandline[256];
  1516. +};
  1517. +
  1518. +static struct param_struct *params=(struct param_struct *)0x0207C000; 
  1519. +
  1520. +#define EOF -1
  1521. +
  1522. +DECLARE(uch, inbuf, INBUFSIZ);
  1523. +DECLARE(uch, outbuf, OUTBUFSIZ+OUTBUF_EXTRA);
  1524. +DECLARE(uch, window, WSIZE);
  1525. +
  1526. +unsigned outcnt;
  1527. +unsigned insize;
  1528. +unsigned inptr;
  1529. +
  1530. +extern char input_data[], input_end[];
  1531. +int input_len;
  1532. +
  1533. +int input_ptr;
  1534. +
  1535. +int method, exit_code, part_nb, last_member;
  1536. +int test = 0;
  1537. +int force = 0;
  1538. +int verbose = 1;
  1539. +long bytes_in, bytes_out;
  1540. +
  1541. +char *output_data;
  1542. +unsigned long output_ptr;
  1543. +
  1544. +extern int end;
  1545. +long free_mem_ptr = (long)&end;
  1546. +
  1547. +int to_stdout = 0;
  1548. +int hard_math = 0;
  1549. +
  1550. +void (*work)(int inf, int outf);
  1551. +void makecrc(void);
  1552. +
  1553. +local int get_method(int);
  1554. +
  1555. +char *vidmem;
  1556. +int video_num_lines, video_num_columns;
  1557. +int bytes_per_char_h;
  1558. +int white;
  1559. +
  1560. +static void puts(const char *);
  1561. +
  1562. +const char cmap_80[][8]=
  1563. +{
  1564. + {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}, /*   */
  1565. + {0x18,0x18,0x18,0x18,0x18,0x00,0x18,0x00}, /* ! */
  1566. + {0x6C,0x6C,0x6C,0x00,0x00,0x00,0x00,0x00}, /* " */
  1567. + {0x36,0x36,0x7F,0x36,0x7F,0x36,0x36,0x00}, /* # */
  1568. + {0x0C,0x3F,0x68,0x3E,0x0B,0x7E,0x18,0x00}, /* $ */
  1569. + {0x60,0x66,0x0C,0x18,0x30,0x66,0x06,0x00}, /* % */
  1570. + {0x38,0x6C,0x6C,0x38,0x6D,0x66,0x3B,0x00}, /* & */
  1571. + {0x18,0x18,0x18,0x00,0x00,0x00,0x00,0x00}, /* ' */
  1572. + {0x0C,0x18,0x30,0x30,0x30,0x18,0x0C,0x00}, /* ( */
  1573. + {0x30,0x18,0x0C,0x0C,0x0C,0x18,0x30,0x00}, /* ) */
  1574. + {0x00,0x18,0x7E,0x3C,0x7E,0x18,0x00,0x00}, /* * */
  1575. + {0x00,0x18,0x18,0x7E,0x18,0x18,0x00,0x00}, /* + */
  1576. + {0x00,0x00,0x00,0x00,0x00,0x18,0x18,0x30}, /* , */
  1577. + {0x00,0x00,0x00,0x7E,0x00,0x00,0x00,0x00}, /* - */
  1578. + {0x00,0x00,0x00,0x00,0x00,0x18,0x18,0x00}, /* . */
  1579. + {0x00,0x06,0x0C,0x18,0x30,0x60,0x00,0x00}, /* / */
  1580. + {0x3C,0x66,0x6E,0x7E,0x76,0x66,0x3C,0x00}, /* 0 */
  1581. + {0x18,0x38,0x18,0x18,0x18,0x18,0x7E,0x00}, /* 1 */
  1582. + {0x3C,0x66,0x06,0x0C,0x18,0x30,0x7E,0x00}, /* 2 */
  1583. + {0x3C,0x66,0x06,0x1C,0x06,0x66,0x3C,0x00}, /* 3 */
  1584. + {0x0C,0x1C,0x3C,0x6C,0x7E,0x0C,0x0C,0x00}, /* 4 */
  1585. + {0x7E,0x60,0x7C,0x06,0x06,0x66,0x3C,0x00}, /* 5 */
  1586. + {0x1C,0x30,0x60,0x7C,0x66,0x66,0x3C,0x00}, /* 6 */
  1587. + {0x7E,0x06,0x0C,0x18,0x30,0x30,0x30,0x00}, /* 7 */
  1588. + {0x3C,0x66,0x66,0x3C,0x66,0x66,0x3C,0x00}, /* 8 */
  1589. + {0x3C,0x66,0x66,0x3E,0x06,0x0C,0x38,0x00}, /* 9 */
  1590. + {0x00,0x00,0x18,0x18,0x00,0x18,0x18,0x00}, /* : */
  1591. + {0x00,0x00,0x18,0x18,0x00,0x18,0x18,0x30}, /* ; */
  1592. + {0x0C,0x18,0x30,0x60,0x30,0x18,0x0C,0x00}, /* < */
  1593. + {0x00,0x00,0x7E,0x00,0x7E,0x00,0x00,0x00}, /* = */
  1594. + {0x30,0x18,0x0C,0x06,0x0C,0x18,0x30,0x00}, /* > */
  1595. + {0x3C,0x66,0x0C,0x18,0x18,0x00,0x18,0x00}, /* ? */
  1596. + {0x3C,0x66,0x6E,0x6A,0x6E,0x60,0x3C,0x00}, /* @ */
  1597. + {0x3C,0x66,0x66,0x7E,0x66,0x66,0x66,0x00}, /* A */
  1598. + {0x7C,0x66,0x66,0x7C,0x66,0x66,0x7C,0x00}, /* B */
  1599. + {0x3C,0x66,0x60,0x60,0x60,0x66,0x3C,0x00}, /* C */
  1600. + {0x78,0x6C,0x66,0x66,0x66,0x6C,0x78,0x00}, /* D */
  1601. + {0x7E,0x60,0x60,0x7C,0x60,0x60,0x7E,0x00}, /* E */
  1602. + {0x7E,0x60,0x60,0x7C,0x60,0x60,0x60,0x00}, /* F */
  1603. + {0x3C,0x66,0x60,0x6E,0x66,0x66,0x3C,0x00}, /* G */
  1604. + {0x66,0x66,0x66,0x7E,0x66,0x66,0x66,0x00}, /* H */
  1605. + {0x7E,0x18,0x18,0x18,0x18,0x18,0x7E,0x00}, /* I */
  1606. + {0x3E,0x0C,0x0C,0x0C,0x0C,0x6C,0x38,0x00}, /* J */
  1607. + {0x66,0x6C,0x78,0x70,0x78,0x6C,0x66,0x00}, /* K */
  1608. + {0x60,0x60,0x60,0x60,0x60,0x60,0x7E,0x00}, /* L */
  1609. + {0x63,0x77,0x7F,0x6B,0x6B,0x63,0x63,0x00}, /* M */
  1610. + {0x66,0x66,0x76,0x7E,0x6E,0x66,0x66,0x00}, /* N */
  1611. + {0x3C,0x66,0x66,0x66,0x66,0x66,0x3C,0x00}, /* O */
  1612. + {0x7C,0x66,0x66,0x7C,0x60,0x60,0x60,0x00}, /* P */
  1613. + {0x3C,0x66,0x66,0x66,0x6A,0x6C,0x36,0x00}, /* Q */
  1614. + {0x7C,0x66,0x66,0x7C,0x6C,0x66,0x66,0x00}, /* R */
  1615. + {0x3C,0x66,0x60,0x3C,0x06,0x66,0x3C,0x00}, /* S */
  1616. + {0x7E,0x18,0x18,0x18,0x18,0x18,0x18,0x00}, /* T */
  1617. + {0x66,0x66,0x66,0x66,0x66,0x66,0x3C,0x00}, /* U */
  1618. + {0x66,0x66,0x66,0x66,0x66,0x3C,0x18,0x00}, /* V */
  1619. + {0x63,0x63,0x6B,0x6B,0x7F,0x77,0x63,0x00}, /* W */
  1620. + {0x66,0x66,0x3C,0x18,0x3C,0x66,0x66,0x00}, /* X */
  1621. + {0x66,0x66,0x66,0x3C,0x18,0x18,0x18,0x00}, /* Y */
  1622. + {0x7E,0x06,0x0C,0x18,0x30,0x60,0x7E,0x00}, /* Z */
  1623. + {0x7C,0x60,0x60,0x60,0x60,0x60,0x7C,0x00}, /* [ */
  1624. + {0x00,0x60,0x30,0x18,0x0C,0x06,0x00,0x00}, /* \ */
  1625. + {0x3E,0x06,0x06,0x06,0x06,0x06,0x3E,0x00}, /* ] */
  1626. + {0x3C,0x66,0x00,0x00,0x00,0x00,0x00,0x00}, /* ^ */
  1627. + {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFF}, /* _ */
  1628. + {0x30,0x18,0x00,0x00,0x00,0x00,0x00,0x00}, /* ` */
  1629. + {0x00,0x00,0x3C,0x06,0x3E,0x66,0x3E,0x00}, /* a */
  1630. + {0x60,0x60,0x7C,0x66,0x66,0x66,0x7C,0x00}, /* b */
  1631. + {0x00,0x00,0x3C,0x66,0x60,0x66,0x3C,0x00}, /* c */
  1632. + {0x06,0x06,0x3E,0x66,0x66,0x66,0x3E,0x00}, /* d */
  1633. + {0x00,0x00,0x3C,0x66,0x7E,0x60,0x3C,0x00}, /* e */
  1634. + {0x1C,0x30,0x30,0x7C,0x30,0x30,0x30,0x00}, /* f */
  1635. + {0x00,0x00,0x3E,0x66,0x66,0x3E,0x06,0x3C}, /* g */
  1636. + {0x60,0x60,0x7C,0x66,0x66,0x66,0x66,0x00}, /* h */
  1637. + {0x18,0x00,0x38,0x18,0x18,0x18,0x3C,0x00}, /* i */
  1638. + {0x18,0x00,0x38,0x18,0x18,0x18,0x18,0x70}, /* j */
  1639. + {0x60,0x60,0x66,0x6C,0x78,0x6C,0x66,0x00}, /* k */
  1640. + {0x38,0x18,0x18,0x18,0x18,0x18,0x3C,0x00}, /* l */
  1641. + {0x00,0x00,0x36,0x7F,0x6B,0x6B,0x63,0x00}, /* m */
  1642. + {0x00,0x00,0x7C,0x66,0x66,0x66,0x66,0x00}, /* n */
  1643. + {0x00,0x00,0x3C,0x66,0x66,0x66,0x3C,0x00}, /* o */
  1644. + {0x00,0x00,0x7C,0x66,0x66,0x7C,0x60,0x60}, /* p */
  1645. + {0x00,0x00,0x3E,0x66,0x66,0x3E,0x06,0x07}, /* q */
  1646. + {0x00,0x00,0x6C,0x76,0x60,0x60,0x60,0x00}, /* r */
  1647. + {0x00,0x00,0x3E,0x60,0x3C,0x06,0x7C,0x00}, /* s */
  1648. + {0x30,0x30,0x7C,0x30,0x30,0x30,0x1C,0x00}, /* t */
  1649. + {0x00,0x00,0x66,0x66,0x66,0x66,0x3E,0x00}, /* u */
  1650. + {0x00,0x00,0x66,0x66,0x66,0x3C,0x18,0x00}, /* v */
  1651. + {0x00,0x00,0x63,0x6B,0x6B,0x7F,0x36,0x00}, /* w */
  1652. + {0x00,0x00,0x66,0x3C,0x18,0x3C,0x66,0x00}, /* x */
  1653. + {0x00,0x00,0x66,0x66,0x66,0x3E,0x06,0x3C}, /* y */
  1654. + {0x00,0x00,0x7E,0x0C,0x18,0x30,0x7E,0x00}, /* z */
  1655. + {0x0C,0x18,0x18,0x70,0x18,0x18,0x0C,0x00}, /* { */
  1656. + {0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x00}, /* | */
  1657. + {0x30,0x18,0x18,0x0E,0x18,0x18,0x30,0x00}, /* } */
  1658. + {0x31,0x6B,0x46,0x00,0x00,0x00,0x00,0x00}, /* ~ */
  1659. + {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF}  /*  */
  1660. +};
  1661. +
  1662. +void *malloc(int size)
  1663. +{
  1664. +    void *p;
  1665. +
  1666. +    if (size <0) error("Malloc error\n");
  1667. +    if (free_mem_ptr <= 0) error("Memory error\n");
  1668. +
  1669. +    while(1) {
  1670. +        free_mem_ptr = (free_mem_ptr + 3) & ~3;    /* Align */
  1671. +
  1672. +        p = (void *)free_mem_ptr;
  1673. +        free_mem_ptr += size;
  1674. +
  1675. +        /*
  1676. +           * The part of the compressed kernel which has already been expanded
  1677. +         * is no longer needed. Therefore we can reuse it for malloc.
  1678. +         * With bigger kernels, this is necessary.
  1679. +         */
  1680. + 
  1681. +        if (free_mem_ptr < (long)&end) {
  1682. +            if (free_mem_ptr > (long)&input_data[input_ptr])
  1683. +                error("\nOut of memory\n");
  1684. +
  1685. +            return p;
  1686. +        }
  1687. +        if (free_mem_ptr < 0x01a00000)
  1688. +            return p;
  1689. +        puts("large kernel, memory tight...");
  1690. +        free_mem_ptr = (long)input_data;
  1691. +    }
  1692. +}
  1693. +
  1694. +void free(void *where)
  1695. +{    /* Don't care */
  1696. +}
  1697. +
  1698. +static void scroll()
  1699. +{
  1700. +#if 0
  1701. +    int i;
  1702. +
  1703. +    memcpy ( vidmem, vidmem + cols * 2, ( lines - 1 ) * cols * 2 );
  1704. +    for ( i = ( lines - 1 ) * cols * 2; i < lines * cols * 2; i += 2 )
  1705. +        vidmem[i] = ' ';
  1706. +#endif
  1707. +}
  1708. +
  1709. +static void puts(const char *s)
  1710. +{
  1711. +    extern void ll_char_write(char *, char, char, char, char);
  1712. +    int x,y;
  1713. +    char c;
  1714. +    char *ptr;
  1715. +
  1716. +    x = params->video_x;
  1717. +    y = params->video_y;
  1718. +
  1719. +    while ( ( c = *s++ ) != '\0' ) {
  1720. +        if ( c == '\n' ) {
  1721. +            x = 0;
  1722. +            if ( ++y >= video_num_lines ) {
  1723. +                scroll();
  1724. +                y--;
  1725. +            }
  1726. +        } else {
  1727. +            ptr = vidmem + (y*video_num_columns*params->bytes_per_char_v+x)*bytes_per_char_h;
  1728. +            ll_char_write(ptr, c, white, 0, 0);
  1729. +            if ( ++x >= video_num_columns ) {
  1730. +                x = 0;
  1731. +                if ( ++y >= video_num_lines ) {
  1732. +                    scroll();
  1733. +                    y--;
  1734. +                }
  1735. +            }
  1736. +        }
  1737. +    }
  1738. +
  1739. +    params->video_x = x;
  1740. +    params->video_y = y;
  1741. +}
  1742. +
  1743. +__ptr_t memset(__ptr_t s, int c, size_t n)
  1744. +{
  1745. +    int i;
  1746. +    char *ss = (char*)s;
  1747. +
  1748. +    for (i=0;i<n;i++) ss[i] = c;
  1749. +}
  1750. +
  1751. +__ptr_t memcpy(__ptr_t __dest, __const __ptr_t __src,
  1752. +                size_t __n)
  1753. +{
  1754. +    int i;
  1755. +    char *d = (char *)__dest, *s = (char *)__src;
  1756. +
  1757. +    for (i=0;i<__n;i++) d[i] = s[i];
  1758. +}
  1759. +
  1760. +extern ulg crc_32_tab[];   /* crc table, defined below */
  1761. +
  1762. +/* ===========================================================================
  1763. + * Run a set of bytes through the crc shift register.  If s is a NULL
  1764. + * pointer, then initialize the crc shift register contents instead.
  1765. + * Return the current crc in either case.
  1766. + */
  1767. +ulg updcrc(s, n)
  1768. +    uch *s;                 /* pointer to bytes to pump through */
  1769. +    unsigned n;             /* number of bytes in s[] */
  1770. +{
  1771. +    register ulg c;         /* temporary variable */
  1772. +
  1773. +    static ulg crc = (ulg)0xffffffffL; /* shift register contents */
  1774. +
  1775. +    if (s == NULL) {
  1776. +    c = 0xffffffffL;
  1777. +    } else {
  1778. +    c = crc;
  1779. +    while (n--) {
  1780. +        c = crc_32_tab[((int)c ^ (*s++)) & 0xff] ^ (c >> 8);
  1781. +    }
  1782. +    }
  1783. +    crc = c;
  1784. +    return c ^ 0xffffffffL;       /* (instead of ~c for 64-bit machines) */
  1785. +}
  1786. +
  1787. +/* ===========================================================================
  1788. + * Clear input and output buffers
  1789. + */
  1790. +void clear_bufs()
  1791. +{
  1792. +    outcnt = 0;
  1793. +    insize = inptr = 0;
  1794. +    bytes_in = bytes_out = 0L;
  1795. +}
  1796. +
  1797. +/* ===========================================================================
  1798. + * Fill the input buffer. This is called only when the buffer is empty
  1799. + * and at least one byte is really needed.
  1800. + */
  1801. +int fill_inbuf()
  1802. +{
  1803. +    int len, i;
  1804. +
  1805. +    /* Read as much as possible */
  1806. +    insize = 0;
  1807. +    do {
  1808. +    len = INBUFSIZ-insize;
  1809. +    if (len > (input_len-input_ptr+1)) len=input_len-input_ptr+1;
  1810. +        if (len == 0 || len == EOF) break;
  1811. +
  1812. +        for (i=0;i<len;i++) inbuf[insize+i] = input_data[input_ptr+i];
  1813. +    insize += len;
  1814. +    input_ptr += len;
  1815. +    } while (insize < INBUFSIZ);
  1816. +
  1817. +    if (insize == 0) {
  1818. +    error("unable to fill buffer\n");
  1819. +    }
  1820. +    bytes_in += (ulg)insize;
  1821. +    inptr = 1;
  1822. +    return inbuf[0];
  1823. +}
  1824. +
  1825. +/* ===========================================================================
  1826. + * Write the output window window[0..outcnt-1] and update crc and bytes_out.
  1827. + * (Used for the decompressed data only.)
  1828. + */
  1829. +void flush_window()
  1830. +{
  1831. +    if (outcnt == 0) return;
  1832. +    updcrc(window, outcnt);
  1833. +
  1834. +    memcpy(&output_data[output_ptr], (char *)window, outcnt);
  1835. +
  1836. +    bytes_out += (ulg)outcnt;
  1837. +    output_ptr += (ulg)outcnt;
  1838. +    outcnt = 0;
  1839. +}
  1840. +
  1841. +/*
  1842. + * Code to compute the CRC-32 table. Borrowed from 
  1843. + * gzip-1.0.3/makecrc.c.
  1844. + */
  1845. +
  1846. +ulg crc_32_tab[256];
  1847. +
  1848. +void
  1849. +makecrc(void)
  1850. +{
  1851. +/* Not copyrighted 1990 Mark Adler    */
  1852. +
  1853. +  unsigned long c;      /* crc shift register */
  1854. +  unsigned long e;      /* polynomial exclusive-or pattern */
  1855. +  int i;                /* counter for all possible eight bit values */
  1856. +  int k;                /* byte being shifted into crc apparatus */
  1857. +
  1858. +  /* terms of polynomial defining this crc (except x^32): */
  1859. +  static int p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26};
  1860. +
  1861. +  /* Make exclusive-or pattern from polynomial */
  1862. +  e = 0;
  1863. +  for (i = 0; i < sizeof(p)/sizeof(int); i++)
  1864. +    e |= 1L << (31 - p[i]);
  1865. +
  1866. +  crc_32_tab[0] = 0;
  1867. +
  1868. +  for (i = 1; i < 256; i++)
  1869. +  {
  1870. +    c = 0;
  1871. +    for (k = i | 256; k != 1; k >>= 1)
  1872. +    {
  1873. +      c = c & 1 ? (c >> 1) ^ e : c >> 1;
  1874. +      if (k & 1)
  1875. +        c ^= e;
  1876. +    }
  1877. +    crc_32_tab[i] = c;
  1878. +  }
  1879. +}
  1880. +
  1881. +void error(char *x)
  1882. +{
  1883. +    puts("\n\n");
  1884. +    puts(x);
  1885. +    puts("\n\n -- System halted");
  1886. +
  1887. +    while(1);    /* Halt */
  1888. +}
  1889. +
  1890. +#define STACK_SIZE (4096)
  1891. +
  1892. +long _stack_start [STACK_SIZE];
  1893. +
  1894. +void decompress_kernel(int output_start)
  1895. +{
  1896. +    input_len = input_end - input_data;
  1897. +    vidmem = (char *)0x02000000;
  1898. +
  1899. +    video_num_lines = params->video_num_rows;
  1900. +    video_num_columns  = params->video_num_cols;
  1901. +    bytes_per_char_h = params->bytes_per_char_h;
  1902. +    white = bytes_per_char_h == 8 ? 0xfc : 7;
  1903. +    
  1904. +    if (params->nr_pages * params->page_size < 2048*1024) error("<2M of mem\n");
  1905. +
  1906. +    output_data = (char *)output_start;    /* Points to kernel start */
  1907. +    output_ptr = 0;
  1908. +
  1909. +    exit_code = 0;
  1910. +    test = 0;
  1911. +    input_ptr = 0;
  1912. +    part_nb = 0;
  1913. +
  1914. +    clear_bufs();
  1915. +    makecrc();
  1916. +
  1917. +    puts("Uncompressing Linux...");
  1918. +
  1919. +    method = get_method(0);
  1920. +
  1921. +    work(0, 0);
  1922. +
  1923. +    puts("done.\n");
  1924. +
  1925. +    puts("Now booting the kernel\n");
  1926. +}
  1927. +
  1928. +/* ========================================================================
  1929. + * Check the magic number of the input file and update ofname if an
  1930. + * original name was given and to_stdout is not set.
  1931. + * Return the compression method, -1 for error, -2 for warning.
  1932. + * Set inptr to the offset of the next byte to be processed.
  1933. + * This function may be called repeatedly for an input file consisting
  1934. + * of several contiguous gzip'ed members.
  1935. + * IN assertions: there is at least one remaining compressed member.
  1936. + *   If the member is a zip file, it must be the only one.
  1937. + */
  1938. +
  1939. +union magic
  1940. +{
  1941. +    char magic[2];
  1942. +    short s_magic;
  1943. +};
  1944. +
  1945. +local int get_method(in)
  1946. +    int in;        /* input file descriptor */
  1947. +{
  1948. +    uch flags;
  1949. +    union magic magic; /* magic header */
  1950. +    union magic gzip_magic = { GZIP_MAGIC };
  1951. +    union magic old_gzip_magic = { OLD_GZIP_MAGIC };
  1952. +
  1953. +    magic.magic[0] = (char)get_byte();
  1954. +    magic.magic[1] = (char)get_byte();
  1955. +
  1956. +    method = -1;                 /* unknown yet */
  1957. +    part_nb++;                   /* number of parts in gzip file */
  1958. +    last_member = 0;
  1959. +    /* assume multiple members in gzip file except for record oriented I/O */
  1960. +
  1961. +    if (magic.s_magic == gzip_magic.s_magic
  1962. +        || magic.s_magic == old_gzip_magic.s_magic) {
  1963. +
  1964. +    work = unzip;
  1965. +    method = (int)get_byte();
  1966. +    flags  = (uch)get_byte();
  1967. +
  1968. +    if ((flags & ENCRYPTED) != 0)
  1969. +        error("Input is encrypted\n");
  1970. +
  1971. +    if ((flags & CONTINUATION) != 0)
  1972. +        error("Multi part input\n");
  1973. +
  1974. +    if ((flags & RESERVED) != 0) {
  1975. +        error("Input has invalid flags\n");
  1976. +        exit_code = ERROR;
  1977. +        if (force <= 1)
  1978. +            return -1;
  1979. +    }
  1980. +
  1981. +    (ulg)get_byte();    /* Get timestamp */
  1982. +    ((ulg)get_byte()) << 8;
  1983. +    ((ulg)get_byte()) << 16;
  1984. +    ((ulg)get_byte()) << 24;
  1985. +
  1986. +    (void)get_byte();  /* Ignore extra flags for the moment */
  1987. +    (void)get_byte();  /* Ignore OS type for the moment */
  1988. +
  1989. +    if ((flags & EXTRA_FIELD) != 0) {
  1990. +        unsigned len = (unsigned)get_byte();
  1991. +        len |= ((unsigned)get_byte())<<8;
  1992. +        while (len--) (void)get_byte();
  1993. +    }
  1994. +
  1995. +    /* Get original file name if it was truncated */
  1996. +    if ((flags & ORIG_NAME) != 0) {
  1997. +        if (to_stdout || part_nb > 1) {
  1998. +            /* Discard the old name */
  1999. +            while (get_byte() != 0) /* null */ ;
  2000. +        } else {
  2001. +        } /* to_stdout */
  2002. +    } /* orig_name */
  2003. +
  2004. +    /* Discard file comment if any */
  2005. +    if ((flags & COMMENT) != 0) {
  2006. +        while (get_byte() != 0) /* null */ ;
  2007. +    }
  2008. +    } else
  2009. +    error("unknown compression method");
  2010. +    return method;
  2011. +}
  2012. diff -urNwbB linux/arch/arm/boot/compressed/piggyback.c linux.arm/arch/arm/boot/compressed/piggyback.c
  2013. --- linux/arch/arm/boot/compressed/piggyback.c    Thu Jan  1 01:00:00 1970
  2014. +++ linux.arm/arch/arm/boot/compressed/piggyback.c    Sun Feb 11 09:32:12 1996
  2015. @@ -0,0 +1,83 @@
  2016. +/*
  2017. + *    linux/zBoot/piggyback.c
  2018. + *
  2019. + *    (C) 1993 Hannu Savolainen
  2020. + */
  2021. +
  2022. +/*
  2023. + *    This program reads the compressed system image from stdin and
  2024. + *    encapsulates it into an object file written to the stdout.
  2025. + */
  2026. +
  2027. +#include <stdio.h>
  2028. +#include <unistd.h>
  2029. +#include <a.out.h>
  2030. +
  2031. +int main(int argc, char *argv[])
  2032. +{
  2033. +    int c, n=0, len=0;
  2034. +    char tmp_buf[512*1024];
  2035. +    
  2036. +    struct exec obj = {0x00670107};    /* object header */
  2037. +    char string_names[] = {"_input_data\0_input_end\0"};
  2038. +
  2039. +    struct nlist var_names[2] = /* Symbol table */
  2040. +        {    
  2041. +            {    /* _input_data    */
  2042. +                (char *)4, 7, 0, 0, 0
  2043. +            },
  2044. +            {    /* _input_len */
  2045. +                (char *)16, 7, 0, 0, 0
  2046. +            }
  2047. +        };
  2048. +
  2049. +
  2050. +    len = 0;
  2051. +    while ((n = read(0, &tmp_buf[len], sizeof(tmp_buf)-len+1)) > 0)
  2052. +          len += n;
  2053. +
  2054. +    len = (len + 3) & ~3;
  2055. +
  2056. +    if (n==-1)
  2057. +    {
  2058. +        perror("stdin");
  2059. +        exit(-1);
  2060. +    }
  2061. +
  2062. +    if (len >= sizeof(tmp_buf))
  2063. +    {
  2064. +        fprintf(stderr, "%s: Input too large\n", argv[0]);
  2065. +        exit(-1);
  2066. +    }
  2067. +
  2068. +    fprintf(stderr, "Compressed size %d.\n", len);
  2069. +
  2070. +/*
  2071. + *    Output object header
  2072. + */
  2073. +    obj.a_data = len /* + sizeof(long) */;
  2074. +    obj.a_syms = sizeof(var_names);
  2075. +    write(1, (char *)&obj, sizeof(obj));
  2076. +
  2077. +/*
  2078. + *    Output data segment (compressed system & len)
  2079. + */
  2080. +    write(1, tmp_buf, len);
  2081. +/*    write(1, (char *)&len, sizeof(len));*/
  2082. +
  2083. +/*
  2084. + *    Output symbol table
  2085. + */
  2086. +    var_names[1].n_value = len;
  2087. +    write(1, (char *)&var_names, sizeof(var_names));
  2088. +
  2089. +/*
  2090. + *    Output string table
  2091. + */
  2092. +    len = sizeof(string_names) + sizeof(len);
  2093. +    write(1, (char *)&len, sizeof(len));
  2094. +    write(1, string_names, sizeof(string_names));
  2095. +
  2096. +    exit(0);
  2097. +
  2098. +}
  2099. diff -urNwbB linux/arch/arm/boot/compressed/unzip.c linux.arm/arch/arm/boot/compressed/unzip.c
  2100. --- linux/arch/arm/boot/compressed/unzip.c    Thu Jan  1 01:00:00 1970
  2101. +++ linux.arm/arch/arm/boot/compressed/unzip.c    Sat Feb 24 09:36:43 1996
  2102. @@ -0,0 +1,180 @@
  2103. +/* unzip.c -- decompress files in gzip or pkzip format.
  2104. + * Copyright (C) 1992-1993 Jean-loup Gailly
  2105. + *
  2106. + * Adapted for Linux booting by Hannu Savolainen 1993
  2107. + *
  2108. + * This is free software; you can redistribute it and/or modify it under the
  2109. + * terms of the GNU General Public License, see the file COPYING.
  2110. + *
  2111. + * The code in this file is derived from the file funzip.c written
  2112. + * and put in the public domain by Mark Adler.
  2113. + */
  2114. +
  2115. +/*
  2116. +   This version can extract files in gzip or pkzip format.
  2117. +   For the latter, only the first entry is extracted, and it has to be
  2118. +   either deflated or stored.
  2119. + */
  2120. +
  2121. +#ifndef lint
  2122. +static char rcsid[] = "$Id: unzip.c,v 0.9 1993/02/10 16:07:22 jloup Exp $";
  2123. +#endif
  2124. +
  2125. +#include "gzip.h"
  2126. +#include "crypt.h"
  2127. +
  2128. +#include <stdio.h>
  2129. +
  2130. +/* PKZIP header definitions */
  2131. +#define LOCSIG 0x04034b50L      /* four-byte lead-in (lsb first) */
  2132. +#define LOCFLG 6                /* offset of bit flag */
  2133. +#define  CRPFLG 1               /*  bit for encrypted entry */
  2134. +#define  EXTFLG 8               /*  bit for extended local header */
  2135. +#define LOCHOW 8                /* offset of compression method */
  2136. +#define LOCTIM 10               /* file mod time (for decryption) */
  2137. +#define LOCCRC 14               /* offset of crc */
  2138. +#define LOCSIZ 18               /* offset of compressed size */
  2139. +#define LOCLEN 22               /* offset of uncompressed length */
  2140. +#define LOCFIL 26               /* offset of file name field length */
  2141. +#define LOCEXT 28               /* offset of extra field length */
  2142. +#define LOCHDR 30               /* size of local header, including sig */
  2143. +#define EXTHDR 16               /* size of extended local header, inc sig */
  2144. +
  2145. +
  2146. +/* Globals */
  2147. +
  2148. +int decrypt;      /* flag to turn on decryption */
  2149. +char *key;        /* not used--needed to link crypt.c */
  2150. +int pkzip = 0;    /* set for a pkzip file */
  2151. +int extended = 0; /* set if extended local header */
  2152. +
  2153. +/* ===========================================================================
  2154. + * Check zip file and advance inptr to the start of the compressed data.
  2155. + * Get ofname from the local header if necessary.
  2156. + */
  2157. +int check_zipfile(in)
  2158. +    int in;   /* input file descriptors */
  2159. +{
  2160. +    uch *h = inbuf + inptr; /* first local header */
  2161. +
  2162. +    /* ifd = in; */
  2163. +
  2164. +    /* Check validity of local header, and skip name and extra fields */
  2165. +    inptr += LOCHDR + SH(h + LOCFIL) + SH(h + LOCEXT);
  2166. +
  2167. +    if (inptr > insize || LG(h) != LOCSIG) {
  2168. +    error("input not a zip");
  2169. +    }
  2170. +    method = h[LOCHOW];
  2171. +    if (method != STORED && method != DEFLATED) {
  2172. +    error("first entry not deflated or stored--can't extract");
  2173. +    }
  2174. +
  2175. +    /* If entry encrypted, decrypt and validate encryption header */
  2176. +    if ((decrypt = h[LOCFLG] & CRPFLG) != 0) {
  2177. +    error("encrypted file\n");
  2178. +    exit_code = ERROR;
  2179. +    return -1;
  2180. +    }
  2181. +
  2182. +    /* Save flags for unzip() */
  2183. +    extended = (h[LOCFLG] & EXTFLG) != 0;
  2184. +    pkzip = 1;
  2185. +
  2186. +    /* Get ofname and time stamp from local header (to be done) */
  2187. +    return 0;
  2188. +}
  2189. +
  2190. +/* ===========================================================================
  2191. + * Unzip in to out.  This routine works on both gzip and pkzip files.
  2192. + *
  2193. + * IN assertions: the buffer inbuf contains already the beginning of
  2194. + *   the compressed data, from offsets inptr to insize-1 included.
  2195. + *   The magic header has already been checked. The output buffer is cleared.
  2196. + */
  2197. +void unzip(in, out)
  2198. +    int in, out;   /* input and output file descriptors */
  2199. +{
  2200. +    ulg orig_crc = 0;       /* original crc */
  2201. +    ulg orig_len = 0;       /* original uncompressed length */
  2202. +    int n;
  2203. +    uch buf[EXTHDR];        /* extended local header */
  2204. +
  2205. +    /* ifd = in;
  2206. +    ofd = out; */
  2207. +
  2208. +    updcrc(NULL, 0);           /* initialize crc */
  2209. +
  2210. +    if (pkzip && !extended) {  /* crc and length at the end otherwise */
  2211. +    orig_crc = LG(inbuf + LOCCRC);
  2212. +    orig_len = LG(inbuf + LOCLEN);
  2213. +    }
  2214. +
  2215. +    /* Decompress */
  2216. +    if (method == DEFLATED)  {
  2217. +
  2218. +    int res = inflate();
  2219. +
  2220. +    if (res == 3) {
  2221. +        error("out of memory");
  2222. +    } else if (res != 0) {
  2223. +        error("invalid compressed format");
  2224. +    }
  2225. +
  2226. +    } else if (pkzip && method == STORED) {
  2227. +
  2228. +    register ulg n = LG(inbuf + LOCLEN);
  2229. +
  2230. +    if (n != LG(inbuf + LOCSIZ) - (decrypt ? RAND_HEAD_LEN : 0)) {
  2231. +
  2232. +        error("length mismatch");
  2233. +    }
  2234. +    while (n--) {
  2235. +        uch c = (uch)get_byte();
  2236. +#ifdef CRYPT
  2237. +        if (decrypt) zdecode(c);
  2238. +#endif
  2239. +        if (!test) put_char(c);
  2240. +    }
  2241. +    } else {
  2242. +    error("internal error, invalid method");
  2243. +    }
  2244. +
  2245. +    /* Get the crc and original length */
  2246. +    if (!pkzip) {
  2247. +        /* crc32  (see algorithm.doc)
  2248. +     * uncompressed input size modulo 2^32
  2249. +         */
  2250. +    for (n = 0; n < 8; n++) {
  2251. +        buf[n] = (uch)get_byte(); /* may cause an error if EOF */
  2252. +    }
  2253. +    orig_crc = LG(buf);
  2254. +    orig_len = LG(buf+4);
  2255. +
  2256. +    } else if (extended) {  /* If extended header, check it */
  2257. +    /* signature - 4bytes: 0x50 0x4b 0x07 0x08
  2258. +     * CRC-32 value
  2259. +         * compressed size 4-bytes
  2260. +         * uncompressed size 4-bytes
  2261. +     */
  2262. +    for (n = 0; n < EXTHDR; n++) {
  2263. +        buf[n] = (uch)get_byte(); /* may cause an error if EOF */
  2264. +    }
  2265. +    orig_crc = LG(buf+4);
  2266. +    orig_len = LG(buf+12);
  2267. +    }
  2268. +
  2269. +    /* Validate decompression */
  2270. +    if (orig_crc != updcrc(outbuf, 0)) {
  2271. +    error("crc error");
  2272. +    }
  2273. +    if (orig_len != bytes_out) {
  2274. +    error("length error");
  2275. +    }
  2276. +
  2277. +    /* Check if there are more entries in a pkzip file */
  2278. +    if (pkzip && inptr + 4 < insize && LG(inbuf+inptr) == LOCSIG) {
  2279. +        error("zip file has more than one entry");
  2280. +    }
  2281. +    extended = pkzip = 0; /* for next file */
  2282. +}
  2283. diff -urNwbB linux/arch/arm/boot/compressed/xtract.c linux.arm/arch/arm/boot/compressed/xtract.c
  2284. --- linux/arch/arm/boot/compressed/xtract.c    Thu Jan  1 01:00:00 1970
  2285. +++ linux.arm/arch/arm/boot/compressed/xtract.c    Sun Feb 11 09:32:12 1996
  2286. @@ -0,0 +1,86 @@
  2287. +/*
  2288. + *  linux/zBoot/xtract.c
  2289. + *
  2290. + *  Copyright (C) 1993  Hannu Savolainen
  2291. + *
  2292. + *    Extracts the system image and writes it to the stdout.
  2293. + *    based on tools/build.c by Linus Torvalds
  2294. + */
  2295. +
  2296. +#include <stdio.h>    /* fprintf */
  2297. +#include <string.h>
  2298. +#include <stdlib.h>    /* contains exit */
  2299. +#include <sys/types.h>    /* unistd.h needs this */
  2300. +#include <sys/stat.h>
  2301. +#include <sys/sysmacros.h>
  2302. +#include <unistd.h>    /* contains read/write */
  2303. +#include <fcntl.h>
  2304. +#include <a.out.h>
  2305. +
  2306. +#define N_MAGIC_OFFSET 1024
  2307. +
  2308. +static int GCC_HEADER = sizeof(struct exec);
  2309. +
  2310. +#define STRINGIFY(x) #x
  2311. +
  2312. +void die(char * str)
  2313. +{
  2314. +    fprintf(stderr,"%s\n",str);
  2315. +    exit(1);
  2316. +}
  2317. +
  2318. +void usage(void)
  2319. +{
  2320. +    die("Usage: xtract system [ | gzip | piggyback > piggy.s]");
  2321. +}
  2322. +
  2323. +int main(int argc, char ** argv)
  2324. +{
  2325. +    int i,c,id, sz;
  2326. +    char buf[1024];
  2327. +    char major_root, minor_root;
  2328. +    struct stat sb;
  2329. +
  2330. +    struct exec *ex = (struct exec *)buf;
  2331. +
  2332. +    if (argc  != 2)
  2333. +        usage();
  2334. +    
  2335. +    if ((id=open(argv[1],O_RDONLY,0))<0)
  2336. +        die("Unable to open 'system'");
  2337. +    if (read(id,buf,GCC_HEADER) != GCC_HEADER)
  2338. +        die("Unable to read header of 'system'");
  2339. +    if (N_MAGIC(*ex) == ZMAGIC) {
  2340. +        GCC_HEADER = N_MAGIC_OFFSET;
  2341. +        lseek(id, GCC_HEADER, SEEK_SET);
  2342. +    } else if (N_MAGIC(*ex) != QMAGIC)
  2343. +        die("Non-GCC header of 'system'");
  2344. +
  2345. +    sz = N_SYMOFF(*ex) - GCC_HEADER + 4;    /* +4 to get the same result than tools/build */
  2346. +
  2347. +    fprintf(stderr, "System size is %d\n", sz);
  2348. +
  2349. +    while (sz)
  2350. +    {
  2351. +        int l, n;
  2352. +
  2353. +        l = sz;
  2354. +        if (l > sizeof(buf)) l = sizeof(buf);
  2355. +
  2356. +        if ((n=read(id, buf, l)) !=l)
  2357. +        {
  2358. +            if (n == -1) 
  2359. +               perror(argv[1]);
  2360. +            else
  2361. +               fprintf(stderr, "Unexpected EOF\n");
  2362. +
  2363. +            die("Can't read system");
  2364. +        }
  2365. +
  2366. +        write(1, buf, l);
  2367. +        sz -= l;
  2368. +    }
  2369. +
  2370. +    close(id);
  2371. +    return(0);
  2372. +}
  2373. diff -urNwbB linux/arch/arm/boot/install.sh linux.arm/arch/arm/boot/install.sh
  2374. --- linux/arch/arm/boot/install.sh    Thu Jan  1 01:00:00 1970
  2375. +++ linux.arm/arch/arm/boot/install.sh    Sun Mar  3 12:16:58 1996
  2376. @@ -0,0 +1,60 @@
  2377. +#!/bin/sh
  2378. +#
  2379. +# arch/i386/boot/install.sh
  2380. +#
  2381. +# This file is subject to the terms and conditions of the GNU General Public
  2382. +# License.  See the file "COPYING" in the main directory of this archive
  2383. +# for more details.
  2384. +#
  2385. +# Copyright (C) 1995 by Linus Torvalds
  2386. +#
  2387. +# Adapted from code in arch/i386/boot/Makefile by H. Peter Anvin
  2388. +#
  2389. +# "make install" script for i386 architecture
  2390. +#
  2391. +# Arguments:
  2392. +#   $1 - kernel version
  2393. +#   $2 - kernel image file
  2394. +#   $3 - kernel map file
  2395. +#   $4 - default install path (blank if root directory)
  2396. +#
  2397. +
  2398. +# User may have a custom install script
  2399. +
  2400. +if [ -x /sbin/installkernel ]; then
  2401. +  exec /sbin/installkernel "$@"
  2402. +fi
  2403. +
  2404. +if [ "$2" = "zImage" ]; then
  2405. +# Compressed install
  2406. +  echo "Installing compressed kernel"
  2407. +  if [ -f $4/vmlinuz-$1 ]; then
  2408. +    mv $4/vmlinuz-$1 $4/vmlinuz.old
  2409. +  fi
  2410. +
  2411. +  if [ -f $4/System.map-$1 ]; then
  2412. +    mv $4/System.map-$1 $4/System.old
  2413. +  fi
  2414. +
  2415. +  cat $2 > $4/vmlinuz-$1
  2416. +  cp $3 $4/System.map-$1
  2417. +else
  2418. +# Normal install
  2419. +  echo "Installing normal kernel"
  2420. +  if [ -f $4/vmlinux-$1 ]; then
  2421. +    mv $4/vmlinux-$1 $4/vmlinux.old
  2422. +  fi
  2423. +
  2424. +  if [ -f $4/System.map ]; then
  2425. +    mv $4/System.map $4/System.old
  2426. +  fi
  2427. +
  2428. +  cat $2 > $4/vmlinux-$1
  2429. +  cp $3 $4/System.map
  2430. +fi
  2431. +
  2432. +if [ -x /sbin/loadmap ]; then
  2433. +  /sbin/loadmap
  2434. +else
  2435. +  echo "You have to install it yourself"
  2436. +fi
  2437. diff -urNwbB linux/arch/arm/boot/tools/build.c linux.arm/arch/arm/boot/tools/build.c
  2438. --- linux/arch/arm/boot/tools/build.c    Thu Jan  1 01:00:00 1970
  2439. +++ linux.arm/arch/arm/boot/tools/build.c    Sun Feb 11 22:01:19 1996
  2440. @@ -0,0 +1,56 @@
  2441. +#include <stdio.h>
  2442. +#include <stdlib.h>
  2443. +#include <a.out.h>
  2444. +#include <string.h>
  2445. +
  2446. +int main(int argc, char **argv)
  2447. +{
  2448. +    void *data;
  2449. +    struct exec ex;
  2450. +    FILE *f;
  2451. +    int totlen;
  2452. +
  2453. +    if (argc < 2) {
  2454. +        fprintf(stderr, "Usage: build kernel-name\n");
  2455. +        exit(1);
  2456. +    }
  2457. +
  2458. +    f = fopen(argv[1], "rb");
  2459. +
  2460. +    fread(&ex, 1, sizeof(ex), f);
  2461. +
  2462. +    if(N_MAGIC(ex) == ZMAGIC) {
  2463. +        fseek(f, 4096, SEEK_SET);
  2464. +        totlen = ex.a_text + ex.a_data + ex.a_bss;
  2465. +    } else
  2466. +    if(N_MAGIC(ex) == QMAGIC) {
  2467. +        unsigned long my_header[8];
  2468. +        
  2469. +        fseek(f, 0x20, SEEK_SET);
  2470. +
  2471. +        memset(my_header, 0, 0x20);
  2472. +
  2473. +        my_header[0] = 0xea000006;
  2474. +        
  2475. +        fwrite(my_header, 4, 8, stdout);
  2476. +        
  2477. +        totlen = ex.a_text + ex.a_data + ex.a_bss - 0x20;
  2478. +    } else {
  2479. +        fprintf(stderr, "Unacceptable a.out header on kernel\n");
  2480. +        fclose(f);
  2481. +        exit(1);
  2482. +    }
  2483. +
  2484. +    fprintf(stderr, "Kernel is %dk (%dk text, %dk data, %dk bss)\n",
  2485. +        (ex.a_text + ex.a_data + ex.a_bss)/1024,
  2486. +         ex.a_text/1024, ex.a_data/1024, ex.a_bss/1024);
  2487. +
  2488. +    data = malloc(totlen);
  2489. +    fread(data, 1, totlen, f);
  2490. +    fwrite(data, 1, totlen, stdout);
  2491. +
  2492. +    free(data);
  2493. +    fclose(f);
  2494. +    fflush(stdout);
  2495. +    return 0;
  2496. +}
  2497. diff -urNwbB linux/arch/arm/config.in linux.arm/arch/arm/config.in
  2498. --- linux/arch/arm/config.in    Thu Jan  1 01:00:00 1970
  2499. +++ linux.arm/arch/arm/config.in    Sat Feb 24 21:32:58 1996
  2500. @@ -0,0 +1,202 @@
  2501. +#
  2502. +# For a description of the syntax of this configuration file,
  2503. +# see the Configure script.
  2504. +#
  2505. +# This is to tell configure not to execute the sound configuration.
  2506. +#
  2507. +CONFIG_ARM=1
  2508. +
  2509. +mainmenu_name "Linux kernel configuration"
  2510. +
  2511. +echo "/* Automatically generated by configure.  Use Make config to change */" >> $CONFIG_H
  2512. +#
  2513. +# These are to alter the behaviour of various Makefiles and init/main.c
  2514. +# in the architecture-independent areas.
  2515. +#
  2516. +echo "#define CONFIG_ARM 1" >> $CONFIG_H
  2517. +echo "CONFIG_ARM=1" >> $CONFIG
  2518. +
  2519. +mainmenu_option next_comment
  2520. +comment 'General setup'
  2521. +bool 'Compile for arm3' CONFIG_ARM3 y
  2522. +if [ "$CONFIG_ARM3" = "n" ]; then
  2523. +  bool 'Compile for arm610/710' CONFIG_ARM610 y
  2524. +  if [ "$CONFIG_ARM610" = "n" ]; then
  2525. +    bool 'Compile for StrongARM' CONFIG_ARMSTRONG y
  2526. +  fi
  2527. +else
  2528. +  bool 'Page size as 32K' CONFIG_PAGE_32K y
  2529. +  if [ "$CONFIG_PAGE_32K" = "n" ]; then
  2530. +    bool 'Page size as 16K' CONFIG_PAGE_16K y
  2531. +    if [ "$CONFIG_PAGE_16K" = "n" ]; then
  2532. +      echo "Auto detected page size"
  2533. +    fi
  2534. +  fi
  2535. +fi
  2536. +
  2537. +comment 'Math emulation is provided by a run-time loadable module'
  2538. +
  2539. +tristate 'Normal floppy disk support' CONFIG_BLK_DEV_FD y
  2540. +bool 'Normal IDE disk/cdrom support' CONFIG_ST506 y
  2541. +if [ "$CONFIG_ST506" = "y" ]; then
  2542. +  comment 'Please see drivers/block/README.ide for help/info on IDE drives'
  2543. +  bool '   Use old disk-only driver for primary i/f' CONFIG_BLK_DEV_HD y
  2544. +#  if [ "$CONFIG_BLK_DEV_HD" = "y" ]; then
  2545. +#    bool '   Include new IDE driver for secondary i/f support' CONFIG_BLK_DEV_IDE n
  2546. +#  else
  2547. +#    bool '   Use new IDE driver for primary/secondary i/f' CONFIG_BLK_DEV_IDE y
  2548. +#  fi
  2549. +#  if [ "$CONFIG_BLK_DEV_IDE" = "y" ]; then
  2550. +#    bool '   Include support for IDE/ATAPI CDROMs' CONFIG_BLK_DEV_IDECD n
  2551. +#  fi
  2552. +fi
  2553. +tristate 'MFM harddisk support' CONFIG_BLK_DEV_XD n
  2554. +
  2555. +bool 'Networking support' CONFIG_NET y
  2556. +bool 'Limit memory to low 16MB' CONFIG_MAX_16M n
  2557. +bool 'System V IPC' CONFIG_SYSVIPC y
  2558. +#tristate 'Kernel support for ELF binaries' CONFIG_BINFMT_ELF n
  2559. +
  2560. +mainmenu_option next_comment
  2561. +comment 'Loadable module support'
  2562. +bool 'Set version information on all symbols for modules' CONFIG_MODVERSIONS y
  2563. +
  2564. +if [ "$CONFIG_NET" = "y" ]; then
  2565. +  mainmenu_option next_comment
  2566. +  comment 'Networking options'
  2567. +  bool 'TCP/IP networking' CONFIG_INET y
  2568. +  if [ "$CONFIG_INET" = "y" ]; then
  2569. +    bool 'IP: forwarding/gatewaying' CONFIG_IP_FORWARD n
  2570. +    bool 'IP: multicasting' CONFIG_IP_MULTICAST n
  2571. +    bool 'IP: firewalling' CONFIG_IP_FIREWALL n
  2572. +    bool 'IP: accounting' CONFIG_IP_ACCT n
  2573. +    tristate 'IP: tunneling' CONFIG_NET_IPIP n
  2574. +    if [ "$CONFIG_IP_FORWARD" = "y" -a "$CONFIG_IP_FIREWALL" = "y" ]; then
  2575. +      bool 'IP: firewall packet logging' CONFIG_IP_FIREWALL_VERBOSE y
  2576. +      bool 'IP: masquerading (ALPHA)' CONFIG_IP_MASQUERADE n
  2577. +    fi
  2578. +    comment '(it is safe to leave these untouched)'
  2579. +    bool 'IP: PC/TCP compatibility mode' CONFIG_INET_PCTCP n
  2580. +    tristate 'IP: Reverse ARP' CONFIG_INET_RARP n
  2581. +    bool 'IP: Assume subnets are local' CONFIG_INET_SNARL y
  2582. +    bool 'IP: Disable NAGLE algorithm (normally enabled)' CONFIG_TCP_NAGLE_OFF n
  2583. +    bool 'IP: Drop source routed frames' CONFIG_IP_NOSR y
  2584. +    bool 'IP: Allow large windows (not recommended if <16MB of memory)' CONFIG_SKB_LARGE n
  2585. +  fi
  2586. +  bool 'The IPX protocol' CONFIG_IPX n
  2587. +  bool 'Appletalk DDP' CONFIG_ATALK n
  2588. +  bool 'Amateur Radio AX.25 Level 2' CONFIG_AX25 n
  2589. +  if [ "$CONFIG_AX25" = "y" ]; then
  2590. +    bool 'Amateur Radio NET/ROM' CONFIG_NETROM n
  2591. +  fi
  2592. +  bool 'Kernel/User network link driver(ALPHA)' CONFIG_NETLINK n
  2593. +  if [ "$CONFIG_NETLINK" = "y" ]; then
  2594. +    bool 'Routing messages' CONFIG_RTNETLINK y
  2595. +  fi
  2596. +fi
  2597. +
  2598. +mainmenu_option next_comment
  2599. +comment 'SCSI support'
  2600. +
  2601. +tristate 'SCSI support?' CONFIG_SCSI n
  2602. +
  2603. +if [ "$CONFIG_SCSI" = "n" ]; then
  2604. +
  2605. +  comment 'Skipping SCSI configuration options...'
  2606. +
  2607. +else
  2608. +
  2609. +  comment 'SCSI support type (disk, tape, CDrom)'
  2610. +
  2611. +  dep_tristate 'SCSI disk support' CONFIG_BLK_DEV_SD y $CONFIG_SCSI
  2612. +  dep_tristate 'SCSI tape support' CONFIG_CHR_DEV_ST y $CONFIG_SCSI
  2613. +  dep_tristate 'SCSI CDROM support' CONFIG_BLK_DEV_SR y $CONFIG_SCSI
  2614. +  dep_tristate 'SCSI generic support' CONFIG_CHR_DEV_SG n $CONFIG_SCSI
  2615. +
  2616. +  comment 'Some SCSI devices (e.g. CD jukebox) support multiple LUNs'
  2617. +
  2618. +  bool 'Probe all LUNs on each SCSI device' CONFIG_SCSI_MULTI_LUN n
  2619. +
  2620. +  mainmenu_option next_comment
  2621. +  comment 'SCSI low-level drivers'
  2622. +
  2623. +  dep_tristate 'Acorn SCSI card (aka30) support' CONFIG_SCSI_ACORNSCSI_3 y $CONFIG_SCSI
  2624. +  dep_tristate 'Cumana 1 support' CONFIG_SCSI_CUMANA_1 n $CONFIG_SCSI
  2625. +  dep_tristate 'EcoScsi support' CONFIG_SCSI_ECOSCSI n $CONFIG_SCSI
  2626. +  dep_tristate 'Oak SCSI support' CONFIG_SCSI_OAK n $CONFIG_SCSI
  2627. +  dep_tristate 'SCSI debugging host adapter' CONFIG_SCSI_DEBUG n $CONFIG_SCSI
  2628. +fi
  2629. +
  2630. +if [ "$CONFIG_NET" = "y" ]; then
  2631. +
  2632. +  mainmenu_option next_comment
  2633. +  comment 'Network device support'
  2634. +
  2635. +  bool 'Network device support?' CONFIG_NETDEVICES y
  2636. +  if [ "$CONFIG_NETDEVICES" = "n" ]; then
  2637. +
  2638. +  comment 'Skipping network driver configuration options...'
  2639. +
  2640. +  else
  2641. +    tristate 'Dummy net driver support' CONFIG_DUMMY y
  2642. +    tristate 'SLIP (serial line) support' CONFIG_SLIP y
  2643. +    if [ "$CONFIG_SLIP" = "y" ]; then
  2644. +      bool ' CSLIP compressed headers' CONFIG_SLIP_COMPRESSED y
  2645. +    fi
  2646. +    tristate 'PPP (point-to-point) support' CONFIG_PPP y
  2647. +    if [ ! "$CONFIG_PPP" = "n" ]; then
  2648. +      comment 'CCP compressors for PPP are only built as modules.'
  2649. +    fi
  2650. +    tristate 'PLIP (parallel port) support' CONFIG_PLIP y
  2651. +    tristate 'EQL (serial line load balancing) support' CONFIG_EQUALIZER n
  2652. +    tristate 'Ether1 (82586) support' CONFIG_ETHER1 n
  2653. +    tristate 'Ether3 (NQ8005) support' CONFIG_ETHER3 n
  2654. +  fi
  2655. +fi
  2656. +
  2657. +mainmenu_option next_comment
  2658. +comment 'Filesystems'
  2659. +
  2660. +tristate 'Standard (minix) fs support' CONFIG_MINIX_FS n
  2661. +tristate 'Extended fs support' CONFIG_EXT_FS n
  2662. +tristate 'Second extended fs support' CONFIG_EXT2_FS y
  2663. +tristate 'xiafs filesystem support' CONFIG_XIA_FS n
  2664. +tristate 'msdos fs support' CONFIG_MSDOS_FS y
  2665. +if [ "$CONFIG_MSDOS_FS" = "y" ]; then
  2666. +  tristate 'umsdos: Unix like fs on top of std MSDOS FAT fs' CONFIG_UMSDOS_FS n
  2667. +fi
  2668. +tristate '/proc filesystem support' CONFIG_PROC_FS y
  2669. +tristate 'ISO9660 cdrom filesystem support' CONFIG_ISO9660_FS y
  2670. +tristate 'OS/2 HPFS filesystem support (read only)' CONFIG_HPFS_FS n
  2671. +tristate 'System V and Coherent filesystem support' CONFIG_SYSV_FS n
  2672. +if [ "$CONFIG_INET" = "y" ]; then
  2673. +  tristate 'NFS filesystem support' CONFIG_NFS_FS y
  2674. +  tristate 'SMB filesystem (to mount WfW shares etc...) support' CONFIG_SMB_FS n
  2675. +fi
  2676. +
  2677. +mainmenu_option next_comment
  2678. +comment 'Character devices'
  2679. +
  2680. +tristate 'Parallel printer support' CONFIG_PRINTER y
  2681. +tristate 'Mouse support' CONFIG_MOUSE y
  2682. +if [ "$CONFIG_MOUSE" = "n" ]; then
  2683. +  comment 'Skipping mouse options...'
  2684. +else
  2685. +  tristate 'Keyboard mouse [all but RiscPC]' CONFIG_KBDMOUSE y
  2686. +fi
  2687. +
  2688. +mainmenu_option next_comment
  2689. +comment 'Sound'
  2690. +
  2691. +tristate 'Sound support' CONFIG_SOUND n
  2692. +
  2693. +mainmenu_option next_comment
  2694. +comment 'Kernel hacking'
  2695. +
  2696. +bool 'Kernel profiling support' CONFIG_PROFILE n
  2697. +if [ "$CONFIG_PROFILE" = "y" ]; then
  2698. +  int ' Profile shift count' CONFIG_PROFILE_SHIFT 2
  2699. +fi
  2700. +if [ "$CONFIG_SCSI" = "y" ]; then
  2701. +bool 'Verbose scsi error reporting (kernel size +=12K)' CONFIG_SCSI_CONSTANTS y
  2702. +fi
  2703. diff -urNwbB linux/arch/arm/drivers/Makefile linux.arm/arch/arm/drivers/Makefile
  2704. --- linux/arch/arm/drivers/Makefile    Thu Jan  1 01:00:00 1970
  2705. +++ linux.arm/arch/arm/drivers/Makefile    Sun Feb 11 09:32:13 1996
  2706. @@ -0,0 +1,33 @@
  2707. +#
  2708. +# Makefile for the linux kernel device drivers.
  2709. +#
  2710. +# Note! Dependencies are done automagically by 'make dep', which also
  2711. +# removes any old dependencies. DON'T put your own dependencies here
  2712. +# unless it's something special (ie not a .c file).
  2713. +#
  2714. +# Note 2! The CFLAGS definitions are now in the main makefile...
  2715. +
  2716. +SUB_DIRS     := block char net #streams
  2717. +MOD_SUB_DIRS := $(SUB_DIRS)
  2718. +ALL_SUB_DIRS := $(SUB_DIRS) scsi sound
  2719. +
  2720. +# If CONFIG_SCSI is set, the core of scsi support will be added to the kernel,
  2721. +# but some of the low-level things may also be modules.
  2722. +ifeq ($(CONFIG_SCSI),y)
  2723. +SUB_DIRS += scsi
  2724. +MOD_SUB_DIRS += scsi
  2725. +else
  2726. +  ifeq ($(CONFIG_SCSI),m)
  2727. +  MOD_SUB_DIRS += scsi
  2728. +  endif
  2729. +endif
  2730. +
  2731. +ifeq ($(CONFIG_SOUND),y)
  2732. +SUB_DIRS += sound
  2733. +else
  2734. +  ifeq ($(CONFIG_SOUND),m)
  2735. +  MOD_SUB_DIRS += sound
  2736. +  endif
  2737. +endif
  2738. +
  2739. +include $(TOPDIR)/Rules.make
  2740. diff -urNwbB linux/arch/arm/drivers/block/Makefile linux.arm/arch/arm/drivers/block/Makefile
  2741. --- linux/arch/arm/drivers/block/Makefile    Thu Jan  1 01:00:00 1970
  2742. +++ linux.arm/arch/arm/drivers/block/Makefile    Sat Feb 24 13:17:05 1996
  2743. @@ -0,0 +1,63 @@
  2744. +#
  2745. +# Makefile for the kernel block device drivers.
  2746. +#
  2747. +# Note! Dependencies are done automagically by 'make dep', which also
  2748. +# removes any old dependencies. DON'T put your own dependencies here
  2749. +# unless it's something special (ie not a .c file).
  2750. +#
  2751. +# Note 2! The CFLAGS definition is now inherited from the
  2752. +# parent makefile.
  2753. +#
  2754. +
  2755. +all: links first_rule
  2756. +
  2757. +L_TARGET := block.a
  2758. +L_OBJS   := ll_rw_blk.o ramdisk.o genhd.o hdsrch.o
  2759. +M_OBJS   :=
  2760. +MOD_LIST_NAME := BLOCK_MODULES
  2761. +
  2762. +ifeq ($(CONFIG_BLK_DEV_FD),y)
  2763. +L_OBJS += floppy.o
  2764. +else
  2765. +  ifeq ($(CONFIG_BLK_DEV_FD),m)
  2766. +  M_OBJS += floppy.o
  2767. +  endif
  2768. +endif
  2769. +
  2770. +ifeq ($(CONFIG_BLK_DEV_HD),y)
  2771. +L_OBJS += hd.o
  2772. +endif
  2773. +
  2774. +ifeq ($(CONFIG_BLK_DEV_IDE),y)
  2775. +L_OBJS += ide.o
  2776. +endif
  2777. +
  2778. +ifeq ($(CONFIG_BLK_DEV_MFM),y)
  2779. +L_OBJS += mfmhd.o
  2780. +else
  2781. +  ifeq ($(CONFIG_BLK_DEV_MFM),m)
  2782. +  M_OBJS += mfmhd_mod.o
  2783. +  endif
  2784. +endif
  2785. +
  2786. +include $(TOPDIR)/Rules.make
  2787. +
  2788. +fastdep: links
  2789. +
  2790. +mfmhd_mod.o: mfmhd.o
  2791. +    ld -r -o $@ mfmhd.o `gcc --print-libgcc-file-name`
  2792. +
  2793. +LK = blk.h ll_rw_blk.c ramdisk.c README.fd README.hd
  2794. +
  2795. +links:
  2796. +    -@for f in $(LK); do \
  2797. +        ln -s ../../../../drivers/block/$$f .; \
  2798. +    done
  2799. +    touch links
  2800. +
  2801. +LINKCLEAN:
  2802. +    -@for f in $(LK); do \
  2803. +        if [ -L $$f ]; then rm -f $$f; fi; \
  2804. +    done
  2805. +    rm -f links
  2806. +
  2807. diff -urNwbB linux/arch/arm/drivers/block/floppy.c linux.arm/arch/arm/drivers/block/floppy.c
  2808. --- linux/arch/arm/drivers/block/floppy.c    Thu Jan  1 01:00:00 1970
  2809. +++ linux.arm/arch/arm/drivers/block/floppy.c    Sun Mar  3 12:20:41 1996
  2810. @@ -0,0 +1,4120 @@
  2811. +/*
  2812. + *  linux/arch/arm/drivers/block/floppy.c
  2813. + *  [ was linux/drivers/block/floppy.c ]
  2814. + *
  2815. + *  Copyright (C) 1991, 1992  Linus Torvalds
  2816. + *  Copyright (C) 1993, 1994  Alain Knaff
  2817. + *  Modifications Copyright (C) 1995 Russell King
  2818. + */
  2819. +/*
  2820. + * 02.12.91 - Changed to static variables to indicate need for reset
  2821. + * and recalibrate. This makes some things easier (output_byte reset
  2822. + * checking etc), and means less interrupt jumping in case of errors,
  2823. + * so the code is hopefully easier to understand.
  2824. + */
  2825. +
  2826. +/*
  2827. + * This file is certainly a mess. I've tried my best to get it working,
  2828. + * but I don't like programming floppies, and I have only one anyway.
  2829. + * Urgel. I should check for more errors, and do more graceful error
  2830. + * recovery. Seems there are problems with several drives. I've tried to
  2831. + * correct them. No promises.
  2832. + */
  2833. +
  2834. +/*
  2835. + * As with hd.c, all routines within this file can (and will) be called
  2836. + * by interrupts, so extreme caution is needed. A hardware interrupt
  2837. + * handler may not sleep, or a kernel panic will happen. Thus I cannot
  2838. + * call "floppy-on" directly, but have to set a special timer interrupt
  2839. + * etc.
  2840. + */
  2841. +
  2842. +/*
  2843. + * 28.02.92 - made track-buffering routines, based on the routines written
  2844. + * by entropy@wintermute.wpi.edu (Lawrence Foard). Linus.
  2845. + */
  2846. +
  2847. +/*
  2848. + * Automatic floppy-detection and formatting written by Werner Almesberger
  2849. + * (almesber@nessie.cs.id.ethz.ch), who also corrected some problems with
  2850. + * the floppy-change signal detection.
  2851. + */
  2852. +
  2853. +/*
  2854. + * 1992/7/22 -- Hennus Bergman: Added better error reporting, fixed
  2855. + * FDC data overrun bug, added some preliminary stuff for vertical
  2856. + * recording support.
  2857. + *
  2858. + * 1992/9/17: Added DMA allocation & DMA functions. -- hhb.
  2859. + *
  2860. + * TODO: Errors are still not counted properly.
  2861. + */
  2862. +
  2863. +/* 1992/9/20
  2864. + * Modifications for ``Sector Shifting'' by Rob Hooft (hooft@chem.ruu.nl)
  2865. + * modelled after the freeware MS/DOS program fdformat/88 V1.8 by
  2866. + * Christoph H. Hochst\"atter.
  2867. + * I have fixed the shift values to the ones I always use. Maybe a new
  2868. + * ioctl() should be created to be able to modify them.
  2869. + * There is a bug in the driver that makes it impossible to format a
  2870. + * floppy as the first thing after bootup.
  2871. + */
  2872. +
  2873. +/*
  2874. + * 1993/4/29 -- Linus -- cleaned up the timer handling in the kernel, and
  2875. + * this helped the floppy driver as well. Much cleaner, and still seems to
  2876. + * work.
  2877. + */
  2878. +
  2879. +/* 1994/6/24 --bbroad-- added the floppy table entries and made
  2880. + * minor modifications to allow 2.88 floppies to be run.
  2881. + */
  2882. +
  2883. +/* 1994/7/13 -- Paul Vojta -- modified the probing code to allow three or more
  2884. + * disk types.
  2885. + */
  2886. +
  2887. +/*
  2888. + * 1994/8/8 -- Alain Knaff -- Switched to fdpatch driver: Support for bigger
  2889. + * format bug fixes, but unfortunately some new bugs too...
  2890. + */
  2891. +
  2892. +/* 1994/9/17 -- Koen Holtman -- added logging of physical floppy write
  2893. + * errors to allow safe writing by specialized programs.
  2894. + */
  2895. +
  2896. +/* 1995/4/24 -- Dan Fandrich -- added support for Commodore 1581 3.5" disks
  2897. + * by defining bit 1 of the "stretch" parameter to mean put sectors on the
  2898. + * opposite side of the disk, leaving the sector IDs alone (i.e. Commodore's
  2899. + * drives are "upside-down").
  2900. + */
  2901. +
  2902. +/*
  2903. + * 1995/8/16 -- Russell King -- altered method for turning floppy drives on
  2904. + * for the arm.
  2905. + */
  2906. +#define CONFIG_FLOPPY_SANITY
  2907. +#undef  CONFIG_FLOPPY_SILENT_DCL_CLEAR
  2908. +
  2909. +#define DEBUGT 2
  2910. +#define DCL_DEBUG /* debug disk change line */
  2911. +
  2912. +#include <linux/config.h>
  2913. +
  2914. +/* do print messages for unexpected interrupts */
  2915. +static int print_unex=1;
  2916. +
  2917. +#ifdef MODULE
  2918. +#define FD_MODULE
  2919. +
  2920. +#include <linux/module.h>
  2921. +/*
  2922. + * NB. we must include the kernel identification string to install the module.
  2923. + */
  2924. +#include <linux/version.h>
  2925. +char kernel_version[] = UTS_RELEASE;
  2926. +
  2927. +int FLOPPY_IRQ=12;
  2928. +int FLOPPY_DMA=2;
  2929. +int ALLOWED_DRIVE_MASK = 0x33;
  2930. +int FDC1 = 0x3f0;
  2931. +int FDC2 = -1;
  2932. +
  2933. +#endif
  2934. +
  2935. +#ifndef FD_MODULE
  2936. +/* the following is the mask of allowed drives. By default units 2 and
  2937. + * 3 of both floppy controllers are disabled, because switching on the
  2938. + * motor of these drives causes system hangs on some PCI computers. drive
  2939. + * 0 is the low bit (0x1), and drive 7 is the high bit (0x80). Bits are on if
  2940. + * a drive is allowed. */
  2941. +static int ALLOWED_DRIVE_MASK=0x33;
  2942. +
  2943. +#define FLOPPY_IRQ 12
  2944. +#define FLOPPY_DMA 2
  2945. +#define FDC1 0x3f0
  2946. +static int FDC2=-1;
  2947. +#endif
  2948. +
  2949. +#define MODULE_AWARE_DRIVER
  2950. +
  2951. +#include <linux/sched.h>
  2952. +#include <linux/fs.h>
  2953. +#include <linux/kernel.h>
  2954. +#include <linux/timer.h>
  2955. +#include <linux/tqueue.h>
  2956. +#define FDPATCHES
  2957. +#include <linux/fdreg.h>
  2958. +
  2959. +/* ============================================ *
  2960. + * old fd.h                                     *
  2961. + * =========================================== */
  2962. +
  2963. +#define OLDFDCLRPRM 0 /* clear user-defined parameters */
  2964. +#define OLDFDSETPRM 1 /* set user-defined parameters for current media */
  2965. +#define OLDFDSETMEDIAPRM 1
  2966. +#define OLDFDDEFPRM 2 /* set user-defined parameters until explicitly cleared */
  2967. +#define OLDFDDEFMEDIAPRM 2
  2968. +#define OLDFDGETPRM 3 /* get disk parameters */
  2969. +#define OLDFDGETMEDIAPRM 3
  2970. +#define OLDFDMSGON  4 /* issue kernel messages on media type change */
  2971. +#define OLDFDMSGOFF 5 /* don't issue kernel messages on media type change */
  2972. +#define OLDFDFMTBEG 6 /* begin formatting a disk */
  2973. +#define OLDFDFMTTRK 7 /* format the specified track */
  2974. +#define OLDFDFMTEND 8 /* end formatting a disk */
  2975. +#define OLDFDSETEMSGTRESH       10      /* set fdc error reporting threshold */
  2976. +#define OLDFDFLUSH  11 /* flush buffers for media; either for verifying media, or for
  2977. +                       handling a media change without closing the file
  2978. +                                              descriptor */
  2979. +#define OLDFDSETMAXERRS 12 /* set abortion and read_track threshold */
  2980. +#define OLDFDGETMAXERRS 14 /* get abortion and read_track threshold */
  2981. +#define OLDFDGETDRVTYP 16          /* get drive type: 5 1/4 or 3 1/2 */
  2982. +
  2983. +#define OLDFDSETDRVPRM 20 /* set drive parameters */
  2984. +#define OLDFDGETDRVPRM 21 /* get drive parameters */
  2985. +#define OLDFDGETDRVSTAT 22 /* get drive state */
  2986. +#define OLDFDPOLLDRVSTAT 23 /* get drive state */
  2987. +#define OLDFDRESET 24 /* reset FDC */
  2988. +
  2989. +#define OLDFD_RESET_IF_NEEDED 0
  2990. +#define OLDFD_RESET_IF_RAWCMD 1
  2991. +#define OLDFD_RESET_ALWAYS 2
  2992. +
  2993. +#define OLDFDGETFDCSTAT 25 /* get fdc state */
  2994. +#define OLDFDWERRORCLR  27 /* clear write error and badness information */
  2995. +#define OLDFDWERRORGET  28 /* get write error and badness information */
  2996. +
  2997. +#define OLDFDRAWCMD 30 /* send a raw command to the fdc */
  2998. +
  2999. +#define OLDFDTWADDLE 40 /* flicker motor-on bit before reading a sector */
  3000. +
  3001. +struct old_floppy_raw_cmd {
  3002. +  void *data;
  3003. +  long length;
  3004. +
  3005. +  unsigned char rate;
  3006. +  unsigned char flags;
  3007. +  unsigned char cmd_count;
  3008. +  unsigned char cmd[9];
  3009. +  unsigned char reply_count;
  3010. +  unsigned char reply[7];
  3011. +  int track;
  3012. +};
  3013. +
  3014. +struct old_floppy_fdc_state {
  3015. +    int spec1; /* spec1 value last used */
  3016. +    int spec2; /* spec2 value last used */
  3017. +    int dtr;
  3018. +    unsigned char version;  /* FDC version code */
  3019. +    unsigned char dor;
  3020. +    int address; /* io address */
  3021. +    unsigned int rawcmd:2;
  3022. +    unsigned int reset:1;
  3023. +    unsigned int need_configure:1;
  3024. +    unsigned int perp_mode:2;
  3025. +    unsigned int has_fifo:1;
  3026. +};
  3027. +
  3028. +
  3029. +#include <linux/fd.h>
  3030. +#include <linux/errno.h>
  3031. +#include <linux/malloc.h>
  3032. +#include <linux/mm.h>
  3033. +#include <linux/string.h>
  3034. +#include <linux/fcntl.h>
  3035. +#include <linux/delay.h>
  3036. +
  3037. +#include <linux/ioport.h>
  3038. +
  3039. +#include <asm/dma.h>
  3040. +#include <asm/irq.h>
  3041. +#include <asm/system.h>
  3042. +#include <asm/io.h>
  3043. +#include <asm/segment.h>
  3044. +
  3045. +#define MAJOR_NR FLOPPY_MAJOR
  3046. +#include "blk.h"
  3047. +
  3048. +
  3049. +/* Dma Memory related stuff */
  3050. +
  3051. +/* Pure 2^n version of get_order */
  3052. +static inline int __get_order (int size)
  3053. +{
  3054. +    int order;
  3055. +
  3056. +    for (order = 0; order < NR_MEM_LISTS; ++order)
  3057. +        if (size <= (PAGE_SIZE << order))
  3058. +            return order;
  3059. +    return NR_MEM_LISTS;
  3060. +}
  3061. +
  3062. +static unsigned long dma_mem_alloc(int size)
  3063. +{
  3064. +    int order = __get_order(size);
  3065. +
  3066. +    if (order >= NR_MEM_LISTS)
  3067. +        return(0);
  3068. +    return __get_dma_pages(GFP_KERNEL,order);
  3069. +}
  3070. +
  3071. +/* End dma memory related stuff */
  3072. +
  3073. +static unsigned int fake_change = 0;
  3074. +static int initialising=1;
  3075. +
  3076. +#define FLOPPY0_TYPE 4
  3077. +#define FLOPPY1_TYPE 0
  3078. +
  3079. +#define N_FDC 2
  3080. +#define N_DRIVE 8
  3081. +
  3082. +static inline int TYPE(kdev_t x) {
  3083. +    return  (MINOR(x)>>2) & 0x1f;
  3084. +}
  3085. +static inline int DRIVE(kdev_t x) {
  3086. +    return (MINOR(x)&0x03) | ((MINOR(x)&0x80)>>5);
  3087. +}
  3088. +#define TOMINOR(x) ((x & 3) | ((x & 4) << 5))
  3089. +#define UNIT(x) ( (x) & 0x03 )        /* drive on fdc */
  3090. +#define FDC(x) ( ((x) & 0x04) >> 2 )  /* fdc of drive */
  3091. +#define REVDRIVE(fdc, unit) ( (unit) + ((fdc) << 2 ))
  3092. +                /* reverse mapping from unit and fdc to drive */
  3093. +#define DP (&drive_params[current_drive])
  3094. +#define DRS (&drive_state[current_drive])
  3095. +#define DRWE (&write_errors[current_drive])
  3096. +#define FDCS (&fdc_state[fdc])
  3097. +#define CLEARF(x) (clear_bit(x##_BIT, &DRS->flags))
  3098. +#define SETF(x) (set_bit(x##_BIT, &DRS->flags))
  3099. +#define TESTF(x) (test_bit(x##_BIT, &DRS->flags))
  3100. +
  3101. +#define UDP (&drive_params[drive])
  3102. +#define UDRS (&drive_state[drive])
  3103. +#define UDRWE (&write_errors[drive])
  3104. +#define UFDCS (&fdc_state[FDC(drive)])
  3105. +#define UCLEARF(x) (clear_bit(x##_BIT, &UDRS->flags))
  3106. +#define USETF(x) (set_bit(x##_BIT, &UDRS->flags))
  3107. +#define UTESTF(x) (test_bit(x##_BIT, &UDRS->flags))
  3108. +
  3109. +#define DPRINT(x) printk(DEVICE_NAME "%d: " x,current_drive)
  3110. +
  3111. +#define DPRINT1(x,x1) printk(DEVICE_NAME "%d: " x,current_drive,(x1))
  3112. +
  3113. +#define DPRINT2(x,x1,x2) printk(DEVICE_NAME "%d: " x,current_drive,(x1),(x2))
  3114. +
  3115. +#define DPRINT3(x,x1,x2,x3) printk(DEVICE_NAME "%d: " x,current_drive,(x1),(x2),(x3))
  3116. +
  3117. +#define PH_HEAD(floppy,head) (((((floppy)->stretch & 2) >>1) ^ head) << 2)
  3118. +#define STRETCH(floppy) ((floppy)->stretch & FD_STRETCH)
  3119. +
  3120. +/* read/write */
  3121. +#define COMMAND raw_cmd->cmd[0]
  3122. +#define DR_SELECT raw_cmd->cmd[1]
  3123. +#define TRACK raw_cmd->cmd[2]
  3124. +#define HEAD raw_cmd->cmd[3]
  3125. +#define SECTOR raw_cmd->cmd[4]
  3126. +#define SIZECODE raw_cmd->cmd[5]
  3127. +#define SECT_PER_TRACK raw_cmd->cmd[6]
  3128. +#define GAP raw_cmd->cmd[7]
  3129. +#define SIZECODE2 raw_cmd->cmd[8]
  3130. +#define NR_RW 9
  3131. +
  3132. +/* format */
  3133. +#define F_SIZECODE raw_cmd->cmd[2]
  3134. +#define F_SECT_PER_TRACK raw_cmd->cmd[3]
  3135. +#define F_GAP raw_cmd->cmd[4]
  3136. +#define F_FILL raw_cmd->cmd[5]
  3137. +#define NR_F 6
  3138. +
  3139. +/*
  3140. + * Maximum disk size (in kilobytes). This default is used whenever the
  3141. + * current disk size is unknown.
  3142. + * [Now it is rather a minimum]
  3143. + */
  3144. +#define MAX_DISK_SIZE 2 /* 3984*/
  3145. +
  3146. +
  3147. +#define K_64    0x10000        /* 64kB */
  3148. +
  3149. +/*
  3150. + * The DMA channel used by the floppy controller cannot access data at
  3151. + * addresses >= 16MB
  3152. + *
  3153. + * Went back to the 1MB limit, as some people had problems with the floppy
  3154. + * driver otherwise. It doesn't matter much for performance anyway, as most
  3155. + * floppy accesses go through the track buffer.
  3156. + */
  3157. +#define CROSS_64KB(a,s) (0)
  3158. +#undef LAST_DMA_ADDR
  3159. +#define LAST_DMA_ADDR    (0x1)
  3160. +
  3161. +/*
  3162. + * globals used by 'result()'
  3163. + */
  3164. +#define MAX_REPLIES 10
  3165. +static unsigned char reply_buffer[MAX_REPLIES];
  3166. +static int inr; /* size of reply buffer, when called from interrupt */
  3167. +#define ST0 (reply_buffer[0])
  3168. +#define ST1 (reply_buffer[1])
  3169. +#define ST2 (reply_buffer[2])
  3170. +#define ST3 (reply_buffer[0]) /* result of GETSTATUS */
  3171. +#define R_TRACK (reply_buffer[3])
  3172. +#define R_HEAD (reply_buffer[4])
  3173. +#define R_SECTOR (reply_buffer[5])
  3174. +#define R_SIZECODE (reply_buffer[6])
  3175. +
  3176. +#define SEL_DLY (2*HZ/100)
  3177. +
  3178. +#define ARRAY_SIZE(x) (sizeof(x) / sizeof( (x)[0] ))
  3179. +/*
  3180. + * this struct defines the different floppy drive types.
  3181. + */
  3182. +static struct {
  3183. +    struct floppy_drive_params params;
  3184. +    const char *name; /* name printed while booting */
  3185. +} default_drive_params[]= {
  3186. +/* NOTE: the time values in jiffies should be in msec!
  3187. + CMOS drive type
  3188. +  |     Maximum data rate supported by drive type
  3189. +  |     |   Head load time, msec
  3190. +  |     |   |   Head unload time, msec (not used)
  3191. +  |     |   |   |     Step rate interval, usec
  3192. +  |     |   |   |     |       Time needed for spinup time (jiffies)
  3193. +  |     |   |   |     |       |      Timeout for spinning down (jiffies)
  3194. +  |     |   |   |     |       |      |   Spindown offset (where disk stops)
  3195. +  |     |   |   |     |       |      |   |     Select delay
  3196. +  |     |   |   |     |       |      |   |     |     RPS
  3197. +  |     |   |   |     |       |      |   |     |     |    Max number of tracks
  3198. +  |     |   |   |     |       |      |   |     |     |    |     Interrupt timeout
  3199. +  |     |   |   |     |       |      |   |     |     |    |     |   Max nonintlv. sectors
  3200. +  |     |   |   |     |       |      |   |     |     |    |     |   | -Max Errors- flags */
  3201. +{{0,  500, 16, 16, 8000,    1*HZ, 3*HZ,  0, SEL_DLY, 5,  80, 3*HZ, 20, {3,1,2,0,2}, 0,
  3202. +      0, { 7, 4, 8, 2, 1, 5, 3,10}, 3*HZ/2, 0 }, "unknown" },
  3203. +
  3204. +{{1,  300, 16, 16, 8000,    1*HZ, 3*HZ,  0, SEL_DLY, 5,  40, 3*HZ, 17, {3,1,2,0,2}, 0,
  3205. +      0, { 1, 0, 0, 0, 0, 0, 0, 0}, 3*HZ/2, 1 }, "360K PC" }, /*5 1/4 360 KB PC*/
  3206. +
  3207. +{{2,  500, 16, 16, 6000, 4*HZ/10, 3*HZ, 14, SEL_DLY, 6,  83, 3*HZ, 17, {3,1,2,0,2}, 0,
  3208. +      0, { 2, 5, 6,23,10,20,11, 0}, 3*HZ/2, 2 }, "1.2M" }, /*5 1/4 HD AT*/
  3209. +
  3210. +{{3,  250, 16, 16, 3000,    1*HZ, 3*HZ,  0, SEL_DLY, 5,  83, 3*HZ, 20, {3,1,2,0,2}, 0,
  3211. +      0, { 4,22,21,30, 3, 0, 0, 0}, 3*HZ/2, 4 }, "720k" }, /*3 1/2 DD*/
  3212. +#if 0
  3213. +{{4,  500, 16, 16, 4000, 4*HZ/10, 3*HZ, 10, SEL_DLY, 5,  83, 3*HZ, 20, {3,1,2,0,2}, 0,
  3214. +      0, { 7, 4,25,22,31,21,29,11}, 3*HZ/2, 7 }, "1.44M" }, /*3 1/2 HD*/
  3215. +#else
  3216. +{{4,  500, 16, 16, 3000, 4*HZ/10, 3*HZ, 10, SEL_DLY, 5,  83, 3*HZ, 20, {3,1,2,0,0}, FTD_MSG,
  3217. +      0, { 7, 4,25,22,31,21,29,11}, 3*HZ/2, 7 }, "1.44M" }, /*3 1/2 HD*/
  3218. +#endif
  3219. +{{5, 1000, 15,  8, 3000, 4*HZ/10, 3*HZ, 10, SEL_DLY, 5,  83, 3*HZ, 40, {3,1,2,0,2}, 0,
  3220. +      0, { 7, 8, 4,25,28,22,31,21}, 3*HZ/2, 8 }, "2.88M AMI BIOS" }, /*3 1/2 ED*/
  3221. +
  3222. +{{6, 1000, 15,  8, 3000, 4*HZ/10, 3*HZ, 10, SEL_DLY, 5,  83, 3*HZ, 40, {3,1,2,0,2}, 0,
  3223. +      0, { 7, 8, 4,25,28,22,31,21}, 3*HZ/2, 8 }, "2.88M" } /*3 1/2 ED*/
  3224. +/*    |  --autodetected formats---   |      |      |
  3225. + *    read_track                     |      |    Name printed when booting
  3226. + *                                   |     Native format
  3227. + *                                 Frequency of disk change checks */
  3228. +};
  3229. +
  3230. +static struct floppy_drive_params drive_params[N_DRIVE];
  3231. +static struct floppy_drive_struct drive_state[N_DRIVE];
  3232. +static struct floppy_write_errors write_errors[N_DRIVE];
  3233. +static struct floppy_raw_cmd *raw_cmd, default_raw_cmd;
  3234. +
  3235. +/*
  3236. + * This struct defines the different floppy types.
  3237. + *
  3238. + * Bit 0 of 'stretch' tells if the tracks need to be doubled for some
  3239. + * types (e.g. 360kB diskette in 1.2MB drive, etc.). Bit 1 of 'stretch'
  3240. + * tells if the disk is in Commodore 1581 format, which means side 0 sectors
  3241. + * are located on side 1 of the disk but with a side 0 ID, and vice-versa.
  3242. + * This is the same as the Sharp MZ-80 5.25" CP/M disk format, except that the
  3243. + * 1581's logical side 0 is on physical side 1, whereas the Sharp's logical
  3244. + * side 0 is on physical side 0 (but with the misnamed sector IDs).
  3245. + * 'stretch' should probably be renamed to something more general, like
  3246. + * 'options'.  Other parameters should be self-explanatory (see also
  3247. + * setfdprm(8)).
  3248. + */
  3249. +/*
  3250. +             Size
  3251. +             |  Sectors per track
  3252. +             |  | Head
  3253. +             |  | |  Tracks
  3254. +             |  | |  | Stretch
  3255. +             |  | |  | |  Gap 1 size
  3256. +             |  | |  | |    |  Data rate, | 0x40 for perp
  3257. +         |  | |  | |    |    |  Spec1 (stepping rate, head unload
  3258. +             |  | |  | |    |    |    |    /fmt gap (gap2) */
  3259. +static struct floppy_struct floppy_type[32] = {
  3260. +    {    0, 0,0, 0,0,0x00,0x00,0x00,0x00,NULL    },    /*  0 no testing    */
  3261. +    {  720, 9,2,40,0,0x2A,0x02,0xDF,0x50,"d360"  }, /*  1 360KB PC      */
  3262. +    { 2400,15,2,80,0,0x1B,0x00,0xDF,0x54,"h1200" },    /*  2 1.2MB AT      */
  3263. +    {  720, 9,1,80,0,0x2A,0x02,0xDF,0x50,"D360"  },    /*  3 360KB SS 3.5" */
  3264. +    { 1440, 9,2,80,0,0x2A,0x02,0xDF,0x50,"D720"  },    /*  4 720KB 3.5"    */
  3265. +    {  720, 9,2,40,1,0x23,0x01,0xDF,0x50,"h360"  },    /*  5 360KB AT      */
  3266. +    { 1440, 9,2,80,0,0x23,0x01,0xDF,0x50,"h720"  },    /*  6 720KB AT      */
  3267. +    { 2880,18,2,80,0,0x1B,0x00,0xCF,0x6C,"H1440" },    /*  7 1.44MB 3.5"   */
  3268. +    { 5760,36,2,80,0,0x1B,0x43,0xAF,0x54,"E2880" },    /*  8 2.88MB 3.5"   */
  3269. +    { 5760,36,2,80,0,0x1B,0x43,0xAF,0x54,"CompaQ"},    /*  9 2.88MB 3.5"   */
  3270. +
  3271. +    { 2880,18,2,80,0,0x25,0x00,0xDF,0x02,"h1440" }, /* 10 1.44MB 5.25"  */
  3272. +    { 3360,21,2,80,0,0x1C,0x00,0xCF,0x0C,"H1680" }, /* 11 1.68MB 3.5"   */
  3273. +    {  820,10,2,41,1,0x25,0x01,0xDF,0x2E,"h410"  },    /* 12 410KB 5.25"   */
  3274. +    { 1640,10,2,82,0,0x25,0x02,0xDF,0x2E,"H820"  },    /* 13 820KB 3.5"    */
  3275. +    { 2952,18,2,82,0,0x25,0x00,0xDF,0x02,"h1476" },    /* 14 1.48MB 5.25"  */
  3276. +    { 3444,21,2,82,0,0x25,0x00,0xDF,0x0C,"H1722" },    /* 15 1.72MB 3.5"   */
  3277. +    {  840,10,2,42,1,0x25,0x01,0xDF,0x2E,"h420"  },    /* 16 420KB 5.25"   */
  3278. +    { 1660,10,2,83,0,0x25,0x02,0xDF,0x2E,"H830"  },    /* 17 830KB 3.5"    */
  3279. +    { 2988,18,2,83,0,0x25,0x00,0xDF,0x02,"h1494" },    /* 18 1.49MB 5.25"  */
  3280. +    { 3486,21,2,83,0,0x25,0x00,0xDF,0x0C,"H1743" }, /* 19 1.74 MB 3.5"  */
  3281. +
  3282. +    { 1760,11,2,80,0,0x1C,0x09,0xCF,0x00,"h880"  }, /* 20 880KB 5.25"   */
  3283. +    { 2080,13,2,80,0,0x1C,0x01,0xCF,0x00,"D1040" }, /* 21 1.04MB 3.5"   */
  3284. +    { 2240,14,2,80,0,0x1C,0x19,0xCF,0x00,"D1120" }, /* 22 1.12MB 3.5"   */
  3285. +    { 3200,20,2,80,0,0x1C,0x20,0xCF,0x2C,"h1600" }, /* 23 1.6MB 5.25"   */
  3286. +    { 3520,22,2,80,0,0x1C,0x08,0xCF,0x2e,"H1760" }, /* 24 1.76MB 3.5"   */
  3287. +    { 3840,24,2,80,0,0x1C,0x20,0xCF,0x00,"H1920" }, /* 25 1.92MB 3.5"   */
  3288. +    { 6400,40,2,80,0,0x25,0x5B,0xCF,0x00,"E3200" }, /* 26 3.20MB 3.5"   */
  3289. +    { 7040,44,2,80,0,0x25,0x5B,0xCF,0x00,"E3520" }, /* 27 3.52MB 3.5"   */
  3290. +    { 7680,48,2,80,0,0x25,0x63,0xCF,0x00,"E3840" }, /* 28 3.84MB 3.5"   */
  3291. +
  3292. +    { 3680,23,2,80,0,0x1C,0x10,0xCF,0x00,"H1840" }, /* 29 1.84MB 3.5"   */
  3293. +    { 1600,10,2,80,0,0x25,0x02,0xDF,0x2E,"D800"  },    /* 30 800KB 3.5"    */
  3294. +    { 3200,20,2,80,0,0x1C,0x00,0xCF,0x2C,"H1600" }, /* 31 1.6MB 3.5"    */
  3295. +};
  3296. +
  3297. +#define    NUMBER(x)    (sizeof(x) / sizeof(*(x)))
  3298. +#define SECTSIZE ( _FD_SECTSIZE(*floppy))
  3299. +
  3300. +/* Auto-detection: Disk type used until the next media change occurs. */
  3301. +struct floppy_struct *current_type[N_DRIVE] = {
  3302. +    NULL, NULL, NULL, NULL,
  3303. +    NULL, NULL, NULL, NULL
  3304. +};
  3305. +
  3306. +/*
  3307. + * User-provided type information. current_type points to
  3308. + * the respective entry of this array.
  3309. + */
  3310. +struct floppy_struct user_params[N_DRIVE];
  3311. +
  3312. +static int floppy_sizes[256];
  3313. +static int floppy_blocksizes[256] = { 0, };
  3314. +
  3315. +/*
  3316. + * The driver is trying to determine the correct media format
  3317. + * while probing is set. rw_interrupt() clears it after a
  3318. + * successful access.
  3319. + */
  3320. +static int probing = 0;
  3321. +
  3322. +/* Synchronization of FDC access. */
  3323. +#define FD_COMMAND_DETECT -2
  3324. +#define FD_COMMAND_NONE -1
  3325. +#define FD_COMMAND_ERROR 2
  3326. +#define FD_COMMAND_OKAY 3
  3327. +
  3328. +static volatile int command_status = FD_COMMAND_NONE, fdc_busy = 0;
  3329. +static struct wait_queue *fdc_wait = NULL, *command_done = NULL;
  3330. +#define NO_SIGNAL (!(current->signal & ~current->blocked) || !interruptible)
  3331. +#define CALL(x) if( (x) == -EINTR) return -EINTR
  3332. +#define ECALL(x) if ((ret = (x))) return ret;
  3333. +#define _WAIT(x,i) CALL(ret=wait_til_done((x),i))
  3334. +#define WAIT(x) _WAIT((x),interruptible)
  3335. +#define IWAIT(x) _WAIT((x),1)
  3336. +
  3337. +/* Errors during formatting are counted here. */
  3338. +static int format_errors;
  3339. +
  3340. +/* Format request descriptor. */
  3341. +static struct format_descr format_req;
  3342. +
  3343. +/*
  3344. + * Rate is 0 for 500kb/s, 1 for 300kbps, 2 for 250kbps
  3345. + * Spec1 is 0xSH, where S is stepping rate (F=1ms, E=2ms, D=3ms etc),
  3346. + * H is head unload time (1=16ms, 2=32ms, etc)
  3347. + */
  3348. +
  3349. +/*
  3350. + * Track buffer
  3351. + * Because these are written to by the DMA controller, they must
  3352. + * not contain a 64k byte boundary crossing, or data will be
  3353. + * corrupted/lost. Alignment of these is enforced in boot/head.S.
  3354. + * Note that you must not change the sizes below without updating head.S.
  3355. + */
  3356. +char *floppy_track_buffer=NULL;
  3357. +int max_buffer_sectors=0;
  3358. +
  3359. +int *errors;
  3360. +typedef void (*done_f)(int);
  3361. +struct cont_t {
  3362. +    void (*interrupt)(void); /* this is called after the interrupt of the
  3363. +                  * main command */
  3364. +    void (*redo)(void); /* this is called to retry the operation */
  3365. +    void (*error)(void); /* this is called to tally an error */
  3366. +    done_f done; /* this is called to say if the operation has
  3367. +              * succeeded/failed */
  3368. +} *cont=NULL;
  3369. +
  3370. +static void floppy_ready(void);
  3371. +static void floppy_start(void);
  3372. +static void process_fd_request(void);
  3373. +static void recalibrate_floppy(void);
  3374. +static void floppy_shutdown(void);
  3375. +
  3376. +static int floppy_grab_irq_and_dma(void);
  3377. +static void floppy_release_irq_and_dma(void);
  3378. +
  3379. +/*
  3380. + * The "reset" variable should be tested whenever an interrupt is scheduled,
  3381. + * after the commands have been sent. This is to ensure that the driver doesn't
  3382. + * get wedged when the interrupt doesn't come because of a failed command.
  3383. + * reset doesn't need to be tested before sending commands, because
  3384. + * output_byte is automatically disabled when reset is set.
  3385. + */
  3386. +#define CHECK_RESET { if ( FDCS->reset ){ reset_fdc(); return ; } }
  3387. +static void reset_fdc(void);
  3388. +
  3389. +/*
  3390. + * These are global variables, as that's the easiest way to give
  3391. + * information to interrupts. They are the data used for the current
  3392. + * request.
  3393. + */
  3394. +#define NO_TRACK -1
  3395. +#define NEED_1_RECAL -2
  3396. +#define NEED_2_RECAL -3
  3397. +
  3398. +/* */
  3399. +static int usage_count = 0;
  3400. +
  3401. +
  3402. +/* buffer related variables */
  3403. +static int buffer_track = -1;
  3404. +static int buffer_drive = -1;
  3405. +static int buffer_min = -1;
  3406. +static int buffer_max = -1;
  3407. +
  3408. +/* fdc related variables, should end up in a struct */
  3409. +static struct floppy_fdc_state fdc_state[N_FDC];
  3410. +static int fdc; /* current fdc */
  3411. +
  3412. +static struct floppy_struct * floppy = floppy_type;
  3413. +static unsigned char current_drive = 0;
  3414. +static long current_count_sectors = 0;
  3415. +static unsigned char sector_t; /* sector in track */
  3416. +
  3417. +#ifdef DEBUGT
  3418. +long unsigned debugtimer;
  3419. +#endif
  3420. +
  3421. +/*
  3422. + * Floppy_selects1 is the list of DOR's to select a drive n
  3423. + * Floppy_selects2 is the list of DOR's to select drive fd
  3424. + * On initialisation, the floppy list is scanned, and the drives allocated
  3425. + * in the order that they are found.  This is done by seeking the drive
  3426. + * to a non-zero track, and then restoring it to track 0.  If an error occurs,
  3427. + * then there is no floppy drive present.
  3428. + */
  3429. +/*extern*/ int no_floppies;
  3430. +unsigned char floppy_selects1[]={ 0x10, 0x21, 0x23, 0x33 };
  3431. +unsigned char floppy_selects2[]={ 0   , 0   , 0   , 0    };
  3432. +
  3433. +/*
  3434. + * Debugging
  3435. + * =========
  3436. + */
  3437. +static inline void set_debugt(void)
  3438. +{
  3439. +#ifdef DEBUGT
  3440. +    debugtimer = jiffies;
  3441. +#endif
  3442. +}
  3443. +
  3444. +static inline void debugt(const char *message)
  3445. +{
  3446. +#ifdef DEBUGT
  3447. +  if ( DP->flags & DEBUGT )
  3448. +    printk("%s dtime=%lu\n", message, jiffies-debugtimer );
  3449. +#endif
  3450. +}
  3451. +
  3452. +typedef void (*timeout_fn)(unsigned long);
  3453. +static struct timer_list fd_timeout ={ NULL, NULL, 0, 0,
  3454. +                    (timeout_fn) floppy_shutdown };
  3455. +
  3456. +static const char *timeout_message;
  3457. +
  3458. +#ifdef CONFIG_FLOPPY_SANITY
  3459. +static void is_alive(const char *message)
  3460. +{
  3461. +    /* this routine checks whether the floppy driver is "alive" */
  3462. +    if (fdc_busy && command_status < 2 && !fd_timeout.prev){
  3463. +        DPRINT1("timeout handler died: %s\n",message);
  3464. +    }
  3465. +}
  3466. +
  3467. +
  3468. +#define OLOGSIZE 20
  3469. +
  3470. +void (*lasthandler)(void) = NULL;
  3471. +int interruptjiffies=0;
  3472. +int resultjiffies=0;
  3473. +int resultsize=0;
  3474. +int lastredo=0;
  3475. +
  3476. +static struct output_log {
  3477. +    unsigned char data;
  3478. +    unsigned char status;
  3479. +    unsigned long jiffies;
  3480. +} output_log[OLOGSIZE];
  3481. +
  3482. +static int output_log_pos=0;
  3483. +#endif
  3484. +
  3485. +#define CURRENTD -1
  3486. +#define MAXTIMEOUT -2
  3487. +
  3488. +
  3489. +
  3490. +static void reschedule_timeout(int drive, const char *message, int marg)
  3491. +{
  3492. +    if (drive == CURRENTD )
  3493. +        drive = current_drive;
  3494. +    del_timer(&fd_timeout);
  3495. +    if (drive < 0 || drive > N_DRIVE) {
  3496. +        fd_timeout.expires = jiffies + 20*HZ;
  3497. +        drive = 0;
  3498. +    } else
  3499. +        fd_timeout.expires = jiffies + UDP->timeout;
  3500. +    add_timer(&fd_timeout);
  3501. +    if (UDP->flags & FD_DEBUG) {
  3502. +        DPRINT("reschedule timeout ");
  3503. +        printk(message, marg);
  3504. +        printk("\n");
  3505. +    }
  3506. +    timeout_message = message;
  3507. +}
  3508. +
  3509. +/*
  3510. + * Bottom half floppy driver.
  3511. + * ==========================
  3512. + *
  3513. + * This part of the file contains the code talking directly to the hardware,
  3514. + * and also the main service loop (seek-configure-spinup-command)
  3515. + */
  3516. +
  3517. +/*
  3518. + * disk change.
  3519. + * This routine is responsible for maintaining the FD_DISK_CHANGE flag,
  3520. + * and the last_checked date.
  3521. + *
  3522. + * last_checked is the date of the last check which showed 'no disk change'
  3523. + * FD_DISK_CHANGE is set under two conditions:
  3524. + * 1. The floppy has been changed after some i/o to that floppy already
  3525. + *    took place.
  3526. + * 2. No floppy disk is in the drive. This is done in order to ensure that
  3527. + *    requests are quickly flushed in case there is no disk in the drive. It
  3528. + *    follows that FD_DISK_CHANGE can only be cleared if there is a disk in
  3529. + *    the drive.
  3530. + *
  3531. + * For 1., maxblock is observed. Maxblock is 0 if no i/o has taken place yet.
  3532. + * For 2., FD_DISK_NEWCHANGE is watched. FD_DISK_NEWCHANGE is cleared on
  3533. + *  each seek. If a disk is present, the disk change line should also be
  3534. + *  cleared on each seek. Thus, if FD_DISK_NEWCHANGE is clear, but the disk
  3535. + *  change line is set, this means either that no disk is in the drive, or
  3536. + *  that it has been removed since the last seek.
  3537. + *
  3538. + * This means that we really have a third possibility too:
  3539. + *  The floppy has been changed after the last seek.
  3540. + */
  3541. +
  3542. +static int disk_change(int drive)
  3543. +{
  3544. +    int fdc=FDC(drive);
  3545. +#ifdef CONFIG_FLOPPY_SANITY
  3546. +    if(jiffies < UDP->select_delay + UDRS->select_date)
  3547. +        DPRINT("WARNING disk change called early\n");
  3548. +    if(! (FDCS->dor & (0x10 << UNIT(drive))) ||
  3549. +       (FDCS->dor & 3) != UNIT(drive) ||
  3550. +       fdc != FDC(drive)){
  3551. +           DPRINT("probing disk change on unselected drive\n");
  3552. +           DPRINT3("drive=%d fdc=%d dor=%x\n",drive, FDC(drive),
  3553. +               FDCS->dor);
  3554. +    }
  3555. +#endif
  3556. +
  3557. +#ifdef DCL_DEBUG
  3558. +    if (UDP->flags & FD_DEBUG){
  3559. +        DPRINT1("checking disk change line for drive %d\n",drive);
  3560. +        DPRINT1("jiffies=%ld\n", jiffies);
  3561. +        DPRINT1("disk change line=%x\n", inb_p(FD_DIR)&0x80);
  3562. +        DPRINT1("flags=%x\n",UDRS->flags);
  3563. +    }
  3564. +#endif
  3565. +    if (UDP->flags & FD_BROKEN_DCL)
  3566. +        return UTESTF(FD_DISK_CHANGED);
  3567. +    if( (inb_p(FD_DIR) ^ UDP->flags) & 0x80){
  3568. +        USETF(FD_VERIFY); /* verify write protection */
  3569. +        if(UDRS->maxblock){
  3570. +            /* mark it changed */
  3571. +            USETF(FD_DISK_CHANGED);
  3572. +
  3573. +            /* invalidate its geometry */
  3574. +            if (UDRS->keep_data >= 0) {
  3575. +                if ((UDP->flags & FTD_MSG) &&
  3576. +                    current_type[drive] != NULL)
  3577. +                    DPRINT("Disk type is undefined after "
  3578. +                           "disk change\n");
  3579. +                current_type[drive] = NULL;
  3580. +                floppy_sizes[TOMINOR(current_drive)] = MAX_DISK_SIZE;
  3581. +            }
  3582. +        }
  3583. +        /*USETF(FD_DISK_NEWCHANGE);*/
  3584. +        return 1;
  3585. +    } else {
  3586. +        UDRS->last_checked=jiffies;
  3587. +        UCLEARF(FD_DISK_NEWCHANGE);
  3588. +    }
  3589. +    return 0;
  3590. +}
  3591. +
  3592. +static inline int is_selected(int dor, int unit)
  3593. +{
  3594. +    return ( (dor  & (0x10 << unit)) && (dor &3) == unit);
  3595. +}
  3596. +
  3597. +static inline void arm_set_dor(int dor)
  3598. +{
  3599. +    if(dor & 0xf0)
  3600. +        outb_p((dor & 0x0c) | floppy_selects1[dor & 3], FD_DOR);
  3601. +    else
  3602. +        outb_p((dor & 0x0c), FD_DOR);
  3603. +}
  3604. +
  3605. +static int set_dor(int fdc, char mask, char data)
  3606. +{
  3607. +    register unsigned char drive, unit, newdor,olddor;
  3608. +
  3609. +    if (FDCS->address == -1)
  3610. +        return -1;
  3611. +
  3612. +    olddor = FDCS->dor;
  3613. +    newdor =  (olddor & mask) | data;
  3614. +    if ( newdor != olddor ){
  3615. +        unit = olddor & 0x3;
  3616. +        if(is_selected(olddor, unit) && !is_selected(newdor, unit)){
  3617. +            drive = REVDRIVE(fdc,unit);
  3618. +#ifdef DCL_DEBUG
  3619. +            if (UDP->flags & FD_DEBUG){
  3620. +                DPRINT("calling disk change from set_dor\n");
  3621. +            }
  3622. +#endif
  3623. +            disk_change(drive);
  3624. +        }
  3625. +        FDCS->dor = newdor;
  3626. +        arm_set_dor(newdor);
  3627. +
  3628. +        unit = newdor & 0x3;
  3629. +        if(!is_selected(olddor, unit) && is_selected(newdor, unit)){
  3630. +            drive = REVDRIVE(fdc,unit);
  3631. +            UDRS->select_date = jiffies;
  3632. +        }
  3633. +    }
  3634. +    if ( newdor & 0xf0 )
  3635. +        floppy_grab_irq_and_dma();
  3636. +    if( olddor & 0xf0 )
  3637. +        floppy_release_irq_and_dma();
  3638. +    return olddor;
  3639. +}
  3640. +
  3641. +static void twaddle(void)
  3642. +{
  3643. +    if (DP->select_delay)
  3644. +        return;
  3645. +    arm_set_dor(FDCS->dor & ~(0x10<<UNIT(current_drive)));
  3646. +    arm_set_dor(FDCS->dor);
  3647. +    DRS->select_date = jiffies;
  3648. +}
  3649. +
  3650. +/* reset all driver information about the current fdc. This is needed after
  3651. + * a reset, and after a raw command. */
  3652. +static void reset_fdc_info(int mode)
  3653. +{
  3654. +    int drive;
  3655. +
  3656. +    FDCS->spec1 = FDCS->spec2 = -1;
  3657. +    FDCS->need_configure = 1;
  3658. +    FDCS->perp_mode = 1;
  3659. +    FDCS->rawcmd = 0;
  3660. +    for ( drive = 0; drive < N_DRIVE; drive++)
  3661. +        if (FDC(drive) == fdc &&
  3662. +            ( mode || UDRS->track != NEED_1_RECAL))
  3663. +            UDRS->track = NEED_2_RECAL;
  3664. +}
  3665. +
  3666. +/* selects the fdc and drive, and enables the fdc's input/dma. */
  3667. +static void set_fdc(int drive)
  3668. +{
  3669. +    if ( drive >= 0 && drive < N_DRIVE){
  3670. +        fdc = FDC(drive);
  3671. +        current_drive = drive;
  3672. +    }
  3673. +    set_dor(fdc,~0,8);
  3674. +    set_dor(1-fdc, ~8, 0);
  3675. +    if ( FDCS->rawcmd == 2 )
  3676. +        reset_fdc_info(1);
  3677. +    if( inb_p(FD_STATUS) != STATUS_READY )
  3678. +        FDCS->reset = 1;
  3679. +}
  3680. +
  3681. +/* locks the driver */
  3682. +static int lock_fdc(int drive, int interruptible)
  3683. +{
  3684. +    if(!usage_count){
  3685. +        printk("trying to lock fdc while usage count=0\n");
  3686. +        return -1;
  3687. +    }
  3688. +    floppy_grab_irq_and_dma();
  3689. +    cli();
  3690. +    while (fdc_busy && NO_SIGNAL)
  3691. +        interruptible_sleep_on(&fdc_wait);
  3692. +    if(fdc_busy){
  3693. +        sti();
  3694. +        return -EINTR;
  3695. +    }
  3696. +    fdc_busy = 1;
  3697. +    sti();
  3698. +    command_status = FD_COMMAND_NONE;
  3699. +    set_fdc(drive);
  3700. +    reschedule_timeout(drive, "lock fdc", 0);
  3701. +    return 0;
  3702. +}
  3703. +
  3704. +#define LOCK_FDC(drive,interruptible) \
  3705. +if(lock_fdc(drive,interruptible)) return -EINTR;
  3706. +
  3707. +
  3708. +/* unlocks the driver */
  3709. +static inline void unlock_fdc(void)
  3710. +{
  3711. +    raw_cmd = NULL;
  3712. +    if (!fdc_busy)
  3713. +        DPRINT("FDC access conflict!\n");
  3714. +
  3715. +    if ( DEVICE_INTR )
  3716. +        DPRINT1("device interrupt still active at FDC release: %p!\n",
  3717. +            DEVICE_INTR);
  3718. +    command_status = FD_COMMAND_NONE;
  3719. +    del_timer(&fd_timeout);
  3720. +    cont = NULL;
  3721. +    fdc_busy = 0;
  3722. +    floppy_release_irq_and_dma();
  3723. +    wake_up(&fdc_wait);
  3724. +}
  3725. +
  3726. +/* switches the motor off after a given timeout */
  3727. +static void motor_off_callback(unsigned long nr)
  3728. +{
  3729. +    unsigned char mask = ~(0x10 << UNIT(nr));
  3730. +
  3731. +    set_dor( FDC(nr), mask, 0 );
  3732. +}
  3733. +
  3734. +static struct timer_list motor_off_timer[N_DRIVE] = {
  3735. +    { NULL, NULL, 0, 0, motor_off_callback },
  3736. +    { NULL, NULL, 0, 1, motor_off_callback },
  3737. +    { NULL, NULL, 0, 2, motor_off_callback },
  3738. +    { NULL, NULL, 0, 3, motor_off_callback },
  3739. +    { NULL, NULL, 0, 4, motor_off_callback },
  3740. +    { NULL, NULL, 0, 5, motor_off_callback },
  3741. +    { NULL, NULL, 0, 6, motor_off_callback },
  3742. +    { NULL, NULL, 0, 7, motor_off_callback }
  3743. +};
  3744. +
  3745. +/* schedules motor off */
  3746. +static void floppy_off(unsigned int drive)
  3747. +{
  3748. +    unsigned long volatile delta;
  3749. +    register int fdc=FDC(drive);
  3750. +
  3751. +    if( !(FDCS->dor & ( 0x10 << UNIT(drive))))
  3752. +        return;
  3753. +
  3754. +    del_timer(motor_off_timer+drive);
  3755. +
  3756. +    /* make spindle stop in a position which minimizes spinup time
  3757. +     * next time */
  3758. +    if ( UDP->rps ){
  3759. +        delta = jiffies - UDRS->first_read_date + HZ -
  3760. +            UDP->spindown_offset;
  3761. +        delta = (( delta * UDP->rps) % HZ ) / UDP->rps;
  3762. +        motor_off_timer[drive].expires = jiffies + UDP->spindown - delta;
  3763. +    }
  3764. +    add_timer(motor_off_timer+drive);
  3765. +}
  3766. +
  3767. +/*
  3768. + * cycle through all N_DRIVE floppy drives, for disk change testing.
  3769. + * stopping at current drive. This is done before any long operation, to
  3770. + * be sure to have up to date disk change information.
  3771. + */
  3772. +static void scandrives(void)
  3773. +{
  3774. +    int i, drive, saved_drive;
  3775. +
  3776. +    if (DP->select_delay)
  3777. +        return;
  3778. +
  3779. +    saved_drive = current_drive;
  3780. +    for(i=0; i< N_DRIVE; i++){
  3781. +        drive = (saved_drive + i + 1 ) % N_DRIVE;
  3782. +        if ( UDRS->fd_ref == 0 || UDP->select_delay != 0)
  3783. +            continue; /* skip closed drives */
  3784. +        set_fdc(drive);
  3785. +        if(! (set_dor( fdc, ~3, UNIT(drive) | ( 0x10 << UNIT(drive))) &
  3786. +              (0x10 << UNIT(drive))))
  3787. +            /* switch the motor off again, if it was off to
  3788. +             * begin with */
  3789. +            set_dor( fdc, ~( 0x10 << UNIT(drive) ), 0 );
  3790. +    }
  3791. +    set_fdc(saved_drive);
  3792. +}
  3793. +
  3794. +static struct timer_list fd_timer ={ NULL, NULL, 0, 0, 0 };
  3795. +
  3796. +/* this function makes sure that the disk stays in the drive during the
  3797. + * transfer */
  3798. +static void fd_watchdog(void)
  3799. +{
  3800. +#ifdef DCL_DEBUG
  3801. +    if (DP->flags & FD_DEBUG){
  3802. +        DPRINT("calling disk change from watchdog\n");
  3803. +    }
  3804. +#endif
  3805. +
  3806. +    if ( disk_change(current_drive) ){
  3807. +        DPRINT("disk removed during i/o\n");
  3808. +        floppy_shutdown();
  3809. +    } else {
  3810. +        del_timer(&fd_timer);
  3811. +        fd_timer.function = (timeout_fn) fd_watchdog;
  3812. +        fd_timer.expires = jiffies + HZ / 10;
  3813. +        add_timer(&fd_timer);
  3814. +    }
  3815. +}
  3816. +
  3817. +static void main_command_interrupt(void)
  3818. +{
  3819. +    del_timer(&fd_timer);
  3820. +    cont->interrupt();
  3821. +}
  3822. +
  3823. +/* waits for a delay (spinup or select) to pass */
  3824. +static int wait_for_completion(int delay, timeout_fn function)
  3825. +{
  3826. +    if ( FDCS->reset ){
  3827. +        reset_fdc(); /* do the reset during sleep to win time
  3828. +                  * if we don't need to sleep, it's a good
  3829. +                  * occasion anyways */
  3830. +        return 1;
  3831. +    }
  3832. +
  3833. +    if ( jiffies < delay ){
  3834. +        del_timer(&fd_timer);
  3835. +        fd_timer.function = function;
  3836. +        fd_timer.expires = delay;
  3837. +        add_timer(&fd_timer);
  3838. +        return 1;
  3839. +    }
  3840. +    return 0;
  3841. +}
  3842. +
  3843. +static int hlt_disabled=0;
  3844. +static void floppy_disable_hlt(void)
  3845. +{
  3846. +    unsigned long flags;
  3847. +    save_flags(flags);
  3848. +    cli();
  3849. +    if(!hlt_disabled){
  3850. +        hlt_disabled=1;
  3851. +#ifdef HAVE_DISABLE_HLT
  3852. +        disable_hlt();
  3853. +#endif
  3854. +    }
  3855. +    restore_flags(flags);
  3856. +}
  3857. +
  3858. +static void floppy_enable_hlt(void)
  3859. +{
  3860. +    unsigned long flags;
  3861. +    save_flags(flags);
  3862. +    cli();
  3863. +    if(hlt_disabled){
  3864. +        hlt_disabled=0;
  3865. +#ifdef HAVE_DISABLE_HLT
  3866. +        enable_hlt();
  3867. +#endif
  3868. +    }
  3869. +    restore_flags(flags);
  3870. +}
  3871. +
  3872. +
  3873. +static void setup_DMA(void)
  3874. +{
  3875. +#ifdef CONFIG_FLOPPY_SANITY
  3876. +    if (raw_cmd->length == 0){
  3877. +        int i;
  3878. +
  3879. +        printk("zero dma transfer size:");
  3880. +        for(i=0; i< raw_cmd->cmd_count; i++)
  3881. +            printk("%x,", raw_cmd->cmd[i]);
  3882. +        printk("\n");
  3883. +        cont->done(0);
  3884. +        FDCS->reset = 1;
  3885. +        return;
  3886. +    }
  3887. +#if 0
  3888. +    /* disabled because of new buffer location for raw cmd */
  3889. +    if ((!CURRENT ||
  3890. +         CURRENT->buffer != raw_cmd->kernel_data ||
  3891. +         raw_cmd->length > 512 * CURRENT->nr_sectors) &&
  3892. +        (raw_cmd->kernel_data < floppy_track_buffer ||
  3893. +         raw_cmd->kernel_data + raw_cmd->length >
  3894. +         floppy_track_buffer + 1024 * max_buffer_sectors)){
  3895. +        printk("bad address. start=%p lg=%lx tb=%p\n",
  3896. +               raw_cmd->kernel_data, raw_cmd->length,
  3897. +               floppy_track_buffer);
  3898. +        if ( CURRENT ){
  3899. +            printk("buffer=%p nr=%lx cnr=%lx\n",
  3900. +                   CURRENT->buffer, CURRENT->nr_sectors,
  3901. +                   CURRENT->current_nr_sectors);
  3902. +        }
  3903. +        cont->done(0);
  3904. +        FDCS->reset=1;
  3905. +        return;
  3906. +    }
  3907. +    if ((long) raw_cmd->kernel_data % 512 ){
  3908. +        printk("non aligned address: %p\n", raw_cmd->kernel_data );
  3909. +        cont->done(0);
  3910. +        FDCS->reset=1;
  3911. +        return;
  3912. +    }
  3913. +    if (CROSS_64KB(raw_cmd->kernel_data, raw_cmd->length)) {
  3914. +        printk("DMA crossing 64-K boundary %p-%p\n",
  3915. +               raw_cmd->kernel_data,
  3916. +               raw_cmd->kernel_data + raw_cmd->length);
  3917. +        cont->done(0);
  3918. +        FDCS->reset=1;
  3919. +        return;
  3920. +    }
  3921. +#endif
  3922. +#endif
  3923. +    cli();
  3924. +    disable_dma(FLOPPY_DMA);
  3925. +    clear_dma_ff(FLOPPY_DMA);
  3926. +    set_dma_mode(FLOPPY_DMA,
  3927. +             (raw_cmd->flags & FD_RAW_READ)?
  3928. +             DMA_MODE_READ : DMA_MODE_WRITE);
  3929. +    set_dma_addr(FLOPPY_DMA, virt_to_bus(raw_cmd->kernel_data));
  3930. +    set_dma_count(FLOPPY_DMA, raw_cmd->length);
  3931. +    enable_dma(FLOPPY_DMA);
  3932. +    sti();
  3933. +    floppy_disable_hlt();
  3934. +}
  3935. +
  3936. +/* sends a command byte to the fdc */
  3937. +static int output_byte(char byte)
  3938. +{
  3939. +    int counter;
  3940. +    unsigned char status=0;
  3941. +    unsigned char rstatus;
  3942. +
  3943. +    if (FDCS->reset)
  3944. +        return -1;
  3945. +    for(counter = 0 ; counter < 10000 && !FDCS->reset ; counter++) {
  3946. +        rstatus = inb_p(FD_STATUS);
  3947. +        status = rstatus &(STATUS_READY|STATUS_DIR|STATUS_DMA);
  3948. +        if (!(status & STATUS_READY))
  3949. +            continue;
  3950. +        if (status == STATUS_READY){
  3951. +            outb_p(byte,FD_DATA);
  3952. +
  3953. +#ifdef CONFIG_FLOPPY_SANITY
  3954. +            output_log[output_log_pos].data = byte;
  3955. +            output_log[output_log_pos].status = rstatus;
  3956. +            output_log[output_log_pos].jiffies = jiffies;
  3957. +            output_log_pos = (output_log_pos + 1) % OLOGSIZE;
  3958. +#endif
  3959. +            return 0;
  3960. +        } else
  3961. +            break;
  3962. +    }
  3963. +    FDCS->reset = 1;
  3964. +    if ( !initialising )
  3965. +        DPRINT2("Unable to send byte %x to FDC. Status=%x\n",
  3966. +            byte, status);
  3967. +    return -1;
  3968. +}
  3969. +#define LAST_OUT(x) if(output_byte(x)){ reset_fdc();return;}
  3970. +
  3971. +/* gets the response from the fdc */
  3972. +static int result(void)
  3973. +{
  3974. +    int i = 0, counter, status = 0;
  3975. +
  3976. +    if (FDCS->reset)
  3977. +        return -1;
  3978. +    for (counter = 0 ; counter < 10000 && !FDCS->reset ; counter++) {
  3979. +        status = inb_p(FD_STATUS)&
  3980. +            (STATUS_DIR|STATUS_READY|STATUS_BUSY|STATUS_DMA);
  3981. +        if (!(status & STATUS_READY))
  3982. +            continue;
  3983. +        if (status == STATUS_READY){
  3984. +#ifdef CONFIG_FLOPPY_SANITY
  3985. +            resultjiffies = jiffies;
  3986. +            resultsize = i;
  3987. +#endif
  3988. +            return i;
  3989. +        }
  3990. +        if (status & STATUS_DMA )
  3991. +            break;
  3992. +        if (status == (STATUS_DIR|STATUS_READY|STATUS_BUSY)) {
  3993. +            if (i >= MAX_REPLIES) {
  3994. +                DPRINT("floppy_stat reply overrun\n");
  3995. +                break;
  3996. +            }
  3997. +            reply_buffer[i++] = inb_p(FD_DATA);
  3998. +        }
  3999. +    }
  4000. +    FDCS->reset = 1;
  4001. +    if ( !initialising )
  4002. +        DPRINT3("Getstatus times out (%x) on fdc %d [%d]\n",
  4003. +            status, fdc, i);
  4004. +    return -1;
  4005. +}
  4006. +
  4007. +/* Set perpendicular mode as required, based on data rate, if supported.
  4008. + * 82077 Now tested. 1Mbps data rate only possible with 82077-1.
  4009. + */
  4010. +static inline void perpendicular_mode(void)
  4011. +{
  4012. +    unsigned char perp_mode;
  4013. +
  4014. +    if (!floppy)
  4015. +        return;
  4016. +    if (floppy->rate & 0x40){
  4017. +        switch(raw_cmd->rate){
  4018. +            case 0:
  4019. +                perp_mode=2;
  4020. +                break;
  4021. +            case 3:
  4022. +                perp_mode=3;
  4023. +                break;
  4024. +            default:
  4025. +                DPRINT("Invalid data rate for perpendicular mode!\n");
  4026. +                cont->done(0);
  4027. +                FDCS->reset = 1; /* convenient way to return to
  4028. +                          * redo without to much hassle (deep
  4029. +                          * stack et al. */
  4030. +                return;
  4031. +        }
  4032. +    } else
  4033. +        perp_mode = 0;
  4034. +
  4035. +    if ( FDCS->perp_mode == perp_mode )
  4036. +        return;
  4037. +    if (FDCS->version >= FDC_82077_ORIG && FDCS->has_fifo) {
  4038. +        output_byte(FD_PERPENDICULAR);
  4039. +        output_byte(perp_mode);
  4040. +        FDCS->perp_mode = perp_mode;
  4041. +    } else if (perp_mode) {
  4042. +        DPRINT("perpendicular mode not supported by this FDC.\n");
  4043. +    }
  4044. +} /* perpendicular_mode */
  4045. +
  4046. +#define NOMINAL_DTR 500
  4047. +
  4048. +/* Issue a "SPECIFY" command to set the step rate time, head unload time,
  4049. + * head load time, and DMA disable flag to values needed by floppy.
  4050. + *
  4051. + * The value "dtr" is the data transfer rate in Kbps.  It is needed
  4052. + * to account for the data rate-based scaling done by the 82072 and 82077
  4053. + * FDC types.  This parameter is ignored for other types of FDCs (i.e.
  4054. + * 8272a).
  4055. + *
  4056. + * Note that changing the data transfer rate has a (probably deleterious)
  4057. + * effect on the parameters subject to scaling for 82072/82077 FDCs, so
  4058. + * fdc_specify is called again after each data transfer rate
  4059. + * change.
  4060. + *
  4061. + * srt: 1000 to 16000 in microseconds
  4062. + * hut: 16 to 240 milliseconds
  4063. + * hlt: 2 to 254 milliseconds
  4064. + *
  4065. + * These values are rounded up to the next highest available delay time.
  4066. + */
  4067. +static void fdc_specify(void)
  4068. +{
  4069. +    unsigned char spec1, spec2;
  4070. +    int srt, hlt, hut;
  4071. +    unsigned long dtr = NOMINAL_DTR;
  4072. +    unsigned long scale_dtr = NOMINAL_DTR;
  4073. +    int hlt_max_code = 0x7f;
  4074. +    int hut_max_code = 0xf;
  4075. +
  4076. +    if (FDCS->need_configure && FDCS->has_fifo) {
  4077. +        if ( FDCS->reset )
  4078. +            return;
  4079. +        /* Turn on FIFO for 82077-class FDC (improves performance) */
  4080. +        /* TODO: lock this in via LOCK during initialization */
  4081. +        output_byte(FD_CONFIGURE);
  4082. +        output_byte(0);
  4083. +        output_byte(0x2A);    /* FIFO on, polling off, 10 byte threshold */
  4084. +        output_byte(0);        /* precompensation from track 0 upwards */
  4085. +        if ( FDCS->reset ){
  4086. +            FDCS->has_fifo=0;
  4087. +            return;
  4088. +        }
  4089. +        FDCS->need_configure = 0;
  4090. +        /*DPRINT("FIFO enabled\n");*/
  4091. +    }
  4092. +
  4093. +    switch (raw_cmd->rate & 0x03) {
  4094. +        case 3:
  4095. +            dtr = 1000;
  4096. +            break;
  4097. +        case 1:
  4098. +            dtr = 300;
  4099. +            break;
  4100. +        case 2:
  4101. +            dtr = 250;
  4102. +            break;
  4103. +    }
  4104. +
  4105. +    if (FDCS->version >= FDC_82072) {
  4106. +        scale_dtr = dtr;
  4107. +        hlt_max_code = 0x00; /* 0==256msec*dtr0/dtr (not linear!) */
  4108. +        hut_max_code = 0x0; /* 0==256msec*dtr0/dtr (not linear!) */
  4109. +    }
  4110. +
  4111. +    /* Convert step rate from microseconds to milliseconds and 4 bits */
  4112. +    srt = 16 - (DP->srt*scale_dtr/1000 + NOMINAL_DTR - 1)/NOMINAL_DTR;
  4113. +    if (srt > 0xf)
  4114. +        srt = 0xf;
  4115. +    else if (srt < 0)
  4116. +        srt = 0;
  4117. +
  4118. +    hlt = (DP->hlt*scale_dtr/2 + NOMINAL_DTR - 1)/NOMINAL_DTR;
  4119. +    if (hlt < 0x01)
  4120. +        hlt = 0x01;
  4121. +    else if (hlt > 0x7f)
  4122. +        hlt = hlt_max_code;
  4123. +
  4124. +    hut = (DP->hut*scale_dtr/16 + NOMINAL_DTR - 1)/NOMINAL_DTR;
  4125. +    if (hut < 0x1)
  4126. +        hut = 0x1;
  4127. +    else if (hut > 0xf)
  4128. +        hut = hut_max_code;
  4129. +
  4130. +    spec1 = (srt << 4) | hut;
  4131. +    spec2 = (hlt << 1);
  4132. +
  4133. +    /* If these parameters did not change, just return with success */
  4134. +    if (FDCS->spec1 != spec1 || FDCS->spec2 != spec2) {
  4135. +        /* Go ahead and set spec1 and spec2 */
  4136. +        output_byte(FD_SPECIFY);
  4137. +        output_byte(FDCS->spec1 = spec1);
  4138. +        output_byte(FDCS->spec2 = spec2);
  4139. +    }
  4140. +} /* fdc_specify */
  4141. +
  4142. +/* Set the FDC's data transfer rate on behalf of the specified drive.
  4143. + * NOTE: with 82072/82077 FDCs, changing the data rate requires a reissue
  4144. + * of the specify command (i.e. using the fdc_specify function).
  4145. + */
  4146. +static int fdc_dtr(void)
  4147. +{
  4148. +    /* If data rate not already set to desired value, set it. */
  4149. +    if ( raw_cmd->rate == FDCS->dtr)
  4150. +        return 0;
  4151. +
  4152. +    /* Set dtr */
  4153. +    outb_p(raw_cmd->rate, FD_DCR);
  4154. +
  4155. +    /* TODO: some FDC/drive combinations (C&T 82C711 with TEAC 1.2MB)
  4156. +     * need a stabilization period of several milliseconds to be
  4157. +     * enforced after data rate changes before R/W operations.
  4158. +     * Pause 5 msec to avoid trouble. (Needs to be 2 jiffies)
  4159. +     */
  4160. +    FDCS->dtr = raw_cmd->rate;
  4161. +    return(wait_for_completion(jiffies+2*HZ/100,
  4162. +                   (timeout_fn) floppy_ready));
  4163. +} /* fdc_dtr */
  4164. +
  4165. +static void tell_sector(void)
  4166. +{
  4167. +    printk(": track %d, head %d, sector %d, size %d",
  4168. +           R_TRACK, R_HEAD, R_SECTOR, R_SIZECODE);
  4169. +} /* tell_sector */
  4170. +
  4171. +
  4172. +/*
  4173. + * Ok, this error interpreting routine is called after a
  4174. + * DMA read/write has succeeded
  4175. + * or failed, so we check the results, and copy any buffers.
  4176. + * hhb: Added better error reporting.
  4177. + * ak: Made this into a separate routine.
  4178. + */
  4179. +static int interpret_errors(void)
  4180. +{
  4181. +    char bad;
  4182. +int res = get_dma_residue(FLOPPY_DMA);
  4183. +if(res) {printk("\n-- DMA residue (%d)",res); tell_sector(); printk("\n");}
  4184. +    if (inr!=7) {
  4185. +        DPRINT("-- FDC reply error");
  4186. +        FDCS->reset = 1;
  4187. +        return 1;
  4188. +    }
  4189. +
  4190. +    /* check IC to find cause of interrupt */
  4191. +    switch (ST0 & ST0_INTR) {
  4192. +        case 0x40:    /* error occurred during command execution */
  4193. +            bad = 1;
  4194. +            if (ST1 & ST1_WP) {
  4195. +                DPRINT("Drive is write protected\n");
  4196. +                CLEARF(FD_DISK_WRITABLE);
  4197. +                cont->done(0);
  4198. +                bad = 2;
  4199. +            } else if (ST1 & ST1_ND) {
  4200. +                SETF(FD_NEED_TWADDLE);
  4201. +            } else if (ST1 & ST1_OR) {
  4202. +                if (DP->flags & FTD_MSG )
  4203. +                    DPRINT("Over/Underrun - retrying\n");
  4204. +                bad = 0;
  4205. +            }else if(*errors >= DP->max_errors.reporting){
  4206. +                DPRINT("");
  4207. +                if (ST0 & ST0_ECE) {
  4208. +                    printk("Recalibrate failed!");
  4209. +                } else if (ST2 & ST2_CRC) {
  4210. +                    printk("data CRC error");
  4211. +                    tell_sector();
  4212. +                } else if (ST1 & ST1_CRC) {
  4213. +                    printk("CRC error");
  4214. +                    tell_sector();
  4215. +                } else if ((ST1 & (ST1_MAM|ST1_ND)) || (ST2 & ST2_MAM)) {
  4216. +                    if (!probing) {
  4217. +                        printk("sector not found");
  4218. +                        tell_sector();
  4219. +                    } else
  4220. +                        printk("probe failed...");
  4221. +                } else if (ST2 & ST2_WC) {    /* seek error */
  4222. +                    printk("wrong cylinder");
  4223. +                } else if (ST2 & ST2_BC) {    /* cylinder marked as bad */
  4224. +                    printk("bad cylinder");
  4225. +                } else {
  4226. +                    printk("unknown error. ST[0..2] are: 0x%x 0x%x 0x%x", ST0, ST1, ST2);
  4227. +                    tell_sector();
  4228. +                }
  4229. +                printk("\n");
  4230. +
  4231. +            }
  4232. +            if ( ST2 & ST2_WC || ST2 & ST2_BC)
  4233. +                /* wrong cylinder => recal */
  4234. +                DRS->track = NEED_2_RECAL;
  4235. +            return bad;
  4236. +        case 0x80: /* invalid command given */
  4237. +            DPRINT("Invalid FDC command given!\n");
  4238. +            cont->done(0);
  4239. +            return 2;
  4240. +        case 0xc0:
  4241. +            DPRINT("Abnormal termination caused by polling\n");
  4242. +            cont->error();
  4243. +            return 2;
  4244. +        default: /* (0) Normal command termination */
  4245. +            return 0;
  4246. +    }
  4247. +}
  4248. +
  4249. +/*
  4250. + * This routine is called when everything should be correctly set up
  4251. + * for the transfer (ie floppy motor is on, the correct floppy is
  4252. + * selected, and the head is sitting on the right track).
  4253. + */
  4254. +static void setup_rw_floppy(void)
  4255. +{
  4256. +    int i,ready_date,r, flags,dflags;
  4257. +    timeout_fn function;
  4258. +
  4259. +    flags = raw_cmd->flags;
  4260. +    if ( flags & ( FD_RAW_READ | FD_RAW_WRITE))
  4261. +        flags |= FD_RAW_INTR;
  4262. +
  4263. +    if ((flags & FD_RAW_SPIN) && !(flags & FD_RAW_NO_MOTOR)){
  4264. +        ready_date = DRS->spinup_date + DP->spinup;
  4265. +        /* If spinup will take a long time, rerun scandrives
  4266. +         * again just before spinup completion. Beware that
  4267. +         * after scandrives, we must again wait for selection.
  4268. +         */
  4269. +        if ( ready_date > jiffies + DP->select_delay){
  4270. +            ready_date -= DP->select_delay;
  4271. +            function = (timeout_fn) floppy_start;
  4272. +        } else
  4273. +            function = (timeout_fn) setup_rw_floppy;
  4274. +
  4275. +        /* wait until the floppy is spinning fast enough */
  4276. +        if (wait_for_completion(ready_date,function))
  4277. +            return;
  4278. +    }
  4279. +    dflags = DRS->flags;
  4280. +
  4281. +    if ( (flags & FD_RAW_READ) || (flags & FD_RAW_WRITE))
  4282. +        setup_DMA();
  4283. +
  4284. +    if ( flags & FD_RAW_INTR )
  4285. +        SET_INTR(main_command_interrupt);
  4286. +
  4287. +    r=0;
  4288. +    for(i=0; i< raw_cmd->cmd_count; i++)
  4289. +        r|=output_byte( raw_cmd->cmd[i] );
  4290. +
  4291. +#ifdef DEBUGT
  4292. +    debugt("rw_command: ");
  4293. +#endif
  4294. +    if ( r ){
  4295. +        reset_fdc();
  4296. +        return;
  4297. +    }
  4298. +
  4299. +    if ( ! ( flags & FD_RAW_INTR )){
  4300. +        inr = result();
  4301. +        cont->interrupt();
  4302. +    } else if ( flags & FD_RAW_NEED_DISK )
  4303. +        fd_watchdog();
  4304. +}
  4305. +
  4306. +static int blind_seek;
  4307. +
  4308. +/*
  4309. + * This is the routine called after every seek (or recalibrate) interrupt
  4310. + * from the floppy controller.
  4311. + */
  4312. +static void seek_interrupt(void)
  4313. +{
  4314. +#ifdef DEBUGT
  4315. +    debugt("seek interrupt:");
  4316. +#endif
  4317. +    if (inr != 2 || (ST0 & 0xF8) != 0x20 ) {
  4318. +        DPRINT("seek failed\n");
  4319. +        DRS->track = NEED_2_RECAL;
  4320. +        cont->error();
  4321. +        cont->redo();
  4322. +        return;
  4323. +    }
  4324. +    if (DRS->track >= 0 && DRS->track != ST1 && !blind_seek){
  4325. +#ifdef DCL_DEBUG
  4326. +        if (DP->flags & FD_DEBUG){
  4327. +            DPRINT("clearing NEWCHANGE flag because of effective seek\n");
  4328. +            DPRINT1("jiffies=%ld\n", jiffies);
  4329. +        }
  4330. +#endif
  4331. +        CLEARF(FD_DISK_NEWCHANGE); /* effective seek */
  4332. +        DRS->select_date = jiffies;
  4333. +    }
  4334. +    DRS->track = ST1;
  4335. +    floppy_ready();
  4336. +}
  4337. +
  4338. +static void check_wp(void)
  4339. +{
  4340. +    if (TESTF(FD_VERIFY)) {
  4341. +        /* check write protection */
  4342. +        output_byte( FD_GETSTATUS );
  4343. +        output_byte( UNIT(current_drive) );
  4344. +        if ( result() != 1 ){
  4345. +            FDCS->reset = 1;
  4346. +            return;
  4347. +        }
  4348. +        CLEARF(FD_VERIFY);
  4349. +        CLEARF(FD_NEED_TWADDLE);
  4350. +#ifdef DCL_DEBUG
  4351. +        if (DP->flags & FD_DEBUG){
  4352. +            DPRINT("checking whether disk is write protected\n");
  4353. +            DPRINT1("wp=%x\n",ST3 & 0x40);
  4354. +        }
  4355. +#endif
  4356. +        if (!( ST3  & 0x40))
  4357. +            SETF(FD_DISK_WRITABLE);
  4358. +        else
  4359. +            CLEARF(FD_DISK_WRITABLE);
  4360. +    }
  4361. +}
  4362. +
  4363. +static void seek_floppy(void)
  4364. +{
  4365. +    int track;
  4366. +
  4367. +    blind_seek=0;
  4368. +
  4369. +#ifdef DCL_DEBUG
  4370. +    if (DP->flags & FD_DEBUG){
  4371. +        DPRINT("calling disk change from seek\n");
  4372. +    }
  4373. +#endif
  4374. +
  4375. +    if (!TESTF(FD_DISK_NEWCHANGE) &&
  4376. +        disk_change(current_drive) &&
  4377. +        (raw_cmd->flags & FD_RAW_NEED_DISK)){
  4378. +        /* the media changed flag should be cleared after the seek.
  4379. +         * If it isn't, this means that there is really no disk in
  4380. +         * the drive.
  4381. +         */
  4382. +        SETF(FD_DISK_CHANGED);
  4383. +        cont->done(0);
  4384. +        cont->redo();
  4385. +        return;
  4386. +    }
  4387. +    if ( DRS->track <= NEED_1_RECAL ){
  4388. +        recalibrate_floppy();
  4389. +        return;
  4390. +    } else if (TESTF(FD_DISK_NEWCHANGE) &&
  4391. +           (raw_cmd->flags & FD_RAW_NEED_DISK) &&
  4392. +           (DRS->track <= NO_TRACK || DRS->track == raw_cmd->track)) {
  4393. +        /* we seek to clear the media-changed condition. Does anybody
  4394. +         * know a more elegant way, which works on all drives? */
  4395. +        if ( raw_cmd->track )
  4396. +            track = raw_cmd->track - 1;
  4397. +        else {
  4398. +            if(DP->flags & FD_SILENT_DCL_CLEAR){
  4399. +                set_dor(fdc, ~ (0x10 << UNIT(current_drive)), 0);
  4400. +                blind_seek = 1;
  4401. +                raw_cmd->flags |= FD_RAW_NEED_SEEK;
  4402. +            }
  4403. +            track = 1;
  4404. +        }
  4405. +    } else {
  4406. +        check_wp();
  4407. +        if (raw_cmd->track != DRS->track &&
  4408. +            (raw_cmd->flags & FD_RAW_NEED_SEEK))
  4409. +            track = raw_cmd->track;
  4410. +        else {
  4411. +            setup_rw_floppy();
  4412. +            return;
  4413. +        }
  4414. +    }
  4415. +
  4416. +    SET_INTR(seek_interrupt);
  4417. +    output_byte(FD_SEEK);
  4418. +    output_byte(UNIT(current_drive));
  4419. +    LAST_OUT(track);
  4420. +#ifdef DEBUGT
  4421. +    debugt("seek command:");
  4422. +#endif
  4423. +}
  4424. +
  4425. +static void recal_interrupt(void)
  4426. +{
  4427. +#ifdef DEBUGT
  4428. +    debugt("recal interrupt:");
  4429. +#endif
  4430. +    if (inr !=2 )
  4431. +        FDCS->reset = 1;
  4432. +    else if (ST0 & ST0_ECE) {
  4433. +               switch(DRS->track){
  4434. +                   case NEED_1_RECAL:
  4435. +#ifdef DEBUGT
  4436. +                debugt("recal interrupt need 1 recal:");
  4437. +#endif
  4438. +                /* after a second recalibrate, we still haven't
  4439. +                 * reached track 0. Probably no drive. Raise an
  4440. +                 * error, as failing immediately might upset
  4441. +                 * computers possessed by the Devil :-) */
  4442. +                cont->error();
  4443. +                cont->redo();
  4444. +                return;
  4445. +            case NEED_2_RECAL:
  4446. +#ifdef DEBUGT
  4447. +                debugt("recal interrupt need 2 recal:");
  4448. +#endif
  4449. +                /* If we already did a recalibrate,
  4450. +                 * and we are not at track 0, this
  4451. +                 * means we have moved. (The only way
  4452. +                 * not to move at recalibration is to
  4453. +                 * be already at track 0.) Clear the
  4454. +                 * new change flag */
  4455. +#ifdef DCL_DEBUG
  4456. +                if (DP->flags & FD_DEBUG){
  4457. +                    DPRINT("clearing NEWCHANGE flag because of second recalibrate\n");
  4458. +                }
  4459. +#endif
  4460. +
  4461. +                CLEARF(FD_DISK_NEWCHANGE);
  4462. +                DRS->select_date = jiffies;
  4463. +                /* fall through */
  4464. +            default:
  4465. +#ifdef DEBUGT
  4466. +                debugt("recal interrupt default:");
  4467. +#endif
  4468. +                /* Recalibrate moves the head by at
  4469. +                 * most 80 steps. If after one
  4470. +                 * recalibrate we don't have reached
  4471. +                 * track 0, this might mean that we
  4472. +                 * started beyond track 80.  Try
  4473. +                 * again.  */
  4474. +                DRS->track = NEED_1_RECAL;
  4475. +                break;
  4476. +        }
  4477. +    } else
  4478. +        DRS->track = ST1;
  4479. +    floppy_ready();
  4480. +}
  4481. +
  4482. +/*
  4483. + * Unexpected interrupt - Print as much debugging info as we can...
  4484. + * All bets are off...
  4485. + */
  4486. +static void unexpected_floppy_interrupt(void)
  4487. +{
  4488. +    int i;
  4489. +    if ( initialising )
  4490. +        return;
  4491. +    if(print_unex){
  4492. +        DPRINT("unexpected interrupt\n");
  4493. +        if ( inr >= 0 )
  4494. +            for(i=0; i<inr; i++)
  4495. +                printk("%d %x\n", i, reply_buffer[i] );
  4496. +    }
  4497. +    while(1){
  4498. +        output_byte(FD_SENSEI);
  4499. +        inr=result();
  4500. +        if ( inr != 2 )
  4501. +            break;
  4502. +        if(print_unex){
  4503. +            printk("sensei\n");
  4504. +            for(i=0; i<inr; i++)
  4505. +                printk("%d %x\n", i, reply_buffer[i] );
  4506. +        }
  4507. +    }
  4508. +    FDCS->reset = 1;
  4509. +}
  4510. +
  4511. +struct tq_struct floppy_tq =
  4512. +{ 0, 0, (void *) (void *) unexpected_floppy_interrupt, 0 };
  4513. +
  4514. +/* interrupt handler */
  4515. +static void floppy_interrupt(int irq, struct pt_regs *regs)
  4516. +{
  4517. +    void (*handler)(void) = DEVICE_INTR;
  4518. +
  4519. +    lasthandler = handler;
  4520. +    interruptjiffies = jiffies;
  4521. +
  4522. +    floppy_enable_hlt();
  4523. +    CLEAR_INTR;
  4524. +    if ( fdc >= N_FDC || FDCS->address == -1){
  4525. +        /* we don't even know which FDC is the culprit */
  4526. +        printk("DOR0=%x\n", fdc_state[0].dor);
  4527. +        printk("floppy interrupt on bizarre fdc %d\n",fdc);
  4528. +        printk("handler=%p\n", handler);
  4529. +        is_alive("bizarre fdc");
  4530. +        return;
  4531. +    }
  4532. +    inr = result();
  4533. +    if (!handler){
  4534. +        unexpected_floppy_interrupt();
  4535. +        is_alive("unexpected");
  4536. +        return;
  4537. +    }
  4538. +    if ( inr == 0 ){
  4539. +        do {
  4540. +            output_byte(FD_SENSEI);
  4541. +            inr = result();
  4542. +        } while ( (ST0 & 0x83) != UNIT(current_drive) && inr == 2);
  4543. +    }
  4544. +    floppy_tq.routine = (void *)(void *) handler;
  4545. +    queue_task_irq(&floppy_tq, &tq_timer);
  4546. +    is_alive("normal interrupt end");
  4547. +}
  4548. +
  4549. +static void recalibrate_floppy(void)
  4550. +{
  4551. +#ifdef DEBUGT
  4552. +    debugt("recalibrate floppy:");
  4553. +#endif
  4554. +    SET_INTR(recal_interrupt);
  4555. +    output_byte(FD_RECALIBRATE);
  4556. +    LAST_OUT(UNIT(current_drive));
  4557. +}
  4558. +
  4559. +/*
  4560. + * Must do 4 FD_SENSEIs after reset because of ``drive polling''.
  4561. + */
  4562. +static void reset_interrupt(void)
  4563. +{
  4564. +#ifdef DEBUGT
  4565. +    debugt("reset interrupt:");
  4566. +#endif
  4567. +    /* fdc_specify();       reprogram fdc */
  4568. +    result();        /* get the status ready for set_fdc */
  4569. +    if ( FDCS->reset )
  4570. +        cont->error(); /* a reset just after a reset. BAD! */
  4571. +    cont->redo();
  4572. +}
  4573. +
  4574. +/*
  4575. + * reset is done by pulling bit 2 of DOR low for a while (old FDC's),
  4576. + * or by setting the self clearing bit 7 of STATUS (newer FDC's)
  4577. + */
  4578. +static void reset_fdc(void)
  4579. +{
  4580. +    SET_INTR(reset_interrupt);
  4581. +    FDCS->reset = 0;
  4582. +    reset_fdc_info(0);
  4583. +    if ( FDCS->version >= FDC_82077 )
  4584. +        outb_p(0x80 | ( FDCS->dtr &3), FD_STATUS);
  4585. +    else {
  4586. +        arm_set_dor(FDCS->dor & ~0x04);
  4587. +        udelay(FD_RESET_DELAY);
  4588. +        arm_set_dor(FDCS->dor);
  4589. +    }
  4590. +}
  4591. +
  4592. +static void empty(void)
  4593. +{
  4594. +}
  4595. +
  4596. +void show_floppy(void)
  4597. +{
  4598. +    int i;
  4599. +
  4600. +    printk("\n");
  4601. +    printk("floppy driver state\n");
  4602. +    printk("-------------------\n");
  4603. +    printk("now=%ld last interrupt=%d last called handler=%p\n",
  4604. +        jiffies, interruptjiffies, lasthandler);
  4605. +
  4606. +
  4607. +#ifdef CONFIG_FLOPPY_SANITY
  4608. +    printk("timeout_message=%s\n", timeout_message);
  4609. +    printk("last output bytes:\n");
  4610. +    for(i=0; i < OLOGSIZE; i++)
  4611. +        printk("%2x %2x %ld\n",
  4612. +            output_log[(i+output_log_pos) % OLOGSIZE].data,
  4613. +            output_log[(i+output_log_pos) % OLOGSIZE].status,
  4614. +            output_log[(i+output_log_pos) % OLOGSIZE].jiffies);
  4615. +    printk("last result at %d\n", resultjiffies);
  4616. +    printk("last redo_fd_request at %d\n", lastredo);
  4617. +    for(i=0; i<resultsize; i++){
  4618. +        printk("%2x ", reply_buffer[i]);
  4619. +    }
  4620. +    printk("\n");
  4621. +#endif
  4622. +
  4623. +#if 0
  4624. +    for(i=0; i<N_FDC; i++){
  4625. +        if(FDCS->address != -1){
  4626. +            printk("dor %d = %x\n", i, fdc_state[i].dor );
  4627. +            outb_p(fdc_state[i].address+2, fdc_state[i].dor);
  4628. +            udelay(1000); /* maybe we'll catch an interrupt... */
  4629. +        }
  4630. +    }
  4631. +#endif
  4632. +    printk("status=%x\n", inb_p(FD_STATUS));
  4633. +    printk("fdc_busy=%d\n", fdc_busy);
  4634. +    if( DEVICE_INTR)
  4635. +        printk("DEVICE_INTR=%p\n", DEVICE_INTR);
  4636. +    if(floppy_tq.sync)
  4637. +        printk("floppy_tq.routine=%p\n", floppy_tq.routine);
  4638. +    if(fd_timer.prev)
  4639. +        printk("fd_timer.function=%p\n", fd_timer.function);
  4640. +    if(fd_timeout.prev){
  4641. +        printk("timer_table=%p\n",fd_timeout.function);
  4642. +        printk("expires=%ld\n",fd_timeout.expires-jiffies);
  4643. +        printk("now=%ld\n",jiffies);
  4644. +    }
  4645. +    printk("cont=%p\n", cont);
  4646. +    printk("CURRENT=%p\n", CURRENT);
  4647. +    printk("command_status=%d\n", command_status);
  4648. +    printk("\n");
  4649. +}
  4650. +
  4651. +static void floppy_shutdown(void)
  4652. +{
  4653. +    if (!initialising)
  4654. +        show_floppy();
  4655. +    CLEAR_INTR;
  4656. +    floppy_tq.routine = (void *)(void *) empty;
  4657. +    del_timer( &fd_timer);
  4658. +    sti();
  4659. +
  4660. +    floppy_enable_hlt();
  4661. +    disable_dma(FLOPPY_DMA);
  4662. +    /* avoid dma going to a random drive after shutdown */
  4663. +    
  4664. +    if(!initialising)
  4665. +        DPRINT("floppy timeout\n");
  4666. +    FDCS->reset = 1;
  4667. +    if (cont){
  4668. +        cont->done(0);
  4669. +        cont->redo(); /* this will recall reset when needed */
  4670. +    } else {
  4671. +        printk("no cont in shutdown!\n");
  4672. +        process_fd_request();
  4673. +    }
  4674. +    is_alive("floppy shutdown");
  4675. +}
  4676. +/*typedef void (*timeout_fn)(unsigned long);*/
  4677. +
  4678. +/* start motor, check media-changed condition and write protection */
  4679. +static int start_motor( void (*function)(void)  )
  4680. +{
  4681. +    int mask, data;
  4682. +
  4683. +    mask = 0xfc;
  4684. +    data = UNIT(current_drive);
  4685. +    if (!(raw_cmd->flags & FD_RAW_NO_MOTOR)){
  4686. +        if(!(FDCS->dor & ( 0x10 << UNIT(current_drive) ) )){
  4687. +            set_debugt();
  4688. +            /* no read since this drive is running */
  4689. +            DRS->first_read_date = 0;
  4690. +            /* note motor start time if motor is not yet running */
  4691. +            DRS->spinup_date = jiffies;
  4692. +            data |= (0x10 << UNIT(current_drive));
  4693. +        }
  4694. +    } else
  4695. +        if (FDCS->dor & ( 0x10 << UNIT(current_drive) ) )
  4696. +            mask &= ~(0x10 << UNIT(current_drive));
  4697. +
  4698. +    /* starts motor and selects floppy */
  4699. +    del_timer(motor_off_timer + current_drive);
  4700. +    set_dor( fdc, mask, data);
  4701. +
  4702. +    /* wait_for_completion also schedules reset if needed. */
  4703. +    return(wait_for_completion(DRS->select_date+DP->select_delay,
  4704. +                   (timeout_fn) function));
  4705. +}
  4706. +
  4707. +static void floppy_ready(void)
  4708. +{
  4709. +    CHECK_RESET;
  4710. +    if(start_motor(floppy_ready)) return;
  4711. +    if(fdc_dtr()) return;
  4712. +
  4713. +#ifdef DCL_DEBUG
  4714. +    if (DP->flags & FD_DEBUG){
  4715. +        DPRINT("calling disk change from floppy_ready\n");
  4716. +    }
  4717. +#endif
  4718. +
  4719. +    if(!(raw_cmd->flags & FD_RAW_NO_MOTOR) &&
  4720. +       disk_change(current_drive) &&
  4721. +       !DP->select_delay)
  4722. +           twaddle(); /* this clears the dcl on certain drive/controller
  4723. +                   * combinations */
  4724. +
  4725. +    if ( raw_cmd->flags & (FD_RAW_NEED_SEEK | FD_RAW_NEED_DISK)){
  4726. +        perpendicular_mode();
  4727. +        fdc_specify(); /* must be done here because of hut, hlt ... */
  4728. +        seek_floppy();
  4729. +    } else
  4730. +        setup_rw_floppy();
  4731. +}
  4732. +
  4733. +static void floppy_start(void)
  4734. +{
  4735. +    reschedule_timeout(CURRENTD, "floppy start", 0);
  4736. +
  4737. +    scandrives();
  4738. +#ifdef DCL_DEBUG
  4739. +    if (DP->flags & FD_DEBUG){
  4740. +        DPRINT("setting NEWCHANGE in floppy_start\n");
  4741. +    }
  4742. +#endif
  4743. +    SETF(FD_DISK_NEWCHANGE);
  4744. +    floppy_ready();
  4745. +}
  4746. +
  4747. +/*
  4748. + * ========================================================================
  4749. + * here ends the bottom half. Exported routines are:
  4750. + * floppy_start, floppy_off, floppy_ready, lock_fdc, unlock_fdc, set_fdc,
  4751. + * start_motor, reset_fdc, reset_fdc_info, interpret_errors.
  4752. + * Initialisation also uses output_byte, result, set_dor, floppy_interrupt
  4753. + * and set_dor.
  4754. + * ========================================================================
  4755. + */
  4756. +/*
  4757. + * General purpose continuations.
  4758. + * ==============================
  4759. + */
  4760. +
  4761. +static void do_wakeup(void)
  4762. +{
  4763. +    reschedule_timeout(MAXTIMEOUT, "do wakeup", 0);
  4764. +    cont = 0;
  4765. +    command_status += 2;
  4766. +    wake_up(&command_done);
  4767. +}
  4768. +
  4769. +static struct cont_t wakeup_cont={
  4770. +    empty,
  4771. +    do_wakeup,
  4772. +    empty,
  4773. +    (done_f)empty
  4774. +};
  4775. +
  4776. +static int wait_til_done( void (*handler)(void ), int interruptible )
  4777. +{
  4778. +    int ret;
  4779. +
  4780. +    floppy_tq.routine = (void *)(void *) handler;
  4781. +    queue_task(&floppy_tq, &tq_timer);
  4782. +
  4783. +    cli();
  4784. +    while(command_status < 2 && NO_SIGNAL){
  4785. +        is_alive("wait_til_done");
  4786. +        if (interruptible)
  4787. +            interruptible_sleep_on(&command_done);
  4788. +        else
  4789. +            sleep_on(&command_done);
  4790. +    }
  4791. +    if(command_status < 2){
  4792. +        floppy_shutdown();
  4793. +        sti();
  4794. +        process_fd_request();
  4795. +        return -EINTR;
  4796. +    }
  4797. +    sti();
  4798. +
  4799. +    if ( FDCS->reset )
  4800. +        command_status = FD_COMMAND_ERROR;
  4801. +    if ( command_status == FD_COMMAND_OKAY )
  4802. +        ret=0;
  4803. +    else
  4804. +        ret=-EIO;
  4805. +    command_status = FD_COMMAND_NONE;
  4806. +    return ret;
  4807. +}
  4808. +
  4809. +static void generic_done(int result)
  4810. +{
  4811. +    command_status = result;
  4812. +    cont = &wakeup_cont;
  4813. +}
  4814. +
  4815. +static void generic_success(void)
  4816. +{
  4817. +    cont->done(1);
  4818. +}
  4819. +
  4820. +static void generic_failure(void)
  4821. +{
  4822. +    cont->done(0);
  4823. +}
  4824. +
  4825. +static void success_and_wakeup(void)
  4826. +{
  4827. +    generic_success();
  4828. +    cont->redo();
  4829. +}
  4830. +
  4831. +
  4832. +/*
  4833. + * formatting and rw support.
  4834. + * ==========================
  4835. + */
  4836. +
  4837. +static int next_valid_format(void)
  4838. +{
  4839. +    int probed_format;
  4840. +
  4841. +    probed_format = DRS->probed_format;
  4842. +    while(1){
  4843. +        if ( probed_format >= 8 ||
  4844. +            ! DP->autodetect[probed_format] ){
  4845. +            DRS->probed_format = 0;
  4846. +            return 1;
  4847. +        }
  4848. +        if ( floppy_type[DP->autodetect[probed_format]].sect ){
  4849. +            DRS->probed_format = probed_format;
  4850. +            return 0;
  4851. +        }
  4852. +        probed_format++;
  4853. +    }
  4854. +}
  4855. +
  4856. +static void bad_flp_intr(void)
  4857. +{
  4858. +    if ( probing ){
  4859. +        DRS->probed_format++;
  4860. +        if ( !next_valid_format())
  4861. +            return;
  4862. +    }
  4863. +    (*errors)++;
  4864. +    if (*errors > DRWE->badness)
  4865. +            DRWE->badness = *errors;
  4866. +    if (*errors > DP->max_errors.abort)
  4867. +        cont->done(0);
  4868. +    if (*errors > DP->max_errors.reset)
  4869. +        FDCS->reset = 1;
  4870. +    else if (*errors > DP->max_errors.recal)
  4871. +        DRS->track = NEED_2_RECAL;
  4872. +}
  4873. +
  4874. +static void set_floppy(kdev_t device)
  4875. +{
  4876. +    if (TYPE(device))
  4877. +        floppy = TYPE(device) + floppy_type;
  4878. +    else
  4879. +        floppy = current_type[ DRIVE(device) ];
  4880. +}
  4881. +
  4882. +/*
  4883. + * formatting and support.
  4884. + * =======================
  4885. + */
  4886. +static void format_interrupt(void)
  4887. +{
  4888. +    switch (interpret_errors()){
  4889. +        case 1:
  4890. +            cont->error();
  4891. +        case 2:
  4892. +            break;
  4893. +        case 0:
  4894. +            cont->done(1);
  4895. +    }
  4896. +    cont->redo();
  4897. +}
  4898. +
  4899. +#define CODE2SIZE (ssize = ( ( 1 << SIZECODE ) + 3 ) >> 2)
  4900. +#define FM_MODE(x,y) ((y) & ~(((x)->rate & 0x80 ) >>1))
  4901. +#define CT(x) ( (x) | 0x40 )
  4902. +static void setup_format_params(int track)
  4903. +{
  4904. +    struct fparm {
  4905. +        unsigned char track,head,sect,size;
  4906. +    } *here = (struct fparm *)floppy_track_buffer;
  4907. +    int il,n;
  4908. +    int count,head_shift,track_shift;
  4909. +
  4910. +    raw_cmd = &default_raw_cmd;
  4911. +    raw_cmd->track = track;
  4912. +    
  4913. +    raw_cmd->flags = FD_RAW_WRITE | FD_RAW_INTR | FD_RAW_SPIN |
  4914. +        /*FD_RAW_NEED_DISK |*/ FD_RAW_NEED_SEEK;
  4915. +    raw_cmd->rate = floppy->rate & 0x3;
  4916. +    raw_cmd->cmd_count = NR_F;
  4917. +    COMMAND = FM_MODE(floppy,FD_FORMAT);
  4918. +    DR_SELECT = UNIT(current_drive) + PH_HEAD(floppy,format_req.head);
  4919. +    F_SIZECODE = FD_SIZECODE(floppy);
  4920. +    F_SECT_PER_TRACK = floppy->sect << 2 >> F_SIZECODE;
  4921. +    F_GAP = floppy->fmt_gap;
  4922. +    F_FILL = FD_FILL_BYTE;
  4923. +
  4924. +    raw_cmd->kernel_data = floppy_track_buffer;
  4925. +    raw_cmd->length = 4 * F_SECT_PER_TRACK;
  4926. +
  4927. +    /* allow for about 30ms for data transport per track */
  4928. +    head_shift  = (F_SECT_PER_TRACK + 5) / 6;
  4929. +
  4930. +    /* a ``cylinder'' is two tracks plus a little stepping time */
  4931. +    track_shift = 2 * head_shift + 3;
  4932. +
  4933. +    /* position of logical sector 1 on this track */
  4934. +    n = (track_shift * format_req.track + head_shift * format_req.head )
  4935. +        % F_SECT_PER_TRACK;
  4936. +
  4937. +    /* determine interleave */
  4938. +    il = 1;
  4939. +    if (floppy->sect > DP->interleave_sect && F_SIZECODE == 2)
  4940. +        il++;
  4941. +
  4942. +    /* initialize field */
  4943. +    for (count = 0; count < F_SECT_PER_TRACK; ++count) {
  4944. +        here[count].track = format_req.track;
  4945. +        here[count].head = format_req.head;
  4946. +        here[count].sect = 0;
  4947. +        here[count].size = F_SIZECODE;
  4948. +    }
  4949. +    /* place logical sectors */
  4950. +    for (count = 1; count <= F_SECT_PER_TRACK; ++count) {
  4951. +        here[n].sect = count;
  4952. +        n = (n+il) % F_SECT_PER_TRACK;
  4953. +        if (here[n].sect) { /* sector busy, find next free sector */
  4954. +            ++n;
  4955. +            if (n>= F_SECT_PER_TRACK) {
  4956. +                n-=F_SECT_PER_TRACK;
  4957. +                while (here[n].sect) ++n;
  4958. +            }
  4959. +        }
  4960. +    }
  4961. +}
  4962. +
  4963. +static void redo_format(void)
  4964. +{
  4965. +    buffer_track = -1;
  4966. +    setup_format_params(format_req.track << STRETCH(floppy));
  4967. +    floppy_start();
  4968. +#ifdef DEBUGT
  4969. +    debugt("queue format request");
  4970. +#endif
  4971. +}
  4972. +
  4973. +static struct cont_t format_cont={
  4974. +    format_interrupt,
  4975. +    redo_format,
  4976. +    bad_flp_intr,
  4977. +    generic_done };
  4978. +
  4979. +static int do_format(kdev_t device, struct format_descr *tmp_format_req)
  4980. +{
  4981. +    int ret;
  4982. +    int drive=DRIVE(device);
  4983. +
  4984. +    LOCK_FDC(drive,1);
  4985. +    set_floppy(device);
  4986. +    if (!floppy ||
  4987. +        floppy->track > DP->tracks ||
  4988. +        tmp_format_req->track >= floppy->track ||
  4989. +        tmp_format_req->head >= floppy->head ||
  4990. +        (floppy->sect << 2) % (1 << FD_SIZECODE(floppy)) ||
  4991. +        !floppy->fmt_gap) {
  4992. +        process_fd_request();
  4993. +        return -EINVAL;
  4994. +    }
  4995. +    format_req = *tmp_format_req;
  4996. +    format_errors = 0;
  4997. +    cont = &format_cont;
  4998. +    errors = &format_errors;
  4999. +    IWAIT(redo_format);
  5000. +    process_fd_request();
  5001. +    return ret;
  5002. +}
  5003. +
  5004. +/*
  5005. + * Buffer read/write and support
  5006. + * =============================
  5007. + */
  5008. +
  5009. +/* new request_done. Can handle physical sectors which are smaller than a
  5010. + * logical buffer */
  5011. +static void request_done(int uptodate)
  5012. +{
  5013. +    int block;
  5014. +
  5015. +    probing = 0;
  5016. +    reschedule_timeout(MAXTIMEOUT, "request done %d", uptodate);
  5017. +
  5018. +    if (!CURRENT){
  5019. +        DPRINT("request list destroyed in floppy request done\n");
  5020. +        return;
  5021. +    }
  5022. +    if (uptodate){
  5023. +        /* maintain values for invalidation on geometry
  5024. +         * change */
  5025. +        block = current_count_sectors + CURRENT->sector;
  5026. +        if (block > DRS->maxblock)
  5027. +            DRS->maxblock=block;
  5028. +        if ( block > floppy->sect)
  5029. +            DRS->maxtrack = 1;
  5030. +
  5031. +        /* unlock chained buffers */
  5032. +        while (current_count_sectors && CURRENT &&
  5033. +               current_count_sectors >= CURRENT->current_nr_sectors ){
  5034. +            current_count_sectors -= CURRENT->current_nr_sectors;
  5035. +            CURRENT->nr_sectors -= CURRENT->current_nr_sectors;
  5036. +            CURRENT->sector += CURRENT->current_nr_sectors;
  5037. +            end_request(1);
  5038. +        }
  5039. +        if ( current_count_sectors && CURRENT){
  5040. +            /* "unlock" last subsector */
  5041. +            CURRENT->buffer += current_count_sectors <<9;
  5042. +            CURRENT->current_nr_sectors -= current_count_sectors;
  5043. +            CURRENT->nr_sectors -= current_count_sectors;
  5044. +            CURRENT->sector += current_count_sectors;
  5045. +            return;
  5046. +        }
  5047. +
  5048. +        if ( current_count_sectors && ! CURRENT )
  5049. +            DPRINT("request list destroyed in floppy request done\n");
  5050. +
  5051. +    } else {
  5052. +        if(CURRENT->cmd == WRITE) {
  5053. +            /* record write error information */
  5054. +            DRWE->write_errors++;
  5055. +            if(DRWE->write_errors == 1) {
  5056. +                DRWE->first_error_sector = CURRENT->sector;
  5057. +                DRWE->first_error_generation = DRS->generation;
  5058. +            }
  5059. +            DRWE->last_error_sector = CURRENT->sector;
  5060. +            DRWE->last_error_generation = DRS->generation;
  5061. +        }
  5062. +        end_request(0);
  5063. +    }
  5064. +}
  5065. +
  5066. +/* Interrupt handler evaluating the result of the r/w operation */
  5067. +static void rw_interrupt(void)
  5068. +{
  5069. +    int nr_sectors, ssize;
  5070. +
  5071. +    if ( ! DRS->first_read_date )
  5072. +        DRS->first_read_date = jiffies;
  5073. +
  5074. +    nr_sectors = 0;
  5075. +    CODE2SIZE;
  5076. +    nr_sectors = ((R_TRACK-TRACK)*floppy->head+R_HEAD-HEAD) *
  5077. +        floppy->sect + ((R_SECTOR-SECTOR) <<  SIZECODE >> 2) -
  5078. +        (sector_t % floppy->sect) % ssize;
  5079. +
  5080. +#ifdef CONFIG_FLOPPY_SANITY
  5081. +    if ( nr_sectors > current_count_sectors + ssize -
  5082. +         (current_count_sectors + sector_t) % ssize +
  5083. +         sector_t % ssize){
  5084. +        DPRINT2("long rw: %x instead of %lx\n",
  5085. +            nr_sectors, current_count_sectors);
  5086. +        printk("rs=%d s=%d\n", R_SECTOR, SECTOR);
  5087. +        printk("rh=%d h=%d\n", R_HEAD, HEAD);
  5088. +        printk("rt=%d t=%d\n", R_TRACK, TRACK);
  5089. +        printk("spt=%d st=%d ss=%d\n", SECT_PER_TRACK,
  5090. +               sector_t, ssize);
  5091. +    }
  5092. +#endif
  5093. +    if ( nr_sectors < 0 )
  5094. +        nr_sectors = 0;
  5095. +    if ( nr_sectors < current_count_sectors )
  5096. +        current_count_sectors = nr_sectors;
  5097. +
  5098. +    switch (interpret_errors()){
  5099. +        case 2:
  5100. +            cont->redo();
  5101. +            return;
  5102. +        case 1:
  5103. +            if (  !current_count_sectors){
  5104. +                cont->error();
  5105. +                cont->redo();
  5106. +                return;
  5107. +            }
  5108. +            break;
  5109. +        case 0:
  5110. +            if (  !current_count_sectors){
  5111. +                cont->redo();
  5112. +                return;
  5113. +            }
  5114. +            current_type[current_drive] = floppy;
  5115. +            floppy_sizes[TOMINOR(current_drive) ]= floppy->size>>1;
  5116. +            break;
  5117. +    }
  5118. +
  5119. +    if (probing) {
  5120. +        if (DP->flags & FTD_MSG)
  5121. +            DPRINT2("Auto-detected floppy type %s in fd%d\n",
  5122. +                floppy->name,current_drive);
  5123. +        current_type[current_drive] = floppy;
  5124. +        floppy_sizes[TOMINOR(current_drive)] = floppy->size >> 1;
  5125. +        probing = 0;
  5126. +    }
  5127. +
  5128. +    if ( CT(COMMAND) != FD_READ ||
  5129. +         raw_cmd->kernel_data == CURRENT->buffer ){
  5130. +        /* transfer directly from buffer */
  5131. +        cont->done(1);
  5132. +    } else if ( CT(COMMAND) == FD_READ){
  5133. +        buffer_track = raw_cmd->track;
  5134. +        buffer_drive = current_drive;
  5135. +        if ( nr_sectors + sector_t > buffer_max )
  5136. +            buffer_max = nr_sectors + sector_t;
  5137. +    }
  5138. +    cont->redo();
  5139. +}
  5140. +
  5141. +/* Compute maximal contiguous buffer size. */
  5142. +static int buffer_chain_size(void)
  5143. +{
  5144. +    struct buffer_head *bh;
  5145. +    int size;
  5146. +    char *base;
  5147. +
  5148. +    base = CURRENT->buffer;
  5149. +    size = CURRENT->current_nr_sectors << 9;
  5150. +    bh = CURRENT->bh;
  5151. +
  5152. +    if(bh){
  5153. +        bh = bh->b_reqnext;
  5154. +        while ( bh && bh->b_data == base + size ){
  5155. +            size += bh->b_size;
  5156. +            bh = bh->b_reqnext;
  5157. +        }
  5158. +    }
  5159. +    return size >> 9;
  5160. +}
  5161. +
  5162. +/* Compute the maximal transfer size */
  5163. +static int transfer_size(int ssize, int max_sector, int max_size)
  5164. +{
  5165. +    if ( max_sector > sector_t + max_size)
  5166. +        max_sector = sector_t + max_size;
  5167. +
  5168. +    /* alignment */
  5169. +    max_sector -= (max_sector % floppy->sect ) % ssize;
  5170. +
  5171. +    /* transfer size, beginning not aligned */
  5172. +    current_count_sectors = max_sector - sector_t ;
  5173. +
  5174. +    return max_sector;
  5175. +}
  5176. +
  5177. +/*
  5178. + * Move data from/to the track buffer to/from the buffer cache.
  5179. + */
  5180. +static void copy_buffer(int ssize, int max_sector, int max_sector_2)
  5181. +{
  5182. +    int remaining; /* number of transferred 512-byte sectors */
  5183. +    struct buffer_head *bh;
  5184. +    char *buffer, *dma_buffer;
  5185. +    int size;
  5186. +
  5187. +    if ( max_sector > max_sector_2 )
  5188. +        max_sector = max_sector_2;
  5189. +
  5190. +    max_sector = transfer_size(ssize, max_sector, CURRENT->nr_sectors);
  5191. +
  5192. +    if (current_count_sectors <= 0 && CT(COMMAND) == FD_WRITE &&
  5193. +        buffer_max > sector_t + CURRENT->nr_sectors){
  5194. +        current_count_sectors = buffer_max - sector_t;
  5195. +        if ( current_count_sectors > CURRENT->nr_sectors )
  5196. +            current_count_sectors = CURRENT->nr_sectors;
  5197. +    }
  5198. +    remaining = current_count_sectors << 9;
  5199. +#ifdef CONFIG_FLOPPY_SANITY
  5200. +    if ((remaining >> 9) > CURRENT->nr_sectors  &&
  5201. +        CT(COMMAND) == FD_WRITE ){
  5202. +        DPRINT("in copy buffer\n");
  5203. +        printk("current_count_sectors=%ld\n", current_count_sectors);
  5204. +        printk("remaining=%d\n", remaining >> 9);
  5205. +        printk("CURRENT->nr_sectors=%ld\n",CURRENT->nr_sectors);
  5206. +        printk("CURRENT->current_nr_sectors=%ld\n",
  5207. +               CURRENT->current_nr_sectors);
  5208. +        printk("max_sector=%d\n", max_sector);
  5209. +        printk("ssize=%d\n", ssize);
  5210. +    }
  5211. +#endif
  5212. +
  5213. +    if ( max_sector > buffer_max )
  5214. +        buffer_max = max_sector;
  5215. +
  5216. +    dma_buffer = floppy_track_buffer + ((sector_t - buffer_min) << 9);
  5217. +
  5218. +    bh = CURRENT->bh;
  5219. +    size = CURRENT->current_nr_sectors << 9;
  5220. +    buffer = CURRENT->buffer;
  5221. +
  5222. +    while ( remaining > 0){
  5223. +        if ( size > remaining )
  5224. +            size = remaining;
  5225. +#ifdef CONFIG_FLOPPY_SANITY
  5226. +        if (dma_buffer + size >
  5227. +            floppy_track_buffer + (max_buffer_sectors << 10) ||
  5228. +            dma_buffer < floppy_track_buffer ){
  5229. +            DPRINT1("buffer overrun in copy buffer %d\n",
  5230. +                (int) ((floppy_track_buffer - dma_buffer) >>9));
  5231. +            printk("sector_t=%d buffer_min=%d\n",
  5232. +                   sector_t, buffer_min);
  5233. +            printk("current_count_sectors=%ld\n",
  5234. +                   current_count_sectors);
  5235. +            if ( CT(COMMAND) == FD_READ )
  5236. +                printk("read\n");
  5237. +            if ( CT(COMMAND) == FD_READ )
  5238. +                printk("write\n");
  5239. +            break;
  5240. +        }
  5241. +        if ( ((unsigned long)buffer) % 512 )
  5242. +            DPRINT1("%p buffer not aligned\n", buffer);
  5243. +#endif
  5244. +        if ( CT(COMMAND) == FD_READ )
  5245. +            memcpy( buffer, dma_buffer, size);
  5246. +        else
  5247. +            memcpy( dma_buffer, buffer, size);
  5248. +        remaining -= size;
  5249. +        if ( !remaining)
  5250. +            break;
  5251. +
  5252. +        dma_buffer += size;
  5253. +        bh = bh->b_reqnext;
  5254. +#ifdef CONFIG_FLOPPY_SANITY
  5255. +        if ( !bh){
  5256. +            DPRINT("bh=null in copy buffer after copy\n");
  5257. +            break;
  5258. +        }
  5259. +#endif
  5260. +        size = bh->b_size;
  5261. +        buffer = bh->b_data;
  5262. +    }
  5263. +#ifdef CONFIG_FLOPPY_SANITY
  5264. +    if ( remaining ){
  5265. +        if ( remaining > 0 )
  5266. +            max_sector -= remaining >> 9;
  5267. +        DPRINT1("weirdness: remaining %d\n", remaining>>9);
  5268. +    }
  5269. +#endif
  5270. +}
  5271. +
  5272. +/*
  5273. + * Formulate a read/write request.
  5274. + * this routine decides where to load the data (directly to buffer, or to
  5275. + * tmp floppy area), how much data to load (the size of the buffer, the whole
  5276. + * track, or a single sector)
  5277. + * All floppy_track_buffer handling goes in here. If we ever add track buffer
  5278. + * allocation on the fly, it should be done here. No other part should need
  5279. + * modification.
  5280. + */
  5281. +
  5282. +static int make_raw_rw_request(void)
  5283. +{
  5284. +    int aligned_sector_t;
  5285. +    int max_sector, max_size, tracksize, ssize;
  5286. +
  5287. +    set_fdc(DRIVE(CURRENT->rq_dev));
  5288. +
  5289. +    raw_cmd = &default_raw_cmd;
  5290. +    raw_cmd->flags = FD_RAW_SPIN | FD_RAW_NEED_DISK | FD_RAW_NEED_DISK |
  5291. +        FD_RAW_NEED_SEEK;
  5292. +    raw_cmd->cmd_count = NR_RW;
  5293. +    if (CURRENT->cmd == READ){
  5294. +        raw_cmd->flags |= FD_RAW_READ;
  5295. +        COMMAND = FM_MODE(floppy,FD_READ);
  5296. +    } else if (CURRENT->cmd == WRITE){
  5297. +        raw_cmd->flags |= FD_RAW_WRITE;
  5298. +        COMMAND = FM_MODE(floppy,FD_WRITE);
  5299. +    } else {
  5300. +        DPRINT("make_raw_rw_request: unknown command\n");
  5301. +        return 0;
  5302. +    }
  5303. +
  5304. +    max_sector = floppy->sect * floppy->head;
  5305. +    
  5306. +    TRACK = CURRENT->sector / max_sector;
  5307. +    sector_t = CURRENT->sector % max_sector;
  5308. +    if ( floppy->track && TRACK >= floppy->track )
  5309. +        return 0;
  5310. +    HEAD = sector_t / floppy->sect;
  5311. +
  5312. +    if (((floppy->stretch & FD_SWAPSIDES) || TESTF( FD_NEED_TWADDLE)) &&
  5313. +        sector_t < floppy->sect )
  5314. +        max_sector = floppy->sect;
  5315. +
  5316. +    /* 2M disks have phantom sectors on the first track */
  5317. +    if ( (floppy->rate & FD_2M ) && (!TRACK) && (!HEAD)){
  5318. +        max_sector = 2 * floppy->sect / 3;
  5319. +        if (sector_t >= max_sector){
  5320. +            current_count_sectors =  (floppy->sect - sector_t);
  5321. +            if ( current_count_sectors > CURRENT->nr_sectors )
  5322. +                current_count_sectors = CURRENT->nr_sectors;
  5323. +            return 1;
  5324. +        }
  5325. +        SIZECODE = 2;
  5326. +    } else
  5327. +        SIZECODE = FD_SIZECODE(floppy);
  5328. +    raw_cmd->rate = floppy->rate & 3;
  5329. +    if ((floppy->rate & FD_2M) &&
  5330. +        (TRACK || HEAD ) &&
  5331. +        raw_cmd->rate == 2)
  5332. +        raw_cmd->rate = 1;
  5333. +
  5334. +    if ( SIZECODE )
  5335. +        SIZECODE2 = 0xff;
  5336. +    else
  5337. +        SIZECODE2 = 0x80;
  5338. +    raw_cmd->track = TRACK << STRETCH(floppy);
  5339. +    DR_SELECT = UNIT(current_drive) + PH_HEAD(floppy,HEAD);
  5340. +    GAP = floppy->gap;
  5341. +    CODE2SIZE;
  5342. +    SECT_PER_TRACK = floppy->sect << 2 >> SIZECODE;
  5343. +    SECTOR = ((sector_t % floppy->sect) << 2 >> SIZECODE) + 1;
  5344. +    tracksize = floppy->sect - floppy->sect % ssize;
  5345. +    if ( tracksize < floppy->sect ){
  5346. +        SECT_PER_TRACK ++;
  5347. +        if (  tracksize <= sector_t % floppy->sect)
  5348. +            SECTOR--;
  5349. +        while ( tracksize <= sector_t % floppy->sect){
  5350. +            while( tracksize + ssize > floppy->sect ){
  5351. +                SIZECODE--;
  5352. +                ssize >>= 1;
  5353. +            }
  5354. +            SECTOR++; SECT_PER_TRACK ++;
  5355. +            tracksize += ssize;
  5356. +        }
  5357. +        max_sector = HEAD * floppy->sect + tracksize;
  5358. +    } else if ( !TRACK && !HEAD && !( floppy->rate & FD_2M ) && probing)
  5359. +        max_sector = floppy->sect;
  5360. +
  5361. +    aligned_sector_t = sector_t - ( sector_t % floppy->sect ) % ssize;
  5362. +    max_size = CURRENT->nr_sectors;
  5363. +    if ((raw_cmd->track == buffer_track) && (current_drive == buffer_drive) &&
  5364. +        (sector_t >= buffer_min) && (sector_t < buffer_max)) {
  5365. +        /* data already in track buffer */
  5366. +        if (CT(COMMAND) == FD_READ) {
  5367. +            copy_buffer(1, max_sector, buffer_max);
  5368. +            return 1;
  5369. +        }
  5370. +    } else if (aligned_sector_t != sector_t || CURRENT->nr_sectors < ssize){
  5371. +        if (CT(COMMAND) == FD_WRITE){
  5372. +            if(sector_t + CURRENT->nr_sectors > ssize &&
  5373. +               sector_t + CURRENT->nr_sectors < ssize + ssize)
  5374. +                max_size = ssize + ssize;
  5375. +            else
  5376. +                max_size = ssize;
  5377. +        }
  5378. +        raw_cmd->flags &= ~FD_RAW_WRITE;
  5379. +        raw_cmd->flags |= FD_RAW_READ;
  5380. +        COMMAND = FM_MODE(floppy,FD_READ);
  5381. +    } else if ((unsigned long)CURRENT->buffer < MAX_DMA_ADDRESS ) {
  5382. +        int direct, indirect;
  5383. +
  5384. +        indirect= transfer_size(ssize,max_sector,max_buffer_sectors*2) -
  5385. +            sector_t;
  5386. +
  5387. +        max_size = buffer_chain_size();
  5388. +#if 0
  5389. +        if ( max_size > ( MAX_DMA_ADDRESS - ((unsigned long) CURRENT->buffer))>>9)
  5390. +            max_size=(MAX_DMA_ADDRESS - ((unsigned long) CURRENT->buffer))>>9;
  5391. +        /* 64 kb boundaries */
  5392. +        if (CROSS_64KB(CURRENT->buffer, max_size << 9))
  5393. +            max_size = ( K_64 - ((long) CURRENT->buffer) % K_64)>>9;
  5394. +#endif
  5395. +        direct = transfer_size(ssize,max_sector,max_size) - sector_t;
  5396. +        /*
  5397. +         *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *