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
28
29
30
31
32
33
34
35#include <linux/kernel.h>
36#include <linux/gfp.h>
37#include <linux/pci.h>
38#include <linux/module.h>
39#include <linux/libata.h>
40#include <linux/highmem.h>
41
42#include "libata.h"
43
44static struct workqueue_struct *ata_sff_wq;
45
46const struct ata_port_operations ata_sff_port_ops = {
47 .inherits = &ata_base_port_ops,
48
49 .qc_prep = ata_noop_qc_prep,
50 .qc_issue = ata_sff_qc_issue,
51 .qc_fill_rtf = ata_sff_qc_fill_rtf,
52
53 .freeze = ata_sff_freeze,
54 .thaw = ata_sff_thaw,
55 .prereset = ata_sff_prereset,
56 .softreset = ata_sff_softreset,
57 .hardreset = sata_sff_hardreset,
58 .postreset = ata_sff_postreset,
59 .error_handler = ata_sff_error_handler,
60
61 .sff_dev_select = ata_sff_dev_select,
62 .sff_check_status = ata_sff_check_status,
63 .sff_tf_load = ata_sff_tf_load,
64 .sff_tf_read = ata_sff_tf_read,
65 .sff_exec_command = ata_sff_exec_command,
66 .sff_data_xfer = ata_sff_data_xfer,
67 .sff_drain_fifo = ata_sff_drain_fifo,
68
69 .lost_interrupt = ata_sff_lost_interrupt,
70};
71EXPORT_SYMBOL_GPL(ata_sff_port_ops);
72
73
74
75
76
77
78
79
80
81
82
83
84u8 ata_sff_check_status(struct ata_port *ap)
85{
86 return ioread8(ap->ioaddr.status_addr);
87}
88EXPORT_SYMBOL_GPL(ata_sff_check_status);
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103static u8 ata_sff_altstatus(struct ata_port *ap)
104{
105 if (ap->ops->sff_check_altstatus)
106 return ap->ops->sff_check_altstatus(ap);
107
108 return ioread8(ap->ioaddr.altstatus_addr);
109}
110
111
112
113
114
115
116
117
118
119
120
121
122
123static u8 ata_sff_irq_status(struct ata_port *ap)
124{
125 u8 status;
126
127 if (ap->ops->sff_check_altstatus || ap->ioaddr.altstatus_addr) {
128 status = ata_sff_altstatus(ap);
129
130 if (status & ATA_BUSY)
131 return status;
132 }
133
134 status = ap->ops->sff_check_status(ap);
135 return status;
136}
137
138
139
140
141
142
143
144
145
146
147
148
149
150static void ata_sff_sync(struct ata_port *ap)
151{
152 if (ap->ops->sff_check_altstatus)
153 ap->ops->sff_check_altstatus(ap);
154 else if (ap->ioaddr.altstatus_addr)
155 ioread8(ap->ioaddr.altstatus_addr);
156}
157
158
159
160
161
162
163
164
165
166
167
168
169
170void ata_sff_pause(struct ata_port *ap)
171{
172 ata_sff_sync(ap);
173 ndelay(400);
174}
175EXPORT_SYMBOL_GPL(ata_sff_pause);
176
177
178
179
180
181
182
183
184
185void ata_sff_dma_pause(struct ata_port *ap)
186{
187 if (ap->ops->sff_check_altstatus || ap->ioaddr.altstatus_addr) {
188
189
190 ata_sff_altstatus(ap);
191 return;
192 }
193
194
195
196 BUG();
197}
198EXPORT_SYMBOL_GPL(ata_sff_dma_pause);
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215int ata_sff_busy_sleep(struct ata_port *ap,
216 unsigned long tmout_pat, unsigned long tmout)
217{
218 unsigned long timer_start, timeout;
219 u8 status;
220
221 status = ata_sff_busy_wait(ap, ATA_BUSY, 300);
222 timer_start = jiffies;
223 timeout = ata_deadline(timer_start, tmout_pat);
224 while (status != 0xff && (status & ATA_BUSY) &&
225 time_before(jiffies, timeout)) {
226 ata_msleep(ap, 50);
227 status = ata_sff_busy_wait(ap, ATA_BUSY, 3);
228 }
229
230 if (status != 0xff && (status & ATA_BUSY))
231 ata_port_warn(ap,
232 "port is slow to respond, please be patient (Status 0x%x)\n",
233 status);
234
235 timeout = ata_deadline(timer_start, tmout);
236 while (status != 0xff && (status & ATA_BUSY) &&
237 time_before(jiffies, timeout)) {
238 ata_msleep(ap, 50);
239 status = ap->ops->sff_check_status(ap);
240 }
241
242 if (status == 0xff)
243 return -ENODEV;
244
245 if (status & ATA_BUSY) {
246 ata_port_err(ap,
247 "port failed to respond (%lu secs, Status 0x%x)\n",
248 DIV_ROUND_UP(tmout, 1000), status);
249 return -EBUSY;
250 }
251
252 return 0;
253}
254EXPORT_SYMBOL_GPL(ata_sff_busy_sleep);
255
256static int ata_sff_check_ready(struct ata_link *link)
257{
258 u8 status = link->ap->ops->sff_check_status(link->ap);
259
260 return ata_check_ready(status);
261}
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277int ata_sff_wait_ready(struct ata_link *link, unsigned long deadline)
278{
279 return ata_wait_ready(link, deadline, ata_sff_check_ready);
280}
281EXPORT_SYMBOL_GPL(ata_sff_wait_ready);
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296static void ata_sff_set_devctl(struct ata_port *ap, u8 ctl)
297{
298 if (ap->ops->sff_set_devctl)
299 ap->ops->sff_set_devctl(ap, ctl);
300 else
301 iowrite8(ctl, ap->ioaddr.ctl_addr);
302}
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318void ata_sff_dev_select(struct ata_port *ap, unsigned int device)
319{
320 u8 tmp;
321
322 if (device == 0)
323 tmp = ATA_DEVICE_OBS;
324 else
325 tmp = ATA_DEVICE_OBS | ATA_DEV1;
326
327 iowrite8(tmp, ap->ioaddr.device_addr);
328 ata_sff_pause(ap);
329}
330EXPORT_SYMBOL_GPL(ata_sff_dev_select);
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350static void ata_dev_select(struct ata_port *ap, unsigned int device,
351 unsigned int wait, unsigned int can_sleep)
352{
353 if (ata_msg_probe(ap))
354 ata_port_info(ap, "ata_dev_select: ENTER, device %u, wait %u\n",
355 device, wait);
356
357 if (wait)
358 ata_wait_idle(ap);
359
360 ap->ops->sff_dev_select(ap, device);
361
362 if (wait) {
363 if (can_sleep && ap->link.device[device].class == ATA_DEV_ATAPI)
364 ata_msleep(ap, 150);
365 ata_wait_idle(ap);
366 }
367}
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382void ata_sff_irq_on(struct ata_port *ap)
383{
384 struct ata_ioports *ioaddr = &ap->ioaddr;
385
386 if (ap->ops->sff_irq_on) {
387 ap->ops->sff_irq_on(ap);
388 return;
389 }
390
391 ap->ctl &= ~ATA_NIEN;
392 ap->last_ctl = ap->ctl;
393
394 if (ap->ops->sff_set_devctl || ioaddr->ctl_addr)
395 ata_sff_set_devctl(ap, ap->ctl);
396 ata_wait_idle(ap);
397
398 if (ap->ops->sff_irq_clear)
399 ap->ops->sff_irq_clear(ap);
400}
401EXPORT_SYMBOL_GPL(ata_sff_irq_on);
402
403
404
405
406
407
408
409
410
411
412
413void ata_sff_tf_load(struct ata_port *ap, const struct ata_taskfile *tf)
414{
415 struct ata_ioports *ioaddr = &ap->ioaddr;
416 unsigned int is_addr = tf->flags & ATA_TFLAG_ISADDR;
417
418 if (tf->ctl != ap->last_ctl) {
419 if (ioaddr->ctl_addr)
420 iowrite8(tf->ctl, ioaddr->ctl_addr);
421 ap->last_ctl = tf->ctl;
422 ata_wait_idle(ap);
423 }
424
425 if (is_addr && (tf->flags & ATA_TFLAG_LBA48)) {
426 WARN_ON_ONCE(!ioaddr->ctl_addr);
427 iowrite8(tf->hob_feature, ioaddr->feature_addr);
428 iowrite8(tf->hob_nsect, ioaddr->nsect_addr);
429 iowrite8(tf->hob_lbal, ioaddr->lbal_addr);
430 iowrite8(tf->hob_lbam, ioaddr->lbam_addr);
431 iowrite8(tf->hob_lbah, ioaddr->lbah_addr);
432 VPRINTK("hob: feat 0x%X nsect 0x%X, lba 0x%X 0x%X 0x%X\n",
433 tf->hob_feature,
434 tf->hob_nsect,
435 tf->hob_lbal,
436 tf->hob_lbam,
437 tf->hob_lbah);
438 }
439
440 if (is_addr) {
441 iowrite8(tf->feature, ioaddr->feature_addr);
442 iowrite8(tf->nsect, ioaddr->nsect_addr);
443 iowrite8(tf->lbal, ioaddr->lbal_addr);
444 iowrite8(tf->lbam, ioaddr->lbam_addr);
445 iowrite8(tf->lbah, ioaddr->lbah_addr);
446 VPRINTK("feat 0x%X nsect 0x%X lba 0x%X 0x%X 0x%X\n",
447 tf->feature,
448 tf->nsect,
449 tf->lbal,
450 tf->lbam,
451 tf->lbah);
452 }
453
454 if (tf->flags & ATA_TFLAG_DEVICE) {
455 iowrite8(tf->device, ioaddr->device_addr);
456 VPRINTK("device 0x%X\n", tf->device);
457 }
458
459 ata_wait_idle(ap);
460}
461EXPORT_SYMBOL_GPL(ata_sff_tf_load);
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476void ata_sff_tf_read(struct ata_port *ap, struct ata_taskfile *tf)
477{
478 struct ata_ioports *ioaddr = &ap->ioaddr;
479
480 tf->command = ata_sff_check_status(ap);
481 tf->feature = ioread8(ioaddr->error_addr);
482 tf->nsect = ioread8(ioaddr->nsect_addr);
483 tf->lbal = ioread8(ioaddr->lbal_addr);
484 tf->lbam = ioread8(ioaddr->lbam_addr);
485 tf->lbah = ioread8(ioaddr->lbah_addr);
486 tf->device = ioread8(ioaddr->device_addr);
487
488 if (tf->flags & ATA_TFLAG_LBA48) {
489 if (likely(ioaddr->ctl_addr)) {
490 iowrite8(tf->ctl | ATA_HOB, ioaddr->ctl_addr);
491 tf->hob_feature = ioread8(ioaddr->error_addr);
492 tf->hob_nsect = ioread8(ioaddr->nsect_addr);
493 tf->hob_lbal = ioread8(ioaddr->lbal_addr);
494 tf->hob_lbam = ioread8(ioaddr->lbam_addr);
495 tf->hob_lbah = ioread8(ioaddr->lbah_addr);
496 iowrite8(tf->ctl, ioaddr->ctl_addr);
497 ap->last_ctl = tf->ctl;
498 } else
499 WARN_ON_ONCE(1);
500 }
501}
502EXPORT_SYMBOL_GPL(ata_sff_tf_read);
503
504
505
506
507
508
509
510
511
512
513
514
515void ata_sff_exec_command(struct ata_port *ap, const struct ata_taskfile *tf)
516{
517 DPRINTK("ata%u: cmd 0x%X\n", ap->print_id, tf->command);
518
519 iowrite8(tf->command, ap->ioaddr.command_addr);
520 ata_sff_pause(ap);
521}
522EXPORT_SYMBOL_GPL(ata_sff_exec_command);
523
524
525
526
527
528
529
530
531
532
533
534
535
536static inline void ata_tf_to_host(struct ata_port *ap,
537 const struct ata_taskfile *tf)
538{
539 ap->ops->sff_tf_load(ap, tf);
540 ap->ops->sff_exec_command(ap, tf);
541}
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558unsigned int ata_sff_data_xfer(struct ata_device *dev, unsigned char *buf,
559 unsigned int buflen, int rw)
560{
561 struct ata_port *ap = dev->link->ap;
562 void __iomem *data_addr = ap->ioaddr.data_addr;
563 unsigned int words = buflen >> 1;
564
565
566 if (rw == READ)
567 ioread16_rep(data_addr, buf, words);
568 else
569 iowrite16_rep(data_addr, buf, words);
570
571
572 if (unlikely(buflen & 0x01)) {
573 unsigned char pad[2] = { };
574
575
576 buf += buflen - 1;
577
578
579
580
581
582 if (rw == READ) {
583 ioread16_rep(data_addr, pad, 1);
584 *buf = pad[0];
585 } else {
586 pad[0] = *buf;
587 iowrite16_rep(data_addr, pad, 1);
588 }
589 words++;
590 }
591
592 return words << 1;
593}
594EXPORT_SYMBOL_GPL(ata_sff_data_xfer);
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613unsigned int ata_sff_data_xfer32(struct ata_device *dev, unsigned char *buf,
614 unsigned int buflen, int rw)
615{
616 struct ata_port *ap = dev->link->ap;
617 void __iomem *data_addr = ap->ioaddr.data_addr;
618 unsigned int words = buflen >> 2;
619 int slop = buflen & 3;
620
621 if (!(ap->pflags & ATA_PFLAG_PIO32))
622 return ata_sff_data_xfer(dev, buf, buflen, rw);
623
624
625 if (rw == READ)
626 ioread32_rep(data_addr, buf, words);
627 else
628 iowrite32_rep(data_addr, buf, words);
629
630
631 if (unlikely(slop)) {
632 unsigned char pad[4] = { };
633
634
635 buf += buflen - slop;
636
637
638
639
640
641 if (rw == READ) {
642 if (slop < 3)
643 ioread16_rep(data_addr, pad, 1);
644 else
645 ioread32_rep(data_addr, pad, 1);
646 memcpy(buf, pad, slop);
647 } else {
648 memcpy(pad, buf, slop);
649 if (slop < 3)
650 iowrite16_rep(data_addr, pad, 1);
651 else
652 iowrite32_rep(data_addr, pad, 1);
653 }
654 }
655 return (buflen + 1) & ~1;
656}
657EXPORT_SYMBOL_GPL(ata_sff_data_xfer32);
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675unsigned int ata_sff_data_xfer_noirq(struct ata_device *dev, unsigned char *buf,
676 unsigned int buflen, int rw)
677{
678 unsigned long flags;
679 unsigned int consumed;
680
681 local_irq_save(flags);
682 consumed = ata_sff_data_xfer32(dev, buf, buflen, rw);
683 local_irq_restore(flags);
684
685 return consumed;
686}
687EXPORT_SYMBOL_GPL(ata_sff_data_xfer_noirq);
688
689
690
691
692
693
694
695
696
697
698static void ata_pio_sector(struct ata_queued_cmd *qc)
699{
700 int do_write = (qc->tf.flags & ATA_TFLAG_WRITE);
701 struct ata_port *ap = qc->ap;
702 struct page *page;
703 unsigned int offset;
704 unsigned char *buf;
705
706 if (qc->curbytes == qc->nbytes - qc->sect_size)
707 ap->hsm_task_state = HSM_ST_LAST;
708
709 page = sg_page(qc->cursg);
710 offset = qc->cursg->offset + qc->cursg_ofs;
711
712
713 page = nth_page(page, (offset >> PAGE_SHIFT));
714 offset %= PAGE_SIZE;
715
716 DPRINTK("data %s\n", qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
717
718 if (PageHighMem(page)) {
719 unsigned long flags;
720
721
722 local_irq_save(flags);
723 buf = kmap_atomic(page);
724
725
726 ap->ops->sff_data_xfer(qc->dev, buf + offset, qc->sect_size,
727 do_write);
728
729 kunmap_atomic(buf);
730 local_irq_restore(flags);
731 } else {
732 buf = page_address(page);
733 ap->ops->sff_data_xfer(qc->dev, buf + offset, qc->sect_size,
734 do_write);
735 }
736
737 if (!do_write && !PageSlab(page))
738 flush_dcache_page(page);
739
740 qc->curbytes += qc->sect_size;
741 qc->cursg_ofs += qc->sect_size;
742
743 if (qc->cursg_ofs == qc->cursg->length) {
744 qc->cursg = sg_next(qc->cursg);
745 qc->cursg_ofs = 0;
746 }
747}
748
749
750
751
752
753
754
755
756
757
758
759static void ata_pio_sectors(struct ata_queued_cmd *qc)
760{
761 if (is_multi_taskfile(&qc->tf)) {
762
763 unsigned int nsect;
764
765 WARN_ON_ONCE(qc->dev->multi_count == 0);
766
767 nsect = min((qc->nbytes - qc->curbytes) / qc->sect_size,
768 qc->dev->multi_count);
769 while (nsect--)
770 ata_pio_sector(qc);
771 } else
772 ata_pio_sector(qc);
773
774 ata_sff_sync(qc->ap);
775}
776
777
778
779
780
781
782
783
784
785
786
787
788static void atapi_send_cdb(struct ata_port *ap, struct ata_queued_cmd *qc)
789{
790
791 DPRINTK("send cdb\n");
792 WARN_ON_ONCE(qc->dev->cdb_len < 12);
793
794 ap->ops->sff_data_xfer(qc->dev, qc->cdb, qc->dev->cdb_len, 1);
795 ata_sff_sync(ap);
796
797
798 switch (qc->tf.protocol) {
799 case ATAPI_PROT_PIO:
800 ap->hsm_task_state = HSM_ST;
801 break;
802 case ATAPI_PROT_NODATA:
803 ap->hsm_task_state = HSM_ST_LAST;
804 break;
805#ifdef CONFIG_ATA_BMDMA
806 case ATAPI_PROT_DMA:
807 ap->hsm_task_state = HSM_ST_LAST;
808
809 ap->ops->bmdma_start(qc);
810 break;
811#endif
812 default:
813 BUG();
814 }
815}
816
817
818
819
820
821
822
823
824
825
826
827
828static int __atapi_pio_bytes(struct ata_queued_cmd *qc, unsigned int bytes)
829{
830 int rw = (qc->tf.flags & ATA_TFLAG_WRITE) ? WRITE : READ;
831 struct ata_port *ap = qc->ap;
832 struct ata_device *dev = qc->dev;
833 struct ata_eh_info *ehi = &dev->link->eh_info;
834 struct scatterlist *sg;
835 struct page *page;
836 unsigned char *buf;
837 unsigned int offset, count, consumed;
838
839next_sg:
840 sg = qc->cursg;
841 if (unlikely(!sg)) {
842 ata_ehi_push_desc(ehi, "unexpected or too much trailing data "
843 "buf=%u cur=%u bytes=%u",
844 qc->nbytes, qc->curbytes, bytes);
845 return -1;
846 }
847
848 page = sg_page(sg);
849 offset = sg->offset + qc->cursg_ofs;
850
851
852 page = nth_page(page, (offset >> PAGE_SHIFT));
853 offset %= PAGE_SIZE;
854
855
856 count = min(sg->length - qc->cursg_ofs, bytes);
857
858
859 count = min(count, (unsigned int)PAGE_SIZE - offset);
860
861 DPRINTK("data %s\n", qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
862
863 if (PageHighMem(page)) {
864 unsigned long flags;
865
866
867 local_irq_save(flags);
868 buf = kmap_atomic(page);
869
870
871 consumed = ap->ops->sff_data_xfer(dev, buf + offset,
872 count, rw);
873
874 kunmap_atomic(buf);
875 local_irq_restore(flags);
876 } else {
877 buf = page_address(page);
878 consumed = ap->ops->sff_data_xfer(dev, buf + offset,
879 count, rw);
880 }
881
882 bytes -= min(bytes, consumed);
883 qc->curbytes += count;
884 qc->cursg_ofs += count;
885
886 if (qc->cursg_ofs == sg->length) {
887 qc->cursg = sg_next(qc->cursg);
888 qc->cursg_ofs = 0;
889 }
890
891
892
893
894
895
896
897 if (bytes)
898 goto next_sg;
899 return 0;
900}
901
902
903
904
905
906
907
908
909
910
911static void atapi_pio_bytes(struct ata_queued_cmd *qc)
912{
913 struct ata_port *ap = qc->ap;
914 struct ata_device *dev = qc->dev;
915 struct ata_eh_info *ehi = &dev->link->eh_info;
916 unsigned int ireason, bc_lo, bc_hi, bytes;
917 int i_write, do_write = (qc->tf.flags & ATA_TFLAG_WRITE) ? 1 : 0;
918
919
920
921
922
923
924
925 ap->ops->sff_tf_read(ap, &qc->result_tf);
926 ireason = qc->result_tf.nsect;
927 bc_lo = qc->result_tf.lbam;
928 bc_hi = qc->result_tf.lbah;
929 bytes = (bc_hi << 8) | bc_lo;
930
931
932 if (unlikely(ireason & ATAPI_COD))
933 goto atapi_check;
934
935
936 i_write = ((ireason & ATAPI_IO) == 0) ? 1 : 0;
937 if (unlikely(do_write != i_write))
938 goto atapi_check;
939
940 if (unlikely(!bytes))
941 goto atapi_check;
942
943 VPRINTK("ata%u: xfering %d bytes\n", ap->print_id, bytes);
944
945 if (unlikely(__atapi_pio_bytes(qc, bytes)))
946 goto err_out;
947 ata_sff_sync(ap);
948
949 return;
950
951 atapi_check:
952 ata_ehi_push_desc(ehi, "ATAPI check failed (ireason=0x%x bytes=%u)",
953 ireason, bytes);
954 err_out:
955 qc->err_mask |= AC_ERR_HSM;
956 ap->hsm_task_state = HSM_ST_ERR;
957}
958
959
960
961
962
963
964
965
966
967static inline int ata_hsm_ok_in_wq(struct ata_port *ap,
968 struct ata_queued_cmd *qc)
969{
970 if (qc->tf.flags & ATA_TFLAG_POLLING)
971 return 1;
972
973 if (ap->hsm_task_state == HSM_ST_FIRST) {
974 if (qc->tf.protocol == ATA_PROT_PIO &&
975 (qc->tf.flags & ATA_TFLAG_WRITE))
976 return 1;
977
978 if (ata_is_atapi(qc->tf.protocol) &&
979 !(qc->dev->flags & ATA_DFLAG_CDB_INTR))
980 return 1;
981 }
982
983 return 0;
984}
985
986
987
988
989
990
991
992
993
994
995
996
997static void ata_hsm_qc_complete(struct ata_queued_cmd *qc, int in_wq)
998{
999 struct ata_port *ap = qc->ap;
1000
1001 if (ap->ops->error_handler) {
1002 if (in_wq) {
1003
1004
1005
1006 qc = ata_qc_from_tag(ap, qc->tag);
1007 if (qc) {
1008 if (likely(!(qc->err_mask & AC_ERR_HSM))) {
1009 ata_sff_irq_on(ap);
1010 ata_qc_complete(qc);
1011 } else
1012 ata_port_freeze(ap);
1013 }
1014 } else {
1015 if (likely(!(qc->err_mask & AC_ERR_HSM)))
1016 ata_qc_complete(qc);
1017 else
1018 ata_port_freeze(ap);
1019 }
1020 } else {
1021 if (in_wq) {
1022 ata_sff_irq_on(ap);
1023 ata_qc_complete(qc);
1024 } else
1025 ata_qc_complete(qc);
1026 }
1027}
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039int ata_sff_hsm_move(struct ata_port *ap, struct ata_queued_cmd *qc,
1040 u8 status, int in_wq)
1041{
1042 struct ata_link *link = qc->dev->link;
1043 struct ata_eh_info *ehi = &link->eh_info;
1044 int poll_next;
1045
1046 lockdep_assert_held(ap->lock);
1047
1048 WARN_ON_ONCE((qc->flags & ATA_QCFLAG_ACTIVE) == 0);
1049
1050
1051
1052
1053
1054 WARN_ON_ONCE(in_wq != ata_hsm_ok_in_wq(ap, qc));
1055
1056fsm_start:
1057 DPRINTK("ata%u: protocol %d task_state %d (dev_stat 0x%X)\n",
1058 ap->print_id, qc->tf.protocol, ap->hsm_task_state, status);
1059
1060 switch (ap->hsm_task_state) {
1061 case HSM_ST_FIRST:
1062
1063
1064
1065
1066
1067
1068 poll_next = (qc->tf.flags & ATA_TFLAG_POLLING);
1069
1070
1071 if (unlikely((status & ATA_DRQ) == 0)) {
1072
1073 if (likely(status & (ATA_ERR | ATA_DF)))
1074
1075 qc->err_mask |= AC_ERR_DEV;
1076 else {
1077
1078 ata_ehi_push_desc(ehi,
1079 "ST_FIRST: !(DRQ|ERR|DF)");
1080 qc->err_mask |= AC_ERR_HSM;
1081 }
1082
1083 ap->hsm_task_state = HSM_ST_ERR;
1084 goto fsm_start;
1085 }
1086
1087
1088
1089
1090
1091
1092
1093 if (unlikely(status & (ATA_ERR | ATA_DF))) {
1094
1095
1096
1097
1098
1099 if (!(qc->dev->horkage & ATA_HORKAGE_STUCK_ERR)) {
1100 ata_ehi_push_desc(ehi, "ST_FIRST: "
1101 "DRQ=1 with device error, "
1102 "dev_stat 0x%X", status);
1103 qc->err_mask |= AC_ERR_HSM;
1104 ap->hsm_task_state = HSM_ST_ERR;
1105 goto fsm_start;
1106 }
1107 }
1108
1109 if (qc->tf.protocol == ATA_PROT_PIO) {
1110
1111
1112
1113
1114
1115
1116
1117
1118 ap->hsm_task_state = HSM_ST;
1119 ata_pio_sectors(qc);
1120 } else
1121
1122 atapi_send_cdb(ap, qc);
1123
1124
1125
1126
1127 break;
1128
1129 case HSM_ST:
1130
1131 if (qc->tf.protocol == ATAPI_PROT_PIO) {
1132
1133 if ((status & ATA_DRQ) == 0) {
1134
1135
1136
1137 ap->hsm_task_state = HSM_ST_LAST;
1138 goto fsm_start;
1139 }
1140
1141
1142
1143
1144
1145
1146
1147 if (unlikely(status & (ATA_ERR | ATA_DF))) {
1148 ata_ehi_push_desc(ehi, "ST-ATAPI: "
1149 "DRQ=1 with device error, "
1150 "dev_stat 0x%X", status);
1151 qc->err_mask |= AC_ERR_HSM;
1152 ap->hsm_task_state = HSM_ST_ERR;
1153 goto fsm_start;
1154 }
1155
1156 atapi_pio_bytes(qc);
1157
1158 if (unlikely(ap->hsm_task_state == HSM_ST_ERR))
1159
1160 goto fsm_start;
1161
1162 } else {
1163
1164 if (unlikely((status & ATA_DRQ) == 0)) {
1165
1166 if (likely(status & (ATA_ERR | ATA_DF))) {
1167
1168 qc->err_mask |= AC_ERR_DEV;
1169
1170
1171
1172
1173
1174 if (qc->dev->horkage &
1175 ATA_HORKAGE_DIAGNOSTIC)
1176 qc->err_mask |=
1177 AC_ERR_NODEV_HINT;
1178 } else {
1179
1180
1181
1182
1183 ata_ehi_push_desc(ehi, "ST-ATA: "
1184 "DRQ=0 without device error, "
1185 "dev_stat 0x%X", status);
1186 qc->err_mask |= AC_ERR_HSM |
1187 AC_ERR_NODEV_HINT;
1188 }
1189
1190 ap->hsm_task_state = HSM_ST_ERR;
1191 goto fsm_start;
1192 }
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204 if (unlikely(status & (ATA_ERR | ATA_DF))) {
1205
1206 qc->err_mask |= AC_ERR_DEV;
1207
1208 if (!(qc->tf.flags & ATA_TFLAG_WRITE)) {
1209 ata_pio_sectors(qc);
1210 status = ata_wait_idle(ap);
1211 }
1212
1213 if (status & (ATA_BUSY | ATA_DRQ)) {
1214 ata_ehi_push_desc(ehi, "ST-ATA: "
1215 "BUSY|DRQ persists on ERR|DF, "
1216 "dev_stat 0x%X", status);
1217 qc->err_mask |= AC_ERR_HSM;
1218 }
1219
1220
1221
1222
1223
1224
1225
1226
1227 if (status == 0x7f)
1228 qc->err_mask |= AC_ERR_NODEV_HINT;
1229
1230
1231
1232
1233
1234 ap->hsm_task_state = HSM_ST_ERR;
1235 goto fsm_start;
1236 }
1237
1238 ata_pio_sectors(qc);
1239
1240 if (ap->hsm_task_state == HSM_ST_LAST &&
1241 (!(qc->tf.flags & ATA_TFLAG_WRITE))) {
1242
1243 status = ata_wait_idle(ap);
1244 goto fsm_start;
1245 }
1246 }
1247
1248 poll_next = 1;
1249 break;
1250
1251 case HSM_ST_LAST:
1252 if (unlikely(!ata_ok(status))) {
1253 qc->err_mask |= __ac_err_mask(status);
1254 ap->hsm_task_state = HSM_ST_ERR;
1255 goto fsm_start;
1256 }
1257
1258
1259 DPRINTK("ata%u: dev %u command complete, drv_stat 0x%x\n",
1260 ap->print_id, qc->dev->devno, status);
1261
1262 WARN_ON_ONCE(qc->err_mask & (AC_ERR_DEV | AC_ERR_HSM));
1263
1264 ap->hsm_task_state = HSM_ST_IDLE;
1265
1266
1267 ata_hsm_qc_complete(qc, in_wq);
1268
1269 poll_next = 0;
1270 break;
1271
1272 case HSM_ST_ERR:
1273 ap->hsm_task_state = HSM_ST_IDLE;
1274
1275
1276 ata_hsm_qc_complete(qc, in_wq);
1277
1278 poll_next = 0;
1279 break;
1280 default:
1281 poll_next = 0;
1282 WARN(true, "ata%d: SFF host state machine in invalid state %d",
1283 ap->print_id, ap->hsm_task_state);
1284 }
1285
1286 return poll_next;
1287}
1288EXPORT_SYMBOL_GPL(ata_sff_hsm_move);
1289
1290void ata_sff_queue_work(struct work_struct *work)
1291{
1292 queue_work(ata_sff_wq, work);
1293}
1294EXPORT_SYMBOL_GPL(ata_sff_queue_work);
1295
1296void ata_sff_queue_delayed_work(struct delayed_work *dwork, unsigned long delay)
1297{
1298 queue_delayed_work(ata_sff_wq, dwork, delay);
1299}
1300EXPORT_SYMBOL_GPL(ata_sff_queue_delayed_work);
1301
1302void ata_sff_queue_pio_task(struct ata_link *link, unsigned long delay)
1303{
1304 struct ata_port *ap = link->ap;
1305
1306 WARN_ON((ap->sff_pio_task_link != NULL) &&
1307 (ap->sff_pio_task_link != link));
1308 ap->sff_pio_task_link = link;
1309
1310
1311 ata_sff_queue_delayed_work(&ap->sff_pio_task, msecs_to_jiffies(delay));
1312}
1313EXPORT_SYMBOL_GPL(ata_sff_queue_pio_task);
1314
1315void ata_sff_flush_pio_task(struct ata_port *ap)
1316{
1317 DPRINTK("ENTER\n");
1318
1319 cancel_delayed_work_sync(&ap->sff_pio_task);
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329 spin_lock_irq(ap->lock);
1330 ap->hsm_task_state = HSM_ST_IDLE;
1331 spin_unlock_irq(ap->lock);
1332
1333 ap->sff_pio_task_link = NULL;
1334
1335 if (ata_msg_ctl(ap))
1336 ata_port_dbg(ap, "%s: EXIT\n", __func__);
1337}
1338
1339static void ata_sff_pio_task(struct work_struct *work)
1340{
1341 struct ata_port *ap =
1342 container_of(work, struct ata_port, sff_pio_task.work);
1343 struct ata_link *link = ap->sff_pio_task_link;
1344 struct ata_queued_cmd *qc;
1345 u8 status;
1346 int poll_next;
1347
1348 spin_lock_irq(ap->lock);
1349
1350 BUG_ON(ap->sff_pio_task_link == NULL);
1351
1352 qc = ata_qc_from_tag(ap, link->active_tag);
1353 if (!qc) {
1354 ap->sff_pio_task_link = NULL;
1355 goto out_unlock;
1356 }
1357
1358fsm_start:
1359 WARN_ON_ONCE(ap->hsm_task_state == HSM_ST_IDLE);
1360
1361
1362
1363
1364
1365
1366
1367
1368 status = ata_sff_busy_wait(ap, ATA_BUSY, 5);
1369 if (status & ATA_BUSY) {
1370 spin_unlock_irq(ap->lock);
1371 ata_msleep(ap, 2);
1372 spin_lock_irq(ap->lock);
1373
1374 status = ata_sff_busy_wait(ap, ATA_BUSY, 10);
1375 if (status & ATA_BUSY) {
1376 ata_sff_queue_pio_task(link, ATA_SHORT_PAUSE);
1377 goto out_unlock;
1378 }
1379 }
1380
1381
1382
1383
1384
1385 ap->sff_pio_task_link = NULL;
1386
1387 poll_next = ata_sff_hsm_move(ap, qc, status, 1);
1388
1389
1390
1391
1392 if (poll_next)
1393 goto fsm_start;
1394out_unlock:
1395 spin_unlock_irq(ap->lock);
1396}
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411unsigned int ata_sff_qc_issue(struct ata_queued_cmd *qc)
1412{
1413 struct ata_port *ap = qc->ap;
1414 struct ata_link *link = qc->dev->link;
1415
1416
1417
1418
1419 if (ap->flags & ATA_FLAG_PIO_POLLING)
1420 qc->tf.flags |= ATA_TFLAG_POLLING;
1421
1422
1423 ata_dev_select(ap, qc->dev->devno, 1, 0);
1424
1425
1426 switch (qc->tf.protocol) {
1427 case ATA_PROT_NODATA:
1428 if (qc->tf.flags & ATA_TFLAG_POLLING)
1429 ata_qc_set_polling(qc);
1430
1431 ata_tf_to_host(ap, &qc->tf);
1432 ap->hsm_task_state = HSM_ST_LAST;
1433
1434 if (qc->tf.flags & ATA_TFLAG_POLLING)
1435 ata_sff_queue_pio_task(link, 0);
1436
1437 break;
1438
1439 case ATA_PROT_PIO:
1440 if (qc->tf.flags & ATA_TFLAG_POLLING)
1441 ata_qc_set_polling(qc);
1442
1443 ata_tf_to_host(ap, &qc->tf);
1444
1445 if (qc->tf.flags & ATA_TFLAG_WRITE) {
1446
1447 ap->hsm_task_state = HSM_ST_FIRST;
1448 ata_sff_queue_pio_task(link, 0);
1449
1450
1451
1452
1453 } else {
1454
1455 ap->hsm_task_state = HSM_ST;
1456
1457 if (qc->tf.flags & ATA_TFLAG_POLLING)
1458 ata_sff_queue_pio_task(link, 0);
1459
1460
1461
1462
1463
1464 }
1465
1466 break;
1467
1468 case ATAPI_PROT_PIO:
1469 case ATAPI_PROT_NODATA:
1470 if (qc->tf.flags & ATA_TFLAG_POLLING)
1471 ata_qc_set_polling(qc);
1472
1473 ata_tf_to_host(ap, &qc->tf);
1474
1475 ap->hsm_task_state = HSM_ST_FIRST;
1476
1477
1478 if ((!(qc->dev->flags & ATA_DFLAG_CDB_INTR)) ||
1479 (qc->tf.flags & ATA_TFLAG_POLLING))
1480 ata_sff_queue_pio_task(link, 0);
1481 break;
1482
1483 default:
1484 WARN_ON_ONCE(1);
1485 return AC_ERR_SYSTEM;
1486 }
1487
1488 return 0;
1489}
1490EXPORT_SYMBOL_GPL(ata_sff_qc_issue);
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505bool ata_sff_qc_fill_rtf(struct ata_queued_cmd *qc)
1506{
1507 qc->ap->ops->sff_tf_read(qc->ap, &qc->result_tf);
1508 return true;
1509}
1510EXPORT_SYMBOL_GPL(ata_sff_qc_fill_rtf);
1511
1512static unsigned int ata_sff_idle_irq(struct ata_port *ap)
1513{
1514 ap->stats.idle_irq++;
1515
1516#ifdef ATA_IRQ_TRAP
1517 if ((ap->stats.idle_irq % 1000) == 0) {
1518 ap->ops->sff_check_status(ap);
1519 if (ap->ops->sff_irq_clear)
1520 ap->ops->sff_irq_clear(ap);
1521 ata_port_warn(ap, "irq trap\n");
1522 return 1;
1523 }
1524#endif
1525 return 0;
1526}
1527
1528static unsigned int __ata_sff_port_intr(struct ata_port *ap,
1529 struct ata_queued_cmd *qc,
1530 bool hsmv_on_idle)
1531{
1532 u8 status;
1533
1534 VPRINTK("ata%u: protocol %d task_state %d\n",
1535 ap->print_id, qc->tf.protocol, ap->hsm_task_state);
1536
1537
1538 switch (ap->hsm_task_state) {
1539 case HSM_ST_FIRST:
1540
1541
1542
1543
1544
1545
1546
1547
1548 if (!(qc->dev->flags & ATA_DFLAG_CDB_INTR))
1549 return ata_sff_idle_irq(ap);
1550 break;
1551 case HSM_ST_IDLE:
1552 return ata_sff_idle_irq(ap);
1553 default:
1554 break;
1555 }
1556
1557
1558 status = ata_sff_irq_status(ap);
1559 if (status & ATA_BUSY) {
1560 if (hsmv_on_idle) {
1561
1562 qc->err_mask |= AC_ERR_HSM;
1563 ap->hsm_task_state = HSM_ST_ERR;
1564 } else
1565 return ata_sff_idle_irq(ap);
1566 }
1567
1568
1569 if (ap->ops->sff_irq_clear)
1570 ap->ops->sff_irq_clear(ap);
1571
1572 ata_sff_hsm_move(ap, qc, status, 0);
1573
1574 return 1;
1575}
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590unsigned int ata_sff_port_intr(struct ata_port *ap, struct ata_queued_cmd *qc)
1591{
1592 return __ata_sff_port_intr(ap, qc, false);
1593}
1594EXPORT_SYMBOL_GPL(ata_sff_port_intr);
1595
1596static inline irqreturn_t __ata_sff_interrupt(int irq, void *dev_instance,
1597 unsigned int (*port_intr)(struct ata_port *, struct ata_queued_cmd *))
1598{
1599 struct ata_host *host = dev_instance;
1600 bool retried = false;
1601 unsigned int i;
1602 unsigned int handled, idle, polling;
1603 unsigned long flags;
1604
1605
1606 spin_lock_irqsave(&host->lock, flags);
1607
1608retry:
1609 handled = idle = polling = 0;
1610 for (i = 0; i < host->n_ports; i++) {
1611 struct ata_port *ap = host->ports[i];
1612 struct ata_queued_cmd *qc;
1613
1614 qc = ata_qc_from_tag(ap, ap->link.active_tag);
1615 if (qc) {
1616 if (!(qc->tf.flags & ATA_TFLAG_POLLING))
1617 handled |= port_intr(ap, qc);
1618 else
1619 polling |= 1 << i;
1620 } else
1621 idle |= 1 << i;
1622 }
1623
1624
1625
1626
1627
1628
1629 if (!handled && !retried) {
1630 bool retry = false;
1631
1632 for (i = 0; i < host->n_ports; i++) {
1633 struct ata_port *ap = host->ports[i];
1634
1635 if (polling & (1 << i))
1636 continue;
1637
1638 if (!ap->ops->sff_irq_check ||
1639 !ap->ops->sff_irq_check(ap))
1640 continue;
1641
1642 if (idle & (1 << i)) {
1643 ap->ops->sff_check_status(ap);
1644 if (ap->ops->sff_irq_clear)
1645 ap->ops->sff_irq_clear(ap);
1646 } else {
1647
1648 if (!(ap->ops->sff_check_status(ap) & ATA_BUSY))
1649 retry |= true;
1650
1651
1652
1653
1654 }
1655 }
1656
1657 if (retry) {
1658 retried = true;
1659 goto retry;
1660 }
1661 }
1662
1663 spin_unlock_irqrestore(&host->lock, flags);
1664
1665 return IRQ_RETVAL(handled);
1666}
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682irqreturn_t ata_sff_interrupt(int irq, void *dev_instance)
1683{
1684 return __ata_sff_interrupt(irq, dev_instance, ata_sff_port_intr);
1685}
1686EXPORT_SYMBOL_GPL(ata_sff_interrupt);
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701void ata_sff_lost_interrupt(struct ata_port *ap)
1702{
1703 u8 status;
1704 struct ata_queued_cmd *qc;
1705
1706
1707 qc = ata_qc_from_tag(ap, ap->link.active_tag);
1708
1709 if (!qc || qc->tf.flags & ATA_TFLAG_POLLING)
1710 return;
1711
1712
1713 status = ata_sff_altstatus(ap);
1714 if (status & ATA_BUSY)
1715 return;
1716
1717
1718
1719 ata_port_warn(ap, "lost interrupt (Status 0x%x)\n",
1720 status);
1721
1722
1723 ata_sff_port_intr(ap, qc);
1724}
1725EXPORT_SYMBOL_GPL(ata_sff_lost_interrupt);
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736void ata_sff_freeze(struct ata_port *ap)
1737{
1738 ap->ctl |= ATA_NIEN;
1739 ap->last_ctl = ap->ctl;
1740
1741 if (ap->ops->sff_set_devctl || ap->ioaddr.ctl_addr)
1742 ata_sff_set_devctl(ap, ap->ctl);
1743
1744
1745
1746
1747
1748 ap->ops->sff_check_status(ap);
1749
1750 if (ap->ops->sff_irq_clear)
1751 ap->ops->sff_irq_clear(ap);
1752}
1753EXPORT_SYMBOL_GPL(ata_sff_freeze);
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764void ata_sff_thaw(struct ata_port *ap)
1765{
1766
1767 ap->ops->sff_check_status(ap);
1768 if (ap->ops->sff_irq_clear)
1769 ap->ops->sff_irq_clear(ap);
1770 ata_sff_irq_on(ap);
1771}
1772EXPORT_SYMBOL_GPL(ata_sff_thaw);
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789int ata_sff_prereset(struct ata_link *link, unsigned long deadline)
1790{
1791 struct ata_eh_context *ehc = &link->eh_context;
1792 int rc;
1793
1794 rc = ata_std_prereset(link, deadline);
1795 if (rc)
1796 return rc;
1797
1798
1799 if (ehc->i.action & ATA_EH_HARDRESET)
1800 return 0;
1801
1802
1803 if (!ata_link_offline(link)) {
1804 rc = ata_sff_wait_ready(link, deadline);
1805 if (rc && rc != -ENODEV) {
1806 ata_link_warn(link,
1807 "device not ready (errno=%d), forcing hardreset\n",
1808 rc);
1809 ehc->i.action |= ATA_EH_HARDRESET;
1810 }
1811 }
1812
1813 return 0;
1814}
1815EXPORT_SYMBOL_GPL(ata_sff_prereset);
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834static unsigned int ata_devchk(struct ata_port *ap, unsigned int device)
1835{
1836 struct ata_ioports *ioaddr = &ap->ioaddr;
1837 u8 nsect, lbal;
1838
1839 ap->ops->sff_dev_select(ap, device);
1840
1841 iowrite8(0x55, ioaddr->nsect_addr);
1842 iowrite8(0xaa, ioaddr->lbal_addr);
1843
1844 iowrite8(0xaa, ioaddr->nsect_addr);
1845 iowrite8(0x55, ioaddr->lbal_addr);
1846
1847 iowrite8(0x55, ioaddr->nsect_addr);
1848 iowrite8(0xaa, ioaddr->lbal_addr);
1849
1850 nsect = ioread8(ioaddr->nsect_addr);
1851 lbal = ioread8(ioaddr->lbal_addr);
1852
1853 if ((nsect == 0x55) && (lbal == 0xaa))
1854 return 1;
1855
1856 return 0;
1857}
1858
1859
1860
1861
1862
1863
1864
1865
1866
1867
1868
1869
1870
1871
1872
1873
1874
1875
1876
1877
1878
1879
1880unsigned int ata_sff_dev_classify(struct ata_device *dev, int present,
1881 u8 *r_err)
1882{
1883 struct ata_port *ap = dev->link->ap;
1884 struct ata_taskfile tf;
1885 unsigned int class;
1886 u8 err;
1887
1888 ap->ops->sff_dev_select(ap, dev->devno);
1889
1890 memset(&tf, 0, sizeof(tf));
1891
1892 ap->ops->sff_tf_read(ap, &tf);
1893 err = tf.feature;
1894 if (r_err)
1895 *r_err = err;
1896
1897
1898 if (err == 0)
1899
1900 dev->horkage |= ATA_HORKAGE_DIAGNOSTIC;
1901 else if (err == 1)
1902 ;
1903 else if ((dev->devno == 0) && (err == 0x81))
1904 ;
1905 else
1906 return ATA_DEV_NONE;
1907
1908
1909 class = ata_dev_classify(&tf);
1910
1911 if (class == ATA_DEV_UNKNOWN) {
1912
1913
1914
1915
1916
1917
1918 if (present && (dev->horkage & ATA_HORKAGE_DIAGNOSTIC))
1919 class = ATA_DEV_ATA;
1920 else
1921 class = ATA_DEV_NONE;
1922 } else if ((class == ATA_DEV_ATA) &&
1923 (ap->ops->sff_check_status(ap) == 0))
1924 class = ATA_DEV_NONE;
1925
1926 return class;
1927}
1928EXPORT_SYMBOL_GPL(ata_sff_dev_classify);
1929
1930
1931
1932
1933
1934
1935
1936
1937
1938
1939
1940
1941
1942
1943
1944
1945
1946
1947int ata_sff_wait_after_reset(struct ata_link *link, unsigned int devmask,
1948 unsigned long deadline)
1949{
1950 struct ata_port *ap = link->ap;
1951 struct ata_ioports *ioaddr = &ap->ioaddr;
1952 unsigned int dev0 = devmask & (1 << 0);
1953 unsigned int dev1 = devmask & (1 << 1);
1954 int rc, ret = 0;
1955
1956 ata_msleep(ap, ATA_WAIT_AFTER_RESET);
1957
1958
1959 rc = ata_sff_wait_ready(link, deadline);
1960
1961
1962
1963 if (rc)
1964 return rc;
1965
1966
1967
1968
1969 if (dev1) {
1970 int i;
1971
1972 ap->ops->sff_dev_select(ap, 1);
1973
1974
1975
1976
1977
1978 for (i = 0; i < 2; i++) {
1979 u8 nsect, lbal;
1980
1981 nsect = ioread8(ioaddr->nsect_addr);
1982 lbal = ioread8(ioaddr->lbal_addr);
1983 if ((nsect == 1) && (lbal == 1))
1984 break;
1985 ata_msleep(ap, 50);
1986 }
1987
1988 rc = ata_sff_wait_ready(link, deadline);
1989 if (rc) {
1990 if (rc != -ENODEV)
1991 return rc;
1992 ret = rc;
1993 }
1994 }
1995
1996
1997 ap->ops->sff_dev_select(ap, 0);
1998 if (dev1)
1999 ap->ops->sff_dev_select(ap, 1);
2000 if (dev0)
2001 ap->ops->sff_dev_select(ap, 0);
2002
2003 return ret;
2004}
2005EXPORT_SYMBOL_GPL(ata_sff_wait_after_reset);
2006
2007static int ata_bus_softreset(struct ata_port *ap, unsigned int devmask,
2008 unsigned long deadline)
2009{
2010 struct ata_ioports *ioaddr = &ap->ioaddr;
2011
2012 DPRINTK("ata%u: bus reset via SRST\n", ap->print_id);
2013
2014 if (ap->ioaddr.ctl_addr) {
2015
2016 iowrite8(ap->ctl, ioaddr->ctl_addr);
2017 udelay(20);
2018 iowrite8(ap->ctl | ATA_SRST, ioaddr->ctl_addr);
2019 udelay(20);
2020 iowrite8(ap->ctl, ioaddr->ctl_addr);
2021 ap->last_ctl = ap->ctl;
2022 }
2023
2024
2025 return ata_sff_wait_after_reset(&ap->link, devmask, deadline);
2026}
2027
2028
2029
2030
2031
2032
2033
2034
2035
2036
2037
2038
2039
2040
2041
2042int ata_sff_softreset(struct ata_link *link, unsigned int *classes,
2043 unsigned long deadline)
2044{
2045 struct ata_port *ap = link->ap;
2046 unsigned int slave_possible = ap->flags & ATA_FLAG_SLAVE_POSS;
2047 unsigned int devmask = 0;
2048 int rc;
2049 u8 err;
2050
2051 DPRINTK("ENTER\n");
2052
2053
2054 if (ata_devchk(ap, 0))
2055 devmask |= (1 << 0);
2056 if (slave_possible && ata_devchk(ap, 1))
2057 devmask |= (1 << 1);
2058
2059
2060 ap->ops->sff_dev_select(ap, 0);
2061
2062
2063 DPRINTK("about to softreset, devmask=%x\n", devmask);
2064 rc = ata_bus_softreset(ap, devmask, deadline);
2065
2066 if (rc && (rc != -ENODEV || sata_scr_valid(link))) {
2067 ata_link_err(link, "SRST failed (errno=%d)\n", rc);
2068 return rc;
2069 }
2070
2071
2072 classes[0] = ata_sff_dev_classify(&link->device[0],
2073 devmask & (1 << 0), &err);
2074 if (slave_possible && err != 0x81)
2075 classes[1] = ata_sff_dev_classify(&link->device[1],
2076 devmask & (1 << 1), &err);
2077
2078 DPRINTK("EXIT, classes[0]=%u [1]=%u\n", classes[0], classes[1]);
2079 return 0;
2080}
2081EXPORT_SYMBOL_GPL(ata_sff_softreset);
2082
2083
2084
2085
2086
2087
2088
2089
2090
2091
2092
2093
2094
2095
2096
2097
2098int sata_sff_hardreset(struct ata_link *link, unsigned int *class,
2099 unsigned long deadline)
2100{
2101 struct ata_eh_context *ehc = &link->eh_context;
2102 const unsigned long *timing = sata_ehc_deb_timing(ehc);
2103 bool online;
2104 int rc;
2105
2106 rc = sata_link_hardreset(link, timing, deadline, &online,
2107 ata_sff_check_ready);
2108 if (online)
2109 *class = ata_sff_dev_classify(link->device, 1, NULL);
2110
2111 DPRINTK("EXIT, class=%u\n", *class);
2112 return rc;
2113}
2114EXPORT_SYMBOL_GPL(sata_sff_hardreset);
2115
2116
2117
2118
2119
2120
2121
2122
2123
2124
2125
2126
2127
2128void ata_sff_postreset(struct ata_link *link, unsigned int *classes)
2129{
2130 struct ata_port *ap = link->ap;
2131
2132 ata_std_postreset(link, classes);
2133
2134
2135 if (classes[0] != ATA_DEV_NONE)
2136 ap->ops->sff_dev_select(ap, 1);
2137 if (classes[1] != ATA_DEV_NONE)
2138 ap->ops->sff_dev_select(ap, 0);
2139
2140
2141 if (classes[0] == ATA_DEV_NONE && classes[1] == ATA_DEV_NONE) {
2142 DPRINTK("EXIT, no device\n");
2143 return;
2144 }
2145
2146
2147 if (ap->ops->sff_set_devctl || ap->ioaddr.ctl_addr) {
2148 ata_sff_set_devctl(ap, ap->ctl);
2149 ap->last_ctl = ap->ctl;
2150 }
2151}
2152EXPORT_SYMBOL_GPL(ata_sff_postreset);
2153
2154
2155
2156
2157
2158
2159
2160
2161
2162
2163
2164void ata_sff_drain_fifo(struct ata_queued_cmd *qc)
2165{
2166 int count;
2167 struct ata_port *ap;
2168
2169
2170 if (qc == NULL || qc->dma_dir == DMA_TO_DEVICE)
2171 return;
2172
2173 ap = qc->ap;
2174
2175 for (count = 0; (ap->ops->sff_check_status(ap) & ATA_DRQ)
2176 && count < 65536; count += 2)
2177 ioread16(ap->ioaddr.data_addr);
2178
2179
2180 if (count)
2181 ata_port_dbg(ap, "drained %d bytes to clear DRQ\n", count);
2182
2183}
2184EXPORT_SYMBOL_GPL(ata_sff_drain_fifo);
2185
2186
2187
2188
2189
2190
2191
2192
2193
2194
2195
2196
2197
2198void ata_sff_error_handler(struct ata_port *ap)
2199{
2200 ata_reset_fn_t softreset = ap->ops->softreset;
2201 ata_reset_fn_t hardreset = ap->ops->hardreset;
2202 struct ata_queued_cmd *qc;
2203 unsigned long flags;
2204
2205 qc = __ata_qc_from_tag(ap, ap->link.active_tag);
2206 if (qc && !(qc->flags & ATA_QCFLAG_FAILED))
2207 qc = NULL;
2208
2209 spin_lock_irqsave(ap->lock, flags);
2210
2211
2212
2213
2214
2215
2216
2217
2218 if (ap->ops->sff_drain_fifo)
2219 ap->ops->sff_drain_fifo(qc);
2220
2221 spin_unlock_irqrestore(ap->lock, flags);
2222
2223
2224 if ((hardreset == sata_std_hardreset ||
2225 hardreset == sata_sff_hardreset) && !sata_scr_valid(&ap->link))
2226 hardreset = NULL;
2227
2228 ata_do_eh(ap, ap->ops->prereset, softreset, hardreset,
2229 ap->ops->postreset);
2230}
2231EXPORT_SYMBOL_GPL(ata_sff_error_handler);
2232
2233
2234
2235
2236
2237
2238
2239
2240
2241
2242
2243
2244void ata_sff_std_ports(struct ata_ioports *ioaddr)
2245{
2246 ioaddr->data_addr = ioaddr->cmd_addr + ATA_REG_DATA;
2247 ioaddr->error_addr = ioaddr->cmd_addr + ATA_REG_ERR;
2248 ioaddr->feature_addr = ioaddr->cmd_addr + ATA_REG_FEATURE;
2249 ioaddr->nsect_addr = ioaddr->cmd_addr + ATA_REG_NSECT;
2250 ioaddr->lbal_addr = ioaddr->cmd_addr + ATA_REG_LBAL;
2251 ioaddr->lbam_addr = ioaddr->cmd_addr + ATA_REG_LBAM;
2252 ioaddr->lbah_addr = ioaddr->cmd_addr + ATA_REG_LBAH;
2253 ioaddr->device_addr = ioaddr->cmd_addr + ATA_REG_DEVICE;
2254 ioaddr->status_addr = ioaddr->cmd_addr + ATA_REG_STATUS;
2255 ioaddr->command_addr = ioaddr->cmd_addr + ATA_REG_CMD;
2256}
2257EXPORT_SYMBOL_GPL(ata_sff_std_ports);
2258
2259#ifdef CONFIG_PCI
2260
2261static int ata_resources_present(struct pci_dev *pdev, int port)
2262{
2263 int i;
2264
2265
2266 port = port * 2;
2267 for (i = 0; i < 2; i++) {
2268 if (pci_resource_start(pdev, port + i) == 0 ||
2269 pci_resource_len(pdev, port + i) == 0)
2270 return 0;
2271 }
2272 return 1;
2273}
2274
2275
2276
2277
2278
2279
2280
2281
2282
2283
2284
2285
2286
2287
2288
2289
2290
2291
2292
2293
2294int ata_pci_sff_init_host(struct ata_host *host)
2295{
2296 struct device *gdev = host->dev;
2297 struct pci_dev *pdev = to_pci_dev(gdev);
2298 unsigned int mask = 0;
2299 int i, rc;
2300
2301
2302 for (i = 0; i < 2; i++) {
2303 struct ata_port *ap = host->ports[i];
2304 int base = i * 2;
2305 void __iomem * const *iomap;
2306
2307 if (ata_port_is_dummy(ap))
2308 continue;
2309
2310
2311
2312
2313
2314 if (!ata_resources_present(pdev, i)) {
2315 ap->ops = &ata_dummy_port_ops;
2316 continue;
2317 }
2318
2319 rc = pcim_iomap_regions(pdev, 0x3 << base,
2320 dev_driver_string(gdev));
2321 if (rc) {
2322 dev_warn(gdev,
2323 "failed to request/iomap BARs for port %d (errno=%d)\n",
2324 i, rc);
2325 if (rc == -EBUSY)
2326 pcim_pin_device(pdev);
2327 ap->ops = &ata_dummy_port_ops;
2328 continue;
2329 }
2330 host->iomap = iomap = pcim_iomap_table(pdev);
2331
2332 ap->ioaddr.cmd_addr = iomap[base];
2333 ap->ioaddr.altstatus_addr =
2334 ap->ioaddr.ctl_addr = (void __iomem *)
2335 ((unsigned long)iomap[base + 1] | ATA_PCI_CTL_OFS);
2336 ata_sff_std_ports(&ap->ioaddr);
2337
2338 ata_port_desc(ap, "cmd 0x%llx ctl 0x%llx",
2339 (unsigned long long)pci_resource_start(pdev, base),
2340 (unsigned long long)pci_resource_start(pdev, base + 1));
2341
2342 mask |= 1 << i;
2343 }
2344
2345 if (!mask) {
2346 dev_err(gdev, "no available native port\n");
2347 return -ENODEV;
2348 }
2349
2350 return 0;
2351}
2352EXPORT_SYMBOL_GPL(ata_pci_sff_init_host);
2353
2354
2355
2356
2357
2358
2359
2360
2361
2362
2363
2364
2365
2366
2367
2368
2369int ata_pci_sff_prepare_host(struct pci_dev *pdev,
2370 const struct ata_port_info * const *ppi,
2371 struct ata_host **r_host)
2372{
2373 struct ata_host *host;
2374 int rc;
2375
2376 if (!devres_open_group(&pdev->dev, NULL, GFP_KERNEL))
2377 return -ENOMEM;
2378
2379 host = ata_host_alloc_pinfo(&pdev->dev, ppi, 2);
2380 if (!host) {
2381 dev_err(&pdev->dev, "failed to allocate ATA host\n");
2382 rc = -ENOMEM;
2383 goto err_out;
2384 }
2385
2386 rc = ata_pci_sff_init_host(host);
2387 if (rc)
2388 goto err_out;
2389
2390 devres_remove_group(&pdev->dev, NULL);
2391 *r_host = host;
2392 return 0;
2393
2394err_out:
2395 devres_release_group(&pdev->dev, NULL);
2396 return rc;
2397}
2398EXPORT_SYMBOL_GPL(ata_pci_sff_prepare_host);
2399
2400
2401
2402
2403
2404
2405
2406
2407
2408
2409
2410
2411
2412
2413
2414
2415
2416int ata_pci_sff_activate_host(struct ata_host *host,
2417 irq_handler_t irq_handler,
2418 struct scsi_host_template *sht)
2419{
2420 struct device *dev = host->dev;
2421 struct pci_dev *pdev = to_pci_dev(dev);
2422 const char *drv_name = dev_driver_string(host->dev);
2423 int legacy_mode = 0, rc;
2424
2425 rc = ata_host_start(host);
2426 if (rc)
2427 return rc;
2428
2429 if ((pdev->class >> 8) == PCI_CLASS_STORAGE_IDE) {
2430 u8 tmp8, mask;
2431
2432
2433 pci_read_config_byte(pdev, PCI_CLASS_PROG, &tmp8);
2434 mask = (1 << 2) | (1 << 0);
2435 if ((tmp8 & mask) != mask)
2436 legacy_mode = 1;
2437 }
2438
2439 if (!devres_open_group(dev, NULL, GFP_KERNEL))
2440 return -ENOMEM;
2441
2442 if (!legacy_mode && pdev->irq) {
2443 int i;
2444
2445 rc = devm_request_irq(dev, pdev->irq, irq_handler,
2446 IRQF_SHARED, drv_name, host);
2447 if (rc)
2448 goto out;
2449
2450 for (i = 0; i < 2; i++) {
2451 if (ata_port_is_dummy(host->ports[i]))
2452 continue;
2453 ata_port_desc(host->ports[i], "irq %d", pdev->irq);
2454 }
2455 } else if (legacy_mode) {
2456 if (!ata_port_is_dummy(host->ports[0])) {
2457 rc = devm_request_irq(dev, ATA_PRIMARY_IRQ(pdev),
2458 irq_handler, IRQF_SHARED,
2459 drv_name, host);
2460 if (rc)
2461 goto out;
2462
2463 ata_port_desc(host->ports[0], "irq %d",
2464 ATA_PRIMARY_IRQ(pdev));
2465 }
2466
2467 if (!ata_port_is_dummy(host->ports[1])) {
2468 rc = devm_request_irq(dev, ATA_SECONDARY_IRQ(pdev),
2469 irq_handler, IRQF_SHARED,
2470 drv_name, host);
2471 if (rc)
2472 goto out;
2473
2474 ata_port_desc(host->ports[1], "irq %d",
2475 ATA_SECONDARY_IRQ(pdev));
2476 }
2477 }
2478
2479 rc = ata_host_register(host, sht);
2480out:
2481 if (rc == 0)
2482 devres_remove_group(dev, NULL);
2483 else
2484 devres_release_group(dev, NULL);
2485
2486 return rc;
2487}
2488EXPORT_SYMBOL_GPL(ata_pci_sff_activate_host);
2489
2490static const struct ata_port_info *ata_sff_find_valid_pi(
2491 const struct ata_port_info * const *ppi)
2492{
2493 int i;
2494
2495
2496 for (i = 0; i < 2 && ppi[i]; i++)
2497 if (ppi[i]->port_ops != &ata_dummy_port_ops)
2498 return ppi[i];
2499
2500 return NULL;
2501}
2502
2503static int ata_pci_init_one(struct pci_dev *pdev,
2504 const struct ata_port_info * const *ppi,
2505 struct scsi_host_template *sht, void *host_priv,
2506 int hflags, bool bmdma)
2507{
2508 struct device *dev = &pdev->dev;
2509 const struct ata_port_info *pi;
2510 struct ata_host *host = NULL;
2511 int rc;
2512
2513 DPRINTK("ENTER\n");
2514
2515 pi = ata_sff_find_valid_pi(ppi);
2516 if (!pi) {
2517 dev_err(&pdev->dev, "no valid port_info specified\n");
2518 return -EINVAL;
2519 }
2520
2521 if (!devres_open_group(dev, NULL, GFP_KERNEL))
2522 return -ENOMEM;
2523
2524 rc = pcim_enable_device(pdev);
2525 if (rc)
2526 goto out;
2527
2528#ifdef CONFIG_ATA_BMDMA
2529 if (bmdma)
2530
2531 rc = ata_pci_bmdma_prepare_host(pdev, ppi, &host);
2532 else
2533#endif
2534
2535 rc = ata_pci_sff_prepare_host(pdev, ppi, &host);
2536 if (rc)
2537 goto out;
2538 host->private_data = host_priv;
2539 host->flags |= hflags;
2540
2541#ifdef CONFIG_ATA_BMDMA
2542 if (bmdma) {
2543 pci_set_master(pdev);
2544 rc = ata_pci_sff_activate_host(host, ata_bmdma_interrupt, sht);
2545 } else
2546#endif
2547 rc = ata_pci_sff_activate_host(host, ata_sff_interrupt, sht);
2548out:
2549 if (rc == 0)
2550 devres_remove_group(&pdev->dev, NULL);
2551 else
2552 devres_release_group(&pdev->dev, NULL);
2553
2554 return rc;
2555}
2556
2557
2558
2559
2560
2561
2562
2563
2564
2565
2566
2567
2568
2569
2570
2571
2572
2573
2574
2575
2576
2577
2578
2579int ata_pci_sff_init_one(struct pci_dev *pdev,
2580 const struct ata_port_info * const *ppi,
2581 struct scsi_host_template *sht, void *host_priv, int hflag)
2582{
2583 return ata_pci_init_one(pdev, ppi, sht, host_priv, hflag, 0);
2584}
2585EXPORT_SYMBOL_GPL(ata_pci_sff_init_one);
2586
2587#endif
2588
2589
2590
2591
2592
2593#ifdef CONFIG_ATA_BMDMA
2594
2595const struct ata_port_operations ata_bmdma_port_ops = {
2596 .inherits = &ata_sff_port_ops,
2597
2598 .error_handler = ata_bmdma_error_handler,
2599 .post_internal_cmd = ata_bmdma_post_internal_cmd,
2600
2601 .qc_prep = ata_bmdma_qc_prep,
2602 .qc_issue = ata_bmdma_qc_issue,
2603
2604 .sff_irq_clear = ata_bmdma_irq_clear,
2605 .bmdma_setup = ata_bmdma_setup,
2606 .bmdma_start = ata_bmdma_start,
2607 .bmdma_stop = ata_bmdma_stop,
2608 .bmdma_status = ata_bmdma_status,
2609
2610 .port_start = ata_bmdma_port_start,
2611};
2612EXPORT_SYMBOL_GPL(ata_bmdma_port_ops);
2613
2614const struct ata_port_operations ata_bmdma32_port_ops = {
2615 .inherits = &ata_bmdma_port_ops,
2616
2617 .sff_data_xfer = ata_sff_data_xfer32,
2618 .port_start = ata_bmdma_port_start32,
2619};
2620EXPORT_SYMBOL_GPL(ata_bmdma32_port_ops);
2621
2622
2623
2624
2625
2626
2627
2628
2629
2630
2631
2632
2633static void ata_bmdma_fill_sg(struct ata_queued_cmd *qc)
2634{
2635 struct ata_port *ap = qc->ap;
2636 struct ata_bmdma_prd *prd = ap->bmdma_prd;
2637 struct scatterlist *sg;
2638 unsigned int si, pi;
2639
2640 pi = 0;
2641 for_each_sg(qc->sg, sg, qc->n_elem, si) {
2642 u32 addr, offset;
2643 u32 sg_len, len;
2644
2645
2646
2647
2648
2649 addr = (u32) sg_dma_address(sg);
2650 sg_len = sg_dma_len(sg);
2651
2652 while (sg_len) {
2653 offset = addr & 0xffff;
2654 len = sg_len;
2655 if ((offset + sg_len) > 0x10000)
2656 len = 0x10000 - offset;
2657
2658 prd[pi].addr = cpu_to_le32(addr);
2659 prd[pi].flags_len = cpu_to_le32(len & 0xffff);
2660 VPRINTK("PRD[%u] = (0x%X, 0x%X)\n", pi, addr, len);
2661
2662 pi++;
2663 sg_len -= len;
2664 addr += len;
2665 }
2666 }
2667
2668 prd[pi - 1].flags_len |= cpu_to_le32(ATA_PRD_EOT);
2669}
2670
2671
2672
2673
2674
2675
2676
2677
2678
2679
2680
2681
2682
2683
2684static void ata_bmdma_fill_sg_dumb(struct ata_queued_cmd *qc)
2685{
2686 struct ata_port *ap = qc->ap;
2687 struct ata_bmdma_prd *prd = ap->bmdma_prd;
2688 struct scatterlist *sg;
2689 unsigned int si, pi;
2690
2691 pi = 0;
2692 for_each_sg(qc->sg, sg, qc->n_elem, si) {
2693 u32 addr, offset;
2694 u32 sg_len, len, blen;
2695
2696
2697
2698
2699
2700 addr = (u32) sg_dma_address(sg);
2701 sg_len = sg_dma_len(sg);
2702
2703 while (sg_len) {
2704 offset = addr & 0xffff;
2705 len = sg_len;
2706 if ((offset + sg_len) > 0x10000)
2707 len = 0x10000 - offset;
2708
2709 blen = len & 0xffff;
2710 prd[pi].addr = cpu_to_le32(addr);
2711 if (blen == 0) {
2712
2713
2714
2715 prd[pi].flags_len = cpu_to_le32(0x8000);
2716 blen = 0x8000;
2717 prd[++pi].addr = cpu_to_le32(addr + 0x8000);
2718 }
2719 prd[pi].flags_len = cpu_to_le32(blen);
2720 VPRINTK("PRD[%u] = (0x%X, 0x%X)\n", pi, addr, len);
2721
2722 pi++;
2723 sg_len -= len;
2724 addr += len;
2725 }
2726 }
2727
2728 prd[pi - 1].flags_len |= cpu_to_le32(ATA_PRD_EOT);
2729}
2730
2731
2732
2733
2734
2735
2736
2737
2738
2739
2740void ata_bmdma_qc_prep(struct ata_queued_cmd *qc)
2741{
2742 if (!(qc->flags & ATA_QCFLAG_DMAMAP))
2743 return;
2744
2745 ata_bmdma_fill_sg(qc);
2746}
2747EXPORT_SYMBOL_GPL(ata_bmdma_qc_prep);
2748
2749
2750
2751
2752
2753
2754
2755
2756
2757
2758void ata_bmdma_dumb_qc_prep(struct ata_queued_cmd *qc)
2759{
2760 if (!(qc->flags & ATA_QCFLAG_DMAMAP))
2761 return;
2762
2763 ata_bmdma_fill_sg_dumb(qc);
2764}
2765EXPORT_SYMBOL_GPL(ata_bmdma_dumb_qc_prep);
2766
2767
2768
2769
2770
2771
2772
2773
2774
2775
2776
2777
2778
2779
2780
2781unsigned int ata_bmdma_qc_issue(struct ata_queued_cmd *qc)
2782{
2783 struct ata_port *ap = qc->ap;
2784 struct ata_link *link = qc->dev->link;
2785
2786
2787 if (!ata_is_dma(qc->tf.protocol))
2788 return ata_sff_qc_issue(qc);
2789
2790
2791 ata_dev_select(ap, qc->dev->devno, 1, 0);
2792
2793
2794 switch (qc->tf.protocol) {
2795 case ATA_PROT_DMA:
2796 WARN_ON_ONCE(qc->tf.flags & ATA_TFLAG_POLLING);
2797
2798 ap->ops->sff_tf_load(ap, &qc->tf);
2799 ap->ops->bmdma_setup(qc);
2800 ap->ops->bmdma_start(qc);
2801 ap->hsm_task_state = HSM_ST_LAST;
2802 break;
2803
2804 case ATAPI_PROT_DMA:
2805 WARN_ON_ONCE(qc->tf.flags & ATA_TFLAG_POLLING);
2806
2807 ap->ops->sff_tf_load(ap, &qc->tf);
2808 ap->ops->bmdma_setup(qc);
2809 ap->hsm_task_state = HSM_ST_FIRST;
2810
2811
2812 if (!(qc->dev->flags & ATA_DFLAG_CDB_INTR))
2813 ata_sff_queue_pio_task(link, 0);
2814 break;
2815
2816 default:
2817 WARN_ON(1);
2818 return AC_ERR_SYSTEM;
2819 }
2820
2821 return 0;
2822}
2823EXPORT_SYMBOL_GPL(ata_bmdma_qc_issue);
2824
2825
2826
2827
2828
2829
2830
2831
2832
2833
2834
2835
2836
2837
2838unsigned int ata_bmdma_port_intr(struct ata_port *ap, struct ata_queued_cmd *qc)
2839{
2840 struct ata_eh_info *ehi = &ap->link.eh_info;
2841 u8 host_stat = 0;
2842 bool bmdma_stopped = false;
2843 unsigned int handled;
2844
2845 if (ap->hsm_task_state == HSM_ST_LAST && ata_is_dma(qc->tf.protocol)) {
2846
2847 host_stat = ap->ops->bmdma_status(ap);
2848 VPRINTK("ata%u: host_stat 0x%X\n", ap->print_id, host_stat);
2849
2850
2851 if (!(host_stat & ATA_DMA_INTR))
2852 return ata_sff_idle_irq(ap);
2853
2854
2855 ap->ops->bmdma_stop(qc);
2856 bmdma_stopped = true;
2857
2858 if (unlikely(host_stat & ATA_DMA_ERR)) {
2859
2860 qc->err_mask |= AC_ERR_HOST_BUS;
2861 ap->hsm_task_state = HSM_ST_ERR;
2862 }
2863 }
2864
2865 handled = __ata_sff_port_intr(ap, qc, bmdma_stopped);
2866
2867 if (unlikely(qc->err_mask) && ata_is_dma(qc->tf.protocol))
2868 ata_ehi_push_desc(ehi, "BMDMA stat 0x%x", host_stat);
2869
2870 return handled;
2871}
2872EXPORT_SYMBOL_GPL(ata_bmdma_port_intr);
2873
2874
2875
2876
2877
2878
2879
2880
2881
2882
2883
2884
2885
2886
2887
2888irqreturn_t ata_bmdma_interrupt(int irq, void *dev_instance)
2889{
2890 return __ata_sff_interrupt(irq, dev_instance, ata_bmdma_port_intr);
2891}
2892EXPORT_SYMBOL_GPL(ata_bmdma_interrupt);
2893
2894
2895
2896
2897
2898
2899
2900
2901
2902
2903
2904
2905
2906void ata_bmdma_error_handler(struct ata_port *ap)
2907{
2908 struct ata_queued_cmd *qc;
2909 unsigned long flags;
2910 bool thaw = false;
2911
2912 qc = __ata_qc_from_tag(ap, ap->link.active_tag);
2913 if (qc && !(qc->flags & ATA_QCFLAG_FAILED))
2914 qc = NULL;
2915
2916
2917 spin_lock_irqsave(ap->lock, flags);
2918
2919 if (qc && ata_is_dma(qc->tf.protocol)) {
2920 u8 host_stat;
2921
2922 host_stat = ap->ops->bmdma_status(ap);
2923
2924
2925
2926
2927
2928
2929 if (qc->err_mask == AC_ERR_TIMEOUT && (host_stat & ATA_DMA_ERR)) {
2930 qc->err_mask = AC_ERR_HOST_BUS;
2931 thaw = true;
2932 }
2933
2934 ap->ops->bmdma_stop(qc);
2935
2936
2937 if (thaw) {
2938 ap->ops->sff_check_status(ap);
2939 if (ap->ops->sff_irq_clear)
2940 ap->ops->sff_irq_clear(ap);
2941 }
2942 }
2943
2944 spin_unlock_irqrestore(ap->lock, flags);
2945
2946 if (thaw)
2947 ata_eh_thaw_port(ap);
2948
2949 ata_sff_error_handler(ap);
2950}
2951EXPORT_SYMBOL_GPL(ata_bmdma_error_handler);
2952
2953
2954
2955
2956
2957
2958
2959
2960void ata_bmdma_post_internal_cmd(struct ata_queued_cmd *qc)
2961{
2962 struct ata_port *ap = qc->ap;
2963 unsigned long flags;
2964
2965 if (ata_is_dma(qc->tf.protocol)) {
2966 spin_lock_irqsave(ap->lock, flags);
2967 ap->ops->bmdma_stop(qc);
2968 spin_unlock_irqrestore(ap->lock, flags);
2969 }
2970}
2971EXPORT_SYMBOL_GPL(ata_bmdma_post_internal_cmd);
2972
2973
2974
2975
2976
2977
2978
2979
2980
2981
2982
2983
2984void ata_bmdma_irq_clear(struct ata_port *ap)
2985{
2986 void __iomem *mmio = ap->ioaddr.bmdma_addr;
2987
2988 if (!mmio)
2989 return;
2990
2991 iowrite8(ioread8(mmio + ATA_DMA_STATUS), mmio + ATA_DMA_STATUS);
2992}
2993EXPORT_SYMBOL_GPL(ata_bmdma_irq_clear);
2994
2995
2996
2997
2998
2999
3000
3001
3002void ata_bmdma_setup(struct ata_queued_cmd *qc)
3003{
3004 struct ata_port *ap = qc->ap;
3005 unsigned int rw = (qc->tf.flags & ATA_TFLAG_WRITE);
3006 u8 dmactl;
3007
3008
3009 mb();
3010 iowrite32(ap->bmdma_prd_dma, ap->ioaddr.bmdma_addr + ATA_DMA_TABLE_OFS);
3011
3012
3013 dmactl = ioread8(ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
3014 dmactl &= ~(ATA_DMA_WR | ATA_DMA_START);
3015 if (!rw)
3016 dmactl |= ATA_DMA_WR;
3017 iowrite8(dmactl, ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
3018
3019
3020 ap->ops->sff_exec_command(ap, &qc->tf);
3021}
3022EXPORT_SYMBOL_GPL(ata_bmdma_setup);
3023
3024
3025
3026
3027
3028
3029
3030
3031void ata_bmdma_start(struct ata_queued_cmd *qc)
3032{
3033 struct ata_port *ap = qc->ap;
3034 u8 dmactl;
3035
3036
3037 dmactl = ioread8(ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
3038 iowrite8(dmactl | ATA_DMA_START, ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
3039
3040
3041
3042
3043
3044
3045
3046
3047
3048
3049
3050
3051
3052
3053
3054}
3055EXPORT_SYMBOL_GPL(ata_bmdma_start);
3056
3057
3058
3059
3060
3061
3062
3063
3064
3065
3066
3067
3068void ata_bmdma_stop(struct ata_queued_cmd *qc)
3069{
3070 struct ata_port *ap = qc->ap;
3071 void __iomem *mmio = ap->ioaddr.bmdma_addr;
3072
3073
3074 iowrite8(ioread8(mmio + ATA_DMA_CMD) & ~ATA_DMA_START,
3075 mmio + ATA_DMA_CMD);
3076
3077
3078 ata_sff_dma_pause(ap);
3079}
3080EXPORT_SYMBOL_GPL(ata_bmdma_stop);
3081
3082
3083
3084
3085
3086
3087
3088
3089
3090
3091
3092
3093u8 ata_bmdma_status(struct ata_port *ap)
3094{
3095 return ioread8(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
3096}
3097EXPORT_SYMBOL_GPL(ata_bmdma_status);
3098
3099
3100
3101
3102
3103
3104
3105
3106
3107
3108
3109
3110
3111
3112int ata_bmdma_port_start(struct ata_port *ap)
3113{
3114 if (ap->mwdma_mask || ap->udma_mask) {
3115 ap->bmdma_prd =
3116 dmam_alloc_coherent(ap->host->dev, ATA_PRD_TBL_SZ,
3117 &ap->bmdma_prd_dma, GFP_KERNEL);
3118 if (!ap->bmdma_prd)
3119 return -ENOMEM;
3120 }
3121
3122 return 0;
3123}
3124EXPORT_SYMBOL_GPL(ata_bmdma_port_start);
3125
3126
3127
3128
3129
3130
3131
3132
3133
3134
3135
3136
3137
3138
3139
3140int ata_bmdma_port_start32(struct ata_port *ap)
3141{
3142 ap->pflags |= ATA_PFLAG_PIO32 | ATA_PFLAG_PIO32CHANGE;
3143 return ata_bmdma_port_start(ap);
3144}
3145EXPORT_SYMBOL_GPL(ata_bmdma_port_start32);
3146
3147#ifdef CONFIG_PCI
3148
3149
3150
3151
3152
3153
3154
3155
3156
3157
3158int ata_pci_bmdma_clear_simplex(struct pci_dev *pdev)
3159{
3160 unsigned long bmdma = pci_resource_start(pdev, 4);
3161 u8 simplex;
3162
3163 if (bmdma == 0)
3164 return -ENOENT;
3165
3166 simplex = inb(bmdma + 0x02);
3167 outb(simplex & 0x60, bmdma + 0x02);
3168 simplex = inb(bmdma + 0x02);
3169 if (simplex & 0x80)
3170 return -EOPNOTSUPP;
3171 return 0;
3172}
3173EXPORT_SYMBOL_GPL(ata_pci_bmdma_clear_simplex);
3174
3175static void ata_bmdma_nodma(struct ata_host *host, const char *reason)
3176{
3177 int i;
3178
3179 dev_err(host->dev, "BMDMA: %s, falling back to PIO\n", reason);
3180
3181 for (i = 0; i < 2; i++) {
3182 host->ports[i]->mwdma_mask = 0;
3183 host->ports[i]->udma_mask = 0;
3184 }
3185}
3186
3187
3188
3189
3190
3191
3192
3193
3194
3195
3196void ata_pci_bmdma_init(struct ata_host *host)
3197{
3198 struct device *gdev = host->dev;
3199 struct pci_dev *pdev = to_pci_dev(gdev);
3200 int i, rc;
3201
3202
3203 if (pci_resource_start(pdev, 4) == 0) {
3204 ata_bmdma_nodma(host, "BAR4 is zero");
3205 return;
3206 }
3207
3208
3209
3210
3211
3212
3213
3214 rc = dma_set_mask(&pdev->dev, ATA_DMA_MASK);
3215 if (rc)
3216 ata_bmdma_nodma(host, "failed to set dma mask");
3217 if (!rc) {
3218 rc = dma_set_coherent_mask(&pdev->dev, ATA_DMA_MASK);
3219 if (rc)
3220 ata_bmdma_nodma(host,
3221 "failed to set consistent dma mask");
3222 }
3223
3224
3225 rc = pcim_iomap_regions(pdev, 1 << 4, dev_driver_string(gdev));
3226 if (rc) {
3227 ata_bmdma_nodma(host, "failed to request/iomap BAR4");
3228 return;
3229 }
3230 host->iomap = pcim_iomap_table(pdev);
3231
3232 for (i = 0; i < 2; i++) {
3233 struct ata_port *ap = host->ports[i];
3234 void __iomem *bmdma = host->iomap[4] + 8 * i;
3235
3236 if (ata_port_is_dummy(ap))
3237 continue;
3238
3239 ap->ioaddr.bmdma_addr = bmdma;
3240 if ((!(ap->flags & ATA_FLAG_IGN_SIMPLEX)) &&
3241 (ioread8(bmdma + 2) & 0x80))
3242 host->flags |= ATA_HOST_SIMPLEX;
3243
3244 ata_port_desc(ap, "bmdma 0x%llx",
3245 (unsigned long long)pci_resource_start(pdev, 4) + 8 * i);
3246 }
3247}
3248EXPORT_SYMBOL_GPL(ata_pci_bmdma_init);
3249
3250
3251
3252
3253
3254
3255
3256
3257
3258
3259
3260
3261
3262
3263
3264
3265int ata_pci_bmdma_prepare_host(struct pci_dev *pdev,
3266 const struct ata_port_info * const * ppi,
3267 struct ata_host **r_host)
3268{
3269 int rc;
3270
3271 rc = ata_pci_sff_prepare_host(pdev, ppi, r_host);
3272 if (rc)
3273 return rc;
3274
3275 ata_pci_bmdma_init(*r_host);
3276 return 0;
3277}
3278EXPORT_SYMBOL_GPL(ata_pci_bmdma_prepare_host);
3279
3280
3281
3282
3283
3284
3285
3286
3287
3288
3289
3290
3291
3292
3293
3294
3295
3296
3297int ata_pci_bmdma_init_one(struct pci_dev *pdev,
3298 const struct ata_port_info * const * ppi,
3299 struct scsi_host_template *sht, void *host_priv,
3300 int hflags)
3301{
3302 return ata_pci_init_one(pdev, ppi, sht, host_priv, hflags, 1);
3303}
3304EXPORT_SYMBOL_GPL(ata_pci_bmdma_init_one);
3305
3306#endif
3307#endif
3308
3309
3310
3311
3312
3313
3314
3315
3316
3317
3318
3319void ata_sff_port_init(struct ata_port *ap)
3320{
3321 INIT_DELAYED_WORK(&ap->sff_pio_task, ata_sff_pio_task);
3322 ap->ctl = ATA_DEVCTL_OBS;
3323 ap->last_ctl = 0xFF;
3324}
3325
3326int __init ata_sff_init(void)
3327{
3328 ata_sff_wq = alloc_workqueue("ata_sff", WQ_MEM_RECLAIM, WQ_MAX_ACTIVE);
3329 if (!ata_sff_wq)
3330 return -ENOMEM;
3331
3332 return 0;
3333}
3334
3335void ata_sff_exit(void)
3336{
3337 destroy_workqueue(ata_sff_wq);
3338}
3339