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

/*
 * ixp4xx PATA/Compact Flash driver
 * Copyright (C) 2006-07 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. In the irq is not available, you might
 * want to modify both this driver and libata to 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.2"

static int ixp4xx_set_mode(struct ata_link *link, struct ata_device **error)
{
	struct ata_device *dev;

	ata_link_for_each_dev(dev, link) {
		if (ata_dev_enabled(dev)) {
			ata_dev_printk(dev, KERN_INFO, "configured for PIO0\n");
			dev->pio_mode = XFER_PIO_0;
			dev->xfer_mode = XFER_PIO_0;
			dev->xfer_shift = ATA_SHIFT_PIO;
			dev->flags |= ATA_DFLAG_PIO;
		}
	}
	return 0;
}

static unsigned int ixp4xx_mmio_data_xfer(struct ata_device *dev,
				unsigned char *buf, unsigned int buflen, int rw)
{
	unsigned int i;
	unsigned int words = buflen >> 1;
	u16 *buf16 = (u16 *) buf;
	struct ata_port *ap = dev->link->ap;
	void __iomem *mmio = 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 (rw == READ)
		for (i = 0; i < words; i++)
			buf16[i] = readw(mmio);
	else
		for (i = 0; i < words; i++)
			writew(buf16[i], mmio);

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

		if (rw == READ) {
			align_buf[0] = readw(mmio);
			memcpy(trailing_buf, align_buf, 1);
		} else {
			memcpy(align_buf, trailing_buf, 1);
			writew(align_buf[0], mmio);
		}
		words++;
	}

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

	return words << 1;
}

static struct scsi_host_template ixp4xx_sht = {
	ATA_PIO_SHT(DRV_NAME),
};

static struct ata_port_operations ixp4xx_port_ops = {
	.inherits		= &ata_sff_port_ops,
	.sff_data_xfer		= ixp4xx_mmio_data_xfer,
	.cable_detect		= ata_cable_40wire,
	.set_mode		= ixp4xx_set_mode,
};

static void ixp4xx_setup_port(struct ata_port *ap,
			      struct ixp4xx_pata_data *data,
			      unsigned long raw_cs0, unsigned long raw_cs1)
{
	struct ata_ioports *ioaddr = &ap->ioaddr;
	unsigned long raw_cmd = raw_cs0;
	unsigned long raw_ctl = raw_cs1 + 0x06;

	ioaddr->cmd_addr	= data->cs0;
	ioaddr->altstatus_addr	= data->cs1 + 0x06;
	ioaddr->ctl_addr	= data->cs1 + 0x06;

	ata_sff_std_ports(ioaddr);

#ifndef __ARMEB__

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

	*(unsigned long *)&ioaddr->data_addr		^= 0x02;
	*(unsigned long *)&ioaddr->cmd_addr		^= 0x03;
	*(unsigned long *)&ioaddr->altstatus_addr	^= 0x03;
	*(unsigned long *)&ioaddr->ctl_addr		^= 0x03;
	*(unsigned long *)&ioaddr->error_addr		^= 0x03;
	*(unsigned long *)&ioaddr->feature_addr		^= 0x03;
	*(unsigned long *)&ioaddr->nsect_addr		^= 0x03;
	*(unsigned long *)&ioaddr->lbal_addr		^= 0x03;
	*(unsigned long *)&ioaddr->lbam_addr		^= 0x03;
	*(unsigned long *)&ioaddr->lbah_addr		^= 0x03;
	*(unsigned long *)&ioaddr->device_addr		^= 0x03;
	*(unsigned long *)&ioaddr->status_addr		^= 0x03;
	*(unsigned long *)&ioaddr->command_addr		^= 0x03;

	raw_cmd ^= 0x03;
	raw_ctl ^= 0x03;
#endif

	ata_port_desc(ap, "cmd 0x%lx ctl 0x%lx", raw_cmd, raw_ctl);
}

static __devinit int ixp4xx_pata_probe(struct platform_device *pdev)
{
	unsigned int irq;
	struct resource *cs0, *cs1;
	struct ata_host *host;
	struct ata_port *ap;
	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;

	/* allocate host */
	host = ata_host_alloc(&pdev->dev, 1);
	if (!host)
		return -ENOMEM;

	/* acquire resources and fill host */
	pdev->dev.coherent_dma_mask = DMA_32BIT_MASK;

	data->cs0 = devm_ioremap(&pdev->dev, cs0->start, 0x1000);
	data->cs1 = devm_ioremap(&pdev->dev, cs1->start, 0x1000);

	if (!data->cs0 || !data->cs1)
		return -ENOMEM;

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

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

	ap = host->ports[0];

	ap->ops	= &ixp4xx_port_ops;
	ap->pio_mask = 0x1f; /* PIO4 */
	ap->flags |= ATA_FLAG_MMIO | ATA_FLAG_NO_LEGACY | ATA_FLAG_NO_ATAPI;

	ixp4xx_setup_port(ap, data, cs0->start, cs1->start);

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

	/* activate host */
	return ata_host_activate(host, irq, ata_sff_interrupt, 0, &ixp4xx_sht);
}

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

	ata_host_detach(host);

	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_ALIAS("platform:" DRV_NAME);

