blob: eb2181a6a11cbe9dfd825daae8c03a73aa85fc19 [file] [log] [blame]
Bartlomiej Zolnierkiewicz594c16d2008-07-15 21:21:58 +02001/*
2 * ATAPI support.
3 */
4
5#include <linux/kernel.h>
Borislav Petkov4cad0852009-01-02 16:12:53 +01006#include <linux/cdrom.h>
Bartlomiej Zolnierkiewicz594c16d2008-07-15 21:21:58 +02007#include <linux/delay.h>
8#include <linux/ide.h>
Geert Uytterhoeven479edf02009-03-31 20:14:57 +02009#include <linux/scatterlist.h>
10
Bartlomiej Zolnierkiewicz646c0cb2008-07-15 21:22:03 +020011#include <scsi/scsi.h>
12
Borislav Petkov103f7032009-04-26 10:39:07 +020013#define DRV_NAME "ide-atapi"
14#define PFX DRV_NAME ": "
15
Bartlomiej Zolnierkiewicz646c0cb2008-07-15 21:22:03 +020016#ifdef DEBUG
17#define debug_log(fmt, args...) \
18 printk(KERN_INFO "ide: " fmt, ## args)
19#else
20#define debug_log(fmt, args...) do {} while (0)
21#endif
22
Borislav Petkov8c662852009-01-02 16:12:54 +010023#define ATAPI_MIN_CDB_BYTES 12
24
Borislav Petkov991cb262009-01-02 16:12:52 +010025static inline int dev_is_idecd(ide_drive_t *drive)
26{
Borislav Petkov53174642009-01-02 16:12:54 +010027 return drive->media == ide_cdrom || drive->media == ide_optical;
Borislav Petkov991cb262009-01-02 16:12:52 +010028}
29
Bartlomiej Zolnierkiewicz51509ee2008-10-10 22:39:34 +020030/*
31 * Check whether we can support a device,
32 * based on the ATAPI IDENTIFY command results.
33 */
34int ide_check_atapi_device(ide_drive_t *drive, const char *s)
35{
36 u16 *id = drive->id;
37 u8 gcw[2], protocol, device_type, removable, drq_type, packet_size;
38
39 *((u16 *)&gcw) = id[ATA_ID_CONFIG];
40
41 protocol = (gcw[1] & 0xC0) >> 6;
42 device_type = gcw[1] & 0x1F;
43 removable = (gcw[0] & 0x80) >> 7;
44 drq_type = (gcw[0] & 0x60) >> 5;
45 packet_size = gcw[0] & 0x03;
46
47#ifdef CONFIG_PPC
48 /* kludge for Apple PowerBook internal zip */
49 if (drive->media == ide_floppy && device_type == 5 &&
50 !strstr((char *)&id[ATA_ID_PROD], "CD-ROM") &&
51 strstr((char *)&id[ATA_ID_PROD], "ZIP"))
52 device_type = 0;
53#endif
54
55 if (protocol != 2)
56 printk(KERN_ERR "%s: %s: protocol (0x%02x) is not ATAPI\n",
57 s, drive->name, protocol);
58 else if ((drive->media == ide_floppy && device_type != 0) ||
59 (drive->media == ide_tape && device_type != 1))
60 printk(KERN_ERR "%s: %s: invalid device type (0x%02x)\n",
61 s, drive->name, device_type);
62 else if (removable == 0)
63 printk(KERN_ERR "%s: %s: the removable flag is not set\n",
64 s, drive->name);
65 else if (drive->media == ide_floppy && drq_type == 3)
66 printk(KERN_ERR "%s: %s: sorry, DRQ type (0x%02x) not "
67 "supported\n", s, drive->name, drq_type);
68 else if (packet_size != 0)
69 printk(KERN_ERR "%s: %s: packet size (0x%02x) is not 12 "
70 "bytes\n", s, drive->name, packet_size);
71 else
72 return 1;
73 return 0;
74}
75EXPORT_SYMBOL_GPL(ide_check_atapi_device);
76
Bartlomiej Zolnierkiewicz7bf74202008-10-10 22:39:37 +020077void ide_init_pc(struct ide_atapi_pc *pc)
78{
79 memset(pc, 0, sizeof(*pc));
Bartlomiej Zolnierkiewicz7bf74202008-10-10 22:39:37 +020080}
81EXPORT_SYMBOL_GPL(ide_init_pc);
82
Bartlomiej Zolnierkiewicz7645c152008-10-10 22:39:37 +020083/*
Bartlomiej Zolnierkiewicz2ac07d92008-10-10 22:39:38 +020084 * Add a special packet command request to the tail of the request queue,
85 * and wait for it to be serviced.
86 */
87int ide_queue_pc_tail(ide_drive_t *drive, struct gendisk *disk,
Borislav Petkovb13345f2009-05-02 10:26:12 +020088 struct ide_atapi_pc *pc, void *buf, unsigned int bufflen)
Bartlomiej Zolnierkiewicz2ac07d92008-10-10 22:39:38 +020089{
90 struct request *rq;
91 int error;
92
93 rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
94 rq->cmd_type = REQ_TYPE_SPECIAL;
Tejun Heoc267cc12009-04-19 07:00:42 +090095 rq->special = (char *)pc;
Borislav Petkov3eb76c12009-03-13 21:16:12 +010096
Borislav Petkovb13345f2009-05-02 10:26:12 +020097 if (buf && bufflen) {
98 error = blk_rq_map_kern(drive->queue, rq, buf, bufflen,
Tejun Heo5c4be572009-04-19 07:00:42 +090099 GFP_NOIO);
100 if (error)
101 goto put_req;
Borislav Petkov3eb76c12009-03-13 21:16:12 +0100102 }
103
Bartlomiej Zolnierkiewicz2ac07d92008-10-10 22:39:38 +0200104 memcpy(rq->cmd, pc->c, 12);
105 if (drive->media == ide_tape)
106 rq->cmd[13] = REQ_IDETAPE_PC1;
107 error = blk_execute_rq(drive->queue, disk, rq, 0);
Tejun Heo5c4be572009-04-19 07:00:42 +0900108put_req:
Bartlomiej Zolnierkiewicz2ac07d92008-10-10 22:39:38 +0200109 blk_put_request(rq);
Bartlomiej Zolnierkiewicz2ac07d92008-10-10 22:39:38 +0200110 return error;
111}
112EXPORT_SYMBOL_GPL(ide_queue_pc_tail);
113
Bartlomiej Zolnierkiewiczde699ad2008-10-10 22:39:39 +0200114int ide_do_test_unit_ready(ide_drive_t *drive, struct gendisk *disk)
115{
116 struct ide_atapi_pc pc;
117
118 ide_init_pc(&pc);
119 pc.c[0] = TEST_UNIT_READY;
120
Borislav Petkovb13345f2009-05-02 10:26:12 +0200121 return ide_queue_pc_tail(drive, disk, &pc, NULL, 0);
Bartlomiej Zolnierkiewiczde699ad2008-10-10 22:39:39 +0200122}
123EXPORT_SYMBOL_GPL(ide_do_test_unit_ready);
124
Bartlomiej Zolnierkiewicz0c8a6c72008-10-10 22:39:39 +0200125int ide_do_start_stop(ide_drive_t *drive, struct gendisk *disk, int start)
126{
127 struct ide_atapi_pc pc;
128
129 ide_init_pc(&pc);
130 pc.c[0] = START_STOP;
131 pc.c[4] = start;
132
133 if (drive->media == ide_tape)
134 pc.flags |= PC_FLAG_WAIT_FOR_DSC;
135
Borislav Petkovb13345f2009-05-02 10:26:12 +0200136 return ide_queue_pc_tail(drive, disk, &pc, NULL, 0);
Bartlomiej Zolnierkiewicz0c8a6c72008-10-10 22:39:39 +0200137}
138EXPORT_SYMBOL_GPL(ide_do_start_stop);
139
Bartlomiej Zolnierkiewicz05780422008-10-10 22:39:38 +0200140int ide_set_media_lock(ide_drive_t *drive, struct gendisk *disk, int on)
141{
142 struct ide_atapi_pc pc;
143
Bartlomiej Zolnierkiewicz42619d32008-10-17 18:09:11 +0200144 if ((drive->dev_flags & IDE_DFLAG_DOORLOCKING) == 0)
Bartlomiej Zolnierkiewicz05780422008-10-10 22:39:38 +0200145 return 0;
146
147 ide_init_pc(&pc);
148 pc.c[0] = ALLOW_MEDIUM_REMOVAL;
149 pc.c[4] = on;
150
Borislav Petkovb13345f2009-05-02 10:26:12 +0200151 return ide_queue_pc_tail(drive, disk, &pc, NULL, 0);
Bartlomiej Zolnierkiewicz05780422008-10-10 22:39:38 +0200152}
153EXPORT_SYMBOL_GPL(ide_set_media_lock);
154
Bartlomiej Zolnierkiewicz6b0da282008-10-13 21:39:32 +0200155void ide_create_request_sense_cmd(ide_drive_t *drive, struct ide_atapi_pc *pc)
156{
157 ide_init_pc(pc);
158 pc->c[0] = REQUEST_SENSE;
159 if (drive->media == ide_floppy) {
160 pc->c[4] = 255;
161 pc->req_xfer = 18;
162 } else {
163 pc->c[4] = 20;
164 pc->req_xfer = 20;
165 }
166}
167EXPORT_SYMBOL_GPL(ide_create_request_sense_cmd);
168
Borislav Petkova1df5162009-04-19 07:00:42 +0900169void ide_prep_sense(ide_drive_t *drive, struct request *rq)
170{
171 struct request_sense *sense = &drive->sense_data;
172 struct request *sense_rq = &drive->sense_rq;
173 unsigned int cmd_len, sense_len;
Tejun Heo5c4be572009-04-19 07:00:42 +0900174 int err;
Borislav Petkova1df5162009-04-19 07:00:42 +0900175
Borislav Petkova1df5162009-04-19 07:00:42 +0900176 switch (drive->media) {
177 case ide_floppy:
178 cmd_len = 255;
179 sense_len = 18;
180 break;
181 case ide_tape:
182 cmd_len = 20;
183 sense_len = 20;
184 break;
185 default:
186 cmd_len = 18;
187 sense_len = 18;
188 }
189
190 BUG_ON(sense_len > sizeof(*sense));
191
192 if (blk_sense_request(rq) || drive->sense_rq_armed)
193 return;
194
195 memset(sense, 0, sizeof(*sense));
196
197 blk_rq_init(rq->q, sense_rq);
Borislav Petkova1df5162009-04-19 07:00:42 +0900198
Tejun Heo5c4be572009-04-19 07:00:42 +0900199 err = blk_rq_map_kern(drive->queue, sense_rq, sense, sense_len,
200 GFP_NOIO);
201 if (unlikely(err)) {
202 if (printk_ratelimit())
Borislav Petkov103f7032009-04-26 10:39:07 +0200203 printk(KERN_WARNING PFX "%s: failed to map sense "
204 "buffer\n", drive->name);
Tejun Heo5c4be572009-04-19 07:00:42 +0900205 return;
206 }
207
208 sense_rq->rq_disk = rq->rq_disk;
Borislav Petkova1df5162009-04-19 07:00:42 +0900209 sense_rq->cmd[0] = GPCMD_REQUEST_SENSE;
210 sense_rq->cmd[4] = cmd_len;
Borislav Petkova1df5162009-04-19 07:00:42 +0900211 sense_rq->cmd_type = REQ_TYPE_SENSE;
212 sense_rq->cmd_flags |= REQ_PREEMPT;
213
214 if (drive->media == ide_tape)
215 sense_rq->cmd[13] = REQ_IDETAPE_PC1;
216
217 drive->sense_rq_armed = true;
218}
219EXPORT_SYMBOL_GPL(ide_prep_sense);
220
Tejun Heo5c4be572009-04-19 07:00:42 +0900221int ide_queue_sense_rq(ide_drive_t *drive, void *special)
Borislav Petkova1df5162009-04-19 07:00:42 +0900222{
Tejun Heo5c4be572009-04-19 07:00:42 +0900223 /* deferred failure from ide_prep_sense() */
224 if (!drive->sense_rq_armed) {
Borislav Petkov103f7032009-04-26 10:39:07 +0200225 printk(KERN_WARNING PFX "%s: error queuing a sense request\n",
Tejun Heo5c4be572009-04-19 07:00:42 +0900226 drive->name);
227 return -ENOMEM;
228 }
Borislav Petkova1df5162009-04-19 07:00:42 +0900229
230 drive->sense_rq.special = special;
231 drive->sense_rq_armed = false;
232
233 drive->hwif->rq = NULL;
234
235 elv_add_request(drive->queue, &drive->sense_rq,
236 ELEVATOR_INSERT_FRONT, 0);
Tejun Heo5c4be572009-04-19 07:00:42 +0900237 return 0;
Borislav Petkova1df5162009-04-19 07:00:42 +0900238}
239EXPORT_SYMBOL_GPL(ide_queue_sense_rq);
240
Bartlomiej Zolnierkiewicz6b0da282008-10-13 21:39:32 +0200241/*
242 * Called when an error was detected during the last packet command.
Borislav Petkov6b544fc2009-04-19 07:00:42 +0900243 * We queue a request sense packet command at the head of the request
244 * queue.
Bartlomiej Zolnierkiewicz6b0da282008-10-13 21:39:32 +0200245 */
Borislav Petkov6b544fc2009-04-19 07:00:42 +0900246void ide_retry_pc(ide_drive_t *drive)
Bartlomiej Zolnierkiewicz6b0da282008-10-13 21:39:32 +0200247{
Tejun Heo8f6205c2009-05-08 11:53:59 +0900248 struct request *failed_rq = drive->hwif->rq;
Borislav Petkov6b544fc2009-04-19 07:00:42 +0900249 struct request *sense_rq = &drive->sense_rq;
Bartlomiej Zolnierkiewicz6b0da282008-10-13 21:39:32 +0200250 struct ide_atapi_pc *pc = &drive->request_sense_pc;
251
252 (void)ide_read_error(drive);
Borislav Petkov6b544fc2009-04-19 07:00:42 +0900253
254 /* init pc from sense_rq */
255 ide_init_pc(pc);
256 memcpy(pc->c, sense_rq->cmd, 12);
Borislav Petkov6b544fc2009-04-19 07:00:42 +0900257
Bartlomiej Zolnierkiewicz6b0da282008-10-13 21:39:32 +0200258 if (drive->media == ide_tape)
Borislav Petkov626542c2009-06-07 15:37:05 +0200259 drive->atapi_flags |= IDE_AFLAG_IGNORE_DSC;
Borislav Petkov6b544fc2009-04-19 07:00:42 +0900260
Tejun Heo8f6205c2009-05-08 11:53:59 +0900261 /*
262 * Push back the failed request and put request sense on top
263 * of it. The failed command will be retried after sense data
264 * is acquired.
265 */
266 blk_requeue_request(failed_rq->q, failed_rq);
267 drive->hwif->rq = NULL;
268 if (ide_queue_sense_rq(drive, pc)) {
Tejun Heo9934c8c2009-05-08 11:54:16 +0900269 blk_start_request(failed_rq);
Tejun Heo8f6205c2009-05-08 11:53:59 +0900270 ide_complete_rq(drive, -EIO, blk_rq_bytes(failed_rq));
271 }
Bartlomiej Zolnierkiewicz6b0da282008-10-13 21:39:32 +0200272}
273EXPORT_SYMBOL_GPL(ide_retry_pc);
274
Borislav Petkov4cad0852009-01-02 16:12:53 +0100275int ide_cd_expiry(ide_drive_t *drive)
276{
Bartlomiej Zolnierkiewiczb65fac32009-01-06 17:20:50 +0100277 struct request *rq = drive->hwif->rq;
Borislav Petkov4cad0852009-01-02 16:12:53 +0100278 unsigned long wait = 0;
279
280 debug_log("%s: rq->cmd[0]: 0x%x\n", __func__, rq->cmd[0]);
281
282 /*
283 * Some commands are *slow* and normally take a long time to complete.
284 * Usually we can use the ATAPI "disconnect" to bypass this, but not all
285 * commands/drives support that. Let ide_timer_expiry keep polling us
286 * for these.
287 */
288 switch (rq->cmd[0]) {
289 case GPCMD_BLANK:
290 case GPCMD_FORMAT_UNIT:
291 case GPCMD_RESERVE_RZONE_TRACK:
292 case GPCMD_CLOSE_TRACK:
293 case GPCMD_FLUSH_CACHE:
294 wait = ATAPI_WAIT_PC;
295 break;
296 default:
297 if (!(rq->cmd_flags & REQ_QUIET))
Borislav Petkov103f7032009-04-26 10:39:07 +0200298 printk(KERN_INFO PFX "cmd 0x%x timed out\n",
Borislav Petkov4cad0852009-01-02 16:12:53 +0100299 rq->cmd[0]);
300 wait = 0;
301 break;
302 }
303 return wait;
304}
305EXPORT_SYMBOL_GPL(ide_cd_expiry);
306
Borislav Petkov392de1d2009-01-02 16:12:52 +0100307int ide_cd_get_xferlen(struct request *rq)
308{
309 if (blk_fs_request(rq))
310 return 32768;
311 else if (blk_sense_request(rq) || blk_pc_request(rq) ||
312 rq->cmd_type == REQ_TYPE_ATA_PC)
Tejun Heo34b7d2c2009-05-07 22:24:43 +0900313 return blk_rq_bytes(rq);
Borislav Petkov392de1d2009-01-02 16:12:52 +0100314 else
315 return 0;
316}
317EXPORT_SYMBOL_GPL(ide_cd_get_xferlen);
318
Bartlomiej Zolnierkiewicz0d6a9752009-03-24 23:22:46 +0100319void ide_read_bcount_and_ireason(ide_drive_t *drive, u16 *bcount, u8 *ireason)
320{
Sergei Shtylyov3153c262009-04-08 14:13:03 +0200321 struct ide_taskfile tf;
Bartlomiej Zolnierkiewicz0d6a9752009-03-24 23:22:46 +0100322
Sergei Shtylyov3153c262009-04-08 14:13:03 +0200323 drive->hwif->tp_ops->tf_read(drive, &tf, IDE_VALID_NSECT |
324 IDE_VALID_LBAM | IDE_VALID_LBAH);
Bartlomiej Zolnierkiewicz0d6a9752009-03-24 23:22:46 +0100325
Sergei Shtylyov3153c262009-04-08 14:13:03 +0200326 *bcount = (tf.lbah << 8) | tf.lbam;
327 *ireason = tf.nsect & 3;
Bartlomiej Zolnierkiewicz0d6a9752009-03-24 23:22:46 +0100328}
329EXPORT_SYMBOL_GPL(ide_read_bcount_and_ireason);
330
Bartlomiej Zolnierkiewiczaa5d2de2008-10-13 21:39:32 +0200331/*
Borislav Petkov103f7032009-04-26 10:39:07 +0200332 * Check the contents of the interrupt reason register and attempt to recover if
333 * there are problems.
334 *
335 * Returns:
336 * - 0 if everything's ok
337 * - 1 if the request has to be terminated.
338 */
339int ide_check_ireason(ide_drive_t *drive, struct request *rq, int len,
340 int ireason, int rw)
341{
342 ide_hwif_t *hwif = drive->hwif;
343
344 debug_log("ireason: 0x%x, rw: 0x%x\n", ireason, rw);
345
346 if (ireason == (!rw << 1))
347 return 0;
348 else if (ireason == (rw << 1)) {
349 printk(KERN_ERR PFX "%s: %s: wrong transfer direction!\n",
350 drive->name, __func__);
351
352 if (dev_is_idecd(drive))
353 ide_pad_transfer(drive, rw, len);
354 } else if (!rw && ireason == ATAPI_COD) {
355 if (dev_is_idecd(drive)) {
356 /*
357 * Some drives (ASUS) seem to tell us that status info
358 * is available. Just get it and ignore.
359 */
360 (void)hwif->tp_ops->read_status(hwif);
361 return 0;
362 }
363 } else {
364 if (ireason & ATAPI_COD)
365 printk(KERN_ERR PFX "%s: CoD != 0 in %s\n", drive->name,
366 __func__);
367
368 /* drive wants a command packet, or invalid ireason... */
369 printk(KERN_ERR PFX "%s: %s: bad interrupt reason 0x%02x\n",
370 drive->name, __func__, ireason);
371 }
372
373 if (dev_is_idecd(drive) && rq->cmd_type == REQ_TYPE_ATA_PC)
374 rq->cmd_flags |= REQ_FAILED;
375
376 return 1;
377}
378EXPORT_SYMBOL_GPL(ide_check_ireason);
379
380/*
Bartlomiej Zolnierkiewiczaa5d2de2008-10-13 21:39:32 +0200381 * This is the usual interrupt handler which will be called during a packet
382 * command. We will transfer some of the data (as requested by the drive)
383 * and will re-point interrupt handler to us.
384 */
385static ide_startstop_t ide_pc_intr(ide_drive_t *drive)
Bartlomiej Zolnierkiewicz646c0cb2008-07-15 21:22:03 +0200386{
Bartlomiej Zolnierkiewicz2b9efba2008-10-13 21:39:31 +0200387 struct ide_atapi_pc *pc = drive->pc;
Bartlomiej Zolnierkiewicz646c0cb2008-07-15 21:22:03 +0200388 ide_hwif_t *hwif = drive->hwif;
Bartlomiej Zolnierkiewiczf094d4d2009-03-31 20:15:24 +0200389 struct ide_cmd *cmd = &hwif->cmd;
Bartlomiej Zolnierkiewiczb65fac32009-01-06 17:20:50 +0100390 struct request *rq = hwif->rq;
Bartlomiej Zolnierkiewicz374e0422008-07-23 19:55:56 +0200391 const struct ide_tp_ops *tp_ops = hwif->tp_ops;
Bartlomiej Zolnierkiewiczd93bc452009-03-31 20:15:26 +0200392 unsigned int timeout, done;
Bartlomiej Zolnierkiewicz646c0cb2008-07-15 21:22:03 +0200393 u16 bcount;
Borislav Petkov5d655a02009-01-02 16:12:54 +0100394 u8 stat, ireason, dsc = 0;
Bartlomiej Zolnierkiewiczd93bc452009-03-31 20:15:26 +0200395 u8 write = !!(pc->flags & PC_FLAG_WRITING);
Bartlomiej Zolnierkiewicz646c0cb2008-07-15 21:22:03 +0200396
397 debug_log("Enter %s - interrupt handler\n", __func__);
398
Borislav Petkov5d655a02009-01-02 16:12:54 +0100399 timeout = (drive->media == ide_floppy) ? WAIT_FLOPPY_CMD
400 : WAIT_TAPE_CMD;
Bartlomiej Zolnierkiewicz844b9462008-10-13 21:39:31 +0200401
Bartlomiej Zolnierkiewicz646c0cb2008-07-15 21:22:03 +0200402 /* Clear the interrupt */
Bartlomiej Zolnierkiewicz374e0422008-07-23 19:55:56 +0200403 stat = tp_ops->read_status(hwif);
Bartlomiej Zolnierkiewicz646c0cb2008-07-15 21:22:03 +0200404
405 if (pc->flags & PC_FLAG_DMA_IN_PROGRESS) {
Bartlomiej Zolnierkiewicz88b41322009-03-31 20:15:22 +0200406 int rc;
Bartlomiej Zolnierkiewicz44530112009-03-31 20:15:20 +0200407
Bartlomiej Zolnierkiewicz88b41322009-03-31 20:15:22 +0200408 drive->waiting_for_dma = 0;
409 rc = hwif->dma_ops->dma_end(drive);
Bartlomiej Zolnierkiewiczf094d4d2009-03-31 20:15:24 +0200410 ide_dma_unmap_sg(drive, cmd);
Bartlomiej Zolnierkiewicz44530112009-03-31 20:15:20 +0200411
412 if (rc || (drive->media == ide_tape && (stat & ATA_ERR))) {
Borislav Petkov5d655a02009-01-02 16:12:54 +0100413 if (drive->media == ide_floppy)
Borislav Petkov103f7032009-04-26 10:39:07 +0200414 printk(KERN_ERR PFX "%s: DMA %s error\n",
Bartlomiej Zolnierkiewicz646c0cb2008-07-15 21:22:03 +0200415 drive->name, rq_data_dir(pc->rq)
416 ? "write" : "read");
417 pc->flags |= PC_FLAG_DMA_ERROR;
Tejun Heo6d700382009-04-19 08:46:03 +0900418 } else
Borislav Petkov077e6db2009-05-01 21:21:02 +0200419 rq->resid_len = 0;
Bartlomiej Zolnierkiewicz646c0cb2008-07-15 21:22:03 +0200420 debug_log("%s: DMA finished\n", drive->name);
421 }
422
423 /* No more interrupts */
Bartlomiej Zolnierkiewicz3a7d2482008-10-10 22:39:21 +0200424 if ((stat & ATA_DRQ) == 0) {
Borislav Petkov5b6c9422009-03-31 20:15:34 +0200425 int uptodate, error;
Bartlomiej Zolnierkiewicz03a2faa2009-03-27 12:46:36 +0100426
Bartlomiej Zolnierkiewicz646c0cb2008-07-15 21:22:03 +0200427 debug_log("Packet command completed, %d bytes transferred\n",
Borislav Petkov077e6db2009-05-01 21:21:02 +0200428 blk_rq_bytes(rq));
Bartlomiej Zolnierkiewicz646c0cb2008-07-15 21:22:03 +0200429
430 pc->flags &= ~PC_FLAG_DMA_IN_PROGRESS;
431
432 local_irq_enable_in_hardirq();
433
Borislav Petkov5d655a02009-01-02 16:12:54 +0100434 if (drive->media == ide_tape &&
Bartlomiej Zolnierkiewicz3a7d2482008-10-10 22:39:21 +0200435 (stat & ATA_ERR) && rq->cmd[0] == REQUEST_SENSE)
436 stat &= ~ATA_ERR;
Borislav Petkov8fccf892008-07-23 19:56:01 +0200437
Bartlomiej Zolnierkiewicz3a7d2482008-10-10 22:39:21 +0200438 if ((stat & ATA_ERR) || (pc->flags & PC_FLAG_DMA_ERROR)) {
Bartlomiej Zolnierkiewicz646c0cb2008-07-15 21:22:03 +0200439 /* Error detected */
440 debug_log("%s: I/O error\n", drive->name);
441
Borislav Petkov5d655a02009-01-02 16:12:54 +0100442 if (drive->media != ide_tape)
Bartlomiej Zolnierkiewicz646c0cb2008-07-15 21:22:03 +0200443 pc->rq->errors++;
Bartlomiej Zolnierkiewicz646c0cb2008-07-15 21:22:03 +0200444
Borislav Petkov8fccf892008-07-23 19:56:01 +0200445 if (rq->cmd[0] == REQUEST_SENSE) {
Borislav Petkov103f7032009-04-26 10:39:07 +0200446 printk(KERN_ERR PFX "%s: I/O error in request "
447 "sense command\n", drive->name);
Bartlomiej Zolnierkiewicz646c0cb2008-07-15 21:22:03 +0200448 return ide_do_reset(drive);
449 }
450
Borislav Petkov8fccf892008-07-23 19:56:01 +0200451 debug_log("[cmd %x]: check condition\n", rq->cmd[0]);
Bartlomiej Zolnierkiewicz646c0cb2008-07-15 21:22:03 +0200452
453 /* Retry operation */
Borislav Petkov6b544fc2009-04-19 07:00:42 +0900454 ide_retry_pc(drive);
Borislav Petkov8fccf892008-07-23 19:56:01 +0200455
Bartlomiej Zolnierkiewicz646c0cb2008-07-15 21:22:03 +0200456 /* queued, but not started */
457 return ide_stopped;
458 }
Bartlomiej Zolnierkiewicz646c0cb2008-07-15 21:22:03 +0200459 pc->error = 0;
Bartlomiej Zolnierkiewiczb14c7212008-10-13 21:39:30 +0200460
461 if ((pc->flags & PC_FLAG_WAIT_FOR_DSC) && (stat & ATA_DSC) == 0)
462 dsc = 1;
Borislav Petkov8fccf892008-07-23 19:56:01 +0200463
Tejun Heob3071d12009-04-19 08:46:02 +0900464 /*
465 * ->pc_callback() might change rq->data_len for
466 * residual count, cache total length.
467 */
Tejun Heo21d9c5d2009-04-19 08:46:02 +0900468 done = blk_rq_bytes(rq);
Tejun Heob3071d12009-04-19 08:46:02 +0900469
Bartlomiej Zolnierkiewicz646c0cb2008-07-15 21:22:03 +0200470 /* Command finished - Call the callback function */
Bartlomiej Zolnierkiewicz03a2faa2009-03-27 12:46:36 +0100471 uptodate = drive->pc_callback(drive, dsc);
472
473 if (uptodate == 0)
474 drive->failed_pc = NULL;
475
Bartlomiej Zolnierkiewicz6902a532009-03-27 12:46:43 +0100476 if (blk_special_request(rq)) {
477 rq->errors = 0;
Borislav Petkov5b6c9422009-03-31 20:15:34 +0200478 error = 0;
Bartlomiej Zolnierkiewicz89f78b32009-03-27 12:46:43 +0100479 } else {
Bartlomiej Zolnierkiewicz349d12a2009-03-31 20:15:26 +0200480
Bartlomiej Zolnierkiewicz89f78b32009-03-27 12:46:43 +0100481 if (blk_fs_request(rq) == 0 && uptodate <= 0) {
482 if (rq->errors == 0)
483 rq->errors = -EIO;
484 }
Bartlomiej Zolnierkiewicz349d12a2009-03-31 20:15:26 +0200485
Borislav Petkov5b6c9422009-03-31 20:15:34 +0200486 error = uptodate ? 0 : -EIO;
Bartlomiej Zolnierkiewicz89f78b32009-03-27 12:46:43 +0100487 }
Borislav Petkov8fccf892008-07-23 19:56:01 +0200488
Tejun Heoc3a4d782009-05-07 22:24:37 +0900489 ide_complete_rq(drive, error, blk_rq_bytes(rq));
Bartlomiej Zolnierkiewicz646c0cb2008-07-15 21:22:03 +0200490 return ide_stopped;
491 }
492
493 if (pc->flags & PC_FLAG_DMA_IN_PROGRESS) {
494 pc->flags &= ~PC_FLAG_DMA_IN_PROGRESS;
Borislav Petkov103f7032009-04-26 10:39:07 +0200495 printk(KERN_ERR PFX "%s: The device wants to issue more "
496 "interrupts in DMA mode\n", drive->name);
Bartlomiej Zolnierkiewicz646c0cb2008-07-15 21:22:03 +0200497 ide_dma_off(drive);
498 return ide_do_reset(drive);
499 }
Bartlomiej Zolnierkiewicz646c0cb2008-07-15 21:22:03 +0200500
Bartlomiej Zolnierkiewicz18236492008-07-23 19:55:54 +0200501 /* Get the number of bytes to transfer on this interrupt. */
502 ide_read_bcount_and_ireason(drive, &bcount, &ireason);
Bartlomiej Zolnierkiewicz646c0cb2008-07-15 21:22:03 +0200503
Borislav Petkov103f7032009-04-26 10:39:07 +0200504 if (ide_check_ireason(drive, rq, bcount, ireason, write))
Bartlomiej Zolnierkiewicz646c0cb2008-07-15 21:22:03 +0200505 return ide_do_reset(drive);
Borislav Petkov8fccf892008-07-23 19:56:01 +0200506
Tejun Heo6d700382009-04-19 08:46:03 +0900507 done = min_t(unsigned int, bcount, cmd->nleft);
508 ide_pio_bytes(drive, cmd, write, done);
Bartlomiej Zolnierkiewicz646c0cb2008-07-15 21:22:03 +0200509
Tejun Heo6d700382009-04-19 08:46:03 +0900510 /* Update transferred byte count */
Borislav Petkov077e6db2009-05-01 21:21:02 +0200511 rq->resid_len -= done;
Bartlomiej Zolnierkiewicz646c0cb2008-07-15 21:22:03 +0200512
Bartlomiej Zolnierkiewiczd93bc452009-03-31 20:15:26 +0200513 bcount -= done;
514
515 if (bcount)
516 ide_pad_transfer(drive, write, bcount);
517
Borislav Petkov077e6db2009-05-01 21:21:02 +0200518 debug_log("[cmd %x] transferred %d bytes, padded %d bytes, resid: %u\n",
519 rq->cmd[0], done, bcount, rq->resid_len);
Bartlomiej Zolnierkiewiczd93bc452009-03-31 20:15:26 +0200520
Bartlomiej Zolnierkiewicz646c0cb2008-07-15 21:22:03 +0200521 /* And set the interrupt handler again */
Bartlomiej Zolnierkiewicz60c0cd02009-03-27 12:46:46 +0100522 ide_set_handler(drive, ide_pc_intr, timeout);
Bartlomiej Zolnierkiewicz646c0cb2008-07-15 21:22:03 +0200523 return ide_started;
524}
Bartlomiej Zolnierkiewicz594c16d2008-07-15 21:21:58 +0200525
Sergei Shtylyov60f85012009-04-08 14:13:01 +0200526static void ide_init_packet_cmd(struct ide_cmd *cmd, u8 valid_tf,
Bartlomiej Zolnierkiewiczb788ee92009-03-27 12:46:46 +0100527 u16 bcount, u8 dma)
Bartlomiej Zolnierkiewicz7a254df2009-03-24 23:22:39 +0100528{
Sergei Shtylyov60f85012009-04-08 14:13:01 +0200529 cmd->protocol = dma ? ATAPI_PROT_DMA : ATAPI_PROT_PIO;
530 cmd->valid.out.tf = IDE_VALID_LBAH | IDE_VALID_LBAM |
531 IDE_VALID_FEATURE | valid_tf;
Bartlomiej Zolnierkiewicz35b5d0b2009-03-27 12:46:47 +0100532 cmd->tf.command = ATA_CMD_PACKET;
Bartlomiej Zolnierkiewiczb788ee92009-03-27 12:46:46 +0100533 cmd->tf.feature = dma; /* Use PIO/DMA */
534 cmd->tf.lbam = bcount & 0xff;
535 cmd->tf.lbah = (bcount >> 8) & 0xff;
Bartlomiej Zolnierkiewicz7a254df2009-03-24 23:22:39 +0100536}
537
Bartlomiej Zolnierkiewicz88a72102008-07-23 19:55:54 +0200538static u8 ide_read_ireason(ide_drive_t *drive)
539{
Sergei Shtylyov3153c262009-04-08 14:13:03 +0200540 struct ide_taskfile tf;
Bartlomiej Zolnierkiewicz88a72102008-07-23 19:55:54 +0200541
Sergei Shtylyov3153c262009-04-08 14:13:03 +0200542 drive->hwif->tp_ops->tf_read(drive, &tf, IDE_VALID_NSECT);
Bartlomiej Zolnierkiewicz88a72102008-07-23 19:55:54 +0200543
Sergei Shtylyov3153c262009-04-08 14:13:03 +0200544 return tf.nsect & 3;
Bartlomiej Zolnierkiewicz88a72102008-07-23 19:55:54 +0200545}
546
Bartlomiej Zolnierkiewicz594c16d2008-07-15 21:21:58 +0200547static u8 ide_wait_ireason(ide_drive_t *drive, u8 ireason)
548{
Bartlomiej Zolnierkiewicz594c16d2008-07-15 21:21:58 +0200549 int retries = 100;
550
Bartlomiej Zolnierkiewicz3a7d2482008-10-10 22:39:21 +0200551 while (retries-- && ((ireason & ATAPI_COD) == 0 ||
552 (ireason & ATAPI_IO))) {
Borislav Petkov103f7032009-04-26 10:39:07 +0200553 printk(KERN_ERR PFX "%s: (IO,CoD != (0,1) while issuing "
Bartlomiej Zolnierkiewicz594c16d2008-07-15 21:21:58 +0200554 "a packet command, retrying\n", drive->name);
555 udelay(100);
Bartlomiej Zolnierkiewicz88a72102008-07-23 19:55:54 +0200556 ireason = ide_read_ireason(drive);
Bartlomiej Zolnierkiewicz594c16d2008-07-15 21:21:58 +0200557 if (retries == 0) {
Borislav Petkov103f7032009-04-26 10:39:07 +0200558 printk(KERN_ERR PFX "%s: (IO,CoD != (0,1) while issuing"
559 " a packet command, ignoring\n",
Bartlomiej Zolnierkiewicz594c16d2008-07-15 21:21:58 +0200560 drive->name);
Bartlomiej Zolnierkiewicz3a7d2482008-10-10 22:39:21 +0200561 ireason |= ATAPI_COD;
562 ireason &= ~ATAPI_IO;
Bartlomiej Zolnierkiewicz594c16d2008-07-15 21:21:58 +0200563 }
564 }
565
566 return ireason;
567}
568
Bartlomiej Zolnierkiewiczbaf08f02008-10-13 21:39:32 +0200569static int ide_delayed_transfer_pc(ide_drive_t *drive)
570{
571 /* Send the actual packet */
572 drive->hwif->tp_ops->output_data(drive, NULL, drive->pc->c, 12);
573
574 /* Timeout for the packet command */
575 return WAIT_FLOPPY_CMD;
576}
577
578static ide_startstop_t ide_transfer_pc(ide_drive_t *drive)
Bartlomiej Zolnierkiewicz594c16d2008-07-15 21:21:58 +0200579{
Borislav Petkovb16aabc2009-01-02 16:12:56 +0100580 struct ide_atapi_pc *uninitialized_var(pc);
Bartlomiej Zolnierkiewicz594c16d2008-07-15 21:21:58 +0200581 ide_hwif_t *hwif = drive->hwif;
Bartlomiej Zolnierkiewiczb65fac32009-01-06 17:20:50 +0100582 struct request *rq = hwif->rq;
Bartlomiej Zolnierkiewiczbaf08f02008-10-13 21:39:32 +0200583 ide_expiry_t *expiry;
584 unsigned int timeout;
Borislav Petkov8c662852009-01-02 16:12:54 +0100585 int cmd_len;
Bartlomiej Zolnierkiewicz594c16d2008-07-15 21:21:58 +0200586 ide_startstop_t startstop;
587 u8 ireason;
588
Bartlomiej Zolnierkiewicz3a7d2482008-10-10 22:39:21 +0200589 if (ide_wait_stat(&startstop, drive, ATA_DRQ, ATA_BUSY, WAIT_READY)) {
Borislav Petkov103f7032009-04-26 10:39:07 +0200590 printk(KERN_ERR PFX "%s: Strange, packet command initiated yet "
Bartlomiej Zolnierkiewicz594c16d2008-07-15 21:21:58 +0200591 "DRQ isn't asserted\n", drive->name);
592 return startstop;
593 }
594
Borislav Petkov5f258432009-01-02 16:12:53 +0100595 if (drive->atapi_flags & IDE_AFLAG_DRQ_INTERRUPT) {
596 if (drive->dma)
597 drive->waiting_for_dma = 1;
598 }
599
Borislav Petkov8c662852009-01-02 16:12:54 +0100600 if (dev_is_idecd(drive)) {
601 /* ATAPI commands get padded out to 12 bytes minimum */
602 cmd_len = COMMAND_SIZE(rq->cmd[0]);
603 if (cmd_len < ATAPI_MIN_CDB_BYTES)
604 cmd_len = ATAPI_MIN_CDB_BYTES;
Borislav Petkovdef860d2009-01-02 16:12:55 +0100605
606 timeout = rq->timeout;
607 expiry = ide_cd_expiry;
608 } else {
Borislav Petkovb16aabc2009-01-02 16:12:56 +0100609 pc = drive->pc;
610
Borislav Petkov8c662852009-01-02 16:12:54 +0100611 cmd_len = ATAPI_MIN_CDB_BYTES;
612
Borislav Petkovdef860d2009-01-02 16:12:55 +0100613 /*
614 * If necessary schedule the packet transfer to occur 'timeout'
Martin Olsson19af5cd2009-04-23 11:37:37 +0200615 * milliseconds later in ide_delayed_transfer_pc() after the
Borislav Petkovdef860d2009-01-02 16:12:55 +0100616 * device says it's ready for a packet.
617 */
618 if (drive->atapi_flags & IDE_AFLAG_ZIP_DRIVE) {
619 timeout = drive->pc_delay;
620 expiry = &ide_delayed_transfer_pc;
621 } else {
622 timeout = (drive->media == ide_floppy) ? WAIT_FLOPPY_CMD
623 : WAIT_TAPE_CMD;
624 expiry = NULL;
625 }
Borislav Petkov06cc2772009-01-02 16:12:56 +0100626
627 ireason = ide_read_ireason(drive);
628 if (drive->media == ide_tape)
629 ireason = ide_wait_ireason(drive, ireason);
630
631 if ((ireason & ATAPI_COD) == 0 || (ireason & ATAPI_IO)) {
Borislav Petkov103f7032009-04-26 10:39:07 +0200632 printk(KERN_ERR PFX "%s: (IO,CoD) != (0,1) while "
633 "issuing a packet command\n", drive->name);
Borislav Petkov06cc2772009-01-02 16:12:56 +0100634
635 return ide_do_reset(drive);
636 }
Bartlomiej Zolnierkiewiczbaf08f02008-10-13 21:39:32 +0200637 }
638
Bartlomiej Zolnierkiewicz60c0cd02009-03-27 12:46:46 +0100639 hwif->expiry = expiry;
640
Bartlomiej Zolnierkiewicz594c16d2008-07-15 21:21:58 +0200641 /* Set the interrupt routine */
Borislav Petkovd6251d42009-01-06 17:20:58 +0100642 ide_set_handler(drive,
643 (dev_is_idecd(drive) ? drive->irq_handler
644 : ide_pc_intr),
Bartlomiej Zolnierkiewicz60c0cd02009-03-27 12:46:46 +0100645 timeout);
Bartlomiej Zolnierkiewicz594c16d2008-07-15 21:21:58 +0200646
Borislav Petkov2eba0822009-03-31 20:14:58 +0200647 /* Send the actual packet */
648 if ((drive->atapi_flags & IDE_AFLAG_ZIP_DRIVE) == 0)
649 hwif->tp_ops->output_data(drive, NULL, rq->cmd, cmd_len);
650
Bartlomiej Zolnierkiewicz594c16d2008-07-15 21:21:58 +0200651 /* Begin DMA, if necessary */
Borislav Petkovb16aabc2009-01-02 16:12:56 +0100652 if (dev_is_idecd(drive)) {
653 if (drive->dma)
654 hwif->dma_ops->dma_start(drive);
655 } else {
656 if (pc->flags & PC_FLAG_DMA_OK) {
657 pc->flags |= PC_FLAG_DMA_IN_PROGRESS;
658 hwif->dma_ops->dma_start(drive);
659 }
Bartlomiej Zolnierkiewicz594c16d2008-07-15 21:21:58 +0200660 }
661
Bartlomiej Zolnierkiewicz594c16d2008-07-15 21:21:58 +0200662 return ide_started;
663}
Bartlomiej Zolnierkiewicz6bf16412008-07-15 21:22:00 +0200664
Bartlomiej Zolnierkiewiczb788ee92009-03-27 12:46:46 +0100665ide_startstop_t ide_issue_pc(ide_drive_t *drive, struct ide_cmd *cmd)
Bartlomiej Zolnierkiewicz6bf16412008-07-15 21:22:00 +0200666{
Borislav Petkovd77612a2009-01-02 16:12:55 +0100667 struct ide_atapi_pc *pc;
Bartlomiej Zolnierkiewicz6bf16412008-07-15 21:22:00 +0200668 ide_hwif_t *hwif = drive->hwif;
Borislav Petkov4cad0852009-01-02 16:12:53 +0100669 ide_expiry_t *expiry = NULL;
Bartlomiej Zolnierkiewicze6830a82009-03-27 12:46:37 +0100670 struct request *rq = hwif->rq;
Borislav Petkovdfb7e622009-05-01 20:35:21 +0200671 unsigned int timeout, bytes;
Borislav Petkov392de1d2009-01-02 16:12:52 +0100672 u16 bcount;
Sergei Shtylyov60f85012009-04-08 14:13:01 +0200673 u8 valid_tf;
Bartlomiej Zolnierkiewicz35b5d0b2009-03-27 12:46:47 +0100674 u8 drq_int = !!(drive->atapi_flags & IDE_AFLAG_DRQ_INTERRUPT);
Bartlomiej Zolnierkiewicz6bf16412008-07-15 21:22:00 +0200675
Borislav Petkoved485542009-01-02 16:12:52 +0100676 if (dev_is_idecd(drive)) {
Sergei Shtylyov60f85012009-04-08 14:13:01 +0200677 valid_tf = IDE_VALID_NSECT | IDE_VALID_LBAL;
Bartlomiej Zolnierkiewicze6830a82009-03-27 12:46:37 +0100678 bcount = ide_cd_get_xferlen(rq);
Borislav Petkov4cad0852009-01-02 16:12:53 +0100679 expiry = ide_cd_expiry;
Borislav Petkov28ad91d2009-01-02 16:12:56 +0100680 timeout = ATAPI_WAIT_PC;
Borislav Petkovd77612a2009-01-02 16:12:55 +0100681
Bartlomiej Zolnierkiewicz5ae54122009-03-31 20:15:20 +0200682 if (drive->dma)
683 drive->dma = !ide_dma_prepare(drive, cmd);
Borislav Petkoved485542009-01-02 16:12:52 +0100684 } else {
Borislav Petkovd77612a2009-01-02 16:12:55 +0100685 pc = drive->pc;
686
Sergei Shtylyov60f85012009-04-08 14:13:01 +0200687 valid_tf = IDE_VALID_DEVICE;
Borislav Petkovdfb7e622009-05-01 20:35:21 +0200688 bytes = blk_rq_bytes(rq);
Borislav Petkovdfb7e622009-05-01 20:35:21 +0200689 bcount = ((drive->media == ide_tape) ? bytes
690 : min_t(unsigned int,
691 bytes, 63 * 1024));
Borislav Petkovd77612a2009-01-02 16:12:55 +0100692
Borislav Petkov077e6db2009-05-01 21:21:02 +0200693 /* We haven't transferred any data yet */
694 rq->resid_len = bcount;
Borislav Petkovd77612a2009-01-02 16:12:55 +0100695
696 if (pc->flags & PC_FLAG_DMA_ERROR) {
697 pc->flags &= ~PC_FLAG_DMA_ERROR;
698 ide_dma_off(drive);
699 }
700
Bartlomiej Zolnierkiewicz5ae54122009-03-31 20:15:20 +0200701 if (pc->flags & PC_FLAG_DMA_OK)
702 drive->dma = !ide_dma_prepare(drive, cmd);
Borislav Petkovd77612a2009-01-02 16:12:55 +0100703
704 if (!drive->dma)
705 pc->flags &= ~PC_FLAG_DMA_OK;
Borislav Petkov28ad91d2009-01-02 16:12:56 +0100706
707 timeout = (drive->media == ide_floppy) ? WAIT_FLOPPY_CMD
708 : WAIT_TAPE_CMD;
Borislav Petkoved485542009-01-02 16:12:52 +0100709 }
Bartlomiej Zolnierkiewicz6bf16412008-07-15 21:22:00 +0200710
Sergei Shtylyov60f85012009-04-08 14:13:01 +0200711 ide_init_packet_cmd(cmd, valid_tf, bcount, drive->dma);
Bartlomiej Zolnierkiewiczb788ee92009-03-27 12:46:46 +0100712
713 (void)do_rw_taskfile(drive, cmd);
Bartlomiej Zolnierkiewicz6bf16412008-07-15 21:22:00 +0200714
Bartlomiej Zolnierkiewicz35b5d0b2009-03-27 12:46:47 +0100715 if (drq_int) {
Borislav Petkov5f258432009-01-02 16:12:53 +0100716 if (drive->dma)
717 drive->waiting_for_dma = 0;
Bartlomiej Zolnierkiewicz22117d62009-03-27 12:46:47 +0100718 hwif->expiry = expiry;
Bartlomiej Zolnierkiewicz6bf16412008-07-15 21:22:00 +0200719 }
Bartlomiej Zolnierkiewicz35b5d0b2009-03-27 12:46:47 +0100720
721 ide_execute_command(drive, cmd, ide_transfer_pc, timeout);
722
723 return drq_int ? ide_started : ide_transfer_pc(drive);
Bartlomiej Zolnierkiewicz6bf16412008-07-15 21:22:00 +0200724}
725EXPORT_SYMBOL_GPL(ide_issue_pc);