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_bittime(struct net_device *ndev, struct can_bittime *bt)
 471 {
 472         switch (bt->type) {
 473         case CAN_BITTIME_STD:
 474                 /*SJW is test via max_sjw */
 475                 if (out_of_range(bt->std.sjw, 1, 4))
 476                         return -EIO;
 477                 if (out_of_range(bt->std.phase_seg1 + bt->std.prop_seg, 1, 16))
 478                         return -EIO;
 479                 if (out_of_range(bt->std.phase_seg2, 1, 8))
 480                         return -EIO;
 481                 /*BRP is test via max_brp */
 482                 if (ndev->flags & IFF_UP)
 483                         return -EBUSY;
 484                 break;
 485         case CAN_BITTIME_BTR:
 486         default:
 487                 mod_alert("%s, type %i not supported", ndev->name, bt->type);
 488                 return -EINVAL;
 489                 break;
 490         }
 491         return 0;
 492 }
 493
 494 static int candev_get_state(struct net_device *ndev, enum can_state *state)
 495 {
 496         struct softing_priv *priv = netdev_priv(ndev);
 497         mod_trace("%s", ndev->name);
 498         if (priv->netdev->flags & IFF_UP)
 499                 *state = CAN_STATE_STOPPED;
 500         else if (priv->can.state == CAN_STATE_STOPPED)
 501                 *state = CAN_STATE_STOPPED;
 502         else
 503                 *state = CAN_STATE_ACTIVE;
 504         return 0;
 505 }
 506
 507 static int candev_set_mode(struct net_device *ndev, enum can_mode mode)
 508 {
 509         struct softing_priv *priv = netdev_priv(ndev);
 510         struct softing *card = priv->card;
 511         mod_trace("%s %u", ndev->name, mode);
 512         switch (mode) {
 513         case CAN_MODE_START:
 514                 /*recovery from busoff? */
 515                 if (mutex_lock_interruptible(&card->fw.lock))
 516                         return -ERESTARTSYS;
 517                 softing_reinit(card, -1, -1);
 518                 mutex_unlock(&card->fw.lock);
 519                 break;
 520         case CAN_MODE_STOP:
 521         case CAN_MODE_SLEEP:
 522                 return -EOPNOTSUPP;
 523         }
 524         return 0;
 525 }
 526
 527 /*assume the card->lock is held*/
 528
 529 int softing_card_irq(struct softing *card, int enable)
 530 {
 531         int ret;
 532         if (!enable) {
 533                 if (card->irq.requested && card->irq.nr) {
 534                         free_irq(card->irq.nr, card);
 535                         card->irq.requested = 0;
 536                 }
 537                 return 0;
 538         }
 539         if (!card->irq.requested && (card->irq.nr)) {
 540                 irqreturn_t(*fn) (int, void *);
 541                 unsigned int flags;
 542                 flags = IRQF_DISABLED;  /*| IRQF_TRIGGER_LOW; */
 543                 fn = dev_interrupt_nshared;
 544                 if (card->irq.shared) {
 545                         flags |= IRQF_SHARED;
 546                         fn = dev_interrupt_shared;
 547                 }
 548                 ret = request_irq(card->irq.nr, fn, flags, card->id.name, card);
 549                 if (ret) {
 550                         mod_alert("%s, request_irq(%u) failed, %s shared"
 551                                 , card->id.name, card->irq.nr
 552                                 , (card->irq.shared ? "" : "not")
 553                                 );
 554                         return ret;
 555                 }
 556                 card->irq.requested = 1;
 557         }
 558         return 0;
 559 }
 560
 561 static void shutdown_card(struct softing *card)
 562 {
 563         int fw_up = 0;
 564         mod_trace("%s", card->id.name);
 565         if (mutex_lock_interruptible(&card->fw.lock))
 566                 /* return -ERESTARTSYS*/;
 567         fw_up = card->fw.up;
 568         card->fw.up = 0;
 569
 570         if (card->irq.requested && card->irq.nr) {
 571                 free_irq(card->irq.nr, card);
 572                 card->irq.requested = 0;
 573         }
 574         if (fw_up) {
 575                 if (card->fn.enable_irq)
 576                         card->fn.enable_irq(card, 0);
 577                 if (card->fn.reset)
 578                         card->fn.reset(card, 1);
 579         }
 580         mutex_unlock(&card->fw.lock);
 581         tasklet_kill(&card->irq.bh);
 582 }
 583
 584 static int boot_card(struct softing *card)
 585 {
 586         mod_trace("%s", card->id.name);
 587         if (mutex_lock_interruptible(&card->fw.lock))
 588                 return -ERESTARTSYS;
 589         if (card->fw.up) {
 590                 mutex_unlock(&card->fw.lock);
 591                 return 0;
 592         }
 593         /*reset board */
 594
 595         if (card->fn.enable_irq)
 596                 card->fn.enable_irq(card, 1);
 597         /*boot card */
 598         if (card->fn.reset)
 599                 card->fn.reset(card, 1);
 600         /*test dp ram */
 601         if (card->dpram.virt) {
 602                 unsigned char *lp;
 603                 static const unsigned char stream[]
 604                 = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, };
 605                 unsigned char back[sizeof(stream)];
 606                 for (lp = card->dpram.virt;
 607                           &lp[sizeof(stream)] <= card->dpram.end;
 608                           lp += sizeof(stream)) {
 609                         memcpy_toio(lp, stream, sizeof(stream));
 610                         /* flush IO cache */
 611                         mb();
 612                         memcpy_fromio(back, lp, sizeof(stream));
 613
 614                         if (memcmp(back, stream, sizeof(stream))) {
 615                                 char line[3 * sizeof(stream)
 616                                         / sizeof(stream[0]) + 1];
 617                                 char *pline = line;
 618                                 unsigned char *addr = lp;
 619                                 for (lp = back; lp < &back[sizeof(stream)
 620                                                 / sizeof(stream[0])]; ++lp)
 621                                         pline += sprintf(pline, " %02x", *lp);
 622
 623                                 mod_alert("write to dpram failed at 0x%p, %s"
 624                                         , addr, line);
 625                                 goto open_failed;
 626                         }
 627                 }
 628                 /*fill dpram with 0x55 */
 629                 /*for (lp = card->dpram.virt; lp <= card->dpram.end; ++lp) {
 630                  *lp = 0x55;
 631                  }*/
 632                 wmb();
 633         } else {
 634                 goto open_failed;
 635         }
 636         /*load boot firmware */
 637         if (softing_load_fw(card->desc->boot.fw, card, card->dpram.virt,
 638                                  card->dpram.size,
 639                                  card->desc->boot.offs -
 640                                  card->desc->boot.addr))
 641                 goto open_failed;
 642         /*load load firmware */
 643         if (softing_load_fw(card->desc->load.fw, card, card->dpram.virt,
 644                                  card->dpram.size,
 645                                  card->desc->load.offs -
 646                                  card->desc->load.addr))
 647                 goto open_failed;
 648
 649         if (card->fn.reset)
 650                 card->fn.reset(card, 0);
 651         if (softing_bootloader_command(card, 0, "card boot"))
 652                 goto open_failed;
 653         if (softing_load_app_fw(card->desc->app.fw, card))
 654                 goto open_failed;
 655         /*reset chip */
 656         card->dpram.info->reset_rcv_fifo = 0;
 657         card->dpram.info->reset = 1;
 658         /*sync */
 659         if (softing_fct_cmd(card, 99, 0x55, "sync-a"))
 660                 goto open_failed;
 661         if (softing_fct_cmd(card, 99, 0xaa, "sync-a"))
 662                 goto open_failed;
 663         /*reset chip */
 664         if (softing_fct_cmd(card, 0, 0, "reset_chip"))
 665                 goto open_failed;
 666         /*get_serial */
 667         if (softing_fct_cmd(card, 43, 0, "get_serial_number"))
 668                 goto open_failed;
 669         card->id.serial =
 670                  (u16) card->dpram.fct->param[1] +
 671                  (((u16) card->dpram.fct->param[2]) << 16);
 672         /*get_version */
 673         if (softing_fct_cmd(card, 12, 0, "get_version"))
 674                 goto open_failed;
 675         card->id.fw = (u16) card->dpram.fct->param[1];
 676         card->id.hw = (u16) card->dpram.fct->param[2];
 677         card->id.lic = (u16) card->dpram.fct->param[3];
 678         card->id.chip[0] = (u16) card->dpram.fct->param[4];
 679         card->id.chip[1] = (u16) card->dpram.fct->param[5];
 680
 681         mod_info("%s, card booted, "
 682                         "serial %u, fw %u, hw %u, lic %u, chip (%u,%u)",
 683                   card->id.name, card->id.serial, card->id.fw, card->id.hw,
 684                   card->id.lic, card->id.chip[0], card->id.chip[1]);
 685
 686         card->fw.up = 1;
 687         mutex_unlock(&card->fw.lock);
 688         return 0;
 689 open_failed:
 690         card->fw.up = 0;
 691         if (card->fn.enable_irq)
 692                 card->fn.enable_irq(card, 0);
 693         if (card->fn.reset)
 694                 card->fn.reset(card, 1);
 695         mutex_unlock(&card->fw.lock);
 696         return EINVAL;
 697 }
 698
 699 /*sysfs stuff*/
 700
 701 /* Because the struct softing may be used by pcmcia devices
 702  * as well as pci devices, * we have no clue how to get
 703  * from a struct device * towards the struct softing *.
 704  * It may go over a pci_device->priv or over a pcmcia_device->priv.
 705  * Therefore, provide the struct softing pointer within the attribute.
 706  * Then we don't need driver/bus specific things in these attributes
 707  */
 708 struct softing_attribute {
 709         struct device_attribute dev;
 710         ssize_t (*show) (struct softing *card, char *buf);
 711         ssize_t (*store)(struct softing *card, const char *buf, size_t count);
 712         struct softing *card;
 713 };
 714
 715 static ssize_t rd_card_attr(struct device *dev, struct device_attribute *attr
 716                 , char *buf) {
 717         struct softing_attribute *cattr
 718                 = container_of(attr, struct softing_attribute, dev);
 719         return cattr->show ? cattr->show(cattr->card, buf) : 0;
 720 }
 721 static ssize_t wr_card_attr(struct device *dev, struct device_attribute *attr
 722                 , const char *buf, size_t count) {
 723         struct softing_attribute *cattr
 724                 = container_of(attr, struct softing_attribute, dev);
 725         return cattr->store ? cattr->store(cattr->card, buf, count) : 0;
 726 }
 727
 728 #define declare_attr(_name, _mode, _show, _store) { \
 729         .dev = { \
 730                 .attr = { \
 731                         .name = __stringify(_name), \
 732                         .mode = _mode, \
 733                 }, \
 734                 .show = rd_card_attr, \
 735                 .store = wr_card_attr, \
 736         }, \
 737         .show = _show, \
 738         .store = _store, \
 739 }
 740
 741 #define CARD_SHOW(name, member) \
 742 static ssize_t show_##name(struct softing *card, char *buf) { \
 743         return sprintf(buf, "%u\n", card->member); \
 744 }
 745 CARD_SHOW(serial        , id.serial);
 746 CARD_SHOW(firmware      , id.fw);
 747 CARD_SHOW(hardware      , id.hw);
 748 CARD_SHOW(license       , id.lic);
 749 CARD_SHOW(freq          , id.freq);
 750 CARD_SHOW(txpending     , tx.pending);
 751
 752 static const struct softing_attribute card_attr_proto [] = {
 753         declare_attr(serial     , 0644, show_serial     , 0),
 754         declare_attr(firmware   , 0644, show_firmware   , 0),
 755         declare_attr(hardware   , 0644, show_hardware   , 0),
 756         declare_attr(license    , 0644, show_license    , 0),
 757         declare_attr(freq       , 0644, show_freq       , 0),
 758         declare_attr(txpending  , 0644, show_txpending  , 0),
 759 };
 760
 761 static int mk_card_sysfs(struct softing *card)
 762 {
 763         int size;
 764         int j;
 765
 766         size = sizeof(card_attr_proto)/sizeof(card_attr_proto[0]);
 767         card->attr = kmalloc((size+1)*sizeof(card->attr[0]), GFP_KERNEL);
 768         if (!card->attr)
 769                 goto attr_mem_failed;
 770         memcpy(card->attr, card_attr_proto, size * sizeof(card->attr[0]));
 771         memset(&card->attr[size], 0, sizeof(card->attr[0]));
 772
 773         card->grp  = kmalloc((size+1)*sizeof(card->grp [0]), GFP_KERNEL);
 774         if (!card->grp)
 775                 goto grp_mem_failed;
 776
 777         for (j = 0; j < size; ++j) {
 778                 card->attr[j].card = card;
 779                 card->grp[j] = &card->attr[j].dev.attr;
 780                 if (!card->attr[j].show)
 781                         card->attr[j].dev.attr.mode &= ~(S_IRUGO);
 782                 if (!card->attr[j].store)
 783                         card->attr[j].dev.attr.mode &= ~(S_IWUGO);
 784         }
 785         card->grp[size] = 0;
 786         card->sysfs.name        = "softing";
 787         card->sysfs.attrs = card->grp;
 788         if (sysfs_create_group(&card->dev->kobj, &card->sysfs) < 0)
 789                 goto sysfs_failed;
 790
 791         return 0;
 792
 793 sysfs_failed:
 794         kfree(card->grp);
 795 grp_mem_failed:
 796         kfree(card->attr);
 797 attr_mem_failed:
 798         return -1;
 799 }
 800 static void rm_card_sysfs(struct softing *card)
 801 {
 802         sysfs_remove_group(&card->dev->kobj, &card->sysfs);
 803         kfree(card->grp);
 804         kfree(card->attr);
 805 }
 806
 807 static ssize_t show_chip(struct device *dev
 808                 , struct device_attribute *attr, char *buf)
 809 {
 810         struct net_device *ndev = to_net_dev(dev);
 811         struct softing_priv *priv = netdev2softing(ndev);
 812         return sprintf(buf, "%i\n", priv->chip);
 813 }
 814
 815 static ssize_t show_output(struct device *dev
 816                 , struct device_attribute *attr, char *buf)
 817 {
 818         struct net_device *ndev = to_net_dev(dev);
 819         struct softing_priv *priv = netdev2softing(ndev);
 820         return sprintf(buf, "0x%02x\n", priv->output);
 821 }
 822
 823 static ssize_t store_output(struct device *dev
 824                 , struct device_attribute *attr
 825                 , const char *buf, size_t count)
 826 {
 827         struct net_device *ndev = to_net_dev(dev);
 828         struct softing_priv *priv = netdev2softing(ndev);
 829         struct softing *card = priv->card;
 830
 831         int v = strict_strtol(buf, 0, 0);
 832
 833         if (mutex_lock_interruptible(&card->fw.lock))
 834                 return -ERESTARTSYS;
 835         if (ndev->flags & IFF_UP) {
 836                 int j;
 837                 /* we will need a restart */
 838                 for (j = 0; j < card->nbus; ++j) {
 839                         if (j == priv->index)
 840                                 /* me, myself & I */
 841                                 continue;
 842                         if (card->bus[j]->netdev->flags & IFF_UP) {
 843                                 mutex_unlock(&card->fw.lock);
 844                                 return -EBUSY;
 845                         }
 846                 }
 847                 priv->output = v;
 848                 softing_reinit(card, -1, -1);
 849         } else {
 850                 priv->output = v;
 851         }
 852         mutex_unlock(&card->fw.lock);
 853         return count;
 854 }
 855 /* TODO
 856  * the latest softing cards support sleep mode too
 857  */
 858
 859 static const DEVICE_ATTR(chip, S_IRUGO, show_chip, 0);
 860 static const DEVICE_ATTR(output, S_IRUGO | S_IWUSR, show_output, store_output);
 861
 862 static const struct attribute *const netdev_sysfs_entries [] = {
 863         &dev_attr_chip          .attr,
 864         &dev_attr_output        .attr,
 865         0,
 866 };
 867 static const struct attribute_group netdev_sysfs = {
 868         .name  = 0,
 869         .attrs = (struct attribute **)netdev_sysfs_entries,
 870 };
 871
 872 static int mk_netdev_sysfs(struct softing_priv *priv)
 873 {
 874         if (!priv->netdev->dev.kobj.sd) {
 875                 mod_alert("sysfs_create_group would fail");
 876                 return ENODEV;
 877         }
 878         return sysfs_create_group(&priv->netdev->dev.kobj, &netdev_sysfs);
 879 }
 880 static void rm_netdev_sysfs(struct softing_priv *priv)
 881 {
 882         sysfs_remove_group(&priv->netdev->dev.kobj, &netdev_sysfs);
 883 }
 884
 885 static struct softing_priv *mk_netdev(struct softing *card, u16 chip_id)
 886 {
 887         struct net_device *ndev;
 888         struct softing_priv *priv;
 889
 890         ndev = alloc_candev(sizeof(*priv));
 891         if (!ndev) {
 892                 mod_alert("alloc_candev failed");
 893                 return 0;
 894         }
 895         priv = netdev_priv(ndev);
 896         priv->netdev            = ndev;
 897         priv->card              = card;
 898         priv->can.can_sys_clock = 8000000UL;
 899         priv->can.max_brp       = card->desc->max_brp;
 900         priv->can.max_sjw       = card->desc->max_sjw;
 901         priv->sample            = 1;
 902         priv->chip              = chip_id;
 903         priv->output = softing_default_output(card, priv);
 904         SET_NETDEV_DEV(ndev, card->dev);
 905
 906         ndev->flags |= IFF_ECHO;
 907         ndev->open              = netdev_open;
 908         ndev->stop              = netdev_stop;
 909         ndev->hard_start_xmit   = netdev_start_xmit;
 910         priv->can.do_set_bittime = candev_set_bittime;
 911         priv->can.do_get_state  = candev_get_state;
 912         priv->can.do_set_mode   = candev_set_mode;
 913
 914         if (can_set_bitrate(ndev, 250000UL))
 915                 mod_alert("bitrate failed");
 916
 917         return priv;
 918 }
 919
 920 static void rm_netdev(struct softing_priv *priv)
 921 {
 922         free_candev(priv->netdev);
 923 }
 924
 925 static int reg_netdev(struct softing_priv *priv)
 926 {
 927         int ret;
 928         netif_carrier_off(priv->netdev);
 929         ret = register_netdev(priv->netdev);
 930         if (ret) {
 931                 mod_alert("%s, register failed", priv->card->id.name);
 932                 goto reg_failed;
 933         }
 934         ret = mk_netdev_sysfs(priv);
 935         if (ret) {
 936                 mod_alert("%s, sysfs failed", priv->card->id.name);
 937                 goto sysfs_failed;
 938         }
 939         return 0;
 940 sysfs_failed:
 941         unregister_netdev(priv->netdev);
 942 reg_failed:
 943         return EINVAL;
 944 }
 945
 946 static void unreg_netdev(struct softing_priv *priv)
 947 {
 948         rm_netdev_sysfs(priv);
 949         unregister_netdev(priv->netdev);
 950 }
 951
 952 void rm_softing(struct softing *card)
 953 {
 954         int j;
 955
 956         /*first, disable card*/
 957         shutdown_card(card);
 958
 959         for (j = 0; j < card->nbus; ++j) {
 960                 unreg_netdev(card->bus[j]);
 961                 rm_netdev(card->bus[j]);
 962         }
 963
 964         rm_card_sysfs(card);
 965
 966         iounmap(card->dpram.virt);
 967 }
 968 EXPORT_SYMBOL(rm_softing);
 969
 970 int mk_softing(struct softing *card)
 971 {
 972         int j;
 973
 974         /* try_module_get(THIS_MODULE); */
 975         mutex_init(&card->fw.lock);
 976         spin_lock_init(&card->spin);
 977         tasklet_init(&card->irq.bh, softing_dev_svc, (unsigned long)card);
 978
 979         card->desc = softing_lookup_desc(card->id.manf, card->id.prod);
 980         if (!card->desc) {
 981                 mod_alert("0x%04x:0x%04x not supported\n", card->id.manf,
 982                           card->id.prod);
 983                 goto lookup_failed;
 984         }
 985         card->id.name = card->desc->name;
 986         mod_trace("can (%s)", card->id.name);
 987
 988         card->dpram.virt = ioremap(card->dpram.phys, card->dpram.size);
 989         if (!card->dpram.virt) {
 990                 mod_alert("dpram ioremap failed\n");
 991                 goto ioremap_failed;
 992         }
 993
 994         card->dpram.size = card->desc->dpram_size;
 995         card->dpram.end = &card->dpram.virt[card->dpram.size];
 996         /*initialize_board */
 997         card->dpram.rx = (struct softing_rx *)&card->dpram.virt[0x0000];
 998         card->dpram.tx = (struct softing_tx *)&card->dpram.virt[0x0400];
 999         card->dpram.fct = (struct softing_fct *)&card->dpram.virt[0x0300];
1000         card->dpram.info = (struct softing_info *)&card->dpram.virt[0x0330];
1001         card->dpram.command = (unsigned short *)&card->dpram.virt[0x07e0];
1002         card->dpram.receipt = (unsigned short *)&card->dpram.virt[0x07f0];
1003         card->dpram.irq = (struct softing_irq *)&card->dpram.virt[0x07fe];
1004
1005         /*reset card */
1006         if (card->fn.reset)
1007                 card->fn.reset(card, 1);
1008         if (boot_card(card)) {
1009                 mod_alert("%s, failed to boot", card->id.name);
1010                 goto boot_failed;
1011         }
1012
1013         /*only now, the chip's are known */
1014         card->id.freq = card->desc->freq * 1000000UL;
1015
1016         if (mk_card_sysfs(card)) {
1017                 mod_alert("%s, sysfs failed", card->id.name);
1018                 goto sysfs_failed;
1019         }
1020
1021         if (card->nbus > (sizeof(card->bus) / sizeof(card->bus[0]))) {
1022                 card->nbus = sizeof(card->bus) / sizeof(card->bus[0]);
1023                 mod_alert("%s, going for %u busses", card->id.name, card->nbus);
1024         }
1025
1026         for (j = 0; j < card->nbus; ++j) {
1027                 card->bus[j] = mk_netdev(card, card->id.chip[j]);
1028                 if (!card->bus[j]) {
1029                         mod_alert("%s: failed to make can[%i]", card->id.name,
1030                                   j);
1031                         goto netdev_failed;
1032                 }
1033                 card->bus[j]->index = j;
1034         }
1035         for (j = 0; j < card->nbus; ++j) {
1036                 if (reg_netdev(card->bus[j])) {
1037                         mod_alert("%s: failed to register can[%i]",
1038                                   card->id.name, j);
1039                         goto reg_failed;
1040                 }
1041         }
1042         mod_trace("card initialised");
1043         return 0;
1044
1045 reg_failed:
1046         for (j = 0; j < card->nbus; ++j)
1047                 unreg_netdev(card->bus[j]);
1048 netdev_failed:
1049         for (j = 0; j < card->nbus; ++j) {
1050                 if (card->bus[j])
1051                         rm_netdev(card->bus[j]);
1052         }
1053         rm_card_sysfs(card);
1054 sysfs_failed:
1055         shutdown_card(card);
1056 boot_failed:
1057         iounmap(card->dpram.virt);
1058         card->dpram.virt = 0;
1059         card->dpram.end = 0;
1060 ioremap_failed:
1061 lookup_failed:
1062         tasklet_kill(&card->irq.bh);
1063         return EINVAL;
1064 }
1065 EXPORT_SYMBOL(mk_softing);
1066
1067 static int __init mod_start(void)
1068 {
1069         mod_trace("");
1070         return 0;
1071 }
1072
1073 static void __exit mod_stop(void)
1074 {
1075         mod_trace("");
1076 }
1077
1078 module_init(mod_start);
1079 module_exit(mod_stop);
1080
1081 MODULE_DESCRIPTION("socketcan softing driver");
1082 MODULE_AUTHOR("Kurt Van Dijck <kurt.van.dijck@eia.be>");
1083 MODULE_LICENSE("GPL");
1084
1085 int softing_debug = 1;
1086 EXPORT_SYMBOL(softing_debug);
1087 module_param(softing_debug, int , S_IRUGO | S_IWUSR | S_IWGRP);
1088 MODULE_PARM_DESC(softing_debug, "trace softing functions");