Commit | Line | Data |
---|---|---|
35e62ae8 | 1 | // SPDX-License-Identifier: GPL-2.0-only |
03fd3cf5 KVD |
2 | /* |
3 | * Copyright (C) 2008-2010 | |
4 | * | |
5 | * - Kurt Van Dijck, EIA Electronics | |
03fd3cf5 KVD |
6 | */ |
7 | ||
8 | #include <linux/firmware.h> | |
174cd4b1 | 9 | #include <linux/sched/signal.h> |
03fd3cf5 | 10 | #include <asm/div64.h> |
b7f080cf | 11 | #include <asm/io.h> |
03fd3cf5 KVD |
12 | |
13 | #include "softing.h" | |
14 | ||
15 | /* | |
16 | * low level DPRAM command. | |
17 | * Make sure that card->dpram[DPRAM_FCT_HOST] is preset | |
18 | */ | |
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 | ||
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 | ||
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 | ||
94 | static 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 | ||
133 | int 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; | |
ef813c41 | 141 | uint8_t *buf = NULL, *new_buf; |
03fd3cf5 KVD |
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); | |
ef813c41 AK |
190 | new_buf = krealloc(buf, buflen, GFP_KERNEL); |
191 | if (!new_buf) { | |
03fd3cf5 KVD |
192 | ret = -ENOMEM; |
193 | goto failed; | |
194 | } | |
ef813c41 | 195 | buf = new_buf; |
03fd3cf5 KVD |
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; | |
210 | failed: | |
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 | ||
218 | int 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 | ||
88bfb9a7 | 276 | /* regular data */ |
03fd3cf5 KVD |
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; | |
309 | failed: | |
310 | release_firmware(fw); | |
311 | if (ret < 0) | |
312 | dev_info(&card->pdev->dev, "firmware %s failed\n", file); | |
313 | return ret; | |
314 | } | |
315 | ||
316 | static 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 | ||
338 | int 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; | |
368 | failed: | |
369 | return ret; | |
370 | } | |
371 | ||
372 | static 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 | ||
8b0e1953 | 382 | card->ts_overflow = ktime_add_us(0, ovf); |
03fd3cf5 KVD |
383 | } |
384 | ||
385 | ktime_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 | ||
409 | static 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 | ||
417 | int 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; | |
383de566 | 439 | if (up) |
03fd3cf5 KVD |
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) | |
88bfb9a7 | 477 | /* no buses to be brought up */ |
03fd3cf5 KVD |
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, | |
88bfb9a7 | 484 | "err_reporting flag differs for buses\n"); |
03fd3cf5 KVD |
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 | } | |
370d988c MKB |
568 | |
569 | /* enable_error_frame | |
570 | * | |
03fd3cf5 KVD |
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 | |
370d988c MKB |
574 | */ |
575 | if (0 && error_reporting) { | |
03fd3cf5 KVD |
576 | ret = softing_fct_cmd(card, 51, "enable_error_frame"); |
577 | if (ret < 0) | |
578 | goto failed; | |
579 | } | |
370d988c | 580 | |
03fd3cf5 KVD |
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; | |
c7b74967 | 628 | msg.len = CAN_ERR_DLC; |
03fd3cf5 KVD |
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) { | |
88bfb9a7 | 639 | /* notify other buses on the restart */ |
8b0e1953 | 640 | softing_netdev_rx(netdev, &msg, 0); |
03fd3cf5 KVD |
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; | |
650 | card_done: | |
651 | mutex_unlock(&card->fw.lock); | |
652 | return 0; | |
653 | invalid: | |
654 | ret = -EINVAL; | |
655 | failed: | |
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 | ||
669 | int 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 | } |