diff options
author | Oliver Hartkopp <socketcan@hartkopp.net> | 2011-09-23 02:59:48 -0400 |
---|---|---|
committer | David S. Miller <davem@davemloft.net> | 2011-09-28 13:41:50 -0400 |
commit | fd734c6f25aea4b2b44b045e489aec67b388577e (patch) | |
tree | d2ff70a1b48016d6821930ddd1a9b9ff20e7e489 /drivers/net/can | |
parent | f786ecba4158880f8cdc0ebb93e7d78e6c125449 (diff) |
can/sja1000: add driver for EMS PCMCIA card
This patch adds the driver for the SJA1000 based PCMCIA card 'CPC-Card' from
EMS Dr. Thomas Wuensche (http://www.ems-wuensche.de).
Signed-off-by: Oliver Hartkopp <socketcan@hartkopp.net>
Acked-by: Markus Plessing <plessing@ems-wuensche.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
Diffstat (limited to 'drivers/net/can')
-rw-r--r-- | drivers/net/can/sja1000/Kconfig | 7 | ||||
-rw-r--r-- | drivers/net/can/sja1000/Makefile | 1 | ||||
-rw-r--r-- | drivers/net/can/sja1000/ems_pcmcia.c | 331 |
3 files changed, 339 insertions, 0 deletions
diff --git a/drivers/net/can/sja1000/Kconfig b/drivers/net/can/sja1000/Kconfig index 72b637d31c91..fe9e64d476eb 100644 --- a/drivers/net/can/sja1000/Kconfig +++ b/drivers/net/can/sja1000/Kconfig | |||
@@ -29,6 +29,13 @@ config CAN_SJA1000_OF_PLATFORM | |||
29 | OpenFirmware bindings, e.g. if you have a PowerPC based system | 29 | OpenFirmware bindings, e.g. if you have a PowerPC based system |
30 | you may want to enable this option. | 30 | you may want to enable this option. |
31 | 31 | ||
32 | config CAN_EMS_PCMCIA | ||
33 | tristate "EMS CPC-CARD Card" | ||
34 | depends on PCMCIA | ||
35 | ---help--- | ||
36 | This driver is for the one or two channel CPC-CARD cards from | ||
37 | EMS Dr. Thomas Wuensche (http://www.ems-wuensche.de). | ||
38 | |||
32 | config CAN_EMS_PCI | 39 | config CAN_EMS_PCI |
33 | tristate "EMS CPC-PCI, CPC-PCIe and CPC-104P Card" | 40 | tristate "EMS CPC-PCI, CPC-PCIe and CPC-104P Card" |
34 | depends on PCI | 41 | depends on PCI |
diff --git a/drivers/net/can/sja1000/Makefile b/drivers/net/can/sja1000/Makefile index 428f5cf30b60..0604f240c8b1 100644 --- a/drivers/net/can/sja1000/Makefile +++ b/drivers/net/can/sja1000/Makefile | |||
@@ -6,6 +6,7 @@ obj-$(CONFIG_CAN_SJA1000) += sja1000.o | |||
6 | obj-$(CONFIG_CAN_SJA1000_ISA) += sja1000_isa.o | 6 | obj-$(CONFIG_CAN_SJA1000_ISA) += sja1000_isa.o |
7 | obj-$(CONFIG_CAN_SJA1000_PLATFORM) += sja1000_platform.o | 7 | obj-$(CONFIG_CAN_SJA1000_PLATFORM) += sja1000_platform.o |
8 | obj-$(CONFIG_CAN_SJA1000_OF_PLATFORM) += sja1000_of_platform.o | 8 | obj-$(CONFIG_CAN_SJA1000_OF_PLATFORM) += sja1000_of_platform.o |
9 | obj-$(CONFIG_CAN_EMS_PCMCIA) += ems_pcmcia.o | ||
9 | obj-$(CONFIG_CAN_EMS_PCI) += ems_pci.o | 10 | obj-$(CONFIG_CAN_EMS_PCI) += ems_pci.o |
10 | obj-$(CONFIG_CAN_KVASER_PCI) += kvaser_pci.o | 11 | obj-$(CONFIG_CAN_KVASER_PCI) += kvaser_pci.o |
11 | obj-$(CONFIG_CAN_PEAK_PCI) += peak_pci.o | 12 | obj-$(CONFIG_CAN_PEAK_PCI) += peak_pci.o |
diff --git a/drivers/net/can/sja1000/ems_pcmcia.c b/drivers/net/can/sja1000/ems_pcmcia.c new file mode 100644 index 000000000000..075a5457a190 --- /dev/null +++ b/drivers/net/can/sja1000/ems_pcmcia.c | |||
@@ -0,0 +1,331 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2008 Sebastian Haas (initial chardev implementation) | ||
3 | * Copyright (C) 2010 Markus Plessing <plessing@ems-wuensche.com> | ||
4 | * Rework for mainline by Oliver Hartkopp <socketcan@hartkopp.net> | ||
5 | * | ||
6 | * This program is free software; you can redistribute it and/or modify | ||
7 | * it under the terms of the version 2 of the GNU General Public License | ||
8 | * as published by the Free Software Foundation | ||
9 | * | ||
10 | * This program is distributed in the hope that it will be useful, | ||
11 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
13 | * GNU General Public License for more details. | ||
14 | */ | ||
15 | |||
16 | #include <linux/kernel.h> | ||
17 | #include <linux/module.h> | ||
18 | #include <linux/interrupt.h> | ||
19 | #include <linux/netdevice.h> | ||
20 | #include <linux/delay.h> | ||
21 | #include <linux/io.h> | ||
22 | #include <pcmcia/cistpl.h> | ||
23 | #include <pcmcia/ds.h> | ||
24 | #include <linux/can.h> | ||
25 | #include <linux/can/dev.h> | ||
26 | #include "sja1000.h" | ||
27 | |||
28 | #define DRV_NAME "ems_pcmcia" | ||
29 | |||
30 | MODULE_AUTHOR("Markus Plessing <plessing@ems-wuensche.com>"); | ||
31 | MODULE_DESCRIPTION("Socket-CAN driver for EMS CPC-CARD cards"); | ||
32 | MODULE_SUPPORTED_DEVICE("EMS CPC-CARD CAN card"); | ||
33 | MODULE_LICENSE("GPL v2"); | ||
34 | |||
35 | #define EMS_PCMCIA_MAX_CHAN 2 | ||
36 | |||
37 | struct ems_pcmcia_card { | ||
38 | int channels; | ||
39 | struct pcmcia_device *pcmcia_dev; | ||
40 | struct net_device *net_dev[EMS_PCMCIA_MAX_CHAN]; | ||
41 | void __iomem *base_addr; | ||
42 | }; | ||
43 | |||
44 | #define EMS_PCMCIA_CAN_CLOCK (16000000 / 2) | ||
45 | |||
46 | /* | ||
47 | * The board configuration is probably following: | ||
48 | * RX1 is connected to ground. | ||
49 | * TX1 is not connected. | ||
50 | * CLKO is not connected. | ||
51 | * Setting the OCR register to 0xDA is a good idea. | ||
52 | * This means normal output mode , push-pull and the correct polarity. | ||
53 | */ | ||
54 | #define EMS_PCMCIA_OCR (OCR_TX0_PUSHPULL | OCR_TX1_PUSHPULL) | ||
55 | |||
56 | /* | ||
57 | * In the CDR register, you should set CBP to 1. | ||
58 | * You will probably also want to set the clock divider value to 7 | ||
59 | * (meaning direct oscillator output) because the second SJA1000 chip | ||
60 | * is driven by the first one CLKOUT output. | ||
61 | */ | ||
62 | #define EMS_PCMCIA_CDR (CDR_CBP | CDR_CLKOUT_MASK) | ||
63 | #define EMS_PCMCIA_MEM_SIZE 4096 /* Size of the remapped io-memory */ | ||
64 | #define EMS_PCMCIA_CAN_BASE_OFFSET 0x100 /* Offset where controllers starts */ | ||
65 | #define EMS_PCMCIA_CAN_CTRL_SIZE 0x80 /* Memory size for each controller */ | ||
66 | |||
67 | #define EMS_CMD_RESET 0x00 /* Perform a reset of the card */ | ||
68 | #define EMS_CMD_MAP 0x03 /* Map CAN controllers into card' memory */ | ||
69 | #define EMS_CMD_UMAP 0x02 /* Unmap CAN controllers from card' memory */ | ||
70 | |||
71 | static struct pcmcia_device_id ems_pcmcia_tbl[] = { | ||
72 | PCMCIA_DEVICE_PROD_ID123("EMS_T_W", "CPC-Card", "V2.0", 0xeab1ea23, | ||
73 | 0xa338573f, 0xe4575800), | ||
74 | PCMCIA_DEVICE_NULL, | ||
75 | }; | ||
76 | |||
77 | MODULE_DEVICE_TABLE(pcmcia, ems_pcmcia_tbl); | ||
78 | |||
79 | static u8 ems_pcmcia_read_reg(const struct sja1000_priv *priv, int port) | ||
80 | { | ||
81 | return readb(priv->reg_base + port); | ||
82 | } | ||
83 | |||
84 | static void ems_pcmcia_write_reg(const struct sja1000_priv *priv, int port, | ||
85 | u8 val) | ||
86 | { | ||
87 | writeb(val, priv->reg_base + port); | ||
88 | } | ||
89 | |||
90 | static irqreturn_t ems_pcmcia_interrupt(int irq, void *dev_id) | ||
91 | { | ||
92 | struct ems_pcmcia_card *card = dev_id; | ||
93 | struct net_device *dev; | ||
94 | irqreturn_t retval = IRQ_NONE; | ||
95 | int i, again; | ||
96 | |||
97 | /* Card not present */ | ||
98 | if (readw(card->base_addr) != 0xAA55) | ||
99 | return IRQ_HANDLED; | ||
100 | |||
101 | do { | ||
102 | again = 0; | ||
103 | |||
104 | /* Check interrupt for each channel */ | ||
105 | for (i = 0; i < card->channels; i++) { | ||
106 | dev = card->net_dev[i]; | ||
107 | if (!dev) | ||
108 | continue; | ||
109 | |||
110 | if (sja1000_interrupt(irq, dev) == IRQ_HANDLED) | ||
111 | again = 1; | ||
112 | } | ||
113 | /* At least one channel handled the interrupt */ | ||
114 | if (again) | ||
115 | retval = IRQ_HANDLED; | ||
116 | |||
117 | } while (again); | ||
118 | |||
119 | return retval; | ||
120 | } | ||
121 | |||
122 | /* | ||
123 | * Check if a CAN controller is present at the specified location | ||
124 | * by trying to set 'em into the PeliCAN mode | ||
125 | */ | ||
126 | static inline int ems_pcmcia_check_chan(struct sja1000_priv *priv) | ||
127 | { | ||
128 | /* Make sure SJA1000 is in reset mode */ | ||
129 | ems_pcmcia_write_reg(priv, REG_MOD, 1); | ||
130 | ems_pcmcia_write_reg(priv, REG_CDR, CDR_PELICAN); | ||
131 | |||
132 | /* read reset-values */ | ||
133 | if (ems_pcmcia_read_reg(priv, REG_CDR) == CDR_PELICAN) | ||
134 | return 1; | ||
135 | |||
136 | return 0; | ||
137 | } | ||
138 | |||
139 | static void ems_pcmcia_del_card(struct pcmcia_device *pdev) | ||
140 | { | ||
141 | struct ems_pcmcia_card *card = pdev->priv; | ||
142 | struct net_device *dev; | ||
143 | int i; | ||
144 | |||
145 | free_irq(pdev->irq, card); | ||
146 | |||
147 | for (i = 0; i < card->channels; i++) { | ||
148 | dev = card->net_dev[i]; | ||
149 | if (!dev) | ||
150 | continue; | ||
151 | |||
152 | printk(KERN_INFO "%s: removing %s on channel #%d\n", | ||
153 | DRV_NAME, dev->name, i); | ||
154 | unregister_sja1000dev(dev); | ||
155 | free_sja1000dev(dev); | ||
156 | } | ||
157 | |||
158 | writeb(EMS_CMD_UMAP, card->base_addr); | ||
159 | iounmap(card->base_addr); | ||
160 | kfree(card); | ||
161 | |||
162 | pdev->priv = NULL; | ||
163 | } | ||
164 | |||
165 | /* | ||
166 | * Probe PCI device for EMS CAN signature and register each available | ||
167 | * CAN channel to SJA1000 Socket-CAN subsystem. | ||
168 | */ | ||
169 | static int __devinit ems_pcmcia_add_card(struct pcmcia_device *pdev, | ||
170 | unsigned long base) | ||
171 | { | ||
172 | struct sja1000_priv *priv; | ||
173 | struct net_device *dev; | ||
174 | struct ems_pcmcia_card *card; | ||
175 | int err, i; | ||
176 | |||
177 | /* Allocating card structures to hold addresses, ... */ | ||
178 | card = kzalloc(sizeof(struct ems_pcmcia_card), GFP_KERNEL); | ||
179 | if (!card) | ||
180 | return -ENOMEM; | ||
181 | |||
182 | pdev->priv = card; | ||
183 | card->channels = 0; | ||
184 | |||
185 | card->base_addr = ioremap(base, EMS_PCMCIA_MEM_SIZE); | ||
186 | if (!card->base_addr) { | ||
187 | err = -ENOMEM; | ||
188 | goto failure_cleanup; | ||
189 | } | ||
190 | |||
191 | /* Check for unique EMS CAN signature */ | ||
192 | if (readw(card->base_addr) != 0xAA55) { | ||
193 | err = -ENODEV; | ||
194 | goto failure_cleanup; | ||
195 | } | ||
196 | |||
197 | /* Request board reset */ | ||
198 | writeb(EMS_CMD_RESET, card->base_addr); | ||
199 | |||
200 | /* Make sure CAN controllers are mapped into card's memory space */ | ||
201 | writeb(EMS_CMD_MAP, card->base_addr); | ||
202 | |||
203 | /* Detect available channels */ | ||
204 | for (i = 0; i < EMS_PCMCIA_MAX_CHAN; i++) { | ||
205 | dev = alloc_sja1000dev(0); | ||
206 | if (!dev) { | ||
207 | err = -ENOMEM; | ||
208 | goto failure_cleanup; | ||
209 | } | ||
210 | |||
211 | card->net_dev[i] = dev; | ||
212 | priv = netdev_priv(dev); | ||
213 | priv->priv = card; | ||
214 | SET_NETDEV_DEV(dev, &pdev->dev); | ||
215 | |||
216 | priv->irq_flags = IRQF_SHARED; | ||
217 | dev->irq = pdev->irq; | ||
218 | priv->reg_base = card->base_addr + EMS_PCMCIA_CAN_BASE_OFFSET + | ||
219 | (i * EMS_PCMCIA_CAN_CTRL_SIZE); | ||
220 | |||
221 | /* Check if channel is present */ | ||
222 | if (ems_pcmcia_check_chan(priv)) { | ||
223 | priv->read_reg = ems_pcmcia_read_reg; | ||
224 | priv->write_reg = ems_pcmcia_write_reg; | ||
225 | priv->can.clock.freq = EMS_PCMCIA_CAN_CLOCK; | ||
226 | priv->ocr = EMS_PCMCIA_OCR; | ||
227 | priv->cdr = EMS_PCMCIA_CDR; | ||
228 | priv->flags |= SJA1000_CUSTOM_IRQ_HANDLER; | ||
229 | |||
230 | /* Register SJA1000 device */ | ||
231 | err = register_sja1000dev(dev); | ||
232 | if (err) { | ||
233 | free_sja1000dev(dev); | ||
234 | goto failure_cleanup; | ||
235 | } | ||
236 | |||
237 | card->channels++; | ||
238 | |||
239 | printk(KERN_INFO "%s: registered %s on channel " | ||
240 | "#%d at 0x%p, irq %d\n", DRV_NAME, dev->name, | ||
241 | i, priv->reg_base, dev->irq); | ||
242 | } else | ||
243 | free_sja1000dev(dev); | ||
244 | } | ||
245 | |||
246 | err = request_irq(dev->irq, &ems_pcmcia_interrupt, IRQF_SHARED, | ||
247 | DRV_NAME, card); | ||
248 | if (!err) | ||
249 | return 0; | ||
250 | |||
251 | failure_cleanup: | ||
252 | ems_pcmcia_del_card(pdev); | ||
253 | return err; | ||
254 | } | ||
255 | |||
256 | /* | ||
257 | * Setup PCMCIA socket and probe for EMS CPC-CARD | ||
258 | */ | ||
259 | static int __devinit ems_pcmcia_probe(struct pcmcia_device *dev) | ||
260 | { | ||
261 | int csval; | ||
262 | |||
263 | /* General socket configuration */ | ||
264 | dev->config_flags |= CONF_ENABLE_IRQ; | ||
265 | dev->config_index = 1; | ||
266 | dev->config_regs = PRESENT_OPTION; | ||
267 | |||
268 | /* The io structure describes IO port mapping */ | ||
269 | dev->resource[0]->end = 16; | ||
270 | dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8; | ||
271 | dev->resource[1]->end = 16; | ||
272 | dev->resource[1]->flags |= IO_DATA_PATH_WIDTH_16; | ||
273 | dev->io_lines = 5; | ||
274 | |||
275 | /* Allocate a memory window */ | ||
276 | dev->resource[2]->flags = | ||
277 | (WIN_DATA_WIDTH_8 | WIN_MEMORY_TYPE_CM | WIN_ENABLE); | ||
278 | dev->resource[2]->start = dev->resource[2]->end = 0; | ||
279 | |||
280 | csval = pcmcia_request_window(dev, dev->resource[2], 0); | ||
281 | if (csval) { | ||
282 | dev_err(&dev->dev, "pcmcia_request_window failed (err=%d)\n", | ||
283 | csval); | ||
284 | return 0; | ||
285 | } | ||
286 | |||
287 | csval = pcmcia_map_mem_page(dev, dev->resource[2], dev->config_base); | ||
288 | if (csval) { | ||
289 | dev_err(&dev->dev, "pcmcia_map_mem_page failed (err=%d)\n", | ||
290 | csval); | ||
291 | return 0; | ||
292 | } | ||
293 | |||
294 | csval = pcmcia_enable_device(dev); | ||
295 | if (csval) { | ||
296 | dev_err(&dev->dev, "pcmcia_enable_device failed (err=%d)\n", | ||
297 | csval); | ||
298 | return 0; | ||
299 | } | ||
300 | |||
301 | ems_pcmcia_add_card(dev, dev->resource[2]->start); | ||
302 | return 0; | ||
303 | } | ||
304 | |||
305 | /* | ||
306 | * Release claimed resources | ||
307 | */ | ||
308 | static void ems_pcmcia_remove(struct pcmcia_device *dev) | ||
309 | { | ||
310 | ems_pcmcia_del_card(dev); | ||
311 | pcmcia_disable_device(dev); | ||
312 | } | ||
313 | |||
314 | static struct pcmcia_driver ems_pcmcia_driver = { | ||
315 | .name = DRV_NAME, | ||
316 | .probe = ems_pcmcia_probe, | ||
317 | .remove = ems_pcmcia_remove, | ||
318 | .id_table = ems_pcmcia_tbl, | ||
319 | }; | ||
320 | |||
321 | static int __init ems_pcmcia_init(void) | ||
322 | { | ||
323 | return pcmcia_register_driver(&ems_pcmcia_driver); | ||
324 | } | ||
325 | module_init(ems_pcmcia_init); | ||
326 | |||
327 | static void __exit ems_pcmcia_exit(void) | ||
328 | { | ||
329 | pcmcia_unregister_driver(&ems_pcmcia_driver); | ||
330 | } | ||
331 | module_exit(ems_pcmcia_exit); | ||