[mirror_ubuntu-artful-kernel.git] / drivers / ata / pata_ixp4xx_cf.c

/*
 * ixp4xx PATA/Compact Flash driver
 * Copyright (c) 2006 Tower Technologies
 * Author: Alessandro Zummo <a.zummo@towertech.it>
 *
 * An ATA driver to handle a Compact Flash connected
 * to the ixp4xx expansion bus in TrueIDE mode. The CF
 * must have it chip selects connected to two CS lines
 * on the ixp4xx. The interrupt line is optional, if not
 * specified the driver will run in polling mode.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/libata.h>
#include <linux/irq.h>
#include <linux/platform_device.h>
#include <scsi/scsi_host.h>

#define DRV_NAME	"pata_ixp4xx_cf"
#define DRV_VERSION	"0.1.1"

static void ixp4xx_set_mode(struct ata_port *ap)
{
	int i;

	for (i = 0; i < ATA_MAX_DEVICES; i++) {
		struct ata_device *dev = &ap->device[i];
		if (ata_dev_enabled(dev)) {
			dev->pio_mode = XFER_PIO_0;
			dev->xfer_mode = XFER_PIO_0;
			dev->xfer_shift = ATA_SHIFT_PIO;
			dev->flags |= ATA_DFLAG_PIO;
		}
	}
}

static void ixp4xx_phy_reset(struct ata_port *ap)
{
	ap->cbl = ATA_CBL_PATA40;
	ata_port_probe(ap);
	ata_bus_reset(ap);
}

static void ixp4xx_mmio_data_xfer(struct ata_device *adev, unsigned char *buf,
				unsigned int buflen, int write_data)
{
	unsigned int i;
	unsigned int words = buflen >> 1;
	u16 *buf16 = (u16 *) buf;
	struct ata_port *ap = adev->ap;
	void __iomem *mmio = (void __iomem *)ap->ioaddr.data_addr;
	struct ixp4xx_pata_data *data = ap->host->dev->platform_data;

	/* set the expansion bus in 16bit mode and restore
	 * 8 bit mode after the transaction.
	 */
	*data->cs0_cfg &= ~(0x01);
	udelay(100);

	/* Transfer multiple of 2 bytes */
	if (write_data) {
		for (i = 0; i < words; i++)
			writew(buf16[i], mmio);
	} else {
		for (i = 0; i < words; i++)
			buf16[i] = readw(mmio);
	}

	/* Transfer trailing 1 byte, if any. */
	if (unlikely(buflen & 0x01)) {
		u16 align_buf[1] = { 0 };
		unsigned char *trailing_buf = buf + buflen - 1;

		if (write_data) {
			memcpy(align_buf, trailing_buf, 1);
			writew(align_buf[0], mmio);
		} else {
			align_buf[0] = readw(mmio);
			memcpy(trailing_buf, align_buf, 1);
		}
	}

	udelay(100);
	*data->cs0_cfg |= 0x01;
}

static void ixp4xx_irq_clear(struct ata_port *ap)
{
}

static void ixp4xx_host_stop (struct ata_host *host)
{
	struct ixp4xx_pata_data *data = host->dev->platform_data;

	iounmap(data->cs0);
	iounmap(data->cs1);
}

static struct scsi_host_template ixp4xx_sht = {
	.module			= THIS_MODULE,
	.name			= DRV_NAME,
	.ioctl			= ata_scsi_ioctl,
	.queuecommand		= ata_scsi_queuecmd,
	.can_queue		= ATA_DEF_QUEUE,
	.this_id		= ATA_SHT_THIS_ID,
	.sg_tablesize		= LIBATA_MAX_PRD,
	.max_sectors		= ATA_MAX_SECTORS,
	.cmd_per_lun		= ATA_SHT_CMD_PER_LUN,
	.emulated		= ATA_SHT_EMULATED,
	.use_clustering		= ATA_SHT_USE_CLUSTERING,
	.proc_name		= DRV_NAME,
	.dma_boundary		= ATA_DMA_BOUNDARY,
	.slave_configure	= ata_scsi_slave_config,
	.bios_param		= ata_std_bios_param,
};

