[linux-2.6-block.git] / drivers / net / can / sja1000 / tscan1.c

/*
 * tscan1.c: driver for Technologic Systems TS-CAN1 PC104 boards
 *
 * Copyright 2010 Andre B. Oliveira
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

/*
 * References:
 * - Getting started with TS-CAN1, Technologic Systems, Jun 2009
 *	http://www.embeddedarm.com/documentation/ts-can1-manual.pdf
 */

#include <linux/init.h>
#include <linux/io.h>
#include <linux/ioport.h>
#include <linux/isa.h>
#include <linux/module.h>
#include <linux/netdevice.h>
#include "sja1000.h"

MODULE_DESCRIPTION("Driver for Technologic Systems TS-CAN1 PC104 boards");
MODULE_AUTHOR("Andre B. Oliveira <anbadeol@gmail.com>");
MODULE_LICENSE("GPL");

/* Maximum number of boards (one in each JP1:JP2 setting of IO address) */
#define TSCAN1_MAXDEV 4

/* PLD registers address offsets */
#define TSCAN1_ID1	0
#define TSCAN1_ID2	1
#define TSCAN1_VERSION	2
#define TSCAN1_LED	3
#define TSCAN1_PAGE	4
#define TSCAN1_MODE	5
#define TSCAN1_JUMPERS	6

/* PLD board identifier registers magic values */
#define TSCAN1_ID1_VALUE 0xf6
#define TSCAN1_ID2_VALUE 0xb9

/* PLD mode register SJA1000 IO enable bit */
#define TSCAN1_MODE_ENABLE 0x40

/* PLD jumpers register bits */
#define TSCAN1_JP4 0x10
#define TSCAN1_JP5 0x20

/* PLD IO base addresses start */
#define TSCAN1_PLD_ADDRESS 0x150

/* PLD register space size */
#define TSCAN1_PLD_SIZE 8

/* SJA1000 register space size */
#define TSCAN1_SJA1000_SIZE 32

/* SJA1000 crystal frequency (16MHz) */
#define TSCAN1_SJA1000_XTAL 16000000

/* SJA1000 IO base addresses */
static const unsigned short tscan1_sja1000_addresses[] = {
	0x100, 0x120, 0x180, 0x1a0, 0x200, 0x240, 0x280, 0x320
};

/* Read SJA1000 register */
static u8 tscan1_read(const struct sja1000_priv *priv, int reg)
{
	return inb((unsigned long)priv->reg_base + reg);
}

/* Write SJA1000 register */
static void tscan1_write(const struct sja1000_priv *priv, int reg, u8 val)
{
	outb(val, (unsigned long)priv->reg_base + reg);
}

