kernel/2.6/drivers/net/can/mscan/mscan.c

   1 /*
   2  * mscan.c
   3  *
   4  * DESCRIPTION:
   5  *  CAN bus driver for the alone generic (as possible as) MSCAN controller.
   6  *
   7  * AUTHOR:
   8  *  Andrey Volkov <avolkov@varma-el.com>
   9  *
  10  * COPYRIGHT:
  11  *  2005-2006, Varma Electronics Oy
  12  *
  13  * LICENCE:
  14  *  This program is free software; you can redistribute it and/or modify
  15  *  it under the terms of the GNU General Public License as published by
  16  *  the Free Software Foundation; either version 2 of the License, or
  17  *  (at your option) any later version.
  18  *
  19  *  This program is distributed in the hope that it will be useful,
  20  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  *  GNU General Public License for more details.
  23  *
  24  *  You should have received a copy of the GNU General Public License
  25  *  along with this program; if not, write to the Free Software
  26  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  27  *
  28  */
  29
  30 #include <linux/kernel.h>
  31 #include <linux/module.h>
  32 #include <linux/interrupt.h>
  33 #include <linux/delay.h>
  34 #include <linux/netdevice.h>
  35 #include <linux/if_arp.h>
  36 #include <linux/if_ether.h>
  37 #include <linux/list.h>
  38 #include <linux/can.h>
  39 #include <linux/can/dev.h>
  40 #include <linux/can/error.h>
  41 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
  42 #include <linux/io.h>
  43 #else
  44 #include <asm/io.h>
  45 #endif
  46
  47 #include "mscan.h"
  48
  49 #include <linux/can/version.h>  /* for RCSID. Removed by mkpatch script */
  50 RCSID("$Id$");
  51
  52 #define MSCAN_NORMAL_MODE       0
  53 #define MSCAN_SLEEP_MODE        MSCAN_SLPRQ
  54 #define MSCAN_INIT_MODE         (MSCAN_INITRQ | MSCAN_SLPRQ)
  55 #define MSCAN_POWEROFF_MODE     (MSCAN_CSWAI | MSCAN_SLPRQ)
  56 #define MSCAN_SET_MODE_RETRIES  255
  57
  58
  59 #define BTR0_BRP_MASK           0x3f
  60 #define BTR0_SJW_SHIFT          6
  61 #define BTR0_SJW_MASK           (0x3 << BTR0_SJW_SHIFT)
  62
  63 #define BTR1_TSEG1_MASK         0xf
  64 #define BTR1_TSEG2_SHIFT        4
  65 #define BTR1_TSEG2_MASK         (0x7 << BTR1_TSEG2_SHIFT)
  66 #define BTR1_SAM_SHIFT          7
  67
  68 #define BTR0_SET_BRP(brp)       (((brp) - 1) & BTR0_BRP_MASK)
  69 #define BTR0_SET_SJW(sjw)       ((((sjw) - 1) << BTR0_SJW_SHIFT) & \
  70                                  BTR0_SJW_MASK)
  71
  72 #define BTR1_SET_TSEG1(tseg1)   (((tseg1) - 1) &  BTR1_TSEG1_MASK)
  73 #define BTR1_SET_TSEG2(tseg2)   ((((tseg2) - 1) << BTR1_TSEG2_SHIFT) & \
  74                                  BTR1_TSEG2_MASK)
  75 #define BTR1_SET_SAM(sam)       (((sam) & 1) << BTR1_SAM_SHIFT)
  76
  77 static struct can_bittiming_const mscan_bittiming_const = {
  78         .tseg1_min = 4,
  79         .tseg1_max = 16,
  80         .tseg2_min = 2,
  81         .tseg2_max = 8,
  82         .sjw_max = 4,
  83         .brp_min = 1,
  84         .brp_max = 64,
  85         .brp_inc = 1,
  86 };
  87
  88 struct mscan_state {
  89         u8 mode;
  90         u8 canrier;
  91         u8 cantier;
  92 };
  93
  94 #define TX_QUEUE_SIZE   3
  95
  96 struct tx_queue_entry {
  97         struct list_head list;
  98         u8 mask;
  99         u8 id;
 100 };
 101
 102 struct mscan_priv {
 103         struct can_priv can;
 104         long open_time;
 105         volatile unsigned long flags;
 106         u8 shadow_statflg;
 107         u8 shadow_canrier;
 108         u8 cur_pri;
 109         u8 tx_active;
 110
 111         struct list_head tx_head;
 112         struct tx_queue_entry tx_queue[TX_QUEUE_SIZE];
 113 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,23)
 114         struct napi_struct napi;
 115         struct net_device *dev;
 116 #endif
 117 };
 118
 119 #define F_RX_PROGRESS   0
 120 #define F_TX_PROGRESS   1
 121 #define F_TX_WAIT_ALL   2
 122
 123 static enum can_state state_map[] = {
 124         CAN_STATE_ACTIVE,
 125         CAN_STATE_BUS_WARNING,
 126         CAN_STATE_BUS_PASSIVE,
 127         CAN_STATE_BUS_OFF
 128 };
 129
 130 static int mscan_set_mode(struct net_device *dev, u8 mode)
 131 {
 132         struct mscan_regs *regs = (struct mscan_regs *)dev->base_addr;
 133         struct mscan_priv *priv = netdev_priv(dev);
 134         int ret = 0;
 135         int i;
 136         u8 canctl1;
 137
 138         if (mode != MSCAN_NORMAL_MODE) {
 139
 140                 if (priv->tx_active) {
 141                         /* Abort transfers before going to sleep */
 142                         out_8(&regs->cantier, 0);
 143                         out_8(&regs->cantarq, priv->tx_active);
 144                         out_8(&regs->cantier, priv->tx_active);
 145                 }
 146
 147                 canctl1 = in_8(&regs->canctl1);
 148                 if ((mode & MSCAN_SLPRQ) && (canctl1 & MSCAN_SLPAK) == 0) {
 149                         out_8(&regs->canctl0,
 150                               in_8(&regs->canctl0) | MSCAN_SLPRQ);
 151                         for (i = 0; i < MSCAN_SET_MODE_RETRIES; i++) {
 152                                 if (in_8(&regs->canctl1) & MSCAN_SLPAK)
 153                                         break;
 154                                 udelay(100);
 155                         }
 156                         if (i >= MSCAN_SET_MODE_RETRIES)
 157                                 ret = -ENODEV;
 158                 }
 159                 if (!ret)
 160                         priv->can.state = CAN_STATE_SLEEPING;
 161
 162                 if (!ret && (mode & MSCAN_INITRQ)
 163                     && (canctl1 & MSCAN_INITAK) == 0) {
 164                         out_8(&regs->canctl0,
 165                               in_8(&regs->canctl0) | MSCAN_INITRQ);
 166                         for (i = 0; i < MSCAN_SET_MODE_RETRIES; i++) {
 167                                 if (in_8(&regs->canctl1) & MSCAN_INITAK)
 168                                         break;
 169                         }
 170                         if (i >= MSCAN_SET_MODE_RETRIES)
 171                                 ret = -ENODEV;
 172                 }
 173                 if (!ret)
 174                         priv->can.state = CAN_STATE_STOPPED;
 175
 176                 if (!ret && (mode & MSCAN_CSWAI))
 177                         out_8(&regs->canctl0,
 178                               in_8(&regs->canctl0) | MSCAN_CSWAI);
 179
 180         } else {
 181                 canctl1 = in_8(&regs->canctl1);
 182                 if (canctl1 & (MSCAN_SLPAK | MSCAN_INITAK)) {
 183                         out_8(&regs->canctl0, in_8(&regs->canctl0) &
 184                               ~(MSCAN_SLPRQ | MSCAN_INITRQ));
 185                         for (i = 0; i < MSCAN_SET_MODE_RETRIES; i++) {
 186                                 canctl1 = in_8(&regs->canctl1);
 187                                 if (!(canctl1 & (MSCAN_INITAK | MSCAN_SLPAK)))
 188                                         break;
 189                         }
 190                         if (i >= MSCAN_SET_MODE_RETRIES)
 191                                 ret = -ENODEV;
 192                         else
 193                                 priv->can.state = CAN_STATE_ACTIVE;
 194                 }
 195         }
 196         return ret;
 197 }
 198
 199 static int mscan_start(struct net_device *dev)
 200 {
 201         struct mscan_priv *priv = netdev_priv(dev);
 202         struct mscan_regs *regs = (struct mscan_regs *)dev->base_addr;
 203         u8 canrflg;
 204         int err;
 205
 206         out_8(&regs->canrier, 0);
 207
 208         INIT_LIST_HEAD(&priv->tx_head);
 209         priv->cur_pri = 0;
 210         priv->tx_active = 0;
 211         priv->shadow_canrier = 0;
 212         priv->flags = 0;
 213
 214         err = mscan_set_mode(dev, MSCAN_NORMAL_MODE);
 215         if (err)
 216                 return err;
 217
 218         canrflg = in_8(&regs->canrflg);
 219         priv->shadow_statflg = canrflg & MSCAN_STAT_MSK;
 220         priv->can.state = state_map[max(MSCAN_STATE_RX(canrflg),
 221                                     MSCAN_STATE_TX(canrflg))];
 222         out_8(&regs->cantier, 0);
 223
 224         /* Enable receive interrupts. */
 225         out_8(&regs->canrier, MSCAN_OVRIE | MSCAN_RXFIE | MSCAN_CSCIE |
 226               MSCAN_RSTATE1 | MSCAN_RSTATE0 | MSCAN_TSTATE1 | MSCAN_TSTATE0);
 227
 228         return 0;
 229 }
 230
 231 static int mscan_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
 232 {
 233         struct can_frame *frame = (struct can_frame *)skb->data;
 234         struct mscan_regs *regs = (struct mscan_regs *)dev->base_addr;
 235         struct mscan_priv *priv = netdev_priv(dev);
 236         int i, rtr, buf_id;
 237         u32 can_id;
 238
 239         if (frame->can_dlc > 8)
 240                 return -EINVAL;
 241
 242         dev_dbg(ND2D(dev), "%s\n", __func__);
 243         out_8(&regs->cantier, 0);
 244
 245         i = ~priv->tx_active & MSCAN_TXE;
 246         buf_id = ffs(i) - 1;
 247         switch (hweight8(i)) {
 248         case 0:
 249                 netif_stop_queue(dev);
 250                 dev_err(ND2D(dev), "BUG! Tx Ring full when queue awake!\n");
 251                 return NETDEV_TX_BUSY;
 252         case 1:
 253                 /* if buf_id < 3, then current frame will be send out of order,
 254                    since  buffer with lower id have higher priority (hell..) */
 255                 if (buf_id < 3)
 256                         priv->cur_pri++;
 257                 if (priv->cur_pri == 0xff)
 258                         set_bit(F_TX_WAIT_ALL, &priv->flags);
 259                 netif_stop_queue(dev);
 260         case 2:
 261                 set_bit(F_TX_PROGRESS, &priv->flags);
 262         }
 263         out_8(&regs->cantbsel, i);
 264
 265         rtr = frame->can_id & CAN_RTR_FLAG;
 266
 267         if (frame->can_id & CAN_EFF_FLAG) {
 268                 dev_dbg(ND2D(dev), "sending extended frame\n");
 269
 270                 can_id = (frame->can_id & CAN_EFF_MASK) << 1;
 271                 if (rtr)
 272                         can_id |= 1;
 273                 out_be16(&regs->tx.idr3_2, can_id);
 274
 275                 can_id >>= 16;
 276                 can_id = (can_id & 0x7) | ((can_id << 2) & 0xffe0) | (3 << 3);
 277         } else {
 278                 dev_dbg(ND2D(dev), "sending standard frame\n");
 279                 can_id = (frame->can_id & CAN_SFF_MASK) << 5;
 280                 if (rtr)
 281                         can_id |= 1 << 4;
 282         }
 283         out_be16(&regs->tx.idr1_0, can_id);
 284
 285         if (!rtr) {
 286                 volatile void __iomem *data = &regs->tx.dsr1_0;
 287                 u16 *payload = (u16 *) frame->data;
 288                 /*Its safe to write into dsr[dlc+1] */
 289                 for (i = 0; i < (frame->can_dlc + 1) / 2; i++) {
 290                         out_be16(data, *payload++);
 291                         data += 2 + _MSCAN_RESERVED_DSR_SIZE;
 292                 }
 293         }
 294
 295         out_8(&regs->tx.dlr, frame->can_dlc);
 296         out_8(&regs->tx.tbpr, priv->cur_pri);
 297
 298         /* Start transmission. */
 299         out_8(&regs->cantflg, 1 << buf_id);
 300
 301         if (!test_bit(F_TX_PROGRESS, &priv->flags))
 302                 dev->trans_start = jiffies;
 303
 304         list_add_tail(&priv->tx_queue[buf_id].list, &priv->tx_head);
 305
 306         can_put_echo_skb(skb, dev, buf_id);
 307
 308         /* Enable interrupt. */
 309         priv->tx_active |= 1 << buf_id;
 310         out_8(&regs->cantier, priv->tx_active);
 311
 312         return NETDEV_TX_OK;
 313 }
 314
 315 static inline int check_set_state(struct net_device *dev, u8 canrflg)
 316 {
 317         struct mscan_priv *priv = netdev_priv(dev);
 318         enum can_state state;
 319         int ret = 0;
 320
 321         if (!(canrflg & MSCAN_CSCIF) || priv->can.state > CAN_STATE_BUS_OFF)
 322                 return 0;
 323
 324         state = state_map[max(MSCAN_STATE_RX(canrflg),
 325                               MSCAN_STATE_TX(canrflg))];
 326         if (priv->can.state < state)
 327                 ret = 1;
 328         if (state == CAN_STATE_BUS_OFF)
 329                 can_bus_off(dev);
 330         priv->can.state = state;
 331         return ret;
 332 }
 333
 334 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,23)
 335 static int mscan_rx_poll(struct napi_struct *napi, int quota)
 336 #else
 337 static int mscan_rx_poll(struct net_device *dev, int *budget)
 338 #endif
 339 {
 340 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,23)
 341         struct mscan_priv *priv = container_of(napi, struct mscan_priv, napi);
 342         struct net_device *dev = priv->dev;
 343 #else
 344         struct mscan_priv *priv = netdev_priv(dev);
 345         int quota = min(dev->quota, *budget);
 346 #endif
 347         struct mscan_regs *regs = (struct mscan_regs *)dev->base_addr;
 348         struct net_device_stats *stats = dev->get_stats(dev);
 349         int npackets = 0;
 350         int ret = 1;
 351         struct sk_buff *skb;
 352         struct can_frame *frame;
 353         u32 can_id;
 354         u8 canrflg;
 355         int i;
 356
 357         while (npackets < quota && ((canrflg = in_8(&regs->canrflg)) &
 358                                     (MSCAN_RXF | MSCAN_ERR_IF))) {
 359
 360                 skb = dev_alloc_skb(sizeof(struct can_frame));
 361                 if (!skb) {
 362                         if (printk_ratelimit())
 363                                 dev_notice(ND2D(dev), "packet dropped\n");
 364                         stats->rx_dropped++;
 365                         out_8(&regs->canrflg, canrflg);
 366                         continue;
 367                 }
 368
 369                 frame = (struct can_frame *)skb_put(skb, sizeof(*frame));
 370                 memset(frame, 0, sizeof(*frame));
 371
 372                 if (canrflg & MSCAN_RXF) {
 373                         can_id = in_be16(&regs->rx.idr1_0);
 374                         if (can_id & (1 << 3)) {
 375                                 frame->can_id = CAN_EFF_FLAG;
 376                                 can_id = ((can_id << 16) |
 377                                           in_be16(&regs->rx.idr3_2));
 378                                 can_id = ((can_id & 0xffe00000) |
 379                                           ((can_id & 0x7ffff) << 2)) >> 2;
 380                         } else {
 381                                 can_id >>= 4;
 382                                 frame->can_id = 0;
 383                         }
 384
 385                         frame->can_id |= can_id >> 1;
 386                         if (can_id & 1)
 387                                 frame->can_id |= CAN_RTR_FLAG;
 388                         frame->can_dlc = in_8(&regs->rx.dlr) & 0xf;
 389
 390                         if (!(frame->can_id & CAN_RTR_FLAG)) {
 391                                 volatile void __iomem *data = &regs->rx.dsr1_0;
 392                                 u16 *payload = (u16 *) frame->data;
 393                                 for (i = 0; i < (frame->can_dlc + 1) / 2; i++) {
 394                                         *payload++ = in_be16(data);
 395                                         data += 2 + _MSCAN_RESERVED_DSR_SIZE;
 396                                 }
 397                         }
 398
 399                         dev_dbg(ND2D(dev),
 400                                 "received pkt: id: %u dlc: %u data: ",
 401                                 frame->can_id, frame->can_dlc);
 402 #ifdef DEBUG
 403                         for (i = 0;
 404                              i < frame->can_dlc && !(frame->can_id &
 405                                                      CAN_FLAG_RTR); i++)
 406                                 printk(KERN_DEBUG "%2x ", frame->data[i]);
 407                         printk(KERN_DEBUG "\n");
 408 #endif
 409
 410                         out_8(&regs->canrflg, MSCAN_RXF);
 411                         dev->last_rx = jiffies;
 412                         stats->rx_packets++;
 413                         stats->rx_bytes += frame->can_dlc;
 414                 } else if (canrflg & MSCAN_ERR_IF) {
 415                         frame->can_id = CAN_ERR_FLAG;
 416
 417                         if (canrflg & MSCAN_OVRIF) {
 418                                 frame->can_id |= CAN_ERR_CRTL;
 419                                 frame->data[1] = CAN_ERR_CRTL_RX_OVERFLOW;
 420                                 stats->rx_over_errors++;
 421                         } else
 422                                 frame->data[1] = 0;
 423
 424                         if (check_set_state(dev, canrflg)) {
 425                                 frame->can_id |= CAN_ERR_CRTL;
 426                                 switch (priv->can.state) {
 427                                 case CAN_STATE_BUS_WARNING:
 428                                         if ((priv->shadow_statflg &
 429                                              MSCAN_RSTAT_MSK) <
 430                                             (canrflg & MSCAN_RSTAT_MSK))
 431                                                 frame->data[1] |=
 432                                                     CAN_ERR_CRTL_RX_WARNING;
 433
 434                                         if ((priv->shadow_statflg &
 435                                              MSCAN_TSTAT_MSK) <
 436                                             (canrflg & MSCAN_TSTAT_MSK))
 437                                                 frame->data[1] |=
 438                                                         CAN_ERR_CRTL_TX_WARNING;
 439                                         break;
 440                                 case CAN_STATE_BUS_PASSIVE:
 441                                         frame->data[1] |=
 442                                             CAN_ERR_CRTL_RX_PASSIVE;
 443                                         break;
 444                                 case CAN_STATE_BUS_OFF:
 445                                         frame->can_id |= CAN_ERR_BUSOFF;
 446                                         frame->can_id &= ~CAN_ERR_CRTL;
 447                                         break;
 448                                 default:
 449                                         break;
 450                                 }
 451                         }
 452                         priv->shadow_statflg = canrflg & MSCAN_STAT_MSK;
 453                         frame->can_dlc = CAN_ERR_DLC;
 454                         out_8(&regs->canrflg, MSCAN_ERR_IF);
 455                 }
 456
 457                 npackets++;
 458                 skb->dev = dev;
 459                 skb->protocol = __constant_htons(ETH_P_CAN);
 460                 skb->ip_summed = CHECKSUM_UNNECESSARY;
 461                 netif_receive_skb(skb);
 462         }
 463
 464 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,23)
 465         *budget -= npackets;
 466         dev->quota -= npackets;
 467 #endif
 468
 469         if (!(in_8(&regs->canrflg) & (MSCAN_RXF | MSCAN_ERR_IF))) {
 470 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,23)
 471                 netif_rx_complete(dev, &priv->napi);
 472 #else
 473                 netif_rx_complete(dev);
 474 #endif
 475                 clear_bit(F_RX_PROGRESS, &priv->flags);
 476 #if 0
 477                 out_8(&regs->canrier,
 478                       in_8(&regs->canrier) | MSCAN_ERR_IF | MSCAN_RXFIE);
 479 #else
 480                 if (priv->can.state < CAN_STATE_BUS_OFF)
 481                         out_8(&regs->canrier, priv->shadow_canrier);
 482 #endif
 483                 ret = 0;
 484         }
 485         return ret;
 486 }
 487
 488
 489 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19)
 490 static irqreturn_t mscan_isr(int irq, void *dev_id, struct pt_regs *r)
 491 #else
 492 static irqreturn_t mscan_isr(int irq, void *dev_id)
 493 #endif
 494 {
 495         struct net_device *dev = (struct net_device *)dev_id;
 496         struct mscan_priv *priv = netdev_priv(dev);
 497         struct mscan_regs *regs = (struct mscan_regs *)dev->base_addr;
 498         struct net_device_stats *stats = dev->get_stats(dev);
 499         u8 cantier, cantflg, canrflg;
 500         irqreturn_t ret = IRQ_NONE;
 501
 502         cantier = in_8(&regs->cantier) & MSCAN_TXE;
 503         cantflg = in_8(&regs->cantflg) & cantier;
 504
 505         if (cantier && cantflg) {
 506
 507                 struct list_head *tmp, *pos;
 508
 509                 list_for_each_safe(pos, tmp, &priv->tx_head) {
 510                         struct tx_queue_entry *entry =
 511                             list_entry(pos, struct tx_queue_entry, list);
 512                         u8 mask = entry->mask;
 513
 514                         if (!(cantflg & mask))
 515                                 continue;
 516
 517                         out_8(&regs->cantbsel, mask);
 518                         stats->tx_bytes += in_8(&regs->tx.dlr);
 519                         stats->tx_packets++;
 520                         can_get_echo_skb(dev, entry->id);
 521                         priv->tx_active &= ~mask;
 522                         list_del(pos);
 523                 }
 524
 525                 if (list_empty(&priv->tx_head)) {
 526                         clear_bit(F_TX_WAIT_ALL, &priv->flags);
 527                         clear_bit(F_TX_PROGRESS, &priv->flags);
 528                         priv->cur_pri = 0;
 529                 } else
 530                         dev->trans_start = jiffies;
 531
 532                 if (!test_bit(F_TX_WAIT_ALL, &priv->flags))
 533                         netif_wake_queue(dev);
 534
 535                 out_8(&regs->cantier, priv->tx_active);
 536                 ret = IRQ_HANDLED;
 537         }
 538
 539         canrflg = in_8(&regs->canrflg);
 540         if ((canrflg & ~MSCAN_STAT_MSK) &&
 541             !test_and_set_bit(F_RX_PROGRESS, &priv->flags)) {
 542 #if 0
 543                 printk(KERN_DEBUG "%s: canrflg=%#02x canrier=%#02x\n",
 544                        dev->name, canrflg, in_8(&regs->canrier));
 545 #endif
 546 #if 0
 547                 if (check_set_state(dev, canrflg)) {
 548                         out_8(&regs->canrflg, MSCAN_CSCIF);
 549                         ret = IRQ_HANDLED;
 550                 }
 551 #endif
 552                 if (canrflg & ~MSCAN_STAT_MSK) {
 553                         priv->shadow_canrier = in_8(&regs->canrier);
 554                         out_8(&regs->canrier, 0);
 555 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,23)
 556                         netif_rx_schedule(dev, &priv->napi);
 557 #else
 558                         netif_rx_schedule(dev);
 559 #endif
 560                         ret = IRQ_HANDLED;
 561                 } else
 562                         clear_bit(F_RX_PROGRESS, &priv->flags);
 563         }
 564         return ret;
 565 }
 566
 567 static int mscan_do_set_mode(struct net_device *dev, enum can_mode mode)
 568 {
 569
 570         struct mscan_priv *priv = netdev_priv(dev);
 571         int ret = 0;
 572
 573         if (!priv->open_time)
 574                 return -EINVAL;
 575
 576         switch (mode) {
 577         case CAN_MODE_SLEEP:
 578         case CAN_MODE_STOP:
 579                 netif_stop_queue(dev);
 580                 mscan_set_mode(dev,
 581                                (mode ==
 582                                 CAN_MODE_STOP) ? MSCAN_INIT_MODE :
 583                                MSCAN_SLEEP_MODE);
 584                 break;
 585         case CAN_MODE_START:
 586                 if (priv->can.state <= CAN_STATE_BUS_OFF)
 587                         mscan_set_mode(dev, MSCAN_INIT_MODE);
 588                 ret = mscan_start(dev);
 589                 if (ret)
 590                         break;
 591                 if (netif_queue_stopped(dev))
 592                         netif_wake_queue(dev);
 593                 break;
 594
 595         default:
 596                 ret = -EOPNOTSUPP;
 597                 break;
 598         }
 599         return ret;
 600 }
 601
 602 static int mscan_do_set_bittiming(struct net_device *dev)
 603 {
 604         struct mscan_regs *regs = (struct mscan_regs *)dev->base_addr;
 605         struct mscan_priv *priv = netdev_priv(dev);
 606         struct can_bittiming *bt = &priv->can.bittiming;
 607         u8 btr0, btr1;
 608
 609         btr0 = BTR0_SET_BRP(bt->brp) | BTR0_SET_SJW(bt->sjw);
 610         btr1 = (BTR1_SET_TSEG1(bt->prop_seg + bt->phase_seg1) |
 611                 BTR1_SET_TSEG2(bt->phase_seg2) |
 612                 BTR1_SET_SAM(priv->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES));
 613
 614         dev_info(ND2D(dev), "BTR0=0x%02x BTR1=0x%02x\n", btr0, btr1);
 615
 616         out_8(&regs->canbtr0, btr0);
 617         out_8(&regs->canbtr1, btr1);
 618
 619         return 0;
 620 }
 621
 622 static int mscan_open(struct net_device *dev)
 623 {
 624         int ret;
 625         struct mscan_priv *priv = netdev_priv(dev);
 626         struct mscan_regs *regs = (struct mscan_regs *)dev->base_addr;
 627
 628         /* determine and set bittime */
 629         ret = can_set_bittiming(dev);
 630         if (ret)
 631                 return ret;
 632
 633 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,23)
 634         napi_enable(&priv->napi);
 635 #endif
 636 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18)
 637         ret = request_irq(dev->irq, mscan_isr, SA_SHIRQ, dev->name, dev);
 638 #else
 639         ret = request_irq(dev->irq, mscan_isr, IRQF_SHARED, dev->name, dev);
 640 #endif
 641
 642         if (ret < 0) {
 643 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,23)
 644                 napi_disable(&priv->napi);
 645 #endif
 646                 printk(KERN_ERR "%s - failed to attach interrupt\n",
 647                        dev->name);
 648                 return ret;
 649         }
 650
 651         priv->open_time = jiffies;
 652
 653         out_8(&regs->canctl1, in_8(&regs->canctl1) & ~MSCAN_LISTEN);
 654
 655         ret = mscan_start(dev);
 656         if (ret)
 657                 return ret;
 658
 659         netif_start_queue(dev);
 660
 661         return 0;
 662 }
 663
 664 static int mscan_close(struct net_device *dev)
 665 {
 666         struct mscan_regs *regs = (struct mscan_regs *)dev->base_addr;
 667         struct mscan_priv *priv = netdev_priv(dev);
 668
 669 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,23)
 670         napi_disable(&priv->napi);
 671 #endif
 672
 673         out_8(&regs->cantier, 0);
 674         out_8(&regs->canrier, 0);
 675         free_irq(dev->irq, dev);
 676         mscan_set_mode(dev, MSCAN_INIT_MODE);
 677         can_close_cleanup(dev);
 678         netif_stop_queue(dev);
 679         priv->open_time = 0;
 680
 681         return 0;
 682 }
 683
 684 int register_mscandev(struct net_device *dev, int clock_src)
 685 {
 686         struct mscan_regs *regs = (struct mscan_regs *)dev->base_addr;
 687         u8 ctl1;
 688
 689         ctl1 = in_8(&regs->canctl1);
 690         if (clock_src)
 691                 ctl1 |= MSCAN_CLKSRC;
 692         else
 693                 ctl1 &= ~MSCAN_CLKSRC;
 694
 695         ctl1 |= MSCAN_CANE;
 696         out_8(&regs->canctl1, ctl1);
 697         udelay(100);
 698
 699         /* acceptance mask/acceptance code (accept everything) */
 700         out_be16(&regs->canidar1_0, 0);
 701         out_be16(&regs->canidar3_2, 0);
 702         out_be16(&regs->canidar5_4, 0);
 703         out_be16(&regs->canidar7_6, 0);
 704
 705         out_be16(&regs->canidmr1_0, 0xffff);
 706         out_be16(&regs->canidmr3_2, 0xffff);
 707         out_be16(&regs->canidmr5_4, 0xffff);
 708         out_be16(&regs->canidmr7_6, 0xffff);
 709         /* Two 32 bit Acceptance Filters */
 710         out_8(&regs->canidac, MSCAN_AF_32BIT);
 711
 712         mscan_set_mode(dev, MSCAN_INIT_MODE);
 713
 714         return register_netdev(dev);
 715 }
 716 EXPORT_SYMBOL(register_mscandev);
 717
 718 void unregister_mscandev(struct net_device *dev)
 719 {
 720         struct mscan_regs *regs = (struct mscan_regs *)dev->base_addr;
 721         mscan_set_mode(dev, MSCAN_INIT_MODE);
 722         out_8(&regs->canctl1, in_8(&regs->canctl1) & ~MSCAN_CANE);
 723         unregister_netdev(dev);
 724 }
 725 EXPORT_SYMBOL(unregister_mscandev);
 726
 727 struct net_device *alloc_mscandev(void)
 728 {
 729         struct net_device *dev;
 730         struct mscan_priv *priv;
 731         int i;
 732
 733         dev = alloc_candev(sizeof(struct mscan_priv));
 734         if (!dev)
 735                 return NULL;
 736         priv = netdev_priv(dev);
 737
 738         dev->open = mscan_open;
 739         dev->stop = mscan_close;
 740         dev->hard_start_xmit = mscan_hard_start_xmit;
 741
 742         dev->flags |= IFF_ECHO; /* we support local echo */
 743
 744 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,23)
 745         priv->dev = dev;
 746         netif_napi_add(dev, &priv->napi, mscan_rx_poll, 8);
 747 #else
 748         dev->poll = mscan_rx_poll;
 749         dev->weight = 8;
 750 #endif
 751
 752         priv->can.bittiming_const = &mscan_bittiming_const;
 753         priv->can.do_set_bittiming = mscan_do_set_bittiming;
 754         priv->can.do_set_mode = mscan_do_set_mode;
 755
 756         for (i = 0; i < TX_QUEUE_SIZE; i++) {
 757                 priv->tx_queue[i].id = i;
 758                 priv->tx_queue[i].mask = 1 << i;
 759         }
 760
 761         return dev;
 762 }
 763 EXPORT_SYMBOL(alloc_mscandev);
 764
 765 MODULE_AUTHOR("Andrey Volkov <avolkov@varma-el.com>");
 766 MODULE_LICENSE("GPL v2");
 767 MODULE_DESCRIPTION("CAN port driver for a mscan based chips");