kernel/2.6/drivers/net/can/softing/softing_fw.c

   1 /*
   2 * drivers/net/can/softing/softing_fw.c
   3 *
   4 * Copyright (C) 2008
   5 *
   6 * - Kurt Van Dijck, EIA Electronics
   7 *
   8 * This program is free software; you can redistribute it and/or modify
   9 * it under the terms of the version 2 of the GNU General Public License
  10 * as published by the Free Software Foundation
  11 *
  12 * This program is distributed in the hope that it will be useful,
  13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  15 * GNU General Public License for more details.
  16 *
  17 * You should have received a copy of the GNU General Public License
  18 * along with this program; if not, write to the Free Software
  19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  20 */
  21
  22 #include <linux/module.h>
  23 #include <linux/init.h>
  24 #include <linux/device.h>
  25 #include <linux/firmware.h>
  26 #include <linux/interrupt.h>
  27 #include <linux/mutex.h>
  28 #include <linux/io.h>
  29
  30 #include "softing.h"
  31
  32 #define fw_dir "softing-4.6/"
  33
  34 const struct can_bittiming_const softing_btr_const = {
  35         .tseg1_min = 1,
  36         .tseg1_max = 16,
  37         .tseg2_min = 1,
  38         .tseg2_max = 8,
  39         .sjw_max = 4, /* overruled */
  40         .brp_min = 1,
  41         .brp_max = 32, /* overruled */
  42         .brp_inc = 1,
  43 };
  44
  45 static const struct softing_desc carddescs[] = {
  46 {
  47         .name = "CANcard",
  48         .manf = 0x0168, .prod = 0x001,
  49         .generation = 1,
  50         .freq = 16, .max_brp = 32, .max_sjw = 4,
  51         .dpram_size = 0x0800,
  52         .boot = {0x0000, 0x000000, fw_dir "bcard.bin",},
  53         .load = {0x0120, 0x00f600, fw_dir "ldcard.bin",},
  54         .app = {0x0010, 0x0d0000, fw_dir "cancard.bin",},
  55 }, {
  56         .name = "CANcard-NEC",
  57         .manf = 0x0168, .prod = 0x002,
  58         .generation = 1,
  59         .freq = 16, .max_brp = 32, .max_sjw = 4,
  60         .dpram_size = 0x0800,
  61         .boot = {0x0000, 0x000000, fw_dir "bcard.bin",},
  62         .load = {0x0120, 0x00f600, fw_dir "ldcard.bin",},
  63         .app = {0x0010, 0x0d0000, fw_dir "cancard.bin",},
  64 }, {
  65         .name = "CANcard-SJA",
  66         .manf = 0x0168, .prod = 0x004,
  67         .generation = 1,
  68         .freq = 20, .max_brp = 32, .max_sjw = 4,
  69         .dpram_size = 0x0800,
  70         .boot = {0x0000, 0x000000, fw_dir "bcard.bin",},
  71         .load = {0x0120, 0x00f600, fw_dir "ldcard.bin",},
  72         .app = {0x0010, 0x0d0000, fw_dir "cansja.bin",},
  73 }, {
  74         .name = "CANcard-2",
  75         .manf = 0x0168, .prod = 0x005,
  76         .generation = 2,
  77         .freq = 24, .max_brp = 64, .max_sjw = 4,
  78         .dpram_size = 0x0800,
  79         .boot = {0x0000, 0x000000, fw_dir "bcard2.bin",},
  80         .load = {0x0120, 0x00f600, fw_dir "ldcard2.bin",},
  81         .app = {0x0010, 0x0d0000, fw_dir "cancrd2.bin",},
  82 }, {
  83         .name = "Vector-CANcard",
  84         .manf = 0x0168, .prod = 0x081,
  85         .generation = 1,
  86         .freq = 16, .max_brp = 64, .max_sjw = 4,
  87         .dpram_size = 0x0800,
  88         .boot = {0x0000, 0x000000, fw_dir "bcard.bin",},
  89         .load = {0x0120, 0x00f600, fw_dir "ldcard.bin",},
  90         .app = {0x0010, 0x0d0000, fw_dir "cancard.bin",},
  91 }, {
  92         .name = "Vector-CANcard-SJA",
  93         .manf = 0x0168, .prod = 0x084,
  94         .generation = 1,
  95         .freq = 20, .max_brp = 32, .max_sjw = 4,
  96         .dpram_size = 0x0800,
  97         .boot = {0x0000, 0x000000, fw_dir "bcard.bin",},
  98         .load = {0x0120, 0x00f600, fw_dir "ldcard.bin",},
  99         .app = {0x0010, 0x0d0000, fw_dir "cansja.bin",},
 100 }, {
 101         .name = "Vector-CANcard-2",
 102         .manf = 0x0168, .prod = 0x085,
 103         .generation = 2,
 104         .freq = 24, .max_brp = 64, .max_sjw = 4,
 105         .dpram_size = 0x0800,
 106         .boot = {0x0000, 0x000000, fw_dir "bcard2.bin",},
 107         .load = {0x0120, 0x00f600, fw_dir "ldcard2.bin",},
 108         .app = {0x0010, 0x0d0000, fw_dir "cancrd2.bin",},
 109 }, {
 110         .name = "EDICcard-NEC",
 111         .manf = 0x0168, .prod = 0x102,
 112         .generation = 1,
 113         .freq = 16, .max_brp = 64, .max_sjw = 4,
 114         .dpram_size = 0x0800,
 115         .boot = {0x0000, 0x000000, fw_dir "bcard.bin",},
 116         .load = {0x0120, 0x00f600, fw_dir "ldcard.bin",},
 117         .app = {0x0010, 0x0d0000, fw_dir "cancard.bin",},
 118 }, {
 119         .name = "EDICcard-2",
 120         .manf = 0x0168, .prod = 0x105,
 121         .generation = 2,
 122         .freq = 24, .max_brp = 64, .max_sjw = 4,
 123         .dpram_size = 0x0800,
 124         .boot = {0x0000, 0x000000, fw_dir "bcard2.bin",},
 125         .load = {0x0120, 0x00f600, fw_dir "ldcard2.bin",},
 126         .app = {0x0010, 0x0d0000, fw_dir "cancrd2.bin",},
 127         },
 128
 129 /* never tested, but taken from original softing */
 130 {       .name = "CAN-AC2-104",
 131         .manf = 0x0000, .prod = 0x009,
 132         .generation = 1,
 133         .freq = 25, .max_brp = 64, .max_sjw = 4,
 134         .dpram_size = 0x1000,
 135         .boot = {0x0000, 0x000000, fw_dir "boot104.bin",},
 136         .load = {0x0800, 0x035000, fw_dir "ld104.bin",},
 137         .app = {0x0010, 0x120000, fw_dir "canpc104.bin",},
 138         },
 139 {0, 0,},
 140 };
 141
 142 const struct softing_desc *softing_lookup_desc
 143                                         (unsigned int manf, unsigned int prod)
 144 {
 145         const struct softing_desc *lp = carddescs;
 146         for (; lp->name; ++lp) {
 147                 if ((lp->manf == manf) && (lp->prod == prod))
 148                         return lp;
 149         }
 150         return 0;
 151 }
 152 EXPORT_SYMBOL(softing_lookup_desc);
 153
 154 int softing_fct_cmd(struct softing *card, int cmd, int vector, const char *msg)
 155 {
 156         int ret;
 157         unsigned long stamp;
 158         if (vector == RES_OK)
 159                 vector = RES_NONE;
 160         card->dpram.fct->param[0] = cmd;
 161         card->dpram.fct->host_access = vector;
 162         /* be sure to flush this to the card */
 163         wmb();
 164         stamp = jiffies;
 165         /*wait for card */
 166         do {
 167                 ret = card->dpram.fct->host_access;
 168                 /* don't have any cached variables */
 169                 rmb();
 170                 if (ret == RES_OK) {
 171                         /*don't read return-value now */
 172                         ret = card->dpram.fct->returned;
 173                         if (ret)
 174                                 dev_alert(card->dev,
 175                                         "%s returned %u\n", msg, ret);
 176                         return 0;
 177                 }
 178                 if ((jiffies - stamp) >= 1 * HZ)
 179                         break;
 180                 if (in_interrupt())
 181                         /* go as fast as possible */
 182                         continue;
 183                 /* process context => relax */
 184                 schedule();
 185         } while (!signal_pending(current));
 186
 187         if (ret == RES_NONE) {
 188                 dev_alert(card->dev,
 189                         "%s, no response from card on %u/0x%02x\n",
 190                         msg, cmd, vector);
 191                 return 1;
 192         } else {
 193                 dev_alert(card->dev,
 194                         "%s, bad response from card on %u/0x%02x, 0x%04x\n",
 195                         msg, cmd, vector, ret);
 196                 /*make sure to return something not 0 */
 197                 return ret ? ret : 1;
 198         }
 199 }
 200
 201 int softing_bootloader_command(struct softing *card
 202                 , int command, const char *msg)
 203 {
 204         int ret;
 205         unsigned long stamp;
 206         card->dpram.receipt[0] = RES_NONE;
 207         card->dpram.command[0] = command;
 208         /* be sure to flush this to the card */
 209         wmb();
 210         stamp = jiffies;
 211         /*wait for card */
 212         do {
 213                 ret = card->dpram.receipt[0];
 214                 /* don't have any cached variables */
 215                 rmb();
 216                 if (ret == RES_OK)
 217                         return 0;
 218                 if ((jiffies - stamp) >= (3 * HZ))
 219                         break;
 220                 schedule();
 221         } while (!signal_pending(current));
 222
 223         switch (ret) {
 224         case RES_NONE:
 225                 dev_alert(card->dev, "%s: no response from card\n", msg);
 226                 break;
 227         case RES_NOK:
 228                 dev_alert(card->dev, "%s: response from card nok\n", msg);
 229                 break;
 230         case RES_UNKNOWN:
 231                 dev_alert(card->dev, "%s: command 0x%04x unknown\n",
 232                         msg, command);
 233                 break;
 234         default:
 235                 dev_alert(card->dev, "%s: bad response from card (%u)]\n",
 236                         msg, ret);
 237                 break;
 238         }
 239         return ret ? ret : 1;
 240 }
 241
 242 struct fw_hdr {
 243         u16 type;
 244         u32 addr;
 245         u16 len;
 246         u16 checksum;
 247         const unsigned char *base;
 248 } __attribute__ ((packed));
 249
 250 static int fw_parse(const unsigned char **pmem, struct fw_hdr *hdr)
 251 {
 252         u16 tmp;
 253         const unsigned char *mem;
 254         const unsigned char *end;
 255         mem = *pmem;
 256         hdr->type = (mem[0] << 0) | (mem[1] << 8);
 257         hdr->addr = (mem[2] << 0) | (mem[3] << 8)
 258                  | (mem[4] << 16) | (mem[5] << 24);
 259         hdr->len = (mem[6] << 0) | (mem[7] << 8);
 260         hdr->base = &mem[8];
 261         hdr->checksum =
 262                  (hdr->base[hdr->len] << 0) | (hdr->base[hdr->len + 1] << 8);
 263         for (tmp = 0, mem = *pmem, end = &hdr->base[hdr->len]; mem < end; ++mem)
 264                 tmp += *mem;
 265         if (tmp != hdr->checksum)
 266                 return EINVAL;
 267         *pmem += 10 + hdr->len;
 268         return 0;
 269 }
 270
 271 int softing_load_fw(const char *file, struct softing *card,
 272                         unsigned char *virt, unsigned int size, int offset)
 273 {
 274         const struct firmware *fw;
 275         const unsigned char *mem;
 276         const unsigned char *end;
 277         int ret;
 278         u32 start_addr;
 279         struct fw_hdr rec;
 280         int ok = 0;
 281         unsigned char buf[1024];
 282
 283         ret = request_firmware(&fw, file, card->dev);
 284         if (ret) {
 285                 dev_alert(card->dev, "request_firmware(%s) got %i\n",
 286                         file, ret);
 287                 return ret;
 288         }
 289         dev_dbg(card->dev, "%s, firmware(%s) got %u bytes"
 290                 ", offset %c0x%04x\n",
 291                 card->id.name, file, (unsigned int)fw->size,
 292                 (offset >= 0) ? '+' : '-', abs(offset));
 293         /* parse the firmware */
 294         mem = fw->data;
 295         end = &mem[fw->size];
 296         /* look for header record */
 297         if (fw_parse(&mem, &rec))
 298                 goto fw_end;
 299         if (rec.type != 0xffff) {
 300                 dev_alert(card->dev, "firware starts with type 0x%04x\n",
 301                         rec.type);
 302                 goto fw_end;
 303         }
 304         if (strncmp("Structured Binary Format, Softing GmbH"
 305                         , rec.base, rec.len)) {
 306                 dev_info(card->dev, "firware string '%.*s'\n",
 307                         rec.len, rec.base);
 308                 goto fw_end;
 309         }
 310         ok |= 1;
 311         /* ok, we had a header */
 312         while (mem < end) {
 313                 if (fw_parse(&mem, &rec))
 314                         break;
 315                 if (rec.type == 3) {
 316                         /*start address */
 317                         start_addr = rec.addr;
 318                         ok |= 2;
 319                         continue;
 320                 } else if (rec.type == 1) {
 321                         /*eof */
 322                         ok |= 4;
 323                         goto fw_end;
 324                 } else if (rec.type != 0) {
 325                         dev_alert(card->dev, "unknown record type 0x%04x\n",
 326                                 rec.type);
 327                         break;
 328                 }
 329
 330                 if ((rec.addr + rec.len + offset) > size) {
 331                         dev_alert(card->dev,
 332                                 "firmware out of range (0x%08x / 0x%08x)\n",
 333                                 (rec.addr + rec.len + offset), size);
 334                         goto fw_end;
 335                 }
 336                 memcpy_toio(&virt[rec.addr + offset],
 337                                  rec.base, rec.len);
 338                 /* be sure to flush caches from IO space */
 339                 mb();
 340                 if (rec.len > sizeof(buf)) {
 341                         dev_info(card->dev,
 342                                 "record is big (%u bytes), not verifying\n",
 343                                 rec.len);
 344                         continue;
 345                 }
 346                 /* verify record data */
 347                 memcpy_fromio(buf, &virt[rec.addr + offset], rec.len);
 348                 if (!memcmp(buf, rec.base, rec.len))
 349                         /* is ok */
 350                         continue;
 351                 dev_alert(card->dev, "0x%08x:0x%03x at 0x%p failed\n",
 352                         rec.addr, rec.len, &virt[rec.addr + offset]);
 353                 goto fw_end;
 354         }
 355 fw_end:
 356         release_firmware(fw);
 357         if (0x5 == (ok & 0x5)) {
 358                 /*got eof & start */
 359                 return 0;
 360         }
 361         dev_info(card->dev, "firmware %s failed\n", file);
 362         return EINVAL;
 363 }
 364
 365 int softing_load_app_fw(const char *file, struct softing *card)
 366 {
 367         const struct firmware *fw;
 368         const unsigned char *mem;
 369         const unsigned char *end;
 370         int ret;
 371         struct fw_hdr rec;
 372         int ok = 0;
 373         u32 start_addr = 0;
 374         u16 rx_sum;
 375         unsigned int sum;
 376         const unsigned char *mem_lp;
 377         const unsigned char *mem_end;
 378         struct cpy {
 379                 u32 src;
 380                 u32 dst;
 381                 u16 len;
 382                 u8 do_cs;
 383         } __attribute__((packed)) *pcpy =
 384                  (struct cpy *)&card->dpram.command[1];
 385         struct cmd {
 386                 u32 start;
 387                 u8 autorestart;
 388         } __attribute__((packed)) *pcmdstart =
 389                 (struct cmd *)&card->dpram.command[1];
 390
 391         ret = request_firmware(&fw, file, card->dev);
 392         if (ret) {
 393                 dev_alert(card->dev, "request_firmware(%s) got %i\n",
 394                         file, ret);
 395                 return ret;
 396         }
 397         dev_dbg(card->dev, "%s, firmware(%s) got %lu bytes\n",
 398                 card->id.name, file, (unsigned long)fw->size);
 399         /* parse the firmware */
 400         mem = fw->data;
 401         end = &mem[fw->size];
 402         /* look for header record */
 403         if (fw_parse(&mem, &rec))
 404                 goto fw_end;
 405         if (rec.type != 0xffff) {
 406                 dev_alert(card->dev, "firware starts with type 0x%04x\n",
 407                         rec.type);
 408                 goto fw_end;
 409         }
 410         if (strncmp("Structured Binary Format, Softing GmbH"
 411                 , rec.base, rec.len)) {
 412                 dev_alert(card->dev, "firware string '%.*s' fault\n",
 413                         rec.len, rec.base);
 414                 goto fw_end;
 415         }
 416         ok |= 1;
 417         /* ok, we had a header */
 418         while (mem < end) {
 419                 if (fw_parse(&mem, &rec))
 420                         break;
 421
 422                 if (rec.type == 3) {
 423                         /*start address */
 424                         start_addr = rec.addr;
 425                         ok |= 2;
 426                         continue;
 427                 } else if (rec.type == 1) {
 428                         /*eof */
 429                         ok |= 4;
 430                         goto fw_end;
 431                 } else if (rec.type != 0) {
 432                         dev_alert(card->dev, "unknown record type 0x%04x\n",
 433                                 rec.type);
 434                         break;
 435                 }
 436                 /* regualar data */
 437                 for (sum = 0, mem_lp = rec.base, mem_end = &mem_lp[rec.len];
 438                         mem_lp < mem_end; ++mem_lp)
 439                         sum += *mem_lp;
 440
 441                 memcpy_toio(&card->dpram. virt[card->desc->app.offs],
 442                                  rec.base, rec.len);
 443                 pcpy->src = card->desc->app.offs + card->desc->app.addr;
 444                 pcpy->dst = rec.addr;
 445                 pcpy->len = rec.len;
 446                 pcpy->do_cs = 1;
 447                 if (softing_bootloader_command(card, 1, "loading app."))
 448                         goto fw_end;
 449                 /*verify checksum */
 450                 rx_sum = card->dpram.receipt[1];
 451                 if (rx_sum != (sum & 0xffff)) {
 452                         dev_alert(card->dev, "SRAM seems to be damaged"
 453                                 ", wanted 0x%04x, got 0x%04x\n", sum, rx_sum);
 454                         goto fw_end;
 455                 }
 456         }
 457 fw_end:
 458         release_firmware(fw);
 459         if (ok != 7)
 460                 goto fw_failed;
 461         /*got start, start_addr, & eof */
 462         pcmdstart->start = start_addr;
 463         pcmdstart->autorestart = 1;
 464         if (softing_bootloader_command(card, 3, "start app."))
 465                 goto fw_failed;
 466         dev_info(card->dev, "firmware %s up\n", file);
 467         return 0;
 468 fw_failed:
 469         dev_info(card->dev, "firmware %s failed\n", file);
 470         return EINVAL;
 471 }
 472
 473 int softing_reset_chip(struct softing *card)
 474 {
 475         do {
 476                 /*reset chip */
 477                 card->dpram.info->reset_rcv_fifo = 0;
 478                 card->dpram.info->reset = 1;
 479                 if (!softing_fct_cmd(card, 0, 0, "reset_chip"))
 480                         break;
 481                 if (signal_pending(current))
 482                         goto failed;
 483                 /*sync */
 484                 if (softing_fct_cmd(card, 99, 0x55, "sync-a"))
 485                         goto failed;
 486                 if (softing_fct_cmd(card, 99, 0xaa, "sync-a"))
 487                         goto failed;
 488         } while (1);
 489         card->tx.pending = 0;
 490         return 0;
 491 failed:
 492         return -EIO;
 493 }
 494
 495 int softing_cycle(struct softing *card, struct softing_priv *bus, int up)
 496 {
 497         int ret;
 498         struct softing_priv *pbus;
 499         int mask_start;
 500         int j;
 501         struct can_frame msg;
 502
 503         if (!card->fw.up)
 504                 return -EIO;
 505
 506         ret = mutex_lock_interruptible(&card->fw.lock);
 507         if (ret)
 508                 return ret;
 509         if (card->fw.failed)
 510                 goto failed_already;
 511
 512         mask_start = 0;
 513         /* bring netdevs down */
 514         for (j = 0; j < card->nbus; ++j) {
 515                 pbus = card->bus[j];
 516                 if (!pbus)
 517                         continue;
 518
 519                 if (bus != pbus)
 520                         netif_stop_queue(pbus->netdev);
 521
 522                 if ((bus != pbus) && netif_running(pbus->netdev))
 523                         mask_start |= (1 << j);
 524                 if (netif_running(pbus->netdev)) {
 525                         pbus->tx.pending = 0;
 526                         pbus->tx.echo_put = 0;
 527                         pbus->tx.echo_get = 0;
 528                         /* this bus' may just have called open_candev()
 529                          * which is rather stupid to call close_candev()
 530                          * already
 531                          * but we may come here from busoff recovery too
 532                          * in which case the echo_skb _needs_ flushing too.
 533                          * just be sure to call open_candev() again
 534                          */
 535                         close_candev(pbus->netdev);
 536                 }
 537                 pbus->can.state = CAN_STATE_STOPPED;
 538         }
 539         card->tx.pending = 0;
 540         if (bus && up)
 541                 /* prepare to start this bus as well */
 542                 mask_start |= (1 << bus->index);
 543
 544         softing_card_irq(card, 0);
 545         ret = softing_reset_chip(card);
 546         if (ret)
 547                 goto failed;
 548         if (!mask_start)
 549                 /* no busses to be brought up */
 550                 goto card_done;
 551
 552         /* from here, we must jump to failed: */
 553
 554         if (mask_start & 1) {
 555                 pbus = card->bus[0];
 556                 /*init chip 1 */
 557                 card->dpram.fct->param[1] = pbus->can.bittiming.brp;
 558                 card->dpram.fct->param[2] = pbus->can.bittiming.sjw;
 559                 card->dpram.fct->param[3] =
 560                         pbus->can.bittiming.phase_seg1 +
 561                         pbus->can.bittiming.prop_seg;
 562                 card->dpram.fct->param[4] =
 563                         pbus->can.bittiming.phase_seg2;
 564                 card->dpram.fct->param[5] = (pbus->can.ctrlmode &
 565                         CAN_CTRLMODE_3_SAMPLES) ? 1 : 0;
 566                 if (softing_fct_cmd(card, 1, 0, "initialize_chip[0]"))
 567                         goto failed;
 568                 /*set mode */
 569                 card->dpram.fct->param[1] = 0;
 570                 card->dpram.fct->param[2] = 0;
 571                 if (softing_fct_cmd(card, 3, 0, "set_mode[0]"))
 572                         goto failed;
 573                 /*set filter */
 574                 card->dpram.fct->param[1] = 0x0000;/*card->bus[0].s.msg; */
 575                 card->dpram.fct->param[2] = 0x07ff;/*card->bus[0].s.msk; */
 576                 card->dpram.fct->param[3] = 0x0000;/*card->bus[0].l.msg; */
 577                 card->dpram.fct->param[4] = 0xffff;/*card->bus[0].l.msk; */
 578                 card->dpram.fct->param[5] = 0x0000;/*card->bus[0].l.msg >> 16;*/
 579                 card->dpram.fct->param[6] = 0x1fff;/*card->bus[0].l.msk >> 16;*/
 580                 if (softing_fct_cmd(card, 7, 0, "set_filter[0]"))
 581                         goto failed;
 582                 /*set output control */
 583                 card->dpram.fct->param[1] = pbus->output;
 584                 if (softing_fct_cmd(card, 5, 0, "set_output[0]"))
 585                         goto failed;
 586         }
 587         if (mask_start & 2) {
 588                 pbus = card->bus[1];
 589                 /*init chip2 */
 590                 card->dpram.fct->param[1] = pbus->can.bittiming.brp;
 591                 card->dpram.fct->param[2] = pbus->can.bittiming.sjw;
 592                 card->dpram.fct->param[3] =
 593                         pbus->can.bittiming.phase_seg1 +
 594                         pbus->can.bittiming.prop_seg;
 595                 card->dpram.fct->param[4] =
 596                         pbus->can.bittiming.phase_seg2;
 597                 card->dpram.fct->param[5] = (pbus->can.ctrlmode &
 598                         CAN_CTRLMODE_3_SAMPLES) ? 1 : 0;
 599                 if (softing_fct_cmd(card, 2, 0, "initialize_chip[1]"))
 600                         goto failed;
 601                 /*set mode2 */
 602                 card->dpram.fct->param[1] = 0;
 603                 card->dpram.fct->param[2] = 0;
 604                 if (softing_fct_cmd(card, 4, 0, "set_mode[1]"))
 605                         goto failed;
 606                 /*set filter2 */
 607                 card->dpram.fct->param[1] = 0x0000;/*card->bus[1].s.msg; */
 608                 card->dpram.fct->param[2] = 0x07ff;/*card->bus[1].s.msk; */
 609                 card->dpram.fct->param[3] = 0x0000;/*card->bus[1].l.msg; */
 610                 card->dpram.fct->param[4] = 0xffff;/*card->bus[1].l.msk; */
 611                 card->dpram.fct->param[5] = 0x0000;/*card->bus[1].l.msg >> 16;*/
 612                 card->dpram.fct->param[6] = 0x1fff;/*card->bus[1].l.msk >> 16;*/
 613                 if (softing_fct_cmd(card, 8, 0, "set_filter[1]"))
 614                         goto failed;
 615                 /*set output control2 */
 616                 card->dpram.fct->param[1] = pbus->output;
 617                 if (softing_fct_cmd(card, 6, 0, "set_output[1]"))
 618                         goto failed;
 619         }
 620         /*enable_error_frame */
 621         /*
 622         if (softing_fct_cmd(card, 51, 0, "enable_error_frame"))
 623                 goto failed;
 624         */
 625         /*initialize interface */
 626         card->dpram.fct->param[1] = 1;
 627         card->dpram.fct->param[2] = 1;
 628         card->dpram.fct->param[3] = 1;
 629         card->dpram.fct->param[4] = 1;
 630         card->dpram.fct->param[5] = 1;
 631         card->dpram.fct->param[6] = 1;
 632         card->dpram.fct->param[7] = 1;
 633         card->dpram.fct->param[8] = 1;
 634         card->dpram.fct->param[9] = 1;
 635         card->dpram.fct->param[10] = 1;
 636         if (softing_fct_cmd(card, 17, 0, "initialize_interface"))
 637                 goto failed;
 638         /*enable_fifo */
 639         if (softing_fct_cmd(card, 36, 0, "enable_fifo"))
 640                 goto failed;
 641         /*enable fifo tx ack */
 642         if (softing_fct_cmd(card, 13, 0, "fifo_tx_ack[0]"))
 643                 goto failed;
 644         /*enable fifo tx ack2 */
 645         if (softing_fct_cmd(card, 14, 0, "fifo_tx_ack[1]"))
 646                 goto failed;
 647         /*enable timestamps */
 648         /*is default, no code found */
 649         /*start_chip */
 650         if (softing_fct_cmd(card, 11, 0, "start_chip"))
 651                 goto failed;
 652         card->dpram.info->bus_state = 0;
 653         card->dpram.info->bus_state2 = 0;
 654         dev_info(card->dev, "ok for %s, %s/%s\n",
 655                 card->bus[0]->netdev->name, card->bus[1]->netdev->name,
 656                 card->id.name);
 657         if (card->desc->generation < 2) {
 658                 card->dpram.irq->to_host = 0;
 659                 /* flush the DPRAM caches */
 660                 wmb();
 661         }
 662
 663         card->boot_time = ktime_get_real();
 664
 665         /*run once */
 666         /*the bottom halve will start flushing the tx-queue too */
 667         /*tasklet_schedule(&card->irq.bh);*/
 668         ret = softing_card_irq(card, 1);
 669         if (ret)
 670                 goto failed;
 671
 672         /*
 673          * do socketcan notifications/status changes
 674          * from here, no errors should occur, or the failed: part
 675          * must be reviewed
 676          */
 677         memset(&msg, 0, sizeof(msg));
 678         msg.can_id = CAN_ERR_FLAG | CAN_ERR_RESTARTED;
 679         msg.can_dlc = CAN_ERR_DLC;
 680         for (j = 0; j < card->nbus; ++j) {
 681                 pbus = card->bus[j];
 682                 if (!pbus)
 683                         continue;
 684                 if (!(mask_start & (1 << j)))
 685                         continue;
 686                 pbus->can.state = CAN_STATE_ERROR_ACTIVE;
 687                 open_candev(pbus->netdev);
 688                 if (bus != pbus) {
 689                         /* notify other busses on the restart */
 690                         softing_rx(pbus->netdev, &msg, ktime_set(0, 0));
 691                         ++pbus->can.can_stats.restarts;
 692                 }
 693                 netif_wake_queue(pbus->netdev);
 694         }
 695 card_done:
 696         mutex_unlock(&card->fw.lock);
 697         return 0;
 698 failed:
 699         dev_alert(card->dev, "firmware failed, going idle\n");
 700         softing_card_irq(card, 0);
 701         softing_reset_chip(card);
 702         card->fw.failed = 1;
 703         mutex_unlock(&card->fw.lock);
 704         /* bring all other interfaces down */
 705         for (j = 0; j < card->nbus; ++j) {
 706                 pbus = card->bus[j];
 707                 if (!pbus)
 708                         continue;
 709                 dev_close(pbus->netdev);
 710         }
 711         return -EIO;
 712
 713 failed_already:
 714         mutex_unlock(&card->fw.lock);
 715         return -EIO;
 716 }
 717
 718
 719 int softing_default_output(struct softing *card, struct softing_priv *priv)
 720 {
 721         switch (priv->chip) {
 722         case 1000:
 723                 if (card->desc->generation < 2)
 724                         return 0xfb;
 725                 return 0xfa;
 726         case 5:
 727                 return 0x60;
 728         default:
 729                 return 0x40;
 730         }
 731 }
 732
 733 ktime_t softing_raw2ktime(struct softing *card, u32 raw)
 734 {
 735         uint64_t ovf;
 736         uint64_t rawl;
 737         uint64_t expected;
 738         ktime_t now;
 739         ktime_t target;
 740         ovf = 0x100000000ULL;
 741         rawl = raw;
 742         /*TODO : don't loose higher order bits in computation */
 743         switch (card->desc->freq) {
 744         case 20:
 745                 ovf = ovf * 4 / 5;
 746                 rawl = rawl * 4 / 5;
 747                 break;
 748         case 24:
 749                 ovf = ovf * 2 / 3;
 750                 rawl = rawl * 2 / 3;
 751                 break;
 752         case 25:
 753                 ovf = ovf * 16 / 25;
 754                 rawl = rawl * 16 / 25;
 755                 break;
 756         case 0:
 757         case 16:
 758                 break;
 759         default:
 760                 /* return empty time */
 761                 return ktime_set(0, 0);
 762         }
 763         now = ktime_get_real();
 764         expected = (ktime_us_delta(now, card->boot_time)) % ovf;
 765         /*
 766          * strange seuence for equation, but mind the 'unsigned-ness'
 767          * the idea was to:
 768          * if (expected < (rawl - (ovf / 2)))
 769          * meaning: on wrap-around (occurs at 'ovf'), expected (actual time)
 770          * may wrap around, altough rawl (receive time)
 771          * is just before wrap-around. In that case, offset 'expected'
 772          * note that expected can also be slightly earlier, as the card's
 773          * timer starts a little (but unknown to me) after I mark 'boot_time'
 774          */
 775         if (rawl < (expected + (ovf / 2)))
 776                 /* now (expected) is always later than card stamp */
 777                 expected += ovf;
 778         target = ktime_sub_us(now, (expected - rawl));
 779         return target;
 780 }
 781