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 */ 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 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 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 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 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 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 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 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 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 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 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