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