4 * (c) 2007 Red Hat <alan@redhat.com>
7 #include <linux/kernel.h>
8 #include <linux/module.h>
10 #include <linux/init.h>
11 #include <linux/blkdev.h>
12 #include <linux/delay.h>
13 #include <linux/device.h>
14 #include <scsi/scsi_host.h>
15 #include <acpi/acpi_bus.h>
16 #include <acpi/acnames.h>
17 #include <acpi/acnamesp.h>
18 #include <acpi/acparser.h>
19 #include <acpi/acexcep.h>
20 #include <acpi/acmacros.h>
21 #include <acpi/actypes.h>
23 #include <linux/libata.h>
24 #include <linux/ata.h>
26 #define DRV_NAME "pata_acpi"
27 #define DRV_VERSION "0.2.3"
30 struct ata_acpi_gtm gtm
;
32 unsigned long mask
[2];
36 * pacpi_pre_reset - check for 40/80 pin
38 * @deadline: deadline jiffies for the operation
40 * Perform the PATA port setup we need.
43 static int pacpi_pre_reset(struct ata_link
*link
, unsigned long deadline
)
45 struct ata_port
*ap
= link
->ap
;
46 struct pata_acpi
*acpi
= ap
->private_data
;
47 if (ap
->acpi_handle
== NULL
|| ata_acpi_gtm(ap
, &acpi
->gtm
) < 0)
50 return ata_std_prereset(link
, deadline
);
54 * pacpi_cable_detect - cable type detection
57 * Perform device specific cable detection
60 static int pacpi_cable_detect(struct ata_port
*ap
)
62 struct pata_acpi
*acpi
= ap
->private_data
;
64 if ((acpi
->mask
[0] | acpi
->mask
[1]) & (0xF8 << ATA_SHIFT_UDMA
))
65 return ATA_CBL_PATA80
;
67 return ATA_CBL_PATA40
;
71 * pacpi_error_handler - Setup and error handler
75 * None (inherited from caller).
78 static void pacpi_error_handler(struct ata_port
*ap
)
80 ata_bmdma_drive_eh(ap
, pacpi_pre_reset
, ata_std_softreset
, NULL
,
85 * pacpi_discover_modes - filter non ACPI modes
87 * @mask: proposed modes
89 * Try the modes available and see which ones the ACPI method will
90 * set up sensibly. From this we get a mask of ACPI modes we can use
93 static unsigned long pacpi_discover_modes(struct ata_port
*ap
, struct ata_device
*adev
)
95 struct pata_acpi
*acpi
= ap
->private_data
;
96 struct ata_acpi_gtm probe
;
97 unsigned int xfer_mask
;
101 ata_acpi_gtm(ap
, &probe
);
103 xfer_mask
= ata_acpi_gtm_xfermask(adev
, &probe
);
105 if (xfer_mask
& (0xF8 << ATA_SHIFT_UDMA
))
106 ap
->cbl
= ATA_CBL_PATA80
;
112 * pacpi_mode_filter - mode filter for ACPI
114 * @mask: mask of valid modes
116 * Filter the valid mode list according to our own specific rules, in
117 * this case the list of discovered valid modes obtained by ACPI probing
120 static unsigned long pacpi_mode_filter(struct ata_device
*adev
, unsigned long mask
)
122 struct pata_acpi
*acpi
= adev
->link
->ap
->private_data
;
123 return ata_pci_default_filter(adev
, mask
& acpi
->mask
[adev
->devno
]);
127 * pacpi_set_piomode - set initial PIO mode data
132 static void pacpi_set_piomode(struct ata_port
*ap
, struct ata_device
*adev
)
134 int unit
= adev
->devno
;
135 struct pata_acpi
*acpi
= ap
->private_data
;
136 const struct ata_timing
*t
;
138 if (!(acpi
->gtm
.flags
& 0x10))
141 /* Now stuff the nS values into the structure */
142 t
= ata_timing_find_mode(adev
->pio_mode
);
143 acpi
->gtm
.drive
[unit
].pio
= t
->cycle
;
144 ata_acpi_stm(ap
, &acpi
->gtm
);
145 /* See what mode we actually got */
146 ata_acpi_gtm(ap
, &acpi
->gtm
);
150 * pacpi_set_dmamode - set initial DMA mode data
155 static void pacpi_set_dmamode(struct ata_port
*ap
, struct ata_device
*adev
)
157 int unit
= adev
->devno
;
158 struct pata_acpi
*acpi
= ap
->private_data
;
159 const struct ata_timing
*t
;
161 if (!(acpi
->gtm
.flags
& 0x10))
164 /* Now stuff the nS values into the structure */
165 t
= ata_timing_find_mode(adev
->dma_mode
);
166 if (adev
->dma_mode
>= XFER_UDMA_0
) {
167 acpi
->gtm
.drive
[unit
].dma
= t
->udma
;
168 acpi
->gtm
.flags
|= (1 << (2 * unit
));
170 acpi
->gtm
.drive
[unit
].dma
= t
->cycle
;
171 acpi
->gtm
.flags
&= ~(1 << (2 * unit
));
173 ata_acpi_stm(ap
, &acpi
->gtm
);
174 /* See what mode we actually got */
175 ata_acpi_gtm(ap
, &acpi
->gtm
);
179 * pacpi_qc_issue_prot - command issue
180 * @qc: command pending
182 * Called when the libata layer is about to issue a command. We wrap
183 * this interface so that we can load the correct ATA timings if
187 static unsigned int pacpi_qc_issue_prot(struct ata_queued_cmd
*qc
)
189 struct ata_port
*ap
= qc
->ap
;
190 struct ata_device
*adev
= qc
->dev
;
191 struct pata_acpi
*acpi
= ap
->private_data
;
193 if (acpi
->gtm
.flags
& 0x10)
194 return ata_qc_issue_prot(qc
);
196 if (adev
!= acpi
->last
) {
197 pacpi_set_piomode(ap
, adev
);
199 pacpi_set_dmamode(ap
, adev
);
202 return ata_qc_issue_prot(qc
);
206 * pacpi_port_start - port setup
207 * @ap: ATA port being set up
209 * Use the port_start hook to maintain private control structures
212 static int pacpi_port_start(struct ata_port
*ap
)
214 struct pci_dev
*pdev
= to_pci_dev(ap
->host
->dev
);
215 struct pata_acpi
*acpi
;
219 if (ap
->acpi_handle
== NULL
)
222 acpi
= ap
->private_data
= devm_kzalloc(&pdev
->dev
, sizeof(struct pata_acpi
), GFP_KERNEL
);
223 if (ap
->private_data
== NULL
)
225 acpi
->mask
[0] = pacpi_discover_modes(ap
, &ap
->link
.device
[0]);
226 acpi
->mask
[1] = pacpi_discover_modes(ap
, &ap
->link
.device
[1]);
227 ret
= ata_sff_port_start(ap
);
234 static struct scsi_host_template pacpi_sht
= {
235 ATA_BMDMA_SHT(DRV_NAME
),
238 static const struct ata_port_operations pacpi_ops
= {
239 .set_piomode
= pacpi_set_piomode
,
240 .set_dmamode
= pacpi_set_dmamode
,
241 .mode_filter
= pacpi_mode_filter
,
243 /* Task file is PCI ATA format, use helpers */
244 .tf_load
= ata_tf_load
,
245 .tf_read
= ata_tf_read
,
246 .check_status
= ata_check_status
,
247 .exec_command
= ata_exec_command
,
248 .dev_select
= ata_std_dev_select
,
250 .freeze
= ata_bmdma_freeze
,
251 .thaw
= ata_bmdma_thaw
,
252 .error_handler
= pacpi_error_handler
,
253 .post_internal_cmd
= ata_bmdma_post_internal_cmd
,
254 .cable_detect
= pacpi_cable_detect
,
256 /* BMDMA handling is PCI ATA format, use helpers */
257 .bmdma_setup
= ata_bmdma_setup
,
258 .bmdma_start
= ata_bmdma_start
,
259 .bmdma_stop
= ata_bmdma_stop
,
260 .bmdma_status
= ata_bmdma_status
,
261 .qc_prep
= ata_qc_prep
,
262 .qc_issue
= pacpi_qc_issue_prot
,
263 .data_xfer
= ata_data_xfer
,
265 /* Timeout handling */
266 .irq_handler
= ata_interrupt
,
267 .irq_clear
= ata_bmdma_irq_clear
,
268 .irq_on
= ata_irq_on
,
270 /* Generic PATA PCI ATA helpers */
271 .port_start
= pacpi_port_start
,
276 * pacpi_init_one - Register ACPI ATA PCI device with kernel services
277 * @pdev: PCI device to register
278 * @ent: Entry in pacpi_pci_tbl matching with @pdev
280 * Called from kernel PCI layer.
283 * Inherited from PCI layer (may sleep).
286 * Zero on success, or -ERRNO value.
289 static int pacpi_init_one (struct pci_dev
*pdev
, const struct pci_device_id
*id
)
291 static const struct ata_port_info info
= {
293 .flags
= ATA_FLAG_SLAVE_POSS
| ATA_FLAG_SRST
,
299 .port_ops
= &pacpi_ops
,
301 const struct ata_port_info
*ppi
[] = { &info
, NULL
};
302 return ata_pci_init_one(pdev
, ppi
);
305 static const struct pci_device_id pacpi_pci_tbl
[] = {
306 { PCI_ANY_ID
, PCI_ANY_ID
, PCI_ANY_ID
, PCI_ANY_ID
, PCI_CLASS_STORAGE_IDE
<< 8, 0xFFFFFF00UL
, 1},
307 { } /* terminate list */
310 static struct pci_driver pacpi_pci_driver
= {
312 .id_table
= pacpi_pci_tbl
,
313 .probe
= pacpi_init_one
,
314 .remove
= ata_pci_remove_one
,
316 .suspend
= ata_pci_device_suspend
,
317 .resume
= ata_pci_device_resume
,
321 static int __init
pacpi_init(void)
323 return pci_register_driver(&pacpi_pci_driver
);
326 static void __exit
pacpi_exit(void)
328 pci_unregister_driver(&pacpi_pci_driver
);
331 module_init(pacpi_init
);
332 module_exit(pacpi_exit
);
334 MODULE_AUTHOR("Alan Cox");
335 MODULE_DESCRIPTION("SCSI low-level driver for ATA in ACPI mode");
336 MODULE_LICENSE("GPL");
337 MODULE_DEVICE_TABLE(pci
, pacpi_pci_tbl
);
338 MODULE_VERSION(DRV_VERSION
);