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

   1 /*
   2 * drivers/net/can/softing/softing_main.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/version.h>
  23 #include <linux/module.h>
  24 #include <linux/init.h>
  25 #include <linux/device.h>
  26 #include <linux/interrupt.h>
  27 #include <linux/mutex.h>
  28 #include <linux/io.h>
  29
  30 #include "softing.h"
  31
  32 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
  33 #error This driver does not support Kernel versions < 2.6.23
  34 #endif
  35
  36 #define TX_ECHO_SKB_MAX 4
  37
  38 /*
  39  * test is a specific CAN netdev
  40  * is online (ie. up 'n running, not sleeping, not busoff
  41  */
  42 static inline int canif_is_active(struct net_device *netdev)
  43 {
  44         struct can_priv *can = netdev_priv(netdev);
  45         if (!netif_running(netdev))
  46                 return 0;
  47         return (can->state <= CAN_STATE_ERROR_PASSIVE);
  48 }
  49
  50 /* trigger the tx queue-ing */
  51 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,32)
  52 static int netdev_start_xmit(struct sk_buff *skb, struct net_device *dev)
  53 #else
  54 static netdev_tx_t netdev_start_xmit(struct sk_buff *skb,
  55                         struct net_device *dev)
  56 #endif
  57 {
  58         struct softing_priv *priv = netdev_priv(dev);
  59         struct softing *card = priv->card;
  60         int ret;
  61         int bhlock;
  62         u8 *ptr;
  63         u8 cmd;
  64         unsigned int fifo_wr;
  65         struct can_frame msg;
  66
  67         if (can_dropped_invalid_skb(dev, skb))
  68                 return NETDEV_TX_OK;
  69
  70         if (in_interrupt()) {
  71                 bhlock = 0;
  72                 spin_lock(&card->spin);
  73         } else {
  74                 bhlock = 1;
  75                 spin_lock_bh(&card->spin);
  76         }
  77         ret = NETDEV_TX_BUSY;
  78         if (!card->fw.up)
  79                 goto xmit_done;
  80         if (card->tx.pending >= TXMAX)
  81                 goto xmit_done;
  82         if (priv->tx.pending >= TX_ECHO_SKB_MAX)
  83                 goto xmit_done;
  84         fifo_wr = card->dpram.tx->wr;
  85         if (fifo_wr == card->dpram.tx->rd)
  86                 /*fifo full */
  87                 goto xmit_done;
  88         memcpy(&msg, skb->data, sizeof(msg));
  89         ptr = &card->dpram.tx->fifo[fifo_wr][0];
  90         cmd = CMD_TX;
  91         if (msg.can_id & CAN_RTR_FLAG)
  92                 cmd |= CMD_RTR;
  93         if (msg.can_id & CAN_EFF_FLAG)
  94                 cmd |= CMD_XTD;
  95         if (priv->index)
  96                 cmd |= CMD_BUS2;
  97         *ptr++ = cmd;
  98         *ptr++ = msg.can_dlc;
  99         *ptr++ = (msg.can_id >> 0);
 100         *ptr++ = (msg.can_id >> 8);
 101         if (msg.can_id & CAN_EFF_FLAG) {
 102                 *ptr++ = (msg.can_id >> 16);
 103                 *ptr++ = (msg.can_id >> 24);
 104         } else {
 105                 /*increment 1, not 2 as you might think */
 106                 ptr += 1;
 107         }
 108         if (!(msg.can_id & CAN_RTR_FLAG))
 109                 memcpy_toio(ptr, &msg.data[0], msg.can_dlc);
 110         if (++fifo_wr >=
 111                  sizeof(card->dpram.tx->fifo) /
 112                  sizeof(card->dpram.tx->fifo[0]))
 113                 fifo_wr = 0;
 114         card->dpram.tx->wr = fifo_wr;
 115         card->tx.last_bus = priv->index;
 116         ++card->tx.pending;
 117         ++priv->tx.pending;
 118         can_put_echo_skb(skb, dev, priv->tx.echo_put);
 119         ++priv->tx.echo_put;
 120         if (priv->tx.echo_put >= TX_ECHO_SKB_MAX)
 121                 priv->tx.echo_put = 0;
 122         /* can_put_echo_skb() saves the skb, safe to return TX_OK */
 123         ret = NETDEV_TX_OK;
 124 xmit_done:
 125         if (bhlock)
 126                 spin_unlock_bh(&card->spin);
 127         else
 128                 spin_unlock(&card->spin);
 129         if (card->tx.pending >= TXMAX) {
 130                 struct softing_priv *bus;
 131                 int j;
 132                 for (j = 0; j < card->nbus; ++j) {
 133                         bus = card->bus[j];
 134                         if (!bus)
 135                                 continue;
 136                         netif_stop_queue(bus->netdev);
 137                 }
 138         }
 139         if (ret != NETDEV_TX_OK)
 140                 netif_stop_queue(dev);
 141
 142         return ret;
 143 }
 144
 145 int softing_rx(struct net_device *netdev, const struct can_frame *msg,
 146         ktime_t ktime)
 147 {
 148         struct sk_buff *skb;
 149         struct can_frame *cf;
 150         int ret;
 151         struct net_device_stats *stats;
 152
 153         skb = alloc_can_skb(netdev, &cf);
 154         if (!skb)
 155                 return -ENOMEM;
 156         memcpy(cf, msg, sizeof(*msg));
 157         skb->tstamp = ktime;
 158         ret = netif_rx(skb);
 159         if (ret == NET_RX_DROP) {
 160 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
 161                 stats = can_get_stats(netdev);
 162 #else
 163                 stats = &netdev->stats;
 164 #endif
 165                 ++stats->rx_dropped;
 166         }
 167         return ret;
 168 }
 169
 170 static int softing_dev_svc_once(struct softing *card)
 171 {
 172         int j;
 173         struct softing_priv *bus;
 174         ktime_t ktime;
 175         struct can_frame msg;
 176
 177         unsigned int fifo_rd;
 178         unsigned int cnt = 0;
 179         struct net_device_stats *stats;
 180         u8 *ptr;
 181         u32 tmp;
 182         u8 cmd;
 183
 184         memset(&msg, 0, sizeof(msg));
 185         if (card->dpram.rx->lost_msg) {
 186                 /*reset condition */
 187                 card->dpram.rx->lost_msg = 0;
 188                 /* prepare msg */
 189                 msg.can_id = CAN_ERR_FLAG | CAN_ERR_CRTL;
 190                 msg.can_dlc = CAN_ERR_DLC;
 191                 msg.data[1] = CAN_ERR_CRTL_RX_OVERFLOW;
 192                 /*
 193                  * service to all busses, we don't know which it was applicable
 194                  * but only service busses that are online
 195                  */
 196                 for (j = 0; j < card->nbus; ++j) {
 197                         bus = card->bus[j];
 198                         if (!bus)
 199                                 continue;
 200                         if (!canif_is_active(bus->netdev))
 201                                 /* a dead bus has no overflows */
 202                                 continue;
 203 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
 204                         stats = can_get_stats(bus->netdev);
 205 #else
 206                         stats = &bus->netdev->stats;
 207 #endif
 208                         ++stats->rx_over_errors;
 209                         softing_rx(bus->netdev, &msg, ktime_set(0, 0));
 210                 }
 211                 /* prepare for other use */
 212                 memset(&msg, 0, sizeof(msg));
 213                 ++cnt;
 214         }
 215
 216         fifo_rd = card->dpram.rx->rd;
 217         if (++fifo_rd >= ARRAY_SIZE(card->dpram.rx->fifo))
 218                 fifo_rd = 0;
 219
 220         if (card->dpram.rx->wr == fifo_rd)
 221                 return cnt;
 222
 223         ptr = &card->dpram.rx->fifo[fifo_rd][0];
 224
 225         cmd = *ptr++;
 226         if (cmd == 0xff) {
 227                 /*not quite usefull, probably the card has got out */
 228                 dev_alert(card->dev, "got cmd 0x%02x,"
 229                         " I suspect the card is lost\n", cmd);
 230         }
 231         /*mod_trace("0x%02x", cmd);*/
 232         bus = card->bus[0];
 233         if (cmd & CMD_BUS2)
 234                 bus = card->bus[1];
 235
 236 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
 237         stats = can_get_stats(bus->netdev);
 238 #else
 239         stats = &bus->netdev->stats;
 240 #endif
 241         if (cmd & CMD_ERR) {
 242                 u8 can_state;
 243                 u8 state;
 244                 state = *ptr++;
 245
 246                 msg.can_id = CAN_ERR_FLAG;
 247                 msg.can_dlc = CAN_ERR_DLC;
 248
 249                 if (state & 0x80) {
 250                         can_state = CAN_STATE_BUS_OFF;
 251                         msg.can_id |= CAN_ERR_BUSOFF;
 252                         state = 2;
 253                 } else if (state & 0x60) {
 254                         can_state = CAN_STATE_ERROR_PASSIVE;
 255                         msg.can_id |= CAN_ERR_BUSERROR;
 256                         msg.data[1] = CAN_ERR_CRTL_TX_PASSIVE;
 257                         state = 1;
 258                 } else {
 259                         can_state = CAN_STATE_ERROR_ACTIVE;
 260                         state = 0;
 261                         msg.can_id |= CAN_ERR_BUSERROR;
 262                 }
 263                 /*update DPRAM */
 264                 if (!bus->index)
 265                         card->dpram.info->bus_state = state;
 266                 else
 267                         card->dpram.info->bus_state2 = state;
 268                 /*timestamp */
 269                 tmp = (ptr[0] <<  0) | (ptr[1] <<  8)
 270                     | (ptr[2] << 16) | (ptr[3] << 24);
 271                 ptr += 4;
 272                 ktime = softing_raw2ktime(card, tmp);
 273                 /*trigger dual port RAM */
 274                 mb();
 275                 card->dpram.rx->rd = fifo_rd;
 276
 277                 ++bus->can.can_stats.bus_error;
 278                 ++stats->rx_errors;
 279                 /*update internal status */
 280                 if (can_state != bus->can.state) {
 281                         bus->can.state = can_state;
 282                         if (can_state == CAN_STATE_ERROR_PASSIVE)
 283                                 ++bus->can.can_stats.error_passive;
 284                         if (can_state == CAN_STATE_BUS_OFF) {
 285                                 /* this calls can_close_cleanup() */
 286                                 can_bus_off(bus->netdev);
 287                                 netif_stop_queue(bus->netdev);
 288                         }
 289                         /*trigger socketcan */
 290                         softing_rx(bus->netdev, &msg, ktime);
 291                 }
 292
 293         } else {
 294                 if (cmd & CMD_RTR)
 295                         msg.can_id |= CAN_RTR_FLAG;
 296                 /* acknowledge, was tx msg
 297                  * no real tx flag to set
 298                 if (cmd & CMD_ACK) {
 299                 }
 300                  */
 301                 msg.can_dlc = get_can_dlc(*ptr++);
 302                 if (cmd & CMD_XTD) {
 303                         msg.can_id |= CAN_EFF_FLAG;
 304                         msg.can_id |= (ptr[0] <<  0) | (ptr[1] <<  8)
 305                                     | (ptr[2] << 16) | (ptr[3] << 24);
 306                         ptr += 4;
 307                 } else {
 308                         msg.can_id |= (ptr[0] << 0) | (ptr[1] << 8);
 309                         ptr += 2;
 310                 }
 311                 tmp = (ptr[0] <<  0) | (ptr[1] <<  8)
 312                     | (ptr[2] << 16) | (ptr[3] << 24);
 313                 ptr += 4;
 314                 ktime = softing_raw2ktime(card, tmp);
 315                 memcpy_fromio(&msg.data[0], ptr, 8);
 316                 ptr += 8;
 317                 /*trigger dual port RAM */
 318                 mb();
 319                 card->dpram.rx->rd = fifo_rd;
 320                 /*update socket */
 321                 if (cmd & CMD_ACK) {
 322                         struct sk_buff *skb;
 323                         skb = bus->can.echo_skb[bus->tx.echo_get];
 324                         if (skb)
 325                                 skb->tstamp = ktime;
 326                         can_get_echo_skb(bus->netdev, bus->tx.echo_get);
 327                         ++bus->tx.echo_get;
 328                         if (bus->tx.echo_get >= TX_ECHO_SKB_MAX)
 329                                 bus->tx.echo_get = 0;
 330                         if (bus->tx.pending)
 331                                 --bus->tx.pending;
 332                         if (card->tx.pending)
 333                                 --card->tx.pending;
 334                         ++stats->tx_packets;
 335                         stats->tx_bytes += msg.can_dlc;
 336                 } else {
 337                         ++stats->rx_packets;
 338                         stats->rx_bytes += msg.can_dlc;
 339 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,32)
 340                         bus->netdev->last_rx = jiffies;
 341 #endif
 342                         softing_rx(bus->netdev, &msg, ktime);
 343                 }
 344         }
 345         ++cnt;
 346         return cnt;
 347 }
 348
 349 static void softing_dev_svc(unsigned long param)
 350 {
 351         struct softing *card = (struct softing *)param;
 352         struct softing_priv *bus;
 353         int j;
 354         int offset;
 355
 356         spin_lock(&card->spin);
 357         while (softing_dev_svc_once(card) > 0)
 358                 ++card->irq.svc_count;
 359         spin_unlock(&card->spin);
 360         /*resume tx queue's */
 361         offset = card->tx.last_bus;
 362         for (j = 0; j < card->nbus; ++j) {
 363                 if (card->tx.pending >= TXMAX)
 364                         break;
 365                 bus = card->bus[(j + offset + 1) % card->nbus];
 366                 if (!bus)
 367                         continue;
 368                 if (!canif_is_active(bus->netdev))
 369                         /* it makes no sense to wake dead busses */
 370                         continue;
 371                 if (bus->tx.pending >= TX_ECHO_SKB_MAX)
 372                         continue;
 373                 netif_wake_queue(bus->netdev);
 374         }
 375 }
 376
 377 static
 378 irqreturn_t dev_interrupt_shared(int irq, void *dev_id)
 379 {
 380         struct softing *card = (struct softing *)dev_id;
 381         unsigned char ir;
 382         ir = card->dpram.virt[0xe02];
 383         card->dpram.virt[0xe02] = 0;
 384         if (card->dpram.rx->rd == 0xffff) {
 385                 dev_alert(card->dev, "I think the card is gone\n");
 386                 return IRQ_NONE;
 387         }
 388         if (ir == 1) {
 389                 tasklet_schedule(&card->irq.bh);
 390                 return IRQ_HANDLED;
 391         } else if (ir == 0x10) {
 392                 return IRQ_NONE;
 393         } else {
 394                 return IRQ_NONE;
 395         }
 396 }
 397
 398 static
 399 irqreturn_t dev_interrupt_nshared(int irq, void *dev_id)
 400 {
 401         struct softing *card = (struct softing *)dev_id;
 402         unsigned char irq_host;
 403         irq_host = card->dpram.irq->to_host;
 404         /* make sure we have a copy, before clearing the variable in DPRAM */
 405         rmb();
 406         card->dpram.irq->to_host = 0;
 407         /* make sure we cleared it */
 408         wmb();
 409         if (card->dpram.rx->rd == 0xffff) {
 410                 dev_alert(card->dev, "I think the card is gone\n");
 411                 return IRQ_NONE;
 412         }
 413         tasklet_schedule(&card->irq.bh);
 414         return IRQ_HANDLED;
 415 }
 416
 417 static int netdev_open(struct net_device *ndev)
 418 {
 419         struct softing_priv *priv = netdev_priv(ndev);
 420         struct softing *card = priv->card;
 421         int ret;
 422
 423         /* check or determine and set bittime */
 424         ret = open_candev(ndev);
 425         if (ret)
 426                 goto failed;
 427         ret = softing_cycle(card, priv, 1);
 428         if (ret)
 429                 goto failed;
 430         return 0;
 431 failed:
 432         return ret;
 433 }
 434
 435 static int netdev_stop(struct net_device *ndev)
 436 {
 437         struct softing_priv *priv = netdev_priv(ndev);
 438         struct softing *card = priv->card;
 439         int ret;
 440
 441         netif_stop_queue(ndev);
 442
 443         /* softing cycle does close_candev() */
 444         ret = softing_cycle(card, priv, 0);
 445         return ret;
 446 }
 447
 448 static int candev_set_mode(struct net_device *ndev, enum can_mode mode)
 449 {
 450         struct softing_priv *priv = netdev_priv(ndev);
 451         struct softing *card = priv->card;
 452         int ret;
 453
 454         switch (mode) {
 455         case CAN_MODE_START:
 456                 /* softing cycle does close_candev() */
 457                 ret = softing_cycle(card, priv, 1);
 458                 return ret;
 459         case CAN_MODE_STOP:
 460         case CAN_MODE_SLEEP:
 461                 return -EOPNOTSUPP;
 462         }
 463         return 0;
 464 }
 465
 466 /*assume the card->lock is held*/
 467
 468 int softing_card_irq(struct softing *card, int enable)
 469 {
 470         int ret;
 471         if (!enable) {
 472                 if (card->irq.requested && card->irq.nr) {
 473                         free_irq(card->irq.nr, card);
 474                         card->irq.requested = 0;
 475                 }
 476                 return 0;
 477         }
 478         if (!card->irq.requested && (card->irq.nr)) {
 479                 irqreturn_t(*fn) (int, void *);
 480                 fn = dev_interrupt_nshared;
 481                 if (card->desc->generation >= 2)
 482                         fn = dev_interrupt_shared;
 483                 ret = request_irq(card->irq.nr, fn, IRQF_SHARED,
 484                                 card->id.name, card);
 485                 if (ret) {
 486                         dev_alert(card->dev, "%s, request_irq(%u) failed\n",
 487                                 card->id.name, card->irq.nr);
 488                         return ret;
 489                 }
 490                 card->irq.requested = 1;
 491         }
 492         return 0;
 493 }
 494
 495 static void shutdown_card(struct softing *card)
 496 {
 497         int fw_up = 0;
 498         dev_dbg(card->dev, "%s()\n", __func__);
 499         if (mutex_lock_interruptible(&card->fw.lock))
 500                 /* return -ERESTARTSYS*/;
 501         fw_up = card->fw.up;
 502         card->fw.up = 0;
 503
 504         if (card->irq.requested && card->irq.nr) {
 505                 free_irq(card->irq.nr, card);
 506                 card->irq.requested = 0;
 507         }
 508         if (fw_up) {
 509                 if (card->fn.enable_irq)
 510                         card->fn.enable_irq(card, 0);
 511                 if (card->fn.reset)
 512                         card->fn.reset(card, 1);
 513         }
 514         mutex_unlock(&card->fw.lock);
 515         tasklet_kill(&card->irq.bh);
 516 }
 517
 518 static int boot_card(struct softing *card)
 519 {
 520         unsigned char *lp;
 521         static const unsigned char stream[] =
 522                 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, };
 523         unsigned char back[sizeof(stream)];
 524         dev_dbg(card->dev, "%s()\n", __func__);
 525
 526         if (mutex_lock_interruptible(&card->fw.lock))
 527                 return -ERESTARTSYS;
 528         if (card->fw.up) {
 529                 mutex_unlock(&card->fw.lock);
 530                 return 0;
 531         }
 532         /*reset board */
 533
 534         if (card->fn.enable_irq)
 535                 card->fn.enable_irq(card, 1);
 536         /*boot card */
 537         if (card->fn.reset)
 538                 card->fn.reset(card, 1);
 539         /*test dp ram */
 540         if (!card->dpram.virt)
 541                 goto open_failed;
 542         for (lp = card->dpram.virt; &lp[sizeof(stream)] <= card->dpram.end;
 543                 lp += sizeof(stream)) {
 544
 545                 memcpy_toio(lp, stream, sizeof(stream));
 546                 /* flush IO cache */
 547                 mb();
 548                 memcpy_fromio(back, lp, sizeof(stream));
 549
 550                 if (!memcmp(back, stream, sizeof(stream)))
 551                         continue;
 552                 /* memory is not equal */
 553                 dev_alert(card->dev, "write to dpram failed at 0x%04lx\n",
 554                         (unsigned long)(lp - card->dpram.virt));
 555                 goto open_failed;
 556         }
 557         wmb();
 558         /*load boot firmware */
 559         if (softing_load_fw(card->desc->boot.fw, card, card->dpram.virt,
 560                                  card->dpram.size,
 561                                  card->desc->boot.offs -
 562                                  card->desc->boot.addr))
 563                 goto open_failed;
 564         /*load load firmware */
 565         if (softing_load_fw(card->desc->load.fw, card, card->dpram.virt,
 566                                  card->dpram.size,
 567                                  card->desc->load.offs -
 568                                  card->desc->load.addr))
 569                 goto open_failed;
 570
 571         if (card->fn.reset)
 572                 card->fn.reset(card, 0);
 573         if (softing_bootloader_command(card, 0, "card boot"))
 574                 goto open_failed;
 575         if (softing_load_app_fw(card->desc->app.fw, card))
 576                 goto open_failed;
 577         /*reset chip */
 578         card->dpram.info->reset_rcv_fifo = 0;
 579         card->dpram.info->reset = 1;
 580         /*sync */
 581         if (softing_fct_cmd(card, 99, 0x55, "sync-a"))
 582                 goto open_failed;
 583         if (softing_fct_cmd(card, 99, 0xaa, "sync-a"))
 584                 goto open_failed;
 585         /*reset chip */
 586         if (softing_fct_cmd(card, 0, 0, "reset_chip"))
 587                 goto open_failed;
 588         /*get_serial */
 589         if (softing_fct_cmd(card, 43, 0, "get_serial_number"))
 590                 goto open_failed;
 591         card->id.serial =
 592                  (u16) card->dpram.fct->param[1] +
 593                  (((u16) card->dpram.fct->param[2]) << 16);
 594         /*get_version */
 595         if (softing_fct_cmd(card, 12, 0, "get_version"))
 596                 goto open_failed;
 597         card->id.fw = (u16) card->dpram.fct->param[1];
 598         card->id.hw = (u16) card->dpram.fct->param[2];
 599         card->id.lic = (u16) card->dpram.fct->param[3];
 600         card->id.chip[0] = (u16) card->dpram.fct->param[4];
 601         card->id.chip[1] = (u16) card->dpram.fct->param[5];
 602
 603         dev_info(card->dev, "card booted, type %s, "
 604                         "serial %u, fw %u, hw %u, lic %u, chip (%u,%u)\n",
 605                   card->id.name, card->id.serial, card->id.fw, card->id.hw,
 606                   card->id.lic, card->id.chip[0], card->id.chip[1]);
 607
 608         card->fw.up = 1;
 609         mutex_unlock(&card->fw.lock);
 610         return 0;
 611 open_failed:
 612         card->fw.up = 0;
 613         if (card->fn.enable_irq)
 614                 card->fn.enable_irq(card, 0);
 615         if (card->fn.reset)
 616                 card->fn.reset(card, 1);
 617         mutex_unlock(&card->fw.lock);
 618         return EINVAL;
 619 }
 620
 621 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,28)
 622 static const struct net_device_ops softing_netdev_ops = {
 623         .ndo_open       = netdev_open,
 624         .ndo_stop       = netdev_stop,
 625         .ndo_start_xmit = netdev_start_xmit,
 626 };
 627 #endif
 628
 629 static const struct can_bittiming_const softing_btr_const = {
 630         .tseg1_min = 1,
 631         .tseg1_max = 16,
 632         .tseg2_min = 1,
 633         .tseg2_max = 8,
 634         .sjw_max = 4, /* overruled */
 635         .brp_min = 1,
 636         .brp_max = 32, /* overruled */
 637         .brp_inc = 1,
 638 };
 639
 640
 641 static struct softing_priv *mk_netdev(struct softing *card, u16 chip_id)
 642 {
 643         struct net_device *ndev;
 644         struct softing_priv *priv;
 645
 646         ndev = alloc_candev(sizeof(*priv), TX_ECHO_SKB_MAX);
 647         if (!ndev) {
 648                 dev_alert(card->dev, "alloc_candev failed\n");
 649                 return 0;
 650         }
 651         priv = netdev_priv(ndev);
 652         priv->netdev            = ndev;
 653         priv->card              = card;
 654         memcpy(&priv->btr_const, &softing_btr_const, sizeof(priv->btr_const));
 655         priv->btr_const.brp_max = card->desc->max_brp;
 656         priv->btr_const.sjw_max = card->desc->max_sjw;
 657         priv->can.bittiming_const = &priv->btr_const;
 658         priv->can.clock.freq    = 8000000;
 659         priv->chip              = chip_id;
 660         priv->output = softing_default_output(card, priv);
 661         SET_NETDEV_DEV(ndev, card->dev);
 662
 663         ndev->flags |= IFF_ECHO;
 664 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,28)
 665         ndev->netdev_ops        = &softing_netdev_ops;
 666 #else
 667         ndev->open              = netdev_open;
 668         ndev->stop              = netdev_stop;
 669         ndev->hard_start_xmit   = netdev_start_xmit;
 670 #endif
 671         priv->can.do_set_mode   = candev_set_mode;
 672         priv->can.ctrlmode_supported = CAN_CTRLMODE_3_SAMPLES;
 673
 674         return priv;
 675 }
 676
 677 static int reg_netdev(struct softing_priv *priv)
 678 {
 679         int ret;
 680         ret = register_candev(priv->netdev);
 681         if (ret) {
 682                 dev_alert(priv->card->dev, "%s, register failed\n",
 683                         priv->card->id.name);
 684                 goto reg_failed;
 685         }
 686         ret = softing_bus_sysfs_create(priv);
 687         if (ret) {
 688                 dev_alert(priv->card->dev, "%s, sysfs failed\n",
 689                         priv->card->id.name);
 690                 goto sysfs_failed;
 691         }
 692         return 0;
 693 sysfs_failed:
 694         unregister_candev(priv->netdev);
 695 reg_failed:
 696         return EINVAL;
 697 }
 698
 699 void rm_softing(struct softing *card)
 700 {
 701         int j;
 702
 703         /*first, disable card*/
 704         shutdown_card(card);
 705
 706         for (j = 0; j < card->nbus; ++j) {
 707                 if (!card->bus[j])
 708                         continue;
 709                 softing_bus_sysfs_remove(card->bus[j]);
 710                 unregister_candev(card->bus[j]->netdev);
 711                 free_candev(card->bus[j]->netdev);
 712                 card->bus[j] = 0;
 713         }
 714
 715         softing_card_sysfs_remove(card);
 716
 717         iounmap(card->dpram.virt);
 718 }
 719 EXPORT_SYMBOL(rm_softing);
 720
 721 int mk_softing(struct softing *card)
 722 {
 723         int j;
 724
 725         /* try_module_get(THIS_MODULE); */
 726         mutex_init(&card->fw.lock);
 727         spin_lock_init(&card->spin);
 728         tasklet_init(&card->irq.bh, softing_dev_svc, (unsigned long)card);
 729
 730         if (!card->desc) {
 731                 dev_alert(card->dev, "no card description\n");
 732                 goto lookup_failed;
 733         }
 734         card->id.name = card->desc->name;
 735
 736         card->dpram.virt = ioremap(card->dpram.phys, card->dpram.size);
 737         if (!card->dpram.virt) {
 738                 dev_alert(card->dev, "dpram ioremap failed\n");
 739                 goto ioremap_failed;
 740         }
 741
 742         card->dpram.size = card->desc->dpram_size;
 743         card->dpram.end = &card->dpram.virt[card->dpram.size];
 744         /*initialize_board */
 745         card->dpram.rx = (struct softing_rx *)&card->dpram.virt[0x0000];
 746         card->dpram.tx = (struct softing_tx *)&card->dpram.virt[0x0400];
 747         card->dpram.fct = (struct softing_fct *)&card->dpram.virt[0x0300];
 748         card->dpram.info = (struct softing_info *)&card->dpram.virt[0x0330];
 749         card->dpram.command = (unsigned short *)&card->dpram.virt[0x07e0];
 750         card->dpram.receipt = (unsigned short *)&card->dpram.virt[0x07f0];
 751         card->dpram.irq = (struct softing_irq *)&card->dpram.virt[0x07fe];
 752
 753         /*reset card */
 754         if (card->fn.reset)
 755                 card->fn.reset(card, 1);
 756         if (boot_card(card)) {
 757                 dev_alert(card->dev, "failed to boot\n");
 758                 goto boot_failed;
 759         }
 760
 761         /*only now, the chip's are known */
 762         card->id.freq = card->desc->freq * 1000000UL;
 763
 764         if (softing_card_sysfs_create(card)) {
 765                 dev_alert(card->dev, "sysfs failed\n");
 766                 goto sysfs_failed;
 767         }
 768
 769         if (card->nbus > (sizeof(card->bus) / sizeof(card->bus[0]))) {
 770                 card->nbus = sizeof(card->bus) / sizeof(card->bus[0]);
 771                 dev_alert(card->dev, "have %u busses\n", card->nbus);
 772         }
 773
 774         for (j = 0; j < card->nbus; ++j) {
 775                 card->bus[j] = mk_netdev(card, card->id.chip[j]);
 776                 if (!card->bus[j]) {
 777                         dev_alert(card->dev, "failed to make can[%i]", j);
 778                         goto netdev_failed;
 779                 }
 780                 card->bus[j]->index = j;
 781         }
 782         for (j = 0; j < card->nbus; ++j) {
 783                 if (reg_netdev(card->bus[j])) {
 784                         dev_alert(card->dev,
 785                                 "failed to register can[%i]\n", j);
 786                         goto reg_failed;
 787                 }
 788         }
 789         dev_info(card->dev, "card initialised\n");
 790         return 0;
 791
 792 reg_failed:
 793         for (j = 0; j < card->nbus; ++j) {
 794                 if (!card->bus[j])
 795                         continue;
 796                 softing_bus_sysfs_remove(card->bus[j]);
 797                 unregister_candev(card->bus[j]->netdev);
 798         }
 799 netdev_failed:
 800         for (j = 0; j < card->nbus; ++j) {
 801                 if (!card->bus[j])
 802                         continue;
 803                 free_candev(card->bus[j]->netdev);
 804                 card->bus[j] = 0;
 805         }
 806         softing_card_sysfs_remove(card);
 807 sysfs_failed:
 808         shutdown_card(card);
 809 boot_failed:
 810         iounmap(card->dpram.virt);
 811         card->dpram.virt = 0;
 812         card->dpram.end = 0;
 813 ioremap_failed:
 814 lookup_failed:
 815         tasklet_kill(&card->irq.bh);
 816         return EINVAL;
 817 }
 818 EXPORT_SYMBOL(mk_softing);
 819
 820 static int __init mod_start(void)
 821 {
 822         printk(KERN_INFO "[%s] start\n", THIS_MODULE->name);
 823         return 0;
 824 }
 825
 826 static void __exit mod_stop(void)
 827 {
 828         printk(KERN_INFO "[%s] stop\n", THIS_MODULE->name);
 829 }
 830
 831 module_init(mod_start);
 832 module_exit(mod_stop);
 833
 834 MODULE_DESCRIPTION("socketcan softing driver");
 835 MODULE_AUTHOR("Kurt Van Dijck <kurt.van.dijck@eia.be>");
 836 MODULE_LICENSE("GPL");
 837
 838 int softing_debug = 1;
 839 EXPORT_SYMBOL(softing_debug);
 840 module_param(softing_debug, int , S_IRUGO | S_IWUSR | S_IWGRP);
 841 MODULE_PARM_DESC(softing_debug, "trace softing functions");