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