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 /* this is the worst thing on the softing API
  33  * 2 busses are driven together, I don't know how
  34  * to recover a single of them.
  35  * Therefore, when one bus is modified, the other
  36  * is flushed too
  37  */
  38 void softing_flush_echo_skb(struct softing_priv *priv)
  39 {
  40         can_close_cleanup(priv->netdev);
  41         priv->tx.pending = 0;
  42         priv->tx.echo_put = 0;
  43         priv->tx.echo_get = 0;
  44 }
  45
  46 /*softing_unlocked_tx_run:*/
  47 /*trigger the tx queue-ing*/
  48 /*no locks are grabbed, so be sure to have the spin spinlock*/
  49 static int netdev_start_xmit(struct sk_buff *skb, struct net_device *dev)
  50 {
  51         struct softing_priv *priv = (struct softing_priv *)netdev_priv(dev);
  52         struct softing *card = priv->card;
  53         int ret;
  54         int bhlock;
  55         u8 *ptr;
  56         u8 cmd;
  57         unsigned int fifo_wr;
  58         struct can_frame msg;
  59
  60         ret = -ENOTTY;
  61         if (in_interrupt()) {
  62                 bhlock = 0;
  63                 spin_lock(&card->spin);
  64         } else {
  65                 bhlock = 1;
  66                 spin_lock_bh(&card->spin);
  67         }
  68         if (!card->fw.up) {
  69                 ret = -EIO;
  70                 goto xmit_done;
  71         }
  72         if (netif_carrier_ok(priv->netdev) <= 0) {
  73                 ret = -EBADF;
  74                 goto xmit_done;
  75         }
  76         if (card->tx.pending >= TXMAX) {
  77                 ret = -EBUSY;
  78                 goto xmit_done;
  79         }
  80         if (priv->tx.pending >= CAN_ECHO_SKB_MAX) {
  81                 ret = -EBUSY;
  82                 goto xmit_done;
  83         }
  84         fifo_wr = card->dpram.tx->wr;
  85         if (fifo_wr == card->dpram.tx->rd) {
  86                 /*fifo full */
  87                 ret = -EAGAIN;
  88                 goto xmit_done;
  89         }
  90         memcpy(&msg, skb->data, sizeof(msg));
  91         ptr = &card->dpram.tx->fifo[fifo_wr][0];
  92         cmd = CMD_TX;
  93         if (msg.can_id & CAN_RTR_FLAG)
  94                 cmd |= CMD_RTR;
  95         if (msg.can_id & CAN_EFF_FLAG)
  96                 cmd |= CMD_XTD;
  97         if (priv->index)
  98                 cmd |= CMD_BUS2;
  99         *ptr++ = cmd;
 100         *ptr++ = msg.can_dlc;
 101         *ptr++ = (msg.can_id >> 0);
 102         *ptr++ = (msg.can_id >> 8);
 103         if (msg.can_id & CAN_EFF_FLAG) {
 104                 *ptr++ = (msg.can_id >> 16);
 105                 *ptr++ = (msg.can_id >> 24);
 106         } else {
 107                 /*increment 1, not 2 as you might think */
 108                 ptr += 1;
 109         }
 110         if (!(msg.can_id & CAN_RTR_FLAG))
 111                 memcpy_toio(ptr, &msg.data[0], msg.can_dlc);
 112         if (++fifo_wr >=
 113                  sizeof(card->dpram.tx->fifo) /
 114                  sizeof(card->dpram.tx->fifo[0]))
 115                 fifo_wr = 0;
 116         card->dpram.tx->wr = fifo_wr;
 117         ret = 0;
 118         ++card->tx.pending;
 119         ++priv->tx.pending;
 120         can_put_echo_skb(skb, dev, priv->tx.echo_put);
 121         ++priv->tx.echo_put;
 122         if (priv->tx.echo_put >= CAN_ECHO_SKB_MAX)
 123                 priv->tx.echo_put = 0;
 124         /* clear pointer, so don't erase later */
 125         skb = 0;
 126 xmit_done:
 127         if (bhlock)
 128                 spin_unlock_bh(&card->spin);
 129         else
 130                 spin_unlock(&card->spin);
 131         if (card->tx.pending >= TXMAX) {
 132                 struct softing_priv *bus;
 133                 int j;
 134                 for (j = 0; j < card->nbus; ++j) {
 135                         bus = card->bus[j];
 136                         if (!bus)
 137                                 continue;
 138                         netif_stop_queue(bus->netdev);
 139                 }
 140         }
 141
 142         /* free skb, if not handled by the driver */
 143         if (skb)
 144                 dev_kfree_skb(skb);
 145         return ret;
 146 }
 147
 148 static int softing_dev_svc_once(struct softing *card)
 149 {
 150         int j;
 151         struct softing_priv *bus;
 152         struct sk_buff *skb;
 153         struct can_frame msg;
 154
 155         unsigned int fifo_rd;
 156         unsigned int cnt = 0;
 157         struct net_device_stats *stats;
 158
 159         memset(&msg, 0, sizeof(msg));
 160         if (card->dpram.rx->lost_msg) {
 161                 /*reset condition */
 162                 card->dpram.rx->lost_msg = 0;
 163                 /* prepare msg */
 164                 msg.can_id = CAN_ERR_FLAG | CAN_ERR_CRTL;
 165                 msg.can_dlc = CAN_ERR_DLC;
 166                 msg.data[1] = CAN_ERR_CRTL_RX_OVERFLOW;
 167                 /*service to both busses, we don't know which one generated */
 168                 for (j = 0; j < card->nbus; ++j) {
 169                         bus = card->bus[j];
 170                         if (!bus)
 171                                 continue;
 172                         if (!netif_carrier_ok(bus->netdev))
 173                                 continue;
 174                         ++bus->can.can_stats.data_overrun;
 175                         skb = dev_alloc_skb(sizeof(msg));
 176                         if (!skb)
 177                                 return -ENOMEM;
 178                         skb->dev = bus->netdev;
 179                         skb->protocol = htons(ETH_P_CAN);
 180                         skb->ip_summed = CHECKSUM_UNNECESSARY;
 181                         memcpy(skb_put(skb, sizeof(msg)), &msg, sizeof(msg));
 182                         if (netif_rx(skb))
 183                                 dev_kfree_skb_irq(skb);
 184                 }
 185                 memset(&msg, 0, sizeof(msg));
 186                 ++cnt;
 187         }
 188
 189         fifo_rd = card->dpram.rx->rd;
 190         if (++fifo_rd >=
 191                  sizeof(card->dpram.rx->fifo) / sizeof(card->dpram.rx->fifo[0]))
 192                 fifo_rd = 0;
 193         if (card->dpram.rx->wr != fifo_rd) {
 194                 u8 *ptr;
 195                 u32 tmp;
 196                 u8 cmd;
 197                 int do_skb;
 198
 199                 ptr = &card->dpram.rx->fifo[fifo_rd][0];
 200
 201                 cmd = *ptr++;
 202                 if (cmd == 0xff) {
 203                         /*not quite usefull, probably the card has got out */
 204                         mod_alert("got cmd 0x%02x, I suspect the card is lost"
 205                                 , cmd);
 206                 }
 207                 /*mod_trace("0x%02x", cmd);*/
 208                 bus = card->bus[0];
 209                 if (cmd & CMD_BUS2)
 210                         bus = card->bus[1];
 211
 212 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
 213                 stats = can_get_stats(bus->netdev);
 214 #else
 215                 stats = &bus->netdev->stats;
 216 #endif
 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         int ret;
 430
 431         mod_trace("%s", ndev->name);
 432         /* determine and set bittime */
 433         ret = can_set_bittiming(ndev);
 434         if (ret)
 435                 return ret;
 436         if (mutex_lock_interruptible(&card->fw.lock))
 437                 return -ERESTARTSYS;
 438         fw = card->fw.up;
 439         if (fw)
 440                 softing_reinit(card
 441                         , (card->bus[0] == priv) ? 1 : -1
 442                         , (card->bus[1] == priv) ? 1 : -1);
 443         mutex_unlock(&card->fw.lock);
 444         if (!fw)
 445                 return -EIO;
 446         netif_start_queue(ndev);
 447         return 0;
 448 }
 449
 450 static int netdev_stop(struct net_device *ndev)
 451 {
 452         struct softing_priv *priv = netdev_priv(ndev);
 453         struct softing *card = priv->card;
 454         int fw;
 455
 456         mod_trace("%s", ndev->name);
 457         netif_stop_queue(ndev);
 458         netif_carrier_off(ndev);
 459         softing_flush_echo_skb(priv);
 460         can_close_cleanup(ndev);
 461         if (mutex_lock_interruptible(&card->fw.lock))
 462                 return -ERESTARTSYS;
 463         fw = card->fw.up;
 464         if (fw)
 465                 softing_reinit(card
 466                         , (card->bus[0] == priv) ? 0 : -1
 467                         , (card->bus[1] == priv) ? 0 : -1);
 468         mutex_unlock(&card->fw.lock);
 469         if (!fw)
 470                 return -EIO;
 471         return 0;
 472 }
 473
 474 static int candev_get_state(struct net_device *ndev, enum can_state *state)
 475 {
 476         struct softing_priv *priv = netdev_priv(ndev);
 477         mod_trace("%s", ndev->name);
 478         if (priv->netdev->flags & IFF_UP)
 479                 *state = CAN_STATE_STOPPED;
 480         else if (priv->can.state == CAN_STATE_STOPPED)
 481                 *state = CAN_STATE_STOPPED;
 482         else
 483                 *state = CAN_STATE_ACTIVE;
 484         return 0;
 485 }
 486
 487 static int candev_set_mode(struct net_device *ndev, enum can_mode mode)
 488 {
 489         struct softing_priv *priv = netdev_priv(ndev);
 490         struct softing *card = priv->card;
 491         mod_trace("%s %u", ndev->name, mode);
 492         switch (mode) {
 493         case CAN_MODE_START:
 494                 /*recovery from busoff? */
 495                 if (mutex_lock_interruptible(&card->fw.lock))
 496                         return -ERESTARTSYS;
 497                 softing_reinit(card, -1, -1);
 498                 mutex_unlock(&card->fw.lock);
 499                 break;
 500         case CAN_MODE_STOP:
 501         case CAN_MODE_SLEEP:
 502                 return -EOPNOTSUPP;
 503         }
 504         return 0;
 505 }
 506
 507 /*assume the card->lock is held*/
 508
 509 int softing_card_irq(struct softing *card, int enable)
 510 {
 511         int ret;
 512         if (!enable) {
 513                 if (card->irq.requested && card->irq.nr) {
 514                         free_irq(card->irq.nr, card);
 515                         card->irq.requested = 0;
 516                 }
 517                 return 0;
 518         }
 519         if (!card->irq.requested && (card->irq.nr)) {
 520                 irqreturn_t(*fn) (int, void *);
 521                 unsigned int flags;
 522                 flags = IRQF_DISABLED | IRQF_SHARED;/*| IRQF_TRIGGER_LOW; */
 523                 fn = dev_interrupt_nshared;
 524                 if (card->desc->generation >= 2)
 525                         fn = dev_interrupt_shared;
 526                 ret = request_irq(card->irq.nr, fn, flags, card->id.name, card);
 527                 if (ret) {
 528                         mod_alert("%s, request_irq(%u) failed"
 529                                 , card->id.name, card->irq.nr
 530                                 );
 531                         return ret;
 532                 }
 533                 card->irq.requested = 1;
 534         }
 535         return 0;
 536 }
 537
 538 static void shutdown_card(struct softing *card)
 539 {
 540         int fw_up = 0;
 541         mod_trace("%s", card->id.name);
 542         if (mutex_lock_interruptible(&card->fw.lock))
 543                 /* return -ERESTARTSYS*/;
 544         fw_up = card->fw.up;
 545         card->fw.up = 0;
 546
 547         if (card->irq.requested && card->irq.nr) {
 548                 free_irq(card->irq.nr, card);
 549                 card->irq.requested = 0;
 550         }
 551         if (fw_up) {
 552                 if (card->fn.enable_irq)
 553                         card->fn.enable_irq(card, 0);
 554                 if (card->fn.reset)
 555                         card->fn.reset(card, 1);
 556         }
 557         mutex_unlock(&card->fw.lock);
 558         tasklet_kill(&card->irq.bh);
 559 }
 560
 561 static int boot_card(struct softing *card)
 562 {
 563         mod_trace("%s", card->id.name);
 564         if (mutex_lock_interruptible(&card->fw.lock))
 565                 return -ERESTARTSYS;
 566         if (card->fw.up) {
 567                 mutex_unlock(&card->fw.lock);
 568                 return 0;
 569         }
 570         /*reset board */
 571
 572         if (card->fn.enable_irq)
 573                 card->fn.enable_irq(card, 1);
 574         /*boot card */
 575         if (card->fn.reset)
 576                 card->fn.reset(card, 1);
 577         /*test dp ram */
 578         if (card->dpram.virt) {
 579                 unsigned char *lp;
 580                 static const unsigned char stream[]
 581                 = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, };
 582                 unsigned char back[sizeof(stream)];
 583                 for (lp = card->dpram.virt;
 584                           &lp[sizeof(stream)] <= card->dpram.end;
 585                           lp += sizeof(stream)) {
 586                         memcpy_toio(lp, stream, sizeof(stream));
 587                         /* flush IO cache */
 588                         mb();
 589                         memcpy_fromio(back, lp, sizeof(stream));
 590
 591                         if (memcmp(back, stream, sizeof(stream))) {
 592                                 char line[3 * sizeof(stream)
 593                                         / sizeof(stream[0]) + 1];
 594                                 char *pline = line;
 595                                 unsigned char *addr = lp;
 596                                 for (lp = back; lp < &back[sizeof(stream)
 597                                                 / sizeof(stream[0])]; ++lp)
 598                                         pline += sprintf(pline, " %02x", *lp);
 599
 600                                 mod_alert("write to dpram failed at 0x%p, %s"
 601                                         , addr, line);
 602                                 goto open_failed;
 603                         }
 604                 }
 605                 /*fill dpram with 0x55 */
 606                 /*for (lp = card->dpram.virt; lp <= card->dpram.end; ++lp) {
 607                  *lp = 0x55;
 608                  }*/
 609                 wmb();
 610         } else {
 611                 goto open_failed;
 612         }
 613         /*load boot firmware */
 614         if (softing_load_fw(card->desc->boot.fw, card, card->dpram.virt,
 615                                  card->dpram.size,
 616                                  card->desc->boot.offs -
 617                                  card->desc->boot.addr))
 618                 goto open_failed;
 619         /*load load firmware */
 620         if (softing_load_fw(card->desc->load.fw, card, card->dpram.virt,
 621                                  card->dpram.size,
 622                                  card->desc->load.offs -
 623                                  card->desc->load.addr))
 624                 goto open_failed;
 625
 626         if (card->fn.reset)
 627                 card->fn.reset(card, 0);
 628         if (softing_bootloader_command(card, 0, "card boot"))
 629                 goto open_failed;
 630         if (softing_load_app_fw(card->desc->app.fw, card))
 631                 goto open_failed;
 632         /*reset chip */
 633         card->dpram.info->reset_rcv_fifo = 0;
 634         card->dpram.info->reset = 1;
 635         /*sync */
 636         if (softing_fct_cmd(card, 99, 0x55, "sync-a"))
 637                 goto open_failed;
 638         if (softing_fct_cmd(card, 99, 0xaa, "sync-a"))
 639                 goto open_failed;
 640         /*reset chip */
 641         if (softing_fct_cmd(card, 0, 0, "reset_chip"))
 642                 goto open_failed;
 643         /*get_serial */
 644         if (softing_fct_cmd(card, 43, 0, "get_serial_number"))
 645                 goto open_failed;
 646         card->id.serial =
 647                  (u16) card->dpram.fct->param[1] +
 648                  (((u16) card->dpram.fct->param[2]) << 16);
 649         /*get_version */
 650         if (softing_fct_cmd(card, 12, 0, "get_version"))
 651                 goto open_failed;
 652         card->id.fw = (u16) card->dpram.fct->param[1];
 653         card->id.hw = (u16) card->dpram.fct->param[2];
 654         card->id.lic = (u16) card->dpram.fct->param[3];
 655         card->id.chip[0] = (u16) card->dpram.fct->param[4];
 656         card->id.chip[1] = (u16) card->dpram.fct->param[5];
 657
 658         mod_info("%s, card booted, "
 659                         "serial %u, fw %u, hw %u, lic %u, chip (%u,%u)",
 660                   card->id.name, card->id.serial, card->id.fw, card->id.hw,
 661                   card->id.lic, card->id.chip[0], card->id.chip[1]);
 662
 663         card->fw.up = 1;
 664         mutex_unlock(&card->fw.lock);
 665         return 0;
 666 open_failed:
 667         card->fw.up = 0;
 668         if (card->fn.enable_irq)
 669                 card->fn.enable_irq(card, 0);
 670         if (card->fn.reset)
 671                 card->fn.reset(card, 1);
 672         mutex_unlock(&card->fw.lock);
 673         return EINVAL;
 674 }
 675
 676 /*sysfs stuff*/
 677
 678 /* Because the struct softing may be used by pcmcia devices
 679  * as well as pci devices, * we have no clue how to get
 680  * from a struct device * towards the struct softing *.
 681  * It may go over a pci_device->priv or over a pcmcia_device->priv.
 682  * Therefore, provide the struct softing pointer within the attribute.
 683  * Then we don't need driver/bus specific things in these attributes
 684  */
 685 struct softing_attribute {
 686         struct device_attribute dev;
 687         ssize_t (*show) (struct softing *card, char *buf);
 688         ssize_t (*store)(struct softing *card, const char *buf, size_t count);
 689         struct softing *card;
 690 };
 691
 692 static ssize_t rd_card_attr(struct device *dev, struct device_attribute *attr
 693                 , char *buf) {
 694         struct softing_attribute *cattr
 695                 = container_of(attr, struct softing_attribute, dev);
 696         return cattr->show ? cattr->show(cattr->card, buf) : 0;
 697 }
 698 static ssize_t wr_card_attr(struct device *dev, struct device_attribute *attr
 699                 , const char *buf, size_t count) {
 700         struct softing_attribute *cattr
 701                 = container_of(attr, struct softing_attribute, dev);
 702         return cattr->store ? cattr->store(cattr->card, buf, count) : 0;
 703 }
 704
 705 #define declare_attr(_name, _mode, _show, _store) { \
 706         .dev = { \
 707                 .attr = { \
 708                         .name = __stringify(_name), \
 709                         .mode = _mode, \
 710                 }, \
 711                 .show = rd_card_attr, \
 712                 .store = wr_card_attr, \
 713         }, \
 714         .show = _show, \
 715         .store = _store, \
 716 }
 717
 718 #define CARD_SHOW(name, member) \
 719 static ssize_t show_##name(struct softing *card, char *buf) { \
 720         return sprintf(buf, "%u\n", card->member); \
 721 }
 722 CARD_SHOW(serial        , id.serial);
 723 CARD_SHOW(firmware      , id.fw);
 724 CARD_SHOW(hardware      , id.hw);
 725 CARD_SHOW(license       , id.lic);
 726 CARD_SHOW(freq          , id.freq);
 727 CARD_SHOW(txpending     , tx.pending);
 728
 729 static const struct softing_attribute card_attr_proto [] = {
 730         declare_attr(serial     , 0444, show_serial     , 0),
 731         declare_attr(firmware   , 0444, show_firmware   , 0),
 732         declare_attr(hardware   , 0444, show_hardware   , 0),
 733         declare_attr(license    , 0444, show_license    , 0),
 734         declare_attr(freq       , 0444, show_freq       , 0),
 735         declare_attr(txpending  , 0644, show_txpending  , 0),
 736 };
 737
 738 static int mk_card_sysfs(struct softing *card)
 739 {
 740         int size;
 741         int j;
 742
 743         size = sizeof(card_attr_proto)/sizeof(card_attr_proto[0]);
 744         card->attr = kmalloc((size+1)*sizeof(card->attr[0]), GFP_KERNEL);
 745         if (!card->attr)
 746                 goto attr_mem_failed;
 747         memcpy(card->attr, card_attr_proto, size * sizeof(card->attr[0]));
 748         memset(&card->attr[size], 0, sizeof(card->attr[0]));
 749
 750         card->grp  = kmalloc((size+1)*sizeof(card->grp [0]), GFP_KERNEL);
 751         if (!card->grp)
 752                 goto grp_mem_failed;
 753
 754         for (j = 0; j < size; ++j) {
 755                 card->attr[j].card = card;
 756                 card->grp[j] = &card->attr[j].dev.attr;
 757                 if (!card->attr[j].show)
 758                         card->attr[j].dev.attr.mode &= ~(S_IRUGO);
 759                 if (!card->attr[j].store)
 760                         card->attr[j].dev.attr.mode &= ~(S_IWUGO);
 761         }
 762         card->grp[size] = 0;
 763         card->sysfs.name        = "softing";
 764         card->sysfs.attrs = card->grp;
 765         if (sysfs_create_group(&card->dev->kobj, &card->sysfs) < 0)
 766                 goto sysfs_failed;
 767
 768         return 0;
 769
 770 sysfs_failed:
 771         kfree(card->grp);
 772 grp_mem_failed:
 773         kfree(card->attr);
 774 attr_mem_failed:
 775         return -1;
 776 }
 777 static void rm_card_sysfs(struct softing *card)
 778 {
 779         sysfs_remove_group(&card->dev->kobj, &card->sysfs);
 780         kfree(card->grp);
 781         kfree(card->attr);
 782 }
 783
 784 static ssize_t show_chip(struct device *dev
 785                 , struct device_attribute *attr, char *buf)
 786 {
 787         struct net_device *ndev = to_net_dev(dev);
 788         struct softing_priv *priv = netdev2softing(ndev);
 789         return sprintf(buf, "%i\n", priv->chip);
 790 }
 791
 792 static ssize_t show_output(struct device *dev
 793                 , struct device_attribute *attr, char *buf)
 794 {
 795         struct net_device *ndev = to_net_dev(dev);
 796         struct softing_priv *priv = netdev2softing(ndev);
 797         return sprintf(buf, "0x%02x\n", priv->output);
 798 }
 799
 800 static ssize_t store_output(struct device *dev
 801                 , struct device_attribute *attr
 802                 , const char *buf, size_t count)
 803 {
 804         struct net_device *ndev = to_net_dev(dev);
 805         struct softing_priv *priv = netdev2softing(ndev);
 806         struct softing *card = priv->card;
 807
 808         u8 v = simple_strtoul(buf, NULL, 10) & 0xFFU;
 809
 810         if (mutex_lock_interruptible(&card->fw.lock))
 811                 return -ERESTARTSYS;
 812         if (ndev->flags & IFF_UP) {
 813                 int j;
 814                 /* we will need a restart */
 815                 for (j = 0; j < card->nbus; ++j) {
 816                         if (j == priv->index)
 817                                 /* me, myself & I */
 818                                 continue;
 819                         if (card->bus[j]->netdev->flags & IFF_UP) {
 820                                 mutex_unlock(&card->fw.lock);
 821                                 return -EBUSY;
 822                         }
 823                 }
 824                 priv->output = v;
 825                 softing_reinit(card, -1, -1);
 826         } else {
 827                 priv->output = v;
 828         }
 829         mutex_unlock(&card->fw.lock);
 830         return count;
 831 }
 832 /* TODO
 833  * the latest softing cards support sleep mode too
 834  */
 835
 836 static const DEVICE_ATTR(chip, S_IRUGO, show_chip, 0);
 837 static const DEVICE_ATTR(output, S_IRUGO | S_IWUSR, show_output, store_output);
 838
 839 static const struct attribute *const netdev_sysfs_entries [] = {
 840         &dev_attr_chip          .attr,
 841         &dev_attr_output        .attr,
 842         0,
 843 };
 844 static const struct attribute_group netdev_sysfs = {
 845         .name  = 0,
 846         .attrs = (struct attribute **)netdev_sysfs_entries,
 847 };
 848
 849 static int mk_netdev_sysfs(struct softing_priv *priv)
 850 {
 851         if (!priv->netdev->dev.kobj.sd) {
 852                 mod_alert("sysfs_create_group would fail");
 853                 return ENODEV;
 854         }
 855         return sysfs_create_group(&priv->netdev->dev.kobj, &netdev_sysfs);
 856 }
 857 static void rm_netdev_sysfs(struct softing_priv *priv)
 858 {
 859         sysfs_remove_group(&priv->netdev->dev.kobj, &netdev_sysfs);
 860 }
 861
 862 static struct softing_priv *mk_netdev(struct softing *card, u16 chip_id)
 863 {
 864         struct net_device *ndev;
 865         struct softing_priv *priv;
 866
 867         ndev = alloc_candev(sizeof(*priv));
 868         if (!ndev) {
 869                 mod_alert("alloc_candev failed");
 870                 return 0;
 871         }
 872         priv = netdev_priv(ndev);
 873         priv->netdev            = ndev;
 874         priv->card              = card;
 875         memcpy(&priv->btr_const, &softing_btr_const, sizeof(priv->btr_const));
 876         priv->btr_const.brp_max = card->desc->max_brp;
 877         priv->btr_const.sjw_max = card->desc->max_sjw;
 878         priv->can.bittiming_const = &priv->btr_const;
 879         priv->can.bittiming.clock = 8000000;
 880         priv->chip              = chip_id;
 881         priv->output = softing_default_output(card, priv);
 882         SET_NETDEV_DEV(ndev, card->dev);
 883
 884         ndev->flags |= IFF_ECHO;
 885         ndev->open              = netdev_open;
 886         ndev->stop              = netdev_stop;
 887         ndev->hard_start_xmit   = netdev_start_xmit;
 888         priv->can.do_get_state  = candev_get_state;
 889         priv->can.do_set_mode   = candev_set_mode;
 890
 891         return priv;
 892 }
 893
 894 static void rm_netdev(struct softing_priv *priv)
 895 {
 896         free_candev(priv->netdev);
 897 }
 898
 899 static int reg_netdev(struct softing_priv *priv)
 900 {
 901         int ret;
 902         netif_carrier_off(priv->netdev);
 903         ret = register_netdev(priv->netdev);
 904         if (ret) {
 905                 mod_alert("%s, register failed", priv->card->id.name);
 906                 goto reg_failed;
 907         }
 908         ret = mk_netdev_sysfs(priv);
 909         if (ret) {
 910                 mod_alert("%s, sysfs failed", priv->card->id.name);
 911                 goto sysfs_failed;
 912         }
 913         return 0;
 914 sysfs_failed:
 915         unregister_netdev(priv->netdev);
 916 reg_failed:
 917         return EINVAL;
 918 }
 919
 920 static void unreg_netdev(struct softing_priv *priv)
 921 {
 922         rm_netdev_sysfs(priv);
 923         unregister_netdev(priv->netdev);
 924 }
 925
 926 void rm_softing(struct softing *card)
 927 {
 928         int j;
 929
 930         /*first, disable card*/
 931         shutdown_card(card);
 932
 933         for (j = 0; j < card->nbus; ++j) {
 934                 unreg_netdev(card->bus[j]);
 935                 rm_netdev(card->bus[j]);
 936         }
 937
 938         rm_card_sysfs(card);
 939
 940         iounmap(card->dpram.virt);
 941 }
 942 EXPORT_SYMBOL(rm_softing);
 943
 944 int mk_softing(struct softing *card)
 945 {
 946         int j;
 947
 948         /* try_module_get(THIS_MODULE); */
 949         mutex_init(&card->fw.lock);
 950         spin_lock_init(&card->spin);
 951         tasklet_init(&card->irq.bh, softing_dev_svc, (unsigned long)card);
 952
 953         card->desc = softing_lookup_desc(card->id.manf, card->id.prod);
 954         if (!card->desc) {
 955                 mod_alert("0x%04x:0x%04x not supported\n", card->id.manf,
 956                           card->id.prod);
 957                 goto lookup_failed;
 958         }
 959         card->id.name = card->desc->name;
 960         mod_trace("can (%s)", card->id.name);
 961
 962         card->dpram.virt = ioremap(card->dpram.phys, card->dpram.size);
 963         if (!card->dpram.virt) {
 964                 mod_alert("dpram ioremap failed\n");
 965                 goto ioremap_failed;
 966         }
 967
 968         card->dpram.size = card->desc->dpram_size;
 969         card->dpram.end = &card->dpram.virt[card->dpram.size];
 970         /*initialize_board */
 971         card->dpram.rx = (struct softing_rx *)&card->dpram.virt[0x0000];
 972         card->dpram.tx = (struct softing_tx *)&card->dpram.virt[0x0400];
 973         card->dpram.fct = (struct softing_fct *)&card->dpram.virt[0x0300];
 974         card->dpram.info = (struct softing_info *)&card->dpram.virt[0x0330];
 975         card->dpram.command = (unsigned short *)&card->dpram.virt[0x07e0];
 976         card->dpram.receipt = (unsigned short *)&card->dpram.virt[0x07f0];
 977         card->dpram.irq = (struct softing_irq *)&card->dpram.virt[0x07fe];
 978
 979         /*reset card */
 980         if (card->fn.reset)
 981                 card->fn.reset(card, 1);
 982         if (boot_card(card)) {
 983                 mod_alert("%s, failed to boot", card->id.name);
 984                 goto boot_failed;
 985         }
 986
 987         /*only now, the chip's are known */
 988         card->id.freq = card->desc->freq * 1000000UL;
 989
 990         if (mk_card_sysfs(card)) {
 991                 mod_alert("%s, sysfs failed", card->id.name);
 992                 goto sysfs_failed;
 993         }
 994
 995         if (card->nbus > (sizeof(card->bus) / sizeof(card->bus[0]))) {
 996                 card->nbus = sizeof(card->bus) / sizeof(card->bus[0]);
 997                 mod_alert("%s, going for %u busses", card->id.name, card->nbus);
 998         }
 999
1000         for (j = 0; j < card->nbus; ++j) {
1001                 card->bus[j] = mk_netdev(card, card->id.chip[j]);
1002                 if (!card->bus[j]) {
1003                         mod_alert("%s: failed to make can[%i]", card->id.name,
1004                                   j);
1005                         goto netdev_failed;
1006                 }
1007                 card->bus[j]->index = j;
1008         }
1009         for (j = 0; j < card->nbus; ++j) {
1010                 if (reg_netdev(card->bus[j])) {
1011                         mod_alert("%s: failed to register can[%i]",
1012                                   card->id.name, j);
1013                         goto reg_failed;
1014                 }
1015         }
1016         mod_trace("card initialised");
1017         return 0;
1018
1019 reg_failed:
1020         for (j = 0; j < card->nbus; ++j)
1021                 unreg_netdev(card->bus[j]);
1022 netdev_failed:
1023         for (j = 0; j < card->nbus; ++j) {
1024                 if (card->bus[j])
1025                         rm_netdev(card->bus[j]);
1026         }
1027         rm_card_sysfs(card);
1028 sysfs_failed:
1029         shutdown_card(card);
1030 boot_failed:
1031         iounmap(card->dpram.virt);
1032         card->dpram.virt = 0;
1033         card->dpram.end = 0;
1034 ioremap_failed:
1035 lookup_failed:
1036         tasklet_kill(&card->irq.bh);
1037         return EINVAL;
1038 }
1039 EXPORT_SYMBOL(mk_softing);
1040
1041 static int __init mod_start(void)
1042 {
1043         mod_trace("");
1044         return 0;
1045 }
1046
1047 static void __exit mod_stop(void)
1048 {
1049         mod_trace("");
1050 }
1051
1052 module_init(mod_start);
1053 module_exit(mod_stop);
1054
1055 MODULE_DESCRIPTION("socketcan softing driver");
1056 MODULE_AUTHOR("Kurt Van Dijck <kurt.van.dijck@eia.be>");
1057 MODULE_LICENSE("GPL");
1058
1059 int softing_debug = 1;
1060 EXPORT_SYMBOL(softing_debug);
1061 module_param(softing_debug, int , S_IRUGO | S_IWUSR | S_IWGRP);
1062 MODULE_PARM_DESC(softing_debug, "trace softing functions");