Version:  2.0.40 2.2.26 2.4.37 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16

Linux/drivers/ata/pata_acpi.c

  1 /*
  2  *      ACPI PATA driver
  3  *
  4  *      (c) 2007 Red Hat
  5  */
  6 
  7 #include <linux/kernel.h>
  8 #include <linux/module.h>
  9 #include <linux/pci.h>
 10 #include <linux/blkdev.h>
 11 #include <linux/delay.h>
 12 #include <linux/device.h>
 13 #include <linux/gfp.h>
 14 #include <linux/acpi.h>
 15 #include <linux/libata.h>
 16 #include <linux/ata.h>
 17 #include <scsi/scsi_host.h>
 18 
 19 #define DRV_NAME        "pata_acpi"
 20 #define DRV_VERSION     "0.2.3"
 21 
 22 struct pata_acpi {
 23         struct ata_acpi_gtm gtm;
 24         void *last;
 25         unsigned long mask[2];
 26 };
 27 
 28 /**
 29  *      pacpi_pre_reset -       check for 40/80 pin
 30  *      @ap: Port
 31  *      @deadline: deadline jiffies for the operation
 32  *
 33  *      Perform the PATA port setup we need.
 34  */
 35 
 36 static int pacpi_pre_reset(struct ata_link *link, unsigned long deadline)
 37 {
 38         struct ata_port *ap = link->ap;
 39         struct pata_acpi *acpi = ap->private_data;
 40         if (ACPI_HANDLE(&ap->tdev) == NULL || ata_acpi_gtm(ap, &acpi->gtm) < 0)
 41                 return -ENODEV;
 42 
 43         return ata_sff_prereset(link, deadline);
 44 }
 45 
 46 /**
 47  *      pacpi_cable_detect      -       cable type detection
 48  *      @ap: port to detect
 49  *
 50  *      Perform device specific cable detection
 51  */
 52 
 53 static int pacpi_cable_detect(struct ata_port *ap)
 54 {
 55         struct pata_acpi *acpi = ap->private_data;
 56 
 57         if ((acpi->mask[0] | acpi->mask[1]) & (0xF8 << ATA_SHIFT_UDMA))
 58                 return ATA_CBL_PATA80;
 59         else
 60                 return ATA_CBL_PATA40;
 61 }
 62 
 63 /**
 64  *      pacpi_discover_modes    -       filter non ACPI modes
 65  *      @adev: ATA device
 66  *      @mask: proposed modes
 67  *
 68  *      Try the modes available and see which ones the ACPI method will
 69  *      set up sensibly. From this we get a mask of ACPI modes we can use
 70  */
 71 
 72 static unsigned long pacpi_discover_modes(struct ata_port *ap, struct ata_device *adev)
 73 {
 74         struct pata_acpi *acpi = ap->private_data;
 75         struct ata_acpi_gtm probe;
 76         unsigned int xfer_mask;
 77 
 78         probe = acpi->gtm;
 79 
 80         ata_acpi_gtm(ap, &probe);
 81 
 82         xfer_mask = ata_acpi_gtm_xfermask(adev, &probe);
 83 
 84         if (xfer_mask & (0xF8 << ATA_SHIFT_UDMA))
 85                 ap->cbl = ATA_CBL_PATA80;
 86 
 87         return xfer_mask;
 88 }
 89 
 90 /**
 91  *      pacpi_mode_filter       -       mode filter for ACPI
 92  *      @adev: device
 93  *      @mask: mask of valid modes
 94  *
 95  *      Filter the valid mode list according to our own specific rules, in
 96  *      this case the list of discovered valid modes obtained by ACPI probing
 97  */
 98 
 99 static unsigned long pacpi_mode_filter(struct ata_device *adev, unsigned long mask)
