Commit | Line | Data |
---|---|---|
edd2c26f WG |
1 | /* |
2 | * Driver for CC770 and AN82527 CAN controllers on the legacy ISA bus | |
3 | * | |
4 | * Copyright (C) 2009, 2011 Wolfgang Grandegger <wg@grandegger.com> | |
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 | /* | |
17 | * Bosch CC770 and Intel AN82527 CAN controllers on the ISA or PC-104 bus. | |
18 | * The I/O port or memory address and the IRQ number must be specified via | |
19 | * module parameters: | |
20 | * | |
21 | * insmod cc770_isa.ko port=0x310,0x380 irq=7,11 | |
22 | * | |
23 | * for ISA devices using I/O ports or: | |
24 | * | |
25 | * insmod cc770_isa.ko mem=0xd1000,0xd1000 irq=7,11 | |
26 | * | |
27 | * for memory mapped ISA devices. | |
28 | * | |
29 | * Indirect access via address and data port is supported as well: | |
30 | * | |
31 | * insmod cc770_isa.ko port=0x310,0x380 indirect=1 irq=7,11 | |
32 | * | |
33 | * Furthermore, the following mode parameter can be defined: | |
34 | * | |
35 | * clk: External oscillator clock frequency (default=16000000 [16 MHz]) | |
36 | * cir: CPU interface register (default=0x40 [DSC]) | |
37 | * bcr: Bus configuration register (default=0x40 [CBY]) | |
38 | * cor: Clockout register (default=0x00) | |
39 | * | |
40 | * Note: for clk, cir, bcr and cor, the first argument re-defines the | |
41 | * default for all other devices, e.g.: | |
42 | * | |
43 | * insmod cc770_isa.ko mem=0xd1000,0xd1000 irq=7,11 clk=24000000 | |
44 | * | |
45 | * is equivalent to | |
46 | * | |
47 | * insmod cc770_isa.ko mem=0xd1000,0xd1000 irq=7,11 clk=24000000,24000000 | |
48 | */ | |
49 | ||
50 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt | |
51 | ||
52 | #include <linux/kernel.h> | |
53 | #include <linux/module.h> | |
54 | #include <linux/platform_device.h> | |
55 | #include <linux/interrupt.h> | |
56 | #include <linux/netdevice.h> | |
57 | #include <linux/delay.h> | |
58 | #include <linux/irq.h> | |
59 | #include <linux/io.h> | |
60 | #include <linux/can.h> | |
61 | #include <linux/can/dev.h> | |
62 | #include <linux/can/platform/cc770.h> | |
63 | ||
64 | #include "cc770.h" | |
65 | ||
66 | #define MAXDEV 8 | |
67 | ||
68 | MODULE_AUTHOR("Wolfgang Grandegger <wg@grandegger.com>"); | |
69 | MODULE_DESCRIPTION("Socket-CAN driver for CC770 on the ISA bus"); | |
70 | MODULE_LICENSE("GPL v2"); | |
71 | ||
72 | #define CLK_DEFAULT 16000000 /* 16 MHz */ | |
73 | #define COR_DEFAULT 0x00 | |
74 | #define BCR_DEFAULT BUSCFG_CBY | |
75 | ||
76 | static unsigned long port[MAXDEV]; | |
77 | static unsigned long mem[MAXDEV]; | |
3c8ac0f2 BP |
78 | static int irq[MAXDEV]; |
79 | static int clk[MAXDEV]; | |
80 | static u8 cir[MAXDEV] = {[0 ... (MAXDEV - 1)] = 0xff}; | |
81 | static u8 cor[MAXDEV] = {[0 ... (MAXDEV - 1)] = 0xff}; | |
82 | static u8 bcr[MAXDEV] = {[0 ... (MAXDEV - 1)] = 0xff}; | |
83 | static int indirect[MAXDEV] = {[0 ... (MAXDEV - 1)] = -1}; | |
edd2c26f WG |
84 | |
85 | module_param_array(port, ulong, NULL, S_IRUGO); | |
86 | MODULE_PARM_DESC(port, "I/O port number"); | |
87 | ||
88 | module_param_array(mem, ulong, NULL, S_IRUGO); | |
89 | MODULE_PARM_DESC(mem, "I/O memory address"); | |
90 | ||
91 | module_param_array(indirect, int, NULL, S_IRUGO); | |
92 | MODULE_PARM_DESC(indirect, "Indirect access via address and data port"); | |
93 | ||
94 | module_param_array(irq, int, NULL, S_IRUGO); | |
95 | MODULE_PARM_DESC(irq, "IRQ number"); | |
96 | ||
97 | module_param_array(clk, int, NULL, S_IRUGO); | |
98 | MODULE_PARM_DESC(clk, "External oscillator clock frequency " | |
99 | "(default=16000000 [16 MHz])"); | |
100 | ||
101 | module_param_array(cir, byte, NULL, S_IRUGO); | |
102 | MODULE_PARM_DESC(cir, "CPU interface register (default=0x40 [DSC])"); | |
103 | ||
104 | module_param_array(cor, byte, NULL, S_IRUGO); | |
105 | MODULE_PARM_DESC(cor, "Clockout register (default=0x00)"); | |
106 | ||
107 | module_param_array(bcr, byte, NULL, S_IRUGO); | |
108 | MODULE_PARM_DESC(bcr, "Bus configuration register (default=0x40 [CBY])"); | |
109 | ||
110 | #define CC770_IOSIZE 0x20 | |
111 | #define CC770_IOSIZE_INDIRECT 0x02 | |
112 | ||
2d5091e0 WZ |
113 | /* Spinlock for cc770_isa_port_write_reg_indirect |
114 | * and cc770_isa_port_read_reg_indirect | |
115 | */ | |
116 | static DEFINE_SPINLOCK(cc770_isa_port_lock); | |
117 | ||
edd2c26f WG |
118 | static struct platform_device *cc770_isa_devs[MAXDEV]; |
119 | ||
120 | static u8 cc770_isa_mem_read_reg(const struct cc770_priv *priv, int reg) | |
121 | { | |
122 | return readb(priv->reg_base + reg); | |
123 | } | |
124 | ||
125 | static void cc770_isa_mem_write_reg(const struct cc770_priv *priv, | |
126 | int reg, u8 val) | |
127 | { | |
128 | writeb(val, priv->reg_base + reg); | |
129 | } | |
130 | ||
131 | static u8 cc770_isa_port_read_reg(const struct cc770_priv *priv, int reg) | |
132 | { | |
133 | return inb((unsigned long)priv->reg_base + reg); | |
134 | } | |
135 | ||
136 | static void cc770_isa_port_write_reg(const struct cc770_priv *priv, | |
137 | int reg, u8 val) | |
138 | { | |
139 | outb(val, (unsigned long)priv->reg_base + reg); | |
140 | } | |
141 | ||
142 | static u8 cc770_isa_port_read_reg_indirect(const struct cc770_priv *priv, | |
143 | int reg) | |
144 | { | |
145 | unsigned long base = (unsigned long)priv->reg_base; | |
2d5091e0 WZ |
146 | unsigned long flags; |
147 | u8 val; | |
edd2c26f | 148 | |
2d5091e0 | 149 | spin_lock_irqsave(&cc770_isa_port_lock, flags); |
edd2c26f | 150 | outb(reg, base); |
2d5091e0 WZ |
151 | val = inb(base + 1); |
152 | spin_unlock_irqrestore(&cc770_isa_port_lock, flags); | |
153 | ||
154 | return val; | |
edd2c26f WG |
155 | } |
156 | ||
157 | static void cc770_isa_port_write_reg_indirect(const struct cc770_priv *priv, | |
158 | int reg, u8 val) | |
159 | { | |
160 | unsigned long base = (unsigned long)priv->reg_base; | |
2d5091e0 | 161 | unsigned long flags; |
edd2c26f | 162 | |
2d5091e0 | 163 | spin_lock_irqsave(&cc770_isa_port_lock, flags); |
edd2c26f WG |
164 | outb(reg, base); |
165 | outb(val, base + 1); | |
2d5091e0 | 166 | spin_unlock_irqrestore(&cc770_isa_port_lock, flags); |
edd2c26f WG |
167 | } |
168 | ||
3c8ac0f2 | 169 | static int cc770_isa_probe(struct platform_device *pdev) |
edd2c26f WG |
170 | { |
171 | struct net_device *dev; | |
172 | struct cc770_priv *priv; | |
173 | void __iomem *base = NULL; | |
174 | int iosize = CC770_IOSIZE; | |
175 | int idx = pdev->id; | |
176 | int err; | |
177 | u32 clktmp; | |
178 | ||
179 | dev_dbg(&pdev->dev, "probing idx=%d: port=%#lx, mem=%#lx, irq=%d\n", | |
180 | idx, port[idx], mem[idx], irq[idx]); | |
181 | if (mem[idx]) { | |
182 | if (!request_mem_region(mem[idx], iosize, KBUILD_MODNAME)) { | |
183 | err = -EBUSY; | |
184 | goto exit; | |
185 | } | |
186 | base = ioremap_nocache(mem[idx], iosize); | |
187 | if (!base) { | |
188 | err = -ENOMEM; | |
189 | goto exit_release; | |
190 | } | |
191 | } else { | |
192 | if (indirect[idx] > 0 || | |
193 | (indirect[idx] == -1 && indirect[0] > 0)) | |
194 | iosize = CC770_IOSIZE_INDIRECT; | |
195 | if (!request_region(port[idx], iosize, KBUILD_MODNAME)) { | |
196 | err = -EBUSY; | |
197 | goto exit; | |
198 | } | |
199 | } | |
200 | ||
201 | dev = alloc_cc770dev(0); | |
202 | if (!dev) { | |
203 | err = -ENOMEM; | |
204 | goto exit_unmap; | |
205 | } | |
206 | priv = netdev_priv(dev); | |
207 | ||
208 | dev->irq = irq[idx]; | |
209 | priv->irq_flags = IRQF_SHARED; | |
210 | if (mem[idx]) { | |
211 | priv->reg_base = base; | |
212 | dev->base_addr = mem[idx]; | |
213 | priv->read_reg = cc770_isa_mem_read_reg; | |
214 | priv->write_reg = cc770_isa_mem_write_reg; | |
215 | } else { | |
216 | priv->reg_base = (void __iomem *)port[idx]; | |
217 | dev->base_addr = port[idx]; | |
218 | ||
219 | if (iosize == CC770_IOSIZE_INDIRECT) { | |
220 | priv->read_reg = cc770_isa_port_read_reg_indirect; | |
221 | priv->write_reg = cc770_isa_port_write_reg_indirect; | |
222 | } else { | |
223 | priv->read_reg = cc770_isa_port_read_reg; | |
224 | priv->write_reg = cc770_isa_port_write_reg; | |
225 | } | |
226 | } | |
227 | ||
228 | if (clk[idx]) | |
229 | clktmp = clk[idx]; | |
230 | else if (clk[0]) | |
231 | clktmp = clk[0]; | |
232 | else | |
233 | clktmp = CLK_DEFAULT; | |
234 | priv->can.clock.freq = clktmp; | |
235 | ||
236 | if (cir[idx] != 0xff) { | |
237 | priv->cpu_interface = cir[idx]; | |
238 | } else if (cir[0] != 0xff) { | |
239 | priv->cpu_interface = cir[0]; | |
240 | } else { | |
241 | /* The system clock may not exceed 10 MHz */ | |
242 | if (clktmp > 10000000) { | |
243 | priv->cpu_interface |= CPUIF_DSC; | |
244 | clktmp /= 2; | |
245 | } | |
246 | /* The memory clock may not exceed 8 MHz */ | |
247 | if (clktmp > 8000000) | |
248 | priv->cpu_interface |= CPUIF_DMC; | |
249 | } | |
250 | ||
251 | if (priv->cpu_interface & CPUIF_DSC) | |
252 | priv->can.clock.freq /= 2; | |
253 | ||
254 | if (bcr[idx] != 0xff) | |
255 | priv->bus_config = bcr[idx]; | |
256 | else if (bcr[0] != 0xff) | |
257 | priv->bus_config = bcr[0]; | |
258 | else | |
259 | priv->bus_config = BCR_DEFAULT; | |
260 | ||
261 | if (cor[idx] != 0xff) | |
262 | priv->clkout = cor[idx]; | |
263 | else if (cor[0] != 0xff) | |
264 | priv->clkout = cor[0]; | |
265 | else | |
266 | priv->clkout = COR_DEFAULT; | |
267 | ||
00e4bbc8 | 268 | platform_set_drvdata(pdev, dev); |
edd2c26f WG |
269 | SET_NETDEV_DEV(dev, &pdev->dev); |
270 | ||
271 | err = register_cc770dev(dev); | |
272 | if (err) { | |
273 | dev_err(&pdev->dev, | |
274 | "couldn't register device (err=%d)\n", err); | |
275 | goto exit_unmap; | |
276 | } | |
277 | ||
278 | dev_info(&pdev->dev, "device registered (reg_base=0x%p, irq=%d)\n", | |
279 | priv->reg_base, dev->irq); | |
280 | return 0; | |
281 | ||
282 | exit_unmap: | |
283 | if (mem[idx]) | |
284 | iounmap(base); | |
285 | exit_release: | |
286 | if (mem[idx]) | |
287 | release_mem_region(mem[idx], iosize); | |
288 | else | |
289 | release_region(port[idx], iosize); | |
290 | exit: | |
291 | return err; | |
292 | } | |
293 | ||
3c8ac0f2 | 294 | static int cc770_isa_remove(struct platform_device *pdev) |
edd2c26f | 295 | { |
00e4bbc8 | 296 | struct net_device *dev = platform_get_drvdata(pdev); |
edd2c26f WG |
297 | struct cc770_priv *priv = netdev_priv(dev); |
298 | int idx = pdev->id; | |
299 | ||
300 | unregister_cc770dev(dev); | |
edd2c26f WG |
301 | |
302 | if (mem[idx]) { | |
303 | iounmap(priv->reg_base); | |
304 | release_mem_region(mem[idx], CC770_IOSIZE); | |
305 | } else { | |
306 | if (priv->read_reg == cc770_isa_port_read_reg_indirect) | |
307 | release_region(port[idx], CC770_IOSIZE_INDIRECT); | |
308 | else | |
309 | release_region(port[idx], CC770_IOSIZE); | |
310 | } | |
311 | free_cc770dev(dev); | |
312 | ||
313 | return 0; | |
314 | } | |
315 | ||
316 | static struct platform_driver cc770_isa_driver = { | |
317 | .probe = cc770_isa_probe, | |
3c8ac0f2 | 318 | .remove = cc770_isa_remove, |
edd2c26f WG |
319 | .driver = { |
320 | .name = KBUILD_MODNAME, | |
edd2c26f WG |
321 | }, |
322 | }; | |
323 | ||
324 | static int __init cc770_isa_init(void) | |
325 | { | |
326 | int idx, err; | |
327 | ||
328 | for (idx = 0; idx < ARRAY_SIZE(cc770_isa_devs); idx++) { | |
329 | if ((port[idx] || mem[idx]) && irq[idx]) { | |
330 | cc770_isa_devs[idx] = | |
331 | platform_device_alloc(KBUILD_MODNAME, idx); | |
332 | if (!cc770_isa_devs[idx]) { | |
333 | err = -ENOMEM; | |
334 | goto exit_free_devices; | |
335 | } | |
336 | err = platform_device_add(cc770_isa_devs[idx]); | |
337 | if (err) { | |
338 | platform_device_put(cc770_isa_devs[idx]); | |
339 | goto exit_free_devices; | |
340 | } | |
341 | pr_debug("platform device %d: port=%#lx, mem=%#lx, " | |
342 | "irq=%d\n", | |
343 | idx, port[idx], mem[idx], irq[idx]); | |
344 | } else if (idx == 0 || port[idx] || mem[idx]) { | |
345 | pr_err("insufficient parameters supplied\n"); | |
346 | err = -EINVAL; | |
347 | goto exit_free_devices; | |
348 | } | |
349 | } | |
350 | ||
351 | err = platform_driver_register(&cc770_isa_driver); | |
352 | if (err) | |
353 | goto exit_free_devices; | |
354 | ||
355 | pr_info("driver for max. %d devices registered\n", MAXDEV); | |
356 | ||
357 | return 0; | |
358 | ||
359 | exit_free_devices: | |
360 | while (--idx >= 0) { | |
361 | if (cc770_isa_devs[idx]) | |
362 | platform_device_unregister(cc770_isa_devs[idx]); | |
363 | } | |
364 | ||
365 | return err; | |
366 | } | |
367 | module_init(cc770_isa_init); | |
368 | ||
369 | static void __exit cc770_isa_exit(void) | |
370 | { | |
371 | int idx; | |
372 | ||
373 | platform_driver_unregister(&cc770_isa_driver); | |
374 | for (idx = 0; idx < ARRAY_SIZE(cc770_isa_devs); idx++) { | |
375 | if (cc770_isa_devs[idx]) | |
376 | platform_device_unregister(cc770_isa_devs[idx]); | |
377 | } | |
378 | } | |
379 | module_exit(cc770_isa_exit); |