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