static struct ata_port_operations ixp4xx_port_ops = {
	.set_mode	= ixp4xx_set_mode,
	.mode_filter	= ata_pci_default_filter,

	.port_disable	= ata_port_disable,
	.tf_load	= ata_tf_load,
	.tf_read	= ata_tf_read,
	.check_status 	= ata_check_status,
	.exec_command	= ata_exec_command,
	.dev_select 	= ata_std_dev_select,

	.qc_prep 	= ata_qc_prep,
	.qc_issue	= ata_qc_issue_prot,
	.eng_timeout	= ata_eng_timeout,
	.data_xfer	= ixp4xx_mmio_data_xfer,

	.irq_handler	= ata_interrupt,
	.irq_clear	= ixp4xx_irq_clear,

	.port_start	= ata_port_start,
	.port_stop	= ata_port_stop,
	.host_stop	= ixp4xx_host_stop,

	.phy_reset	= ixp4xx_phy_reset,
};

static void ixp4xx_setup_port(struct ata_ioports *ioaddr,
				struct ixp4xx_pata_data *data)
{
	ioaddr->cmd_addr	= (unsigned long) data->cs0;
	ioaddr->altstatus_addr	= (unsigned long) data->cs1 + 0x06;
	ioaddr->ctl_addr	= (unsigned long) data->cs1 + 0x06;

	ata_std_ports(ioaddr);

#ifndef __ARMEB__

	/* adjust the addresses to handle the address swizzling of the
	 * ixp4xx in little endian mode.
	 */

	ioaddr->data_addr	^= 0x02;
	ioaddr->cmd_addr	^= 0x03;
	ioaddr->altstatus_addr	^= 0x03;
	ioaddr->ctl_addr	^= 0x03;
	ioaddr->error_addr	^= 0x03;
	ioaddr->feature_addr	^= 0x03;
	ioaddr->nsect_addr	^= 0x03;
	ioaddr->lbal_addr 	^= 0x03;
	ioaddr->lbam_addr	^= 0x03;
	ioaddr->lbah_addr	^= 0x03;
	ioaddr->device_addr	^= 0x03;
	ioaddr->status_addr	^= 0x03;
	ioaddr->command_addr	^= 0x03;
#endif
}

static __devinit int ixp4xx_pata_probe(struct platform_device *pdev)
{
	int ret;
	unsigned int irq;
	struct resource *cs0, *cs1;
	struct ata_probe_ent ae;

	struct ixp4xx_pata_data *data = pdev->dev.platform_data;

	cs0 = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	cs1 = platform_get_resource(pdev, IORESOURCE_MEM, 1);

	if (!cs0 || !cs1)
		return -EINVAL;

	pdev->dev.coherent_dma_mask = DMA_32BIT_MASK;

	data->cs0 = ioremap(cs0->start, 0x1000);
	data->cs1 = ioremap(cs1->start, 0x1000);

	irq = platform_get_irq(pdev, 0);
	if (irq)
		set_irq_type(irq, IRQT_HIGH);

	/* Setup expansion bus chip selects */
	*data->cs0_cfg = data->cs0_bits;
	*data->cs1_cfg = data->cs1_bits;

	memset(&ae, 0, sizeof(struct ata_probe_ent));
	INIT_LIST_HEAD(&ae.node);

	ae.dev		= &pdev->dev;
	ae.port_ops	= &ixp4xx_port_ops;
	ae.sht		= &ixp4xx_sht;
	ae.n_ports	= 1;
	ae.pio_mask	= 0x1f; /* PIO4 */
	ae.irq		= irq;
	ae.irq_flags	= 0;
	ae.port_flags	= ATA_FLAG_MMIO | ATA_FLAG_NO_LEGACY
			| ATA_FLAG_NO_ATAPI | ATA_FLAG_SRST;

	/* run in polling mode if no irq has been assigned */
	if (!irq)
		ae.port_flags |= ATA_FLAG_PIO_POLLING;

	ixp4xx_setup_port(&ae.port[0], data);

	dev_printk(KERN_INFO, &pdev->dev, "version " DRV_VERSION "\n");

	ret = ata_device_add(&ae);
	if (ret == 0)
		return -ENODEV;

	return 0;
}

