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