blob: ee9b96da841e1b14324a6551f48981be401de854 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 libata-core.c - helper library for ATA
3
4 Copyright 2003-2004 Red Hat, Inc. All rights reserved.
5 Copyright 2003-2004 Jeff Garzik
6
7 The contents of this file are subject to the Open
8 Software License version 1.1 that can be found at
9 http://www.opensource.org/licenses/osl-1.1.txt and is included herein
10 by reference.
11
12 Alternatively, the contents of this file may be used under the terms
13 of the GNU General Public License version 2 (the "GPL") as distributed
14 in the kernel source COPYING file, in which case the provisions of
15 the GPL are applicable instead of the above. If you wish to allow
16 the use of your version of this file only under the terms of the
17 GPL and not to allow others to use your version of this file under
18 the OSL, indicate your decision by deleting the provisions above and
19 replace them with the notice and other provisions required by the GPL.
20 If you do not delete the provisions above, a recipient may use your
21 version of this file under either the OSL or the GPL.
22
23 */
24
25#include <linux/config.h>
26#include <linux/kernel.h>
27#include <linux/module.h>
28#include <linux/pci.h>
29#include <linux/init.h>
30#include <linux/list.h>
31#include <linux/mm.h>
32#include <linux/highmem.h>
33#include <linux/spinlock.h>
34#include <linux/blkdev.h>
35#include <linux/delay.h>
36#include <linux/timer.h>
37#include <linux/interrupt.h>
38#include <linux/completion.h>
39#include <linux/suspend.h>
40#include <linux/workqueue.h>
41#include <scsi/scsi.h>
42#include "scsi.h"
43#include "scsi_priv.h"
44#include <scsi/scsi_host.h>
45#include <linux/libata.h>
46#include <asm/io.h>
47#include <asm/semaphore.h>
48#include <asm/byteorder.h>
49
50#include "libata.h"
51
52static unsigned int ata_busy_sleep (struct ata_port *ap,
53 unsigned long tmout_pat,
54 unsigned long tmout);
55static void ata_set_mode(struct ata_port *ap);
56static void ata_dev_set_xfermode(struct ata_port *ap, struct ata_device *dev);
57static unsigned int ata_get_mode_mask(struct ata_port *ap, int shift);
58static int fgb(u32 bitmap);
59static int ata_choose_xfer_mode(struct ata_port *ap,
60 u8 *xfer_mode_out,
61 unsigned int *xfer_shift_out);
62static int ata_qc_complete_noop(struct ata_queued_cmd *qc, u8 drv_stat);
63static void __ata_qc_complete(struct ata_queued_cmd *qc);
64
65static unsigned int ata_unique_id = 1;
66static struct workqueue_struct *ata_wq;
67
68MODULE_AUTHOR("Jeff Garzik");
69MODULE_DESCRIPTION("Library module for ATA devices");
70MODULE_LICENSE("GPL");
71MODULE_VERSION(DRV_VERSION);
72
73/**
74 * ata_tf_load - send taskfile registers to host controller
75 * @ap: Port to which output is sent
76 * @tf: ATA taskfile register set
77 *
78 * Outputs ATA taskfile to standard ATA host controller.
79 *
80 * LOCKING:
81 * Inherited from caller.
82 */
83
84static void ata_tf_load_pio(struct ata_port *ap, struct ata_taskfile *tf)
85{
86 struct ata_ioports *ioaddr = &ap->ioaddr;
87 unsigned int is_addr = tf->flags & ATA_TFLAG_ISADDR;
88
89 if (tf->ctl != ap->last_ctl) {
90 outb(tf->ctl, ioaddr->ctl_addr);
91 ap->last_ctl = tf->ctl;
92 ata_wait_idle(ap);
93 }
94
95 if (is_addr && (tf->flags & ATA_TFLAG_LBA48)) {
96 outb(tf->hob_feature, ioaddr->feature_addr);
97 outb(tf->hob_nsect, ioaddr->nsect_addr);
98 outb(tf->hob_lbal, ioaddr->lbal_addr);
99 outb(tf->hob_lbam, ioaddr->lbam_addr);
100 outb(tf->hob_lbah, ioaddr->lbah_addr);
101 VPRINTK("hob: feat 0x%X nsect 0x%X, lba 0x%X 0x%X 0x%X\n",
102 tf->hob_feature,
103 tf->hob_nsect,
104 tf->hob_lbal,
105 tf->hob_lbam,
106 tf->hob_lbah);
107 }
108
109 if (is_addr) {
110 outb(tf->feature, ioaddr->feature_addr);
111 outb(tf->nsect, ioaddr->nsect_addr);
112 outb(tf->lbal, ioaddr->lbal_addr);
113 outb(tf->lbam, ioaddr->lbam_addr);
114 outb(tf->lbah, ioaddr->lbah_addr);
115 VPRINTK("feat 0x%X nsect 0x%X lba 0x%X 0x%X 0x%X\n",
116 tf->feature,
117 tf->nsect,
118 tf->lbal,
119 tf->lbam,
120 tf->lbah);
121 }
122
123 if (tf->flags & ATA_TFLAG_DEVICE) {
124 outb(tf->device, ioaddr->device_addr);
125 VPRINTK("device 0x%X\n", tf->device);
126 }
127
128 ata_wait_idle(ap);
129}
130
131/**
132 * ata_tf_load_mmio - send taskfile registers to host controller
133 * @ap: Port to which output is sent
134 * @tf: ATA taskfile register set
135 *
136 * Outputs ATA taskfile to standard ATA host controller using MMIO.
137 *
138 * LOCKING:
139 * Inherited from caller.
140 */
141
142static void ata_tf_load_mmio(struct ata_port *ap, struct ata_taskfile *tf)
143{
144 struct ata_ioports *ioaddr = &ap->ioaddr;
145 unsigned int is_addr = tf->flags & ATA_TFLAG_ISADDR;
146
147 if (tf->ctl != ap->last_ctl) {
148 writeb(tf->ctl, (void __iomem *) ap->ioaddr.ctl_addr);
149 ap->last_ctl = tf->ctl;
150 ata_wait_idle(ap);
151 }
152
153 if (is_addr && (tf->flags & ATA_TFLAG_LBA48)) {
154 writeb(tf->hob_feature, (void __iomem *) ioaddr->feature_addr);
155 writeb(tf->hob_nsect, (void __iomem *) ioaddr->nsect_addr);
156 writeb(tf->hob_lbal, (void __iomem *) ioaddr->lbal_addr);
157 writeb(tf->hob_lbam, (void __iomem *) ioaddr->lbam_addr);
158 writeb(tf->hob_lbah, (void __iomem *) ioaddr->lbah_addr);
159 VPRINTK("hob: feat 0x%X nsect 0x%X, lba 0x%X 0x%X 0x%X\n",
160 tf->hob_feature,
161 tf->hob_nsect,
162 tf->hob_lbal,
163 tf->hob_lbam,
164 tf->hob_lbah);
165 }
166
167 if (is_addr) {
168 writeb(tf->feature, (void __iomem *) ioaddr->feature_addr);
169 writeb(tf->nsect, (void __iomem *) ioaddr->nsect_addr);
170 writeb(tf->lbal, (void __iomem *) ioaddr->lbal_addr);
171 writeb(tf->lbam, (void __iomem *) ioaddr->lbam_addr);
172 writeb(tf->lbah, (void __iomem *) ioaddr->lbah_addr);
173 VPRINTK("feat 0x%X nsect 0x%X lba 0x%X 0x%X 0x%X\n",
174 tf->feature,
175 tf->nsect,
176 tf->lbal,
177 tf->lbam,
178 tf->lbah);
179 }
180
181 if (tf->flags & ATA_TFLAG_DEVICE) {
182 writeb(tf->device, (void __iomem *) ioaddr->device_addr);
183 VPRINTK("device 0x%X\n", tf->device);
184 }
185
186 ata_wait_idle(ap);
187}
188
189void ata_tf_load(struct ata_port *ap, struct ata_taskfile *tf)
190{
191 if (ap->flags & ATA_FLAG_MMIO)
192 ata_tf_load_mmio(ap, tf);
193 else
194 ata_tf_load_pio(ap, tf);
195}
196
197/**
198 * ata_exec_command - issue ATA command to host controller
199 * @ap: port to which command is being issued
200 * @tf: ATA taskfile register set
201 *
202 * Issues PIO/MMIO write to ATA command register, with proper
203 * synchronization with interrupt handler / other threads.
204 *
205 * LOCKING:
206 * spin_lock_irqsave(host_set lock)
207 */
208
209static void ata_exec_command_pio(struct ata_port *ap, struct ata_taskfile *tf)
210{
211 DPRINTK("ata%u: cmd 0x%X\n", ap->id, tf->command);
212
213 outb(tf->command, ap->ioaddr.command_addr);
214 ata_pause(ap);
215}
216
217
218/**
219 * ata_exec_command_mmio - issue ATA command to host controller
220 * @ap: port to which command is being issued
221 * @tf: ATA taskfile register set
222 *
223 * Issues MMIO write to ATA command register, with proper
224 * synchronization with interrupt handler / other threads.
225 *
226 * LOCKING:
227 * spin_lock_irqsave(host_set lock)
228 */
229
230static void ata_exec_command_mmio(struct ata_port *ap, struct ata_taskfile *tf)
231{
232 DPRINTK("ata%u: cmd 0x%X\n", ap->id, tf->command);
233
234 writeb(tf->command, (void __iomem *) ap->ioaddr.command_addr);
235 ata_pause(ap);
236}
237
238void ata_exec_command(struct ata_port *ap, struct ata_taskfile *tf)
239{
240 if (ap->flags & ATA_FLAG_MMIO)
241 ata_exec_command_mmio(ap, tf);
242 else
243 ata_exec_command_pio(ap, tf);
244}
245
246/**
247 * ata_exec - issue ATA command to host controller
248 * @ap: port to which command is being issued
249 * @tf: ATA taskfile register set
250 *
251 * Issues PIO/MMIO write to ATA command register, with proper
252 * synchronization with interrupt handler / other threads.
253 *
254 * LOCKING:
255 * Obtains host_set lock.
256 */
257
258static inline void ata_exec(struct ata_port *ap, struct ata_taskfile *tf)
259{
260 unsigned long flags;
261
262 DPRINTK("ata%u: cmd 0x%X\n", ap->id, tf->command);
263 spin_lock_irqsave(&ap->host_set->lock, flags);
264 ap->ops->exec_command(ap, tf);
265 spin_unlock_irqrestore(&ap->host_set->lock, flags);
266}
267
268/**
269 * ata_tf_to_host - issue ATA taskfile to host controller
270 * @ap: port to which command is being issued
271 * @tf: ATA taskfile register set
272 *
273 * Issues ATA taskfile register set to ATA host controller,
274 * with proper synchronization with interrupt handler and
275 * other threads.
276 *
277 * LOCKING:
278 * Obtains host_set lock.
279 */
280
281static void ata_tf_to_host(struct ata_port *ap, struct ata_taskfile *tf)
282{
283 ap->ops->tf_load(ap, tf);
284
285 ata_exec(ap, tf);
286}
287
288/**
289 * ata_tf_to_host_nolock - issue ATA taskfile to host controller
290 * @ap: port to which command is being issued
291 * @tf: ATA taskfile register set
292 *
293 * Issues ATA taskfile register set to ATA host controller,
294 * with proper synchronization with interrupt handler and
295 * other threads.
296 *
297 * LOCKING:
298 * spin_lock_irqsave(host_set lock)
299 */
300
301void ata_tf_to_host_nolock(struct ata_port *ap, struct ata_taskfile *tf)
302{
303 ap->ops->tf_load(ap, tf);
304 ap->ops->exec_command(ap, tf);
305}
306
307/**
308 * ata_tf_read - input device's ATA taskfile shadow registers
309 * @ap: Port from which input is read
310 * @tf: ATA taskfile register set for storing input
311 *
312 * Reads ATA taskfile registers for currently-selected device
313 * into @tf.
314 *
315 * LOCKING:
316 * Inherited from caller.
317 */
318
319static void ata_tf_read_pio(struct ata_port *ap, struct ata_taskfile *tf)
320{
321 struct ata_ioports *ioaddr = &ap->ioaddr;
322
323 tf->nsect = inb(ioaddr->nsect_addr);
324 tf->lbal = inb(ioaddr->lbal_addr);
325 tf->lbam = inb(ioaddr->lbam_addr);
326 tf->lbah = inb(ioaddr->lbah_addr);
327 tf->device = inb(ioaddr->device_addr);
328
329 if (tf->flags & ATA_TFLAG_LBA48) {
330 outb(tf->ctl | ATA_HOB, ioaddr->ctl_addr);
331 tf->hob_feature = inb(ioaddr->error_addr);
332 tf->hob_nsect = inb(ioaddr->nsect_addr);
333 tf->hob_lbal = inb(ioaddr->lbal_addr);
334 tf->hob_lbam = inb(ioaddr->lbam_addr);
335 tf->hob_lbah = inb(ioaddr->lbah_addr);
336 }
337}
338
339/**
340 * ata_tf_read_mmio - input device's ATA taskfile shadow registers
341 * @ap: Port from which input is read
342 * @tf: ATA taskfile register set for storing input
343 *
344 * Reads ATA taskfile registers for currently-selected device
345 * into @tf via MMIO.
346 *
347 * LOCKING:
348 * Inherited from caller.
349 */
350
351static void ata_tf_read_mmio(struct ata_port *ap, struct ata_taskfile *tf)
352{
353 struct ata_ioports *ioaddr = &ap->ioaddr;
354
355 tf->nsect = readb((void __iomem *)ioaddr->nsect_addr);
356 tf->lbal = readb((void __iomem *)ioaddr->lbal_addr);
357 tf->lbam = readb((void __iomem *)ioaddr->lbam_addr);
358 tf->lbah = readb((void __iomem *)ioaddr->lbah_addr);
359 tf->device = readb((void __iomem *)ioaddr->device_addr);
360
361 if (tf->flags & ATA_TFLAG_LBA48) {
362 writeb(tf->ctl | ATA_HOB, (void __iomem *) ap->ioaddr.ctl_addr);
363 tf->hob_feature = readb((void __iomem *)ioaddr->error_addr);
364 tf->hob_nsect = readb((void __iomem *)ioaddr->nsect_addr);
365 tf->hob_lbal = readb((void __iomem *)ioaddr->lbal_addr);
366 tf->hob_lbam = readb((void __iomem *)ioaddr->lbam_addr);
367 tf->hob_lbah = readb((void __iomem *)ioaddr->lbah_addr);
368 }
369}
370
371void ata_tf_read(struct ata_port *ap, struct ata_taskfile *tf)
372{
373 if (ap->flags & ATA_FLAG_MMIO)
374 ata_tf_read_mmio(ap, tf);
375 else
376 ata_tf_read_pio(ap, tf);
377}
378
379/**
380 * ata_check_status_pio - Read device status reg & clear interrupt
381 * @ap: port where the device is
382 *
383 * Reads ATA taskfile status register for currently-selected device
384 * and return it's value. This also clears pending interrupts
385 * from this device
386 *
387 * LOCKING:
388 * Inherited from caller.
389 */
390static u8 ata_check_status_pio(struct ata_port *ap)
391{
392 return inb(ap->ioaddr.status_addr);
393}
394
395/**
396 * ata_check_status_mmio - Read device status reg & clear interrupt
397 * @ap: port where the device is
398 *
399 * Reads ATA taskfile status register for currently-selected device
400 * via MMIO and return it's value. This also clears pending interrupts
401 * from this device
402 *
403 * LOCKING:
404 * Inherited from caller.
405 */
406static u8 ata_check_status_mmio(struct ata_port *ap)
407{
408 return readb((void __iomem *) ap->ioaddr.status_addr);
409}
410
411u8 ata_check_status(struct ata_port *ap)
412{
413 if (ap->flags & ATA_FLAG_MMIO)
414 return ata_check_status_mmio(ap);
415 return ata_check_status_pio(ap);
416}
417
418u8 ata_altstatus(struct ata_port *ap)
419{
420 if (ap->ops->check_altstatus)
421 return ap->ops->check_altstatus(ap);
422
423 if (ap->flags & ATA_FLAG_MMIO)
424 return readb((void __iomem *)ap->ioaddr.altstatus_addr);
425 return inb(ap->ioaddr.altstatus_addr);
426}
427
428u8 ata_chk_err(struct ata_port *ap)
429{
430 if (ap->ops->check_err)
431 return ap->ops->check_err(ap);
432
433 if (ap->flags & ATA_FLAG_MMIO) {
434 return readb((void __iomem *) ap->ioaddr.error_addr);
435 }
436 return inb(ap->ioaddr.error_addr);
437}
438
439/**
440 * ata_tf_to_fis - Convert ATA taskfile to SATA FIS structure
441 * @tf: Taskfile to convert
442 * @fis: Buffer into which data will output
443 * @pmp: Port multiplier port
444 *
445 * Converts a standard ATA taskfile to a Serial ATA
446 * FIS structure (Register - Host to Device).
447 *
448 * LOCKING:
449 * Inherited from caller.
450 */
451
452void ata_tf_to_fis(struct ata_taskfile *tf, u8 *fis, u8 pmp)
453{
454 fis[0] = 0x27; /* Register - Host to Device FIS */
455 fis[1] = (pmp & 0xf) | (1 << 7); /* Port multiplier number,
456 bit 7 indicates Command FIS */
457 fis[2] = tf->command;
458 fis[3] = tf->feature;
459
460 fis[4] = tf->lbal;
461 fis[5] = tf->lbam;
462 fis[6] = tf->lbah;
463 fis[7] = tf->device;
464
465 fis[8] = tf->hob_lbal;
466 fis[9] = tf->hob_lbam;
467 fis[10] = tf->hob_lbah;
468 fis[11] = tf->hob_feature;
469
470 fis[12] = tf->nsect;
471 fis[13] = tf->hob_nsect;
472 fis[14] = 0;
473 fis[15] = tf->ctl;
474
475 fis[16] = 0;
476 fis[17] = 0;
477 fis[18] = 0;
478 fis[19] = 0;
479}
480
481/**
482 * ata_tf_from_fis - Convert SATA FIS to ATA taskfile
483 * @fis: Buffer from which data will be input
484 * @tf: Taskfile to output
485 *
486 * Converts a standard ATA taskfile to a Serial ATA
487 * FIS structure (Register - Host to Device).
488 *
489 * LOCKING:
490 * Inherited from caller.
491 */
492
493void ata_tf_from_fis(u8 *fis, struct ata_taskfile *tf)
494{
495 tf->command = fis[2]; /* status */
496 tf->feature = fis[3]; /* error */
497
498 tf->lbal = fis[4];
499 tf->lbam = fis[5];
500 tf->lbah = fis[6];
501 tf->device = fis[7];
502
503 tf->hob_lbal = fis[8];
504 tf->hob_lbam = fis[9];
505 tf->hob_lbah = fis[10];
506
507 tf->nsect = fis[12];
508 tf->hob_nsect = fis[13];
509}
510
511/**
512 * ata_prot_to_cmd - determine which read/write opcodes to use
513 * @protocol: ATA_PROT_xxx taskfile protocol
514 * @lba48: true is lba48 is present
515 *
516 * Given necessary input, determine which read/write commands
517 * to use to transfer data.
518 *
519 * LOCKING:
520 * None.
521 */
522static int ata_prot_to_cmd(int protocol, int lba48)
523{
524 int rcmd = 0, wcmd = 0;
525
526 switch (protocol) {
527 case ATA_PROT_PIO:
528 if (lba48) {
529 rcmd = ATA_CMD_PIO_READ_EXT;
530 wcmd = ATA_CMD_PIO_WRITE_EXT;
531 } else {
532 rcmd = ATA_CMD_PIO_READ;
533 wcmd = ATA_CMD_PIO_WRITE;
534 }
535 break;
536
537 case ATA_PROT_DMA:
538 if (lba48) {
539 rcmd = ATA_CMD_READ_EXT;
540 wcmd = ATA_CMD_WRITE_EXT;
541 } else {
542 rcmd = ATA_CMD_READ;
543 wcmd = ATA_CMD_WRITE;
544 }
545 break;
546
547 default:
548 return -1;
549 }
550
551 return rcmd | (wcmd << 8);
552}
553
554/**
555 * ata_dev_set_protocol - set taskfile protocol and r/w commands
556 * @dev: device to examine and configure
557 *
558 * Examine the device configuration, after we have
559 * read the identify-device page and configured the
560 * data transfer mode. Set internal state related to
561 * the ATA taskfile protocol (pio, pio mult, dma, etc.)
562 * and calculate the proper read/write commands to use.
563 *
564 * LOCKING:
565 * caller.
566 */
567static void ata_dev_set_protocol(struct ata_device *dev)
568{
569 int pio = (dev->flags & ATA_DFLAG_PIO);
570 int lba48 = (dev->flags & ATA_DFLAG_LBA48);
571 int proto, cmd;
572
573 if (pio)
574 proto = dev->xfer_protocol = ATA_PROT_PIO;
575 else
576 proto = dev->xfer_protocol = ATA_PROT_DMA;
577
578 cmd = ata_prot_to_cmd(proto, lba48);
579 if (cmd < 0)
580 BUG();
581
582 dev->read_cmd = cmd & 0xff;
583 dev->write_cmd = (cmd >> 8) & 0xff;
584}
585
586static const char * xfer_mode_str[] = {
587 "UDMA/16",
588 "UDMA/25",
589 "UDMA/33",
590 "UDMA/44",
591 "UDMA/66",
592 "UDMA/100",
593 "UDMA/133",
594 "UDMA7",
595 "MWDMA0",
596 "MWDMA1",
597 "MWDMA2",
598 "PIO0",
599 "PIO1",
600 "PIO2",
601 "PIO3",
602 "PIO4",
603};
604
605/**
606 * ata_udma_string - convert UDMA bit offset to string
607 * @mask: mask of bits supported; only highest bit counts.
608 *
609 * Determine string which represents the highest speed
610 * (highest bit in @udma_mask).
611 *
612 * LOCKING:
613 * None.
614 *
615 * RETURNS:
616 * Constant C string representing highest speed listed in
617 * @udma_mask, or the constant C string "<n/a>".
618 */
619
620static const char *ata_mode_string(unsigned int mask)
621{
622 int i;
623
624 for (i = 7; i >= 0; i--)
625 if (mask & (1 << i))
626 goto out;
627 for (i = ATA_SHIFT_MWDMA + 2; i >= ATA_SHIFT_MWDMA; i--)
628 if (mask & (1 << i))
629 goto out;
630 for (i = ATA_SHIFT_PIO + 4; i >= ATA_SHIFT_PIO; i--)
631 if (mask & (1 << i))
632 goto out;
633
634 return "<n/a>";
635
636out:
637 return xfer_mode_str[i];
638}
639
640/**
641 * ata_pio_devchk - PATA device presence detection
642 * @ap: ATA channel to examine
643 * @device: Device to examine (starting at zero)
644 *
645 * This technique was originally described in
646 * Hale Landis's ATADRVR (www.ata-atapi.com), and
647 * later found its way into the ATA/ATAPI spec.
648 *
649 * Write a pattern to the ATA shadow registers,
650 * and if a device is present, it will respond by
651 * correctly storing and echoing back the
652 * ATA shadow register contents.
653 *
654 * LOCKING:
655 * caller.
656 */
657
658static unsigned int ata_pio_devchk(struct ata_port *ap,
659 unsigned int device)
660{
661 struct ata_ioports *ioaddr = &ap->ioaddr;
662 u8 nsect, lbal;
663
664 ap->ops->dev_select(ap, device);
665
666 outb(0x55, ioaddr->nsect_addr);
667 outb(0xaa, ioaddr->lbal_addr);
668
669 outb(0xaa, ioaddr->nsect_addr);
670 outb(0x55, ioaddr->lbal_addr);
671
672 outb(0x55, ioaddr->nsect_addr);
673 outb(0xaa, ioaddr->lbal_addr);
674
675 nsect = inb(ioaddr->nsect_addr);
676 lbal = inb(ioaddr->lbal_addr);
677
678 if ((nsect == 0x55) && (lbal == 0xaa))
679 return 1; /* we found a device */
680
681 return 0; /* nothing found */
682}
683
684/**
685 * ata_mmio_devchk - PATA device presence detection
686 * @ap: ATA channel to examine
687 * @device: Device to examine (starting at zero)
688 *
689 * This technique was originally described in
690 * Hale Landis's ATADRVR (www.ata-atapi.com), and
691 * later found its way into the ATA/ATAPI spec.
692 *
693 * Write a pattern to the ATA shadow registers,
694 * and if a device is present, it will respond by
695 * correctly storing and echoing back the
696 * ATA shadow register contents.
697 *
698 * LOCKING:
699 * caller.
700 */
701
702static unsigned int ata_mmio_devchk(struct ata_port *ap,
703 unsigned int device)
704{
705 struct ata_ioports *ioaddr = &ap->ioaddr;
706 u8 nsect, lbal;
707
708 ap->ops->dev_select(ap, device);
709
710 writeb(0x55, (void __iomem *) ioaddr->nsect_addr);
711 writeb(0xaa, (void __iomem *) ioaddr->lbal_addr);
712
713 writeb(0xaa, (void __iomem *) ioaddr->nsect_addr);
714 writeb(0x55, (void __iomem *) ioaddr->lbal_addr);
715
716 writeb(0x55, (void __iomem *) ioaddr->nsect_addr);
717 writeb(0xaa, (void __iomem *) ioaddr->lbal_addr);
718
719 nsect = readb((void __iomem *) ioaddr->nsect_addr);
720 lbal = readb((void __iomem *) ioaddr->lbal_addr);
721
722 if ((nsect == 0x55) && (lbal == 0xaa))
723 return 1; /* we found a device */
724
725 return 0; /* nothing found */
726}
727
728/**
729 * ata_devchk - PATA device presence detection
730 * @ap: ATA channel to examine
731 * @device: Device to examine (starting at zero)
732 *
733 * Dispatch ATA device presence detection, depending
734 * on whether we are using PIO or MMIO to talk to the
735 * ATA shadow registers.
736 *
737 * LOCKING:
738 * caller.
739 */
740
741static unsigned int ata_devchk(struct ata_port *ap,
742 unsigned int device)
743{
744 if (ap->flags & ATA_FLAG_MMIO)
745 return ata_mmio_devchk(ap, device);
746 return ata_pio_devchk(ap, device);
747}
748
749/**
750 * ata_dev_classify - determine device type based on ATA-spec signature
751 * @tf: ATA taskfile register set for device to be identified
752 *
753 * Determine from taskfile register contents whether a device is
754 * ATA or ATAPI, as per "Signature and persistence" section
755 * of ATA/PI spec (volume 1, sect 5.14).
756 *
757 * LOCKING:
758 * None.
759 *
760 * RETURNS:
761 * Device type, %ATA_DEV_ATA, %ATA_DEV_ATAPI, or %ATA_DEV_UNKNOWN
762 * the event of failure.
763 */
764
765unsigned int ata_dev_classify(struct ata_taskfile *tf)
766{
767 /* Apple's open source Darwin code hints that some devices only
768 * put a proper signature into the LBA mid/high registers,
769 * So, we only check those. It's sufficient for uniqueness.
770 */
771
772 if (((tf->lbam == 0) && (tf->lbah == 0)) ||
773 ((tf->lbam == 0x3c) && (tf->lbah == 0xc3))) {
774 DPRINTK("found ATA device by sig\n");
775 return ATA_DEV_ATA;
776 }
777
778 if (((tf->lbam == 0x14) && (tf->lbah == 0xeb)) ||
779 ((tf->lbam == 0x69) && (tf->lbah == 0x96))) {
780 DPRINTK("found ATAPI device by sig\n");
781 return ATA_DEV_ATAPI;
782 }
783
784 DPRINTK("unknown device\n");
785 return ATA_DEV_UNKNOWN;
786}
787
788/**
789 * ata_dev_try_classify - Parse returned ATA device signature
790 * @ap: ATA channel to examine
791 * @device: Device to examine (starting at zero)
792 *
793 * After an event -- SRST, E.D.D., or SATA COMRESET -- occurs,
794 * an ATA/ATAPI-defined set of values is placed in the ATA
795 * shadow registers, indicating the results of device detection
796 * and diagnostics.
797 *
798 * Select the ATA device, and read the values from the ATA shadow
799 * registers. Then parse according to the Error register value,
800 * and the spec-defined values examined by ata_dev_classify().
801 *
802 * LOCKING:
803 * caller.
804 */
805
806static u8 ata_dev_try_classify(struct ata_port *ap, unsigned int device)
807{
808 struct ata_device *dev = &ap->device[device];
809 struct ata_taskfile tf;
810 unsigned int class;
811 u8 err;
812
813 ap->ops->dev_select(ap, device);
814
815 memset(&tf, 0, sizeof(tf));
816
817 err = ata_chk_err(ap);
818 ap->ops->tf_read(ap, &tf);
819
820 dev->class = ATA_DEV_NONE;
821
822 /* see if device passed diags */
823 if (err == 1)
824 /* do nothing */ ;
825 else if ((device == 0) && (err == 0x81))
826 /* do nothing */ ;
827 else
828 return err;
829
830 /* determine if device if ATA or ATAPI */
831 class = ata_dev_classify(&tf);
832 if (class == ATA_DEV_UNKNOWN)
833 return err;
834 if ((class == ATA_DEV_ATA) && (ata_chk_status(ap) == 0))
835 return err;
836
837 dev->class = class;
838
839 return err;
840}
841
842/**
843 * ata_dev_id_string - Convert IDENTIFY DEVICE page into string
844 * @id: IDENTIFY DEVICE results we will examine
845 * @s: string into which data is output
846 * @ofs: offset into identify device page
847 * @len: length of string to return. must be an even number.
848 *
849 * The strings in the IDENTIFY DEVICE page are broken up into
850 * 16-bit chunks. Run through the string, and output each
851 * 8-bit chunk linearly, regardless of platform.
852 *
853 * LOCKING:
854 * caller.
855 */
856
857void ata_dev_id_string(u16 *id, unsigned char *s,
858 unsigned int ofs, unsigned int len)
859{
860 unsigned int c;
861
862 while (len > 0) {
863 c = id[ofs] >> 8;
864 *s = c;
865 s++;
866
867 c = id[ofs] & 0xff;
868 *s = c;
869 s++;
870
871 ofs++;
872 len -= 2;
873 }
874}
875
876void ata_noop_dev_select (struct ata_port *ap, unsigned int device)
877{
878}
879
880/**
881 * ata_std_dev_select - Select device 0/1 on ATA bus
882 * @ap: ATA channel to manipulate
883 * @device: ATA device (numbered from zero) to select
884 *
885 * Use the method defined in the ATA specification to
886 * make either device 0, or device 1, active on the
887 * ATA channel.
888 *
889 * LOCKING:
890 * caller.
891 */
892
893void ata_std_dev_select (struct ata_port *ap, unsigned int device)
894{
895 u8 tmp;
896
897 if (device == 0)
898 tmp = ATA_DEVICE_OBS;
899 else
900 tmp = ATA_DEVICE_OBS | ATA_DEV1;
901
902 if (ap->flags & ATA_FLAG_MMIO) {
903 writeb(tmp, (void __iomem *) ap->ioaddr.device_addr);
904 } else {
905 outb(tmp, ap->ioaddr.device_addr);
906 }
907 ata_pause(ap); /* needed; also flushes, for mmio */
908}
909
910/**
911 * ata_dev_select - Select device 0/1 on ATA bus
912 * @ap: ATA channel to manipulate
913 * @device: ATA device (numbered from zero) to select
914 * @wait: non-zero to wait for Status register BSY bit to clear
915 * @can_sleep: non-zero if context allows sleeping
916 *
917 * Use the method defined in the ATA specification to
918 * make either device 0, or device 1, active on the
919 * ATA channel.
920 *
921 * This is a high-level version of ata_std_dev_select(),
922 * which additionally provides the services of inserting
923 * the proper pauses and status polling, where needed.
924 *
925 * LOCKING:
926 * caller.
927 */
928
929void ata_dev_select(struct ata_port *ap, unsigned int device,
930 unsigned int wait, unsigned int can_sleep)
931{
932 VPRINTK("ENTER, ata%u: device %u, wait %u\n",
933 ap->id, device, wait);
934
935 if (wait)
936 ata_wait_idle(ap);
937
938 ap->ops->dev_select(ap, device);
939
940 if (wait) {
941 if (can_sleep && ap->device[device].class == ATA_DEV_ATAPI)
942 msleep(150);
943 ata_wait_idle(ap);
944 }
945}
946
947/**
948 * ata_dump_id - IDENTIFY DEVICE info debugging output
949 * @dev: Device whose IDENTIFY DEVICE page we will dump
950 *
951 * Dump selected 16-bit words from a detected device's
952 * IDENTIFY PAGE page.
953 *
954 * LOCKING:
955 * caller.
956 */
957
958static inline void ata_dump_id(struct ata_device *dev)
959{
960 DPRINTK("49==0x%04x "
961 "53==0x%04x "
962 "63==0x%04x "
963 "64==0x%04x "
964 "75==0x%04x \n",
965 dev->id[49],
966 dev->id[53],
967 dev->id[63],
968 dev->id[64],
969 dev->id[75]);
970 DPRINTK("80==0x%04x "
971 "81==0x%04x "
972 "82==0x%04x "
973 "83==0x%04x "
974 "84==0x%04x \n",
975 dev->id[80],
976 dev->id[81],
977 dev->id[82],
978 dev->id[83],
979 dev->id[84]);
980 DPRINTK("88==0x%04x "
981 "93==0x%04x\n",
982 dev->id[88],
983 dev->id[93]);
984}
985
986/**
987 * ata_dev_identify - obtain IDENTIFY x DEVICE page
988 * @ap: port on which device we wish to probe resides
989 * @device: device bus address, starting at zero
990 *
991 * Following bus reset, we issue the IDENTIFY [PACKET] DEVICE
992 * command, and read back the 512-byte device information page.
993 * The device information page is fed to us via the standard
994 * PIO-IN protocol, but we hand-code it here. (TODO: investigate
995 * using standard PIO-IN paths)
996 *
997 * After reading the device information page, we use several
998 * bits of information from it to initialize data structures
999 * that will be used during the lifetime of the ata_device.
1000 * Other data from the info page is used to disqualify certain
1001 * older ATA devices we do not wish to support.
1002 *
1003 * LOCKING:
1004 * Inherited from caller. Some functions called by this function
1005 * obtain the host_set lock.
1006 */
1007
1008static void ata_dev_identify(struct ata_port *ap, unsigned int device)
1009{
1010 struct ata_device *dev = &ap->device[device];
1011 unsigned int i;
1012 u16 tmp;
1013 unsigned long xfer_modes;
1014 u8 status;
1015 unsigned int using_edd;
1016 DECLARE_COMPLETION(wait);
1017 struct ata_queued_cmd *qc;
1018 unsigned long flags;
1019 int rc;
1020
1021 if (!ata_dev_present(dev)) {
1022 DPRINTK("ENTER/EXIT (host %u, dev %u) -- nodev\n",
1023 ap->id, device);
1024 return;
1025 }
1026
1027 if (ap->flags & (ATA_FLAG_SRST | ATA_FLAG_SATA_RESET))
1028 using_edd = 0;
1029 else
1030 using_edd = 1;
1031
1032 DPRINTK("ENTER, host %u, dev %u\n", ap->id, device);
1033
1034 assert (dev->class == ATA_DEV_ATA || dev->class == ATA_DEV_ATAPI ||
1035 dev->class == ATA_DEV_NONE);
1036
1037 ata_dev_select(ap, device, 1, 1); /* select device 0/1 */
1038
1039 qc = ata_qc_new_init(ap, dev);
1040 BUG_ON(qc == NULL);
1041
1042 ata_sg_init_one(qc, dev->id, sizeof(dev->id));
1043 qc->dma_dir = DMA_FROM_DEVICE;
1044 qc->tf.protocol = ATA_PROT_PIO;
1045 qc->nsect = 1;
1046
1047retry:
1048 if (dev->class == ATA_DEV_ATA) {
1049 qc->tf.command = ATA_CMD_ID_ATA;
1050 DPRINTK("do ATA identify\n");
1051 } else {
1052 qc->tf.command = ATA_CMD_ID_ATAPI;
1053 DPRINTK("do ATAPI identify\n");
1054 }
1055
1056 qc->waiting = &wait;
1057 qc->complete_fn = ata_qc_complete_noop;
1058
1059 spin_lock_irqsave(&ap->host_set->lock, flags);
1060 rc = ata_qc_issue(qc);
1061 spin_unlock_irqrestore(&ap->host_set->lock, flags);
1062
1063 if (rc)
1064 goto err_out;
1065 else
1066 wait_for_completion(&wait);
1067
1068 status = ata_chk_status(ap);
1069 if (status & ATA_ERR) {
1070 /*
1071 * arg! EDD works for all test cases, but seems to return
1072 * the ATA signature for some ATAPI devices. Until the
1073 * reason for this is found and fixed, we fix up the mess
1074 * here. If IDENTIFY DEVICE returns command aborted
1075 * (as ATAPI devices do), then we issue an
1076 * IDENTIFY PACKET DEVICE.
1077 *
1078 * ATA software reset (SRST, the default) does not appear
1079 * to have this problem.
1080 */
1081 if ((using_edd) && (qc->tf.command == ATA_CMD_ID_ATA)) {
1082 u8 err = ata_chk_err(ap);
1083 if (err & ATA_ABORTED) {
1084 dev->class = ATA_DEV_ATAPI;
1085 qc->cursg = 0;
1086 qc->cursg_ofs = 0;
1087 qc->cursect = 0;
1088 qc->nsect = 1;
1089 goto retry;
1090 }
1091 }
1092 goto err_out;
1093 }
1094
1095 swap_buf_le16(dev->id, ATA_ID_WORDS);
1096
1097 /* print device capabilities */
1098 printk(KERN_DEBUG "ata%u: dev %u cfg "
1099 "49:%04x 82:%04x 83:%04x 84:%04x 85:%04x 86:%04x 87:%04x 88:%04x\n",
1100 ap->id, device, dev->id[49],
1101 dev->id[82], dev->id[83], dev->id[84],
1102 dev->id[85], dev->id[86], dev->id[87],
1103 dev->id[88]);
1104
1105 /*
1106 * common ATA, ATAPI feature tests
1107 */
1108
1109 /* we require LBA and DMA support (bits 8 & 9 of word 49) */
1110 if (!ata_id_has_dma(dev->id) || !ata_id_has_lba(dev->id)) {
1111 printk(KERN_DEBUG "ata%u: no dma/lba\n", ap->id);
1112 goto err_out_nosup;
1113 }
1114
1115 /* quick-n-dirty find max transfer mode; for printk only */
1116 xfer_modes = dev->id[ATA_ID_UDMA_MODES];
1117 if (!xfer_modes)
1118 xfer_modes = (dev->id[ATA_ID_MWDMA_MODES]) << ATA_SHIFT_MWDMA;
1119 if (!xfer_modes) {
1120 xfer_modes = (dev->id[ATA_ID_PIO_MODES]) << (ATA_SHIFT_PIO + 3);
1121 xfer_modes |= (0x7 << ATA_SHIFT_PIO);
1122 }
1123
1124 ata_dump_id(dev);
1125
1126 /* ATA-specific feature tests */
1127 if (dev->class == ATA_DEV_ATA) {
1128 if (!ata_id_is_ata(dev->id)) /* sanity check */
1129 goto err_out_nosup;
1130
1131 tmp = dev->id[ATA_ID_MAJOR_VER];
1132 for (i = 14; i >= 1; i--)
1133 if (tmp & (1 << i))
1134 break;
1135
1136 /* we require at least ATA-3 */
1137 if (i < 3) {
1138 printk(KERN_DEBUG "ata%u: no ATA-3\n", ap->id);
1139 goto err_out_nosup;
1140 }
1141
1142 if (ata_id_has_lba48(dev->id)) {
1143 dev->flags |= ATA_DFLAG_LBA48;
1144 dev->n_sectors = ata_id_u64(dev->id, 100);
1145 } else {
1146 dev->n_sectors = ata_id_u32(dev->id, 60);
1147 }
1148
1149 ap->host->max_cmd_len = 16;
1150
1151 /* print device info to dmesg */
1152 printk(KERN_INFO "ata%u: dev %u ATA, max %s, %Lu sectors:%s\n",
1153 ap->id, device,
1154 ata_mode_string(xfer_modes),
1155 (unsigned long long)dev->n_sectors,
1156 dev->flags & ATA_DFLAG_LBA48 ? " lba48" : "");
1157 }
1158
1159 /* ATAPI-specific feature tests */
1160 else {
1161 if (ata_id_is_ata(dev->id)) /* sanity check */
1162 goto err_out_nosup;
1163
1164 rc = atapi_cdb_len(dev->id);
1165 if ((rc < 12) || (rc > ATAPI_CDB_LEN)) {
1166 printk(KERN_WARNING "ata%u: unsupported CDB len\n", ap->id);
1167 goto err_out_nosup;
1168 }
1169 ap->cdb_len = (unsigned int) rc;
1170 ap->host->max_cmd_len = (unsigned char) ap->cdb_len;
1171
1172 /* print device info to dmesg */
1173 printk(KERN_INFO "ata%u: dev %u ATAPI, max %s\n",
1174 ap->id, device,
1175 ata_mode_string(xfer_modes));
1176 }
1177
1178 DPRINTK("EXIT, drv_stat = 0x%x\n", ata_chk_status(ap));
1179 return;
1180
1181err_out_nosup:
1182 printk(KERN_WARNING "ata%u: dev %u not supported, ignoring\n",
1183 ap->id, device);
1184err_out:
1185 dev->class++; /* converts ATA_DEV_xxx into ATA_DEV_xxx_UNSUP */
1186 DPRINTK("EXIT, err\n");
1187}
1188
1189/**
1190 * ata_bus_probe - Reset and probe ATA bus
1191 * @ap: Bus to probe
1192 *
1193 * LOCKING:
1194 *
1195 * RETURNS:
1196 * Zero on success, non-zero on error.
1197 */
1198
1199static int ata_bus_probe(struct ata_port *ap)
1200{
1201 unsigned int i, found = 0;
1202
1203 ap->ops->phy_reset(ap);
1204 if (ap->flags & ATA_FLAG_PORT_DISABLED)
1205 goto err_out;
1206
1207 for (i = 0; i < ATA_MAX_DEVICES; i++) {
1208 ata_dev_identify(ap, i);
1209 if (ata_dev_present(&ap->device[i])) {
1210 found = 1;
1211 if (ap->ops->dev_config)
1212 ap->ops->dev_config(ap, &ap->device[i]);
1213 }
1214 }
1215
1216 if ((!found) || (ap->flags & ATA_FLAG_PORT_DISABLED))
1217 goto err_out_disable;
1218
1219 ata_set_mode(ap);
1220 if (ap->flags & ATA_FLAG_PORT_DISABLED)
1221 goto err_out_disable;
1222
1223 return 0;
1224
1225err_out_disable:
1226 ap->ops->port_disable(ap);
1227err_out:
1228 return -1;
1229}
1230
1231/**
1232 * ata_port_probe -
1233 * @ap:
1234 *
1235 * LOCKING:
1236 */
1237
1238void ata_port_probe(struct ata_port *ap)
1239{
1240 ap->flags &= ~ATA_FLAG_PORT_DISABLED;
1241}
1242
1243/**
1244 * __sata_phy_reset -
1245 * @ap:
1246 *
1247 * LOCKING:
1248 *
1249 */
1250void __sata_phy_reset(struct ata_port *ap)
1251{
1252 u32 sstatus;
1253 unsigned long timeout = jiffies + (HZ * 5);
1254
1255 if (ap->flags & ATA_FLAG_SATA_RESET) {
Brett Russcdcca892005-03-28 15:10:27 -05001256 /* issue phy wake/reset */
1257 scr_write_flush(ap, SCR_CONTROL, 0x301);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001258 udelay(400); /* FIXME: a guess */
1259 }
Brett Russcdcca892005-03-28 15:10:27 -05001260 scr_write_flush(ap, SCR_CONTROL, 0x300); /* phy wake/clear reset */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001261
1262 /* wait for phy to become ready, if necessary */
1263 do {
1264 msleep(200);
1265 sstatus = scr_read(ap, SCR_STATUS);
1266 if ((sstatus & 0xf) != 1)
1267 break;
1268 } while (time_before(jiffies, timeout));
1269
1270 /* TODO: phy layer with polling, timeouts, etc. */
1271 if (sata_dev_present(ap))
1272 ata_port_probe(ap);
1273 else {
1274 sstatus = scr_read(ap, SCR_STATUS);
1275 printk(KERN_INFO "ata%u: no device found (phy stat %08x)\n",
1276 ap->id, sstatus);
1277 ata_port_disable(ap);
1278 }
1279
1280 if (ap->flags & ATA_FLAG_PORT_DISABLED)
1281 return;
1282
1283 if (ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT)) {
1284 ata_port_disable(ap);
1285 return;
1286 }
1287
1288 ap->cbl = ATA_CBL_SATA;
1289}
1290
1291/**
1292 * __sata_phy_reset -
1293 * @ap:
1294 *
1295 * LOCKING:
1296 *
1297 */
1298void sata_phy_reset(struct ata_port *ap)
1299{
1300 __sata_phy_reset(ap);
1301 if (ap->flags & ATA_FLAG_PORT_DISABLED)
1302 return;
1303 ata_bus_reset(ap);
1304}
1305
1306/**
1307 * ata_port_disable -
1308 * @ap:
1309 *
1310 * LOCKING:
1311 */
1312
1313void ata_port_disable(struct ata_port *ap)
1314{
1315 ap->device[0].class = ATA_DEV_NONE;
1316 ap->device[1].class = ATA_DEV_NONE;
1317 ap->flags |= ATA_FLAG_PORT_DISABLED;
1318}
1319
1320static struct {
1321 unsigned int shift;
1322 u8 base;
1323} xfer_mode_classes[] = {
1324 { ATA_SHIFT_UDMA, XFER_UDMA_0 },
1325 { ATA_SHIFT_MWDMA, XFER_MW_DMA_0 },
1326 { ATA_SHIFT_PIO, XFER_PIO_0 },
1327};
1328
1329static inline u8 base_from_shift(unsigned int shift)
1330{
1331 int i;
1332
1333 for (i = 0; i < ARRAY_SIZE(xfer_mode_classes); i++)
1334 if (xfer_mode_classes[i].shift == shift)
1335 return xfer_mode_classes[i].base;
1336
1337 return 0xff;
1338}
1339
1340static void ata_dev_set_mode(struct ata_port *ap, struct ata_device *dev)
1341{
1342 int ofs, idx;
1343 u8 base;
1344
1345 if (!ata_dev_present(dev) || (ap->flags & ATA_FLAG_PORT_DISABLED))
1346 return;
1347
1348 if (dev->xfer_shift == ATA_SHIFT_PIO)
1349 dev->flags |= ATA_DFLAG_PIO;
1350
1351 ata_dev_set_xfermode(ap, dev);
1352
1353 base = base_from_shift(dev->xfer_shift);
1354 ofs = dev->xfer_mode - base;
1355 idx = ofs + dev->xfer_shift;
1356 WARN_ON(idx >= ARRAY_SIZE(xfer_mode_str));
1357
1358 DPRINTK("idx=%d xfer_shift=%u, xfer_mode=0x%x, base=0x%x, offset=%d\n",
1359 idx, dev->xfer_shift, (int)dev->xfer_mode, (int)base, ofs);
1360
1361 printk(KERN_INFO "ata%u: dev %u configured for %s\n",
1362 ap->id, dev->devno, xfer_mode_str[idx]);
1363}
1364
1365static int ata_host_set_pio(struct ata_port *ap)
1366{
1367 unsigned int mask;
1368 int x, i;
1369 u8 base, xfer_mode;
1370
1371 mask = ata_get_mode_mask(ap, ATA_SHIFT_PIO);
1372 x = fgb(mask);
1373 if (x < 0) {
1374 printk(KERN_WARNING "ata%u: no PIO support\n", ap->id);
1375 return -1;
1376 }
1377
1378 base = base_from_shift(ATA_SHIFT_PIO);
1379 xfer_mode = base + x;
1380
1381 DPRINTK("base 0x%x xfer_mode 0x%x mask 0x%x x %d\n",
1382 (int)base, (int)xfer_mode, mask, x);
1383
1384 for (i = 0; i < ATA_MAX_DEVICES; i++) {
1385 struct ata_device *dev = &ap->device[i];
1386 if (ata_dev_present(dev)) {
1387 dev->pio_mode = xfer_mode;
1388 dev->xfer_mode = xfer_mode;
1389 dev->xfer_shift = ATA_SHIFT_PIO;
1390 if (ap->ops->set_piomode)
1391 ap->ops->set_piomode(ap, dev);
1392 }
1393 }
1394
1395 return 0;
1396}
1397
1398static void ata_host_set_dma(struct ata_port *ap, u8 xfer_mode,
1399 unsigned int xfer_shift)
1400{
1401 int i;
1402
1403 for (i = 0; i < ATA_MAX_DEVICES; i++) {
1404 struct ata_device *dev = &ap->device[i];
1405 if (ata_dev_present(dev)) {
1406 dev->dma_mode = xfer_mode;
1407 dev->xfer_mode = xfer_mode;
1408 dev->xfer_shift = xfer_shift;
1409 if (ap->ops->set_dmamode)
1410 ap->ops->set_dmamode(ap, dev);
1411 }
1412 }
1413}
1414
1415/**
1416 * ata_set_mode - Program timings and issue SET FEATURES - XFER
1417 * @ap: port on which timings will be programmed
1418 *
1419 * LOCKING:
1420 *
1421 */
1422static void ata_set_mode(struct ata_port *ap)
1423{
1424 unsigned int i, xfer_shift;
1425 u8 xfer_mode;
1426 int rc;
1427
1428 /* step 1: always set host PIO timings */
1429 rc = ata_host_set_pio(ap);
1430 if (rc)
1431 goto err_out;
1432
1433 /* step 2: choose the best data xfer mode */
1434 xfer_mode = xfer_shift = 0;
1435 rc = ata_choose_xfer_mode(ap, &xfer_mode, &xfer_shift);
1436 if (rc)
1437 goto err_out;
1438
1439 /* step 3: if that xfer mode isn't PIO, set host DMA timings */
1440 if (xfer_shift != ATA_SHIFT_PIO)
1441 ata_host_set_dma(ap, xfer_mode, xfer_shift);
1442
1443 /* step 4: update devices' xfer mode */
1444 ata_dev_set_mode(ap, &ap->device[0]);
1445 ata_dev_set_mode(ap, &ap->device[1]);
1446
1447 if (ap->flags & ATA_FLAG_PORT_DISABLED)
1448 return;
1449
1450 if (ap->ops->post_set_mode)
1451 ap->ops->post_set_mode(ap);
1452
1453 for (i = 0; i < 2; i++) {
1454 struct ata_device *dev = &ap->device[i];
1455 ata_dev_set_protocol(dev);
1456 }
1457
1458 return;
1459
1460err_out:
1461 ata_port_disable(ap);
1462}
1463
1464/**
1465 * ata_busy_sleep - sleep until BSY clears, or timeout
1466 * @ap: port containing status register to be polled
1467 * @tmout_pat: impatience timeout
1468 * @tmout: overall timeout
1469 *
1470 * LOCKING:
1471 *
1472 */
1473
1474static unsigned int ata_busy_sleep (struct ata_port *ap,
1475 unsigned long tmout_pat,
1476 unsigned long tmout)
1477{
1478 unsigned long timer_start, timeout;
1479 u8 status;
1480
1481 status = ata_busy_wait(ap, ATA_BUSY, 300);
1482 timer_start = jiffies;
1483 timeout = timer_start + tmout_pat;
1484 while ((status & ATA_BUSY) && (time_before(jiffies, timeout))) {
1485 msleep(50);
1486 status = ata_busy_wait(ap, ATA_BUSY, 3);
1487 }
1488
1489 if (status & ATA_BUSY)
1490 printk(KERN_WARNING "ata%u is slow to respond, "
1491 "please be patient\n", ap->id);
1492
1493 timeout = timer_start + tmout;
1494 while ((status & ATA_BUSY) && (time_before(jiffies, timeout))) {
1495 msleep(50);
1496 status = ata_chk_status(ap);
1497 }
1498
1499 if (status & ATA_BUSY) {
1500 printk(KERN_ERR "ata%u failed to respond (%lu secs)\n",
1501 ap->id, tmout / HZ);
1502 return 1;
1503 }
1504
1505 return 0;
1506}
1507
1508static void ata_bus_post_reset(struct ata_port *ap, unsigned int devmask)
1509{
1510 struct ata_ioports *ioaddr = &ap->ioaddr;
1511 unsigned int dev0 = devmask & (1 << 0);
1512 unsigned int dev1 = devmask & (1 << 1);
1513 unsigned long timeout;
1514
1515 /* if device 0 was found in ata_devchk, wait for its
1516 * BSY bit to clear
1517 */
1518 if (dev0)
1519 ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT);
1520
1521 /* if device 1 was found in ata_devchk, wait for
1522 * register access, then wait for BSY to clear
1523 */
1524 timeout = jiffies + ATA_TMOUT_BOOT;
1525 while (dev1) {
1526 u8 nsect, lbal;
1527
1528 ap->ops->dev_select(ap, 1);
1529 if (ap->flags & ATA_FLAG_MMIO) {
1530 nsect = readb((void __iomem *) ioaddr->nsect_addr);
1531 lbal = readb((void __iomem *) ioaddr->lbal_addr);
1532 } else {
1533 nsect = inb(ioaddr->nsect_addr);
1534 lbal = inb(ioaddr->lbal_addr);
1535 }
1536 if ((nsect == 1) && (lbal == 1))
1537 break;
1538 if (time_after(jiffies, timeout)) {
1539 dev1 = 0;
1540 break;
1541 }
1542 msleep(50); /* give drive a breather */
1543 }
1544 if (dev1)
1545 ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT);
1546
1547 /* is all this really necessary? */
1548 ap->ops->dev_select(ap, 0);
1549 if (dev1)
1550 ap->ops->dev_select(ap, 1);
1551 if (dev0)
1552 ap->ops->dev_select(ap, 0);
1553}
1554
1555/**
1556 * ata_bus_edd -
1557 * @ap:
1558 *
1559 * LOCKING:
1560 *
1561 */
1562
1563static unsigned int ata_bus_edd(struct ata_port *ap)
1564{
1565 struct ata_taskfile tf;
1566
1567 /* set up execute-device-diag (bus reset) taskfile */
1568 /* also, take interrupts to a known state (disabled) */
1569 DPRINTK("execute-device-diag\n");
1570 ata_tf_init(ap, &tf, 0);
1571 tf.ctl |= ATA_NIEN;
1572 tf.command = ATA_CMD_EDD;
1573 tf.protocol = ATA_PROT_NODATA;
1574
1575 /* do bus reset */
1576 ata_tf_to_host(ap, &tf);
1577
1578 /* spec says at least 2ms. but who knows with those
1579 * crazy ATAPI devices...
1580 */
1581 msleep(150);
1582
1583 return ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT);
1584}
1585
1586static unsigned int ata_bus_softreset(struct ata_port *ap,
1587 unsigned int devmask)
1588{
1589 struct ata_ioports *ioaddr = &ap->ioaddr;
1590
1591 DPRINTK("ata%u: bus reset via SRST\n", ap->id);
1592
1593 /* software reset. causes dev0 to be selected */
1594 if (ap->flags & ATA_FLAG_MMIO) {
1595 writeb(ap->ctl, (void __iomem *) ioaddr->ctl_addr);
1596 udelay(20); /* FIXME: flush */
1597 writeb(ap->ctl | ATA_SRST, (void __iomem *) ioaddr->ctl_addr);
1598 udelay(20); /* FIXME: flush */
1599 writeb(ap->ctl, (void __iomem *) ioaddr->ctl_addr);
1600 } else {
1601 outb(ap->ctl, ioaddr->ctl_addr);
1602 udelay(10);
1603 outb(ap->ctl | ATA_SRST, ioaddr->ctl_addr);
1604 udelay(10);
1605 outb(ap->ctl, ioaddr->ctl_addr);
1606 }
1607
1608 /* spec mandates ">= 2ms" before checking status.
1609 * We wait 150ms, because that was the magic delay used for
1610 * ATAPI devices in Hale Landis's ATADRVR, for the period of time
1611 * between when the ATA command register is written, and then
1612 * status is checked. Because waiting for "a while" before
1613 * checking status is fine, post SRST, we perform this magic
1614 * delay here as well.
1615 */
1616 msleep(150);
1617
1618 ata_bus_post_reset(ap, devmask);
1619
1620 return 0;
1621}
1622
1623/**
1624 * ata_bus_reset - reset host port and associated ATA channel
1625 * @ap: port to reset
1626 *
1627 * This is typically the first time we actually start issuing
1628 * commands to the ATA channel. We wait for BSY to clear, then
1629 * issue EXECUTE DEVICE DIAGNOSTIC command, polling for its
1630 * result. Determine what devices, if any, are on the channel
1631 * by looking at the device 0/1 error register. Look at the signature
1632 * stored in each device's taskfile registers, to determine if
1633 * the device is ATA or ATAPI.
1634 *
1635 * LOCKING:
1636 * Inherited from caller. Some functions called by this function
1637 * obtain the host_set lock.
1638 *
1639 * SIDE EFFECTS:
1640 * Sets ATA_FLAG_PORT_DISABLED if bus reset fails.
1641 */
1642
1643void ata_bus_reset(struct ata_port *ap)
1644{
1645 struct ata_ioports *ioaddr = &ap->ioaddr;
1646 unsigned int slave_possible = ap->flags & ATA_FLAG_SLAVE_POSS;
1647 u8 err;
1648 unsigned int dev0, dev1 = 0, rc = 0, devmask = 0;
1649
1650 DPRINTK("ENTER, host %u, port %u\n", ap->id, ap->port_no);
1651
1652 /* determine if device 0/1 are present */
1653 if (ap->flags & ATA_FLAG_SATA_RESET)
1654 dev0 = 1;
1655 else {
1656 dev0 = ata_devchk(ap, 0);
1657 if (slave_possible)
1658 dev1 = ata_devchk(ap, 1);
1659 }
1660
1661 if (dev0)
1662 devmask |= (1 << 0);
1663 if (dev1)
1664 devmask |= (1 << 1);
1665
1666 /* select device 0 again */
1667 ap->ops->dev_select(ap, 0);
1668
1669 /* issue bus reset */
1670 if (ap->flags & ATA_FLAG_SRST)
1671 rc = ata_bus_softreset(ap, devmask);
1672 else if ((ap->flags & ATA_FLAG_SATA_RESET) == 0) {
1673 /* set up device control */
1674 if (ap->flags & ATA_FLAG_MMIO)
1675 writeb(ap->ctl, (void __iomem *) ioaddr->ctl_addr);
1676 else
1677 outb(ap->ctl, ioaddr->ctl_addr);
1678 rc = ata_bus_edd(ap);
1679 }
1680
1681 if (rc)
1682 goto err_out;
1683
1684 /*
1685 * determine by signature whether we have ATA or ATAPI devices
1686 */
1687 err = ata_dev_try_classify(ap, 0);
1688 if ((slave_possible) && (err != 0x81))
1689 ata_dev_try_classify(ap, 1);
1690
1691 /* re-enable interrupts */
1692 if (ap->ioaddr.ctl_addr) /* FIXME: hack. create a hook instead */
1693 ata_irq_on(ap);
1694
1695 /* is double-select really necessary? */
1696 if (ap->device[1].class != ATA_DEV_NONE)
1697 ap->ops->dev_select(ap, 1);
1698 if (ap->device[0].class != ATA_DEV_NONE)
1699 ap->ops->dev_select(ap, 0);
1700
1701 /* if no devices were detected, disable this port */
1702 if ((ap->device[0].class == ATA_DEV_NONE) &&
1703 (ap->device[1].class == ATA_DEV_NONE))
1704 goto err_out;
1705
1706 if (ap->flags & (ATA_FLAG_SATA_RESET | ATA_FLAG_SRST)) {
1707 /* set up device control for ATA_FLAG_SATA_RESET */
1708 if (ap->flags & ATA_FLAG_MMIO)
1709 writeb(ap->ctl, (void __iomem *) ioaddr->ctl_addr);
1710 else
1711 outb(ap->ctl, ioaddr->ctl_addr);
1712 }
1713
1714 DPRINTK("EXIT\n");
1715 return;
1716
1717err_out:
1718 printk(KERN_ERR "ata%u: disabling port\n", ap->id);
1719 ap->ops->port_disable(ap);
1720
1721 DPRINTK("EXIT\n");
1722}
1723
1724static void ata_pr_blacklisted(struct ata_port *ap, struct ata_device *dev)
1725{
1726 printk(KERN_WARNING "ata%u: dev %u is on DMA blacklist, disabling DMA\n",
1727 ap->id, dev->devno);
1728}
1729
1730static const char * ata_dma_blacklist [] = {
1731 "WDC AC11000H",
1732 "WDC AC22100H",
1733 "WDC AC32500H",
1734 "WDC AC33100H",
1735 "WDC AC31600H",
1736 "WDC AC32100H",
1737 "WDC AC23200L",
1738 "Compaq CRD-8241B",
1739 "CRD-8400B",
1740 "CRD-8480B",
1741 "CRD-8482B",
1742 "CRD-84",
1743 "SanDisk SDP3B",
1744 "SanDisk SDP3B-64",
1745 "SANYO CD-ROM CRD",
1746 "HITACHI CDR-8",
1747 "HITACHI CDR-8335",
1748 "HITACHI CDR-8435",
1749 "Toshiba CD-ROM XM-6202B",
1750 "CD-532E-A",
1751 "E-IDE CD-ROM CR-840",
1752 "CD-ROM Drive/F5A",
1753 "WPI CDD-820",
1754 "SAMSUNG CD-ROM SC-148C",
1755 "SAMSUNG CD-ROM SC",
1756 "SanDisk SDP3B-64",
1757 "SAMSUNG CD-ROM SN-124",
1758 "ATAPI CD-ROM DRIVE 40X MAXIMUM",
1759 "_NEC DV5800A",
1760};
1761
1762static int ata_dma_blacklisted(struct ata_port *ap, struct ata_device *dev)
1763{
1764 unsigned char model_num[40];
1765 char *s;
1766 unsigned int len;
1767 int i;
1768
1769 ata_dev_id_string(dev->id, model_num, ATA_ID_PROD_OFS,
1770 sizeof(model_num));
1771 s = &model_num[0];
1772 len = strnlen(s, sizeof(model_num));
1773
1774 /* ATAPI specifies that empty space is blank-filled; remove blanks */
1775 while ((len > 0) && (s[len - 1] == ' ')) {
1776 len--;
1777 s[len] = 0;
1778 }
1779
1780 for (i = 0; i < ARRAY_SIZE(ata_dma_blacklist); i++)
1781 if (!strncmp(ata_dma_blacklist[i], s, len))
1782 return 1;
1783
1784 return 0;
1785}
1786
1787static unsigned int ata_get_mode_mask(struct ata_port *ap, int shift)
1788{
1789 struct ata_device *master, *slave;
1790 unsigned int mask;
1791
1792 master = &ap->device[0];
1793 slave = &ap->device[1];
1794
1795 assert (ata_dev_present(master) || ata_dev_present(slave));
1796
1797 if (shift == ATA_SHIFT_UDMA) {
1798 mask = ap->udma_mask;
1799 if (ata_dev_present(master)) {
1800 mask &= (master->id[ATA_ID_UDMA_MODES] & 0xff);
1801 if (ata_dma_blacklisted(ap, master)) {
1802 mask = 0;
1803 ata_pr_blacklisted(ap, master);
1804 }
1805 }
1806 if (ata_dev_present(slave)) {
1807 mask &= (slave->id[ATA_ID_UDMA_MODES] & 0xff);
1808 if (ata_dma_blacklisted(ap, slave)) {
1809 mask = 0;
1810 ata_pr_blacklisted(ap, slave);
1811 }
1812 }
1813 }
1814 else if (shift == ATA_SHIFT_MWDMA) {
1815 mask = ap->mwdma_mask;
1816 if (ata_dev_present(master)) {
1817 mask &= (master->id[ATA_ID_MWDMA_MODES] & 0x07);
1818 if (ata_dma_blacklisted(ap, master)) {
1819 mask = 0;
1820 ata_pr_blacklisted(ap, master);
1821 }
1822 }
1823 if (ata_dev_present(slave)) {
1824 mask &= (slave->id[ATA_ID_MWDMA_MODES] & 0x07);
1825 if (ata_dma_blacklisted(ap, slave)) {
1826 mask = 0;
1827 ata_pr_blacklisted(ap, slave);
1828 }
1829 }
1830 }
1831 else if (shift == ATA_SHIFT_PIO) {
1832 mask = ap->pio_mask;
1833 if (ata_dev_present(master)) {
1834 /* spec doesn't return explicit support for
1835 * PIO0-2, so we fake it
1836 */
1837 u16 tmp_mode = master->id[ATA_ID_PIO_MODES] & 0x03;
1838 tmp_mode <<= 3;
1839 tmp_mode |= 0x7;
1840 mask &= tmp_mode;
1841 }
1842 if (ata_dev_present(slave)) {
1843 /* spec doesn't return explicit support for
1844 * PIO0-2, so we fake it
1845 */
1846 u16 tmp_mode = slave->id[ATA_ID_PIO_MODES] & 0x03;
1847 tmp_mode <<= 3;
1848 tmp_mode |= 0x7;
1849 mask &= tmp_mode;
1850 }
1851 }
1852 else {
1853 mask = 0xffffffff; /* shut up compiler warning */
1854 BUG();
1855 }
1856
1857 return mask;
1858}
1859
1860/* find greatest bit */
1861static int fgb(u32 bitmap)
1862{
1863 unsigned int i;
1864 int x = -1;
1865
1866 for (i = 0; i < 32; i++)
1867 if (bitmap & (1 << i))
1868 x = i;
1869
1870 return x;
1871}
1872
1873/**
1874 * ata_choose_xfer_mode - attempt to find best transfer mode
1875 * @ap: Port for which an xfer mode will be selected
1876 * @xfer_mode_out: (output) SET FEATURES - XFER MODE code
1877 * @xfer_shift_out: (output) bit shift that selects this mode
1878 *
1879 * LOCKING:
1880 *
1881 * RETURNS:
1882 * Zero on success, negative on error.
1883 */
1884
1885static int ata_choose_xfer_mode(struct ata_port *ap,
1886 u8 *xfer_mode_out,
1887 unsigned int *xfer_shift_out)
1888{
1889 unsigned int mask, shift;
1890 int x, i;
1891
1892 for (i = 0; i < ARRAY_SIZE(xfer_mode_classes); i++) {
1893 shift = xfer_mode_classes[i].shift;
1894 mask = ata_get_mode_mask(ap, shift);
1895
1896 x = fgb(mask);
1897 if (x >= 0) {
1898 *xfer_mode_out = xfer_mode_classes[i].base + x;
1899 *xfer_shift_out = shift;
1900 return 0;
1901 }
1902 }
1903
1904 return -1;
1905}
1906
1907/**
1908 * ata_dev_set_xfermode - Issue SET FEATURES - XFER MODE command
1909 * @ap: Port associated with device @dev
1910 * @dev: Device to which command will be sent
1911 *
1912 * LOCKING:
1913 */
1914
1915static void ata_dev_set_xfermode(struct ata_port *ap, struct ata_device *dev)
1916{
1917 DECLARE_COMPLETION(wait);
1918 struct ata_queued_cmd *qc;
1919 int rc;
1920 unsigned long flags;
1921
1922 /* set up set-features taskfile */
1923 DPRINTK("set features - xfer mode\n");
1924
1925 qc = ata_qc_new_init(ap, dev);
1926 BUG_ON(qc == NULL);
1927
1928 qc->tf.command = ATA_CMD_SET_FEATURES;
1929 qc->tf.feature = SETFEATURES_XFER;
1930 qc->tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
1931 qc->tf.protocol = ATA_PROT_NODATA;
1932 qc->tf.nsect = dev->xfer_mode;
1933
1934 qc->waiting = &wait;
1935 qc->complete_fn = ata_qc_complete_noop;
1936
1937 spin_lock_irqsave(&ap->host_set->lock, flags);
1938 rc = ata_qc_issue(qc);
1939 spin_unlock_irqrestore(&ap->host_set->lock, flags);
1940
1941 if (rc)
1942 ata_port_disable(ap);
1943 else
1944 wait_for_completion(&wait);
1945
1946 DPRINTK("EXIT\n");
1947}
1948
1949/**
1950 * ata_sg_clean -
1951 * @qc:
1952 *
1953 * LOCKING:
1954 */
1955
1956static void ata_sg_clean(struct ata_queued_cmd *qc)
1957{
1958 struct ata_port *ap = qc->ap;
1959 struct scatterlist *sg = qc->sg;
1960 int dir = qc->dma_dir;
1961
1962 assert(qc->flags & ATA_QCFLAG_DMAMAP);
1963 assert(sg != NULL);
1964
1965 if (qc->flags & ATA_QCFLAG_SINGLE)
1966 assert(qc->n_elem == 1);
1967
1968 DPRINTK("unmapping %u sg elements\n", qc->n_elem);
1969
1970 if (qc->flags & ATA_QCFLAG_SG)
1971 dma_unmap_sg(ap->host_set->dev, sg, qc->n_elem, dir);
1972 else
1973 dma_unmap_single(ap->host_set->dev, sg_dma_address(&sg[0]),
1974 sg_dma_len(&sg[0]), dir);
1975
1976 qc->flags &= ~ATA_QCFLAG_DMAMAP;
1977 qc->sg = NULL;
1978}
1979
1980/**
1981 * ata_fill_sg - Fill PCI IDE PRD table
1982 * @qc: Metadata associated with taskfile to be transferred
1983 *
1984 * LOCKING:
1985 *
1986 */
1987static void ata_fill_sg(struct ata_queued_cmd *qc)
1988{
1989 struct scatterlist *sg = qc->sg;
1990 struct ata_port *ap = qc->ap;
1991 unsigned int idx, nelem;
1992
1993 assert(sg != NULL);
1994 assert(qc->n_elem > 0);
1995
1996 idx = 0;
1997 for (nelem = qc->n_elem; nelem; nelem--,sg++) {
1998 u32 addr, offset;
1999 u32 sg_len, len;
2000
2001 /* determine if physical DMA addr spans 64K boundary.
2002 * Note h/w doesn't support 64-bit, so we unconditionally
2003 * truncate dma_addr_t to u32.
2004 */
2005 addr = (u32) sg_dma_address(sg);
2006 sg_len = sg_dma_len(sg);
2007
2008 while (sg_len) {
2009 offset = addr & 0xffff;
2010 len = sg_len;
2011 if ((offset + sg_len) > 0x10000)
2012 len = 0x10000 - offset;
2013
2014 ap->prd[idx].addr = cpu_to_le32(addr);
2015 ap->prd[idx].flags_len = cpu_to_le32(len & 0xffff);
2016 VPRINTK("PRD[%u] = (0x%X, 0x%X)\n", idx, addr, len);
2017
2018 idx++;
2019 sg_len -= len;
2020 addr += len;
2021 }
2022 }
2023
2024 if (idx)
2025 ap->prd[idx - 1].flags_len |= cpu_to_le32(ATA_PRD_EOT);
2026}
2027/**
2028 * ata_check_atapi_dma - Check whether ATAPI DMA can be supported
2029 * @qc: Metadata associated with taskfile to check
2030 *
2031 * LOCKING:
2032 * RETURNS: 0 when ATAPI DMA can be used
2033 * nonzero otherwise
2034 */
2035int ata_check_atapi_dma(struct ata_queued_cmd *qc)
2036{
2037 struct ata_port *ap = qc->ap;
2038 int rc = 0; /* Assume ATAPI DMA is OK by default */
2039
2040 if (ap->ops->check_atapi_dma)
2041 rc = ap->ops->check_atapi_dma(qc);
2042
2043 return rc;
2044}
2045/**
2046 * ata_qc_prep - Prepare taskfile for submission
2047 * @qc: Metadata associated with taskfile to be prepared
2048 *
2049 * LOCKING:
2050 * spin_lock_irqsave(host_set lock)
2051 */
2052void ata_qc_prep(struct ata_queued_cmd *qc)
2053{
2054 if (!(qc->flags & ATA_QCFLAG_DMAMAP))
2055 return;
2056
2057 ata_fill_sg(qc);
2058}
2059
2060void ata_sg_init_one(struct ata_queued_cmd *qc, void *buf, unsigned int buflen)
2061{
2062 struct scatterlist *sg;
2063
2064 qc->flags |= ATA_QCFLAG_SINGLE;
2065
2066 memset(&qc->sgent, 0, sizeof(qc->sgent));
2067 qc->sg = &qc->sgent;
2068 qc->n_elem = 1;
2069 qc->buf_virt = buf;
2070
2071 sg = qc->sg;
2072 sg->page = virt_to_page(buf);
2073 sg->offset = (unsigned long) buf & ~PAGE_MASK;
2074 sg_dma_len(sg) = buflen;
2075}
2076
2077void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg,
2078 unsigned int n_elem)
2079{
2080 qc->flags |= ATA_QCFLAG_SG;
2081 qc->sg = sg;
2082 qc->n_elem = n_elem;
2083}
2084
2085/**
2086 * ata_sg_setup_one -
2087 * @qc:
2088 *
2089 * LOCKING:
2090 * spin_lock_irqsave(host_set lock)
2091 *
2092 * RETURNS:
2093 *
2094 */
2095
2096static int ata_sg_setup_one(struct ata_queued_cmd *qc)
2097{
2098 struct ata_port *ap = qc->ap;
2099 int dir = qc->dma_dir;
2100 struct scatterlist *sg = qc->sg;
2101 dma_addr_t dma_address;
2102
2103 dma_address = dma_map_single(ap->host_set->dev, qc->buf_virt,
2104 sg_dma_len(sg), dir);
2105 if (dma_mapping_error(dma_address))
2106 return -1;
2107
2108 sg_dma_address(sg) = dma_address;
2109
2110 DPRINTK("mapped buffer of %d bytes for %s\n", sg_dma_len(sg),
2111 qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
2112
2113 return 0;
2114}
2115
2116/**
2117 * ata_sg_setup -
2118 * @qc:
2119 *
2120 * LOCKING:
2121 * spin_lock_irqsave(host_set lock)
2122 *
2123 * RETURNS:
2124 *
2125 */
2126
2127static int ata_sg_setup(struct ata_queued_cmd *qc)
2128{
2129 struct ata_port *ap = qc->ap;
2130 struct scatterlist *sg = qc->sg;
2131 int n_elem, dir;
2132
2133 VPRINTK("ENTER, ata%u\n", ap->id);
2134 assert(qc->flags & ATA_QCFLAG_SG);
2135
2136 dir = qc->dma_dir;
2137 n_elem = dma_map_sg(ap->host_set->dev, sg, qc->n_elem, dir);
2138 if (n_elem < 1)
2139 return -1;
2140
2141 DPRINTK("%d sg elements mapped\n", n_elem);
2142
2143 qc->n_elem = n_elem;
2144
2145 return 0;
2146}
2147
2148/**
2149 * ata_pio_poll -
2150 * @ap:
2151 *
2152 * LOCKING:
2153 *
2154 * RETURNS:
2155 *
2156 */
2157
2158static unsigned long ata_pio_poll(struct ata_port *ap)
2159{
2160 u8 status;
2161 unsigned int poll_state = PIO_ST_UNKNOWN;
2162 unsigned int reg_state = PIO_ST_UNKNOWN;
2163 const unsigned int tmout_state = PIO_ST_TMOUT;
2164
2165 switch (ap->pio_task_state) {
2166 case PIO_ST:
2167 case PIO_ST_POLL:
2168 poll_state = PIO_ST_POLL;
2169 reg_state = PIO_ST;
2170 break;
2171 case PIO_ST_LAST:
2172 case PIO_ST_LAST_POLL:
2173 poll_state = PIO_ST_LAST_POLL;
2174 reg_state = PIO_ST_LAST;
2175 break;
2176 default:
2177 BUG();
2178 break;
2179 }
2180
2181 status = ata_chk_status(ap);
2182 if (status & ATA_BUSY) {
2183 if (time_after(jiffies, ap->pio_task_timeout)) {
2184 ap->pio_task_state = tmout_state;
2185 return 0;
2186 }
2187 ap->pio_task_state = poll_state;
2188 return ATA_SHORT_PAUSE;
2189 }
2190
2191 ap->pio_task_state = reg_state;
2192 return 0;
2193}
2194
2195/**
2196 * ata_pio_complete -
2197 * @ap:
2198 *
2199 * LOCKING:
2200 */
2201
2202static void ata_pio_complete (struct ata_port *ap)
2203{
2204 struct ata_queued_cmd *qc;
2205 u8 drv_stat;
2206
2207 /*
2208 * This is purely hueristic. This is a fast path.
2209 * Sometimes when we enter, BSY will be cleared in
2210 * a chk-status or two. If not, the drive is probably seeking
2211 * or something. Snooze for a couple msecs, then
2212 * chk-status again. If still busy, fall back to
2213 * PIO_ST_POLL state.
2214 */
2215 drv_stat = ata_busy_wait(ap, ATA_BUSY | ATA_DRQ, 10);
2216 if (drv_stat & (ATA_BUSY | ATA_DRQ)) {
2217 msleep(2);
2218 drv_stat = ata_busy_wait(ap, ATA_BUSY | ATA_DRQ, 10);
2219 if (drv_stat & (ATA_BUSY | ATA_DRQ)) {
2220 ap->pio_task_state = PIO_ST_LAST_POLL;
2221 ap->pio_task_timeout = jiffies + ATA_TMOUT_PIO;
2222 return;
2223 }
2224 }
2225
2226 drv_stat = ata_wait_idle(ap);
2227 if (!ata_ok(drv_stat)) {
2228 ap->pio_task_state = PIO_ST_ERR;
2229 return;
2230 }
2231
2232 qc = ata_qc_from_tag(ap, ap->active_tag);
2233 assert(qc != NULL);
2234
2235 ap->pio_task_state = PIO_ST_IDLE;
2236
2237 ata_irq_on(ap);
2238
2239 ata_qc_complete(qc, drv_stat);
2240}
2241
2242void swap_buf_le16(u16 *buf, unsigned int buf_words)
2243{
2244#ifdef __BIG_ENDIAN
2245 unsigned int i;
2246
2247 for (i = 0; i < buf_words; i++)
2248 buf[i] = le16_to_cpu(buf[i]);
2249#endif /* __BIG_ENDIAN */
2250}
2251
2252static void ata_mmio_data_xfer(struct ata_port *ap, unsigned char *buf,
2253 unsigned int buflen, int write_data)
2254{
2255 unsigned int i;
2256 unsigned int words = buflen >> 1;
2257 u16 *buf16 = (u16 *) buf;
2258 void __iomem *mmio = (void __iomem *)ap->ioaddr.data_addr;
2259
2260 if (write_data) {
2261 for (i = 0; i < words; i++)
2262 writew(le16_to_cpu(buf16[i]), mmio);
2263 } else {
2264 for (i = 0; i < words; i++)
2265 buf16[i] = cpu_to_le16(readw(mmio));
2266 }
2267}
2268
2269static void ata_pio_data_xfer(struct ata_port *ap, unsigned char *buf,
2270 unsigned int buflen, int write_data)
2271{
2272 unsigned int dwords = buflen >> 1;
2273
2274 if (write_data)
2275 outsw(ap->ioaddr.data_addr, buf, dwords);
2276 else
2277 insw(ap->ioaddr.data_addr, buf, dwords);
2278}
2279
2280static void ata_data_xfer(struct ata_port *ap, unsigned char *buf,
2281 unsigned int buflen, int do_write)
2282{
2283 if (ap->flags & ATA_FLAG_MMIO)
2284 ata_mmio_data_xfer(ap, buf, buflen, do_write);
2285 else
2286 ata_pio_data_xfer(ap, buf, buflen, do_write);
2287}
2288
2289static void ata_pio_sector(struct ata_queued_cmd *qc)
2290{
2291 int do_write = (qc->tf.flags & ATA_TFLAG_WRITE);
2292 struct scatterlist *sg = qc->sg;
2293 struct ata_port *ap = qc->ap;
2294 struct page *page;
2295 unsigned int offset;
2296 unsigned char *buf;
2297
2298 if (qc->cursect == (qc->nsect - 1))
2299 ap->pio_task_state = PIO_ST_LAST;
2300
2301 page = sg[qc->cursg].page;
2302 offset = sg[qc->cursg].offset + qc->cursg_ofs * ATA_SECT_SIZE;
2303
2304 /* get the current page and offset */
2305 page = nth_page(page, (offset >> PAGE_SHIFT));
2306 offset %= PAGE_SIZE;
2307
2308 buf = kmap(page) + offset;
2309
2310 qc->cursect++;
2311 qc->cursg_ofs++;
2312
2313 if ((qc->cursg_ofs * ATA_SECT_SIZE) == sg_dma_len(&sg[qc->cursg])) {
2314 qc->cursg++;
2315 qc->cursg_ofs = 0;
2316 }
2317
2318 DPRINTK("data %s\n", qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
2319
2320 /* do the actual data transfer */
2321 do_write = (qc->tf.flags & ATA_TFLAG_WRITE);
2322 ata_data_xfer(ap, buf, ATA_SECT_SIZE, do_write);
2323
2324 kunmap(page);
2325}
2326
2327static void __atapi_pio_bytes(struct ata_queued_cmd *qc, unsigned int bytes)
2328{
2329 int do_write = (qc->tf.flags & ATA_TFLAG_WRITE);
2330 struct scatterlist *sg = qc->sg;
2331 struct ata_port *ap = qc->ap;
2332 struct page *page;
2333 unsigned char *buf;
2334 unsigned int offset, count;
2335
2336 if (qc->curbytes == qc->nbytes - bytes)
2337 ap->pio_task_state = PIO_ST_LAST;
2338
2339next_sg:
2340 sg = &qc->sg[qc->cursg];
2341
2342next_page:
2343 page = sg->page;
2344 offset = sg->offset + qc->cursg_ofs;
2345
2346 /* get the current page and offset */
2347 page = nth_page(page, (offset >> PAGE_SHIFT));
2348 offset %= PAGE_SIZE;
2349
2350 count = min(sg_dma_len(sg) - qc->cursg_ofs, bytes);
2351
2352 /* don't cross page boundaries */
2353 count = min(count, (unsigned int)PAGE_SIZE - offset);
2354
2355 buf = kmap(page) + offset;
2356
2357 bytes -= count;
2358 qc->curbytes += count;
2359 qc->cursg_ofs += count;
2360
2361 if (qc->cursg_ofs == sg_dma_len(sg)) {
2362 qc->cursg++;
2363 qc->cursg_ofs = 0;
2364 }
2365
2366 DPRINTK("data %s\n", qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
2367
2368 /* do the actual data transfer */
2369 ata_data_xfer(ap, buf, count, do_write);
2370
2371 kunmap(page);
2372
2373 if (bytes) {
2374 if (qc->cursg_ofs < sg_dma_len(sg))
2375 goto next_page;
2376 goto next_sg;
2377 }
2378}
2379
2380static void atapi_pio_bytes(struct ata_queued_cmd *qc)
2381{
2382 struct ata_port *ap = qc->ap;
2383 struct ata_device *dev = qc->dev;
2384 unsigned int ireason, bc_lo, bc_hi, bytes;
2385 int i_write, do_write = (qc->tf.flags & ATA_TFLAG_WRITE) ? 1 : 0;
2386
2387 ap->ops->tf_read(ap, &qc->tf);
2388 ireason = qc->tf.nsect;
2389 bc_lo = qc->tf.lbam;
2390 bc_hi = qc->tf.lbah;
2391 bytes = (bc_hi << 8) | bc_lo;
2392
2393 /* shall be cleared to zero, indicating xfer of data */
2394 if (ireason & (1 << 0))
2395 goto err_out;
2396
2397 /* make sure transfer direction matches expected */
2398 i_write = ((ireason & (1 << 1)) == 0) ? 1 : 0;
2399 if (do_write != i_write)
2400 goto err_out;
2401
2402 __atapi_pio_bytes(qc, bytes);
2403
2404 return;
2405
2406err_out:
2407 printk(KERN_INFO "ata%u: dev %u: ATAPI check failed\n",
2408 ap->id, dev->devno);
2409 ap->pio_task_state = PIO_ST_ERR;
2410}
2411
2412/**
2413 * ata_pio_sector -
2414 * @ap:
2415 *
2416 * LOCKING:
2417 */
2418
2419static void ata_pio_block(struct ata_port *ap)
2420{
2421 struct ata_queued_cmd *qc;
2422 u8 status;
2423
2424 /*
2425 * This is purely hueristic. This is a fast path.
2426 * Sometimes when we enter, BSY will be cleared in
2427 * a chk-status or two. If not, the drive is probably seeking
2428 * or something. Snooze for a couple msecs, then
2429 * chk-status again. If still busy, fall back to
2430 * PIO_ST_POLL state.
2431 */
2432 status = ata_busy_wait(ap, ATA_BUSY, 5);
2433 if (status & ATA_BUSY) {
2434 msleep(2);
2435 status = ata_busy_wait(ap, ATA_BUSY, 10);
2436 if (status & ATA_BUSY) {
2437 ap->pio_task_state = PIO_ST_POLL;
2438 ap->pio_task_timeout = jiffies + ATA_TMOUT_PIO;
2439 return;
2440 }
2441 }
2442
2443 qc = ata_qc_from_tag(ap, ap->active_tag);
2444 assert(qc != NULL);
2445
2446 if (is_atapi_taskfile(&qc->tf)) {
2447 /* no more data to transfer or unsupported ATAPI command */
2448 if ((status & ATA_DRQ) == 0) {
2449 ap->pio_task_state = PIO_ST_IDLE;
2450
2451 ata_irq_on(ap);
2452
2453 ata_qc_complete(qc, status);
2454 return;
2455 }
2456
2457 atapi_pio_bytes(qc);
2458 } else {
2459 /* handle BSY=0, DRQ=0 as error */
2460 if ((status & ATA_DRQ) == 0) {
2461 ap->pio_task_state = PIO_ST_ERR;
2462 return;
2463 }
2464
2465 ata_pio_sector(qc);
2466 }
2467}
2468
2469static void ata_pio_error(struct ata_port *ap)
2470{
2471 struct ata_queued_cmd *qc;
2472 u8 drv_stat;
2473
2474 qc = ata_qc_from_tag(ap, ap->active_tag);
2475 assert(qc != NULL);
2476
2477 drv_stat = ata_chk_status(ap);
2478 printk(KERN_WARNING "ata%u: PIO error, drv_stat 0x%x\n",
2479 ap->id, drv_stat);
2480
2481 ap->pio_task_state = PIO_ST_IDLE;
2482
2483 ata_irq_on(ap);
2484
2485 ata_qc_complete(qc, drv_stat | ATA_ERR);
2486}
2487
2488static void ata_pio_task(void *_data)
2489{
2490 struct ata_port *ap = _data;
2491 unsigned long timeout = 0;
2492
2493 switch (ap->pio_task_state) {
2494 case PIO_ST_IDLE:
2495 return;
2496
2497 case PIO_ST:
2498 ata_pio_block(ap);
2499 break;
2500
2501 case PIO_ST_LAST:
2502 ata_pio_complete(ap);
2503 break;
2504
2505 case PIO_ST_POLL:
2506 case PIO_ST_LAST_POLL:
2507 timeout = ata_pio_poll(ap);
2508 break;
2509
2510 case PIO_ST_TMOUT:
2511 case PIO_ST_ERR:
2512 ata_pio_error(ap);
2513 return;
2514 }
2515
2516 if (timeout)
2517 queue_delayed_work(ata_wq, &ap->pio_task,
2518 timeout);
2519 else
2520 queue_work(ata_wq, &ap->pio_task);
2521}
2522
2523static void atapi_request_sense(struct ata_port *ap, struct ata_device *dev,
2524 struct scsi_cmnd *cmd)
2525{
2526 DECLARE_COMPLETION(wait);
2527 struct ata_queued_cmd *qc;
2528 unsigned long flags;
2529 int rc;
2530
2531 DPRINTK("ATAPI request sense\n");
2532
2533 qc = ata_qc_new_init(ap, dev);
2534 BUG_ON(qc == NULL);
2535
2536 /* FIXME: is this needed? */
2537 memset(cmd->sense_buffer, 0, sizeof(cmd->sense_buffer));
2538
2539 ata_sg_init_one(qc, cmd->sense_buffer, sizeof(cmd->sense_buffer));
2540 qc->dma_dir = DMA_FROM_DEVICE;
2541
Albert Lee21b1ed72005-04-29 17:34:59 +08002542 memset(&qc->cdb, 0, ap->cdb_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002543 qc->cdb[0] = REQUEST_SENSE;
2544 qc->cdb[4] = SCSI_SENSE_BUFFERSIZE;
2545
2546 qc->tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
2547 qc->tf.command = ATA_CMD_PACKET;
2548
2549 qc->tf.protocol = ATA_PROT_ATAPI;
2550 qc->tf.lbam = (8 * 1024) & 0xff;
2551 qc->tf.lbah = (8 * 1024) >> 8;
2552 qc->nbytes = SCSI_SENSE_BUFFERSIZE;
2553
2554 qc->waiting = &wait;
2555 qc->complete_fn = ata_qc_complete_noop;
2556
2557 spin_lock_irqsave(&ap->host_set->lock, flags);
2558 rc = ata_qc_issue(qc);
2559 spin_unlock_irqrestore(&ap->host_set->lock, flags);
2560
2561 if (rc)
2562 ata_port_disable(ap);
2563 else
2564 wait_for_completion(&wait);
2565
2566 DPRINTK("EXIT\n");
2567}
2568
2569/**
2570 * ata_qc_timeout - Handle timeout of queued command
2571 * @qc: Command that timed out
2572 *
2573 * Some part of the kernel (currently, only the SCSI layer)
2574 * has noticed that the active command on port @ap has not
2575 * completed after a specified length of time. Handle this
2576 * condition by disabling DMA (if necessary) and completing
2577 * transactions, with error if necessary.
2578 *
2579 * This also handles the case of the "lost interrupt", where
2580 * for some reason (possibly hardware bug, possibly driver bug)
2581 * an interrupt was not delivered to the driver, even though the
2582 * transaction completed successfully.
2583 *
2584 * LOCKING:
2585 */
2586
2587static void ata_qc_timeout(struct ata_queued_cmd *qc)
2588{
2589 struct ata_port *ap = qc->ap;
2590 struct ata_device *dev = qc->dev;
2591 u8 host_stat = 0, drv_stat;
2592
2593 DPRINTK("ENTER\n");
2594
2595 /* FIXME: doesn't this conflict with timeout handling? */
2596 if (qc->dev->class == ATA_DEV_ATAPI && qc->scsicmd) {
2597 struct scsi_cmnd *cmd = qc->scsicmd;
2598
2599 if (!scsi_eh_eflags_chk(cmd, SCSI_EH_CANCEL_CMD)) {
2600
2601 /* finish completing original command */
2602 __ata_qc_complete(qc);
2603
2604 atapi_request_sense(ap, dev, cmd);
2605
2606 cmd->result = (CHECK_CONDITION << 1) | (DID_OK << 16);
2607 scsi_finish_command(cmd);
2608
2609 goto out;
2610 }
2611 }
2612
2613 /* hack alert! We cannot use the supplied completion
2614 * function from inside the ->eh_strategy_handler() thread.
2615 * libata is the only user of ->eh_strategy_handler() in
2616 * any kernel, so the default scsi_done() assumes it is
2617 * not being called from the SCSI EH.
2618 */
2619 qc->scsidone = scsi_finish_command;
2620
2621 switch (qc->tf.protocol) {
2622
2623 case ATA_PROT_DMA:
2624 case ATA_PROT_ATAPI_DMA:
2625 host_stat = ap->ops->bmdma_status(ap);
2626
2627 /* before we do anything else, clear DMA-Start bit */
2628 ap->ops->bmdma_stop(ap);
2629
2630 /* fall through */
2631
2632 default:
2633 ata_altstatus(ap);
2634 drv_stat = ata_chk_status(ap);
2635
2636 /* ack bmdma irq events */
2637 ap->ops->irq_clear(ap);
2638
2639 printk(KERN_ERR "ata%u: command 0x%x timeout, stat 0x%x host_stat 0x%x\n",
2640 ap->id, qc->tf.command, drv_stat, host_stat);
2641
2642 /* complete taskfile transaction */
2643 ata_qc_complete(qc, drv_stat);
2644 break;
2645 }
2646out:
2647 DPRINTK("EXIT\n");
2648}
2649
2650/**
2651 * ata_eng_timeout - Handle timeout of queued command
2652 * @ap: Port on which timed-out command is active
2653 *
2654 * Some part of the kernel (currently, only the SCSI layer)
2655 * has noticed that the active command on port @ap has not
2656 * completed after a specified length of time. Handle this
2657 * condition by disabling DMA (if necessary) and completing
2658 * transactions, with error if necessary.
2659 *
2660 * This also handles the case of the "lost interrupt", where
2661 * for some reason (possibly hardware bug, possibly driver bug)
2662 * an interrupt was not delivered to the driver, even though the
2663 * transaction completed successfully.
2664 *
2665 * LOCKING:
2666 * Inherited from SCSI layer (none, can sleep)
2667 */
2668
2669void ata_eng_timeout(struct ata_port *ap)
2670{
2671 struct ata_queued_cmd *qc;
2672
2673 DPRINTK("ENTER\n");
2674
2675 qc = ata_qc_from_tag(ap, ap->active_tag);
2676 if (!qc) {
2677 printk(KERN_ERR "ata%u: BUG: timeout without command\n",
2678 ap->id);
2679 goto out;
2680 }
2681
2682 ata_qc_timeout(qc);
2683
2684out:
2685 DPRINTK("EXIT\n");
2686}
2687
2688/**
2689 * ata_qc_new - Request an available ATA command, for queueing
2690 * @ap: Port associated with device @dev
2691 * @dev: Device from whom we request an available command structure
2692 *
2693 * LOCKING:
2694 */
2695
2696static struct ata_queued_cmd *ata_qc_new(struct ata_port *ap)
2697{
2698 struct ata_queued_cmd *qc = NULL;
2699 unsigned int i;
2700
2701 for (i = 0; i < ATA_MAX_QUEUE; i++)
2702 if (!test_and_set_bit(i, &ap->qactive)) {
2703 qc = ata_qc_from_tag(ap, i);
2704 break;
2705 }
2706
2707 if (qc)
2708 qc->tag = i;
2709
2710 return qc;
2711}
2712
2713/**
2714 * ata_qc_new_init - Request an available ATA command, and initialize it
2715 * @ap: Port associated with device @dev
2716 * @dev: Device from whom we request an available command structure
2717 *
2718 * LOCKING:
2719 */
2720
2721struct ata_queued_cmd *ata_qc_new_init(struct ata_port *ap,
2722 struct ata_device *dev)
2723{
2724 struct ata_queued_cmd *qc;
2725
2726 qc = ata_qc_new(ap);
2727 if (qc) {
2728 qc->sg = NULL;
2729 qc->flags = 0;
2730 qc->scsicmd = NULL;
2731 qc->ap = ap;
2732 qc->dev = dev;
2733 qc->cursect = qc->cursg = qc->cursg_ofs = 0;
2734 qc->nsect = 0;
2735 qc->nbytes = qc->curbytes = 0;
2736
2737 ata_tf_init(ap, &qc->tf, dev->devno);
2738
2739 if (dev->flags & ATA_DFLAG_LBA48)
2740 qc->tf.flags |= ATA_TFLAG_LBA48;
2741 }
2742
2743 return qc;
2744}
2745
2746static int ata_qc_complete_noop(struct ata_queued_cmd *qc, u8 drv_stat)
2747{
2748 return 0;
2749}
2750
2751static void __ata_qc_complete(struct ata_queued_cmd *qc)
2752{
2753 struct ata_port *ap = qc->ap;
2754 unsigned int tag, do_clear = 0;
2755
2756 qc->flags = 0;
2757 tag = qc->tag;
2758 if (likely(ata_tag_valid(tag))) {
2759 if (tag == ap->active_tag)
2760 ap->active_tag = ATA_TAG_POISON;
2761 qc->tag = ATA_TAG_POISON;
2762 do_clear = 1;
2763 }
2764
2765 if (qc->waiting) {
2766 struct completion *waiting = qc->waiting;
2767 qc->waiting = NULL;
2768 complete(waiting);
2769 }
2770
2771 if (likely(do_clear))
2772 clear_bit(tag, &ap->qactive);
2773}
2774
2775/**
2776 * ata_qc_free - free unused ata_queued_cmd
2777 * @qc: Command to complete
2778 *
2779 * Designed to free unused ata_queued_cmd object
2780 * in case something prevents using it.
2781 *
2782 * LOCKING:
2783 *
2784 */
2785void ata_qc_free(struct ata_queued_cmd *qc)
2786{
2787 assert(qc != NULL); /* ata_qc_from_tag _might_ return NULL */
2788 assert(qc->waiting == NULL); /* nothing should be waiting */
2789
2790 __ata_qc_complete(qc);
2791}
2792
2793/**
2794 * ata_qc_complete - Complete an active ATA command
2795 * @qc: Command to complete
2796 * @drv_stat: ATA status register contents
2797 *
2798 * LOCKING:
2799 *
2800 */
2801
2802void ata_qc_complete(struct ata_queued_cmd *qc, u8 drv_stat)
2803{
2804 int rc;
2805
2806 assert(qc != NULL); /* ata_qc_from_tag _might_ return NULL */
2807 assert(qc->flags & ATA_QCFLAG_ACTIVE);
2808
2809 if (likely(qc->flags & ATA_QCFLAG_DMAMAP))
2810 ata_sg_clean(qc);
2811
2812 /* call completion callback */
2813 rc = qc->complete_fn(qc, drv_stat);
Albert Lee21b1ed72005-04-29 17:34:59 +08002814 qc->flags &= ~ATA_QCFLAG_ACTIVE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002815
2816 /* if callback indicates not to complete command (non-zero),
2817 * return immediately
2818 */
2819 if (rc != 0)
2820 return;
2821
2822 __ata_qc_complete(qc);
2823
2824 VPRINTK("EXIT\n");
2825}
2826
2827static inline int ata_should_dma_map(struct ata_queued_cmd *qc)
2828{
2829 struct ata_port *ap = qc->ap;
2830
2831 switch (qc->tf.protocol) {
2832 case ATA_PROT_DMA:
2833 case ATA_PROT_ATAPI_DMA:
2834 return 1;
2835
2836 case ATA_PROT_ATAPI:
2837 case ATA_PROT_PIO:
2838 case ATA_PROT_PIO_MULT:
2839 if (ap->flags & ATA_FLAG_PIO_DMA)
2840 return 1;
2841
2842 /* fall through */
2843
2844 default:
2845 return 0;
2846 }
2847
2848 /* never reached */
2849}
2850
2851/**
2852 * ata_qc_issue - issue taskfile to device
2853 * @qc: command to issue to device
2854 *
2855 * Prepare an ATA command to submission to device.
2856 * This includes mapping the data into a DMA-able
2857 * area, filling in the S/G table, and finally
2858 * writing the taskfile to hardware, starting the command.
2859 *
2860 * LOCKING:
2861 * spin_lock_irqsave(host_set lock)
2862 *
2863 * RETURNS:
2864 * Zero on success, negative on error.
2865 */
2866
2867int ata_qc_issue(struct ata_queued_cmd *qc)
2868{
2869 struct ata_port *ap = qc->ap;
2870
2871 if (ata_should_dma_map(qc)) {
2872 if (qc->flags & ATA_QCFLAG_SG) {
2873 if (ata_sg_setup(qc))
2874 goto err_out;
2875 } else if (qc->flags & ATA_QCFLAG_SINGLE) {
2876 if (ata_sg_setup_one(qc))
2877 goto err_out;
2878 }
2879 } else {
2880 qc->flags &= ~ATA_QCFLAG_DMAMAP;
2881 }
2882
2883 ap->ops->qc_prep(qc);
2884
2885 qc->ap->active_tag = qc->tag;
2886 qc->flags |= ATA_QCFLAG_ACTIVE;
2887
2888 return ap->ops->qc_issue(qc);
2889
2890err_out:
2891 return -1;
2892}
2893
2894/**
2895 * ata_qc_issue_prot - issue taskfile to device in proto-dependent manner
2896 * @qc: command to issue to device
2897 *
2898 * Using various libata functions and hooks, this function
2899 * starts an ATA command. ATA commands are grouped into
2900 * classes called "protocols", and issuing each type of protocol
2901 * is slightly different.
2902 *
2903 * LOCKING:
2904 * spin_lock_irqsave(host_set lock)
2905 *
2906 * RETURNS:
2907 * Zero on success, negative on error.
2908 */
2909
2910int ata_qc_issue_prot(struct ata_queued_cmd *qc)
2911{
2912 struct ata_port *ap = qc->ap;
2913
2914 ata_dev_select(ap, qc->dev->devno, 1, 0);
2915
2916 switch (qc->tf.protocol) {
2917 case ATA_PROT_NODATA:
2918 ata_tf_to_host_nolock(ap, &qc->tf);
2919 break;
2920
2921 case ATA_PROT_DMA:
2922 ap->ops->tf_load(ap, &qc->tf); /* load tf registers */
2923 ap->ops->bmdma_setup(qc); /* set up bmdma */
2924 ap->ops->bmdma_start(qc); /* initiate bmdma */
2925 break;
2926
2927 case ATA_PROT_PIO: /* load tf registers, initiate polling pio */
2928 ata_qc_set_polling(qc);
2929 ata_tf_to_host_nolock(ap, &qc->tf);
2930 ap->pio_task_state = PIO_ST;
2931 queue_work(ata_wq, &ap->pio_task);
2932 break;
2933
2934 case ATA_PROT_ATAPI:
2935 ata_qc_set_polling(qc);
2936 ata_tf_to_host_nolock(ap, &qc->tf);
2937 queue_work(ata_wq, &ap->packet_task);
2938 break;
2939
2940 case ATA_PROT_ATAPI_NODATA:
2941 ata_tf_to_host_nolock(ap, &qc->tf);
2942 queue_work(ata_wq, &ap->packet_task);
2943 break;
2944
2945 case ATA_PROT_ATAPI_DMA:
2946 ap->ops->tf_load(ap, &qc->tf); /* load tf registers */
2947 ap->ops->bmdma_setup(qc); /* set up bmdma */
2948 queue_work(ata_wq, &ap->packet_task);
2949 break;
2950
2951 default:
2952 WARN_ON(1);
2953 return -1;
2954 }
2955
2956 return 0;
2957}
2958
2959/**
2960 * ata_bmdma_setup - Set up PCI IDE BMDMA transaction
2961 * @qc: Info associated with this ATA transaction.
2962 *
2963 * LOCKING:
2964 * spin_lock_irqsave(host_set lock)
2965 */
2966
2967static void ata_bmdma_setup_mmio (struct ata_queued_cmd *qc)
2968{
2969 struct ata_port *ap = qc->ap;
2970 unsigned int rw = (qc->tf.flags & ATA_TFLAG_WRITE);
2971 u8 dmactl;
2972 void __iomem *mmio = (void __iomem *) ap->ioaddr.bmdma_addr;
2973
2974 /* load PRD table addr. */
2975 mb(); /* make sure PRD table writes are visible to controller */
2976 writel(ap->prd_dma, mmio + ATA_DMA_TABLE_OFS);
2977
2978 /* specify data direction, triple-check start bit is clear */
2979 dmactl = readb(mmio + ATA_DMA_CMD);
2980 dmactl &= ~(ATA_DMA_WR | ATA_DMA_START);
2981 if (!rw)
2982 dmactl |= ATA_DMA_WR;
2983 writeb(dmactl, mmio + ATA_DMA_CMD);
2984
2985 /* issue r/w command */
2986 ap->ops->exec_command(ap, &qc->tf);
2987}
2988
2989/**
2990 * ata_bmdma_start - Start a PCI IDE BMDMA transaction
2991 * @qc: Info associated with this ATA transaction.
2992 *
2993 * LOCKING:
2994 * spin_lock_irqsave(host_set lock)
2995 */
2996
2997static void ata_bmdma_start_mmio (struct ata_queued_cmd *qc)
2998{
2999 struct ata_port *ap = qc->ap;
3000 void __iomem *mmio = (void __iomem *) ap->ioaddr.bmdma_addr;
3001 u8 dmactl;
3002
3003 /* start host DMA transaction */
3004 dmactl = readb(mmio + ATA_DMA_CMD);
3005 writeb(dmactl | ATA_DMA_START, mmio + ATA_DMA_CMD);
3006
3007 /* Strictly, one may wish to issue a readb() here, to
3008 * flush the mmio write. However, control also passes
3009 * to the hardware at this point, and it will interrupt
3010 * us when we are to resume control. So, in effect,
3011 * we don't care when the mmio write flushes.
3012 * Further, a read of the DMA status register _immediately_
3013 * following the write may not be what certain flaky hardware
3014 * is expected, so I think it is best to not add a readb()
3015 * without first all the MMIO ATA cards/mobos.
3016 * Or maybe I'm just being paranoid.
3017 */
3018}
3019
3020/**
3021 * ata_bmdma_setup_pio - Set up PCI IDE BMDMA transaction (PIO)
3022 * @qc: Info associated with this ATA transaction.
3023 *
3024 * LOCKING:
3025 * spin_lock_irqsave(host_set lock)
3026 */
3027
3028static void ata_bmdma_setup_pio (struct ata_queued_cmd *qc)
3029{
3030 struct ata_port *ap = qc->ap;
3031 unsigned int rw = (qc->tf.flags & ATA_TFLAG_WRITE);
3032 u8 dmactl;
3033
3034 /* load PRD table addr. */
3035 outl(ap->prd_dma, ap->ioaddr.bmdma_addr + ATA_DMA_TABLE_OFS);
3036
3037 /* specify data direction, triple-check start bit is clear */
3038 dmactl = inb(ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
3039 dmactl &= ~(ATA_DMA_WR | ATA_DMA_START);
3040 if (!rw)
3041 dmactl |= ATA_DMA_WR;
3042 outb(dmactl, ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
3043
3044 /* issue r/w command */
3045 ap->ops->exec_command(ap, &qc->tf);
3046}
3047
3048/**
3049 * ata_bmdma_start_pio - Start a PCI IDE BMDMA transaction (PIO)
3050 * @qc: Info associated with this ATA transaction.
3051 *
3052 * LOCKING:
3053 * spin_lock_irqsave(host_set lock)
3054 */
3055
3056static void ata_bmdma_start_pio (struct ata_queued_cmd *qc)
3057{
3058 struct ata_port *ap = qc->ap;
3059 u8 dmactl;
3060
3061 /* start host DMA transaction */
3062 dmactl = inb(ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
3063 outb(dmactl | ATA_DMA_START,
3064 ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
3065}
3066
3067void ata_bmdma_start(struct ata_queued_cmd *qc)
3068{
3069 if (qc->ap->flags & ATA_FLAG_MMIO)
3070 ata_bmdma_start_mmio(qc);
3071 else
3072 ata_bmdma_start_pio(qc);
3073}
3074
3075void ata_bmdma_setup(struct ata_queued_cmd *qc)
3076{
3077 if (qc->ap->flags & ATA_FLAG_MMIO)
3078 ata_bmdma_setup_mmio(qc);
3079 else
3080 ata_bmdma_setup_pio(qc);
3081}
3082
3083void ata_bmdma_irq_clear(struct ata_port *ap)
3084{
3085 if (ap->flags & ATA_FLAG_MMIO) {
3086 void __iomem *mmio = ((void __iomem *) ap->ioaddr.bmdma_addr) + ATA_DMA_STATUS;
3087 writeb(readb(mmio), mmio);
3088 } else {
3089 unsigned long addr = ap->ioaddr.bmdma_addr + ATA_DMA_STATUS;
3090 outb(inb(addr), addr);
3091 }
3092
3093}
3094
3095u8 ata_bmdma_status(struct ata_port *ap)
3096{
3097 u8 host_stat;
3098 if (ap->flags & ATA_FLAG_MMIO) {
3099 void __iomem *mmio = (void __iomem *) ap->ioaddr.bmdma_addr;
3100 host_stat = readb(mmio + ATA_DMA_STATUS);
3101 } else
3102 host_stat = inb(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
3103 return host_stat;
3104}
3105
3106void ata_bmdma_stop(struct ata_port *ap)
3107{
3108 if (ap->flags & ATA_FLAG_MMIO) {
3109 void __iomem *mmio = (void __iomem *) ap->ioaddr.bmdma_addr;
3110
3111 /* clear start/stop bit */
3112 writeb(readb(mmio + ATA_DMA_CMD) & ~ATA_DMA_START,
3113 mmio + ATA_DMA_CMD);
3114 } else {
3115 /* clear start/stop bit */
3116 outb(inb(ap->ioaddr.bmdma_addr + ATA_DMA_CMD) & ~ATA_DMA_START,
3117 ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
3118 }
3119
3120 /* one-PIO-cycle guaranteed wait, per spec, for HDMA1:0 transition */
3121 ata_altstatus(ap); /* dummy read */
3122}
3123
3124/**
3125 * ata_host_intr - Handle host interrupt for given (port, task)
3126 * @ap: Port on which interrupt arrived (possibly...)
3127 * @qc: Taskfile currently active in engine
3128 *
3129 * Handle host interrupt for given queued command. Currently,
3130 * only DMA interrupts are handled. All other commands are
3131 * handled via polling with interrupts disabled (nIEN bit).
3132 *
3133 * LOCKING:
3134 * spin_lock_irqsave(host_set lock)
3135 *
3136 * RETURNS:
3137 * One if interrupt was handled, zero if not (shared irq).
3138 */
3139
3140inline unsigned int ata_host_intr (struct ata_port *ap,
3141 struct ata_queued_cmd *qc)
3142{
3143 u8 status, host_stat;
3144
3145 switch (qc->tf.protocol) {
3146
3147 case ATA_PROT_DMA:
3148 case ATA_PROT_ATAPI_DMA:
3149 case ATA_PROT_ATAPI:
3150 /* check status of DMA engine */
3151 host_stat = ap->ops->bmdma_status(ap);
3152 VPRINTK("ata%u: host_stat 0x%X\n", ap->id, host_stat);
3153
3154 /* if it's not our irq... */
3155 if (!(host_stat & ATA_DMA_INTR))
3156 goto idle_irq;
3157
3158 /* before we do anything else, clear DMA-Start bit */
3159 ap->ops->bmdma_stop(ap);
3160
3161 /* fall through */
3162
3163 case ATA_PROT_ATAPI_NODATA:
3164 case ATA_PROT_NODATA:
3165 /* check altstatus */
3166 status = ata_altstatus(ap);
3167 if (status & ATA_BUSY)
3168 goto idle_irq;
3169
3170 /* check main status, clearing INTRQ */
3171 status = ata_chk_status(ap);
3172 if (unlikely(status & ATA_BUSY))
3173 goto idle_irq;
3174 DPRINTK("ata%u: protocol %d (dev_stat 0x%X)\n",
3175 ap->id, qc->tf.protocol, status);
3176
3177 /* ack bmdma irq events */
3178 ap->ops->irq_clear(ap);
3179
3180 /* complete taskfile transaction */
3181 ata_qc_complete(qc, status);
3182 break;
3183
3184 default:
3185 goto idle_irq;
3186 }
3187
3188 return 1; /* irq handled */
3189
3190idle_irq:
3191 ap->stats.idle_irq++;
3192
3193#ifdef ATA_IRQ_TRAP
3194 if ((ap->stats.idle_irq % 1000) == 0) {
3195 handled = 1;
3196 ata_irq_ack(ap, 0); /* debug trap */
3197 printk(KERN_WARNING "ata%d: irq trap\n", ap->id);
3198 }
3199#endif
3200 return 0; /* irq not handled */
3201}
3202
3203/**
3204 * ata_interrupt - Default ATA host interrupt handler
3205 * @irq: irq line
3206 * @dev_instance: pointer to our host information structure
3207 * @regs: unused
3208 *
3209 * LOCKING:
3210 *
3211 * RETURNS:
3212 *
3213 */
3214
3215irqreturn_t ata_interrupt (int irq, void *dev_instance, struct pt_regs *regs)
3216{
3217 struct ata_host_set *host_set = dev_instance;
3218 unsigned int i;
3219 unsigned int handled = 0;
3220 unsigned long flags;
3221
3222 /* TODO: make _irqsave conditional on x86 PCI IDE legacy mode */
3223 spin_lock_irqsave(&host_set->lock, flags);
3224
3225 for (i = 0; i < host_set->n_ports; i++) {
3226 struct ata_port *ap;
3227
3228 ap = host_set->ports[i];
3229 if (ap && (!(ap->flags & ATA_FLAG_PORT_DISABLED))) {
3230 struct ata_queued_cmd *qc;
3231
3232 qc = ata_qc_from_tag(ap, ap->active_tag);
Albert Lee21b1ed72005-04-29 17:34:59 +08003233 if (qc && (!(qc->tf.ctl & ATA_NIEN)) &&
3234 (qc->flags & ATA_QCFLAG_ACTIVE))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003235 handled |= ata_host_intr(ap, qc);
3236 }
3237 }
3238
3239 spin_unlock_irqrestore(&host_set->lock, flags);
3240
3241 return IRQ_RETVAL(handled);
3242}
3243
3244/**
3245 * atapi_packet_task - Write CDB bytes to hardware
3246 * @_data: Port to which ATAPI device is attached.
3247 *
3248 * When device has indicated its readiness to accept
3249 * a CDB, this function is called. Send the CDB.
3250 * If DMA is to be performed, exit immediately.
3251 * Otherwise, we are in polling mode, so poll
3252 * status under operation succeeds or fails.
3253 *
3254 * LOCKING:
3255 * Kernel thread context (may sleep)
3256 */
3257
3258static void atapi_packet_task(void *_data)
3259{
3260 struct ata_port *ap = _data;
3261 struct ata_queued_cmd *qc;
3262 u8 status;
3263
3264 qc = ata_qc_from_tag(ap, ap->active_tag);
3265 assert(qc != NULL);
3266 assert(qc->flags & ATA_QCFLAG_ACTIVE);
3267
3268 /* sleep-wait for BSY to clear */
3269 DPRINTK("busy wait\n");
3270 if (ata_busy_sleep(ap, ATA_TMOUT_CDB_QUICK, ATA_TMOUT_CDB))
3271 goto err_out;
3272
3273 /* make sure DRQ is set */
3274 status = ata_chk_status(ap);
3275 if ((status & (ATA_BUSY | ATA_DRQ)) != ATA_DRQ)
3276 goto err_out;
3277
3278 /* send SCSI cdb */
3279 DPRINTK("send cdb\n");
3280 assert(ap->cdb_len >= 12);
3281 ata_data_xfer(ap, qc->cdb, ap->cdb_len, 1);
3282
3283 /* if we are DMA'ing, irq handler takes over from here */
3284 if (qc->tf.protocol == ATA_PROT_ATAPI_DMA)
3285 ap->ops->bmdma_start(qc); /* initiate bmdma */
3286
3287 /* non-data commands are also handled via irq */
3288 else if (qc->tf.protocol == ATA_PROT_ATAPI_NODATA) {
3289 /* do nothing */
3290 }
3291
3292 /* PIO commands are handled by polling */
3293 else {
3294 ap->pio_task_state = PIO_ST;
3295 queue_work(ata_wq, &ap->pio_task);
3296 }
3297
3298 return;
3299
3300err_out:
3301 ata_qc_complete(qc, ATA_ERR);
3302}
3303
3304int ata_port_start (struct ata_port *ap)
3305{
3306 struct device *dev = ap->host_set->dev;
3307
3308 ap->prd = dma_alloc_coherent(dev, ATA_PRD_TBL_SZ, &ap->prd_dma, GFP_KERNEL);
3309 if (!ap->prd)
3310 return -ENOMEM;
3311
3312 DPRINTK("prd alloc, virt %p, dma %llx\n", ap->prd, (unsigned long long) ap->prd_dma);
3313
3314 return 0;
3315}
3316
3317void ata_port_stop (struct ata_port *ap)
3318{
3319 struct device *dev = ap->host_set->dev;
3320
3321 dma_free_coherent(dev, ATA_PRD_TBL_SZ, ap->prd, ap->prd_dma);
3322}
3323
3324/**
3325 * ata_host_remove - Unregister SCSI host structure with upper layers
3326 * @ap: Port to unregister
3327 * @do_unregister: 1 if we fully unregister, 0 to just stop the port
3328 *
3329 * LOCKING:
3330 */
3331
3332static void ata_host_remove(struct ata_port *ap, unsigned int do_unregister)
3333{
3334 struct Scsi_Host *sh = ap->host;
3335
3336 DPRINTK("ENTER\n");
3337
3338 if (do_unregister)
3339 scsi_remove_host(sh);
3340
3341 ap->ops->port_stop(ap);
3342}
3343
3344/**
3345 * ata_host_init - Initialize an ata_port structure
3346 * @ap: Structure to initialize
3347 * @host: associated SCSI mid-layer structure
3348 * @host_set: Collection of hosts to which @ap belongs
3349 * @ent: Probe information provided by low-level driver
3350 * @port_no: Port number associated with this ata_port
3351 *
3352 * LOCKING:
3353 *
3354 */
3355
3356static void ata_host_init(struct ata_port *ap, struct Scsi_Host *host,
3357 struct ata_host_set *host_set,
3358 struct ata_probe_ent *ent, unsigned int port_no)
3359{
3360 unsigned int i;
3361
3362 host->max_id = 16;
3363 host->max_lun = 1;
3364 host->max_channel = 1;
3365 host->unique_id = ata_unique_id++;
3366 host->max_cmd_len = 12;
3367 scsi_set_device(host, ent->dev);
3368 scsi_assign_lock(host, &host_set->lock);
3369
3370 ap->flags = ATA_FLAG_PORT_DISABLED;
3371 ap->id = host->unique_id;
3372 ap->host = host;
3373 ap->ctl = ATA_DEVCTL_OBS;
3374 ap->host_set = host_set;
3375 ap->port_no = port_no;
3376 ap->hard_port_no =
3377 ent->legacy_mode ? ent->hard_port_no : port_no;
3378 ap->pio_mask = ent->pio_mask;
3379 ap->mwdma_mask = ent->mwdma_mask;
3380 ap->udma_mask = ent->udma_mask;
3381 ap->flags |= ent->host_flags;
3382 ap->ops = ent->port_ops;
3383 ap->cbl = ATA_CBL_NONE;
3384 ap->active_tag = ATA_TAG_POISON;
3385 ap->last_ctl = 0xFF;
3386
3387 INIT_WORK(&ap->packet_task, atapi_packet_task, ap);
3388 INIT_WORK(&ap->pio_task, ata_pio_task, ap);
3389
3390 for (i = 0; i < ATA_MAX_DEVICES; i++)
3391 ap->device[i].devno = i;
3392
3393#ifdef ATA_IRQ_TRAP
3394 ap->stats.unhandled_irq = 1;
3395 ap->stats.idle_irq = 1;
3396#endif
3397
3398 memcpy(&ap->ioaddr, &ent->port[port_no], sizeof(struct ata_ioports));
3399}
3400
3401/**
3402 * ata_host_add - Attach low-level ATA driver to system
3403 * @ent: Information provided by low-level driver
3404 * @host_set: Collections of ports to which we add
3405 * @port_no: Port number associated with this host
3406 *
3407 * LOCKING:
3408 *
3409 * RETURNS:
3410 *
3411 */
3412
3413static struct ata_port * ata_host_add(struct ata_probe_ent *ent,
3414 struct ata_host_set *host_set,
3415 unsigned int port_no)
3416{
3417 struct Scsi_Host *host;
3418 struct ata_port *ap;
3419 int rc;
3420
3421 DPRINTK("ENTER\n");
3422 host = scsi_host_alloc(ent->sht, sizeof(struct ata_port));
3423 if (!host)
3424 return NULL;
3425
3426 ap = (struct ata_port *) &host->hostdata[0];
3427
3428 ata_host_init(ap, host, host_set, ent, port_no);
3429
3430 rc = ap->ops->port_start(ap);
3431 if (rc)
3432 goto err_out;
3433
3434 return ap;
3435
3436err_out:
3437 scsi_host_put(host);
3438 return NULL;
3439}
3440
3441/**
3442 * ata_device_add -
3443 * @ent:
3444 *
3445 * LOCKING:
3446 *
3447 * RETURNS:
3448 *
3449 */
3450
3451int ata_device_add(struct ata_probe_ent *ent)
3452{
3453 unsigned int count = 0, i;
3454 struct device *dev = ent->dev;
3455 struct ata_host_set *host_set;
3456
3457 DPRINTK("ENTER\n");
3458 /* alloc a container for our list of ATA ports (buses) */
3459 host_set = kmalloc(sizeof(struct ata_host_set) +
3460 (ent->n_ports * sizeof(void *)), GFP_KERNEL);
3461 if (!host_set)
3462 return 0;
3463 memset(host_set, 0, sizeof(struct ata_host_set) + (ent->n_ports * sizeof(void *)));
3464 spin_lock_init(&host_set->lock);
3465
3466 host_set->dev = dev;
3467 host_set->n_ports = ent->n_ports;
3468 host_set->irq = ent->irq;
3469 host_set->mmio_base = ent->mmio_base;
3470 host_set->private_data = ent->private_data;
3471 host_set->ops = ent->port_ops;
3472
3473 /* register each port bound to this device */
3474 for (i = 0; i < ent->n_ports; i++) {
3475 struct ata_port *ap;
3476 unsigned long xfer_mode_mask;
3477
3478 ap = ata_host_add(ent, host_set, i);
3479 if (!ap)
3480 goto err_out;
3481
3482 host_set->ports[i] = ap;
3483 xfer_mode_mask =(ap->udma_mask << ATA_SHIFT_UDMA) |
3484 (ap->mwdma_mask << ATA_SHIFT_MWDMA) |
3485 (ap->pio_mask << ATA_SHIFT_PIO);
3486
3487 /* print per-port info to dmesg */
3488 printk(KERN_INFO "ata%u: %cATA max %s cmd 0x%lX ctl 0x%lX "
3489 "bmdma 0x%lX irq %lu\n",
3490 ap->id,
3491 ap->flags & ATA_FLAG_SATA ? 'S' : 'P',
3492 ata_mode_string(xfer_mode_mask),
3493 ap->ioaddr.cmd_addr,
3494 ap->ioaddr.ctl_addr,
3495 ap->ioaddr.bmdma_addr,
3496 ent->irq);
3497
3498 ata_chk_status(ap);
3499 host_set->ops->irq_clear(ap);
3500 count++;
3501 }
3502
3503 if (!count) {
3504 kfree(host_set);
3505 return 0;
3506 }
3507
3508 /* obtain irq, that is shared between channels */
3509 if (request_irq(ent->irq, ent->port_ops->irq_handler, ent->irq_flags,
3510 DRV_NAME, host_set))
3511 goto err_out;
3512
3513 /* perform each probe synchronously */
3514 DPRINTK("probe begin\n");
3515 for (i = 0; i < count; i++) {
3516 struct ata_port *ap;
3517 int rc;
3518
3519 ap = host_set->ports[i];
3520
3521 DPRINTK("ata%u: probe begin\n", ap->id);
3522 rc = ata_bus_probe(ap);
3523 DPRINTK("ata%u: probe end\n", ap->id);
3524
3525 if (rc) {
3526 /* FIXME: do something useful here?
3527 * Current libata behavior will
3528 * tear down everything when
3529 * the module is removed
3530 * or the h/w is unplugged.
3531 */
3532 }
3533
3534 rc = scsi_add_host(ap->host, dev);
3535 if (rc) {
3536 printk(KERN_ERR "ata%u: scsi_add_host failed\n",
3537 ap->id);
3538 /* FIXME: do something useful here */
3539 /* FIXME: handle unconditional calls to
3540 * scsi_scan_host and ata_host_remove, below,
3541 * at the very least
3542 */
3543 }
3544 }
3545
3546 /* probes are done, now scan each port's disk(s) */
3547 DPRINTK("probe begin\n");
3548 for (i = 0; i < count; i++) {
3549 struct ata_port *ap = host_set->ports[i];
3550
3551 scsi_scan_host(ap->host);
3552 }
3553
3554 dev_set_drvdata(dev, host_set);
3555
3556 VPRINTK("EXIT, returning %u\n", ent->n_ports);
3557 return ent->n_ports; /* success */
3558
3559err_out:
3560 for (i = 0; i < count; i++) {
3561 ata_host_remove(host_set->ports[i], 1);
3562 scsi_host_put(host_set->ports[i]->host);
3563 }
3564 kfree(host_set);
3565 VPRINTK("EXIT, returning 0\n");
3566 return 0;
3567}
3568
3569/**
3570 * ata_scsi_release - SCSI layer callback hook for host unload
3571 * @host: libata host to be unloaded
3572 *
3573 * Performs all duties necessary to shut down a libata port...
3574 * Kill port kthread, disable port, and release resources.
3575 *
3576 * LOCKING:
3577 * Inherited from SCSI layer.
3578 *
3579 * RETURNS:
3580 * One.
3581 */
3582
3583int ata_scsi_release(struct Scsi_Host *host)
3584{
3585 struct ata_port *ap = (struct ata_port *) &host->hostdata[0];
3586
3587 DPRINTK("ENTER\n");
3588
3589 ap->ops->port_disable(ap);
3590 ata_host_remove(ap, 0);
3591
3592 DPRINTK("EXIT\n");
3593 return 1;
3594}
3595
3596/**
3597 * ata_std_ports - initialize ioaddr with standard port offsets.
3598 * @ioaddr: IO address structure to be initialized
3599 */
3600void ata_std_ports(struct ata_ioports *ioaddr)
3601{
3602 ioaddr->data_addr = ioaddr->cmd_addr + ATA_REG_DATA;
3603 ioaddr->error_addr = ioaddr->cmd_addr + ATA_REG_ERR;
3604 ioaddr->feature_addr = ioaddr->cmd_addr + ATA_REG_FEATURE;
3605 ioaddr->nsect_addr = ioaddr->cmd_addr + ATA_REG_NSECT;
3606 ioaddr->lbal_addr = ioaddr->cmd_addr + ATA_REG_LBAL;
3607 ioaddr->lbam_addr = ioaddr->cmd_addr + ATA_REG_LBAM;
3608 ioaddr->lbah_addr = ioaddr->cmd_addr + ATA_REG_LBAH;
3609 ioaddr->device_addr = ioaddr->cmd_addr + ATA_REG_DEVICE;
3610 ioaddr->status_addr = ioaddr->cmd_addr + ATA_REG_STATUS;
3611 ioaddr->command_addr = ioaddr->cmd_addr + ATA_REG_CMD;
3612}
3613
3614static struct ata_probe_ent *
3615ata_probe_ent_alloc(struct device *dev, struct ata_port_info *port)
3616{
3617 struct ata_probe_ent *probe_ent;
3618
3619 probe_ent = kmalloc(sizeof(*probe_ent), GFP_KERNEL);
3620 if (!probe_ent) {
3621 printk(KERN_ERR DRV_NAME "(%s): out of memory\n",
3622 kobject_name(&(dev->kobj)));
3623 return NULL;
3624 }
3625
3626 memset(probe_ent, 0, sizeof(*probe_ent));
3627
3628 INIT_LIST_HEAD(&probe_ent->node);
3629 probe_ent->dev = dev;
3630
3631 probe_ent->sht = port->sht;
3632 probe_ent->host_flags = port->host_flags;
3633 probe_ent->pio_mask = port->pio_mask;
3634 probe_ent->mwdma_mask = port->mwdma_mask;
3635 probe_ent->udma_mask = port->udma_mask;
3636 probe_ent->port_ops = port->port_ops;
3637
3638 return probe_ent;
3639}
3640
3641#ifdef CONFIG_PCI
3642struct ata_probe_ent *
3643ata_pci_init_native_mode(struct pci_dev *pdev, struct ata_port_info **port)
3644{
3645 struct ata_probe_ent *probe_ent =
3646 ata_probe_ent_alloc(pci_dev_to_dev(pdev), port[0]);
3647 if (!probe_ent)
3648 return NULL;
3649
3650 probe_ent->n_ports = 2;
3651 probe_ent->irq = pdev->irq;
3652 probe_ent->irq_flags = SA_SHIRQ;
3653
3654 probe_ent->port[0].cmd_addr = pci_resource_start(pdev, 0);
3655 probe_ent->port[0].altstatus_addr =
3656 probe_ent->port[0].ctl_addr =
3657 pci_resource_start(pdev, 1) | ATA_PCI_CTL_OFS;
3658 probe_ent->port[0].bmdma_addr = pci_resource_start(pdev, 4);
3659
3660 probe_ent->port[1].cmd_addr = pci_resource_start(pdev, 2);
3661 probe_ent->port[1].altstatus_addr =
3662 probe_ent->port[1].ctl_addr =
3663 pci_resource_start(pdev, 3) | ATA_PCI_CTL_OFS;
3664 probe_ent->port[1].bmdma_addr = pci_resource_start(pdev, 4) + 8;
3665
3666 ata_std_ports(&probe_ent->port[0]);
3667 ata_std_ports(&probe_ent->port[1]);
3668
3669 return probe_ent;
3670}
3671
3672static struct ata_probe_ent *
3673ata_pci_init_legacy_mode(struct pci_dev *pdev, struct ata_port_info **port,
3674 struct ata_probe_ent **ppe2)
3675{
3676 struct ata_probe_ent *probe_ent, *probe_ent2;
3677
3678 probe_ent = ata_probe_ent_alloc(pci_dev_to_dev(pdev), port[0]);
3679 if (!probe_ent)
3680 return NULL;
3681 probe_ent2 = ata_probe_ent_alloc(pci_dev_to_dev(pdev), port[1]);
3682 if (!probe_ent2) {
3683 kfree(probe_ent);
3684 return NULL;
3685 }
3686
3687 probe_ent->n_ports = 1;
3688 probe_ent->irq = 14;
3689
3690 probe_ent->hard_port_no = 0;
3691 probe_ent->legacy_mode = 1;
3692
3693 probe_ent2->n_ports = 1;
3694 probe_ent2->irq = 15;
3695
3696 probe_ent2->hard_port_no = 1;
3697 probe_ent2->legacy_mode = 1;
3698
3699 probe_ent->port[0].cmd_addr = 0x1f0;
3700 probe_ent->port[0].altstatus_addr =
3701 probe_ent->port[0].ctl_addr = 0x3f6;
3702 probe_ent->port[0].bmdma_addr = pci_resource_start(pdev, 4);
3703
3704 probe_ent2->port[0].cmd_addr = 0x170;
3705 probe_ent2->port[0].altstatus_addr =
3706 probe_ent2->port[0].ctl_addr = 0x376;
3707 probe_ent2->port[0].bmdma_addr = pci_resource_start(pdev, 4)+8;
3708
3709 ata_std_ports(&probe_ent->port[0]);
3710 ata_std_ports(&probe_ent2->port[0]);
3711
3712 *ppe2 = probe_ent2;
3713 return probe_ent;
3714}
3715
3716/**
3717 * ata_pci_init_one - Initialize/register PCI IDE host controller
3718 * @pdev: Controller to be initialized
3719 * @port_info: Information from low-level host driver
3720 * @n_ports: Number of ports attached to host controller
3721 *
3722 * LOCKING:
3723 * Inherited from PCI layer (may sleep).
3724 *
3725 * RETURNS:
3726 *
3727 */
3728
3729int ata_pci_init_one (struct pci_dev *pdev, struct ata_port_info **port_info,
3730 unsigned int n_ports)
3731{
3732 struct ata_probe_ent *probe_ent, *probe_ent2 = NULL;
3733 struct ata_port_info *port[2];
3734 u8 tmp8, mask;
3735 unsigned int legacy_mode = 0;
3736 int disable_dev_on_err = 1;
3737 int rc;
3738
3739 DPRINTK("ENTER\n");
3740
3741 port[0] = port_info[0];
3742 if (n_ports > 1)
3743 port[1] = port_info[1];
3744 else
3745 port[1] = port[0];
3746
3747 if ((port[0]->host_flags & ATA_FLAG_NO_LEGACY) == 0
3748 && (pdev->class >> 8) == PCI_CLASS_STORAGE_IDE) {
3749 /* TODO: support transitioning to native mode? */
3750 pci_read_config_byte(pdev, PCI_CLASS_PROG, &tmp8);
3751 mask = (1 << 2) | (1 << 0);
3752 if ((tmp8 & mask) != mask)
3753 legacy_mode = (1 << 3);
3754 }
3755
3756 /* FIXME... */
3757 if ((!legacy_mode) && (n_ports > 1)) {
3758 printk(KERN_ERR "ata: BUG: native mode, n_ports > 1\n");
3759 return -EINVAL;
3760 }
3761
3762 rc = pci_enable_device(pdev);
3763 if (rc)
3764 return rc;
3765
3766 rc = pci_request_regions(pdev, DRV_NAME);
3767 if (rc) {
3768 disable_dev_on_err = 0;
3769 goto err_out;
3770 }
3771
3772 if (legacy_mode) {
3773 if (!request_region(0x1f0, 8, "libata")) {
3774 struct resource *conflict, res;
3775 res.start = 0x1f0;
3776 res.end = 0x1f0 + 8 - 1;
3777 conflict = ____request_resource(&ioport_resource, &res);
3778 if (!strcmp(conflict->name, "libata"))
3779 legacy_mode |= (1 << 0);
3780 else {
3781 disable_dev_on_err = 0;
3782 printk(KERN_WARNING "ata: 0x1f0 IDE port busy\n");
3783 }
3784 } else
3785 legacy_mode |= (1 << 0);
3786
3787 if (!request_region(0x170, 8, "libata")) {
3788 struct resource *conflict, res;
3789 res.start = 0x170;
3790 res.end = 0x170 + 8 - 1;
3791 conflict = ____request_resource(&ioport_resource, &res);
3792 if (!strcmp(conflict->name, "libata"))
3793 legacy_mode |= (1 << 1);
3794 else {
3795 disable_dev_on_err = 0;
3796 printk(KERN_WARNING "ata: 0x170 IDE port busy\n");
3797 }
3798 } else
3799 legacy_mode |= (1 << 1);
3800 }
3801
3802 /* we have legacy mode, but all ports are unavailable */
3803 if (legacy_mode == (1 << 3)) {
3804 rc = -EBUSY;
3805 goto err_out_regions;
3806 }
3807
3808 rc = pci_set_dma_mask(pdev, ATA_DMA_MASK);
3809 if (rc)
3810 goto err_out_regions;
3811 rc = pci_set_consistent_dma_mask(pdev, ATA_DMA_MASK);
3812 if (rc)
3813 goto err_out_regions;
3814
3815 if (legacy_mode) {
3816 probe_ent = ata_pci_init_legacy_mode(pdev, port, &probe_ent2);
3817 } else
3818 probe_ent = ata_pci_init_native_mode(pdev, port);
3819 if (!probe_ent) {
3820 rc = -ENOMEM;
3821 goto err_out_regions;
3822 }
3823
3824 pci_set_master(pdev);
3825
3826 /* FIXME: check ata_device_add return */
3827 if (legacy_mode) {
3828 if (legacy_mode & (1 << 0))
3829 ata_device_add(probe_ent);
3830 if (legacy_mode & (1 << 1))
3831 ata_device_add(probe_ent2);
3832 } else
3833 ata_device_add(probe_ent);
3834
3835 kfree(probe_ent);
3836 kfree(probe_ent2);
3837
3838 return 0;
3839
3840err_out_regions:
3841 if (legacy_mode & (1 << 0))
3842 release_region(0x1f0, 8);
3843 if (legacy_mode & (1 << 1))
3844 release_region(0x170, 8);
3845 pci_release_regions(pdev);
3846err_out:
3847 if (disable_dev_on_err)
3848 pci_disable_device(pdev);
3849 return rc;
3850}
3851
3852/**
3853 * ata_pci_remove_one - PCI layer callback for device removal
3854 * @pdev: PCI device that was removed
3855 *
3856 * PCI layer indicates to libata via this hook that
3857 * hot-unplug or module unload event has occured.
3858 * Handle this by unregistering all objects associated
3859 * with this PCI device. Free those objects. Then finally
3860 * release PCI resources and disable device.
3861 *
3862 * LOCKING:
3863 * Inherited from PCI layer (may sleep).
3864 */
3865
3866void ata_pci_remove_one (struct pci_dev *pdev)
3867{
3868 struct device *dev = pci_dev_to_dev(pdev);
3869 struct ata_host_set *host_set = dev_get_drvdata(dev);
3870 struct ata_port *ap;
3871 unsigned int i;
3872
3873 for (i = 0; i < host_set->n_ports; i++) {
3874 ap = host_set->ports[i];
3875
3876 scsi_remove_host(ap->host);
3877 }
3878
3879 free_irq(host_set->irq, host_set);
3880 if (host_set->ops->host_stop)
3881 host_set->ops->host_stop(host_set);
3882 if (host_set->mmio_base)
3883 iounmap(host_set->mmio_base);
3884
3885 for (i = 0; i < host_set->n_ports; i++) {
3886 ap = host_set->ports[i];
3887
3888 ata_scsi_release(ap->host);
3889
3890 if ((ap->flags & ATA_FLAG_NO_LEGACY) == 0) {
3891 struct ata_ioports *ioaddr = &ap->ioaddr;
3892
3893 if (ioaddr->cmd_addr == 0x1f0)
3894 release_region(0x1f0, 8);
3895 else if (ioaddr->cmd_addr == 0x170)
3896 release_region(0x170, 8);
3897 }
3898
3899 scsi_host_put(ap->host);
3900 }
3901
3902 kfree(host_set);
3903
3904 pci_release_regions(pdev);
3905 pci_disable_device(pdev);
3906 dev_set_drvdata(dev, NULL);
3907}
3908
3909/* move to PCI subsystem */
3910int pci_test_config_bits(struct pci_dev *pdev, struct pci_bits *bits)
3911{
3912 unsigned long tmp = 0;
3913
3914 switch (bits->width) {
3915 case 1: {
3916 u8 tmp8 = 0;
3917 pci_read_config_byte(pdev, bits->reg, &tmp8);
3918 tmp = tmp8;
3919 break;
3920 }
3921 case 2: {
3922 u16 tmp16 = 0;
3923 pci_read_config_word(pdev, bits->reg, &tmp16);
3924 tmp = tmp16;
3925 break;
3926 }
3927 case 4: {
3928 u32 tmp32 = 0;
3929 pci_read_config_dword(pdev, bits->reg, &tmp32);
3930 tmp = tmp32;
3931 break;
3932 }
3933
3934 default:
3935 return -EINVAL;
3936 }
3937
3938 tmp &= bits->mask;
3939
3940 return (tmp == bits->val) ? 1 : 0;
3941}
3942#endif /* CONFIG_PCI */
3943
3944
3945/**
3946 * ata_init -
3947 *
3948 * LOCKING:
3949 *
3950 * RETURNS:
3951 *
3952 */
3953
3954static int __init ata_init(void)
3955{
3956 ata_wq = create_workqueue("ata");
3957 if (!ata_wq)
3958 return -ENOMEM;
3959
3960 printk(KERN_DEBUG "libata version " DRV_VERSION " loaded.\n");
3961 return 0;
3962}
3963
3964static void __exit ata_exit(void)
3965{
3966 destroy_workqueue(ata_wq);
3967}
3968
3969module_init(ata_init);
3970module_exit(ata_exit);
3971
3972/*
3973 * libata is essentially a library of internal helper functions for
3974 * low-level ATA host controller drivers. As such, the API/ABI is
3975 * likely to change as new drivers are added and updated.
3976 * Do not depend on ABI/API stability.
3977 */
3978
3979EXPORT_SYMBOL_GPL(ata_std_bios_param);
3980EXPORT_SYMBOL_GPL(ata_std_ports);
3981EXPORT_SYMBOL_GPL(ata_device_add);
3982EXPORT_SYMBOL_GPL(ata_sg_init);
3983EXPORT_SYMBOL_GPL(ata_sg_init_one);
3984EXPORT_SYMBOL_GPL(ata_qc_complete);
3985EXPORT_SYMBOL_GPL(ata_qc_issue_prot);
3986EXPORT_SYMBOL_GPL(ata_eng_timeout);
3987EXPORT_SYMBOL_GPL(ata_tf_load);
3988EXPORT_SYMBOL_GPL(ata_tf_read);
3989EXPORT_SYMBOL_GPL(ata_noop_dev_select);
3990EXPORT_SYMBOL_GPL(ata_std_dev_select);
3991EXPORT_SYMBOL_GPL(ata_tf_to_fis);
3992EXPORT_SYMBOL_GPL(ata_tf_from_fis);
3993EXPORT_SYMBOL_GPL(ata_check_status);
3994EXPORT_SYMBOL_GPL(ata_altstatus);
3995EXPORT_SYMBOL_GPL(ata_chk_err);
3996EXPORT_SYMBOL_GPL(ata_exec_command);
3997EXPORT_SYMBOL_GPL(ata_port_start);
3998EXPORT_SYMBOL_GPL(ata_port_stop);
3999EXPORT_SYMBOL_GPL(ata_interrupt);
4000EXPORT_SYMBOL_GPL(ata_qc_prep);
4001EXPORT_SYMBOL_GPL(ata_bmdma_setup);
4002EXPORT_SYMBOL_GPL(ata_bmdma_start);
4003EXPORT_SYMBOL_GPL(ata_bmdma_irq_clear);
4004EXPORT_SYMBOL_GPL(ata_bmdma_status);
4005EXPORT_SYMBOL_GPL(ata_bmdma_stop);
4006EXPORT_SYMBOL_GPL(ata_port_probe);
4007EXPORT_SYMBOL_GPL(sata_phy_reset);
4008EXPORT_SYMBOL_GPL(__sata_phy_reset);
4009EXPORT_SYMBOL_GPL(ata_bus_reset);
4010EXPORT_SYMBOL_GPL(ata_port_disable);
4011EXPORT_SYMBOL_GPL(ata_scsi_ioctl);
4012EXPORT_SYMBOL_GPL(ata_scsi_queuecmd);
4013EXPORT_SYMBOL_GPL(ata_scsi_error);
4014EXPORT_SYMBOL_GPL(ata_scsi_slave_config);
4015EXPORT_SYMBOL_GPL(ata_scsi_release);
4016EXPORT_SYMBOL_GPL(ata_host_intr);
4017EXPORT_SYMBOL_GPL(ata_dev_classify);
4018EXPORT_SYMBOL_GPL(ata_dev_id_string);
4019EXPORT_SYMBOL_GPL(ata_scsi_simulate);
4020
4021#ifdef CONFIG_PCI
4022EXPORT_SYMBOL_GPL(pci_test_config_bits);
4023EXPORT_SYMBOL_GPL(ata_pci_init_native_mode);
4024EXPORT_SYMBOL_GPL(ata_pci_init_one);
4025EXPORT_SYMBOL_GPL(ata_pci_remove_one);
4026#endif /* CONFIG_PCI */