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 */
_softing_fct_cmd(struct softing * card,int16_t cmd,uint16_t vector,const char * msg)19 static 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
softing_fct_cmd(struct softing * card,int16_t cmd,const char * msg)53 static 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
softing_bootloader_command(struct softing * card,int16_t cmd,const char * msg)65 int 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
fw_parse(const u8 ** pmem,const u8 * limit,u16 * ptype,u32 * paddr,u16 * plen,const u8 ** pdat)94 static int fw_parse(const u8 **pmem, const u8 *limit, u16 *ptype,
95 u32 *paddr, u16 *plen, const u8 **pdat)
96 {
97 uint16_t checksum[2];
98 const u8 *mem;
99 const u8 *record_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 /* A record needs an 8-byte prefix and a 2-byte checksum. */
118 if (mem > limit || limit - mem < 10)
119 return -EINVAL;
120
121 *ptype = le16_to_cpup((void *)&mem[0]);
122 *paddr = le32_to_cpup((void *)&mem[2]);
123 *plen = le16_to_cpup((void *)&mem[6]);
124 if (*plen > limit - mem - 10)
125 return -EINVAL;
126
127 *pdat = &mem[8];
128 /* verify checksum */
129 record_end = &mem[8 + *plen];
130 checksum[0] = le16_to_cpup((void *)record_end);
131 for (checksum[1] = 0; mem < record_end; ++mem)
132 checksum[1] += *mem;
133 if (checksum[0] != checksum[1])
134 return -EINVAL;
135 /* increment */
136 *pmem += 10 + *plen;
137 return 0;
138 }
139
softing_load_fw(const char * file,struct softing * card,__iomem uint8_t * dpram,unsigned int size,int offset)140 int softing_load_fw(const char *file, struct softing *card,
141 __iomem uint8_t *dpram, unsigned int size, int offset)
142 {
143 const struct firmware *fw;
144 int ret;
145 const uint8_t *mem, *end, *dat;
146 uint16_t type, len;
147 uint32_t addr;
148 uint8_t *buf = NULL, *new_buf;
149 s64 dpram_offset;
150 int buflen = 0;
151 int8_t type_end = 0;
152
153 ret = request_firmware(&fw, file, &card->pdev->dev);
154 if (ret < 0)
155 return ret;
156 dev_dbg(&card->pdev->dev, "%s, firmware(%s) got %u bytes"
157 ", offset %c0x%04x\n",
158 card->pdat->name, file, (unsigned int)fw->size,
159 (offset >= 0) ? '+' : '-', (unsigned int)abs(offset));
160 /* parse the firmware */
161 mem = fw->data;
162 end = &mem[fw->size];
163 /* look for header record */
164 ret = fw_parse(&mem, end, &type, &addr, &len, &dat);
165 if (ret < 0)
166 goto failed;
167 if (type != 0xffff)
168 goto failed;
169 if (strncmp("Structured Binary Format, Softing GmbH" , dat, len)) {
170 ret = -EINVAL;
171 goto failed;
172 }
173 /* ok, we had a header */
174 while (mem < end) {
175 ret = fw_parse(&mem, end, &type, &addr, &len, &dat);
176 if (ret < 0)
177 goto failed;
178 if (type == 3) {
179 /* start address, not used here */
180 continue;
181 } else if (type == 1) {
182 /* eof */
183 type_end = 1;
184 break;
185 } else if (type != 0) {
186 ret = -EINVAL;
187 goto failed;
188 }
189
190 dpram_offset = (s64)addr + offset;
191 if (dpram_offset < 0 || dpram_offset > size ||
192 len > size - dpram_offset) {
193 ret = -EINVAL;
194 goto failed;
195 }
196 memcpy_toio(&dpram[dpram_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 new_buf = krealloc(buf, buflen, GFP_KERNEL);
203 if (!new_buf) {
204 ret = -ENOMEM;
205 goto failed;
206 }
207 buf = new_buf;
208 }
209 /* verify record data */
210 memcpy_fromio(buf, &dpram[dpram_offset], len);
211 if (memcmp(buf, dat, len)) {
212 /* is not ok */
213 dev_alert(&card->pdev->dev, "DPRAM readback failed\n");
214 ret = -EIO;
215 goto failed;
216 }
217 }
218 if (!type_end)
219 /* no end record seen */
220 goto failed;
221 ret = 0;
222 failed:
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
softing_load_app_fw(const char * file,struct softing * card)230 int 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 /* parse the firmware */
249 mem = fw->data;
250 end = &mem[fw->size];
251 /* look for header record */
252 ret = fw_parse(&mem, end, &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 /* ok, we had a header */
267 while (mem < end) {
268 ret = fw_parse(&mem, end, &type, &addr, &len, &dat);
269 if (ret)
270 goto failed;
271
272 if (type == 3) {
273 /* start address */
274 start_addr = addr;
275 type_entrypoint = 1;
276 continue;
277 } else if (type == 1) {
278 /* eof */
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 /* regular data */
289 for (sum = 0, j = 0; j < len; ++j)
290 sum += dat[j];
291 /* work in 16bit (target) */
292 sum &= 0xffff;
293
294 if (card->pdat->app.offs > card->dpram_size ||
295 len > card->dpram_size - card->pdat->app.offs) {
296 ret = -EINVAL;
297 goto failed;
298 }
299
300 memcpy_toio(&card->dpram[card->pdat->app.offs], dat, len);
301 iowrite32(card->pdat->app.offs + card->pdat->app.addr,
302 &card->dpram[DPRAM_COMMAND + 2]);
303 iowrite32(addr, &card->dpram[DPRAM_COMMAND + 6]);
304 iowrite16(len, &card->dpram[DPRAM_COMMAND + 10]);
305 iowrite8(1, &card->dpram[DPRAM_COMMAND + 12]);
306 ret = softing_bootloader_command(card, 1, "loading app.");
307 if (ret < 0)
308 goto failed;
309 /* verify checksum */
310 rx_sum = ioread16(&card->dpram[DPRAM_RECEIPT + 2]);
311 if (rx_sum != sum) {
312 dev_alert(&card->pdev->dev, "SRAM seems to be damaged"
313 ", wanted 0x%04x, got 0x%04x\n", sum, rx_sum);
314 ret = -EIO;
315 goto failed;
316 }
317 }
318 if (!type_end || !type_entrypoint)
319 goto failed;
320 /* start application in card */
321 iowrite32(start_addr, &card->dpram[DPRAM_COMMAND + 2]);
322 iowrite8(1, &card->dpram[DPRAM_COMMAND + 6]);
323 ret = softing_bootloader_command(card, 3, "start app.");
324 if (ret < 0)
325 goto failed;
326 ret = 0;
327 failed:
328 release_firmware(fw);
329 if (ret < 0)
330 dev_info(&card->pdev->dev, "firmware %s failed\n", file);
331 return ret;
332 }
333
softing_reset_chip(struct softing * card)334 static int softing_reset_chip(struct softing *card)
335 {
336 int ret;
337
338 do {
339 /* reset chip */
340 iowrite8(0, &card->dpram[DPRAM_RESET_RX_FIFO]);
341 iowrite8(0, &card->dpram[DPRAM_RESET_RX_FIFO+1]);
342 iowrite8(1, &card->dpram[DPRAM_RESET]);
343 iowrite8(0, &card->dpram[DPRAM_RESET+1]);
344
345 ret = softing_fct_cmd(card, 0, "reset_can");
346 if (!ret)
347 break;
348 if (signal_pending(current))
349 /* don't wait any longer */
350 break;
351 } while (1);
352 card->tx.pending = 0;
353 return ret;
354 }
355
softing_chip_poweron(struct softing * card)356 int softing_chip_poweron(struct softing *card)
357 {
358 int ret;
359 /* sync */
360 ret = _softing_fct_cmd(card, 99, 0x55, "sync-a");
361 if (ret < 0)
362 goto failed;
363
364 ret = _softing_fct_cmd(card, 99, 0xaa, "sync-b");
365 if (ret < 0)
366 goto failed;
367
368 ret = softing_reset_chip(card);
369 if (ret < 0)
370 goto failed;
371 /* get_serial */
372 ret = softing_fct_cmd(card, 43, "get_serial_number");
373 if (ret < 0)
374 goto failed;
375 card->id.serial = ioread32(&card->dpram[DPRAM_FCT_PARAM]);
376 /* get_version */
377 ret = softing_fct_cmd(card, 12, "get_version");
378 if (ret < 0)
379 goto failed;
380 card->id.fw_version = ioread16(&card->dpram[DPRAM_FCT_PARAM + 2]);
381 card->id.hw_version = ioread16(&card->dpram[DPRAM_FCT_PARAM + 4]);
382 card->id.license = ioread16(&card->dpram[DPRAM_FCT_PARAM + 6]);
383 card->id.chip[0] = ioread16(&card->dpram[DPRAM_FCT_PARAM + 8]);
384 card->id.chip[1] = ioread16(&card->dpram[DPRAM_FCT_PARAM + 10]);
385 return 0;
386 failed:
387 return ret;
388 }
389
softing_initialize_timestamp(struct softing * card)390 static void softing_initialize_timestamp(struct softing *card)
391 {
392 uint64_t ovf;
393
394 card->ts_ref = ktime_get();
395
396 /* 16MHz is the reference */
397 ovf = 0x100000000ULL * 16;
398 do_div(ovf, card->pdat->freq ?: 16);
399
400 card->ts_overflow = ktime_add_us(0, ovf);
401 }
402
softing_raw2ktime(struct softing * card,u32 raw)403 ktime_t softing_raw2ktime(struct softing *card, u32 raw)
404 {
405 uint64_t rawl;
406 ktime_t now, real_offset;
407 ktime_t target;
408 ktime_t tmp;
409
410 now = ktime_get();
411 real_offset = ktime_sub(ktime_get_real(), now);
412
413 /* find nsec from card */
414 rawl = raw * 16;
415 do_div(rawl, card->pdat->freq ?: 16);
416 target = ktime_add_us(card->ts_ref, rawl);
417 /* test for overflows */
418 tmp = ktime_add(target, card->ts_overflow);
419 while (unlikely(ktime_to_ns(tmp) > ktime_to_ns(now))) {
420 card->ts_ref = ktime_add(card->ts_ref, card->ts_overflow);
421 target = tmp;
422 tmp = ktime_add(target, card->ts_overflow);
423 }
424 return ktime_add(target, real_offset);
425 }
426
softing_error_reporting(struct net_device * netdev)427 static inline int softing_error_reporting(struct net_device *netdev)
428 {
429 struct softing_priv *priv = netdev_priv(netdev);
430
431 return (priv->can.ctrlmode & CAN_CTRLMODE_BERR_REPORTING)
432 ? 1 : 0;
433 }
434
softing_startstop(struct net_device * dev,int up)435 int softing_startstop(struct net_device *dev, int up)
436 {
437 int ret;
438 struct softing *card;
439 struct softing_priv *priv;
440 struct net_device *netdev;
441 int bus_bitmask_start;
442 int j, error_reporting;
443 struct can_frame msg;
444 const struct can_bittiming *bt;
445
446 priv = netdev_priv(dev);
447 card = priv->card;
448
449 if (!card->fw.up)
450 return -EIO;
451
452 ret = mutex_lock_interruptible(&card->fw.lock);
453 if (ret)
454 return ret;
455
456 bus_bitmask_start = 0;
457 if (up)
458 /* prepare to start this bus as well */
459 bus_bitmask_start |= (1 << priv->index);
460 /* bring netdevs down */
461 for (j = 0; j < ARRAY_SIZE(card->net); ++j) {
462 netdev = card->net[j];
463 if (!netdev)
464 continue;
465 priv = netdev_priv(netdev);
466
467 if (dev != netdev)
468 netif_stop_queue(netdev);
469
470 if (netif_running(netdev)) {
471 if (dev != netdev)
472 bus_bitmask_start |= (1 << j);
473 priv->tx.pending = 0;
474 priv->tx.echo_put = 0;
475 priv->tx.echo_get = 0;
476 /*
477 * this bus' may just have called open_candev()
478 * which is rather stupid to call close_candev()
479 * already
480 * but we may come here from busoff recovery too
481 * in which case the echo_skb _needs_ flushing too.
482 * just be sure to call open_candev() again
483 */
484 close_candev(netdev);
485 }
486 priv->can.state = CAN_STATE_STOPPED;
487 }
488 card->tx.pending = 0;
489
490 softing_enable_irq(card, 0);
491 ret = softing_reset_chip(card);
492 if (ret)
493 goto failed;
494 if (!bus_bitmask_start)
495 /* no buses to be brought up */
496 goto card_done;
497
498 if ((bus_bitmask_start & 1) && (bus_bitmask_start & 2)
499 && (softing_error_reporting(card->net[0])
500 != softing_error_reporting(card->net[1]))) {
501 dev_alert(&card->pdev->dev,
502 "err_reporting flag differs for buses\n");
503 goto invalid;
504 }
505 error_reporting = 0;
506 if (bus_bitmask_start & 1) {
507 netdev = card->net[0];
508 priv = netdev_priv(netdev);
509 error_reporting += softing_error_reporting(netdev);
510 /* init chip 1 */
511 bt = &priv->can.bittiming;
512 iowrite16(bt->brp, &card->dpram[DPRAM_FCT_PARAM + 2]);
513 iowrite16(bt->sjw, &card->dpram[DPRAM_FCT_PARAM + 4]);
514 iowrite16(bt->phase_seg1 + bt->prop_seg,
515 &card->dpram[DPRAM_FCT_PARAM + 6]);
516 iowrite16(bt->phase_seg2, &card->dpram[DPRAM_FCT_PARAM + 8]);
517 iowrite16((priv->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES) ? 1 : 0,
518 &card->dpram[DPRAM_FCT_PARAM + 10]);
519 ret = softing_fct_cmd(card, 1, "initialize_chip[0]");
520 if (ret < 0)
521 goto failed;
522 /* set mode */
523 iowrite16(0, &card->dpram[DPRAM_FCT_PARAM + 2]);
524 iowrite16(0, &card->dpram[DPRAM_FCT_PARAM + 4]);
525 ret = softing_fct_cmd(card, 3, "set_mode[0]");
526 if (ret < 0)
527 goto failed;
528 /* set filter */
529 /* 11bit id & mask */
530 iowrite16(0x0000, &card->dpram[DPRAM_FCT_PARAM + 2]);
531 iowrite16(0x07ff, &card->dpram[DPRAM_FCT_PARAM + 4]);
532 /* 29bit id.lo & mask.lo & id.hi & mask.hi */
533 iowrite16(0x0000, &card->dpram[DPRAM_FCT_PARAM + 6]);
534 iowrite16(0xffff, &card->dpram[DPRAM_FCT_PARAM + 8]);
535 iowrite16(0x0000, &card->dpram[DPRAM_FCT_PARAM + 10]);
536 iowrite16(0x1fff, &card->dpram[DPRAM_FCT_PARAM + 12]);
537 ret = softing_fct_cmd(card, 7, "set_filter[0]");
538 if (ret < 0)
539 goto failed;
540 /* set output control */
541 iowrite16(priv->output, &card->dpram[DPRAM_FCT_PARAM + 2]);
542 ret = softing_fct_cmd(card, 5, "set_output[0]");
543 if (ret < 0)
544 goto failed;
545 }
546 if (bus_bitmask_start & 2) {
547 netdev = card->net[1];
548 priv = netdev_priv(netdev);
549 error_reporting += softing_error_reporting(netdev);
550 /* init chip2 */
551 bt = &priv->can.bittiming;
552 iowrite16(bt->brp, &card->dpram[DPRAM_FCT_PARAM + 2]);
553 iowrite16(bt->sjw, &card->dpram[DPRAM_FCT_PARAM + 4]);
554 iowrite16(bt->phase_seg1 + bt->prop_seg,
555 &card->dpram[DPRAM_FCT_PARAM + 6]);
556 iowrite16(bt->phase_seg2, &card->dpram[DPRAM_FCT_PARAM + 8]);
557 iowrite16((priv->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES) ? 1 : 0,
558 &card->dpram[DPRAM_FCT_PARAM + 10]);
559 ret = softing_fct_cmd(card, 2, "initialize_chip[1]");
560 if (ret < 0)
561 goto failed;
562 /* set mode2 */
563 iowrite16(0, &card->dpram[DPRAM_FCT_PARAM + 2]);
564 iowrite16(0, &card->dpram[DPRAM_FCT_PARAM + 4]);
565 ret = softing_fct_cmd(card, 4, "set_mode[1]");
566 if (ret < 0)
567 goto failed;
568 /* set filter2 */
569 /* 11bit id & mask */
570 iowrite16(0x0000, &card->dpram[DPRAM_FCT_PARAM + 2]);
571 iowrite16(0x07ff, &card->dpram[DPRAM_FCT_PARAM + 4]);
572 /* 29bit id.lo & mask.lo & id.hi & mask.hi */
573 iowrite16(0x0000, &card->dpram[DPRAM_FCT_PARAM + 6]);
574 iowrite16(0xffff, &card->dpram[DPRAM_FCT_PARAM + 8]);
575 iowrite16(0x0000, &card->dpram[DPRAM_FCT_PARAM + 10]);
576 iowrite16(0x1fff, &card->dpram[DPRAM_FCT_PARAM + 12]);
577 ret = softing_fct_cmd(card, 8, "set_filter[1]");
578 if (ret < 0)
579 goto failed;
580 /* set output control2 */
581 iowrite16(priv->output, &card->dpram[DPRAM_FCT_PARAM + 2]);
582 ret = softing_fct_cmd(card, 6, "set_output[1]");
583 if (ret < 0)
584 goto failed;
585 }
586
587 /* enable_error_frame
588 *
589 * Error reporting is switched off at the moment since
590 * the receiving of them is not yet 100% verified
591 * This should be enabled sooner or later
592 */
593 if (0 && error_reporting) {
594 ret = softing_fct_cmd(card, 51, "enable_error_frame");
595 if (ret < 0)
596 goto failed;
597 }
598
599 /* initialize interface */
600 iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 2]);
601 iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 4]);
602 iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 6]);
603 iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 8]);
604 iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 10]);
605 iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 12]);
606 iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 14]);
607 iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 16]);
608 iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 18]);
609 iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 20]);
610 ret = softing_fct_cmd(card, 17, "initialize_interface");
611 if (ret < 0)
612 goto failed;
613 /* enable_fifo */
614 ret = softing_fct_cmd(card, 36, "enable_fifo");
615 if (ret < 0)
616 goto failed;
617 /* enable fifo tx ack */
618 ret = softing_fct_cmd(card, 13, "fifo_tx_ack[0]");
619 if (ret < 0)
620 goto failed;
621 /* enable fifo tx ack2 */
622 ret = softing_fct_cmd(card, 14, "fifo_tx_ack[1]");
623 if (ret < 0)
624 goto failed;
625 /* start_chip */
626 ret = softing_fct_cmd(card, 11, "start_chip");
627 if (ret < 0)
628 goto failed;
629 iowrite8(0, &card->dpram[DPRAM_INFO_BUSSTATE]);
630 iowrite8(0, &card->dpram[DPRAM_INFO_BUSSTATE2]);
631 if (card->pdat->generation < 2) {
632 iowrite8(0, &card->dpram[DPRAM_V2_IRQ_TOHOST]);
633 /* flush the DPRAM caches */
634 wmb();
635 }
636
637 softing_initialize_timestamp(card);
638
639 /*
640 * do socketcan notifications/status changes
641 * from here, no errors should occur, or the failed: part
642 * must be reviewed
643 */
644 memset(&msg, 0, sizeof(msg));
645 msg.can_id = CAN_ERR_FLAG | CAN_ERR_RESTARTED;
646 msg.len = CAN_ERR_DLC;
647 for (j = 0; j < ARRAY_SIZE(card->net); ++j) {
648 if (!(bus_bitmask_start & (1 << j)))
649 continue;
650 netdev = card->net[j];
651 if (!netdev)
652 continue;
653 priv = netdev_priv(netdev);
654 priv->can.state = CAN_STATE_ERROR_ACTIVE;
655 open_candev(netdev);
656 if (dev != netdev) {
657 /* notify other buses on the restart */
658 softing_netdev_rx(netdev, &msg, 0);
659 ++priv->can.can_stats.restarts;
660 }
661 netif_wake_queue(netdev);
662 }
663
664 /* enable interrupts */
665 ret = softing_enable_irq(card, 1);
666 if (ret)
667 goto failed;
668 card_done:
669 mutex_unlock(&card->fw.lock);
670 return 0;
671 invalid:
672 ret = -EINVAL;
673 failed:
674 softing_enable_irq(card, 0);
675 softing_reset_chip(card);
676 mutex_unlock(&card->fw.lock);
677 /* bring all other interfaces down */
678 for (j = 0; j < ARRAY_SIZE(card->net); ++j) {
679 netdev = card->net[j];
680 if (!netdev)
681 continue;
682 dev_close(netdev);
683 }
684 return ret;
685 }
686
softing_default_output(struct net_device * netdev)687 int softing_default_output(struct net_device *netdev)
688 {
689 struct softing_priv *priv = netdev_priv(netdev);
690 struct softing *card = priv->card;
691
692 switch (priv->chip) {
693 case 1000:
694 return (card->pdat->generation < 2) ? 0xfb : 0xfa;
695 case 5:
696 return 0x60;
697 default:
698 return 0x40;
699 }
700 }
701