linux/drivers/net/can/softing/softing_fw.c
<<
>>
Prefs
   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, see <http://www.gnu.org/licenses/>.
  17 */
  18
  19#include <linux/firmware.h>
  20#include <linux/sched/signal.h>
  21#include <asm/div64.h>
  22#include <asm/io.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 */
  30static 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
  64static 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
  76int 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
 105static 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
 144int 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, *new_buf;
 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                        new_buf = krealloc(buf, buflen, GFP_KERNEL);
 202                        if (!new_buf) {
 203                                ret = -ENOMEM;
 204                                goto failed;
 205                        }
 206                        buf = new_buf;
 207                }
 208                /* verify record data */
 209                memcpy_fromio(buf, &dpram[addr + offset], len);
 210                if (memcmp(buf, dat, len)) {
 211                        /* is not ok */
 212                        dev_alert(&card->pdev->dev, "DPRAM readback failed\n");
 213                        ret = -EIO;
 214                        goto failed;
 215                }
 216        }
 217        if (!type_end)
 218                /* no end record seen */
 219                goto failed;
 220        ret = 0;
 221failed:
 222        kfree(buf);
 223        release_firmware(fw);
 224        if (ret < 0)
 225                dev_info(&card->pdev->dev, "firmware %s failed\n", file);
 226        return ret;
 227}
 228
 229int softing_load_app_fw(const char *file, struct softing *card)
 230{
 231        const struct firmware *fw;
 232        const uint8_t *mem, *end, *dat;
 233        int ret, j;
 234        uint16_t type, len;
 235        uint32_t addr, start_addr = 0;
 236        unsigned int sum, rx_sum;
 237        int8_t type_end = 0, type_entrypoint = 0;
 238
 239        ret = request_firmware(&fw, file, &card->pdev->dev);
 240        if (ret) {
 241                dev_alert(&card->pdev->dev, "request_firmware(%s) got %i\n",
 242                        file, ret);
 243                return ret;
 244        }
 245        dev_dbg(&card->pdev->dev, "firmware(%s) got %lu bytes\n",
 246                file, (unsigned long)fw->size);
 247        /* parse the firmware */
 248        mem = fw->data;
 249        end = &mem[fw->size];
 250        /* look for header record */
 251        ret = fw_parse(&mem, &type, &addr, &len, &dat);
 252        if (ret)
 253                goto failed;
 254        ret = -EINVAL;
 255        if (type != 0xffff) {
 256                dev_alert(&card->pdev->dev, "firmware starts with type 0x%x\n",
 257                        type);
 258                goto failed;
 259        }
 260        if (strncmp("Structured Binary Format, Softing GmbH", dat, len)) {
 261                dev_alert(&card->pdev->dev, "firmware string '%.*s' fault\n",
 262                                len, dat);
 263                goto failed;
 264        }
 265        /* ok, we had a header */
 266        while (mem < end) {
 267                ret = fw_parse(&mem, &type, &addr, &len, &dat);
 268                if (ret)
 269                        goto failed;
 270
 271                if (type == 3) {
 272                        /* start address */
 273                        start_addr = addr;
 274                        type_entrypoint = 1;
 275                        continue;
 276                } else if (type == 1) {
 277                        /* eof */
 278                        type_end = 1;
 279                        break;
 280                } else if (type != 0) {
 281                        dev_alert(&card->pdev->dev,
 282                                        "unknown record type 0x%04x\n", type);
 283                        ret = -EINVAL;
 284                        goto failed;
 285                }
 286
 287                /* regualar data */
 288                for (sum = 0, j = 0; j < len; ++j)
 289                        sum += dat[j];
 290                /* work in 16bit (target) */
 291                sum &= 0xffff;
 292
 293                memcpy_toio(&card->dpram[card->pdat->app.offs], dat, len);
 294                iowrite32(card->pdat->app.offs + card->pdat->app.addr,
 295                                &card->dpram[DPRAM_COMMAND + 2]);
 296                iowrite32(addr, &card->dpram[DPRAM_COMMAND + 6]);
 297                iowrite16(len, &card->dpram[DPRAM_COMMAND + 10]);
 298                iowrite8(1, &card->dpram[DPRAM_COMMAND + 12]);
 299                ret = softing_bootloader_command(card, 1, "loading app.");
 300                if (ret < 0)
 301                        goto failed;
 302                /* verify checksum */
 303                rx_sum = ioread16(&card->dpram[DPRAM_RECEIPT + 2]);
 304                if (rx_sum != sum) {
 305                        dev_alert(&card->pdev->dev, "SRAM seems to be damaged"
 306                                ", wanted 0x%04x, got 0x%04x\n", sum, rx_sum);
 307                        ret = -EIO;
 308                        goto failed;
 309                }
 310        }
 311        if (!type_end || !type_entrypoint)
 312                goto failed;
 313        /* start application in card */
 314        iowrite32(start_addr, &card->dpram[DPRAM_COMMAND + 2]);
 315        iowrite8(1, &card->dpram[DPRAM_COMMAND + 6]);
 316        ret = softing_bootloader_command(card, 3, "start app.");
 317        if (ret < 0)
 318                goto failed;
 319        ret = 0;
 320failed:
 321        release_firmware(fw);
 322        if (ret < 0)
 323                dev_info(&card->pdev->dev, "firmware %s failed\n", file);
 324        return ret;
 325}
 326
 327static int softing_reset_chip(struct softing *card)
 328{
 329        int ret;
 330
 331        do {
 332                /* reset chip */
 333                iowrite8(0, &card->dpram[DPRAM_RESET_RX_FIFO]);
 334                iowrite8(0, &card->dpram[DPRAM_RESET_RX_FIFO+1]);
 335                iowrite8(1, &card->dpram[DPRAM_RESET]);
 336                iowrite8(0, &card->dpram[DPRAM_RESET+1]);
 337
 338                ret = softing_fct_cmd(card, 0, "reset_can");
 339                if (!ret)
 340                        break;
 341                if (signal_pending(current))
 342                        /* don't wait any longer */
 343                        break;
 344        } while (1);
 345        card->tx.pending = 0;
 346        return ret;
 347}
 348
 349int softing_chip_poweron(struct softing *card)
 350{
 351        int ret;
 352        /* sync */
 353        ret = _softing_fct_cmd(card, 99, 0x55, "sync-a");
 354        if (ret < 0)
 355                goto failed;
 356
 357        ret = _softing_fct_cmd(card, 99, 0xaa, "sync-b");
 358        if (ret < 0)
 359                goto failed;
 360
 361        ret = softing_reset_chip(card);
 362        if (ret < 0)
 363                goto failed;
 364        /* get_serial */
 365        ret = softing_fct_cmd(card, 43, "get_serial_number");
 366        if (ret < 0)
 367                goto failed;
 368        card->id.serial = ioread32(&card->dpram[DPRAM_FCT_PARAM]);
 369        /* get_version */
 370        ret = softing_fct_cmd(card, 12, "get_version");
 371        if (ret < 0)
 372                goto failed;
 373        card->id.fw_version = ioread16(&card->dpram[DPRAM_FCT_PARAM + 2]);
 374        card->id.hw_version = ioread16(&card->dpram[DPRAM_FCT_PARAM + 4]);
 375        card->id.license = ioread16(&card->dpram[DPRAM_FCT_PARAM + 6]);
 376        card->id.chip[0] = ioread16(&card->dpram[DPRAM_FCT_PARAM + 8]);
 377        card->id.chip[1] = ioread16(&card->dpram[DPRAM_FCT_PARAM + 10]);
 378        return 0;
 379failed:
 380        return ret;
 381}
 382
 383static void softing_initialize_timestamp(struct softing *card)
 384{
 385        uint64_t ovf;
 386
 387        card->ts_ref = ktime_get();
 388
 389        /* 16MHz is the reference */
 390        ovf = 0x100000000ULL * 16;
 391        do_div(ovf, card->pdat->freq ?: 16);
 392
 393        card->ts_overflow = ktime_add_us(0, ovf);
 394}
 395
 396ktime_t softing_raw2ktime(struct softing *card, u32 raw)
 397{
 398        uint64_t rawl;
 399        ktime_t now, real_offset;
 400        ktime_t target;
 401        ktime_t tmp;
 402
 403        now = ktime_get();
 404        real_offset = ktime_sub(ktime_get_real(), now);
 405
 406        /* find nsec from card */
 407        rawl = raw * 16;
 408        do_div(rawl, card->pdat->freq ?: 16);
 409        target = ktime_add_us(card->ts_ref, rawl);
 410        /* test for overflows */
 411        tmp = ktime_add(target, card->ts_overflow);
 412        while (unlikely(ktime_to_ns(tmp) > ktime_to_ns(now))) {
 413                card->ts_ref = ktime_add(card->ts_ref, card->ts_overflow);
 414                target = tmp;
 415                tmp = ktime_add(target, card->ts_overflow);
 416        }
 417        return ktime_add(target, real_offset);
 418}
 419
 420static inline int softing_error_reporting(struct net_device *netdev)
 421{
 422        struct softing_priv *priv = netdev_priv(netdev);
 423
 424        return (priv->can.ctrlmode & CAN_CTRLMODE_BERR_REPORTING)
 425                ? 1 : 0;
 426}
 427
 428int softing_startstop(struct net_device *dev, int up)
 429{
 430        int ret;
 431        struct softing *card;
 432        struct softing_priv *priv;
 433        struct net_device *netdev;
 434        int bus_bitmask_start;
 435        int j, error_reporting;
 436        struct can_frame msg;
 437        const struct can_bittiming *bt;
 438
 439        priv = netdev_priv(dev);
 440        card = priv->card;
 441
 442        if (!card->fw.up)
 443                return -EIO;
 444
 445        ret = mutex_lock_interruptible(&card->fw.lock);
 446        if (ret)
 447                return ret;
 448
 449        bus_bitmask_start = 0;
 450        if (dev && up)
 451                /* prepare to start this bus as well */
 452                bus_bitmask_start |= (1 << priv->index);
 453        /* bring netdevs down */
 454        for (j = 0; j < ARRAY_SIZE(card->net); ++j) {
 455                netdev = card->net[j];
 456                if (!netdev)
 457                        continue;
 458                priv = netdev_priv(netdev);
 459
 460                if (dev != netdev)
 461                        netif_stop_queue(netdev);
 462
 463                if (netif_running(netdev)) {
 464                        if (dev != netdev)
 465                                bus_bitmask_start |= (1 << j);
 466                        priv->tx.pending = 0;
 467                        priv->tx.echo_put = 0;
 468                        priv->tx.echo_get = 0;
 469                        /*
 470                         * this bus' may just have called open_candev()
 471                         * which is rather stupid to call close_candev()
 472                         * already
 473                         * but we may come here from busoff recovery too
 474                         * in which case the echo_skb _needs_ flushing too.
 475                         * just be sure to call open_candev() again
 476                         */
 477                        close_candev(netdev);
 478                }
 479                priv->can.state = CAN_STATE_STOPPED;
 480        }
 481        card->tx.pending = 0;
 482
 483        softing_enable_irq(card, 0);
 484        ret = softing_reset_chip(card);
 485        if (ret)
 486                goto failed;
 487        if (!bus_bitmask_start)
 488                /* no busses to be brought up */
 489                goto card_done;
 490
 491        if ((bus_bitmask_start & 1) && (bus_bitmask_start & 2)
 492                        && (softing_error_reporting(card->net[0])
 493                                != softing_error_reporting(card->net[1]))) {
 494                dev_alert(&card->pdev->dev,
 495                                "err_reporting flag differs for busses\n");
 496                goto invalid;
 497        }
 498        error_reporting = 0;
 499        if (bus_bitmask_start & 1) {
 500                netdev = card->net[0];
 501                priv = netdev_priv(netdev);
 502                error_reporting += softing_error_reporting(netdev);
 503                /* init chip 1 */
 504                bt = &priv->can.bittiming;
 505                iowrite16(bt->brp, &card->dpram[DPRAM_FCT_PARAM + 2]);
 506                iowrite16(bt->sjw, &card->dpram[DPRAM_FCT_PARAM + 4]);
 507                iowrite16(bt->phase_seg1 + bt->prop_seg,
 508                                &card->dpram[DPRAM_FCT_PARAM + 6]);
 509                iowrite16(bt->phase_seg2, &card->dpram[DPRAM_FCT_PARAM + 8]);
 510                iowrite16((priv->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES) ? 1 : 0,
 511                                &card->dpram[DPRAM_FCT_PARAM + 10]);
 512                ret = softing_fct_cmd(card, 1, "initialize_chip[0]");
 513                if (ret < 0)
 514                        goto failed;
 515                /* set mode */
 516                iowrite16(0, &card->dpram[DPRAM_FCT_PARAM + 2]);
 517                iowrite16(0, &card->dpram[DPRAM_FCT_PARAM + 4]);
 518                ret = softing_fct_cmd(card, 3, "set_mode[0]");
 519                if (ret < 0)
 520                        goto failed;
 521                /* set filter */
 522                /* 11bit id & mask */
 523                iowrite16(0x0000, &card->dpram[DPRAM_FCT_PARAM + 2]);
 524                iowrite16(0x07ff, &card->dpram[DPRAM_FCT_PARAM + 4]);
 525                /* 29bit id.lo & mask.lo & id.hi & mask.hi */
 526                iowrite16(0x0000, &card->dpram[DPRAM_FCT_PARAM + 6]);
 527                iowrite16(0xffff, &card->dpram[DPRAM_FCT_PARAM + 8]);
 528                iowrite16(0x0000, &card->dpram[DPRAM_FCT_PARAM + 10]);
 529                iowrite16(0x1fff, &card->dpram[DPRAM_FCT_PARAM + 12]);
 530                ret = softing_fct_cmd(card, 7, "set_filter[0]");
 531                if (ret < 0)
 532                        goto failed;
 533                /* set output control */
 534                iowrite16(priv->output, &card->dpram[DPRAM_FCT_PARAM + 2]);
 535                ret = softing_fct_cmd(card, 5, "set_output[0]");
 536                if (ret < 0)
 537                        goto failed;
 538        }
 539        if (bus_bitmask_start & 2) {
 540                netdev = card->net[1];
 541                priv = netdev_priv(netdev);
 542                error_reporting += softing_error_reporting(netdev);
 543                /* init chip2 */
 544                bt = &priv->can.bittiming;
 545                iowrite16(bt->brp, &card->dpram[DPRAM_FCT_PARAM + 2]);
 546                iowrite16(bt->sjw, &card->dpram[DPRAM_FCT_PARAM + 4]);
 547                iowrite16(bt->phase_seg1 + bt->prop_seg,
 548                                &card->dpram[DPRAM_FCT_PARAM + 6]);
 549                iowrite16(bt->phase_seg2, &card->dpram[DPRAM_FCT_PARAM + 8]);
 550                iowrite16((priv->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES) ? 1 : 0,
 551                                &card->dpram[DPRAM_FCT_PARAM + 10]);
 552                ret = softing_fct_cmd(card, 2, "initialize_chip[1]");
 553                if (ret < 0)
 554                        goto failed;
 555                /* set mode2 */
 556                iowrite16(0, &card->dpram[DPRAM_FCT_PARAM + 2]);
 557                iowrite16(0, &card->dpram[DPRAM_FCT_PARAM + 4]);
 558                ret = softing_fct_cmd(card, 4, "set_mode[1]");
 559                if (ret < 0)
 560                        goto failed;
 561                /* set filter2 */
 562                /* 11bit id & mask */
 563                iowrite16(0x0000, &card->dpram[DPRAM_FCT_PARAM + 2]);
 564                iowrite16(0x07ff, &card->dpram[DPRAM_FCT_PARAM + 4]);
 565                /* 29bit id.lo & mask.lo & id.hi & mask.hi */
 566                iowrite16(0x0000, &card->dpram[DPRAM_FCT_PARAM + 6]);
 567                iowrite16(0xffff, &card->dpram[DPRAM_FCT_PARAM + 8]);
 568                iowrite16(0x0000, &card->dpram[DPRAM_FCT_PARAM + 10]);
 569                iowrite16(0x1fff, &card->dpram[DPRAM_FCT_PARAM + 12]);
 570                ret = softing_fct_cmd(card, 8, "set_filter[1]");
 571                if (ret < 0)
 572                        goto failed;
 573                /* set output control2 */
 574                iowrite16(priv->output, &card->dpram[DPRAM_FCT_PARAM + 2]);
 575                ret = softing_fct_cmd(card, 6, "set_output[1]");
 576                if (ret < 0)
 577                        goto failed;
 578        }
 579        /* enable_error_frame */
 580        /*
 581         * Error reporting is switched off at the moment since
 582         * the receiving of them is not yet 100% verified
 583         * This should be enabled sooner or later
 584         *
 585        if (error_reporting) {
 586                ret = softing_fct_cmd(card, 51, "enable_error_frame");
 587                if (ret < 0)
 588                        goto failed;
 589        }
 590        */
 591        /* initialize interface */
 592        iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 2]);
 593        iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 4]);
 594        iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 6]);
 595        iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 8]);
 596        iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 10]);
 597        iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 12]);
 598        iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 14]);
 599        iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 16]);
 600        iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 18]);
 601        iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 20]);
 602        ret = softing_fct_cmd(card, 17, "initialize_interface");
 603        if (ret < 0)
 604                goto failed;
 605        /* enable_fifo */
 606        ret = softing_fct_cmd(card, 36, "enable_fifo");
 607        if (ret < 0)
 608                goto failed;
 609        /* enable fifo tx ack */
 610        ret = softing_fct_cmd(card, 13, "fifo_tx_ack[0]");
 611        if (ret < 0)
 612                goto failed;
 613        /* enable fifo tx ack2 */
 614        ret = softing_fct_cmd(card, 14, "fifo_tx_ack[1]");
 615        if (ret < 0)
 616                goto failed;
 617        /* start_chip */
 618        ret = softing_fct_cmd(card, 11, "start_chip");
 619        if (ret < 0)
 620                goto failed;
 621        iowrite8(0, &card->dpram[DPRAM_INFO_BUSSTATE]);
 622        iowrite8(0, &card->dpram[DPRAM_INFO_BUSSTATE2]);
 623        if (card->pdat->generation < 2) {
 624                iowrite8(0, &card->dpram[DPRAM_V2_IRQ_TOHOST]);
 625                /* flush the DPRAM caches */
 626                wmb();
 627        }
 628
 629        softing_initialize_timestamp(card);
 630
 631        /*
 632         * do socketcan notifications/status changes
 633         * from here, no errors should occur, or the failed: part
 634         * must be reviewed
 635         */
 636        memset(&msg, 0, sizeof(msg));
 637        msg.can_id = CAN_ERR_FLAG | CAN_ERR_RESTARTED;
 638        msg.can_dlc = CAN_ERR_DLC;
 639        for (j = 0; j < ARRAY_SIZE(card->net); ++j) {
 640                if (!(bus_bitmask_start & (1 << j)))
 641                        continue;
 642                netdev = card->net[j];
 643                if (!netdev)
 644                        continue;
 645                priv = netdev_priv(netdev);
 646                priv->can.state = CAN_STATE_ERROR_ACTIVE;
 647                open_candev(netdev);
 648                if (dev != netdev) {
 649                        /* notify other busses on the restart */
 650                        softing_netdev_rx(netdev, &msg, 0);
 651                        ++priv->can.can_stats.restarts;
 652                }
 653                netif_wake_queue(netdev);
 654        }
 655
 656        /* enable interrupts */
 657        ret = softing_enable_irq(card, 1);
 658        if (ret)
 659                goto failed;
 660card_done:
 661        mutex_unlock(&card->fw.lock);
 662        return 0;
 663invalid:
 664        ret = -EINVAL;
 665failed:
 666        softing_enable_irq(card, 0);
 667        softing_reset_chip(card);
 668        mutex_unlock(&card->fw.lock);
 669        /* bring all other interfaces down */
 670        for (j = 0; j < ARRAY_SIZE(card->net); ++j) {
 671                netdev = card->net[j];
 672                if (!netdev)
 673                        continue;
 674                dev_close(netdev);
 675        }
 676        return ret;
 677}
 678
 679int softing_default_output(struct net_device *netdev)
 680{
 681        struct softing_priv *priv = netdev_priv(netdev);
 682        struct softing *card = priv->card;
 683
 684        switch (priv->chip) {
 685        case 1000:
 686                return (card->pdat->generation < 2) ? 0xfb : 0xfa;
 687        case 5:
 688                return 0x60;
 689        default:
 690                return 0x40;
 691        }
 692}
 693