1 /******************************************************************
2 * CopyPolicy: GNU Public License 2 applies
3 * Original interface.c Copyright (C) 1994-1997
4 * Eissfeldt heiko@colossus.escape.de
5 * Current blenderization Copyright (C) 1998-1999 Monty xiphmont@mit.edu
6 * FreeBSD porting (c) 2003
7 * Simon 'corecode' Schubert <corecode@corecode.ath.cx>
8 *
9 * Generic SCSI interface specific code.
10 *
11 ******************************************************************/
12
13 #include "low_interface.h"
14 #include "common_interface.h"
15 #include "utils.h"
16
17 /* hook */
Dummy(cdrom_drive * d,int s)18 static int Dummy (cdrom_drive *d,int s){
19 return(0);
20 }
21
22 #include "drive_exceptions.h"
23
tweak_SG_buffer(cdrom_drive * d)24 static void tweak_SG_buffer(cdrom_drive *d){
25 int table,reserved;
26 char buffer[256];
27
28 #ifdef Linux
29 /* maximum transfer size? */
30 if(ioctl(d->cdda_fd,SG_GET_RESERVED_SIZE,&reserved)){
31 /* Up, guess not. */
32 cdmessage(d,"\tCould not get scatter/gather buffer size.\n");
33 return;
34 }
35
36 if(ioctl(d->cdda_fd,SG_GET_SG_TABLESIZE,&table))table=1;
37 {
38 int cur;
39
40 sprintf(buffer,"\tDMA scatter/gather table entries: %d\n\t"
41 "table entry size: %d bytes\n\t"
42 "maximum theoretical transfer: %d sectors\n",
43 table,reserved,table*reserved/CD_FRAMESIZE_RAW);
44 cdmessage(d,buffer);
45
46 cur=table*reserved;
47
48 /* not too much; new kernels have trouble with DMA allocation, so
49 be more conservative: 32kB max until I test more thoroughly */
50 cur=(cur>1024*32?1024*32:cur);
51 d->nsectors=cur/CD_FRAMESIZE_RAW;
52 d->bigbuff=cur;
53
54 sprintf(buffer,"\tSetting default read size to %d sectors (%d bytes).\n\n",
55 d->nsectors,d->nsectors*CD_FRAMESIZE_RAW);
56 cdmessage(d,buffer);
57 }
58
59 /* Disable command queue; we don't need it, no reason to have it on */
60 reserved=0;
61 if(ioctl(d->cdda_fd,SG_SET_COMMAND_Q,&reserved)){
62 cdmessage(d,"\tCouldn't disable command queue! Continuing anyway...\n");
63 }
64
65 #elif defined(__FreeBSD__)
66 d->nsectors = 26; /* FreeBSD only supports 64K I/O transfer size */
67 d->bigbuff = d->nsectors * CD_FRAMESIZE_RAW;
68
69 sprintf(buffer,"\tSetting default read size to %d sectors (%d bytes).\n\n",
70 d->nsectors,d->nsectors*CD_FRAMESIZE_RAW);
71 cdmessage(d,buffer);
72 #endif
73 }
74
75 #ifdef Linux
reset_scsi(cdrom_drive * d)76 static void reset_scsi(cdrom_drive *d){
77 int arg;
78 d->enable_cdda(d,0);
79
80 cdmessage(d,"sending SG SCSI reset... ");
81 if(ioctl(d->cdda_fd,SG_SCSI_RESET,&arg))
82 cdmessage(d,"FAILED: EBUSY\n");
83 else
84 cdmessage(d,"OK\n");
85
86 d->enable_cdda(d,1);
87 }
88
89 #elif defined(__FreeBSD__)
reset_scsi(cdrom_drive * d)90 static void reset_scsi(cdrom_drive *d) {
91 d->enable_cdda(d,0);
92
93 d->ccb->ccb_h.func_code = XPT_RESET_DEV;
94 d->ccb->ccb_h.timeout = 5000;
95
96 cdmessage(d, "sending SCSI reset... ");
97 if (cam_send_ccb(d->dev, d->ccb)) {
98 cdmessage(d, "error sending XPT_RESET_DEV CCB");
99 } else {
100
101 if (((d->ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) ||
102 ((d->ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_BDR_SENT))
103 cdmessage(d,"OK\n");
104 else
105 cdmessage(d,"FAILED\n");
106 }
107
108 d->enable_cdda(d,1);
109 }
110 #endif
111
112 #ifdef Linux
clear_garbage(cdrom_drive * d)113 static void clear_garbage(cdrom_drive *d){
114 fd_set fdset;
115 struct timeval tv;
116 struct sg_header *sg_hd=(struct sg_header *)d->sg;
117 int flag=0;
118
119 /* clear out any possibly preexisting garbage */
120 FD_ZERO(&fdset);
121 FD_SET(d->cdda_fd,&fdset);
122 tv.tv_sec=0;
123 tv.tv_usec=0;
124
125 /* I like select */
126 while(select(d->cdda_fd+1,&fdset,NULL,NULL,&tv)==1){
127
128 sg_hd->twelve_byte = 0;
129 sg_hd->result = 0;
130 sg_hd->reply_len = SG_OFF;
131 read(d->cdda_fd, sg_hd, 1);
132
133 /* reset for select */
134 FD_ZERO(&fdset);
135 FD_SET(d->cdda_fd,&fdset);
136 tv.tv_sec=0;
137 tv.tv_usec=0;
138 if(!flag && d->report_all)
139 cdmessage(d,"Clearing previously returned data from SCSI buffer\n");
140 flag=1;
141 }
142 }
143 #endif
144
145 /* process a complete scsi command. */
146 #ifdef Linux
handle_scsi_cmd(cdrom_drive * d,unsigned int cmd_len,unsigned int in_size,unsigned int out_size,unsigned char bytefill,int bytecheck)147 static int handle_scsi_cmd(cdrom_drive *d,
148 unsigned int cmd_len,
149 unsigned int in_size,
150 unsigned int out_size,
151
152 unsigned char bytefill,
153 int bytecheck){
154 int status = 0;
155 struct sg_header *sg_hd=(struct sg_header *)d->sg;
156 long writebytes=SG_OFF+cmd_len+in_size;
157
158 /* generic scsi device services */
159
160 /* clear out any possibly preexisting garbage */
161 clear_garbage(d);
162
163 memset(sg_hd,0,sizeof(sg_hd));
164 sg_hd->twelve_byte = cmd_len == 12;
165 sg_hd->result = 0;
166 sg_hd->reply_len = SG_OFF + out_size;
167
168 /* The following is one of the scariest hacks I've ever had to use.
169 The idea is this: We want to know if a command fails. The
170 generic scsi driver (as of now) won't tell us; it hands back the
171 uninitialized contents of the preallocated kernel buffer. We
172 force this buffer to a known value via another bug (nonzero data
173 length for a command that doesn't take data) such that we can
174 tell if the command failed. Scared yet? */
175
176 if(bytecheck && out_size>in_size){
177 memset(d->sg_buffer+cmd_len+in_size,bytefill,out_size-in_size);
178 /* the size does not remove cmd_len due to the way the kernel
179 driver copies buffers */
180 writebytes+=(out_size-in_size);
181 }
182
183 {
184 /* Select on write with a 5 second timeout. This is a hack until
185 a better error reporting layer is in place in alpha 10; right
186 now, always print a message. */
187
188 fd_set fdset;
189 struct timeval tv;
190
191 FD_ZERO(&fdset);
192 FD_SET(d->cdda_fd,&fdset);
193 tv.tv_sec=60; /* Increased to 1m for plextor, as the drive will
194 try to get through rough spots on its own and
195 this can take time 19991129 */
196 tv.tv_usec=0;
197
198 while(1){
199 int ret=select(d->cdda_fd+1,NULL,&fdset,NULL,&tv);
200 if(ret>0)break;
201 if(ret<0 && errno!=EINTR)break;
202 if(ret==0){
203 fprintf(stderr,"\nSCSI transport error: timeout waiting to write"
204 " packet\n\n");
205 return(TR_EWRITE);
206 }
207 }
208 }
209
210 sigprocmask (SIG_BLOCK, &(d->sigset), NULL );
211 errno=0;
212 status = write(d->cdda_fd, sg_hd, writebytes );
213
214 if (status<0 || status != writebytes ) {
215 sigprocmask ( SIG_UNBLOCK, &(d->sigset), NULL );
216 if(errno==0)errno=EIO;
217 return(TR_EWRITE);
218 }
219
220 {
221 /* Select on read (and write; this signals an error) with a 5
222 second timeout. This is a hack until a better error reporting
223 layer is in place in alpha 10; right now, always print a
224 message. */
225
226 fd_set rset;
227 struct timeval tv;
228
229 FD_ZERO(&rset);
230 FD_SET(d->cdda_fd,&rset);
231 tv.tv_sec=60; /* Increased to 1m for plextor, as the drive will
232 try to get through rough spots on its own and
233 this can take time 19991129 */
234 tv.tv_usec=0;
235
236 while(1){
237 int ret=select(d->cdda_fd+1,&rset,NULL,NULL,&tv);
238 if(ret<0 && errno!=EINTR)break;
239 if(ret==0){
240 sigprocmask ( SIG_UNBLOCK, &(d->sigset), NULL );
241 fprintf(stderr,"\nSCSI transport error: timeout waiting to read"
242 " packet\n\n");
243 return(TR_EREAD);
244 }
245 if(ret>0){
246 /* is it readable or something else? */
247 if(FD_ISSET(d->cdda_fd,&rset))break;
248 sigprocmask ( SIG_UNBLOCK, &(d->sigset), NULL );
249 fprintf(stderr,"\nSCSI transport: error reading packet\n\n");
250 return(TR_EREAD);
251 }
252 }
253 }
254
255 errno=0;
256 status = read(d->cdda_fd, sg_hd, SG_OFF + out_size);
257 sigprocmask ( SIG_UNBLOCK, &(d->sigset), NULL );
258
259 if (status<0)return(TR_EREAD);
260
261 if(status != SG_OFF + out_size || sg_hd->result){
262 if(errno==0)errno=EIO;
263 return(TR_EREAD);
264 }
265
266 if(sg_hd->sense_buffer[0]){
267 char key=sg_hd->sense_buffer[2]&0xf;
268 char ASC=sg_hd->sense_buffer[12];
269 char ASCQ=sg_hd->sense_buffer[13];
270 switch(key){
271 case 0:
272 if(errno==0)errno=EIO;
273 return(TR_UNKNOWN);
274 case 1:
275 break;
276 case 2:
277 if(errno==0)errno=EBUSY;
278 return(TR_BUSY);
279 case 3:
280 if(ASC==0x0C && ASCQ==0x09){
281 /* loss of streaming */
282 if(errno==0)errno=EIO;
283 return(TR_STREAMING);
284 }else{
285 if(errno==0)errno=EIO;
286 return(TR_MEDIUM);
287 }
288 case 4:
289 if(errno==0)errno=EIO;
290 return(TR_FAULT);
291 case 5:
292 if(errno==0)errno=EINVAL;
293 return(TR_ILLEGAL);
294 default:
295 if(errno==0)errno=EIO;
296 return(TR_UNKNOWN);
297 }
298 }
299
300 /* still not foolproof; the following doesn't guarantee that we got
301 all the data, just that the command was not rejected. */
302
303 /* Why do this with the above sense stuff? For some reason,
304 commands still get through. Perhaps no data comes back even
305 though the target reports success? */
306
307 if(bytecheck && in_size+cmd_len<out_size){
308 long i,flag=0;
309 for(i=in_size;i<out_size;i++)
310 if(d->sg_buffer[i]!=bytefill){
311 flag=1;
312 break;
313 }
314
315 if(!flag){
316 errno=EINVAL;
317 return(TR_ILLEGAL);
318 }
319 }
320
321 errno=0;
322 return(0);
323 }
324
325 #elif defined(__FreeBSD__)
handle_scsi_cmd(cdrom_drive * d,unsigned int cmd_len,unsigned int out_size,unsigned int in_size,unsigned char bytefill,int bytecheck)326 static int handle_scsi_cmd(cdrom_drive *d,
327 unsigned int cmd_len,
328 unsigned int out_size,
329 unsigned int in_size,
330 unsigned char bytefill,
331 int bytecheck) {
332 int result;
333 int error_code, sense_key, asc, ascq;
334
335 bzero(&d->ccb->csio, sizeof(d->ccb->csio));
336
337 memcpy(d->ccb->csio.cdb_io.cdb_bytes, d->sg_buffer, cmd_len);
338
339 if (bytecheck && out_size == 0)
340 memset(d->sg_buffer, bytefill, in_size);
341
342 cam_fill_csio(&d->ccb->csio,
343 /* retries */ 0,
344 /* cbfcnp */ NULL,
345 /* flags */ CAM_DEV_QFRZDIS | (out_size ? CAM_DIR_OUT : CAM_DIR_IN),
346 /* tag_action */ MSG_SIMPLE_Q_TAG,
347 /* data_ptr */ out_size ? d->sg_buffer + cmd_len : d->sg_buffer,
348 /* dxfer_len */ out_size ? out_size : in_size,
349 /* sense_len */ SSD_FULL_SIZE,
350 /* cdb_len */ cmd_len,
351 /* timeout */ 60000); /* XXX */
352
353 if ((result = cam_send_ccb(d->dev, d->ccb)) < 0 ||
354 (d->ccb->ccb_h.status & CAM_STATUS_MASK) == 0 /* hack? */)
355 return TR_EREAD;
356
357 if ((d->ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP &&
358 (d->ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_SCSI_STATUS_ERROR) {
359 fprintf (stderr, "\t\terror returned from SCSI command:\n"
360 "\t\tccb->ccb_h.status == %d\n", d->ccb->ccb_h.status);
361 errno = EIO;
362 return TR_UNKNOWN;
363 }
364
365 if (d->ccb->csio.dxfer_len != in_size) {
366 errno = EIO;
367 return TR_EREAD;
368 }
369
370 scsi_extract_sense(&d->ccb->csio.sense_data, &error_code, &sense_key,
371 &asc, &ascq);
372
373 switch (error_code) {
374 case SSD_CURRENT_ERROR:
375 case SSD_DEFERRED_ERROR:
376 #if (CAM_VERSION > 0x15)
377 case SSD_DESC_CURRENT_ERROR:
378 case SSD_DESC_DEFERRED_ERROR:
379 #endif
380 switch (sense_key) {
381 case SSD_KEY_NO_SENSE:
382 errno = EIO;
383 return TR_UNKNOWN;
384 case SSD_KEY_RECOVERED_ERROR:
385 break;
386 case SSD_KEY_NOT_READY:
387 errno = EBUSY;
388 return TR_BUSY;
389 case SSD_KEY_MEDIUM_ERROR:
390 errno = EIO;
391 if ((asc == 0x0c) && (ascq == 0x09))
392 return TR_STREAMING;
393 else
394 return TR_MEDIUM;
395 case SSD_KEY_HARDWARE_ERROR:
396 errno = EIO;
397 return TR_FAULT;
398 case SSD_KEY_ILLEGAL_REQUEST:
399 errno = EINVAL;
400 return TR_ILLEGAL;
401 default:
402 errno = EIO;
403 return TR_UNKNOWN;
404 }
405 default:
406 break;
407 }
408
409 return 0;
410 }
411 #endif
412
413
414 /* Group 1 (10b) command */
415
mode_sense_atapi(cdrom_drive * d,int size,int page)416 static int mode_sense_atapi(cdrom_drive *d,int size,int page){
417 memcpy(d->sg_buffer,
418 (char []) {0x5A, /* MODE_SENSE */
419 0x00, /* reserved */
420 0x00, /* page */
421 0, /* reserved */
422 0, /* reserved */
423 0, /* reserved */
424 0, /* reserved */
425 0, /* MSB (0) */
426 0, /* sizeof(modesense - SG_OFF) */
427 0}, /* reserved */
428 10);
429
430 d->sg_buffer[1]=d->lun<<5;
431 d->sg_buffer[2]=0x3F&page;
432 d->sg_buffer[8]=size+4;
433
434 if (handle_scsi_cmd (d, 10, 0, size+4,'\377',1)) return(1);
435
436 {
437 char *b=d->sg_buffer;
438 if(b[0])return(1); /* Handles only up to 256 bytes */
439 if(b[6])return(1); /* Handles only up to 256 bytes */
440
441 b[0]=b[1]-3;
442 b[1]=b[2];
443 b[2]=b[3];
444 b[3]=b[7];
445
446 memmove(b+4,b+8,size);
447 }
448 return(0);
449 }
450
451 /* group 0 (6b) command */
452
mode_sense_scsi(cdrom_drive * d,int size,int page)453 static int mode_sense_scsi(cdrom_drive *d,int size,int page){
454 memcpy(d->sg_buffer,
455 (char []) {0x1A, /* MODE_SENSE */
456 0x00, /* return block descriptor/lun */
457 0x00, /* page */
458 0, /* reserved */
459 0, /* sizeof(modesense - SG_OFF) */
460 0}, /* control */
461 6);
462
463 d->sg_buffer[1]=d->lun<<5;
464 d->sg_buffer[2]=(0x3F&page);
465 d->sg_buffer[4]=size;
466
467 if (handle_scsi_cmd (d, 6, 0, size, '\377',1)) return(1);
468 return(0);
469 }
470
mode_sense(cdrom_drive * d,int size,int page)471 static int mode_sense(cdrom_drive *d,int size,int page){
472 if(d->is_atapi)
473 return(mode_sense_atapi(d,size,page));
474 return(mode_sense_scsi(d,size,page));
475 }
476
mode_select(cdrom_drive * d,int density,int secsize)477 static int mode_select(cdrom_drive *d,int density,int secsize){
478 /* short circut the way Heiko does it; less flexible, but shorter */
479 if(d->is_atapi){
480 unsigned char *mode = d->sg_buffer + 18;
481
482 memcpy(d->sg_buffer,
483 (char []) { 0x55, /* MODE_SELECT */
484 0x10, /* no save page */
485 0, /* reserved */
486 0, /* reserved */
487 0, /* reserved */
488 0, /* reserved */
489 0, /* reserved */
490 0, /* reserved */
491 12, /* sizeof(mode) */
492 0, /* reserved */
493
494 /* mode parameter header */
495 0, 0, 0, 0, 0, 0, 0,
496 8, /* Block Descriptor Length */
497
498 /* descriptor block */
499 0, /* Density Code */
500 0, 0, 0, /* # of Blocks */
501 0, /* reserved */
502 0, 0, 0},/* Blocklen */
503 26);
504
505 d->sg_buffer[1]|=d->lun<<5;
506
507 /* prepare to read cds in the previous mode */
508 mode [0] = density;
509 mode [6] = secsize >> 8; /* block length "msb" */
510 mode [7] = secsize & 0xFF; /* block length lsb */
511
512 /* do the scsi cmd */
513 return(handle_scsi_cmd (d,10, 16, 0,0,0));
514
515 }else{
516 unsigned char *mode = d->sg_buffer + 10;
517
518 memcpy(d->sg_buffer,
519 (char []) { 0x15, /* MODE_SELECT */
520 0x10, /* no save page */
521 0, /* reserved */
522 0, /* reserved */
523 12, /* sizeof(mode) */
524 0, /* reserved */
525 /* mode section */
526 0,
527 0, 0,
528 8, /* Block Descriptor Length */
529 0, /* Density Code */
530 0, 0, 0, /* # of Blocks */
531 0, /* reserved */
532 0, 0, 0},/* Blocklen */
533 18);
534
535 /* prepare to read cds in the previous mode */
536 mode [0] = density;
537 mode [6] = secsize >> 8; /* block length "msb" */
538 mode [7] = secsize & 0xFF; /* block length lsb */
539
540 /* do the scsi cmd */
541 return(handle_scsi_cmd (d,6, 12, 0,0,0));
542 }
543 }
544
545 /* get current sector size from SCSI cdrom drive */
get_orig_sectorsize(cdrom_drive * d)546 static unsigned int get_orig_sectorsize(cdrom_drive *d){
547 if(mode_sense(d,12,0x01))return(-1);
548
549 d->orgdens = d->sg_buffer[4];
550 return(d->orgsize = ((int)(d->sg_buffer[10])<<8)+d->sg_buffer[11]);
551 }
552
553 /* switch CDROM scsi drives to given sector size */
set_sectorsize(cdrom_drive * d,unsigned int secsize)554 static int set_sectorsize (cdrom_drive *d,unsigned int secsize){
555 return(mode_select(d,d->orgdens,secsize));
556 }
557
558 /* switch Toshiba/DEC and HP drives from/to cdda density */
scsi_enable_cdda(cdrom_drive * d,int fAudioMode)559 int scsi_enable_cdda (cdrom_drive *d, int fAudioMode){
560 if (fAudioMode) {
561 if(mode_select(d,d->density,CD_FRAMESIZE_RAW)){
562 if(d->error_retry)
563 cderror(d,"001: Unable to set CDROM to read audio mode\n");
564 return(-1);
565 }
566 } else {
567 if(mode_select(d,d->orgdens,d->orgsize)){
568 if(d->error_retry)
569 cderror(d,"001: Unable to set CDROM to read audio mode\n");
570 return(-1);
571 }
572 }
573 return(0);
574 }
575
576 typedef struct scsi_TOC { /* structure of scsi table of contents (cdrom) */
577 unsigned char reserved1;
578 unsigned char bFlags;
579 unsigned char bTrack;
580 unsigned char reserved2;
581 signed char start_MSB;
582 unsigned char start_1;
583 unsigned char start_2;
584 unsigned char start_LSB;
585 } scsi_TOC;
586
587
588 /* read the table of contents from the cd and fill the TOC array */
589 /* Do it like the kernel ioctl driver; the 'all at once' approach
590 fails on at least one Kodak drive. */
591
scsi_read_toc(cdrom_drive * d)592 static int scsi_read_toc (cdrom_drive *d){
593 int i,first,last;
594 unsigned tracks;
595
596 /* READTOC, MSF format flag, res, res, res, res, Start track, len msb,
597 len lsb, flags */
598
599 /* read the header first */
600 memcpy(d->sg_buffer, (char []){ 0x43, 0, 0, 0, 0, 0, 1, 0, 12, 0}, 10);
601 d->sg_buffer[1]=d->lun<<5;
602
603 if (handle_scsi_cmd (d,10, 0, 12,'\377',1)){
604 cderror(d,"004: Unable to read table of contents header\n");
605 return(-4);
606 }
607
608 first=d->sg_buffer[2];
609 last=d->sg_buffer[3];
610 tracks=last-first+1;
611
612 if (last > MAXTRK || first > MAXTRK || last<0 || first<0) {
613 cderror(d,"003: CDROM reporting illegal number of tracks\n");
614 return(-3);
615 }
616
617 for (i = first; i <= last; i++){
618 memcpy(d->sg_buffer, (char []){ 0x43, 0, 0, 0, 0, 0, 0, 0, 12, 0}, 10);
619 d->sg_buffer[1]=d->lun<<5;
620 d->sg_buffer[6]=i;
621
622 if (handle_scsi_cmd (d,10, 0, 12,'\377',1)){
623 cderror(d,"005: Unable to read table of contents entry\n");
624 return(-5);
625 }
626 {
627 scsi_TOC *toc=(scsi_TOC *)(d->sg_buffer+4);
628
629 d->disc_toc[i-first].bFlags=toc->bFlags;
630 d->disc_toc[i-first].bTrack=i;
631 d->disc_toc[i-first].dwStartSector= d->adjust_ssize *
632 (((int)(toc->start_MSB)<<24) |
633 (toc->start_1<<16)|
634 (toc->start_2<<8)|
635 (toc->start_LSB));
636 }
637 }
638
639 memcpy(d->sg_buffer, (char []){ 0x43, 0, 0, 0, 0, 0, 0, 0, 12, 0}, 10);
640 d->sg_buffer[1]=d->lun<<5;
641 d->sg_buffer[6]=0xAA;
642
643 if (handle_scsi_cmd (d,10, 0, 12,'\377',1)){
644 cderror(d,"002: Unable to read table of contents lead-out\n");
645 return(-2);
646 }
647 {
648 scsi_TOC *toc=(scsi_TOC *)(d->sg_buffer+4);
649
650 d->disc_toc[i-first].bFlags=toc->bFlags;
651 d->disc_toc[i-first].bTrack=0xAA;
652 d->disc_toc[i-first].dwStartSector= d->adjust_ssize *
653 (((int)(toc->start_MSB)<<24) |
654 (toc->start_1<<16)|
655 (toc->start_2<<8)|
656 (toc->start_LSB));
657 }
658
659 d->cd_extra = FixupTOC(d,tracks+1); /* include lead-out */
660 return(tracks);
661 }
662
663 /* a contribution from Boris for IMS cdd 522 */
664 /* check this for ACER/Creative/Foo 525,620E,622E, etc? */
scsi_read_toc2(cdrom_drive * d)665 static int scsi_read_toc2 (cdrom_drive *d){
666 u_int32_t foo,bar;
667
668 int i;
669 unsigned tracks;
670
671 memcpy(d->sg_buffer, (char[]){ 0xe5, 0, 0, 0, 0, 0, 0, 0, 0, 0}, 10);
672 d->sg_buffer[5]=1;
673 d->sg_buffer[8]=255;
674
675 if (handle_scsi_cmd (d,10, 0, 256,'\377',1)){
676 cderror(d,"004: Unable to read table of contents header\n");
677 return(-4);
678 }
679
680 /* copy to our structure and convert start sector */
681 tracks = d->sg_buffer[1];
682 if (tracks > MAXTRK) {
683 cderror(d,"003: CDROM reporting illegal number of tracks\n");
684 return(-3);
685 }
686
687 for (i = 0; i < tracks; i++){
688 memcpy(d->sg_buffer, (char[]){ 0xe5, 0, 0, 0, 0, 0, 0, 0, 0, 0}, 10);
689 d->sg_buffer[5]=i+1;
690 d->sg_buffer[8]=255;
691
692 if (handle_scsi_cmd (d,10, 0, 256,'\377',1)){
693 cderror(d,"005: Unable to read table of contents entry\n");
694 return(-5);
695 }
696
697 d->disc_toc[i].bFlags = d->sg_buffer[10];
698 d->disc_toc[i].bTrack = i + 1;
699
700 d->disc_toc[i].dwStartSector= d->adjust_ssize *
701 (((signed char)(d->sg_buffer[2])<<24) |
702 (d->sg_buffer[3]<<16)|
703 (d->sg_buffer[4]<<8)|
704 (d->sg_buffer[5]));
705 }
706
707 d->disc_toc[i].bFlags = 0;
708 d->disc_toc[i].bTrack = i + 1;
709 memcpy (&foo, d->sg_buffer+2, 4);
710 memcpy (&bar, d->sg_buffer+6, 4);
711 d->disc_toc[i].dwStartSector = d->adjust_ssize * (be32_to_cpu(foo) +
712 be32_to_cpu(bar));
713
714 d->disc_toc[i].dwStartSector= d->adjust_ssize *
715 ((((signed char)(d->sg_buffer[2])<<24) |
716 (d->sg_buffer[3]<<16)|
717 (d->sg_buffer[4]<<8)|
718 (d->sg_buffer[5]))+
719
720 ((((signed char)(d->sg_buffer[6])<<24) |
721 (d->sg_buffer[7]<<16)|
722 (d->sg_buffer[8]<<8)|
723 (d->sg_buffer[9]))));
724
725
726 d->cd_extra = FixupTOC(d,tracks+1);
727 return(tracks);
728 }
729
730 /* These do one 'extra' copy in the name of clean code */
731
i_read_28(cdrom_drive * d,void * p,long begin,long sectors)732 static int i_read_28 (cdrom_drive *d, void *p, long begin, long sectors){
733 int ret;
734 memcpy(d->sg_buffer,(char []){0x28, 0, 0, 0, 0, 0, 0, 0, 0, 0},10);
735
736 if(d->fua)
737 d->sg_buffer[1]=0x08;
738
739 d->sg_buffer[1]|=d->lun<<5;
740
741 d->sg_buffer[3] = (begin >> 16) & 0xFF;
742 d->sg_buffer[4] = (begin >> 8) & 0xFF;
743 d->sg_buffer[5] = begin & 0xFF;
744 d->sg_buffer[8] = sectors;
745 if((ret=handle_scsi_cmd(d,10,0,sectors * CD_FRAMESIZE_RAW,'\177',1)))
746 return(ret);
747 if(p)memcpy(p,d->sg_buffer,sectors*CD_FRAMESIZE_RAW);
748 return(0);
749 }
750
i_read_A8(cdrom_drive * d,void * p,long begin,long sectors)751 static int i_read_A8 (cdrom_drive *d, void *p, long begin, long sectors){
752 int ret;
753 memcpy(d->sg_buffer,(char []){0xA8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},12);
754
755 if(d->fua)
756 d->sg_buffer[1]=0x08;
757
758 d->sg_buffer[1]|=d->lun<<5;
759
760 d->sg_buffer[3] = (begin >> 16) & 0xFF;
761 d->sg_buffer[4] = (begin >> 8) & 0xFF;
762 d->sg_buffer[5] = begin & 0xFF;
763 d->sg_buffer[9] = sectors;
764 if((ret=handle_scsi_cmd(d,12,0,sectors * CD_FRAMESIZE_RAW,'\177',1)))
765 return(ret);
766 if(p)memcpy(p,d->sg_buffer,sectors*CD_FRAMESIZE_RAW);
767 return(0);
768 }
769
i_read_D4_10(cdrom_drive * d,void * p,long begin,long sectors)770 static int i_read_D4_10 (cdrom_drive *d, void *p, long begin, long sectors){
771 int ret;
772 memcpy(d->sg_buffer,(char []){0xd4, 0, 0, 0, 0, 0, 0, 0, 0, 0},10);
773
774 if(d->fua)
775 d->sg_buffer[1]=0x08;
776
777 d->sg_buffer[1]|=d->lun<<5;
778 d->sg_buffer[3] = (begin >> 16) & 0xFF;
779 d->sg_buffer[4] = (begin >> 8) & 0xFF;
780 d->sg_buffer[5] = begin & 0xFF;
781 d->sg_buffer[8] = sectors;
782 if((ret=handle_scsi_cmd(d,10,0,sectors * CD_FRAMESIZE_RAW,'\177',1)))
783 return(ret);
784 if(p)memcpy(p,d->sg_buffer,sectors*CD_FRAMESIZE_RAW);
785 return(0);
786 }
787
i_read_D4_12(cdrom_drive * d,void * p,long begin,long sectors)788 static int i_read_D4_12 (cdrom_drive *d, void *p, long begin, long sectors){
789 int ret;
790 memcpy(d->sg_buffer,(char []){0xd4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},12);
791
792 if(d->fua)
793 d->sg_buffer[1]=0x08;
794
795 d->sg_buffer[1]|=d->lun<<5;
796 d->sg_buffer[3] = (begin >> 16) & 0xFF;
797 d->sg_buffer[4] = (begin >> 8) & 0xFF;
798 d->sg_buffer[5] = begin & 0xFF;
799 d->sg_buffer[9] = sectors;
800 if((ret=handle_scsi_cmd(d,12,0,sectors * CD_FRAMESIZE_RAW,'\177',1)))
801 return(ret);
802 if(p)memcpy(p,d->sg_buffer,sectors*CD_FRAMESIZE_RAW);
803 return(0);
804 }
805
i_read_D5(cdrom_drive * d,void * p,long begin,long sectors)806 static int i_read_D5 (cdrom_drive *d, void *p, long begin, long sectors){
807 int ret;
808 memcpy(d->sg_buffer,(char []){0xd5, 0, 0, 0, 0, 0, 0, 0, 0, 0},10);
809
810 if(d->fua)
811 d->sg_buffer[1]=0x08;
812
813 d->sg_buffer[1]|=d->lun<<5;
814 d->sg_buffer[3] = (begin >> 16) & 0xFF;
815 d->sg_buffer[4] = (begin >> 8) & 0xFF;
816 d->sg_buffer[5] = begin & 0xFF;
817 d->sg_buffer[8] = sectors;
818 if((ret=handle_scsi_cmd(d,10,0,sectors * CD_FRAMESIZE_RAW,'\177',1)))
819 return(ret);
820 if(p)memcpy(p,d->sg_buffer,sectors*CD_FRAMESIZE_RAW);
821 return(0);
822 }
823
i_read_D8(cdrom_drive * d,void * p,long begin,long sectors)824 static int i_read_D8 (cdrom_drive *d, void *p, long begin, long sectors){
825 int ret;
826 memcpy(d->sg_buffer,(char []){0xd8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},12);
827
828 if(d->fua)
829 d->sg_buffer[1]=0x08;
830
831 d->sg_buffer[1]|=d->lun<<5;
832 d->sg_buffer[3] = (begin >> 16) & 0xFF;
833 d->sg_buffer[4] = (begin >> 8) & 0xFF;
834 d->sg_buffer[5] = begin & 0xFF;
835 d->sg_buffer[9] = sectors;
836 if((ret=handle_scsi_cmd(d,12,0,sectors * CD_FRAMESIZE_RAW,'\177',1)))
837 return(ret);
838 if(p)memcpy(p,d->sg_buffer,sectors*CD_FRAMESIZE_RAW);
839 return(0);
840 }
841
i_read_mmc(cdrom_drive * d,void * p,long begin,long sectors)842 static int i_read_mmc (cdrom_drive *d, void *p, long begin, long sectors){
843 int ret;
844 /* if(begin<=12007 && begin+sectors>12000){
845 errno=EIO;
846 return(TR_ILLEGAL);
847 }*/
848
849 memcpy(d->sg_buffer,(char []){0xbe, 0, 0, 0, 0, 0, 0, 0, 0, 0x10, 0, 0},12);
850
851 d->sg_buffer[3] = (begin >> 16) & 0xFF;
852 d->sg_buffer[4] = (begin >> 8) & 0xFF;
853 d->sg_buffer[5] = begin & 0xFF;
854 d->sg_buffer[8] = sectors;
855 if((ret=handle_scsi_cmd(d,12,0,sectors * CD_FRAMESIZE_RAW,'\177',1)))
856 return(ret);
857 if(p)memcpy(p,d->sg_buffer,sectors*CD_FRAMESIZE_RAW);
858 return(0);
859 }
860
i_read_mmc2(cdrom_drive * d,void * p,long begin,long sectors)861 static int i_read_mmc2 (cdrom_drive *d, void *p, long begin, long sectors){
862 int ret;
863 memcpy(d->sg_buffer,(char []){0xbe, 0, 0, 0, 0, 0, 0, 0, 0, 0xf8, 0, 0},12);
864
865 d->sg_buffer[3] = (begin >> 16) & 0xFF;
866 d->sg_buffer[4] = (begin >> 8) & 0xFF;
867 d->sg_buffer[5] = begin & 0xFF;
868 d->sg_buffer[8] = sectors;
869 if((ret=handle_scsi_cmd(d,12,0,sectors * CD_FRAMESIZE_RAW,'\177',1)))
870 return(ret);
871 if(p)memcpy(p,d->sg_buffer,sectors*CD_FRAMESIZE_RAW);
872 return(0);
873 }
874
i_read_mmc3(cdrom_drive * d,void * p,long begin,long sectors)875 static int i_read_mmc3 (cdrom_drive *d, void *p, long begin, long sectors){
876 int ret;
877 memcpy(d->sg_buffer,(char []){0xbe, 4, 0, 0, 0, 0, 0, 0, 0, 0xf8, 0, 0},12);
878
879 d->sg_buffer[3] = (begin >> 16) & 0xFF;
880 d->sg_buffer[4] = (begin >> 8) & 0xFF;
881 d->sg_buffer[5] = begin & 0xFF;
882 d->sg_buffer[8] = sectors;
883 if((ret=handle_scsi_cmd(d,12,0,sectors * CD_FRAMESIZE_RAW,'\177',1)))
884 return(ret);
885 if(p)memcpy(p,d->sg_buffer,sectors*CD_FRAMESIZE_RAW);
886 return(0);
887 }
888
889 /* straight from the MMC3 spec */
LBA_to_MSF(long lba,unsigned char * M,unsigned char * S,unsigned char * F)890 static inline void LBA_to_MSF(long lba,
891 unsigned char *M,
892 unsigned char *S,
893 unsigned char *F){
894 if(lba>=-150){
895 *M=(lba+150)/(60*75);
896 lba-=(*M)*60*75;
897 *S=(lba+150)/75;
898 lba-=(*S)*75;
899 *F=(lba+150);
900 }else{
901 *M=(lba+450150)/(60*75);
902 lba-=(*M)*60*75;
903 *S=(lba+450150)/75;
904 lba-=(*S)*75;
905 *F=(lba+450150);
906 }
907 }
908
909
i_read_msf(cdrom_drive * d,void * p,long begin,long sectors)910 static int i_read_msf (cdrom_drive *d, void *p, long begin, long sectors){
911 int ret;
912 memcpy(d->sg_buffer,(char []){0xb9, 0, 0, 0, 0, 0, 0, 0, 0, 0x10, 0, 0},12);
913
914 LBA_to_MSF(begin,d->sg_buffer+3,d->sg_buffer+4,d->sg_buffer+5);
915 LBA_to_MSF(begin+sectors,d->sg_buffer+6,d->sg_buffer+7,d->sg_buffer+8);
916
917 if((ret=handle_scsi_cmd(d,12,0,sectors * CD_FRAMESIZE_RAW,'\177',1)))
918 return(ret);
919 if(p)memcpy(p,d->sg_buffer,sectors*CD_FRAMESIZE_RAW);
920 return(0);
921 }
922
i_read_msf2(cdrom_drive * d,void * p,long begin,long sectors)923 static int i_read_msf2 (cdrom_drive *d, void *p, long begin, long sectors){
924 int ret;
925 memcpy(d->sg_buffer,(char []){0xb9, 0, 0, 0, 0, 0, 0, 0, 0, 0xf8, 0, 0},12);
926
927 LBA_to_MSF(begin,d->sg_buffer+3,d->sg_buffer+4,d->sg_buffer+5);
928 LBA_to_MSF(begin+sectors,d->sg_buffer+6,d->sg_buffer+7,d->sg_buffer+8);
929
930 if((ret=handle_scsi_cmd(d,12,0,sectors * CD_FRAMESIZE_RAW,'\177',1)))
931 return(ret);
932 if(p)memcpy(p,d->sg_buffer,sectors*CD_FRAMESIZE_RAW);
933 return(0);
934 }
935
i_read_msf3(cdrom_drive * d,void * p,long begin,long sectors)936 static int i_read_msf3 (cdrom_drive *d, void *p, long begin, long sectors){
937 int ret;
938 memcpy(d->sg_buffer,(char []){0xb9, 4, 0, 0, 0, 0, 0, 0, 0, 0xf8, 0, 0},12);
939
940 LBA_to_MSF(begin,d->sg_buffer+3,d->sg_buffer+4,d->sg_buffer+5);
941 LBA_to_MSF(begin+sectors,d->sg_buffer+6,d->sg_buffer+7,d->sg_buffer+8);
942
943 if((ret=handle_scsi_cmd(d,12,0,sectors * CD_FRAMESIZE_RAW,'\177',1)))
944 return(ret);
945 if(p)memcpy(p,d->sg_buffer,sectors*CD_FRAMESIZE_RAW);
946 return(0);
947 }
948
scsi_read_map(cdrom_drive * d,void * p,long begin,long sectors,int (* map)(cdrom_drive *,void *,long,long))949 static long scsi_read_map (cdrom_drive *d, void *p, long begin, long sectors,
950 int (*map)(cdrom_drive *, void *, long, long)){
951 int retry_count,err;
952 char *buffer=(char *)p;
953
954 /* read d->nsectors at a time, max. */
955 sectors=(sectors>d->nsectors?d->nsectors:sectors);
956 sectors=(sectors<1?1:sectors);
957
958 retry_count=0;
959
960 while(1) {
961 if((err=map(d,(p?buffer:NULL),begin,sectors))){
962 if(d->report_all){
963 #ifdef Linux
964 struct sg_header *sg_hd=(struct sg_header *)d->sg;
965 #elif defined(__FreeBSD__)
966 int error_code, sense_key, asc, ascq;
967 #endif
968 char b[256];
969
970 sprintf(b,"scsi_read error: sector=%ld length=%ld retry=%d\n",
971 begin,sectors,retry_count);
972 fputs(b, stderr);
973 cdmessage(d,b);
974 #if defined(__FreeBSD__)
975 scsi_extract_sense(&d->ccb->csio.sense_data, &error_code, &sense_key,
976 &asc, &ascq);
977 #endif
978 sprintf(b," Sense key: %x ASC: %x ASCQ: %x\n",
979 #ifdef Linux
980 (int)(sg_hd->sense_buffer[2]&0xf),
981 (int)(sg_hd->sense_buffer[12]),
982 (int)(sg_hd->sense_buffer[13]));
983 #elif defined(__FreeBSD__)
984 sense_key, asc, ascq);
985 #endif
986 fputs(b, stderr);
987 cdmessage(d,b);
988 sprintf(b," Transport error: %s\n",strerror_tr[err]);
989 fputs(b, stderr);
990 cdmessage(d,b);
991 sprintf(b," System error: %s\n",strerror(errno));
992 fputs(b, stderr);
993 cdmessage(d,b);
994 }
995
996 if(!d->error_retry)return(-7);
997 switch(errno){
998 case EINTR:
999 usleep(100);
1000 continue;
1001 case ENOMEM:
1002 /* D'oh. Possible kernel error. Keep limping */
1003 usleep(100);
1004 if(sectors==1){
1005 /* Nope, can't continue */
1006 cderror(d,"300: Kernel memory error\n");
1007 return(-300);
1008 }
1009 if(d->report_all){
1010 char b[256];
1011 sprintf(b,"scsi_read: kernel couldn't alloc %ld bytes. "
1012 "backing off...\n",sectors*CD_FRAMESIZE_RAW);
1013
1014 cdmessage(d,b);
1015 }
1016 sectors--;
1017 continue;
1018 default:
1019 if(sectors==1){
1020 if(errno==EIO)
1021 if(d->fua==-1) /* testing for FUA support */
1022 return(-7);
1023
1024 /* *Could* be I/O or media error. I think. If we're at
1025 30 retries, we better skip this unhappy little
1026 sector. */
1027 if(retry_count>MAX_RETRIES-1){
1028 char b[256];
1029 sprintf(b,"010: Unable to access sector %ld\n",
1030 begin);
1031 cderror(d,b);
1032 return(-10);
1033
1034 }
1035 break;
1036 }
1037
1038 /* Hmm. OK, this is just a tad silly. just in case this was
1039 a timeout and a reset happened, we need to set the drive
1040 back to cdda */
1041 reset_scsi(d);
1042 }
1043 }else{
1044
1045 /* Did we get all the bytes we think we did, or did the kernel
1046 suck? */
1047 if(buffer){
1048 long i;
1049 for(i=sectors*CD_FRAMESIZE_RAW;i>1;i-=2)
1050 if(buffer[i-1]!='\177' || buffer[i-2]!='\177')
1051 break;
1052
1053 i/=CD_FRAMESIZE_RAW;
1054 if(i!=sectors){
1055 if(d->report_all){
1056 char b[256];
1057 sprintf(b,"scsi_read underrun: pos=%ld len=%ld read=%ld retry=%d\n",
1058 begin,sectors,i,retry_count);
1059
1060 cdmessage(d,b);
1061 }
1062 reset_scsi(d);
1063 }
1064
1065 if(i>0)return(i);
1066 }else
1067 break;
1068 }
1069
1070 retry_count++;
1071 if(sectors==1 && retry_count>MAX_RETRIES){
1072 cderror(d,"007: Unknown, unrecoverable error reading data\n");
1073 return(-7);
1074 }
1075 if(sectors>1)sectors=sectors/2;
1076 d->enable_cdda(d,0);
1077 d->enable_cdda(d,1);
1078
1079 }
1080 return(sectors);
1081 }
1082
scsi_read_28(cdrom_drive * d,void * p,long begin,long sectors)1083 long scsi_read_28 (cdrom_drive *d, void *p, long begin,
1084 long sectors){
1085 return(scsi_read_map(d,p,begin,sectors,i_read_28));
1086 }
1087
scsi_read_A8(cdrom_drive * d,void * p,long begin,long sectors)1088 long scsi_read_A8 (cdrom_drive *d, void *p, long begin,
1089 long sectors){
1090 return(scsi_read_map(d,p,begin,sectors,i_read_A8));
1091 }
1092
scsi_read_D4_10(cdrom_drive * d,void * p,long begin,long sectors)1093 long scsi_read_D4_10 (cdrom_drive *d, void *p, long begin,
1094 long sectors){
1095 return(scsi_read_map(d,p,begin,sectors,i_read_D4_10));
1096 }
1097
scsi_read_D4_12(cdrom_drive * d,void * p,long begin,long sectors)1098 long scsi_read_D4_12 (cdrom_drive *d, void *p, long begin,
1099 long sectors){
1100 return(scsi_read_map(d,p,begin,sectors,i_read_D4_12));
1101 }
1102
scsi_read_D5(cdrom_drive * d,void * p,long begin,long sectors)1103 long scsi_read_D5 (cdrom_drive *d, void *p, long begin,
1104 long sectors){
1105 return(scsi_read_map(d,p,begin,sectors,i_read_D5));
1106 }
1107
scsi_read_D8(cdrom_drive * d,void * p,long begin,long sectors)1108 long scsi_read_D8 (cdrom_drive *d, void *p, long begin,
1109 long sectors){
1110 return(scsi_read_map(d,p,begin,sectors,i_read_D8));
1111 }
1112
scsi_read_mmc(cdrom_drive * d,void * p,long begin,long sectors)1113 long scsi_read_mmc (cdrom_drive *d, void *p, long begin,
1114 long sectors){
1115 return(scsi_read_map(d,p,begin,sectors,i_read_mmc));
1116 }
1117
scsi_read_mmc2(cdrom_drive * d,void * p,long begin,long sectors)1118 long scsi_read_mmc2 (cdrom_drive *d, void *p, long begin,
1119 long sectors){
1120 return(scsi_read_map(d,p,begin,sectors,i_read_mmc2));
1121 }
1122
scsi_read_mmc3(cdrom_drive * d,void * p,long begin,long sectors)1123 long scsi_read_mmc3 (cdrom_drive *d, void *p, long begin,
1124 long sectors){
1125 return(scsi_read_map(d,p,begin,sectors,i_read_mmc3));
1126 }
1127
scsi_read_msf(cdrom_drive * d,void * p,long begin,long sectors)1128 long scsi_read_msf (cdrom_drive *d, void *p, long begin,
1129 long sectors){
1130 return(scsi_read_map(d,p,begin,sectors,i_read_msf));
1131 }
1132
scsi_read_msf2(cdrom_drive * d,void * p,long begin,long sectors)1133 long scsi_read_msf2 (cdrom_drive *d, void *p, long begin,
1134 long sectors){
1135 return(scsi_read_map(d,p,begin,sectors,i_read_msf2));
1136 }
1137
scsi_read_msf3(cdrom_drive * d,void * p,long begin,long sectors)1138 long scsi_read_msf3 (cdrom_drive *d, void *p, long begin,
1139 long sectors){
1140 return(scsi_read_map(d,p,begin,sectors,i_read_msf3));
1141 }
1142
1143
1144 /* Some drives, given an audio read command, return only 2048 bytes
1145 of data as opposed to 2352 bytes. Look for bytess at the end of the
1146 single sector verification read */
1147
count_2352_bytes(cdrom_drive * d)1148 static int count_2352_bytes(cdrom_drive *d){
1149 long i;
1150 for(i=2351;i>=0;i--)
1151 if(d->sg_buffer[i]!=(unsigned char)'\177')
1152 return(((i+3)>>2)<<2);
1153
1154 return(0);
1155 }
1156
verify_nonzero(cdrom_drive * d)1157 static int verify_nonzero(cdrom_drive *d){
1158 long i,flag=0;
1159 for(i=0;i<2352;i++)
1160 if(d->sg_buffer[i]!=0){
1161 flag=1;
1162 break;
1163 }
1164
1165 return(flag);
1166 }
1167
1168 /* So many different read commands, densities, features...
1169 Verify that our selected 'read' command actually reads
1170 nonzero data, else search through other possibilities */
1171
verify_read_command(cdrom_drive * d)1172 static int verify_read_command(cdrom_drive *d){
1173 int i,j,k;
1174 int audioflag=0;
1175
1176 int (*enablecommand) (struct cdrom_drive *d, int speed);
1177 long (*readcommand) (struct cdrom_drive *d, void *p, long begin,
1178 long sectors);
1179 unsigned char density;
1180
1181 int16_t *buff=malloc(CD_FRAMESIZE_RAW);
1182
1183 cdmessage(d,"Verifying CDDA command set...\n");
1184
1185 /* try the expected command set; grab the center of each track, look
1186 for data */
1187
1188 if(d->enable_cdda(d,1)==0){
1189
1190 for(i=1;i<=d->tracks;i++){
1191 if(cdda_track_audiop(d,i)==1){
1192 long firstsector=cdda_track_firstsector(d,i);
1193 long lastsector=cdda_track_lastsector(d,i);
1194 long sector=(firstsector+lastsector)>>1;
1195 audioflag=1;
1196
1197 if(d->read_audio(d,buff,sector,1)>0){
1198 if(count_2352_bytes(d)==2352){
1199 cdmessage(d,"\tExpected command set reads OK.\n");
1200 d->enable_cdda(d,0);
1201 free(buff);
1202 return(0);
1203 }
1204 }
1205 }
1206 }
1207
1208 d->enable_cdda(d,0);
1209 }
1210
1211 if(!audioflag){
1212 cdmessage(d,"\tCould not find any audio tracks on this disk.\n");
1213 return(-403);
1214 }
1215
1216
1217 {
1218 char *es="",*rs="";
1219 d->bigendianp=-1;
1220 density=d->density;
1221 readcommand=d->read_audio;
1222 enablecommand=d->enable_cdda;
1223
1224
1225 /* No nonzeroes? D'oh. Exhaustive search */
1226 cdmessage(d,"\tExpected command set FAILED!\n"
1227 "\tPerforming full probe for CDDA command set...\n");
1228
1229 /* loops:
1230 density/enable no, 0x0/org, 0x04/org, 0x82/org
1231 read command read_10 read_12 read_nec read_sony read_mmc read_mmc2 */
1232
1233 /* NEC test must come before sony; the nec drive expects d8 to be
1234 10 bytes, and a 12 byte verson (Sony) crashes the drive */
1235
1236 for(j=0;j>=0;j++){
1237 int densitypossible=1;
1238
1239 switch(j){
1240 case 0:
1241 d->read_audio=scsi_read_28;
1242 rs="28 0x,00";
1243 break;
1244 case 1:
1245 d->read_audio=scsi_read_A8;
1246 rs="a8 0x,00";
1247 break;
1248 case 2:
1249 d->read_audio=scsi_read_mmc;
1250 rs="be 00,10";
1251 densitypossible=0;
1252 break;
1253 case 3:
1254 d->read_audio=scsi_read_mmc2;
1255 rs="be 00,f8";
1256 densitypossible=0;
1257 break;
1258 case 4:
1259 d->read_audio=scsi_read_mmc3;
1260 rs="be 04,f8";
1261 densitypossible=0;
1262 break;
1263
1264 case 5:
1265 d->read_audio=scsi_read_msf;
1266 rs="b9 00,10";
1267 densitypossible=0;
1268 break;
1269 case 6:
1270 d->read_audio=scsi_read_msf2;
1271 rs="b9 00,f8";
1272 densitypossible=0;
1273 break;
1274 case 7:
1275 d->read_audio=scsi_read_msf3;
1276 rs="b9 04,f8";
1277 densitypossible=0;
1278 break;
1279
1280 case 8:
1281 d->read_audio=scsi_read_D4_10;
1282 rs="d4(10)0x";
1283 break;
1284 case 9:
1285 d->read_audio=scsi_read_D4_12;
1286 rs="d4(12)0x";
1287 break;
1288 case 10:
1289 d->read_audio=scsi_read_D5;
1290 rs="d5 0x,00";
1291 break;
1292 case 11:
1293 d->read_audio=scsi_read_D8;
1294 rs="d8 0x,00";
1295 j=-2;
1296 break;
1297 }
1298
1299 for(i=0;i>=0;i++){
1300 switch(i){
1301 case 0:
1302 d->density=0;
1303 d->enable_cdda=Dummy;
1304 es="none ";
1305 if(!densitypossible)i=-2; /* short circuit MMC style commands */
1306 break;
1307 case 1:
1308 d->density=0;
1309 d->enable_cdda=scsi_enable_cdda;
1310 es="yes/0x00";
1311 break;
1312 case 2:
1313 d->density=0x04;
1314 d->enable_cdda=scsi_enable_cdda;
1315 es="yes/0x04";
1316 break;
1317 case 3:
1318 d->density=0x82;
1319 d->enable_cdda=scsi_enable_cdda;
1320 es="yes/0x82";
1321 case 4:
1322 d->density=0x81;
1323 d->enable_cdda=scsi_enable_cdda;
1324 es="yes/0x81";
1325 i=-2;
1326 break;
1327 }
1328
1329 cdmessage(d,"\ttest -> density: [");
1330 cdmessage(d,es);
1331 cdmessage(d,"] command: [");
1332 cdmessage(d,rs);
1333 cdmessage(d,"]\n");
1334
1335 {
1336 int densityflag=0;
1337 int rejectflag=0;
1338 int zeroflag=0;
1339 int lengthflag=0;
1340
1341 if(d->enable_cdda(d,1)==0){
1342 for(k=1;k<=d->tracks;k++){
1343 if(cdda_track_audiop(d,k)==1){
1344 long firstsector=cdda_track_firstsector(d,k);
1345 long lastsector=cdda_track_lastsector(d,k);
1346 long sector=(firstsector+lastsector)>>1;
1347
1348 if(d->read_audio(d,buff,sector,1)>0){
1349 if((lengthflag=count_2352_bytes(d))==2352){
1350 if(verify_nonzero(d)){
1351 cdmessage(d,"\t\tCommand set FOUND!\n");
1352
1353 free(buff);
1354 d->enable_cdda(d,0);
1355 return(0);
1356 }else{
1357 zeroflag++;
1358 }
1359 }
1360 }else{
1361 rejectflag++;
1362 break;
1363 }
1364 }
1365 }
1366 d->enable_cdda(d,0);
1367 }else{
1368 densityflag++;
1369 }
1370
1371 if(densityflag)
1372 cdmessage(d,"\t\tDrive rejected density set\n");
1373 if(rejectflag){
1374 char buffer[256];
1375 sprintf(buffer,"\t\tDrive rejected read command packet(s)\n");
1376 cdmessage(d,buffer);
1377 }
1378 if(lengthflag>0 && lengthflag<2352){
1379 char buffer[256];
1380 sprintf(buffer,"\t\tDrive returned at least one packet, but with\n"
1381 "\t\tincorrect size (%d)\n",lengthflag);
1382 cdmessage(d,buffer);
1383 }
1384 if(zeroflag){
1385 char buffer[256];
1386 sprintf(buffer,"\t\tDrive returned %d packet(s), but contents\n"
1387 "\t\twere entirely zero\n",zeroflag);
1388 cdmessage(d,buffer);
1389 }
1390 }
1391 }
1392 }
1393
1394 /* D'oh. */
1395 d->density=density;
1396 d->read_audio=readcommand;
1397 d->enable_cdda=enablecommand;
1398
1399 cdmessage(d,"\tUnable to find any suitable command set from probe;\n"
1400 "\tdrive probably not CDDA capable.\n");
1401
1402 cderror(d,"006: Could not read any data from drive\n");
1403
1404 }
1405 free(buff);
1406 return(-6);
1407 }
1408
check_fua_bit(cdrom_drive * d)1409 static void check_fua_bit(cdrom_drive *d){
1410 int16_t *buff=malloc(CD_FRAMESIZE_RAW);
1411 long i;
1412
1413 if(d->read_audio==scsi_read_mmc)return;
1414 if(d->read_audio==scsi_read_mmc2)return;
1415 if(d->read_audio==scsi_read_mmc3)return;
1416
1417 cdmessage(d,"This command set may use a Force Unit Access bit.");
1418 cdmessage(d,"\nChecking drive for FUA bit support...\n");
1419
1420 d->enable_cdda(d,1);
1421 d->fua=1;
1422
1423 for(i=1;i<=d->tracks;i++){
1424 if(cdda_track_audiop(d,i)==1){
1425 long firstsector=cdda_track_firstsector(d,i);
1426 long lastsector=cdda_track_lastsector(d,i);
1427 long sector=(firstsector+lastsector)>>1;
1428
1429 if(d->read_audio(d,buff,sector,1)>0){
1430 cdmessage(d,"\tDrive accepted FUA bit.\n");
1431 d->enable_cdda(d,0);
1432 free(buff);
1433 return;
1434 }
1435 }
1436 }
1437
1438 d->fua=0;
1439 cdmessage(d,"\tDrive rejected FUA bit.\n");
1440 free(buff);
1441 return;
1442 }
1443
1444 #ifdef Linux
check_atapi(cdrom_drive * d)1445 static int check_atapi(cdrom_drive *d){
1446 int atapiret=-1;
1447 int fd = d->cdda_fd; /* this is the correct fd (not ioctl_fd), as the
1448 generic device is the device we need to check */
1449
1450 cdmessage(d,"\nChecking for SCSI emulation...\n");
1451
1452 if (ioctl(fd,SG_EMULATED_HOST,&atapiret)){
1453 cderror(d,"\tSG_EMULATED_HOST ioctl() failed!\n");
1454 return(-1);
1455 } else {
1456 if(atapiret==1){
1457 cdmessage(d,"\tDrive is ATAPI (using SCSI host adaptor emulation)\n");
1458 /* Disable kernel SCSI command translation layer for access through sg */
1459 if (ioctl(fd,SG_SET_TRANSFORM,0))
1460 cderror(d,"\tCouldn't disable kernel command translation layer\n");
1461 d->is_atapi=1;
1462 }else{
1463 cdmessage(d,"\tDrive is SCSI\n");
1464 d->is_atapi=0;
1465 }
1466
1467 return(d->is_atapi);
1468 }
1469 }
1470
1471 #elif defined(__FreeBSD__)
1472 static int
check_atapi(cdrom_drive * d)1473 check_atapi(cdrom_drive *d)
1474 {
1475 bzero(&(&d->ccb->ccb_h)[1], sizeof(d->ccb->cpi) - sizeof(d->ccb->ccb_h));
1476
1477 d->ccb->ccb_h.func_code = XPT_PATH_INQ;
1478
1479 cdmessage(d, "\nChecking for ATAPICAM...\n");
1480
1481 if (cam_send_ccb(d->dev, d->ccb) < 0) {
1482 cderror(d, "\terror sending XPT_PATH_INQ CCB: ");
1483 cderror(d, cam_errbuf);
1484 cderror(d, "\n");
1485 return -1;
1486 }
1487
1488 if ((d->ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
1489 cderror(d, "\tXPT_PATH_INQ CCB failed: ");
1490 cderror(d, cam_errbuf);
1491 cderror(d, "\n");
1492 return -1;
1493 }
1494
1495 /*
1496 * if the bus device name is `ata', we're (obviously)
1497 * running ATAPICAM.
1498 * same for the new ahci(4) and siis(4) drivers and future others
1499 * which use SATA transport too...
1500 */
1501
1502 if (strncmp(d->ccb->cpi.dev_name, "ata", 3) == 0 ||
1503 #if __FreeBSD_version >= 800102
1504 d->ccb->cpi.transport == XPORT_SATA ||
1505 #endif
1506 d->ccb->cpi.transport == XPORT_ATA) {
1507 cdmessage(d, "\tDrive is ATAPI (using ATAPICAM or direct CAM (S)ATA transport)\n");
1508 d->is_atapi = 1;
1509 } else {
1510 cdmessage(d, "\tDrive is SCSI\n");
1511 d->is_atapi = 0;
1512 }
1513
1514 return d->is_atapi;
1515 }
1516 #endif
1517
check_mmc(cdrom_drive * d)1518 static int check_mmc(cdrom_drive *d){
1519 char *b;
1520 cdmessage(d,"\nChecking for MMC style command set...\n");
1521
1522 d->is_mmc=0;
1523 if(mode_sense(d,22,0x2A)==0){
1524
1525 b=d->sg_buffer;
1526 b+=b[3]+4;
1527
1528 if((b[0]&0x3F)==0x2A){
1529 /* MMC style drive! */
1530 d->is_mmc=1;
1531
1532 if(b[1]>=4){
1533 if(b[5]&0x1){
1534 cdmessage(d,"\tDrive is MMC style\n");
1535 return(1);
1536 }else{
1537 cdmessage(d,"\tDrive is MMC, but reports CDDA incapable.\n");
1538 cdmessage(d,"\tIt will likely not be able to read audio data.\n");
1539 return(1);
1540 }
1541 }
1542 }
1543 }
1544
1545 cdmessage(d,"\tDrive does not have MMC CDDA support\n");
1546 return(0);
1547 }
1548
check_exceptions(cdrom_drive * d,exception * list)1549 static void check_exceptions(cdrom_drive *d,exception *list){
1550
1551 int i=0;
1552 while(list[i].model){
1553 if(!strncmp(list[i].model,d->drive_model,strlen(list[i].model))){
1554 if(list[i].density)d->density=list[i].density;
1555 if(list[i].enable)d->enable_cdda=list[i].enable;
1556 if(list[i].read)d->read_audio=list[i].read;
1557 if(list[i].bigendianp!=-1)d->bigendianp=list[i].bigendianp;
1558 return;
1559 }
1560 i++;
1561 }
1562 }
1563
1564 #ifdef Linux
1565 /* request vendor brand and model */
scsi_inquiry(cdrom_drive * d)1566 unsigned char *scsi_inquiry(cdrom_drive *d){
1567 memcpy(d->sg_buffer,(char[]){ 0x12,0,0,0,56,0},6);
1568
1569 if(handle_scsi_cmd(d,6, 0, 56,'\377',1)) {
1570 cderror(d,"008: Unable to identify CDROM model\n");
1571 return(NULL);
1572 }
1573 return (d->sg_buffer);
1574 }
1575 #endif
1576
1577
scsi_init_drive(cdrom_drive * d)1578 int scsi_init_drive(cdrom_drive *d){
1579 int ret;
1580
1581 check_atapi(d);
1582 check_mmc(d);
1583
1584 /* generic Sony type defaults; specialize from here */
1585 d->density = 0x0;
1586 d->enable_cdda = Dummy;
1587 d->read_audio = scsi_read_D8;
1588 d->fua=0x0;
1589 if(d->is_atapi)d->lun=0; /* it should already be; just to make sure */
1590
1591 if(d->is_mmc){
1592
1593 d->read_audio = scsi_read_mmc2;
1594 d->bigendianp=0;
1595
1596 check_exceptions(d,mmc_list);
1597
1598 }else{
1599
1600 if(d->is_atapi){
1601 /* Not MMC maybe still uses 0xbe */
1602
1603 d->read_audio = scsi_read_mmc2;
1604 d->bigendianp=0;
1605
1606 check_exceptions(d,atapi_list);
1607
1608 }else{
1609
1610 check_exceptions(d,scsi_list);
1611
1612 }
1613 }
1614
1615 if(!d->is_atapi)set_sectorsize(d,2048); /* we really do want the
1616 sector size at 2048 to begin.*/
1617 d->enable_cdda(d,0);
1618
1619 d->read_toc = (!memcmp(d->drive_model, "IMS", 3) && !d->is_atapi) ? scsi_read_toc2 :
1620 scsi_read_toc;
1621 d->set_speed = NULL;
1622
1623
1624 if(!d->is_atapi){
1625 unsigned sector_size= get_orig_sectorsize(d);
1626
1627 if(sector_size<2048 && set_sectorsize(d,2048))
1628 d->adjust_ssize = 2048 / sector_size;
1629 else
1630 d->adjust_ssize = 1;
1631 }else
1632 d->adjust_ssize = 1;
1633
1634 d->tracks=d->read_toc(d);
1635 if(d->tracks<1)
1636 return(d->tracks);
1637
1638 tweak_SG_buffer(d);
1639 d->opened=1;
1640
1641 if((ret=verify_read_command(d)))return(ret);
1642 check_fua_bit(d);
1643
1644 d->error_retry=1;
1645 #ifdef Linux
1646 d->sg=realloc(d->sg,d->nsectors*CD_FRAMESIZE_RAW + SG_OFF + 128);
1647 d->sg_buffer=d->sg+SG_OFF;
1648 #elif defined(__FreeBSD__)
1649 d->sg_buffer = realloc(d->sg_buffer, d->nsectors * CD_FRAMESIZE_RAW);
1650 #endif
1651 d->report_all=1;
1652 return(0);
1653 }
1654
1655