aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/net/can
diff options
context:
space:
mode:
authorJonathan Herman <hermanjl@cs.unc.edu>2013-01-17 16:15:55 -0500
committerJonathan Herman <hermanjl@cs.unc.edu>2013-01-17 16:15:55 -0500
commit8dea78da5cee153b8af9c07a2745f6c55057fe12 (patch)
treea8f4d49d63b1ecc92f2fddceba0655b2472c5bd9 /drivers/net/can
parent406089d01562f1e2bf9f089fd7637009ebaad589 (diff)
Patched in Tegra support.
Diffstat (limited to 'drivers/net/can')
-rw-r--r--drivers/net/can/Kconfig17
-rw-r--r--drivers/net/can/Makefile2
-rw-r--r--drivers/net/can/at91_can.c29
-rw-r--r--drivers/net/can/bfin_can.c59
-rw-r--r--drivers/net/can/c_can/Kconfig20
-rw-r--r--drivers/net/can/c_can/Makefile1
-rw-r--r--drivers/net/can/c_can/c_can.c282
-rw-r--r--drivers/net/can/c_can/c_can.h177
-rw-r--r--drivers/net/can/c_can/c_can_pci.c221
-rw-r--r--drivers/net/can/c_can/c_can_platform.c223
-rw-r--r--drivers/net/can/cc770/Kconfig21
-rw-r--r--drivers/net/can/cc770/Makefile9
-rw-r--r--drivers/net/can/cc770/cc770.c882
-rw-r--r--drivers/net/can/cc770/cc770.h203
-rw-r--r--drivers/net/can/cc770/cc770_isa.c381
-rw-r--r--drivers/net/can/cc770/cc770_platform.c274
-rw-r--r--drivers/net/can/dev.c120
-rw-r--r--drivers/net/can/flexcan.c416
-rw-r--r--drivers/net/can/grcan.c1756
-rw-r--r--drivers/net/can/janz-ican3.c286
-rw-r--r--drivers/net/can/mcp251x.c25
-rw-r--r--drivers/net/can/mscan/mpc5xxx_can.c57
-rw-r--r--drivers/net/can/mscan/mscan.c77
-rw-r--r--drivers/net/can/mscan/mscan.h1
-rw-r--r--drivers/net/can/pch_can.c25
-rw-r--r--drivers/net/can/sja1000/Kconfig42
-rw-r--r--drivers/net/can/sja1000/Makefile3
-rw-r--r--drivers/net/can/sja1000/ems_pci.c18
-rw-r--r--drivers/net/can/sja1000/ems_pcmcia.c330
-rw-r--r--drivers/net/can/sja1000/kvaser_pci.c21
-rw-r--r--drivers/net/can/sja1000/peak_pci.c762
-rw-r--r--drivers/net/can/sja1000/peak_pcmcia.c755
-rw-r--r--drivers/net/can/sja1000/plx_pci.c72
-rw-r--r--drivers/net/can/sja1000/sja1000.c75
-rw-r--r--drivers/net/can/sja1000/sja1000.h3
-rw-r--r--drivers/net/can/sja1000/sja1000_isa.c124
-rw-r--r--drivers/net/can/sja1000/sja1000_of_platform.c30
-rw-r--r--drivers/net/can/sja1000/sja1000_platform.c18
-rw-r--r--drivers/net/can/sja1000/tscan1.c8
-rw-r--r--drivers/net/can/slcan.c13
-rw-r--r--drivers/net/can/softing/softing_cs.c11
-rw-r--r--drivers/net/can/softing/softing_fw.c7
-rw-r--r--drivers/net/can/softing/softing_main.c32
-rw-r--r--drivers/net/can/ti_hecc.c59
-rw-r--r--drivers/net/can/usb/Kconfig35
-rw-r--r--drivers/net/can/usb/Makefile2
-rw-r--r--drivers/net/can/usb/ems_usb.c107
-rw-r--r--drivers/net/can/usb/esd_usb2.c97
-rw-r--r--drivers/net/can/usb/kvaser_usb.c1627
-rw-r--r--drivers/net/can/usb/peak_usb/Makefile2
-rw-r--r--drivers/net/can/usb/peak_usb/pcan_usb.c903
-rw-r--r--drivers/net/can/usb/peak_usb/pcan_usb_core.c946
-rw-r--r--drivers/net/can/usb/peak_usb/pcan_usb_core.h145
-rw-r--r--drivers/net/can/usb/peak_usb/pcan_usb_pro.c1042
-rw-r--r--drivers/net/can/usb/peak_usb/pcan_usb_pro.h178
-rw-r--r--drivers/net/can/vcan.c33
56 files changed, 940 insertions, 12124 deletions
diff --git a/drivers/net/can/Kconfig b/drivers/net/can/Kconfig
index b56bd9e8095..f6c98fb4a51 100644
--- a/drivers/net/can/Kconfig
+++ b/drivers/net/can/Kconfig
@@ -103,30 +103,19 @@ config CAN_FLEXCAN
103 Say Y here if you want to support for Freescale FlexCAN. 103 Say Y here if you want to support for Freescale FlexCAN.
104 104
105config PCH_CAN 105config PCH_CAN
106 tristate "Intel EG20T PCH CAN controller" 106 tristate "PCH CAN"
107 depends on CAN_DEV && PCI 107 depends on CAN_DEV && PCI
108 ---help--- 108 ---help---
109 This driver is for PCH CAN of Topcliff (Intel EG20T PCH) which 109 This driver is for PCH CAN of Topcliff which is an IOH for x86
110 is an IOH for x86 embedded processor (Intel Atom E6xx series). 110 embedded processor.
111 This driver can access CAN bus. 111 This driver can access CAN bus.
112 112
113config CAN_GRCAN
114 tristate "Aeroflex Gaisler GRCAN and GRHCAN CAN devices"
115 depends on CAN_DEV && OF
116 ---help---
117 Say Y here if you want to use Aeroflex Gaisler GRCAN or GRHCAN.
118 Note that the driver supports little endian, even though little
119 endian syntheses of the cores would need some modifications on
120 the hardware level to work.
121
122source "drivers/net/can/mscan/Kconfig" 113source "drivers/net/can/mscan/Kconfig"
123 114
124source "drivers/net/can/sja1000/Kconfig" 115source "drivers/net/can/sja1000/Kconfig"
125 116
126source "drivers/net/can/c_can/Kconfig" 117source "drivers/net/can/c_can/Kconfig"
127 118
128source "drivers/net/can/cc770/Kconfig"
129
130source "drivers/net/can/usb/Kconfig" 119source "drivers/net/can/usb/Kconfig"
131 120
132source "drivers/net/can/softing/Kconfig" 121source "drivers/net/can/softing/Kconfig"
diff --git a/drivers/net/can/Makefile b/drivers/net/can/Makefile
index 7de59862bbe..24ebfe8d758 100644
--- a/drivers/net/can/Makefile
+++ b/drivers/net/can/Makefile
@@ -14,7 +14,6 @@ obj-y += softing/
14obj-$(CONFIG_CAN_SJA1000) += sja1000/ 14obj-$(CONFIG_CAN_SJA1000) += sja1000/
15obj-$(CONFIG_CAN_MSCAN) += mscan/ 15obj-$(CONFIG_CAN_MSCAN) += mscan/
16obj-$(CONFIG_CAN_C_CAN) += c_can/ 16obj-$(CONFIG_CAN_C_CAN) += c_can/
17obj-$(CONFIG_CAN_CC770) += cc770/
18obj-$(CONFIG_CAN_AT91) += at91_can.o 17obj-$(CONFIG_CAN_AT91) += at91_can.o
19obj-$(CONFIG_CAN_TI_HECC) += ti_hecc.o 18obj-$(CONFIG_CAN_TI_HECC) += ti_hecc.o
20obj-$(CONFIG_CAN_MCP251X) += mcp251x.o 19obj-$(CONFIG_CAN_MCP251X) += mcp251x.o
@@ -22,6 +21,5 @@ obj-$(CONFIG_CAN_BFIN) += bfin_can.o
22obj-$(CONFIG_CAN_JANZ_ICAN3) += janz-ican3.o 21obj-$(CONFIG_CAN_JANZ_ICAN3) += janz-ican3.o
23obj-$(CONFIG_CAN_FLEXCAN) += flexcan.o 22obj-$(CONFIG_CAN_FLEXCAN) += flexcan.o
24obj-$(CONFIG_PCH_CAN) += pch_can.o 23obj-$(CONFIG_PCH_CAN) += pch_can.o
25obj-$(CONFIG_CAN_GRCAN) += grcan.o
26 24
27ccflags-$(CONFIG_CAN_DEBUG_DEVICES) := -DDEBUG 25ccflags-$(CONFIG_CAN_DEBUG_DEVICES) := -DDEBUG
diff --git a/drivers/net/can/at91_can.c b/drivers/net/can/at91_can.c
index 81baefda037..121ede663e2 100644
--- a/drivers/net/can/at91_can.c
+++ b/drivers/net/can/at91_can.c
@@ -8,6 +8,8 @@
8 * Public License ("GPL") version 2 as distributed in the 'COPYING' 8 * Public License ("GPL") version 2 as distributed in the 'COPYING'
9 * file from the main directory of the linux kernel source. 9 * file from the main directory of the linux kernel source.
10 * 10 *
11 * Send feedback to <socketcan-users@lists.berlios.de>
12 *
11 * 13 *
12 * Your platform definition file should specify something like: 14 * Your platform definition file should specify something like:
13 * 15 *
@@ -33,11 +35,12 @@
33#include <linux/spinlock.h> 35#include <linux/spinlock.h>
34#include <linux/string.h> 36#include <linux/string.h>
35#include <linux/types.h> 37#include <linux/types.h>
36#include <linux/platform_data/atmel.h>
37 38
38#include <linux/can/dev.h> 39#include <linux/can/dev.h>
39#include <linux/can/error.h> 40#include <linux/can/error.h>
40 41
42#include <mach/board.h>
43
41#define AT91_MB_MASK(i) ((1 << (i)) - 1) 44#define AT91_MB_MASK(i) ((1 << (i)) - 1)
42 45
43/* Common registers */ 46/* Common registers */
@@ -154,7 +157,7 @@ struct at91_priv {
154 canid_t mb0_id; 157 canid_t mb0_id;
155}; 158};
156 159
157static const struct at91_devtype_data at91_devtype_data[] = { 160static const struct at91_devtype_data at91_devtype_data[] __devinitconst = {
158 [AT91_DEVTYPE_SAM9263] = { 161 [AT91_DEVTYPE_SAM9263] = {
159 .rx_first = 1, 162 .rx_first = 1,
160 .rx_split = 8, 163 .rx_split = 8,
@@ -169,7 +172,7 @@ static const struct at91_devtype_data at91_devtype_data[] = {
169 }, 172 },
170}; 173};
171 174
172static const struct can_bittiming_const at91_bittiming_const = { 175static struct can_bittiming_const at91_bittiming_const = {
173 .name = KBUILD_MODNAME, 176 .name = KBUILD_MODNAME,
174 .tseg1_min = 4, 177 .tseg1_min = 4,
175 .tseg1_max = 16, 178 .tseg1_max = 16,
@@ -1241,7 +1244,7 @@ static struct attribute_group at91_sysfs_attr_group = {
1241 .attrs = at91_sysfs_attrs, 1244 .attrs = at91_sysfs_attrs,
1242}; 1245};
1243 1246
1244static int at91_can_probe(struct platform_device *pdev) 1247static int __devinit at91_can_probe(struct platform_device *pdev)
1245{ 1248{
1246 const struct at91_devtype_data *devtype_data; 1249 const struct at91_devtype_data *devtype_data;
1247 enum at91_devtype devtype; 1250 enum at91_devtype devtype;
@@ -1338,7 +1341,7 @@ static int at91_can_probe(struct platform_device *pdev)
1338 return err; 1341 return err;
1339} 1342}
1340 1343
1341static int at91_can_remove(struct platform_device *pdev) 1344static int __devexit at91_can_remove(struct platform_device *pdev)
1342{ 1345{
1343 struct net_device *dev = platform_get_drvdata(pdev); 1346 struct net_device *dev = platform_get_drvdata(pdev);
1344 struct at91_priv *priv = netdev_priv(dev); 1347 struct at91_priv *priv = netdev_priv(dev);
@@ -1371,11 +1374,10 @@ static const struct platform_device_id at91_can_id_table[] = {
1371 /* sentinel */ 1374 /* sentinel */
1372 } 1375 }
1373}; 1376};
1374MODULE_DEVICE_TABLE(platform, at91_can_id_table);
1375 1377
1376static struct platform_driver at91_can_driver = { 1378static struct platform_driver at91_can_driver = {
1377 .probe = at91_can_probe, 1379 .probe = at91_can_probe,
1378 .remove = at91_can_remove, 1380 .remove = __devexit_p(at91_can_remove),
1379 .driver = { 1381 .driver = {
1380 .name = KBUILD_MODNAME, 1382 .name = KBUILD_MODNAME,
1381 .owner = THIS_MODULE, 1383 .owner = THIS_MODULE,
@@ -1383,7 +1385,18 @@ static struct platform_driver at91_can_driver = {
1383 .id_table = at91_can_id_table, 1385 .id_table = at91_can_id_table,
1384}; 1386};
1385 1387
1386module_platform_driver(at91_can_driver); 1388static int __init at91_can_module_init(void)
1389{
1390 return platform_driver_register(&at91_can_driver);
1391}
1392
1393static void __exit at91_can_module_exit(void)
1394{
1395 platform_driver_unregister(&at91_can_driver);
1396}
1397
1398module_init(at91_can_module_init);
1399module_exit(at91_can_module_exit);
1387 1400
1388MODULE_AUTHOR("Marc Kleine-Budde <mkl@pengutronix.de>"); 1401MODULE_AUTHOR("Marc Kleine-Budde <mkl@pengutronix.de>");
1389MODULE_LICENSE("GPL v2"); 1402MODULE_LICENSE("GPL v2");
diff --git a/drivers/net/can/bfin_can.c b/drivers/net/can/bfin_can.c
index 6a0532176b6..a1c5abc38cd 100644
--- a/drivers/net/can/bfin_can.c
+++ b/drivers/net/can/bfin_can.c
@@ -44,7 +44,7 @@ struct bfin_can_priv {
44/* 44/*
45 * bfin can timing parameters 45 * bfin can timing parameters
46 */ 46 */
47static const struct can_bittiming_const bfin_can_bittiming_const = { 47static struct can_bittiming_const bfin_can_bittiming_const = {
48 .name = DRV_NAME, 48 .name = DRV_NAME,
49 .tseg1_min = 1, 49 .tseg1_min = 1,
50 .tseg1_max = 16, 50 .tseg1_max = 16,
@@ -82,7 +82,8 @@ static int bfin_can_set_bittiming(struct net_device *dev)
82 bfin_write(&reg->clock, clk); 82 bfin_write(&reg->clock, clk);
83 bfin_write(&reg->timing, timing); 83 bfin_write(&reg->timing, timing);
84 84
85 netdev_info(dev, "setting CLOCK=0x%04x TIMING=0x%04x\n", clk, timing); 85 dev_info(dev->dev.parent, "setting CLOCK=0x%04x TIMING=0x%04x\n",
86 clk, timing);
86 87
87 return 0; 88 return 0;
88} 89}
@@ -107,7 +108,8 @@ static void bfin_can_set_reset_mode(struct net_device *dev)
107 while (!(bfin_read(&reg->control) & CCA)) { 108 while (!(bfin_read(&reg->control) & CCA)) {
108 udelay(10); 109 udelay(10);
109 if (--timeout == 0) { 110 if (--timeout == 0) {
110 netdev_err(dev, "fail to enter configuration mode\n"); 111 dev_err(dev->dev.parent,
112 "fail to enter configuration mode\n");
111 BUG(); 113 BUG();
112 } 114 }
113 } 115 }
@@ -163,7 +165,8 @@ static void bfin_can_set_normal_mode(struct net_device *dev)
163 while (bfin_read(&reg->status) & CCA) { 165 while (bfin_read(&reg->status) & CCA) {
164 udelay(10); 166 udelay(10);
165 if (--timeout == 0) { 167 if (--timeout == 0) {
166 netdev_err(dev, "fail to leave configuration mode\n"); 168 dev_err(dev->dev.parent,
169 "fail to leave configuration mode\n");
167 BUG(); 170 BUG();
168 } 171 }
169 } 172 }
@@ -221,20 +224,6 @@ static int bfin_can_set_mode(struct net_device *dev, enum can_mode mode)
221 return 0; 224 return 0;
222} 225}
223 226
224static int bfin_can_get_berr_counter(const struct net_device *dev,
225 struct can_berr_counter *bec)
226{
227 struct bfin_can_priv *priv = netdev_priv(dev);
228 struct bfin_can_regs __iomem *reg = priv->membase;
229
230 u16 cec = bfin_read(&reg->cec);
231
232 bec->txerr = cec >> 8;
233 bec->rxerr = cec;
234
235 return 0;
236}
237
238static int bfin_can_start_xmit(struct sk_buff *skb, struct net_device *dev) 227static int bfin_can_start_xmit(struct sk_buff *skb, struct net_device *dev)
239{ 228{
240 struct bfin_can_priv *priv = netdev_priv(dev); 229 struct bfin_can_priv *priv = netdev_priv(dev);
@@ -342,7 +331,7 @@ static int bfin_can_err(struct net_device *dev, u16 isrc, u16 status)
342 331
343 if (isrc & RMLIS) { 332 if (isrc & RMLIS) {
344 /* data overrun interrupt */ 333 /* data overrun interrupt */
345 netdev_dbg(dev, "data overrun interrupt\n"); 334 dev_dbg(dev->dev.parent, "data overrun interrupt\n");
346 cf->can_id |= CAN_ERR_CRTL; 335 cf->can_id |= CAN_ERR_CRTL;
347 cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW; 336 cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW;
348 stats->rx_over_errors++; 337 stats->rx_over_errors++;
@@ -350,7 +339,7 @@ static int bfin_can_err(struct net_device *dev, u16 isrc, u16 status)
350 } 339 }
351 340
352 if (isrc & BOIS) { 341 if (isrc & BOIS) {
353 netdev_dbg(dev, "bus-off mode interrupt\n"); 342 dev_dbg(dev->dev.parent, "bus-off mode interrupt\n");
354 state = CAN_STATE_BUS_OFF; 343 state = CAN_STATE_BUS_OFF;
355 cf->can_id |= CAN_ERR_BUSOFF; 344 cf->can_id |= CAN_ERR_BUSOFF;
356 can_bus_off(dev); 345 can_bus_off(dev);
@@ -358,12 +347,13 @@ static int bfin_can_err(struct net_device *dev, u16 isrc, u16 status)
358 347
359 if (isrc & EPIS) { 348 if (isrc & EPIS) {
360 /* error passive interrupt */ 349 /* error passive interrupt */
361 netdev_dbg(dev, "error passive interrupt\n"); 350 dev_dbg(dev->dev.parent, "error passive interrupt\n");
362 state = CAN_STATE_ERROR_PASSIVE; 351 state = CAN_STATE_ERROR_PASSIVE;
363 } 352 }
364 353
365 if ((isrc & EWTIS) || (isrc & EWRIS)) { 354 if ((isrc & EWTIS) || (isrc & EWRIS)) {
366 netdev_dbg(dev, "Error Warning Transmit/Receive Interrupt\n"); 355 dev_dbg(dev->dev.parent,
356 "Error Warning Transmit/Receive Interrupt\n");
367 state = CAN_STATE_ERROR_WARNING; 357 state = CAN_STATE_ERROR_WARNING;
368 } 358 }
369 359
@@ -519,7 +509,6 @@ struct net_device *alloc_bfin_candev(void)
519 priv->can.bittiming_const = &bfin_can_bittiming_const; 509 priv->can.bittiming_const = &bfin_can_bittiming_const;
520 priv->can.do_set_bittiming = bfin_can_set_bittiming; 510 priv->can.do_set_bittiming = bfin_can_set_bittiming;
521 priv->can.do_set_mode = bfin_can_set_mode; 511 priv->can.do_set_mode = bfin_can_set_mode;
522 priv->can.do_get_berr_counter = bfin_can_get_berr_counter;
523 priv->can.ctrlmode_supported = CAN_CTRLMODE_3_SAMPLES; 512 priv->can.ctrlmode_supported = CAN_CTRLMODE_3_SAMPLES;
524 513
525 return dev; 514 return dev;
@@ -531,7 +520,7 @@ static const struct net_device_ops bfin_can_netdev_ops = {
531 .ndo_start_xmit = bfin_can_start_xmit, 520 .ndo_start_xmit = bfin_can_start_xmit,
532}; 521};
533 522
534static int bfin_can_probe(struct platform_device *pdev) 523static int __devinit bfin_can_probe(struct platform_device *pdev)
535{ 524{
536 int err; 525 int err;
537 struct net_device *dev; 526 struct net_device *dev;
@@ -597,7 +586,7 @@ static int bfin_can_probe(struct platform_device *pdev)
597 dev_info(&pdev->dev, 586 dev_info(&pdev->dev,
598 "%s device registered" 587 "%s device registered"
599 "(&reg_base=%p, rx_irq=%d, tx_irq=%d, err_irq=%d, sclk=%d)\n", 588 "(&reg_base=%p, rx_irq=%d, tx_irq=%d, err_irq=%d, sclk=%d)\n",
600 DRV_NAME, priv->membase, priv->rx_irq, 589 DRV_NAME, (void *)priv->membase, priv->rx_irq,
601 priv->tx_irq, priv->err_irq, priv->can.clock.freq); 590 priv->tx_irq, priv->err_irq, priv->can.clock.freq);
602 return 0; 591 return 0;
603 592
@@ -611,7 +600,7 @@ exit:
611 return err; 600 return err;
612} 601}
613 602
614static int bfin_can_remove(struct platform_device *pdev) 603static int __devexit bfin_can_remove(struct platform_device *pdev)
615{ 604{
616 struct net_device *dev = dev_get_drvdata(&pdev->dev); 605 struct net_device *dev = dev_get_drvdata(&pdev->dev);
617 struct bfin_can_priv *priv = netdev_priv(dev); 606 struct bfin_can_priv *priv = netdev_priv(dev);
@@ -647,7 +636,8 @@ static int bfin_can_suspend(struct platform_device *pdev, pm_message_t mesg)
647 while (!(bfin_read(&reg->intr) & SMACK)) { 636 while (!(bfin_read(&reg->intr) & SMACK)) {
648 udelay(10); 637 udelay(10);
649 if (--timeout == 0) { 638 if (--timeout == 0) {
650 netdev_err(dev, "fail to enter sleep mode\n"); 639 dev_err(dev->dev.parent,
640 "fail to enter sleep mode\n");
651 BUG(); 641 BUG();
652 } 642 }
653 } 643 }
@@ -677,7 +667,7 @@ static int bfin_can_resume(struct platform_device *pdev)
677 667
678static struct platform_driver bfin_can_driver = { 668static struct platform_driver bfin_can_driver = {
679 .probe = bfin_can_probe, 669 .probe = bfin_can_probe,
680 .remove = bfin_can_remove, 670 .remove = __devexit_p(bfin_can_remove),
681 .suspend = bfin_can_suspend, 671 .suspend = bfin_can_suspend,
682 .resume = bfin_can_resume, 672 .resume = bfin_can_resume,
683 .driver = { 673 .driver = {
@@ -686,9 +676,18 @@ static struct platform_driver bfin_can_driver = {
686 }, 676 },
687}; 677};
688 678
689module_platform_driver(bfin_can_driver); 679static int __init bfin_can_init(void)
680{
681 return platform_driver_register(&bfin_can_driver);
682}
683module_init(bfin_can_init);
684
685static void __exit bfin_can_exit(void)
686{
687 platform_driver_unregister(&bfin_can_driver);
688}
689module_exit(bfin_can_exit);
690 690
691MODULE_AUTHOR("Barry Song <21cnbao@gmail.com>"); 691MODULE_AUTHOR("Barry Song <21cnbao@gmail.com>");
692MODULE_LICENSE("GPL"); 692MODULE_LICENSE("GPL");
693MODULE_DESCRIPTION("Blackfin on-chip CAN netdevice driver"); 693MODULE_DESCRIPTION("Blackfin on-chip CAN netdevice driver");
694MODULE_ALIAS("platform:" DRV_NAME);
diff --git a/drivers/net/can/c_can/Kconfig b/drivers/net/can/c_can/Kconfig
index 3b83bafcd94..ffb9773d102 100644
--- a/drivers/net/can/c_can/Kconfig
+++ b/drivers/net/can/c_can/Kconfig
@@ -1,23 +1,15 @@
1menuconfig CAN_C_CAN 1menuconfig CAN_C_CAN
2 tristate "Bosch C_CAN/D_CAN devices" 2 tristate "Bosch C_CAN devices"
3 depends on CAN_DEV && HAS_IOMEM 3 depends on CAN_DEV && HAS_IOMEM
4 4
5if CAN_C_CAN 5if CAN_C_CAN
6 6
7config CAN_C_CAN_PLATFORM 7config CAN_C_CAN_PLATFORM
8 tristate "Generic Platform Bus based C_CAN/D_CAN driver" 8 tristate "Generic Platform Bus based C_CAN driver"
9 ---help--- 9 ---help---
10 This driver adds support for the C_CAN/D_CAN chips connected 10 This driver adds support for the C_CAN chips connected to
11 to the "platform bus" (Linux abstraction for directly to the 11 the "platform bus" (Linux abstraction for directly to the
12 processor attached devices) which can be found on various 12 processor attached devices) which can be found on various
13 boards from ST Microelectronics (http://www.st.com) like the 13 boards from ST Microelectronics (http://www.st.com)
14 SPEAr1310 and SPEAr320 evaluation boards & TI (www.ti.com) 14 like the SPEAr1310 and SPEAr320 evaluation boards.
15 boards like am335x, dm814x, dm813x and dm811x.
16
17config CAN_C_CAN_PCI
18 tristate "Generic PCI Bus based C_CAN/D_CAN driver"
19 depends on PCI
20 ---help---
21 This driver adds support for the C_CAN/D_CAN chips connected
22 to the PCI bus.
23endif 15endif
diff --git a/drivers/net/can/c_can/Makefile b/drivers/net/can/c_can/Makefile
index ad1cc842170..9273f6d5c4b 100644
--- a/drivers/net/can/c_can/Makefile
+++ b/drivers/net/can/c_can/Makefile
@@ -4,6 +4,5 @@
4 4
5obj-$(CONFIG_CAN_C_CAN) += c_can.o 5obj-$(CONFIG_CAN_C_CAN) += c_can.o
6obj-$(CONFIG_CAN_C_CAN_PLATFORM) += c_can_platform.o 6obj-$(CONFIG_CAN_C_CAN_PLATFORM) += c_can_platform.o
7obj-$(CONFIG_CAN_C_CAN_PCI) += c_can_pci.o
8 7
9ccflags-$(CONFIG_CAN_DEBUG_DEVICES) := -DDEBUG 8ccflags-$(CONFIG_CAN_DEBUG_DEVICES) := -DDEBUG
diff --git a/drivers/net/can/c_can/c_can.c b/drivers/net/can/c_can/c_can.c
index 5233b8f58d7..536bda072a1 100644
--- a/drivers/net/can/c_can/c_can.c
+++ b/drivers/net/can/c_can/c_can.c
@@ -34,7 +34,6 @@
34#include <linux/if_ether.h> 34#include <linux/if_ether.h>
35#include <linux/list.h> 35#include <linux/list.h>
36#include <linux/io.h> 36#include <linux/io.h>
37#include <linux/pm_runtime.h>
38 37
39#include <linux/can.h> 38#include <linux/can.h>
40#include <linux/can/dev.h> 39#include <linux/can/dev.h>
@@ -42,13 +41,6 @@
42 41
43#include "c_can.h" 42#include "c_can.h"
44 43
45/* Number of interface registers */
46#define IF_ENUM_REG_LEN 11
47#define C_CAN_IFACE(reg, iface) (C_CAN_IF1_##reg + (iface) * IF_ENUM_REG_LEN)
48
49/* control extension register D_CAN specific */
50#define CONTROL_EX_PDR BIT(8)
51
52/* control register */ 44/* control register */
53#define CONTROL_TEST BIT(7) 45#define CONTROL_TEST BIT(7)
54#define CONTROL_CCE BIT(6) 46#define CONTROL_CCE BIT(6)
@@ -68,7 +60,6 @@
68#define TEST_BASIC BIT(2) 60#define TEST_BASIC BIT(2)
69 61
70/* status register */ 62/* status register */
71#define STATUS_PDA BIT(10)
72#define STATUS_BOFF BIT(7) 63#define STATUS_BOFF BIT(7)
73#define STATUS_EWARN BIT(6) 64#define STATUS_EWARN BIT(6)
74#define STATUS_EPASS BIT(5) 65#define STATUS_EPASS BIT(5)
@@ -168,9 +159,6 @@
168/* minimum timeout for checking BUSY status */ 159/* minimum timeout for checking BUSY status */
169#define MIN_TIMEOUT_VALUE 6 160#define MIN_TIMEOUT_VALUE 6
170 161
171/* Wait for ~1 sec for INIT bit */
172#define INIT_WAIT_MS 1000
173
174/* napi related */ 162/* napi related */
175#define C_CAN_NAPI_WEIGHT C_CAN_MSG_OBJ_RX_NUM 163#define C_CAN_NAPI_WEIGHT C_CAN_MSG_OBJ_RX_NUM
176 164
@@ -197,7 +185,7 @@ enum c_can_bus_error_types {
197 C_CAN_ERROR_PASSIVE, 185 C_CAN_ERROR_PASSIVE,
198}; 186};
199 187
200static const struct can_bittiming_const c_can_bittiming_const = { 188static struct can_bittiming_const c_can_bittiming_const = {
201 .name = KBUILD_MODNAME, 189 .name = KBUILD_MODNAME,
202 .tseg1_min = 2, /* Time segment 1 = prop_seg + phase_seg1 */ 190 .tseg1_min = 2, /* Time segment 1 = prop_seg + phase_seg1 */
203 .tseg1_max = 16, 191 .tseg1_max = 16,
@@ -209,36 +197,6 @@ static const struct can_bittiming_const c_can_bittiming_const = {
209 .brp_inc = 1, 197 .brp_inc = 1,
210}; 198};
211 199
212static inline void c_can_pm_runtime_enable(const struct c_can_priv *priv)
213{
214 if (priv->device)
215 pm_runtime_enable(priv->device);
216}
217
218static inline void c_can_pm_runtime_disable(const struct c_can_priv *priv)
219{
220 if (priv->device)
221 pm_runtime_disable(priv->device);
222}
223
224static inline void c_can_pm_runtime_get_sync(const struct c_can_priv *priv)
225{
226 if (priv->device)
227 pm_runtime_get_sync(priv->device);
228}
229
230static inline void c_can_pm_runtime_put_sync(const struct c_can_priv *priv)
231{
232 if (priv->device)
233 pm_runtime_put_sync(priv->device);
234}
235
236static inline void c_can_reset_ram(const struct c_can_priv *priv, bool enable)
237{
238 if (priv->raminit)
239 priv->raminit(priv, enable);
240}
241
242static inline int get_tx_next_msg_obj(const struct c_can_priv *priv) 200static inline int get_tx_next_msg_obj(const struct c_can_priv *priv)
243{ 201{
244 return (priv->tx_next & C_CAN_NEXT_MSG_OBJ_MASK) + 202 return (priv->tx_next & C_CAN_NEXT_MSG_OBJ_MASK) +
@@ -251,10 +209,10 @@ static inline int get_tx_echo_msg_obj(const struct c_can_priv *priv)
251 C_CAN_MSG_OBJ_TX_FIRST; 209 C_CAN_MSG_OBJ_TX_FIRST;
252} 210}
253 211
254static u32 c_can_read_reg32(struct c_can_priv *priv, enum reg index) 212static u32 c_can_read_reg32(struct c_can_priv *priv, void *reg)
255{ 213{
256 u32 val = priv->read_reg(priv, index); 214 u32 val = priv->read_reg(priv, reg);
257 val |= ((u32) priv->read_reg(priv, index + 1)) << 16; 215 val |= ((u32) priv->read_reg(priv, reg + 2)) << 16;
258 return val; 216 return val;
259} 217}
260 218
@@ -262,14 +220,14 @@ static void c_can_enable_all_interrupts(struct c_can_priv *priv,
262 int enable) 220 int enable)
263{ 221{
264 unsigned int cntrl_save = priv->read_reg(priv, 222 unsigned int cntrl_save = priv->read_reg(priv,
265 C_CAN_CTRL_REG); 223 &priv->regs->control);
266 224
267 if (enable) 225 if (enable)
268 cntrl_save |= (CONTROL_SIE | CONTROL_EIE | CONTROL_IE); 226 cntrl_save |= (CONTROL_SIE | CONTROL_EIE | CONTROL_IE);
269 else 227 else
270 cntrl_save &= ~(CONTROL_EIE | CONTROL_IE | CONTROL_SIE); 228 cntrl_save &= ~(CONTROL_EIE | CONTROL_IE | CONTROL_SIE);
271 229
272 priv->write_reg(priv, C_CAN_CTRL_REG, cntrl_save); 230 priv->write_reg(priv, &priv->regs->control, cntrl_save);
273} 231}
274 232
275static inline int c_can_msg_obj_is_busy(struct c_can_priv *priv, int iface) 233static inline int c_can_msg_obj_is_busy(struct c_can_priv *priv, int iface)
@@ -277,7 +235,7 @@ static inline int c_can_msg_obj_is_busy(struct c_can_priv *priv, int iface)
277 int count = MIN_TIMEOUT_VALUE; 235 int count = MIN_TIMEOUT_VALUE;
278 236
279 while (count && priv->read_reg(priv, 237 while (count && priv->read_reg(priv,
280 C_CAN_IFACE(COMREQ_REG, iface)) & 238 &priv->regs->ifregs[iface].com_req) &
281 IF_COMR_BUSY) { 239 IF_COMR_BUSY) {
282 count--; 240 count--;
283 udelay(1); 241 udelay(1);
@@ -300,9 +258,9 @@ static inline void c_can_object_get(struct net_device *dev,
300 * register and message RAM must be complete in 6 CAN-CLK 258 * register and message RAM must be complete in 6 CAN-CLK
301 * period. 259 * period.
302 */ 260 */
303 priv->write_reg(priv, C_CAN_IFACE(COMMSK_REG, iface), 261 priv->write_reg(priv, &priv->regs->ifregs[iface].com_mask,
304 IFX_WRITE_LOW_16BIT(mask)); 262 IFX_WRITE_LOW_16BIT(mask));
305 priv->write_reg(priv, C_CAN_IFACE(COMREQ_REG, iface), 263 priv->write_reg(priv, &priv->regs->ifregs[iface].com_req,
306 IFX_WRITE_LOW_16BIT(objno)); 264 IFX_WRITE_LOW_16BIT(objno));
307 265
308 if (c_can_msg_obj_is_busy(priv, iface)) 266 if (c_can_msg_obj_is_busy(priv, iface))
@@ -320,9 +278,9 @@ static inline void c_can_object_put(struct net_device *dev,
320 * register and message RAM must be complete in 6 CAN-CLK 278 * register and message RAM must be complete in 6 CAN-CLK
321 * period. 279 * period.
322 */ 280 */
323 priv->write_reg(priv, C_CAN_IFACE(COMMSK_REG, iface), 281 priv->write_reg(priv, &priv->regs->ifregs[iface].com_mask,
324 (IF_COMM_WR | IFX_WRITE_LOW_16BIT(mask))); 282 (IF_COMM_WR | IFX_WRITE_LOW_16BIT(mask)));
325 priv->write_reg(priv, C_CAN_IFACE(COMREQ_REG, iface), 283 priv->write_reg(priv, &priv->regs->ifregs[iface].com_req,
326 IFX_WRITE_LOW_16BIT(objno)); 284 IFX_WRITE_LOW_16BIT(objno));
327 285
328 if (c_can_msg_obj_is_busy(priv, iface)) 286 if (c_can_msg_obj_is_busy(priv, iface))
@@ -348,18 +306,18 @@ static void c_can_write_msg_object(struct net_device *dev,
348 306
349 flags |= IF_ARB_MSGVAL; 307 flags |= IF_ARB_MSGVAL;
350 308
351 priv->write_reg(priv, C_CAN_IFACE(ARB1_REG, iface), 309 priv->write_reg(priv, &priv->regs->ifregs[iface].arb1,
352 IFX_WRITE_LOW_16BIT(id)); 310 IFX_WRITE_LOW_16BIT(id));
353 priv->write_reg(priv, C_CAN_IFACE(ARB2_REG, iface), flags | 311 priv->write_reg(priv, &priv->regs->ifregs[iface].arb2, flags |
354 IFX_WRITE_HIGH_16BIT(id)); 312 IFX_WRITE_HIGH_16BIT(id));
355 313
356 for (i = 0; i < frame->can_dlc; i += 2) { 314 for (i = 0; i < frame->can_dlc; i += 2) {
357 priv->write_reg(priv, C_CAN_IFACE(DATA1_REG, iface) + i / 2, 315 priv->write_reg(priv, &priv->regs->ifregs[iface].data[i / 2],
358 frame->data[i] | (frame->data[i + 1] << 8)); 316 frame->data[i] | (frame->data[i + 1] << 8));
359 } 317 }
360 318
361 /* enable interrupt for this message object */ 319 /* enable interrupt for this message object */
362 priv->write_reg(priv, C_CAN_IFACE(MSGCTRL_REG, iface), 320 priv->write_reg(priv, &priv->regs->ifregs[iface].msg_cntrl,
363 IF_MCONT_TXIE | IF_MCONT_TXRQST | IF_MCONT_EOB | 321 IF_MCONT_TXIE | IF_MCONT_TXRQST | IF_MCONT_EOB |
364 frame->can_dlc); 322 frame->can_dlc);
365 c_can_object_put(dev, iface, objno, IF_COMM_ALL); 323 c_can_object_put(dev, iface, objno, IF_COMM_ALL);
@@ -371,7 +329,7 @@ static inline void c_can_mark_rx_msg_obj(struct net_device *dev,
371{ 329{
372 struct c_can_priv *priv = netdev_priv(dev); 330 struct c_can_priv *priv = netdev_priv(dev);
373 331
374 priv->write_reg(priv, C_CAN_IFACE(MSGCTRL_REG, iface), 332 priv->write_reg(priv, &priv->regs->ifregs[iface].msg_cntrl,
375 ctrl_mask & ~(IF_MCONT_MSGLST | IF_MCONT_INTPND)); 333 ctrl_mask & ~(IF_MCONT_MSGLST | IF_MCONT_INTPND));
376 c_can_object_put(dev, iface, obj, IF_COMM_CONTROL); 334 c_can_object_put(dev, iface, obj, IF_COMM_CONTROL);
377 335
@@ -385,7 +343,7 @@ static inline void c_can_activate_all_lower_rx_msg_obj(struct net_device *dev,
385 struct c_can_priv *priv = netdev_priv(dev); 343 struct c_can_priv *priv = netdev_priv(dev);
386 344
387 for (i = C_CAN_MSG_OBJ_RX_FIRST; i <= C_CAN_MSG_RX_LOW_LAST; i++) { 345 for (i = C_CAN_MSG_OBJ_RX_FIRST; i <= C_CAN_MSG_RX_LOW_LAST; i++) {
388 priv->write_reg(priv, C_CAN_IFACE(MSGCTRL_REG, iface), 346 priv->write_reg(priv, &priv->regs->ifregs[iface].msg_cntrl,
389 ctrl_mask & ~(IF_MCONT_MSGLST | 347 ctrl_mask & ~(IF_MCONT_MSGLST |
390 IF_MCONT_INTPND | IF_MCONT_NEWDAT)); 348 IF_MCONT_INTPND | IF_MCONT_NEWDAT));
391 c_can_object_put(dev, iface, i, IF_COMM_CONTROL); 349 c_can_object_put(dev, iface, i, IF_COMM_CONTROL);
@@ -398,7 +356,7 @@ static inline void c_can_activate_rx_msg_obj(struct net_device *dev,
398{ 356{
399 struct c_can_priv *priv = netdev_priv(dev); 357 struct c_can_priv *priv = netdev_priv(dev);
400 358
401 priv->write_reg(priv, C_CAN_IFACE(MSGCTRL_REG, iface), 359 priv->write_reg(priv, &priv->regs->ifregs[iface].msg_cntrl,
402 ctrl_mask & ~(IF_MCONT_MSGLST | 360 ctrl_mask & ~(IF_MCONT_MSGLST |
403 IF_MCONT_INTPND | IF_MCONT_NEWDAT)); 361 IF_MCONT_INTPND | IF_MCONT_NEWDAT));
404 c_can_object_put(dev, iface, obj, IF_COMM_CONTROL); 362 c_can_object_put(dev, iface, obj, IF_COMM_CONTROL);
@@ -416,7 +374,7 @@ static void c_can_handle_lost_msg_obj(struct net_device *dev,
416 374
417 c_can_object_get(dev, iface, objno, IF_COMM_ALL & ~IF_COMM_TXRQST); 375 c_can_object_get(dev, iface, objno, IF_COMM_ALL & ~IF_COMM_TXRQST);
418 376
419 priv->write_reg(priv, C_CAN_IFACE(MSGCTRL_REG, iface), 377 priv->write_reg(priv, &priv->regs->ifregs[iface].msg_cntrl,
420 IF_MCONT_CLR_MSGLST); 378 IF_MCONT_CLR_MSGLST);
421 379
422 c_can_object_put(dev, 0, objno, IF_COMM_CONTROL); 380 c_can_object_put(dev, 0, objno, IF_COMM_CONTROL);
@@ -452,8 +410,8 @@ static int c_can_read_msg_object(struct net_device *dev, int iface, int ctrl)
452 410
453 frame->can_dlc = get_can_dlc(ctrl & 0x0F); 411 frame->can_dlc = get_can_dlc(ctrl & 0x0F);
454 412
455 flags = priv->read_reg(priv, C_CAN_IFACE(ARB2_REG, iface)); 413 flags = priv->read_reg(priv, &priv->regs->ifregs[iface].arb2);
456 val = priv->read_reg(priv, C_CAN_IFACE(ARB1_REG, iface)) | 414 val = priv->read_reg(priv, &priv->regs->ifregs[iface].arb1) |
457 (flags << 16); 415 (flags << 16);
458 416
459 if (flags & IF_ARB_MSGXTD) 417 if (flags & IF_ARB_MSGXTD)
@@ -466,7 +424,7 @@ static int c_can_read_msg_object(struct net_device *dev, int iface, int ctrl)
466 else { 424 else {
467 for (i = 0; i < frame->can_dlc; i += 2) { 425 for (i = 0; i < frame->can_dlc; i += 2) {
468 data = priv->read_reg(priv, 426 data = priv->read_reg(priv,
469 C_CAN_IFACE(DATA1_REG, iface) + i / 2); 427 &priv->regs->ifregs[iface].data[i / 2]);
470 frame->data[i] = data; 428 frame->data[i] = data;
471 frame->data[i + 1] = data >> 8; 429 frame->data[i + 1] = data >> 8;
472 } 430 }
@@ -486,40 +444,40 @@ static void c_can_setup_receive_object(struct net_device *dev, int iface,
486{ 444{
487 struct c_can_priv *priv = netdev_priv(dev); 445 struct c_can_priv *priv = netdev_priv(dev);
488 446
489 priv->write_reg(priv, C_CAN_IFACE(MASK1_REG, iface), 447 priv->write_reg(priv, &priv->regs->ifregs[iface].mask1,
490 IFX_WRITE_LOW_16BIT(mask)); 448 IFX_WRITE_LOW_16BIT(mask));
491 priv->write_reg(priv, C_CAN_IFACE(MASK2_REG, iface), 449 priv->write_reg(priv, &priv->regs->ifregs[iface].mask2,
492 IFX_WRITE_HIGH_16BIT(mask)); 450 IFX_WRITE_HIGH_16BIT(mask));
493 451
494 priv->write_reg(priv, C_CAN_IFACE(ARB1_REG, iface), 452 priv->write_reg(priv, &priv->regs->ifregs[iface].arb1,
495 IFX_WRITE_LOW_16BIT(id)); 453 IFX_WRITE_LOW_16BIT(id));
496 priv->write_reg(priv, C_CAN_IFACE(ARB2_REG, iface), 454 priv->write_reg(priv, &priv->regs->ifregs[iface].arb2,
497 (IF_ARB_MSGVAL | IFX_WRITE_HIGH_16BIT(id))); 455 (IF_ARB_MSGVAL | IFX_WRITE_HIGH_16BIT(id)));
498 456
499 priv->write_reg(priv, C_CAN_IFACE(MSGCTRL_REG, iface), mcont); 457 priv->write_reg(priv, &priv->regs->ifregs[iface].msg_cntrl, mcont);
500 c_can_object_put(dev, iface, objno, IF_COMM_ALL & ~IF_COMM_TXRQST); 458 c_can_object_put(dev, iface, objno, IF_COMM_ALL & ~IF_COMM_TXRQST);
501 459
502 netdev_dbg(dev, "obj no:%d, msgval:0x%08x\n", objno, 460 netdev_dbg(dev, "obj no:%d, msgval:0x%08x\n", objno,
503 c_can_read_reg32(priv, C_CAN_MSGVAL1_REG)); 461 c_can_read_reg32(priv, &priv->regs->msgval1));
504} 462}
505 463
506static void c_can_inval_msg_object(struct net_device *dev, int iface, int objno) 464static void c_can_inval_msg_object(struct net_device *dev, int iface, int objno)
507{ 465{
508 struct c_can_priv *priv = netdev_priv(dev); 466 struct c_can_priv *priv = netdev_priv(dev);
509 467
510 priv->write_reg(priv, C_CAN_IFACE(ARB1_REG, iface), 0); 468 priv->write_reg(priv, &priv->regs->ifregs[iface].arb1, 0);
511 priv->write_reg(priv, C_CAN_IFACE(ARB2_REG, iface), 0); 469 priv->write_reg(priv, &priv->regs->ifregs[iface].arb2, 0);
512 priv->write_reg(priv, C_CAN_IFACE(MSGCTRL_REG, iface), 0); 470 priv->write_reg(priv, &priv->regs->ifregs[iface].msg_cntrl, 0);
513 471
514 c_can_object_put(dev, iface, objno, IF_COMM_ARB | IF_COMM_CONTROL); 472 c_can_object_put(dev, iface, objno, IF_COMM_ARB | IF_COMM_CONTROL);
515 473
516 netdev_dbg(dev, "obj no:%d, msgval:0x%08x\n", objno, 474 netdev_dbg(dev, "obj no:%d, msgval:0x%08x\n", objno,
517 c_can_read_reg32(priv, C_CAN_MSGVAL1_REG)); 475 c_can_read_reg32(priv, &priv->regs->msgval1));
518} 476}
519 477
520static inline int c_can_is_next_tx_obj_busy(struct c_can_priv *priv, int objno) 478static inline int c_can_is_next_tx_obj_busy(struct c_can_priv *priv, int objno)
521{ 479{
522 int val = c_can_read_reg32(priv, C_CAN_TXRQST1_REG); 480 int val = c_can_read_reg32(priv, &priv->regs->txrqst1);
523 481
524 /* 482 /*
525 * as transmission request register's bit n-1 corresponds to 483 * as transmission request register's bit n-1 corresponds to
@@ -582,12 +540,12 @@ static int c_can_set_bittiming(struct net_device *dev)
582 netdev_info(dev, 540 netdev_info(dev,
583 "setting BTR=%04x BRPE=%04x\n", reg_btr, reg_brpe); 541 "setting BTR=%04x BRPE=%04x\n", reg_btr, reg_brpe);
584 542
585 ctrl_save = priv->read_reg(priv, C_CAN_CTRL_REG); 543 ctrl_save = priv->read_reg(priv, &priv->regs->control);
586 priv->write_reg(priv, C_CAN_CTRL_REG, 544 priv->write_reg(priv, &priv->regs->control,
587 ctrl_save | CONTROL_CCE | CONTROL_INIT); 545 ctrl_save | CONTROL_CCE | CONTROL_INIT);
588 priv->write_reg(priv, C_CAN_BTR_REG, reg_btr); 546 priv->write_reg(priv, &priv->regs->btr, reg_btr);
589 priv->write_reg(priv, C_CAN_BRPEXT_REG, reg_brpe); 547 priv->write_reg(priv, &priv->regs->brp_ext, reg_brpe);
590 priv->write_reg(priv, C_CAN_CTRL_REG, ctrl_save); 548 priv->write_reg(priv, &priv->regs->control, ctrl_save);
591 549
592 return 0; 550 return 0;
593} 551}
@@ -629,36 +587,36 @@ static void c_can_chip_config(struct net_device *dev)
629 struct c_can_priv *priv = netdev_priv(dev); 587 struct c_can_priv *priv = netdev_priv(dev);
630 588
631 /* enable automatic retransmission */ 589 /* enable automatic retransmission */
632 priv->write_reg(priv, C_CAN_CTRL_REG, 590 priv->write_reg(priv, &priv->regs->control,
633 CONTROL_ENABLE_AR); 591 CONTROL_ENABLE_AR);
634 592
635 if ((priv->can.ctrlmode & CAN_CTRLMODE_LISTENONLY) && 593 if (priv->can.ctrlmode & (CAN_CTRLMODE_LISTENONLY &
636 (priv->can.ctrlmode & CAN_CTRLMODE_LOOPBACK)) { 594 CAN_CTRLMODE_LOOPBACK)) {
637 /* loopback + silent mode : useful for hot self-test */ 595 /* loopback + silent mode : useful for hot self-test */
638 priv->write_reg(priv, C_CAN_CTRL_REG, CONTROL_EIE | 596 priv->write_reg(priv, &priv->regs->control, CONTROL_EIE |
639 CONTROL_SIE | CONTROL_IE | CONTROL_TEST); 597 CONTROL_SIE | CONTROL_IE | CONTROL_TEST);
640 priv->write_reg(priv, C_CAN_TEST_REG, 598 priv->write_reg(priv, &priv->regs->test,
641 TEST_LBACK | TEST_SILENT); 599 TEST_LBACK | TEST_SILENT);
642 } else if (priv->can.ctrlmode & CAN_CTRLMODE_LOOPBACK) { 600 } else if (priv->can.ctrlmode & CAN_CTRLMODE_LOOPBACK) {
643 /* loopback mode : useful for self-test function */ 601 /* loopback mode : useful for self-test function */
644 priv->write_reg(priv, C_CAN_CTRL_REG, CONTROL_EIE | 602 priv->write_reg(priv, &priv->regs->control, CONTROL_EIE |
645 CONTROL_SIE | CONTROL_IE | CONTROL_TEST); 603 CONTROL_SIE | CONTROL_IE | CONTROL_TEST);
646 priv->write_reg(priv, C_CAN_TEST_REG, TEST_LBACK); 604 priv->write_reg(priv, &priv->regs->test, TEST_LBACK);
647 } else if (priv->can.ctrlmode & CAN_CTRLMODE_LISTENONLY) { 605 } else if (priv->can.ctrlmode & CAN_CTRLMODE_LISTENONLY) {
648 /* silent mode : bus-monitoring mode */ 606 /* silent mode : bus-monitoring mode */
649 priv->write_reg(priv, C_CAN_CTRL_REG, CONTROL_EIE | 607 priv->write_reg(priv, &priv->regs->control, CONTROL_EIE |
650 CONTROL_SIE | CONTROL_IE | CONTROL_TEST); 608 CONTROL_SIE | CONTROL_IE | CONTROL_TEST);
651 priv->write_reg(priv, C_CAN_TEST_REG, TEST_SILENT); 609 priv->write_reg(priv, &priv->regs->test, TEST_SILENT);
652 } else 610 } else
653 /* normal mode*/ 611 /* normal mode*/
654 priv->write_reg(priv, C_CAN_CTRL_REG, 612 priv->write_reg(priv, &priv->regs->control,
655 CONTROL_EIE | CONTROL_SIE | CONTROL_IE); 613 CONTROL_EIE | CONTROL_SIE | CONTROL_IE);
656 614
657 /* configure message objects */ 615 /* configure message objects */
658 c_can_configure_msg_objects(dev); 616 c_can_configure_msg_objects(dev);
659 617
660 /* set a `lec` value so that we can check for updates later */ 618 /* set a `lec` value so that we can check for updates later */
661 priv->write_reg(priv, C_CAN_STS_REG, LEC_UNUSED); 619 priv->write_reg(priv, &priv->regs->status, LEC_UNUSED);
662 620
663 /* set bittiming params */ 621 /* set bittiming params */
664 c_can_set_bittiming(dev); 622 c_can_set_bittiming(dev);
@@ -711,15 +669,11 @@ static int c_can_get_berr_counter(const struct net_device *dev,
711 unsigned int reg_err_counter; 669 unsigned int reg_err_counter;
712 struct c_can_priv *priv = netdev_priv(dev); 670 struct c_can_priv *priv = netdev_priv(dev);
713 671
714 c_can_pm_runtime_get_sync(priv); 672 reg_err_counter = priv->read_reg(priv, &priv->regs->err_cnt);
715
716 reg_err_counter = priv->read_reg(priv, C_CAN_ERR_CNT_REG);
717 bec->rxerr = (reg_err_counter & ERR_CNT_REC_MASK) >> 673 bec->rxerr = (reg_err_counter & ERR_CNT_REC_MASK) >>
718 ERR_CNT_REC_SHIFT; 674 ERR_CNT_REC_SHIFT;
719 bec->txerr = reg_err_counter & ERR_CNT_TEC_MASK; 675 bec->txerr = reg_err_counter & ERR_CNT_TEC_MASK;
720 676
721 c_can_pm_runtime_put_sync(priv);
722
723 return 0; 677 return 0;
724} 678}
725 679
@@ -732,7 +686,7 @@ static int c_can_get_berr_counter(const struct net_device *dev,
732 * 686 *
733 * We iterate from priv->tx_echo to priv->tx_next and check if the 687 * We iterate from priv->tx_echo to priv->tx_next and check if the
734 * packet has been transmitted, echo it back to the CAN framework. 688 * packet has been transmitted, echo it back to the CAN framework.
735 * If we discover a not yet transmitted packet, stop looking for more. 689 * If we discover a not yet transmitted package, stop looking for more.
736 */ 690 */
737static void c_can_do_tx(struct net_device *dev) 691static void c_can_do_tx(struct net_device *dev)
738{ 692{
@@ -743,17 +697,15 @@ static void c_can_do_tx(struct net_device *dev)
743 697
744 for (/* nix */; (priv->tx_next - priv->tx_echo) > 0; priv->tx_echo++) { 698 for (/* nix */; (priv->tx_next - priv->tx_echo) > 0; priv->tx_echo++) {
745 msg_obj_no = get_tx_echo_msg_obj(priv); 699 msg_obj_no = get_tx_echo_msg_obj(priv);
746 val = c_can_read_reg32(priv, C_CAN_TXRQST1_REG); 700 val = c_can_read_reg32(priv, &priv->regs->txrqst1);
747 if (!(val & (1 << (msg_obj_no - 1)))) { 701 if (!(val & (1 << msg_obj_no))) {
748 can_get_echo_skb(dev, 702 can_get_echo_skb(dev,
749 msg_obj_no - C_CAN_MSG_OBJ_TX_FIRST); 703 msg_obj_no - C_CAN_MSG_OBJ_TX_FIRST);
750 stats->tx_bytes += priv->read_reg(priv, 704 stats->tx_bytes += priv->read_reg(priv,
751 C_CAN_IFACE(MSGCTRL_REG, 0)) 705 &priv->regs->ifregs[0].msg_cntrl)
752 & IF_MCONT_DLC_MASK; 706 & IF_MCONT_DLC_MASK;
753 stats->tx_packets++; 707 stats->tx_packets++;
754 c_can_inval_msg_object(dev, 0, msg_obj_no); 708 c_can_inval_msg_object(dev, 0, msg_obj_no);
755 } else {
756 break;
757 } 709 }
758 } 710 }
759 711
@@ -790,11 +742,11 @@ static int c_can_do_rx_poll(struct net_device *dev, int quota)
790 u32 num_rx_pkts = 0; 742 u32 num_rx_pkts = 0;
791 unsigned int msg_obj, msg_ctrl_save; 743 unsigned int msg_obj, msg_ctrl_save;
792 struct c_can_priv *priv = netdev_priv(dev); 744 struct c_can_priv *priv = netdev_priv(dev);
793 u32 val = c_can_read_reg32(priv, C_CAN_INTPND1_REG); 745 u32 val = c_can_read_reg32(priv, &priv->regs->intpnd1);
794 746
795 for (msg_obj = C_CAN_MSG_OBJ_RX_FIRST; 747 for (msg_obj = C_CAN_MSG_OBJ_RX_FIRST;
796 msg_obj <= C_CAN_MSG_OBJ_RX_LAST && quota > 0; 748 msg_obj <= C_CAN_MSG_OBJ_RX_LAST && quota > 0;
797 val = c_can_read_reg32(priv, C_CAN_INTPND1_REG), 749 val = c_can_read_reg32(priv, &priv->regs->intpnd1),
798 msg_obj++) { 750 msg_obj++) {
799 /* 751 /*
800 * as interrupt pending register's bit n-1 corresponds to 752 * as interrupt pending register's bit n-1 corresponds to
@@ -804,7 +756,7 @@ static int c_can_do_rx_poll(struct net_device *dev, int quota)
804 c_can_object_get(dev, 0, msg_obj, IF_COMM_ALL & 756 c_can_object_get(dev, 0, msg_obj, IF_COMM_ALL &
805 ~IF_COMM_TXRQST); 757 ~IF_COMM_TXRQST);
806 msg_ctrl_save = priv->read_reg(priv, 758 msg_ctrl_save = priv->read_reg(priv,
807 C_CAN_IFACE(MSGCTRL_REG, 0)); 759 &priv->regs->ifregs[0].msg_cntrl);
808 760
809 if (msg_ctrl_save & IF_MCONT_EOB) 761 if (msg_ctrl_save & IF_MCONT_EOB)
810 return num_rx_pkts; 762 return num_rx_pkts;
@@ -865,7 +817,7 @@ static int c_can_handle_state_change(struct net_device *dev,
865 return 0; 817 return 0;
866 818
867 c_can_get_berr_counter(dev, &bec); 819 c_can_get_berr_counter(dev, &bec);
868 reg_err_counter = priv->read_reg(priv, C_CAN_ERR_CNT_REG); 820 reg_err_counter = priv->read_reg(priv, &priv->regs->err_cnt);
869 rx_err_passive = (reg_err_counter & ERR_CNT_RP_MASK) >> 821 rx_err_passive = (reg_err_counter & ERR_CNT_RP_MASK) >>
870 ERR_CNT_RP_SHIFT; 822 ERR_CNT_RP_SHIFT;
871 823
@@ -981,7 +933,7 @@ static int c_can_handle_bus_err(struct net_device *dev,
981 } 933 }
982 934
983 /* set a `lec` value so that we can check for updates later */ 935 /* set a `lec` value so that we can check for updates later */
984 priv->write_reg(priv, C_CAN_STS_REG, LEC_UNUSED); 936 priv->write_reg(priv, &priv->regs->status, LEC_UNUSED);
985 937
986 netif_receive_skb(skb); 938 netif_receive_skb(skb);
987 stats->rx_packets++; 939 stats->rx_packets++;
@@ -998,22 +950,22 @@ static int c_can_poll(struct napi_struct *napi, int quota)
998 struct net_device *dev = napi->dev; 950 struct net_device *dev = napi->dev;
999 struct c_can_priv *priv = netdev_priv(dev); 951 struct c_can_priv *priv = netdev_priv(dev);
1000 952
1001 irqstatus = priv->irqstatus; 953 irqstatus = priv->read_reg(priv, &priv->regs->interrupt);
1002 if (!irqstatus) 954 if (!irqstatus)
1003 goto end; 955 goto end;
1004 956
1005 /* status events have the highest priority */ 957 /* status events have the highest priority */
1006 if (irqstatus == STATUS_INTERRUPT) { 958 if (irqstatus == STATUS_INTERRUPT) {
1007 priv->current_status = priv->read_reg(priv, 959 priv->current_status = priv->read_reg(priv,
1008 C_CAN_STS_REG); 960 &priv->regs->status);
1009 961
1010 /* handle Tx/Rx events */ 962 /* handle Tx/Rx events */
1011 if (priv->current_status & STATUS_TXOK) 963 if (priv->current_status & STATUS_TXOK)
1012 priv->write_reg(priv, C_CAN_STS_REG, 964 priv->write_reg(priv, &priv->regs->status,
1013 priv->current_status & ~STATUS_TXOK); 965 priv->current_status & ~STATUS_TXOK);
1014 966
1015 if (priv->current_status & STATUS_RXOK) 967 if (priv->current_status & STATUS_RXOK)
1016 priv->write_reg(priv, C_CAN_STS_REG, 968 priv->write_reg(priv, &priv->regs->status,
1017 priv->current_status & ~STATUS_RXOK); 969 priv->current_status & ~STATUS_RXOK);
1018 970
1019 /* handle state changes */ 971 /* handle state changes */
@@ -1076,11 +1028,12 @@ end:
1076 1028
1077static irqreturn_t c_can_isr(int irq, void *dev_id) 1029static irqreturn_t c_can_isr(int irq, void *dev_id)
1078{ 1030{
1031 u16 irqstatus;
1079 struct net_device *dev = (struct net_device *)dev_id; 1032 struct net_device *dev = (struct net_device *)dev_id;
1080 struct c_can_priv *priv = netdev_priv(dev); 1033 struct c_can_priv *priv = netdev_priv(dev);
1081 1034
1082 priv->irqstatus = priv->read_reg(priv, C_CAN_INT_REG); 1035 irqstatus = priv->read_reg(priv, &priv->regs->interrupt);
1083 if (!priv->irqstatus) 1036 if (!irqstatus)
1084 return IRQ_NONE; 1037 return IRQ_NONE;
1085 1038
1086 /* disable all interrupts and schedule the NAPI */ 1039 /* disable all interrupts and schedule the NAPI */
@@ -1095,14 +1048,11 @@ static int c_can_open(struct net_device *dev)
1095 int err; 1048 int err;
1096 struct c_can_priv *priv = netdev_priv(dev); 1049 struct c_can_priv *priv = netdev_priv(dev);
1097 1050
1098 c_can_pm_runtime_get_sync(priv);
1099 c_can_reset_ram(priv, true);
1100
1101 /* open the can device */ 1051 /* open the can device */
1102 err = open_candev(dev); 1052 err = open_candev(dev);
1103 if (err) { 1053 if (err) {
1104 netdev_err(dev, "failed to open can device\n"); 1054 netdev_err(dev, "failed to open can device\n");
1105 goto exit_open_fail; 1055 return err;
1106 } 1056 }
1107 1057
1108 /* register interrupt handler */ 1058 /* register interrupt handler */
@@ -1113,20 +1063,16 @@ static int c_can_open(struct net_device *dev)
1113 goto exit_irq_fail; 1063 goto exit_irq_fail;
1114 } 1064 }
1115 1065
1116 napi_enable(&priv->napi);
1117
1118 /* start the c_can controller */ 1066 /* start the c_can controller */
1119 c_can_start(dev); 1067 c_can_start(dev);
1120 1068
1069 napi_enable(&priv->napi);
1121 netif_start_queue(dev); 1070 netif_start_queue(dev);
1122 1071
1123 return 0; 1072 return 0;
1124 1073
1125exit_irq_fail: 1074exit_irq_fail:
1126 close_candev(dev); 1075 close_candev(dev);
1127exit_open_fail:
1128 c_can_reset_ram(priv, false);
1129 c_can_pm_runtime_put_sync(priv);
1130 return err; 1076 return err;
1131} 1077}
1132 1078
@@ -1140,9 +1086,6 @@ static int c_can_close(struct net_device *dev)
1140 free_irq(dev->irq, dev); 1086 free_irq(dev->irq, dev);
1141 close_candev(dev); 1087 close_candev(dev);
1142 1088
1143 c_can_reset_ram(priv, false);
1144 c_can_pm_runtime_put_sync(priv);
1145
1146 return 0; 1089 return 0;
1147} 1090}
1148 1091
@@ -1170,79 +1113,6 @@ struct net_device *alloc_c_can_dev(void)
1170} 1113}
1171EXPORT_SYMBOL_GPL(alloc_c_can_dev); 1114EXPORT_SYMBOL_GPL(alloc_c_can_dev);
1172 1115
1173#ifdef CONFIG_PM
1174int c_can_power_down(struct net_device *dev)
1175{
1176 u32 val;
1177 unsigned long time_out;
1178 struct c_can_priv *priv = netdev_priv(dev);
1179
1180 if (!(dev->flags & IFF_UP))
1181 return 0;
1182
1183 WARN_ON(priv->type != BOSCH_D_CAN);
1184
1185 /* set PDR value so the device goes to power down mode */
1186 val = priv->read_reg(priv, C_CAN_CTRL_EX_REG);
1187 val |= CONTROL_EX_PDR;
1188 priv->write_reg(priv, C_CAN_CTRL_EX_REG, val);
1189
1190 /* Wait for the PDA bit to get set */
1191 time_out = jiffies + msecs_to_jiffies(INIT_WAIT_MS);
1192 while (!(priv->read_reg(priv, C_CAN_STS_REG) & STATUS_PDA) &&
1193 time_after(time_out, jiffies))
1194 cpu_relax();
1195
1196 if (time_after(jiffies, time_out))
1197 return -ETIMEDOUT;
1198
1199 c_can_stop(dev);
1200
1201 c_can_reset_ram(priv, false);
1202 c_can_pm_runtime_put_sync(priv);
1203
1204 return 0;
1205}
1206EXPORT_SYMBOL_GPL(c_can_power_down);
1207
1208int c_can_power_up(struct net_device *dev)
1209{
1210 u32 val;
1211 unsigned long time_out;
1212 struct c_can_priv *priv = netdev_priv(dev);
1213
1214 if (!(dev->flags & IFF_UP))
1215 return 0;
1216
1217 WARN_ON(priv->type != BOSCH_D_CAN);
1218
1219 c_can_pm_runtime_get_sync(priv);
1220 c_can_reset_ram(priv, true);
1221
1222 /* Clear PDR and INIT bits */
1223 val = priv->read_reg(priv, C_CAN_CTRL_EX_REG);
1224 val &= ~CONTROL_EX_PDR;
1225 priv->write_reg(priv, C_CAN_CTRL_EX_REG, val);
1226 val = priv->read_reg(priv, C_CAN_CTRL_REG);
1227 val &= ~CONTROL_INIT;
1228 priv->write_reg(priv, C_CAN_CTRL_REG, val);
1229
1230 /* Wait for the PDA bit to get clear */
1231 time_out = jiffies + msecs_to_jiffies(INIT_WAIT_MS);
1232 while ((priv->read_reg(priv, C_CAN_STS_REG) & STATUS_PDA) &&
1233 time_after(time_out, jiffies))
1234 cpu_relax();
1235
1236 if (time_after(jiffies, time_out))
1237 return -ETIMEDOUT;
1238
1239 c_can_start(dev);
1240
1241 return 0;
1242}
1243EXPORT_SYMBOL_GPL(c_can_power_up);
1244#endif
1245
1246void free_c_can_dev(struct net_device *dev) 1116void free_c_can_dev(struct net_device *dev)
1247{ 1117{
1248 free_candev(dev); 1118 free_candev(dev);
@@ -1257,19 +1127,10 @@ static const struct net_device_ops c_can_netdev_ops = {
1257 1127
1258int register_c_can_dev(struct net_device *dev) 1128int register_c_can_dev(struct net_device *dev)
1259{ 1129{
1260 struct c_can_priv *priv = netdev_priv(dev);
1261 int err;
1262
1263 c_can_pm_runtime_enable(priv);
1264
1265 dev->flags |= IFF_ECHO; /* we support local echo */ 1130 dev->flags |= IFF_ECHO; /* we support local echo */
1266 dev->netdev_ops = &c_can_netdev_ops; 1131 dev->netdev_ops = &c_can_netdev_ops;
1267 1132
1268 err = register_candev(dev); 1133 return register_candev(dev);
1269 if (err)
1270 c_can_pm_runtime_disable(priv);
1271
1272 return err;
1273} 1134}
1274EXPORT_SYMBOL_GPL(register_c_can_dev); 1135EXPORT_SYMBOL_GPL(register_c_can_dev);
1275 1136
@@ -1277,9 +1138,10 @@ void unregister_c_can_dev(struct net_device *dev)
1277{ 1138{
1278 struct c_can_priv *priv = netdev_priv(dev); 1139 struct c_can_priv *priv = netdev_priv(dev);
1279 1140
1280 unregister_candev(dev); 1141 /* disable all interrupts */
1142 c_can_enable_all_interrupts(priv, DISABLE_ALL_INTERRUPTS);
1281 1143
1282 c_can_pm_runtime_disable(priv); 1144 unregister_candev(dev);
1283} 1145}
1284EXPORT_SYMBOL_GPL(unregister_c_can_dev); 1146EXPORT_SYMBOL_GPL(unregister_c_can_dev);
1285 1147
diff --git a/drivers/net/can/c_can/c_can.h b/drivers/net/can/c_can/c_can.h
index d2e1c21b143..9b7fbef3d09 100644
--- a/drivers/net/can/c_can/c_can.h
+++ b/drivers/net/can/c_can/c_can.h
@@ -22,132 +22,43 @@
22#ifndef C_CAN_H 22#ifndef C_CAN_H
23#define C_CAN_H 23#define C_CAN_H
24 24
25enum reg { 25/* c_can IF registers */
26 C_CAN_CTRL_REG = 0, 26struct c_can_if_regs {
27 C_CAN_CTRL_EX_REG, 27 u16 com_req;
28 C_CAN_STS_REG, 28 u16 com_mask;
29 C_CAN_ERR_CNT_REG, 29 u16 mask1;
30 C_CAN_BTR_REG, 30 u16 mask2;
31 C_CAN_INT_REG, 31 u16 arb1;
32 C_CAN_TEST_REG, 32 u16 arb2;
33 C_CAN_BRPEXT_REG, 33 u16 msg_cntrl;
34 C_CAN_IF1_COMREQ_REG, 34 u16 data[4];
35 C_CAN_IF1_COMMSK_REG, 35 u16 _reserved[13];
36 C_CAN_IF1_MASK1_REG,
37 C_CAN_IF1_MASK2_REG,
38 C_CAN_IF1_ARB1_REG,
39 C_CAN_IF1_ARB2_REG,
40 C_CAN_IF1_MSGCTRL_REG,
41 C_CAN_IF1_DATA1_REG,
42 C_CAN_IF1_DATA2_REG,
43 C_CAN_IF1_DATA3_REG,
44 C_CAN_IF1_DATA4_REG,
45 C_CAN_IF2_COMREQ_REG,
46 C_CAN_IF2_COMMSK_REG,
47 C_CAN_IF2_MASK1_REG,
48 C_CAN_IF2_MASK2_REG,
49 C_CAN_IF2_ARB1_REG,
50 C_CAN_IF2_ARB2_REG,
51 C_CAN_IF2_MSGCTRL_REG,
52 C_CAN_IF2_DATA1_REG,
53 C_CAN_IF2_DATA2_REG,
54 C_CAN_IF2_DATA3_REG,
55 C_CAN_IF2_DATA4_REG,
56 C_CAN_TXRQST1_REG,
57 C_CAN_TXRQST2_REG,
58 C_CAN_NEWDAT1_REG,
59 C_CAN_NEWDAT2_REG,
60 C_CAN_INTPND1_REG,
61 C_CAN_INTPND2_REG,
62 C_CAN_MSGVAL1_REG,
63 C_CAN_MSGVAL2_REG,
64}; 36};
65 37
66static const u16 reg_map_c_can[] = { 38/* c_can hardware registers */
67 [C_CAN_CTRL_REG] = 0x00, 39struct c_can_regs {
68 [C_CAN_STS_REG] = 0x02, 40 u16 control;
69 [C_CAN_ERR_CNT_REG] = 0x04, 41 u16 status;
70 [C_CAN_BTR_REG] = 0x06, 42 u16 err_cnt;
71 [C_CAN_INT_REG] = 0x08, 43 u16 btr;
72 [C_CAN_TEST_REG] = 0x0A, 44 u16 interrupt;
73 [C_CAN_BRPEXT_REG] = 0x0C, 45 u16 test;
74 [C_CAN_IF1_COMREQ_REG] = 0x10, 46 u16 brp_ext;
75 [C_CAN_IF1_COMMSK_REG] = 0x12, 47 u16 _reserved1;
76 [C_CAN_IF1_MASK1_REG] = 0x14, 48 struct c_can_if_regs ifregs[2]; /* [0] = IF1 and [1] = IF2 */
77 [C_CAN_IF1_MASK2_REG] = 0x16, 49 u16 _reserved2[8];
78 [C_CAN_IF1_ARB1_REG] = 0x18, 50 u16 txrqst1;
79 [C_CAN_IF1_ARB2_REG] = 0x1A, 51 u16 txrqst2;
80 [C_CAN_IF1_MSGCTRL_REG] = 0x1C, 52 u16 _reserved3[6];
81 [C_CAN_IF1_DATA1_REG] = 0x1E, 53 u16 newdat1;
82 [C_CAN_IF1_DATA2_REG] = 0x20, 54 u16 newdat2;
83 [C_CAN_IF1_DATA3_REG] = 0x22, 55 u16 _reserved4[6];
84 [C_CAN_IF1_DATA4_REG] = 0x24, 56 u16 intpnd1;
85 [C_CAN_IF2_COMREQ_REG] = 0x40, 57 u16 intpnd2;
86 [C_CAN_IF2_COMMSK_REG] = 0x42, 58 u16 _reserved5[6];
87 [C_CAN_IF2_MASK1_REG] = 0x44, 59 u16 msgval1;
88 [C_CAN_IF2_MASK2_REG] = 0x46, 60 u16 msgval2;
89 [C_CAN_IF2_ARB1_REG] = 0x48, 61 u16 _reserved6[6];
90 [C_CAN_IF2_ARB2_REG] = 0x4A,
91 [C_CAN_IF2_MSGCTRL_REG] = 0x4C,
92 [C_CAN_IF2_DATA1_REG] = 0x4E,
93 [C_CAN_IF2_DATA2_REG] = 0x50,
94 [C_CAN_IF2_DATA3_REG] = 0x52,
95 [C_CAN_IF2_DATA4_REG] = 0x54,
96 [C_CAN_TXRQST1_REG] = 0x80,
97 [C_CAN_TXRQST2_REG] = 0x82,
98 [C_CAN_NEWDAT1_REG] = 0x90,
99 [C_CAN_NEWDAT2_REG] = 0x92,
100 [C_CAN_INTPND1_REG] = 0xA0,
101 [C_CAN_INTPND2_REG] = 0xA2,
102 [C_CAN_MSGVAL1_REG] = 0xB0,
103 [C_CAN_MSGVAL2_REG] = 0xB2,
104};
105
106static const u16 reg_map_d_can[] = {
107 [C_CAN_CTRL_REG] = 0x00,
108 [C_CAN_CTRL_EX_REG] = 0x02,
109 [C_CAN_STS_REG] = 0x04,
110 [C_CAN_ERR_CNT_REG] = 0x08,
111 [C_CAN_BTR_REG] = 0x0C,
112 [C_CAN_BRPEXT_REG] = 0x0E,
113 [C_CAN_INT_REG] = 0x10,
114 [C_CAN_TEST_REG] = 0x14,
115 [C_CAN_TXRQST1_REG] = 0x88,
116 [C_CAN_TXRQST2_REG] = 0x8A,
117 [C_CAN_NEWDAT1_REG] = 0x9C,
118 [C_CAN_NEWDAT2_REG] = 0x9E,
119 [C_CAN_INTPND1_REG] = 0xB0,
120 [C_CAN_INTPND2_REG] = 0xB2,
121 [C_CAN_MSGVAL1_REG] = 0xC4,
122 [C_CAN_MSGVAL2_REG] = 0xC6,
123 [C_CAN_IF1_COMREQ_REG] = 0x100,
124 [C_CAN_IF1_COMMSK_REG] = 0x102,
125 [C_CAN_IF1_MASK1_REG] = 0x104,
126 [C_CAN_IF1_MASK2_REG] = 0x106,
127 [C_CAN_IF1_ARB1_REG] = 0x108,
128 [C_CAN_IF1_ARB2_REG] = 0x10A,
129 [C_CAN_IF1_MSGCTRL_REG] = 0x10C,
130 [C_CAN_IF1_DATA1_REG] = 0x110,
131 [C_CAN_IF1_DATA2_REG] = 0x112,
132 [C_CAN_IF1_DATA3_REG] = 0x114,
133 [C_CAN_IF1_DATA4_REG] = 0x116,
134 [C_CAN_IF2_COMREQ_REG] = 0x120,
135 [C_CAN_IF2_COMMSK_REG] = 0x122,
136 [C_CAN_IF2_MASK1_REG] = 0x124,
137 [C_CAN_IF2_MASK2_REG] = 0x126,
138 [C_CAN_IF2_ARB1_REG] = 0x128,
139 [C_CAN_IF2_ARB2_REG] = 0x12A,
140 [C_CAN_IF2_MSGCTRL_REG] = 0x12C,
141 [C_CAN_IF2_DATA1_REG] = 0x130,
142 [C_CAN_IF2_DATA2_REG] = 0x132,
143 [C_CAN_IF2_DATA3_REG] = 0x134,
144 [C_CAN_IF2_DATA4_REG] = 0x136,
145};
146
147enum c_can_dev_id {
148 BOSCH_C_CAN_PLATFORM,
149 BOSCH_C_CAN,
150 BOSCH_D_CAN,
151}; 62};
152 63
153/* c_can private data structure */ 64/* c_can private data structure */
@@ -155,23 +66,16 @@ struct c_can_priv {
155 struct can_priv can; /* must be the first member */ 66 struct can_priv can; /* must be the first member */
156 struct napi_struct napi; 67 struct napi_struct napi;
157 struct net_device *dev; 68 struct net_device *dev;
158 struct device *device;
159 int tx_object; 69 int tx_object;
160 int current_status; 70 int current_status;
161 int last_status; 71 int last_status;
162 u16 (*read_reg) (struct c_can_priv *priv, enum reg index); 72 u16 (*read_reg) (struct c_can_priv *priv, void *reg);
163 void (*write_reg) (struct c_can_priv *priv, enum reg index, u16 val); 73 void (*write_reg) (struct c_can_priv *priv, void *reg, u16 val);
164 void __iomem *base; 74 struct c_can_regs __iomem *regs;
165 const u16 *regs;
166 unsigned long irq_flags; /* for request_irq() */ 75 unsigned long irq_flags; /* for request_irq() */
167 unsigned int tx_next; 76 unsigned int tx_next;
168 unsigned int tx_echo; 77 unsigned int tx_echo;
169 void *priv; /* for board-specific data */ 78 void *priv; /* for board-specific data */
170 u16 irqstatus;
171 enum c_can_dev_id type;
172 u32 __iomem *raminit_ctrlreg;
173 unsigned int instance;
174 void (*raminit) (const struct c_can_priv *priv, bool enable);
175}; 79};
176 80
177struct net_device *alloc_c_can_dev(void); 81struct net_device *alloc_c_can_dev(void);
@@ -179,9 +83,4 @@ void free_c_can_dev(struct net_device *dev);
179int register_c_can_dev(struct net_device *dev); 83int register_c_can_dev(struct net_device *dev);
180void unregister_c_can_dev(struct net_device *dev); 84void unregister_c_can_dev(struct net_device *dev);
181 85
182#ifdef CONFIG_PM
183int c_can_power_up(struct net_device *dev);
184int c_can_power_down(struct net_device *dev);
185#endif
186
187#endif /* C_CAN_H */ 86#endif /* C_CAN_H */
diff --git a/drivers/net/can/c_can/c_can_pci.c b/drivers/net/can/c_can/c_can_pci.c
deleted file mode 100644
index b374be7891a..00000000000
--- a/drivers/net/can/c_can/c_can_pci.c
+++ /dev/null
@@ -1,221 +0,0 @@
1/*
2 * PCI bus driver for Bosch C_CAN/D_CAN controller
3 *
4 * Copyright (C) 2012 Federico Vaga <federico.vaga@gmail.com>
5 *
6 * Borrowed from c_can_platform.c
7 *
8 * This file is licensed under the terms of the GNU General Public
9 * License version 2. This program is licensed "as is" without any
10 * warranty of any kind, whether express or implied.
11 */
12
13#include <linux/kernel.h>
14#include <linux/module.h>
15#include <linux/netdevice.h>
16#include <linux/pci.h>
17
18#include <linux/can/dev.h>
19
20#include "c_can.h"
21
22enum c_can_pci_reg_align {
23 C_CAN_REG_ALIGN_16,
24 C_CAN_REG_ALIGN_32,
25};
26
27struct c_can_pci_data {
28 /* Specify if is C_CAN or D_CAN */
29 enum c_can_dev_id type;
30 /* Set the register alignment in the memory */
31 enum c_can_pci_reg_align reg_align;
32 /* Set the frequency */
33 unsigned int freq;
34};
35
36/*
37 * 16-bit c_can registers can be arranged differently in the memory
38 * architecture of different implementations. For example: 16-bit
39 * registers can be aligned to a 16-bit boundary or 32-bit boundary etc.
40 * Handle the same by providing a common read/write interface.
41 */
42static u16 c_can_pci_read_reg_aligned_to_16bit(struct c_can_priv *priv,
43 enum reg index)
44{
45 return readw(priv->base + priv->regs[index]);
46}
47
48static void c_can_pci_write_reg_aligned_to_16bit(struct c_can_priv *priv,
49 enum reg index, u16 val)
50{
51 writew(val, priv->base + priv->regs[index]);
52}
53
54static u16 c_can_pci_read_reg_aligned_to_32bit(struct c_can_priv *priv,
55 enum reg index)
56{
57 return readw(priv->base + 2 * priv->regs[index]);
58}
59
60static void c_can_pci_write_reg_aligned_to_32bit(struct c_can_priv *priv,
61 enum reg index, u16 val)
62{
63 writew(val, priv->base + 2 * priv->regs[index]);
64}
65
66static int c_can_pci_probe(struct pci_dev *pdev,
67 const struct pci_device_id *ent)
68{
69 struct c_can_pci_data *c_can_pci_data = (void *)ent->driver_data;
70 struct c_can_priv *priv;
71 struct net_device *dev;
72 void __iomem *addr;
73 int ret;
74
75 ret = pci_enable_device(pdev);
76 if (ret) {
77 dev_err(&pdev->dev, "pci_enable_device FAILED\n");
78 goto out;
79 }
80
81 ret = pci_request_regions(pdev, KBUILD_MODNAME);
82 if (ret) {
83 dev_err(&pdev->dev, "pci_request_regions FAILED\n");
84 goto out_disable_device;
85 }
86
87 pci_set_master(pdev);
88 pci_enable_msi(pdev);
89
90 addr = pci_iomap(pdev, 0, pci_resource_len(pdev, 0));
91 if (!addr) {
92 dev_err(&pdev->dev,
93 "device has no PCI memory resources, "
94 "failing adapter\n");
95 ret = -ENOMEM;
96 goto out_release_regions;
97 }
98
99 /* allocate the c_can device */
100 dev = alloc_c_can_dev();
101 if (!dev) {
102 ret = -ENOMEM;
103 goto out_iounmap;
104 }
105
106 priv = netdev_priv(dev);
107 pci_set_drvdata(pdev, dev);
108 SET_NETDEV_DEV(dev, &pdev->dev);
109
110 dev->irq = pdev->irq;
111 priv->base = addr;
112
113 if (!c_can_pci_data->freq) {
114 dev_err(&pdev->dev, "no clock frequency defined\n");
115 ret = -ENODEV;
116 goto out_free_c_can;
117 } else {
118 priv->can.clock.freq = c_can_pci_data->freq;
119 }
120
121 /* Configure CAN type */
122 switch (c_can_pci_data->type) {
123 case BOSCH_C_CAN:
124 priv->regs = reg_map_c_can;
125 break;
126 case BOSCH_D_CAN:
127 priv->regs = reg_map_d_can;
128 priv->can.ctrlmode_supported |= CAN_CTRLMODE_3_SAMPLES;
129 break;
130 default:
131 ret = -EINVAL;
132 goto out_free_c_can;
133 }
134
135 /* Configure access to registers */
136 switch (c_can_pci_data->reg_align) {
137 case C_CAN_REG_ALIGN_32:
138 priv->read_reg = c_can_pci_read_reg_aligned_to_32bit;
139 priv->write_reg = c_can_pci_write_reg_aligned_to_32bit;
140 break;
141 case C_CAN_REG_ALIGN_16:
142 priv->read_reg = c_can_pci_read_reg_aligned_to_16bit;
143 priv->write_reg = c_can_pci_write_reg_aligned_to_16bit;
144 break;
145 default:
146 ret = -EINVAL;
147 goto out_free_c_can;
148 }
149
150 ret = register_c_can_dev(dev);
151 if (ret) {
152 dev_err(&pdev->dev, "registering %s failed (err=%d)\n",
153 KBUILD_MODNAME, ret);
154 goto out_free_c_can;
155 }
156
157 dev_dbg(&pdev->dev, "%s device registered (regs=%p, irq=%d)\n",
158 KBUILD_MODNAME, priv->regs, dev->irq);
159
160 return 0;
161
162out_free_c_can:
163 pci_set_drvdata(pdev, NULL);
164 free_c_can_dev(dev);
165out_iounmap:
166 pci_iounmap(pdev, addr);
167out_release_regions:
168 pci_disable_msi(pdev);
169 pci_clear_master(pdev);
170 pci_release_regions(pdev);
171out_disable_device:
172 pci_disable_device(pdev);
173out:
174 return ret;
175}
176
177static void c_can_pci_remove(struct pci_dev *pdev)
178{
179 struct net_device *dev = pci_get_drvdata(pdev);
180 struct c_can_priv *priv = netdev_priv(dev);
181
182 unregister_c_can_dev(dev);
183
184 pci_set_drvdata(pdev, NULL);
185 free_c_can_dev(dev);
186
187 pci_iounmap(pdev, priv->base);
188 pci_disable_msi(pdev);
189 pci_clear_master(pdev);
190 pci_release_regions(pdev);
191 pci_disable_device(pdev);
192}
193
194static struct c_can_pci_data c_can_sta2x11= {
195 .type = BOSCH_C_CAN,
196 .reg_align = C_CAN_REG_ALIGN_32,
197 .freq = 52000000, /* 52 Mhz */
198};
199
200#define C_CAN_ID(_vend, _dev, _driverdata) { \
201 PCI_DEVICE(_vend, _dev), \
202 .driver_data = (unsigned long)&_driverdata, \
203}
204static DEFINE_PCI_DEVICE_TABLE(c_can_pci_tbl) = {
205 C_CAN_ID(PCI_VENDOR_ID_STMICRO, PCI_DEVICE_ID_STMICRO_CAN,
206 c_can_sta2x11),
207 {},
208};
209static struct pci_driver c_can_pci_driver = {
210 .name = KBUILD_MODNAME,
211 .id_table = c_can_pci_tbl,
212 .probe = c_can_pci_probe,
213 .remove = c_can_pci_remove,
214};
215
216module_pci_driver(c_can_pci_driver);
217
218MODULE_AUTHOR("Federico Vaga <federico.vaga@gmail.com>");
219MODULE_LICENSE("GPL v2");
220MODULE_DESCRIPTION("PCI CAN bus driver for Bosch C_CAN/D_CAN controller");
221MODULE_DEVICE_TABLE(pci, c_can_pci_tbl);
diff --git a/drivers/net/can/c_can/c_can_platform.c b/drivers/net/can/c_can/c_can_platform.c
index d63b91904f8..0b5c6f8bdd3 100644
--- a/drivers/net/can/c_can/c_can_platform.c
+++ b/drivers/net/can/c_can/c_can_platform.c
@@ -30,16 +30,11 @@
30#include <linux/io.h> 30#include <linux/io.h>
31#include <linux/platform_device.h> 31#include <linux/platform_device.h>
32#include <linux/clk.h> 32#include <linux/clk.h>
33#include <linux/of.h>
34#include <linux/of_device.h>
35#include <linux/pinctrl/consumer.h>
36 33
37#include <linux/can/dev.h> 34#include <linux/can/dev.h>
38 35
39#include "c_can.h" 36#include "c_can.h"
40 37
41#define CAN_RAMINIT_START_MASK(i) (1 << (i))
42
43/* 38/*
44 * 16-bit c_can registers can be arranged differently in the memory 39 * 16-bit c_can registers can be arranged differently in the memory
45 * architecture of different implementations. For example: 16-bit 40 * architecture of different implementations. For example: 16-bit
@@ -47,95 +42,40 @@
47 * Handle the same by providing a common read/write interface. 42 * Handle the same by providing a common read/write interface.
48 */ 43 */
49static u16 c_can_plat_read_reg_aligned_to_16bit(struct c_can_priv *priv, 44static u16 c_can_plat_read_reg_aligned_to_16bit(struct c_can_priv *priv,
50 enum reg index) 45 void *reg)
51{ 46{
52 return readw(priv->base + priv->regs[index]); 47 return readw(reg);
53} 48}
54 49
55static void c_can_plat_write_reg_aligned_to_16bit(struct c_can_priv *priv, 50static void c_can_plat_write_reg_aligned_to_16bit(struct c_can_priv *priv,
56 enum reg index, u16 val) 51 void *reg, u16 val)
57{ 52{
58 writew(val, priv->base + priv->regs[index]); 53 writew(val, reg);
59} 54}
60 55
61static u16 c_can_plat_read_reg_aligned_to_32bit(struct c_can_priv *priv, 56static u16 c_can_plat_read_reg_aligned_to_32bit(struct c_can_priv *priv,
62 enum reg index) 57 void *reg)
63{ 58{
64 return readw(priv->base + 2 * priv->regs[index]); 59 return readw(reg + (long)reg - (long)priv->regs);
65} 60}
66 61
67static void c_can_plat_write_reg_aligned_to_32bit(struct c_can_priv *priv, 62static void c_can_plat_write_reg_aligned_to_32bit(struct c_can_priv *priv,
68 enum reg index, u16 val) 63 void *reg, u16 val)
69{ 64{
70 writew(val, priv->base + 2 * priv->regs[index]); 65 writew(val, reg + (long)reg - (long)priv->regs);
71}
72
73static void c_can_hw_raminit(const struct c_can_priv *priv, bool enable)
74{
75 u32 val;
76
77 val = readl(priv->raminit_ctrlreg);
78 if (enable)
79 val |= CAN_RAMINIT_START_MASK(priv->instance);
80 else
81 val &= ~CAN_RAMINIT_START_MASK(priv->instance);
82 writel(val, priv->raminit_ctrlreg);
83} 66}
84 67
85static struct platform_device_id c_can_id_table[] = { 68static int __devinit c_can_plat_probe(struct platform_device *pdev)
86 [BOSCH_C_CAN_PLATFORM] = {
87 .name = KBUILD_MODNAME,
88 .driver_data = BOSCH_C_CAN,
89 },
90 [BOSCH_C_CAN] = {
91 .name = "c_can",
92 .driver_data = BOSCH_C_CAN,
93 },
94 [BOSCH_D_CAN] = {
95 .name = "d_can",
96 .driver_data = BOSCH_D_CAN,
97 }, {
98 }
99};
100MODULE_DEVICE_TABLE(platform, c_can_id_table);
101
102static const struct of_device_id c_can_of_table[] = {
103 { .compatible = "bosch,c_can", .data = &c_can_id_table[BOSCH_C_CAN] },
104 { .compatible = "bosch,d_can", .data = &c_can_id_table[BOSCH_D_CAN] },
105 { /* sentinel */ },
106};
107MODULE_DEVICE_TABLE(of, c_can_of_table);
108
109static int c_can_plat_probe(struct platform_device *pdev)
110{ 69{
111 int ret; 70 int ret;
112 void __iomem *addr; 71 void __iomem *addr;
113 struct net_device *dev; 72 struct net_device *dev;
114 struct c_can_priv *priv; 73 struct c_can_priv *priv;
115 const struct of_device_id *match; 74 struct resource *mem;
116 const struct platform_device_id *id;
117 struct pinctrl *pinctrl;
118 struct resource *mem, *res;
119 int irq; 75 int irq;
76#ifdef CONFIG_HAVE_CLK
120 struct clk *clk; 77 struct clk *clk;
121 78
122 if (pdev->dev.of_node) {
123 match = of_match_device(c_can_of_table, &pdev->dev);
124 if (!match) {
125 dev_err(&pdev->dev, "Failed to find matching dt id\n");
126 ret = -EINVAL;
127 goto exit;
128 }
129 id = match->data;
130 } else {
131 id = platform_get_device_id(pdev);
132 }
133
134 pinctrl = devm_pinctrl_get_select_default(&pdev->dev);
135 if (IS_ERR(pinctrl))
136 dev_warn(&pdev->dev,
137 "failed to configure pins from driver\n");
138
139 /* get the appropriate clk */ 79 /* get the appropriate clk */
140 clk = clk_get(&pdev->dev, NULL); 80 clk = clk_get(&pdev->dev, NULL);
141 if (IS_ERR(clk)) { 81 if (IS_ERR(clk)) {
@@ -143,6 +83,7 @@ static int c_can_plat_probe(struct platform_device *pdev)
143 ret = -ENODEV; 83 ret = -ENODEV;
144 goto exit; 84 goto exit;
145 } 85 }
86#endif
146 87
147 /* get the platform data */ 88 /* get the platform data */
148 mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); 89 mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
@@ -174,51 +115,26 @@ static int c_can_plat_probe(struct platform_device *pdev)
174 } 115 }
175 116
176 priv = netdev_priv(dev); 117 priv = netdev_priv(dev);
177 switch (id->driver_data) {
178 case BOSCH_C_CAN:
179 priv->regs = reg_map_c_can;
180 switch (mem->flags & IORESOURCE_MEM_TYPE_MASK) {
181 case IORESOURCE_MEM_32BIT:
182 priv->read_reg = c_can_plat_read_reg_aligned_to_32bit;
183 priv->write_reg = c_can_plat_write_reg_aligned_to_32bit;
184 break;
185 case IORESOURCE_MEM_16BIT:
186 default:
187 priv->read_reg = c_can_plat_read_reg_aligned_to_16bit;
188 priv->write_reg = c_can_plat_write_reg_aligned_to_16bit;
189 break;
190 }
191 break;
192 case BOSCH_D_CAN:
193 priv->regs = reg_map_d_can;
194 priv->can.ctrlmode_supported |= CAN_CTRLMODE_3_SAMPLES;
195 priv->read_reg = c_can_plat_read_reg_aligned_to_16bit;
196 priv->write_reg = c_can_plat_write_reg_aligned_to_16bit;
197 118
198 if (pdev->dev.of_node) 119 dev->irq = irq;
199 priv->instance = of_alias_get_id(pdev->dev.of_node, "d_can"); 120 priv->regs = addr;
200 else 121#ifdef CONFIG_HAVE_CLK
201 priv->instance = pdev->id; 122 priv->can.clock.freq = clk_get_rate(clk);
123 priv->priv = clk;
124#endif
202 125
203 res = platform_get_resource(pdev, IORESOURCE_MEM, 1); 126 switch (mem->flags & IORESOURCE_MEM_TYPE_MASK) {
204 priv->raminit_ctrlreg = devm_request_and_ioremap(&pdev->dev, res); 127 case IORESOURCE_MEM_32BIT:
205 if (!priv->raminit_ctrlreg || priv->instance < 0) 128 priv->read_reg = c_can_plat_read_reg_aligned_to_32bit;
206 dev_info(&pdev->dev, "control memory is not used for raminit\n"); 129 priv->write_reg = c_can_plat_write_reg_aligned_to_32bit;
207 else
208 priv->raminit = c_can_hw_raminit;
209 break; 130 break;
131 case IORESOURCE_MEM_16BIT:
210 default: 132 default:
211 ret = -EINVAL; 133 priv->read_reg = c_can_plat_read_reg_aligned_to_16bit;
212 goto exit_free_device; 134 priv->write_reg = c_can_plat_write_reg_aligned_to_16bit;
135 break;
213 } 136 }
214 137
215 dev->irq = irq;
216 priv->base = addr;
217 priv->device = &pdev->dev;
218 priv->can.clock.freq = clk_get_rate(clk);
219 priv->priv = clk;
220 priv->type = id->driver_data;
221
222 platform_set_drvdata(pdev, dev); 138 platform_set_drvdata(pdev, dev);
223 SET_NETDEV_DEV(dev, &pdev->dev); 139 SET_NETDEV_DEV(dev, &pdev->dev);
224 140
@@ -230,7 +146,7 @@ static int c_can_plat_probe(struct platform_device *pdev)
230 } 146 }
231 147
232 dev_info(&pdev->dev, "%s device registered (regs=%p, irq=%d)\n", 148 dev_info(&pdev->dev, "%s device registered (regs=%p, irq=%d)\n",
233 KBUILD_MODNAME, priv->base, dev->irq); 149 KBUILD_MODNAME, priv->regs, dev->irq);
234 return 0; 150 return 0;
235 151
236exit_free_device: 152exit_free_device:
@@ -241,14 +157,16 @@ exit_iounmap:
241exit_release_mem: 157exit_release_mem:
242 release_mem_region(mem->start, resource_size(mem)); 158 release_mem_region(mem->start, resource_size(mem));
243exit_free_clk: 159exit_free_clk:
160#ifdef CONFIG_HAVE_CLK
244 clk_put(clk); 161 clk_put(clk);
245exit: 162exit:
163#endif
246 dev_err(&pdev->dev, "probe failed\n"); 164 dev_err(&pdev->dev, "probe failed\n");
247 165
248 return ret; 166 return ret;
249} 167}
250 168
251static int c_can_plat_remove(struct platform_device *pdev) 169static int __devexit c_can_plat_remove(struct platform_device *pdev)
252{ 170{
253 struct net_device *dev = platform_get_drvdata(pdev); 171 struct net_device *dev = platform_get_drvdata(pdev);
254 struct c_can_priv *priv = netdev_priv(dev); 172 struct c_can_priv *priv = netdev_priv(dev);
@@ -258,89 +176,38 @@ static int c_can_plat_remove(struct platform_device *pdev)
258 platform_set_drvdata(pdev, NULL); 176 platform_set_drvdata(pdev, NULL);
259 177
260 free_c_can_dev(dev); 178 free_c_can_dev(dev);
261 iounmap(priv->base); 179 iounmap(priv->regs);
262 180
263 mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); 181 mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
264 release_mem_region(mem->start, resource_size(mem)); 182 release_mem_region(mem->start, resource_size(mem));
265 183
184#ifdef CONFIG_HAVE_CLK
266 clk_put(priv->priv); 185 clk_put(priv->priv);
186#endif
267 187
268 return 0; 188 return 0;
269} 189}
270 190
271#ifdef CONFIG_PM
272static int c_can_suspend(struct platform_device *pdev, pm_message_t state)
273{
274 int ret;
275 struct net_device *ndev = platform_get_drvdata(pdev);
276 struct c_can_priv *priv = netdev_priv(ndev);
277
278 if (priv->type != BOSCH_D_CAN) {
279 dev_warn(&pdev->dev, "Not supported\n");
280 return 0;
281 }
282
283 if (netif_running(ndev)) {
284 netif_stop_queue(ndev);
285 netif_device_detach(ndev);
286 }
287
288 ret = c_can_power_down(ndev);
289 if (ret) {
290 netdev_err(ndev, "failed to enter power down mode\n");
291 return ret;
292 }
293
294 priv->can.state = CAN_STATE_SLEEPING;
295
296 return 0;
297}
298
299static int c_can_resume(struct platform_device *pdev)
300{
301 int ret;
302 struct net_device *ndev = platform_get_drvdata(pdev);
303 struct c_can_priv *priv = netdev_priv(ndev);
304
305 if (priv->type != BOSCH_D_CAN) {
306 dev_warn(&pdev->dev, "Not supported\n");
307 return 0;
308 }
309
310 ret = c_can_power_up(ndev);
311 if (ret) {
312 netdev_err(ndev, "Still in power down mode\n");
313 return ret;
314 }
315
316 priv->can.state = CAN_STATE_ERROR_ACTIVE;
317
318 if (netif_running(ndev)) {
319 netif_device_attach(ndev);
320 netif_start_queue(ndev);
321 }
322
323 return 0;
324}
325#else
326#define c_can_suspend NULL
327#define c_can_resume NULL
328#endif
329
330static struct platform_driver c_can_plat_driver = { 191static struct platform_driver c_can_plat_driver = {
331 .driver = { 192 .driver = {
332 .name = KBUILD_MODNAME, 193 .name = KBUILD_MODNAME,
333 .owner = THIS_MODULE, 194 .owner = THIS_MODULE,
334 .of_match_table = of_match_ptr(c_can_of_table),
335 }, 195 },
336 .probe = c_can_plat_probe, 196 .probe = c_can_plat_probe,
337 .remove = c_can_plat_remove, 197 .remove = __devexit_p(c_can_plat_remove),
338 .suspend = c_can_suspend,
339 .resume = c_can_resume,
340 .id_table = c_can_id_table,
341}; 198};
342 199
343module_platform_driver(c_can_plat_driver); 200static int __init c_can_plat_init(void)
201{
202 return platform_driver_register(&c_can_plat_driver);
203}
204module_init(c_can_plat_init);
205
206static void __exit c_can_plat_exit(void)
207{
208 platform_driver_unregister(&c_can_plat_driver);
209}
210module_exit(c_can_plat_exit);
344 211
345MODULE_AUTHOR("Bhupesh Sharma <bhupesh.sharma@st.com>"); 212MODULE_AUTHOR("Bhupesh Sharma <bhupesh.sharma@st.com>");
346MODULE_LICENSE("GPL v2"); 213MODULE_LICENSE("GPL v2");
diff --git a/drivers/net/can/cc770/Kconfig b/drivers/net/can/cc770/Kconfig
deleted file mode 100644
index 22c07a8c8b4..00000000000
--- a/drivers/net/can/cc770/Kconfig
+++ /dev/null
@@ -1,21 +0,0 @@
1menuconfig CAN_CC770
2 tristate "Bosch CC770 and Intel AN82527 devices"
3 depends on CAN_DEV && HAS_IOMEM
4
5if CAN_CC770
6
7config CAN_CC770_ISA
8 tristate "ISA Bus based legacy CC770 driver"
9 ---help---
10 This driver adds legacy support for CC770 and AN82527 chips
11 connected to the ISA bus using I/O port, memory mapped or
12 indirect access.
13
14config CAN_CC770_PLATFORM
15 tristate "Generic Platform Bus based CC770 driver"
16 ---help---
17 This driver adds support for the CC770 and AN82527 chips
18 connected to the "platform bus" (Linux abstraction for directly
19 to the processor attached devices).
20
21endif
diff --git a/drivers/net/can/cc770/Makefile b/drivers/net/can/cc770/Makefile
deleted file mode 100644
index 9fb8321b33e..00000000000
--- a/drivers/net/can/cc770/Makefile
+++ /dev/null
@@ -1,9 +0,0 @@
1#
2# Makefile for the Bosch CC770 CAN controller drivers.
3#
4
5obj-$(CONFIG_CAN_CC770) += cc770.o
6obj-$(CONFIG_CAN_CC770_ISA) += cc770_isa.o
7obj-$(CONFIG_CAN_CC770_PLATFORM) += cc770_platform.o
8
9ccflags-$(CONFIG_CAN_DEBUG_DEVICES) := -DDEBUG
diff --git a/drivers/net/can/cc770/cc770.c b/drivers/net/can/cc770/cc770.c
deleted file mode 100644
index 0f12abf6591..00000000000
--- a/drivers/net/can/cc770/cc770.c
+++ /dev/null
@@ -1,882 +0,0 @@
1/*
2 * Core driver for the CC770 and AN82527 CAN controllers
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#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
17
18#include <linux/module.h>
19#include <linux/init.h>
20#include <linux/kernel.h>
21#include <linux/sched.h>
22#include <linux/types.h>
23#include <linux/fcntl.h>
24#include <linux/interrupt.h>
25#include <linux/ptrace.h>
26#include <linux/string.h>
27#include <linux/errno.h>
28#include <linux/netdevice.h>
29#include <linux/if_arp.h>
30#include <linux/if_ether.h>
31#include <linux/skbuff.h>
32#include <linux/delay.h>
33
34#include <linux/can.h>
35#include <linux/can/dev.h>
36#include <linux/can/error.h>
37#include <linux/can/platform/cc770.h>
38
39#include "cc770.h"
40
41MODULE_AUTHOR("Wolfgang Grandegger <wg@grandegger.com>");
42MODULE_LICENSE("GPL v2");
43MODULE_DESCRIPTION(KBUILD_MODNAME "CAN netdevice driver");
44
45/*
46 * The CC770 is a CAN controller from Bosch, which is 100% compatible
47 * with the AN82527 from Intel, but with "bugs" being fixed and some
48 * additional functionality, mainly:
49 *
50 * 1. RX and TX error counters are readable.
51 * 2. Support of silent (listen-only) mode.
52 * 3. Message object 15 can receive all types of frames, also RTR and EFF.
53 *
54 * Details are available from Bosch's "CC770_Product_Info_2007-01.pdf",
55 * which explains in detail the compatibility between the CC770 and the
56 * 82527. This driver use the additional functionality 3. on real CC770
57 * devices. Unfortunately, the CC770 does still not store the message
58 * identifier of received remote transmission request frames and
59 * therefore it's set to 0.
60 *
61 * The message objects 1..14 can be used for TX and RX while the message
62 * objects 15 is optimized for RX. It has a shadow register for reliable
63 * data receiption under heavy bus load. Therefore it makes sense to use
64 * this message object for the needed use case. The frame type (EFF/SFF)
65 * for the message object 15 can be defined via kernel module parameter
66 * "msgobj15_eff". If not equal 0, it will receive 29-bit EFF frames,
67 * otherwise 11 bit SFF messages.
68 */
69static int msgobj15_eff;
70module_param(msgobj15_eff, int, S_IRUGO);
71MODULE_PARM_DESC(msgobj15_eff, "Extended 29-bit frames for message object 15 "
72 "(default: 11-bit standard frames)");
73
74static int i82527_compat;
75module_param(i82527_compat, int, S_IRUGO);
76MODULE_PARM_DESC(i82527_compat, "Strict Intel 82527 comptibility mode "
77 "without using additional functions");
78
79/*
80 * This driver uses the last 5 message objects 11..15. The definitions
81 * and structure below allows to configure and assign them to the real
82 * message object.
83 */
84static unsigned char cc770_obj_flags[CC770_OBJ_MAX] = {
85 [CC770_OBJ_RX0] = CC770_OBJ_FLAG_RX,
86 [CC770_OBJ_RX1] = CC770_OBJ_FLAG_RX | CC770_OBJ_FLAG_EFF,
87 [CC770_OBJ_RX_RTR0] = CC770_OBJ_FLAG_RX | CC770_OBJ_FLAG_RTR,
88 [CC770_OBJ_RX_RTR1] = CC770_OBJ_FLAG_RX | CC770_OBJ_FLAG_RTR |
89 CC770_OBJ_FLAG_EFF,
90 [CC770_OBJ_TX] = 0,
91};
92
93static const struct can_bittiming_const cc770_bittiming_const = {
94 .name = KBUILD_MODNAME,
95 .tseg1_min = 1,
96 .tseg1_max = 16,
97 .tseg2_min = 1,
98 .tseg2_max = 8,
99 .sjw_max = 4,
100 .brp_min = 1,
101 .brp_max = 64,
102 .brp_inc = 1,
103};
104
105static inline int intid2obj(unsigned int intid)
106{
107 if (intid == 2)
108 return 0;
109 else
110 return MSGOBJ_LAST + 2 - intid;
111}
112
113static void enable_all_objs(const struct net_device *dev)
114{
115 struct cc770_priv *priv = netdev_priv(dev);
116 u8 msgcfg;
117 unsigned char obj_flags;
118 unsigned int o, mo;
119
120 for (o = 0; o < ARRAY_SIZE(priv->obj_flags); o++) {
121 obj_flags = priv->obj_flags[o];
122 mo = obj2msgobj(o);
123
124 if (obj_flags & CC770_OBJ_FLAG_RX) {
125 /*
126 * We don't need extra objects for RTR and EFF if
127 * the additional CC770 functions are enabled.
128 */
129 if (priv->control_normal_mode & CTRL_EAF) {
130 if (o > 0)
131 continue;
132 netdev_dbg(dev, "Message object %d for "
133 "RX data, RTR, SFF and EFF\n", mo);
134 } else {
135 netdev_dbg(dev,
136 "Message object %d for RX %s %s\n",
137 mo, obj_flags & CC770_OBJ_FLAG_RTR ?
138 "RTR" : "data",
139 obj_flags & CC770_OBJ_FLAG_EFF ?
140 "EFF" : "SFF");
141 }
142
143 if (obj_flags & CC770_OBJ_FLAG_EFF)
144 msgcfg = MSGCFG_XTD;
145 else
146 msgcfg = 0;
147 if (obj_flags & CC770_OBJ_FLAG_RTR)
148 msgcfg |= MSGCFG_DIR;
149
150 cc770_write_reg(priv, msgobj[mo].config, msgcfg);
151 cc770_write_reg(priv, msgobj[mo].ctrl0,
152 MSGVAL_SET | TXIE_RES |
153 RXIE_SET | INTPND_RES);
154
155 if (obj_flags & CC770_OBJ_FLAG_RTR)
156 cc770_write_reg(priv, msgobj[mo].ctrl1,
157 NEWDAT_RES | CPUUPD_SET |
158 TXRQST_RES | RMTPND_RES);
159 else
160 cc770_write_reg(priv, msgobj[mo].ctrl1,
161 NEWDAT_RES | MSGLST_RES |
162 TXRQST_RES | RMTPND_RES);
163 } else {
164 netdev_dbg(dev, "Message object %d for "
165 "TX data, RTR, SFF and EFF\n", mo);
166
167 cc770_write_reg(priv, msgobj[mo].ctrl1,
168 RMTPND_RES | TXRQST_RES |
169 CPUUPD_RES | NEWDAT_RES);
170 cc770_write_reg(priv, msgobj[mo].ctrl0,
171 MSGVAL_RES | TXIE_RES |
172 RXIE_RES | INTPND_RES);
173 }
174 }
175}
176
177static void disable_all_objs(const struct cc770_priv *priv)
178{
179 int o, mo;
180
181 for (o = 0; o < ARRAY_SIZE(priv->obj_flags); o++) {
182 mo = obj2msgobj(o);
183
184 if (priv->obj_flags[o] & CC770_OBJ_FLAG_RX) {
185 if (o > 0 && priv->control_normal_mode & CTRL_EAF)
186 continue;
187
188 cc770_write_reg(priv, msgobj[mo].ctrl1,
189 NEWDAT_RES | MSGLST_RES |
190 TXRQST_RES | RMTPND_RES);
191 cc770_write_reg(priv, msgobj[mo].ctrl0,
192 MSGVAL_RES | TXIE_RES |
193 RXIE_RES | INTPND_RES);
194 } else {
195 /* Clear message object for send */
196 cc770_write_reg(priv, msgobj[mo].ctrl1,
197 RMTPND_RES | TXRQST_RES |
198 CPUUPD_RES | NEWDAT_RES);
199 cc770_write_reg(priv, msgobj[mo].ctrl0,
200 MSGVAL_RES | TXIE_RES |
201 RXIE_RES | INTPND_RES);
202 }
203 }
204}
205
206static void set_reset_mode(struct net_device *dev)
207{
208 struct cc770_priv *priv = netdev_priv(dev);
209
210 /* Enable configuration and puts chip in bus-off, disable interrupts */
211 cc770_write_reg(priv, control, CTRL_CCE | CTRL_INI);
212
213 priv->can.state = CAN_STATE_STOPPED;
214
215 /* Clear interrupts */
216 cc770_read_reg(priv, interrupt);
217
218 /* Clear status register */
219 cc770_write_reg(priv, status, 0);
220
221 /* Disable all used message objects */
222 disable_all_objs(priv);
223}
224
225static void set_normal_mode(struct net_device *dev)
226{
227 struct cc770_priv *priv = netdev_priv(dev);
228
229 /* Clear interrupts */
230 cc770_read_reg(priv, interrupt);
231
232 /* Clear status register and pre-set last error code */
233 cc770_write_reg(priv, status, STAT_LEC_MASK);
234
235 /* Enable all used message objects*/
236 enable_all_objs(dev);
237
238 /*
239 * Clear bus-off, interrupts only for errors,
240 * not for status change
241 */
242 cc770_write_reg(priv, control, priv->control_normal_mode);
243
244 priv->can.state = CAN_STATE_ERROR_ACTIVE;
245}
246
247static void chipset_init(struct cc770_priv *priv)
248{
249 int mo, id, data;
250
251 /* Enable configuration and put chip in bus-off, disable interrupts */
252 cc770_write_reg(priv, control, (CTRL_CCE | CTRL_INI));
253
254 /* Set CLKOUT divider and slew rates */
255 cc770_write_reg(priv, clkout, priv->clkout);
256
257 /* Configure CPU interface / CLKOUT enable */
258 cc770_write_reg(priv, cpu_interface, priv->cpu_interface);
259
260 /* Set bus configuration */
261 cc770_write_reg(priv, bus_config, priv->bus_config);
262
263 /* Clear interrupts */
264 cc770_read_reg(priv, interrupt);
265
266 /* Clear status register */
267 cc770_write_reg(priv, status, 0);
268
269 /* Clear and invalidate message objects */
270 for (mo = MSGOBJ_FIRST; mo <= MSGOBJ_LAST; mo++) {
271 cc770_write_reg(priv, msgobj[mo].ctrl0,
272 INTPND_UNC | RXIE_RES |
273 TXIE_RES | MSGVAL_RES);
274 cc770_write_reg(priv, msgobj[mo].ctrl0,
275 INTPND_RES | RXIE_RES |
276 TXIE_RES | MSGVAL_RES);
277 cc770_write_reg(priv, msgobj[mo].ctrl1,
278 NEWDAT_RES | MSGLST_RES |
279 TXRQST_RES | RMTPND_RES);
280 for (data = 0; data < 8; data++)
281 cc770_write_reg(priv, msgobj[mo].data[data], 0);
282 for (id = 0; id < 4; id++)
283 cc770_write_reg(priv, msgobj[mo].id[id], 0);
284 cc770_write_reg(priv, msgobj[mo].config, 0);
285 }
286
287 /* Set all global ID masks to "don't care" */
288 cc770_write_reg(priv, global_mask_std[0], 0);
289 cc770_write_reg(priv, global_mask_std[1], 0);
290 cc770_write_reg(priv, global_mask_ext[0], 0);
291 cc770_write_reg(priv, global_mask_ext[1], 0);
292 cc770_write_reg(priv, global_mask_ext[2], 0);
293 cc770_write_reg(priv, global_mask_ext[3], 0);
294
295}
296
297static int cc770_probe_chip(struct net_device *dev)
298{
299 struct cc770_priv *priv = netdev_priv(dev);
300
301 /* Enable configuration, put chip in bus-off, disable ints */
302 cc770_write_reg(priv, control, CTRL_CCE | CTRL_EAF | CTRL_INI);
303 /* Configure cpu interface / CLKOUT disable */
304 cc770_write_reg(priv, cpu_interface, priv->cpu_interface);
305
306 /*
307 * Check if hardware reset is still inactive or maybe there
308 * is no chip in this address space
309 */
310 if (cc770_read_reg(priv, cpu_interface) & CPUIF_RST) {
311 netdev_info(dev, "probing @0x%p failed (reset)\n",
312 priv->reg_base);
313 return -ENODEV;
314 }
315
316 /* Write and read back test pattern (some arbitrary values) */
317 cc770_write_reg(priv, msgobj[1].data[1], 0x25);
318 cc770_write_reg(priv, msgobj[2].data[3], 0x52);
319 cc770_write_reg(priv, msgobj[10].data[6], 0xc3);
320 if ((cc770_read_reg(priv, msgobj[1].data[1]) != 0x25) ||
321 (cc770_read_reg(priv, msgobj[2].data[3]) != 0x52) ||
322 (cc770_read_reg(priv, msgobj[10].data[6]) != 0xc3)) {
323 netdev_info(dev, "probing @0x%p failed (pattern)\n",
324 priv->reg_base);
325 return -ENODEV;
326 }
327
328 /* Check if this chip is a CC770 supporting additional functions */
329 if (cc770_read_reg(priv, control) & CTRL_EAF)
330 priv->control_normal_mode |= CTRL_EAF;
331
332 return 0;
333}
334
335static void cc770_start(struct net_device *dev)
336{
337 struct cc770_priv *priv = netdev_priv(dev);
338
339 /* leave reset mode */
340 if (priv->can.state != CAN_STATE_STOPPED)
341 set_reset_mode(dev);
342
343 /* leave reset mode */
344 set_normal_mode(dev);
345}
346
347static int cc770_set_mode(struct net_device *dev, enum can_mode mode)
348{
349 switch (mode) {
350 case CAN_MODE_START:
351 cc770_start(dev);
352 netif_wake_queue(dev);
353 break;
354
355 default:
356 return -EOPNOTSUPP;
357 }
358
359 return 0;
360}
361
362static int cc770_set_bittiming(struct net_device *dev)
363{
364 struct cc770_priv *priv = netdev_priv(dev);
365 struct can_bittiming *bt = &priv->can.bittiming;
366 u8 btr0, btr1;
367
368 btr0 = ((bt->brp - 1) & 0x3f) | (((bt->sjw - 1) & 0x3) << 6);
369 btr1 = ((bt->prop_seg + bt->phase_seg1 - 1) & 0xf) |
370 (((bt->phase_seg2 - 1) & 0x7) << 4);
371 if (priv->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES)
372 btr1 |= 0x80;
373
374 netdev_info(dev, "setting BTR0=0x%02x BTR1=0x%02x\n", btr0, btr1);
375
376 cc770_write_reg(priv, bit_timing_0, btr0);
377 cc770_write_reg(priv, bit_timing_1, btr1);
378
379 return 0;
380}
381
382static int cc770_get_berr_counter(const struct net_device *dev,
383 struct can_berr_counter *bec)
384{
385 struct cc770_priv *priv = netdev_priv(dev);
386
387 bec->txerr = cc770_read_reg(priv, tx_error_counter);
388 bec->rxerr = cc770_read_reg(priv, rx_error_counter);
389
390 return 0;
391}
392
393static netdev_tx_t cc770_start_xmit(struct sk_buff *skb, struct net_device *dev)
394{
395 struct cc770_priv *priv = netdev_priv(dev);
396 struct net_device_stats *stats = &dev->stats;
397 struct can_frame *cf = (struct can_frame *)skb->data;
398 unsigned int mo = obj2msgobj(CC770_OBJ_TX);
399 u8 dlc, rtr;
400 u32 id;
401 int i;
402
403 if (can_dropped_invalid_skb(dev, skb))
404 return NETDEV_TX_OK;
405
406 if ((cc770_read_reg(priv,
407 msgobj[mo].ctrl1) & TXRQST_UNC) == TXRQST_SET) {
408 netdev_err(dev, "TX register is still occupied!\n");
409 return NETDEV_TX_BUSY;
410 }
411
412 netif_stop_queue(dev);
413
414 dlc = cf->can_dlc;
415 id = cf->can_id;
416 if (cf->can_id & CAN_RTR_FLAG)
417 rtr = 0;
418 else
419 rtr = MSGCFG_DIR;
420 cc770_write_reg(priv, msgobj[mo].ctrl1,
421 RMTPND_RES | TXRQST_RES | CPUUPD_SET | NEWDAT_RES);
422 cc770_write_reg(priv, msgobj[mo].ctrl0,
423 MSGVAL_SET | TXIE_SET | RXIE_RES | INTPND_RES);
424 if (id & CAN_EFF_FLAG) {
425 id &= CAN_EFF_MASK;
426 cc770_write_reg(priv, msgobj[mo].config,
427 (dlc << 4) | rtr | MSGCFG_XTD);
428 cc770_write_reg(priv, msgobj[mo].id[3], id << 3);
429 cc770_write_reg(priv, msgobj[mo].id[2], id >> 5);
430 cc770_write_reg(priv, msgobj[mo].id[1], id >> 13);
431 cc770_write_reg(priv, msgobj[mo].id[0], id >> 21);
432 } else {
433 id &= CAN_SFF_MASK;
434 cc770_write_reg(priv, msgobj[mo].config, (dlc << 4) | rtr);
435 cc770_write_reg(priv, msgobj[mo].id[0], id >> 3);
436 cc770_write_reg(priv, msgobj[mo].id[1], id << 5);
437 }
438
439 for (i = 0; i < dlc; i++)
440 cc770_write_reg(priv, msgobj[mo].data[i], cf->data[i]);
441
442 /* Store echo skb before starting the transfer */
443 can_put_echo_skb(skb, dev, 0);
444
445 cc770_write_reg(priv, msgobj[mo].ctrl1,
446 RMTPND_RES | TXRQST_SET | CPUUPD_RES | NEWDAT_UNC);
447
448 stats->tx_bytes += dlc;
449
450
451 /*
452 * HM: We had some cases of repeated IRQs so make sure the
453 * INT is acknowledged I know it's already further up, but
454 * doing again fixed the issue
455 */
456 cc770_write_reg(priv, msgobj[mo].ctrl0,
457 MSGVAL_UNC | TXIE_UNC | RXIE_UNC | INTPND_RES);
458
459 return NETDEV_TX_OK;
460}
461
462static void cc770_rx(struct net_device *dev, unsigned int mo, u8 ctrl1)
463{
464 struct cc770_priv *priv = netdev_priv(dev);
465 struct net_device_stats *stats = &dev->stats;
466 struct can_frame *cf;
467 struct sk_buff *skb;
468 u8 config;
469 u32 id;
470 int i;
471
472 skb = alloc_can_skb(dev, &cf);
473 if (!skb)
474 return;
475
476 config = cc770_read_reg(priv, msgobj[mo].config);
477
478 if (ctrl1 & RMTPND_SET) {
479 /*
480 * Unfortunately, the chip does not store the real message
481 * identifier of the received remote transmission request
482 * frame. Therefore we set it to 0.
483 */
484 cf->can_id = CAN_RTR_FLAG;
485 if (config & MSGCFG_XTD)
486 cf->can_id |= CAN_EFF_FLAG;
487 cf->can_dlc = 0;
488 } else {
489 if (config & MSGCFG_XTD) {
490 id = cc770_read_reg(priv, msgobj[mo].id[3]);
491 id |= cc770_read_reg(priv, msgobj[mo].id[2]) << 8;
492 id |= cc770_read_reg(priv, msgobj[mo].id[1]) << 16;
493 id |= cc770_read_reg(priv, msgobj[mo].id[0]) << 24;
494 id >>= 3;
495 id |= CAN_EFF_FLAG;
496 } else {
497 id = cc770_read_reg(priv, msgobj[mo].id[1]);
498 id |= cc770_read_reg(priv, msgobj[mo].id[0]) << 8;
499 id >>= 5;
500 }
501
502 cf->can_id = id;
503 cf->can_dlc = get_can_dlc((config & 0xf0) >> 4);
504 for (i = 0; i < cf->can_dlc; i++)
505 cf->data[i] = cc770_read_reg(priv, msgobj[mo].data[i]);
506 }
507 netif_rx(skb);
508
509 stats->rx_packets++;
510 stats->rx_bytes += cf->can_dlc;
511}
512
513static int cc770_err(struct net_device *dev, u8 status)
514{
515 struct cc770_priv *priv = netdev_priv(dev);
516 struct net_device_stats *stats = &dev->stats;
517 struct can_frame *cf;
518 struct sk_buff *skb;
519 u8 lec;
520
521 netdev_dbg(dev, "status interrupt (%#x)\n", status);
522
523 skb = alloc_can_err_skb(dev, &cf);
524 if (!skb)
525 return -ENOMEM;
526
527 /* Use extended functions of the CC770 */
528 if (priv->control_normal_mode & CTRL_EAF) {
529 cf->data[6] = cc770_read_reg(priv, tx_error_counter);
530 cf->data[7] = cc770_read_reg(priv, rx_error_counter);
531 }
532
533 if (status & STAT_BOFF) {
534 /* Disable interrupts */
535 cc770_write_reg(priv, control, CTRL_INI);
536 cf->can_id |= CAN_ERR_BUSOFF;
537 priv->can.state = CAN_STATE_BUS_OFF;
538 can_bus_off(dev);
539 } else if (status & STAT_WARN) {
540 cf->can_id |= CAN_ERR_CRTL;
541 /* Only the CC770 does show error passive */
542 if (cf->data[7] > 127) {
543 cf->data[1] = CAN_ERR_CRTL_RX_PASSIVE |
544 CAN_ERR_CRTL_TX_PASSIVE;
545 priv->can.state = CAN_STATE_ERROR_PASSIVE;
546 priv->can.can_stats.error_passive++;
547 } else {
548 cf->data[1] = CAN_ERR_CRTL_RX_WARNING |
549 CAN_ERR_CRTL_TX_WARNING;
550 priv->can.state = CAN_STATE_ERROR_WARNING;
551 priv->can.can_stats.error_warning++;
552 }
553 } else {
554 /* Back to error avtive */
555 cf->can_id |= CAN_ERR_PROT;
556 cf->data[2] = CAN_ERR_PROT_ACTIVE;
557 priv->can.state = CAN_STATE_ERROR_ACTIVE;
558 }
559
560 lec = status & STAT_LEC_MASK;
561 if (lec < 7 && lec > 0) {
562 if (lec == STAT_LEC_ACK) {
563 cf->can_id |= CAN_ERR_ACK;
564 } else {
565 cf->can_id |= CAN_ERR_PROT;
566 switch (lec) {
567 case STAT_LEC_STUFF:
568 cf->data[2] |= CAN_ERR_PROT_STUFF;
569 break;
570 case STAT_LEC_FORM:
571 cf->data[2] |= CAN_ERR_PROT_FORM;
572 break;
573 case STAT_LEC_BIT1:
574 cf->data[2] |= CAN_ERR_PROT_BIT1;
575 break;
576 case STAT_LEC_BIT0:
577 cf->data[2] |= CAN_ERR_PROT_BIT0;
578 break;
579 case STAT_LEC_CRC:
580 cf->data[3] |= CAN_ERR_PROT_LOC_CRC_SEQ;
581 break;
582 }
583 }
584 }
585
586 netif_rx(skb);
587
588 stats->rx_packets++;
589 stats->rx_bytes += cf->can_dlc;
590
591 return 0;
592}
593
594static int cc770_status_interrupt(struct net_device *dev)
595{
596 struct cc770_priv *priv = netdev_priv(dev);
597 u8 status;
598
599 status = cc770_read_reg(priv, status);
600 /* Reset the status register including RXOK and TXOK */
601 cc770_write_reg(priv, status, STAT_LEC_MASK);
602
603 if (status & (STAT_WARN | STAT_BOFF) ||
604 (status & STAT_LEC_MASK) != STAT_LEC_MASK) {
605 cc770_err(dev, status);
606 return status & STAT_BOFF;
607 }
608
609 return 0;
610}
611
612static void cc770_rx_interrupt(struct net_device *dev, unsigned int o)
613{
614 struct cc770_priv *priv = netdev_priv(dev);
615 struct net_device_stats *stats = &dev->stats;
616 unsigned int mo = obj2msgobj(o);
617 u8 ctrl1;
618 int n = CC770_MAX_MSG;
619
620 while (n--) {
621 ctrl1 = cc770_read_reg(priv, msgobj[mo].ctrl1);
622
623 if (!(ctrl1 & NEWDAT_SET)) {
624 /* Check for RTR if additional functions are enabled */
625 if (priv->control_normal_mode & CTRL_EAF) {
626 if (!(cc770_read_reg(priv, msgobj[mo].ctrl0) &
627 INTPND_SET))
628 break;
629 } else {
630 break;
631 }
632 }
633
634 if (ctrl1 & MSGLST_SET) {
635 stats->rx_over_errors++;
636 stats->rx_errors++;
637 }
638 if (mo < MSGOBJ_LAST)
639 cc770_write_reg(priv, msgobj[mo].ctrl1,
640 NEWDAT_RES | MSGLST_RES |
641 TXRQST_UNC | RMTPND_UNC);
642 cc770_rx(dev, mo, ctrl1);
643
644 cc770_write_reg(priv, msgobj[mo].ctrl0,
645 MSGVAL_SET | TXIE_RES |
646 RXIE_SET | INTPND_RES);
647 cc770_write_reg(priv, msgobj[mo].ctrl1,
648 NEWDAT_RES | MSGLST_RES |
649 TXRQST_RES | RMTPND_RES);
650 }
651}
652
653static void cc770_rtr_interrupt(struct net_device *dev, unsigned int o)
654{
655 struct cc770_priv *priv = netdev_priv(dev);
656 unsigned int mo = obj2msgobj(o);
657 u8 ctrl0, ctrl1;
658 int n = CC770_MAX_MSG;
659
660 while (n--) {
661 ctrl0 = cc770_read_reg(priv, msgobj[mo].ctrl0);
662 if (!(ctrl0 & INTPND_SET))
663 break;
664
665 ctrl1 = cc770_read_reg(priv, msgobj[mo].ctrl1);
666 cc770_rx(dev, mo, ctrl1);
667
668 cc770_write_reg(priv, msgobj[mo].ctrl0,
669 MSGVAL_SET | TXIE_RES |
670 RXIE_SET | INTPND_RES);
671 cc770_write_reg(priv, msgobj[mo].ctrl1,
672 NEWDAT_RES | CPUUPD_SET |
673 TXRQST_RES | RMTPND_RES);
674 }
675}
676
677static void cc770_tx_interrupt(struct net_device *dev, unsigned int o)
678{
679 struct cc770_priv *priv = netdev_priv(dev);
680 struct net_device_stats *stats = &dev->stats;
681 unsigned int mo = obj2msgobj(o);
682
683 /* Nothing more to send, switch off interrupts */
684 cc770_write_reg(priv, msgobj[mo].ctrl0,
685 MSGVAL_RES | TXIE_RES | RXIE_RES | INTPND_RES);
686 /*
687 * We had some cases of repeated IRQ so make sure the
688 * INT is acknowledged
689 */
690 cc770_write_reg(priv, msgobj[mo].ctrl0,
691 MSGVAL_UNC | TXIE_UNC | RXIE_UNC | INTPND_RES);
692
693 stats->tx_packets++;
694 can_get_echo_skb(dev, 0);
695 netif_wake_queue(dev);
696}
697
698static irqreturn_t cc770_interrupt(int irq, void *dev_id)
699{
700 struct net_device *dev = (struct net_device *)dev_id;
701 struct cc770_priv *priv = netdev_priv(dev);
702 u8 intid;
703 int o, n = 0;
704
705 /* Shared interrupts and IRQ off? */
706 if (priv->can.state == CAN_STATE_STOPPED)
707 return IRQ_NONE;
708
709 if (priv->pre_irq)
710 priv->pre_irq(priv);
711
712 while (n < CC770_MAX_IRQ) {
713 /* Read the highest pending interrupt request */
714 intid = cc770_read_reg(priv, interrupt);
715 if (!intid)
716 break;
717 n++;
718
719 if (intid == 1) {
720 /* Exit in case of bus-off */
721 if (cc770_status_interrupt(dev))
722 break;
723 } else {
724 o = intid2obj(intid);
725
726 if (o >= CC770_OBJ_MAX) {
727 netdev_err(dev, "Unexpected interrupt id %d\n",
728 intid);
729 continue;
730 }
731
732 if (priv->obj_flags[o] & CC770_OBJ_FLAG_RTR)
733 cc770_rtr_interrupt(dev, o);
734 else if (priv->obj_flags[o] & CC770_OBJ_FLAG_RX)
735 cc770_rx_interrupt(dev, o);
736 else
737 cc770_tx_interrupt(dev, o);
738 }
739 }
740
741 if (priv->post_irq)
742 priv->post_irq(priv);
743
744 if (n >= CC770_MAX_IRQ)
745 netdev_dbg(dev, "%d messages handled in ISR", n);
746
747 return (n) ? IRQ_HANDLED : IRQ_NONE;
748}
749
750static int cc770_open(struct net_device *dev)
751{
752 struct cc770_priv *priv = netdev_priv(dev);
753 int err;
754
755 /* set chip into reset mode */
756 set_reset_mode(dev);
757
758 /* common open */
759 err = open_candev(dev);
760 if (err)
761 return err;
762
763 err = request_irq(dev->irq, &cc770_interrupt, priv->irq_flags,
764 dev->name, dev);
765 if (err) {
766 close_candev(dev);
767 return -EAGAIN;
768 }
769
770 /* init and start chip */
771 cc770_start(dev);
772
773 netif_start_queue(dev);
774
775 return 0;
776}
777
778static int cc770_close(struct net_device *dev)
779{
780 netif_stop_queue(dev);
781 set_reset_mode(dev);
782
783 free_irq(dev->irq, dev);
784 close_candev(dev);
785
786 return 0;
787}
788
789struct net_device *alloc_cc770dev(int sizeof_priv)
790{
791 struct net_device *dev;
792 struct cc770_priv *priv;
793
794 dev = alloc_candev(sizeof(struct cc770_priv) + sizeof_priv,
795 CC770_ECHO_SKB_MAX);
796 if (!dev)
797 return NULL;
798
799 priv = netdev_priv(dev);
800
801 priv->dev = dev;
802 priv->can.bittiming_const = &cc770_bittiming_const;
803 priv->can.do_set_bittiming = cc770_set_bittiming;
804 priv->can.do_set_mode = cc770_set_mode;
805 priv->can.ctrlmode_supported = CAN_CTRLMODE_3_SAMPLES;
806
807 memcpy(priv->obj_flags, cc770_obj_flags, sizeof(cc770_obj_flags));
808
809 if (sizeof_priv)
810 priv->priv = (void *)priv + sizeof(struct cc770_priv);
811
812 return dev;
813}
814EXPORT_SYMBOL_GPL(alloc_cc770dev);
815
816void free_cc770dev(struct net_device *dev)
817{
818 free_candev(dev);
819}
820EXPORT_SYMBOL_GPL(free_cc770dev);
821
822static const struct net_device_ops cc770_netdev_ops = {
823 .ndo_open = cc770_open,
824 .ndo_stop = cc770_close,
825 .ndo_start_xmit = cc770_start_xmit,
826};
827
828int register_cc770dev(struct net_device *dev)
829{
830 struct cc770_priv *priv = netdev_priv(dev);
831 int err;
832
833 err = cc770_probe_chip(dev);
834 if (err)
835 return err;
836
837 dev->netdev_ops = &cc770_netdev_ops;
838
839 dev->flags |= IFF_ECHO; /* we support local echo */
840
841 /* Should we use additional functions? */
842 if (!i82527_compat && priv->control_normal_mode & CTRL_EAF) {
843 priv->can.do_get_berr_counter = cc770_get_berr_counter;
844 priv->control_normal_mode = CTRL_IE | CTRL_EAF | CTRL_EIE;
845 netdev_dbg(dev, "i82527 mode with additional functions\n");
846 } else {
847 priv->control_normal_mode = CTRL_IE | CTRL_EIE;
848 netdev_dbg(dev, "strict i82527 compatibility mode\n");
849 }
850
851 chipset_init(priv);
852 set_reset_mode(dev);
853
854 return register_candev(dev);
855}
856EXPORT_SYMBOL_GPL(register_cc770dev);
857
858void unregister_cc770dev(struct net_device *dev)
859{
860 set_reset_mode(dev);
861 unregister_candev(dev);
862}
863EXPORT_SYMBOL_GPL(unregister_cc770dev);
864
865static __init int cc770_init(void)
866{
867 if (msgobj15_eff) {
868 cc770_obj_flags[CC770_OBJ_RX0] |= CC770_OBJ_FLAG_EFF;
869 cc770_obj_flags[CC770_OBJ_RX1] &= ~CC770_OBJ_FLAG_EFF;
870 }
871
872 pr_info("CAN netdevice driver\n");
873
874 return 0;
875}
876module_init(cc770_init);
877
878static __exit void cc770_exit(void)
879{
880 pr_info("driver removed\n");
881}
882module_exit(cc770_exit);
diff --git a/drivers/net/can/cc770/cc770.h b/drivers/net/can/cc770/cc770.h
deleted file mode 100644
index a1739db98d9..00000000000
--- a/drivers/net/can/cc770/cc770.h
+++ /dev/null
@@ -1,203 +0,0 @@
1/*
2 * Core driver for the CC770 and AN82527 CAN controllers
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#ifndef CC770_DEV_H
17#define CC770_DEV_H
18
19#include <linux/can/dev.h>
20
21struct cc770_msgobj {
22 u8 ctrl0;
23 u8 ctrl1;
24 u8 id[4];
25 u8 config;
26 u8 data[8];
27 u8 dontuse; /* padding */
28} __packed;
29
30struct cc770_regs {
31 union {
32 struct cc770_msgobj msgobj[16]; /* Message object 1..15 */
33 struct {
34 u8 control; /* Control Register */
35 u8 status; /* Status Register */
36 u8 cpu_interface; /* CPU Interface Register */
37 u8 dontuse1;
38 u8 high_speed_read[2]; /* High Speed Read */
39 u8 global_mask_std[2]; /* Standard Global Mask */
40 u8 global_mask_ext[4]; /* Extended Global Mask */
41 u8 msg15_mask[4]; /* Message 15 Mask */
42 u8 dontuse2[15];
43 u8 clkout; /* Clock Out Register */
44 u8 dontuse3[15];
45 u8 bus_config; /* Bus Configuration Register */
46 u8 dontuse4[15];
47 u8 bit_timing_0; /* Bit Timing Register byte 0 */
48 u8 dontuse5[15];
49 u8 bit_timing_1; /* Bit Timing Register byte 1 */
50 u8 dontuse6[15];
51 u8 interrupt; /* Interrupt Register */
52 u8 dontuse7[15];
53 u8 rx_error_counter; /* Receive Error Counter */
54 u8 dontuse8[15];
55 u8 tx_error_counter; /* Transmit Error Counter */
56 u8 dontuse9[31];
57 u8 p1_conf;
58 u8 dontuse10[15];
59 u8 p2_conf;
60 u8 dontuse11[15];
61 u8 p1_in;
62 u8 dontuse12[15];
63 u8 p2_in;
64 u8 dontuse13[15];
65 u8 p1_out;
66 u8 dontuse14[15];
67 u8 p2_out;
68 u8 dontuse15[15];
69 u8 serial_reset_addr;
70 };
71 };
72} __packed;
73
74/* Control Register (0x00) */
75#define CTRL_INI 0x01 /* Initialization */
76#define CTRL_IE 0x02 /* Interrupt Enable */
77#define CTRL_SIE 0x04 /* Status Interrupt Enable */
78#define CTRL_EIE 0x08 /* Error Interrupt Enable */
79#define CTRL_EAF 0x20 /* Enable additional functions */
80#define CTRL_CCE 0x40 /* Change Configuration Enable */
81
82/* Status Register (0x01) */
83#define STAT_LEC_STUFF 0x01 /* Stuff error */
84#define STAT_LEC_FORM 0x02 /* Form error */
85#define STAT_LEC_ACK 0x03 /* Acknowledgement error */
86#define STAT_LEC_BIT1 0x04 /* Bit1 error */
87#define STAT_LEC_BIT0 0x05 /* Bit0 error */
88#define STAT_LEC_CRC 0x06 /* CRC error */
89#define STAT_LEC_MASK 0x07 /* Last Error Code mask */
90#define STAT_TXOK 0x08 /* Transmit Message Successfully */
91#define STAT_RXOK 0x10 /* Receive Message Successfully */
92#define STAT_WAKE 0x20 /* Wake Up Status */
93#define STAT_WARN 0x40 /* Warning Status */
94#define STAT_BOFF 0x80 /* Bus Off Status */
95
96/*
97 * CPU Interface Register (0x02)
98 * Clock Out Register (0x1f)
99 * Bus Configuration Register (0x2f)
100 *
101 * see include/linux/can/platform/cc770.h
102 */
103
104/* Message Control Register 0 (Base Address + 0x0) */
105#define INTPND_RES 0x01 /* No Interrupt pending */
106#define INTPND_SET 0x02 /* Interrupt pending */
107#define INTPND_UNC 0x03
108#define RXIE_RES 0x04 /* Receive Interrupt Disable */
109#define RXIE_SET 0x08 /* Receive Interrupt Enable */
110#define RXIE_UNC 0x0c
111#define TXIE_RES 0x10 /* Transmit Interrupt Disable */
112#define TXIE_SET 0x20 /* Transmit Interrupt Enable */
113#define TXIE_UNC 0x30
114#define MSGVAL_RES 0x40 /* Message Invalid */
115#define MSGVAL_SET 0x80 /* Message Valid */
116#define MSGVAL_UNC 0xc0
117
118/* Message Control Register 1 (Base Address + 0x01) */
119#define NEWDAT_RES 0x01 /* No New Data */
120#define NEWDAT_SET 0x02 /* New Data */
121#define NEWDAT_UNC 0x03
122#define MSGLST_RES 0x04 /* No Message Lost */
123#define MSGLST_SET 0x08 /* Message Lost */
124#define MSGLST_UNC 0x0c
125#define CPUUPD_RES 0x04 /* No CPU Updating */
126#define CPUUPD_SET 0x08 /* CPU Updating */
127#define CPUUPD_UNC 0x0c
128#define TXRQST_RES 0x10 /* No Transmission Request */
129#define TXRQST_SET 0x20 /* Transmission Request */
130#define TXRQST_UNC 0x30
131#define RMTPND_RES 0x40 /* No Remote Request Pending */
132#define RMTPND_SET 0x80 /* Remote Request Pending */
133#define RMTPND_UNC 0xc0
134
135/* Message Configuration Register (Base Address + 0x06) */
136#define MSGCFG_XTD 0x04 /* Extended Identifier */
137#define MSGCFG_DIR 0x08 /* Direction is Transmit */
138
139#define MSGOBJ_FIRST 1
140#define MSGOBJ_LAST 15
141
142#define CC770_IO_SIZE 0x100
143#define CC770_MAX_IRQ 20 /* max. number of interrupts handled in ISR */
144#define CC770_MAX_MSG 4 /* max. number of messages handled in ISR */
145
146#define CC770_ECHO_SKB_MAX 1
147
148#define cc770_read_reg(priv, member) \
149 priv->read_reg(priv, offsetof(struct cc770_regs, member))
150
151#define cc770_write_reg(priv, member, value) \
152 priv->write_reg(priv, offsetof(struct cc770_regs, member), value)
153
154/*
155 * Message objects and flags used by this driver
156 */
157#define CC770_OBJ_FLAG_RX 0x01
158#define CC770_OBJ_FLAG_RTR 0x02
159#define CC770_OBJ_FLAG_EFF 0x04
160
161enum {
162 CC770_OBJ_RX0 = 0, /* for receiving normal messages */
163 CC770_OBJ_RX1, /* for receiving normal messages */
164 CC770_OBJ_RX_RTR0, /* for receiving remote transmission requests */
165 CC770_OBJ_RX_RTR1, /* for receiving remote transmission requests */
166 CC770_OBJ_TX, /* for sending messages */
167 CC770_OBJ_MAX
168};
169
170#define obj2msgobj(o) (MSGOBJ_LAST - (o)) /* message object 11..15 */
171
172/*
173 * CC770 private data structure
174 */
175struct cc770_priv {
176 struct can_priv can; /* must be the first member */
177 struct sk_buff *echo_skb;
178
179 /* the lower-layer is responsible for appropriate locking */
180 u8 (*read_reg)(const struct cc770_priv *priv, int reg);
181 void (*write_reg)(const struct cc770_priv *priv, int reg, u8 val);
182 void (*pre_irq)(const struct cc770_priv *priv);
183 void (*post_irq)(const struct cc770_priv *priv);
184
185 void *priv; /* for board-specific data */
186 struct net_device *dev;
187
188 void __iomem *reg_base; /* ioremap'ed address to registers */
189 unsigned long irq_flags; /* for request_irq() */
190
191 unsigned char obj_flags[CC770_OBJ_MAX];
192 u8 control_normal_mode; /* Control register for normal mode */
193 u8 cpu_interface; /* CPU interface register */
194 u8 clkout; /* Clock out register */
195 u8 bus_config; /* Bus conffiguration register */
196};
197
198struct net_device *alloc_cc770dev(int sizeof_priv);
199void free_cc770dev(struct net_device *dev);
200int register_cc770dev(struct net_device *dev);
201void unregister_cc770dev(struct net_device *dev);
202
203#endif /* CC770_DEV_H */
diff --git a/drivers/net/can/cc770/cc770_isa.c b/drivers/net/can/cc770/cc770_isa.c
deleted file mode 100644
index 8eaaac81f32..00000000000
--- a/drivers/net/can/cc770/cc770_isa.c
+++ /dev/null
@@ -1,381 +0,0 @@
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
68MODULE_AUTHOR("Wolfgang Grandegger <wg@grandegger.com>");
69MODULE_DESCRIPTION("Socket-CAN driver for CC770 on the ISA bus");
70MODULE_LICENSE("GPL v2");
71
72#define CLK_DEFAULT 16000000 /* 16 MHz */
73#define COR_DEFAULT 0x00
74#define BCR_DEFAULT BUSCFG_CBY
75
76static unsigned long port[MAXDEV];
77static unsigned long mem[MAXDEV];
78static int irq[MAXDEV];
79static int clk[MAXDEV];
80static u8 cir[MAXDEV] = {[0 ... (MAXDEV - 1)] = 0xff};
81static u8 cor[MAXDEV] = {[0 ... (MAXDEV - 1)] = 0xff};
82static u8 bcr[MAXDEV] = {[0 ... (MAXDEV - 1)] = 0xff};
83static int indirect[MAXDEV] = {[0 ... (MAXDEV - 1)] = -1};
84
85module_param_array(port, ulong, NULL, S_IRUGO);
86MODULE_PARM_DESC(port, "I/O port number");
87
88module_param_array(mem, ulong, NULL, S_IRUGO);
89MODULE_PARM_DESC(mem, "I/O memory address");
90
91module_param_array(indirect, int, NULL, S_IRUGO);
92MODULE_PARM_DESC(indirect, "Indirect access via address and data port");
93
94module_param_array(irq, int, NULL, S_IRUGO);
95MODULE_PARM_DESC(irq, "IRQ number");
96
97module_param_array(clk, int, NULL, S_IRUGO);
98MODULE_PARM_DESC(clk, "External oscillator clock frequency "
99 "(default=16000000 [16 MHz])");
100
101module_param_array(cir, byte, NULL, S_IRUGO);
102MODULE_PARM_DESC(cir, "CPU interface register (default=0x40 [DSC])");
103
104module_param_array(cor, byte, NULL, S_IRUGO);
105MODULE_PARM_DESC(cor, "Clockout register (default=0x00)");
106
107module_param_array(bcr, byte, NULL, S_IRUGO);
108MODULE_PARM_DESC(bcr, "Bus configuration register (default=0x40 [CBY])");
109
110#define CC770_IOSIZE 0x20
111#define CC770_IOSIZE_INDIRECT 0x02
112
113/* Spinlock for cc770_isa_port_write_reg_indirect
114 * and cc770_isa_port_read_reg_indirect
115 */
116static DEFINE_SPINLOCK(cc770_isa_port_lock);
117
118static struct platform_device *cc770_isa_devs[MAXDEV];
119
120static u8 cc770_isa_mem_read_reg(const struct cc770_priv *priv, int reg)
121{
122 return readb(priv->reg_base + reg);
123}
124
125static 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
131static 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
136static 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
142static 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;
146 unsigned long flags;
147 u8 val;
148
149 spin_lock_irqsave(&cc770_isa_port_lock, flags);
150 outb(reg, base);
151 val = inb(base + 1);
152 spin_unlock_irqrestore(&cc770_isa_port_lock, flags);
153
154 return val;
155}
156
157static 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;
161 unsigned long flags;
162
163 spin_lock_irqsave(&cc770_isa_port_lock, flags);
164 outb(reg, base);
165 outb(val, base + 1);
166 spin_unlock_irqrestore(&cc770_isa_port_lock, flags);
167}
168
169static int cc770_isa_probe(struct platform_device *pdev)
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
268 dev_set_drvdata(&pdev->dev, dev);
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
294static int cc770_isa_remove(struct platform_device *pdev)
295{
296 struct net_device *dev = dev_get_drvdata(&pdev->dev);
297 struct cc770_priv *priv = netdev_priv(dev);
298 int idx = pdev->id;
299
300 unregister_cc770dev(dev);
301 dev_set_drvdata(&pdev->dev, NULL);
302
303 if (mem[idx]) {
304 iounmap(priv->reg_base);
305 release_mem_region(mem[idx], CC770_IOSIZE);
306 } else {
307 if (priv->read_reg == cc770_isa_port_read_reg_indirect)
308 release_region(port[idx], CC770_IOSIZE_INDIRECT);
309 else
310 release_region(port[idx], CC770_IOSIZE);
311 }
312 free_cc770dev(dev);
313
314 return 0;
315}
316
317static struct platform_driver cc770_isa_driver = {
318 .probe = cc770_isa_probe,
319 .remove = cc770_isa_remove,
320 .driver = {
321 .name = KBUILD_MODNAME,
322 .owner = THIS_MODULE,
323 },
324};
325
326static int __init cc770_isa_init(void)
327{
328 int idx, err;
329
330 for (idx = 0; idx < ARRAY_SIZE(cc770_isa_devs); idx++) {
331 if ((port[idx] || mem[idx]) && irq[idx]) {
332 cc770_isa_devs[idx] =
333 platform_device_alloc(KBUILD_MODNAME, idx);
334 if (!cc770_isa_devs[idx]) {
335 err = -ENOMEM;
336 goto exit_free_devices;
337 }
338 err = platform_device_add(cc770_isa_devs[idx]);
339 if (err) {
340 platform_device_put(cc770_isa_devs[idx]);
341 goto exit_free_devices;
342 }
343 pr_debug("platform device %d: port=%#lx, mem=%#lx, "
344 "irq=%d\n",
345 idx, port[idx], mem[idx], irq[idx]);
346 } else if (idx == 0 || port[idx] || mem[idx]) {
347 pr_err("insufficient parameters supplied\n");
348 err = -EINVAL;
349 goto exit_free_devices;
350 }
351 }
352
353 err = platform_driver_register(&cc770_isa_driver);
354 if (err)
355 goto exit_free_devices;
356
357 pr_info("driver for max. %d devices registered\n", MAXDEV);
358
359 return 0;
360
361exit_free_devices:
362 while (--idx >= 0) {
363 if (cc770_isa_devs[idx])
364 platform_device_unregister(cc770_isa_devs[idx]);
365 }
366
367 return err;
368}
369module_init(cc770_isa_init);
370
371static void __exit cc770_isa_exit(void)
372{
373 int idx;
374
375 platform_driver_unregister(&cc770_isa_driver);
376 for (idx = 0; idx < ARRAY_SIZE(cc770_isa_devs); idx++) {
377 if (cc770_isa_devs[idx])
378 platform_device_unregister(cc770_isa_devs[idx]);
379 }
380}
381module_exit(cc770_isa_exit);
diff --git a/drivers/net/can/cc770/cc770_platform.c b/drivers/net/can/cc770/cc770_platform.c
deleted file mode 100644
index d0f6bfc45ae..00000000000
--- a/drivers/net/can/cc770/cc770_platform.c
+++ /dev/null
@@ -1,274 +0,0 @@
1/*
2 * Driver for CC770 and AN82527 CAN controllers on the platform 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 * If platform data are used you should have similar definitions
18 * in your board-specific code:
19 *
20 * static struct cc770_platform_data myboard_cc770_pdata = {
21 * .osc_freq = 16000000,
22 * .cir = 0x41,
23 * .cor = 0x20,
24 * .bcr = 0x40,
25 * };
26 *
27 * Please see include/linux/can/platform/cc770.h for description of
28 * above fields.
29 *
30 * If the device tree is used, you need a CAN node definition in your
31 * DTS file similar to:
32 *
33 * can@3,100 {
34 * compatible = "bosch,cc770";
35 * reg = <3 0x100 0x80>;
36 * interrupts = <2 0>;
37 * interrupt-parent = <&mpic>;
38 * bosch,external-clock-frequency = <16000000>;
39 * };
40 *
41 * See "Documentation/devicetree/bindings/net/can/cc770.txt" for further
42 * information.
43 */
44
45#include <linux/kernel.h>
46#include <linux/module.h>
47#include <linux/interrupt.h>
48#include <linux/netdevice.h>
49#include <linux/delay.h>
50#include <linux/platform_device.h>
51#include <linux/of.h>
52#include <linux/can.h>
53#include <linux/can/dev.h>
54#include <linux/can/platform/cc770.h>
55
56#include "cc770.h"
57
58#define DRV_NAME "cc770_platform"
59
60MODULE_AUTHOR("Wolfgang Grandegger <wg@grandegger.com>");
61MODULE_DESCRIPTION("Socket-CAN driver for CC770 on the platform bus");
62MODULE_LICENSE("GPL v2");
63MODULE_ALIAS("platform:" DRV_NAME);
64
65#define CC770_PLATFORM_CAN_CLOCK 16000000
66
67static u8 cc770_platform_read_reg(const struct cc770_priv *priv, int reg)
68{
69 return ioread8(priv->reg_base + reg);
70}
71
72static void cc770_platform_write_reg(const struct cc770_priv *priv, int reg,
73 u8 val)
74{
75 iowrite8(val, priv->reg_base + reg);
76}
77
78static int cc770_get_of_node_data(struct platform_device *pdev,
79 struct cc770_priv *priv)
80{
81 struct device_node *np = pdev->dev.of_node;
82 const u32 *prop;
83 int prop_size;
84 u32 clkext;
85
86 prop = of_get_property(np, "bosch,external-clock-frequency",
87 &prop_size);
88 if (prop && (prop_size == sizeof(u32)))
89 clkext = *prop;
90 else
91 clkext = CC770_PLATFORM_CAN_CLOCK; /* default */
92 priv->can.clock.freq = clkext;
93
94 /* The system clock may not exceed 10 MHz */
95 if (priv->can.clock.freq > 10000000) {
96 priv->cpu_interface |= CPUIF_DSC;
97 priv->can.clock.freq /= 2;
98 }
99
100 /* The memory clock may not exceed 8 MHz */
101 if (priv->can.clock.freq > 8000000)
102 priv->cpu_interface |= CPUIF_DMC;
103
104 if (of_get_property(np, "bosch,divide-memory-clock", NULL))
105 priv->cpu_interface |= CPUIF_DMC;
106 if (of_get_property(np, "bosch,iso-low-speed-mux", NULL))
107 priv->cpu_interface |= CPUIF_MUX;
108
109 if (!of_get_property(np, "bosch,no-comperator-bypass", NULL))
110 priv->bus_config |= BUSCFG_CBY;
111 if (of_get_property(np, "bosch,disconnect-rx0-input", NULL))
112 priv->bus_config |= BUSCFG_DR0;
113 if (of_get_property(np, "bosch,disconnect-rx1-input", NULL))
114 priv->bus_config |= BUSCFG_DR1;
115 if (of_get_property(np, "bosch,disconnect-tx1-output", NULL))
116 priv->bus_config |= BUSCFG_DT1;
117 if (of_get_property(np, "bosch,polarity-dominant", NULL))
118 priv->bus_config |= BUSCFG_POL;
119
120 prop = of_get_property(np, "bosch,clock-out-frequency", &prop_size);
121 if (prop && (prop_size == sizeof(u32)) && *prop > 0) {
122 u32 cdv = clkext / *prop;
123 int slew;
124
125 if (cdv > 0 && cdv < 16) {
126 priv->cpu_interface |= CPUIF_CEN;
127 priv->clkout |= (cdv - 1) & CLKOUT_CD_MASK;
128
129 prop = of_get_property(np, "bosch,slew-rate",
130 &prop_size);
131 if (prop && (prop_size == sizeof(u32))) {
132 slew = *prop;
133 } else {
134 /* Determine default slew rate */
135 slew = (CLKOUT_SL_MASK >>
136 CLKOUT_SL_SHIFT) -
137 ((cdv * clkext - 1) / 8000000);
138 if (slew < 0)
139 slew = 0;
140 }
141 priv->clkout |= (slew << CLKOUT_SL_SHIFT) &
142 CLKOUT_SL_MASK;
143 } else {
144 dev_dbg(&pdev->dev, "invalid clock-out-frequency\n");
145 }
146 }
147
148 return 0;
149}
150
151static int cc770_get_platform_data(struct platform_device *pdev,
152 struct cc770_priv *priv)
153{
154
155 struct cc770_platform_data *pdata = pdev->dev.platform_data;
156
157 priv->can.clock.freq = pdata->osc_freq;
158 if (priv->cpu_interface & CPUIF_DSC)
159 priv->can.clock.freq /= 2;
160 priv->clkout = pdata->cor;
161 priv->bus_config = pdata->bcr;
162 priv->cpu_interface = pdata->cir;
163
164 return 0;
165}
166
167static int cc770_platform_probe(struct platform_device *pdev)
168{
169 struct net_device *dev;
170 struct cc770_priv *priv;
171 struct resource *mem;
172 resource_size_t mem_size;
173 void __iomem *base;
174 int err, irq;
175
176 mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
177 irq = platform_get_irq(pdev, 0);
178 if (!mem || irq <= 0)
179 return -ENODEV;
180
181 mem_size = resource_size(mem);
182 if (!request_mem_region(mem->start, mem_size, pdev->name))
183 return -EBUSY;
184
185 base = ioremap(mem->start, mem_size);
186 if (!base) {
187 err = -ENOMEM;
188 goto exit_release_mem;
189 }
190
191 dev = alloc_cc770dev(0);
192 if (!dev) {
193 err = -ENOMEM;
194 goto exit_unmap_mem;
195 }
196
197 dev->irq = irq;
198 priv = netdev_priv(dev);
199 priv->read_reg = cc770_platform_read_reg;
200 priv->write_reg = cc770_platform_write_reg;
201 priv->irq_flags = IRQF_SHARED;
202 priv->reg_base = base;
203
204 if (pdev->dev.of_node)
205 err = cc770_get_of_node_data(pdev, priv);
206 else if (pdev->dev.platform_data)
207 err = cc770_get_platform_data(pdev, priv);
208 else
209 err = -ENODEV;
210 if (err)
211 goto exit_free_cc770;
212
213 dev_dbg(&pdev->dev,
214 "reg_base=0x%p irq=%d clock=%d cpu_interface=0x%02x "
215 "bus_config=0x%02x clkout=0x%02x\n",
216 priv->reg_base, dev->irq, priv->can.clock.freq,
217 priv->cpu_interface, priv->bus_config, priv->clkout);
218
219 dev_set_drvdata(&pdev->dev, dev);
220 SET_NETDEV_DEV(dev, &pdev->dev);
221
222 err = register_cc770dev(dev);
223 if (err) {
224 dev_err(&pdev->dev,
225 "couldn't register CC700 device (err=%d)\n", err);
226 goto exit_free_cc770;
227 }
228
229 return 0;
230
231exit_free_cc770:
232 free_cc770dev(dev);
233exit_unmap_mem:
234 iounmap(base);
235exit_release_mem:
236 release_mem_region(mem->start, mem_size);
237
238 return err;
239}
240
241static int cc770_platform_remove(struct platform_device *pdev)
242{
243 struct net_device *dev = dev_get_drvdata(&pdev->dev);
244 struct cc770_priv *priv = netdev_priv(dev);
245 struct resource *mem;
246
247 unregister_cc770dev(dev);
248 iounmap(priv->reg_base);
249 free_cc770dev(dev);
250
251 mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
252 release_mem_region(mem->start, resource_size(mem));
253
254 return 0;
255}
256
257static struct of_device_id cc770_platform_table[] = {
258 {.compatible = "bosch,cc770"}, /* CC770 from Bosch */
259 {.compatible = "intc,82527"}, /* AN82527 from Intel CP */
260 {},
261};
262MODULE_DEVICE_TABLE(of, cc770_platform_table);
263
264static struct platform_driver cc770_platform_driver = {
265 .driver = {
266 .name = DRV_NAME,
267 .owner = THIS_MODULE,
268 .of_match_table = cc770_platform_table,
269 },
270 .probe = cc770_platform_probe,
271 .remove = cc770_platform_remove,
272};
273
274module_platform_driver(cc770_platform_driver);
diff --git a/drivers/net/can/dev.c b/drivers/net/can/dev.c
index 8233e5ed293..9bf1116e5b5 100644
--- a/drivers/net/can/dev.c
+++ b/drivers/net/can/dev.c
@@ -33,39 +33,6 @@ MODULE_DESCRIPTION(MOD_DESC);
33MODULE_LICENSE("GPL v2"); 33MODULE_LICENSE("GPL v2");
34MODULE_AUTHOR("Wolfgang Grandegger <wg@grandegger.com>"); 34MODULE_AUTHOR("Wolfgang Grandegger <wg@grandegger.com>");
35 35
36/* CAN DLC to real data length conversion helpers */
37
38static const u8 dlc2len[] = {0, 1, 2, 3, 4, 5, 6, 7,
39 8, 12, 16, 20, 24, 32, 48, 64};
40
41/* get data length from can_dlc with sanitized can_dlc */
42u8 can_dlc2len(u8 can_dlc)
43{
44 return dlc2len[can_dlc & 0x0F];
45}
46EXPORT_SYMBOL_GPL(can_dlc2len);
47
48static const u8 len2dlc[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, /* 0 - 8 */
49 9, 9, 9, 9, /* 9 - 12 */
50 10, 10, 10, 10, /* 13 - 16 */
51 11, 11, 11, 11, /* 17 - 20 */
52 12, 12, 12, 12, /* 21 - 24 */
53 13, 13, 13, 13, 13, 13, 13, 13, /* 25 - 32 */
54 14, 14, 14, 14, 14, 14, 14, 14, /* 33 - 40 */
55 14, 14, 14, 14, 14, 14, 14, 14, /* 41 - 48 */
56 15, 15, 15, 15, 15, 15, 15, 15, /* 49 - 56 */
57 15, 15, 15, 15, 15, 15, 15, 15}; /* 57 - 64 */
58
59/* map the sanitized data length to an appropriate data length code */
60u8 can_len2dlc(u8 len)
61{
62 if (unlikely(len > 64))
63 return 0xF;
64
65 return len2dlc[len];
66}
67EXPORT_SYMBOL_GPL(can_len2dlc);
68
69#ifdef CONFIG_CAN_CALC_BITTIMING 36#ifdef CONFIG_CAN_CALC_BITTIMING
70#define CAN_CALC_MAX_ERROR 50 /* in one-tenth of a percent */ 37#define CAN_CALC_MAX_ERROR 50 /* in one-tenth of a percent */
71 38
@@ -163,13 +130,13 @@ static int can_calc_bittiming(struct net_device *dev, struct can_bittiming *bt)
163 /* Error in one-tenth of a percent */ 130 /* Error in one-tenth of a percent */
164 error = (best_error * 1000) / bt->bitrate; 131 error = (best_error * 1000) / bt->bitrate;
165 if (error > CAN_CALC_MAX_ERROR) { 132 if (error > CAN_CALC_MAX_ERROR) {
166 netdev_err(dev, 133 dev_err(dev->dev.parent,
167 "bitrate error %ld.%ld%% too high\n", 134 "bitrate error %ld.%ld%% too high\n",
168 error / 10, error % 10); 135 error / 10, error % 10);
169 return -EDOM; 136 return -EDOM;
170 } else { 137 } else {
171 netdev_warn(dev, "bitrate error %ld.%ld%%\n", 138 dev_warn(dev->dev.parent, "bitrate error %ld.%ld%%\n",
172 error / 10, error % 10); 139 error / 10, error % 10);
173 } 140 }
174 } 141 }
175 142
@@ -183,19 +150,7 @@ static int can_calc_bittiming(struct net_device *dev, struct can_bittiming *bt)
183 bt->prop_seg = tseg1 / 2; 150 bt->prop_seg = tseg1 / 2;
184 bt->phase_seg1 = tseg1 - bt->prop_seg; 151 bt->phase_seg1 = tseg1 - bt->prop_seg;
185 bt->phase_seg2 = tseg2; 152 bt->phase_seg2 = tseg2;
186 153 bt->sjw = 1;
187 /* check for sjw user settings */
188 if (!bt->sjw || !btc->sjw_max)
189 bt->sjw = 1;
190 else {
191 /* bt->sjw is at least 1 -> sanitize upper bound to sjw_max */
192 if (bt->sjw > btc->sjw_max)
193 bt->sjw = btc->sjw_max;
194 /* bt->sjw must not be higher than tseg2 */
195 if (tseg2 < bt->sjw)
196 bt->sjw = tseg2;
197 }
198
199 bt->brp = best_brp; 154 bt->brp = best_brp;
200 /* real bit-rate */ 155 /* real bit-rate */
201 bt->bitrate = priv->clock.freq / (bt->brp * (tseg1 + tseg2 + 1)); 156 bt->bitrate = priv->clock.freq / (bt->brp * (tseg1 + tseg2 + 1));
@@ -205,7 +160,7 @@ static int can_calc_bittiming(struct net_device *dev, struct can_bittiming *bt)
205#else /* !CONFIG_CAN_CALC_BITTIMING */ 160#else /* !CONFIG_CAN_CALC_BITTIMING */
206static int can_calc_bittiming(struct net_device *dev, struct can_bittiming *bt) 161static int can_calc_bittiming(struct net_device *dev, struct can_bittiming *bt)
207{ 162{
208 netdev_err(dev, "bit-timing calculation not available\n"); 163 dev_err(dev->dev.parent, "bit-timing calculation not available\n");
209 return -EINVAL; 164 return -EINVAL;
210} 165}
211#endif /* CONFIG_CAN_CALC_BITTIMING */ 166#endif /* CONFIG_CAN_CALC_BITTIMING */
@@ -346,7 +301,8 @@ void can_put_echo_skb(struct sk_buff *skb, struct net_device *dev,
346 priv->echo_skb[idx] = skb; 301 priv->echo_skb[idx] = skb;
347 } else { 302 } else {
348 /* locking problem with netif_stop_queue() ?? */ 303 /* locking problem with netif_stop_queue() ?? */
349 netdev_err(dev, "%s: BUG! echo_skb is occupied!\n", __func__); 304 dev_err(dev->dev.parent, "%s: BUG! echo_skb is occupied!\n",
305 __func__);
350 kfree_skb(skb); 306 kfree_skb(skb);
351 } 307 }
352} 308}
@@ -359,24 +315,16 @@ EXPORT_SYMBOL_GPL(can_put_echo_skb);
359 * is handled in the device driver. The driver must protect 315 * is handled in the device driver. The driver must protect
360 * access to priv->echo_skb, if necessary. 316 * access to priv->echo_skb, if necessary.
361 */ 317 */
362unsigned int can_get_echo_skb(struct net_device *dev, unsigned int idx) 318void can_get_echo_skb(struct net_device *dev, unsigned int idx)
363{ 319{
364 struct can_priv *priv = netdev_priv(dev); 320 struct can_priv *priv = netdev_priv(dev);
365 321
366 BUG_ON(idx >= priv->echo_skb_max); 322 BUG_ON(idx >= priv->echo_skb_max);
367 323
368 if (priv->echo_skb[idx]) { 324 if (priv->echo_skb[idx]) {
369 struct sk_buff *skb = priv->echo_skb[idx];
370 struct can_frame *cf = (struct can_frame *)skb->data;
371 u8 dlc = cf->can_dlc;
372
373 netif_rx(priv->echo_skb[idx]); 325 netif_rx(priv->echo_skb[idx]);
374 priv->echo_skb[idx] = NULL; 326 priv->echo_skb[idx] = NULL;
375
376 return dlc;
377 } 327 }
378
379 return 0;
380} 328}
381EXPORT_SYMBOL_GPL(can_get_echo_skb); 329EXPORT_SYMBOL_GPL(can_get_echo_skb);
382 330
@@ -401,7 +349,7 @@ EXPORT_SYMBOL_GPL(can_free_echo_skb);
401/* 349/*
402 * CAN device restart for bus-off recovery 350 * CAN device restart for bus-off recovery
403 */ 351 */
404static void can_restart(unsigned long data) 352void can_restart(unsigned long data)
405{ 353{
406 struct net_device *dev = (struct net_device *)data; 354 struct net_device *dev = (struct net_device *)data;
407 struct can_priv *priv = netdev_priv(dev); 355 struct can_priv *priv = netdev_priv(dev);
@@ -432,7 +380,7 @@ static void can_restart(unsigned long data)
432 stats->rx_bytes += cf->can_dlc; 380 stats->rx_bytes += cf->can_dlc;
433 381
434restart: 382restart:
435 netdev_dbg(dev, "restarted\n"); 383 dev_dbg(dev->dev.parent, "restarted\n");
436 priv->can_stats.restarts++; 384 priv->can_stats.restarts++;
437 385
438 /* Now restart the device */ 386 /* Now restart the device */
@@ -440,7 +388,7 @@ restart:
440 388
441 netif_carrier_on(dev); 389 netif_carrier_on(dev);
442 if (err) 390 if (err)
443 netdev_err(dev, "Error %d during restart", err); 391 dev_err(dev->dev.parent, "Error %d during restart", err);
444} 392}
445 393
446int can_restart_now(struct net_device *dev) 394int can_restart_now(struct net_device *dev)
@@ -473,7 +421,7 @@ void can_bus_off(struct net_device *dev)
473{ 421{
474 struct can_priv *priv = netdev_priv(dev); 422 struct can_priv *priv = netdev_priv(dev);
475 423
476 netdev_dbg(dev, "bus-off\n"); 424 dev_dbg(dev->dev.parent, "bus-off\n");
477 425
478 netif_carrier_off(dev); 426 netif_carrier_off(dev);
479 priv->can_stats.bus_off++; 427 priv->can_stats.bus_off++;
@@ -487,14 +435,14 @@ EXPORT_SYMBOL_GPL(can_bus_off);
487static void can_setup(struct net_device *dev) 435static void can_setup(struct net_device *dev)
488{ 436{
489 dev->type = ARPHRD_CAN; 437 dev->type = ARPHRD_CAN;
490 dev->mtu = CAN_MTU; 438 dev->mtu = sizeof(struct can_frame);
491 dev->hard_header_len = 0; 439 dev->hard_header_len = 0;
492 dev->addr_len = 0; 440 dev->addr_len = 0;
493 dev->tx_queue_len = 10; 441 dev->tx_queue_len = 10;
494 442
495 /* New-style flags. */ 443 /* New-style flags. */
496 dev->flags = IFF_NOARP; 444 dev->flags = IFF_NOARP;
497 dev->features = NETIF_F_HW_CSUM; 445 dev->features = NETIF_F_NO_CSUM;
498} 446}
499 447
500struct sk_buff *alloc_can_skb(struct net_device *dev, struct can_frame **cf) 448struct sk_buff *alloc_can_skb(struct net_device *dev, struct can_frame **cf)
@@ -585,7 +533,7 @@ int open_candev(struct net_device *dev)
585 struct can_priv *priv = netdev_priv(dev); 533 struct can_priv *priv = netdev_priv(dev);
586 534
587 if (!priv->bittiming.tq && !priv->bittiming.bitrate) { 535 if (!priv->bittiming.tq && !priv->bittiming.bitrate) {
588 netdev_err(dev, "bit-timing not yet defined\n"); 536 dev_err(dev->dev.parent, "bit-timing not yet defined\n");
589 return -EINVAL; 537 return -EINVAL;
590 } 538 }
591 539
@@ -609,7 +557,8 @@ void close_candev(struct net_device *dev)
609{ 557{
610 struct can_priv *priv = netdev_priv(dev); 558 struct can_priv *priv = netdev_priv(dev);
611 559
612 del_timer_sync(&priv->restart_timer); 560 if (del_timer_sync(&priv->restart_timer))
561 dev_put(dev);
613 can_flush_echo_skb(dev); 562 can_flush_echo_skb(dev);
614} 563}
615EXPORT_SYMBOL_GPL(close_candev); 564EXPORT_SYMBOL_GPL(close_candev);
@@ -719,19 +668,18 @@ static int can_fill_info(struct sk_buff *skb, const struct net_device *dev)
719 668
720 if (priv->do_get_state) 669 if (priv->do_get_state)
721 priv->do_get_state(dev, &state); 670 priv->do_get_state(dev, &state);
722 if (nla_put_u32(skb, IFLA_CAN_STATE, state) || 671 NLA_PUT_U32(skb, IFLA_CAN_STATE, state);
723 nla_put(skb, IFLA_CAN_CTRLMODE, sizeof(cm), &cm) || 672 NLA_PUT(skb, IFLA_CAN_CTRLMODE, sizeof(cm), &cm);
724 nla_put_u32(skb, IFLA_CAN_RESTART_MS, priv->restart_ms) || 673 NLA_PUT_U32(skb, IFLA_CAN_RESTART_MS, priv->restart_ms);
725 nla_put(skb, IFLA_CAN_BITTIMING, 674 NLA_PUT(skb, IFLA_CAN_BITTIMING,
726 sizeof(priv->bittiming), &priv->bittiming) || 675 sizeof(priv->bittiming), &priv->bittiming);
727 nla_put(skb, IFLA_CAN_CLOCK, sizeof(cm), &priv->clock) || 676 NLA_PUT(skb, IFLA_CAN_CLOCK, sizeof(cm), &priv->clock);
728 (priv->do_get_berr_counter && 677 if (priv->do_get_berr_counter && !priv->do_get_berr_counter(dev, &bec))
729 !priv->do_get_berr_counter(dev, &bec) && 678 NLA_PUT(skb, IFLA_CAN_BERR_COUNTER, sizeof(bec), &bec);
730 nla_put(skb, IFLA_CAN_BERR_COUNTER, sizeof(bec), &bec)) || 679 if (priv->bittiming_const)
731 (priv->bittiming_const && 680 NLA_PUT(skb, IFLA_CAN_BITTIMING_CONST,
732 nla_put(skb, IFLA_CAN_BITTIMING_CONST, 681 sizeof(*priv->bittiming_const), priv->bittiming_const);
733 sizeof(*priv->bittiming_const), priv->bittiming_const))) 682
734 goto nla_put_failure;
735 return 0; 683 return 0;
736 684
737nla_put_failure: 685nla_put_failure:
@@ -747,9 +695,9 @@ static int can_fill_xstats(struct sk_buff *skb, const struct net_device *dev)
747{ 695{
748 struct can_priv *priv = netdev_priv(dev); 696 struct can_priv *priv = netdev_priv(dev);
749 697
750 if (nla_put(skb, IFLA_INFO_XSTATS, 698 NLA_PUT(skb, IFLA_INFO_XSTATS,
751 sizeof(priv->can_stats), &priv->can_stats)) 699 sizeof(priv->can_stats), &priv->can_stats);
752 goto nla_put_failure; 700
753 return 0; 701 return 0;
754 702
755nla_put_failure: 703nla_put_failure:
diff --git a/drivers/net/can/flexcan.c b/drivers/net/can/flexcan.c
index 0289a6d86f6..17678117ed6 100644
--- a/drivers/net/can/flexcan.c
+++ b/drivers/net/can/flexcan.c
@@ -33,10 +33,9 @@
33#include <linux/kernel.h> 33#include <linux/kernel.h>
34#include <linux/list.h> 34#include <linux/list.h>
35#include <linux/module.h> 35#include <linux/module.h>
36#include <linux/of.h>
37#include <linux/of_device.h>
38#include <linux/platform_device.h> 36#include <linux/platform_device.h>
39#include <linux/pinctrl/consumer.h> 37
38#include <mach/clock.h>
40 39
41#define DRV_NAME "flexcan" 40#define DRV_NAME "flexcan"
42 41
@@ -120,9 +119,6 @@
120 (FLEXCAN_ESR_TWRN_INT | FLEXCAN_ESR_RWRN_INT | FLEXCAN_ESR_BOFF_INT) 119 (FLEXCAN_ESR_TWRN_INT | FLEXCAN_ESR_RWRN_INT | FLEXCAN_ESR_BOFF_INT)
121#define FLEXCAN_ESR_ERR_ALL \ 120#define FLEXCAN_ESR_ERR_ALL \
122 (FLEXCAN_ESR_ERR_BUS | FLEXCAN_ESR_ERR_STATE) 121 (FLEXCAN_ESR_ERR_BUS | FLEXCAN_ESR_ERR_STATE)
123#define FLEXCAN_ESR_ALL_INT \
124 (FLEXCAN_ESR_TWRN_INT | FLEXCAN_ESR_RWRN_INT | \
125 FLEXCAN_ESR_BOFF_INT | FLEXCAN_ESR_ERR_INT)
126 122
127/* FLEXCAN interrupt flag register (IFLAG) bits */ 123/* FLEXCAN interrupt flag register (IFLAG) bits */
128#define FLEXCAN_TX_BUF_ID 8 124#define FLEXCAN_TX_BUF_ID 8
@@ -144,23 +140,6 @@
144 140
145#define FLEXCAN_MB_CODE_MASK (0xf0ffffff) 141#define FLEXCAN_MB_CODE_MASK (0xf0ffffff)
146 142
147/*
148 * FLEXCAN hardware feature flags
149 *
150 * Below is some version info we got:
151 * SOC Version IP-Version Glitch- [TR]WRN_INT
152 * Filter? connected?
153 * MX25 FlexCAN2 03.00.00.00 no no
154 * MX28 FlexCAN2 03.00.04.00 yes yes
155 * MX35 FlexCAN2 03.00.00.00 no no
156 * MX53 FlexCAN2 03.00.00.00 yes no
157 * MX6s FlexCAN3 10.00.12.00 yes yes
158 *
159 * Some SOCs do not have the RX_WARN & TX_WARN interrupt line connected.
160 */
161#define FLEXCAN_HAS_V10_FEATURES BIT(1) /* For core version >= 10 */
162#define FLEXCAN_HAS_BROKEN_ERR_STATE BIT(2) /* [TR]WRN_INT not connected */
163
164/* Structure of the message buffer */ 143/* Structure of the message buffer */
165struct flexcan_mb { 144struct flexcan_mb {
166 u32 can_ctrl; 145 u32 can_ctrl;
@@ -183,21 +162,10 @@ struct flexcan_regs {
183 u32 imask1; /* 0x28 */ 162 u32 imask1; /* 0x28 */
184 u32 iflag2; /* 0x2c */ 163 u32 iflag2; /* 0x2c */
185 u32 iflag1; /* 0x30 */ 164 u32 iflag1; /* 0x30 */
186 u32 crl2; /* 0x34 */ 165 u32 _reserved2[19];
187 u32 esr2; /* 0x38 */
188 u32 imeur; /* 0x3c */
189 u32 lrfr; /* 0x40 */
190 u32 crcr; /* 0x44 */
191 u32 rxfgmask; /* 0x48 */
192 u32 rxfir; /* 0x4c */
193 u32 _reserved3[12];
194 struct flexcan_mb cantxfg[64]; 166 struct flexcan_mb cantxfg[64];
195}; 167};
196 168
197struct flexcan_devtype_data {
198 u32 features; /* hardware controller features */
199};
200
201struct flexcan_priv { 169struct flexcan_priv {
202 struct can_priv can; 170 struct can_priv can;
203 struct net_device *dev; 171 struct net_device *dev;
@@ -207,21 +175,11 @@ struct flexcan_priv {
207 u32 reg_esr; 175 u32 reg_esr;
208 u32 reg_ctrl_default; 176 u32 reg_ctrl_default;
209 177
210 struct clk *clk_ipg; 178 struct clk *clk;
211 struct clk *clk_per;
212 struct flexcan_platform_data *pdata; 179 struct flexcan_platform_data *pdata;
213 const struct flexcan_devtype_data *devtype_data;
214}; 180};
215 181
216static struct flexcan_devtype_data fsl_p1010_devtype_data = { 182static struct can_bittiming_const flexcan_bittiming_const = {
217 .features = FLEXCAN_HAS_BROKEN_ERR_STATE,
218};
219static struct flexcan_devtype_data fsl_imx28_devtype_data;
220static struct flexcan_devtype_data fsl_imx6q_devtype_data = {
221 .features = FLEXCAN_HAS_V10_FEATURES,
222};
223
224static const struct can_bittiming_const flexcan_bittiming_const = {
225 .name = DRV_NAME, 183 .name = DRV_NAME,
226 .tseg1_min = 4, 184 .tseg1_min = 4,
227 .tseg1_max = 16, 185 .tseg1_max = 16,
@@ -234,31 +192,6 @@ static const struct can_bittiming_const flexcan_bittiming_const = {
234}; 192};
235 193
236/* 194/*
237 * Abstract off the read/write for arm versus ppc.
238 */
239#if defined(__BIG_ENDIAN)
240static inline u32 flexcan_read(void __iomem *addr)
241{
242 return in_be32(addr);
243}
244
245static inline void flexcan_write(u32 val, void __iomem *addr)
246{
247 out_be32(addr, val);
248}
249#else
250static inline u32 flexcan_read(void __iomem *addr)
251{
252 return readl(addr);
253}
254
255static inline void flexcan_write(u32 val, void __iomem *addr)
256{
257 writel(val, addr);
258}
259#endif
260
261/*
262 * Swtich transceiver on or off 195 * Swtich transceiver on or off
263 */ 196 */
264static void flexcan_transceiver_switch(const struct flexcan_priv *priv, int on) 197static void flexcan_transceiver_switch(const struct flexcan_priv *priv, int on)
@@ -279,9 +212,9 @@ static inline void flexcan_chip_enable(struct flexcan_priv *priv)
279 struct flexcan_regs __iomem *regs = priv->base; 212 struct flexcan_regs __iomem *regs = priv->base;
280 u32 reg; 213 u32 reg;
281 214
282 reg = flexcan_read(&regs->mcr); 215 reg = readl(&regs->mcr);
283 reg &= ~FLEXCAN_MCR_MDIS; 216 reg &= ~FLEXCAN_MCR_MDIS;
284 flexcan_write(reg, &regs->mcr); 217 writel(reg, &regs->mcr);
285 218
286 udelay(10); 219 udelay(10);
287} 220}
@@ -291,9 +224,9 @@ static inline void flexcan_chip_disable(struct flexcan_priv *priv)
291 struct flexcan_regs __iomem *regs = priv->base; 224 struct flexcan_regs __iomem *regs = priv->base;
292 u32 reg; 225 u32 reg;
293 226
294 reg = flexcan_read(&regs->mcr); 227 reg = readl(&regs->mcr);
295 reg |= FLEXCAN_MCR_MDIS; 228 reg |= FLEXCAN_MCR_MDIS;
296 flexcan_write(reg, &regs->mcr); 229 writel(reg, &regs->mcr);
297} 230}
298 231
299static int flexcan_get_berr_counter(const struct net_device *dev, 232static int flexcan_get_berr_counter(const struct net_device *dev,
@@ -301,7 +234,7 @@ static int flexcan_get_berr_counter(const struct net_device *dev,
301{ 234{
302 const struct flexcan_priv *priv = netdev_priv(dev); 235 const struct flexcan_priv *priv = netdev_priv(dev);
303 struct flexcan_regs __iomem *regs = priv->base; 236 struct flexcan_regs __iomem *regs = priv->base;
304 u32 reg = flexcan_read(&regs->ecr); 237 u32 reg = readl(&regs->ecr);
305 238
306 bec->txerr = (reg >> 0) & 0xff; 239 bec->txerr = (reg >> 0) & 0xff;
307 bec->rxerr = (reg >> 8) & 0xff; 240 bec->rxerr = (reg >> 8) & 0xff;
@@ -312,6 +245,7 @@ static int flexcan_get_berr_counter(const struct net_device *dev,
312static int flexcan_start_xmit(struct sk_buff *skb, struct net_device *dev) 245static int flexcan_start_xmit(struct sk_buff *skb, struct net_device *dev)
313{ 246{
314 const struct flexcan_priv *priv = netdev_priv(dev); 247 const struct flexcan_priv *priv = netdev_priv(dev);
248 struct net_device_stats *stats = &dev->stats;
315 struct flexcan_regs __iomem *regs = priv->base; 249 struct flexcan_regs __iomem *regs = priv->base;
316 struct can_frame *cf = (struct can_frame *)skb->data; 250 struct can_frame *cf = (struct can_frame *)skb->data;
317 u32 can_id; 251 u32 can_id;
@@ -334,17 +268,20 @@ static int flexcan_start_xmit(struct sk_buff *skb, struct net_device *dev)
334 268
335 if (cf->can_dlc > 0) { 269 if (cf->can_dlc > 0) {
336 u32 data = be32_to_cpup((__be32 *)&cf->data[0]); 270 u32 data = be32_to_cpup((__be32 *)&cf->data[0]);
337 flexcan_write(data, &regs->cantxfg[FLEXCAN_TX_BUF_ID].data[0]); 271 writel(data, &regs->cantxfg[FLEXCAN_TX_BUF_ID].data[0]);
338 } 272 }
339 if (cf->can_dlc > 3) { 273 if (cf->can_dlc > 3) {
340 u32 data = be32_to_cpup((__be32 *)&cf->data[4]); 274 u32 data = be32_to_cpup((__be32 *)&cf->data[4]);
341 flexcan_write(data, &regs->cantxfg[FLEXCAN_TX_BUF_ID].data[1]); 275 writel(data, &regs->cantxfg[FLEXCAN_TX_BUF_ID].data[1]);
342 } 276 }
343 277
344 can_put_echo_skb(skb, dev, 0); 278 writel(can_id, &regs->cantxfg[FLEXCAN_TX_BUF_ID].can_id);
279 writel(ctrl, &regs->cantxfg[FLEXCAN_TX_BUF_ID].can_ctrl);
345 280
346 flexcan_write(can_id, &regs->cantxfg[FLEXCAN_TX_BUF_ID].can_id); 281 kfree_skb(skb);
347 flexcan_write(ctrl, &regs->cantxfg[FLEXCAN_TX_BUF_ID].can_ctrl); 282
283 /* tx_packets is incremented in flexcan_irq */
284 stats->tx_bytes += cf->can_dlc;
348 285
349 return NETDEV_TX_OK; 286 return NETDEV_TX_OK;
350} 287}
@@ -358,34 +295,34 @@ static void do_bus_err(struct net_device *dev,
358 cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR; 295 cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR;
359 296
360 if (reg_esr & FLEXCAN_ESR_BIT1_ERR) { 297 if (reg_esr & FLEXCAN_ESR_BIT1_ERR) {
361 netdev_dbg(dev, "BIT1_ERR irq\n"); 298 dev_dbg(dev->dev.parent, "BIT1_ERR irq\n");
362 cf->data[2] |= CAN_ERR_PROT_BIT1; 299 cf->data[2] |= CAN_ERR_PROT_BIT1;
363 tx_errors = 1; 300 tx_errors = 1;
364 } 301 }
365 if (reg_esr & FLEXCAN_ESR_BIT0_ERR) { 302 if (reg_esr & FLEXCAN_ESR_BIT0_ERR) {
366 netdev_dbg(dev, "BIT0_ERR irq\n"); 303 dev_dbg(dev->dev.parent, "BIT0_ERR irq\n");
367 cf->data[2] |= CAN_ERR_PROT_BIT0; 304 cf->data[2] |= CAN_ERR_PROT_BIT0;
368 tx_errors = 1; 305 tx_errors = 1;
369 } 306 }
370 if (reg_esr & FLEXCAN_ESR_ACK_ERR) { 307 if (reg_esr & FLEXCAN_ESR_ACK_ERR) {
371 netdev_dbg(dev, "ACK_ERR irq\n"); 308 dev_dbg(dev->dev.parent, "ACK_ERR irq\n");
372 cf->can_id |= CAN_ERR_ACK; 309 cf->can_id |= CAN_ERR_ACK;
373 cf->data[3] |= CAN_ERR_PROT_LOC_ACK; 310 cf->data[3] |= CAN_ERR_PROT_LOC_ACK;
374 tx_errors = 1; 311 tx_errors = 1;
375 } 312 }
376 if (reg_esr & FLEXCAN_ESR_CRC_ERR) { 313 if (reg_esr & FLEXCAN_ESR_CRC_ERR) {
377 netdev_dbg(dev, "CRC_ERR irq\n"); 314 dev_dbg(dev->dev.parent, "CRC_ERR irq\n");
378 cf->data[2] |= CAN_ERR_PROT_BIT; 315 cf->data[2] |= CAN_ERR_PROT_BIT;
379 cf->data[3] |= CAN_ERR_PROT_LOC_CRC_SEQ; 316 cf->data[3] |= CAN_ERR_PROT_LOC_CRC_SEQ;
380 rx_errors = 1; 317 rx_errors = 1;
381 } 318 }
382 if (reg_esr & FLEXCAN_ESR_FRM_ERR) { 319 if (reg_esr & FLEXCAN_ESR_FRM_ERR) {
383 netdev_dbg(dev, "FRM_ERR irq\n"); 320 dev_dbg(dev->dev.parent, "FRM_ERR irq\n");
384 cf->data[2] |= CAN_ERR_PROT_FORM; 321 cf->data[2] |= CAN_ERR_PROT_FORM;
385 rx_errors = 1; 322 rx_errors = 1;
386 } 323 }
387 if (reg_esr & FLEXCAN_ESR_STF_ERR) { 324 if (reg_esr & FLEXCAN_ESR_STF_ERR) {
388 netdev_dbg(dev, "STF_ERR irq\n"); 325 dev_dbg(dev->dev.parent, "STF_ERR irq\n");
389 cf->data[2] |= CAN_ERR_PROT_STUFF; 326 cf->data[2] |= CAN_ERR_PROT_STUFF;
390 rx_errors = 1; 327 rx_errors = 1;
391 } 328 }
@@ -432,7 +369,7 @@ static void do_state(struct net_device *dev,
432 */ 369 */
433 if (new_state >= CAN_STATE_ERROR_WARNING && 370 if (new_state >= CAN_STATE_ERROR_WARNING &&
434 new_state <= CAN_STATE_BUS_OFF) { 371 new_state <= CAN_STATE_BUS_OFF) {
435 netdev_dbg(dev, "Error Warning IRQ\n"); 372 dev_dbg(dev->dev.parent, "Error Warning IRQ\n");
436 priv->can.can_stats.error_warning++; 373 priv->can.can_stats.error_warning++;
437 374
438 cf->can_id |= CAN_ERR_CRTL; 375 cf->can_id |= CAN_ERR_CRTL;
@@ -448,7 +385,7 @@ static void do_state(struct net_device *dev,
448 */ 385 */
449 if (new_state >= CAN_STATE_ERROR_PASSIVE && 386 if (new_state >= CAN_STATE_ERROR_PASSIVE &&
450 new_state <= CAN_STATE_BUS_OFF) { 387 new_state <= CAN_STATE_BUS_OFF) {
451 netdev_dbg(dev, "Error Passive IRQ\n"); 388 dev_dbg(dev->dev.parent, "Error Passive IRQ\n");
452 priv->can.can_stats.error_passive++; 389 priv->can.can_stats.error_passive++;
453 390
454 cf->can_id |= CAN_ERR_CRTL; 391 cf->can_id |= CAN_ERR_CRTL;
@@ -458,8 +395,8 @@ static void do_state(struct net_device *dev,
458 } 395 }
459 break; 396 break;
460 case CAN_STATE_BUS_OFF: 397 case CAN_STATE_BUS_OFF:
461 netdev_err(dev, "BUG! " 398 dev_err(dev->dev.parent,
462 "hardware recovered automatically from BUS_OFF\n"); 399 "BUG! hardware recovered automatically from BUS_OFF\n");
463 break; 400 break;
464 default: 401 default:
465 break; 402 break;
@@ -468,7 +405,7 @@ static void do_state(struct net_device *dev,
468 /* process state changes depending on the new state */ 405 /* process state changes depending on the new state */
469 switch (new_state) { 406 switch (new_state) {
470 case CAN_STATE_ERROR_ACTIVE: 407 case CAN_STATE_ERROR_ACTIVE:
471 netdev_dbg(dev, "Error Active\n"); 408 dev_dbg(dev->dev.parent, "Error Active\n");
472 cf->can_id |= CAN_ERR_PROT; 409 cf->can_id |= CAN_ERR_PROT;
473 cf->data[2] = CAN_ERR_PROT_ACTIVE; 410 cf->data[2] = CAN_ERR_PROT_ACTIVE;
474 break; 411 break;
@@ -527,8 +464,8 @@ static void flexcan_read_fifo(const struct net_device *dev,
527 struct flexcan_mb __iomem *mb = &regs->cantxfg[0]; 464 struct flexcan_mb __iomem *mb = &regs->cantxfg[0];
528 u32 reg_ctrl, reg_id; 465 u32 reg_ctrl, reg_id;
529 466
530 reg_ctrl = flexcan_read(&mb->can_ctrl); 467 reg_ctrl = readl(&mb->can_ctrl);
531 reg_id = flexcan_read(&mb->can_id); 468 reg_id = readl(&mb->can_id);
532 if (reg_ctrl & FLEXCAN_MB_CNT_IDE) 469 if (reg_ctrl & FLEXCAN_MB_CNT_IDE)
533 cf->can_id = ((reg_id >> 0) & CAN_EFF_MASK) | CAN_EFF_FLAG; 470 cf->can_id = ((reg_id >> 0) & CAN_EFF_MASK) | CAN_EFF_FLAG;
534 else 471 else
@@ -538,12 +475,12 @@ static void flexcan_read_fifo(const struct net_device *dev,
538 cf->can_id |= CAN_RTR_FLAG; 475 cf->can_id |= CAN_RTR_FLAG;
539 cf->can_dlc = get_can_dlc((reg_ctrl >> 16) & 0xf); 476 cf->can_dlc = get_can_dlc((reg_ctrl >> 16) & 0xf);
540 477
541 *(__be32 *)(cf->data + 0) = cpu_to_be32(flexcan_read(&mb->data[0])); 478 *(__be32 *)(cf->data + 0) = cpu_to_be32(readl(&mb->data[0]));
542 *(__be32 *)(cf->data + 4) = cpu_to_be32(flexcan_read(&mb->data[1])); 479 *(__be32 *)(cf->data + 4) = cpu_to_be32(readl(&mb->data[1]));
543 480
544 /* mark as read */ 481 /* mark as read */
545 flexcan_write(FLEXCAN_IFLAG_RX_FIFO_AVAILABLE, &regs->iflag1); 482 writel(FLEXCAN_IFLAG_RX_FIFO_AVAILABLE, &regs->iflag1);
546 flexcan_read(&regs->timer); 483 readl(&regs->timer);
547} 484}
548 485
549static int flexcan_read_frame(struct net_device *dev) 486static int flexcan_read_frame(struct net_device *dev)
@@ -579,17 +516,17 @@ static int flexcan_poll(struct napi_struct *napi, int quota)
579 * The error bits are cleared on read, 516 * The error bits are cleared on read,
580 * use saved value from irq handler. 517 * use saved value from irq handler.
581 */ 518 */
582 reg_esr = flexcan_read(&regs->esr) | priv->reg_esr; 519 reg_esr = readl(&regs->esr) | priv->reg_esr;
583 520
584 /* handle state changes */ 521 /* handle state changes */
585 work_done += flexcan_poll_state(dev, reg_esr); 522 work_done += flexcan_poll_state(dev, reg_esr);
586 523
587 /* handle RX-FIFO */ 524 /* handle RX-FIFO */
588 reg_iflag1 = flexcan_read(&regs->iflag1); 525 reg_iflag1 = readl(&regs->iflag1);
589 while (reg_iflag1 & FLEXCAN_IFLAG_RX_FIFO_AVAILABLE && 526 while (reg_iflag1 & FLEXCAN_IFLAG_RX_FIFO_AVAILABLE &&
590 work_done < quota) { 527 work_done < quota) {
591 work_done += flexcan_read_frame(dev); 528 work_done += flexcan_read_frame(dev);
592 reg_iflag1 = flexcan_read(&regs->iflag1); 529 reg_iflag1 = readl(&regs->iflag1);
593 } 530 }
594 531
595 /* report bus errors */ 532 /* report bus errors */
@@ -599,8 +536,8 @@ static int flexcan_poll(struct napi_struct *napi, int quota)
599 if (work_done < quota) { 536 if (work_done < quota) {
600 napi_complete(napi); 537 napi_complete(napi);
601 /* enable IRQs */ 538 /* enable IRQs */
602 flexcan_write(FLEXCAN_IFLAG_DEFAULT, &regs->imask1); 539 writel(FLEXCAN_IFLAG_DEFAULT, &regs->imask1);
603 flexcan_write(priv->reg_ctrl_default, &regs->ctrl); 540 writel(priv->reg_ctrl_default, &regs->ctrl);
604 } 541 }
605 542
606 return work_done; 543 return work_done;
@@ -614,11 +551,9 @@ static irqreturn_t flexcan_irq(int irq, void *dev_id)
614 struct flexcan_regs __iomem *regs = priv->base; 551 struct flexcan_regs __iomem *regs = priv->base;
615 u32 reg_iflag1, reg_esr; 552 u32 reg_iflag1, reg_esr;
616 553
617 reg_iflag1 = flexcan_read(&regs->iflag1); 554 reg_iflag1 = readl(&regs->iflag1);
618 reg_esr = flexcan_read(&regs->esr); 555 reg_esr = readl(&regs->esr);
619 /* ACK all bus error and state change IRQ sources */ 556 writel(FLEXCAN_ESR_ERR_INT, &regs->esr); /* ACK err IRQ */
620 if (reg_esr & FLEXCAN_ESR_ALL_INT)
621 flexcan_write(reg_esr & FLEXCAN_ESR_ALL_INT, &regs->esr);
622 557
623 /* 558 /*
624 * schedule NAPI in case of: 559 * schedule NAPI in case of:
@@ -634,25 +569,25 @@ static irqreturn_t flexcan_irq(int irq, void *dev_id)
634 * save them for later use. 569 * save them for later use.
635 */ 570 */
636 priv->reg_esr = reg_esr & FLEXCAN_ESR_ERR_BUS; 571 priv->reg_esr = reg_esr & FLEXCAN_ESR_ERR_BUS;
637 flexcan_write(FLEXCAN_IFLAG_DEFAULT & 572 writel(FLEXCAN_IFLAG_DEFAULT & ~FLEXCAN_IFLAG_RX_FIFO_AVAILABLE,
638 ~FLEXCAN_IFLAG_RX_FIFO_AVAILABLE, &regs->imask1); 573 &regs->imask1);
639 flexcan_write(priv->reg_ctrl_default & ~FLEXCAN_CTRL_ERR_ALL, 574 writel(priv->reg_ctrl_default & ~FLEXCAN_CTRL_ERR_ALL,
640 &regs->ctrl); 575 &regs->ctrl);
641 napi_schedule(&priv->napi); 576 napi_schedule(&priv->napi);
642 } 577 }
643 578
644 /* FIFO overflow */ 579 /* FIFO overflow */
645 if (reg_iflag1 & FLEXCAN_IFLAG_RX_FIFO_OVERFLOW) { 580 if (reg_iflag1 & FLEXCAN_IFLAG_RX_FIFO_OVERFLOW) {
646 flexcan_write(FLEXCAN_IFLAG_RX_FIFO_OVERFLOW, &regs->iflag1); 581 writel(FLEXCAN_IFLAG_RX_FIFO_OVERFLOW, &regs->iflag1);
647 dev->stats.rx_over_errors++; 582 dev->stats.rx_over_errors++;
648 dev->stats.rx_errors++; 583 dev->stats.rx_errors++;
649 } 584 }
650 585
651 /* transmission complete interrupt */ 586 /* transmission complete interrupt */
652 if (reg_iflag1 & (1 << FLEXCAN_TX_BUF_ID)) { 587 if (reg_iflag1 & (1 << FLEXCAN_TX_BUF_ID)) {
653 stats->tx_bytes += can_get_echo_skb(dev, 0); 588 /* tx_bytes is incremented in flexcan_start_xmit */
654 stats->tx_packets++; 589 stats->tx_packets++;
655 flexcan_write((1 << FLEXCAN_TX_BUF_ID), &regs->iflag1); 590 writel((1 << FLEXCAN_TX_BUF_ID), &regs->iflag1);
656 netif_wake_queue(dev); 591 netif_wake_queue(dev);
657 } 592 }
658 593
@@ -666,7 +601,7 @@ static void flexcan_set_bittiming(struct net_device *dev)
666 struct flexcan_regs __iomem *regs = priv->base; 601 struct flexcan_regs __iomem *regs = priv->base;
667 u32 reg; 602 u32 reg;
668 603
669 reg = flexcan_read(&regs->ctrl); 604 reg = readl(&regs->ctrl);
670 reg &= ~(FLEXCAN_CTRL_PRESDIV(0xff) | 605 reg &= ~(FLEXCAN_CTRL_PRESDIV(0xff) |
671 FLEXCAN_CTRL_RJW(0x3) | 606 FLEXCAN_CTRL_RJW(0x3) |
672 FLEXCAN_CTRL_PSEG1(0x7) | 607 FLEXCAN_CTRL_PSEG1(0x7) |
@@ -689,12 +624,12 @@ static void flexcan_set_bittiming(struct net_device *dev)
689 if (priv->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES) 624 if (priv->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES)
690 reg |= FLEXCAN_CTRL_SMP; 625 reg |= FLEXCAN_CTRL_SMP;
691 626
692 netdev_info(dev, "writing ctrl=0x%08x\n", reg); 627 dev_info(dev->dev.parent, "writing ctrl=0x%08x\n", reg);
693 flexcan_write(reg, &regs->ctrl); 628 writel(reg, &regs->ctrl);
694 629
695 /* print chip status */ 630 /* print chip status */
696 netdev_dbg(dev, "%s: mcr=0x%08x ctrl=0x%08x\n", __func__, 631 dev_dbg(dev->dev.parent, "%s: mcr=0x%08x ctrl=0x%08x\n", __func__,
697 flexcan_read(&regs->mcr), flexcan_read(&regs->ctrl)); 632 readl(&regs->mcr), readl(&regs->ctrl));
698} 633}
699 634
700/* 635/*
@@ -715,13 +650,14 @@ static int flexcan_chip_start(struct net_device *dev)
715 flexcan_chip_enable(priv); 650 flexcan_chip_enable(priv);
716 651
717 /* soft reset */ 652 /* soft reset */
718 flexcan_write(FLEXCAN_MCR_SOFTRST, &regs->mcr); 653 writel(FLEXCAN_MCR_SOFTRST, &regs->mcr);
719 udelay(10); 654 udelay(10);
720 655
721 reg_mcr = flexcan_read(&regs->mcr); 656 reg_mcr = readl(&regs->mcr);
722 if (reg_mcr & FLEXCAN_MCR_SOFTRST) { 657 if (reg_mcr & FLEXCAN_MCR_SOFTRST) {
723 netdev_err(dev, "Failed to softreset can module (mcr=0x%08x)\n", 658 dev_err(dev->dev.parent,
724 reg_mcr); 659 "Failed to softreset can module (mcr=0x%08x)\n",
660 reg_mcr);
725 err = -ENODEV; 661 err = -ENODEV;
726 goto out; 662 goto out;
727 } 663 }
@@ -737,15 +673,14 @@ static int flexcan_chip_start(struct net_device *dev)
737 * only supervisor access 673 * only supervisor access
738 * enable warning int 674 * enable warning int
739 * choose format C 675 * choose format C
740 * disable local echo
741 * 676 *
742 */ 677 */
743 reg_mcr = flexcan_read(&regs->mcr); 678 reg_mcr = readl(&regs->mcr);
744 reg_mcr |= FLEXCAN_MCR_FRZ | FLEXCAN_MCR_FEN | FLEXCAN_MCR_HALT | 679 reg_mcr |= FLEXCAN_MCR_FRZ | FLEXCAN_MCR_FEN | FLEXCAN_MCR_HALT |
745 FLEXCAN_MCR_SUPV | FLEXCAN_MCR_WRN_EN | 680 FLEXCAN_MCR_SUPV | FLEXCAN_MCR_WRN_EN |
746 FLEXCAN_MCR_IDAM_C | FLEXCAN_MCR_SRX_DIS; 681 FLEXCAN_MCR_IDAM_C;
747 netdev_dbg(dev, "%s: writing mcr=0x%08x", __func__, reg_mcr); 682 dev_dbg(dev->dev.parent, "%s: writing mcr=0x%08x", __func__, reg_mcr);
748 flexcan_write(reg_mcr, &regs->mcr); 683 writel(reg_mcr, &regs->mcr);
749 684
750 /* 685 /*
751 * CTRL 686 * CTRL
@@ -758,59 +693,51 @@ static int flexcan_chip_start(struct net_device *dev)
758 * enable tx and rx warning interrupt 693 * enable tx and rx warning interrupt
759 * enable bus off interrupt 694 * enable bus off interrupt
760 * (== FLEXCAN_CTRL_ERR_STATE) 695 * (== FLEXCAN_CTRL_ERR_STATE)
696 *
697 * _note_: we enable the "error interrupt"
698 * (FLEXCAN_CTRL_ERR_MSK), too. Otherwise we don't get any
699 * warning or bus passive interrupts.
761 */ 700 */
762 reg_ctrl = flexcan_read(&regs->ctrl); 701 reg_ctrl = readl(&regs->ctrl);
763 reg_ctrl &= ~FLEXCAN_CTRL_TSYN; 702 reg_ctrl &= ~FLEXCAN_CTRL_TSYN;
764 reg_ctrl |= FLEXCAN_CTRL_BOFF_REC | FLEXCAN_CTRL_LBUF | 703 reg_ctrl |= FLEXCAN_CTRL_BOFF_REC | FLEXCAN_CTRL_LBUF |
765 FLEXCAN_CTRL_ERR_STATE; 704 FLEXCAN_CTRL_ERR_STATE | FLEXCAN_CTRL_ERR_MSK;
766 /*
767 * enable the "error interrupt" (FLEXCAN_CTRL_ERR_MSK),
768 * on most Flexcan cores, too. Otherwise we don't get
769 * any error warning or passive interrupts.
770 */
771 if (priv->devtype_data->features & FLEXCAN_HAS_BROKEN_ERR_STATE ||
772 priv->can.ctrlmode & CAN_CTRLMODE_BERR_REPORTING)
773 reg_ctrl |= FLEXCAN_CTRL_ERR_MSK;
774 705
775 /* save for later use */ 706 /* save for later use */
776 priv->reg_ctrl_default = reg_ctrl; 707 priv->reg_ctrl_default = reg_ctrl;
777 netdev_dbg(dev, "%s: writing ctrl=0x%08x", __func__, reg_ctrl); 708 dev_dbg(dev->dev.parent, "%s: writing ctrl=0x%08x", __func__, reg_ctrl);
778 flexcan_write(reg_ctrl, &regs->ctrl); 709 writel(reg_ctrl, &regs->ctrl);
779 710
780 for (i = 0; i < ARRAY_SIZE(regs->cantxfg); i++) { 711 for (i = 0; i < ARRAY_SIZE(regs->cantxfg); i++) {
781 flexcan_write(0, &regs->cantxfg[i].can_ctrl); 712 writel(0, &regs->cantxfg[i].can_ctrl);
782 flexcan_write(0, &regs->cantxfg[i].can_id); 713 writel(0, &regs->cantxfg[i].can_id);
783 flexcan_write(0, &regs->cantxfg[i].data[0]); 714 writel(0, &regs->cantxfg[i].data[0]);
784 flexcan_write(0, &regs->cantxfg[i].data[1]); 715 writel(0, &regs->cantxfg[i].data[1]);
785 716
786 /* put MB into rx queue */ 717 /* put MB into rx queue */
787 flexcan_write(FLEXCAN_MB_CNT_CODE(0x4), 718 writel(FLEXCAN_MB_CNT_CODE(0x4), &regs->cantxfg[i].can_ctrl);
788 &regs->cantxfg[i].can_ctrl);
789 } 719 }
790 720
791 /* acceptance mask/acceptance code (accept everything) */ 721 /* acceptance mask/acceptance code (accept everything) */
792 flexcan_write(0x0, &regs->rxgmask); 722 writel(0x0, &regs->rxgmask);
793 flexcan_write(0x0, &regs->rx14mask); 723 writel(0x0, &regs->rx14mask);
794 flexcan_write(0x0, &regs->rx15mask); 724 writel(0x0, &regs->rx15mask);
795
796 if (priv->devtype_data->features & FLEXCAN_HAS_V10_FEATURES)
797 flexcan_write(0x0, &regs->rxfgmask);
798 725
799 flexcan_transceiver_switch(priv, 1); 726 flexcan_transceiver_switch(priv, 1);
800 727
801 /* synchronize with the can bus */ 728 /* synchronize with the can bus */
802 reg_mcr = flexcan_read(&regs->mcr); 729 reg_mcr = readl(&regs->mcr);
803 reg_mcr &= ~FLEXCAN_MCR_HALT; 730 reg_mcr &= ~FLEXCAN_MCR_HALT;
804 flexcan_write(reg_mcr, &regs->mcr); 731 writel(reg_mcr, &regs->mcr);
805 732
806 priv->can.state = CAN_STATE_ERROR_ACTIVE; 733 priv->can.state = CAN_STATE_ERROR_ACTIVE;
807 734
808 /* enable FIFO interrupts */ 735 /* enable FIFO interrupts */
809 flexcan_write(FLEXCAN_IFLAG_DEFAULT, &regs->imask1); 736 writel(FLEXCAN_IFLAG_DEFAULT, &regs->imask1);
810 737
811 /* print chip status */ 738 /* print chip status */
812 netdev_dbg(dev, "%s: reading mcr=0x%08x ctrl=0x%08x\n", __func__, 739 dev_dbg(dev->dev.parent, "%s: reading mcr=0x%08x ctrl=0x%08x\n",
813 flexcan_read(&regs->mcr), flexcan_read(&regs->ctrl)); 740 __func__, readl(&regs->mcr), readl(&regs->ctrl));
814 741
815 return 0; 742 return 0;
816 743
@@ -832,12 +759,12 @@ static void flexcan_chip_stop(struct net_device *dev)
832 u32 reg; 759 u32 reg;
833 760
834 /* Disable all interrupts */ 761 /* Disable all interrupts */
835 flexcan_write(0, &regs->imask1); 762 writel(0, &regs->imask1);
836 763
837 /* Disable + halt module */ 764 /* Disable + halt module */
838 reg = flexcan_read(&regs->mcr); 765 reg = readl(&regs->mcr);
839 reg |= FLEXCAN_MCR_MDIS | FLEXCAN_MCR_HALT; 766 reg |= FLEXCAN_MCR_MDIS | FLEXCAN_MCR_HALT;
840 flexcan_write(reg, &regs->mcr); 767 writel(reg, &regs->mcr);
841 768
842 flexcan_transceiver_switch(priv, 0); 769 flexcan_transceiver_switch(priv, 0);
843 priv->can.state = CAN_STATE_STOPPED; 770 priv->can.state = CAN_STATE_STOPPED;
@@ -850,8 +777,7 @@ static int flexcan_open(struct net_device *dev)
850 struct flexcan_priv *priv = netdev_priv(dev); 777 struct flexcan_priv *priv = netdev_priv(dev);
851 int err; 778 int err;
852 779
853 clk_prepare_enable(priv->clk_ipg); 780 clk_enable(priv->clk);
854 clk_prepare_enable(priv->clk_per);
855 781
856 err = open_candev(dev); 782 err = open_candev(dev);
857 if (err) 783 if (err)
@@ -873,8 +799,7 @@ static int flexcan_open(struct net_device *dev)
873 out_close: 799 out_close:
874 close_candev(dev); 800 close_candev(dev);
875 out: 801 out:
876 clk_disable_unprepare(priv->clk_per); 802 clk_disable(priv->clk);
877 clk_disable_unprepare(priv->clk_ipg);
878 803
879 return err; 804 return err;
880} 805}
@@ -888,8 +813,7 @@ static int flexcan_close(struct net_device *dev)
888 flexcan_chip_stop(dev); 813 flexcan_chip_stop(dev);
889 814
890 free_irq(dev->irq, dev); 815 free_irq(dev->irq, dev);
891 clk_disable_unprepare(priv->clk_per); 816 clk_disable(priv->clk);
892 clk_disable_unprepare(priv->clk_ipg);
893 817
894 close_candev(dev); 818 close_candev(dev);
895 819
@@ -922,37 +846,37 @@ static const struct net_device_ops flexcan_netdev_ops = {
922 .ndo_start_xmit = flexcan_start_xmit, 846 .ndo_start_xmit = flexcan_start_xmit,
923}; 847};
924 848
925static int register_flexcandev(struct net_device *dev) 849static int __devinit register_flexcandev(struct net_device *dev)
926{ 850{
927 struct flexcan_priv *priv = netdev_priv(dev); 851 struct flexcan_priv *priv = netdev_priv(dev);
928 struct flexcan_regs __iomem *regs = priv->base; 852 struct flexcan_regs __iomem *regs = priv->base;
929 u32 reg, err; 853 u32 reg, err;
930 854
931 clk_prepare_enable(priv->clk_ipg); 855 clk_enable(priv->clk);
932 clk_prepare_enable(priv->clk_per);
933 856
934 /* select "bus clock", chip must be disabled */ 857 /* select "bus clock", chip must be disabled */
935 flexcan_chip_disable(priv); 858 flexcan_chip_disable(priv);
936 reg = flexcan_read(&regs->ctrl); 859 reg = readl(&regs->ctrl);
937 reg |= FLEXCAN_CTRL_CLK_SRC; 860 reg |= FLEXCAN_CTRL_CLK_SRC;
938 flexcan_write(reg, &regs->ctrl); 861 writel(reg, &regs->ctrl);
939 862
940 flexcan_chip_enable(priv); 863 flexcan_chip_enable(priv);
941 864
942 /* set freeze, halt and activate FIFO, restrict register access */ 865 /* set freeze, halt and activate FIFO, restrict register access */
943 reg = flexcan_read(&regs->mcr); 866 reg = readl(&regs->mcr);
944 reg |= FLEXCAN_MCR_FRZ | FLEXCAN_MCR_HALT | 867 reg |= FLEXCAN_MCR_FRZ | FLEXCAN_MCR_HALT |
945 FLEXCAN_MCR_FEN | FLEXCAN_MCR_SUPV; 868 FLEXCAN_MCR_FEN | FLEXCAN_MCR_SUPV;
946 flexcan_write(reg, &regs->mcr); 869 writel(reg, &regs->mcr);
947 870
948 /* 871 /*
949 * Currently we only support newer versions of this core 872 * Currently we only support newer versions of this core
950 * featuring a RX FIFO. Older cores found on some Coldfire 873 * featuring a RX FIFO. Older cores found on some Coldfire
951 * derivates are not yet supported. 874 * derivates are not yet supported.
952 */ 875 */
953 reg = flexcan_read(&regs->mcr); 876 reg = readl(&regs->mcr);
954 if (!(reg & FLEXCAN_MCR_FEN)) { 877 if (!(reg & FLEXCAN_MCR_FEN)) {
955 netdev_err(dev, "Could not enable RX FIFO, unsupported core\n"); 878 dev_err(dev->dev.parent,
879 "Could not enable RX FIFO, unsupported core\n");
956 err = -ENODEV; 880 err = -ENODEV;
957 goto out; 881 goto out;
958 } 882 }
@@ -962,68 +886,31 @@ static int register_flexcandev(struct net_device *dev)
962 out: 886 out:
963 /* disable core and turn off clocks */ 887 /* disable core and turn off clocks */
964 flexcan_chip_disable(priv); 888 flexcan_chip_disable(priv);
965 clk_disable_unprepare(priv->clk_per); 889 clk_disable(priv->clk);
966 clk_disable_unprepare(priv->clk_ipg);
967 890
968 return err; 891 return err;
969} 892}
970 893
971static void unregister_flexcandev(struct net_device *dev) 894static void __devexit unregister_flexcandev(struct net_device *dev)
972{ 895{
973 unregister_candev(dev); 896 unregister_candev(dev);
974} 897}
975 898
976static const struct of_device_id flexcan_of_match[] = { 899static int __devinit flexcan_probe(struct platform_device *pdev)
977 { .compatible = "fsl,p1010-flexcan", .data = &fsl_p1010_devtype_data, },
978 { .compatible = "fsl,imx28-flexcan", .data = &fsl_imx28_devtype_data, },
979 { .compatible = "fsl,imx6q-flexcan", .data = &fsl_imx6q_devtype_data, },
980 { /* sentinel */ },
981};
982MODULE_DEVICE_TABLE(of, flexcan_of_match);
983
984static const struct platform_device_id flexcan_id_table[] = {
985 { .name = "flexcan", .driver_data = (kernel_ulong_t)&fsl_p1010_devtype_data, },
986 { /* sentinel */ },
987};
988MODULE_DEVICE_TABLE(platform, flexcan_id_table);
989
990static int flexcan_probe(struct platform_device *pdev)
991{ 900{
992 const struct of_device_id *of_id;
993 const struct flexcan_devtype_data *devtype_data;
994 struct net_device *dev; 901 struct net_device *dev;
995 struct flexcan_priv *priv; 902 struct flexcan_priv *priv;
996 struct resource *mem; 903 struct resource *mem;
997 struct clk *clk_ipg = NULL, *clk_per = NULL; 904 struct clk *clk;
998 struct pinctrl *pinctrl;
999 void __iomem *base; 905 void __iomem *base;
1000 resource_size_t mem_size; 906 resource_size_t mem_size;
1001 int err, irq; 907 int err, irq;
1002 u32 clock_freq = 0;
1003
1004 pinctrl = devm_pinctrl_get_select_default(&pdev->dev);
1005 if (IS_ERR(pinctrl))
1006 return PTR_ERR(pinctrl);
1007
1008 if (pdev->dev.of_node)
1009 of_property_read_u32(pdev->dev.of_node,
1010 "clock-frequency", &clock_freq);
1011
1012 if (!clock_freq) {
1013 clk_ipg = devm_clk_get(&pdev->dev, "ipg");
1014 if (IS_ERR(clk_ipg)) {
1015 dev_err(&pdev->dev, "no ipg clock defined\n");
1016 err = PTR_ERR(clk_ipg);
1017 goto failed_clock;
1018 }
1019 clock_freq = clk_get_rate(clk_ipg);
1020 908
1021 clk_per = devm_clk_get(&pdev->dev, "per"); 909 clk = clk_get(&pdev->dev, NULL);
1022 if (IS_ERR(clk_per)) { 910 if (IS_ERR(clk)) {
1023 dev_err(&pdev->dev, "no per clock defined\n"); 911 dev_err(&pdev->dev, "no clock defined\n");
1024 err = PTR_ERR(clk_per); 912 err = PTR_ERR(clk);
1025 goto failed_clock; 913 goto failed_clock;
1026 }
1027 } 914 }
1028 915
1029 mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); 916 mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
@@ -1045,29 +932,18 @@ static int flexcan_probe(struct platform_device *pdev)
1045 goto failed_map; 932 goto failed_map;
1046 } 933 }
1047 934
1048 dev = alloc_candev(sizeof(struct flexcan_priv), 1); 935 dev = alloc_candev(sizeof(struct flexcan_priv), 0);
1049 if (!dev) { 936 if (!dev) {
1050 err = -ENOMEM; 937 err = -ENOMEM;
1051 goto failed_alloc; 938 goto failed_alloc;
1052 } 939 }
1053 940
1054 of_id = of_match_device(flexcan_of_match, &pdev->dev);
1055 if (of_id) {
1056 devtype_data = of_id->data;
1057 } else if (pdev->id_entry->driver_data) {
1058 devtype_data = (struct flexcan_devtype_data *)
1059 pdev->id_entry->driver_data;
1060 } else {
1061 err = -ENODEV;
1062 goto failed_devtype;
1063 }
1064
1065 dev->netdev_ops = &flexcan_netdev_ops; 941 dev->netdev_ops = &flexcan_netdev_ops;
1066 dev->irq = irq; 942 dev->irq = irq;
1067 dev->flags |= IFF_ECHO; 943 dev->flags |= IFF_ECHO; /* we support local echo in hardware */
1068 944
1069 priv = netdev_priv(dev); 945 priv = netdev_priv(dev);
1070 priv->can.clock.freq = clock_freq; 946 priv->can.clock.freq = clk_get_rate(clk);
1071 priv->can.bittiming_const = &flexcan_bittiming_const; 947 priv->can.bittiming_const = &flexcan_bittiming_const;
1072 priv->can.do_set_mode = flexcan_set_mode; 948 priv->can.do_set_mode = flexcan_set_mode;
1073 priv->can.do_get_berr_counter = flexcan_get_berr_counter; 949 priv->can.do_get_berr_counter = flexcan_get_berr_counter;
@@ -1076,10 +952,8 @@ static int flexcan_probe(struct platform_device *pdev)
1076 CAN_CTRLMODE_BERR_REPORTING; 952 CAN_CTRLMODE_BERR_REPORTING;
1077 priv->base = base; 953 priv->base = base;
1078 priv->dev = dev; 954 priv->dev = dev;
1079 priv->clk_ipg = clk_ipg; 955 priv->clk = clk;
1080 priv->clk_per = clk_per;
1081 priv->pdata = pdev->dev.platform_data; 956 priv->pdata = pdev->dev.platform_data;
1082 priv->devtype_data = devtype_data;
1083 957
1084 netif_napi_add(dev, &priv->napi, flexcan_poll, FLEXCAN_NAPI_WEIGHT); 958 netif_napi_add(dev, &priv->napi, flexcan_poll, FLEXCAN_NAPI_WEIGHT);
1085 959
@@ -1098,18 +972,18 @@ static int flexcan_probe(struct platform_device *pdev)
1098 return 0; 972 return 0;
1099 973
1100 failed_register: 974 failed_register:
1101 failed_devtype:
1102 free_candev(dev); 975 free_candev(dev);
1103 failed_alloc: 976 failed_alloc:
1104 iounmap(base); 977 iounmap(base);
1105 failed_map: 978 failed_map:
1106 release_mem_region(mem->start, mem_size); 979 release_mem_region(mem->start, mem_size);
1107 failed_get: 980 failed_get:
981 clk_put(clk);
1108 failed_clock: 982 failed_clock:
1109 return err; 983 return err;
1110} 984}
1111 985
1112static int flexcan_remove(struct platform_device *pdev) 986static int __devexit flexcan_remove(struct platform_device *pdev)
1113{ 987{
1114 struct net_device *dev = platform_get_drvdata(pdev); 988 struct net_device *dev = platform_get_drvdata(pdev);
1115 struct flexcan_priv *priv = netdev_priv(dev); 989 struct flexcan_priv *priv = netdev_priv(dev);
@@ -1122,61 +996,33 @@ static int flexcan_remove(struct platform_device *pdev)
1122 mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); 996 mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1123 release_mem_region(mem->start, resource_size(mem)); 997 release_mem_region(mem->start, resource_size(mem));
1124 998
999 clk_put(priv->clk);
1000
1125 free_candev(dev); 1001 free_candev(dev);
1126 1002
1127 return 0; 1003 return 0;
1128} 1004}
1129 1005
1130#ifdef CONFIG_PM 1006static struct platform_driver flexcan_driver = {
1131static int flexcan_suspend(struct platform_device *pdev, pm_message_t state) 1007 .driver.name = DRV_NAME,
1132{ 1008 .probe = flexcan_probe,
1133 struct net_device *dev = platform_get_drvdata(pdev); 1009 .remove = __devexit_p(flexcan_remove),
1134 struct flexcan_priv *priv = netdev_priv(dev); 1010};
1135
1136 flexcan_chip_disable(priv);
1137
1138 if (netif_running(dev)) {
1139 netif_stop_queue(dev);
1140 netif_device_detach(dev);
1141 }
1142 priv->can.state = CAN_STATE_SLEEPING;
1143 1011
1144 return 0; 1012static int __init flexcan_init(void)
1013{
1014 pr_info("%s netdevice driver\n", DRV_NAME);
1015 return platform_driver_register(&flexcan_driver);
1145} 1016}
1146 1017
1147static int flexcan_resume(struct platform_device *pdev) 1018static void __exit flexcan_exit(void)
1148{ 1019{
1149 struct net_device *dev = platform_get_drvdata(pdev); 1020 platform_driver_unregister(&flexcan_driver);
1150 struct flexcan_priv *priv = netdev_priv(dev); 1021 pr_info("%s: driver removed\n", DRV_NAME);
1151
1152 priv->can.state = CAN_STATE_ERROR_ACTIVE;
1153 if (netif_running(dev)) {
1154 netif_device_attach(dev);
1155 netif_start_queue(dev);
1156 }
1157 flexcan_chip_enable(priv);
1158
1159 return 0;
1160} 1022}
1161#else
1162#define flexcan_suspend NULL
1163#define flexcan_resume NULL
1164#endif
1165
1166static struct platform_driver flexcan_driver = {
1167 .driver = {
1168 .name = DRV_NAME,
1169 .owner = THIS_MODULE,
1170 .of_match_table = flexcan_of_match,
1171 },
1172 .probe = flexcan_probe,
1173 .remove = flexcan_remove,
1174 .suspend = flexcan_suspend,
1175 .resume = flexcan_resume,
1176 .id_table = flexcan_id_table,
1177};
1178 1023
1179module_platform_driver(flexcan_driver); 1024module_init(flexcan_init);
1025module_exit(flexcan_exit);
1180 1026
1181MODULE_AUTHOR("Sascha Hauer <kernel@pengutronix.de>, " 1027MODULE_AUTHOR("Sascha Hauer <kernel@pengutronix.de>, "
1182 "Marc Kleine-Budde <kernel@pengutronix.de>"); 1028 "Marc Kleine-Budde <kernel@pengutronix.de>");
diff --git a/drivers/net/can/grcan.c b/drivers/net/can/grcan.c
deleted file mode 100644
index 17fbc7a0922..00000000000
--- a/drivers/net/can/grcan.c
+++ /dev/null
@@ -1,1756 +0,0 @@
1/*
2 * Socket CAN driver for Aeroflex Gaisler GRCAN and GRHCAN.
3 *
4 * 2012 (c) Aeroflex Gaisler AB
5 *
6 * This driver supports GRCAN and GRHCAN CAN controllers available in the GRLIB
7 * VHDL IP core library.
8 *
9 * Full documentation of the GRCAN core can be found here:
10 * http://www.gaisler.com/products/grlib/grip.pdf
11 *
12 * See "Documentation/devicetree/bindings/net/can/grcan.txt" for information on
13 * open firmware properties.
14 *
15 * See "Documentation/ABI/testing/sysfs-class-net-grcan" for information on the
16 * sysfs interface.
17 *
18 * See "Documentation/kernel-parameters.txt" for information on the module
19 * parameters.
20 *
21 * This program is free software; you can redistribute it and/or modify it
22 * under the terms of the GNU General Public License as published by the
23 * Free Software Foundation; either version 2 of the License, or (at your
24 * option) any later version.
25 *
26 * Contributors: Andreas Larsson <andreas@gaisler.com>
27 */
28
29#include <linux/kernel.h>
30#include <linux/module.h>
31#include <linux/interrupt.h>
32#include <linux/netdevice.h>
33#include <linux/delay.h>
34#include <linux/io.h>
35#include <linux/can/dev.h>
36#include <linux/spinlock.h>
37
38#include <linux/of_platform.h>
39#include <asm/prom.h>
40
41#include <linux/of_irq.h>
42
43#include <linux/dma-mapping.h>
44
45#define DRV_NAME "grcan"
46
47#define GRCAN_NAPI_WEIGHT 32
48
49#define GRCAN_RESERVE_SIZE(slot1, slot2) (((slot2) - (slot1)) / 4 - 1)
50
51struct grcan_registers {
52 u32 conf; /* 0x00 */
53 u32 stat; /* 0x04 */
54 u32 ctrl; /* 0x08 */
55 u32 __reserved1[GRCAN_RESERVE_SIZE(0x08, 0x18)];
56 u32 smask; /* 0x18 - CanMASK */
57 u32 scode; /* 0x1c - CanCODE */
58 u32 __reserved2[GRCAN_RESERVE_SIZE(0x1c, 0x100)];
59 u32 pimsr; /* 0x100 */
60 u32 pimr; /* 0x104 */
61 u32 pisr; /* 0x108 */
62 u32 pir; /* 0x10C */
63 u32 imr; /* 0x110 */
64 u32 picr; /* 0x114 */
65 u32 __reserved3[GRCAN_RESERVE_SIZE(0x114, 0x200)];
66 u32 txctrl; /* 0x200 */
67 u32 txaddr; /* 0x204 */
68 u32 txsize; /* 0x208 */
69 u32 txwr; /* 0x20C */
70 u32 txrd; /* 0x210 */
71 u32 txirq; /* 0x214 */
72 u32 __reserved4[GRCAN_RESERVE_SIZE(0x214, 0x300)];
73 u32 rxctrl; /* 0x300 */
74 u32 rxaddr; /* 0x304 */
75 u32 rxsize; /* 0x308 */
76 u32 rxwr; /* 0x30C */
77 u32 rxrd; /* 0x310 */
78 u32 rxirq; /* 0x314 */
79 u32 rxmask; /* 0x318 */
80 u32 rxcode; /* 0x31C */
81};
82
83#define GRCAN_CONF_ABORT 0x00000001
84#define GRCAN_CONF_ENABLE0 0x00000002
85#define GRCAN_CONF_ENABLE1 0x00000004
86#define GRCAN_CONF_SELECT 0x00000008
87#define GRCAN_CONF_SILENT 0x00000010
88#define GRCAN_CONF_SAM 0x00000020 /* Available in some hardware */
89#define GRCAN_CONF_BPR 0x00000300 /* Note: not BRP */
90#define GRCAN_CONF_RSJ 0x00007000
91#define GRCAN_CONF_PS1 0x00f00000
92#define GRCAN_CONF_PS2 0x000f0000
93#define GRCAN_CONF_SCALER 0xff000000
94#define GRCAN_CONF_OPERATION \
95 (GRCAN_CONF_ABORT | GRCAN_CONF_ENABLE0 | GRCAN_CONF_ENABLE1 \
96 | GRCAN_CONF_SELECT | GRCAN_CONF_SILENT | GRCAN_CONF_SAM)
97#define GRCAN_CONF_TIMING \
98 (GRCAN_CONF_BPR | GRCAN_CONF_RSJ | GRCAN_CONF_PS1 \
99 | GRCAN_CONF_PS2 | GRCAN_CONF_SCALER)
100
101#define GRCAN_CONF_RSJ_MIN 1
102#define GRCAN_CONF_RSJ_MAX 4
103#define GRCAN_CONF_PS1_MIN 1
104#define GRCAN_CONF_PS1_MAX 15
105#define GRCAN_CONF_PS2_MIN 2
106#define GRCAN_CONF_PS2_MAX 8
107#define GRCAN_CONF_SCALER_MIN 0
108#define GRCAN_CONF_SCALER_MAX 255
109#define GRCAN_CONF_SCALER_INC 1
110
111#define GRCAN_CONF_BPR_BIT 8
112#define GRCAN_CONF_RSJ_BIT 12
113#define GRCAN_CONF_PS1_BIT 20
114#define GRCAN_CONF_PS2_BIT 16
115#define GRCAN_CONF_SCALER_BIT 24
116
117#define GRCAN_STAT_PASS 0x000001
118#define GRCAN_STAT_OFF 0x000002
119#define GRCAN_STAT_OR 0x000004
120#define GRCAN_STAT_AHBERR 0x000008
121#define GRCAN_STAT_ACTIVE 0x000010
122#define GRCAN_STAT_RXERRCNT 0x00ff00
123#define GRCAN_STAT_TXERRCNT 0xff0000
124
125#define GRCAN_STAT_ERRCTR_RELATED (GRCAN_STAT_PASS | GRCAN_STAT_OFF)
126
127#define GRCAN_STAT_RXERRCNT_BIT 8
128#define GRCAN_STAT_TXERRCNT_BIT 16
129
130#define GRCAN_STAT_ERRCNT_WARNING_LIMIT 96
131#define GRCAN_STAT_ERRCNT_PASSIVE_LIMIT 127
132
133#define GRCAN_CTRL_RESET 0x2
134#define GRCAN_CTRL_ENABLE 0x1
135
136#define GRCAN_TXCTRL_ENABLE 0x1
137#define GRCAN_TXCTRL_ONGOING 0x2
138#define GRCAN_TXCTRL_SINGLE 0x4
139
140#define GRCAN_RXCTRL_ENABLE 0x1
141#define GRCAN_RXCTRL_ONGOING 0x2
142
143/* Relative offset of IRQ sources to AMBA Plug&Play */
144#define GRCAN_IRQIX_IRQ 0
145#define GRCAN_IRQIX_TXSYNC 1
146#define GRCAN_IRQIX_RXSYNC 2
147
148#define GRCAN_IRQ_PASS 0x00001
149#define GRCAN_IRQ_OFF 0x00002
150#define GRCAN_IRQ_OR 0x00004
151#define GRCAN_IRQ_RXAHBERR 0x00008
152#define GRCAN_IRQ_TXAHBERR 0x00010
153#define GRCAN_IRQ_RXIRQ 0x00020
154#define GRCAN_IRQ_TXIRQ 0x00040
155#define GRCAN_IRQ_RXFULL 0x00080
156#define GRCAN_IRQ_TXEMPTY 0x00100
157#define GRCAN_IRQ_RX 0x00200
158#define GRCAN_IRQ_TX 0x00400
159#define GRCAN_IRQ_RXSYNC 0x00800
160#define GRCAN_IRQ_TXSYNC 0x01000
161#define GRCAN_IRQ_RXERRCTR 0x02000
162#define GRCAN_IRQ_TXERRCTR 0x04000
163#define GRCAN_IRQ_RXMISS 0x08000
164#define GRCAN_IRQ_TXLOSS 0x10000
165
166#define GRCAN_IRQ_NONE 0
167#define GRCAN_IRQ_ALL \
168 (GRCAN_IRQ_PASS | GRCAN_IRQ_OFF | GRCAN_IRQ_OR \
169 | GRCAN_IRQ_RXAHBERR | GRCAN_IRQ_TXAHBERR \
170 | GRCAN_IRQ_RXIRQ | GRCAN_IRQ_TXIRQ \
171 | GRCAN_IRQ_RXFULL | GRCAN_IRQ_TXEMPTY \
172 | GRCAN_IRQ_RX | GRCAN_IRQ_TX | GRCAN_IRQ_RXSYNC \
173 | GRCAN_IRQ_TXSYNC | GRCAN_IRQ_RXERRCTR \
174 | GRCAN_IRQ_TXERRCTR | GRCAN_IRQ_RXMISS \
175 | GRCAN_IRQ_TXLOSS)
176
177#define GRCAN_IRQ_ERRCTR_RELATED (GRCAN_IRQ_RXERRCTR | GRCAN_IRQ_TXERRCTR \
178 | GRCAN_IRQ_PASS | GRCAN_IRQ_OFF)
179#define GRCAN_IRQ_ERRORS (GRCAN_IRQ_ERRCTR_RELATED | GRCAN_IRQ_OR \
180 | GRCAN_IRQ_TXAHBERR | GRCAN_IRQ_RXAHBERR \
181 | GRCAN_IRQ_TXLOSS)
182#define GRCAN_IRQ_DEFAULT (GRCAN_IRQ_RX | GRCAN_IRQ_TX | GRCAN_IRQ_ERRORS)
183
184#define GRCAN_MSG_SIZE 16
185
186#define GRCAN_MSG_IDE 0x80000000
187#define GRCAN_MSG_RTR 0x40000000
188#define GRCAN_MSG_BID 0x1ffc0000
189#define GRCAN_MSG_EID 0x1fffffff
190#define GRCAN_MSG_IDE_BIT 31
191#define GRCAN_MSG_RTR_BIT 30
192#define GRCAN_MSG_BID_BIT 18
193#define GRCAN_MSG_EID_BIT 0
194
195#define GRCAN_MSG_DLC 0xf0000000
196#define GRCAN_MSG_TXERRC 0x00ff0000
197#define GRCAN_MSG_RXERRC 0x0000ff00
198#define GRCAN_MSG_DLC_BIT 28
199#define GRCAN_MSG_TXERRC_BIT 16
200#define GRCAN_MSG_RXERRC_BIT 8
201#define GRCAN_MSG_AHBERR 0x00000008
202#define GRCAN_MSG_OR 0x00000004
203#define GRCAN_MSG_OFF 0x00000002
204#define GRCAN_MSG_PASS 0x00000001
205
206#define GRCAN_MSG_DATA_SLOT_INDEX(i) (2 + (i) / 4)
207#define GRCAN_MSG_DATA_SHIFT(i) ((3 - (i) % 4) * 8)
208
209#define GRCAN_BUFFER_ALIGNMENT 1024
210#define GRCAN_DEFAULT_BUFFER_SIZE 1024
211#define GRCAN_VALID_TR_SIZE_MASK 0x001fffc0
212
213#define GRCAN_INVALID_BUFFER_SIZE(s) \
214 ((s) == 0 || ((s) & ~GRCAN_VALID_TR_SIZE_MASK))
215
216#if GRCAN_INVALID_BUFFER_SIZE(GRCAN_DEFAULT_BUFFER_SIZE)
217#error "Invalid default buffer size"
218#endif
219
220struct grcan_dma_buffer {
221 size_t size;
222 void *buf;
223 dma_addr_t handle;
224};
225
226struct grcan_dma {
227 size_t base_size;
228 void *base_buf;
229 dma_addr_t base_handle;
230 struct grcan_dma_buffer tx;
231 struct grcan_dma_buffer rx;
232};
233
234/* GRCAN configuration parameters */
235struct grcan_device_config {
236 unsigned short enable0;
237 unsigned short enable1;
238 unsigned short select;
239 unsigned int txsize;
240 unsigned int rxsize;
241};
242
243#define GRCAN_DEFAULT_DEVICE_CONFIG { \
244 .enable0 = 0, \
245 .enable1 = 0, \
246 .select = 0, \
247 .txsize = GRCAN_DEFAULT_BUFFER_SIZE, \
248 .rxsize = GRCAN_DEFAULT_BUFFER_SIZE, \
249 }
250
251#define GRCAN_TXBUG_SAFE_GRLIB_VERSION 0x4100
252#define GRLIB_VERSION_MASK 0xffff
253
254/* GRCAN private data structure */
255struct grcan_priv {
256 struct can_priv can; /* must be the first member */
257 struct net_device *dev;
258 struct napi_struct napi;
259
260 struct grcan_registers __iomem *regs; /* ioremap'ed registers */
261 struct grcan_device_config config;
262 struct grcan_dma dma;
263
264 struct sk_buff **echo_skb; /* We allocate this on our own */
265 u8 *txdlc; /* Length of queued frames */
266
267 /* The echo skb pointer, pointing into echo_skb and indicating which
268 * frames can be echoed back. See the "Notes on the tx cyclic buffer
269 * handling"-comment for grcan_start_xmit for more details.
270 */
271 u32 eskbp;
272
273 /* Lock for controlling changes to the netif tx queue state, accesses to
274 * the echo_skb pointer eskbp and for making sure that a running reset
275 * and/or a close of the interface is done without interference from
276 * other parts of the code.
277 *
278 * The echo_skb pointer, eskbp, should only be accessed under this lock
279 * as it can be changed in several places and together with decisions on
280 * whether to wake up the tx queue.
281 *
282 * The tx queue must never be woken up if there is a running reset or
283 * close in progress.
284 *
285 * A running reset (see below on need_txbug_workaround) should never be
286 * done if the interface is closing down and several running resets
287 * should never be scheduled simultaneously.
288 */
289 spinlock_t lock;
290
291 /* Whether a workaround is needed due to a bug in older hardware. In
292 * this case, the driver both tries to prevent the bug from being
293 * triggered and recovers, if the bug nevertheless happens, by doing a
294 * running reset. A running reset, resets the device and continues from
295 * where it were without being noticeable from outside the driver (apart
296 * from slight delays).
297 */
298 bool need_txbug_workaround;
299
300 /* To trigger initization of running reset and to trigger running reset
301 * respectively in the case of a hanged device due to a txbug.
302 */
303 struct timer_list hang_timer;
304 struct timer_list rr_timer;
305
306 /* To avoid waking up the netif queue and restarting timers
307 * when a reset is scheduled or when closing of the device is
308 * undergoing
309 */
310 bool resetting;
311 bool closing;
312};
313
314/* Wait time for a short wait for ongoing to clear */
315#define GRCAN_SHORTWAIT_USECS 10
316
317/* Limit on the number of transmitted bits of an eff frame according to the CAN
318 * specification: 1 bit start of frame, 32 bits arbitration field, 6 bits
319 * control field, 8 bytes data field, 16 bits crc field, 2 bits ACK field and 7
320 * bits end of frame
321 */
322#define GRCAN_EFF_FRAME_MAX_BITS (1+32+6+8*8+16+2+7)
323
324#if defined(__BIG_ENDIAN)
325static inline u32 grcan_read_reg(u32 __iomem *reg)
326{
327 return ioread32be(reg);
328}
329
330static inline void grcan_write_reg(u32 __iomem *reg, u32 val)
331{
332 iowrite32be(val, reg);
333}
334#else
335static inline u32 grcan_read_reg(u32 __iomem *reg)
336{
337 return ioread32(reg);
338}
339
340static inline void grcan_write_reg(u32 __iomem *reg, u32 val)
341{
342 iowrite32(val, reg);
343}
344#endif
345
346static inline void grcan_clear_bits(u32 __iomem *reg, u32 mask)
347{
348 grcan_write_reg(reg, grcan_read_reg(reg) & ~mask);
349}
350
351static inline void grcan_set_bits(u32 __iomem *reg, u32 mask)
352{
353 grcan_write_reg(reg, grcan_read_reg(reg) | mask);
354}
355
356static inline u32 grcan_read_bits(u32 __iomem *reg, u32 mask)
357{
358 return grcan_read_reg(reg) & mask;
359}
360
361static inline void grcan_write_bits(u32 __iomem *reg, u32 value, u32 mask)
362{
363 u32 old = grcan_read_reg(reg);
364
365 grcan_write_reg(reg, (old & ~mask) | (value & mask));
366}
367
368/* a and b should both be in [0,size] and a == b == size should not hold */
369static inline u32 grcan_ring_add(u32 a, u32 b, u32 size)
370{
371 u32 sum = a + b;
372
373 if (sum < size)
374 return sum;
375 else
376 return sum - size;
377}
378
379/* a and b should both be in [0,size) */
380static inline u32 grcan_ring_sub(u32 a, u32 b, u32 size)
381{
382 return grcan_ring_add(a, size - b, size);
383}
384
385/* Available slots for new transmissions */
386static inline u32 grcan_txspace(size_t txsize, u32 txwr, u32 eskbp)
387{
388 u32 slots = txsize / GRCAN_MSG_SIZE - 1;
389 u32 used = grcan_ring_sub(txwr, eskbp, txsize) / GRCAN_MSG_SIZE;
390
391 return slots - used;
392}
393
394/* Configuration parameters that can be set via module parameters */
395static struct grcan_device_config grcan_module_config =
396 GRCAN_DEFAULT_DEVICE_CONFIG;
397
398static const struct can_bittiming_const grcan_bittiming_const = {
399 .name = DRV_NAME,
400 .tseg1_min = GRCAN_CONF_PS1_MIN + 1,
401 .tseg1_max = GRCAN_CONF_PS1_MAX + 1,
402 .tseg2_min = GRCAN_CONF_PS2_MIN,
403 .tseg2_max = GRCAN_CONF_PS2_MAX,
404 .sjw_max = GRCAN_CONF_RSJ_MAX,
405 .brp_min = GRCAN_CONF_SCALER_MIN + 1,
406 .brp_max = GRCAN_CONF_SCALER_MAX + 1,
407 .brp_inc = GRCAN_CONF_SCALER_INC,
408};
409
410static int grcan_set_bittiming(struct net_device *dev)
411{
412 struct grcan_priv *priv = netdev_priv(dev);
413 struct grcan_registers __iomem *regs = priv->regs;
414 struct can_bittiming *bt = &priv->can.bittiming;
415 u32 timing = 0;
416 int bpr, rsj, ps1, ps2, scaler;
417
418 /* Should never happen - function will not be called when
419 * device is up
420 */
421 if (grcan_read_bits(&regs->ctrl, GRCAN_CTRL_ENABLE))
422 return -EBUSY;
423
424 bpr = 0; /* Note bpr and brp are different concepts */
425 rsj = bt->sjw;
426 ps1 = (bt->prop_seg + bt->phase_seg1) - 1; /* tseg1 - 1 */
427 ps2 = bt->phase_seg2;
428 scaler = (bt->brp - 1);
429 netdev_dbg(dev, "Request for BPR=%d, RSJ=%d, PS1=%d, PS2=%d, SCALER=%d",
430 bpr, rsj, ps1, ps2, scaler);
431 if (!(ps1 > ps2)) {
432 netdev_err(dev, "PS1 > PS2 must hold: PS1=%d, PS2=%d\n",
433 ps1, ps2);
434 return -EINVAL;
435 }
436 if (!(ps2 >= rsj)) {
437 netdev_err(dev, "PS2 >= RSJ must hold: PS2=%d, RSJ=%d\n",
438 ps2, rsj);
439 return -EINVAL;
440 }
441
442 timing |= (bpr << GRCAN_CONF_BPR_BIT) & GRCAN_CONF_BPR;
443 timing |= (rsj << GRCAN_CONF_RSJ_BIT) & GRCAN_CONF_RSJ;
444 timing |= (ps1 << GRCAN_CONF_PS1_BIT) & GRCAN_CONF_PS1;
445 timing |= (ps2 << GRCAN_CONF_PS2_BIT) & GRCAN_CONF_PS2;
446 timing |= (scaler << GRCAN_CONF_SCALER_BIT) & GRCAN_CONF_SCALER;
447 netdev_info(dev, "setting timing=0x%x\n", timing);
448 grcan_write_bits(&regs->conf, timing, GRCAN_CONF_TIMING);
449
450 return 0;
451}
452
453static int grcan_get_berr_counter(const struct net_device *dev,
454 struct can_berr_counter *bec)
455{
456 struct grcan_priv *priv = netdev_priv(dev);
457 struct grcan_registers __iomem *regs = priv->regs;
458 u32 status = grcan_read_reg(&regs->stat);
459
460 bec->txerr = (status & GRCAN_STAT_TXERRCNT) >> GRCAN_STAT_TXERRCNT_BIT;
461 bec->rxerr = (status & GRCAN_STAT_RXERRCNT) >> GRCAN_STAT_RXERRCNT_BIT;
462 return 0;
463}
464
465static int grcan_poll(struct napi_struct *napi, int budget);
466
467/* Reset device, but keep configuration information */
468static void grcan_reset(struct net_device *dev)
469{
470 struct grcan_priv *priv = netdev_priv(dev);
471 struct grcan_registers __iomem *regs = priv->regs;
472 u32 config = grcan_read_reg(&regs->conf);
473
474 grcan_set_bits(&regs->ctrl, GRCAN_CTRL_RESET);
475 grcan_write_reg(&regs->conf, config);
476
477 priv->eskbp = grcan_read_reg(&regs->txrd);
478 priv->can.state = CAN_STATE_STOPPED;
479
480 /* Turn off hardware filtering - regs->rxcode set to 0 by reset */
481 grcan_write_reg(&regs->rxmask, 0);
482}
483
484/* stop device without changing any configurations */
485static void grcan_stop_hardware(struct net_device *dev)
486{
487 struct grcan_priv *priv = netdev_priv(dev);
488 struct grcan_registers __iomem *regs = priv->regs;
489
490 grcan_write_reg(&regs->imr, GRCAN_IRQ_NONE);
491 grcan_clear_bits(&regs->txctrl, GRCAN_TXCTRL_ENABLE);
492 grcan_clear_bits(&regs->rxctrl, GRCAN_RXCTRL_ENABLE);
493 grcan_clear_bits(&regs->ctrl, GRCAN_CTRL_ENABLE);
494}
495
496/* Let priv->eskbp catch up to regs->txrd and echo back the skbs if echo
497 * is true and free them otherwise.
498 *
499 * If budget is >= 0, stop after handling at most budget skbs. Otherwise,
500 * continue until priv->eskbp catches up to regs->txrd.
501 *
502 * priv->lock *must* be held when calling this function
503 */
504static int catch_up_echo_skb(struct net_device *dev, int budget, bool echo)
505{
506 struct grcan_priv *priv = netdev_priv(dev);
507 struct grcan_registers __iomem *regs = priv->regs;
508 struct grcan_dma *dma = &priv->dma;
509 struct net_device_stats *stats = &dev->stats;
510 int i, work_done;
511
512 /* Updates to priv->eskbp and wake-ups of the queue needs to
513 * be atomic towards the reads of priv->eskbp and shut-downs
514 * of the queue in grcan_start_xmit.
515 */
516 u32 txrd = grcan_read_reg(&regs->txrd);
517
518 for (work_done = 0; work_done < budget || budget < 0; work_done++) {
519 if (priv->eskbp == txrd)
520 break;
521 i = priv->eskbp / GRCAN_MSG_SIZE;
522 if (echo) {
523 /* Normal echo of messages */
524 stats->tx_packets++;
525 stats->tx_bytes += priv->txdlc[i];
526 priv->txdlc[i] = 0;
527 can_get_echo_skb(dev, i);
528 } else {
529 /* For cleanup of untransmitted messages */
530 can_free_echo_skb(dev, i);
531 }
532
533 priv->eskbp = grcan_ring_add(priv->eskbp, GRCAN_MSG_SIZE,
534 dma->tx.size);
535 txrd = grcan_read_reg(&regs->txrd);
536 }
537 return work_done;
538}
539
540static void grcan_lost_one_shot_frame(struct net_device *dev)
541{
542 struct grcan_priv *priv = netdev_priv(dev);
543 struct grcan_registers __iomem *regs = priv->regs;
544 struct grcan_dma *dma = &priv->dma;
545 u32 txrd;
546 unsigned long flags;
547
548 spin_lock_irqsave(&priv->lock, flags);
549
550 catch_up_echo_skb(dev, -1, true);
551
552 if (unlikely(grcan_read_bits(&regs->txctrl, GRCAN_TXCTRL_ENABLE))) {
553 /* Should never happen */
554 netdev_err(dev, "TXCTRL enabled at TXLOSS in one shot mode\n");
555 } else {
556 /* By the time an GRCAN_IRQ_TXLOSS is generated in
557 * one-shot mode there is no problem in writing
558 * to TXRD even in versions of the hardware in
559 * which GRCAN_TXCTRL_ONGOING is not cleared properly
560 * in one-shot mode.
561 */
562
563 /* Skip message and discard echo-skb */
564 txrd = grcan_read_reg(&regs->txrd);
565 txrd = grcan_ring_add(txrd, GRCAN_MSG_SIZE, dma->tx.size);
566 grcan_write_reg(&regs->txrd, txrd);
567 catch_up_echo_skb(dev, -1, false);
568
569 if (!priv->resetting && !priv->closing &&
570 !(priv->can.ctrlmode & CAN_CTRLMODE_LISTENONLY)) {
571 netif_wake_queue(dev);
572 grcan_set_bits(&regs->txctrl, GRCAN_TXCTRL_ENABLE);
573 }
574 }
575
576 spin_unlock_irqrestore(&priv->lock, flags);
577}
578
579static void grcan_err(struct net_device *dev, u32 sources, u32 status)
580{
581 struct grcan_priv *priv = netdev_priv(dev);
582 struct grcan_registers __iomem *regs = priv->regs;
583 struct grcan_dma *dma = &priv->dma;
584 struct net_device_stats *stats = &dev->stats;
585 struct can_frame cf;
586
587 /* Zero potential error_frame */
588 memset(&cf, 0, sizeof(cf));
589
590 /* Message lost interrupt. This might be due to arbitration error, but
591 * is also triggered when there is no one else on the can bus or when
592 * there is a problem with the hardware interface or the bus itself. As
593 * arbitration errors can not be singled out, no error frames are
594 * generated reporting this event as an arbitration error.
595 */
596 if (sources & GRCAN_IRQ_TXLOSS) {
597 /* Take care of failed one-shot transmit */
598 if (priv->can.ctrlmode & CAN_CTRLMODE_ONE_SHOT)
599 grcan_lost_one_shot_frame(dev);
600
601 /* Stop printing as soon as error passive or bus off is in
602 * effect to limit the amount of txloss debug printouts.
603 */
604 if (!(status & GRCAN_STAT_ERRCTR_RELATED)) {
605 netdev_dbg(dev, "tx message lost\n");
606 stats->tx_errors++;
607 }
608 }
609
610 /* Conditions dealing with the error counters. There is no interrupt for
611 * error warning, but there are interrupts for increases of the error
612 * counters.
613 */
614 if ((sources & GRCAN_IRQ_ERRCTR_RELATED) ||
615 (status & GRCAN_STAT_ERRCTR_RELATED)) {
616 enum can_state state = priv->can.state;
617 enum can_state oldstate = state;
618 u32 txerr = (status & GRCAN_STAT_TXERRCNT)
619 >> GRCAN_STAT_TXERRCNT_BIT;
620 u32 rxerr = (status & GRCAN_STAT_RXERRCNT)
621 >> GRCAN_STAT_RXERRCNT_BIT;
622
623 /* Figure out current state */
624 if (status & GRCAN_STAT_OFF) {
625 state = CAN_STATE_BUS_OFF;
626 } else if (status & GRCAN_STAT_PASS) {
627 state = CAN_STATE_ERROR_PASSIVE;
628 } else if (txerr >= GRCAN_STAT_ERRCNT_WARNING_LIMIT ||
629 rxerr >= GRCAN_STAT_ERRCNT_WARNING_LIMIT) {
630 state = CAN_STATE_ERROR_WARNING;
631 } else {
632 state = CAN_STATE_ERROR_ACTIVE;
633 }
634
635 /* Handle and report state changes */
636 if (state != oldstate) {
637 switch (state) {
638 case CAN_STATE_BUS_OFF:
639 netdev_dbg(dev, "bus-off\n");
640 netif_carrier_off(dev);
641 priv->can.can_stats.bus_off++;
642
643 /* Prevent the hardware from recovering from bus
644 * off on its own if restart is disabled.
645 */
646 if (!priv->can.restart_ms)
647 grcan_stop_hardware(dev);
648
649 cf.can_id |= CAN_ERR_BUSOFF;
650 break;
651
652 case CAN_STATE_ERROR_PASSIVE:
653 netdev_dbg(dev, "Error passive condition\n");
654 priv->can.can_stats.error_passive++;
655
656 cf.can_id |= CAN_ERR_CRTL;
657 if (txerr >= GRCAN_STAT_ERRCNT_PASSIVE_LIMIT)
658 cf.data[1] |= CAN_ERR_CRTL_TX_PASSIVE;
659 if (rxerr >= GRCAN_STAT_ERRCNT_PASSIVE_LIMIT)
660 cf.data[1] |= CAN_ERR_CRTL_RX_PASSIVE;
661 break;
662
663 case CAN_STATE_ERROR_WARNING:
664 netdev_dbg(dev, "Error warning condition\n");
665 priv->can.can_stats.error_warning++;
666
667 cf.can_id |= CAN_ERR_CRTL;
668 if (txerr >= GRCAN_STAT_ERRCNT_WARNING_LIMIT)
669 cf.data[1] |= CAN_ERR_CRTL_TX_WARNING;
670 if (rxerr >= GRCAN_STAT_ERRCNT_WARNING_LIMIT)
671 cf.data[1] |= CAN_ERR_CRTL_RX_WARNING;
672 break;
673
674 case CAN_STATE_ERROR_ACTIVE:
675 netdev_dbg(dev, "Error active condition\n");
676 cf.can_id |= CAN_ERR_CRTL;
677 break;
678
679 default:
680 /* There are no others at this point */
681 break;
682 }
683 cf.data[6] = txerr;
684 cf.data[7] = rxerr;
685 priv->can.state = state;
686 }
687
688 /* Report automatic restarts */
689 if (priv->can.restart_ms && oldstate == CAN_STATE_BUS_OFF) {
690 unsigned long flags;
691
692 cf.can_id |= CAN_ERR_RESTARTED;
693 netdev_dbg(dev, "restarted\n");
694 priv->can.can_stats.restarts++;
695 netif_carrier_on(dev);
696
697 spin_lock_irqsave(&priv->lock, flags);
698
699 if (!priv->resetting && !priv->closing) {
700 u32 txwr = grcan_read_reg(&regs->txwr);
701
702 if (grcan_txspace(dma->tx.size, txwr,
703 priv->eskbp))
704 netif_wake_queue(dev);
705 }
706
707 spin_unlock_irqrestore(&priv->lock, flags);
708 }
709 }
710
711 /* Data overrun interrupt */
712 if ((sources & GRCAN_IRQ_OR) || (status & GRCAN_STAT_OR)) {
713 netdev_dbg(dev, "got data overrun interrupt\n");
714 stats->rx_over_errors++;
715 stats->rx_errors++;
716
717 cf.can_id |= CAN_ERR_CRTL;
718 cf.data[1] |= CAN_ERR_CRTL_RX_OVERFLOW;
719 }
720
721 /* AHB bus error interrupts (not CAN bus errors) - shut down the
722 * device.
723 */
724 if (sources & (GRCAN_IRQ_TXAHBERR | GRCAN_IRQ_RXAHBERR) ||
725 (status & GRCAN_STAT_AHBERR)) {
726 char *txrx = "";
727 unsigned long flags;
728
729 if (sources & GRCAN_IRQ_TXAHBERR) {
730 txrx = "on tx ";
731 stats->tx_errors++;
732 } else if (sources & GRCAN_IRQ_RXAHBERR) {
733 txrx = "on rx ";
734 stats->rx_errors++;
735 }
736 netdev_err(dev, "Fatal AHB buss error %s- halting device\n",
737 txrx);
738
739 spin_lock_irqsave(&priv->lock, flags);
740
741 /* Prevent anything to be enabled again and halt device */
742 priv->closing = true;
743 netif_stop_queue(dev);
744 grcan_stop_hardware(dev);
745 priv->can.state = CAN_STATE_STOPPED;
746
747 spin_unlock_irqrestore(&priv->lock, flags);
748 }
749
750 /* Pass on error frame if something to report,
751 * i.e. id contains some information
752 */
753 if (cf.can_id) {
754 struct can_frame *skb_cf;
755 struct sk_buff *skb = alloc_can_err_skb(dev, &skb_cf);
756
757 if (skb == NULL) {
758 netdev_dbg(dev, "could not allocate error frame\n");
759 return;
760 }
761 skb_cf->can_id |= cf.can_id;
762 memcpy(skb_cf->data, cf.data, sizeof(cf.data));
763
764 netif_rx(skb);
765 }
766}
767
768static irqreturn_t grcan_interrupt(int irq, void *dev_id)
769{
770 struct net_device *dev = dev_id;
771 struct grcan_priv *priv = netdev_priv(dev);
772 struct grcan_registers __iomem *regs = priv->regs;
773 u32 sources, status;
774
775 /* Find out the source */
776 sources = grcan_read_reg(&regs->pimsr);
777 if (!sources)
778 return IRQ_NONE;
779 grcan_write_reg(&regs->picr, sources);
780 status = grcan_read_reg(&regs->stat);
781
782 /* If we got TX progress, the device has not hanged,
783 * so disable the hang timer
784 */
785 if (priv->need_txbug_workaround &&
786 (sources & (GRCAN_IRQ_TX | GRCAN_IRQ_TXLOSS))) {
787 del_timer(&priv->hang_timer);
788 }
789
790 /* Frame(s) received or transmitted */
791 if (sources & (GRCAN_IRQ_TX | GRCAN_IRQ_RX)) {
792 /* Disable tx/rx interrupts and schedule poll(). No need for
793 * locking as interference from a running reset at worst leads
794 * to an extra interrupt.
795 */
796 grcan_clear_bits(&regs->imr, GRCAN_IRQ_TX | GRCAN_IRQ_RX);
797 napi_schedule(&priv->napi);
798 }
799
800 /* (Potential) error conditions to take care of */
801 if (sources & GRCAN_IRQ_ERRORS)
802 grcan_err(dev, sources, status);
803
804 return IRQ_HANDLED;
805}
806
807/* Reset device and restart operations from where they were.
808 *
809 * This assumes that RXCTRL & RXCTRL is properly disabled and that RX
810 * is not ONGOING (TX might be stuck in ONGOING due to a harwrware bug
811 * for single shot)
812 */
813static void grcan_running_reset(unsigned long data)
814{
815 struct net_device *dev = (struct net_device *)data;
816 struct grcan_priv *priv = netdev_priv(dev);
817 struct grcan_registers __iomem *regs = priv->regs;
818 unsigned long flags;
819
820 /* This temporarily messes with eskbp, so we need to lock
821 * priv->lock
822 */
823 spin_lock_irqsave(&priv->lock, flags);
824
825 priv->resetting = false;
826 del_timer(&priv->hang_timer);
827 del_timer(&priv->rr_timer);
828
829 if (!priv->closing) {
830 /* Save and reset - config register preserved by grcan_reset */
831 u32 imr = grcan_read_reg(&regs->imr);
832
833 u32 txaddr = grcan_read_reg(&regs->txaddr);
834 u32 txsize = grcan_read_reg(&regs->txsize);
835 u32 txwr = grcan_read_reg(&regs->txwr);
836 u32 txrd = grcan_read_reg(&regs->txrd);
837 u32 eskbp = priv->eskbp;
838
839 u32 rxaddr = grcan_read_reg(&regs->rxaddr);
840 u32 rxsize = grcan_read_reg(&regs->rxsize);
841 u32 rxwr = grcan_read_reg(&regs->rxwr);
842 u32 rxrd = grcan_read_reg(&regs->rxrd);
843
844 grcan_reset(dev);
845
846 /* Restore */
847 grcan_write_reg(&regs->txaddr, txaddr);
848 grcan_write_reg(&regs->txsize, txsize);
849 grcan_write_reg(&regs->txwr, txwr);
850 grcan_write_reg(&regs->txrd, txrd);
851 priv->eskbp = eskbp;
852
853 grcan_write_reg(&regs->rxaddr, rxaddr);
854 grcan_write_reg(&regs->rxsize, rxsize);
855 grcan_write_reg(&regs->rxwr, rxwr);
856 grcan_write_reg(&regs->rxrd, rxrd);
857
858 /* Turn on device again */
859 grcan_write_reg(&regs->imr, imr);
860 priv->can.state = CAN_STATE_ERROR_ACTIVE;
861 grcan_write_reg(&regs->txctrl, GRCAN_TXCTRL_ENABLE
862 | (priv->can.ctrlmode & CAN_CTRLMODE_ONE_SHOT
863 ? GRCAN_TXCTRL_SINGLE : 0));
864 grcan_write_reg(&regs->rxctrl, GRCAN_RXCTRL_ENABLE);
865 grcan_write_reg(&regs->ctrl, GRCAN_CTRL_ENABLE);
866
867 /* Start queue if there is size and listen-onle mode is not
868 * enabled
869 */
870 if (grcan_txspace(priv->dma.tx.size, txwr, priv->eskbp) &&
871 !(priv->can.ctrlmode & CAN_CTRLMODE_LISTENONLY))
872 netif_wake_queue(dev);
873 }
874
875 spin_unlock_irqrestore(&priv->lock, flags);
876
877 netdev_err(dev, "Device reset and restored\n");
878}
879
880/* Waiting time in usecs corresponding to the transmission of three maximum
881 * sized can frames in the given bitrate (in bits/sec). Waiting for this amount
882 * of time makes sure that the can controller have time to finish sending or
883 * receiving a frame with a good margin.
884 *
885 * usecs/sec * number of frames * bits/frame / bits/sec
886 */
887static inline u32 grcan_ongoing_wait_usecs(__u32 bitrate)
888{
889 return 1000000 * 3 * GRCAN_EFF_FRAME_MAX_BITS / bitrate;
890}
891
892/* Set timer so that it will not fire until after a period in which the can
893 * controller have a good margin to finish transmitting a frame unless it has
894 * hanged
895 */
896static inline void grcan_reset_timer(struct timer_list *timer, __u32 bitrate)
897{
898 u32 wait_jiffies = usecs_to_jiffies(grcan_ongoing_wait_usecs(bitrate));
899
900 mod_timer(timer, jiffies + wait_jiffies);
901}
902
903/* Disable channels and schedule a running reset */
904static void grcan_initiate_running_reset(unsigned long data)
905{
906 struct net_device *dev = (struct net_device *)data;
907 struct grcan_priv *priv = netdev_priv(dev);
908 struct grcan_registers __iomem *regs = priv->regs;
909 unsigned long flags;
910
911 netdev_err(dev, "Device seems hanged - reset scheduled\n");
912
913 spin_lock_irqsave(&priv->lock, flags);
914
915 /* The main body of this function must never be executed again
916 * until after an execution of grcan_running_reset
917 */
918 if (!priv->resetting && !priv->closing) {
919 priv->resetting = true;
920 netif_stop_queue(dev);
921 grcan_clear_bits(&regs->txctrl, GRCAN_TXCTRL_ENABLE);
922 grcan_clear_bits(&regs->rxctrl, GRCAN_RXCTRL_ENABLE);
923 grcan_reset_timer(&priv->rr_timer, priv->can.bittiming.bitrate);
924 }
925
926 spin_unlock_irqrestore(&priv->lock, flags);
927}
928
929static void grcan_free_dma_buffers(struct net_device *dev)
930{
931 struct grcan_priv *priv = netdev_priv(dev);
932 struct grcan_dma *dma = &priv->dma;
933
934 dma_free_coherent(&dev->dev, dma->base_size, dma->base_buf,
935 dma->base_handle);
936 memset(dma, 0, sizeof(*dma));
937}
938
939static int grcan_allocate_dma_buffers(struct net_device *dev,
940 size_t tsize, size_t rsize)
941{
942 struct grcan_priv *priv = netdev_priv(dev);
943 struct grcan_dma *dma = &priv->dma;
944 struct grcan_dma_buffer *large = rsize > tsize ? &dma->rx : &dma->tx;
945 struct grcan_dma_buffer *small = rsize > tsize ? &dma->tx : &dma->rx;
946 size_t shift;
947
948 /* Need a whole number of GRCAN_BUFFER_ALIGNMENT for the large,
949 * i.e. first buffer
950 */
951 size_t maxs = max(tsize, rsize);
952 size_t lsize = ALIGN(maxs, GRCAN_BUFFER_ALIGNMENT);
953
954 /* Put the small buffer after that */
955 size_t ssize = min(tsize, rsize);
956
957 /* Extra GRCAN_BUFFER_ALIGNMENT to allow for alignment */
958 dma->base_size = lsize + ssize + GRCAN_BUFFER_ALIGNMENT;
959 dma->base_buf = dma_alloc_coherent(&dev->dev,
960 dma->base_size,
961 &dma->base_handle,
962 GFP_KERNEL);
963
964 if (!dma->base_buf)
965 return -ENOMEM;
966
967 dma->tx.size = tsize;
968 dma->rx.size = rsize;
969
970 large->handle = ALIGN(dma->base_handle, GRCAN_BUFFER_ALIGNMENT);
971 small->handle = large->handle + lsize;
972 shift = large->handle - dma->base_handle;
973
974 large->buf = dma->base_buf + shift;
975 small->buf = large->buf + lsize;
976
977 return 0;
978}
979
980/* priv->lock *must* be held when calling this function */
981static int grcan_start(struct net_device *dev)
982{
983 struct grcan_priv *priv = netdev_priv(dev);
984 struct grcan_registers __iomem *regs = priv->regs;
985 u32 confop, txctrl;
986
987 grcan_reset(dev);
988
989 grcan_write_reg(&regs->txaddr, priv->dma.tx.handle);
990 grcan_write_reg(&regs->txsize, priv->dma.tx.size);
991 /* regs->txwr, regs->txrd and priv->eskbp already set to 0 by reset */
992
993 grcan_write_reg(&regs->rxaddr, priv->dma.rx.handle);
994 grcan_write_reg(&regs->rxsize, priv->dma.rx.size);
995 /* regs->rxwr and regs->rxrd already set to 0 by reset */
996
997 /* Enable interrupts */
998 grcan_read_reg(&regs->pir);
999 grcan_write_reg(&regs->imr, GRCAN_IRQ_DEFAULT);
1000
1001 /* Enable interfaces, channels and device */
1002 confop = GRCAN_CONF_ABORT
1003 | (priv->config.enable0 ? GRCAN_CONF_ENABLE0 : 0)
1004 | (priv->config.enable1 ? GRCAN_CONF_ENABLE1 : 0)
1005 | (priv->config.select ? GRCAN_CONF_SELECT : 0)
1006 | (priv->can.ctrlmode & CAN_CTRLMODE_LISTENONLY ?
1007 GRCAN_CONF_SILENT : 0)
1008 | (priv->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES ?
1009 GRCAN_CONF_SAM : 0);
1010 grcan_write_bits(&regs->conf, confop, GRCAN_CONF_OPERATION);
1011 txctrl = GRCAN_TXCTRL_ENABLE
1012 | (priv->can.ctrlmode & CAN_CTRLMODE_ONE_SHOT
1013 ? GRCAN_TXCTRL_SINGLE : 0);
1014 grcan_write_reg(&regs->txctrl, txctrl);
1015 grcan_write_reg(&regs->rxctrl, GRCAN_RXCTRL_ENABLE);
1016 grcan_write_reg(&regs->ctrl, GRCAN_CTRL_ENABLE);
1017
1018 priv->can.state = CAN_STATE_ERROR_ACTIVE;
1019
1020 return 0;
1021}
1022
1023static int grcan_set_mode(struct net_device *dev, enum can_mode mode)
1024{
1025 struct grcan_priv *priv = netdev_priv(dev);
1026 unsigned long flags;
1027 int err = 0;
1028
1029 if (mode == CAN_MODE_START) {
1030 /* This might be called to restart the device to recover from
1031 * bus off errors
1032 */
1033 spin_lock_irqsave(&priv->lock, flags);
1034 if (priv->closing || priv->resetting) {
1035 err = -EBUSY;
1036 } else {
1037 netdev_info(dev, "Restarting device\n");
1038 grcan_start(dev);
1039 if (!(priv->can.ctrlmode & CAN_CTRLMODE_LISTENONLY))
1040 netif_wake_queue(dev);
1041 }
1042 spin_unlock_irqrestore(&priv->lock, flags);
1043 return err;
1044 }
1045 return -EOPNOTSUPP;
1046}
1047
1048static int grcan_open(struct net_device *dev)
1049{
1050 struct grcan_priv *priv = netdev_priv(dev);
1051 struct grcan_dma *dma = &priv->dma;
1052 unsigned long flags;
1053 int err;
1054
1055 /* Allocate memory */
1056 err = grcan_allocate_dma_buffers(dev, priv->config.txsize,
1057 priv->config.rxsize);
1058 if (err) {
1059 netdev_err(dev, "could not allocate DMA buffers\n");
1060 return err;
1061 }
1062
1063 priv->echo_skb = kzalloc(dma->tx.size * sizeof(*priv->echo_skb),
1064 GFP_KERNEL);
1065 if (!priv->echo_skb) {
1066 err = -ENOMEM;
1067 goto exit_free_dma_buffers;
1068 }
1069 priv->can.echo_skb_max = dma->tx.size;
1070 priv->can.echo_skb = priv->echo_skb;
1071
1072 priv->txdlc = kzalloc(dma->tx.size * sizeof(*priv->txdlc), GFP_KERNEL);
1073 if (!priv->txdlc) {
1074 err = -ENOMEM;
1075 goto exit_free_echo_skb;
1076 }
1077
1078 /* Get can device up */
1079 err = open_candev(dev);
1080 if (err)
1081 goto exit_free_txdlc;
1082
1083 err = request_irq(dev->irq, grcan_interrupt, IRQF_SHARED,
1084 dev->name, dev);
1085 if (err)
1086 goto exit_close_candev;
1087
1088 spin_lock_irqsave(&priv->lock, flags);
1089
1090 napi_enable(&priv->napi);
1091 grcan_start(dev);
1092 if (!(priv->can.ctrlmode & CAN_CTRLMODE_LISTENONLY))
1093 netif_start_queue(dev);
1094 priv->resetting = false;
1095 priv->closing = false;
1096
1097 spin_unlock_irqrestore(&priv->lock, flags);
1098
1099 return 0;
1100
1101exit_close_candev:
1102 close_candev(dev);
1103exit_free_txdlc:
1104 kfree(priv->txdlc);
1105exit_free_echo_skb:
1106 kfree(priv->echo_skb);
1107exit_free_dma_buffers:
1108 grcan_free_dma_buffers(dev);
1109 return err;
1110}
1111
1112static int grcan_close(struct net_device *dev)
1113{
1114 struct grcan_priv *priv = netdev_priv(dev);
1115 unsigned long flags;
1116
1117 napi_disable(&priv->napi);
1118
1119 spin_lock_irqsave(&priv->lock, flags);
1120
1121 priv->closing = true;
1122 if (priv->need_txbug_workaround) {
1123 del_timer_sync(&priv->hang_timer);
1124 del_timer_sync(&priv->rr_timer);
1125 }
1126 netif_stop_queue(dev);
1127 grcan_stop_hardware(dev);
1128 priv->can.state = CAN_STATE_STOPPED;
1129
1130 spin_unlock_irqrestore(&priv->lock, flags);
1131
1132 free_irq(dev->irq, dev);
1133 close_candev(dev);
1134
1135 grcan_free_dma_buffers(dev);
1136 priv->can.echo_skb_max = 0;
1137 priv->can.echo_skb = NULL;
1138 kfree(priv->echo_skb);
1139 kfree(priv->txdlc);
1140
1141 return 0;
1142}
1143
1144static int grcan_transmit_catch_up(struct net_device *dev, int budget)
1145{
1146 struct grcan_priv *priv = netdev_priv(dev);
1147 unsigned long flags;
1148 int work_done;
1149
1150 spin_lock_irqsave(&priv->lock, flags);
1151
1152 work_done = catch_up_echo_skb(dev, budget, true);
1153 if (work_done) {
1154 if (!priv->resetting && !priv->closing &&
1155 !(priv->can.ctrlmode & CAN_CTRLMODE_LISTENONLY))
1156 netif_wake_queue(dev);
1157
1158 /* With napi we don't get TX interrupts for a while,
1159 * so prevent a running reset while catching up
1160 */
1161 if (priv->need_txbug_workaround)
1162 del_timer(&priv->hang_timer);
1163 }
1164
1165 spin_unlock_irqrestore(&priv->lock, flags);
1166
1167 return work_done;
1168}
1169
1170static int grcan_receive(struct net_device *dev, int budget)
1171{
1172 struct grcan_priv *priv = netdev_priv(dev);
1173 struct grcan_registers __iomem *regs = priv->regs;
1174 struct grcan_dma *dma = &priv->dma;
1175 struct net_device_stats *stats = &dev->stats;
1176 struct can_frame *cf;
1177 struct sk_buff *skb;
1178 u32 wr, rd, startrd;
1179 u32 *slot;
1180 u32 i, rtr, eff, j, shift;
1181 int work_done = 0;
1182
1183 rd = grcan_read_reg(&regs->rxrd);
1184 startrd = rd;
1185 for (work_done = 0; work_done < budget; work_done++) {
1186 /* Check for packet to receive */
1187 wr = grcan_read_reg(&regs->rxwr);
1188 if (rd == wr)
1189 break;
1190
1191 /* Take care of packet */
1192 skb = alloc_can_skb(dev, &cf);
1193 if (skb == NULL) {
1194 netdev_err(dev,
1195 "dropping frame: skb allocation failed\n");
1196 stats->rx_dropped++;
1197 continue;
1198 }
1199
1200 slot = dma->rx.buf + rd;
1201 eff = slot[0] & GRCAN_MSG_IDE;
1202 rtr = slot[0] & GRCAN_MSG_RTR;
1203 if (eff) {
1204 cf->can_id = ((slot[0] & GRCAN_MSG_EID)
1205 >> GRCAN_MSG_EID_BIT);
1206 cf->can_id |= CAN_EFF_FLAG;
1207 } else {
1208 cf->can_id = ((slot[0] & GRCAN_MSG_BID)
1209 >> GRCAN_MSG_BID_BIT);
1210 }
1211 cf->can_dlc = get_can_dlc((slot[1] & GRCAN_MSG_DLC)
1212 >> GRCAN_MSG_DLC_BIT);
1213 if (rtr) {
1214 cf->can_id |= CAN_RTR_FLAG;
1215 } else {
1216 for (i = 0; i < cf->can_dlc; i++) {
1217 j = GRCAN_MSG_DATA_SLOT_INDEX(i);
1218 shift = GRCAN_MSG_DATA_SHIFT(i);
1219 cf->data[i] = (u8)(slot[j] >> shift);
1220 }
1221 }
1222 netif_receive_skb(skb);
1223
1224 /* Update statistics and read pointer */
1225 stats->rx_packets++;
1226 stats->rx_bytes += cf->can_dlc;
1227 rd = grcan_ring_add(rd, GRCAN_MSG_SIZE, dma->rx.size);
1228 }
1229
1230 /* Make sure everything is read before allowing hardware to
1231 * use the memory
1232 */
1233 mb();
1234
1235 /* Update read pointer - no need to check for ongoing */
1236 if (likely(rd != startrd))
1237 grcan_write_reg(&regs->rxrd, rd);
1238
1239 return work_done;
1240}
1241
1242static int grcan_poll(struct napi_struct *napi, int budget)
1243{
1244 struct grcan_priv *priv = container_of(napi, struct grcan_priv, napi);
1245 struct net_device *dev = priv->dev;
1246 struct grcan_registers __iomem *regs = priv->regs;
1247 unsigned long flags;
1248 int tx_work_done, rx_work_done;
1249 int rx_budget = budget / 2;
1250 int tx_budget = budget - rx_budget;
1251
1252 /* Half of the budget for receiveing messages */
1253 rx_work_done = grcan_receive(dev, rx_budget);
1254
1255 /* Half of the budget for transmitting messages as that can trigger echo
1256 * frames being received
1257 */
1258 tx_work_done = grcan_transmit_catch_up(dev, tx_budget);
1259
1260 if (rx_work_done < rx_budget && tx_work_done < tx_budget) {
1261 napi_complete(napi);
1262
1263 /* Guarantee no interference with a running reset that otherwise
1264 * could turn off interrupts.
1265 */
1266 spin_lock_irqsave(&priv->lock, flags);
1267
1268 /* Enable tx and rx interrupts again. No need to check
1269 * priv->closing as napi_disable in grcan_close is waiting for
1270 * scheduled napi calls to finish.
1271 */
1272 grcan_set_bits(&regs->imr, GRCAN_IRQ_TX | GRCAN_IRQ_RX);
1273
1274 spin_unlock_irqrestore(&priv->lock, flags);
1275 }
1276
1277 return rx_work_done + tx_work_done;
1278}
1279
1280/* Work tx bug by waiting while for the risky situation to clear. If that fails,
1281 * drop a frame in one-shot mode or indicate a busy device otherwise.
1282 *
1283 * Returns 0 on successful wait. Otherwise it sets *netdev_tx_status to the
1284 * value that should be returned by grcan_start_xmit when aborting the xmit.
1285 */
1286static int grcan_txbug_workaround(struct net_device *dev, struct sk_buff *skb,
1287 u32 txwr, u32 oneshotmode,
1288 netdev_tx_t *netdev_tx_status)
1289{
1290 struct grcan_priv *priv = netdev_priv(dev);
1291 struct grcan_registers __iomem *regs = priv->regs;
1292 struct grcan_dma *dma = &priv->dma;
1293 int i;
1294 unsigned long flags;
1295
1296 /* Wait a while for ongoing to be cleared or read pointer to catch up to
1297 * write pointer. The latter is needed due to a bug in older versions of
1298 * GRCAN in which ONGOING is not cleared properly one-shot mode when a
1299 * transmission fails.
1300 */
1301 for (i = 0; i < GRCAN_SHORTWAIT_USECS; i++) {
1302 udelay(1);
1303 if (!grcan_read_bits(&regs->txctrl, GRCAN_TXCTRL_ONGOING) ||
1304 grcan_read_reg(&regs->txrd) == txwr) {
1305 return 0;
1306 }
1307 }
1308
1309 /* Clean up, in case the situation was not resolved */
1310 spin_lock_irqsave(&priv->lock, flags);
1311 if (!priv->resetting && !priv->closing) {
1312 /* Queue might have been stopped earlier in grcan_start_xmit */
1313 if (grcan_txspace(dma->tx.size, txwr, priv->eskbp))
1314 netif_wake_queue(dev);
1315 /* Set a timer to resolve a hanged tx controller */
1316 if (!timer_pending(&priv->hang_timer))
1317 grcan_reset_timer(&priv->hang_timer,
1318 priv->can.bittiming.bitrate);
1319 }
1320 spin_unlock_irqrestore(&priv->lock, flags);
1321
1322 if (oneshotmode) {
1323 /* In one-shot mode we should never end up here because
1324 * then the interrupt handler increases txrd on TXLOSS,
1325 * but it is consistent with one-shot mode to drop the
1326 * frame in this case.
1327 */
1328 kfree_skb(skb);
1329 *netdev_tx_status = NETDEV_TX_OK;
1330 } else {
1331 /* In normal mode the socket-can transmission queue get
1332 * to keep the frame so that it can be retransmitted
1333 * later
1334 */
1335 *netdev_tx_status = NETDEV_TX_BUSY;
1336 }
1337 return -EBUSY;
1338}
1339
1340/* Notes on the tx cyclic buffer handling:
1341 *
1342 * regs->txwr - the next slot for the driver to put data to be sent
1343 * regs->txrd - the next slot for the device to read data
1344 * priv->eskbp - the next slot for the driver to call can_put_echo_skb for
1345 *
1346 * grcan_start_xmit can enter more messages as long as regs->txwr does
1347 * not reach priv->eskbp (within 1 message gap)
1348 *
1349 * The device sends messages until regs->txrd reaches regs->txwr
1350 *
1351 * The interrupt calls handler calls can_put_echo_skb until
1352 * priv->eskbp reaches regs->txrd
1353 */
1354static netdev_tx_t grcan_start_xmit(struct sk_buff *skb,
1355 struct net_device *dev)
1356{
1357 struct grcan_priv *priv = netdev_priv(dev);
1358 struct grcan_registers __iomem *regs = priv->regs;
1359 struct grcan_dma *dma = &priv->dma;
1360 struct can_frame *cf = (struct can_frame *)skb->data;
1361 u32 id, txwr, txrd, space, txctrl;
1362 int slotindex;
1363 u32 *slot;
1364 u32 i, rtr, eff, dlc, tmp, err;
1365 int j, shift;
1366 unsigned long flags;
1367 u32 oneshotmode = priv->can.ctrlmode & CAN_CTRLMODE_ONE_SHOT;
1368
1369 if (can_dropped_invalid_skb(dev, skb))
1370 return NETDEV_TX_OK;
1371
1372 /* Trying to transmit in silent mode will generate error interrupts, but
1373 * this should never happen - the queue should not have been started.
1374 */
1375 if (priv->can.ctrlmode & CAN_CTRLMODE_LISTENONLY)
1376 return NETDEV_TX_BUSY;
1377
1378 /* Reads of priv->eskbp and shut-downs of the queue needs to
1379 * be atomic towards the updates to priv->eskbp and wake-ups
1380 * of the queue in the interrupt handler.
1381 */
1382 spin_lock_irqsave(&priv->lock, flags);
1383
1384 txwr = grcan_read_reg(&regs->txwr);
1385 space = grcan_txspace(dma->tx.size, txwr, priv->eskbp);
1386
1387 slotindex = txwr / GRCAN_MSG_SIZE;
1388 slot = dma->tx.buf + txwr;
1389
1390 if (unlikely(space == 1))
1391 netif_stop_queue(dev);
1392
1393 spin_unlock_irqrestore(&priv->lock, flags);
1394 /* End of critical section*/
1395
1396 /* This should never happen. If circular buffer is full, the
1397 * netif_stop_queue should have been stopped already.
1398 */
1399 if (unlikely(!space)) {
1400 netdev_err(dev, "No buffer space, but queue is non-stopped.\n");
1401 return NETDEV_TX_BUSY;
1402 }
1403
1404 /* Convert and write CAN message to DMA buffer */
1405 eff = cf->can_id & CAN_EFF_FLAG;
1406 rtr = cf->can_id & CAN_RTR_FLAG;
1407 id = cf->can_id & (eff ? CAN_EFF_MASK : CAN_SFF_MASK);
1408 dlc = cf->can_dlc;
1409 if (eff)
1410 tmp = (id << GRCAN_MSG_EID_BIT) & GRCAN_MSG_EID;
1411 else
1412 tmp = (id << GRCAN_MSG_BID_BIT) & GRCAN_MSG_BID;
1413 slot[0] = (eff ? GRCAN_MSG_IDE : 0) | (rtr ? GRCAN_MSG_RTR : 0) | tmp;
1414
1415 slot[1] = ((dlc << GRCAN_MSG_DLC_BIT) & GRCAN_MSG_DLC);
1416 slot[2] = 0;
1417 slot[3] = 0;
1418 for (i = 0; i < dlc; i++) {
1419 j = GRCAN_MSG_DATA_SLOT_INDEX(i);
1420 shift = GRCAN_MSG_DATA_SHIFT(i);
1421 slot[j] |= cf->data[i] << shift;
1422 }
1423
1424 /* Checking that channel has not been disabled. These cases
1425 * should never happen
1426 */
1427 txctrl = grcan_read_reg(&regs->txctrl);
1428 if (!(txctrl & GRCAN_TXCTRL_ENABLE))
1429 netdev_err(dev, "tx channel spuriously disabled\n");
1430
1431 if (oneshotmode && !(txctrl & GRCAN_TXCTRL_SINGLE))
1432 netdev_err(dev, "one-shot mode spuriously disabled\n");
1433
1434 /* Bug workaround for old version of grcan where updating txwr
1435 * in the same clock cycle as the controller updates txrd to
1436 * the current txwr could hang the can controller
1437 */
1438 if (priv->need_txbug_workaround) {
1439 txrd = grcan_read_reg(&regs->txrd);
1440 if (unlikely(grcan_ring_sub(txwr, txrd, dma->tx.size) == 1)) {
1441 netdev_tx_t txstatus;
1442
1443 err = grcan_txbug_workaround(dev, skb, txwr,
1444 oneshotmode, &txstatus);
1445 if (err)
1446 return txstatus;
1447 }
1448 }
1449
1450 /* Prepare skb for echoing. This must be after the bug workaround above
1451 * as ownership of the skb is passed on by calling can_put_echo_skb.
1452 * Returning NETDEV_TX_BUSY or accessing skb or cf after a call to
1453 * can_put_echo_skb would be an error unless other measures are
1454 * taken.
1455 */
1456 priv->txdlc[slotindex] = cf->can_dlc; /* Store dlc for statistics */
1457 can_put_echo_skb(skb, dev, slotindex);
1458
1459 /* Make sure everything is written before allowing hardware to
1460 * read from the memory
1461 */
1462 wmb();
1463
1464 /* Update write pointer to start transmission */
1465 grcan_write_reg(&regs->txwr,
1466 grcan_ring_add(txwr, GRCAN_MSG_SIZE, dma->tx.size));
1467
1468 return NETDEV_TX_OK;
1469}
1470
1471/* ========== Setting up sysfs interface and module parameters ========== */
1472
1473#define GRCAN_NOT_BOOL(unsigned_val) ((unsigned_val) > 1)
1474
1475#define GRCAN_MODULE_PARAM(name, mtype, valcheckf, desc) \
1476 static void grcan_sanitize_##name(struct platform_device *pd) \
1477 { \
1478 struct grcan_device_config grcan_default_config \
1479 = GRCAN_DEFAULT_DEVICE_CONFIG; \
1480 if (valcheckf(grcan_module_config.name)) { \
1481 dev_err(&pd->dev, \
1482 "Invalid module parameter value for " \
1483 #name " - setting default\n"); \
1484 grcan_module_config.name = \
1485 grcan_default_config.name; \
1486 } \
1487 } \
1488 module_param_named(name, grcan_module_config.name, \
1489 mtype, S_IRUGO); \
1490 MODULE_PARM_DESC(name, desc)
1491
1492#define GRCAN_CONFIG_ATTR(name, desc) \
1493 static ssize_t grcan_store_##name(struct device *sdev, \
1494 struct device_attribute *att, \
1495 const char *buf, \
1496 size_t count) \
1497 { \
1498 struct net_device *dev = to_net_dev(sdev); \
1499 struct grcan_priv *priv = netdev_priv(dev); \
1500 u8 val; \
1501 int ret; \
1502 if (dev->flags & IFF_UP) \
1503 return -EBUSY; \
1504 ret = kstrtou8(buf, 0, &val); \
1505 if (ret < 0 || val > 1) \
1506 return -EINVAL; \
1507 priv->config.name = val; \
1508 return count; \
1509 } \
1510 static ssize_t grcan_show_##name(struct device *sdev, \
1511 struct device_attribute *att, \
1512 char *buf) \
1513 { \
1514 struct net_device *dev = to_net_dev(sdev); \
1515 struct grcan_priv *priv = netdev_priv(dev); \
1516 return sprintf(buf, "%d\n", priv->config.name); \
1517 } \
1518 static DEVICE_ATTR(name, S_IRUGO | S_IWUSR, \
1519 grcan_show_##name, \
1520 grcan_store_##name); \
1521 GRCAN_MODULE_PARAM(name, ushort, GRCAN_NOT_BOOL, desc)
1522
1523/* The following configuration options are made available both via module
1524 * parameters and writable sysfs files. See the chapter about GRCAN in the
1525 * documentation for the GRLIB VHDL library for further details.
1526 */
1527GRCAN_CONFIG_ATTR(enable0,
1528 "Configuration of physical interface 0. Determines\n" \
1529 "the \"Enable 0\" bit of the configuration register.\n" \
1530 "Format: 0 | 1\nDefault: 0\n");
1531
1532GRCAN_CONFIG_ATTR(enable1,
1533 "Configuration of physical interface 1. Determines\n" \
1534 "the \"Enable 1\" bit of the configuration register.\n" \
1535 "Format: 0 | 1\nDefault: 0\n");
1536
1537GRCAN_CONFIG_ATTR(select,
1538 "Select which physical interface to use.\n" \
1539 "Format: 0 | 1\nDefault: 0\n");
1540
1541/* The tx and rx buffer size configuration options are only available via module
1542 * parameters.
1543 */
1544GRCAN_MODULE_PARAM(txsize, uint, GRCAN_INVALID_BUFFER_SIZE,
1545 "Sets the size of the tx buffer.\n" \
1546 "Format: <unsigned int> where (txsize & ~0x1fffc0) == 0\n" \
1547 "Default: 1024\n");
1548GRCAN_MODULE_PARAM(rxsize, uint, GRCAN_INVALID_BUFFER_SIZE,
1549 "Sets the size of the rx buffer.\n" \
1550 "Format: <unsigned int> where (size & ~0x1fffc0) == 0\n" \
1551 "Default: 1024\n");
1552
1553/* Function that makes sure that configuration done using
1554 * module parameters are set to valid values
1555 */
1556static void grcan_sanitize_module_config(struct platform_device *ofdev)
1557{
1558 grcan_sanitize_enable0(ofdev);
1559 grcan_sanitize_enable1(ofdev);
1560 grcan_sanitize_select(ofdev);
1561 grcan_sanitize_txsize(ofdev);
1562 grcan_sanitize_rxsize(ofdev);
1563}
1564
1565static const struct attribute *const sysfs_grcan_attrs[] = {
1566 /* Config attrs */
1567 &dev_attr_enable0.attr,
1568 &dev_attr_enable1.attr,
1569 &dev_attr_select.attr,
1570 NULL,
1571};
1572
1573static const struct attribute_group sysfs_grcan_group = {
1574 .name = "grcan",
1575 .attrs = (struct attribute **)sysfs_grcan_attrs,
1576};
1577
1578/* ========== Setting up the driver ========== */
1579
1580static const struct net_device_ops grcan_netdev_ops = {
1581 .ndo_open = grcan_open,
1582 .ndo_stop = grcan_close,
1583 .ndo_start_xmit = grcan_start_xmit,
1584};
1585
1586static int grcan_setup_netdev(struct platform_device *ofdev,
1587 void __iomem *base,
1588 int irq, u32 ambafreq, bool txbug)
1589{
1590 struct net_device *dev;
1591 struct grcan_priv *priv;
1592 struct grcan_registers __iomem *regs;
1593 int err;
1594
1595 dev = alloc_candev(sizeof(struct grcan_priv), 0);
1596 if (!dev)
1597 return -ENOMEM;
1598
1599 dev->irq = irq;
1600 dev->flags |= IFF_ECHO;
1601 dev->netdev_ops = &grcan_netdev_ops;
1602 dev->sysfs_groups[0] = &sysfs_grcan_group;
1603
1604 priv = netdev_priv(dev);
1605 memcpy(&priv->config, &grcan_module_config,
1606 sizeof(struct grcan_device_config));
1607 priv->dev = dev;
1608 priv->regs = base;
1609 priv->can.bittiming_const = &grcan_bittiming_const;
1610 priv->can.do_set_bittiming = grcan_set_bittiming;
1611 priv->can.do_set_mode = grcan_set_mode;
1612 priv->can.do_get_berr_counter = grcan_get_berr_counter;
1613 priv->can.clock.freq = ambafreq;
1614 priv->can.ctrlmode_supported =
1615 CAN_CTRLMODE_LISTENONLY | CAN_CTRLMODE_ONE_SHOT;
1616 priv->need_txbug_workaround = txbug;
1617
1618 /* Discover if triple sampling is supported by hardware */
1619 regs = priv->regs;
1620 grcan_set_bits(&regs->ctrl, GRCAN_CTRL_RESET);
1621 grcan_set_bits(&regs->conf, GRCAN_CONF_SAM);
1622 if (grcan_read_bits(&regs->conf, GRCAN_CONF_SAM)) {
1623 priv->can.ctrlmode_supported |= CAN_CTRLMODE_3_SAMPLES;
1624 dev_dbg(&ofdev->dev, "Hardware supports triple-sampling\n");
1625 }
1626
1627 spin_lock_init(&priv->lock);
1628
1629 if (priv->need_txbug_workaround) {
1630 init_timer(&priv->rr_timer);
1631 priv->rr_timer.function = grcan_running_reset;
1632 priv->rr_timer.data = (unsigned long)dev;
1633
1634 init_timer(&priv->hang_timer);
1635 priv->hang_timer.function = grcan_initiate_running_reset;
1636 priv->hang_timer.data = (unsigned long)dev;
1637 }
1638
1639 netif_napi_add(dev, &priv->napi, grcan_poll, GRCAN_NAPI_WEIGHT);
1640
1641 SET_NETDEV_DEV(dev, &ofdev->dev);
1642 dev_info(&ofdev->dev, "regs=0x%p, irq=%d, clock=%d\n",
1643 priv->regs, dev->irq, priv->can.clock.freq);
1644
1645 err = register_candev(dev);
1646 if (err)
1647 goto exit_free_candev;
1648
1649 dev_set_drvdata(&ofdev->dev, dev);
1650
1651 /* Reset device to allow bit-timing to be set. No need to call
1652 * grcan_reset at this stage. That is done in grcan_open.
1653 */
1654 grcan_write_reg(&regs->ctrl, GRCAN_CTRL_RESET);
1655
1656 return 0;
1657exit_free_candev:
1658 free_candev(dev);
1659 return err;
1660}
1661
1662static int grcan_probe(struct platform_device *ofdev)
1663{
1664 struct device_node *np = ofdev->dev.of_node;
1665 struct resource *res;
1666 u32 sysid, ambafreq;
1667 int irq, err;
1668 void __iomem *base;
1669 bool txbug = true;
1670
1671 /* Compare GRLIB version number with the first that does not
1672 * have the tx bug (see start_xmit)
1673 */
1674 err = of_property_read_u32(np, "systemid", &sysid);
1675 if (!err && ((sysid & GRLIB_VERSION_MASK)
1676 >= GRCAN_TXBUG_SAFE_GRLIB_VERSION))
1677 txbug = false;
1678
1679 err = of_property_read_u32(np, "freq", &ambafreq);
1680 if (err) {
1681 dev_err(&ofdev->dev, "unable to fetch \"freq\" property\n");
1682 goto exit_error;
1683 }
1684
1685 res = platform_get_resource(ofdev, IORESOURCE_MEM, 0);
1686 base = devm_request_and_ioremap(&ofdev->dev, res);
1687 if (!base) {
1688 dev_err(&ofdev->dev, "couldn't map IO resource\n");
1689 err = -EADDRNOTAVAIL;
1690 goto exit_error;
1691 }
1692
1693 irq = irq_of_parse_and_map(np, GRCAN_IRQIX_IRQ);
1694 if (!irq) {
1695 dev_err(&ofdev->dev, "no irq found\n");
1696 err = -ENODEV;
1697 goto exit_error;
1698 }
1699
1700 grcan_sanitize_module_config(ofdev);
1701
1702 err = grcan_setup_netdev(ofdev, base, irq, ambafreq, txbug);
1703 if (err)
1704 goto exit_dispose_irq;
1705
1706 return 0;
1707
1708exit_dispose_irq:
1709 irq_dispose_mapping(irq);
1710exit_error:
1711 dev_err(&ofdev->dev,
1712 "%s socket CAN driver initialization failed with error %d\n",
1713 DRV_NAME, err);
1714 return err;
1715}
1716
1717static int grcan_remove(struct platform_device *ofdev)
1718{
1719 struct net_device *dev = dev_get_drvdata(&ofdev->dev);
1720 struct grcan_priv *priv = netdev_priv(dev);
1721
1722 unregister_candev(dev); /* Will in turn call grcan_close */
1723
1724 irq_dispose_mapping(dev->irq);
1725 dev_set_drvdata(&ofdev->dev, NULL);
1726 netif_napi_del(&priv->napi);
1727 free_candev(dev);
1728
1729 return 0;
1730}
1731
1732static struct of_device_id grcan_match[] = {
1733 {.name = "GAISLER_GRCAN"},
1734 {.name = "01_03d"},
1735 {.name = "GAISLER_GRHCAN"},
1736 {.name = "01_034"},
1737 {},
1738};
1739
1740MODULE_DEVICE_TABLE(of, grcan_match);
1741
1742static struct platform_driver grcan_driver = {
1743 .driver = {
1744 .name = DRV_NAME,
1745 .owner = THIS_MODULE,
1746 .of_match_table = grcan_match,
1747 },
1748 .probe = grcan_probe,
1749 .remove = grcan_remove,
1750};
1751
1752module_platform_driver(grcan_driver);
1753
1754MODULE_AUTHOR("Aeroflex Gaisler AB.");
1755MODULE_DESCRIPTION("Socket CAN driver for Aeroflex Gaisler GRCAN");
1756MODULE_LICENSE("GPL");
diff --git a/drivers/net/can/janz-ican3.c b/drivers/net/can/janz-ican3.c
index c4bc1d2e203..32778d56d33 100644
--- a/drivers/net/can/janz-ican3.c
+++ b/drivers/net/can/janz-ican3.c
@@ -116,7 +116,6 @@
116#define ICAN3_BUSERR_QUOTA_MAX 255 116#define ICAN3_BUSERR_QUOTA_MAX 255
117 117
118/* Janz ICAN3 CAN Frame Conversion */ 118/* Janz ICAN3 CAN Frame Conversion */
119#define ICAN3_SNGL 0x02
120#define ICAN3_ECHO 0x10 119#define ICAN3_ECHO 0x10
121#define ICAN3_EFF_RTR 0x40 120#define ICAN3_EFF_RTR 0x40
122#define ICAN3_SFF_RTR 0x10 121#define ICAN3_SFF_RTR 0x10
@@ -221,9 +220,6 @@ struct ican3_dev {
221 /* old and new style host interface */ 220 /* old and new style host interface */
222 unsigned int iftype; 221 unsigned int iftype;
223 222
224 /* queue for echo packets */
225 struct sk_buff_head echoq;
226
227 /* 223 /*
228 * Any function which changes the current DPM page must hold this 224 * Any function which changes the current DPM page must hold this
229 * lock while it is performing data accesses. This ensures that the 225 * lock while it is performing data accesses. This ensures that the
@@ -239,6 +235,7 @@ struct ican3_dev {
239 235
240 /* fast host interface */ 236 /* fast host interface */
241 unsigned int fastrx_start; 237 unsigned int fastrx_start;
238 unsigned int fastrx_int;
242 unsigned int fastrx_num; 239 unsigned int fastrx_num;
243 unsigned int fasttx_start; 240 unsigned int fasttx_start;
244 unsigned int fasttx_num; 241 unsigned int fasttx_num;
@@ -365,7 +362,7 @@ static int ican3_old_send_msg(struct ican3_dev *mod, struct ican3_msg *msg)
365 * ICAN3 "new-style" Host Interface Setup 362 * ICAN3 "new-style" Host Interface Setup
366 */ 363 */
367 364
368static void ican3_init_new_host_interface(struct ican3_dev *mod) 365static void __devinit ican3_init_new_host_interface(struct ican3_dev *mod)
369{ 366{
370 struct ican3_new_desc desc; 367 struct ican3_new_desc desc;
371 unsigned long flags; 368 unsigned long flags;
@@ -444,7 +441,7 @@ static void ican3_init_new_host_interface(struct ican3_dev *mod)
444 * ICAN3 Fast Host Interface Setup 441 * ICAN3 Fast Host Interface Setup
445 */ 442 */
446 443
447static void ican3_init_fast_host_interface(struct ican3_dev *mod) 444static void __devinit ican3_init_fast_host_interface(struct ican3_dev *mod)
448{ 445{
449 struct ican3_fast_desc desc; 446 struct ican3_fast_desc desc;
450 unsigned long flags; 447 unsigned long flags;
@@ -457,6 +454,7 @@ static void ican3_init_fast_host_interface(struct ican3_dev *mod)
457 /* save the start recv page */ 454 /* save the start recv page */
458 mod->fastrx_start = mod->free_page; 455 mod->fastrx_start = mod->free_page;
459 mod->fastrx_num = 0; 456 mod->fastrx_num = 0;
457 mod->fastrx_int = 0;
460 458
461 /* build a single fast tohost queue descriptor */ 459 /* build a single fast tohost queue descriptor */
462 memset(&desc, 0, sizeof(desc)); 460 memset(&desc, 0, sizeof(desc));
@@ -631,7 +629,7 @@ static int ican3_recv_msg(struct ican3_dev *mod, struct ican3_msg *msg)
631 * Quick Pre-constructed Messages 629 * Quick Pre-constructed Messages
632 */ 630 */
633 631
634static int ican3_msg_connect(struct ican3_dev *mod) 632static int __devinit ican3_msg_connect(struct ican3_dev *mod)
635{ 633{
636 struct ican3_msg msg; 634 struct ican3_msg msg;
637 635
@@ -642,7 +640,7 @@ static int ican3_msg_connect(struct ican3_dev *mod)
642 return ican3_send_msg(mod, &msg); 640 return ican3_send_msg(mod, &msg);
643} 641}
644 642
645static int ican3_msg_disconnect(struct ican3_dev *mod) 643static int __devexit ican3_msg_disconnect(struct ican3_dev *mod)
646{ 644{
647 struct ican3_msg msg; 645 struct ican3_msg msg;
648 646
@@ -653,7 +651,7 @@ static int ican3_msg_disconnect(struct ican3_dev *mod)
653 return ican3_send_msg(mod, &msg); 651 return ican3_send_msg(mod, &msg);
654} 652}
655 653
656static int ican3_msg_newhostif(struct ican3_dev *mod) 654static int __devinit ican3_msg_newhostif(struct ican3_dev *mod)
657{ 655{
658 struct ican3_msg msg; 656 struct ican3_msg msg;
659 int ret; 657 int ret;
@@ -674,7 +672,7 @@ static int ican3_msg_newhostif(struct ican3_dev *mod)
674 return 0; 672 return 0;
675} 673}
676 674
677static int ican3_msg_fasthostif(struct ican3_dev *mod) 675static int __devinit ican3_msg_fasthostif(struct ican3_dev *mod)
678{ 676{
679 struct ican3_msg msg; 677 struct ican3_msg msg;
680 unsigned int addr; 678 unsigned int addr;
@@ -707,7 +705,7 @@ static int ican3_msg_fasthostif(struct ican3_dev *mod)
707 * Setup the CAN filter to either accept or reject all 705 * Setup the CAN filter to either accept or reject all
708 * messages from the CAN bus. 706 * messages from the CAN bus.
709 */ 707 */
710static int ican3_set_id_filter(struct ican3_dev *mod, bool accept) 708static int __devinit ican3_set_id_filter(struct ican3_dev *mod, bool accept)
711{ 709{
712 struct ican3_msg msg; 710 struct ican3_msg msg;
713 int ret; 711 int ret;
@@ -815,10 +813,10 @@ static void ican3_to_can_frame(struct ican3_dev *mod,
815 813
816 cf->can_id |= desc->data[0] << 3; 814 cf->can_id |= desc->data[0] << 3;
817 cf->can_id |= (desc->data[1] & 0xe0) >> 5; 815 cf->can_id |= (desc->data[1] & 0xe0) >> 5;
818 cf->can_dlc = get_can_dlc(desc->data[1] & ICAN3_CAN_DLC_MASK); 816 cf->can_dlc = desc->data[1] & ICAN3_CAN_DLC_MASK;
819 memcpy(cf->data, &desc->data[2], cf->can_dlc); 817 memcpy(cf->data, &desc->data[2], sizeof(cf->data));
820 } else { 818 } else {
821 cf->can_dlc = get_can_dlc(desc->data[0] & ICAN3_CAN_DLC_MASK); 819 cf->can_dlc = desc->data[0] & ICAN3_CAN_DLC_MASK;
822 if (desc->data[0] & ICAN3_EFF_RTR) 820 if (desc->data[0] & ICAN3_EFF_RTR)
823 cf->can_id |= CAN_RTR_FLAG; 821 cf->can_id |= CAN_RTR_FLAG;
824 822
@@ -833,7 +831,7 @@ static void ican3_to_can_frame(struct ican3_dev *mod,
833 cf->can_id |= desc->data[3] >> 5; /* 2-0 */ 831 cf->can_id |= desc->data[3] >> 5; /* 2-0 */
834 } 832 }
835 833
836 memcpy(cf->data, &desc->data[6], cf->can_dlc); 834 memcpy(cf->data, &desc->data[6], sizeof(cf->data));
837 } 835 }
838} 836}
839 837
@@ -849,10 +847,6 @@ static void can_frame_to_ican3(struct ican3_dev *mod,
849 desc->data[0] |= cf->can_dlc; 847 desc->data[0] |= cf->can_dlc;
850 desc->data[1] |= ICAN3_ECHO; 848 desc->data[1] |= ICAN3_ECHO;
851 849
852 /* support single transmission (no retries) mode */
853 if (mod->can.ctrlmode & CAN_CTRLMODE_ONE_SHOT)
854 desc->data[1] |= ICAN3_SNGL;
855
856 if (cf->can_id & CAN_RTR_FLAG) 850 if (cf->can_id & CAN_RTR_FLAG)
857 desc->data[0] |= ICAN3_EFF_RTR; 851 desc->data[0] |= ICAN3_EFF_RTR;
858 852
@@ -869,7 +863,7 @@ static void can_frame_to_ican3(struct ican3_dev *mod,
869 } 863 }
870 864
871 /* copy the data bits into the descriptor */ 865 /* copy the data bits into the descriptor */
872 memcpy(&desc->data[6], cf->data, cf->can_dlc); 866 memcpy(&desc->data[6], cf->data, sizeof(cf->data));
873} 867}
874 868
875/* 869/*
@@ -915,8 +909,8 @@ static void ican3_handle_msglost(struct ican3_dev *mod, struct ican3_msg *msg)
915 if (skb) { 909 if (skb) {
916 cf->can_id |= CAN_ERR_CRTL; 910 cf->can_id |= CAN_ERR_CRTL;
917 cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW; 911 cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW;
918 stats->rx_over_errors++;
919 stats->rx_errors++; 912 stats->rx_errors++;
913 stats->rx_bytes += cf->can_dlc;
920 netif_rx(skb); 914 netif_rx(skb);
921 } 915 }
922} 916}
@@ -933,7 +927,7 @@ static int ican3_handle_cevtind(struct ican3_dev *mod, struct ican3_msg *msg)
933 struct net_device *dev = mod->ndev; 927 struct net_device *dev = mod->ndev;
934 struct net_device_stats *stats = &dev->stats; 928 struct net_device_stats *stats = &dev->stats;
935 enum can_state state = mod->can.state; 929 enum can_state state = mod->can.state;
936 u8 isrc, ecc, status, rxerr, txerr; 930 u8 status, isrc, rxerr, txerr;
937 struct can_frame *cf; 931 struct can_frame *cf;
938 struct sk_buff *skb; 932 struct sk_buff *skb;
939 933
@@ -949,53 +943,15 @@ static int ican3_handle_cevtind(struct ican3_dev *mod, struct ican3_msg *msg)
949 return -EINVAL; 943 return -EINVAL;
950 } 944 }
951 945
946 skb = alloc_can_err_skb(dev, &cf);
947 if (skb == NULL)
948 return -ENOMEM;
949
952 isrc = msg->data[0]; 950 isrc = msg->data[0];
953 ecc = msg->data[2];
954 status = msg->data[3]; 951 status = msg->data[3];
955 rxerr = msg->data[4]; 952 rxerr = msg->data[4];
956 txerr = msg->data[5]; 953 txerr = msg->data[5];
957 954
958 /*
959 * This hardware lacks any support other than bus error messages to
960 * determine if packet transmission has failed.
961 *
962 * When TX errors happen, one echo skb needs to be dropped from the
963 * front of the queue.
964 *
965 * A small bit of code is duplicated here and below, to avoid error
966 * skb allocation when it will just be freed immediately.
967 */
968 if (isrc == CEVTIND_BEI) {
969 int ret;
970 dev_dbg(mod->dev, "bus error interrupt\n");
971
972 /* TX error */
973 if (!(ecc & ECC_DIR)) {
974 kfree_skb(skb_dequeue(&mod->echoq));
975 stats->tx_errors++;
976 } else {
977 stats->rx_errors++;
978 }
979
980 /*
981 * The controller automatically disables bus-error interrupts
982 * and therefore we must re-enable them.
983 */
984 ret = ican3_set_buserror(mod, 1);
985 if (ret) {
986 dev_err(mod->dev, "unable to re-enable bus-error\n");
987 return ret;
988 }
989
990 /* bus error reporting is off, return immediately */
991 if (!(mod->can.ctrlmode & CAN_CTRLMODE_BERR_REPORTING))
992 return 0;
993 }
994
995 skb = alloc_can_err_skb(dev, &cf);
996 if (skb == NULL)
997 return -ENOMEM;
998
999 /* data overrun interrupt */ 955 /* data overrun interrupt */
1000 if (isrc == CEVTIND_DOI || isrc == CEVTIND_LOST) { 956 if (isrc == CEVTIND_DOI || isrc == CEVTIND_LOST) {
1001 dev_dbg(mod->dev, "data overrun interrupt\n"); 957 dev_dbg(mod->dev, "data overrun interrupt\n");
@@ -1024,7 +980,11 @@ static int ican3_handle_cevtind(struct ican3_dev *mod, struct ican3_msg *msg)
1024 980
1025 /* bus error interrupt */ 981 /* bus error interrupt */
1026 if (isrc == CEVTIND_BEI) { 982 if (isrc == CEVTIND_BEI) {
983 u8 ecc = msg->data[2];
984
985 dev_dbg(mod->dev, "bus error interrupt\n");
1027 mod->can.can_stats.bus_error++; 986 mod->can.can_stats.bus_error++;
987 stats->rx_errors++;
1028 cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR; 988 cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR;
1029 989
1030 switch (ecc & ECC_MASK) { 990 switch (ecc & ECC_MASK) {
@@ -1043,7 +1003,7 @@ static int ican3_handle_cevtind(struct ican3_dev *mod, struct ican3_msg *msg)
1043 break; 1003 break;
1044 } 1004 }
1045 1005
1046 if (!(ecc & ECC_DIR)) 1006 if ((ecc & ECC_DIR) == 0)
1047 cf->data[2] |= CAN_ERR_PROT_TX; 1007 cf->data[2] |= CAN_ERR_PROT_TX;
1048 1008
1049 cf->data[6] = txerr; 1009 cf->data[6] = txerr;
@@ -1070,6 +1030,8 @@ static int ican3_handle_cevtind(struct ican3_dev *mod, struct ican3_msg *msg)
1070 } 1030 }
1071 1031
1072 mod->can.state = state; 1032 mod->can.state = state;
1033 stats->rx_errors++;
1034 stats->rx_bytes += cf->can_dlc;
1073 netif_rx(skb); 1035 netif_rx(skb);
1074 return 0; 1036 return 0;
1075} 1037}
@@ -1129,88 +1091,6 @@ static void ican3_handle_message(struct ican3_dev *mod, struct ican3_msg *msg)
1129} 1091}
1130 1092
1131/* 1093/*
1132 * The ican3 needs to store all echo skbs, and therefore cannot
1133 * use the generic infrastructure for this.
1134 */
1135static void ican3_put_echo_skb(struct ican3_dev *mod, struct sk_buff *skb)
1136{
1137 struct sock *srcsk = skb->sk;
1138
1139 if (atomic_read(&skb->users) != 1) {
1140 struct sk_buff *old_skb = skb;
1141
1142 skb = skb_clone(old_skb, GFP_ATOMIC);
1143 kfree_skb(old_skb);
1144 if (!skb)
1145 return;
1146 } else {
1147 skb_orphan(skb);
1148 }
1149
1150 skb->sk = srcsk;
1151
1152 /* save this skb for tx interrupt echo handling */
1153 skb_queue_tail(&mod->echoq, skb);
1154}
1155
1156static unsigned int ican3_get_echo_skb(struct ican3_dev *mod)
1157{
1158 struct sk_buff *skb = skb_dequeue(&mod->echoq);
1159 struct can_frame *cf;
1160 u8 dlc;
1161
1162 /* this should never trigger unless there is a driver bug */
1163 if (!skb) {
1164 netdev_err(mod->ndev, "BUG: echo skb not occupied\n");
1165 return 0;
1166 }
1167
1168 cf = (struct can_frame *)skb->data;
1169 dlc = cf->can_dlc;
1170
1171 /* check flag whether this packet has to be looped back */
1172 if (skb->pkt_type != PACKET_LOOPBACK) {
1173 kfree_skb(skb);
1174 return dlc;
1175 }
1176
1177 skb->protocol = htons(ETH_P_CAN);
1178 skb->pkt_type = PACKET_BROADCAST;
1179 skb->ip_summed = CHECKSUM_UNNECESSARY;
1180 skb->dev = mod->ndev;
1181 netif_receive_skb(skb);
1182 return dlc;
1183}
1184
1185/*
1186 * Compare an skb with an existing echo skb
1187 *
1188 * This function will be used on devices which have a hardware loopback.
1189 * On these devices, this function can be used to compare a received skb
1190 * with the saved echo skbs so that the hardware echo skb can be dropped.
1191 *
1192 * Returns true if the skb's are identical, false otherwise.
1193 */
1194static bool ican3_echo_skb_matches(struct ican3_dev *mod, struct sk_buff *skb)
1195{
1196 struct can_frame *cf = (struct can_frame *)skb->data;
1197 struct sk_buff *echo_skb = skb_peek(&mod->echoq);
1198 struct can_frame *echo_cf;
1199
1200 if (!echo_skb)
1201 return false;
1202
1203 echo_cf = (struct can_frame *)echo_skb->data;
1204 if (cf->can_id != echo_cf->can_id)
1205 return false;
1206
1207 if (cf->can_dlc != echo_cf->can_dlc)
1208 return false;
1209
1210 return memcmp(cf->data, echo_cf->data, cf->can_dlc) == 0;
1211}
1212
1213/*
1214 * Check that there is room in the TX ring to transmit another skb 1094 * Check that there is room in the TX ring to transmit another skb
1215 * 1095 *
1216 * LOCKING: must hold mod->lock 1096 * LOCKING: must hold mod->lock
@@ -1220,10 +1100,6 @@ static bool ican3_txok(struct ican3_dev *mod)
1220 struct ican3_fast_desc __iomem *desc; 1100 struct ican3_fast_desc __iomem *desc;
1221 u8 control; 1101 u8 control;
1222 1102
1223 /* check that we have echo queue space */
1224 if (skb_queue_len(&mod->echoq) >= ICAN3_TX_BUFFERS)
1225 return false;
1226
1227 /* copy the control bits of the descriptor */ 1103 /* copy the control bits of the descriptor */
1228 ican3_set_page(mod, mod->fasttx_start + (mod->fasttx_num / 16)); 1104 ican3_set_page(mod, mod->fasttx_start + (mod->fasttx_num / 16));
1229 desc = mod->dpm + ((mod->fasttx_num % 16) * sizeof(*desc)); 1105 desc = mod->dpm + ((mod->fasttx_num % 16) * sizeof(*desc));
@@ -1274,27 +1150,10 @@ static int ican3_recv_skb(struct ican3_dev *mod)
1274 /* convert the ICAN3 frame into Linux CAN format */ 1150 /* convert the ICAN3 frame into Linux CAN format */
1275 ican3_to_can_frame(mod, &desc, cf); 1151 ican3_to_can_frame(mod, &desc, cf);
1276 1152
1277 /* 1153 /* receive the skb, update statistics */
1278 * If this is an ECHO frame received from the hardware loopback 1154 netif_receive_skb(skb);
1279 * feature, use the skb saved in the ECHO stack instead. This allows
1280 * the Linux CAN core to support CAN_RAW_RECV_OWN_MSGS correctly.
1281 *
1282 * Since this is a confirmation of a successfully transmitted packet
1283 * sent from this host, update the transmit statistics.
1284 *
1285 * Also, the netdevice queue needs to be allowed to send packets again.
1286 */
1287 if (ican3_echo_skb_matches(mod, skb)) {
1288 stats->tx_packets++;
1289 stats->tx_bytes += ican3_get_echo_skb(mod);
1290 kfree_skb(skb);
1291 goto err_noalloc;
1292 }
1293
1294 /* update statistics, receive the skb */
1295 stats->rx_packets++; 1155 stats->rx_packets++;
1296 stats->rx_bytes += cf->can_dlc; 1156 stats->rx_bytes += cf->can_dlc;
1297 netif_receive_skb(skb);
1298 1157
1299err_noalloc: 1158err_noalloc:
1300 /* toggle the valid bit and return the descriptor to the ring */ 1159 /* toggle the valid bit and return the descriptor to the ring */
@@ -1317,13 +1176,13 @@ err_noalloc:
1317static int ican3_napi(struct napi_struct *napi, int budget) 1176static int ican3_napi(struct napi_struct *napi, int budget)
1318{ 1177{
1319 struct ican3_dev *mod = container_of(napi, struct ican3_dev, napi); 1178 struct ican3_dev *mod = container_of(napi, struct ican3_dev, napi);
1179 struct ican3_msg msg;
1320 unsigned long flags; 1180 unsigned long flags;
1321 int received = 0; 1181 int received = 0;
1322 int ret; 1182 int ret;
1323 1183
1324 /* process all communication messages */ 1184 /* process all communication messages */
1325 while (true) { 1185 while (true) {
1326 struct ican3_msg msg;
1327 ret = ican3_recv_msg(mod, &msg); 1186 ret = ican3_recv_msg(mod, &msg);
1328 if (ret) 1187 if (ret)
1329 break; 1188 break;
@@ -1391,6 +1250,7 @@ static irqreturn_t ican3_irq(int irq, void *dev_id)
1391 */ 1250 */
1392static int ican3_reset_module(struct ican3_dev *mod) 1251static int ican3_reset_module(struct ican3_dev *mod)
1393{ 1252{
1253 u8 val = 1 << mod->num;
1394 unsigned long start; 1254 unsigned long start;
1395 u8 runold, runnew; 1255 u8 runold, runnew;
1396 1256
@@ -1404,7 +1264,8 @@ static int ican3_reset_module(struct ican3_dev *mod)
1404 runold = ioread8(mod->dpm + TARGET_RUNNING); 1264 runold = ioread8(mod->dpm + TARGET_RUNNING);
1405 1265
1406 /* reset the module */ 1266 /* reset the module */
1407 iowrite8(0x00, &mod->dpmctrl->hwreset); 1267 iowrite8(val, &mod->ctrl->reset_assert);
1268 iowrite8(val, &mod->ctrl->reset_deassert);
1408 1269
1409 /* wait until the module has finished resetting and is running */ 1270 /* wait until the module has finished resetting and is running */
1410 start = jiffies; 1271 start = jiffies;
@@ -1421,7 +1282,7 @@ static int ican3_reset_module(struct ican3_dev *mod)
1421 return -ETIMEDOUT; 1282 return -ETIMEDOUT;
1422} 1283}
1423 1284
1424static void ican3_shutdown_module(struct ican3_dev *mod) 1285static void __devexit ican3_shutdown_module(struct ican3_dev *mod)
1425{ 1286{
1426 ican3_msg_disconnect(mod); 1287 ican3_msg_disconnect(mod);
1427 ican3_reset_module(mod); 1288 ican3_reset_module(mod);
@@ -1430,7 +1291,7 @@ static void ican3_shutdown_module(struct ican3_dev *mod)
1430/* 1291/*
1431 * Startup an ICAN module, bringing it into fast mode 1292 * Startup an ICAN module, bringing it into fast mode
1432 */ 1293 */
1433static int ican3_startup_module(struct ican3_dev *mod) 1294static int __devinit ican3_startup_module(struct ican3_dev *mod)
1434{ 1295{
1435 int ret; 1296 int ret;
1436 1297
@@ -1464,7 +1325,7 @@ static int ican3_startup_module(struct ican3_dev *mod)
1464 } 1325 }
1465 1326
1466 /* default to "bus errors enabled" */ 1327 /* default to "bus errors enabled" */
1467 ret = ican3_set_buserror(mod, 1); 1328 ret = ican3_set_buserror(mod, ICAN3_BUSERR_QUOTA_MAX);
1468 if (ret) { 1329 if (ret) {
1469 dev_err(mod->dev, "unable to set bus-error\n"); 1330 dev_err(mod->dev, "unable to set bus-error\n");
1470 return ret; 1331 return ret;
@@ -1493,6 +1354,7 @@ static int ican3_startup_module(struct ican3_dev *mod)
1493static int ican3_open(struct net_device *ndev) 1354static int ican3_open(struct net_device *ndev)
1494{ 1355{
1495 struct ican3_dev *mod = netdev_priv(ndev); 1356 struct ican3_dev *mod = netdev_priv(ndev);
1357 u8 quota;
1496 int ret; 1358 int ret;
1497 1359
1498 /* open the CAN layer */ 1360 /* open the CAN layer */
@@ -1502,6 +1364,19 @@ static int ican3_open(struct net_device *ndev)
1502 return ret; 1364 return ret;
1503 } 1365 }
1504 1366
1367 /* set the bus error generation state appropriately */
1368 if (mod->can.ctrlmode & CAN_CTRLMODE_BERR_REPORTING)
1369 quota = ICAN3_BUSERR_QUOTA_MAX;
1370 else
1371 quota = 0;
1372
1373 ret = ican3_set_buserror(mod, quota);
1374 if (ret) {
1375 dev_err(mod->dev, "unable to set bus-error\n");
1376 close_candev(ndev);
1377 return ret;
1378 }
1379
1505 /* bring the bus online */ 1380 /* bring the bus online */
1506 ret = ican3_set_bus_state(mod, true); 1381 ret = ican3_set_bus_state(mod, true);
1507 if (ret) { 1382 if (ret) {
@@ -1533,9 +1408,6 @@ static int ican3_stop(struct net_device *ndev)
1533 return ret; 1408 return ret;
1534 } 1409 }
1535 1410
1536 /* drop all outstanding echo skbs */
1537 skb_queue_purge(&mod->echoq);
1538
1539 /* close the CAN layer */ 1411 /* close the CAN layer */
1540 close_candev(ndev); 1412 close_candev(ndev);
1541 return 0; 1413 return 0;
@@ -1544,19 +1416,18 @@ static int ican3_stop(struct net_device *ndev)
1544static int ican3_xmit(struct sk_buff *skb, struct net_device *ndev) 1416static int ican3_xmit(struct sk_buff *skb, struct net_device *ndev)
1545{ 1417{
1546 struct ican3_dev *mod = netdev_priv(ndev); 1418 struct ican3_dev *mod = netdev_priv(ndev);
1419 struct net_device_stats *stats = &ndev->stats;
1547 struct can_frame *cf = (struct can_frame *)skb->data; 1420 struct can_frame *cf = (struct can_frame *)skb->data;
1548 struct ican3_fast_desc desc; 1421 struct ican3_fast_desc desc;
1549 void __iomem *desc_addr; 1422 void __iomem *desc_addr;
1550 unsigned long flags; 1423 unsigned long flags;
1551 1424
1552 if (can_dropped_invalid_skb(ndev, skb))
1553 return NETDEV_TX_OK;
1554
1555 spin_lock_irqsave(&mod->lock, flags); 1425 spin_lock_irqsave(&mod->lock, flags);
1556 1426
1557 /* check that we can actually transmit */ 1427 /* check that we can actually transmit */
1558 if (!ican3_txok(mod)) { 1428 if (!ican3_txok(mod)) {
1559 dev_err(mod->dev, "BUG: no free descriptors\n"); 1429 dev_err(mod->dev, "no free descriptors, stopping queue\n");
1430 netif_stop_queue(ndev);
1560 spin_unlock_irqrestore(&mod->lock, flags); 1431 spin_unlock_irqrestore(&mod->lock, flags);
1561 return NETDEV_TX_BUSY; 1432 return NETDEV_TX_BUSY;
1562 } 1433 }
@@ -1571,14 +1442,6 @@ static int ican3_xmit(struct sk_buff *skb, struct net_device *ndev)
1571 can_frame_to_ican3(mod, cf, &desc); 1442 can_frame_to_ican3(mod, cf, &desc);
1572 1443
1573 /* 1444 /*
1574 * This hardware doesn't have TX-done notifications, so we'll try and
1575 * emulate it the best we can using ECHO skbs. Add the skb to the ECHO
1576 * stack. Upon packet reception, check if the ECHO skb and received
1577 * skb match, and use that to wake the queue.
1578 */
1579 ican3_put_echo_skb(mod, skb);
1580
1581 /*
1582 * the programming manual says that you must set the IVALID bit, then 1445 * the programming manual says that you must set the IVALID bit, then
1583 * interrupt, then set the valid bit. Quite weird, but it seems to be 1446 * interrupt, then set the valid bit. Quite weird, but it seems to be
1584 * required for this to work 1447 * required for this to work
@@ -1596,7 +1459,19 @@ static int ican3_xmit(struct sk_buff *skb, struct net_device *ndev)
1596 mod->fasttx_num = (desc.control & DESC_WRAP) ? 0 1459 mod->fasttx_num = (desc.control & DESC_WRAP) ? 0
1597 : (mod->fasttx_num + 1); 1460 : (mod->fasttx_num + 1);
1598 1461
1599 /* if there is no free descriptor space, stop the transmit queue */ 1462 /* update statistics */
1463 stats->tx_packets++;
1464 stats->tx_bytes += cf->can_dlc;
1465 kfree_skb(skb);
1466
1467 /*
1468 * This hardware doesn't have TX-done notifications, so we'll try and
1469 * emulate it the best we can using ECHO skbs. Get the next TX
1470 * descriptor, and see if we have room to send. If not, stop the queue.
1471 * It will be woken when the ECHO skb for the current packet is recv'd.
1472 */
1473
1474 /* copy the control bits of the descriptor */
1600 if (!ican3_txok(mod)) 1475 if (!ican3_txok(mod))
1601 netif_stop_queue(ndev); 1476 netif_stop_queue(ndev);
1602 1477
@@ -1615,7 +1490,7 @@ static const struct net_device_ops ican3_netdev_ops = {
1615 */ 1490 */
1616 1491
1617/* This structure was stolen from drivers/net/can/sja1000/sja1000.c */ 1492/* This structure was stolen from drivers/net/can/sja1000/sja1000.c */
1618static const struct can_bittiming_const ican3_bittiming_const = { 1493static struct can_bittiming_const ican3_bittiming_const = {
1619 .name = DRV_NAME, 1494 .name = DRV_NAME,
1620 .tseg1_min = 1, 1495 .tseg1_min = 1,
1621 .tseg1_max = 16, 1496 .tseg1_max = 16,
@@ -1692,7 +1567,7 @@ static int ican3_get_berr_counter(const struct net_device *ndev,
1692 return ret; 1567 return ret;
1693 1568
1694 ret = wait_for_completion_timeout(&mod->buserror_comp, HZ); 1569 ret = wait_for_completion_timeout(&mod->buserror_comp, HZ);
1695 if (ret == 0) { 1570 if (ret <= 0) {
1696 dev_info(mod->dev, "%s timed out\n", __func__); 1571 dev_info(mod->dev, "%s timed out\n", __func__);
1697 return -ETIMEDOUT; 1572 return -ETIMEDOUT;
1698 } 1573 }
@@ -1718,7 +1593,7 @@ static ssize_t ican3_sysfs_show_term(struct device *dev,
1718 return ret; 1593 return ret;
1719 1594
1720 ret = wait_for_completion_timeout(&mod->termination_comp, HZ); 1595 ret = wait_for_completion_timeout(&mod->termination_comp, HZ);
1721 if (ret == 0) { 1596 if (ret <= 0) {
1722 dev_info(mod->dev, "%s timed out\n", __func__); 1597 dev_info(mod->dev, "%s timed out\n", __func__);
1723 return -ETIMEDOUT; 1598 return -ETIMEDOUT;
1724 } 1599 }
@@ -1760,7 +1635,7 @@ static struct attribute_group ican3_sysfs_attr_group = {
1760 * PCI Subsystem 1635 * PCI Subsystem
1761 */ 1636 */
1762 1637
1763static int ican3_probe(struct platform_device *pdev) 1638static int __devinit ican3_probe(struct platform_device *pdev)
1764{ 1639{
1765 struct janz_platform_data *pdata; 1640 struct janz_platform_data *pdata;
1766 struct net_device *ndev; 1641 struct net_device *ndev;
@@ -1792,7 +1667,6 @@ static int ican3_probe(struct platform_device *pdev)
1792 mod->dev = &pdev->dev; 1667 mod->dev = &pdev->dev;
1793 mod->num = pdata->modno; 1668 mod->num = pdata->modno;
1794 netif_napi_add(ndev, &mod->napi, ican3_napi, ICAN3_RX_BUFFERS); 1669 netif_napi_add(ndev, &mod->napi, ican3_napi, ICAN3_RX_BUFFERS);
1795 skb_queue_head_init(&mod->echoq);
1796 spin_lock_init(&mod->lock); 1670 spin_lock_init(&mod->lock);
1797 init_completion(&mod->termination_comp); 1671 init_completion(&mod->termination_comp);
1798 init_completion(&mod->buserror_comp); 1672 init_completion(&mod->buserror_comp);
@@ -1813,8 +1687,7 @@ static int ican3_probe(struct platform_device *pdev)
1813 mod->can.do_set_mode = ican3_set_mode; 1687 mod->can.do_set_mode = ican3_set_mode;
1814 mod->can.do_get_berr_counter = ican3_get_berr_counter; 1688 mod->can.do_get_berr_counter = ican3_get_berr_counter;
1815 mod->can.ctrlmode_supported = CAN_CTRLMODE_3_SAMPLES 1689 mod->can.ctrlmode_supported = CAN_CTRLMODE_3_SAMPLES
1816 | CAN_CTRLMODE_BERR_REPORTING 1690 | CAN_CTRLMODE_BERR_REPORTING;
1817 | CAN_CTRLMODE_ONE_SHOT;
1818 1691
1819 /* find our IRQ number */ 1692 /* find our IRQ number */
1820 mod->irq = platform_get_irq(pdev, 0); 1693 mod->irq = platform_get_irq(pdev, 0);
@@ -1898,7 +1771,7 @@ out_return:
1898 return ret; 1771 return ret;
1899} 1772}
1900 1773
1901static int ican3_remove(struct platform_device *pdev) 1774static int __devexit ican3_remove(struct platform_device *pdev)
1902{ 1775{
1903 struct net_device *ndev = platform_get_drvdata(pdev); 1776 struct net_device *ndev = platform_get_drvdata(pdev);
1904 struct ican3_dev *mod = netdev_priv(ndev); 1777 struct ican3_dev *mod = netdev_priv(ndev);
@@ -1927,12 +1800,23 @@ static struct platform_driver ican3_driver = {
1927 .owner = THIS_MODULE, 1800 .owner = THIS_MODULE,
1928 }, 1801 },
1929 .probe = ican3_probe, 1802 .probe = ican3_probe,
1930 .remove = ican3_remove, 1803 .remove = __devexit_p(ican3_remove),
1931}; 1804};
1932 1805
1933module_platform_driver(ican3_driver); 1806static int __init ican3_init(void)
1807{
1808 return platform_driver_register(&ican3_driver);
1809}
1810
1811static void __exit ican3_exit(void)
1812{
1813 platform_driver_unregister(&ican3_driver);
1814}
1934 1815
1935MODULE_AUTHOR("Ira W. Snyder <iws@ovro.caltech.edu>"); 1816MODULE_AUTHOR("Ira W. Snyder <iws@ovro.caltech.edu>");
1936MODULE_DESCRIPTION("Janz MODULbus VMOD-ICAN3 Driver"); 1817MODULE_DESCRIPTION("Janz MODULbus VMOD-ICAN3 Driver");
1937MODULE_LICENSE("GPL"); 1818MODULE_LICENSE("GPL");
1938MODULE_ALIAS("platform:janz-ican3"); 1819MODULE_ALIAS("platform:janz-ican3");
1820
1821module_init(ican3_init);
1822module_exit(ican3_exit);
diff --git a/drivers/net/can/mcp251x.c b/drivers/net/can/mcp251x.c
index 5eaf47b8e37..330140ee266 100644
--- a/drivers/net/can/mcp251x.c
+++ b/drivers/net/can/mcp251x.c
@@ -83,11 +83,6 @@
83#define INSTRUCTION_LOAD_TXB(n) (0x40 + 2 * (n)) 83#define INSTRUCTION_LOAD_TXB(n) (0x40 + 2 * (n))
84#define INSTRUCTION_READ_RXB(n) (((n) == 0) ? 0x90 : 0x94) 84#define INSTRUCTION_READ_RXB(n) (((n) == 0) ? 0x90 : 0x94)
85#define INSTRUCTION_RESET 0xC0 85#define INSTRUCTION_RESET 0xC0
86#define RTS_TXB0 0x01
87#define RTS_TXB1 0x02
88#define RTS_TXB2 0x04
89#define INSTRUCTION_RTS(n) (0x80 | ((n) & 0x07))
90
91 86
92/* MPC251x registers */ 87/* MPC251x registers */
93#define CANSTAT 0x0e 88#define CANSTAT 0x0e
@@ -219,7 +214,7 @@ static int mcp251x_enable_dma; /* Enable SPI DMA. Default: 0 (Off) */
219module_param(mcp251x_enable_dma, int, S_IRUGO); 214module_param(mcp251x_enable_dma, int, S_IRUGO);
220MODULE_PARM_DESC(mcp251x_enable_dma, "Enable SPI DMA. Default: 0 (Off)"); 215MODULE_PARM_DESC(mcp251x_enable_dma, "Enable SPI DMA. Default: 0 (Off)");
221 216
222static const struct can_bittiming_const mcp251x_bittiming_const = { 217static struct can_bittiming_const mcp251x_bittiming_const = {
223 .name = DEVICE_NAME, 218 .name = DEVICE_NAME,
224 .tseg1_min = 3, 219 .tseg1_min = 3,
225 .tseg1_max = 16, 220 .tseg1_max = 16,
@@ -402,7 +397,6 @@ static void mcp251x_hw_tx_frame(struct spi_device *spi, u8 *buf,
402static void mcp251x_hw_tx(struct spi_device *spi, struct can_frame *frame, 397static void mcp251x_hw_tx(struct spi_device *spi, struct can_frame *frame,
403 int tx_buf_idx) 398 int tx_buf_idx)
404{ 399{
405 struct mcp251x_priv *priv = dev_get_drvdata(&spi->dev);
406 u32 sid, eid, exide, rtr; 400 u32 sid, eid, exide, rtr;
407 u8 buf[SPI_TRANSFER_BUF_LEN]; 401 u8 buf[SPI_TRANSFER_BUF_LEN];
408 402
@@ -424,10 +418,7 @@ static void mcp251x_hw_tx(struct spi_device *spi, struct can_frame *frame,
424 buf[TXBDLC_OFF] = (rtr << DLC_RTR_SHIFT) | frame->can_dlc; 418 buf[TXBDLC_OFF] = (rtr << DLC_RTR_SHIFT) | frame->can_dlc;
425 memcpy(buf + TXBDAT_OFF, frame->data, frame->can_dlc); 419 memcpy(buf + TXBDAT_OFF, frame->data, frame->can_dlc);
426 mcp251x_hw_tx_frame(spi, buf, frame->can_dlc, tx_buf_idx); 420 mcp251x_hw_tx_frame(spi, buf, frame->can_dlc, tx_buf_idx);
427 421 mcp251x_write_reg(spi, TXBCTRL(tx_buf_idx), TXBCTRL_TXREQ);
428 /* use INSTRUCTION_RTS, to avoid "repeated frame problem" */
429 priv->spi_tx_buf[0] = INSTRUCTION_RTS(1 << tx_buf_idx);
430 mcp251x_spi_trans(priv->spi, 1);
431} 422}
432 423
433static void mcp251x_hw_rx_frame(struct spi_device *spi, u8 *buf, 424static void mcp251x_hw_rx_frame(struct spi_device *spi, u8 *buf,
@@ -721,7 +712,8 @@ static void mcp251x_error_skb(struct net_device *net, int can_id, int data1)
721 frame->data[1] = data1; 712 frame->data[1] = data1;
722 netif_rx_ni(skb); 713 netif_rx_ni(skb);
723 } else { 714 } else {
724 netdev_err(net, "cannot allocate error skb\n"); 715 dev_err(&net->dev,
716 "cannot allocate error skb\n");
725 } 717 }
726} 718}
727 719
@@ -981,7 +973,7 @@ static const struct net_device_ops mcp251x_netdev_ops = {
981 .ndo_start_xmit = mcp251x_hard_start_xmit, 973 .ndo_start_xmit = mcp251x_hard_start_xmit,
982}; 974};
983 975
984static int mcp251x_can_probe(struct spi_device *spi) 976static int __devinit mcp251x_can_probe(struct spi_device *spi)
985{ 977{
986 struct net_device *net; 978 struct net_device *net;
987 struct mcp251x_priv *priv; 979 struct mcp251x_priv *priv;
@@ -1029,7 +1021,8 @@ static int mcp251x_can_probe(struct spi_device *spi)
1029 GFP_DMA); 1021 GFP_DMA);
1030 1022
1031 if (priv->spi_tx_buf) { 1023 if (priv->spi_tx_buf) {
1032 priv->spi_rx_buf = (priv->spi_tx_buf + (PAGE_SIZE / 2)); 1024 priv->spi_rx_buf = (u8 *)(priv->spi_tx_buf +
1025 (PAGE_SIZE / 2));
1033 priv->spi_rx_dma = (dma_addr_t)(priv->spi_tx_dma + 1026 priv->spi_rx_dma = (dma_addr_t)(priv->spi_tx_dma +
1034 (PAGE_SIZE / 2)); 1027 (PAGE_SIZE / 2));
1035 } else { 1028 } else {
@@ -1100,7 +1093,7 @@ error_out:
1100 return ret; 1093 return ret;
1101} 1094}
1102 1095
1103static int mcp251x_can_remove(struct spi_device *spi) 1096static int __devexit mcp251x_can_remove(struct spi_device *spi)
1104{ 1097{
1105 struct mcp251x_platform_data *pdata = spi->dev.platform_data; 1098 struct mcp251x_platform_data *pdata = spi->dev.platform_data;
1106 struct mcp251x_priv *priv = dev_get_drvdata(&spi->dev); 1099 struct mcp251x_priv *priv = dev_get_drvdata(&spi->dev);
@@ -1198,7 +1191,7 @@ static struct spi_driver mcp251x_can_driver = {
1198 1191
1199 .id_table = mcp251x_id_table, 1192 .id_table = mcp251x_id_table,
1200 .probe = mcp251x_can_probe, 1193 .probe = mcp251x_can_probe,
1201 .remove = mcp251x_can_remove, 1194 .remove = __devexit_p(mcp251x_can_remove),
1202 .suspend = mcp251x_can_suspend, 1195 .suspend = mcp251x_can_suspend,
1203 .resume = mcp251x_can_resume, 1196 .resume = mcp251x_can_resume,
1204}; 1197};
diff --git a/drivers/net/can/mscan/mpc5xxx_can.c b/drivers/net/can/mscan/mpc5xxx_can.c
index 668850e441d..5fedc337556 100644
--- a/drivers/net/can/mscan/mpc5xxx_can.c
+++ b/drivers/net/can/mscan/mpc5xxx_can.c
@@ -43,13 +43,14 @@ struct mpc5xxx_can_data {
43}; 43};
44 44
45#ifdef CONFIG_PPC_MPC52xx 45#ifdef CONFIG_PPC_MPC52xx
46static struct of_device_id mpc52xx_cdm_ids[] = { 46static struct of_device_id __devinitdata mpc52xx_cdm_ids[] = {
47 { .compatible = "fsl,mpc5200-cdm", }, 47 { .compatible = "fsl,mpc5200-cdm", },
48 {} 48 {}
49}; 49};
50 50
51static u32 mpc52xx_can_get_clock(struct platform_device *ofdev, 51static u32 __devinit mpc52xx_can_get_clock(struct platform_device *ofdev,
52 const char *clock_name, int *mscan_clksrc) 52 const char *clock_name,
53 int *mscan_clksrc)
53{ 54{
54 unsigned int pvr; 55 unsigned int pvr;
55 struct mpc52xx_cdm __iomem *cdm; 56 struct mpc52xx_cdm __iomem *cdm;
@@ -100,8 +101,9 @@ static u32 mpc52xx_can_get_clock(struct platform_device *ofdev,
100 return freq; 101 return freq;
101} 102}
102#else /* !CONFIG_PPC_MPC52xx */ 103#else /* !CONFIG_PPC_MPC52xx */
103static u32 mpc52xx_can_get_clock(struct platform_device *ofdev, 104static u32 __devinit mpc52xx_can_get_clock(struct platform_device *ofdev,
104 const char *clock_name, int *mscan_clksrc) 105 const char *clock_name,
106 int *mscan_clksrc)
105{ 107{
106 return 0; 108 return 0;
107} 109}
@@ -122,13 +124,14 @@ struct mpc512x_clockctl {
122 u32 mccr[4]; /* MSCAN Clk Ctrl Reg 1-3 */ 124 u32 mccr[4]; /* MSCAN Clk Ctrl Reg 1-3 */
123}; 125};
124 126
125static struct of_device_id mpc512x_clock_ids[] = { 127static struct of_device_id __devinitdata mpc512x_clock_ids[] = {
126 { .compatible = "fsl,mpc5121-clock", }, 128 { .compatible = "fsl,mpc5121-clock", },
127 {} 129 {}
128}; 130};
129 131
130static u32 mpc512x_can_get_clock(struct platform_device *ofdev, 132static u32 __devinit mpc512x_can_get_clock(struct platform_device *ofdev,
131 const char *clock_name, int *mscan_clksrc) 133 const char *clock_name,
134 int *mscan_clksrc)
132{ 135{
133 struct mpc512x_clockctl __iomem *clockctl; 136 struct mpc512x_clockctl __iomem *clockctl;
134 struct device_node *np_clock; 137 struct device_node *np_clock;
@@ -178,7 +181,7 @@ static u32 mpc512x_can_get_clock(struct platform_device *ofdev,
178 181
179 if (!clock_name || !strcmp(clock_name, "sys")) { 182 if (!clock_name || !strcmp(clock_name, "sys")) {
180 sys_clk = clk_get(&ofdev->dev, "sys_clk"); 183 sys_clk = clk_get(&ofdev->dev, "sys_clk");
181 if (IS_ERR(sys_clk)) { 184 if (!sys_clk) {
182 dev_err(&ofdev->dev, "couldn't get sys_clk\n"); 185 dev_err(&ofdev->dev, "couldn't get sys_clk\n");
183 goto exit_unmap; 186 goto exit_unmap;
184 } 187 }
@@ -201,7 +204,7 @@ static u32 mpc512x_can_get_clock(struct platform_device *ofdev,
201 204
202 if (clocksrc < 0) { 205 if (clocksrc < 0) {
203 ref_clk = clk_get(&ofdev->dev, "ref_clk"); 206 ref_clk = clk_get(&ofdev->dev, "ref_clk");
204 if (IS_ERR(ref_clk)) { 207 if (!ref_clk) {
205 dev_err(&ofdev->dev, "couldn't get ref_clk\n"); 208 dev_err(&ofdev->dev, "couldn't get ref_clk\n");
206 goto exit_unmap; 209 goto exit_unmap;
207 } 210 }
@@ -236,18 +239,19 @@ exit_put:
236 return freq; 239 return freq;
237} 240}
238#else /* !CONFIG_PPC_MPC512x */ 241#else /* !CONFIG_PPC_MPC512x */
239static u32 mpc512x_can_get_clock(struct platform_device *ofdev, 242static u32 __devinit mpc512x_can_get_clock(struct platform_device *ofdev,
240 const char *clock_name, int *mscan_clksrc) 243 const char *clock_name,
244 int *mscan_clksrc)
241{ 245{
242 return 0; 246 return 0;
243} 247}
244#endif /* CONFIG_PPC_MPC512x */ 248#endif /* CONFIG_PPC_MPC512x */
245 249
246static const struct of_device_id mpc5xxx_can_table[]; 250static struct of_device_id mpc5xxx_can_table[];
247static int mpc5xxx_can_probe(struct platform_device *ofdev) 251static int __devinit mpc5xxx_can_probe(struct platform_device *ofdev)
248{ 252{
249 const struct of_device_id *match; 253 const struct of_device_id *match;
250 const struct mpc5xxx_can_data *data; 254 struct mpc5xxx_can_data *data;
251 struct device_node *np = ofdev->dev.of_node; 255 struct device_node *np = ofdev->dev.of_node;
252 struct net_device *dev; 256 struct net_device *dev;
253 struct mscan_priv *priv; 257 struct mscan_priv *priv;
@@ -319,7 +323,7 @@ exit_unmap_mem:
319 return err; 323 return err;
320} 324}
321 325
322static int mpc5xxx_can_remove(struct platform_device *ofdev) 326static int __devexit mpc5xxx_can_remove(struct platform_device *ofdev)
323{ 327{
324 struct net_device *dev = dev_get_drvdata(&ofdev->dev); 328 struct net_device *dev = dev_get_drvdata(&ofdev->dev);
325 struct mscan_priv *priv = netdev_priv(dev); 329 struct mscan_priv *priv = netdev_priv(dev);
@@ -376,23 +380,22 @@ static int mpc5xxx_can_resume(struct platform_device *ofdev)
376} 380}
377#endif 381#endif
378 382
379static const struct mpc5xxx_can_data mpc5200_can_data = { 383static struct mpc5xxx_can_data __devinitdata mpc5200_can_data = {
380 .type = MSCAN_TYPE_MPC5200, 384 .type = MSCAN_TYPE_MPC5200,
381 .get_clock = mpc52xx_can_get_clock, 385 .get_clock = mpc52xx_can_get_clock,
382}; 386};
383 387
384static const struct mpc5xxx_can_data mpc5121_can_data = { 388static struct mpc5xxx_can_data __devinitdata mpc5121_can_data = {
385 .type = MSCAN_TYPE_MPC5121, 389 .type = MSCAN_TYPE_MPC5121,
386 .get_clock = mpc512x_can_get_clock, 390 .get_clock = mpc512x_can_get_clock,
387}; 391};
388 392
389static const struct of_device_id mpc5xxx_can_table[] = { 393static struct of_device_id __devinitdata mpc5xxx_can_table[] = {
390 { .compatible = "fsl,mpc5200-mscan", .data = &mpc5200_can_data, }, 394 { .compatible = "fsl,mpc5200-mscan", .data = &mpc5200_can_data, },
391 /* Note that only MPC5121 Rev. 2 (and later) is supported */ 395 /* Note that only MPC5121 Rev. 2 (and later) is supported */
392 { .compatible = "fsl,mpc5121-mscan", .data = &mpc5121_can_data, }, 396 { .compatible = "fsl,mpc5121-mscan", .data = &mpc5121_can_data, },
393 {}, 397 {},
394}; 398};
395MODULE_DEVICE_TABLE(of, mpc5xxx_can_table);
396 399
397static struct platform_driver mpc5xxx_can_driver = { 400static struct platform_driver mpc5xxx_can_driver = {
398 .driver = { 401 .driver = {
@@ -401,14 +404,24 @@ static struct platform_driver mpc5xxx_can_driver = {
401 .of_match_table = mpc5xxx_can_table, 404 .of_match_table = mpc5xxx_can_table,
402 }, 405 },
403 .probe = mpc5xxx_can_probe, 406 .probe = mpc5xxx_can_probe,
404 .remove = mpc5xxx_can_remove, 407 .remove = __devexit_p(mpc5xxx_can_remove),
405#ifdef CONFIG_PM 408#ifdef CONFIG_PM
406 .suspend = mpc5xxx_can_suspend, 409 .suspend = mpc5xxx_can_suspend,
407 .resume = mpc5xxx_can_resume, 410 .resume = mpc5xxx_can_resume,
408#endif 411#endif
409}; 412};
410 413
411module_platform_driver(mpc5xxx_can_driver); 414static int __init mpc5xxx_can_init(void)
415{
416 return platform_driver_register(&mpc5xxx_can_driver);
417}
418module_init(mpc5xxx_can_init);
419
420static void __exit mpc5xxx_can_exit(void)
421{
422 platform_driver_unregister(&mpc5xxx_can_driver);
423};
424module_exit(mpc5xxx_can_exit);
412 425
413MODULE_AUTHOR("Wolfgang Grandegger <wg@grandegger.com>"); 426MODULE_AUTHOR("Wolfgang Grandegger <wg@grandegger.com>");
414MODULE_DESCRIPTION("Freescale MPC5xxx CAN driver"); 427MODULE_DESCRIPTION("Freescale MPC5xxx CAN driver");
diff --git a/drivers/net/can/mscan/mscan.c b/drivers/net/can/mscan/mscan.c
index e6b40954e20..4cc6f44c2ba 100644
--- a/drivers/net/can/mscan/mscan.c
+++ b/drivers/net/can/mscan/mscan.c
@@ -34,7 +34,7 @@
34 34
35#include "mscan.h" 35#include "mscan.h"
36 36
37static const struct can_bittiming_const mscan_bittiming_const = { 37static struct can_bittiming_const mscan_bittiming_const = {
38 .name = "mscan", 38 .name = "mscan",
39 .tseg1_min = 4, 39 .tseg1_min = 4,
40 .tseg1_max = 16, 40 .tseg1_max = 16,
@@ -62,7 +62,7 @@ static enum can_state state_map[] = {
62static int mscan_set_mode(struct net_device *dev, u8 mode) 62static int mscan_set_mode(struct net_device *dev, u8 mode)
63{ 63{
64 struct mscan_priv *priv = netdev_priv(dev); 64 struct mscan_priv *priv = netdev_priv(dev);
65 struct mscan_regs __iomem *regs = priv->reg_base; 65 struct mscan_regs *regs = (struct mscan_regs *)priv->reg_base;
66 int ret = 0; 66 int ret = 0;
67 int i; 67 int i;
68 u8 canctl1; 68 u8 canctl1;
@@ -95,9 +95,9 @@ static int mscan_set_mode(struct net_device *dev, u8 mode)
95 * any, at once. 95 * any, at once.
96 */ 96 */
97 if (i >= MSCAN_SET_MODE_RETRIES) 97 if (i >= MSCAN_SET_MODE_RETRIES)
98 netdev_dbg(dev, 98 dev_dbg(dev->dev.parent,
99 "device failed to enter sleep mode. " 99 "device failed to enter sleep mode. "
100 "We proceed anyhow.\n"); 100 "We proceed anyhow.\n");
101 else 101 else
102 priv->can.state = CAN_STATE_SLEEPING; 102 priv->can.state = CAN_STATE_SLEEPING;
103 } 103 }
@@ -138,7 +138,7 @@ static int mscan_set_mode(struct net_device *dev, u8 mode)
138static int mscan_start(struct net_device *dev) 138static int mscan_start(struct net_device *dev)
139{ 139{
140 struct mscan_priv *priv = netdev_priv(dev); 140 struct mscan_priv *priv = netdev_priv(dev);
141 struct mscan_regs __iomem *regs = priv->reg_base; 141 struct mscan_regs *regs = (struct mscan_regs *)priv->reg_base;
142 u8 canrflg; 142 u8 canrflg;
143 int err; 143 int err;
144 144
@@ -178,7 +178,7 @@ static int mscan_restart(struct net_device *dev)
178 struct mscan_priv *priv = netdev_priv(dev); 178 struct mscan_priv *priv = netdev_priv(dev);
179 179
180 if (priv->type == MSCAN_TYPE_MPC5121) { 180 if (priv->type == MSCAN_TYPE_MPC5121) {
181 struct mscan_regs __iomem *regs = priv->reg_base; 181 struct mscan_regs *regs = (struct mscan_regs *)priv->reg_base;
182 182
183 priv->can.state = CAN_STATE_ERROR_ACTIVE; 183 priv->can.state = CAN_STATE_ERROR_ACTIVE;
184 WARN(!(in_8(&regs->canmisc) & MSCAN_BOHOLD), 184 WARN(!(in_8(&regs->canmisc) & MSCAN_BOHOLD),
@@ -199,7 +199,7 @@ static netdev_tx_t mscan_start_xmit(struct sk_buff *skb, struct net_device *dev)
199{ 199{
200 struct can_frame *frame = (struct can_frame *)skb->data; 200 struct can_frame *frame = (struct can_frame *)skb->data;
201 struct mscan_priv *priv = netdev_priv(dev); 201 struct mscan_priv *priv = netdev_priv(dev);
202 struct mscan_regs __iomem *regs = priv->reg_base; 202 struct mscan_regs *regs = (struct mscan_regs *)priv->reg_base;
203 int i, rtr, buf_id; 203 int i, rtr, buf_id;
204 u32 can_id; 204 u32 can_id;
205 205
@@ -213,7 +213,7 @@ static netdev_tx_t mscan_start_xmit(struct sk_buff *skb, struct net_device *dev)
213 switch (hweight8(i)) { 213 switch (hweight8(i)) {
214 case 0: 214 case 0:
215 netif_stop_queue(dev); 215 netif_stop_queue(dev);
216 netdev_err(dev, "Tx Ring full when queue awake!\n"); 216 dev_err(dev->dev.parent, "Tx Ring full when queue awake!\n");
217 return NETDEV_TX_BUSY; 217 return NETDEV_TX_BUSY;
218 case 1: 218 case 1:
219 /* 219 /*
@@ -307,7 +307,7 @@ static enum can_state check_set_state(struct net_device *dev, u8 canrflg)
307static void mscan_get_rx_frame(struct net_device *dev, struct can_frame *frame) 307static void mscan_get_rx_frame(struct net_device *dev, struct can_frame *frame)
308{ 308{
309 struct mscan_priv *priv = netdev_priv(dev); 309 struct mscan_priv *priv = netdev_priv(dev);
310 struct mscan_regs __iomem *regs = priv->reg_base; 310 struct mscan_regs *regs = (struct mscan_regs *)priv->reg_base;
311 u32 can_id; 311 u32 can_id;
312 int i; 312 int i;
313 313
@@ -348,11 +348,11 @@ static void mscan_get_err_frame(struct net_device *dev, struct can_frame *frame,
348 u8 canrflg) 348 u8 canrflg)
349{ 349{
350 struct mscan_priv *priv = netdev_priv(dev); 350 struct mscan_priv *priv = netdev_priv(dev);
351 struct mscan_regs __iomem *regs = priv->reg_base; 351 struct mscan_regs *regs = (struct mscan_regs *)priv->reg_base;
352 struct net_device_stats *stats = &dev->stats; 352 struct net_device_stats *stats = &dev->stats;
353 enum can_state old_state; 353 enum can_state old_state;
354 354
355 netdev_dbg(dev, "error interrupt (canrflg=%#x)\n", canrflg); 355 dev_dbg(dev->dev.parent, "error interrupt (canrflg=%#x)\n", canrflg);
356 frame->can_id = CAN_ERR_FLAG; 356 frame->can_id = CAN_ERR_FLAG;
357 357
358 if (canrflg & MSCAN_OVRIF) { 358 if (canrflg & MSCAN_OVRIF) {
@@ -411,7 +411,7 @@ static int mscan_rx_poll(struct napi_struct *napi, int quota)
411{ 411{
412 struct mscan_priv *priv = container_of(napi, struct mscan_priv, napi); 412 struct mscan_priv *priv = container_of(napi, struct mscan_priv, napi);
413 struct net_device *dev = napi->dev; 413 struct net_device *dev = napi->dev;
414 struct mscan_regs __iomem *regs = priv->reg_base; 414 struct mscan_regs *regs = (struct mscan_regs *)priv->reg_base;
415 struct net_device_stats *stats = &dev->stats; 415 struct net_device_stats *stats = &dev->stats;
416 int npackets = 0; 416 int npackets = 0;
417 int ret = 1; 417 int ret = 1;
@@ -427,7 +427,7 @@ static int mscan_rx_poll(struct napi_struct *napi, int quota)
427 skb = alloc_can_skb(dev, &frame); 427 skb = alloc_can_skb(dev, &frame);
428 if (!skb) { 428 if (!skb) {
429 if (printk_ratelimit()) 429 if (printk_ratelimit())
430 netdev_notice(dev, "packet dropped\n"); 430 dev_notice(dev->dev.parent, "packet dropped\n");
431 stats->rx_dropped++; 431 stats->rx_dropped++;
432 out_8(&regs->canrflg, canrflg); 432 out_8(&regs->canrflg, canrflg);
433 continue; 433 continue;
@@ -458,7 +458,7 @@ static irqreturn_t mscan_isr(int irq, void *dev_id)
458{ 458{
459 struct net_device *dev = (struct net_device *)dev_id; 459 struct net_device *dev = (struct net_device *)dev_id;
460 struct mscan_priv *priv = netdev_priv(dev); 460 struct mscan_priv *priv = netdev_priv(dev);
461 struct mscan_regs __iomem *regs = priv->reg_base; 461 struct mscan_regs *regs = (struct mscan_regs *)priv->reg_base;
462 struct net_device_stats *stats = &dev->stats; 462 struct net_device_stats *stats = &dev->stats;
463 u8 cantier, cantflg, canrflg; 463 u8 cantier, cantflg, canrflg;
464 irqreturn_t ret = IRQ_NONE; 464 irqreturn_t ret = IRQ_NONE;
@@ -517,8 +517,12 @@ static irqreturn_t mscan_isr(int irq, void *dev_id)
517 517
518static int mscan_do_set_mode(struct net_device *dev, enum can_mode mode) 518static int mscan_do_set_mode(struct net_device *dev, enum can_mode mode)
519{ 519{
520 struct mscan_priv *priv = netdev_priv(dev);
520 int ret = 0; 521 int ret = 0;
521 522
523 if (!priv->open_time)
524 return -EINVAL;
525
522 switch (mode) { 526 switch (mode) {
523 case CAN_MODE_START: 527 case CAN_MODE_START:
524 ret = mscan_restart(dev); 528 ret = mscan_restart(dev);
@@ -538,7 +542,7 @@ static int mscan_do_set_mode(struct net_device *dev, enum can_mode mode)
538static int mscan_do_set_bittiming(struct net_device *dev) 542static int mscan_do_set_bittiming(struct net_device *dev)
539{ 543{
540 struct mscan_priv *priv = netdev_priv(dev); 544 struct mscan_priv *priv = netdev_priv(dev);
541 struct mscan_regs __iomem *regs = priv->reg_base; 545 struct mscan_regs *regs = (struct mscan_regs *)priv->reg_base;
542 struct can_bittiming *bt = &priv->can.bittiming; 546 struct can_bittiming *bt = &priv->can.bittiming;
543 u8 btr0, btr1; 547 u8 btr0, btr1;
544 548
@@ -547,7 +551,8 @@ static int mscan_do_set_bittiming(struct net_device *dev)
547 BTR1_SET_TSEG2(bt->phase_seg2) | 551 BTR1_SET_TSEG2(bt->phase_seg2) |
548 BTR1_SET_SAM(priv->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES)); 552 BTR1_SET_SAM(priv->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES));
549 553
550 netdev_info(dev, "setting BTR0=0x%02x BTR1=0x%02x\n", btr0, btr1); 554 dev_info(dev->dev.parent, "setting BTR0=0x%02x BTR1=0x%02x\n",
555 btr0, btr1);
551 556
552 out_8(&regs->canbtr0, btr0); 557 out_8(&regs->canbtr0, btr0);
553 out_8(&regs->canbtr1, btr1); 558 out_8(&regs->canbtr1, btr1);
@@ -555,23 +560,11 @@ static int mscan_do_set_bittiming(struct net_device *dev)
555 return 0; 560 return 0;
556} 561}
557 562
558static int mscan_get_berr_counter(const struct net_device *dev,
559 struct can_berr_counter *bec)
560{
561 struct mscan_priv *priv = netdev_priv(dev);
562 struct mscan_regs __iomem *regs = priv->reg_base;
563
564 bec->txerr = in_8(&regs->cantxerr);
565 bec->rxerr = in_8(&regs->canrxerr);
566
567 return 0;
568}
569
570static int mscan_open(struct net_device *dev) 563static int mscan_open(struct net_device *dev)
571{ 564{
572 int ret; 565 int ret;
573 struct mscan_priv *priv = netdev_priv(dev); 566 struct mscan_priv *priv = netdev_priv(dev);
574 struct mscan_regs __iomem *regs = priv->reg_base; 567 struct mscan_regs *regs = (struct mscan_regs *)priv->reg_base;
575 568
576 /* common open */ 569 /* common open */
577 ret = open_candev(dev); 570 ret = open_candev(dev);
@@ -582,14 +575,13 @@ static int mscan_open(struct net_device *dev)
582 575
583 ret = request_irq(dev->irq, mscan_isr, 0, dev->name, dev); 576 ret = request_irq(dev->irq, mscan_isr, 0, dev->name, dev);
584 if (ret < 0) { 577 if (ret < 0) {
585 netdev_err(dev, "failed to attach interrupt\n"); 578 dev_err(dev->dev.parent, "failed to attach interrupt\n");
586 goto exit_napi_disable; 579 goto exit_napi_disable;
587 } 580 }
588 581
589 if (priv->can.ctrlmode & CAN_CTRLMODE_LISTENONLY) 582 priv->open_time = jiffies;
590 setbits8(&regs->canctl1, MSCAN_LISTEN); 583
591 else 584 clrbits8(&regs->canctl1, MSCAN_LISTEN);
592 clrbits8(&regs->canctl1, MSCAN_LISTEN);
593 585
594 ret = mscan_start(dev); 586 ret = mscan_start(dev);
595 if (ret) 587 if (ret)
@@ -600,6 +592,7 @@ static int mscan_open(struct net_device *dev)
600 return 0; 592 return 0;
601 593
602exit_free_irq: 594exit_free_irq:
595 priv->open_time = 0;
603 free_irq(dev->irq, dev); 596 free_irq(dev->irq, dev);
604exit_napi_disable: 597exit_napi_disable:
605 napi_disable(&priv->napi); 598 napi_disable(&priv->napi);
@@ -610,7 +603,7 @@ exit_napi_disable:
610static int mscan_close(struct net_device *dev) 603static int mscan_close(struct net_device *dev)
611{ 604{
612 struct mscan_priv *priv = netdev_priv(dev); 605 struct mscan_priv *priv = netdev_priv(dev);
613 struct mscan_regs __iomem *regs = priv->reg_base; 606 struct mscan_regs *regs = (struct mscan_regs *)priv->reg_base;
614 607
615 netif_stop_queue(dev); 608 netif_stop_queue(dev);
616 napi_disable(&priv->napi); 609 napi_disable(&priv->napi);
@@ -620,6 +613,7 @@ static int mscan_close(struct net_device *dev)
620 mscan_set_mode(dev, MSCAN_INIT_MODE); 613 mscan_set_mode(dev, MSCAN_INIT_MODE);
621 close_candev(dev); 614 close_candev(dev);
622 free_irq(dev->irq, dev); 615 free_irq(dev->irq, dev);
616 priv->open_time = 0;
623 617
624 return 0; 618 return 0;
625} 619}
@@ -633,7 +627,7 @@ static const struct net_device_ops mscan_netdev_ops = {
633int register_mscandev(struct net_device *dev, int mscan_clksrc) 627int register_mscandev(struct net_device *dev, int mscan_clksrc)
634{ 628{
635 struct mscan_priv *priv = netdev_priv(dev); 629 struct mscan_priv *priv = netdev_priv(dev);
636 struct mscan_regs __iomem *regs = priv->reg_base; 630 struct mscan_regs *regs = (struct mscan_regs *)priv->reg_base;
637 u8 ctl1; 631 u8 ctl1;
638 632
639 ctl1 = in_8(&regs->canctl1); 633 ctl1 = in_8(&regs->canctl1);
@@ -642,10 +636,8 @@ int register_mscandev(struct net_device *dev, int mscan_clksrc)
642 else 636 else
643 ctl1 &= ~MSCAN_CLKSRC; 637 ctl1 &= ~MSCAN_CLKSRC;
644 638
645 if (priv->type == MSCAN_TYPE_MPC5121) { 639 if (priv->type == MSCAN_TYPE_MPC5121)
646 priv->can.do_get_berr_counter = mscan_get_berr_counter;
647 ctl1 |= MSCAN_BORM; /* bus-off recovery upon request */ 640 ctl1 |= MSCAN_BORM; /* bus-off recovery upon request */
648 }
649 641
650 ctl1 |= MSCAN_CANE; 642 ctl1 |= MSCAN_CANE;
651 out_8(&regs->canctl1, ctl1); 643 out_8(&regs->canctl1, ctl1);
@@ -672,7 +664,7 @@ int register_mscandev(struct net_device *dev, int mscan_clksrc)
672void unregister_mscandev(struct net_device *dev) 664void unregister_mscandev(struct net_device *dev)
673{ 665{
674 struct mscan_priv *priv = netdev_priv(dev); 666 struct mscan_priv *priv = netdev_priv(dev);
675 struct mscan_regs __iomem *regs = priv->reg_base; 667 struct mscan_regs *regs = (struct mscan_regs *)priv->reg_base;
676 mscan_set_mode(dev, MSCAN_INIT_MODE); 668 mscan_set_mode(dev, MSCAN_INIT_MODE);
677 clrbits8(&regs->canctl1, MSCAN_CANE); 669 clrbits8(&regs->canctl1, MSCAN_CANE);
678 unregister_candev(dev); 670 unregister_candev(dev);
@@ -698,8 +690,7 @@ struct net_device *alloc_mscandev(void)
698 priv->can.bittiming_const = &mscan_bittiming_const; 690 priv->can.bittiming_const = &mscan_bittiming_const;
699 priv->can.do_set_bittiming = mscan_do_set_bittiming; 691 priv->can.do_set_bittiming = mscan_do_set_bittiming;
700 priv->can.do_set_mode = mscan_do_set_mode; 692 priv->can.do_set_mode = mscan_do_set_mode;
701 priv->can.ctrlmode_supported = CAN_CTRLMODE_3_SAMPLES | 693 priv->can.ctrlmode_supported = CAN_CTRLMODE_3_SAMPLES;
702 CAN_CTRLMODE_LISTENONLY;
703 694
704 for (i = 0; i < TX_QUEUE_SIZE; i++) { 695 for (i = 0; i < TX_QUEUE_SIZE; i++) {
705 priv->tx_queue[i].id = i; 696 priv->tx_queue[i].id = i;
diff --git a/drivers/net/can/mscan/mscan.h b/drivers/net/can/mscan/mscan.h
index af2ed8baf0a..b43e9f5d326 100644
--- a/drivers/net/can/mscan/mscan.h
+++ b/drivers/net/can/mscan/mscan.h
@@ -281,6 +281,7 @@ struct tx_queue_entry {
281struct mscan_priv { 281struct mscan_priv {
282 struct can_priv can; /* must be the first member */ 282 struct can_priv can; /* must be the first member */
283 unsigned int type; /* MSCAN type variants */ 283 unsigned int type; /* MSCAN type variants */
284 long open_time;
284 unsigned long flags; 285 unsigned long flags;
285 void __iomem *reg_base; /* ioremap'ed address to registers */ 286 void __iomem *reg_base; /* ioremap'ed address to registers */
286 u8 shadow_statflg; 287 u8 shadow_statflg;
diff --git a/drivers/net/can/pch_can.c b/drivers/net/can/pch_can.c
index 7d1748575b1..d11fbb2b95f 100644
--- a/drivers/net/can/pch_can.c
+++ b/drivers/net/can/pch_can.c
@@ -1,6 +1,6 @@
1/* 1/*
2 * Copyright (C) 1999 - 2010 Intel Corporation. 2 * Copyright (C) 1999 - 2010 Intel Corporation.
3 * Copyright (C) 2010 LAPIS SEMICONDUCTOR CO., LTD. 3 * Copyright (C) 2010 OKI SEMICONDUCTOR CO., LTD.
4 * 4 *
5 * This program is free software; you can redistribute it and/or modify 5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by 6 * it under the terms of the GNU General Public License as published by
@@ -66,7 +66,6 @@
66#define PCH_IF_CREQ_BUSY BIT(15) 66#define PCH_IF_CREQ_BUSY BIT(15)
67 67
68#define PCH_STATUS_INT 0x8000 68#define PCH_STATUS_INT 0x8000
69#define PCH_RP 0x00008000
70#define PCH_REC 0x00007f00 69#define PCH_REC 0x00007f00
71#define PCH_TEC 0x000000ff 70#define PCH_TEC 0x000000ff
72 71
@@ -184,7 +183,7 @@ struct pch_can_priv {
184 int use_msi; 183 int use_msi;
185}; 184};
186 185
187static const struct can_bittiming_const pch_can_bittiming_const = { 186static struct can_bittiming_const pch_can_bittiming_const = {
188 .name = KBUILD_MODNAME, 187 .name = KBUILD_MODNAME,
189 .tseg1_min = 2, 188 .tseg1_min = 2,
190 .tseg1_max = 16, 189 .tseg1_max = 16,
@@ -528,7 +527,7 @@ static void pch_can_error(struct net_device *ndev, u32 status)
528 priv->can.can_stats.error_passive++; 527 priv->can.can_stats.error_passive++;
529 state = CAN_STATE_ERROR_PASSIVE; 528 state = CAN_STATE_ERROR_PASSIVE;
530 cf->can_id |= CAN_ERR_CRTL; 529 cf->can_id |= CAN_ERR_CRTL;
531 if (errc & PCH_RP) 530 if (((errc & PCH_REC) >> 8) > 127)
532 cf->data[1] |= CAN_ERR_CRTL_RX_PASSIVE; 531 cf->data[1] |= CAN_ERR_CRTL_RX_PASSIVE;
533 if ((errc & PCH_TEC) > 127) 532 if ((errc & PCH_TEC) > 127)
534 cf->data[1] |= CAN_ERR_CRTL_TX_PASSIVE; 533 cf->data[1] |= CAN_ERR_CRTL_TX_PASSIVE;
@@ -954,7 +953,7 @@ static const struct net_device_ops pch_can_netdev_ops = {
954 .ndo_start_xmit = pch_xmit, 953 .ndo_start_xmit = pch_xmit,
955}; 954};
956 955
957static void pch_can_remove(struct pci_dev *pdev) 956static void __devexit pch_can_remove(struct pci_dev *pdev)
958{ 957{
959 struct net_device *ndev = pci_get_drvdata(pdev); 958 struct net_device *ndev = pci_get_drvdata(pdev);
960 struct pch_can_priv *priv = netdev_priv(ndev); 959 struct pch_can_priv *priv = netdev_priv(ndev);
@@ -1178,7 +1177,7 @@ static int pch_can_get_berr_counter(const struct net_device *dev,
1178 return 0; 1177 return 0;
1179} 1178}
1180 1179
1181static int pch_can_probe(struct pci_dev *pdev, 1180static int __devinit pch_can_probe(struct pci_dev *pdev,
1182 const struct pci_device_id *id) 1181 const struct pci_device_id *id)
1183{ 1182{
1184 struct net_device *ndev; 1183 struct net_device *ndev;
@@ -1269,12 +1268,22 @@ static struct pci_driver pch_can_pci_driver = {
1269 .name = "pch_can", 1268 .name = "pch_can",
1270 .id_table = pch_pci_tbl, 1269 .id_table = pch_pci_tbl,
1271 .probe = pch_can_probe, 1270 .probe = pch_can_probe,
1272 .remove = pch_can_remove, 1271 .remove = __devexit_p(pch_can_remove),
1273 .suspend = pch_can_suspend, 1272 .suspend = pch_can_suspend,
1274 .resume = pch_can_resume, 1273 .resume = pch_can_resume,
1275}; 1274};
1276 1275
1277module_pci_driver(pch_can_pci_driver); 1276static int __init pch_can_pci_init(void)
1277{
1278 return pci_register_driver(&pch_can_pci_driver);
1279}
1280module_init(pch_can_pci_init);
1281
1282static void __exit pch_can_pci_exit(void)
1283{
1284 pci_unregister_driver(&pch_can_pci_driver);
1285}
1286module_exit(pch_can_pci_exit);
1278 1287
1279MODULE_DESCRIPTION("Intel EG20T PCH CAN(Controller Area Network) Driver"); 1288MODULE_DESCRIPTION("Intel EG20T PCH CAN(Controller Area Network) Driver");
1280MODULE_LICENSE("GPL v2"); 1289MODULE_LICENSE("GPL v2");
diff --git a/drivers/net/can/sja1000/Kconfig b/drivers/net/can/sja1000/Kconfig
index 92f73c708a3..6fdc031daaa 100644
--- a/drivers/net/can/sja1000/Kconfig
+++ b/drivers/net/can/sja1000/Kconfig
@@ -6,6 +6,7 @@ if CAN_SJA1000
6 6
7config CAN_SJA1000_ISA 7config CAN_SJA1000_ISA
8 tristate "ISA Bus based legacy SJA1000 driver" 8 tristate "ISA Bus based legacy SJA1000 driver"
9 depends on ISA
9 ---help--- 10 ---help---
10 This driver adds legacy support for SJA1000 chips connected to 11 This driver adds legacy support for SJA1000 chips connected to
11 the ISA bus using I/O port, memory mapped or indirect access. 12 the ISA bus using I/O port, memory mapped or indirect access.
@@ -21,20 +22,13 @@ config CAN_SJA1000_PLATFORM
21 22
22config CAN_SJA1000_OF_PLATFORM 23config CAN_SJA1000_OF_PLATFORM
23 tristate "Generic OF Platform Bus based SJA1000 driver" 24 tristate "Generic OF Platform Bus based SJA1000 driver"
24 depends on OF 25 depends on PPC_OF
25 ---help--- 26 ---help---
26 This driver adds support for the SJA1000 chips connected to 27 This driver adds support for the SJA1000 chips connected to
27 the OpenFirmware "platform bus" found on embedded systems with 28 the OpenFirmware "platform bus" found on embedded systems with
28 OpenFirmware bindings, e.g. if you have a PowerPC based system 29 OpenFirmware bindings, e.g. if you have a PowerPC based system
29 you may want to enable this option. 30 you may want to enable this option.
30 31
31config CAN_EMS_PCMCIA
32 tristate "EMS CPC-CARD Card"
33 depends on PCMCIA
34 ---help---
35 This driver is for the one or two channel CPC-CARD cards from
36 EMS Dr. Thomas Wuensche (http://www.ems-wuensche.de).
37
38config CAN_EMS_PCI 32config CAN_EMS_PCI
39 tristate "EMS CPC-PCI, CPC-PCIe and CPC-104P Card" 33 tristate "EMS CPC-PCI, CPC-PCIe and CPC-104P Card"
40 depends on PCI 34 depends on PCI
@@ -43,39 +37,11 @@ config CAN_EMS_PCI
43 CPC-PCIe and CPC-104P cards from EMS Dr. Thomas Wuensche 37 CPC-PCIe and CPC-104P cards from EMS Dr. Thomas Wuensche
44 (http://www.ems-wuensche.de). 38 (http://www.ems-wuensche.de).
45 39
46config CAN_PEAK_PCMCIA
47 tristate "PEAK PCAN-PC Card"
48 depends on PCMCIA
49 ---help---
50 This driver is for the PCAN-PC Card PCMCIA adapter (1 or 2 channels)
51 from PEAK-System (http://www.peak-system.com). To compile this
52 driver as a module, choose M here: the module will be called
53 peak_pcmcia.
54
55config CAN_PEAK_PCI
56 tristate "PEAK PCAN-PCI/PCIe/miniPCI Cards"
57 depends on PCI
58 ---help---
59 This driver is for the PCAN-PCI/PCIe/miniPCI cards
60 (1, 2, 3 or 4 channels) from PEAK-System Technik
61 (http://www.peak-system.com).
62
63config CAN_PEAK_PCIEC
64 bool "PEAK PCAN-ExpressCard Cards"
65 depends on CAN_PEAK_PCI
66 select I2C
67 select I2C_ALGOBIT
68 default y
69 ---help---
70 Say Y here if you want to use a PCAN-ExpressCard from PEAK-System
71 Technik. This will also automatically select I2C and I2C_ALGO
72 configuration options.
73
74config CAN_KVASER_PCI 40config CAN_KVASER_PCI
75 tristate "Kvaser PCIcanx and Kvaser PCIcan PCI Cards" 41 tristate "Kvaser PCIcanx and Kvaser PCIcan PCI Cards"
76 depends on PCI 42 depends on PCI
77 ---help--- 43 ---help---
78 This driver is for the PCIcanx and PCIcan cards (1, 2 or 44 This driver is for the the PCIcanx and PCIcan cards (1, 2 or
79 4 channel) from Kvaser (http://www.kvaser.com). 45 4 channel) from Kvaser (http://www.kvaser.com).
80 46
81config CAN_PLX_PCI 47config CAN_PLX_PCI
@@ -92,8 +58,6 @@ config CAN_PLX_PCI
92 - esd CAN-PCIe/2000 58 - esd CAN-PCIe/2000
93 - Marathon CAN-bus-PCI card (http://www.marathon.ru/) 59 - Marathon CAN-bus-PCI card (http://www.marathon.ru/)
94 - TEWS TECHNOLOGIES TPMC810 card (http://www.tews.com/) 60 - TEWS TECHNOLOGIES TPMC810 card (http://www.tews.com/)
95 - IXXAT Automation PC-I 04/PCI card (http://www.ixxat.com/)
96 - Connect Tech Inc. CANpro/104-Plus Opto (CRG001) card (http://www.connecttech.com)
97 61
98config CAN_TSCAN1 62config CAN_TSCAN1
99 tristate "TS-CAN1 PC104 boards" 63 tristate "TS-CAN1 PC104 boards"
diff --git a/drivers/net/can/sja1000/Makefile b/drivers/net/can/sja1000/Makefile
index b3d05cbfec3..2c591eb321c 100644
--- a/drivers/net/can/sja1000/Makefile
+++ b/drivers/net/can/sja1000/Makefile
@@ -6,11 +6,8 @@ obj-$(CONFIG_CAN_SJA1000) += sja1000.o
6obj-$(CONFIG_CAN_SJA1000_ISA) += sja1000_isa.o 6obj-$(CONFIG_CAN_SJA1000_ISA) += sja1000_isa.o
7obj-$(CONFIG_CAN_SJA1000_PLATFORM) += sja1000_platform.o 7obj-$(CONFIG_CAN_SJA1000_PLATFORM) += sja1000_platform.o
8obj-$(CONFIG_CAN_SJA1000_OF_PLATFORM) += sja1000_of_platform.o 8obj-$(CONFIG_CAN_SJA1000_OF_PLATFORM) += sja1000_of_platform.o
9obj-$(CONFIG_CAN_EMS_PCMCIA) += ems_pcmcia.o
10obj-$(CONFIG_CAN_EMS_PCI) += ems_pci.o 9obj-$(CONFIG_CAN_EMS_PCI) += ems_pci.o
11obj-$(CONFIG_CAN_KVASER_PCI) += kvaser_pci.o 10obj-$(CONFIG_CAN_KVASER_PCI) += kvaser_pci.o
12obj-$(CONFIG_CAN_PEAK_PCMCIA) += peak_pcmcia.o
13obj-$(CONFIG_CAN_PEAK_PCI) += peak_pci.o
14obj-$(CONFIG_CAN_PLX_PCI) += plx_pci.o 11obj-$(CONFIG_CAN_PLX_PCI) += plx_pci.o
15obj-$(CONFIG_CAN_TSCAN1) += tscan1.o 12obj-$(CONFIG_CAN_TSCAN1) += tscan1.o
16 13
diff --git a/drivers/net/can/sja1000/ems_pci.c b/drivers/net/can/sja1000/ems_pci.c
index 036a326836b..36f4f9780c3 100644
--- a/drivers/net/can/sja1000/ems_pci.c
+++ b/drivers/net/can/sja1000/ems_pci.c
@@ -220,8 +220,8 @@ static void ems_pci_card_reset(struct ems_pci_card *card)
220 * Probe PCI device for EMS CAN signature and register each available 220 * Probe PCI device for EMS CAN signature and register each available
221 * CAN channel to SJA1000 Socket-CAN subsystem. 221 * CAN channel to SJA1000 Socket-CAN subsystem.
222 */ 222 */
223static int ems_pci_add_card(struct pci_dev *pdev, 223static int __devinit ems_pci_add_card(struct pci_dev *pdev,
224 const struct pci_device_id *ent) 224 const struct pci_device_id *ent)
225{ 225{
226 struct sja1000_priv *priv; 226 struct sja1000_priv *priv;
227 struct net_device *dev; 227 struct net_device *dev;
@@ -371,4 +371,16 @@ static struct pci_driver ems_pci_driver = {
371 .remove = ems_pci_del_card, 371 .remove = ems_pci_del_card,
372}; 372};
373 373
374module_pci_driver(ems_pci_driver); 374static int __init ems_pci_init(void)
375{
376 return pci_register_driver(&ems_pci_driver);
377}
378
379static void __exit ems_pci_exit(void)
380{
381 pci_unregister_driver(&ems_pci_driver);
382}
383
384module_init(ems_pci_init);
385module_exit(ems_pci_exit);
386
diff --git a/drivers/net/can/sja1000/ems_pcmcia.c b/drivers/net/can/sja1000/ems_pcmcia.c
deleted file mode 100644
index 5c2f3fbbf5a..00000000000
--- a/drivers/net/can/sja1000/ems_pcmcia.c
+++ /dev/null
@@ -1,330 +0,0 @@
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
30MODULE_AUTHOR("Markus Plessing <plessing@ems-wuensche.com>");
31MODULE_DESCRIPTION("Socket-CAN driver for EMS CPC-CARD cards");
32MODULE_SUPPORTED_DEVICE("EMS CPC-CARD CAN card");
33MODULE_LICENSE("GPL v2");
34
35#define EMS_PCMCIA_MAX_CHAN 2
36
37struct 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
71static 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
77MODULE_DEVICE_TABLE(pcmcia, ems_pcmcia_tbl);
78
79static u8 ems_pcmcia_read_reg(const struct sja1000_priv *priv, int port)
80{
81 return readb(priv->reg_base + port);
82}
83
84static 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
90static 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 */
126static 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
139static 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 */
169static int ems_pcmcia_add_card(struct pcmcia_device *pdev, unsigned long base)
170{
171 struct sja1000_priv *priv;
172 struct net_device *dev;
173 struct ems_pcmcia_card *card;
174 int err, i;
175
176 /* Allocating card structures to hold addresses, ... */
177 card = kzalloc(sizeof(struct ems_pcmcia_card), GFP_KERNEL);
178 if (!card)
179 return -ENOMEM;
180
181 pdev->priv = card;
182 card->channels = 0;
183
184 card->base_addr = ioremap(base, EMS_PCMCIA_MEM_SIZE);
185 if (!card->base_addr) {
186 err = -ENOMEM;
187 goto failure_cleanup;
188 }
189
190 /* Check for unique EMS CAN signature */
191 if (readw(card->base_addr) != 0xAA55) {
192 err = -ENODEV;
193 goto failure_cleanup;
194 }
195
196 /* Request board reset */
197 writeb(EMS_CMD_RESET, card->base_addr);
198
199 /* Make sure CAN controllers are mapped into card's memory space */
200 writeb(EMS_CMD_MAP, card->base_addr);
201
202 /* Detect available channels */
203 for (i = 0; i < EMS_PCMCIA_MAX_CHAN; i++) {
204 dev = alloc_sja1000dev(0);
205 if (!dev) {
206 err = -ENOMEM;
207 goto failure_cleanup;
208 }
209
210 card->net_dev[i] = dev;
211 priv = netdev_priv(dev);
212 priv->priv = card;
213 SET_NETDEV_DEV(dev, &pdev->dev);
214
215 priv->irq_flags = IRQF_SHARED;
216 dev->irq = pdev->irq;
217 priv->reg_base = card->base_addr + EMS_PCMCIA_CAN_BASE_OFFSET +
218 (i * EMS_PCMCIA_CAN_CTRL_SIZE);
219
220 /* Check if channel is present */
221 if (ems_pcmcia_check_chan(priv)) {
222 priv->read_reg = ems_pcmcia_read_reg;
223 priv->write_reg = ems_pcmcia_write_reg;
224 priv->can.clock.freq = EMS_PCMCIA_CAN_CLOCK;
225 priv->ocr = EMS_PCMCIA_OCR;
226 priv->cdr = EMS_PCMCIA_CDR;
227 priv->flags |= SJA1000_CUSTOM_IRQ_HANDLER;
228
229 /* Register SJA1000 device */
230 err = register_sja1000dev(dev);
231 if (err) {
232 free_sja1000dev(dev);
233 goto failure_cleanup;
234 }
235
236 card->channels++;
237
238 printk(KERN_INFO "%s: registered %s on channel "
239 "#%d at 0x%p, irq %d\n", DRV_NAME, dev->name,
240 i, priv->reg_base, dev->irq);
241 } else
242 free_sja1000dev(dev);
243 }
244
245 err = request_irq(dev->irq, &ems_pcmcia_interrupt, IRQF_SHARED,
246 DRV_NAME, card);
247 if (!err)
248 return 0;
249
250failure_cleanup:
251 ems_pcmcia_del_card(pdev);
252 return err;
253}
254
255/*
256 * Setup PCMCIA socket and probe for EMS CPC-CARD
257 */
258static int ems_pcmcia_probe(struct pcmcia_device *dev)
259{
260 int csval;
261
262 /* General socket configuration */
263 dev->config_flags |= CONF_ENABLE_IRQ;
264 dev->config_index = 1;
265 dev->config_regs = PRESENT_OPTION;
266
267 /* The io structure describes IO port mapping */
268 dev->resource[0]->end = 16;
269 dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
270 dev->resource[1]->end = 16;
271 dev->resource[1]->flags |= IO_DATA_PATH_WIDTH_16;
272 dev->io_lines = 5;
273
274 /* Allocate a memory window */
275 dev->resource[2]->flags =
276 (WIN_DATA_WIDTH_8 | WIN_MEMORY_TYPE_CM | WIN_ENABLE);
277 dev->resource[2]->start = dev->resource[2]->end = 0;
278
279 csval = pcmcia_request_window(dev, dev->resource[2], 0);
280 if (csval) {
281 dev_err(&dev->dev, "pcmcia_request_window failed (err=%d)\n",
282 csval);
283 return 0;
284 }
285
286 csval = pcmcia_map_mem_page(dev, dev->resource[2], dev->config_base);
287 if (csval) {
288 dev_err(&dev->dev, "pcmcia_map_mem_page failed (err=%d)\n",
289 csval);
290 return 0;
291 }
292
293 csval = pcmcia_enable_device(dev);
294 if (csval) {
295 dev_err(&dev->dev, "pcmcia_enable_device failed (err=%d)\n",
296 csval);
297 return 0;
298 }
299
300 ems_pcmcia_add_card(dev, dev->resource[2]->start);
301 return 0;
302}
303
304/*
305 * Release claimed resources
306 */
307static void ems_pcmcia_remove(struct pcmcia_device *dev)
308{
309 ems_pcmcia_del_card(dev);
310 pcmcia_disable_device(dev);
311}
312
313static struct pcmcia_driver ems_pcmcia_driver = {
314 .name = DRV_NAME,
315 .probe = ems_pcmcia_probe,
316 .remove = ems_pcmcia_remove,
317 .id_table = ems_pcmcia_tbl,
318};
319
320static int __init ems_pcmcia_init(void)
321{
322 return pcmcia_register_driver(&ems_pcmcia_driver);
323}
324module_init(ems_pcmcia_init);
325
326static void __exit ems_pcmcia_exit(void)
327{
328 pcmcia_unregister_driver(&ems_pcmcia_driver);
329}
330module_exit(ems_pcmcia_exit);
diff --git a/drivers/net/can/sja1000/kvaser_pci.c b/drivers/net/can/sja1000/kvaser_pci.c
index 37b0381f532..ed004cebd31 100644
--- a/drivers/net/can/sja1000/kvaser_pci.c
+++ b/drivers/net/can/sja1000/kvaser_pci.c
@@ -290,8 +290,8 @@ failure:
290 return err; 290 return err;
291} 291}
292 292
293static int kvaser_pci_init_one(struct pci_dev *pdev, 293static int __devinit kvaser_pci_init_one(struct pci_dev *pdev,
294 const struct pci_device_id *ent) 294 const struct pci_device_id *ent)
295{ 295{
296 int err; 296 int err;
297 struct net_device *master_dev = NULL; 297 struct net_device *master_dev = NULL;
@@ -379,7 +379,7 @@ failure:
379 379
380} 380}
381 381
382static void kvaser_pci_remove_one(struct pci_dev *pdev) 382static void __devexit kvaser_pci_remove_one(struct pci_dev *pdev)
383{ 383{
384 struct net_device *dev = pci_get_drvdata(pdev); 384 struct net_device *dev = pci_get_drvdata(pdev);
385 385
@@ -394,7 +394,18 @@ static struct pci_driver kvaser_pci_driver = {
394 .name = DRV_NAME, 394 .name = DRV_NAME,
395 .id_table = kvaser_pci_tbl, 395 .id_table = kvaser_pci_tbl,
396 .probe = kvaser_pci_init_one, 396 .probe = kvaser_pci_init_one,
397 .remove = kvaser_pci_remove_one, 397 .remove = __devexit_p(kvaser_pci_remove_one),
398}; 398};
399 399
400module_pci_driver(kvaser_pci_driver); 400static int __init kvaser_pci_init(void)
401{
402 return pci_register_driver(&kvaser_pci_driver);
403}
404
405static void __exit kvaser_pci_exit(void)
406{
407 pci_unregister_driver(&kvaser_pci_driver);
408}
409
410module_init(kvaser_pci_init);
411module_exit(kvaser_pci_exit);
diff --git a/drivers/net/can/sja1000/peak_pci.c b/drivers/net/can/sja1000/peak_pci.c
deleted file mode 100644
index d84888f03d9..00000000000
--- a/drivers/net/can/sja1000/peak_pci.c
+++ /dev/null
@@ -1,762 +0,0 @@
1/*
2 * Copyright (C) 2007, 2011 Wolfgang Grandegger <wg@grandegger.com>
3 * Copyright (C) 2012 Stephane Grosjean <s.grosjean@peak-system.com>
4 *
5 * Derived from the PCAN project file driver/src/pcan_pci.c:
6 *
7 * Copyright (C) 2001-2006 PEAK System-Technik GmbH
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the version 2 of the GNU General Public License
11 * as published by the Free Software Foundation
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 */
18
19#include <linux/kernel.h>
20#include <linux/module.h>
21#include <linux/interrupt.h>
22#include <linux/netdevice.h>
23#include <linux/delay.h>
24#include <linux/pci.h>
25#include <linux/io.h>
26#include <linux/i2c.h>
27#include <linux/i2c-algo-bit.h>
28#include <linux/can.h>
29#include <linux/can/dev.h>
30
31#include "sja1000.h"
32
33MODULE_AUTHOR("Stephane Grosjean <s.grosjean@peak-system.com>");
34MODULE_DESCRIPTION("Socket-CAN driver for PEAK PCAN PCI family cards");
35MODULE_SUPPORTED_DEVICE("PEAK PCAN PCI/PCIe/PCIeC miniPCI CAN cards");
36MODULE_SUPPORTED_DEVICE("PEAK PCAN miniPCIe/cPCI PC/104+ PCI/104e CAN Cards");
37MODULE_LICENSE("GPL v2");
38
39#define DRV_NAME "peak_pci"
40
41struct peak_pciec_card;
42struct peak_pci_chan {
43 void __iomem *cfg_base; /* Common for all channels */
44 struct net_device *prev_dev; /* Chain of network devices */
45 u16 icr_mask; /* Interrupt mask for fast ack */
46 struct peak_pciec_card *pciec_card; /* only for PCIeC LEDs */
47};
48
49#define PEAK_PCI_CAN_CLOCK (16000000 / 2)
50
51#define PEAK_PCI_CDR (CDR_CBP | CDR_CLKOUT_MASK)
52#define PEAK_PCI_OCR OCR_TX0_PUSHPULL
53
54/*
55 * Important PITA registers
56 */
57#define PITA_ICR 0x00 /* Interrupt control register */
58#define PITA_GPIOICR 0x18 /* GPIO interface control register */
59#define PITA_MISC 0x1C /* Miscellaneous register */
60
61#define PEAK_PCI_CFG_SIZE 0x1000 /* Size of the config PCI bar */
62#define PEAK_PCI_CHAN_SIZE 0x0400 /* Size used by the channel */
63
64#define PEAK_PCI_VENDOR_ID 0x001C /* The PCI device and vendor IDs */
65#define PEAK_PCI_DEVICE_ID 0x0001 /* for PCI/PCIe slot cards */
66#define PEAK_PCIEC_DEVICE_ID 0x0002 /* for ExpressCard slot cards */
67#define PEAK_PCIE_DEVICE_ID 0x0003 /* for nextgen PCIe slot cards */
68#define PEAK_CPCI_DEVICE_ID 0x0004 /* for nextgen cPCI slot cards */
69#define PEAK_MPCI_DEVICE_ID 0x0005 /* for nextgen miniPCI slot cards */
70#define PEAK_PC_104P_DEVICE_ID 0x0006 /* PCAN-PC/104+ cards */
71#define PEAK_PCI_104E_DEVICE_ID 0x0007 /* PCAN-PCI/104 Express cards */
72#define PEAK_MPCIE_DEVICE_ID 0x0008 /* The miniPCIe slot cards */
73
74#define PEAK_PCI_CHAN_MAX 4
75
76static const u16 peak_pci_icr_masks[PEAK_PCI_CHAN_MAX] = {
77 0x02, 0x01, 0x40, 0x80
78};
79
80static DEFINE_PCI_DEVICE_TABLE(peak_pci_tbl) = {
81 {PEAK_PCI_VENDOR_ID, PEAK_PCI_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID,},
82 {PEAK_PCI_VENDOR_ID, PEAK_PCIE_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID,},
83 {PEAK_PCI_VENDOR_ID, PEAK_MPCI_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID,},
84 {PEAK_PCI_VENDOR_ID, PEAK_MPCIE_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID,},
85 {PEAK_PCI_VENDOR_ID, PEAK_PC_104P_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID,},
86 {PEAK_PCI_VENDOR_ID, PEAK_PCI_104E_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID,},
87 {PEAK_PCI_VENDOR_ID, PEAK_CPCI_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID,},
88#ifdef CONFIG_CAN_PEAK_PCIEC
89 {PEAK_PCI_VENDOR_ID, PEAK_PCIEC_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID,},
90#endif
91 {0,}
92};
93
94MODULE_DEVICE_TABLE(pci, peak_pci_tbl);
95
96#ifdef CONFIG_CAN_PEAK_PCIEC
97/*
98 * PCAN-ExpressCard needs I2C bit-banging configuration option.
99 */
100
101/* GPIOICR byte access offsets */
102#define PITA_GPOUT 0x18 /* GPx output value */
103#define PITA_GPIN 0x19 /* GPx input value */
104#define PITA_GPOEN 0x1A /* configure GPx as ouput pin */
105
106/* I2C GP bits */
107#define PITA_GPIN_SCL 0x01 /* Serial Clock Line */
108#define PITA_GPIN_SDA 0x04 /* Serial DAta line */
109
110#define PCA9553_1_SLAVEADDR (0xC4 >> 1)
111
112/* PCA9553 LS0 fields values */
113enum {
114 PCA9553_LOW,
115 PCA9553_HIGHZ,
116 PCA9553_PWM0,
117 PCA9553_PWM1
118};
119
120/* LEDs control */
121#define PCA9553_ON PCA9553_LOW
122#define PCA9553_OFF PCA9553_HIGHZ
123#define PCA9553_SLOW PCA9553_PWM0
124#define PCA9553_FAST PCA9553_PWM1
125
126#define PCA9553_LED(c) (1 << (c))
127#define PCA9553_LED_STATE(s, c) ((s) << ((c) << 1))
128
129#define PCA9553_LED_ON(c) PCA9553_LED_STATE(PCA9553_ON, c)
130#define PCA9553_LED_OFF(c) PCA9553_LED_STATE(PCA9553_OFF, c)
131#define PCA9553_LED_SLOW(c) PCA9553_LED_STATE(PCA9553_SLOW, c)
132#define PCA9553_LED_FAST(c) PCA9553_LED_STATE(PCA9553_FAST, c)
133#define PCA9553_LED_MASK(c) PCA9553_LED_STATE(0x03, c)
134
135#define PCA9553_LED_OFF_ALL (PCA9553_LED_OFF(0) | PCA9553_LED_OFF(1))
136
137#define PCA9553_LS0_INIT 0x40 /* initial value (!= from 0x00) */
138
139struct peak_pciec_chan {
140 struct net_device *netdev;
141 unsigned long prev_rx_bytes;
142 unsigned long prev_tx_bytes;
143};
144
145struct peak_pciec_card {
146 void __iomem *cfg_base; /* Common for all channels */
147 void __iomem *reg_base; /* first channel base address */
148 u8 led_cache; /* leds state cache */
149
150 /* PCIExpressCard i2c data */
151 struct i2c_algo_bit_data i2c_bit;
152 struct i2c_adapter led_chip;
153 struct delayed_work led_work; /* led delayed work */
154 int chan_count;
155 struct peak_pciec_chan channel[PEAK_PCI_CHAN_MAX];
156};
157
158/* "normal" pci register write callback is overloaded for leds control */
159static void peak_pci_write_reg(const struct sja1000_priv *priv,
160 int port, u8 val);
161
162static inline void pita_set_scl_highz(struct peak_pciec_card *card)
163{
164 u8 gp_outen = readb(card->cfg_base + PITA_GPOEN) & ~PITA_GPIN_SCL;
165 writeb(gp_outen, card->cfg_base + PITA_GPOEN);
166}
167
168static inline void pita_set_sda_highz(struct peak_pciec_card *card)
169{
170 u8 gp_outen = readb(card->cfg_base + PITA_GPOEN) & ~PITA_GPIN_SDA;
171 writeb(gp_outen, card->cfg_base + PITA_GPOEN);
172}
173
174static void peak_pciec_init_pita_gpio(struct peak_pciec_card *card)
175{
176 /* raise SCL & SDA GPIOs to high-Z */
177 pita_set_scl_highz(card);
178 pita_set_sda_highz(card);
179}
180
181static void pita_setsda(void *data, int state)
182{
183 struct peak_pciec_card *card = (struct peak_pciec_card *)data;
184 u8 gp_out, gp_outen;
185
186 /* set output sda always to 0 */
187 gp_out = readb(card->cfg_base + PITA_GPOUT) & ~PITA_GPIN_SDA;
188 writeb(gp_out, card->cfg_base + PITA_GPOUT);
189
190 /* control output sda with GPOEN */
191 gp_outen = readb(card->cfg_base + PITA_GPOEN);
192 if (state)
193 gp_outen &= ~PITA_GPIN_SDA;
194 else
195 gp_outen |= PITA_GPIN_SDA;
196
197 writeb(gp_outen, card->cfg_base + PITA_GPOEN);
198}
199
200static void pita_setscl(void *data, int state)
201{
202 struct peak_pciec_card *card = (struct peak_pciec_card *)data;
203 u8 gp_out, gp_outen;
204
205 /* set output scl always to 0 */
206 gp_out = readb(card->cfg_base + PITA_GPOUT) & ~PITA_GPIN_SCL;
207 writeb(gp_out, card->cfg_base + PITA_GPOUT);
208
209 /* control output scl with GPOEN */
210 gp_outen = readb(card->cfg_base + PITA_GPOEN);
211 if (state)
212 gp_outen &= ~PITA_GPIN_SCL;
213 else
214 gp_outen |= PITA_GPIN_SCL;
215
216 writeb(gp_outen, card->cfg_base + PITA_GPOEN);
217}
218
219static int pita_getsda(void *data)
220{
221 struct peak_pciec_card *card = (struct peak_pciec_card *)data;
222
223 /* set tristate */
224 pita_set_sda_highz(card);
225
226 return (readb(card->cfg_base + PITA_GPIN) & PITA_GPIN_SDA) ? 1 : 0;
227}
228
229static int pita_getscl(void *data)
230{
231 struct peak_pciec_card *card = (struct peak_pciec_card *)data;
232
233 /* set tristate */
234 pita_set_scl_highz(card);
235
236 return (readb(card->cfg_base + PITA_GPIN) & PITA_GPIN_SCL) ? 1 : 0;
237}
238
239/*
240 * write commands to the LED chip though the I2C-bus of the PCAN-PCIeC
241 */
242static int peak_pciec_write_pca9553(struct peak_pciec_card *card,
243 u8 offset, u8 data)
244{
245 u8 buffer[2] = {
246 offset,
247 data
248 };
249 struct i2c_msg msg = {
250 .addr = PCA9553_1_SLAVEADDR,
251 .len = 2,
252 .buf = buffer,
253 };
254 int ret;
255
256 /* cache led mask */
257 if ((offset == 5) && (data == card->led_cache))
258 return 0;
259
260 ret = i2c_transfer(&card->led_chip, &msg, 1);
261 if (ret < 0)
262 return ret;
263
264 if (offset == 5)
265 card->led_cache = data;
266
267 return 0;
268}
269
270/*
271 * delayed work callback used to control the LEDs
272 */
273static void peak_pciec_led_work(struct work_struct *work)
274{
275 struct peak_pciec_card *card =
276 container_of(work, struct peak_pciec_card, led_work.work);
277 struct net_device *netdev;
278 u8 new_led = card->led_cache;
279 int i, up_count = 0;
280
281 /* first check what is to do */
282 for (i = 0; i < card->chan_count; i++) {
283 /* default is: not configured */
284 new_led &= ~PCA9553_LED_MASK(i);
285 new_led |= PCA9553_LED_ON(i);
286
287 netdev = card->channel[i].netdev;
288 if (!netdev || !(netdev->flags & IFF_UP))
289 continue;
290
291 up_count++;
292
293 /* no activity (but configured) */
294 new_led &= ~PCA9553_LED_MASK(i);
295 new_led |= PCA9553_LED_SLOW(i);
296
297 /* if bytes counters changed, set fast blinking led */
298 if (netdev->stats.rx_bytes != card->channel[i].prev_rx_bytes) {
299 card->channel[i].prev_rx_bytes = netdev->stats.rx_bytes;
300 new_led &= ~PCA9553_LED_MASK(i);
301 new_led |= PCA9553_LED_FAST(i);
302 }
303 if (netdev->stats.tx_bytes != card->channel[i].prev_tx_bytes) {
304 card->channel[i].prev_tx_bytes = netdev->stats.tx_bytes;
305 new_led &= ~PCA9553_LED_MASK(i);
306 new_led |= PCA9553_LED_FAST(i);
307 }
308 }
309
310 /* check if LS0 settings changed, only update i2c if so */
311 peak_pciec_write_pca9553(card, 5, new_led);
312
313 /* restart timer (except if no more configured channels) */
314 if (up_count)
315 schedule_delayed_work(&card->led_work, HZ);
316}
317
318/*
319 * set LEDs blinking state
320 */
321static void peak_pciec_set_leds(struct peak_pciec_card *card, u8 led_mask, u8 s)
322{
323 u8 new_led = card->led_cache;
324 int i;
325
326 /* first check what is to do */
327 for (i = 0; i < card->chan_count; i++)
328 if (led_mask & PCA9553_LED(i)) {
329 new_led &= ~PCA9553_LED_MASK(i);
330 new_led |= PCA9553_LED_STATE(s, i);
331 }
332
333 /* check if LS0 settings changed, only update i2c if so */
334 peak_pciec_write_pca9553(card, 5, new_led);
335}
336
337/*
338 * start one second delayed work to control LEDs
339 */
340static void peak_pciec_start_led_work(struct peak_pciec_card *card)
341{
342 if (!delayed_work_pending(&card->led_work))
343 schedule_delayed_work(&card->led_work, HZ);
344}
345
346/*
347 * stop LEDs delayed work
348 */
349static void peak_pciec_stop_led_work(struct peak_pciec_card *card)
350{
351 cancel_delayed_work_sync(&card->led_work);
352}
353
354/*
355 * initialize the PCA9553 4-bit I2C-bus LED chip
356 */
357static int peak_pciec_init_leds(struct peak_pciec_card *card)
358{
359 int err;
360
361 /* prescaler for frequency 0: "SLOW" = 1 Hz = "44" */
362 err = peak_pciec_write_pca9553(card, 1, 44 / 1);
363 if (err)
364 return err;
365
366 /* duty cycle 0: 50% */
367 err = peak_pciec_write_pca9553(card, 2, 0x80);
368 if (err)
369 return err;
370
371 /* prescaler for frequency 1: "FAST" = 5 Hz */
372 err = peak_pciec_write_pca9553(card, 3, 44 / 5);
373 if (err)
374 return err;
375
376 /* duty cycle 1: 50% */
377 err = peak_pciec_write_pca9553(card, 4, 0x80);
378 if (err)
379 return err;
380
381 /* switch LEDs to initial state */
382 return peak_pciec_write_pca9553(card, 5, PCA9553_LS0_INIT);
383}
384
385/*
386 * restore LEDs state to off peak_pciec_leds_exit
387 */
388static void peak_pciec_leds_exit(struct peak_pciec_card *card)
389{
390 /* switch LEDs to off */
391 peak_pciec_write_pca9553(card, 5, PCA9553_LED_OFF_ALL);
392}
393
394/*
395 * normal write sja1000 register method overloaded to catch when controller
396 * is started or stopped, to control leds
397 */
398static void peak_pciec_write_reg(const struct sja1000_priv *priv,
399 int port, u8 val)
400{
401 struct peak_pci_chan *chan = priv->priv;
402 struct peak_pciec_card *card = chan->pciec_card;
403 int c = (priv->reg_base - card->reg_base) / PEAK_PCI_CHAN_SIZE;
404
405 /* sja1000 register changes control the leds state */
406 if (port == REG_MOD)
407 switch (val) {
408 case MOD_RM:
409 /* Reset Mode: set led on */
410 peak_pciec_set_leds(card, PCA9553_LED(c), PCA9553_ON);
411 break;
412 case 0x00:
413 /* Normal Mode: led slow blinking and start led timer */
414 peak_pciec_set_leds(card, PCA9553_LED(c), PCA9553_SLOW);
415 peak_pciec_start_led_work(card);
416 break;
417 default:
418 break;
419 }
420
421 /* call base function */
422 peak_pci_write_reg(priv, port, val);
423}
424
425static struct i2c_algo_bit_data peak_pciec_i2c_bit_ops = {
426 .setsda = pita_setsda,
427 .setscl = pita_setscl,
428 .getsda = pita_getsda,
429 .getscl = pita_getscl,
430 .udelay = 10,
431 .timeout = HZ,
432};
433
434static int peak_pciec_probe(struct pci_dev *pdev, struct net_device *dev)
435{
436 struct sja1000_priv *priv = netdev_priv(dev);
437 struct peak_pci_chan *chan = priv->priv;
438 struct peak_pciec_card *card;
439 int err;
440
441 /* copy i2c object address from 1st channel */
442 if (chan->prev_dev) {
443 struct sja1000_priv *prev_priv = netdev_priv(chan->prev_dev);
444 struct peak_pci_chan *prev_chan = prev_priv->priv;
445
446 card = prev_chan->pciec_card;
447 if (!card)
448 return -ENODEV;
449
450 /* channel is the first one: do the init part */
451 } else {
452 /* create the bit banging I2C adapter structure */
453 card = kzalloc(sizeof(struct peak_pciec_card), GFP_KERNEL);
454 if (!card) {
455 dev_err(&pdev->dev,
456 "failed allocating memory for i2c chip\n");
457 return -ENOMEM;
458 }
459
460 card->cfg_base = chan->cfg_base;
461 card->reg_base = priv->reg_base;
462
463 card->led_chip.owner = THIS_MODULE;
464 card->led_chip.dev.parent = &pdev->dev;
465 card->led_chip.algo_data = &card->i2c_bit;
466 strncpy(card->led_chip.name, "peak_i2c",
467 sizeof(card->led_chip.name));
468
469 card->i2c_bit = peak_pciec_i2c_bit_ops;
470 card->i2c_bit.udelay = 10;
471 card->i2c_bit.timeout = HZ;
472 card->i2c_bit.data = card;
473
474 peak_pciec_init_pita_gpio(card);
475
476 err = i2c_bit_add_bus(&card->led_chip);
477 if (err) {
478 dev_err(&pdev->dev, "i2c init failed\n");
479 goto pciec_init_err_1;
480 }
481
482 err = peak_pciec_init_leds(card);
483 if (err) {
484 dev_err(&pdev->dev, "leds hardware init failed\n");
485 goto pciec_init_err_2;
486 }
487
488 INIT_DELAYED_WORK(&card->led_work, peak_pciec_led_work);
489 /* PCAN-ExpressCard needs its own callback for leds */
490 priv->write_reg = peak_pciec_write_reg;
491 }
492
493 chan->pciec_card = card;
494 card->channel[card->chan_count++].netdev = dev;
495
496 return 0;
497
498pciec_init_err_2:
499 i2c_del_adapter(&card->led_chip);
500
501pciec_init_err_1:
502 peak_pciec_init_pita_gpio(card);
503 kfree(card);
504
505 return err;
506}
507
508static void peak_pciec_remove(struct peak_pciec_card *card)
509{
510 peak_pciec_stop_led_work(card);
511 peak_pciec_leds_exit(card);
512 i2c_del_adapter(&card->led_chip);
513 peak_pciec_init_pita_gpio(card);
514 kfree(card);
515}
516
517#else /* CONFIG_CAN_PEAK_PCIEC */
518
519/*
520 * Placebo functions when PCAN-ExpressCard support is not selected
521 */
522static inline int peak_pciec_probe(struct pci_dev *pdev, struct net_device *dev)
523{
524 return -ENODEV;
525}
526
527static inline void peak_pciec_remove(struct peak_pciec_card *card)
528{
529}
530#endif /* CONFIG_CAN_PEAK_PCIEC */
531
532static u8 peak_pci_read_reg(const struct sja1000_priv *priv, int port)
533{
534 return readb(priv->reg_base + (port << 2));
535}
536
537static void peak_pci_write_reg(const struct sja1000_priv *priv,
538 int port, u8 val)
539{
540 writeb(val, priv->reg_base + (port << 2));
541}
542
543static void peak_pci_post_irq(const struct sja1000_priv *priv)
544{
545 struct peak_pci_chan *chan = priv->priv;
546 u16 icr;
547
548 /* Select and clear in PITA stored interrupt */
549 icr = readw(chan->cfg_base + PITA_ICR);
550 if (icr & chan->icr_mask)
551 writew(chan->icr_mask, chan->cfg_base + PITA_ICR);
552}
553
554static int peak_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
555{
556 struct sja1000_priv *priv;
557 struct peak_pci_chan *chan;
558 struct net_device *dev;
559 void __iomem *cfg_base, *reg_base;
560 u16 sub_sys_id, icr;
561 int i, err, channels;
562
563 err = pci_enable_device(pdev);
564 if (err)
565 return err;
566
567 err = pci_request_regions(pdev, DRV_NAME);
568 if (err)
569 goto failure_disable_pci;
570
571 err = pci_read_config_word(pdev, 0x2e, &sub_sys_id);
572 if (err)
573 goto failure_release_regions;
574
575 dev_dbg(&pdev->dev, "probing device %04x:%04x:%04x\n",
576 pdev->vendor, pdev->device, sub_sys_id);
577
578 err = pci_write_config_word(pdev, 0x44, 0);
579 if (err)
580 goto failure_release_regions;
581
582 if (sub_sys_id >= 12)
583 channels = 4;
584 else if (sub_sys_id >= 10)
585 channels = 3;
586 else if (sub_sys_id >= 4)
587 channels = 2;
588 else
589 channels = 1;
590
591 cfg_base = pci_iomap(pdev, 0, PEAK_PCI_CFG_SIZE);
592 if (!cfg_base) {
593 dev_err(&pdev->dev, "failed to map PCI resource #0\n");
594 err = -ENOMEM;
595 goto failure_release_regions;
596 }
597
598 reg_base = pci_iomap(pdev, 1, PEAK_PCI_CHAN_SIZE * channels);
599 if (!reg_base) {
600 dev_err(&pdev->dev, "failed to map PCI resource #1\n");
601 err = -ENOMEM;
602 goto failure_unmap_cfg_base;
603 }
604
605 /* Set GPIO control register */
606 writew(0x0005, cfg_base + PITA_GPIOICR + 2);
607 /* Enable all channels of this card */
608 writeb(0x00, cfg_base + PITA_GPIOICR);
609 /* Toggle reset */
610 writeb(0x05, cfg_base + PITA_MISC + 3);
611 mdelay(5);
612 /* Leave parport mux mode */
613 writeb(0x04, cfg_base + PITA_MISC + 3);
614
615 icr = readw(cfg_base + PITA_ICR + 2);
616
617 for (i = 0; i < channels; i++) {
618 dev = alloc_sja1000dev(sizeof(struct peak_pci_chan));
619 if (!dev) {
620 err = -ENOMEM;
621 goto failure_remove_channels;
622 }
623
624 priv = netdev_priv(dev);
625 chan = priv->priv;
626
627 chan->cfg_base = cfg_base;
628 priv->reg_base = reg_base + i * PEAK_PCI_CHAN_SIZE;
629
630 priv->read_reg = peak_pci_read_reg;
631 priv->write_reg = peak_pci_write_reg;
632 priv->post_irq = peak_pci_post_irq;
633
634 priv->can.clock.freq = PEAK_PCI_CAN_CLOCK;
635 priv->ocr = PEAK_PCI_OCR;
636 priv->cdr = PEAK_PCI_CDR;
637 /* Neither a slave nor a single device distributes the clock */
638 if (channels == 1 || i > 0)
639 priv->cdr |= CDR_CLK_OFF;
640
641 /* Setup interrupt handling */
642 priv->irq_flags = IRQF_SHARED;
643 dev->irq = pdev->irq;
644
645 chan->icr_mask = peak_pci_icr_masks[i];
646 icr |= chan->icr_mask;
647
648 SET_NETDEV_DEV(dev, &pdev->dev);
649
650 /* Create chain of SJA1000 devices */
651 chan->prev_dev = pci_get_drvdata(pdev);
652 pci_set_drvdata(pdev, dev);
653
654 /*
655 * PCAN-ExpressCard needs some additional i2c init.
656 * This must be done *before* register_sja1000dev() but
657 * *after* devices linkage
658 */
659 if (pdev->device == PEAK_PCIEC_DEVICE_ID) {
660 err = peak_pciec_probe(pdev, dev);
661 if (err) {
662 dev_err(&pdev->dev,
663 "failed to probe device (err %d)\n",
664 err);
665 goto failure_free_dev;
666 }
667 }
668
669 err = register_sja1000dev(dev);
670 if (err) {
671 dev_err(&pdev->dev, "failed to register device\n");
672 goto failure_free_dev;
673 }
674
675 dev_info(&pdev->dev,
676 "%s at reg_base=0x%p cfg_base=0x%p irq=%d\n",
677 dev->name, priv->reg_base, chan->cfg_base, dev->irq);
678 }
679
680 /* Enable interrupts */
681 writew(icr, cfg_base + PITA_ICR + 2);
682
683 return 0;
684
685failure_free_dev:
686 pci_set_drvdata(pdev, chan->prev_dev);
687 free_sja1000dev(dev);
688
689failure_remove_channels:
690 /* Disable interrupts */
691 writew(0x0, cfg_base + PITA_ICR + 2);
692
693 chan = NULL;
694 for (dev = pci_get_drvdata(pdev); dev; dev = chan->prev_dev) {
695 unregister_sja1000dev(dev);
696 free_sja1000dev(dev);
697 priv = netdev_priv(dev);
698 chan = priv->priv;
699 }
700
701 /* free any PCIeC resources too */
702 if (chan && chan->pciec_card)
703 peak_pciec_remove(chan->pciec_card);
704
705 pci_iounmap(pdev, reg_base);
706
707failure_unmap_cfg_base:
708 pci_iounmap(pdev, cfg_base);
709
710failure_release_regions:
711 pci_release_regions(pdev);
712
713failure_disable_pci:
714 pci_disable_device(pdev);
715
716 return err;
717}
718
719static void peak_pci_remove(struct pci_dev *pdev)
720{
721 struct net_device *dev = pci_get_drvdata(pdev); /* Last device */
722 struct sja1000_priv *priv = netdev_priv(dev);
723 struct peak_pci_chan *chan = priv->priv;
724 void __iomem *cfg_base = chan->cfg_base;
725 void __iomem *reg_base = priv->reg_base;
726
727 /* Disable interrupts */
728 writew(0x0, cfg_base + PITA_ICR + 2);
729
730 /* Loop over all registered devices */
731 while (1) {
732 dev_info(&pdev->dev, "removing device %s\n", dev->name);
733 unregister_sja1000dev(dev);
734 free_sja1000dev(dev);
735 dev = chan->prev_dev;
736
737 if (!dev) {
738 /* do that only for first channel */
739 if (chan->pciec_card)
740 peak_pciec_remove(chan->pciec_card);
741 break;
742 }
743 priv = netdev_priv(dev);
744 chan = priv->priv;
745 }
746
747 pci_iounmap(pdev, reg_base);
748 pci_iounmap(pdev, cfg_base);
749 pci_release_regions(pdev);
750 pci_disable_device(pdev);
751
752 pci_set_drvdata(pdev, NULL);
753}
754
755static struct pci_driver peak_pci_driver = {
756 .name = DRV_NAME,
757 .id_table = peak_pci_tbl,
758 .probe = peak_pci_probe,
759 .remove = peak_pci_remove,
760};
761
762module_pci_driver(peak_pci_driver);
diff --git a/drivers/net/can/sja1000/peak_pcmcia.c b/drivers/net/can/sja1000/peak_pcmcia.c
deleted file mode 100644
index f1175142b0a..00000000000
--- a/drivers/net/can/sja1000/peak_pcmcia.c
+++ /dev/null
@@ -1,755 +0,0 @@
1/*
2 * Copyright (C) 2010-2012 Stephane Grosjean <s.grosjean@peak-system.com>
3 *
4 * CAN driver for PEAK-System PCAN-PC Card
5 * Derived from the PCAN project file driver/src/pcan_pccard.c
6 * Copyright (C) 2006-2010 PEAK System-Technik GmbH
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the version 2 of the GNU General Public License
10 * as published by the Free Software Foundation
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 */
17#include <linux/kernel.h>
18#include <linux/module.h>
19#include <linux/interrupt.h>
20#include <linux/netdevice.h>
21#include <linux/delay.h>
22#include <linux/timer.h>
23#include <linux/io.h>
24#include <pcmcia/cistpl.h>
25#include <pcmcia/ds.h>
26#include <linux/can.h>
27#include <linux/can/dev.h>
28#include "sja1000.h"
29
30MODULE_AUTHOR("Stephane Grosjean <s.grosjean@peak-system.com>");
31MODULE_DESCRIPTION("CAN driver for PEAK-System PCAN-PC Cards");
32MODULE_LICENSE("GPL v2");
33MODULE_SUPPORTED_DEVICE("PEAK PCAN-PC Card");
34
35/* PEAK-System PCMCIA driver name */
36#define PCC_NAME "peak_pcmcia"
37
38#define PCC_CHAN_MAX 2
39
40#define PCC_CAN_CLOCK (16000000 / 2)
41
42#define PCC_MANF_ID 0x0377
43#define PCC_CARD_ID 0x0001
44
45#define PCC_CHAN_SIZE 0x20
46#define PCC_CHAN_OFF(c) ((c) * PCC_CHAN_SIZE)
47#define PCC_COMN_OFF (PCC_CHAN_OFF(PCC_CHAN_MAX))
48#define PCC_COMN_SIZE 0x40
49
50/* common area registers */
51#define PCC_CCR 0x00
52#define PCC_CSR 0x02
53#define PCC_CPR 0x04
54#define PCC_SPI_DIR 0x06
55#define PCC_SPI_DOR 0x08
56#define PCC_SPI_ADR 0x0a
57#define PCC_SPI_IR 0x0c
58#define PCC_FW_MAJOR 0x10
59#define PCC_FW_MINOR 0x12
60
61/* CCR bits */
62#define PCC_CCR_CLK_16 0x00
63#define PCC_CCR_CLK_10 0x01
64#define PCC_CCR_CLK_21 0x02
65#define PCC_CCR_CLK_8 0x03
66#define PCC_CCR_CLK_MASK PCC_CCR_CLK_8
67
68#define PCC_CCR_RST_CHAN(c) (0x01 << ((c) + 2))
69#define PCC_CCR_RST_ALL (PCC_CCR_RST_CHAN(0) | PCC_CCR_RST_CHAN(1))
70#define PCC_CCR_RST_MASK PCC_CCR_RST_ALL
71
72/* led selection bits */
73#define PCC_LED(c) (1 << (c))
74#define PCC_LED_ALL (PCC_LED(0) | PCC_LED(1))
75
76/* led state value */
77#define PCC_LED_ON 0x00
78#define PCC_LED_FAST 0x01
79#define PCC_LED_SLOW 0x02
80#define PCC_LED_OFF 0x03
81
82#define PCC_CCR_LED_CHAN(s, c) ((s) << (((c) + 2) << 1))
83
84#define PCC_CCR_LED_ON_CHAN(c) PCC_CCR_LED_CHAN(PCC_LED_ON, c)
85#define PCC_CCR_LED_FAST_CHAN(c) PCC_CCR_LED_CHAN(PCC_LED_FAST, c)
86#define PCC_CCR_LED_SLOW_CHAN(c) PCC_CCR_LED_CHAN(PCC_LED_SLOW, c)
87#define PCC_CCR_LED_OFF_CHAN(c) PCC_CCR_LED_CHAN(PCC_LED_OFF, c)
88#define PCC_CCR_LED_MASK_CHAN(c) PCC_CCR_LED_OFF_CHAN(c)
89#define PCC_CCR_LED_OFF_ALL (PCC_CCR_LED_OFF_CHAN(0) | \
90 PCC_CCR_LED_OFF_CHAN(1))
91#define PCC_CCR_LED_MASK PCC_CCR_LED_OFF_ALL
92
93#define PCC_CCR_INIT (PCC_CCR_CLK_16 | PCC_CCR_RST_ALL | PCC_CCR_LED_OFF_ALL)
94
95/* CSR bits */
96#define PCC_CSR_SPI_BUSY 0x04
97
98/* time waiting for SPI busy (prevent from infinite loop) */
99#define PCC_SPI_MAX_BUSY_WAIT_MS 3
100
101/* max count of reading the SPI status register waiting for a change */
102/* (prevent from infinite loop) */
103#define PCC_WRITE_MAX_LOOP 1000
104
105/* max nb of int handled by that isr in one shot (prevent from infinite loop) */
106#define PCC_ISR_MAX_LOOP 10
107
108/* EEPROM chip instruction set */
109/* note: EEPROM Read/Write instructions include A8 bit */
110#define PCC_EEP_WRITE(a) (0x02 | (((a) & 0x100) >> 5))
111#define PCC_EEP_READ(a) (0x03 | (((a) & 0x100) >> 5))
112#define PCC_EEP_WRDI 0x04 /* EEPROM Write Disable */
113#define PCC_EEP_RDSR 0x05 /* EEPROM Read Status Register */
114#define PCC_EEP_WREN 0x06 /* EEPROM Write Enable */
115
116/* EEPROM Status Register bits */
117#define PCC_EEP_SR_WEN 0x02 /* EEPROM SR Write Enable bit */
118#define PCC_EEP_SR_WIP 0x01 /* EEPROM SR Write In Progress bit */
119
120/*
121 * The board configuration is probably following:
122 * RX1 is connected to ground.
123 * TX1 is not connected.
124 * CLKO is not connected.
125 * Setting the OCR register to 0xDA is a good idea.
126 * This means normal output mode, push-pull and the correct polarity.
127 */
128#define PCC_OCR (OCR_TX0_PUSHPULL | OCR_TX1_PUSHPULL)
129
130/*
131 * In the CDR register, you should set CBP to 1.
132 * You will probably also want to set the clock divider value to 7
133 * (meaning direct oscillator output) because the second SJA1000 chip
134 * is driven by the first one CLKOUT output.
135 */
136#define PCC_CDR (CDR_CBP | CDR_CLKOUT_MASK)
137
138struct pcan_channel {
139 struct net_device *netdev;
140 unsigned long prev_rx_bytes;
141 unsigned long prev_tx_bytes;
142};
143
144/* PCAN-PC Card private structure */
145struct pcan_pccard {
146 struct pcmcia_device *pdev;
147 int chan_count;
148 struct pcan_channel channel[PCC_CHAN_MAX];
149 u8 ccr;
150 u8 fw_major;
151 u8 fw_minor;
152 void __iomem *ioport_addr;
153 struct timer_list led_timer;
154};
155
156static struct pcmcia_device_id pcan_table[] = {
157 PCMCIA_DEVICE_MANF_CARD(PCC_MANF_ID, PCC_CARD_ID),
158 PCMCIA_DEVICE_NULL,
159};
160
161MODULE_DEVICE_TABLE(pcmcia, pcan_table);
162
163static void pcan_set_leds(struct pcan_pccard *card, u8 mask, u8 state);
164
165/*
166 * start timer which controls leds state
167 */
168static void pcan_start_led_timer(struct pcan_pccard *card)
169{
170 if (!timer_pending(&card->led_timer))
171 mod_timer(&card->led_timer, jiffies + HZ);
172}
173
174/*
175 * stop the timer which controls leds state
176 */
177static void pcan_stop_led_timer(struct pcan_pccard *card)
178{
179 del_timer_sync(&card->led_timer);
180}
181
182/*
183 * read a sja1000 register
184 */
185static u8 pcan_read_canreg(const struct sja1000_priv *priv, int port)
186{
187 return ioread8(priv->reg_base + port);
188}
189
190/*
191 * write a sja1000 register
192 */
193static void pcan_write_canreg(const struct sja1000_priv *priv, int port, u8 v)
194{
195 struct pcan_pccard *card = priv->priv;
196 int c = (priv->reg_base - card->ioport_addr) / PCC_CHAN_SIZE;
197
198 /* sja1000 register changes control the leds state */
199 if (port == REG_MOD)
200 switch (v) {
201 case MOD_RM:
202 /* Reset Mode: set led on */
203 pcan_set_leds(card, PCC_LED(c), PCC_LED_ON);
204 break;
205 case 0x00:
206 /* Normal Mode: led slow blinking and start led timer */
207 pcan_set_leds(card, PCC_LED(c), PCC_LED_SLOW);
208 pcan_start_led_timer(card);
209 break;
210 default:
211 break;
212 }
213
214 iowrite8(v, priv->reg_base + port);
215}
216
217/*
218 * read a register from the common area
219 */
220static u8 pcan_read_reg(struct pcan_pccard *card, int port)
221{
222 return ioread8(card->ioport_addr + PCC_COMN_OFF + port);
223}
224
225/*
226 * write a register into the common area
227 */
228static void pcan_write_reg(struct pcan_pccard *card, int port, u8 v)
229{
230 /* cache ccr value */
231 if (port == PCC_CCR) {
232 if (card->ccr == v)
233 return;
234 card->ccr = v;
235 }
236
237 iowrite8(v, card->ioport_addr + PCC_COMN_OFF + port);
238}
239
240/*
241 * check whether the card is present by checking its fw version numbers
242 * against values read at probing time.
243 */
244static inline int pcan_pccard_present(struct pcan_pccard *card)
245{
246 return ((pcan_read_reg(card, PCC_FW_MAJOR) == card->fw_major) &&
247 (pcan_read_reg(card, PCC_FW_MINOR) == card->fw_minor));
248}
249
250/*
251 * wait for SPI engine while it is busy
252 */
253static int pcan_wait_spi_busy(struct pcan_pccard *card)
254{
255 unsigned long timeout = jiffies +
256 msecs_to_jiffies(PCC_SPI_MAX_BUSY_WAIT_MS) + 1;
257
258 /* be sure to read status at least once after sleeping */
259 while (pcan_read_reg(card, PCC_CSR) & PCC_CSR_SPI_BUSY) {
260 if (time_after(jiffies, timeout))
261 return -EBUSY;
262 schedule();
263 }
264
265 return 0;
266}
267
268/*
269 * write data in device eeprom
270 */
271static int pcan_write_eeprom(struct pcan_pccard *card, u16 addr, u8 v)
272{
273 u8 status;
274 int err, i;
275
276 /* write instruction enabling write */
277 pcan_write_reg(card, PCC_SPI_IR, PCC_EEP_WREN);
278 err = pcan_wait_spi_busy(card);
279 if (err)
280 goto we_spi_err;
281
282 /* wait until write enabled */
283 for (i = 0; i < PCC_WRITE_MAX_LOOP; i++) {
284 /* write instruction reading the status register */
285 pcan_write_reg(card, PCC_SPI_IR, PCC_EEP_RDSR);
286 err = pcan_wait_spi_busy(card);
287 if (err)
288 goto we_spi_err;
289
290 /* get status register value and check write enable bit */
291 status = pcan_read_reg(card, PCC_SPI_DIR);
292 if (status & PCC_EEP_SR_WEN)
293 break;
294 }
295
296 if (i >= PCC_WRITE_MAX_LOOP) {
297 dev_err(&card->pdev->dev,
298 "stop waiting to be allowed to write in eeprom\n");
299 return -EIO;
300 }
301
302 /* set address and data */
303 pcan_write_reg(card, PCC_SPI_ADR, addr & 0xff);
304 pcan_write_reg(card, PCC_SPI_DOR, v);
305
306 /*
307 * write instruction with bit[3] set according to address value:
308 * if addr refers to upper half of the memory array: bit[3] = 1
309 */
310 pcan_write_reg(card, PCC_SPI_IR, PCC_EEP_WRITE(addr));
311 err = pcan_wait_spi_busy(card);
312 if (err)
313 goto we_spi_err;
314
315 /* wait while write in progress */
316 for (i = 0; i < PCC_WRITE_MAX_LOOP; i++) {
317 /* write instruction reading the status register */
318 pcan_write_reg(card, PCC_SPI_IR, PCC_EEP_RDSR);
319 err = pcan_wait_spi_busy(card);
320 if (err)
321 goto we_spi_err;
322
323 /* get status register value and check write in progress bit */
324 status = pcan_read_reg(card, PCC_SPI_DIR);
325 if (!(status & PCC_EEP_SR_WIP))
326 break;
327 }
328
329 if (i >= PCC_WRITE_MAX_LOOP) {
330 dev_err(&card->pdev->dev,
331 "stop waiting for write in eeprom to complete\n");
332 return -EIO;
333 }
334
335 /* write instruction disabling write */
336 pcan_write_reg(card, PCC_SPI_IR, PCC_EEP_WRDI);
337 err = pcan_wait_spi_busy(card);
338 if (err)
339 goto we_spi_err;
340
341 return 0;
342
343we_spi_err:
344 dev_err(&card->pdev->dev,
345 "stop waiting (spi engine always busy) err %d\n", err);
346
347 return err;
348}
349
350static void pcan_set_leds(struct pcan_pccard *card, u8 led_mask, u8 state)
351{
352 u8 ccr = card->ccr;
353 int i;
354
355 for (i = 0; i < card->chan_count; i++)
356 if (led_mask & PCC_LED(i)) {
357 /* clear corresponding led bits in ccr */
358 ccr &= ~PCC_CCR_LED_MASK_CHAN(i);
359 /* then set new bits */
360 ccr |= PCC_CCR_LED_CHAN(state, i);
361 }
362
363 /* real write only if something has changed in ccr */
364 pcan_write_reg(card, PCC_CCR, ccr);
365}
366
367/*
368 * enable/disable CAN connectors power
369 */
370static inline void pcan_set_can_power(struct pcan_pccard *card, int onoff)
371{
372 int err;
373
374 err = pcan_write_eeprom(card, 0, !!onoff);
375 if (err)
376 dev_err(&card->pdev->dev,
377 "failed setting power %s to can connectors (err %d)\n",
378 (onoff) ? "on" : "off", err);
379}
380
381/*
382 * set leds state according to channel activity
383 */
384static void pcan_led_timer(unsigned long arg)
385{
386 struct pcan_pccard *card = (struct pcan_pccard *)arg;
387 struct net_device *netdev;
388 int i, up_count = 0;
389 u8 ccr;
390
391 ccr = card->ccr;
392 for (i = 0; i < card->chan_count; i++) {
393 /* default is: not configured */
394 ccr &= ~PCC_CCR_LED_MASK_CHAN(i);
395 ccr |= PCC_CCR_LED_ON_CHAN(i);
396
397 netdev = card->channel[i].netdev;
398 if (!netdev || !(netdev->flags & IFF_UP))
399 continue;
400
401 up_count++;
402
403 /* no activity (but configured) */
404 ccr &= ~PCC_CCR_LED_MASK_CHAN(i);
405 ccr |= PCC_CCR_LED_SLOW_CHAN(i);
406
407 /* if bytes counters changed, set fast blinking led */
408 if (netdev->stats.rx_bytes != card->channel[i].prev_rx_bytes) {
409 card->channel[i].prev_rx_bytes = netdev->stats.rx_bytes;
410 ccr &= ~PCC_CCR_LED_MASK_CHAN(i);
411 ccr |= PCC_CCR_LED_FAST_CHAN(i);
412 }
413 if (netdev->stats.tx_bytes != card->channel[i].prev_tx_bytes) {
414 card->channel[i].prev_tx_bytes = netdev->stats.tx_bytes;
415 ccr &= ~PCC_CCR_LED_MASK_CHAN(i);
416 ccr |= PCC_CCR_LED_FAST_CHAN(i);
417 }
418 }
419
420 /* write the new leds state */
421 pcan_write_reg(card, PCC_CCR, ccr);
422
423 /* restart timer (except if no more configured channels) */
424 if (up_count)
425 mod_timer(&card->led_timer, jiffies + HZ);
426}
427
428/*
429 * interrupt service routine
430 */
431static irqreturn_t pcan_isr(int irq, void *dev_id)
432{
433 struct pcan_pccard *card = dev_id;
434 int irq_handled;
435
436 /* prevent from infinite loop */
437 for (irq_handled = 0; irq_handled < PCC_ISR_MAX_LOOP; irq_handled++) {
438 /* handle shared interrupt and next loop */
439 int nothing_to_handle = 1;
440 int i;
441
442 /* check interrupt for each channel */
443 for (i = 0; i < card->chan_count; i++) {
444 struct net_device *netdev;
445
446 /*
447 * check whether the card is present before calling
448 * sja1000_interrupt() to speed up hotplug detection
449 */
450 if (!pcan_pccard_present(card)) {
451 /* card unplugged during isr */
452 return IRQ_NONE;
453 }
454
455 /*
456 * should check whether all or SJA1000_MAX_IRQ
457 * interrupts have been handled: loop again to be sure.
458 */
459 netdev = card->channel[i].netdev;
460 if (netdev &&
461 sja1000_interrupt(irq, netdev) == IRQ_HANDLED)
462 nothing_to_handle = 0;
463 }
464
465 if (nothing_to_handle)
466 break;
467 }
468
469 return (irq_handled) ? IRQ_HANDLED : IRQ_NONE;
470}
471
472/*
473 * free all resources used by the channels and switch off leds and can power
474 */
475static void pcan_free_channels(struct pcan_pccard *card)
476{
477 int i;
478 u8 led_mask = 0;
479
480 for (i = 0; i < card->chan_count; i++) {
481 struct net_device *netdev;
482 char name[IFNAMSIZ];
483
484 led_mask |= PCC_LED(i);
485
486 netdev = card->channel[i].netdev;
487 if (!netdev)
488 continue;
489
490 strncpy(name, netdev->name, IFNAMSIZ);
491
492 unregister_sja1000dev(netdev);
493
494 free_sja1000dev(netdev);
495
496 dev_info(&card->pdev->dev, "%s removed\n", name);
497 }
498
499 /* do it only if device not removed */
500 if (pcan_pccard_present(card)) {
501 pcan_set_leds(card, led_mask, PCC_LED_OFF);
502 pcan_set_can_power(card, 0);
503 }
504}
505
506/*
507 * check if a CAN controller is present at the specified location
508 */
509static inline int pcan_channel_present(struct sja1000_priv *priv)
510{
511 /* make sure SJA1000 is in reset mode */
512 pcan_write_canreg(priv, REG_MOD, 1);
513 pcan_write_canreg(priv, REG_CDR, CDR_PELICAN);
514
515 /* read reset-values */
516 if (pcan_read_canreg(priv, REG_CDR) == CDR_PELICAN)
517 return 1;
518
519 return 0;
520}
521
522static int pcan_add_channels(struct pcan_pccard *card)
523{
524 struct pcmcia_device *pdev = card->pdev;
525 int i, err = 0;
526 u8 ccr = PCC_CCR_INIT;
527
528 /* init common registers (reset channels and leds off) */
529 card->ccr = ~ccr;
530 pcan_write_reg(card, PCC_CCR, ccr);
531
532 /* wait 2ms before unresetting channels */
533 mdelay(2);
534
535 ccr &= ~PCC_CCR_RST_ALL;
536 pcan_write_reg(card, PCC_CCR, ccr);
537
538 /* create one network device per channel detected */
539 for (i = 0; i < ARRAY_SIZE(card->channel); i++) {
540 struct net_device *netdev;
541 struct sja1000_priv *priv;
542
543 netdev = alloc_sja1000dev(0);
544 if (!netdev) {
545 err = -ENOMEM;
546 break;
547 }
548
549 /* update linkages */
550 priv = netdev_priv(netdev);
551 priv->priv = card;
552 SET_NETDEV_DEV(netdev, &pdev->dev);
553
554 priv->irq_flags = IRQF_SHARED;
555 netdev->irq = pdev->irq;
556 priv->reg_base = card->ioport_addr + PCC_CHAN_OFF(i);
557
558 /* check if channel is present */
559 if (!pcan_channel_present(priv)) {
560 dev_err(&pdev->dev, "channel %d not present\n", i);
561 free_sja1000dev(netdev);
562 continue;
563 }
564
565 priv->read_reg = pcan_read_canreg;
566 priv->write_reg = pcan_write_canreg;
567 priv->can.clock.freq = PCC_CAN_CLOCK;
568 priv->ocr = PCC_OCR;
569 priv->cdr = PCC_CDR;
570
571 /* Neither a slave device distributes the clock */
572 if (i > 0)
573 priv->cdr |= CDR_CLK_OFF;
574
575 priv->flags |= SJA1000_CUSTOM_IRQ_HANDLER;
576
577 /* register SJA1000 device */
578 err = register_sja1000dev(netdev);
579 if (err) {
580 free_sja1000dev(netdev);
581 continue;
582 }
583
584 card->channel[i].netdev = netdev;
585 card->chan_count++;
586
587 /* set corresponding led on in the new ccr */
588 ccr &= ~PCC_CCR_LED_OFF_CHAN(i);
589
590 dev_info(&pdev->dev,
591 "%s on channel %d at 0x%p irq %d\n",
592 netdev->name, i, priv->reg_base, pdev->irq);
593 }
594
595 /* write new ccr (change leds state) */
596 pcan_write_reg(card, PCC_CCR, ccr);
597
598 return err;
599}
600
601static int pcan_conf_check(struct pcmcia_device *pdev, void *priv_data)
602{
603 pdev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
604 pdev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8; /* only */
605 pdev->io_lines = 10;
606
607 /* This reserves IO space but doesn't actually enable it */
608 return pcmcia_request_io(pdev);
609}
610
611/*
612 * free all resources used by the device
613 */
614static void pcan_free(struct pcmcia_device *pdev)
615{
616 struct pcan_pccard *card = pdev->priv;
617
618 if (!card)
619 return;
620
621 free_irq(pdev->irq, card);
622 pcan_stop_led_timer(card);
623
624 pcan_free_channels(card);
625
626 ioport_unmap(card->ioport_addr);
627
628 kfree(card);
629 pdev->priv = NULL;
630}
631
632/*
633 * setup PCMCIA socket and probe for PEAK-System PC-CARD
634 */
635static int pcan_probe(struct pcmcia_device *pdev)
636{
637 struct pcan_pccard *card;
638 int err;
639
640 pdev->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_IO;
641
642 err = pcmcia_loop_config(pdev, pcan_conf_check, NULL);
643 if (err) {
644 dev_err(&pdev->dev, "pcmcia_loop_config() error %d\n", err);
645 goto probe_err_1;
646 }
647
648 if (!pdev->irq) {
649 dev_err(&pdev->dev, "no irq assigned\n");
650 err = -ENODEV;
651 goto probe_err_1;
652 }
653
654 err = pcmcia_enable_device(pdev);
655 if (err) {
656 dev_err(&pdev->dev, "pcmcia_enable_device failed err=%d\n",
657 err);
658 goto probe_err_1;
659 }
660
661 card = kzalloc(sizeof(struct pcan_pccard), GFP_KERNEL);
662 if (!card) {
663 dev_err(&pdev->dev, "couldn't allocate card memory\n");
664 err = -ENOMEM;
665 goto probe_err_2;
666 }
667
668 card->pdev = pdev;
669 pdev->priv = card;
670
671 /* sja1000 api uses iomem */
672 card->ioport_addr = ioport_map(pdev->resource[0]->start,
673 resource_size(pdev->resource[0]));
674 if (!card->ioport_addr) {
675 dev_err(&pdev->dev, "couldn't map io port into io memory\n");
676 err = -ENOMEM;
677 goto probe_err_3;
678 }
679 card->fw_major = pcan_read_reg(card, PCC_FW_MAJOR);
680 card->fw_minor = pcan_read_reg(card, PCC_FW_MINOR);
681
682 /* display board name and firware version */
683 dev_info(&pdev->dev, "PEAK-System pcmcia card %s fw %d.%d\n",
684 pdev->prod_id[1] ? pdev->prod_id[1] : "PCAN-PC Card",
685 card->fw_major, card->fw_minor);
686
687 /* detect available channels */
688 pcan_add_channels(card);
689 if (!card->chan_count) {
690 err = -ENOMEM;
691 goto probe_err_4;
692 }
693
694 /* init the timer which controls the leds */
695 init_timer(&card->led_timer);
696 card->led_timer.function = pcan_led_timer;
697 card->led_timer.data = (unsigned long)card;
698
699 /* request the given irq */
700 err = request_irq(pdev->irq, &pcan_isr, IRQF_SHARED, PCC_NAME, card);
701 if (err) {
702 dev_err(&pdev->dev, "couldn't request irq%d\n", pdev->irq);
703 goto probe_err_5;
704 }
705
706 /* power on the connectors */
707 pcan_set_can_power(card, 1);
708
709 return 0;
710
711probe_err_5:
712 /* unregister can devices from network */
713 pcan_free_channels(card);
714
715probe_err_4:
716 ioport_unmap(card->ioport_addr);
717
718probe_err_3:
719 kfree(card);
720 pdev->priv = NULL;
721
722probe_err_2:
723 pcmcia_disable_device(pdev);
724
725probe_err_1:
726 return err;
727}
728
729/*
730 * release claimed resources
731 */
732static void pcan_remove(struct pcmcia_device *pdev)
733{
734 pcan_free(pdev);
735 pcmcia_disable_device(pdev);
736}
737
738static struct pcmcia_driver pcan_driver = {
739 .name = PCC_NAME,
740 .probe = pcan_probe,
741 .remove = pcan_remove,
742 .id_table = pcan_table,
743};
744
745static int __init pcan_init(void)
746{
747 return pcmcia_register_driver(&pcan_driver);
748}
749module_init(pcan_init);
750
751static void __exit pcan_exit(void)
752{
753 pcmcia_unregister_driver(&pcan_driver);
754}
755module_exit(pcan_exit);
diff --git a/drivers/net/can/sja1000/plx_pci.c b/drivers/net/can/sja1000/plx_pci.c
index 11d1062a944..c7f3d4ea116 100644
--- a/drivers/net/can/sja1000/plx_pci.c
+++ b/drivers/net/can/sja1000/plx_pci.c
@@ -43,9 +43,7 @@ MODULE_SUPPORTED_DEVICE("Adlink PCI-7841/cPCI-7841, "
43 "TEWS TECHNOLOGIES TPMC810, " 43 "TEWS TECHNOLOGIES TPMC810, "
44 "esd CAN-PCI/CPCI/PCI104/200, " 44 "esd CAN-PCI/CPCI/PCI104/200, "
45 "esd CAN-PCI/PMC/266, " 45 "esd CAN-PCI/PMC/266, "
46 "esd CAN-PCIe/2000, " 46 "esd CAN-PCIe/2000")
47 "Connect Tech Inc. CANpro/104-Plus Opto (CRG001), "
48 "IXXAT PC-I 04/PCI")
49MODULE_LICENSE("GPL v2"); 47MODULE_LICENSE("GPL v2");
50 48
51#define PLX_PCI_MAX_CHAN 2 49#define PLX_PCI_MAX_CHAN 2
@@ -123,18 +121,11 @@ struct plx_pci_card {
123#define ESD_PCI_SUB_SYS_ID_PCIE2000 0x0200 121#define ESD_PCI_SUB_SYS_ID_PCIE2000 0x0200
124#define ESD_PCI_SUB_SYS_ID_PCI104200 0x0501 122#define ESD_PCI_SUB_SYS_ID_PCI104200 0x0501
125 123
126#define IXXAT_PCI_VENDOR_ID 0x10b5
127#define IXXAT_PCI_DEVICE_ID 0x9050
128#define IXXAT_PCI_SUB_SYS_ID 0x2540
129
130#define MARATHON_PCI_DEVICE_ID 0x2715 124#define MARATHON_PCI_DEVICE_ID 0x2715
131 125
132#define TEWS_PCI_VENDOR_ID 0x1498 126#define TEWS_PCI_VENDOR_ID 0x1498
133#define TEWS_PCI_DEVICE_ID_TMPC810 0x032A 127#define TEWS_PCI_DEVICE_ID_TMPC810 0x032A
134 128
135#define CTI_PCI_VENDOR_ID 0x12c4
136#define CTI_PCI_DEVICE_ID_CRG001 0x0900
137
138static void plx_pci_reset_common(struct pci_dev *pdev); 129static void plx_pci_reset_common(struct pci_dev *pdev);
139static void plx_pci_reset_marathon(struct pci_dev *pdev); 130static void plx_pci_reset_marathon(struct pci_dev *pdev);
140static void plx9056_pci_reset_common(struct pci_dev *pdev); 131static void plx9056_pci_reset_common(struct pci_dev *pdev);
@@ -162,7 +153,7 @@ struct plx_pci_card_info {
162 void (*reset_func)(struct pci_dev *pdev); 153 void (*reset_func)(struct pci_dev *pdev);
163}; 154};
164 155
165static struct plx_pci_card_info plx_pci_card_info_adlink = { 156static struct plx_pci_card_info plx_pci_card_info_adlink __devinitdata = {
166 "Adlink PCI-7841/cPCI-7841", 2, 157 "Adlink PCI-7841/cPCI-7841", 2,
167 PLX_PCI_CAN_CLOCK, PLX_PCI_OCR, PLX_PCI_CDR, 158 PLX_PCI_CAN_CLOCK, PLX_PCI_OCR, PLX_PCI_CDR,
168 {1, 0x00, 0x00}, { {2, 0x00, 0x80}, {2, 0x80, 0x80} }, 159 {1, 0x00, 0x00}, { {2, 0x00, 0x80}, {2, 0x80, 0x80} },
@@ -170,7 +161,7 @@ static struct plx_pci_card_info plx_pci_card_info_adlink = {
170 /* based on PLX9052 */ 161 /* based on PLX9052 */
171}; 162};
172 163
173static struct plx_pci_card_info plx_pci_card_info_adlink_se = { 164static struct plx_pci_card_info plx_pci_card_info_adlink_se __devinitdata = {
174 "Adlink PCI-7841/cPCI-7841 SE", 2, 165 "Adlink PCI-7841/cPCI-7841 SE", 2,
175 PLX_PCI_CAN_CLOCK, PLX_PCI_OCR, PLX_PCI_CDR, 166 PLX_PCI_CAN_CLOCK, PLX_PCI_OCR, PLX_PCI_CDR,
176 {0, 0x00, 0x00}, { {2, 0x00, 0x80}, {2, 0x80, 0x80} }, 167 {0, 0x00, 0x00}, { {2, 0x00, 0x80}, {2, 0x80, 0x80} },
@@ -178,7 +169,7 @@ static struct plx_pci_card_info plx_pci_card_info_adlink_se = {
178 /* based on PLX9052 */ 169 /* based on PLX9052 */
179}; 170};
180 171
181static struct plx_pci_card_info plx_pci_card_info_esd200 = { 172static struct plx_pci_card_info plx_pci_card_info_esd200 __devinitdata = {
182 "esd CAN-PCI/CPCI/PCI104/200", 2, 173 "esd CAN-PCI/CPCI/PCI104/200", 2,
183 PLX_PCI_CAN_CLOCK, PLX_PCI_OCR, PLX_PCI_CDR, 174 PLX_PCI_CAN_CLOCK, PLX_PCI_OCR, PLX_PCI_CDR,
184 {0, 0x00, 0x00}, { {2, 0x00, 0x80}, {2, 0x100, 0x80} }, 175 {0, 0x00, 0x00}, { {2, 0x00, 0x80}, {2, 0x100, 0x80} },
@@ -186,7 +177,7 @@ static struct plx_pci_card_info plx_pci_card_info_esd200 = {
186 /* based on PLX9030/9050 */ 177 /* based on PLX9030/9050 */
187}; 178};
188 179
189static struct plx_pci_card_info plx_pci_card_info_esd266 = { 180static struct plx_pci_card_info plx_pci_card_info_esd266 __devinitdata = {
190 "esd CAN-PCI/PMC/266", 2, 181 "esd CAN-PCI/PMC/266", 2,
191 PLX_PCI_CAN_CLOCK, PLX_PCI_OCR, PLX_PCI_CDR, 182 PLX_PCI_CAN_CLOCK, PLX_PCI_OCR, PLX_PCI_CDR,
192 {0, 0x00, 0x00}, { {2, 0x00, 0x80}, {2, 0x100, 0x80} }, 183 {0, 0x00, 0x00}, { {2, 0x00, 0x80}, {2, 0x100, 0x80} },
@@ -194,7 +185,7 @@ static struct plx_pci_card_info plx_pci_card_info_esd266 = {
194 /* based on PLX9056 */ 185 /* based on PLX9056 */
195}; 186};
196 187
197static struct plx_pci_card_info plx_pci_card_info_esd2000 = { 188static struct plx_pci_card_info plx_pci_card_info_esd2000 __devinitdata = {
198 "esd CAN-PCIe/2000", 2, 189 "esd CAN-PCIe/2000", 2,
199 PLX_PCI_CAN_CLOCK, PLX_PCI_OCR, PLX_PCI_CDR, 190 PLX_PCI_CAN_CLOCK, PLX_PCI_OCR, PLX_PCI_CDR,
200 {0, 0x00, 0x00}, { {2, 0x00, 0x80}, {2, 0x100, 0x80} }, 191 {0, 0x00, 0x00}, { {2, 0x00, 0x80}, {2, 0x100, 0x80} },
@@ -202,15 +193,7 @@ static struct plx_pci_card_info plx_pci_card_info_esd2000 = {
202 /* based on PEX8311 */ 193 /* based on PEX8311 */
203}; 194};
204 195
205static struct plx_pci_card_info plx_pci_card_info_ixxat = { 196static struct plx_pci_card_info plx_pci_card_info_marathon __devinitdata = {
206 "IXXAT PC-I 04/PCI", 2,
207 PLX_PCI_CAN_CLOCK, PLX_PCI_OCR, PLX_PCI_CDR,
208 {0, 0x00, 0x00}, { {2, 0x00, 0x80}, {2, 0x200, 0x80} },
209 &plx_pci_reset_common
210 /* based on PLX9050 */
211};
212
213static struct plx_pci_card_info plx_pci_card_info_marathon = {
214 "Marathon CAN-bus-PCI", 2, 197 "Marathon CAN-bus-PCI", 2,
215 PLX_PCI_CAN_CLOCK, PLX_PCI_OCR, PLX_PCI_CDR, 198 PLX_PCI_CAN_CLOCK, PLX_PCI_OCR, PLX_PCI_CDR,
216 {0, 0x00, 0x00}, { {2, 0x00, 0x00}, {4, 0x00, 0x00} }, 199 {0, 0x00, 0x00}, { {2, 0x00, 0x00}, {4, 0x00, 0x00} },
@@ -218,7 +201,7 @@ static struct plx_pci_card_info plx_pci_card_info_marathon = {
218 /* based on PLX9052 */ 201 /* based on PLX9052 */
219}; 202};
220 203
221static struct plx_pci_card_info plx_pci_card_info_tews = { 204static struct plx_pci_card_info plx_pci_card_info_tews __devinitdata = {
222 "TEWS TECHNOLOGIES TPMC810", 2, 205 "TEWS TECHNOLOGIES TPMC810", 2,
223 PLX_PCI_CAN_CLOCK, PLX_PCI_OCR, PLX_PCI_CDR, 206 PLX_PCI_CAN_CLOCK, PLX_PCI_OCR, PLX_PCI_CDR,
224 {0, 0x00, 0x00}, { {2, 0x000, 0x80}, {2, 0x100, 0x80} }, 207 {0, 0x00, 0x00}, { {2, 0x000, 0x80}, {2, 0x100, 0x80} },
@@ -226,14 +209,6 @@ static struct plx_pci_card_info plx_pci_card_info_tews = {
226 /* based on PLX9030 */ 209 /* based on PLX9030 */
227}; 210};
228 211
229static struct plx_pci_card_info plx_pci_card_info_cti = {
230 "Connect Tech Inc. CANpro/104-Plus Opto (CRG001)", 2,
231 PLX_PCI_CAN_CLOCK, PLX_PCI_OCR, PLX_PCI_CDR,
232 {0, 0x00, 0x00}, { {2, 0x000, 0x80}, {2, 0x100, 0x80} },
233 &plx_pci_reset_common
234 /* based on PLX9030 */
235};
236
237static DEFINE_PCI_DEVICE_TABLE(plx_pci_tbl) = { 212static DEFINE_PCI_DEVICE_TABLE(plx_pci_tbl) = {
238 { 213 {
239 /* Adlink PCI-7841/cPCI-7841 */ 214 /* Adlink PCI-7841/cPCI-7841 */
@@ -292,13 +267,6 @@ static DEFINE_PCI_DEVICE_TABLE(plx_pci_tbl) = {
292 (kernel_ulong_t)&plx_pci_card_info_esd2000 267 (kernel_ulong_t)&plx_pci_card_info_esd2000
293 }, 268 },
294 { 269 {
295 /* IXXAT PC-I 04/PCI card */
296 IXXAT_PCI_VENDOR_ID, IXXAT_PCI_DEVICE_ID,
297 PCI_ANY_ID, IXXAT_PCI_SUB_SYS_ID,
298 0, 0,
299 (kernel_ulong_t)&plx_pci_card_info_ixxat
300 },
301 {
302 /* Marathon CAN-bus-PCI card */ 270 /* Marathon CAN-bus-PCI card */
303 PCI_VENDOR_ID_PLX, MARATHON_PCI_DEVICE_ID, 271 PCI_VENDOR_ID_PLX, MARATHON_PCI_DEVICE_ID,
304 PCI_ANY_ID, PCI_ANY_ID, 272 PCI_ANY_ID, PCI_ANY_ID,
@@ -312,13 +280,6 @@ static DEFINE_PCI_DEVICE_TABLE(plx_pci_tbl) = {
312 0, 0, 280 0, 0,
313 (kernel_ulong_t)&plx_pci_card_info_tews 281 (kernel_ulong_t)&plx_pci_card_info_tews
314 }, 282 },
315 {
316 /* Connect Tech Inc. CANpro/104-Plus Opto (CRG001) card */
317 PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9030,
318 CTI_PCI_VENDOR_ID, CTI_PCI_DEVICE_ID_CRG001,
319 0, 0,
320 (kernel_ulong_t)&plx_pci_card_info_cti
321 },
322 { 0,} 283 { 0,}
323}; 284};
324MODULE_DEVICE_TABLE(pci, plx_pci_tbl); 285MODULE_DEVICE_TABLE(pci, plx_pci_tbl);
@@ -484,8 +445,8 @@ static void plx_pci_del_card(struct pci_dev *pdev)
484 * Probe PLX90xx based device for the SJA1000 chips and register each 445 * Probe PLX90xx based device for the SJA1000 chips and register each
485 * available CAN channel to SJA1000 Socket-CAN subsystem. 446 * available CAN channel to SJA1000 Socket-CAN subsystem.
486 */ 447 */
487static int plx_pci_add_card(struct pci_dev *pdev, 448static int __devinit plx_pci_add_card(struct pci_dev *pdev,
488 const struct pci_device_id *ent) 449 const struct pci_device_id *ent)
489{ 450{
490 struct sja1000_priv *priv; 451 struct sja1000_priv *priv;
491 struct net_device *dev; 452 struct net_device *dev;
@@ -628,4 +589,15 @@ static struct pci_driver plx_pci_driver = {
628 .remove = plx_pci_del_card, 589 .remove = plx_pci_del_card,
629}; 590};
630 591
631module_pci_driver(plx_pci_driver); 592static int __init plx_pci_init(void)
593{
594 return pci_register_driver(&plx_pci_driver);
595}
596
597static void __exit plx_pci_exit(void)
598{
599 pci_unregister_driver(&plx_pci_driver);
600}
601
602module_init(plx_pci_init);
603module_exit(plx_pci_exit);
diff --git a/drivers/net/can/sja1000/sja1000.c b/drivers/net/can/sja1000/sja1000.c
index 83ee11eca0e..f501bba1fc6 100644
--- a/drivers/net/can/sja1000/sja1000.c
+++ b/drivers/net/can/sja1000/sja1000.c
@@ -40,6 +40,8 @@
40 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH 40 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
41 * DAMAGE. 41 * DAMAGE.
42 * 42 *
43 * Send feedback to <socketcan-users@lists.berlios.de>
44 *
43 */ 45 */
44 46
45#include <linux/module.h> 47#include <linux/module.h>
@@ -69,7 +71,7 @@ MODULE_AUTHOR("Oliver Hartkopp <oliver.hartkopp@volkswagen.de>");
69MODULE_LICENSE("Dual BSD/GPL"); 71MODULE_LICENSE("Dual BSD/GPL");
70MODULE_DESCRIPTION(DRV_NAME "CAN netdevice driver"); 72MODULE_DESCRIPTION(DRV_NAME "CAN netdevice driver");
71 73
72static const struct can_bittiming_const sja1000_bittiming_const = { 74static struct can_bittiming_const sja1000_bittiming_const = {
73 .name = DRV_NAME, 75 .name = DRV_NAME,
74 .tseg1_min = 1, 76 .tseg1_min = 1,
75 .tseg1_max = 16, 77 .tseg1_max = 16,
@@ -95,16 +97,11 @@ static void sja1000_write_cmdreg(struct sja1000_priv *priv, u8 val)
95 spin_unlock_irqrestore(&priv->cmdreg_lock, flags); 97 spin_unlock_irqrestore(&priv->cmdreg_lock, flags);
96} 98}
97 99
98static int sja1000_is_absent(struct sja1000_priv *priv)
99{
100 return (priv->read_reg(priv, REG_MOD) == 0xFF);
101}
102
103static int sja1000_probe_chip(struct net_device *dev) 100static int sja1000_probe_chip(struct net_device *dev)
104{ 101{
105 struct sja1000_priv *priv = netdev_priv(dev); 102 struct sja1000_priv *priv = netdev_priv(dev);
106 103
107 if (priv->reg_base && sja1000_is_absent(priv)) { 104 if (priv->reg_base && (priv->read_reg(priv, 0) == 0xFF)) {
108 printk(KERN_INFO "%s: probing @0x%lX failed\n", 105 printk(KERN_INFO "%s: probing @0x%lX failed\n",
109 DRV_NAME, dev->base_addr); 106 DRV_NAME, dev->base_addr);
110 return 0; 107 return 0;
@@ -133,7 +130,7 @@ static void set_reset_mode(struct net_device *dev)
133 status = priv->read_reg(priv, REG_MOD); 130 status = priv->read_reg(priv, REG_MOD);
134 } 131 }
135 132
136 netdev_err(dev, "setting SJA1000 into reset mode failed!\n"); 133 dev_err(dev->dev.parent, "setting SJA1000 into reset mode failed!\n");
137} 134}
138 135
139static void set_normal_mode(struct net_device *dev) 136static void set_normal_mode(struct net_device *dev)
@@ -156,17 +153,12 @@ static void set_normal_mode(struct net_device *dev)
156 } 153 }
157 154
158 /* set chip to normal mode */ 155 /* set chip to normal mode */
159 if (priv->can.ctrlmode & CAN_CTRLMODE_LISTENONLY) 156 priv->write_reg(priv, REG_MOD, 0x00);
160 priv->write_reg(priv, REG_MOD, MOD_LOM);
161 else
162 priv->write_reg(priv, REG_MOD, 0x00);
163
164 udelay(10); 157 udelay(10);
165
166 status = priv->read_reg(priv, REG_MOD); 158 status = priv->read_reg(priv, REG_MOD);
167 } 159 }
168 160
169 netdev_err(dev, "setting SJA1000 into normal mode failed!\n"); 161 dev_err(dev->dev.parent, "setting SJA1000 into normal mode failed!\n");
170} 162}
171 163
172static void sja1000_start(struct net_device *dev) 164static void sja1000_start(struct net_device *dev)
@@ -188,6 +180,11 @@ static void sja1000_start(struct net_device *dev)
188 180
189static int sja1000_set_mode(struct net_device *dev, enum can_mode mode) 181static int sja1000_set_mode(struct net_device *dev, enum can_mode mode)
190{ 182{
183 struct sja1000_priv *priv = netdev_priv(dev);
184
185 if (!priv->open_time)
186 return -EINVAL;
187
191 switch (mode) { 188 switch (mode) {
192 case CAN_MODE_START: 189 case CAN_MODE_START:
193 sja1000_start(dev); 190 sja1000_start(dev);
@@ -214,7 +211,8 @@ static int sja1000_set_bittiming(struct net_device *dev)
214 if (priv->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES) 211 if (priv->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES)
215 btr1 |= 0x80; 212 btr1 |= 0x80;
216 213
217 netdev_info(dev, "setting BTR0=0x%02x BTR1=0x%02x\n", btr0, btr1); 214 dev_info(dev->dev.parent,
215 "setting BTR0=0x%02x BTR1=0x%02x\n", btr0, btr1);
218 216
219 priv->write_reg(priv, REG_BTR0, btr0); 217 priv->write_reg(priv, REG_BTR0, btr0);
220 priv->write_reg(priv, REG_BTR1, btr1); 218 priv->write_reg(priv, REG_BTR1, btr1);
@@ -310,10 +308,7 @@ static netdev_tx_t sja1000_start_xmit(struct sk_buff *skb,
310 308
311 can_put_echo_skb(skb, dev, 0); 309 can_put_echo_skb(skb, dev, 0);
312 310
313 if (priv->can.ctrlmode & CAN_CTRLMODE_ONE_SHOT) 311 sja1000_write_cmdreg(priv, CMD_TR);
314 sja1000_write_cmdreg(priv, CMD_TR | CMD_AT);
315 else
316 sja1000_write_cmdreg(priv, CMD_TR);
317 312
318 return NETDEV_TX_OK; 313 return NETDEV_TX_OK;
319} 314}
@@ -385,7 +380,7 @@ static int sja1000_err(struct net_device *dev, uint8_t isrc, uint8_t status)
385 380
386 if (isrc & IRQ_DOI) { 381 if (isrc & IRQ_DOI) {
387 /* data overrun interrupt */ 382 /* data overrun interrupt */
388 netdev_dbg(dev, "data overrun interrupt\n"); 383 dev_dbg(dev->dev.parent, "data overrun interrupt\n");
389 cf->can_id |= CAN_ERR_CRTL; 384 cf->can_id |= CAN_ERR_CRTL;
390 cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW; 385 cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW;
391 stats->rx_over_errors++; 386 stats->rx_over_errors++;
@@ -395,7 +390,7 @@ static int sja1000_err(struct net_device *dev, uint8_t isrc, uint8_t status)
395 390
396 if (isrc & IRQ_EI) { 391 if (isrc & IRQ_EI) {
397 /* error warning interrupt */ 392 /* error warning interrupt */
398 netdev_dbg(dev, "error warning interrupt\n"); 393 dev_dbg(dev->dev.parent, "error warning interrupt\n");
399 394
400 if (status & SR_BS) { 395 if (status & SR_BS) {
401 state = CAN_STATE_BUS_OFF; 396 state = CAN_STATE_BUS_OFF;
@@ -436,7 +431,7 @@ static int sja1000_err(struct net_device *dev, uint8_t isrc, uint8_t status)
436 } 431 }
437 if (isrc & IRQ_EPI) { 432 if (isrc & IRQ_EPI) {
438 /* error passive interrupt */ 433 /* error passive interrupt */
439 netdev_dbg(dev, "error passive interrupt\n"); 434 dev_dbg(dev->dev.parent, "error passive interrupt\n");
440 if (status & SR_ES) 435 if (status & SR_ES)
441 state = CAN_STATE_ERROR_PASSIVE; 436 state = CAN_STATE_ERROR_PASSIVE;
442 else 437 else
@@ -444,7 +439,7 @@ static int sja1000_err(struct net_device *dev, uint8_t isrc, uint8_t status)
444 } 439 }
445 if (isrc & IRQ_ALI) { 440 if (isrc & IRQ_ALI) {
446 /* arbitration lost interrupt */ 441 /* arbitration lost interrupt */
447 netdev_dbg(dev, "arbitration lost interrupt\n"); 442 dev_dbg(dev->dev.parent, "arbitration lost interrupt\n");
448 alc = priv->read_reg(priv, REG_ALC); 443 alc = priv->read_reg(priv, REG_ALC);
449 priv->can.can_stats.arbitration_lost++; 444 priv->can.can_stats.arbitration_lost++;
450 stats->tx_errors++; 445 stats->tx_errors++;
@@ -500,26 +495,15 @@ irqreturn_t sja1000_interrupt(int irq, void *dev_id)
500 while ((isrc = priv->read_reg(priv, REG_IR)) && (n < SJA1000_MAX_IRQ)) { 495 while ((isrc = priv->read_reg(priv, REG_IR)) && (n < SJA1000_MAX_IRQ)) {
501 n++; 496 n++;
502 status = priv->read_reg(priv, REG_SR); 497 status = priv->read_reg(priv, REG_SR);
503 /* check for absent controller due to hw unplug */
504 if (status == 0xFF && sja1000_is_absent(priv))
505 return IRQ_NONE;
506 498
507 if (isrc & IRQ_WUI) 499 if (isrc & IRQ_WUI)
508 netdev_warn(dev, "wakeup interrupt\n"); 500 dev_warn(dev->dev.parent, "wakeup interrupt\n");
509 501
510 if (isrc & IRQ_TI) { 502 if (isrc & IRQ_TI) {
511 /* transmission buffer released */ 503 /* transmission complete interrupt */
512 if (priv->can.ctrlmode & CAN_CTRLMODE_ONE_SHOT && 504 stats->tx_bytes += priv->read_reg(priv, REG_FI) & 0xf;
513 !(status & SR_TCS)) { 505 stats->tx_packets++;
514 stats->tx_errors++; 506 can_get_echo_skb(dev, 0);
515 can_free_echo_skb(dev, 0);
516 } else {
517 /* transmission complete */
518 stats->tx_bytes +=
519 priv->read_reg(priv, REG_FI) & 0xf;
520 stats->tx_packets++;
521 can_get_echo_skb(dev, 0);
522 }
523 netif_wake_queue(dev); 507 netif_wake_queue(dev);
524 } 508 }
525 if (isrc & IRQ_RI) { 509 if (isrc & IRQ_RI) {
@@ -527,9 +511,6 @@ irqreturn_t sja1000_interrupt(int irq, void *dev_id)
527 while (status & SR_RBS) { 511 while (status & SR_RBS) {
528 sja1000_rx(dev); 512 sja1000_rx(dev);
529 status = priv->read_reg(priv, REG_SR); 513 status = priv->read_reg(priv, REG_SR);
530 /* check for absent controller */
531 if (status == 0xFF && sja1000_is_absent(priv))
532 return IRQ_NONE;
533 } 514 }
534 } 515 }
535 if (isrc & (IRQ_DOI | IRQ_EI | IRQ_BEI | IRQ_EPI | IRQ_ALI)) { 516 if (isrc & (IRQ_DOI | IRQ_EI | IRQ_BEI | IRQ_EPI | IRQ_ALI)) {
@@ -543,7 +524,7 @@ irqreturn_t sja1000_interrupt(int irq, void *dev_id)
543 priv->post_irq(priv); 524 priv->post_irq(priv);
544 525
545 if (n >= SJA1000_MAX_IRQ) 526 if (n >= SJA1000_MAX_IRQ)
546 netdev_dbg(dev, "%d messages handled in ISR", n); 527 dev_dbg(dev->dev.parent, "%d messages handled in ISR", n);
547 528
548 return (n) ? IRQ_HANDLED : IRQ_NONE; 529 return (n) ? IRQ_HANDLED : IRQ_NONE;
549} 530}
@@ -574,6 +555,7 @@ static int sja1000_open(struct net_device *dev)
574 555
575 /* init and start chi */ 556 /* init and start chi */
576 sja1000_start(dev); 557 sja1000_start(dev);
558 priv->open_time = jiffies;
577 559
578 netif_start_queue(dev); 560 netif_start_queue(dev);
579 561
@@ -592,6 +574,8 @@ static int sja1000_close(struct net_device *dev)
592 574
593 close_candev(dev); 575 close_candev(dev);
594 576
577 priv->open_time = 0;
578
595 return 0; 579 return 0;
596} 580}
597 581
@@ -613,8 +597,7 @@ struct net_device *alloc_sja1000dev(int sizeof_priv)
613 priv->can.do_set_mode = sja1000_set_mode; 597 priv->can.do_set_mode = sja1000_set_mode;
614 priv->can.do_get_berr_counter = sja1000_get_berr_counter; 598 priv->can.do_get_berr_counter = sja1000_get_berr_counter;
615 priv->can.ctrlmode_supported = CAN_CTRLMODE_3_SAMPLES | 599 priv->can.ctrlmode_supported = CAN_CTRLMODE_3_SAMPLES |
616 CAN_CTRLMODE_BERR_REPORTING | CAN_CTRLMODE_LISTENONLY | 600 CAN_CTRLMODE_BERR_REPORTING;
617 CAN_CTRLMODE_ONE_SHOT;
618 601
619 spin_lock_init(&priv->cmdreg_lock); 602 spin_lock_init(&priv->cmdreg_lock);
620 603
diff --git a/drivers/net/can/sja1000/sja1000.h b/drivers/net/can/sja1000/sja1000.h
index afa99847a51..78bd4ecac14 100644
--- a/drivers/net/can/sja1000/sja1000.h
+++ b/drivers/net/can/sja1000/sja1000.h
@@ -40,6 +40,8 @@
40 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH 40 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
41 * DAMAGE. 41 * DAMAGE.
42 * 42 *
43 * Send feedback to <socketcan-users@lists.berlios.de>
44 *
43 */ 45 */
44 46
45#ifndef SJA1000_DEV_H 47#ifndef SJA1000_DEV_H
@@ -152,6 +154,7 @@
152 */ 154 */
153struct sja1000_priv { 155struct sja1000_priv {
154 struct can_priv can; /* must be the first member */ 156 struct can_priv can; /* must be the first member */
157 int open_time;
155 struct sk_buff *echo_skb; 158 struct sk_buff *echo_skb;
156 159
157 /* the lower-layer is responsible for appropriate locking */ 160 /* the lower-layer is responsible for appropriate locking */
diff --git a/drivers/net/can/sja1000/sja1000_isa.c b/drivers/net/can/sja1000/sja1000_isa.c
index 5c8da466148..496223e9e2f 100644
--- a/drivers/net/can/sja1000/sja1000_isa.c
+++ b/drivers/net/can/sja1000/sja1000_isa.c
@@ -17,7 +17,7 @@
17 17
18#include <linux/kernel.h> 18#include <linux/kernel.h>
19#include <linux/module.h> 19#include <linux/module.h>
20#include <linux/platform_device.h> 20#include <linux/isa.h>
21#include <linux/interrupt.h> 21#include <linux/interrupt.h>
22#include <linux/netdevice.h> 22#include <linux/netdevice.h>
23#include <linux/delay.h> 23#include <linux/delay.h>
@@ -42,11 +42,11 @@ MODULE_LICENSE("GPL v2");
42 42
43static unsigned long port[MAXDEV]; 43static unsigned long port[MAXDEV];
44static unsigned long mem[MAXDEV]; 44static unsigned long mem[MAXDEV];
45static int irq[MAXDEV]; 45static int __devinitdata irq[MAXDEV];
46static int clk[MAXDEV]; 46static int __devinitdata clk[MAXDEV];
47static unsigned char cdr[MAXDEV] = {[0 ... (MAXDEV - 1)] = 0xff}; 47static char __devinitdata cdr[MAXDEV] = {[0 ... (MAXDEV - 1)] = -1};
48static unsigned char ocr[MAXDEV] = {[0 ... (MAXDEV - 1)] = 0xff}; 48static char __devinitdata ocr[MAXDEV] = {[0 ... (MAXDEV - 1)] = -1};
49static int indirect[MAXDEV] = {[0 ... (MAXDEV - 1)] = -1}; 49static char __devinitdata indirect[MAXDEV] = {[0 ... (MAXDEV - 1)] = -1};
50 50
51module_param_array(port, ulong, NULL, S_IRUGO); 51module_param_array(port, ulong, NULL, S_IRUGO);
52MODULE_PARM_DESC(port, "I/O port number"); 52MODULE_PARM_DESC(port, "I/O port number");
@@ -54,7 +54,7 @@ MODULE_PARM_DESC(port, "I/O port number");
54module_param_array(mem, ulong, NULL, S_IRUGO); 54module_param_array(mem, ulong, NULL, S_IRUGO);
55MODULE_PARM_DESC(mem, "I/O memory address"); 55MODULE_PARM_DESC(mem, "I/O memory address");
56 56
57module_param_array(indirect, int, NULL, S_IRUGO); 57module_param_array(indirect, byte, NULL, S_IRUGO);
58MODULE_PARM_DESC(indirect, "Indirect access via address and data port"); 58MODULE_PARM_DESC(indirect, "Indirect access via address and data port");
59 59
60module_param_array(irq, int, NULL, S_IRUGO); 60module_param_array(irq, int, NULL, S_IRUGO);
@@ -75,8 +75,6 @@ MODULE_PARM_DESC(ocr, "Output control register "
75#define SJA1000_IOSIZE 0x20 75#define SJA1000_IOSIZE 0x20
76#define SJA1000_IOSIZE_INDIRECT 0x02 76#define SJA1000_IOSIZE_INDIRECT 0x02
77 77
78static struct platform_device *sja1000_isa_devs[MAXDEV];
79
80static u8 sja1000_isa_mem_read_reg(const struct sja1000_priv *priv, int reg) 78static u8 sja1000_isa_mem_read_reg(const struct sja1000_priv *priv, int reg)
81{ 79{
82 return readb(priv->reg_base + reg); 80 return readb(priv->reg_base + reg);
@@ -117,18 +115,26 @@ static void sja1000_isa_port_write_reg_indirect(const struct sja1000_priv *priv,
117 outb(val, base + 1); 115 outb(val, base + 1);
118} 116}
119 117
120static int sja1000_isa_probe(struct platform_device *pdev) 118static int __devinit sja1000_isa_match(struct device *pdev, unsigned int idx)
119{
120 if (port[idx] || mem[idx]) {
121 if (irq[idx])
122 return 1;
123 } else if (idx)
124 return 0;
125
126 dev_err(pdev, "insufficient parameters supplied\n");
127 return 0;
128}
129
130static int __devinit sja1000_isa_probe(struct device *pdev, unsigned int idx)
121{ 131{
122 struct net_device *dev; 132 struct net_device *dev;
123 struct sja1000_priv *priv; 133 struct sja1000_priv *priv;
124 void __iomem *base = NULL; 134 void __iomem *base = NULL;
125 int iosize = SJA1000_IOSIZE; 135 int iosize = SJA1000_IOSIZE;
126 int idx = pdev->id;
127 int err; 136 int err;
128 137
129 dev_dbg(&pdev->dev, "probing idx=%d: port=%#lx, mem=%#lx, irq=%d\n",
130 idx, port[idx], mem[idx], irq[idx]);
131
132 if (mem[idx]) { 138 if (mem[idx]) {
133 if (!request_mem_region(mem[idx], iosize, DRV_NAME)) { 139 if (!request_mem_region(mem[idx], iosize, DRV_NAME)) {
134 err = -EBUSY; 140 err = -EBUSY;
@@ -183,31 +189,31 @@ static int sja1000_isa_probe(struct platform_device *pdev)
183 else 189 else
184 priv->can.clock.freq = CLK_DEFAULT / 2; 190 priv->can.clock.freq = CLK_DEFAULT / 2;
185 191
186 if (ocr[idx] != 0xff) 192 if (ocr[idx] != -1)
187 priv->ocr = ocr[idx]; 193 priv->ocr = ocr[idx] & 0xff;
188 else if (ocr[0] != 0xff) 194 else if (ocr[0] != -1)
189 priv->ocr = ocr[0]; 195 priv->ocr = ocr[0] & 0xff;
190 else 196 else
191 priv->ocr = OCR_DEFAULT; 197 priv->ocr = OCR_DEFAULT;
192 198
193 if (cdr[idx] != 0xff) 199 if (cdr[idx] != -1)
194 priv->cdr = cdr[idx]; 200 priv->cdr = cdr[idx] & 0xff;
195 else if (cdr[0] != 0xff) 201 else if (cdr[0] != -1)
196 priv->cdr = cdr[0]; 202 priv->cdr = cdr[0] & 0xff;
197 else 203 else
198 priv->cdr = CDR_DEFAULT; 204 priv->cdr = CDR_DEFAULT;
199 205
200 dev_set_drvdata(&pdev->dev, dev); 206 dev_set_drvdata(pdev, dev);
201 SET_NETDEV_DEV(dev, &pdev->dev); 207 SET_NETDEV_DEV(dev, pdev);
202 208
203 err = register_sja1000dev(dev); 209 err = register_sja1000dev(dev);
204 if (err) { 210 if (err) {
205 dev_err(&pdev->dev, "registering %s failed (err=%d)\n", 211 dev_err(pdev, "registering %s failed (err=%d)\n",
206 DRV_NAME, err); 212 DRV_NAME, err);
207 goto exit_unmap; 213 goto exit_unmap;
208 } 214 }
209 215
210 dev_info(&pdev->dev, "%s device registered (reg_base=0x%p, irq=%d)\n", 216 dev_info(pdev, "%s device registered (reg_base=0x%p, irq=%d)\n",
211 DRV_NAME, priv->reg_base, dev->irq); 217 DRV_NAME, priv->reg_base, dev->irq);
212 return 0; 218 return 0;
213 219
@@ -223,14 +229,13 @@ static int sja1000_isa_probe(struct platform_device *pdev)
223 return err; 229 return err;
224} 230}
225 231
226static int sja1000_isa_remove(struct platform_device *pdev) 232static int __devexit sja1000_isa_remove(struct device *pdev, unsigned int idx)
227{ 233{
228 struct net_device *dev = dev_get_drvdata(&pdev->dev); 234 struct net_device *dev = dev_get_drvdata(pdev);
229 struct sja1000_priv *priv = netdev_priv(dev); 235 struct sja1000_priv *priv = netdev_priv(dev);
230 int idx = pdev->id;
231 236
232 unregister_sja1000dev(dev); 237 unregister_sja1000dev(dev);
233 dev_set_drvdata(&pdev->dev, NULL); 238 dev_set_drvdata(pdev, NULL);
234 239
235 if (mem[idx]) { 240 if (mem[idx]) {
236 iounmap(priv->reg_base); 241 iounmap(priv->reg_base);
@@ -246,70 +251,29 @@ static int sja1000_isa_remove(struct platform_device *pdev)
246 return 0; 251 return 0;
247} 252}
248 253
249static struct platform_driver sja1000_isa_driver = { 254static struct isa_driver sja1000_isa_driver = {
255 .match = sja1000_isa_match,
250 .probe = sja1000_isa_probe, 256 .probe = sja1000_isa_probe,
251 .remove = sja1000_isa_remove, 257 .remove = __devexit_p(sja1000_isa_remove),
252 .driver = { 258 .driver = {
253 .name = DRV_NAME, 259 .name = DRV_NAME,
254 .owner = THIS_MODULE,
255 }, 260 },
256}; 261};
257 262
258static int __init sja1000_isa_init(void) 263static int __init sja1000_isa_init(void)
259{ 264{
260 int idx, err; 265 int err = isa_register_driver(&sja1000_isa_driver, MAXDEV);
261
262 for (idx = 0; idx < MAXDEV; idx++) {
263 if ((port[idx] || mem[idx]) && irq[idx]) {
264 sja1000_isa_devs[idx] =
265 platform_device_alloc(DRV_NAME, idx);
266 if (!sja1000_isa_devs[idx]) {
267 err = -ENOMEM;
268 goto exit_free_devices;
269 }
270 err = platform_device_add(sja1000_isa_devs[idx]);
271 if (err) {
272 platform_device_put(sja1000_isa_devs[idx]);
273 goto exit_free_devices;
274 }
275 pr_debug("%s: platform device %d: port=%#lx, mem=%#lx, "
276 "irq=%d\n",
277 DRV_NAME, idx, port[idx], mem[idx], irq[idx]);
278 } else if (idx == 0 || port[idx] || mem[idx]) {
279 pr_err("%s: insufficient parameters supplied\n",
280 DRV_NAME);
281 err = -EINVAL;
282 goto exit_free_devices;
283 }
284 }
285
286 err = platform_driver_register(&sja1000_isa_driver);
287 if (err)
288 goto exit_free_devices;
289
290 pr_info("Legacy %s driver for max. %d devices registered\n",
291 DRV_NAME, MAXDEV);
292
293 return 0;
294
295exit_free_devices:
296 while (--idx >= 0) {
297 if (sja1000_isa_devs[idx])
298 platform_device_unregister(sja1000_isa_devs[idx]);
299 }
300 266
267 if (!err)
268 printk(KERN_INFO
269 "Legacy %s driver for max. %d devices registered\n",
270 DRV_NAME, MAXDEV);
301 return err; 271 return err;
302} 272}
303 273
304static void __exit sja1000_isa_exit(void) 274static void __exit sja1000_isa_exit(void)
305{ 275{
306 int idx; 276 isa_unregister_driver(&sja1000_isa_driver);
307
308 platform_driver_unregister(&sja1000_isa_driver);
309 for (idx = 0; idx < MAXDEV; idx++) {
310 if (sja1000_isa_devs[idx])
311 platform_device_unregister(sja1000_isa_devs[idx]);
312 }
313} 277}
314 278
315module_init(sja1000_isa_init); 279module_init(sja1000_isa_init);
diff --git a/drivers/net/can/sja1000/sja1000_of_platform.c b/drivers/net/can/sja1000/sja1000_of_platform.c
index 6433b81256c..cee6ba2b8b5 100644
--- a/drivers/net/can/sja1000/sja1000_of_platform.c
+++ b/drivers/net/can/sja1000/sja1000_of_platform.c
@@ -29,7 +29,7 @@
29 * nxp,external-clock-frequency = <16000000>; 29 * nxp,external-clock-frequency = <16000000>;
30 * }; 30 * };
31 * 31 *
32 * See "Documentation/devicetree/bindings/net/can/sja1000.txt" for further 32 * See "Documentation/powerpc/dts-bindings/can/sja1000.txt" for further
33 * information. 33 * information.
34 */ 34 */
35 35
@@ -42,8 +42,6 @@
42#include <linux/can/dev.h> 42#include <linux/can/dev.h>
43 43
44#include <linux/of_platform.h> 44#include <linux/of_platform.h>
45#include <linux/of_address.h>
46#include <linux/of_irq.h>
47#include <asm/prom.h> 45#include <asm/prom.h>
48 46
49#include "sja1000.h" 47#include "sja1000.h"
@@ -61,16 +59,16 @@ MODULE_LICENSE("GPL v2");
61 59
62static u8 sja1000_ofp_read_reg(const struct sja1000_priv *priv, int reg) 60static u8 sja1000_ofp_read_reg(const struct sja1000_priv *priv, int reg)
63{ 61{
64 return ioread8(priv->reg_base + reg); 62 return in_8(priv->reg_base + reg);
65} 63}
66 64
67static void sja1000_ofp_write_reg(const struct sja1000_priv *priv, 65static void sja1000_ofp_write_reg(const struct sja1000_priv *priv,
68 int reg, u8 val) 66 int reg, u8 val)
69{ 67{
70 iowrite8(val, priv->reg_base + reg); 68 out_8(priv->reg_base + reg, val);
71} 69}
72 70
73static int sja1000_ofp_remove(struct platform_device *ofdev) 71static int __devexit sja1000_ofp_remove(struct platform_device *ofdev)
74{ 72{
75 struct net_device *dev = dev_get_drvdata(&ofdev->dev); 73 struct net_device *dev = dev_get_drvdata(&ofdev->dev);
76 struct sja1000_priv *priv = netdev_priv(dev); 74 struct sja1000_priv *priv = netdev_priv(dev);
@@ -90,7 +88,7 @@ static int sja1000_ofp_remove(struct platform_device *ofdev)
90 return 0; 88 return 0;
91} 89}
92 90
93static int sja1000_ofp_probe(struct platform_device *ofdev) 91static int __devinit sja1000_ofp_probe(struct platform_device *ofdev)
94{ 92{
95 struct device_node *np = ofdev->dev.of_node; 93 struct device_node *np = ofdev->dev.of_node;
96 struct net_device *dev; 94 struct net_device *dev;
@@ -121,7 +119,7 @@ static int sja1000_ofp_probe(struct platform_device *ofdev)
121 } 119 }
122 120
123 irq = irq_of_parse_and_map(np, 0); 121 irq = irq_of_parse_and_map(np, 0);
124 if (irq == 0) { 122 if (irq == NO_IRQ) {
125 dev_err(&ofdev->dev, "no irq found\n"); 123 dev_err(&ofdev->dev, "no irq found\n");
126 err = -ENODEV; 124 err = -ENODEV;
127 goto exit_unmap_mem; 125 goto exit_unmap_mem;
@@ -206,7 +204,7 @@ exit_release_mem:
206 return err; 204 return err;
207} 205}
208 206
209static struct of_device_id sja1000_ofp_table[] = { 207static struct of_device_id __devinitdata sja1000_ofp_table[] = {
210 {.compatible = "nxp,sja1000"}, 208 {.compatible = "nxp,sja1000"},
211 {}, 209 {},
212}; 210};
@@ -219,7 +217,17 @@ static struct platform_driver sja1000_ofp_driver = {
219 .of_match_table = sja1000_ofp_table, 217 .of_match_table = sja1000_ofp_table,
220 }, 218 },
221 .probe = sja1000_ofp_probe, 219 .probe = sja1000_ofp_probe,
222 .remove = sja1000_ofp_remove, 220 .remove = __devexit_p(sja1000_ofp_remove),
223}; 221};
224 222
225module_platform_driver(sja1000_ofp_driver); 223static int __init sja1000_ofp_init(void)
224{
225 return platform_driver_register(&sja1000_ofp_driver);
226}
227module_init(sja1000_ofp_init);
228
229static void __exit sja1000_ofp_exit(void)
230{
231 return platform_driver_unregister(&sja1000_ofp_driver);
232};
233module_exit(sja1000_ofp_exit);
diff --git a/drivers/net/can/sja1000/sja1000_platform.c b/drivers/net/can/sja1000/sja1000_platform.c
index 21619bb5b86..d9fadc489b3 100644
--- a/drivers/net/can/sja1000/sja1000_platform.c
+++ b/drivers/net/can/sja1000/sja1000_platform.c
@@ -34,7 +34,6 @@
34 34
35MODULE_AUTHOR("Sascha Hauer <s.hauer@pengutronix.de>"); 35MODULE_AUTHOR("Sascha Hauer <s.hauer@pengutronix.de>");
36MODULE_DESCRIPTION("Socket-CAN driver for SJA1000 on the platform bus"); 36MODULE_DESCRIPTION("Socket-CAN driver for SJA1000 on the platform bus");
37MODULE_ALIAS("platform:" DRV_NAME);
38MODULE_LICENSE("GPL v2"); 37MODULE_LICENSE("GPL v2");
39 38
40static u8 sp_read_reg8(const struct sja1000_priv *priv, int reg) 39static u8 sp_read_reg8(const struct sja1000_priv *priv, int reg)
@@ -110,9 +109,7 @@ static int sp_probe(struct platform_device *pdev)
110 priv = netdev_priv(dev); 109 priv = netdev_priv(dev);
111 110
112 dev->irq = res_irq->start; 111 dev->irq = res_irq->start;
113 priv->irq_flags = res_irq->flags & IRQF_TRIGGER_MASK; 112 priv->irq_flags = res_irq->flags & (IRQF_TRIGGER_MASK | IRQF_SHARED);
114 if (res_irq->flags & IORESOURCE_IRQ_SHAREABLE)
115 priv->irq_flags |= IRQF_SHARED;
116 priv->reg_base = addr; 113 priv->reg_base = addr;
117 /* The CAN clock frequency is half the oscillator clock frequency */ 114 /* The CAN clock frequency is half the oscillator clock frequency */
118 priv->can.clock.freq = pdata->osc_freq / 2; 115 priv->can.clock.freq = pdata->osc_freq / 2;
@@ -188,4 +185,15 @@ static struct platform_driver sp_driver = {
188 }, 185 },
189}; 186};
190 187
191module_platform_driver(sp_driver); 188static int __init sp_init(void)
189{
190 return platform_driver_register(&sp_driver);
191}
192
193static void __exit sp_exit(void)
194{
195 platform_driver_unregister(&sp_driver);
196}
197
198module_init(sp_init);
199module_exit(sp_exit);
diff --git a/drivers/net/can/sja1000/tscan1.c b/drivers/net/can/sja1000/tscan1.c
index 76513dd780c..9756099a883 100644
--- a/drivers/net/can/sja1000/tscan1.c
+++ b/drivers/net/can/sja1000/tscan1.c
@@ -71,7 +71,7 @@ MODULE_LICENSE("GPL");
71#define TSCAN1_SJA1000_XTAL 16000000 71#define TSCAN1_SJA1000_XTAL 16000000
72 72
73/* SJA1000 IO base addresses */ 73/* SJA1000 IO base addresses */
74static const unsigned short tscan1_sja1000_addresses[] = { 74static const unsigned short tscan1_sja1000_addresses[] __devinitconst = {
75 0x100, 0x120, 0x180, 0x1a0, 0x200, 0x240, 0x280, 0x320 75 0x100, 0x120, 0x180, 0x1a0, 0x200, 0x240, 0x280, 0x320
76}; 76};
77 77
@@ -88,7 +88,7 @@ static void tscan1_write(const struct sja1000_priv *priv, int reg, u8 val)
88} 88}
89 89
90/* Probe for a TS-CAN1 board with JP2:JP1 jumper setting ID */ 90/* Probe for a TS-CAN1 board with JP2:JP1 jumper setting ID */
91static int tscan1_probe(struct device *dev, unsigned id) 91static int __devinit tscan1_probe(struct device *dev, unsigned id)
92{ 92{
93 struct net_device *netdev; 93 struct net_device *netdev;
94 struct sja1000_priv *priv; 94 struct sja1000_priv *priv;
@@ -171,7 +171,7 @@ static int tscan1_probe(struct device *dev, unsigned id)
171 return -ENXIO; 171 return -ENXIO;
172} 172}
173 173
174static int tscan1_remove(struct device *dev, unsigned id /*unused*/) 174static int __devexit tscan1_remove(struct device *dev, unsigned id /*unused*/)
175{ 175{
176 struct net_device *netdev; 176 struct net_device *netdev;
177 struct sja1000_priv *priv; 177 struct sja1000_priv *priv;
@@ -197,7 +197,7 @@ static int tscan1_remove(struct device *dev, unsigned id /*unused*/)
197 197
198static struct isa_driver tscan1_isa_driver = { 198static struct isa_driver tscan1_isa_driver = {
199 .probe = tscan1_probe, 199 .probe = tscan1_probe,
200 .remove = tscan1_remove, 200 .remove = __devexit_p(tscan1_remove),
201 .driver = { 201 .driver = {
202 .name = "tscan1", 202 .name = "tscan1",
203 }, 203 },
diff --git a/drivers/net/can/slcan.c b/drivers/net/can/slcan.c
index adc3708d882..4b70b7e8bde 100644
--- a/drivers/net/can/slcan.c
+++ b/drivers/net/can/slcan.c
@@ -1,7 +1,7 @@
1/* 1/*
2 * slcan.c - serial line CAN interface driver (using tty line discipline) 2 * slcan.c - serial line CAN interface driver (using tty line discipline)
3 * 3 *
4 * This file is derived from linux/drivers/net/slip/slip.c 4 * This file is derived from linux/drivers/net/slip.c
5 * 5 *
6 * slip.c Authors : Laurence Culhane <loz@holmes.demon.co.uk> 6 * slip.c Authors : Laurence Culhane <loz@holmes.demon.co.uk>
7 * Fred N. van Kempen <waltje@uwalt.nl.mugnet.org> 7 * Fred N. van Kempen <waltje@uwalt.nl.mugnet.org>
@@ -35,11 +35,14 @@
35 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH 35 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
36 * DAMAGE. 36 * DAMAGE.
37 * 37 *
38 * Send feedback to <socketcan-users@lists.berlios.de>
39 *
38 */ 40 */
39 41
40#include <linux/module.h> 42#include <linux/module.h>
41#include <linux/moduleparam.h> 43#include <linux/moduleparam.h>
42 44
45#include <asm/system.h>
43#include <linux/uaccess.h> 46#include <linux/uaccess.h>
44#include <linux/bitops.h> 47#include <linux/bitops.h>
45#include <linux/string.h> 48#include <linux/string.h>
@@ -56,7 +59,7 @@
56#include <linux/kernel.h> 59#include <linux/kernel.h>
57#include <linux/can.h> 60#include <linux/can.h>
58 61
59static __initconst const char banner[] = 62static __initdata const char banner[] =
60 KERN_INFO "slcan: serial line CAN interface driver\n"; 63 KERN_INFO "slcan: serial line CAN interface driver\n";
61 64
62MODULE_ALIAS_LDISC(N_SLCAN); 65MODULE_ALIAS_LDISC(N_SLCAN);
@@ -386,7 +389,7 @@ static void slc_setup(struct net_device *dev)
386 389
387 /* New-style flags. */ 390 /* New-style flags. */
388 dev->flags = IFF_NOARP; 391 dev->flags = IFF_NOARP;
389 dev->features = NETIF_F_HW_CSUM; 392 dev->features = NETIF_F_NO_CSUM;
390} 393}
391 394
392/****************************************** 395/******************************************
@@ -638,8 +641,10 @@ static int __init slcan_init(void)
638 printk(KERN_INFO "slcan: %d dynamic interface channels.\n", maxdev); 641 printk(KERN_INFO "slcan: %d dynamic interface channels.\n", maxdev);
639 642
640 slcan_devs = kzalloc(sizeof(struct net_device *)*maxdev, GFP_KERNEL); 643 slcan_devs = kzalloc(sizeof(struct net_device *)*maxdev, GFP_KERNEL);
641 if (!slcan_devs) 644 if (!slcan_devs) {
645 printk(KERN_ERR "slcan: can't allocate slcan device array!\n");
642 return -ENOMEM; 646 return -ENOMEM;
647 }
643 648
644 /* Fill in our line protocol discipline, and register it */ 649 /* Fill in our line protocol discipline, and register it */
645 status = tty_register_ldisc(N_SLCAN, &slc_ldisc); 650 status = tty_register_ldisc(N_SLCAN, &slc_ldisc);
diff --git a/drivers/net/can/softing/softing_cs.c b/drivers/net/can/softing/softing_cs.c
index c2c0a5bb0b2..c0e1b1eb87a 100644
--- a/drivers/net/can/softing/softing_cs.c
+++ b/drivers/net/can/softing/softing_cs.c
@@ -159,7 +159,7 @@ MODULE_FIRMWARE(fw_dir "bcard2.bin");
159MODULE_FIRMWARE(fw_dir "ldcard2.bin"); 159MODULE_FIRMWARE(fw_dir "ldcard2.bin");
160MODULE_FIRMWARE(fw_dir "cancrd2.bin"); 160MODULE_FIRMWARE(fw_dir "cancrd2.bin");
161 161
162static const struct softing_platform_data 162static __devinit const struct softing_platform_data
163*softingcs_find_platform_data(unsigned int manf, unsigned int prod) 163*softingcs_find_platform_data(unsigned int manf, unsigned int prod)
164{ 164{
165 const struct softing_platform_data *lp; 165 const struct softing_platform_data *lp;
@@ -193,7 +193,8 @@ static int softingcs_enable_irq(struct platform_device *pdev, int v)
193/* 193/*
194 * pcmcia check 194 * pcmcia check
195 */ 195 */
196static int softingcs_probe_config(struct pcmcia_device *pcmcia, void *priv_data) 196static __devinit int softingcs_probe_config(struct pcmcia_device *pcmcia,
197 void *priv_data)
197{ 198{
198 struct softing_platform_data *pdat = priv_data; 199 struct softing_platform_data *pdat = priv_data;
199 struct resource *pres; 200 struct resource *pres;
@@ -214,7 +215,7 @@ static int softingcs_probe_config(struct pcmcia_device *pcmcia, void *priv_data)
214 return pcmcia_request_window(pcmcia, pres, memspeed); 215 return pcmcia_request_window(pcmcia, pres, memspeed);
215} 216}
216 217
217static void softingcs_remove(struct pcmcia_device *pcmcia) 218static __devexit void softingcs_remove(struct pcmcia_device *pcmcia)
218{ 219{
219 struct platform_device *pdev = pcmcia->priv; 220 struct platform_device *pdev = pcmcia->priv;
220 221
@@ -234,7 +235,7 @@ static void softingcs_pdev_release(struct device *dev)
234 kfree(pdev); 235 kfree(pdev);
235} 236}
236 237
237static int softingcs_probe(struct pcmcia_device *pcmcia) 238static __devinit int softingcs_probe(struct pcmcia_device *pcmcia)
238{ 239{
239 int ret; 240 int ret;
240 struct platform_device *pdev; 241 struct platform_device *pdev;
@@ -337,7 +338,7 @@ static struct pcmcia_driver softingcs_driver = {
337 .name = "softingcs", 338 .name = "softingcs",
338 .id_table = softingcs_ids, 339 .id_table = softingcs_ids,
339 .probe = softingcs_probe, 340 .probe = softingcs_probe,
340 .remove = softingcs_remove, 341 .remove = __devexit_p(softingcs_remove),
341}; 342};
342 343
343static int __init softingcs_start(void) 344static int __init softingcs_start(void)
diff --git a/drivers/net/can/softing/softing_fw.c b/drivers/net/can/softing/softing_fw.c
index b595d3422b9..31059617567 100644
--- a/drivers/net/can/softing/softing_fw.c
+++ b/drivers/net/can/softing/softing_fw.c
@@ -150,7 +150,7 @@ int softing_load_fw(const char *file, struct softing *card,
150 const uint8_t *mem, *end, *dat; 150 const uint8_t *mem, *end, *dat;
151 uint16_t type, len; 151 uint16_t type, len;
152 uint32_t addr; 152 uint32_t addr;
153 uint8_t *buf = NULL, *new_buf; 153 uint8_t *buf = NULL;
154 int buflen = 0; 154 int buflen = 0;
155 int8_t type_end = 0; 155 int8_t type_end = 0;
156 156
@@ -199,12 +199,11 @@ int softing_load_fw(const char *file, struct softing *card,
199 if (len > buflen) { 199 if (len > buflen) {
200 /* align buflen */ 200 /* align buflen */
201 buflen = (len + (1024-1)) & ~(1024-1); 201 buflen = (len + (1024-1)) & ~(1024-1);
202 new_buf = krealloc(buf, buflen, GFP_KERNEL); 202 buf = krealloc(buf, buflen, GFP_KERNEL);
203 if (!new_buf) { 203 if (!buf) {
204 ret = -ENOMEM; 204 ret = -ENOMEM;
205 goto failed; 205 goto failed;
206 } 206 }
207 buf = new_buf;
208 } 207 }
209 /* verify record data */ 208 /* verify record data */
210 memcpy_fromio(buf, &dpram[addr + offset], len); 209 memcpy_fromio(buf, &dpram[addr + offset], len);
diff --git a/drivers/net/can/softing/softing_main.c b/drivers/net/can/softing/softing_main.c
index 3a2b45601ec..09a8b86cf1a 100644
--- a/drivers/net/can/softing/softing_main.c
+++ b/drivers/net/can/softing/softing_main.c
@@ -478,7 +478,7 @@ static void softing_card_shutdown(struct softing *card)
478 mutex_unlock(&card->fw.lock); 478 mutex_unlock(&card->fw.lock);
479} 479}
480 480
481static int softing_card_boot(struct softing *card) 481static __devinit int softing_card_boot(struct softing *card)
482{ 482{
483 int ret, j; 483 int ret, j;
484 static const uint8_t stream[] = { 484 static const uint8_t stream[] = {
@@ -645,8 +645,8 @@ static const struct can_bittiming_const softing_btr_const = {
645}; 645};
646 646
647 647
648static struct net_device *softing_netdev_create(struct softing *card, 648static __devinit struct net_device *softing_netdev_create(struct softing *card,
649 uint16_t chip_id) 649 uint16_t chip_id)
650{ 650{
651 struct net_device *netdev; 651 struct net_device *netdev;
652 struct softing_priv *priv; 652 struct softing_priv *priv;
@@ -676,7 +676,7 @@ static struct net_device *softing_netdev_create(struct softing *card,
676 return netdev; 676 return netdev;
677} 677}
678 678
679static int softing_netdev_register(struct net_device *netdev) 679static __devinit int softing_netdev_register(struct net_device *netdev)
680{ 680{
681 int ret; 681 int ret;
682 682
@@ -745,7 +745,7 @@ static const struct attribute_group softing_pdev_group = {
745/* 745/*
746 * platform driver 746 * platform driver
747 */ 747 */
748static int softing_pdev_remove(struct platform_device *pdev) 748static __devexit int softing_pdev_remove(struct platform_device *pdev)
749{ 749{
750 struct softing *card = platform_get_drvdata(pdev); 750 struct softing *card = platform_get_drvdata(pdev);
751 int j; 751 int j;
@@ -766,7 +766,7 @@ static int softing_pdev_remove(struct platform_device *pdev)
766 return 0; 766 return 0;
767} 767}
768 768
769static int softing_pdev_probe(struct platform_device *pdev) 769static __devinit int softing_pdev_probe(struct platform_device *pdev)
770{ 770{
771 const struct softing_platform_data *pdat = pdev->dev.platform_data; 771 const struct softing_platform_data *pdat = pdev->dev.platform_data;
772 struct softing *card; 772 struct softing *card;
@@ -826,12 +826,12 @@ static int softing_pdev_probe(struct platform_device *pdev)
826 goto sysfs_failed; 826 goto sysfs_failed;
827 } 827 }
828 828
829 ret = -ENOMEM;
829 for (j = 0; j < ARRAY_SIZE(card->net); ++j) { 830 for (j = 0; j < ARRAY_SIZE(card->net); ++j) {
830 card->net[j] = netdev = 831 card->net[j] = netdev =
831 softing_netdev_create(card, card->id.chip[j]); 832 softing_netdev_create(card, card->id.chip[j]);
832 if (!netdev) { 833 if (!netdev) {
833 dev_alert(&pdev->dev, "failed to make can[%i]", j); 834 dev_alert(&pdev->dev, "failed to make can[%i]", j);
834 ret = -ENOMEM;
835 goto netdev_failed; 835 goto netdev_failed;
836 } 836 }
837 priv = netdev_priv(card->net[j]); 837 priv = netdev_priv(card->net[j]);
@@ -871,12 +871,24 @@ static struct platform_driver softing_driver = {
871 .owner = THIS_MODULE, 871 .owner = THIS_MODULE,
872 }, 872 },
873 .probe = softing_pdev_probe, 873 .probe = softing_pdev_probe,
874 .remove = softing_pdev_remove, 874 .remove = __devexit_p(softing_pdev_remove),
875}; 875};
876 876
877module_platform_driver(softing_driver);
878
879MODULE_ALIAS("platform:softing"); 877MODULE_ALIAS("platform:softing");
878
879static int __init softing_start(void)
880{
881 return platform_driver_register(&softing_driver);
882}
883
884static void __exit softing_stop(void)
885{
886 platform_driver_unregister(&softing_driver);
887}
888
889module_init(softing_start);
890module_exit(softing_stop);
891
880MODULE_DESCRIPTION("Softing DPRAM CAN driver"); 892MODULE_DESCRIPTION("Softing DPRAM CAN driver");
881MODULE_AUTHOR("Kurt Van Dijck <kurt.van.dijck@eia.be>"); 893MODULE_AUTHOR("Kurt Van Dijck <kurt.van.dijck@eia.be>");
882MODULE_LICENSE("GPL v2"); 894MODULE_LICENSE("GPL v2");
diff --git a/drivers/net/can/ti_hecc.c b/drivers/net/can/ti_hecc.c
index f898c636372..2adc294f512 100644
--- a/drivers/net/can/ti_hecc.c
+++ b/drivers/net/can/ti_hecc.c
@@ -196,7 +196,7 @@ MODULE_VERSION(HECC_MODULE_VERSION);
196#define HECC_CANGIM_SIL BIT(2) /* system interrupts to int line 1 */ 196#define HECC_CANGIM_SIL BIT(2) /* system interrupts to int line 1 */
197 197
198/* CAN Bittiming constants as per HECC specs */ 198/* CAN Bittiming constants as per HECC specs */
199static const struct can_bittiming_const ti_hecc_bittiming_const = { 199static struct can_bittiming_const ti_hecc_bittiming_const = {
200 .name = DRV_NAME, 200 .name = DRV_NAME,
201 .tseg1_min = 1, 201 .tseg1_min = 1,
202 .tseg1_max = 16, 202 .tseg1_max = 16,
@@ -306,7 +306,7 @@ static int ti_hecc_set_btc(struct ti_hecc_priv *priv)
306 if (bit_timing->brp > 4) 306 if (bit_timing->brp > 4)
307 can_btc |= HECC_CANBTC_SAM; 307 can_btc |= HECC_CANBTC_SAM;
308 else 308 else
309 netdev_warn(priv->ndev, "WARN: Triple" 309 dev_warn(priv->ndev->dev.parent, "WARN: Triple" \
310 "sampling not set due to h/w limitations"); 310 "sampling not set due to h/w limitations");
311 } 311 }
312 can_btc |= ((bit_timing->sjw - 1) & 0x3) << 8; 312 can_btc |= ((bit_timing->sjw - 1) & 0x3) << 8;
@@ -315,7 +315,7 @@ static int ti_hecc_set_btc(struct ti_hecc_priv *priv)
315 /* ERM being set to 0 by default meaning resync at falling edge */ 315 /* ERM being set to 0 by default meaning resync at falling edge */
316 316
317 hecc_write(priv, HECC_CANBTC, can_btc); 317 hecc_write(priv, HECC_CANBTC, can_btc);
318 netdev_info(priv->ndev, "setting CANBTC=%#x\n", can_btc); 318 dev_info(priv->ndev->dev.parent, "setting CANBTC=%#x\n", can_btc);
319 319
320 return 0; 320 return 0;
321} 321}
@@ -332,7 +332,7 @@ static void ti_hecc_reset(struct net_device *ndev)
332 u32 cnt; 332 u32 cnt;
333 struct ti_hecc_priv *priv = netdev_priv(ndev); 333 struct ti_hecc_priv *priv = netdev_priv(ndev);
334 334
335 netdev_dbg(ndev, "resetting hecc ...\n"); 335 dev_dbg(ndev->dev.parent, "resetting hecc ...\n");
336 hecc_set_bit(priv, HECC_CANMC, HECC_CANMC_SRES); 336 hecc_set_bit(priv, HECC_CANMC, HECC_CANMC_SRES);
337 337
338 /* Set change control request and wait till enabled */ 338 /* Set change control request and wait till enabled */
@@ -458,17 +458,6 @@ static int ti_hecc_do_set_mode(struct net_device *ndev, enum can_mode mode)
458 return ret; 458 return ret;
459} 459}
460 460
461static int ti_hecc_get_berr_counter(const struct net_device *ndev,
462 struct can_berr_counter *bec)
463{
464 struct ti_hecc_priv *priv = netdev_priv(ndev);
465
466 bec->txerr = hecc_read(priv, HECC_CANTEC);
467 bec->rxerr = hecc_read(priv, HECC_CANREC);
468
469 return 0;
470}
471
472/* 461/*
473 * ti_hecc_xmit: HECC Transmit 462 * ti_hecc_xmit: HECC Transmit
474 * 463 *
@@ -507,7 +496,7 @@ static netdev_tx_t ti_hecc_xmit(struct sk_buff *skb, struct net_device *ndev)
507 if (unlikely(hecc_read(priv, HECC_CANME) & mbx_mask)) { 496 if (unlikely(hecc_read(priv, HECC_CANME) & mbx_mask)) {
508 spin_unlock_irqrestore(&priv->mbx_lock, flags); 497 spin_unlock_irqrestore(&priv->mbx_lock, flags);
509 netif_stop_queue(ndev); 498 netif_stop_queue(ndev);
510 netdev_err(priv->ndev, 499 dev_err(priv->ndev->dev.parent,
511 "BUG: TX mbx not ready tx_head=%08X, tx_tail=%08X\n", 500 "BUG: TX mbx not ready tx_head=%08X, tx_tail=%08X\n",
512 priv->tx_head, priv->tx_tail); 501 priv->tx_head, priv->tx_tail);
513 return NETDEV_TX_BUSY; 502 return NETDEV_TX_BUSY;
@@ -561,7 +550,7 @@ static int ti_hecc_rx_pkt(struct ti_hecc_priv *priv, int mbxno)
561 skb = alloc_can_skb(priv->ndev, &cf); 550 skb = alloc_can_skb(priv->ndev, &cf);
562 if (!skb) { 551 if (!skb) {
563 if (printk_ratelimit()) 552 if (printk_ratelimit())
564 netdev_err(priv->ndev, 553 dev_err(priv->ndev->dev.parent,
565 "ti_hecc_rx_pkt: alloc_can_skb() failed\n"); 554 "ti_hecc_rx_pkt: alloc_can_skb() failed\n");
566 return -ENOMEM; 555 return -ENOMEM;
567 } 556 }
@@ -679,7 +668,7 @@ static int ti_hecc_error(struct net_device *ndev, int int_status,
679 skb = alloc_can_err_skb(ndev, &cf); 668 skb = alloc_can_err_skb(ndev, &cf);
680 if (!skb) { 669 if (!skb) {
681 if (printk_ratelimit()) 670 if (printk_ratelimit())
682 netdev_err(priv->ndev, 671 dev_err(priv->ndev->dev.parent,
683 "ti_hecc_error: alloc_can_err_skb() failed\n"); 672 "ti_hecc_error: alloc_can_err_skb() failed\n");
684 return -ENOMEM; 673 return -ENOMEM;
685 } 674 }
@@ -695,7 +684,7 @@ static int ti_hecc_error(struct net_device *ndev, int int_status,
695 cf->data[1] |= CAN_ERR_CRTL_RX_WARNING; 684 cf->data[1] |= CAN_ERR_CRTL_RX_WARNING;
696 } 685 }
697 hecc_set_bit(priv, HECC_CANES, HECC_CANES_EW); 686 hecc_set_bit(priv, HECC_CANES, HECC_CANES_EW);
698 netdev_dbg(priv->ndev, "Error Warning interrupt\n"); 687 dev_dbg(priv->ndev->dev.parent, "Error Warning interrupt\n");
699 hecc_clear_bit(priv, HECC_CANMC, HECC_CANMC_CCR); 688 hecc_clear_bit(priv, HECC_CANMC, HECC_CANMC_CCR);
700 } 689 }
701 690
@@ -710,7 +699,7 @@ static int ti_hecc_error(struct net_device *ndev, int int_status,
710 cf->data[1] |= CAN_ERR_CRTL_RX_PASSIVE; 699 cf->data[1] |= CAN_ERR_CRTL_RX_PASSIVE;
711 } 700 }
712 hecc_set_bit(priv, HECC_CANES, HECC_CANES_EP); 701 hecc_set_bit(priv, HECC_CANES, HECC_CANES_EP);
713 netdev_dbg(priv->ndev, "Error passive interrupt\n"); 702 dev_dbg(priv->ndev->dev.parent, "Error passive interrupt\n");
714 hecc_clear_bit(priv, HECC_CANMC, HECC_CANMC_CCR); 703 hecc_clear_bit(priv, HECC_CANMC, HECC_CANMC_CCR);
715 } 704 }
716 705
@@ -756,10 +745,9 @@ static int ti_hecc_error(struct net_device *ndev, int int_status,
756 } 745 }
757 } 746 }
758 747
759 netif_rx(skb); 748 netif_receive_skb(skb);
760 stats->rx_packets++; 749 stats->rx_packets++;
761 stats->rx_bytes += cf->can_dlc; 750 stats->rx_bytes += cf->can_dlc;
762
763 return 0; 751 return 0;
764} 752}
765 753
@@ -836,7 +824,7 @@ static int ti_hecc_open(struct net_device *ndev)
836 err = request_irq(ndev->irq, ti_hecc_interrupt, IRQF_SHARED, 824 err = request_irq(ndev->irq, ti_hecc_interrupt, IRQF_SHARED,
837 ndev->name, ndev); 825 ndev->name, ndev);
838 if (err) { 826 if (err) {
839 netdev_err(ndev, "error requesting interrupt\n"); 827 dev_err(ndev->dev.parent, "error requesting interrupt\n");
840 return err; 828 return err;
841 } 829 }
842 830
@@ -845,7 +833,7 @@ static int ti_hecc_open(struct net_device *ndev)
845 /* Open common can device */ 833 /* Open common can device */
846 err = open_candev(ndev); 834 err = open_candev(ndev);
847 if (err) { 835 if (err) {
848 netdev_err(ndev, "open_candev() failed %d\n", err); 836 dev_err(ndev->dev.parent, "open_candev() failed %d\n", err);
849 ti_hecc_transceiver_switch(priv, 0); 837 ti_hecc_transceiver_switch(priv, 0);
850 free_irq(ndev->irq, ndev); 838 free_irq(ndev->irq, ndev);
851 return err; 839 return err;
@@ -934,7 +922,6 @@ static int ti_hecc_probe(struct platform_device *pdev)
934 priv->can.bittiming_const = &ti_hecc_bittiming_const; 922 priv->can.bittiming_const = &ti_hecc_bittiming_const;
935 priv->can.do_set_mode = ti_hecc_do_set_mode; 923 priv->can.do_set_mode = ti_hecc_do_set_mode;
936 priv->can.do_get_state = ti_hecc_get_state; 924 priv->can.do_get_state = ti_hecc_get_state;
937 priv->can.do_get_berr_counter = ti_hecc_get_berr_counter;
938 priv->can.ctrlmode_supported = CAN_CTRLMODE_3_SAMPLES; 925 priv->can.ctrlmode_supported = CAN_CTRLMODE_3_SAMPLES;
939 926
940 spin_lock_init(&priv->mbx_lock); 927 spin_lock_init(&priv->mbx_lock);
@@ -978,18 +965,18 @@ probe_exit:
978 return err; 965 return err;
979} 966}
980 967
981static int ti_hecc_remove(struct platform_device *pdev) 968static int __devexit ti_hecc_remove(struct platform_device *pdev)
982{ 969{
983 struct resource *res; 970 struct resource *res;
984 struct net_device *ndev = platform_get_drvdata(pdev); 971 struct net_device *ndev = platform_get_drvdata(pdev);
985 struct ti_hecc_priv *priv = netdev_priv(ndev); 972 struct ti_hecc_priv *priv = netdev_priv(ndev);
986 973
987 unregister_candev(ndev);
988 clk_disable(priv->clk); 974 clk_disable(priv->clk);
989 clk_put(priv->clk); 975 clk_put(priv->clk);
990 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 976 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
991 iounmap(priv->base); 977 iounmap(priv->base);
992 release_mem_region(res->start, resource_size(res)); 978 release_mem_region(res->start, resource_size(res));
979 unregister_candev(ndev);
993 free_candev(ndev); 980 free_candev(ndev);
994 platform_set_drvdata(pdev, NULL); 981 platform_set_drvdata(pdev, NULL);
995 982
@@ -1045,14 +1032,26 @@ static struct platform_driver ti_hecc_driver = {
1045 .owner = THIS_MODULE, 1032 .owner = THIS_MODULE,
1046 }, 1033 },
1047 .probe = ti_hecc_probe, 1034 .probe = ti_hecc_probe,
1048 .remove = ti_hecc_remove, 1035 .remove = __devexit_p(ti_hecc_remove),
1049 .suspend = ti_hecc_suspend, 1036 .suspend = ti_hecc_suspend,
1050 .resume = ti_hecc_resume, 1037 .resume = ti_hecc_resume,
1051}; 1038};
1052 1039
1053module_platform_driver(ti_hecc_driver); 1040static int __init ti_hecc_init_driver(void)
1041{
1042 printk(KERN_INFO DRV_DESC "\n");
1043 return platform_driver_register(&ti_hecc_driver);
1044}
1045
1046static void __exit ti_hecc_exit_driver(void)
1047{
1048 printk(KERN_INFO DRV_DESC " unloaded\n");
1049 platform_driver_unregister(&ti_hecc_driver);
1050}
1051
1052module_exit(ti_hecc_exit_driver);
1053module_init(ti_hecc_init_driver);
1054 1054
1055MODULE_AUTHOR("Anant Gole <anantgole@ti.com>"); 1055MODULE_AUTHOR("Anant Gole <anantgole@ti.com>");
1056MODULE_LICENSE("GPL v2"); 1056MODULE_LICENSE("GPL v2");
1057MODULE_DESCRIPTION(DRV_DESC); 1057MODULE_DESCRIPTION(DRV_DESC);
1058MODULE_ALIAS("platform:" DRV_NAME);
diff --git a/drivers/net/can/usb/Kconfig b/drivers/net/can/usb/Kconfig
index a4e4bee3571..04525495b15 100644
--- a/drivers/net/can/usb/Kconfig
+++ b/drivers/net/can/usb/Kconfig
@@ -13,39 +13,4 @@ config CAN_ESD_USB2
13 This driver supports the CAN-USB/2 interface 13 This driver supports the CAN-USB/2 interface
14 from esd electronic system design gmbh (http://www.esd.eu). 14 from esd electronic system design gmbh (http://www.esd.eu).
15 15
16config CAN_KVASER_USB
17 tristate "Kvaser CAN/USB interface"
18 ---help---
19 This driver adds support for Kvaser CAN/USB devices like Kvaser
20 Leaf Light.
21
22 The driver gives support for the following devices:
23 - Kvaser Leaf Light
24 - Kvaser Leaf Professional HS
25 - Kvaser Leaf SemiPro HS
26 - Kvaser Leaf Professional LS
27 - Kvaser Leaf Professional SWC
28 - Kvaser Leaf Professional LIN
29 - Kvaser Leaf SemiPro LS
30 - Kvaser Leaf SemiPro SWC
31 - Kvaser Memorator II HS/HS
32 - Kvaser USBcan Professional HS/HS
33 - Kvaser Leaf Light GI
34 - Kvaser Leaf Professional HS (OBD-II connector)
35 - Kvaser Memorator Professional HS/LS
36 - Kvaser Leaf Light "China"
37 - Kvaser BlackBird SemiPro
38 - Kvaser USBcan R
39
40 If unsure, say N.
41
42 To compile this driver as a module, choose M here: the
43 module will be called kvaser_usb.
44
45config CAN_PEAK_USB
46 tristate "PEAK PCAN-USB/USB Pro interfaces"
47 ---help---
48 This driver supports the PCAN-USB and PCAN-USB Pro adapters
49 from PEAK-System Technik (http://www.peak-system.com).
50
51endmenu 16endmenu
diff --git a/drivers/net/can/usb/Makefile b/drivers/net/can/usb/Makefile
index 80a2ee41fd6..fce3cf11719 100644
--- a/drivers/net/can/usb/Makefile
+++ b/drivers/net/can/usb/Makefile
@@ -4,7 +4,5 @@
4 4
5obj-$(CONFIG_CAN_EMS_USB) += ems_usb.o 5obj-$(CONFIG_CAN_EMS_USB) += ems_usb.o
6obj-$(CONFIG_CAN_ESD_USB2) += esd_usb2.o 6obj-$(CONFIG_CAN_ESD_USB2) += esd_usb2.o
7obj-$(CONFIG_CAN_KVASER_USB) += kvaser_usb.o
8obj-$(CONFIG_CAN_PEAK_USB) += peak_usb/
9 7
10ccflags-$(CONFIG_CAN_DEBUG_DEVICES) := -DDEBUG 8ccflags-$(CONFIG_CAN_DEBUG_DEVICES) := -DDEBUG
diff --git a/drivers/net/can/usb/ems_usb.c b/drivers/net/can/usb/ems_usb.c
index c69f0b72b35..a72c7bfb409 100644
--- a/drivers/net/can/usb/ems_usb.c
+++ b/drivers/net/can/usb/ems_usb.c
@@ -245,6 +245,7 @@ struct ems_tx_urb_context {
245 245
246struct ems_usb { 246struct ems_usb {
247 struct can_priv can; /* must be the first member */ 247 struct can_priv can; /* must be the first member */
248 int open_time;
248 249
249 struct sk_buff *echo_skb[MAX_TX_URBS]; 250 struct sk_buff *echo_skb[MAX_TX_URBS];
250 251
@@ -287,7 +288,8 @@ static void ems_usb_read_interrupt_callback(struct urb *urb)
287 return; 288 return;
288 289
289 default: 290 default:
290 netdev_info(netdev, "Rx interrupt aborted %d\n", urb->status); 291 dev_info(netdev->dev.parent, "Rx interrupt aborted %d\n",
292 urb->status);
291 break; 293 break;
292 } 294 }
293 295
@@ -296,7 +298,8 @@ static void ems_usb_read_interrupt_callback(struct urb *urb)
296 if (err == -ENODEV) 298 if (err == -ENODEV)
297 netif_device_detach(netdev); 299 netif_device_detach(netdev);
298 else if (err) 300 else if (err)
299 netdev_err(netdev, "failed resubmitting intr urb: %d\n", err); 301 dev_err(netdev->dev.parent,
302 "failed resubmitting intr urb: %d\n", err);
300} 303}
301 304
302static void ems_usb_rx_can_msg(struct ems_usb *dev, struct ems_cpc_msg *msg) 305static void ems_usb_rx_can_msg(struct ems_usb *dev, struct ems_cpc_msg *msg)
@@ -428,7 +431,8 @@ static void ems_usb_read_bulk_callback(struct urb *urb)
428 return; 431 return;
429 432
430 default: 433 default:
431 netdev_info(netdev, "Rx URB aborted (%d)\n", urb->status); 434 dev_info(netdev->dev.parent, "Rx URB aborted (%d)\n",
435 urb->status);
432 goto resubmit_urb; 436 goto resubmit_urb;
433 } 437 }
434 438
@@ -473,7 +477,7 @@ static void ems_usb_read_bulk_callback(struct urb *urb)
473 msg_count--; 477 msg_count--;
474 478
475 if (start > urb->transfer_buffer_length) { 479 if (start > urb->transfer_buffer_length) {
476 netdev_err(netdev, "format error\n"); 480 dev_err(netdev->dev.parent, "format error\n");
477 break; 481 break;
478 } 482 }
479 } 483 }
@@ -489,8 +493,8 @@ resubmit_urb:
489 if (retval == -ENODEV) 493 if (retval == -ENODEV)
490 netif_device_detach(netdev); 494 netif_device_detach(netdev);
491 else if (retval) 495 else if (retval)
492 netdev_err(netdev, 496 dev_err(netdev->dev.parent,
493 "failed resubmitting read bulk urb: %d\n", retval); 497 "failed resubmitting read bulk urb: %d\n", retval);
494} 498}
495 499
496/* 500/*
@@ -517,7 +521,8 @@ static void ems_usb_write_bulk_callback(struct urb *urb)
517 return; 521 return;
518 522
519 if (urb->status) 523 if (urb->status)
520 netdev_info(netdev, "Tx URB aborted (%d)\n", urb->status); 524 dev_info(netdev->dev.parent, "Tx URB aborted (%d)\n",
525 urb->status);
521 526
522 netdev->trans_start = jiffies; 527 netdev->trans_start = jiffies;
523 528
@@ -600,18 +605,18 @@ static int ems_usb_start(struct ems_usb *dev)
600 /* create a URB, and a buffer for it */ 605 /* create a URB, and a buffer for it */
601 urb = usb_alloc_urb(0, GFP_KERNEL); 606 urb = usb_alloc_urb(0, GFP_KERNEL);
602 if (!urb) { 607 if (!urb) {
603 netdev_err(netdev, "No memory left for URBs\n"); 608 dev_err(netdev->dev.parent,
604 err = -ENOMEM; 609 "No memory left for URBs\n");
605 break; 610 return -ENOMEM;
606 } 611 }
607 612
608 buf = usb_alloc_coherent(dev->udev, RX_BUFFER_SIZE, GFP_KERNEL, 613 buf = usb_alloc_coherent(dev->udev, RX_BUFFER_SIZE, GFP_KERNEL,
609 &urb->transfer_dma); 614 &urb->transfer_dma);
610 if (!buf) { 615 if (!buf) {
611 netdev_err(netdev, "No memory left for USB buffer\n"); 616 dev_err(netdev->dev.parent,
617 "No memory left for USB buffer\n");
612 usb_free_urb(urb); 618 usb_free_urb(urb);
613 err = -ENOMEM; 619 return -ENOMEM;
614 break;
615 } 620 }
616 621
617 usb_fill_bulk_urb(urb, dev->udev, usb_rcvbulkpipe(dev->udev, 2), 622 usb_fill_bulk_urb(urb, dev->udev, usb_rcvbulkpipe(dev->udev, 2),
@@ -622,6 +627,9 @@ static int ems_usb_start(struct ems_usb *dev)
622 627
623 err = usb_submit_urb(urb, GFP_KERNEL); 628 err = usb_submit_urb(urb, GFP_KERNEL);
624 if (err) { 629 if (err) {
630 if (err == -ENODEV)
631 netif_device_detach(dev->netdev);
632
625 usb_unanchor_urb(urb); 633 usb_unanchor_urb(urb);
626 usb_free_coherent(dev->udev, RX_BUFFER_SIZE, buf, 634 usb_free_coherent(dev->udev, RX_BUFFER_SIZE, buf,
627 urb->transfer_dma); 635 urb->transfer_dma);
@@ -634,13 +642,13 @@ static int ems_usb_start(struct ems_usb *dev)
634 642
635 /* Did we submit any URBs */ 643 /* Did we submit any URBs */
636 if (i == 0) { 644 if (i == 0) {
637 netdev_warn(netdev, "couldn't setup read URBs\n"); 645 dev_warn(netdev->dev.parent, "couldn't setup read URBs\n");
638 return err; 646 return err;
639 } 647 }
640 648
641 /* Warn if we've couldn't transmit all the URBs */ 649 /* Warn if we've couldn't transmit all the URBs */
642 if (i < MAX_RX_URBS) 650 if (i < MAX_RX_URBS)
643 netdev_warn(netdev, "rx performance may be slow\n"); 651 dev_warn(netdev->dev.parent, "rx performance may be slow\n");
644 652
645 /* Setup and start interrupt URB */ 653 /* Setup and start interrupt URB */
646 usb_fill_int_urb(dev->intr_urb, dev->udev, 654 usb_fill_int_urb(dev->intr_urb, dev->udev,
@@ -651,7 +659,11 @@ static int ems_usb_start(struct ems_usb *dev)
651 659
652 err = usb_submit_urb(dev->intr_urb, GFP_KERNEL); 660 err = usb_submit_urb(dev->intr_urb, GFP_KERNEL);
653 if (err) { 661 if (err) {
654 netdev_warn(netdev, "intr URB submit failed: %d\n", err); 662 if (err == -ENODEV)
663 netif_device_detach(dev->netdev);
664
665 dev_warn(netdev->dev.parent, "intr URB submit failed: %d\n",
666 err);
655 667
656 return err; 668 return err;
657 } 669 }
@@ -680,7 +692,10 @@ static int ems_usb_start(struct ems_usb *dev)
680 return 0; 692 return 0;
681 693
682failed: 694failed:
683 netdev_warn(netdev, "couldn't submit control: %d\n", err); 695 if (err == -ENODEV)
696 netif_device_detach(dev->netdev);
697
698 dev_warn(netdev->dev.parent, "couldn't submit control: %d\n", err);
684 699
685 return err; 700 return err;
686} 701}
@@ -720,13 +735,15 @@ static int ems_usb_open(struct net_device *netdev)
720 if (err == -ENODEV) 735 if (err == -ENODEV)
721 netif_device_detach(dev->netdev); 736 netif_device_detach(dev->netdev);
722 737
723 netdev_warn(netdev, "couldn't start device: %d\n", err); 738 dev_warn(netdev->dev.parent, "couldn't start device: %d\n",
739 err);
724 740
725 close_candev(netdev); 741 close_candev(netdev);
726 742
727 return err; 743 return err;
728 } 744 }
729 745
746 dev->open_time = jiffies;
730 747
731 netif_start_queue(netdev); 748 netif_start_queue(netdev);
732 749
@@ -752,13 +769,13 @@ static netdev_tx_t ems_usb_start_xmit(struct sk_buff *skb, struct net_device *ne
752 /* create a URB, and a buffer for it, and copy the data to the URB */ 769 /* create a URB, and a buffer for it, and copy the data to the URB */
753 urb = usb_alloc_urb(0, GFP_ATOMIC); 770 urb = usb_alloc_urb(0, GFP_ATOMIC);
754 if (!urb) { 771 if (!urb) {
755 netdev_err(netdev, "No memory left for URBs\n"); 772 dev_err(netdev->dev.parent, "No memory left for URBs\n");
756 goto nomem; 773 goto nomem;
757 } 774 }
758 775
759 buf = usb_alloc_coherent(dev->udev, size, GFP_ATOMIC, &urb->transfer_dma); 776 buf = usb_alloc_coherent(dev->udev, size, GFP_ATOMIC, &urb->transfer_dma);
760 if (!buf) { 777 if (!buf) {
761 netdev_err(netdev, "No memory left for USB buffer\n"); 778 dev_err(netdev->dev.parent, "No memory left for USB buffer\n");
762 usb_free_urb(urb); 779 usb_free_urb(urb);
763 goto nomem; 780 goto nomem;
764 } 781 }
@@ -801,7 +818,7 @@ static netdev_tx_t ems_usb_start_xmit(struct sk_buff *skb, struct net_device *ne
801 usb_unanchor_urb(urb); 818 usb_unanchor_urb(urb);
802 usb_free_coherent(dev->udev, size, buf, urb->transfer_dma); 819 usb_free_coherent(dev->udev, size, buf, urb->transfer_dma);
803 820
804 netdev_warn(netdev, "couldn't find free context\n"); 821 dev_warn(netdev->dev.parent, "couldn't find free context\n");
805 822
806 return NETDEV_TX_BUSY; 823 return NETDEV_TX_BUSY;
807 } 824 }
@@ -832,7 +849,7 @@ static netdev_tx_t ems_usb_start_xmit(struct sk_buff *skb, struct net_device *ne
832 if (err == -ENODEV) { 849 if (err == -ENODEV) {
833 netif_device_detach(netdev); 850 netif_device_detach(netdev);
834 } else { 851 } else {
835 netdev_warn(netdev, "failed tx_urb %d\n", err); 852 dev_warn(netdev->dev.parent, "failed tx_urb %d\n", err);
836 853
837 stats->tx_dropped++; 854 stats->tx_dropped++;
838 } 855 }
@@ -872,10 +889,12 @@ static int ems_usb_close(struct net_device *netdev)
872 889
873 /* Set CAN controller to reset mode */ 890 /* Set CAN controller to reset mode */
874 if (ems_usb_write_mode(dev, SJA1000_MOD_RM)) 891 if (ems_usb_write_mode(dev, SJA1000_MOD_RM))
875 netdev_warn(netdev, "couldn't stop device"); 892 dev_warn(netdev->dev.parent, "couldn't stop device");
876 893
877 close_candev(netdev); 894 close_candev(netdev);
878 895
896 dev->open_time = 0;
897
879 return 0; 898 return 0;
880} 899}
881 900
@@ -885,7 +904,7 @@ static const struct net_device_ops ems_usb_netdev_ops = {
885 .ndo_start_xmit = ems_usb_start_xmit, 904 .ndo_start_xmit = ems_usb_start_xmit,
886}; 905};
887 906
888static const struct can_bittiming_const ems_usb_bittiming_const = { 907static struct can_bittiming_const ems_usb_bittiming_const = {
889 .name = "ems_usb", 908 .name = "ems_usb",
890 .tseg1_min = 1, 909 .tseg1_min = 1,
891 .tseg1_max = 16, 910 .tseg1_max = 16,
@@ -901,10 +920,13 @@ static int ems_usb_set_mode(struct net_device *netdev, enum can_mode mode)
901{ 920{
902 struct ems_usb *dev = netdev_priv(netdev); 921 struct ems_usb *dev = netdev_priv(netdev);
903 922
923 if (!dev->open_time)
924 return -EINVAL;
925
904 switch (mode) { 926 switch (mode) {
905 case CAN_MODE_START: 927 case CAN_MODE_START:
906 if (ems_usb_write_mode(dev, SJA1000_MOD_NORMAL)) 928 if (ems_usb_write_mode(dev, SJA1000_MOD_NORMAL))
907 netdev_warn(netdev, "couldn't start device"); 929 dev_warn(netdev->dev.parent, "couldn't start device");
908 930
909 if (netif_queue_stopped(netdev)) 931 if (netif_queue_stopped(netdev))
910 netif_wake_queue(netdev); 932 netif_wake_queue(netdev);
@@ -929,7 +951,8 @@ static int ems_usb_set_bittiming(struct net_device *netdev)
929 if (dev->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES) 951 if (dev->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES)
930 btr1 |= 0x80; 952 btr1 |= 0x80;
931 953
932 netdev_info(netdev, "setting BTR0=0x%02x BTR1=0x%02x\n", btr0, btr1); 954 dev_info(netdev->dev.parent, "setting BTR0=0x%02x BTR1=0x%02x\n",
955 btr0, btr1);
933 956
934 dev->active_params.msg.can_params.cc_params.sja1000.btr0 = btr0; 957 dev->active_params.msg.can_params.cc_params.sja1000.btr0 = btr0;
935 dev->active_params.msg.can_params.cc_params.sja1000.btr1 = btr1; 958 dev->active_params.msg.can_params.cc_params.sja1000.btr1 = btr1;
@@ -1034,13 +1057,15 @@ static int ems_usb_probe(struct usb_interface *intf,
1034 1057
1035 err = ems_usb_command_msg(dev, &dev->active_params); 1058 err = ems_usb_command_msg(dev, &dev->active_params);
1036 if (err) { 1059 if (err) {
1037 netdev_err(netdev, "couldn't initialize controller: %d\n", err); 1060 dev_err(netdev->dev.parent,
1061 "couldn't initialize controller: %d\n", err);
1038 goto cleanup_tx_msg_buffer; 1062 goto cleanup_tx_msg_buffer;
1039 } 1063 }
1040 1064
1041 err = register_candev(netdev); 1065 err = register_candev(netdev);
1042 if (err) { 1066 if (err) {
1043 netdev_err(netdev, "couldn't register CAN device: %d\n", err); 1067 dev_err(netdev->dev.parent,
1068 "couldn't register CAN device: %d\n", err);
1044 goto cleanup_tx_msg_buffer; 1069 goto cleanup_tx_msg_buffer;
1045 } 1070 }
1046 1071
@@ -1090,4 +1115,28 @@ static struct usb_driver ems_usb_driver = {
1090 .id_table = ems_usb_table, 1115 .id_table = ems_usb_table,
1091}; 1116};
1092 1117
1093module_usb_driver(ems_usb_driver); 1118static int __init ems_usb_init(void)
1119{
1120 int err;
1121
1122 printk(KERN_INFO "CPC-USB kernel driver loaded\n");
1123
1124 /* register this driver with the USB subsystem */
1125 err = usb_register(&ems_usb_driver);
1126
1127 if (err) {
1128 err("usb_register failed. Error number %d\n", err);
1129 return err;
1130 }
1131
1132 return 0;
1133}
1134
1135static void __exit ems_usb_exit(void)
1136{
1137 /* deregister this driver with the USB subsystem */
1138 usb_deregister(&ems_usb_driver);
1139}
1140
1141module_init(ems_usb_init);
1142module_exit(ems_usb_exit);
diff --git a/drivers/net/can/usb/esd_usb2.c b/drivers/net/can/usb/esd_usb2.c
index 9b74d1e3ad4..eb8b0e60028 100644
--- a/drivers/net/can/usb/esd_usb2.c
+++ b/drivers/net/can/usb/esd_usb2.c
@@ -1,7 +1,7 @@
1/* 1/*
2 * CAN driver for esd CAN-USB/2 and CAN-USB/Micro 2 * CAN driver for esd CAN-USB/2
3 * 3 *
4 * Copyright (C) 2010-2012 Matthias Fuchs <matthias.fuchs@esd.eu>, esd gmbh 4 * Copyright (C) 2010 Matthias Fuchs <matthias.fuchs@esd.eu>, esd gmbh
5 * 5 *
6 * This program is free software; you can redistribute it and/or modify it 6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published 7 * under the terms of the GNU General Public License as published
@@ -28,16 +28,14 @@
28#include <linux/can/error.h> 28#include <linux/can/error.h>
29 29
30MODULE_AUTHOR("Matthias Fuchs <matthias.fuchs@esd.eu>"); 30MODULE_AUTHOR("Matthias Fuchs <matthias.fuchs@esd.eu>");
31MODULE_DESCRIPTION("CAN driver for esd CAN-USB/2 and CAN-USB/Micro interfaces"); 31MODULE_DESCRIPTION("CAN driver for esd CAN-USB/2 interfaces");
32MODULE_LICENSE("GPL v2"); 32MODULE_LICENSE("GPL v2");
33 33
34/* Define these values to match your devices */ 34/* Define these values to match your devices */
35#define USB_ESDGMBH_VENDOR_ID 0x0ab4 35#define USB_ESDGMBH_VENDOR_ID 0x0ab4
36#define USB_CANUSB2_PRODUCT_ID 0x0010 36#define USB_CANUSB2_PRODUCT_ID 0x0010
37#define USB_CANUSBM_PRODUCT_ID 0x0011
38 37
39#define ESD_USB2_CAN_CLOCK 60000000 38#define ESD_USB2_CAN_CLOCK 60000000
40#define ESD_USBM_CAN_CLOCK 36000000
41#define ESD_USB2_MAX_NETS 2 39#define ESD_USB2_MAX_NETS 2
42 40
43/* USB2 commands */ 41/* USB2 commands */
@@ -71,7 +69,6 @@ MODULE_LICENSE("GPL v2");
71#define ESD_USB2_TSEG2_SHIFT 20 69#define ESD_USB2_TSEG2_SHIFT 20
72#define ESD_USB2_SJW_MAX 4 70#define ESD_USB2_SJW_MAX 4
73#define ESD_USB2_SJW_SHIFT 14 71#define ESD_USB2_SJW_SHIFT 14
74#define ESD_USBM_SJW_SHIFT 24
75#define ESD_USB2_BRP_MIN 1 72#define ESD_USB2_BRP_MIN 1
76#define ESD_USB2_BRP_MAX 1024 73#define ESD_USB2_BRP_MAX 1024
77#define ESD_USB2_BRP_INC 1 74#define ESD_USB2_BRP_INC 1
@@ -186,7 +183,6 @@ struct __attribute__ ((packed)) esd_usb2_msg {
186 183
187static struct usb_device_id esd_usb2_table[] = { 184static struct usb_device_id esd_usb2_table[] = {
188 {USB_DEVICE(USB_ESDGMBH_VENDOR_ID, USB_CANUSB2_PRODUCT_ID)}, 185 {USB_DEVICE(USB_ESDGMBH_VENDOR_ID, USB_CANUSB2_PRODUCT_ID)},
189 {USB_DEVICE(USB_ESDGMBH_VENDOR_ID, USB_CANUSBM_PRODUCT_ID)},
190 {} 186 {}
191}; 187};
192MODULE_DEVICE_TABLE(usb, esd_usb2_table); 188MODULE_DEVICE_TABLE(usb, esd_usb2_table);
@@ -217,6 +213,7 @@ struct esd_usb2_net_priv {
217 struct usb_anchor tx_submitted; 213 struct usb_anchor tx_submitted;
218 struct esd_tx_urb_context tx_contexts[MAX_TX_URBS]; 214 struct esd_tx_urb_context tx_contexts[MAX_TX_URBS];
219 215
216 int open_time;
220 struct esd_usb2 *usb2; 217 struct esd_usb2 *usb2;
221 struct net_device *netdev; 218 struct net_device *netdev;
222 int index; 219 int index;
@@ -473,7 +470,8 @@ static void esd_usb2_write_bulk_callback(struct urb *urb)
473 return; 470 return;
474 471
475 if (urb->status) 472 if (urb->status)
476 netdev_info(netdev, "Tx URB aborted (%d)\n", urb->status); 473 dev_info(netdev->dev.parent, "Tx URB aborted (%d)\n",
474 urb->status);
477 475
478 netdev->trans_start = jiffies; 476 netdev->trans_start = jiffies;
479} 477}
@@ -653,7 +651,7 @@ failed:
653 if (err == -ENODEV) 651 if (err == -ENODEV)
654 netif_device_detach(netdev); 652 netif_device_detach(netdev);
655 653
656 netdev_err(netdev, "couldn't start device: %d\n", err); 654 dev_err(netdev->dev.parent, "couldn't start device: %d\n", err);
657 655
658 return err; 656 return err;
659} 657}
@@ -689,11 +687,14 @@ static int esd_usb2_open(struct net_device *netdev)
689 /* finally start device */ 687 /* finally start device */
690 err = esd_usb2_start(priv); 688 err = esd_usb2_start(priv);
691 if (err) { 689 if (err) {
692 netdev_warn(netdev, "couldn't start device: %d\n", err); 690 dev_warn(netdev->dev.parent,
691 "couldn't start device: %d\n", err);
693 close_candev(netdev); 692 close_candev(netdev);
694 return err; 693 return err;
695 } 694 }
696 695
696 priv->open_time = jiffies;
697
697 netif_start_queue(netdev); 698 netif_start_queue(netdev);
698 699
699 return 0; 700 return 0;
@@ -720,7 +721,7 @@ static netdev_tx_t esd_usb2_start_xmit(struct sk_buff *skb,
720 /* create a URB, and a buffer for it, and copy the data to the URB */ 721 /* create a URB, and a buffer for it, and copy the data to the URB */
721 urb = usb_alloc_urb(0, GFP_ATOMIC); 722 urb = usb_alloc_urb(0, GFP_ATOMIC);
722 if (!urb) { 723 if (!urb) {
723 netdev_err(netdev, "No memory left for URBs\n"); 724 dev_err(netdev->dev.parent, "No memory left for URBs\n");
724 stats->tx_dropped++; 725 stats->tx_dropped++;
725 dev_kfree_skb(skb); 726 dev_kfree_skb(skb);
726 goto nourbmem; 727 goto nourbmem;
@@ -729,7 +730,7 @@ static netdev_tx_t esd_usb2_start_xmit(struct sk_buff *skb,
729 buf = usb_alloc_coherent(dev->udev, size, GFP_ATOMIC, 730 buf = usb_alloc_coherent(dev->udev, size, GFP_ATOMIC,
730 &urb->transfer_dma); 731 &urb->transfer_dma);
731 if (!buf) { 732 if (!buf) {
732 netdev_err(netdev, "No memory left for USB buffer\n"); 733 dev_err(netdev->dev.parent, "No memory left for USB buffer\n");
733 stats->tx_dropped++; 734 stats->tx_dropped++;
734 dev_kfree_skb(skb); 735 dev_kfree_skb(skb);
735 goto nobufmem; 736 goto nobufmem;
@@ -765,7 +766,7 @@ static netdev_tx_t esd_usb2_start_xmit(struct sk_buff *skb,
765 * This may never happen. 766 * This may never happen.
766 */ 767 */
767 if (!context) { 768 if (!context) {
768 netdev_warn(netdev, "couldn't find free context\n"); 769 dev_warn(netdev->dev.parent, "couldn't find free context\n");
769 ret = NETDEV_TX_BUSY; 770 ret = NETDEV_TX_BUSY;
770 goto releasebuf; 771 goto releasebuf;
771 } 772 }
@@ -805,7 +806,7 @@ static netdev_tx_t esd_usb2_start_xmit(struct sk_buff *skb,
805 if (err == -ENODEV) 806 if (err == -ENODEV)
806 netif_device_detach(netdev); 807 netif_device_detach(netdev);
807 else 808 else
808 netdev_warn(netdev, "failed tx_urb %d\n", err); 809 dev_warn(netdev->dev.parent, "failed tx_urb %d\n", err);
809 810
810 goto releasebuf; 811 goto releasebuf;
811 } 812 }
@@ -844,7 +845,7 @@ static int esd_usb2_close(struct net_device *netdev)
844 for (i = 0; i <= ESD_MAX_ID_SEGMENT; i++) 845 for (i = 0; i <= ESD_MAX_ID_SEGMENT; i++)
845 msg.msg.filter.mask[i] = 0; 846 msg.msg.filter.mask[i] = 0;
846 if (esd_usb2_send_msg(priv->usb2, &msg) < 0) 847 if (esd_usb2_send_msg(priv->usb2, &msg) < 0)
847 netdev_err(netdev, "sending idadd message failed\n"); 848 dev_err(netdev->dev.parent, "sending idadd message failed\n");
848 849
849 /* set CAN controller to reset mode */ 850 /* set CAN controller to reset mode */
850 msg.msg.hdr.len = 2; 851 msg.msg.hdr.len = 2;
@@ -853,7 +854,7 @@ static int esd_usb2_close(struct net_device *netdev)
853 msg.msg.setbaud.rsvd = 0; 854 msg.msg.setbaud.rsvd = 0;
854 msg.msg.setbaud.baud = cpu_to_le32(ESD_USB2_NO_BAUDRATE); 855 msg.msg.setbaud.baud = cpu_to_le32(ESD_USB2_NO_BAUDRATE);
855 if (esd_usb2_send_msg(priv->usb2, &msg) < 0) 856 if (esd_usb2_send_msg(priv->usb2, &msg) < 0)
856 netdev_err(netdev, "sending setbaud message failed\n"); 857 dev_err(netdev->dev.parent, "sending setbaud message failed\n");
857 858
858 priv->can.state = CAN_STATE_STOPPED; 859 priv->can.state = CAN_STATE_STOPPED;
859 860
@@ -861,6 +862,8 @@ static int esd_usb2_close(struct net_device *netdev)
861 862
862 close_candev(netdev); 863 close_candev(netdev);
863 864
865 priv->open_time = 0;
866
864 return 0; 867 return 0;
865} 868}
866 869
@@ -870,7 +873,7 @@ static const struct net_device_ops esd_usb2_netdev_ops = {
870 .ndo_start_xmit = esd_usb2_start_xmit, 873 .ndo_start_xmit = esd_usb2_start_xmit,
871}; 874};
872 875
873static const struct can_bittiming_const esd_usb2_bittiming_const = { 876static struct can_bittiming_const esd_usb2_bittiming_const = {
874 .name = "esd_usb2", 877 .name = "esd_usb2",
875 .tseg1_min = ESD_USB2_TSEG1_MIN, 878 .tseg1_min = ESD_USB2_TSEG1_MIN,
876 .tseg1_max = ESD_USB2_TSEG1_MAX, 879 .tseg1_max = ESD_USB2_TSEG1_MAX,
@@ -888,22 +891,11 @@ static int esd_usb2_set_bittiming(struct net_device *netdev)
888 struct can_bittiming *bt = &priv->can.bittiming; 891 struct can_bittiming *bt = &priv->can.bittiming;
889 struct esd_usb2_msg msg; 892 struct esd_usb2_msg msg;
890 u32 canbtr; 893 u32 canbtr;
891 int sjw_shift;
892 894
893 canbtr = ESD_USB2_UBR; 895 canbtr = ESD_USB2_UBR;
894 if (priv->can.ctrlmode & CAN_CTRLMODE_LISTENONLY)
895 canbtr |= ESD_USB2_LOM;
896
897 canbtr |= (bt->brp - 1) & (ESD_USB2_BRP_MAX - 1); 896 canbtr |= (bt->brp - 1) & (ESD_USB2_BRP_MAX - 1);
898
899 if (le16_to_cpu(priv->usb2->udev->descriptor.idProduct) ==
900 USB_CANUSBM_PRODUCT_ID)
901 sjw_shift = ESD_USBM_SJW_SHIFT;
902 else
903 sjw_shift = ESD_USB2_SJW_SHIFT;
904
905 canbtr |= ((bt->sjw - 1) & (ESD_USB2_SJW_MAX - 1)) 897 canbtr |= ((bt->sjw - 1) & (ESD_USB2_SJW_MAX - 1))
906 << sjw_shift; 898 << ESD_USB2_SJW_SHIFT;
907 canbtr |= ((bt->prop_seg + bt->phase_seg1 - 1) 899 canbtr |= ((bt->prop_seg + bt->phase_seg1 - 1)
908 & (ESD_USB2_TSEG1_MAX - 1)) 900 & (ESD_USB2_TSEG1_MAX - 1))
909 << ESD_USB2_TSEG1_SHIFT; 901 << ESD_USB2_TSEG1_SHIFT;
@@ -918,7 +910,7 @@ static int esd_usb2_set_bittiming(struct net_device *netdev)
918 msg.msg.setbaud.rsvd = 0; 910 msg.msg.setbaud.rsvd = 0;
919 msg.msg.setbaud.baud = cpu_to_le32(canbtr); 911 msg.msg.setbaud.baud = cpu_to_le32(canbtr);
920 912
921 netdev_info(netdev, "setting BTR=%#x\n", canbtr); 913 dev_info(netdev->dev.parent, "setting BTR=%#x\n", canbtr);
922 914
923 return esd_usb2_send_msg(priv->usb2, &msg); 915 return esd_usb2_send_msg(priv->usb2, &msg);
924} 916}
@@ -936,6 +928,11 @@ static int esd_usb2_get_berr_counter(const struct net_device *netdev,
936 928
937static int esd_usb2_set_mode(struct net_device *netdev, enum can_mode mode) 929static int esd_usb2_set_mode(struct net_device *netdev, enum can_mode mode)
938{ 930{
931 struct esd_usb2_net_priv *priv = netdev_priv(netdev);
932
933 if (!priv->open_time)
934 return -EINVAL;
935
939 switch (mode) { 936 switch (mode) {
940 case CAN_MODE_START: 937 case CAN_MODE_START:
941 netif_wake_queue(netdev); 938 netif_wake_queue(netdev);
@@ -976,20 +973,12 @@ static int esd_usb2_probe_one_net(struct usb_interface *intf, int index)
976 priv->index = index; 973 priv->index = index;
977 974
978 priv->can.state = CAN_STATE_STOPPED; 975 priv->can.state = CAN_STATE_STOPPED;
979 priv->can.ctrlmode_supported = CAN_CTRLMODE_LISTENONLY; 976 priv->can.clock.freq = ESD_USB2_CAN_CLOCK;
980
981 if (le16_to_cpu(dev->udev->descriptor.idProduct) ==
982 USB_CANUSBM_PRODUCT_ID)
983 priv->can.clock.freq = ESD_USBM_CAN_CLOCK;
984 else {
985 priv->can.clock.freq = ESD_USB2_CAN_CLOCK;
986 priv->can.ctrlmode_supported |= CAN_CTRLMODE_3_SAMPLES;
987 }
988
989 priv->can.bittiming_const = &esd_usb2_bittiming_const; 977 priv->can.bittiming_const = &esd_usb2_bittiming_const;
990 priv->can.do_set_bittiming = esd_usb2_set_bittiming; 978 priv->can.do_set_bittiming = esd_usb2_set_bittiming;
991 priv->can.do_set_mode = esd_usb2_set_mode; 979 priv->can.do_set_mode = esd_usb2_set_mode;
992 priv->can.do_get_berr_counter = esd_usb2_get_berr_counter; 980 priv->can.do_get_berr_counter = esd_usb2_get_berr_counter;
981 priv->can.ctrlmode_supported = CAN_CTRLMODE_3_SAMPLES;
993 982
994 netdev->flags |= IFF_ECHO; /* we support local echo */ 983 netdev->flags |= IFF_ECHO; /* we support local echo */
995 984
@@ -999,14 +988,15 @@ static int esd_usb2_probe_one_net(struct usb_interface *intf, int index)
999 988
1000 err = register_candev(netdev); 989 err = register_candev(netdev);
1001 if (err) { 990 if (err) {
1002 dev_err(&intf->dev, "couldn't register CAN device: %d\n", err); 991 dev_err(&intf->dev,
992 "couldn't register CAN device: %d\n", err);
1003 free_candev(netdev); 993 free_candev(netdev);
1004 err = -ENOMEM; 994 err = -ENOMEM;
1005 goto done; 995 goto done;
1006 } 996 }
1007 997
1008 dev->nets[index] = priv; 998 dev->nets[index] = priv;
1009 netdev_info(netdev, "device %s registered\n", netdev->name); 999 dev_info(netdev->dev.parent, "device %s registered\n", netdev->name);
1010 1000
1011done: 1001done:
1012 return err; 1002 return err;
@@ -1118,4 +1108,25 @@ static struct usb_driver esd_usb2_driver = {
1118 .id_table = esd_usb2_table, 1108 .id_table = esd_usb2_table,
1119}; 1109};
1120 1110
1121module_usb_driver(esd_usb2_driver); 1111static int __init esd_usb2_init(void)
1112{
1113 int err;
1114
1115 /* register this driver with the USB subsystem */
1116 err = usb_register(&esd_usb2_driver);
1117
1118 if (err) {
1119 err("usb_register failed. Error number %d\n", err);
1120 return err;
1121 }
1122
1123 return 0;
1124}
1125module_init(esd_usb2_init);
1126
1127static void __exit esd_usb2_exit(void)
1128{
1129 /* deregister this driver with the USB subsystem */
1130 usb_deregister(&esd_usb2_driver);
1131}
1132module_exit(esd_usb2_exit);
diff --git a/drivers/net/can/usb/kvaser_usb.c b/drivers/net/can/usb/kvaser_usb.c
deleted file mode 100644
index 5b58a4d8739..00000000000
--- a/drivers/net/can/usb/kvaser_usb.c
+++ /dev/null
@@ -1,1627 +0,0 @@
1/*
2 * This program is free software; you can redistribute it and/or
3 * modify it under the terms of the GNU General Public License as
4 * published by the Free Software Foundation version 2.
5 *
6 * Parts of this driver are based on the following:
7 * - Kvaser linux leaf driver (version 4.78)
8 * - CAN driver for esd CAN-USB/2
9 *
10 * Copyright (C) 2002-2006 KVASER AB, Sweden. All rights reserved.
11 * Copyright (C) 2010 Matthias Fuchs <matthias.fuchs@esd.eu>, esd gmbh
12 * Copyright (C) 2012 Olivier Sobrie <olivier@sobrie.be>
13 */
14
15#include <linux/init.h>
16#include <linux/completion.h>
17#include <linux/module.h>
18#include <linux/netdevice.h>
19#include <linux/usb.h>
20
21#include <linux/can.h>
22#include <linux/can/dev.h>
23#include <linux/can/error.h>
24
25#define MAX_TX_URBS 16
26#define MAX_RX_URBS 4
27#define START_TIMEOUT 1000 /* msecs */
28#define STOP_TIMEOUT 1000 /* msecs */
29#define USB_SEND_TIMEOUT 1000 /* msecs */
30#define USB_RECV_TIMEOUT 1000 /* msecs */
31#define RX_BUFFER_SIZE 3072
32#define CAN_USB_CLOCK 8000000
33#define MAX_NET_DEVICES 3
34
35/* Kvaser USB devices */
36#define KVASER_VENDOR_ID 0x0bfd
37#define USB_LEAF_DEVEL_PRODUCT_ID 10
38#define USB_LEAF_LITE_PRODUCT_ID 11
39#define USB_LEAF_PRO_PRODUCT_ID 12
40#define USB_LEAF_SPRO_PRODUCT_ID 14
41#define USB_LEAF_PRO_LS_PRODUCT_ID 15
42#define USB_LEAF_PRO_SWC_PRODUCT_ID 16
43#define USB_LEAF_PRO_LIN_PRODUCT_ID 17
44#define USB_LEAF_SPRO_LS_PRODUCT_ID 18
45#define USB_LEAF_SPRO_SWC_PRODUCT_ID 19
46#define USB_MEMO2_DEVEL_PRODUCT_ID 22
47#define USB_MEMO2_HSHS_PRODUCT_ID 23
48#define USB_UPRO_HSHS_PRODUCT_ID 24
49#define USB_LEAF_LITE_GI_PRODUCT_ID 25
50#define USB_LEAF_PRO_OBDII_PRODUCT_ID 26
51#define USB_MEMO2_HSLS_PRODUCT_ID 27
52#define USB_LEAF_LITE_CH_PRODUCT_ID 28
53#define USB_BLACKBIRD_SPRO_PRODUCT_ID 29
54#define USB_OEM_MERCURY_PRODUCT_ID 34
55#define USB_OEM_LEAF_PRODUCT_ID 35
56#define USB_CAN_R_PRODUCT_ID 39
57
58/* USB devices features */
59#define KVASER_HAS_SILENT_MODE BIT(0)
60#define KVASER_HAS_TXRX_ERRORS BIT(1)
61
62/* Message header size */
63#define MSG_HEADER_LEN 2
64
65/* Can message flags */
66#define MSG_FLAG_ERROR_FRAME BIT(0)
67#define MSG_FLAG_OVERRUN BIT(1)
68#define MSG_FLAG_NERR BIT(2)
69#define MSG_FLAG_WAKEUP BIT(3)
70#define MSG_FLAG_REMOTE_FRAME BIT(4)
71#define MSG_FLAG_RESERVED BIT(5)
72#define MSG_FLAG_TX_ACK BIT(6)
73#define MSG_FLAG_TX_REQUEST BIT(7)
74
75/* Can states */
76#define M16C_STATE_BUS_RESET BIT(0)
77#define M16C_STATE_BUS_ERROR BIT(4)
78#define M16C_STATE_BUS_PASSIVE BIT(5)
79#define M16C_STATE_BUS_OFF BIT(6)
80
81/* Can msg ids */
82#define CMD_RX_STD_MESSAGE 12
83#define CMD_TX_STD_MESSAGE 13
84#define CMD_RX_EXT_MESSAGE 14
85#define CMD_TX_EXT_MESSAGE 15
86#define CMD_SET_BUS_PARAMS 16
87#define CMD_GET_BUS_PARAMS 17
88#define CMD_GET_BUS_PARAMS_REPLY 18
89#define CMD_GET_CHIP_STATE 19
90#define CMD_CHIP_STATE_EVENT 20
91#define CMD_SET_CTRL_MODE 21
92#define CMD_GET_CTRL_MODE 22
93#define CMD_GET_CTRL_MODE_REPLY 23
94#define CMD_RESET_CHIP 24
95#define CMD_RESET_CARD 25
96#define CMD_START_CHIP 26
97#define CMD_START_CHIP_REPLY 27
98#define CMD_STOP_CHIP 28
99#define CMD_STOP_CHIP_REPLY 29
100#define CMD_GET_CARD_INFO2 32
101#define CMD_GET_CARD_INFO 34
102#define CMD_GET_CARD_INFO_REPLY 35
103#define CMD_GET_SOFTWARE_INFO 38
104#define CMD_GET_SOFTWARE_INFO_REPLY 39
105#define CMD_ERROR_EVENT 45
106#define CMD_FLUSH_QUEUE 48
107#define CMD_RESET_ERROR_COUNTER 49
108#define CMD_TX_ACKNOWLEDGE 50
109#define CMD_CAN_ERROR_EVENT 51
110#define CMD_USB_THROTTLE 77
111#define CMD_LOG_MESSAGE 106
112
113/* error factors */
114#define M16C_EF_ACKE BIT(0)
115#define M16C_EF_CRCE BIT(1)
116#define M16C_EF_FORME BIT(2)
117#define M16C_EF_STFE BIT(3)
118#define M16C_EF_BITE0 BIT(4)
119#define M16C_EF_BITE1 BIT(5)
120#define M16C_EF_RCVE BIT(6)
121#define M16C_EF_TRE BIT(7)
122
123/* bittiming parameters */
124#define KVASER_USB_TSEG1_MIN 1
125#define KVASER_USB_TSEG1_MAX 16
126#define KVASER_USB_TSEG2_MIN 1
127#define KVASER_USB_TSEG2_MAX 8
128#define KVASER_USB_SJW_MAX 4
129#define KVASER_USB_BRP_MIN 1
130#define KVASER_USB_BRP_MAX 64
131#define KVASER_USB_BRP_INC 1
132
133/* ctrl modes */
134#define KVASER_CTRL_MODE_NORMAL 1
135#define KVASER_CTRL_MODE_SILENT 2
136#define KVASER_CTRL_MODE_SELFRECEPTION 3
137#define KVASER_CTRL_MODE_OFF 4
138
139struct kvaser_msg_simple {
140 u8 tid;
141 u8 channel;
142} __packed;
143
144struct kvaser_msg_cardinfo {
145 u8 tid;
146 u8 nchannels;
147 __le32 serial_number;
148 __le32 padding;
149 __le32 clock_resolution;
150 __le32 mfgdate;
151 u8 ean[8];
152 u8 hw_revision;
153 u8 usb_hs_mode;
154 __le16 padding2;
155} __packed;
156
157struct kvaser_msg_cardinfo2 {
158 u8 tid;
159 u8 channel;
160 u8 pcb_id[24];
161 __le32 oem_unlock_code;
162} __packed;
163
164struct kvaser_msg_softinfo {
165 u8 tid;
166 u8 channel;
167 __le32 sw_options;
168 __le32 fw_version;
169 __le16 max_outstanding_tx;
170 __le16 padding[9];
171} __packed;
172
173struct kvaser_msg_busparams {
174 u8 tid;
175 u8 channel;
176 __le32 bitrate;
177 u8 tseg1;
178 u8 tseg2;
179 u8 sjw;
180 u8 no_samp;
181} __packed;
182
183struct kvaser_msg_tx_can {
184 u8 channel;
185 u8 tid;
186 u8 msg[14];
187 u8 padding;
188 u8 flags;
189} __packed;
190
191struct kvaser_msg_rx_can {
192 u8 channel;
193 u8 flag;
194 __le16 time[3];
195 u8 msg[14];
196} __packed;
197
198struct kvaser_msg_chip_state_event {
199 u8 tid;
200 u8 channel;
201 __le16 time[3];
202 u8 tx_errors_count;
203 u8 rx_errors_count;
204 u8 status;
205 u8 padding[3];
206} __packed;
207
208struct kvaser_msg_tx_acknowledge {
209 u8 channel;
210 u8 tid;
211 __le16 time[3];
212 u8 flags;
213 u8 time_offset;
214} __packed;
215
216struct kvaser_msg_error_event {
217 u8 tid;
218 u8 flags;
219 __le16 time[3];
220 u8 channel;
221 u8 padding;
222 u8 tx_errors_count;
223 u8 rx_errors_count;
224 u8 status;
225 u8 error_factor;
226} __packed;
227
228struct kvaser_msg_ctrl_mode {
229 u8 tid;
230 u8 channel;
231 u8 ctrl_mode;
232 u8 padding[3];
233} __packed;
234
235struct kvaser_msg_flush_queue {
236 u8 tid;
237 u8 channel;
238 u8 flags;
239 u8 padding[3];
240} __packed;
241
242struct kvaser_msg_log_message {
243 u8 channel;
244 u8 flags;
245 __le16 time[3];
246 u8 dlc;
247 u8 time_offset;
248 __le32 id;
249 u8 data[8];
250} __packed;
251
252struct kvaser_msg {
253 u8 len;
254 u8 id;
255 union {
256 struct kvaser_msg_simple simple;
257 struct kvaser_msg_cardinfo cardinfo;
258 struct kvaser_msg_cardinfo2 cardinfo2;
259 struct kvaser_msg_softinfo softinfo;
260 struct kvaser_msg_busparams busparams;
261 struct kvaser_msg_tx_can tx_can;
262 struct kvaser_msg_rx_can rx_can;
263 struct kvaser_msg_chip_state_event chip_state_event;
264 struct kvaser_msg_tx_acknowledge tx_acknowledge;
265 struct kvaser_msg_error_event error_event;
266 struct kvaser_msg_ctrl_mode ctrl_mode;
267 struct kvaser_msg_flush_queue flush_queue;
268 struct kvaser_msg_log_message log_message;
269 } u;
270} __packed;
271
272struct kvaser_usb_tx_urb_context {
273 struct kvaser_usb_net_priv *priv;
274 u32 echo_index;
275 int dlc;
276};
277
278struct kvaser_usb {
279 struct usb_device *udev;
280 struct kvaser_usb_net_priv *nets[MAX_NET_DEVICES];
281
282 struct usb_endpoint_descriptor *bulk_in, *bulk_out;
283 struct usb_anchor rx_submitted;
284
285 u32 fw_version;
286 unsigned int nchannels;
287
288 bool rxinitdone;
289 void *rxbuf[MAX_RX_URBS];
290 dma_addr_t rxbuf_dma[MAX_RX_URBS];
291};
292
293struct kvaser_usb_net_priv {
294 struct can_priv can;
295
296 atomic_t active_tx_urbs;
297 struct usb_anchor tx_submitted;
298 struct kvaser_usb_tx_urb_context tx_contexts[MAX_TX_URBS];
299
300 struct completion start_comp, stop_comp;
301
302 struct kvaser_usb *dev;
303 struct net_device *netdev;
304 int channel;
305
306 struct can_berr_counter bec;
307};
308
309static const struct usb_device_id kvaser_usb_table[] = {
310 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_DEVEL_PRODUCT_ID) },
311 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_LITE_PRODUCT_ID) },
312 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_PRO_PRODUCT_ID),
313 .driver_info = KVASER_HAS_TXRX_ERRORS |
314 KVASER_HAS_SILENT_MODE },
315 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_SPRO_PRODUCT_ID),
316 .driver_info = KVASER_HAS_TXRX_ERRORS |
317 KVASER_HAS_SILENT_MODE },
318 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_PRO_LS_PRODUCT_ID),
319 .driver_info = KVASER_HAS_TXRX_ERRORS |
320 KVASER_HAS_SILENT_MODE },
321 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_PRO_SWC_PRODUCT_ID),
322 .driver_info = KVASER_HAS_TXRX_ERRORS |
323 KVASER_HAS_SILENT_MODE },
324 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_PRO_LIN_PRODUCT_ID),
325 .driver_info = KVASER_HAS_TXRX_ERRORS |
326 KVASER_HAS_SILENT_MODE },
327 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_SPRO_LS_PRODUCT_ID),
328 .driver_info = KVASER_HAS_TXRX_ERRORS |
329 KVASER_HAS_SILENT_MODE },
330 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_SPRO_SWC_PRODUCT_ID),
331 .driver_info = KVASER_HAS_TXRX_ERRORS |
332 KVASER_HAS_SILENT_MODE },
333 { USB_DEVICE(KVASER_VENDOR_ID, USB_MEMO2_DEVEL_PRODUCT_ID),
334 .driver_info = KVASER_HAS_TXRX_ERRORS |
335 KVASER_HAS_SILENT_MODE },
336 { USB_DEVICE(KVASER_VENDOR_ID, USB_MEMO2_HSHS_PRODUCT_ID),
337 .driver_info = KVASER_HAS_TXRX_ERRORS |
338 KVASER_HAS_SILENT_MODE },
339 { USB_DEVICE(KVASER_VENDOR_ID, USB_UPRO_HSHS_PRODUCT_ID),
340 .driver_info = KVASER_HAS_TXRX_ERRORS },
341 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_LITE_GI_PRODUCT_ID) },
342 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_PRO_OBDII_PRODUCT_ID),
343 .driver_info = KVASER_HAS_TXRX_ERRORS |
344 KVASER_HAS_SILENT_MODE },
345 { USB_DEVICE(KVASER_VENDOR_ID, USB_MEMO2_HSLS_PRODUCT_ID),
346 .driver_info = KVASER_HAS_TXRX_ERRORS },
347 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_LITE_CH_PRODUCT_ID),
348 .driver_info = KVASER_HAS_TXRX_ERRORS },
349 { USB_DEVICE(KVASER_VENDOR_ID, USB_BLACKBIRD_SPRO_PRODUCT_ID),
350 .driver_info = KVASER_HAS_TXRX_ERRORS },
351 { USB_DEVICE(KVASER_VENDOR_ID, USB_OEM_MERCURY_PRODUCT_ID),
352 .driver_info = KVASER_HAS_TXRX_ERRORS },
353 { USB_DEVICE(KVASER_VENDOR_ID, USB_OEM_LEAF_PRODUCT_ID),
354 .driver_info = KVASER_HAS_TXRX_ERRORS },
355 { USB_DEVICE(KVASER_VENDOR_ID, USB_CAN_R_PRODUCT_ID),
356 .driver_info = KVASER_HAS_TXRX_ERRORS },
357 { }
358};
359MODULE_DEVICE_TABLE(usb, kvaser_usb_table);
360
361static inline int kvaser_usb_send_msg(const struct kvaser_usb *dev,
362 struct kvaser_msg *msg)
363{
364 int actual_len;
365
366 return usb_bulk_msg(dev->udev,
367 usb_sndbulkpipe(dev->udev,
368 dev->bulk_out->bEndpointAddress),
369 msg, msg->len, &actual_len,
370 USB_SEND_TIMEOUT);
371}
372
373static int kvaser_usb_wait_msg(const struct kvaser_usb *dev, u8 id,
374 struct kvaser_msg *msg)
375{
376 struct kvaser_msg *tmp;
377 void *buf;
378 int actual_len;
379 int err;
380 int pos = 0;
381
382 buf = kzalloc(RX_BUFFER_SIZE, GFP_KERNEL);
383 if (!buf)
384 return -ENOMEM;
385
386 err = usb_bulk_msg(dev->udev,
387 usb_rcvbulkpipe(dev->udev,
388 dev->bulk_in->bEndpointAddress),
389 buf, RX_BUFFER_SIZE, &actual_len,
390 USB_RECV_TIMEOUT);
391 if (err < 0)
392 goto end;
393
394 while (pos <= actual_len - MSG_HEADER_LEN) {
395 tmp = buf + pos;
396
397 if (!tmp->len)
398 break;
399
400 if (pos + tmp->len > actual_len) {
401 dev_err(dev->udev->dev.parent, "Format error\n");
402 break;
403 }
404
405 if (tmp->id == id) {
406 memcpy(msg, tmp, tmp->len);
407 goto end;
408 }
409
410 pos += tmp->len;
411 }
412
413 err = -EINVAL;
414
415end:
416 kfree(buf);
417
418 return err;
419}
420
421static int kvaser_usb_send_simple_msg(const struct kvaser_usb *dev,
422 u8 msg_id, int channel)
423{
424 struct kvaser_msg *msg;
425 int rc;
426
427 msg = kmalloc(sizeof(*msg), GFP_KERNEL);
428 if (!msg)
429 return -ENOMEM;
430
431 msg->id = msg_id;
432 msg->len = MSG_HEADER_LEN + sizeof(struct kvaser_msg_simple);
433 msg->u.simple.channel = channel;
434 msg->u.simple.tid = 0xff;
435
436 rc = kvaser_usb_send_msg(dev, msg);
437
438 kfree(msg);
439 return rc;
440}
441
442static int kvaser_usb_get_software_info(struct kvaser_usb *dev)
443{
444 struct kvaser_msg msg;
445 int err;
446
447 err = kvaser_usb_send_simple_msg(dev, CMD_GET_SOFTWARE_INFO, 0);
448 if (err)
449 return err;
450
451 err = kvaser_usb_wait_msg(dev, CMD_GET_SOFTWARE_INFO_REPLY, &msg);
452 if (err)
453 return err;
454
455 dev->fw_version = le32_to_cpu(msg.u.softinfo.fw_version);
456
457 return 0;
458}
459
460static int kvaser_usb_get_card_info(struct kvaser_usb *dev)
461{
462 struct kvaser_msg msg;
463 int err;
464
465 err = kvaser_usb_send_simple_msg(dev, CMD_GET_CARD_INFO, 0);
466 if (err)
467 return err;
468
469 err = kvaser_usb_wait_msg(dev, CMD_GET_CARD_INFO_REPLY, &msg);
470 if (err)
471 return err;
472
473 dev->nchannels = msg.u.cardinfo.nchannels;
474
475 return 0;
476}
477
478static void kvaser_usb_tx_acknowledge(const struct kvaser_usb *dev,
479 const struct kvaser_msg *msg)
480{
481 struct net_device_stats *stats;
482 struct kvaser_usb_tx_urb_context *context;
483 struct kvaser_usb_net_priv *priv;
484 struct sk_buff *skb;
485 struct can_frame *cf;
486 u8 channel = msg->u.tx_acknowledge.channel;
487 u8 tid = msg->u.tx_acknowledge.tid;
488
489 if (channel >= dev->nchannels) {
490 dev_err(dev->udev->dev.parent,
491 "Invalid channel number (%d)\n", channel);
492 return;
493 }
494
495 priv = dev->nets[channel];
496
497 if (!netif_device_present(priv->netdev))
498 return;
499
500 stats = &priv->netdev->stats;
501
502 context = &priv->tx_contexts[tid % MAX_TX_URBS];
503
504 /* Sometimes the state change doesn't come after a bus-off event */
505 if (priv->can.restart_ms &&
506 (priv->can.state >= CAN_STATE_BUS_OFF)) {
507 skb = alloc_can_err_skb(priv->netdev, &cf);
508 if (skb) {
509 cf->can_id |= CAN_ERR_RESTARTED;
510 netif_rx(skb);
511
512 stats->rx_packets++;
513 stats->rx_bytes += cf->can_dlc;
514 } else {
515 netdev_err(priv->netdev,
516 "No memory left for err_skb\n");
517 }
518
519 priv->can.can_stats.restarts++;
520 netif_carrier_on(priv->netdev);
521
522 priv->can.state = CAN_STATE_ERROR_ACTIVE;
523 }
524
525 stats->tx_packets++;
526 stats->tx_bytes += context->dlc;
527 can_get_echo_skb(priv->netdev, context->echo_index);
528
529 context->echo_index = MAX_TX_URBS;
530 atomic_dec(&priv->active_tx_urbs);
531
532 netif_wake_queue(priv->netdev);
533}
534
535static void kvaser_usb_simple_msg_callback(struct urb *urb)
536{
537 struct net_device *netdev = urb->context;
538
539 kfree(urb->transfer_buffer);
540
541 if (urb->status)
542 netdev_warn(netdev, "urb status received: %d\n",
543 urb->status);
544}
545
546static int kvaser_usb_simple_msg_async(struct kvaser_usb_net_priv *priv,
547 u8 msg_id)
548{
549 struct kvaser_usb *dev = priv->dev;
550 struct net_device *netdev = priv->netdev;
551 struct kvaser_msg *msg;
552 struct urb *urb;
553 void *buf;
554 int err;
555
556 urb = usb_alloc_urb(0, GFP_ATOMIC);
557 if (!urb) {
558 netdev_err(netdev, "No memory left for URBs\n");
559 return -ENOMEM;
560 }
561
562 buf = kmalloc(sizeof(struct kvaser_msg), GFP_ATOMIC);
563 if (!buf) {
564 netdev_err(netdev, "No memory left for USB buffer\n");
565 usb_free_urb(urb);
566 return -ENOMEM;
567 }
568
569 msg = (struct kvaser_msg *)buf;
570 msg->len = MSG_HEADER_LEN + sizeof(struct kvaser_msg_simple);
571 msg->id = msg_id;
572 msg->u.simple.channel = priv->channel;
573
574 usb_fill_bulk_urb(urb, dev->udev,
575 usb_sndbulkpipe(dev->udev,
576 dev->bulk_out->bEndpointAddress),
577 buf, msg->len,
578 kvaser_usb_simple_msg_callback, priv);
579 usb_anchor_urb(urb, &priv->tx_submitted);
580
581 err = usb_submit_urb(urb, GFP_ATOMIC);
582 if (err) {
583 netdev_err(netdev, "Error transmitting URB\n");
584 usb_unanchor_urb(urb);
585 usb_free_urb(urb);
586 kfree(buf);
587 return err;
588 }
589
590 usb_free_urb(urb);
591
592 return 0;
593}
594
595static void kvaser_usb_unlink_tx_urbs(struct kvaser_usb_net_priv *priv)
596{
597 int i;
598
599 usb_kill_anchored_urbs(&priv->tx_submitted);
600 atomic_set(&priv->active_tx_urbs, 0);
601
602 for (i = 0; i < MAX_TX_URBS; i++)
603 priv->tx_contexts[i].echo_index = MAX_TX_URBS;
604}
605
606static void kvaser_usb_rx_error(const struct kvaser_usb *dev,
607 const struct kvaser_msg *msg)
608{
609 struct can_frame *cf;
610 struct sk_buff *skb;
611 struct net_device_stats *stats;
612 struct kvaser_usb_net_priv *priv;
613 unsigned int new_state;
614 u8 channel, status, txerr, rxerr, error_factor;
615
616 switch (msg->id) {
617 case CMD_CAN_ERROR_EVENT:
618 channel = msg->u.error_event.channel;
619 status = msg->u.error_event.status;
620 txerr = msg->u.error_event.tx_errors_count;
621 rxerr = msg->u.error_event.rx_errors_count;
622 error_factor = msg->u.error_event.error_factor;
623 break;
624 case CMD_LOG_MESSAGE:
625 channel = msg->u.log_message.channel;
626 status = msg->u.log_message.data[0];
627 txerr = msg->u.log_message.data[2];
628 rxerr = msg->u.log_message.data[3];
629 error_factor = msg->u.log_message.data[1];
630 break;
631 case CMD_CHIP_STATE_EVENT:
632 channel = msg->u.chip_state_event.channel;
633 status = msg->u.chip_state_event.status;
634 txerr = msg->u.chip_state_event.tx_errors_count;
635 rxerr = msg->u.chip_state_event.rx_errors_count;
636 error_factor = 0;
637 break;
638 default:
639 dev_err(dev->udev->dev.parent, "Invalid msg id (%d)\n",
640 msg->id);
641 return;
642 }
643
644 if (channel >= dev->nchannels) {
645 dev_err(dev->udev->dev.parent,
646 "Invalid channel number (%d)\n", channel);
647 return;
648 }
649
650 priv = dev->nets[channel];
651 stats = &priv->netdev->stats;
652
653 if (status & M16C_STATE_BUS_RESET) {
654 kvaser_usb_unlink_tx_urbs(priv);
655 return;
656 }
657
658 skb = alloc_can_err_skb(priv->netdev, &cf);
659 if (!skb) {
660 stats->rx_dropped++;
661 return;
662 }
663
664 new_state = priv->can.state;
665
666 netdev_dbg(priv->netdev, "Error status: 0x%02x\n", status);
667
668 if (status & M16C_STATE_BUS_OFF) {
669 cf->can_id |= CAN_ERR_BUSOFF;
670
671 priv->can.can_stats.bus_off++;
672 if (!priv->can.restart_ms)
673 kvaser_usb_simple_msg_async(priv, CMD_STOP_CHIP);
674
675 netif_carrier_off(priv->netdev);
676
677 new_state = CAN_STATE_BUS_OFF;
678 } else if (status & M16C_STATE_BUS_PASSIVE) {
679 if (priv->can.state != CAN_STATE_ERROR_PASSIVE) {
680 cf->can_id |= CAN_ERR_CRTL;
681
682 if (txerr || rxerr)
683 cf->data[1] = (txerr > rxerr)
684 ? CAN_ERR_CRTL_TX_PASSIVE
685 : CAN_ERR_CRTL_RX_PASSIVE;
686 else
687 cf->data[1] = CAN_ERR_CRTL_TX_PASSIVE |
688 CAN_ERR_CRTL_RX_PASSIVE;
689
690 priv->can.can_stats.error_passive++;
691 }
692
693 new_state = CAN_STATE_ERROR_PASSIVE;
694 }
695
696 if (status == M16C_STATE_BUS_ERROR) {
697 if ((priv->can.state < CAN_STATE_ERROR_WARNING) &&
698 ((txerr >= 96) || (rxerr >= 96))) {
699 cf->can_id |= CAN_ERR_CRTL;
700 cf->data[1] = (txerr > rxerr)
701 ? CAN_ERR_CRTL_TX_WARNING
702 : CAN_ERR_CRTL_RX_WARNING;
703
704 priv->can.can_stats.error_warning++;
705 new_state = CAN_STATE_ERROR_WARNING;
706 } else if (priv->can.state > CAN_STATE_ERROR_ACTIVE) {
707 cf->can_id |= CAN_ERR_PROT;
708 cf->data[2] = CAN_ERR_PROT_ACTIVE;
709
710 new_state = CAN_STATE_ERROR_ACTIVE;
711 }
712 }
713
714 if (!status) {
715 cf->can_id |= CAN_ERR_PROT;
716 cf->data[2] = CAN_ERR_PROT_ACTIVE;
717
718 new_state = CAN_STATE_ERROR_ACTIVE;
719 }
720
721 if (priv->can.restart_ms &&
722 (priv->can.state >= CAN_STATE_BUS_OFF) &&
723 (new_state < CAN_STATE_BUS_OFF)) {
724 cf->can_id |= CAN_ERR_RESTARTED;
725 netif_carrier_on(priv->netdev);
726
727 priv->can.can_stats.restarts++;
728 }
729
730 if (error_factor) {
731 priv->can.can_stats.bus_error++;
732 stats->rx_errors++;
733
734 cf->can_id |= CAN_ERR_BUSERROR | CAN_ERR_PROT;
735
736 if (error_factor & M16C_EF_ACKE)
737 cf->data[3] |= (CAN_ERR_PROT_LOC_ACK);
738 if (error_factor & M16C_EF_CRCE)
739 cf->data[3] |= (CAN_ERR_PROT_LOC_CRC_SEQ |
740 CAN_ERR_PROT_LOC_CRC_DEL);
741 if (error_factor & M16C_EF_FORME)
742 cf->data[2] |= CAN_ERR_PROT_FORM;
743 if (error_factor & M16C_EF_STFE)
744 cf->data[2] |= CAN_ERR_PROT_STUFF;
745 if (error_factor & M16C_EF_BITE0)
746 cf->data[2] |= CAN_ERR_PROT_BIT0;
747 if (error_factor & M16C_EF_BITE1)
748 cf->data[2] |= CAN_ERR_PROT_BIT1;
749 if (error_factor & M16C_EF_TRE)
750 cf->data[2] |= CAN_ERR_PROT_TX;
751 }
752
753 cf->data[6] = txerr;
754 cf->data[7] = rxerr;
755
756 priv->bec.txerr = txerr;
757 priv->bec.rxerr = rxerr;
758
759 priv->can.state = new_state;
760
761 netif_rx(skb);
762
763 stats->rx_packets++;
764 stats->rx_bytes += cf->can_dlc;
765}
766
767static void kvaser_usb_rx_can_err(const struct kvaser_usb_net_priv *priv,
768 const struct kvaser_msg *msg)
769{
770 struct can_frame *cf;
771 struct sk_buff *skb;
772 struct net_device_stats *stats = &priv->netdev->stats;
773
774 if (msg->u.rx_can.flag & (MSG_FLAG_ERROR_FRAME |
775 MSG_FLAG_NERR)) {
776 netdev_err(priv->netdev, "Unknow error (flags: 0x%02x)\n",
777 msg->u.rx_can.flag);
778
779 stats->rx_errors++;
780 return;
781 }
782
783 if (msg->u.rx_can.flag & MSG_FLAG_OVERRUN) {
784 skb = alloc_can_err_skb(priv->netdev, &cf);
785 if (!skb) {
786 stats->rx_dropped++;
787 return;
788 }
789
790 cf->can_id |= CAN_ERR_CRTL;
791 cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW;
792
793 stats->rx_over_errors++;
794 stats->rx_errors++;
795
796 netif_rx(skb);
797
798 stats->rx_packets++;
799 stats->rx_bytes += cf->can_dlc;
800 }
801}
802
803static void kvaser_usb_rx_can_msg(const struct kvaser_usb *dev,
804 const struct kvaser_msg *msg)
805{
806 struct kvaser_usb_net_priv *priv;
807 struct can_frame *cf;
808 struct sk_buff *skb;
809 struct net_device_stats *stats;
810 u8 channel = msg->u.rx_can.channel;
811
812 if (channel >= dev->nchannels) {
813 dev_err(dev->udev->dev.parent,
814 "Invalid channel number (%d)\n", channel);
815 return;
816 }
817
818 priv = dev->nets[channel];
819 stats = &priv->netdev->stats;
820
821 if (msg->u.rx_can.flag & (MSG_FLAG_ERROR_FRAME | MSG_FLAG_NERR |
822 MSG_FLAG_OVERRUN)) {
823 kvaser_usb_rx_can_err(priv, msg);
824 return;
825 } else if (msg->u.rx_can.flag & ~MSG_FLAG_REMOTE_FRAME) {
826 netdev_warn(priv->netdev,
827 "Unhandled frame (flags: 0x%02x)",
828 msg->u.rx_can.flag);
829 return;
830 }
831
832 skb = alloc_can_skb(priv->netdev, &cf);
833 if (!skb) {
834 stats->tx_dropped++;
835 return;
836 }
837
838 cf->can_id = ((msg->u.rx_can.msg[0] & 0x1f) << 6) |
839 (msg->u.rx_can.msg[1] & 0x3f);
840 cf->can_dlc = get_can_dlc(msg->u.rx_can.msg[5]);
841
842 if (msg->id == CMD_RX_EXT_MESSAGE) {
843 cf->can_id <<= 18;
844 cf->can_id |= ((msg->u.rx_can.msg[2] & 0x0f) << 14) |
845 ((msg->u.rx_can.msg[3] & 0xff) << 6) |
846 (msg->u.rx_can.msg[4] & 0x3f);
847 cf->can_id |= CAN_EFF_FLAG;
848 }
849
850 if (msg->u.rx_can.flag & MSG_FLAG_REMOTE_FRAME)
851 cf->can_id |= CAN_RTR_FLAG;
852 else
853 memcpy(cf->data, &msg->u.rx_can.msg[6], cf->can_dlc);
854
855 netif_rx(skb);
856
857 stats->rx_packets++;
858 stats->rx_bytes += cf->can_dlc;
859}
860
861static void kvaser_usb_start_chip_reply(const struct kvaser_usb *dev,
862 const struct kvaser_msg *msg)
863{
864 struct kvaser_usb_net_priv *priv;
865 u8 channel = msg->u.simple.channel;
866
867 if (channel >= dev->nchannels) {
868 dev_err(dev->udev->dev.parent,
869 "Invalid channel number (%d)\n", channel);
870 return;
871 }
872
873 priv = dev->nets[channel];
874
875 if (completion_done(&priv->start_comp) &&
876 netif_queue_stopped(priv->netdev)) {
877 netif_wake_queue(priv->netdev);
878 } else {
879 netif_start_queue(priv->netdev);
880 complete(&priv->start_comp);
881 }
882}
883
884static void kvaser_usb_stop_chip_reply(const struct kvaser_usb *dev,
885 const struct kvaser_msg *msg)
886{
887 struct kvaser_usb_net_priv *priv;
888 u8 channel = msg->u.simple.channel;
889
890 if (channel >= dev->nchannels) {
891 dev_err(dev->udev->dev.parent,
892 "Invalid channel number (%d)\n", channel);
893 return;
894 }
895
896 priv = dev->nets[channel];
897
898 complete(&priv->stop_comp);
899}
900
901static void kvaser_usb_handle_message(const struct kvaser_usb *dev,
902 const struct kvaser_msg *msg)
903{
904 switch (msg->id) {
905 case CMD_START_CHIP_REPLY:
906 kvaser_usb_start_chip_reply(dev, msg);
907 break;
908
909 case CMD_STOP_CHIP_REPLY:
910 kvaser_usb_stop_chip_reply(dev, msg);
911 break;
912
913 case CMD_RX_STD_MESSAGE:
914 case CMD_RX_EXT_MESSAGE:
915 kvaser_usb_rx_can_msg(dev, msg);
916 break;
917
918 case CMD_CHIP_STATE_EVENT:
919 case CMD_CAN_ERROR_EVENT:
920 kvaser_usb_rx_error(dev, msg);
921 break;
922
923 case CMD_LOG_MESSAGE:
924 if (msg->u.log_message.flags & MSG_FLAG_ERROR_FRAME)
925 kvaser_usb_rx_error(dev, msg);
926 break;
927
928 case CMD_TX_ACKNOWLEDGE:
929 kvaser_usb_tx_acknowledge(dev, msg);
930 break;
931
932 default:
933 dev_warn(dev->udev->dev.parent,
934 "Unhandled message (%d)\n", msg->id);
935 break;
936 }
937}
938
939static void kvaser_usb_read_bulk_callback(struct urb *urb)
940{
941 struct kvaser_usb *dev = urb->context;
942 struct kvaser_msg *msg;
943 int pos = 0;
944 int err, i;
945
946 switch (urb->status) {
947 case 0:
948 break;
949 case -ENOENT:
950 case -ESHUTDOWN:
951 return;
952 default:
953 dev_info(dev->udev->dev.parent, "Rx URB aborted (%d)\n",
954 urb->status);
955 goto resubmit_urb;
956 }
957
958 while (pos <= urb->actual_length - MSG_HEADER_LEN) {
959 msg = urb->transfer_buffer + pos;
960
961 if (!msg->len)
962 break;
963
964 if (pos + msg->len > urb->actual_length) {
965 dev_err(dev->udev->dev.parent, "Format error\n");
966 break;
967 }
968
969 kvaser_usb_handle_message(dev, msg);
970
971 pos += msg->len;
972 }
973
974resubmit_urb:
975 usb_fill_bulk_urb(urb, dev->udev,
976 usb_rcvbulkpipe(dev->udev,
977 dev->bulk_in->bEndpointAddress),
978 urb->transfer_buffer, RX_BUFFER_SIZE,
979 kvaser_usb_read_bulk_callback, dev);
980
981 err = usb_submit_urb(urb, GFP_ATOMIC);
982 if (err == -ENODEV) {
983 for (i = 0; i < dev->nchannels; i++) {
984 if (!dev->nets[i])
985 continue;
986
987 netif_device_detach(dev->nets[i]->netdev);
988 }
989 } else if (err) {
990 dev_err(dev->udev->dev.parent,
991 "Failed resubmitting read bulk urb: %d\n", err);
992 }
993
994 return;
995}
996
997static int kvaser_usb_setup_rx_urbs(struct kvaser_usb *dev)
998{
999 int i, err = 0;
1000
1001 if (dev->rxinitdone)
1002 return 0;
1003
1004 for (i = 0; i < MAX_RX_URBS; i++) {
1005 struct urb *urb = NULL;
1006 u8 *buf = NULL;
1007 dma_addr_t buf_dma;
1008
1009 urb = usb_alloc_urb(0, GFP_KERNEL);
1010 if (!urb) {
1011 dev_warn(dev->udev->dev.parent,
1012 "No memory left for URBs\n");
1013 err = -ENOMEM;
1014 break;
1015 }
1016
1017 buf = usb_alloc_coherent(dev->udev, RX_BUFFER_SIZE,
1018 GFP_KERNEL, &buf_dma);
1019 if (!buf) {
1020 dev_warn(dev->udev->dev.parent,
1021 "No memory left for USB buffer\n");
1022 usb_free_urb(urb);
1023 err = -ENOMEM;
1024 break;
1025 }
1026
1027 usb_fill_bulk_urb(urb, dev->udev,
1028 usb_rcvbulkpipe(dev->udev,
1029 dev->bulk_in->bEndpointAddress),
1030 buf, RX_BUFFER_SIZE,
1031 kvaser_usb_read_bulk_callback,
1032 dev);
1033 urb->transfer_dma = buf_dma;
1034 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1035 usb_anchor_urb(urb, &dev->rx_submitted);
1036
1037 err = usb_submit_urb(urb, GFP_KERNEL);
1038 if (err) {
1039 usb_unanchor_urb(urb);
1040 usb_free_coherent(dev->udev, RX_BUFFER_SIZE, buf,
1041 buf_dma);
1042 usb_free_urb(urb);
1043 break;
1044 }
1045
1046 dev->rxbuf[i] = buf;
1047 dev->rxbuf_dma[i] = buf_dma;
1048
1049 usb_free_urb(urb);
1050 }
1051
1052 if (i == 0) {
1053 dev_warn(dev->udev->dev.parent,
1054 "Cannot setup read URBs, error %d\n", err);
1055 return err;
1056 } else if (i < MAX_RX_URBS) {
1057 dev_warn(dev->udev->dev.parent,
1058 "RX performances may be slow\n");
1059 }
1060
1061 dev->rxinitdone = true;
1062
1063 return 0;
1064}
1065
1066static int kvaser_usb_set_opt_mode(const struct kvaser_usb_net_priv *priv)
1067{
1068 struct kvaser_msg *msg;
1069 int rc;
1070
1071 msg = kmalloc(sizeof(*msg), GFP_KERNEL);
1072 if (!msg)
1073 return -ENOMEM;
1074
1075 msg->id = CMD_SET_CTRL_MODE;
1076 msg->len = MSG_HEADER_LEN + sizeof(struct kvaser_msg_ctrl_mode);
1077 msg->u.ctrl_mode.tid = 0xff;
1078 msg->u.ctrl_mode.channel = priv->channel;
1079
1080 if (priv->can.ctrlmode & CAN_CTRLMODE_LISTENONLY)
1081 msg->u.ctrl_mode.ctrl_mode = KVASER_CTRL_MODE_SILENT;
1082 else
1083 msg->u.ctrl_mode.ctrl_mode = KVASER_CTRL_MODE_NORMAL;
1084
1085 rc = kvaser_usb_send_msg(priv->dev, msg);
1086
1087 kfree(msg);
1088 return rc;
1089}
1090
1091static int kvaser_usb_start_chip(struct kvaser_usb_net_priv *priv)
1092{
1093 int err;
1094
1095 init_completion(&priv->start_comp);
1096
1097 err = kvaser_usb_send_simple_msg(priv->dev, CMD_START_CHIP,
1098 priv->channel);
1099 if (err)
1100 return err;
1101
1102 if (!wait_for_completion_timeout(&priv->start_comp,
1103 msecs_to_jiffies(START_TIMEOUT)))
1104 return -ETIMEDOUT;
1105
1106 return 0;
1107}
1108
1109static int kvaser_usb_open(struct net_device *netdev)
1110{
1111 struct kvaser_usb_net_priv *priv = netdev_priv(netdev);
1112 struct kvaser_usb *dev = priv->dev;
1113 int err;
1114
1115 err = open_candev(netdev);
1116 if (err)
1117 return err;
1118
1119 err = kvaser_usb_setup_rx_urbs(dev);
1120 if (err)
1121 goto error;
1122
1123 err = kvaser_usb_set_opt_mode(priv);
1124 if (err)
1125 goto error;
1126
1127 err = kvaser_usb_start_chip(priv);
1128 if (err) {
1129 netdev_warn(netdev, "Cannot start device, error %d\n", err);
1130 goto error;
1131 }
1132
1133 priv->can.state = CAN_STATE_ERROR_ACTIVE;
1134
1135 return 0;
1136
1137error:
1138 close_candev(netdev);
1139 return err;
1140}
1141
1142static void kvaser_usb_unlink_all_urbs(struct kvaser_usb *dev)
1143{
1144 int i;
1145
1146 usb_kill_anchored_urbs(&dev->rx_submitted);
1147
1148 for (i = 0; i < MAX_RX_URBS; i++)
1149 usb_free_coherent(dev->udev, RX_BUFFER_SIZE,
1150 dev->rxbuf[i],
1151 dev->rxbuf_dma[i]);
1152
1153 for (i = 0; i < MAX_NET_DEVICES; i++) {
1154 struct kvaser_usb_net_priv *priv = dev->nets[i];
1155
1156 if (priv)
1157 kvaser_usb_unlink_tx_urbs(priv);
1158 }
1159}
1160
1161static int kvaser_usb_stop_chip(struct kvaser_usb_net_priv *priv)
1162{
1163 int err;
1164
1165 init_completion(&priv->stop_comp);
1166
1167 err = kvaser_usb_send_simple_msg(priv->dev, CMD_STOP_CHIP,
1168 priv->channel);
1169 if (err)
1170 return err;
1171
1172 if (!wait_for_completion_timeout(&priv->stop_comp,
1173 msecs_to_jiffies(STOP_TIMEOUT)))
1174 return -ETIMEDOUT;
1175
1176 return 0;
1177}
1178
1179static int kvaser_usb_flush_queue(struct kvaser_usb_net_priv *priv)
1180{
1181 struct kvaser_msg *msg;
1182 int rc;
1183
1184 msg = kmalloc(sizeof(*msg), GFP_KERNEL);
1185 if (!msg)
1186 return -ENOMEM;
1187
1188 msg->id = CMD_FLUSH_QUEUE;
1189 msg->len = MSG_HEADER_LEN + sizeof(struct kvaser_msg_flush_queue);
1190 msg->u.flush_queue.channel = priv->channel;
1191 msg->u.flush_queue.flags = 0x00;
1192
1193 rc = kvaser_usb_send_msg(priv->dev, msg);
1194
1195 kfree(msg);
1196 return rc;
1197}
1198
1199static int kvaser_usb_close(struct net_device *netdev)
1200{
1201 struct kvaser_usb_net_priv *priv = netdev_priv(netdev);
1202 struct kvaser_usb *dev = priv->dev;
1203 int err;
1204
1205 netif_stop_queue(netdev);
1206
1207 err = kvaser_usb_flush_queue(priv);
1208 if (err)
1209 netdev_warn(netdev, "Cannot flush queue, error %d\n", err);
1210
1211 if (kvaser_usb_send_simple_msg(dev, CMD_RESET_CHIP, priv->channel))
1212 netdev_warn(netdev, "Cannot reset card, error %d\n", err);
1213
1214 err = kvaser_usb_stop_chip(priv);
1215 if (err)
1216 netdev_warn(netdev, "Cannot stop device, error %d\n", err);
1217
1218 priv->can.state = CAN_STATE_STOPPED;
1219 close_candev(priv->netdev);
1220
1221 return 0;
1222}
1223
1224static void kvaser_usb_write_bulk_callback(struct urb *urb)
1225{
1226 struct kvaser_usb_tx_urb_context *context = urb->context;
1227 struct kvaser_usb_net_priv *priv;
1228 struct net_device *netdev;
1229
1230 if (WARN_ON(!context))
1231 return;
1232
1233 priv = context->priv;
1234 netdev = priv->netdev;
1235
1236 kfree(urb->transfer_buffer);
1237
1238 if (!netif_device_present(netdev))
1239 return;
1240
1241 if (urb->status)
1242 netdev_info(netdev, "Tx URB aborted (%d)\n", urb->status);
1243}
1244
1245static netdev_tx_t kvaser_usb_start_xmit(struct sk_buff *skb,
1246 struct net_device *netdev)
1247{
1248 struct kvaser_usb_net_priv *priv = netdev_priv(netdev);
1249 struct kvaser_usb *dev = priv->dev;
1250 struct net_device_stats *stats = &netdev->stats;
1251 struct can_frame *cf = (struct can_frame *)skb->data;
1252 struct kvaser_usb_tx_urb_context *context = NULL;
1253 struct urb *urb;
1254 void *buf;
1255 struct kvaser_msg *msg;
1256 int i, err;
1257 int ret = NETDEV_TX_OK;
1258
1259 if (can_dropped_invalid_skb(netdev, skb))
1260 return NETDEV_TX_OK;
1261
1262 urb = usb_alloc_urb(0, GFP_ATOMIC);
1263 if (!urb) {
1264 netdev_err(netdev, "No memory left for URBs\n");
1265 stats->tx_dropped++;
1266 goto nourbmem;
1267 }
1268
1269 buf = kmalloc(sizeof(struct kvaser_msg), GFP_ATOMIC);
1270 if (!buf) {
1271 netdev_err(netdev, "No memory left for USB buffer\n");
1272 stats->tx_dropped++;
1273 goto nobufmem;
1274 }
1275
1276 msg = buf;
1277 msg->len = MSG_HEADER_LEN + sizeof(struct kvaser_msg_tx_can);
1278 msg->u.tx_can.flags = 0;
1279 msg->u.tx_can.channel = priv->channel;
1280
1281 if (cf->can_id & CAN_EFF_FLAG) {
1282 msg->id = CMD_TX_EXT_MESSAGE;
1283 msg->u.tx_can.msg[0] = (cf->can_id >> 24) & 0x1f;
1284 msg->u.tx_can.msg[1] = (cf->can_id >> 18) & 0x3f;
1285 msg->u.tx_can.msg[2] = (cf->can_id >> 14) & 0x0f;
1286 msg->u.tx_can.msg[3] = (cf->can_id >> 6) & 0xff;
1287 msg->u.tx_can.msg[4] = cf->can_id & 0x3f;
1288 } else {
1289 msg->id = CMD_TX_STD_MESSAGE;
1290 msg->u.tx_can.msg[0] = (cf->can_id >> 6) & 0x1f;
1291 msg->u.tx_can.msg[1] = cf->can_id & 0x3f;
1292 }
1293
1294 msg->u.tx_can.msg[5] = cf->can_dlc;
1295 memcpy(&msg->u.tx_can.msg[6], cf->data, cf->can_dlc);
1296
1297 if (cf->can_id & CAN_RTR_FLAG)
1298 msg->u.tx_can.flags |= MSG_FLAG_REMOTE_FRAME;
1299
1300 for (i = 0; i < ARRAY_SIZE(priv->tx_contexts); i++) {
1301 if (priv->tx_contexts[i].echo_index == MAX_TX_URBS) {
1302 context = &priv->tx_contexts[i];
1303 break;
1304 }
1305 }
1306
1307 if (!context) {
1308 netdev_warn(netdev, "cannot find free context\n");
1309 ret = NETDEV_TX_BUSY;
1310 goto releasebuf;
1311 }
1312
1313 context->priv = priv;
1314 context->echo_index = i;
1315 context->dlc = cf->can_dlc;
1316
1317 msg->u.tx_can.tid = context->echo_index;
1318
1319 usb_fill_bulk_urb(urb, dev->udev,
1320 usb_sndbulkpipe(dev->udev,
1321 dev->bulk_out->bEndpointAddress),
1322 buf, msg->len,
1323 kvaser_usb_write_bulk_callback, context);
1324 usb_anchor_urb(urb, &priv->tx_submitted);
1325
1326 can_put_echo_skb(skb, netdev, context->echo_index);
1327
1328 atomic_inc(&priv->active_tx_urbs);
1329
1330 if (atomic_read(&priv->active_tx_urbs) >= MAX_TX_URBS)
1331 netif_stop_queue(netdev);
1332
1333 err = usb_submit_urb(urb, GFP_ATOMIC);
1334 if (unlikely(err)) {
1335 can_free_echo_skb(netdev, context->echo_index);
1336
1337 skb = NULL; /* set to NULL to avoid double free in
1338 * dev_kfree_skb(skb) */
1339
1340 atomic_dec(&priv->active_tx_urbs);
1341 usb_unanchor_urb(urb);
1342
1343 stats->tx_dropped++;
1344
1345 if (err == -ENODEV)
1346 netif_device_detach(netdev);
1347 else
1348 netdev_warn(netdev, "Failed tx_urb %d\n", err);
1349
1350 goto releasebuf;
1351 }
1352
1353 usb_free_urb(urb);
1354
1355 return NETDEV_TX_OK;
1356
1357releasebuf:
1358 kfree(buf);
1359nobufmem:
1360 usb_free_urb(urb);
1361nourbmem:
1362 dev_kfree_skb(skb);
1363 return ret;
1364}
1365
1366static const struct net_device_ops kvaser_usb_netdev_ops = {
1367 .ndo_open = kvaser_usb_open,
1368 .ndo_stop = kvaser_usb_close,
1369 .ndo_start_xmit = kvaser_usb_start_xmit,
1370};
1371
1372static const struct can_bittiming_const kvaser_usb_bittiming_const = {
1373 .name = "kvaser_usb",
1374 .tseg1_min = KVASER_USB_TSEG1_MIN,
1375 .tseg1_max = KVASER_USB_TSEG1_MAX,
1376 .tseg2_min = KVASER_USB_TSEG2_MIN,
1377 .tseg2_max = KVASER_USB_TSEG2_MAX,
1378 .sjw_max = KVASER_USB_SJW_MAX,
1379 .brp_min = KVASER_USB_BRP_MIN,
1380 .brp_max = KVASER_USB_BRP_MAX,
1381 .brp_inc = KVASER_USB_BRP_INC,
1382};
1383
1384static int kvaser_usb_set_bittiming(struct net_device *netdev)
1385{
1386 struct kvaser_usb_net_priv *priv = netdev_priv(netdev);
1387 struct can_bittiming *bt = &priv->can.bittiming;
1388 struct kvaser_usb *dev = priv->dev;
1389 struct kvaser_msg *msg;
1390 int rc;
1391
1392 msg = kmalloc(sizeof(*msg), GFP_KERNEL);
1393 if (!msg)
1394 return -ENOMEM;
1395
1396 msg->id = CMD_SET_BUS_PARAMS;
1397 msg->len = MSG_HEADER_LEN + sizeof(struct kvaser_msg_busparams);
1398 msg->u.busparams.channel = priv->channel;
1399 msg->u.busparams.tid = 0xff;
1400 msg->u.busparams.bitrate = cpu_to_le32(bt->bitrate);
1401 msg->u.busparams.sjw = bt->sjw;
1402 msg->u.busparams.tseg1 = bt->prop_seg + bt->phase_seg1;
1403 msg->u.busparams.tseg2 = bt->phase_seg2;
1404
1405 if (priv->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES)
1406 msg->u.busparams.no_samp = 3;
1407 else
1408 msg->u.busparams.no_samp = 1;
1409
1410 rc = kvaser_usb_send_msg(dev, msg);
1411
1412 kfree(msg);
1413 return rc;
1414}
1415
1416static int kvaser_usb_set_mode(struct net_device *netdev,
1417 enum can_mode mode)
1418{
1419 struct kvaser_usb_net_priv *priv = netdev_priv(netdev);
1420 int err;
1421
1422 switch (mode) {
1423 case CAN_MODE_START:
1424 err = kvaser_usb_simple_msg_async(priv, CMD_START_CHIP);
1425 if (err)
1426 return err;
1427 break;
1428 default:
1429 return -EOPNOTSUPP;
1430 }
1431
1432 return 0;
1433}
1434
1435static int kvaser_usb_get_berr_counter(const struct net_device *netdev,
1436 struct can_berr_counter *bec)
1437{
1438 struct kvaser_usb_net_priv *priv = netdev_priv(netdev);
1439
1440 *bec = priv->bec;
1441
1442 return 0;
1443}
1444
1445static void kvaser_usb_remove_interfaces(struct kvaser_usb *dev)
1446{
1447 int i;
1448
1449 for (i = 0; i < dev->nchannels; i++) {
1450 if (!dev->nets[i])
1451 continue;
1452
1453 unregister_netdev(dev->nets[i]->netdev);
1454 }
1455
1456 kvaser_usb_unlink_all_urbs(dev);
1457
1458 for (i = 0; i < dev->nchannels; i++) {
1459 if (!dev->nets[i])
1460 continue;
1461
1462 free_candev(dev->nets[i]->netdev);
1463 }
1464}
1465
1466static int kvaser_usb_init_one(struct usb_interface *intf,
1467 const struct usb_device_id *id, int channel)
1468{
1469 struct kvaser_usb *dev = usb_get_intfdata(intf);
1470 struct net_device *netdev;
1471 struct kvaser_usb_net_priv *priv;
1472 int i, err;
1473
1474 netdev = alloc_candev(sizeof(*priv), MAX_TX_URBS);
1475 if (!netdev) {
1476 dev_err(&intf->dev, "Cannot alloc candev\n");
1477 return -ENOMEM;
1478 }
1479
1480 priv = netdev_priv(netdev);
1481
1482 init_completion(&priv->start_comp);
1483 init_completion(&priv->stop_comp);
1484
1485 init_usb_anchor(&priv->tx_submitted);
1486 atomic_set(&priv->active_tx_urbs, 0);
1487
1488 for (i = 0; i < ARRAY_SIZE(priv->tx_contexts); i++)
1489 priv->tx_contexts[i].echo_index = MAX_TX_URBS;
1490
1491 priv->dev = dev;
1492 priv->netdev = netdev;
1493 priv->channel = channel;
1494
1495 priv->can.state = CAN_STATE_STOPPED;
1496 priv->can.clock.freq = CAN_USB_CLOCK;
1497 priv->can.bittiming_const = &kvaser_usb_bittiming_const;
1498 priv->can.do_set_bittiming = kvaser_usb_set_bittiming;
1499 priv->can.do_set_mode = kvaser_usb_set_mode;
1500 if (id->driver_info & KVASER_HAS_TXRX_ERRORS)
1501 priv->can.do_get_berr_counter = kvaser_usb_get_berr_counter;
1502 priv->can.ctrlmode_supported = CAN_CTRLMODE_3_SAMPLES;
1503 if (id->driver_info & KVASER_HAS_SILENT_MODE)
1504 priv->can.ctrlmode_supported |= CAN_CTRLMODE_LISTENONLY;
1505
1506 netdev->flags |= IFF_ECHO;
1507
1508 netdev->netdev_ops = &kvaser_usb_netdev_ops;
1509
1510 SET_NETDEV_DEV(netdev, &intf->dev);
1511
1512 dev->nets[channel] = priv;
1513
1514 err = register_candev(netdev);
1515 if (err) {
1516 dev_err(&intf->dev, "Failed to register can device\n");
1517 free_candev(netdev);
1518 dev->nets[channel] = NULL;
1519 return err;
1520 }
1521
1522 netdev_dbg(netdev, "device registered\n");
1523
1524 return 0;
1525}
1526
1527static void kvaser_usb_get_endpoints(const struct usb_interface *intf,
1528 struct usb_endpoint_descriptor **in,
1529 struct usb_endpoint_descriptor **out)
1530{
1531 const struct usb_host_interface *iface_desc;
1532 struct usb_endpoint_descriptor *endpoint;
1533 int i;
1534
1535 iface_desc = &intf->altsetting[0];
1536
1537 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
1538 endpoint = &iface_desc->endpoint[i].desc;
1539
1540 if (usb_endpoint_is_bulk_in(endpoint))
1541 *in = endpoint;
1542
1543 if (usb_endpoint_is_bulk_out(endpoint))
1544 *out = endpoint;
1545 }
1546}
1547
1548static int kvaser_usb_probe(struct usb_interface *intf,
1549 const struct usb_device_id *id)
1550{
1551 struct kvaser_usb *dev;
1552 int err = -ENOMEM;
1553 int i;
1554
1555 dev = devm_kzalloc(&intf->dev, sizeof(*dev), GFP_KERNEL);
1556 if (!dev)
1557 return -ENOMEM;
1558
1559 kvaser_usb_get_endpoints(intf, &dev->bulk_in, &dev->bulk_out);
1560 if (!dev->bulk_in || !dev->bulk_out) {
1561 dev_err(&intf->dev, "Cannot get usb endpoint(s)");
1562 return err;
1563 }
1564
1565 dev->udev = interface_to_usbdev(intf);
1566
1567 init_usb_anchor(&dev->rx_submitted);
1568
1569 usb_set_intfdata(intf, dev);
1570
1571 for (i = 0; i < MAX_NET_DEVICES; i++)
1572 kvaser_usb_send_simple_msg(dev, CMD_RESET_CHIP, i);
1573
1574 err = kvaser_usb_get_software_info(dev);
1575 if (err) {
1576 dev_err(&intf->dev,
1577 "Cannot get software infos, error %d\n", err);
1578 return err;
1579 }
1580
1581 err = kvaser_usb_get_card_info(dev);
1582 if (err) {
1583 dev_err(&intf->dev,
1584 "Cannot get card infos, error %d\n", err);
1585 return err;
1586 }
1587
1588 dev_dbg(&intf->dev, "Firmware version: %d.%d.%d\n",
1589 ((dev->fw_version >> 24) & 0xff),
1590 ((dev->fw_version >> 16) & 0xff),
1591 (dev->fw_version & 0xffff));
1592
1593 for (i = 0; i < dev->nchannels; i++) {
1594 err = kvaser_usb_init_one(intf, id, i);
1595 if (err) {
1596 kvaser_usb_remove_interfaces(dev);
1597 return err;
1598 }
1599 }
1600
1601 return 0;
1602}
1603
1604static void kvaser_usb_disconnect(struct usb_interface *intf)
1605{
1606 struct kvaser_usb *dev = usb_get_intfdata(intf);
1607
1608 usb_set_intfdata(intf, NULL);
1609
1610 if (!dev)
1611 return;
1612
1613 kvaser_usb_remove_interfaces(dev);
1614}
1615
1616static struct usb_driver kvaser_usb_driver = {
1617 .name = "kvaser_usb",
1618 .probe = kvaser_usb_probe,
1619 .disconnect = kvaser_usb_disconnect,
1620 .id_table = kvaser_usb_table,
1621};
1622
1623module_usb_driver(kvaser_usb_driver);
1624
1625MODULE_AUTHOR("Olivier Sobrie <olivier@sobrie.be>");
1626MODULE_DESCRIPTION("CAN driver for Kvaser CAN/USB devices");
1627MODULE_LICENSE("GPL v2");
diff --git a/drivers/net/can/usb/peak_usb/Makefile b/drivers/net/can/usb/peak_usb/Makefile
deleted file mode 100644
index 1aefbc88d64..00000000000
--- a/drivers/net/can/usb/peak_usb/Makefile
+++ /dev/null
@@ -1,2 +0,0 @@
1obj-$(CONFIG_CAN_PEAK_USB) += peak_usb.o
2peak_usb-y = pcan_usb_core.o pcan_usb.o pcan_usb_pro.o
diff --git a/drivers/net/can/usb/peak_usb/pcan_usb.c b/drivers/net/can/usb/peak_usb/pcan_usb.c
deleted file mode 100644
index 25723d8ee20..00000000000
--- a/drivers/net/can/usb/peak_usb/pcan_usb.c
+++ /dev/null
@@ -1,903 +0,0 @@
1/*
2 * CAN driver for PEAK System PCAN-USB adapter
3 * Derived from the PCAN project file driver/src/pcan_usb.c
4 *
5 * Copyright (C) 2003-2010 PEAK System-Technik GmbH
6 * Copyright (C) 2011-2012 Stephane Grosjean <s.grosjean@peak-system.com>
7 *
8 * Many thanks to Klaus Hitschler <klaus.hitschler@gmx.de>
9 *
10 * This program is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU General Public License as published
12 * by the Free Software Foundation; version 2 of the License.
13 *
14 * This program is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * General Public License for more details.
18 */
19#include <linux/netdevice.h>
20#include <linux/usb.h>
21#include <linux/module.h>
22
23#include <linux/can.h>
24#include <linux/can/dev.h>
25#include <linux/can/error.h>
26
27#include "pcan_usb_core.h"
28
29MODULE_SUPPORTED_DEVICE("PEAK-System PCAN-USB adapter");
30
31/* PCAN-USB Endpoints */
32#define PCAN_USB_EP_CMDOUT 1
33#define PCAN_USB_EP_CMDIN (PCAN_USB_EP_CMDOUT | USB_DIR_IN)
34#define PCAN_USB_EP_MSGOUT 2
35#define PCAN_USB_EP_MSGIN (PCAN_USB_EP_MSGOUT | USB_DIR_IN)
36
37/* PCAN-USB command struct */
38#define PCAN_USB_CMD_FUNC 0
39#define PCAN_USB_CMD_NUM 1
40#define PCAN_USB_CMD_ARGS 2
41#define PCAN_USB_CMD_ARGS_LEN 14
42#define PCAN_USB_CMD_LEN (PCAN_USB_CMD_ARGS + \
43 PCAN_USB_CMD_ARGS_LEN)
44
45/* PCAN-USB command timeout (ms.) */
46#define PCAN_USB_COMMAND_TIMEOUT 1000
47
48/* PCAN-USB startup timeout (ms.) */
49#define PCAN_USB_STARTUP_TIMEOUT 10
50
51/* PCAN-USB rx/tx buffers size */
52#define PCAN_USB_RX_BUFFER_SIZE 64
53#define PCAN_USB_TX_BUFFER_SIZE 64
54
55#define PCAN_USB_MSG_HEADER_LEN 2
56
57/* PCAN-USB adapter internal clock (MHz) */
58#define PCAN_USB_CRYSTAL_HZ 16000000
59
60/* PCAN-USB USB message record status/len field */
61#define PCAN_USB_STATUSLEN_TIMESTAMP (1 << 7)
62#define PCAN_USB_STATUSLEN_INTERNAL (1 << 6)
63#define PCAN_USB_STATUSLEN_EXT_ID (1 << 5)
64#define PCAN_USB_STATUSLEN_RTR (1 << 4)
65#define PCAN_USB_STATUSLEN_DLC (0xf)
66
67/* PCAN-USB error flags */
68#define PCAN_USB_ERROR_TXFULL 0x01
69#define PCAN_USB_ERROR_RXQOVR 0x02
70#define PCAN_USB_ERROR_BUS_LIGHT 0x04
71#define PCAN_USB_ERROR_BUS_HEAVY 0x08
72#define PCAN_USB_ERROR_BUS_OFF 0x10
73#define PCAN_USB_ERROR_RXQEMPTY 0x20
74#define PCAN_USB_ERROR_QOVR 0x40
75#define PCAN_USB_ERROR_TXQFULL 0x80
76
77/* SJA1000 modes */
78#define SJA1000_MODE_NORMAL 0x00
79#define SJA1000_MODE_INIT 0x01
80
81/*
82 * tick duration = 42.666 us =>
83 * (tick_number * 44739243) >> 20 ~ (tick_number * 42666) / 1000
84 * accuracy = 10^-7
85 */
86#define PCAN_USB_TS_DIV_SHIFTER 20
87#define PCAN_USB_TS_US_PER_TICK 44739243
88
89/* PCAN-USB messages record types */
90#define PCAN_USB_REC_ERROR 1
91#define PCAN_USB_REC_ANALOG 2
92#define PCAN_USB_REC_BUSLOAD 3
93#define PCAN_USB_REC_TS 4
94#define PCAN_USB_REC_BUSEVT 5
95
96/* private to PCAN-USB adapter */
97struct pcan_usb {
98 struct peak_usb_device dev;
99 struct peak_time_ref time_ref;
100 struct timer_list restart_timer;
101};
102
103/* incoming message context for decoding */
104struct pcan_usb_msg_context {
105 u16 ts16;
106 u8 prev_ts8;
107 u8 *ptr;
108 u8 *end;
109 u8 rec_cnt;
110 u8 rec_idx;
111 u8 rec_data_idx;
112 struct net_device *netdev;
113 struct pcan_usb *pdev;
114};
115
116/*
117 * send a command
118 */
119static int pcan_usb_send_cmd(struct peak_usb_device *dev, u8 f, u8 n, u8 *p)
120{
121 int err;
122 int actual_length;
123
124 /* usb device unregistered? */
125 if (!(dev->state & PCAN_USB_STATE_CONNECTED))
126 return 0;
127
128 dev->cmd_buf[PCAN_USB_CMD_FUNC] = f;
129 dev->cmd_buf[PCAN_USB_CMD_NUM] = n;
130
131 if (p)
132 memcpy(dev->cmd_buf + PCAN_USB_CMD_ARGS,
133 p, PCAN_USB_CMD_ARGS_LEN);
134
135 err = usb_bulk_msg(dev->udev,
136 usb_sndbulkpipe(dev->udev, PCAN_USB_EP_CMDOUT),
137 dev->cmd_buf, PCAN_USB_CMD_LEN, &actual_length,
138 PCAN_USB_COMMAND_TIMEOUT);
139 if (err)
140 netdev_err(dev->netdev,
141 "sending cmd f=0x%x n=0x%x failure: %d\n",
142 f, n, err);
143 return err;
144}
145
146/*
147 * send a command then wait for its response
148 */
149static int pcan_usb_wait_rsp(struct peak_usb_device *dev, u8 f, u8 n, u8 *p)
150{
151 int err;
152 int actual_length;
153
154 /* usb device unregistered? */
155 if (!(dev->state & PCAN_USB_STATE_CONNECTED))
156 return 0;
157
158 /* first, send command */
159 err = pcan_usb_send_cmd(dev, f, n, NULL);
160 if (err)
161 return err;
162
163 err = usb_bulk_msg(dev->udev,
164 usb_rcvbulkpipe(dev->udev, PCAN_USB_EP_CMDIN),
165 dev->cmd_buf, PCAN_USB_CMD_LEN, &actual_length,
166 PCAN_USB_COMMAND_TIMEOUT);
167 if (err)
168 netdev_err(dev->netdev,
169 "waiting rsp f=0x%x n=0x%x failure: %d\n", f, n, err);
170 else if (p)
171 memcpy(p, dev->cmd_buf + PCAN_USB_CMD_ARGS,
172 PCAN_USB_CMD_ARGS_LEN);
173
174 return err;
175}
176
177static int pcan_usb_set_sja1000(struct peak_usb_device *dev, u8 mode)
178{
179 u8 args[PCAN_USB_CMD_ARGS_LEN] = {
180 [1] = mode,
181 };
182
183 return pcan_usb_send_cmd(dev, 9, 2, args);
184}
185
186static int pcan_usb_set_bus(struct peak_usb_device *dev, u8 onoff)
187{
188 u8 args[PCAN_USB_CMD_ARGS_LEN] = {
189 [0] = !!onoff,
190 };
191
192 return pcan_usb_send_cmd(dev, 3, 2, args);
193}
194
195static int pcan_usb_set_silent(struct peak_usb_device *dev, u8 onoff)
196{
197 u8 args[PCAN_USB_CMD_ARGS_LEN] = {
198 [0] = !!onoff,
199 };
200
201 return pcan_usb_send_cmd(dev, 3, 3, args);
202}
203
204static int pcan_usb_set_ext_vcc(struct peak_usb_device *dev, u8 onoff)
205{
206 u8 args[PCAN_USB_CMD_ARGS_LEN] = {
207 [0] = !!onoff,
208 };
209
210 return pcan_usb_send_cmd(dev, 10, 2, args);
211}
212
213/*
214 * set bittiming value to can
215 */
216static int pcan_usb_set_bittiming(struct peak_usb_device *dev,
217 struct can_bittiming *bt)
218{
219 u8 args[PCAN_USB_CMD_ARGS_LEN];
220 u8 btr0, btr1;
221
222 btr0 = ((bt->brp - 1) & 0x3f) | (((bt->sjw - 1) & 0x3) << 6);
223 btr1 = ((bt->prop_seg + bt->phase_seg1 - 1) & 0xf) |
224 (((bt->phase_seg2 - 1) & 0x7) << 4);
225 if (dev->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES)
226 btr1 |= 0x80;
227
228 netdev_info(dev->netdev, "setting BTR0=0x%02x BTR1=0x%02x\n",
229 btr0, btr1);
230
231 args[0] = btr1;
232 args[1] = btr0;
233
234 return pcan_usb_send_cmd(dev, 1, 2, args);
235}
236
237/*
238 * init/reset can
239 */
240static int pcan_usb_write_mode(struct peak_usb_device *dev, u8 onoff)
241{
242 int err;
243
244 err = pcan_usb_set_bus(dev, onoff);
245 if (err)
246 return err;
247
248 if (!onoff) {
249 err = pcan_usb_set_sja1000(dev, SJA1000_MODE_INIT);
250 } else {
251 /* the PCAN-USB needs time to init */
252 set_current_state(TASK_INTERRUPTIBLE);
253 schedule_timeout(msecs_to_jiffies(PCAN_USB_STARTUP_TIMEOUT));
254 }
255
256 return err;
257}
258
259/*
260 * handle end of waiting for the device to reset
261 */
262static void pcan_usb_restart(unsigned long arg)
263{
264 /* notify candev and netdev */
265 peak_usb_restart_complete((struct peak_usb_device *)arg);
266}
267
268/*
269 * handle the submission of the restart urb
270 */
271static void pcan_usb_restart_pending(struct urb *urb)
272{
273 struct pcan_usb *pdev = urb->context;
274
275 /* the PCAN-USB needs time to restart */
276 mod_timer(&pdev->restart_timer,
277 jiffies + msecs_to_jiffies(PCAN_USB_STARTUP_TIMEOUT));
278
279 /* can delete usb resources */
280 peak_usb_async_complete(urb);
281}
282
283/*
284 * handle asynchronous restart
285 */
286static int pcan_usb_restart_async(struct peak_usb_device *dev, struct urb *urb,
287 u8 *buf)
288{
289 struct pcan_usb *pdev = container_of(dev, struct pcan_usb, dev);
290
291 if (timer_pending(&pdev->restart_timer))
292 return -EBUSY;
293
294 /* set bus on */
295 buf[PCAN_USB_CMD_FUNC] = 3;
296 buf[PCAN_USB_CMD_NUM] = 2;
297 buf[PCAN_USB_CMD_ARGS] = 1;
298
299 usb_fill_bulk_urb(urb, dev->udev,
300 usb_sndbulkpipe(dev->udev, PCAN_USB_EP_CMDOUT),
301 buf, PCAN_USB_CMD_LEN,
302 pcan_usb_restart_pending, pdev);
303
304 return usb_submit_urb(urb, GFP_ATOMIC);
305}
306
307/*
308 * read serial number from device
309 */
310static int pcan_usb_get_serial(struct peak_usb_device *dev, u32 *serial_number)
311{
312 u8 args[PCAN_USB_CMD_ARGS_LEN];
313 int err;
314
315 err = pcan_usb_wait_rsp(dev, 6, 1, args);
316 if (err) {
317 netdev_err(dev->netdev, "getting serial failure: %d\n", err);
318 } else if (serial_number) {
319 u32 tmp32;
320
321 memcpy(&tmp32, args, 4);
322 *serial_number = le32_to_cpu(tmp32);
323 }
324
325 return err;
326}
327
328/*
329 * read device id from device
330 */
331static int pcan_usb_get_device_id(struct peak_usb_device *dev, u32 *device_id)
332{
333 u8 args[PCAN_USB_CMD_ARGS_LEN];
334 int err;
335
336 err = pcan_usb_wait_rsp(dev, 4, 1, args);
337 if (err)
338 netdev_err(dev->netdev, "getting device id failure: %d\n", err);
339 else if (device_id)
340 *device_id = args[0];
341
342 return err;
343}
344
345/*
346 * update current time ref with received timestamp
347 */
348static int pcan_usb_update_ts(struct pcan_usb_msg_context *mc)
349{
350 u16 tmp16;
351
352 if ((mc->ptr+2) > mc->end)
353 return -EINVAL;
354
355 memcpy(&tmp16, mc->ptr, 2);
356
357 mc->ts16 = le16_to_cpu(tmp16);
358
359 if (mc->rec_idx > 0)
360 peak_usb_update_ts_now(&mc->pdev->time_ref, mc->ts16);
361 else
362 peak_usb_set_ts_now(&mc->pdev->time_ref, mc->ts16);
363
364 return 0;
365}
366
367/*
368 * decode received timestamp
369 */
370static int pcan_usb_decode_ts(struct pcan_usb_msg_context *mc, u8 first_packet)
371{
372 /* only 1st packet supplies a word timestamp */
373 if (first_packet) {
374 u16 tmp16;
375
376 if ((mc->ptr + 2) > mc->end)
377 return -EINVAL;
378
379 memcpy(&tmp16, mc->ptr, 2);
380 mc->ptr += 2;
381
382 mc->ts16 = le16_to_cpu(tmp16);
383 mc->prev_ts8 = mc->ts16 & 0x00ff;
384 } else {
385 u8 ts8;
386
387 if ((mc->ptr + 1) > mc->end)
388 return -EINVAL;
389
390 ts8 = *mc->ptr++;
391
392 if (ts8 < mc->prev_ts8)
393 mc->ts16 += 0x100;
394
395 mc->ts16 &= 0xff00;
396 mc->ts16 |= ts8;
397 mc->prev_ts8 = ts8;
398 }
399
400 return 0;
401}
402
403static int pcan_usb_decode_error(struct pcan_usb_msg_context *mc, u8 n,
404 u8 status_len)
405{
406 struct sk_buff *skb;
407 struct can_frame *cf;
408 struct timeval tv;
409 enum can_state new_state;
410
411 /* ignore this error until 1st ts received */
412 if (n == PCAN_USB_ERROR_QOVR)
413 if (!mc->pdev->time_ref.tick_count)
414 return 0;
415
416 new_state = mc->pdev->dev.can.state;
417
418 switch (mc->pdev->dev.can.state) {
419 case CAN_STATE_ERROR_ACTIVE:
420 if (n & PCAN_USB_ERROR_BUS_LIGHT) {
421 new_state = CAN_STATE_ERROR_WARNING;
422 break;
423 }
424
425 case CAN_STATE_ERROR_WARNING:
426 if (n & PCAN_USB_ERROR_BUS_HEAVY) {
427 new_state = CAN_STATE_ERROR_PASSIVE;
428 break;
429 }
430 if (n & PCAN_USB_ERROR_BUS_OFF) {
431 new_state = CAN_STATE_BUS_OFF;
432 break;
433 }
434 if (n & (PCAN_USB_ERROR_RXQOVR | PCAN_USB_ERROR_QOVR)) {
435 /*
436 * trick to bypass next comparison and process other
437 * errors
438 */
439 new_state = CAN_STATE_MAX;
440 break;
441 }
442 if ((n & PCAN_USB_ERROR_BUS_LIGHT) == 0) {
443 /* no error (back to active state) */
444 mc->pdev->dev.can.state = CAN_STATE_ERROR_ACTIVE;
445 return 0;
446 }
447 break;
448
449 case CAN_STATE_ERROR_PASSIVE:
450 if (n & PCAN_USB_ERROR_BUS_OFF) {
451 new_state = CAN_STATE_BUS_OFF;
452 break;
453 }
454 if (n & PCAN_USB_ERROR_BUS_LIGHT) {
455 new_state = CAN_STATE_ERROR_WARNING;
456 break;
457 }
458 if (n & (PCAN_USB_ERROR_RXQOVR | PCAN_USB_ERROR_QOVR)) {
459 /*
460 * trick to bypass next comparison and process other
461 * errors
462 */
463 new_state = CAN_STATE_MAX;
464 break;
465 }
466
467 if ((n & PCAN_USB_ERROR_BUS_HEAVY) == 0) {
468 /* no error (back to active state) */
469 mc->pdev->dev.can.state = CAN_STATE_ERROR_ACTIVE;
470 return 0;
471 }
472 break;
473
474 default:
475 /* do nothing waiting for restart */
476 return 0;
477 }
478
479 /* donot post any error if current state didn't change */
480 if (mc->pdev->dev.can.state == new_state)
481 return 0;
482
483 /* allocate an skb to store the error frame */
484 skb = alloc_can_err_skb(mc->netdev, &cf);
485 if (!skb)
486 return -ENOMEM;
487
488 switch (new_state) {
489 case CAN_STATE_BUS_OFF:
490 cf->can_id |= CAN_ERR_BUSOFF;
491 can_bus_off(mc->netdev);
492 break;
493
494 case CAN_STATE_ERROR_PASSIVE:
495 cf->can_id |= CAN_ERR_CRTL;
496 cf->data[1] |= CAN_ERR_CRTL_TX_PASSIVE |
497 CAN_ERR_CRTL_RX_PASSIVE;
498 mc->pdev->dev.can.can_stats.error_passive++;
499 break;
500
501 case CAN_STATE_ERROR_WARNING:
502 cf->can_id |= CAN_ERR_CRTL;
503 cf->data[1] |= CAN_ERR_CRTL_TX_WARNING |
504 CAN_ERR_CRTL_RX_WARNING;
505 mc->pdev->dev.can.can_stats.error_warning++;
506 break;
507
508 default:
509 /* CAN_STATE_MAX (trick to handle other errors) */
510 cf->can_id |= CAN_ERR_CRTL;
511 cf->data[1] |= CAN_ERR_CRTL_RX_OVERFLOW;
512 mc->netdev->stats.rx_over_errors++;
513 mc->netdev->stats.rx_errors++;
514
515 new_state = mc->pdev->dev.can.state;
516 break;
517 }
518
519 mc->pdev->dev.can.state = new_state;
520
521 if (status_len & PCAN_USB_STATUSLEN_TIMESTAMP) {
522 struct skb_shared_hwtstamps *hwts = skb_hwtstamps(skb);
523
524 peak_usb_get_ts_tv(&mc->pdev->time_ref, mc->ts16, &tv);
525 hwts->hwtstamp = timeval_to_ktime(tv);
526 }
527
528 netif_rx(skb);
529 mc->netdev->stats.rx_packets++;
530 mc->netdev->stats.rx_bytes += cf->can_dlc;
531
532 return 0;
533}
534
535/*
536 * decode non-data usb message
537 */
538static int pcan_usb_decode_status(struct pcan_usb_msg_context *mc,
539 u8 status_len)
540{
541 u8 rec_len = status_len & PCAN_USB_STATUSLEN_DLC;
542 u8 f, n;
543 int err;
544
545 /* check whether function and number can be read */
546 if ((mc->ptr + 2) > mc->end)
547 return -EINVAL;
548
549 f = mc->ptr[PCAN_USB_CMD_FUNC];
550 n = mc->ptr[PCAN_USB_CMD_NUM];
551 mc->ptr += PCAN_USB_CMD_ARGS;
552
553 if (status_len & PCAN_USB_STATUSLEN_TIMESTAMP) {
554 int err = pcan_usb_decode_ts(mc, !mc->rec_idx);
555
556 if (err)
557 return err;
558 }
559
560 switch (f) {
561 case PCAN_USB_REC_ERROR:
562 err = pcan_usb_decode_error(mc, n, status_len);
563 if (err)
564 return err;
565 break;
566
567 case PCAN_USB_REC_ANALOG:
568 /* analog values (ignored) */
569 rec_len = 2;
570 break;
571
572 case PCAN_USB_REC_BUSLOAD:
573 /* bus load (ignored) */
574 rec_len = 1;
575 break;
576
577 case PCAN_USB_REC_TS:
578 /* only timestamp */
579 if (pcan_usb_update_ts(mc))
580 return -EINVAL;
581 break;
582
583 case PCAN_USB_REC_BUSEVT:
584 /* error frame/bus event */
585 if (n & PCAN_USB_ERROR_TXQFULL)
586 netdev_dbg(mc->netdev, "device Tx queue full)\n");
587 break;
588 default:
589 netdev_err(mc->netdev, "unexpected function %u\n", f);
590 break;
591 }
592
593 if ((mc->ptr + rec_len) > mc->end)
594 return -EINVAL;
595
596 mc->ptr += rec_len;
597
598 return 0;
599}
600
601/*
602 * decode data usb message
603 */
604static int pcan_usb_decode_data(struct pcan_usb_msg_context *mc, u8 status_len)
605{
606 u8 rec_len = status_len & PCAN_USB_STATUSLEN_DLC;
607 struct sk_buff *skb;
608 struct can_frame *cf;
609 struct timeval tv;
610 struct skb_shared_hwtstamps *hwts;
611
612 skb = alloc_can_skb(mc->netdev, &cf);
613 if (!skb)
614 return -ENOMEM;
615
616 if (status_len & PCAN_USB_STATUSLEN_EXT_ID) {
617 u32 tmp32;
618
619 if ((mc->ptr + 4) > mc->end)
620 goto decode_failed;
621
622 memcpy(&tmp32, mc->ptr, 4);
623 mc->ptr += 4;
624
625 cf->can_id = le32_to_cpu(tmp32 >> 3) | CAN_EFF_FLAG;
626 } else {
627 u16 tmp16;
628
629 if ((mc->ptr + 2) > mc->end)
630 goto decode_failed;
631
632 memcpy(&tmp16, mc->ptr, 2);
633 mc->ptr += 2;
634
635 cf->can_id = le16_to_cpu(tmp16 >> 5);
636 }
637
638 cf->can_dlc = get_can_dlc(rec_len);
639
640 /* first data packet timestamp is a word */
641 if (pcan_usb_decode_ts(mc, !mc->rec_data_idx))
642 goto decode_failed;
643
644 /* read data */
645 memset(cf->data, 0x0, sizeof(cf->data));
646 if (status_len & PCAN_USB_STATUSLEN_RTR) {
647 cf->can_id |= CAN_RTR_FLAG;
648 } else {
649 if ((mc->ptr + rec_len) > mc->end)
650 goto decode_failed;
651
652 memcpy(cf->data, mc->ptr, rec_len);
653 mc->ptr += rec_len;
654 }
655
656 /* convert timestamp into kernel time */
657 peak_usb_get_ts_tv(&mc->pdev->time_ref, mc->ts16, &tv);
658 hwts = skb_hwtstamps(skb);
659 hwts->hwtstamp = timeval_to_ktime(tv);
660
661 /* push the skb */
662 netif_rx(skb);
663
664 /* update statistics */
665 mc->netdev->stats.rx_packets++;
666 mc->netdev->stats.rx_bytes += cf->can_dlc;
667
668 return 0;
669
670decode_failed:
671 dev_kfree_skb(skb);
672 return -EINVAL;
673}
674
675/*
676 * process incoming message
677 */
678static int pcan_usb_decode_msg(struct peak_usb_device *dev, u8 *ibuf, u32 lbuf)
679{
680 struct pcan_usb_msg_context mc = {
681 .rec_cnt = ibuf[1],
682 .ptr = ibuf + PCAN_USB_MSG_HEADER_LEN,
683 .end = ibuf + lbuf,
684 .netdev = dev->netdev,
685 .pdev = container_of(dev, struct pcan_usb, dev),
686 };
687 int err;
688
689 for (err = 0; mc.rec_idx < mc.rec_cnt && !err; mc.rec_idx++) {
690 u8 sl = *mc.ptr++;
691
692 /* handle status and error frames here */
693 if (sl & PCAN_USB_STATUSLEN_INTERNAL) {
694 err = pcan_usb_decode_status(&mc, sl);
695 /* handle normal can frames here */
696 } else {
697 err = pcan_usb_decode_data(&mc, sl);
698 mc.rec_data_idx++;
699 }
700 }
701
702 return err;
703}
704
705/*
706 * process any incoming buffer
707 */
708static int pcan_usb_decode_buf(struct peak_usb_device *dev, struct urb *urb)
709{
710 int err = 0;
711
712 if (urb->actual_length > PCAN_USB_MSG_HEADER_LEN) {
713 err = pcan_usb_decode_msg(dev, urb->transfer_buffer,
714 urb->actual_length);
715
716 } else if (urb->actual_length > 0) {
717 netdev_err(dev->netdev, "usb message length error (%u)\n",
718 urb->actual_length);
719 err = -EINVAL;
720 }
721
722 return err;
723}
724
725/*
726 * process outgoing packet
727 */
728static int pcan_usb_encode_msg(struct peak_usb_device *dev, struct sk_buff *skb,
729 u8 *obuf, size_t *size)
730{
731 struct net_device *netdev = dev->netdev;
732 struct net_device_stats *stats = &netdev->stats;
733 struct can_frame *cf = (struct can_frame *)skb->data;
734 u8 *pc;
735
736 obuf[0] = 2;
737 obuf[1] = 1;
738
739 pc = obuf + PCAN_USB_MSG_HEADER_LEN;
740
741 /* status/len byte */
742 *pc = cf->can_dlc;
743 if (cf->can_id & CAN_RTR_FLAG)
744 *pc |= PCAN_USB_STATUSLEN_RTR;
745
746 /* can id */
747 if (cf->can_id & CAN_EFF_FLAG) {
748 __le32 tmp32 = cpu_to_le32((cf->can_id & CAN_ERR_MASK) << 3);
749
750 *pc |= PCAN_USB_STATUSLEN_EXT_ID;
751 memcpy(++pc, &tmp32, 4);
752 pc += 4;
753 } else {
754 __le16 tmp16 = cpu_to_le16((cf->can_id & CAN_ERR_MASK) << 5);
755
756 memcpy(++pc, &tmp16, 2);
757 pc += 2;
758 }
759
760 /* can data */
761 if (!(cf->can_id & CAN_RTR_FLAG)) {
762 memcpy(pc, cf->data, cf->can_dlc);
763 pc += cf->can_dlc;
764 }
765
766 obuf[(*size)-1] = (u8)(stats->tx_packets & 0xff);
767
768 return 0;
769}
770
771/*
772 * start interface
773 */
774static int pcan_usb_start(struct peak_usb_device *dev)
775{
776 struct pcan_usb *pdev = container_of(dev, struct pcan_usb, dev);
777
778 /* number of bits used in timestamps read from adapter struct */
779 peak_usb_init_time_ref(&pdev->time_ref, &pcan_usb);
780
781 /* if revision greater than 3, can put silent mode on/off */
782 if (dev->device_rev > 3) {
783 int err;
784
785 err = pcan_usb_set_silent(dev,
786 dev->can.ctrlmode & CAN_CTRLMODE_LISTENONLY);
787 if (err)
788 return err;
789 }
790
791 return pcan_usb_set_ext_vcc(dev, 0);
792}
793
794static int pcan_usb_init(struct peak_usb_device *dev)
795{
796 struct pcan_usb *pdev = container_of(dev, struct pcan_usb, dev);
797 u32 serial_number;
798 int err;
799
800 /* initialize a timer needed to wait for hardware restart */
801 init_timer(&pdev->restart_timer);
802 pdev->restart_timer.function = pcan_usb_restart;
803 pdev->restart_timer.data = (unsigned long)dev;
804
805 /*
806 * explicit use of dev_xxx() instead of netdev_xxx() here:
807 * information displayed are related to the device itself, not
808 * to the canx netdevice.
809 */
810 err = pcan_usb_get_serial(dev, &serial_number);
811 if (err) {
812 dev_err(dev->netdev->dev.parent,
813 "unable to read %s serial number (err %d)\n",
814 pcan_usb.name, err);
815 return err;
816 }
817
818 dev_info(dev->netdev->dev.parent,
819 "PEAK-System %s adapter hwrev %u serial %08X (%u channel)\n",
820 pcan_usb.name, dev->device_rev, serial_number,
821 pcan_usb.ctrl_count);
822
823 return 0;
824}
825
826/*
827 * probe function for new PCAN-USB usb interface
828 */
829static int pcan_usb_probe(struct usb_interface *intf)
830{
831 struct usb_host_interface *if_desc;
832 int i;
833
834 if_desc = intf->altsetting;
835
836 /* check interface endpoint addresses */
837 for (i = 0; i < if_desc->desc.bNumEndpoints; i++) {
838 struct usb_endpoint_descriptor *ep = &if_desc->endpoint[i].desc;
839
840 switch (ep->bEndpointAddress) {
841 case PCAN_USB_EP_CMDOUT:
842 case PCAN_USB_EP_CMDIN:
843 case PCAN_USB_EP_MSGOUT:
844 case PCAN_USB_EP_MSGIN:
845 break;
846 default:
847 return -ENODEV;
848 }
849 }
850
851 return 0;
852}
853
854/*
855 * describe the PCAN-USB adapter
856 */
857struct peak_usb_adapter pcan_usb = {
858 .name = "PCAN-USB",
859 .device_id = PCAN_USB_PRODUCT_ID,
860 .ctrl_count = 1,
861 .clock = {
862 .freq = PCAN_USB_CRYSTAL_HZ / 2 ,
863 },
864 .bittiming_const = {
865 .name = "pcan_usb",
866 .tseg1_min = 1,
867 .tseg1_max = 16,
868 .tseg2_min = 1,
869 .tseg2_max = 8,
870 .sjw_max = 4,
871 .brp_min = 1,
872 .brp_max = 64,
873 .brp_inc = 1,
874 },
875
876 /* size of device private data */
877 .sizeof_dev_private = sizeof(struct pcan_usb),
878
879 /* timestamps usage */
880 .ts_used_bits = 16,
881 .ts_period = 24575, /* calibration period in ts. */
882 .us_per_ts_scale = PCAN_USB_TS_US_PER_TICK, /* us=(ts*scale) */
883 .us_per_ts_shift = PCAN_USB_TS_DIV_SHIFTER, /* >> shift */
884
885 /* give here messages in/out endpoints */
886 .ep_msg_in = PCAN_USB_EP_MSGIN,
887 .ep_msg_out = {PCAN_USB_EP_MSGOUT},
888
889 /* size of rx/tx usb buffers */
890 .rx_buffer_size = PCAN_USB_RX_BUFFER_SIZE,
891 .tx_buffer_size = PCAN_USB_TX_BUFFER_SIZE,
892
893 /* device callbacks */
894 .intf_probe = pcan_usb_probe,
895 .dev_init = pcan_usb_init,
896 .dev_set_bus = pcan_usb_write_mode,
897 .dev_set_bittiming = pcan_usb_set_bittiming,
898 .dev_get_device_id = pcan_usb_get_device_id,
899 .dev_decode_buf = pcan_usb_decode_buf,
900 .dev_encode_msg = pcan_usb_encode_msg,
901 .dev_start = pcan_usb_start,
902 .dev_restart_async = pcan_usb_restart_async,
903};
diff --git a/drivers/net/can/usb/peak_usb/pcan_usb_core.c b/drivers/net/can/usb/peak_usb/pcan_usb_core.c
deleted file mode 100644
index d9290ea788e..00000000000
--- a/drivers/net/can/usb/peak_usb/pcan_usb_core.c
+++ /dev/null
@@ -1,946 +0,0 @@
1/*
2 * CAN driver for PEAK System USB adapters
3 * Derived from the PCAN project file driver/src/pcan_usb_core.c
4 *
5 * Copyright (C) 2003-2010 PEAK System-Technik GmbH
6 * Copyright (C) 2010-2012 Stephane Grosjean <s.grosjean@peak-system.com>
7 *
8 * Many thanks to Klaus Hitschler <klaus.hitschler@gmx.de>
9 *
10 * This program is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU General Public License as published
12 * by the Free Software Foundation; version 2 of the License.
13 *
14 * This program is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * General Public License for more details.
18 */
19#include <linux/init.h>
20#include <linux/signal.h>
21#include <linux/slab.h>
22#include <linux/module.h>
23#include <linux/netdevice.h>
24#include <linux/usb.h>
25
26#include <linux/can.h>
27#include <linux/can/dev.h>
28#include <linux/can/error.h>
29
30#include "pcan_usb_core.h"
31
32MODULE_AUTHOR("Stephane Grosjean <s.grosjean@peak-system.com>");
33MODULE_DESCRIPTION("CAN driver for PEAK-System USB adapters");
34MODULE_LICENSE("GPL v2");
35
36/* Table of devices that work with this driver */
37static struct usb_device_id peak_usb_table[] = {
38 {USB_DEVICE(PCAN_USB_VENDOR_ID, PCAN_USB_PRODUCT_ID)},
39 {USB_DEVICE(PCAN_USB_VENDOR_ID, PCAN_USBPRO_PRODUCT_ID)},
40 {} /* Terminating entry */
41};
42
43MODULE_DEVICE_TABLE(usb, peak_usb_table);
44
45/* List of supported PCAN-USB adapters (NULL terminated list) */
46static struct peak_usb_adapter *peak_usb_adapters_list[] = {
47 &pcan_usb,
48 &pcan_usb_pro,
49 NULL,
50};
51
52/*
53 * dump memory
54 */
55#define DUMP_WIDTH 16
56void pcan_dump_mem(char *prompt, void *p, int l)
57{
58 pr_info("%s dumping %s (%d bytes):\n",
59 PCAN_USB_DRIVER_NAME, prompt ? prompt : "memory", l);
60 print_hex_dump(KERN_INFO, PCAN_USB_DRIVER_NAME " ", DUMP_PREFIX_NONE,
61 DUMP_WIDTH, 1, p, l, false);
62}
63
64/*
65 * initialize a time_ref object with usb adapter own settings
66 */
67void peak_usb_init_time_ref(struct peak_time_ref *time_ref,
68 struct peak_usb_adapter *adapter)
69{
70 if (time_ref) {
71 memset(time_ref, 0, sizeof(struct peak_time_ref));
72 time_ref->adapter = adapter;
73 }
74}
75
76static void peak_usb_add_us(struct timeval *tv, u32 delta_us)
77{
78 /* number of s. to add to final time */
79 u32 delta_s = delta_us / 1000000;
80
81 delta_us -= delta_s * 1000000;
82
83 tv->tv_usec += delta_us;
84 if (tv->tv_usec >= 1000000) {
85 tv->tv_usec -= 1000000;
86 delta_s++;
87 }
88 tv->tv_sec += delta_s;
89}
90
91/*
92 * sometimes, another now may be more recent than current one...
93 */
94void peak_usb_update_ts_now(struct peak_time_ref *time_ref, u32 ts_now)
95{
96 time_ref->ts_dev_2 = ts_now;
97
98 /* should wait at least two passes before computing */
99 if (time_ref->tv_host.tv_sec > 0) {
100 u32 delta_ts = time_ref->ts_dev_2 - time_ref->ts_dev_1;
101
102 if (time_ref->ts_dev_2 < time_ref->ts_dev_1)
103 delta_ts &= (1 << time_ref->adapter->ts_used_bits) - 1;
104
105 time_ref->ts_total += delta_ts;
106 }
107}
108
109/*
110 * register device timestamp as now
111 */
112void peak_usb_set_ts_now(struct peak_time_ref *time_ref, u32 ts_now)
113{
114 if (time_ref->tv_host_0.tv_sec == 0) {
115 /* use monotonic clock to correctly compute further deltas */
116 time_ref->tv_host_0 = ktime_to_timeval(ktime_get());
117 time_ref->tv_host.tv_sec = 0;
118 } else {
119 /*
120 * delta_us should not be >= 2^32 => delta_s should be < 4294
121 * handle 32-bits wrapping here: if count of s. reaches 4200,
122 * reset counters and change time base
123 */
124 if (time_ref->tv_host.tv_sec != 0) {
125 u32 delta_s = time_ref->tv_host.tv_sec
126 - time_ref->tv_host_0.tv_sec;
127 if (delta_s > 4200) {
128 time_ref->tv_host_0 = time_ref->tv_host;
129 time_ref->ts_total = 0;
130 }
131 }
132
133 time_ref->tv_host = ktime_to_timeval(ktime_get());
134 time_ref->tick_count++;
135 }
136
137 time_ref->ts_dev_1 = time_ref->ts_dev_2;
138 peak_usb_update_ts_now(time_ref, ts_now);
139}
140
141/*
142 * compute timeval according to current ts and time_ref data
143 */
144void peak_usb_get_ts_tv(struct peak_time_ref *time_ref, u32 ts,
145 struct timeval *tv)
146{
147 /* protect from getting timeval before setting now */
148 if (time_ref->tv_host.tv_sec > 0) {
149 u64 delta_us;
150
151 delta_us = ts - time_ref->ts_dev_2;
152 if (ts < time_ref->ts_dev_2)
153 delta_us &= (1 << time_ref->adapter->ts_used_bits) - 1;
154
155 delta_us += time_ref->ts_total;
156
157 delta_us *= time_ref->adapter->us_per_ts_scale;
158 delta_us >>= time_ref->adapter->us_per_ts_shift;
159
160 *tv = time_ref->tv_host_0;
161 peak_usb_add_us(tv, (u32)delta_us);
162 } else {
163 *tv = ktime_to_timeval(ktime_get());
164 }
165}
166
167/*
168 * callback for bulk Rx urb
169 */
170static void peak_usb_read_bulk_callback(struct urb *urb)
171{
172 struct peak_usb_device *dev = urb->context;
173 struct net_device *netdev;
174 int err;
175
176 netdev = dev->netdev;
177
178 if (!netif_device_present(netdev))
179 return;
180
181 /* check reception status */
182 switch (urb->status) {
183 case 0:
184 /* success */
185 break;
186
187 case -EILSEQ:
188 case -ENOENT:
189 case -ECONNRESET:
190 case -ESHUTDOWN:
191 return;
192
193 default:
194 if (net_ratelimit())
195 netdev_err(netdev,
196 "Rx urb aborted (%d)\n", urb->status);
197 goto resubmit_urb;
198 }
199
200 /* protect from any incoming empty msgs */
201 if ((urb->actual_length > 0) && (dev->adapter->dev_decode_buf)) {
202 /* handle these kinds of msgs only if _start callback called */
203 if (dev->state & PCAN_USB_STATE_STARTED) {
204 err = dev->adapter->dev_decode_buf(dev, urb);
205 if (err)
206 pcan_dump_mem("received usb message",
207 urb->transfer_buffer,
208 urb->transfer_buffer_length);
209 }
210 }
211
212resubmit_urb:
213 usb_fill_bulk_urb(urb, dev->udev,
214 usb_rcvbulkpipe(dev->udev, dev->ep_msg_in),
215 urb->transfer_buffer, dev->adapter->rx_buffer_size,
216 peak_usb_read_bulk_callback, dev);
217
218 usb_anchor_urb(urb, &dev->rx_submitted);
219 err = usb_submit_urb(urb, GFP_ATOMIC);
220 if (!err)
221 return;
222
223 usb_unanchor_urb(urb);
224
225 if (err == -ENODEV)
226 netif_device_detach(netdev);
227 else
228 netdev_err(netdev, "failed resubmitting read bulk urb: %d\n",
229 err);
230}
231
232/*
233 * callback for bulk Tx urb
234 */
235static void peak_usb_write_bulk_callback(struct urb *urb)
236{
237 struct peak_tx_urb_context *context = urb->context;
238 struct peak_usb_device *dev;
239 struct net_device *netdev;
240
241 BUG_ON(!context);
242
243 dev = context->dev;
244 netdev = dev->netdev;
245
246 atomic_dec(&dev->active_tx_urbs);
247
248 if (!netif_device_present(netdev))
249 return;
250
251 /* check tx status */
252 switch (urb->status) {
253 case 0:
254 /* transmission complete */
255 netdev->stats.tx_packets++;
256 netdev->stats.tx_bytes += context->dlc;
257
258 /* prevent tx timeout */
259 netdev->trans_start = jiffies;
260 break;
261
262 default:
263 if (net_ratelimit())
264 netdev_err(netdev, "Tx urb aborted (%d)\n",
265 urb->status);
266 case -EPROTO:
267 case -ENOENT:
268 case -ECONNRESET:
269 case -ESHUTDOWN:
270
271 break;
272 }
273
274 /* should always release echo skb and corresponding context */
275 can_get_echo_skb(netdev, context->echo_index);
276 context->echo_index = PCAN_USB_MAX_TX_URBS;
277
278 /* do wakeup tx queue in case of success only */
279 if (!urb->status)
280 netif_wake_queue(netdev);
281}
282
283/*
284 * called by netdev to send one skb on the CAN interface.
285 */
286static netdev_tx_t peak_usb_ndo_start_xmit(struct sk_buff *skb,
287 struct net_device *netdev)
288{
289 struct peak_usb_device *dev = netdev_priv(netdev);
290 struct peak_tx_urb_context *context = NULL;
291 struct net_device_stats *stats = &netdev->stats;
292 struct can_frame *cf = (struct can_frame *)skb->data;
293 struct urb *urb;
294 u8 *obuf;
295 int i, err;
296 size_t size = dev->adapter->tx_buffer_size;
297
298 if (can_dropped_invalid_skb(netdev, skb))
299 return NETDEV_TX_OK;
300
301 for (i = 0; i < PCAN_USB_MAX_TX_URBS; i++)
302 if (dev->tx_contexts[i].echo_index == PCAN_USB_MAX_TX_URBS) {
303 context = dev->tx_contexts + i;
304 break;
305 }
306
307 if (!context) {
308 /* should not occur except during restart */
309 return NETDEV_TX_BUSY;
310 }
311
312 urb = context->urb;
313 obuf = urb->transfer_buffer;
314
315 err = dev->adapter->dev_encode_msg(dev, skb, obuf, &size);
316 if (err) {
317 if (net_ratelimit())
318 netdev_err(netdev, "packet dropped\n");
319 dev_kfree_skb(skb);
320 stats->tx_dropped++;
321 return NETDEV_TX_OK;
322 }
323
324 context->echo_index = i;
325 context->dlc = cf->can_dlc;
326
327 usb_anchor_urb(urb, &dev->tx_submitted);
328
329 can_put_echo_skb(skb, netdev, context->echo_index);
330
331 atomic_inc(&dev->active_tx_urbs);
332
333 err = usb_submit_urb(urb, GFP_ATOMIC);
334 if (err) {
335 can_free_echo_skb(netdev, context->echo_index);
336
337 usb_unanchor_urb(urb);
338
339 /* this context is not used in fact */
340 context->echo_index = PCAN_USB_MAX_TX_URBS;
341
342 atomic_dec(&dev->active_tx_urbs);
343
344 switch (err) {
345 case -ENODEV:
346 netif_device_detach(netdev);
347 break;
348 default:
349 netdev_warn(netdev, "tx urb submitting failed err=%d\n",
350 err);
351 case -ENOENT:
352 /* cable unplugged */
353 stats->tx_dropped++;
354 }
355 } else {
356 netdev->trans_start = jiffies;
357
358 /* slow down tx path */
359 if (atomic_read(&dev->active_tx_urbs) >= PCAN_USB_MAX_TX_URBS)
360 netif_stop_queue(netdev);
361 }
362
363 return NETDEV_TX_OK;
364}
365
366/*
367 * start the CAN interface.
368 * Rx and Tx urbs are allocated here. Rx urbs are submitted here.
369 */
370static int peak_usb_start(struct peak_usb_device *dev)
371{
372 struct net_device *netdev = dev->netdev;
373 int err, i;
374
375 for (i = 0; i < PCAN_USB_MAX_RX_URBS; i++) {
376 struct urb *urb;
377 u8 *buf;
378
379 /* create a URB, and a buffer for it, to receive usb messages */
380 urb = usb_alloc_urb(0, GFP_KERNEL);
381 if (!urb) {
382 netdev_err(netdev, "No memory left for URBs\n");
383 err = -ENOMEM;
384 break;
385 }
386
387 buf = kmalloc(dev->adapter->rx_buffer_size, GFP_KERNEL);
388 if (!buf) {
389 netdev_err(netdev, "No memory left for USB buffer\n");
390 usb_free_urb(urb);
391 err = -ENOMEM;
392 break;
393 }
394
395 usb_fill_bulk_urb(urb, dev->udev,
396 usb_rcvbulkpipe(dev->udev, dev->ep_msg_in),
397 buf, dev->adapter->rx_buffer_size,
398 peak_usb_read_bulk_callback, dev);
399
400 /* ask last usb_free_urb() to also kfree() transfer_buffer */
401 urb->transfer_flags |= URB_FREE_BUFFER;
402 usb_anchor_urb(urb, &dev->rx_submitted);
403
404 err = usb_submit_urb(urb, GFP_KERNEL);
405 if (err) {
406 if (err == -ENODEV)
407 netif_device_detach(dev->netdev);
408
409 usb_unanchor_urb(urb);
410 kfree(buf);
411 usb_free_urb(urb);
412 break;
413 }
414
415 /* drop reference, USB core will take care of freeing it */
416 usb_free_urb(urb);
417 }
418
419 /* did we submit any URBs? Warn if we was not able to submit all urbs */
420 if (i < PCAN_USB_MAX_RX_URBS) {
421 if (i == 0) {
422 netdev_err(netdev, "couldn't setup any rx URB\n");
423 return err;
424 }
425
426 netdev_warn(netdev, "rx performance may be slow\n");
427 }
428
429 /* pre-alloc tx buffers and corresponding urbs */
430 for (i = 0; i < PCAN_USB_MAX_TX_URBS; i++) {
431 struct peak_tx_urb_context *context;
432 struct urb *urb;
433 u8 *buf;
434
435 /* create a URB and a buffer for it, to transmit usb messages */
436 urb = usb_alloc_urb(0, GFP_KERNEL);
437 if (!urb) {
438 netdev_err(netdev, "No memory left for URBs\n");
439 err = -ENOMEM;
440 break;
441 }
442
443 buf = kmalloc(dev->adapter->tx_buffer_size, GFP_KERNEL);
444 if (!buf) {
445 netdev_err(netdev, "No memory left for USB buffer\n");
446 usb_free_urb(urb);
447 err = -ENOMEM;
448 break;
449 }
450
451 context = dev->tx_contexts + i;
452 context->dev = dev;
453 context->urb = urb;
454
455 usb_fill_bulk_urb(urb, dev->udev,
456 usb_sndbulkpipe(dev->udev, dev->ep_msg_out),
457 buf, dev->adapter->tx_buffer_size,
458 peak_usb_write_bulk_callback, context);
459
460 /* ask last usb_free_urb() to also kfree() transfer_buffer */
461 urb->transfer_flags |= URB_FREE_BUFFER;
462 }
463
464 /* warn if we were not able to allocate enough tx contexts */
465 if (i < PCAN_USB_MAX_TX_URBS) {
466 if (i == 0) {
467 netdev_err(netdev, "couldn't setup any tx URB\n");
468 return err;
469 }
470
471 netdev_warn(netdev, "tx performance may be slow\n");
472 }
473
474 if (dev->adapter->dev_start) {
475 err = dev->adapter->dev_start(dev);
476 if (err)
477 goto failed;
478 }
479
480 dev->state |= PCAN_USB_STATE_STARTED;
481
482 /* can set bus on now */
483 if (dev->adapter->dev_set_bus) {
484 err = dev->adapter->dev_set_bus(dev, 1);
485 if (err)
486 goto failed;
487 }
488
489 dev->can.state = CAN_STATE_ERROR_ACTIVE;
490
491 return 0;
492
493failed:
494 if (err == -ENODEV)
495 netif_device_detach(dev->netdev);
496
497 netdev_warn(netdev, "couldn't submit control: %d\n", err);
498
499 return err;
500}
501
502/*
503 * called by netdev to open the corresponding CAN interface.
504 */
505static int peak_usb_ndo_open(struct net_device *netdev)
506{
507 struct peak_usb_device *dev = netdev_priv(netdev);
508 int err;
509
510 /* common open */
511 err = open_candev(netdev);
512 if (err)
513 return err;
514
515 /* finally start device */
516 err = peak_usb_start(dev);
517 if (err) {
518 netdev_err(netdev, "couldn't start device: %d\n", err);
519 close_candev(netdev);
520 return err;
521 }
522
523 netif_start_queue(netdev);
524
525 return 0;
526}
527
528/*
529 * unlink in-flight Rx and Tx urbs and free their memory.
530 */
531static void peak_usb_unlink_all_urbs(struct peak_usb_device *dev)
532{
533 int i;
534
535 /* free all Rx (submitted) urbs */
536 usb_kill_anchored_urbs(&dev->rx_submitted);
537
538 /* free unsubmitted Tx urbs first */
539 for (i = 0; i < PCAN_USB_MAX_TX_URBS; i++) {
540 struct urb *urb = dev->tx_contexts[i].urb;
541
542 if (!urb ||
543 dev->tx_contexts[i].echo_index != PCAN_USB_MAX_TX_URBS) {
544 /*
545 * this urb is already released or always submitted,
546 * let usb core free by itself
547 */
548 continue;
549 }
550
551 usb_free_urb(urb);
552 dev->tx_contexts[i].urb = NULL;
553 }
554
555 /* then free all submitted Tx urbs */
556 usb_kill_anchored_urbs(&dev->tx_submitted);
557 atomic_set(&dev->active_tx_urbs, 0);
558}
559
560/*
561 * called by netdev to close the corresponding CAN interface.
562 */
563static int peak_usb_ndo_stop(struct net_device *netdev)
564{
565 struct peak_usb_device *dev = netdev_priv(netdev);
566
567 dev->state &= ~PCAN_USB_STATE_STARTED;
568 netif_stop_queue(netdev);
569
570 /* unlink all pending urbs and free used memory */
571 peak_usb_unlink_all_urbs(dev);
572
573 if (dev->adapter->dev_stop)
574 dev->adapter->dev_stop(dev);
575
576 close_candev(netdev);
577
578 dev->can.state = CAN_STATE_STOPPED;
579
580 /* can set bus off now */
581 if (dev->adapter->dev_set_bus) {
582 int err = dev->adapter->dev_set_bus(dev, 0);
583 if (err)
584 return err;
585 }
586
587 return 0;
588}
589
590/*
591 * handle end of waiting for the device to reset
592 */
593void peak_usb_restart_complete(struct peak_usb_device *dev)
594{
595 /* finally MUST update can state */
596 dev->can.state = CAN_STATE_ERROR_ACTIVE;
597
598 /* netdev queue can be awaken now */
599 netif_wake_queue(dev->netdev);
600}
601
602void peak_usb_async_complete(struct urb *urb)
603{
604 kfree(urb->transfer_buffer);
605 usb_free_urb(urb);
606}
607
608/*
609 * device (auto-)restart mechanism runs in a timer context =>
610 * MUST handle restart with asynchronous usb transfers
611 */
612static int peak_usb_restart(struct peak_usb_device *dev)
613{
614 struct urb *urb;
615 int err;
616 u8 *buf;
617
618 /*
619 * if device doesn't define any asynchronous restart handler, simply
620 * wake the netdev queue up
621 */
622 if (!dev->adapter->dev_restart_async) {
623 peak_usb_restart_complete(dev);
624 return 0;
625 }
626
627 /* first allocate a urb to handle the asynchronous steps */
628 urb = usb_alloc_urb(0, GFP_ATOMIC);
629 if (!urb) {
630 netdev_err(dev->netdev, "no memory left for urb\n");
631 return -ENOMEM;
632 }
633
634 /* also allocate enough space for the commands to send */
635 buf = kmalloc(PCAN_USB_MAX_CMD_LEN, GFP_ATOMIC);
636 if (!buf) {
637 netdev_err(dev->netdev, "no memory left for async cmd\n");
638 usb_free_urb(urb);
639 return -ENOMEM;
640 }
641
642 /* call the device specific handler for the restart */
643 err = dev->adapter->dev_restart_async(dev, urb, buf);
644 if (!err)
645 return 0;
646
647 kfree(buf);
648 usb_free_urb(urb);
649
650 return err;
651}
652
653/*
654 * candev callback used to change CAN mode.
655 * Warning: this is called from a timer context!
656 */
657static int peak_usb_set_mode(struct net_device *netdev, enum can_mode mode)
658{
659 struct peak_usb_device *dev = netdev_priv(netdev);
660 int err = 0;
661
662 switch (mode) {
663 case CAN_MODE_START:
664 err = peak_usb_restart(dev);
665 if (err)
666 netdev_err(netdev, "couldn't start device (err %d)\n",
667 err);
668 break;
669
670 default:
671 return -EOPNOTSUPP;
672 }
673
674 return err;
675}
676
677/*
678 * candev callback used to set device bitrate.
679 */
680static int peak_usb_set_bittiming(struct net_device *netdev)
681{
682 struct peak_usb_device *dev = netdev_priv(netdev);
683 struct can_bittiming *bt = &dev->can.bittiming;
684
685 if (dev->adapter->dev_set_bittiming) {
686 int err = dev->adapter->dev_set_bittiming(dev, bt);
687
688 if (err)
689 netdev_info(netdev, "couldn't set bitrate (err %d)\n",
690 err);
691 return err;
692 }
693
694 return 0;
695}
696
697static const struct net_device_ops peak_usb_netdev_ops = {
698 .ndo_open = peak_usb_ndo_open,
699 .ndo_stop = peak_usb_ndo_stop,
700 .ndo_start_xmit = peak_usb_ndo_start_xmit,
701};
702
703/*
704 * create one device which is attached to CAN controller #ctrl_idx of the
705 * usb adapter.
706 */
707static int peak_usb_create_dev(struct peak_usb_adapter *peak_usb_adapter,
708 struct usb_interface *intf, int ctrl_idx)
709{
710 struct usb_device *usb_dev = interface_to_usbdev(intf);
711 int sizeof_candev = peak_usb_adapter->sizeof_dev_private;
712 struct peak_usb_device *dev;
713 struct net_device *netdev;
714 int i, err;
715 u16 tmp16;
716
717 if (sizeof_candev < sizeof(struct peak_usb_device))
718 sizeof_candev = sizeof(struct peak_usb_device);
719
720 netdev = alloc_candev(sizeof_candev, PCAN_USB_MAX_TX_URBS);
721 if (!netdev) {
722 dev_err(&intf->dev, "%s: couldn't alloc candev\n",
723 PCAN_USB_DRIVER_NAME);
724 return -ENOMEM;
725 }
726
727 dev = netdev_priv(netdev);
728
729 /* allocate a buffer large enough to send commands */
730 dev->cmd_buf = kmalloc(PCAN_USB_MAX_CMD_LEN, GFP_KERNEL);
731 if (!dev->cmd_buf) {
732 dev_err(&intf->dev, "%s: couldn't alloc cmd buffer\n",
733 PCAN_USB_DRIVER_NAME);
734 err = -ENOMEM;
735 goto lbl_set_intf_data;
736 }
737
738 dev->udev = usb_dev;
739 dev->netdev = netdev;
740 dev->adapter = peak_usb_adapter;
741 dev->ctrl_idx = ctrl_idx;
742 dev->state = PCAN_USB_STATE_CONNECTED;
743
744 dev->ep_msg_in = peak_usb_adapter->ep_msg_in;
745 dev->ep_msg_out = peak_usb_adapter->ep_msg_out[ctrl_idx];
746
747 dev->can.clock = peak_usb_adapter->clock;
748 dev->can.bittiming_const = &peak_usb_adapter->bittiming_const;
749 dev->can.do_set_bittiming = peak_usb_set_bittiming;
750 dev->can.do_set_mode = peak_usb_set_mode;
751 dev->can.ctrlmode_supported = CAN_CTRLMODE_3_SAMPLES |
752 CAN_CTRLMODE_LISTENONLY;
753
754 netdev->netdev_ops = &peak_usb_netdev_ops;
755
756 netdev->flags |= IFF_ECHO; /* we support local echo */
757
758 init_usb_anchor(&dev->rx_submitted);
759
760 init_usb_anchor(&dev->tx_submitted);
761 atomic_set(&dev->active_tx_urbs, 0);
762
763 for (i = 0; i < PCAN_USB_MAX_TX_URBS; i++)
764 dev->tx_contexts[i].echo_index = PCAN_USB_MAX_TX_URBS;
765
766 dev->prev_siblings = usb_get_intfdata(intf);
767 usb_set_intfdata(intf, dev);
768
769 SET_NETDEV_DEV(netdev, &intf->dev);
770
771 err = register_candev(netdev);
772 if (err) {
773 dev_err(&intf->dev, "couldn't register CAN device: %d\n", err);
774 goto lbl_free_cmd_buf;
775 }
776
777 if (dev->prev_siblings)
778 (dev->prev_siblings)->next_siblings = dev;
779
780 /* keep hw revision into the netdevice */
781 tmp16 = le16_to_cpu(usb_dev->descriptor.bcdDevice);
782 dev->device_rev = tmp16 >> 8;
783
784 if (dev->adapter->dev_init) {
785 err = dev->adapter->dev_init(dev);
786 if (err)
787 goto lbl_free_cmd_buf;
788 }
789
790 /* set bus off */
791 if (dev->adapter->dev_set_bus) {
792 err = dev->adapter->dev_set_bus(dev, 0);
793 if (err)
794 goto lbl_free_cmd_buf;
795 }
796
797 /* get device number early */
798 if (dev->adapter->dev_get_device_id)
799 dev->adapter->dev_get_device_id(dev, &dev->device_number);
800
801 netdev_info(netdev, "attached to %s channel %u (device %u)\n",
802 peak_usb_adapter->name, ctrl_idx, dev->device_number);
803
804 return 0;
805
806lbl_free_cmd_buf:
807 kfree(dev->cmd_buf);
808
809lbl_set_intf_data:
810 usb_set_intfdata(intf, dev->prev_siblings);
811 free_candev(netdev);
812
813 return err;
814}
815
816/*
817 * called by the usb core when the device is unplugged from the system
818 */
819static void peak_usb_disconnect(struct usb_interface *intf)
820{
821 struct peak_usb_device *dev;
822
823 /* unregister as many netdev devices as siblings */
824 for (dev = usb_get_intfdata(intf); dev; dev = dev->prev_siblings) {
825 struct net_device *netdev = dev->netdev;
826 char name[IFNAMSIZ];
827
828 dev->state &= ~PCAN_USB_STATE_CONNECTED;
829 strncpy(name, netdev->name, IFNAMSIZ);
830
831 unregister_netdev(netdev);
832 free_candev(netdev);
833
834 kfree(dev->cmd_buf);
835 dev->next_siblings = NULL;
836 if (dev->adapter->dev_free)
837 dev->adapter->dev_free(dev);
838
839 dev_info(&intf->dev, "%s removed\n", name);
840 }
841
842 usb_set_intfdata(intf, NULL);
843}
844
845/*
846 * probe function for new PEAK-System devices
847 */
848static int peak_usb_probe(struct usb_interface *intf,
849 const struct usb_device_id *id)
850{
851 struct usb_device *usb_dev = interface_to_usbdev(intf);
852 struct peak_usb_adapter *peak_usb_adapter, **pp;
853 int i, err = -ENOMEM;
854
855 usb_dev = interface_to_usbdev(intf);
856
857 /* get corresponding PCAN-USB adapter */
858 for (pp = peak_usb_adapters_list; *pp; pp++)
859 if ((*pp)->device_id == usb_dev->descriptor.idProduct)
860 break;
861
862 peak_usb_adapter = *pp;
863 if (!peak_usb_adapter) {
864 /* should never come except device_id bad usage in this file */
865 pr_err("%s: didn't find device id. 0x%x in devices list\n",
866 PCAN_USB_DRIVER_NAME, usb_dev->descriptor.idProduct);
867 return -ENODEV;
868 }
869
870 /* got corresponding adapter: check if it handles current interface */
871 if (peak_usb_adapter->intf_probe) {
872 err = peak_usb_adapter->intf_probe(intf);
873 if (err)
874 return err;
875 }
876
877 for (i = 0; i < peak_usb_adapter->ctrl_count; i++) {
878 err = peak_usb_create_dev(peak_usb_adapter, intf, i);
879 if (err) {
880 /* deregister already created devices */
881 peak_usb_disconnect(intf);
882 break;
883 }
884 }
885
886 return err;
887}
888
889/* usb specific object needed to register this driver with the usb subsystem */
890static struct usb_driver peak_usb_driver = {
891 .name = PCAN_USB_DRIVER_NAME,
892 .disconnect = peak_usb_disconnect,
893 .probe = peak_usb_probe,
894 .id_table = peak_usb_table,
895};
896
897static int __init peak_usb_init(void)
898{
899 int err;
900
901 /* register this driver with the USB subsystem */
902 err = usb_register(&peak_usb_driver);
903 if (err)
904 pr_err("%s: usb_register failed (err %d)\n",
905 PCAN_USB_DRIVER_NAME, err);
906
907 return err;
908}
909
910static int peak_usb_do_device_exit(struct device *d, void *arg)
911{
912 struct usb_interface *intf = to_usb_interface(d);
913 struct peak_usb_device *dev;
914
915 /* stop as many netdev devices as siblings */
916 for (dev = usb_get_intfdata(intf); dev; dev = dev->prev_siblings) {
917 struct net_device *netdev = dev->netdev;
918
919 if (netif_device_present(netdev))
920 if (dev->adapter->dev_exit)
921 dev->adapter->dev_exit(dev);
922 }
923
924 return 0;
925}
926
927static void __exit peak_usb_exit(void)
928{
929 int err;
930
931 /* last chance do send any synchronous commands here */
932 err = driver_for_each_device(&peak_usb_driver.drvwrap.driver, NULL,
933 NULL, peak_usb_do_device_exit);
934 if (err)
935 pr_err("%s: failed to stop all can devices (err %d)\n",
936 PCAN_USB_DRIVER_NAME, err);
937
938 /* deregister this driver with the USB subsystem */
939 usb_deregister(&peak_usb_driver);
940
941 pr_info("%s: PCAN-USB interfaces driver unloaded\n",
942 PCAN_USB_DRIVER_NAME);
943}
944
945module_init(peak_usb_init);
946module_exit(peak_usb_exit);
diff --git a/drivers/net/can/usb/peak_usb/pcan_usb_core.h b/drivers/net/can/usb/peak_usb/pcan_usb_core.h
deleted file mode 100644
index 073b47ff8ee..00000000000
--- a/drivers/net/can/usb/peak_usb/pcan_usb_core.h
+++ /dev/null
@@ -1,145 +0,0 @@
1/*
2 * CAN driver for PEAK System USB adapters
3 * Derived from the PCAN project file driver/src/pcan_usb_core.c
4 *
5 * Copyright (C) 2003-2010 PEAK System-Technik GmbH
6 * Copyright (C) 2010-2012 Stephane Grosjean <s.grosjean@peak-system.com>
7 *
8 * Many thanks to Klaus Hitschler <klaus.hitschler@gmx.de>
9 *
10 * This program is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU General Public License as published
12 * by the Free Software Foundation; version 2 of the License.
13 *
14 * This program is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * General Public License for more details.
18 */
19#ifndef PCAN_USB_CORE_H
20#define PCAN_USB_CORE_H
21
22/* PEAK-System vendor id. */
23#define PCAN_USB_VENDOR_ID 0x0c72
24
25/* supported device ids. */
26#define PCAN_USB_PRODUCT_ID 0x000c
27#define PCAN_USBPRO_PRODUCT_ID 0x000d
28
29#define PCAN_USB_DRIVER_NAME "peak_usb"
30
31/* number of urbs that are submitted for rx/tx per channel */
32#define PCAN_USB_MAX_RX_URBS 4
33#define PCAN_USB_MAX_TX_URBS 10
34
35/* usb adapters maximum channels per usb interface */
36#define PCAN_USB_MAX_CHANNEL 2
37
38/* maximum length of the usb commands sent to/received from the devices */
39#define PCAN_USB_MAX_CMD_LEN 32
40
41struct peak_usb_device;
42
43/* PEAK-System USB adapter descriptor */
44struct peak_usb_adapter {
45 char *name;
46 u32 device_id;
47 struct can_clock clock;
48 const struct can_bittiming_const bittiming_const;
49 unsigned int ctrl_count;
50
51 int (*intf_probe)(struct usb_interface *intf);
52
53 int (*dev_init)(struct peak_usb_device *dev);
54 void (*dev_exit)(struct peak_usb_device *dev);
55 void (*dev_free)(struct peak_usb_device *dev);
56 int (*dev_open)(struct peak_usb_device *dev);
57 int (*dev_close)(struct peak_usb_device *dev);
58 int (*dev_set_bittiming)(struct peak_usb_device *dev,
59 struct can_bittiming *bt);
60 int (*dev_set_bus)(struct peak_usb_device *dev, u8 onoff);
61 int (*dev_get_device_id)(struct peak_usb_device *dev, u32 *device_id);
62 int (*dev_decode_buf)(struct peak_usb_device *dev, struct urb *urb);
63 int (*dev_encode_msg)(struct peak_usb_device *dev, struct sk_buff *skb,
64 u8 *obuf, size_t *size);
65 int (*dev_start)(struct peak_usb_device *dev);
66 int (*dev_stop)(struct peak_usb_device *dev);
67 int (*dev_restart_async)(struct peak_usb_device *dev, struct urb *urb,
68 u8 *buf);
69 u8 ep_msg_in;
70 u8 ep_msg_out[PCAN_USB_MAX_CHANNEL];
71 u8 ts_used_bits;
72 u32 ts_period;
73 u8 us_per_ts_shift;
74 u32 us_per_ts_scale;
75
76 int rx_buffer_size;
77 int tx_buffer_size;
78 int sizeof_dev_private;
79};
80
81extern struct peak_usb_adapter pcan_usb;
82extern struct peak_usb_adapter pcan_usb_pro;
83
84struct peak_time_ref {
85 struct timeval tv_host_0, tv_host;
86 u32 ts_dev_1, ts_dev_2;
87 u64 ts_total;
88 u32 tick_count;
89 struct peak_usb_adapter *adapter;
90};
91
92struct peak_tx_urb_context {
93 struct peak_usb_device *dev;
94 u32 echo_index;
95 u8 dlc;
96 struct urb *urb;
97};
98
99#define PCAN_USB_STATE_CONNECTED 0x00000001
100#define PCAN_USB_STATE_STARTED 0x00000002
101
102/* PEAK-System USB device */
103struct peak_usb_device {
104 struct can_priv can;
105 struct peak_usb_adapter *adapter;
106 unsigned int ctrl_idx;
107 u32 state;
108
109 struct sk_buff *echo_skb[PCAN_USB_MAX_TX_URBS];
110
111 struct usb_device *udev;
112 struct net_device *netdev;
113
114 atomic_t active_tx_urbs;
115 struct usb_anchor tx_submitted;
116 struct peak_tx_urb_context tx_contexts[PCAN_USB_MAX_TX_URBS];
117
118 u8 *cmd_buf;
119 struct usb_anchor rx_submitted;
120
121 u32 device_number;
122 u8 device_rev;
123
124 u8 ep_msg_in;
125 u8 ep_msg_out;
126
127 u16 bus_load;
128
129 struct peak_usb_device *prev_siblings;
130 struct peak_usb_device *next_siblings;
131};
132
133void pcan_dump_mem(char *prompt, void *p, int l);
134
135/* common timestamp management */
136void peak_usb_init_time_ref(struct peak_time_ref *time_ref,
137 struct peak_usb_adapter *adapter);
138void peak_usb_update_ts_now(struct peak_time_ref *time_ref, u32 ts_now);
139void peak_usb_set_ts_now(struct peak_time_ref *time_ref, u32 ts_now);
140void peak_usb_get_ts_tv(struct peak_time_ref *time_ref, u32 ts,
141 struct timeval *tv);
142
143void peak_usb_async_complete(struct urb *urb);
144void peak_usb_restart_complete(struct peak_usb_device *dev);
145#endif
diff --git a/drivers/net/can/usb/peak_usb/pcan_usb_pro.c b/drivers/net/can/usb/peak_usb/pcan_usb_pro.c
deleted file mode 100644
index 30d79bfa5b1..00000000000
--- a/drivers/net/can/usb/peak_usb/pcan_usb_pro.c
+++ /dev/null
@@ -1,1042 +0,0 @@
1/*
2 * CAN driver for PEAK System PCAN-USB Pro adapter
3 * Derived from the PCAN project file driver/src/pcan_usbpro.c
4 *
5 * Copyright (C) 2003-2011 PEAK System-Technik GmbH
6 * Copyright (C) 2011-2012 Stephane Grosjean <s.grosjean@peak-system.com>
7 *
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published
10 * by the Free Software Foundation; version 2 of the License.
11 *
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
16 */
17#include <linux/netdevice.h>
18#include <linux/usb.h>
19#include <linux/module.h>
20
21#include <linux/can.h>
22#include <linux/can/dev.h>
23#include <linux/can/error.h>
24
25#include "pcan_usb_core.h"
26#include "pcan_usb_pro.h"
27
28MODULE_SUPPORTED_DEVICE("PEAK-System PCAN-USB Pro adapter");
29
30/* PCAN-USB Pro Endpoints */
31#define PCAN_USBPRO_EP_CMDOUT 1
32#define PCAN_USBPRO_EP_CMDIN (PCAN_USBPRO_EP_CMDOUT | USB_DIR_IN)
33#define PCAN_USBPRO_EP_MSGOUT_0 2
34#define PCAN_USBPRO_EP_MSGIN (PCAN_USBPRO_EP_MSGOUT_0 | USB_DIR_IN)
35#define PCAN_USBPRO_EP_MSGOUT_1 3
36#define PCAN_USBPRO_EP_UNUSED (PCAN_USBPRO_EP_MSGOUT_1 | USB_DIR_IN)
37
38#define PCAN_USBPRO_CHANNEL_COUNT 2
39
40/* PCAN-USB Pro adapter internal clock (MHz) */
41#define PCAN_USBPRO_CRYSTAL_HZ 56000000
42
43/* PCAN-USB Pro command timeout (ms.) */
44#define PCAN_USBPRO_COMMAND_TIMEOUT 1000
45
46/* PCAN-USB Pro rx/tx buffers size */
47#define PCAN_USBPRO_RX_BUFFER_SIZE 1024
48#define PCAN_USBPRO_TX_BUFFER_SIZE 64
49
50#define PCAN_USBPRO_MSG_HEADER_LEN 4
51
52/* some commands responses need to be re-submitted */
53#define PCAN_USBPRO_RSP_SUBMIT_MAX 2
54
55#define PCAN_USBPRO_RTR 0x01
56#define PCAN_USBPRO_EXT 0x02
57
58#define PCAN_USBPRO_CMD_BUFFER_SIZE 512
59
60/* handle device specific info used by the netdevices */
61struct pcan_usb_pro_interface {
62 struct peak_usb_device *dev[PCAN_USBPRO_CHANNEL_COUNT];
63 struct peak_time_ref time_ref;
64 int cm_ignore_count;
65 int dev_opened_count;
66};
67
68/* device information */
69struct pcan_usb_pro_device {
70 struct peak_usb_device dev;
71 struct pcan_usb_pro_interface *usb_if;
72 u32 cached_ccbt;
73};
74
75/* internal structure used to handle messages sent to bulk urb */
76struct pcan_usb_pro_msg {
77 u8 *rec_ptr;
78 int rec_buffer_size;
79 int rec_buffer_len;
80 union {
81 u16 *rec_cnt_rd;
82 u32 *rec_cnt;
83 u8 *rec_buffer;
84 } u;
85};
86
87/* records sizes table indexed on message id. (8-bits value) */
88static u16 pcan_usb_pro_sizeof_rec[256] = {
89 [PCAN_USBPRO_SETBTR] = sizeof(struct pcan_usb_pro_btr),
90 [PCAN_USBPRO_SETBUSACT] = sizeof(struct pcan_usb_pro_busact),
91 [PCAN_USBPRO_SETSILENT] = sizeof(struct pcan_usb_pro_silent),
92 [PCAN_USBPRO_SETFILTR] = sizeof(struct pcan_usb_pro_filter),
93 [PCAN_USBPRO_SETTS] = sizeof(struct pcan_usb_pro_setts),
94 [PCAN_USBPRO_GETDEVID] = sizeof(struct pcan_usb_pro_devid),
95 [PCAN_USBPRO_SETLED] = sizeof(struct pcan_usb_pro_setled),
96 [PCAN_USBPRO_RXMSG8] = sizeof(struct pcan_usb_pro_rxmsg),
97 [PCAN_USBPRO_RXMSG4] = sizeof(struct pcan_usb_pro_rxmsg) - 4,
98 [PCAN_USBPRO_RXMSG0] = sizeof(struct pcan_usb_pro_rxmsg) - 8,
99 [PCAN_USBPRO_RXRTR] = sizeof(struct pcan_usb_pro_rxmsg) - 8,
100 [PCAN_USBPRO_RXSTATUS] = sizeof(struct pcan_usb_pro_rxstatus),
101 [PCAN_USBPRO_RXTS] = sizeof(struct pcan_usb_pro_rxts),
102 [PCAN_USBPRO_TXMSG8] = sizeof(struct pcan_usb_pro_txmsg),
103 [PCAN_USBPRO_TXMSG4] = sizeof(struct pcan_usb_pro_txmsg) - 4,
104 [PCAN_USBPRO_TXMSG0] = sizeof(struct pcan_usb_pro_txmsg) - 8,
105};
106
107/*
108 * initialize PCAN-USB Pro message data structure
109 */
110static u8 *pcan_msg_init(struct pcan_usb_pro_msg *pm, void *buffer_addr,
111 int buffer_size)
112{
113 if (buffer_size < PCAN_USBPRO_MSG_HEADER_LEN)
114 return NULL;
115
116 pm->u.rec_buffer = (u8 *)buffer_addr;
117 pm->rec_buffer_size = pm->rec_buffer_len = buffer_size;
118 pm->rec_ptr = pm->u.rec_buffer + PCAN_USBPRO_MSG_HEADER_LEN;
119
120 return pm->rec_ptr;
121}
122
123static u8 *pcan_msg_init_empty(struct pcan_usb_pro_msg *pm,
124 void *buffer_addr, int buffer_size)
125{
126 u8 *pr = pcan_msg_init(pm, buffer_addr, buffer_size);
127
128 if (pr) {
129 pm->rec_buffer_len = PCAN_USBPRO_MSG_HEADER_LEN;
130 *pm->u.rec_cnt = 0;
131 }
132 return pr;
133}
134
135/*
136 * add one record to a message being built
137 */
138static int pcan_msg_add_rec(struct pcan_usb_pro_msg *pm, u8 id, ...)
139{
140 int len, i;
141 u8 *pc;
142 va_list ap;
143
144 va_start(ap, id);
145
146 pc = pm->rec_ptr + 1;
147
148 i = 0;
149 switch (id) {
150 case PCAN_USBPRO_TXMSG8:
151 i += 4;
152 case PCAN_USBPRO_TXMSG4:
153 i += 4;
154 case PCAN_USBPRO_TXMSG0:
155 *pc++ = va_arg(ap, int);
156 *pc++ = va_arg(ap, int);
157 *pc++ = va_arg(ap, int);
158 *(u32 *)pc = cpu_to_le32(va_arg(ap, u32));
159 pc += 4;
160 memcpy(pc, va_arg(ap, int *), i);
161 pc += i;
162 break;
163
164 case PCAN_USBPRO_SETBTR:
165 case PCAN_USBPRO_GETDEVID:
166 *pc++ = va_arg(ap, int);
167 pc += 2;
168 *(u32 *)pc = cpu_to_le32(va_arg(ap, u32));
169 pc += 4;
170 break;
171
172 case PCAN_USBPRO_SETFILTR:
173 case PCAN_USBPRO_SETBUSACT:
174 case PCAN_USBPRO_SETSILENT:
175 *pc++ = va_arg(ap, int);
176 *(u16 *)pc = cpu_to_le16(va_arg(ap, int));
177 pc += 2;
178 break;
179
180 case PCAN_USBPRO_SETLED:
181 *pc++ = va_arg(ap, int);
182 *(u16 *)pc = cpu_to_le16(va_arg(ap, int));
183 pc += 2;
184 *(u32 *)pc = cpu_to_le32(va_arg(ap, u32));
185 pc += 4;
186 break;
187
188 case PCAN_USBPRO_SETTS:
189 pc++;
190 *(u16 *)pc = cpu_to_le16(va_arg(ap, int));
191 pc += 2;
192 break;
193
194 default:
195 pr_err("%s: %s(): unknown data type %02Xh (%d)\n",
196 PCAN_USB_DRIVER_NAME, __func__, id, id);
197 pc--;
198 break;
199 }
200
201 len = pc - pm->rec_ptr;
202 if (len > 0) {
203 *pm->u.rec_cnt = cpu_to_le32(*pm->u.rec_cnt+1);
204 *pm->rec_ptr = id;
205
206 pm->rec_ptr = pc;
207 pm->rec_buffer_len += len;
208 }
209
210 va_end(ap);
211
212 return len;
213}
214
215/*
216 * send PCAN-USB Pro command synchronously
217 */
218static int pcan_usb_pro_send_cmd(struct peak_usb_device *dev,
219 struct pcan_usb_pro_msg *pum)
220{
221 int actual_length;
222 int err;
223
224 /* usb device unregistered? */
225 if (!(dev->state & PCAN_USB_STATE_CONNECTED))
226 return 0;
227
228 err = usb_bulk_msg(dev->udev,
229 usb_sndbulkpipe(dev->udev, PCAN_USBPRO_EP_CMDOUT),
230 pum->u.rec_buffer, pum->rec_buffer_len,
231 &actual_length, PCAN_USBPRO_COMMAND_TIMEOUT);
232 if (err)
233 netdev_err(dev->netdev, "sending command failure: %d\n", err);
234
235 return err;
236}
237
238/*
239 * wait for PCAN-USB Pro command response
240 */
241static int pcan_usb_pro_wait_rsp(struct peak_usb_device *dev,
242 struct pcan_usb_pro_msg *pum)
243{
244 u8 req_data_type, req_channel;
245 int actual_length;
246 int i, err = 0;
247
248 /* usb device unregistered? */
249 if (!(dev->state & PCAN_USB_STATE_CONNECTED))
250 return 0;
251
252 req_data_type = pum->u.rec_buffer[4];
253 req_channel = pum->u.rec_buffer[5];
254
255 *pum->u.rec_cnt = 0;
256 for (i = 0; !err && i < PCAN_USBPRO_RSP_SUBMIT_MAX; i++) {
257 struct pcan_usb_pro_msg rsp;
258 union pcan_usb_pro_rec *pr;
259 u32 r, rec_cnt;
260 u16 rec_len;
261 u8 *pc;
262
263 err = usb_bulk_msg(dev->udev,
264 usb_rcvbulkpipe(dev->udev, PCAN_USBPRO_EP_CMDIN),
265 pum->u.rec_buffer, pum->rec_buffer_len,
266 &actual_length, PCAN_USBPRO_COMMAND_TIMEOUT);
267 if (err) {
268 netdev_err(dev->netdev, "waiting rsp error %d\n", err);
269 break;
270 }
271
272 if (actual_length == 0)
273 continue;
274
275 err = -EBADMSG;
276 if (actual_length < PCAN_USBPRO_MSG_HEADER_LEN) {
277 netdev_err(dev->netdev,
278 "got abnormal too small rsp (len=%d)\n",
279 actual_length);
280 break;
281 }
282
283 pc = pcan_msg_init(&rsp, pum->u.rec_buffer,
284 actual_length);
285
286 rec_cnt = le32_to_cpu(*rsp.u.rec_cnt);
287
288 /* loop on records stored into message */
289 for (r = 0; r < rec_cnt; r++) {
290 pr = (union pcan_usb_pro_rec *)pc;
291 rec_len = pcan_usb_pro_sizeof_rec[pr->data_type];
292 if (!rec_len) {
293 netdev_err(dev->netdev,
294 "got unprocessed record in msg\n");
295 pcan_dump_mem("rcvd rsp msg", pum->u.rec_buffer,
296 actual_length);
297 break;
298 }
299
300 /* check if response corresponds to request */
301 if (pr->data_type != req_data_type)
302 netdev_err(dev->netdev,
303 "got unwanted rsp %xh: ignored\n",
304 pr->data_type);
305
306 /* check if channel in response corresponds too */
307 else if ((req_channel != 0xff) && \
308 (pr->bus_act.channel != req_channel))
309 netdev_err(dev->netdev,
310 "got rsp %xh but on chan%u: ignored\n",
311 req_data_type, pr->bus_act.channel);
312
313 /* got the response */
314 else
315 return 0;
316
317 /* otherwise, go on with next record in message */
318 pc += rec_len;
319 }
320 }
321
322 return (i >= PCAN_USBPRO_RSP_SUBMIT_MAX) ? -ERANGE : err;
323}
324
325static int pcan_usb_pro_send_req(struct peak_usb_device *dev, int req_id,
326 int req_value, void *req_addr, int req_size)
327{
328 int err;
329 u8 req_type;
330 unsigned int p;
331
332 /* usb device unregistered? */
333 if (!(dev->state & PCAN_USB_STATE_CONNECTED))
334 return 0;
335
336 memset(req_addr, '\0', req_size);
337
338 req_type = USB_TYPE_VENDOR | USB_RECIP_OTHER;
339
340 switch (req_id) {
341 case PCAN_USBPRO_REQ_FCT:
342 p = usb_sndctrlpipe(dev->udev, 0);
343 break;
344
345 default:
346 p = usb_rcvctrlpipe(dev->udev, 0);
347 req_type |= USB_DIR_IN;
348 break;
349 }
350
351 err = usb_control_msg(dev->udev, p, req_id, req_type, req_value, 0,
352 req_addr, req_size, 2 * USB_CTRL_GET_TIMEOUT);
353 if (err < 0) {
354 netdev_info(dev->netdev,
355 "unable to request usb[type=%d value=%d] err=%d\n",
356 req_id, req_value, err);
357 return err;
358 }
359
360 return 0;
361}
362
363static int pcan_usb_pro_set_ts(struct peak_usb_device *dev, u16 onoff)
364{
365 struct pcan_usb_pro_msg um;
366
367 pcan_msg_init_empty(&um, dev->cmd_buf, PCAN_USB_MAX_CMD_LEN);
368 pcan_msg_add_rec(&um, PCAN_USBPRO_SETTS, onoff);
369
370 return pcan_usb_pro_send_cmd(dev, &um);
371}
372
373static int pcan_usb_pro_set_bitrate(struct peak_usb_device *dev, u32 ccbt)
374{
375 struct pcan_usb_pro_device *pdev =
376 container_of(dev, struct pcan_usb_pro_device, dev);
377 struct pcan_usb_pro_msg um;
378
379 pcan_msg_init_empty(&um, dev->cmd_buf, PCAN_USB_MAX_CMD_LEN);
380 pcan_msg_add_rec(&um, PCAN_USBPRO_SETBTR, dev->ctrl_idx, ccbt);
381
382 /* cache the CCBT value to reuse it before next buson */
383 pdev->cached_ccbt = ccbt;
384
385 return pcan_usb_pro_send_cmd(dev, &um);
386}
387
388static int pcan_usb_pro_set_bus(struct peak_usb_device *dev, u8 onoff)
389{
390 struct pcan_usb_pro_msg um;
391
392 /* if bus=on, be sure the bitrate being set before! */
393 if (onoff) {
394 struct pcan_usb_pro_device *pdev =
395 container_of(dev, struct pcan_usb_pro_device, dev);
396
397 pcan_usb_pro_set_bitrate(dev, pdev->cached_ccbt);
398 }
399
400 pcan_msg_init_empty(&um, dev->cmd_buf, PCAN_USB_MAX_CMD_LEN);
401 pcan_msg_add_rec(&um, PCAN_USBPRO_SETBUSACT, dev->ctrl_idx, onoff);
402
403 return pcan_usb_pro_send_cmd(dev, &um);
404}
405
406static int pcan_usb_pro_set_silent(struct peak_usb_device *dev, u8 onoff)
407{
408 struct pcan_usb_pro_msg um;
409
410 pcan_msg_init_empty(&um, dev->cmd_buf, PCAN_USB_MAX_CMD_LEN);
411 pcan_msg_add_rec(&um, PCAN_USBPRO_SETSILENT, dev->ctrl_idx, onoff);
412
413 return pcan_usb_pro_send_cmd(dev, &um);
414}
415
416static int pcan_usb_pro_set_filter(struct peak_usb_device *dev, u16 filter_mode)
417{
418 struct pcan_usb_pro_msg um;
419
420 pcan_msg_init_empty(&um, dev->cmd_buf, PCAN_USB_MAX_CMD_LEN);
421 pcan_msg_add_rec(&um, PCAN_USBPRO_SETFILTR, dev->ctrl_idx, filter_mode);
422
423 return pcan_usb_pro_send_cmd(dev, &um);
424}
425
426static int pcan_usb_pro_set_led(struct peak_usb_device *dev, u8 mode,
427 u32 timeout)
428{
429 struct pcan_usb_pro_msg um;
430
431 pcan_msg_init_empty(&um, dev->cmd_buf, PCAN_USB_MAX_CMD_LEN);
432 pcan_msg_add_rec(&um, PCAN_USBPRO_SETLED, dev->ctrl_idx, mode, timeout);
433
434 return pcan_usb_pro_send_cmd(dev, &um);
435}
436
437static int pcan_usb_pro_get_device_id(struct peak_usb_device *dev,
438 u32 *device_id)
439{
440 struct pcan_usb_pro_devid *pdn;
441 struct pcan_usb_pro_msg um;
442 int err;
443 u8 *pc;
444
445 pc = pcan_msg_init_empty(&um, dev->cmd_buf, PCAN_USB_MAX_CMD_LEN);
446 pcan_msg_add_rec(&um, PCAN_USBPRO_GETDEVID, dev->ctrl_idx);
447
448 err = pcan_usb_pro_send_cmd(dev, &um);
449 if (err)
450 return err;
451
452 err = pcan_usb_pro_wait_rsp(dev, &um);
453 if (err)
454 return err;
455
456 pdn = (struct pcan_usb_pro_devid *)pc;
457 if (device_id)
458 *device_id = le32_to_cpu(pdn->serial_num);
459
460 return err;
461}
462
463static int pcan_usb_pro_set_bittiming(struct peak_usb_device *dev,
464 struct can_bittiming *bt)
465{
466 u32 ccbt;
467
468 ccbt = (dev->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES) ? 0x00800000 : 0;
469 ccbt |= (bt->sjw - 1) << 24;
470 ccbt |= (bt->phase_seg2 - 1) << 20;
471 ccbt |= (bt->prop_seg + bt->phase_seg1 - 1) << 16; /* = tseg1 */
472 ccbt |= bt->brp - 1;
473
474 netdev_info(dev->netdev, "setting ccbt=0x%08x\n", ccbt);
475
476 return pcan_usb_pro_set_bitrate(dev, ccbt);
477}
478
479static void pcan_usb_pro_restart_complete(struct urb *urb)
480{
481 /* can delete usb resources */
482 peak_usb_async_complete(urb);
483
484 /* notify candev and netdev */
485 peak_usb_restart_complete(urb->context);
486}
487
488/*
489 * handle restart but in asynchronously way
490 */
491static int pcan_usb_pro_restart_async(struct peak_usb_device *dev,
492 struct urb *urb, u8 *buf)
493{
494 struct pcan_usb_pro_msg um;
495
496 pcan_msg_init_empty(&um, buf, PCAN_USB_MAX_CMD_LEN);
497 pcan_msg_add_rec(&um, PCAN_USBPRO_SETBUSACT, dev->ctrl_idx, 1);
498
499 usb_fill_bulk_urb(urb, dev->udev,
500 usb_sndbulkpipe(dev->udev, PCAN_USBPRO_EP_CMDOUT),
501 buf, PCAN_USB_MAX_CMD_LEN,
502 pcan_usb_pro_restart_complete, dev);
503
504 return usb_submit_urb(urb, GFP_ATOMIC);
505}
506
507static void pcan_usb_pro_drv_loaded(struct peak_usb_device *dev, int loaded)
508{
509 u8 buffer[16];
510
511 buffer[0] = 0;
512 buffer[1] = !!loaded;
513
514 pcan_usb_pro_send_req(dev, PCAN_USBPRO_REQ_FCT,
515 PCAN_USBPRO_FCT_DRVLD, buffer, sizeof(buffer));
516}
517
518static inline
519struct pcan_usb_pro_interface *pcan_usb_pro_dev_if(struct peak_usb_device *dev)
520{
521 struct pcan_usb_pro_device *pdev =
522 container_of(dev, struct pcan_usb_pro_device, dev);
523 return pdev->usb_if;
524}
525
526static int pcan_usb_pro_handle_canmsg(struct pcan_usb_pro_interface *usb_if,
527 struct pcan_usb_pro_rxmsg *rx)
528{
529 const unsigned int ctrl_idx = (rx->len >> 4) & 0x0f;
530 struct peak_usb_device *dev = usb_if->dev[ctrl_idx];
531 struct net_device *netdev = dev->netdev;
532 struct can_frame *can_frame;
533 struct sk_buff *skb;
534 struct timeval tv;
535 struct skb_shared_hwtstamps *hwts;
536
537 skb = alloc_can_skb(netdev, &can_frame);
538 if (!skb)
539 return -ENOMEM;
540
541 can_frame->can_id = le32_to_cpu(rx->id);
542 can_frame->can_dlc = rx->len & 0x0f;
543
544 if (rx->flags & PCAN_USBPRO_EXT)
545 can_frame->can_id |= CAN_EFF_FLAG;
546
547 if (rx->flags & PCAN_USBPRO_RTR)
548 can_frame->can_id |= CAN_RTR_FLAG;
549 else
550 memcpy(can_frame->data, rx->data, can_frame->can_dlc);
551
552 peak_usb_get_ts_tv(&usb_if->time_ref, le32_to_cpu(rx->ts32), &tv);
553 hwts = skb_hwtstamps(skb);
554 hwts->hwtstamp = timeval_to_ktime(tv);
555
556 netif_rx(skb);
557 netdev->stats.rx_packets++;
558 netdev->stats.rx_bytes += can_frame->can_dlc;
559
560 return 0;
561}
562
563static int pcan_usb_pro_handle_error(struct pcan_usb_pro_interface *usb_if,
564 struct pcan_usb_pro_rxstatus *er)
565{
566 const u32 raw_status = le32_to_cpu(er->status);
567 const unsigned int ctrl_idx = (er->channel >> 4) & 0x0f;
568 struct peak_usb_device *dev = usb_if->dev[ctrl_idx];
569 struct net_device *netdev = dev->netdev;
570 struct can_frame *can_frame;
571 enum can_state new_state = CAN_STATE_ERROR_ACTIVE;
572 u8 err_mask = 0;
573 struct sk_buff *skb;
574 struct timeval tv;
575 struct skb_shared_hwtstamps *hwts;
576
577 /* nothing should be sent while in BUS_OFF state */
578 if (dev->can.state == CAN_STATE_BUS_OFF)
579 return 0;
580
581 if (!raw_status) {
582 /* no error bit (back to active state) */
583 dev->can.state = CAN_STATE_ERROR_ACTIVE;
584 return 0;
585 }
586
587 if (raw_status & (PCAN_USBPRO_STATUS_OVERRUN |
588 PCAN_USBPRO_STATUS_QOVERRUN)) {
589 /* trick to bypass next comparison and process other errors */
590 new_state = CAN_STATE_MAX;
591 }
592
593 if (raw_status & PCAN_USBPRO_STATUS_BUS) {
594 new_state = CAN_STATE_BUS_OFF;
595 } else if (raw_status & PCAN_USBPRO_STATUS_ERROR) {
596 u32 rx_err_cnt = (le32_to_cpu(er->err_frm) & 0x00ff0000) >> 16;
597 u32 tx_err_cnt = (le32_to_cpu(er->err_frm) & 0xff000000) >> 24;
598
599 if (rx_err_cnt > 127)
600 err_mask |= CAN_ERR_CRTL_RX_PASSIVE;
601 else if (rx_err_cnt > 96)
602 err_mask |= CAN_ERR_CRTL_RX_WARNING;
603
604 if (tx_err_cnt > 127)
605 err_mask |= CAN_ERR_CRTL_TX_PASSIVE;
606 else if (tx_err_cnt > 96)
607 err_mask |= CAN_ERR_CRTL_TX_WARNING;
608
609 if (err_mask & (CAN_ERR_CRTL_RX_WARNING |
610 CAN_ERR_CRTL_TX_WARNING))
611 new_state = CAN_STATE_ERROR_WARNING;
612 else if (err_mask & (CAN_ERR_CRTL_RX_PASSIVE |
613 CAN_ERR_CRTL_TX_PASSIVE))
614 new_state = CAN_STATE_ERROR_PASSIVE;
615 }
616
617 /* donot post any error if current state didn't change */
618 if (dev->can.state == new_state)
619 return 0;
620
621 /* allocate an skb to store the error frame */
622 skb = alloc_can_err_skb(netdev, &can_frame);
623 if (!skb)
624 return -ENOMEM;
625
626 switch (new_state) {
627 case CAN_STATE_BUS_OFF:
628 can_frame->can_id |= CAN_ERR_BUSOFF;
629 can_bus_off(netdev);
630 break;
631
632 case CAN_STATE_ERROR_PASSIVE:
633 can_frame->can_id |= CAN_ERR_CRTL;
634 can_frame->data[1] |= err_mask;
635 dev->can.can_stats.error_passive++;
636 break;
637
638 case CAN_STATE_ERROR_WARNING:
639 can_frame->can_id |= CAN_ERR_CRTL;
640 can_frame->data[1] |= err_mask;
641 dev->can.can_stats.error_warning++;
642 break;
643
644 case CAN_STATE_ERROR_ACTIVE:
645 break;
646
647 default:
648 /* CAN_STATE_MAX (trick to handle other errors) */
649 if (raw_status & PCAN_USBPRO_STATUS_OVERRUN) {
650 can_frame->can_id |= CAN_ERR_PROT;
651 can_frame->data[2] |= CAN_ERR_PROT_OVERLOAD;
652 netdev->stats.rx_over_errors++;
653 netdev->stats.rx_errors++;
654 }
655
656 if (raw_status & PCAN_USBPRO_STATUS_QOVERRUN) {
657 can_frame->can_id |= CAN_ERR_CRTL;
658 can_frame->data[1] |= CAN_ERR_CRTL_RX_OVERFLOW;
659 netdev->stats.rx_over_errors++;
660 netdev->stats.rx_errors++;
661 }
662
663 new_state = CAN_STATE_ERROR_ACTIVE;
664 break;
665 }
666
667 dev->can.state = new_state;
668
669 peak_usb_get_ts_tv(&usb_if->time_ref, le32_to_cpu(er->ts32), &tv);
670 hwts = skb_hwtstamps(skb);
671 hwts->hwtstamp = timeval_to_ktime(tv);
672 netif_rx(skb);
673 netdev->stats.rx_packets++;
674 netdev->stats.rx_bytes += can_frame->can_dlc;
675
676 return 0;
677}
678
679static void pcan_usb_pro_handle_ts(struct pcan_usb_pro_interface *usb_if,
680 struct pcan_usb_pro_rxts *ts)
681{
682 /* should wait until clock is stabilized */
683 if (usb_if->cm_ignore_count > 0)
684 usb_if->cm_ignore_count--;
685 else
686 peak_usb_set_ts_now(&usb_if->time_ref,
687 le32_to_cpu(ts->ts64[1]));
688}
689
690/*
691 * callback for bulk IN urb
692 */
693static int pcan_usb_pro_decode_buf(struct peak_usb_device *dev, struct urb *urb)
694{
695 struct pcan_usb_pro_interface *usb_if = pcan_usb_pro_dev_if(dev);
696 struct net_device *netdev = dev->netdev;
697 struct pcan_usb_pro_msg usb_msg;
698 u8 *rec_ptr, *msg_end;
699 u16 rec_cnt;
700 int err = 0;
701
702 rec_ptr = pcan_msg_init(&usb_msg, urb->transfer_buffer,
703 urb->actual_length);
704 if (!rec_ptr) {
705 netdev_err(netdev, "bad msg hdr len %d\n", urb->actual_length);
706 return -EINVAL;
707 }
708
709 /* loop reading all the records from the incoming message */
710 msg_end = urb->transfer_buffer + urb->actual_length;
711 rec_cnt = le16_to_cpu(*usb_msg.u.rec_cnt_rd);
712 for (; rec_cnt > 0; rec_cnt--) {
713 union pcan_usb_pro_rec *pr = (union pcan_usb_pro_rec *)rec_ptr;
714 u16 sizeof_rec = pcan_usb_pro_sizeof_rec[pr->data_type];
715
716 if (!sizeof_rec) {
717 netdev_err(netdev,
718 "got unsupported rec in usb msg:\n");
719 err = -ENOTSUPP;
720 break;
721 }
722
723 /* check if the record goes out of current packet */
724 if (rec_ptr + sizeof_rec > msg_end) {
725 netdev_err(netdev,
726 "got frag rec: should inc usb rx buf size\n");
727 err = -EBADMSG;
728 break;
729 }
730
731 switch (pr->data_type) {
732 case PCAN_USBPRO_RXMSG8:
733 case PCAN_USBPRO_RXMSG4:
734 case PCAN_USBPRO_RXMSG0:
735 case PCAN_USBPRO_RXRTR:
736 err = pcan_usb_pro_handle_canmsg(usb_if, &pr->rx_msg);
737 if (err < 0)
738 goto fail;
739 break;
740
741 case PCAN_USBPRO_RXSTATUS:
742 err = pcan_usb_pro_handle_error(usb_if, &pr->rx_status);
743 if (err < 0)
744 goto fail;
745 break;
746
747 case PCAN_USBPRO_RXTS:
748 pcan_usb_pro_handle_ts(usb_if, &pr->rx_ts);
749 break;
750
751 default:
752 netdev_err(netdev,
753 "unhandled rec type 0x%02x (%d): ignored\n",
754 pr->data_type, pr->data_type);
755 break;
756 }
757
758 rec_ptr += sizeof_rec;
759 }
760
761fail:
762 if (err)
763 pcan_dump_mem("received msg",
764 urb->transfer_buffer, urb->actual_length);
765
766 return err;
767}
768
769static int pcan_usb_pro_encode_msg(struct peak_usb_device *dev,
770 struct sk_buff *skb, u8 *obuf, size_t *size)
771{
772 struct can_frame *cf = (struct can_frame *)skb->data;
773 u8 data_type, len, flags;
774 struct pcan_usb_pro_msg usb_msg;
775
776 pcan_msg_init_empty(&usb_msg, obuf, *size);
777
778 if ((cf->can_id & CAN_RTR_FLAG) || (cf->can_dlc == 0))
779 data_type = PCAN_USBPRO_TXMSG0;
780 else if (cf->can_dlc <= 4)
781 data_type = PCAN_USBPRO_TXMSG4;
782 else
783 data_type = PCAN_USBPRO_TXMSG8;
784
785 len = (dev->ctrl_idx << 4) | (cf->can_dlc & 0x0f);
786
787 flags = 0;
788 if (cf->can_id & CAN_EFF_FLAG)
789 flags |= 0x02;
790 if (cf->can_id & CAN_RTR_FLAG)
791 flags |= 0x01;
792
793 pcan_msg_add_rec(&usb_msg, data_type, 0, flags, len, cf->can_id,
794 cf->data);
795
796 *size = usb_msg.rec_buffer_len;
797
798 return 0;
799}
800
801static int pcan_usb_pro_start(struct peak_usb_device *dev)
802{
803 struct pcan_usb_pro_device *pdev =
804 container_of(dev, struct pcan_usb_pro_device, dev);
805 int err;
806
807 err = pcan_usb_pro_set_silent(dev,
808 dev->can.ctrlmode & CAN_CTRLMODE_LISTENONLY);
809 if (err)
810 return err;
811
812 /* filter mode: 0-> All OFF; 1->bypass */
813 err = pcan_usb_pro_set_filter(dev, 1);
814 if (err)
815 return err;
816
817 /* opening first device: */
818 if (pdev->usb_if->dev_opened_count == 0) {
819 /* reset time_ref */
820 peak_usb_init_time_ref(&pdev->usb_if->time_ref, &pcan_usb_pro);
821
822 /* ask device to send ts messages */
823 err = pcan_usb_pro_set_ts(dev, 1);
824 }
825
826 pdev->usb_if->dev_opened_count++;
827
828 return err;
829}
830
831/*
832 * stop interface
833 * (last chance before set bus off)
834 */
835static int pcan_usb_pro_stop(struct peak_usb_device *dev)
836{
837 struct pcan_usb_pro_device *pdev =
838 container_of(dev, struct pcan_usb_pro_device, dev);
839
840 /* turn off ts msgs for that interface if no other dev opened */
841 if (pdev->usb_if->dev_opened_count == 1)
842 pcan_usb_pro_set_ts(dev, 0);
843
844 pdev->usb_if->dev_opened_count--;
845
846 return 0;
847}
848
849/*
850 * called when probing to initialize a device object.
851 */
852static int pcan_usb_pro_init(struct peak_usb_device *dev)
853{
854 struct pcan_usb_pro_interface *usb_if;
855 struct pcan_usb_pro_device *pdev =
856 container_of(dev, struct pcan_usb_pro_device, dev);
857
858 /* do this for 1st channel only */
859 if (!dev->prev_siblings) {
860 struct pcan_usb_pro_fwinfo fi;
861 struct pcan_usb_pro_blinfo bi;
862 int err;
863
864 /* allocate netdevices common structure attached to first one */
865 usb_if = kzalloc(sizeof(struct pcan_usb_pro_interface),
866 GFP_KERNEL);
867 if (!usb_if)
868 return -ENOMEM;
869
870 /* number of ts msgs to ignore before taking one into account */
871 usb_if->cm_ignore_count = 5;
872
873 /*
874 * explicit use of dev_xxx() instead of netdev_xxx() here:
875 * information displayed are related to the device itself, not
876 * to the canx netdevices.
877 */
878 err = pcan_usb_pro_send_req(dev, PCAN_USBPRO_REQ_INFO,
879 PCAN_USBPRO_INFO_FW,
880 &fi, sizeof(fi));
881 if (err) {
882 kfree(usb_if);
883 dev_err(dev->netdev->dev.parent,
884 "unable to read %s firmware info (err %d)\n",
885 pcan_usb_pro.name, err);
886 return err;
887 }
888
889 err = pcan_usb_pro_send_req(dev, PCAN_USBPRO_REQ_INFO,
890 PCAN_USBPRO_INFO_BL,
891 &bi, sizeof(bi));
892 if (err) {
893 kfree(usb_if);
894 dev_err(dev->netdev->dev.parent,
895 "unable to read %s bootloader info (err %d)\n",
896 pcan_usb_pro.name, err);
897 return err;
898 }
899
900 dev_info(dev->netdev->dev.parent,
901 "PEAK-System %s hwrev %u serial %08X.%08X (%u channels)\n",
902 pcan_usb_pro.name,
903 bi.hw_rev, bi.serial_num_hi, bi.serial_num_lo,
904 pcan_usb_pro.ctrl_count);
905
906 /* tell the device the can driver is running */
907 pcan_usb_pro_drv_loaded(dev, 1);
908 } else {
909 usb_if = pcan_usb_pro_dev_if(dev->prev_siblings);
910 }
911
912 pdev->usb_if = usb_if;
913 usb_if->dev[dev->ctrl_idx] = dev;
914
915 /* set LED in default state (end of init phase) */
916 pcan_usb_pro_set_led(dev, 0, 1);
917
918 return 0;
919}
920
921static void pcan_usb_pro_exit(struct peak_usb_device *dev)
922{
923 struct pcan_usb_pro_device *pdev =
924 container_of(dev, struct pcan_usb_pro_device, dev);
925
926 /*
927 * when rmmod called before unplug and if down, should reset things
928 * before leaving
929 */
930 if (dev->can.state != CAN_STATE_STOPPED) {
931 /* set bus off on the corresponding channel */
932 pcan_usb_pro_set_bus(dev, 0);
933 }
934
935 /* if channel #0 (only) */
936 if (dev->ctrl_idx == 0) {
937 /* turn off calibration message if any device were opened */
938 if (pdev->usb_if->dev_opened_count > 0)
939 pcan_usb_pro_set_ts(dev, 0);
940
941 /* tell the PCAN-USB Pro device the driver is being unloaded */
942 pcan_usb_pro_drv_loaded(dev, 0);
943 }
944}
945
946/*
947 * called when PCAN-USB Pro adapter is unplugged
948 */
949static void pcan_usb_pro_free(struct peak_usb_device *dev)
950{
951 /* last device: can free pcan_usb_pro_interface object now */
952 if (!dev->prev_siblings && !dev->next_siblings)
953 kfree(pcan_usb_pro_dev_if(dev));
954}
955
956/*
957 * probe function for new PCAN-USB Pro usb interface
958 */
959static int pcan_usb_pro_probe(struct usb_interface *intf)
960{
961 struct usb_host_interface *if_desc;
962 int i;
963
964 if_desc = intf->altsetting;
965
966 /* check interface endpoint addresses */
967 for (i = 0; i < if_desc->desc.bNumEndpoints; i++) {
968 struct usb_endpoint_descriptor *ep = &if_desc->endpoint[i].desc;
969
970 /*
971 * below is the list of valid ep addreses. Any other ep address
972 * is considered as not-CAN interface address => no dev created
973 */
974 switch (ep->bEndpointAddress) {
975 case PCAN_USBPRO_EP_CMDOUT:
976 case PCAN_USBPRO_EP_CMDIN:
977 case PCAN_USBPRO_EP_MSGOUT_0:
978 case PCAN_USBPRO_EP_MSGOUT_1:
979 case PCAN_USBPRO_EP_MSGIN:
980 case PCAN_USBPRO_EP_UNUSED:
981 break;
982 default:
983 return -ENODEV;
984 }
985 }
986
987 return 0;
988}
989
990/*
991 * describe the PCAN-USB Pro adapter
992 */
993struct peak_usb_adapter pcan_usb_pro = {
994 .name = "PCAN-USB Pro",
995 .device_id = PCAN_USBPRO_PRODUCT_ID,
996 .ctrl_count = PCAN_USBPRO_CHANNEL_COUNT,
997 .clock = {
998 .freq = PCAN_USBPRO_CRYSTAL_HZ,
999 },
1000 .bittiming_const = {
1001 .name = "pcan_usb_pro",
1002 .tseg1_min = 1,
1003 .tseg1_max = 16,
1004 .tseg2_min = 1,
1005 .tseg2_max = 8,
1006 .sjw_max = 4,
1007 .brp_min = 1,
1008 .brp_max = 1024,
1009 .brp_inc = 1,
1010 },
1011
1012 /* size of device private data */
1013 .sizeof_dev_private = sizeof(struct pcan_usb_pro_device),
1014
1015 /* timestamps usage */
1016 .ts_used_bits = 32,
1017 .ts_period = 1000000, /* calibration period in ts. */
1018 .us_per_ts_scale = 1, /* us = (ts * scale) >> shift */
1019 .us_per_ts_shift = 0,
1020
1021 /* give here messages in/out endpoints */
1022 .ep_msg_in = PCAN_USBPRO_EP_MSGIN,
1023 .ep_msg_out = {PCAN_USBPRO_EP_MSGOUT_0, PCAN_USBPRO_EP_MSGOUT_1},
1024
1025 /* size of rx/tx usb buffers */
1026 .rx_buffer_size = PCAN_USBPRO_RX_BUFFER_SIZE,
1027 .tx_buffer_size = PCAN_USBPRO_TX_BUFFER_SIZE,
1028
1029 /* device callbacks */
1030 .intf_probe = pcan_usb_pro_probe,
1031 .dev_init = pcan_usb_pro_init,
1032 .dev_exit = pcan_usb_pro_exit,
1033 .dev_free = pcan_usb_pro_free,
1034 .dev_set_bus = pcan_usb_pro_set_bus,
1035 .dev_set_bittiming = pcan_usb_pro_set_bittiming,
1036 .dev_get_device_id = pcan_usb_pro_get_device_id,
1037 .dev_decode_buf = pcan_usb_pro_decode_buf,
1038 .dev_encode_msg = pcan_usb_pro_encode_msg,
1039 .dev_start = pcan_usb_pro_start,
1040 .dev_stop = pcan_usb_pro_stop,
1041 .dev_restart_async = pcan_usb_pro_restart_async,
1042};
diff --git a/drivers/net/can/usb/peak_usb/pcan_usb_pro.h b/drivers/net/can/usb/peak_usb/pcan_usb_pro.h
deleted file mode 100644
index a869918c562..00000000000
--- a/drivers/net/can/usb/peak_usb/pcan_usb_pro.h
+++ /dev/null
@@ -1,178 +0,0 @@
1/*
2 * CAN driver for PEAK System PCAN-USB Pro adapter
3 * Derived from the PCAN project file driver/src/pcan_usbpro_fw.h
4 *
5 * Copyright (C) 2003-2011 PEAK System-Technik GmbH
6 * Copyright (C) 2011-2012 Stephane Grosjean <s.grosjean@peak-system.com>
7 *
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published
10 * by the Free Software Foundation; version 2 of the License.
11 *
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
16 */
17#ifndef PCAN_USB_PRO_H
18#define PCAN_USB_PRO_H
19
20/*
21 * USB Vendor request data types
22 */
23#define PCAN_USBPRO_REQ_INFO 0
24#define PCAN_USBPRO_REQ_FCT 2
25
26/* Vendor Request value for XXX_INFO */
27#define PCAN_USBPRO_INFO_BL 0
28#define PCAN_USBPRO_INFO_FW 1
29
30/* Vendor Request value for XXX_FCT */
31#define PCAN_USBPRO_FCT_DRVLD 5 /* tell device driver is loaded */
32
33/* PCAN_USBPRO_INFO_BL vendor request record type */
34struct __packed pcan_usb_pro_blinfo {
35 u32 ctrl_type;
36 u8 version[4];
37 u8 day;
38 u8 month;
39 u8 year;
40 u8 dummy;
41 u32 serial_num_hi;
42 u32 serial_num_lo;
43 u32 hw_type;
44 u32 hw_rev;
45};
46
47/* PCAN_USBPRO_INFO_FW vendor request record type */
48struct __packed pcan_usb_pro_fwinfo {
49 u32 ctrl_type;
50 u8 version[4];
51 u8 day;
52 u8 month;
53 u8 year;
54 u8 dummy;
55 u32 fw_type;
56};
57
58/*
59 * USB Command record types
60 */
61#define PCAN_USBPRO_SETBTR 0x02
62#define PCAN_USBPRO_SETBUSACT 0x04
63#define PCAN_USBPRO_SETSILENT 0x05
64#define PCAN_USBPRO_SETFILTR 0x0a
65#define PCAN_USBPRO_SETTS 0x10
66#define PCAN_USBPRO_GETDEVID 0x12
67#define PCAN_USBPRO_SETLED 0x1C
68#define PCAN_USBPRO_RXMSG8 0x80
69#define PCAN_USBPRO_RXMSG4 0x81
70#define PCAN_USBPRO_RXMSG0 0x82
71#define PCAN_USBPRO_RXRTR 0x83
72#define PCAN_USBPRO_RXSTATUS 0x84
73#define PCAN_USBPRO_RXTS 0x85
74#define PCAN_USBPRO_TXMSG8 0x41
75#define PCAN_USBPRO_TXMSG4 0x42
76#define PCAN_USBPRO_TXMSG0 0x43
77
78/* record structures */
79struct __packed pcan_usb_pro_btr {
80 u8 data_type;
81 u8 channel;
82 u16 dummy;
83 u32 CCBT;
84};
85
86struct __packed pcan_usb_pro_busact {
87 u8 data_type;
88 u8 channel;
89 u16 onoff;
90};
91
92struct __packed pcan_usb_pro_silent {
93 u8 data_type;
94 u8 channel;
95 u16 onoff;
96};
97
98struct __packed pcan_usb_pro_filter {
99 u8 data_type;
100 u8 dummy;
101 u16 filter_mode;
102};
103
104struct __packed pcan_usb_pro_setts {
105 u8 data_type;
106 u8 dummy;
107 u16 mode;
108};
109
110struct __packed pcan_usb_pro_devid {
111 u8 data_type;
112 u8 channel;
113 u16 dummy;
114 u32 serial_num;
115};
116
117struct __packed pcan_usb_pro_setled {
118 u8 data_type;
119 u8 channel;
120 u16 mode;
121 u32 timeout;
122};
123
124struct __packed pcan_usb_pro_rxmsg {
125 u8 data_type;
126 u8 client;
127 u8 flags;
128 u8 len;
129 u32 ts32;
130 u32 id;
131
132 u8 data[8];
133};
134
135#define PCAN_USBPRO_STATUS_ERROR 0x0001
136#define PCAN_USBPRO_STATUS_BUS 0x0002
137#define PCAN_USBPRO_STATUS_OVERRUN 0x0004
138#define PCAN_USBPRO_STATUS_QOVERRUN 0x0008
139
140struct __packed pcan_usb_pro_rxstatus {
141 u8 data_type;
142 u8 channel;
143 u16 status;
144 u32 ts32;
145 u32 err_frm;
146};
147
148struct __packed pcan_usb_pro_rxts {
149 u8 data_type;
150 u8 dummy[3];
151 u32 ts64[2];
152};
153
154struct __packed pcan_usb_pro_txmsg {
155 u8 data_type;
156 u8 client;
157 u8 flags;
158 u8 len;
159 u32 id;
160 u8 data[8];
161};
162
163union pcan_usb_pro_rec {
164 u8 data_type;
165 struct pcan_usb_pro_btr btr;
166 struct pcan_usb_pro_busact bus_act;
167 struct pcan_usb_pro_silent silent_mode;
168 struct pcan_usb_pro_filter filter_mode;
169 struct pcan_usb_pro_setts ts;
170 struct pcan_usb_pro_devid dev_id;
171 struct pcan_usb_pro_setled set_led;
172 struct pcan_usb_pro_rxmsg rx_msg;
173 struct pcan_usb_pro_rxstatus rx_status;
174 struct pcan_usb_pro_rxts rx_ts;
175 struct pcan_usb_pro_txmsg tx_msg;
176};
177
178#endif
diff --git a/drivers/net/can/vcan.c b/drivers/net/can/vcan.c
index 0a2a5ee79a1..a30b8f480f6 100644
--- a/drivers/net/can/vcan.c
+++ b/drivers/net/can/vcan.c
@@ -37,6 +37,8 @@
37 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH 37 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
38 * DAMAGE. 38 * DAMAGE.
39 * 39 *
40 * Send feedback to <socketcan-users@lists.berlios.de>
41 *
40 */ 42 */
41 43
42#include <linux/module.h> 44#include <linux/module.h>
@@ -49,7 +51,7 @@
49#include <linux/slab.h> 51#include <linux/slab.h>
50#include <net/rtnetlink.h> 52#include <net/rtnetlink.h>
51 53
52static __initconst const char banner[] = 54static __initdata const char banner[] =
53 KERN_INFO "vcan: Virtual CAN interface driver\n"; 55 KERN_INFO "vcan: Virtual CAN interface driver\n";
54 56
55MODULE_DESCRIPTION("virtual CAN interface"); 57MODULE_DESCRIPTION("virtual CAN interface");
@@ -63,19 +65,20 @@ MODULE_AUTHOR("Urs Thuermann <urs.thuermann@volkswagen.de>");
63 * See Documentation/networking/can.txt for details. 65 * See Documentation/networking/can.txt for details.
64 */ 66 */
65 67
66static bool echo; /* echo testing. Default: 0 (Off) */ 68static int echo; /* echo testing. Default: 0 (Off) */
67module_param(echo, bool, S_IRUGO); 69module_param(echo, bool, S_IRUGO);
68MODULE_PARM_DESC(echo, "Echo sent frames (for testing). Default: 0 (Off)"); 70MODULE_PARM_DESC(echo, "Echo sent frames (for testing). Default: 0 (Off)");
69 71
70 72
71static void vcan_rx(struct sk_buff *skb, struct net_device *dev) 73static void vcan_rx(struct sk_buff *skb, struct net_device *dev)
72{ 74{
73 struct canfd_frame *cfd = (struct canfd_frame *)skb->data; 75 struct can_frame *cf = (struct can_frame *)skb->data;
74 struct net_device_stats *stats = &dev->stats; 76 struct net_device_stats *stats = &dev->stats;
75 77
76 stats->rx_packets++; 78 stats->rx_packets++;
77 stats->rx_bytes += cfd->len; 79 stats->rx_bytes += cf->can_dlc;
78 80
81 skb->protocol = htons(ETH_P_CAN);
79 skb->pkt_type = PACKET_BROADCAST; 82 skb->pkt_type = PACKET_BROADCAST;
80 skb->dev = dev; 83 skb->dev = dev;
81 skb->ip_summed = CHECKSUM_UNNECESSARY; 84 skb->ip_summed = CHECKSUM_UNNECESSARY;
@@ -85,7 +88,7 @@ static void vcan_rx(struct sk_buff *skb, struct net_device *dev)
85 88
86static netdev_tx_t vcan_tx(struct sk_buff *skb, struct net_device *dev) 89static netdev_tx_t vcan_tx(struct sk_buff *skb, struct net_device *dev)
87{ 90{
88 struct canfd_frame *cfd = (struct canfd_frame *)skb->data; 91 struct can_frame *cf = (struct can_frame *)skb->data;
89 struct net_device_stats *stats = &dev->stats; 92 struct net_device_stats *stats = &dev->stats;
90 int loop; 93 int loop;
91 94
@@ -93,7 +96,7 @@ static netdev_tx_t vcan_tx(struct sk_buff *skb, struct net_device *dev)
93 return NETDEV_TX_OK; 96 return NETDEV_TX_OK;
94 97
95 stats->tx_packets++; 98 stats->tx_packets++;
96 stats->tx_bytes += cfd->len; 99 stats->tx_bytes += cf->can_dlc;
97 100
98 /* set flag whether this packet has to be looped back */ 101 /* set flag whether this packet has to be looped back */
99 loop = skb->pkt_type == PACKET_LOOPBACK; 102 loop = skb->pkt_type == PACKET_LOOPBACK;
@@ -107,7 +110,7 @@ static netdev_tx_t vcan_tx(struct sk_buff *skb, struct net_device *dev)
107 * CAN core already did the echo for us 110 * CAN core already did the echo for us
108 */ 111 */
109 stats->rx_packets++; 112 stats->rx_packets++;
110 stats->rx_bytes += cfd->len; 113 stats->rx_bytes += cf->can_dlc;
111 } 114 }
112 kfree_skb(skb); 115 kfree_skb(skb);
113 return NETDEV_TX_OK; 116 return NETDEV_TX_OK;
@@ -132,28 +135,14 @@ static netdev_tx_t vcan_tx(struct sk_buff *skb, struct net_device *dev)
132 return NETDEV_TX_OK; 135 return NETDEV_TX_OK;
133} 136}
134 137
135static int vcan_change_mtu(struct net_device *dev, int new_mtu)
136{
137 /* Do not allow changing the MTU while running */
138 if (dev->flags & IFF_UP)
139 return -EBUSY;
140
141 if (new_mtu != CAN_MTU && new_mtu != CANFD_MTU)
142 return -EINVAL;
143
144 dev->mtu = new_mtu;
145 return 0;
146}
147
148static const struct net_device_ops vcan_netdev_ops = { 138static const struct net_device_ops vcan_netdev_ops = {
149 .ndo_start_xmit = vcan_tx, 139 .ndo_start_xmit = vcan_tx,
150 .ndo_change_mtu = vcan_change_mtu,
151}; 140};
152 141
153static void vcan_setup(struct net_device *dev) 142static void vcan_setup(struct net_device *dev)
154{ 143{
155 dev->type = ARPHRD_CAN; 144 dev->type = ARPHRD_CAN;
156 dev->mtu = CAN_MTU; 145 dev->mtu = sizeof(struct can_frame);
157 dev->hard_header_len = 0; 146 dev->hard_header_len = 0;
158 dev->addr_len = 0; 147 dev->addr_len = 0;
159 dev->tx_queue_len = 0; 148 dev->tx_queue_len = 0;
generated by cgit v1.2.2 (git 2.25.0) at 2024-10-22 19:19:03 -0400