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