1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * Copyright (C) 2008-2010 |
4 | * |
5 | * - Kurt Van Dijck, EIA Electronics |
6 | */ |
7 | |
8 | #include <linux/ethtool.h> |
9 | #include <linux/module.h> |
10 | #include <linux/interrupt.h> |
11 | #include <asm/io.h> |
12 | |
13 | #include "softing.h" |
14 | |
15 | #define TX_ECHO_SKB_MAX (((TXMAX+1)/2)-1) |
16 | |
17 | /* |
18 | * test is a specific CAN netdev |
19 | * is online (ie. up 'n running, not sleeping, not busoff |
20 | */ |
21 | static inline int canif_is_active(struct net_device *netdev) |
22 | { |
23 | struct can_priv *can = netdev_priv(dev: netdev); |
24 | |
25 | if (!netif_running(dev: netdev)) |
26 | return 0; |
27 | return (can->state <= CAN_STATE_ERROR_PASSIVE); |
28 | } |
29 | |
30 | /* reset DPRAM */ |
31 | static inline void softing_set_reset_dpram(struct softing *card) |
32 | { |
33 | if (card->pdat->generation >= 2) { |
34 | spin_lock_bh(lock: &card->spin); |
35 | iowrite8(ioread8(&card->dpram[DPRAM_V2_RESET]) & ~1, |
36 | &card->dpram[DPRAM_V2_RESET]); |
37 | spin_unlock_bh(lock: &card->spin); |
38 | } |
39 | } |
40 | |
41 | static inline void softing_clr_reset_dpram(struct softing *card) |
42 | { |
43 | if (card->pdat->generation >= 2) { |
44 | spin_lock_bh(lock: &card->spin); |
45 | iowrite8(ioread8(&card->dpram[DPRAM_V2_RESET]) | 1, |
46 | &card->dpram[DPRAM_V2_RESET]); |
47 | spin_unlock_bh(lock: &card->spin); |
48 | } |
49 | } |
50 | |
51 | /* trigger the tx queue-ing */ |
52 | static netdev_tx_t softing_netdev_start_xmit(struct sk_buff *skb, |
53 | struct net_device *dev) |
54 | { |
55 | struct softing_priv *priv = netdev_priv(dev); |
56 | struct softing *card = priv->card; |
57 | int ret; |
58 | uint8_t *ptr; |
59 | uint8_t fifo_wr, fifo_rd; |
60 | struct can_frame *cf = (struct can_frame *)skb->data; |
61 | uint8_t buf[DPRAM_TX_SIZE]; |
62 | |
63 | if (can_dev_dropped_skb(dev, skb)) |
64 | return NETDEV_TX_OK; |
65 | |
66 | spin_lock(lock: &card->spin); |
67 | |
68 | ret = NETDEV_TX_BUSY; |
69 | if (!card->fw.up || |
70 | (card->tx.pending >= TXMAX) || |
71 | (priv->tx.pending >= TX_ECHO_SKB_MAX)) |
72 | goto xmit_done; |
73 | fifo_wr = ioread8(&card->dpram[DPRAM_TX_WR]); |
74 | fifo_rd = ioread8(&card->dpram[DPRAM_TX_RD]); |
75 | if (fifo_wr == fifo_rd) |
76 | /* fifo full */ |
77 | goto xmit_done; |
78 | memset(buf, 0, sizeof(buf)); |
79 | ptr = buf; |
80 | *ptr = CMD_TX; |
81 | if (cf->can_id & CAN_RTR_FLAG) |
82 | *ptr |= CMD_RTR; |
83 | if (cf->can_id & CAN_EFF_FLAG) |
84 | *ptr |= CMD_XTD; |
85 | if (priv->index) |
86 | *ptr |= CMD_BUS2; |
87 | ++ptr; |
88 | *ptr++ = cf->len; |
89 | *ptr++ = (cf->can_id >> 0); |
90 | *ptr++ = (cf->can_id >> 8); |
91 | if (cf->can_id & CAN_EFF_FLAG) { |
92 | *ptr++ = (cf->can_id >> 16); |
93 | *ptr++ = (cf->can_id >> 24); |
94 | } else { |
95 | /* increment 1, not 2 as you might think */ |
96 | ptr += 1; |
97 | } |
98 | if (!(cf->can_id & CAN_RTR_FLAG)) |
99 | memcpy(ptr, &cf->data[0], cf->len); |
100 | memcpy_toio(&card->dpram[DPRAM_TX + DPRAM_TX_SIZE * fifo_wr], |
101 | buf, DPRAM_TX_SIZE); |
102 | if (++fifo_wr >= DPRAM_TX_CNT) |
103 | fifo_wr = 0; |
104 | iowrite8(fifo_wr, &card->dpram[DPRAM_TX_WR]); |
105 | card->tx.last_bus = priv->index; |
106 | ++card->tx.pending; |
107 | ++priv->tx.pending; |
108 | can_put_echo_skb(skb, dev, idx: priv->tx.echo_put, frame_len: 0); |
109 | ++priv->tx.echo_put; |
110 | if (priv->tx.echo_put >= TX_ECHO_SKB_MAX) |
111 | priv->tx.echo_put = 0; |
112 | /* can_put_echo_skb() saves the skb, safe to return TX_OK */ |
113 | ret = NETDEV_TX_OK; |
114 | xmit_done: |
115 | spin_unlock(lock: &card->spin); |
116 | if (card->tx.pending >= TXMAX) { |
117 | int j; |
118 | for (j = 0; j < ARRAY_SIZE(card->net); ++j) { |
119 | if (card->net[j]) |
120 | netif_stop_queue(dev: card->net[j]); |
121 | } |
122 | } |
123 | if (ret != NETDEV_TX_OK) |
124 | netif_stop_queue(dev); |
125 | |
126 | return ret; |
127 | } |
128 | |
129 | /* |
130 | * shortcut for skb delivery |
131 | */ |
132 | int softing_netdev_rx(struct net_device *netdev, const struct can_frame *msg, |
133 | ktime_t ktime) |
134 | { |
135 | struct sk_buff *skb; |
136 | struct can_frame *cf; |
137 | |
138 | skb = alloc_can_skb(dev: netdev, cf: &cf); |
139 | if (!skb) |
140 | return -ENOMEM; |
141 | memcpy(cf, msg, sizeof(*msg)); |
142 | skb->tstamp = ktime; |
143 | return netif_rx(skb); |
144 | } |
145 | |
146 | /* |
147 | * softing_handle_1 |
148 | * pop 1 entry from the DPRAM queue, and process |
149 | */ |
150 | static int softing_handle_1(struct softing *card) |
151 | { |
152 | struct net_device *netdev; |
153 | struct softing_priv *priv; |
154 | ktime_t ktime; |
155 | struct can_frame msg; |
156 | int cnt = 0, lost_msg; |
157 | uint8_t fifo_rd, fifo_wr, cmd; |
158 | uint8_t *ptr; |
159 | uint32_t tmp_u32; |
160 | uint8_t buf[DPRAM_RX_SIZE]; |
161 | |
162 | memset(&msg, 0, sizeof(msg)); |
163 | /* test for lost msgs */ |
164 | lost_msg = ioread8(&card->dpram[DPRAM_RX_LOST]); |
165 | if (lost_msg) { |
166 | int j; |
167 | /* reset condition */ |
168 | iowrite8(0, &card->dpram[DPRAM_RX_LOST]); |
169 | /* prepare msg */ |
170 | msg.can_id = CAN_ERR_FLAG | CAN_ERR_CRTL; |
171 | msg.len = CAN_ERR_DLC; |
172 | msg.data[1] = CAN_ERR_CRTL_RX_OVERFLOW; |
173 | /* |
174 | * service to all buses, we don't know which it was applicable |
175 | * but only service buses that are online |
176 | */ |
177 | for (j = 0; j < ARRAY_SIZE(card->net); ++j) { |
178 | netdev = card->net[j]; |
179 | if (!netdev) |
180 | continue; |
181 | if (!canif_is_active(netdev)) |
182 | /* a dead bus has no overflows */ |
183 | continue; |
184 | ++netdev->stats.rx_over_errors; |
185 | softing_netdev_rx(netdev, msg: &msg, ktime: 0); |
186 | } |
187 | /* prepare for other use */ |
188 | memset(&msg, 0, sizeof(msg)); |
189 | ++cnt; |
190 | } |
191 | |
192 | fifo_rd = ioread8(&card->dpram[DPRAM_RX_RD]); |
193 | fifo_wr = ioread8(&card->dpram[DPRAM_RX_WR]); |
194 | |
195 | if (++fifo_rd >= DPRAM_RX_CNT) |
196 | fifo_rd = 0; |
197 | if (fifo_wr == fifo_rd) |
198 | return cnt; |
199 | |
200 | memcpy_fromio(buf, &card->dpram[DPRAM_RX + DPRAM_RX_SIZE*fifo_rd], |
201 | DPRAM_RX_SIZE); |
202 | mb(); |
203 | /* trigger dual port RAM */ |
204 | iowrite8(fifo_rd, &card->dpram[DPRAM_RX_RD]); |
205 | |
206 | ptr = buf; |
207 | cmd = *ptr++; |
208 | if (cmd == 0xff) |
209 | /* not quite useful, probably the card has got out */ |
210 | return 0; |
211 | netdev = card->net[0]; |
212 | if (cmd & CMD_BUS2) |
213 | netdev = card->net[1]; |
214 | priv = netdev_priv(dev: netdev); |
215 | |
216 | if (cmd & CMD_ERR) { |
217 | uint8_t can_state, state; |
218 | |
219 | state = *ptr++; |
220 | |
221 | msg.can_id = CAN_ERR_FLAG; |
222 | msg.len = CAN_ERR_DLC; |
223 | |
224 | if (state & SF_MASK_BUSOFF) { |
225 | can_state = CAN_STATE_BUS_OFF; |
226 | msg.can_id |= CAN_ERR_BUSOFF; |
227 | state = STATE_BUSOFF; |
228 | } else if (state & SF_MASK_EPASSIVE) { |
229 | can_state = CAN_STATE_ERROR_PASSIVE; |
230 | msg.can_id |= CAN_ERR_CRTL; |
231 | msg.data[1] = CAN_ERR_CRTL_TX_PASSIVE; |
232 | state = STATE_EPASSIVE; |
233 | } else { |
234 | can_state = CAN_STATE_ERROR_ACTIVE; |
235 | msg.can_id |= CAN_ERR_CRTL; |
236 | state = STATE_EACTIVE; |
237 | } |
238 | /* update DPRAM */ |
239 | iowrite8(state, &card->dpram[priv->index ? |
240 | DPRAM_INFO_BUSSTATE2 : DPRAM_INFO_BUSSTATE]); |
241 | /* timestamp */ |
242 | tmp_u32 = le32_to_cpup(p: (void *)ptr); |
243 | ktime = softing_raw2ktime(card, raw: tmp_u32); |
244 | |
245 | ++netdev->stats.rx_errors; |
246 | /* update internal status */ |
247 | if (can_state != priv->can.state) { |
248 | priv->can.state = can_state; |
249 | if (can_state == CAN_STATE_ERROR_PASSIVE) |
250 | ++priv->can.can_stats.error_passive; |
251 | else if (can_state == CAN_STATE_BUS_OFF) { |
252 | /* this calls can_close_cleanup() */ |
253 | ++priv->can.can_stats.bus_off; |
254 | can_bus_off(dev: netdev); |
255 | netif_stop_queue(dev: netdev); |
256 | } |
257 | /* trigger socketcan */ |
258 | softing_netdev_rx(netdev, msg: &msg, ktime); |
259 | } |
260 | |
261 | } else { |
262 | if (cmd & CMD_RTR) |
263 | msg.can_id |= CAN_RTR_FLAG; |
264 | msg.len = can_cc_dlc2len(*ptr++); |
265 | if (cmd & CMD_XTD) { |
266 | msg.can_id |= CAN_EFF_FLAG; |
267 | msg.can_id |= le32_to_cpup(p: (void *)ptr); |
268 | ptr += 4; |
269 | } else { |
270 | msg.can_id |= le16_to_cpup(p: (void *)ptr); |
271 | ptr += 2; |
272 | } |
273 | /* timestamp */ |
274 | tmp_u32 = le32_to_cpup(p: (void *)ptr); |
275 | ptr += 4; |
276 | ktime = softing_raw2ktime(card, raw: tmp_u32); |
277 | if (!(msg.can_id & CAN_RTR_FLAG)) |
278 | memcpy(&msg.data[0], ptr, 8); |
279 | /* update socket */ |
280 | if (cmd & CMD_ACK) { |
281 | /* acknowledge, was tx msg */ |
282 | struct sk_buff *skb; |
283 | skb = priv->can.echo_skb[priv->tx.echo_get]; |
284 | if (skb) |
285 | skb->tstamp = ktime; |
286 | ++netdev->stats.tx_packets; |
287 | netdev->stats.tx_bytes += |
288 | can_get_echo_skb(dev: netdev, idx: priv->tx.echo_get, |
289 | NULL); |
290 | ++priv->tx.echo_get; |
291 | if (priv->tx.echo_get >= TX_ECHO_SKB_MAX) |
292 | priv->tx.echo_get = 0; |
293 | if (priv->tx.pending) |
294 | --priv->tx.pending; |
295 | if (card->tx.pending) |
296 | --card->tx.pending; |
297 | } else { |
298 | int ret; |
299 | |
300 | ret = softing_netdev_rx(netdev, msg: &msg, ktime); |
301 | if (ret == NET_RX_SUCCESS) { |
302 | ++netdev->stats.rx_packets; |
303 | if (!(msg.can_id & CAN_RTR_FLAG)) |
304 | netdev->stats.rx_bytes += msg.len; |
305 | } else { |
306 | ++netdev->stats.rx_dropped; |
307 | } |
308 | } |
309 | } |
310 | ++cnt; |
311 | return cnt; |
312 | } |
313 | |
314 | /* |
315 | * real interrupt handler |
316 | */ |
317 | static irqreturn_t softing_irq_thread(int irq, void *dev_id) |
318 | { |
319 | struct softing *card = (struct softing *)dev_id; |
320 | struct net_device *netdev; |
321 | struct softing_priv *priv; |
322 | int j, offset, work_done; |
323 | |
324 | work_done = 0; |
325 | spin_lock_bh(lock: &card->spin); |
326 | while (softing_handle_1(card) > 0) { |
327 | ++card->irq.svc_count; |
328 | ++work_done; |
329 | } |
330 | spin_unlock_bh(lock: &card->spin); |
331 | /* resume tx queue's */ |
332 | offset = card->tx.last_bus; |
333 | for (j = 0; j < ARRAY_SIZE(card->net); ++j) { |
334 | if (card->tx.pending >= TXMAX) |
335 | break; |
336 | netdev = card->net[(j + offset + 1) % card->pdat->nbus]; |
337 | if (!netdev) |
338 | continue; |
339 | priv = netdev_priv(dev: netdev); |
340 | if (!canif_is_active(netdev)) |
341 | /* it makes no sense to wake dead buses */ |
342 | continue; |
343 | if (priv->tx.pending >= TX_ECHO_SKB_MAX) |
344 | continue; |
345 | ++work_done; |
346 | netif_wake_queue(dev: netdev); |
347 | } |
348 | return work_done ? IRQ_HANDLED : IRQ_NONE; |
349 | } |
350 | |
351 | /* |
352 | * interrupt routines: |
353 | * schedule the 'real interrupt handler' |
354 | */ |
355 | static irqreturn_t softing_irq_v2(int irq, void *dev_id) |
356 | { |
357 | struct softing *card = (struct softing *)dev_id; |
358 | uint8_t ir; |
359 | |
360 | ir = ioread8(&card->dpram[DPRAM_V2_IRQ_TOHOST]); |
361 | iowrite8(0, &card->dpram[DPRAM_V2_IRQ_TOHOST]); |
362 | return (1 == ir) ? IRQ_WAKE_THREAD : IRQ_NONE; |
363 | } |
364 | |
365 | static irqreturn_t softing_irq_v1(int irq, void *dev_id) |
366 | { |
367 | struct softing *card = (struct softing *)dev_id; |
368 | uint8_t ir; |
369 | |
370 | ir = ioread8(&card->dpram[DPRAM_IRQ_TOHOST]); |
371 | iowrite8(0, &card->dpram[DPRAM_IRQ_TOHOST]); |
372 | return ir ? IRQ_WAKE_THREAD : IRQ_NONE; |
373 | } |
374 | |
375 | /* |
376 | * netdev/candev interoperability |
377 | */ |
378 | static int softing_netdev_open(struct net_device *ndev) |
379 | { |
380 | int ret; |
381 | |
382 | /* check or determine and set bittime */ |
383 | ret = open_candev(dev: ndev); |
384 | if (ret) |
385 | return ret; |
386 | |
387 | ret = softing_startstop(netdev: ndev, up: 1); |
388 | if (ret < 0) |
389 | close_candev(dev: ndev); |
390 | |
391 | return ret; |
392 | } |
393 | |
394 | static int softing_netdev_stop(struct net_device *ndev) |
395 | { |
396 | netif_stop_queue(dev: ndev); |
397 | |
398 | /* softing cycle does close_candev() */ |
399 | return softing_startstop(netdev: ndev, up: 0); |
400 | } |
401 | |
402 | static int softing_candev_set_mode(struct net_device *ndev, enum can_mode mode) |
403 | { |
404 | int ret; |
405 | |
406 | switch (mode) { |
407 | case CAN_MODE_START: |
408 | /* softing_startstop does close_candev() */ |
409 | ret = softing_startstop(netdev: ndev, up: 1); |
410 | return ret; |
411 | case CAN_MODE_STOP: |
412 | case CAN_MODE_SLEEP: |
413 | return -EOPNOTSUPP; |
414 | } |
415 | return 0; |
416 | } |
417 | |
418 | /* |
419 | * Softing device management helpers |
420 | */ |
421 | int softing_enable_irq(struct softing *card, int enable) |
422 | { |
423 | int ret; |
424 | |
425 | if (!card->irq.nr) { |
426 | return 0; |
427 | } else if (card->irq.requested && !enable) { |
428 | free_irq(card->irq.nr, card); |
429 | card->irq.requested = 0; |
430 | } else if (!card->irq.requested && enable) { |
431 | ret = request_threaded_irq(irq: card->irq.nr, |
432 | handler: (card->pdat->generation >= 2) ? |
433 | softing_irq_v2 : softing_irq_v1, |
434 | thread_fn: softing_irq_thread, IRQF_SHARED, |
435 | name: dev_name(dev: &card->pdev->dev), dev: card); |
436 | if (ret) { |
437 | dev_alert(&card->pdev->dev, |
438 | "request_threaded_irq(%u) failed\n" , |
439 | card->irq.nr); |
440 | return ret; |
441 | } |
442 | card->irq.requested = 1; |
443 | } |
444 | return 0; |
445 | } |
446 | |
447 | static void softing_card_shutdown(struct softing *card) |
448 | { |
449 | int fw_up = 0; |
450 | |
451 | if (mutex_lock_interruptible(&card->fw.lock)) { |
452 | /* return -ERESTARTSYS */; |
453 | } |
454 | fw_up = card->fw.up; |
455 | card->fw.up = 0; |
456 | |
457 | if (card->irq.requested && card->irq.nr) { |
458 | free_irq(card->irq.nr, card); |
459 | card->irq.requested = 0; |
460 | } |
461 | if (fw_up) { |
462 | if (card->pdat->enable_irq) |
463 | card->pdat->enable_irq(card->pdev, 0); |
464 | softing_set_reset_dpram(card); |
465 | if (card->pdat->reset) |
466 | card->pdat->reset(card->pdev, 1); |
467 | } |
468 | mutex_unlock(lock: &card->fw.lock); |
469 | } |
470 | |
471 | static int softing_card_boot(struct softing *card) |
472 | { |
473 | int ret, j; |
474 | static const uint8_t stream[] = { |
475 | 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, }; |
476 | unsigned char back[sizeof(stream)]; |
477 | |
478 | if (mutex_lock_interruptible(&card->fw.lock)) |
479 | return -ERESTARTSYS; |
480 | if (card->fw.up) { |
481 | mutex_unlock(lock: &card->fw.lock); |
482 | return 0; |
483 | } |
484 | /* reset board */ |
485 | if (card->pdat->enable_irq) |
486 | card->pdat->enable_irq(card->pdev, 1); |
487 | /* boot card */ |
488 | softing_set_reset_dpram(card); |
489 | if (card->pdat->reset) |
490 | card->pdat->reset(card->pdev, 1); |
491 | for (j = 0; (j + sizeof(stream)) < card->dpram_size; |
492 | j += sizeof(stream)) { |
493 | |
494 | memcpy_toio(&card->dpram[j], stream, sizeof(stream)); |
495 | /* flush IO cache */ |
496 | mb(); |
497 | memcpy_fromio(back, &card->dpram[j], sizeof(stream)); |
498 | |
499 | if (!memcmp(p: back, q: stream, size: sizeof(stream))) |
500 | continue; |
501 | /* memory is not equal */ |
502 | dev_alert(&card->pdev->dev, "dpram failed at 0x%04x\n" , j); |
503 | ret = -EIO; |
504 | goto failed; |
505 | } |
506 | wmb(); |
507 | /* load boot firmware */ |
508 | ret = softing_load_fw(file: card->pdat->boot.fw, card, virt: card->dpram, |
509 | size: card->dpram_size, |
510 | offset: card->pdat->boot.offs - card->pdat->boot.addr); |
511 | if (ret < 0) |
512 | goto failed; |
513 | /* load loader firmware */ |
514 | ret = softing_load_fw(file: card->pdat->load.fw, card, virt: card->dpram, |
515 | size: card->dpram_size, |
516 | offset: card->pdat->load.offs - card->pdat->load.addr); |
517 | if (ret < 0) |
518 | goto failed; |
519 | |
520 | if (card->pdat->reset) |
521 | card->pdat->reset(card->pdev, 0); |
522 | softing_clr_reset_dpram(card); |
523 | ret = softing_bootloader_command(card, cmd: 0, msg: "card boot" ); |
524 | if (ret < 0) |
525 | goto failed; |
526 | ret = softing_load_app_fw(file: card->pdat->app.fw, card); |
527 | if (ret < 0) |
528 | goto failed; |
529 | |
530 | ret = softing_chip_poweron(card); |
531 | if (ret < 0) |
532 | goto failed; |
533 | |
534 | card->fw.up = 1; |
535 | mutex_unlock(lock: &card->fw.lock); |
536 | return 0; |
537 | failed: |
538 | card->fw.up = 0; |
539 | if (card->pdat->enable_irq) |
540 | card->pdat->enable_irq(card->pdev, 0); |
541 | softing_set_reset_dpram(card); |
542 | if (card->pdat->reset) |
543 | card->pdat->reset(card->pdev, 1); |
544 | mutex_unlock(lock: &card->fw.lock); |
545 | return ret; |
546 | } |
547 | |
548 | /* |
549 | * netdev sysfs |
550 | */ |
551 | static ssize_t show_chip(struct device *dev, struct device_attribute *attr, |
552 | char *buf) |
553 | { |
554 | struct net_device *ndev = to_net_dev(dev); |
555 | struct softing_priv *priv = netdev2softing(ndev); |
556 | |
557 | return sprintf(buf, fmt: "%i\n" , priv->chip); |
558 | } |
559 | |
560 | static ssize_t show_output(struct device *dev, struct device_attribute *attr, |
561 | char *buf) |
562 | { |
563 | struct net_device *ndev = to_net_dev(dev); |
564 | struct softing_priv *priv = netdev2softing(ndev); |
565 | |
566 | return sprintf(buf, fmt: "0x%02x\n" , priv->output); |
567 | } |
568 | |
569 | static ssize_t store_output(struct device *dev, struct device_attribute *attr, |
570 | const char *buf, size_t count) |
571 | { |
572 | struct net_device *ndev = to_net_dev(dev); |
573 | struct softing_priv *priv = netdev2softing(ndev); |
574 | struct softing *card = priv->card; |
575 | unsigned long val; |
576 | int ret; |
577 | |
578 | ret = kstrtoul(s: buf, base: 0, res: &val); |
579 | if (ret < 0) |
580 | return ret; |
581 | val &= 0xFF; |
582 | |
583 | ret = mutex_lock_interruptible(&card->fw.lock); |
584 | if (ret) |
585 | return -ERESTARTSYS; |
586 | if (netif_running(dev: ndev)) { |
587 | mutex_unlock(lock: &card->fw.lock); |
588 | return -EBUSY; |
589 | } |
590 | priv->output = val; |
591 | mutex_unlock(lock: &card->fw.lock); |
592 | return count; |
593 | } |
594 | |
595 | static const DEVICE_ATTR(chip, 0444, show_chip, NULL); |
596 | static const DEVICE_ATTR(output, 0644, show_output, store_output); |
597 | |
598 | static const struct attribute *const netdev_sysfs_attrs[] = { |
599 | &dev_attr_chip.attr, |
600 | &dev_attr_output.attr, |
601 | NULL, |
602 | }; |
603 | static const struct attribute_group netdev_sysfs_group = { |
604 | .name = NULL, |
605 | .attrs = (struct attribute **)netdev_sysfs_attrs, |
606 | }; |
607 | |
608 | static const struct net_device_ops softing_netdev_ops = { |
609 | .ndo_open = softing_netdev_open, |
610 | .ndo_stop = softing_netdev_stop, |
611 | .ndo_start_xmit = softing_netdev_start_xmit, |
612 | .ndo_change_mtu = can_change_mtu, |
613 | }; |
614 | |
615 | static const struct ethtool_ops softing_ethtool_ops = { |
616 | .get_ts_info = ethtool_op_get_ts_info, |
617 | }; |
618 | |
619 | static const struct can_bittiming_const softing_btr_const = { |
620 | .name = KBUILD_MODNAME, |
621 | .tseg1_min = 1, |
622 | .tseg1_max = 16, |
623 | .tseg2_min = 1, |
624 | .tseg2_max = 8, |
625 | .sjw_max = 4, /* overruled */ |
626 | .brp_min = 1, |
627 | .brp_max = 32, /* overruled */ |
628 | .brp_inc = 1, |
629 | }; |
630 | |
631 | |
632 | static struct net_device *softing_netdev_create(struct softing *card, |
633 | uint16_t chip_id) |
634 | { |
635 | struct net_device *netdev; |
636 | struct softing_priv *priv; |
637 | |
638 | netdev = alloc_candev(sizeof(*priv), TX_ECHO_SKB_MAX); |
639 | if (!netdev) { |
640 | dev_alert(&card->pdev->dev, "alloc_candev failed\n" ); |
641 | return NULL; |
642 | } |
643 | priv = netdev_priv(dev: netdev); |
644 | priv->netdev = netdev; |
645 | priv->card = card; |
646 | memcpy(&priv->btr_const, &softing_btr_const, sizeof(priv->btr_const)); |
647 | priv->btr_const.brp_max = card->pdat->max_brp; |
648 | priv->btr_const.sjw_max = card->pdat->max_sjw; |
649 | priv->can.bittiming_const = &priv->btr_const; |
650 | priv->can.clock.freq = 8000000; |
651 | priv->chip = chip_id; |
652 | priv->output = softing_default_output(netdev); |
653 | SET_NETDEV_DEV(netdev, &card->pdev->dev); |
654 | |
655 | netdev->flags |= IFF_ECHO; |
656 | netdev->netdev_ops = &softing_netdev_ops; |
657 | netdev->ethtool_ops = &softing_ethtool_ops; |
658 | priv->can.do_set_mode = softing_candev_set_mode; |
659 | priv->can.ctrlmode_supported = CAN_CTRLMODE_3_SAMPLES; |
660 | |
661 | return netdev; |
662 | } |
663 | |
664 | static int softing_netdev_register(struct net_device *netdev) |
665 | { |
666 | int ret; |
667 | |
668 | ret = register_candev(dev: netdev); |
669 | if (ret) { |
670 | dev_alert(&netdev->dev, "register failed\n" ); |
671 | return ret; |
672 | } |
673 | if (sysfs_create_group(kobj: &netdev->dev.kobj, grp: &netdev_sysfs_group) < 0) |
674 | netdev_alert(dev: netdev, format: "sysfs group failed\n" ); |
675 | |
676 | return 0; |
677 | } |
678 | |
679 | static void softing_netdev_cleanup(struct net_device *netdev) |
680 | { |
681 | sysfs_remove_group(kobj: &netdev->dev.kobj, grp: &netdev_sysfs_group); |
682 | unregister_candev(dev: netdev); |
683 | free_candev(dev: netdev); |
684 | } |
685 | |
686 | /* |
687 | * sysfs for Platform device |
688 | */ |
689 | #define DEV_ATTR_RO(name, member) \ |
690 | static ssize_t show_##name(struct device *dev, \ |
691 | struct device_attribute *attr, char *buf) \ |
692 | { \ |
693 | struct softing *card = dev_get_drvdata(dev); \ |
694 | return sprintf(buf, "%u\n", card->member); \ |
695 | } \ |
696 | static DEVICE_ATTR(name, 0444, show_##name, NULL) |
697 | |
698 | #define DEV_ATTR_RO_STR(name, member) \ |
699 | static ssize_t show_##name(struct device *dev, \ |
700 | struct device_attribute *attr, char *buf) \ |
701 | { \ |
702 | struct softing *card = dev_get_drvdata(dev); \ |
703 | return sprintf(buf, "%s\n", card->member); \ |
704 | } \ |
705 | static DEVICE_ATTR(name, 0444, show_##name, NULL) |
706 | |
707 | DEV_ATTR_RO(serial, id.serial); |
708 | DEV_ATTR_RO_STR(firmware, pdat->app.fw); |
709 | DEV_ATTR_RO(firmware_version, id.fw_version); |
710 | DEV_ATTR_RO_STR(hardware, pdat->name); |
711 | DEV_ATTR_RO(hardware_version, id.hw_version); |
712 | DEV_ATTR_RO(license, id.license); |
713 | |
714 | static struct attribute *softing_pdev_attrs[] = { |
715 | &dev_attr_serial.attr, |
716 | &dev_attr_firmware.attr, |
717 | &dev_attr_firmware_version.attr, |
718 | &dev_attr_hardware.attr, |
719 | &dev_attr_hardware_version.attr, |
720 | &dev_attr_license.attr, |
721 | NULL, |
722 | }; |
723 | |
724 | static const struct attribute_group softing_pdev_group = { |
725 | .name = NULL, |
726 | .attrs = softing_pdev_attrs, |
727 | }; |
728 | |
729 | /* |
730 | * platform driver |
731 | */ |
732 | static void softing_pdev_remove(struct platform_device *pdev) |
733 | { |
734 | struct softing *card = platform_get_drvdata(pdev); |
735 | int j; |
736 | |
737 | /* first, disable card*/ |
738 | softing_card_shutdown(card); |
739 | |
740 | for (j = 0; j < ARRAY_SIZE(card->net); ++j) { |
741 | if (!card->net[j]) |
742 | continue; |
743 | softing_netdev_cleanup(netdev: card->net[j]); |
744 | card->net[j] = NULL; |
745 | } |
746 | sysfs_remove_group(kobj: &pdev->dev.kobj, grp: &softing_pdev_group); |
747 | |
748 | iounmap(addr: card->dpram); |
749 | kfree(objp: card); |
750 | } |
751 | |
752 | static int softing_pdev_probe(struct platform_device *pdev) |
753 | { |
754 | const struct softing_platform_data *pdat = dev_get_platdata(dev: &pdev->dev); |
755 | struct softing *card; |
756 | struct net_device *netdev; |
757 | struct softing_priv *priv; |
758 | struct resource *pres; |
759 | int ret; |
760 | int j; |
761 | |
762 | if (!pdat) { |
763 | dev_warn(&pdev->dev, "no platform data\n" ); |
764 | return -EINVAL; |
765 | } |
766 | if (pdat->nbus > ARRAY_SIZE(card->net)) { |
767 | dev_warn(&pdev->dev, "%u nets??\n" , pdat->nbus); |
768 | return -EINVAL; |
769 | } |
770 | |
771 | card = kzalloc(size: sizeof(*card), GFP_KERNEL); |
772 | if (!card) |
773 | return -ENOMEM; |
774 | card->pdat = pdat; |
775 | card->pdev = pdev; |
776 | platform_set_drvdata(pdev, data: card); |
777 | mutex_init(&card->fw.lock); |
778 | spin_lock_init(&card->spin); |
779 | |
780 | ret = -EINVAL; |
781 | pres = platform_get_resource(pdev, IORESOURCE_MEM, 0); |
782 | if (!pres) |
783 | goto platform_resource_failed; |
784 | card->dpram_phys = pres->start; |
785 | card->dpram_size = resource_size(res: pres); |
786 | card->dpram = ioremap(offset: card->dpram_phys, size: card->dpram_size); |
787 | if (!card->dpram) { |
788 | dev_alert(&card->pdev->dev, "dpram ioremap failed\n" ); |
789 | goto ioremap_failed; |
790 | } |
791 | |
792 | pres = platform_get_resource(pdev, IORESOURCE_IRQ, 0); |
793 | if (pres) |
794 | card->irq.nr = pres->start; |
795 | |
796 | /* reset card */ |
797 | ret = softing_card_boot(card); |
798 | if (ret < 0) { |
799 | dev_alert(&pdev->dev, "failed to boot\n" ); |
800 | goto boot_failed; |
801 | } |
802 | |
803 | /* only now, the chip's are known */ |
804 | card->id.freq = card->pdat->freq; |
805 | |
806 | ret = sysfs_create_group(kobj: &pdev->dev.kobj, grp: &softing_pdev_group); |
807 | if (ret < 0) { |
808 | dev_alert(&card->pdev->dev, "sysfs failed\n" ); |
809 | goto sysfs_failed; |
810 | } |
811 | |
812 | for (j = 0; j < ARRAY_SIZE(card->net); ++j) { |
813 | card->net[j] = netdev = |
814 | softing_netdev_create(card, chip_id: card->id.chip[j]); |
815 | if (!netdev) { |
816 | dev_alert(&pdev->dev, "failed to make can[%i]" , j); |
817 | ret = -ENOMEM; |
818 | goto netdev_failed; |
819 | } |
820 | netdev->dev_id = j; |
821 | priv = netdev_priv(dev: card->net[j]); |
822 | priv->index = j; |
823 | ret = softing_netdev_register(netdev); |
824 | if (ret) { |
825 | free_candev(dev: netdev); |
826 | card->net[j] = NULL; |
827 | dev_alert(&card->pdev->dev, |
828 | "failed to register can[%i]\n" , j); |
829 | goto netdev_failed; |
830 | } |
831 | } |
832 | dev_info(&card->pdev->dev, "%s ready.\n" , card->pdat->name); |
833 | return 0; |
834 | |
835 | netdev_failed: |
836 | for (j = 0; j < ARRAY_SIZE(card->net); ++j) { |
837 | if (!card->net[j]) |
838 | continue; |
839 | softing_netdev_cleanup(netdev: card->net[j]); |
840 | } |
841 | sysfs_remove_group(kobj: &pdev->dev.kobj, grp: &softing_pdev_group); |
842 | sysfs_failed: |
843 | softing_card_shutdown(card); |
844 | boot_failed: |
845 | iounmap(addr: card->dpram); |
846 | ioremap_failed: |
847 | platform_resource_failed: |
848 | kfree(objp: card); |
849 | return ret; |
850 | } |
851 | |
852 | static struct platform_driver softing_driver = { |
853 | .driver = { |
854 | .name = KBUILD_MODNAME, |
855 | }, |
856 | .probe = softing_pdev_probe, |
857 | .remove_new = softing_pdev_remove, |
858 | }; |
859 | |
860 | module_platform_driver(softing_driver); |
861 | |
862 | MODULE_ALIAS("platform:softing" ); |
863 | MODULE_DESCRIPTION("Softing DPRAM CAN driver" ); |
864 | MODULE_AUTHOR("Kurt Van Dijck <kurt.van.dijck@eia.be>" ); |
865 | MODULE_LICENSE("GPL v2" ); |
866 | |