/* Probe for a TS-CAN1 board with JP2:JP1 jumper setting ID */
static int tscan1_probe(struct device *dev, unsigned id)
{
	struct net_device *netdev;
	struct sja1000_priv *priv;
	unsigned long pld_base, sja1000_base;
	int irq, i;

	pld_base = TSCAN1_PLD_ADDRESS + id * TSCAN1_PLD_SIZE;
	if (!request_region(pld_base, TSCAN1_PLD_SIZE, dev_name(dev)))
		return -EBUSY;

	if (inb(pld_base + TSCAN1_ID1) != TSCAN1_ID1_VALUE ||
	    inb(pld_base + TSCAN1_ID2) != TSCAN1_ID2_VALUE) {
		release_region(pld_base, TSCAN1_PLD_SIZE);
		return -ENODEV;
	}

	switch (inb(pld_base + TSCAN1_JUMPERS) & (TSCAN1_JP4 | TSCAN1_JP5)) {
	case TSCAN1_JP4:
		irq = 6;
		break;
	case TSCAN1_JP5:
		irq = 7;
		break;
	case TSCAN1_JP4 | TSCAN1_JP5:
		irq = 5;
		break;
	default:
		dev_err(dev, "invalid JP4:JP5 setting (no IRQ)\n");
		release_region(pld_base, TSCAN1_PLD_SIZE);
		return -EINVAL;
	}

	netdev = alloc_sja1000dev(0);
	if (!netdev) {
		release_region(pld_base, TSCAN1_PLD_SIZE);
		return -ENOMEM;
	}

	dev_set_drvdata(dev, netdev);
	SET_NETDEV_DEV(netdev, dev);

	netdev->base_addr = pld_base;
	netdev->irq = irq;

	priv = netdev_priv(netdev);
	priv->read_reg = tscan1_read;
	priv->write_reg = tscan1_write;
	priv->can.clock.freq = TSCAN1_SJA1000_XTAL / 2;
	priv->cdr = CDR_CBP | CDR_CLK_OFF;
	priv->ocr = OCR_TX0_PUSHPULL;

	/* Select the first SJA1000 IO address that is free and that works */
	for (i = 0; i < ARRAY_SIZE(tscan1_sja1000_addresses); i++) {
		sja1000_base = tscan1_sja1000_addresses[i];
		if (!request_region(sja1000_base, TSCAN1_SJA1000_SIZE,
								dev_name(dev)))
			continue;

		/* Set SJA1000 IO base address and enable it */
		outb(TSCAN1_MODE_ENABLE | i, pld_base + TSCAN1_MODE);

		priv->reg_base = (void __iomem *)sja1000_base;
		if (!register_sja1000dev(netdev)) {
			/* SJA1000 probe succeeded; turn LED off and return */
			outb(0, pld_base + TSCAN1_LED);
			netdev_info(netdev, "TS-CAN1 at 0x%lx 0x%lx irq %d\n",
						pld_base, sja1000_base, irq);
			return 0;
		}

		/* SJA1000 probe failed; release and try next address */
		outb(0, pld_base + TSCAN1_MODE);
		release_region(sja1000_base, TSCAN1_SJA1000_SIZE);
	}

	dev_err(dev, "failed to assign SJA1000 IO address\n");
	dev_set_drvdata(dev, NULL);
	free_sja1000dev(netdev);
	release_region(pld_base, TSCAN1_PLD_SIZE);
	return -ENXIO;
}

static int tscan1_remove(struct device *dev, unsigned id /*unused*/)
{
	struct net_device *netdev;
	struct sja1000_priv *priv;
	unsigned long pld_base, sja1000_base;

	netdev = dev_get_drvdata(dev);
	unregister_sja1000dev(netdev);
	dev_set_drvdata(dev, NULL);

	priv = netdev_priv(netdev);
	pld_base = netdev->base_addr;
	sja1000_base = (unsigned long)priv->reg_base;

	outb(0, pld_base + TSCAN1_MODE);	/* disable SJA1000 IO space */

	release_region(sja1000_base, TSCAN1_SJA1000_SIZE);
	release_region(pld_base, TSCAN1_PLD_SIZE);

	free_sja1000dev(netdev);

	return 0;
}

static struct isa_driver tscan1_isa_driver = {
	.probe = tscan1_probe,
	.remove = tscan1_remove,
	.driver = {
		.name = "tscan1",
	},
};

static int __init tscan1_init(void)
{
	return isa_register_driver(&tscan1_isa_driver, TSCAN1_MAXDEV);
}
module_init(tscan1_init);

