drivers/net/can/softing/softing_fw.c

   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 }