drivers/net/can/softing/softing_fw.c

   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 = reject_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 = reject_firmware(&fw, file, &card->pdev->dev);
 229         if (ret) {
 230                 dev_alert(&card->pdev->dev, "reject_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.can_dlc = 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 }