drivers/net/wireless/arlan-main.c

   1 /*
   2  *  Copyright (C) 1997 Cullen Jennings
   3  *  Copyright (C) 1998 Elmer Joandiu, elmer@ylenurme.ee
   4  *  GNU General Public License applies
   5  * This module provides support for the Arlan 655 card made by Aironet
   6  */
   7
   8 #include <linux/config.h>
   9 #include "arlan.h"
  10
  11 #if BITS_PER_LONG != 32
  12 #  error FIXME: this driver requires a 32-bit platform
  13 #endif
  14
  15 static const char *arlan_version = "C.Jennigs 97 & Elmer.Joandi@ut.ee  Oct'98, http://www.ylenurme.ee/~elmer/655/";
  16
  17 struct net_device *arlan_device[MAX_ARLANS];
  18
  19 static int SID = SIDUNKNOWN;
  20 static int radioNodeId = radioNodeIdUNKNOWN;
  21 static char encryptionKey[12] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'};
  22 int arlan_debug = debugUNKNOWN;
  23 static int spreadingCode = spreadingCodeUNKNOWN;
  24 static int channelNumber = channelNumberUNKNOWN;
  25 static int channelSet = channelSetUNKNOWN;
  26 static int systemId = systemIdUNKNOWN;
  27 static int registrationMode = registrationModeUNKNOWN;
  28 static int keyStart;
  29 static int tx_delay_ms;
  30 static int retries = 5;
  31 static int tx_queue_len = 1;
  32 static int arlan_EEPROM_bad;
  33
  34 #ifdef ARLAN_DEBUGGING
  35
  36 static int arlan_entry_debug;
  37 static int arlan_exit_debug;
  38 static int testMemory = testMemoryUNKNOWN;
  39 static int irq = irqUNKNOWN;
  40 static int txScrambled = 1;
  41 static int mdebug;
  42 #endif
  43
  44 MODULE_PARM(irq, "i");
  45 MODULE_PARM(mem, "i");
  46 MODULE_PARM(arlan_debug, "i");
  47 MODULE_PARM(testMemory, "i");
  48 MODULE_PARM(spreadingCode, "i");
  49 MODULE_PARM(channelNumber, "i");
  50 MODULE_PARM(channelSet, "i");
  51 MODULE_PARM(systemId, "i");
  52 MODULE_PARM(registrationMode, "i");
  53 MODULE_PARM(radioNodeId, "i");
  54 MODULE_PARM(SID, "i");
  55 MODULE_PARM(txScrambled, "i");
  56 MODULE_PARM(keyStart, "i");
  57 MODULE_PARM(mdebug, "i");
  58 MODULE_PARM(tx_delay_ms, "i");
  59 MODULE_PARM(retries, "i");
  60 MODULE_PARM(async, "i");
  61 MODULE_PARM(tx_queue_len, "i");
  62 MODULE_PARM(arlan_entry_debug, "i");
  63 MODULE_PARM(arlan_exit_debug, "i");
  64 MODULE_PARM(arlan_entry_and_exit_debug, "i");
  65 MODULE_PARM(arlan_EEPROM_bad, "i");
  66 MODULE_PARM_DESC(irq, "(unused)");
  67 MODULE_PARM_DESC(mem, "Arlan memory address for single device probing");
  68 MODULE_PARM_DESC(arlan_debug, "Arlan debug enable (0-1)");
  69 MODULE_PARM_DESC(testMemory, "(unused)");
  70 MODULE_PARM_DESC(mdebug, "Arlan multicast debugging (0-1)");
  71 MODULE_PARM_DESC(retries, "Arlan maximum packet retransmisions");
  72 #ifdef ARLAN_ENTRY_EXIT_DEBUGGING
  73 MODULE_PARM_DESC(arlan_entry_debug, "Arlan driver function entry debugging");
  74 MODULE_PARM_DESC(arlan_exit_debug, "Arlan driver function exit debugging");
  75 MODULE_PARM_DESC(arlan_entry_and_exit_debug, "Arlan driver function entry and exit debugging");
  76 #else
  77 MODULE_PARM_DESC(arlan_entry_debug, "(ignored)");
  78 MODULE_PARM_DESC(arlan_exit_debug, "(ignored)");
  79 MODULE_PARM_DESC(arlan_entry_and_exit_debug, "(ignored)");
  80 #endif
  81
  82 struct arlan_conf_stru arlan_conf[MAX_ARLANS];
  83 static int arlans_found;
  84
  85 static  int     arlan_open(struct net_device *dev);
  86 static  int     arlan_tx(struct sk_buff *skb, struct net_device *dev);
  87 static  irqreturn_t arlan_interrupt(int irq, void *dev_id, struct pt_regs *regs);
  88 static  int     arlan_close(struct net_device *dev);
  89 static  struct net_device_stats *
  90                 arlan_statistics                (struct net_device *dev);
  91 static  void    arlan_set_multicast             (struct net_device *dev);
  92 static  int     arlan_hw_tx                     (struct net_device* dev, char *buf, int length );
  93 static  int     arlan_hw_config                 (struct net_device * dev);
  94 static  void    arlan_tx_done_interrupt         (struct net_device * dev, int status);
  95 static  void    arlan_rx_interrupt              (struct net_device * dev, u_char rxStatus, u_short, u_short);
  96 static  void    arlan_process_interrupt         (struct net_device * dev);
  97 static  void    arlan_tx_timeout                (struct net_device *dev);
  98
  99 static inline long us2ticks(int us)
 100 {
 101         return us * (1000000 / HZ);
 102 }
 103
 104
 105 #ifdef ARLAN_ENTRY_EXIT_DEBUGGING
 106 #define ARLAN_DEBUG_ENTRY(name) \
 107         {\
 108         struct timeval timev;\
 109         do_gettimeofday(&timev);\
 110                 if (arlan_entry_debug || arlan_entry_and_exit_debug)\
 111                         printk("--->>>" name " %ld " "\n",((long int) timev.tv_sec * 1000000 + timev.tv_usec));\
 112         }
 113 #define ARLAN_DEBUG_EXIT(name) \
 114         {\
 115         struct timeval timev;\
 116         do_gettimeofday(&timev);\
 117                 if (arlan_exit_debug || arlan_entry_and_exit_debug)\
 118                         printk("<<<---" name " %ld " "\n",((long int) timev.tv_sec * 1000000 + timev.tv_usec) );\
 119         }
 120 #else
 121 #define ARLAN_DEBUG_ENTRY(name)
 122 #define ARLAN_DEBUG_EXIT(name)
 123 #endif
 124
 125
 126 #define arlan_interrupt_ack(dev)\
 127         clearClearInterrupt(dev);\
 128         setClearInterrupt(dev);
 129
 130 static inline int arlan_drop_tx(struct net_device *dev)
 131 {
 132         struct arlan_private *priv = dev->priv;
 133
 134         priv->stats.tx_errors++;
 135         if (priv->Conf->tx_delay_ms)
 136         {
 137                 priv->tx_done_delayed = jiffies + priv->Conf->tx_delay_ms * HZ / 1000 + 1;
 138         }
 139         else
 140         {
 141                 priv->waiting_command_mask &= ~ARLAN_COMMAND_TX;
 142                 TXHEAD(dev).offset = 0;
 143                 TXTAIL(dev).offset = 0;
 144                 priv->txLast = 0;
 145                 priv->bad = 0;
 146                 if (!priv->under_reset && !priv->under_config)
 147                         netif_wake_queue (dev);
 148         }
 149         return 1;
 150 }
 151
 152
 153 int arlan_command(struct net_device *dev, int command_p)
 154 {
 155         struct arlan_private *priv = dev->priv;
 156         volatile struct arlan_shmem *arlan = priv->card;
 157         struct arlan_conf_stru *conf = priv->Conf;
 158         int udelayed = 0;
 159         int i = 0;
 160         unsigned long flags;
 161
 162         ARLAN_DEBUG_ENTRY("arlan_command");
 163
 164         if (priv->card_polling_interval)
 165                 priv->card_polling_interval = 1;
 166
 167         if (arlan_debug & ARLAN_DEBUG_CHAIN_LOCKS)
 168                 printk(KERN_DEBUG "arlan_command, %lx commandByte %x waiting %lx incoming %x \n",
 169                 jiffies, READSHMB(arlan->commandByte),
 170                        priv->waiting_command_mask, command_p);
 171
 172         priv->waiting_command_mask |= command_p;
 173
 174         if (priv->waiting_command_mask & ARLAN_COMMAND_RESET)
 175                 if (time_after(jiffies, priv->lastReset + 5 * HZ))
 176                         priv->waiting_command_mask &= ~ARLAN_COMMAND_RESET;
 177
 178         if (priv->waiting_command_mask & ARLAN_COMMAND_INT_ACK)
 179         {
 180                 arlan_interrupt_ack(dev);
 181                 priv->waiting_command_mask &= ~ARLAN_COMMAND_INT_ACK;
 182         }
 183         if (priv->waiting_command_mask & ARLAN_COMMAND_INT_ENABLE)
 184         {
 185                 setInterruptEnable(dev);
 186                 priv->waiting_command_mask &= ~ARLAN_COMMAND_INT_ENABLE;
 187         }
 188
 189         /* Card access serializing lock */
 190         spin_lock_irqsave(&priv->lock, flags);
 191
 192         /* Check cards status and waiting */
 193
 194         if (priv->waiting_command_mask & (ARLAN_COMMAND_LONG_WAIT_NOW | ARLAN_COMMAND_WAIT_NOW))
 195         {
 196                 while (priv->waiting_command_mask & (ARLAN_COMMAND_LONG_WAIT_NOW | ARLAN_COMMAND_WAIT_NOW))
 197                 {
 198                         if (READSHMB(arlan->resetFlag) ||
 199                                 READSHMB(arlan->commandByte))   /* ||
 200                                                                    (readControlRegister(dev) & ARLAN_ACCESS))
 201                                                                  */
 202                                 udelay(40);
 203                         else
 204                                 priv->waiting_command_mask &= ~(ARLAN_COMMAND_LONG_WAIT_NOW | ARLAN_COMMAND_WAIT_NOW);
 205
 206                         udelayed++;
 207
 208                         if (priv->waiting_command_mask & ARLAN_COMMAND_LONG_WAIT_NOW)
 209                         {
 210                                 if (udelayed * 40 > 1000000)
 211                                 {
 212                                         printk(KERN_ERR "%s long wait too long \n", dev->name);
 213                                         priv->waiting_command_mask |= ARLAN_COMMAND_RESET;
 214                                         break;
 215                                 }
 216                         }
 217                         else if (priv->waiting_command_mask & ARLAN_COMMAND_WAIT_NOW)
 218                         {
 219                                 if (udelayed * 40 > 1000)
 220                                 {
 221                                         printk(KERN_ERR "%s short wait too long \n", dev->name);
 222                                         goto bad_end;
 223                                 }
 224                         }
 225                 }
 226         }
 227         else
 228         {
 229                 i = 0;
 230                 while ((READSHMB(arlan->resetFlag) ||
 231                         READSHMB(arlan->commandByte)) &&
 232                         conf->pre_Command_Wait > (i++) * 10)
 233                         udelay(10);
 234
 235
 236                 if ((READSHMB(arlan->resetFlag) ||
 237                         READSHMB(arlan->commandByte)) &&
 238                         !(priv->waiting_command_mask & ARLAN_COMMAND_RESET))
 239                 {
 240                         goto card_busy_end;
 241                 }
 242         }
 243         if (priv->waiting_command_mask & ARLAN_COMMAND_RESET)
 244                 priv->under_reset = 1;
 245         if (priv->waiting_command_mask & ARLAN_COMMAND_CONF)
 246                 priv->under_config = 1;
 247
 248         /* Issuing command */
 249         arlan_lock_card_access(dev);
 250         if (priv->waiting_command_mask & ARLAN_COMMAND_POWERUP)
 251         {
 252         //     if (readControlRegister(dev) & (ARLAN_ACCESS && ARLAN_POWER))
 253                 setPowerOn(dev);
 254                 arlan_interrupt_lancpu(dev);
 255                 priv->waiting_command_mask &= ~ARLAN_COMMAND_POWERUP;
 256                 priv->waiting_command_mask |= ARLAN_COMMAND_RESET;
 257                 priv->card_polling_interval = HZ / 10;
 258         }
 259         else if (priv->waiting_command_mask & ARLAN_COMMAND_ACTIVATE)
 260         {
 261                 WRITESHMB(arlan->commandByte, ARLAN_COM_ACTIVATE);
 262                 arlan_interrupt_lancpu(dev);
 263                 priv->waiting_command_mask &= ~ARLAN_COMMAND_ACTIVATE;
 264                 priv->card_polling_interval = HZ / 10;
 265         }
 266         else if (priv->waiting_command_mask & ARLAN_COMMAND_RX_ABORT)
 267         {
 268                 if (priv->rx_command_given)
 269                 {
 270                         WRITESHMB(arlan->commandByte, ARLAN_COM_RX_ABORT);
 271                         arlan_interrupt_lancpu(dev);
 272                         priv->rx_command_given = 0;
 273                 }
 274                 priv->waiting_command_mask &= ~ARLAN_COMMAND_RX_ABORT;
 275                 priv->card_polling_interval = 1;
 276         }
 277         else if (priv->waiting_command_mask & ARLAN_COMMAND_TX_ABORT)
 278         {
 279                 if (priv->tx_command_given)
 280                 {
 281                         WRITESHMB(arlan->commandByte, ARLAN_COM_TX_ABORT);
 282                         arlan_interrupt_lancpu(dev);
 283                         priv->tx_command_given = 0;
 284                 }
 285                 priv->waiting_command_mask &= ~ARLAN_COMMAND_TX_ABORT;
 286                 priv->card_polling_interval = 1;
 287         }
 288         else if (priv->waiting_command_mask & ARLAN_COMMAND_RESET)
 289         {
 290                 priv->under_reset=1;
 291                 netif_stop_queue (dev);
 292
 293                 arlan_drop_tx(dev);
 294                 if (priv->tx_command_given || priv->rx_command_given)
 295                 {
 296                         printk(KERN_ERR "%s: Reset under tx or rx command \n", dev->name);
 297                 }
 298                 netif_stop_queue (dev);
 299                 if (arlan_debug & ARLAN_DEBUG_RESET)
 300                         printk(KERN_ERR "%s: Doing chip reset\n", dev->name);
 301                 priv->lastReset = jiffies;
 302                 WRITESHM(arlan->commandByte, 0, u_char);
 303                 /* hold card in reset state */
 304                 setHardwareReset(dev);
 305                 /* set reset flag and then release reset */
 306                 WRITESHM(arlan->resetFlag, 0xff, u_char);
 307                 clearChannelAttention(dev);
 308                 clearHardwareReset(dev);
 309                 priv->card_polling_interval = HZ / 4;
 310                 priv->waiting_command_mask &= ~ARLAN_COMMAND_RESET;
 311                 priv->waiting_command_mask |= ARLAN_COMMAND_INT_RACK;
 312 //              priv->waiting_command_mask |= ARLAN_COMMAND_INT_RENABLE;
 313 //              priv->waiting_command_mask |= ARLAN_COMMAND_RX;
 314         }
 315         else if (priv->waiting_command_mask & ARLAN_COMMAND_INT_RACK)
 316         {
 317                 clearHardwareReset(dev);
 318                 clearClearInterrupt(dev);
 319                 setClearInterrupt(dev);
 320                 setInterruptEnable(dev);
 321                 priv->waiting_command_mask &= ~ARLAN_COMMAND_INT_RACK;
 322                 priv->waiting_command_mask |= ARLAN_COMMAND_CONF;
 323                 priv->under_config = 1;
 324                 priv->under_reset = 0;
 325         }
 326         else if (priv->waiting_command_mask & ARLAN_COMMAND_INT_RENABLE)
 327         {
 328                 setInterruptEnable(dev);
 329                 priv->waiting_command_mask &= ~ARLAN_COMMAND_INT_RENABLE;
 330         }
 331         else if (priv->waiting_command_mask & ARLAN_COMMAND_CONF)
 332         {
 333                 if (priv->tx_command_given || priv->rx_command_given)
 334                 {
 335                         printk(KERN_ERR "%s: Reset under tx or rx command \n", dev->name);
 336                 }
 337                 arlan_drop_tx(dev);
 338                 setInterruptEnable(dev);
 339                 arlan_hw_config(dev);
 340                 arlan_interrupt_lancpu(dev);
 341                 priv->waiting_command_mask &= ~ARLAN_COMMAND_CONF;
 342                 priv->card_polling_interval = HZ / 10;
 343 //              priv->waiting_command_mask |= ARLAN_COMMAND_INT_RACK;
 344 //              priv->waiting_command_mask |= ARLAN_COMMAND_INT_ENABLE;
 345                 priv->waiting_command_mask |= ARLAN_COMMAND_CONF_WAIT;
 346         }
 347         else if (priv->waiting_command_mask & ARLAN_COMMAND_CONF_WAIT)
 348         {
 349                 if (READSHMB(arlan->configuredStatusFlag) != 0 &&
 350                         READSHMB(arlan->diagnosticInfo) == 0xff)
 351                 {
 352                         priv->waiting_command_mask &= ~ARLAN_COMMAND_CONF_WAIT;
 353                         priv->waiting_command_mask |= ARLAN_COMMAND_RX;
 354                         priv->waiting_command_mask |= ARLAN_COMMAND_TBUSY_CLEAR;
 355                         priv->card_polling_interval = HZ / 10;
 356                         priv->tx_command_given = 0;
 357                         priv->under_config = 0;
 358                 }
 359                 else
 360                 {
 361                         priv->card_polling_interval = 1;
 362                         if (arlan_debug & ARLAN_DEBUG_TIMING)
 363                                 printk(KERN_ERR "configure delayed \n");
 364                 }
 365         }
 366         else if (priv->waiting_command_mask & ARLAN_COMMAND_RX)
 367         {
 368                 if (!registrationBad(dev))
 369                 {
 370                         setInterruptEnable(dev);
 371                         memset_io((void *) arlan->commandParameter, 0, 0xf);
 372                         WRITESHMB(arlan->commandByte, ARLAN_COM_INT | ARLAN_COM_RX_ENABLE);
 373                         WRITESHMB(arlan->commandParameter[0], conf->rxParameter);
 374                         arlan_interrupt_lancpu(dev);
 375                         priv->rx_command_given = 0; // mnjah, bad
 376                         priv->waiting_command_mask &= ~ARLAN_COMMAND_RX;
 377                         priv->card_polling_interval = 1;
 378                 }
 379                 else
 380                         priv->card_polling_interval = 2;
 381         }
 382         else if (priv->waiting_command_mask & ARLAN_COMMAND_TBUSY_CLEAR)
 383         {
 384                 if ( !registrationBad(dev) &&
 385                      (netif_queue_stopped(dev) || !netif_running(dev)) )
 386                         {
 387                                 priv->waiting_command_mask &= ~ARLAN_COMMAND_TBUSY_CLEAR;
 388                                 netif_wake_queue (dev);
 389                         }
 390         }
 391         else if (priv->waiting_command_mask & ARLAN_COMMAND_TX)
 392         {
 393                 if (!test_and_set_bit(0, (void *) &priv->tx_command_given))
 394                 {
 395                         if (time_after(jiffies,
 396                                        priv->tx_last_sent + us2ticks(conf->rx_tweak1))
 397                             || time_before(jiffies,
 398                                            priv->last_rx_int_ack_time + us2ticks(conf->rx_tweak2)))
 399                         {
 400                                 setInterruptEnable(dev);
 401                                 memset_io((void *) arlan->commandParameter, 0, 0xf);
 402                                 WRITESHMB(arlan->commandByte, ARLAN_COM_TX_ENABLE | ARLAN_COM_INT);
 403                                 memcpy_toio((void *) arlan->commandParameter, &TXLAST(dev), 14);
 404 //                              for ( i=1 ; i < 15 ; i++) printk("%02x:",READSHMB(arlan->commandParameter[i]));
 405                                 priv->tx_last_sent = jiffies;
 406                                 arlan_interrupt_lancpu(dev);
 407                                 priv->tx_command_given = 1;
 408                                 priv->waiting_command_mask &= ~ARLAN_COMMAND_TX;
 409                                 priv->card_polling_interval = 1;
 410                         }
 411                         else
 412                         {
 413                                 priv->tx_command_given = 0;
 414                                 priv->card_polling_interval = 1;
 415                         }
 416                 }
 417                 else if (arlan_debug & ARLAN_DEBUG_CHAIN_LOCKS)
 418                         printk(KERN_ERR "tx command when tx chain locked \n");
 419         }
 420         else if (priv->waiting_command_mask & ARLAN_COMMAND_NOOPINT)
 421         {
 422                 {
 423                         WRITESHMB(arlan->commandByte, ARLAN_COM_NOP | ARLAN_COM_INT);
 424                 }
 425                 arlan_interrupt_lancpu(dev);
 426                 priv->waiting_command_mask &= ~ARLAN_COMMAND_NOOPINT;
 427                 priv->card_polling_interval = HZ / 3;
 428         }
 429         else if (priv->waiting_command_mask & ARLAN_COMMAND_NOOP)
 430         {
 431                 WRITESHMB(arlan->commandByte, ARLAN_COM_NOP);
 432                 arlan_interrupt_lancpu(dev);
 433                 priv->waiting_command_mask &= ~ARLAN_COMMAND_NOOP;
 434                 priv->card_polling_interval = HZ / 3;
 435         }
 436         else if (priv->waiting_command_mask & ARLAN_COMMAND_SLOW_POLL)
 437         {
 438                 WRITESHMB(arlan->commandByte, ARLAN_COM_GOTO_SLOW_POLL);
 439                 arlan_interrupt_lancpu(dev);
 440                 priv->waiting_command_mask &= ~ARLAN_COMMAND_SLOW_POLL;
 441                 priv->card_polling_interval = HZ / 3;
 442         }
 443         else if (priv->waiting_command_mask & ARLAN_COMMAND_POWERDOWN)
 444         {
 445                 setPowerOff(dev);
 446                 if (arlan_debug & ARLAN_DEBUG_CARD_STATE)
 447                         printk(KERN_WARNING "%s: Arlan Going Standby\n", dev->name);
 448                 priv->waiting_command_mask &= ~ARLAN_COMMAND_POWERDOWN;
 449                 priv->card_polling_interval = 3 * HZ;
 450         }
 451         arlan_unlock_card_access(dev);
 452         for (i = 0; READSHMB(arlan->commandByte) && i < 20; i++)
 453                 udelay(10);
 454         if (READSHMB(arlan->commandByte))
 455                 if (arlan_debug & ARLAN_DEBUG_CARD_STATE)
 456                         printk(KERN_ERR "card busy leaving command %lx\n", priv->waiting_command_mask);
 457
 458         spin_unlock_irqrestore(&priv->lock, flags);
 459         ARLAN_DEBUG_EXIT("arlan_command");
 460         priv->last_command_buff_free_time = jiffies;
 461         return 0;
 462
 463 card_busy_end:
 464         if (time_after(jiffies, priv->last_command_buff_free_time + HZ))
 465                 priv->waiting_command_mask |= ARLAN_COMMAND_CLEAN_AND_RESET;
 466
 467         if (arlan_debug & ARLAN_DEBUG_CARD_STATE)
 468                 printk(KERN_ERR "%s arlan_command card busy end \n", dev->name);
 469         spin_unlock_irqrestore(&priv->lock, flags);
 470         ARLAN_DEBUG_EXIT("arlan_command");
 471         return 1;
 472
 473 bad_end:
 474         printk(KERN_ERR "%s arlan_command bad end \n", dev->name);
 475
 476         spin_unlock_irqrestore(&priv->lock, flags);
 477         ARLAN_DEBUG_EXIT("arlan_command");
 478
 479         return -1;
 480 }
 481
 482 static inline void arlan_command_process(struct net_device *dev)
 483 {
 484         struct arlan_private *priv = dev->priv;
 485
 486         int times = 0;
 487         while (priv->waiting_command_mask && times < 8)
 488         {
 489                 if (priv->waiting_command_mask)
 490                 {
 491                         if (arlan_command(dev, 0))
 492                                 break;
 493                         times++;
 494                 }
 495                 /* if long command, we won't repeat trying */ ;
 496                 if (priv->card_polling_interval > 1)
 497                         break;
 498                 times++;
 499         }
 500 }
 501
 502
 503 static inline void arlan_retransmit_now(struct net_device *dev)
 504 {
 505         struct arlan_private *priv = dev->priv;
 506
 507
 508         ARLAN_DEBUG_ENTRY("arlan_retransmit_now");
 509         if (TXLAST(dev).offset == 0)
 510         {
 511                 if (TXHEAD(dev).offset)
 512                 {
 513                         priv->txLast = 0;
 514                         IFDEBUG(ARLAN_DEBUG_TX_CHAIN) printk(KERN_DEBUG "TX buff switch to head \n");
 515
 516                 }
 517                 else if (TXTAIL(dev).offset)
 518                 {
 519                         IFDEBUG(ARLAN_DEBUG_TX_CHAIN) printk(KERN_DEBUG "TX buff switch to tail \n");
 520                         priv->txLast = 1;
 521                 }
 522                 else
 523                         IFDEBUG(ARLAN_DEBUG_TX_CHAIN) printk(KERN_ERR "ReTransmit buff empty");
 524                 netif_wake_queue (dev);
 525                 return;
 526
 527         }
 528         arlan_command(dev, ARLAN_COMMAND_TX);
 529
 530         priv->Conf->driverRetransmissions++;
 531         priv->retransmissions++;
 532
 533         IFDEBUG(ARLAN_DEBUG_TX_CHAIN) printk("Retransmit %d bytes \n", TXLAST(dev).length);
 534
 535         ARLAN_DEBUG_EXIT("arlan_retransmit_now");
 536 }
 537
 538
 539
 540 static void arlan_registration_timer(unsigned long data)
 541 {
 542         struct net_device *dev = (struct net_device *) data;
 543         struct arlan_private *priv = dev->priv;
 544         int bh_mark_needed = 0;
 545         int next_tick = 1;
 546         long lostTime = ((long)jiffies - (long)priv->registrationLastSeen)
 547                         * (1000/HZ);
 548
 549         if (registrationBad(dev))
 550         {
 551                 priv->registrationLostCount++;
 552                 if (lostTime > 7000 && lostTime < 7200)
 553                 {
 554                         printk(KERN_NOTICE "%s registration Lost \n", dev->name);
 555                 }
 556                 if (lostTime / priv->reRegisterExp > 2000)
 557                         arlan_command(dev, ARLAN_COMMAND_CLEAN_AND_CONF);
 558                 if (lostTime / (priv->reRegisterExp) > 3500)
 559                         arlan_command(dev, ARLAN_COMMAND_CLEAN_AND_RESET);
 560                 if (priv->reRegisterExp < 400)
 561                         priv->reRegisterExp += 2;
 562                 if (lostTime > 7200)
 563                 {
 564                         next_tick = HZ;
 565                         arlan_command(dev, ARLAN_COMMAND_CLEAN_AND_RESET);
 566                 }
 567         }
 568         else
 569         {
 570                 if (priv->Conf->registrationMode && lostTime > 10000 &&
 571                         priv->registrationLostCount)
 572                 {
 573                         printk(KERN_NOTICE "%s registration is back after %ld milliseconds\n",
 574                                dev->name, lostTime);
 575                 }
 576                 priv->registrationLastSeen = jiffies;
 577                 priv->registrationLostCount = 0;
 578                 priv->reRegisterExp = 1;
 579                 if (!netif_running(dev) )
 580                         netif_wake_queue(dev);
 581                 if (time_after(priv->tx_last_sent,priv->tx_last_cleared) &&
 582                     time_after(jiffies, priv->tx_last_sent * 5*HZ) ){
 583                         arlan_command(dev, ARLAN_COMMAND_CLEAN_AND_RESET);
 584                         priv->tx_last_cleared = jiffies;
 585                 }
 586         }
 587
 588
 589         if (!registrationBad(dev) && priv->ReTransmitRequested)
 590         {
 591                 IFDEBUG(ARLAN_DEBUG_TX_CHAIN)
 592                         printk(KERN_ERR "Retransmit from timer \n");
 593                 priv->ReTransmitRequested = 0;
 594                 arlan_retransmit_now(dev);
 595         }
 596         if (!registrationBad(dev) &&
 597                 time_after(jiffies, priv->tx_done_delayed) &&
 598                 priv->tx_done_delayed != 0)
 599         {
 600                 TXLAST(dev).offset = 0;
 601                 if (priv->txLast)
 602                         priv->txLast = 0;
 603                 else if (TXTAIL(dev).offset)
 604                         priv->txLast = 1;
 605                 if (TXLAST(dev).offset)
 606                 {
 607                         arlan_retransmit_now(dev);
 608                         dev->trans_start = jiffies;
 609                 }
 610                 if (!(TXHEAD(dev).offset && TXTAIL(dev).offset))
 611                 {
 612                         netif_wake_queue (dev);
 613                 }
 614                 priv->tx_done_delayed = 0;
 615                 bh_mark_needed = 1;
 616         }
 617         if (bh_mark_needed)
 618         {
 619                 netif_wake_queue (dev);
 620         }
 621         arlan_process_interrupt(dev);
 622
 623         if (next_tick < priv->card_polling_interval)
 624                 next_tick = priv->card_polling_interval;
 625
 626         priv->timer.expires = jiffies + next_tick;
 627
 628         add_timer(&priv->timer);
 629 }
 630
 631
 632 #ifdef ARLAN_DEBUGGING
 633
 634 static void arlan_print_registers(struct net_device *dev, int line)
 635 {
 636         struct arlan_private *priv = dev->priv;
 637         volatile struct arlan_shmem *arlan = priv->card;
 638
 639         u_char hostcpuLock, lancpuLock, controlRegister, cntrlRegImage,
 640                 txStatus, rxStatus, interruptInProgress, commandByte;
 641
 642
 643         ARLAN_DEBUG_ENTRY("arlan_print_registers");
 644         READSHM(interruptInProgress, arlan->interruptInProgress, u_char);
 645         READSHM(hostcpuLock, arlan->hostcpuLock, u_char);
 646         READSHM(lancpuLock, arlan->lancpuLock, u_char);
 647         READSHM(controlRegister, arlan->controlRegister, u_char);
 648         READSHM(cntrlRegImage, arlan->cntrlRegImage, u_char);
 649         READSHM(txStatus, arlan->txStatus, u_char);
 650         READSHM(rxStatus, arlan->rxStatus, u_char);
 651         READSHM(commandByte, arlan->commandByte, u_char);
 652
 653         printk(KERN_WARNING "line %04d IP %02x HL %02x LL %02x CB %02x CR %02x CRI %02x TX %02x RX %02x\n",
 654                 line, interruptInProgress, hostcpuLock, lancpuLock, commandByte,
 655                 controlRegister, cntrlRegImage, txStatus, rxStatus);
 656
 657         ARLAN_DEBUG_EXIT("arlan_print_registers");
 658 }
 659 #endif
 660
 661
 662 static int arlan_hw_tx(struct net_device *dev, char *buf, int length)
 663 {
 664         int i;
 665
 666         struct arlan_private *priv = dev->priv;
 667         volatile struct arlan_shmem *arlan = priv->card;
 668         struct arlan_conf_stru *conf = priv->Conf;
 669
 670         int tailStarts = 0x800;
 671         int headEnds = 0x0;
 672
 673
 674         ARLAN_DEBUG_ENTRY("arlan_hw_tx");
 675         if (TXHEAD(dev).offset)
 676                 headEnds = (((TXHEAD(dev).offset + TXHEAD(dev).length - (((int) arlan->txBuffer) - ((int) arlan))) / 64) + 1) * 64;
 677         if (TXTAIL(dev).offset)
 678                 tailStarts = 0x800 - (((TXTAIL(dev).offset - (((int) arlan->txBuffer) - ((int) arlan))) / 64) + 2) * 64;
 679
 680
 681         if (!TXHEAD(dev).offset && length < tailStarts)
 682         {
 683                 IFDEBUG(ARLAN_DEBUG_TX_CHAIN)
 684                         printk(KERN_ERR "TXHEAD insert, tailStart %d\n", tailStarts);
 685
 686                 TXHEAD(dev).offset =
 687                         (((int) arlan->txBuffer) - ((int) arlan));
 688                 TXHEAD(dev).length = length - ARLAN_FAKE_HDR_LEN;
 689                 for (i = 0; i < 6; i++)
 690                         TXHEAD(dev).dest[i] = buf[i];
 691                 TXHEAD(dev).clear = conf->txClear;
 692                 TXHEAD(dev).retries = conf->txRetries;  /* 0 is use default */
 693                 TXHEAD(dev).routing = conf->txRouting;
 694                 TXHEAD(dev).scrambled = conf->txScrambled;
 695                 memcpy_toio(((char *) arlan + TXHEAD(dev).offset), buf + ARLAN_FAKE_HDR_LEN, TXHEAD(dev).length);
 696         }
 697         else if (!TXTAIL(dev).offset && length < (0x800 - headEnds))
 698         {
 699                 IFDEBUG(ARLAN_DEBUG_TX_CHAIN)
 700                         printk(KERN_ERR "TXTAIL insert, headEnd %d\n", headEnds);
 701
 702                 TXTAIL(dev).offset =
 703                         (((int) arlan->txBuffer) - ((int) arlan)) + 0x800 - (length / 64 + 2) * 64;
 704                 TXTAIL(dev).length = length - ARLAN_FAKE_HDR_LEN;
 705                 for (i = 0; i < 6; i++)
 706                         TXTAIL(dev).dest[i] = buf[i];
 707                 TXTAIL(dev).clear = conf->txClear;
 708                 TXTAIL(dev).retries = conf->txRetries;
 709                 TXTAIL(dev).routing = conf->txRouting;
 710                 TXTAIL(dev).scrambled = conf->txScrambled;
 711                 memcpy_toio(((char *) arlan + TXTAIL(dev).offset), buf + ARLAN_FAKE_HDR_LEN, TXTAIL(dev).length);
 712         }
 713         else
 714         {
 715                 netif_stop_queue (dev);
 716                 IFDEBUG(ARLAN_DEBUG_TX_CHAIN)
 717                         printk(KERN_ERR "TX TAIL & HEAD full, return, tailStart %d headEnd %d\n", tailStarts, headEnds);
 718                 return -1;
 719         }
 720         priv->out_bytes += length;
 721         priv->out_bytes10 += length;
 722         if (conf->measure_rate < 1)
 723                 conf->measure_rate = 1;
 724         if (time_after(jiffies, priv->out_time + conf->measure_rate * HZ))
 725         {
 726                 conf->out_speed = priv->out_bytes / conf->measure_rate;
 727                 priv->out_bytes = 0;
 728                 priv->out_time = jiffies;
 729         }
 730         if (time_after(jiffies, priv->out_time10 + conf->measure_rate * 10*HZ))
 731         {
 732                 conf->out_speed10 = priv->out_bytes10 / (10 * conf->measure_rate);
 733                 priv->out_bytes10 = 0;
 734                 priv->out_time10 = jiffies;
 735         }
 736         if (TXHEAD(dev).offset && TXTAIL(dev).offset)
 737         {
 738                 netif_stop_queue (dev);
 739                 return 0;
 740         }
 741         else
 742                 netif_start_queue (dev);
 743
 744
 745         IFDEBUG(ARLAN_DEBUG_HEADER_DUMP)
 746                 printk(KERN_WARNING "%s Transmit t %2x:%2x:%2x:%2x:%2x:%2x f %2x:%2x:%2x:%2x:%2x:%2x \n", dev->name,
 747                    (unsigned char) buf[0], (unsigned char) buf[1], (unsigned char) buf[2], (unsigned char) buf[3],
 748                    (unsigned char) buf[4], (unsigned char) buf[5], (unsigned char) buf[6], (unsigned char) buf[7],
 749                    (unsigned char) buf[8], (unsigned char) buf[9], (unsigned char) buf[10], (unsigned char) buf[11]);
 750
 751         IFDEBUG(ARLAN_DEBUG_TX_CHAIN) printk(KERN_ERR "TX command prepare for buffer %d\n", priv->txLast);
 752
 753         arlan_command(dev, ARLAN_COMMAND_TX);
 754
 755         priv->tx_last_sent = jiffies;
 756
 757         IFDEBUG(ARLAN_DEBUG_TX_CHAIN) printk("%s TX Qued %d bytes \n", dev->name, length);
 758
 759         ARLAN_DEBUG_EXIT("arlan_hw_tx");
 760
 761         return 0;
 762 }
 763
 764
 765 static int arlan_hw_config(struct net_device *dev)
 766 {
 767         struct arlan_private *priv = dev->priv;
 768         volatile struct arlan_shmem *arlan = priv->card;
 769         struct arlan_conf_stru *conf = priv->Conf;
 770
 771         ARLAN_DEBUG_ENTRY("arlan_hw_config");
 772
 773         printk(KERN_NOTICE "%s arlan configure called \n", dev->name);
 774         if (arlan_EEPROM_bad)
 775                 printk(KERN_NOTICE "arlan configure with eeprom bad option \n");
 776
 777
 778         WRITESHM(arlan->spreadingCode, conf->spreadingCode, u_char);
 779         WRITESHM(arlan->channelSet, conf->channelSet, u_char);
 780
 781         if (arlan_EEPROM_bad)
 782                 WRITESHM(arlan->defaultChannelSet, conf->channelSet, u_char);
 783
 784         WRITESHM(arlan->channelNumber, conf->channelNumber, u_char);
 785
 786         WRITESHM(arlan->scramblingDisable, conf->scramblingDisable, u_char);
 787         WRITESHM(arlan->txAttenuation, conf->txAttenuation, u_char);
 788
 789         WRITESHM(arlan->systemId, conf->systemId, u_int);
 790
 791         WRITESHM(arlan->maxRetries, conf->maxRetries, u_char);
 792         WRITESHM(arlan->receiveMode, conf->receiveMode, u_char);
 793         WRITESHM(arlan->priority, conf->priority, u_char);
 794         WRITESHM(arlan->rootOrRepeater, conf->rootOrRepeater, u_char);
 795         WRITESHM(arlan->SID, conf->SID, u_int);
 796
 797         WRITESHM(arlan->registrationMode, conf->registrationMode, u_char);
 798
 799         WRITESHM(arlan->registrationFill, conf->registrationFill, u_char);
 800         WRITESHM(arlan->localTalkAddress, conf->localTalkAddress, u_char);
 801         WRITESHM(arlan->codeFormat, conf->codeFormat, u_char);
 802         WRITESHM(arlan->numChannels, conf->numChannels, u_char);
 803         WRITESHM(arlan->channel1, conf->channel1, u_char);
 804         WRITESHM(arlan->channel2, conf->channel2, u_char);
 805         WRITESHM(arlan->channel3, conf->channel3, u_char);
 806         WRITESHM(arlan->channel4, conf->channel4, u_char);
 807         WRITESHM(arlan->radioNodeId, conf->radioNodeId, u_short);
 808         WRITESHM(arlan->SID, conf->SID, u_int);
 809         WRITESHM(arlan->waitTime, conf->waitTime, u_short);
 810         WRITESHM(arlan->lParameter, conf->lParameter, u_short);
 811         memcpy_toio(&(arlan->_15), &(conf->_15), 3);
 812         WRITESHM(arlan->_15, conf->_15, u_short);
 813         WRITESHM(arlan->headerSize, conf->headerSize, u_short);
 814         if (arlan_EEPROM_bad)
 815                 WRITESHM(arlan->hardwareType, conf->hardwareType, u_char);
 816         WRITESHM(arlan->radioType, conf->radioType, u_char);
 817         if (arlan_EEPROM_bad)
 818                 WRITESHM(arlan->radioModule, conf->radioType, u_char);
 819
 820         memcpy_toio(arlan->encryptionKey + keyStart, encryptionKey, 8);
 821         memcpy_toio(arlan->name, conf->siteName, 16);
 822
 823         WRITESHMB(arlan->commandByte, ARLAN_COM_INT | ARLAN_COM_CONF);  /* do configure */
 824         memset_io(arlan->commandParameter, 0, 0xf);     /* 0xf */
 825         memset_io(arlan->commandParameter + 1, 0, 2);
 826         if (conf->writeEEPROM)
 827         {
 828                   memset_io(arlan->commandParameter, conf->writeEEPROM, 1);
 829 //              conf->writeEEPROM=0;
 830         }
 831         if (conf->registrationMode && conf->registrationInterrupts)
 832                 memset_io(arlan->commandParameter + 3, 1, 1);
 833         else
 834                 memset_io(arlan->commandParameter + 3, 0, 1);
 835
 836         priv->irq_test_done = 0;
 837
 838         if (conf->tx_queue_len)
 839                 dev->tx_queue_len = conf->tx_queue_len;
 840         udelay(100);
 841
 842         ARLAN_DEBUG_EXIT("arlan_hw_config");
 843         return 0;
 844 }
 845
 846
 847 static int arlan_read_card_configuration(struct net_device *dev)
 848 {
 849         u_char tlx415;
 850         struct arlan_private *priv = dev->priv;
 851         volatile struct arlan_shmem *arlan = priv->card;
 852         struct arlan_conf_stru *conf = priv->Conf;
 853
 854         ARLAN_DEBUG_ENTRY("arlan_read_card_configuration");
 855
 856         if (radioNodeId == radioNodeIdUNKNOWN)
 857         {
 858                 READSHM(conf->radioNodeId, arlan->radioNodeId, u_short);
 859         }
 860         else
 861                 conf->radioNodeId = radioNodeId;
 862
 863         if (SID == SIDUNKNOWN)
 864         {
 865                 READSHM(conf->SID, arlan->SID, u_int);
 866         }
 867         else conf->SID = SID;
 868
 869         if (spreadingCode == spreadingCodeUNKNOWN)
 870         {
 871                   READSHM(conf->spreadingCode, arlan->spreadingCode, u_char);
 872         }
 873         else
 874                 conf->spreadingCode = spreadingCode;
 875
 876         if (channelSet == channelSetUNKNOWN)
 877         {
 878                 READSHM(conf->channelSet, arlan->channelSet, u_char);
 879         }
 880         else conf->channelSet = channelSet;
 881
 882         if (channelNumber == channelNumberUNKNOWN)
 883         {
 884                 READSHM(conf->channelNumber, arlan->channelNumber, u_char);
 885         }
 886         else conf->channelNumber = channelNumber;
 887
 888         READSHM(conf->scramblingDisable, arlan->scramblingDisable, u_char);
 889         READSHM(conf->txAttenuation, arlan->txAttenuation, u_char);
 890
 891         if (systemId == systemIdUNKNOWN)
 892         {
 893                 READSHM(conf->systemId, arlan->systemId, u_int);
 894         }
 895         else conf->systemId = systemId;
 896
 897         READSHM(conf->maxDatagramSize, arlan->maxDatagramSize, u_short);
 898         READSHM(conf->maxFrameSize, arlan->maxFrameSize, u_short);
 899         READSHM(conf->maxRetries, arlan->maxRetries, u_char);
 900         READSHM(conf->receiveMode, arlan->receiveMode, u_char);
 901         READSHM(conf->priority, arlan->priority, u_char);
 902         READSHM(conf->rootOrRepeater, arlan->rootOrRepeater, u_char);
 903
 904         if (SID == SIDUNKNOWN)
 905         {
 906                   READSHM(conf->SID, arlan->SID, u_int);
 907         }
 908         else conf->SID = SID;
 909
 910         if (registrationMode == registrationModeUNKNOWN)
 911         {
 912                   READSHM(conf->registrationMode, arlan->registrationMode, u_char);
 913         }
 914         else conf->registrationMode = registrationMode;
 915
 916         READSHM(conf->registrationFill, arlan->registrationFill, u_char);
 917         READSHM(conf->localTalkAddress, arlan->localTalkAddress, u_char);
 918         READSHM(conf->codeFormat, arlan->codeFormat, u_char);
 919         READSHM(conf->numChannels, arlan->numChannels, u_char);
 920         READSHM(conf->channel1, arlan->channel1, u_char);
 921         READSHM(conf->channel2, arlan->channel2, u_char);
 922         READSHM(conf->channel3, arlan->channel3, u_char);
 923         READSHM(conf->channel4, arlan->channel4, u_char);
 924         READSHM(conf->waitTime, arlan->waitTime, u_short);
 925         READSHM(conf->lParameter, arlan->lParameter, u_short);
 926         READSHM(conf->_15, arlan->_15, u_short);
 927         READSHM(conf->headerSize, arlan->headerSize, u_short);
 928         READSHM(conf->hardwareType, arlan->hardwareType, u_char);
 929         READSHM(conf->radioType, arlan->radioModule, u_char);
 930
 931         if (conf->radioType == 0)
 932                 conf->radioType = 0xc;
 933
 934         WRITESHM(arlan->configStatus, 0xA5, u_char);
 935         READSHM(tlx415, arlan->configStatus, u_char);
 936
 937         if (tlx415 != 0xA5)
 938                 printk(KERN_INFO "%s tlx415 chip \n", dev->name);
 939
 940         conf->txClear = 0;
 941         conf->txRetries = 1;
 942         conf->txRouting = 1;
 943         conf->txScrambled = 0;
 944         conf->rxParameter = 1;
 945         conf->txTimeoutMs = 4000;
 946         conf->waitCardTimeout = 100000;
 947         conf->receiveMode = ARLAN_RCV_CLEAN;
 948         memcpy_fromio(conf->siteName, arlan->name, 16);
 949         conf->siteName[16] = '\0';
 950         conf->retries = retries;
 951         conf->tx_delay_ms = tx_delay_ms;
 952         conf->ReTransmitPacketMaxSize = 200;
 953         conf->waitReTransmitPacketMaxSize = 200;
 954         conf->txAckTimeoutMs = 900;
 955         conf->fastReTransCount = 3;
 956
 957         ARLAN_DEBUG_EXIT("arlan_read_card_configuration");
 958
 959         return 0;
 960 }
 961
 962
 963 static int lastFoundAt = 0xbe000;
 964
 965
 966 /*
 967  * This is the real probe routine. Linux has a history of friendly device
 968  * probes on the ISA bus. A good device probes avoids doing writes, and
 969  * verifies that the correct device exists and functions.
 970  */
 971 #define ARLAN_SHMEM_SIZE        0x2000
 972 static int __init arlan_check_fingerprint(unsigned long memaddr)
 973 {
 974         static const char probeText[] = "TELESYSTEM SLW INC.    ARLAN \0";
 975         volatile struct arlan_shmem *arlan = (struct arlan_shmem *) memaddr;
 976         unsigned long paddr = virt_to_phys((void *) memaddr);
 977         char tempBuf[49];
 978
 979         ARLAN_DEBUG_ENTRY("arlan_check_fingerprint");
 980
 981         if (!request_mem_region(paddr, ARLAN_SHMEM_SIZE, "arlan")) {
 982                 // printk(KERN_WARNING "arlan: memory region %lx excluded from probing \n",paddr);
 983                 return -ENODEV;
 984         }
 985
 986         memcpy_fromio(tempBuf, arlan->textRegion, 29);
 987         tempBuf[30] = 0;
 988
 989         /* check for card at this address */
 990         if (0 != strncmp(tempBuf, probeText, 29)){
 991                 release_mem_region(paddr, ARLAN_SHMEM_SIZE);
 992                 return -ENODEV;
 993         }
 994
 995 //   printk(KERN_INFO "arlan found at 0x%x \n",memaddr);
 996         ARLAN_DEBUG_EXIT("arlan_check_fingerprint");
 997
 998         return 0;
 999 }
