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 } 694