2 * Platform CAN bus driver for Bosch C_CAN controller
4 * Copyright (C) 2010 ST Microelectronics
5 * Bhupesh Sharma <bhupesh.sharma@st.com>
7 * Borrowed heavily from the C_CAN driver originally written by:
9 * - Sascha Hauer, Marc Kleine-Budde, Pengutronix <s.hauer@pengutronix.de>
10 * - Simon Kallweit, intefo AG <simon.kallweit@intefo.ch>
12 * Bosch C_CAN controller is compliant to CAN protocol version 2.0 part A and B.
13 * Bosch C_CAN user manual can be obtained from:
14 * http://www.semiconductors.bosch.de/media/en/pdf/ipmodules_1/c_can/
15 * users_manual_c_can.pdf
17 * This file is licensed under the terms of the GNU General Public
18 * License version 2. This program is licensed "as is" without any
19 * warranty of any kind, whether express or implied.
22 #include <linux/kernel.h>
23 #include <linux/module.h>
24 #include <linux/interrupt.h>
25 #include <linux/delay.h>
26 #include <linux/netdevice.h>
27 #include <linux/if_arp.h>
28 #include <linux/if_ether.h>
29 #include <linux/list.h>
31 #include <linux/platform_device.h>
32 #include <linux/clk.h>
34 #include <linux/of_device.h>
35 #include <linux/pinctrl/consumer.h>
37 #include <linux/can/dev.h>
41 #define CAN_RAMINIT_START_MASK(i) (1 << (i))
44 * 16-bit c_can registers can be arranged differently in the memory
45 * architecture of different implementations. For example: 16-bit
46 * registers can be aligned to a 16-bit boundary or 32-bit boundary etc.
47 * Handle the same by providing a common read/write interface.
49 static u16
c_can_plat_read_reg_aligned_to_16bit(struct c_can_priv
*priv
,
52 return readw(priv
->base
+ priv
->regs
[index
]);
55 static void c_can_plat_write_reg_aligned_to_16bit(struct c_can_priv
*priv
,
56 enum reg index
, u16 val
)
58 writew(val
, priv
->base
+ priv
->regs
[index
]);
61 static u16
c_can_plat_read_reg_aligned_to_32bit(struct c_can_priv
*priv
,
64 return readw(priv
->base
+ 2 * priv
->regs
[index
]);
67 static void c_can_plat_write_reg_aligned_to_32bit(struct c_can_priv
*priv
,
68 enum reg index
, u16 val
)
70 writew(val
, priv
->base
+ 2 * priv
->regs
[index
]);
73 static void c_can_hw_raminit(const struct c_can_priv
*priv
, bool enable
)
77 val
= readl(priv
->raminit_ctrlreg
);
79 val
|= CAN_RAMINIT_START_MASK(priv
->instance
);
81 val
&= ~CAN_RAMINIT_START_MASK(priv
->instance
);
82 writel(val
, priv
->raminit_ctrlreg
);
85 static struct platform_device_id c_can_id_table
[] = {
86 [BOSCH_C_CAN_PLATFORM
] = {
87 .name
= KBUILD_MODNAME
,
88 .driver_data
= BOSCH_C_CAN
,
92 .driver_data
= BOSCH_C_CAN
,
96 .driver_data
= BOSCH_D_CAN
,
100 MODULE_DEVICE_TABLE(platform
, c_can_id_table
);
102 static 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
] },
107 MODULE_DEVICE_TABLE(of
, c_can_of_table
);
109 static int c_can_plat_probe(struct platform_device
*pdev
)
113 struct net_device
*dev
;
114 struct c_can_priv
*priv
;
115 const struct of_device_id
*match
;
116 const struct platform_device_id
*id
;
117 struct pinctrl
*pinctrl
;
118 struct resource
*mem
, *res
;
122 if (pdev
->dev
.of_node
) {
123 match
= of_match_device(c_can_of_table
, &pdev
->dev
);
125 dev_err(&pdev
->dev
, "Failed to find matching dt id\n");
131 id
= platform_get_device_id(pdev
);
134 pinctrl
= devm_pinctrl_get_select_default(&pdev
->dev
);
137 "failed to configure pins from driver\n");
139 /* get the appropriate clk */
140 clk
= clk_get(&pdev
->dev
, NULL
);
142 dev_err(&pdev
->dev
, "no clock defined\n");
147 /* get the platform data */
148 mem
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
149 irq
= platform_get_irq(pdev
, 0);
150 if (!mem
|| irq
<= 0) {
155 if (!request_mem_region(mem
->start
, resource_size(mem
),
157 dev_err(&pdev
->dev
, "resource unavailable\n");
162 addr
= ioremap(mem
->start
, resource_size(mem
));
164 dev_err(&pdev
->dev
, "failed to map can port\n");
166 goto exit_release_mem
;
169 /* allocate the c_can device */
170 dev
= alloc_c_can_dev();
176 priv
= netdev_priv(dev
);
177 switch (id
->driver_data
) {
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
;
185 case IORESOURCE_MEM_16BIT
:
187 priv
->read_reg
= c_can_plat_read_reg_aligned_to_16bit
;
188 priv
->write_reg
= c_can_plat_write_reg_aligned_to_16bit
;
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
;
198 if (pdev
->dev
.of_node
)
199 priv
->instance
= of_alias_get_id(pdev
->dev
.of_node
, "d_can");
201 priv
->instance
= pdev
->id
;
203 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 1);
204 priv
->raminit_ctrlreg
= devm_ioremap_resource(&pdev
->dev
, res
);
205 if (IS_ERR(priv
->raminit_ctrlreg
) || priv
->instance
< 0)
206 dev_info(&pdev
->dev
, "control memory is not used for raminit\n");
208 priv
->raminit
= c_can_hw_raminit
;
212 goto exit_free_device
;
217 priv
->device
= &pdev
->dev
;
218 priv
->can
.clock
.freq
= clk_get_rate(clk
);
220 priv
->type
= id
->driver_data
;
222 platform_set_drvdata(pdev
, dev
);
223 SET_NETDEV_DEV(dev
, &pdev
->dev
);
225 ret
= register_c_can_dev(dev
);
227 dev_err(&pdev
->dev
, "registering %s failed (err=%d)\n",
228 KBUILD_MODNAME
, ret
);
229 goto exit_free_device
;
232 dev_info(&pdev
->dev
, "%s device registered (regs=%p, irq=%d)\n",
233 KBUILD_MODNAME
, priv
->base
, dev
->irq
);
241 release_mem_region(mem
->start
, resource_size(mem
));
245 dev_err(&pdev
->dev
, "probe failed\n");
250 static int c_can_plat_remove(struct platform_device
*pdev
)
252 struct net_device
*dev
= platform_get_drvdata(pdev
);
253 struct c_can_priv
*priv
= netdev_priv(dev
);
254 struct resource
*mem
;
256 unregister_c_can_dev(dev
);
261 mem
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
262 release_mem_region(mem
->start
, resource_size(mem
));
270 static int c_can_suspend(struct platform_device
*pdev
, pm_message_t state
)
273 struct net_device
*ndev
= platform_get_drvdata(pdev
);
274 struct c_can_priv
*priv
= netdev_priv(ndev
);
276 if (priv
->type
!= BOSCH_D_CAN
) {
277 dev_warn(&pdev
->dev
, "Not supported\n");
281 if (netif_running(ndev
)) {
282 netif_stop_queue(ndev
);
283 netif_device_detach(ndev
);
286 ret
= c_can_power_down(ndev
);
288 netdev_err(ndev
, "failed to enter power down mode\n");
292 priv
->can
.state
= CAN_STATE_SLEEPING
;
297 static int c_can_resume(struct platform_device
*pdev
)
300 struct net_device
*ndev
= platform_get_drvdata(pdev
);
301 struct c_can_priv
*priv
= netdev_priv(ndev
);
303 if (priv
->type
!= BOSCH_D_CAN
) {
304 dev_warn(&pdev
->dev
, "Not supported\n");
308 ret
= c_can_power_up(ndev
);
310 netdev_err(ndev
, "Still in power down mode\n");
314 priv
->can
.state
= CAN_STATE_ERROR_ACTIVE
;
316 if (netif_running(ndev
)) {
317 netif_device_attach(ndev
);
318 netif_start_queue(ndev
);
324 #define c_can_suspend NULL
325 #define c_can_resume NULL
328 static struct platform_driver c_can_plat_driver
= {
330 .name
= KBUILD_MODNAME
,
331 .owner
= THIS_MODULE
,
332 .of_match_table
= of_match_ptr(c_can_of_table
),
334 .probe
= c_can_plat_probe
,
335 .remove
= c_can_plat_remove
,
336 .suspend
= c_can_suspend
,
337 .resume
= c_can_resume
,
338 .id_table
= c_can_id_table
,
341 module_platform_driver(c_can_plat_driver
);
343 MODULE_AUTHOR("Bhupesh Sharma <bhupesh.sharma@st.com>");
344 MODULE_LICENSE("GPL v2");
345 MODULE_DESCRIPTION("Platform CAN bus driver for Bosch C_CAN controller");