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         netif_start_queue(ndev);
 431         return 0;
 432 failed:
 433         return ret;
 434 }
 435
 436 static int netdev_stop(struct net_device *ndev)
 437 {
 438         struct softing_priv *priv = netdev_priv(ndev);
 439         struct softing *card = priv->card;
 440         int ret;
 441
 442         netif_stop_queue(ndev);
 443
 444         /* softing cycle does close_candev() */
 445         ret = softing_cycle(card, priv, 0);
 446         return ret;
 447 }
 448
 449 static int candev_set_mode(struct net_device *ndev, enum can_mode mode)
 450 {
 451         struct softing_priv *priv = netdev_priv(ndev);
 452         struct softing *card = priv->card;
 453         int ret;
 454
 455         switch (mode) {
 456         case CAN_MODE_START:
 457                 /* softing cycle does close_candev() */
 458                 ret = softing_cycle(card, priv, 1);
 459                 return ret;
 460         case CAN_MODE_STOP:
 461         case CAN_MODE_SLEEP:
 462                 return -EOPNOTSUPP;
 463         }
 464         return 0;
 465 }
 466
 467 /*assume the card->lock is held*/
 468
 469 int softing_card_irq(struct softing *card, int enable)
 470 {
 471         int ret;
 472         if (!enable) {
 473                 if (card->irq.requested && card->irq.nr) {
 474                         free_irq(card->irq.nr, card);
 475                         card->irq.requested = 0;
 476                 }
 477                 return 0;
 478         }
 479         if (!card->irq.requested && (card->irq.nr)) {
 480                 irqreturn_t(*fn) (int, void *);
 481                 unsigned int flags;
 482                 flags = IRQF_DISABLED | IRQF_SHARED;/*| IRQF_TRIGGER_LOW; */
 483                 fn = dev_interrupt_nshared;
 484                 if (card->desc->generation >= 2)
 485                         fn = dev_interrupt_shared;
 486                 ret = request_irq(card->irq.nr, fn, flags, card->id.name, card);
 487                 if (ret) {
 488                         dev_alert(card->dev, "%s, request_irq(%u) failed\n",
 489                                 card->id.name, card->irq.nr);
 490                         return ret;
 491                 }
 492                 card->irq.requested = 1;
 493         }
 494         return 0;
 495 }
 496
 497 static void shutdown_card(struct softing *card)
 498 {
 499         int fw_up = 0;
 500         dev_dbg(card->dev, "%s()\n", __func__);
 501         if (mutex_lock_interruptible(&card->fw.lock))
 502                 /* return -ERESTARTSYS*/;
 503         fw_up = card->fw.up;
 504         card->fw.up = 0;
 505
 506         if (card->irq.requested && card->irq.nr) {
 507                 free_irq(card->irq.nr, card);
 508                 card->irq.requested = 0;
 509         }
 510         if (fw_up) {
 511                 if (card->fn.enable_irq)
 512                         card->fn.enable_irq(card, 0);
 513                 if (card->fn.reset)
 514                         card->fn.reset(card, 1);
 515         }
 516         mutex_unlock(&card->fw.lock);
 517         tasklet_kill(&card->irq.bh);
 518 }
 519
 520 static int boot_card(struct softing *card)
 521 {
 522         unsigned char *lp;
 523         static const unsigned char stream[] =
 524                 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, };
 525         unsigned char back[sizeof(stream)];
 526         dev_dbg(card->dev, "%s()\n", __func__);
 527
 528         if (mutex_lock_interruptible(&card->fw.lock))
 529                 return -ERESTARTSYS;
 530         if (card->fw.up) {
 531                 mutex_unlock(&card->fw.lock);
 532                 return 0;
 533         }
 534         /*reset board */
 535
 536         if (card->fn.enable_irq)
 537                 card->fn.enable_irq(card, 1);
 538         /*boot card */
 539         if (card->fn.reset)
 540                 card->fn.reset(card, 1);
 541         /*test dp ram */
 542         if (!card->dpram.virt)
 543                 goto open_failed;
 544         for (lp = card->dpram.virt; &lp[sizeof(stream)] <= card->dpram.end;
 545                 lp += sizeof(stream)) {
 546
 547                 memcpy_toio(lp, stream, sizeof(stream));
 548                 /* flush IO cache */
 549                 mb();
 550                 memcpy_fromio(back, lp, sizeof(stream));
 551
 552                 if (!memcmp(back, stream, sizeof(stream)))
 553                         continue;
 554                 /* memory is not equal */
 555                 dev_alert(card->dev, "write to dpram failed at 0x%04lx\n",
 556                         (unsigned long)(lp - card->dpram.virt));
 557                 goto open_failed;
 558         }
 559         wmb();
 560         /*load boot firmware */
 561         if (softing_load_fw(card->desc->boot.fw, card, card->dpram.virt,
 562                                  card->dpram.size,
 563                                  card->desc->boot.offs -
 564                                  card->desc->boot.addr))
 565                 goto open_failed;
 566         /*load load firmware */
 567         if (softing_load_fw(card->desc->load.fw, card, card->dpram.virt,
 568                                  card->dpram.size,
 569                                  card->desc->load.offs -
 570                                  card->desc->load.addr))
 571                 goto open_failed;
 572
 573         if (card->fn.reset)
 574                 card->fn.reset(card, 0);
 575         if (softing_bootloader_command(card, 0, "card boot"))
 576                 goto open_failed;
 577         if (softing_load_app_fw(card->desc->app.fw, card))
 578                 goto open_failed;
 579         /*reset chip */
 580         card->dpram.info->reset_rcv_fifo = 0;
 581         card->dpram.info->reset = 1;
 582         /*sync */
 583         if (softing_fct_cmd(card, 99, 0x55, "sync-a"))
 584                 goto open_failed;
 585         if (softing_fct_cmd(card, 99, 0xaa, "sync-a"))
 586                 goto open_failed;
 587         /*reset chip */
 588         if (softing_fct_cmd(card, 0, 0, "reset_chip"))
 589                 goto open_failed;
 590         /*get_serial */
 591         if (softing_fct_cmd(card, 43, 0, "get_serial_number"))
 592                 goto open_failed;
 593         card->id.serial =
 594                  (u16) card->dpram.fct->param[1] +
 595                  (((u16) card->dpram.fct->param[2]) << 16);
 596         /*get_version */
 597         if (softing_fct_cmd(card, 12, 0, "get_version"))
 598                 goto open_failed;
 599         card->id.fw = (u16) card->dpram.fct->param[1];
 600         card->id.hw = (u16) card->dpram.fct->param[2];
 601         card->id.lic = (u16) card->dpram.fct->param[3];
 602         card->id.chip[0] = (u16) card->dpram.fct->param[4];
 603         card->id.chip[1] = (u16) card->dpram.fct->param[5];
 604
 605         dev_info(card->dev, "card booted, type %s, "
 606                         "serial %u, fw %u, hw %u, lic %u, chip (%u,%u)\n",
 607                   card->id.name, card->id.serial, card->id.fw, card->id.hw,
 608                   card->id.lic, card->id.chip[0], card->id.chip[1]);
 609
 610         card->fw.up = 1;
 611         mutex_unlock(&card->fw.lock);
 612         return 0;
 613 open_failed:
 614         card->fw.up = 0;
 615         if (card->fn.enable_irq)
 616                 card->fn.enable_irq(card, 0);
 617         if (card->fn.reset)
 618                 card->fn.reset(card, 1);
 619         mutex_unlock(&card->fw.lock);
 620         return EINVAL;
 621 }
 622
 623 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,28)
 624 static const struct net_device_ops softing_netdev_ops = {
 625         .ndo_open       = netdev_open,
 626         .ndo_stop       = netdev_stop,
 627         .ndo_start_xmit = netdev_start_xmit,
 628 };
 629 #endif
 630
 631 static const struct can_bittiming_const softing_btr_const = {
 632         .tseg1_min = 1,
 633         .tseg1_max = 16,
 634         .tseg2_min = 1,
 635         .tseg2_max = 8,
 636         .sjw_max = 4, /* overruled */
 637         .brp_min = 1,
 638         .brp_max = 32, /* overruled */
 639         .brp_inc = 1,
 640 };
 641
 642
 643 static struct softing_priv *mk_netdev(struct softing *card, u16 chip_id)
 644 {
 645         struct net_device *ndev;
 646         struct softing_priv *priv;
 647
 648         ndev = alloc_candev(sizeof(*priv), TX_ECHO_SKB_MAX);
 649         if (!ndev) {
 650                 dev_alert(card->dev, "alloc_candev failed\n");
 651                 return 0;
 652         }
 653         priv = netdev_priv(ndev);
 654         priv->netdev            = ndev;
 655         priv->card              = card;
 656         memcpy(&priv->btr_const, &softing_btr_const, sizeof(priv->btr_const));
 657         priv->btr_const.brp_max = card->desc->max_brp;
 658         priv->btr_const.sjw_max = card->desc->max_sjw;
 659         priv->can.bittiming_const = &priv->btr_const;
 660         priv->can.clock.freq    = 8000000;
 661         priv->chip              = chip_id;
 662         priv->output = softing_default_output(card, priv);
 663         SET_NETDEV_DEV(ndev, card->dev);
 664
 665         ndev->flags |= IFF_ECHO;
 666 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,28)
 667         ndev->netdev_ops        = &softing_netdev_ops;
 668 #else
 669         ndev->open              = netdev_open;
 670         ndev->stop              = netdev_stop;
 671         ndev->hard_start_xmit   = netdev_start_xmit;
 672 #endif
 673         priv->can.do_set_mode   = candev_set_mode;
 674         priv->can.ctrlmode_supported = CAN_CTRLMODE_3_SAMPLES;
 675
 676         return priv;
 677 }
 678
 679 static int reg_netdev(struct softing_priv *priv)
 680 {
 681         int ret;
 682         ret = register_candev(priv->netdev);
 683         if (ret) {
 684                 dev_alert(priv->card->dev, "%s, register failed\n",
 685                         priv->card->id.name);
 686                 goto reg_failed;
 687         }
 688         ret = softing_bus_sysfs_create(priv);
 689         if (ret) {
 690                 dev_alert(priv->card->dev, "%s, sysfs failed\n",
 691                         priv->card->id.name);
 692                 goto sysfs_failed;
 693         }
 694         return 0;
 695 sysfs_failed:
 696         unregister_candev(priv->netdev);
 697 reg_failed:
 698         return EINVAL;
 699 }
 700
 701 void rm_softing(struct softing *card)
 702 {
 703         int j;
 704
 705         /*first, disable card*/
 706         shutdown_card(card);
 707
 708         for (j = 0; j < card->nbus; ++j) {
 709                 if (!card->bus[j])
 710                         continue;
 711                 softing_bus_sysfs_remove(card->bus[j]);
 712                 unregister_candev(card->bus[j]->netdev);
 713                 free_candev(card->bus[j]->netdev);
 714                 card->bus[j] = 0;
 715         }
 716
 717         softing_card_sysfs_remove(card);
 718
 719         iounmap(card->dpram.virt);
 720 }
 721 EXPORT_SYMBOL(rm_softing);
 722
 723 int mk_softing(struct softing *card)
 724 {
 725         int j;
 726
 727         /* try_module_get(THIS_MODULE); */
 728         mutex_init(&card->fw.lock);
 729         spin_lock_init(&card->spin);
 730         tasklet_init(&card->irq.bh, softing_dev_svc, (unsigned long)card);
 731
 732         if (!card->desc) {
 733                 dev_alert(card->dev, "no card description\n");
 734                 goto lookup_failed;
 735         }
 736         card->id.name = card->desc->name;
 737
 738         card->dpram.virt = ioremap(card->dpram.phys, card->dpram.size);
 739         if (!card->dpram.virt) {
 740                 dev_alert(card->dev, "dpram ioremap failed\n");
 741                 goto ioremap_failed;
 742         }
 743
 744         card->dpram.size = card->desc->dpram_size;
 745         card->dpram.end = &card->dpram.virt[card->dpram.size];
 746         /*initialize_board */
 747         card->dpram.rx = (struct softing_rx *)&card->dpram.virt[0x0000];
 748         card->dpram.tx = (struct softing_tx *)&card->dpram.virt[0x0400];
 749         card->dpram.fct = (struct softing_fct *)&card->dpram.virt[0x0300];
 750         card->dpram.info = (struct softing_info *)&card->dpram.virt[0x0330];
 751         card->dpram.command = (unsigned short *)&card->dpram.virt[0x07e0];
 752         card->dpram.receipt = (unsigned short *)&card->dpram.virt[0x07f0];
 753         card->dpram.irq = (struct softing_irq *)&card->dpram.virt[0x07fe];
 754
 755         /*reset card */
 756         if (card->fn.reset)
 757                 card->fn.reset(card, 1);
 758         if (boot_card(card)) {
 759                 dev_alert(card->dev, "failed to boot\n");
 760                 goto boot_failed;
 761         }
 762
 763         /*only now, the chip's are known */
 764         card->id.freq = card->desc->freq * 1000000UL;
 765
 766         if (softing_card_sysfs_create(card)) {
 767                 dev_alert(card->dev, "sysfs failed\n");
 768                 goto sysfs_failed;
 769         }
 770
 771         if (card->nbus > (sizeof(card->bus) / sizeof(card->bus[0]))) {
 772                 card->nbus = sizeof(card->bus) / sizeof(card->bus[0]);
 773                 dev_alert(card->dev, "have %u busses\n", card->nbus);
 774         }
 775
 776         for (j = 0; j < card->nbus; ++j) {
 777                 card->bus[j] = mk_netdev(card, card->id.chip[j]);
 778                 if (!card->bus[j]) {
 779                         dev_alert(card->dev, "failed to make can[%i]", j);
 780                         goto netdev_failed;
 781                 }
 782                 card->bus[j]->index = j;
 783         }
 784         for (j = 0; j < card->nbus; ++j) {
 785                 if (reg_netdev(card->bus[j])) {
 786                         dev_alert(card->dev,
 787                                 "failed to register can[%i]\n", j);
 788                         goto reg_failed;
 789                 }
 790         }
 791         dev_info(card->dev, "card initialised\n");
 792         return 0;
 793
 794 reg_failed:
 795         for (j = 0; j < card->nbus; ++j) {
 796                 if (!card->bus[j])
 797                         continue;
 798                 softing_bus_sysfs_remove(card->bus[j]);
 799                 unregister_candev(card->bus[j]->netdev);
 800         }
 801 netdev_failed:
 802         for (j = 0; j < card->nbus; ++j) {
 803                 if (!card->bus[j])
 804                         continue;
 805                 free_candev(card->bus[j]->netdev);
 806                 card->bus[j] = 0;
 807         }
 808         softing_card_sysfs_remove(card);
 809 sysfs_failed:
 810         shutdown_card(card);
 811 boot_failed:
 812         iounmap(card->dpram.virt);
 813         card->dpram.virt = 0;
 814         card->dpram.end = 0;
 815 ioremap_failed:
 816 lookup_failed:
 817         tasklet_kill(&card->irq.bh);
 818         return EINVAL;
 819 }
 820 EXPORT_SYMBOL(mk_softing);
 821
 822 static int __init mod_start(void)
 823 {
 824         printk(KERN_INFO "[%s] start\n", THIS_MODULE->name);
 825         return 0;
 826 }
 827
 828 static void __exit mod_stop(void)
 829 {
 830         printk(KERN_INFO "[%s] stop\n", THIS_MODULE->name);
 831 }
 832
 833 module_init(mod_start);
 834 module_exit(mod_stop);
 835
 836 MODULE_DESCRIPTION("socketcan softing driver");
 837 MODULE_AUTHOR("Kurt Van Dijck <kurt.van.dijck@eia.be>");
 838 MODULE_LICENSE("GPL");
 839
 840 int softing_debug = 1;
 841 EXPORT_SYMBOL(softing_debug);
 842 module_param(softing_debug, int , S_IRUGO | S_IWUSR | S_IWGRP);
 843 MODULE_PARM_DESC(softing_debug, "trace softing functions");