blob: 40ae11cbfda43b5f43207aa6a3e6d8983e873ba5 [file] [log] [blame]
Paul Mundta20c9e82006-10-27 19:08:48 -07001/*
2 * Generic platform device PATA driver
3 *
4 * Copyright (C) 2006 Paul Mundt
5 *
6 * Based on pata_pcmcia:
7 *
8 * Copyright 2005-2006 Red Hat Inc <alan@redhat.com>, all rights reserved.
9 *
10 * This file is subject to the terms and conditions of the GNU General Public
11 * License. See the file "COPYING" in the main directory of this archive
12 * for more details.
13 */
14#include <linux/kernel.h>
15#include <linux/module.h>
16#include <linux/init.h>
17#include <linux/blkdev.h>
18#include <scsi/scsi_host.h>
19#include <linux/ata.h>
20#include <linux/libata.h>
21#include <linux/platform_device.h>
22#include <linux/pata_platform.h>
23
24#define DRV_NAME "pata_platform"
25#define DRV_VERSION "0.1.2"
26
27static int pio_mask = 1;
28
29/*
30 * Provide our own set_mode() as we don't want to change anything that has
31 * already been configured..
32 */
Al Viro161c8882007-01-30 13:23:45 +000033static int pata_platform_set_mode(struct ata_port *ap, struct ata_device **unused)
Paul Mundta20c9e82006-10-27 19:08:48 -070034{
35 int i;
36
37 for (i = 0; i < ATA_MAX_DEVICES; i++) {
38 struct ata_device *dev = &ap->device[i];
39
40 if (ata_dev_enabled(dev)) {
41 /* We don't really care */
42 dev->pio_mode = dev->xfer_mode = XFER_PIO_0;
43 dev->xfer_shift = ATA_SHIFT_PIO;
44 dev->flags |= ATA_DFLAG_PIO;
45 }
46 }
Al Viro161c8882007-01-30 13:23:45 +000047 return 0;
Paul Mundta20c9e82006-10-27 19:08:48 -070048}
49
50static void pata_platform_host_stop(struct ata_host *host)
51{
52 int i;
53
54 /*
55 * Unmap the bases for MMIO
56 */
57 for (i = 0; i < host->n_ports; i++) {
58 struct ata_port *ap = host->ports[i];
59
60 if (ap->flags & ATA_FLAG_MMIO) {
61 iounmap((void __iomem *)ap->ioaddr.ctl_addr);
62 iounmap((void __iomem *)ap->ioaddr.cmd_addr);
63 }
64 }
65}
66
67static struct scsi_host_template pata_platform_sht = {
68 .module = THIS_MODULE,
69 .name = DRV_NAME,
70 .ioctl = ata_scsi_ioctl,
71 .queuecommand = ata_scsi_queuecmd,
72 .can_queue = ATA_DEF_QUEUE,
73 .this_id = ATA_SHT_THIS_ID,
74 .sg_tablesize = LIBATA_MAX_PRD,
Paul Mundta20c9e82006-10-27 19:08:48 -070075 .cmd_per_lun = ATA_SHT_CMD_PER_LUN,
76 .emulated = ATA_SHT_EMULATED,
77 .use_clustering = ATA_SHT_USE_CLUSTERING,
78 .proc_name = DRV_NAME,
79 .dma_boundary = ATA_DMA_BOUNDARY,
80 .slave_configure = ata_scsi_slave_config,
Tejun Heoc972b602006-11-29 12:10:46 +090081 .slave_destroy = ata_scsi_slave_destroy,
Paul Mundta20c9e82006-10-27 19:08:48 -070082 .bios_param = ata_std_bios_param,
83};
84
85static struct ata_port_operations pata_platform_port_ops = {
86 .set_mode = pata_platform_set_mode,
87
88 .port_disable = ata_port_disable,
89 .tf_load = ata_tf_load,
90 .tf_read = ata_tf_read,
91 .check_status = ata_check_status,
92 .exec_command = ata_exec_command,
93 .dev_select = ata_std_dev_select,
94
95 .freeze = ata_bmdma_freeze,
96 .thaw = ata_bmdma_thaw,
97 .error_handler = ata_bmdma_error_handler,
98 .post_internal_cmd = ata_bmdma_post_internal_cmd,
99
100 .qc_prep = ata_qc_prep,
101 .qc_issue = ata_qc_issue_prot,
102
103 .data_xfer = ata_pio_data_xfer_noirq,
104
105 .irq_handler = ata_interrupt,
106 .irq_clear = ata_bmdma_irq_clear,
107
108 .port_start = ata_port_start,
109 .port_stop = ata_port_stop,
110 .host_stop = pata_platform_host_stop
111};
112
113static void pata_platform_setup_port(struct ata_ioports *ioaddr,
114 struct pata_platform_info *info)
115{
116 unsigned int shift = 0;
117
118 /* Fixup the port shift for platforms that need it */
119 if (info && info->ioport_shift)
120 shift = info->ioport_shift;
121
122 ioaddr->data_addr = ioaddr->cmd_addr + (ATA_REG_DATA << shift);
123 ioaddr->error_addr = ioaddr->cmd_addr + (ATA_REG_ERR << shift);
124 ioaddr->feature_addr = ioaddr->cmd_addr + (ATA_REG_FEATURE << shift);
125 ioaddr->nsect_addr = ioaddr->cmd_addr + (ATA_REG_NSECT << shift);
126 ioaddr->lbal_addr = ioaddr->cmd_addr + (ATA_REG_LBAL << shift);
127 ioaddr->lbam_addr = ioaddr->cmd_addr + (ATA_REG_LBAM << shift);
128 ioaddr->lbah_addr = ioaddr->cmd_addr + (ATA_REG_LBAH << shift);
129 ioaddr->device_addr = ioaddr->cmd_addr + (ATA_REG_DEVICE << shift);
130 ioaddr->status_addr = ioaddr->cmd_addr + (ATA_REG_STATUS << shift);
131 ioaddr->command_addr = ioaddr->cmd_addr + (ATA_REG_CMD << shift);
132}
133
134/**
135 * pata_platform_probe - attach a platform interface
136 * @pdev: platform device
137 *
138 * Register a platform bus IDE interface. Such interfaces are PIO and we
139 * assume do not support IRQ sharing.
140 *
141 * Platform devices are expected to contain 3 resources per port:
142 *
143 * - I/O Base (IORESOURCE_IO or IORESOURCE_MEM)
144 * - CTL Base (IORESOURCE_IO or IORESOURCE_MEM)
145 * - IRQ (IORESOURCE_IRQ)
146 *
147 * If the base resources are both mem types, the ioremap() is handled
148 * here. For IORESOURCE_IO, it's assumed that there's no remapping
149 * necessary.
150 */
151static int __devinit pata_platform_probe(struct platform_device *pdev)
152{
153 struct resource *io_res, *ctl_res;
154 struct ata_probe_ent ae;
155 unsigned int mmio;
156 int ret;
157
158 /*
159 * Simple resource validation ..
160 */
161 if (unlikely(pdev->num_resources != 3)) {
162 dev_err(&pdev->dev, "invalid number of resources\n");
163 return -EINVAL;
164 }
165
166 /*
167 * Get the I/O base first
168 */
169 io_res = platform_get_resource(pdev, IORESOURCE_IO, 0);
170 if (io_res == NULL) {
171 io_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
172 if (unlikely(io_res == NULL))
173 return -EINVAL;
174 }
175
176 /*
177 * Then the CTL base
178 */
179 ctl_res = platform_get_resource(pdev, IORESOURCE_IO, 1);
180 if (ctl_res == NULL) {
181 ctl_res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
182 if (unlikely(ctl_res == NULL))
183 return -EINVAL;
184 }
185
186 /*
187 * Check for MMIO
188 */
189 mmio = (( io_res->flags == IORESOURCE_MEM) &&
190 (ctl_res->flags == IORESOURCE_MEM));
191
192 /*
193 * Now that that's out of the way, wire up the port..
194 */
195 memset(&ae, 0, sizeof(struct ata_probe_ent));
196 INIT_LIST_HEAD(&ae.node);
197 ae.dev = &pdev->dev;
198 ae.port_ops = &pata_platform_port_ops;
199 ae.sht = &pata_platform_sht;
200 ae.n_ports = 1;
201 ae.pio_mask = pio_mask;
202 ae.irq = platform_get_irq(pdev, 0);
203 ae.irq_flags = 0;
204 ae.port_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST;
205
206 /*
207 * Handle the MMIO case
208 */
209 if (mmio) {
210 ae.port_flags |= ATA_FLAG_MMIO;
211
212 ae.port[0].cmd_addr = (unsigned long)ioremap(io_res->start,
213 io_res->end - io_res->start + 1);
214 if (unlikely(!ae.port[0].cmd_addr)) {
215 dev_err(&pdev->dev, "failed to remap IO base\n");
216 return -ENXIO;
217 }
218
219 ae.port[0].ctl_addr = (unsigned long)ioremap(ctl_res->start,
220 ctl_res->end - ctl_res->start + 1);
221 if (unlikely(!ae.port[0].ctl_addr)) {
222 dev_err(&pdev->dev, "failed to remap CTL base\n");
223 ret = -ENXIO;
224 goto bad_remap;
225 }
226 } else {
227 ae.port[0].cmd_addr = io_res->start;
228 ae.port[0].ctl_addr = ctl_res->start;
229 }
230
231 ae.port[0].altstatus_addr = ae.port[0].ctl_addr;
232
233 pata_platform_setup_port(&ae.port[0], pdev->dev.platform_data);
234
235 if (unlikely(ata_device_add(&ae) == 0)) {
236 ret = -ENODEV;
237 goto add_failed;
238 }
239
240 return 0;
241
242add_failed:
243 if (ae.port[0].ctl_addr && mmio)
244 iounmap((void __iomem *)ae.port[0].ctl_addr);
245bad_remap:
246 if (ae.port[0].cmd_addr && mmio)
247 iounmap((void __iomem *)ae.port[0].cmd_addr);
248
249 return ret;
250}
251
252/**
253 * pata_platform_remove - unplug a platform interface
254 * @pdev: platform device
255 *
256 * A platform bus ATA device has been unplugged. Perform the needed
257 * cleanup. Also called on module unload for any active devices.
258 */
259static int __devexit pata_platform_remove(struct platform_device *pdev)
260{
261 struct device *dev = &pdev->dev;
262 struct ata_host *host = dev_get_drvdata(dev);
263
264 ata_host_remove(host);
265 dev_set_drvdata(dev, NULL);
266
267 return 0;
268}
269
270static struct platform_driver pata_platform_driver = {
271 .probe = pata_platform_probe,
272 .remove = __devexit_p(pata_platform_remove),
273 .driver = {
274 .name = DRV_NAME,
275 .owner = THIS_MODULE,
276 },
277};
278
279static int __init pata_platform_init(void)
280{
281 return platform_driver_register(&pata_platform_driver);
282}
283
284static void __exit pata_platform_exit(void)
285{
286 platform_driver_unregister(&pata_platform_driver);
287}
288module_init(pata_platform_init);
289module_exit(pata_platform_exit);
290
291module_param(pio_mask, int, 0);
292
293MODULE_AUTHOR("Paul Mundt");
294MODULE_DESCRIPTION("low-level driver for platform device ATA");
295MODULE_LICENSE("GPL");
296MODULE_VERSION(DRV_VERSION);