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 } tx_queue_entry_t;
  85
  86 struct mscan_priv {
  87         struct can_priv can;
  88         volatile unsigned long flags;
  89         u8 shadow_statflg;
  90         u8 shadow_canrier;
  91         u8 cur_pri;
  92         u8 tx_active;
  93
  94         struct list_head tx_head;
  95         tx_queue_entry_t tx_queue[TX_QUEUE_SIZE];
  96 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,23)
  97         struct napi_struct napi;
  98         struct net_device *dev;
  99 #endif
 100 };
 101
 102 #define F_RX_PROGRESS   0
 103 #define F_TX_PROGRESS   1
 104 #define F_TX_WAIT_ALL   2
 105
 106 static int mscan_set_mode(struct net_device *dev, u8 mode)
 107 {
 108         struct mscan_regs *regs = (struct mscan_regs *)dev->base_addr;
 109         int ret = 0;
 110         int i;
 111         u8 canctl1;
 112
 113         if (mode != MSCAN_NORMAL_MODE) {
 114                 canctl1 = in_8(&regs->canctl1);
 115                 if ((mode & MSCAN_SLPRQ) && (canctl1 & MSCAN_SLPAK) == 0) {
 116                         out_8(&regs->canctl0,
 117                               in_8(&regs->canctl0) | MSCAN_SLPRQ);
 118                         for (i = 0; i < MSCAN_SET_MODE_RETRIES; i++) {
 119                                 if (in_8(&regs->canctl1) & MSCAN_SLPAK)
 120                                         break;
 121                                 udelay(100);
 122                         }
 123                         if (i >= MSCAN_SET_MODE_RETRIES)
 124                                 ret = -ENODEV;
 125                 }
 126
 127                 if (!ret && (mode & MSCAN_INITRQ)
 128                     && (canctl1 & MSCAN_INITAK) == 0) {
 129                         out_8(&regs->canctl0,
 130                               in_8(&regs->canctl0) | MSCAN_INITRQ);
 131                         for (i = 0; i < MSCAN_SET_MODE_RETRIES; i++) {
 132                                 if (in_8(&regs->canctl1) & MSCAN_INITAK)
 133                                         break;
 134                         }
 135                         if (i >= MSCAN_SET_MODE_RETRIES)
 136                                 ret = -ENODEV;
 137                 }
 138
 139                 if (!ret && (mode & MSCAN_CSWAI))
 140                         out_8(&regs->canctl0,
 141                               in_8(&regs->canctl0) | MSCAN_CSWAI);
 142
 143         } else {
 144                 canctl1 = in_8(&regs->canctl1);
 145                 if (canctl1 & (MSCAN_SLPAK | MSCAN_INITAK)) {
 146                         out_8(&regs->canctl0, in_8(&regs->canctl0) &
 147                               ~(MSCAN_SLPRQ | MSCAN_INITRQ));
 148                         for (i = 0; i < MSCAN_SET_MODE_RETRIES; i++) {
 149                                 canctl1 = in_8(&regs->canctl1);
 150                                 if (!(canctl1 & (MSCAN_INITAK | MSCAN_SLPAK)))
 151                                         break;
 152                         }
 153                         if (i >= MSCAN_SET_MODE_RETRIES)
 154                                 ret = -ENODEV;
 155                 }
 156         }
 157         return ret;
 158 }
 159
 160 static void mscan_push_state(struct net_device *dev, struct mscan_state *state)
 161 {
 162         struct mscan_regs *regs = (struct mscan_regs *)dev->base_addr;
 163
 164         state->mode = in_8(&regs->canctl0) & (MSCAN_SLPRQ | MSCAN_INITRQ |
 165                                               MSCAN_CSWAI);
 166         state->canrier = in_8(&regs->canrier);
 167         state->cantier = in_8(&regs->cantier);
 168 }
 169
 170 static int mscan_pop_state(struct net_device *dev, struct mscan_state *state)
 171 {
 172         struct mscan_regs *regs = (struct mscan_regs *)dev->base_addr;
 173
 174         int ret;
 175         ret = mscan_set_mode(dev, state->mode);
 176         if (!ret) {
 177                 out_8(&regs->canrier, state->canrier);
 178                 out_8(&regs->cantier, state->cantier);
 179         }
 180         return ret;
 181 }
 182
 183 static int mscan_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
 184 {
 185         struct can_frame *frame = (struct can_frame *)skb->data;
 186         struct mscan_regs *regs = (struct mscan_regs *)dev->base_addr;
 187         struct mscan_priv *priv = netdev_priv(dev);
 188
 189         int i, rtr, buf_id;
 190         u32 can_id;
 191
 192         if (frame->can_dlc > 8)
 193                 return -EINVAL;
 194
 195         dev_dbg(ND2D(dev), "%s\n", __FUNCTION__);
 196         out_8(&regs->cantier, 0);
 197
 198         i = ~priv->tx_active & MSCAN_TXE;
 199         buf_id = ffs(i) - 1;
 200         switch (hweight8(i)) {
 201         case 0:
 202                 netif_stop_queue(dev);
 203                 dev_err(ND2D(dev), "BUG! Tx Ring full when queue awake!\n");
 204                 return NETDEV_TX_BUSY;
 205         case 1:
 206                 /* if buf_id < 3, then current frame will be send out of order,
 207                    since  buffer with lower id have higher priority (hell..) */
 208                 if (buf_id < 3)
 209                         priv->cur_pri++;
 210                 if (priv->cur_pri == 0xff)
 211                         set_bit(F_TX_WAIT_ALL, &priv->flags);
 212                 netif_stop_queue(dev);
 213         case 2:
 214                 set_bit(F_TX_PROGRESS, &priv->flags);
 215         }
 216         out_8(&regs->cantbsel, i);
 217
 218         rtr = frame->can_id & CAN_RTR_FLAG;
 219
 220         if (frame->can_id & CAN_EFF_FLAG) {
 221                 dev_dbg(ND2D(dev), "sending extended frame\n");
 222
 223                 can_id = (frame->can_id & CAN_EFF_MASK) << 1;
 224                 if (rtr)
 225                         can_id |= 1;
 226                 out_be16(&regs->tx.idr3_2, can_id);
 227
 228                 can_id >>= 16;
 229                 can_id = (can_id & 0x7) | ((can_id << 2) & 0xffe0) | (3 << 3);
 230         } else {
 231                 dev_dbg(ND2D(dev), "sending standard frame\n");
 232                 can_id = (frame->can_id & CAN_SFF_MASK) << 5;
 233                 if (rtr)
 234                         can_id |= 1 << 4;
 235         }
 236         out_be16(&regs->tx.idr1_0, can_id);
 237
 238         if (!rtr) {
 239                 volatile void __iomem *data = &regs->tx.dsr1_0;
 240                 u16 *payload = (u16 *) frame->data;
 241                 /*Its safe to write into dsr[dlc+1] */
 242                 for (i = 0; i < (frame->can_dlc + 1) / 2; i++) {
 243                         out_be16(data, *payload++);
 244                         data += 2 + _MSCAN_RESERVED_DSR_SIZE;
 245                 }
 246         }
 247
 248         out_8(&regs->tx.dlr, frame->can_dlc);
 249         out_8(&regs->tx.tbpr, priv->cur_pri);
 250
 251         /* Start transmission. */
 252         out_8(&regs->cantflg, 1 << buf_id);
 253
 254         if (!test_bit(F_TX_PROGRESS, &priv->flags))
 255                 dev->trans_start = jiffies;
 256
 257         list_add_tail(&priv->tx_queue[buf_id].list, &priv->tx_head);
 258
 259         kfree_skb(skb);
 260
 261         /* Enable interrupt. */
 262         priv->tx_active |= 1 << buf_id;
 263         out_8(&regs->cantier, priv->tx_active);
 264
 265         return NETDEV_TX_OK;
 266 }
 267
 268 static void mscan_tx_timeout(struct net_device *dev)
 269 {
 270         struct sk_buff *skb;
 271         struct mscan_regs *regs = (struct mscan_regs *)dev->base_addr;
 272         struct mscan_priv *priv = netdev_priv(dev);
 273         struct can_frame *frame;
 274         u8 mask;
 275
 276         printk("%s\n", __FUNCTION__);
 277
 278         out_8(&regs->cantier, 0);
 279
 280         mask = list_entry(priv->tx_head.next, tx_queue_entry_t, list)->mask;
 281         dev->trans_start = jiffies;
 282         out_8(&regs->cantarq, mask);
 283         out_8(&regs->cantier, priv->tx_active);
 284
 285         skb = dev_alloc_skb(sizeof(struct can_frame));
 286         if (!skb) {
 287                 if (printk_ratelimit())
 288                         dev_notice(ND2D(dev), "TIMEOUT packet dropped\n");
 289                 return;
 290         }
 291         frame = (struct can_frame *)skb_put(skb, sizeof(struct can_frame));
 292
 293         frame->can_id = CAN_ERR_FLAG | CAN_ERR_TX_TIMEOUT;
 294         frame->can_dlc = CAN_ERR_DLC;
 295
 296         skb->dev = dev;
 297         skb->protocol = __constant_htons(ETH_P_CAN);
 298         skb->pkt_type = PACKET_BROADCAST;
 299         skb->ip_summed = CHECKSUM_UNNECESSARY;
 300
 301         netif_rx(skb);
 302
 303 }
 304
 305 static can_state_t state_map[] = {
 306         CAN_STATE_ACTIVE,
 307         CAN_STATE_BUS_WARNING,
 308         CAN_STATE_BUS_PASSIVE,
 309         CAN_STATE_BUS_OFF
 310 };
 311
 312 static inline int check_set_state(struct net_device *dev, u8 canrflg)
 313 {
 314         struct mscan_priv *priv = netdev_priv(dev);
 315         can_state_t state;
 316         int ret = 0;
 317
 318         if (!(canrflg & MSCAN_CSCIF) || priv->can.state > CAN_STATE_BUS_OFF)
 319                 return 0;
 320
 321         state =
 322             state_map[max(MSCAN_STATE_RX(canrflg), MSCAN_STATE_TX(canrflg))];
 323         if (priv->can.state < state)
 324                 ret = 1;
 325         if (state == CAN_STATE_BUS_OFF)
 326                 netif_carrier_off(dev);
 327         else if (priv->can.state == CAN_STATE_BUS_OFF
 328                  && state != CAN_STATE_BUS_OFF)
 329                 netif_carrier_on(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,
 370                                                     sizeof(struct can_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("%2x ", frame->data[i]);
 407                         printk("\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                                 }
 449                         }
 450                         priv->shadow_statflg = canrflg & MSCAN_STAT_MSK;
 451                         frame->can_dlc = CAN_ERR_DLC;
 452                         out_8(&regs->canrflg, MSCAN_ERR_IF);
 453                 }
 454
 455                 npackets++;
 456                 skb->dev = dev;
 457                 skb->protocol = __constant_htons(ETH_P_CAN);
 458                 skb->ip_summed = CHECKSUM_UNNECESSARY;
 459                 netif_receive_skb(skb);
 460         }
 461
 462 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,23)
 463         *budget -= npackets;
 464         dev->quota -= npackets;
 465 #endif
 466
 467         if (!(in_8(&regs->canrflg) & (MSCAN_RXF | MSCAN_ERR_IF))) {
 468 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,23)
 469                 netif_rx_complete(dev, &priv->napi);
 470 #else
 471                 netif_rx_complete(dev);
 472 #endif
 473                 clear_bit(F_RX_PROGRESS, &priv->flags);
 474                 out_8(&regs->canrier,
 475                       in_8(&regs->canrier) | MSCAN_ERR_IF | MSCAN_RXFIE);
 476                 ret = 0;
 477         }
 478         return ret;
 479 }
 480
 481
 482 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19)
 483 static irqreturn_t mscan_isr(int irq, void *dev_id, struct pt_regs *r)
 484 #else
 485 static irqreturn_t mscan_isr(int irq, void *dev_id)
 486 #endif
 487 {
 488         struct net_device *dev = (struct net_device *)dev_id;
 489         struct mscan_priv *priv = netdev_priv(dev);
 490         struct mscan_regs *regs = (struct mscan_regs *)dev->base_addr;
 491         struct net_device_stats *stats = dev->get_stats(dev);
 492         u8 cantflg, canrflg;
 493         irqreturn_t ret = IRQ_NONE;
 494
 495         if (in_8(&regs->cantier) & MSCAN_TXE) {
 496                 struct list_head *tmp, *pos;
 497
 498                 cantflg = in_8(&regs->cantflg) & MSCAN_TXE;
 499
 500                 list_for_each_safe(pos, tmp, &priv->tx_head) {
 501                         tx_queue_entry_t *entry =
 502                             list_entry(pos, tx_queue_entry_t, list);
 503                         u8 mask = entry->mask;
 504
 505                         if (!(cantflg & mask))
 506                                 continue;
 507
 508                         if (in_8(&regs->cantaak) & mask) {
 509                                 stats->tx_dropped++;
 510                                 stats->tx_aborted_errors++;
 511                         } else {
 512                                 out_8(&regs->cantbsel, mask);
 513                                 stats->tx_bytes +=
 514                                     in_8(&regs->tx.dlr);
 515                                 stats->tx_packets++;
 516                         }
 517                         priv->tx_active &= ~mask;
 518                         list_del(pos);
 519                 }
 520
 521                 if (list_empty(&priv->tx_head)) {
 522                         clear_bit(F_TX_WAIT_ALL, &priv->flags);
 523                         clear_bit(F_TX_PROGRESS, &priv->flags);
 524                         priv->cur_pri = 0;
 525                 } else
 526                         dev->trans_start = jiffies;
 527
 528                 if (!test_bit(F_TX_WAIT_ALL, &priv->flags))
 529                         netif_wake_queue(dev);
 530
 531                 out_8(&regs->cantier, priv->tx_active);
 532                 ret = IRQ_HANDLED;
 533         }
 534
 535         if ((((canrflg = in_8(&regs->canrflg)) & ~MSCAN_STAT_MSK)) &&
 536             !test_and_set_bit(F_RX_PROGRESS, &priv->flags)) {
 537                 if (check_set_state(dev, canrflg)) {
 538                         out_8(&regs->canrflg, MSCAN_CSCIF);
 539                         ret = IRQ_HANDLED;
 540                 }
 541                 if (canrflg & ~MSCAN_STAT_MSK) {
 542                         priv->shadow_canrier = in_8(&regs->canrier);
 543                         out_8(&regs->canrier, 0);
 544 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,23)
 545                         netif_rx_schedule(dev, &priv->napi);
 546 #else
 547                         netif_rx_schedule(dev);
 548 #endif
 549                         ret = IRQ_HANDLED;
 550                 } else
 551                         clear_bit(F_RX_PROGRESS, &priv->flags);
 552         }
 553         return ret;
 554 }
 555
 556 static int mscan_do_set_mode(struct net_device *dev, can_mode_t mode)
 557 {
 558         switch (mode) {
 559         case CAN_MODE_SLEEP:
 560         case CAN_MODE_STOP:
 561                 netif_stop_queue(dev);
 562                 mscan_set_mode(dev,
 563                                (mode ==
 564                                 CAN_MODE_STOP) ? MSCAN_INIT_MODE :
 565                                MSCAN_SLEEP_MODE);
 566                 break;
 567         case CAN_MODE_START:
 568                 printk("%s: CAN_MODE_START requested\n", __FUNCTION__);
 569                 mscan_set_mode(dev, MSCAN_NORMAL_MODE);
 570                 netif_wake_queue(dev);
 571                 break;
 572
 573         default:
 574                 return -EOPNOTSUPP;
 575         }
 576         return 0;
 577 }
 578
 579 static int mscan_do_set_bit_time(struct net_device *dev,
 580                                  struct can_bittime *bt)
 581 {
 582         struct mscan_priv *priv = netdev_priv(dev);
 583         struct mscan_regs *regs = (struct mscan_regs *)dev->base_addr;
 584         int ret = 0;
 585         u8 reg;
 586         struct mscan_state state;
 587
 588         if (bt->type != CAN_BITTIME_STD)
 589                 return -EINVAL;
 590
 591         spin_lock_irq(&priv->can.irq_lock);
 592
 593         mscan_push_state(dev, &state);
 594         ret = mscan_set_mode(dev, MSCAN_INIT_MODE);
 595         if (!ret) {
 596                 reg = BTR0_SET_BRP(bt->std.brp) | BTR0_SET_SJW(bt->std.sjw);
 597                 out_8(&regs->canbtr0, reg);
 598
 599                 reg = (BTR1_SET_TSEG1(bt->std.prop_seg + bt->std.phase_seg1) |
 600                        BTR1_SET_TSEG2(bt->std.phase_seg2) |
 601                        BTR1_SET_SAM(bt->std.sam));
 602                 out_8(&regs->canbtr1, reg);
 603
 604                 ret = mscan_pop_state(dev, &state);
 605         }
 606
 607         spin_unlock_irq(&priv->can.irq_lock);
 608         return ret;
 609 }
 610
 611 static int mscan_open(struct net_device *dev)
 612 {
 613         int ret;
 614         struct mscan_priv *priv = netdev_priv(dev);
 615         struct mscan_regs *regs = (struct mscan_regs *)dev->base_addr;
 616
 617 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,23)
 618         napi_enable(&priv->napi);
 619 #endif
 620 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18)
 621         ret = request_irq(dev->irq, mscan_isr, SA_SHIRQ, dev->name, dev);
 622 #else
 623         ret = request_irq(dev->irq, mscan_isr, IRQF_SHARED, dev->name, dev);
 624 #endif
 625
 626         if (ret  < 0) {
 627 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,23)
 628                 napi_disable(&priv->napi);
 629 #endif
 630                 printk(KERN_ERR "%s - failed to attach interrupt\n",
 631                        dev->name);
 632                 return ret;
 633         }
 634
 635         INIT_LIST_HEAD(&priv->tx_head);
 636         /* acceptance mask/acceptance code (accept everything) */
 637         out_be16(&regs->canidar1_0, 0);
 638         out_be16(&regs->canidar3_2, 0);
 639         out_be16(&regs->canidar5_4, 0);
 640         out_be16(&regs->canidar7_6, 0);
 641
 642         out_be16(&regs->canidmr1_0, 0xffff);
 643         out_be16(&regs->canidmr3_2, 0xffff);
 644         out_be16(&regs->canidmr5_4, 0xffff);
 645         out_be16(&regs->canidmr7_6, 0xffff);
 646         /* Two 32 bit Acceptance Filters */
 647         out_8(&regs->canidac, MSCAN_AF_32BIT);
 648
 649         out_8(&regs->canctl1, in_8(&regs->canctl1) & ~MSCAN_LISTEN);
 650         mscan_set_mode(dev, MSCAN_NORMAL_MODE);
 651
 652         priv->shadow_statflg = in_8(&regs->canrflg) & MSCAN_STAT_MSK;
 653         priv->cur_pri = 0;
 654         priv->tx_active = 0;
 655
 656         out_8(&regs->cantier, 0);
 657         /* Enable receive interrupts. */
 658         out_8(&regs->canrier, MSCAN_OVRIE | MSCAN_RXFIE | MSCAN_CSCIE |
 659               MSCAN_RSTATE1 | MSCAN_RSTATE0 | MSCAN_TSTATE1 | MSCAN_TSTATE0);
 660
 661         netif_start_queue(dev);
 662
 663         return 0;
 664 }
 665
 666 static int mscan_close(struct net_device *dev)
 667 {
 668         struct mscan_regs *regs = (struct mscan_regs *)dev->base_addr;
 669
 670         netif_stop_queue(dev);
 671
 672         /* disable interrupts */
 673         out_8(&regs->cantier, 0);
 674         out_8(&regs->canrier, 0);
 675         free_irq(dev->irq, dev);
 676
 677         mscan_set_mode(dev, MSCAN_INIT_MODE);
 678         return 0;
 679 }
 680
 681 int register_mscandev(struct net_device *dev, int clock_src)
 682 {
 683         struct mscan_regs *regs = (struct mscan_regs *)dev->base_addr;
 684         u8 ctl1;
 685
 686         ctl1 = in_8(&regs->canctl1);
 687         if (clock_src)
 688                 ctl1 |= MSCAN_CLKSRC;
 689         else
 690                 ctl1 &= ~MSCAN_CLKSRC;
 691
 692         ctl1 |= MSCAN_CANE;
 693         out_8(&regs->canctl1, ctl1);
 694         udelay(100);
 695
 696         mscan_set_mode(dev, MSCAN_INIT_MODE);
 697
 698         return register_netdev(dev);
 699 }
 700
 701 EXPORT_SYMBOL(register_mscandev);
 702
 703 void unregister_mscandev(struct net_device *dev)
 704 {
 705         struct mscan_regs *regs = (struct mscan_regs *)dev->base_addr;
 706         mscan_set_mode(dev, MSCAN_INIT_MODE);
 707         out_8(&regs->canctl1, in_8(&regs->canctl1) & ~MSCAN_CANE);
 708         unregister_netdev(dev);
 709 }
 710
 711 EXPORT_SYMBOL(unregister_mscandev);
 712
 713 struct net_device *alloc_mscandev(void)
 714 {
 715         struct net_device *dev;
 716         struct mscan_priv *priv;
 717         int i;
 718
 719         dev = alloc_candev(sizeof(struct mscan_priv));
 720         if (!dev)
 721                 return NULL;
 722         priv = netdev_priv(dev);
 723
 724         dev->watchdog_timeo = MSCAN_WATCHDOG_TIMEOUT;
 725         dev->open = mscan_open;
 726         dev->stop = mscan_close;
 727         dev->hard_start_xmit = mscan_hard_start_xmit;
 728         dev->tx_timeout = mscan_tx_timeout;
 729
 730 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,23)
 731         priv->dev = dev;
 732         netif_napi_add(dev, &priv->napi, mscan_rx_poll, 8);
 733 #else
 734         dev->poll = mscan_rx_poll;
 735         dev->weight = 8;
 736 #endif
 737
 738         priv->can.do_set_bit_time = mscan_do_set_bit_time;
 739         priv->can.do_set_mode = mscan_do_set_mode;
 740
 741         for (i = 0; i < TX_QUEUE_SIZE; i++)
 742                 priv->tx_queue[i].mask = 1 << i;
 743
 744         return dev;
 745 }
 746
 747 EXPORT_SYMBOL(alloc_mscandev);
 748
 749 MODULE_AUTHOR("Andrey Volkov <avolkov@varma-el.com>");
 750 MODULE_LICENSE("GPL v2");
 751 MODULE_DESCRIPTION("CAN port driver for a mscan based chips");