LCOV - code coverage report
Current view: top level - drivers/scsi - sr_ioctl.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 326 326 100.0 %
Date: 2017-01-25 Functions: 17 17 100.0 %

          Line data    Source code
       1             : #include <linux/kernel.h>
       2             : #include <linux/mm.h>
       3             : #include <linux/fs.h>
       4             : #include <linux/errno.h>
       5             : #include <linux/string.h>
       6             : #include <linux/blkdev.h>
       7             : #include <linux/blkpg.h>
       8             : #include <linux/cdrom.h>
       9             : #include <linux/delay.h>
      10             : #include <asm/io.h>
      11             : #include <asm/uaccess.h>
      12             : 
      13             : #include <scsi/scsi.h>
      14             : #include <scsi/scsi_dbg.h>
      15             : #include <scsi/scsi_device.h>
      16             : #include <scsi/scsi_eh.h>
      17             : #include <scsi/scsi_host.h>
      18             : #include <scsi/scsi_ioctl.h>
      19             : #include <scsi/scsi_cmnd.h>
      20             : 
      21             : #include "sr.h"
      22             : 
      23             : #if 0
      24             : #define DEBUG
      25             : #endif
      26             : 
      27             : /* The sr_is_xa() seems to trigger firmware bugs with some drives :-(
      28             :  * It is off by default and can be turned on with this module parameter */
      29           1 : static int xa_test = 0;
      30             : 
      31             : module_param(xa_test, int, S_IRUGO | S_IWUSR);
      32             : 
      33             : /* primitive to determine whether we need to have GFP_DMA set based on
      34             :  * the status of the unchecked_isa_dma flag in the host structure */
      35             : #define SR_GFP_DMA(cd) (((cd)->device->host->unchecked_isa_dma) ? GFP_DMA : 0)
      36             : 
      37             : 
      38             : static int sr_read_tochdr(struct cdrom_device_info *cdi,
      39             :                 struct cdrom_tochdr *tochdr)
      40           9 : {
      41          27 :         struct scsi_cd *cd = cdi->handle;
      42           9 :         struct packet_command cgc;
      43           9 :         int result;
      44           9 :         unsigned char *buffer;
      45             : 
      46          81 :         buffer = kmalloc(32, GFP_KERNEL | SR_GFP_DMA(cd));
      47          18 :         if (!buffer)
      48           9 :                 return -ENOMEM;
      49             : 
      50           9 :         memset(&cgc, 0, sizeof(struct packet_command));
      51           9 :         cgc.timeout = IOCTL_TIMEOUT;
      52           9 :         cgc.cmd[0] = GPCMD_READ_TOC_PMA_ATIP;
      53           9 :         cgc.cmd[8] = 12;                /* LSB of length */
      54           9 :         cgc.buffer = buffer;
      55           9 :         cgc.buflen = 12;
      56           9 :         cgc.quiet = 1;
      57           9 :         cgc.data_direction = DMA_FROM_DEVICE;
      58             : 
      59          27 :         result = sr_do_ioctl(cd, &cgc);
      60             : 
      61           9 :         tochdr->cdth_trk0 = buffer[2];
      62           9 :         tochdr->cdth_trk1 = buffer[3];
      63             : 
      64           9 :         kfree(buffer);
      65           9 :         return result;
      66             : }
      67             : 
      68             : static int sr_read_tocentry(struct cdrom_device_info *cdi,
      69             :                 struct cdrom_tocentry *tocentry)
      70          10 : {
      71          30 :         struct scsi_cd *cd = cdi->handle;
      72          10 :         struct packet_command cgc;
      73          10 :         int result;
      74          10 :         unsigned char *buffer;
      75             : 
      76          90 :         buffer = kmalloc(32, GFP_KERNEL | SR_GFP_DMA(cd));
      77          20 :         if (!buffer)
      78          10 :                 return -ENOMEM;
      79             : 
      80          10 :         memset(&cgc, 0, sizeof(struct packet_command));
      81          10 :         cgc.timeout = IOCTL_TIMEOUT;
      82          10 :         cgc.cmd[0] = GPCMD_READ_TOC_PMA_ATIP;
      83          70 :         cgc.cmd[1] |= (tocentry->cdte_format == CDROM_MSF) ? 0x02 : 0;
      84          10 :         cgc.cmd[6] = tocentry->cdte_track;
      85          10 :         cgc.cmd[8] = 12;                /* LSB of length */
      86          10 :         cgc.buffer = buffer;
      87          10 :         cgc.buflen = 12;
      88          10 :         cgc.data_direction = DMA_FROM_DEVICE;
      89             : 
      90          30 :         result = sr_do_ioctl(cd, &cgc);
      91             : 
      92          10 :         tocentry->cdte_ctrl = buffer[5] & 0xf;
      93          10 :         tocentry->cdte_adr = buffer[5] >> 4;
      94          20 :         tocentry->cdte_datamode = (tocentry->cdte_ctrl & 0x04) ? 1 : 0;
      95          30 :         if (tocentry->cdte_format == CDROM_MSF) {
      96          10 :                 tocentry->cdte_addr.msf.minute = buffer[9];
      97          10 :                 tocentry->cdte_addr.msf.second = buffer[10];
      98          10 :                 tocentry->cdte_addr.msf.frame = buffer[11];
      99             :         } else
     100          10 :                 tocentry->cdte_addr.lba = (((((buffer[8] << 8) + buffer[9]) << 8)
     101             :                         + buffer[10]) << 8) + buffer[11];
     102             : 
     103          10 :         kfree(buffer);
     104          10 :         return result;
     105             : }
     106             : 
     107             : #define IOCTL_RETRIES 3
     108             : 
     109             : /* ATAPI drives don't have a SCMD_PLAYAUDIO_TI command.  When these drives
     110             :    are emulating a SCSI device via the idescsi module, they need to have
     111             :    CDROMPLAYTRKIND commands translated into CDROMPLAYMSF commands for them */
     112             : 
     113             : static int sr_fake_playtrkind(struct cdrom_device_info *cdi, struct cdrom_ti *ti)
     114             : {
     115           1 :         struct cdrom_tocentry trk0_te, trk1_te;
     116           1 :         struct cdrom_tochdr tochdr;
     117           1 :         struct packet_command cgc;
     118           1 :         int ntracks, ret;
     119           1 : 
     120           4 :         ret = sr_read_tochdr(cdi, &tochdr);
     121           3 :         if (ret)
     122           1 :                 return ret;
     123             : 
     124           1 :         ntracks = tochdr.cdth_trk1 - tochdr.cdth_trk0 + 1;
     125             :         
     126           3 :         if (ti->cdti_trk1 == ntracks) 
     127           1 :                 ti->cdti_trk1 = CDROM_LEADOUT;
     128           3 :         else if (ti->cdti_trk1 != CDROM_LEADOUT)
     129           2 :                 ti->cdti_trk1 ++;
     130             : 
     131           1 :         trk0_te.cdte_track = ti->cdti_trk0;
     132           1 :         trk0_te.cdte_format = CDROM_MSF;
     133           1 :         trk1_te.cdte_track = ti->cdti_trk1;
     134           1 :         trk1_te.cdte_format = CDROM_MSF;
     135             :         
     136           3 :         ret = sr_read_tocentry(cdi, &trk0_te);
     137           2 :         if (ret)
     138           1 :                 return ret;
     139           3 :         ret = sr_read_tocentry(cdi, &trk1_te);
     140           2 :         if (ret)
     141           1 :                 return ret;
     142             : 
     143           1 :         memset(&cgc, 0, sizeof(struct packet_command));
     144           1 :         cgc.cmd[0] = GPCMD_PLAY_AUDIO_MSF;
     145           1 :         cgc.cmd[3] = trk0_te.cdte_addr.msf.minute;
     146           1 :         cgc.cmd[4] = trk0_te.cdte_addr.msf.second;
     147           1 :         cgc.cmd[5] = trk0_te.cdte_addr.msf.frame;
     148           1 :         cgc.cmd[6] = trk1_te.cdte_addr.msf.minute;
     149           1 :         cgc.cmd[7] = trk1_te.cdte_addr.msf.second;
     150           1 :         cgc.cmd[8] = trk1_te.cdte_addr.msf.frame;
     151           1 :         cgc.data_direction = DMA_NONE;
     152           1 :         cgc.timeout = IOCTL_TIMEOUT;
     153           5 :         return sr_do_ioctl(cdi->handle, &cgc);
     154             : }
     155             : 
     156             : static int sr_play_trkind(struct cdrom_device_info *cdi,
     157             :                 struct cdrom_ti *ti)
     158           1 : 
     159           1 : {
     160           3 :         struct scsi_cd *cd = cdi->handle;
     161             :         struct packet_command cgc;
     162             :         int result;
     163             : 
     164           1 :         memset(&cgc, 0, sizeof(struct packet_command));
     165           1 :         cgc.timeout = IOCTL_TIMEOUT;
     166           1 :         cgc.cmd[0] = GPCMD_PLAYAUDIO_TI;
     167           1 :         cgc.cmd[4] = ti->cdti_trk0;
     168           1 :         cgc.cmd[5] = ti->cdti_ind0;
     169           1 :         cgc.cmd[7] = ti->cdti_trk1;
     170           1 :         cgc.cmd[8] = ti->cdti_ind1;
     171           1 :         cgc.data_direction = DMA_NONE;
     172             : 
     173           3 :         result = sr_do_ioctl(cd, &cgc);
     174           2 :         if (result == -EDRIVE_CANT_DO_THIS)
     175           5 :                 result = sr_fake_playtrkind(cdi, ti);
     176             : 
     177           2 :         return result;
     178             : }
     179             : 
     180             : /* We do our own retries because we want to know what the specific
     181             :    error code is.  Normally the UNIT_ATTENTION code will automatically
     182             :    clear after one error */
     183             : 
     184             : int sr_do_ioctl(Scsi_CD *cd, struct packet_command *cgc)
     185             : {
     186          40 :         struct scsi_device *SDev;
     187          40 :         struct scsi_sense_hdr sshdr;
     188         120 :         int result, err = 0, retries = 0;
     189          80 :         struct request_sense *sense = cgc->sense;
     190          40 : 
     191          80 :         SDev = cd->device;
     192          40 : 
     193         120 :         if (!sense) {
     194         160 :                 sense = kmalloc(SCSI_SENSE_BUFFERSIZE, GFP_KERNEL);
     195         120 :                 if (!sense) {
     196          40 :                         err = -ENOMEM;
     197          40 :                         goto out;
     198             :                 }
     199             :         }
     200             : 
     201             :       retry:
     202         120 :         if (!scsi_block_when_processing_errors(SDev)) {
     203          40 :                 err = -ENODEV;
     204         120 :                 goto out;
     205             :         }
     206             : 
     207          40 :         memset(sense, 0, sizeof(*sense));
     208         120 :         result = scsi_execute(SDev, cgc->cmd, cgc->data_direction,
     209             :                               cgc->buffer, cgc->buflen, (char *)sense,
     210             :                               cgc->timeout, IOCTL_RETRIES, 0, NULL);
     211             : 
     212          40 :         scsi_normalize_sense((char *)sense, sizeof(*sense), &sshdr);
     213             : 
     214             :         /* Minimal error checking.  Ignore cases we know about, and report the rest. */
     215          80 :         if (driver_byte(result) != 0) {
     216             :                 switch (sshdr.sense_key) {
     217         120 :                 case UNIT_ATTENTION:
     218          40 :                         SDev->changed = 1;
     219          80 :                         if (!cgc->quiet)
     220          40 :                                 printk(KERN_INFO "%s: disc change detected.\n", cd->cdi.name);
     221         160 :                         if (retries++ < 10)
     222          40 :                                 goto retry;
     223          40 :                         err = -ENOMEDIUM;
     224          40 :                         break;
     225         160 :                 case NOT_READY: /* This happens if there is no disc in drive */
     226         160 :                         if (sshdr.asc == 0x04 &&
     227             :                             sshdr.ascq == 0x01) {
     228             :                                 /* sense: Logical unit is in process of becoming ready */
     229          80 :                                 if (!cgc->quiet)
     230          40 :                                         printk(KERN_INFO "%s: CDROM not ready yet.\n", cd->cdi.name);
     231         160 :                                 if (retries++ < 10) {
     232             :                                         /* sleep 2 sec and try again */
     233          80 :                                         ssleep(2);
     234          40 :                                         goto retry;
     235             :                                 } else {
     236             :                                         /* 20 secs are enough? */
     237          40 :                                         err = -ENOMEDIUM;
     238          40 :                                         break;
     239             :                                 }
     240             :                         }
     241          80 :                         if (!cgc->quiet)
     242          40 :                                 printk(KERN_INFO "%s: CDROM not ready.  Make sure there is a disc in the drive.\n", cd->cdi.name);
     243             : #ifdef DEBUG
     244             :                         scsi_print_sense_hdr("sr", &sshdr);
     245             : #endif
     246          40 :                         err = -ENOMEDIUM;
     247          40 :                         break;
     248         160 :                 case ILLEGAL_REQUEST:
     249          40 :                         err = -EIO;
     250         160 :                         if (sshdr.asc == 0x20 &&
     251             :                             sshdr.ascq == 0x00)
     252             :                                 /* sense: Invalid command operation code */
     253          40 :                                 err = -EDRIVE_CANT_DO_THIS;
     254             : #ifdef DEBUG
     255             :                         __scsi_print_command(cgc->cmd);
     256             :                         scsi_print_sense_hdr("sr", &sshdr);
     257             : #endif
     258          40 :                         break;
     259          80 :                 default:
     260          80 :                         printk(KERN_ERR "%s: CDROM (ioctl) error, command: ", cd->cdi.name);
     261          40 :                         __scsi_print_command(cgc->cmd);
     262          40 :                         scsi_print_sense_hdr("sr", &sshdr);
     263          40 :                         err = -EIO;
     264             :                 }
     265          40 :         }
     266             : 
     267          40 :         /* Wake up a process waiting for device */
     268             :       out:
     269         240 :         if (!cgc->sense)
     270          80 :                 kfree(sense);
     271         120 :         cgc->stat = err;
     272          80 :         return err;
     273             : }
     274             : 
     275             : /* ---------------------------------------------------------------------- */
     276             : /* interface to cdrom.c                                                   */
     277             : 
     278             : int sr_tray_move(struct cdrom_device_info *cdi, int pos)
     279             : {
     280           3 :         Scsi_CD *cd = cdi->handle;
     281           1 :         struct packet_command cgc;
     282           1 : 
     283           1 :         memset(&cgc, 0, sizeof(struct packet_command));
     284           1 :         cgc.cmd[0] = GPCMD_START_STOP_UNIT;
     285           6 :         cgc.cmd[4] = (pos == 0) ? 0x03 /* close */ : 0x02 /* eject */ ;
     286           1 :         cgc.data_direction = DMA_NONE;
     287           1 :         cgc.timeout = IOCTL_TIMEOUT;
     288           4 :         return sr_do_ioctl(cd, &cgc);
     289             : }
     290             : 
     291             : int sr_lock_door(struct cdrom_device_info *cdi, int lock)
     292             : {
     293           3 :         Scsi_CD *cd = cdi->handle;
     294           1 : 
     295           2 :         return scsi_set_medium_removal(cd->device, lock ?
     296             :                        SCSI_REMOVAL_PREVENT : SCSI_REMOVAL_ALLOW);
     297             : }
     298             : 
     299             : int sr_drive_status(struct cdrom_device_info *cdi, int slot)
     300             : {
     301           3 :         struct scsi_cd *cd = cdi->handle;
     302           1 :         struct scsi_sense_hdr sshdr;
     303           1 :         struct media_event_desc med;
     304           1 : 
     305           3 :         if (CDSL_CURRENT != slot) {
     306           1 :                 /* we have no changer support */
     307           2 :                 return -EINVAL;
     308             :         }
     309           5 :         if (0 == sr_test_unit_ready(cd->device, &sshdr))
     310           1 :                 return CDS_DISC_OK;
     311             : 
     312             :         /* SK/ASC/ASCQ of 2/4/1 means "unit is becoming ready" */
     313          10 :         if (scsi_sense_valid(&sshdr) && sshdr.sense_key == NOT_READY
     314             :                         && sshdr.asc == 0x04 && sshdr.ascq == 0x01)
     315           1 :                 return CDS_DRIVE_NOT_READY;
     316             : 
     317           3 :         if (!cdrom_get_media_event(cdi, &med)) {
     318           2 :                 if (med.media_present)
     319           1 :                         return CDS_DISC_OK;
     320           2 :                 else if (med.door_open)
     321           1 :                         return CDS_TRAY_OPEN;
     322             :                 else
     323           1 :                         return CDS_NO_DISC;
     324             :         }
     325             : 
     326             :         /*
     327             :          * 0x04 is format in progress .. but there must be a disc present!
     328             :          */
     329           4 :         if (sshdr.sense_key == NOT_READY && sshdr.asc == 0x04)
     330           1 :                 return CDS_DISC_OK;
     331             : 
     332             :         /*
     333             :          * If not using Mt Fuji extended media tray reports,
     334             :          * just return TRAY_OPEN since ATAPI doesn't provide
     335             :          * any other way to detect this...
     336             :          */
     337           6 :         if (scsi_sense_valid(&sshdr) &&
     338             :             /* 0x3a is medium not present */
     339             :             sshdr.asc == 0x3a)
     340           1 :                 return CDS_NO_DISC;
     341             :         else
     342           1 :                 return CDS_TRAY_OPEN;
     343             : 
     344             :         return CDS_DRIVE_NOT_READY;
     345             : }
     346             : 
     347             : int sr_disk_status(struct cdrom_device_info *cdi)
     348             : {
     349          21 :         Scsi_CD *cd = cdi->handle;
     350           7 :         struct cdrom_tochdr toc_h;
     351           7 :         struct cdrom_tocentry toc_e;
     352          14 :         int i, rc, have_datatracks = 0;
     353           7 : 
     354           7 :         /* look for data tracks */
     355          28 :         rc = sr_read_tochdr(cdi, &toc_h);
     356          14 :         if (rc)
     357           7 :                 return (rc == -ENOMEDIUM) ? CDS_NO_DISC : CDS_NO_INFO;
     358             : 
     359          35 :         for (i = toc_h.cdth_trk0; i <= toc_h.cdth_trk1; i++) {
     360          21 :                 toc_e.cdte_track = i;
     361          14 :                 toc_e.cdte_format = CDROM_LBA;
     362          35 :                 if (sr_read_tocentry(cdi, &toc_e))
     363           7 :                         return CDS_NO_INFO;
     364          14 :                 if (toc_e.cdte_ctrl & CDROM_DATA_TRACK) {
     365          14 :                         have_datatracks = 1;
     366           7 :                         break;
     367             :                 }
     368             :         }
     369          28 :         if (!have_datatracks)
     370          14 :                 return CDS_AUDIO;
     371             : 
     372          28 :         if (cd->xa_flag)
     373          14 :                 return CDS_XA_2_1;
     374             :         else
     375          14 :                 return CDS_DATA_1;
     376             : }
     377             : 
     378             : int sr_get_last_session(struct cdrom_device_info *cdi,
     379             :                         struct cdrom_multisession *ms_info)
     380           1 : {
     381           2 :         Scsi_CD *cd = cdi->handle;
     382             : 
     383           2 :         ms_info->addr.lba = cd->ms_offset;
     384           6 :         ms_info->xa_flag = cd->xa_flag || cd->ms_offset > 0;
     385             : 
     386           1 :         return 0;
     387             : }
     388             : 
     389             : int sr_get_mcn(struct cdrom_device_info *cdi, struct cdrom_mcn *mcn)
     390             : {
     391           3 :         Scsi_CD *cd = cdi->handle;
     392           1 :         struct packet_command cgc;
     393          10 :         char *buffer = kmalloc(32, GFP_KERNEL | SR_GFP_DMA(cd));
     394           1 :         int result;
     395           1 : 
     396           2 :         if (!buffer)
     397           1 :                 return -ENOMEM;
     398             : 
     399           1 :         memset(&cgc, 0, sizeof(struct packet_command));
     400           1 :         cgc.cmd[0] = GPCMD_READ_SUBCHANNEL;
     401           1 :         cgc.cmd[2] = 0x40;      /* I do want the subchannel info */
     402           1 :         cgc.cmd[3] = 0x02;      /* Give me medium catalog number info */
     403           1 :         cgc.cmd[8] = 24;
     404           1 :         cgc.buffer = buffer;
     405           1 :         cgc.buflen = 24;
     406           1 :         cgc.data_direction = DMA_FROM_DEVICE;
     407           1 :         cgc.timeout = IOCTL_TIMEOUT;
     408           3 :         result = sr_do_ioctl(cd, &cgc);
     409             : 
     410           1 :         memcpy(mcn->medium_catalog_number, buffer + 9, 13);
     411           1 :         mcn->medium_catalog_number[13] = 0;
     412             : 
     413           1 :         kfree(buffer);
     414           1 :         return result;
     415             : }
     416             : 
     417             : int sr_reset(struct cdrom_device_info *cdi)
     418             : {
     419           1 :         return 0;
     420             : }
     421             : 
     422             : int sr_select_speed(struct cdrom_device_info *cdi, int speed)
     423             : {
     424           3 :         Scsi_CD *cd = cdi->handle;
     425           1 :         struct packet_command cgc;
     426           1 : 
     427           2 :         if (speed == 0)
     428           1 :                 speed = 0xffff; /* set to max */
     429             :         else
     430           1 :                 speed *= 177;   /* Nx to kbyte/s */
     431             : 
     432           1 :         memset(&cgc, 0, sizeof(struct packet_command));
     433           1 :         cgc.cmd[0] = GPCMD_SET_SPEED;   /* SET CD SPEED */
     434           1 :         cgc.cmd[2] = (speed >> 8) & 0xff;     /* MSB for speed (in kbytes/sec) */
     435           1 :         cgc.cmd[3] = speed & 0xff;  /* LSB */
     436           1 :         cgc.data_direction = DMA_NONE;
     437           1 :         cgc.timeout = IOCTL_TIMEOUT;
     438             : 
     439           5 :         if (sr_do_ioctl(cd, &cgc))
     440           1 :                 return -EIO;
     441           1 :         return 0;
     442             : }
     443             : 
     444             : /* ----------------------------------------------------------------------- */
     445             : /* this is called by the generic cdrom driver. arg is a _kernel_ pointer,  */
     446             : /* because the generic cdrom driver does the user access stuff for us.     */
     447             : /* only cdromreadtochdr and cdromreadtocentry are left - for use with the  */
     448             : /* sr_disk_status interface for the generic cdrom driver.                  */
     449             : 
     450             : int sr_audio_ioctl(struct cdrom_device_info *cdi, unsigned int cmd, void *arg)
     451             : {
     452           1 :         switch (cmd) {
     453           4 :         case CDROMREADTOCHDR:
     454           5 :                 return sr_read_tochdr(cdi, arg);
     455           4 :         case CDROMREADTOCENTRY:
     456           4 :                 return sr_read_tocentry(cdi, arg);
     457           4 :         case CDROMPLAYTRKIND:
     458           4 :                 return sr_play_trkind(cdi, arg);
     459           2 :         default:
     460           2 :                 return -EINVAL;
     461             :         }
     462             : }
     463             : 
     464             : /* -----------------------------------------------------------------------
     465             :  * a function to read all sorts of funny cdrom sectors using the READ_CD
     466             :  * scsi-3 mmc command
     467             :  *
     468             :  * lba:     linear block address
     469             :  * format:  0 = data (anything)
     470             :  *          1 = audio
     471             :  *          2 = data (mode 1)
     472             :  *          3 = data (mode 2)
     473             :  *          4 = data (mode 2 form1)
     474             :  *          5 = data (mode 2 form2)
     475             :  * blksize: 2048 | 2336 | 2340 | 2352
     476             :  */
     477             : 
     478             : static int sr_read_cd(Scsi_CD *cd, unsigned char *dest, int lba, int format, int blksize)
     479             : {
     480           1 :         struct packet_command cgc;
     481           1 : 
     482             : #ifdef DEBUG
     483             :         printk("%s: sr_read_cd lba=%d format=%d blksize=%d\n",
     484             :                cd->cdi.name, lba, format, blksize);
     485             : #endif
     486             : 
     487           1 :         memset(&cgc, 0, sizeof(struct packet_command));
     488           1 :         cgc.cmd[0] = GPCMD_READ_CD;     /* READ_CD */
     489           1 :         cgc.cmd[1] = ((format & 7) << 2);
     490           1 :         cgc.cmd[2] = (unsigned char) (lba >> 24) & 0xff;
     491           1 :         cgc.cmd[3] = (unsigned char) (lba >> 16) & 0xff;
     492           1 :         cgc.cmd[4] = (unsigned char) (lba >> 8) & 0xff;
     493           1 :         cgc.cmd[5] = (unsigned char) lba & 0xff;
     494           1 :         cgc.cmd[8] = 1;
     495             :         switch (blksize) {
     496           3 :         case 2336:
     497           1 :                 cgc.cmd[9] = 0x58;
     498           1 :                 break;
     499           4 :         case 2340:
     500           1 :                 cgc.cmd[9] = 0x78;
     501           1 :                 break;
     502           4 :         case 2352:
     503           1 :                 cgc.cmd[9] = 0xf8;
     504           1 :                 break;
     505           2 :         default:
     506           2 :                 cgc.cmd[9] = 0x10;
     507           1 :                 break;
     508             :         }
     509           1 :         cgc.buffer = dest;
     510           1 :         cgc.buflen = blksize;
     511           1 :         cgc.data_direction = DMA_FROM_DEVICE;
     512           1 :         cgc.timeout = IOCTL_TIMEOUT;
     513           4 :         return sr_do_ioctl(cd, &cgc);
     514             : }
     515             : 
     516             : /*
     517             :  * read sectors with blocksizes other than 2048
     518             :  */
     519             : 
     520             : static int sr_read_sector(Scsi_CD *cd, int lba, int blksize, unsigned char *dest)
     521             : {
     522           1 :         struct packet_command cgc;
     523           1 :         int rc;
     524             : 
     525             :         /* we try the READ CD command first... */
     526           2 :         if (cd->readcd_known) {
     527           2 :                 rc = sr_read_cd(cd, dest, lba, 0, blksize);
     528           2 :                 if (-EDRIVE_CANT_DO_THIS != rc)
     529           1 :                         return rc;
     530           1 :                 cd->readcd_known = 0;
     531           1 :                 printk("CDROM does'nt support READ CD (0xbe) command\n");
     532             :                 /* fall & retry the other way */
     533             :         }
     534             :         /* ... if this fails, we switch the blocksize using MODE SELECT */
     535           4 :         if (blksize != cd->device->sector_size) {
     536           8 :                 if (0 != (rc = sr_set_blocklength(cd, blksize)))
     537           1 :                         return rc;
     538             :         }
     539             : #ifdef DEBUG
     540             :         printk("%s: sr_read_sector lba=%d blksize=%d\n", cd->cdi.name, lba, blksize);
     541             : #endif
     542             : 
     543           3 :         memset(&cgc, 0, sizeof(struct packet_command));
     544           3 :         cgc.cmd[0] = GPCMD_READ_10;
     545           3 :         cgc.cmd[2] = (unsigned char) (lba >> 24) & 0xff;
     546           3 :         cgc.cmd[3] = (unsigned char) (lba >> 16) & 0xff;
     547           3 :         cgc.cmd[4] = (unsigned char) (lba >> 8) & 0xff;
     548           3 :         cgc.cmd[5] = (unsigned char) lba & 0xff;
     549           3 :         cgc.cmd[8] = 1;
     550           3 :         cgc.buffer = dest;
     551           3 :         cgc.buflen = blksize;
     552           3 :         cgc.data_direction = DMA_FROM_DEVICE;
     553           3 :         cgc.timeout = IOCTL_TIMEOUT;
     554           9 :         rc = sr_do_ioctl(cd, &cgc);
     555             : 
     556           1 :         return rc;
     557             : }
     558             : 
     559             : /*
     560             :  * read a sector in raw mode to check the sector format
     561             :  * ret: 1 == mode2 (XA), 0 == mode1, <0 == error 
     562             :  */
     563             : 
     564             : int sr_is_xa(Scsi_CD *cd)
     565             : {
     566           1 :         unsigned char *raw_sector;
     567           1 :         int is_xa;
     568           1 : 
     569           3 :         if (!xa_test)
     570           1 :                 return 0;
     571             : 
     572           9 :         raw_sector = kmalloc(2048, GFP_KERNEL | SR_GFP_DMA(cd));
     573           2 :         if (!raw_sector)
     574           1 :                 return -ENOMEM;
     575           7 :         if (0 == sr_read_sector(cd, cd->ms_offset + 16,
     576             :                                 CD_FRAMESIZE_RAW1, raw_sector)) {
     577           1 :                 is_xa = (raw_sector[3] == 0x02) ? 1 : 0;
     578             :         } else {
     579             :                 /* read a raw sector failed for some reason. */
     580           1 :                 is_xa = -1;
     581             :         }
     582           1 :         kfree(raw_sector);
     583             : #ifdef DEBUG
     584             :         printk("%s: sr_is_xa: %d\n", cd->cdi.name, is_xa);
     585             : #endif
     586           1 :         return is_xa;
     587             : }

Generated by: LCOV version 1.10