home *** CD-ROM | disk | FTP | other *** search
/ PC-Online 1996 May / PCOnline_05_1996.bin / linux / source / kernel-s / v1.1 / slackwar.001 < prev    next >
Text File  |  1995-10-10  |  241KB  |  7,831 lines
  1. diff -u --recursive --new-file linux-1.1.58/ANNOUNCE.eata linux/ANNOUNCE.eata
  2. --- linux-1.1.58/ANNOUNCE.eata    Wed Dec 31 18:00:00 1969
  3. +++ linux/ANNOUNCE.eata    Wed Oct 26 23:01:49 1994
  4. @@ -0,0 +1,39 @@
  5. +This is the announcement for the EATA SCSI driver
  6. +
  7. +The driver supports all EATA-DMA Protocol compliant SCSI 
  8. +ISA and EISA controllers (PCI rsn.)
  9. +
  10. +Those are for example:
  11. +        DPT Smartcache    : PM2011 (ISA), PM2012A (EISA), 
  12. +                            PM2012B (EISA) 
  13. +            Smartcache III: PM2021 (ISA), PM2022 (EISA), 
  14. +                            PM2122 (EISA), PM2322 (EISA)
  15. +        controllers from NEC and AT&T.
  16. +
  17. +The driver has been tested on the PM2011, PM2021 and PM2022 
  18. +
  19. +I call it still ALPHA software but the driver is pretty stable
  20. +and has been used for some months now. There are just some  
  21. +features missing (PCI/multiple HAs) which I want to implement
  22. +in the next time.
  23. +
  24. +The installation is basically a plug and play installation.
  25. +Just "cd" to your linux directory and extract the files from the 
  26. +TAR archive. Then you will find the diffile eata_patch.
  27. +Apply that with  "patch -p1 <patch.eata" against your linux source 
  28. +tree. The diffs were made against Linux 1.1.51
  29. +
  30. +The (hopefully) only problem that might appear is that you have
  31. +to configure the disk geometry of your first two drives. This 
  32. +problem only appears for people who were already able to use
  33. +their controller under Linux in IDE emulation mode and are sharing
  34. +the drives with DOS or some other OS that operates the controller
  35. +in IDE emulation mode (ie. doesn't use a SCSI driver).
  36. +
  37. +If you've got problems, questions or whatever, send me a mail 
  38. +
  39. +neuffer@goofy.zdv.uni-mainz.de
  40. +Michael_Neuffer@wi2.maus.de (Mails<16KB & <48KB per day)
  41. +
  42. +
  43. +Mike
  44. diff -u --recursive --new-file linux-1.1.58/README-Slackware linux/README-Slackware
  45. --- linux-1.1.58/README-Slackware    Wed Dec 31 18:00:00 1969
  46. +++ linux/README-Slackware    Wed Oct 26 23:01:49 1994
  47. @@ -0,0 +1,14 @@
  48. +The following changes were made to this kernel:
  49. +
  50. +Added nec260-0_3 patches (NEC CD-ROM on the IDE interface)
  51. +Added sony535-0.6 patches (Sony 531/535 CD-ROM drives)
  52. +Added dpt_EATA_0.3a patches (EATA compliant ISA and EISA SCSI)
  53. +Added Adaptec 274x SCSI patches.
  54. +Added Always in2000 patches.
  55. +
  56. +NOTE: IN2000 and Adaptec 1742 drivers should not be compiled into the same
  57. +kernel.  Do not compile the NEC CD-ROM driver into your kernel unless you
  58. +have an NEC CD-ROM driver attached as the slave device on your IDE controller.
  59. +I have no idea what it does if it finds a hard drive there...
  60. +
  61. +Pat
  62. diff -u --recursive --new-file linux-1.1.58/arch/i386/config.in linux/arch/i386/config.in
  63. --- linux-1.1.58/arch/i386/config.in    Mon Oct 24 17:43:29 1994
  64. +++ linux/arch/i386/config.in    Wed Oct 26 23:05:33 1994
  65. @@ -11,8 +11,9 @@
  66.  bool 'Networking support' CONFIG_NET y
  67.  bool 'Limit memory to low 16MB' CONFIG_MAX_16M n
  68.  bool 'System V IPC' CONFIG_SYSVIPC y
  69. -bool 'Kernel support for ELF binaries' CONFIG_BINFMT_ELF y
  70.  bool 'Use -m486 flag for 486-specific optimizations' CONFIG_M486 y
  71. +bool 'Kernel support for ELF binaries' CONFIG_BINFMT_ELF y
  72. +bool 'Do you wish to be offered ALPHA drivers added by Slackware?' ALPHA_SLACK y
  73.  
  74.  if [ "$CONFIG_NET" = "y" ]; then
  75.  comment 'Networking options'
  76. @@ -51,11 +52,15 @@
  77.  bool 'Adaptec AHA152X support' CONFIG_SCSI_AHA152X n
  78.  bool 'Adaptec AHA1542 support' CONFIG_SCSI_AHA1542 y
  79.  bool 'Adaptec AHA1740 support' CONFIG_SCSI_AHA1740 n
  80. +if [ "$ALPHA_SLACK" = "y" ]; then
  81. +  bool 'Adaptec AHA274X/284X support' CONFIG_SCSI_AHA274X y
  82. +  bool 'Always IN2000 SCSI support' CONFIG_SCSI_IN2000 n
  83. +  bool 'EATA-DMA (rev. 2.0b) (DPT,NEC,AT&T) support' CONFIG_SCSI_EATA n
  84. +fi
  85.  bool 'BusLogic SCSI support' CONFIG_SCSI_BUSLOGIC n
  86.  bool 'Future Domain 16xx SCSI support' CONFIG_SCSI_FUTURE_DOMAIN n
  87.  bool 'Generic NCR5380 SCSI support' CONFIG_SCSI_GENERIC_NCR5380 n
  88.  bool 'NCR53c7,8xx SCSI support'  CONFIG_SCSI_NCR53C7xx n
  89. -#bool 'Always IN2000 SCSI support' CONFIG_SCSI_IN2000 n
  90.  bool 'PAS16 SCSI support' CONFIG_SCSI_PAS16 n
  91.  bool 'Seagate ST-02 and Future Domain TMC-8xx SCSI support' CONFIG_SCSI_SEAGATE n
  92.  bool 'Trantor T128/T128F/T228 SCSI support' CONFIG_SCSI_T128 n
  93. @@ -133,6 +138,10 @@
  94.  comment 'CD-ROM drivers'
  95.  
  96.  bool 'Sony CDU31A/CDU33A CDROM driver support' CONFIG_CDU31A n
  97. +if [ "$ALPHA_SLACK" = "y" ]; then
  98. +  bool 'Sony CDU535 CDROM driver support' CONFIG_CDU535 n
  99. +  bool 'NEC CDR-260 CDROM driver support' CONFIG_NEC260 n
  100. +fi
  101.  bool 'Mitsumi CDROM driver support' CONFIG_MCD n
  102.  bool 'Matsushita/Panasonic CDROM driver support' CONFIG_SBPCD n
  103.  if [ "$CONFIG_SBPCD" = "y" ]; then
  104. diff -u --recursive --new-file linux-1.1.58/config.in linux/config.in
  105. --- linux-1.1.58/config.in    Sat Sep 17 21:48:10 1994
  106. +++ linux/config.in    Wed Oct 26 23:05:42 1994
  107. @@ -12,6 +12,8 @@
  108.  bool 'Limit memory to low 16MB' CONFIG_MAX_16M n
  109.  bool 'System V IPC' CONFIG_SYSVIPC y
  110.  bool 'Use -m486 flag for 486-specific optimizations' CONFIG_M486 y
  111. +bool 'Kernel support for ELF binaries' CONFIG_BINFMT_ELF y
  112. +bool 'Do you wish to be offered ALPHA drivers added by Slackware?' ALPHA_SLACK y
  113.  
  114.  if [ "$CONFIG_NET" = "y" ]; then
  115.  comment 'Networking options'
  116. @@ -24,7 +26,7 @@
  117.  bool 'Assume subnets are local' CONFIG_INET_SNARL y
  118.  bool 'Disable NAGLE algorithm (normally enabled)' CONFIG_TCP_NAGLE_OFF n
  119.  fi
  120. -bool 'The IPX protocol' CONFIG_IPX y
  121. +bool 'The IPX protocol' CONFIG_IPX n
  122.  #bool 'Amateur Radio AX.25 Level 2' CONFIG_AX25 n
  123.  fi
  124.  
  125. @@ -50,11 +52,15 @@
  126.  bool 'Adaptec AHA152X support' CONFIG_SCSI_AHA152X n
  127.  bool 'Adaptec AHA1542 support' CONFIG_SCSI_AHA1542 y
  128.  bool 'Adaptec AHA1740 support' CONFIG_SCSI_AHA1740 n
  129. +if [ "$ALPHA_SLACK" = "y" ]; then
  130. +  bool 'Adaptec AHA274X/284X support' CONFIG_SCSI_AHA274X y
  131. +  bool 'Always IN2000 SCSI support' CONFIG_SCSI_IN2000 n
  132. +  bool 'EATA-DMA (rev. 2.0b) (DPT,NEC,AT&T) support' CONFIG_SCSI_EATA n
  133. +fi
  134.  bool 'BusLogic SCSI support' CONFIG_SCSI_BUSLOGIC n
  135.  bool 'Future Domain 16xx SCSI support' CONFIG_SCSI_FUTURE_DOMAIN n
  136.  bool 'Generic NCR5380 SCSI support' CONFIG_SCSI_GENERIC_NCR5380 n
  137.  bool 'NCR53c7,8xx SCSI support'  CONFIG_SCSI_NCR53C7xx n
  138. -#bool 'Always IN2000 SCSI support' CONFIG_SCSI_IN2000 n
  139.  bool 'PAS16 SCSI support' CONFIG_SCSI_PAS16 n
  140.  bool 'Seagate ST-02 and Future Domain TMC-8xx SCSI support' CONFIG_SCSI_SEAGATE n
  141.  bool 'Trantor T128/T128F/T228 SCSI support' CONFIG_SCSI_T128 n
  142. @@ -107,6 +113,8 @@
  143.      if [ "$CONFIG_NET_ALPHA" = "y" ]; then
  144.          bool 'EtherExpress support' CONFIG_EEXPRESS n
  145.          bool 'AT1700 support' CONFIG_AT1700 n
  146. +        bool 'NI5210 support' CONFIG_NI52 n
  147. +        bool 'NI6510 support' CONFIG_NI65 n
  148.      fi
  149.      bool 'HP PCLAN support' CONFIG_HPLAN n
  150.      bool 'NE2000/NE1000 support' CONFIG_NE2000 y
  151. @@ -117,8 +125,6 @@
  152.          bool 'Ansel Communications EISA 3200 support' CONFIG_AC3200 n
  153.      fi
  154.      bool 'Apricot Xen-II on board ethernet' CONFIG_APRICOT n
  155. -#bool 'NI52EE support' CONFIG_NI52 n
  156. -#bool 'NI65EE support' CONFIG_NI65 n
  157.  bool 'Pocket and portable adaptors' CONFIG_NET_POCKET n
  158.  if [ "$CONFIG_NET_POCKET" = "y" ]; then
  159.      bool 'D-Link DE600 pocket adaptor support' CONFIG_DE600 n
  160. @@ -132,6 +138,10 @@
  161.  comment 'CD-ROM drivers'
  162.  
  163.  bool 'Sony CDU31A/CDU33A CDROM driver support' CONFIG_CDU31A n
  164. +if [ "$ALPHA_SLACK" = "y" ]; then
  165. +  bool 'Sony CDU535 CDROM driver support' CONFIG_CDU535 n
  166. +  bool 'NEC CDR-260 CDROM driver support' CONFIG_NEC260 n
  167. +fi
  168.  bool 'Mitsumi CDROM driver support' CONFIG_MCD n
  169.  bool 'Matsushita/Panasonic CDROM driver support' CONFIG_SBPCD n
  170.  if [ "$CONFIG_SBPCD" = "y" ]; then
  171. diff -u --recursive --new-file linux-1.1.58/drivers/block/Makefile linux/drivers/block/Makefile
  172. --- linux-1.1.58/drivers/block/Makefile    Sat Sep 17 21:44:49 1994
  173. +++ linux/drivers/block/Makefile    Wed Oct 26 23:01:59 1994
  174. @@ -64,7 +64,16 @@
  175.  SRCS := $(SRCS) xd.c
  176.  endif
  177.  
  178. -all: block.a
  179. +ifdef CONFIG_CDU535
  180. +OBJS := $(OBJS) sonycd535.o
  181. +SRCS := $(SRCS) sonycd535.c
  182. +endif
  183. +
  184. +ifdef CONFIG_NEC260
  185. +OBJS := $(OBJS) nec260.o
  186. +SRCS := $(SRCS) nec260.c
  187. +CFLAGS := $(CFLAGS) -DLINKED_IN_KERNEL -DNO_IRQACTION
  188. +endif
  189.  
  190.  block.a: $(OBJS)
  191.      rm -f block.a
  192. diff -u --recursive --new-file linux-1.1.58/drivers/block/blk.h linux/drivers/block/blk.h
  193. --- linux-1.1.58/drivers/block/blk.h    Thu Oct 13 21:31:06 1994
  194. +++ linux/drivers/block/blk.h    Wed Oct 26 23:02:00 1994
  195. @@ -40,6 +40,9 @@
  196.  extern unsigned long hd_init(unsigned long mem_start, unsigned long mem_end);
  197.  extern unsigned long cdu31a_init(unsigned long mem_start, unsigned long mem_end);
  198.  extern unsigned long mcd_init(unsigned long mem_start, unsigned long mem_end);
  199. +#ifdef CONFIG_CDU535
  200. +extern unsigned long init_sony535(unsigned long mem_start, unsigned long mem_end);
  201. +#endif
  202.  #ifdef CONFIG_SBPCD
  203.  extern unsigned long sbpcd_init(unsigned long, unsigned long);
  204.  #endif CONFIG_SBPCD
  205. @@ -135,6 +138,14 @@
  206.  
  207.  #define DEVICE_NAME "CDU31A"
  208.  #define DEVICE_REQUEST do_cdu31a_request
  209. +#define DEVICE_NR(device) (MINOR(device))
  210. +#define DEVICE_ON(device)
  211. +#define DEVICE_OFF(device)
  212. +
  213. +#elif (MAJOR_NR == CDU535_CDROM_MAJOR)
  214. +#define DEVICE_NAME "SONY-CDU535"
  215. +#define DEVICE_INTR do_cdu535
  216. +#define DEVICE_REQUEST do_cdu535_request
  217.  #define DEVICE_NR(device) (MINOR(device))
  218.  #define DEVICE_ON(device)
  219.  #define DEVICE_OFF(device)
  220. diff -u --recursive --new-file linux-1.1.58/drivers/block/hd.c linux/drivers/block/hd.c
  221. --- linux-1.1.58/drivers/block/hd.c    Mon Oct 24 17:43:36 1994
  222. +++ linux/drivers/block/hd.c    Wed Oct 26 23:02:00 1994
  223. @@ -43,6 +43,10 @@
  224.  #define MAJOR_NR HD_MAJOR
  225.  #include "blk.h"
  226.  
  227. +#ifdef CONFIG_NEC260
  228. +int the_nec260_major = 0;
  229. +#endif
  230. +
  231.  #define HD_IRQ 14
  232.  
  233.  static int revalidate_hddisk(int, int);
  234. @@ -660,6 +664,9 @@
  235.      reset = 1;
  236.      dev = DEVICE_NR(CURRENT->dev);
  237.      printk("hd%c: timeout\n", dev+'a');
  238. +#ifdef CONFIG_NEC260
  239. +    if (CURRENT->dev < 0) return;
  240. +#endif
  241.      if (++CURRENT->errors >= MAX_ERRORS) {
  242.  #ifdef DEBUG
  243.          printk("hd%c: too many errors\n", dev+'a');
  244. @@ -718,6 +725,14 @@
  245.          return;
  246.  repeat:
  247.      timer_active &= ~(1<<HD_TIMER);
  248. +#ifdef CONFIG_NEC260
  249. +    if (!CURRENT && the_nec260_major > 0 &&
  250. +        blk_dev[the_nec260_major].current_request) {
  251. +      cli ();
  252. +      (blk_dev[the_nec260_major].request_fn) ();
  253. +    }
  254. +    if (CURRENT && CURRENT->dev < 0) return;
  255. +#endif
  256.      sti();
  257.      INIT_REQUEST;
  258.      if (reset) {
  259. diff -u --recursive --new-file linux-1.1.58/drivers/block/ll_rw_blk.c linux/drivers/block/ll_rw_blk.c
  260. --- linux-1.1.58/drivers/block/ll_rw_blk.c    Mon Oct 24 17:43:36 1994
  261. +++ linux/drivers/block/ll_rw_blk.c    Wed Oct 26 23:02:00 1994
  262. @@ -35,6 +35,10 @@
  263.  
  264.  int read_ahead[MAX_BLKDEV] = {0, };
  265.  
  266. +#if defined(CONFIG_CDU535) && defined(CONFIG_CDU31A)
  267. +    int sonycd_save_mem_start;
  268. +#endif
  269. +
  270.  /* blk_dev_struct is:
  271.   *    do_request-address
  272.   *    next-request
  273. @@ -501,15 +505,36 @@
  274.  #ifdef CONFIG_BLK_DEV_XD
  275.      mem_start = xd_init(mem_start,mem_end);
  276.  #endif
  277. +#if defined(CONFIG_CDU535) && defined(CONFIG_CDU31A)
  278. +    {  /* since controllers for 535 and 31A can be at same location
  279. +        * we have to be careful.
  280. +        */
  281. +        sonycd_save_mem_start = mem_start;
  282. +        mem_start = cdu31a_init(mem_start,mem_end);
  283. +        if ( mem_start == sonycd_save_mem_start ) {  /* CDU31A not found */
  284. +            mem_start = init_sony535(mem_start,mem_end);
  285. +        }
  286. +    }
  287. +#else
  288.  #ifdef CONFIG_CDU31A
  289.      mem_start = cdu31a_init(mem_start,mem_end);
  290.  #endif
  291. +#ifdef CONFIG_CDU535
  292. +    mem_start = init_sony535(mem_start,mem_end);
  293. +#endif
  294. +#endif  /* CONFIG_CDU31A && CONFIG_CDU535 */
  295.  #ifdef CONFIG_MCD
  296.      mem_start = mcd_init(mem_start,mem_end);
  297.  #endif
  298.  #ifdef CONFIG_SBPCD
  299.      mem_start = sbpcd_init(mem_start, mem_end);
  300.  #endif CONFIG_SBPCD
  301. +#ifdef CONFIG_NEC260
  302. +        {
  303. +          extern unsigned long nec260_init (unsigned long, unsigned long);
  304. +      mem_start = nec260_init(mem_start, mem_end);
  305. +    }
  306. +#endif
  307.      if (ramdisk_size)
  308.          mem_start += rd_init(mem_start, ramdisk_size*1024);
  309.      return mem_start;
  310. diff -u --recursive --new-file linux-1.1.58/drivers/block/mcd.c linux/drivers/block/mcd.c
  311. --- linux-1.1.58/drivers/block/mcd.c    Sat Sep 17 21:48:13 1994
  312. +++ linux/drivers/block/mcd.c    Wed Oct 26 23:02:00 1994
  313. @@ -1182,7 +1182,6 @@
  314.  
  315.      mcd_invalidate_buffers();
  316.      mcdPresent = 1;
  317. -    printk("\n");
  318.      return mem_start;
  319.  }
  320.  
  321. diff -u --recursive --new-file linux-1.1.58/drivers/block/nec260.c linux/drivers/block/nec260.c
  322. --- linux-1.1.58/drivers/block/nec260.c    Wed Dec 31 18:00:00 1969
  323. +++ linux/drivers/block/nec260.c    Wed Oct 26 23:02:00 1994
  324. @@ -0,0 +1,852 @@
  325. +/*
  326. + * nec260.c - NEC CDR-260 driver
  327. + *  some pieces derived from mcd.c.
  328. + *
  329. + * scott snyder  <snyder@fnald0.fnal.gov>
  330. + *
  331. + *   0.1  May 31, 1994  Initial alpha release.
  332. + *   0.2  Sep  4, 1994  Converted into a loadable kernel module.
  333. + *                      Made more flexible wrt. hardware configurations.
  334. + *                      Sense disk changes properly.
  335. + *   0.3  Sep. 11, 1994 Add LINKED_IN_KERNEL #ifdef's.
  336. + *
  337. + *   Copyright (c) 1994  scott snyder <snyder@fnald0.fnal.gov>
  338. + *
  339. + *   This program is free software; you can redistribute it and/or modify
  340. + *   it under the terms of the GNU General Public License as published by
  341. + *   the Free Software Foundation; either version 2, or (at your option)
  342. + *   any later version.
  343. + *
  344. + *   You should have received a copy of the GNU General Public License
  345. + *   (for example /usr/src/linux/COPYING); if not, write to the Free
  346. + *   Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  347. + */
  348. +
  349. +#define REALLY_SLOW_IO
  350. +#include <asm/io.h>
  351. +
  352. +#include <linux/string.h>
  353. +#include <linux/sched.h>
  354. +#include <linux/timer.h>
  355. +#include <asm/io.h>
  356. +#include <linux/hdreg.h>
  357. +#include <linux/signal.h>
  358. +#include <linux/autoconf.h>
  359. +
  360. +#ifdef LINKED_IN_KERNEL
  361. +# define MAYBE_STATIC static
  362. +#else
  363. +# include <linux/module.h>
  364. +# define MAYBE_STATIC
  365. +#endif
  366. +
  367. +#include "version.h"
  368. +
  369. +/***************************************************************************/
  370. +
  371. +/* Configuration options which may be set when loading the driver. */
  372. +
  373. +/* Major device number. */
  374. +MAYBE_STATIC int nec260_major = 26;
  375. +
  376. +/* IRQ level used.  Only matters if nec260_no_hd is turned on. */
  377. +MAYBE_STATIC int nec260_irq = 14;
  378. +
  379. +/* Base I/O address for the IDE adapter registers. */
  380. +MAYBE_STATIC int nec260_base = HD_DATA;
  381. +
  382. +/* Set this to 1 if the device is configured as the master on the bus. */
  383. +MAYBE_STATIC int nec260_master = 0;
  384. + 
  385. +/* Set this to 1 if the cdrom drive is on the bus by itself. */
  386. +MAYBE_STATIC int nec260_no_hd = 0;
  387. +
  388. +/***************************************************************************/
  389. +
  390. +#define HD_DATA_OFFSET    (HD_DATA   - HD_DATA)
  391. +#define HD_STATUS_OFFSET  (HD_STATUS - HD_DATA)
  392. +#define HD_ERROR_OFFSET   (HD_ERROR  - HD_DATA)
  393. +#define HD_LCYL_OFFSET    (HD_LCYL   - HD_DATA)
  394. +#define HD_HCYL_OFFSET    (HD_HCYL   - HD_DATA)
  395. +#define HD_CURRENT_OFFSET (HD_CURRENT - HD_DATA)
  396. +#define HD_COMMAND_OFFSET (HD_COMMAND - HD_DATA)
  397. +
  398. +#define MAJOR_NR nec260_major
  399. +#define DEVICE_NAME "NEC IDE CD-ROM"
  400. +#define DEVICE_REQUEST do_nec260_request
  401. +#define DEVICE_NR(device) (MINOR(device))
  402. +#define DEVICE_ON(device)
  403. +#define DEVICE_OFF(device)
  404. +#define DEVICE_INTR do_nec260
  405. +
  406. +#include "blk.h"
  407. +
  408. +/* The call interface for binding interrupts changed in 1.1.43 :-( */
  409. +
  410. +#if (KERNEL_MAJOR >= 1) && \
  411. +    (KERNEL_MINOR >= 1) && \
  412. +    (KERNEL_PATCH >= 43)
  413. +# define NO_IRQACTION
  414. +#endif
  415. +
  416. +/***************************************************************************/
  417. +
  418. +/* special command codes for strategy routine. */
  419. +#define CHECK_STATUS 4314
  420. +
  421. +#define CD_BLOCK_SIZE 2048
  422. +
  423. +static void nec260_timeout (unsigned long x);
  424. +static void do_read_callback (void);
  425. +static void do_read_callback_2 (void);
  426. +static int test_read (unsigned int dev, unsigned int block,
  427. +              unsigned int nsect);
  428. +
  429. +
  430. +/* Values to write to the controller registers to start a transaction. */
  431. +
  432. +static char regimage[7] = {
  433. +  0,                          /* HD_PRECOMP */
  434. +  0,                          /* HD_NSECTOR */
  435. +  0,                          /* HD_SECTOR  */
  436. +  (CD_BLOCK_SIZE & 0xff),     /* HD_LCYL   # of bytes to read  (lo) */
  437. +  (CD_BLOCK_SIZE >> 8),       /* HD_HCYL   # of bytes to read  (hi) */
  438. +  0xf0,                       /* HD_CURRENT   (device select) (slave)     */
  439. +  0xa0                        /* HD_COMMAND                         */
  440. +};
  441. +
  442. +
  443. +/* Image of command to be sent to the device for a read.
  444. +   Portions of this will be overwritten to set the sector number.
  445. +   If i actually had documentation for this device, i could probably
  446. +   give these values some meaningful names... */
  447. +
  448. +static char cmdimage[12] = {0x28, 0, 0, 0, 0x0f, 0x54, 0, 0, 1, 0, 0, 0};
  449. +
  450. +static int nec260_request_in_progress = 0;
  451. +static int nec260_waiting_for_int = 0;
  452. +static int nec260_open_count = 0;
  453. +static int nec260_media_changed = 0;
  454. +static void (**nec260_handler_ptr)(void);
  455. +static int the_hd_major;
  456. +static int retrying = 0;
  457. +
  458. +static struct timer_list nec260_timer = {NULL, NULL, 0, 0, nec260_timeout};
  459. +
  460. +/* The transfer buffer. */
  461. +static char nec260_buf[CD_BLOCK_SIZE];
  462. +static int  nec260_bn = -1;
  463. +
  464. +/* The dummy request which we use to plug up the HD queue. */
  465. +static struct request plug;
  466. +
  467. +/* Symbols from hd.c. */
  468. +extern int the_nec260_major;
  469. +extern void (*do_hd)(void);
  470. +#ifdef CONFIG_BLK_DEV_HD1
  471. +extern void (*do_hd1)(void);
  472. +#endif
  473. +
  474. +
  475. +/***************************************************************************/
  476. +
  477. +/*
  478. + * Wait until the controller is idle.
  479. + * Returns the status field; if it has the bit BUSY_STAT set,
  480. + * we timed out.
  481. + */
  482. +static int controller_busy (void)
  483. +{
  484. +  int retries = 100000;
  485. +  unsigned char status;
  486. +
  487. +  do 
  488. +    {
  489. +      status = inb_p (nec260_base + HD_STATUS_OFFSET);
  490. +    } while ((status & BUSY_STAT) && --retries);
  491. +#ifdef SHY_DEVICE
  492. +  {
  493. +    static doneonce = 0;
  494. +    if (status == 0xff && !doneonce)
  495. +      status = 0;
  496. +    doneonce = 1;
  497. +  }
  498. +#endif
  499. +  return status;
  500. +}
  501. +
  502. +
  503. +/*
  504. + * Wait for the controller to be ready to receive a command.
  505. + * Returns 0 if successful, -1 if we timed out.
  506. + */
  507. +static inline int wait_DRQ (void)
  508. +{
  509. +  int retries = 100000;
  510. +
  511. +  while (--retries > 0)
  512. +    if (inb_p (nec260_base + HD_STATUS_OFFSET) & DRQ_STAT)
  513. +      return 0;
  514. +  return -1;
  515. +}
  516. +
  517. +
  518. +/*
  519. + * Stick a dummy request at the head of the HD request queue
  520. + * to prevent any HD activity while we're using the controller.
  521. + * The HD queue must be empty.
  522. + */
  523. +static void plug_hd (void)
  524. +{
  525. +  if (nec260_no_hd)
  526. +    printk ("nec260: spurious call to plug_hd\n");
  527. +  else
  528. +    { 
  529. +      cli ();  /* safety */
  530. +      if (blk_dev[the_hd_major].current_request != NULL)
  531. +    {
  532. +      printk ("nec260 (plug_hd): hd already active!\n");
  533. +      return;
  534. +    }
  535. +      blk_dev[the_hd_major].current_request = &plug;
  536. +      plug.dev = -1;
  537. +      plug.next = NULL;
  538. +      
  539. +      /* exits with ints clear */
  540. +    }
  541. +}
  542. +
  543. +
  544. +/*
  545. + * Remove the dummy request from the start of the HD queue.
  546. + */
  547. +static void unplug_hd (void)
  548. +{
  549. +  if (nec260_no_hd)
  550. +    printk ("nec260: spurious call to unplug_hd\n");
  551. +  else
  552. +    { 
  553. +      cli ();  /* safety */
  554. +      if (blk_dev[the_hd_major].current_request != &plug) 
  555. +    {
  556. +      printk ("nec260 (unplug_hd): hd not plugged!\n");
  557. +      return;
  558. +    }
  559. +      blk_dev[the_hd_major].current_request = plug.next;
  560. +      (blk_dev[the_hd_major].request_fn) ();
  561. +    }
  562. +}
  563. +
  564. +
  565. +/*
  566. + * Unplug the HD queue and end a idecd request.
  567. + */
  568. +static void end_read_request (int flag)
  569. +{
  570. +  if (! nec260_no_hd)
  571. +    unplug_hd ();
  572. +  end_request (flag);
  573. +  nec260_request_in_progress = 0;
  574. +}
  575. +
  576. +
  577. +/*
  578. + * Transfer as much data as we can from NEC260_BUF to the output buffer.
  579. + */
  580. +static void
  581. +nec260_transfer(void)
  582. +{
  583. +  long offs;
  584. +
  585. +  while (CURRENT -> nr_sectors > 0 && nec260_bn == CURRENT -> sector / 4)
  586. +    {
  587. +      offs = (CURRENT -> sector & 3) * 512;
  588. +      memcpy (CURRENT -> buffer, nec260_buf + offs, 512);
  589. +      CURRENT -> nr_sectors--;
  590. +      CURRENT -> sector++;
  591. +      CURRENT -> buffer += 512;
  592. +    }
  593. +}
  594. +
  595. +
  596. +/*
  597. + * Invalidate any data saved in our internal buffer
  598. + */
  599. +static void
  600. +nec260_invalidate_buffers (void)
  601. +{
  602. +  nec260_bn = -1;
  603. +}
  604. +
  605. +
  606. +/*
  607. + * Complete a read request with status STAT, and call the request routine
  608. + * to start off the next one.
  609. + */
  610. +static void complete_read_request (int stat)
  611. +{
  612. +  del_timer (&nec260_timer);    /* Cancel the timeout */
  613. +  end_read_request (stat);
  614. +  cli ();
  615. +  do_nec260_request ();
  616. +}
  617. +
  618. +
  619. +/*
  620. + * Called when our timer goes off.
  621. + */
  622. +static void nec260_timeout (unsigned long x)
  623. +{
  624. +  /* Ignore if we're not waiting for an interrupt. */
  625. +  if (! nec260_waiting_for_int) return;
  626. +
  627. +  /* Complete the request with error status. */
  628. +  nec260_waiting_for_int = 0;
  629. +  printk ("nec260: request timed out\n");
  630. +  if (*nec260_handler_ptr == do_read_callback ||
  631. +      *nec260_handler_ptr == do_read_callback_2)
  632. +    *nec260_handler_ptr = NULL;
  633. +  else
  634. +    printk ("nec260: funny value for interrupt handler\n");
  635. +  complete_read_request (0);
  636. +}
  637. +
  638. +/*
  639. + * Interrupt routine to swallow the extra interrupt from the device.
  640. + */
  641. +static void do_read_callback_2 (void)
  642. +{
  643. +  int stat;
  644. +
  645. +  *nec260_handler_ptr = NULL;
  646. +
  647. +  if (! nec260_waiting_for_int) 
  648. +    {
  649. +      printk ("nec260 (do_read_callback_2): spurious call?\n");
  650. +      return;
  651. +    }
  652. +
  653. +  nec260_waiting_for_int = 0;
  654. +
  655. +  /* Check error flag and complete the I/O. */
  656. +  stat = inb (nec260_base + HD_ERROR_OFFSET);
  657. +  stat = ((stat & ERR_STAT) == 0);
  658. +  complete_read_request (stat);
  659. +}
  660. +
  661. +
  662. +/*
  663. + * Interrupt routine.  Called when a read request has completed.
  664. + */
  665. +static void do_read_callback (void)
  666. +{
  667. +  int stat, len, thislen;
  668. +
  669. +  if (! nec260_waiting_for_int) 
  670. +    {
  671. +      printk ("nec260 (do_read_callback): spurious call?\n");
  672. +      return;
  673. +    }
  674. +
  675. +  nec260_waiting_for_int = 0;
  676. +
  677. +  /* Check for errors. */
  678. +  stat = inb (nec260_base + HD_ERROR_OFFSET);
  679. +
  680. +  if (stat & ERR_STAT)
  681. +    stat = 0;
  682. +  else
  683. +    {
  684. +      if (CURRENT->cmd != CHECK_STATUS)
  685. +    {
  686. +      /* Error bit not set.
  687. +         Read the device registers to see how much data is waiting. */
  688. +      len = inb_p (nec260_base + HD_LCYL_OFFSET) +
  689. +               256 * inb_p (nec260_base + HD_HCYL_OFFSET);
  690. +
  691. +      /* Read the data into our buffer. */
  692. +      thislen = len;
  693. +      if (thislen > sizeof (nec260_buf)) thislen = sizeof (nec260_buf);
  694. +      insw (nec260_base + HD_DATA_OFFSET, nec260_buf, thislen/2);
  695. +      len -= thislen;
  696. +
  697. +      /* Warn if the size of the data from the device is
  698. +         larger than the buffer. */
  699. +      if (len > 0)
  700. +        {
  701. +          printk ("nec260: discarding %x bytes\n", len);
  702. +          while (len > 0) 
  703. +        {
  704. +          (void) inw_p (nec260_base + HD_DATA_OFFSET);
  705. +          len -= 2;
  706. +        }
  707. +        }
  708. +    }
  709. +
  710. +      /* Check for tray open/disk changed.
  711. +     For some reason, these don't set the `error' bit. */
  712. +      if (stat == 0x24)
  713. +    {
  714. +      /* Tray open.  The request fails. */
  715. +      printk ("nec260: tray open\n");
  716. +      nec260_invalidate_buffers ();
  717. +      nec260_media_changed = 1;
  718. +      stat = 0;
  719. +    }
  720. +      else if (stat == 0x64)
  721. +    {
  722. +      /* Media changed.  Try the operation again. */
  723. +      printk ("nec260: media change\n");
  724. +      nec260_invalidate_buffers ();
  725. +      nec260_media_changed = 1;
  726. +      if (CURRENT->cmd != CHECK_STATUS && !retrying)
  727. +        {
  728. +          del_timer (&nec260_timer);
  729. +          retrying = 1;
  730. +          test_read (MINOR (CURRENT->dev),
  731. +             CURRENT->sector, CURRENT->nr_sectors);
  732. +          return;
  733. +        }
  734. +      stat = 0;
  735. +    }
  736. +      else if (CURRENT->cmd == CHECK_STATUS)
  737. +    stat = 1;
  738. +      else
  739. +    {
  740. +      /* Copy as much as we can into the output buffer. */
  741. +      nec260_bn = CURRENT->sector / 4;
  742. +      nec260_transfer ();
  743. +
  744. +      stat = 1;
  745. +    }
  746. +    }
  747. +
  748. +  /* If there was an error, complete the request now with an error.
  749. +     But if the read is successful, the device is going to be sending
  750. +     us another interrupt.  It likes long goodbyes, i guess.  Anyway,
  751. +     wait until we see this extra interrupt before ending the request. */
  752. +  if (stat && CURRENT->cmd != CHECK_STATUS)
  753. +    {
  754. +      *nec260_handler_ptr = do_read_callback_2;
  755. +      nec260_waiting_for_int = 1;
  756. +    }
  757. +  else
  758. +    complete_read_request (stat);
  759. +}
  760. + 
  761. +
  762. +/*
  763. + * Start a read request from the CD-ROM.
  764. + * Returns 0 if the request was started successfully,
  765. + *  -1 if there was an error.
  766. + * Note: The NSECT arg is presently ignored; we always read exactly
  767. + *       one block.
  768. + */
  769. +static int do_read (unsigned int dev, unsigned int block, unsigned int nsect)
  770. +{
  771. +  int i;
  772. +  char *the_regimage;
  773. +  char check_status_regimage[sizeof (regimage)];
  774. +  char *the_cmdimage;
  775. +  char check_status_cmdimage[sizeof (cmdimage)];
  776. +
  777. +  /* Wait for the controller to be idle. */
  778. +  if (controller_busy () & BUSY_STAT) return -1;
  779. +
  780. +  if (CURRENT->cmd == CHECK_STATUS)
  781. +    {
  782. +      the_regimage = check_status_regimage;
  783. +      for (i=0; i<sizeof (check_status_regimage); i++)
  784. +    check_status_regimage[i] = 0;
  785. +      check_status_regimage[HD_CURRENT_OFFSET-1]=regimage[HD_CURRENT_OFFSET-1];
  786. +      check_status_regimage[HD_COMMAND_OFFSET-1]=regimage[HD_COMMAND_OFFSET-1];
  787. +    }
  788. +  else
  789. +    the_regimage = regimage;
  790. +
  791. +  /* Set up the controller registers. */
  792. +  for (i=0; i<sizeof (regimage); i++)
  793. +    outb_p (the_regimage[i], nec260_base + HD_ERROR_OFFSET + i);
  794. +
  795. +  /* Wait for the controller to be ready to receive the comand. */
  796. +  if (controller_busy () & BUSY_STAT) {
  797. +    printk ("nec260: controller busy\n"); return -1;
  798. +  }
  799. +  if (wait_DRQ ()) {
  800. +    printk ("nec260: controller not ready\n"); return -1;
  801. +  }
  802. +  if (controller_busy () & BUSY_STAT) {
  803. +    printk ("nec260: controller busy (2)\n"); return -1;
  804. +  }
  805. +
  806. +  if (CURRENT->cmd == CHECK_STATUS)
  807. +    {
  808. +      the_cmdimage = check_status_cmdimage;
  809. +      for (i=0; i<sizeof (check_status_cmdimage); i++)
  810. +    check_status_cmdimage[i] = 0;
  811. +    }
  812. +  else
  813. +    {
  814. +      /* Write the sector address into the command image. */
  815. +      {
  816. +    union {
  817. +      struct {unsigned char b0, b1, b2, b3;} b;
  818. +      struct {unsigned long l0;} l;
  819. +    } conv;
  820. +    conv.l.l0 = CURRENT->sector / 4;
  821. +    cmdimage[2] = conv.b.b3;
  822. +    cmdimage[3] = conv.b.b2;
  823. +    cmdimage[4] = conv.b.b1;
  824. +    cmdimage[5] = conv.b.b0;
  825. +      }
  826. +      the_cmdimage = cmdimage;
  827. +    }
  828. +
  829. +  /* Send the command to the device. */
  830. +  outsw (nec260_base + HD_DATA_OFFSET, the_cmdimage, sizeof (cmdimage)/2);
  831. +
  832. +  /* Set up our interrupt handler and return. */
  833. +  *nec260_handler_ptr = do_read_callback;
  834. +  nec260_waiting_for_int = 1;
  835. +
  836. +  /* Set up a timeout. */
  837. +  nec260_timer.expires = 500;
  838. +  add_timer (&nec260_timer);
  839. +
  840. +  return 0;
  841. +}
  842. +
  843. +
  844. +/*
  845. + * Start a read request.
  846. + * If there is an error starting it, terminate the current request
  847. + * immediately with an error.
  848. + */
  849. +static int test_read (unsigned int dev, unsigned int block,
  850. +              unsigned int nsect)
  851. +{
  852. +  int stat;
  853. +  stat = do_read (dev, block, nsect);
  854. +
  855. +  if (stat)
  856. +    end_read_request (0);
  857. +  return 1;
  858. +}
  859. +
  860. +
  861. +/*
  862. + * I/O request routine called from kernel.
  863. + */
  864. +static void do_nec260_request (void)
  865. +{
  866. +  unsigned int block,dev;
  867. +  unsigned int nsect;
  868. +
  869. +  /* Don't do anything if we're waiting for a request to complete.
  870. +     (Can this actually happen?) */
  871. +  if (nec260_request_in_progress) return;
  872. +
  873. + repeat:
  874. +  cli (); /* safety */
  875. +  nec260_request_in_progress = 0;
  876. +
  877. +  /* Return if our queue is plugged. */
  878. +  if (!(CURRENT) || CURRENT->dev < 0) return;
  879. +
  880. +  /* Get the next request on the queue. */
  881. +  INIT_REQUEST;
  882. +  dev = MINOR (CURRENT->dev);
  883. +  block = CURRENT->sector;
  884. +  nsect = CURRENT->nr_sectors;
  885. +
  886. +  /* Return if there wasn't one. */
  887. +  if (CURRENT == NULL || CURRENT -> sector == -1)
  888. +    return;
  889. +
  890. +  /* We can only read. */
  891. +  if (CURRENT -> cmd != READ && CURRENT->cmd != CHECK_STATUS)
  892. +    {
  893. +      printk ("nec260: bad cmd %d\n", CURRENT -> cmd);
  894. +      end_request (0);
  895. +      goto repeat;
  896. +    }
  897. +
  898. +  if (CURRENT->cmd != CHECK_STATUS)
  899. +    {
  900. +      /* Try to satisfy the request from the buffer. */
  901. +      nec260_transfer ();
  902. +
  903. +      /* If we got the entire request, we're done. */
  904. +      if (CURRENT->nr_sectors == 0) 
  905. +    {
  906. +      end_request (1);
  907. +      goto repeat;
  908. +    }
  909. +    }
  910. +
  911. +  /* If the HD is currently active,  return - we must wait for it to finish.
  912. +     If it is idle (no requests in the queue), plug up the queue with a dummy
  913. +     request until we're done using the controller. */
  914. +  if (! nec260_no_hd)
  915. +    {
  916. +      if (blk_dev[the_hd_major].current_request) return;
  917. +      plug_hd ();
  918. +    }
  919. +  nec260_request_in_progress = 1;
  920. +
  921. +  retrying = 0;
  922. +  if (!test_read (dev, block, nsect))
  923. +    goto repeat;
  924. +
  925. +  sti ();
  926. +  return;
  927. +}
  928. +
  929. +
  930. +/*
  931. + * Open the device.
  932. + */
  933. +
  934. +static int
  935. +nec260_open (struct inode *ip, struct file *fp)
  936. +{
  937. +  /* should check that h/w is available... */
  938. +
  939. +  /* no write access */
  940. +  if (fp->f_mode & 2) return -EROFS;
  941. +
  942. +  if (!nec260_open_count)
  943. +    {
  944. +      nec260_invalidate_buffers ();
  945. +
  946. +      /* should check that there's a disk in the drive? */
  947. +    }
  948. +
  949. +  /* Opened ok.  Count this access and return success. */
  950. +  ++nec260_open_count;
  951. +#ifndef LINKED_IN_KERNEL
  952. +  MOD_INC_USE_COUNT;
  953. +#endif
  954. +  return 0;
  955. +}
  956. +
  957. +
  958. +/*
  959. + * Close down the device.  Invalidate all cached blocks.
  960. + */
  961. +
  962. +static void
  963. +nec260_release (struct inode *inode, struct file *file)
  964. +{
  965. +  --nec260_open_count;
  966. +  if (nec260_open_count < 0)
  967. +    {
  968. +      printk ("nec260: inconsistent open count %d\n", nec260_open_count);
  969. +      nec260_open_count = 0;
  970. +    }
  971. +
  972. +  if (nec260_open_count == 0)
  973. +    {
  974. +      nec260_invalidate_buffers ();
  975. +      sync_dev (inode->i_rdev);
  976. +      invalidate_buffers (inode->i_rdev);
  977. +    }
  978. +#ifndef LINKED_IN_KERNEL
  979. +  MOD_DEC_USE_COUNT;
  980. +#endif
  981. +}
  982. +
  983. +
  984. +static
  985. +void nec260_do_check_status (dev_t full_dev)
  986. +{
  987. +  struct request check_status_req;
  988. +  struct semaphore sem = MUTEX_LOCKED;
  989. +
  990. +  check_status_req.dev = full_dev;
  991. +  check_status_req.cmd = CHECK_STATUS;
  992. +  check_status_req.errors = 0;
  993. +  check_status_req.sector = 0;
  994. +  check_status_req.nr_sectors = 0;
  995. +  check_status_req.current_nr_sectors = 0;
  996. +  check_status_req.buffer = NULL;
  997. +  check_status_req.sem = &sem;
  998. +  check_status_req.bh = NULL;
  999. +  check_status_req.bhtail = NULL;
  1000. +  check_status_req.next = NULL;
  1001. +
  1002. +  cli ();
  1003. +  if (CURRENT == NULL)
  1004. +    {
  1005. +      CURRENT = &check_status_req;
  1006. +      do_nec260_request ();
  1007. +    }
  1008. +  else
  1009. +    {
  1010. +      check_status_req.next = CURRENT;
  1011. +      CURRENT->next = &check_status_req;
  1012. +    }
  1013. +  sti ();
  1014. +
  1015. +  down (&sem);
  1016. +}
  1017. +
  1018. +
  1019. +static
  1020. +int nec260_disk_change (dev_t full_dev)
  1021. +{
  1022. +  int retval, target;
  1023. +
  1024. +  target = MINOR (full_dev);
  1025. +
  1026. +  if (target > 0)
  1027. +    {
  1028. +      printk ("nec260 (nec260_disk_change): invalid device %d\n", target);
  1029. +      return 0;
  1030. +    }
  1031. +
  1032. +  if (nec260_media_changed == 0)
  1033. +    nec260_do_check_status (full_dev);
  1034. +
  1035. +  retval = nec260_media_changed;
  1036. +  nec260_media_changed = 0;
  1037. +
  1038. +  printk ("nec260: disk change %d\n", retval);
  1039. +
  1040. +  return retval;
  1041. +}
  1042. +
  1043. +
  1044. +static void nec260_interrupt (int unused)
  1045. +{
  1046. +  void (*handler)(void) = DEVICE_INTR;
  1047. +    
  1048. +  DEVICE_INTR = NULL;
  1049. +  if (!handler)
  1050. +    printk ("nec260: unexpected interrupt\n");
  1051. +  else
  1052. +    handler();
  1053. +  sti();
  1054. +}
  1055. +
  1056. +
  1057. +#ifndef NO_IRQACTION
  1058. +/*
  1059. + * This is the cdrom IRQ description. The SA_INTERRUPT in sa_flags
  1060. + * means we run the IRQ-handler with interrupts disabled.
  1061. + */
  1062. +static struct sigaction nec260_sigaction = {
  1063. +    nec260_interrupt,
  1064. +    0,
  1065. +    SA_INTERRUPT,
  1066. +    NULL
  1067. +};
  1068. +#endif /* ! NO_IRQACTION */
  1069. +
  1070. +
  1071. +
  1072. +static struct file_operations nec260_fops = {
  1073. +    NULL,            /* lseek - default */
  1074. +    block_read,        /* read - general block-dev read */
  1075. +    block_write,        /* write - general block-dev write */
  1076. +    NULL,            /* readdir - bad */
  1077. +    NULL,            /* select */
  1078. +    NULL,             /* ioctl */
  1079. +    NULL,            /* mmap */
  1080. +    nec260_open,        /* open */
  1081. +        nec260_release,        /* release */
  1082. +        NULL,                    /* fsync */  
  1083. +        NULL,                    /* fasync */  
  1084. +        nec260_disk_change,    /* check_media_change */  
  1085. +        NULL,                    /* revalidate */  
  1086. +};
  1087. +
  1088. +
  1089. +MAYBE_STATIC int init_module (void)
  1090. +{
  1091. +  /* Find the major numbe of the HD on our IDE bus. */
  1092. +  the_hd_major = HD_MAJOR;
  1093. +#ifdef CONFIG_BLK_DEV_HD1
  1094. +  if (nec260_base == HD1_DATA)
  1095. +    the_hd_major = HD1_MAJOR;
  1096. +#endif
  1097. +
  1098. +  /* Register ourselves with the kernel. */
  1099. +  if (register_blkdev (nec260_major, "nec260", &nec260_fops) != 0) 
  1100. +    {
  1101. +      printk("nec260: Unable to get major %d for NEC CDR-260\n", nec260_major);
  1102. +      return -EIO;
  1103. +    }
  1104. +
  1105. +  printk ("nec260: registered with major #%d\n", nec260_major);
  1106. +
  1107. +  /* Install our device request routine. */
  1108. +  blk_dev[nec260_major].request_fn = DEVICE_REQUEST;
  1109. +  read_ahead[nec260_major] = 4;
  1110. +
  1111. +  /* Set the proper device select code. */
  1112. +  if (nec260_master)
  1113. +    regimage[5] = 0xe0;
  1114. +  else
  1115. +    regimage[5] = 0xf0;
  1116. +
  1117. +  if (nec260_no_hd)
  1118. +    {
  1119. +      /* Set up the interrupt. */
  1120. +      do_nec260 = NULL;
  1121. +      nec260_handler_ptr = &do_nec260;
  1122. +#ifdef NO_IRQACTION
  1123. +      if (request_irq (nec260_irq, nec260_interrupt, SA_INTERRUPT, "nec260"))
  1124. +#else
  1125. +      if (irqaction (nec260_irq, &nec260_sigaction))
  1126. +#endif
  1127. +    {
  1128. +      printk ("Unable to get IRQ%d for NEC CDR-260 CD-ROM\n", nec260_irq);
  1129. +      unregister_blkdev (nec260_major, "nec260");
  1130. +      return -EIO;
  1131. +    }
  1132. +    }
  1133. +  else
  1134. +    {
  1135. +      /* tell hd.c our major number */
  1136. +      the_nec260_major = nec260_major;
  1137. +
  1138. +      /* Set up nec260_handler_ptr to point to the HD interrupt vector. */
  1139. +      nec260_handler_ptr = &do_hd;
  1140. +#ifdef CONFIG_BLK_DEV_HD1
  1141. +      if (nec260_base == HD1_DATA)
  1142. +    the_hd_major = &do_hd1;
  1143. +#endif
  1144. +    }
  1145. +
  1146. +  return 0;
  1147. +}
  1148. +
  1149. +#ifdef LINKED_IN_KERNEL
  1150. +
  1151. +unsigned long nec260_init (unsigned long mem_start, unsigned long mem_end)
  1152. +{
  1153. +  init_module ();
  1154. +  return mem_start;
  1155. +}
  1156. +
  1157. +#else
  1158. +
  1159. +void cleanup_module (void)
  1160. +{
  1161. +  if (MOD_IN_USE)
  1162. +    printk("nec260: device busy, remove delayed\n");
  1163. +
  1164. +  if (unregister_blkdev (nec260_major, "nec260") != 0)
  1165. +    printk ("nec260: cleanup_module failed\n");
  1166. +  else 
  1167. +    {
  1168. +      printk ("nec260: cleanup_module succeeded\n");
  1169. +      if (nec260_no_hd)
  1170. +    free_irq (nec260_irq);
  1171. +      else
  1172. +    the_nec260_major = 0;
  1173. +    }
  1174. +}
  1175. +
  1176. +#endif
  1177. diff -u --recursive --new-file linux-1.1.58/drivers/block/sonycd535.c linux/drivers/block/sonycd535.c
  1178. --- linux-1.1.58/drivers/block/sonycd535.c    Wed Dec 31 18:00:00 1969
  1179. +++ linux/drivers/block/sonycd535.c    Wed Oct 26 23:02:00 1994
  1180. @@ -0,0 +1,1537 @@
  1181. +/*
  1182. + * Sony CDU-535 interface device driver
  1183. + *
  1184. + * This is a modified version of the CDU-31A device driver (see below).
  1185. + * Changes were made using documentation for the CDU-531 (which Sony
  1186. + * assures me is very similar to the 535) and partial disassembly of the
  1187. + * DOS driver.  I used Minyard's driver and replaced the the CDU-31A 
  1188. + * commands with the CDU-531 commands.  This was complicated by a different
  1189. + * interface protocol with the drive.  The driver is still polled.
  1190. + *
  1191. + * Data transfer rate is about 110 Kb/sec, theoretical maximum is 150 Kb/sec.
  1192. + * I tried polling without the sony_sleep during the data transfers but
  1193. + * it did not speed things up any.
  1194. + *
  1195. + *  5/23/93 (rgj) changed the major number to 21 to get rid of conflict
  1196. + * with CDU-31A driver.  This is the also the number from the Linux
  1197. + * Device Driver Registry for the Sony Drive.  Hope nobody else is using it.
  1198. + *
  1199. + *  8/29/93 (rgj) remove the configuring of the interface board address
  1200. + * from the top level configuration, you have to modify it in this file.
  1201. + *
  1202. + * Things to do:
  1203. + *    - handle errors and status better, put everything into a single word
  1204. + *    - use interrupts, DMA
  1205. + *
  1206. + *  Known Bugs:
  1207. + *    -
  1208. + *
  1209. + *   Ron Jeppesen (ronj.an@site007.saic.com)
  1210. + *
  1211. + *
  1212. + *------------------------------------------------------------------------
  1213. + * Sony CDROM interface device driver.
  1214. + *
  1215. + * Corey Minyard (minyard@wf-rch.cirr.com) (CDU-535 complaints to ronj above)
  1216. + *
  1217. + * Colossians 3:17
  1218. + *
  1219. + * The Sony interface device driver handles Sony interface CDROM
  1220. + * drives and provides a complete block-level interface as well as an
  1221. + * ioctl() interface compatible with the Sun (as specified in
  1222. + * include/linux/cdrom.h).  With this interface, CDROMs can be
  1223. + * accessed and standard audio CDs can be played back normally.
  1224. + *
  1225. + * This interface is (unfortunatly) a polled interface.  This is
  1226. + * because most Sony interfaces are set up with DMA and interrupts
  1227. + * disables.  Some (like mine) do not even have the capability to
  1228. + * handle interrupts or DMA.  For this reason you will see a lot of
  1229. + * the following:
  1230. + *
  1231. + *   retry_count = jiffies+ SONY_JIFFIES_TIMEOUT;
  1232. + *   while ((retry_count > jiffies) && (! <some condition to wait for))
  1233. + *   {
  1234. + *      while (handle_sony_cd_attention())
  1235. + *         ;
  1236. + *
  1237. + *      sony_sleep();
  1238. + *   }
  1239. + *   if (the condition not met)
  1240. + *   {
  1241. + *      return an error;
  1242. + *   }
  1243. + *
  1244. + * This ugly hack waits for something to happen, sleeping a little
  1245. + * between every try.  it also handles attentions, which are
  1246. + * asyncronous events from the drive informing the driver that a disk
  1247. + * has been inserted, removed, etc.
  1248. + *
  1249. + * One thing about these drives: They talk in MSF (Minute Second Frame) format.
  1250. + * There are 75 frames a second, 60 seconds a minute, and up to 75 minutes on a
  1251. + * disk.  The funny thing is that these are sent to the drive in BCD, but the
  1252. + * interface wants to see them in decimal.  A lot of conversion goes on.
  1253. + *
  1254. + *  Copyright (C) 1993  Corey Minyard
  1255. + *
  1256. + *  This program is free software; you can redistribute it and/or modify
  1257. + *  it under the terms of the GNU General Public License as published by
  1258. + *  the Free Software Foundation; either version 2 of the License, or
  1259. + *  (at your option) any later version.
  1260. + *
  1261. + *  This program is distributed in the hope that it will be useful,
  1262. + *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  1263. + *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  1264. + *  GNU General Public License for more details.
  1265. + *
  1266. + *  You should have received a copy of the GNU General Public License
  1267. + *  along with this program; if not, write to the Free Software
  1268. + *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  1269. + *
  1270. + */
  1271. +
  1272. +
  1273. +#include <linux/config.h>
  1274. +#ifdef CONFIG_CDU535
  1275. +
  1276. +#include <linux/errno.h>
  1277. +#include <linux/signal.h>
  1278. +#include <linux/sched.h>
  1279. +#include <linux/timer.h>
  1280. +#include <linux/fs.h>
  1281. +#include <linux/kernel.h>
  1282. +#include <linux/hdreg.h>
  1283. +#include <linux/genhd.h>
  1284. +
  1285. +#define REALLY_SLOW_IO
  1286. +#include <asm/system.h>
  1287. +#include <asm/io.h>
  1288. +#include <asm/segment.h>
  1289. +
  1290. +#include <linux/cdrom.h>
  1291. +#include <linux/sonycd535.h>
  1292. +
  1293. +#define MAJOR_NR CDU535_CDROM_MAJOR
  1294. +#include "blk.h"
  1295. +
  1296. +/*
  1297. + * this is the base address of the interface card for the Sony CDU535
  1298. + * CDROM drive.  If your jumpers are set for an address other than
  1299. + * this one (the default), change the following line to the
  1300. + * proper address.
  1301. + */
  1302. +#define CDU535_ADDRESS    (0x340)
  1303. +
  1304. +#define DEBUG
  1305. +
  1306. +/*
  1307. + *  SONY535_BUFFER_SIZE determines the size of internal buffer used
  1308. + *  by the drive.  It must be at least 2K and the larger the buffer
  1309. + *  the better the transfer rate.  It does however take system memory.
  1310. + *   On my system I get the following transfer rates using dd to read
  1311. + *  10 Mb off /dev/cdrom.
  1312. + *
  1313. + *      8K buffer         43 Kb/sec
  1314. + *    16K buffer         66 Kb/sec
  1315. + *    32K buffer         91 Kb/sec
  1316. + *    64K buffer        111 Kb/sec
  1317. + *    128K buffer        123 Kb/sec
  1318. + *    512K buffer        123 Kb/sec
  1319. + */
  1320. +#define SONY535_BUFFER_SIZE    (64*1024)
  1321. +
  1322. +/*
  1323. + *  if LOCK_DOORS is defined then the eject button is disabled while
  1324. + * the device is open.
  1325. + */
  1326. +#define LOCK_DOORS
  1327. +
  1328. +static int read_subcode(void);
  1329. +static void sony_get_toc(void);
  1330. +static int cdu_open( struct inode *inode, struct file *filp );
  1331. +static inline unsigned int int_to_bcd(unsigned int val);
  1332. +static unsigned int bcd_to_int(unsigned int bcd);
  1333. +static int do_sony_cmd( Byte *cmd, int nCmd, Byte status[2], 
  1334. +                 Byte *response, int nResponse, int ignoreStatusBit7 );
  1335. +
  1336. +/* The base I/O address of the Sony Interface.  This is a variable (not a
  1337. +   #define) so it can be easily changed via some future ioctl() */
  1338. +static unsigned short sony_cd_base_io = CDU535_ADDRESS;
  1339. +
  1340. +/*
  1341. + * The following are I/O addresses of the various registers for the drive.  The
  1342. + * comment for the base address also applies here.
  1343. + */
  1344. +static unsigned short select_unit_reg;
  1345. +static unsigned short result_reg;
  1346. +static unsigned short command_reg;
  1347. +static unsigned short read_status_reg;
  1348. +static unsigned short data_reg;
  1349. +
  1350. +static int initialized = 0;                /* Has the drive been initialized? */
  1351. +static int sony_disc_changed = 1;          /* Has the disk been changed
  1352. +                                              since the last check? */
  1353. +static int sony_toc_read = 0;              /* Has the table of contents been
  1354. +                                              read? */
  1355. +static unsigned int sony_buffer_size;      /* Size in bytes of the read-ahead
  1356. +                                              buffer. */
  1357. +static unsigned int sony_buffer_sectors;   /* Size (in 2048 byte records) of
  1358. +                                              the read-ahead buffer. */
  1359. +static unsigned int sony_usage = 0;        /* How many processes have the
  1360. +                                              drive open. */
  1361. +
  1362. +static int sony_first_block = -1;          /* First OS block (512 byte) in
  1363. +                                              the read-ahead buffer */
  1364. +static int sony_last_block = -1;           /* Last OS block (512 byte) in
  1365. +                                              the read-ahead buffer */
  1366. +
  1367. +static struct s535_sony_toc *sony_toc;           /* Points to the table of
  1368. +                                                    contents. */
  1369. +static struct s535_sony_subcode *last_sony_subcode; /* Points to the last
  1370. +                                                    subcode address read */
  1371. +static unsigned char *sony_buffer;               /* Points to the read-ahead
  1372. +                                                    buffer */
  1373. +static int sony_inuse = 0;        /* is the drive in use? Only one
  1374. +                       open at a time allowed */
  1375. +
  1376. +/*
  1377. + * The audio status uses the values from read subchannel data as specified
  1378. + * in include/linux/cdrom.h.
  1379. + */
  1380. +static int sony_audio_status = CDROM_AUDIO_NO_STATUS;
  1381. +
  1382. +/*
  1383. + * The following are a hack for pausing and resuming audio play.  The drive
  1384. + * does not work as I would expect it, if you stop it then start it again,
  1385. + * the drive seeks back to the beginning and starts over.  This holds the
  1386. + * position during a pause so a resume can restart it.  It uses the
  1387. + * audio status variable above to tell if it is paused.
  1388. + *   I just kept the CDU-31A driver behavior rather than using the PAUSE
  1389. + * command on the CDU-535.
  1390. + */
  1391. +static unsigned char cur_pos_msf[3] = { 0, 0, 0 };
  1392. +static unsigned char final_pos_msf[3] = { 0, 0, 0 };
  1393. +
  1394. +
  1395. +/*
  1396. + * This routine returns 1 if the disk has been changed since the last
  1397. + * check or 0 if it hasn't.
  1398. + */
  1399. +static int
  1400. +cdu535_check_media_change(dev_t full_dev)
  1401. +{
  1402. +   int retval, target;
  1403. +
  1404. +   target = MINOR(full_dev);
  1405. +
  1406. +   if (target > 0) {
  1407. +      printk("Sony CD-ROM request error: invalid device.\n");
  1408. +      return 0;
  1409. +   }
  1410. +
  1411. +   /* if driver is not initialized, always return 0 */
  1412. +   retval = ( initialized ? sony_disc_changed : 0 );
  1413. +   sony_disc_changed = 0;
  1414. +   return retval;
  1415. +}
  1416. +
  1417. +
  1418. +/*
  1419. + * Wait a little while (used for polling the drive).  If in initialization,
  1420. + * setting a timeout doesn't work, so just loop for a while  (we trust
  1421. + * that the sony_sleep() call is protected by a test for proper jiffies count).
  1422. + */
  1423. +static inline void
  1424. +sony_sleep(void)
  1425. +{
  1426. +   current->state = TASK_INTERRUPTIBLE;
  1427. +   current->timeout = jiffies;
  1428. +   schedule();
  1429. +}
  1430. +
  1431. +/*------------------start of SONY CDU535 very specific ---------------------*/
  1432. +
  1433. +/****************************************************************************
  1434. + * void select_unit( int unit_no )
  1435. + *
  1436. + *  Select the specified unit (0-3) so that subsequent commands reference it
  1437. + ****************************************************************************/
  1438. +static void 
  1439. +select_unit( int unit_no )
  1440. +{
  1441. +   unsigned int select_mask = ~(1 << unit_no);
  1442. +   outb( select_mask, select_unit_reg );
  1443. +}  /* select_unit() */
  1444. +
  1445. +/***************************************************************************
  1446. + * int read_result_reg( unsigned char *data_ptr )
  1447. + *
  1448. + *  Read a result byte from the Sony CDU controller, store in location pointed
  1449. + * to by data_ptr.  Return zero on success, TIME_OUT if we did not receive
  1450. + * data.
  1451. + ***************************************************************************/
  1452. +static int 
  1453. +read_result_reg( unsigned char *data_ptr )
  1454. +{
  1455. +   int retry_count;
  1456. +   int read_status;
  1457. +  
  1458. +   retry_count = jiffies + SONY_JIFFIES_TIMEOUT;
  1459. +   while ( retry_count > jiffies ) 
  1460. +   {
  1461. +      if ( ((read_status=inb(read_status_reg)) & SONY535_RESULT_NOT_READY_BIT) == 0 ) 
  1462. +      {
  1463. +#if 0
  1464. +         printk("read_result_reg(): readStatReg = 0x%x\n", read_status );
  1465. +#endif
  1466. +         *data_ptr = inb(result_reg);
  1467. +         return( 0 );
  1468. +      }
  1469. +      else 
  1470. +      {
  1471. +         sony_sleep();
  1472. +      }
  1473. +   }
  1474. +   printk(" Sony CDROM read_result_reg: TIME OUT!\n");
  1475. +   return( TIME_OUT );
  1476. +}  /* read_result_reg() */
  1477. +
  1478. +/****************************************************************************
  1479. + * int read_exec_status( Byte status[2] )
  1480. + *
  1481. + *  Read the execution status of the last command and put into status. 
  1482. + * Handles reading second status word if available.  Returns 0 on success,
  1483. + * TIME_OUT on failure.
  1484. + ****************************************************************************/
  1485. +static int 
  1486. +read_exec_status( Byte status[2] )
  1487. +{
  1488. +   status[1] = 0;
  1489. +   if ( read_result_reg( &(status[0]) ) != 0 ) return( TIME_OUT );
  1490. +   if ( (status[0] & 0x80) != 0 )  /* byte two follows */
  1491. +   {
  1492. +      if ( read_result_reg( &(status[1]) ) != 0 ) return( TIME_OUT );
  1493. +   }
  1494. +#if 0
  1495. +   printk("read_exec_status: read 0x%x\n", status[0] );
  1496. +   if (status[0] & 0x80) printk(" and 0x%x\n", status[1] );
  1497. +   printk("\n");
  1498. +#endif
  1499. +   return( 0 );
  1500. +}  /* read_exec_status() */
  1501. +
  1502. +/****************************************************************************
  1503. + * int check_drive_status( void )
  1504. + *
  1505. + *  Check the current drive status.  Using this before executing a command
  1506. + * takes care of the problem of unsolicited drive status-2 messages.
  1507. + * Add a check of the audio status if we think the disk is playing.
  1508. + ****************************************************************************/
  1509. +static int 
  1510. +check_drive_status( void )
  1511. +{
  1512. +   Byte status, e_status[2];
  1513. +   int CDD, ATN;
  1514. +   unsigned char cmd;
  1515. +  
  1516. +   select_unit(0);
  1517. +   if ( sony_audio_status == CDROM_AUDIO_PLAY )  /* check status */
  1518. +   {
  1519. +      outb( SONY535_REQUEST_AUDIO_STATUS, command_reg );
  1520. +      if ( read_result_reg( &status ) == 0 ) 
  1521. +      {
  1522. +         switch( status ) 
  1523. +         {
  1524. +            case 0x0:  break;            /* play in progress */
  1525. +            case 0x1:  break;            /* paused */
  1526. +            case 0x3:                /* audio play completed */
  1527. +            case 0x5:                /* play not requested */
  1528. +                       sony_audio_status = CDROM_AUDIO_COMPLETED;
  1529. +                       read_subcode();
  1530. +                       break;
  1531. +            case 0x4:                /* error during play */
  1532. +                       sony_audio_status = CDROM_AUDIO_ERROR;
  1533. +                       break;
  1534. +         }
  1535. +      }
  1536. +   }
  1537. +    /* now check drive status */
  1538. +   outb( SONY535_REQUEST_DRIVE_STATUS_2, command_reg );
  1539. +   if ( read_result_reg( &status ) != 0 ) 
  1540. +      return( TIME_OUT );
  1541. +
  1542. +#if 0
  1543. +   printk("--check_drive_status() got 0x%x\n", status );
  1544. +#endif
  1545. +  
  1546. +   if ( status == 0 ) return( 0 );
  1547. +  
  1548. +   ATN = status & 0xf;
  1549. +   CDD = (status >> 4) & 0xf;
  1550. +  
  1551. +   switch ( ATN ) 
  1552. +   {
  1553. +      case 0x0:
  1554. +                 break;  /* go on to CDD stuff */
  1555. +      case SONY535_ATN_BUSY:
  1556. +                 if ( initialized )
  1557. +                    printk("Sony CDROM error, drive busy\n");
  1558. +                 return( CD_BUSY);
  1559. +      case SONY535_ATN_EJECT_IN_PROGRESS:
  1560. +                 printk("Sony CDROM error, eject in progress\n");
  1561. +                 sony_audio_status = CDROM_AUDIO_INVALID;
  1562. +                 return( CD_BUSY);
  1563. +      case SONY535_ATN_RESET_OCCURRED:
  1564. +      case SONY535_ATN_DISC_CHANGED:
  1565. +      case SONY535_ATN_RESET_AND_DISC_CHANGED:
  1566. +#ifdef DEBUG
  1567. +                 printk("Sony CDROM, reset occurred or disc changed\n");
  1568. +#endif
  1569. +                 sony_disc_changed = 1;
  1570. +                 sony_toc_read = 0;
  1571. +                 sony_audio_status = CDROM_AUDIO_NO_STATUS;
  1572. +                 sony_first_block = -1;
  1573. +                 sony_last_block = -1;
  1574. +                 if (initialized)
  1575. +                 {
  1576. +                    cmd = SONY535_SPIN_UP;
  1577. +                    do_sony_cmd( &cmd,1, e_status, NULL,0, 0 );
  1578. +                    sony_get_toc();
  1579. +                 }
  1580. +                 return( 0 );
  1581. +      default:
  1582. +                 printk("Sony CDROM error, drive busy (ATN=0x%x)\n", ATN );
  1583. +                 return( CD_BUSY );
  1584. +   }
  1585. +   switch ( CDD ) 
  1586. +   {  /* the 531 docs are not helpful in decoding this */
  1587. +      case 0x0:       /* just use the values from the DOS driver */
  1588. +      case 0x2:
  1589. +      case 0xa:
  1590. +                 break;  /* no error */
  1591. +      case 0xc:
  1592. +                 printk("check_drive_status(): CDD = 0xc! Not properly handled!\n");
  1593. +                 return( CD_BUSY );  /* ? */
  1594. +      default:
  1595. +                 return( CD_BUSY );
  1596. +   }
  1597. +   return( 0 );
  1598. +}  /* check_drive_status() */
  1599. +
  1600. +/*****************************************************************************
  1601. + * int do_sony_cmd( Byte *cmd, int n_cmd, Byte status[2], 
  1602. + *                Byte *response, int n_response, int ignore_status_bit7 )
  1603. + *
  1604. + *  Generic routine for executing commands.  The command and its parameters
  1605. + *  should be placed in the cmd[] array, number of bytes in the command is
  1606. + *  stored in nCmd.  The response from the command will be stored in the
  1607. + *  response array.  The number of bytes you expect back (excluding status)
  1608. + *  should be passed in nReponse.  Finally, some
  1609. + *  commands set bit 7 of the return status even when there is no second
  1610. + *  status byte, on these commands set ignoreStatusBit7 TRUE.
  1611. + *    If the command was sent and data recieved back, then we return 0,
  1612. + *  else we return TIME_OUT.  You still have to check the status yourself.
  1613. + *    You should call check_drive_status() before calling this routine
  1614. + *  so that you do not lose notifications of disk changes, etc.
  1615. + ****************************************************************************/
  1616. +static int 
  1617. +do_sony_cmd( Byte *cmd, int n_cmd, Byte status[2], 
  1618. +             Byte *response, int n_response, int ignore_status_bit7 )
  1619. +{
  1620. +   int i;
  1621. +  
  1622. +    /* write out the command */
  1623. +   for ( i=0; i < n_cmd; i++ )
  1624. +      outb( cmd[i], command_reg );
  1625. +  
  1626. +    /* read back the status */
  1627. +   if ( read_result_reg( status ) != 0 )
  1628. +      return( TIME_OUT );
  1629. +   if ( !ignore_status_bit7 && ((status[0] & 0x80) != 0) ) /* get second status byte */
  1630. +   {
  1631. +      if ( read_result_reg( status+1 ) != 0 )
  1632. +         return( TIME_OUT );
  1633. +   }
  1634. +   else
  1635. +   {
  1636. +      status[1] = 0;
  1637. +   }
  1638. +    
  1639. +   /* do not know about when I should read set of data and when not to */
  1640. +   if ( (status[0] & ((ignore_status_bit7 ? 0x7f : 0xff) & 0x8f)) != 0 )
  1641. +      return( 0 );
  1642. +  
  1643. +    /* else, read in rest of data */
  1644. +   for ( i=0; n_response > 0; n_response--, i++ )
  1645. +      if ( read_result_reg( response+i ) != 0 ) return(TIME_OUT);
  1646. +   return( 0 );
  1647. +}  /* do_sony_cmd() */
  1648. +
  1649. +/**************************************************************************
  1650. + * int set_drive_mode( int mode, Byte status[2] )
  1651. + *
  1652. + *  Set the drive mode to the specified value (mode=0 is audio, mode=e0
  1653. + * is mode-1 CDROM
  1654. + **************************************************************************/
  1655. +static int 
  1656. +set_drive_mode( int mode, Byte status[2] )
  1657. +{
  1658. +   Byte cmd_buff[2], ret_buff[1];
  1659. +  
  1660. +   cmd_buff[0] = SONY535_SET_DRIVE_MODE;
  1661. +   cmd_buff[1] = mode;
  1662. +   return( do_sony_cmd( cmd_buff,2, status, ret_buff,1, 1 ) );
  1663. +}  /* set_drive_mode() */
  1664. +
  1665. +/***************************************************************************
  1666. + * int seek_and_read_N_blocks( Byte params[], int n_blocks, Byte status[2], 
  1667. + *                             Byte *data_buff, int buff_size )
  1668. + *
  1669. + *  Read n_blocks of data from the CDROM starting at position params[0:2],
  1670. + *  number of blocks in stored in params[3:5] -- both these are already
  1671. + *  int bcd format.
  1672. + *  Transfer the data into the buffer pointed at by data_buff.  buff_size
  1673. + *  gives the number of bytes available in the buffer.
  1674. + *    The routine returns number of bytes read in if successful, otherwise
  1675. + *  it returns one of the standard error returns.
  1676. + ***************************************************************************/
  1677. +static int 
  1678. +seek_and_read_N_blocks( Byte params[], int n_blocks, Byte status[2],
  1679. +                        Byte *data_buff, int buf_size )
  1680. +{
  1681. +   int i;
  1682. +   const int block_size = 2048;
  1683. +   Byte cmd_buff[7];
  1684. +   int read_status;
  1685. +   Byte *start_pos = data_buff;
  1686. +   int retry_count;
  1687. +  
  1688. +   if ( ((long)block_size)*n_blocks > buf_size )
  1689. +      return( NO_ROOM );
  1690. +  
  1691. +   set_drive_mode( SONY535_CDROM_DRIVE_MODE, status );
  1692. +  
  1693. +    /* send command to read the data */
  1694. +   cmd_buff[0] = SONY535_SEEK_AND_READ_N_BLOCKS_1;
  1695. +   for ( i=0; i < 6; i++ )
  1696. +      cmd_buff[i+1] = params[i];
  1697. +   for ( i=0; i < 7; i++ )
  1698. +      outb( cmd_buff[i], command_reg );
  1699. +  
  1700. +    /* read back the data one block at a time */
  1701. +   while ( n_blocks-- > 0 ) 
  1702. +   {
  1703. +       /* wait for data to be ready */
  1704. +      retry_count = jiffies + SONY_JIFFIES_TIMEOUT;
  1705. +      while ( retry_count > jiffies ) 
  1706. +      {
  1707. +         read_status = inb(read_status_reg);
  1708. +         if ( (read_status & SONY535_RESULT_NOT_READY_BIT) == 0 ) 
  1709. +         {
  1710. +            read_exec_status( status );
  1711. +            return( BAD_STATUS );
  1712. +         }
  1713. +         if ( (read_status & SONY535_DATA_NOT_READY_BIT) == 0 ) 
  1714. +         {
  1715. +             /* data is ready, read it */
  1716. +            for ( i=0; i < block_size; i++ )
  1717. +               *data_buff++ = inb( data_reg );  /* unrolling this loop does not seem to help */
  1718. +            break;  /* exit the timeout loop */
  1719. +         }
  1720. +         sony_sleep();  /* data not ready, sleep a while */
  1721. +      }
  1722. +      if ( retry_count <= jiffies )
  1723. +      return( TIME_OUT );  /* if we reach this stage */
  1724. +   }
  1725. +  
  1726. +    /* read all the data, now read the status */
  1727. +   if ( (i=read_exec_status( status )) != 0 )
  1728. +      return( i );
  1729. +   return( data_buff - start_pos );
  1730. +}  /* seek_and_read_N_blocks() */
  1731. +
  1732. +/****************************************************************************
  1733. + * int request_toc_data( Byte status[2], struct s535_sony_toc *toc )
  1734. + *
  1735. + *  Read in the table of contents data.  Converts all the bcd data
  1736. + * into integers in the toc structure.
  1737. + ****************************************************************************/
  1738. +static int 
  1739. +request_toc_data( Byte status[2], struct s535_sony_toc *toc )
  1740. +{
  1741. +   int to_status;
  1742. +   int i, j, n_tracks, track_no;
  1743. +   Byte cmd_no = 0xb2;
  1744. +   Byte track_address_buffer[5];
  1745. +   int first_track_num, last_track_num;
  1746. +
  1747. +    /* read the fixed portion of the table of contents */
  1748. +   if ((to_status=do_sony_cmd( &cmd_no,1, status, (Byte *)toc,15, 1 )) != 0 )
  1749. +      return( to_status );
  1750. +  
  1751. +    /* convert the data into integers so we can use them */
  1752. +   first_track_num = bcd_to_int(toc->first_track_num);
  1753. +   last_track_num = bcd_to_int(toc->last_track_num);
  1754. +   n_tracks = last_track_num - first_track_num + 1;
  1755. +  
  1756. +    /* read each of the track address descriptors */
  1757. +   for ( i=0; i < n_tracks; i++ ) 
  1758. +   {
  1759. +       /* read the descriptor into a temporary buffer */
  1760. +      for ( j=0; j < 5; j++ ) 
  1761. +      {
  1762. +         if ( read_result_reg( track_address_buffer+j ) != 0 )
  1763. +            return( TIME_OUT );
  1764. +         if ( j == 1 )  /* need to convert from bcd */
  1765. +            track_no = bcd_to_int(track_address_buffer[j]);
  1766. +      }
  1767. +       /* copy the descriptor to proper location - sonycd.c just fills */
  1768. +      memcpy( toc->tracks+i, track_address_buffer, 5 );
  1769. +   }
  1770. +   return( 0 );
  1771. +}  /* request_toc_data() */
  1772. +
  1773. +/***************************************************************************
  1774. + * int spin_up_drive( Byte status[2] )
  1775. + *
  1776. + *  Spin up the drive (unless it is already spinning).
  1777. + ***************************************************************************/
  1778. +static int 
  1779. +spin_up_drive( Byte status[2] )
  1780. +{
  1781. +   Byte cmd_buff[1];
  1782. +  
  1783. +    /* first see if the drive is already spinning */
  1784. +   cmd_buff[0] = SONY535_REQUEST_DRIVE_STATUS_1;
  1785. +   if ( do_sony_cmd( cmd_buff,1, status, NULL,0, 0 ) != 0 )
  1786. +      return(TIME_OUT );
  1787. +   if ( (status[0] & SONY535_STATUS1_NOT_SPINNING) == 0 )
  1788. +      return( 0 );  /* its already spinning */
  1789. +  
  1790. +    /* else, give the spin-up command */
  1791. +   cmd_buff[0] = SONY535_SPIN_UP;
  1792. +   return( do_sony_cmd( cmd_buff, 1, status, NULL,0, 0 )  );
  1793. +}  /* spin_up_drive() */
  1794. +
  1795. +/*--------------------end of SONY CDU535 very specific ---------------------*/
  1796. +
  1797. +/* Convert from an integer 0-99 to BCD */
  1798. +static inline unsigned int
  1799. +int_to_bcd(unsigned int val)
  1800. +{
  1801. +   int retval;
  1802. +
  1803. +
  1804. +   retval = (val / 10) << 4;
  1805. +   retval = retval | val % 10;
  1806. +   return(retval);
  1807. +}
  1808. +
  1809. +
  1810. +/* Convert from BCD to an integer from 0-99 */
  1811. +static unsigned int
  1812. +bcd_to_int(unsigned int bcd)
  1813. +{
  1814. +   return((((bcd >> 4) & 0x0f) * 10) + (bcd & 0x0f));
  1815. +}
  1816. +
  1817. +
  1818. +/*
  1819. + * Convert a logical sector value (like the OS would want to use for
  1820. + * a block device) to an MSF format.
  1821. + */
  1822. +static void
  1823. +log_to_msf(unsigned int log, unsigned char *msf)
  1824. +{
  1825. +   log = log + LOG_START_OFFSET;
  1826. +   msf[0] = int_to_bcd(log / 4500);
  1827. +   log = log % 4500;
  1828. +   msf[1] = int_to_bcd(log / 75);
  1829. +   msf[2] = int_to_bcd(log % 75);
  1830. +}
  1831. +
  1832. +
  1833. +/*
  1834. + * Convert an MSF format to a logical sector.
  1835. + */
  1836. +static unsigned int
  1837. +msf_to_log(unsigned char *msf)
  1838. +{
  1839. +   unsigned int log;
  1840. +
  1841. +
  1842. +   log = bcd_to_int(msf[2]);
  1843. +   log += bcd_to_int(msf[1]) * 75;
  1844. +   log += bcd_to_int(msf[0]) * 4500;
  1845. +   log = log - LOG_START_OFFSET;
  1846. +
  1847. +   return log;
  1848. +}
  1849. +
  1850. +
  1851. +/*
  1852. + * Take in integer size value and put it into a buffer like
  1853. + * the drive would want to see a number-of-sector value.
  1854. + */
  1855. +static void
  1856. +size_to_buf(unsigned int size,
  1857. +            unsigned char *buf)
  1858. +{
  1859. +   buf[0] = size / 65536;
  1860. +   size = size % 65536;
  1861. +   buf[1] = size / 256;
  1862. +   buf[2] = size % 256;
  1863. +}
  1864. +
  1865. +
  1866. +/*
  1867. + * The OS calls this to perform a read or write operation to the drive.
  1868. + * Write obviously fail.  Reads to a read ahead of sony_buffer_size
  1869. + * bytes to help speed operations.  This especially helps since the OS
  1870. + * uses 1024 byte blocks and the drive uses 2048 byte blocks.  Since most
  1871. + * data access on a CD is done sequentially, this saves a lot of operations.
  1872. + */
  1873. +static void
  1874. +do_cdu535_request(void)
  1875. +{
  1876. +   int block;
  1877. +   unsigned int dev;
  1878. +   int nsect;
  1879. +   unsigned char params[10];
  1880. +   int copyoff;
  1881. +   int spin_up_retry;
  1882. +   unsigned int read_size;
  1883. +   unsigned char status[2], cmd[2];
  1884. +
  1885. +
  1886. +   if ( !sony_inuse )
  1887. +   {
  1888. +      cdu_open( NULL, NULL );
  1889. +   }
  1890. +   
  1891. +   while (1)
  1892. +   {
  1893. +      /*
  1894. +       * The beginning here is stolen from the hard disk driver.  I hope
  1895. +       * its right.
  1896. +       */
  1897. +      if (!(CURRENT) || CURRENT->dev < 0)
  1898. +      {
  1899. +         return;
  1900. +      }
  1901. +
  1902. +      INIT_REQUEST;
  1903. +      dev = MINOR(CURRENT->dev);
  1904. +      block = CURRENT->sector;
  1905. +      nsect = CURRENT->nr_sectors;
  1906. +      if (dev != 0)
  1907. +      {
  1908. +         end_request(0);
  1909. +         continue;
  1910. +      }
  1911. +
  1912. +      switch(CURRENT->cmd)
  1913. +      {
  1914. +      case READ:
  1915. +         /*
  1916. +          * If the block address is invalid or the request goes beyond the end of
  1917. +          * the media, return an error.
  1918. +          */
  1919. +         if ((block / 4) >= sony_toc->lead_out_start_lba)
  1920. +         {
  1921. +            end_request(0);
  1922. +            return;
  1923. +         }
  1924. +         if (((block + nsect) / 4) >= sony_toc->lead_out_start_lba)
  1925. +         {
  1926. +            end_request(0);
  1927. +            return;
  1928. +         }
  1929. +
  1930. +         while (nsect > 0)
  1931. +         {
  1932. +            /*
  1933. +             * If the requested sector is not currently in the read-ahead buffer,
  1934. +             * it must be read in.
  1935. +             */
  1936. +            if ((block < sony_first_block) || (block > sony_last_block))
  1937. +            {
  1938. +               sony_first_block = (block / 4) * 4;
  1939. +               log_to_msf(block/4, params);
  1940. +
  1941. +               /*
  1942. +                * If the full read-ahead would go beyond the end of the media, trim
  1943. +                * it back to read just till the end of the media.
  1944. +                */
  1945. +               if (((block / 4) + sony_buffer_sectors) >= sony_toc->lead_out_start_lba)
  1946. +               {
  1947. +                  sony_last_block = (sony_toc->lead_out_start_lba * 4) - 1;
  1948. +                  read_size = sony_toc->lead_out_start_lba - (block / 4);
  1949. +               }
  1950. +               else
  1951. +               {
  1952. +                  sony_last_block = sony_first_block + (sony_buffer_sectors * 4) - 1;
  1953. +                  read_size = sony_buffer_sectors;
  1954. +               }
  1955. +               size_to_buf(read_size, ¶ms[3]);
  1956. +
  1957. +               /*
  1958. +                * Read the data.  If the drive was not spinning, spin it up and try
  1959. +                * once more.  I know, the goto is ugly, but I am too lazy to fix it.
  1960. +                */
  1961. +               spin_up_retry = 0;
  1962. +try_read_again:
  1963. +#if 0
  1964. +               if ( check_drive_status() != 0 ) {  /* drive not ready */
  1965. +                  sony_first_block = -1;
  1966. +                  sony_last_block = -1;
  1967. +                  end_request(0);
  1968. +                  return;
  1969. +                  }
  1970. +#endif
  1971. +               if ( seek_and_read_N_blocks( params, read_size, status, sony_buffer,
  1972. +                         (read_size * 2048) ) < 0 ) {
  1973. +                  if ((status[0] & SONY535_STATUS1_NOT_SPINNING) && (!spin_up_retry))
  1974. +                  {
  1975. +                     printk(" Sony535 Debug -- calling spin up when reading data!\n");
  1976. +                     cmd[0] = SONY535_SPIN_UP;
  1977. +                     do_sony_cmd( cmd,1, status, NULL,0, 0);
  1978. +                     spin_up_retry = 1;
  1979. +                     goto try_read_again;
  1980. +                  }
  1981. +
  1982. +                  printk("Sony CDROM Read error: 0x%.2x\n", status[0]);
  1983. +                  sony_first_block = -1;
  1984. +                  sony_last_block = -1;
  1985. +                  end_request(0);
  1986. +                  return;
  1987. +               }
  1988. +            }
  1989. +   
  1990. +            /*
  1991. +             * The data is in memory now, copy it to the buffer and advance to the
  1992. +             * next block to read.
  1993. +             */
  1994. +            copyoff = (block - sony_first_block) * 512;
  1995. +            memcpy(CURRENT->buffer, sony_buffer+copyoff, 512);
  1996. +               
  1997. +            block += 1;
  1998. +            nsect -= 1;
  1999. +            CURRENT->buffer += 512;
  2000. +         }
  2001. +               
  2002. +         end_request(1);
  2003. +         break;
  2004. +            
  2005. +      case WRITE:
  2006. +         end_request(0);
  2007. +         break;
  2008. +            
  2009. +      default:
  2010. +         panic("Unkown SONY CD cmd");
  2011. +      }
  2012. +   }
  2013. +}
  2014. +
  2015. +
  2016. +/*
  2017. + * Read the table of contents from the drive and set sony_toc_read if
  2018. + * successful.
  2019. + */
  2020. +static void
  2021. +sony_get_toc(void)
  2022. +{
  2023. +   unsigned char status[2];
  2024. +  
  2025. +   if ( !sony_toc_read ) 
  2026. +   {
  2027. +       /* do not call check_drive_status() from here since it can call this routine */
  2028. +      if ( request_toc_data( status, sony_toc ) < 0 )
  2029. +         return;
  2030. +      sony_toc->lead_out_start_lba = msf_to_log(sony_toc->lead_out_start_msf);
  2031. +      sony_toc_read = 1;
  2032. +   }
  2033. +}
  2034. +
  2035. +
  2036. +/*
  2037. + * Search for a specific track in the table of contents.  track is
  2038. + * passed in bcd format
  2039. + */
  2040. +static int
  2041. +find_track(int track)
  2042. +{
  2043. +   int i;
  2044. +   int num_tracks;
  2045. +
  2046. +
  2047. +   num_tracks = bcd_to_int(sony_toc->last_track_num) - 
  2048. +                   bcd_to_int(sony_toc->first_track_num) + 1;
  2049. +   for (i = 0; i < num_tracks; i++)
  2050. +   {
  2051. +      if (sony_toc->tracks[i].track == track)
  2052. +      {
  2053. +         return i;
  2054. +      }
  2055. +   }
  2056. +
  2057. +   return -1;
  2058. +}
  2059. +
  2060. +/*
  2061. + * Read the subcode and put it int last_sony_subcode for future use.
  2062. + */
  2063. +static int
  2064. +read_subcode(void)
  2065. +{
  2066. +   Byte cmd = SONY535_REQUEST_SUB_Q_DATA, status[2];
  2067. +   int dsc_status;
  2068. +   
  2069. +   if ( check_drive_status() != 0 )
  2070. +      return( -EIO );
  2071. +     
  2072. +   if ( (dsc_status=do_sony_cmd( &cmd,1, status, (Byte *)last_sony_subcode, 
  2073. +                      sizeof(struct s535_sony_subcode), 1 )) != 0 ) 
  2074. +   {
  2075. +      printk("Sony CDROM error 0x%.2x, %d (read_subcode)\n", status[0], 
  2076. +              dsc_status );
  2077. +      return( -EIO );
  2078. +   }
  2079. +   return(0);
  2080. +}
  2081. +
  2082. +
  2083. +/*
  2084. + * Get the subchannel info like the CDROMSUBCHNL command wants to see it.  If
  2085. + * the drive is playing, the subchannel needs to be read (since it would be
  2086. + * changing).  If the drive is paused or completed, the subcode information has
  2087. + * already been stored, just use that.  The ioctl call wants things in decimal
  2088. + * (not BCD), so all the conversions are done.
  2089. + */
  2090. +static int
  2091. +sony_get_subchnl_info(long arg)
  2092. +{
  2093. +   struct cdrom_subchnl schi;
  2094. +
  2095. +
  2096. +   /* Get attention stuff */
  2097. +   if ( check_drive_status() != 0 )
  2098. +      return( -EIO );
  2099. +
  2100. +   sony_get_toc();
  2101. +   if (!sony_toc_read)
  2102. +   {
  2103. +      return -EIO;
  2104. +   }
  2105. +
  2106. +   verify_area(VERIFY_WRITE /* and read */, (char *) arg, sizeof(schi));
  2107. +
  2108. +   memcpy_fromfs(&schi, (char *) arg, sizeof(schi));
  2109. +   
  2110. +   switch (sony_audio_status)
  2111. +   {
  2112. +   case CDROM_AUDIO_PLAY:
  2113. +      if (read_subcode() < 0)
  2114. +      {
  2115. +         return -EIO;
  2116. +      }
  2117. +      break;
  2118. +
  2119. +   case CDROM_AUDIO_PAUSED:
  2120. +   case CDROM_AUDIO_COMPLETED:
  2121. +      break;
  2122. +
  2123. +   case CDROM_AUDIO_NO_STATUS:
  2124. +      schi.cdsc_audiostatus = sony_audio_status;
  2125. +      memcpy_tofs((char *) arg, &schi, sizeof(schi));
  2126. +      return 0;
  2127. +      break;
  2128. +
  2129. +   case CDROM_AUDIO_INVALID:
  2130. +   case CDROM_AUDIO_ERROR:
  2131. +   default:
  2132. +      return -EIO;
  2133. +   }
  2134. +
  2135. +   schi.cdsc_audiostatus = sony_audio_status;
  2136. +   schi.cdsc_adr = last_sony_subcode->address;
  2137. +   schi.cdsc_ctrl = last_sony_subcode->control;
  2138. +   schi.cdsc_trk = bcd_to_int(last_sony_subcode->track_num);
  2139. +   schi.cdsc_ind = bcd_to_int(last_sony_subcode->index_num);
  2140. +   if (schi.cdsc_format == CDROM_MSF)
  2141. +   {
  2142. +      schi.cdsc_absaddr.msf.minute = bcd_to_int(last_sony_subcode->abs_msf[0]);
  2143. +      schi.cdsc_absaddr.msf.second = bcd_to_int(last_sony_subcode->abs_msf[1]);
  2144. +      schi.cdsc_absaddr.msf.frame = bcd_to_int(last_sony_subcode->abs_msf[2]);
  2145. +
  2146. +      schi.cdsc_reladdr.msf.minute = bcd_to_int(last_sony_subcode->rel_msf[0]);
  2147. +      schi.cdsc_reladdr.msf.second = bcd_to_int(last_sony_subcode->rel_msf[1]);
  2148. +      schi.cdsc_reladdr.msf.frame = bcd_to_int(last_sony_subcode->rel_msf[2]);
  2149. +   }
  2150. +   else if (schi.cdsc_format == CDROM_LBA)
  2151. +   {
  2152. +      schi.cdsc_absaddr.lba = msf_to_log(last_sony_subcode->abs_msf);
  2153. +      schi.cdsc_reladdr.lba = msf_to_log(last_sony_subcode->rel_msf);
  2154. +   }
  2155. +   
  2156. +   memcpy_tofs((char *) arg, &schi, sizeof(schi));
  2157. +   return 0;
  2158. +}
  2159. +
  2160. +
  2161. +/*
  2162. + * The big ugly ioctl handler.
  2163. + */
  2164. +static int
  2165. +cdu_ioctl(struct inode *inode,
  2166. +          struct file  *file,
  2167. +          unsigned int cmd,
  2168. +          unsigned long arg)
  2169. +{
  2170. +   unsigned int dev;
  2171. +   unsigned char status[2];
  2172. +   unsigned char cmd_buff[10], params[10];
  2173. +   int i, dsc_status;
  2174. +
  2175. +
  2176. +   if (!inode)
  2177. +   {
  2178. +      return -EINVAL;
  2179. +   }
  2180. +   dev = MINOR(inode->i_rdev) >> 6;
  2181. +   if (dev != 0)
  2182. +   {
  2183. +      return -EINVAL;
  2184. +   }
  2185. +   
  2186. +   if ( check_drive_status() != 0 )
  2187. +      return( -EIO );
  2188. +
  2189. +   switch (cmd)
  2190. +   {
  2191. +   case CDROMSTART:     /* Spin up the drive */
  2192. +      if ( spin_up_drive( status ) < 0 )
  2193. +      {
  2194. +         printk("Sony CDROM error 0x%.2x (CDROMSTART)\n", status[0]);
  2195. +         return -EIO;
  2196. +      }
  2197. +      return 0;
  2198. +      break;
  2199. +      
  2200. +   case CDROMSTOP:      /* Spin down the drive */
  2201. +      cmd_buff[0] = SONY535_HOLD;
  2202. +      do_sony_cmd( cmd_buff,1, status, NULL,0, 0 );
  2203. +
  2204. +      /*
  2205. +       * Spin the drive down, ignoring the error if the disk was
  2206. +       * already not spinning.
  2207. +       */
  2208. +      sony_audio_status = CDROM_AUDIO_NO_STATUS;
  2209. +      cmd_buff[0] = SONY535_SPIN_DOWN;
  2210. +      dsc_status = do_sony_cmd( cmd_buff,1, status, NULL,0, 0 );
  2211. +      if ( (( dsc_status < 0 ) && (dsc_status != BAD_STATUS)) ||
  2212. +           ( (status[0] & ~(SONY535_STATUS1_NOT_SPINNING)) != 0) ) 
  2213. +      {
  2214. +         printk("Sony CDROM error 0x%.2x (CDROMSTOP)\n", status[0]);
  2215. +         return -EIO;
  2216. +      }
  2217. +      
  2218. +      return 0;
  2219. +      break;
  2220. +
  2221. +   case CDROMPAUSE:     /* Pause the drive */
  2222. +      cmd_buff[0] = SONY535_HOLD;  /* CDU-31 driver uses AUDIO_STOP, not pause */
  2223. +      if ( do_sony_cmd( cmd_buff,1, status, NULL,0, 0 ) != 0 ) 
  2224. +      {
  2225. +         printk("Sony CDROM error 0x%.2x (CDROMPAUSE)\n", status[0]);
  2226. +         return -EIO;
  2227. +      }
  2228. +
  2229. +      /* Get the current position and save it for resuming */
  2230. +      if (read_subcode() < 0)
  2231. +      {
  2232. +         return -EIO;
  2233. +      }
  2234. +      cur_pos_msf[0] = last_sony_subcode->abs_msf[0];
  2235. +      cur_pos_msf[1] = last_sony_subcode->abs_msf[1];
  2236. +      cur_pos_msf[2] = last_sony_subcode->abs_msf[2];
  2237. +      sony_audio_status = CDROM_AUDIO_PAUSED;
  2238. +      return 0;
  2239. +      break;
  2240. +
  2241. +   case CDROMRESUME:    /* Start the drive after being paused */
  2242. +      set_drive_mode( SONY535_AUDIO_DRIVE_MODE, status );
  2243. +      
  2244. +      if (sony_audio_status != CDROM_AUDIO_PAUSED)
  2245. +      {
  2246. +         return -EINVAL;
  2247. +      }
  2248. +      
  2249. +      spin_up_drive( status );
  2250. +      
  2251. +      /* Start the drive at the saved position. */
  2252. +      cmd_buff[0] = SONY535_PLAY_AUDIO;
  2253. +      cmd_buff[1] = 0;  /* play back starting at this address */
  2254. +      cmd_buff[2] = cur_pos_msf[0];
  2255. +      cmd_buff[3] = cur_pos_msf[1];
  2256. +      cmd_buff[4] = cur_pos_msf[2];
  2257. +      cmd_buff[5] = SONY535_PLAY_AUDIO;
  2258. +      cmd_buff[6] = 2;  /* set ending address */
  2259. +      cmd_buff[7] = final_pos_msf[0];
  2260. +      cmd_buff[8] = final_pos_msf[1];
  2261. +      cmd_buff[9] = final_pos_msf[2];
  2262. +      if ( (do_sony_cmd( cmd_buff,5, status, NULL,0, 0 ) != 0 ) ||
  2263. +           (do_sony_cmd( cmd_buff+5,5, status, NULL,0, 0 ) != 0 ) )
  2264. +      {
  2265. +         printk("Sony CDROM error 0x%.2x (CDROMRESUME)\n", status[0]);
  2266. +         return -EIO;
  2267. +      }
  2268. +      sony_audio_status = CDROM_AUDIO_PLAY;
  2269. +      return 0;
  2270. +      break;
  2271. +
  2272. +   case CDROMPLAYMSF:   /* Play starting at the given MSF address. */
  2273. +      verify_area(VERIFY_READ, (char *) arg, 6);
  2274. +      spin_up_drive( status );
  2275. +      set_drive_mode( SONY535_AUDIO_DRIVE_MODE, status );
  2276. +      memcpy_fromfs(params, (void *) arg, 6);
  2277. +      
  2278. +      /* The parameters are given in int, must be converted */
  2279. +      for (i=0; i<3; i++)
  2280. +      {
  2281. +         cmd_buff[2+i] = int_to_bcd(params[i]);
  2282. +         cmd_buff[7+i] = int_to_bcd(params[i+3]);
  2283. +      }
  2284. +      cmd_buff[0] = SONY535_PLAY_AUDIO;
  2285. +      cmd_buff[1] = 0;  /* play back starting at this address */
  2286. +       /* cmd_buff[2-4] are filled in for loop above */
  2287. +      cmd_buff[5] = SONY535_PLAY_AUDIO;
  2288. +      cmd_buff[6] = 2;  /* set ending address */
  2289. +       /* cmd_buff[7-9] are filled in for loop above */
  2290. +      if ( (do_sony_cmd( cmd_buff,5, status, NULL,0, 0 ) != 0 ) ||
  2291. +           (do_sony_cmd( cmd_buff+5,5, status, NULL,0, 0 ) != 0 ) )
  2292. +      {
  2293. +         printk("Sony CDROM error 0x%.2x (CDROMPLAYMSF)\n", status[0]);
  2294. +         return -EIO;
  2295. +      }
  2296. +      
  2297. +      /* Save the final position for pauses and resumes */
  2298. +      final_pos_msf[0] = cmd_buff[7];
  2299. +      final_pos_msf[1] = cmd_buff[8];
  2300. +      final_pos_msf[2] = cmd_buff[9];
  2301. +      sony_audio_status = CDROM_AUDIO_PLAY;
  2302. +      return 0;
  2303. +      break;
  2304. +
  2305. +   case CDROMREADTOCHDR:        /* Read the table of contents header */
  2306. +      {
  2307. +         struct cdrom_tochdr *hdr;
  2308. +         struct cdrom_tochdr loc_hdr;
  2309. +         
  2310. +         sony_get_toc();
  2311. +         if (!sony_toc_read)
  2312. +         {
  2313. +            return -EIO;
  2314. +         }
  2315. +         
  2316. +         hdr = (struct cdrom_tochdr *) arg;
  2317. +         verify_area(VERIFY_WRITE, hdr, sizeof(*hdr));
  2318. +         loc_hdr.cdth_trk0 = bcd_to_int(sony_toc->first_track_num);
  2319. +         loc_hdr.cdth_trk1 = bcd_to_int(sony_toc->last_track_num);
  2320. +         memcpy_tofs(hdr, &loc_hdr, sizeof(*hdr));
  2321. +      }
  2322. +      return 0;
  2323. +      break;
  2324. +
  2325. +   case CDROMREADTOCENTRY:      /* Read a given table of contents entry */
  2326. +      {
  2327. +         struct cdrom_tocentry *entry;
  2328. +         struct cdrom_tocentry loc_entry;
  2329. +         int track_idx;
  2330. +         unsigned char *msf_val = NULL;
  2331. +         
  2332. +         sony_get_toc();
  2333. +         if (!sony_toc_read)
  2334. +         {
  2335. +            return -EIO;
  2336. +         }
  2337. +         
  2338. +         entry = (struct cdrom_tocentry *) arg;
  2339. +         verify_area(VERIFY_WRITE /* and read */, entry, sizeof(*entry));
  2340. +         
  2341. +         memcpy_fromfs(&loc_entry, entry, sizeof(loc_entry));
  2342. +         
  2343. +         /* Lead out is handled separately since it is special. */
  2344. +         if (loc_entry.cdte_track == CDROM_LEADOUT)
  2345. +         {
  2346. +            loc_entry.cdte_adr = 0 /*sony_toc->address2*/;
  2347. +            loc_entry.cdte_ctrl = sony_toc->control2;
  2348. +            msf_val = sony_toc->lead_out_start_msf;
  2349. +         }
  2350. +         else
  2351. +         {
  2352. +            track_idx = find_track(int_to_bcd(loc_entry.cdte_track));
  2353. +            if (track_idx < 0)
  2354. +            {
  2355. +               return -EINVAL;
  2356. +            }
  2357. +            
  2358. +            loc_entry.cdte_adr = 0 /*sony_toc->tracks[track_idx].address*/;
  2359. +            loc_entry.cdte_ctrl = sony_toc->tracks[track_idx].control;
  2360. +            msf_val = sony_toc->tracks[track_idx].track_start_msf;
  2361. +         }
  2362. +         
  2363. +         /* Logical buffer address or MSF format requested? */
  2364. +         if (loc_entry.cdte_format == CDROM_LBA)
  2365. +         {
  2366. +            loc_entry.cdte_addr.lba = msf_to_log(msf_val);
  2367. +         }
  2368. +         else if (loc_entry.cdte_format == CDROM_MSF)
  2369. +         {
  2370. +            loc_entry.cdte_addr.msf.minute = bcd_to_int(*msf_val);
  2371. +            loc_entry.cdte_addr.msf.second = bcd_to_int(*(msf_val+1));
  2372. +            loc_entry.cdte_addr.msf.frame = bcd_to_int(*(msf_val+2));
  2373. +         }
  2374. +         memcpy_tofs(entry, &loc_entry, sizeof(*entry));
  2375. +      }
  2376. +      return 0;
  2377. +      break;
  2378. +
  2379. +   case CDROMPLAYTRKIND:     /* Play a track.  This currently ignores index. */
  2380. +      {
  2381. +         struct cdrom_ti ti;
  2382. +         int track_idx;
  2383. +         
  2384. +         sony_get_toc();
  2385. +         if (!sony_toc_read)
  2386. +         {
  2387. +            return -EIO;
  2388. +         }
  2389. +         
  2390. +         verify_area( VERIFY_READ, (char *) arg, sizeof(ti));
  2391. +         
  2392. +         memcpy_fromfs(&ti, (char *) arg, sizeof(ti));
  2393. +         if (   (ti.cdti_trk0 < sony_toc->first_track_num)
  2394. +             || (ti.cdti_trk0 > sony_toc->last_track_num)
  2395. +             || (ti.cdti_trk1 < ti.cdti_trk0))
  2396. +         {
  2397. +            return -EINVAL;
  2398. +         }
  2399. +         
  2400. +         track_idx = find_track(int_to_bcd(ti.cdti_trk0));
  2401. +         if (track_idx < 0)
  2402. +         {
  2403. +            return -EINVAL;
  2404. +         }
  2405. +         params[1] = sony_toc->tracks[track_idx].track_start_msf[0];
  2406. +         params[2] = sony_toc->tracks[track_idx].track_start_msf[1];
  2407. +         params[3] = sony_toc->tracks[track_idx].track_start_msf[2];
  2408. +         /*
  2409. +          * If we want to stop after the last track, use the lead-out
  2410. +          * MSF to do that.
  2411. +          */
  2412. +         if (ti.cdti_trk1 >= bcd_to_int(sony_toc->last_track_num))
  2413. +         {
  2414. +            log_to_msf(msf_to_log(sony_toc->lead_out_start_msf)-1,
  2415. +                       &(params[4]));
  2416. +         }
  2417. +         else
  2418. +         {
  2419. +            track_idx = find_track(int_to_bcd(ti.cdti_trk1+1));
  2420. +            if (track_idx < 0)
  2421. +            {
  2422. +               return -EINVAL;
  2423. +            }
  2424. +            log_to_msf(msf_to_log(sony_toc->tracks[track_idx].track_start_msf)-1,
  2425. +                       &(params[4]));
  2426. +         }
  2427. +         params[0] = 0x03;
  2428. +         
  2429. +         spin_up_drive( status );
  2430. +         
  2431. +         set_drive_mode( SONY535_AUDIO_DRIVE_MODE, status );
  2432. +      
  2433. +         /* Start the drive at the saved position. */
  2434. +         cmd_buff[0] = SONY535_PLAY_AUDIO;
  2435. +         cmd_buff[1] = 0;  /* play back starting at this address */
  2436. +         cmd_buff[2] = params[1];
  2437. +         cmd_buff[3] = params[2];
  2438. +         cmd_buff[4] = params[3];
  2439. +         cmd_buff[5] = SONY535_PLAY_AUDIO;
  2440. +         cmd_buff[6] = 2;  /* set ending address */
  2441. +         cmd_buff[7] = params[4];
  2442. +         cmd_buff[8] = params[5];
  2443. +         cmd_buff[9] = params[6];
  2444. +         if ( (do_sony_cmd( cmd_buff,5, status, NULL,0, 0 ) != 0 ) ||
  2445. +              (do_sony_cmd( cmd_buff+5,5, status, NULL,0, 0 ) != 0 ) )
  2446. +         {
  2447. +            printk("Params: %x %x %x %x %x %x %x\n", params[0], params[1],
  2448. +                   params[2], params[3], params[4], params[5], params[6]);
  2449. +            printk("Sony CDROM error 0x%.2x (CDROMPLAYTRKIND)\n", status[0]);
  2450. +            return -EIO;
  2451. +         }
  2452. +         
  2453. +         /* Save the final position for pauses and resumes */
  2454. +         final_pos_msf[0] = params[4];
  2455. +         final_pos_msf[1] = params[5];
  2456. +         final_pos_msf[2] = params[6];
  2457. +         sony_audio_status = CDROM_AUDIO_PLAY;
  2458. +         return 0;
  2459. +      }
  2460. +     
  2461. +   case CDROMSUBCHNL:   /* Get subchannel info */
  2462. +      return sony_get_subchnl_info(arg);
  2463. +
  2464. +   case CDROMVOLCTRL:   /* Volume control.  What volume does this change, anyway? */
  2465. +      {
  2466. +         struct cdrom_volctrl volctrl;
  2467. +         
  2468. +         verify_area(VERIFY_READ, (char *) arg, sizeof(volctrl));
  2469. +         
  2470. +         memcpy_fromfs(&volctrl, (char *) arg, sizeof(volctrl));
  2471. +         cmd_buff[0] = SONY535_SET_VOLUME;
  2472. +         cmd_buff[1] = volctrl.channel0;
  2473. +         cmd_buff[2] = volctrl.channel1;
  2474. +         if ( do_sony_cmd( cmd_buff,3, status, NULL,0, 0 ) != 0 )
  2475. +         {
  2476. +            printk("Sony CDROM error 0x%.2x (CDROMVOLCTRL)\n", status[0]);
  2477. +            return -EIO;
  2478. +         }
  2479. +      }
  2480. +      return 0;
  2481. +
  2482. +   case CDROMEJECT:     /* Eject the drive */
  2483. +      cmd_buff[0] = SONY535_STOP;
  2484. +      do_sony_cmd( cmd_buff,1, status, NULL,0, 0 );
  2485. +      cmd_buff[0] = SONY535_SPIN_DOWN;
  2486. +      do_sony_cmd( cmd_buff,1, status, NULL,0, 0 );
  2487. +
  2488. +      sony_audio_status = CDROM_AUDIO_INVALID;
  2489. +      cmd_buff[0] = SONY535_EJECT_CADDY;
  2490. +      if ( do_sony_cmd( cmd_buff,1, status, NULL,0, 0 ) != 0 )
  2491. +      {
  2492. +         printk("Sony CDROM error 0x%.2x (CDROMEJECT)\n", status[0]);
  2493. +         return -EIO;
  2494. +      }
  2495. +      return 0;
  2496. +      break;
  2497. +     
  2498. +   default:
  2499. +      return -EINVAL;
  2500. +   }
  2501. +}
  2502. +
  2503. +
  2504. +/*
  2505. + * Open the drive for operations.  Spin the drive up and read the table of
  2506. + * contents if these have not already been done.
  2507. + */
  2508. +static int
  2509. +cdu_open(struct inode *inode,
  2510. +         struct file *filp)
  2511. +{
  2512. +   unsigned char status[2], cmd_buff[2];
  2513. +
  2514. +
  2515. +   if ( sony_inuse )
  2516. +   {
  2517. +      return( -EBUSY );
  2518. +   }
  2519. +   
  2520. +   if ( check_drive_status() != 0 )
  2521. +   {
  2522. +      return( -EIO );
  2523. +   }
  2524. +      
  2525. +   sony_inuse = 1;
  2526. +   
  2527. +   if ( spin_up_drive( status ) != 0 )
  2528. +   {
  2529. +      printk("Sony CDROM error 0x%.2x (cdu_open, spin up)\n", status[0]);
  2530. +      sony_inuse = 0;
  2531. +      return -EIO;
  2532. +   }
  2533. +      
  2534. +#if 0  /* what is this doing - CDU-535 does not have separate READ and REQ_TOC */
  2535. +   do_sony_cd_cmd(SONY_READ_TOC_CMD, NULL, 0, res_reg, &res_size);
  2536. +   if ((res_size < 2) || (res_reg[0] != 0))
  2537. +   {
  2538. +      /* If the drive is already playing, its ok. */
  2539. +      if (res_reg[1] == SONY_AUDIO_PLAYING_ERR)
  2540. +      {
  2541. +         goto drive_spinning;
  2542. +      }
  2543. +
  2544. +      printk("Sony CDROM error 0x%.2x (cdu_open, read toc)\n", res_reg[1]);
  2545. +      do_sony_cd_cmd(SONY_SPIN_DOWN_CMD, NULL, 0, res_reg, &res_size);
  2546. +      
  2547. +      sony_inuse = 0;
  2548. +      return -EIO;
  2549. +   }
  2550. +#endif
  2551. +
  2552. +   sony_get_toc();
  2553. +   if (!sony_toc_read)
  2554. +   {
  2555. +      cmd_buff[0] = SONY535_SPIN_DOWN;
  2556. +      do_sony_cmd( cmd_buff,1, status, NULL,0, 0 );
  2557. +      sony_inuse = 0;
  2558. +      return -EIO;
  2559. +   }
  2560. +      
  2561. +#if 0  /* not used without stuff read toc above */
  2562. +drive_spinning:
  2563. +#endif
  2564. +
  2565. +   if ( inode ) 
  2566. +   {
  2567. +      check_disk_change(inode->i_rdev);
  2568. +   }
  2569. +
  2570. +   sony_usage++;
  2571. +   
  2572. +#ifdef LOCK_DOORS
  2573. +    /* disable the eject button while mounted */
  2574. +   cmd_buff[0] = SONY535_DISABLE_EJECT_BUTTON;
  2575. +   do_sony_cmd( cmd_buff,1, status, NULL,0, 0 );
  2576. +#endif
  2577. +
  2578. +   return 0;
  2579. +}
  2580. +
  2581. +
  2582. +/*
  2583. + * Close the drive.  Spin it down if no task is using it.  The spin
  2584. + * down will fail if playing audio, so audio play is OK.
  2585. + */
  2586. +static void
  2587. +cdu_release(struct inode *inode,
  2588. +         struct file *filp)
  2589. +{
  2590. +   unsigned char status[2], cmd_no;
  2591. +
  2592. +   sony_inuse = 0;
  2593. +
  2594. +   if (sony_usage > 0)
  2595. +   {
  2596. +      sony_usage--;
  2597. +   }
  2598. +   if (sony_usage == 0)
  2599. +   {
  2600. +      sync_dev(inode->i_rdev);
  2601. +      check_drive_status();
  2602. +
  2603. +      if ( sony_audio_status != CDROM_AUDIO_PLAY ) {
  2604. +         cmd_no = SONY535_SPIN_DOWN;
  2605. +         do_sony_cmd( &cmd_no,1, status, NULL,0, 0 );
  2606. +         }
  2607. +#ifdef LOCK_DOORS
  2608. +       /* enable the eject button after umount */
  2609. +      cmd_no = SONY535_ENABLE_EJECT_BUTTON;
  2610. +      do_sony_cmd( &cmd_no,1, status, NULL,0, 0 );
  2611. +#endif
  2612. +   }
  2613. +}
  2614. +
  2615. +
  2616. +static struct file_operations cdu_fops = {
  2617. +   NULL,                   /* lseek - default */
  2618. +   block_read,             /* read - general block-dev read */
  2619. +   block_write,            /* write - general block-dev write */
  2620. +   NULL,                   /* readdir - bad */
  2621. +   NULL,                   /* select */
  2622. +   cdu_ioctl,              /* ioctl */
  2623. +   NULL,                   /* mmap */
  2624. +   cdu_open,               /* open */
  2625. +   cdu_release,            /* release */
  2626. +   NULL,                   /* fsync */
  2627. +   NULL,                   /* fasync */
  2628. +   cdu535_check_media_change, /* check_media_change */
  2629. +   NULL                    /* revalidate */
  2630. +};
  2631. +
  2632. +
  2633. +/*
  2634. + * Initialize the driver.
  2635. + */
  2636. +unsigned long
  2637. +init_sony535(unsigned long mem_start, unsigned long mem_end)
  2638. +{
  2639. +   struct s535_sony_drive_config drive_config;
  2640. +   unsigned char cmd_buff[3], ret_buff[2];
  2641. +   unsigned char status[2];
  2642. +   int retry_count;
  2643. +
  2644. +
  2645. +   /* Set up all the register locations */
  2646. +   result_reg = sony_cd_base_io;
  2647. +   command_reg = sony_cd_base_io;
  2648. +   data_reg = sony_cd_base_io + 1;
  2649. +   read_status_reg = sony_cd_base_io + 2;
  2650. +   select_unit_reg = sony_cd_base_io + 3;
  2651. +
  2652. +    /* look for the CD-ROM, follows the procedure in the DOS driver */
  2653. +   inb( select_unit_reg );
  2654. +   retry_count = jiffies + 2*HZ;
  2655. +   while ( retry_count > jiffies )
  2656. +      sony_sleep();        /* wait for 40 18 Hz ticks (from DOS driver) */
  2657. +   inb( result_reg );
  2658. +   
  2659. +   outb( 0, read_status_reg );    /* does a reset? */
  2660. +   retry_count = jiffies + SONY_JIFFIES_TIMEOUT;
  2661. +   while ( retry_count > jiffies ) 
  2662. +   {
  2663. +      select_unit(0);
  2664. +      if ( inb( result_reg ) != 0xff )
  2665. +         break;
  2666. +      sony_sleep();  /* about 1-2 ms on my machine */
  2667. +   }
  2668. +   
  2669. +   if ( (retry_count > jiffies) && (check_drive_status() != TIME_OUT) ) 
  2670. +   {  
  2671. +       /* CD-ROM drive responded --  get the drive configuration */
  2672. +      cmd_buff[0] = SONY535_INQUIRY;
  2673. +      if ( do_sony_cmd( cmd_buff,1, status, (Byte *)&drive_config, 28, 1) == 0 ) 
  2674. +      {
  2675. +          /* was able to get the configuration, set drive mode as rest of init */
  2676. +         if ( (status[0] & 0x7f) != 0 )
  2677. +            printk("Inquiry command returned status = 0x%x\n",status[0]);
  2678. +         cmd_buff[0] = SONY535_SET_DRIVE_MODE;
  2679. +         cmd_buff[1] = 0x0;  /* default audio */
  2680. +         if (do_sony_cmd( cmd_buff,2, status, ret_buff,1, 1 ) == 0 ) 
  2681. +         {
  2682. +             /* set the drive mode successful, we are set! */
  2683. +            sony_buffer_size = SONY535_BUFFER_SIZE;
  2684. +            sony_buffer_sectors = sony_buffer_size / 2048;
  2685. +
  2686. +            printk("Sony I/F CDROM : %8.8s %16.16s %4.4s",
  2687. +                   drive_config.vendor_id,
  2688. +                   drive_config.product_id,
  2689. +                   drive_config.product_rev_level );
  2690. +            printk("  using %d byte buffer\n", sony_buffer_size);
  2691. +
  2692. +        if (register_blkdev(MAJOR_NR,"cdu",&cdu_fops)) {
  2693. +        printk("Unable to get major %d for sony CDU-535 cd\n",MAJOR_NR);
  2694. +        return( mem_start );
  2695. +        }
  2696. +            blk_dev[MAJOR_NR].request_fn = DEVICE_REQUEST;
  2697. +            read_ahead[MAJOR_NR] = 8;               /* 8 sector (4kB) read-ahead */
  2698. +
  2699. +            sony_toc = (struct s535_sony_toc *) mem_start;
  2700. +            mem_start += sizeof(*sony_toc);
  2701. +            last_sony_subcode = (struct s535_sony_subcode *) mem_start;
  2702. +            mem_start += sizeof(*last_sony_subcode);
  2703. +            sony_buffer = (unsigned char *) mem_start;
  2704. +            mem_start += sony_buffer_size;
  2705. +
  2706. +            initialized = 1;
  2707. +         }
  2708. +      }
  2709. +   }
  2710. +
  2711. +   if ( !initialized )
  2712. +      printk( "Did not find a Sony CDU-535 drive\n");
  2713. +
  2714. +   return mem_start;
  2715. +}
  2716. +
  2717. +#endif  /* CONFIG_CDU535 */
  2718. diff -u --recursive --new-file linux-1.1.58/drivers/block/version.h linux/drivers/block/version.h
  2719. --- linux-1.1.58/drivers/block/version.h    Wed Dec 31 18:00:00 1969
  2720. +++ linux/drivers/block/version.h    Wed Oct 26 23:02:00 1994
  2721. @@ -0,0 +1,7 @@
  2722. +#define UTS_RELEASE "1.1.53"
  2723. +#define UTS_VERSION "#8 Wed Oct 12 21:48:39 CDT 1994"
  2724. +#define LINUX_COMPILE_TIME "21:48:39"
  2725. +#define LINUX_COMPILE_BY "root"
  2726. +#define LINUX_COMPILE_HOST "fuzzy"
  2727. +#define LINUX_COMPILE_DOMAIN "is.a.good.cat"
  2728. +#define LINUX_COMPILER "gcc version 2.5.8"
  2729. diff -u --recursive --new-file linux-1.1.58/drivers/scsi/53c8xx_d.h linux/drivers/scsi/53c8xx_d.h
  2730. --- linux-1.1.58/drivers/scsi/53c8xx_d.h    Sat Sep 17 21:48:35 1994
  2731. +++ linux/drivers/scsi/53c8xx_d.h    Wed Oct 26 23:02:00 1994
  2732. @@ -296,7 +296,7 @@
  2733.  ABSOLUTE reselected_tag = 0
  2734.  
  2735.  ; Request sense command pointer, its a 6 byte command, should
  2736. -; be constant for all commands since we allays want 16 bytes of 
  2737. +; be constant for all commands since we always want 16 bytes of 
  2738.  ; sense and we don't need to change any fields as we did under 
  2739.  ; SCSI-I when we actually cared about the LUN field.
  2740.  ;EXTERNAL NCR53c7xx_sense        ; Request sense command
  2741. @@ -314,7 +314,7 @@
  2742.  ;
  2743.  ; MODIFIES : SCRATCH, reconnect_dsa_head
  2744.  ; 
  2745. -; EXITS : allays passes control to schedule
  2746. +; EXITS : always passes control to schedule
  2747.  
  2748.  ENTRY dsa_schedule
  2749.  dsa_schedule:
  2750. @@ -1378,7 +1378,7 @@
  2751.      ; XXX the ALU is only eight bits wide, and the assembler
  2752.      ; wont do the dirt work for us.  As long as dsa_check_reselect
  2753.      ; is negative, we need to sign extend with 1 bits to the full
  2754. -    ; 32 bit width of the address.
  2755. +    ; 32 bit width os the address.
  2756.      ;
  2757.      ; A potential work around would be to have a known alignment 
  2758.      ; of the DSA structure such that the base address plus 
  2759. diff -u --recursive --new-file linux-1.1.58/drivers/scsi/Makefile linux/drivers/scsi/Makefile
  2760. --- linux-1.1.58/drivers/scsi/Makefile    Sat Sep 17 21:47:29 1994
  2761. +++ linux/drivers/scsi/Makefile    Wed Oct 26 23:02:01 1994
  2762. @@ -62,6 +62,11 @@
  2763.  SCSI_SRCS := $(SCSI_SRCS) aha1740.c
  2764.  endif
  2765.  
  2766. +ifdef CONFIG_SCSI_AHA274X
  2767. +SCSI_OBJS := $(SCSI_OBJS) aha274x.o
  2768. +SCSI_SRCS := $(SCSI_SRCS) aha274x.c
  2769. +endif
  2770. +
  2771.  ifdef CONFIG_SCSI_BUSLOGIC
  2772.  SCSI_OBJS := $(SCSI_OBJS) buslogic.o
  2773.  SCSI_SRCS := $(SCSI_SRCS) buslogic.c
  2774. @@ -70,6 +75,11 @@
  2775.  ifdef CONFIG_SCSI_DEBUG
  2776.  SCSI_OBJS := $(SCSI_OBJS) scsi_debug.o
  2777.  SCSI_SRCS := $(SCSI_SRCS) scsi_debug.c
  2778. +endif
  2779. +
  2780. +ifdef CONFIG_SCSI_EATA
  2781. +SCSI_OBJS := $(SCSI_OBJS) eata.o
  2782. +SCSI_SRCS := $(SCSI_SRCS) eata.c
  2783.  endif
  2784.  
  2785.  ifdef CONFIG_SCSI_FUTURE_DOMAIN
  2786. diff -u --recursive --new-file linux-1.1.58/drivers/scsi/aha274x.c linux/drivers/scsi/aha274x.c
  2787. --- linux-1.1.58/drivers/scsi/aha274x.c    Wed Dec 31 18:00:00 1969
  2788. +++ linux/drivers/scsi/aha274x.c    Wed Oct 26 23:02:01 1994
  2789. @@ -0,0 +1,1449 @@
  2790. +/*
  2791. + *  @(#)aha274x.c 1.28 94/10/04 jda
  2792. + *
  2793. + *  Adaptec 274x device driver for Linux.
  2794. + *  Copyright (c) 1994 The University of Calgary Department of Computer Science.
  2795. + *  
  2796. + *  This program is free software; you can redistribute it and/or modify
  2797. + *  it under the terms of the GNU General Public License as published by
  2798. + *  the Free Software Foundation; either version 2 of the License, or
  2799. + *  (at your option) any later version.
  2800. + *  
  2801. + *  This program is distributed in the hope that it will be useful,
  2802. + *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  2803. + *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  2804. + *  GNU General Public License for more details.
  2805. + *  
  2806. + *  You should have received a copy of the GNU General Public License
  2807. + *  along with this program; if not, write to the Free Software
  2808. + *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  2809. + *
  2810. + *  Sources include the Adaptec 1740 driver (aha1740.c), the
  2811. + *  Ultrastor 24F driver (ultrastor.c), various Linux kernel
  2812. + *  source, the Adaptec EISA config file (!adp7771.cfg), the
  2813. + *  Adaptec AHA-2740A Series User's Guide, the Linux Kernel
  2814. + *  Hacker's Guide, Writing a SCSI Device Driver for Linux,
  2815. + *  the Adaptec 1542 driver (aha1542.c), the Adaptec EISA
  2816. + *  overlay file (adp7770.ovl), the Adaptec AHA-2740 Series
  2817. + *  Technical Reference Manual, the Adaptec AIC-7770 Data
  2818. + *  Book, the ANSI SCSI specification, the ANSI SCSI-2
  2819. + *  specification (draft 10c), ...
  2820. + *
  2821. + *  On a twin-bus adapter card, channel B is ignored.  Rationale:
  2822. + *  it would greatly complicate the sequencer and host driver code,
  2823. + *  and both busses are multiplexed on to the EISA bus anyway.  So
  2824. + *  I don't really see any technical advantage to supporting both.
  2825. + *
  2826. + *  As well, multiple adapter card using the same IRQ level are
  2827. + *  not supported.  It doesn't make sense to configure the cards
  2828. + *  this way from a performance standpoint.  Not to mention that
  2829. + *  the kernel would have to support two devices per registered IRQ.
  2830. + */
  2831. +
  2832. +#include <stdarg.h>
  2833. +#include <asm/io.h>
  2834. +#include <linux/string.h>
  2835. +#include <linux/kernel.h>
  2836. +#include <linux/ioport.h>
  2837. +#include <linux/delay.h>
  2838. +
  2839. +#include "../block/blk.h"
  2840. +#include "sd.h"
  2841. +#include "scsi.h"
  2842. +#include "hosts.h"
  2843. +#include "aha274x.h"
  2844. +
  2845. +/*
  2846. + *  There should be a specific return value for this in scsi.h, but
  2847. + *  it seems that most drivers ignore it.
  2848. + */
  2849. +#define DID_UNDERFLOW    DID_ERROR
  2850. +
  2851. +/* EISA stuff */
  2852. +
  2853. +#define MINEISA        1
  2854. +#define MAXEISA        15
  2855. +#define SLOTBASE(x)    ((x) << 12)
  2856. +
  2857. +#define MAXIRQ        15
  2858. +
  2859. +/* AIC-7770 offset definitions */
  2860. +
  2861. +#define O_MINREG(x)    ((x) + 0xc00)        /* i/o range to reserve */
  2862. +#define O_MAXREG(x)    ((x) + 0xcbf)
  2863. +
  2864. +#define O_SCSISEQ(x)    ((x) + 0xc00)        /* scsi sequence control */
  2865. +#define O_SCSISIGI(x)    ((x) + 0xc03)        /* scsi control signal read */
  2866. +#define O_SCSISIGO(x)    ((x) + 0xc03)        /* scsi control signal write */
  2867. +#define O_SCSIID(x)    ((x) + 0xc05)        /* scsi id */
  2868. +#define O_SSTAT0(x)    ((x) + 0xc0b)        /* scsi status register 0 */
  2869. +#define O_CLRSINT1(x)    ((x) + 0xc0c)        /* clear scsi interrupt 1 */
  2870. +#define O_SSTAT1(x)    ((x) + 0xc0c)        /* scsi status register 1 */
  2871. +#define O_SELID(x)    ((x) + 0xc19)        /* [re]selection id */
  2872. +#define O_SBLKCTL(x)    ((x) + 0xc1f)        /* scsi block control */
  2873. +#define O_SEQCTL(x)    ((x) + 0xc60)        /* sequencer control */
  2874. +#define O_SEQRAM(x)    ((x) + 0xc61)        /* sequencer ram data */
  2875. +#define O_SEQADDR(x)    ((x) + 0xc62)        /* sequencer address (W) */
  2876. +#define O_BIDx(x)    ((x) + 0xc80)        /* board id */
  2877. +#define O_BCTL(x)    ((x) + 0xc84)        /* board control */
  2878. +#define O_HCNTRL(x)    ((x) + 0xc87)        /* host control */
  2879. +#define O_SCBPTR(x)    ((x) + 0xc90)        /* scb pointer */
  2880. +#define O_INTSTAT(x)    ((x) + 0xc91)        /* interrupt status */
  2881. +#define O_ERROR(x)    ((x) + 0xc92)        /* hard error */
  2882. +#define O_CLRINT(x)    ((x) + 0xc92)        /* clear interrupt status */
  2883. +#define O_SCBCNT(x)    ((x) + 0xc9a)        /* scb auto increment */
  2884. +#define O_QINFIFO(x)    ((x) + 0xc9b)        /* queue in fifo */
  2885. +#define O_QINCNT(x)    ((x) + 0xc9c)        /* queue in count */
  2886. +#define O_QOUTFIFO(x)    ((x) + 0xc9d)        /* queue out fifo */
  2887. +#define O_QOUTCNT(x)    ((x) + 0xc9e)        /* queue out count */
  2888. +#define O_SCBARRAY(x)    ((x) + 0xca0)        /* scb array start */
  2889. +
  2890. +/* host adapter offset definitions */
  2891. +
  2892. +#define HA_REJBYTE(x)    ((x) + 0xc31)        /* 1st message in byte */
  2893. +#define HA_MSG_FLAGS(x)    ((x) + 0xc35)        /* outgoing message flag */
  2894. +#define HA_MSG_LEN(x)    ((x) + 0xc36)        /* outgoing message length */
  2895. +#define HA_MSG_START(x)    ((x) + 0xc37)        /* outgoing message body */
  2896. +#define HA_ARG_1(x)    ((x) + 0xc4c)        /* sdtr <-> rate parameters */
  2897. +#define HA_ARG_2(x)    ((x) + 0xc4d)
  2898. +#define HA_RETURN_1(x)    ((x) + 0xc4c)
  2899. +#define HA_RETURN_2(x)    ((x) + 0xc4d)
  2900. +#define HA_SIGSTATE(x)    ((x) + 0xc4e)        /* value in SCSISIGO */
  2901. +#define HA_NEEDSDTR(x)    ((x) + 0xc4f)        /* synchronous negotiation? */
  2902. +
  2903. +#define HA_SCSICONF(x)    ((x) + 0xc5a)        /* SCSI config register */
  2904. +#define HA_INTDEF(x)    ((x) + 0xc5c)        /* interrupt def'n register */
  2905. +#define HA_HOSTCONF(x)    ((x) + 0xc5d)        /* host config def'n register */
  2906. +
  2907. +/* debugging code */
  2908. +
  2909. +#define AHA274X_DEBUG
  2910. +
  2911. +/*
  2912. + *  If a parity error occurs during a data transfer phase, run the
  2913. + *  command to completion - it's easier that way - making a note
  2914. + *  of the error condition in this location.  This then will modify
  2915. + *  a DID_OK status into a DID_PARITY one for the higher-level SCSI
  2916. + *  code.
  2917. + */
  2918. +#define aha274x_parity(cmd)    ((cmd)->SCp.Status)
  2919. +
  2920. +/*
  2921. + *  Since the sequencer code DMAs the scatter-gather structures
  2922. + *  directly from memory, we use this macro to assert that the
  2923. + *  kernel structure hasn't changed.
  2924. + */
  2925. +#define SG_STRUCT_CHECK(sg) \
  2926. +    ((char *)&(sg).address - (char *)&(sg) != 0 ||    \
  2927. +     (char *)&(sg).length  - (char *)&(sg) != 8 ||    \
  2928. +     sizeof((sg).address) != 4 ||            \
  2929. +     sizeof((sg).length)  != 4 ||            \
  2930. +     sizeof(sg)          != 12)
  2931. +
  2932. +/*
  2933. + *  "Static" structures.  Note that these are NOT initialized
  2934. + *  to zero inside the kernel - we have to initialize them all
  2935. + *  explicitly.
  2936. + *
  2937. + *  We support a maximum of one adapter card per IRQ level (see the
  2938. + *  rationale for this above).  On an interrupt, use the IRQ as an
  2939. + *  index into aha274x_boards[] to locate the card information.
  2940. + */
  2941. +static struct Scsi_Host *aha274x_boards[MAXIRQ + 1];
  2942. +
  2943. +struct aha274x_host {
  2944. +    int base;                    /* card base address */
  2945. +    int startup;                    /* intr type check */
  2946. +    volatile int unpause;                /* value for HCNTRL */
  2947. +    volatile Scsi_Cmnd *SCB_array[AHA274X_MAXSCB];    /* active commands */
  2948. +};
  2949. +
  2950. +struct aha274x_scb {
  2951. +    unsigned char control;
  2952. +    unsigned char target_channel_lun;        /* 4/1/3 bits */
  2953. +    unsigned char SG_segment_count;
  2954. +    unsigned char SG_list_pointer[4];
  2955. +    unsigned char SCSI_cmd_pointer[4];
  2956. +    unsigned char SCSI_cmd_length;
  2957. +    unsigned char RESERVED[2];            /* must be zero */
  2958. +    unsigned char target_status;
  2959. +    unsigned char residual_data_count[3];
  2960. +    unsigned char residual_SG_segment_count;
  2961. +    unsigned char data_pointer[4];
  2962. +    unsigned char data_count[3];
  2963. +#if 0
  2964. +    /*
  2965. +     *  No real point in transferring this to the
  2966. +     *  SCB registers.
  2967. +     */
  2968. +    unsigned char RESERVED[6];
  2969. +#endif
  2970. +};
  2971. +
  2972. +/*
  2973. + *  NB.  This table MUST be ordered shortest period first.
  2974. + */
  2975. +static struct {
  2976. +    short period;
  2977. +    short rate;
  2978. +    char *english;
  2979. +} aha274x_synctab[] = {
  2980. +    100,    0,    "10.0",
  2981. +    125,    1,    "8.0",
  2982. +    150,    2,    "6.67",
  2983. +    175,    3,    "5.7",
  2984. +    200,    4,    "5.0",
  2985. +    225,    5,    "4.4",
  2986. +    250,    6,    "4.0",
  2987. +    275,    7,    "3.6"
  2988. +};
  2989. +
  2990. +static int aha274x_synctab_max =
  2991. +    sizeof(aha274x_synctab) / sizeof(aha274x_synctab[0]);
  2992. +
  2993. +enum aha_type {
  2994. +    T_NONE,
  2995. +    T_274X,
  2996. +    T_284X,
  2997. +    T_MAX
  2998. +};
  2999. +
  3000. +#ifdef AHA274X_DEBUG
  3001. +
  3002. +    extern int vsprintf(char *, const char *, va_list);
  3003. +
  3004. +    static
  3005. +    void debug(const char *fmt, ...)
  3006. +    {
  3007. +        va_list ap;
  3008. +        char buf[256];
  3009. +
  3010. +        va_start(ap, fmt);
  3011. +          vsprintf(buf, fmt, ap);
  3012. +          printk(buf);
  3013. +        va_end(ap);
  3014. +    }
  3015. +
  3016. +    static
  3017. +    void debug_config(enum aha_type type, int base)
  3018. +    {
  3019. +        int ioport2, ioport3, ioport4;
  3020. +
  3021. +        static char *BRT[T_MAX][16] = {
  3022. +            { },                    /* T_NONE */
  3023. +            {
  3024. +                "2",   "???", "???", "12",    /* T_274X */
  3025. +                "???", "???", "???", "28",
  3026. +                "???", "???", "???", "44",
  3027. +                "???", "???", "???", "60"
  3028. +            },
  3029. +            {
  3030. +                "2",  "4",  "8",  "12",        /* T_284X */
  3031. +                "16", "20", "24", "28",
  3032. +                "32", "36", "40", "44",
  3033. +                "48", "52", "56", "60"
  3034. +            }
  3035. +        };
  3036. +        static int DFT[4] = {
  3037. +            0, 50, 75, 100
  3038. +        };
  3039. +        static int SST[4] = {
  3040. +            256, 128, 64, 32
  3041. +        };
  3042. +
  3043. +        ioport2 = inb(HA_HOSTCONF(base));
  3044. +        ioport3 = inb(HA_SCSICONF(base));
  3045. +        ioport4 = inb(HA_INTDEF(base));
  3046. +
  3047. +        if (type == T_284X)
  3048. +            printk("AHA284X AT SLOT %d:\n", base >> 12);
  3049. +        else
  3050. +            printk("AHA274X AT EISA SLOT %d:\n", base >> 12);
  3051. +
  3052. +        printk("    irq %d\n"
  3053. +               "    bus release time %s bclks\n"
  3054. +               "    data fifo threshold %d%%\n",
  3055. +               ioport4 & 0xf,
  3056. +               BRT[type][(ioport2 >> 2) & 0xf],
  3057. +               DFT[(ioport2 >> 6) & 0x3]);
  3058. +
  3059. +        printk("    SCSI CHANNEL A:\n"
  3060. +               "        scsi id %d\n"
  3061. +               "        scsi bus parity check %sabled\n"
  3062. +               "        scsi selection timeout %d ms\n"
  3063. +               "        scsi bus reset at power-on %sabled\n",
  3064. +               ioport3 & 0x7,
  3065. +               (ioport3 & 0x20) ? "en" : "dis",
  3066. +               SST[(ioport3 >> 3) & 0x3],
  3067. +               (ioport3 & 0x40) ? "en" : "dis");
  3068. +
  3069. +        if (type == T_274X) {
  3070. +            printk("        scsi bus termination %sabled\n",
  3071. +                   (ioport3 & 0x80) ? "en" : "dis");
  3072. +        }
  3073. +    }
  3074. +
  3075. +    static
  3076. +    void debug_rate(int base, int rate)
  3077. +    {
  3078. +        int target = inb(O_SCSIID(base)) >> 4;
  3079. +
  3080. +        if (rate) {
  3081. +            printk("aha274x: target %d now synchronous at %sMb/s\n",
  3082. +                   target,
  3083. +                   aha274x_synctab[(rate >> 4) & 0x7].english);
  3084. +        } else {
  3085. +            printk("aha274x: target %d using asynchronous mode\n",
  3086. +                   target);
  3087. +        }
  3088. +    }
  3089. +
  3090. +#else
  3091. +
  3092. +#    define debug(fmt, args...)
  3093. +#    define debug_config(x)
  3094. +#    define debug_rate(x,y)
  3095. +
  3096. +#endif AHA274X_DEBUG
  3097. +
  3098. +static
  3099. +void aha274x_getscb(int base, struct aha274x_scb *scb)
  3100. +{
  3101. +    /*
  3102. +     *  This is almost identical to aha274x_putscb().
  3103. +     */
  3104. +    outb(0x80, O_SCBCNT(base));    /* SCBAUTO */
  3105. +
  3106. +    asm volatile("cld\n\t"
  3107. +             "rep\n\t"
  3108. +             "insb"
  3109. +             : /* no output */
  3110. +             :"D" (scb), "c" (sizeof(*scb)), "d" (O_SCBARRAY(base))
  3111. +             :"di", "cx", "dx");
  3112. +
  3113. +    outb(0, O_SCBCNT(base));
  3114. +}
  3115. +
  3116. +/*
  3117. + *  How much data should be transferred for this SCSI command?  Stop
  3118. + *  at segment sg_last if it's a scatter-gather command so we can
  3119. + *  compute underflow easily.
  3120. + */
  3121. +static
  3122. +unsigned aha274x_length(Scsi_Cmnd *cmd, int sg_last)
  3123. +{
  3124. +    int i, segments;
  3125. +    unsigned length;
  3126. +    struct scatterlist *sg;
  3127. +
  3128. +    segments = cmd->use_sg - sg_last;
  3129. +    sg = (struct scatterlist *)cmd->buffer;
  3130. +
  3131. +    if (cmd->use_sg) {
  3132. +        for (i = length = 0;
  3133. +             i < cmd->use_sg && i < segments;
  3134. +             i++)
  3135. +        {
  3136. +            length += sg[i].length;
  3137. +        }
  3138. +    } else
  3139. +        length = cmd->request_bufflen;
  3140. +
  3141. +    return(length);
  3142. +}
  3143. +
  3144. +static
  3145. +void aha274x_sg_check(Scsi_Cmnd *cmd)
  3146. +{
  3147. +    int i;
  3148. +    struct scatterlist *sg = (struct scatterlist *)cmd->buffer;
  3149. +
  3150. +    if (cmd->use_sg) {
  3151. +        for (i = 0; i < cmd->use_sg; i++)
  3152. +            if ((unsigned)sg[i].length > 0xffff)
  3153. +                panic("aha274x_sg_check: s/g segment > 64k\n");
  3154. +    }
  3155. +}
  3156. +
  3157. +static
  3158. +void aha274x_to_scsirate(unsigned char *rate,
  3159. +             unsigned char transfer,
  3160. +             unsigned char offset)
  3161. +{
  3162. +    int i;
  3163. +
  3164. +    transfer *= 4;
  3165. +
  3166. +    for (i = 0; i < aha274x_synctab_max-1; i++) {
  3167. +
  3168. +        if (transfer == aha274x_synctab[i].period) {
  3169. +            *rate = (aha274x_synctab[i].rate << 4) | (offset & 0xf);
  3170. +            return;
  3171. +        }
  3172. +
  3173. +        if (transfer > aha274x_synctab[i].period &&
  3174. +            transfer < aha274x_synctab[i+1].period)
  3175. +        {
  3176. +            *rate = (aha274x_synctab[i+1].rate << 4) |
  3177. +                (offset & 0xf);
  3178. +            return;
  3179. +        }
  3180. +    }
  3181. +    *rate = 0;
  3182. +}
  3183. +
  3184. +/*
  3185. + *  Pause the sequencer and wait for it to actually stop - this
  3186. + *  is important since the sequencer can disable pausing for critical
  3187. + *  sections.
  3188. + */
  3189. +#define PAUSE_SEQUENCER(p)    \
  3190. +    do {                                \
  3191. +        outb(0xe, O_HCNTRL(p->base));    /* IRQMS|PAUSE|INTEN */    \
  3192. +                                    \
  3193. +        while ((inb(O_HCNTRL(p->base)) & 0x4) == 0)        \
  3194. +            ;                        \
  3195. +    } while (0)
  3196. +
  3197. +/*
  3198. + *  Unpause the sequencer.  Unremarkable, yet done often enough to
  3199. + *  warrant an easy way to do it.
  3200. + */
  3201. +#define UNPAUSE_SEQUENCER(p)    \
  3202. +    outb(p->unpause, O_HCNTRL(p->base))    /* IRQMS|INTEN */
  3203. +
  3204. +/*
  3205. + *  See comments in aha274x_loadram() wrt this.
  3206. + */
  3207. +#define RESTART_SEQUENCER(p)    \
  3208. +    do {                        \
  3209. +        do {                    \
  3210. +            outb(0x2, O_SEQCTL(p->base));    \
  3211. +        } while (inw(O_SEQADDR(p->base)) != 0);    \
  3212. +                            \
  3213. +        UNPAUSE_SEQUENCER(p);            \
  3214. +    } while (0)
  3215. +
  3216. +/*
  3217. + *  Since we declared this using SA_INTERRUPT, interrupts should
  3218. + *  be disabled all through this function unless we say otherwise.
  3219. + */
  3220. +static
  3221. +void aha274x_isr(int irq)
  3222. +{
  3223. +    int base, intstat;
  3224. +    struct aha274x_host *p;
  3225. +    
  3226. +    p = (struct aha274x_host *)aha274x_boards[irq]->hostdata;
  3227. +    base = p->base;
  3228. +
  3229. +    /*
  3230. +     *  Check the startup flag - if no commands have been queued,
  3231. +     *  we probably have the interrupt type set wrong.  Reverse
  3232. +     *  the stored value and the active one in the host control
  3233. +     *  register.
  3234. +     */
  3235. +    if (p->startup) {
  3236. +        p->unpause ^= 0x8;
  3237. +        outb(inb(O_HCNTRL(p->base)) ^ 0x8, O_HCNTRL(p->base));
  3238. +        return;
  3239. +    }
  3240. +
  3241. +    /*
  3242. +     *  Handle all the interrupt sources - especially for SCSI
  3243. +     *  interrupts, we won't get a second chance at them.
  3244. +     */
  3245. +    intstat = inb(O_INTSTAT(base));
  3246. +
  3247. +    if (intstat & 0x8) {                /* BRKADRINT */
  3248. +
  3249. +        panic("aha274x_isr: brkadrint, error = 0x%x, seqaddr = 0x%x\n",
  3250. +              inb(O_ERROR(base)), inw(O_SEQADDR(base)));
  3251. +    }
  3252. +
  3253. +    if (intstat & 0x4) {                /* SCSIINT */
  3254. +
  3255. +        int scbptr = inb(O_SCBPTR(base));
  3256. +        int status = inb(O_SSTAT1(base));
  3257. +        Scsi_Cmnd *cmd;
  3258. +
  3259. +        cmd = (Scsi_Cmnd *)p->SCB_array[scbptr];
  3260. +        if (!cmd) {
  3261. +            printk("aha274x_isr: no command for scb (scsiint)\n");
  3262. +            /*
  3263. +             *  Turn off the interrupt and set status
  3264. +             *  to zero, so that it falls through the
  3265. +             *  reset of the SCSIINT code.
  3266. +             */
  3267. +            outb(status, O_CLRSINT1(base));
  3268. +            UNPAUSE_SEQUENCER(p);
  3269. +            outb(0x4, O_CLRINT(base));    /* undocumented */
  3270. +            status = 0;
  3271. +        }
  3272. +        p->SCB_array[scbptr] = NULL;
  3273. +
  3274. +        /*
  3275. +         *  Only the SCSI Status 1 register has information
  3276. +         *  about exceptional conditions that we'd have a
  3277. +         *  SCSIINT about; anything in SSTAT0 will be handled
  3278. +         *  by the sequencer.  Note that there can be multiple
  3279. +         *  bits set.
  3280. +         */
  3281. +        if (status & 0x80) {            /* SELTO */
  3282. +            /*
  3283. +             *  Hardware selection timer has expired.  Turn
  3284. +             *  off SCSI selection sequence.
  3285. +             */
  3286. +            outb(0, O_SCSISEQ(base));
  3287. +            cmd->result = DID_TIME_OUT << 16;
  3288. +
  3289. +            /*
  3290. +             *  If there's an active message, it belongs to the
  3291. +             *  command that is getting punted - remove it.
  3292. +             */
  3293. +            outb(0, HA_MSG_FLAGS(base));
  3294. +
  3295. +            /*
  3296. +             *  Shut off the offending interrupt sources, reset
  3297. +             *  the sequencer address to zero and unpause it,
  3298. +             *  then call the high-level SCSI completion routine.
  3299. +             *
  3300. +             *  WARNING!  This is a magic sequence!  After many
  3301. +             *  hours of guesswork, turning off the SCSI interrupts
  3302. +             *  in CLRSINT? does NOT clear the SCSIINT bit in
  3303. +             *  INTSTAT.  By writing to the (undocumented, unused
  3304. +             *  according to the AIC-7770 manual) third bit of
  3305. +             *  CLRINT, you can clear INTSTAT.  But, if you do it
  3306. +             *  while the sequencer is paused, you get a BRKADRINT
  3307. +             *  with an Illegal Host Address status, so the
  3308. +             *  sequencer has to be restarted first.
  3309. +             */
  3310. +            outb(0x80, O_CLRSINT1(base));    /* CLRSELTIMO */
  3311. +            RESTART_SEQUENCER(p);
  3312. +
  3313. +            outb(0x4, O_CLRINT(base));    /* undocumented */
  3314. +            cmd->scsi_done(cmd);
  3315. +        }
  3316. +
  3317. +        if (status & 0x4) {            /* SCSIPERR */
  3318. +            /*
  3319. +             *  A parity error has occurred during a data
  3320. +             *  transfer phase.  Flag it and continue.
  3321. +             */
  3322. +            printk("aha274x: parity error on target %d, lun %d\n",
  3323. +                   cmd->target,
  3324. +                   cmd->lun);
  3325. +            aha274x_parity(cmd) = DID_PARITY;
  3326. +
  3327. +            /*
  3328. +             *  Clear interrupt and resume as above.
  3329. +             */
  3330. +            outb(0x4, O_CLRSINT1(base));    /* CLRSCSIPERR */
  3331. +            UNPAUSE_SEQUENCER(p);
  3332. +
  3333. +            outb(0x4, O_CLRINT(base));    /* undocumented */
  3334. +        }
  3335. +
  3336. +        if ((status & (0x8|0x4)) == 0 && status) {
  3337. +            /*
  3338. +             *  We don't know what's going on.  Turn off the
  3339. +             *  interrupt source and try to continue.
  3340. +             */
  3341. +            printk("aha274x_isr: sstat1 = 0x%x\n", status);
  3342. +            outb(status, O_CLRSINT1(base));
  3343. +            UNPAUSE_SEQUENCER(p);
  3344. +            outb(0x4, O_CLRINT(base));    /* undocumented */
  3345. +        }
  3346. +    }
  3347. +
  3348. +    if (intstat & 0x2) {                /* CMDCMPLT */
  3349. +
  3350. +        int complete, old_scbptr;
  3351. +        struct aha274x_scb scb;
  3352. +        unsigned actual;
  3353. +        Scsi_Cmnd *cmd;
  3354. +
  3355. +        /*
  3356. +         *  The sequencer will continue running when it
  3357. +         *  issues this interrupt.  There may be >1 commands
  3358. +         *  finished, so loop until we've processed them all.
  3359. +         */
  3360. +        do {
  3361. +            complete = inb(O_QOUTFIFO(base));
  3362. +
  3363. +            cmd = (Scsi_Cmnd *)p->SCB_array[complete];
  3364. +            if (!cmd) {
  3365. +                printk("aha274x warning: "
  3366. +                       "no command for scb (cmdcmplt)\n");
  3367. +                continue;
  3368. +            }
  3369. +            p->SCB_array[complete] = NULL;
  3370. +            
  3371. +            PAUSE_SEQUENCER(p);
  3372. +
  3373. +            /*
  3374. +             *  After pausing the sequencer (and waiting
  3375. +             *  for it to stop), save its SCB pointer, then
  3376. +             *  write in our completed one and read the SCB
  3377. +             *  registers.  Afterwards, restore the saved
  3378. +             *  pointer, unpause the sequencer and call the
  3379. +             *  higher-level completion function - unpause
  3380. +             *  first since we have no idea how long done()
  3381. +             *  will take.
  3382. +             */
  3383. +            old_scbptr = inb(O_SCBPTR(base));
  3384. +            outb(complete, O_SCBPTR(base));
  3385. +
  3386. +            aha274x_getscb(base, &scb);
  3387. +            outb(old_scbptr, O_SCBPTR(base));
  3388. +
  3389. +            UNPAUSE_SEQUENCER(p);
  3390. +
  3391. +            cmd->result = scb.target_status |
  3392. +                     (aha274x_parity(cmd) << 16);
  3393. +
  3394. +            /*
  3395. +             *  Did we underflow?  At this time, there's only
  3396. +             *  one other driver that bothers to check for this,
  3397. +             *  and cmd->underflow seems to be set rather half-
  3398. +             *  heartedly in the higher-level SCSI code.
  3399. +             */
  3400. +            actual = aha274x_length(cmd,
  3401. +                        scb.residual_SG_segment_count);
  3402. +
  3403. +            actual -= ((scb.residual_data_count[2] << 16) |
  3404. +                   (scb.residual_data_count[1] <<  8) |
  3405. +                   (scb.residual_data_count[0]));
  3406. +
  3407. +            if (actual < cmd->underflow) {
  3408. +                printk("aha274x: target %d underflow - "
  3409. +                       "wanted (at least) %u, got %u\n",
  3410. +                       cmd->target, cmd->underflow, actual);
  3411. +
  3412. +                cmd->result = scb.target_status |
  3413. +                         (DID_UNDERFLOW << 16);
  3414. +            }
  3415. +
  3416. +            cmd->scsi_done(cmd);
  3417. +
  3418. +            /*
  3419. +             *  Clear interrupt status before checking
  3420. +             *  the output queue again.  This eliminates
  3421. +             *  a race condition whereby a command could
  3422. +             *  complete between the queue poll and the
  3423. +             *  interrupt clearing, so notification of the
  3424. +             *  command being complete never made it back
  3425. +             *  up to the kernel.
  3426. +             */
  3427. +            outb(0x2, O_CLRINT(base));    /* CLRCMDINT */
  3428. +
  3429. +        } while (inb(O_QOUTCNT(base)));
  3430. +    }
  3431. +
  3432. +    if (intstat & 0x1) {                /* SEQINT */
  3433. +
  3434. +        unsigned char transfer, offset, rate;
  3435. +
  3436. +        /*
  3437. +         *  Although the sequencer is paused immediately on
  3438. +         *  a SEQINT, an interrupt for a SCSIINT or a CMDCMPLT
  3439. +         *  condition will have unpaused the sequencer before
  3440. +         *  this point.
  3441. +         */
  3442. +        PAUSE_SEQUENCER(p);
  3443. +
  3444. +        switch (intstat & 0xf0) {
  3445. +            case 0x00:
  3446. +            panic("aha274x_isr: unknown scsi bus phase\n");
  3447. +            case 0x10:
  3448. +            debug("aha274x_isr warning: "
  3449. +                  "issuing message reject, 1st byte 0x%x\n",
  3450. +                  inb(HA_REJBYTE(base)));
  3451. +            break;
  3452. +            case 0x20:
  3453. +            panic("aha274x_isr: reconnecting target %d "
  3454. +                  "didn't issue IDENTIFY message\n",
  3455. +                  (inb(O_SELID(base)) >> 4) & 0xf);
  3456. +            case 0x30:
  3457. +            debug("aha274x_isr: sequencer couldn't find match "
  3458. +                  "for reconnecting target %d - issuing ABORT\n",
  3459. +                  (inb(O_SELID(base)) >> 4) & 0xf);
  3460. +            break;
  3461. +            case 0x40:
  3462. +            transfer = inb(HA_ARG_1(base));
  3463. +            offset = inb(HA_ARG_2(base));
  3464. +            aha274x_to_scsirate(&rate, transfer, offset);
  3465. +            outb(rate, HA_RETURN_1(base));
  3466. +            debug_rate(base, rate);
  3467. +            break;
  3468. +            default:
  3469. +            debug("aha274x_isr: seqint, "
  3470. +                  "intstat = 0x%x, scsisigi = 0x%x\n",
  3471. +                  intstat, inb(O_SCSISIGI(base)));
  3472. +            break;
  3473. +        }
  3474. +
  3475. +        outb(0x1, O_CLRINT(base));        /* CLRSEQINT */
  3476. +        UNPAUSE_SEQUENCER(p);
  3477. +    }
  3478. +}
  3479. +
  3480. +/*
  3481. + *  Probing for EISA boards: it looks like the first two bytes
  3482. + *  are a manufacturer code - three characters, five bits each:
  3483. + *
  3484. + *         BYTE 0   BYTE 1   BYTE 2   BYTE 3
  3485. + *        ?1111122 22233333 PPPPPPPP RRRRRRRR
  3486. + *
  3487. + *  The characters are baselined off ASCII '@', so add that value
  3488. + *  to each to get the real ASCII code for it.  The next two bytes
  3489. + *  appear to be a product and revision number, probably vendor-
  3490. + *  specific.  This is what is being searched for at each port,
  3491. + *  and what should probably correspond to the ID= field in the
  3492. + *  ECU's .cfg file for the card - if your card is not detected,
  3493. + *  make sure your signature is listed in the array.
  3494. + *
  3495. + *  The fourth byte's lowest bit seems to be an enabled/disabled
  3496. + *  flag (rest of the bits are reserved?).
  3497. + */
  3498. +
  3499. +static
  3500. +enum aha_type aha274x_probe(int slot, int s_base)
  3501. +{
  3502. +    int i;
  3503. +    unsigned char buf[4];
  3504. +
  3505. +    static struct {
  3506. +        int n;
  3507. +        unsigned char signature[sizeof(buf)];
  3508. +        enum aha_type type;
  3509. +    } S[] = {
  3510. +        4, { 0x04, 0x90, 0x77, 0x71 }, T_274X,    /* host adapter 274x */
  3511. +        4, { 0x04, 0x90, 0x77, 0x70 }, T_274X,    /* motherboard 274x  */
  3512. +        4, { 0x04, 0x90, 0x77, 0x56 }, T_284X,    /* 284x, BIOS enabled */
  3513. +    };
  3514. +
  3515. +    for (i = 0; i < sizeof(buf); i++) {
  3516. +        /*
  3517. +         *  The VL-bus cards need to be primed by
  3518. +         *  writing before a signature check.
  3519. +         */
  3520. +        outb(0x80 + i, s_base);
  3521. +        buf[i] = inb(s_base + i);
  3522. +    }
  3523. +
  3524. +    for (i = 0; i < sizeof(S)/sizeof(S[0]); i++) {
  3525. +        if (!memcmp(buf, S[i].signature, S[i].n)) {
  3526. +            /*
  3527. +             *  Signature match on enabled card?
  3528. +             */
  3529. +            if (inb(s_base + 4) & 1)
  3530. +                return(S[i].type);
  3531. +            printk("aha274x disabled at slot %d, ignored\n", slot);
  3532. +        }
  3533. +    }
  3534. +    return(T_NONE);
  3535. +}
  3536. +
  3537. +/*
  3538. + *  Return ' ' for plain 274x, 'T' for twin-channel, 'W' for
  3539. + *  wide channel, '?' for anything else.
  3540. + */
  3541. +
  3542. +static
  3543. +char aha274x_type(int base)
  3544. +{
  3545. +    /*
  3546. +     *  The AIC-7770 can be wired so that, on chip reset,
  3547. +     *  the SCSI Block Control register indicates how many
  3548. +     *  busses the chip is configured for.
  3549. +     */
  3550. +    switch (inb(O_SBLKCTL(base))) {
  3551. +        case 0:
  3552. +        return(' ');
  3553. +        case 2:
  3554. +        return('W');
  3555. +        case 8:
  3556. +        return('T');
  3557. +        default:
  3558. +        printk("aha274x has unknown bus configuration\n");
  3559. +        return('?');
  3560. +    }
  3561. +}
  3562. +
  3563. +static
  3564. +void aha274x_loadram(int base)
  3565. +{
  3566. +    static unsigned char seqprog[] = {
  3567. +        /*
  3568. +         *  Each sequencer instruction is 29 bits
  3569. +         *  long (fill in the excess with zeroes)
  3570. +         *  and has to be loaded from least -> most
  3571. +         *  significant byte, so this table has the
  3572. +         *  byte ordering reversed.
  3573. +         */
  3574. +#        include "aha274x_seq.h"
  3575. +    };
  3576. +
  3577. +    /*
  3578. +     *  When the AIC-7770 is paused (as on chip reset), the
  3579. +     *  sequencer address can be altered and a sequencer
  3580. +     *  program can be loaded by writing it, byte by byte, to
  3581. +     *  the sequencer RAM port - the Adaptec documentation
  3582. +     *  recommends using REP OUTSB to do this, hence the inline
  3583. +     *  assembly.  Since the address autoincrements as we load
  3584. +     *  the program, reset it back to zero afterward.  Disable
  3585. +     *  sequencer RAM parity error detection while loading, and
  3586. +     *  make sure the LOADRAM bit is enabled for loading.
  3587. +     */
  3588. +    outb(0x83, O_SEQCTL(base));    /* PERRORDIS|SEQRESET|LOADRAM */
  3589. +
  3590. +    asm volatile("cld\n\t"
  3591. +             "rep\n\t"
  3592. +             "outsb"
  3593. +             : /* no output */
  3594. +             :"S" (seqprog), "c" (sizeof(seqprog)), "d" (O_SEQRAM(base))
  3595. +             :"si", "cx", "dx");
  3596. +
  3597. +    /*
  3598. +     *  WARNING!  This is a magic sequence!  After extensive
  3599. +     *  experimentation, it seems that you MUST turn off the
  3600. +     *  LOADRAM bit before you play with SEQADDR again, else
  3601. +     *  you will end up with parity errors being flagged on
  3602. +     *  your sequencer program.  (You would also think that
  3603. +     *  turning off LOADRAM and setting SEQRESET to reset the
  3604. +     *  address to zero would work, but you need to do it twice
  3605. +     *  for it to take effect on the address.  Timing problem?)
  3606. +     */
  3607. +    outb(0, O_SEQCTL(base));
  3608. +    do {
  3609. +        /*
  3610. +         *  Actually, reset it until
  3611. +         *  the address shows up as
  3612. +         *  zero just to be safe..
  3613. +         */
  3614. +        outb(0x2, O_SEQCTL(base));    /* SEQRESET */
  3615. +
  3616. +    } while (inw(O_SEQADDR(base)) != 0);
  3617. +}
  3618. +
  3619. +static
  3620. +int aha274x_register(Scsi_Host_Template *template,
  3621. +             enum aha_type type,
  3622. +             int base)
  3623. +{
  3624. +    int i, irq, scsi_id;
  3625. +    struct Scsi_Host *host;
  3626. +    struct aha274x_host *p;
  3627. +
  3628. +    /*
  3629. +     *  Give the AIC-7770 a reset - reading the 274x's registers
  3630. +     *  returns zeroes unless you do.  This forces a pause of the
  3631. +     *  Sequencer.
  3632. +     */
  3633. +    outb(1, O_HCNTRL(base));    /* CHIPRST */
  3634. +
  3635. +    /*
  3636. +     *  The IRQ level in i/o port 4 maps directly onto the real
  3637. +     *  IRQ number.  If it's ok, register it with the kernel.
  3638. +     *
  3639. +     *  NB. the Adaptec documentation says the IRQ number is only
  3640. +     *    in the lower four bits; the ECU information shows the
  3641. +     *    high bit being used as well.  Which is correct?
  3642. +     */
  3643. +    irq = inb(HA_INTDEF(base)) & 0xf;
  3644. +    if (irq < 9 || irq > 15) {
  3645. +        printk("aha274x uses unsupported IRQ level, ignoring\n");
  3646. +        return(0);
  3647. +    }
  3648. +    
  3649. +    /*
  3650. +     *  Lock out other contenders for our i/o space.
  3651. +     */
  3652. +    snarf_region(O_MINREG(base), O_MAXREG(base)-O_MINREG(base));
  3653. +
  3654. +    /*
  3655. +     *  Any card-type-specific adjustments before we register
  3656. +     *  the scsi host(s).
  3657. +     */
  3658. +
  3659. +    scsi_id = inb(HA_SCSICONF(base)) & 0x7;
  3660. +
  3661. +    switch (aha274x_type(base)) {
  3662. +        case 'T':
  3663. +        printk("aha274x warning: ignoring channel B of 274x-twin\n");
  3664. +        break;
  3665. +        case ' ':
  3666. +        break;
  3667. +        default:
  3668. +        printk("aha274x is an unsupported type, ignoring\n");
  3669. +        return(0);
  3670. +    }
  3671. +
  3672. +    /*
  3673. +     *  Before registry, make sure that the offsets of the
  3674. +     *  struct scatterlist are what the sequencer will expect,
  3675. +     *  otherwise disable scatter-gather altogether until someone
  3676. +     *  can fix it.  This is important since the sequencer will
  3677. +     *  DMA elements of the SG array in while executing commands.
  3678. +     */
  3679. +    if (template->sg_tablesize != SG_NONE) {
  3680. +        struct scatterlist sg;
  3681. +
  3682. +        if (SG_STRUCT_CHECK(sg)) {
  3683. +            printk("aha274x warning: kernel scatter-gather "
  3684. +                   "structures changed, disabling it\n");
  3685. +            template->sg_tablesize = SG_NONE;
  3686. +        }
  3687. +    }
  3688. +    
  3689. +    /*
  3690. +     *  Register each "host" and fill in the returned Scsi_Host
  3691. +     *  structure as best we can.  Some of the parameters aren't
  3692. +     *  really relevant for EISA, and none of the high-level SCSI
  3693. +     *  code looks at it anyway.. why are the fields there?  Also
  3694. +     *  save the pointer so that we can find the information when
  3695. +     *  an IRQ is triggered.
  3696. +     */
  3697. +    host = scsi_register(template, sizeof(struct aha274x_host));
  3698. +    host->this_id = scsi_id;
  3699. +    host->irq = irq;
  3700. +
  3701. +    aha274x_boards[irq] = host;
  3702. +    
  3703. +    p = (struct aha274x_host *)host->hostdata;
  3704. +    for (i = 0; i < AHA274X_MAXSCB; i++)
  3705. +        p->SCB_array[i] = NULL;
  3706. +    p->base = base;
  3707. +
  3708. +    /*
  3709. +     *  The interrupt trigger is different depending
  3710. +     *  on whether the card is EISA or VL-bus - sometimes.
  3711. +     *  The startup variable will be cleared once the first
  3712. +     *  command is queued, and is checked in the isr to
  3713. +     *  try and detect when the interrupt type is set
  3714. +     *  incorrectly, triggering an interrupt immediately.
  3715. +     */
  3716. +    p->unpause = (type != T_274X ? 0x2 : 0xa);
  3717. +    p->startup = !0;
  3718. +
  3719. +    /*
  3720. +     *  Register IRQ with the kernel _after_ the host information
  3721. +     *  is set up, in case we take an interrupt right away, due to
  3722. +     *  the interrupt type being set wrong.
  3723. +     */
  3724. +    if (request_irq(irq, aha274x_isr, SA_INTERRUPT, "AHA274x/284x")) {
  3725. +        printk("aha274x couldn't register irq %d, ignoring\n", irq);
  3726. +        return(0);
  3727. +    }
  3728. +
  3729. +    /*
  3730. +     *  Print out debugging information before re-enabling
  3731. +     *  the card - a lot of registers on it can't be read
  3732. +     *  when the sequencer is active.
  3733. +     */
  3734. +    debug_config(type, base);
  3735. +
  3736. +    /*
  3737. +     *  Load the sequencer program, then re-enable the board -
  3738. +     *  resetting the AIC-7770 disables it, leaving the lights
  3739. +     *  on with nobody home.
  3740. +     */
  3741. +    aha274x_loadram(base);
  3742. +    outb(1, O_BCTL(base));        /* ENABLE */
  3743. +
  3744. +    /*
  3745. +     *  Set the host adapter registers to indicate that synchronous
  3746. +     *  negotiation should be attempted the first time the targets
  3747. +     *  are communicated with.  Also initialize the active message
  3748. +     *  flag to indicate that there is no message.
  3749. +     */
  3750. +    outb(0xff, HA_NEEDSDTR(base));
  3751. +    outb(0, HA_MSG_FLAGS(base));
  3752. +
  3753. +    /*
  3754. +     *  Unpause the sequencer before returning and enable
  3755. +     *  interrupts - we shouldn't get any until the first
  3756. +     *  command is sent to us by the high-level SCSI code.
  3757. +     */
  3758. +    UNPAUSE_SEQUENCER(p);
  3759. +    return(1);
  3760. +}
  3761. +
  3762. +int aha274x_detect(Scsi_Host_Template *template)
  3763. +{
  3764. +    enum aha_type type;
  3765. +    int found = 0, slot, base;
  3766. +
  3767. +    for (slot = MINEISA; slot <= MAXEISA; slot++) {
  3768. +
  3769. +        base = SLOTBASE(slot);
  3770. +        
  3771. +        if (check_region(O_MINREG(base),
  3772. +                 O_MAXREG(base)-O_MINREG(base)))
  3773. +        {
  3774. +            /*
  3775. +             *  Some other driver has staked a
  3776. +             *  claim to this i/o region already.
  3777. +             */
  3778. +            continue;
  3779. +        }
  3780. +
  3781. +        type = aha274x_probe(slot, O_BIDx(base));
  3782. +
  3783. +        if (type != T_NONE) {
  3784. +            /*
  3785. +             *  We "find" a 274x if we locate the card
  3786. +             *  signature and we can set it up and register
  3787. +             *  it with the kernel without incident.
  3788. +             */
  3789. +            found += aha274x_register(template, type, base);
  3790. +        }
  3791. +    }
  3792. +    template->name = (char *)aha274x_info();
  3793. +    return(found);
  3794. +}
  3795. +
  3796. +const char *aha274x_info(void)
  3797. +{
  3798. +    return("Adaptec AHA274x/284x (EISA/VL-bus -> Fast SCSI) "
  3799. +           AHA274X_SEQ_VERSION "/"
  3800. +           AHA274X_H_VERSION "/"
  3801. +           "1.28");
  3802. +}
  3803. +
  3804. +int aha274x_command(Scsi_Cmnd *cmd)
  3805. +{
  3806. +    /*
  3807. +     *  This is a relic of non-interrupt-driven SCSI
  3808. +     *  drivers.  With the can_queue variable set, this
  3809. +     *  should never be called.
  3810. +     */
  3811. +    panic("aha274x_command was called\n");
  3812. +}
  3813. +
  3814. +static
  3815. +void aha274x_buildscb(struct aha274x_host *p,
  3816. +              Scsi_Cmnd *cmd,
  3817. +              struct aha274x_scb *scb)
  3818. +{
  3819. +    void *addr;
  3820. +    unsigned length;
  3821. +
  3822. +    memset(scb, 0, sizeof(*scb));
  3823. +
  3824. +    /*
  3825. +     *  NB. channel selection (bit 3) is always zero.
  3826. +     */
  3827. +    scb->target_channel_lun = ((cmd->target << 4) & 0xf0) |
  3828. +                   (cmd->lun & 0x7);
  3829. +
  3830. +    /*
  3831. +     *  The interpretation of request_buffer and request_bufflen
  3832. +     *  changes depending on whether or not use_sg is zero; a
  3833. +     *  non-zero use_sg indicates the number of elements in the
  3834. +     *  scatter-gather array.
  3835. +     *
  3836. +     *  The AIC-7770 can't support transfers of any sort larger
  3837. +     *  than 2^24 (three-byte count) without backflips.  For what
  3838. +     *  the kernel is doing, this shouldn't occur.  I hope.
  3839. +     */
  3840. +    length = aha274x_length(cmd, 0);
  3841. +
  3842. +    /*
  3843. +     *  The sequencer code cannot yet handle scatter-gather segments
  3844. +     *  larger than 64k (two-byte length).  The 1.1.x kernels, however,
  3845. +     *  have a four-byte length field in the struct scatterlist, so
  3846. +     *  make sure we don't exceed 64k on these kernels for now.
  3847. +     */
  3848. +    aha274x_sg_check(cmd);
  3849. +
  3850. +    if (length > 0xffffff) {
  3851. +        panic("aha274x_buildscb: can't transfer > 2^24 - 1 bytes\n");
  3852. +    }
  3853. +
  3854. +    /*
  3855. +     *  XXX - this relies on the host data being stored in a
  3856. +     *      little-endian format.
  3857. +     */
  3858. +    addr = cmd->cmnd;
  3859. +    scb->SCSI_cmd_length = COMMAND_SIZE(cmd->cmnd[0]);
  3860. +    memcpy(scb->SCSI_cmd_pointer, &addr, sizeof(scb->SCSI_cmd_pointer));
  3861. +
  3862. +    if (cmd->use_sg) {
  3863. +#if 0
  3864. +        debug("aha274x_buildscb: SG used, %d segments, length %u\n",
  3865. +              cmd->use_sg,
  3866. +              length);
  3867. +#endif
  3868. +        scb->SG_segment_count = cmd->use_sg;
  3869. +        memcpy(scb->SG_list_pointer,
  3870. +               &cmd->request_buffer,
  3871. +               sizeof(scb->SG_list_pointer));
  3872. +    } else {
  3873. +        scb->SG_segment_count = 0;
  3874. +        memcpy(scb->data_pointer,
  3875. +               &cmd->request_buffer,
  3876. +               sizeof(scb->data_pointer));
  3877. +        memcpy(scb->data_count,
  3878. +               &cmd->request_bufflen,
  3879. +               sizeof(scb->data_count));
  3880. +    }
  3881. +}
  3882. +
  3883. +static
  3884. +void aha274x_putscb(int base, struct aha274x_scb *scb)
  3885. +{
  3886. +    /*
  3887. +     *  By turning on the SCB auto increment, any reference
  3888. +     *  to the SCB I/O space postincrements the SCB address
  3889. +     *  we're looking at.  So turn this on and dump the relevant
  3890. +     *  portion of the SCB to the card.
  3891. +     */
  3892. +    outb(0x80, O_SCBCNT(base));    /* SCBAUTO */
  3893. +
  3894. +    asm volatile("cld\n\t"
  3895. +             "rep\n\t"
  3896. +             "outsb"
  3897. +             : /* no output */
  3898. +             :"S" (scb), "c" (sizeof(*scb)), "d" (O_SCBARRAY(base))
  3899. +             :"si", "cx", "dx");
  3900. +
  3901. +    outb(0, O_SCBCNT(base));
  3902. +}
  3903. +
  3904. +int aha274x_queue(Scsi_Cmnd *cmd, void (*fn)(Scsi_Cmnd *))
  3905. +{
  3906. +    long flags;
  3907. +    int empty, old_scbptr;
  3908. +    struct aha274x_host *p;
  3909. +    struct aha274x_scb scb;
  3910. +
  3911. +#if 0
  3912. +    debug("aha274x_queue: cmd 0x%x (size %u), target %d, lun %d\n",
  3913. +          cmd->cmnd[0],
  3914. +          COMMAND_SIZE(cmd->cmnd[0]),
  3915. +          cmd->target,
  3916. +          cmd->lun);
  3917. +#endif
  3918. +
  3919. +    p = (struct aha274x_host *)cmd->host->hostdata;
  3920. +
  3921. +    /*
  3922. +     *  Construct the SCB beforehand, so the sequencer is
  3923. +     *  paused a minimal amount of time.
  3924. +     */
  3925. +    aha274x_buildscb(p, cmd, &scb);
  3926. +
  3927. +    /*
  3928. +     *  Clear the startup flag - we can now legitimately
  3929. +     *  expect interrupts.
  3930. +     */
  3931. +    p->startup = 0;
  3932. +
  3933. +    /*
  3934. +     *  This is a critical section, since we don't want the
  3935. +     *  interrupt routine mucking with the host data or the
  3936. +     *  card.  Since the kernel documentation is vague on
  3937. +     *  whether or not we are in a cli/sti pair already, save
  3938. +     *  the flags to be on the safe side.
  3939. +     */
  3940. +    save_flags(flags);
  3941. +    cli();
  3942. +
  3943. +    /*
  3944. +     *  Find a free slot in the SCB array to load this command
  3945. +     *  into.  Since can_queue is set to AHA274X_MAXSCB, we
  3946. +     *  should always find one.
  3947. +     */
  3948. +    for (empty = 0; empty < AHA274X_MAXSCB; empty++)
  3949. +        if (!p->SCB_array[empty])
  3950. +            break;
  3951. +    if (empty == AHA274X_MAXSCB)
  3952. +        panic("aha274x_queue: couldn't find a free scb\n");
  3953. +
  3954. +    /*
  3955. +     *  Pause the sequencer so we can play with its registers -
  3956. +     *  wait for it to acknowledge the pause.
  3957. +     *
  3958. +     *  XXX - should the interrupts be left on while doing this?
  3959. +     */
  3960. +    PAUSE_SEQUENCER(p);
  3961. +
  3962. +    /*
  3963. +     *  Save the SCB pointer and put our own pointer in - this
  3964. +     *  selects one of the four banks of SCB registers.  Load
  3965. +     *  the SCB, then write its pointer into the queue in FIFO
  3966. +     *  and restore the saved SCB pointer.
  3967. +     */
  3968. +    old_scbptr = inb(O_SCBPTR(p->base));
  3969. +    outb(empty, O_SCBPTR(p->base));
  3970. +    
  3971. +    aha274x_putscb(p->base, &scb);
  3972. +
  3973. +    outb(empty, O_QINFIFO(p->base));
  3974. +    outb(old_scbptr, O_SCBPTR(p->base));
  3975. +
  3976. +    /*
  3977. +     *  Make sure the Scsi_Cmnd pointer is saved, the struct it
  3978. +     *  points to is set up properly, and the parity error flag
  3979. +     *  is reset, then unpause the sequencer and watch the fun
  3980. +     *  begin.
  3981. +     */
  3982. +    cmd->scsi_done = fn;
  3983. +    p->SCB_array[empty] = cmd;
  3984. +    aha274x_parity(cmd) = DID_OK;
  3985. +
  3986. +    UNPAUSE_SEQUENCER(p);
  3987. +
  3988. +    restore_flags(flags);
  3989. +    return(0);
  3990. +}
  3991. +
  3992. +/* return values from aha274x_kill */
  3993. +
  3994. +enum k_state {
  3995. +    k_ok,                /* scb found and message sent */
  3996. +    k_busy,                /* message already present */
  3997. +    k_absent,            /* couldn't locate scb */
  3998. +    k_disconnect,            /* scb found, but disconnected */
  3999. +};
  4000. +
  4001. +/*
  4002. + *  This must be called with interrupts disabled - it's going to
  4003. + *  be messing around with the host data, and an interrupt being
  4004. + *  fielded in the middle could get ugly.
  4005. + *
  4006. + *  Since so much of the abort and reset code is shared, this
  4007. + *  function performs more magic than it really should.  If the
  4008. + *  command completes ok, then it will call scsi_done with the
  4009. + *  result code passed in.  The unpause parameter controls whether
  4010. + *  or not the sequencer gets unpaused - the reset function, for
  4011. + *  instance, may want to do something more aggressive.
  4012. + *
  4013. + *  Note that the command is checked for in our SCB_array first
  4014. + *  before the sequencer is paused, so if k_absent is returned,
  4015. + *  then the sequencer is NOT paused.
  4016. + */
  4017. +
  4018. +static
  4019. +enum k_state aha274x_kill(Scsi_Cmnd *cmd, unsigned char message,
  4020. +              unsigned int result, int unpause)
  4021. +{
  4022. +    struct aha274x_host *p;
  4023. +    int i, scb, found, queued;
  4024. +    unsigned char scbsave[AHA274X_MAXSCB];
  4025. +
  4026. +    p = (struct aha274x_host *)cmd->host->hostdata;
  4027. +
  4028. +    /*
  4029. +     *  If we can't find the command, assume it just completed
  4030. +     *  and shrug it away.
  4031. +     */
  4032. +    for (scb = 0; scb < AHA274X_MAXSCB; scb++)
  4033. +        if (p->SCB_array[scb] == cmd)
  4034. +            break;
  4035. +
  4036. +    if (scb == AHA274X_MAXSCB)
  4037. +        return(k_absent);
  4038. +
  4039. +    PAUSE_SEQUENCER(p);
  4040. +
  4041. +    /*
  4042. +     *  This is the best case, really.  Check to see if the
  4043. +     *  command is still in the sequencer's input queue.  If
  4044. +     *  so, simply remove it.  Reload the queue afterward.
  4045. +     */
  4046. +    queued = inb(O_QINCNT(p->base));
  4047. +    
  4048. +    for (i = found = 0; i < queued; i++) {
  4049. +        scbsave[i] = inb(O_QINFIFO(p->base));
  4050. +
  4051. +        if (scbsave[i] == scb) {
  4052. +            found = 1;
  4053. +            i -= 1;
  4054. +        }
  4055. +    }
  4056. +
  4057. +    queued -= found;
  4058. +    for (i = 0; i < queued; i++)
  4059. +        outb(scbsave[i], O_QINFIFO(p->base));
  4060. +
  4061. +    if (found)
  4062. +        goto complete;
  4063. +
  4064. +    /*
  4065. +     *  Check the current SCB bank.  If it's not the one belonging
  4066. +     *  to the command we want to kill, assume that the command
  4067. +     *  is disconnected.  It's rather a pain to force a reconnect
  4068. +     *  and send a message to the target, so we abdicate responsibility
  4069. +     *  in this case.
  4070. +     */
  4071. +    if (inb(O_SCBPTR(p->base)) != scb) {
  4072. +        if (unpause)
  4073. +            UNPAUSE_SEQUENCER(p);
  4074. +        return(k_disconnect);
  4075. +    }
  4076. +
  4077. +    /*
  4078. +     *  Presumably at this point our target command is active.  Check
  4079. +     *  to see if there's a message already in effect.  If not, place
  4080. +     *  our message in and assert ATN so the target goes into MESSAGE
  4081. +     *  OUT phase.
  4082. +     */
  4083. +    if (inb(HA_MSG_FLAGS(p->base)) & 0x80) {
  4084. +        if (unpause)
  4085. +            UNPAUSE_SEQUENCER(p);
  4086. +        return(k_busy);
  4087. +    }
  4088. +
  4089. +    outb(0x80, HA_MSG_FLAGS(p->base));        /* active message */
  4090. +    outb(1, HA_MSG_LEN(p->base));            /* length = 1 */
  4091. +    outb(message, HA_MSG_START(p->base));        /* message body */
  4092. +
  4093. +    /*
  4094. +     *  Assert ATN.  Use the value of SCSISIGO saved by the
  4095. +     *  sequencer code so we don't alter its contents radically
  4096. +     *  in the middle of something critical.
  4097. +     */
  4098. +    outb(inb(HA_SIGSTATE(p->base)) | 0x10, O_SCSISIGO(p->base));
  4099. +
  4100. +    /*
  4101. +     *  The command has been killed.  Do the bookkeeping, unpause
  4102. +     *  the sequencer, and notify the higher-level SCSI code.
  4103. +     */
  4104. +complete:
  4105. +    p->SCB_array[scb] = NULL;
  4106. +    if (unpause)
  4107. +        UNPAUSE_SEQUENCER(p);
  4108. +
  4109. +    cmd->result = result << 16;
  4110. +    cmd->scsi_done(cmd);
  4111. +    return(k_ok);
  4112. +}
  4113. +
  4114. +int aha274x_abort(Scsi_Cmnd *cmd)
  4115. +{
  4116. +    int rv;
  4117. +    long flags;
  4118. +
  4119. +    save_flags(flags);
  4120. +    cli();
  4121. +
  4122. +    switch (aha274x_kill(cmd, ABORT, DID_ABORT, !0)) {
  4123. +        case k_ok:        rv = SCSI_ABORT_SUCCESS;    break;
  4124. +        case k_busy:    rv = SCSI_ABORT_BUSY;        break;
  4125. +        case k_absent:    rv = SCSI_ABORT_NOT_RUNNING;    break;
  4126. +        case k_disconnect:    rv = SCSI_ABORT_SNOOZE;        break;
  4127. +        default:
  4128. +        panic("aha274x_do_abort: internal error\n");
  4129. +    }
  4130. +
  4131. +    restore_flags(flags);
  4132. +    return(rv);
  4133. +}
  4134. +
  4135. +/*
  4136. + *  Resetting the bus always succeeds - is has to, otherwise the
  4137. + *  kernel will panic!  Try a surgical technique - sending a BUS
  4138. + *  DEVICE RESET message - on the offending target before pulling
  4139. + *  the SCSI bus reset line.
  4140. + */
  4141. +
  4142. +int aha274x_reset(Scsi_Cmnd *cmd)
  4143. +{
  4144. +    int i;
  4145. +    long flags;
  4146. +    Scsi_Cmnd *reset;
  4147. +    struct aha274x_host *p;
  4148. +
  4149. +    p = (struct aha274x_host *)cmd->host->hostdata;
  4150. +    save_flags(flags);
  4151. +    cli();
  4152. +
  4153. +    switch (aha274x_kill(cmd, BUS_DEVICE_RESET, DID_RESET, 0)) {
  4154. +
  4155. +        case k_ok:
  4156. +        /*
  4157. +         *  The RESET message was sent to the target
  4158. +         *  with no problems.  Flag that target as
  4159. +         *  needing a SDTR negotiation on the next
  4160. +         *  connection and restart the sequencer.
  4161. +         */
  4162. +        outb((1 << cmd->target), HA_NEEDSDTR(p->base));
  4163. +        UNPAUSE_SEQUENCER(p);
  4164. +        break;
  4165. +
  4166. +        case k_absent:
  4167. +        /*
  4168. +         *  The sequencer will not be paused if aha274x_kill()
  4169. +         *  couldn't find the command.
  4170. +         */
  4171. +        PAUSE_SEQUENCER(p);
  4172. +        /* falls through */
  4173. +
  4174. +        case k_busy:
  4175. +        case k_disconnect:
  4176. +        /*
  4177. +         *  Do a hard reset of the SCSI bus.  According to the
  4178. +         *  SCSI-2 draft specification, reset has to be asserted
  4179. +         *  for at least 25us.  I'm invoking the kernel delay
  4180. +         *  function for 30us since I'm not totally trusting of
  4181. +         *  the busy loop timing.
  4182. +         *
  4183. +         *  XXX - I'm not convinced this works.  I tried resetting
  4184. +         *      the bus before, trying to get the devices on the
  4185. +         *      bus to revert to asynchronous transfer, and it
  4186. +         *      never seemed to work.
  4187. +         */
  4188. +        debug("aha274x: attempting to reset scsi bus and card\n");
  4189. +
  4190. +        outb(1, O_SCSISEQ(p->base));        /* SCSIRSTO */
  4191. +        udelay(30);
  4192. +        outb(0, O_SCSISEQ(p->base));        /* !SCSIRSTO */
  4193. +
  4194. +        outb(0xff, HA_NEEDSDTR(p->base));
  4195. +        UNPAUSE_SEQUENCER(p);
  4196. +
  4197. +        /*
  4198. +         *  Locate the command and return a "reset" status
  4199. +         *  for it.  This is not completely correct and will
  4200. +         *  probably return to haunt me later.
  4201. +         */
  4202. +        for (i = 0; i < AHA274X_MAXSCB; i++) {
  4203. +            if (cmd == p->SCB_array[i]) {
  4204. +                reset = (Scsi_Cmnd *)p->SCB_array[i];
  4205. +                p->SCB_array[i] = NULL;
  4206. +                reset->result = DID_RESET << 16;
  4207. +                reset->scsi_done(reset);
  4208. +                break;
  4209. +            }
  4210. +        }
  4211. +        break;
  4212. +
  4213. +        default:
  4214. +        panic("aha274x_reset: internal error\n");
  4215. +    }
  4216. +
  4217. +    restore_flags(flags);
  4218. +    return(SCSI_RESET_SUCCESS);
  4219. +}
  4220. +
  4221. +int aha274x_biosparam(Disk *disk, int devno, int geom[])
  4222. +{
  4223. +    /*
  4224. +     *  XXX - when I find the EISA configuration information,
  4225. +     *      this should change to handle the "extended translation
  4226. +     *      for drives >1G" option, which uses 255 heads and
  4227. +     *      63 sectors/track for drives >1G.  Right now, just
  4228. +     *      assume it's turned off.
  4229. +     */
  4230. +    debug("aha274x_biosparam warning: don't know translation config\n");
  4231. +
  4232. +    geom[0] = 64;
  4233. +    geom[1] = 32;
  4234. +    geom[2] = disk->capacity / (64 * 32);
  4235. +
  4236. +    return(0);
  4237. +}
  4238. +
  4239. diff -u --recursive --new-file linux-1.1.58/drivers/scsi/aha274x.h linux/drivers/scsi/aha274x.h
  4240. --- linux-1.1.58/drivers/scsi/aha274x.h    Wed Dec 31 18:00:00 1969
  4241. +++ linux/drivers/scsi/aha274x.h    Wed Oct 26 23:02:01 1994
  4242. @@ -0,0 +1,62 @@
  4243. +/* @(#)aha274x.h 1.11 94/09/06 jda */
  4244. +
  4245. +/*
  4246. + * Adaptec 274x device driver for Linux.
  4247. + * Copyright (c) 1994 The University of Calgary Department of Computer Science.
  4248. + * 
  4249. + * This program is free software; you can redistribute it and/or modify
  4250. + * it under the terms of the GNU General Public License as published by
  4251. + * the Free Software Foundation; either version 2 of the License, or
  4252. + * (at your option) any later version.
  4253. + * 
  4254. + * This program is distributed in the hope that it will be useful,
  4255. + * but WITHOUT ANY WARRANTY; without even the implied warranty of
  4256. + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  4257. + * GNU General Public License for more details.
  4258. + * 
  4259. + * You should have received a copy of the GNU General Public License
  4260. + * along with this program; if not, write to the Free Software
  4261. + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  4262. + */
  4263. +
  4264. +#ifndef aha274x_h
  4265. +#define aha274x_h
  4266. +
  4267. +#define    AHA274X_MAXSCB        4
  4268. +#define AHA274X_H_VERSION    "1.11"
  4269. +
  4270. +/*
  4271. + *  Scsi_Host_Template (see hosts.h) for 274x - some fields
  4272. + *  to do with card config are filled in after the card is
  4273. + *  detected.
  4274. + */
  4275. +#define AHA274X    {                        \
  4276. +    NULL,                            \
  4277. +    "",                            \
  4278. +    aha274x_detect,                        \
  4279. +    NULL,                            \
  4280. +    aha274x_info,                        \
  4281. +    aha274x_command,                    \
  4282. +    aha274x_queue,                        \
  4283. +    aha274x_abort,                        \
  4284. +    aha274x_reset,                        \
  4285. +    NULL,                            \
  4286. +    aha274x_biosparam,                    \
  4287. +    AHA274X_MAXSCB,        /* max simultaneous cmds      */\
  4288. +    -1,            /* scsi id of host adapter    */\
  4289. +    SG_ALL,            /* max scatter-gather cmds    */\
  4290. +    1,            /* cmds per lun (linked cmds) */\
  4291. +    0,            /* number of 274x's present   */\
  4292. +    0,            /* no memory DMA restrictions */\
  4293. +    DISABLE_CLUSTERING                    \
  4294. +}
  4295. +
  4296. +extern int aha274x_queue(Scsi_Cmnd *, void (*)(Scsi_Cmnd *));
  4297. +extern int aha274x_biosparam(Disk *, int, int[]);
  4298. +extern int aha274x_detect(Scsi_Host_Template *);
  4299. +extern int aha274x_command(Scsi_Cmnd *);
  4300. +extern int aha274x_abort(Scsi_Cmnd *);
  4301. +extern int aha274x_reset(Scsi_Cmnd *);
  4302. +extern const char *aha274x_info(void);
  4303. +
  4304. +#endif
  4305. diff -u --recursive --new-file linux-1.1.58/drivers/scsi/aha274x.seq linux/drivers/scsi/aha274x.seq
  4306. --- linux-1.1.58/drivers/scsi/aha274x.seq    Wed Dec 31 18:00:00 1969
  4307. +++ linux/drivers/scsi/aha274x.seq    Wed Oct 26 23:02:01 1994
  4308. @@ -0,0 +1,1021 @@
  4309. +# @(#)aha274x.seq 1.28 94/10/04 jda
  4310. +#
  4311. +# Adaptec 274x device driver for Linux.
  4312. +# Copyright (c) 1994 The University of Calgary Department of Computer Science.
  4313. +# 
  4314. +# This program is free software; you can redistribute it and/or modify
  4315. +# it under the terms of the GNU General Public License as published by
  4316. +# the Free Software Foundation; either version 2 of the License, or
  4317. +# (at your option) any later version.
  4318. +# 
  4319. +# This program is distributed in the hope that it will be useful,
  4320. +# but WITHOUT ANY WARRANTY; without even the implied warranty of
  4321. +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  4322. +# GNU General Public License for more details.
  4323. +# 
  4324. +# You should have received a copy of the GNU General Public License
  4325. +# along with this program; if not, write to the Free Software
  4326. +# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  4327. +
  4328. +VERSION AHA274X_SEQ_VERSION 1.28
  4329. +
  4330. +MAXSCB        = 4
  4331. +
  4332. +SCSISEQ        = 0x00
  4333. +SXFRCTL0    = 0x01
  4334. +SXFRCTL1    = 0x02
  4335. +SCSISIGI    = 0x03
  4336. +SCSISIGO    = 0x03
  4337. +SCSIRATE    = 0x04
  4338. +SCSIID        = 0x05
  4339. +SCSIDATL    = 0x06
  4340. +STCNT        = 0x08
  4341. +STCNT+0        = 0x08
  4342. +STCNT+1        = 0x09
  4343. +STCNT+2        = 0x0a
  4344. +SSTAT0        = 0x0b
  4345. +CLRSINT1    = 0x0c
  4346. +SSTAT1        = 0x0c
  4347. +SIMODE1        = 0x11
  4348. +SCSIBUSL    = 0x12
  4349. +SHADDR        = 0x14
  4350. +SELID        = 0x19
  4351. +SBLKCTL        = 0x1f
  4352. +SEQCTL        = 0x60
  4353. +A        = 0x64                # == ACCUM
  4354. +SINDEX        = 0x65
  4355. +DINDEX        = 0x66
  4356. +ALLZEROS    = 0x6a
  4357. +NONE        = 0x6a
  4358. +SINDIR        = 0x6c
  4359. +DINDIR        = 0x6d
  4360. +FUNCTION1    = 0x6e
  4361. +HADDR        = 0x88
  4362. +HCNT        = 0x8c
  4363. +HCNT+0        = 0x8c
  4364. +HCNT+1        = 0x8d
  4365. +HCNT+2        = 0x8e
  4366. +SCBPTR        = 0x90
  4367. +INTSTAT        = 0x91
  4368. +DFCNTRL        = 0x93
  4369. +DFSTATUS    = 0x94
  4370. +DFDAT        = 0x99
  4371. +QINFIFO        = 0x9b
  4372. +QINCNT        = 0x9c
  4373. +QOUTFIFO    = 0x9d
  4374. +
  4375. +SCSICONF    = 0x5a
  4376. +
  4377. +#  The two reserved bytes at SCBARRAY+1[23] are expected to be set to
  4378. +#  zero, and the reserved bit in SCBARRAY+0 is used as an internal flag
  4379. +#  to indicate whether or not to reload scatter-gather parameters after
  4380. +#  a disconnect.
  4381. +#
  4382. +SCBARRAY+0    = 0xa0
  4383. +SCBARRAY+1    = 0xa1
  4384. +SCBARRAY+2    = 0xa2
  4385. +SCBARRAY+3    = 0xa3
  4386. +SCBARRAY+7    = 0xa7
  4387. +SCBARRAY+11    = 0xab
  4388. +SCBARRAY+14    = 0xae
  4389. +SCBARRAY+15    = 0xaf
  4390. +SCBARRAY+16    = 0xb0
  4391. +SCBARRAY+17    = 0xb1
  4392. +SCBARRAY+18    = 0xb2
  4393. +SCBARRAY+19    = 0xb3
  4394. +SCBARRAY+20    = 0xb4
  4395. +SCBARRAY+21    = 0xb5
  4396. +SCBARRAY+22    = 0xb6
  4397. +SCBARRAY+23    = 0xb7
  4398. +SCBARRAY+24    = 0xb8
  4399. +SCBARRAY+25    = 0xb9
  4400. +
  4401. +SIGNAL_0    = 0x01                # unknown scsi bus phase
  4402. +SIGNAL_1    = 0x11                # message reject
  4403. +SIGNAL_2    = 0x21                # no IDENTIFY after reconnect
  4404. +SIGNAL_3    = 0x31                # no cmd match for reconnect
  4405. +SIGNAL_4    = 0x41                # SDTR -> SCSIRATE conversion
  4406. +
  4407. +#  The host adapter card (at least the BIOS) uses 20-2f for SCSI
  4408. +#  device information, 32-33 and 5a-5f as well.  Since we don't support
  4409. +#  wide or twin-bus SCSI, 28-2f can be reclaimed.  As it turns out, the
  4410. +#  BIOS trashes 20-27 anyway, writing the synchronous negotiation results
  4411. +#  on top of the BIOS values, so we re-use those for our per-target
  4412. +#  scratchspace (actually a value that can be copied directly into
  4413. +#  SCSIRATE).  This implies, since we can't get the BIOS config values,
  4414. +#  that all targets will be negotiated with for synchronous transfer.
  4415. +#  NEEDSDTR has one bit per target indicating if an SDTR message is
  4416. +#  needed for that device - this will be set initially, as well as
  4417. +#  after a bus reset condition.
  4418. +#
  4419. +#  The high bit of DROPATN is set if ATN should be dropped before the ACK
  4420. +#  when outb is called.  REJBYTE contains the first byte of a MESSAGE IN
  4421. +#  message, so the driver can report an intelligible error if a message is
  4422. +#  rejected.
  4423. +#
  4424. +#  RESELECT's high bit is true if we are currently handling a reselect;
  4425. +#  its next-highest bit is true ONLY IF we've seen an IDENTIFY message
  4426. +#  from the reselecting target.  If we haven't had IDENTIFY, then we have
  4427. +#  no idea what the lun is, and we can't select the right SCB register
  4428. +#  bank, so force a kernel panic if the target attempts a data in/out or
  4429. +#  command phase instead of corrupting something.
  4430. +#
  4431. +#  Note that SG_NEXT occupies four bytes.
  4432. +#
  4433. +SYNCNEG        = 0x20
  4434. +DISC_DSB_A    = 0x32
  4435. +
  4436. +DROPATN        = 0x30
  4437. +REJBYTE        = 0x31
  4438. +RESELECT    = 0x34
  4439. +
  4440. +MSG_FLAGS    = 0x35
  4441. +MSG_LEN        = 0x36
  4442. +MSG_START+0    = 0x37
  4443. +MSG_START+1    = 0x38
  4444. +MSG_START+2    = 0x39
  4445. +MSG_START+3    = 0x3a
  4446. +MSG_START+4    = 0x3b
  4447. +MSG_START+5    = 0x3c
  4448. +-MSG_START+0    = 0xc9                # 2's complement of MSG_START+0
  4449. +
  4450. +ARG_1        = 0x4c                # sdtr conversion args & return
  4451. +ARG_2        = 0x4d
  4452. +RETURN_1    = 0x4c
  4453. +
  4454. +SIGSTATE    = 0x4e                # value written to SCSISIGO
  4455. +NEEDSDTR    = 0x4f                # send SDTR message, 1 bit/trgt
  4456. +
  4457. +SG_SIZEOF    = 12                # sizeof(struct scatterlist)
  4458. +SG_NOLOAD    = 0x50                # load SG pointer/length?
  4459. +SG_COUNT    = 0x51                # working value of SG count
  4460. +SG_NEXT        = 0x52                # working value of SG pointer
  4461. +SG_NEXT+0    = 0x52
  4462. +SG_NEXT+1    = 0x53
  4463. +SG_NEXT+2    = 0x54
  4464. +SG_NEXT+3    = 0x55
  4465. +
  4466. +#  Poll QINCNT for work - the lower three bits contain
  4467. +#  the number of entries in the Queue In FIFO.
  4468. +#
  4469. +start:
  4470. +    test    SCSISIGI,0x4    jnz reselect    # BSYI
  4471. +    test    QINCNT,0x7    jz start
  4472. +
  4473. +#  We have at least one queued SCB now.  Set the SCB pointer
  4474. +#  from the FIFO so we see the right bank of SCB registers,
  4475. +#  then set SCSI options and set the initiator and target
  4476. +#  SCSI IDs.
  4477. +#
  4478. +    mov    SCBPTR,QINFIFO
  4479. +    mov    SCBARRAY+1    call initialize
  4480. +    clr    SG_NOLOAD
  4481. +    clr    RESELECT
  4482. +
  4483. +#  As soon as we get a successful selection, the target should go
  4484. +#  into the message out phase since we have ATN asserted.  Prepare
  4485. +#  the message to send, locking out the device driver.  If the device
  4486. +#  driver hasn't beaten us with an ABORT or RESET message, then tack
  4487. +#  on a SDTR negotation if required.
  4488. +#
  4489. +#  Messages are stored in scratch RAM starting with a flag byte (high bit
  4490. +#  set means active message), one length byte, and then the message itself.
  4491. +#
  4492. +    mov    SCBARRAY+1    call disconnect    # disconnect ok?
  4493. +
  4494. +    and    SINDEX,0x7,SCBARRAY+1        # lun
  4495. +    or    SINDEX,A            # return value from disconnect
  4496. +    or    SINDEX,0x80    call mk_mesg    # IDENTIFY message
  4497. +
  4498. +    mov    A,SINDEX
  4499. +    cmp    MSG_START+0,A    jne !message    # did driver beat us?
  4500. +    mvi    MSG_START+1    call mk_sdtr    # build SDTR message if needed
  4501. +
  4502. +!message:
  4503. +
  4504. +#  Enable selection phase as an initiator, and do automatic ATN
  4505. +#  after the selection.
  4506. +#
  4507. +    mvi    SCSISEQ,0x48            # ENSELO|ENAUTOATNO
  4508. +
  4509. +#  Wait for successful arbitration.  The AIC-7770 documentation says
  4510. +#  that SELINGO indicates successful arbitration, and that it should
  4511. +#  be used to look for SELDO.  However, if the sequencer is paused at
  4512. +#  just the right time - a parallel fsck(8) on two drives did it for
  4513. +#  me - then SELINGO can flip back to false before we've seen it.  This
  4514. +#  makes the sequencer sit in the arbitration loop forever.  This is
  4515. +#  Not Good.
  4516. +#
  4517. +#  Therefore, I've added a check in the arbitration loop for SELDO
  4518. +#  too.  This could arguably be made a critical section by disabling
  4519. +#  pauses, but I don't want to make a potentially infinite loop a CS.
  4520. +#  I suppose you could fold it into the select loop, too, but since
  4521. +#  I've been hunting this bug for four days it's kinda like a trophy.
  4522. +#
  4523. +arbitrate:
  4524. +    test    SSTAT0,0x40    jnz *select    # SELDO
  4525. +    test    SSTAT0,0x10    jz arbitrate    # SELINGO
  4526. +
  4527. +#  Wait for a successful selection.  If the hardware selection
  4528. +#  timer goes off, then the driver gets the interrupt, so we don't
  4529. +#  need to worry about it.
  4530. +#
  4531. +select:
  4532. +    test    SSTAT0,0x40    jz select    # SELDO
  4533. +    jmp    *select
  4534. +
  4535. +#  Reselection is being initiated by a target - we've seen the BSY
  4536. +#  line driven active, and we didn't do it!  Enable the reselection
  4537. +#  hardware, and wait for it to finish.  Make a note that we've been
  4538. +#  reselected, but haven't seen an IDENTIFY message from the target
  4539. +#  yet.
  4540. +#
  4541. +reselect:
  4542. +    mvi    SCSISEQ,0x10            # ENRSELI
  4543. +
  4544. +reselect1:
  4545. +    test    SSTAT0,0x20    jz reselect1    # SELDI
  4546. +    mov    SELID        call initialize
  4547. +
  4548. +    mvi    RESELECT,0x80            # reselected, no IDENTIFY
  4549. +
  4550. +#  After the [re]selection, make sure that the [re]selection enable
  4551. +#  bit is off.  This chip is flaky enough without extra things
  4552. +#  turned on.  Also clear the BUSFREE bit in SSTAT1 since we'll be
  4553. +#  using it shortly.
  4554. +#
  4555. +*select:
  4556. +    clr    SCSISEQ
  4557. +    mvi    CLRSINT1,0x8            # CLRBUSFREE
  4558. +
  4559. +#  Main loop for information transfer phases.  If BSY is false, then
  4560. +#  we have a bus free condition, expected or not.  Otherwise, wait
  4561. +#  for the target to assert REQ before checking MSG, C/D and I/O
  4562. +#  for the bus phase.
  4563. +#
  4564. +#  We can't simply look at the values of SCSISIGI here (if we want
  4565. +#  to do synchronous data transfer), because the target won't assert
  4566. +#  REQ if it's already sent us some data that we haven't acknowledged
  4567. +#  yet.
  4568. +#
  4569. +ITloop:
  4570. +    test    SSTAT1,0x8    jnz p_busfree    # BUSFREE
  4571. +    test    SSTAT1,0x1    jz ITloop    # REQINIT
  4572. +
  4573. +    and    A,0xe0,SCSISIGI            # CDI|IOI|MSGI
  4574. +
  4575. +    cmp    ALLZEROS,A    je p_dataout
  4576. +    cmp    A,0x40        je p_datain
  4577. +    cmp    A,0x80        je p_command
  4578. +    cmp    A,0xc0        je p_status
  4579. +    cmp    A,0xa0        je p_mesgout
  4580. +    cmp    A,0xe0        je p_mesgin
  4581. +
  4582. +    mvi    INTSTAT,SIGNAL_0        # unknown - signal driver
  4583. +
  4584. +p_dataout:
  4585. +    mvi    0        call scsisig    # !CDO|!IOO|!MSGO
  4586. +    call    assert
  4587. +    call    sg_load
  4588. +
  4589. +    mvi    A,3
  4590. +    mvi    DINDEX,HCNT
  4591. +    mvi    SCBARRAY+23    call bcopy
  4592. +
  4593. +    mvi    A,3
  4594. +    mvi    DINDEX,STCNT
  4595. +    mvi    SCBARRAY+23    call bcopy
  4596. +
  4597. +    mvi    A,4
  4598. +    mvi    DINDEX,HADDR
  4599. +    mvi    SCBARRAY+19    call bcopy
  4600. +
  4601. +    mvi    0x3d        call dma    # SCSIEN|SDMAEN|HDMAEN|
  4602. +                        #   DIRECTION|FIFORESET
  4603. +
  4604. +#  After a DMA finishes, save the final transfer pointer and count
  4605. +#  back into the SCB, in case a device disconnects in the middle of
  4606. +#  a transfer.  Use SHADDR and STCNT instead of HADDR and HCNT, since
  4607. +#  it's a reflection of how many bytes were transferred on the SCSI
  4608. +#  (as opposed to the host) bus.
  4609. +#
  4610. +    mvi    A,3
  4611. +    mvi    DINDEX,SCBARRAY+23
  4612. +    mvi    STCNT        call bcopy
  4613. +
  4614. +    mvi    A,4
  4615. +    mvi    DINDEX,SCBARRAY+19
  4616. +    mvi    SHADDR        call bcopy
  4617. +
  4618. +    call    sg_advance
  4619. +    mov    SCBARRAY+18,SG_COUNT        # residual S/G count
  4620. +
  4621. +    jmp    ITloop
  4622. +
  4623. +p_datain:
  4624. +    mvi    0x40        call scsisig    # !CDO|IOO|!MSGO
  4625. +    call    assert
  4626. +    call    sg_load
  4627. +
  4628. +    mvi    A,3
  4629. +    mvi    DINDEX,HCNT
  4630. +    mvi    SCBARRAY+23    call bcopy
  4631. +
  4632. +    mvi    A,3
  4633. +    mvi    DINDEX,STCNT
  4634. +    mvi    SCBARRAY+23    call bcopy
  4635. +
  4636. +    mvi    A,4
  4637. +    mvi    DINDEX,HADDR
  4638. +    mvi    SCBARRAY+19    call bcopy
  4639. +
  4640. +    mvi    0x39        call dma    # SCSIEN|SDMAEN|HDMAEN|
  4641. +                        #   !DIRECTION|FIFORESET
  4642. +    mvi    A,3
  4643. +    mvi    DINDEX,SCBARRAY+23
  4644. +    mvi    STCNT        call bcopy
  4645. +
  4646. +    mvi    A,4
  4647. +    mvi    DINDEX,SCBARRAY+19
  4648. +    mvi    SHADDR        call bcopy
  4649. +
  4650. +    call    sg_advance
  4651. +    mov    SCBARRAY+18,SG_COUNT        # residual S/G count
  4652. +
  4653. +    jmp    ITloop
  4654. +
  4655. +#  Command phase.  Set up the DMA registers and let 'er rip - the
  4656. +#  two bytes after the SCB SCSI_cmd_length are zeroed by the driver,
  4657. +#  so we can copy those three bytes directly into HCNT.
  4658. +#
  4659. +p_command:
  4660. +    mvi    0x80        call scsisig    # CDO|!IOO|!MSGO
  4661. +    call    assert
  4662. +
  4663. +    mvi    A,3
  4664. +    mvi    DINDEX,HCNT
  4665. +    mvi    SCBARRAY+11    call bcopy
  4666. +
  4667. +    mvi    A,3
  4668. +    mvi    DINDEX,STCNT
  4669. +    mvi    SCBARRAY+11    call bcopy
  4670. +
  4671. +    mvi    A,4
  4672. +    mvi    DINDEX,HADDR
  4673. +    mvi    SCBARRAY+7    call bcopy
  4674. +
  4675. +    mvi    0x3d        call dma    # SCSIEN|SDMAEN|HDMAEN|
  4676. +                        #   DIRECTION|FIFORESET
  4677. +    jmp    ITloop
  4678. +
  4679. +#  Status phase.  Wait for the data byte to appear, then read it
  4680. +#  and store it into the SCB.
  4681. +#
  4682. +p_status:
  4683. +    mvi    0xc0        call scsisig    # CDO|IOO|!MSGO
  4684. +
  4685. +    mvi    SCBARRAY+14    call inb
  4686. +    jmp    ITloop
  4687. +
  4688. +#  Message out phase.  If there is no active message, but the target
  4689. +#  took us into this phase anyway, build a no-op message and send it.
  4690. +#
  4691. +p_mesgout:
  4692. +    mvi    0xa0        call scsisig    # CDO|!IOO|MSGO
  4693. +    mvi    0x8        call mk_mesg    # build NOP message
  4694. +
  4695. +#  Set up automatic PIO transfer from MSG_START.  Bit 3 in
  4696. +#  SXFRCTL0 (SPIOEN) is already on.
  4697. +#
  4698. +    mvi    SINDEX,MSG_START+0
  4699. +    mov    DINDEX,MSG_LEN
  4700. +    clr    A
  4701. +
  4702. +#  When target asks for a byte, drop ATN if it's the last one in
  4703. +#  the message.  Otherwise, keep going until the message is exhausted.
  4704. +#  (We can't use outb for this since it wants the input in SINDEX.)
  4705. +#
  4706. +#  Keep an eye out for a phase change, in case the target issues
  4707. +#  a MESSAGE REJECT.
  4708. +#
  4709. +p_mesgout2:
  4710. +    test    SSTAT0,0x2    jz p_mesgout2    # SPIORDY
  4711. +    test    SSTAT1,0x10    jnz p_mesgout6    # PHASEMIS
  4712. +
  4713. +    cmp    DINDEX,1    jne p_mesgout3    # last byte?
  4714. +    mvi    CLRSINT1,0x40            # CLRATNO - drop ATN
  4715. +
  4716. +#  Write a byte to the SCSI bus.  The AIC-7770 refuses to automatically
  4717. +#  send ACKs in automatic PIO or DMA mode unless you make sure that the
  4718. +#  "expected" bus phase in SCSISIGO matches the actual bus phase.  This
  4719. +#  behaviour is completely undocumented and caused me several days of
  4720. +#  grief.
  4721. +#
  4722. +#  After plugging in different drives to test with and using a longer
  4723. +#  SCSI cable, I found that I/O in Automatic PIO mode ceased to function,
  4724. +#  especially when transferring >1 byte.  It seems to be much more stable
  4725. +#  if STCNT is set to one before the transfer, and SDONE (in SSTAT0) is
  4726. +#  polled for transfer completion - for both output _and_ input.  The
  4727. +#  only theory I have is that SPIORDY doesn't drop right away when SCSIDATL
  4728. +#  is accessed (like the documentation says it does), and that on a longer
  4729. +#  cable run, the sequencer code was fast enough to loop back and see
  4730. +#  an SPIORDY that hadn't dropped yet.
  4731. +#
  4732. +p_mesgout3:
  4733. +    call    one_stcnt
  4734. +    mov    SCSIDATL,SINDIR
  4735. +
  4736. +p_mesgout4:
  4737. +    test    SSTAT0,0x4    jz p_mesgout4    # SDONE
  4738. +    dec    DINDEX
  4739. +    inc    A
  4740. +    cmp    MSG_LEN,A    jne p_mesgout2
  4741. +
  4742. +#  If the next bus phase after ATN drops is a message out, it means
  4743. +#  that the target is requesting that the last message(s) be resent.
  4744. +#
  4745. +p_mesgout5:
  4746. +    test    SSTAT1,0x8    jnz p_mesgout6    # BUSFREE
  4747. +    test    SSTAT1,0x1    jz p_mesgout5    # REQINIT
  4748. +
  4749. +    and    A,0xe0,SCSISIGI            # CDI|IOI|MSGI
  4750. +    cmp    A,0xa0        jne p_mesgout6
  4751. +    mvi    0x10        call scsisig    # ATNO - re-assert ATN
  4752. +
  4753. +    jmp    ITloop
  4754. +
  4755. +p_mesgout6:
  4756. +    mvi    CLRSINT1,0x40            # CLRATNO - in case of PHASEMIS
  4757. +    clr    MSG_FLAGS            # no active msg
  4758. +    jmp    ITloop
  4759. +
  4760. +#  Message in phase.  Bytes are read using Automatic PIO mode, but not
  4761. +#  using inb.  This alleviates a race condition, namely that if ATN had
  4762. +#  to be asserted under Automatic PIO mode, it had to beat the SCSI
  4763. +#  circuitry sending an ACK to the target.  This showed up under heavy
  4764. +#  loads and really confused things, since ABORT commands wouldn't be
  4765. +#  seen by the drive after an IDENTIFY message in until it had changed
  4766. +#  to a data I/O phase.
  4767. +#
  4768. +p_mesgin:
  4769. +    mvi    0xe0        call scsisig    # CDO|IOO|MSGO
  4770. +    mvi    A        call inb_first    # read the 1st message byte
  4771. +    mvi    REJBYTE,A            # save it for the driver
  4772. +
  4773. +    cmp    ALLZEROS,A    jne p_mesgin1
  4774. +
  4775. +#  We got a "command complete" message, so put the SCB pointer
  4776. +#  into the Queue Out, and trigger a completion interrupt.
  4777. +#
  4778. +    mov    QOUTFIFO,SCBPTR
  4779. +    mvi    INTSTAT,0x2            # CMDCMPLT
  4780. +    jmp    p_mesgin_done
  4781. +
  4782. +#  Is it an extended message?  We only support the synchronous data
  4783. +#  transfer request message, which will probably be in response to
  4784. +#  an SDTR message out from us.  If it's not an SDTR, reject it -
  4785. +#  apparently this can be done after any message in byte, according
  4786. +#  to the SCSI-2 spec.
  4787. +#
  4788. +#  XXX - we should really reject this if we didn't initiate the SDTR
  4789. +#     negotiation; this may cause problems with unusual devices.
  4790. +#
  4791. +p_mesgin1:
  4792. +    cmp    A,1        jne p_mesgin2    # extended message code?
  4793. +    
  4794. +    mvi    A        call inb_next
  4795. +    cmp    A,3        jne p_mesginN    # extended mesg length = 3
  4796. +    mvi    A        call inb_next
  4797. +    cmp    A,1        jne p_mesginN    # SDTR code
  4798. +
  4799. +    mvi    ARG_1        call inb_next    # xfer period
  4800. +    mvi    ARG_2        call inb_next    # REQ/ACK offset
  4801. +    mvi    INTSTAT,SIGNAL_4        # call driver to convert
  4802. +
  4803. +    call    ndx_sdtr            # index sync config for target
  4804. +    mov    DINDEX,SINDEX
  4805. +    mov    DINDIR,RETURN_1            # save returned value
  4806. +
  4807. +    not    A                # turn off "need sdtr" flag
  4808. +    and    NEEDSDTR,A
  4809. +
  4810. +#  Even though the SCSI-2 specification says that a device responding
  4811. +#  to our SDTR message should honor our parameters for transmitting
  4812. +#  to us, it doesn't seem to work too well in real life.  In particular,
  4813. +#  a lot of CD-ROM and tape units don't function: try using the SDTR
  4814. +#  parameters the device sent us for both transmitting and receiving.
  4815. +#
  4816. +    mov    SCSIRATE,RETURN_1
  4817. +    jmp    p_mesgin_done
  4818. +
  4819. +#  Is it a disconnect message?  Set a flag in the SCB to remind us
  4820. +#  and await the bus going free.
  4821. +#
  4822. +p_mesgin2:
  4823. +    cmp    A,4        jne p_mesgin3    # disconnect code?
  4824. +
  4825. +    or    SCBARRAY+0,0x4            # set "disconnected" bit
  4826. +    jmp    p_mesgin_done
  4827. +
  4828. +#  Save data pointers message?  Copy working values into the SCB,
  4829. +#  usually in preparation for a disconnect.
  4830. +#
  4831. +p_mesgin3:
  4832. +    cmp    A,2        jne p_mesgin4    # save data pointers code?
  4833. +
  4834. +    call    sg_ram2scb
  4835. +    jmp    p_mesgin_done
  4836. +
  4837. +#  Restore pointers message?  Data pointers are recopied from the
  4838. +#  SCB anyway at the start of any DMA operation, so the only thing
  4839. +#  to copy is the scatter-gather values.
  4840. +#
  4841. +p_mesgin4:
  4842. +    cmp    A,3        jne p_mesgin5    # restore pointers code?
  4843. +
  4844. +    call    sg_scb2ram
  4845. +    jmp    p_mesgin_done
  4846. +
  4847. +#  Identify message?  For a reconnecting target, this tells us the lun
  4848. +#  that the reconnection is for - find the correct SCB and switch to it,
  4849. +#  clearing the "disconnected" bit so we don't "find" it by accident later.
  4850. +#
  4851. +p_mesgin5:
  4852. +    test    A,0x80        jz p_mesgin6    # identify message?
  4853. +
  4854. +    test    A,0x78        jnz p_mesginN    # !DiscPriv|!LUNTAR|!Reserved
  4855. +
  4856. +    mov    A        call findSCB    # switch to correct SCB
  4857. +
  4858. +#  If a active message is present after calling findSCB, then either it
  4859. +#  or the driver is trying to abort the command.  Either way, something
  4860. +#  untoward has happened and we should just leave it alone.
  4861. +#
  4862. +    test    MSG_FLAGS,0x80    jnz p_mesgin_done
  4863. +
  4864. +    xor    SCBARRAY+0,0x4            # clear disconnect bit in SCB
  4865. +    mvi    RESELECT,0xc0            # make note of IDENTIFY
  4866. +
  4867. +    call    sg_scb2ram            # implied restore pointers
  4868. +                        #   required on reselect
  4869. +    jmp    p_mesgin_done
  4870. +
  4871. +#  Message reject?  If we have an outstanding SDTR negotiation, assume
  4872. +#  that it's a response from the target selecting asynchronous transfer,
  4873. +#  otherwise just ignore it since we have no clue what it pertains to.
  4874. +#
  4875. +#  XXX - I don't have a device that responds this way.  Does this code
  4876. +#     actually work?
  4877. +#
  4878. +p_mesgin6:
  4879. +    cmp    A,7        jne p_mesgin7    # message reject code?
  4880. +
  4881. +    and    FUNCTION1,0x70,SCSIID        # outstanding SDTR message?
  4882. +    mov    A,FUNCTION1
  4883. +    test    NEEDSDTR,A    jz p_mesgin_done  # no - ignore rejection
  4884. +
  4885. +    call    ndx_sdtr            # note use of asynch xfer
  4886. +    mov    DINDEX,SINDEX
  4887. +    clr    DINDIR
  4888. +
  4889. +    not    A                # turn off "active sdtr" flag
  4890. +    and    NEEDSDTR,A
  4891. +
  4892. +    clr    SCSIRATE            # select asynch xfer
  4893. +    jmp    p_mesgin_done
  4894. +
  4895. +#  [ ADD MORE MESSAGE HANDLING HERE ]
  4896. +#
  4897. +p_mesgin7:
  4898. +
  4899. +#  We have no idea what this message in is, and there's no way
  4900. +#  to pass it up to the kernel, so we issue a message reject and
  4901. +#  hope for the best.  Since we're now using manual PIO mode to
  4902. +#  read in the message, there should no longer be a race condition
  4903. +#  present when we assert ATN.  In any case, rejection should be a
  4904. +#  rare occurrence - signal the driver when it happens.
  4905. +#
  4906. +p_mesginN:
  4907. +    or    SINDEX,0x10,SIGSTATE        # turn on ATNO
  4908. +    call    scsisig
  4909. +    mvi    INTSTAT,SIGNAL_1        # let driver know
  4910. +
  4911. +    mvi    0x7        call mk_mesg    # MESSAGE REJECT message
  4912. +
  4913. +p_mesgin_done:
  4914. +    call    inb_last            # ack & turn auto PIO back on
  4915. +    jmp    ITloop
  4916. +
  4917. +#  Bus free phase.  It might be useful to interrupt the device
  4918. +#  driver if we aren't expecting this.  For now, make sure that
  4919. +#  ATN isn't being asserted and look for a new command.
  4920. +#
  4921. +p_busfree:
  4922. +    mvi    CLRSINT1,0x40            # CLRATNO
  4923. +    clr    SIGSTATE
  4924. +    jmp    start
  4925. +
  4926. +#  Bcopy: number of bytes to transfer should be in A, DINDEX should
  4927. +#  contain the destination address, and SINDEX should contain the
  4928. +#  source address.  All input parameters are trashed on return.
  4929. +#
  4930. +bcopy:
  4931. +    mov    DINDIR,SINDIR
  4932. +    dec    A
  4933. +    cmp    ALLZEROS,A    jne bcopy
  4934. +    ret
  4935. +
  4936. +#  Locking the driver out, build a one-byte message passed in SINDEX
  4937. +#  if there is no active message already.  SINDEX is returned intact.
  4938. +#
  4939. +mk_mesg:
  4940. +    mvi    SEQCTL,0x40            # PAUSEDIS
  4941. +    test    MSG_FLAGS,0x80    jnz mk_mesg1    # active message?
  4942. +
  4943. +    mvi    MSG_FLAGS,0x80            # if not, there is now
  4944. +    mvi    MSG_LEN,1            # length = 1
  4945. +    mov    MSG_START+0,SINDEX        # 1-byte message
  4946. +
  4947. +mk_mesg1:
  4948. +    clr    SEQCTL                # !PAUSEDIS
  4949. +    ret
  4950. +
  4951. +#  Input byte in Automatic PIO mode.  The address to store the byte
  4952. +#  in should be in SINDEX.  DINDEX will be used by this routine.
  4953. +#
  4954. +inb:
  4955. +    test    SSTAT0,0x2    jz inb        # SPIORDY
  4956. +    mov    DINDEX,SINDEX
  4957. +    call    one_stcnt            # xfer one byte
  4958. +    mov    DINDIR,SCSIDATL
  4959. +inb1:
  4960. +    test    SSTAT0,0x4    jz inb1        # SDONE - wait to "finish"
  4961. +    ret
  4962. +
  4963. +#  Carefully read data in Automatic PIO mode.  I first tried this using
  4964. +#  Manual PIO mode, but it gave me continual underrun errors, probably
  4965. +#  indicating that I did something wrong, but I feel more secure leaving
  4966. +#  Automatic PIO on all the time.
  4967. +#
  4968. +#  According to Adaptec's documentation, an ACK is not sent on input from
  4969. +#  the target until SCSIDATL is read from.  So we wait until SCSIDATL is
  4970. +#  latched (the usual way), then read the data byte directly off the bus
  4971. +#  using SCSIBUSL.  When we have pulled the ATN line, or we just want to
  4972. +#  acknowledge the byte, then we do a dummy read from SCISDATL.  The SCSI
  4973. +#  spec guarantees that the target will hold the data byte on the bus until
  4974. +#  we send our ACK.
  4975. +#
  4976. +#  The assumption here is that these are called in a particular sequence,
  4977. +#  and that REQ is already set when inb_first is called.  inb_{first,next}
  4978. +#  use the same calling convention as inb.
  4979. +#
  4980. +inb_first:
  4981. +    mov    DINDEX,SINDEX
  4982. +    mov    DINDIR,SCSIBUSL    ret        # read byte directly from bus
  4983. +
  4984. +inb_next:
  4985. +    mov    DINDEX,SINDEX            # save SINDEX
  4986. +
  4987. +    call    one_stcnt            # xfer one byte
  4988. +    mov    NONE,SCSIDATL            # dummy read from latch to ACK
  4989. +inb_next1:
  4990. +    test    SSTAT0,0x4    jz inb_next1    # SDONE
  4991. +inb_next2:
  4992. +    test    SSTAT0,0x2    jz inb_next2    # SPIORDY - wait for next byte
  4993. +    mov    DINDIR,SCSIBUSL    ret        # read byte directly from bus
  4994. +
  4995. +inb_last:
  4996. +    call    one_stcnt            # ACK with dummy read
  4997. +    mov    NONE,SCSIDATL
  4998. +inb_last1:
  4999. +    test    SSTAT0,0x4    jz inb_last1    # wait for completion
  5000. +    ret
  5001. +
  5002. +#  Output byte in Automatic PIO mode.  The byte to output should be
  5003. +#  in SINDEX.  If DROPATN's high bit is set, then ATN will be dropped
  5004. +#  before the byte is output.
  5005. +#
  5006. +outb:
  5007. +    test    SSTAT0,0x2    jz outb        # SPIORDY
  5008. +    call    one_stcnt            # xfer one byte
  5009. +
  5010. +    test    DROPATN,0x80    jz outb1
  5011. +    mvi    CLRSINT1,0x40            # CLRATNO
  5012. +    clr    DROPATN
  5013. +outb1:
  5014. +    mov    SCSIDATL,SINDEX
  5015. +outb2:
  5016. +    test    SSTAT0,0x4    jz outb2    # SDONE
  5017. +    ret
  5018. +
  5019. +#  Write the value "1" into the STCNT registers, for Automatic PIO
  5020. +#  transfers.
  5021. +#
  5022. +one_stcnt:
  5023. +    clr    STCNT+2
  5024. +    clr    STCNT+1
  5025. +    mvi    STCNT+0,1    ret
  5026. +
  5027. +#  DMA data transfer.  HADDR and HCNT must be loaded first, and
  5028. +#  SINDEX should contain the value to load DFCNTRL with - 0x3d for
  5029. +#  host->scsi, or 0x39 for scsi->host.  The SCSI channel is cleared
  5030. +#  during initialization.
  5031. +#
  5032. +dma:
  5033. +    mov    DFCNTRL,SINDEX
  5034. +dma1:
  5035. +dma2:
  5036. +    test    SSTAT0,0x1    jnz dma3    # DMADONE
  5037. +    test    SSTAT1,0x10    jz dma1        # PHASEMIS, ie. underrun
  5038. +
  5039. +#  We will be "done" DMAing when the transfer count goes to zero, or
  5040. +#  the target changes the phase (in light of this, it makes sense that
  5041. +#  the DMA circuitry doesn't ACK when PHASEMIS is active).  If we are
  5042. +#  doing a SCSI->Host transfer, flush the data FIFO.
  5043. +#
  5044. +dma3:
  5045. +    test    SINDEX,0x4    jnz dma5    # DIRECTION
  5046. +    and    SINDEX,0xfe            # mask out FIFORESET
  5047. +    or    DFCNTRL,0x2,SINDEX        # FIFOFLUSH
  5048. +dma4:
  5049. +    test    DFCNTRL,0x2    jnz dma4    # FIFOFLUSHACK
  5050. +
  5051. +#  Now shut the DMA enables off, and copy STCNT (ie. the underrun
  5052. +#  amount, if any) to the SCB registers; SG_COUNT will get copied to
  5053. +#  the SCB's residual S/G count field after sg_advance is called.  Make
  5054. +#  sure that the DMA enables are actually off first lest we get an ILLSADDR.
  5055. +#
  5056. +dma5:
  5057. +    clr    DFCNTRL                # disable DMA
  5058. +dma6:
  5059. +    test    DFCNTRL,0x38    jnz dma6    # SCSIENACK|SDMAENACK|HDMAENACK
  5060. +
  5061. +    mvi    A,3
  5062. +    mvi    DINDEX,SCBARRAY+15
  5063. +    mvi    STCNT        call bcopy
  5064. +
  5065. +    ret
  5066. +
  5067. +#  Common SCSI initialization for selection and reselection.  Expects
  5068. +#  the target SCSI ID to be in the upper four bits of SINDEX, and A's
  5069. +#  contents are stomped on return.
  5070. +#
  5071. +initialize:
  5072. +    clr    SBLKCTL                # channel A, !wide
  5073. +    and    SCSIID,0xf0,SINDEX        # target ID
  5074. +    and    A,0x7,SCSICONF            # SCSI_ID_A[210]
  5075. +    or    SCSIID,A
  5076. +
  5077. +#  Esundry initialization.
  5078. +#
  5079. +    clr    DROPATN
  5080. +    clr    SIGSTATE
  5081. +
  5082. +#  Turn on Automatic PIO mode now, before we expect to see an REQ
  5083. +#  from the target.  It shouldn't hurt anything to leave it on.  Set
  5084. +#  CLRCHN here before the target has entered a data transfer mode -
  5085. +#  with synchronous SCSI, if you do it later, you blow away some
  5086. +#  data in the SCSI FIFO that the target has already sent to you.
  5087. +#
  5088. +    mvi    SXFRCTL0,0xa            # SPIOEN|CLRCHN
  5089. +
  5090. +#  Set SCSI bus parity checking and the selection timeout value,
  5091. +#  and enable the hardware selection timer.  Set the SELTO interrupt
  5092. +#  to signal the driver.
  5093. +#
  5094. +    and    A,0x38,SCSICONF            # PARITY_ENB_A|SEL_TIM_A[10]
  5095. +    or    SXFRCTL1,0x4,A            # ENSTIMER
  5096. +    mvi    SIMODE1,0x84            # ENSELTIMO|ENSCSIPERR
  5097. +    
  5098. +#  Initialize scatter-gather pointers by setting up the working copy
  5099. +#  in scratch RAM.
  5100. +#
  5101. +    call    sg_scb2ram
  5102. +
  5103. +#  Initialize SCSIRATE with the appropriate value for this target.
  5104. +#
  5105. +    call    ndx_sdtr
  5106. +    mov    SCSIRATE,SINDIR
  5107. +    ret
  5108. +
  5109. +#  Assert that if we've been reselected, then we've seen an IDENTIFY
  5110. +#  message.
  5111. +#
  5112. +assert:
  5113. +    test    RESELECT,0x80    jz assert1    # reselected?
  5114. +    test    RESELECT,0x40    jnz assert1    # seen IDENTIFY?
  5115. +
  5116. +    mvi    INTSTAT,SIGNAL_2        # no - cause a kernel panic
  5117. +
  5118. +assert1:
  5119. +    ret
  5120. +
  5121. +#  Find out if disconnection is ok from the information the BIOS has left
  5122. +#  us.  The target ID should be in the upper four bits of SINDEX; A will
  5123. +#  contain either 0x40 (disconnection ok) or 0x00 (diconnection not ok)
  5124. +#  on exit.
  5125. +#
  5126. +#  This is the only place the target ID is limited to three bits, so we
  5127. +#  can use the FUNCTION1 register.
  5128. +#
  5129. +disconnect:
  5130. +    and    FUNCTION1,0x70,SINDEX        # strip off extra just in case
  5131. +    mov    A,FUNCTION1
  5132. +    test    DISC_DSB_A,A    jz disconnect1    # bit nonzero if DISabled
  5133. +
  5134. +    clr    A        ret
  5135. +disconnect1:
  5136. +    mvi    A,0x40        ret
  5137. +
  5138. +#  Locate the SCB matching the target ID in SELID and the lun in the lower
  5139. +#  three bits of SINDEX, and switch the SCB to it.  Have the kernel print
  5140. +#  a warning message if it can't be found - this seems to happen occasionally
  5141. +#  under high loads.  Also, if not found, generate an ABORT message to the
  5142. +#  target.
  5143. +#
  5144. +findSCB:
  5145. +    and    A,0x7,SINDEX            # lun in lower three bits
  5146. +    or    A,A,SELID            # can I do this?
  5147. +    and    A,0xf7                # only channel A implemented
  5148. +
  5149. +    clr    SINDEX
  5150. +
  5151. +findSCB1:
  5152. +    mov    SCBPTR,SINDEX            # switch to new SCB
  5153. +    cmp    SCBARRAY+1,A    jne findSCB2    # target ID/channel/lun match?
  5154. +    test    SCBARRAY+0,0x4    jz findSCB2    # should be disconnected
  5155. +
  5156. +    ret
  5157. +
  5158. +findSCB2:
  5159. +    inc    SINDEX
  5160. +    cmp    SINDEX,MAXSCB    jne findSCB1
  5161. +
  5162. +    mvi    INTSTAT,SIGNAL_3        # not found - signal kernel
  5163. +    mvi    0x6        call mk_mesg    # ABORT message
  5164. +
  5165. +    or    SINDEX,0x10,SIGSTATE        # assert ATNO
  5166. +    call    scsisig
  5167. +    ret
  5168. +
  5169. +#  Make a working copy of the scatter-gather parameters in the SCB.
  5170. +#
  5171. +sg_scb2ram:
  5172. +    mov    SG_COUNT,SCBARRAY+2
  5173. +
  5174. +    mvi    A,4
  5175. +    mvi    DINDEX,SG_NEXT
  5176. +    mvi    SCBARRAY+3    call bcopy
  5177. +
  5178. +    mvi    SG_NOLOAD,0x80
  5179. +    test    SCBARRAY+0,0x10    jnz sg_scb2ram1    # don't reload s/g?
  5180. +    clr    SG_NOLOAD
  5181. +
  5182. +sg_scb2ram1:
  5183. +    ret
  5184. +
  5185. +#  Copying RAM values back to SCB, for Save Data Pointers message.
  5186. +#
  5187. +sg_ram2scb:
  5188. +    mov    SCBARRAY+2,SG_COUNT
  5189. +
  5190. +    mvi    A,4
  5191. +    mvi    DINDEX,SCBARRAY+3
  5192. +    mvi    SG_NEXT        call bcopy
  5193. +
  5194. +    and    SCBARRAY+0,0xef,SCBARRAY+0
  5195. +    test    SG_NOLOAD,0x80    jz sg_ram2scb1    # reload s/g?
  5196. +    or    SCBARRAY+0,0x10
  5197. +
  5198. +sg_ram2scb1:
  5199. +    ret
  5200. +
  5201. +#  Load a struct scatter if needed and set up the data address and
  5202. +#  length.  If the working value of the SG count is nonzero, then
  5203. +#  we need to load a new set of values.
  5204. +#
  5205. +#  This, like the above DMA, assumes a little-endian host data storage.
  5206. +#
  5207. +sg_load:
  5208. +    test    SG_COUNT,0xff    jz sg_load3    # SG being used?
  5209. +    test    SG_NOLOAD,0x80    jnz sg_load3    # don't reload s/g?
  5210. +
  5211. +    clr    HCNT+2
  5212. +    clr    HCNT+1
  5213. +    mvi    HCNT+0,SG_SIZEOF
  5214. +
  5215. +    mvi    A,4
  5216. +    mvi    DINDEX,HADDR
  5217. +    mvi    SG_NEXT        call bcopy
  5218. +
  5219. +    mvi    DFCNTRL,0xd            # HDMAEN|DIRECTION|FIFORESET
  5220. +
  5221. +#  Wait for DMA from host memory to data FIFO to complete, then disable
  5222. +#  DMA and wait for it to acknowledge that it's off.
  5223. +#
  5224. +sg_load1:
  5225. +    test    DFSTATUS,0x8    jz sg_load1    # HDONE
  5226. +
  5227. +    clr    DFCNTRL                # disable DMA
  5228. +sg_load2:
  5229. +    test    DFCNTRL,0x8    jnz sg_load2    # HDMAENACK
  5230. +
  5231. +#  Copy data from FIFO into SCB data pointer and data count.  This assumes
  5232. +#  that the struct scatterlist has this structure (this and sizeof(struct
  5233. +#  scatterlist) == 12 are asserted in aha274x.c):
  5234. +#
  5235. +#    struct scatterlist {
  5236. +#        char *address;        /* four bytes, little-endian order */
  5237. +#        ...            /* four bytes, ignored */
  5238. +#        unsigned short length;    /* two bytes, little-endian order */
  5239. +#    }
  5240. +#
  5241. +    mov    SCBARRAY+19,DFDAT        # new data address
  5242. +    mov    SCBARRAY+20,DFDAT
  5243. +    mov    SCBARRAY+21,DFDAT
  5244. +    mov    SCBARRAY+22,DFDAT
  5245. +
  5246. +    mov    NONE,DFDAT            # throw away four bytes
  5247. +    mov    NONE,DFDAT
  5248. +    mov    NONE,DFDAT
  5249. +    mov    NONE,DFDAT
  5250. +
  5251. +    mov    SCBARRAY+23,DFDAT
  5252. +    mov    SCBARRAY+24,DFDAT
  5253. +    clr    SCBARRAY+25
  5254. +
  5255. +sg_load3:
  5256. +    ret
  5257. +
  5258. +#  Advance the scatter-gather pointers only IF NEEDED.  If SG is enabled,
  5259. +#  and the SCSI transfer count is zero (note that this should be called
  5260. +#  right after a DMA finishes), then move the working copies of the SG
  5261. +#  pointer/length along.  If the SCSI transfer count is not zero, then
  5262. +#  presumably the target is disconnecting - do not reload the SG values
  5263. +#  next time.
  5264. +#
  5265. +sg_advance:
  5266. +    test    SG_COUNT,0xff    jz sg_advance2    # s/g enabled?
  5267. +
  5268. +    test    STCNT+0,0xff    jnz sg_advance1    # SCSI transfer count nonzero?
  5269. +    test    STCNT+1,0xff    jnz sg_advance1
  5270. +    test    STCNT+2,0xff    jnz sg_advance1
  5271. +
  5272. +    clr    SG_NOLOAD            # reload s/g next time
  5273. +    dec    SG_COUNT            # one less segment to go
  5274. +
  5275. +    clr    A                # add sizeof(struct scatter)
  5276. +    add    SG_NEXT+0,SG_SIZEOF,SG_NEXT+0
  5277. +    adc    SG_NEXT+1,A,SG_NEXT+1
  5278. +    adc    SG_NEXT+2,A,SG_NEXT+2
  5279. +    adc    SG_NEXT+3,A,SG_NEXT+3
  5280. +
  5281. +    ret
  5282. +
  5283. +sg_advance1:
  5284. +    mvi    SG_NOLOAD,0x80            # don't reload s/g next time
  5285. +sg_advance2:
  5286. +    ret
  5287. +
  5288. +#  Add the array base SYNCNEG to the target offset (the target address
  5289. +#  is in SCSIID), and return the result in SINDEX.  The accumulator
  5290. +#  contains the 3->8 decoding of the target ID on return.
  5291. +#
  5292. +ndx_sdtr:
  5293. +    shr    A,SCSIID,4
  5294. +    and    A,0x7
  5295. +    add    SINDEX,SYNCNEG,A
  5296. +
  5297. +    and    FUNCTION1,0x70,SCSIID        # 3-bit target address decode
  5298. +    mov    A,FUNCTION1    ret
  5299. +
  5300. +#  If we need to negotiate transfer parameters, build the SDTR message
  5301. +#  starting at the address passed in SINDEX.  DINDEX is modified on return.
  5302. +#
  5303. +mk_sdtr:
  5304. +    mov    DINDEX,SINDEX            # save SINDEX
  5305. +
  5306. +    call    ndx_sdtr
  5307. +    test    NEEDSDTR,A    jnz mk_sdtr1    # do we need negotiation?
  5308. +    ret
  5309. +
  5310. +mk_sdtr1:
  5311. +    mvi    DINDIR,1            # extended message
  5312. +    mvi    DINDIR,3            # extended message length = 3
  5313. +    mvi    DINDIR,1            # SDTR code
  5314. +    mvi    DINDIR,25            # REQ/ACK transfer period
  5315. +    mvi    DINDIR,15            # REQ/ACK offset
  5316. +
  5317. +    add    MSG_LEN,-MSG_START+0,DINDEX    # update message length
  5318. +    ret
  5319. +
  5320. +#  Set SCSI bus control signal state.  This also saves the last-written
  5321. +#  value into a location where the higher-level driver can read it - if
  5322. +#  it has to send an ABORT or RESET message, then it needs to know this
  5323. +#  so it can assert ATN without upsetting SCSISIGO.  The new value is
  5324. +#  expected in SINDEX.  Change the actual state last to avoid contention
  5325. +#  from the driver.
  5326. +#
  5327. +scsisig:
  5328. +    mov    SIGSTATE,SINDEX
  5329. +    mov    SCSISIGO,SINDEX    ret
  5330. diff -u --recursive --new-file linux-1.1.58/drivers/scsi/aha274x_seq.h linux/drivers/scsi/aha274x_seq.h
  5331. --- linux-1.1.58/drivers/scsi/aha274x_seq.h    Wed Dec 31 18:00:00 1969
  5332. +++ linux/drivers/scsi/aha274x_seq.h    Wed Oct 26 23:02:01 1994
  5333. @@ -0,0 +1,336 @@
  5334. +#define AHA274X_SEQ_VERSION "1.26"
  5335. +    0x04, 0x03, 0x12, 0x1a,
  5336. +    0x07, 0x9c, 0x00, 0x1e,
  5337. +    0xff, 0x9b, 0x90, 0x02,
  5338. +    0x00, 0xa1, 0xe1, 0x16,
  5339. +    0xff, 0x6a, 0x54, 0x02,
  5340. +    0xff, 0x6a, 0x34, 0x02,
  5341. +    0x00, 0xa1, 0xf3, 0x16,
  5342. +    0x07, 0xa1, 0x65, 0x02,
  5343. +    0x00, 0x65, 0x65, 0x00,
  5344. +    0x80, 0x65, 0xad, 0x16,
  5345. +    0xff, 0x65, 0x64, 0x02,
  5346. +    0x00, 0x37, 0x0d, 0x18,
  5347. +    0x38, 0x6a, 0x42, 0x17,
  5348. +    0x48, 0x6a, 0x00, 0x00,
  5349. +    0x40, 0x0b, 0x16, 0x1a,
  5350. +    0x10, 0x0b, 0x0e, 0x1e,
  5351. +    0x40, 0x0b, 0x10, 0x1e,
  5352. +    0x00, 0x65, 0x16, 0x10,
  5353. +    0x10, 0x6a, 0x00, 0x00,
  5354. +    0x20, 0x0b, 0x13, 0x1e,
  5355. +    0x00, 0x19, 0xe1, 0x16,
  5356. +    0x80, 0x6a, 0x34, 0x00,
  5357. +    0xff, 0x6a, 0x00, 0x02,
  5358. +    0x08, 0x6a, 0x0c, 0x00,
  5359. +    0x08, 0x0c, 0xa6, 0x1a,
  5360. +    0x01, 0x0c, 0x18, 0x1e,
  5361. +    0xe0, 0x03, 0x64, 0x02,
  5362. +    0x00, 0x6a, 0x22, 0x1c,
  5363. +    0x40, 0x64, 0x32, 0x1c,
  5364. +    0x80, 0x64, 0x42, 0x1c,
  5365. +    0xc0, 0x64, 0x4f, 0x1c,
  5366. +    0xa0, 0x64, 0x52, 0x1c,
  5367. +    0xe0, 0x64, 0x68, 0x1c,
  5368. +    0x01, 0x6a, 0x91, 0x00,
  5369. +    0x00, 0x6a, 0x4d, 0x17,
  5370. +    0x00, 0x65, 0xef, 0x16,
  5371. +    0x00, 0x65, 0x17, 0x17,
  5372. +    0x03, 0x6a, 0x64, 0x00,
  5373. +    0x8c, 0x6a, 0x66, 0x00,
  5374. +    0xb7, 0x6a, 0xa9, 0x16,
  5375. +    0x03, 0x6a, 0x64, 0x00,
  5376. +    0x08, 0x6a, 0x66, 0x00,
  5377. +    0xb7, 0x6a, 0xa9, 0x16,
  5378. +    0x04, 0x6a, 0x64, 0x00,
  5379. +    0x88, 0x6a, 0x66, 0x00,
  5380. +    0xb3, 0x6a, 0xa9, 0x16,
  5381. +    0x3d, 0x6a, 0xd1, 0x16,
  5382. +    0x00, 0x65, 0x2f, 0x17,
  5383. +    0xff, 0x55, 0xb2, 0x02,
  5384. +    0x00, 0x65, 0x18, 0x10,
  5385. +    0x40, 0x6a, 0x4d, 0x17,
  5386. +    0x00, 0x65, 0xef, 0x16,
  5387. +    0x00, 0x65, 0x17, 0x17,
  5388. +    0x03, 0x6a, 0x64, 0x00,
  5389. +    0x8c, 0x6a, 0x66, 0x00,
  5390. +    0xb7, 0x6a, 0xa9, 0x16,
  5391. +    0x03, 0x6a, 0x64, 0x00,
  5392. +    0x08, 0x6a, 0x66, 0x00,
  5393. +    0xb7, 0x6a, 0xa9, 0x16,
  5394. +    0x04, 0x6a, 0x64, 0x00,
  5395. +    0x88, 0x6a, 0x66, 0x00,
  5396. +    0xb3, 0x6a, 0xa9, 0x16,
  5397. +    0x39, 0x6a, 0xd1, 0x16,
  5398. +    0x00, 0x65, 0x2f, 0x17,
  5399. +    0xff, 0x55, 0xb2, 0x02,
  5400. +    0x00, 0x65, 0x18, 0x10,
  5401. +    0x80, 0x6a, 0x4d, 0x17,
  5402. +    0x00, 0x65, 0xef, 0x16,
  5403. +    0x03, 0x6a, 0x64, 0x00,
  5404. +    0x8c, 0x6a, 0x66, 0x00,
  5405. +    0xab, 0x6a, 0xa9, 0x16,
  5406. +    0x03, 0x6a, 0x64, 0x00,
  5407. +    0x08, 0x6a, 0x66, 0x00,
  5408. +    0xab, 0x6a, 0xa9, 0x16,
  5409. +    0x04, 0x6a, 0x64, 0x00,
  5410. +    0x88, 0x6a, 0x66, 0x00,
  5411. +    0xa7, 0x6a, 0xa9, 0x16,
  5412. +    0x3d, 0x6a, 0xd1, 0x16,
  5413. +    0x00, 0x65, 0x18, 0x10,
  5414. +    0xc0, 0x6a, 0x4d, 0x17,
  5415. +    0xae, 0x6a, 0xb4, 0x16,
  5416. +    0x00, 0x65, 0x18, 0x10,
  5417. +    0xa0, 0x6a, 0x4d, 0x17,
  5418. +    0x08, 0x6a, 0xad, 0x16,
  5419. +    0x37, 0x6a, 0x65, 0x00,
  5420. +    0xff, 0x36, 0x66, 0x02,
  5421. +    0xff, 0x6a, 0x64, 0x02,
  5422. +    0x02, 0x0b, 0x57, 0x1e,
  5423. +    0x01, 0x66, 0x5a, 0x18,
  5424. +    0x40, 0x6a, 0x0c, 0x00,
  5425. +    0x00, 0x65, 0xce, 0x16,
  5426. +    0xff, 0x6c, 0x06, 0x02,
  5427. +    0x04, 0x0b, 0x5c, 0x1e,
  5428. +    0xff, 0x66, 0x66, 0x06,
  5429. +    0x01, 0x64, 0x64, 0x06,
  5430. +    0x00, 0x36, 0x57, 0x18,
  5431. +    0x08, 0x0c, 0x66, 0x1a,
  5432. +    0x01, 0x0c, 0x60, 0x1e,
  5433. +    0xe0, 0x03, 0x64, 0x02,
  5434. +    0xa0, 0x64, 0x66, 0x18,
  5435. +    0x10, 0x6a, 0x4d, 0x17,
  5436. +    0x00, 0x65, 0x18, 0x10,
  5437. +    0xff, 0x6a, 0x35, 0x02,
  5438. +    0x00, 0x65, 0x18, 0x10,
  5439. +    0xe0, 0x6a, 0x4d, 0x17,
  5440. +    0x64, 0x6a, 0xba, 0x16,
  5441. +    0x00, 0x6a, 0x31, 0x00,
  5442. +    0x00, 0x6a, 0x6f, 0x18,
  5443. +    0xff, 0x90, 0x9d, 0x02,
  5444. +    0x02, 0x6a, 0x91, 0x00,
  5445. +    0x00, 0x65, 0xa4, 0x10,
  5446. +    0x01, 0x64, 0x7e, 0x18,
  5447. +    0x64, 0x6a, 0xbc, 0x16,
  5448. +    0x03, 0x64, 0xa0, 0x18,
  5449. +    0x64, 0x6a, 0xbc, 0x16,
  5450. +    0x01, 0x64, 0xa0, 0x18,
  5451. +    0x4c, 0x6a, 0xbc, 0x16,
  5452. +    0x4d, 0x6a, 0xbc, 0x16,
  5453. +    0x41, 0x6a, 0x91, 0x00,
  5454. +    0x00, 0x65, 0x3d, 0x17,
  5455. +    0xff, 0x65, 0x66, 0x02,
  5456. +    0xff, 0x4c, 0x6d, 0x02,
  5457. +    0xff, 0x64, 0x64, 0x04,
  5458. +    0x00, 0x4f, 0x4f, 0x02,
  5459. +    0xff, 0x4c, 0x04, 0x02,
  5460. +    0x00, 0x65, 0xa4, 0x10,
  5461. +    0x04, 0x64, 0x81, 0x18,
  5462. +    0x04, 0xa0, 0xa0, 0x00,
  5463. +    0x00, 0x65, 0xa4, 0x10,
  5464. +    0x02, 0x64, 0x8a, 0x18,
  5465. +    0x04, 0x6a, 0x64, 0x00,
  5466. +    0xb3, 0x6a, 0x66, 0x00,
  5467. +    0x50, 0x6a, 0xa9, 0x16,
  5468. +    0x03, 0x6a, 0x64, 0x00,
  5469. +    0xb7, 0x6a, 0x66, 0x00,
  5470. +    0xaf, 0x6a, 0xa9, 0x16,
  5471. +    0x00, 0x65, 0x0f, 0x17,
  5472. +    0x00, 0x65, 0xa4, 0x10,
  5473. +    0x03, 0x64, 0x8d, 0x18,
  5474. +    0x00, 0x65, 0x07, 0x17,
  5475. +    0x00, 0x65, 0xa4, 0x10,
  5476. +    0x80, 0x64, 0x95, 0x1e,
  5477. +    0x78, 0x64, 0xa0, 0x1a,
  5478. +    0x00, 0x64, 0xf8, 0x16,
  5479. +    0x80, 0x35, 0xa4, 0x1a,
  5480. +    0x04, 0xa0, 0xa0, 0x04,
  5481. +    0xc0, 0x6a, 0x34, 0x00,
  5482. +    0x00, 0x65, 0x07, 0x17,
  5483. +    0x00, 0x65, 0xa4, 0x10,
  5484. +    0x07, 0x64, 0xa0, 0x18,
  5485. +    0x70, 0x05, 0x6e, 0x02,
  5486. +    0xff, 0x6e, 0x64, 0x02,
  5487. +    0x00, 0x4f, 0xa4, 0x1e,
  5488. +    0x00, 0x65, 0x3d, 0x17,
  5489. +    0xff, 0x65, 0x66, 0x02,
  5490. +    0xff, 0x6a, 0x6d, 0x02,
  5491. +    0xff, 0x64, 0x64, 0x04,
  5492. +    0x00, 0x4f, 0x4f, 0x02,
  5493. +    0xff, 0x6a, 0x04, 0x02,
  5494. +    0x00, 0x65, 0xa4, 0x10,
  5495. +    0x10, 0x4e, 0x65, 0x00,
  5496. +    0x00, 0x65, 0x4d, 0x17,
  5497. +    0x11, 0x6a, 0x91, 0x00,
  5498. +    0x07, 0x6a, 0xad, 0x16,
  5499. +    0x00, 0x65, 0xc2, 0x16,
  5500. +    0x00, 0x65, 0x18, 0x10,
  5501. +    0x40, 0x6a, 0x0c, 0x00,
  5502. +    0xff, 0x6a, 0x4e, 0x02,
  5503. +    0x00, 0x65, 0x00, 0x10,
  5504. +    0xff, 0x6c, 0x6d, 0x02,
  5505. +    0xff, 0x64, 0x64, 0x06,
  5506. +    0x00, 0x6a, 0xa9, 0x18,
  5507. +    0xff, 0x6a, 0x6a, 0x03,
  5508. +    0x40, 0x6a, 0x60, 0x00,
  5509. +    0x80, 0x35, 0xb2, 0x1a,
  5510. +    0x80, 0x6a, 0x35, 0x00,
  5511. +    0x01, 0x6a, 0x36, 0x00,
  5512. +    0xff, 0x65, 0x37, 0x02,
  5513. +    0xff, 0x6a, 0x60, 0x02,
  5514. +    0xff, 0x6a, 0x6a, 0x03,
  5515. +    0x02, 0x0b, 0xb4, 0x1e,
  5516. +    0xff, 0x65, 0x66, 0x02,
  5517. +    0x00, 0x65, 0xce, 0x16,
  5518. +    0xff, 0x06, 0x6d, 0x02,
  5519. +    0x04, 0x0b, 0xb8, 0x1e,
  5520. +    0xff, 0x6a, 0x6a, 0x03,
  5521. +    0xff, 0x65, 0x66, 0x02,
  5522. +    0xff, 0x12, 0x6d, 0x03,
  5523. +    0xff, 0x65, 0x66, 0x02,
  5524. +    0x00, 0x65, 0xce, 0x16,
  5525. +    0xff, 0x06, 0x6a, 0x02,
  5526. +    0x04, 0x0b, 0xbf, 0x1e,
  5527. +    0x02, 0x0b, 0xc0, 0x1e,
  5528. +    0xff, 0x12, 0x6d, 0x03,
  5529. +    0x00, 0x65, 0xce, 0x16,
  5530. +    0xff, 0x06, 0x6a, 0x02,
  5531. +    0x04, 0x0b, 0xc4, 0x1e,
  5532. +    0xff, 0x6a, 0x6a, 0x03,
  5533. +    0x02, 0x0b, 0xc6, 0x1e,
  5534. +    0x00, 0x65, 0xce, 0x16,
  5535. +    0x80, 0x30, 0xcb, 0x1e,
  5536. +    0x40, 0x6a, 0x0c, 0x00,
  5537. +    0xff, 0x6a, 0x30, 0x02,
  5538. +    0xff, 0x65, 0x06, 0x02,
  5539. +    0x04, 0x0b, 0xcc, 0x1e,
  5540. +    0xff, 0x6a, 0x6a, 0x03,
  5541. +    0xff, 0x6a, 0x0a, 0x02,
  5542. +    0xff, 0x6a, 0x09, 0x02,
  5543. +    0x01, 0x6a, 0x08, 0x01,
  5544. +    0xff, 0x65, 0x93, 0x02,
  5545. +    0x01, 0x0b, 0xd4, 0x1a,
  5546. +    0x10, 0x0c, 0xd2, 0x1e,
  5547. +    0x04, 0x65, 0xd8, 0x1a,
  5548. +    0xfe, 0x65, 0x65, 0x02,
  5549. +    0x02, 0x65, 0x93, 0x00,
  5550. +    0x02, 0x93, 0xd7, 0x1a,
  5551. +    0xff, 0x6a, 0x93, 0x02,
  5552. +    0x38, 0x93, 0xd9, 0x1a,
  5553. +    0x04, 0x6a, 0x64, 0x00,
  5554. +    0x50, 0x6a, 0x66, 0x00,
  5555. +    0x14, 0x6a, 0xa9, 0x16,
  5556. +    0x03, 0x6a, 0x64, 0x00,
  5557. +    0xaf, 0x6a, 0x66, 0x00,
  5558. +    0x08, 0x6a, 0xa9, 0x16,
  5559. +    0xff, 0x6a, 0x6a, 0x03,
  5560. +    0xff, 0x6a, 0x1f, 0x02,
  5561. +    0xf0, 0x65, 0x05, 0x02,
  5562. +    0x07, 0x5a, 0x64, 0x02,
  5563. +    0x00, 0x05, 0x05, 0x00,
  5564. +    0xff, 0x6a, 0x30, 0x02,
  5565. +    0xff, 0x6a, 0x4e, 0x02,
  5566. +    0x0a, 0x6a, 0x01, 0x00,
  5567. +    0x38, 0x5a, 0x64, 0x02,
  5568. +    0x04, 0x64, 0x02, 0x00,
  5569. +    0x84, 0x6a, 0x11, 0x00,
  5570. +    0x00, 0x65, 0x07, 0x17,
  5571. +    0x00, 0x65, 0x3d, 0x17,
  5572. +    0xff, 0x6c, 0x04, 0x02,
  5573. +    0xff, 0x6a, 0x6a, 0x03,
  5574. +    0x80, 0x34, 0xf2, 0x1e,
  5575. +    0x40, 0x34, 0xf2, 0x1a,
  5576. +    0x21, 0x6a, 0x91, 0x00,
  5577. +    0xff, 0x6a, 0x6a, 0x03,
  5578. +    0x70, 0x65, 0x6e, 0x02,
  5579. +    0xff, 0x6e, 0x64, 0x02,
  5580. +    0x00, 0x32, 0xf7, 0x1e,
  5581. +    0xff, 0x6a, 0x64, 0x03,
  5582. +    0x40, 0x6a, 0x64, 0x01,
  5583. +    0x07, 0x65, 0x64, 0x02,
  5584. +    0x00, 0x19, 0x64, 0x00,
  5585. +    0xf7, 0x64, 0x64, 0x02,
  5586. +    0xff, 0x6a, 0x65, 0x02,
  5587. +    0xff, 0x65, 0x90, 0x02,
  5588. +    0x00, 0xa1, 0x00, 0x19,
  5589. +    0x04, 0xa0, 0x00, 0x1f,
  5590. +    0xff, 0x6a, 0x6a, 0x03,
  5591. +    0x01, 0x65, 0x65, 0x06,
  5592. +    0x04, 0x65, 0xfc, 0x18,
  5593. +    0x31, 0x6a, 0x91, 0x00,
  5594. +    0x06, 0x6a, 0xad, 0x16,
  5595. +    0x10, 0x4e, 0x65, 0x00,
  5596. +    0x00, 0x65, 0x4d, 0x17,
  5597. +    0xff, 0x6a, 0x6a, 0x03,
  5598. +    0xff, 0xa2, 0x55, 0x02,
  5599. +    0x04, 0x6a, 0x64, 0x00,
  5600. +    0x56, 0x6a, 0x66, 0x00,
  5601. +    0xa3, 0x6a, 0xa9, 0x16,
  5602. +    0x80, 0x6a, 0x54, 0x00,
  5603. +    0x10, 0xa0, 0x0e, 0x1b,
  5604. +    0xff, 0x6a, 0x54, 0x02,
  5605. +    0xff, 0x6a, 0x6a, 0x03,
  5606. +    0xff, 0x55, 0xa2, 0x02,
  5607. +    0x04, 0x6a, 0x64, 0x00,
  5608. +    0xa3, 0x6a, 0x66, 0x00,
  5609. +    0x56, 0x6a, 0xa9, 0x16,
  5610. +    0xef, 0xa0, 0xa0, 0x02,
  5611. +    0x80, 0x54, 0x16, 0x1f,
  5612. +    0x10, 0xa0, 0xa0, 0x00,
  5613. +    0xff, 0x6a, 0x6a, 0x03,
  5614. +    0xff, 0x55, 0x2e, 0x1f,
  5615. +    0x80, 0x54, 0x2e, 0x1b,
  5616. +    0xff, 0x6a, 0x8e, 0x02,
  5617. +    0xff, 0x6a, 0x8d, 0x02,
  5618. +    0x0c, 0x6a, 0x8c, 0x00,
  5619. +    0x04, 0x6a, 0x64, 0x00,
  5620. +    0x88, 0x6a, 0x66, 0x00,
  5621. +    0x56, 0x6a, 0xa9, 0x16,
  5622. +    0x0d, 0x6a, 0x93, 0x00,
  5623. +    0x08, 0x94, 0x20, 0x1f,
  5624. +    0xff, 0x6a, 0x93, 0x02,
  5625. +    0x08, 0x93, 0x22, 0x1b,
  5626. +    0xff, 0x99, 0xb3, 0x02,
  5627. +    0xff, 0x99, 0xb4, 0x02,
  5628. +    0xff, 0x99, 0xb5, 0x02,
  5629. +    0xff, 0x99, 0xb6, 0x02,
  5630. +    0xff, 0x99, 0x6a, 0x02,
  5631. +    0xff, 0x99, 0x6a, 0x02,
  5632. +    0xff, 0x99, 0x6a, 0x02,
  5633. +    0xff, 0x99, 0x6a, 0x02,
  5634. +    0xff, 0x99, 0xb7, 0x02,
  5635. +    0xff, 0x99, 0xb8, 0x02,
  5636. +    0xff, 0x6a, 0xb9, 0x02,
  5637. +    0xff, 0x6a, 0x6a, 0x03,
  5638. +    0xff, 0x55, 0x3c, 0x1f,
  5639. +    0xff, 0x08, 0x3b, 0x1b,
  5640. +    0xff, 0x09, 0x3b, 0x1b,
  5641. +    0xff, 0x0a, 0x3b, 0x1b,
  5642. +    0xff, 0x6a, 0x54, 0x02,
  5643. +    0xff, 0x55, 0x55, 0x06,
  5644. +    0xff, 0x6a, 0x64, 0x02,
  5645. +    0x0c, 0x56, 0x56, 0x06,
  5646. +    0x00, 0x57, 0x57, 0x08,
  5647. +    0x00, 0x58, 0x58, 0x08,
  5648. +    0x00, 0x59, 0x59, 0x08,
  5649. +    0xff, 0x6a, 0x6a, 0x03,
  5650. +    0x80, 0x6a, 0x54, 0x00,
  5651. +    0xff, 0x6a, 0x6a, 0x03,
  5652. +    0x4c, 0x05, 0x64, 0x0a,
  5653. +    0x07, 0x64, 0x64, 0x02,
  5654. +    0x20, 0x64, 0x65, 0x06,
  5655. +    0x70, 0x05, 0x6e, 0x02,
  5656. +    0xff, 0x6e, 0x64, 0x03,
  5657. +    0xff, 0x65, 0x66, 0x02,
  5658. +    0x00, 0x65, 0x3d, 0x17,
  5659. +    0x00, 0x4f, 0x46, 0x1b,
  5660. +    0xff, 0x6a, 0x6a, 0x03,
  5661. +    0x01, 0x6a, 0x6d, 0x00,
  5662. +    0x03, 0x6a, 0x6d, 0x00,
  5663. +    0x01, 0x6a, 0x6d, 0x00,
  5664. +    0x19, 0x6a, 0x6d, 0x00,
  5665. +    0x0f, 0x6a, 0x6d, 0x00,
  5666. +    0xc9, 0x66, 0x36, 0x06,
  5667. +    0xff, 0x6a, 0x6a, 0x03,
  5668. +    0xff, 0x65, 0x4e, 0x02,
  5669. +    0xff, 0x65, 0x03, 0x03,
  5670. diff -u --recursive --new-file linux-1.1.58/drivers/scsi/eata.c linux/drivers/scsi/eata.c
  5671. --- linux-1.1.58/drivers/scsi/eata.c    Wed Dec 31 18:00:00 1969
  5672. +++ linux/drivers/scsi/eata.c    Wed Oct 26 23:02:01 1994
  5673. @@ -0,0 +1,621 @@
  5674. +/************************************************************
  5675. + *                                                          *
  5676. + *                  Linux EATA SCSI driver                  *
  5677. + *                                                          *
  5678. + *  based on the EATA proposal rev 2.0b, DPT DOS driver kit *
  5679. + *  some proprietary source (DPT Unix driver), several      *
  5680. + *  other linux scsi drivers and kernel documentation       *
  5681. + *                                                          *
  5682. + *  The driver currently:                                   *
  5683. + *      -has ISA detection routines                         *
  5684. + *      -has EISA detection routines (new)                  *
  5685. + *      -doesn't support more than one HA and one channel   *
  5686. + *      -gets sometimes timeouts when accessing more than   *
  5687. + *       one device "simultaniously"                        *
  5688. + *                                                          *
  5689. + *  ECS_emulation_sense() doesn't work and I don't know why * 
  5690. + *  Until this is working, the drive geometry has to be     * 
  5691. + *  hardcoded into the driver :-( (Any ideas ?)             *
  5692. + *                                                          *
  5693. + *  (c)1993,94 Michael Neuffer                              *
  5694. + *             Michael_Neuffer@wi2.maus.de (mails <16KB!)   *
  5695. + *             neuffer@goofy.zdv.uni-mainz.de               *
  5696. + *                                                          *
  5697. + *  This program is free software; you can redistribute it  * 
  5698. + *  and/or modify it under the terms of the GNU General     *
  5699. + *  Public License as published by the Free Software        *
  5700. + *  Foundation; either version 2 of the License, or         *
  5701. + *  (at your option) any later version.                     *
  5702. + *                                                          *
  5703. + *  This program is distributed in the hope that it will be *
  5704. + *  useful, but WITHOUT ANY WARRANTY; without even the      *
  5705. + *  implied warranty of MERCHANTABILITY or FITNESS FOR A    *
  5706. + *  PARTICULAR PURPOSE.  See the GNU General Public License *
  5707. + *  for more details.                                       *
  5708. + *                                                          *
  5709. + *  You should have received a copy of the GNU General      * 
  5710. + *  Public License along with this kernel; if not, write to *
  5711. + *  the Free Software Foundation, Inc., 675 Mass Ave,       *
  5712. + *  Cambridge, MA 02139, USA.                               *
  5713. + *                                                          *
  5714. + *                                                          *
  5715. + * I have to thank DPT for their excellent support. I took  *
  5716. + * me almost a year and a stopover at their HQ on my first  *
  5717. + * trip to the USA to get it, but now they are very helpful *
  5718. + * and try to give me all the infos and support I need....  *
  5719. + *                                                          *
  5720. + ************************************************************
  5721. + *  last change: 02.10.94                                   *
  5722. + ************************************************************/
  5723. +
  5724. +/* Look in eata.h for configuration information */
  5725. +
  5726. +#include <linux/kernel.h>
  5727. +#include <linux/sched.h>
  5728. +#include <linux/string.h>
  5729. +#include <linux/ioport.h>
  5730. +#include <asm/io.h>
  5731. +#include <asm/dma.h>
  5732. +#include "eata.h"
  5733. +#include "scsi.h"
  5734. +#include "sd.h"
  5735. +
  5736. +#define MAXISA  4
  5737. +#define MAXEISA 16  
  5738. +
  5739. +static unsigned int ISAbases[]={0x1F0,0x170,0x330,0x230};
  5740. +static unsigned int EISAbases[]={1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
  5741. +static struct eata_register *EATA_base;
  5742. +
  5743. +static unsigned char dma_channel;
  5744. +static struct geom_emul geometry;       /* Drive 1 & 2 geometry              */
  5745. +
  5746. +static int eata_int_happened, eata_status, expecting_ints;
  5747. +
  5748. +struct eata_cmd_queue outstanding[64];  /* We should allocate this dynamicly */
  5749. +
  5750. +int cont_errs[]=
  5751. +{
  5752. +  DID_OK,         /* No error                    */
  5753. +  DID_NO_CONNECT, /* Selection Timeout           */
  5754. +  DID_TIME_OUT,   /* Command Timeout             */
  5755. +  DID_RESET,      /* SCSI Bus Reset Received     */
  5756. +  DID_ERROR,      /* Initial Controller Power up */
  5757. +  DID_ERROR,      /* Unexpected Bus Phase        */
  5758. +  DID_ERROR,      /* Unexpected Bus Free         */
  5759. +  DID_PARITY,     /* Bus Parity Error            */
  5760. +  DID_ERROR,      /* SCSI Hung                   */
  5761. +  DID_ERROR,      /* Unexpected Message Rejected */
  5762. +  DID_ERROR,      /* SCSI Bus Reset STUCK        */            
  5763. +  DID_ERROR,      /* Auto Request-Sense Failed   */
  5764. +  DID_PARITY,     /* Controller Ram Parity Error */
  5765. +};
  5766. +
  5767. +inline void end_of_command(void)
  5768. +{
  5769. +  Scsi_Cmnd *cmd;
  5770. +  struct eata_ccb *cp;
  5771. +  struct eata_sp  *sp;
  5772. +  int i, result;
  5773. +        /* Find out which CP caused the interrupt */
  5774. +  for(i=0; i<64; i++)
  5775. +    {
  5776. +      if(outstanding[i].used && outstanding[i].sp.cont_stat & 0x80)
  5777. +    break;
  5778. +    }
  5779. +  if(i==64)
  5780. +    {
  5781. +      printk("Got interrupt but no finished packet found!\n");
  5782. +      return;
  5783. +    }
  5784. +  DBG(DBG_AHMON,outb(i, 0x80));                   /* Ahmon's special */     
  5785. +  cmd=outstanding[i].cmd;
  5786. +  cp=&outstanding[i].cp;
  5787. +  sp=&outstanding[i].sp;
  5788. +  outstanding[i].used=0;
  5789. +  if(cmd->use_sg) scsi_free(cmd->host_scribble, 512);
  5790. +  result=sp->scsi_stat;                             
  5791. +  
  5792. +  DBG(DBG_INTR,printk("end_of_command: queuenr: %d message bytes: %x,%x,%x\n",
  5793. +              i,sp->msg[0],sp->msg[1],sp->msg[2]));
  5794. + 
  5795. +  result|=COMMAND_COMPLETE<<8; 
  5796. +  result|=cont_errs[sp->cont_stat&0x7f] << 16; /* Fixed the error array */
  5797. +  cmd->result=result;
  5798. +  
  5799. +  cmd->scsi_done(cmd);
  5800. +}
  5801. +
  5802. +void eata_int_handler(int irq)
  5803. +{
  5804. +  eata_status=inb(((int)EATA_base)+HA_RSTATUS); /* Acknowledge interrupt */
  5805. +  DBG(DBG_INTR, printk(" Interrupt %d received, expected: %d,Status: %x\n",irq,
  5806. +               expecting_ints,eata_status));
  5807. +  if(expecting_ints==EXP_NOTHING)
  5808. +    {
  5809. +      printk("eata_int_handler: Unexpected interrupt!\n");
  5810. +      return;
  5811. +    }
  5812. +  if(expecting_ints==EXP_NORMAL)
  5813. +    {
  5814. +      eata_int_happened=1;
  5815. +      return;
  5816. +    }
  5817. +  end_of_command();
  5818. +}
  5819. +
  5820. +inline void eata_set_dma_address(int add)
  5821. +{
  5822. +  outb(add & 0x000000ff, ((int)EATA_base)+HA_WDMAADDR);
  5823. +  outb((add & 0x0000ff00) >> 8, ((int)EATA_base)+HA_WDMAADDR+1);
  5824. +  outb((add & 0x00ff0000) >> 16, ((int)EATA_base)+HA_WDMAADDR+2);
  5825. +  outb((add & 0xff000000) >> 24, ((int)EATA_base)+HA_WDMAADDR+3);
  5826. +}
  5827. +
  5828. +const char *eata_info(void)
  5829. +{
  5830. +  static char *information="EATA SCSI Controller Driver\n";
  5831. +  return information;
  5832. +}
  5833. +
  5834. +inline int eata_reverse(int arg)
  5835. +{
  5836. +  int result;
  5837. +  result=(arg & 0xff000000) >> 24;
  5838. +  result|=((arg & 0x00ff0000) >> 8);
  5839. +  result|=((arg & 0x0000ff00) << 8);
  5840. +  result|=((arg & 0x000000ff) << 24);
  5841. +  return result;
  5842. +}
  5843. +
  5844. +int eata_queue(Scsi_Cmnd *cmd, void *(done)(struct scsi_cmnd *))
  5845. +{
  5846. +  int i=64,status;
  5847. +  struct eata_sp  *sp;
  5848. +  struct eata_ccb *cp;
  5849. +  struct eata_sg_list *sglist;
  5850. +  struct scatterlist *sl;
  5851. +
  5852. +        /* Search for an open command slot.  If i==64, then
  5853. +       there must be none free.  If this is the case, keep
  5854. +       trying because an interrupt will eventually happen
  5855. +       that will free up a slot. 
  5856. +    
  5857. +       This is assuming that interrupts are enabled when this
  5858. +       routine is called.  Is that true? 
  5859. +        */
  5860. +
  5861. +  i=64;
  5862. +  while(i==64) for(i=0; i<64 && outstanding[i].used; i++);
  5863. +  cli();
  5864. +  outstanding[i].used=1; /* Claim it    */
  5865. +  cmd->scsi_done=done;
  5866. +  sp=&outstanding[i].sp;
  5867. +  cp=&outstanding[i].cp;
  5868. +  sp->cont_stat=0; /* Clear this out because the interrupt handler
  5869. +              checks it. Note that I clear it BEFORE I set the
  5870. +              pointer in outstanding[] */
  5871. +  outstanding[i].cmd=cmd;
  5872. +  sti();
  5873. +  if(cmd->cmnd[0]==WRITE_6 || cmd->cmnd[0]==WRITE_10)
  5874. +    cp->cp_option.Byte=HA_DATA_OUT;                       /* Output mode */
  5875. +  else
  5876. +    cp->cp_option.Byte=HA_DATA_IN;                        /* Input mode  */
  5877. +  if(cmd->use_sg) {
  5878. +    cp->cp_option.Byte|=HA_SC_GA;                         /* SG mode     */
  5879. +    sglist=(struct eata_sg_list *)scsi_malloc(512);       /* Max needed 64 */
  5880. +    if(!sglist) 
  5881. +      {
  5882. +    panic("eata_queue: scsi_malloc failed. No memory for SG list\n");
  5883. +      }
  5884. +    cmd->host_scribble=(unsigned char *)sglist;
  5885. +    sl=(struct scatterlist *)cmd->request_buffer;
  5886. +    for(i=0; i<cmd->use_sg; i++, sglist++, sl++)
  5887. +      {
  5888. +    sglist->data=(void *)eata_reverse((int )sl->address);
  5889. +    sglist->len=eata_reverse((int )sl->length);
  5890. +      }
  5891. +    sglist=(struct eata_sg_list *)cmd->host_scribble;
  5892. +  }
  5893. +  cp->reqlen=38;
  5894. +  cp->cp_option2.Byte=0x00;
  5895. +  cp->cp_id=cmd->target;
  5896. +  cp->cp_msg0=cmd->lun+HA_IDENTIFY_MSG+HA_G_DISCO_RECO; /*Those bits should always be set*/
  5897. +  cp->cp_msg1=cp->cp_msg2=cp->cp_msg3=0;
  5898. +  memset(cp->cp_cdb, 0, 12);
  5899. +  memcpy(cp->cp_cdb, cmd->cmnd, COMMAND_SIZE(*cmd->cmnd));
  5900. +  if(cmd->use_sg)
  5901. +    {
  5902. +      *((int *)cp->cp_dataDMA)=eata_reverse((int )sglist);
  5903. +      *((int *)cp->cp_datalen)=eata_reverse(cmd->use_sg*8);
  5904. +    }
  5905. +  else
  5906. +    {
  5907. +      *((int *)cp->cp_datalen)=eata_reverse(cmd->request_bufflen);
  5908. +      *((int *)cp->cp_dataDMA)=eata_reverse((int )cmd->request_buffer);
  5909. +    }
  5910. +  *((int *)cp->cp_statDMA)=eata_reverse((int )sp);
  5911. +  *((int *)cp->cp_viraddr)=i;      
  5912. +  DBG(DBG_QUEUE,printk("EATA_QUEUE pos: %d, com: %x, SG: %d\n",i,cmd->cmnd[0],
  5913. +               cmd->use_sg));
  5914. +  status=inb(((int)EATA_base)+HA_RSTATUS);
  5915. +  while(status & HA_SBSY) status=inb(((int)EATA_base)+HA_RSTATUS);
  5916. +  expecting_ints=EXP_RETURN;
  5917. +  eata_set_dma_address((int )cp);
  5918. +  outb(EATA_CMD_DMA_SEND_CP, ((int)EATA_base)+HA_WCOMMAND); /* Let 'er rip */
  5919. +  return(0);
  5920. +}
  5921. +
  5922. +static volatile int internal_done_flag = 0;
  5923. +static volatile int internal_done_errcode = 0;
  5924. +
  5925. +static void internal_done(Scsi_Cmnd * SCpnt)
  5926. +{
  5927. +    internal_done_errcode = SCpnt->result;
  5928. +    ++internal_done_flag;
  5929. +}
  5930. +
  5931. +int eata_command(Scsi_Cmnd *SCpnt)
  5932. +{
  5933. +
  5934. +  DBG(DBG_FUNC,printk("eata_command: calling eata_queue\n"));
  5935. +
  5936. +  eata_queue(SCpnt, internal_done);
  5937. +  
  5938. +  while (!internal_done_flag);
  5939. +  internal_done_flag = 0;
  5940. +  return internal_done_errcode;
  5941. +}
  5942. +
  5943. +int eata_abort(Scsi_Cmnd *cmd)
  5944. +{
  5945. +  int i;
  5946. +
  5947. +  /* Just act like we did something */
  5948. +  DBG(DBG_ABNORM,printk("eata_abort()\n"));
  5949. +  DELAY(200);
  5950. +  /*
  5951. +  eata_reset(cmd);
  5952. +  */
  5953. +  
  5954. +  for(i=0; i<64; i++) 
  5955. +    if((outstanding[i].cmd==cmd)&& outstanding[i].used)
  5956. +      return(SCSI_ABORT_BUSY);
  5957. +  return(SCSI_ABORT_NOT_RUNNING); /*SNOOZE*/
  5958. +}
  5959. +
  5960. +int eata_reset(Scsi_Cmnd *cmd)
  5961. +{
  5962. +  int i;
  5963. +  long time;
  5964. +  DBG(DBG_ABNORM,printk("eata_reset()\n"));
  5965. +  DELAY(200);
  5966. +  outb(EATA_CMD_RESET, ((int)EATA_base)+HA_WCOMMAND);
  5967. +/*  if(cmd)
  5968. +    cmd->flags|=NEEDS_JUMPSTART;                                         
  5969. +*/  
  5970. +  time=jiffies+75;
  5971. +  while(time>jiffies);
  5972. +  for(i=0; i<64; i++) outstanding[i].used=0;
  5973. +  return(SCSI_RESET_WAKEUP);
  5974. +}
  5975. +
  5976. +int eata_biosparam(Scsi_Disk * disk, int dev, int geo[])
  5977. +{
  5978. +  int id;
  5979. +  int size = disk->capacity;
  5980. +  
  5981. +  id=MINOR(dev);
  5982. +  if (id) id>>=4;
  5983. +
  5984. +  DBG(DBG_PROBE,printk("\nSize: %d, Device: %x, id: %x\n\n",size,dev,id));
  5985. +  
  5986. +  if(geometry.drv[0].id==id){
  5987. +    geo[0]=geometry.drv[0].heads;
  5988. +    geo[1]=geometry.drv[0].sectors;
  5989. +    geo[2]=geometry.drv[0].cylinder;
  5990. +  }else if(geometry.drv[1].id==id){
  5991. +    geo[0]=geometry.drv[1].heads;
  5992. +    geo[1]=geometry.drv[1].sectors;
  5993. +    geo[2]=geometry.drv[1].cylinder;
  5994. +  }else{
  5995. +    if(size<0x200000){
  5996. +      geo[0]=64;
  5997. +      geo[1]=32;
  5998. +    }else if(size<0x400000){
  5999. +      geo[0]=65;
  6000. +      geo[1]=63;
  6001. +    }else if(size<0x800000){
  6002. +      geo[0]=128;
  6003. +      geo[1]=63;
  6004. +    }else{
  6005. +      geo[0]=255;
  6006. +      geo[1]=63;
  6007. +    }    
  6008. +    geo[2]=size/(geo[0]*geo[1]);
  6009. +  }
  6010. +  return(0);
  6011. +}
  6012. +
  6013. +int get_conf_DMA(struct eata_register *base,struct get_conf *buf)
  6014. +{
  6015. +   long i;
  6016. +  
  6017. +  inb(((int)base)+HA_RSTATUS);               /* Clear any pending conditions */
  6018. + 
  6019. +  i=jiffies;
  6020. +  expecting_ints=EXP_NORMAL;
  6021. +  eata_int_happened=0;
  6022. +
  6023. +  outb((unchar)((long)(buf)>>24),(int)base+HA_WDMAADDR+3);/*get config of    */
  6024. +  outb((unchar)((long)(buf)>>16),(int)base+HA_WDMAADDR+2);/*poss. controllers*/
  6025. +  outb((unchar)((long)(buf)>>8), (int)base+HA_WDMAADDR+1);
  6026. +  outb((unchar)((long)(buf)),    (int)base+HA_WDMAADDR); 
  6027. +  outb(EATA_CMD_DMA_READ_CONFIG, (int)base+HA_WCOMMAND);  /* set opcode      */
  6028. +
  6029. +  while(!eata_int_happened && jiffies<i+200);             /* wait for 2 sec. */
  6030. +  expecting_ints=EXP_NOTHING;
  6031. +
  6032. +  if(!eata_int_happened){
  6033. +    printk("eata.c get_conf_DMA: Controller timeout\n");
  6034. +    return (0);
  6035. +  }
  6036. +  
  6037. +  DBG(DBG_PROBE,printk("\nSignature: %c %c %c %c \n",(char)buf->gco_sig[0],
  6038. +           (char)buf->gco_sig[1],(char)buf->gco_sig[2],(char)buf->gco_sig[3]));
  6039. +  if((buf->gco_sig[0]=='E')&&(buf->gco_sig[1]== 'A')
  6040. +       &&(buf->gco_sig[2]== 'T')&&(buf->gco_sig[3]== 'A')) { 
  6041. +    DBG(DBG_PROBE,printk("EATA Controller found at %x EATA Level: %x\n",
  6042. +            (unsigned int) base,(unsigned int)(buf->gco_version>>4)));
  6043. +    return(1);
  6044. +  }
  6045. +  return(0);
  6046. +}
  6047. +
  6048. +long find_EISA(int flag, struct get_conf *buf)
  6049. +{
  6050. +/* 
  6051. +   Is there anyone using more than 2 controllers
  6052. +   at the same time ? ie. more than one secondary ?
  6053. +   I don't think so.
  6054. +*/
  6055. +  struct eata_register *base;
  6056. +  int i;
  6057. +  unsigned char pal1,pal2,pal3,*p;
  6058. +
  6059. +  for(i=0; i<MAXEISA;i++){
  6060. +    if(EISAbases[i]){                      /* Still a possibility ?          */
  6061. +      base=(void *)0x1c88+(i*0x1000);
  6062. +      p=(char*)base;
  6063. +      pal1=*(p-8);
  6064. +      pal2=*(p-7);
  6065. +      pal3=*(p-6);
  6066. +      if(((pal1==0x12)&&(pal2==0x14))||    /* Check for id tags              */
  6067. +     ((pal1==0x38)&&(pal2==0xa3)&&(pal3==0x82))||
  6068. +     ((pal1==0x5d)&&(pal2==0xc3)&&(pal3==0x90))||        /* SCIII PM2022 */
  6069. +     ((pal1==0x06)&&(pal2==0x94)&&(pal3==0x24)))
  6070. +    if(get_conf_DMA(base,buf)){
  6071. +      if((!buf->bit2.SECOND)&&(buf->bit2.IRQ)&&(flag==-1)){
  6072. +                                       /* We just found a primary EISA   */
  6073. +        ISAbases[0]=0;                 /* so there is no prim. ISA cont. */
  6074. +        EISAbases[i]=0;                /* and we don't need to look for  */
  6075. +        return((long)base);            /* a sec. EISA controller here    */
  6076. +      }
  6077. +      else if((buf->bit2.SECOND)&&(buf->bit2.IRQ)&&(!flag)){ 
  6078. +                                       /* We've found a EISA secondary   */
  6079. +        ISAbases[1]=0;                 /* so there is no sec. ISA cont.  */
  6080. +        EISAbases[i]=0;
  6081. +        return((long)base);
  6082. +      }
  6083. +      else EISAbases[i]=0;
  6084. +    }
  6085. +    }
  6086. +  }
  6087. +  return(0l);                              /* Nothing found  :-(             */
  6088. +}
  6089. +
  6090. +long find_ISA(struct eata_register *base, struct get_conf *buf)
  6091. +{
  6092. +  int i,l;
  6093. +  long ret;
  6094. +
  6095. +  ret=0;
  6096. +  if(!base){
  6097. +    for (l=1;l<=MAXISA;l++){
  6098. +      if(ISAbases[l]){
  6099. +    i=get_conf_DMA(base,buf);
  6100. +    if (!i) ISAbases[l]=0;
  6101. +    else{
  6102. +      ret=(int)base;
  6103. +      break;
  6104. +    }
  6105. +      }
  6106. +    }
  6107. +  }else{
  6108. +    i=get_conf_DMA(base, buf);
  6109. +    if((i==1)&&((((long)base==0x1F0l)&&!buf->bit2.SECOND)
  6110. +             ||(((long)base!=0x1F0l)&&buf->bit2.SECOND))) 
  6111. +      ret=(long)base;
  6112. +    else ret=0;
  6113. +  }
  6114. +  return(ret);
  6115. +}
  6116. +
  6117. +int ECS_emulation_sense(long base,int drive)
  6118. +{
  6119. + /*
  6120. +     I'm not sure what's going wrong here, because now I have 
  6121. +     documentation of the ECS command set but still I don't 
  6122. +     get it to work, I don't get a reponse from the 
  6123. +     controller (Ready + Seek complete...) :-(
  6124. + */
  6125. +  int x,ret;
  6126. +  struct emul_sense *p;
  6127. +  char buff[256];
  6128. + /* long time;*/
  6129. +
  6130. +  ret=0;
  6131. +
  6132. +  while(inb_p(base+HA_RSTATUS)&HA_SBSY);      /* Waiting to get not busy */
  6133. +
  6134. +  expecting_ints=EXP_NORMAL;
  6135. +  eata_int_happened=0;
  6136. +
  6137. +  x=drive<<5;
  6138. +  outb(base+1,0);
  6139. +  outb(base+2,0);
  6140. +  outb(base+3,255);
  6141. +  outb(base+4,0);
  6142. +  outb(base+5,0);
  6143. +  outb(base+HA_WCOMMAND-1,x);
  6144. +  outb(base+HA_WCOMMAND,ECS_EMULATE_SENSE);
  6145. +
  6146. +  DBG(DBG_WINTR,printk("ECS: Waiting for interrupt\n"));
  6147. +
  6148. +/* while(!eata_int_happened); */                /* wait for interrupt  */
  6149. +
  6150. +  expecting_ints=EXP_NOTHING;
  6151. +  while(!((x=inb_p(base+HA_RSTATUS))&HA_SDRQ)){
  6152. +    DBG(DBG_WINTR,printk("Controller status %x\n",x));
  6153. +    DELAY(50);
  6154. +  }
  6155. +  insw(base+HA_RDATA,buff,256);             /* Get the Data and    */
  6156. +  while(inb(base+HA_RSTATUS)&HA_SDRQ)       /* throw away the rest */
  6157. +    inb(base+HA_RDATA);
  6158. +  p=(struct emul_sense *)buff;
  6159. +  geometry.drv[drive].heads=p->Heads;
  6160. +  geometry.drv[drive].sectors=p->Sectors;
  6161. +  geometry.drv[drive].cylinder=(p->Cyls[0]<<8)+p->Cyls[1];
  6162. +  if(p->lunmap[drive]&0x80)
  6163. +    geometry.drv[drive].trans=0;
  6164. +  if(drive==0){
  6165. +    if(p->lunmap[2]&0x80) ret=0;
  6166. +    else ret=1;
  6167. +    geometry.drv[drive].id=p->lunmap[0];
  6168. +    geometry.drv[drive].lun=p->lunmap[1];
  6169. +  } else if(drive==1){
  6170. +    ret=1;
  6171. +    geometry.drv[drive].id=p->lunmap[2];
  6172. +    geometry.drv[drive].lun=p->lunmap[3];
  6173. +  }
  6174. +  return(ret);
  6175. +}
  6176. +
  6177. +void get_geo_trans(long base)
  6178. +{ 
  6179. +  outb(0x70,0x12);
  6180. +  if(inb(0x71)){
  6181. +    geometry.drv[0].trans=1;
  6182. +    if(ECS_emulation_sense(base,0)){
  6183. +      outb(0x70,0x12);
  6184. +      if(inb(0x71)&0xF){
  6185. +    geometry.drv[1].trans=1;
  6186. +    ECS_emulation_sense(base,1);
  6187. +      }
  6188. +    }
  6189. +  }
  6190. +}
  6191. +
  6192. +/* int eata_detect(int index) */
  6193. +int eata_detect(Scsi_Host_Template * tpnt)
  6194. +{
  6195. +  struct get_conf gc;
  6196. +  int i;
  6197. +  int err;
  6198. +  long base;
  6199. +  long time;
  6200. +  unsigned int irqlist[16]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
  6201. +
  6202. +  geometry.drv[0].trans=geometry.drv[1].trans=0; 
  6203. +  base=0;
  6204. +  err=0;
  6205. +
  6206. +  
  6207. +  for(i=0;i<16;i++)                        /* Here we grab every available IRQ    */
  6208. +    if(!request_irq(i,eata_int_handler,SA_INTERRUPT,"EATA"))/* until we know which one we  */
  6209. +      irqlist[i]=1;                        /* will need                   */
  6210. +
  6211. +
  6212. +  base=find_EISA(-1,&gc);                  /* Check for primary EISA HA */
  6213. +  if(base) ISAbases[0]=0; /* If found, there can't be an ISA prim. here */
  6214. +  else base=find_ISA((void *)0x1F0,&gc);   /* Check for primary ISA HA  */
  6215. +  if (!base) {                             /* no primary found          */
  6216. +    base=find_EISA(0,&gc);                 /* Check for secondary EISA  */
  6217. +    if (!base) base=find_ISA((void *)0,&gc); 
  6218. +    if (!base) {                           /* No controller fould :-(   */
  6219. +      for(i=0;i<16;i++)                    /* release all interrupts    */ 
  6220. +    if(irqlist[i]){
  6221. +      free_irq(i);
  6222. +      irqlist[i]=0;
  6223. +    }
  6224. +      return(0);
  6225. +    }
  6226. +  }
  6227. +/*  else get_geo_trans(base); */           /* set emulation parameters  */
  6228. +
  6229. +  else if(IDE_EMULATION){                  /* Unfortionally,we have to  */
  6230. +    geometry.drv[0].heads=HEADS0;          /* hardcode the drive geometry */
  6231. +    geometry.drv[0].sectors=SECTORS0;      /* into the driver for now   */
  6232. +    geometry.drv[0].cylinder=CYLINDER0;
  6233. +    geometry.drv[0].id=ID0;
  6234. +    geometry.drv[1].heads=HEADS1;
  6235. +    geometry.drv[1].sectors=SECTORS1;
  6236. +    geometry.drv[1].cylinder=CYLINDER1;
  6237. +    geometry.drv[1].id=ID1;
  6238. +  } else {
  6239. +    geometry.drv[0].id=-1;
  6240. +    geometry.drv[1].id=-1;
  6241. +  }
  6242. +
  6243. +  dma_channel=(8-gc.bit2.DRQX)&7;          /* Which DMA channel ?      */
  6244. +  if (!gc.bit1.DRQ_valid) {
  6245. +    DBG(DBG_PROBE,printk("EISA EATA controller found.\n"));
  6246. +    err=0;
  6247. +  }else if (request_dma(dma_channel,"DPT_EATA")) {
  6248. +    printk("Unable to allocate DMA channel %d for EATA controller.\n",
  6249. +       dma_channel);
  6250. +    err=1;
  6251. +  }
  6252. +
  6253. +  for(i=0;i<16;i++)                         /* Now we can release all  */
  6254. +    if(irqlist[i] && (i!=gc.bit2.IRQ)){     /* unused interrupts again */
  6255. +      free_irq(i);
  6256. +      irqlist[i]=0;
  6257. +    }
  6258. +  if (err) {
  6259. +    free_irq((unsigned int)gc.bit2.IRQ);
  6260. +    return(0);
  6261. +  }
  6262. +  if(!irqlist[(unsigned int) gc.bit2.IRQ]){
  6263. +    printk("eata_detect: Couldn't alloc. IRQ%d!\n",(unsigned int)gc.bit2.IRQ);
  6264. +    return(0);
  6265. +  }
  6266. +
  6267. +  tpnt->can_queue=((int)(gc.gco_queuesiz[0])<<8) + ((int)(gc.gco_queuesiz[1]));
  6268. +  DBG(DBG_PROBE, printk("Can queue %d commands \n",tpnt->can_queue));
  6269. +  if(tpnt->can_queue>64)                 /* This is only temporarily in here */
  6270. +    tpnt->can_queue=64;                   /* We'll allocate the needed space */
  6271. +
  6272. +  tpnt->this_id=(int)(xscsi2int(gc.gco_HAaddress));
  6273. +  tpnt->sg_tablesize=((short unsigned int)(gc.gco_SGsiz[0])<<8)
  6274. +                                      +((short unsigned int)(gc.gco_SGsiz[1]));
  6275. +  tpnt->cmd_per_lun=1;                    
  6276. +                               
  6277. +  if (!gc.bit1.DRQ_valid) tpnt->unchecked_isa_dma=0; /* This is an EISA contr.*/
  6278. +  else tpnt->unchecked_isa_dma=1;                    /* Here we have only ISA */
  6279. +
  6280. +  snarf_region(base, 9);
  6281. +  scsi_register(tpnt,0);
  6282. +  printk("EATA - DMA driver version: %d.%d%s\n",VER_MAJOR,VER_MINOR,VER_SUB);
  6283. +  printk("EATA compliant controller detected. EATA Level %x, SCSI ID is %d \n",
  6284. +            (unsigned int)(gc.gco_version>>4),tpnt->this_id);
  6285. +  printk("Using IRQ %d, DMA channel %d, at %lx\n",(unsigned int)gc.bit2.IRQ,
  6286. +            dma_channel,base); 
  6287. +  time=jiffies;
  6288. +  while(jiffies<time+300);                               /* Let 'em read 8-) */
  6289. +  for(i=0; i<64; i++) outstanding[i].used=0;             /* Do some setup    */
  6290. +  EATA_base=(void *)base;
  6291. +  return(1);
  6292. +
  6293. +}  
  6294. +  
  6295. diff -u --recursive --new-file linux-1.1.58/drivers/scsi/eata.h linux/drivers/scsi/eata.h
  6296. --- linux-1.1.58/drivers/scsi/eata.h    Wed Dec 31 18:00:00 1969
  6297. +++ linux/drivers/scsi/eata.h    Wed Oct 26 23:02:02 1994
  6298. @@ -0,0 +1,349 @@
  6299. +/***************************************************
  6300. + *  Header file for eata.c Linux EATA SCSI driver  *
  6301. + *  currently contains lots of unused stuff        *
  6302. + *  (c) 1993,94 Michael Neuffer                    *
  6303. + ***************************************************
  6304. + * last change: 20.09.94                           *
  6305. + ***************************************************/
  6306. +
  6307. +
  6308. +#ifndef _EATA_H
  6309. +#define _EATA_H
  6310. +
  6311. +#include "../block/blk.h"
  6312. +#include "scsi.h"
  6313. +#include "hosts.h"
  6314. +
  6315. +
  6316. +#define VER_MAJOR 0
  6317. +#define VER_MINOR 3
  6318. +#define VER_SUB   "a"
  6319. +
  6320. +/************************************************************************
  6321. + * Here you can configure your drives that are running in IDE           *
  6322. + * emulation mode                                                       *
  6323. + * If all your drives are running in native mode (not emulated), set    *
  6324. + * IDE_EMULATION to 0                                                   * 
  6325. + * If you have only one drive (running in IDE emu. mode), set ID1 to -1 *
  6326. + ************************************************************************/
  6327. +#define IDE_EMULATION 1          /* Here are drives running in emu. mode   */
  6328. +
  6329. +#define ID0           0          /* SCSI ID of "IDE" drive mapped to C:    */
  6330. +                                 /* If you're not sure check your config
  6331. +                  * utility that came with your controller
  6332. +                  */
  6333. +#define HEADS0       13          /* Number of emulated heads of this drive */  
  6334. +#define SECTORS0     38          /* Number of emulated sectors             */ 
  6335. +#define CYLINDER0   719          /* Number of emulated cylinders           */
  6336. +   
  6337. +#define ID1           1          /* SCSI ID of "IDE" drive mapped to D:    */
  6338. +#define HEADS1       16          /* Number of emulated heads of this drive */ 
  6339. +#define SECTORS1     62          /* Number of emulated sectors             */
  6340. +#define CYLINDER1  1024          /* Number of emulated cylinders           */
  6341. +
  6342. +/************************************************************************
  6343. + * Debug options.                                                       * 
  6344. + * Enable DEBUG and whichever options you require.                      *
  6345. + ************************************************************************/
  6346. +#define DEBUG        0    /* Enable debug code.             */
  6347. +#define DBG_PROBE    1    /* Debug probe routines.         */
  6348. +#define    DBG_DUMP    1    /* Dump response to probes in hex.     */
  6349. +#define DBG_DELAY    0    /* Build in delays so debug messages can be
  6350. +                 * be read before they vanish of the top of
  6351. +                 * the screen!
  6352. +                 */
  6353. +#define DBG_FUNC    1    /* Trace function calls.         */
  6354. +#define DBG_TRAP    1    /* Trap errors from higher levels.    */
  6355. +#define DBG_QUEUE    1    /* Trace command queueing.         */
  6356. +#define DBG_INTR    0       /* Trace interrupt service routine.     */
  6357. +#define DBG_WINTR       1       /* Trace Wait for interrupt             */
  6358. +#define DBG_ABNORM    1    /* Debug abnormal actions (reset, abort)*/
  6359. +#define DBG_AHMON       0       /* Ahmon's special  (-;                 */  
  6360. +
  6361. +#if DEBUG
  6362. +static char dummy;
  6363. +#define DBG(x, y)    if ((x)) {y;} else dummy=0
  6364. +#else
  6365. +#define DBG(x, y)
  6366. +#endif
  6367. +
  6368. +#if DEBUG && DBG_DELAY
  6369. +#define DELAY(x)    if (1) { int i; i = jiffies + x; while (jiffies < i); } else dummy=0
  6370. +#else
  6371. +#define DELAY(x)    
  6372. +#endif
  6373. +
  6374. +
  6375. +#define EATA {                       \
  6376. +    NULL,                        \
  6377. +        "Generic EATA - DMA (rev. 2.0b) driver", \
  6378. +        eata_detect,                 \
  6379. +        NULL,                        \
  6380. +        eata_info,                   \
  6381. +        eata_command,                \
  6382. +        eata_queue,                  \
  6383. +        eata_abort,                  \
  6384. +        eata_reset,                  \
  6385. +        NULL, /* Slave attach */     \
  6386. +        eata_biosparam,              \
  6387. +        1,      /* Canqueue */       \
  6388. +        7,      /* this_id */        \
  6389. +        64,     /* sg_tablesize */   \
  6390. +        1,      /* cmd_per_lun */    \
  6391. +        0,      /* present */        \
  6392. +        0,      /* unchecked_isa_dma */\
  6393. +    ENABLE_CLUSTERING }
  6394. +
  6395. +int eata_detect(Scsi_Host_Template *);
  6396. +const char *eata_info(void);
  6397. +int eata_command(Scsi_Cmnd *);
  6398. +int eata_queue(Scsi_Cmnd *, void *(done)(struct scsi_cmnd *));
  6399. +int eata_abort(Scsi_Cmnd *);
  6400. +int eata_reset(Scsi_Cmnd *);
  6401. +int eata_biosparam(Disk *, int, int []);
  6402. +
  6403. +
  6404. +typedef unsigned char byte;
  6405. +
  6406. +/***********************************************
  6407. + *         EATA Register definitions           *
  6408. + ***********************************************/
  6409. +
  6410. +#define EATA_CMD_PIO_READ_CONFIG 0xf0
  6411. +#define EATA_CMD_PIO_SET_CONFIG  0xf1
  6412. +#define EATA_CMD_PIO_SEND_CP     0xf2
  6413. +#define EATA_CMD_PIO_RECEIVE_SP  0xf3
  6414. +#define EATA_CMD_PIO_TRUNC       0xf4
  6415. +#define EATA_CMD_RESET           0xf9
  6416. +
  6417. +#define EATA_CMD_DMA_READ_CONFIG 0xfd
  6418. +#define EATA_CMD_DMA_SET_CONFIG  0xfe
  6419. +#define EATA_CMD_DMA_SEND_CP     0xff
  6420. +
  6421. +#define ECS_EMULATE_SENSE        0xd4
  6422. +
  6423. +#define HA_WCOMMAND 0x07        /* command register offset   */
  6424. +#define HA_WDMAADDR 0x02        /* DMA address LSB offset    */  
  6425. +#define HA_RAUXSTAT 0x08        /* aux status register offset*/
  6426. +#define HA_RSTATUS  0x07        /* status register offset    */
  6427. +#define HA_RDATA    0x00        /* data register (16bit)     */
  6428. +
  6429. +#define HA_ABUSY    0x01        /* aux busy bit              */
  6430. +#define HA_AIRQ     0x02        /* aux IRQ pending bit       */
  6431. +#define HA_SERROR   0x01        /* pr. command ended in error*/
  6432. +#define HA_SMORE    0x02        /* more data soon to come    */
  6433. +#define HA_SCORR    0x04        /* data corrected            */
  6434. +#define HA_SDRQ     0x08        /* data request active       */
  6435. +#define HA_SSC      0x10        /* seek complete             */
  6436. +#define HA_SFAULT   0x20        /* write fault               */
  6437. +#define HA_SRDY     0x40        /* drive ready               */
  6438. +#define HA_SBSY     0x80        /* drive busy                */
  6439. +#define HA_SDRDY    HA_SSC+HA_SRDY+HA_SDRQ 
  6440. +
  6441. +struct reg_bit {        /* reading this one will clear the interrupt     */
  6442. +  byte error:1;     /* previous command ended in an error           */
  6443. +  byte more:1;      /* more DATA comming soon, poll BSY & DRQ (PIO) */
  6444. +  byte corr:1;      /* data read was successfully corrected with ECC*/
  6445. +  byte drq:1;       /* data request aktive  */     
  6446. +  byte sc:1;        /* seek complete        */
  6447. +  byte fault:1;     /* write fault          */
  6448. +  byte ready:1;     /* drive ready          */
  6449. +  byte busy:1;      /* controller busy      */
  6450. +};
  6451. +
  6452. +struct reg_abit {       /* reading this won't clear the interrupt */
  6453. +  byte abusy:1;     /* auxiliary busy                         */
  6454. +  byte irq:1;       /* set when drive interrupt is asserted   */
  6455. +  byte dummy:6;
  6456. +};
  6457. +
  6458. +struct eata_register {              /* EATA register set */
  6459. +  byte data_reg[2];         /* R, couldn't figure this one out          */
  6460. +  byte cp_addr[4];          /* W, CP address register                   */
  6461. +  union { 
  6462. +    byte command;                 /* W, command code: [read|set] conf, send CP*/
  6463. +    struct reg_bit status;    /* R, see register_bit1                     */
  6464. +    byte statusbyte;
  6465. +  } ovr;   
  6466. +  struct reg_abit aux_stat;     /* R, see register_bit2                       */
  6467. +};
  6468. +
  6469. +/**********************************************
  6470. + *  Other (command) definitions               *
  6471. + **********************************************/
  6472. +
  6473. +struct gco_bits1 {
  6474. +  byte OCS_enabled:1;            /* Overlap Command Support enabled      */
  6475. +  byte TAR_support:1;            /* SCSI Target Mode supported        */
  6476. +  byte TRNXFR:1;        /* Truncate Transfer Cmd not necessary    */
  6477. +                                /* Only used in PIO Mode         */
  6478. +  byte MORE_support:1;            /* MORE supported (only PIO Mode)     */
  6479. +  byte DMA_support:1;            /* DMA supported Driver uses only     */
  6480. +                            /* this mode                */
  6481. +  byte DRQ_valid:1;        /* DRQ value in Byte 30 is valid    */
  6482. +  byte ATA:1;                /* ATA device connected (no support)    */
  6483. +  byte HAA_valid:1;        /* Hostadapter Address is valid         */
  6484. +};
  6485. +
  6486. +struct gco_bits2 {
  6487. +  byte IRQ:4;                 /* IRQ used this HA            */
  6488. +  byte SECOND:1;              /* This is a secondary controller            */
  6489. +  byte IRQ_TR:1;              /* IRQ Trigger: 0=edge, 1=level            */
  6490. +  byte DRQX:2;                /* DRQ index, DRQ is 2comp of DRQX    */
  6491. +};
  6492. +
  6493. +struct get_conf {               /* Read Configuration Array  */
  6494. +  byte gco_len[4];            /* Should return 0x1c             */
  6495. +  byte gco_sig[4];            /* Signature MUST be "EATA"         */
  6496. +  byte gco_version;           /* upper nibble contains Version          */
  6497. +  struct gco_bits1 bit1;                
  6498. +  byte gco_cppadlen[2];          /* Number of pad bytes send after CD data */
  6499. +                              /* set to zero for DMA commands        */
  6500. +  byte gco_HAaddress[4];      /* SCSI ID of controller if SCSI device   */
  6501. +                              /* if not, zero is returned         */
  6502. +  byte gco_cplen[4];          /* CP length: number of valid cp bytes     */
  6503. +  byte gco_splen[4];          /* Number of bytes returned after            */ 
  6504. +                              /* Receive SP command            */
  6505. +  byte gco_queuesiz[2];          /* max number of queueable CPs        */
  6506. +  byte gco_dummy[2];
  6507. +  byte gco_SGsiz[2];          /* max number of SG table entries            */
  6508. +  struct gco_bits2 bit2;
  6509. +  byte gco_sync;              /* device at ID 7 tru 0 is running in     */
  6510. +                              /* synchronous mode                       */
  6511. +  byte gco_unused[480];
  6512. +};
  6513. +
  6514. +struct sco_bits {
  6515. +  byte EATA_disable:1;          /* Disable EATA interface :-(        */
  6516. +  byte OC_enable:1;          /* Enable overlapped commands        */
  6517. +  byte MPD_enable:1;          /* Enable sending of all Save, Restore    */
  6518. +                              /* and Modify Data Pointer Messages       */
  6519. +  byte TAR_enable:1;          /* Enable HA Target mode                       */
  6520. +}; 
  6521. +
  6522. +struct set_conf {          /* Set Configuration Array */
  6523. +  byte sco_trlen[2];          /* Number of bytes following this field    */
  6524. +  struct sco_bits bit;
  6525. +  byte sco_zero;              /* set this one to zero               */  
  6526. +  char   sco_unused[508];
  6527. +};
  6528. +
  6529. +#define HA_DATA_IN  0x80
  6530. +#define HA_DATA_OUT 0x40
  6531. +#define HA_SC_GA    0x08
  6532. +
  6533. +
  6534. +struct cp_bits {              /* Send Command Packet Bits           */
  6535. +  byte SCSI_Reset:1;          /* Cause a SCSI Bus reset on the cmd  */
  6536. +  byte HBA_Init:1;            /* Cause Controller to reInitialize   */
  6537. +  byte Auto_Req_Sen:1;        /* Do Auto Request Sense on errors    */
  6538. +  byte scatter:1;             /* Data Ptr points to a SG Packet     */
  6539. +  byte Resrvd:1;              /* RFU                                */
  6540. +  byte Interpret:1;           /* Interpret the SCSI cdb of own use  */
  6541. +  byte DataOut:1;             /* Data Out phase with command        */
  6542. +  byte DataIn:1;              /* Data In phase with command         */
  6543. +};
  6544. +
  6545. +struct cp_bits2 {
  6546. +  byte Phsunit:1;             /* physical unit on mirrored pair        */
  6547. +  byte Iat:1;                 /* inhibit address translation        */
  6548. +  byte HBA_Cin:1;             /* HBA Inhibit caching                */
  6549. +};
  6550. +
  6551. +struct eata_ccb {             /* Send Command Packet structure      */
  6552. +  union {
  6553. +    struct cp_bits bit;       /* CP Bits                */
  6554. +    byte Byte;
  6555. +  } cp_option;
  6556. +  byte reqlen;               /* Request Sense Length               */ 
  6557. +                              /* Valid if Auto_Req_Sen=1            */
  6558. +  byte unused[4];
  6559. +  union {
  6560. +    struct cp_bits2 bit;      /* Send command direct to physical unit   */   
  6561. +    byte Byte;
  6562. +  } cp_option2;
  6563. +  byte cp_id;                 /* SCSI Device ID of target       */ 
  6564. +  byte cp_msg0;               /* Message bytes 0-3              */
  6565. +  byte cp_msg1;
  6566. +  byte cp_msg2;
  6567. +  byte cp_msg3;
  6568. +  byte cp_cdb[12];              /* Command Descriptor Block       */
  6569. +  byte cp_datalen[4];           /* Data Transfer Length           */
  6570. +                              /* If scatter=1 len of sg package */
  6571. +  byte cp_viraddr[4];         /* Virtual address of CP          */
  6572. +  byte cp_dataDMA[4];           /* Data Address, if scatter=1     */
  6573. +                              /* address of scatter packet      */  
  6574. +  byte cp_statDMA[4];         /* address for Status Packet      */ 
  6575. +  byte cp_reqDMA[4];          /* Request Sense Address, used if */
  6576. +                              /* CP command ends with error     */
  6577. +};
  6578. +
  6579. +
  6580. +struct eata_sp
  6581. +{
  6582. +  byte cont_stat, scsi_stat, reserved[2];
  6583. +  byte residue_len[4], cp_id[4], msg[12];
  6584. +};
  6585. +
  6586. +struct eata_cmd_queue
  6587. +{
  6588. +  int used;
  6589. +  struct eata_sp  sp;
  6590. +  struct eata_ccb cp;
  6591. +  Scsi_Cmnd *cmd;
  6592. +};
  6593. +
  6594. +struct eata_sg_list
  6595. +{
  6596. +        void *data;
  6597. +        int len;
  6598. +};
  6599. +
  6600. +
  6601. +
  6602. +
  6603. +/* structure for max. 2 emulated drives */
  6604. +struct drive_geom_emul {
  6605. +  byte trans;                 /* translation flag 1=transl */
  6606. +  int  channel;               /* SCSI channel number       */
  6607. +  byte HBA;                   /* HBA number (prim/sec)     */
  6608. +  byte id;                    /* drive id                  */
  6609. +  byte lun;                   /* drive lun                 */
  6610. +  uint heads;                 /* number of heads           */
  6611. +  uint sectors;               /* number of sectors         */
  6612. +  uint cylinder;              /* number of cylinders       */
  6613. +};
  6614. +
  6615. +struct geom_emul {
  6616. +  int bios_drives;               /* number of emulated drives */
  6617. +  struct drive_geom_emul drv[2]; /* drive structures          */
  6618. +};
  6619. +
  6620. +struct emul_sense {
  6621. +  byte Byte0;
  6622. +  byte Cyls[2];
  6623. +  byte Heads;
  6624. +  byte Sectors;
  6625. +  byte padding;
  6626. +  byte drtype[2];
  6627. +  byte lunmap[8];
  6628. +};
  6629. +
  6630. +/**********************************************
  6631. + * Message definitions                        *
  6632. + **********************************************/
  6633. +#define HA_IDENTIFY_MSG 0x80       /* Sent identify message      */
  6634. +#define HA_G_DISCO_RECO 0x40       /* Grant disconnect privilege */
  6635. +
  6636. +/*********************************************
  6637. + * Misc. definitions                         *
  6638. + *********************************************/
  6639. +#define EXP_NOTHING 0
  6640. +#define EXP_RETURN  2
  6641. +#define EXP_NORMAL  1
  6642. +
  6643. +
  6644. +#define xscsi2int(up) ( (((long)(up)[0]) << 24) + (((long)(up)[1]) << 16) \
  6645. +                      + (((long)(up)[2]) <<  8) +  ((long)(up)[3]) )
  6646. +
  6647. +#endif /* _EATA_H */
  6648. diff -u --recursive --new-file linux-1.1.58/drivers/scsi/hosts.c linux/drivers/scsi/hosts.c
  6649. --- linux-1.1.58/drivers/scsi/hosts.c    Sat Sep 17 21:49:42 1994
  6650. +++ linux/drivers/scsi/hosts.c    Wed Oct 26 23:02:02 1994
  6651. @@ -39,10 +39,20 @@
  6652.  #include "aha1740.h"
  6653.  #endif
  6654.  
  6655. +#ifdef CONFIG_SCSI_AHA274X
  6656. +#include "aha274x.h"
  6657. +#endif
  6658. +
  6659. +
  6660. +
  6661.  #ifdef CONFIG_SCSI_BUSLOGIC
  6662.  #include "buslogic.h"
  6663.  #endif
  6664.  
  6665. +#ifdef CONFIG_SCSI_EATA            
  6666. +#include "eata.h"
  6667. +#endif
  6668. +
  6669.  #ifdef CONFIG_SCSI_FUTURE_DOMAIN
  6670.  #include "fdomain.h"
  6671.  #endif
  6672. @@ -131,6 +141,12 @@
  6673.  #endif
  6674.  #ifdef CONFIG_SCSI_AHA1740
  6675.      AHA1740,
  6676. +#endif
  6677. +#ifdef CONFIG_SCSI_AHA274X
  6678. +    AHA274X,
  6679. +#endif
  6680. +#ifdef CONFIG_SCSI_EATA 
  6681. +        EATA,
  6682.  #endif
  6683.  #ifdef CONFIG_SCSI_FUTURE_DOMAIN
  6684.      FDOMAIN_16X0,
  6685. diff -u --recursive --new-file linux-1.1.58/drivers/scsi/in2000.c linux/drivers/scsi/in2000.c
  6686. --- linux-1.1.58/drivers/scsi/in2000.c    Wed Dec 31 18:00:00 1969
  6687. +++ linux/drivers/scsi/in2000.c    Wed Oct 26 23:02:02 1994
  6688. @@ -0,0 +1,677 @@
  6689. +/*
  6690. + *  This file is in2000.c, written and
  6691. + *  Copyright (C) 1993  Brad McLean
  6692. + *    Last edit 07/19/94 WDE
  6693. + * Disclaimer:
  6694. + * Note:  This is ugly.  I know it, I wrote it, but my whole
  6695. + * focus was on getting the damn thing up and out quickly.
  6696. + * Future stuff that would be nice:  Command chaining, and
  6697. + * a local queue of commands would speed stuff up considerably.
  6698. + * Disconnection needs some supporting code.  All of this
  6699. + * is beyond the scope of what I wanted to address, but if you
  6700. + * have time and patience, more power to you.
  6701. + * Also, there are some constants scattered throughout that
  6702. + * should have defines, and I should have built functions to
  6703. + * address the registers on the WD chip.
  6704. + * Oh well, I'm out of time for this project.
  6705. + * The one good thing to be said is that you can use the card.
  6706. + */
  6707. +
  6708. +/*
  6709. + * This module was updated by Shaun Savage first on 5-13-93
  6710. + * At that time the write was fixed, irq detection, and some
  6711. + * timing stuff.  since that time other problems were fixed.
  6712. + * On 7-20-93 this file was updated for patch level 11
  6713. + * There are still problems with it but it work on 95% of
  6714. + * the machines.  There are still problems with it working with
  6715. + * IDE drives, as swap drive and HD that support reselection.
  6716. + * But for most people it will work.
  6717. + */
  6718. +/* More changes by Bill Earnest, wde@aluxpo.att.com
  6719. + * through 4/07/94. Includes rewrites of FIFO routines,
  6720. + * length-limited commands to make swap partitions work.
  6721. + * Merged the changes released by Larry Doolittle, based on input
  6722. + * from Jon Luckey, Roger Sunshine, John Shifflett. The FAST_FIFO
  6723. + * doesn't work for me. Scatter-gather code from Eric. The change to
  6724. + * an IF stmt. in the interrupt routine finally made it stable.
  6725. + * Limiting swap request size patch to ll_rw_blk.c not needed now.
  6726. + * Please ignore the clutter of debug stmts., pretty can come later.
  6727. + */
  6728. +/* Merged code from Matt Postiff improving the auto-sense validation
  6729. + * for all I/O addresses. Some reports of problems still come in, but
  6730. + * have been unable to reproduce or localize the cause. Some are from
  6731. + * LUN > 0 problems, but that is not host specific. Now 6/6/94.
  6732. + */
  6733. +/* Changes for 1.1.28 kernel made 7/19/94, code not affected. (WDE)
  6734. + */
  6735. +
  6736. +#include <linux/kernel.h>
  6737. +#include <linux/head.h>
  6738. +#include <linux/types.h>
  6739. +#include <linux/string.h>
  6740. +
  6741. +#include <linux/sched.h>
  6742. +#include <asm/dma.h>
  6743. +
  6744. +#include <asm/system.h>
  6745. +#include <asm/io.h>
  6746. +#include "../block/blk.h"
  6747. +#include "scsi.h"
  6748. +#include "hosts.h"
  6749. +
  6750. +#include "in2000.h"
  6751. +
  6752. +/*#define FAST_FIFO_IO*/
  6753. +
  6754. +/*#define DEBUG*/
  6755. +#ifdef DEBUG
  6756. +#define DEB(x) x
  6757. +#else
  6758. +#define DEB(x)
  6759. +#endif
  6760. +
  6761. +/* These functions are based on include/asm/io.h */
  6762. +#ifndef inw
  6763. +inline static unsigned short inw( unsigned short port )
  6764. +{
  6765. +   unsigned short _v;
  6766. +   
  6767. +   __asm__ volatile ("inw %1,%0"
  6768. +             :"=a" (_v):"d" ((unsigned short) port));
  6769. +   return _v;
  6770. +}
  6771. +#endif
  6772. +
  6773. +#ifndef outw
  6774. +inline static void outw( unsigned short value, unsigned short port )
  6775. +{
  6776. +   __asm__ volatile ("outw %0,%1"
  6777. +            : /* no outputs */
  6778. +            :"a" ((unsigned short) value),
  6779. +            "d" ((unsigned short) port));
  6780. +}
  6781. +#endif
  6782. +
  6783. +/* These functions are lifted from drivers/block/hd.c */
  6784. +
  6785. +#define port_read(port,buf,nr) \
  6786. +__asm__("cld;rep;insw": :"d" (port),"D" (buf),"c" (nr):"cx","di")
  6787. +
  6788. +#define port_write(port,buf,nr) \
  6789. +__asm__("cld;rep;outsw": :"d" (port),"S" (buf),"c" (nr):"cx","si")
  6790. +
  6791. +static unsigned int base;
  6792. +static unsigned int ficmsk;
  6793. +static unsigned char irq_level;
  6794. +static int in2000_datalen;
  6795. +static unsigned int in2000_nsegment;
  6796. +static unsigned int in2000_current_segment;
  6797. +static unsigned short *in2000_dataptr;
  6798. +static char    in2000_datawrite;
  6799. +struct scatterlist * in2000_scatter;
  6800. +static Scsi_Cmnd *in2000_SCptr = 0;
  6801. +
  6802. +void (*in2000_done)(Scsi_Cmnd *);
  6803. +
  6804. +int in2000_test_port(int index)
  6805. +{
  6806. +    static const int *bios_tab[] = {
  6807. +    (int *) 0xc8000, (int *) 0xd0000, (int *) 0xd8000 };
  6808. +    int    i;
  6809. +    char    tmp;
  6810. +
  6811. +    tmp = inb(INFLED);
  6812. +    /* First, see if the DIP switch values are valid */
  6813. +    /* The test of B7 may fail on some early boards, mine works. */
  6814. +    if (((~tmp & 0x3) != index ) || (tmp & 0x80) || !(tmp & 0x4) )
  6815. +        return 0;
  6816. +    printk("IN-2000 probe got dip setting of %02X\n", tmp);
  6817. +    tmp = inb(INVERS);
  6818. +/* Add some extra sanity checks here */
  6819. +    for(i=0; i < 3; i++)
  6820. +    if(*(bios_tab[i]+0x04) == 0x41564f4e) {
  6821. +      printk("IN-2000 probe found hdw. vers. %02x, BIOS at %06x\n",
  6822. +        tmp, (unsigned int)bios_tab[i]);
  6823. +        return 1;
  6824. +    }
  6825. +    printk("in2000 BIOS not found.\n");
  6826. +    return 0;
  6827. +}
  6828. +
  6829. +
  6830. +/*
  6831. + * retreive the current transaction counter from the WD
  6832. + */
  6833. +
  6834. +unsigned in2000_txcnt(void)
  6835. +{
  6836. +    unsigned total=0;
  6837. +
  6838. +    if(inb(INSTAT) & 0x20) return 0xffffff;    /* not readable now */
  6839. +    outb(TXCNTH,INSTAT);    /* then autoincrement */
  6840. +    total =  (inb(INDATA) & 0xff) << 16;
  6841. +    outb(TXCNTM,INSTAT);
  6842. +    total += (inb(INDATA) & 0xff) << 8;
  6843. +    outb(TXCNTL,INSTAT);
  6844. +    total += (inb(INDATA) & 0xff);
  6845. +    return total;
  6846. +}
  6847. +
  6848. +/*
  6849. + * Note: the FIFO is screwy, and has a counter granularity of 16 bytes, so
  6850. + * we have to reconcile the FIFO counter, the transaction byte count from the
  6851. + * WD chip, and of course, our desired transaction size.  It may look strange,
  6852. + * and could probably use improvement, but it works, for now.
  6853. + */
  6854. +
  6855. +void in2000_fifo_out(void)    /* uses FIFOCNTR */
  6856. +{
  6857. +    unsigned count, infcnt, txcnt;
  6858. +
  6859. +    infcnt = inb(INFCNT)& 0xfe;    /* FIFO counter */
  6860. +    do {
  6861. +    txcnt = in2000_txcnt();
  6862. +/*DEB(printk("FIw:%d %02x %d\n", in2000_datalen, infcnt, txcnt));*/
  6863. +    count = (infcnt << 3) - 32;    /* dont fill completely */
  6864. +    if ( count > in2000_datalen )
  6865. +        count = in2000_datalen;    /* limit to actual data on hand */
  6866. +    count >>= 1;        /* Words, not bytes */
  6867. +#ifdef FAST_FIFO_IO
  6868. +    if ( count ) {
  6869. +        port_write(INFIFO, in2000_dataptr, count);
  6870. +        in2000_datalen -= (count<<1);
  6871. +    }
  6872. +#else
  6873. +    while ( count-- )
  6874. +        {
  6875. +        outw(*in2000_dataptr++, INFIFO);
  6876. +        in2000_datalen -= 2;
  6877. +        }
  6878. +#endif
  6879. +    } while((in2000_datalen > 0) && ((infcnt = (inb(INFCNT)) & 0xfe) >= 0x20) );
  6880. +    /* If scatter-gather, go on to next segment */
  6881. +    if( !in2000_datalen && in2000_current_segment < in2000_nsegment)
  6882. +      {
  6883. +      in2000_scatter++;
  6884. +      in2000_current_segment++;
  6885. +      in2000_datalen = in2000_scatter->length;
  6886. +      in2000_dataptr = (unsigned short*)in2000_scatter->address;
  6887. +      }
  6888. +    if ( in2000_datalen <= 0 )
  6889. +    {
  6890. +    ficmsk = 0;
  6891. +    count = 32;    /* Always says to use this much flush */
  6892. +    while ( count-- )
  6893. +        outw(0, INFIFO);
  6894. +    outb(2, ININTR); /* Mask FIFO Interrupts when done */
  6895. +    }
  6896. +}
  6897. +
  6898. +void in2000_fifo_in(void)    /* uses FIFOCNTR */
  6899. +{
  6900. +    unsigned fic, count, count2;
  6901. +
  6902. +    count = inb(INFCNT) & 0xe1;
  6903. +    do{
  6904. +    count2 = count;
  6905. +    count = (fic = inb(INFCNT)) & 0xe1;
  6906. +    } while ( count != count2 );
  6907. +DEB(printk("FIir:%d %02x %08x\n", in2000_datalen,fic,(unsigned int )in2000_dataptr));
  6908. +    do {
  6909. +    count2 = in2000_txcnt();    /* bytes yet to come over SCSI bus */
  6910. +DEB(printk("FIr:%d %02x %08x %08x\n", in2000_datalen,fic,count2,(unsigned int)in2000_dataptr));
  6911. +    if(count2 > 65536) count2 = 0;
  6912. +    if(fic > 128) count = 1024;
  6913. +      else if(fic > 64) count = 512;
  6914. +        else if (fic > 32) count = 256;
  6915. +          else if ( count2 < in2000_datalen ) /* if drive has < what we want */
  6916. +            count = in2000_datalen - count2;    /* FIFO has the rest */
  6917. +    if ( count > in2000_datalen )    /* count2 is lesser of FIFO & rqst */
  6918. +        count2 = in2000_datalen >> 1;    /* converted to word count */
  6919. +    else
  6920. +        count2 = count >> 1;
  6921. +    count >>= 1;        /* also to words */
  6922. +    count -= count2;    /* extra left over in FIFO */
  6923. +#ifdef FAST_FIFO_IO
  6924. +    if ( count2 ) {
  6925. +        port_read(INFIFO, in2000_dataptr, count2);
  6926. +        in2000_datalen -= (count2<<1);
  6927. +    }
  6928. +#else
  6929. +    while ( count2-- )
  6930. +    {
  6931. +        *in2000_dataptr++ = inw(INFIFO);
  6932. +        in2000_datalen -=2;
  6933. +    }
  6934. +#endif
  6935. +    } while((in2000_datalen > 0) && (fic = inb(INFCNT)) );
  6936. +DEB(printk("FIer:%d %02x %08x\n", in2000_datalen,fic,(unsigned int )in2000_dataptr));
  6937. +/*    while ( count-- )
  6938. +        inw(INFIFO);*/    /* Throw away some extra stuff */
  6939. +    if( !in2000_datalen && in2000_current_segment < in2000_nsegment)
  6940. +      {
  6941. +      in2000_scatter++;
  6942. +      in2000_current_segment++;
  6943. +      in2000_datalen = in2000_scatter->length;
  6944. +      in2000_dataptr = (unsigned short*)in2000_scatter->address;
  6945. +      }
  6946. +    if ( ! in2000_datalen ){
  6947. +    outb(2, ININTR); /* Mask FIFO Interrupts when done */
  6948. +    ficmsk = 0;}
  6949. +}
  6950. +
  6951. +const char *in2000_info(void)
  6952. +{
  6953. +    static char buffer[] = "";
  6954. +    return buffer;
  6955. +}
  6956. +
  6957. +void in2000_intr_handle(int foo)
  6958. +{
  6959. +    int result=0;
  6960. +    unsigned int count,auxstatus,scsistatus,cmdphase,scsibyte;
  6961. +    int action=0;
  6962. +    Scsi_Cmnd *SCptr;
  6963. +
  6964. +  DEB(printk("INT:%d %02x %08x\n", in2000_datalen, inb(INFCNT),(unsigned int)in2000_dataptr));
  6965. +
  6966. +    if (( (ficmsk & (count = inb(INFCNT))) == 0xfe ) ||
  6967. +        ( (inb(INSTAT) & 0x8c) == 0x80))
  6968. +    {    /* FIFO interrupt or WD interrupt */
  6969. +       auxstatus = inb(INSTAT);    /* need to save now */
  6970. +       outb(SCSIST,INSTAT);
  6971. +       scsistatus = inb(INDATA); /* This clears the WD intrpt bit */
  6972. +       outb(TARGETU,INSTAT);    /* then autoincrement */
  6973. +       scsibyte = inb(INDATA);    /* Get the scsi status byte */
  6974. +       outb(CMDPHAS,INSTAT);
  6975. +       cmdphase = inb(INDATA);
  6976. +       DEB(printk("(int2000:%02x %02x %02x %02x %02x)\n",count,auxstatus,
  6977. +        scsistatus,cmdphase,scsibyte));
  6978. +
  6979. +    /* Why do we assume that we need to send more data here??? ERY */
  6980. +       if ( in2000_datalen && in2000_dataptr )    /* data xfer pending */
  6981. +           {
  6982. +           if ( in2000_datawrite )
  6983. +        in2000_fifo_out();
  6984. +        else
  6985. +        in2000_fifo_in();
  6986. +           } else ficmsk = 0;
  6987. +    if ( (auxstatus & 0x8c) == 0x80 )
  6988. +        {    /* There is a WD Chip interrupt & register read good */
  6989. +        outb(2,ININTR);    /* Disable fifo interrupts */
  6990. +        ficmsk = 0;
  6991. +        result = DID_OK << 16;
  6992. +        /* 16=Select & transfer complete, 85=got disconnect */
  6993. +        if ((scsistatus != 0x16) && (scsistatus != 0x85)
  6994. +        && (scsistatus != 0x42)){
  6995. +/*           printk("(WDi2000:%02x %02x %02x %02x %02x)\n",count,auxstatus,
  6996. +            scsistatus,cmdphase,scsibyte);*/
  6997. +/*        printk("QDAT:%d %08x %02x\n",
  6998. +        in2000_datalen,(unsigned int)in2000_dataptr,ficmsk);*/
  6999. +        ;
  7000. +        }
  7001. +        switch ( scsistatus & 0xf0 )
  7002. +            {
  7003. +            case    0x00:    /* Card Reset Completed */
  7004. +            action = 3;
  7005. +            break;
  7006. +            case    0x10:    /* Successful Command Completion */
  7007. +            if ( scsistatus & 0x8 )
  7008. +                    action = 1;
  7009. +            break;
  7010. +            case    0x20:    /* Command Paused or Aborted */
  7011. +            if ( (scsistatus & 0x8) )
  7012. +                    action = 1;
  7013. +            else if ( (scsistatus & 7) < 2 )
  7014. +                    action = 2;
  7015. +                 else
  7016. +                    result = DID_ABORT << 16;
  7017. +            break;
  7018. +            case    0x40:    /* Terminated early */
  7019. +            if ( scsistatus & 0x8 )
  7020. +                     action = 1;
  7021. +            else if ( (scsistatus & 7) > 2 )
  7022. +                     action = 2;
  7023. +                 else
  7024. +                    result = DID_TIME_OUT << 16;
  7025. +            break;
  7026. +            case    0x80:    /* Service Required from SCSI bus */
  7027. +            if ( scsistatus & 0x8 )
  7028. +                action = 1;
  7029. +            else
  7030. +                action = 2;
  7031. +            break;
  7032. +            }        /* end switch(scsistatus) */
  7033. +        outb(0,INFLED);
  7034. +        switch ( action )
  7035. +            {
  7036. +            case    0x02:    /* Issue an abort */
  7037. +            outb(COMMAND,INSTAT);
  7038. +            outb(1,INDATA);     /* ABORT COMMAND */
  7039. +            result = DID_ABORT << 16;
  7040. +            case    0x00:    /* Basically all done */
  7041. +            if ( ! in2000_SCptr )
  7042. +                return;
  7043. +            in2000_SCptr->result = result | scsibyte;
  7044. +            SCptr = in2000_SCptr;
  7045. +            in2000_SCptr = 0;
  7046. +            if ( in2000_done )
  7047. +                     (*in2000_done)(SCptr);
  7048. +            break;
  7049. +            case    0x01:    /* We need to reissue a command */
  7050. +            outb(CMDPHAS,INSTAT);
  7051. +            switch ( scsistatus & 7 )
  7052. +                {
  7053. +                case    0:    /* Data out phase */
  7054. +                    case    1:    /* Data in phase */
  7055. +                    case    4:    /* Unspec info out phase */
  7056. +                    case    5:    /* Unspec info in phase */
  7057. +                    case    6:    /* Message in phase */
  7058. +                    case    7:    /* Message in phase */
  7059. +                outb(0x41,INDATA); /* rdy to disconn */
  7060. +                break;
  7061. +                    case    2:    /* command phase */
  7062. +                outb(0x30,INDATA); /* rdy to send cmd bytes */
  7063. +                break;
  7064. +                    case    3:    /* status phase */
  7065. +                outb(0x45,INDATA); /* To go to status phase,*/
  7066. +                outb(TXCNTH,INSTAT); /* elim. data, autoinc */
  7067. +                outb(0,INDATA);
  7068. +                outb(0,INDATA);
  7069. +                outb(0,INDATA);
  7070. +                in2000_datalen = 0;
  7071. +                in2000_dataptr = 0;
  7072. +                break;
  7073. +                }    /* end switch(scsistatus) */
  7074. +            outb(COMMAND,INSTAT);
  7075. +            outb(8,INDATA);     /* RESTART THE COMMAND */
  7076. +            break;
  7077. +            case    0x03:    /* Finish up a Card Reset */
  7078. +            outb(TIMEOUT,INSTAT);    /* I got these values */
  7079. +                        /* by reverse Engineering */
  7080. +            outb(IN2000_TMOUT,INDATA); /* the Always' bios. */
  7081. +            outb(CONTROL,INSTAT);
  7082. +            outb(0,INDATA);
  7083. +            outb(SYNCTXR,INSTAT);
  7084. +            outb(0x40,INDATA);    /* async, 4 cyc xfer per. */
  7085. +            break;
  7086. +            }        /* end switch(action) */
  7087. +        }            /* end if auxstatus for WD int */
  7088. +    }            /* end while intrpt active */
  7089. +}
  7090. +
  7091. +int in2000_queuecommand(Scsi_Cmnd * SCpnt, void (*done)(Scsi_Cmnd *))
  7092. +{
  7093. +    unchar direction;
  7094. +    unchar *cmd = (unchar *) SCpnt->cmnd;
  7095. +    unchar target = SCpnt->target;
  7096. +    void *buff = SCpnt->request_buffer;
  7097. +    int bufflen = SCpnt->request_bufflen;
  7098. +    int timeout, size, loop;
  7099. +    int i;
  7100. +
  7101. +    /*
  7102. +     * This SCSI command has no data phase, but unfortunately the mid-level
  7103. +     * SCSI drivers ask for 256 bytes of data xfer.  Our card hangs if you
  7104. +     * do this, so we protect against it here.  It would be nice if the mid-
  7105. +     * level could be changed, but who knows if that would break other host
  7106. +     * adapter drivers.
  7107. +     */
  7108. +    if ( *cmd == TEST_UNIT_READY )
  7109. +    bufflen = 0;
  7110. +
  7111. +    /*
  7112. +     * What it looks like.  Boy did I get tired of reading it's output.
  7113. +     */
  7114. +    if (*cmd == READ_10 || *cmd == WRITE_10) {
  7115. +    i = xscsi2int((cmd+1));
  7116. +    } else if (*cmd == READ_6 || *cmd == WRITE_6) {
  7117. +    i = scsi2int((cmd+1));
  7118. +    } else {
  7119. +    i = -1;
  7120. +    }
  7121. +#ifdef DEBUG
  7122. +    printk("in2000qcmd: pos %d len %d ", i, bufflen);
  7123. +    printk("scsi cmd:");
  7124. +    for (i = 0; i < (COMMAND_SIZE(*cmd)); i++) printk("%02x ", cmd[i]);
  7125. +    printk("\n");
  7126. +#endif
  7127. +    direction = 1;    /* assume for most commands */
  7128. +    if (*cmd == WRITE_10 || *cmd == WRITE_6)
  7129. +    direction = 0;
  7130. +    size = COMMAND_SIZE(*cmd);    /* CDB length */ 
  7131. +    /*
  7132. +     * Setup our current pointers
  7133. +     * This is where you would allocate a control structure in a queue,
  7134. +     * If you were going to upgrade this to do multiple issue.
  7135. +     * Note that datalen and dataptr exist because we can change the
  7136. +     * values during the course of the operation, while managing the
  7137. +     * FIFO.
  7138. +     * Note the nasty little first clause.  In theory, the mid-level
  7139. +     * drivers should never hand us more than one command at a time,
  7140. +     * but just in case someone gets cute in configuring the driver,
  7141. +     * we'll protect them, although not very politely.
  7142. +     */
  7143. +    if ( in2000_SCptr )
  7144. +    {
  7145. +    printk("in2000_queue_command waiting for free command block!\n");
  7146. +    while ( in2000_SCptr );
  7147. +    }
  7148. +    for ( timeout = jiffies + 5; timeout > jiffies; )
  7149. +    {
  7150. +    if ( ! ( inb(INSTAT) & 0xb0 ) )
  7151. +    {
  7152. +        timeout = 0;
  7153. +        break;
  7154. +    }
  7155. +    else
  7156. +    {
  7157. +        inb(INSTAT);
  7158. +        outb(SCSIST,INSTAT);
  7159. +        inb(INDATA);
  7160. +        outb(TARGETU,INSTAT);     /* then autoinc */
  7161. +        inb(INDATA);
  7162. +        inb(INDATA);
  7163. +    }
  7164. +    }
  7165. +    if ( timeout )
  7166. +    {
  7167. +    printk("in2000_queue_command timeout!\n");
  7168. +    SCpnt->result = DID_TIME_OUT << 16;
  7169. +    (*done)(SCpnt);
  7170. +    return 1;
  7171. +    }
  7172. +    /* Added for scatter-gather support */
  7173. +    in2000_nsegment = SCpnt->use_sg;
  7174. +    in2000_current_segment = 0;
  7175. +    if(SCpnt->use_sg){
  7176. +      in2000_scatter = (struct scatterlist *) buff;
  7177. +      in2000_datalen = in2000_scatter->length;
  7178. +      in2000_dataptr = (unsigned short*)in2000_scatter->address;
  7179. +    } else {
  7180. +      in2000_scatter = NULL;
  7181. +      in2000_datalen = bufflen;
  7182. +      in2000_dataptr = (unsigned short*) buff;
  7183. +    };
  7184. +    in2000_done = done;
  7185. +    in2000_SCptr = SCpnt;
  7186. +    /*
  7187. +     * Write the CDB to the card, then the LUN, the length, and the target.
  7188. +     */
  7189. +    outb(TOTSECT, INSTAT);    /* start here then autoincrement */
  7190. +    for ( loop=0; loop < size; loop++ )
  7191. +    outb(cmd[loop],INDATA);
  7192. +    outb(TARGETU,INSTAT);
  7193. +    outb(SCpnt->lun & 7,INDATA);
  7194. +    SCpnt->host_scribble = NULL;
  7195. +    outb(TXCNTH,INSTAT);    /* then autoincrement */
  7196. +    outb(bufflen>>16,INDATA);
  7197. +    outb(bufflen>>8,INDATA);
  7198. +    outb(bufflen,INDATA);
  7199. +    outb(target&7,INDATA);
  7200. +    /*
  7201. +     * Set up the FIFO
  7202. +     */
  7203. +    cli();        /* so FIFO init waits till WD set */
  7204. +    outb(0,INFRST);
  7205. +    if ( direction == 1 )
  7206. +    {
  7207. +    in2000_datawrite = 0;
  7208. +    outb(0,INFWRT);
  7209. +    }
  7210. +    else
  7211. +    {
  7212. +    in2000_datawrite = 1;
  7213. +    for ( loop=16; --loop; ) /* preload the outgoing fifo */
  7214. +        {
  7215. +        outw(*in2000_dataptr++,INFIFO);
  7216. +        if(in2000_datalen > 0) in2000_datalen-=2;
  7217. +        }
  7218. +    }
  7219. +    ficmsk = 0xff;
  7220. +    /*
  7221. +     * Start it up
  7222. +     */
  7223. +    outb(CONTROL,INSTAT);    /* WD BUS Mode */
  7224. +    outb(0x4C,INDATA);
  7225. +    if ( in2000_datalen )        /* if data xfer cmd */
  7226. +        outb(0,ININTR);        /* Enable FIFO intrpt some boards? */
  7227. +    outb(COMMAND,INSTAT);
  7228. +    outb(0,INNLED);
  7229. +    outb(8,INDATA);        /* Select w/ATN & Transfer */
  7230. +    sti();            /* let the intrpt rip */
  7231. +    return 0;
  7232. +}
  7233. +
  7234. +static volatile int internal_done_flag = 0;
  7235. +static volatile int internal_done_errcode = 0;
  7236. +
  7237. +static void internal_done(Scsi_Cmnd * SCpnt)
  7238. +{
  7239. +    internal_done_errcode = SCpnt->result;
  7240. +    ++internal_done_flag;
  7241. +}
  7242. +
  7243. +int in2000_command(Scsi_Cmnd * SCpnt)
  7244. +{
  7245. +    in2000_queuecommand(SCpnt, internal_done);
  7246. +
  7247. +    while (!internal_done_flag);
  7248. +    internal_done_flag = 0;
  7249. +    return internal_done_errcode;
  7250. +}
  7251. +
  7252. +int in2000_detect(Scsi_Host_Template * tpnt)
  7253. +{
  7254. +/* Order chosen to reduce conflicts with some multi-port serial boards */
  7255. +    int base_tab[] = { 0x220,0x200,0x110,0x100 };
  7256. +    int int_tab[] = { 15,14,11,10 };
  7257. +    int loop, tmp;
  7258. +
  7259. +    DEB(printk("in2000_detect: \n"));
  7260. +    
  7261. +    for ( loop=0; loop < 4; loop++ )
  7262. +    {
  7263. +    base = base_tab[loop];
  7264. +    if ( in2000_test_port(loop))  break;
  7265. +    }
  7266. +    if ( loop == 4 )
  7267. +    return 0;
  7268. +
  7269. +  /* Read the dip switch values again for miscellaneous checking and
  7270. +     informative messages */
  7271. +  tmp = inb(INFLED);
  7272. +
  7273. +  /* Bit 2 tells us if interrupts are disabled */
  7274. +  if ( (tmp & 0x4) == 0 ) {
  7275. +    printk("The IN-2000 is not configured for interrupt operation\n");
  7276. +    printk("Change the DIP switch settings to enable interrupt operation\n");
  7277. +  }
  7278. +
  7279. +  /* Bit 6 tells us about floppy controller */
  7280. +  printk("IN-2000 probe found floppy controller on IN-2000 ");
  7281. +  if ( (tmp & 0x40) == 0)
  7282. +    printk("enabled\n");
  7283. +  else
  7284. +    printk("disabled\n");
  7285. +
  7286. +  /* Bit 5 tells us about synch/asynch mode */
  7287. +  printk("IN-2000 probe found IN-2000 in ");
  7288. +  if ( (tmp & 0x20) == 0)
  7289. +    printk("synchronous mode\n");
  7290. +  else
  7291. +    printk("asynchronous mode\n");
  7292. +
  7293. +    irq_level = int_tab [ ((~inb(INFLED)>>3)&0x3) ];
  7294. +
  7295. +    printk("Configuring IN2000 at IO:%x, IRQ %d"
  7296. +#ifdef FAST_FIFO_IO
  7297. +        " (using fast FIFO I/O code)"
  7298. +#endif
  7299. +        "\n",base, irq_level);
  7300. +
  7301. +    outb(2,ININTR);    /* Shut off the FIFO first, so it won't ask for data.*/
  7302. +    if (request_irq(irq_level, in2000_intr_handle, SA_INTERRUPT, "IN2000"))
  7303. +    {
  7304. +    printk("in2000_detect: Unable to allocate IRQ.\n");
  7305. +    return 0;
  7306. +    }
  7307. +    outb(0,INFWRT);    /* read mode so WD can intrpt */
  7308. +    outb(SCSIST,INSTAT);
  7309. +    inb(INDATA);    /* free status reg, clear WD intrpt */
  7310. +    outb(OWNID,INSTAT);
  7311. +    outb(0x7,INDATA);    /* we use addr 7 */
  7312. +    outb(COMMAND,INSTAT);
  7313. +    outb(0,INDATA);    /* do chip reset */
  7314. +    return 1;
  7315. +}
  7316. +
  7317. +int in2000_abort(Scsi_Cmnd * SCpnt, int i)
  7318. +{
  7319. +    DEB(printk("in2000_abort\n"));
  7320. +    /*
  7321. +     * Ask no stupid questions, just order the abort.
  7322. +     */
  7323. +    outb(COMMAND,INSTAT);
  7324. +    outb(1,INDATA);    /* Abort Command */
  7325. +    return 0;
  7326. +}
  7327. +
  7328. +static inline void delay( unsigned how_long )
  7329. +{
  7330. +    unsigned long time = jiffies + how_long;
  7331. +    while (jiffies < time) ;
  7332. +}
  7333. +
  7334. +int in2000_reset(Scsi_Cmnd * SCpnt)
  7335. +{
  7336. +    DEB(printk("in2000_reset called\n"));
  7337. +    /*
  7338. +     * Note: this is finished off by an incoming interrupt
  7339. +     */
  7340. +    outb(0,INFWRT);    /* read mode so WD can intrpt */
  7341. +    outb(SCSIST,INSTAT);
  7342. +    inb(INDATA);
  7343. +    outb(OWNID,INSTAT);
  7344. +    outb(0x7,INDATA);    /* ID=7,noadv, no parity, clk div=2 (8-10Mhz clk) */
  7345. +    outb(COMMAND,INSTAT);
  7346. +    outb(0,INDATA);    /* reset WD chip */
  7347. +    delay(2);
  7348. +#ifdef SCSI_RESET_PENDING
  7349. +    return SCSI_RESET_PENDING;
  7350. +#else
  7351. +    if(SCpnt) SCpnt->flags |= NEEDS_JUMPSTART;
  7352. +    return 0;
  7353. +#endif
  7354. +}
  7355. +
  7356. +int in2000_biosparam(int size, int dev, int* iinfo)
  7357. +    {
  7358. +    DEB(printk("in2000_biosparam\n"));
  7359. +    iinfo[0] = 64;
  7360. +    iinfo[1] = 32;
  7361. +    iinfo[2] = size >> 11;
  7362. +    return 0;
  7363. +    }
  7364. + 
  7365. +
  7366. diff -u --recursive --new-file linux-1.1.58/drivers/scsi/in2000.h linux/drivers/scsi/in2000.h
  7367. --- linux-1.1.58/drivers/scsi/in2000.h    Wed Dec 31 18:00:00 1969
  7368. +++ linux/drivers/scsi/in2000.h    Wed Oct 26 23:02:02 1994
  7369. @@ -0,0 +1,124 @@
  7370. +#ifndef _IN2000_H
  7371. +
  7372. +/* $Id: in2000.h,v 1.1 1994/03/14 06:27:38 root Exp root $
  7373. + *
  7374. + * Header file for the Always IN 2000 driver for Linux
  7375. + *
  7376. + */
  7377. +
  7378. +#include <linux/types.h>
  7379. +
  7380. +/* The IN-2000 is based on a WD33C93 */
  7381. +
  7382. +#define    INSTAT    (base + 0x0)    /* R: Auxiliary Status; W: register select */
  7383. +#define    INDATA    (base + 0x1)    /* R/W: Data port */
  7384. +#define    INFIFO    (base + 0x2)    /* R/W FIFO, Word access only */
  7385. +#define    INREST    (base + 0x3)    /* W: Reset everything */
  7386. +#define    INFCNT    (base + 0x4)    /* R: FIFO byte count */
  7387. +#define    INFRST    (base + 0x5)    /* W: Reset Fifo count and to write */
  7388. +#define    INFWRT    (base + 0x7)    /* W: Set FIFO to read */
  7389. +#define    INFLED    (base + 0x8)    /* W: Set LED; R: Dip Switch settings */
  7390. +#define    INNLED    (base + 0x9)    /* W: reset LED */
  7391. +#define    INVERS    (base + 0xa)    /* R: Read hw version, end-reset */
  7392. +#define    ININTR    (base + 0xc)    /* W: Interrupt Mask Port */
  7393. +#define G2CNTRL_HRDY    0x20        /* Sets HOST ready */
  7394. +
  7395. +/* WD33C93 defines */
  7396. +#define    OWNID    0
  7397. +#define    CONTROL    1
  7398. +#define    TIMEOUT    2
  7399. +#define    TOTSECT    3
  7400. +#define    TOTHEAD    4
  7401. +#define    TOTCYLH 5
  7402. +#define    TOTCYLL    6
  7403. +#define    LADRSHH    7
  7404. +#define    LADRSHL    8
  7405. +#define    LADRSLH    9
  7406. +#define    LADRSLL    10
  7407. +#define    SECTNUM    11
  7408. +#define    HEADNUM    12
  7409. +#define    CYLNUMH    13
  7410. +#define    CYLNUML    14
  7411. +#define    TARGETU    15
  7412. +#define    CMDPHAS    16
  7413. +#define    SYNCTXR    17
  7414. +#define    TXCNTH    18
  7415. +#define    TXCNTM    19
  7416. +#define TXCNTL    20
  7417. +#define DESTID    21
  7418. +#define    SRCID    22
  7419. +#define    SCSIST    23
  7420. +#define    COMMAND    24
  7421. +#define    WDDATA    25
  7422. +#define    AUXSTAT    31
  7423. +
  7424. +/* OWNID Register Bits */
  7425. +#define    OWN_EAF    0x08
  7426. +#define    OWN_EHP    0x10
  7427. +#define    OWN_FS0    0x40
  7428. +#define    OWN_FS1    0x80
  7429. +/* AUX Register Bits */
  7430. +#define    AUX_DBR    0
  7431. +#define    AUX_PE    1
  7432. +#define    AUX_CIP    0x10
  7433. +#define    AUX_BSY    0x20
  7434. +#define    AUX_LCI    0x40
  7435. +#define    AUX_INT    0x80
  7436. +
  7437. +/* Select timeout const, 1 count = 8ms */
  7438. +#define IN2000_TMOUT 0x1f
  7439. +
  7440. +#if 0
  7441. +/* This is used with scatter-gather */
  7442. +struct in2000_chain {
  7443. +  ulong  dataptr;        /* Location of data */
  7444. +  ulong  datalen;        /* Size of this part of chain */
  7445. +};
  7446. +#endif
  7447. +
  7448. +/* These belong in scsi.h also */
  7449. +#define any2scsi(up, p)                \
  7450. +(up)[0] = (((unsigned long)(p)) >> 16);        \
  7451. +(up)[1] = (((unsigned long)(p)) >> 8);        \
  7452. +(up)[2] = ((unsigned long)(p));
  7453. +
  7454. +#define scsi2int(up) ( ((((long)*(up))&0x1f) << 16) + (((long)(up)[1]) << 8) + ((long)(up)[2]) )
  7455. +
  7456. +#define xany2scsi(up, p)    \
  7457. +(up)[0] = ((long)(p)) >> 24;    \
  7458. +(up)[1] = ((long)(p)) >> 16;    \
  7459. +(up)[2] = ((long)(p)) >> 8;    \
  7460. +(up)[3] = ((long)(p));
  7461. +
  7462. +#define xscsi2int(up) ( (((long)(up)[0]) << 24) + (((long)(up)[1]) << 16) \
  7463. +              + (((long)(up)[2]) <<  8) +  ((long)(up)[3]) )
  7464. +
  7465. +#define MAX_CDB 12
  7466. +#define MAX_SENSE 14
  7467. +#define MAX_STATUS 32
  7468. +
  7469. +int in2000_detect(Scsi_Host_Template *);
  7470. +int in2000_command(Scsi_Cmnd *);
  7471. +int in2000_queuecommand(Scsi_Cmnd *, void (*done)(Scsi_Cmnd *));
  7472. +int in2000_abort(Scsi_Cmnd *, int);
  7473. +const char *in2000_info(void);
  7474. +int in2000_reset(Scsi_Cmnd *);
  7475. +int in2000_biosparam(int, int, int*);
  7476. +
  7477. +
  7478. +#ifndef NULL
  7479. +    #define NULL 0
  7480. +#endif
  7481. +
  7482. +/* next may be "SG_NONE" or "SG_ALL" or nr. of (1k) blocks per R/W Cmd. */
  7483. +#define IN2000_SG SG_ALL
  7484. +#define IN2000 {NULL, "Always IN2000", in2000_detect, NULL,    \
  7485. +        in2000_info, in2000_command,    \
  7486. +        in2000_queuecommand,        \
  7487. +        in2000_abort,            \
  7488. +        in2000_reset,            \
  7489. +            NULL,                        \
  7490. +        in2000_biosparam,               \
  7491. +        1, 7, IN2000_SG, 1, 0, 0}
  7492. +
  7493. +#endif
  7494. diff -u --recursive --new-file linux-1.1.58/drivers/sound/local.h linux/drivers/sound/local.h
  7495. --- linux-1.1.58/drivers/sound/local.h    Wed Dec 31 18:00:00 1969
  7496. +++ linux/drivers/sound/local.h    Wed Oct 26 23:02:02 1994
  7497. @@ -0,0 +1,9 @@
  7498. +/*    Generated by configure. Don't edit!!!!    */
  7499. +
  7500. +#undef CONFIGURE_SOUNDCARD
  7501. +#undef KERNEL_SOUNDCARD
  7502. +#define SOUND_VERSION_STRING "2.90-2"
  7503. +#define SOUND_CONFIG_DATE "Wed Oct 12 19:29:11 CDT 1994"
  7504. +#define SOUND_CONFIG_BY "root"
  7505. +#define SOUND_CONFIG_HOST "fuzzy"
  7506. +#define SOUND_CONFIG_DOMAIN ""
  7507. diff -u --recursive --new-file linux-1.1.58/eata.lsm linux/eata.lsm
  7508. --- linux-1.1.58/eata.lsm    Wed Dec 31 18:00:00 1969
  7509. +++ linux/eata.lsm    Wed Oct 26 23:02:02 1994
  7510. @@ -0,0 +1,29 @@
  7511. +Begin2
  7512. +Title        = EATA SCSI driver (DPT/NEC/AT&T)
  7513. +Version      = 0.3a
  7514. +Desc1        = Lowlevel device driver for all EATA compliant ISA and EISA 
  7515. +Desc2        = SCSI controllers
  7516. +Desc3        = Supported controllers are DPT PM2011, PM2012A, PM2012B
  7517. +Desc4        = PM2021, PM2022, PM2122, PM2322 and some OEMs from NEC and AT&T
  7518. +Author       = Michael Neuffer
  7519. +AuthorEmail  = Michael_Neuffer@wi2.maus.de, neuffer@goofy.zdv.uni-mainz.de
  7520. +Maintainer   = Michael Neuffer
  7521. +MaintEmail   = Michael_Neuffer@wi2.maus.de, neuffer@goofy.zdv.uni-mainz.de
  7522. +Site1        = tsx-11.mit.edu
  7523. +Path1        = /pub/linux/ALPHA/scsi/
  7524. +File1        = dpt_eata3a.tgz
  7525. +Site2        = sunsite.unc.edu
  7526. +Path2        = /pub/Linux/ALPHA/scsi
  7527. +File2        = dpt_eata03a.tgz
  7528. +Site3        = ftp.uni-mainz.de
  7529. +Path3        = /pub/Linux/Driver/SCSI
  7530. +File3        = dpt_eata03a.tgz
  7531. +Required1    = EATA compilant controller, Linux 1.1.51
  7532. +CopyPolicy1  = Code copyrighted be Michael Neuffer
  7533. +CopyPolicy2  = GNU Copyleft
  7534. +Keywords     = SCSI EATA DPT PM2011 PM2012A PM2012B PM2021 PM2022 PM2122 PM2322 NEC AT&T
  7535. +RelFiles1    = Slackboot_eata.gz Linux 1.1.51 Slackware bootdisk, kernel with many enabled features
  7536. +Entered      = 15AUG94
  7537. +EnteredBy    = Michael Neuffer
  7538. +End
  7539. +
  7540. diff -u --recursive --new-file linux-1.1.58/include/linux/sonycd535.h linux/include/linux/sonycd535.h
  7541. --- linux-1.1.58/include/linux/sonycd535.h    Wed Dec 31 18:00:00 1969
  7542. +++ linux/include/linux/sonycd535.h    Wed Oct 26 23:02:02 1994
  7543. @@ -0,0 +1,183 @@
  7544. +#ifndef SONYCD535_H
  7545. +#define SONYCD535_H
  7546. +
  7547. +/*
  7548. + * define all the commands recognized by the CDU-531/5
  7549. + */
  7550. +#define SONY535_REQUEST_DRIVE_STATUS_1        (0x80)
  7551. +#define SONY535_REQUEST_SENSE            (0x82)
  7552. +#define SONY535_REQUEST_DRIVE_STATUS_2        (0x84)
  7553. +#define SONY535_REQUEST_ERROR_STATUS        (0x86)
  7554. +#define SONY535_REQUEST_AUDIO_STATUS        (0x88)
  7555. +#define SONY535_INQUIRY                (0x8a)
  7556. +
  7557. +#define SONY535_SET_INACTIVITY_TIME        (0x90)
  7558. +
  7559. +#define SONY535_SEEK_AND_READ_N_BLOCKS_1    (0xa0)
  7560. +#define SONY535_SEEK_AND_READ_N_BLOCKS_2    (0xa4)
  7561. +#define SONY535_PLAY_AUDIO            (0xa6)
  7562. +
  7563. +#define SONY535_REQUEST_DISC_CAPACITY        (0xb0)
  7564. +#define SONY535_REQUEST_TOC_DATA        (0xb2)
  7565. +#define SONY535_REQUEST_SUB_Q_DATA        (0xb4)
  7566. +#define SONY535_REQUEST_ISRC            (0xb6)
  7567. +#define SONY535_REQUEST_UPC_EAN            (0xb8)
  7568. +
  7569. +#define SONY535_SET_DRIVE_MODE            (0xc0)
  7570. +#define SONY535_REQUEST_DRIVE_MODE        (0xc2)
  7571. +#define SONY535_SET_RETRY_COUNT            (0xc4)
  7572. +
  7573. +#define SONY535_DIAGNOSTIC_1            (0xc6)
  7574. +#define SONY535_DIAGNOSTIC_4            (0xcc)
  7575. +#define SONY535_DIAGNOSTIC_5            (0xce)
  7576. +
  7577. +#define SONY535_EJECT_CADDY            (0xd0)
  7578. +#define SONY535_DISABLE_EJECT_BUTTON        (0xd2)
  7579. +#define SONY535_ENABLE_EJECT_BUTTON        (0xd4)
  7580. +
  7581. +#define SONY535_HOLD                (0xe0)
  7582. +#define SONY535_AUDIO_PAUSE_ON_OFF        (0xe2)
  7583. +#define SONY535_SET_VOLUME            (0xe8)
  7584. +
  7585. +#define SONY535_STOP                (0xf0)
  7586. +#define SONY535_SPIN_UP                (0xf2)
  7587. +#define SONY535_SPIN_DOWN            (0xf4)
  7588. +
  7589. +#define SONY535_CLEAR_PARAMETERS        (0xf6)
  7590. +#define SONY535_CLEAR_ENDING_ADDRESS        (0xf8)
  7591. +
  7592. +/*
  7593. + * define some masks
  7594. + */
  7595. +#define SONY535_DATA_NOT_READY_BIT        (0x1)
  7596. +#define SONY535_RESULT_NOT_READY_BIT        (0x2)
  7597. +
  7598. +/*
  7599. + *  drive status 1
  7600. + */
  7601. +#define SONY535_STATUS1_COMMAND_ERROR        (0x1)
  7602. +#define SONY535_STATUS1_DATA_ERROR        (0x2)
  7603. +#define SONY535_STATUS1_SEEK_ERROR        (0x4)
  7604. +#define SONY535_STATUS1_DISC_TYPE_ERROR        (0x8)
  7605. +#define SONY535_STATUS1_NOT_SPINNING        (0x10)
  7606. +#define SONY535_STATUS1_EJECT_BUTTON_PRESSED    (0x20)
  7607. +#define SONY535_STATUS1_CADDY_NOT_INSERTED    (0x40)
  7608. +#define SONY535_STATUS1_BYTE_TWO_FOLLOWS    (0x80)
  7609. +
  7610. +/*
  7611. + * drive status 2
  7612. + */
  7613. +#define SONY535_CDD_LOADING_ERROR        (0x7)
  7614. +#define SONY535_CDD_NO_DISC            (0x8)
  7615. +#define SONY535_CDD_UNLOADING_ERROR        (0x9)
  7616. +#define SONY535_CDD_CADDY_NOT_INSERTED        (0xd)
  7617. +#define SONY535_ATN_RESET_OCCURRED        (0x2)
  7618. +#define SONY535_ATN_DISC_CHANGED        (0x4)
  7619. +#define SONY535_ATN_RESET_AND_DISC_CHANGED    (0x6)
  7620. +#define SONY535_ATN_EJECT_IN_PROGRESS        (0xe)
  7621. +#define SONY535_ATN_BUSY            (0xf)
  7622. +
  7623. +/*
  7624. + * define some parameters
  7625. + */
  7626. +#define SONY535_AUDIO_DRIVE_MODE        (0)
  7627. +#define SONY535_CDROM_DRIVE_MODE        (0xe0)
  7628. +
  7629. +#define SONY535_PLAY_OP_PLAYBACK        (0)
  7630. +#define SONY535_PLAY_OP_ENTER_HOLD        (1)
  7631. +#define SONY535_PLAY_OP_SET_AUDIO_ENDING_ADDR    (2)
  7632. +#define SONY535_PLAY_OP_SCAN_FORWARD        (3)
  7633. +#define SONY535_PLAY_OP_SCAN_BACKWARD        (4)
  7634. +
  7635. +/*
  7636. + *  convert from msf format to block number 
  7637. + */
  7638. +#define SONY_BLOCK_NUMBER(m,s,f) (((m)*60L+(s))*75L+(f))
  7639. +#define SONY_BLOCK_NUMBER_MSF(x) (((x)[0]*60L+(x)[1])*75L+(x)[2])
  7640. +
  7641. +/*
  7642. + *  error return values from the doSonyCmd() routines
  7643. + */
  7644. +#define TIME_OUT            (-1)
  7645. +#define NO_CDROM            (-2)
  7646. +#define BAD_STATUS            (-3)
  7647. +#define CD_BUSY                (-4)
  7648. +#define NOT_DATA_CD            (-5)
  7649. +#define NO_ROOM                (-6)
  7650. +
  7651. +#define LOG_START_OFFSET        150     /* Offset of first logical sector */
  7652. +
  7653. +#define SONY_JIFFIES_TIMEOUT            500  /* Maximum number of jiffies (10ms)
  7654. +                                                  the drive will wait/try for an
  7655. +                                                  operation */
  7656. +#define SONY_READY_RETRIES      (50000)  /* How many times to retry a
  7657. +                                                  spin waiting for a register
  7658. +                                                  to come ready */
  7659. +#define SONY535_FAST_POLLS    (10000)   /* how many times recheck 
  7660. +                                                  status waiting for a data
  7661. +                                                  to become ready */
  7662. +
  7663. +typedef unsigned char Byte;
  7664. +
  7665. +/*
  7666. + * This is the complete status returned from the drive configuration request
  7667. + * command.
  7668. + */
  7669. +struct s535_sony_drive_config
  7670. +{
  7671. +   char vendor_id[8];
  7672. +   char product_id[16];
  7673. +   char product_rev_level[4];
  7674. +};
  7675. +
  7676. +/* The following is returned from the request sub-q data command */
  7677. +struct s535_sony_subcode
  7678. +{
  7679. +   unsigned char address        :4;
  7680. +   unsigned char control        :4;
  7681. +   unsigned char track_num;
  7682. +   unsigned char index_num;
  7683. +   unsigned char rel_msf[3];
  7684. +   unsigned char abs_msf[3];
  7685. +};
  7686. +
  7687. +struct s535_sony_disc_capacity
  7688. +{
  7689. +   Byte mFirstTrack, sFirstTrack, fFirstTrack;
  7690. +   Byte mLeadOut, sLeadOut, fLeadOut;
  7691. +};
  7692. +
  7693. +/*
  7694. + * The following is returned from the request TOC (Table Of Contents) command.
  7695. + * (last_track_num-first_track_num+1) values are valid in tracks.
  7696. + */
  7697. +struct s535_sony_toc
  7698. +{
  7699. +   unsigned char reserved0      :4;
  7700. +   unsigned char control0       :4;
  7701. +   unsigned char point0;
  7702. +   unsigned char first_track_num;
  7703. +   unsigned char reserved0a;
  7704. +   unsigned char reserved0b;
  7705. +   unsigned char reserved1      :4;
  7706. +   unsigned char control1       :4;
  7707. +   unsigned char point1;
  7708. +   unsigned char last_track_num;
  7709. +   unsigned char dummy1;
  7710. +   unsigned char dummy2;
  7711. +   unsigned char reserved2      :4;
  7712. +   unsigned char control2       :4;
  7713. +   unsigned char point2;
  7714. +   unsigned char lead_out_start_msf[3];
  7715. +   struct
  7716. +   {
  7717. +      unsigned char reserved    :4;
  7718. +      unsigned char control     :4;
  7719. +      unsigned char track;
  7720. +      unsigned char track_start_msf[3];
  7721. +   } tracks[100];
  7722. +
  7723. +   unsigned int lead_out_start_lba;
  7724. +};
  7725. +
  7726. +#endif /* SONYCD535_H */
  7727. diff -u --recursive --new-file linux-1.1.58/kernel/ksyms.c linux/kernel/ksyms.c
  7728. --- linux-1.1.58/kernel/ksyms.c    Mon Oct 24 17:43:34 1994
  7729. +++ linux/kernel/ksyms.c    Wed Oct 26 23:04:07 1994
  7730. @@ -53,6 +53,15 @@
  7731.  
  7732.  extern void (* iABI_hook)(struct pt_regs * regs);
  7733.  
  7734. +#ifdef CONFIG_NEC260
  7735. +#include <linux/sched.h>
  7736. +extern int the_nec260_major;
  7737. +extern void (*do_hd) (void);
  7738. +#ifdef CONFIG_BLK_DEV_HD1
  7739. +extern void (*do_hd1) (void);
  7740. +#endif
  7741. +#endif
  7742. +
  7743.  struct symbol_table symbol_table = { 0, 0, 0, /* for stacked module support */
  7744.      {
  7745.      /* stackable module support */
  7746. @@ -199,6 +208,19 @@
  7747.      X(dev_queue_xmit),
  7748.      X(dev_base),
  7749.  #endif
  7750. +#ifdef CONFIG_NEC260
  7751. +    /* for the nec cdr-260 cdrom drive */
  7752. +    X (the_nec260_major),
  7753. +    X (do_hd),
  7754. +    X (read_ahead),
  7755. +    X (sync_dev),
  7756. +    X (invalidate_buffers),
  7757. +    X (__down),
  7758. +#ifdef CONFIG_BLK_DEV_HD1
  7759. +    X (do_hd1),
  7760. +#endif
  7761. +#endif
  7762. +
  7763.  
  7764.      /********************************************************
  7765.       * Do not add anything below this line,
  7766. diff -u --recursive --new-file linux-1.1.58/patch.eata linux/patch.eata
  7767. --- linux-1.1.58/patch.eata    Wed Dec 31 18:00:00 1969
  7768. +++ linux/patch.eata    Wed Oct 26 23:02:02 1994
  7769. @@ -0,0 +1,50 @@
  7770. +diff -u --recursive --new-file linux50/config.in linux/config.in
  7771. +--- config.old  Tue Sep 27 17:54:13 1994
  7772. ++++ config.in   Tue Sep 27 17:53:40 1994
  7773. +@@ -51,6 +51,7 @@
  7774. + bool 'Adaptec AHA1542 support' CONFIG_SCSI_AHA1542 n
  7775. + bool 'Adaptec AHA1740 support' CONFIG_SCSI_AHA1740 n
  7776. + bool 'BusLogic SCSI support' CONFIG_SCSI_BUSLOGIC n
  7777. ++bool 'EATA-DMA (rev. 2.0b) (DPT,NEC,AT&T) support' CONFIG_SCSI_EATA y
  7778. + bool 'Future Domain 16xx SCSI support' CONFIG_SCSI_FUTURE_DOMAIN n
  7779. + bool 'Generic NCR5380 SCSI support' CONFIG_SCSI_GENERIC_NCR5380 n
  7780. + bool 'NCR53c7,8xx SCSI support'  CONFIG_SCSI_NCR53C7xx n
  7781. +diff -u --recursive --new-file linux50/drivers/scsi/Makefile linux/drivers/scsi/Makefile
  7782. +--- linux50/drivers/scsi/Makefile    Tue Sep 27 18:02:02 1994
  7783. ++++ linux/drivers/scsi/Makefile    Thu Sep  8 23:23:19 1994
  7784. +@@ -72,6 +72,11 @@
  7785. + SCSI_SRCS := $(SCSI_SRCS) scsi_debug.c
  7786. + endif
  7787. + 
  7788. ++ifdef CONFIG_SCSI_EATA
  7789. ++SCSI_OBJS := $(SCSI_OBJS) eata.o
  7790. ++SCSI_SRCS := $(SCSI_SRCS) eata.c
  7791. ++endif
  7792. ++
  7793. + ifdef CONFIG_SCSI_FUTURE_DOMAIN
  7794. + SCSI_OBJS := $(SCSI_OBJS) fdomain.o
  7795. + SCSI_SRCS := $(SCSI_SRCS) fdomain.c
  7796. +diff -u --recursive --new-file linux50/drivers/scsi/hosts.c linux/drivers/scsi/hosts.c
  7797. +--- linux50/drivers/scsi/hosts.c    Tue Sep 27 18:03:15 1994
  7798. ++++ linux/drivers/scsi/hosts.c    Thu Sep  8 23:23:19 1994
  7799. +@@ -43,6 +43,10 @@
  7800. + #include "buslogic.h"
  7801. + #endif
  7802. + 
  7803. ++#ifdef CONFIG_SCSI_EATA            
  7804. ++#include "eata.h"
  7805. ++#endif
  7806. ++
  7807. + #ifdef CONFIG_SCSI_FUTURE_DOMAIN
  7808. + #include "fdomain.h"
  7809. + #endif
  7810. +@@ -131,6 +135,9 @@
  7811. + #ifdef CONFIG_SCSI_AHA1740
  7812. +     AHA1740,
  7813. + #endif
  7814. ++#ifdef CONFIG_SCSI_EATA 
  7815. ++        EATA,
  7816. ++#endif
  7817. + #ifdef CONFIG_SCSI_FUTURE_DOMAIN
  7818. +     FDOMAIN_16X0,
  7819. + #endif
  7820. diff -u --recursive --new-file linux-1.1.58/tools/version.h linux/tools/version.h
  7821. --- linux-1.1.58/tools/version.h    Wed Dec 31 18:00:00 1969
  7822. +++ linux/tools/version.h    Wed Oct 26 23:02:02 1994
  7823. @@ -0,0 +1,7 @@
  7824. +#define UTS_RELEASE "1.1.53"
  7825. +#define UTS_VERSION "#8 Wed Oct 12 21:48:39 CDT 1994"
  7826. +#define LINUX_COMPILE_TIME "21:48:39"
  7827. +#define LINUX_COMPILE_BY "root"
  7828. +#define LINUX_COMPILE_HOST "fuzzy"
  7829. +#define LINUX_COMPILE_DOMAIN "is.a.good.cat"
  7830. +#define LINUX_COMPILER "gcc version 2.5.8"
  7831.