blob: 9add4c521b6bc5a868cd3937fcd5625ae8b8ca86 [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
Edward Falk0baab862005-06-02 18:17:13 -0400189
190/**
191 * ata_tf_load - send taskfile registers to host controller
192 * @ap: Port to which output is sent
193 * @tf: ATA taskfile register set
194 *
195 * Outputs ATA taskfile to standard ATA host controller using MMIO
196 * or PIO as indicated by the ATA_FLAG_MMIO flag.
197 * Writes the control, feature, nsect, lbal, lbam, and lbah registers.
198 * Optionally (ATA_TFLAG_LBA48) writes hob_feature, hob_nsect,
199 * hob_lbal, hob_lbam, and hob_lbah.
200 *
201 * This function waits for idle (!BUSY and !DRQ) after writing
202 * registers. If the control register has a new value, this
203 * function also waits for idle after writing control and before
204 * writing the remaining registers.
205 *
206 * May be used as the tf_load() entry in ata_port_operations.
207 *
208 * LOCKING:
209 * Inherited from caller.
210 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211void ata_tf_load(struct ata_port *ap, struct ata_taskfile *tf)
212{
213 if (ap->flags & ATA_FLAG_MMIO)
214 ata_tf_load_mmio(ap, tf);
215 else
216 ata_tf_load_pio(ap, tf);
217}
218
219/**
Edward Falk0baab862005-06-02 18:17:13 -0400220 * ata_exec_command_pio - issue ATA command to host controller
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221 * @ap: port to which command is being issued
222 * @tf: ATA taskfile register set
223 *
Edward Falk0baab862005-06-02 18:17:13 -0400224 * Issues PIO write to ATA command register, with proper
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225 * synchronization with interrupt handler / other threads.
226 *
227 * LOCKING:
228 * spin_lock_irqsave(host_set lock)
229 */
230
231static void ata_exec_command_pio(struct ata_port *ap, struct ata_taskfile *tf)
232{
233 DPRINTK("ata%u: cmd 0x%X\n", ap->id, tf->command);
234
235 outb(tf->command, ap->ioaddr.command_addr);
236 ata_pause(ap);
237}
238
239
240/**
241 * ata_exec_command_mmio - issue ATA command to host controller
242 * @ap: port to which command is being issued
243 * @tf: ATA taskfile register set
244 *
245 * Issues MMIO write to ATA command register, with proper
246 * synchronization with interrupt handler / other threads.
247 *
248 * LOCKING:
249 * spin_lock_irqsave(host_set lock)
250 */
251
252static void ata_exec_command_mmio(struct ata_port *ap, struct ata_taskfile *tf)
253{
254 DPRINTK("ata%u: cmd 0x%X\n", ap->id, tf->command);
255
256 writeb(tf->command, (void __iomem *) ap->ioaddr.command_addr);
257 ata_pause(ap);
258}
259
Edward Falk0baab862005-06-02 18:17:13 -0400260
261/**
262 * ata_exec_command - issue ATA command to host controller
263 * @ap: port to which command is being issued
264 * @tf: ATA taskfile register set
265 *
266 * Issues PIO/MMIO write to ATA command register, with proper
267 * synchronization with interrupt handler / other threads.
268 *
269 * LOCKING:
270 * spin_lock_irqsave(host_set lock)
271 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272void ata_exec_command(struct ata_port *ap, struct ata_taskfile *tf)
273{
274 if (ap->flags & ATA_FLAG_MMIO)
275 ata_exec_command_mmio(ap, tf);
276 else
277 ata_exec_command_pio(ap, tf);
278}
279
280/**
281 * ata_exec - issue ATA command to host controller
282 * @ap: port to which command is being issued
283 * @tf: ATA taskfile register set
284 *
285 * Issues PIO/MMIO write to ATA command register, with proper
286 * synchronization with interrupt handler / other threads.
287 *
288 * LOCKING:
289 * Obtains host_set lock.
290 */
291
292static inline void ata_exec(struct ata_port *ap, struct ata_taskfile *tf)
293{
294 unsigned long flags;
295
296 DPRINTK("ata%u: cmd 0x%X\n", ap->id, tf->command);
297 spin_lock_irqsave(&ap->host_set->lock, flags);
298 ap->ops->exec_command(ap, tf);
299 spin_unlock_irqrestore(&ap->host_set->lock, flags);
300}
301
302/**
303 * ata_tf_to_host - issue ATA taskfile to host controller
304 * @ap: port to which command is being issued
305 * @tf: ATA taskfile register set
306 *
307 * Issues ATA taskfile register set to ATA host controller,
308 * with proper synchronization with interrupt handler and
309 * other threads.
310 *
311 * LOCKING:
312 * Obtains host_set lock.
313 */
314
315static void ata_tf_to_host(struct ata_port *ap, struct ata_taskfile *tf)
316{
317 ap->ops->tf_load(ap, tf);
318
319 ata_exec(ap, tf);
320}
321
322/**
323 * ata_tf_to_host_nolock - issue ATA taskfile to host controller
324 * @ap: port to which command is being issued
325 * @tf: ATA taskfile register set
326 *
327 * Issues ATA taskfile register set to ATA host controller,
328 * with proper synchronization with interrupt handler and
329 * other threads.
330 *
331 * LOCKING:
332 * spin_lock_irqsave(host_set lock)
333 */
334
335void ata_tf_to_host_nolock(struct ata_port *ap, struct ata_taskfile *tf)
336{
337 ap->ops->tf_load(ap, tf);
338 ap->ops->exec_command(ap, tf);
339}
340
341/**
Edward Falk0baab862005-06-02 18:17:13 -0400342 * ata_tf_read_pio - input device's ATA taskfile shadow registers
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343 * @ap: Port from which input is read
344 * @tf: ATA taskfile register set for storing input
345 *
346 * Reads ATA taskfile registers for currently-selected device
347 * into @tf.
348 *
349 * LOCKING:
350 * Inherited from caller.
351 */
352
353static void ata_tf_read_pio(struct ata_port *ap, struct ata_taskfile *tf)
354{
355 struct ata_ioports *ioaddr = &ap->ioaddr;
356
357 tf->nsect = inb(ioaddr->nsect_addr);
358 tf->lbal = inb(ioaddr->lbal_addr);
359 tf->lbam = inb(ioaddr->lbam_addr);
360 tf->lbah = inb(ioaddr->lbah_addr);
361 tf->device = inb(ioaddr->device_addr);
362
363 if (tf->flags & ATA_TFLAG_LBA48) {
364 outb(tf->ctl | ATA_HOB, ioaddr->ctl_addr);
365 tf->hob_feature = inb(ioaddr->error_addr);
366 tf->hob_nsect = inb(ioaddr->nsect_addr);
367 tf->hob_lbal = inb(ioaddr->lbal_addr);
368 tf->hob_lbam = inb(ioaddr->lbam_addr);
369 tf->hob_lbah = inb(ioaddr->lbah_addr);
370 }
371}
372
373/**
374 * ata_tf_read_mmio - input device's ATA taskfile shadow registers
375 * @ap: Port from which input is read
376 * @tf: ATA taskfile register set for storing input
377 *
378 * Reads ATA taskfile registers for currently-selected device
379 * into @tf via MMIO.
380 *
381 * LOCKING:
382 * Inherited from caller.
383 */
384
385static void ata_tf_read_mmio(struct ata_port *ap, struct ata_taskfile *tf)
386{
387 struct ata_ioports *ioaddr = &ap->ioaddr;
388
389 tf->nsect = readb((void __iomem *)ioaddr->nsect_addr);
390 tf->lbal = readb((void __iomem *)ioaddr->lbal_addr);
391 tf->lbam = readb((void __iomem *)ioaddr->lbam_addr);
392 tf->lbah = readb((void __iomem *)ioaddr->lbah_addr);
393 tf->device = readb((void __iomem *)ioaddr->device_addr);
394
395 if (tf->flags & ATA_TFLAG_LBA48) {
396 writeb(tf->ctl | ATA_HOB, (void __iomem *) ap->ioaddr.ctl_addr);
397 tf->hob_feature = readb((void __iomem *)ioaddr->error_addr);
398 tf->hob_nsect = readb((void __iomem *)ioaddr->nsect_addr);
399 tf->hob_lbal = readb((void __iomem *)ioaddr->lbal_addr);
400 tf->hob_lbam = readb((void __iomem *)ioaddr->lbam_addr);
401 tf->hob_lbah = readb((void __iomem *)ioaddr->lbah_addr);
402 }
403}
404
Edward Falk0baab862005-06-02 18:17:13 -0400405
406/**
407 * ata_tf_read - input device's ATA taskfile shadow registers
408 * @ap: Port from which input is read
409 * @tf: ATA taskfile register set for storing input
410 *
411 * Reads ATA taskfile registers for currently-selected device
412 * into @tf.
413 *
414 * Reads nsect, lbal, lbam, lbah, and device. If ATA_TFLAG_LBA48
415 * is set, also reads the hob registers.
416 *
417 * May be used as the tf_read() entry in ata_port_operations.
418 *
419 * LOCKING:
420 * Inherited from caller.
421 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422void ata_tf_read(struct ata_port *ap, struct ata_taskfile *tf)
423{
424 if (ap->flags & ATA_FLAG_MMIO)
425 ata_tf_read_mmio(ap, tf);
426 else
427 ata_tf_read_pio(ap, tf);
428}
429
430/**
431 * ata_check_status_pio - Read device status reg & clear interrupt
432 * @ap: port where the device is
433 *
434 * Reads ATA taskfile status register for currently-selected device
Edward Falk0baab862005-06-02 18:17:13 -0400435 * and return its value. This also clears pending interrupts
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436 * from this device
437 *
438 * LOCKING:
439 * Inherited from caller.
440 */
441static u8 ata_check_status_pio(struct ata_port *ap)
442{
443 return inb(ap->ioaddr.status_addr);
444}
445
446/**
447 * ata_check_status_mmio - Read device status reg & clear interrupt
448 * @ap: port where the device is
449 *
450 * Reads ATA taskfile status register for currently-selected device
Edward Falk0baab862005-06-02 18:17:13 -0400451 * via MMIO and return its value. This also clears pending interrupts
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452 * from this device
453 *
454 * LOCKING:
455 * Inherited from caller.
456 */
457static u8 ata_check_status_mmio(struct ata_port *ap)
458{
459 return readb((void __iomem *) ap->ioaddr.status_addr);
460}
461
Edward Falk0baab862005-06-02 18:17:13 -0400462
463/**
464 * ata_check_status - Read device status reg & clear interrupt
465 * @ap: port where the device is
466 *
467 * Reads ATA taskfile status register for currently-selected device
468 * and return its value. This also clears pending interrupts
469 * from this device
470 *
471 * May be used as the check_status() entry in ata_port_operations.
472 *
473 * LOCKING:
474 * Inherited from caller.
475 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476u8 ata_check_status(struct ata_port *ap)
477{
478 if (ap->flags & ATA_FLAG_MMIO)
479 return ata_check_status_mmio(ap);
480 return ata_check_status_pio(ap);
481}
482
Edward Falk0baab862005-06-02 18:17:13 -0400483
484/**
485 * ata_altstatus - Read device alternate status reg
486 * @ap: port where the device is
487 *
488 * Reads ATA taskfile alternate status register for
489 * currently-selected device and return its value.
490 *
491 * Note: may NOT be used as the check_altstatus() entry in
492 * ata_port_operations.
493 *
494 * LOCKING:
495 * Inherited from caller.
496 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497u8 ata_altstatus(struct ata_port *ap)
498{
499 if (ap->ops->check_altstatus)
500 return ap->ops->check_altstatus(ap);
501
502 if (ap->flags & ATA_FLAG_MMIO)
503 return readb((void __iomem *)ap->ioaddr.altstatus_addr);
504 return inb(ap->ioaddr.altstatus_addr);
505}
506
Edward Falk0baab862005-06-02 18:17:13 -0400507
508/**
509 * ata_chk_err - Read device error reg
510 * @ap: port where the device is
511 *
512 * Reads ATA taskfile error register for
513 * currently-selected device and return its value.
514 *
515 * Note: may NOT be used as the check_err() entry in
516 * ata_port_operations.
517 *
518 * LOCKING:
519 * Inherited from caller.
520 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521u8 ata_chk_err(struct ata_port *ap)
522{
523 if (ap->ops->check_err)
524 return ap->ops->check_err(ap);
525
526 if (ap->flags & ATA_FLAG_MMIO) {
527 return readb((void __iomem *) ap->ioaddr.error_addr);
528 }
529 return inb(ap->ioaddr.error_addr);
530}
531
532/**
533 * ata_tf_to_fis - Convert ATA taskfile to SATA FIS structure
534 * @tf: Taskfile to convert
535 * @fis: Buffer into which data will output
536 * @pmp: Port multiplier port
537 *
538 * Converts a standard ATA taskfile to a Serial ATA
539 * FIS structure (Register - Host to Device).
540 *
541 * LOCKING:
542 * Inherited from caller.
543 */
544
545void ata_tf_to_fis(struct ata_taskfile *tf, u8 *fis, u8 pmp)
546{
547 fis[0] = 0x27; /* Register - Host to Device FIS */
548 fis[1] = (pmp & 0xf) | (1 << 7); /* Port multiplier number,
549 bit 7 indicates Command FIS */
550 fis[2] = tf->command;
551 fis[3] = tf->feature;
552
553 fis[4] = tf->lbal;
554 fis[5] = tf->lbam;
555 fis[6] = tf->lbah;
556 fis[7] = tf->device;
557
558 fis[8] = tf->hob_lbal;
559 fis[9] = tf->hob_lbam;
560 fis[10] = tf->hob_lbah;
561 fis[11] = tf->hob_feature;
562
563 fis[12] = tf->nsect;
564 fis[13] = tf->hob_nsect;
565 fis[14] = 0;
566 fis[15] = tf->ctl;
567
568 fis[16] = 0;
569 fis[17] = 0;
570 fis[18] = 0;
571 fis[19] = 0;
572}
573
574/**
575 * ata_tf_from_fis - Convert SATA FIS to ATA taskfile
576 * @fis: Buffer from which data will be input
577 * @tf: Taskfile to output
578 *
579 * Converts a standard ATA taskfile to a Serial ATA
580 * FIS structure (Register - Host to Device).
581 *
582 * LOCKING:
583 * Inherited from caller.
584 */
585
586void ata_tf_from_fis(u8 *fis, struct ata_taskfile *tf)
587{
588 tf->command = fis[2]; /* status */
589 tf->feature = fis[3]; /* error */
590
591 tf->lbal = fis[4];
592 tf->lbam = fis[5];
593 tf->lbah = fis[6];
594 tf->device = fis[7];
595
596 tf->hob_lbal = fis[8];
597 tf->hob_lbam = fis[9];
598 tf->hob_lbah = fis[10];
599
600 tf->nsect = fis[12];
601 tf->hob_nsect = fis[13];
602}
603
604/**
605 * ata_prot_to_cmd - determine which read/write opcodes to use
606 * @protocol: ATA_PROT_xxx taskfile protocol
607 * @lba48: true is lba48 is present
608 *
609 * Given necessary input, determine which read/write commands
610 * to use to transfer data.
611 *
612 * LOCKING:
613 * None.
614 */
615static int ata_prot_to_cmd(int protocol, int lba48)
616{
617 int rcmd = 0, wcmd = 0;
618
619 switch (protocol) {
620 case ATA_PROT_PIO:
621 if (lba48) {
622 rcmd = ATA_CMD_PIO_READ_EXT;
623 wcmd = ATA_CMD_PIO_WRITE_EXT;
624 } else {
625 rcmd = ATA_CMD_PIO_READ;
626 wcmd = ATA_CMD_PIO_WRITE;
627 }
628 break;
629
630 case ATA_PROT_DMA:
631 if (lba48) {
632 rcmd = ATA_CMD_READ_EXT;
633 wcmd = ATA_CMD_WRITE_EXT;
634 } else {
635 rcmd = ATA_CMD_READ;
636 wcmd = ATA_CMD_WRITE;
637 }
638 break;
639
640 default:
641 return -1;
642 }
643
644 return rcmd | (wcmd << 8);
645}
646
647/**
648 * ata_dev_set_protocol - set taskfile protocol and r/w commands
649 * @dev: device to examine and configure
650 *
651 * Examine the device configuration, after we have
652 * read the identify-device page and configured the
653 * data transfer mode. Set internal state related to
654 * the ATA taskfile protocol (pio, pio mult, dma, etc.)
655 * and calculate the proper read/write commands to use.
656 *
657 * LOCKING:
658 * caller.
659 */
660static void ata_dev_set_protocol(struct ata_device *dev)
661{
662 int pio = (dev->flags & ATA_DFLAG_PIO);
663 int lba48 = (dev->flags & ATA_DFLAG_LBA48);
664 int proto, cmd;
665
666 if (pio)
667 proto = dev->xfer_protocol = ATA_PROT_PIO;
668 else
669 proto = dev->xfer_protocol = ATA_PROT_DMA;
670
671 cmd = ata_prot_to_cmd(proto, lba48);
672 if (cmd < 0)
673 BUG();
674
675 dev->read_cmd = cmd & 0xff;
676 dev->write_cmd = (cmd >> 8) & 0xff;
677}
678
679static const char * xfer_mode_str[] = {
680 "UDMA/16",
681 "UDMA/25",
682 "UDMA/33",
683 "UDMA/44",
684 "UDMA/66",
685 "UDMA/100",
686 "UDMA/133",
687 "UDMA7",
688 "MWDMA0",
689 "MWDMA1",
690 "MWDMA2",
691 "PIO0",
692 "PIO1",
693 "PIO2",
694 "PIO3",
695 "PIO4",
696};
697
698/**
699 * ata_udma_string - convert UDMA bit offset to string
700 * @mask: mask of bits supported; only highest bit counts.
701 *
702 * Determine string which represents the highest speed
703 * (highest bit in @udma_mask).
704 *
705 * LOCKING:
706 * None.
707 *
708 * RETURNS:
709 * Constant C string representing highest speed listed in
710 * @udma_mask, or the constant C string "<n/a>".
711 */
712
713static const char *ata_mode_string(unsigned int mask)
714{
715 int i;
716
717 for (i = 7; i >= 0; i--)
718 if (mask & (1 << i))
719 goto out;
720 for (i = ATA_SHIFT_MWDMA + 2; i >= ATA_SHIFT_MWDMA; i--)
721 if (mask & (1 << i))
722 goto out;
723 for (i = ATA_SHIFT_PIO + 4; i >= ATA_SHIFT_PIO; i--)
724 if (mask & (1 << i))
725 goto out;
726
727 return "<n/a>";
728
729out:
730 return xfer_mode_str[i];
731}
732
733/**
734 * ata_pio_devchk - PATA device presence detection
735 * @ap: ATA channel to examine
736 * @device: Device to examine (starting at zero)
737 *
738 * This technique was originally described in
739 * Hale Landis's ATADRVR (www.ata-atapi.com), and
740 * later found its way into the ATA/ATAPI spec.
741 *
742 * Write a pattern to the ATA shadow registers,
743 * and if a device is present, it will respond by
744 * correctly storing and echoing back the
745 * ATA shadow register contents.
746 *
747 * LOCKING:
748 * caller.
749 */
750
751static unsigned int ata_pio_devchk(struct ata_port *ap,
752 unsigned int device)
753{
754 struct ata_ioports *ioaddr = &ap->ioaddr;
755 u8 nsect, lbal;
756
757 ap->ops->dev_select(ap, device);
758
759 outb(0x55, ioaddr->nsect_addr);
760 outb(0xaa, ioaddr->lbal_addr);
761
762 outb(0xaa, ioaddr->nsect_addr);
763 outb(0x55, ioaddr->lbal_addr);
764
765 outb(0x55, ioaddr->nsect_addr);
766 outb(0xaa, ioaddr->lbal_addr);
767
768 nsect = inb(ioaddr->nsect_addr);
769 lbal = inb(ioaddr->lbal_addr);
770
771 if ((nsect == 0x55) && (lbal == 0xaa))
772 return 1; /* we found a device */
773
774 return 0; /* nothing found */
775}
776
777/**
778 * ata_mmio_devchk - PATA device presence detection
779 * @ap: ATA channel to examine
780 * @device: Device to examine (starting at zero)
781 *
782 * This technique was originally described in
783 * Hale Landis's ATADRVR (www.ata-atapi.com), and
784 * later found its way into the ATA/ATAPI spec.
785 *
786 * Write a pattern to the ATA shadow registers,
787 * and if a device is present, it will respond by
788 * correctly storing and echoing back the
789 * ATA shadow register contents.
790 *
791 * LOCKING:
792 * caller.
793 */
794
795static unsigned int ata_mmio_devchk(struct ata_port *ap,
796 unsigned int device)
797{
798 struct ata_ioports *ioaddr = &ap->ioaddr;
799 u8 nsect, lbal;
800
801 ap->ops->dev_select(ap, device);
802
803 writeb(0x55, (void __iomem *) ioaddr->nsect_addr);
804 writeb(0xaa, (void __iomem *) ioaddr->lbal_addr);
805
806 writeb(0xaa, (void __iomem *) ioaddr->nsect_addr);
807 writeb(0x55, (void __iomem *) ioaddr->lbal_addr);
808
809 writeb(0x55, (void __iomem *) ioaddr->nsect_addr);
810 writeb(0xaa, (void __iomem *) ioaddr->lbal_addr);
811
812 nsect = readb((void __iomem *) ioaddr->nsect_addr);
813 lbal = readb((void __iomem *) ioaddr->lbal_addr);
814
815 if ((nsect == 0x55) && (lbal == 0xaa))
816 return 1; /* we found a device */
817
818 return 0; /* nothing found */
819}
820
821/**
822 * ata_devchk - PATA device presence detection
823 * @ap: ATA channel to examine
824 * @device: Device to examine (starting at zero)
825 *
826 * Dispatch ATA device presence detection, depending
827 * on whether we are using PIO or MMIO to talk to the
828 * ATA shadow registers.
829 *
830 * LOCKING:
831 * caller.
832 */
833
834static unsigned int ata_devchk(struct ata_port *ap,
835 unsigned int device)
836{
837 if (ap->flags & ATA_FLAG_MMIO)
838 return ata_mmio_devchk(ap, device);
839 return ata_pio_devchk(ap, device);
840}
841
842/**
843 * ata_dev_classify - determine device type based on ATA-spec signature
844 * @tf: ATA taskfile register set for device to be identified
845 *
846 * Determine from taskfile register contents whether a device is
847 * ATA or ATAPI, as per "Signature and persistence" section
848 * of ATA/PI spec (volume 1, sect 5.14).
849 *
850 * LOCKING:
851 * None.
852 *
853 * RETURNS:
854 * Device type, %ATA_DEV_ATA, %ATA_DEV_ATAPI, or %ATA_DEV_UNKNOWN
855 * the event of failure.
856 */
857
858unsigned int ata_dev_classify(struct ata_taskfile *tf)
859{
860 /* Apple's open source Darwin code hints that some devices only
861 * put a proper signature into the LBA mid/high registers,
862 * So, we only check those. It's sufficient for uniqueness.
863 */
864
865 if (((tf->lbam == 0) && (tf->lbah == 0)) ||
866 ((tf->lbam == 0x3c) && (tf->lbah == 0xc3))) {
867 DPRINTK("found ATA device by sig\n");
868 return ATA_DEV_ATA;
869 }
870
871 if (((tf->lbam == 0x14) && (tf->lbah == 0xeb)) ||
872 ((tf->lbam == 0x69) && (tf->lbah == 0x96))) {
873 DPRINTK("found ATAPI device by sig\n");
874 return ATA_DEV_ATAPI;
875 }
876
877 DPRINTK("unknown device\n");
878 return ATA_DEV_UNKNOWN;
879}
880
881/**
882 * ata_dev_try_classify - Parse returned ATA device signature
883 * @ap: ATA channel to examine
884 * @device: Device to examine (starting at zero)
885 *
886 * After an event -- SRST, E.D.D., or SATA COMRESET -- occurs,
887 * an ATA/ATAPI-defined set of values is placed in the ATA
888 * shadow registers, indicating the results of device detection
889 * and diagnostics.
890 *
891 * Select the ATA device, and read the values from the ATA shadow
892 * registers. Then parse according to the Error register value,
893 * and the spec-defined values examined by ata_dev_classify().
894 *
895 * LOCKING:
896 * caller.
897 */
898
899static u8 ata_dev_try_classify(struct ata_port *ap, unsigned int device)
900{
901 struct ata_device *dev = &ap->device[device];
902 struct ata_taskfile tf;
903 unsigned int class;
904 u8 err;
905
906 ap->ops->dev_select(ap, device);
907
908 memset(&tf, 0, sizeof(tf));
909
910 err = ata_chk_err(ap);
911 ap->ops->tf_read(ap, &tf);
912
913 dev->class = ATA_DEV_NONE;
914
915 /* see if device passed diags */
916 if (err == 1)
917 /* do nothing */ ;
918 else if ((device == 0) && (err == 0x81))
919 /* do nothing */ ;
920 else
921 return err;
922
923 /* determine if device if ATA or ATAPI */
924 class = ata_dev_classify(&tf);
925 if (class == ATA_DEV_UNKNOWN)
926 return err;
927 if ((class == ATA_DEV_ATA) && (ata_chk_status(ap) == 0))
928 return err;
929
930 dev->class = class;
931
932 return err;
933}
934
935/**
936 * ata_dev_id_string - Convert IDENTIFY DEVICE page into string
937 * @id: IDENTIFY DEVICE results we will examine
938 * @s: string into which data is output
939 * @ofs: offset into identify device page
940 * @len: length of string to return. must be an even number.
941 *
942 * The strings in the IDENTIFY DEVICE page are broken up into
943 * 16-bit chunks. Run through the string, and output each
944 * 8-bit chunk linearly, regardless of platform.
945 *
946 * LOCKING:
947 * caller.
948 */
949
950void ata_dev_id_string(u16 *id, unsigned char *s,
951 unsigned int ofs, unsigned int len)
952{
953 unsigned int c;
954
955 while (len > 0) {
956 c = id[ofs] >> 8;
957 *s = c;
958 s++;
959
960 c = id[ofs] & 0xff;
961 *s = c;
962 s++;
963
964 ofs++;
965 len -= 2;
966 }
967}
968
Edward Falk0baab862005-06-02 18:17:13 -0400969
970/**
971 * ata_noop_dev_select - Select device 0/1 on ATA bus
972 * @ap: ATA channel to manipulate
973 * @device: ATA device (numbered from zero) to select
974 *
975 * This function performs no actual function.
976 *
977 * May be used as the dev_select() entry in ata_port_operations.
978 *
979 * LOCKING:
980 * caller.
981 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700982void ata_noop_dev_select (struct ata_port *ap, unsigned int device)
983{
984}
985
Edward Falk0baab862005-06-02 18:17:13 -0400986
Linus Torvalds1da177e2005-04-16 15:20:36 -0700987/**
988 * ata_std_dev_select - Select device 0/1 on ATA bus
989 * @ap: ATA channel to manipulate
990 * @device: ATA device (numbered from zero) to select
991 *
992 * Use the method defined in the ATA specification to
993 * make either device 0, or device 1, active on the
Edward Falk0baab862005-06-02 18:17:13 -0400994 * ATA channel. Works with both PIO and MMIO.
995 *
996 * May be used as the dev_select() entry in ata_port_operations.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700997 *
998 * LOCKING:
999 * caller.
1000 */
1001
1002void ata_std_dev_select (struct ata_port *ap, unsigned int device)
1003{
1004 u8 tmp;
1005
1006 if (device == 0)
1007 tmp = ATA_DEVICE_OBS;
1008 else
1009 tmp = ATA_DEVICE_OBS | ATA_DEV1;
1010
1011 if (ap->flags & ATA_FLAG_MMIO) {
1012 writeb(tmp, (void __iomem *) ap->ioaddr.device_addr);
1013 } else {
1014 outb(tmp, ap->ioaddr.device_addr);
1015 }
1016 ata_pause(ap); /* needed; also flushes, for mmio */
1017}
1018
1019/**
1020 * ata_dev_select - Select device 0/1 on ATA bus
1021 * @ap: ATA channel to manipulate
1022 * @device: ATA device (numbered from zero) to select
1023 * @wait: non-zero to wait for Status register BSY bit to clear
1024 * @can_sleep: non-zero if context allows sleeping
1025 *
1026 * Use the method defined in the ATA specification to
1027 * make either device 0, or device 1, active on the
1028 * ATA channel.
1029 *
1030 * This is a high-level version of ata_std_dev_select(),
1031 * which additionally provides the services of inserting
1032 * the proper pauses and status polling, where needed.
1033 *
1034 * LOCKING:
1035 * caller.
1036 */
1037
1038void ata_dev_select(struct ata_port *ap, unsigned int device,
1039 unsigned int wait, unsigned int can_sleep)
1040{
1041 VPRINTK("ENTER, ata%u: device %u, wait %u\n",
1042 ap->id, device, wait);
1043
1044 if (wait)
1045 ata_wait_idle(ap);
1046
1047 ap->ops->dev_select(ap, device);
1048
1049 if (wait) {
1050 if (can_sleep && ap->device[device].class == ATA_DEV_ATAPI)
1051 msleep(150);
1052 ata_wait_idle(ap);
1053 }
1054}
1055
1056/**
1057 * ata_dump_id - IDENTIFY DEVICE info debugging output
1058 * @dev: Device whose IDENTIFY DEVICE page we will dump
1059 *
1060 * Dump selected 16-bit words from a detected device's
1061 * IDENTIFY PAGE page.
1062 *
1063 * LOCKING:
1064 * caller.
1065 */
1066
1067static inline void ata_dump_id(struct ata_device *dev)
1068{
1069 DPRINTK("49==0x%04x "
1070 "53==0x%04x "
1071 "63==0x%04x "
1072 "64==0x%04x "
1073 "75==0x%04x \n",
1074 dev->id[49],
1075 dev->id[53],
1076 dev->id[63],
1077 dev->id[64],
1078 dev->id[75]);
1079 DPRINTK("80==0x%04x "
1080 "81==0x%04x "
1081 "82==0x%04x "
1082 "83==0x%04x "
1083 "84==0x%04x \n",
1084 dev->id[80],
1085 dev->id[81],
1086 dev->id[82],
1087 dev->id[83],
1088 dev->id[84]);
1089 DPRINTK("88==0x%04x "
1090 "93==0x%04x\n",
1091 dev->id[88],
1092 dev->id[93]);
1093}
1094
1095/**
1096 * ata_dev_identify - obtain IDENTIFY x DEVICE page
1097 * @ap: port on which device we wish to probe resides
1098 * @device: device bus address, starting at zero
1099 *
1100 * Following bus reset, we issue the IDENTIFY [PACKET] DEVICE
1101 * command, and read back the 512-byte device information page.
1102 * The device information page is fed to us via the standard
1103 * PIO-IN protocol, but we hand-code it here. (TODO: investigate
1104 * using standard PIO-IN paths)
1105 *
1106 * After reading the device information page, we use several
1107 * bits of information from it to initialize data structures
1108 * that will be used during the lifetime of the ata_device.
1109 * Other data from the info page is used to disqualify certain
1110 * older ATA devices we do not wish to support.
1111 *
1112 * LOCKING:
1113 * Inherited from caller. Some functions called by this function
1114 * obtain the host_set lock.
1115 */
1116
1117static void ata_dev_identify(struct ata_port *ap, unsigned int device)
1118{
1119 struct ata_device *dev = &ap->device[device];
1120 unsigned int i;
1121 u16 tmp;
1122 unsigned long xfer_modes;
1123 u8 status;
1124 unsigned int using_edd;
1125 DECLARE_COMPLETION(wait);
1126 struct ata_queued_cmd *qc;
1127 unsigned long flags;
1128 int rc;
1129
1130 if (!ata_dev_present(dev)) {
1131 DPRINTK("ENTER/EXIT (host %u, dev %u) -- nodev\n",
1132 ap->id, device);
1133 return;
1134 }
1135
1136 if (ap->flags & (ATA_FLAG_SRST | ATA_FLAG_SATA_RESET))
1137 using_edd = 0;
1138 else
1139 using_edd = 1;
1140
1141 DPRINTK("ENTER, host %u, dev %u\n", ap->id, device);
1142
1143 assert (dev->class == ATA_DEV_ATA || dev->class == ATA_DEV_ATAPI ||
1144 dev->class == ATA_DEV_NONE);
1145
1146 ata_dev_select(ap, device, 1, 1); /* select device 0/1 */
1147
1148 qc = ata_qc_new_init(ap, dev);
1149 BUG_ON(qc == NULL);
1150
1151 ata_sg_init_one(qc, dev->id, sizeof(dev->id));
1152 qc->dma_dir = DMA_FROM_DEVICE;
1153 qc->tf.protocol = ATA_PROT_PIO;
1154 qc->nsect = 1;
1155
1156retry:
1157 if (dev->class == ATA_DEV_ATA) {
1158 qc->tf.command = ATA_CMD_ID_ATA;
1159 DPRINTK("do ATA identify\n");
1160 } else {
1161 qc->tf.command = ATA_CMD_ID_ATAPI;
1162 DPRINTK("do ATAPI identify\n");
1163 }
1164
1165 qc->waiting = &wait;
1166 qc->complete_fn = ata_qc_complete_noop;
1167
1168 spin_lock_irqsave(&ap->host_set->lock, flags);
1169 rc = ata_qc_issue(qc);
1170 spin_unlock_irqrestore(&ap->host_set->lock, flags);
1171
1172 if (rc)
1173 goto err_out;
1174 else
1175 wait_for_completion(&wait);
1176
1177 status = ata_chk_status(ap);
1178 if (status & ATA_ERR) {
1179 /*
1180 * arg! EDD works for all test cases, but seems to return
1181 * the ATA signature for some ATAPI devices. Until the
1182 * reason for this is found and fixed, we fix up the mess
1183 * here. If IDENTIFY DEVICE returns command aborted
1184 * (as ATAPI devices do), then we issue an
1185 * IDENTIFY PACKET DEVICE.
1186 *
1187 * ATA software reset (SRST, the default) does not appear
1188 * to have this problem.
1189 */
1190 if ((using_edd) && (qc->tf.command == ATA_CMD_ID_ATA)) {
1191 u8 err = ata_chk_err(ap);
1192 if (err & ATA_ABORTED) {
1193 dev->class = ATA_DEV_ATAPI;
1194 qc->cursg = 0;
1195 qc->cursg_ofs = 0;
1196 qc->cursect = 0;
1197 qc->nsect = 1;
1198 goto retry;
1199 }
1200 }
1201 goto err_out;
1202 }
1203
1204 swap_buf_le16(dev->id, ATA_ID_WORDS);
1205
1206 /* print device capabilities */
1207 printk(KERN_DEBUG "ata%u: dev %u cfg "
1208 "49:%04x 82:%04x 83:%04x 84:%04x 85:%04x 86:%04x 87:%04x 88:%04x\n",
1209 ap->id, device, dev->id[49],
1210 dev->id[82], dev->id[83], dev->id[84],
1211 dev->id[85], dev->id[86], dev->id[87],
1212 dev->id[88]);
1213
1214 /*
1215 * common ATA, ATAPI feature tests
1216 */
1217
1218 /* we require LBA and DMA support (bits 8 & 9 of word 49) */
1219 if (!ata_id_has_dma(dev->id) || !ata_id_has_lba(dev->id)) {
1220 printk(KERN_DEBUG "ata%u: no dma/lba\n", ap->id);
1221 goto err_out_nosup;
1222 }
1223
1224 /* quick-n-dirty find max transfer mode; for printk only */
1225 xfer_modes = dev->id[ATA_ID_UDMA_MODES];
1226 if (!xfer_modes)
1227 xfer_modes = (dev->id[ATA_ID_MWDMA_MODES]) << ATA_SHIFT_MWDMA;
1228 if (!xfer_modes) {
1229 xfer_modes = (dev->id[ATA_ID_PIO_MODES]) << (ATA_SHIFT_PIO + 3);
1230 xfer_modes |= (0x7 << ATA_SHIFT_PIO);
1231 }
1232
1233 ata_dump_id(dev);
1234
1235 /* ATA-specific feature tests */
1236 if (dev->class == ATA_DEV_ATA) {
1237 if (!ata_id_is_ata(dev->id)) /* sanity check */
1238 goto err_out_nosup;
1239
1240 tmp = dev->id[ATA_ID_MAJOR_VER];
1241 for (i = 14; i >= 1; i--)
1242 if (tmp & (1 << i))
1243 break;
1244
1245 /* we require at least ATA-3 */
1246 if (i < 3) {
1247 printk(KERN_DEBUG "ata%u: no ATA-3\n", ap->id);
1248 goto err_out_nosup;
1249 }
1250
1251 if (ata_id_has_lba48(dev->id)) {
1252 dev->flags |= ATA_DFLAG_LBA48;
1253 dev->n_sectors = ata_id_u64(dev->id, 100);
1254 } else {
1255 dev->n_sectors = ata_id_u32(dev->id, 60);
1256 }
1257
1258 ap->host->max_cmd_len = 16;
1259
1260 /* print device info to dmesg */
1261 printk(KERN_INFO "ata%u: dev %u ATA, max %s, %Lu sectors:%s\n",
1262 ap->id, device,
1263 ata_mode_string(xfer_modes),
1264 (unsigned long long)dev->n_sectors,
1265 dev->flags & ATA_DFLAG_LBA48 ? " lba48" : "");
1266 }
1267
1268 /* ATAPI-specific feature tests */
1269 else {
1270 if (ata_id_is_ata(dev->id)) /* sanity check */
1271 goto err_out_nosup;
1272
1273 rc = atapi_cdb_len(dev->id);
1274 if ((rc < 12) || (rc > ATAPI_CDB_LEN)) {
1275 printk(KERN_WARNING "ata%u: unsupported CDB len\n", ap->id);
1276 goto err_out_nosup;
1277 }
1278 ap->cdb_len = (unsigned int) rc;
1279 ap->host->max_cmd_len = (unsigned char) ap->cdb_len;
1280
1281 /* print device info to dmesg */
1282 printk(KERN_INFO "ata%u: dev %u ATAPI, max %s\n",
1283 ap->id, device,
1284 ata_mode_string(xfer_modes));
1285 }
1286
1287 DPRINTK("EXIT, drv_stat = 0x%x\n", ata_chk_status(ap));
1288 return;
1289
1290err_out_nosup:
1291 printk(KERN_WARNING "ata%u: dev %u not supported, ignoring\n",
1292 ap->id, device);
1293err_out:
1294 dev->class++; /* converts ATA_DEV_xxx into ATA_DEV_xxx_UNSUP */
1295 DPRINTK("EXIT, err\n");
1296}
1297
Brad Campbell6f2f3812005-05-12 15:07:47 -04001298
1299static inline u8 ata_dev_knobble(struct ata_port *ap)
1300{
1301 return ((ap->cbl == ATA_CBL_SATA) && (!ata_id_is_sata(ap->device->id)));
1302}
1303
1304/**
1305 * ata_dev_config - Run device specific handlers and check for
1306 * SATA->PATA bridges
1307 * @ap: Bus
1308 * @i: Device
1309 *
1310 * LOCKING:
1311 */
1312
1313void ata_dev_config(struct ata_port *ap, unsigned int i)
1314{
1315 /* limit bridge transfers to udma5, 200 sectors */
1316 if (ata_dev_knobble(ap)) {
1317 printk(KERN_INFO "ata%u(%u): applying bridge limits\n",
1318 ap->id, ap->device->devno);
1319 ap->udma_mask &= ATA_UDMA5;
1320 ap->host->max_sectors = ATA_MAX_SECTORS;
1321 ap->host->hostt->max_sectors = ATA_MAX_SECTORS;
1322 ap->device->flags |= ATA_DFLAG_LOCK_SECTORS;
1323 }
1324
1325 if (ap->ops->dev_config)
1326 ap->ops->dev_config(ap, &ap->device[i]);
1327}
1328
Linus Torvalds1da177e2005-04-16 15:20:36 -07001329/**
1330 * ata_bus_probe - Reset and probe ATA bus
1331 * @ap: Bus to probe
1332 *
Jeff Garzik0cba6322005-05-30 19:49:12 -04001333 * Master ATA bus probing function. Initiates a hardware-dependent
1334 * bus reset, then attempts to identify any devices found on
1335 * the bus.
1336 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001337 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04001338 * PCI/etc. bus probe sem.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001339 *
1340 * RETURNS:
1341 * Zero on success, non-zero on error.
1342 */
1343
1344static int ata_bus_probe(struct ata_port *ap)
1345{
1346 unsigned int i, found = 0;
1347
1348 ap->ops->phy_reset(ap);
1349 if (ap->flags & ATA_FLAG_PORT_DISABLED)
1350 goto err_out;
1351
1352 for (i = 0; i < ATA_MAX_DEVICES; i++) {
1353 ata_dev_identify(ap, i);
1354 if (ata_dev_present(&ap->device[i])) {
1355 found = 1;
Brad Campbell6f2f3812005-05-12 15:07:47 -04001356 ata_dev_config(ap,i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001357 }
1358 }
1359
1360 if ((!found) || (ap->flags & ATA_FLAG_PORT_DISABLED))
1361 goto err_out_disable;
1362
1363 ata_set_mode(ap);
1364 if (ap->flags & ATA_FLAG_PORT_DISABLED)
1365 goto err_out_disable;
1366
1367 return 0;
1368
1369err_out_disable:
1370 ap->ops->port_disable(ap);
1371err_out:
1372 return -1;
1373}
1374
1375/**
Jeff Garzik0cba6322005-05-30 19:49:12 -04001376 * ata_port_probe - Mark port as enabled
1377 * @ap: Port for which we indicate enablement
Linus Torvalds1da177e2005-04-16 15:20:36 -07001378 *
Jeff Garzik0cba6322005-05-30 19:49:12 -04001379 * Modify @ap data structure such that the system
1380 * thinks that the entire port is enabled.
1381 *
1382 * LOCKING: host_set lock, or some other form of
1383 * serialization.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001384 */
1385
1386void ata_port_probe(struct ata_port *ap)
1387{
1388 ap->flags &= ~ATA_FLAG_PORT_DISABLED;
1389}
1390
1391/**
Jeff Garzik780a87f2005-05-30 15:41:05 -04001392 * __sata_phy_reset - Wake/reset a low-level SATA PHY
1393 * @ap: SATA port associated with target SATA PHY.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001394 *
Jeff Garzik780a87f2005-05-30 15:41:05 -04001395 * This function issues commands to standard SATA Sxxx
1396 * PHY registers, to wake up the phy (and device), and
1397 * clear any reset condition.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001398 *
1399 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04001400 * PCI/etc. bus probe sem.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001401 *
1402 */
1403void __sata_phy_reset(struct ata_port *ap)
1404{
1405 u32 sstatus;
1406 unsigned long timeout = jiffies + (HZ * 5);
1407
1408 if (ap->flags & ATA_FLAG_SATA_RESET) {
Brett Russcdcca892005-03-28 15:10:27 -05001409 /* issue phy wake/reset */
1410 scr_write_flush(ap, SCR_CONTROL, 0x301);
Tejun Heo62ba2842005-06-26 23:27:19 +09001411 /* Couldn't find anything in SATA I/II specs, but
1412 * AHCI-1.1 10.4.2 says at least 1 ms. */
1413 mdelay(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001414 }
Brett Russcdcca892005-03-28 15:10:27 -05001415 scr_write_flush(ap, SCR_CONTROL, 0x300); /* phy wake/clear reset */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001416
1417 /* wait for phy to become ready, if necessary */
1418 do {
1419 msleep(200);
1420 sstatus = scr_read(ap, SCR_STATUS);
1421 if ((sstatus & 0xf) != 1)
1422 break;
1423 } while (time_before(jiffies, timeout));
1424
1425 /* TODO: phy layer with polling, timeouts, etc. */
1426 if (sata_dev_present(ap))
1427 ata_port_probe(ap);
1428 else {
1429 sstatus = scr_read(ap, SCR_STATUS);
1430 printk(KERN_INFO "ata%u: no device found (phy stat %08x)\n",
1431 ap->id, sstatus);
1432 ata_port_disable(ap);
1433 }
1434
1435 if (ap->flags & ATA_FLAG_PORT_DISABLED)
1436 return;
1437
1438 if (ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT)) {
1439 ata_port_disable(ap);
1440 return;
1441 }
1442
1443 ap->cbl = ATA_CBL_SATA;
1444}
1445
1446/**
Jeff Garzik780a87f2005-05-30 15:41:05 -04001447 * sata_phy_reset - Reset SATA bus.
1448 * @ap: SATA port associated with target SATA PHY.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001449 *
Jeff Garzik780a87f2005-05-30 15:41:05 -04001450 * This function resets the SATA bus, and then probes
1451 * the bus for devices.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001452 *
1453 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04001454 * PCI/etc. bus probe sem.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001455 *
1456 */
1457void sata_phy_reset(struct ata_port *ap)
1458{
1459 __sata_phy_reset(ap);
1460 if (ap->flags & ATA_FLAG_PORT_DISABLED)
1461 return;
1462 ata_bus_reset(ap);
1463}
1464
1465/**
Jeff Garzik780a87f2005-05-30 15:41:05 -04001466 * ata_port_disable - Disable port.
1467 * @ap: Port to be disabled.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001468 *
Jeff Garzik780a87f2005-05-30 15:41:05 -04001469 * Modify @ap data structure such that the system
1470 * thinks that the entire port is disabled, and should
1471 * never attempt to probe or communicate with devices
1472 * on this port.
1473 *
1474 * LOCKING: host_set lock, or some other form of
1475 * serialization.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001476 */
1477
1478void ata_port_disable(struct ata_port *ap)
1479{
1480 ap->device[0].class = ATA_DEV_NONE;
1481 ap->device[1].class = ATA_DEV_NONE;
1482 ap->flags |= ATA_FLAG_PORT_DISABLED;
1483}
1484
1485static struct {
1486 unsigned int shift;
1487 u8 base;
1488} xfer_mode_classes[] = {
1489 { ATA_SHIFT_UDMA, XFER_UDMA_0 },
1490 { ATA_SHIFT_MWDMA, XFER_MW_DMA_0 },
1491 { ATA_SHIFT_PIO, XFER_PIO_0 },
1492};
1493
1494static inline u8 base_from_shift(unsigned int shift)
1495{
1496 int i;
1497
1498 for (i = 0; i < ARRAY_SIZE(xfer_mode_classes); i++)
1499 if (xfer_mode_classes[i].shift == shift)
1500 return xfer_mode_classes[i].base;
1501
1502 return 0xff;
1503}
1504
1505static void ata_dev_set_mode(struct ata_port *ap, struct ata_device *dev)
1506{
1507 int ofs, idx;
1508 u8 base;
1509
1510 if (!ata_dev_present(dev) || (ap->flags & ATA_FLAG_PORT_DISABLED))
1511 return;
1512
1513 if (dev->xfer_shift == ATA_SHIFT_PIO)
1514 dev->flags |= ATA_DFLAG_PIO;
1515
1516 ata_dev_set_xfermode(ap, dev);
1517
1518 base = base_from_shift(dev->xfer_shift);
1519 ofs = dev->xfer_mode - base;
1520 idx = ofs + dev->xfer_shift;
1521 WARN_ON(idx >= ARRAY_SIZE(xfer_mode_str));
1522
1523 DPRINTK("idx=%d xfer_shift=%u, xfer_mode=0x%x, base=0x%x, offset=%d\n",
1524 idx, dev->xfer_shift, (int)dev->xfer_mode, (int)base, ofs);
1525
1526 printk(KERN_INFO "ata%u: dev %u configured for %s\n",
1527 ap->id, dev->devno, xfer_mode_str[idx]);
1528}
1529
1530static int ata_host_set_pio(struct ata_port *ap)
1531{
1532 unsigned int mask;
1533 int x, i;
1534 u8 base, xfer_mode;
1535
1536 mask = ata_get_mode_mask(ap, ATA_SHIFT_PIO);
1537 x = fgb(mask);
1538 if (x < 0) {
1539 printk(KERN_WARNING "ata%u: no PIO support\n", ap->id);
1540 return -1;
1541 }
1542
1543 base = base_from_shift(ATA_SHIFT_PIO);
1544 xfer_mode = base + x;
1545
1546 DPRINTK("base 0x%x xfer_mode 0x%x mask 0x%x x %d\n",
1547 (int)base, (int)xfer_mode, mask, x);
1548
1549 for (i = 0; i < ATA_MAX_DEVICES; i++) {
1550 struct ata_device *dev = &ap->device[i];
1551 if (ata_dev_present(dev)) {
1552 dev->pio_mode = xfer_mode;
1553 dev->xfer_mode = xfer_mode;
1554 dev->xfer_shift = ATA_SHIFT_PIO;
1555 if (ap->ops->set_piomode)
1556 ap->ops->set_piomode(ap, dev);
1557 }
1558 }
1559
1560 return 0;
1561}
1562
1563static void ata_host_set_dma(struct ata_port *ap, u8 xfer_mode,
1564 unsigned int xfer_shift)
1565{
1566 int i;
1567
1568 for (i = 0; i < ATA_MAX_DEVICES; i++) {
1569 struct ata_device *dev = &ap->device[i];
1570 if (ata_dev_present(dev)) {
1571 dev->dma_mode = xfer_mode;
1572 dev->xfer_mode = xfer_mode;
1573 dev->xfer_shift = xfer_shift;
1574 if (ap->ops->set_dmamode)
1575 ap->ops->set_dmamode(ap, dev);
1576 }
1577 }
1578}
1579
1580/**
1581 * ata_set_mode - Program timings and issue SET FEATURES - XFER
1582 * @ap: port on which timings will be programmed
1583 *
Jeff Garzik780a87f2005-05-30 15:41:05 -04001584 * Set ATA device disk transfer mode (PIO3, UDMA6, etc.).
1585 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001586 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04001587 * PCI/etc. bus probe sem.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001588 *
1589 */
1590static void ata_set_mode(struct ata_port *ap)
1591{
1592 unsigned int i, xfer_shift;
1593 u8 xfer_mode;
1594 int rc;
1595
1596 /* step 1: always set host PIO timings */
1597 rc = ata_host_set_pio(ap);
1598 if (rc)
1599 goto err_out;
1600
1601 /* step 2: choose the best data xfer mode */
1602 xfer_mode = xfer_shift = 0;
1603 rc = ata_choose_xfer_mode(ap, &xfer_mode, &xfer_shift);
1604 if (rc)
1605 goto err_out;
1606
1607 /* step 3: if that xfer mode isn't PIO, set host DMA timings */
1608 if (xfer_shift != ATA_SHIFT_PIO)
1609 ata_host_set_dma(ap, xfer_mode, xfer_shift);
1610
1611 /* step 4: update devices' xfer mode */
1612 ata_dev_set_mode(ap, &ap->device[0]);
1613 ata_dev_set_mode(ap, &ap->device[1]);
1614
1615 if (ap->flags & ATA_FLAG_PORT_DISABLED)
1616 return;
1617
1618 if (ap->ops->post_set_mode)
1619 ap->ops->post_set_mode(ap);
1620
1621 for (i = 0; i < 2; i++) {
1622 struct ata_device *dev = &ap->device[i];
1623 ata_dev_set_protocol(dev);
1624 }
1625
1626 return;
1627
1628err_out:
1629 ata_port_disable(ap);
1630}
1631
1632/**
1633 * ata_busy_sleep - sleep until BSY clears, or timeout
1634 * @ap: port containing status register to be polled
1635 * @tmout_pat: impatience timeout
1636 * @tmout: overall timeout
1637 *
Jeff Garzik780a87f2005-05-30 15:41:05 -04001638 * Sleep until ATA Status register bit BSY clears,
1639 * or a timeout occurs.
1640 *
1641 * LOCKING: None.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001642 *
1643 */
1644
1645static unsigned int ata_busy_sleep (struct ata_port *ap,
1646 unsigned long tmout_pat,
1647 unsigned long tmout)
1648{
1649 unsigned long timer_start, timeout;
1650 u8 status;
1651
1652 status = ata_busy_wait(ap, ATA_BUSY, 300);
1653 timer_start = jiffies;
1654 timeout = timer_start + tmout_pat;
1655 while ((status & ATA_BUSY) && (time_before(jiffies, timeout))) {
1656 msleep(50);
1657 status = ata_busy_wait(ap, ATA_BUSY, 3);
1658 }
1659
1660 if (status & ATA_BUSY)
1661 printk(KERN_WARNING "ata%u is slow to respond, "
1662 "please be patient\n", ap->id);
1663
1664 timeout = timer_start + tmout;
1665 while ((status & ATA_BUSY) && (time_before(jiffies, timeout))) {
1666 msleep(50);
1667 status = ata_chk_status(ap);
1668 }
1669
1670 if (status & ATA_BUSY) {
1671 printk(KERN_ERR "ata%u failed to respond (%lu secs)\n",
1672 ap->id, tmout / HZ);
1673 return 1;
1674 }
1675
1676 return 0;
1677}
1678
1679static void ata_bus_post_reset(struct ata_port *ap, unsigned int devmask)
1680{
1681 struct ata_ioports *ioaddr = &ap->ioaddr;
1682 unsigned int dev0 = devmask & (1 << 0);
1683 unsigned int dev1 = devmask & (1 << 1);
1684 unsigned long timeout;
1685
1686 /* if device 0 was found in ata_devchk, wait for its
1687 * BSY bit to clear
1688 */
1689 if (dev0)
1690 ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT);
1691
1692 /* if device 1 was found in ata_devchk, wait for
1693 * register access, then wait for BSY to clear
1694 */
1695 timeout = jiffies + ATA_TMOUT_BOOT;
1696 while (dev1) {
1697 u8 nsect, lbal;
1698
1699 ap->ops->dev_select(ap, 1);
1700 if (ap->flags & ATA_FLAG_MMIO) {
1701 nsect = readb((void __iomem *) ioaddr->nsect_addr);
1702 lbal = readb((void __iomem *) ioaddr->lbal_addr);
1703 } else {
1704 nsect = inb(ioaddr->nsect_addr);
1705 lbal = inb(ioaddr->lbal_addr);
1706 }
1707 if ((nsect == 1) && (lbal == 1))
1708 break;
1709 if (time_after(jiffies, timeout)) {
1710 dev1 = 0;
1711 break;
1712 }
1713 msleep(50); /* give drive a breather */
1714 }
1715 if (dev1)
1716 ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT);
1717
1718 /* is all this really necessary? */
1719 ap->ops->dev_select(ap, 0);
1720 if (dev1)
1721 ap->ops->dev_select(ap, 1);
1722 if (dev0)
1723 ap->ops->dev_select(ap, 0);
1724}
1725
1726/**
Jeff Garzik0cba6322005-05-30 19:49:12 -04001727 * ata_bus_edd - Issue EXECUTE DEVICE DIAGNOSTIC command.
1728 * @ap: Port to reset and probe
Linus Torvalds1da177e2005-04-16 15:20:36 -07001729 *
Jeff Garzik0cba6322005-05-30 19:49:12 -04001730 * Use the EXECUTE DEVICE DIAGNOSTIC command to reset and
1731 * probe the bus. Not often used these days.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001732 *
1733 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04001734 * PCI/etc. bus probe sem.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001735 *
1736 */
1737
1738static unsigned int ata_bus_edd(struct ata_port *ap)
1739{
1740 struct ata_taskfile tf;
1741
1742 /* set up execute-device-diag (bus reset) taskfile */
1743 /* also, take interrupts to a known state (disabled) */
1744 DPRINTK("execute-device-diag\n");
1745 ata_tf_init(ap, &tf, 0);
1746 tf.ctl |= ATA_NIEN;
1747 tf.command = ATA_CMD_EDD;
1748 tf.protocol = ATA_PROT_NODATA;
1749
1750 /* do bus reset */
1751 ata_tf_to_host(ap, &tf);
1752
1753 /* spec says at least 2ms. but who knows with those
1754 * crazy ATAPI devices...
1755 */
1756 msleep(150);
1757
1758 return ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT);
1759}
1760
1761static unsigned int ata_bus_softreset(struct ata_port *ap,
1762 unsigned int devmask)
1763{
1764 struct ata_ioports *ioaddr = &ap->ioaddr;
1765
1766 DPRINTK("ata%u: bus reset via SRST\n", ap->id);
1767
1768 /* software reset. causes dev0 to be selected */
1769 if (ap->flags & ATA_FLAG_MMIO) {
1770 writeb(ap->ctl, (void __iomem *) ioaddr->ctl_addr);
1771 udelay(20); /* FIXME: flush */
1772 writeb(ap->ctl | ATA_SRST, (void __iomem *) ioaddr->ctl_addr);
1773 udelay(20); /* FIXME: flush */
1774 writeb(ap->ctl, (void __iomem *) ioaddr->ctl_addr);
1775 } else {
1776 outb(ap->ctl, ioaddr->ctl_addr);
1777 udelay(10);
1778 outb(ap->ctl | ATA_SRST, ioaddr->ctl_addr);
1779 udelay(10);
1780 outb(ap->ctl, ioaddr->ctl_addr);
1781 }
1782
1783 /* spec mandates ">= 2ms" before checking status.
1784 * We wait 150ms, because that was the magic delay used for
1785 * ATAPI devices in Hale Landis's ATADRVR, for the period of time
1786 * between when the ATA command register is written, and then
1787 * status is checked. Because waiting for "a while" before
1788 * checking status is fine, post SRST, we perform this magic
1789 * delay here as well.
1790 */
1791 msleep(150);
1792
1793 ata_bus_post_reset(ap, devmask);
1794
1795 return 0;
1796}
1797
1798/**
1799 * ata_bus_reset - reset host port and associated ATA channel
1800 * @ap: port to reset
1801 *
1802 * This is typically the first time we actually start issuing
1803 * commands to the ATA channel. We wait for BSY to clear, then
1804 * issue EXECUTE DEVICE DIAGNOSTIC command, polling for its
1805 * result. Determine what devices, if any, are on the channel
1806 * by looking at the device 0/1 error register. Look at the signature
1807 * stored in each device's taskfile registers, to determine if
1808 * the device is ATA or ATAPI.
1809 *
1810 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04001811 * PCI/etc. bus probe sem.
1812 * Obtains host_set lock.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001813 *
1814 * SIDE EFFECTS:
1815 * Sets ATA_FLAG_PORT_DISABLED if bus reset fails.
1816 */
1817
1818void ata_bus_reset(struct ata_port *ap)
1819{
1820 struct ata_ioports *ioaddr = &ap->ioaddr;
1821 unsigned int slave_possible = ap->flags & ATA_FLAG_SLAVE_POSS;
1822 u8 err;
1823 unsigned int dev0, dev1 = 0, rc = 0, devmask = 0;
1824
1825 DPRINTK("ENTER, host %u, port %u\n", ap->id, ap->port_no);
1826
1827 /* determine if device 0/1 are present */
1828 if (ap->flags & ATA_FLAG_SATA_RESET)
1829 dev0 = 1;
1830 else {
1831 dev0 = ata_devchk(ap, 0);
1832 if (slave_possible)
1833 dev1 = ata_devchk(ap, 1);
1834 }
1835
1836 if (dev0)
1837 devmask |= (1 << 0);
1838 if (dev1)
1839 devmask |= (1 << 1);
1840
1841 /* select device 0 again */
1842 ap->ops->dev_select(ap, 0);
1843
1844 /* issue bus reset */
1845 if (ap->flags & ATA_FLAG_SRST)
1846 rc = ata_bus_softreset(ap, devmask);
1847 else if ((ap->flags & ATA_FLAG_SATA_RESET) == 0) {
1848 /* set up device control */
1849 if (ap->flags & ATA_FLAG_MMIO)
1850 writeb(ap->ctl, (void __iomem *) ioaddr->ctl_addr);
1851 else
1852 outb(ap->ctl, ioaddr->ctl_addr);
1853 rc = ata_bus_edd(ap);
1854 }
1855
1856 if (rc)
1857 goto err_out;
1858
1859 /*
1860 * determine by signature whether we have ATA or ATAPI devices
1861 */
1862 err = ata_dev_try_classify(ap, 0);
1863 if ((slave_possible) && (err != 0x81))
1864 ata_dev_try_classify(ap, 1);
1865
1866 /* re-enable interrupts */
1867 if (ap->ioaddr.ctl_addr) /* FIXME: hack. create a hook instead */
1868 ata_irq_on(ap);
1869
1870 /* is double-select really necessary? */
1871 if (ap->device[1].class != ATA_DEV_NONE)
1872 ap->ops->dev_select(ap, 1);
1873 if (ap->device[0].class != ATA_DEV_NONE)
1874 ap->ops->dev_select(ap, 0);
1875
1876 /* if no devices were detected, disable this port */
1877 if ((ap->device[0].class == ATA_DEV_NONE) &&
1878 (ap->device[1].class == ATA_DEV_NONE))
1879 goto err_out;
1880
1881 if (ap->flags & (ATA_FLAG_SATA_RESET | ATA_FLAG_SRST)) {
1882 /* set up device control for ATA_FLAG_SATA_RESET */
1883 if (ap->flags & ATA_FLAG_MMIO)
1884 writeb(ap->ctl, (void __iomem *) ioaddr->ctl_addr);
1885 else
1886 outb(ap->ctl, ioaddr->ctl_addr);
1887 }
1888
1889 DPRINTK("EXIT\n");
1890 return;
1891
1892err_out:
1893 printk(KERN_ERR "ata%u: disabling port\n", ap->id);
1894 ap->ops->port_disable(ap);
1895
1896 DPRINTK("EXIT\n");
1897}
1898
1899static void ata_pr_blacklisted(struct ata_port *ap, struct ata_device *dev)
1900{
1901 printk(KERN_WARNING "ata%u: dev %u is on DMA blacklist, disabling DMA\n",
1902 ap->id, dev->devno);
1903}
1904
1905static const char * ata_dma_blacklist [] = {
1906 "WDC AC11000H",
1907 "WDC AC22100H",
1908 "WDC AC32500H",
1909 "WDC AC33100H",
1910 "WDC AC31600H",
1911 "WDC AC32100H",
1912 "WDC AC23200L",
1913 "Compaq CRD-8241B",
1914 "CRD-8400B",
1915 "CRD-8480B",
1916 "CRD-8482B",
1917 "CRD-84",
1918 "SanDisk SDP3B",
1919 "SanDisk SDP3B-64",
1920 "SANYO CD-ROM CRD",
1921 "HITACHI CDR-8",
1922 "HITACHI CDR-8335",
1923 "HITACHI CDR-8435",
1924 "Toshiba CD-ROM XM-6202B",
Jeff Garzike9222562005-06-28 00:03:37 -04001925 "TOSHIBA CD-ROM XM-1702BC",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001926 "CD-532E-A",
1927 "E-IDE CD-ROM CR-840",
1928 "CD-ROM Drive/F5A",
1929 "WPI CDD-820",
1930 "SAMSUNG CD-ROM SC-148C",
1931 "SAMSUNG CD-ROM SC",
1932 "SanDisk SDP3B-64",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001933 "ATAPI CD-ROM DRIVE 40X MAXIMUM",
1934 "_NEC DV5800A",
1935};
1936
1937static int ata_dma_blacklisted(struct ata_port *ap, struct ata_device *dev)
1938{
1939 unsigned char model_num[40];
1940 char *s;
1941 unsigned int len;
1942 int i;
1943
1944 ata_dev_id_string(dev->id, model_num, ATA_ID_PROD_OFS,
1945 sizeof(model_num));
1946 s = &model_num[0];
1947 len = strnlen(s, sizeof(model_num));
1948
1949 /* ATAPI specifies that empty space is blank-filled; remove blanks */
1950 while ((len > 0) && (s[len - 1] == ' ')) {
1951 len--;
1952 s[len] = 0;
1953 }
1954
1955 for (i = 0; i < ARRAY_SIZE(ata_dma_blacklist); i++)
1956 if (!strncmp(ata_dma_blacklist[i], s, len))
1957 return 1;
1958
1959 return 0;
1960}
1961
1962static unsigned int ata_get_mode_mask(struct ata_port *ap, int shift)
1963{
1964 struct ata_device *master, *slave;
1965 unsigned int mask;
1966
1967 master = &ap->device[0];
1968 slave = &ap->device[1];
1969
1970 assert (ata_dev_present(master) || ata_dev_present(slave));
1971
1972 if (shift == ATA_SHIFT_UDMA) {
1973 mask = ap->udma_mask;
1974 if (ata_dev_present(master)) {
1975 mask &= (master->id[ATA_ID_UDMA_MODES] & 0xff);
1976 if (ata_dma_blacklisted(ap, master)) {
1977 mask = 0;
1978 ata_pr_blacklisted(ap, master);
1979 }
1980 }
1981 if (ata_dev_present(slave)) {
1982 mask &= (slave->id[ATA_ID_UDMA_MODES] & 0xff);
1983 if (ata_dma_blacklisted(ap, slave)) {
1984 mask = 0;
1985 ata_pr_blacklisted(ap, slave);
1986 }
1987 }
1988 }
1989 else if (shift == ATA_SHIFT_MWDMA) {
1990 mask = ap->mwdma_mask;
1991 if (ata_dev_present(master)) {
1992 mask &= (master->id[ATA_ID_MWDMA_MODES] & 0x07);
1993 if (ata_dma_blacklisted(ap, master)) {
1994 mask = 0;
1995 ata_pr_blacklisted(ap, master);
1996 }
1997 }
1998 if (ata_dev_present(slave)) {
1999 mask &= (slave->id[ATA_ID_MWDMA_MODES] & 0x07);
2000 if (ata_dma_blacklisted(ap, slave)) {
2001 mask = 0;
2002 ata_pr_blacklisted(ap, slave);
2003 }
2004 }
2005 }
2006 else if (shift == ATA_SHIFT_PIO) {
2007 mask = ap->pio_mask;
2008 if (ata_dev_present(master)) {
2009 /* spec doesn't return explicit support for
2010 * PIO0-2, so we fake it
2011 */
2012 u16 tmp_mode = master->id[ATA_ID_PIO_MODES] & 0x03;
2013 tmp_mode <<= 3;
2014 tmp_mode |= 0x7;
2015 mask &= tmp_mode;
2016 }
2017 if (ata_dev_present(slave)) {
2018 /* spec doesn't return explicit support for
2019 * PIO0-2, so we fake it
2020 */
2021 u16 tmp_mode = slave->id[ATA_ID_PIO_MODES] & 0x03;
2022 tmp_mode <<= 3;
2023 tmp_mode |= 0x7;
2024 mask &= tmp_mode;
2025 }
2026 }
2027 else {
2028 mask = 0xffffffff; /* shut up compiler warning */
2029 BUG();
2030 }
2031
2032 return mask;
2033}
2034
2035/* find greatest bit */
2036static int fgb(u32 bitmap)
2037{
2038 unsigned int i;
2039 int x = -1;
2040
2041 for (i = 0; i < 32; i++)
2042 if (bitmap & (1 << i))
2043 x = i;
2044
2045 return x;
2046}
2047
2048/**
2049 * ata_choose_xfer_mode - attempt to find best transfer mode
2050 * @ap: Port for which an xfer mode will be selected
2051 * @xfer_mode_out: (output) SET FEATURES - XFER MODE code
2052 * @xfer_shift_out: (output) bit shift that selects this mode
2053 *
Jeff Garzik0cba6322005-05-30 19:49:12 -04002054 * Based on host and device capabilities, determine the
2055 * maximum transfer mode that is amenable to all.
2056 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07002057 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04002058 * PCI/etc. bus probe sem.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002059 *
2060 * RETURNS:
2061 * Zero on success, negative on error.
2062 */
2063
2064static int ata_choose_xfer_mode(struct ata_port *ap,
2065 u8 *xfer_mode_out,
2066 unsigned int *xfer_shift_out)
2067{
2068 unsigned int mask, shift;
2069 int x, i;
2070
2071 for (i = 0; i < ARRAY_SIZE(xfer_mode_classes); i++) {
2072 shift = xfer_mode_classes[i].shift;
2073 mask = ata_get_mode_mask(ap, shift);
2074
2075 x = fgb(mask);
2076 if (x >= 0) {
2077 *xfer_mode_out = xfer_mode_classes[i].base + x;
2078 *xfer_shift_out = shift;
2079 return 0;
2080 }
2081 }
2082
2083 return -1;
2084}
2085
2086/**
2087 * ata_dev_set_xfermode - Issue SET FEATURES - XFER MODE command
2088 * @ap: Port associated with device @dev
2089 * @dev: Device to which command will be sent
2090 *
Jeff Garzik780a87f2005-05-30 15:41:05 -04002091 * Issue SET FEATURES - XFER MODE command to device @dev
2092 * on port @ap.
2093 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07002094 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04002095 * PCI/etc. bus probe sem.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002096 */
2097
2098static void ata_dev_set_xfermode(struct ata_port *ap, struct ata_device *dev)
2099{
2100 DECLARE_COMPLETION(wait);
2101 struct ata_queued_cmd *qc;
2102 int rc;
2103 unsigned long flags;
2104
2105 /* set up set-features taskfile */
2106 DPRINTK("set features - xfer mode\n");
2107
2108 qc = ata_qc_new_init(ap, dev);
2109 BUG_ON(qc == NULL);
2110
2111 qc->tf.command = ATA_CMD_SET_FEATURES;
2112 qc->tf.feature = SETFEATURES_XFER;
2113 qc->tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
2114 qc->tf.protocol = ATA_PROT_NODATA;
2115 qc->tf.nsect = dev->xfer_mode;
2116
2117 qc->waiting = &wait;
2118 qc->complete_fn = ata_qc_complete_noop;
2119
2120 spin_lock_irqsave(&ap->host_set->lock, flags);
2121 rc = ata_qc_issue(qc);
2122 spin_unlock_irqrestore(&ap->host_set->lock, flags);
2123
2124 if (rc)
2125 ata_port_disable(ap);
2126 else
2127 wait_for_completion(&wait);
2128
2129 DPRINTK("EXIT\n");
2130}
2131
2132/**
Jeff Garzik0cba6322005-05-30 19:49:12 -04002133 * ata_sg_clean - Unmap DMA memory associated with command
2134 * @qc: Command containing DMA memory to be released
2135 *
2136 * Unmap all mapped DMA memory associated with this command.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002137 *
2138 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04002139 * spin_lock_irqsave(host_set lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002140 */
2141
2142static void ata_sg_clean(struct ata_queued_cmd *qc)
2143{
2144 struct ata_port *ap = qc->ap;
2145 struct scatterlist *sg = qc->sg;
2146 int dir = qc->dma_dir;
2147
2148 assert(qc->flags & ATA_QCFLAG_DMAMAP);
2149 assert(sg != NULL);
2150
2151 if (qc->flags & ATA_QCFLAG_SINGLE)
2152 assert(qc->n_elem == 1);
2153
2154 DPRINTK("unmapping %u sg elements\n", qc->n_elem);
2155
2156 if (qc->flags & ATA_QCFLAG_SG)
2157 dma_unmap_sg(ap->host_set->dev, sg, qc->n_elem, dir);
2158 else
2159 dma_unmap_single(ap->host_set->dev, sg_dma_address(&sg[0]),
2160 sg_dma_len(&sg[0]), dir);
2161
2162 qc->flags &= ~ATA_QCFLAG_DMAMAP;
2163 qc->sg = NULL;
2164}
2165
2166/**
2167 * ata_fill_sg - Fill PCI IDE PRD table
2168 * @qc: Metadata associated with taskfile to be transferred
2169 *
Jeff Garzik780a87f2005-05-30 15:41:05 -04002170 * Fill PCI IDE PRD (scatter-gather) table with segments
2171 * associated with the current disk command.
2172 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07002173 * LOCKING:
Jeff Garzik780a87f2005-05-30 15:41:05 -04002174 * spin_lock_irqsave(host_set lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002175 *
2176 */
2177static void ata_fill_sg(struct ata_queued_cmd *qc)
2178{
2179 struct scatterlist *sg = qc->sg;
2180 struct ata_port *ap = qc->ap;
2181 unsigned int idx, nelem;
2182
2183 assert(sg != NULL);
2184 assert(qc->n_elem > 0);
2185
2186 idx = 0;
2187 for (nelem = qc->n_elem; nelem; nelem--,sg++) {
2188 u32 addr, offset;
2189 u32 sg_len, len;
2190
2191 /* determine if physical DMA addr spans 64K boundary.
2192 * Note h/w doesn't support 64-bit, so we unconditionally
2193 * truncate dma_addr_t to u32.
2194 */
2195 addr = (u32) sg_dma_address(sg);
2196 sg_len = sg_dma_len(sg);
2197
2198 while (sg_len) {
2199 offset = addr & 0xffff;
2200 len = sg_len;
2201 if ((offset + sg_len) > 0x10000)
2202 len = 0x10000 - offset;
2203
2204 ap->prd[idx].addr = cpu_to_le32(addr);
2205 ap->prd[idx].flags_len = cpu_to_le32(len & 0xffff);
2206 VPRINTK("PRD[%u] = (0x%X, 0x%X)\n", idx, addr, len);
2207
2208 idx++;
2209 sg_len -= len;
2210 addr += len;
2211 }
2212 }
2213
2214 if (idx)
2215 ap->prd[idx - 1].flags_len |= cpu_to_le32(ATA_PRD_EOT);
2216}
2217/**
2218 * ata_check_atapi_dma - Check whether ATAPI DMA can be supported
2219 * @qc: Metadata associated with taskfile to check
2220 *
Jeff Garzik780a87f2005-05-30 15:41:05 -04002221 * Allow low-level driver to filter ATA PACKET commands, returning
2222 * a status indicating whether or not it is OK to use DMA for the
2223 * supplied PACKET command.
2224 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07002225 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04002226 * spin_lock_irqsave(host_set lock)
2227 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07002228 * RETURNS: 0 when ATAPI DMA can be used
2229 * nonzero otherwise
2230 */
2231int ata_check_atapi_dma(struct ata_queued_cmd *qc)
2232{
2233 struct ata_port *ap = qc->ap;
2234 int rc = 0; /* Assume ATAPI DMA is OK by default */
2235
2236 if (ap->ops->check_atapi_dma)
2237 rc = ap->ops->check_atapi_dma(qc);
2238
2239 return rc;
2240}
2241/**
2242 * ata_qc_prep - Prepare taskfile for submission
2243 * @qc: Metadata associated with taskfile to be prepared
2244 *
Jeff Garzik780a87f2005-05-30 15:41:05 -04002245 * Prepare ATA taskfile for submission.
2246 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07002247 * LOCKING:
2248 * spin_lock_irqsave(host_set lock)
2249 */
2250void ata_qc_prep(struct ata_queued_cmd *qc)
2251{
2252 if (!(qc->flags & ATA_QCFLAG_DMAMAP))
2253 return;
2254
2255 ata_fill_sg(qc);
2256}
2257
Jeff Garzik0cba6322005-05-30 19:49:12 -04002258/**
2259 * ata_sg_init_one - Associate command with memory buffer
2260 * @qc: Command to be associated
2261 * @buf: Memory buffer
2262 * @buflen: Length of memory buffer, in bytes.
2263 *
2264 * Initialize the data-related elements of queued_cmd @qc
2265 * to point to a single memory buffer, @buf of byte length @buflen.
2266 *
2267 * LOCKING:
2268 * spin_lock_irqsave(host_set lock)
2269 */
2270
Edward Falk0baab862005-06-02 18:17:13 -04002271
2272
2273/**
2274 * ata_sg_init_one - Prepare a one-entry scatter-gather list.
2275 * @qc: Queued command
2276 * @buf: transfer buffer
2277 * @buflen: length of buf
2278 *
2279 * Builds a single-entry scatter-gather list to initiate a
2280 * transfer utilizing the specified buffer.
2281 *
2282 * LOCKING:
2283 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002284void ata_sg_init_one(struct ata_queued_cmd *qc, void *buf, unsigned int buflen)
2285{
2286 struct scatterlist *sg;
2287
2288 qc->flags |= ATA_QCFLAG_SINGLE;
2289
2290 memset(&qc->sgent, 0, sizeof(qc->sgent));
2291 qc->sg = &qc->sgent;
2292 qc->n_elem = 1;
2293 qc->buf_virt = buf;
2294
2295 sg = qc->sg;
2296 sg->page = virt_to_page(buf);
2297 sg->offset = (unsigned long) buf & ~PAGE_MASK;
Albert Lee32529e02005-05-26 03:49:42 -04002298 sg->length = buflen;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002299}
2300
Jeff Garzik0cba6322005-05-30 19:49:12 -04002301/**
2302 * ata_sg_init - Associate command with scatter-gather table.
2303 * @qc: Command to be associated
2304 * @sg: Scatter-gather table.
2305 * @n_elem: Number of elements in s/g table.
2306 *
2307 * Initialize the data-related elements of queued_cmd @qc
2308 * to point to a scatter-gather table @sg, containing @n_elem
2309 * elements.
2310 *
2311 * LOCKING:
2312 * spin_lock_irqsave(host_set lock)
2313 */
2314
Edward Falk0baab862005-06-02 18:17:13 -04002315
2316/**
2317 * ata_sg_init - Assign a scatter gather list to a queued command
2318 * @qc: Queued command
2319 * @sg: Scatter-gather list
2320 * @n_elem: length of sg list
2321 *
2322 * Attaches a scatter-gather list to a queued command.
2323 *
2324 * LOCKING:
2325 */
2326
Linus Torvalds1da177e2005-04-16 15:20:36 -07002327void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg,
2328 unsigned int n_elem)
2329{
2330 qc->flags |= ATA_QCFLAG_SG;
2331 qc->sg = sg;
2332 qc->n_elem = n_elem;
2333}
2334
2335/**
Jeff Garzik0cba6322005-05-30 19:49:12 -04002336 * ata_sg_setup_one - DMA-map the memory buffer associated with a command.
2337 * @qc: Command with memory buffer to be mapped.
2338 *
2339 * DMA-map the memory buffer associated with queued_cmd @qc.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002340 *
2341 * LOCKING:
2342 * spin_lock_irqsave(host_set lock)
2343 *
2344 * RETURNS:
Jeff Garzik0cba6322005-05-30 19:49:12 -04002345 * Zero on success, negative on error.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002346 */
2347
2348static int ata_sg_setup_one(struct ata_queued_cmd *qc)
2349{
2350 struct ata_port *ap = qc->ap;
2351 int dir = qc->dma_dir;
2352 struct scatterlist *sg = qc->sg;
2353 dma_addr_t dma_address;
2354
2355 dma_address = dma_map_single(ap->host_set->dev, qc->buf_virt,
Albert Lee32529e02005-05-26 03:49:42 -04002356 sg->length, dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002357 if (dma_mapping_error(dma_address))
2358 return -1;
2359
2360 sg_dma_address(sg) = dma_address;
Albert Lee32529e02005-05-26 03:49:42 -04002361 sg_dma_len(sg) = sg->length;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002362
2363 DPRINTK("mapped buffer of %d bytes for %s\n", sg_dma_len(sg),
2364 qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
2365
2366 return 0;
2367}
2368
2369/**
Jeff Garzik0cba6322005-05-30 19:49:12 -04002370 * ata_sg_setup - DMA-map the scatter-gather table associated with a command.
2371 * @qc: Command with scatter-gather table to be mapped.
2372 *
2373 * DMA-map the scatter-gather table associated with queued_cmd @qc.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002374 *
2375 * LOCKING:
2376 * spin_lock_irqsave(host_set lock)
2377 *
2378 * RETURNS:
Jeff Garzik0cba6322005-05-30 19:49:12 -04002379 * Zero on success, negative on error.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002380 *
2381 */
2382
2383static int ata_sg_setup(struct ata_queued_cmd *qc)
2384{
2385 struct ata_port *ap = qc->ap;
2386 struct scatterlist *sg = qc->sg;
2387 int n_elem, dir;
2388
2389 VPRINTK("ENTER, ata%u\n", ap->id);
2390 assert(qc->flags & ATA_QCFLAG_SG);
2391
2392 dir = qc->dma_dir;
2393 n_elem = dma_map_sg(ap->host_set->dev, sg, qc->n_elem, dir);
2394 if (n_elem < 1)
2395 return -1;
2396
2397 DPRINTK("%d sg elements mapped\n", n_elem);
2398
2399 qc->n_elem = n_elem;
2400
2401 return 0;
2402}
2403
2404/**
2405 * ata_pio_poll -
2406 * @ap:
2407 *
2408 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04002409 * None. (executing in kernel thread context)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002410 *
2411 * RETURNS:
2412 *
2413 */
2414
2415static unsigned long ata_pio_poll(struct ata_port *ap)
2416{
2417 u8 status;
2418 unsigned int poll_state = PIO_ST_UNKNOWN;
2419 unsigned int reg_state = PIO_ST_UNKNOWN;
2420 const unsigned int tmout_state = PIO_ST_TMOUT;
2421
2422 switch (ap->pio_task_state) {
2423 case PIO_ST:
2424 case PIO_ST_POLL:
2425 poll_state = PIO_ST_POLL;
2426 reg_state = PIO_ST;
2427 break;
2428 case PIO_ST_LAST:
2429 case PIO_ST_LAST_POLL:
2430 poll_state = PIO_ST_LAST_POLL;
2431 reg_state = PIO_ST_LAST;
2432 break;
2433 default:
2434 BUG();
2435 break;
2436 }
2437
2438 status = ata_chk_status(ap);
2439 if (status & ATA_BUSY) {
2440 if (time_after(jiffies, ap->pio_task_timeout)) {
2441 ap->pio_task_state = tmout_state;
2442 return 0;
2443 }
2444 ap->pio_task_state = poll_state;
2445 return ATA_SHORT_PAUSE;
2446 }
2447
2448 ap->pio_task_state = reg_state;
2449 return 0;
2450}
2451
2452/**
2453 * ata_pio_complete -
2454 * @ap:
2455 *
2456 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04002457 * None. (executing in kernel thread context)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002458 */
2459
2460static void ata_pio_complete (struct ata_port *ap)
2461{
2462 struct ata_queued_cmd *qc;
2463 u8 drv_stat;
2464
2465 /*
2466 * This is purely hueristic. This is a fast path.
2467 * Sometimes when we enter, BSY will be cleared in
2468 * a chk-status or two. If not, the drive is probably seeking
2469 * or something. Snooze for a couple msecs, then
2470 * chk-status again. If still busy, fall back to
2471 * PIO_ST_POLL state.
2472 */
2473 drv_stat = ata_busy_wait(ap, ATA_BUSY | ATA_DRQ, 10);
2474 if (drv_stat & (ATA_BUSY | ATA_DRQ)) {
2475 msleep(2);
2476 drv_stat = ata_busy_wait(ap, ATA_BUSY | ATA_DRQ, 10);
2477 if (drv_stat & (ATA_BUSY | ATA_DRQ)) {
2478 ap->pio_task_state = PIO_ST_LAST_POLL;
2479 ap->pio_task_timeout = jiffies + ATA_TMOUT_PIO;
2480 return;
2481 }
2482 }
2483
2484 drv_stat = ata_wait_idle(ap);
2485 if (!ata_ok(drv_stat)) {
2486 ap->pio_task_state = PIO_ST_ERR;
2487 return;
2488 }
2489
2490 qc = ata_qc_from_tag(ap, ap->active_tag);
2491 assert(qc != NULL);
2492
2493 ap->pio_task_state = PIO_ST_IDLE;
2494
2495 ata_irq_on(ap);
2496
2497 ata_qc_complete(qc, drv_stat);
2498}
2499
Edward Falk0baab862005-06-02 18:17:13 -04002500
2501/**
2502 * swap_buf_le16 -
2503 * @buf: Buffer to swap
2504 * @buf_words: Number of 16-bit words in buffer.
2505 *
2506 * Swap halves of 16-bit words if needed to convert from
2507 * little-endian byte order to native cpu byte order, or
2508 * vice-versa.
2509 *
2510 * LOCKING:
2511 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002512void swap_buf_le16(u16 *buf, unsigned int buf_words)
2513{
2514#ifdef __BIG_ENDIAN
2515 unsigned int i;
2516
2517 for (i = 0; i < buf_words; i++)
2518 buf[i] = le16_to_cpu(buf[i]);
2519#endif /* __BIG_ENDIAN */
2520}
2521
Albert Lee6ae4cfb2005-08-12 14:15:34 +08002522/**
2523 * ata_mmio_data_xfer - Transfer data by MMIO
2524 * @ap: port to read/write
2525 * @buf: data buffer
2526 * @buflen: buffer length
2527 * @do_write: read/write
2528 *
2529 * Transfer data from/to the device data register by MMIO.
2530 *
2531 * LOCKING:
2532 * Inherited from caller.
2533 *
2534 */
2535
Linus Torvalds1da177e2005-04-16 15:20:36 -07002536static void ata_mmio_data_xfer(struct ata_port *ap, unsigned char *buf,
2537 unsigned int buflen, int write_data)
2538{
2539 unsigned int i;
2540 unsigned int words = buflen >> 1;
2541 u16 *buf16 = (u16 *) buf;
2542 void __iomem *mmio = (void __iomem *)ap->ioaddr.data_addr;
2543
Albert Lee6ae4cfb2005-08-12 14:15:34 +08002544 /* Transfer multiple of 2 bytes */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002545 if (write_data) {
2546 for (i = 0; i < words; i++)
2547 writew(le16_to_cpu(buf16[i]), mmio);
2548 } else {
2549 for (i = 0; i < words; i++)
2550 buf16[i] = cpu_to_le16(readw(mmio));
2551 }
Albert Lee6ae4cfb2005-08-12 14:15:34 +08002552
2553 /* Transfer trailing 1 byte, if any. */
2554 if (unlikely(buflen & 0x01)) {
2555 u16 align_buf[1] = { 0 };
2556 unsigned char *trailing_buf = buf + buflen - 1;
2557
2558 if (write_data) {
2559 memcpy(align_buf, trailing_buf, 1);
2560 writew(le16_to_cpu(align_buf[0]), mmio);
2561 } else {
2562 align_buf[0] = cpu_to_le16(readw(mmio));
2563 memcpy(trailing_buf, align_buf, 1);
2564 }
2565 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002566}
2567
Albert Lee6ae4cfb2005-08-12 14:15:34 +08002568/**
2569 * ata_pio_data_xfer - Transfer data by PIO
2570 * @ap: port to read/write
2571 * @buf: data buffer
2572 * @buflen: buffer length
2573 * @do_write: read/write
2574 *
2575 * Transfer data from/to the device data register by PIO.
2576 *
2577 * LOCKING:
2578 * Inherited from caller.
2579 *
2580 */
2581
Linus Torvalds1da177e2005-04-16 15:20:36 -07002582static void ata_pio_data_xfer(struct ata_port *ap, unsigned char *buf,
2583 unsigned int buflen, int write_data)
2584{
Albert Lee6ae4cfb2005-08-12 14:15:34 +08002585 unsigned int words = buflen >> 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002586
Albert Lee6ae4cfb2005-08-12 14:15:34 +08002587 /* Transfer multiple of 2 bytes */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002588 if (write_data)
Albert Lee6ae4cfb2005-08-12 14:15:34 +08002589 outsw(ap->ioaddr.data_addr, buf, words);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002590 else
Albert Lee6ae4cfb2005-08-12 14:15:34 +08002591 insw(ap->ioaddr.data_addr, buf, words);
2592
2593 /* Transfer trailing 1 byte, if any. */
2594 if (unlikely(buflen & 0x01)) {
2595 u16 align_buf[1] = { 0 };
2596 unsigned char *trailing_buf = buf + buflen - 1;
2597
2598 if (write_data) {
2599 memcpy(align_buf, trailing_buf, 1);
2600 outw(le16_to_cpu(align_buf[0]), ap->ioaddr.data_addr);
2601 } else {
2602 align_buf[0] = cpu_to_le16(inw(ap->ioaddr.data_addr));
2603 memcpy(trailing_buf, align_buf, 1);
2604 }
2605 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002606}
2607
Albert Lee6ae4cfb2005-08-12 14:15:34 +08002608/**
2609 * ata_data_xfer - Transfer data from/to the data register.
2610 * @ap: port to read/write
2611 * @buf: data buffer
2612 * @buflen: buffer length
2613 * @do_write: read/write
2614 *
2615 * Transfer data from/to the device data register.
2616 *
2617 * LOCKING:
2618 * Inherited from caller.
2619 *
2620 */
2621
Linus Torvalds1da177e2005-04-16 15:20:36 -07002622static void ata_data_xfer(struct ata_port *ap, unsigned char *buf,
2623 unsigned int buflen, int do_write)
2624{
2625 if (ap->flags & ATA_FLAG_MMIO)
2626 ata_mmio_data_xfer(ap, buf, buflen, do_write);
2627 else
2628 ata_pio_data_xfer(ap, buf, buflen, do_write);
2629}
2630
Albert Lee6ae4cfb2005-08-12 14:15:34 +08002631/**
2632 * ata_pio_sector - Transfer ATA_SECT_SIZE (512 bytes) of data.
2633 * @qc: Command on going
2634 *
2635 * Transfer ATA_SECT_SIZE of data from/to the ATA device.
2636 *
2637 * LOCKING:
2638 * Inherited from caller.
2639 */
2640
Linus Torvalds1da177e2005-04-16 15:20:36 -07002641static void ata_pio_sector(struct ata_queued_cmd *qc)
2642{
2643 int do_write = (qc->tf.flags & ATA_TFLAG_WRITE);
2644 struct scatterlist *sg = qc->sg;
2645 struct ata_port *ap = qc->ap;
2646 struct page *page;
2647 unsigned int offset;
2648 unsigned char *buf;
2649
2650 if (qc->cursect == (qc->nsect - 1))
2651 ap->pio_task_state = PIO_ST_LAST;
2652
2653 page = sg[qc->cursg].page;
2654 offset = sg[qc->cursg].offset + qc->cursg_ofs * ATA_SECT_SIZE;
2655
2656 /* get the current page and offset */
2657 page = nth_page(page, (offset >> PAGE_SHIFT));
2658 offset %= PAGE_SIZE;
2659
2660 buf = kmap(page) + offset;
2661
2662 qc->cursect++;
2663 qc->cursg_ofs++;
2664
Albert Lee32529e02005-05-26 03:49:42 -04002665 if ((qc->cursg_ofs * ATA_SECT_SIZE) == (&sg[qc->cursg])->length) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002666 qc->cursg++;
2667 qc->cursg_ofs = 0;
2668 }
2669
2670 DPRINTK("data %s\n", qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
2671
2672 /* do the actual data transfer */
2673 do_write = (qc->tf.flags & ATA_TFLAG_WRITE);
2674 ata_data_xfer(ap, buf, ATA_SECT_SIZE, do_write);
2675
2676 kunmap(page);
2677}
2678
Albert Lee6ae4cfb2005-08-12 14:15:34 +08002679/**
2680 * __atapi_pio_bytes - Transfer data from/to the ATAPI device.
2681 * @qc: Command on going
2682 * @bytes: number of bytes
2683 *
2684 * Transfer Transfer data from/to the ATAPI device.
2685 *
2686 * LOCKING:
2687 * Inherited from caller.
2688 *
2689 */
2690
Linus Torvalds1da177e2005-04-16 15:20:36 -07002691static void __atapi_pio_bytes(struct ata_queued_cmd *qc, unsigned int bytes)
2692{
2693 int do_write = (qc->tf.flags & ATA_TFLAG_WRITE);
2694 struct scatterlist *sg = qc->sg;
2695 struct ata_port *ap = qc->ap;
2696 struct page *page;
2697 unsigned char *buf;
2698 unsigned int offset, count;
2699
Albert Lee563a6e12005-08-12 14:17:50 +08002700 if (qc->curbytes + bytes >= qc->nbytes)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002701 ap->pio_task_state = PIO_ST_LAST;
2702
2703next_sg:
Albert Lee563a6e12005-08-12 14:17:50 +08002704 if (unlikely(qc->cursg >= qc->n_elem)) {
2705 /*
2706 * The end of qc->sg is reached and the device expects
2707 * more data to transfer. In order not to overrun qc->sg
2708 * and fulfill length specified in the byte count register,
2709 * - for read case, discard trailing data from the device
2710 * - for write case, padding zero data to the device
2711 */
2712 u16 pad_buf[1] = { 0 };
2713 unsigned int words = bytes >> 1;
2714 unsigned int i;
2715
2716 if (words) /* warning if bytes > 1 */
2717 printk(KERN_WARNING "ata%u: %u bytes trailing data\n",
2718 ap->id, bytes);
2719
2720 for (i = 0; i < words; i++)
2721 ata_data_xfer(ap, (unsigned char*)pad_buf, 2, do_write);
2722
2723 ap->pio_task_state = PIO_ST_LAST;
2724 return;
2725 }
2726
Linus Torvalds1da177e2005-04-16 15:20:36 -07002727 sg = &qc->sg[qc->cursg];
2728
Linus Torvalds1da177e2005-04-16 15:20:36 -07002729 page = sg->page;
2730 offset = sg->offset + qc->cursg_ofs;
2731
2732 /* get the current page and offset */
2733 page = nth_page(page, (offset >> PAGE_SHIFT));
2734 offset %= PAGE_SIZE;
2735
Albert Lee6952df02005-06-06 15:56:03 +08002736 /* don't overrun current sg */
Albert Lee32529e02005-05-26 03:49:42 -04002737 count = min(sg->length - qc->cursg_ofs, bytes);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002738
2739 /* don't cross page boundaries */
2740 count = min(count, (unsigned int)PAGE_SIZE - offset);
2741
2742 buf = kmap(page) + offset;
2743
2744 bytes -= count;
2745 qc->curbytes += count;
2746 qc->cursg_ofs += count;
2747
Albert Lee32529e02005-05-26 03:49:42 -04002748 if (qc->cursg_ofs == sg->length) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002749 qc->cursg++;
2750 qc->cursg_ofs = 0;
2751 }
2752
2753 DPRINTK("data %s\n", qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
2754
2755 /* do the actual data transfer */
2756 ata_data_xfer(ap, buf, count, do_write);
2757
2758 kunmap(page);
2759
Albert Lee563a6e12005-08-12 14:17:50 +08002760 if (bytes)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002761 goto next_sg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002762}
2763
Albert Lee6ae4cfb2005-08-12 14:15:34 +08002764/**
2765 * atapi_pio_bytes - Transfer data from/to the ATAPI device.
2766 * @qc: Command on going
2767 *
2768 * Transfer Transfer data from/to the ATAPI device.
2769 *
2770 * LOCKING:
2771 * Inherited from caller.
2772 *
2773 */
2774
Linus Torvalds1da177e2005-04-16 15:20:36 -07002775static void atapi_pio_bytes(struct ata_queued_cmd *qc)
2776{
2777 struct ata_port *ap = qc->ap;
2778 struct ata_device *dev = qc->dev;
2779 unsigned int ireason, bc_lo, bc_hi, bytes;
2780 int i_write, do_write = (qc->tf.flags & ATA_TFLAG_WRITE) ? 1 : 0;
2781
2782 ap->ops->tf_read(ap, &qc->tf);
2783 ireason = qc->tf.nsect;
2784 bc_lo = qc->tf.lbam;
2785 bc_hi = qc->tf.lbah;
2786 bytes = (bc_hi << 8) | bc_lo;
2787
2788 /* shall be cleared to zero, indicating xfer of data */
2789 if (ireason & (1 << 0))
2790 goto err_out;
2791
2792 /* make sure transfer direction matches expected */
2793 i_write = ((ireason & (1 << 1)) == 0) ? 1 : 0;
2794 if (do_write != i_write)
2795 goto err_out;
2796
2797 __atapi_pio_bytes(qc, bytes);
2798
2799 return;
2800
2801err_out:
2802 printk(KERN_INFO "ata%u: dev %u: ATAPI check failed\n",
2803 ap->id, dev->devno);
2804 ap->pio_task_state = PIO_ST_ERR;
2805}
2806
2807/**
2808 * ata_pio_sector -
2809 * @ap:
2810 *
2811 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04002812 * None. (executing in kernel thread context)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002813 */
2814
2815static void ata_pio_block(struct ata_port *ap)
2816{
2817 struct ata_queued_cmd *qc;
2818 u8 status;
2819
2820 /*
2821 * This is purely hueristic. This is a fast path.
2822 * Sometimes when we enter, BSY will be cleared in
2823 * a chk-status or two. If not, the drive is probably seeking
2824 * or something. Snooze for a couple msecs, then
2825 * chk-status again. If still busy, fall back to
2826 * PIO_ST_POLL state.
2827 */
2828 status = ata_busy_wait(ap, ATA_BUSY, 5);
2829 if (status & ATA_BUSY) {
2830 msleep(2);
2831 status = ata_busy_wait(ap, ATA_BUSY, 10);
2832 if (status & ATA_BUSY) {
2833 ap->pio_task_state = PIO_ST_POLL;
2834 ap->pio_task_timeout = jiffies + ATA_TMOUT_PIO;
2835 return;
2836 }
2837 }
2838
2839 qc = ata_qc_from_tag(ap, ap->active_tag);
2840 assert(qc != NULL);
2841
2842 if (is_atapi_taskfile(&qc->tf)) {
2843 /* no more data to transfer or unsupported ATAPI command */
2844 if ((status & ATA_DRQ) == 0) {
2845 ap->pio_task_state = PIO_ST_IDLE;
2846
2847 ata_irq_on(ap);
2848
2849 ata_qc_complete(qc, status);
2850 return;
2851 }
2852
2853 atapi_pio_bytes(qc);
2854 } else {
2855 /* handle BSY=0, DRQ=0 as error */
2856 if ((status & ATA_DRQ) == 0) {
2857 ap->pio_task_state = PIO_ST_ERR;
2858 return;
2859 }
2860
2861 ata_pio_sector(qc);
2862 }
2863}
2864
2865static void ata_pio_error(struct ata_port *ap)
2866{
2867 struct ata_queued_cmd *qc;
2868 u8 drv_stat;
2869
2870 qc = ata_qc_from_tag(ap, ap->active_tag);
2871 assert(qc != NULL);
2872
2873 drv_stat = ata_chk_status(ap);
2874 printk(KERN_WARNING "ata%u: PIO error, drv_stat 0x%x\n",
2875 ap->id, drv_stat);
2876
2877 ap->pio_task_state = PIO_ST_IDLE;
2878
2879 ata_irq_on(ap);
2880
2881 ata_qc_complete(qc, drv_stat | ATA_ERR);
2882}
2883
2884static void ata_pio_task(void *_data)
2885{
2886 struct ata_port *ap = _data;
2887 unsigned long timeout = 0;
2888
2889 switch (ap->pio_task_state) {
2890 case PIO_ST_IDLE:
2891 return;
2892
2893 case PIO_ST:
2894 ata_pio_block(ap);
2895 break;
2896
2897 case PIO_ST_LAST:
2898 ata_pio_complete(ap);
2899 break;
2900
2901 case PIO_ST_POLL:
2902 case PIO_ST_LAST_POLL:
2903 timeout = ata_pio_poll(ap);
2904 break;
2905
2906 case PIO_ST_TMOUT:
2907 case PIO_ST_ERR:
2908 ata_pio_error(ap);
2909 return;
2910 }
2911
2912 if (timeout)
2913 queue_delayed_work(ata_wq, &ap->pio_task,
2914 timeout);
2915 else
2916 queue_work(ata_wq, &ap->pio_task);
2917}
2918
2919static void atapi_request_sense(struct ata_port *ap, struct ata_device *dev,
2920 struct scsi_cmnd *cmd)
2921{
2922 DECLARE_COMPLETION(wait);
2923 struct ata_queued_cmd *qc;
2924 unsigned long flags;
2925 int rc;
2926
2927 DPRINTK("ATAPI request sense\n");
2928
2929 qc = ata_qc_new_init(ap, dev);
2930 BUG_ON(qc == NULL);
2931
2932 /* FIXME: is this needed? */
2933 memset(cmd->sense_buffer, 0, sizeof(cmd->sense_buffer));
2934
2935 ata_sg_init_one(qc, cmd->sense_buffer, sizeof(cmd->sense_buffer));
2936 qc->dma_dir = DMA_FROM_DEVICE;
2937
Albert Lee21b1ed72005-04-29 17:34:59 +08002938 memset(&qc->cdb, 0, ap->cdb_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002939 qc->cdb[0] = REQUEST_SENSE;
2940 qc->cdb[4] = SCSI_SENSE_BUFFERSIZE;
2941
2942 qc->tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
2943 qc->tf.command = ATA_CMD_PACKET;
2944
2945 qc->tf.protocol = ATA_PROT_ATAPI;
2946 qc->tf.lbam = (8 * 1024) & 0xff;
2947 qc->tf.lbah = (8 * 1024) >> 8;
2948 qc->nbytes = SCSI_SENSE_BUFFERSIZE;
2949
2950 qc->waiting = &wait;
2951 qc->complete_fn = ata_qc_complete_noop;
2952
2953 spin_lock_irqsave(&ap->host_set->lock, flags);
2954 rc = ata_qc_issue(qc);
2955 spin_unlock_irqrestore(&ap->host_set->lock, flags);
2956
2957 if (rc)
2958 ata_port_disable(ap);
2959 else
2960 wait_for_completion(&wait);
2961
2962 DPRINTK("EXIT\n");
2963}
2964
2965/**
2966 * ata_qc_timeout - Handle timeout of queued command
2967 * @qc: Command that timed out
2968 *
2969 * Some part of the kernel (currently, only the SCSI layer)
2970 * has noticed that the active command on port @ap has not
2971 * completed after a specified length of time. Handle this
2972 * condition by disabling DMA (if necessary) and completing
2973 * transactions, with error if necessary.
2974 *
2975 * This also handles the case of the "lost interrupt", where
2976 * for some reason (possibly hardware bug, possibly driver bug)
2977 * an interrupt was not delivered to the driver, even though the
2978 * transaction completed successfully.
2979 *
2980 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04002981 * Inherited from SCSI layer (none, can sleep)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002982 */
2983
2984static void ata_qc_timeout(struct ata_queued_cmd *qc)
2985{
2986 struct ata_port *ap = qc->ap;
2987 struct ata_device *dev = qc->dev;
2988 u8 host_stat = 0, drv_stat;
2989
2990 DPRINTK("ENTER\n");
2991
2992 /* FIXME: doesn't this conflict with timeout handling? */
2993 if (qc->dev->class == ATA_DEV_ATAPI && qc->scsicmd) {
2994 struct scsi_cmnd *cmd = qc->scsicmd;
2995
Christoph Hellwig3111b0d2005-06-19 13:43:26 +02002996 if (!(cmd->eh_eflags & SCSI_EH_CANCEL_CMD)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002997
2998 /* finish completing original command */
2999 __ata_qc_complete(qc);
3000
3001 atapi_request_sense(ap, dev, cmd);
3002
3003 cmd->result = (CHECK_CONDITION << 1) | (DID_OK << 16);
3004 scsi_finish_command(cmd);
3005
3006 goto out;
3007 }
3008 }
3009
3010 /* hack alert! We cannot use the supplied completion
3011 * function from inside the ->eh_strategy_handler() thread.
3012 * libata is the only user of ->eh_strategy_handler() in
3013 * any kernel, so the default scsi_done() assumes it is
3014 * not being called from the SCSI EH.
3015 */
3016 qc->scsidone = scsi_finish_command;
3017
3018 switch (qc->tf.protocol) {
3019
3020 case ATA_PROT_DMA:
3021 case ATA_PROT_ATAPI_DMA:
3022 host_stat = ap->ops->bmdma_status(ap);
3023
3024 /* before we do anything else, clear DMA-Start bit */
3025 ap->ops->bmdma_stop(ap);
3026
3027 /* fall through */
3028
3029 default:
3030 ata_altstatus(ap);
3031 drv_stat = ata_chk_status(ap);
3032
3033 /* ack bmdma irq events */
3034 ap->ops->irq_clear(ap);
3035
3036 printk(KERN_ERR "ata%u: command 0x%x timeout, stat 0x%x host_stat 0x%x\n",
3037 ap->id, qc->tf.command, drv_stat, host_stat);
3038
3039 /* complete taskfile transaction */
3040 ata_qc_complete(qc, drv_stat);
3041 break;
3042 }
3043out:
3044 DPRINTK("EXIT\n");
3045}
3046
3047/**
3048 * ata_eng_timeout - Handle timeout of queued command
3049 * @ap: Port on which timed-out command is active
3050 *
3051 * Some part of the kernel (currently, only the SCSI layer)
3052 * has noticed that the active command on port @ap has not
3053 * completed after a specified length of time. Handle this
3054 * condition by disabling DMA (if necessary) and completing
3055 * transactions, with error if necessary.
3056 *
3057 * This also handles the case of the "lost interrupt", where
3058 * for some reason (possibly hardware bug, possibly driver bug)
3059 * an interrupt was not delivered to the driver, even though the
3060 * transaction completed successfully.
3061 *
3062 * LOCKING:
3063 * Inherited from SCSI layer (none, can sleep)
3064 */
3065
3066void ata_eng_timeout(struct ata_port *ap)
3067{
3068 struct ata_queued_cmd *qc;
3069
3070 DPRINTK("ENTER\n");
3071
3072 qc = ata_qc_from_tag(ap, ap->active_tag);
3073 if (!qc) {
3074 printk(KERN_ERR "ata%u: BUG: timeout without command\n",
3075 ap->id);
3076 goto out;
3077 }
3078
3079 ata_qc_timeout(qc);
3080
3081out:
3082 DPRINTK("EXIT\n");
3083}
3084
3085/**
3086 * ata_qc_new - Request an available ATA command, for queueing
3087 * @ap: Port associated with device @dev
3088 * @dev: Device from whom we request an available command structure
3089 *
3090 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04003091 * None.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003092 */
3093
3094static struct ata_queued_cmd *ata_qc_new(struct ata_port *ap)
3095{
3096 struct ata_queued_cmd *qc = NULL;
3097 unsigned int i;
3098
3099 for (i = 0; i < ATA_MAX_QUEUE; i++)
3100 if (!test_and_set_bit(i, &ap->qactive)) {
3101 qc = ata_qc_from_tag(ap, i);
3102 break;
3103 }
3104
3105 if (qc)
3106 qc->tag = i;
3107
3108 return qc;
3109}
3110
3111/**
3112 * ata_qc_new_init - Request an available ATA command, and initialize it
3113 * @ap: Port associated with device @dev
3114 * @dev: Device from whom we request an available command structure
3115 *
3116 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04003117 * None.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003118 */
3119
3120struct ata_queued_cmd *ata_qc_new_init(struct ata_port *ap,
3121 struct ata_device *dev)
3122{
3123 struct ata_queued_cmd *qc;
3124
3125 qc = ata_qc_new(ap);
3126 if (qc) {
3127 qc->sg = NULL;
3128 qc->flags = 0;
3129 qc->scsicmd = NULL;
3130 qc->ap = ap;
3131 qc->dev = dev;
3132 qc->cursect = qc->cursg = qc->cursg_ofs = 0;
3133 qc->nsect = 0;
3134 qc->nbytes = qc->curbytes = 0;
3135
3136 ata_tf_init(ap, &qc->tf, dev->devno);
3137
3138 if (dev->flags & ATA_DFLAG_LBA48)
3139 qc->tf.flags |= ATA_TFLAG_LBA48;
3140 }
3141
3142 return qc;
3143}
3144
3145static int ata_qc_complete_noop(struct ata_queued_cmd *qc, u8 drv_stat)
3146{
3147 return 0;
3148}
3149
3150static void __ata_qc_complete(struct ata_queued_cmd *qc)
3151{
3152 struct ata_port *ap = qc->ap;
3153 unsigned int tag, do_clear = 0;
3154
3155 qc->flags = 0;
3156 tag = qc->tag;
3157 if (likely(ata_tag_valid(tag))) {
3158 if (tag == ap->active_tag)
3159 ap->active_tag = ATA_TAG_POISON;
3160 qc->tag = ATA_TAG_POISON;
3161 do_clear = 1;
3162 }
3163
3164 if (qc->waiting) {
3165 struct completion *waiting = qc->waiting;
3166 qc->waiting = NULL;
3167 complete(waiting);
3168 }
3169
3170 if (likely(do_clear))
3171 clear_bit(tag, &ap->qactive);
3172}
3173
3174/**
3175 * ata_qc_free - free unused ata_queued_cmd
3176 * @qc: Command to complete
3177 *
3178 * Designed to free unused ata_queued_cmd object
3179 * in case something prevents using it.
3180 *
3181 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04003182 * spin_lock_irqsave(host_set lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003183 *
3184 */
3185void ata_qc_free(struct ata_queued_cmd *qc)
3186{
3187 assert(qc != NULL); /* ata_qc_from_tag _might_ return NULL */
3188 assert(qc->waiting == NULL); /* nothing should be waiting */
3189
3190 __ata_qc_complete(qc);
3191}
3192
3193/**
3194 * ata_qc_complete - Complete an active ATA command
3195 * @qc: Command to complete
Jeff Garzik0cba6322005-05-30 19:49:12 -04003196 * @drv_stat: ATA Status register contents
3197 *
3198 * Indicate to the mid and upper layers that an ATA
3199 * command has completed, with either an ok or not-ok status.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003200 *
3201 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04003202 * spin_lock_irqsave(host_set lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003203 *
3204 */
3205
3206void ata_qc_complete(struct ata_queued_cmd *qc, u8 drv_stat)
3207{
3208 int rc;
3209
3210 assert(qc != NULL); /* ata_qc_from_tag _might_ return NULL */
3211 assert(qc->flags & ATA_QCFLAG_ACTIVE);
3212
3213 if (likely(qc->flags & ATA_QCFLAG_DMAMAP))
3214 ata_sg_clean(qc);
3215
3216 /* call completion callback */
3217 rc = qc->complete_fn(qc, drv_stat);
Albert Lee21b1ed72005-04-29 17:34:59 +08003218 qc->flags &= ~ATA_QCFLAG_ACTIVE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003219
3220 /* if callback indicates not to complete command (non-zero),
3221 * return immediately
3222 */
3223 if (rc != 0)
3224 return;
3225
3226 __ata_qc_complete(qc);
3227
3228 VPRINTK("EXIT\n");
3229}
3230
3231static inline int ata_should_dma_map(struct ata_queued_cmd *qc)
3232{
3233 struct ata_port *ap = qc->ap;
3234
3235 switch (qc->tf.protocol) {
3236 case ATA_PROT_DMA:
3237 case ATA_PROT_ATAPI_DMA:
3238 return 1;
3239
3240 case ATA_PROT_ATAPI:
3241 case ATA_PROT_PIO:
3242 case ATA_PROT_PIO_MULT:
3243 if (ap->flags & ATA_FLAG_PIO_DMA)
3244 return 1;
3245
3246 /* fall through */
3247
3248 default:
3249 return 0;
3250 }
3251
3252 /* never reached */
3253}
3254
3255/**
3256 * ata_qc_issue - issue taskfile to device
3257 * @qc: command to issue to device
3258 *
3259 * Prepare an ATA command to submission to device.
3260 * This includes mapping the data into a DMA-able
3261 * area, filling in the S/G table, and finally
3262 * writing the taskfile to hardware, starting the command.
3263 *
3264 * LOCKING:
3265 * spin_lock_irqsave(host_set lock)
3266 *
3267 * RETURNS:
3268 * Zero on success, negative on error.
3269 */
3270
3271int ata_qc_issue(struct ata_queued_cmd *qc)
3272{
3273 struct ata_port *ap = qc->ap;
3274
3275 if (ata_should_dma_map(qc)) {
3276 if (qc->flags & ATA_QCFLAG_SG) {
3277 if (ata_sg_setup(qc))
3278 goto err_out;
3279 } else if (qc->flags & ATA_QCFLAG_SINGLE) {
3280 if (ata_sg_setup_one(qc))
3281 goto err_out;
3282 }
3283 } else {
3284 qc->flags &= ~ATA_QCFLAG_DMAMAP;
3285 }
3286
3287 ap->ops->qc_prep(qc);
3288
3289 qc->ap->active_tag = qc->tag;
3290 qc->flags |= ATA_QCFLAG_ACTIVE;
3291
3292 return ap->ops->qc_issue(qc);
3293
3294err_out:
3295 return -1;
3296}
3297
Edward Falk0baab862005-06-02 18:17:13 -04003298
Linus Torvalds1da177e2005-04-16 15:20:36 -07003299/**
3300 * ata_qc_issue_prot - issue taskfile to device in proto-dependent manner
3301 * @qc: command to issue to device
3302 *
3303 * Using various libata functions and hooks, this function
3304 * starts an ATA command. ATA commands are grouped into
3305 * classes called "protocols", and issuing each type of protocol
3306 * is slightly different.
3307 *
Edward Falk0baab862005-06-02 18:17:13 -04003308 * May be used as the qc_issue() entry in ata_port_operations.
3309 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07003310 * LOCKING:
3311 * spin_lock_irqsave(host_set lock)
3312 *
3313 * RETURNS:
3314 * Zero on success, negative on error.
3315 */
3316
3317int ata_qc_issue_prot(struct ata_queued_cmd *qc)
3318{
3319 struct ata_port *ap = qc->ap;
3320
3321 ata_dev_select(ap, qc->dev->devno, 1, 0);
3322
3323 switch (qc->tf.protocol) {
3324 case ATA_PROT_NODATA:
3325 ata_tf_to_host_nolock(ap, &qc->tf);
3326 break;
3327
3328 case ATA_PROT_DMA:
3329 ap->ops->tf_load(ap, &qc->tf); /* load tf registers */
3330 ap->ops->bmdma_setup(qc); /* set up bmdma */
3331 ap->ops->bmdma_start(qc); /* initiate bmdma */
3332 break;
3333
3334 case ATA_PROT_PIO: /* load tf registers, initiate polling pio */
3335 ata_qc_set_polling(qc);
3336 ata_tf_to_host_nolock(ap, &qc->tf);
3337 ap->pio_task_state = PIO_ST;
3338 queue_work(ata_wq, &ap->pio_task);
3339 break;
3340
3341 case ATA_PROT_ATAPI:
3342 ata_qc_set_polling(qc);
3343 ata_tf_to_host_nolock(ap, &qc->tf);
3344 queue_work(ata_wq, &ap->packet_task);
3345 break;
3346
3347 case ATA_PROT_ATAPI_NODATA:
3348 ata_tf_to_host_nolock(ap, &qc->tf);
3349 queue_work(ata_wq, &ap->packet_task);
3350 break;
3351
3352 case ATA_PROT_ATAPI_DMA:
3353 ap->ops->tf_load(ap, &qc->tf); /* load tf registers */
3354 ap->ops->bmdma_setup(qc); /* set up bmdma */
3355 queue_work(ata_wq, &ap->packet_task);
3356 break;
3357
3358 default:
3359 WARN_ON(1);
3360 return -1;
3361 }
3362
3363 return 0;
3364}
3365
3366/**
Edward Falk0baab862005-06-02 18:17:13 -04003367 * ata_bmdma_setup_mmio - Set up PCI IDE BMDMA transaction
Linus Torvalds1da177e2005-04-16 15:20:36 -07003368 * @qc: Info associated with this ATA transaction.
3369 *
3370 * LOCKING:
3371 * spin_lock_irqsave(host_set lock)
3372 */
3373
3374static void ata_bmdma_setup_mmio (struct ata_queued_cmd *qc)
3375{
3376 struct ata_port *ap = qc->ap;
3377 unsigned int rw = (qc->tf.flags & ATA_TFLAG_WRITE);
3378 u8 dmactl;
3379 void __iomem *mmio = (void __iomem *) ap->ioaddr.bmdma_addr;
3380
3381 /* load PRD table addr. */
3382 mb(); /* make sure PRD table writes are visible to controller */
3383 writel(ap->prd_dma, mmio + ATA_DMA_TABLE_OFS);
3384
3385 /* specify data direction, triple-check start bit is clear */
3386 dmactl = readb(mmio + ATA_DMA_CMD);
3387 dmactl &= ~(ATA_DMA_WR | ATA_DMA_START);
3388 if (!rw)
3389 dmactl |= ATA_DMA_WR;
3390 writeb(dmactl, mmio + ATA_DMA_CMD);
3391
3392 /* issue r/w command */
3393 ap->ops->exec_command(ap, &qc->tf);
3394}
3395
3396/**
3397 * ata_bmdma_start - Start a PCI IDE BMDMA transaction
3398 * @qc: Info associated with this ATA transaction.
3399 *
3400 * LOCKING:
3401 * spin_lock_irqsave(host_set lock)
3402 */
3403
3404static void ata_bmdma_start_mmio (struct ata_queued_cmd *qc)
3405{
3406 struct ata_port *ap = qc->ap;
3407 void __iomem *mmio = (void __iomem *) ap->ioaddr.bmdma_addr;
3408 u8 dmactl;
3409
3410 /* start host DMA transaction */
3411 dmactl = readb(mmio + ATA_DMA_CMD);
3412 writeb(dmactl | ATA_DMA_START, mmio + ATA_DMA_CMD);
3413
3414 /* Strictly, one may wish to issue a readb() here, to
3415 * flush the mmio write. However, control also passes
3416 * to the hardware at this point, and it will interrupt
3417 * us when we are to resume control. So, in effect,
3418 * we don't care when the mmio write flushes.
3419 * Further, a read of the DMA status register _immediately_
3420 * following the write may not be what certain flaky hardware
3421 * is expected, so I think it is best to not add a readb()
3422 * without first all the MMIO ATA cards/mobos.
3423 * Or maybe I'm just being paranoid.
3424 */
3425}
3426
3427/**
3428 * ata_bmdma_setup_pio - Set up PCI IDE BMDMA transaction (PIO)
3429 * @qc: Info associated with this ATA transaction.
3430 *
3431 * LOCKING:
3432 * spin_lock_irqsave(host_set lock)
3433 */
3434
3435static void ata_bmdma_setup_pio (struct ata_queued_cmd *qc)
3436{
3437 struct ata_port *ap = qc->ap;
3438 unsigned int rw = (qc->tf.flags & ATA_TFLAG_WRITE);
3439 u8 dmactl;
3440
3441 /* load PRD table addr. */
3442 outl(ap->prd_dma, ap->ioaddr.bmdma_addr + ATA_DMA_TABLE_OFS);
3443
3444 /* specify data direction, triple-check start bit is clear */
3445 dmactl = inb(ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
3446 dmactl &= ~(ATA_DMA_WR | ATA_DMA_START);
3447 if (!rw)
3448 dmactl |= ATA_DMA_WR;
3449 outb(dmactl, ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
3450
3451 /* issue r/w command */
3452 ap->ops->exec_command(ap, &qc->tf);
3453}
3454
3455/**
3456 * ata_bmdma_start_pio - Start a PCI IDE BMDMA transaction (PIO)
3457 * @qc: Info associated with this ATA transaction.
3458 *
3459 * LOCKING:
3460 * spin_lock_irqsave(host_set lock)
3461 */
3462
3463static void ata_bmdma_start_pio (struct ata_queued_cmd *qc)
3464{
3465 struct ata_port *ap = qc->ap;
3466 u8 dmactl;
3467
3468 /* start host DMA transaction */
3469 dmactl = inb(ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
3470 outb(dmactl | ATA_DMA_START,
3471 ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
3472}
3473
Edward Falk0baab862005-06-02 18:17:13 -04003474
3475/**
3476 * ata_bmdma_start - Start a PCI IDE BMDMA transaction
3477 * @qc: Info associated with this ATA transaction.
3478 *
3479 * Writes the ATA_DMA_START flag to the DMA command register.
3480 *
3481 * May be used as the bmdma_start() entry in ata_port_operations.
3482 *
3483 * LOCKING:
3484 * spin_lock_irqsave(host_set lock)
3485 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003486void ata_bmdma_start(struct ata_queued_cmd *qc)
3487{
3488 if (qc->ap->flags & ATA_FLAG_MMIO)
3489 ata_bmdma_start_mmio(qc);
3490 else
3491 ata_bmdma_start_pio(qc);
3492}
3493
Edward Falk0baab862005-06-02 18:17:13 -04003494
3495/**
3496 * ata_bmdma_setup - Set up PCI IDE BMDMA transaction
3497 * @qc: Info associated with this ATA transaction.
3498 *
3499 * Writes address of PRD table to device's PRD Table Address
3500 * register, sets the DMA control register, and calls
3501 * ops->exec_command() to start the transfer.
3502 *
3503 * May be used as the bmdma_setup() entry in ata_port_operations.
3504 *
3505 * LOCKING:
3506 * spin_lock_irqsave(host_set lock)
3507 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003508void ata_bmdma_setup(struct ata_queued_cmd *qc)
3509{
3510 if (qc->ap->flags & ATA_FLAG_MMIO)
3511 ata_bmdma_setup_mmio(qc);
3512 else
3513 ata_bmdma_setup_pio(qc);
3514}
3515
Edward Falk0baab862005-06-02 18:17:13 -04003516
3517/**
3518 * ata_bmdma_irq_clear - Clear PCI IDE BMDMA interrupt.
Jeff Garzikdecc6d02005-06-02 18:42:33 -04003519 * @ap: Port associated with this ATA transaction.
Edward Falk0baab862005-06-02 18:17:13 -04003520 *
3521 * Clear interrupt and error flags in DMA status register.
3522 *
3523 * May be used as the irq_clear() entry in ata_port_operations.
3524 *
3525 * LOCKING:
3526 * spin_lock_irqsave(host_set lock)
3527 */
3528
Linus Torvalds1da177e2005-04-16 15:20:36 -07003529void ata_bmdma_irq_clear(struct ata_port *ap)
3530{
3531 if (ap->flags & ATA_FLAG_MMIO) {
3532 void __iomem *mmio = ((void __iomem *) ap->ioaddr.bmdma_addr) + ATA_DMA_STATUS;
3533 writeb(readb(mmio), mmio);
3534 } else {
3535 unsigned long addr = ap->ioaddr.bmdma_addr + ATA_DMA_STATUS;
3536 outb(inb(addr), addr);
3537 }
3538
3539}
3540
Edward Falk0baab862005-06-02 18:17:13 -04003541
3542/**
3543 * ata_bmdma_status - Read PCI IDE BMDMA status
Jeff Garzikdecc6d02005-06-02 18:42:33 -04003544 * @ap: Port associated with this ATA transaction.
Edward Falk0baab862005-06-02 18:17:13 -04003545 *
3546 * Read and return BMDMA status register.
3547 *
3548 * May be used as the bmdma_status() entry in ata_port_operations.
3549 *
3550 * LOCKING:
3551 * spin_lock_irqsave(host_set lock)
3552 */
3553
Linus Torvalds1da177e2005-04-16 15:20:36 -07003554u8 ata_bmdma_status(struct ata_port *ap)
3555{
3556 u8 host_stat;
3557 if (ap->flags & ATA_FLAG_MMIO) {
3558 void __iomem *mmio = (void __iomem *) ap->ioaddr.bmdma_addr;
3559 host_stat = readb(mmio + ATA_DMA_STATUS);
3560 } else
3561 host_stat = inb(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
3562 return host_stat;
3563}
3564
Edward Falk0baab862005-06-02 18:17:13 -04003565
3566/**
3567 * ata_bmdma_stop - Stop PCI IDE BMDMA transfer
Jeff Garzikdecc6d02005-06-02 18:42:33 -04003568 * @ap: Port associated with this ATA transaction.
Edward Falk0baab862005-06-02 18:17:13 -04003569 *
3570 * Clears the ATA_DMA_START flag in the dma control register
3571 *
3572 * May be used as the bmdma_stop() entry in ata_port_operations.
3573 *
3574 * LOCKING:
3575 * spin_lock_irqsave(host_set lock)
3576 */
3577
Linus Torvalds1da177e2005-04-16 15:20:36 -07003578void ata_bmdma_stop(struct ata_port *ap)
3579{
3580 if (ap->flags & ATA_FLAG_MMIO) {
3581 void __iomem *mmio = (void __iomem *) ap->ioaddr.bmdma_addr;
3582
3583 /* clear start/stop bit */
3584 writeb(readb(mmio + ATA_DMA_CMD) & ~ATA_DMA_START,
3585 mmio + ATA_DMA_CMD);
3586 } else {
3587 /* clear start/stop bit */
3588 outb(inb(ap->ioaddr.bmdma_addr + ATA_DMA_CMD) & ~ATA_DMA_START,
3589 ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
3590 }
3591
3592 /* one-PIO-cycle guaranteed wait, per spec, for HDMA1:0 transition */
3593 ata_altstatus(ap); /* dummy read */
3594}
3595
3596/**
3597 * ata_host_intr - Handle host interrupt for given (port, task)
3598 * @ap: Port on which interrupt arrived (possibly...)
3599 * @qc: Taskfile currently active in engine
3600 *
3601 * Handle host interrupt for given queued command. Currently,
3602 * only DMA interrupts are handled. All other commands are
3603 * handled via polling with interrupts disabled (nIEN bit).
3604 *
3605 * LOCKING:
3606 * spin_lock_irqsave(host_set lock)
3607 *
3608 * RETURNS:
3609 * One if interrupt was handled, zero if not (shared irq).
3610 */
3611
3612inline unsigned int ata_host_intr (struct ata_port *ap,
3613 struct ata_queued_cmd *qc)
3614{
3615 u8 status, host_stat;
3616
3617 switch (qc->tf.protocol) {
3618
3619 case ATA_PROT_DMA:
3620 case ATA_PROT_ATAPI_DMA:
3621 case ATA_PROT_ATAPI:
3622 /* check status of DMA engine */
3623 host_stat = ap->ops->bmdma_status(ap);
3624 VPRINTK("ata%u: host_stat 0x%X\n", ap->id, host_stat);
3625
3626 /* if it's not our irq... */
3627 if (!(host_stat & ATA_DMA_INTR))
3628 goto idle_irq;
3629
3630 /* before we do anything else, clear DMA-Start bit */
3631 ap->ops->bmdma_stop(ap);
3632
3633 /* fall through */
3634
3635 case ATA_PROT_ATAPI_NODATA:
3636 case ATA_PROT_NODATA:
3637 /* check altstatus */
3638 status = ata_altstatus(ap);
3639 if (status & ATA_BUSY)
3640 goto idle_irq;
3641
3642 /* check main status, clearing INTRQ */
3643 status = ata_chk_status(ap);
3644 if (unlikely(status & ATA_BUSY))
3645 goto idle_irq;
3646 DPRINTK("ata%u: protocol %d (dev_stat 0x%X)\n",
3647 ap->id, qc->tf.protocol, status);
3648
3649 /* ack bmdma irq events */
3650 ap->ops->irq_clear(ap);
3651
3652 /* complete taskfile transaction */
3653 ata_qc_complete(qc, status);
3654 break;
3655
3656 default:
3657 goto idle_irq;
3658 }
3659
3660 return 1; /* irq handled */
3661
3662idle_irq:
3663 ap->stats.idle_irq++;
3664
3665#ifdef ATA_IRQ_TRAP
3666 if ((ap->stats.idle_irq % 1000) == 0) {
3667 handled = 1;
3668 ata_irq_ack(ap, 0); /* debug trap */
3669 printk(KERN_WARNING "ata%d: irq trap\n", ap->id);
3670 }
3671#endif
3672 return 0; /* irq not handled */
3673}
3674
3675/**
3676 * ata_interrupt - Default ATA host interrupt handler
Jeff Garzik0cba6322005-05-30 19:49:12 -04003677 * @irq: irq line (unused)
3678 * @dev_instance: pointer to our ata_host_set information structure
Linus Torvalds1da177e2005-04-16 15:20:36 -07003679 * @regs: unused
3680 *
Jeff Garzik0cba6322005-05-30 19:49:12 -04003681 * Default interrupt handler for PCI IDE devices. Calls
3682 * ata_host_intr() for each port that is not disabled.
3683 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07003684 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04003685 * Obtains host_set lock during operation.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003686 *
3687 * RETURNS:
Jeff Garzik0cba6322005-05-30 19:49:12 -04003688 * IRQ_NONE or IRQ_HANDLED.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003689 *
3690 */
3691
3692irqreturn_t ata_interrupt (int irq, void *dev_instance, struct pt_regs *regs)
3693{
3694 struct ata_host_set *host_set = dev_instance;
3695 unsigned int i;
3696 unsigned int handled = 0;
3697 unsigned long flags;
3698
3699 /* TODO: make _irqsave conditional on x86 PCI IDE legacy mode */
3700 spin_lock_irqsave(&host_set->lock, flags);
3701
3702 for (i = 0; i < host_set->n_ports; i++) {
3703 struct ata_port *ap;
3704
3705 ap = host_set->ports[i];
3706 if (ap && (!(ap->flags & ATA_FLAG_PORT_DISABLED))) {
3707 struct ata_queued_cmd *qc;
3708
3709 qc = ata_qc_from_tag(ap, ap->active_tag);
Albert Lee21b1ed72005-04-29 17:34:59 +08003710 if (qc && (!(qc->tf.ctl & ATA_NIEN)) &&
3711 (qc->flags & ATA_QCFLAG_ACTIVE))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003712 handled |= ata_host_intr(ap, qc);
3713 }
3714 }
3715
3716 spin_unlock_irqrestore(&host_set->lock, flags);
3717
3718 return IRQ_RETVAL(handled);
3719}
3720
3721/**
3722 * atapi_packet_task - Write CDB bytes to hardware
3723 * @_data: Port to which ATAPI device is attached.
3724 *
3725 * When device has indicated its readiness to accept
3726 * a CDB, this function is called. Send the CDB.
3727 * If DMA is to be performed, exit immediately.
3728 * Otherwise, we are in polling mode, so poll
3729 * status under operation succeeds or fails.
3730 *
3731 * LOCKING:
3732 * Kernel thread context (may sleep)
3733 */
3734
3735static void atapi_packet_task(void *_data)
3736{
3737 struct ata_port *ap = _data;
3738 struct ata_queued_cmd *qc;
3739 u8 status;
3740
3741 qc = ata_qc_from_tag(ap, ap->active_tag);
3742 assert(qc != NULL);
3743 assert(qc->flags & ATA_QCFLAG_ACTIVE);
3744
3745 /* sleep-wait for BSY to clear */
3746 DPRINTK("busy wait\n");
3747 if (ata_busy_sleep(ap, ATA_TMOUT_CDB_QUICK, ATA_TMOUT_CDB))
3748 goto err_out;
3749
3750 /* make sure DRQ is set */
3751 status = ata_chk_status(ap);
3752 if ((status & (ATA_BUSY | ATA_DRQ)) != ATA_DRQ)
3753 goto err_out;
3754
3755 /* send SCSI cdb */
3756 DPRINTK("send cdb\n");
3757 assert(ap->cdb_len >= 12);
3758 ata_data_xfer(ap, qc->cdb, ap->cdb_len, 1);
3759
3760 /* if we are DMA'ing, irq handler takes over from here */
3761 if (qc->tf.protocol == ATA_PROT_ATAPI_DMA)
3762 ap->ops->bmdma_start(qc); /* initiate bmdma */
3763
3764 /* non-data commands are also handled via irq */
3765 else if (qc->tf.protocol == ATA_PROT_ATAPI_NODATA) {
3766 /* do nothing */
3767 }
3768
3769 /* PIO commands are handled by polling */
3770 else {
3771 ap->pio_task_state = PIO_ST;
3772 queue_work(ata_wq, &ap->pio_task);
3773 }
3774
3775 return;
3776
3777err_out:
3778 ata_qc_complete(qc, ATA_ERR);
3779}
3780
Edward Falk0baab862005-06-02 18:17:13 -04003781
3782/**
3783 * ata_port_start - Set port up for dma.
3784 * @ap: Port to initialize
3785 *
3786 * Called just after data structures for each port are
3787 * initialized. Allocates space for PRD table.
3788 *
3789 * May be used as the port_start() entry in ata_port_operations.
3790 *
3791 * LOCKING:
3792 */
3793
Linus Torvalds1da177e2005-04-16 15:20:36 -07003794int ata_port_start (struct ata_port *ap)
3795{
3796 struct device *dev = ap->host_set->dev;
3797
3798 ap->prd = dma_alloc_coherent(dev, ATA_PRD_TBL_SZ, &ap->prd_dma, GFP_KERNEL);
3799 if (!ap->prd)
3800 return -ENOMEM;
3801
3802 DPRINTK("prd alloc, virt %p, dma %llx\n", ap->prd, (unsigned long long) ap->prd_dma);
3803
3804 return 0;
3805}
3806
Edward Falk0baab862005-06-02 18:17:13 -04003807
3808/**
3809 * ata_port_stop - Undo ata_port_start()
3810 * @ap: Port to shut down
3811 *
3812 * Frees the PRD table.
3813 *
3814 * May be used as the port_stop() entry in ata_port_operations.
3815 *
3816 * LOCKING:
3817 */
3818
Linus Torvalds1da177e2005-04-16 15:20:36 -07003819void ata_port_stop (struct ata_port *ap)
3820{
3821 struct device *dev = ap->host_set->dev;
3822
3823 dma_free_coherent(dev, ATA_PRD_TBL_SZ, ap->prd, ap->prd_dma);
3824}
3825
Jeff Garzikaa8f0dc2005-05-26 21:54:27 -04003826void ata_host_stop (struct ata_host_set *host_set)
3827{
3828 if (host_set->mmio_base)
3829 iounmap(host_set->mmio_base);
3830}
3831
3832
Linus Torvalds1da177e2005-04-16 15:20:36 -07003833/**
3834 * ata_host_remove - Unregister SCSI host structure with upper layers
3835 * @ap: Port to unregister
3836 * @do_unregister: 1 if we fully unregister, 0 to just stop the port
3837 *
3838 * LOCKING:
3839 */
3840
3841static void ata_host_remove(struct ata_port *ap, unsigned int do_unregister)
3842{
3843 struct Scsi_Host *sh = ap->host;
3844
3845 DPRINTK("ENTER\n");
3846
3847 if (do_unregister)
3848 scsi_remove_host(sh);
3849
3850 ap->ops->port_stop(ap);
3851}
3852
3853/**
3854 * ata_host_init - Initialize an ata_port structure
3855 * @ap: Structure to initialize
3856 * @host: associated SCSI mid-layer structure
3857 * @host_set: Collection of hosts to which @ap belongs
3858 * @ent: Probe information provided by low-level driver
3859 * @port_no: Port number associated with this ata_port
3860 *
Jeff Garzik0cba6322005-05-30 19:49:12 -04003861 * Initialize a new ata_port structure, and its associated
3862 * scsi_host.
3863 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07003864 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04003865 * Inherited from caller.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003866 *
3867 */
3868
3869static void ata_host_init(struct ata_port *ap, struct Scsi_Host *host,
3870 struct ata_host_set *host_set,
3871 struct ata_probe_ent *ent, unsigned int port_no)
3872{
3873 unsigned int i;
3874
3875 host->max_id = 16;
3876 host->max_lun = 1;
3877 host->max_channel = 1;
3878 host->unique_id = ata_unique_id++;
3879 host->max_cmd_len = 12;
Christoph Hellwig12413192005-06-11 01:05:01 +02003880
Linus Torvalds1da177e2005-04-16 15:20:36 -07003881 scsi_assign_lock(host, &host_set->lock);
3882
3883 ap->flags = ATA_FLAG_PORT_DISABLED;
3884 ap->id = host->unique_id;
3885 ap->host = host;
3886 ap->ctl = ATA_DEVCTL_OBS;
3887 ap->host_set = host_set;
3888 ap->port_no = port_no;
3889 ap->hard_port_no =
3890 ent->legacy_mode ? ent->hard_port_no : port_no;
3891 ap->pio_mask = ent->pio_mask;
3892 ap->mwdma_mask = ent->mwdma_mask;
3893 ap->udma_mask = ent->udma_mask;
3894 ap->flags |= ent->host_flags;
3895 ap->ops = ent->port_ops;
3896 ap->cbl = ATA_CBL_NONE;
3897 ap->active_tag = ATA_TAG_POISON;
3898 ap->last_ctl = 0xFF;
3899
3900 INIT_WORK(&ap->packet_task, atapi_packet_task, ap);
3901 INIT_WORK(&ap->pio_task, ata_pio_task, ap);
3902
3903 for (i = 0; i < ATA_MAX_DEVICES; i++)
3904 ap->device[i].devno = i;
3905
3906#ifdef ATA_IRQ_TRAP
3907 ap->stats.unhandled_irq = 1;
3908 ap->stats.idle_irq = 1;
3909#endif
3910
3911 memcpy(&ap->ioaddr, &ent->port[port_no], sizeof(struct ata_ioports));
3912}
3913
3914/**
3915 * ata_host_add - Attach low-level ATA driver to system
3916 * @ent: Information provided by low-level driver
3917 * @host_set: Collections of ports to which we add
3918 * @port_no: Port number associated with this host
3919 *
Jeff Garzik0cba6322005-05-30 19:49:12 -04003920 * Attach low-level ATA driver to system.
3921 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07003922 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04003923 * PCI/etc. bus probe sem.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003924 *
3925 * RETURNS:
Jeff Garzik0cba6322005-05-30 19:49:12 -04003926 * New ata_port on success, for NULL on error.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003927 *
3928 */
3929
3930static struct ata_port * ata_host_add(struct ata_probe_ent *ent,
3931 struct ata_host_set *host_set,
3932 unsigned int port_no)
3933{
3934 struct Scsi_Host *host;
3935 struct ata_port *ap;
3936 int rc;
3937
3938 DPRINTK("ENTER\n");
3939 host = scsi_host_alloc(ent->sht, sizeof(struct ata_port));
3940 if (!host)
3941 return NULL;
3942
3943 ap = (struct ata_port *) &host->hostdata[0];
3944
3945 ata_host_init(ap, host, host_set, ent, port_no);
3946
3947 rc = ap->ops->port_start(ap);
3948 if (rc)
3949 goto err_out;
3950
3951 return ap;
3952
3953err_out:
3954 scsi_host_put(host);
3955 return NULL;
3956}
3957
3958/**
Jeff Garzik0cba6322005-05-30 19:49:12 -04003959 * ata_device_add - Register hardware device with ATA and SCSI layers
3960 * @ent: Probe information describing hardware device to be registered
3961 *
3962 * This function processes the information provided in the probe
3963 * information struct @ent, allocates the necessary ATA and SCSI
3964 * host information structures, initializes them, and registers
3965 * everything with requisite kernel subsystems.
3966 *
3967 * This function requests irqs, probes the ATA bus, and probes
3968 * the SCSI bus.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003969 *
3970 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04003971 * PCI/etc. bus probe sem.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003972 *
3973 * RETURNS:
Jeff Garzik0cba6322005-05-30 19:49:12 -04003974 * Number of ports registered. Zero on error (no ports registered).
Linus Torvalds1da177e2005-04-16 15:20:36 -07003975 *
3976 */
3977
3978int ata_device_add(struct ata_probe_ent *ent)
3979{
3980 unsigned int count = 0, i;
3981 struct device *dev = ent->dev;
3982 struct ata_host_set *host_set;
3983
3984 DPRINTK("ENTER\n");
3985 /* alloc a container for our list of ATA ports (buses) */
3986 host_set = kmalloc(sizeof(struct ata_host_set) +
3987 (ent->n_ports * sizeof(void *)), GFP_KERNEL);
3988 if (!host_set)
3989 return 0;
3990 memset(host_set, 0, sizeof(struct ata_host_set) + (ent->n_ports * sizeof(void *)));
3991 spin_lock_init(&host_set->lock);
3992
3993 host_set->dev = dev;
3994 host_set->n_ports = ent->n_ports;
3995 host_set->irq = ent->irq;
3996 host_set->mmio_base = ent->mmio_base;
3997 host_set->private_data = ent->private_data;
3998 host_set->ops = ent->port_ops;
3999
4000 /* register each port bound to this device */
4001 for (i = 0; i < ent->n_ports; i++) {
4002 struct ata_port *ap;
4003 unsigned long xfer_mode_mask;
4004
4005 ap = ata_host_add(ent, host_set, i);
4006 if (!ap)
4007 goto err_out;
4008
4009 host_set->ports[i] = ap;
4010 xfer_mode_mask =(ap->udma_mask << ATA_SHIFT_UDMA) |
4011 (ap->mwdma_mask << ATA_SHIFT_MWDMA) |
4012 (ap->pio_mask << ATA_SHIFT_PIO);
4013
4014 /* print per-port info to dmesg */
4015 printk(KERN_INFO "ata%u: %cATA max %s cmd 0x%lX ctl 0x%lX "
4016 "bmdma 0x%lX irq %lu\n",
4017 ap->id,
4018 ap->flags & ATA_FLAG_SATA ? 'S' : 'P',
4019 ata_mode_string(xfer_mode_mask),
4020 ap->ioaddr.cmd_addr,
4021 ap->ioaddr.ctl_addr,
4022 ap->ioaddr.bmdma_addr,
4023 ent->irq);
4024
4025 ata_chk_status(ap);
4026 host_set->ops->irq_clear(ap);
4027 count++;
4028 }
4029
4030 if (!count) {
4031 kfree(host_set);
4032 return 0;
4033 }
4034
4035 /* obtain irq, that is shared between channels */
4036 if (request_irq(ent->irq, ent->port_ops->irq_handler, ent->irq_flags,
4037 DRV_NAME, host_set))
4038 goto err_out;
4039
4040 /* perform each probe synchronously */
4041 DPRINTK("probe begin\n");
4042 for (i = 0; i < count; i++) {
4043 struct ata_port *ap;
4044 int rc;
4045
4046 ap = host_set->ports[i];
4047
4048 DPRINTK("ata%u: probe begin\n", ap->id);
4049 rc = ata_bus_probe(ap);
4050 DPRINTK("ata%u: probe end\n", ap->id);
4051
4052 if (rc) {
4053 /* FIXME: do something useful here?
4054 * Current libata behavior will
4055 * tear down everything when
4056 * the module is removed
4057 * or the h/w is unplugged.
4058 */
4059 }
4060
4061 rc = scsi_add_host(ap->host, dev);
4062 if (rc) {
4063 printk(KERN_ERR "ata%u: scsi_add_host failed\n",
4064 ap->id);
4065 /* FIXME: do something useful here */
4066 /* FIXME: handle unconditional calls to
4067 * scsi_scan_host and ata_host_remove, below,
4068 * at the very least
4069 */
4070 }
4071 }
4072
4073 /* probes are done, now scan each port's disk(s) */
4074 DPRINTK("probe begin\n");
4075 for (i = 0; i < count; i++) {
4076 struct ata_port *ap = host_set->ports[i];
4077
4078 scsi_scan_host(ap->host);
4079 }
4080
4081 dev_set_drvdata(dev, host_set);
4082
4083 VPRINTK("EXIT, returning %u\n", ent->n_ports);
4084 return ent->n_ports; /* success */
4085
4086err_out:
4087 for (i = 0; i < count; i++) {
4088 ata_host_remove(host_set->ports[i], 1);
4089 scsi_host_put(host_set->ports[i]->host);
4090 }
4091 kfree(host_set);
4092 VPRINTK("EXIT, returning 0\n");
4093 return 0;
4094}
4095
4096/**
4097 * ata_scsi_release - SCSI layer callback hook for host unload
4098 * @host: libata host to be unloaded
4099 *
4100 * Performs all duties necessary to shut down a libata port...
4101 * Kill port kthread, disable port, and release resources.
4102 *
4103 * LOCKING:
4104 * Inherited from SCSI layer.
4105 *
4106 * RETURNS:
4107 * One.
4108 */
4109
4110int ata_scsi_release(struct Scsi_Host *host)
4111{
4112 struct ata_port *ap = (struct ata_port *) &host->hostdata[0];
4113
4114 DPRINTK("ENTER\n");
4115
4116 ap->ops->port_disable(ap);
4117 ata_host_remove(ap, 0);
4118
4119 DPRINTK("EXIT\n");
4120 return 1;
4121}
4122
4123/**
4124 * ata_std_ports - initialize ioaddr with standard port offsets.
4125 * @ioaddr: IO address structure to be initialized
Edward Falk0baab862005-06-02 18:17:13 -04004126 *
4127 * Utility function which initializes data_addr, error_addr,
4128 * feature_addr, nsect_addr, lbal_addr, lbam_addr, lbah_addr,
4129 * device_addr, status_addr, and command_addr to standard offsets
4130 * relative to cmd_addr.
4131 *
4132 * Does not set ctl_addr, altstatus_addr, bmdma_addr, or scr_addr.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004133 */
Edward Falk0baab862005-06-02 18:17:13 -04004134
Linus Torvalds1da177e2005-04-16 15:20:36 -07004135void ata_std_ports(struct ata_ioports *ioaddr)
4136{
4137 ioaddr->data_addr = ioaddr->cmd_addr + ATA_REG_DATA;
4138 ioaddr->error_addr = ioaddr->cmd_addr + ATA_REG_ERR;
4139 ioaddr->feature_addr = ioaddr->cmd_addr + ATA_REG_FEATURE;
4140 ioaddr->nsect_addr = ioaddr->cmd_addr + ATA_REG_NSECT;
4141 ioaddr->lbal_addr = ioaddr->cmd_addr + ATA_REG_LBAL;
4142 ioaddr->lbam_addr = ioaddr->cmd_addr + ATA_REG_LBAM;
4143 ioaddr->lbah_addr = ioaddr->cmd_addr + ATA_REG_LBAH;
4144 ioaddr->device_addr = ioaddr->cmd_addr + ATA_REG_DEVICE;
4145 ioaddr->status_addr = ioaddr->cmd_addr + ATA_REG_STATUS;
4146 ioaddr->command_addr = ioaddr->cmd_addr + ATA_REG_CMD;
4147}
4148
4149static struct ata_probe_ent *
4150ata_probe_ent_alloc(struct device *dev, struct ata_port_info *port)
4151{
4152 struct ata_probe_ent *probe_ent;
4153
4154 probe_ent = kmalloc(sizeof(*probe_ent), GFP_KERNEL);
4155 if (!probe_ent) {
4156 printk(KERN_ERR DRV_NAME "(%s): out of memory\n",
4157 kobject_name(&(dev->kobj)));
4158 return NULL;
4159 }
4160
4161 memset(probe_ent, 0, sizeof(*probe_ent));
4162
4163 INIT_LIST_HEAD(&probe_ent->node);
4164 probe_ent->dev = dev;
4165
4166 probe_ent->sht = port->sht;
4167 probe_ent->host_flags = port->host_flags;
4168 probe_ent->pio_mask = port->pio_mask;
4169 probe_ent->mwdma_mask = port->mwdma_mask;
4170 probe_ent->udma_mask = port->udma_mask;
4171 probe_ent->port_ops = port->port_ops;
4172
4173 return probe_ent;
4174}
4175
Edward Falk0baab862005-06-02 18:17:13 -04004176
4177
4178/**
4179 * ata_pci_init_native_mode - Initialize native-mode driver
4180 * @pdev: pci device to be initialized
4181 * @port: array[2] of pointers to port info structures.
4182 *
4183 * Utility function which allocates and initializes an
4184 * ata_probe_ent structure for a standard dual-port
4185 * PIO-based IDE controller. The returned ata_probe_ent
4186 * structure can be passed to ata_device_add(). The returned
4187 * ata_probe_ent structure should then be freed with kfree().
4188 */
4189
Linus Torvalds1da177e2005-04-16 15:20:36 -07004190#ifdef CONFIG_PCI
4191struct ata_probe_ent *
4192ata_pci_init_native_mode(struct pci_dev *pdev, struct ata_port_info **port)
4193{
4194 struct ata_probe_ent *probe_ent =
4195 ata_probe_ent_alloc(pci_dev_to_dev(pdev), port[0]);
4196 if (!probe_ent)
4197 return NULL;
4198
4199 probe_ent->n_ports = 2;
4200 probe_ent->irq = pdev->irq;
4201 probe_ent->irq_flags = SA_SHIRQ;
4202
4203 probe_ent->port[0].cmd_addr = pci_resource_start(pdev, 0);
4204 probe_ent->port[0].altstatus_addr =
4205 probe_ent->port[0].ctl_addr =
4206 pci_resource_start(pdev, 1) | ATA_PCI_CTL_OFS;
4207 probe_ent->port[0].bmdma_addr = pci_resource_start(pdev, 4);
4208
4209 probe_ent->port[1].cmd_addr = pci_resource_start(pdev, 2);
4210 probe_ent->port[1].altstatus_addr =
4211 probe_ent->port[1].ctl_addr =
4212 pci_resource_start(pdev, 3) | ATA_PCI_CTL_OFS;
4213 probe_ent->port[1].bmdma_addr = pci_resource_start(pdev, 4) + 8;
4214
4215 ata_std_ports(&probe_ent->port[0]);
4216 ata_std_ports(&probe_ent->port[1]);
4217
4218 return probe_ent;
4219}
4220
4221static struct ata_probe_ent *
4222ata_pci_init_legacy_mode(struct pci_dev *pdev, struct ata_port_info **port,
4223 struct ata_probe_ent **ppe2)
4224{
4225 struct ata_probe_ent *probe_ent, *probe_ent2;
4226
4227 probe_ent = ata_probe_ent_alloc(pci_dev_to_dev(pdev), port[0]);
4228 if (!probe_ent)
4229 return NULL;
4230 probe_ent2 = ata_probe_ent_alloc(pci_dev_to_dev(pdev), port[1]);
4231 if (!probe_ent2) {
4232 kfree(probe_ent);
4233 return NULL;
4234 }
4235
4236 probe_ent->n_ports = 1;
4237 probe_ent->irq = 14;
4238
4239 probe_ent->hard_port_no = 0;
4240 probe_ent->legacy_mode = 1;
4241
4242 probe_ent2->n_ports = 1;
4243 probe_ent2->irq = 15;
4244
4245 probe_ent2->hard_port_no = 1;
4246 probe_ent2->legacy_mode = 1;
4247
4248 probe_ent->port[0].cmd_addr = 0x1f0;
4249 probe_ent->port[0].altstatus_addr =
4250 probe_ent->port[0].ctl_addr = 0x3f6;
4251 probe_ent->port[0].bmdma_addr = pci_resource_start(pdev, 4);
4252
4253 probe_ent2->port[0].cmd_addr = 0x170;
4254 probe_ent2->port[0].altstatus_addr =
4255 probe_ent2->port[0].ctl_addr = 0x376;
4256 probe_ent2->port[0].bmdma_addr = pci_resource_start(pdev, 4)+8;
4257
4258 ata_std_ports(&probe_ent->port[0]);
4259 ata_std_ports(&probe_ent2->port[0]);
4260
4261 *ppe2 = probe_ent2;
4262 return probe_ent;
4263}
4264
4265/**
4266 * ata_pci_init_one - Initialize/register PCI IDE host controller
4267 * @pdev: Controller to be initialized
4268 * @port_info: Information from low-level host driver
4269 * @n_ports: Number of ports attached to host controller
4270 *
Edward Falk0baab862005-06-02 18:17:13 -04004271 * This is a helper function which can be called from a driver's
4272 * xxx_init_one() probe function if the hardware uses traditional
4273 * IDE taskfile registers.
4274 *
4275 * This function calls pci_enable_device(), reserves its register
4276 * regions, sets the dma mask, enables bus master mode, and calls
4277 * ata_device_add()
4278 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07004279 * LOCKING:
4280 * Inherited from PCI layer (may sleep).
4281 *
4282 * RETURNS:
Jeff Garzik0cba6322005-05-30 19:49:12 -04004283 * Zero on success, negative on errno-based value on error.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004284 *
4285 */
4286
4287int ata_pci_init_one (struct pci_dev *pdev, struct ata_port_info **port_info,
4288 unsigned int n_ports)
4289{
4290 struct ata_probe_ent *probe_ent, *probe_ent2 = NULL;
4291 struct ata_port_info *port[2];
4292 u8 tmp8, mask;
4293 unsigned int legacy_mode = 0;
4294 int disable_dev_on_err = 1;
4295 int rc;
4296
4297 DPRINTK("ENTER\n");
4298
4299 port[0] = port_info[0];
4300 if (n_ports > 1)
4301 port[1] = port_info[1];
4302 else
4303 port[1] = port[0];
4304
4305 if ((port[0]->host_flags & ATA_FLAG_NO_LEGACY) == 0
4306 && (pdev->class >> 8) == PCI_CLASS_STORAGE_IDE) {
4307 /* TODO: support transitioning to native mode? */
4308 pci_read_config_byte(pdev, PCI_CLASS_PROG, &tmp8);
4309 mask = (1 << 2) | (1 << 0);
4310 if ((tmp8 & mask) != mask)
4311 legacy_mode = (1 << 3);
4312 }
4313
4314 /* FIXME... */
4315 if ((!legacy_mode) && (n_ports > 1)) {
4316 printk(KERN_ERR "ata: BUG: native mode, n_ports > 1\n");
4317 return -EINVAL;
4318 }
4319
4320 rc = pci_enable_device(pdev);
4321 if (rc)
4322 return rc;
4323
4324 rc = pci_request_regions(pdev, DRV_NAME);
4325 if (rc) {
4326 disable_dev_on_err = 0;
4327 goto err_out;
4328 }
4329
4330 if (legacy_mode) {
4331 if (!request_region(0x1f0, 8, "libata")) {
4332 struct resource *conflict, res;
4333 res.start = 0x1f0;
4334 res.end = 0x1f0 + 8 - 1;
4335 conflict = ____request_resource(&ioport_resource, &res);
4336 if (!strcmp(conflict->name, "libata"))
4337 legacy_mode |= (1 << 0);
4338 else {
4339 disable_dev_on_err = 0;
4340 printk(KERN_WARNING "ata: 0x1f0 IDE port busy\n");
4341 }
4342 } else
4343 legacy_mode |= (1 << 0);
4344
4345 if (!request_region(0x170, 8, "libata")) {
4346 struct resource *conflict, res;
4347 res.start = 0x170;
4348 res.end = 0x170 + 8 - 1;
4349 conflict = ____request_resource(&ioport_resource, &res);
4350 if (!strcmp(conflict->name, "libata"))
4351 legacy_mode |= (1 << 1);
4352 else {
4353 disable_dev_on_err = 0;
4354 printk(KERN_WARNING "ata: 0x170 IDE port busy\n");
4355 }
4356 } else
4357 legacy_mode |= (1 << 1);
4358 }
4359
4360 /* we have legacy mode, but all ports are unavailable */
4361 if (legacy_mode == (1 << 3)) {
4362 rc = -EBUSY;
4363 goto err_out_regions;
4364 }
4365
4366 rc = pci_set_dma_mask(pdev, ATA_DMA_MASK);
4367 if (rc)
4368 goto err_out_regions;
4369 rc = pci_set_consistent_dma_mask(pdev, ATA_DMA_MASK);
4370 if (rc)
4371 goto err_out_regions;
4372
4373 if (legacy_mode) {
4374 probe_ent = ata_pci_init_legacy_mode(pdev, port, &probe_ent2);
4375 } else
4376 probe_ent = ata_pci_init_native_mode(pdev, port);
4377 if (!probe_ent) {
4378 rc = -ENOMEM;
4379 goto err_out_regions;
4380 }
4381
4382 pci_set_master(pdev);
4383
4384 /* FIXME: check ata_device_add return */
4385 if (legacy_mode) {
4386 if (legacy_mode & (1 << 0))
4387 ata_device_add(probe_ent);
4388 if (legacy_mode & (1 << 1))
4389 ata_device_add(probe_ent2);
4390 } else
4391 ata_device_add(probe_ent);
4392
4393 kfree(probe_ent);
4394 kfree(probe_ent2);
4395
4396 return 0;
4397
4398err_out_regions:
4399 if (legacy_mode & (1 << 0))
4400 release_region(0x1f0, 8);
4401 if (legacy_mode & (1 << 1))
4402 release_region(0x170, 8);
4403 pci_release_regions(pdev);
4404err_out:
4405 if (disable_dev_on_err)
4406 pci_disable_device(pdev);
4407 return rc;
4408}
4409
4410/**
4411 * ata_pci_remove_one - PCI layer callback for device removal
4412 * @pdev: PCI device that was removed
4413 *
4414 * PCI layer indicates to libata via this hook that
4415 * hot-unplug or module unload event has occured.
4416 * Handle this by unregistering all objects associated
4417 * with this PCI device. Free those objects. Then finally
4418 * release PCI resources and disable device.
4419 *
4420 * LOCKING:
4421 * Inherited from PCI layer (may sleep).
4422 */
4423
4424void ata_pci_remove_one (struct pci_dev *pdev)
4425{
4426 struct device *dev = pci_dev_to_dev(pdev);
4427 struct ata_host_set *host_set = dev_get_drvdata(dev);
4428 struct ata_port *ap;
4429 unsigned int i;
4430
4431 for (i = 0; i < host_set->n_ports; i++) {
4432 ap = host_set->ports[i];
4433
4434 scsi_remove_host(ap->host);
4435 }
4436
4437 free_irq(host_set->irq, host_set);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004438
4439 for (i = 0; i < host_set->n_ports; i++) {
4440 ap = host_set->ports[i];
4441
4442 ata_scsi_release(ap->host);
4443
4444 if ((ap->flags & ATA_FLAG_NO_LEGACY) == 0) {
4445 struct ata_ioports *ioaddr = &ap->ioaddr;
4446
4447 if (ioaddr->cmd_addr == 0x1f0)
4448 release_region(0x1f0, 8);
4449 else if (ioaddr->cmd_addr == 0x170)
4450 release_region(0x170, 8);
4451 }
4452
4453 scsi_host_put(ap->host);
4454 }
4455
Jeff Garzikaa8f0dc2005-05-26 21:54:27 -04004456 if (host_set->ops->host_stop)
4457 host_set->ops->host_stop(host_set);
4458
Linus Torvalds1da177e2005-04-16 15:20:36 -07004459 kfree(host_set);
4460
4461 pci_release_regions(pdev);
4462 pci_disable_device(pdev);
4463 dev_set_drvdata(dev, NULL);
4464}
4465
4466/* move to PCI subsystem */
4467int pci_test_config_bits(struct pci_dev *pdev, struct pci_bits *bits)
4468{
4469 unsigned long tmp = 0;
4470
4471 switch (bits->width) {
4472 case 1: {
4473 u8 tmp8 = 0;
4474 pci_read_config_byte(pdev, bits->reg, &tmp8);
4475 tmp = tmp8;
4476 break;
4477 }
4478 case 2: {
4479 u16 tmp16 = 0;
4480 pci_read_config_word(pdev, bits->reg, &tmp16);
4481 tmp = tmp16;
4482 break;
4483 }
4484 case 4: {
4485 u32 tmp32 = 0;
4486 pci_read_config_dword(pdev, bits->reg, &tmp32);
4487 tmp = tmp32;
4488 break;
4489 }
4490
4491 default:
4492 return -EINVAL;
4493 }
4494
4495 tmp &= bits->mask;
4496
4497 return (tmp == bits->val) ? 1 : 0;
4498}
4499#endif /* CONFIG_PCI */
4500
4501
Linus Torvalds1da177e2005-04-16 15:20:36 -07004502static int __init ata_init(void)
4503{
4504 ata_wq = create_workqueue("ata");
4505 if (!ata_wq)
4506 return -ENOMEM;
4507
4508 printk(KERN_DEBUG "libata version " DRV_VERSION " loaded.\n");
4509 return 0;
4510}
4511
4512static void __exit ata_exit(void)
4513{
4514 destroy_workqueue(ata_wq);
4515}
4516
4517module_init(ata_init);
4518module_exit(ata_exit);
4519
4520/*
4521 * libata is essentially a library of internal helper functions for
4522 * low-level ATA host controller drivers. As such, the API/ABI is
4523 * likely to change as new drivers are added and updated.
4524 * Do not depend on ABI/API stability.
4525 */
4526
4527EXPORT_SYMBOL_GPL(ata_std_bios_param);
4528EXPORT_SYMBOL_GPL(ata_std_ports);
4529EXPORT_SYMBOL_GPL(ata_device_add);
4530EXPORT_SYMBOL_GPL(ata_sg_init);
4531EXPORT_SYMBOL_GPL(ata_sg_init_one);
4532EXPORT_SYMBOL_GPL(ata_qc_complete);
4533EXPORT_SYMBOL_GPL(ata_qc_issue_prot);
4534EXPORT_SYMBOL_GPL(ata_eng_timeout);
4535EXPORT_SYMBOL_GPL(ata_tf_load);
4536EXPORT_SYMBOL_GPL(ata_tf_read);
4537EXPORT_SYMBOL_GPL(ata_noop_dev_select);
4538EXPORT_SYMBOL_GPL(ata_std_dev_select);
4539EXPORT_SYMBOL_GPL(ata_tf_to_fis);
4540EXPORT_SYMBOL_GPL(ata_tf_from_fis);
4541EXPORT_SYMBOL_GPL(ata_check_status);
4542EXPORT_SYMBOL_GPL(ata_altstatus);
4543EXPORT_SYMBOL_GPL(ata_chk_err);
4544EXPORT_SYMBOL_GPL(ata_exec_command);
4545EXPORT_SYMBOL_GPL(ata_port_start);
4546EXPORT_SYMBOL_GPL(ata_port_stop);
Jeff Garzikaa8f0dc2005-05-26 21:54:27 -04004547EXPORT_SYMBOL_GPL(ata_host_stop);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004548EXPORT_SYMBOL_GPL(ata_interrupt);
4549EXPORT_SYMBOL_GPL(ata_qc_prep);
4550EXPORT_SYMBOL_GPL(ata_bmdma_setup);
4551EXPORT_SYMBOL_GPL(ata_bmdma_start);
4552EXPORT_SYMBOL_GPL(ata_bmdma_irq_clear);
4553EXPORT_SYMBOL_GPL(ata_bmdma_status);
4554EXPORT_SYMBOL_GPL(ata_bmdma_stop);
4555EXPORT_SYMBOL_GPL(ata_port_probe);
4556EXPORT_SYMBOL_GPL(sata_phy_reset);
4557EXPORT_SYMBOL_GPL(__sata_phy_reset);
4558EXPORT_SYMBOL_GPL(ata_bus_reset);
4559EXPORT_SYMBOL_GPL(ata_port_disable);
4560EXPORT_SYMBOL_GPL(ata_scsi_ioctl);
4561EXPORT_SYMBOL_GPL(ata_scsi_queuecmd);
4562EXPORT_SYMBOL_GPL(ata_scsi_error);
4563EXPORT_SYMBOL_GPL(ata_scsi_slave_config);
4564EXPORT_SYMBOL_GPL(ata_scsi_release);
4565EXPORT_SYMBOL_GPL(ata_host_intr);
4566EXPORT_SYMBOL_GPL(ata_dev_classify);
4567EXPORT_SYMBOL_GPL(ata_dev_id_string);
Brad Campbell6f2f3812005-05-12 15:07:47 -04004568EXPORT_SYMBOL_GPL(ata_dev_config);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004569EXPORT_SYMBOL_GPL(ata_scsi_simulate);
4570
4571#ifdef CONFIG_PCI
4572EXPORT_SYMBOL_GPL(pci_test_config_bits);
4573EXPORT_SYMBOL_GPL(ata_pci_init_native_mode);
4574EXPORT_SYMBOL_GPL(ata_pci_init_one);
4575EXPORT_SYMBOL_GPL(ata_pci_remove_one);
4576#endif /* CONFIG_PCI */