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