kernel-cd-mrw-2.patch

   1 diff -ur -X /home/axboe/cdrom/exclude /opt/kernel/linux-2.4.19-pre4/drivers/cdrom/cdrom.c linux/drivers/cdrom/cdrom.c
   2 --- /opt/kernel/linux-2.4.19-pre4/drivers/cdrom/cdrom.c Fri Nov 16 19:14:08 2001
   3 +++ linux/drivers/cdrom/cdrom.c Tue Mar 26 09:49:44 2002
   4 @@ -228,10 +228,16 @@
   5     3.12 Oct 18, 2000 - Jens Axboe <axboe@suse.de>
   6    -- Use quiet bit on packet commands not known to work
   7
   8 +   3.20 Sep 24, 2001 - Jens Axboe <axboe@suse.de>
   9 +  -- Various fixes and lots of cleanups not listed :-)
  10 +  -- Locking fixes
  11 +  -- Mt Rainier support
  12 +  -- DVD-RAM write open fixes
  13 +
  14  -------------------------------------------------------------------------*/
  15
  16 -#define REVISION "Revision: 3.12"
  17 -#define VERSION "Id: cdrom.c 3.12 2000/10/18"
  18 +#define REVISION "Revision: 3.20"
  19 +#define VERSION "Id: cdrom.c 3.20 2001/09/24"
  20
  21  /* I use an error-log mask to give fine grain control over the type of
  22     messages dumped to the system logs.  The available masks include: */
  23 @@ -266,7 +272,6 @@
  24  #include <linux/init.h>
  25
  26  #include <asm/fcntl.h>
  27 -#include <asm/segment.h>
  28  #include <asm/uaccess.h>
  29
  30  /* used to tell the module to turn on full debugging messages */
  31 @@ -279,11 +284,25 @@
  32  static int lockdoor = 1;
  33  /* will we ever get to use this... sigh. */
  34  static int check_media_type;
  35 +/* automatically restart mrw format */
  36 +static int mrw_format_restart = 1;
  37  MODULE_PARM(debug, "i");
  38  MODULE_PARM(autoclose, "i");
  39  MODULE_PARM(autoeject, "i");
  40  MODULE_PARM(lockdoor, "i");
  41  MODULE_PARM(check_media_type, "i");
  42 +MODULE_PARM(mrw_format_restart, "i");
  43 +
  44 +static spinlock_t cdrom_lock = SPIN_LOCK_UNLOCKED;
  45 +
  46 +static const char *mrw_format_status[] = {
  47 +       "not mrw",
  48 +       "bgformat inactive",
  49 +       "bgformat active",
  50 +       "mrw complete",
  51 +};
  52 +
  53 +static const char *mrw_address_space[] = { "DMA", "GAA" };
  54
  55  #if (ERRLOGMASK!=CD_NOTHING)
  56  #define cdinfo(type, fmt, args...) \
  57 @@ -321,6 +340,10 @@
  58  int cdrom_get_last_written(kdev_t dev, long *last_written);
  59  int cdrom_get_next_writable(kdev_t dev, long *next_writable);
  60
  61 +static int __cdrom_get_di(struct cdrom_device_info *cdi, disc_information *di);
  62 +
  63 +static int cdrom_mrw_exit(struct cdrom_device_info *cdi);
  64 +
  65  #ifdef CONFIG_SYSCTL
  66  static void cdrom_sysctl_register(void);
  67  #endif /* CONFIG_SYSCTL */
  68 @@ -348,13 +371,14 @@
  69                 return -1;
  70         if (cdo->open == NULL || cdo->release == NULL)
  71                 return -2;
  72 -       if ( !banner_printed ) {
  73 +       if (!banner_printed) {
  74                 printk(KERN_INFO "Uniform CD-ROM driver " REVISION "\n");
  75                 banner_printed = 1;
  76  #ifdef CONFIG_SYSCTL
  77                 cdrom_sysctl_register();
  78  #endif /* CONFIG_SYSCTL */
  79         }
  80 +
  81         ENSURE(drive_status, CDC_DRIVE_STATUS );
  82         ENSURE(media_changed, CDC_MEDIA_CHANGED);
  83         ENSURE(tray_move, CDC_CLOSE_TRAY | CDC_OPEN_TRAY);
  84 @@ -379,6 +403,9 @@
  85         if (check_media_type==1)
  86                 cdi->options |= (int) CDO_CHECK_TYPE;
  87
  88 +       if (CDROM_CAN(CDC_MRW_W))
  89 +               cdi->exit = cdrom_mrw_exit;
  90 +
  91         if (!devfs_handle)
  92                 devfs_handle = devfs_mk_dir (NULL, "cdroms", NULL);
  93         cdi->number = devfs_alloc_unique_number (&cdrom_numspace);
  94 @@ -399,9 +426,12 @@
  95                         devfs_auto_unregister (cdi->de, slave);
  96                 }
  97         }
  98 +
  99         cdinfo(CD_REG_UNREG, "drive \"/dev/%s\" registered\n", cdi->name);
 100 +       spin_lock(&cdrom_lock);
 101         cdi->next = topCdromPtr;
 102         topCdromPtr = cdi;
 103 +       spin_unlock(&cdrom_lock);
 104         return 0;
 105  }
 106  #undef ENSURE
 107 @@ -417,18 +447,26 @@
 108                 return -1;
 109
 110         prev = NULL;
 111 +       spin_lock(&cdrom_lock);
 112         cdi = topCdromPtr;
 113         while (cdi != NULL && cdi->dev != unreg->dev) {
 114                 prev = cdi;
 115                 cdi = cdi->next;
 116         }
 117
 118 -       if (cdi == NULL)
 119 +       if (cdi == NULL) {
 120 +               spin_unlock(&cdrom_lock);
 121                 return -2;
 122 +       }
 123         if (prev)
 124                 prev->next = cdi->next;
 125         else
 126                 topCdromPtr = cdi->next;
 127 +       spin_unlock(&cdrom_lock);
 128 +
 129 +       if (cdi->exit)
 130 +               cdi->exit(cdi);
 131 +
 132         cdi->ops->n_minors--;
 133         devfs_unregister (cdi->de);
 134         devfs_dealloc_unique_number (&cdrom_numspace, cdi->number);
 135 @@ -440,13 +478,292 @@
 136  {
 137         struct cdrom_device_info *cdi;
 138
 139 +       spin_lock(&cdrom_lock);
 140         cdi = topCdromPtr;
 141         while (cdi != NULL && cdi->dev != dev)
 142                 cdi = cdi->next;
 143 +       spin_unlock(&cdrom_lock);
 144
 145         return cdi;
 146  }
 147
 148 +int cdrom_get_media_event(struct cdrom_device_info *cdi,
 149 +                         struct media_event_desc *med)
 150 +{
 151 +       struct cdrom_generic_command cgc;
 152 +       unsigned char buffer[8];
 153 +       struct event_header *eh = (struct event_header *) buffer;
 154 +
 155 +       init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
 156 +       cgc.cmd[0] = GPCMD_GET_EVENT_STATUS_NOTIFICATION;
 157 +       cgc.cmd[1] = 1;         /* IMMED */
 158 +       cgc.cmd[4] = 1 << 4;    /* media event */
 159 +       cgc.cmd[8] = sizeof(buffer);
 160 +       cgc.quiet = 1;
 161 +
 162 +       if (cdi->ops->generic_packet(cdi, &cgc))
 163 +               return 1;
 164 +
 165 +       if (be16_to_cpu(eh->data_len) < sizeof(*med))
 166 +               return 1;
 167 +
 168 +       memcpy(med, &buffer[sizeof(*eh)], sizeof(*med));
 169 +       return 0;
 170 +}
 171 +
 172 +/*
 173 + * the first prototypes used 0x2c as the page code for the mrw mode page,
 174 + * subsequently this was changed to 0x03. probe the one used by this drive
 175 + */
 176 +int cdrom_mrw_probe_pc(struct cdrom_device_info *cdi)
 177 +{
 178 +       struct cdrom_generic_command cgc;
 179 +       char buffer[16];
 180 +
 181 +       init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
 182 +
 183 +       cgc.buffer = buffer;
 184 +       cgc.buflen = sizeof(buffer);
 185 +       cgc.timeout = HZ;
 186 +       cgc.quiet = 1;
 187 +
 188 +       if (!cdrom_mode_sense(cdi, &cgc, MRW_MODE_PC, 0)) {
 189 +               cdi->mrw_mode_page = MRW_MODE_PC;
 190 +               return 0;
 191 +       } else if (!cdrom_mode_sense(cdi, &cgc, MRW_MODE_PC_PRE1, 0)) {
 192 +               cdi->mrw_mode_page = MRW_MODE_PC_PRE1;
 193 +               return 0;
 194 +       } else {
 195 +               printk("cdrom: %s: unknown mrw mode page\n", cdi->name);
 196 +               return 1;
 197 +       }
 198 +
 199 +       printk("cdrom: %s: mrw mode page %x\n", cdi->name, cdi->mrw_mode_page);
 200 +}
 201 +
 202 +int cdrom_is_mrw(struct cdrom_device_info *cdi, int *write)
 203 +{
 204 +       struct cdrom_generic_command cgc;
 205 +       struct mrw_feature_desc *mfd;
 206 +       unsigned char buffer[16];
 207 +       int ret;
 208 +
 209 +       init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
 210 +
 211 +       cgc.cmd[0] = GPCMD_GET_CONFIGURATION;
 212 +       cgc.cmd[3] = CDF_MRW;
 213 +       cgc.cmd[8] = sizeof(buffer);
 214 +       cgc.quiet = 1;
 215 +
 216 +       if ((ret = cdi->ops->generic_packet(cdi, &cgc)))
 217 +               return ret;
 218 +
 219 +       mfd = (struct mrw_feature_desc *)&buffer[sizeof(struct feature_header)];
 220 +       *write = mfd->write;
 221 +
 222 +       if ((ret = cdrom_mrw_probe_pc(cdi)))
 223 +               return ret;
 224 +
 225 +       return 0;
 226 +}
 227 +
 228 +static int cdrom_mrw_bgformat(struct cdrom_device_info *cdi, int cont)
 229 +{
 230 +       struct cdrom_generic_command cgc;
 231 +       unsigned char buffer[12];
 232 +       int ret;
 233 +
 234 +       printk("cdrom: %sstarting format\n", cont ? "Re" : "");
 235 +
 236 +       /*
 237 +        * FmtData bit set (bit 4), format type is 1
 238 +        */
 239 +       init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_WRITE);
 240 +       cgc.cmd[0] = GPCMD_FORMAT_UNIT;
 241 +       cgc.cmd[1] = (1 << 4) | 1;
 242 +
 243 +       cgc.timeout = 5 * 60 * HZ;
 244 +
 245 +       /*
 246 +        * 4 byte format list header, 8 byte format list descriptor
 247 +        */
 248 +       buffer[1] = 1 << 1;
 249 +       buffer[3] = 8;
 250 +
 251 +       /*
 252 +        * nr_blocks field
 253 +        */
 254 +       buffer[4] = 0xff;
 255 +       buffer[5] = 0xff;
 256 +       buffer[6] = 0xff;
 257 +       buffer[7] = 0xff;
 258 +
 259 +       buffer[8] = 0x24 << 2;
 260 +       buffer[11] = cont;
 261 +
 262 +       ret = cdi->ops->generic_packet(cdi, &cgc);
 263 +       if (ret)
 264 +               printk("cdrom: bgformat failed\n");
 265 +
 266 +       return ret;
 267 +}
 268 +
 269 +static int cdrom_mrw_bgformat_susp(struct cdrom_device_info *cdi, int immed)
 270 +{
 271 +       struct cdrom_generic_command cgc;
 272 +
 273 +       init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
 274 +       cgc.cmd[0] = GPCMD_CLOSE_TRACK;
 275 +
 276 +       /*
 277 +        * Session = 1, Track = 0
 278 +        */
 279 +       cgc.cmd[1] = !!immed;
 280 +       cgc.cmd[2] = 1 << 1;
 281 +
 282 +       cgc.timeout = 300 * HZ;
 283 +
 284 +       return cdi->ops->generic_packet(cdi, &cgc);
 285 +}
 286 +
 287 +static int cdrom_flush_cache(struct cdrom_device_info *cdi)
 288 +{
 289 +       struct cdrom_generic_command cgc;
 290 +
 291 +       init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
 292 +       cgc.cmd[0] = GPCMD_FLUSH_CACHE;
 293 +
 294 +       cgc.timeout = 5 * 60 * HZ;
 295 +
 296 +       return cdi->ops->generic_packet(cdi, &cgc);
 297 +}
 298 +
 299 +static int cdrom_mrw_exit(struct cdrom_device_info *cdi)
 300 +{
 301 +       disc_information di;
 302 +       int ret = 0;
 303 +
 304 +       if (__cdrom_get_di(cdi, &di))
 305 +               return 1;
 306 +
 307 +       if (di.mrw_status == CDM_MRW_BGFORMAT_ACTIVE) {
 308 +               printk("cdrom: issuing MRW back ground format suspend\n");
 309 +               ret = cdrom_mrw_bgformat_susp(cdi, 0);
 310 +       }
 311 +
 312 +       if (!ret)
 313 +               ret = cdrom_flush_cache(cdi);
 314 +
 315 +       return ret;
 316 +}
 317 +
 318 +static int cdrom_mrw_set_lba_space(struct cdrom_device_info *cdi, int space)
 319 +{
 320 +       struct cdrom_generic_command cgc;
 321 +       struct mode_page_header *mph;
 322 +       char buffer[16];
 323 +       int ret, offset, size;
 324 +
 325 +       init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
 326 +
 327 +       cgc.buffer = buffer;
 328 +       cgc.buflen = sizeof(buffer);
 329 +
 330 +       if ((ret = cdrom_mode_sense(cdi, &cgc, cdi->mrw_mode_page, 0)))
 331 +               return ret;
 332 +
 333 +       mph = (struct mode_page_header *) buffer;
 334 +       offset = be16_to_cpu(mph->desc_length);
 335 +       size = be16_to_cpu(mph->mode_data_length) + 2;
 336 +
 337 +       buffer[offset + 3] = space;
 338 +       cgc.buflen = size;
 339 +
 340 +       if ((ret = cdrom_mode_select(cdi, &cgc)))
 341 +               return ret;
 342 +
 343 +       printk("cdrom: %s: mrw address space %s selected\n", cdi->name, mrw_address_space[space]);
 344 +       return 0;
 345 +}
 346 +
 347 +static int cdrom_media_erasable(struct cdrom_device_info *cdi)
 348 +{
 349 +       disc_information di;
 350 +
 351 +       if (__cdrom_get_di(cdi, &di))
 352 +               return 0;
 353 +
 354 +       return di.erasable;
 355 +}
 356 +
 357 +/*
 358 + * FIXME: check RO bit
 359 + */
 360 +static int cdrom_dvdram_open_write(struct cdrom_device_info *cdi)
 361 +{
 362 +       return !cdrom_media_erasable(cdi);
 363 +}
 364 +
 365 +static int cdrom_mrw_open_write(struct cdrom_device_info *cdi)
 366 +{
 367 +       disc_information di;
 368 +       int ret;
 369 +
 370 +       /*
 371 +        * always reset to GAA lba space on open
 372 +        */
 373 +       if (cdrom_mrw_set_lba_space(cdi, MRW_LBA_GAA))
 374 +               return 1;
 375 +
 376 +       if (__cdrom_get_di(cdi, &di))
 377 +               return 1;
 378 +
 379 +       if (!di.erasable)
 380 +               return 1;
 381 +
 382 +       /*
 383 +        * mrw_status
 384 +        * 0    -       not MRW formatted
 385 +        * 1    -       MRW bgformat started, but not running or complete
 386 +        * 2    -       MRW bgformat in progress
 387 +        * 3    -       MRW formatting complete
 388 +        */
 389 +       ret = 0;
 390 +       printk("cdrom open: mrw_status '%s'\n", mrw_format_status[di.mrw_status]);
 391 +       if (!di.mrw_status)
 392 +               ret = 1;
 393 +       else if (di.mrw_status == CDM_MRW_BGFORMAT_INACTIVE && mrw_format_restart)
 394 +               ret = cdrom_mrw_bgformat(cdi, 1);
 395 +
 396 +       return ret;
 397 +}
 398 +
 399 +/*
 400 + * returns 0 for ok to open write, non-0 to disallow
 401 + */
 402 +static int cdrom_open_write(struct cdrom_device_info *cdi)
 403 +{
 404 +       int ret;
 405 +
 406 +       if (CDROM_CAN(CDC_MRW_W))
 407 +               ret = cdrom_mrw_open_write(cdi);
 408 +       else if (CDROM_CAN(CDC_DVD_RAM))
 409 +               ret = cdrom_dvdram_open_write(cdi);
 410 +       else
 411 +               ret = 1;
 412 +
 413 +       return ret;
 414 +}
 415 +
 416 +static int cdrom_close_write(struct cdrom_device_info *cdi)
 417 +{
 418 +#if 0
 419 +       return cdrom_flush_cache(cdi);
 420 +#else
 421 +       return 0;
 422 +#endif
 423 +}
 424 +
 425  /* We use the open-option O_NONBLOCK to indicate that the
 426   * purpose of opening is only for subsequent ioctl() calls; no device
 427   * integrity checks are performed.
 428 @@ -465,8 +782,15 @@
 429         if ((cdi = cdrom_find_device(dev)) == NULL)
 430                 return -ENODEV;
 431
 432 -       if ((fp->f_mode & FMODE_WRITE) && !CDROM_CAN(CDC_DVD_RAM))
 433 -               return -EROFS;
 434 +       cdi->use_count++;
 435 +       ret = -EROFS;
 436 +       if (fp->f_mode & FMODE_WRITE) {
 437 +               printk("cdrom: %s opening for WRITE\n", current->comm);
 438 +               if (!CDROM_CAN(CDC_RAM))
 439 +                       goto out;
 440 +               if (cdrom_open_write(cdi))
 441 +                       goto out;
 442 +       }
 443
 444         /* if this was a O_NONBLOCK open and we should honor the flags,
 445          * do a quick open without drive/disc integrity checks. */
 446 @@ -475,12 +799,13 @@
 447         else
 448                 ret = open_for_data(cdi);
 449
 450 -       if (!ret) cdi->use_count++;
 451 -
 452         cdinfo(CD_OPEN, "Use count for \"/dev/%s\" now %d\n", cdi->name, cdi->use_count);
 453         /* Do this on open.  Don't wait for mount, because they might
 454             not be mounting, but opening with O_NONBLOCK */
 455         check_disk_change(dev);
 456 +out:
 457 +       if (ret)
 458 +               cdi->use_count--;
 459         return ret;
 460  }
 461
 462 @@ -491,6 +816,7 @@
 463         struct cdrom_device_ops *cdo = cdi->ops;
 464         tracktype tracks;
 465         cdinfo(CD_OPEN, "entering open_for_data\n");
 466 +
 467         /* Check if the driver can report drive status.  If it can, we
 468            can do clever things.  If it can't, well, we at least tried! */
 469         if (cdo->drive_status != NULL) {
 470 @@ -568,7 +894,7 @@
 471                 cdinfo(CD_OPEN, "open device failed.\n");
 472                 goto clean_up_and_return;
 473         }
 474 -       if (CDROM_CAN(CDC_LOCK) && cdi->options & CDO_LOCK) {
 475 +       if (CDROM_CAN(CDC_LOCK) && (cdi->options & CDO_LOCK)) {
 476                         cdo->lock_door(cdi, 1);
 477                         cdinfo(CD_OPEN, "door locked.\n");
 478         }
 479 @@ -646,7 +972,6 @@
 480         return 0;
 481  }
 482
 483 -
 484  /* Admittedly, the logic below could be performed in a nicer way. */
 485  int cdrom_release(struct inode *ip, struct file *fp)
 486  {
 487 @@ -657,17 +982,23 @@
 488
 489         cdinfo(CD_CLOSE, "entering cdrom_release\n");
 490
 491 -       if (cdi->use_count > 0)
 492 -               cdi->use_count--;
 493 -       if (cdi->use_count == 0)
 494 +       if (!--cdi->use_count) {
 495                 cdinfo(CD_CLOSE, "Use count for \"/dev/%s\" now zero\n", cdi->name);
 496 -       if (cdi->use_count == 0 &&
 497 -           cdo->capability & CDC_LOCK && !keeplocked) {
 498 -               cdinfo(CD_CLOSE, "Unlocking door!\n");
 499 -               cdo->lock_door(cdi, 0);
 500 +               if ((cdo->capability & CDC_LOCK) && !keeplocked) {
 501 +                       cdinfo(CD_CLOSE, "Unlocking door!\n");
 502 +                       cdo->lock_door(cdi, 0);
 503 +               }
 504         }
 505 +
 506         opened_for_data = !(cdi->options & CDO_USE_FFLAGS) ||
 507                 !(fp && fp->f_flags & O_NONBLOCK);
 508 +
 509 +       /*
 510 +        * flush cache on last write release
 511 +        */
 512 +       if (CDROM_CAN(CDC_RAM) && !cdi->use_count && opened_for_data)
 513 +               cdrom_close_write(cdi);
 514 +
 515         cdo->release(cdi);
 516         if (cdi->use_count == 0) {      /* last process that closes dev*/
 517                 if (opened_for_data &&
 518 @@ -1902,10 +2233,24 @@
 519                 }
 520         }
 521
 522 +       /*
 523 +        * queue command and wait for it to complete
 524 +        */
 525         ret = cdi->ops->generic_packet(cdi, cgc);
 526 -       __copy_to_user(usense, cgc->sense, sizeof(*usense));
 527 +
 528 +       /*
 529 +        * always copy back sense, command need not have failed for it to
 530 +        * contain useful info
 531 +        */
 532 +       if (usense)
 533 +               __copy_to_user(usense, cgc->sense, sizeof(*usense));
 534 +
 535 +       /*
 536 +        * this really needs to be modified to copy back good bytes
 537 +        */
 538         if (!ret && cgc->data_direction == CGC_DATA_READ)
 539                 __copy_to_user(ubuf, cgc->buffer, cgc->buflen);
 540 +
 541         kfree(cgc->buffer);
 542         return ret;
 543  }
 544 @@ -2234,10 +2579,8 @@
 545         return cdo->generic_packet(cdi, &cgc);
 546  }
 547
 548 -/* requires CD R/RW */
 549 -int cdrom_get_disc_info(kdev_t dev, disc_information *di)
 550 +static int __cdrom_get_di(struct cdrom_device_info *cdi, disc_information *di)
 551  {
 552 -       struct cdrom_device_info *cdi = cdrom_find_device(dev);
 553         struct cdrom_device_ops *cdo = cdi->ops;
 554         struct cdrom_generic_command cgc;
 555         int ret;
 556 @@ -2264,6 +2607,14 @@
 557         return cdo->generic_packet(cdi, &cgc);
 558  }
 559
 560 +/* requires CD R/RW */
 561 +int cdrom_get_disc_info(kdev_t dev, disc_information *di)
 562 +{
 563 +       struct cdrom_device_info *cdi = cdrom_find_device(dev);
 564 +
 565 +       return __cdrom_get_di(cdi, di);
 566 +}
 567 +
 568
 569  /* return the last written block on the CD-R media. this is for the udf
 570     file system. */
 571 @@ -2379,6 +2730,8 @@
 572  EXPORT_SYMBOL(cdrom_mode_sense);
 573  EXPORT_SYMBOL(init_cdrom_command);
 574  EXPORT_SYMBOL(cdrom_find_device);
 575 +EXPORT_SYMBOL(cdrom_get_media_event);
 576 +EXPORT_SYMBOL(cdrom_is_mrw);
 577
 578  #ifdef CONFIG_SYSCTL
 579
 580 @@ -2475,6 +2828,14 @@
 581         for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
 582             pos += sprintf(info+pos, "\t%d", CDROM_CAN(CDC_DVD_RAM) != 0);
 583
 584 +       pos += sprintf(info+pos, "\nCan read MRW:");
 585 +       for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
 586 +           pos += sprintf(info+pos, "\t\t%d", CDROM_CAN(CDC_MRW) != 0);
 587 +
 588 +       pos += sprintf(info+pos, "\nCan write MRW:");
 589 +       for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
 590 +           pos += sprintf(info+pos, "\t\t%d", CDROM_CAN(CDC_MRW_W) != 0);
 591 +
 592         strcpy(info+pos,"\n\n");
 593
 594          return proc_dostring(ctl, write, filp, buffer, lenp);
 595 diff -ur -X /home/axboe/cdrom/exclude /opt/kernel/linux-2.4.19-pre4/drivers/ide/ide-cd.c linux/drivers/ide/ide-cd.c
 596 --- /opt/kernel/linux-2.4.19-pre4/drivers/ide/ide-cd.c  Tue Mar 26 09:52:55 2002
 597 +++ linux/drivers/ide/ide-cd.c  Mon Mar 25 17:40:39 2002
 598 @@ -694,12 +698,17 @@
 599                 case GPCMD_BLANK:
 600                 case GPCMD_FORMAT_UNIT:
 601                 case GPCMD_RESERVE_RZONE_TRACK:
 602 -                       wait = WAIT_CMD;
 603 +               case GPCMD_CLOSE_TRACK:
 604 +               case GPCMD_FLUSH_CACHE:
 605 +                       wait = ATAPI_WAIT_PC;
 606                         break;
 607                 default:
 608 +                       if (!pc->quiet)
 609 +                               printk("ide-cd: cmd 0x%x timed out\n",pc->c[0]);
 610                         wait = 0;
 611                         break;
 612         }
 613 +
 614         return wait;
 615  }
 616
 617 @@ -745,7 +754,7 @@
 618                 (void) (HWIF(drive)->dmaproc(ide_dma_begin, drive));
 619
 620         if (CDROM_CONFIG_FLAGS (drive)->drq_interrupt) {
 621 -               ide_set_handler (drive, handler, WAIT_CMD, cdrom_timer_expiry);
 622 +               ide_set_handler (drive, handler, ATAPI_WAIT_PC, cdrom_timer_expiry);
 623                 OUT_BYTE (WIN_PACKETCMD, IDE_COMMAND_REG); /* packet command */
 624                 return ide_started;
 625         } else {
 626 @@ -1009,7 +1018,7 @@
 627
 628         /* Done moving data!
 629            Wait for another interrupt. */
 630 -       ide_set_handler(drive, &cdrom_read_intr, WAIT_CMD, NULL);
 631 +       ide_set_handler(drive, &cdrom_read_intr, ATAPI_WAIT_PC, NULL);
 632         return ide_started;
 633  }
 634
 635 @@ -1125,16 +1134,15 @@
 636         pc.c[7] = (nframes >> 8);
 637         pc.c[8] = (nframes & 0xff);
 638         put_unaligned(cpu_to_be32(frame), (unsigned int *) &pc.c[2]);
 639 -       pc.timeout = WAIT_CMD;
 640 +       pc.timeout = ATAPI_WAIT_PC;
 641
 642         /* Send the command to the drive and return. */
 643         return cdrom_transfer_packet_command(drive, &pc, &cdrom_read_intr);
 644  }
 645
 646 -
 647  #define IDECD_SEEK_THRESHOLD   (1000)                  /* 1000 blocks */
 648  #define IDECD_SEEK_TIMER       (5 * WAIT_MIN_SLEEP)    /* 100 ms */
 649 -#define IDECD_SEEK_TIMEOUT     WAIT_CMD                        /* 10 sec */
 650 +#define IDECD_SEEK_TIMEOUT     (2 * WAIT_CMD)          /* 20 sec */
 651
 652  static ide_startstop_t cdrom_seek_intr (ide_drive_t *drive)
 653  {
 654 @@ -1178,7 +1186,7 @@
 655         pc.c[0] = GPCMD_SEEK;
 656         put_unaligned(cpu_to_be32(frame), (unsigned int *) &pc.c[2]);
 657
 658 -       pc.timeout = WAIT_CMD;
 659 +       pc.timeout = ATAPI_WAIT_PC;
 660         return cdrom_transfer_packet_command(drive, &pc, &cdrom_seek_intr);
 661  }
 662
 663 @@ -1198,28 +1198,6 @@
 664         return cdrom_start_packet_command (drive, 0, cdrom_start_seek_continuation);
 665  }
 666
 667 -static inline int cdrom_merge_requests(struct request *rq, struct request *nxt)
 668 -{
 669 -       int ret = 1;
 670 -
 671 -       /*
 672 -        * partitions not really working, but better check anyway...
 673 -        */
 674 -       if (rq->cmd == nxt->cmd && rq->rq_dev == nxt->rq_dev) {
 675 -               if (rq->cmd == WRITE)
 676 -                       printk("merged write\n");
 677 -               rq->nr_sectors += nxt->nr_sectors;
 678 -               rq->hard_nr_sectors += nxt->nr_sectors;
 679 -               rq->bhtail->b_reqnext = nxt->bh;
 680 -               rq->bhtail = nxt->bhtail;
 681 -               list_del(&nxt->queue);
 682 -               blkdev_release_request(nxt);
 683 -               ret = 0;
 684 -       }
 685 -
 686 -       return ret;
 687 -}
 688 -
 689  /*
 690   * the current request will always be the first one on the list
 691   */
 692 @@ -1229,13 +1217,31 @@
 693                         break;
 694
 695                 nxt = blkdev_entry_to_request(entry);
 696 +
 697 +               if (rq->cmd != nxt->cmd)
 698 +                       break;
 699 +               if (rq->rq_dev != nxt->rq_dev)
 700 +                       break;
 701                 if (rq->sector + rq->nr_sectors != nxt->sector)
 702                         break;
 703 -               else if (rq->nr_sectors + nxt->nr_sectors > SECTORS_MAX)
 704 +               if (rq->nr_sectors + nxt->nr_sectors >= SECTORS_MAX)
 705                         break;
 706 -
 707 -               if (cdrom_merge_requests(rq, nxt))
 708 +               if (rq->nr_segments + nxt->nr_segments > PRD_ENTRIES)
 709                         break;
 710 +
 711 +               /*
 712 +                * ok to merge them
 713 +                */
 714 +               rq->nr_sectors += nxt->nr_sectors;
 715 +               rq->hard_nr_sectors += nxt->nr_sectors;
 716 +               rq->bhtail->b_reqnext = nxt->bh;
 717 +               rq->bhtail = nxt->bhtail;
 718 +
 719 +               /*
 720 +                * release nxt
 721 +                */
 722 +               blkdev_dequeue_request(nxt);
 723 +               blkdev_release_request(nxt);
 724         }
 725
 726         spin_unlock_irqrestore(&io_request_lock, flags);
 727 @@ -1399,7 +1405,7 @@
 728         }
 729
 730         /* Now we wait for another interrupt. */
 731 -       ide_set_handler (drive, &cdrom_pc_intr, WAIT_CMD, cdrom_timer_expiry);
 732 +       ide_set_handler (drive, &cdrom_pc_intr, ATAPI_WAIT_PC, cdrom_timer_expiry);
 733         return ide_started;
 734  }
 735
 736 @@ -1410,7 +1416,7 @@
 737         struct packet_command *pc = (struct packet_command *)rq->buffer;
 738
 739         if (!pc->timeout)
 740 -               pc->timeout = WAIT_CMD;
 741 +               pc->timeout = ATAPI_WAIT_PC;
 742
 743         /* Send the command to the drive and return. */
 744         return cdrom_transfer_packet_command(drive, pc, &cdrom_pc_intr);
 745 @@ -1624,7 +1630,7 @@
 746         }
 747
 748         /* re-arm handler */
 749 -       ide_set_handler(drive, &cdrom_write_intr, 5 * WAIT_CMD, NULL);
 750 +       ide_set_handler(drive, &cdrom_write_intr, ATAPI_WAIT_PC, NULL);
 751         return ide_started;
 752  }
 753
 754 @@ -1649,7 +1655,7 @@
 755         pc.c[7] = (nframes >> 8) & 0xff;
 756         pc.c[8] = nframes & 0xff;
 757         put_unaligned(cpu_to_be32(frame), (unsigned int *)&pc.c[2]);
 758 -       pc.timeout = 2 * WAIT_CMD;
 759 +       pc.timeout = ATAPI_WAIT_PC;
 760
 761         return cdrom_transfer_packet_command(drive, &pc, cdrom_write_intr);
 762  }
 763 @@ -2188,7 +2194,7 @@
 764         ide_drive_t *drive = (ide_drive_t*) cdi->handle;
 765
 766         if (cgc->timeout <= 0)
 767 -               cgc->timeout = WAIT_CMD;
 768 +               cgc->timeout = ATAPI_WAIT_PC;
 769
 770         /* here we queue the commands from the uniform CD-ROM
 771            layer. the packet must be complete, as we do not
 772 @@ -2200,6 +2206,7 @@
 773         pc.quiet = cgc->quiet;
 774         pc.timeout = cgc->timeout;
 775         pc.sense = cgc->sense;
 776 +
 777         return cgc->stat = cdrom_queue_packet_command(drive, &pc);
 778  }
 779
 780 @@ -2385,37 +2392,49 @@
 781          return 0;
 782  }
 783
 784 +/*
 785 + * add logic to try GET_EVENT command first to check for media and tray
 786 + * status. this should be supported by newer cd-r/w and all DVD etc
 787 + * drives
 788 + */
 789  static
 790  int ide_cdrom_drive_status (struct cdrom_device_info *cdi, int slot_nr)
 791  {
 792         ide_drive_t *drive = (ide_drive_t*) cdi->handle;
 793 +       struct media_event_desc med;
 794 +       struct request_sense sense;
 795 +       int stat;
 796
 797 -       if (slot_nr == CDSL_CURRENT) {
 798 -               struct request_sense sense;
 799 -               int stat = cdrom_check_status(drive, &sense);
 800 -               if (stat == 0 || sense.sense_key == UNIT_ATTENTION)
 801 -                       return CDS_DISC_OK;
 802 +       if (slot_nr != CDSL_CURRENT)
 803 +               return -EINVAL;
 804
 805 -               if (sense.sense_key == NOT_READY && sense.asc == 0x04 &&
 806 -                   sense.ascq == 0x04)
 807 -                       return CDS_DISC_OK;
 808 +       stat = cdrom_check_status(drive, &sense);
 809 +       if (!stat || sense.sense_key == UNIT_ATTENTION)
 810 +               return CDS_DISC_OK;
 811
 812 +       if (!cdrom_get_media_event(cdi, &med)) {
 813 +               if (med.media_present)
 814 +                       return CDS_DISC_OK;
 815 +               if (med.door_open)
 816 +                       return CDS_TRAY_OPEN;
 817 +       }
 818
 819 -               /*
 820 -                * If not using Mt Fuji extended media tray reports,
 821 -                * just return TRAY_OPEN since ATAPI doesn't provide
 822 -                * any other way to detect this...
 823 -                */
 824 -               if (sense.sense_key == NOT_READY) {
 825 -                       if (sense.asc == 0x3a && sense.ascq == 1)
 826 -                               return CDS_NO_DISC;
 827 -                       else
 828 -                               return CDS_TRAY_OPEN;
 829 -               }
 830 +       if (sense.sense_key == NOT_READY && sense.asc == 0x04 && sense.ascq == 0x04)
 831 +               return CDS_DISC_OK;
 832
 833 -               return CDS_DRIVE_NOT_READY;
 834 +       /*
 835 +        * If not using Mt Fuji extended media tray reports,
 836 +        * just return TRAY_OPEN since ATAPI doesn't provide
 837 +        * any other way to detect this...
 838 +        */
 839 +       if (sense.sense_key == NOT_READY) {
 840 +               if (sense.asc == 0x3a && sense.ascq == 1)
 841 +                       return CDS_NO_DISC;
 842 +               else
 843 +                       return CDS_TRAY_OPEN;
 844         }
 845 -       return -EINVAL;
 846 +
 847 +       return CDS_DRIVE_NOT_READY;
 848  }
 849
 850  static
 851 @@ -2523,7 +2542,8 @@
 852                                 CDC_MEDIA_CHANGED | CDC_PLAY_AUDIO | CDC_RESET |
 853                                 CDC_IOCTLS | CDC_DRIVE_STATUS | CDC_CD_R |
 854                                 CDC_CD_RW | CDC_DVD | CDC_DVD_R| CDC_DVD_RAM |
 855 -                               CDC_GENERIC_PACKET,
 856 +                               CDC_GENERIC_PACKET | CDC_MRW | CDC_MRW_W |
 857 +                               CDC_RAM,
 858         generic_packet:         ide_cdrom_packet,
 859  };
 860
 861 @@ -2558,6 +2578,10 @@
 862                 devinfo->mask |= CDC_PLAY_AUDIO;
 863         if (!CDROM_CONFIG_FLAGS (drive)->close_tray)
 864                 devinfo->mask |= CDC_CLOSE_TRAY;
 865 +       if (!CDROM_CONFIG_FLAGS(drive)->mrw)
 866 +               devinfo->mask |= CDC_MRW;
 867 +       if (!CDROM_CONFIG_FLAGS(drive)->mrw_w)
 868 +               devinfo->mask |= CDC_MRW_W;
 869
 870         devinfo->de = devfs_register(drive->de, "cd", DEVFS_FL_DEFAULT,
 871                                      HWIF(drive)->major, minor,
 872 @@ -2585,14 +2609,6 @@
 873                         size -= sizeof(cap->pad);
 874         }
 875
 876 -       /* we have to cheat a little here. the packet will eventually
 877 -        * be queued with ide_cdrom_packet(), which extracts the
 878 -        * drive from cdi->handle. Since this device hasn't been
 879 -        * registered with the Uniform layer yet, it can't do this.
 880 -        * Same goes for cdi->ops.
 881 -        */
 882 -       cdi->handle = (ide_drive_t *) drive;
 883 -       cdi->ops = &ide_cdrom_dops;
 884         init_cdrom_command(&cgc, cap, size, CGC_DATA_UNKNOWN);
 885         do { /* we seem to get stat=0x01,err=0x00 the first time (??) */
 886                 stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CAPABILITIES_PAGE, 0);
 887 @@ -2608,17 +2624,36 @@
 888         struct cdrom_info *info = drive->driver_data;
 889         struct cdrom_device_info *cdi = &info->devinfo;
 890         struct atapi_capabilities_page cap;
 891 -       int nslots = 1;
 892 +       int nslots = 1, mrw_write = 0;
 893
 894 -       if (CDROM_CONFIG_FLAGS (drive)->nec260) {
 895 +       if (CDROM_CONFIG_FLAGS (drive)->nec260 ||
 896 +           !strcmp(drive->id->model,"STINGRAY 8422 IDE 8X CD-ROM 7-27-95")) {
 897                 CDROM_CONFIG_FLAGS (drive)->no_eject = 0;
 898                 CDROM_CONFIG_FLAGS (drive)->audio_play = 1;
 899                 return nslots;
 900         }
 901
 902 +       /*
 903 +        * we have to cheat a little here. the packet will eventually
 904 +        * be queued with ide_cdrom_packet(), which extracts the
 905 +        * drive from cdi->handle. Since this device hasn't been
 906 +        * registered with the Uniform layer yet, it can't do this.
 907 +        * Same goes for cdi->ops.
 908 +        */
 909 +       cdi->handle = (ide_drive_t *) drive;
 910 +       cdi->ops = &ide_cdrom_dops;
 911 +
 912         if (ide_cdrom_get_capabilities(drive, &cap))
 913                 return 0;
 914
 915 +       if (!cdrom_is_mrw(cdi, &mrw_write)) {
 916 +               CDROM_CONFIG_FLAGS(drive)->mrw = 1;
 917 +               if (mrw_write) {
 918 +                       CDROM_CONFIG_FLAGS(drive)->mrw_w = 1;
 919 +                       CDROM_CONFIG_FLAGS(drive)->ram = 1;
 920 +               }
 921 +       }
 922 +
 923         if (cap.lock == 0)
 924                 CDROM_CONFIG_FLAGS (drive)->no_doorlock = 1;
 925         if (cap.eject)
 926 @@ -2631,8 +2666,10 @@
 927                 CDROM_CONFIG_FLAGS (drive)->test_write = 1;
 928         if (cap.dvd_ram_read || cap.dvd_r_read || cap.dvd_rom)
 929                 CDROM_CONFIG_FLAGS (drive)->dvd = 1;
 930 -       if (cap.dvd_ram_write)
 931 +       if (cap.dvd_ram_write) {
 932                 CDROM_CONFIG_FLAGS (drive)->dvd_ram = 1;
 933 +               CDROM_CONFIG_FLAGS(drive)->ram = 1;
 934 +       }
 935         if (cap.dvd_r_write)
 936                 CDROM_CONFIG_FLAGS (drive)->dvd_r = 1;
 937         if (cap.audio_play)
 938 @@ -2693,6 +2730,10 @@
 939                 (CDROM_CONFIG_FLAGS (drive)->cd_r)? "-R" : "",
 940                 (CDROM_CONFIG_FLAGS (drive)->cd_rw)? "/RW" : "");
 941
 942 +       if (CDROM_CONFIG_FLAGS(drive)->mrw || CDROM_CONFIG_FLAGS(drive)->mrw_w)
 943 +               printk(" CD-MR%s",
 944 +               CDROM_CONFIG_FLAGS(drive)->mrw_w ? "W" : "");
 945 +
 946          if (CDROM_CONFIG_FLAGS (drive)->is_changer)
 947                 printk (" changer w/%d slots", nslots);
 948          else
 949 @@ -2726,14 +2767,9 @@
 950         struct cdrom_info *info = drive->driver_data;
 951         struct cdrom_device_info *cdi = &info->devinfo;
 952         int minor = drive->select.b.unit << PARTN_BITS;
 953 +       kdev_t cd_dev = MKDEV(HWIF(drive)->major, minor);
 954         int nslots;
 955
 956 -       /*
 957 -        * default to read-only always and fix latter at the bottom
 958 -        */
 959 -       set_device_ro(MKDEV(HWIF(drive)->major, minor), 0);
 960 -       set_blocksize(MKDEV(HWIF(drive)->major, minor), CD_FRAMESIZE);
 961 -
 962         drive->special.all      = 0;
 963         drive->ready_stat       = 0;
 964
 965 @@ -2850,8 +2886,11 @@
 966
 967         nslots = ide_cdrom_probe_capabilities (drive);
 968
 969 -       if (CDROM_CONFIG_FLAGS(drive)->dvd_ram)
 970 -               set_device_ro(MKDEV(HWIF(drive)->major, minor), 0);
 971 +       /*
 972 +        * set correct block size and read-only for non-ram media
 973 +        */
 974 +       set_blocksize(cd_dev, CD_FRAMESIZE);
 975 +       set_device_ro(cd_dev, !CDROM_CONFIG_FLAGS(drive)->ram);
 976
 977         if (ide_cdrom_register (drive, nslots)) {
 978                 printk ("%s: ide_cdrom_setup failed to register device with the cdrom driver.\n", drive->name);
 979 diff -ur -X /home/axboe/cdrom/exclude /opt/kernel/linux-2.4.19-pre4/drivers/ide/ide-cd.h linux/drivers/ide/ide-cd.h
 980 --- /opt/kernel/linux-2.4.19-pre4/drivers/ide/ide-cd.h  Tue Mar 26 09:52:55 2002
 981 +++ linux/drivers/ide/ide-cd.h  Tue Mar 26 09:55:15 2002
 982 @@ -35,6 +35,11 @@
 983  #define NO_DOOR_LOCKING 0
 984  #endif
 985
 986 +/*
 987 + * typical timeout for packet command
 988 + */
 989 +#define ATAPI_WAIT_PC  (60 * HZ)
 990 +
 991  /************************************************************************/
 992
 993  #define SECTOR_BITS            9
 994 @@ -75,6 +80,9 @@
 995         __u8 dvd                : 1; /* Drive is a DVD-ROM */
 996         __u8 dvd_r              : 1; /* Drive can write DVD-R */
 997         __u8 dvd_ram            : 1; /* Drive can write DVD-RAM */
 998 +       __u8 mrw                : 1; /* drive can read mrw */
 999 +       __u8 mrw_w              : 1; /* drive can write mrw */
1000 +       __u8 ram                : 1; /* generic WRITE (dvd-ram/mrw) */
1001         __u8 test_write         : 1; /* Drive can fake writes */
1002         __u8 supp_disc_present  : 1; /* Changer can report exact contents
1003                                         of slots. */
1004 diff -ur -X /home/axboe/cdrom/exclude /opt/kernel/linux-2.4.19-pre4/drivers/ide/ide-dma.c linux/drivers/ide/ide-dma.c
1005 --- /opt/kernel/linux-2.4.19-pre4/drivers/ide/ide-dma.c Tue Mar 26 09:52:55 2002
1006 +++ linux/drivers/ide/ide-dma.c Mon Mar 25 08:42:18 2002
1007 @@ -204,25 +204,6 @@
1008  #endif /* CONFIG_IDEDMA_NEW_DRIVE_LISTINGS */
1009
1010  /*
1011 - * Our Physical Region Descriptor (PRD) table should be large enough
1012 - * to handle the biggest I/O request we are likely to see.  Since requests
1013 - * can have no more than 256 sectors, and since the typical blocksize is
1014 - * two or more sectors, we could get by with a limit of 128 entries here for
1015 - * the usual worst case.  Most requests seem to include some contiguous blocks,
1016 - * further reducing the number of table entries required.
1017 - *
1018 - * The driver reverts to PIO mode for individual requests that exceed
1019 - * this limit (possible with 512 byte blocksizes, eg. MSDOS f/s), so handling
1020 - * 100% of all crazy scenarios here is not necessary.
1021 - *
1022 - * As it turns out though, we must allocate a full 4KB page for this,
1023 - * so the two PRD tables (ide0 & ide1) will each get half of that,
1024 - * allowing each to have about 256 entries (8 bytes each) from this.
1025 - */
1026 -#define PRD_BYTES      8
1027 -#define PRD_ENTRIES    (PAGE_SIZE / (2 * PRD_BYTES))
1028 -
1029 -/*
1030   * dma_intr() is the handler for disk read/write DMA interrupts
1031   */
1032  ide_startstop_t ide_dma_intr (ide_drive_t *drive)
1033 diff -ur -X /home/axboe/cdrom/exclude /opt/kernel/linux-2.4.19-pre4/drivers/scsi/sr.c linux/drivers/scsi/sr.c
1034 --- /opt/kernel/linux-2.4.19-pre4/drivers/scsi/sr.c     Tue Mar 26 09:52:56 2002
1035 +++ linux/drivers/scsi/sr.c     Tue Mar 26 08:00:47 2002
1036 @@ -128,7 +128,8 @@
1037                                 CDC_MEDIA_CHANGED | CDC_PLAY_AUDIO |
1038                                 CDC_RESET | CDC_IOCTLS | CDC_DRIVE_STATUS |
1039                                 CDC_CD_R | CDC_CD_RW | CDC_DVD | CDC_DVD_R |
1040 -                               CDC_DVD_RAM | CDC_GENERIC_PACKET,
1041 +                               CDC_DVD_RAM | CDC_GENERIC_PACKET | CDC_MRW |
1042 +                               CDC_MRW_W | CDC_RAM,
1043         generic_packet:         sr_packet,
1044  };
1045
1046 @@ -690,7 +691,7 @@
1047  {
1048         unsigned char cmd[6];
1049         unsigned char *buffer;
1050 -       int rc, n;
1051 +       int rc, n, mrw_write = 0, mrw = 1;
1052
1053         static char *loadmech[] =
1054         {
1055 @@ -716,7 +717,7 @@
1056         cmd[2] = 0x2a;
1057         cmd[4] = 128;
1058         cmd[3] = cmd[5] = 0;
1059 -       rc = sr_do_ioctl(i, cmd, buffer, 128, 1, SCSI_DATA_READ, NULL, SR_TIMEOUT);
1060 +       rc = sr_do_ioctl(i, cmd, buffer, 128, 1, SCSI_DATA_READ, NULL, 0);
1061
1062         if (rc) {
1063                 /* failed, drive doesn't have capabilities mode page */
1064 @@ -728,6 +729,15 @@
1065                 printk("sr%i: scsi-1 drive\n", i);
1066                 return;
1067         }
1068 +
1069 +       if (cdrom_is_mrw(&scsi_CDs[i].cdi, &mrw_write)) {
1070 +               mrw = 0;
1071 +               scsi_CDs[i].cdi.mask |= CDC_MRW;
1072 +               scsi_CDs[i].cdi.mask |= CDC_MRW_W;
1073 +       }
1074 +       if (!mrw_write)
1075 +               scsi_CDs[i].cdi.mask |= CDC_MRW_W;
1076 +
1077         n = buffer[3] + 4;
1078         scsi_CDs[i].cdi.speed = ((buffer[n + 8] << 8) + buffer[n + 9]) / 176;
1079         scsi_CDs[i].readcd_known = 1;
1080 @@ -777,7 +785,14 @@
1081         /*else    I don't think it can close its tray
1082            scsi_CDs[i].cdi.mask |= CDC_CLOSE_TRAY; */
1083
1084 +       /*
1085 +        * if DVD-RAM of MRW-W, we are randomly writeable
1086 +        */
1087 +       if ((scsi_CDs[i].cdi.mask & (CDC_DVD_RAM | CDC_MRW_W)) != (CDC_DVD_RAM | CDC_MRW_W))
1088 +               scsi_CDs[i].device->writeable = 1;
1089 +
1090         scsi_free(buffer, 512);
1091 +
1092  }
1093
1094  /*
1095 diff -ur -X /home/axboe/cdrom/exclude /opt/kernel/linux-2.4.19-pre4/include/linux/cdrom.h linux/include/linux/cdrom.h
1096 --- /opt/kernel/linux-2.4.19-pre4/include/linux/cdrom.h Thu Nov 22 20:47:04 2001
1097 +++ linux/include/linux/cdrom.h Tue Mar 26 09:55:09 2002
1098 @@ -5,7 +5,7 @@
1099   *               1994, 1995   Eberhard Moenkeberg, emoenke@gwdg.de
1100   *               1996         David van Leeuwen, david@tm.tno.nl
1101   *               1997, 1998   Erik Andersen, andersee@debian.org
1102 - *               1998-2000    Jens Axboe, axboe@suse.de
1103 + *               1998-2002    Jens Axboe, axboe@suse.de
1104   */
1105
1106  #ifndef        _LINUX_CDROM_H
1107 @@ -387,6 +387,9 @@
1108  #define CDC_DVD                        0x8000  /* drive is a DVD */
1109  #define CDC_DVD_R              0x10000 /* drive can write DVD-R */
1110  #define CDC_DVD_RAM            0x20000 /* drive can write DVD-RAM */
1111 +#define CDC_MRW                        0x40000 /* drive can read MRW */
1112 +#define CDC_MRW_W              0x80000 /* drive can write MRW */
1113 +#define CDC_RAM                        0x100000 /* ok to open WRITE */
1114
1115  /* drive status possibilities returned by CDROM_DRIVE_STATUS ioctl */
1116  #define CDS_NO_INFO            0       /* if not implemented */
1117 @@ -714,16 +717,61 @@
1118         __u8 asb[46];
1119  };
1120
1121 -#ifdef __KERNEL__
1122 -#include <linux/devfs_fs_kernel.h>
1123 +/*
1124 + * feature profile
1125 + */
1126 +#define CDF_MRW                0x28
1127 +
1128 +/*
1129 + * media status bits
1130 + */
1131 +#define CDM_MRW_NOTMRW                 0
1132 +#define CDM_MRW_BGFORMAT_INACTIVE      1
1133 +#define CDM_MRW_BGFORMAT_ACTIVE                2
1134 +#define CDM_MRW_BGFORMAT_COMPLETE      3
1135 +
1136 +/*
1137 + * mrw address spaces
1138 + */
1139 +#define MRW_LBA_DMA                    0
1140 +#define MRW_LBA_GAA                    1
1141 +
1142 +/*
1143 + * mrw mode pages (first is deprecated) -- probed at init time and
1144 + * cdi->mrw_mode_page is set
1145 + */
1146 +#define MRW_MODE_PC_PRE1               0x2c
1147 +#define MRW_MODE_PC                    0x03
1148
1149 -struct cdrom_write_settings {
1150 -       unsigned char fpacket;          /* fixed/variable packets */
1151 -       unsigned long packet_size;      /* write out this number of packets */
1152 -       unsigned long nwa;              /* next writeable address */
1153 -       unsigned char writeable;        /* cdrom is writeable */
1154 +struct mrw_feature_desc {
1155 +       __u16 feature_code;
1156 +#if defined(__BIG_ENDIAN_BITFIELD)
1157 +       __u8 reserved1          : 2;
1158 +       __u8 feature_version    : 4;
1159 +       __u8 persistent         : 1;
1160 +       __u8 curr               : 1;
1161 +#elif defined(__LITTLE_ENDIAN_BITFIELD)
1162 +       __u8 curr               : 1;
1163 +       __u8 persistent         : 1;
1164 +       __u8 feature_version    : 4;
1165 +       __u8 reserved1          : 2;
1166 +#endif
1167 +       __u8 add_len;
1168 +#if defined(__BIG_ENDIAN_BITFIELD)
1169 +       __u8 reserved2          : 7;
1170 +       __u8 write              : 1;
1171 +#elif defined(__LITTLE_ENDIAN_BITFIELD)
1172 +       __u8 write              : 1;
1173 +       __u8 reserved2          : 7;
1174 +#endif
1175 +       __u8 reserved3;
1176 +       __u8 reserved4;
1177 +       __u8 reserved5;
1178  };
1179
1180 +#ifdef __KERNEL__
1181 +#include <linux/devfs_fs_kernel.h>
1182 +
1183  /* Uniform cdrom data structures for cdrom.c */
1184  struct cdrom_device_info {
1185         struct cdrom_device_ops  *ops;  /* link to device_ops */
1186 @@ -744,7 +792,9 @@
1187  /* per-device flags */
1188          __u8 sanyo_slot                : 2;    /* Sanyo 3 CD changer support */
1189          __u8 reserved          : 6;    /* not used yet */
1190 -       struct cdrom_write_settings write;
1191 +
1192 +       int (*exit)(struct cdrom_device_info *);
1193 +       int mrw_mode_page;
1194  };
1195
1196  struct cdrom_device_ops {
1197 @@ -819,6 +869,8 @@
1198                                void *buffer, int len, int type);
1199  extern struct cdrom_device_info *cdrom_find_device(kdev_t dev);
1200
1201 +#endif /* __KERNEL__ */
1202 +
1203  typedef struct {
1204         __u16 disc_information_length;
1205  #if defined(__BIG_ENDIAN_BITFIELD)
1206 @@ -842,9 +894,13 @@
1207         __u8 did_v                      : 1;
1208          __u8 dbc_v                     : 1;
1209          __u8 uru                       : 1;
1210 -        __u8 reserved2                 : 5;
1211 +        __u8 reserved2                 : 2;
1212 +       __u8 dbit                       : 1;
1213 +       __u8 mrw_status                 : 2;
1214  #elif defined(__LITTLE_ENDIAN_BITFIELD)
1215 -        __u8 reserved2                 : 5;
1216 +       __u8 mrw_status                 : 2;
1217 +       __u8 dbit                       : 1;
1218 +        __u8 reserved2                 : 2;
1219          __u8 uru                       : 1;
1220          __u8 dbc_v                     : 1;
1221         __u8 did_v                      : 1;
1222 @@ -901,10 +957,6 @@
1223         __u32 last_rec_address;
1224  } track_information;
1225
1226 -extern int cdrom_get_disc_info(kdev_t dev, disc_information *di);
1227 -extern int cdrom_get_track_info(kdev_t dev, __u16 track, __u8 type,
1228 -                               track_information *ti);
1229 -
1230  /* The SCSI spec says there could be 256 slots. */
1231  #define CDROM_MAX_SLOTS        256
1232
1233 @@ -1053,6 +1105,51 @@
1234         __u8 reserved3;
1235  } rpc_state_t;
1236
1237 -#endif  /* End of kernel only stuff */
1238 +struct feature_header {
1239 +       __u32 data_len;
1240 +       __u8 reserved1;
1241 +       __u8 reserved2;
1242 +       __u16 curr_profile;
1243 +};
1244 +
1245 +struct event_header {
1246 +       __u16 data_len;
1247 +#if defined(__BIG_ENDIAN_BITFIELD)
1248 +       __u8 nea                : 1;
1249 +       __u8 reserved1          : 4;
1250 +       __u8 notification_class : 3;
1251 +#elif defined(__LITTLE_ENDIAN_BITFIELD)
1252 +       __u8 notification_class : 3;
1253 +       __u8 reserved1          : 4;
1254 +       __u8 nea                : 1;
1255 +#endif
1256 +       __u8 supp_event_class;
1257 +};
1258 +
1259 +struct media_event_desc {
1260 +#if defined(__BIG_ENDIAN_BITFIELD)
1261 +       __u8 reserved1          : 4;
1262 +       __u8 media_event_code   : 4;
1263 +       __u8 reserved2          : 6;
1264 +       __u8 media_present      : 1;
1265 +       __u8 door_open          : 1;
1266 +#elif defined(__LITTLE_ENDIAN_BITFIELD)
1267 +       __u8 media_event_code   : 4;
1268 +       __u8 reserved1          : 4;
1269 +       __u8 door_open          : 1;
1270 +       __u8 media_present      : 1;
1271 +       __u8 reserved2          : 6;
1272 +#endif
1273 +       __u8 start_slot;
1274 +       __u8 end_slot;
1275 +};
1276 +
1277 +#ifdef __KERNEL__
1278 +extern int cdrom_get_disc_info(kdev_t dev, disc_information *di);
1279 +extern int cdrom_get_track_info(kdev_t dev, __u16 track, __u8 type,
1280 +                               track_information *ti);
1281 +extern int cdrom_get_media_event(struct cdrom_device_info *cdi, struct media_event_desc *med);
1282 +extern int cdrom_is_mrw(struct cdrom_device_info *cdi, int *write);
1283 +#endif /* __KERNEL__ */
1284
1285  #endif  /* _LINUX_CDROM_H */
1286 diff -ur -X /home/axboe/cdrom/exclude /opt/kernel/linux-2.4.19-pre4/include/linux/ide.h linux/include/linux/ide.h
1287 --- /opt/kernel/linux-2.4.19-pre4/include/linux/ide.h   Tue Mar 26 09:52:58 2002
1288 +++ linux/include/linux/ide.h   Mon Mar 25 11:55:23 2002
1289 @@ -259,6 +259,25 @@
1290  #endif
1291
1292  /*
1293 + * Our Physical Region Descriptor (PRD) table should be large enough
1294 + * to handle the biggest I/O request we are likely to see.  Since requests
1295 + * can have no more than 256 sectors, and since the typical blocksize is
1296 + * two or more sectors, we could get by with a limit of 128 entries here for
1297 + * the usual worst case.  Most requests seem to include some contiguous blocks,
1298 + * further reducing the number of table entries required.
1299 + *
1300 + * The driver reverts to PIO mode for individual requests that exceed
1301 + * this limit (possible with 512 byte blocksizes, eg. MSDOS f/s), so handling
1302 + * 100% of all crazy scenarios here is not necessary.
1303 + *
1304 + * As it turns out though, we must allocate a full 4KB page for this,
1305 + * so the two PRD tables (ide0 & ide1) will each get half of that,
1306 + * allowing each to have about 256 entries (8 bytes each) from this.
1307 + */
1308 +#define PRD_BYTES      8
1309 +#define PRD_ENTRIES    (PAGE_SIZE / (2 * PRD_BYTES))
1310 +
1311 +/*
1312   * hwif_chipset_t is used to keep track of the specific hardware
1313   * chipset used by each IDE interface, if known.
1314   */
1315 diff -ur -X /home/axboe/cdrom/exclude /opt/kernel/linux-2.4.19-pre4/include/linux/udf_fs.h linux/include/linux/udf_fs.h
1316 --- /opt/kernel/linux-2.4.19-pre4/include/linux/udf_fs.h        Tue Mar 26 09:52:58 2002
1317 +++ linux/include/linux/udf_fs.h        Mon Mar 25 08:50:14 2002
1318 @@ -30,6 +30,7 @@
1319   * HISTORY
1320   *
1321   */
1322 +#include <linux/config.h>
1323
1324  #ifndef _UDF_FS_H
1325  #define _UDF_FS_H 1