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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
sr.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：26k
源码类别：

嵌入式Linux

开发平台：

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);
  202. #ifdef DEBUG
  203. printk("sr.c done: %x %pn", result, SCpnt->request.bh->b_data);
  204. #endif
  205. /*
  206.    Handle MEDIUM ERRORs or VOLUME OVERFLOWs that indicate partial success.
  207.    Since this is a relatively rare error condition, no care is taken to
  208.    avoid unnecessary additional work such as memcpy's that could be avoided.
  209.  */
  212. if (driver_byte(result) != 0 && /* An error occurred */
  213.     SCpnt->sense_buffer[0] == 0xF0 && /* Sense data is valid */
  214.     (SCpnt->sense_buffer[2] == MEDIUM_ERROR ||
  215.      SCpnt->sense_buffer[2] == VOLUME_OVERFLOW ||
  216.      SCpnt->sense_buffer[2] == ILLEGAL_REQUEST)) {
  217. long error_sector = (SCpnt->sense_buffer[3] << 24) |
  218. (SCpnt->sense_buffer[4] << 16) |
  219. (SCpnt->sense_buffer[5] << 8) |
  220. SCpnt->sense_buffer[6];
  221. if (SCpnt->request.bh != NULL)
  222. block_sectors = SCpnt->request.bh->b_size >> 9;
  223. if (block_sectors < 4)
  224. block_sectors = 4;
  225. if (scsi_CDs[device_nr].device->sector_size == 2048)
  226. error_sector <<= 2;
  227. error_sector &= ~(block_sectors - 1);
  228. good_sectors = error_sector - SCpnt->request.sector;
  229. if (good_sectors < 0 || good_sectors >= this_count)
  230. good_sectors = 0;
  231. /*
  232.  * The SCSI specification allows for the value returned by READ
  233.  * CAPACITY to be up to 75 2K sectors past the last readable
  234.  * block.  Therefore, if we hit a medium error within the last
  235.  * 75 2K sectors, we decrease the saved size value.
  236.  */
  237. if ((error_sector >> 1) < sr_sizes[device_nr] &&
  238.     scsi_CDs[device_nr].capacity - error_sector < 4 * 75)
  239. sr_sizes[device_nr] = error_sector >> 1;
  240. }
  242. /*
  243.  * This calls the generic completion function, now that we know
  244.  * how many actual sectors finished, and how many sectors we need
  245.  * to say have failed.
  246.  */
  247. scsi_io_completion(SCpnt, good_sectors, block_sectors);
  248. }
  251. static request_queue_t *sr_find_queue(kdev_t dev)
  252. {
  253. /*
  254.  * No such device
  255.  */
  256. if (MINOR(dev) >= sr_template.dev_max || !scsi_CDs[MINOR(dev)].device)
  257. return NULL;
  259. return &scsi_CDs[MINOR(dev)].device->request_queue;
  260. }
  262. static int sr_scatter_pad(Scsi_Cmnd *SCpnt, int s_size)
  263. {
  264. struct scatterlist *sg, *old_sg = NULL;
  265. int i, fsize, bsize, sg_ent, sg_count;
  266. char *front, *back;
  267. void **bbpnt, **old_bbpnt = NULL;
  269. back = front = NULL;
  270. sg_ent = SCpnt->use_sg;
  271. bsize = 0; /* gcc... */
  273. /*
  274.  * need front pad
  275.  */
  276. if ((fsize = SCpnt->request.sector % (s_size >> 9))) {
  277. fsize <<= 9;
  278. sg_ent++;
  279. if ((front = scsi_malloc(fsize)) == NULL)
  280. goto no_mem;
  281. }
  282. /*
  283.  * need a back pad too
  284.  */
  285. if ((bsize = s_size - ((SCpnt->request_bufflen + fsize) % s_size))) {
  286. sg_ent++;
  287. if ((back = scsi_malloc(bsize)) == NULL)
  288. goto no_mem;
  289. }
  291. /*
  292.  * extend or allocate new scatter-gather table
  293.  */
  294. sg_count = SCpnt->use_sg;
  295. if (sg_count) {
  296. old_sg = (struct scatterlist *) SCpnt->request_buffer;
  297. old_bbpnt = SCpnt->bounce_buffers;
  298. } else {
  299. sg_count = 1;
  300. sg_ent++;
  301. }
  303. /* Get space for scatterlist and bounce buffer array. */
  304. i  = sg_ent * sizeof(struct scatterlist);
  305. i += sg_ent * sizeof(void *);
  306. i  = (i + 511) & ~511;
  308. if ((sg = scsi_malloc(i)) == NULL)
  309. goto no_mem;
  311. bbpnt = (void **)
  312. ((char *)sg + (sg_ent * sizeof(struct scatterlist)));
  314. /*
  315.  * no more failing memory allocs possible, we can safely assign
  316.  * SCpnt values now
  317.  */
  318. SCpnt->sglist_len = i;
  319. SCpnt->use_sg = sg_count;
  320. memset(sg, 0, SCpnt->sglist_len);
  322. i = 0;
  323. if (fsize) {
  324. sg[0].address = bbpnt[0] = front;
  325. sg[0].length = fsize;
  326. i++;
  327. }
  328. if (old_sg) {
  329. memcpy(sg + i, old_sg, SCpnt->use_sg * sizeof(struct scatterlist));
  330. memcpy(bbpnt + i, old_bbpnt, SCpnt->use_sg * sizeof(void *));
  331. scsi_free(old_sg, (((SCpnt->use_sg * sizeof(struct scatterlist)) +
  332.     (SCpnt->use_sg * sizeof(void *))) + 511) & ~511);
  333. } else {
  334. sg[i].address = SCpnt->request_buffer;
  335. sg[i].length = SCpnt->request_bufflen;
  336. }
  338. SCpnt->request_bufflen += (fsize + bsize);
  339. SCpnt->request_buffer = sg;
  340. SCpnt->bounce_buffers = bbpnt;
  341. SCpnt->use_sg += i;
  343. if (bsize) {
  344. sg[SCpnt->use_sg].address = back;
  345. bbpnt[SCpnt->use_sg] = back;
  346. sg[SCpnt->use_sg].length = bsize;
  347. SCpnt->use_sg++;
  348. }
  350. return 0;
  352. no_mem:
  353. printk("sr: ran out of mem for scatter padn");
  354. if (front)
  355. scsi_free(front, fsize);
  356. if (back)
  357. scsi_free(back, bsize);
  359. return 1;
  360. }
  363. static int sr_init_command(Scsi_Cmnd * SCpnt)
  364. {
  365. int dev, devm, block=0, this_count, s_size;
  367. devm = MINOR(SCpnt->request.rq_dev);
  368. dev = DEVICE_NR(SCpnt->request.rq_dev);
  370. SCSI_LOG_HLQUEUE(1, printk("Doing sr request, dev = %d, block = %dn", devm, block));
  372. if (dev >= sr_template.nr_dev ||
  373.     !scsi_CDs[dev].device ||
  374.     !scsi_CDs[dev].device->online) {
  375. SCSI_LOG_HLQUEUE(2, printk("Finishing %ld sectorsn", SCpnt->request.nr_sectors));
  376. SCSI_LOG_HLQUEUE(2, printk("Retry with 0x%pn", SCpnt));
  377. return 0;
  378. }
  379. if (scsi_CDs[dev].device->changed) {
  380. /*
  381.  * quietly refuse to do anything to a changed disc until the
  382.  * changed bit has been reset
  383.  */
  384. return 0;
  385. }
  387. if ((SCpnt->request.cmd == WRITE) && !scsi_CDs[dev].device->writeable)
  388. return 0;
  390. /*
  391.  * we do lazy blocksize switching (when reading XA sectors,
  392.  * see CDROMREADMODE2 ioctl) 
  393.  */
  394. s_size = scsi_CDs[dev].device->sector_size;
  395. if (s_size > 2048) {
  396. if (!in_interrupt())
  397. sr_set_blocklength(DEVICE_NR(CURRENT->rq_dev), 2048);
  398. else
  399. printk("sr: can't switch blocksize: in interruptn");
  400. }
  402. if (s_size != 512 && s_size != 1024 && s_size != 2048) {
  403. printk("sr: bad sector size %dn", s_size);
  404. return 0;
  405. }
  407. block = SCpnt->request.sector / (s_size >> 9);
  409. /*
  410.  * request doesn't start on hw block boundary, add scatter pads
  411.  */
  412. if ((SCpnt->request.sector % (s_size >> 9)) || (SCpnt->request_bufflen % s_size))
  413. if (sr_scatter_pad(SCpnt, s_size))
  414. return 0;
  416. this_count = (SCpnt->request_bufflen >> 9) / (s_size >> 9);
  418. switch (SCpnt->request.cmd) {
  419. case WRITE:
  420. SCpnt->cmnd[0] = WRITE_10;
  421. SCpnt->sc_data_direction = SCSI_DATA_WRITE;
  422. break;
  423. case READ:
  424. SCpnt->cmnd[0] = READ_10;
  425. SCpnt->sc_data_direction = SCSI_DATA_READ;
  426. break;
  427. default:
  428. printk("Unknown sr command %dn", SCpnt->request.cmd);
  429. return 0;
  430. }
  432. SCSI_LOG_HLQUEUE(2, printk("sr%d : %s %d/%ld 512 byte blocks.n",
  433.                                    devm,
  434.    (SCpnt->request.cmd == WRITE) ? "writing" : "reading",
  435.  this_count, SCpnt->request.nr_sectors));
  437. SCpnt->cmnd[1] = (SCpnt->device->scsi_level <= SCSI_2) ?
  438.  ((SCpnt->lun << 5) & 0xe0) : 0;
  440. if (this_count > 0xffff)
  441. this_count = 0xffff;
  443. SCpnt->cmnd[2] = (unsigned char) (block >> 24) & 0xff;
  444. SCpnt->cmnd[3] = (unsigned char) (block >> 16) & 0xff;
  445. SCpnt->cmnd[4] = (unsigned char) (block >> 8) & 0xff;
  446. SCpnt->cmnd[5] = (unsigned char) block & 0xff;
  447. SCpnt->cmnd[6] = SCpnt->cmnd[9] = 0;
  448. SCpnt->cmnd[7] = (unsigned char) (this_count >> 8) & 0xff;
  449. SCpnt->cmnd[8] = (unsigned char) this_count & 0xff;
  451. /*
  452.  * We shouldn't disconnect in the middle of a sector, so with a dumb
  453.  * host adapter, it's safe to assume that we can at least transfer
  454.  * this many bytes between each connect / disconnect.
  455.  */
  456. SCpnt->transfersize = scsi_CDs[dev].device->sector_size;
  457. SCpnt->underflow = this_count << 9;
  459. SCpnt->allowed = MAX_RETRIES;
  460. SCpnt->timeout_per_command = SR_TIMEOUT;
  462. /*
  463.  * This is the completion routine we use.  This is matched in terms
  464.  * of capability to this function.
  465.  */
  466. SCpnt->done = rw_intr;
  468. {
  469. struct scatterlist *sg = SCpnt->request_buffer;
  470. int i, size = 0;
  471. for (i = 0; i < SCpnt->use_sg; i++)
  472. size += sg[i].length;
  474. if (size != SCpnt->request_bufflen && SCpnt->use_sg) {
  475. printk("sr: mismatch count %d, bytes %dn", size, SCpnt->request_bufflen);
  476. SCpnt->request_bufflen = size;
  477. }
  478. }
  480. /*
  481.  * This indicates that the command is ready from our end to be
  482.  * queued.
  483.  */
  484. return 1;
  485. }
  487. struct block_device_operations sr_bdops =
  488. {
  489. owner: THIS_MODULE,
  490. open: cdrom_open,
  491. release: cdrom_release,
  492. ioctl: cdrom_ioctl,
  493. check_media_change: cdrom_media_changed,
  494. };
  496. static int sr_open(struct cdrom_device_info *cdi, int purpose)
  497. {
  498. check_disk_change(cdi->dev);
  500. if (MINOR(cdi->dev) >= sr_template.dev_max
  501.     || !scsi_CDs[MINOR(cdi->dev)].device) {
  502. return -ENXIO; /* No such device */
  503. }
  504. /*
  505.  * If the device is in error recovery, wait until it is done.
  506.  * If the device is offline, then disallow any access to it.
  507.  */
  508. if (!scsi_block_when_processing_errors(scsi_CDs[MINOR(cdi->dev)].device)) {
  509. return -ENXIO;
  510. }
  511. scsi_CDs[MINOR(cdi->dev)].device->access_count++;
  512. if (scsi_CDs[MINOR(cdi->dev)].device->host->hostt->module)
  513. __MOD_INC_USE_COUNT(scsi_CDs[MINOR(cdi->dev)].device->host->hostt->module);
  514. if (sr_template.module)
  515. __MOD_INC_USE_COUNT(sr_template.module);
  517. /* If this device did not have media in the drive at boot time, then
  518.  * we would have been unable to get the sector size.  Check to see if
  519.  * this is the case, and try again.
  520.  */
  522. if (scsi_CDs[MINOR(cdi->dev)].needs_sector_size)
  523. get_sectorsize(MINOR(cdi->dev));
  525. return 0;
  526. }
  528. static int sr_detect(Scsi_Device * SDp)
  529. {
  531. if (SDp->type != TYPE_ROM && SDp->type != TYPE_WORM)
  532. return 0;
  533. sr_template.dev_noticed++;
  534. return 1;
  535. }
  537. static int sr_attach(Scsi_Device * SDp)
  538. {
  539. Scsi_CD *cpnt;
  540. int i;
  542. if (SDp->type != TYPE_ROM && SDp->type != TYPE_WORM)
  543. return 1;
  545. if (sr_template.nr_dev >= sr_template.dev_max) {
  546. SDp->attached--;
  547. return 1;
  548. }
  549. for (cpnt = scsi_CDs, i = 0; i < sr_template.dev_max; i++, cpnt++)
  550. if (!cpnt->device)
  551. break;
  553. if (i >= sr_template.dev_max)
  554. panic("scsi_devices corrupt (sr)");
  557. scsi_CDs[i].device = SDp;
  559. sr_template.nr_dev++;
  560. if (sr_template.nr_dev > sr_template.dev_max)
  561. panic("scsi_devices corrupt (sr)");
  563. printk("Attached scsi CD-ROM sr%d at scsi%d, channel %d, id %d, lun %dn",
  564.        i, SDp->host->host_no, SDp->channel, SDp->id, SDp->lun);
  565. return 0;
  566. }
  569. void get_sectorsize(int i)
  570. {
  571. unsigned char cmd[10];
  572. unsigned char *buffer;
  573. int the_result, retries;
  574. int sector_size;
  575. Scsi_Request *SRpnt;
  577. buffer = (unsigned char *) scsi_malloc(512);
  578. SRpnt = scsi_allocate_request(scsi_CDs[i].device);
  580. if(buffer == NULL || SRpnt == NULL)
  581. {
  582. scsi_CDs[i].capacity = 0x1fffff;
  583. sector_size = 2048; /* A guess, just in case */
  584. scsi_CDs[i].needs_sector_size = 1;
  585. if(buffer)
  586. scsi_free(buffer, 512);
  587. if(SRpnt)
  588. scsi_release_request(SRpnt);
  589. return;
  590. }
  592. retries = 3;
  593. do {
  594. cmd[0] = READ_CAPACITY;
  595. cmd[1] = (scsi_CDs[i].device->scsi_level <= SCSI_2) ?
  596.  ((scsi_CDs[i].device->lun << 5) & 0xe0) : 0;
  597. memset((void *) &cmd[2], 0, 8);
  598. SRpnt->sr_request.rq_status = RQ_SCSI_BUSY; /* Mark as really busy */
  599. SRpnt->sr_cmd_len = 0;
  601. memset(buffer, 0, 8);
  603. /* Do the command and wait.. */
  605. SRpnt->sr_data_direction = SCSI_DATA_READ;
  606. scsi_wait_req(SRpnt, (void *) cmd, (void *) buffer,
  607.       8, SR_TIMEOUT, MAX_RETRIES);
  609. the_result = SRpnt->sr_result;
  610. retries--;
  612. } while (the_result && retries);
  615. scsi_release_request(SRpnt);
  616. SRpnt = NULL;
  618. if (the_result) {
  619. scsi_CDs[i].capacity = 0x1fffff;
  620. sector_size = 2048; /* A guess, just in case */
  621. scsi_CDs[i].needs_sector_size = 1;
  622. } else {
  623. #if 0
  624. if (cdrom_get_last_written(MKDEV(MAJOR_NR, i),
  625.    &scsi_CDs[i].capacity))
  626. #endif
  627. scsi_CDs[i].capacity = 1 + ((buffer[0] << 24) |
  628.     (buffer[1] << 16) |
  629.     (buffer[2] << 8) |
  630.     buffer[3]);
  631. sector_size = (buffer[4] << 24) |
  632.     (buffer[5] << 16) | (buffer[6] << 8) | buffer[7];
  633. switch (sector_size) {
  634. /*
  635.  * HP 4020i CD-Recorder reports 2340 byte sectors
  636.  * Philips CD-Writers report 2352 byte sectors
  637.  *
  638.  * Use 2k sectors for them..
  639.  */
  640. case 0:
  641. case 2340:
  642. case 2352:
  643. sector_size = 2048;
  644. /* fall through */
  645. case 2048:
  646. scsi_CDs[i].capacity *= 4;
  647. /* fall through */
  648. case 512:
  649. break;
  650. default:
  651. printk("sr%d: unsupported sector size %d.n",
  652.        i, sector_size);
  653. scsi_CDs[i].capacity = 0;
  654. scsi_CDs[i].needs_sector_size = 1;
  655. }
  657. scsi_CDs[i].device->sector_size = sector_size;
  659. /*
  660.  * Add this so that we have the ability to correctly gauge
  661.  * what the device is capable of.
  662.  */
  663. scsi_CDs[i].needs_sector_size = 0;
  664. sr_sizes[i] = scsi_CDs[i].capacity >> (BLOCK_SIZE_BITS - 9);
  665. };
  666. scsi_free(buffer, 512);
  667. }
  669. void get_capabilities(int i)
  670. {
  671. unsigned char cmd[6];
  672. unsigned char *buffer;
  673. int rc, n;
  675. static char *loadmech[] =
  676. {
  677. "caddy",
  678. "tray",
  679. "pop-up",
  680. "",
  681. "changer",
  682. "cartridge changer",
  683. "",
  684. ""
  685. };
  687. buffer = (unsigned char *) scsi_malloc(512);
  688. if (!buffer)
  689. {
  690. printk(KERN_ERR "sr: out of memory.n");
  691. return;
  692. }
  693. cmd[0] = MODE_SENSE;
  694. cmd[1] = (scsi_CDs[i].device->scsi_level <= SCSI_2) ?
  695.  ((scsi_CDs[i].device->lun << 5) & 0xe0) : 0;
  696. cmd[2] = 0x2a;
  697. cmd[4] = 128;
  698. cmd[3] = cmd[5] = 0;
  699. rc = sr_do_ioctl(i, cmd, buffer, 128, 1, SCSI_DATA_READ, NULL);
  701. if (rc) {
  702. /* failed, drive doesn't have capabilities mode page */
  703. scsi_CDs[i].cdi.speed = 1;
  704. scsi_CDs[i].cdi.mask |= (CDC_CD_R | CDC_CD_RW | CDC_DVD_R |
  705.  CDC_DVD | CDC_DVD_RAM |
  706.  CDC_SELECT_DISC | CDC_SELECT_SPEED);
  707. scsi_free(buffer, 512);
  708. printk("sr%i: scsi-1 driven", i);
  709. return;
  710. }
  711. n = buffer[3] + 4;
  712. scsi_CDs[i].cdi.speed = ((buffer[n + 8] << 8) + buffer[n + 9]) / 176;
  713. scsi_CDs[i].readcd_known = 1;
  714. scsi_CDs[i].readcd_cdda = buffer[n + 5] & 0x01;
  715. /* print some capability bits */
  716. printk("sr%i: scsi3-mmc drive: %dx/%dx %s%s%s%s%s%sn", i,
  717.        ((buffer[n + 14] << 8) + buffer[n + 15]) / 176,
  718.        scsi_CDs[i].cdi.speed,
  719.        buffer[n + 3] & 0x01 ? "writer " : "", /* CD Writer */
  720.        buffer[n + 3] & 0x20 ? "dvd-ram " : "",
  721.        buffer[n + 2] & 0x02 ? "cd/rw " : "", /* can read rewriteable */
  722.        buffer[n + 4] & 0x20 ? "xa/form2 " : "", /* can read xa/from2 */
  723.        buffer[n + 5] & 0x01 ? "cdda " : "", /* can read audio data */
  724.        loadmech[buffer[n + 6] >> 5]);
  725. if ((buffer[n + 6] >> 5) == 0)
  726. /* caddy drives can't close tray... */
  727. scsi_CDs[i].cdi.mask |= CDC_CLOSE_TRAY;
  728. if ((buffer[n + 2] & 0x8) == 0)
  729. /* not a DVD drive */
  730. scsi_CDs[i].cdi.mask |= CDC_DVD;
  731. if ((buffer[n + 3] & 0x20) == 0) {
  732. /* can't write DVD-RAM media */
  733. scsi_CDs[i].cdi.mask |= CDC_DVD_RAM;
  734. } else {
  735. scsi_CDs[i].device->writeable = 1;
  736. }
  737. if ((buffer[n + 3] & 0x10) == 0)
  738. /* can't write DVD-R media */
  739. scsi_CDs[i].cdi.mask |= CDC_DVD_R;
  740. if ((buffer[n + 3] & 0x2) == 0)
  741. /* can't write CD-RW media */
  742. scsi_CDs[i].cdi.mask |= CDC_CD_RW;
  743. if ((buffer[n + 3] & 0x1) == 0)
  744. /* can't write CD-R media */
  745. scsi_CDs[i].cdi.mask |= CDC_CD_R;
  746. if ((buffer[n + 6] & 0x8) == 0)
  747. /* can't eject */
  748. scsi_CDs[i].cdi.mask |= CDC_OPEN_TRAY;
  750. if ((buffer[n + 6] >> 5) == mechtype_individual_changer ||
  751.     (buffer[n + 6] >> 5) == mechtype_cartridge_changer)
  752. scsi_CDs[i].cdi.capacity =
  753.     cdrom_number_of_slots(&(scsi_CDs[i].cdi));
  754. if (scsi_CDs[i].cdi.capacity <= 1)
  755. /* not a changer */
  756. scsi_CDs[i].cdi.mask |= CDC_SELECT_DISC;
  757. /*else    I don't think it can close its tray
  758.    scsi_CDs[i].cdi.mask |= CDC_CLOSE_TRAY; */
  760. scsi_free(buffer, 512);
  761. }
  763. /*
  764.  * sr_packet() is the entry point for the generic commands generated
  765.  * by the Uniform CD-ROM layer. 
  766.  */
  767. static int sr_packet(struct cdrom_device_info *cdi, struct cdrom_generic_command *cgc)
  768. {
  769. Scsi_Device *device = scsi_CDs[MINOR(cdi->dev)].device;
  771. /* set the LUN */
  772. if (device->scsi_level <= SCSI_2)
  773. cgc->cmd[1] |= device->lun << 5;
  775. cgc->stat = sr_do_ioctl(MINOR(cdi->dev), cgc->cmd, cgc->buffer, cgc->buflen, cgc->quiet, cgc->data_direction, cgc->sense);
  777. return cgc->stat;
  778. }
  780. static int sr_registered;
  782. static int sr_init()
  783. {
  784. int i;
  786. if (sr_template.dev_noticed == 0)
  787. return 0;
  789. if (!sr_registered) {
  790. if (devfs_register_blkdev(MAJOR_NR, "sr", &sr_bdops)) {
  791. printk("Unable to get major %d for SCSI-CDn", MAJOR_NR);
  792. sr_template.dev_noticed = 0;
  793. return 1;
  794. }
  795. sr_registered++;
  796. }
  797. if (scsi_CDs)
  798. return 0;
  800. sr_template.dev_max = sr_template.dev_noticed + SR_EXTRA_DEVS;
  801. scsi_CDs = kmalloc(sr_template.dev_max * sizeof(Scsi_CD), GFP_ATOMIC);
  802. if (!scsi_CDs)
  803. goto cleanup_devfs;
  804. memset(scsi_CDs, 0, sr_template.dev_max * sizeof(Scsi_CD));
  806. sr_sizes = kmalloc(sr_template.dev_max * sizeof(int), GFP_ATOMIC);
  807. if (!sr_sizes)
  808. goto cleanup_cds;
  809. memset(sr_sizes, 0, sr_template.dev_max * sizeof(int));
  811. sr_blocksizes = kmalloc(sr_template.dev_max * sizeof(int), GFP_ATOMIC);
  812. if (!sr_blocksizes)
  813. goto cleanup_sizes;
  815. sr_hardsizes = kmalloc(sr_template.dev_max * sizeof(int), GFP_ATOMIC);
  816. if (!sr_hardsizes)
  817. goto cleanup_blocksizes;
  818. /*
  819.  * These are good guesses for the time being.
  820.  */
  821. for (i = 0; i < sr_template.dev_max; i++) {
  822. sr_blocksizes[i] = 2048;
  823. sr_hardsizes[i] = 2048;
  824.         }
  825. blksize_size[MAJOR_NR] = sr_blocksizes;
  826.         hardsect_size[MAJOR_NR] = sr_hardsizes;
  827. return 0;
  828. cleanup_blocksizes:
  829. kfree(sr_blocksizes);
  830. cleanup_sizes:
  831. kfree(sr_sizes);
  832. cleanup_cds:
  833. kfree(scsi_CDs);
  834. scsi_CDs = NULL;
  835. cleanup_devfs:
  836. devfs_unregister_blkdev(MAJOR_NR, "sr");
  837. sr_template.dev_noticed = 0;
  838. sr_registered--;
  839. return 1;
  840. }
  842. void sr_finish()
  843. {
  844. int i;
  845. char name[6];
  847. blk_dev[MAJOR_NR].queue = sr_find_queue;
  848. blk_size[MAJOR_NR] = sr_sizes;
  850. for (i = 0; i < sr_template.nr_dev; ++i) {
  851. /* If we have already seen this, then skip it.  Comes up
  852.  * with loadable modules. */
  853. if (scsi_CDs[i].capacity)
  854. continue;
  855. scsi_CDs[i].capacity = 0x1fffff;
  856. scsi_CDs[i].device->sector_size = 2048; /* A guess, just in case */
  857. scsi_CDs[i].needs_sector_size = 1;
  858. scsi_CDs[i].device->changed = 1; /* force recheck CD type */
  859. #if 0
  860. /* seems better to leave this for later */
  861. get_sectorsize(i);
  862. printk("Scd sectorsize = %d bytes.n", scsi_CDs[i].sector_size);
  863. #endif
  864. scsi_CDs[i].use = 1;
  866. scsi_CDs[i].device->ten = 1;
  867. scsi_CDs[i].device->remap = 1;
  868. scsi_CDs[i].readcd_known = 0;
  869. scsi_CDs[i].readcd_cdda = 0;
  870. sr_sizes[i] = scsi_CDs[i].capacity >> (BLOCK_SIZE_BITS - 9);
  872. scsi_CDs[i].cdi.ops = &sr_dops;
  873. scsi_CDs[i].cdi.handle = &scsi_CDs[i];
  874. scsi_CDs[i].cdi.dev = MKDEV(MAJOR_NR, i);
  875. scsi_CDs[i].cdi.mask = 0;
  876. scsi_CDs[i].cdi.capacity = 1;
  877. /*
  878.  * FIXME: someone needs to handle a get_capabilities
  879.  * failure properly ??
  880.  */
  881. get_capabilities(i);
  882. sr_vendor_init(i);
  884. sprintf(name, "sr%d", i);
  885. strcpy(scsi_CDs[i].cdi.name, name);
  886.                 scsi_CDs[i].cdi.de =
  887.                     devfs_register (scsi_CDs[i].device->de, "cd",
  888.                                     DEVFS_FL_DEFAULT, MAJOR_NR, i,
  889.                                     S_IFBLK | S_IRUGO | S_IWUGO,
  890.                                     &sr_bdops, NULL);
  891. register_cdrom(&scsi_CDs[i].cdi);
  892. }
  895. /* If our host adapter is capable of scatter-gather, then we increase
  896.  * the read-ahead to 16 blocks (32 sectors).  If not, we use
  897.  * a two block (4 sector) read ahead. */
  898. if (scsi_CDs[0].device && scsi_CDs[0].device->host->sg_tablesize)
  899. read_ahead[MAJOR_NR] = 32; /* 32 sector read-ahead.  Always removable. */
  900. else
  901. read_ahead[MAJOR_NR] = 4; /* 4 sector read-ahead */
  903. return;
  904. }
  906. static void sr_detach(Scsi_Device * SDp)
  907. {
  908. Scsi_CD *cpnt;
  909. int i;
  911. if (scsi_CDs == NULL)
  912. return;
  913. for (cpnt = scsi_CDs, i = 0; i < sr_template.dev_max; i++, cpnt++)
  914. if (cpnt->device == SDp) {
  915. /*
  916.  * Since the cdrom is read-only, no need to sync the device.
  917.  * We should be kind to our buffer cache, however.
  918.  */
  919. invalidate_device(MKDEV(MAJOR_NR, i), 0);
  921. /*
  922.  * Reset things back to a sane state so that one can re-load a new
  923.  * driver (perhaps the same one).
  924.  */
  925. unregister_cdrom(&(cpnt->cdi));
  926. cpnt->device = NULL;
  927. cpnt->capacity = 0;
  928. SDp->attached--;
  929. sr_template.nr_dev--;
  930. sr_template.dev_noticed--;
  931. sr_sizes[i] = 0;
  932. return;
  933. }
  934. return;
  935. }
  937. static int __init init_sr(void)
  938. {
  939. sr_template.module = THIS_MODULE;
  940. return scsi_register_module(MODULE_SCSI_DEV, &sr_template);
  941. }
  943. static void __exit exit_sr(void)
  944. {
  945. scsi_unregister_module(MODULE_SCSI_DEV, &sr_template);
  946. devfs_unregister_blkdev(MAJOR_NR, "sr");
  947. sr_registered--;
  948. if (scsi_CDs != NULL) {
  949. kfree(scsi_CDs);
  951. kfree(sr_sizes);
  952. sr_sizes = NULL;
  954. kfree(sr_blocksizes);
  955. sr_blocksizes = NULL;
  956. kfree(sr_hardsizes);
  957. sr_hardsizes = NULL;
  958. }
  959. blksize_size[MAJOR_NR] = NULL;
  960.         hardsect_size[MAJOR_NR] = NULL;
  961. blk_size[MAJOR_NR] = NULL;
  962. read_ahead[MAJOR_NR] = 0;
  964. sr_template.dev_max = 0;
  965. }
  967. module_init(init_sr);
  968. module_exit(exit_sr);
  969. MODULE_LICENSE("GPL");