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