static void __exit tscan1_exit(void)
{
	isa_unregister_driver(&tscan1_isa_driver);
}
module_exit(tscan1_exit);
Commit	Line	Data
2d3359f8 AO	1	/*
	2	* tscan1.c: driver for Technologic Systems TS-CAN1 PC104 boards
	3	*
	4	* Copyright 2010 Andre B. Oliveira
	5	*
	6	* This program is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU General Public License
	8	* as published by the Free Software Foundation; either version 2
	9	* of the License, or (at your option) any later version.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with this program. If not, see <http://www.gnu.org/licenses/>.
	18	*/
	19
	20	/*
	21	* References:
	22	* - Getting started with TS-CAN1, Technologic Systems, Jun 2009
	23	* http://www.embeddedarm.com/documentation/ts-can1-manual.pdf
	24	*/
	25
	26	#include <linux/init.h>
	27	#include <linux/io.h>
	28	#include <linux/ioport.h>
	29	#include <linux/isa.h>
	30	#include <linux/module.h>
	31	#include <linux/netdevice.h>
	32	#include "sja1000.h"
	33
	34	MODULE_DESCRIPTION("Driver for Technologic Systems TS-CAN1 PC104 boards");
	35	MODULE_AUTHOR("Andre B. Oliveira <anbadeol@gmail.com>");
	36	MODULE_LICENSE("GPL");
	37
	38	/* Maximum number of boards (one in each JP1:JP2 setting of IO address) */
	39	#define TSCAN1_MAXDEV 4
	40
	41	/* PLD registers address offsets */
	42	#define TSCAN1_ID1 0
	43	#define TSCAN1_ID2 1
	44	#define TSCAN1_VERSION 2
	45	#define TSCAN1_LED 3
	46	#define TSCAN1_PAGE 4
	47	#define TSCAN1_MODE 5
	48	#define TSCAN1_JUMPERS 6
	49
	50	/* PLD board identifier registers magic values */
	51	#define TSCAN1_ID1_VALUE 0xf6
	52	#define TSCAN1_ID2_VALUE 0xb9
	53
	54	/* PLD mode register SJA1000 IO enable bit */
	55	#define TSCAN1_MODE_ENABLE 0x40
	56
	57	/* PLD jumpers register bits */
	58	#define TSCAN1_JP4 0x10
	59	#define TSCAN1_JP5 0x20
	60
	61	/* PLD IO base addresses start */
	62	#define TSCAN1_PLD_ADDRESS 0x150
	63
	64	/* PLD register space size */
65	#define TSCAN1_PLD_SIZE 8
66
67	/* SJA1000 register space size */
68	#define TSCAN1_SJA1000_SIZE 32
69
70	/* SJA1000 crystal frequency (16MHz) */
71	#define TSCAN1_SJA1000_XTAL 16000000
72
73	/* SJA1000 IO base addresses */
3c8ac0f2	74	static const unsigned short tscan1_sja1000_addresses[] = {
2d3359f8 AO	75	0x100, 0x120, 0x180, 0x1a0, 0x200, 0x240, 0x280, 0x320
	76	};
	77
	78	/* Read SJA1000 register */
	79	static u8 tscan1_read(const struct sja1000_priv *priv, int reg)
	80	{
	81	return inb((unsigned long)priv->reg_base + reg);
	82	}
	83
	84	/* Write SJA1000 register */
	85	static void tscan1_write(const struct sja1000_priv *priv, int reg, u8 val)
	86	{
	87	outb(val, (unsigned long)priv->reg_base + reg);
	88	}
	89
	90	/* Probe for a TS-CAN1 board with JP2:JP1 jumper setting ID */
