libata: convert native PCI host handling to new init model
[safe/jmp/linux-2.6] / drivers / ata / libata-sff.c
1 /*
2  *  libata-bmdma.c - helper library for PCI IDE BMDMA
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-2006 Red Hat, Inc.  All rights reserved.
9  *  Copyright 2003-2006 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/kernel.h>
36 #include <linux/pci.h>
37 #include <linux/libata.h>
38
39 #include "libata.h"
40
41 /**
42  *      ata_irq_on - Enable interrupts on a port.
43  *      @ap: Port on which interrupts are enabled.
44  *
45  *      Enable interrupts on a legacy IDE device using MMIO or PIO,
46  *      wait for idle, clear any pending interrupts.
47  *
48  *      LOCKING:
49  *      Inherited from caller.
50  */
51 u8 ata_irq_on(struct ata_port *ap)
52 {
53         struct ata_ioports *ioaddr = &ap->ioaddr;
54         u8 tmp;
55
56         ap->ctl &= ~ATA_NIEN;
57         ap->last_ctl = ap->ctl;
58
59         iowrite8(ap->ctl, ioaddr->ctl_addr);
60         tmp = ata_wait_idle(ap);
61
62         ap->ops->irq_clear(ap);
63
64         return tmp;
65 }
66
67 u8 ata_dummy_irq_on (struct ata_port *ap)       { return 0; }
68
69 /**
70  *      ata_irq_ack - Acknowledge a device interrupt.
71  *      @ap: Port on which interrupts are enabled.
72  *
73  *      Wait up to 10 ms for legacy IDE device to become idle (BUSY
74  *      or BUSY+DRQ clear).  Obtain dma status and port status from
75  *      device.  Clear the interrupt.  Return port status.
76  *
77  *      LOCKING:
78  */
79
80 u8 ata_irq_ack(struct ata_port *ap, unsigned int chk_drq)
81 {
82         unsigned int bits = chk_drq ? ATA_BUSY | ATA_DRQ : ATA_BUSY;
83         u8 host_stat, post_stat, status;
84
85         status = ata_busy_wait(ap, bits, 1000);
86         if (status & bits)
87                 if (ata_msg_err(ap))
88                         printk(KERN_ERR "abnormal status 0x%X\n", status);
89
90         /* get controller status; clear intr, err bits */
91         host_stat = ioread8(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
92         iowrite8(host_stat | ATA_DMA_INTR | ATA_DMA_ERR,
93                  ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
94
95         post_stat = ioread8(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
96
97         if (ata_msg_intr(ap))
98                 printk(KERN_INFO "%s: irq ack: host_stat 0x%X, new host_stat 0x%X, drv_stat 0x%X\n",
99                         __FUNCTION__,
100                         host_stat, post_stat, status);
101
102         return status;
103 }
104
105 u8 ata_dummy_irq_ack(struct ata_port *ap, unsigned int chk_drq) { return 0; }
106
107 /**
108  *      ata_tf_load - send taskfile registers to host controller
109  *      @ap: Port to which output is sent
110  *      @tf: ATA taskfile register set
111  *
112  *      Outputs ATA taskfile to standard ATA host controller.
113  *
114  *      LOCKING:
115  *      Inherited from caller.
116  */
117
118 void ata_tf_load(struct ata_port *ap, const struct ata_taskfile *tf)
119 {
120         struct ata_ioports *ioaddr = &ap->ioaddr;
121         unsigned int is_addr = tf->flags & ATA_TFLAG_ISADDR;
122
123         if (tf->ctl != ap->last_ctl) {
124                 iowrite8(tf->ctl, ioaddr->ctl_addr);
125                 ap->last_ctl = tf->ctl;
126                 ata_wait_idle(ap);
127         }
128
129         if (is_addr && (tf->flags & ATA_TFLAG_LBA48)) {
130                 iowrite8(tf->hob_feature, ioaddr->feature_addr);
131                 iowrite8(tf->hob_nsect, ioaddr->nsect_addr);
132                 iowrite8(tf->hob_lbal, ioaddr->lbal_addr);
133                 iowrite8(tf->hob_lbam, ioaddr->lbam_addr);
134                 iowrite8(tf->hob_lbah, ioaddr->lbah_addr);
135                 VPRINTK("hob: feat 0x%X nsect 0x%X, lba 0x%X 0x%X 0x%X\n",
136                         tf->hob_feature,
137                         tf->hob_nsect,
138                         tf->hob_lbal,
139                         tf->hob_lbam,
140                         tf->hob_lbah);
141         }
142
143         if (is_addr) {
144                 iowrite8(tf->feature, ioaddr->feature_addr);
145                 iowrite8(tf->nsect, ioaddr->nsect_addr);
146                 iowrite8(tf->lbal, ioaddr->lbal_addr);
147                 iowrite8(tf->lbam, ioaddr->lbam_addr);
148                 iowrite8(tf->lbah, ioaddr->lbah_addr);
149                 VPRINTK("feat 0x%X nsect 0x%X lba 0x%X 0x%X 0x%X\n",
150                         tf->feature,
151                         tf->nsect,
152                         tf->lbal,
153                         tf->lbam,
154                         tf->lbah);
155         }
156
157         if (tf->flags & ATA_TFLAG_DEVICE) {
158                 iowrite8(tf->device, ioaddr->device_addr);
159                 VPRINTK("device 0x%X\n", tf->device);
160         }
161
162         ata_wait_idle(ap);
163 }
164
165 /**
166  *      ata_exec_command - issue ATA command to host controller
167  *      @ap: port to which command is being issued
168  *      @tf: ATA taskfile register set
169  *
170  *      Issues ATA command, with proper synchronization with interrupt
171  *      handler / other threads.
172  *
173  *      LOCKING:
174  *      spin_lock_irqsave(host lock)
175  */
176 void ata_exec_command(struct ata_port *ap, const struct ata_taskfile *tf)
177 {
178         DPRINTK("ata%u: cmd 0x%X\n", ap->print_id, tf->command);
179
180         iowrite8(tf->command, ap->ioaddr.command_addr);
181         ata_pause(ap);
182 }
183
184 /**
185  *      ata_tf_read - input device's ATA taskfile shadow registers
186  *      @ap: Port from which input is read
187  *      @tf: ATA taskfile register set for storing input
188  *
189  *      Reads ATA taskfile registers for currently-selected device
190  *      into @tf.
191  *
192  *      LOCKING:
193  *      Inherited from caller.
194  */
195 void ata_tf_read(struct ata_port *ap, struct ata_taskfile *tf)
196 {
197         struct ata_ioports *ioaddr = &ap->ioaddr;
198
199         tf->command = ata_check_status(ap);
200         tf->feature = ioread8(ioaddr->error_addr);
201         tf->nsect = ioread8(ioaddr->nsect_addr);
202         tf->lbal = ioread8(ioaddr->lbal_addr);
203         tf->lbam = ioread8(ioaddr->lbam_addr);
204         tf->lbah = ioread8(ioaddr->lbah_addr);
205         tf->device = ioread8(ioaddr->device_addr);
206
207         if (tf->flags & ATA_TFLAG_LBA48) {
208                 iowrite8(tf->ctl | ATA_HOB, ioaddr->ctl_addr);
209                 tf->hob_feature = ioread8(ioaddr->error_addr);
210                 tf->hob_nsect = ioread8(ioaddr->nsect_addr);
211                 tf->hob_lbal = ioread8(ioaddr->lbal_addr);
212                 tf->hob_lbam = ioread8(ioaddr->lbam_addr);
213                 tf->hob_lbah = ioread8(ioaddr->lbah_addr);
214         }
215 }
216
217 /**
218  *      ata_check_status - Read device status reg & clear interrupt
219  *      @ap: port where the device is
220  *
221  *      Reads ATA taskfile status register for currently-selected device
222  *      and return its value. This also clears pending interrupts
223  *      from this device
224  *
225  *      LOCKING:
226  *      Inherited from caller.
227  */
228 u8 ata_check_status(struct ata_port *ap)
229 {
230         return ioread8(ap->ioaddr.status_addr);
231 }
232
233 /**
234  *      ata_altstatus - Read device alternate status reg
235  *      @ap: port where the device is
236  *
237  *      Reads ATA taskfile alternate status register for
238  *      currently-selected device and return its value.
239  *
240  *      Note: may NOT be used as the check_altstatus() entry in
241  *      ata_port_operations.
242  *
243  *      LOCKING:
244  *      Inherited from caller.
245  */
246 u8 ata_altstatus(struct ata_port *ap)
247 {
248         if (ap->ops->check_altstatus)
249                 return ap->ops->check_altstatus(ap);
250
251         return ioread8(ap->ioaddr.altstatus_addr);
252 }
253
254 /**
255  *      ata_bmdma_setup - Set up PCI IDE BMDMA transaction
256  *      @qc: Info associated with this ATA transaction.
257  *
258  *      LOCKING:
259  *      spin_lock_irqsave(host lock)
260  */
261 void ata_bmdma_setup(struct ata_queued_cmd *qc)
262 {
263         struct ata_port *ap = qc->ap;
264         unsigned int rw = (qc->tf.flags & ATA_TFLAG_WRITE);
265         u8 dmactl;
266
267         /* load PRD table addr. */
268         mb();   /* make sure PRD table writes are visible to controller */
269         iowrite32(ap->prd_dma, ap->ioaddr.bmdma_addr + ATA_DMA_TABLE_OFS);
270
271         /* specify data direction, triple-check start bit is clear */
272         dmactl = ioread8(ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
273         dmactl &= ~(ATA_DMA_WR | ATA_DMA_START);
274         if (!rw)
275                 dmactl |= ATA_DMA_WR;
276         iowrite8(dmactl, ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
277
278         /* issue r/w command */
279         ap->ops->exec_command(ap, &qc->tf);
280 }
281
282 /**
283  *      ata_bmdma_start - Start a PCI IDE BMDMA transaction
284  *      @qc: Info associated with this ATA transaction.
285  *
286  *      LOCKING:
287  *      spin_lock_irqsave(host lock)
288  */
289 void ata_bmdma_start (struct ata_queued_cmd *qc)
290 {
291         struct ata_port *ap = qc->ap;
292         u8 dmactl;
293
294         /* start host DMA transaction */
295         dmactl = ioread8(ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
296         iowrite8(dmactl | ATA_DMA_START, ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
297
298         /* Strictly, one may wish to issue a readb() here, to
299          * flush the mmio write.  However, control also passes
300          * to the hardware at this point, and it will interrupt
301          * us when we are to resume control.  So, in effect,
302          * we don't care when the mmio write flushes.
303          * Further, a read of the DMA status register _immediately_
304          * following the write may not be what certain flaky hardware
305          * is expected, so I think it is best to not add a readb()
306          * without first all the MMIO ATA cards/mobos.
307          * Or maybe I'm just being paranoid.
308          */
309 }
310
311 /**
312  *      ata_bmdma_irq_clear - Clear PCI IDE BMDMA interrupt.
313  *      @ap: Port associated with this ATA transaction.
314  *
315  *      Clear interrupt and error flags in DMA status register.
316  *
317  *      May be used as the irq_clear() entry in ata_port_operations.
318  *
319  *      LOCKING:
320  *      spin_lock_irqsave(host lock)
321  */
322 void ata_bmdma_irq_clear(struct ata_port *ap)
323 {
324         void __iomem *mmio = ap->ioaddr.bmdma_addr;
325
326         if (!mmio)
327                 return;
328
329         iowrite8(ioread8(mmio + ATA_DMA_STATUS), mmio + ATA_DMA_STATUS);
330 }
331
332 /**
333  *      ata_bmdma_status - Read PCI IDE BMDMA status
334  *      @ap: Port associated with this ATA transaction.
335  *
336  *      Read and return BMDMA status register.
337  *
338  *      May be used as the bmdma_status() entry in ata_port_operations.
339  *
340  *      LOCKING:
341  *      spin_lock_irqsave(host lock)
342  */
343 u8 ata_bmdma_status(struct ata_port *ap)
344 {
345         return ioread8(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
346 }
347
348 /**
349  *      ata_bmdma_stop - Stop PCI IDE BMDMA transfer
350  *      @qc: Command we are ending DMA for
351  *
352  *      Clears the ATA_DMA_START flag in the dma control register
353  *
354  *      May be used as the bmdma_stop() entry in ata_port_operations.
355  *
356  *      LOCKING:
357  *      spin_lock_irqsave(host lock)
358  */
359 void ata_bmdma_stop(struct ata_queued_cmd *qc)
360 {
361         struct ata_port *ap = qc->ap;
362         void __iomem *mmio = ap->ioaddr.bmdma_addr;
363
364         /* clear start/stop bit */
365         iowrite8(ioread8(mmio + ATA_DMA_CMD) & ~ATA_DMA_START,
366                  mmio + ATA_DMA_CMD);
367
368         /* one-PIO-cycle guaranteed wait, per spec, for HDMA1:0 transition */
369         ata_altstatus(ap);        /* dummy read */
370 }
371
372 /**
373  *      ata_bmdma_freeze - Freeze BMDMA controller port
374  *      @ap: port to freeze
375  *
376  *      Freeze BMDMA controller port.
377  *
378  *      LOCKING:
379  *      Inherited from caller.
380  */
381 void ata_bmdma_freeze(struct ata_port *ap)
382 {
383         struct ata_ioports *ioaddr = &ap->ioaddr;
384
385         ap->ctl |= ATA_NIEN;
386         ap->last_ctl = ap->ctl;
387
388         iowrite8(ap->ctl, ioaddr->ctl_addr);
389
390         /* Under certain circumstances, some controllers raise IRQ on
391          * ATA_NIEN manipulation.  Also, many controllers fail to mask
392          * previously pending IRQ on ATA_NIEN assertion.  Clear it.
393          */
394         ata_chk_status(ap);
395
396         ap->ops->irq_clear(ap);
397 }
398
399 /**
400  *      ata_bmdma_thaw - Thaw BMDMA controller port
401  *      @ap: port to thaw
402  *
403  *      Thaw BMDMA controller port.
404  *
405  *      LOCKING:
406  *      Inherited from caller.
407  */
408 void ata_bmdma_thaw(struct ata_port *ap)
409 {
410         /* clear & re-enable interrupts */
411         ata_chk_status(ap);
412         ap->ops->irq_clear(ap);
413         ap->ops->irq_on(ap);
414 }
415
416 /**
417  *      ata_bmdma_drive_eh - Perform EH with given methods for BMDMA controller
418  *      @ap: port to handle error for
419  *      @prereset: prereset method (can be NULL)
420  *      @softreset: softreset method (can be NULL)
421  *      @hardreset: hardreset method (can be NULL)
422  *      @postreset: postreset method (can be NULL)
423  *
424  *      Handle error for ATA BMDMA controller.  It can handle both
425  *      PATA and SATA controllers.  Many controllers should be able to
426  *      use this EH as-is or with some added handling before and
427  *      after.
428  *
429  *      This function is intended to be used for constructing
430  *      ->error_handler callback by low level drivers.
431  *
432  *      LOCKING:
433  *      Kernel thread context (may sleep)
434  */
435 void ata_bmdma_drive_eh(struct ata_port *ap, ata_prereset_fn_t prereset,
436                         ata_reset_fn_t softreset, ata_reset_fn_t hardreset,
437                         ata_postreset_fn_t postreset)
438 {
439         struct ata_queued_cmd *qc;
440         unsigned long flags;
441         int thaw = 0;
442
443         qc = __ata_qc_from_tag(ap, ap->active_tag);
444         if (qc && !(qc->flags & ATA_QCFLAG_FAILED))
445                 qc = NULL;
446
447         /* reset PIO HSM and stop DMA engine */
448         spin_lock_irqsave(ap->lock, flags);
449
450         ap->hsm_task_state = HSM_ST_IDLE;
451
452         if (qc && (qc->tf.protocol == ATA_PROT_DMA ||
453                    qc->tf.protocol == ATA_PROT_ATAPI_DMA)) {
454                 u8 host_stat;
455
456                 host_stat = ap->ops->bmdma_status(ap);
457
458                 /* BMDMA controllers indicate host bus error by
459                  * setting DMA_ERR bit and timing out.  As it wasn't
460                  * really a timeout event, adjust error mask and
461                  * cancel frozen state.
462                  */
463                 if (qc->err_mask == AC_ERR_TIMEOUT && (host_stat & ATA_DMA_ERR)) {
464                         qc->err_mask = AC_ERR_HOST_BUS;
465                         thaw = 1;
466                 }
467
468                 ap->ops->bmdma_stop(qc);
469         }
470
471         ata_altstatus(ap);
472         ata_chk_status(ap);
473         ap->ops->irq_clear(ap);
474
475         spin_unlock_irqrestore(ap->lock, flags);
476
477         if (thaw)
478                 ata_eh_thaw_port(ap);
479
480         /* PIO and DMA engines have been stopped, perform recovery */
481         ata_do_eh(ap, prereset, softreset, hardreset, postreset);
482 }
483
484 /**
485  *      ata_bmdma_error_handler - Stock error handler for BMDMA controller
486  *      @ap: port to handle error for
487  *
488  *      Stock error handler for BMDMA controller.
489  *
490  *      LOCKING:
491  *      Kernel thread context (may sleep)
492  */
493 void ata_bmdma_error_handler(struct ata_port *ap)
494 {
495         ata_reset_fn_t hardreset;
496
497         hardreset = NULL;
498         if (sata_scr_valid(ap))
499                 hardreset = sata_std_hardreset;
500
501         ata_bmdma_drive_eh(ap, ata_std_prereset, ata_std_softreset, hardreset,
502                            ata_std_postreset);
503 }
504
505 /**
506  *      ata_bmdma_post_internal_cmd - Stock post_internal_cmd for
507  *                                    BMDMA controller
508  *      @qc: internal command to clean up
509  *
510  *      LOCKING:
511  *      Kernel thread context (may sleep)
512  */
513 void ata_bmdma_post_internal_cmd(struct ata_queued_cmd *qc)
514 {
515         if (qc->ap->ioaddr.bmdma_addr)
516                 ata_bmdma_stop(qc);
517 }
518
519 #ifdef CONFIG_PCI
520
521 static int ata_resources_present(struct pci_dev *pdev, int port)
522 {
523         int i;
524
525         /* Check the PCI resources for this channel are enabled */
526         port = port * 2;
527         for (i = 0; i < 2; i ++) {
528                 if (pci_resource_start(pdev, port + i) == 0 ||
529                     pci_resource_len(pdev, port + i) == 0)
530                         return 0;
531         }
532         return 1;
533 }
534
535 /**
536  *      ata_pci_init_native_mode - Initialize native-mode driver
537  *      @pdev:  pci device to be initialized
538  *      @port:  array[2] of pointers to port info structures.
539  *      @ports: bitmap of ports present
540  *
541  *      Utility function which allocates and initializes an
542  *      ata_probe_ent structure for a standard dual-port
543  *      PIO-based IDE controller.  The returned ata_probe_ent
544  *      structure can be passed to ata_device_add().  The returned
545  *      ata_probe_ent structure should then be freed with kfree().
546  *
547  *      The caller need only pass the address of the primary port, the
548  *      secondary will be deduced automatically. If the device has non
549  *      standard secondary port mappings this function can be called twice,
550  *      once for each interface.
551  */
552
553 struct ata_probe_ent *
554 ata_pci_init_native_mode(struct pci_dev *pdev, struct ata_port_info **port, int ports)
555 {
556         struct ata_probe_ent *probe_ent;
557         int i;
558         void __iomem * const *iomap;
559
560         /* Discard disabled ports.  Some controllers show their unused
561          * channels this way.  Disabled ports will be made dummy.
562          */
563         if (ata_resources_present(pdev, 0) == 0)
564                 ports &= ~ATA_PORT_PRIMARY;
565         if (ata_resources_present(pdev, 1) == 0)
566                 ports &= ~ATA_PORT_SECONDARY;
567
568         if (!ports) {
569                 dev_printk(KERN_ERR, &pdev->dev, "no available port\n");
570                 return NULL;
571         }
572
573         /* iomap BARs */
574         for (i = 0; i < 4; i++) {
575                 if (!(ports & (1 << (i / 2))))
576                         continue;
577                 if (pcim_iomap(pdev, i, 0) == NULL) {
578                         dev_printk(KERN_ERR, &pdev->dev,
579                                    "failed to iomap PCI BAR %d\n", i);
580                         return NULL;
581                 }
582         }
583
584         pcim_iomap(pdev, 4, 0); /* may fail */
585         iomap = pcim_iomap_table(pdev);
586
587         /* alloc and init probe_ent */
588         probe_ent = ata_probe_ent_alloc(pci_dev_to_dev(pdev), port[0]);
589         if (!probe_ent)
590                 return NULL;
591
592         probe_ent->n_ports = 2;
593         probe_ent->irq = pdev->irq;
594         probe_ent->irq_flags = IRQF_SHARED;
595
596         if (ports & ATA_PORT_PRIMARY) {
597                 probe_ent->port[0].cmd_addr = iomap[0];
598                 probe_ent->port[0].altstatus_addr =
599                 probe_ent->port[0].ctl_addr = (void __iomem *)
600                         ((unsigned long)iomap[1] | ATA_PCI_CTL_OFS);
601                 if (iomap[4]) {
602                         if ((!(port[0]->flags & ATA_FLAG_IGN_SIMPLEX)) &&
603                             (ioread8(iomap[4] + 2) & 0x80))
604                                 probe_ent->_host_flags |= ATA_HOST_SIMPLEX;
605                         probe_ent->port[0].bmdma_addr = iomap[4];
606                 }
607                 ata_std_ports(&probe_ent->port[0]);
608         } else
609                 probe_ent->dummy_port_mask |= ATA_PORT_PRIMARY;
610
611         if (ports & ATA_PORT_SECONDARY) {
612                 probe_ent->port[1].cmd_addr = iomap[2];
613                 probe_ent->port[1].altstatus_addr =
614                 probe_ent->port[1].ctl_addr = (void __iomem *)
615                         ((unsigned long)iomap[3] | ATA_PCI_CTL_OFS);
616                 if (iomap[4]) {
617                         if ((!(port[1]->flags & ATA_FLAG_IGN_SIMPLEX)) &&
618                             (ioread8(iomap[4] + 10) & 0x80))
619                                 probe_ent->_host_flags |= ATA_HOST_SIMPLEX;
620                         probe_ent->port[1].bmdma_addr = iomap[4] + 8;
621                 }
622                 ata_std_ports(&probe_ent->port[1]);
623                 probe_ent->pinfo2 = port[1];
624         } else
625                 probe_ent->dummy_port_mask |= ATA_PORT_SECONDARY;
626
627         return probe_ent;
628 }
629
630 /**
631  *      ata_pci_init_bmdma - acquire PCI BMDMA resources and init ATA host
632  *      @host: target ATA host
633  *
634  *      Acquire PCI BMDMA resources and initialize @host accordingly.
635  *
636  *      LOCKING:
637  *      Inherited from calling layer (may sleep).
638  *
639  *      RETURNS:
640  *      0 on success, -errno otherwise.
641  */
642 static int ata_pci_init_bmdma(struct ata_host *host)
643 {
644         struct device *gdev = host->dev;
645         struct pci_dev *pdev = to_pci_dev(gdev);
646         int i, rc;
647
648         /* TODO: If we get no DMA mask we should fall back to PIO */
649         rc = pci_set_dma_mask(pdev, ATA_DMA_MASK);
650         if (rc)
651                 return rc;
652         rc = pci_set_consistent_dma_mask(pdev, ATA_DMA_MASK);
653         if (rc)
654                 return rc;
655
656         /* request and iomap DMA region */
657         rc = pcim_iomap_regions(pdev, 1 << 4, DRV_NAME);
658         if (rc) {
659                 dev_printk(KERN_ERR, gdev, "failed to request/iomap BAR4\n");
660                 return -ENOMEM;
661         }
662         host->iomap = pcim_iomap_table(pdev);
663
664         for (i = 0; i < 2; i++) {
665                 struct ata_port *ap = host->ports[i];
666                 struct ata_ioports *ioaddr = &ap->ioaddr;
667                 void __iomem *bmdma = host->iomap[4] + 8 * i;
668
669                 if (ata_port_is_dummy(ap))
670                         continue;
671
672                 ioaddr->bmdma_addr = bmdma;
673                 if ((!(ap->flags & ATA_FLAG_IGN_SIMPLEX)) &&
674                     (ioread8(bmdma + 2) & 0x80))
675                         host->flags |= ATA_HOST_SIMPLEX;
676         }
677
678         return 0;
679 }
680
681 /**
682  *      ata_pci_init_native_host - acquire native ATA resources and init host
683  *      @host: target ATA host
684  *      @port_mask: ports to consider
685  *
686  *      Acquire native PCI ATA resources for @host and initialize
687  *      @host accordoingly.
688  *
689  *      LOCKING:
690  *      Inherited from calling layer (may sleep).
691  *
692  *      RETURNS:
693  *      0 on success, -errno otherwise.
694  */
695 int ata_pci_init_native_host(struct ata_host *host, unsigned int port_mask)
696 {
697         struct device *gdev = host->dev;
698         struct pci_dev *pdev = to_pci_dev(gdev);
699         int i, rc;
700
701         /* Discard disabled ports.  Some controllers show their unused
702          * channels this way.  Disabled ports are made dummy.
703          */
704         for (i = 0; i < 2; i++) {
705                 if ((port_mask & (1 << i)) && !ata_resources_present(pdev, i)) {
706                         host->ports[i]->ops = &ata_dummy_port_ops;
707                         port_mask &= ~(1 << i);
708                 }
709         }
710
711         if (!port_mask) {
712                 dev_printk(KERN_ERR, gdev, "no available port\n");
713                 return -ENODEV;
714         }
715
716         /* request, iomap BARs and init port addresses accordingly */
717         for (i = 0; i < 2; i++) {
718                 struct ata_port *ap = host->ports[i];
719                 int base = i * 2;
720                 void __iomem * const *iomap;
721
722                 if (!(port_mask & (1 << i)))
723                         continue;
724
725                 rc = pcim_iomap_regions(pdev, 0x3 << base, DRV_NAME);
726                 if (rc) {
727                         dev_printk(KERN_ERR, gdev, "failed to request/iomap "
728                                    "BARs for port %d (errno=%d)\n", i, rc);
729                         if (rc == -EBUSY)
730                                 pcim_pin_device(pdev);
731                         return rc;
732                 }
733                 host->iomap = iomap = pcim_iomap_table(pdev);
734
735                 ap->ioaddr.cmd_addr = iomap[base];
736                 ap->ioaddr.altstatus_addr =
737                 ap->ioaddr.ctl_addr = (void __iomem *)
738                         ((unsigned long)iomap[base + 1] | ATA_PCI_CTL_OFS);
739                 ata_std_ports(&ap->ioaddr);
740         }
741
742         return 0;
743 }
744
745 struct ata_legacy_devres {
746         unsigned int    mask;
747         unsigned long   cmd_port[2];
748         void __iomem *  cmd_addr[2];
749         void __iomem *  ctl_addr[2];
750         unsigned int    irq[2];
751         void *          irq_dev_id[2];
752 };
753
754 static void ata_legacy_free_irqs(struct ata_legacy_devres *legacy_dr)
755 {
756         int i;
757
758         for (i = 0; i < 2; i++) {
759                 if (!legacy_dr->irq[i])
760                         continue;
761
762                 free_irq(legacy_dr->irq[i], legacy_dr->irq_dev_id[i]);
763                 legacy_dr->irq[i] = 0;
764                 legacy_dr->irq_dev_id[i] = NULL;
765         }
766 }
767
768 static void ata_legacy_release(struct device *gdev, void *res)
769 {
770         struct ata_legacy_devres *this = res;
771         int i;
772
773         ata_legacy_free_irqs(this);
774
775         for (i = 0; i < 2; i++) {
776                 if (this->cmd_addr[i])
777                         ioport_unmap(this->cmd_addr[i]);
778                 if (this->ctl_addr[i])
779                         ioport_unmap(this->ctl_addr[i]);
780                 if (this->cmd_port[i])
781                         release_region(this->cmd_port[i], 8);
782         }
783 }
784
785 static int ata_init_legacy_port(struct ata_port *ap,
786                                 struct ata_legacy_devres *legacy_dr)
787 {
788         struct ata_host *host = ap->host;
789         int port_no = ap->port_no;
790         unsigned long cmd_port, ctl_port;
791
792         if (port_no == 0) {
793                 cmd_port = ATA_PRIMARY_CMD;
794                 ctl_port = ATA_PRIMARY_CTL;
795         } else {
796                 cmd_port = ATA_SECONDARY_CMD;
797                 ctl_port = ATA_SECONDARY_CTL;
798         }
799
800         /* request cmd_port */
801         if (request_region(cmd_port, 8, "libata"))
802                 legacy_dr->cmd_port[port_no] = cmd_port;
803         else {
804                 dev_printk(KERN_WARNING, host->dev,
805                            "0x%0lX IDE port busy\n", cmd_port);
806                 return -EBUSY;
807         }
808
809         /* iomap cmd and ctl ports */
810         legacy_dr->cmd_addr[port_no] = ioport_map(cmd_port, 8);
811         legacy_dr->ctl_addr[port_no] = ioport_map(ctl_port, 1);
812         if (!legacy_dr->cmd_addr[port_no] || !legacy_dr->ctl_addr[port_no])
813                 return -ENOMEM;
814
815         /* init IO addresses */
816         ap->ioaddr.cmd_addr = legacy_dr->cmd_addr[port_no];
817         ap->ioaddr.altstatus_addr = legacy_dr->ctl_addr[port_no];
818         ap->ioaddr.ctl_addr = legacy_dr->ctl_addr[port_no];
819         ata_std_ports(&ap->ioaddr);
820
821         return 0;
822 }
823
824 /**
825  *      ata_init_legacy_host - acquire legacy ATA resources and init ATA host
826  *      @host: target ATA host
827  *      @legacy_mask: out parameter, mask indicating ports is in legacy mode
828  *      @was_busy: out parameter, indicates whether any port was busy
829  *
830  *      Acquire legacy ATA resources for ports.
831  *
832  *      LOCKING:
833  *      Inherited from calling layer (may sleep).
834  *
835  *      RETURNS:
836  *      0 on success, -errno otherwise.
837  */
838 static int ata_init_legacy_host(struct ata_host *host,
839                                 unsigned int *legacy_mask, int *was_busy)
840 {
841         struct device *gdev = host->dev;
842         struct ata_legacy_devres *legacy_dr;
843         int i, rc;
844
845         if (!devres_open_group(gdev, NULL, GFP_KERNEL))
846                 return -ENOMEM;
847
848         rc = -ENOMEM;
849         legacy_dr = devres_alloc(ata_legacy_release, sizeof(*legacy_dr),
850                                  GFP_KERNEL);
851         if (!legacy_dr)
852                 goto err_out;
853         devres_add(gdev, legacy_dr);
854
855         for (i = 0; i < 2; i++) {
856                 *legacy_mask &= ~(1 << i);
857                 rc = ata_init_legacy_port(host->ports[i], legacy_dr);
858                 if (rc == 0)
859                         legacy_dr->mask |= 1 << i;
860                 else if (rc == -EBUSY)
861                         (*was_busy)++;
862         }
863
864         if (!legacy_dr->mask)
865                 return -EBUSY;
866
867         for (i = 0; i < 2; i++)
868                 if (!(legacy_dr->mask & (1 << i)))
869                         host->ports[i]->ops = &ata_dummy_port_ops;
870
871         *legacy_mask |= legacy_dr->mask;
872
873         devres_remove_group(gdev, NULL);
874         return 0;
875
876  err_out:
877         devres_release_group(gdev, NULL);
878         return rc;
879 }
880
881 /**
882  *      ata_request_legacy_irqs - request legacy ATA IRQs
883  *      @host: target ATA host
884  *      @handler: array of IRQ handlers
885  *      @irq_flags: array of IRQ flags
886  *      @dev_id: array of IRQ dev_ids
887  *
888  *      Request legacy IRQs for non-dummy legacy ports in @host.  All
889  *      IRQ parameters are passed as array to allow ports to have
890  *      separate IRQ handlers.
891  *
892  *      LOCKING:
893  *      Inherited from calling layer (may sleep).
894  *
895  *      RETURNS:
896  *      0 on success, -errno otherwise.
897  */
898 static int ata_request_legacy_irqs(struct ata_host *host,
899                                    irq_handler_t const *handler,
900                                    const unsigned int *irq_flags,
901                                    void * const *dev_id)
902 {
903         struct device *gdev = host->dev;
904         struct ata_legacy_devres *legacy_dr;
905         int i, rc;
906
907         legacy_dr = devres_find(host->dev, ata_legacy_release, NULL, NULL);
908         BUG_ON(!legacy_dr);
909
910         for (i = 0; i < 2; i++) {
911                 unsigned int irq;
912
913                 /* FIXME: ATA_*_IRQ() should take generic device not pci_dev */
914                 if (i == 0)
915                         irq = ATA_PRIMARY_IRQ(to_pci_dev(gdev));
916                 else
917                         irq = ATA_SECONDARY_IRQ(to_pci_dev(gdev));
918
919                 if (!(legacy_dr->mask & (1 << i)))
920                         continue;
921
922                 if (!handler[i]) {
923                         dev_printk(KERN_ERR, gdev,
924                                    "NULL handler specified for port %d\n", i);
925                         rc = -EINVAL;
926                         goto err_out;
927                 }
928
929                 rc = request_irq(irq, handler[i], irq_flags[i], DRV_NAME,
930                                  dev_id[i]);
931                 if (rc) {
932                         dev_printk(KERN_ERR, gdev,
933                                 "irq %u request failed (errno=%d)\n", irq, rc);
934                         goto err_out;
935                 }
936
937                 /* record irq allocation in legacy_dr */
938                 legacy_dr->irq[i] = irq;
939                 legacy_dr->irq_dev_id[i] = dev_id[i];
940
941                 /* only used to print info */
942                 if (i == 0)
943                         host->irq = irq;
944                 else
945                         host->irq2 = irq;
946         }
947
948         return 0;
949
950  err_out:
951         ata_legacy_free_irqs(legacy_dr);
952         return rc;
953 }
954
955 /**
956  *      ata_pci_init_one - Initialize/register PCI IDE host controller
957  *      @pdev: Controller to be initialized
958  *      @port_info: Information from low-level host driver
959  *      @n_ports: Number of ports attached to host controller
960  *
961  *      This is a helper function which can be called from a driver's
962  *      xxx_init_one() probe function if the hardware uses traditional
963  *      IDE taskfile registers.
964  *
965  *      This function calls pci_enable_device(), reserves its register
966  *      regions, sets the dma mask, enables bus master mode, and calls
967  *      ata_device_add()
968  *
969  *      ASSUMPTION:
970  *      Nobody makes a single channel controller that appears solely as
971  *      the secondary legacy port on PCI.
972  *
973  *      LOCKING:
974  *      Inherited from PCI layer (may sleep).
975  *
976  *      RETURNS:
977  *      Zero on success, negative on errno-based value on error.
978  */
979
980 int ata_pci_init_one (struct pci_dev *pdev, struct ata_port_info **port_info,
981                       unsigned int n_ports)
982 {
983         struct device *dev = &pdev->dev;
984         struct ata_host *host = NULL;
985         const struct ata_port_info *port[2];
986         u8 mask;
987         unsigned int legacy_mode = 0;
988         int rc;
989
990         DPRINTK("ENTER\n");
991
992         if (!devres_open_group(dev, NULL, GFP_KERNEL))
993                 return -ENOMEM;
994
995         BUG_ON(n_ports < 1 || n_ports > 2);
996
997         port[0] = port_info[0];
998         if (n_ports > 1)
999                 port[1] = port_info[1];
1000         else
1001                 port[1] = port[0];
1002
1003         /* FIXME: Really for ATA it isn't safe because the device may be
1004            multi-purpose and we want to leave it alone if it was already
1005            enabled. Secondly for shared use as Arjan says we want refcounting
1006
1007            Checking dev->is_enabled is insufficient as this is not set at
1008            boot for the primary video which is BIOS enabled
1009           */
1010
1011         rc = pcim_enable_device(pdev);
1012         if (rc)
1013                 goto err_out;
1014
1015         if ((pdev->class >> 8) == PCI_CLASS_STORAGE_IDE) {
1016                 u8 tmp8;
1017
1018                 /* TODO: What if one channel is in native mode ... */
1019                 pci_read_config_byte(pdev, PCI_CLASS_PROG, &tmp8);
1020                 mask = (1 << 2) | (1 << 0);
1021                 if ((tmp8 & mask) != mask)
1022                         legacy_mode = (1 << 3);
1023 #if defined(CONFIG_NO_ATA_LEGACY)
1024                 /* Some platforms with PCI limits cannot address compat
1025                    port space. In that case we punt if their firmware has
1026                    left a device in compatibility mode */
1027                 if (legacy_mode) {
1028                         printk(KERN_ERR "ata: Compatibility mode ATA is not supported on this platform, skipping.\n");
1029                         rc = -EOPNOTSUPP;
1030                         goto err_out;
1031                 }
1032 #endif
1033         }
1034
1035         /* alloc and init host */
1036         host = ata_host_alloc_pinfo(dev, port, 2);
1037         if (!host) {
1038                 dev_printk(KERN_ERR, &pdev->dev,
1039                            "failed to allocate ATA host\n");
1040                 rc = -ENOMEM;
1041                 goto err_out;
1042         }
1043
1044         if (!legacy_mode) {
1045                 unsigned int port_mask;
1046
1047                 port_mask = ATA_PORT_PRIMARY;
1048                 if (n_ports > 1)
1049                         port_mask |= ATA_PORT_SECONDARY;
1050
1051                 rc = ata_pci_init_native_host(host, port_mask);
1052                 if (rc)
1053                         goto err_out;
1054         } else {
1055                 int was_busy = 0;
1056
1057                 rc = ata_init_legacy_host(host, &legacy_mode, &was_busy);
1058                 if (was_busy)
1059                         pcim_pin_device(pdev);
1060                 if (rc)
1061                         goto err_out;
1062
1063                 /* request respective PCI regions, may fail */
1064                 rc = pci_request_region(pdev, 1, DRV_NAME);
1065                 rc = pci_request_region(pdev, 3, DRV_NAME);
1066         }
1067
1068         /* init BMDMA, may fail */
1069         ata_pci_init_bmdma(host);
1070         pci_set_master(pdev);
1071
1072         /* start host and request IRQ */
1073         rc = ata_host_start(host);
1074         if (rc)
1075                 goto err_out;
1076
1077         if (!legacy_mode)
1078                 rc = devm_request_irq(dev, pdev->irq,
1079                                       port_info[0]->port_ops->irq_handler,
1080                                       IRQF_SHARED, DRV_NAME, host);
1081         else {
1082                 irq_handler_t handler[2] = { host->ops->irq_handler,
1083                                              host->ops->irq_handler };
1084                 unsigned int irq_flags[2] = { IRQF_SHARED, IRQF_SHARED };
1085                 void *dev_id[2] = { host, host };
1086
1087                 rc = ata_request_legacy_irqs(host, handler, irq_flags, dev_id);
1088         }
1089         if (rc)
1090                 goto err_out;
1091
1092         /* register */
1093         rc = ata_host_register(host, port_info[0]->sht);
1094         if (rc)
1095                 goto err_out;
1096
1097         devres_remove_group(dev, NULL);
1098         return 0;
1099
1100 err_out:
1101         devres_release_group(dev, NULL);
1102         return rc;
1103 }
1104
1105 /**
1106  *      ata_pci_clear_simplex   -       attempt to kick device out of simplex
1107  *      @pdev: PCI device
1108  *
1109  *      Some PCI ATA devices report simplex mode but in fact can be told to
1110  *      enter non simplex mode. This implements the neccessary logic to
1111  *      perform the task on such devices. Calling it on other devices will
1112  *      have -undefined- behaviour.
1113  */
1114
1115 int ata_pci_clear_simplex(struct pci_dev *pdev)
1116 {
1117         unsigned long bmdma = pci_resource_start(pdev, 4);
1118         u8 simplex;
1119
1120         if (bmdma == 0)
1121                 return -ENOENT;
1122
1123         simplex = inb(bmdma + 0x02);
1124         outb(simplex & 0x60, bmdma + 0x02);
1125         simplex = inb(bmdma + 0x02);
1126         if (simplex & 0x80)
1127                 return -EOPNOTSUPP;
1128         return 0;
1129 }
1130
1131 unsigned long ata_pci_default_filter(struct ata_device *adev, unsigned long xfer_mask)
1132 {
1133         /* Filter out DMA modes if the device has been configured by
1134            the BIOS as PIO only */
1135
1136         if (adev->ap->ioaddr.bmdma_addr == 0)
1137                 xfer_mask &= ~(ATA_MASK_MWDMA | ATA_MASK_UDMA);
1138         return xfer_mask;
1139 }
1140
1141 #endif /* CONFIG_PCI */
1142