df3df0041eb61b8b0050703bbeb5585500bbc8fd
[linux-2.6.git] / drivers / ide / ide-cd_ioctl.c
1 /*
2  * cdrom.c IOCTLs handling for ide-cd driver.
3  *
4  * Copyright (C) 1994-1996  Scott Snyder <snyder@fnald0.fnal.gov>
5  * Copyright (C) 1996-1998  Erik Andersen <andersee@debian.org>
6  * Copyright (C) 1998-2000  Jens Axboe <axboe@suse.de>
7  */
8
9 #include <linux/kernel.h>
10 #include <linux/cdrom.h>
11 #include <linux/ide.h>
12 #include <scsi/scsi.h>
13
14 #include "ide-cd.h"
15
16 /****************************************************************************
17  * Other driver requests (open, close, check media change).
18  */
19 int ide_cdrom_open_real(struct cdrom_device_info *cdi, int purpose)
20 {
21         return 0;
22 }
23
24 /*
25  * Close down the device.  Invalidate all cached blocks.
26  */
27 void ide_cdrom_release_real(struct cdrom_device_info *cdi)
28 {
29         ide_drive_t *drive = cdi->handle;
30
31         if (!cdi->use_count)
32                 drive->atapi_flags &= ~IDE_AFLAG_TOC_VALID;
33 }
34
35 /*
36  * add logic to try GET_EVENT command first to check for media and tray
37  * status. this should be supported by newer cd-r/w and all DVD etc
38  * drives
39  */
40 int ide_cdrom_drive_status(struct cdrom_device_info *cdi, int slot_nr)
41 {
42         ide_drive_t *drive = cdi->handle;
43         struct media_event_desc med;
44         struct request_sense sense;
45         int stat;
46
47         if (slot_nr != CDSL_CURRENT)
48                 return -EINVAL;
49
50         stat = cdrom_check_status(drive, &sense);
51         if (!stat || sense.sense_key == UNIT_ATTENTION)
52                 return CDS_DISC_OK;
53
54         if (!cdrom_get_media_event(cdi, &med)) {
55                 if (med.media_present)
56                         return CDS_DISC_OK;
57                 else if (med.door_open)
58                         return CDS_TRAY_OPEN;
59                 else
60                         return CDS_NO_DISC;
61         }
62
63         if (sense.sense_key == NOT_READY && sense.asc == 0x04
64                         && sense.ascq == 0x04)
65                 return CDS_DISC_OK;
66
67         /*
68          * If not using Mt Fuji extended media tray reports,
69          * just return TRAY_OPEN since ATAPI doesn't provide
70          * any other way to detect this...
71          */
72         if (sense.sense_key == NOT_READY) {
73                 if (sense.asc == 0x3a && sense.ascq == 1)
74                         return CDS_NO_DISC;
75                 else
76                         return CDS_TRAY_OPEN;
77         }
78         return CDS_DRIVE_NOT_READY;
79 }
80
81 int ide_cdrom_check_media_change_real(struct cdrom_device_info *cdi,
82                                        int slot_nr)
83 {
84         ide_drive_t *drive = cdi->handle;
85         int retval;
86
87         if (slot_nr == CDSL_CURRENT) {
88                 (void) cdrom_check_status(drive, NULL);
89                 retval = (drive->dev_flags & IDE_DFLAG_MEDIA_CHANGED) ? 1 : 0;
90                 drive->dev_flags &= ~IDE_DFLAG_MEDIA_CHANGED;
91                 return retval;
92         } else {
93                 return -EINVAL;
94         }
95 }
96
97 /* Eject the disk if EJECTFLAG is 0.
98    If EJECTFLAG is 1, try to reload the disk. */
99 static
100 int cdrom_eject(ide_drive_t *drive, int ejectflag,
101                 struct request_sense *sense)
102 {
103         struct cdrom_info *cd = drive->driver_data;
104         struct cdrom_device_info *cdi = &cd->devinfo;
105         char loej = 0x02;
106         unsigned char cmd[BLK_MAX_CDB];
107
108         if ((drive->atapi_flags & IDE_AFLAG_NO_EJECT) && !ejectflag)
109                 return -EDRIVE_CANT_DO_THIS;
110
111         /* reload fails on some drives, if the tray is locked */
112         if ((drive->atapi_flags & IDE_AFLAG_DOOR_LOCKED) && ejectflag)
113                 return 0;
114
115         /* only tell drive to close tray if open, if it can do that */
116         if (ejectflag && (cdi->mask & CDC_CLOSE_TRAY))
117                 loej = 0;
118
119         memset(cmd, 0, BLK_MAX_CDB);
120
121         cmd[0] = GPCMD_START_STOP_UNIT;
122         cmd[4] = loej | (ejectflag != 0);
123
124         return ide_cd_queue_pc(drive, cmd, 0, NULL, NULL, sense, 0, 0);
125 }
126
127 /* Lock the door if LOCKFLAG is nonzero; unlock it otherwise. */
128 static
129 int ide_cd_lockdoor(ide_drive_t *drive, int lockflag,
130                     struct request_sense *sense)
131 {
132         struct request_sense my_sense;
133         int stat;
134
135         if (sense == NULL)
136                 sense = &my_sense;
137
138         /* If the drive cannot lock the door, just pretend. */
139         if ((drive->dev_flags & IDE_DFLAG_DOORLOCKING) == 0) {
140                 stat = 0;
141         } else {
142                 unsigned char cmd[BLK_MAX_CDB];
143
144                 memset(cmd, 0, BLK_MAX_CDB);
145
146                 cmd[0] = GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL;
147                 cmd[4] = lockflag ? 1 : 0;
148
149                 stat = ide_cd_queue_pc(drive, cmd, 0, NULL, NULL,
150                                        sense, 0, 0);
151         }
152
153         /* If we got an illegal field error, the drive
154            probably cannot lock the door. */
155         if (stat != 0 &&
156             sense->sense_key == ILLEGAL_REQUEST &&
157             (sense->asc == 0x24 || sense->asc == 0x20)) {
158                 printk(KERN_ERR "%s: door locking not supported\n",
159                         drive->name);
160                 drive->dev_flags &= ~IDE_DFLAG_DOORLOCKING;
161                 stat = 0;
162         }
163
164         /* no medium, that's alright. */
165         if (stat != 0 && sense->sense_key == NOT_READY && sense->asc == 0x3a)
166                 stat = 0;
167
168         if (stat == 0) {
169                 if (lockflag)
170                         drive->atapi_flags |= IDE_AFLAG_DOOR_LOCKED;
171                 else
172                         drive->atapi_flags &= ~IDE_AFLAG_DOOR_LOCKED;
173         }
174
175         return stat;
176 }
177
178 int ide_cdrom_tray_move(struct cdrom_device_info *cdi, int position)
179 {
180         ide_drive_t *drive = cdi->handle;
181         struct request_sense sense;
182
183         if (position) {
184                 int stat = ide_cd_lockdoor(drive, 0, &sense);
185
186                 if (stat)
187                         return stat;
188         }
189
190         return cdrom_eject(drive, !position, &sense);
191 }
192
193 int ide_cdrom_lock_door(struct cdrom_device_info *cdi, int lock)
194 {
195         ide_drive_t *drive = cdi->handle;
196
197         return ide_cd_lockdoor(drive, lock, NULL);
198 }
199
200 /*
201  * ATAPI devices are free to select the speed you request or any slower
202  * rate. :-(  Requesting too fast a speed will _not_ produce an error.
203  */
204 int ide_cdrom_select_speed(struct cdrom_device_info *cdi, int speed)
205 {
206         ide_drive_t *drive = cdi->handle;
207         struct cdrom_info *cd = drive->driver_data;
208         struct request_sense sense;
209         u8 buf[ATAPI_CAPABILITIES_PAGE_SIZE];
210         int stat;
211         unsigned char cmd[BLK_MAX_CDB];
212
213         if (speed == 0)
214                 speed = 0xffff; /* set to max */
215         else
216                 speed *= 177;   /* Nx to kbytes/s */
217
218         memset(cmd, 0, BLK_MAX_CDB);
219
220         cmd[0] = GPCMD_SET_SPEED;
221         /* Read Drive speed in kbytes/second MSB/LSB */
222         cmd[2] = (speed >> 8) & 0xff;
223         cmd[3] = speed & 0xff;
224         if ((cdi->mask & (CDC_CD_R | CDC_CD_RW | CDC_DVD_R)) !=
225             (CDC_CD_R | CDC_CD_RW | CDC_DVD_R)) {
226                 /* Write Drive speed in kbytes/second MSB/LSB */
227                 cmd[4] = (speed >> 8) & 0xff;
228                 cmd[5] = speed & 0xff;
229         }
230
231         stat = ide_cd_queue_pc(drive, cmd, 0, NULL, NULL, &sense, 0, 0);
232
233         if (!ide_cdrom_get_capabilities(drive, buf)) {
234                 ide_cdrom_update_speed(drive, buf);
235                 cdi->speed = cd->current_speed;
236         }
237
238         return 0;
239 }
240
241 int ide_cdrom_get_last_session(struct cdrom_device_info *cdi,
242                                struct cdrom_multisession *ms_info)
243 {
244         struct atapi_toc *toc;
245         ide_drive_t *drive = cdi->handle;
246         struct cdrom_info *info = drive->driver_data;
247         struct request_sense sense;
248         int ret;
249
250         if ((drive->atapi_flags & IDE_AFLAG_TOC_VALID) == 0 || !info->toc) {
251                 ret = ide_cd_read_toc(drive, &sense);
252                 if (ret)
253                         return ret;
254         }
255
256         toc = info->toc;
257         ms_info->addr.lba = toc->last_session_lba;
258         ms_info->xa_flag = toc->xa_flag;
259
260         return 0;
261 }
262
263 int ide_cdrom_get_mcn(struct cdrom_device_info *cdi,
264                       struct cdrom_mcn *mcn_info)
265 {
266         ide_drive_t *drive = cdi->handle;
267         int stat, mcnlen;
268         char buf[24];
269         unsigned char cmd[BLK_MAX_CDB];
270         unsigned len = sizeof(buf);
271
272         memset(cmd, 0, BLK_MAX_CDB);
273
274         cmd[0] = GPCMD_READ_SUBCHANNEL;
275         cmd[1] = 2;             /* MSF addressing */
276         cmd[2] = 0x40;  /* request subQ data */
277         cmd[3] = 2;             /* format */
278         cmd[8] = len;
279
280         stat = ide_cd_queue_pc(drive, cmd, 0, buf, &len, NULL, 0, 0);
281         if (stat)
282                 return stat;
283
284         mcnlen = sizeof(mcn_info->medium_catalog_number) - 1;
285         memcpy(mcn_info->medium_catalog_number, buf + 9, mcnlen);
286         mcn_info->medium_catalog_number[mcnlen] = '\0';
287
288         return 0;
289 }
290
291 int ide_cdrom_reset(struct cdrom_device_info *cdi)
292 {
293         ide_drive_t *drive = cdi->handle;
294         struct cdrom_info *cd = drive->driver_data;
295         struct request_sense sense;
296         struct request *rq;
297         int ret;
298
299         rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
300         rq->cmd_type = REQ_TYPE_SPECIAL;
301         rq->cmd_flags = REQ_QUIET;
302         ret = blk_execute_rq(drive->queue, cd->disk, rq, 0);
303         blk_put_request(rq);
304         /*
305          * A reset will unlock the door. If it was previously locked,
306          * lock it again.
307          */
308         if (drive->atapi_flags & IDE_AFLAG_DOOR_LOCKED)
309                 (void)ide_cd_lockdoor(drive, 1, &sense);
310
311         return ret;
312 }
313
314 static int ide_cd_get_toc_entry(ide_drive_t *drive, int track,
315                                 struct atapi_toc_entry **ent)
316 {
317         struct cdrom_info *info = drive->driver_data;
318         struct atapi_toc *toc = info->toc;
319         int ntracks;
320
321         /*
322          * don't serve cached data, if the toc isn't valid
323          */
324         if ((drive->atapi_flags & IDE_AFLAG_TOC_VALID) == 0)
325                 return -EINVAL;
326
327         /* Check validity of requested track number. */
328         ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
329
330         if (toc->hdr.first_track == CDROM_LEADOUT)
331                 ntracks = 0;
332
333         if (track == CDROM_LEADOUT)
334                 *ent = &toc->ent[ntracks];
335         else if (track < toc->hdr.first_track || track > toc->hdr.last_track)
336                 return -EINVAL;
337         else
338                 *ent = &toc->ent[track - toc->hdr.first_track];
339
340         return 0;
341 }
342
343 static int ide_cd_fake_play_trkind(ide_drive_t *drive, void *arg)
344 {
345         struct cdrom_ti *ti = arg;
346         struct atapi_toc_entry *first_toc, *last_toc;
347         unsigned long lba_start, lba_end;
348         int stat;
349         struct request_sense sense;
350         unsigned char cmd[BLK_MAX_CDB];
351
352         stat = ide_cd_get_toc_entry(drive, ti->cdti_trk0, &first_toc);
353         if (stat)
354                 return stat;
355
356         stat = ide_cd_get_toc_entry(drive, ti->cdti_trk1, &last_toc);
357         if (stat)
358                 return stat;
359
360         if (ti->cdti_trk1 != CDROM_LEADOUT)
361                 ++last_toc;
362         lba_start = first_toc->addr.lba;
363         lba_end   = last_toc->addr.lba;
364
365         if (lba_end <= lba_start)
366                 return -EINVAL;
367
368         memset(cmd, 0, BLK_MAX_CDB);
369
370         cmd[0] = GPCMD_PLAY_AUDIO_MSF;
371         lba_to_msf(lba_start,   &cmd[3], &cmd[4], &cmd[5]);
372         lba_to_msf(lba_end - 1, &cmd[6], &cmd[7], &cmd[8]);
373
374         return ide_cd_queue_pc(drive, cmd, 0, NULL, NULL, &sense, 0, 0);
375 }
376
377 static int ide_cd_read_tochdr(ide_drive_t *drive, void *arg)
378 {
379         struct cdrom_info *cd = drive->driver_data;
380         struct cdrom_tochdr *tochdr = arg;
381         struct atapi_toc *toc;
382         int stat;
383
384         /* Make sure our saved TOC is valid. */
385         stat = ide_cd_read_toc(drive, NULL);
386         if (stat)
387                 return stat;
388
389         toc = cd->toc;
390         tochdr->cdth_trk0 = toc->hdr.first_track;
391         tochdr->cdth_trk1 = toc->hdr.last_track;
392
393         return 0;
394 }
395
396 static int ide_cd_read_tocentry(ide_drive_t *drive, void *arg)
397 {
398         struct cdrom_tocentry *tocentry = arg;
399         struct atapi_toc_entry *toce;
400         int stat;
401
402         stat = ide_cd_get_toc_entry(drive, tocentry->cdte_track, &toce);
403         if (stat)
404                 return stat;
405
406         tocentry->cdte_ctrl = toce->control;
407         tocentry->cdte_adr  = toce->adr;
408         if (tocentry->cdte_format == CDROM_MSF) {
409                 lba_to_msf(toce->addr.lba,
410                            &tocentry->cdte_addr.msf.minute,
411                            &tocentry->cdte_addr.msf.second,
412                            &tocentry->cdte_addr.msf.frame);
413         } else
414                 tocentry->cdte_addr.lba = toce->addr.lba;
415
416         return 0;
417 }
418
419 int ide_cdrom_audio_ioctl(struct cdrom_device_info *cdi,
420                           unsigned int cmd, void *arg)
421 {
422         ide_drive_t *drive = cdi->handle;
423
424         switch (cmd) {
425         /*
426          * emulate PLAY_AUDIO_TI command with PLAY_AUDIO_10, since
427          * atapi doesn't support it
428          */
429         case CDROMPLAYTRKIND:
430                 return ide_cd_fake_play_trkind(drive, arg);
431         case CDROMREADTOCHDR:
432                 return ide_cd_read_tochdr(drive, arg);
433         case CDROMREADTOCENTRY:
434                 return ide_cd_read_tocentry(drive, arg);
435         default:
436                 return -EINVAL;
437         }
438 }
439
440 /* the generic packet interface to cdrom.c */
441 int ide_cdrom_packet(struct cdrom_device_info *cdi,
442                             struct packet_command *cgc)
443 {
444         ide_drive_t *drive = cdi->handle;
445         unsigned int flags = 0;
446         unsigned len = cgc->buflen;
447
448         if (cgc->timeout <= 0)
449                 cgc->timeout = ATAPI_WAIT_PC;
450
451         /* here we queue the commands from the uniform CD-ROM
452            layer. the packet must be complete, as we do not
453            touch it at all. */
454
455         if (cgc->data_direction == CGC_DATA_WRITE)
456                 flags |= REQ_RW;
457
458         if (cgc->sense)
459                 memset(cgc->sense, 0, sizeof(struct request_sense));
460
461         if (cgc->quiet)
462                 flags |= REQ_QUIET;
463
464         cgc->stat = ide_cd_queue_pc(drive, cgc->cmd,
465                                     cgc->data_direction == CGC_DATA_WRITE,
466                                     cgc->buffer, &len,
467                                     cgc->sense, cgc->timeout, flags);
468         if (!cgc->stat)
469                 cgc->buflen -= len;
470         return cgc->stat;
471 }