![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sr.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / i386 / i386at / gpl / linux / scsi|
Return to sr.c CVS log | Up to [GnuMach] / Gnu-Mach / i386 / i386at / gpl / linux / scsi |
1.1 ! root 1: /* ! 2: * sr.c Copyright (C) 1992 David Giller ! 3: * Copyright (C) 1993, 1994, 1995 Eric Youngdale ! 4: * ! 5: * adapted from: ! 6: * sd.c Copyright (C) 1992 Drew Eckhardt ! 7: * Linux scsi disk driver by ! 8: * Drew Eckhardt <[email protected]> ! 9: * ! 10: * Modified by Eric Youngdale [email protected] to ! 11: * add scatter-gather, multiple outstanding request, and other ! 12: * enhancements. ! 13: * ! 14: * Modified by Eric Youngdale [email protected] to support loadable ! 15: * low-level scsi drivers. ! 16: * ! 17: * Modified by Thomas Quinot [email protected] to ! 18: * provide auto-eject. ! 19: * ! 20: */ ! 21: ! 22: #include <linux/module.h> ! 23: ! 24: #include <linux/fs.h> ! 25: #include <linux/kernel.h> ! 26: #include <linux/sched.h> ! 27: #include <linux/mm.h> ! 28: #include <linux/string.h> ! 29: #include <linux/errno.h> ! 30: #include <linux/cdrom.h> ! 31: #include <asm/system.h> ! 32: ! 33: #define MAJOR_NR SCSI_CDROM_MAJOR ! 34: #include <linux/blk.h> ! 35: #include "scsi.h" ! 36: #include "hosts.h" ! 37: #include "sr.h" ! 38: #include "scsi_ioctl.h" /* For the door lock/unlock commands */ ! 39: #include "constants.h" ! 40: ! 41: #define MAX_RETRIES 3 ! 42: #define SR_TIMEOUT (150 * HZ) ! 43: ! 44: static int sr_init(void); ! 45: static void sr_finish(void); ! 46: static int sr_attach(Scsi_Device *); ! 47: static int sr_detect(Scsi_Device *); ! 48: static void sr_detach(Scsi_Device *); ! 49: ! 50: struct Scsi_Device_Template sr_template = {NULL, "cdrom", "sr", NULL, TYPE_ROM, ! 51: SCSI_CDROM_MAJOR, 0, 0, 0, 1, ! 52: sr_detect, sr_init, ! 53: sr_finish, sr_attach, sr_detach}; ! 54: ! 55: Scsi_CD * scsi_CDs = NULL; ! 56: static int * sr_sizes; ! 57: ! 58: static int * sr_blocksizes; ! 59: ! 60: static int sr_open(struct inode *, struct file *); ! 61: static void get_sectorsize(int); ! 62: ! 63: extern int sr_ioctl(struct inode *, struct file *, unsigned int, unsigned long); ! 64: ! 65: void requeue_sr_request (Scsi_Cmnd * SCpnt); ! 66: static int check_cdrom_media_change(kdev_t); ! 67: ! 68: static void sr_release(struct inode * inode, struct file * file) ! 69: { ! 70: sync_dev(inode->i_rdev); ! 71: if(! --scsi_CDs[MINOR(inode->i_rdev)].device->access_count) ! 72: { ! 73: sr_ioctl(inode, NULL, SCSI_IOCTL_DOORUNLOCK, 0); ! 74: if (scsi_CDs[MINOR(inode->i_rdev)].auto_eject) ! 75: sr_ioctl(inode, NULL, CDROMEJECT, 0); ! 76: } ! 77: if (scsi_CDs[MINOR(inode->i_rdev)].device->host->hostt->usage_count) ! 78: (*scsi_CDs[MINOR(inode->i_rdev)].device->host->hostt->usage_count)--; ! 79: if(sr_template.usage_count) (*sr_template.usage_count)--; ! 80: } ! 81: ! 82: static struct file_operations sr_fops = ! 83: { ! 84: NULL, /* lseek - default */ ! 85: block_read, /* read - general block-dev read */ ! 86: block_write, /* write - general block-dev write */ ! 87: NULL, /* readdir - bad */ ! 88: NULL, /* select */ ! 89: sr_ioctl, /* ioctl */ ! 90: NULL, /* mmap */ ! 91: sr_open, /* special open code */ ! 92: sr_release, /* release */ ! 93: NULL, /* fsync */ ! 94: NULL, /* fasync */ ! 95: check_cdrom_media_change, /* Disk change */ ! 96: NULL /* revalidate */ ! 97: }; ! 98: ! 99: /* ! 100: * This function checks to see if the media has been changed in the ! 101: * CDROM drive. It is possible that we have already sensed a change, ! 102: * or the drive may have sensed one and not yet reported it. We must ! 103: * be ready for either case. This function always reports the current ! 104: * value of the changed bit. If flag is 0, then the changed bit is reset. ! 105: * This function could be done as an ioctl, but we would need to have ! 106: * an inode for that to work, and we do not always have one. ! 107: */ ! 108: ! 109: int check_cdrom_media_change(kdev_t full_dev){ ! 110: int retval, target; ! 111: struct inode inode; ! 112: int flag = 0; ! 113: ! 114: target = MINOR(full_dev); ! 115: ! 116: if (target >= sr_template.nr_dev) { ! 117: printk("CD-ROM request error: invalid device.\n"); ! 118: return 0; ! 119: }; ! 120: ! 121: inode.i_rdev = full_dev; /* This is all we really need here */ ! 122: retval = sr_ioctl(&inode, NULL, SCSI_IOCTL_TEST_UNIT_READY, 0); ! 123: ! 124: if(retval){ /* Unable to test, unit probably not ready. This usually ! 125: * means there is no disc in the drive. Mark as changed, ! 126: * and we will figure it out later once the drive is ! 127: * available again. */ ! 128: ! 129: scsi_CDs[target].device->changed = 1; ! 130: return 1; /* This will force a flush, if called from ! 131: * check_disk_change */ ! 132: }; ! 133: ! 134: retval = scsi_CDs[target].device->changed; ! 135: if(!flag) { ! 136: scsi_CDs[target].device->changed = 0; ! 137: /* If the disk changed, the capacity will now be different, ! 138: * so we force a re-read of this information */ ! 139: if (retval) scsi_CDs[target].needs_sector_size = 1; ! 140: }; ! 141: return retval; ! 142: } ! 143: ! 144: /* ! 145: * rw_intr is the interrupt routine for the device driver. It will be notified on the ! 146: * end of a SCSI read / write, and will take on of several actions based on success or failure. ! 147: */ ! 148: ! 149: static void rw_intr (Scsi_Cmnd * SCpnt) ! 150: { ! 151: int result = SCpnt->result; ! 152: int this_count = SCpnt->this_count; ! 153: ! 154: #ifdef DEBUG ! 155: printk("sr.c done: %x %x\n",result, SCpnt->request.bh->b_data); ! 156: #endif ! 157: if (!result) ! 158: { /* No error */ ! 159: if (SCpnt->use_sg == 0) { ! 160: if (SCpnt->buffer != SCpnt->request.buffer) ! 161: { ! 162: int offset; ! 163: offset = (SCpnt->request.sector % 4) << 9; ! 164: memcpy((char *)SCpnt->request.buffer, ! 165: (char *)SCpnt->buffer + offset, ! 166: this_count << 9); ! 167: /* Even though we are not using scatter-gather, we look ! 168: * ahead and see if there is a linked request for the ! 169: * other half of this buffer. If there is, then satisfy ! 170: * it. */ ! 171: if((offset == 0) && this_count == 2 && ! 172: SCpnt->request.nr_sectors > this_count && ! 173: SCpnt->request.bh && ! 174: SCpnt->request.bh->b_reqnext && ! 175: SCpnt->request.bh->b_reqnext->b_size == 1024) { ! 176: memcpy((char *)SCpnt->request.bh->b_reqnext->b_data, ! 177: (char *)SCpnt->buffer + 1024, ! 178: 1024); ! 179: this_count += 2; ! 180: }; ! 181: ! 182: scsi_free(SCpnt->buffer, 2048); ! 183: } ! 184: } else { ! 185: struct scatterlist * sgpnt; ! 186: int i; ! 187: sgpnt = (struct scatterlist *) SCpnt->buffer; ! 188: for(i=0; i<SCpnt->use_sg; i++) { ! 189: if (sgpnt[i].alt_address) { ! 190: if (sgpnt[i].alt_address != sgpnt[i].address) { ! 191: memcpy(sgpnt[i].alt_address, sgpnt[i].address, sgpnt[i].length); ! 192: }; ! 193: scsi_free(sgpnt[i].address, sgpnt[i].length); ! 194: }; ! 195: }; ! 196: scsi_free(SCpnt->buffer, SCpnt->sglist_len); /* Free list of scatter-gather pointers */ ! 197: if(SCpnt->request.sector % 4) this_count -= 2; ! 198: /* See if there is a padding record at the end that needs to be removed */ ! 199: if(this_count > SCpnt->request.nr_sectors) ! 200: this_count -= 2; ! 201: }; ! 202: ! 203: #ifdef DEBUG ! 204: printk("(%x %x %x) ",SCpnt->request.bh, SCpnt->request.nr_sectors, ! 205: this_count); ! 206: #endif ! 207: if (SCpnt->request.nr_sectors > this_count) ! 208: { ! 209: SCpnt->request.errors = 0; ! 210: if (!SCpnt->request.bh) ! 211: panic("sr.c: linked page request (%lx %x)", ! 212: SCpnt->request.sector, this_count); ! 213: } ! 214: ! 215: SCpnt = end_scsi_request(SCpnt, 1, this_count); /* All done */ ! 216: requeue_sr_request(SCpnt); ! 217: return; ! 218: } /* Normal completion */ ! 219: ! 220: /* We only come through here if we have an error of some kind */ ! 221: ! 222: /* Free up any indirection buffers we allocated for DMA purposes. */ ! 223: if (SCpnt->use_sg) { ! 224: struct scatterlist * sgpnt; ! 225: int i; ! 226: sgpnt = (struct scatterlist *) SCpnt->buffer; ! 227: for(i=0; i<SCpnt->use_sg; i++) { ! 228: if (sgpnt[i].alt_address) { ! 229: scsi_free(sgpnt[i].address, sgpnt[i].length); ! 230: }; ! 231: }; ! 232: scsi_free(SCpnt->buffer, SCpnt->sglist_len); /* Free list of scatter-gather pointers */ ! 233: } else { ! 234: if (SCpnt->buffer != SCpnt->request.buffer) ! 235: scsi_free(SCpnt->buffer, SCpnt->bufflen); ! 236: }; ! 237: ! 238: if (driver_byte(result) != 0) { ! 239: if ((SCpnt->sense_buffer[0] & 0x7f) == 0x70) { ! 240: if ((SCpnt->sense_buffer[2] & 0xf) == UNIT_ATTENTION) { ! 241: /* detected disc change. set a bit and quietly refuse ! 242: * further access. */ ! 243: ! 244: scsi_CDs[DEVICE_NR(SCpnt->request.rq_dev)].device->changed = 1; ! 245: SCpnt = end_scsi_request(SCpnt, 0, this_count); ! 246: requeue_sr_request(SCpnt); ! 247: return; ! 248: } ! 249: } ! 250: ! 251: if (SCpnt->sense_buffer[2] == ILLEGAL_REQUEST) { ! 252: printk("CD-ROM error: "); ! 253: print_sense("sr", SCpnt); ! 254: printk("command was: "); ! 255: print_command(SCpnt->cmnd); ! 256: if (scsi_CDs[DEVICE_NR(SCpnt->request.rq_dev)].ten) { ! 257: scsi_CDs[DEVICE_NR(SCpnt->request.rq_dev)].ten = 0; ! 258: requeue_sr_request(SCpnt); ! 259: result = 0; ! 260: return; ! 261: } else { ! 262: SCpnt = end_scsi_request(SCpnt, 0, this_count); ! 263: requeue_sr_request(SCpnt); /* Do next request */ ! 264: return; ! 265: } ! 266: ! 267: } ! 268: ! 269: if (SCpnt->sense_buffer[2] == NOT_READY) { ! 270: printk("CDROM not ready. Make sure you have a disc in the drive.\n"); ! 271: SCpnt = end_scsi_request(SCpnt, 0, this_count); ! 272: requeue_sr_request(SCpnt); /* Do next request */ ! 273: return; ! 274: }; ! 275: } ! 276: ! 277: /* We only get this far if we have an error we have not recognized */ ! 278: if(result) { ! 279: printk("SCSI CD error : host %d id %d lun %d return code = %03x\n", ! 280: scsi_CDs[DEVICE_NR(SCpnt->request.rq_dev)].device->host->host_no, ! 281: scsi_CDs[DEVICE_NR(SCpnt->request.rq_dev)].device->id, ! 282: scsi_CDs[DEVICE_NR(SCpnt->request.rq_dev)].device->lun, ! 283: result); ! 284: ! 285: if (status_byte(result) == CHECK_CONDITION) ! 286: print_sense("sr", SCpnt); ! 287: ! 288: SCpnt = end_scsi_request(SCpnt, 0, SCpnt->request.current_nr_sectors); ! 289: requeue_sr_request(SCpnt); ! 290: } ! 291: } ! 292: ! 293: /* ! 294: * Here I tried to implement better support for PhotoCD's. ! 295: * ! 296: * Much of this has do be done with vendor-specific SCSI-commands. ! 297: * So I have to complete it step by step. Useful information is welcome. ! 298: * ! 299: * Actually works: ! 300: * - NEC: Detection and support of multisession CD's. Special handling ! 301: * for XA-disks is not necessary. ! 302: * ! 303: * - TOSHIBA: setting density is done here now, mounting PhotoCD's should ! 304: * work now without running the program "set_density" ! 305: * Multisession CD's are supported too. ! 306: * ! 307: * [email protected] (Gerd Knorr) ! 308: */ ! 309: /* ! 310: * 19950704 [email protected] (Thomas Quinot) ! 311: * ! 312: * - SONY: Same as Nec. ! 313: * ! 314: * - PIONEER: works with SONY code ! 315: */ ! 316: ! 317: static void sr_photocd(struct inode *inode) ! 318: { ! 319: unsigned long sector,min,sec,frame; ! 320: unsigned char buf[40]; /* the buffer for the ioctl */ ! 321: unsigned char *cmd; /* the scsi-command */ ! 322: unsigned char *send; /* the data we send to the drive ... */ ! 323: unsigned char *rec; /* ... and get back */ ! 324: int rc,is_xa,no_multi; ! 325: ! 326: if (scsi_CDs[MINOR(inode->i_rdev)].xa_flags & 0x02) { ! 327: #ifdef DEBUG ! 328: printk("sr_photocd: CDROM and/or the driver does not support multisession CD's"); ! 329: #endif ! 330: return; ! 331: } ! 332: ! 333: if (!suser()) { ! 334: /* I'm not the superuser, so SCSI_IOCTL_SEND_COMMAND isn't allowed for me. ! 335: * That's why mpcd_sector will be initialized with zero, because I'm not ! 336: * able to get the right value. Necessary only if access_count is 1, else ! 337: * no disk change happened since the last call of this function and we can ! 338: * keep the old value. ! 339: */ ! 340: if (1 == scsi_CDs[MINOR(inode->i_rdev)].device->access_count) { ! 341: scsi_CDs[MINOR(inode->i_rdev)].mpcd_sector = 0; ! 342: scsi_CDs[MINOR(inode->i_rdev)].xa_flags &= ~0x01; ! 343: } ! 344: return; ! 345: } ! 346: ! 347: sector = 0; ! 348: is_xa = 0; ! 349: no_multi = 0; ! 350: cmd = rec = &buf[8]; ! 351: ! 352: switch(scsi_CDs[MINOR(inode->i_rdev)].device->manufacturer) { ! 353: ! 354: case SCSI_MAN_NEC: ! 355: #ifdef DEBUG ! 356: printk("sr_photocd: use NEC code\n"); ! 357: #endif ! 358: memset(buf,0,40); ! 359: *((unsigned long*)buf) = 0x0; /* we send nothing... */ ! 360: *((unsigned long*)buf+1) = 0x16; /* and receive 0x16 bytes */ ! 361: cmd[0] = 0xde; ! 362: cmd[1] = 0x03; ! 363: cmd[2] = 0xb0; ! 364: rc = kernel_scsi_ioctl(scsi_CDs[MINOR(inode->i_rdev)].device, ! 365: SCSI_IOCTL_SEND_COMMAND, buf); ! 366: if (rc != 0) { ! 367: printk("sr_photocd: ioctl error (NEC): 0x%x\n",rc); ! 368: break; ! 369: } ! 370: if (rec[14] != 0 && rec[14] != 0xb0) { ! 371: printk("sr_photocd: (NEC) Hmm, seems the CDROM doesn't support multisession CD's\n"); ! 372: no_multi = 1; ! 373: break; ! 374: } ! 375: min = (unsigned long) rec[15]/16*10 + (unsigned long) rec[15]%16; ! 376: sec = (unsigned long) rec[16]/16*10 + (unsigned long) rec[16]%16; ! 377: frame = (unsigned long) rec[17]/16*10 + (unsigned long) rec[17]%16; ! 378: sector = min*CD_SECS*CD_FRAMES + sec*CD_FRAMES + frame; ! 379: is_xa = (rec[14] == 0xb0); ! 380: #ifdef DEBUG ! 381: if (sector) { ! 382: printk("sr_photocd: multisession CD detected. start: %lu\n",sector); ! 383: } ! 384: #endif ! 385: break; ! 386: ! 387: case SCSI_MAN_TOSHIBA: ! 388: #ifdef DEBUG ! 389: printk("sr_photocd: use TOSHIBA code\n"); ! 390: #endif ! 391: ! 392: /* we request some disc information (is it a XA-CD ?, ! 393: * where starts the last session ?) */ ! 394: memset(buf,0,40); ! 395: *((unsigned long*)buf) = 0; ! 396: *((unsigned long*)buf+1) = 4; /* we receive 4 bytes from the drive */ ! 397: cmd[0] = 0xc7; ! 398: cmd[1] = 3; ! 399: rc = kernel_scsi_ioctl(scsi_CDs[MINOR(inode->i_rdev)].device, ! 400: SCSI_IOCTL_SEND_COMMAND, buf); ! 401: if (rc != 0) { ! 402: if (rc == 0x28000002) { ! 403: /* Got a "not ready" - error. No chance to find out if this is ! 404: * because there is no CD in the drive or because the drive ! 405: * don't knows multisession CD's. So I need to do an extra check... */ ! 406: if (kernel_scsi_ioctl(scsi_CDs[MINOR(inode->i_rdev)].device, ! 407: SCSI_IOCTL_TEST_UNIT_READY, NULL)) { ! 408: printk("sr_photocd: drive not ready\n"); ! 409: } else { ! 410: printk("sr_photocd: (TOSHIBA) Hmm, seems the CDROM doesn't support multisession CD's\n"); ! 411: no_multi = 1; ! 412: } ! 413: } else ! 414: printk("sr_photocd: ioctl error (TOSHIBA #1): 0x%x\n",rc); ! 415: break; /* if the first ioctl fails, we don't call the second one */ ! 416: } ! 417: is_xa = (rec[0] == 0x20); ! 418: min = (unsigned long) rec[1]/16*10 + (unsigned long) rec[1]%16; ! 419: sec = (unsigned long) rec[2]/16*10 + (unsigned long) rec[2]%16; ! 420: frame = (unsigned long) rec[3]/16*10 + (unsigned long) rec[3]%16; ! 421: sector = min*CD_SECS*CD_FRAMES + sec*CD_FRAMES + frame; ! 422: if (sector) { ! 423: sector -= CD_BLOCK_OFFSET; ! 424: #ifdef DEBUG ! 425: printk("sr_photocd: multisession CD detected: start: %lu\n",sector); ! 426: #endif ! 427: } ! 428: ! 429: /* now we do a get_density... */ ! 430: memset(buf,0,40); ! 431: *((unsigned long*)buf) = 0; ! 432: *((unsigned long*)buf+1) = 12; ! 433: cmd[0] = 0x1a; ! 434: cmd[2] = 1; ! 435: cmd[4] = 12; ! 436: rc = kernel_scsi_ioctl(scsi_CDs[MINOR(inode->i_rdev)].device, ! 437: SCSI_IOCTL_SEND_COMMAND, buf); ! 438: if (rc != 0) { ! 439: printk("sr_photocd: ioctl error (TOSHIBA #2): 0x%x\n",rc); ! 440: break; ! 441: } ! 442: #ifdef DEBUG ! 443: printk("sr_photocd: get_density: 0x%x\n",rec[4]); ! 444: #endif ! 445: ! 446: /* ...and only if necessary a set_density */ ! 447: if ((rec[4] != 0x81 && is_xa) || (rec[4] != 0 && !is_xa)) { ! 448: #ifdef DEBUG ! 449: printk("sr_photocd: doing set_density\n"); ! 450: #endif ! 451: memset(buf,0,40); ! 452: *((unsigned long*)buf) = 12; /* sending 12 bytes... */ ! 453: *((unsigned long*)buf+1) = 0; ! 454: cmd[0] = 0x15; ! 455: cmd[1] = (1 << 4); ! 456: cmd[4] = 12; ! 457: send = &cmd[6]; /* this is a 6-Byte command */ ! 458: send[ 3] = 0x08; /* the data for the command */ ! 459: send[ 4] = (is_xa) ? 0x81 : 0; /* density 0x81 for XA-CD's, 0 else */ ! 460: send[10] = 0x08; ! 461: rc = kernel_scsi_ioctl(scsi_CDs[MINOR(inode->i_rdev)].device, ! 462: SCSI_IOCTL_SEND_COMMAND, buf); ! 463: if (rc != 0) { ! 464: printk("sr_photocd: ioctl error (TOSHIBA #3): 0x%x\n",rc); ! 465: } ! 466: /* The set_density command may have changed the sector size or capacity. */ ! 467: scsi_CDs[MINOR(inode->i_rdev)].needs_sector_size = 1; ! 468: } ! 469: break; ! 470: ! 471: case SCSI_MAN_SONY: /* Thomas QUINOT <[email protected]> */ ! 472: case SCSI_MAN_PIONEER: ! 473: #ifdef DEBUG ! 474: printk("sr_photocd: use SONY/PIONEER code\n"); ! 475: #endif ! 476: memset(buf,0,40); ! 477: *((unsigned long*)buf) = 0x0; /* we send nothing... */ ! 478: *((unsigned long*)buf+1) = 0x0c; /* and receive 0x0c bytes */ ! 479: cmd[0] = 0x43; /* Read TOC */ ! 480: cmd[8] = 0x0c; ! 481: cmd[9] = 0x40; ! 482: rc = kernel_scsi_ioctl(scsi_CDs[MINOR(inode->i_rdev)].device, ! 483: SCSI_IOCTL_SEND_COMMAND, buf); ! 484: ! 485: if (rc != 0) { ! 486: printk("sr_photocd: ioctl error (SONY): 0x%x\n",rc); ! 487: break; ! 488: } ! 489: if ((rec[0] << 8) + rec[1] != 0x0a) { ! 490: printk("sr_photocd: (SONY) Hmm, seems the CDROM doesn't support multisession CD's\n"); ! 491: no_multi = 1; ! 492: break; ! 493: } ! 494: sector = rec[11] + (rec[10] << 8) + (rec[9] << 16) + (rec[8] << 24); ! 495: is_xa = !!sector; ! 496: #ifdef DEBUG ! 497: if (sector) ! 498: printk ("sr_photocd: multisession CD detected. start: %lu\n",sector); ! 499: #endif ! 500: break; ! 501: ! 502: case SCSI_MAN_NEC_OLDCDR: ! 503: case SCSI_MAN_UNKNOWN: ! 504: default: ! 505: sector = 0; ! 506: no_multi = 1; ! 507: break; } ! 508: ! 509: scsi_CDs[MINOR(inode->i_rdev)].mpcd_sector = sector; ! 510: if (is_xa) ! 511: scsi_CDs[MINOR(inode->i_rdev)].xa_flags |= 0x01; ! 512: else ! 513: scsi_CDs[MINOR(inode->i_rdev)].xa_flags &= ~0x01; ! 514: if (no_multi) ! 515: scsi_CDs[MINOR(inode->i_rdev)].xa_flags |= 0x02; ! 516: return; ! 517: } ! 518: ! 519: static int sr_open(struct inode * inode, struct file * filp) ! 520: { ! 521: if(MINOR(inode->i_rdev) >= sr_template.nr_dev || ! 522: !scsi_CDs[MINOR(inode->i_rdev)].device) return -ENXIO; /* No such device */ ! 523: ! 524: if (filp->f_mode & 2) ! 525: return -EROFS; ! 526: ! 527: check_disk_change(inode->i_rdev); ! 528: ! 529: if(!scsi_CDs[MINOR(inode->i_rdev)].device->access_count++) ! 530: sr_ioctl(inode, NULL, SCSI_IOCTL_DOORLOCK, 0); ! 531: if (scsi_CDs[MINOR(inode->i_rdev)].device->host->hostt->usage_count) ! 532: (*scsi_CDs[MINOR(inode->i_rdev)].device->host->hostt->usage_count)++; ! 533: if(sr_template.usage_count) (*sr_template.usage_count)++; ! 534: ! 535: sr_photocd(inode); ! 536: ! 537: /* If this device did not have media in the drive at boot time, then ! 538: * we would have been unable to get the sector size. Check to see if ! 539: * this is the case, and try again. ! 540: */ ! 541: ! 542: if(scsi_CDs[MINOR(inode->i_rdev)].needs_sector_size) ! 543: get_sectorsize(MINOR(inode->i_rdev)); ! 544: ! 545: return 0; ! 546: } ! 547: ! 548: ! 549: /* ! 550: * do_sr_request() is the request handler function for the sr driver. ! 551: * Its function in life is to take block device requests, and ! 552: * translate them to SCSI commands. ! 553: */ ! 554: ! 555: static void do_sr_request (void) ! 556: { ! 557: Scsi_Cmnd * SCpnt = NULL; ! 558: struct request * req = NULL; ! 559: Scsi_Device * SDev; ! 560: unsigned long flags; ! 561: int flag = 0; ! 562: ! 563: while (1==1){ ! 564: save_flags(flags); ! 565: cli(); ! 566: if (CURRENT != NULL && CURRENT->rq_status == RQ_INACTIVE) { ! 567: restore_flags(flags); ! 568: return; ! 569: }; ! 570: ! 571: INIT_SCSI_REQUEST; ! 572: ! 573: SDev = scsi_CDs[DEVICE_NR(CURRENT->rq_dev)].device; ! 574: ! 575: /* ! 576: * I am not sure where the best place to do this is. We need ! 577: * to hook in a place where we are likely to come if in user ! 578: * space. ! 579: */ ! 580: if( SDev->was_reset ) ! 581: { ! 582: /* ! 583: * We need to relock the door, but we might ! 584: * be in an interrupt handler. Only do this ! 585: * from user space, since we do not want to ! 586: * sleep from an interrupt. ! 587: */ ! 588: if( SDev->removable && !intr_count ) ! 589: { ! 590: scsi_ioctl(SDev, SCSI_IOCTL_DOORLOCK, 0); ! 591: } ! 592: SDev->was_reset = 0; ! 593: } ! 594: ! 595: if (flag++ == 0) ! 596: SCpnt = allocate_device(&CURRENT, ! 597: scsi_CDs[DEVICE_NR(CURRENT->rq_dev)].device, 0); ! 598: else SCpnt = NULL; ! 599: restore_flags(flags); ! 600: ! 601: /* This is a performance enhancement. We dig down into the request list and ! 602: * try and find a queueable request (i.e. device not busy, and host able to ! 603: * accept another command. If we find one, then we queue it. This can ! 604: * make a big difference on systems with more than one disk drive. We want ! 605: * to have the interrupts off when monkeying with the request list, because ! 606: * otherwise the kernel might try and slip in a request in between somewhere. */ ! 607: ! 608: if (!SCpnt && sr_template.nr_dev > 1){ ! 609: struct request *req1; ! 610: req1 = NULL; ! 611: save_flags(flags); ! 612: cli(); ! 613: req = CURRENT; ! 614: while(req){ ! 615: SCpnt = request_queueable(req, ! 616: scsi_CDs[DEVICE_NR(req->rq_dev)].device); ! 617: if(SCpnt) break; ! 618: req1 = req; ! 619: req = req->next; ! 620: }; ! 621: if (SCpnt && req->rq_status == RQ_INACTIVE) { ! 622: if (req == CURRENT) ! 623: CURRENT = CURRENT->next; ! 624: else ! 625: req1->next = req->next; ! 626: }; ! 627: restore_flags(flags); ! 628: }; ! 629: ! 630: if (!SCpnt) ! 631: return; /* Could not find anything to do */ ! 632: ! 633: wake_up(&wait_for_request); ! 634: ! 635: /* Queue command */ ! 636: requeue_sr_request(SCpnt); ! 637: }; /* While */ ! 638: } ! 639: ! 640: void requeue_sr_request (Scsi_Cmnd * SCpnt) ! 641: { ! 642: unsigned int dev, block, realcount; ! 643: unsigned char cmd[10], *buffer, tries; ! 644: int this_count, start, end_rec; ! 645: ! 646: tries = 2; ! 647: ! 648: repeat: ! 649: if(!SCpnt || SCpnt->request.rq_status == RQ_INACTIVE) { ! 650: do_sr_request(); ! 651: return; ! 652: } ! 653: ! 654: dev = MINOR(SCpnt->request.rq_dev); ! 655: block = SCpnt->request.sector; ! 656: buffer = NULL; ! 657: this_count = 0; ! 658: ! 659: if (dev >= sr_template.nr_dev) { ! 660: /* printk("CD-ROM request error: invalid device.\n"); */ ! 661: SCpnt = end_scsi_request(SCpnt, 0, SCpnt->request.nr_sectors); ! 662: tries = 2; ! 663: goto repeat; ! 664: } ! 665: ! 666: if (!scsi_CDs[dev].use) { ! 667: /* printk("CD-ROM request error: device marked not in use.\n"); */ ! 668: SCpnt = end_scsi_request(SCpnt, 0, SCpnt->request.nr_sectors); ! 669: tries = 2; ! 670: goto repeat; ! 671: } ! 672: ! 673: if (scsi_CDs[dev].device->changed) { ! 674: /* ! 675: * quietly refuse to do anything to a changed disc ! 676: * until the changed bit has been reset ! 677: */ ! 678: /* printk("CD-ROM has been changed. Prohibiting further I/O.\n"); */ ! 679: SCpnt = end_scsi_request(SCpnt, 0, SCpnt->request.nr_sectors); ! 680: tries = 2; ! 681: goto repeat; ! 682: } ! 683: ! 684: switch (SCpnt->request.cmd) ! 685: { ! 686: case WRITE: ! 687: SCpnt = end_scsi_request(SCpnt, 0, SCpnt->request.nr_sectors); ! 688: goto repeat; ! 689: break; ! 690: case READ : ! 691: cmd[0] = READ_6; ! 692: break; ! 693: default : ! 694: panic ("Unknown sr command %d\n", SCpnt->request.cmd); ! 695: } ! 696: ! 697: cmd[1] = (SCpnt->lun << 5) & 0xe0; ! 698: ! 699: /* ! 700: * Now do the grungy work of figuring out which sectors we need, and ! 701: * where in memory we are going to put them. ! 702: * ! 703: * The variables we need are: ! 704: * ! 705: * this_count= number of 512 byte sectors being read ! 706: * block = starting cdrom sector to read. ! 707: * realcount = # of cdrom sectors to read ! 708: * ! 709: * The major difference between a scsi disk and a scsi cdrom ! 710: * is that we will always use scatter-gather if we can, because we can ! 711: * work around the fact that the buffer cache has a block size of 1024, ! 712: * and we have 2048 byte sectors. This code should work for buffers that ! 713: * are any multiple of 512 bytes long. ! 714: */ ! 715: ! 716: SCpnt->use_sg = 0; ! 717: ! 718: if (SCpnt->host->sg_tablesize > 0 && ! 719: (!need_isa_buffer || ! 720: dma_free_sectors >= 10)) { ! 721: struct buffer_head * bh; ! 722: struct scatterlist * sgpnt; ! 723: int count, this_count_max; ! 724: bh = SCpnt->request.bh; ! 725: this_count = 0; ! 726: count = 0; ! 727: this_count_max = (scsi_CDs[dev].ten ? 0xffff : 0xff) << 4; ! 728: /* Calculate how many links we can use. First see if we need ! 729: * a padding record at the start */ ! 730: this_count = SCpnt->request.sector % 4; ! 731: if(this_count) count++; ! 732: while(bh && count < SCpnt->host->sg_tablesize) { ! 733: if ((this_count + (bh->b_size >> 9)) > this_count_max) break; ! 734: this_count += (bh->b_size >> 9); ! 735: count++; ! 736: bh = bh->b_reqnext; ! 737: }; ! 738: /* Fix up in case of an odd record at the end */ ! 739: end_rec = 0; ! 740: if(this_count % 4) { ! 741: if (count < SCpnt->host->sg_tablesize) { ! 742: count++; ! 743: end_rec = (4 - (this_count % 4)) << 9; ! 744: this_count += 4 - (this_count % 4); ! 745: } else { ! 746: count--; ! 747: this_count -= (this_count % 4); ! 748: }; ! 749: }; ! 750: SCpnt->use_sg = count; /* Number of chains */ ! 751: count = 512;/* scsi_malloc can only allocate in chunks of 512 bytes*/ ! 752: while( count < (SCpnt->use_sg * sizeof(struct scatterlist))) ! 753: count = count << 1; ! 754: SCpnt->sglist_len = count; ! 755: sgpnt = (struct scatterlist * ) scsi_malloc(count); ! 756: if (!sgpnt) { ! 757: printk("Warning - running *really* short on DMA buffers\n"); ! 758: SCpnt->use_sg = 0; /* No memory left - bail out */ ! 759: } else { ! 760: buffer = (unsigned char *) sgpnt; ! 761: count = 0; ! 762: bh = SCpnt->request.bh; ! 763: if(SCpnt->request.sector % 4) { ! 764: sgpnt[count].length = (SCpnt->request.sector % 4) << 9; ! 765: sgpnt[count].address = (char *) scsi_malloc(sgpnt[count].length); ! 766: if(!sgpnt[count].address) panic("SCSI DMA pool exhausted."); ! 767: sgpnt[count].alt_address = sgpnt[count].address; /* Flag to delete ! 768: if needed */ ! 769: count++; ! 770: }; ! 771: for(bh = SCpnt->request.bh; count < SCpnt->use_sg; ! 772: count++, bh = bh->b_reqnext) { ! 773: if (bh) { /* Need a placeholder at the end of the record? */ ! 774: sgpnt[count].address = bh->b_data; ! 775: sgpnt[count].length = bh->b_size; ! 776: sgpnt[count].alt_address = NULL; ! 777: } else { ! 778: sgpnt[count].address = (char *) scsi_malloc(end_rec); ! 779: if(!sgpnt[count].address) panic("SCSI DMA pool exhausted."); ! 780: sgpnt[count].length = end_rec; ! 781: sgpnt[count].alt_address = sgpnt[count].address; ! 782: if (count+1 != SCpnt->use_sg) panic("Bad sr request list"); ! 783: break; ! 784: }; ! 785: if (((long) sgpnt[count].address) + sgpnt[count].length > ISA_DMA_THRESHOLD && ! 786: SCpnt->host->unchecked_isa_dma) { ! 787: sgpnt[count].alt_address = sgpnt[count].address; ! 788: /* We try and avoid exhausting the DMA pool, since it is easier ! 789: * to control usage here. In other places we might have a more ! 790: * pressing need, and we would be screwed if we ran out */ ! 791: if(dma_free_sectors < (sgpnt[count].length >> 9) + 5) { ! 792: sgpnt[count].address = NULL; ! 793: } else { ! 794: sgpnt[count].address = (char *) scsi_malloc(sgpnt[count].length); ! 795: }; ! 796: /* If we start running low on DMA buffers, we abort the scatter-gather ! 797: * operation, and free all of the memory we have allocated. We want to ! 798: * ensure that all scsi operations are able to do at least a non-scatter/gather ! 799: * operation */ ! 800: if(sgpnt[count].address == NULL){ /* Out of dma memory */ ! 801: printk("Warning: Running low on SCSI DMA buffers"); ! 802: /* Try switching back to a non scatter-gather operation. */ ! 803: while(--count >= 0){ ! 804: if(sgpnt[count].alt_address) ! 805: scsi_free(sgpnt[count].address, sgpnt[count].length); ! 806: }; ! 807: SCpnt->use_sg = 0; ! 808: scsi_free(buffer, SCpnt->sglist_len); ! 809: break; ! 810: }; /* if address == NULL */ ! 811: }; /* if need DMA fixup */ ! 812: }; /* for loop to fill list */ ! 813: #ifdef DEBUG ! 814: printk("SR: %d %d %d %d %d *** ",SCpnt->use_sg, SCpnt->request.sector, ! 815: this_count, ! 816: SCpnt->request.current_nr_sectors, ! 817: SCpnt->request.nr_sectors); ! 818: for(count=0; count<SCpnt->use_sg; count++) ! 819: printk("SGlist: %d %x %x %x\n", count, ! 820: sgpnt[count].address, ! 821: sgpnt[count].alt_address, ! 822: sgpnt[count].length); ! 823: #endif ! 824: }; /* Able to allocate scatter-gather list */ ! 825: }; ! 826: ! 827: if (SCpnt->use_sg == 0){ ! 828: /* We cannot use scatter-gather. Do this the old fashion way */ ! 829: if (!SCpnt->request.bh) ! 830: this_count = SCpnt->request.nr_sectors; ! 831: else ! 832: this_count = (SCpnt->request.bh->b_size >> 9); ! 833: ! 834: start = block % 4; ! 835: if (start) ! 836: { ! 837: this_count = ((this_count > 4 - start) ? ! 838: (4 - start) : (this_count)); ! 839: buffer = (unsigned char *) scsi_malloc(2048); ! 840: } ! 841: else if (this_count < 4) ! 842: { ! 843: buffer = (unsigned char *) scsi_malloc(2048); ! 844: } ! 845: else ! 846: { ! 847: this_count -= this_count % 4; ! 848: buffer = (unsigned char *) SCpnt->request.buffer; ! 849: if (((long) buffer) + (this_count << 9) > ISA_DMA_THRESHOLD && ! 850: SCpnt->host->unchecked_isa_dma) ! 851: buffer = (unsigned char *) scsi_malloc(this_count << 9); ! 852: } ! 853: }; ! 854: ! 855: if (scsi_CDs[dev].sector_size == 2048) ! 856: block = block >> 2; /* These are the sectors that the cdrom uses */ ! 857: else ! 858: block = block & 0xfffffffc; ! 859: ! 860: realcount = (this_count + 3) / 4; ! 861: ! 862: if (scsi_CDs[dev].sector_size == 512) realcount = realcount << 2; ! 863: ! 864: if (((realcount > 0xff) || (block > 0x1fffff)) && scsi_CDs[dev].ten) ! 865: { ! 866: if (realcount > 0xffff) ! 867: { ! 868: realcount = 0xffff; ! 869: this_count = realcount * (scsi_CDs[dev].sector_size >> 9); ! 870: } ! 871: ! 872: cmd[0] += READ_10 - READ_6 ; ! 873: cmd[2] = (unsigned char) (block >> 24) & 0xff; ! 874: cmd[3] = (unsigned char) (block >> 16) & 0xff; ! 875: cmd[4] = (unsigned char) (block >> 8) & 0xff; ! 876: cmd[5] = (unsigned char) block & 0xff; ! 877: cmd[6] = cmd[9] = 0; ! 878: cmd[7] = (unsigned char) (realcount >> 8) & 0xff; ! 879: cmd[8] = (unsigned char) realcount & 0xff; ! 880: } ! 881: else ! 882: { ! 883: if (realcount > 0xff) ! 884: { ! 885: realcount = 0xff; ! 886: this_count = realcount * (scsi_CDs[dev].sector_size >> 9); ! 887: } ! 888: ! 889: cmd[1] |= (unsigned char) ((block >> 16) & 0x1f); ! 890: cmd[2] = (unsigned char) ((block >> 8) & 0xff); ! 891: cmd[3] = (unsigned char) block & 0xff; ! 892: cmd[4] = (unsigned char) realcount; ! 893: cmd[5] = 0; ! 894: } ! 895: ! 896: #ifdef DEBUG ! 897: { ! 898: int i; ! 899: printk("ReadCD: %d %d %d %d\n",block, realcount, buffer, this_count); ! 900: printk("Use sg: %d\n", SCpnt->use_sg); ! 901: printk("Dumping command: "); ! 902: for(i=0; i<12; i++) printk("%2.2x ", cmd[i]); ! 903: printk("\n"); ! 904: }; ! 905: #endif ! 906: ! 907: /* Some dumb host adapters can speed transfers by knowing the ! 908: * minimum transfersize in advance. ! 909: * ! 910: * We shouldn't disconnect in the middle of a sector, but the cdrom ! 911: * sector size can be larger than the size of a buffer and the ! 912: * transfer may be split to the size of a buffer. So it's safe to ! 913: * assume that we can at least transfer the minimum of the buffer ! 914: * size (1024) and the sector size between each connect / disconnect. ! 915: */ ! 916: ! 917: SCpnt->transfersize = (scsi_CDs[dev].sector_size > 1024) ? ! 918: 1024 : scsi_CDs[dev].sector_size; ! 919: ! 920: SCpnt->this_count = this_count; ! 921: scsi_do_cmd (SCpnt, (void *) cmd, buffer, ! 922: realcount * scsi_CDs[dev].sector_size, ! 923: rw_intr, SR_TIMEOUT, MAX_RETRIES); ! 924: } ! 925: ! 926: static int sr_detect(Scsi_Device * SDp){ ! 927: ! 928: if(SDp->type != TYPE_ROM && SDp->type != TYPE_WORM) return 0; ! 929: ! 930: printk("Detected scsi CD-ROM sr%d at scsi%d, channel %d, id %d, lun %d\n", ! 931: sr_template.dev_noticed++, ! 932: SDp->host->host_no, SDp->channel, SDp->id, SDp->lun); ! 933: ! 934: return 1; ! 935: } ! 936: ! 937: static int sr_attach(Scsi_Device * SDp){ ! 938: Scsi_CD * cpnt; ! 939: int i; ! 940: ! 941: if(SDp->type != TYPE_ROM && SDp->type != TYPE_WORM) return 1; ! 942: ! 943: if (sr_template.nr_dev >= sr_template.dev_max) ! 944: { ! 945: SDp->attached--; ! 946: return 1; ! 947: } ! 948: ! 949: for(cpnt = scsi_CDs, i=0; i<sr_template.dev_max; i++, cpnt++) ! 950: if(!cpnt->device) break; ! 951: ! 952: if(i >= sr_template.dev_max) panic ("scsi_devices corrupt (sr)"); ! 953: ! 954: SDp->scsi_request_fn = do_sr_request; ! 955: scsi_CDs[i].device = SDp; ! 956: sr_template.nr_dev++; ! 957: if(sr_template.nr_dev > sr_template.dev_max) ! 958: panic ("scsi_devices corrupt (sr)"); ! 959: return 0; ! 960: } ! 961: ! 962: ! 963: static void sr_init_done (Scsi_Cmnd * SCpnt) ! 964: { ! 965: struct request * req; ! 966: ! 967: req = &SCpnt->request; ! 968: req->rq_status = RQ_SCSI_DONE; /* Busy, but indicate request done */ ! 969: ! 970: if (req->sem != NULL) { ! 971: up(req->sem); ! 972: } ! 973: } ! 974: ! 975: static void get_sectorsize(int i){ ! 976: unsigned char cmd[10]; ! 977: unsigned char *buffer; ! 978: int the_result, retries; ! 979: Scsi_Cmnd * SCpnt; ! 980: ! 981: buffer = (unsigned char *) scsi_malloc(512); ! 982: SCpnt = allocate_device(NULL, scsi_CDs[i].device, 1); ! 983: ! 984: retries = 3; ! 985: do { ! 986: cmd[0] = READ_CAPACITY; ! 987: cmd[1] = (scsi_CDs[i].device->lun << 5) & 0xe0; ! 988: memset ((void *) &cmd[2], 0, 8); ! 989: SCpnt->request.rq_status = RQ_SCSI_BUSY; /* Mark as really busy */ ! 990: SCpnt->cmd_len = 0; ! 991: ! 992: memset(buffer, 0, 8); ! 993: ! 994: /* Do the command and wait.. */ ! 995: { ! 996: struct semaphore sem = MUTEX_LOCKED; ! 997: SCpnt->request.sem = &sem; ! 998: scsi_do_cmd (SCpnt, ! 999: (void *) cmd, (void *) buffer, ! 1000: 512, sr_init_done, SR_TIMEOUT, ! 1001: MAX_RETRIES); ! 1002: down(&sem); ! 1003: } ! 1004: ! 1005: the_result = SCpnt->result; ! 1006: retries--; ! 1007: ! 1008: } while(the_result && retries); ! 1009: ! 1010: SCpnt->request.rq_status = RQ_INACTIVE; /* Mark as not busy */ ! 1011: ! 1012: wake_up(&SCpnt->device->device_wait); ! 1013: ! 1014: if (the_result) { ! 1015: scsi_CDs[i].capacity = 0x1fffff; ! 1016: scsi_CDs[i].sector_size = 2048; /* A guess, just in case */ ! 1017: scsi_CDs[i].needs_sector_size = 1; ! 1018: } else { ! 1019: scsi_CDs[i].capacity = (buffer[0] << 24) | ! 1020: (buffer[1] << 16) | (buffer[2] << 8) | buffer[3]; ! 1021: scsi_CDs[i].sector_size = (buffer[4] << 24) | ! 1022: (buffer[5] << 16) | (buffer[6] << 8) | buffer[7]; ! 1023: if(scsi_CDs[i].sector_size == 0) scsi_CDs[i].sector_size = 2048; ! 1024: /* Work around bug/feature in HP 4020i CD-Recorder... */ ! 1025: if(scsi_CDs[i].sector_size == 2340) scsi_CDs[i].sector_size = 2048; ! 1026: if(scsi_CDs[i].sector_size != 2048 && ! 1027: scsi_CDs[i].sector_size != 512) { ! 1028: printk ("scd%d : unsupported sector size %d.\n", ! 1029: i, scsi_CDs[i].sector_size); ! 1030: scsi_CDs[i].capacity = 0; ! 1031: scsi_CDs[i].needs_sector_size = 1; ! 1032: }; ! 1033: if(scsi_CDs[i].sector_size == 2048) ! 1034: scsi_CDs[i].capacity *= 4; ! 1035: scsi_CDs[i].needs_sector_size = 0; ! 1036: sr_sizes[i] = scsi_CDs[i].capacity; ! 1037: }; ! 1038: scsi_free(buffer, 512); ! 1039: } ! 1040: ! 1041: static int sr_registered = 0; ! 1042: ! 1043: static int sr_init() ! 1044: { ! 1045: int i; ! 1046: ! 1047: if(sr_template.dev_noticed == 0) return 0; ! 1048: ! 1049: if(!sr_registered) { ! 1050: if (register_blkdev(MAJOR_NR,"sr",&sr_fops)) { ! 1051: printk("Unable to get major %d for SCSI-CD\n",MAJOR_NR); ! 1052: return 1; ! 1053: } ! 1054: sr_registered++; ! 1055: } ! 1056: ! 1057: ! 1058: if (scsi_CDs) return 0; ! 1059: sr_template.dev_max = sr_template.dev_noticed + SR_EXTRA_DEVS; ! 1060: scsi_CDs = (Scsi_CD *) scsi_init_malloc(sr_template.dev_max * sizeof(Scsi_CD), GFP_ATOMIC); ! 1061: memset(scsi_CDs, 0, sr_template.dev_max * sizeof(Scsi_CD)); ! 1062: ! 1063: sr_sizes = (int *) scsi_init_malloc(sr_template.dev_max * sizeof(int), GFP_ATOMIC); ! 1064: memset(sr_sizes, 0, sr_template.dev_max * sizeof(int)); ! 1065: ! 1066: sr_blocksizes = (int *) scsi_init_malloc(sr_template.dev_max * ! 1067: sizeof(int), GFP_ATOMIC); ! 1068: for(i=0;i<sr_template.dev_max;i++) sr_blocksizes[i] = 2048; ! 1069: blksize_size[MAJOR_NR] = sr_blocksizes; ! 1070: return 0; ! 1071: } ! 1072: ! 1073: void sr_finish() ! 1074: { ! 1075: int i; ! 1076: ! 1077: blk_dev[MAJOR_NR].request_fn = DEVICE_REQUEST; ! 1078: blk_size[MAJOR_NR] = sr_sizes; ! 1079: ! 1080: for (i = 0; i < sr_template.nr_dev; ++i) ! 1081: { ! 1082: /* If we have already seen this, then skip it. Comes up ! 1083: * with loadable modules. */ ! 1084: if (scsi_CDs[i].capacity) continue; ! 1085: scsi_CDs[i].capacity = 0x1fffff; ! 1086: scsi_CDs[i].sector_size = 2048; /* A guess, just in case */ ! 1087: scsi_CDs[i].needs_sector_size = 1; ! 1088: #if 0 ! 1089: /* seems better to leave this for later */ ! 1090: get_sectorsize(i); ! 1091: printk("Scd sectorsize = %d bytes.\n", scsi_CDs[i].sector_size); ! 1092: #endif ! 1093: scsi_CDs[i].use = 1; ! 1094: scsi_CDs[i].ten = 1; ! 1095: scsi_CDs[i].remap = 1; ! 1096: scsi_CDs[i].auto_eject = 0; /* Default is not to eject upon unmount. */ ! 1097: sr_sizes[i] = scsi_CDs[i].capacity; ! 1098: } ! 1099: ! 1100: ! 1101: /* If our host adapter is capable of scatter-gather, then we increase ! 1102: * the read-ahead to 16 blocks (32 sectors). If not, we use ! 1103: * a two block (4 sector) read ahead. */ ! 1104: if(scsi_CDs[0].device && scsi_CDs[0].device->host->sg_tablesize) ! 1105: read_ahead[MAJOR_NR] = 32; /* 32 sector read-ahead. Always removable. */ ! 1106: else ! 1107: read_ahead[MAJOR_NR] = 4; /* 4 sector read-ahead */ ! 1108: ! 1109: return; ! 1110: } ! 1111: ! 1112: static void sr_detach(Scsi_Device * SDp) ! 1113: { ! 1114: Scsi_CD * cpnt; ! 1115: int i; ! 1116: ! 1117: for(cpnt = scsi_CDs, i=0; i<sr_template.dev_max; i++, cpnt++) ! 1118: if(cpnt->device == SDp) { ! 1119: kdev_t devi = MKDEV(MAJOR_NR, i); ! 1120: ! 1121: /* ! 1122: * Since the cdrom is read-only, no need to sync the device. ! 1123: * We should be kind to our buffer cache, however. ! 1124: */ ! 1125: invalidate_inodes(devi); ! 1126: invalidate_buffers(devi); ! 1127: ! 1128: /* ! 1129: * Reset things back to a sane state so that one can re-load a new ! 1130: * driver (perhaps the same one). ! 1131: */ ! 1132: cpnt->device = NULL; ! 1133: cpnt->capacity = 0; ! 1134: SDp->attached--; ! 1135: sr_template.nr_dev--; ! 1136: sr_template.dev_noticed--; ! 1137: sr_sizes[i] = 0; ! 1138: return; ! 1139: } ! 1140: return; ! 1141: } ! 1142: ! 1143: ! 1144: #ifdef MODULE ! 1145: ! 1146: int init_module(void) { ! 1147: sr_template.usage_count = &mod_use_count_; ! 1148: return scsi_register_module(MODULE_SCSI_DEV, &sr_template); ! 1149: } ! 1150: ! 1151: void cleanup_module( void) ! 1152: { ! 1153: scsi_unregister_module(MODULE_SCSI_DEV, &sr_template); ! 1154: unregister_blkdev(SCSI_CDROM_MAJOR, "sr"); ! 1155: sr_registered--; ! 1156: if(scsi_CDs != NULL) { ! 1157: scsi_init_free((char *) scsi_CDs, ! 1158: (sr_template.dev_noticed + SR_EXTRA_DEVS) ! 1159: * sizeof(Scsi_CD)); ! 1160: ! 1161: scsi_init_free((char *) sr_sizes, sr_template.dev_max * sizeof(int)); ! 1162: scsi_init_free((char *) sr_blocksizes, sr_template.dev_max * sizeof(int)); ! 1163: } ! 1164: ! 1165: blksize_size[MAJOR_NR] = NULL; ! 1166: blk_dev[MAJOR_NR].request_fn = NULL; ! 1167: blk_size[MAJOR_NR] = NULL; ! 1168: read_ahead[MAJOR_NR] = 0; ! 1169: ! 1170: sr_template.dev_max = 0; ! 1171: } ! 1172: #endif /* MODULE */ ! 1173: ! 1174: /* ! 1175: * Overrides for Emacs so that we follow Linus's tabbing style. ! 1176: * Emacs will notice this stuff at the end of the file and automatically ! 1177: * adjust the settings for this buffer only. This must remain at the end ! 1178: * of the file. ! 1179: * --------------------------------------------------------------------------- ! 1180: * Local variables: ! 1181: * c-indent-level: 4 ! 1182: * c-brace-imaginary-offset: 0 ! 1183: * c-brace-offset: -4 ! 1184: * c-argdecl-indent: 4 ! 1185: * c-label-offset: -4 ! 1186: * c-continued-statement-offset: 4 ! 1187: * c-continued-brace-offset: 0 ! 1188: * indent-tabs-mode: nil ! 1189: * tab-width: 8 ! 1190: * End: ! 1191: */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.