?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 3.11-rc3
[cris-mirror.git] / drivers / net / can / softing / softing_fw.c
blobb595d3422b9f759d86c760370b30efcb04f76575
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 */
31 static 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
65 static 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
77 int 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
106 static 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
145 int 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 /* 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 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[addr + 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
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, &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, &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 /* regualar data */
289 for (sum = 0, j = 0; j < len; ++j)
290 sum += dat[j];
291 /* work in 16bit (target) */
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 /* verify checksum */
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 /* start application in card */
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;
321 failed:
322 release_firmware(fw);
323 if (ret < 0)
324 dev_info(&card->pdev->dev, "firmware %s failed\n", file);
325 return ret;
326 }
327
328 static int softing_reset_chip(struct softing *card)
329 {
330 int ret;
331
332 do {
333 /* reset chip */
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 /* don't wait any longer */
344 break;
345 } while (1);
346 card->tx.pending = 0;
347 return ret;
348 }
349
350 int softing_chip_poweron(struct softing *card)
351 {
352 int ret;
353 /* sync */
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 /* get_serial */
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 /* get_version */
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;
380 failed:
381 return ret;
382 }
383
384 static void softing_initialize_timestamp(struct softing *card)
385 {
386 uint64_t ovf;
387
388 card->ts_ref = ktime_get();
389
390 /* 16MHz is the reference */
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
397 ktime_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 /* find nsec from card */
408 rawl = raw * 16;
409 do_div(rawl, card->pdat->freq ?: 16);
410 target = ktime_add_us(card->ts_ref, rawl);
411 /* test for overflows */
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
421 static 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
429 int 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 /* prepare to start this bus as well */
453 bus_bitmask_start |= (1 << priv->index);
454 /* bring netdevs down */
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 * this bus' may just have called open_candev()
472 * which is rather stupid to call close_candev()
473 * already
474 * but we may come here from busoff recovery too
475 * in which case the echo_skb _needs_ flushing too.
476 * just be sure to call open_candev() again
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 /* no busses to be brought up */
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 /* init chip 1 */
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 /* set mode */
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 /* set filter */
523 /* 11bit id & mask */
524 iowrite16(0x0000, &card->dpram[DPRAM_FCT_PARAM + 2]);
525 iowrite16(0x07ff, &card->dpram[DPRAM_FCT_PARAM + 4]);
526 /* 29bit id.lo & mask.lo & id.hi & mask.hi */
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 /* set output control */
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 /* init chip2 */
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 /* set mode2 */
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 /* set filter2 */
563 /* 11bit id & mask */
564 iowrite16(0x0000, &card->dpram[DPRAM_FCT_PARAM + 2]);
565 iowrite16(0x07ff, &card->dpram[DPRAM_FCT_PARAM + 4]);
566 /* 29bit id.lo & mask.lo & id.hi & mask.hi */
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 /* set output control2 */
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 /* enable_error_frame */
581 /*
582 * Error reporting is switched off at the moment since
583 * the receiving of them is not yet 100% verified
584 * This should be enabled sooner or later
585 *
586 if (error_reporting) {
587 ret = softing_fct_cmd(card, 51, "enable_error_frame");
588 if (ret < 0)
589 goto failed;
590 }
591 */
592 /* initialize interface */
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 /* enable_fifo */
607 ret = softing_fct_cmd(card, 36, "enable_fifo");
608 if (ret < 0)
609 goto failed;
610 /* enable fifo tx ack */
611 ret = softing_fct_cmd(card, 13, "fifo_tx_ack[0]");
612 if (ret < 0)
613 goto failed;
614 /* enable fifo tx ack2 */
615 ret = softing_fct_cmd(card, 14, "fifo_tx_ack[1]");
616 if (ret < 0)
617 goto failed;
618 /* start_chip */
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 /* flush the DPRAM caches */
627 wmb();
628 }
629
630 softing_initialize_timestamp(card);
631
632 /*
633 * do socketcan notifications/status changes
634 * from here, no errors should occur, or the failed: part
635 * must be reviewed
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 /* notify other busses on the restart */
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 /* enable interrupts */
658 ret = softing_enable_irq(card, 1);
659 if (ret)
660 goto failed;
661 card_done:
662 mutex_unlock(&card->fw.lock);
663 return 0;
664 invalid:
665 ret = -EINVAL;
666 failed:
667 softing_enable_irq(card, 0);
668 softing_reset_chip(card);
669 mutex_unlock(&card->fw.lock);
670 /* bring all other interfaces down */
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
680 int 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 }
CRIS linux kernel tree