static __devexit int ixp4xx_pata_remove(struct platform_device *dev)
{
	struct ata_host *host = platform_get_drvdata(dev);

	ata_host_remove(host);
	platform_set_drvdata(dev, NULL);

	return 0;
}

static struct platform_driver ixp4xx_pata_platform_driver = {
	.driver	 = {
		.name   = DRV_NAME,
		.owner  = THIS_MODULE,
	},
	.probe		= ixp4xx_pata_probe,
	.remove		= __devexit_p(ixp4xx_pata_remove),
};

static int __init ixp4xx_pata_init(void)
{
	return platform_driver_register(&ixp4xx_pata_platform_driver);
}

static void __exit ixp4xx_pata_exit(void)
{
	platform_driver_unregister(&ixp4xx_pata_platform_driver);
}

MODULE_AUTHOR("Alessandro Zummo <a.zummo@towertech.it>");
MODULE_DESCRIPTION("low-level driver for ixp4xx Compact Flash PATA");
MODULE_LICENSE("GPL");
MODULE_VERSION(DRV_VERSION);

module_init(ixp4xx_pata_init);
module_exit(ixp4xx_pata_exit);
Commit	Line	Data
0df0d0a0 AZ	1	/*
	2	* ixp4xx PATA/Compact Flash driver
	3	* Copyright (c) 2006 Tower Technologies
	4	* Author: Alessandro Zummo <a.zummo@towertech.it>
	5	*
	6	* An ATA driver to handle a Compact Flash connected
	7	* to the ixp4xx expansion bus in TrueIDE mode. The CF
	8	* must have it chip selects connected to two CS lines
	9	* on the ixp4xx. The interrupt line is optional, if not
	10	* specified the driver will run in polling mode.
	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 version 2 as
	14	* published by the Free Software Foundation.
	15	*
	16	*/
	17
	18	#include <linux/kernel.h>
	19	#include <linux/module.h>
	20	#include <linux/libata.h>
	21	#include <linux/irq.h>
	22	#include <linux/platform_device.h>
	23	#include <scsi/scsi_host.h>
	24
	25	#define DRV_NAME "pata_ixp4xx_cf"
	26	#define DRV_VERSION "0.1.1"
	27
	28	static void ixp4xx_set_mode(struct ata_port *ap)
	29	{
	30	int i;
	31
	32	for (i = 0; i < ATA_MAX_DEVICES; i++) {
	33	struct ata_device *dev = &ap->device[i];
	34	if (ata_dev_enabled(dev)) {
	35	dev->pio_mode = XFER_PIO_0;
	36	dev->xfer_mode = XFER_PIO_0;
	37	dev->xfer_shift = ATA_SHIFT_PIO;
	38	dev->flags \|= ATA_DFLAG_PIO;
	39	}
	40	}
	41	}
	42
	43	static void ixp4xx_phy_reset(struct ata_port *ap)
	44	{
	45	ap->cbl = ATA_CBL_PATA40;
	46	ata_port_probe(ap);
	47	ata_bus_reset(ap);
	48	}
	49
	50	static void ixp4xx_mmio_data_xfer(struct ata_device adev, unsigned char buf,
	51	unsigned int buflen, int write_data)
	52	{
	53	unsigned int i;
	54	unsigned int words = buflen >> 1;
	55	u16 buf16 = (u16 ) buf;
	56	struct ata_port *ap = adev->ap;
	57	void __iomem mmio = (void __iomem )ap->ioaddr.data_addr;
	58	struct ixp4xx_pata_data *data = ap->host->dev->platform_data;
	59
	60	/* set the expansion bus in 16bit mode and restore
	61	* 8 bit mode after the transaction.
	62	*/
	63	*data->cs0_cfg &= ~(0x01);
	64	udelay(100);
65
66	/* Transfer multiple of 2 bytes */
67	if (write_data) {
68	for (i = 0; i < words; i++)
69	writew(buf16[i], mmio);
70	} else {
71	for (i = 0; i < words; i++)
72	buf16[i] = readw(mmio);
73	}
74
75	/* Transfer trailing 1 byte, if any. */
76	if (unlikely(buflen & 0x01)) {
77	u16 align_buf[1] = { 0 };
78	unsigned char *trailing_buf = buf + buflen - 1;
79
80	if (write_data) {
81	memcpy(align_buf, trailing_buf, 1);
82	writew(align_buf[0], mmio);
83	} else {
84	align_buf[0] = readw(mmio);
85	memcpy(trailing_buf, align_buf, 1);
86	}
87	}
88
89	udelay(100);
90	*data->cs0_cfg \|= 0x01;
91	}
92
93	static void ixp4xx_irq_clear(struct ata_port *ap)
94	{
95	}
96
97	static void ixp4xx_host_stop (struct ata_host *host)
98	{
99	struct ixp4xx_pata_data *data = host->dev->platform_data;
100
101	iounmap(data->cs0);
102	iounmap(data->cs1);
103	}
104
105	static struct scsi_host_template ixp4xx_sht = {
106	.module = THIS_MODULE,
107	.name = DRV_NAME,
108	.ioctl = ata_scsi_ioctl,
109	.queuecommand = ata_scsi_queuecmd,
110	.can_queue = ATA_DEF_QUEUE,
111	.this_id = ATA_SHT_THIS_ID,
112	.sg_tablesize = LIBATA_MAX_PRD,
113	.max_sectors = ATA_MAX_SECTORS,
114	.cmd_per_lun = ATA_SHT_CMD_PER_LUN,
115	.emulated = ATA_SHT_EMULATED,
116	.use_clustering = ATA_SHT_USE_CLUSTERING,
117	.proc_name = DRV_NAME,
118	.dma_boundary = ATA_DMA_BOUNDARY,
119	.slave_configure = ata_scsi_slave_config,
120	.bios_param = ata_std_bios_param,
121	};
122
123	static struct ata_port_operations ixp4xx_port_ops = {
124	.set_mode = ixp4xx_set_mode,
125	.mode_filter = ata_pci_default_filter,
126
127	.port_disable = ata_port_disable,
128	.tf_load = ata_tf_load,
129	.tf_read = ata_tf_read,
130	.check_status = ata_check_status,
131	.exec_command = ata_exec_command,
132	.dev_select = ata_std_dev_select,
133
134	.qc_prep = ata_qc_prep,
135	.qc_issue = ata_qc_issue_prot,
136	.eng_timeout = ata_eng_timeout,
137	.data_xfer = ixp4xx_mmio_data_xfer,
138
139	.irq_handler = ata_interrupt,
140	.irq_clear = ixp4xx_irq_clear,
141
142	.port_start = ata_port_start,
143	.port_stop = ata_port_stop,
144	.host_stop = ixp4xx_host_stop,
145
146	.phy_reset = ixp4xx_phy_reset,
147	};
148
149	static void ixp4xx_setup_port(struct ata_ioports *ioaddr,
150	struct ixp4xx_pata_data *data)
151	{
152	ioaddr->cmd_addr = (unsigned long) data->cs0;
153	ioaddr->altstatus_addr = (unsigned long) data->cs1 + 0x06;
154	ioaddr->ctl_addr = (unsigned long) data->cs1 + 0x06;
155
156	ata_std_ports(ioaddr);
157
158	#ifndef __ARMEB__
159
160	/* adjust the addresses to handle the address swizzling of the
161	* ixp4xx in little endian mode.
162	*/
163
164	ioaddr->data_addr ^= 0x02;
165	ioaddr->cmd_addr ^= 0x03;
166	ioaddr->altstatus_addr ^= 0x03;
167	ioaddr->ctl_addr ^= 0x03;
168	ioaddr->error_addr ^= 0x03;
169	ioaddr->feature_addr ^= 0x03;
170	ioaddr->nsect_addr ^= 0x03;
171	ioaddr->lbal_addr ^= 0x03;
172	ioaddr->lbam_addr ^= 0x03;
173	ioaddr->lbah_addr ^= 0x03;
174	ioaddr->device_addr ^= 0x03;
175	ioaddr->status_addr ^= 0x03;
176	ioaddr->command_addr ^= 0x03;
177	#endif
178	}
179
180	static __devinit int ixp4xx_pata_probe(struct platform_device *pdev)
181	{
182	int ret;
183	unsigned int irq;
184	struct resource cs0, cs1;
185	struct ata_probe_ent ae;
186
187	struct ixp4xx_pata_data *data = pdev->dev.platform_data;
188
189	cs0 = platform_get_resource(pdev, IORESOURCE_MEM, 0);
190	cs1 = platform_get_resource(pdev, IORESOURCE_MEM, 1);
191
192	if (!cs0 \|\| !cs1)
193	return -EINVAL;
194
195	pdev->dev.coherent_dma_mask = DMA_32BIT_MASK;
196
197	data->cs0 = ioremap(cs0->start, 0x1000);
198	data->cs1 = ioremap(cs1->start, 0x1000);
199
200	irq = platform_get_irq(pdev, 0);
201	if (irq)
202	set_irq_type(irq, IRQT_HIGH);
203
204	/* Setup expansion bus chip selects */
205	*data->cs0_cfg = data->cs0_bits;
206	*data->cs1_cfg = data->cs1_bits;
207
208	memset(&ae, 0, sizeof(struct ata_probe_ent));
209	INIT_LIST_HEAD(&ae.node);
210
211	ae.dev = &pdev->dev;
212	ae.port_ops = &ixp4xx_port_ops;
213	ae.sht = &ixp4xx_sht;
214	ae.n_ports = 1;
215	ae.pio_mask = 0x1f; /* PIO4 */
216	ae.irq = irq;
217	ae.irq_flags = 0;
218	ae.port_flags = ATA_FLAG_MMIO \| ATA_FLAG_NO_LEGACY
219	\| ATA_FLAG_NO_ATAPI \| ATA_FLAG_SRST;
220
221	/* run in polling mode if no irq has been assigned */
222	if (!irq)
223	ae.port_flags \|= ATA_FLAG_PIO_POLLING;
224
225	ixp4xx_setup_port(&ae.port[0], data);
226
227	dev_printk(KERN_INFO, &pdev->dev, "version " DRV_VERSION "\n");
228
229	ret = ata_device_add(&ae);
230	if (ret == 0)
231	return -ENODEV;
232
233	return 0;
234	}
235
236	static __devexit int ixp4xx_pata_remove(struct platform_device *dev)
237	{
238	struct ata_host *host = platform_get_drvdata(dev);
239
240	ata_host_remove(host);
241	platform_set_drvdata(dev, NULL);
242
243	return 0;
244	}
245
246	static struct platform_driver ixp4xx_pata_platform_driver = {
247	.driver = {
248	.name = DRV_NAME,
249	.owner = THIS_MODULE,
250	},
251	.probe = ixp4xx_pata_probe,
252	.remove = __devexit_p(ixp4xx_pata_remove),
253	};
254
255	static int __init ixp4xx_pata_init(void)
256	{
257	return platform_driver_register(&ixp4xx_pata_platform_driver);
258	}
259
260	static void __exit ixp4xx_pata_exit(void)
261	{
262	platform_driver_unregister(&ixp4xx_pata_platform_driver);
263	}
264
265	MODULE_AUTHOR("Alessandro Zummo <a.zummo@towertech.it>");
266	MODULE_DESCRIPTION("low-level driver for ixp4xx Compact Flash PATA");
267	MODULE_LICENSE("GPL");
268	MODULE_VERSION(DRV_VERSION);
269
270	module_init(ixp4xx_pata_init);
271	module_exit(ixp4xx_pata_exit);