1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19#include <linux/module.h>
20#include <linux/interrupt.h>
21#include <asm/io.h>
22
23#include "softing.h"
24
25#define TX_ECHO_SKB_MAX (((TXMAX+1)/2)-1)
26
27
28
29
30
31static 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
41static 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
51static 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
62static 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
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
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
123 ret = NETDEV_TX_OK;
124xmit_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
141
142int 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
158
159
160static 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
174 lost_msg = ioread8(&card->dpram[DPRAM_RX_LOST]);
175 if (lost_msg) {
176 int j;
177
178 iowrite8(0, &card->dpram[DPRAM_RX_LOST]);
179
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
185
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
193 continue;
194 ++netdev->stats.rx_over_errors;
195 softing_netdev_rx(netdev, &msg, ktime_set(0, 0));
196 }
197
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
214 iowrite8(fifo_rd, &card->dpram[DPRAM_RX_RD]);
215
216 ptr = buf;
217 cmd = *ptr++;
218 if (cmd == 0xff)
219
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
249 iowrite8(state, &card->dpram[priv->index ?
250 DPRAM_INFO_BUSSTATE2 : DPRAM_INFO_BUSSTATE]);
251
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
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
264 ++priv->can.can_stats.bus_off;
265 can_bus_off(netdev);
266 netif_stop_queue(netdev);
267 }
268
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
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
292 if (cmd & CMD_ACK) {
293
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
328
329static 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
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
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
365
366
367static 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
377static 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
389
390static int softing_netdev_open(struct net_device *ndev)
391{
392 int ret;
393
394
395 ret = open_candev(ndev);
396 if (!ret)
397 ret = softing_startstop(ndev, 1);
398 return ret;
399}
400
401static int softing_netdev_stop(struct net_device *ndev)
402{
403 int ret;
404
405 netif_stop_queue(ndev);
406
407
408 ret = softing_startstop(ndev, 0);
409 return ret;
410}
411
412static 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
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
430
431int 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
457static void softing_card_shutdown(struct softing *card)
458{
459 int fw_up = 0;
460
461 if (mutex_lock_interruptible(&card->fw.lock))
462 ;
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
480static int softing_card_boot(struct softing *card)
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
494 if (card->pdat->enable_irq)
495 card->pdat->enable_irq(card->pdev, 1);
496
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
505 mb();
506 memcpy_fromio(back, &card->dpram[j], sizeof(stream));
507
508 if (!memcmp(back, stream, sizeof(stream)))
509 continue;
510
511 dev_alert(&card->pdev->dev, "dpram failed at 0x%04x\n", j);
512 ret = -EIO;
513 goto failed;
514 }
515 wmb();
516
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
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;
546failed:
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
559
560static 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
569static 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
578static 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
587 ret = kstrtoul(buf, 0, &val);
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
604static const DEVICE_ATTR(chip, S_IRUGO, show_chip, NULL);
605static const DEVICE_ATTR(output, S_IRUGO | S_IWUSR, show_output, store_output);
606
607static const struct attribute *const netdev_sysfs_attrs[] = {
608 &dev_attr_chip.attr,
609 &dev_attr_output.attr,
610 NULL,
611};
612static const struct attribute_group netdev_sysfs_group = {
613 .name = NULL,
614 .attrs = (struct attribute **)netdev_sysfs_attrs,
615};
616
617static 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,
621 .ndo_change_mtu = can_change_mtu,
622};
623
624static const struct can_bittiming_const softing_btr_const = {
625 .name = "softing",
626 .tseg1_min = 1,
627 .tseg1_max = 16,
628 .tseg2_min = 1,
629 .tseg2_max = 8,
630 .sjw_max = 4,
631 .brp_min = 1,
632 .brp_max = 32,
633 .brp_inc = 1,
634};
635
636
637static struct net_device *softing_netdev_create(struct softing *card,
638 uint16_t chip_id)
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
668static int softing_netdev_register(struct net_device *netdev)
669{
670 int ret;
671
672 ret = register_candev(netdev);
673 if (ret) {
674 dev_alert(&netdev->dev, "register failed\n");
675 return ret;
676 }
677 if (sysfs_create_group(&netdev->dev.kobj, &netdev_sysfs_group) < 0)
678 netdev_alert(netdev, "sysfs group failed\n");
679
680 return 0;
681}
682
683static void softing_netdev_cleanup(struct net_device *netdev)
684{
685 sysfs_remove_group(&netdev->dev.kobj, &netdev_sysfs_group);
686 unregister_candev(netdev);
687 free_candev(netdev);
688}
689
690
691
692
693#define DEV_ATTR_RO(name, member) \
694static 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} \
700static DEVICE_ATTR(name, 0444, show_##name, NULL)
701
702#define DEV_ATTR_RO_STR(name, member) \
703static 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} \
709static DEVICE_ATTR(name, 0444, show_##name, NULL)
710
711DEV_ATTR_RO(serial, id.serial);
712DEV_ATTR_RO_STR(firmware, pdat->app.fw);
713DEV_ATTR_RO(firmware_version, id.fw_version);
714DEV_ATTR_RO_STR(hardware, pdat->name);
715DEV_ATTR_RO(hardware_version, id.hw_version);
716DEV_ATTR_RO(license, id.license);
717
718static 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,
725 NULL,
726};
727
728static const struct attribute_group softing_pdev_group = {
729 .name = NULL,
730 .attrs = softing_pdev_attrs,
731};
732
733
734
735
736static int softing_pdev_remove(struct platform_device *pdev)
737{
738 struct softing *card = platform_get_drvdata(pdev);
739 int j;
740
741
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
757static int softing_pdev_probe(struct platform_device *pdev)
758{
759 const struct softing_platform_data *pdat = dev_get_platdata(&pdev->dev);
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)
788 goto platform_resource_failed;
789 card->dpram_phys = pres->start;
790 card->dpram_size = resource_size(pres);
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
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
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
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);
822 ret = -ENOMEM;
823 goto netdev_failed;
824 }
825 netdev->dev_id = j;
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
840netdev_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);
847sysfs_failed:
848 softing_card_shutdown(card);
849boot_failed:
850 iounmap(card->dpram);
851ioremap_failed:
852platform_resource_failed:
853 kfree(card);
854 return ret;
855}
856
857static struct platform_driver softing_driver = {
858 .driver = {
859 .name = "softing",
860 },
861 .probe = softing_pdev_probe,
862 .remove = softing_pdev_remove,
863};
864
865module_platform_driver(softing_driver);
866
867MODULE_ALIAS("platform:softing");
868MODULE_DESCRIPTION("Softing DPRAM CAN driver");
869MODULE_AUTHOR("Kurt Van Dijck <kurt.van.dijck@eia.be>");
870MODULE_LICENSE("GPL v2");
871
