1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20#include <linux/firmware.h>
21#include <linux/sched.h>
22#include <asm/div64.h>
23#include <asm/io.h>
24
25#include "softing.h"
26
27
28
29
30
31static int _softing_fct_cmd(struct softing *card, int16_t cmd, uint16_t vector,
32 const char *msg)
33{
34 int ret;
35 unsigned long stamp;
36
37 iowrite16(cmd, &card->dpram[DPRAM_FCT_PARAM]);
38 iowrite8(vector >> 8, &card->dpram[DPRAM_FCT_HOST + 1]);
39 iowrite8(vector, &card->dpram[DPRAM_FCT_HOST]);
40
41 wmb();
42 stamp = jiffies + 1 * HZ;
43
44 do {
45
46 ret = ioread8(&card->dpram[DPRAM_FCT_HOST]) +
47 (ioread8(&card->dpram[DPRAM_FCT_HOST + 1]) << 8);
48
49 rmb();
50 if (ret == RES_OK)
51
52 return ioread16(&card->dpram[DPRAM_FCT_RESULT]);
53
54 if ((ret != vector) || time_after(jiffies, stamp))
55 break;
56
57 usleep_range(500, 10000);
58 } while (1);
59
60 ret = (ret == RES_NONE) ? -ETIMEDOUT : -ECANCELED;
61 dev_alert(&card->pdev->dev, "firmware %s failed (%i)\n", msg, ret);
62 return ret;
63}
64
65static int softing_fct_cmd(struct softing *card, int16_t cmd, const char *msg)
66{
67 int ret;
68
69 ret = _softing_fct_cmd(card, cmd, 0, msg);
70 if (ret > 0) {
71 dev_alert(&card->pdev->dev, "%s returned %u\n", msg, ret);
72 ret = -EIO;
73 }
74 return ret;
75}
76
77int softing_bootloader_command(struct softing *card, int16_t cmd,
78 const char *msg)
79{
80 int ret;
81 unsigned long stamp;
82
83 iowrite16(RES_NONE, &card->dpram[DPRAM_RECEIPT]);
84 iowrite16(cmd, &card->dpram[DPRAM_COMMAND]);
85
86 wmb();
87 stamp = jiffies + 3 * HZ;
88
89 do {
90 ret = ioread16(&card->dpram[DPRAM_RECEIPT]);
91
92 rmb();
93 if (ret == RES_OK)
94 return 0;
95 if (time_after(jiffies, stamp))
96 break;
97
98 usleep_range(500, 10000);
99 } while (!signal_pending(current));
100
101 ret = (ret == RES_NONE) ? -ETIMEDOUT : -ECANCELED;
102 dev_alert(&card->pdev->dev, "bootloader %s failed (%i)\n", msg, ret);
103 return ret;
104}
105
106static int fw_parse(const uint8_t **pmem, uint16_t *ptype, uint32_t *paddr,
107 uint16_t *plen, const uint8_t **pdat)
108{
109 uint16_t checksum[2];
110 const uint8_t *mem;
111 const uint8_t *end;
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128 mem = *pmem;
129 *ptype = le16_to_cpup((void *)&mem[0]);
130 *paddr = le32_to_cpup((void *)&mem[2]);
131 *plen = le16_to_cpup((void *)&mem[6]);
132 *pdat = &mem[8];
133
134 end = &mem[8 + *plen];
135 checksum[0] = le16_to_cpup((void *)end);
136 for (checksum[1] = 0; mem < end; ++mem)
137 checksum[1] += *mem;
138 if (checksum[0] != checksum[1])
139 return -EINVAL;
140
141 *pmem += 10 + *plen;
142 return 0;
143}
144
145int softing_load_fw(const char *file, struct softing *card,
146 __iomem uint8_t *dpram, unsigned int size, int offset)
147{
148 const struct firmware *fw;
149 int ret;
150 const uint8_t *mem, *end, *dat;
151 uint16_t type, len;
152 uint32_t addr;
153 uint8_t *buf = NULL, *new_buf;
154 int buflen = 0;
155 int8_t type_end = 0;
156
157 ret = request_firmware(&fw, file, &card->pdev->dev);
158 if (ret < 0)
159 return ret;
160 dev_dbg(&card->pdev->dev, "%s, firmware(%s) got %u bytes"
161 ", offset %c0x%04x\n",
162 card->pdat->name, file, (unsigned int)fw->size,
163 (offset >= 0) ? '+' : '-', (unsigned int)abs(offset));
164
165 mem = fw->data;
166 end = &mem[fw->size];
167
168 ret = fw_parse(&mem, &type, &addr, &len, &dat);
169 if (ret < 0)
170 goto failed;
171 if (type != 0xffff)
172 goto failed;
173 if (strncmp("Structured Binary Format, Softing GmbH" , dat, len)) {
174 ret = -EINVAL;
175 goto failed;
176 }
177
178 while (mem < end) {
179 ret = fw_parse(&mem, &type, &addr, &len, &dat);
180 if (ret < 0)
181 goto failed;
182 if (type == 3) {
183
184 continue;
185 } else if (type == 1) {
186
187 type_end = 1;
188 break;
189 } else if (type != 0) {
190 ret = -EINVAL;
191 goto failed;
192 }
193
194 if ((addr + len + offset) > size)
195 goto failed;
196 memcpy_toio(&dpram[addr + offset], dat, len);
197
198 mb();
199 if (len > buflen) {
200
201 buflen = (len + (1024-1)) & ~(1024-1);
202 new_buf = krealloc(buf, buflen, GFP_KERNEL);
203 if (!new_buf) {
204 ret = -ENOMEM;
205 goto failed;
206 }
207 buf = new_buf;
208 }
209
210 memcpy_fromio(buf, &dpram[addr + offset], len);
211 if (memcmp(buf, dat, len)) {
212
213 dev_alert(&card->pdev->dev, "DPRAM readback failed\n");
214 ret = -EIO;
215 goto failed;
216 }
217 }
218 if (!type_end)
219
220 goto failed;
221 ret = 0;
222failed:
223 kfree(buf);
224 release_firmware(fw);
225 if (ret < 0)
226 dev_info(&card->pdev->dev, "firmware %s failed\n", file);
227 return ret;
228}
229
230int softing_load_app_fw(const char *file, struct softing *card)
231{
232 const struct firmware *fw;
233 const uint8_t *mem, *end, *dat;
234 int ret, j;
235 uint16_t type, len;
236 uint32_t addr, start_addr = 0;
237 unsigned int sum, rx_sum;
238 int8_t type_end = 0, type_entrypoint = 0;
239
240 ret = request_firmware(&fw, file, &card->pdev->dev);
241 if (ret) {
242 dev_alert(&card->pdev->dev, "request_firmware(%s) got %i\n",
243 file, ret);
244 return ret;
245 }
246 dev_dbg(&card->pdev->dev, "firmware(%s) got %lu bytes\n",
247 file, (unsigned long)fw->size);
248
249 mem = fw->data;
250 end = &mem[fw->size];
251
252 ret = fw_parse(&mem, &type, &addr, &len, &dat);
253 if (ret)
254 goto failed;
255 ret = -EINVAL;
256 if (type != 0xffff) {
257 dev_alert(&card->pdev->dev, "firmware starts with type 0x%x\n",
258 type);
259 goto failed;
260 }
261 if (strncmp("Structured Binary Format, Softing GmbH", dat, len)) {
262 dev_alert(&card->pdev->dev, "firmware string '%.*s' fault\n",
263 len, dat);
264 goto failed;
265 }
266
267 while (mem < end) {
268 ret = fw_parse(&mem, &type, &addr, &len, &dat);
269 if (ret)
270 goto failed;
271
272 if (type == 3) {
273
274 start_addr = addr;
275 type_entrypoint = 1;
276 continue;
277 } else if (type == 1) {
278
279 type_end = 1;
280 break;
281 } else if (type != 0) {
282 dev_alert(&card->pdev->dev,
283 "unknown record type 0x%04x\n", type);
284 ret = -EINVAL;
285 goto failed;
286 }
287
288
289 for (sum = 0, j = 0; j < len; ++j)
290 sum += dat[j];
291
292 sum &= 0xffff;
293
294 memcpy_toio(&card->dpram[card->pdat->app.offs], dat, len);
295 iowrite32(card->pdat->app.offs + card->pdat->app.addr,
296 &card->dpram[DPRAM_COMMAND + 2]);
297 iowrite32(addr, &card->dpram[DPRAM_COMMAND + 6]);
298 iowrite16(len, &card->dpram[DPRAM_COMMAND + 10]);
299 iowrite8(1, &card->dpram[DPRAM_COMMAND + 12]);
300 ret = softing_bootloader_command(card, 1, "loading app.");
301 if (ret < 0)
302 goto failed;
303
304 rx_sum = ioread16(&card->dpram[DPRAM_RECEIPT + 2]);
305 if (rx_sum != sum) {
306 dev_alert(&card->pdev->dev, "SRAM seems to be damaged"
307 ", wanted 0x%04x, got 0x%04x\n", sum, rx_sum);
308 ret = -EIO;
309 goto failed;
310 }
311 }
312 if (!type_end || !type_entrypoint)
313 goto failed;
314
315 iowrite32(start_addr, &card->dpram[DPRAM_COMMAND + 2]);
316 iowrite8(1, &card->dpram[DPRAM_COMMAND + 6]);
317 ret = softing_bootloader_command(card, 3, "start app.");
318 if (ret < 0)
319 goto failed;
320 ret = 0;
321failed:
322 release_firmware(fw);
323 if (ret < 0)
324 dev_info(&card->pdev->dev, "firmware %s failed\n", file);
325 return ret;
326}
327
328static int softing_reset_chip(struct softing *card)
329{
330 int ret;
331
332 do {
333
334 iowrite8(0, &card->dpram[DPRAM_RESET_RX_FIFO]);
335 iowrite8(0, &card->dpram[DPRAM_RESET_RX_FIFO+1]);
336 iowrite8(1, &card->dpram[DPRAM_RESET]);
337 iowrite8(0, &card->dpram[DPRAM_RESET+1]);
338
339 ret = softing_fct_cmd(card, 0, "reset_can");
340 if (!ret)
341 break;
342 if (signal_pending(current))
343
344 break;
345 } while (1);
346 card->tx.pending = 0;
347 return ret;
348}
349
350int softing_chip_poweron(struct softing *card)
351{
352 int ret;
353
354 ret = _softing_fct_cmd(card, 99, 0x55, "sync-a");
355 if (ret < 0)
356 goto failed;
357
358 ret = _softing_fct_cmd(card, 99, 0xaa, "sync-b");
359 if (ret < 0)
360 goto failed;
361
362 ret = softing_reset_chip(card);
363 if (ret < 0)
364 goto failed;
365
366 ret = softing_fct_cmd(card, 43, "get_serial_number");
367 if (ret < 0)
368 goto failed;
369 card->id.serial = ioread32(&card->dpram[DPRAM_FCT_PARAM]);
370
371 ret = softing_fct_cmd(card, 12, "get_version");
372 if (ret < 0)
373 goto failed;
374 card->id.fw_version = ioread16(&card->dpram[DPRAM_FCT_PARAM + 2]);
375 card->id.hw_version = ioread16(&card->dpram[DPRAM_FCT_PARAM + 4]);
376 card->id.license = ioread16(&card->dpram[DPRAM_FCT_PARAM + 6]);
377 card->id.chip[0] = ioread16(&card->dpram[DPRAM_FCT_PARAM + 8]);
378 card->id.chip[1] = ioread16(&card->dpram[DPRAM_FCT_PARAM + 10]);
379 return 0;
380failed:
381 return ret;
382}
383
384static void softing_initialize_timestamp(struct softing *card)
385{
386 uint64_t ovf;
387
388 card->ts_ref = ktime_get();
389
390
391 ovf = 0x100000000ULL * 16;
392 do_div(ovf, card->pdat->freq ?: 16);
393
394 card->ts_overflow = ktime_add_us(ktime_set(0, 0), ovf);
395}
396
397ktime_t softing_raw2ktime(struct softing *card, u32 raw)
398{
399 uint64_t rawl;
400 ktime_t now, real_offset;
401 ktime_t target;
402 ktime_t tmp;
403
404 now = ktime_get();
405 real_offset = ktime_sub(ktime_get_real(), now);
406
407
408 rawl = raw * 16;
409 do_div(rawl, card->pdat->freq ?: 16);
410 target = ktime_add_us(card->ts_ref, rawl);
411
412 tmp = ktime_add(target, card->ts_overflow);
413 while (unlikely(ktime_to_ns(tmp) > ktime_to_ns(now))) {
414 card->ts_ref = ktime_add(card->ts_ref, card->ts_overflow);
415 target = tmp;
416 tmp = ktime_add(target, card->ts_overflow);
417 }
418 return ktime_add(target, real_offset);
419}
420
421static inline int softing_error_reporting(struct net_device *netdev)
422{
423 struct softing_priv *priv = netdev_priv(netdev);
424
425 return (priv->can.ctrlmode & CAN_CTRLMODE_BERR_REPORTING)
426 ? 1 : 0;
427}
428
429int softing_startstop(struct net_device *dev, int up)
430{
431 int ret;
432 struct softing *card;
433 struct softing_priv *priv;
434 struct net_device *netdev;
435 int bus_bitmask_start;
436 int j, error_reporting;
437 struct can_frame msg;
438 const struct can_bittiming *bt;
439
440 priv = netdev_priv(dev);
441 card = priv->card;
442
443 if (!card->fw.up)
444 return -EIO;
445
446 ret = mutex_lock_interruptible(&card->fw.lock);
447 if (ret)
448 return ret;
449
450 bus_bitmask_start = 0;
451 if (dev && up)
452
453 bus_bitmask_start |= (1 << priv->index);
454
455 for (j = 0; j < ARRAY_SIZE(card->net); ++j) {
456 netdev = card->net[j];
457 if (!netdev)
458 continue;
459 priv = netdev_priv(netdev);
460
461 if (dev != netdev)
462 netif_stop_queue(netdev);
463
464 if (netif_running(netdev)) {
465 if (dev != netdev)
466 bus_bitmask_start |= (1 << j);
467 priv->tx.pending = 0;
468 priv->tx.echo_put = 0;
469 priv->tx.echo_get = 0;
470
471
472
473
474
475
476
477
478 close_candev(netdev);
479 }
480 priv->can.state = CAN_STATE_STOPPED;
481 }
482 card->tx.pending = 0;
483
484 softing_enable_irq(card, 0);
485 ret = softing_reset_chip(card);
486 if (ret)
487 goto failed;
488 if (!bus_bitmask_start)
489
490 goto card_done;
491
492 if ((bus_bitmask_start & 1) && (bus_bitmask_start & 2)
493 && (softing_error_reporting(card->net[0])
494 != softing_error_reporting(card->net[1]))) {
495 dev_alert(&card->pdev->dev,
496 "err_reporting flag differs for busses\n");
497 goto invalid;
498 }
499 error_reporting = 0;
500 if (bus_bitmask_start & 1) {
501 netdev = card->net[0];
502 priv = netdev_priv(netdev);
503 error_reporting += softing_error_reporting(netdev);
504
505 bt = &priv->can.bittiming;
506 iowrite16(bt->brp, &card->dpram[DPRAM_FCT_PARAM + 2]);
507 iowrite16(bt->sjw, &card->dpram[DPRAM_FCT_PARAM + 4]);
508 iowrite16(bt->phase_seg1 + bt->prop_seg,
509 &card->dpram[DPRAM_FCT_PARAM + 6]);
510 iowrite16(bt->phase_seg2, &card->dpram[DPRAM_FCT_PARAM + 8]);
511 iowrite16((priv->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES) ? 1 : 0,
512 &card->dpram[DPRAM_FCT_PARAM + 10]);
513 ret = softing_fct_cmd(card, 1, "initialize_chip[0]");
514 if (ret < 0)
515 goto failed;
516
517 iowrite16(0, &card->dpram[DPRAM_FCT_PARAM + 2]);
518 iowrite16(0, &card->dpram[DPRAM_FCT_PARAM + 4]);
519 ret = softing_fct_cmd(card, 3, "set_mode[0]");
520 if (ret < 0)
521 goto failed;
522
523
524 iowrite16(0x0000, &card->dpram[DPRAM_FCT_PARAM + 2]);
525 iowrite16(0x07ff, &card->dpram[DPRAM_FCT_PARAM + 4]);
526
527 iowrite16(0x0000, &card->dpram[DPRAM_FCT_PARAM + 6]);
528 iowrite16(0xffff, &card->dpram[DPRAM_FCT_PARAM + 8]);
529 iowrite16(0x0000, &card->dpram[DPRAM_FCT_PARAM + 10]);
530 iowrite16(0x1fff, &card->dpram[DPRAM_FCT_PARAM + 12]);
531 ret = softing_fct_cmd(card, 7, "set_filter[0]");
532 if (ret < 0)
533 goto failed;
534
535 iowrite16(priv->output, &card->dpram[DPRAM_FCT_PARAM + 2]);
536 ret = softing_fct_cmd(card, 5, "set_output[0]");
537 if (ret < 0)
538 goto failed;
539 }
540 if (bus_bitmask_start & 2) {
541 netdev = card->net[1];
542 priv = netdev_priv(netdev);
543 error_reporting += softing_error_reporting(netdev);
544
545 bt = &priv->can.bittiming;
546 iowrite16(bt->brp, &card->dpram[DPRAM_FCT_PARAM + 2]);
547 iowrite16(bt->sjw, &card->dpram[DPRAM_FCT_PARAM + 4]);
548 iowrite16(bt->phase_seg1 + bt->prop_seg,
549 &card->dpram[DPRAM_FCT_PARAM + 6]);
550 iowrite16(bt->phase_seg2, &card->dpram[DPRAM_FCT_PARAM + 8]);
551 iowrite16((priv->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES) ? 1 : 0,
552 &card->dpram[DPRAM_FCT_PARAM + 10]);
553 ret = softing_fct_cmd(card, 2, "initialize_chip[1]");
554 if (ret < 0)
555 goto failed;
556
557 iowrite16(0, &card->dpram[DPRAM_FCT_PARAM + 2]);
558 iowrite16(0, &card->dpram[DPRAM_FCT_PARAM + 4]);
559 ret = softing_fct_cmd(card, 4, "set_mode[1]");
560 if (ret < 0)
561 goto failed;
562
563
564 iowrite16(0x0000, &card->dpram[DPRAM_FCT_PARAM + 2]);
565 iowrite16(0x07ff, &card->dpram[DPRAM_FCT_PARAM + 4]);
566
567 iowrite16(0x0000, &card->dpram[DPRAM_FCT_PARAM + 6]);
568 iowrite16(0xffff, &card->dpram[DPRAM_FCT_PARAM + 8]);
569 iowrite16(0x0000, &card->dpram[DPRAM_FCT_PARAM + 10]);
570 iowrite16(0x1fff, &card->dpram[DPRAM_FCT_PARAM + 12]);
571 ret = softing_fct_cmd(card, 8, "set_filter[1]");
572 if (ret < 0)
573 goto failed;
574
575 iowrite16(priv->output, &card->dpram[DPRAM_FCT_PARAM + 2]);
576 ret = softing_fct_cmd(card, 6, "set_output[1]");
577 if (ret < 0)
578 goto failed;
579 }
580
581
582
583
584
585
586
587
588
589
590
591
592
593 iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 2]);
594 iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 4]);
595 iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 6]);
596 iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 8]);
597 iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 10]);
598 iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 12]);
599 iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 14]);
600 iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 16]);
601 iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 18]);
602 iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 20]);
603 ret = softing_fct_cmd(card, 17, "initialize_interface");
604 if (ret < 0)
605 goto failed;
606
607 ret = softing_fct_cmd(card, 36, "enable_fifo");
608 if (ret < 0)
609 goto failed;
610
611 ret = softing_fct_cmd(card, 13, "fifo_tx_ack[0]");
612 if (ret < 0)
613 goto failed;
614
615 ret = softing_fct_cmd(card, 14, "fifo_tx_ack[1]");
616 if (ret < 0)
617 goto failed;
618
619 ret = softing_fct_cmd(card, 11, "start_chip");
620 if (ret < 0)
621 goto failed;
622 iowrite8(0, &card->dpram[DPRAM_INFO_BUSSTATE]);
623 iowrite8(0, &card->dpram[DPRAM_INFO_BUSSTATE2]);
624 if (card->pdat->generation < 2) {
625 iowrite8(0, &card->dpram[DPRAM_V2_IRQ_TOHOST]);
626
627 wmb();
628 }
629
630 softing_initialize_timestamp(card);
631
632
633
634
635
636
637 memset(&msg, 0, sizeof(msg));
638 msg.can_id = CAN_ERR_FLAG | CAN_ERR_RESTARTED;
639 msg.can_dlc = CAN_ERR_DLC;
640 for (j = 0; j < ARRAY_SIZE(card->net); ++j) {
641 if (!(bus_bitmask_start & (1 << j)))
642 continue;
643 netdev = card->net[j];
644 if (!netdev)
645 continue;
646 priv = netdev_priv(netdev);
647 priv->can.state = CAN_STATE_ERROR_ACTIVE;
648 open_candev(netdev);
649 if (dev != netdev) {
650
651 softing_netdev_rx(netdev, &msg, ktime_set(0, 0));
652 ++priv->can.can_stats.restarts;
653 }
654 netif_wake_queue(netdev);
655 }
656
657
658 ret = softing_enable_irq(card, 1);
659 if (ret)
660 goto failed;
661card_done:
662 mutex_unlock(&card->fw.lock);
663 return 0;
664invalid:
665 ret = -EINVAL;
666failed:
667 softing_enable_irq(card, 0);
668 softing_reset_chip(card);
669 mutex_unlock(&card->fw.lock);
670
671 for (j = 0; j < ARRAY_SIZE(card->net); ++j) {
672 netdev = card->net[j];
673 if (!netdev)
674 continue;
675 dev_close(netdev);
676 }
677 return ret;
678}
679
680int softing_default_output(struct net_device *netdev)
681{
682 struct softing_priv *priv = netdev_priv(netdev);
683 struct softing *card = priv->card;
684
685 switch (priv->chip) {
686 case 1000:
687 return (card->pdat->generation < 2) ? 0xfb : 0xfa;
688 case 5:
689 return 0x60;
690 default:
691 return 0x40;
692 }
693}
694