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 24 #include "softing.h" 25 26 /* 27 * low level DPRAM command. 28 * Make sure that card->dpram[DPRAM_FCT_HOST] is preset 29 */ 30 static int _softing_fct_cmd(struct softing *card, int16_t cmd, uint16_t vector, 31 const char *msg) 32 { 33 int ret; 34 unsigned long stamp; 35 36 iowrite16(cmd, &card->dpram[DPRAM_FCT_PARAM]); 37 iowrite8(vector >> 8, &card->dpram[DPRAM_FCT_HOST + 1]); 38 iowrite8(vector, &card->dpram[DPRAM_FCT_HOST]); 39 /* be sure to flush this to the card */ 40 wmb(); 41 stamp = jiffies + 1 * HZ; 42 /* wait for card */ 43 do { 44 /* DPRAM_FCT_HOST is _not_ aligned */ 45 ret = ioread8(&card->dpram[DPRAM_FCT_HOST]) + 46 (ioread8(&card->dpram[DPRAM_FCT_HOST + 1]) << 8); 47 /* don't have any cached variables */ 48 rmb(); 49 if (ret == RES_OK) 50 /* read return-value now */ 51 return ioread16(&card->dpram[DPRAM_FCT_RESULT]); 52 53 if ((ret != vector) || time_after(jiffies, stamp)) 54 break; 55 /* process context => relax */ 56 usleep_range(500, 10000); 57 } while (1); 58 59 ret = (ret == RES_NONE) ? -ETIMEDOUT : -ECANCELED; 60 dev_alert(&card->pdev->dev, "firmware %s failed (%i)\n", msg, ret); 61 return ret; 62 } 63 64 static int softing_fct_cmd(struct softing *card, int16_t cmd, const char *msg) 65 { 66 int ret; 67 68 ret = _softing_fct_cmd(card, cmd, 0, msg); 69 if (ret > 0) { 70 dev_alert(&card->pdev->dev, "%s returned %u\n", msg, ret); 71 ret = -EIO; 72 } 73 return ret; 74 } 75 76 int softing_bootloader_command(struct softing *card, int16_t cmd, 77 const char *msg) 78 { 79 int ret; 80 unsigned long stamp; 81 82 iowrite16(RES_NONE, &card->dpram[DPRAM_RECEIPT]); 83 iowrite16(cmd, &card->dpram[DPRAM_COMMAND]); 84 /* be sure to flush this to the card */ 85 wmb(); 86 stamp = jiffies + 3 * HZ; 87 /* wait for card */ 88 do { 89 ret = ioread16(&card->dpram[DPRAM_RECEIPT]); 90 /* don't have any cached variables */ 91 rmb(); 92 if (ret == RES_OK) 93 return 0; 94 if (time_after(jiffies, stamp)) 95 break; 96 /* process context => relax */ 97 usleep_range(500, 10000); 98 } while (!signal_pending(current)); 99 100 ret = (ret == RES_NONE) ? -ETIMEDOUT : -ECANCELED; 101 dev_alert(&card->pdev->dev, "bootloader %s failed (%i)\n", msg, ret); 102 return ret; 103 } 104 105 static int fw_parse(const uint8_t **pmem, uint16_t *ptype, uint32_t *paddr, 106 uint16_t *plen, const uint8_t **pdat) 107 { 108 uint16_t checksum[2]; 109 const uint8_t *mem; 110 const uint8_t *end; 111 112 /* 113 * firmware records are a binary, unaligned stream composed of: 114 * uint16_t type; 115 * uint32_t addr; 116 * uint16_t len; 117 * uint8_t dat[len]; 118 * uint16_t checksum; 119 * all values in little endian. 120 * We could define a struct for this, with __attribute__((packed)), 121 * but would that solve the alignment in _all_ cases (cfr. the 122 * struct itself may be an odd address)? 123 * 124 * I chose to use leXX_to_cpup() since this solves both 125 * endianness & alignment. 126 */ 127 mem = *pmem; 128 *ptype = le16_to_cpup((void *)&mem[0]); 129 *paddr = le32_to_cpup((void *)&mem[2]); 130 *plen = le16_to_cpup((void *)&mem[6]); 131 *pdat = &mem[8]; 132 /* verify checksum */ 133 end = &mem[8 + *plen]; 134 checksum[0] = le16_to_cpup((void *)end); 135 for (checksum[1] = 0; mem < end; ++mem) 136 checksum[1] += *mem; 137 if (checksum[0] != checksum[1]) 138 return -EINVAL; 139 /* increment */ 140 *pmem += 10 + *plen; 141 return 0; 142 } 143 144 int softing_load_fw(const char *file, struct softing *card, 145 __iomem uint8_t *dpram, unsigned int size, int offset) 146 { 147 const struct firmware *fw; 148 int ret; 149 const uint8_t *mem, *end, *dat; 150 uint16_t type, len; 151 uint32_t addr; 152 uint8_t *buf = NULL; 153 int buflen = 0; 154 int8_t type_end = 0; 155 156 ret = request_firmware(&fw, file, &card->pdev->dev); 157 if (ret < 0) 158 return ret; 159 dev_dbg(&card->pdev->dev, "%s, firmware(%s) got %u bytes" 160 ", offset %c0x%04x\n", 161 card->pdat->name, file, (unsigned int)fw->size, 162 (offset >= 0) ? '+' : '-', (unsigned int)abs(offset)); 163 /* parse the firmware */ 164 mem = fw->data; 165 end = &mem[fw->size]; 166 /* look for header record */ 167 ret = fw_parse(&mem, &type, &addr, &len, &dat); 168 if (ret < 0) 169 goto failed; 170 if (type != 0xffff) 171 goto failed; 172 if (strncmp("Structured Binary Format, Softing GmbH" , dat, len)) { 173 ret = -EINVAL; 174 goto failed; 175 } 176 /* ok, we had a header */ 177 while (mem < end) { 178 ret = fw_parse(&mem, &type, &addr, &len, &dat); 179 if (ret < 0) 180 goto failed; 181 if (type == 3) { 182 /* start address, not used here */ 183 continue; 184 } else if (type == 1) { 185 /* eof */ 186 type_end = 1; 187 break; 188 } else if (type != 0) { 189 ret = -EINVAL; 190 goto failed; 191 } 192 193 if ((addr + len + offset) > size) 194 goto failed; 195 memcpy_toio(&dpram[addr + offset], dat, len); 196 /* be sure to flush caches from IO space */ 197 mb(); 198 if (len > buflen) { 199 /* align buflen */ 200 buflen = (len + (1024-1)) & ~(1024-1); 201 buf = krealloc(buf, buflen, GFP_KERNEL); 202 if (!buf) { 203 ret = -ENOMEM; 204 goto failed; 205 } 206 } 207 /* verify record data */ 208 memcpy_fromio(buf, &dpram[addr + offset], len); 209 if (memcmp(buf, dat, len)) { 210 /* is not ok */ 211 dev_alert(&card->pdev->dev, "DPRAM readback failed\n"); 212 ret = -EIO; 213 goto failed; 214 } 215 } 216 if (!type_end) 217 /* no end record seen */ 218 goto failed; 219 ret = 0; 220 failed: 221 kfree(buf); 222 release_firmware(fw); 223 if (ret < 0) 224 dev_info(&card->pdev->dev, "firmware %s failed\n", file); 225 return ret; 226 } 227 228 int softing_load_app_fw(const char *file, struct softing *card) 229 { 230 const struct firmware *fw; 231 const uint8_t *mem, *end, *dat; 232 int ret, j; 233 uint16_t type, len; 234 uint32_t addr, start_addr = 0; 235 unsigned int sum, rx_sum; 236 int8_t type_end = 0, type_entrypoint = 0; 237 238 ret = request_firmware(&fw, file, &card->pdev->dev); 239 if (ret) { 240 dev_alert(&card->pdev->dev, "request_firmware(%s) got %i\n", 241 file, ret); 242 return ret; 243 } 244 dev_dbg(&card->pdev->dev, "firmware(%s) got %lu bytes\n", 245 file, (unsigned long)fw->size); 246 /* parse the firmware */ 247 mem = fw->data; 248 end = &mem[fw->size]; 249 /* look for header record */ 250 ret = fw_parse(&mem, &type, &addr, &len, &dat); 251 if (ret) 252 goto failed; 253 ret = -EINVAL; 254 if (type != 0xffff) { 255 dev_alert(&card->pdev->dev, "firmware starts with type 0x%x\n", 256 type); 257 goto failed; 258 } 259 if (strncmp("Structured Binary Format, Softing GmbH", dat, len)) { 260 dev_alert(&card->pdev->dev, "firmware string '%.*s' fault\n", 261 len, dat); 262 goto failed; 263 } 264 /* ok, we had a header */ 265 while (mem < end) { 266 ret = fw_parse(&mem, &type, &addr, &len, &dat); 267 if (ret) 268 goto failed; 269 270 if (type == 3) { 271 /* start address */ 272 start_addr = addr; 273 type_entrypoint = 1; 274 continue; 275 } else if (type == 1) { 276 /* eof */ 277 type_end = 1; 278 break; 279 } else if (type != 0) { 280 dev_alert(&card->pdev->dev, 281 "unknown record type 0x%04x\n", type); 282 ret = -EINVAL; 283 goto failed; 284 } 285 286 /* regualar data */ 287 for (sum = 0, j = 0; j < len; ++j) 288 sum += dat[j]; 289 /* work in 16bit (target) */ 290 sum &= 0xffff; 291 292 memcpy_toio(&card->dpram[card->pdat->app.offs], dat, len); 293 iowrite32(card->pdat->app.offs + card->pdat->app.addr, 294 &card->dpram[DPRAM_COMMAND + 2]); 295 iowrite32(addr, &card->dpram[DPRAM_COMMAND + 6]); 296 iowrite16(len, &card->dpram[DPRAM_COMMAND + 10]); 297 iowrite8(1, &card->dpram[DPRAM_COMMAND + 12]); 298 ret = softing_bootloader_command(card, 1, "loading app."); 299 if (ret < 0) 300 goto failed; 301 /* verify checksum */ 302 rx_sum = ioread16(&card->dpram[DPRAM_RECEIPT + 2]); 303 if (rx_sum != sum) { 304 dev_alert(&card->pdev->dev, "SRAM seems to be damaged" 305 ", wanted 0x%04x, got 0x%04x\n", sum, rx_sum); 306 ret = -EIO; 307 goto failed; 308 } 309 } 310 if (!type_end || !type_entrypoint) 311 goto failed; 312 /* start application in card */ 313 iowrite32(start_addr, &card->dpram[DPRAM_COMMAND + 2]); 314 iowrite8(1, &card->dpram[DPRAM_COMMAND + 6]); 315 ret = softing_bootloader_command(card, 3, "start app."); 316 if (ret < 0) 317 goto failed; 318 ret = 0; 319 failed: 320 release_firmware(fw); 321 if (ret < 0) 322 dev_info(&card->pdev->dev, "firmware %s failed\n", file); 323 return ret; 324 } 325 326 static int softing_reset_chip(struct softing *card) 327 { 328 int ret; 329 330 do { 331 /* reset chip */ 332 iowrite8(0, &card->dpram[DPRAM_RESET_RX_FIFO]); 333 iowrite8(0, &card->dpram[DPRAM_RESET_RX_FIFO+1]); 334 iowrite8(1, &card->dpram[DPRAM_RESET]); 335 iowrite8(0, &card->dpram[DPRAM_RESET+1]); 336 337 ret = softing_fct_cmd(card, 0, "reset_can"); 338 if (!ret) 339 break; 340 if (signal_pending(current)) 341 /* don't wait any longer */ 342 break; 343 } while (1); 344 card->tx.pending = 0; 345 return ret; 346 } 347 348 int softing_chip_poweron(struct softing *card) 349 { 350 int ret; 351 /* sync */ 352 ret = _softing_fct_cmd(card, 99, 0x55, "sync-a"); 353 if (ret < 0) 354 goto failed; 355 356 ret = _softing_fct_cmd(card, 99, 0xaa, "sync-b"); 357 if (ret < 0) 358 goto failed; 359 360 ret = softing_reset_chip(card); 361 if (ret < 0) 362 goto failed; 363 /* get_serial */ 364 ret = softing_fct_cmd(card, 43, "get_serial_number"); 365 if (ret < 0) 366 goto failed; 367 card->id.serial = ioread32(&card->dpram[DPRAM_FCT_PARAM]); 368 /* get_version */ 369 ret = softing_fct_cmd(card, 12, "get_version"); 370 if (ret < 0) 371 goto failed; 372 card->id.fw_version = ioread16(&card->dpram[DPRAM_FCT_PARAM + 2]); 373 card->id.hw_version = ioread16(&card->dpram[DPRAM_FCT_PARAM + 4]); 374 card->id.license = ioread16(&card->dpram[DPRAM_FCT_PARAM + 6]); 375 card->id.chip[0] = ioread16(&card->dpram[DPRAM_FCT_PARAM + 8]); 376 card->id.chip[1] = ioread16(&card->dpram[DPRAM_FCT_PARAM + 10]); 377 return 0; 378 failed: 379 return ret; 380 } 381 382 static void softing_initialize_timestamp(struct softing *card) 383 { 384 uint64_t ovf; 385 386 card->ts_ref = ktime_get(); 387 388 /* 16MHz is the reference */ 389 ovf = 0x100000000ULL * 16; 390 do_div(ovf, card->pdat->freq ?: 16); 391 392 card->ts_overflow = ktime_add_us(ktime_set(0, 0), ovf); 393 } 394 395 ktime_t softing_raw2ktime(struct softing *card, u32 raw) 396 { 397 uint64_t rawl; 398 ktime_t now, real_offset; 399 ktime_t target; 400 ktime_t tmp; 401 402 now = ktime_get(); 403 real_offset = ktime_sub(ktime_get_real(), now); 404 405 /* find nsec from card */ 406 rawl = raw * 16; 407 do_div(rawl, card->pdat->freq ?: 16); 408 target = ktime_add_us(card->ts_ref, rawl); 409 /* test for overflows */ 410 tmp = ktime_add(target, card->ts_overflow); 411 while (unlikely(ktime_to_ns(tmp) > ktime_to_ns(now))) { 412 card->ts_ref = ktime_add(card->ts_ref, card->ts_overflow); 413 target = tmp; 414 tmp = ktime_add(target, card->ts_overflow); 415 } 416 return ktime_add(target, real_offset); 417 } 418 419 static inline int softing_error_reporting(struct net_device *netdev) 420 { 421 struct softing_priv *priv = netdev_priv(netdev); 422 423 return (priv->can.ctrlmode & CAN_CTRLMODE_BERR_REPORTING) 424 ? 1 : 0; 425 } 426 427 int softing_startstop(struct net_device *dev, int up) 428 { 429 int ret; 430 struct softing *card; 431 struct softing_priv *priv; 432 struct net_device *netdev; 433 int bus_bitmask_start; 434 int j, error_reporting; 435 struct can_frame msg; 436 const struct can_bittiming *bt; 437 438 priv = netdev_priv(dev); 439 card = priv->card; 440 441 if (!card->fw.up) 442 return -EIO; 443 444 ret = mutex_lock_interruptible(&card->fw.lock); 445 if (ret) 446 return ret; 447 448 bus_bitmask_start = 0; 449 if (dev && up) 450 /* prepare to start this bus as well */ 451 bus_bitmask_start |= (1 << priv->index); 452 /* bring netdevs down */ 453 for (j = 0; j < ARRAY_SIZE(card->net); ++j) { 454 netdev = card->net[j]; 455 if (!netdev) 456 continue; 457 priv = netdev_priv(netdev); 458 459 if (dev != netdev) 460 netif_stop_queue(netdev); 461 462 if (netif_running(netdev)) { 463 if (dev != netdev) 464 bus_bitmask_start |= (1 << j); 465 priv->tx.pending = 0; 466 priv->tx.echo_put = 0; 467 priv->tx.echo_get = 0; 468 /* 469 * this bus' may just have called open_candev() 470 * which is rather stupid to call close_candev() 471 * already 472 * but we may come here from busoff recovery too 473 * in which case the echo_skb _needs_ flushing too. 474 * just be sure to call open_candev() again 475 */ 476 close_candev(netdev); 477 } 478 priv->can.state = CAN_STATE_STOPPED; 479 } 480 card->tx.pending = 0; 481 482 softing_enable_irq(card, 0); 483 ret = softing_reset_chip(card); 484 if (ret) 485 goto failed; 486 if (!bus_bitmask_start) 487 /* no busses to be brought up */ 488 goto card_done; 489 490 if ((bus_bitmask_start & 1) && (bus_bitmask_start & 2) 491 && (softing_error_reporting(card->net[0]) 492 != softing_error_reporting(card->net[1]))) { 493 dev_alert(&card->pdev->dev, 494 "err_reporting flag differs for busses\n"); 495 goto invalid; 496 } 497 error_reporting = 0; 498 if (bus_bitmask_start & 1) { 499 netdev = card->net[0]; 500 priv = netdev_priv(netdev); 501 error_reporting += softing_error_reporting(netdev); 502 /* init chip 1 */ 503 bt = &priv->can.bittiming; 504 iowrite16(bt->brp, &card->dpram[DPRAM_FCT_PARAM + 2]); 505 iowrite16(bt->sjw, &card->dpram[DPRAM_FCT_PARAM + 4]); 506 iowrite16(bt->phase_seg1 + bt->prop_seg, 507 &card->dpram[DPRAM_FCT_PARAM + 6]); 508 iowrite16(bt->phase_seg2, &card->dpram[DPRAM_FCT_PARAM + 8]); 509 iowrite16((priv->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES) ? 1 : 0, 510 &card->dpram[DPRAM_FCT_PARAM + 10]); 511 ret = softing_fct_cmd(card, 1, "initialize_chip[0]"); 512 if (ret < 0) 513 goto failed; 514 /* set mode */ 515 iowrite16(0, &card->dpram[DPRAM_FCT_PARAM + 2]); 516 iowrite16(0, &card->dpram[DPRAM_FCT_PARAM + 4]); 517 ret = softing_fct_cmd(card, 3, "set_mode[0]"); 518 if (ret < 0) 519 goto failed; 520 /* set filter */ 521 /* 11bit id & mask */ 522 iowrite16(0x0000, &card->dpram[DPRAM_FCT_PARAM + 2]); 523 iowrite16(0x07ff, &card->dpram[DPRAM_FCT_PARAM + 4]); 524 /* 29bit id.lo & mask.lo & id.hi & mask.hi */ 525 iowrite16(0x0000, &card->dpram[DPRAM_FCT_PARAM + 6]); 526 iowrite16(0xffff, &card->dpram[DPRAM_FCT_PARAM + 8]); 527 iowrite16(0x0000, &card->dpram[DPRAM_FCT_PARAM + 10]); 528 iowrite16(0x1fff, &card->dpram[DPRAM_FCT_PARAM + 12]); 529 ret = softing_fct_cmd(card, 7, "set_filter[0]"); 530 if (ret < 0) 531 goto failed; 532 /* set output control */ 533 iowrite16(priv->output, &card->dpram[DPRAM_FCT_PARAM + 2]); 534 ret = softing_fct_cmd(card, 5, "set_output[0]"); 535 if (ret < 0) 536 goto failed; 537 } 538 if (bus_bitmask_start & 2) { 539 netdev = card->net[1]; 540 priv = netdev_priv(netdev); 541 error_reporting += softing_error_reporting(netdev); 542 /* init chip2 */ 543 bt = &priv->can.bittiming; 544 iowrite16(bt->brp, &card->dpram[DPRAM_FCT_PARAM + 2]); 545 iowrite16(bt->sjw, &card->dpram[DPRAM_FCT_PARAM + 4]); 546 iowrite16(bt->phase_seg1 + bt->prop_seg, 547 &card->dpram[DPRAM_FCT_PARAM + 6]); 548 iowrite16(bt->phase_seg2, &card->dpram[DPRAM_FCT_PARAM + 8]); 549 iowrite16((priv->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES) ? 1 : 0, 550 &card->dpram[DPRAM_FCT_PARAM + 10]); 551 ret = softing_fct_cmd(card, 2, "initialize_chip[1]"); 552 if (ret < 0) 553 goto failed; 554 /* set mode2 */ 555 iowrite16(0, &card->dpram[DPRAM_FCT_PARAM + 2]); 556 iowrite16(0, &card->dpram[DPRAM_FCT_PARAM + 4]); 557 ret = softing_fct_cmd(card, 4, "set_mode[1]"); 558 if (ret < 0) 559 goto failed; 560 /* set filter2 */ 561 /* 11bit id & mask */ 562 iowrite16(0x0000, &card->dpram[DPRAM_FCT_PARAM + 2]); 563 iowrite16(0x07ff, &card->dpram[DPRAM_FCT_PARAM + 4]); 564 /* 29bit id.lo & mask.lo & id.hi & mask.hi */ 565 iowrite16(0x0000, &card->dpram[DPRAM_FCT_PARAM + 6]); 566 iowrite16(0xffff, &card->dpram[DPRAM_FCT_PARAM + 8]); 567 iowrite16(0x0000, &card->dpram[DPRAM_FCT_PARAM + 10]); 568 iowrite16(0x1fff, &card->dpram[DPRAM_FCT_PARAM + 12]); 569 ret = softing_fct_cmd(card, 8, "set_filter[1]"); 570 if (ret < 0) 571 goto failed; 572 /* set output control2 */ 573 iowrite16(priv->output, &card->dpram[DPRAM_FCT_PARAM + 2]); 574 ret = softing_fct_cmd(card, 6, "set_output[1]"); 575 if (ret < 0) 576 goto failed; 577 } 578 /* enable_error_frame */ 579 /* 580 * Error reporting is switched off at the moment since 581 * the receiving of them is not yet 100% verified 582 * This should be enabled sooner or later 583 * 584 if (error_reporting) { 585 ret = softing_fct_cmd(card, 51, "enable_error_frame"); 586 if (ret < 0) 587 goto failed; 588 } 589 */ 590 /* initialize interface */ 591 iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 2]); 592 iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 4]); 593 iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 6]); 594 iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 8]); 595 iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 10]); 596 iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 12]); 597 iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 14]); 598 iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 16]); 599 iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 18]); 600 iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 20]); 601 ret = softing_fct_cmd(card, 17, "initialize_interface"); 602 if (ret < 0) 603 goto failed; 604 /* enable_fifo */ 605 ret = softing_fct_cmd(card, 36, "enable_fifo"); 606 if (ret < 0) 607 goto failed; 608 /* enable fifo tx ack */ 609 ret = softing_fct_cmd(card, 13, "fifo_tx_ack[0]"); 610 if (ret < 0) 611 goto failed; 612 /* enable fifo tx ack2 */ 613 ret = softing_fct_cmd(card, 14, "fifo_tx_ack[1]"); 614 if (ret < 0) 615 goto failed; 616 /* start_chip */ 617 ret = softing_fct_cmd(card, 11, "start_chip"); 618 if (ret < 0) 619 goto failed; 620 iowrite8(0, &card->dpram[DPRAM_INFO_BUSSTATE]); 621 iowrite8(0, &card->dpram[DPRAM_INFO_BUSSTATE2]); 622 if (card->pdat->generation < 2) { 623 iowrite8(0, &card->dpram[DPRAM_V2_IRQ_TOHOST]); 624 /* flush the DPRAM caches */ 625 wmb(); 626 } 627 628 softing_initialize_timestamp(card); 629 630 /* 631 * do socketcan notifications/status changes 632 * from here, no errors should occur, or the failed: part 633 * must be reviewed 634 */ 635 memset(&msg, 0, sizeof(msg)); 636 msg.can_id = CAN_ERR_FLAG | CAN_ERR_RESTARTED; 637 msg.can_dlc = CAN_ERR_DLC; 638 for (j = 0; j < ARRAY_SIZE(card->net); ++j) { 639 if (!(bus_bitmask_start & (1 << j))) 640 continue; 641 netdev = card->net[j]; 642 if (!netdev) 643 continue; 644 priv = netdev_priv(netdev); 645 priv->can.state = CAN_STATE_ERROR_ACTIVE; 646 open_candev(netdev); 647 if (dev != netdev) { 648 /* notify other busses on the restart */ 649 softing_netdev_rx(netdev, &msg, ktime_set(0, 0)); 650 ++priv->can.can_stats.restarts; 651 } 652 netif_wake_queue(netdev); 653 } 654 655 /* enable interrupts */ 656 ret = softing_enable_irq(card, 1); 657 if (ret) 658 goto failed; 659 card_done: 660 mutex_unlock(&card->fw.lock); 661 return 0; 662 invalid: 663 ret = -EINVAL; 664 failed: 665 softing_enable_irq(card, 0); 666 softing_reset_chip(card); 667 mutex_unlock(&card->fw.lock); 668 /* bring all other interfaces down */ 669 for (j = 0; j < ARRAY_SIZE(card->net); ++j) { 670 netdev = card->net[j]; 671 if (!netdev) 672 continue; 673 dev_close(netdev); 674 } 675 return ret; 676 } 677 678 int softing_default_output(struct net_device *netdev) 679 { 680 struct softing_priv *priv = netdev_priv(netdev); 681 struct softing *card = priv->card; 682 683 switch (priv->chip) { 684 case 1000: 685 return (card->pdat->generation < 2) ? 0xfb : 0xfa; 686 case 5: 687 return 0x60; 688 default: 689 return 0x40; 690 } 691 } 692