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