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/module.h>
  23 #include <linux/init.h>
  24 #include <linux/device.h>
  25 #include <linux/firmware.h>
  26 #include <linux/interrupt.h>
  27 #include <linux/mutex.h>
  28 #include <linux/io.h>
  29
  30 #include "softing.h"
  31
  32 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 25)
  33         /* clear statistics */
  34 #define strict_strtoul simple_strtoul
  35 #endif
  36 /* this is the worst thing on the softing API
  37  * 2 busses are driven together, I don't know how
  38  * to recover a single of them.
  39  * Therefore, when one bus is modified, the other
  40  * is flushed too
  41  */
  42 void softing_flush_echo_skb(struct softing_priv *priv)
  43 {
  44         can_close_cleanup(priv->netdev);
  45         priv->tx.pending = 0;
  46         priv->tx.echo_put = 0;
  47         priv->tx.echo_get = 0;
  48 }
  49
  50 /*softing_unlocked_tx_run:*/
  51 /*trigger the tx queue-ing*/
  52 /*no locks are grabbed, so be sure to have the spin spinlock*/
  53 static int netdev_start_xmit(struct sk_buff *skb, struct net_device *dev)
  54 {
  55         struct softing_priv *priv = (struct softing_priv *)dev->priv;
  56         struct softing *card = priv->card;
  57         int ret;
  58         int bhlock;
  59         u8 *ptr;
  60         u8 cmd;
  61         unsigned int fifo_wr;
  62         struct can_frame msg;
  63
  64         ret = -ENOTTY;
  65         if (in_interrupt()) {
  66                 bhlock = 0;
  67                 spin_lock(&card->spin);
  68         } else {
  69                 bhlock = 1;
  70                 spin_lock_bh(&card->spin);
  71         }
  72         if (!card->fw.up) {
  73                 ret = -EIO;
  74                 goto xmit_done;
  75         }
  76         if (netif_carrier_ok(priv->netdev) <= 0) {
  77                 ret = -EBADF;
  78                 goto xmit_done;
  79         }
  80         if (card->tx.pending >= TXMAX) {
  81                 ret = -EBUSY;
  82                 goto xmit_done;
  83         }
  84         if (priv->tx.pending >= CAN_ECHO_SKB_MAX) {
  85                 ret = -EBUSY;
  86                 goto xmit_done;
  87         }
  88         fifo_wr = card->dpram.tx->wr;
  89         if (fifo_wr == card->dpram.tx->rd) {
  90                 /*fifo full */
  91                 ret = -EAGAIN;
  92                 goto xmit_done;
  93         }
  94         memcpy(&msg, skb->data, sizeof(msg));
  95         ptr = &card->dpram.tx->fifo[fifo_wr][0];
  96         cmd = CMD_TX;
  97         if (msg.can_id & CAN_RTR_FLAG)
  98                 cmd |= CMD_RTR;
  99         if (msg.can_id & CAN_EFF_FLAG)
 100                 cmd |= CMD_XTD;
 101         if (priv->index)
 102                 cmd |= CMD_BUS2;
 103         *ptr++ = cmd;
 104         *ptr++ = msg.can_dlc;
 105         *ptr++ = (msg.can_id >> 0);
 106         *ptr++ = (msg.can_id >> 8);
 107         if (msg.can_id & CAN_EFF_FLAG) {
 108                 *ptr++ = (msg.can_id >> 16);
 109                 *ptr++ = (msg.can_id >> 24);
 110         } else {
 111                 /*increment 1, not 2 as you might think */
 112                 ptr += 1;
 113         }
 114         if (!(msg.can_id & CAN_RTR_FLAG))
 115                 memcpy_toio(ptr, &msg.data[0], msg.can_dlc);
 116         if (++fifo_wr >=
 117                  sizeof(card->dpram.tx->fifo) /
 118                  sizeof(card->dpram.tx->fifo[0]))
 119                 fifo_wr = 0;
 120         card->dpram.tx->wr = fifo_wr;
 121         ret = 0;
 122         ++card->tx.pending;
 123         ++priv->tx.pending;
 124         can_put_echo_skb(skb, dev, priv->tx.echo_put);
 125         ++priv->tx.echo_put;
 126         if (priv->tx.echo_put >= CAN_ECHO_SKB_MAX)
 127                 priv->tx.echo_put = 0;
 128         /* clear pointer, so don't erase later */
 129         skb = 0;
 130 xmit_done:
 131         if (bhlock)
 132                 spin_unlock_bh(&card->spin);
 133         else
 134                 spin_unlock(&card->spin);
 135         if (card->tx.pending >= TXMAX) {
 136                 struct softing_priv *bus;
 137                 int j;
 138                 for (j = 0; j < card->nbus; ++j) {
 139                         bus = card->bus[j];
 140                         if (!bus)
 141                                 continue;
 142                         netif_stop_queue(bus->netdev);
 143                 }
 144         }
 145
 146         /* free skb, if not handled by the driver */
 147         if (skb)
 148                 dev_kfree_skb(skb);
 149         return ret;
 150 }
 151
 152 static int softing_dev_svc_once(struct softing *card)
 153 {
 154         int j;
 155         struct softing_priv *bus;
 156         struct sk_buff *skb;
 157         struct can_frame msg;
 158
 159         unsigned int fifo_rd;
 160         unsigned int cnt = 0;
 161         struct net_device_stats *stats;
 162
 163         memset(&msg, 0, sizeof(msg));
 164         if (card->dpram.rx->lost_msg) {
 165                 /*reset condition */
 166                 card->dpram.rx->lost_msg = 0;
 167                 /* prepare msg */
 168                 msg.can_id = CAN_ERR_FLAG | CAN_ERR_CRTL;
 169                 msg.can_dlc = CAN_ERR_DLC;
 170                 msg.data[1] = CAN_ERR_CRTL_RX_OVERFLOW;
 171                 /*service to both busses, we don't know which one generated */
 172                 for (j = 0; j < card->nbus; ++j) {
 173                         bus = card->bus[j];
 174                         if (!bus)
 175                                 continue;
 176                         if (!netif_carrier_ok(bus->netdev))
 177                                 continue;
 178                         ++bus->can.can_stats.data_overrun;
 179                         skb = dev_alloc_skb(sizeof(msg));
 180                         if (!skb)
 181                                 return -ENOMEM;
 182                         skb->dev = bus->netdev;
 183                         skb->protocol = htons(ETH_P_CAN);
 184                         skb->ip_summed = CHECKSUM_UNNECESSARY;
 185                         memcpy(skb_put(skb, sizeof(msg)), &msg, sizeof(msg));
 186                         if (netif_rx(skb))
 187                                 dev_kfree_skb_irq(skb);
 188                 }
 189                 memset(&msg, 0, sizeof(msg));
 190                 ++cnt;
 191         }
 192
 193         fifo_rd = card->dpram.rx->rd;
 194         if (++fifo_rd >=
 195                  sizeof(card->dpram.rx->fifo) / sizeof(card->dpram.rx->fifo[0]))
 196                 fifo_rd = 0;
 197         if (card->dpram.rx->wr != fifo_rd) {
 198                 u8 *ptr;
 199                 u32 tmp;
 200                 u8 cmd;
 201                 int do_skb;
 202
 203                 ptr = &card->dpram.rx->fifo[fifo_rd][0];
 204
 205                 cmd = *ptr++;
 206                 if (cmd == 0xff) {
 207                         /*not quite usefull, probably the card has got out */
 208                         mod_alert("got cmd 0x%02x, I suspect the card is lost"
 209                                 , cmd);
 210                 }
 211                 /*mod_trace("0x%02x", cmd);*/
 212                 bus = card->bus[0];
 213                 if (cmd & CMD_BUS2)
 214                         bus = card->bus[1];
 215
 216                 stats = bus->netdev->get_stats(bus->netdev);
 217                 if (cmd & CMD_ERR) {
 218                         u8 can_state;
 219                         u8 state;
 220                         state = *ptr++;
 221
 222                         msg.can_id = CAN_ERR_FLAG;
 223                         msg.can_dlc = CAN_ERR_DLC;
 224
 225                         if (state & 0x80) {
 226                                 can_state = CAN_STATE_BUS_OFF;
 227                                 msg.can_id |= CAN_ERR_BUSOFF;
 228                                 state = 2;
 229                         } else if (state & 0x60) {
 230                                 can_state = CAN_STATE_BUS_PASSIVE;
 231                                 msg.can_id |= CAN_ERR_BUSERROR;
 232                                 state = 1;
 233                         } else {
 234                                 can_state = CAN_STATE_ACTIVE;
 235                                 state = 0;
 236                                 do_skb = 0;
 237                         }
 238                         /*update DPRAM */
 239                         if (!bus->index)
 240                                 card->dpram.info->bus_state = state;
 241                         else
 242                                 card->dpram.info->bus_state2 = state;
 243                         /*timestamp */
 244                         tmp =    (ptr[0] <<  0)
 245                                 |(ptr[1] <<  8)
 246                                 |(ptr[2] << 16)
 247                                 |(ptr[3] << 24);
 248                         ptr += 4;
 249                         /*msg.time = */ softing_time2usec(card, tmp);
 250                         /*trigger dual port RAM */
 251                         mb();
 252                         card->dpram.rx->rd = fifo_rd;
 253                         /*update internal status */
 254                         if (can_state != bus->can.state) {
 255                                 bus->can.state = can_state;
 256                                 if (can_state == 1)
 257                                         bus->can.can_stats.error_passive += 1;
 258                         }
 259                         bus->can.can_stats.bus_error += 1;
 260
 261                         /*trigger socketcan */
 262                         if (state == 2) {
 263                                 /* this calls can_close_cleanup() */
 264                                 softing_flush_echo_skb(bus);
 265                                 can_bus_off(bus->netdev);
 266                                 netif_stop_queue(bus->netdev);
 267                         }
 268                         if ((state == CAN_STATE_BUS_OFF)
 269                                  || (state == CAN_STATE_BUS_PASSIVE)) {
 270                                 skb = dev_alloc_skb(sizeof(msg));
 271                                 if (!skb)
 272                                         return -ENOMEM;
 273                                 skb->dev = bus->netdev;
 274                                 skb->protocol = htons(ETH_P_CAN);
 275                                 skb->ip_summed = CHECKSUM_UNNECESSARY;
 276                                 memcpy(skb_put(skb, sizeof(msg)), &msg,
 277                                                  sizeof(msg));
 278                                 if (netif_rx(skb))
 279                                         dev_kfree_skb_irq(skb);
 280                         }
 281                 } else {
 282                         if (cmd & CMD_RTR)
 283                                 msg.can_id |= CAN_RTR_FLAG;
 284                         /* acknowledge, was tx msg
 285                          * no real tx flag to set
 286                         if (cmd & CMD_ACK) {
 287                         }
 288                          */
 289                         msg.can_dlc = *ptr++;
 290                         if (msg.can_dlc > 8)
 291                                 msg.can_dlc = 8;
 292                         if (cmd & CMD_XTD) {
 293                                 msg.can_id |= CAN_EFF_FLAG;
 294                                 msg.can_id |=
 295                                                 (ptr[0] << 0)
 296                                          | (ptr[1] << 8)
 297                                          | (ptr[2] << 16)
 298                                          | (ptr[3] << 24);
 299                                 ptr += 4;
 300                         } else {
 301                                 msg.can_id |= (ptr[0] << 0) | (ptr[1] << 8);
 302                                 ptr += 2;
 303                         }
 304                         tmp = (ptr[0] << 0)
 305                                  | (ptr[1] << 8)
 306                                  | (ptr[2] << 16)
 307                                  | (ptr[3] << 24);
 308                         ptr += 4;
 309                         /*msg.time = */ softing_time2usec(card, tmp);
 310                         memcpy_fromio(&msg.data[0], ptr, 8);
 311                         ptr += 8;
 312                         /*trigger dual port RAM */
 313                         mb();
 314                         card->dpram.rx->rd = fifo_rd;
 315                         /*update socket */
 316                         if (cmd & CMD_ACK) {
 317                                 can_get_echo_skb(bus->netdev, bus->tx.echo_get);
 318                                 ++bus->tx.echo_get;
 319                                 if (bus->tx.echo_get >= CAN_ECHO_SKB_MAX)
 320                                         bus->tx.echo_get = 0;
 321                                 if (bus->tx.pending)
 322                                         --bus->tx.pending;
 323                                 if (card->tx.pending)
 324                                         --card->tx.pending;
 325                                 stats->tx_packets += 1;
 326                                 stats->tx_bytes += msg.can_dlc;
 327                         } else {
 328                                 stats->rx_packets += 1;
 329                                 stats->rx_bytes += msg.can_dlc;
 330                                 bus->netdev->last_rx = jiffies;
 331                                 skb = dev_alloc_skb(sizeof(msg));
 332                                 if (skb) {
 333                                         skb->dev = bus->netdev;
 334                                         skb->protocol = htons(ETH_P_CAN);
 335                                         skb->ip_summed = CHECKSUM_UNNECESSARY;
 336                                         memcpy(skb_put(skb, sizeof(msg)), &msg,
 337                                                          sizeof(msg));
 338                                         if (netif_rx(skb))
 339                                                 dev_kfree_skb_irq(skb);
 340                                 }
 341                         }
 342                 }
 343                 ++cnt;
 344         }
 345         return cnt;
 346 }
 347
 348 static void softing_dev_svc(unsigned long param)
 349 {
 350         struct softing *card = (struct softing *)param;
 351         struct softing_priv *bus;
 352         int j;
 353         int offset;
 354
 355         spin_lock(&card->spin);
 356         while (softing_dev_svc_once(card) > 0)
 357                 ++card->irq.svc_count;
 358         /*resume tx queue's */
 359         offset = card->tx.last_bus;
 360         for (j = 0; j < card->nbus; ++j) {
 361                 if (card->tx.pending >= TXMAX)
 362                         break;
 363                 bus = card->bus[(j + offset) % card->nbus];
 364                 if (netif_carrier_ok(bus->netdev))
 365                         netif_wake_queue(bus->netdev);
 366         }
 367         spin_unlock(&card->spin);
 368 }
 369
 370 static void card_seems_down(struct softing *card)
 371 {
 372         /* free interrupt, but probably
 373          * in wrong (interrupt) context
 374         if (card->irq.requested) {
 375                 free_irq(card->irq.nr, card);
 376                 card->irq.requested = 0;
 377                 card->fw.up = 0;
 378         }
 379         */
 380         mod_alert("I think the card is vanished");
 381 }
 382
 383 static
 384 irqreturn_t dev_interrupt_shared(int irq, void *dev_id)
 385 {
 386         struct softing *card = (struct softing *)dev_id;
 387         unsigned char ir;
 388         ir = card->dpram.virt[0xe02];
 389         card->dpram.virt[0xe02] = 0;
 390         if (card->dpram.rx->rd == 0xffff) {
 391                 card_seems_down(card);
 392                 return IRQ_NONE;
 393         }
 394         if (ir == 1) {
 395                 tasklet_schedule(&card->irq.bh);
 396                 return IRQ_HANDLED;
 397         } else if (ir == 0x10) {
 398                 return IRQ_NONE;
 399         } else {
 400                 return IRQ_NONE;
 401         }
 402 }
 403
 404 static
 405 irqreturn_t dev_interrupt_nshared(int irq, void *dev_id)
 406 {
 407         struct softing *card = (struct softing *)dev_id;
 408         unsigned char irq_host;
 409         irq_host = card->dpram.irq->to_host;
 410         /* make sure we have a copy, before clearing the variable in DPRAM */
 411         rmb();
 412         card->dpram.irq->to_host = 0;
 413         /* make sure we cleared it */
 414         wmb();
 415         mod_trace("0x%02x", irq_host);
 416         if (card->dpram.rx->rd == 0xffff) {
 417                 card_seems_down(card);
 418                 return IRQ_NONE;
 419         }
 420         tasklet_schedule(&card->irq.bh);
 421         return IRQ_HANDLED;
 422 }
 423
 424 static int netdev_open(struct net_device *ndev)
 425 {
 426         struct softing_priv *priv = netdev_priv(ndev);
 427         struct softing *card = priv->card;
 428         int fw;
 429         mod_trace("%s", ndev->name);
 430         if (mutex_lock_interruptible(&card->fw.lock))
 431                 return -ERESTARTSYS;
 432         fw = card->fw.up;
 433         if (fw)
 434                 softing_reinit(card
 435                         , (card->bus[0] == priv) ? 1 : -1
 436                         , (card->bus[1] == priv) ? 1 : -1);
 437         mutex_unlock(&card->fw.lock);
 438         if (!fw)
 439                 return -EIO;
 440         netif_start_queue(ndev);
 441         return 0;
 442 }
 443
 444 static int netdev_stop(struct net_device *ndev)
 445 {
 446         struct softing_priv *priv = netdev_priv(ndev);
 447         struct softing *card = priv->card;
 448         int fw;
 449
 450         mod_trace("%s", ndev->name);
 451         netif_stop_queue(ndev);
 452         netif_carrier_off(ndev);
 453         softing_flush_echo_skb(priv);
 454         can_close_cleanup(ndev);
 455         if (mutex_lock_interruptible(&card->fw.lock))
 456                 return -ERESTARTSYS;
 457         fw = card->fw.up;
 458         if (fw)
 459                 softing_reinit(card
 460                         , (card->bus[0] == priv) ? 0 : -1
 461                         , (card->bus[1] == priv) ? 0 : -1);
 462         mutex_unlock(&card->fw.lock);
 463         if (!fw)
 464                 return -EIO;
 465         return 0;
 466 }
 467
 468 #define out_of_range(x, min, max) (((x) < min) || ((x) > max))
 469
 470 static int candev_set_bittiming(struct net_device *ndev)
 471 {
 472         struct softing_priv *priv = netdev_priv(ndev);
 473         struct can_bittiming *bt = &priv->can.bittiming;
 474
 475         /*SJW is test via max_sjw */
 476         if (out_of_range(bt->sjw, 1, 4))
 477                 return -EIO;
 478         if (out_of_range(bt->phase_seg1 + bt->prop_seg, 1, 16))
 479                 return -EIO;
 480         if (out_of_range(bt->phase_seg2, 1, 8))
 481                 return -EIO;
 482         /*BRP is test via max_brp */
 483         if (ndev->flags & IFF_UP)
 484                 return -EBUSY;
 485
 486         return 0;
 487 }
 488
 489 static int candev_get_state(struct net_device *ndev, enum can_state *state)
 490 {
 491         struct softing_priv *priv = netdev_priv(ndev);
 492         mod_trace("%s", ndev->name);
 493         if (priv->netdev->flags & IFF_UP)
 494                 *state = CAN_STATE_STOPPED;
 495         else if (priv->can.state == CAN_STATE_STOPPED)
 496                 *state = CAN_STATE_STOPPED;
 497         else
 498                 *state = CAN_STATE_ACTIVE;
 499         return 0;
 500 }
 501
 502 static int candev_set_mode(struct net_device *ndev, enum can_mode mode)
 503 {
 504         struct softing_priv *priv = netdev_priv(ndev);
 505         struct softing *card = priv->card;
 506         mod_trace("%s %u", ndev->name, mode);
 507         switch (mode) {
 508         case CAN_MODE_START:
 509                 /*recovery from busoff? */
 510                 if (mutex_lock_interruptible(&card->fw.lock))
 511                         return -ERESTARTSYS;
 512                 softing_reinit(card, -1, -1);
 513                 mutex_unlock(&card->fw.lock);
 514                 break;
 515         case CAN_MODE_STOP:
 516         case CAN_MODE_SLEEP:
 517                 return -EOPNOTSUPP;
 518         }
 519         return 0;
 520 }
 521
 522 /*assume the card->lock is held*/
 523
 524 int softing_card_irq(struct softing *card, int enable)
 525 {
 526         int ret;
 527         if (!enable) {
 528                 if (card->irq.requested && card->irq.nr) {
 529                         free_irq(card->irq.nr, card);
 530                         card->irq.requested = 0;
 531                 }
 532                 return 0;
 533         }
 534         if (!card->irq.requested && (card->irq.nr)) {
 535                 irqreturn_t(*fn) (int, void *);
 536                 unsigned int flags;
 537                 flags = IRQF_DISABLED;  /*| IRQF_TRIGGER_LOW; */
 538                 fn = dev_interrupt_nshared;
 539                 if (card->irq.shared) {
 540                         flags |= IRQF_SHARED;
 541                         fn = dev_interrupt_shared;
 542                 }
 543                 ret = request_irq(card->irq.nr, fn, flags, card->id.name, card);
 544                 if (ret) {
 545                         mod_alert("%s, request_irq(%u) failed, %s shared"
 546                                 , card->id.name, card->irq.nr
 547                                 , (card->irq.shared ? "" : "not")
 548                                 );
 549                         return ret;
 550                 }
 551                 card->irq.requested = 1;
 552         }
 553         return 0;
 554 }
 555
 556 static void shutdown_card(struct softing *card)
 557 {
 558         int fw_up = 0;
 559         mod_trace("%s", card->id.name);
 560         if (mutex_lock_interruptible(&card->fw.lock))
 561                 /* return -ERESTARTSYS*/;
 562         fw_up = card->fw.up;
 563         card->fw.up = 0;
 564
 565         if (card->irq.requested && card->irq.nr) {
 566                 free_irq(card->irq.nr, card);
 567                 card->irq.requested = 0;
 568         }
 569         if (fw_up) {
 570                 if (card->fn.enable_irq)
 571                         card->fn.enable_irq(card, 0);
 572                 if (card->fn.reset)
 573                         card->fn.reset(card, 1);
 574         }
 575         mutex_unlock(&card->fw.lock);
 576         tasklet_kill(&card->irq.bh);
 577 }
 578
 579 static int boot_card(struct softing *card)
 580 {
 581         mod_trace("%s", card->id.name);
 582         if (mutex_lock_interruptible(&card->fw.lock))
 583                 return -ERESTARTSYS;
 584         if (card->fw.up) {
 585                 mutex_unlock(&card->fw.lock);
 586                 return 0;
 587         }
 588         /*reset board */
 589
 590         if (card->fn.enable_irq)
 591                 card->fn.enable_irq(card, 1);
 592         /*boot card */
 593         if (card->fn.reset)
 594                 card->fn.reset(card, 1);
 595         /*test dp ram */
 596         if (card->dpram.virt) {
 597                 unsigned char *lp;
 598                 static const unsigned char stream[]
 599                 = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, };
 600                 unsigned char back[sizeof(stream)];
 601                 for (lp = card->dpram.virt;
 602                           &lp[sizeof(stream)] <= card->dpram.end;
 603                           lp += sizeof(stream)) {
 604                         memcpy_toio(lp, stream, sizeof(stream));
 605                         /* flush IO cache */
 606                         mb();
 607                         memcpy_fromio(back, lp, sizeof(stream));
 608
 609                         if (memcmp(back, stream, sizeof(stream))) {
 610                                 char line[3 * sizeof(stream)
 611                                         / sizeof(stream[0]) + 1];
 612                                 char *pline = line;
 613                                 unsigned char *addr = lp;
 614                                 for (lp = back; lp < &back[sizeof(stream)
 615                                                 / sizeof(stream[0])]; ++lp)
 616                                         pline += sprintf(pline, " %02x", *lp);
 617
 618                                 mod_alert("write to dpram failed at 0x%p, %s"
 619                                         , addr, line);
 620                                 goto open_failed;
 621                         }
 622                 }
 623                 /*fill dpram with 0x55 */
 624                 /*for (lp = card->dpram.virt; lp <= card->dpram.end; ++lp) {
 625                  *lp = 0x55;
 626                  }*/
 627                 wmb();
 628         } else {
 629                 goto open_failed;
 630         }
 631         /*load boot firmware */
 632         if (softing_load_fw(card->desc->boot.fw, card, card->dpram.virt,
 633                                  card->dpram.size,
 634                                  card->desc->boot.offs -
 635                                  card->desc->boot.addr))
 636                 goto open_failed;
 637         /*load load firmware */
 638         if (softing_load_fw(card->desc->load.fw, card, card->dpram.virt,
 639                                  card->dpram.size,
 640                                  card->desc->load.offs -
 641                                  card->desc->load.addr))
 642                 goto open_failed;
 643
 644         if (card->fn.reset)
 645                 card->fn.reset(card, 0);
 646         if (softing_bootloader_command(card, 0, "card boot"))
 647                 goto open_failed;
 648         if (softing_load_app_fw(card->desc->app.fw, card))
 649                 goto open_failed;
 650         /*reset chip */
 651         card->dpram.info->reset_rcv_fifo = 0;
 652         card->dpram.info->reset = 1;
 653         /*sync */
 654         if (softing_fct_cmd(card, 99, 0x55, "sync-a"))
 655                 goto open_failed;
 656         if (softing_fct_cmd(card, 99, 0xaa, "sync-a"))
 657                 goto open_failed;
 658         /*reset chip */
 659         if (softing_fct_cmd(card, 0, 0, "reset_chip"))
 660                 goto open_failed;
 661         /*get_serial */
 662         if (softing_fct_cmd(card, 43, 0, "get_serial_number"))
 663                 goto open_failed;
 664         card->id.serial =
 665                  (u16) card->dpram.fct->param[1] +
 666                  (((u16) card->dpram.fct->param[2]) << 16);
 667         /*get_version */
 668         if (softing_fct_cmd(card, 12, 0, "get_version"))
 669                 goto open_failed;
 670         card->id.fw = (u16) card->dpram.fct->param[1];
 671         card->id.hw = (u16) card->dpram.fct->param[2];
 672         card->id.lic = (u16) card->dpram.fct->param[3];
 673         card->id.chip[0] = (u16) card->dpram.fct->param[4];
 674         card->id.chip[1] = (u16) card->dpram.fct->param[5];
 675
 676         mod_info("%s, card booted, "
 677                         "serial %u, fw %u, hw %u, lic %u, chip (%u,%u)",
 678                   card->id.name, card->id.serial, card->id.fw, card->id.hw,
 679                   card->id.lic, card->id.chip[0], card->id.chip[1]);
 680
 681         card->fw.up = 1;
 682         mutex_unlock(&card->fw.lock);
 683         return 0;
 684 open_failed:
 685         card->fw.up = 0;
 686         if (card->fn.enable_irq)
 687                 card->fn.enable_irq(card, 0);
 688         if (card->fn.reset)
 689                 card->fn.reset(card, 1);
 690         mutex_unlock(&card->fw.lock);
 691         return EINVAL;
 692 }
 693
 694 /*sysfs stuff*/
 695
 696 /* Because the struct softing may be used by pcmcia devices
 697  * as well as pci devices, * we have no clue how to get
 698  * from a struct device * towards the struct softing *.
 699  * It may go over a pci_device->priv or over a pcmcia_device->priv.
 700  * Therefore, provide the struct softing pointer within the attribute.
 701  * Then we don't need driver/bus specific things in these attributes
 702  */
 703 struct softing_attribute {
 704         struct device_attribute dev;
 705         ssize_t (*show) (struct softing *card, char *buf);
 706         ssize_t (*store)(struct softing *card, const char *buf, size_t count);
 707         struct softing *card;
 708 };
 709
 710 static ssize_t rd_card_attr(struct device *dev, struct device_attribute *attr
 711                 , char *buf) {
 712         struct softing_attribute *cattr
 713                 = container_of(attr, struct softing_attribute, dev);
 714         return cattr->show ? cattr->show(cattr->card, buf) : 0;
 715 }
 716 static ssize_t wr_card_attr(struct device *dev, struct device_attribute *attr
 717                 , const char *buf, size_t count) {
 718         struct softing_attribute *cattr
 719                 = container_of(attr, struct softing_attribute, dev);
 720         return cattr->store ? cattr->store(cattr->card, buf, count) : 0;
 721 }
 722
 723 #define declare_attr(_name, _mode, _show, _store) { \
 724         .dev = { \
 725                 .attr = { \
 726                         .name = __stringify(_name), \
 727                         .mode = _mode, \
 728                 }, \
 729                 .show = rd_card_attr, \
 730                 .store = wr_card_attr, \
 731         }, \
 732         .show = _show, \
 733         .store = _store, \
 734 }
 735
 736 #define CARD_SHOW(name, member) \
 737 static ssize_t show_##name(struct softing *card, char *buf) { \
 738         return sprintf(buf, "%u\n", card->member); \
 739 }
 740 CARD_SHOW(serial        , id.serial);
 741 CARD_SHOW(firmware      , id.fw);
 742 CARD_SHOW(hardware      , id.hw);
 743 CARD_SHOW(license       , id.lic);
 744 CARD_SHOW(freq          , id.freq);
 745 CARD_SHOW(txpending     , tx.pending);
 746
 747 static const struct softing_attribute card_attr_proto [] = {
 748         declare_attr(serial     , 0644, show_serial     , 0),
 749         declare_attr(firmware   , 0644, show_firmware   , 0),
 750         declare_attr(hardware   , 0644, show_hardware   , 0),
 751         declare_attr(license    , 0644, show_license    , 0),
 752         declare_attr(freq       , 0644, show_freq       , 0),
 753         declare_attr(txpending  , 0644, show_txpending  , 0),
 754 };
 755
 756 static int mk_card_sysfs(struct softing *card)
 757 {
 758         int size;
 759         int j;
 760
 761         size = sizeof(card_attr_proto)/sizeof(card_attr_proto[0]);
 762         card->attr = kmalloc((size+1)*sizeof(card->attr[0]), GFP_KERNEL);
 763         if (!card->attr)
 764                 goto attr_mem_failed;
 765         memcpy(card->attr, card_attr_proto, size * sizeof(card->attr[0]));
 766         memset(&card->attr[size], 0, sizeof(card->attr[0]));
 767
 768         card->grp  = kmalloc((size+1)*sizeof(card->grp [0]), GFP_KERNEL);
 769         if (!card->grp)
 770                 goto grp_mem_failed;
 771
 772         for (j = 0; j < size; ++j) {
 773                 card->attr[j].card = card;
 774                 card->grp[j] = &card->attr[j].dev.attr;
 775                 if (!card->attr[j].show)
 776                         card->attr[j].dev.attr.mode &= ~(S_IRUGO);
 777                 if (!card->attr[j].store)
 778                         card->attr[j].dev.attr.mode &= ~(S_IWUGO);
 779         }
 780         card->grp[size] = 0;
 781         card->sysfs.name        = "softing";
 782         card->sysfs.attrs = card->grp;
 783         if (sysfs_create_group(&card->dev->kobj, &card->sysfs) < 0)
 784                 goto sysfs_failed;
 785
 786         return 0;
 787
 788 sysfs_failed:
 789         kfree(card->grp);
 790 grp_mem_failed:
 791         kfree(card->attr);
 792 attr_mem_failed:
 793         return -1;
 794 }
 795 static void rm_card_sysfs(struct softing *card)
 796 {
 797         sysfs_remove_group(&card->dev->kobj, &card->sysfs);
 798         kfree(card->grp);
 799         kfree(card->attr);
 800 }
 801
 802 static ssize_t show_chip(struct device *dev
 803                 , struct device_attribute *attr, char *buf)
 804 {
 805         struct net_device *ndev = to_net_dev(dev);
 806         struct softing_priv *priv = netdev2softing(ndev);
 807         return sprintf(buf, "%i\n", priv->chip);
 808 }
 809
 810 static ssize_t show_output(struct device *dev
 811                 , struct device_attribute *attr, char *buf)
 812 {
 813         struct net_device *ndev = to_net_dev(dev);
 814         struct softing_priv *priv = netdev2softing(ndev);
 815         return sprintf(buf, "0x%02x\n", priv->output);
 816 }
 817
 818 static ssize_t store_output(struct device *dev
 819                 , struct device_attribute *attr
 820                 , const char *buf, size_t count)
 821 {
 822         struct net_device *ndev = to_net_dev(dev);
 823         struct softing_priv *priv = netdev2softing(ndev);
 824         struct softing *card = priv->card;
 825
 826         int v = strict_strtol(buf, 0, 0);
 827
 828         if (mutex_lock_interruptible(&card->fw.lock))
 829                 return -ERESTARTSYS;
 830         if (ndev->flags & IFF_UP) {
 831                 int j;
 832                 /* we will need a restart */
 833                 for (j = 0; j < card->nbus; ++j) {
 834                         if (j == priv->index)
 835                                 /* me, myself & I */
 836                                 continue;
 837                         if (card->bus[j]->netdev->flags & IFF_UP) {
 838                                 mutex_unlock(&card->fw.lock);
 839                                 return -EBUSY;
 840                         }
 841                 }
 842                 priv->output = v;
 843                 softing_reinit(card, -1, -1);
 844         } else {
 845                 priv->output = v;
 846         }
 847         mutex_unlock(&card->fw.lock);
 848         return count;
 849 }
 850 /* TODO
 851  * the latest softing cards support sleep mode too
 852  */
 853
 854 static const DEVICE_ATTR(chip, S_IRUGO, show_chip, 0);
 855 static const DEVICE_ATTR(output, S_IRUGO | S_IWUSR, show_output, store_output);
 856
 857 static const struct attribute *const netdev_sysfs_entries [] = {
 858         &dev_attr_chip          .attr,
 859         &dev_attr_output        .attr,
 860         0,
 861 };
 862 static const struct attribute_group netdev_sysfs = {
 863         .name  = 0,
 864         .attrs = (struct attribute **)netdev_sysfs_entries,
 865 };
 866
 867 static int mk_netdev_sysfs(struct softing_priv *priv)
 868 {
 869         if (!priv->netdev->dev.kobj.sd) {
 870                 mod_alert("sysfs_create_group would fail");
 871                 return ENODEV;
 872         }
 873         return sysfs_create_group(&priv->netdev->dev.kobj, &netdev_sysfs);
 874 }
 875 static void rm_netdev_sysfs(struct softing_priv *priv)
 876 {
 877         sysfs_remove_group(&priv->netdev->dev.kobj, &netdev_sysfs);
 878 }
 879
 880 static struct softing_priv *mk_netdev(struct softing *card, u16 chip_id)
 881 {
 882         struct net_device *ndev;
 883         struct softing_priv *priv;
 884
 885         ndev = alloc_candev(sizeof(*priv));
 886         if (!ndev) {
 887                 mod_alert("alloc_candev failed");
 888                 return 0;
 889         }
 890         priv = netdev_priv(ndev);
 891         priv->netdev            = ndev;
 892         priv->card              = card;
 893
 894         priv->can.bittiming.bitrate = 250000UL; /* default bitrate */
 895         priv->can.bittiming.clock = 8000000UL;
 896 //      priv->can.bittiming.clock = card->desc->freq * 1000000 / 2;
 897
 898         /* point to private card description dependent bittiming */
 899         priv->can.bittiming_const = &priv->softing_bittiming;
 900
 901         /* fill card description dependent bittiming */
 902         priv->softing_bittiming.tseg1_min = 1;
 903         priv->softing_bittiming.tseg1_max = 16;
 904         priv->softing_bittiming.tseg2_min = 1;
 905         priv->softing_bittiming.tseg2_max = 8;
 906         priv->softing_bittiming.sjw_max = card->desc->max_sjw;
 907         priv->softing_bittiming.brp_min = 1;
 908         priv->softing_bittiming.brp_max = card->desc->max_brp;
 909         priv->softing_bittiming.brp_inc = 1;
 910
 911         priv->sample            = 1;
 912         priv->chip              = chip_id;
 913         priv->output = softing_default_output(card, priv);
 914         SET_NETDEV_DEV(ndev, card->dev);
 915
 916         ndev->flags |= IFF_ECHO;
 917         ndev->open              = netdev_open;
 918         ndev->stop              = netdev_stop;
 919         ndev->hard_start_xmit   = netdev_start_xmit;
 920         priv->can.do_set_bittiming = candev_set_bittiming;
 921         priv->can.do_get_state  = candev_get_state;
 922         priv->can.do_set_mode   = candev_set_mode;
 923
 924         if (can_set_bittiming(ndev))
 925                 mod_alert("bitrate failed");
 926
 927         return priv;
 928 }
 929
 930 static void rm_netdev(struct softing_priv *priv)
 931 {
 932         free_candev(priv->netdev);
 933 }
 934
 935 static int reg_netdev(struct softing_priv *priv)
 936 {
 937         int ret;
 938         netif_carrier_off(priv->netdev);
 939         ret = register_netdev(priv->netdev);
 940         if (ret) {
 941                 mod_alert("%s, register failed", priv->card->id.name);
 942                 goto reg_failed;
 943         }
 944         ret = mk_netdev_sysfs(priv);
 945         if (ret) {
 946                 mod_alert("%s, sysfs failed", priv->card->id.name);
 947                 goto sysfs_failed;
 948         }
 949         return 0;
 950 sysfs_failed:
 951         unregister_netdev(priv->netdev);
 952 reg_failed:
 953         return EINVAL;
 954 }
 955
 956 static void unreg_netdev(struct softing_priv *priv)
 957 {
 958         rm_netdev_sysfs(priv);
 959         unregister_netdev(priv->netdev);
 960 }
 961
 962 void rm_softing(struct softing *card)
 963 {
 964         int j;
 965
 966         /*first, disable card*/
 967         shutdown_card(card);
 968
 969         for (j = 0; j < card->nbus; ++j) {
 970                 unreg_netdev(card->bus[j]);
 971                 rm_netdev(card->bus[j]);
 972         }
 973
 974         rm_card_sysfs(card);
 975
 976         iounmap(card->dpram.virt);
 977 }
 978 EXPORT_SYMBOL(rm_softing);
 979
 980 int mk_softing(struct softing *card)
 981 {
 982         int j;
 983
 984         /* try_module_get(THIS_MODULE); */
 985         mutex_init(&card->fw.lock);
 986         spin_lock_init(&card->spin);
 987         tasklet_init(&card->irq.bh, softing_dev_svc, (unsigned long)card);
 988
 989         card->desc = softing_lookup_desc(card->id.manf, card->id.prod);
 990         if (!card->desc) {
 991                 mod_alert("0x%04x:0x%04x not supported\n", card->id.manf,
 992                           card->id.prod);
 993                 goto lookup_failed;
 994         }
 995         card->id.name = card->desc->name;
 996         mod_trace("can (%s)", card->id.name);
 997
 998         card->dpram.virt = ioremap(card->dpram.phys, card->dpram.size);
 999         if (!card->dpram.virt) {
1000                 mod_alert("dpram ioremap failed\n");
1001                 goto ioremap_failed;
1002         }
1003
1004         card->dpram.size = card->desc->dpram_size;
1005         card->dpram.end = &card->dpram.virt[card->dpram.size];
1006         /*initialize_board */
1007         card->dpram.rx = (struct softing_rx *)&card->dpram.virt[0x0000];
1008         card->dpram.tx = (struct softing_tx *)&card->dpram.virt[0x0400];
1009         card->dpram.fct = (struct softing_fct *)&card->dpram.virt[0x0300];
1010         card->dpram.info = (struct softing_info *)&card->dpram.virt[0x0330];
1011         card->dpram.command = (unsigned short *)&card->dpram.virt[0x07e0];
1012         card->dpram.receipt = (unsigned short *)&card->dpram.virt[0x07f0];
1013         card->dpram.irq = (struct softing_irq *)&card->dpram.virt[0x07fe];
1014
1015         /*reset card */
1016         if (card->fn.reset)
1017                 card->fn.reset(card, 1);
1018         if (boot_card(card)) {
1019                 mod_alert("%s, failed to boot", card->id.name);
1020                 goto boot_failed;
1021         }
1022
1023         /*only now, the chip's are known */
1024         card->id.freq = card->desc->freq * 1000000UL;
1025
1026         if (mk_card_sysfs(card)) {
1027                 mod_alert("%s, sysfs failed", card->id.name);
1028                 goto sysfs_failed;
1029         }
1030
1031         if (card->nbus > (sizeof(card->bus) / sizeof(card->bus[0]))) {
1032                 card->nbus = sizeof(card->bus) / sizeof(card->bus[0]);
1033                 mod_alert("%s, going for %u busses", card->id.name, card->nbus);
1034         }
1035
1036         for (j = 0; j < card->nbus; ++j) {
1037                 card->bus[j] = mk_netdev(card, card->id.chip[j]);
1038                 if (!card->bus[j]) {
1039                         mod_alert("%s: failed to make can[%i]", card->id.name,
1040                                   j);
1041                         goto netdev_failed;
1042                 }
1043                 card->bus[j]->index = j;
1044         }
1045         for (j = 0; j < card->nbus; ++j) {
1046                 if (reg_netdev(card->bus[j])) {
1047                         mod_alert("%s: failed to register can[%i]",
1048                                   card->id.name, j);
1049                         goto reg_failed;
1050                 }
1051         }
1052         mod_trace("card initialised");
1053         return 0;
1054
1055 reg_failed:
1056         for (j = 0; j < card->nbus; ++j)
1057                 unreg_netdev(card->bus[j]);
1058 netdev_failed:
1059         for (j = 0; j < card->nbus; ++j) {
1060                 if (card->bus[j])
1061                         rm_netdev(card->bus[j]);
1062         }
1063         rm_card_sysfs(card);
1064 sysfs_failed:
1065         shutdown_card(card);
1066 boot_failed:
1067         iounmap(card->dpram.virt);
1068         card->dpram.virt = 0;
1069         card->dpram.end = 0;
1070 ioremap_failed:
1071 lookup_failed:
1072         tasklet_kill(&card->irq.bh);
1073         return EINVAL;
1074 }
1075 EXPORT_SYMBOL(mk_softing);
1076
1077 static int __init mod_start(void)
1078 {
1079         mod_trace("");
1080         return 0;
1081 }
1082
1083 static void __exit mod_stop(void)
1084 {
1085         mod_trace("");
1086 }
1087
1088 module_init(mod_start);
1089 module_exit(mod_stop);
1090
1091 MODULE_DESCRIPTION("socketcan softing driver");
1092 MODULE_AUTHOR("Kurt Van Dijck <kurt.van.dijck@eia.be>");
1093 MODULE_LICENSE("GPL");
1094
1095 int softing_debug = 1;
1096 EXPORT_SYMBOL(softing_debug);
1097 module_param(softing_debug, int , S_IRUGO | S_IWUSR | S_IWGRP);
1098 MODULE_PARM_DESC(softing_debug, "trace softing functions");