1000
1001 static int arlan_change_mtu(struct net_device *dev, int new_mtu)
1002 {
1003         struct arlan_private *priv = dev->priv;
1004         struct arlan_conf_stru *conf = priv->Conf;
1005
1006         ARLAN_DEBUG_ENTRY("arlan_change_mtu");
1007         if (new_mtu > 2032)
1008                 return -EINVAL;
1009         dev->mtu = new_mtu;
1010         if (new_mtu < 256)
1011                 new_mtu = 256;  /* cards book suggests 1600 */
1012         conf->maxDatagramSize = new_mtu;
1013         conf->maxFrameSize = new_mtu + 48;
1014
1015         arlan_command(dev, ARLAN_COMMAND_CLEAN_AND_CONF);
1016         printk(KERN_NOTICE "%s mtu changed to %d \n", dev->name, new_mtu);
1017
1018         ARLAN_DEBUG_EXIT("arlan_change_mtu");
1019
1020         return 0;
1021 }
1022
1023 static int arlan_mac_addr(struct net_device *dev, void *p)
1024 {
1025         struct sockaddr *addr = p;
1026
1027
1028         ARLAN_DEBUG_ENTRY("arlan_mac_addr");
1029         return -EINVAL;
1030
1031         if (!netif_running(dev))
1032                 return -EBUSY;
1033         memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
1034
1035         ARLAN_DEBUG_EXIT("arlan_mac_addr");
1036         return 0;
1037 }
1038
1039
1040
1041 static int __init arlan_setup_device(struct net_device *dev, int num)
1042 {
1043         struct arlan_private *ap = dev->priv;
1044         int err;
1045
1046         ARLAN_DEBUG_ENTRY("arlan_setup_device");
1047
1048         ap->conf = (struct arlan_shmem *)(ap+1);
1049
1050         dev->tx_queue_len = tx_queue_len;
1051         dev->open = arlan_open;
1052         dev->stop = arlan_close;
1053         dev->hard_start_xmit = arlan_tx;
1054         dev->get_stats = arlan_statistics;
1055         dev->set_multicast_list = arlan_set_multicast;
1056         dev->change_mtu = arlan_change_mtu;
1057         dev->set_mac_address = arlan_mac_addr;
1058         dev->tx_timeout = arlan_tx_timeout;
1059         dev->watchdog_timeo = 3*HZ;
1060
1061         ap->irq_test_done = 0;
1062         ap->Conf = &arlan_conf[num];
1063
1064         ap->Conf->pre_Command_Wait = 40;
1065         ap->Conf->rx_tweak1 = 30;
1066         ap->Conf->rx_tweak2 = 0;
1067
1068
1069         err = register_netdev(dev);
1070         if (err) {
1071                 release_mem_region(virt_to_phys((void *) dev->mem_start),
1072                            ARLAN_SHMEM_SIZE);
1073                 free_netdev(dev);
1074                 return err;
1075         }
1076         arlan_device[num] = dev;
1077         ARLAN_DEBUG_EXIT("arlan_setup_device");
1078         return 0;
1079 }
1080
1081 static int __init arlan_probe_here(struct net_device *dev,
1082                                    unsigned long memaddr)
1083 {
1084         struct arlan_private *ap = dev->priv;
1085
1086         ARLAN_DEBUG_ENTRY("arlan_probe_here");
1087
1088         if (arlan_check_fingerprint(memaddr))
1089                 return -ENODEV;
1090
1091         printk(KERN_NOTICE "%s: Arlan found at %x, \n ", dev->name,
1092                (int) virt_to_phys((void*)memaddr));
1093
1094         ap->card = (void *) memaddr;
1095         dev->mem_start = memaddr;
1096         dev->mem_end = memaddr + ARLAN_SHMEM_SIZE-1;
1097
1098         if (dev->irq < 2)
1099         {
1100                 READSHM(dev->irq, ap->card->irqLevel, u_char);
1101         } else if (dev->irq == 2)
1102                 dev->irq = 9;
1103
1104         arlan_read_card_configuration(dev);
1105
1106         ARLAN_DEBUG_EXIT("arlan_probe_here");
1107         return 0;
1108 }
1109
1110
1111 static int arlan_open(struct net_device *dev)
1112 {
1113         struct arlan_private *priv = dev->priv;
1114         volatile struct arlan_shmem *arlan = priv->card;
1115         int ret = 0;
1116
1117         ARLAN_DEBUG_ENTRY("arlan_open");
1118
1119         ret = request_irq(dev->irq, &arlan_interrupt, 0, dev->name, dev);
1120         if (ret)
1121         {
1122                 printk(KERN_ERR "%s: unable to get IRQ %d .\n",
1123                         dev->name, dev->irq);
1124                 return ret;
1125         }
1126
1127
1128         priv->bad = 0;
1129         priv->lastReset = 0;
1130         priv->reset = 0;
1131         memcpy_fromio(dev->dev_addr, arlan->lanCardNodeId, 6);
1132         memset(dev->broadcast, 0xff, 6);
1133         dev->tx_queue_len = tx_queue_len;
1134         priv->interrupt_processing_active = 0;
1135         spin_lock_init(&priv->lock);
1136
1137         netif_start_queue (dev);
1138
1139         priv->registrationLostCount = 0;
1140         priv->registrationLastSeen = jiffies;
1141         priv->txLast = 0;
1142         priv->tx_command_given = 0;
1143         priv->rx_command_given = 0;
1144
1145         priv->reRegisterExp = 1;
1146         priv->tx_last_sent = jiffies - 1;
1147         priv->tx_last_cleared = jiffies;
1148         priv->Conf->writeEEPROM = 0;
1149         priv->Conf->registrationInterrupts = 1;
1150
1151         init_timer(&priv->timer);
1152         priv->timer.expires = jiffies + HZ / 10;
1153         priv->timer.data = (unsigned long) dev;
1154         priv->timer.function = &arlan_registration_timer;       /* timer handler */
1155
1156         arlan_command(dev, ARLAN_COMMAND_POWERUP | ARLAN_COMMAND_LONG_WAIT_NOW);
1157         mdelay(200);
1158         add_timer(&priv->timer);
1159
1160         ARLAN_DEBUG_EXIT("arlan_open");
1161         return 0;
1162 }
1163
1164
1165 static void arlan_tx_timeout (struct net_device *dev)
1166 {
1167         printk(KERN_ERR "%s: arlan transmit timed out, kernel decided\n", dev->name);
1168         /* Try to restart the adaptor. */
1169         arlan_command(dev, ARLAN_COMMAND_CLEAN_AND_RESET);
1170         // dev->trans_start = jiffies;
1171         // netif_start_queue (dev);
1172 }
1173
1174
1175 static int arlan_tx(struct sk_buff *skb, struct net_device *dev)
1176 {
1177         short length;
1178         unsigned char *buf;
1179
1180         ARLAN_DEBUG_ENTRY("arlan_tx");
1181
1182         length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
1183         buf = skb->data;
1184
1185         if (length + 0x12 > 0x800) {
1186                 printk(KERN_ERR "TX RING overflow \n");
1187                 netif_stop_queue (dev);
1188         }
1189
1190         if (arlan_hw_tx(dev, buf, length) == -1)
1191                 goto bad_end;
1192
1193         dev->trans_start = jiffies;
1194
1195         dev_kfree_skb(skb);
1196
1197         arlan_process_interrupt(dev);
1198         ARLAN_DEBUG_EXIT("arlan_tx");
1199         return 0;
1200
1201 bad_end:
1202         arlan_process_interrupt(dev);
1203         netif_stop_queue (dev);
1204         ARLAN_DEBUG_EXIT("arlan_tx");
1205         return 1;
1206 }
1207
1208
1209 static inline int DoNotReTransmitCrap(struct net_device *dev)
1210 {
1211         struct arlan_private *priv = dev->priv;
1212
1213         if (TXLAST(dev).length < priv->Conf->ReTransmitPacketMaxSize)
1214                 return 1;
1215         return 0;
1216
1217 }
1218
1219 static inline int DoNotWaitReTransmitCrap(struct net_device *dev)
1220 {
1221         struct arlan_private *priv = dev->priv;
1222
1223         if (TXLAST(dev).length < priv->Conf->waitReTransmitPacketMaxSize)
1224                 return 1;
1225         return 0;
1226 }
1227
1228 static inline void arlan_queue_retransmit(struct net_device *dev)
1229 {
1230         struct arlan_private *priv = dev->priv;
1231
1232         ARLAN_DEBUG_ENTRY("arlan_queue_retransmit");
1233
1234         if (DoNotWaitReTransmitCrap(dev))
1235         {
1236                   arlan_drop_tx(dev);
1237         } else
1238                 priv->ReTransmitRequested++;
1239
1240         ARLAN_DEBUG_EXIT("arlan_queue_retransmit");
1241 }
1242
1243 static inline void RetryOrFail(struct net_device *dev)
1244 {
1245         struct arlan_private *priv = dev->priv;
1246
1247         ARLAN_DEBUG_ENTRY("RetryOrFail");
1248
1249         if (priv->retransmissions > priv->Conf->retries ||
1250             DoNotReTransmitCrap(dev))
1251         {
1252                 arlan_drop_tx(dev);
1253         }
1254         else if (priv->bad <= priv->Conf->fastReTransCount)
1255         {
1256                 arlan_retransmit_now(dev);
1257         }
1258         else arlan_queue_retransmit(dev);
1259
1260         ARLAN_DEBUG_EXIT("RetryOrFail");
1261 }
1262
1263
1264 static void arlan_tx_done_interrupt(struct net_device *dev, int status)
1265 {
1266         struct arlan_private *priv = dev->priv;
1267
1268         ARLAN_DEBUG_ENTRY("arlan_tx_done_interrupt");
1269
1270         priv->tx_last_cleared = jiffies;
1271         priv->tx_command_given = 0;
1272         switch (status)
1273         {
1274                 case 1:
1275                 {
1276                         IFDEBUG(ARLAN_DEBUG_TX_CHAIN)
1277                                 printk("arlan intr: transmit OK\n");
1278                         priv->stats.tx_packets++;
1279                         priv->bad = 0;
1280                         priv->reset = 0;
1281                         priv->retransmissions = 0;
1282                         if (priv->Conf->tx_delay_ms)
1283                         {
1284                                 priv->tx_done_delayed = jiffies + (priv->Conf->tx_delay_ms * HZ) / 1000 + 1;
1285                         }
1286                         else
1287                         {
1288                                 TXLAST(dev).offset = 0;
1289                                 if (priv->txLast)
1290                                         priv->txLast = 0;
1291                                 else if (TXTAIL(dev).offset)
1292                                         priv->txLast = 1;
1293                                 if (TXLAST(dev).offset)
1294                                 {
1295                                         arlan_retransmit_now(dev);
1296                                         dev->trans_start = jiffies;
1297                                 }
1298                                 if (!TXHEAD(dev).offset || !TXTAIL(dev).offset)
1299                                 {
1300                                         netif_wake_queue (dev);
1301                                 }
1302                         }
1303                 }
1304                 break;
1305
1306                 case 2:
1307                 {
1308                         IFDEBUG(ARLAN_DEBUG_TX_CHAIN)
1309                                 printk("arlan intr: transmit timed out\n");
1310                         priv->bad += 1;
1311                         //arlan_queue_retransmit(dev);
1312                         RetryOrFail(dev);
1313                 }
1314                 break;
1315
1316                 case 3:
1317                 {
1318                         IFDEBUG(ARLAN_DEBUG_TX_CHAIN)
1319                                 printk("arlan intr: transmit max retries\n");
1320                         priv->bad += 1;
1321                         priv->reset = 0;
1322                         //arlan_queue_retransmit(dev);
1323                         RetryOrFail(dev);
1324                 }
1325                 break;
1326
1327                 case 4:
1328                 {
1329                         IFDEBUG(ARLAN_DEBUG_TX_CHAIN)
1330                                 printk("arlan intr: transmit aborted\n");
1331                         priv->bad += 1;
1332                         arlan_queue_retransmit(dev);
1333                         //RetryOrFail(dev);
1334                 }
1335                 break;
1336
1337                 case 5:
1338                 {
1339                         IFDEBUG(ARLAN_DEBUG_TX_CHAIN)
1340                                 printk("arlan intr: transmit not registered\n");
1341                         priv->bad += 1;
1342                         //debug=101;
1343                         arlan_queue_retransmit(dev);
1344                 }
1345                 break;
1346
1347                 case 6:
1348                 {
1349                         IFDEBUG(ARLAN_DEBUG_TX_CHAIN)
1350                                 printk("arlan intr: transmit destination full\n");
1351                         priv->bad += 1;
1352                         priv->reset = 0;
1353                         //arlan_drop_tx(dev);
1354                         arlan_queue_retransmit(dev);
1355                 }
1356                 break;
1357
1358                 case 7:
1359                 {
1360                         IFDEBUG(ARLAN_DEBUG_TX_CHAIN)
1361                                 printk("arlan intr: transmit unknown ack\n");
1362                         priv->bad += 1;
1363                         priv->reset = 0;
1364                         arlan_queue_retransmit(dev);
1365                 }
1366                 break;
1367
1368                 case 8:
1369                 {
1370                         IFDEBUG(ARLAN_DEBUG_TX_CHAIN)
1371                                 printk("arlan intr: transmit dest mail box full\n");
1372                         priv->bad += 1;
1373                         priv->reset = 0;
1374                         //arlan_drop_tx(dev);
1375                         arlan_queue_retransmit(dev);
1376                 }
1377                 break;
1378
1379                 case 9:
1380                 {
1381                         IFDEBUG(ARLAN_DEBUG_TX_CHAIN)
1382                                 printk("arlan intr: transmit root dest not reg.\n");
1383                         priv->bad += 1;
1384                         priv->reset = 1;
1385                         //arlan_drop_tx(dev);
1386                         arlan_queue_retransmit(dev);
1387                 }
1388                 break;
1389
1390                 default:
1391                 {
1392                         printk(KERN_ERR "arlan intr: transmit status unknown\n");
1393                         priv->bad += 1;
1394                         priv->reset = 1;
1395                         arlan_drop_tx(dev);
1396                 }
1397         }
1398
1399         ARLAN_DEBUG_EXIT("arlan_tx_done_interrupt");
1400 }
1401
1402
1403 static void arlan_rx_interrupt(struct net_device *dev, u_char rxStatus, u_short rxOffset, u_short pkt_len)
1404 {
1405         char *skbtmp;
1406         int i = 0;
1407
1408         struct arlan_private *priv = dev->priv;
1409         volatile struct arlan_shmem *arlan = priv->card;
1410         struct arlan_conf_stru *conf = priv->Conf;
1411
1412
1413         ARLAN_DEBUG_ENTRY("arlan_rx_interrupt");
1414         // by spec,   not                WRITESHMB(arlan->rxStatus,0x00);
1415         // prohibited here              arlan_command(dev, ARLAN_COMMAND_RX);
1416
1417         if (pkt_len < 10 || pkt_len > 2048)
1418         {
1419                 printk(KERN_WARNING "%s: got too short or long packet, len %d \n", dev->name, pkt_len);
1420                 return;
1421         }
1422         if (rxOffset + pkt_len > 0x2000)
1423         {
1424                 printk("%s: got too long packet, len %d offset %x\n", dev->name, pkt_len, rxOffset);
1425                 return;
1426         }
1427         priv->in_bytes += pkt_len;
1428         priv->in_bytes10 += pkt_len;
1429         if (conf->measure_rate < 1)
1430                 conf->measure_rate = 1;
1431         if (time_after(jiffies, priv->in_time + conf->measure_rate * HZ))
1432         {
1433                 conf->in_speed = priv->in_bytes / conf->measure_rate;
1434                 priv->in_bytes = 0;
1435                 priv->in_time = jiffies;
1436         }
1437         if (time_after(jiffies, priv->in_time10 + conf->measure_rate * 10*HZ))
1438         {
1439                 conf->in_speed10 = priv->in_bytes10 / (10 * conf->measure_rate);
1440                 priv->in_bytes10 = 0;
1441                 priv->in_time10 = jiffies;
1442         }
1443         DEBUGSHM(1, "arlan rcv pkt rxStatus= %d ", arlan->rxStatus, u_char);
1444         switch (rxStatus)
1445         {
1446                 case 1:
1447                 case 2:
1448                 case 3:
1449                 {
1450                         /* Malloc up new buffer. */
1451                         struct sk_buff *skb;
1452
1453                         DEBUGSHM(50, "arlan recv pkt offs=%d\n", arlan->rxOffset, u_short);
1454                         DEBUGSHM(1, "arlan rxFrmType = %d \n", arlan->rxFrmType, u_char);
1455                         DEBUGSHM(1, KERN_INFO "arlan rx scrambled = %d \n", arlan->scrambled, u_char);
1456
1457                         /* here we do multicast filtering to avoid slow 8-bit memcopy */
1458 #ifdef ARLAN_MULTICAST
1459                         if (!(dev->flags & IFF_ALLMULTI) &&
1460                                 !(dev->flags & IFF_PROMISC) &&
1461                                 dev->mc_list)
1462                         {
1463                                 char hw_dst_addr[6];
1464                                 struct dev_mc_list *dmi = dev->mc_list;
1465                                 int i;
1466
1467                                 memcpy_fromio(hw_dst_addr, arlan->ultimateDestAddress, 6);
1468                                 if (hw_dst_addr[0] == 0x01)
1469                                 {
1470                                         if (mdebug)
1471                                                 if (hw_dst_addr[1] == 0x00)
1472                                                         printk(KERN_ERR "%s mcast 0x0100 \n", dev->name);
1473                                                 else if (hw_dst_addr[1] == 0x40)
1474                                                         printk(KERN_ERR "%s m/bcast 0x0140 \n", dev->name);
1475                                         while (dmi)
1476                                         {                                                       if (dmi->dmi_addrlen == 6)
1477                                                 {
1478                                                         if (arlan_debug & ARLAN_DEBUG_HEADER_DUMP)
1479                                                                 printk(KERN_ERR "%s mcl %2x:%2x:%2x:%2x:%2x:%2x \n", dev->name,
1480                                                                                  dmi->dmi_addr[0], dmi->dmi_addr[1], dmi->dmi_addr[2],
1481                                                                                  dmi->dmi_addr[3], dmi->dmi_addr[4], dmi->dmi_addr[5]);
1482                                                         for (i = 0; i < 6; i++)
1483                                                                 if (dmi->dmi_addr[i] != hw_dst_addr[i])
1484                                                                         break;
1485                                                         if (i == 6)
1486                                                                 break;
1487                                                 }
1488                                                 else
1489                                                         printk(KERN_ERR "%s: invalid multicast address length given.\n", dev->name);
1490                                                 dmi = dmi->next;
1491                                         }
1492                                         /* we reach here if multicast filtering is on and packet
1493                                          * is multicast and not for receive */
1494                                         goto end_of_interrupt;
1495                                 }
1496                         }
1497 #endif                          // ARLAN_MULTICAST
1498                         /* multicast filtering ends here */
1499                         pkt_len += ARLAN_FAKE_HDR_LEN;
1500
1501                         skb = dev_alloc_skb(pkt_len + 4);
1502                         if (skb == NULL)
1503                         {
1504                                 printk(KERN_ERR "%s: Memory squeeze, dropping packet.\n", dev->name);
1505                                 priv->stats.rx_dropped++;
1506                                 break;
1507                         }
1508                         skb_reserve(skb, 2);
1509                         skb->dev = dev;
1510                         skbtmp = skb_put(skb, pkt_len);
1511
1512                         memcpy_fromio(skbtmp + ARLAN_FAKE_HDR_LEN, ((char *) arlan) + rxOffset, pkt_len - ARLAN_FAKE_HDR_LEN);
1513                         memcpy_fromio(skbtmp, arlan->ultimateDestAddress, 6);
1514                         memcpy_fromio(skbtmp + 6, arlan->rxSrc, 6);
1515                         WRITESHMB(arlan->rxStatus, 0x00);
1516                         arlan_command(dev, ARLAN_COMMAND_RX);
1517
1518                         IFDEBUG(ARLAN_DEBUG_HEADER_DUMP)
1519                         {
1520                                 char immedDestAddress[6];
1521                                 char immedSrcAddress[6];
1522                                 memcpy_fromio(immedDestAddress, arlan->immedDestAddress, 6);
1523                                 memcpy_fromio(immedSrcAddress, arlan->immedSrcAddress, 6);
1524
1525                                 printk(KERN_WARNING "%s t %2x:%2x:%2x:%2x:%2x:%2x f %2x:%2x:%2x:%2x:%2x:%2x imd %2x:%2x:%2x:%2x:%2x:%2x ims %2x:%2x:%2x:%2x:%2x:%2x\n", dev->name,
1526                                         (unsigned char) skbtmp[0], (unsigned char) skbtmp[1], (unsigned char) skbtmp[2], (unsigned char) skbtmp[3],
1527                                         (unsigned char) skbtmp[4], (unsigned char) skbtmp[5], (unsigned char) skbtmp[6], (unsigned char) skbtmp[7],
1528                                         (unsigned char) skbtmp[8], (unsigned char) skbtmp[9], (unsigned char) skbtmp[10], (unsigned char) skbtmp[11],
1529                                         immedDestAddress[0], immedDestAddress[1], immedDestAddress[2],
1530                                         immedDestAddress[3], immedDestAddress[4], immedDestAddress[5],
1531                                         immedSrcAddress[0], immedSrcAddress[1], immedSrcAddress[2],
1532                                         immedSrcAddress[3], immedSrcAddress[4], immedSrcAddress[5]);
1533                         }
1534                         skb->protocol = eth_type_trans(skb, dev);
1535                         IFDEBUG(ARLAN_DEBUG_HEADER_DUMP)
1536                                 if (skb->protocol != 0x608 && skb->protocol != 0x8)
1537                                 {
1538                                         for (i = 0; i <= 22; i++)
1539                                                 printk("%02x:", (u_char) skbtmp[i + 12]);
1540                                         printk(KERN_ERR "\n");
1541                                         printk(KERN_WARNING "arlan kernel pkt type trans %x \n", skb->protocol);
1542                                 }
1543                         netif_rx(skb);
1544                         dev->last_rx = jiffies;
1545                         priv->stats.rx_packets++;
1546                         priv->stats.rx_bytes += pkt_len;
1547                 }
1548                 break;
1549
1550                 default:
1551                         printk(KERN_ERR "arlan intr: received unknown status\n");
1552                         priv->stats.rx_crc_errors++;
1553                         break;
1554         }
1555         ARLAN_DEBUG_EXIT("arlan_rx_interrupt");
1556 }
1557
1558 static void arlan_process_interrupt(struct net_device *dev)
1559 {
1560         struct arlan_private *priv = dev->priv;
1561         volatile struct arlan_shmem *arlan = priv->card;
1562         u_char rxStatus = READSHMB(arlan->rxStatus);
1563         u_char txStatus = READSHMB(arlan->txStatus);
1564         u_short rxOffset = READSHMS(arlan->rxOffset);
1565         u_short pkt_len = READSHMS(arlan->rxLength);
1566         int interrupt_count = 0;
1567
1568         ARLAN_DEBUG_ENTRY("arlan_process_interrupt");
1569
1570         if (test_and_set_bit(0, (void *) &priv->interrupt_processing_active))
1571         {
1572                 if (arlan_debug & ARLAN_DEBUG_CHAIN_LOCKS)
1573                         printk(KERN_ERR "interrupt chain reentering \n");
1574                 goto end_int_process;
1575         }
1576         while ((rxStatus || txStatus || priv->interrupt_ack_requested)
1577                         && (interrupt_count < 5))
1578         {
1579                 if (rxStatus)
1580                         priv->last_rx_int_ack_time = jiffies;
1581
1582                 arlan_command(dev, ARLAN_COMMAND_INT_ACK);
1583                 arlan_command(dev, ARLAN_COMMAND_INT_ENABLE);
1584
1585                 IFDEBUG(ARLAN_DEBUG_INTERRUPT)
1586                         printk(KERN_ERR "%s:  got IRQ rx %x tx %x comm %x rxOff %x rxLen %x \n",
1587                                         dev->name, rxStatus, txStatus, READSHMB(arlan->commandByte),
1588                                         rxOffset, pkt_len);
1589
1590                 if (rxStatus == 0 && txStatus == 0)
1591                 {
1592                         if (priv->irq_test_done)
1593                         {
1594                                 if (!registrationBad(dev))
1595                                         IFDEBUG(ARLAN_DEBUG_INTERRUPT) printk(KERN_ERR "%s unknown interrupt(nop? regLost ?) reason tx %d rx %d ",
1596                                                                                     dev->name, txStatus, rxStatus);
1597                         } else {
1598                                 IFDEBUG(ARLAN_DEBUG_INTERRUPT)
1599                                         printk(KERN_INFO "%s irq $%d test OK \n", dev->name, dev->irq);
1600
1601                         }
1602                         priv->interrupt_ack_requested = 0;
1603                         goto ends;
1604                 }
1605                 if (txStatus != 0)
1606                 {
1607                         WRITESHMB(arlan->txStatus, 0x00);
1608                         arlan_tx_done_interrupt(dev, txStatus);
1609                         goto ends;
1610                 }
1611                 if (rxStatus == 1 || rxStatus == 2)
1612                 {               /* a packet waiting */
1613                         arlan_rx_interrupt(dev, rxStatus, rxOffset, pkt_len);
1614                         goto ends;
1615                 }
1616                 if (rxStatus > 2 && rxStatus < 0xff)
1617                 {
1618                         WRITESHMB(arlan->rxStatus, 0x00);
1619                         printk(KERN_ERR "%s unknown rxStatus reason tx %d rx %d ",
1620                                 dev->name, txStatus, rxStatus);
1621                         goto ends;
1622                 }
1623                 if (rxStatus == 0xff)
1624                 {
1625                         WRITESHMB(arlan->rxStatus, 0x00);
1626                         arlan_command(dev, ARLAN_COMMAND_RX);
1627                         if (registrationBad(dev))
1628                                 netif_device_detach(dev);
1629                         if (!registrationBad(dev))
1630                         {
1631                                 priv->registrationLastSeen = jiffies;
1632                                 if (!netif_queue_stopped(dev) && !priv->under_reset && !priv->under_config)
1633                                         netif_wake_queue (dev);
1634                         }
1635                         goto ends;
1636                 }
1637 ends:
1638
1639                 arlan_command_process(dev);
1640
1641                 rxStatus = READSHMB(arlan->rxStatus);
1642                 txStatus = READSHMB(arlan->txStatus);
1643                 rxOffset = READSHMS(arlan->rxOffset);
1644                 pkt_len = READSHMS(arlan->rxLength);
1645
1646
1647                 priv->irq_test_done = 1;
1648
1649                 interrupt_count++;
1650         }
1651         priv->interrupt_processing_active = 0;
1652
1653 end_int_process:
1654         arlan_command_process(dev);
1655
1656         ARLAN_DEBUG_EXIT("arlan_process_interrupt");
1657         return;
1658 }
1659
1660 static irqreturn_t arlan_interrupt(int irq, void *dev_id, struct pt_regs *regs)
1661 {
1662         struct net_device *dev = dev_id;
1663         struct arlan_private *priv = dev->priv;
1664         volatile struct arlan_shmem *arlan = priv->card;
1665         u_char rxStatus = READSHMB(arlan->rxStatus);
1666         u_char txStatus = READSHMB(arlan->txStatus);
1667
1668         ARLAN_DEBUG_ENTRY("arlan_interrupt");
1669
1670
1671         if (!rxStatus && !txStatus)
1672                 priv->interrupt_ack_requested++;
1673
1674         arlan_process_interrupt(dev);
1675
1676         priv->irq_test_done = 1;
1677
1678         ARLAN_DEBUG_EXIT("arlan_interrupt");
1679         return IRQ_HANDLED;
1680
1681 }
1682
1683
1684 static int arlan_close(struct net_device *dev)
1685 {
1686         struct arlan_private *priv = dev->priv;
1687
1688         ARLAN_DEBUG_ENTRY("arlan_close");
1689
1690         del_timer_sync(&priv->timer);
1691
1692         arlan_command(dev, ARLAN_COMMAND_POWERDOWN);
1693
1694         IFDEBUG(ARLAN_DEBUG_STARTUP)
1695                 printk(KERN_NOTICE "%s: Closing device\n", dev->name);
1696
1697         netif_stop_queue(dev);
1698         free_irq(dev->irq, dev);
1699
1700         ARLAN_DEBUG_EXIT("arlan_close");
1701         return 0;
1702 }
1703
1704 #ifdef ARLAN_DEBUGGING
1705 static long alignLong(volatile u_char * ptr)
1706 {
1707         long ret;
1708         memcpy_fromio(&ret, (void *) ptr, 4);
1709         return ret;
1710 }
1711 #endif
1712
1713 /*
1714  * Get the current statistics.
1715  * This may be called with the card open or closed.
1716  */
1717
1718 static struct net_device_stats *arlan_statistics(struct net_device *dev)
1719 {
1720         struct arlan_private *priv = dev->priv;
1721         volatile struct arlan_shmem *arlan = priv->card;
1722
1723
1724         ARLAN_DEBUG_ENTRY("arlan_statistics");
1725
1726         /* Update the statistics from the device registers. */
1727
1728         READSHM(priv->stats.collisions, arlan->numReTransmissions, u_int);
1729         READSHM(priv->stats.rx_crc_errors, arlan->numCRCErrors, u_int);
1730         READSHM(priv->stats.rx_dropped, arlan->numFramesDiscarded, u_int);
1731         READSHM(priv->stats.rx_fifo_errors, arlan->numRXBufferOverflows, u_int);
1732         READSHM(priv->stats.rx_frame_errors, arlan->numReceiveFramesLost, u_int);
1733         READSHM(priv->stats.rx_over_errors, arlan->numRXOverruns, u_int);
1734         READSHM(priv->stats.rx_packets, arlan->numDatagramsReceived, u_int);
1735         READSHM(priv->stats.tx_aborted_errors, arlan->numAbortErrors, u_int);
1736         READSHM(priv->stats.tx_carrier_errors, arlan->numStatusTimeouts, u_int);
1737         READSHM(priv->stats.tx_dropped, arlan->numDatagramsDiscarded, u_int);
1738         READSHM(priv->stats.tx_fifo_errors, arlan->numTXUnderruns, u_int);
1739         READSHM(priv->stats.tx_packets, arlan->numDatagramsTransmitted, u_int);
1740         READSHM(priv->stats.tx_window_errors, arlan->numHoldOffs, u_int);
1741
1742         ARLAN_DEBUG_EXIT("arlan_statistics");
1743
1744         return &priv->stats;
1745 }
1746
1747
1748 static void arlan_set_multicast(struct net_device *dev)
1749 {
1750         struct arlan_private *priv = dev->priv;
1751         volatile struct arlan_shmem *arlan = priv->card;
1752         struct arlan_conf_stru *conf = priv->Conf;
1753         int board_conf_needed = 0;
1754
1755
1756         ARLAN_DEBUG_ENTRY("arlan_set_multicast");
1757
1758         if (dev->flags & IFF_PROMISC)
1759         {
1760                 unsigned char recMode;
1761                 READSHM(recMode, arlan->receiveMode, u_char);
1762                 conf->receiveMode = (ARLAN_RCV_PROMISC | ARLAN_RCV_CONTROL);
1763                 if (conf->receiveMode != recMode)
1764                         board_conf_needed = 1;
1765         }
1766         else
1767         {
1768                 /* turn off promiscuous mode  */
1769                 unsigned char recMode;
1770                 READSHM(recMode, arlan->receiveMode, u_char);
1771                 conf->receiveMode = ARLAN_RCV_CLEAN | ARLAN_RCV_CONTROL;
1772                 if (conf->receiveMode != recMode)
1773                         board_conf_needed = 1;
1774         }
1775         if (board_conf_needed)
1776                 arlan_command(dev, ARLAN_COMMAND_CONF);
1777
1778         ARLAN_DEBUG_EXIT("arlan_set_multicast");
1779 }
1780
1781
1782 struct net_device * __init arlan_probe(int unit)
1783 {
1784         struct net_device *dev;
1785         int err;
1786         int m;
1787
1788         ARLAN_DEBUG_ENTRY("arlan_probe");
1789
1790         if (arlans_found == MAX_ARLANS)
1791                 return ERR_PTR(-ENODEV);
1792
1793         /*
1794          * Reserve space for local data and a copy of the shared memory
1795          * that is used by the /proc interface.
1796          */
1797         dev = alloc_etherdev(sizeof(struct arlan_private)
1798                              + sizeof(struct arlan_shmem));
1799         if (!dev)
1800                 return ERR_PTR(-ENOMEM);
1801
1802         SET_MODULE_OWNER(dev);
1803
1804         if (unit >= 0) {
1805                 sprintf(dev->name, "eth%d", unit);
1806                 netdev_boot_setup_check(dev);
1807
1808                 if (dev->mem_start) {
1809                         if (arlan_probe_here(dev, dev->mem_start) == 0)
1810                                 goto found;
1811                         goto not_found;
1812                 }
1813
1814         }
1815
1816
1817         for (m = (int)phys_to_virt(lastFoundAt) + ARLAN_SHMEM_SIZE;
1818              m <= (int)phys_to_virt(0xDE000);
1819              m += ARLAN_SHMEM_SIZE)
1820         {
1821                 if (arlan_probe_here(dev, m) == 0)
1822                 {
1823                         lastFoundAt = (int)virt_to_phys((void*)m);
1824                         goto found;
1825                 }
1826         }
1827
1828         if (lastFoundAt == 0xbe000)
1829                 printk(KERN_ERR "arlan: No Arlan devices found \n");
1830
1831  not_found:
1832         free_netdev(dev);
1833         return ERR_PTR(-ENODEV);
1834
1835  found:
1836         err = arlan_setup_device(dev, arlans_found);
1837         if (err)
1838                 dev = ERR_PTR(err);
1839         else if (!arlans_found++)
1840                 printk(KERN_INFO "Arlan driver %s\n", arlan_version);
1841
1842         return dev;
1843 }
1844
1845 #ifdef  MODULE
1846 int init_module(void)
1847 {
1848         int i = 0;
1849
1850         ARLAN_DEBUG_ENTRY("init_module");
1851
1852         if (channelSet != channelSetUNKNOWN || channelNumber != channelNumberUNKNOWN || systemId != systemIdUNKNOWN)
1853                 return -EINVAL;
1854
1855         for (i = 0; i < MAX_ARLANS; i++) {
1856                 struct net_device *dev = arlan_probe(i);
1857
1858                 if (IS_ERR(dev))
1859                         return PTR_ERR(dev);
1860         }
1861         init_arlan_proc();
1862         printk(KERN_INFO "Arlan driver %s\n", arlan_version);
1863         ARLAN_DEBUG_EXIT("init_module");
1864         return 0;
1865 }
1866
1867
1868 void cleanup_module(void)
1869 {
1870         int i = 0;
1871         struct net_device *dev;
1872
1873         ARLAN_DEBUG_ENTRY("cleanup_module");
1874
1875         IFDEBUG(ARLAN_DEBUG_SHUTDOWN)
1876                 printk(KERN_INFO "arlan: unloading module\n");
1877
1878         cleanup_arlan_proc();
1879
1880         for (i = 0; i < MAX_ARLANS; i++)
1881         {
1882                 dev = arlan_device[i];
1883                 if (dev) {
1884                         arlan_command(dev, ARLAN_COMMAND_POWERDOWN );
1885
1886                         unregister_netdev(dev);
1887                         release_mem_region(virt_to_phys((void *) dev->mem_start),
1888                                            ARLAN_SHMEM_SIZE);
1889                         free_netdev(dev);
1890                         arlan_device[i] = NULL;
1891                 }
1892         }
1893
1894         ARLAN_DEBUG_EXIT("cleanup_module");
1895 }
1896
1897
1898 #endif
1899 MODULE_LICENSE("GPL");