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