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