100 {
101         struct pata_acpi *acpi = adev->link->ap->private_data;
102         return mask & acpi->mask[adev->devno];
103 }
104 
105 /**
106  *      pacpi_set_piomode       -       set initial PIO mode data
107  *      @ap: ATA interface
108  *      @adev: ATA device
109  */
110 
111 static void pacpi_set_piomode(struct ata_port *ap, struct ata_device *adev)
112 {
113         int unit = adev->devno;
114         struct pata_acpi *acpi = ap->private_data;
115         const struct ata_timing *t;
116 
117         if (!(acpi->gtm.flags & 0x10))
118                 unit = 0;
119 
120         /* Now stuff the nS values into the structure */
121         t = ata_timing_find_mode(adev->pio_mode);
122         acpi->gtm.drive[unit].pio = t->cycle;
123         ata_acpi_stm(ap, &acpi->gtm);
124         /* See what mode we actually got */
125         ata_acpi_gtm(ap, &acpi->gtm);
126 }
127 
128 /**
129  *      pacpi_set_dmamode       -       set initial DMA mode data
130  *      @ap: ATA interface
131  *      @adev: ATA device
132  */
133 
134 static void pacpi_set_dmamode(struct ata_port *ap, struct ata_device *adev)
135 {
136         int unit = adev->devno;
137         struct pata_acpi *acpi = ap->private_data;
138         const struct ata_timing *t;
139 
140         if (!(acpi->gtm.flags & 0x10))
141                 unit = 0;
142 
143         /* Now stuff the nS values into the structure */
144         t = ata_timing_find_mode(adev->dma_mode);
145         if (adev->dma_mode >= XFER_UDMA_0) {
146                 acpi->gtm.drive[unit].dma = t->udma;
147                 acpi->gtm.flags |= (1 << (2 * unit));
148         } else {
149                 acpi->gtm.drive[unit].dma = t->cycle;
150                 acpi->gtm.flags &= ~(1 << (2 * unit));
151         }
152         ata_acpi_stm(ap, &acpi->gtm);
153         /* See what mode we actually got */
154         ata_acpi_gtm(ap, &acpi->gtm);
155 }
156 
157 /**
158  *      pacpi_qc_issue  -       command issue
159  *      @qc: command pending
160  *
161  *      Called when the libata layer is about to issue a command. We wrap
162  *      this interface so that we can load the correct ATA timings if
163  *      necessary.
164  */
165 
166 static unsigned int pacpi_qc_issue(struct ata_queued_cmd *qc)
167 {
168         struct ata_port *ap = qc->ap;
169         struct ata_device *adev = qc->dev;
170         struct pata_acpi *acpi = ap->private_data;
171 
172         if (acpi->gtm.flags & 0x10)
173                 return ata_bmdma_qc_issue(qc);
174 
175         if (adev != acpi->last) {
176                 pacpi_set_piomode(ap, adev);
177                 if (ata_dma_enabled(adev))
178                         pacpi_set_dmamode(ap, adev);
179                 acpi->last = adev;
180         }
181         return ata_bmdma_qc_issue(qc);
182 }
183 
184 /**
185  *      pacpi_port_start        -       port setup
186  *      @ap: ATA port being set up
187  *
188  *      Use the port_start hook to maintain private control structures
189  */
190 
191 static int pacpi_port_start(struct ata_port *ap)
192 {
193         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
194         struct pata_acpi *acpi;
195 
196         if (ACPI_HANDLE(&ap->tdev) == NULL)
197                 return -ENODEV;
198 
199         acpi = ap->private_data = devm_kzalloc(&pdev->dev, sizeof(struct pata_acpi), GFP_KERNEL);
200         if (ap->private_data == NULL)
201                 return -ENOMEM;
202         acpi->mask[0] = pacpi_discover_modes(ap, &ap->link.device[0]);
203         acpi->mask[1] = pacpi_discover_modes(ap, &ap->link.device[1]);
204         return ata_bmdma_port_start(ap);
205 }
206 
207 static struct scsi_host_template pacpi_sht = {
208         ATA_BMDMA_SHT(DRV_NAME),
209 };
210 
211 static struct ata_port_operations pacpi_ops = {
212         .inherits               = &ata_bmdma_port_ops,
213         .qc_issue               = pacpi_qc_issue,
214         .cable_detect           = pacpi_cable_detect,
215         .mode_filter            = pacpi_mode_filter,
216         .set_piomode            = pacpi_set_piomode,
217         .set_dmamode            = pacpi_set_dmamode,
218         .prereset               = pacpi_pre_reset,
219         .port_start             = pacpi_port_start,
220 };
221 
222 
223 /**
224  *      pacpi_init_one - Register ACPI ATA PCI device with kernel services
225  *      @pdev: PCI device to register
226  *      @ent: Entry in pacpi_pci_tbl matching with @pdev
227  *
228  *      Called from kernel PCI layer.
229  *
230  *      LOCKING:
231  *      Inherited from PCI layer (may sleep).
232  *
233  *      RETURNS:
234  *      Zero on success, or -ERRNO value.
235  */
236 
237 static int pacpi_init_one (struct pci_dev *pdev, const struct pci_device_id *id)
238 {
239         static const struct ata_port_info info = {
240                 .flags          = ATA_FLAG_SLAVE_POSS,
241 
242                 .pio_mask       = ATA_PIO4,
243                 .mwdma_mask     = ATA_MWDMA2,
244                 .udma_mask      = ATA_UDMA6,
245 
246                 .port_ops       = &pacpi_ops,
247         };
248         const struct ata_port_info *ppi[] = { &info, NULL };
249         if (pdev->vendor == PCI_VENDOR_ID_ATI) {
250                 int rc = pcim_enable_device(pdev);
251                 if (rc < 0)
252                         return rc;
253                 pcim_pin_device(pdev);
254         }
255         return ata_pci_bmdma_init_one(pdev, ppi, &pacpi_sht, NULL, 0);
256 }
257 
258 static const struct pci_device_id pacpi_pci_tbl[] = {
259         { PCI_ANY_ID,           PCI_ANY_ID,                        PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_STORAGE_IDE << 8, 0xFFFFFF00UL, 1},
260         { }     /* terminate list */
261 };
262 
263 static struct pci_driver pacpi_pci_driver = {
264         .name                   = DRV_NAME,
265         .id_table               = pacpi_pci_tbl,
266         .probe                  = pacpi_init_one,
267         .remove                 = ata_pci_remove_one,
268 #ifdef CONFIG_PM_SLEEP
269         .suspend                = ata_pci_device_suspend,
270         .resume                 = ata_pci_device_resume,
271 #endif
272 };
273 
274 module_pci_driver(pacpi_pci_driver);
275 
276 MODULE_AUTHOR("Alan Cox");
277 MODULE_DESCRIPTION("SCSI low-level driver for ATA in ACPI mode");
278 MODULE_LICENSE("GPL");
279 MODULE_DEVICE_TABLE(pci, pacpi_pci_tbl);
280 MODULE_VERSION(DRV_VERSION);
281 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us