1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27#include <linux/module.h>
28#include <linux/types.h>
29#include <linux/string.h>
30#include <linux/kernel.h>
31#include <linux/timer.h>
32#include <linux/mm.h>
33#include <linux/interrupt.h>
34#include <linux/major.h>
35#include <linux/errno.h>
36#include <linux/genhd.h>
37#include <linux/blkpg.h>
38#include <linux/slab.h>
39#include <linux/init.h>
40#include <linux/pci.h>
41#include <linux/delay.h>
42#include <linux/ide.h>
43#include <linux/completion.h>
44#include <linux/reboot.h>
45#include <linux/cdrom.h>
46#include <linux/seq_file.h>
47#include <linux/device.h>
48#include <linux/kmod.h>
49#include <linux/scatterlist.h>
50#include <linux/bitops.h>
51
52#include <asm/byteorder.h>
53#include <asm/irq.h>
54#include <asm/uaccess.h>
55#include <asm/io.h>
56
57int ide_end_rq(ide_drive_t *drive, struct request *rq, int error,
58 unsigned int nr_bytes)
59{
60
61
62
63
64 if ((drive->dev_flags & IDE_DFLAG_DMA_PIO_RETRY) &&
65 drive->retry_pio <= 3) {
66 drive->dev_flags &= ~IDE_DFLAG_DMA_PIO_RETRY;
67 ide_dma_on(drive);
68 }
69
70 return blk_end_request(rq, error, nr_bytes);
71}
72EXPORT_SYMBOL_GPL(ide_end_rq);
73
74void ide_complete_cmd(ide_drive_t *drive, struct ide_cmd *cmd, u8 stat, u8 err)
75{
76 const struct ide_tp_ops *tp_ops = drive->hwif->tp_ops;
77 struct ide_taskfile *tf = &cmd->tf;
78 struct request *rq = cmd->rq;
79 u8 tf_cmd = tf->command;
80
81 tf->error = err;
82 tf->status = stat;
83
84 if (cmd->ftf_flags & IDE_FTFLAG_IN_DATA) {
85 u8 data[2];
86
87 tp_ops->input_data(drive, cmd, data, 2);
88
89 cmd->tf.data = data[0];
90 cmd->hob.data = data[1];
91 }
92
93 ide_tf_readback(drive, cmd);
94
95 if ((cmd->tf_flags & IDE_TFLAG_CUSTOM_HANDLER) &&
96 tf_cmd == ATA_CMD_IDLEIMMEDIATE) {
97 if (tf->lbal != 0xc4) {
98 printk(KERN_ERR "%s: head unload failed!\n",
99 drive->name);
100 ide_tf_dump(drive->name, cmd);
101 } else
102 drive->dev_flags |= IDE_DFLAG_PARKED;
103 }
104
105 if (rq && rq->cmd_type == REQ_TYPE_ATA_TASKFILE) {
106 struct ide_cmd *orig_cmd = rq->special;
107
108 if (cmd->tf_flags & IDE_TFLAG_DYN)
109 kfree(orig_cmd);
110 else
111 memcpy(orig_cmd, cmd, sizeof(*cmd));
112 }
113}
114
115int ide_complete_rq(ide_drive_t *drive, int error, unsigned int nr_bytes)
116{
117 ide_hwif_t *hwif = drive->hwif;
118 struct request *rq = hwif->rq;
119 int rc;
120
121
122
123
124
125 if (blk_noretry_request(rq) && error <= 0)
126 nr_bytes = blk_rq_sectors(rq) << 9;
127
128 rc = ide_end_rq(drive, rq, error, nr_bytes);
129 if (rc == 0)
130 hwif->rq = NULL;
131
132 return rc;
133}
134EXPORT_SYMBOL(ide_complete_rq);
135
136void ide_kill_rq(ide_drive_t *drive, struct request *rq)
137{
138 u8 drv_req = blk_special_request(rq) && rq->rq_disk;
139 u8 media = drive->media;
140
141 drive->failed_pc = NULL;
142
143 if ((media == ide_floppy || media == ide_tape) && drv_req) {
144 rq->errors = 0;
145 } else {
146 if (media == ide_tape)
147 rq->errors = IDE_DRV_ERROR_GENERAL;
148 else if (blk_fs_request(rq) == 0 && rq->errors == 0)
149 rq->errors = -EIO;
150 }
151
152 ide_complete_rq(drive, -EIO, blk_rq_bytes(rq));
153}
154
155static void ide_tf_set_specify_cmd(ide_drive_t *drive, struct ide_taskfile *tf)
156{
157 tf->nsect = drive->sect;
158 tf->lbal = drive->sect;
159 tf->lbam = drive->cyl;
160 tf->lbah = drive->cyl >> 8;
161 tf->device = (drive->head - 1) | drive->select;
162 tf->command = ATA_CMD_INIT_DEV_PARAMS;
163}
164
165static void ide_tf_set_restore_cmd(ide_drive_t *drive, struct ide_taskfile *tf)
166{
167 tf->nsect = drive->sect;
168 tf->command = ATA_CMD_RESTORE;
169}
170
171static void ide_tf_set_setmult_cmd(ide_drive_t *drive, struct ide_taskfile *tf)
172{
173 tf->nsect = drive->mult_req;
174 tf->command = ATA_CMD_SET_MULTI;
175}
176
177
178
179
180
181
182
183
184
185static ide_startstop_t do_special(ide_drive_t *drive)
186{
187 struct ide_cmd cmd;
188
189#ifdef DEBUG
190 printk(KERN_DEBUG "%s: %s: 0x%02x\n", drive->name, __func__,
191 drive->special_flags);
192#endif
193 if (drive->media != ide_disk) {
194 drive->special_flags = 0;
195 drive->mult_req = 0;
196 return ide_stopped;
197 }
198
199 memset(&cmd, 0, sizeof(cmd));
200 cmd.protocol = ATA_PROT_NODATA;
201
202 if (drive->special_flags & IDE_SFLAG_SET_GEOMETRY) {
203 drive->special_flags &= ~IDE_SFLAG_SET_GEOMETRY;
204 ide_tf_set_specify_cmd(drive, &cmd.tf);
205 } else if (drive->special_flags & IDE_SFLAG_RECALIBRATE) {
206 drive->special_flags &= ~IDE_SFLAG_RECALIBRATE;
207 ide_tf_set_restore_cmd(drive, &cmd.tf);
208 } else if (drive->special_flags & IDE_SFLAG_SET_MULTMODE) {
209 drive->special_flags &= ~IDE_SFLAG_SET_MULTMODE;
210 ide_tf_set_setmult_cmd(drive, &cmd.tf);
211 } else
212 BUG();
213
214 cmd.valid.out.tf = IDE_VALID_OUT_TF | IDE_VALID_DEVICE;
215 cmd.valid.in.tf = IDE_VALID_IN_TF | IDE_VALID_DEVICE;
216 cmd.tf_flags = IDE_TFLAG_CUSTOM_HANDLER;
217
218 do_rw_taskfile(drive, &cmd);
219
220 return ide_started;
221}
222
223void ide_map_sg(ide_drive_t *drive, struct ide_cmd *cmd)
224{
225 ide_hwif_t *hwif = drive->hwif;
226 struct scatterlist *sg = hwif->sg_table;
227 struct request *rq = cmd->rq;
228
229 cmd->sg_nents = blk_rq_map_sg(drive->queue, rq, sg);
230}
231EXPORT_SYMBOL_GPL(ide_map_sg);
232
233void ide_init_sg_cmd(struct ide_cmd *cmd, unsigned int nr_bytes)
234{
235 cmd->nbytes = cmd->nleft = nr_bytes;
236 cmd->cursg_ofs = 0;
237 cmd->cursg = NULL;
238}
239EXPORT_SYMBOL_GPL(ide_init_sg_cmd);
240
241
242
243
244
245
246
247
248
249
250
251
252
253static ide_startstop_t execute_drive_cmd (ide_drive_t *drive,
254 struct request *rq)
255{
256 struct ide_cmd *cmd = rq->special;
257
258 if (cmd) {
259 if (cmd->protocol == ATA_PROT_PIO) {
260 ide_init_sg_cmd(cmd, blk_rq_sectors(rq) << 9);
261 ide_map_sg(drive, cmd);
262 }
263
264 return do_rw_taskfile(drive, cmd);
265 }
266
267
268
269
270
271#ifdef DEBUG
272 printk("%s: DRIVE_CMD (null)\n", drive->name);
273#endif
274 rq->errors = 0;
275 ide_complete_rq(drive, 0, blk_rq_bytes(rq));
276
277 return ide_stopped;
278}
279
280static ide_startstop_t ide_special_rq(ide_drive_t *drive, struct request *rq)
281{
282 u8 cmd = rq->cmd[0];
283
284 switch (cmd) {
285 case REQ_PARK_HEADS:
286 case REQ_UNPARK_HEADS:
287 return ide_do_park_unpark(drive, rq);
288 case REQ_DEVSET_EXEC:
289 return ide_do_devset(drive, rq);
290 case REQ_DRIVE_RESET:
291 return ide_do_reset(drive);
292 default:
293 BUG();
294 }
295}
296
297
298
299
300
301
302
303
304
305
306static ide_startstop_t start_request (ide_drive_t *drive, struct request *rq)
307{
308 ide_startstop_t startstop;
309
310 BUG_ON(!blk_rq_started(rq));
311
312#ifdef DEBUG
313 printk("%s: start_request: current=0x%08lx\n",
314 drive->hwif->name, (unsigned long) rq);
315#endif
316
317
318 if (drive->max_failures && (drive->failures > drive->max_failures)) {
319 rq->cmd_flags |= REQ_FAILED;
320 goto kill_rq;
321 }
322
323 if (blk_pm_request(rq))
324 ide_check_pm_state(drive, rq);
325
326 drive->hwif->tp_ops->dev_select(drive);
327 if (ide_wait_stat(&startstop, drive, drive->ready_stat,
328 ATA_BUSY | ATA_DRQ, WAIT_READY)) {
329 printk(KERN_ERR "%s: drive not ready for command\n", drive->name);
330 return startstop;
331 }
332
333 if (drive->special_flags == 0) {
334 struct ide_driver *drv;
335
336
337
338
339
340 if (drive->current_speed == 0xff)
341 ide_config_drive_speed(drive, drive->desired_speed);
342
343 if (rq->cmd_type == REQ_TYPE_ATA_TASKFILE)
344 return execute_drive_cmd(drive, rq);
345 else if (blk_pm_request(rq)) {
346 struct request_pm_state *pm = rq->special;
347#ifdef DEBUG_PM
348 printk("%s: start_power_step(step: %d)\n",
349 drive->name, pm->pm_step);
350#endif
351 startstop = ide_start_power_step(drive, rq);
352 if (startstop == ide_stopped &&
353 pm->pm_step == IDE_PM_COMPLETED)
354 ide_complete_pm_rq(drive, rq);
355 return startstop;
356 } else if (!rq->rq_disk && blk_special_request(rq))
357
358
359
360
361
362
363
364
365 return ide_special_rq(drive, rq);
366
367 drv = *(struct ide_driver **)rq->rq_disk->private_data;
368
369 return drv->do_request(drive, rq, blk_rq_pos(rq));
370 }
371 return do_special(drive);
372kill_rq:
373 ide_kill_rq(drive, rq);
374 return ide_stopped;
375}
376
377
378
379
380
381
382
383
384
385
386void ide_stall_queue (ide_drive_t *drive, unsigned long timeout)
387{
388 if (timeout > WAIT_WORSTCASE)
389 timeout = WAIT_WORSTCASE;
390 drive->sleep = timeout + jiffies;
391 drive->dev_flags |= IDE_DFLAG_SLEEPING;
392}
393EXPORT_SYMBOL(ide_stall_queue);
394
395static inline int ide_lock_port(ide_hwif_t *hwif)
396{
397 if (hwif->busy)
398 return 1;
399
400 hwif->busy = 1;
401
402 return 0;
403}
404
405static inline void ide_unlock_port(ide_hwif_t *hwif)
406{
407 hwif->busy = 0;
408}
409
410static inline int ide_lock_host(struct ide_host *host, ide_hwif_t *hwif)
411{
412 int rc = 0;
413
414 if (host->host_flags & IDE_HFLAG_SERIALIZE) {
415 rc = test_and_set_bit_lock(IDE_HOST_BUSY, &host->host_busy);
416 if (rc == 0) {
417 if (host->get_lock)
418 host->get_lock(ide_intr, hwif);
419 }
420 }
421 return rc;
422}
423
424static inline void ide_unlock_host(struct ide_host *host)
425{
426 if (host->host_flags & IDE_HFLAG_SERIALIZE) {
427 if (host->release_lock)
428 host->release_lock();
429 clear_bit_unlock(IDE_HOST_BUSY, &host->host_busy);
430 }
431}
432
433
434
435
436void do_ide_request(struct request_queue *q)
437{
438 ide_drive_t *drive = q->queuedata;
439 ide_hwif_t *hwif = drive->hwif;
440 struct ide_host *host = hwif->host;
441 struct request *rq = NULL;
442 ide_startstop_t startstop;
443
444
445
446
447
448
449 if (blk_queue_flushing(q))
450
451
452
453
454
455 blk_remove_plug(q);
456
457 spin_unlock_irq(q->queue_lock);
458
459
460 might_sleep();
461
462 if (ide_lock_host(host, hwif))
463 goto plug_device_2;
464
465 spin_lock_irq(&hwif->lock);
466
467 if (!ide_lock_port(hwif)) {
468 ide_hwif_t *prev_port;
469
470 WARN_ON_ONCE(hwif->rq);
471repeat:
472 prev_port = hwif->host->cur_port;
473 if (drive->dev_flags & IDE_DFLAG_SLEEPING &&
474 time_after(drive->sleep, jiffies)) {
475 ide_unlock_port(hwif);
476 goto plug_device;
477 }
478
479 if ((hwif->host->host_flags & IDE_HFLAG_SERIALIZE) &&
480 hwif != prev_port) {
481 ide_drive_t *cur_dev =
482 prev_port ? prev_port->cur_dev : NULL;
483
484
485
486
487
488 if (cur_dev &&
489 (cur_dev->dev_flags & IDE_DFLAG_NIEN_QUIRK) == 0)
490 prev_port->tp_ops->write_devctl(prev_port,
491 ATA_NIEN |
492 ATA_DEVCTL_OBS);
493
494 hwif->host->cur_port = hwif;
495 }
496 hwif->cur_dev = drive;
497 drive->dev_flags &= ~(IDE_DFLAG_SLEEPING | IDE_DFLAG_PARKED);
498
499 spin_unlock_irq(&hwif->lock);
500 spin_lock_irq(q->queue_lock);
501
502
503
504
505 if (!rq)
506 rq = blk_fetch_request(drive->queue);
507
508 spin_unlock_irq(q->queue_lock);
509 spin_lock_irq(&hwif->lock);
510
511 if (!rq) {
512 ide_unlock_port(hwif);
513 goto out;
514 }
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529 if ((drive->dev_flags & IDE_DFLAG_BLOCKED) &&
530 blk_pm_request(rq) == 0 &&
531 (rq->cmd_flags & REQ_PREEMPT) == 0) {
532
533 ide_unlock_port(hwif);
534 goto plug_device;
535 }
536
537 hwif->rq = rq;
538
539 spin_unlock_irq(&hwif->lock);
540 startstop = start_request(drive, rq);
541 spin_lock_irq(&hwif->lock);
542
543 if (startstop == ide_stopped) {
544 rq = hwif->rq;
545 hwif->rq = NULL;
546 goto repeat;
547 }
548 } else
549 goto plug_device;
550out:
551 spin_unlock_irq(&hwif->lock);
552 if (rq == NULL)
553 ide_unlock_host(host);
554 spin_lock_irq(q->queue_lock);
555 return;
556
557plug_device:
558 spin_unlock_irq(&hwif->lock);
559 ide_unlock_host(host);
560plug_device_2:
561 spin_lock_irq(q->queue_lock);
562
563 if (rq)
564 blk_requeue_request(q, rq);
565 if (!elv_queue_empty(q))
566 blk_plug_device(q);
567}
568
569static void ide_requeue_and_plug(ide_drive_t *drive, struct request *rq)
570{
571 struct request_queue *q = drive->queue;
572 unsigned long flags;
573
574 spin_lock_irqsave(q->queue_lock, flags);
575
576 if (rq)
577 blk_requeue_request(q, rq);
578 if (!elv_queue_empty(q))
579 blk_plug_device(q);
580
581 spin_unlock_irqrestore(q->queue_lock, flags);
582}
583
584static int drive_is_ready(ide_drive_t *drive)
585{
586 ide_hwif_t *hwif = drive->hwif;
587 u8 stat = 0;
588
589 if (drive->waiting_for_dma)
590 return hwif->dma_ops->dma_test_irq(drive);
591
592 if (hwif->io_ports.ctl_addr &&
593 (hwif->host_flags & IDE_HFLAG_BROKEN_ALTSTATUS) == 0)
594 stat = hwif->tp_ops->read_altstatus(hwif);
595 else
596
597 stat = hwif->tp_ops->read_status(hwif);
598
599 if (stat & ATA_BUSY)
600
601 return 0;
602
603
604 return 1;
605}
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621void ide_timer_expiry (unsigned long data)
622{
623 ide_hwif_t *hwif = (ide_hwif_t *)data;
624 ide_drive_t *uninitialized_var(drive);
625 ide_handler_t *handler;
626 unsigned long flags;
627 int wait = -1;
628 int plug_device = 0;
629 struct request *uninitialized_var(rq_in_flight);
630
631 spin_lock_irqsave(&hwif->lock, flags);
632
633 handler = hwif->handler;
634
635 if (handler == NULL || hwif->req_gen != hwif->req_gen_timer) {
636
637
638
639
640
641
642 } else {
643 ide_expiry_t *expiry = hwif->expiry;
644 ide_startstop_t startstop = ide_stopped;
645
646 drive = hwif->cur_dev;
647
648 if (expiry) {
649 wait = expiry(drive);
650 if (wait > 0) {
651
652 hwif->timer.expires = jiffies + wait;
653 hwif->req_gen_timer = hwif->req_gen;
654 add_timer(&hwif->timer);
655 spin_unlock_irqrestore(&hwif->lock, flags);
656 return;
657 }
658 }
659 hwif->handler = NULL;
660 hwif->expiry = NULL;
661
662
663
664
665
666 spin_unlock(&hwif->lock);
667
668 disable_irq(hwif->irq);
669
670 local_irq_disable();
671 if (hwif->polling) {
672 startstop = handler(drive);
673 } else if (drive_is_ready(drive)) {
674 if (drive->waiting_for_dma)
675 hwif->dma_ops->dma_lost_irq(drive);
676 if (hwif->port_ops && hwif->port_ops->clear_irq)
677 hwif->port_ops->clear_irq(drive);
678
679 printk(KERN_WARNING "%s: lost interrupt\n",
680 drive->name);
681 startstop = handler(drive);
682 } else {
683 if (drive->waiting_for_dma)
684 startstop = ide_dma_timeout_retry(drive, wait);
685 else
686 startstop = ide_error(drive, "irq timeout",
687 hwif->tp_ops->read_status(hwif));
688 }
689 spin_lock_irq(&hwif->lock);
690 enable_irq(hwif->irq);
691 if (startstop == ide_stopped && hwif->polling == 0) {
692 rq_in_flight = hwif->rq;
693 hwif->rq = NULL;
694 ide_unlock_port(hwif);
695 plug_device = 1;
696 }
697 }
698 spin_unlock_irqrestore(&hwif->lock, flags);
699
700 if (plug_device) {
701 ide_unlock_host(hwif->host);
702 ide_requeue_and_plug(drive, rq_in_flight);
703 }
704}
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735static void unexpected_intr(int irq, ide_hwif_t *hwif)
736{
737 u8 stat = hwif->tp_ops->read_status(hwif);
738
739 if (!OK_STAT(stat, ATA_DRDY, BAD_STAT)) {
740
741 static unsigned long last_msgtime, count;
742 ++count;
743
744 if (time_after(jiffies, last_msgtime + HZ)) {
745 last_msgtime = jiffies;
746 printk(KERN_ERR "%s: unexpected interrupt, "
747 "status=0x%02x, count=%ld\n",
748 hwif->name, stat, count);
749 }
750 }
751}
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778irqreturn_t ide_intr (int irq, void *dev_id)
779{
780 ide_hwif_t *hwif = (ide_hwif_t *)dev_id;
781 struct ide_host *host = hwif->host;
782 ide_drive_t *uninitialized_var(drive);
783 ide_handler_t *handler;
784 unsigned long flags;
785 ide_startstop_t startstop;
786 irqreturn_t irq_ret = IRQ_NONE;
787 int plug_device = 0;
788 struct request *uninitialized_var(rq_in_flight);
789
790 if (host->host_flags & IDE_HFLAG_SERIALIZE) {
791 if (hwif != host->cur_port)
792 goto out_early;
793 }
794
795 spin_lock_irqsave(&hwif->lock, flags);
796
797 if (hwif->port_ops && hwif->port_ops->test_irq &&
798 hwif->port_ops->test_irq(hwif) == 0)
799 goto out;
800
801 handler = hwif->handler;
802
803 if (handler == NULL || hwif->polling) {
804
805
806
807
808
809
810
811
812
813
814
815
816 if ((host->irq_flags & IRQF_SHARED) == 0) {
817
818
819
820
821 unexpected_intr(irq, hwif);
822 } else {
823
824
825
826
827 (void)hwif->tp_ops->read_status(hwif);
828 }
829 goto out;
830 }
831
832 drive = hwif->cur_dev;
833
834 if (!drive_is_ready(drive))
835
836
837
838
839
840
841
842 goto out;
843
844 hwif->handler = NULL;
845 hwif->expiry = NULL;
846 hwif->req_gen++;
847 del_timer(&hwif->timer);
848 spin_unlock(&hwif->lock);
849
850 if (hwif->port_ops && hwif->port_ops->clear_irq)
851 hwif->port_ops->clear_irq(drive);
852
853 if (drive->dev_flags & IDE_DFLAG_UNMASK)
854 local_irq_enable_in_hardirq();
855
856
857 startstop = handler(drive);
858
859 spin_lock_irq(&hwif->lock);
860
861
862
863
864
865
866
867 if (startstop == ide_stopped && hwif->polling == 0) {
868 BUG_ON(hwif->handler);
869 rq_in_flight = hwif->rq;
870 hwif->rq = NULL;
871 ide_unlock_port(hwif);
872 plug_device = 1;
873 }
874 irq_ret = IRQ_HANDLED;
875out:
876 spin_unlock_irqrestore(&hwif->lock, flags);
877out_early:
878 if (plug_device) {
879 ide_unlock_host(hwif->host);
880 ide_requeue_and_plug(drive, rq_in_flight);
881 }
882
883 return irq_ret;
884}
885EXPORT_SYMBOL_GPL(ide_intr);
886
887void ide_pad_transfer(ide_drive_t *drive, int write, int len)
888{
889 ide_hwif_t *hwif = drive->hwif;
890 u8 buf[4] = { 0 };
891
892 while (len > 0) {
893 if (write)
894 hwif->tp_ops->output_data(drive, NULL, buf, min(4, len));
895 else
896 hwif->tp_ops->input_data(drive, NULL, buf, min(4, len));
897 len -= 4;
898 }
899}
900EXPORT_SYMBOL_GPL(ide_pad_transfer);
901