开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
sr.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：26k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

sr.c：源码内容
  1. /*
  2.  *  sr.c Copyright (C) 1992 David Giller
  3.  *           Copyright (C) 1993, 1994, 1995, 1999 Eric Youngdale
  4.  *
  5.  *  adapted from:
  6.  *      sd.c Copyright (C) 1992 Drew Eckhardt
  7.  *      Linux scsi disk driver by
  8.  *              Drew Eckhardt <drew@colorado.edu>
  9.  *
  10.  *      Modified by Eric Youngdale ericy@andante.org to
  11.  *      add scatter-gather, multiple outstanding request, and other
  12.  *      enhancements.
  13.  *
  14.  *          Modified by Eric Youngdale eric@andante.org to support loadable
  15.  *          low-level scsi drivers.
  16.  *
  17.  *       Modified by Thomas Quinot thomas@melchior.cuivre.fdn.fr to
  18.  *       provide auto-eject.
  19.  *
  20.  *          Modified by Gerd Knorr <kraxel@cs.tu-berlin.de> to support the
  21.  *          generic cdrom interface
  22.  *
  23.  *       Modified by Jens Axboe <axboe@suse.de> - Uniform sr_packet()
  24.  *       interface, capabilities probe additions, ioctl cleanups, etc.
  25.  *
  26.  *       Modified by Richard Gooch <rgooch@atnf.csiro.au> to support devfs
  27.  *
  28.  *       Modified by Jens Axboe <axboe@suse.de> - support DVD-RAM
  29.  *  transparently and loose the GHOST hack
  30.  *
  31.  *  Modified by Arnaldo Carvalho de Melo <acme@conectiva.com.br>
  32.  *  check resource allocation in sr_init and some cleanups
  33.  *
  34.  */
  36. #include <linux/module.h>
  38. #include <linux/fs.h>
  39. #include <linux/kernel.h>
  40. #include <linux/sched.h>
  41. #include <linux/mm.h>
  42. #include <linux/string.h>
  43. #include <linux/errno.h>
  44. #include <linux/cdrom.h>
  45. #include <linux/interrupt.h>
  46. #include <linux/init.h>
  47. #include <asm/system.h>
  48. #include <asm/io.h>
  49. #include <asm/uaccess.h>
  51. #define MAJOR_NR SCSI_CDROM_MAJOR
  52. #include <linux/blk.h>
  53. #include "scsi.h"
  54. #include "hosts.h"
  55. #include "sr.h"
  56. #include <scsi/scsi_ioctl.h> /* For the door lock/unlock commands */
  57. #include "constants.h"
  59. MODULE_PARM(xa_test, "i"); /* see sr_ioctl.c */
  61. #define MAX_RETRIES 3
  62. #define SR_TIMEOUT (30 * HZ)
  64. static int sr_init(void);
  65. static void sr_finish(void);
  66. static int sr_attach(Scsi_Device *);
  67. static int sr_detect(Scsi_Device *);
  68. static void sr_detach(Scsi_Device *);
  70. static int sr_init_command(Scsi_Cmnd *);
  72. static struct Scsi_Device_Template sr_template =
  73. {
  74. name:"cdrom",
  75. tag:"sr",
  76. scsi_type:TYPE_ROM,
  77. major:SCSI_CDROM_MAJOR,
  78. blk:1,
  79. detect:sr_detect,
  80. init:sr_init,
  81. finish:sr_finish,
  82. attach:sr_attach,
  83. detach:sr_detach,
  84. init_command:sr_init_command
  85. };
  87. Scsi_CD *scsi_CDs;
  88. static int *sr_sizes;
  90. static int *sr_blocksizes;
  91. static int *sr_hardsizes;
  93. static int sr_open(struct cdrom_device_info *, int);
  94. void get_sectorsize(int);
  95. void get_capabilities(int);
  97. static int sr_media_change(struct cdrom_device_info *, int);
  98. static int sr_packet(struct cdrom_device_info *, struct cdrom_generic_command *);
  100. static void sr_release(struct cdrom_device_info *cdi)
  101. {
  102. if (scsi_CDs[MINOR(cdi->dev)].device->sector_size > 2048)
  103. sr_set_blocklength(MINOR(cdi->dev), 2048);
  104. scsi_CDs[MINOR(cdi->dev)].device->access_count--;
  105. if (scsi_CDs[MINOR(cdi->dev)].device->host->hostt->module)
  106. __MOD_DEC_USE_COUNT(scsi_CDs[MINOR(cdi->dev)].device->host->hostt->module);
  107. if (sr_template.module)
  108. __MOD_DEC_USE_COUNT(sr_template.module);
  109. }
  111. static struct cdrom_device_ops sr_dops =
  112. {
  113. open: sr_open,
  114. release: sr_release,
  115. drive_status: sr_drive_status,
  116. media_changed: sr_media_change,
  117. tray_move: sr_tray_move,
  118. lock_door: sr_lock_door,
  119. select_speed: sr_select_speed,
  120. get_last_session: sr_get_last_session,
  121. get_mcn: sr_get_mcn,
  122. reset: sr_reset,
  123. audio_ioctl: sr_audio_ioctl,
  124. dev_ioctl: sr_dev_ioctl,
  125. capability: CDC_CLOSE_TRAY | CDC_OPEN_TRAY | CDC_LOCK |
  126. CDC_SELECT_SPEED | CDC_SELECT_DISC |
  127. CDC_MULTI_SESSION | CDC_MCN |
  128. CDC_MEDIA_CHANGED | CDC_PLAY_AUDIO |
  129. CDC_RESET | CDC_IOCTLS | CDC_DRIVE_STATUS |
  130. CDC_CD_R | CDC_CD_RW | CDC_DVD | CDC_DVD_R |
  131. CDC_DVD_RAM | CDC_GENERIC_PACKET,
  132. generic_packet: sr_packet,
  133. };
  135. /*
  136.  * This function checks to see if the media has been changed in the
  137.  * CDROM drive.  It is possible that we have already sensed a change,
  138.  * or the drive may have sensed one and not yet reported it.  We must
  139.  * be ready for either case. This function always reports the current
  140.  * value of the changed bit.  If flag is 0, then the changed bit is reset.
  141.  * This function could be done as an ioctl, but we would need to have
  142.  * an inode for that to work, and we do not always have one.
  143.  */
  145. int sr_media_change(struct cdrom_device_info *cdi, int slot)
  146. {
  147. int retval;
  149. if (CDSL_CURRENT != slot) {
  150. /* no changer support */
  151. return -EINVAL;
  152. }
  153. retval = scsi_ioctl(scsi_CDs[MINOR(cdi->dev)].device,
  154.     SCSI_IOCTL_TEST_UNIT_READY, 0);
  156. if (retval) {
  157. /* Unable to test, unit probably not ready.  This usually
  158.  * means there is no disc in the drive.  Mark as changed,
  159.  * and we will figure it out later once the drive is
  160.  * available again.  */
  162. scsi_CDs[MINOR(cdi->dev)].device->changed = 1;
  163. return 1; /* This will force a flush, if called from
  164.  * check_disk_change */
  165. };
  167. retval = scsi_CDs[MINOR(cdi->dev)].device->changed;
  168. scsi_CDs[MINOR(cdi->dev)].device->changed = 0;
  169. /* If the disk changed, the capacity will now be different,
  170.  * so we force a re-read of this information */
  171. if (retval) {
  172. /* check multisession offset etc */
  173. sr_cd_check(cdi);
  175. /* 
  176.  * If the disk changed, the capacity will now be different,
  177.  * so we force a re-read of this information 
  178.  * Force 2048 for the sector size so that filesystems won't
  179.  * be trying to use something that is too small if the disc
  180.  * has changed.
  181.  */
  182. scsi_CDs[MINOR(cdi->dev)].needs_sector_size = 1;
  184. scsi_CDs[MINOR(cdi->dev)].device->sector_size = 2048;
  185. }
  186. return retval;
  187. }
  189. /*
  190.  * rw_intr is the interrupt routine for the device driver.  It will be notified on the
  191.  * end of a SCSI read / write, and will take on of several actions based on success or failure.
  192.  */
  194. static void rw_intr(Scsi_Cmnd * SCpnt)
  195. {
  196. int result = SCpnt->result;
  197. int this_count = SCpnt->bufflen >> 9;
  198. int good_sectors = (result == 0 ? this_count : 0);
  199. int block_sectors = 0;
  200. int device_nr = DEVICE_NR(SCpnt->request.rq_dev);
  201. long error_sector;
  203. #ifdef DEBUG
  204. printk("sr.c done: %x %pn", result, SCpnt->request.bh->b_data);
  205. #endif
  206. /*
  207.    Handle MEDIUM ERRORs or VOLUME OVERFLOWs that indicate partial success.
  208.    Since this is a relatively rare error condition, no care is taken to
  209.    avoid unnecessary additional work such as memcpy's that could be avoided.
  210.  */
  213. if (driver_byte(result) != 0 && /* An error occurred */
  214.     SCpnt->sense_buffer[0] == 0xF0) { /* Sense data is valid */
  215. switch (SCpnt->sense_buffer[2]) {
  216. case MEDIUM_ERROR:
  217. case VOLUME_OVERFLOW:
  218. case ILLEGAL_REQUEST:
  219. error_sector = (SCpnt->sense_buffer[3] << 24) |
  220. (SCpnt->sense_buffer[4] << 16) |
  221. (SCpnt->sense_buffer[5] << 8) |
  222. SCpnt->sense_buffer[6];
  223. if (SCpnt->request.bh != NULL)
  224. block_sectors = SCpnt->request.bh->b_size >> 9;
  225. if (block_sectors < 4)
  226. block_sectors = 4;
  227. if (scsi_CDs[device_nr].device->sector_size == 2048)
  228. error_sector <<= 2;
  229. error_sector &= ~(block_sectors - 1);
  230. good_sectors = error_sector - SCpnt->request.sector;
  231. if (good_sectors < 0 || good_sectors >= this_count)
  232. good_sectors = 0;
  233. /*
  234.  * The SCSI specification allows for the value returned
  235.  * by READ CAPACITY to be up to 75 2K sectors past the
  236.  * last readable block.  Therefore, if we hit a medium
  237.  * error within the last 75 2K sectors, we decrease the
  238.  * saved size value.
  239.  */
  240. if ((error_sector >> 1) < sr_sizes[device_nr] &&
  241.     scsi_CDs[device_nr].capacity - error_sector < 4 *75)
  242. sr_sizes[device_nr] = error_sector >> 1;
  243. break;
  245. case RECOVERED_ERROR:
  246. /*
  247.  * An error occured, but it recovered.  Inform the
  248.  * user, but make sure that it's not treated as a
  249.  * hard error.
  250.  */
  251. print_sense("sr", SCpnt);
  252. result = 0;
  253. SCpnt->sense_buffer[0] = 0x0;
  254. good_sectors = this_count;
  255. break;
  257. default:
  258. break;
  259. }
  260. }
  262. /*
  263.  * This calls the generic completion function, now that we know
  264.  * how many actual sectors finished, and how many sectors we need
  265.  * to say have failed.
  266.  */
  267. scsi_io_completion(SCpnt, good_sectors, block_sectors);
  268. }
  271. static request_queue_t *sr_find_queue(kdev_t dev)
  272. {
  273. /*
  274.  * No such device
  275.  */
  276. if (MINOR(dev) >= sr_template.dev_max || !scsi_CDs[MINOR(dev)].device)
  277. return NULL;
  279. return &scsi_CDs[MINOR(dev)].device->request_queue;
  280. }
  282. static int sr_scatter_pad(Scsi_Cmnd *SCpnt, int s_size)
  283. {
  284. struct scatterlist *sg, *old_sg = NULL;
  285. int i, fsize, bsize, sg_ent, sg_count;
  286. char *front, *back;
  287. void **bbpnt, **old_bbpnt = NULL;
  289. back = front = NULL;
  290. sg_ent = SCpnt->use_sg;
  291. bsize = 0; /* gcc... */
  293. /*
  294.  * need front pad
  295.  */
  296. if ((fsize = SCpnt->request.sector % (s_size >> 9))) {
  297. fsize <<= 9;
  298. sg_ent++;
  299. if ((front = scsi_malloc(fsize)) == NULL)
  300. goto no_mem;
  301. }
  302. /*
  303.  * need a back pad too
  304.  */
  305. if ((bsize = s_size - ((SCpnt->request_bufflen + fsize) % s_size))) {
  306. sg_ent++;
  307. if ((back = scsi_malloc(bsize)) == NULL)
  308. goto no_mem;
  309. }
  311. /*
  312.  * extend or allocate new scatter-gather table
  313.  */
  314. sg_count = SCpnt->use_sg;
  315. if (sg_count) {
  316. old_sg = (struct scatterlist *) SCpnt->request_buffer;
  317. old_bbpnt = SCpnt->bounce_buffers;
  318. } else {
  319. sg_count = 1;
  320. sg_ent++;
  321. }
  323. /* Get space for scatterlist and bounce buffer array. */
  324. i  = sg_ent * sizeof(struct scatterlist);
  325. i += sg_ent * sizeof(void *);
  326. i  = (i + 511) & ~511;
  328. if ((sg = scsi_malloc(i)) == NULL)
  329. goto no_mem;
  331. bbpnt = (void **)
  332. ((char *)sg + (sg_ent * sizeof(struct scatterlist)));
  334. /*
  335.  * no more failing memory allocs possible, we can safely assign
  336.  * SCpnt values now
  337.  */
  338. SCpnt->sglist_len = i;
  339. SCpnt->use_sg = sg_count;
  340. memset(sg, 0, SCpnt->sglist_len);
  342. i = 0;
  343. if (fsize) {
  344. sg[0].address = bbpnt[0] = front;
  345. sg[0].length = fsize;
  346. i++;
  347. }
  348. if (old_sg) {
  349. memcpy(sg + i, old_sg, SCpnt->use_sg * sizeof(struct scatterlist));
  350. if (old_bbpnt)
  351. memcpy(bbpnt + i, old_bbpnt, SCpnt->use_sg * sizeof(void *));
  352. scsi_free(old_sg, (((SCpnt->use_sg * sizeof(struct scatterlist)) +
  353.     (SCpnt->use_sg * sizeof(void *))) + 511) & ~511);
  354. } else {
  355. sg[i].address = SCpnt->request_buffer;
  356. sg[i].length = SCpnt->request_bufflen;
  357. }
  359. SCpnt->request_bufflen += (fsize + bsize);
  360. SCpnt->request_buffer = sg;
  361. SCpnt->bounce_buffers = bbpnt;
  362. SCpnt->use_sg += i;
  364. if (bsize) {
  365. sg[SCpnt->use_sg].address = back;
  366. bbpnt[SCpnt->use_sg] = back;
  367. sg[SCpnt->use_sg].length = bsize;
  368. SCpnt->use_sg++;
  369. }
  371. return 0;
  373. no_mem:
  374. printk("sr: ran out of mem for scatter padn");
  375. if (front)
  376. scsi_free(front, fsize);
  377. if (back)
  378. scsi_free(back, bsize);
  380. return 1;
  381. }
  384. static int sr_init_command(Scsi_Cmnd * SCpnt)
  385. {
  386. int dev, devm, block=0, this_count, s_size;
  388. devm = MINOR(SCpnt->request.rq_dev);
  389. dev = DEVICE_NR(SCpnt->request.rq_dev);
  391. SCSI_LOG_HLQUEUE(1, printk("Doing sr request, dev = %d, block = %dn", devm, block));
  393. if (dev >= sr_template.nr_dev ||
  394.     !scsi_CDs[dev].device ||
  395.     !scsi_CDs[dev].device->online) {
  396. SCSI_LOG_HLQUEUE(2, printk("Finishing %ld sectorsn", SCpnt->request.nr_sectors));
  397. SCSI_LOG_HLQUEUE(2, printk("Retry with 0x%pn", SCpnt));
  398. return 0;
  399. }
  400. if (scsi_CDs[dev].device->changed) {
  401. /*
  402.  * quietly refuse to do anything to a changed disc until the
  403.  * changed bit has been reset
  404.  */
  405. return 0;
  406. }
  408. if ((SCpnt->request.cmd == WRITE) && !scsi_CDs[dev].device->writeable)
  409. return 0;
  411. /*
  412.  * we do lazy blocksize switching (when reading XA sectors,
  413.  * see CDROMREADMODE2 ioctl) 
  414.  */
  415. s_size = scsi_CDs[dev].device->sector_size;
  416. if (s_size > 2048) {
  417. if (!in_interrupt())
  418. sr_set_blocklength(DEVICE_NR(CURRENT->rq_dev), 2048);
  419. else
  420. printk("sr: can't switch blocksize: in interruptn");
  421. }
  423. if (s_size != 512 && s_size != 1024 && s_size != 2048) {
  424. printk("sr: bad sector size %dn", s_size);
  425. return 0;
  426. }
  428. block = SCpnt->request.sector / (s_size >> 9);
  430. /*
  431.  * request doesn't start on hw block boundary, add scatter pads
  432.  */
  433. if ((SCpnt->request.sector % (s_size >> 9)) || (SCpnt->request_bufflen % s_size))
  434. if (sr_scatter_pad(SCpnt, s_size))
  435. return 0;
  437. this_count = (SCpnt->request_bufflen >> 9) / (s_size >> 9);
  439. switch (SCpnt->request.cmd) {
  440. case WRITE:
  441. SCpnt->cmnd[0] = WRITE_10;
  442. SCpnt->sc_data_direction = SCSI_DATA_WRITE;
  443. break;
  444. case READ:
  445. SCpnt->cmnd[0] = READ_10;
  446. SCpnt->sc_data_direction = SCSI_DATA_READ;
  447. break;
  448. default:
  449. printk("Unknown sr command %dn", SCpnt->request.cmd);
  450. return 0;
  451. }
  453. SCSI_LOG_HLQUEUE(2, printk("sr%d : %s %d/%ld 512 byte blocks.n",
  454.                                    devm,
  455.    (SCpnt->request.cmd == WRITE) ? "writing" : "reading",
  456.  this_count, SCpnt->request.nr_sectors));
  458. SCpnt->cmnd[1] = (SCpnt->device->scsi_level <= SCSI_2) ?
  459.  ((SCpnt->lun << 5) & 0xe0) : 0;
  461. if (this_count > 0xffff)
  462. this_count = 0xffff;
  464. SCpnt->cmnd[2] = (unsigned char) (block >> 24) & 0xff;
  465. SCpnt->cmnd[3] = (unsigned char) (block >> 16) & 0xff;
  466. SCpnt->cmnd[4] = (unsigned char) (block >> 8) & 0xff;
  467. SCpnt->cmnd[5] = (unsigned char) block & 0xff;
  468. SCpnt->cmnd[6] = SCpnt->cmnd[9] = 0;
  469. SCpnt->cmnd[7] = (unsigned char) (this_count >> 8) & 0xff;
  470. SCpnt->cmnd[8] = (unsigned char) this_count & 0xff;
  472. /*
  473.  * We shouldn't disconnect in the middle of a sector, so with a dumb
  474.  * host adapter, it's safe to assume that we can at least transfer
  475.  * this many bytes between each connect / disconnect.
  476.  */
  477. SCpnt->transfersize = scsi_CDs[dev].device->sector_size;
  478. SCpnt->underflow = this_count << 9;
  480. SCpnt->allowed = MAX_RETRIES;
  481. SCpnt->timeout_per_command = SR_TIMEOUT;
  483. /*
  484.  * This is the completion routine we use.  This is matched in terms
  485.  * of capability to this function.
  486.  */
  487. SCpnt->done = rw_intr;
  489. {
  490. struct scatterlist *sg = SCpnt->request_buffer;
  491. int i, size = 0;
  492. for (i = 0; i < SCpnt->use_sg; i++)
  493. size += sg[i].length;
  495. if (size != SCpnt->request_bufflen && SCpnt->use_sg) {
  496. printk("sr: mismatch count %d, bytes %dn", size, SCpnt->request_bufflen);
  497. SCpnt->request_bufflen = size;
  498. }
  499. }
  501. /*
  502.  * This indicates that the command is ready from our end to be
  503.  * queued.
  504.  */
  505. return 1;
  506. }
  508. struct block_device_operations sr_bdops =
  509. {
  510. owner: THIS_MODULE,
  511. open: cdrom_open,
  512. release: cdrom_release,
  513. ioctl: cdrom_ioctl,
  514. check_media_change: cdrom_media_changed,
  515. };
  517. static int sr_open(struct cdrom_device_info *cdi, int purpose)
  518. {
  519. check_disk_change(cdi->dev);
  521. if (MINOR(cdi->dev) >= sr_template.dev_max
  522.     || !scsi_CDs[MINOR(cdi->dev)].device) {
  523. return -ENXIO; /* No such device */
  524. }
  525. /*
  526.  * If the device is in error recovery, wait until it is done.
  527.  * If the device is offline, then disallow any access to it.
  528.  */
  529. if (!scsi_block_when_processing_errors(scsi_CDs[MINOR(cdi->dev)].device)) {
  530. return -ENXIO;
  531. }
  532. scsi_CDs[MINOR(cdi->dev)].device->access_count++;
  533. if (scsi_CDs[MINOR(cdi->dev)].device->host->hostt->module)
  534. __MOD_INC_USE_COUNT(scsi_CDs[MINOR(cdi->dev)].device->host->hostt->module);
  535. if (sr_template.module)
  536. __MOD_INC_USE_COUNT(sr_template.module);
  538. /* If this device did not have media in the drive at boot time, then
  539.  * we would have been unable to get the sector size.  Check to see if
  540.  * this is the case, and try again.
  541.  */
  543. if (scsi_CDs[MINOR(cdi->dev)].needs_sector_size)
  544. get_sectorsize(MINOR(cdi->dev));
  546. return 0;
  547. }
  549. static int sr_detect(Scsi_Device * SDp)
  550. {
  552. if (SDp->type != TYPE_ROM && SDp->type != TYPE_WORM)
  553. return 0;
  554. sr_template.dev_noticed++;
  555. return 1;
  556. }
  558. static int sr_attach(Scsi_Device * SDp)
  559. {
  560. Scsi_CD *cpnt;
  561. int i;
  563. if (SDp->type != TYPE_ROM && SDp->type != TYPE_WORM)
  564. return 1;
  566. if (sr_template.nr_dev >= sr_template.dev_max) {
  567. SDp->attached--;
  568. return 1;
  569. }
  570. for (cpnt = scsi_CDs, i = 0; i < sr_template.dev_max; i++, cpnt++)
  571. if (!cpnt->device)
  572. break;
  574. if (i >= sr_template.dev_max)
  575. panic("scsi_devices corrupt (sr)");
  578. scsi_CDs[i].device = SDp;
  580. sr_template.nr_dev++;
  581. if (sr_template.nr_dev > sr_template.dev_max)
  582. panic("scsi_devices corrupt (sr)");
  584. printk("Attached scsi CD-ROM sr%d at scsi%d, channel %d, id %d, lun %dn",
  585.        i, SDp->host->host_no, SDp->channel, SDp->id, SDp->lun);
  586. return 0;
  587. }
  590. void get_sectorsize(int i)
  591. {
  592. unsigned char cmd[10];
  593. unsigned char *buffer;
  594. int the_result, retries;
  595. int sector_size;
  596. Scsi_Request *SRpnt;
  598. buffer = (unsigned char *) scsi_malloc(512);
  599. SRpnt = scsi_allocate_request(scsi_CDs[i].device);
  601. if(buffer == NULL || SRpnt == NULL)
  602. {
  603. scsi_CDs[i].capacity = 0x1fffff;
  604. sector_size = 2048; /* A guess, just in case */
  605. scsi_CDs[i].needs_sector_size = 1;
  606. if(buffer)
  607. scsi_free(buffer, 512);
  608. if(SRpnt)
  609. scsi_release_request(SRpnt);
  610. return;
  611. }
  613. retries = 3;
  614. do {
  615. cmd[0] = READ_CAPACITY;
  616. cmd[1] = (scsi_CDs[i].device->scsi_level <= SCSI_2) ?
  617.  ((scsi_CDs[i].device->lun << 5) & 0xe0) : 0;
  618. memset((void *) &cmd[2], 0, 8);
  619. SRpnt->sr_request.rq_status = RQ_SCSI_BUSY; /* Mark as really busy */
  620. SRpnt->sr_cmd_len = 0;
  622. memset(buffer, 0, 8);
  624. /* Do the command and wait.. */
  626. SRpnt->sr_data_direction = SCSI_DATA_READ;
  627. scsi_wait_req(SRpnt, (void *) cmd, (void *) buffer,
  628.       8, SR_TIMEOUT, MAX_RETRIES);
  630. the_result = SRpnt->sr_result;
  631. retries--;
  633. } while (the_result && retries);
  636. scsi_release_request(SRpnt);
  637. SRpnt = NULL;
  639. if (the_result) {
  640. scsi_CDs[i].capacity = 0x1fffff;
  641. sector_size = 2048; /* A guess, just in case */
  642. scsi_CDs[i].needs_sector_size = 1;
  643. } else {
  644. #if 0
  645. if (cdrom_get_last_written(MKDEV(MAJOR_NR, i),
  646.    &scsi_CDs[i].capacity))
  647. #endif
  648. scsi_CDs[i].capacity = 1 + ((buffer[0] << 24) |
  649.     (buffer[1] << 16) |
  650.     (buffer[2] << 8) |
  651.     buffer[3]);
  652. sector_size = (buffer[4] << 24) |
  653.     (buffer[5] << 16) | (buffer[6] << 8) | buffer[7];
  654. switch (sector_size) {
  655. /*
  656.  * HP 4020i CD-Recorder reports 2340 byte sectors
  657.  * Philips CD-Writers report 2352 byte sectors
  658.  *
  659.  * Use 2k sectors for them..
  660.  */
  661. case 0:
  662. case 2340:
  663. case 2352:
  664. sector_size = 2048;
  665. /* fall through */
  666. case 2048:
  667. scsi_CDs[i].capacity *= 4;
  668. /* fall through */
  669. case 512:
  670. break;
  671. default:
  672. printk("sr%d: unsupported sector size %d.n",
  673.        i, sector_size);
  674. scsi_CDs[i].capacity = 0;
  675. scsi_CDs[i].needs_sector_size = 1;
  676. }
  678. scsi_CDs[i].device->sector_size = sector_size;
  680. /*
  681.  * Add this so that we have the ability to correctly gauge
  682.  * what the device is capable of.
  683.  */
  684. scsi_CDs[i].needs_sector_size = 0;
  685. sr_sizes[i] = scsi_CDs[i].capacity >> (BLOCK_SIZE_BITS - 9);
  686. };
  687. scsi_free(buffer, 512);
  688. }
  690. void get_capabilities(int i)
  691. {
  692. unsigned char cmd[6];
  693. unsigned char *buffer;
  694. int rc, n;
  696. static char *loadmech[] =
  697. {
  698. "caddy",
  699. "tray",
  700. "pop-up",
  701. "",
  702. "changer",
  703. "cartridge changer",
  704. "",
  705. ""
  706. };
  708. buffer = (unsigned char *) scsi_malloc(512);
  709. if (!buffer)
  710. {
  711. printk(KERN_ERR "sr: out of memory.n");
  712. return;
  713. }
  714. cmd[0] = MODE_SENSE;
  715. cmd[1] = (scsi_CDs[i].device->scsi_level <= SCSI_2) ?
  716.  ((scsi_CDs[i].device->lun << 5) & 0xe0) : 0;
  717. cmd[2] = 0x2a;
  718. cmd[4] = 128;
  719. cmd[3] = cmd[5] = 0;
  720. rc = sr_do_ioctl(i, cmd, buffer, 128, 1, SCSI_DATA_READ, NULL);
  722. if (rc) {
  723. /* failed, drive doesn't have capabilities mode page */
  724. scsi_CDs[i].cdi.speed = 1;
  725. scsi_CDs[i].cdi.mask |= (CDC_CD_R | CDC_CD_RW | CDC_DVD_R |
  726.  CDC_DVD | CDC_DVD_RAM |
  727.  CDC_SELECT_DISC | CDC_SELECT_SPEED);
  728. scsi_free(buffer, 512);
  729. printk("sr%i: scsi-1 driven", i);
  730. return;
  731. }
  732. n = buffer[3] + 4;
  733. scsi_CDs[i].cdi.speed = ((buffer[n + 8] << 8) + buffer[n + 9]) / 176;
  734. scsi_CDs[i].readcd_known = 1;
  735. scsi_CDs[i].readcd_cdda = buffer[n + 5] & 0x01;
  736. /* print some capability bits */
  737. printk("sr%i: scsi3-mmc drive: %dx/%dx %s%s%s%s%s%sn", i,
  738.        ((buffer[n + 14] << 8) + buffer[n + 15]) / 176,
  739.        scsi_CDs[i].cdi.speed,
  740.        buffer[n + 3] & 0x01 ? "writer " : "", /* CD Writer */
  741.        buffer[n + 3] & 0x20 ? "dvd-ram " : "",
  742.        buffer[n + 2] & 0x02 ? "cd/rw " : "", /* can read rewriteable */
  743.        buffer[n + 4] & 0x20 ? "xa/form2 " : "", /* can read xa/from2 */
  744.        buffer[n + 5] & 0x01 ? "cdda " : "", /* can read audio data */
  745.        loadmech[buffer[n + 6] >> 5]);
  746. if ((buffer[n + 6] >> 5) == 0)
  747. /* caddy drives can't close tray... */
  748. scsi_CDs[i].cdi.mask |= CDC_CLOSE_TRAY;
  749. if ((buffer[n + 2] & 0x8) == 0)
  750. /* not a DVD drive */
  751. scsi_CDs[i].cdi.mask |= CDC_DVD;
  752. if ((buffer[n + 3] & 0x20) == 0) {
  753. /* can't write DVD-RAM media */
  754. scsi_CDs[i].cdi.mask |= CDC_DVD_RAM;
  755. } else {
  756. scsi_CDs[i].device->writeable = 1;
  757. }
  758. if ((buffer[n + 3] & 0x10) == 0)
  759. /* can't write DVD-R media */
  760. scsi_CDs[i].cdi.mask |= CDC_DVD_R;
  761. if ((buffer[n + 3] & 0x2) == 0)
  762. /* can't write CD-RW media */
  763. scsi_CDs[i].cdi.mask |= CDC_CD_RW;
  764. if ((buffer[n + 3] & 0x1) == 0)
  765. /* can't write CD-R media */
  766. scsi_CDs[i].cdi.mask |= CDC_CD_R;
  767. if ((buffer[n + 6] & 0x8) == 0)
  768. /* can't eject */
  769. scsi_CDs[i].cdi.mask |= CDC_OPEN_TRAY;
  771. if ((buffer[n + 6] >> 5) == mechtype_individual_changer ||
  772.     (buffer[n + 6] >> 5) == mechtype_cartridge_changer)
  773. scsi_CDs[i].cdi.capacity =
  774.     cdrom_number_of_slots(&(scsi_CDs[i].cdi));
  775. if (scsi_CDs[i].cdi.capacity <= 1)
  776. /* not a changer */
  777. scsi_CDs[i].cdi.mask |= CDC_SELECT_DISC;
  778. /*else    I don't think it can close its tray
  779.    scsi_CDs[i].cdi.mask |= CDC_CLOSE_TRAY; */
  781. scsi_free(buffer, 512);
  782. }
  784. /*
  785.  * sr_packet() is the entry point for the generic commands generated
  786.  * by the Uniform CD-ROM layer. 
  787.  */
  788. static int sr_packet(struct cdrom_device_info *cdi, struct cdrom_generic_command *cgc)
  789. {
  790. Scsi_Device *device = scsi_CDs[MINOR(cdi->dev)].device;
  792. /* set the LUN */
  793. if (device->scsi_level <= SCSI_2)
  794. cgc->cmd[1] |= device->lun << 5;
  796. cgc->stat = sr_do_ioctl(MINOR(cdi->dev), cgc->cmd, cgc->buffer, cgc->buflen, cgc->quiet, cgc->data_direction, cgc->sense);
  798. return cgc->stat;
  799. }
  801. static int sr_registered;
  803. static int sr_init()
  804. {
  805. int i;
  807. if (sr_template.dev_noticed == 0)
  808. return 0;
  810. if (!sr_registered) {
  811. if (devfs_register_blkdev(MAJOR_NR, "sr", &sr_bdops)) {
  812. printk("Unable to get major %d for SCSI-CDn", MAJOR_NR);
  813. sr_template.dev_noticed = 0;
  814. return 1;
  815. }
  816. sr_registered++;
  817. }
  818. if (scsi_CDs)
  819. return 0;
  821. sr_template.dev_max = sr_template.dev_noticed + SR_EXTRA_DEVS;
  822. scsi_CDs = kmalloc(sr_template.dev_max * sizeof(Scsi_CD), GFP_ATOMIC);
  823. if (!scsi_CDs)
  824. goto cleanup_devfs;
  825. memset(scsi_CDs, 0, sr_template.dev_max * sizeof(Scsi_CD));
  827. sr_sizes = kmalloc(sr_template.dev_max * sizeof(int), GFP_ATOMIC);
  828. if (!sr_sizes)
  829. goto cleanup_cds;
  830. memset(sr_sizes, 0, sr_template.dev_max * sizeof(int));
  832. sr_blocksizes = kmalloc(sr_template.dev_max * sizeof(int), GFP_ATOMIC);
  833. if (!sr_blocksizes)
  834. goto cleanup_sizes;
  836. sr_hardsizes = kmalloc(sr_template.dev_max * sizeof(int), GFP_ATOMIC);
  837. if (!sr_hardsizes)
  838. goto cleanup_blocksizes;
  839. /*
  840.  * These are good guesses for the time being.
  841.  */
  842. for (i = 0; i < sr_template.dev_max; i++) {
  843. sr_blocksizes[i] = 2048;
  844. sr_hardsizes[i] = 2048;
  845.         }
  846. blksize_size[MAJOR_NR] = sr_blocksizes;
  847.         hardsect_size[MAJOR_NR] = sr_hardsizes;
  848. return 0;
  849. cleanup_blocksizes:
  850. kfree(sr_blocksizes);
  851. cleanup_sizes:
  852. kfree(sr_sizes);
  853. cleanup_cds:
  854. kfree(scsi_CDs);
  855. scsi_CDs = NULL;
  856. cleanup_devfs:
  857. devfs_unregister_blkdev(MAJOR_NR, "sr");
  858. sr_template.dev_noticed = 0;
  859. sr_registered--;
  860. return 1;
  861. }
  863. void sr_finish()
  864. {
  865. int i;
  866. char name[6];
  868. blk_dev[MAJOR_NR].queue = sr_find_queue;
  869. blk_size[MAJOR_NR] = sr_sizes;
  871. for (i = 0; i < sr_template.nr_dev; ++i) {
  872. /* If we have already seen this, then skip it.  Comes up
  873.  * with loadable modules. */
  874. if (scsi_CDs[i].capacity)
  875. continue;
  876. scsi_CDs[i].capacity = 0x1fffff;
  877. scsi_CDs[i].device->sector_size = 2048; /* A guess, just in case */
  878. scsi_CDs[i].needs_sector_size = 1;
  879. scsi_CDs[i].device->changed = 1; /* force recheck CD type */
  880. #if 0
  881. /* seems better to leave this for later */
  882. get_sectorsize(i);
  883. printk("Scd sectorsize = %d bytes.n", scsi_CDs[i].sector_size);
  884. #endif
  885. scsi_CDs[i].use = 1;
  887. scsi_CDs[i].device->ten = 1;
  888. scsi_CDs[i].device->remap = 1;
  889. scsi_CDs[i].readcd_known = 0;
  890. scsi_CDs[i].readcd_cdda = 0;
  891. sr_sizes[i] = scsi_CDs[i].capacity >> (BLOCK_SIZE_BITS - 9);
  893. scsi_CDs[i].cdi.ops = &sr_dops;
  894. scsi_CDs[i].cdi.handle = &scsi_CDs[i];
  895. scsi_CDs[i].cdi.dev = MKDEV(MAJOR_NR, i);
  896. scsi_CDs[i].cdi.mask = 0;
  897. scsi_CDs[i].cdi.capacity = 1;
  898. /*
  899.  * FIXME: someone needs to handle a get_capabilities
  900.  * failure properly ??
  901.  */
  902. get_capabilities(i);
  903. sr_vendor_init(i);
  905. sprintf(name, "sr%d", i);
  906. strcpy(scsi_CDs[i].cdi.name, name);
  907.                 scsi_CDs[i].cdi.de =
  908.                     devfs_register (scsi_CDs[i].device->de, "cd",
  909.                                     DEVFS_FL_DEFAULT, MAJOR_NR, i,
  910.                                     S_IFBLK | S_IRUGO | S_IWUGO,
  911.                                     &sr_bdops, NULL);
  912. register_cdrom(&scsi_CDs[i].cdi);
  913. }
  916. /* If our host adapter is capable of scatter-gather, then we increase
  917.  * the read-ahead to 16 blocks (32 sectors).  If not, we use
  918.  * a two block (4 sector) read ahead. */
  919. if (scsi_CDs[0].device && scsi_CDs[0].device->host->sg_tablesize)
  920. read_ahead[MAJOR_NR] = 32; /* 32 sector read-ahead.  Always removable. */
  921. else
  922. read_ahead[MAJOR_NR] = 4; /* 4 sector read-ahead */
  924. return;
  925. }
  927. static void sr_detach(Scsi_Device * SDp)
  928. {
  929. Scsi_CD *cpnt;
  930. int i;
  932. if (scsi_CDs == NULL)
  933. return;
  934. for (cpnt = scsi_CDs, i = 0; i < sr_template.dev_max; i++, cpnt++)
  935. if (cpnt->device == SDp) {
  936. /*
  937.  * Since the cdrom is read-only, no need to sync the device.
  938.  * We should be kind to our buffer cache, however.
  939.  */
  940. invalidate_device(MKDEV(MAJOR_NR, i), 0);
  942. /*
  943.  * Reset things back to a sane state so that one can re-load a new
  944.  * driver (perhaps the same one).
  945.  */
  946. unregister_cdrom(&(cpnt->cdi));
  947. cpnt->device = NULL;
  948. cpnt->capacity = 0;
  949. SDp->attached--;
  950. sr_template.nr_dev--;
  951. sr_template.dev_noticed--;
  952. sr_sizes[i] = 0;
  953. return;
  954. }
  955. return;
  956. }
  958. static int __init init_sr(void)
  959. {
  960. sr_template.module = THIS_MODULE;
  961. return scsi_register_module(MODULE_SCSI_DEV, &sr_template);
  962. }
  964. static void __exit exit_sr(void)
  965. {
  966. scsi_unregister_module(MODULE_SCSI_DEV, &sr_template);
  967. devfs_unregister_blkdev(MAJOR_NR, "sr");
  968. sr_registered--;
  969. if (scsi_CDs != NULL) {
  970. kfree(scsi_CDs);
  972. kfree(sr_sizes);
  973. sr_sizes = NULL;
  975. kfree(sr_blocksizes);
  976. sr_blocksizes = NULL;
  977. kfree(sr_hardsizes);
  978. sr_hardsizes = NULL;
  979. }
  980. blksize_size[MAJOR_NR] = NULL;
  981.         hardsect_size[MAJOR_NR] = NULL;
  982. blk_size[MAJOR_NR] = NULL;
  983. read_ahead[MAJOR_NR] = 0;
  985. sr_template.dev_max = 0;
  986. }
  988. module_init(init_sr);
  989. module_exit(exit_sr);
  990. MODULE_LICENSE("GPL");