3c8ac0f2	91	static int tscan1_probe(struct device *dev, unsigned id)
2d3359f8 AO	92	{
	93	struct net_device *netdev;
	94	struct sja1000_priv *priv;
	95	unsigned long pld_base, sja1000_base;
	96	int irq, i;
	97
	98	pld_base = TSCAN1_PLD_ADDRESS + id * TSCAN1_PLD_SIZE;
	99	if (!request_region(pld_base, TSCAN1_PLD_SIZE, dev_name(dev)))
	100	return -EBUSY;
	101
	102	if (inb(pld_base + TSCAN1_ID1) != TSCAN1_ID1_VALUE \|\|
	103	inb(pld_base + TSCAN1_ID2) != TSCAN1_ID2_VALUE) {
	104	release_region(pld_base, TSCAN1_PLD_SIZE);
	105	return -ENODEV;
	106	}
	107
	108	switch (inb(pld_base + TSCAN1_JUMPERS) & (TSCAN1_JP4 \| TSCAN1_JP5)) {
	109	case TSCAN1_JP4:
	110	irq = 6;
	111	break;
	112	case TSCAN1_JP5:
	113	irq = 7;
	114	break;
	115	case TSCAN1_JP4 \| TSCAN1_JP5:
	116	irq = 5;
	117	break;
	118	default:
	119	dev_err(dev, "invalid JP4:JP5 setting (no IRQ)\n");
	120	release_region(pld_base, TSCAN1_PLD_SIZE);
	121	return -EINVAL;
	122	}
	123
	124	netdev = alloc_sja1000dev(0);
	125	if (!netdev) {
	126	release_region(pld_base, TSCAN1_PLD_SIZE);
	127	return -ENOMEM;
	128	}
	129
	130	dev_set_drvdata(dev, netdev);
	131	SET_NETDEV_DEV(netdev, dev);
	132
	133	netdev->base_addr = pld_base;
	134	netdev->irq = irq;
	135
	136	priv = netdev_priv(netdev);
	137	priv->read_reg = tscan1_read;
	138	priv->write_reg = tscan1_write;
	139	priv->can.clock.freq = TSCAN1_SJA1000_XTAL / 2;
	140	priv->cdr = CDR_CBP \| CDR_CLK_OFF;
	141	priv->ocr = OCR_TX0_PUSHPULL;
	142
	143	/* Select the first SJA1000 IO address that is free and that works */
	144	for (i = 0; i < ARRAY_SIZE(tscan1_sja1000_addresses); i++) {
	145	sja1000_base = tscan1_sja1000_addresses[i];
	146	if (!request_region(sja1000_base, TSCAN1_SJA1000_SIZE,
	147	dev_name(dev)))
	148	continue;
	149
	150	/* Set SJA1000 IO base address and enable it */
	151	outb(TSCAN1_MODE_ENABLE \| i, pld_base + TSCAN1_MODE);
	152
	153	priv->reg_base = (void __iomem *)sja1000_base;
	154	if (!register_sja1000dev(netdev)) {
	155	/* SJA1000 probe succeeded; turn LED off and return */
156	outb(0, pld_base + TSCAN1_LED);
157	netdev_info(netdev, "TS-CAN1 at 0x%lx 0x%lx irq %d\n",
158	pld_base, sja1000_base, irq);
159	return 0;
160	}
161
162	/* SJA1000 probe failed; release and try next address */
163	outb(0, pld_base + TSCAN1_MODE);
164	release_region(sja1000_base, TSCAN1_SJA1000_SIZE);
165	}
166
167	dev_err(dev, "failed to assign SJA1000 IO address\n");
168	dev_set_drvdata(dev, NULL);
169	free_sja1000dev(netdev);
170	release_region(pld_base, TSCAN1_PLD_SIZE);
171	return -ENXIO;
172	}
173
3c8ac0f2	174	static int tscan1_remove(struct device dev, unsigned id /unused*/)
2d3359f8 AO	175	{
	176	struct net_device *netdev;
	177	struct sja1000_priv *priv;
	178	unsigned long pld_base, sja1000_base;
	179
	180	netdev = dev_get_drvdata(dev);
	181	unregister_sja1000dev(netdev);
	182	dev_set_drvdata(dev, NULL);
	183
	184	priv = netdev_priv(netdev);
	185	pld_base = netdev->base_addr;
	186	sja1000_base = (unsigned long)priv->reg_base;
	187
	188	outb(0, pld_base + TSCAN1_MODE); /* disable SJA1000 IO space */
	189
	190	release_region(sja1000_base, TSCAN1_SJA1000_SIZE);
	191	release_region(pld_base, TSCAN1_PLD_SIZE);
	192
	193	free_sja1000dev(netdev);
	194
	195	return 0;
	196	}
	197
	198	static struct isa_driver tscan1_isa_driver = {
	199	.probe = tscan1_probe,
3c8ac0f2	200	.remove = tscan1_remove,
2d3359f8 AO	201	.driver = {
	202	.name = "tscan1",
	203	},
	204	};
	205
	206	static int __init tscan1_init(void)
	207	{
	208	return isa_register_driver(&tscan1_isa_driver, TSCAN1_MAXDEV);
	209	}
	210	module_init(tscan1_init);
	211
	212	static void __exit tscan1_exit(void)
	213	{
	214	isa_unregister_driver(&tscan1_isa_driver);
	215	}
	216	module_exit(tscan1_exit);