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

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