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 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; 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; 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 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; 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 382 card->ts_overflow = ktime_add_us(0, ovf); 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; 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; 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 } 683