home *** CD-ROM | disk | FTP | other *** search
/ PC-Online 1996 May / PCOnline_05_1996.bin / linux / source / kernel-s / v1.3 / patch-1.001 / patch-1~
Text File  |  1995-09-03  |  92KB  |  3,000 lines
  1. diff -u --recursive --new-file v1.3.22/linux/Makefile linux/Makefile
  2. --- v1.3.22/linux/Makefile    Sun Sep  3 12:26:48 1995
  3. +++ linux/Makefile    Sun Sep  3 12:28:30 1995
  4. @@ -1,6 +1,6 @@
  5.  VERSION = 1
  6.  PATCHLEVEL = 3
  7. -SUBLEVEL = 22
  8. +SUBLEVEL = 23
  9.  
  10.  ARCH = i386
  11.  
  12. diff -u --recursive --new-file v1.3.22/linux/arch/i386/mm/fault.c linux/arch/i386/mm/fault.c
  13. --- v1.3.22/linux/arch/i386/mm/fault.c    Wed Aug  2 13:20:59 1995
  14. +++ linux/arch/i386/mm/fault.c    Sun Sep  3 13:26:40 1995
  15. @@ -49,6 +49,16 @@
  16.          goto bad_area;
  17.      if (vma->vm_end - address > current->rlim[RLIMIT_STACK].rlim_cur)
  18.          goto bad_area;
  19. +    if (error_code & 4) {
  20. +        /*
  21. +         * accessing the stack below %esp is always a bug.
  22. +         * The "+ 32" is there due to some instructions (like
  23. +         * pusha) doing pre-decrement on the stack and that
  24. +         * doesn't show up until later..
  25. +         */
  26. +        if (address + 32 < regs->esp)
  27. +            goto bad_area;
  28. +    }
  29.      vma->vm_offset -= vma->vm_start - (address & PAGE_MASK);
  30.      vma->vm_start = (address & PAGE_MASK);
  31.  /*
  32. diff -u --recursive --new-file v1.3.22/linux/drivers/block/README.ide linux/drivers/block/README.ide
  33. --- v1.3.22/linux/drivers/block/README.ide    Sun Sep  3 12:26:50 1995
  34. +++ linux/drivers/block/README.ide    Sun Sep  3 12:03:42 1995
  35. @@ -46,6 +46,9 @@
  36.  NEW!    - ide-cd.c now compiles separate from ide.c
  37.  NEW!    - Bus-Master DMA support for Intel PCI Triton chipset IDE interfaces
  38.  NEW!        - for details, see comments at top of triton.c
  39. +NEW!    - ide-cd.c now supports door locking and auto-loading.
  40. +NEW!            Also preliminary support for multisession and direct
  41. +NEW!            reads of audio data.
  42.  
  43.  For work in progress, see the comments in ide.c, ide-cd.c, and triton.c.
  44.  
  45. @@ -160,6 +163,31 @@
  46.      ln -sf /dev/hdc /dev/cdrom
  47.      mkdir /cd
  48.      mount /dev/cdrom /cd -t iso9660 -o ro
  49. +
  50. +If, after doing all of the above, mount doesn't work and you see
  51. +errors from the driver (with dmesg) complaining about `status=0xff',
  52. +this means that the hardware is not responding to the driver's attempts
  53. +to read it.  One of the following is probably the problem:
  54. +
  55. +  - Your hardware is broken.
  56. +
  57. +  - You are using the wrong address for the device, or you have the
  58. +    drive jumpered wrong.  Review the configuration instructions above.
  59. +
  60. +  - Your IDE controller requires some nonstandard initialization sequence
  61. +    before it will work properly.  If this is the case, there will often
  62. +    be a separate MS-DOS driver just for the controller.  IDE interfaces
  63. +    on sound cards usually fall into this category.  Such configurations
  64. +    can often be made to work by first booting MS-DOS, loading the
  65. +    appropriate drivers, and then warm-booting linux (without powering
  66. +    off).  This can be automated using loadlin in the MS-DOS autoexec.
  67. +
  68. +If you always get timeout errors, interrupts from the drive are probably
  69. +not making it to the host.  Check how you have the hardware jumpered
  70. +and make sure it matches what the driver expects (see the configuration
  71. +instructions above).  If you have a PCI system, also check the BIOS
  72. +setup; i've had one report of a system which was shipped with IRQ 15
  73. +disabled by the BIOS.
  74.  
  75.  The kernel is able to execute binaries directly off of the cdrom,
  76.  provided it is mounted with the default block size of 1024 (as above).
  77. diff -u --recursive --new-file v1.3.22/linux/drivers/block/genhd.c linux/drivers/block/genhd.c
  78. --- v1.3.22/linux/drivers/block/genhd.c    Sun Sep  3 12:26:50 1995
  79. +++ linux/drivers/block/genhd.c    Sun Sep  3 12:20:25 1995
  80. @@ -3,20 +3,17 @@
  81.   *  linux/kernel/hd.c
  82.   *
  83.   *  Copyright (C) 1991, 1992  Linus Torvalds
  84. - */
  85. -
  86. -/*
  87. + *
  88. + *
  89.   *  Thanks to Branko Lankester, lankeste@fwi.uva.nl, who found a bug
  90.   *  in the early extended-partition checks and added DM partitions
  91. - */
  92. -
  93. -/*
  94. + *
  95.   *  Support for DiskManager v6.0x added by Mark Lord (mlord@bnr.ca)
  96.   *  with information provided by OnTrack.  This now works for linux fdisk
  97.   *  and LILO, as well as loadlin and bootln.  Note that disks other than
  98.   *  /dev/hda *must* have a "DOS" type 0x51 partition in the first slot (hda1).
  99. - * 
  100. - *  Added support for "missing/deleted" extended partitions - mlord@bnr.ca
  101. + *
  102. + *  More flexible handling of extended partitions - aeb, 950831
  103.   */
  104.  
  105.  #include <linux/config.h>
  106. @@ -82,14 +79,15 @@
  107.  {
  108.      struct buffer_head *bh;
  109.      struct partition *p;
  110. -    unsigned long first_sector, this_sector;
  111. +    unsigned long first_sector, this_sector, this_size;
  112.      int mask = (1 << hd->minor_shift) - 1;
  113. +    int i;
  114.  
  115.      first_sector = hd->part[MINOR(dev)].start_sect;
  116.      this_sector = first_sector;
  117.  
  118.      while (1) {
  119. -        if ((current_minor & mask) >= (4 + hd->max_p))
  120. +        if ((current_minor & mask) >= hd->max_p)
  121.              return;
  122.          if (!(bh = bread(dev,0,1024)))
  123.              return;
  124. @@ -100,29 +98,56 @@
  125.          bh->b_dirt = 0;
  126.          bh->b_uptodate = 0;
  127.          bh->b_req = 0;
  128. +
  129.          if (*(unsigned short *) (bh->b_data+510) != 0xAA55)
  130.              goto done;
  131. +
  132.          p = (struct partition *) (0x1BE + bh->b_data);
  133. +
  134. +        this_size = hd->part[MINOR(dev)].nr_sects;
  135. +
  136.          /*
  137. -         * Process the first entry, which should be the real
  138. -         * data partition.
  139. +         * Usually, the first entry is the real data partition,
  140. +         * the 2nd entry is the next extended partition, or empty,
  141. +         * and the 3rd and 4th entries are unused.
  142. +         * However, DRDOS sometimes has the extended partition as
  143. +         * the first entry (when the data partition is empty),
  144. +         * and OS/2 seems to use all four entries.
  145.           */
  146. -        if (p->sys_ind == EXTENDED_PARTITION)
  147. -            goto done;    /* shouldn't happen */
  148. -        if (p->sys_ind && p->nr_sects)
  149. -            add_partition(hd, current_minor, this_sector+p->start_sect, p->nr_sects);
  150. -        current_minor++;
  151. -        p++;
  152. +
  153. +        /* 
  154. +         * First process the data partition(s)
  155. +         */
  156. +        for (i=0; i<4; i++, p++) {
  157. +            if (!p->nr_sects || p->sys_ind == EXTENDED_PARTITION)
  158. +              continue;
  159. +
  160. +            if (p->start_sect + p->nr_sects > this_size)
  161. +              continue;
  162. +
  163. +            add_partition(hd, current_minor, this_sector+p->start_sect, p->nr_sects);
  164. +            current_minor++;
  165. +            if ((current_minor & mask) >= hd->max_p)
  166. +              goto done;
  167. +        }
  168.          /*
  169. -         * Process the second entry, which should be a link
  170. -         * to the next logical partition.  Create a minor
  171. -         * for this just long enough to get the next partition
  172. -         * table.  The minor will be reused for the real
  173. +         * Next, process the (first) extended partition, if present.
  174. +         * (So far, there seems to be no reason to make
  175. +         *  extended_partition()  recursive and allow a tree
  176. +         *  of extended partitions.)
  177. +         * It should be a link to the next logical partition.
  178. +         * Create a minor for this just long enough to get the next
  179. +         * partition table.  The minor will be reused for the next
  180.           * data partition.
  181.           */
  182. -        if (p->sys_ind != EXTENDED_PARTITION ||
  183. -            !(hd->part[current_minor].nr_sects = p->nr_sects))
  184. -            goto done;  /* no more logicals in this partition */
  185. +        p -= 4;
  186. +        for (i=0; i<4; i++, p++)
  187. +          if(p->nr_sects && p->sys_ind == EXTENDED_PARTITION)
  188. +            break;
  189. +        if (i == 4)
  190. +          goto done;     /* nothing left to do */
  191. +
  192. +        hd->part[current_minor].nr_sects = p->nr_sects;
  193.          hd->part[current_minor].start_sect = first_sector + p->start_sect;
  194.          this_sector = first_sector + p->start_sect;
  195.          dev = ((hd->major) << 8) | current_minor;
  196. @@ -211,6 +236,9 @@
  197.              printk(" <");
  198.              extended_partition(hd, (hd->major << 8) | minor);
  199.              printk(" >");
  200. +            /* prevent someone doing mkfs or mkswap on
  201. +               an extended partition */
  202. +            hd->part[minor].nr_sects = 0;
  203.          }
  204.      }
  205.      /*
  206. diff -u --recursive --new-file v1.3.22/linux/drivers/block/ide-cd.c linux/drivers/block/ide-cd.c
  207. --- v1.3.22/linux/drivers/block/ide-cd.c    Mon Aug 28 14:52:18 1995
  208. +++ linux/drivers/block/ide-cd.c    Sun Sep  3 12:03:42 1995
  209. @@ -41,21 +41,35 @@
  210.   *                       PLAYAUDIO12 is broken on the Aztech; work around it.
  211.   * 2.05x Aug 11, 1995 -- lots of data structure renaming/restructuring in ide.c
  212.   *                       (my apologies to Scott, but now ide-cd.c is independent)
  213. + * 3.00  Aug 22, 1995 -- Implement CDROMMULTISESSION ioctl (UNTESTED).
  214. + *                       Implement CDROMREADAUDIO ioctl (UNTESTED).
  215. + *                       Use input_ide_data() and output_ide_data().
  216. + *                       Add door locking.
  217. + *                       Fix usage count leak in cdrom_open, which happened
  218. + *                        when a read-write mount was attempted.
  219. + *                       Try to load the disk on open.
  220. + *                       Implement CDROMEJECT_SW ioctl (off by default).
  221. + *                       Read total cdrom capacity during open.
  222. + *                       Rearrange logic in cdrom_decode_status.  Issue
  223. + *                        request sense commands for failed packet commands
  224. + *                        from here instead of from cdrom_queue_packet_command.
  225. + *                        Fix a race condition in retrieving error information.
  226. + *                       Suppress printing normal unit attention errors and
  227. + *                        some drive not ready errors.
  228. + *                       Implement CDROMVOLREAD ioctl.
  229. + *                       Implement CDROMREADMODE1/2 ioctls.
  230. + *                       Fix race condition in setting up interrupt handlers
  231. + *                        when the `serialize' option is used.
  232. + * 3.01  Sep  2, 1995 -- Fix ordering of reenabling interrupts in
  233. + *                        cdrom_queue_request.
  234. + *                       Another try at using ide_[input,output]_data.
  235.   *
  236. - * FIX ME!!  A day-one bug exists when the ide.c "serialize" option is used.
  237. - * For this to always work correctly, ide_set_handler() must be called
  238. - * *just before* the final trigger is given to the drive (to cause it to go
  239. - * off and get data and then interrupt us again).  Otherwise, we may get the
  240. - * interrupt before set_handler() has actually run, resulting in "unexpected_intr".
  241. - *
  242. - * This can only happen in scenarios where we handle a "final" interrupt
  243. - * for one IDE port on, say irq14, and then initiate a new request for the
  244. - * other port on, say irq15, from the irq14 interrupt handler.  If we are
  245. - * running with "unmask" on, or have done sti(), then Whammo -- we're exposed.
  246. - *
  247. - * Places where this needs fixing have been identified in the code with "BUG".
  248. - * -ml  August 11, 1995
  249. - *
  250. + * NOTE: I've tried to implement support for multisession CDs and
  251. + * direct audio reads in this version, but i haven't been able to fully
  252. + * test them due to a lack of the proper hardware.  I'd appreciate hearing
  253. + * if the multisession stuff works; i'd also be interested in hearing
  254. + * if you get anything other than a `Parameter not supported'
  255. + * (asc=0x26, ascq=1) error when trying to do a direct audio read.
  256.   *
  257.   * ATAPI cd-rom driver.  To be used with ide.c.
  258.   *
  259. @@ -80,6 +94,7 @@
  260.  #include <linux/hdreg.h>
  261.  #include <linux/cdrom.h>
  262.  #include <asm/irq.h>
  263. +#include <asm/io.h>
  264.  
  265.  #define _IDE_CD_C    /* used in blk.h */
  266.  #include "ide.h"
  267. @@ -98,17 +113,10 @@
  268.  
  269.  #define MIN(a,b) ((a) < (b) ? (a) : (b))
  270.  
  271. -#if 1    /* "old" method */
  272. -#define OUT_WORDS(b,n)  outsw (IDE_DATA_REG, (b), (n))
  273. -#define IN_WORDS(b,n)   insw  (IDE_DATA_REG, (b), (n))
  274. -#else    /* "new" method -- should really fix each instance instead of this */
  275. -#define OUT_WORDS(b,n)    output_ide_data(drive,b,(n)/2)
  276. -#define IN_WORDS(b,n)    input_ide_data(drive,b,(n)/2)
  277. -#endif
  278. -
  279.  /* special command codes for strategy routine. */
  280. -#define PACKET_COMMAND 4315
  281. +#define PACKET_COMMAND        4315
  282.  #define REQUEST_SENSE_COMMAND 4316
  283. +#define RESET_DRIVE_COMMAND   4317
  284.  
  285.  /* Some ATAPI command opcodes (just like SCSI).
  286.     (Some other cdrom-specific codes are in cdrom.h.) */
  287. @@ -116,9 +124,11 @@
  288.  #define REQUEST_SENSE           0x03
  289.  #define START_STOP              0x1b
  290.  #define ALLOW_MEDIUM_REMOVAL    0x1e
  291. +#define READ_CAPACITY        0x25
  292.  #define READ_10                 0x28
  293.  #define MODE_SENSE_10           0x5a
  294.  #define MODE_SELECT_10          0x55
  295. +#define READ_CD                 0xbe
  296.  
  297.  
  298.  /* ATAPI sense keys (mostly copied from scsi.h). */
  299. @@ -135,25 +145,72 @@
  300.  #define MISCOMPARE              0x0e
  301.  
  302.  /* We want some additional flags for cd-rom drives.
  303. -   To save space in the ide_drive_t struct, use one of the fields which
  304. -   doesn't make sense for cd-roms -- `bios_sect'. */
  305. +   To save space in the ide_drive_t struct, use some fields which
  306. +   doesn't make sense for cd-roms -- `bios_sect' and `bios_head'. */
  307.  
  308. -struct ide_cd_flags {
  309. +/* Configuration flags.  These describe the capabilities of the drive.
  310. +   They generally do not change after initialization, unless we learn
  311. +   more about the drive from stuff failing. */
  312. +struct ide_cd_config_flags {
  313.    unsigned drq_interrupt : 1; /* Device sends an interrupt when ready
  314.                                   for a packet command. */
  315.    unsigned no_playaudio12: 1; /* The PLAYAUDIO12 command is not supported. */
  316. -
  317. -  unsigned media_changed : 1; /* Driver has noticed a media change. */
  318. -  unsigned toc_valid     : 1; /* Saved TOC information is current. */
  319. + 
  320.    unsigned no_lba_toc    : 1; /* Drive cannot return TOC info in LBA format. */
  321.    unsigned msf_as_bcd    : 1; /* Drive uses BCD in PLAYAUDIO_MSF. */
  322. +  unsigned no_doorlock   : 1; /* Drive cannot lock the door. */
  323. +  unsigned old_readcd    : 1; /* Drive uses old READ CD opcode. */
  324.    unsigned reserved : 2;
  325.  };
  326. +#define CDROM_CONFIG_FLAGS(drive) ((struct ide_cd_config_flags *)&((drive)->bios_sect))
  327. +
  328. + 
  329. +/* State flags.  These give information about the current state of the
  330. +   drive, and will change during normal operation. */
  331. +struct ide_cd_state_flags {
  332. +  unsigned media_changed : 1; /* Driver has noticed a media change. */
  333. +  unsigned toc_valid     : 1; /* Saved TOC information is current. */
  334. +  unsigned door_locked   : 1; /* We think that the drive door is locked. */
  335. +  unsigned eject_on_close: 1; /* Drive should eject when device is closed. */
  336. +  unsigned reserved : 4;
  337. +};
  338. +#define CDROM_STATE_FLAGS(drive)  ((struct ide_cd_state_flags *)&((drive)->bios_head))
  339.  
  340. -#define CDROM_FLAGS(drive) ((struct ide_cd_flags *)&((drive)->bios_sect))
  341.  
  342.  #define SECTOR_BUFFER_SIZE CD_FRAMESIZE
  343.  
  344. +
  345. +
  346. +/****************************************************************************
  347. + * Routines to read and write data from/to the drive, using
  348. + * the routines input_ide_data() and output_ide_data() from ide.c.
  349. + *
  350. + * All transfer lengths should be multiples of 16-bit shorts.
  351. + */
  352. +
  353. +
  354. +static inline
  355. +void cdrom_in_bytes (ide_drive_t *drive, void *buffer, uint bytecount)
  356. +{
  357. +  ide_input_data (drive, buffer, bytecount / 4);
  358. +  if ((bytecount & 0x03 >= 2))
  359. +    {
  360. +      insw (IDE_DATA_REG, buffer + (bytecount & ~0x03), 1);
  361. +    }
  362. +}
  363. +
  364. +
  365. +static inline
  366. +void cdrom_out_bytes (ide_drive_t *drive, void *buffer, uint bytecount)
  367. +{
  368. +  ide_output_data (drive, buffer, bytecount / 4);
  369. +  if ((bytecount & 0x03 >= 2))
  370. +    {
  371. +      outsw (IDE_DATA_REG, buffer + (bytecount & ~0x03), 1);
  372. +    }
  373. +}
  374. +
  375. +
  376.  
  377.  /****************************************************************************
  378.   * Descriptions of ATAPI error codes.
  379. @@ -298,7 +355,7 @@
  380.  
  381.  
  382.  /****************************************************************************
  383. - * Generic packet command support routines.
  384. + * Generic packet command support and error handling routines.
  385.   */
  386.  
  387.  
  388. @@ -312,7 +369,7 @@
  389.       the drive, and we don't want to fill the syslog with useless errors. */
  390.    if (failed_command &&
  391.        failed_command->c[0] == SCMD_READ_SUBCHANNEL &&
  392. -      (reqbuf->sense_key == 2 || reqbuf->sense_key == 6))
  393. +      (reqbuf->sense_key == NOT_READY || reqbuf->sense_key == UNIT_ATTENTION))
  394.      return;
  395.  
  396.  #if VERBOSE_IDE_CD_ERRORS
  397. @@ -380,6 +437,15 @@
  398.    }
  399.  
  400.  #else
  401. +
  402. +  /* Suppress printing unit attention and `in progress of becoming ready'
  403. +     errors when we're not being verbose. */
  404. +
  405. +  if (reqbuf->sense_key == UNIT_ATTENTION ||
  406. +      (reqbuf->sense_key == NOT_READY && (reqbuf->asc == 4 ||
  407. +                      reqbuf->asc == 0x3a)))
  408. +    return;
  409. +
  410.    printk ("%s: code: %x  key: %x  asc: %x  ascq: %x\n",
  411.        drive->name,
  412.        reqbuf->error_code, reqbuf->sense_key, reqbuf->asc, reqbuf->ascq);
  413. @@ -402,12 +468,14 @@
  414.  }
  415.  
  416.  
  417. -static void cdrom_queue_request_sense (ide_drive_t *drive)
  418. +static void cdrom_queue_request_sense (ide_drive_t *drive, 
  419. +                       struct semaphore *sem,
  420. +                       struct atapi_request_sense *reqbuf)
  421.  {
  422.    struct request *rq;
  423.    struct packet_command *pc;
  424. -  struct atapi_request_sense *reqbuf;
  425.    unsigned long flags;
  426. +  int len;
  427.  
  428.    int major = HWIF(drive)->major;
  429.  
  430. @@ -427,16 +495,30 @@
  431.  
  432.    restore_flags (flags);
  433.  
  434. +  /* If the request didn't explicitly specify where to put the sense data,
  435. +     use the statically allocated structure. */
  436. +  if (reqbuf == NULL)
  437. +    reqbuf = &drive->cdrom_info.sense_data;
  438. +
  439.    /* Make up a new request to retrieve sense information. */
  440. -  reqbuf = &drive->cdrom_info.sense_data;
  441.  
  442.    pc = &HWIF(drive)->request_sense_pc;
  443.    memset (pc, 0, sizeof (*pc));
  444.  
  445. +  /* The request_sense structure has an odd number of (16-bit) words,
  446. +     which won't work well with 32-bit transfers.  However, we don't care
  447. +     about the last two bytes, so just truncate the structure down
  448. +     to an even length. */
  449. +  len = sizeof (*reqbuf) / 4;
  450. +  len *= 4;
  451. +
  452.    pc->c[0] = REQUEST_SENSE;
  453. -  pc->c[4] = sizeof (*reqbuf);
  454. +  pc->c[4] = len;
  455.    pc->buffer = (char *)reqbuf;
  456. -  pc->buflen = sizeof (*reqbuf);
  457. +  pc->buflen = len;
  458. +  pc->sense_data = reqbuf;    /* The only reason to set this here is so
  459. +                   that cdrom_end_request can find the correct
  460. +                   buffer for dumps to the syslog. */
  461.    
  462.    rq = &HWIF(drive)->request_sense_request;
  463.    rq->dev = MKDEV (major, (drive->select.b.unit) << PARTN_BITS);
  464. @@ -446,7 +528,7 @@
  465.    rq->nr_sectors = 0;
  466.    rq->current_nr_sectors = 0;
  467.    rq->buffer = (char *)pc;
  468. -  rq->sem = NULL;
  469. +  rq->sem = sem;
  470.    rq->bh = NULL;
  471.    rq->bhtail = NULL;
  472.    rq->next = NULL;
  473. @@ -477,9 +559,8 @@
  474.  
  475.    if (rq->cmd == REQUEST_SENSE_COMMAND && uptodate)
  476.      {
  477. -      struct atapi_request_sense *reqbuf;
  478. -      reqbuf = &drive->cdrom_info.sense_data;
  479. -      cdrom_analyze_sense_data (drive, reqbuf, NULL);
  480. +      struct packet_command *pc = (struct packet_command *)rq->buffer;
  481. +      cdrom_analyze_sense_data (drive, pc->sense_data, NULL);
  482.      }
  483.  
  484.    ide_end_request (uptodate, HWGROUP(drive));
  485. @@ -490,8 +571,8 @@
  486.     buffers. */
  487.  static void cdrom_saw_media_change (ide_drive_t *drive)
  488.  {
  489. -  CDROM_FLAGS (drive)->media_changed = 1;
  490. -  CDROM_FLAGS (drive)->toc_valid = 0;
  491. +  CDROM_STATE_FLAGS (drive)->media_changed = 1;
  492. +  CDROM_STATE_FLAGS (drive)->toc_valid = 0;
  493.    drive->cdrom_info.nsectors_buffered = 0;
  494.  }
  495.  
  496. @@ -520,97 +601,126 @@
  497.      {
  498.        cmd = rq->cmd;
  499.  
  500. -      /* Check for tray open */
  501. -      if (sense_key == NOT_READY)
  502. +      if (cmd == REQUEST_SENSE_COMMAND)
  503.      {
  504. -      struct packet_command *pc;
  505. -      cdrom_saw_media_change (drive);
  506. +      /* We got an error trying to get sense info from the drive
  507. +         (probably while trying to recover from a former error).
  508. +         Just give up. */
  509.  
  510. -      /* Fail the request if this is a read command. */
  511. -      if (cmd == READ)
  512. -        {
  513. -          printk ("%s : tray open\n", drive->name);
  514. -          cdrom_end_request (0, drive);
  515. -        }
  516. +      struct packet_command *pc = (struct packet_command *)rq->buffer;
  517. +      pc->stat = 1;
  518. +      cdrom_end_request (1, drive);
  519. +      if (ide_error (drive, "request sense failure", stat))
  520. +        return 1;
  521. +    }
  522.  
  523. -      else
  524. +      else if (cmd == PACKET_COMMAND)
  525. +    {
  526. +      /* All other functions, except for READ. */
  527. +
  528. +      struct packet_command *pc = (struct packet_command *)rq->buffer;
  529. +      struct semaphore *sem = NULL;
  530. +
  531. +      /* Check for tray open. */
  532. +      if (sense_key == NOT_READY)
  533.          {
  534. -          /* Otherwise, it's some other packet command.
  535. -         Print an error message to the syslog.
  536. +          cdrom_saw_media_change (drive);
  537. +
  538. +          /* Print an error message to the syslog.
  539.           Exception: don't print anything if this is a read subchannel
  540.           command.  This is because workman constantly polls the drive
  541.           with this command, and we don't want to uselessly fill up
  542.           the syslog. */
  543. -          pc = (struct packet_command *)rq->buffer;
  544.            if (pc->c[0] != SCMD_READ_SUBCHANNEL)
  545. -        printk ("%s : tray open\n", drive->name);
  546. -
  547. -          /* Set the error flag and complete the request. */
  548. -          pc->stat = 1;
  549. -          cdrom_end_request (1, drive);
  550. +        printk ("%s : tray open or drive not ready\n", drive->name);
  551.          }
  552. -    }
  553.  
  554. -      /* Check for media change. */
  555. -      else if (sense_key == UNIT_ATTENTION)
  556. -    {
  557. -      cdrom_saw_media_change (drive);
  558. -      printk ("%s: media changed\n", drive->name);
  559. -
  560. -      /* Return failure for a packet command, so that
  561. -         cdrom_queue_packet_command can do a request sense before
  562. -         the command gets retried. */
  563. +      /* Check for media change. */
  564. +      else if (sense_key == UNIT_ATTENTION)
  565. +        {
  566. +          cdrom_saw_media_change (drive);
  567. +          printk ("%s: media changed\n", drive->name);
  568. +        }
  569.  
  570. -      if (cmd == PACKET_COMMAND)
  571. +      /* Otherwise, print an error. */
  572. +      else
  573.          {
  574. -          struct packet_command *pc = (struct packet_command *)rq->buffer;
  575. -          pc->stat = 1;
  576. -          cdrom_end_request (1, drive);
  577. +          ide_dump_status (drive, "packet command error", stat);
  578.          }
  579.  
  580. -      /* Otherwise, it's a block read.  Arrange to retry it.
  581. -         But be sure to give up if we've retried too many times. */
  582. -      else if ((++rq->errors > ERROR_MAX))
  583. +      /* Set the error flag and complete the request.
  584. +         Then, if we have a CHECK CONDITION status, queue a request
  585. +         sense command.  We must be careful, though: we don't want
  586. +         the thread in cdrom_queue_packet_command to wake up until
  587. +         the request sense has completed.  We do this by transferring
  588. +         the semaphore from the packet command request to the
  589. +         request sense request. */
  590. +
  591. +      if ((stat & ERR_STAT) != 0)
  592.          {
  593. -          cdrom_end_request (0, drive);
  594. +          sem = rq->sem;
  595. +          rq->sem = NULL;
  596.          }
  597. -    }
  598.  
  599. -      /* Don't attempt to retry if this was a packet command. */
  600. -      else if (cmd == PACKET_COMMAND)
  601. -    {
  602. -      struct packet_command *pc = (struct packet_command *)rq->buffer;
  603. -      ide_dump_status (drive, "packet command error", stat);
  604. -      pc->stat = 1;  /* signal error */
  605. +      pc->stat = 1;
  606.        cdrom_end_request (1, drive);
  607. -    }
  608.  
  609. -      /* No point in retrying after an illegal request or data protect error.*/
  610. -      else if (sense_key == ILLEGAL_REQUEST || sense_key == DATA_PROTECT)
  611. -    {
  612. -      ide_dump_status (drive, "command error", stat);
  613. -      cdrom_end_request (0, drive);
  614. +      if ((stat & ERR_STAT) != 0)
  615. +        cdrom_queue_request_sense (drive, sem, pc->sense_data);
  616.      }
  617.  
  618. -      /* If there were other errors, go to the default handler. */
  619. -      else if ((err & ~ABRT_ERR) != 0)
  620. +      else
  621.      {
  622. -      if (ide_error (drive, "cdrom_decode_status", stat))
  623. -        return 1;
  624. -    }
  625. +      /* Handle errors from READ requests. */
  626.  
  627. -      /* Else, abort if we've racked up too many retries. */
  628. -      else if ((++rq->errors > ERROR_MAX))
  629. -    {
  630. -      cdrom_end_request (0, drive);
  631. -    }
  632. +      /* Check for tray open. */
  633. +      if (sense_key == NOT_READY)
  634. +        {
  635. +          cdrom_saw_media_change (drive);
  636.  
  637. -      /* If we got a CHECK_STATUS condition, and this was a READ request,
  638. -     queue a request sense command to try to find out more about
  639. -     what went wrong (and clear a unit attention)?  For packet commands,
  640. -     this is done separately in cdrom_queue_packet_command. */
  641. -      if ((stat & ERR_STAT) != 0 && cmd == READ)
  642. -    cdrom_queue_request_sense (drive);
  643. +          /* Fail the request. */
  644. +          printk ("%s : tray open\n", drive->name);
  645. +          cdrom_end_request (0, drive);
  646. +        }
  647. +
  648. +      /* Check for media change. */
  649. +      else if (sense_key == UNIT_ATTENTION)
  650. +        {
  651. +          cdrom_saw_media_change (drive);
  652. +
  653. +          /* Arrange to retry the request.
  654. +             But be sure to give up if we've retried too many times. */
  655. +          if (++rq->errors > ERROR_MAX)
  656. +        {
  657. +          cdrom_end_request (0, drive);
  658. +        }
  659. +        }
  660. +      /* No point in retrying after an illegal request or
  661. +         data protect error.*/
  662. +      else if (sense_key == ILLEGAL_REQUEST || sense_key == DATA_PROTECT)
  663. +        {
  664. +          ide_dump_status (drive, "command error", stat);
  665. +          cdrom_end_request (0, drive);
  666. +        }
  667. +
  668. +      /* If there were other errors, go to the default handler. */
  669. +      else if ((err & ~ABRT_ERR) != 0)
  670. +        {
  671. +          if (ide_error (drive, "cdrom_decode_status", stat))
  672. +        return 1;
  673. +        }
  674. +
  675. +      /* Else, abort if we've racked up too many retries. */
  676. +      else if ((++rq->errors > ERROR_MAX))
  677. +        {
  678. +          cdrom_end_request (0, drive);
  679. +        }
  680. +
  681. +      /* If we got a CHECK_CONDITION status, queue a request sense
  682. +         command. */
  683. +      if ((stat & ERR_STAT) != 0)
  684. +        cdrom_queue_request_sense (drive, NULL, NULL);
  685. +    }
  686.      }
  687.  
  688.    /* Retry, or handle the next request. */
  689. @@ -620,10 +730,14 @@
  690.  
  691.  
  692.  /* Set up the device registers for transferring a packet command on DEV,
  693. -   expecting to later transfer XFERLEN bytes.  This should be followed
  694. -   by a call to cdrom_transfer_packet_command; however, if this is a
  695. -   drq_interrupt device, one must wait for an interrupt first. */
  696. -static int cdrom_start_packet_command (ide_drive_t *drive, int xferlen)
  697. +   expecting to later transfer XFERLEN bytes.  HANDLER is the routine
  698. +   which actually transfers the command to the drive.  If this is a
  699. +   drq_interrupt device, this routine will arrange for HANDLER to be
  700. +   called when the interrupt from the drive arrives.  Otherwise, HANDLER
  701. +   will be called immediately after the drive is prepared for the transfer. */
  702. +
  703. +static int cdrom_start_packet_command (ide_drive_t *drive, int xferlen,
  704. +                       ide_handler_t *handler)
  705.  {
  706.    /* Wait for the controller to be idle. */
  707.    if (ide_wait_stat (drive, 0, BUSY_STAT, WAIT_READY)) return 1;
  708. @@ -636,19 +750,29 @@
  709.    OUT_BYTE (xferlen & 0xff, IDE_LCYL_REG);
  710.    OUT_BYTE (xferlen >> 8  , IDE_HCYL_REG);
  711.    OUT_BYTE (drive->ctl, IDE_CONTROL_REG);
  712. -  OUT_BYTE (WIN_PACKETCMD, IDE_COMMAND_REG); /* packet command */
  713. +
  714. +  if (CDROM_CONFIG_FLAGS (drive)->drq_interrupt)
  715. +    {
  716. +      ide_set_handler (drive, handler);
  717. +      OUT_BYTE (WIN_PACKETCMD, IDE_COMMAND_REG); /* packet command */
  718. +    }
  719. +  else
  720. +    {
  721. +      OUT_BYTE (WIN_PACKETCMD, IDE_COMMAND_REG); /* packet command */
  722. +      (*handler) (drive);
  723. +    }
  724.  
  725.    return 0;
  726.  }
  727.  
  728.  
  729. -/* Send a packet command to DEV described by CMD_BUF and CMD_LEN.
  730. +/* Send a packet command to DRIVE described by CMD_BUF and CMD_LEN.
  731.     The device registers must have already been prepared
  732.     by cdrom_start_packet_command. */
  733.  static int cdrom_transfer_packet_command (ide_drive_t *drive,
  734.                                            char *cmd_buf, int cmd_len)
  735.  {
  736. -  if (CDROM_FLAGS (drive)->drq_interrupt)
  737. +  if (CDROM_CONFIG_FLAGS (drive)->drq_interrupt)
  738.      {
  739.        /* Here we should have been called after receiving an interrupt
  740.           from the device.  DRQ should how be set. */
  741. @@ -664,7 +788,7 @@
  742.      }
  743.  
  744.    /* Send the command to the device. */
  745. -  OUT_WORDS (cmd_buf, cmd_len/2);
  746. +  cdrom_out_bytes (drive, cmd_buf, cmd_len);
  747.  
  748.    return 0;
  749.  }
  750. @@ -714,7 +838,7 @@
  751.    dest = info->sector_buffer + info->nsectors_buffered * SECTOR_SIZE;
  752.    while (sectors_to_buffer > 0)
  753.      {
  754. -      IN_WORDS (dest, SECTOR_SIZE / 2);
  755. +      cdrom_in_bytes (drive, dest, SECTOR_SIZE);
  756.        --sectors_to_buffer;
  757.        --sectors_to_transfer;
  758.        ++info->nsectors_buffered;
  759. @@ -725,7 +849,7 @@
  760.    while (sectors_to_transfer > 0)
  761.      {
  762.        char dum[SECTOR_SIZE];
  763. -      IN_WORDS (dum, sizeof (dum) / 2);
  764. +      cdrom_in_bytes (drive, dum, sizeof (dum));
  765.        --sectors_to_transfer;
  766.      }
  767.  }
  768. @@ -753,9 +877,9 @@
  769.           and quit this request. */
  770.        while (len > 0)
  771.          {
  772. -          short dum = 0;
  773. -          OUT_WORDS (&dum, 1);
  774. -          len -= 2;
  775. +          int dum = 0;
  776. +      cdrom_out_bytes (drive, &dum, sizeof (dum));
  777. +          len -= sizeof (dum);
  778.          }
  779.      }
  780.  
  781. @@ -833,7 +957,7 @@
  782.      {
  783.        /* We need to throw away a sector. */
  784.        char dum[SECTOR_SIZE];
  785. -      IN_WORDS (dum, sizeof (dum) / 2);
  786. +      cdrom_in_bytes (drive, dum, sizeof (dum));
  787.  
  788.        --rq->current_nr_sectors;
  789.        --nskip;
  790. @@ -869,7 +993,7 @@
  791.            /* Read this_transfer sectors into the current buffer. */
  792.            while (this_transfer > 0)
  793.              {
  794. -              IN_WORDS (rq->buffer, SECTOR_SIZE / 2);
  795. +              cdrom_in_bytes (drive, rq->buffer, SECTOR_SIZE);
  796.                rq->buffer += SECTOR_SIZE;
  797.                --rq->nr_sectors;
  798.                --rq->current_nr_sectors;
  799. @@ -882,7 +1006,7 @@
  800.  
  801.    /* Done moving data!
  802.       Wait for another interrupt. */
  803. -  ide_set_handler(drive, &cdrom_read_intr);    /* this one is okay */
  804. +  ide_set_handler (drive, &cdrom_read_intr);
  805.  }
  806.  
  807.  
  808. @@ -952,7 +1076,7 @@
  809.   * However, for drq_interrupt devices, it is called from an interrupt
  810.   * when the drive is ready to accept the command.
  811.   */
  812. -static int cdrom_start_read_continuation (ide_drive_t *drive)
  813. +static void cdrom_start_read_continuation (ide_drive_t *drive)
  814.  {
  815.    struct packet_command pc;
  816.    struct request *rq = HWGROUP(drive)->rq;
  817. @@ -981,7 +1105,7 @@
  818.                    drive->name, rq->current_nr_sectors);
  819.            cdrom_end_request (0, drive);
  820.            IDE_DO_REQUEST;
  821. -          return 1;
  822. +          return;
  823.          }
  824.  
  825.        sector -= nskip;
  826. @@ -1016,23 +1140,18 @@
  827.      pc.c[5] = conv.b.b0;
  828.    }
  829.  
  830. -  if (cdrom_transfer_packet_command (drive, pc.c, sizeof (pc.c)))
  831. -    return 1;
  832. +  /* Set up to receive the data-ready interrupt from the drive. */
  833. +  ide_set_handler (drive, &cdrom_read_intr);
  834.  
  835. -  /* Set up our interrupt handler and return. */
  836. -  ide_set_handler(drive, &cdrom_read_intr); /* BUG: do this BEFORE triggering drive */
  837. -
  838. -  return 0;
  839. +  /* Send the command to the drive and return. */
  840. +  (void) cdrom_transfer_packet_command (drive, pc.c, sizeof (pc.c));
  841.  }
  842.  
  843.  
  844.  /*
  845.   * Start a read request from the CD-ROM.
  846. - * Returns 0 if the request was started successfully,
  847. - *  1 if there was an error and we should either retry or move on to the
  848. - *  next request.
  849.   */
  850. -static int cdrom_start_read (ide_drive_t *drive, unsigned int block)
  851. +static void cdrom_start_read (ide_drive_t *drive, unsigned int block)
  852.  {
  853.    struct request *rq = HWGROUP(drive)->rq;
  854.  
  855. @@ -1042,23 +1161,13 @@
  856.  
  857.    /* Satisfy whatever we can of this request from our cached sector. */
  858.    if (cdrom_read_from_buffer (drive))
  859. -    return 1;
  860. +    return;
  861.  
  862.    /* Clear the local sector buffer. */
  863.    drive->cdrom_info.nsectors_buffered = 0;
  864.  
  865. -  if (cdrom_start_packet_command (drive, 32768))
  866. -    return 1;
  867. -
  868. -  if (CDROM_FLAGS (drive)->drq_interrupt)
  869. -    ide_set_handler(drive, (ide_handler_t *)&cdrom_start_read_continuation); /* BUG: do this BEFORE triggering drive */
  870. -  else
  871. -    {
  872. -      if (cdrom_start_read_continuation (drive))
  873. -        return 1;
  874. -    }
  875. -
  876. -  return 0;
  877. +  /* Start sending the read request to the drive. */
  878. +  cdrom_start_packet_command (drive, 32768, cdrom_start_read_continuation);
  879.  }
  880.  
  881.  
  882. @@ -1068,9 +1177,11 @@
  883.   * Execute all other packet commands.
  884.   */
  885.  
  886. -/* Forward declaration */
  887. +/* Forward declarations. */
  888.  static int
  889. -cdrom_request_sense (ide_drive_t *drive, struct atapi_request_sense *reqbuf);
  890. +cdrom_lockdoor (ide_drive_t *drive, int lockflag,
  891. +        struct atapi_request_sense *reqbuf);
  892. +
  893.  
  894.  
  895.  /* Interrupt routine for packet command completion. */
  896. @@ -1131,15 +1242,15 @@
  897.          }
  898.  
  899.        /* Transfer the data. */
  900. -      OUT_WORDS (pc->buffer, thislen / 2);
  901. +      cdrom_out_bytes (drive, pc->buffer, thislen);
  902.  
  903.        /* If we haven't moved enough data to satisfy the drive,
  904.           add some padding. */
  905.        while (len > thislen)
  906.          {
  907. -          short dum = 0;
  908. -          OUT_WORDS (&dum, 1);
  909. -          len -= 2;
  910. +          int dum = 0;
  911. +      cdrom_out_bytes (drive, &dum, sizeof (dum));
  912. +          len -= sizeof (dum);
  913.          }
  914.  
  915.        /* Keep count of how much data we've moved. */
  916. @@ -1160,15 +1271,15 @@
  917.          }
  918.  
  919.        /* Transfer the data. */
  920. -      IN_WORDS (pc->buffer, thislen / 2);
  921. +      cdrom_in_bytes (drive, pc->buffer, thislen);
  922.  
  923.        /* If we haven't moved enough data to satisfy the drive,
  924.           add some padding. */
  925.        while (len > thislen)
  926.          {
  927. -          short dum = 0;
  928. -          IN_WORDS (&dum, 1);
  929. -          len -= 2;
  930. +          int dum = 0;
  931. +      cdrom_in_bytes (drive, &dum, sizeof (dum));
  932. +          len -= sizeof (dum);
  933.          }
  934.  
  935.        /* Keep count of how much data we've moved. */
  936. @@ -1184,26 +1295,24 @@
  937.      }
  938.  
  939.    /* Now we wait for another interrupt. */
  940. -  ide_set_handler(drive, &cdrom_pc_intr);    /* this one is okay */
  941. +  ide_set_handler (drive, &cdrom_pc_intr);
  942.  }
  943.  
  944.  
  945. -static int cdrom_do_pc_continuation (ide_drive_t *drive)
  946. +static void cdrom_do_pc_continuation (ide_drive_t *drive)
  947.  {
  948.    struct request *rq = HWGROUP(drive)->rq;
  949.    struct packet_command *pc = (struct packet_command *)rq->buffer;
  950.  
  951. -  if (cdrom_transfer_packet_command (drive, pc->c, sizeof (pc->c)))
  952. -    return 1;
  953. +  /* Set up a handler for the data-ready interrupt. */
  954. +  ide_set_handler (drive, &cdrom_pc_intr);
  955.  
  956. -  /* Set up our interrupt handler and return. */
  957. -  ide_set_handler(drive, &cdrom_pc_intr); /* BUG: do this BEFORE triggering drive */
  958. -
  959. -  return 0;
  960. +  /* Send the command to the drive and return. */
  961. +  cdrom_transfer_packet_command (drive, pc->c, sizeof (pc->c));
  962.  }
  963.  
  964.  
  965. -static int cdrom_do_packet_command (ide_drive_t *drive)
  966. +static void cdrom_do_packet_command (ide_drive_t *drive)
  967.  {
  968.    int len;
  969.    struct request *rq = HWGROUP(drive)->rq;
  970. @@ -1214,42 +1323,34 @@
  971.  
  972.    pc->stat = 0;
  973.  
  974. -  if (cdrom_start_packet_command (drive, len))
  975. -    return 1;
  976. +  /* Start sending the command to the drive. */
  977. +  cdrom_start_packet_command (drive, len, cdrom_do_pc_continuation);
  978. +}
  979.  
  980. -  if (CDROM_FLAGS (drive)->drq_interrupt)
  981. -    ide_set_handler(drive, (ide_handler_t *)&cdrom_do_pc_continuation); /* BUG: do this BEFORE triggering drive */
  982. -  else
  983. -    {
  984. -      if (cdrom_do_pc_continuation (drive))
  985. -        return 1;
  986. -    }
  987.  
  988. -  return 0;
  989. +/* Sleep for TIME jiffies.
  990. +   Not to be called from an interrupt handler. */
  991. +static
  992. +void cdrom_sleep (int time)
  993. +{
  994. +  current->state = TASK_INTERRUPTIBLE;
  995. +  current->timeout = jiffies + time;
  996. +  schedule ();
  997.  }
  998.  
  999.  
  1000.  static
  1001. -int cdrom_queue_packet_command (ide_drive_t *drive, struct packet_command *pc)
  1002. +void cdrom_queue_request (ide_drive_t *drive, struct request *req)
  1003.  {
  1004. -  int retries = 3;
  1005.    unsigned long flags;
  1006. -  struct request req, **p, **pfirst;
  1007. -  struct semaphore sem = MUTEX_LOCKED;
  1008. +  struct request **p, **pfirst;
  1009.    int major = HWIF(drive)->major;
  1010. +  struct semaphore sem = MUTEX_LOCKED;
  1011.  
  1012. - retry:
  1013. -  req.dev = MKDEV (major, (drive->select.b.unit) << PARTN_BITS);
  1014. -  req.cmd = PACKET_COMMAND;
  1015. -  req.errors = 0;
  1016. -  req.sector = 0;
  1017. -  req.nr_sectors = 0;
  1018. -  req.current_nr_sectors = 0;
  1019. -  req.buffer = (char *)pc;
  1020. -  req.sem = &sem;
  1021. -  req.bh = NULL;
  1022. -  req.bhtail = NULL;
  1023. -  req.next = NULL;
  1024. +  req->dev = MKDEV (major, (drive->select.b.unit) << PARTN_BITS);
  1025. +  req->sem = &sem;
  1026. +  req->errors = 0;
  1027. +  req->next = NULL;
  1028.  
  1029.    save_flags (flags);
  1030.    cli ();
  1031. @@ -1260,42 +1361,88 @@
  1032.      {
  1033.        p = &((*p)->next);
  1034.      }
  1035. -  *p = &req;
  1036. +  *p = req;
  1037.    if (p == pfirst)
  1038.      blk_dev[major].request_fn ();
  1039.  
  1040. +  down (&sem);
  1041. +
  1042.    restore_flags (flags);
  1043. +}
  1044. + 
  1045. + 
  1046. +static
  1047. +int cdrom_queue_packet_command (ide_drive_t *drive, struct packet_command *pc)
  1048. +{
  1049. +  struct atapi_request_sense my_reqbuf;
  1050. +  int retries = 10;
  1051. +  struct request req;
  1052. +
  1053. +  /* If our caller has not provided a place to stick any sense data,
  1054. +     use our own area. */
  1055. +  if (pc->sense_data == NULL)
  1056. +    pc->sense_data = &my_reqbuf;
  1057. +  pc->sense_data->sense_key = 0;
  1058. +
  1059. +  /* Start of retry loop. */
  1060. +  do {
  1061. +    req.cmd = PACKET_COMMAND;
  1062. +    req.sector = 0;
  1063. +    req.nr_sectors = 0;
  1064. +    req.current_nr_sectors = 0;
  1065. +    req.buffer = (char *)pc;
  1066. +    req.bh = NULL;
  1067. +    req.bhtail = NULL;
  1068.  
  1069. -  down (&sem);
  1070. +    cdrom_queue_request (drive, &req);
  1071.  
  1072. -  if (pc->stat != 0)
  1073. -    {
  1074. -      /* The request failed.  Try to do a request sense to get more information
  1075. -     about the error; store the result in the cdrom_info struct
  1076. -     for this drive.  Check to be sure that it wasn't a request sense
  1077. -     request that failed, though, to prevent infinite loops. */
  1078. -      
  1079. -      struct atapi_request_sense *reqbuf = &drive->cdrom_info.sense_data;
  1080. +    if (pc->stat != 0)
  1081. +      {
  1082. +    /* The request failed.  Retry if it was due to a unit attention status
  1083. +       (usually means media was changed). */
  1084. +    struct atapi_request_sense *reqbuf = pc->sense_data;
  1085. +
  1086. +    if (reqbuf->sense_key == UNIT_ATTENTION)
  1087. +      ;
  1088. +
  1089. +    /* Also retry if the drive is in the process of loading a disk.
  1090. +       This time, however, wait a little between retries to give
  1091. +       the drive time. */
  1092. +    else if (reqbuf->sense_key == NOT_READY && reqbuf->asc == 4)
  1093. +      {
  1094. +        cdrom_sleep (HZ);
  1095. +      }
  1096. +
  1097. +    /* Otherwise, don't retry. */
  1098. +    else
  1099. +      retries = 0;
  1100. +
  1101. +    --retries;
  1102. +      }
  1103. +
  1104. +    /* End of retry loop. */
  1105. +  } while (pc->stat != 0 && retries >= 0);
  1106.  
  1107. -      if (pc->c[0] == REQUEST_SENSE || cdrom_request_sense (drive, reqbuf))
  1108. -    {
  1109. -      memset (reqbuf, 0, sizeof (*reqbuf));
  1110. -      reqbuf->asc = 0xff;
  1111. -    }
  1112. -      cdrom_analyze_sense_data (drive, reqbuf, pc);
  1113.  
  1114. -      /* If the error was a unit attention (usually means media was changed),
  1115. -     retry the command. */
  1116. -      if (reqbuf->sense_key == UNIT_ATTENTION && retries > 0)
  1117. +  /* Return an error if the command failed. */
  1118. +  if (pc->stat != 0)
  1119. +    return -EIO;
  1120. +
  1121. +  else
  1122. +    {
  1123. +      /* The command succeeded.  If it was anything other than a request sense,
  1124. +     eject, or door lock command, and we think that the door is presently
  1125. +     unlocked, lock it again.  (The door was probably unlocked via
  1126. +     an explicit CDROMEJECT ioctl.) */
  1127. +      if (CDROM_STATE_FLAGS (drive)->door_locked == 0 &&
  1128. +      (pc->c[0] != REQUEST_SENSE &&
  1129. +       pc->c[0] != ALLOW_MEDIUM_REMOVAL &&
  1130. +       pc->c[0] != START_STOP))
  1131.      {
  1132. -      --retries;
  1133. -      goto retry;
  1134. +      (void) cdrom_lockdoor (drive, 1, NULL);
  1135.      }
  1136. -
  1137. -      return -EIO;
  1138. +      return 0;
  1139.      }
  1140. -  else
  1141. -    return 0;
  1142.  }
  1143.  
  1144.  
  1145. @@ -1310,6 +1457,14 @@
  1146.  
  1147.    if (rq -> cmd == PACKET_COMMAND || rq -> cmd == REQUEST_SENSE_COMMAND)
  1148.      cdrom_do_packet_command (drive);
  1149. +
  1150. +  else if (rq -> cmd == RESET_DRIVE_COMMAND)
  1151. +    {
  1152. +      cdrom_end_request (1, drive);
  1153. +      if (ide_do_reset (drive))
  1154. +    return;
  1155. +    }
  1156. +
  1157.    else if (rq -> cmd != READ)
  1158.      {
  1159.        printk ("ide-cd: bad cmd %d\n", rq -> cmd);
  1160. @@ -1322,7 +1477,13 @@
  1161.  
  1162.  
  1163.  /****************************************************************************
  1164. - * ioctl handling.
  1165. + * Ioctl handling.
  1166. + *
  1167. + * Routines which queue packet commands take as a final argument a pointer
  1168. + * to an atapi_request_sense struct.  If execution of the command results
  1169. + * in an error with a CHECK CONDITION status, this structure will be filled
  1170. + * with the results of the subsequent request sense command.  The pointer
  1171. + * can also be NULL, in which case no sense information is returned.
  1172.   */
  1173.  
  1174.  static inline
  1175. @@ -1374,59 +1535,74 @@
  1176.  }
  1177.  
  1178.  
  1179. -static void
  1180. -cdrom_check_status (ide_drive_t  *drive)
  1181. -{
  1182. -  struct packet_command pc;
  1183. -
  1184. -  memset (&pc, 0, sizeof (pc));
  1185. -
  1186. -  pc.c[0] = TEST_UNIT_READY;
  1187. -
  1188. -  (void) cdrom_queue_packet_command (drive, &pc);
  1189. -}
  1190. -
  1191. -
  1192.  static int
  1193. -cdrom_request_sense (ide_drive_t *drive, struct atapi_request_sense *reqbuf)
  1194. +cdrom_check_status (ide_drive_t  *drive,
  1195. +            struct atapi_request_sense *reqbuf)
  1196.  {
  1197.    struct packet_command pc;
  1198.  
  1199.    memset (&pc, 0, sizeof (pc));
  1200.  
  1201. -  pc.c[0] = REQUEST_SENSE;
  1202. -  pc.c[4] = sizeof (*reqbuf);
  1203. -  pc.buffer = (char *)reqbuf;
  1204. -  pc.buflen = sizeof (*reqbuf);
  1205. +  pc.sense_data = reqbuf;
  1206. +  pc.c[0] = TEST_UNIT_READY;
  1207.  
  1208.    return cdrom_queue_packet_command (drive, &pc);
  1209.  }
  1210.  
  1211.  
  1212. -#if 0
  1213.  /* Lock the door if LOCKFLAG is nonzero; unlock it otherwise. */
  1214.  static int
  1215. -cdrom_lockdoor (ide_drive_t *drive, int lockflag)
  1216. +cdrom_lockdoor (ide_drive_t *drive, int lockflag,
  1217. +        struct atapi_request_sense *reqbuf)
  1218.  {
  1219. +  struct atapi_request_sense my_reqbuf;
  1220. +  int stat;
  1221.    struct packet_command pc;
  1222.  
  1223. -  memset (&pc, 0, sizeof (pc));
  1224. +  if (reqbuf == NULL)
  1225. +    reqbuf = &my_reqbuf;
  1226.  
  1227. -  pc.c[0] = ALLOW_MEDIUM_REMOVAL;
  1228. -  pc.c[4] = (lockflag != 0);
  1229. -  return cdrom_queue_packet_command (drive, &pc);
  1230. +  /* If the drive cannot lock the door, just pretend. */
  1231. +  if (CDROM_CONFIG_FLAGS (drive)->no_doorlock)
  1232. +    stat = 0;
  1233. +  else
  1234. +    {
  1235. +      memset (&pc, 0, sizeof (pc));
  1236. +      pc.sense_data = reqbuf;
  1237. +
  1238. +      pc.c[0] = ALLOW_MEDIUM_REMOVAL;
  1239. +      pc.c[4] = (lockflag != 0);
  1240. +      stat = cdrom_queue_packet_command (drive, &pc);
  1241. +    }
  1242. +
  1243. +  if (stat == 0)
  1244. +    CDROM_STATE_FLAGS (drive)->door_locked = lockflag;
  1245. +  else
  1246. +    {
  1247. +      /* If we got an illegal field error, the drive
  1248. +     probably cannot lock the door. */
  1249. +      if (reqbuf->sense_key == ILLEGAL_REQUEST && reqbuf->asc == 0x24)
  1250. +    {
  1251. +      printk ("%s: door locking not supported\n", drive->name);
  1252. +      CDROM_CONFIG_FLAGS (drive)->no_doorlock = 1;
  1253. +      stat = 0;
  1254. +      CDROM_STATE_FLAGS (drive)->door_locked = lockflag;
  1255. +    }
  1256. +    }
  1257. +  return stat;
  1258.  }
  1259. -#endif
  1260.  
  1261.  
  1262.  /* Eject the disk if EJECTFLAG is 0.
  1263.     If EJECTFLAG is 1, try to reload the disk. */
  1264.  static int
  1265. -cdrom_eject (ide_drive_t *drive, int ejectflag)
  1266. +cdrom_eject (ide_drive_t *drive, int ejectflag,
  1267. +         struct atapi_request_sense *reqbuf)
  1268.  {
  1269.    struct packet_command pc;
  1270.  
  1271.    memset (&pc, 0, sizeof (pc));
  1272. +  pc.sense_data = reqbuf;
  1273.  
  1274.    pc.c[0] = START_STOP;
  1275.    pc.c[4] = 2 + (ejectflag != 0);
  1276. @@ -1435,11 +1611,13 @@
  1277.  
  1278.  
  1279.  static int
  1280. -cdrom_pause (ide_drive_t *drive, int pauseflag)
  1281. +cdrom_pause (ide_drive_t *drive, int pauseflag,
  1282. +         struct atapi_request_sense *reqbuf)
  1283.  {
  1284.    struct packet_command pc;
  1285.  
  1286.    memset (&pc, 0, sizeof (pc));
  1287. +  pc.sense_data = reqbuf;
  1288.  
  1289.    pc.c[0] = SCMD_PAUSE_RESUME;
  1290.    pc.c[8] = !pauseflag;
  1291. @@ -1448,11 +1626,13 @@
  1292.  
  1293.  
  1294.  static int
  1295. -cdrom_startstop (ide_drive_t *drive, int startflag)
  1296. +cdrom_startstop (ide_drive_t *drive, int startflag,
  1297. +         struct atapi_request_sense *reqbuf)
  1298.  {
  1299.    struct packet_command pc;
  1300.  
  1301.    memset (&pc, 0, sizeof (pc));
  1302. +  pc.sense_data = reqbuf;
  1303.  
  1304.    pc.c[0] = START_STOP;
  1305.    pc.c[1] = 1;
  1306. @@ -1462,12 +1642,44 @@
  1307.  
  1308.  
  1309.  static int
  1310. +cdrom_read_capacity (ide_drive_t *drive, unsigned *capacity,
  1311. +             struct atapi_request_sense *reqbuf)
  1312. +{
  1313. +  struct {
  1314. +    unsigned lba;
  1315. +    unsigned blocklen;
  1316. +  } capbuf;
  1317. +
  1318. +  int stat;
  1319. +  struct packet_command pc;
  1320. +
  1321. +  memset (&pc, 0, sizeof (pc));
  1322. +  pc.sense_data = reqbuf;
  1323. +
  1324. +  pc.c[0] = READ_CAPACITY;
  1325. +  pc.buffer = (char *)&capbuf;
  1326. +  pc.buflen = sizeof (capbuf);
  1327. +
  1328. +  stat = cdrom_queue_packet_command (drive, &pc);
  1329. +  if (stat == 0)
  1330. +    {
  1331. +      byte_swap_long (&capbuf.lba);
  1332. +      *capacity = capbuf.lba;
  1333. +    }
  1334. +
  1335. +  return stat;
  1336. +}
  1337. +
  1338. +
  1339. +static int
  1340.  cdrom_read_tocentry (ide_drive_t *drive, int trackno, int msf_flag,
  1341. -                     char *buf, int buflen)
  1342. +                     int format, char *buf, int buflen,
  1343. +             struct atapi_request_sense *reqbuf)
  1344.  {
  1345.    struct packet_command pc;
  1346.  
  1347.    memset (&pc, 0, sizeof (pc));
  1348. +  pc.sense_data = reqbuf;
  1349.  
  1350.    pc.buffer =  buf;
  1351.    pc.buflen = buflen;
  1352. @@ -1475,6 +1687,7 @@
  1353.    pc.c[6] = trackno;
  1354.    pc.c[7] = (buflen >> 8);
  1355.    pc.c[8] = (buflen & 0xff);
  1356. +  pc.c[9] = (format << 6);
  1357.    if (msf_flag) pc.c[1] = 2;
  1358.    return cdrom_queue_packet_command (drive, &pc);
  1359.  }
  1360. @@ -1482,11 +1695,16 @@
  1361.  
  1362.  /* Try to read the entire TOC for the disk into our internal buffer. */
  1363.  static int
  1364. -cdrom_read_toc (ide_drive_t *drive)
  1365. +cdrom_read_toc (ide_drive_t *drive,
  1366. +        struct atapi_request_sense *reqbuf)
  1367.  {
  1368.    int msf_flag;
  1369.    int stat, ntracks, i;
  1370.    struct atapi_toc *toc = drive->cdrom_info.toc;
  1371. +  struct {
  1372. +    struct atapi_toc_header hdr;
  1373. +    struct atapi_toc_entry  ent;
  1374. +  } ms_tmp;
  1375.  
  1376.    if (toc == NULL)
  1377.      {
  1378. @@ -1504,18 +1722,19 @@
  1379.  
  1380.    /* Check to see if the existing data is still valid.
  1381.       If it is, just return. */
  1382. -  if (CDROM_FLAGS (drive)->toc_valid)
  1383. -    cdrom_check_status (drive);
  1384. +  if (CDROM_STATE_FLAGS (drive)->toc_valid)
  1385. +    (void) cdrom_check_status (drive, NULL);
  1386.  
  1387. -  if (CDROM_FLAGS (drive)->toc_valid) return 0;
  1388. +  if (CDROM_STATE_FLAGS (drive)->toc_valid) return 0;
  1389.  
  1390.    /* Some drives can't return TOC data in LBA format. */
  1391. -  msf_flag = (CDROM_FLAGS (drive)->no_lba_toc);
  1392. +  msf_flag = (CDROM_CONFIG_FLAGS (drive)->no_lba_toc);
  1393.  
  1394.    /* First read just the header, so we know how long the TOC is. */
  1395. -  stat = cdrom_read_tocentry (drive, 0, msf_flag, (char *)toc,
  1396. +  stat = cdrom_read_tocentry (drive, 0, msf_flag, 0, (char *)&toc->hdr,
  1397.                                sizeof (struct atapi_toc_header) +
  1398. -                              sizeof (struct atapi_toc_entry));
  1399. +                              sizeof (struct atapi_toc_entry),
  1400. +                  reqbuf);
  1401.    if (stat) return stat;
  1402.  
  1403.    ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
  1404. @@ -1523,9 +1742,10 @@
  1405.    if (ntracks > MAX_TRACKS) ntracks = MAX_TRACKS;
  1406.  
  1407.    /* Now read the whole schmeer. */
  1408. -  stat = cdrom_read_tocentry (drive, 0, msf_flag, (char *)toc,
  1409. +  stat = cdrom_read_tocentry (drive, 0, msf_flag, 0, (char *)&toc->hdr,
  1410.                                sizeof (struct atapi_toc_header) +
  1411. -                              (ntracks+1) * sizeof (struct atapi_toc_entry));
  1412. +                              (ntracks+1) * sizeof (struct atapi_toc_entry),
  1413. +                  reqbuf);
  1414.    if (stat) return stat;
  1415.    byte_swap_word (&toc->hdr.toc_length);
  1416.    for (i=0; i<=ntracks; i++)
  1417. @@ -1539,8 +1759,32 @@
  1418.      byte_swap_long (&toc->ent[i].lba);
  1419.      }
  1420.  
  1421. +  /* Read the multisession information. */
  1422. +  stat = cdrom_read_tocentry (drive, 0, msf_flag, 1,
  1423. +                  (char *)&ms_tmp, sizeof (ms_tmp),
  1424. +                  reqbuf);
  1425. +  if (stat) return stat;
  1426. +  if (msf_flag)
  1427. +    {
  1428. +      byte *adr = (byte *)&(ms_tmp.ent.lba);
  1429. +      toc->last_session_lba = msf_to_lba (adr[1], adr[2], adr[3]);
  1430. +    }
  1431. +  else
  1432. +    {
  1433. +      byte_swap_long (&ms_tmp.ent.lba);
  1434. +      toc->last_session_lba = ms_tmp.ent.lba;
  1435. +    }
  1436. +  toc->xa_flag = (ms_tmp.hdr.first_track != ms_tmp.hdr.last_track);
  1437. +
  1438. +  /* Now try to get the total cdrom capacity. */
  1439. +  stat = cdrom_read_capacity (drive, &toc->capacity, reqbuf);
  1440. +  if (stat) toc->capacity = 0x1fffff;
  1441. +
  1442. +  HWIF(drive)->gd->sizes[drive->select.b.unit << PARTN_BITS]
  1443. +    = toc->capacity * SECTORS_PER_FRAME;
  1444. +
  1445.    /* Remember that we've read this stuff. */
  1446. -  CDROM_FLAGS (drive)->toc_valid = 1;
  1447. +  CDROM_STATE_FLAGS (drive)->toc_valid = 1;
  1448.  
  1449.    return 0;
  1450.  }
  1451. @@ -1548,11 +1792,13 @@
  1452.  
  1453.  static int
  1454.  cdrom_read_subchannel (ide_drive_t *drive,
  1455. -                       char *buf, int buflen)
  1456. +                       char *buf, int buflen,
  1457. +               struct atapi_request_sense *reqbuf)
  1458.  {
  1459.    struct packet_command pc;
  1460.  
  1461.    memset (&pc, 0, sizeof (pc));
  1462. +  pc.sense_data = reqbuf;
  1463.  
  1464.    pc.buffer =  buf;
  1465.    pc.buflen = buflen;
  1466. @@ -1568,11 +1814,13 @@
  1467.  /* modeflag: 0 = current, 1 = changeable mask, 2 = default, 3 = saved */
  1468.  static int
  1469.  cdrom_mode_sense (ide_drive_t *drive, int pageno, int modeflag,
  1470. -                  char *buf, int buflen)
  1471. +                  char *buf, int buflen,
  1472. +          struct atapi_request_sense *reqbuf)
  1473.  {
  1474.    struct packet_command pc;
  1475.  
  1476.    memset (&pc, 0, sizeof (pc));
  1477. +  pc.sense_data = reqbuf;
  1478.  
  1479.    pc.buffer =  buf;
  1480.    pc.buflen = buflen;
  1481. @@ -1585,11 +1833,13 @@
  1482.  
  1483.  
  1484.  static int
  1485. -cdrom_mode_select (ide_drive_t *drive, int pageno, char *buf, int buflen)
  1486. +cdrom_mode_select (ide_drive_t *drive, int pageno, char *buf, int buflen,
  1487. +           struct atapi_request_sense *reqbuf)
  1488.  {
  1489.    struct packet_command pc;
  1490.  
  1491.    memset (&pc, 0, sizeof (pc));
  1492. +  pc.sense_data = reqbuf;
  1493.  
  1494.    pc.buffer =  buf;
  1495.    pc.buflen = - buflen;
  1496. @@ -1603,11 +1853,13 @@
  1497.  
  1498.  
  1499.  static int
  1500. -cdrom_play_lba_range_play12 (ide_drive_t *drive, int lba_start, int lba_end)
  1501. +cdrom_play_lba_range_play12 (ide_drive_t *drive, int lba_start, int lba_end,
  1502. +                 struct atapi_request_sense *reqbuf)
  1503.  {
  1504.    struct packet_command pc;
  1505.  
  1506.    memset (&pc, 0, sizeof (pc));
  1507. +  pc.sense_data = reqbuf;
  1508.  
  1509.    pc.c[0] = SCMD_PLAYAUDIO12;
  1510.    *(int *)(&pc.c[2]) = lba_start;
  1511. @@ -1620,17 +1872,19 @@
  1512.  
  1513.  
  1514.  static int
  1515. -cdrom_play_lba_range_msf (ide_drive_t *drive, int lba_start, int lba_end)
  1516. +cdrom_play_lba_range_msf (ide_drive_t *drive, int lba_start, int lba_end,
  1517. +              struct atapi_request_sense *reqbuf)
  1518.  {
  1519.    struct packet_command pc;
  1520.  
  1521.    memset (&pc, 0, sizeof (pc));
  1522. +  pc.sense_data = reqbuf;
  1523.  
  1524.    pc.c[0] = SCMD_PLAYAUDIO_MSF;
  1525.    lba_to_msf (lba_start, &pc.c[3], &pc.c[4], &pc.c[5]);
  1526.    lba_to_msf (lba_end-1, &pc.c[6], &pc.c[7], &pc.c[8]);
  1527.  
  1528. -  if (CDROM_FLAGS (drive)->msf_as_bcd)
  1529. +  if (CDROM_CONFIG_FLAGS (drive)->msf_as_bcd)
  1530.      {
  1531.        pc.c[3] = bin2bcd (pc.c[3]);
  1532.        pc.c[4] = bin2bcd (pc.c[4]);
  1533. @@ -1647,7 +1901,8 @@
  1534.  /* Play audio starting at LBA LBA_START and finishing with the
  1535.     LBA before LBA_END. */
  1536.  static int
  1537. -cdrom_play_lba_range (ide_drive_t *drive, int lba_start, int lba_end)
  1538. +cdrom_play_lba_range (ide_drive_t *drive, int lba_start, int lba_end,
  1539. +              struct atapi_request_sense *reqbuf)
  1540.  {
  1541.    /* This is rather annoying.
  1542.       My NEC-260 won't recognize group 5 commands such as PLAYAUDIO12;
  1543. @@ -1660,27 +1915,29 @@
  1544.       great.  Otherwise, if the drive reports an illegal command code,
  1545.       try PLAYAUDIO_MSF using the NEC 260-style bcd parameters. */
  1546.  
  1547. -  if (CDROM_FLAGS (drive)->no_playaudio12)
  1548. -    return cdrom_play_lba_range_msf (drive, lba_start, lba_end);
  1549. +  if (CDROM_CONFIG_FLAGS (drive)->no_playaudio12)
  1550. +    return cdrom_play_lba_range_msf (drive, lba_start, lba_end, reqbuf);
  1551.    else
  1552.      {
  1553.        int stat;
  1554. -      struct atapi_request_sense *reqbuf;
  1555. +      struct atapi_request_sense my_reqbuf;
  1556.  
  1557. -      stat = cdrom_play_lba_range_play12 (drive, lba_start, lba_end);
  1558. +      if (reqbuf == NULL)
  1559. +    reqbuf = &my_reqbuf;
  1560. +
  1561. +      stat = cdrom_play_lba_range_play12 (drive, lba_start, lba_end, reqbuf);
  1562.        if (stat == 0) return 0;
  1563.  
  1564.        /* It failed.  Try to find out why. */
  1565. -      reqbuf = &drive->cdrom_info.sense_data;
  1566. -      if (reqbuf->sense_key == 0x05 && reqbuf->asc == 0x20)
  1567. +      if (reqbuf->sense_key == ILLEGAL_REQUEST && reqbuf->asc == 0x20)
  1568.          {
  1569.            /* The drive didn't recognize the command.
  1570.               Retry with the MSF variant. */
  1571.            printk ("%s: Drive does not support PLAYAUDIO12; "
  1572.                    "trying PLAYAUDIO_MSF\n", drive->name);
  1573. -          CDROM_FLAGS (drive)->no_playaudio12 = 1;
  1574. -          CDROM_FLAGS (drive)->msf_as_bcd = 1;
  1575. -          return cdrom_play_lba_range_msf (drive, lba_start, lba_end);
  1576. +          CDROM_CONFIG_FLAGS (drive)->no_playaudio12 = 1;
  1577. +          CDROM_CONFIG_FLAGS (drive)->msf_as_bcd = 1;
  1578. +          return cdrom_play_lba_range_msf (drive, lba_start, lba_end, reqbuf);
  1579.          }
  1580.  
  1581.        /* Failed for some other reason.  Give up. */
  1582. @@ -1691,13 +1948,14 @@
  1583.  
  1584.  static
  1585.  int cdrom_get_toc_entry (ide_drive_t *drive, int track,
  1586. -                         struct atapi_toc_entry **ent)
  1587. +                         struct atapi_toc_entry **ent,
  1588. +             struct atapi_request_sense *reqbuf)
  1589.  {
  1590.    int stat, ntracks;
  1591.    struct atapi_toc *toc;
  1592.  
  1593.    /* Make sure our saved TOC is valid. */
  1594. -  stat = cdrom_read_toc (drive);
  1595. +  stat = cdrom_read_toc (drive, reqbuf);
  1596.    if (stat) return stat;
  1597.  
  1598.    toc = drive->cdrom_info.toc;
  1599. @@ -1716,25 +1974,94 @@
  1600.  }
  1601.  
  1602.  
  1603. +static int
  1604. +cdrom_read_block (ide_drive_t *drive, int format, int lba,
  1605. +          char *buf, int buflen,
  1606. +          struct atapi_request_sense *reqbuf)
  1607. +{
  1608. +  struct packet_command pc;
  1609. +  struct atapi_request_sense my_reqbuf;
  1610. +  int stat;
  1611. +
  1612. +  if (reqbuf == NULL)
  1613. +    reqbuf = &my_reqbuf;
  1614. +
  1615. +  memset (&pc, 0, sizeof (pc));
  1616. +  pc.sense_data = reqbuf;
  1617. +
  1618. +  pc.buffer = buf;
  1619. +  pc.buflen = buflen;
  1620. +
  1621. +  if (CDROM_CONFIG_FLAGS (drive)->old_readcd)
  1622. +    pc.c[0] = 0xd4;
  1623. +  else
  1624. +    pc.c[0] = READ_CD;
  1625. +
  1626. +  pc.c[1] = (format << 2);
  1627. +  *(int *)(&pc.c[2]) = lba;
  1628. +  byte_swap_long ((int *)(&pc.c[2]));
  1629. +  pc.c[8] = 1;  /* one block */
  1630. +  pc.c[9] = 0x10;
  1631. +
  1632. +  stat = cdrom_queue_packet_command (drive, &pc);
  1633. +
  1634. +  /* If the drive doesn't recognize the READ CD opcode, retry the command
  1635. +     with an older opcode for that command. */
  1636. +  if (stat && reqbuf->sense_key == ILLEGAL_REQUEST && reqbuf->asc == 0x20 &&
  1637. +      CDROM_CONFIG_FLAGS (drive)->old_readcd == 0)
  1638. +    {
  1639. +      printk ("%s: Drive does not recognize READ_CD; trying opcode 0xd4\n",
  1640. +          drive->name);
  1641. +      CDROM_CONFIG_FLAGS (drive)->old_readcd = 1;
  1642. +      return cdrom_read_block (drive, format, lba, buf, buflen, reqbuf);
  1643. +    }
  1644. +
  1645. +  return stat;
  1646. +}
  1647. +
  1648. +
  1649.  int ide_cdrom_ioctl (ide_drive_t *drive, struct inode *inode,
  1650. -                        struct file *file, unsigned int cmd, unsigned long arg)
  1651. +             struct file *file, unsigned int cmd, unsigned long arg)
  1652.  {
  1653.    switch (cmd)
  1654.      {
  1655.      case CDROMEJECT:
  1656. -      return cdrom_eject (drive, 0);
  1657. +      {
  1658. +    int stat;
  1659. +
  1660. +    if (drive->usage > 1)
  1661. +      return -EBUSY;
  1662. +
  1663. +    stat = cdrom_lockdoor (drive, 0, NULL);
  1664. +    if (stat) return stat;
  1665. +
  1666. +    return cdrom_eject (drive, 0, NULL);
  1667. +      }
  1668. +
  1669. +    case CDROMEJECT_SW:
  1670. +      {
  1671. +    CDROM_STATE_FLAGS (drive)->eject_on_close = arg;
  1672. +    return 0;
  1673. +      }
  1674.  
  1675.      case CDROMPAUSE:
  1676. -      return cdrom_pause (drive, 1);
  1677. +      return cdrom_pause (drive, 1, NULL);
  1678.  
  1679.      case CDROMRESUME:
  1680. -      return cdrom_pause (drive, 0);
  1681. +      return cdrom_pause (drive, 0, NULL);
  1682.  
  1683.      case CDROMSTART:
  1684. -      return cdrom_startstop (drive, 1);
  1685. +      return cdrom_startstop (drive, 1, NULL);
  1686.  
  1687.      case CDROMSTOP:
  1688. -      return cdrom_startstop (drive, 0);
  1689. +      {
  1690. +    int stat;
  1691. +
  1692. +    stat = cdrom_startstop (drive, 0, NULL);
  1693. +    if (stat) return stat;
  1694. +    /* pit says the Dolphin needs this. */
  1695. +    return cdrom_eject (drive, 1, NULL);
  1696. +      }
  1697.  
  1698.      case CDROMPLAYMSF:
  1699.        {
  1700. @@ -1753,7 +2080,7 @@
  1701.  
  1702.          if (lba_end <= lba_start) return -EINVAL;
  1703.  
  1704. -        return cdrom_play_lba_range (drive, lba_start, lba_end);
  1705. +        return cdrom_play_lba_range (drive, lba_start, lba_end, NULL);
  1706.        }
  1707.  
  1708.      /* Like just about every other Linux cdrom driver, we ignore the
  1709. @@ -1769,9 +2096,9 @@
  1710.  
  1711.          memcpy_fromfs (&ti, (void *) arg, sizeof(ti));
  1712.  
  1713. -        stat = cdrom_get_toc_entry (drive, ti.cdti_trk0, &first_toc);
  1714. +        stat = cdrom_get_toc_entry (drive, ti.cdti_trk0, &first_toc, NULL);
  1715.          if (stat) return stat;
  1716. -        stat = cdrom_get_toc_entry (drive, ti.cdti_trk1, &last_toc);
  1717. +        stat = cdrom_get_toc_entry (drive, ti.cdti_trk1, &last_toc, NULL);
  1718.          if (stat) return stat;
  1719.  
  1720.          if (ti.cdti_trk1 != CDROM_LEADOUT) ++last_toc;
  1721. @@ -1780,7 +2107,7 @@
  1722.  
  1723.          if (lba_end <= lba_start) return -EINVAL;
  1724.  
  1725. -        return cdrom_play_lba_range (drive, lba_start, lba_end);
  1726. +        return cdrom_play_lba_range (drive, lba_start, lba_end, NULL);
  1727.        }
  1728.  
  1729.      case CDROMREADTOCHDR:
  1730. @@ -1793,7 +2120,7 @@
  1731.          if (stat) return stat;
  1732.  
  1733.          /* Make sure our saved TOC is valid. */
  1734. -        stat = cdrom_read_toc (drive);
  1735. +        stat = cdrom_read_toc (drive, NULL);
  1736.          if (stat) return stat;
  1737.  
  1738.          toc = drive->cdrom_info.toc;
  1739. @@ -1818,7 +2145,7 @@
  1740.  
  1741.          memcpy_fromfs (&tocentry, (void *) arg, sizeof (tocentry));
  1742.  
  1743. -        stat = cdrom_get_toc_entry (drive, tocentry.cdte_track, &toce);
  1744. +        stat = cdrom_get_toc_entry (drive, tocentry.cdte_track, &toce, NULL);
  1745.          if (stat) return stat;
  1746.  
  1747.          tocentry.cdte_ctrl = toce->control;
  1748. @@ -1853,7 +2180,7 @@
  1749.  
  1750.          memcpy_fromfs (&subchnl, (void *) arg, sizeof (subchnl));
  1751.  
  1752. -        stat = cdrom_read_subchannel (drive, buffer, sizeof (buffer));
  1753. +        stat = cdrom_read_subchannel (drive, buffer, sizeof (buffer), NULL);
  1754.          if (stat) return stat;
  1755.  
  1756.          abs_lba = *(int *)&buffer[8];
  1757. @@ -1898,9 +2225,9 @@
  1758.          if (stat) return stat;
  1759.          memcpy_fromfs (&volctrl, (void *) arg, sizeof (volctrl));
  1760.  
  1761. -        stat = cdrom_mode_sense (drive, 0x0e, 0, buffer, sizeof (buffer));
  1762. +        stat = cdrom_mode_sense (drive, 0x0e, 0, buffer, sizeof (buffer),NULL);
  1763.          if (stat) return stat;
  1764. -        stat = cdrom_mode_sense (drive, 0x0e, 1, mask  , sizeof (buffer));
  1765. +        stat = cdrom_mode_sense (drive, 0x0e, 1, mask  , sizeof (buffer),NULL);
  1766.          if (stat) return stat;
  1767.  
  1768.          buffer[1] = buffer[2] = 0;
  1769. @@ -1910,35 +2237,219 @@
  1770.          buffer[21] = volctrl.channel2 & mask[21];
  1771.          buffer[23] = volctrl.channel3 & mask[23];
  1772.  
  1773. -        return cdrom_mode_select (drive, 0x0e, buffer, sizeof (buffer));
  1774. +        return cdrom_mode_select (drive, 0x0e, buffer, sizeof (buffer), NULL);
  1775. +      }
  1776. +
  1777. +    case CDROMVOLREAD:
  1778. +      {
  1779. +        struct cdrom_volctrl volctrl;
  1780. +        char buffer[24];
  1781. +        int stat;
  1782. +
  1783. +        stat = verify_area (VERIFY_WRITE, (void *) arg, sizeof (volctrl));
  1784. +        if (stat) return stat;
  1785. +
  1786. +        stat = cdrom_mode_sense (drive, 0x0e, 0, buffer, sizeof (buffer), NULL);
  1787. +        if (stat) return stat;
  1788. +
  1789. +        volctrl.channel0 = buffer[17];
  1790. +        volctrl.channel1 = buffer[19];
  1791. +        volctrl.channel2 = buffer[21];
  1792. +        volctrl.channel3 = buffer[23];
  1793. +
  1794. +        memcpy_tofs ((void *) arg, &volctrl, sizeof (volctrl));
  1795. +
  1796. +    return 0;
  1797. +      }
  1798. +
  1799. +    case CDROMMULTISESSION:
  1800. +      {
  1801. +    struct cdrom_multisession ms_info;
  1802. +    struct atapi_toc *toc;
  1803. +    int stat;
  1804. +
  1805. +    stat = verify_area (VERIFY_READ,  (void *)arg, sizeof (ms_info));
  1806. +        if (stat) return stat;
  1807. +    stat = verify_area (VERIFY_WRITE, (void *)arg, sizeof (ms_info));
  1808. +        if (stat) return stat;
  1809. +
  1810. +    memcpy_fromfs (&ms_info, (void *)arg, sizeof (ms_info));
  1811. +
  1812. +    /* Make sure the TOC information is valid. */
  1813. +    stat = cdrom_read_toc (drive, NULL);
  1814. +    if (stat) return stat;
  1815. +
  1816. +    toc = drive->cdrom_info.toc;
  1817. +
  1818. +    if (ms_info.addr_format == CDROM_MSF)
  1819. +      lba_to_msf (toc->last_session_lba,
  1820. +              &ms_info.addr.msf.minute,
  1821. +              &ms_info.addr.msf.second,
  1822. +              &ms_info.addr.msf.frame);
  1823. +
  1824. +    else if (ms_info.addr_format == CDROM_LBA)
  1825. +      ms_info.addr.lba = toc->last_session_lba;
  1826. +
  1827. +    else
  1828. +      return -EINVAL;
  1829. +
  1830. +    ms_info.xa_flag = toc->xa_flag;
  1831. +
  1832. +    memcpy_tofs ((void *)arg, &ms_info, sizeof (ms_info));
  1833. +
  1834. +    return 0;
  1835. +      }
  1836. +
  1837. +    /* Read 2352 byte blocks from audio tracks. */
  1838. +    case CDROMREADAUDIO:
  1839. +      {
  1840. +    int stat, lba;
  1841. +    struct atapi_toc *toc;
  1842. +    struct cdrom_read_audio ra;
  1843. +    char buf[CD_FRAMESIZE_RAW];
  1844. +
  1845. +    /* Make sure the TOC is up to date. */
  1846. +    stat = cdrom_read_toc (drive, NULL);
  1847. +    if (stat) return stat;
  1848. +
  1849. +    toc = drive->cdrom_info.toc;
  1850. +
  1851. +    stat = verify_area (VERIFY_READ, (char *)arg, sizeof (ra));
  1852. +    if (stat) return stat;
  1853. +
  1854. +    memcpy_fromfs (&ra, (void *)arg, sizeof (ra));
  1855. +
  1856. +    if (ra.nframes < 0 || ra.nframes > toc->capacity)
  1857. +      return -EINVAL;
  1858. +    else if (ra.nframes == 0)
  1859. +      return 0;
  1860. +
  1861. +    stat = verify_area (VERIFY_WRITE, (char *)ra.buf,
  1862. +                              ra.nframes * CD_FRAMESIZE_RAW);
  1863. +    if (stat) return stat;
  1864. +
  1865. +    if (ra.addr_format == CDROM_MSF)
  1866. +      lba = msf_to_lba (ra.addr.msf.minute, ra.addr.msf.second,
  1867. +                ra.addr.msf.frame);
  1868. +    
  1869. +    else if (ra.addr_format == CDROM_LBA)
  1870. +      lba = ra.addr.lba;
  1871. +
  1872. +    else
  1873. +      return -EINVAL;
  1874. +
  1875. +    if (lba < 0 || lba >= toc->capacity)
  1876. +      return -EINVAL;
  1877. +
  1878. +    while (ra.nframes > 0)
  1879. +      {
  1880. +        stat = cdrom_read_block (drive, 1, lba, buf,
  1881. +                     CD_FRAMESIZE_RAW, NULL);
  1882. +        if (stat) return stat;
  1883. +        memcpy_tofs (ra.buf, buf, CD_FRAMESIZE_RAW);
  1884. +        ra.buf += CD_FRAMESIZE_RAW;
  1885. +        --ra.nframes;
  1886. +        ++lba;
  1887. +      }
  1888. +
  1889. +    return 0;
  1890. +      }
  1891. +
  1892. +    case CDROMREADMODE1:
  1893. +    case CDROMREADMODE2:
  1894. +      {
  1895. +    struct cdrom_msf msf;
  1896. +    int blocksize, format, stat, lba;
  1897. +    struct atapi_toc *toc;
  1898. +    char buf[CD_FRAMESIZE_RAW0];
  1899. +
  1900. +    if (cmd == CDROMREADMODE1)
  1901. +      {
  1902. +        blocksize = CD_FRAMESIZE;
  1903. +        format = 2;
  1904. +      }
  1905. +    else
  1906. +      {
  1907. +        blocksize = CD_FRAMESIZE_RAW0;
  1908. +        format = 3;
  1909. +      }
  1910. +
  1911. +    stat = verify_area (VERIFY_READ, (char *)arg, sizeof (msf));
  1912. +    if (stat) return stat;
  1913. +    stat = verify_area (VERIFY_WRITE, (char *)arg, blocksize);
  1914. +    if (stat) return stat;
  1915. +
  1916. +    memcpy_fromfs (&msf, (void *)arg, sizeof (msf));
  1917. +
  1918. +    lba = msf_to_lba (msf.cdmsf_min0, msf.cdmsf_sec0, msf.cdmsf_frame0);
  1919. +    
  1920. +    /* Make sure the TOC is up to date. */
  1921. +    stat = cdrom_read_toc (drive, NULL);
  1922. +    if (stat) return stat;
  1923. +
  1924. +    toc = drive->cdrom_info.toc;
  1925. +
  1926. +    if (lba < 0 || lba >= toc->capacity)
  1927. +      return -EINVAL;
  1928. +
  1929. +    stat = cdrom_read_block (drive, format, lba, buf, blocksize, NULL);
  1930. +    if (stat) return stat;
  1931. +
  1932. +    memcpy_tofs ((char *)arg, buf, blocksize);
  1933. +    return 0;
  1934.        }
  1935.  
  1936. +#if 0 /* Doesn't work reliably yet. */
  1937. +    case CDROMRESET:
  1938. +      {
  1939. +    struct request req;
  1940. +    memset (&req, 0, sizeof (req));
  1941. +    req.cmd = RESET_DRIVE_COMMAND;
  1942. +    cdrom_queue_request (drive, &req);
  1943. +    return 0;
  1944. +      }
  1945. +#endif
  1946. +
  1947. + 
  1948.  #ifdef TEST
  1949.      case 0x1234:
  1950.        {
  1951.          int stat;
  1952.          struct packet_command pc;
  1953. +    int len, lena;
  1954.  
  1955.          memset (&pc, 0, sizeof (pc));
  1956.  
  1957.          stat = verify_area (VERIFY_READ, (void *) arg, sizeof (pc.c));
  1958.          if (stat) return stat;
  1959.          memcpy_fromfs (&pc.c, (void *) arg, sizeof (pc.c));
  1960. +    arg += sizeof (pc.c);
  1961.  
  1962. -        return cdrom_queue_packet_command (drive, &pc);
  1963. -      }
  1964. +    stat = verify_area (VERIFY_READ, (void *) arg, sizeof (len));
  1965. +        if (stat) return stat;
  1966. +        memcpy_fromfs (&len, (void *) arg , sizeof (len));
  1967. +    arg += sizeof (len);
  1968.  
  1969. -    case 0x1235:
  1970. -      {
  1971. -        int stat;
  1972. -        struct atapi_request_sense reqbuf;
  1973. +    if (len > 0) {
  1974. +      stat = verify_area (VERIFY_WRITE, (void *) arg, len);
  1975. +      if (stat) return stat;
  1976. +    }
  1977.  
  1978. -        stat = verify_area (VERIFY_WRITE, (void *) arg, sizeof (reqbuf));
  1979. -        if (stat) return stat;
  1980. +    lena = len;
  1981. +    if (lena  < 0) lena = 0;
  1982.  
  1983. -        stat = cdrom_request_sense (drive, &reqbuf);
  1984. +    {
  1985. +      char buf[lena];
  1986. +      if (len > 0) {
  1987. +        pc.buflen = len;
  1988. +        pc.buffer = buf;
  1989. +      }
  1990.  
  1991. -        memcpy_tofs ((void *) arg, &reqbuf, sizeof (reqbuf));
  1992. +      stat = cdrom_queue_packet_command (drive, &pc);
  1993. +
  1994. +      if (len > 0)
  1995. +        memcpy_tofs ((void *)arg, buf, len);
  1996. +    }
  1997.  
  1998.          return stat;
  1999.        }
  2000. @@ -1960,10 +2471,10 @@
  2001.  {
  2002.    int retval;
  2003.  
  2004. -  cdrom_check_status (drive);
  2005. +  (void) cdrom_check_status (drive, NULL);
  2006.  
  2007. -  retval = CDROM_FLAGS (drive)->media_changed;
  2008. -  CDROM_FLAGS (drive)->media_changed = 0;
  2009. +  retval = CDROM_STATE_FLAGS (drive)->media_changed;
  2010. +  CDROM_STATE_FLAGS (drive)->media_changed = 0;
  2011.  
  2012.    return retval;
  2013.  }
  2014. @@ -1972,15 +2483,43 @@
  2015.  int ide_cdrom_open (struct inode *ip, struct file *fp, ide_drive_t *drive)
  2016.  {
  2017.    /* no write access */
  2018. -  if (fp->f_mode & 2) return -EROFS;
  2019. +  if (fp->f_mode & 2)
  2020. +    {
  2021. +      --drive->usage;
  2022. +      return -EROFS;
  2023. +    }
  2024.  
  2025. -#if 0 /* With this, one cannot eject a disk with workman */
  2026. -  /* If this is the first open, lock the door. */
  2027. +  /* If this is the first open, check the drive status. */
  2028.    if (drive->usage == 1)
  2029. -    (void) cdrom_lockdoor (drive, 1);
  2030. -#endif
  2031. +    {
  2032. +      int stat;
  2033. +      struct atapi_request_sense my_reqbuf;
  2034. +      my_reqbuf.sense_key = 0;
  2035. +
  2036. +      /* Get the drive status. */
  2037. +      stat = cdrom_check_status (drive, &my_reqbuf);
  2038. +
  2039. +      /* If the tray is open, try to close it. */
  2040. +      if (stat && my_reqbuf.sense_key == NOT_READY)
  2041. +    {
  2042. +      cdrom_eject (drive, 1, &my_reqbuf);
  2043. +      stat = cdrom_check_status (drive, &my_reqbuf);
  2044. +    }
  2045. +
  2046. +      /* Return an error if there are still problems. */
  2047. +      if (stat && my_reqbuf.sense_key != UNIT_ATTENTION)
  2048. +    {
  2049. +      --drive->usage;
  2050. +      return -ENXIO;
  2051. +    }
  2052. +
  2053. +      /* Now lock the door. */
  2054. +      (void) cdrom_lockdoor (drive, 1, &my_reqbuf);
  2055. +
  2056. +      /* And try to read the TOC information now. */
  2057. +      (void) cdrom_read_toc (drive, &my_reqbuf);
  2058. +    }
  2059.  
  2060. -  /* Should check that there's a disk in the drive? */
  2061.    return 0;
  2062.  }
  2063.  
  2064. @@ -1995,10 +2534,12 @@
  2065.      {
  2066.        invalidate_buffers (inode->i_rdev);
  2067.  
  2068. -#if 0
  2069.        /* Unlock the door. */
  2070. -      (void) cdrom_lockdoor (drive, 0);
  2071. -#endif
  2072. +      (void) cdrom_lockdoor (drive, 0, NULL);
  2073. +
  2074. +      /* Do an eject if we were requested to do so. */
  2075. +      if (CDROM_STATE_FLAGS (drive)->eject_on_close)
  2076. +    (void) cdrom_eject (drive, 0, NULL);
  2077.      }
  2078.  }
  2079.  
  2080. @@ -2015,28 +2556,35 @@
  2081.    drive->special.all = 0;
  2082.    drive->ready_stat = 0;
  2083.  
  2084. -  CDROM_FLAGS (drive)->media_changed = 0;
  2085. -  CDROM_FLAGS (drive)->toc_valid     = 0;
  2086. -
  2087. -  CDROM_FLAGS (drive)->no_playaudio12 = 0;
  2088. -  CDROM_FLAGS (drive)->no_lba_toc = 0;
  2089. -  CDROM_FLAGS (drive)->msf_as_bcd = 0;
  2090. -  CDROM_FLAGS (drive)->drq_interrupt = ((drive->id->config & 0x0060) == 0x20);
  2091. +  CDROM_STATE_FLAGS (drive)->media_changed = 0;
  2092. +  CDROM_STATE_FLAGS (drive)->toc_valid     = 0;
  2093. +  CDROM_STATE_FLAGS (drive)->door_locked   = 0;
  2094. +
  2095. +  /* Turn this off by default, since many people don't like it. */
  2096. +  CDROM_STATE_FLAGS (drive)->eject_on_close= 0;
  2097. +
  2098. +  CDROM_CONFIG_FLAGS (drive)->no_doorlock = 0;
  2099. +  CDROM_CONFIG_FLAGS (drive)->no_playaudio12 = 0;
  2100. +  CDROM_CONFIG_FLAGS (drive)->old_readcd = 0;
  2101. +  CDROM_CONFIG_FLAGS (drive)->no_lba_toc = 0;
  2102. +  CDROM_CONFIG_FLAGS (drive)->msf_as_bcd = 0;
  2103. +  CDROM_CONFIG_FLAGS (drive)->drq_interrupt =
  2104. +    ((drive->id->config & 0x0060) == 0x20);
  2105.  
  2106.    /* Accommodate some broken drives... */
  2107.    if (strcmp (drive->id->model, "CD220E") == 0)  /* Creative Labs */
  2108. -    CDROM_FLAGS (drive)->no_lba_toc = 1;
  2109. +    CDROM_CONFIG_FLAGS (drive)->no_lba_toc = 1;
  2110.  
  2111.    else if (strcmp (drive->id->model, "TO-ICSLYAL") == 0 ||  /* Acer CD525E */
  2112.             strcmp (drive->id->model, "OTI-SCYLLA") == 0)
  2113. -    CDROM_FLAGS (drive)->no_lba_toc = 1;
  2114. +    CDROM_CONFIG_FLAGS (drive)->no_lba_toc = 1;
  2115.  
  2116.    else if (strcmp (drive->id->model, "CDA26803I SE") == 0) /* Aztech */
  2117.      {
  2118. -      CDROM_FLAGS (drive)->no_lba_toc = 1;
  2119. +      CDROM_CONFIG_FLAGS (drive)->no_lba_toc = 1;
  2120.  
  2121.        /* This drive _also_ does not implement PLAYAUDIO12 correctly. */
  2122. -      CDROM_FLAGS (drive)->no_playaudio12 = 1;
  2123. +      CDROM_CONFIG_FLAGS (drive)->no_playaudio12 = 1;
  2124.      }
  2125.  
  2126.    drive->cdrom_info.toc               = NULL;
  2127. @@ -2046,19 +2594,14 @@
  2128.  }
  2129.  
  2130.  
  2131. -#undef MIN
  2132. -#undef SECTOR_SIZE
  2133. -#undef SECTOR_BITS
  2134. -
  2135.  
  2136.  /*
  2137.   * TODO:
  2138. - *  Read actual disk capacity.
  2139. - *  Multisession support.
  2140. - *  Direct reading of audio data.
  2141. - *  Eject-on-dismount.
  2142. - *  Lock door while there's a mounted volume.
  2143. + *  CDROM_GET_UPC
  2144. + *  CDROMRESET
  2145. + *  Lock the door when a read request completes successfully and the
  2146. + *   door is not already locked.  Also try to reorganize to reduce
  2147. + *   duplicated functionality between read and ioctl paths?
  2148.   *  Establish interfaces for an IDE port driver, and break out the cdrom
  2149.   *   code into a loadable module.
  2150.   */
  2151. -
  2152. diff -u --recursive --new-file v1.3.22/linux/drivers/block/ide.c linux/drivers/block/ide.c
  2153. --- v1.3.22/linux/drivers/block/ide.c    Sun Sep  3 12:26:51 1995
  2154. +++ linux/drivers/block/ide.c    Sun Sep  3 12:03:00 1995
  2155. @@ -1,5 +1,5 @@
  2156.  /*
  2157. - *  linux/drivers/block/ide.c    Version 5.11  Aug 29, 1995
  2158. + *  linux/drivers/block/ide.c    Version 5.12  Sep 1, 1995
  2159.   *
  2160.   *  Copyright (C) 1994, 1995  Linus Torvalds & authors (see below)
  2161.   */
  2162. @@ -130,15 +130,24 @@
  2163.   *            added automatic PCI CMD640 detection/support
  2164.   *            added option for VLB CMD640 support
  2165.   *            tweaked probe to find cdrom on hdb with disks on hda,hdc
  2166. + *  Version 5.12    some performance tuning
  2167. + *            added message to alert user to bad /dev/hd[cd] entries
  2168. + *            OOOPS!  fixed bug in atapi reset
  2169. + *            driver now forces "serialize" again for all cmd640 chips
  2170. + *            noticed REALLY_SLOW_IO had no effect, moved it to ide.c
  2171. + *            made do_drive_cmd() into public ide_do_drive_cmd()
  2172.   *
  2173.   *  Driver compile-time options are in ide.h
  2174.   *
  2175.   *  To do, in likely order of completion:
  2176. - *    - improved CMD support:  probably handing this off to someone else
  2177. + *    - add ioctls to get/set interface timings on cmd640, ht6560b, triton
  2178.   *    - modify kernel to obtain BIOS geometry for drives on 2nd/3rd/4th i/f
  2179. + *    - improved CMD support:  probably handing this off to someone else
  2180.   *    - find someone to work on IDE *tape drive* support
  2181.   */
  2182.  
  2183. +#undef REALLY_SLOW_IO        /* most systems can safely undef this */
  2184. +
  2185.  #include <linux/config.h>
  2186.  #include <linux/types.h>
  2187.  #include <linux/string.h>
  2188. @@ -156,6 +165,7 @@
  2189.  #include <asm/byteorder.h>
  2190.  #include <asm/irq.h>
  2191.  #include <asm/segment.h>
  2192. +#include <asm/io.h>
  2193.  
  2194.  #ifdef CONFIG_PCI
  2195.  #include <linux/bios32.h>
  2196. @@ -239,7 +249,7 @@
  2197.          /* fill in any non-zero initial values */
  2198.          hwif->noprobe    = (h > 1);
  2199.          hwif->io_base    = default_io_base[h];
  2200. -        hwif->ctl_port    = hwif->io_base ? hwif->io_base + 0x206 : 0x000;
  2201. +        hwif->ctl_port    = hwif->io_base ? hwif->io_base+0x206 : 0x000;
  2202.  #ifdef CONFIG_BLK_DEV_HD
  2203.          if (hwif->io_base == HD_DATA)
  2204.              hwif->noprobe = 1; /* may be overriden by ide_setup() */
  2205. @@ -268,7 +278,6 @@
  2206.      }
  2207.  }
  2208.  
  2209. -#ifdef __i386__
  2210.  #define VLB_SYNC 1
  2211.  /*
  2212.   * Some localbus EIDE interfaces require a special access sequence
  2213. @@ -278,34 +287,32 @@
  2214.   * to ensure that the reads all happen together.
  2215.   */
  2216.  static inline void do_vlb_sync (unsigned short port) {
  2217. -    unsigned int _v;
  2218. -    __asm__ __volatile__    (
  2219. -        "inb %w1,%b0\n\t"
  2220. -        "inb %w1,%b0\n\t"
  2221. -        "inb %w1,%b0"
  2222. -        : "=&a" (_v)        /* outputs */
  2223. -        : "d" (port)    );    /* inputs */
  2224. +    (void) inb (port);
  2225. +    (void) inb (port);
  2226. +    (void) inb (port);
  2227.  }
  2228. -#endif    /* __i386__ */
  2229.  
  2230.  /*
  2231.   * This is used for most PIO data transfers *from* the IDE interface
  2232.   */
  2233.  void ide_input_data (ide_drive_t *drive, void *buffer, unsigned int wcount)
  2234.  {
  2235. +    unsigned short io_base  = HWIF(drive)->io_base;
  2236. +    unsigned short data_reg = io_base+IDE_DATA_OFFSET;
  2237. +
  2238.      if (drive->vlb_32bit) {
  2239.  #ifdef VLB_SYNC
  2240.          if (drive->vlb_sync) {
  2241.              cli();
  2242. -            do_vlb_sync(IDE_NSECTOR_REG);
  2243. -            insl(IDE_DATA_REG, buffer, wcount);
  2244. +            do_vlb_sync(io_base+IDE_NSECTOR_OFFSET);
  2245. +            insl(data_reg, buffer, wcount);
  2246.              if (drive->unmask)
  2247.                  sti();
  2248.          } else
  2249.  #endif /* VLB_SYNC */
  2250. -            insl(IDE_DATA_REG, buffer, wcount);
  2251. +            insl(data_reg, buffer, wcount);
  2252.      } else
  2253. -        insw(IDE_DATA_REG, buffer, wcount<<1);
  2254. +        insw(data_reg, buffer, wcount<<1);
  2255.  }
  2256.  
  2257.  /*
  2258. @@ -313,19 +320,22 @@
  2259.   */
  2260.  void ide_output_data (ide_drive_t *drive, void *buffer, unsigned int wcount)
  2261.  {
  2262. +    unsigned short io_base  = HWIF(drive)->io_base;
  2263. +    unsigned short data_reg = io_base+IDE_DATA_OFFSET;
  2264. +
  2265.      if (drive->vlb_32bit) {
  2266.  #ifdef VLB_SYNC
  2267.          if (drive->vlb_sync) {
  2268.              cli();
  2269. -            do_vlb_sync(IDE_NSECTOR_REG);
  2270. -            outsl(IDE_DATA_REG, buffer, wcount);
  2271. +            do_vlb_sync(io_base+IDE_NSECTOR_OFFSET);
  2272. +            outsl(data_reg, buffer, wcount);
  2273.              if (drive->unmask)
  2274.                  sti();
  2275.          } else
  2276.  #endif /* VLB_SYNC */
  2277. -            outsl(IDE_DATA_REG, buffer, wcount);
  2278. +            outsl(data_reg, buffer, wcount);
  2279.      } else
  2280. -        outsw(IDE_DATA_REG, buffer, wcount<<1);
  2281. +        outsw(data_reg, buffer, wcount<<1);
  2282.  }
  2283.  
  2284.  #if SUPPORT_HT6560B
  2285. @@ -677,8 +687,8 @@
  2286.              if (!drive->keep_settings)
  2287.                  drive->unmask = 0;
  2288.              OUT_BYTE (drive->select.all, IDE_SELECT_REG);
  2289. +            udelay (20);
  2290.              OUT_BYTE (WIN_SRST, IDE_COMMAND_REG);
  2291. -            udelay (10);
  2292.              hwgroup->reset_timeout = jiffies + WAIT_WORSTCASE;
  2293.              start_reset_timer (hwif); /* begin periodic polling */
  2294.              restore_flags (flags);
  2295. @@ -851,12 +861,10 @@
  2296.      err = ide_dump_status(drive, msg, stat);
  2297.      if ((rq = HWGROUP(drive)->rq) == NULL || drive == NULL)
  2298.          return 0;
  2299. -#ifdef IDE_DRIVE_CMD
  2300.      if (rq->cmd == IDE_DRIVE_CMD) {    /* never retry an explicit DRIVE_CMD */
  2301.          end_drive_cmd(drive, stat, err);
  2302.          return 0;
  2303.      }
  2304. -#endif    /* IDE_DRIVE_CMD */
  2305.      if (stat & BUSY_STAT) {        /* other bits are useless when BUSY */
  2306.          rq->errors |= ERROR_RESET;
  2307.      } else {
  2308. @@ -1105,7 +1113,6 @@
  2309.      IDE_DO_REQUEST;
  2310.  }
  2311.  
  2312. -#ifdef IDE_DRIVE_CMD
  2313.  /*
  2314.   * drive_cmd_intr() is invoked on completion of a special DRIVE_CMD.
  2315.   */
  2316. @@ -1120,7 +1127,6 @@
  2317.          return;
  2318.      IDE_DO_REQUEST;
  2319.  }
  2320. -#endif    /* IDE_DRIVE_CMD */
  2321.  
  2322.  /*
  2323.   * do_special() is used to issue WIN_SPECIFY, WIN_RESTORE, and WIN_SETMULT
  2324. @@ -1175,26 +1181,28 @@
  2325.  int ide_wait_stat (ide_drive_t *drive, byte good, byte bad, unsigned long timeout)
  2326.  {
  2327.      byte stat;
  2328. +    unsigned long flags;
  2329. +test:
  2330. +    udelay(1);    /* spec allows drive 400ns to change "BUSY" */
  2331. +    if (OK_STAT((stat = GET_STAT()), good, bad))
  2332. +        return 0;    /* fast exit for most frequent case */
  2333. +    if (!(stat & BUSY_STAT)) {
  2334. +        (void) ide_error(drive, "status error", stat);
  2335. +        return 1;
  2336. +    }
  2337.  
  2338. -    udelay(1);    /* spec allows drive 400ns to assert "BUSY" */
  2339. -    if (GET_STAT() & BUSY_STAT) {
  2340. -        unsigned long flags;
  2341. -        save_flags(flags);
  2342. -        sti();
  2343. -        timeout += jiffies;
  2344. -        while (GET_STAT() & BUSY_STAT) {
  2345. -            if (jiffies > timeout) {
  2346. -                restore_flags(flags);
  2347. -                (void) ide_error(drive, "status timeout", GET_STAT());
  2348. -                return 1;
  2349. -            }
  2350. +    save_flags(flags);
  2351. +    sti();
  2352. +    timeout += jiffies;
  2353. +    do {
  2354. +        if (!((stat = GET_STAT()) & BUSY_STAT)) {
  2355. +            restore_flags(flags);
  2356. +            goto test;
  2357.          }
  2358. -        restore_flags(flags);
  2359. -        udelay(1);    /* spec allows 400ns for status to stabilize */
  2360. -    }
  2361. -    if (OK_STAT(stat=GET_STAT(), good, bad))
  2362. -        return 0;
  2363. -    (void) ide_error(drive, "status error", stat);
  2364. +    } while (jiffies <= timeout);
  2365. +
  2366. +    restore_flags(flags);
  2367. +    (void) ide_error(drive, "status timeout", GET_STAT());
  2368.      return 1;
  2369.  }
  2370.  
  2371. @@ -1205,28 +1213,30 @@
  2372.   */
  2373.  static inline void do_rw_disk (ide_drive_t *drive, struct request *rq, unsigned long block)
  2374.  {
  2375. +    unsigned short io_base = HWIF(drive)->io_base;
  2376. +
  2377.      OUT_BYTE(drive->ctl,IDE_CONTROL_REG);
  2378. -    OUT_BYTE(rq->nr_sectors,IDE_NSECTOR_REG);
  2379. +    OUT_BYTE(rq->nr_sectors,io_base+IDE_NSECTOR_OFFSET);
  2380.      if (drive->select.b.lba) {
  2381.  #ifdef DEBUG
  2382.          printk("%s: %sing: LBAsect=%ld, sectors=%ld, buffer=0x%08lx\n",
  2383.              drive->name, (rq->cmd==READ)?"read":"writ", 
  2384.              block, rq->nr_sectors, (unsigned long) rq->buffer);
  2385.  #endif
  2386. -        OUT_BYTE(block,IDE_SECTOR_REG);
  2387. -        OUT_BYTE(block>>=8,IDE_LCYL_REG);
  2388. -        OUT_BYTE(block>>=8,IDE_HCYL_REG);
  2389. -        OUT_BYTE(((block>>8)&0x0f)|drive->select.all,IDE_SELECT_REG);
  2390. +        OUT_BYTE(block,io_base+IDE_SECTOR_OFFSET);
  2391. +        OUT_BYTE(block>>=8,io_base+IDE_LCYL_OFFSET);
  2392. +        OUT_BYTE(block>>=8,io_base+IDE_HCYL_OFFSET);
  2393. +        OUT_BYTE(((block>>8)&0x0f)|drive->select.all,io_base+IDE_SELECT_OFFSET);
  2394.      } else {
  2395.          unsigned int sect,head,cyl,track;
  2396.          track = block / drive->sect;
  2397.          sect  = block % drive->sect + 1;
  2398. -        OUT_BYTE(sect,IDE_SECTOR_REG);
  2399. +        OUT_BYTE(sect,io_base+IDE_SECTOR_OFFSET);
  2400.          head  = track % drive->head;
  2401.          cyl   = track / drive->head;
  2402. -        OUT_BYTE(cyl,IDE_LCYL_REG);
  2403. -        OUT_BYTE(cyl>>8,IDE_HCYL_REG);
  2404. -        OUT_BYTE(head|drive->select.all,IDE_SELECT_REG);
  2405. +        OUT_BYTE(cyl,io_base+IDE_LCYL_OFFSET);
  2406. +        OUT_BYTE(cyl>>8,io_base+IDE_HCYL_OFFSET);
  2407. +        OUT_BYTE(head|drive->select.all,io_base+IDE_SELECT_OFFSET);
  2408.  #ifdef DEBUG
  2409.          printk("%s: %sing: CHS=%d/%d/%d, sectors=%ld, buffer=0x%08lx\n",
  2410.              drive->name, (rq->cmd==READ)?"read":"writ", cyl,
  2411. @@ -1239,7 +1249,7 @@
  2412.              return;
  2413.  #endif /* CONFIG_BLK_DEV_TRITON */
  2414.          ide_set_handler(drive, &read_intr);
  2415. -        OUT_BYTE(drive->mult_count ? WIN_MULTREAD : WIN_READ, IDE_COMMAND_REG);
  2416. +        OUT_BYTE(drive->mult_count ? WIN_MULTREAD : WIN_READ, io_base+IDE_COMMAND_OFFSET);
  2417.          return;
  2418.      }
  2419.      if (rq->cmd == WRITE) {
  2420. @@ -1247,7 +1257,7 @@
  2421.          if (drive->using_dma && !(HWIF(drive)->dmaproc(ide_dma_write, drive)))
  2422.              return;
  2423.  #endif /* CONFIG_BLK_DEV_TRITON */
  2424. -        OUT_BYTE(drive->mult_count ? WIN_MULTWRITE : WIN_WRITE, IDE_COMMAND_REG);
  2425. +        OUT_BYTE(drive->mult_count ? WIN_MULTWRITE : WIN_WRITE, io_base+IDE_COMMAND_OFFSET);
  2426.          if (ide_wait_stat(drive, DATA_READY, drive->bad_wstat, WAIT_DRQ)) {
  2427.              printk("%s: no DRQ after issuing %s\n", drive->name,
  2428.                  drive->mult_count ? "MULTWRITE" : "WRITE");
  2429. @@ -1265,13 +1275,12 @@
  2430.          }
  2431.          return;
  2432.      }
  2433. -#ifdef IDE_DRIVE_CMD
  2434.      if (rq->cmd == IDE_DRIVE_CMD) {
  2435.          byte *args = rq->buffer;
  2436.          if (args) {
  2437.              printk("%s: DRIVE_CMD cmd=0x%02x sc=0x%02x fr=0x%02x\n",
  2438.               drive->name, args[0], args[1], args[2]);
  2439. -            OUT_BYTE(args[2],IDE_FEATURE_REG);
  2440. +            OUT_BYTE(args[2],io_base+IDE_FEATURE_OFFSET);
  2441.              ide_cmd(drive, args[0], args[1], &drive_cmd_intr);
  2442.              return;
  2443.          } else {
  2444. @@ -1286,7 +1295,6 @@
  2445.              return;
  2446.          }
  2447.      }
  2448. -#endif    /* IDE_DRIVE_CMD */
  2449.      printk("%s: bad command: %d\n", drive->name, rq->cmd);
  2450.      ide_end_request(0, HWGROUP(drive));
  2451.  }
  2452. @@ -1574,6 +1582,10 @@
  2453.                  ide_drive_t *drive = &hwif->drives[unit];
  2454.                  if (drive->present)
  2455.                      return drive;
  2456. +            } else if (major == IDE0_MAJOR && unit < 4) {
  2457. +                printk("ide: probable bad entry for /dev/hd%c%d\n",
  2458. +                 'a' + unit, MINOR(i_rdev) & PARTN_MASK);
  2459. +                printk("ide: to fix it, run:  /usr/src/linux/drivers/block/MAKEDEV.ide\n");
  2460.              }
  2461.              break;
  2462.          }
  2463. @@ -1581,14 +1593,13 @@
  2464.      return NULL;
  2465.  }
  2466.  
  2467. -#ifdef IDE_DRIVE_CMD
  2468.  /*
  2469.   * This function issues a specific IDE drive command onto the
  2470.   * tail of the request queue, and waits for it to be completed.
  2471.   * If arg is NULL, it goes through all the motions,
  2472.   * but without actually sending a command to the drive.
  2473.   */
  2474. -static int do_drive_cmd(int rdev, char *args)
  2475. +int ide_do_drive_cmd(int rdev, char *args)
  2476.  {
  2477.      unsigned long flags;
  2478.      unsigned int major = MAJOR(rdev);
  2479. @@ -1626,7 +1637,6 @@
  2480.      restore_flags(flags);
  2481.      return rq.errors ? -EIO : 0;        /* return -EIO if errors */
  2482.  }
  2483. -#endif    /* IDE_DRIVE_CMD */
  2484.  
  2485.  static int ide_open(struct inode * inode, struct file * filp)
  2486.  {
  2487. @@ -1646,13 +1656,9 @@
  2488.          return ide_cdrom_open (inode, filp, drive);
  2489.  #endif    /* CONFIG_BLK_DEV_IDECD */
  2490.      if (drive->removeable) {
  2491. -        check_disk_change(inode->i_rdev);
  2492. -#ifdef IDE_DRIVE_CMD
  2493. -        {
  2494.          byte door_lock[] = {WIN_DOORLOCK,0,0,0};
  2495. -        do_drive_cmd(inode->i_rdev, door_lock);
  2496. -        }
  2497. -#endif /* IDE_DRIVE_CMD */
  2498. +        check_disk_change(inode->i_rdev);
  2499. +        ide_do_drive_cmd(inode->i_rdev, door_lock);
  2500.      }
  2501.      return 0;
  2502.  }
  2503. @@ -1674,13 +1680,9 @@
  2504.          else
  2505.  #endif    /* CONFIG_BLK_DEV_IDECD */
  2506.          if (drive->removeable) {
  2507. -            invalidate_buffers(inode->i_rdev);
  2508. -#ifdef IDE_DRIVE_CMD
  2509. -            {
  2510.              byte door_unlock[] = {WIN_DOORUNLOCK,0,0,0};
  2511. -            do_drive_cmd(inode->i_rdev, door_unlock);
  2512. -            }
  2513. -#endif /* IDE_DRIVE_CMD */
  2514. +            invalidate_buffers(inode->i_rdev);
  2515. +            ide_do_drive_cmd(inode->i_rdev, door_unlock);
  2516.          }
  2517.      }
  2518.  }
  2519. @@ -1876,10 +1878,7 @@
  2520.              drive->mult_req = arg;
  2521.              drive->special.b.set_multmode = 1;
  2522.              restore_flags(flags);
  2523. -#ifndef IDE_DRIVE_CMD
  2524. -            return 0;
  2525. -#else
  2526. -            do_drive_cmd (inode->i_rdev, NULL);
  2527. +            ide_do_drive_cmd (inode->i_rdev, NULL);
  2528.              return (drive->mult_count == arg) ? 0 : -EIO;
  2529.  
  2530.          case HDIO_DRIVE_CMD:
  2531. @@ -1887,20 +1886,19 @@
  2532.              unsigned long args;
  2533.  
  2534.              if (NULL == (long *) arg)
  2535. -                err = do_drive_cmd(inode->i_rdev,NULL);
  2536. +                err = ide_do_drive_cmd(inode->i_rdev,NULL);
  2537.              else {
  2538.                  if (!(err = verify_area(VERIFY_READ,(long *)arg,sizeof(long))))
  2539.                  {
  2540.                      args = get_user((long *)arg);
  2541.                      if (!(err = verify_area(VERIFY_WRITE,(long *)arg,sizeof(long)))) {
  2542. -                        err = do_drive_cmd(inode->i_rdev,(char *)&args);
  2543. +                        err = ide_do_drive_cmd(inode->i_rdev,(char *)&args);
  2544.                          put_user(args,(long *)arg);
  2545.                      }
  2546.                  }
  2547.              }
  2548.              return err;
  2549.          }
  2550. -#endif /* IDE_DRIVE_CMD */
  2551.  
  2552.          RO_IOCTLS(inode->i_rdev, arg);
  2553.  
  2554. @@ -2398,7 +2396,8 @@
  2555.      byte reg;
  2556.      unsigned short port = 0x178;
  2557.  
  2558. -     printk("ide: buggy CMD640 interface: ");
  2559. +    single_threaded = 1;
  2560. +     printk("ide: buggy CMD640 interface: serialized, ");
  2561.      reg = read_cmd640_vlb(port, 0x50);
  2562.      if (reg == 0xff || (reg & 0x90) != 0x90) {
  2563.  #if TRY_CMD640_VLB_AT_0x78
  2564. @@ -2406,9 +2405,8 @@
  2565.          if (reg == 0xff || (reg & 0x90) != 0x90)
  2566.  #endif
  2567.          {
  2568. -            single_threaded = 1;
  2569.              disallow_unmask = 1;
  2570. -            printk("(probe failed) serialized, disabled unmasking\n");
  2571. +            printk("(probe failed) disabled unmasking\n");
  2572.              return;
  2573.          }
  2574.      }
  2575. @@ -2578,8 +2576,14 @@
  2576.  #if SUPPORT_HT6560B
  2577.              case -4: /* "ht6560b" */
  2578.                  if (hw > 1) goto bad_hwif;
  2579. -                ide_hwifs[0].select = 0x1c;
  2580. -                ide_hwifs[1].select = 0x1d;
  2581. +                /*
  2582. +                 * Using 0x1c and 0x1d apparently selects a
  2583. +                 * faster interface speed than 0x3c and 0x3d.
  2584. +                 *
  2585. +                 * Need to add an ioctl to select between them.
  2586. +                 */
  2587. +                ide_hwifs[0].select = 0x3c;
  2588. +                ide_hwifs[1].select = 0x3d;
  2589.                  goto do_serialize;
  2590.  #endif /* SUPPORT_HT6560B */
  2591.  #if SUPPORT_DTC2278
  2592. @@ -2752,7 +2756,7 @@
  2593.      restore_flags(flags);    /* safe now that hwif->hwgroup is set up */
  2594.  
  2595.      printk("%s at 0x%03x-0x%03x,0x%03x on irq %d", hwif->name,
  2596. -        hwif->io_base, hwif->io_base + 7, hwif->ctl_port, hwif->irq);
  2597. +        hwif->io_base, hwif->io_base+7, hwif->ctl_port, hwif->irq);
  2598.      if (hwgroup->hwif != hwif) {
  2599.          char *name = hwgroup->hwif->name;
  2600.          if (hwgroup->hwif->irq == hwif->irq)
  2601. @@ -2818,12 +2822,13 @@
  2602.      int rc;
  2603.      unsigned char reg;
  2604.  
  2605. +    single_threaded = 1;
  2606.      printk("ide: buggy CMD640 interface: ");
  2607.      if ((rc = pcibios_read_config_byte(bus, fn, 0x51, ®))
  2608.       || (rc =  pcibios_write_config_byte(bus, fn, 0x51, reg | 0xc8)))
  2609.          buggy_interface_fallback (rc);
  2610.      else
  2611. -        printk("disabled read-ahead, enabled secondary\n");
  2612. +        printk("serialized, disabled read-ahead, enabled secondary\n");
  2613.  }
  2614.  #endif /* SUPPORT_CMD640 */
  2615.  
  2616. @@ -2840,8 +2845,6 @@
  2617.      byte fn, bus;
  2618.      int rc;
  2619.  
  2620. -    if (!pcibios_present())
  2621. -        return;
  2622.      save_flags(flags);
  2623.      cli();
  2624.      for (index = 0; !pcibios_find_device (vendor, device, index, &bus, &fn); ++index) {
  2625. @@ -2892,7 +2895,8 @@
  2626.      /*
  2627.       * Find/initialize PCI IDE interfaces
  2628.       */
  2629. -    ide_init_pci ();
  2630. +    if (pcibios_present())
  2631. +        ide_init_pci ();
  2632.  #endif /* CONFIG_PCI */
  2633.  
  2634.      /*
  2635. diff -u --recursive --new-file v1.3.22/linux/drivers/block/ide.h linux/drivers/block/ide.h
  2636. --- v1.3.22/linux/drivers/block/ide.h    Sun Sep  3 12:26:51 1995
  2637. +++ linux/drivers/block/ide.h    Sun Sep  3 14:06:00 1995
  2638. @@ -17,11 +17,10 @@
  2639.  
  2640.  /******************************************************************************
  2641.   * IDE driver configuration options (play with these as desired):
  2642. + * 
  2643. + * REALLY_SLOW_IO can be defined in ide.c and ide-cd.c, if necessary
  2644.   */
  2645. -#undef REALLY_SLOW_IO            /* most systems can safely undef this */
  2646. -#include <asm/io.h>
  2647. -
  2648. -#undef     REALLY_FAST_IO            /* define if ide ports are perfect */
  2649. +#define REALLY_FAST_IO            /* define if ide ports are perfect */
  2650.  #define INITIAL_MULT_COUNT    0    /* off=0; on=2,4,8,16,32, etc.. */
  2651.  
  2652.  #ifndef DISK_RECOVERY_TIME        /* off=0; on=access_delay_time */
  2653. @@ -81,14 +80,25 @@
  2654.  #define HWIF(drive)        ((ide_hwif_t *)drive->hwif)
  2655.  #define HWGROUP(drive)        ((ide_hwgroup_t *)(HWIF(drive)->hwgroup))
  2656.  
  2657. -#define IDE_DATA_REG        (HWIF(drive)->io_base)
  2658. -#define IDE_ERROR_REG        (HWIF(drive)->io_base+1)
  2659. -#define IDE_NSECTOR_REG        (HWIF(drive)->io_base+2)
  2660. -#define IDE_SECTOR_REG        (HWIF(drive)->io_base+3)
  2661. -#define IDE_LCYL_REG        (HWIF(drive)->io_base+4)
  2662. -#define IDE_HCYL_REG        (HWIF(drive)->io_base+5)
  2663. -#define IDE_SELECT_REG        (HWIF(drive)->io_base+6)
  2664. -#define IDE_STATUS_REG        (HWIF(drive)->io_base+7)
  2665. +#define IDE_DATA_OFFSET        (0)
  2666. +#define IDE_ERROR_OFFSET    (1)
  2667. +#define IDE_NSECTOR_OFFSET    (2)
  2668. +#define IDE_SECTOR_OFFSET    (3)
  2669. +#define IDE_LCYL_OFFSET        (4)
  2670. +#define IDE_HCYL_OFFSET        (5)
  2671. +#define IDE_SELECT_OFFSET    (6)
  2672. +#define IDE_STATUS_OFFSET    (7)
  2673. +#define IDE_FEATURE_OFFSET    IDE_ERROR_OFFSET
  2674. +#define IDE_COMMAND_OFFSET    IDE_STATUS_OFFSET
  2675. +
  2676. +#define IDE_DATA_REG        (HWIF(drive)->io_base+IDE_DATA_OFFSET)
  2677. +#define IDE_ERROR_REG        (HWIF(drive)->io_base+IDE_ERROR_OFFSET)
  2678. +#define IDE_NSECTOR_REG        (HWIF(drive)->io_base+IDE_NSECTOR_OFFSET)
  2679. +#define IDE_SECTOR_REG        (HWIF(drive)->io_base+IDE_SECTOR_OFFSET)
  2680. +#define IDE_LCYL_REG        (HWIF(drive)->io_base+IDE_LCYL_OFFSET)
  2681. +#define IDE_HCYL_REG        (HWIF(drive)->io_base+IDE_HCYL_OFFSET)
  2682. +#define IDE_SELECT_REG        (HWIF(drive)->io_base+IDE_SELECT_OFFSET)
  2683. +#define IDE_STATUS_REG        (HWIF(drive)->io_base+IDE_STATUS_OFFSET)
  2684.  #define IDE_CONTROL_REG        (HWIF(drive)->ctl_port)
  2685.  #define IDE_FEATURE_REG        IDE_ERROR_REG
  2686.  #define IDE_COMMAND_REG        IDE_STATUS_REG
  2687. @@ -413,6 +423,17 @@
  2688.   * All allocations are longword aligned.
  2689.   */
  2690.  void *ide_alloc (unsigned long bytecount, unsigned long within_area);
  2691. +
  2692. +/*
  2693. + * This function issues a specific IDE drive command onto the
  2694. + * tail of the request queue, and waits for it to be completed.
  2695. + * If arg is NULL, it goes through all the motions,
  2696. + * but without actually sending a command to the drive.
  2697. + *
  2698. + * The value of arg is passed to the internal handler as rq->buffer.
  2699. + */
  2700. +int ide_do_drive_cmd(int rdev, char *args);
  2701. +
  2702.  
  2703.  #ifdef CONFIG_BLK_DEV_IDECD
  2704.  /*
  2705. diff -u --recursive --new-file v1.3.22/linux/drivers/block/triton.c linux/drivers/block/triton.c
  2706. --- v1.3.22/linux/drivers/block/triton.c    Sun Sep  3 12:26:52 1995
  2707. +++ linux/drivers/block/triton.c    Sun Sep  3 12:03:00 1995
  2708. @@ -194,6 +194,29 @@
  2709.      return 1;    /* let the PIO routines handle this weirdness */
  2710.  }
  2711.  
  2712. +static int config_drive_for_dma (ide_drive_t *drive)
  2713. +{
  2714. +    const char **list;
  2715. +
  2716. +    struct hd_driveid *id = drive->id;
  2717. +    if (id && (id->capability & 1)) {
  2718. +        /* Enable DMA on any drive that supports mword2 DMA */
  2719. +        if ((id->field_valid & 2) && (id->dma_mword & 0x404) == 0x404) {
  2720. +            drive->using_dma = 1;
  2721. +            return 0;        /* DMA enabled */
  2722. +        }
  2723. +        /* Consult the list of known "good" drives */
  2724. +        list = good_dma_drives;
  2725. +        while (*list) {
  2726. +            if (!strcmp(*list++,id->model)) {
  2727. +                drive->using_dma = 1;
  2728. +                return 0;    /* DMA enabled */
  2729. +            }
  2730. +        }
  2731. +    }
  2732. +    return 1;    /* DMA not enabled */
  2733. +}
  2734. +
  2735.  /*
  2736.   * triton_dmaproc() initiates/aborts DMA read/write operations on a drive.
  2737.   *
  2738. @@ -207,40 +230,31 @@
  2739.   */
  2740.  static int triton_dmaproc (ide_dma_action_t func, ide_drive_t *drive)
  2741.  {
  2742. -    const char **list;
  2743.      unsigned long dma_base = HWIF(drive)->dma_base;
  2744. +    unsigned int reading = (1 << 3);
  2745.  
  2746. -    if (func == ide_dma_abort) {
  2747. -        outb(inb(dma_base)&~1, dma_base);    /* stop DMA */
  2748. -        return 0;
  2749. -    }
  2750. -    if (func == ide_dma_check) {
  2751. -        struct hd_driveid *id = drive->id;
  2752. -        if (id && (id->capability & 1)) {
  2753. -            /* Enable DMA on any drive that supports mword2 DMA */
  2754. -            if ((id->field_valid & 2) && (id->dma_mword & 0x404) == 0x404) {
  2755. -                drive->using_dma = 1;
  2756. -                return 0;        /* DMA enabled */
  2757. -            }
  2758. -            /* Consult the list of known "good" drives */
  2759. -            list = good_dma_drives;
  2760. -            while (*list) {
  2761. -                if (!strcmp(*list++,id->model)) {
  2762. -                    drive->using_dma = 1;
  2763. -                    return 0;    /* DMA enabled */
  2764. -                }
  2765. -            }
  2766. -        }
  2767. -        return 1;    /* DMA not enabled */
  2768. +    switch (func) {
  2769. +        case ide_dma_abort:
  2770. +            outb(inb(dma_base)&~1, dma_base);    /* stop DMA */
  2771. +            return 0;
  2772. +        case ide_dma_check:
  2773. +            return config_drive_for_dma (drive);
  2774. +        case ide_dma_write:
  2775. +            reading = 0;
  2776. +        case ide_dma_read:
  2777. +            break;
  2778. +        default:
  2779. +            printk("triton_dmaproc: unsupported func: %d\n", func);
  2780. +            return 1;
  2781.      }
  2782.      if (build_dmatable (drive))
  2783.          return 1;
  2784.      outl(virt_to_bus (HWIF(drive)->dmatable), dma_base + 4); /* PRD table */
  2785. -    outb((!func) << 3, dma_base);            /* specify r/w */
  2786. +    outb(reading, dma_base);            /* specify r/w */
  2787.      outb(0x26, dma_base+2);                /* clear status bits */
  2788.      ide_set_handler (drive, &dma_intr);        /* issue cmd to drive */
  2789. -    OUT_BYTE(func ? WIN_WRITEDMA : WIN_READDMA, IDE_COMMAND_REG);
  2790. -    outb(inb(dma_base)|1, dma_base);            /* begin DMA */
  2791. +    OUT_BYTE(reading ? WIN_READDMA : WIN_WRITEDMA, IDE_COMMAND_REG);
  2792. +    outb(inb(dma_base)|1, dma_base);        /* begin DMA */
  2793.      return 0;
  2794.  }
  2795.  
  2796. @@ -326,8 +340,8 @@
  2797.              base = bmiba + 8;
  2798.          } else
  2799.              continue;
  2800. -        printk("    %s: BusMaster DMA at 0x%04x-0x%04x", hwif->name, base, base+5);
  2801. -        if (check_region(base, 6)) {
  2802. +        printk("    %s: BusMaster DMA at 0x%04x-0x%04x", hwif->name, base, base+7);
  2803. +        if (check_region(base, 8)) {
  2804.              printk(" -- ERROR, PORTS ALREADY IN USE");
  2805.          } else {
  2806.              unsigned long *table;
  2807. diff -u --recursive --new-file v1.3.22/linux/drivers/net/Makefile linux/drivers/net/Makefile
  2808. --- v1.3.22/linux/drivers/net/Makefile    Mon Aug 28 14:52:20 1995
  2809. +++ linux/drivers/net/Makefile    Sun Sep  3 12:08:21 1995
  2810. @@ -245,8 +245,6 @@
  2811.  
  2812.  ifdef CONFIG_ARCNET
  2813.  L_OBJS += arcnet.o
  2814. -else
  2815. -M_OBJS += arcnet.o
  2816.  endif
  2817.  
  2818.  ifdef CONFIG_PI
  2819. diff -u --recursive --new-file v1.3.22/linux/drivers/net/lance.c linux/drivers/net/lance.c
  2820. --- v1.3.22/linux/drivers/net/lance.c    Tue Aug 15 20:39:03 1995
  2821. +++ linux/drivers/net/lance.c    Sun Sep  3 11:13:05 1995
  2822. @@ -319,10 +319,14 @@
  2823.      for (port = lance_portlist; *port; port++) {
  2824.          int ioaddr = *port;
  2825.  
  2826. -        if (   check_region(ioaddr, LANCE_TOTAL_SIZE) == 0
  2827. -            && inb(ioaddr + 14) == 0x57
  2828. -            && inb(ioaddr + 15) == 0x57) {
  2829. -            mem_start = lance_probe1(ioaddr, mem_start);
  2830. +        if ( check_region(ioaddr, LANCE_TOTAL_SIZE) == 0) {
  2831. +            /* Detect "normal" 0x57 0x57 and the NI6510EB 0x52 0x44
  2832. +               signatures w/ minimal I/O reads */
  2833. +            char offset15, offset14 = inb(ioaddr + 14);
  2834. +            
  2835. +            if ((offset14 == 0x52 || offset14 == 0x57) &&
  2836. +                ((offset15 = inb(ioaddr + 15)) == 0x57 || offset15 == 0x44))
  2837. +                mem_start = lance_probe1(ioaddr, mem_start);
  2838.          }
  2839.      }
  2840.  
  2841. diff -u --recursive --new-file v1.3.22/linux/include/asm-i386/io.h linux/include/asm-i386/io.h
  2842. --- v1.3.22/linux/include/asm-i386/io.h    Sun Sep  3 12:27:02 1995
  2843. +++ linux/include/asm-i386/io.h    Sun Sep  3 12:06:48 1995
  2844. @@ -121,10 +121,11 @@
  2845.  #undef RETURN_TYPE
  2846.  #define RETURN_TYPE unsigned short
  2847.  /* __IN(w,"w","0" (0)) */
  2848. -__IN(w,)
  2849. +__IN(w,"")
  2850.  #undef RETURN_TYPE
  2851.  #define RETURN_TYPE unsigned int
  2852.  __IN(l,"")
  2853. +#undef RETURN_TYPE
  2854.  
  2855.  __OUT(b,"b",char)
  2856.  __OUT(w,"w",short)
  2857. diff -u --recursive --new-file v1.3.22/linux/include/linux/hdreg.h linux/include/linux/hdreg.h
  2858. --- v1.3.22/linux/include/linux/hdreg.h    Mon Aug 28 14:52:22 1995
  2859. +++ linux/include/linux/hdreg.h    Sun Sep  3 14:04:52 1995
  2860. @@ -1,8 +1,6 @@
  2861.  #ifndef _LINUX_HDREG_H
  2862.  #define _LINUX_HDREG_H
  2863.  
  2864. -#include <linux/config.h>
  2865. -
  2866.  /*
  2867.   * This file contains some defines for the AT-hd-controller.
  2868.   * Various sources.  
  2869. @@ -154,14 +152,19 @@
  2870.      /* unsigned short reservedyy[96];*/    /* reserved (words 160-255) */
  2871.  };
  2872.  
  2873. +#ifdef __KERNEL__
  2874.  /*
  2875.   * These routines are used for kernel command line parameters from main.c:
  2876.   */
  2877. +#include <linux/config.h>
  2878. +
  2879.  #ifdef CONFIG_BLK_DEV_HD
  2880.  void hd_setup(char *, int *);
  2881.  #endif    /* CONFIG_BLK_DEV_HD */
  2882.  #ifdef CONFIG_BLK_DEV_IDE
  2883.  void ide_setup(char *);
  2884.  #endif    /* CONFIG_BLK_DEV_IDE */
  2885. +
  2886. +#endif  /* __KERNEL__ */
  2887.  
  2888.  #endif    /* _LINUX_HDREG_H */
  2889. diff -u --recursive --new-file v1.3.22/linux/include/linux/igmp.h linux/include/linux/igmp.h
  2890. --- v1.3.22/linux/include/linux/igmp.h    Tue Jun  6 11:22:11 1995
  2891. +++ linux/include/linux/igmp.h    Sun Sep  3 11:19:53 1995
  2892. @@ -25,7 +25,7 @@
  2893.  struct igmphdr
  2894.  {
  2895.      unsigned char type;
  2896. -    unsigned char unused;
  2897. +    unsigned char code;
  2898.      unsigned short csum;
  2899.      unsigned long group;
  2900.  };
  2901. @@ -37,7 +37,7 @@
  2902.  struct igmp_header
  2903.  {
  2904.      unsigned char type;
  2905. -    unsigned char unused;
  2906. +    unsigned char code;
  2907.      unsigned short csum;
  2908.      unsigned long group;
  2909.  };
  2910. diff -u --recursive --new-file v1.3.22/linux/include/linux/mcd.h linux/include/linux/mcd.h
  2911. --- v1.3.22/linux/include/linux/mcd.h    Sun Sep  3 12:27:02 1995
  2912. +++ linux/include/linux/mcd.h    Sun Sep  3 12:09:44 1995
  2913. @@ -110,6 +110,8 @@
  2914.      struct msf    diskTime;
  2915.  };
  2916.  
  2917. +#if 0
  2918.  #ifndef I_WAS_HERE
  2919.  #error Please edit this file first.
  2920. +#endif
  2921.  #endif
  2922. diff -u --recursive --new-file v1.3.22/linux/include/linux/mcdx.h linux/include/linux/mcdx.h
  2923. --- v1.3.22/linux/include/linux/mcdx.h    Sun Sep  3 12:27:02 1995
  2924. +++ linux/include/linux/mcdx.h    Sun Sep  3 12:09:44 1995
  2925. @@ -173,6 +173,8 @@
  2926.  #define MCDX_E        1            /* unspec error */
  2927.  #define MCDX_EOM    2            /* end of media */
  2928.  
  2929. +#if 0
  2930.  #ifndef I_WAS_HERE
  2931.  #error Please edit this file first.
  2932. +#endif
  2933.  #endif
  2934. diff -u --recursive --new-file v1.3.22/linux/net/core/dev.c linux/net/core/dev.c
  2935. --- v1.3.22/linux/net/core/dev.c    Sun Sep  3 12:27:05 1995
  2936. +++ linux/net/core/dev.c    Sun Sep  3 12:00:24 1995
  2937. @@ -1305,7 +1305,7 @@
  2938.   
  2939.  void dev_init(void)
  2940.  {
  2941. -    struct device *dev, *dev2;
  2942. +    struct device *dev, **dp;
  2943.  
  2944.      /*
  2945.       *    Add the devices.
  2946. @@ -1313,24 +1313,25 @@
  2947.       *    from the chain disconnecting the device until the
  2948.       *    next reboot.
  2949.       */
  2950. -     
  2951. -    dev2 = NULL;
  2952. -    for (dev = dev_base; dev != NULL; dev=dev->next) 
  2953. +
  2954. +    dp = &dev_base;
  2955. +    while ((dev = *dp) != NULL)
  2956.      {
  2957. +        int i;
  2958. +        for (i = 0; i < DEV_NUMBUFFS; i++)  {
  2959. +            skb_queue_head_init(dev->buffs + i);
  2960. +        }
  2961. +
  2962.          if (dev->init && dev->init(dev)) 
  2963.          {
  2964.              /*
  2965.               *    It failed to come up. Unhook it.
  2966.               */
  2967. -             
  2968. -            if (dev2 == NULL) 
  2969. -                dev_base = dev->next;
  2970. -            else 
  2971. -                dev2->next = dev->next;
  2972. +            *dp = dev->next;
  2973.          } 
  2974.          else
  2975.          {
  2976. -            dev2 = dev;
  2977. +            dp = &dev->next;
  2978.          }
  2979.      }
  2980.      proc_net_register(&(struct proc_dir_entry) {
  2981. @@ -1339,6 +1340,5 @@
  2982.          0, &proc_net_inode_operations,
  2983.          dev_get_info
  2984.      });
  2985. -
  2986.  }
  2987.  
  2988. diff -u --recursive --new-file v1.3.22/linux/net/ipv4/ip.c linux/net/ipv4/ip.c
  2989. --- v1.3.22/linux/net/ipv4/ip.c    Sun Sep  3 12:27:05 1995
  2990. +++ linux/net/ipv4/ip.c    Sat Sep  2 11:45:37 1995
  2991. @@ -1819,7 +1819,7 @@
  2992.      iph->tot_len = ntohs(skb->len-(((unsigned char *)iph)-skb->data));
  2993.  
  2994.  #ifdef CONFIG_IP_FIREWALL
  2995. -    if(ip_fw_chk(iph, dev, ip_fw_blk_chain, ip_fw_blk_policy, 0) != 1)
  2996. +    if(ip_fw_chk(iph, dev, ip_fw_blk_chain, ip_fw_blk_policy, 0) < 1)
  2997.          /* just don't send this packet */
  2998.          return;
  2999.  #endif    
  3000.