module_init(ixp4xx_pata_init);
module_exit(ixp4xx_pata_exit);
Commit	Line	Data
0df0d0a0 AZ	1	/*
0df0d0a0 AZ	2	* ixp4xx PATA/Compact Flash driver
5d4c51f6	3	* Copyright (C) 2006-07 Tower Technologies
0df0d0a0 AZ	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
5d4c51f6 AZ	9	* on the ixp4xx. In the irq is not available, you might
	10	* want to modify both this driver and libata to run in
	11	* polling mode.
0df0d0a0 AZ	12	*
	13	* This program is free software; you can redistribute it and/or modify
	14	* it under the terms of the GNU General Public License version 2 as
	15	* published by the Free Software Foundation.
	16	*
	17	*/
	18
	19	#include <linux/kernel.h>
	20	#include <linux/module.h>
	21	#include <linux/libata.h>
	22	#include <linux/irq.h>
	23	#include <linux/platform_device.h>
	24	#include <scsi/scsi_host.h>
	25
	26	#define DRV_NAME "pata_ixp4xx_cf"
5d4c51f6	27	#define DRV_VERSION "0.2"
0df0d0a0	28
0260731f	29	static int ixp4xx_set_mode(struct ata_link link, struct ata_device *error)
0df0d0a0	30	{
f58229f8	31	struct ata_device *dev;
0df0d0a0	32
0260731f	33	ata_link_for_each_dev(dev, link) {
9666f400	34	if (ata_dev_enabled(dev)) {
3ddcc591	35	ata_dev_printk(dev, KERN_INFO, "configured for PIO0\n");
0df0d0a0 AZ	36	dev->pio_mode = XFER_PIO_0;
	37	dev->xfer_mode = XFER_PIO_0;
	38	dev->xfer_shift = ATA_SHIFT_PIO;
	39	dev->flags \|= ATA_DFLAG_PIO;
	40	}
	41	}
b229a7b0	42	return 0;
0df0d0a0 AZ	43	}
0df0d0a0 AZ	44
55dba312 TH	45	static unsigned int ixp4xx_mmio_data_xfer(struct ata_device *dev,
55dba312 TH	46	unsigned char *buf, unsigned int buflen, int rw)
0df0d0a0 AZ	47	{
	48	unsigned int i;
	49	unsigned int words = buflen >> 1;
	50	u16 buf16 = (u16 ) buf;
55dba312	51	struct ata_port *ap = dev->link->ap;
59f99880	52	void __iomem *mmio = ap->ioaddr.data_addr;
0df0d0a0 AZ	53	struct ixp4xx_pata_data *data = ap->host->dev->platform_data;
	54
	55	/* set the expansion bus in 16bit mode and restore
	56	* 8 bit mode after the transaction.
	57	*/
	58	*data->cs0_cfg &= ~(0x01);
	59	udelay(100);
	60
	61	/* Transfer multiple of 2 bytes */
55dba312	62	if (rw == READ)
0df0d0a0 AZ	63	for (i = 0; i < words; i++)
0df0d0a0 AZ	64	buf16[i] = readw(mmio);
55dba312 TH	65	else
	66	for (i = 0; i < words; i++)
	67	writew(buf16[i], mmio);
0df0d0a0 AZ	68
	69	/* Transfer trailing 1 byte, if any. */
	70	if (unlikely(buflen & 0x01)) {
	71	u16 align_buf[1] = { 0 };
	72	unsigned char *trailing_buf = buf + buflen - 1;
	73
55dba312	74	if (rw == READ) {
0df0d0a0 AZ	75	align_buf[0] = readw(mmio);
0df0d0a0 AZ	76	memcpy(trailing_buf, align_buf, 1);
55dba312 TH	77	} else {
	78	memcpy(align_buf, trailing_buf, 1);
	79	writew(align_buf[0], mmio);
0df0d0a0	80	}
55dba312	81	words++;
0df0d0a0 AZ	82	}
	83
	84	udelay(100);
	85	*data->cs0_cfg \|= 0x01;
55dba312 TH	86
55dba312 TH	87	return words << 1;
0df0d0a0 AZ	88	}
0df0d0a0 AZ	89
0df0d0a0	90	static struct scsi_host_template ixp4xx_sht = {
68d1d07b	91	ATA_PIO_SHT(DRV_NAME),
0df0d0a0 AZ	92	};
	93
	94	static struct ata_port_operations ixp4xx_port_ops = {
029cfd6b	95	.inherits = &ata_sff_port_ops,
5682ed33	96	.sff_data_xfer = ixp4xx_mmio_data_xfer,
5d4c51f6	97	.cable_detect = ata_cable_40wire,
029cfd6b	98	.set_mode = ixp4xx_set_mode,
0df0d0a0 AZ	99	};
0df0d0a0 AZ	100
af183748	101	static void ixp4xx_setup_port(struct ata_port *ap,
cbcdd875 TH	102	struct ixp4xx_pata_data *data,
cbcdd875 TH	103	unsigned long raw_cs0, unsigned long raw_cs1)
0df0d0a0	104	{
af183748	105	struct ata_ioports *ioaddr = &ap->ioaddr;
cbcdd875 TH	106	unsigned long raw_cmd = raw_cs0;
	107	unsigned long raw_ctl = raw_cs1 + 0x06;
	108
0d5ff566 TH	109	ioaddr->cmd_addr = data->cs0;
	110	ioaddr->altstatus_addr = data->cs1 + 0x06;
	111	ioaddr->ctl_addr = data->cs1 + 0x06;
0df0d0a0	112
9363c382	113	ata_sff_std_ports(ioaddr);
0df0d0a0 AZ	114
	115	#ifndef __ARMEB__
	116
	117	/* adjust the addresses to handle the address swizzling of the
	118	* ixp4xx in little endian mode.
	119	*/
	120
0d5ff566 TH	121	(unsigned long )&ioaddr->data_addr ^= 0x02;
	122	(unsigned long )&ioaddr->cmd_addr ^= 0x03;
	123	(unsigned long )&ioaddr->altstatus_addr ^= 0x03;
	124	(unsigned long )&ioaddr->ctl_addr ^= 0x03;
	125	(unsigned long )&ioaddr->error_addr ^= 0x03;
	126	(unsigned long )&ioaddr->feature_addr ^= 0x03;
	127	(unsigned long )&ioaddr->nsect_addr ^= 0x03;
	128	(unsigned long )&ioaddr->lbal_addr ^= 0x03;
	129	(unsigned long )&ioaddr->lbam_addr ^= 0x03;
	130	(unsigned long )&ioaddr->lbah_addr ^= 0x03;
	131	(unsigned long )&ioaddr->device_addr ^= 0x03;
	132	(unsigned long )&ioaddr->status_addr ^= 0x03;
	133	(unsigned long )&ioaddr->command_addr ^= 0x03;
cbcdd875 TH	134
	135	raw_cmd ^= 0x03;
	136	raw_ctl ^= 0x03;
0df0d0a0	137	#endif
cbcdd875 TH	138
cbcdd875 TH	139	ata_port_desc(ap, "cmd 0x%lx ctl 0x%lx", raw_cmd, raw_ctl);
0df0d0a0 AZ	140	}
	141
	142	static __devinit int ixp4xx_pata_probe(struct platform_device *pdev)
	143	{
0df0d0a0 AZ	144	unsigned int irq;
0df0d0a0 AZ	145	struct resource cs0, cs1;
5d728824 TH	146	struct ata_host *host;
5d728824 TH	147	struct ata_port *ap;
0df0d0a0 AZ	148	struct ixp4xx_pata_data *data = pdev->dev.platform_data;
	149
	150	cs0 = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	151	cs1 = platform_get_resource(pdev, IORESOURCE_MEM, 1);
	152
	153	if (!cs0 \|\| !cs1)
	154	return -EINVAL;
	155
5d728824 TH	156	/* allocate host */
	157	host = ata_host_alloc(&pdev->dev, 1);
	158	if (!host)
	159	return -ENOMEM;
	160
	161	/* acquire resources and fill host */
0df0d0a0 AZ	162	pdev->dev.coherent_dma_mask = DMA_32BIT_MASK;
0df0d0a0 AZ	163
24dc5f33 TH	164	data->cs0 = devm_ioremap(&pdev->dev, cs0->start, 0x1000);
24dc5f33 TH	165	data->cs1 = devm_ioremap(&pdev->dev, cs1->start, 0x1000);
0df0d0a0	166
991bf528 ST	167	if (!data->cs0 \|\| !data->cs1)
	168	return -ENOMEM;
	169
0df0d0a0 AZ	170	irq = platform_get_irq(pdev, 0);
0df0d0a0 AZ	171	if (irq)
282c6b9c	172	set_irq_type(irq, IRQT_RISING);
0df0d0a0 AZ	173
	174	/* Setup expansion bus chip selects */
	175	*data->cs0_cfg = data->cs0_bits;
	176	*data->cs1_cfg = data->cs1_bits;
	177
5d728824	178	ap = host->ports[0];
0df0d0a0	179
5d728824 TH	180	ap->ops = &ixp4xx_port_ops;
	181	ap->pio_mask = 0x1f; /* PIO4 */
	182	ap->flags \|= ATA_FLAG_MMIO \| ATA_FLAG_NO_LEGACY \| ATA_FLAG_NO_ATAPI;
0df0d0a0	183
cbcdd875	184	ixp4xx_setup_port(ap, data, cs0->start, cs1->start);
0df0d0a0 AZ	185
	186	dev_printk(KERN_INFO, &pdev->dev, "version " DRV_VERSION "\n");
	187
5d728824	188	/* activate host */
9363c382	189	return ata_host_activate(host, irq, ata_sff_interrupt, 0, &ixp4xx_sht);
0df0d0a0 AZ	190	}
	191
	192	static __devexit int ixp4xx_pata_remove(struct platform_device *dev)
	193	{
	194	struct ata_host *host = platform_get_drvdata(dev);
	195
24dc5f33	196	ata_host_detach(host);
0df0d0a0 AZ	197
	198	return 0;
	199	}
	200
	201	static struct platform_driver ixp4xx_pata_platform_driver = {
	202	.driver = {
	203	.name = DRV_NAME,
	204	.owner = THIS_MODULE,
	205	},
	206	.probe = ixp4xx_pata_probe,
	207	.remove = __devexit_p(ixp4xx_pata_remove),
	208	};
	209
	210	static int __init ixp4xx_pata_init(void)
	211	{
	212	return platform_driver_register(&ixp4xx_pata_platform_driver);
	213	}
	214
	215	static void __exit ixp4xx_pata_exit(void)
	216	{
	217	platform_driver_unregister(&ixp4xx_pata_platform_driver);
	218	}
	219
	220	MODULE_AUTHOR("Alessandro Zummo <a.zummo@towertech.it>");
	221	MODULE_DESCRIPTION("low-level driver for ixp4xx Compact Flash PATA");
	222	MODULE_LICENSE("GPL");
	223	MODULE_VERSION(DRV_VERSION);
458622fc	224	MODULE_ALIAS("platform:" DRV_NAME);
0df0d0a0 AZ	225
	226	module_init(ixp4xx_pata_init);
	227	module_exit(ixp4xx_pata_exit);