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