net/mlx4_core: Reduce harmless SRIOV error message to debug level
[linux-2.6-block.git] / drivers / ide / ide-atapi.c
CommitLineData
594c16d8
BZ
1/*
2 * ATAPI support.
3 */
4
5#include <linux/kernel.h>
4cad085e 6#include <linux/cdrom.h>
594c16d8 7#include <linux/delay.h>
38789fda 8#include <linux/export.h>
594c16d8 9#include <linux/ide.h>
479edf06 10#include <linux/scatterlist.h>
5a0e3ad6 11#include <linux/gfp.h>
479edf06 12
646c0cb6
BZ
13#include <scsi/scsi.h>
14
103f7033
BP
15#define DRV_NAME "ide-atapi"
16#define PFX DRV_NAME ": "
17
646c0cb6
BZ
18#ifdef DEBUG
19#define debug_log(fmt, args...) \
20 printk(KERN_INFO "ide: " fmt, ## args)
21#else
22#define debug_log(fmt, args...) do {} while (0)
23#endif
24
8c662852
BP
25#define ATAPI_MIN_CDB_BYTES 12
26
991cb26a
BP
27static inline int dev_is_idecd(ide_drive_t *drive)
28{
5317464d 29 return drive->media == ide_cdrom || drive->media == ide_optical;
991cb26a
BP
30}
31
51509eec
BZ
32/*
33 * Check whether we can support a device,
34 * based on the ATAPI IDENTIFY command results.
35 */
36int ide_check_atapi_device(ide_drive_t *drive, const char *s)
37{
38 u16 *id = drive->id;
39 u8 gcw[2], protocol, device_type, removable, drq_type, packet_size;
40
41 *((u16 *)&gcw) = id[ATA_ID_CONFIG];
42
43 protocol = (gcw[1] & 0xC0) >> 6;
44 device_type = gcw[1] & 0x1F;
45 removable = (gcw[0] & 0x80) >> 7;
46 drq_type = (gcw[0] & 0x60) >> 5;
47 packet_size = gcw[0] & 0x03;
48
49#ifdef CONFIG_PPC
50 /* kludge for Apple PowerBook internal zip */
51 if (drive->media == ide_floppy && device_type == 5 &&
52 !strstr((char *)&id[ATA_ID_PROD], "CD-ROM") &&
53 strstr((char *)&id[ATA_ID_PROD], "ZIP"))
54 device_type = 0;
55#endif
56
57 if (protocol != 2)
58 printk(KERN_ERR "%s: %s: protocol (0x%02x) is not ATAPI\n",
59 s, drive->name, protocol);
60 else if ((drive->media == ide_floppy && device_type != 0) ||
61 (drive->media == ide_tape && device_type != 1))
62 printk(KERN_ERR "%s: %s: invalid device type (0x%02x)\n",
63 s, drive->name, device_type);
64 else if (removable == 0)
65 printk(KERN_ERR "%s: %s: the removable flag is not set\n",
66 s, drive->name);
67 else if (drive->media == ide_floppy && drq_type == 3)
68 printk(KERN_ERR "%s: %s: sorry, DRQ type (0x%02x) not "
69 "supported\n", s, drive->name, drq_type);
70 else if (packet_size != 0)
71 printk(KERN_ERR "%s: %s: packet size (0x%02x) is not 12 "
72 "bytes\n", s, drive->name, packet_size);
73 else
74 return 1;
75 return 0;
76}
77EXPORT_SYMBOL_GPL(ide_check_atapi_device);
78
7bf7420a
BZ
79void ide_init_pc(struct ide_atapi_pc *pc)
80{
81 memset(pc, 0, sizeof(*pc));
7bf7420a
BZ
82}
83EXPORT_SYMBOL_GPL(ide_init_pc);
84
2ac07d92
BZ
85/*
86 * Add a special packet command request to the tail of the request queue,
87 * and wait for it to be serviced.
88 */
89int ide_queue_pc_tail(ide_drive_t *drive, struct gendisk *disk,
b13345f3 90 struct ide_atapi_pc *pc, void *buf, unsigned int bufflen)
2ac07d92
BZ
91{
92 struct request *rq;
93 int error;
94
aebf526b 95 rq = blk_get_request(drive->queue, REQ_OP_DRV_IN, __GFP_RECLAIM);
82ed4db4 96 scsi_req_init(rq);
2f5a8e80 97 ide_req(rq)->type = ATA_PRIV_MISC;
c267cc1c 98 rq->special = (char *)pc;
3eb76c1c 99
b13345f3
BP
100 if (buf && bufflen) {
101 error = blk_rq_map_kern(drive->queue, rq, buf, bufflen,
5c4be572
TH
102 GFP_NOIO);
103 if (error)
104 goto put_req;
3eb76c1c
BP
105 }
106
82ed4db4 107 memcpy(scsi_req(rq)->cmd, pc->c, 12);
2ac07d92 108 if (drive->media == ide_tape)
82ed4db4 109 scsi_req(rq)->cmd[13] = REQ_IDETAPE_PC1;
b7819b92 110 blk_execute_rq(drive->queue, disk, rq, 0);
17d5363b 111 error = scsi_req(rq)->result ? -EIO : 0;
5c4be572 112put_req:
2ac07d92 113 blk_put_request(rq);
2ac07d92
BZ
114 return error;
115}
116EXPORT_SYMBOL_GPL(ide_queue_pc_tail);
117
de699ad5
BZ
118int ide_do_test_unit_ready(ide_drive_t *drive, struct gendisk *disk)
119{
120 struct ide_atapi_pc pc;
121
122 ide_init_pc(&pc);
123 pc.c[0] = TEST_UNIT_READY;
124
b13345f3 125 return ide_queue_pc_tail(drive, disk, &pc, NULL, 0);
de699ad5
BZ
126}
127EXPORT_SYMBOL_GPL(ide_do_test_unit_ready);
128
0c8a6c7a
BZ
129int ide_do_start_stop(ide_drive_t *drive, struct gendisk *disk, int start)
130{
131 struct ide_atapi_pc pc;
132
133 ide_init_pc(&pc);
134 pc.c[0] = START_STOP;
135 pc.c[4] = start;
136
137 if (drive->media == ide_tape)
138 pc.flags |= PC_FLAG_WAIT_FOR_DSC;
139
b13345f3 140 return ide_queue_pc_tail(drive, disk, &pc, NULL, 0);
0c8a6c7a
BZ
141}
142EXPORT_SYMBOL_GPL(ide_do_start_stop);
143
0578042d
BZ
144int ide_set_media_lock(ide_drive_t *drive, struct gendisk *disk, int on)
145{
146 struct ide_atapi_pc pc;
147
42619d35 148 if ((drive->dev_flags & IDE_DFLAG_DOORLOCKING) == 0)
0578042d
BZ
149 return 0;
150
151 ide_init_pc(&pc);
152 pc.c[0] = ALLOW_MEDIUM_REMOVAL;
153 pc.c[4] = on;
154
b13345f3 155 return ide_queue_pc_tail(drive, disk, &pc, NULL, 0);
0578042d
BZ
156}
157EXPORT_SYMBOL_GPL(ide_set_media_lock);
158
6b0da28b
BZ
159void ide_create_request_sense_cmd(ide_drive_t *drive, struct ide_atapi_pc *pc)
160{
161 ide_init_pc(pc);
162 pc->c[0] = REQUEST_SENSE;
163 if (drive->media == ide_floppy) {
164 pc->c[4] = 255;
165 pc->req_xfer = 18;
166 } else {
167 pc->c[4] = 20;
168 pc->req_xfer = 20;
169 }
170}
171EXPORT_SYMBOL_GPL(ide_create_request_sense_cmd);
172
a1df5169
BP
173void ide_prep_sense(ide_drive_t *drive, struct request *rq)
174{
175 struct request_sense *sense = &drive->sense_data;
82ed4db4
CH
176 struct request *sense_rq = drive->sense_rq;
177 struct scsi_request *req = scsi_req(sense_rq);
a1df5169 178 unsigned int cmd_len, sense_len;
5c4be572 179 int err;
a1df5169 180
a1df5169
BP
181 switch (drive->media) {
182 case ide_floppy:
183 cmd_len = 255;
184 sense_len = 18;
185 break;
186 case ide_tape:
187 cmd_len = 20;
188 sense_len = 20;
189 break;
190 default:
191 cmd_len = 18;
192 sense_len = 18;
193 }
194
195 BUG_ON(sense_len > sizeof(*sense));
196
2f5a8e80 197 if (ata_sense_request(rq) || drive->sense_rq_armed)
a1df5169
BP
198 return;
199
200 memset(sense, 0, sizeof(*sense));
201
202 blk_rq_init(rq->q, sense_rq);
82ed4db4 203 scsi_req_init(sense_rq);
a1df5169 204
5c4be572
TH
205 err = blk_rq_map_kern(drive->queue, sense_rq, sense, sense_len,
206 GFP_NOIO);
207 if (unlikely(err)) {
208 if (printk_ratelimit())
103f7033
BP
209 printk(KERN_WARNING PFX "%s: failed to map sense "
210 "buffer\n", drive->name);
5c4be572
TH
211 return;
212 }
213
214 sense_rq->rq_disk = rq->rq_disk;
aebf526b 215 sense_rq->cmd_flags = REQ_OP_DRV_IN;
2f5a8e80 216 ide_req(sense_rq)->type = ATA_PRIV_SENSE;
e8064021 217 sense_rq->rq_flags |= RQF_PREEMPT;
a1df5169 218
82ed4db4
CH
219 req->cmd[0] = GPCMD_REQUEST_SENSE;
220 req->cmd[4] = cmd_len;
a1df5169 221 if (drive->media == ide_tape)
82ed4db4 222 req->cmd[13] = REQ_IDETAPE_PC1;
a1df5169
BP
223
224 drive->sense_rq_armed = true;
225}
226EXPORT_SYMBOL_GPL(ide_prep_sense);
227
5c4be572 228int ide_queue_sense_rq(ide_drive_t *drive, void *special)
a1df5169 229{
5c4be572
TH
230 /* deferred failure from ide_prep_sense() */
231 if (!drive->sense_rq_armed) {
103f7033 232 printk(KERN_WARNING PFX "%s: error queuing a sense request\n",
5c4be572
TH
233 drive->name);
234 return -ENOMEM;
235 }
a1df5169 236
82ed4db4 237 drive->sense_rq->special = special;
a1df5169
BP
238 drive->sense_rq_armed = false;
239
240 drive->hwif->rq = NULL;
241
82ed4db4 242 elv_add_request(drive->queue, drive->sense_rq, ELEVATOR_INSERT_FRONT);
5c4be572 243 return 0;
a1df5169
BP
244}
245EXPORT_SYMBOL_GPL(ide_queue_sense_rq);
246
6b0da28b
BZ
247/*
248 * Called when an error was detected during the last packet command.
6b544fcc
BP
249 * We queue a request sense packet command at the head of the request
250 * queue.
6b0da28b 251 */
6b544fcc 252void ide_retry_pc(ide_drive_t *drive)
6b0da28b 253{
8f6205cd 254 struct request *failed_rq = drive->hwif->rq;
82ed4db4 255 struct request *sense_rq = drive->sense_rq;
6b0da28b
BZ
256 struct ide_atapi_pc *pc = &drive->request_sense_pc;
257
258 (void)ide_read_error(drive);
6b544fcc
BP
259
260 /* init pc from sense_rq */
261 ide_init_pc(pc);
82ed4db4 262 memcpy(pc->c, scsi_req(sense_rq)->cmd, 12);
6b544fcc 263
6b0da28b 264 if (drive->media == ide_tape)
626542ca 265 drive->atapi_flags |= IDE_AFLAG_IGNORE_DSC;
6b544fcc 266
8f6205cd
TH
267 /*
268 * Push back the failed request and put request sense on top
269 * of it. The failed command will be retried after sense data
270 * is acquired.
271 */
8f6205cd 272 drive->hwif->rq = NULL;
1af18503 273 ide_requeue_and_plug(drive, failed_rq);
8f6205cd 274 if (ide_queue_sense_rq(drive, pc)) {
9934c8c0 275 blk_start_request(failed_rq);
8f6205cd
TH
276 ide_complete_rq(drive, -EIO, blk_rq_bytes(failed_rq));
277 }
6b0da28b
BZ
278}
279EXPORT_SYMBOL_GPL(ide_retry_pc);
280
4cad085e
BP
281int ide_cd_expiry(ide_drive_t *drive)
282{
b65fac32 283 struct request *rq = drive->hwif->rq;
4cad085e
BP
284 unsigned long wait = 0;
285
286 debug_log("%s: rq->cmd[0]: 0x%x\n", __func__, rq->cmd[0]);
287
288 /*
289 * Some commands are *slow* and normally take a long time to complete.
290 * Usually we can use the ATAPI "disconnect" to bypass this, but not all
291 * commands/drives support that. Let ide_timer_expiry keep polling us
292 * for these.
293 */
82ed4db4 294 switch (scsi_req(rq)->cmd[0]) {
4cad085e
BP
295 case GPCMD_BLANK:
296 case GPCMD_FORMAT_UNIT:
297 case GPCMD_RESERVE_RZONE_TRACK:
298 case GPCMD_CLOSE_TRACK:
299 case GPCMD_FLUSH_CACHE:
300 wait = ATAPI_WAIT_PC;
301 break;
302 default:
e8064021 303 if (!(rq->rq_flags & RQF_QUIET))
103f7033 304 printk(KERN_INFO PFX "cmd 0x%x timed out\n",
82ed4db4 305 scsi_req(rq)->cmd[0]);
4cad085e
BP
306 wait = 0;
307 break;
308 }
309 return wait;
310}
311EXPORT_SYMBOL_GPL(ide_cd_expiry);
312
392de1d5
BP
313int ide_cd_get_xferlen(struct request *rq)
314{
aebf526b
CH
315 switch (req_op(rq)) {
316 default:
392de1d5 317 return 32768;
aebf526b
CH
318 case REQ_OP_SCSI_IN:
319 case REQ_OP_SCSI_OUT:
34b7d2c9 320 return blk_rq_bytes(rq);
aebf526b
CH
321 case REQ_OP_DRV_IN:
322 case REQ_OP_DRV_OUT:
2f5a8e80
CH
323 switch (ide_req(rq)->type) {
324 case ATA_PRIV_PC:
325 case ATA_PRIV_SENSE:
326 return blk_rq_bytes(rq);
aebf526b
CH
327 default:
328 return 0;
2f5a8e80 329 }
33659ebb 330 }
392de1d5
BP
331}
332EXPORT_SYMBOL_GPL(ide_cd_get_xferlen);
333
0d6a9754
BZ
334void ide_read_bcount_and_ireason(ide_drive_t *drive, u16 *bcount, u8 *ireason)
335{
3153c26b 336 struct ide_taskfile tf;
0d6a9754 337
3153c26b
SS
338 drive->hwif->tp_ops->tf_read(drive, &tf, IDE_VALID_NSECT |
339 IDE_VALID_LBAM | IDE_VALID_LBAH);
0d6a9754 340
3153c26b
SS
341 *bcount = (tf.lbah << 8) | tf.lbam;
342 *ireason = tf.nsect & 3;
0d6a9754
BZ
343}
344EXPORT_SYMBOL_GPL(ide_read_bcount_and_ireason);
345
103f7033
BP
346/*
347 * Check the contents of the interrupt reason register and attempt to recover if
348 * there are problems.
349 *
350 * Returns:
351 * - 0 if everything's ok
352 * - 1 if the request has to be terminated.
353 */
354int ide_check_ireason(ide_drive_t *drive, struct request *rq, int len,
355 int ireason, int rw)
356{
357 ide_hwif_t *hwif = drive->hwif;
358
359 debug_log("ireason: 0x%x, rw: 0x%x\n", ireason, rw);
360
361 if (ireason == (!rw << 1))
362 return 0;
363 else if (ireason == (rw << 1)) {
364 printk(KERN_ERR PFX "%s: %s: wrong transfer direction!\n",
365 drive->name, __func__);
366
367 if (dev_is_idecd(drive))
368 ide_pad_transfer(drive, rw, len);
369 } else if (!rw && ireason == ATAPI_COD) {
370 if (dev_is_idecd(drive)) {
371 /*
372 * Some drives (ASUS) seem to tell us that status info
373 * is available. Just get it and ignore.
374 */
375 (void)hwif->tp_ops->read_status(hwif);
376 return 0;
377 }
378 } else {
379 if (ireason & ATAPI_COD)
380 printk(KERN_ERR PFX "%s: CoD != 0 in %s\n", drive->name,
381 __func__);
382
383 /* drive wants a command packet, or invalid ireason... */
384 printk(KERN_ERR PFX "%s: %s: bad interrupt reason 0x%02x\n",
385 drive->name, __func__, ireason);
386 }
387
2f5a8e80 388 if (dev_is_idecd(drive) && ata_pc_request(rq))
e8064021 389 rq->rq_flags |= RQF_FAILED;
103f7033
BP
390
391 return 1;
392}
393EXPORT_SYMBOL_GPL(ide_check_ireason);
394
aa5d2de7
BZ
395/*
396 * This is the usual interrupt handler which will be called during a packet
397 * command. We will transfer some of the data (as requested by the drive)
398 * and will re-point interrupt handler to us.
399 */
400static ide_startstop_t ide_pc_intr(ide_drive_t *drive)
646c0cb6 401{
2b9efba4 402 struct ide_atapi_pc *pc = drive->pc;
646c0cb6 403 ide_hwif_t *hwif = drive->hwif;
f094d4d8 404 struct ide_cmd *cmd = &hwif->cmd;
b65fac32 405 struct request *rq = hwif->rq;
374e042c 406 const struct ide_tp_ops *tp_ops = hwif->tp_ops;
d93bc452 407 unsigned int timeout, done;
646c0cb6 408 u16 bcount;
5d655a03 409 u8 stat, ireason, dsc = 0;
d93bc452 410 u8 write = !!(pc->flags & PC_FLAG_WRITING);
646c0cb6
BZ
411
412 debug_log("Enter %s - interrupt handler\n", __func__);
413
5d655a03
BP
414 timeout = (drive->media == ide_floppy) ? WAIT_FLOPPY_CMD
415 : WAIT_TAPE_CMD;
844b9468 416
646c0cb6 417 /* Clear the interrupt */
374e042c 418 stat = tp_ops->read_status(hwif);
646c0cb6
BZ
419
420 if (pc->flags & PC_FLAG_DMA_IN_PROGRESS) {
88b4132e 421 int rc;
4453011f 422
88b4132e
BZ
423 drive->waiting_for_dma = 0;
424 rc = hwif->dma_ops->dma_end(drive);
f094d4d8 425 ide_dma_unmap_sg(drive, cmd);
4453011f
BZ
426
427 if (rc || (drive->media == ide_tape && (stat & ATA_ERR))) {
5d655a03 428 if (drive->media == ide_floppy)
103f7033 429 printk(KERN_ERR PFX "%s: DMA %s error\n",
646c0cb6
BZ
430 drive->name, rq_data_dir(pc->rq)
431 ? "write" : "read");
432 pc->flags |= PC_FLAG_DMA_ERROR;
6d700387 433 } else
82ed4db4 434 scsi_req(rq)->resid_len = 0;
646c0cb6
BZ
435 debug_log("%s: DMA finished\n", drive->name);
436 }
437
438 /* No more interrupts */
3a7d2484 439 if ((stat & ATA_DRQ) == 0) {
5b6c942d 440 int uptodate, error;
03a2faae 441
646c0cb6 442 debug_log("Packet command completed, %d bytes transferred\n",
077e6dba 443 blk_rq_bytes(rq));
646c0cb6
BZ
444
445 pc->flags &= ~PC_FLAG_DMA_IN_PROGRESS;
446
447 local_irq_enable_in_hardirq();
448
5d655a03 449 if (drive->media == ide_tape &&
82ed4db4 450 (stat & ATA_ERR) && scsi_req(rq)->cmd[0] == REQUEST_SENSE)
3a7d2484 451 stat &= ~ATA_ERR;
8fccf899 452
3a7d2484 453 if ((stat & ATA_ERR) || (pc->flags & PC_FLAG_DMA_ERROR)) {
646c0cb6
BZ
454 /* Error detected */
455 debug_log("%s: I/O error\n", drive->name);
456
5d655a03 457 if (drive->media != ide_tape)
17d5363b 458 scsi_req(pc->rq)->result++;
646c0cb6 459
82ed4db4 460 if (scsi_req(rq)->cmd[0] == REQUEST_SENSE) {
103f7033
BP
461 printk(KERN_ERR PFX "%s: I/O error in request "
462 "sense command\n", drive->name);
646c0cb6
BZ
463 return ide_do_reset(drive);
464 }
465
8fccf899 466 debug_log("[cmd %x]: check condition\n", rq->cmd[0]);
646c0cb6
BZ
467
468 /* Retry operation */
6b544fcc 469 ide_retry_pc(drive);
8fccf899 470
646c0cb6
BZ
471 /* queued, but not started */
472 return ide_stopped;
473 }
646c0cb6 474 pc->error = 0;
b14c7212
BZ
475
476 if ((pc->flags & PC_FLAG_WAIT_FOR_DSC) && (stat & ATA_DSC) == 0)
477 dsc = 1;
8fccf899 478
b3071d19
TH
479 /*
480 * ->pc_callback() might change rq->data_len for
481 * residual count, cache total length.
482 */
21d9c5d2 483 done = blk_rq_bytes(rq);
b3071d19 484
646c0cb6 485 /* Command finished - Call the callback function */
03a2faae
BZ
486 uptodate = drive->pc_callback(drive, dsc);
487
488 if (uptodate == 0)
489 drive->failed_pc = NULL;
490
2f5a8e80 491 if (ata_misc_request(rq)) {
17d5363b 492 scsi_req(rq)->result = 0;
5b6c942d 493 error = 0;
89f78b32 494 } else {
349d12a1 495
aebf526b 496 if (blk_rq_is_passthrough(rq) && uptodate <= 0) {
17d5363b
CH
497 if (scsi_req(rq)->result == 0)
498 scsi_req(rq)->result = -EIO;
89f78b32 499 }
349d12a1 500
5b6c942d 501 error = uptodate ? 0 : -EIO;
89f78b32 502 }
8fccf899 503
c3a4d78c 504 ide_complete_rq(drive, error, blk_rq_bytes(rq));
646c0cb6
BZ
505 return ide_stopped;
506 }
507
508 if (pc->flags & PC_FLAG_DMA_IN_PROGRESS) {
509 pc->flags &= ~PC_FLAG_DMA_IN_PROGRESS;
103f7033
BP
510 printk(KERN_ERR PFX "%s: The device wants to issue more "
511 "interrupts in DMA mode\n", drive->name);
646c0cb6
BZ
512 ide_dma_off(drive);
513 return ide_do_reset(drive);
514 }
646c0cb6 515
1823649b
BZ
516 /* Get the number of bytes to transfer on this interrupt. */
517 ide_read_bcount_and_ireason(drive, &bcount, &ireason);
646c0cb6 518
103f7033 519 if (ide_check_ireason(drive, rq, bcount, ireason, write))
646c0cb6 520 return ide_do_reset(drive);
8fccf899 521
6d700387
TH
522 done = min_t(unsigned int, bcount, cmd->nleft);
523 ide_pio_bytes(drive, cmd, write, done);
646c0cb6 524
6d700387 525 /* Update transferred byte count */
82ed4db4 526 scsi_req(rq)->resid_len -= done;
d93bc452
BZ
527
528 bcount -= done;
529
530 if (bcount)
531 ide_pad_transfer(drive, write, bcount);
532
077e6dba 533 debug_log("[cmd %x] transferred %d bytes, padded %d bytes, resid: %u\n",
82ed4db4 534 rq->cmd[0], done, bcount, scsi_req(rq)->resid_len);
646c0cb6 535
646c0cb6 536 /* And set the interrupt handler again */
60c0cd02 537 ide_set_handler(drive, ide_pc_intr, timeout);
646c0cb6
BZ
538 return ide_started;
539}
594c16d8 540
60f85019 541static void ide_init_packet_cmd(struct ide_cmd *cmd, u8 valid_tf,
b788ee9c 542 u16 bcount, u8 dma)
7a254df0 543{
60f85019
SS
544 cmd->protocol = dma ? ATAPI_PROT_DMA : ATAPI_PROT_PIO;
545 cmd->valid.out.tf = IDE_VALID_LBAH | IDE_VALID_LBAM |
546 IDE_VALID_FEATURE | valid_tf;
35b5d0be 547 cmd->tf.command = ATA_CMD_PACKET;
b788ee9c
BZ
548 cmd->tf.feature = dma; /* Use PIO/DMA */
549 cmd->tf.lbam = bcount & 0xff;
550 cmd->tf.lbah = (bcount >> 8) & 0xff;
7a254df0
BZ
551}
552
88a72109
BZ
553static u8 ide_read_ireason(ide_drive_t *drive)
554{
3153c26b 555 struct ide_taskfile tf;
88a72109 556
3153c26b 557 drive->hwif->tp_ops->tf_read(drive, &tf, IDE_VALID_NSECT);
88a72109 558
3153c26b 559 return tf.nsect & 3;
88a72109
BZ
560}
561
594c16d8
BZ
562static u8 ide_wait_ireason(ide_drive_t *drive, u8 ireason)
563{
594c16d8
BZ
564 int retries = 100;
565
3a7d2484
BZ
566 while (retries-- && ((ireason & ATAPI_COD) == 0 ||
567 (ireason & ATAPI_IO))) {
103f7033 568 printk(KERN_ERR PFX "%s: (IO,CoD != (0,1) while issuing "
594c16d8
BZ
569 "a packet command, retrying\n", drive->name);
570 udelay(100);
88a72109 571 ireason = ide_read_ireason(drive);
594c16d8 572 if (retries == 0) {
103f7033
BP
573 printk(KERN_ERR PFX "%s: (IO,CoD != (0,1) while issuing"
574 " a packet command, ignoring\n",
594c16d8 575 drive->name);
3a7d2484
BZ
576 ireason |= ATAPI_COD;
577 ireason &= ~ATAPI_IO;
594c16d8
BZ
578 }
579 }
580
581 return ireason;
582}
583
baf08f0b
BZ
584static int ide_delayed_transfer_pc(ide_drive_t *drive)
585{
586 /* Send the actual packet */
587 drive->hwif->tp_ops->output_data(drive, NULL, drive->pc->c, 12);
588
589 /* Timeout for the packet command */
590 return WAIT_FLOPPY_CMD;
591}
592
593static ide_startstop_t ide_transfer_pc(ide_drive_t *drive)
594c16d8 594{
b16aabc9 595 struct ide_atapi_pc *uninitialized_var(pc);
594c16d8 596 ide_hwif_t *hwif = drive->hwif;
b65fac32 597 struct request *rq = hwif->rq;
baf08f0b
BZ
598 ide_expiry_t *expiry;
599 unsigned int timeout;
8c662852 600 int cmd_len;
594c16d8
BZ
601 ide_startstop_t startstop;
602 u8 ireason;
603
3a7d2484 604 if (ide_wait_stat(&startstop, drive, ATA_DRQ, ATA_BUSY, WAIT_READY)) {
103f7033 605 printk(KERN_ERR PFX "%s: Strange, packet command initiated yet "
594c16d8
BZ
606 "DRQ isn't asserted\n", drive->name);
607 return startstop;
608 }
609
5f25843f
BP
610 if (drive->atapi_flags & IDE_AFLAG_DRQ_INTERRUPT) {
611 if (drive->dma)
612 drive->waiting_for_dma = 1;
613 }
614
8c662852
BP
615 if (dev_is_idecd(drive)) {
616 /* ATAPI commands get padded out to 12 bytes minimum */
82ed4db4 617 cmd_len = COMMAND_SIZE(scsi_req(rq)->cmd[0]);
8c662852
BP
618 if (cmd_len < ATAPI_MIN_CDB_BYTES)
619 cmd_len = ATAPI_MIN_CDB_BYTES;
8c662852 620
def860d0
BP
621 timeout = rq->timeout;
622 expiry = ide_cd_expiry;
baf08f0b 623 } else {
b16aabc9
BP
624 pc = drive->pc;
625
def860d0
BP
626 cmd_len = ATAPI_MIN_CDB_BYTES;
627
628 /*
629 * If necessary schedule the packet transfer to occur 'timeout'
19af5cdb 630 * milliseconds later in ide_delayed_transfer_pc() after the
def860d0
BP
631 * device says it's ready for a packet.
632 */
633 if (drive->atapi_flags & IDE_AFLAG_ZIP_DRIVE) {
634 timeout = drive->pc_delay;
635 expiry = &ide_delayed_transfer_pc;
636 } else {
637 timeout = (drive->media == ide_floppy) ? WAIT_FLOPPY_CMD
638 : WAIT_TAPE_CMD;
639 expiry = NULL;
640 }
06cc2778
BP
641
642 ireason = ide_read_ireason(drive);
643 if (drive->media == ide_tape)
644 ireason = ide_wait_ireason(drive, ireason);
645
646 if ((ireason & ATAPI_COD) == 0 || (ireason & ATAPI_IO)) {
103f7033
BP
647 printk(KERN_ERR PFX "%s: (IO,CoD) != (0,1) while "
648 "issuing a packet command\n", drive->name);
06cc2778
BP
649
650 return ide_do_reset(drive);
651 }
baf08f0b
BZ
652 }
653
60c0cd02
BZ
654 hwif->expiry = expiry;
655
594c16d8 656 /* Set the interrupt routine */
d6251d44
BP
657 ide_set_handler(drive,
658 (dev_is_idecd(drive) ? drive->irq_handler
659 : ide_pc_intr),
60c0cd02 660 timeout);
594c16d8 661
2eba0827
BP
662 /* Send the actual packet */
663 if ((drive->atapi_flags & IDE_AFLAG_ZIP_DRIVE) == 0)
82ed4db4 664 hwif->tp_ops->output_data(drive, NULL, scsi_req(rq)->cmd, cmd_len);
2eba0827 665
594c16d8 666 /* Begin DMA, if necessary */
b16aabc9
BP
667 if (dev_is_idecd(drive)) {
668 if (drive->dma)
669 hwif->dma_ops->dma_start(drive);
670 } else {
671 if (pc->flags & PC_FLAG_DMA_OK) {
672 pc->flags |= PC_FLAG_DMA_IN_PROGRESS;
673 hwif->dma_ops->dma_start(drive);
674 }
594c16d8
BZ
675 }
676
594c16d8
BZ
677 return ide_started;
678}
6bf1641c 679
b788ee9c 680ide_startstop_t ide_issue_pc(ide_drive_t *drive, struct ide_cmd *cmd)
6bf1641c 681{
d77612ab 682 struct ide_atapi_pc *pc;
6bf1641c 683 ide_hwif_t *hwif = drive->hwif;
4cad085e 684 ide_expiry_t *expiry = NULL;
e6830a86 685 struct request *rq = hwif->rq;
dfb7e621 686 unsigned int timeout, bytes;
392de1d5 687 u16 bcount;
60f85019 688 u8 valid_tf;
35b5d0be 689 u8 drq_int = !!(drive->atapi_flags & IDE_AFLAG_DRQ_INTERRUPT);
6bf1641c 690
ed48554f 691 if (dev_is_idecd(drive)) {
60f85019 692 valid_tf = IDE_VALID_NSECT | IDE_VALID_LBAL;
e6830a86 693 bcount = ide_cd_get_xferlen(rq);
4cad085e 694 expiry = ide_cd_expiry;
28ad91db 695 timeout = ATAPI_WAIT_PC;
d77612ab 696
5ae5412d
BZ
697 if (drive->dma)
698 drive->dma = !ide_dma_prepare(drive, cmd);
ed48554f 699 } else {
d77612ab
BP
700 pc = drive->pc;
701
60f85019 702 valid_tf = IDE_VALID_DEVICE;
dfb7e621 703 bytes = blk_rq_bytes(rq);
dfb7e621
BP
704 bcount = ((drive->media == ide_tape) ? bytes
705 : min_t(unsigned int,
706 bytes, 63 * 1024));
6bf1641c 707
077e6dba 708 /* We haven't transferred any data yet */
82ed4db4 709 scsi_req(rq)->resid_len = bcount;
6bf1641c 710
d77612ab
BP
711 if (pc->flags & PC_FLAG_DMA_ERROR) {
712 pc->flags &= ~PC_FLAG_DMA_ERROR;
713 ide_dma_off(drive);
714 }
6bf1641c 715
5ae5412d
BZ
716 if (pc->flags & PC_FLAG_DMA_OK)
717 drive->dma = !ide_dma_prepare(drive, cmd);
6bf1641c 718
d77612ab
BP
719 if (!drive->dma)
720 pc->flags &= ~PC_FLAG_DMA_OK;
28ad91db
BP
721
722 timeout = (drive->media == ide_floppy) ? WAIT_FLOPPY_CMD
723 : WAIT_TAPE_CMD;
d77612ab 724 }
6bf1641c 725
60f85019 726 ide_init_packet_cmd(cmd, valid_tf, bcount, drive->dma);
b788ee9c
BZ
727
728 (void)do_rw_taskfile(drive, cmd);
6bf1641c 729
35b5d0be 730 if (drq_int) {
5f25843f
BP
731 if (drive->dma)
732 drive->waiting_for_dma = 0;
22117d6e 733 hwif->expiry = expiry;
6bf1641c 734 }
35b5d0be
BZ
735
736 ide_execute_command(drive, cmd, ide_transfer_pc, timeout);
737
738 return drq_int ? ide_started : ide_transfer_pc(drive);
6bf1641c
BZ
739}
740EXPORT_SYMBOL_GPL(ide_issue_pc);