drivers/net/wireless/arlan-proc.c

   1 #include <linux/config.h>
   2 #include "arlan.h"
   3
   4 #include <linux/sysctl.h>
   5
   6 #ifdef CONFIG_PROC_FS
   7
   8 /* void enableReceive(struct net_device* dev);
   9 */
  10
  11
  12
  13 #define ARLAN_STR_SIZE  0x2ff0
  14 #define DEV_ARLAN_INFO  1
  15 #define DEV_ARLAN       1
  16 #define SARLG(type,var) {\
  17         pos += sprintf(arlan_drive_info+pos, "%s\t=\t0x%x\n", #var, READSHMB(priva->card->var));        \
  18         }
  19
  20 #define SARLBN(type,var,nn) {\
  21         pos += sprintf(arlan_drive_info+pos, "%s\t=\t0x",#var);\
  22         for (i=0; i < nn; i++ ) pos += sprintf(arlan_drive_info+pos, "%02x",READSHMB(priva->card->var[i]));\
  23         pos += sprintf(arlan_drive_info+pos, "\n");     \
  24         }
  25
  26 #define SARLBNpln(type,var,nn) {\
  27         for (i=0; i < nn; i++ ) pos += sprintf(arlan_drive_info+pos, "%02x",READSHMB(priva->card->var[i]));\
  28         }
  29
  30 #define SARLSTR(var,nn) {\
  31         char tmpStr[400];\
  32         int  tmpLn = nn;\
  33         if (nn > 399 ) tmpLn = 399; \
  34         memcpy(tmpStr,(char *) priva->conf->var,tmpLn);\
  35         tmpStr[tmpLn] = 0; \
  36         pos += sprintf(arlan_drive_info+pos, "%s\t=\t%s \n",#var,priva->conf->var);\
  37         }
  38
  39 #define SARLUC(var)     SARLG(u_char, var)
  40 #define SARLUCN(var,nn) SARLBN(u_char,var, nn)
  41 #define SARLUS(var)     SARLG(u_short, var)
  42 #define SARLUSN(var,nn) SARLBN(u_short,var, nn)
  43 #define SARLUI(var)     SARLG(u_int, var)
  44
  45 #define SARLUSA(var) {\
  46         u_short tmpVar;\
  47         memcpy(&tmpVar, (short *) priva->conf->var,2); \
  48         pos += sprintf(arlan_drive_info+pos, "%s\t=\t0x%x\n",#var, tmpVar);\
  49 }
  50
  51 #define SARLUIA(var) {\
  52         u_int tmpVar;\
  53         memcpy(&tmpVar, (int* )priva->conf->var,4); \
  54         pos += sprintf(arlan_drive_info+pos, "%s\t=\t0x%x\n",#var, tmpVar);\
  55 }
  56
  57
  58 static const char *arlan_diagnostic_info_string(struct net_device *dev)
  59 {
  60
  61         struct arlan_private *priv = netdev_priv(dev);
  62         volatile struct arlan_shmem __iomem *arlan = priv->card;
  63         u_char diagnosticInfo;
  64
  65         READSHM(diagnosticInfo, arlan->diagnosticInfo, u_char);
  66
  67         switch (diagnosticInfo)
  68         {
  69                 case 0xFF:
  70                         return "Diagnostic info is OK";
  71                 case 0xFE:
  72                         return "ERROR EPROM Checksum error ";
  73                 case 0xFD:
  74                         return "ERROR Local Ram Test Failed ";
  75                 case 0xFC:
  76                         return "ERROR SCC failure ";
  77                 case 0xFB:
  78                         return "ERROR BackBone failure ";
  79                 case 0xFA:
  80                         return "ERROR transceiver not found ";
  81                 case 0xF9:
  82                         return "ERROR no more address space ";
  83                 case 0xF8:
  84                         return "ERROR Checksum error  ";
  85                 case 0xF7:
  86                         return "ERROR Missing SS Code";
  87                 case 0xF6:
  88                         return "ERROR Invalid config format";
  89                 case 0xF5:
  90                         return "ERROR Reserved errorcode F5";
  91                 case 0xF4:
  92                         return "ERROR Invalid spreading code/channel number";
  93                 case 0xF3:
  94                         return "ERROR Load Code Error";
  95                 case 0xF2:
  96                         return "ERROR Reserver errorcode F2 ";
  97                 case 0xF1:
  98                         return "ERROR Invalid command receivec by LAN card ";
  99                 case 0xF0:
 100                         return "ERROR Invalid parameter found in command ";
 101                 case 0xEF:
 102                         return "ERROR On-chip timer failure ";
 103                 case 0xEE:
 104                         return "ERROR T410 timer failure ";
 105                 case 0xED:
 106                         return "ERROR Too Many TxEnable commands ";
 107                 case 0xEC:
 108                         return "ERROR EEPROM error on radio module ";
 109                 default:
 110                         return "ERROR unknown Diagnostic info reply code ";
 111           }
 112 }
 113
 114 static const char *arlan_hardware_type_string(struct net_device *dev)
 115 {
 116         u_char hardwareType;
 117         struct arlan_private *priv = netdev_priv(dev);
 118         volatile struct arlan_shmem __iomem *arlan = priv->card;
 119
 120         READSHM(hardwareType, arlan->hardwareType, u_char);
 121         switch (hardwareType)
 122         {
 123                 case 0x00:
 124                         return "type A450";
 125                 case 0x01:
 126                         return "type A650 ";
 127                 case 0x04:
 128                         return "type TMA coproc";
 129                 case 0x0D:
 130                         return "type A650E ";
 131                 case 0x18:
 132                         return "type TMA coproc Australian";
 133                 case 0x19:
 134                         return "type A650A ";
 135                 case 0x26:
 136                         return "type TMA coproc European";
 137                 case 0x2E:
 138                         return "type A655 ";
 139                 case 0x2F:
 140                         return "type A655A ";
 141                 case 0x30:
 142                         return "type A655E ";
 143                 case 0x0B:
 144                         return "type A670 ";
 145                 case 0x0C:
 146                         return "type A670E ";
 147                 case 0x2D:
 148                         return "type A670A ";
 149                 case 0x0F:
 150                         return "type A411T";
 151                 case 0x16:
 152                         return "type A411TA";
 153                 case 0x1B:
 154                         return "type A440T";
 155                 case 0x1C:
 156                         return "type A412T";
 157                 case 0x1E:
 158                         return "type A412TA";
 159                 case 0x22:
 160                         return "type A411TE";
 161                 case 0x24:
 162                         return "type A412TE";
 163                 case 0x27:
 164                         return "type A671T ";
 165                 case 0x29:
 166                         return "type A671TA ";
 167                 case 0x2B:
 168                         return "type A671TE ";
 169                 case 0x31:
 170                         return "type A415T ";
 171                 case 0x33:
 172                         return "type A415TA ";
 173                 case 0x35:
 174                         return "type A415TE ";
 175                 case 0x37:
 176                         return "type A672";
 177                 case 0x39:
 178                         return "type A672A ";
 179                 case 0x3B:
 180                         return "type A672T";
 181                 case 0x6B:
 182                         return "type IC2200";
 183                 default:
 184                         return "type A672T";
 185         }
 186 }
 187 #ifdef ARLAN_DEBUGGING
 188 static void arlan_print_diagnostic_info(struct net_device *dev)
 189 {
 190         int i;
 191         u_char diagnosticInfo;
 192         u_short diagnosticOffset;
 193         u_char hardwareType;
 194         struct arlan_private *priv = netdev_priv(dev);
 195         volatile struct arlan_shmem __iomem *arlan = priv->card;
 196
 197         //  ARLAN_DEBUG_ENTRY("arlan_print_diagnostic_info");
 198
 199         if (READSHMB(arlan->configuredStatusFlag) == 0)
 200                 printk("Arlan: Card NOT configured\n");
 201         else
 202                 printk("Arlan: Card is configured\n");
 203
 204         READSHM(diagnosticInfo, arlan->diagnosticInfo, u_char);
 205         READSHM(diagnosticOffset, arlan->diagnosticOffset, u_short);
 206
 207         printk(KERN_INFO "%s\n", arlan_diagnostic_info_string(dev));
 208
 209         if (diagnosticInfo != 0xff)
 210                 printk("%s arlan: Diagnostic Offset %d \n", dev->name, diagnosticOffset);
 211
 212         printk("arlan: LAN CODE ID = ");
 213         for (i = 0; i < 6; i++)
 214                 DEBUGSHM(1, "%03d:", arlan->lanCardNodeId[i], u_char);
 215         printk("\n");
 216
 217         printk("arlan: Arlan BroadCast address  = ");
 218         for (i = 0; i < 6; i++)
 219                 DEBUGSHM(1, "%03d:", arlan->broadcastAddress[i], u_char);
 220         printk("\n");
 221
 222         READSHM(hardwareType, arlan->hardwareType, u_char);
 223         printk(KERN_INFO "%s\n", arlan_hardware_type_string(dev));
 224
 225
 226         DEBUGSHM(1, "arlan: channelNumber=%d\n", arlan->channelNumber, u_char);
 227         DEBUGSHM(1, "arlan: channelSet=%d\n", arlan->channelSet, u_char);
 228         DEBUGSHM(1, "arlan: spreadingCode=%d\n", arlan->spreadingCode, u_char);
 229         DEBUGSHM(1, "arlan: radioNodeId=%d\n", arlan->radioNodeId, u_short);
 230         DEBUGSHM(1, "arlan: SID =%d\n", arlan->SID, u_short);
 231         DEBUGSHM(1, "arlan: rxOffset=%d\n", arlan->rxOffset, u_short);
 232
 233         DEBUGSHM(1, "arlan: registration mode is %d\n", arlan->registrationMode, u_char);
 234
 235         printk("arlan: name= ");
 236         IFDEBUG(1)
 237
 238         for (i = 0; i < 16; i++)
 239         {
 240                 char c;
 241                 READSHM(c, arlan->name[i], char);
 242                 if (c)
 243                         printk("%c", c);
 244         }
 245         printk("\n");
 246
 247 //   ARLAN_DEBUG_EXIT("arlan_print_diagnostic_info");
 248
 249 }
 250
 251
 252 /******************************         TEST    MEMORY  **************/
 253
 254 static int arlan_hw_test_memory(struct net_device *dev)
 255 {
 256         u_char *ptr;
 257         int i;
 258         int memlen = sizeof(struct arlan_shmem) - 0xF;  /* avoid control register */
 259         volatile char *arlan_mem = (char *) (dev->mem_start);
 260         struct arlan_private *priv = netdev_priv(dev);
 261         volatile struct arlan_shmem __iomem *arlan = priv->card;
 262         char pattern;
 263
 264         ptr = NULL;
 265
 266         /* hold card in reset state */
 267         setHardwareReset(dev);
 268
 269         /* test memory */
 270         pattern = 0;
 271         for (i = 0; i < memlen; i++)
 272                 WRITESHM(arlan_mem[i], ((u_char) pattern++), u_char);
 273
 274         pattern = 0;
 275         for (i = 0; i < memlen; i++)
 276         {
 277                 char res;
 278                 READSHM(res, arlan_mem[i], char);
 279                 if (res != pattern++)
 280                 {
 281                         printk(KERN_ERR "Arlan driver memory test 1 failed \n");
 282                         return -1;
 283                 }
 284         }
 285
 286         pattern = 0;
 287         for (i = 0; i < memlen; i++)
 288                 WRITESHM(arlan_mem[i], ~(pattern++), char);
 289
 290         pattern = 0;
 291         for (i = 0; i < memlen; i++)
 292         {
 293                 char res;
 294                 READSHM(res, arlan_mem[i], char);
 295                 if (res != ~(pattern++))
 296                 {
 297                         printk(KERN_ERR "Arlan driver memory test 2 failed \n");
 298                         return -1;
 299                 }
 300         }
 301
 302         /* zero memory */
 303         for (i = 0; i < memlen; i++)
 304                 WRITESHM(arlan_mem[i], 0x00, char);
 305
 306         IFDEBUG(1) printk(KERN_INFO "Arlan: memory tests ok\n");
 307
 308         /* set reset flag and then release reset */
 309         WRITESHM(arlan->resetFlag, 0xff, u_char);
 310
 311         clearChannelAttention(dev);
 312         clearHardwareReset(dev);
 313
 314         /* wait for reset flag to become zero, we'll wait for two seconds */
 315         if (arlan_command(dev, ARLAN_COMMAND_LONG_WAIT_NOW))
 316         {
 317                 printk(KERN_ERR "%s arlan: failed to come back from memory test\n", dev->name);
 318                 return -1;
 319         }
 320         return 0;
 321 }
 322
 323 static int arlan_setup_card_by_book(struct net_device *dev)
 324 {
 325         u_char irqLevel, configuredStatusFlag;
 326         struct arlan_private *priv = netdev_priv(dev);
 327         volatile struct arlan_shmem __iomem *arlan = priv->card;
 328
 329 //      ARLAN_DEBUG_ENTRY("arlan_setup_card");
 330
 331         READSHM(configuredStatusFlag, arlan->configuredStatusFlag, u_char);
 332
 333         IFDEBUG(10)
 334         if (configuredStatusFlag != 0)
 335                 IFDEBUG(10) printk("arlan: CARD IS CONFIGURED\n");
 336         else
 337                 IFDEBUG(10) printk("arlan: card is NOT configured\n");
 338
 339         if (testMemory || (READSHMB(arlan->diagnosticInfo) != 0xff))
 340                 if (arlan_hw_test_memory(dev))
 341                         return -1;
 342
 343         DEBUGSHM(4, "arlan configuredStatus = %d \n", arlan->configuredStatusFlag, u_char);
 344         DEBUGSHM(4, "arlan driver diagnostic: 0x%2x\n", arlan->diagnosticInfo, u_char);
 345
 346         /* issue nop command - no interrupt */
 347         arlan_command(dev, ARLAN_COMMAND_NOOP);
 348         if (arlan_command(dev, ARLAN_COMMAND_WAIT_NOW) != 0)
 349                 return -1;
 350
 351         IFDEBUG(50) printk("1st Noop successfully executed !!\n");
 352
 353         /* try to turn on the arlan interrupts */
 354         clearClearInterrupt(dev);
 355         setClearInterrupt(dev);
 356         setInterruptEnable(dev);
 357
 358         /* issue nop command - with interrupt */
 359
 360         arlan_command(dev, ARLAN_COMMAND_NOOPINT);
 361         if (arlan_command(dev, ARLAN_COMMAND_WAIT_NOW) != 0)
 362                 return -1;
 363
 364
 365         IFDEBUG(50) printk("2nd Noop successfully executed !!\n");
 366
 367         READSHM(irqLevel, arlan->irqLevel, u_char)
 368
 369         if (irqLevel != dev->irq)
 370         {
 371                 IFDEBUG(1) printk(KERN_WARNING "arlan dip switches set irq to %d\n", irqLevel);
 372                 printk(KERN_WARNING "device driver irq set to %d - does not match\n", dev->irq);
 373                 dev->irq = irqLevel;
 374         }
 375         else
 376                 IFDEBUG(2) printk("irq level is OK\n");
 377
 378
 379         IFDEBUG(3) arlan_print_diagnostic_info(dev);
 380
 381         arlan_command(dev, ARLAN_COMMAND_CONF);
 382
 383         READSHM(configuredStatusFlag, arlan->configuredStatusFlag, u_char);
 384         if (configuredStatusFlag == 0)
 385         {
 386                 printk(KERN_WARNING "arlan configure failed\n");
 387                 return -1;
 388         }
 389         arlan_command(dev, ARLAN_COMMAND_LONG_WAIT_NOW);
 390         arlan_command(dev, ARLAN_COMMAND_RX);
 391         arlan_command(dev, ARLAN_COMMAND_LONG_WAIT_NOW);
 392         printk(KERN_NOTICE "%s: arlan driver version %s loaded\n",
 393                dev->name, arlan_version);
 394
 395 //      ARLAN_DEBUG_EXIT("arlan_setup_card");
 396
 397         return 0;               /* no errors */
 398 }
 399 #endif
 400
 401 #ifdef ARLAN_PROC_INTERFACE
 402 #ifdef ARLAN_PROC_SHM_DUMP
 403
 404 static char arlan_drive_info[ARLAN_STR_SIZE] = "A655\n\0";
 405
 406 static int arlan_sysctl_info(ctl_table * ctl, int write, struct file *filp,
 407                       void __user *buffer, size_t * lenp, loff_t *ppos)
 408 {
 409         int i;
 410         int retv, pos, devnum;
 411         struct arlan_private *priva = NULL;
 412         struct net_device *dev;
 413         pos = 0;
 414         if (write)
 415         {
 416                 printk("wrirte: ");
 417                 for (i = 0; i < 100; i++)
 418                         printk("adi %x \n", arlan_drive_info[i]);
 419         }
 420         if (ctl->procname == NULL || arlan_drive_info == NULL)
 421         {
 422                 printk(KERN_WARNING " procname is NULL in sysctl_table or arlan_drive_info is NULL \n at arlan module\n ");
 423                 return -1;
 424         }
 425         devnum = ctl->procname[5] - '0';
 426         if (devnum < 0 || devnum > MAX_ARLANS - 1)
 427         {
 428                 printk(KERN_WARNING "too strange devnum in procfs parse\n ");
 429                 return -1;
 430         }
 431         else if (arlan_device[devnum] == NULL)
 432         {
 433                 if (ctl->procname)
 434                         pos += sprintf(arlan_drive_info + pos, "\t%s\n\n", ctl->procname);
 435                 pos += sprintf(arlan_drive_info + pos, "No device found here \n");
 436                 goto final;
 437         }
 438         else
 439                 priva = arlan_device[devnum]->priv;
 440
 441         if (priva == NULL)
 442         {
 443                 printk(KERN_WARNING " Could not find the device private in arlan procsys, bad\n ");
 444                 return -1;
 445         }
 446         dev = arlan_device[devnum];
 447
 448         memcpy_fromio(priva->conf, priva->card, sizeof(struct arlan_shmem));
 449
 450         pos = sprintf(arlan_drive_info, "Arlan  info \n");
 451         /* Header Signature */
 452         SARLSTR(textRegion, 48);
 453         SARLUC(resetFlag);
 454         pos += sprintf(arlan_drive_info + pos, "diagnosticInfo\t=\t%s \n", arlan_diagnostic_info_string(dev));
 455         SARLUC(diagnosticInfo);
 456         SARLUS(diagnosticOffset);
 457         SARLUCN(_1, 12);
 458         SARLUCN(lanCardNodeId, 6);
 459         SARLUCN(broadcastAddress, 6);
 460         pos += sprintf(arlan_drive_info + pos, "hardwareType =\t  %s \n", arlan_hardware_type_string(dev));
 461         SARLUC(hardwareType);
 462         SARLUC(majorHardwareVersion);
 463         SARLUC(minorHardwareVersion);
 464         SARLUC(radioModule);
 465         SARLUC(defaultChannelSet);
 466         SARLUCN(_2, 47);
 467
 468         /* Control/Status Block - 0x0080 */
 469         SARLUC(interruptInProgress);
 470         SARLUC(cntrlRegImage);
 471
 472         SARLUCN(_3, 14);
 473         SARLUC(commandByte);
 474         SARLUCN(commandParameter, 15);
 475
 476         /* Receive Status - 0x00a0 */
 477         SARLUC(rxStatus);
 478         SARLUC(rxFrmType);
 479         SARLUS(rxOffset);
 480         SARLUS(rxLength);
 481         SARLUCN(rxSrc, 6);
 482         SARLUC(rxBroadcastFlag);
 483         SARLUC(rxQuality);
 484         SARLUC(scrambled);
 485         SARLUCN(_4, 1);
 486
 487         /* Transmit Status - 0x00b0 */
 488         SARLUC(txStatus);
 489         SARLUC(txAckQuality);
 490         SARLUC(numRetries);
 491         SARLUCN(_5, 14);
 492         SARLUCN(registeredRouter, 6);
 493         SARLUCN(backboneRouter, 6);
 494         SARLUC(registrationStatus);
 495         SARLUC(configuredStatusFlag);
 496         SARLUCN(_6, 1);
 497         SARLUCN(ultimateDestAddress, 6);
 498         SARLUCN(immedDestAddress, 6);
 499         SARLUCN(immedSrcAddress, 6);
 500         SARLUS(rxSequenceNumber);
 501         SARLUC(assignedLocaltalkAddress);
 502         SARLUCN(_7, 27);
 503
 504         /* System Parameter Block */
 505
 506         /* - Driver Parameters (Novell Specific) */
 507
 508         SARLUS(txTimeout);
 509         SARLUS(transportTime);
 510         SARLUCN(_8, 4);
 511
 512         /* - Configuration Parameters */
 513         SARLUC(irqLevel);
 514         SARLUC(spreadingCode);
 515         SARLUC(channelSet);
 516         SARLUC(channelNumber);
 517         SARLUS(radioNodeId);
 518         SARLUCN(_9, 2);
 519         SARLUC(scramblingDisable);
 520         SARLUC(radioType);
 521         SARLUS(routerId);
 522         SARLUCN(_10, 9);
 523         SARLUC(txAttenuation);
 524         SARLUIA(systemId);
 525         SARLUS(globalChecksum);
 526         SARLUCN(_11, 4);
 527         SARLUS(maxDatagramSize);
 528         SARLUS(maxFrameSize);
 529         SARLUC(maxRetries);
 530         SARLUC(receiveMode);
 531         SARLUC(priority);
 532         SARLUC(rootOrRepeater);
 533         SARLUCN(specifiedRouter, 6);
 534         SARLUS(fastPollPeriod);
 535         SARLUC(pollDecay);
 536         SARLUSA(fastPollDelay);
 537         SARLUC(arlThreshold);
 538         SARLUC(arlDecay);
 539         SARLUCN(_12, 1);
 540         SARLUS(specRouterTimeout);
 541         SARLUCN(_13, 5);
 542
 543         /* Scrambled Area */
 544         SARLUIA(SID);
 545         SARLUCN(encryptionKey, 12);
 546         SARLUIA(_14);
 547         SARLUSA(waitTime);
 548         SARLUSA(lParameter);
 549         SARLUCN(_15, 3);
 550         SARLUS(headerSize);
 551         SARLUS(sectionChecksum);
 552
 553         SARLUC(registrationMode);
 554         SARLUC(registrationFill);
 555         SARLUS(pollPeriod);
 556         SARLUS(refreshPeriod);
 557         SARLSTR(name, 16);
 558         SARLUCN(NID, 6);
 559         SARLUC(localTalkAddress);
 560         SARLUC(codeFormat);
 561         SARLUC(numChannels);
 562         SARLUC(channel1);
 563         SARLUC(channel2);
 564         SARLUC(channel3);
 565         SARLUC(channel4);
 566         SARLUCN(SSCode, 59);
 567
 568 /*      SARLUCN( _16, 0x140);
 569  */
 570         /* Statistics Block - 0x0300 */
 571         SARLUC(hostcpuLock);
 572         SARLUC(lancpuLock);
 573         SARLUCN(resetTime, 18);
 574         SARLUIA(numDatagramsTransmitted);
 575         SARLUIA(numReTransmissions);
 576         SARLUIA(numFramesDiscarded);
 577         SARLUIA(numDatagramsReceived);
 578         SARLUIA(numDuplicateReceivedFrames);
 579         SARLUIA(numDatagramsDiscarded);
 580         SARLUS(maxNumReTransmitDatagram);
 581         SARLUS(maxNumReTransmitFrames);
 582         SARLUS(maxNumConsecutiveDuplicateFrames);
 583         /* misaligned here so we have to go to characters */
 584         SARLUIA(numBytesTransmitted);
 585         SARLUIA(numBytesReceived);
 586         SARLUIA(numCRCErrors);
 587         SARLUIA(numLengthErrors);
 588         SARLUIA(numAbortErrors);
 589         SARLUIA(numTXUnderruns);
 590         SARLUIA(numRXOverruns);
 591         SARLUIA(numHoldOffs);
 592         SARLUIA(numFramesTransmitted);
 593         SARLUIA(numFramesReceived);
 594         SARLUIA(numReceiveFramesLost);
 595         SARLUIA(numRXBufferOverflows);
 596         SARLUIA(numFramesDiscardedAddrMismatch);
 597         SARLUIA(numFramesDiscardedSIDMismatch);
 598         SARLUIA(numPollsTransmistted);
 599         SARLUIA(numPollAcknowledges);
 600         SARLUIA(numStatusTimeouts);
 601         SARLUIA(numNACKReceived);
 602         SARLUS(auxCmd);
 603         SARLUCN(dumpPtr, 4);
 604         SARLUC(dumpVal);
 605         SARLUC(wireTest);
 606
 607         /* next 4 seems too long for procfs, over single page ?
 608         SARLUCN( _17, 0x86);
 609         SARLUCN( txBuffer, 0x800);
 610         SARLUCN( rxBuffer,  0x800);
 611         SARLUCN( _18, 0x0bff);
 612          */
 613
 614         pos += sprintf(arlan_drive_info + pos, "rxRing\t=\t0x");
 615         for (i = 0; i < 0x50; i++)
 616                 pos += sprintf(arlan_drive_info + pos, "%02x", ((char *) priva->conf)[priva->conf->rxOffset + i]);
 617         pos += sprintf(arlan_drive_info + pos, "\n");
 618
 619         SARLUC(configStatus);
 620         SARLUC(_22);
 621         SARLUC(progIOCtrl);
 622         SARLUC(shareMBase);
 623         SARLUC(controlRegister);
 624
 625         pos += sprintf(arlan_drive_info + pos, " total %d chars\n", pos);
 626         if (ctl)
 627                 if (ctl->procname)
 628                         pos += sprintf(arlan_drive_info + pos, " driver name : %s\n", ctl->procname);
 629 final:
 630         *lenp = pos;
 631
 632         if (!write)
 633                 retv = proc_dostring(ctl, write, filp, buffer, lenp, ppos);
 634         else
 635         {
 636                 *lenp = 0;
 637                 return -1;
 638         }
 639         return retv;
 640 }
 641
 642
 643 static int arlan_sysctl_info161719(ctl_table * ctl, int write, struct file *filp,
 644                             void __user *buffer, size_t * lenp, loff_t *ppos)
 645 {
 646         int i;
 647         int retv, pos, devnum;
 648         struct arlan_private *priva = NULL;
 649
 650         pos = 0;
 651         devnum = ctl->procname[5] - '0';
 652         if (arlan_device[devnum] == NULL)
 653         {
 654                 pos += sprintf(arlan_drive_info + pos, "No device found here \n");
 655                 goto final;
 656         }
 657         else
 658                 priva = arlan_device[devnum]->priv;
 659         if (priva == NULL)
 660         {
 661                 printk(KERN_WARNING " Could not find the device private in arlan procsys, bad\n ");
 662                 return -1;
 663         }
 664         memcpy_fromio(priva->conf, priva->card, sizeof(struct arlan_shmem));
 665         SARLUCN(_16, 0xC0);
 666         SARLUCN(_17, 0x6A);
 667         SARLUCN(_18, 14);
 668         SARLUCN(_19, 0x86);
 669         SARLUCN(_21, 0x3fd);
 670
 671 final:
 672         *lenp = pos;
 673         retv = proc_dostring(ctl, write, filp, buffer, lenp, ppos);
 674         return retv;
 675 }
 676
 677 static int arlan_sysctl_infotxRing(ctl_table * ctl, int write, struct file *filp,
 678                             void __user *buffer, size_t * lenp, loff_t *ppos)
 679 {
 680         int i;
 681         int retv, pos, devnum;
 682         struct arlan_private *priva = NULL;
 683
 684         pos = 0;
 685         devnum = ctl->procname[5] - '0';
 686         if (arlan_device[devnum] == NULL)
 687         {
 688                   pos += sprintf(arlan_drive_info + pos, "No device found here \n");
 689                   goto final;
 690         }
 691         else
 692                 priva = arlan_device[devnum]->priv;
 693         if (priva == NULL)
 694         {
 695                 printk(KERN_WARNING " Could not find the device private in arlan procsys, bad\n ");
 696                 return -1;
 697         }
 698         memcpy_fromio(priva->conf, priva->card, sizeof(struct arlan_shmem));
 699         SARLBNpln(u_char, txBuffer, 0x800);
 700 final:
 701         *lenp = pos;
 702         retv = proc_dostring(ctl, write, filp, buffer, lenp, ppos);
 703         return retv;
 704 }
 705
 706 static int arlan_sysctl_inforxRing(ctl_table * ctl, int write, struct file *filp,
 707                             void __user *buffer, size_t * lenp, loff_t *ppos)
 708 {
 709         int i;
 710         int retv, pos, devnum;
 711         struct arlan_private *priva = NULL;
 712
 713         pos = 0;
 714         devnum = ctl->procname[5] - '0';
 715         if (arlan_device[devnum] == NULL)
 716         {
 717                   pos += sprintf(arlan_drive_info + pos, "No device found here \n");
 718                   goto final;
 719         } else
 720                 priva = arlan_device[devnum]->priv;
 721         if (priva == NULL)
 722         {
 723                 printk(KERN_WARNING " Could not find the device private in arlan procsys, bad\n ");
 724                 return -1;
 725         }
 726         memcpy_fromio(priva->conf, priva->card, sizeof(struct arlan_shmem));
 727         SARLBNpln(u_char, rxBuffer, 0x800);
 728 final:
 729         *lenp = pos;
 730         retv = proc_dostring(ctl, write, filp, buffer, lenp, ppos);
 731         return retv;
 732 }
 733
 734 static int arlan_sysctl_info18(ctl_table * ctl, int write, struct file *filp,
 735                         void __user *buffer, size_t * lenp, loff_t *ppos)
 736 {
 737         int i;
 738         int retv, pos, devnum;
 739         struct arlan_private *priva = NULL;
 740
 741         pos = 0;
 742         devnum = ctl->procname[5] - '0';
 743         if (arlan_device[devnum] == NULL)
 744         {
 745                 pos += sprintf(arlan_drive_info + pos, "No device found here \n");
 746                 goto final;
 747         }
 748         else
 749                 priva = arlan_device[devnum]->priv;
 750         if (priva == NULL)
 751         {
 752                 printk(KERN_WARNING " Could not find the device private in arlan procsys, bad\n ");
 753                 return -1;
 754         }
 755         memcpy_fromio(priva->conf, priva->card, sizeof(struct arlan_shmem));
 756         SARLBNpln(u_char, _18, 0x800);
 757
 758 final:
 759         *lenp = pos;
 760         retv = proc_dostring(ctl, write, filp, buffer, lenp, ppos);
 761         return retv;
 762 }
 763
 764
 765 #endif                          /* #ifdef ARLAN_PROC_SHM_DUMP */
 766
 767
 768 static char conf_reset_result[200];
 769
 770 static int arlan_configure(ctl_table * ctl, int write, struct file *filp,
 771                     void __user *buffer, size_t * lenp, loff_t *ppos)
 772 {
 773         int pos = 0;
 774         int devnum = ctl->procname[6] - '0';
 775         struct arlan_private *priv;
 776
 777         if (devnum < 0 || devnum > MAX_ARLANS - 1)
 778         {
 779                   printk(KERN_WARNING "too strange devnum in procfs parse\n ");
 780                   return -1;
 781         }
 782         else if (arlan_device[devnum] != NULL)
 783         {
 784                   priv = arlan_device[devnum]->priv;
 785
 786                   arlan_command(arlan_device[devnum], ARLAN_COMMAND_CLEAN_AND_CONF);
 787         }
 788         else
 789                 return -1;
 790
 791         *lenp = pos;
 792         return proc_dostring(ctl, write, filp, buffer, lenp, ppos);
 793 }
 794
 795 static int arlan_sysctl_reset(ctl_table * ctl, int write, struct file *filp,
 796                        void __user *buffer, size_t * lenp, loff_t *ppos)
 797 {
 798         int pos = 0;
 799         int devnum = ctl->procname[5] - '0';
 800         struct arlan_private *priv;
 801
 802         if (devnum < 0 || devnum > MAX_ARLANS - 1)
 803         {
 804                   printk(KERN_WARNING "too strange devnum in procfs parse\n ");
 805                   return -1;
 806         }
 807         else if (arlan_device[devnum] != NULL)
 808         {
 809                 priv = arlan_device[devnum]->priv;
 810                 arlan_command(arlan_device[devnum], ARLAN_COMMAND_CLEAN_AND_RESET);
 811
 812         } else
 813                 return -1;
 814         *lenp = pos + 3;
 815         return proc_dostring(ctl, write, filp, buffer, lenp, ppos);
 816 }
 817
 818
 819 /* Place files in /proc/sys/dev/arlan */
 820 #define CTBLN(num,card,nam) \
 821         { .ctl_name = num,\
 822           .procname = #nam,\
 823           .data = &(arlan_conf[card].nam),\
 824           .maxlen = sizeof(int), .mode = 0600, .proc_handler = &proc_dointvec}
 825 #ifdef ARLAN_DEBUGGING
 826
 827 #define ARLAN_PROC_DEBUG_ENTRIES \
 828         { .ctl_name = 48, .procname = "entry_exit_debug",\
 829           .data = &arlan_entry_and_exit_debug,\
 830           .maxlen = sizeof(int), .mode = 0600, .proc_handler = &proc_dointvec},\
 831         { .ctl_name = 49, .procname = "debug", .data = &arlan_debug,\
 832           .maxlen = sizeof(int), .mode = 0600, .proc_handler = &proc_dointvec},
 833 #else
 834 #define ARLAN_PROC_DEBUG_ENTRIES
 835 #endif
 836
 837 #define ARLAN_SYSCTL_TABLE_TOTAL(cardNo)\
 838         CTBLN(1,cardNo,spreadingCode),\
 839         CTBLN(2,cardNo, channelNumber),\
 840         CTBLN(3,cardNo, scramblingDisable),\
 841         CTBLN(4,cardNo, txAttenuation),\
 842         CTBLN(5,cardNo, systemId), \
 843         CTBLN(6,cardNo, maxDatagramSize),\
 844         CTBLN(7,cardNo, maxFrameSize),\
 845         CTBLN(8,cardNo, maxRetries),\
 846         CTBLN(9,cardNo, receiveMode),\
 847         CTBLN(10,cardNo, priority),\
 848         CTBLN(11,cardNo, rootOrRepeater),\
 849         CTBLN(12,cardNo, SID),\
 850         CTBLN(13,cardNo, registrationMode),\
 851         CTBLN(14,cardNo, registrationFill),\
 852         CTBLN(15,cardNo, localTalkAddress),\
 853         CTBLN(16,cardNo, codeFormat),\
 854         CTBLN(17,cardNo, numChannels),\
 855         CTBLN(18,cardNo, channel1),\
 856         CTBLN(19,cardNo, channel2),\
 857         CTBLN(20,cardNo, channel3),\
 858         CTBLN(21,cardNo, channel4),\
 859         CTBLN(22,cardNo, txClear),\
 860         CTBLN(23,cardNo, txRetries),\
 861         CTBLN(24,cardNo, txRouting),\
 862         CTBLN(25,cardNo, txScrambled),\
 863         CTBLN(26,cardNo, rxParameter),\
 864         CTBLN(27,cardNo, txTimeoutMs),\
 865         CTBLN(28,cardNo, waitCardTimeout),\
 866         CTBLN(29,cardNo, channelSet), \
 867         {.ctl_name = 30, .procname = "name",\
 868          .data = arlan_conf[cardNo].siteName,\
 869          .maxlen = 16, .mode = 0600, .proc_handler = &proc_dostring},\
 870         CTBLN(31,cardNo,waitTime),\
 871         CTBLN(32,cardNo,lParameter),\
 872         CTBLN(33,cardNo,_15),\
 873         CTBLN(34,cardNo,headerSize),\
 874         CTBLN(36,cardNo,tx_delay_ms),\
 875         CTBLN(37,cardNo,retries),\
 876         CTBLN(38,cardNo,ReTransmitPacketMaxSize),\
 877         CTBLN(39,cardNo,waitReTransmitPacketMaxSize),\
 878         CTBLN(40,cardNo,fastReTransCount),\
 879         CTBLN(41,cardNo,driverRetransmissions),\
 880         CTBLN(42,cardNo,txAckTimeoutMs),\
 881         CTBLN(43,cardNo,registrationInterrupts),\
 882         CTBLN(44,cardNo,hardwareType),\
 883         CTBLN(45,cardNo,radioType),\
 884         CTBLN(46,cardNo,writeEEPROM),\
 885         CTBLN(47,cardNo,writeRadioType),\
 886         ARLAN_PROC_DEBUG_ENTRIES\
 887         CTBLN(50,cardNo,in_speed),\
 888         CTBLN(51,cardNo,out_speed),\
 889         CTBLN(52,cardNo,in_speed10),\
 890         CTBLN(53,cardNo,out_speed10),\
 891         CTBLN(54,cardNo,in_speed_max),\
 892         CTBLN(55,cardNo,out_speed_max),\
 893         CTBLN(56,cardNo,measure_rate),\
 894         CTBLN(57,cardNo,pre_Command_Wait),\
 895         CTBLN(58,cardNo,rx_tweak1),\
 896         CTBLN(59,cardNo,rx_tweak2),\
 897         CTBLN(60,cardNo,tx_queue_len),\
 898
 899
 900
 901 static ctl_table arlan_conf_table0[] =
 902 {
 903         ARLAN_SYSCTL_TABLE_TOTAL(0)
 904
 905 #ifdef ARLAN_PROC_SHM_DUMP
 906         {
 907                 .ctl_name       = 150,
 908                 .procname       = "arlan0-txRing",
 909                 .data           = &arlan_drive_info,
 910                 .maxlen         = ARLAN_STR_SIZE,
 911                 .mode           = 0400,
 912                 .proc_handler   = &arlan_sysctl_infotxRing,
 913         },
 914         {
 915                 .ctl_name       = 151,
 916                 .procname       = "arlan0-rxRing",
 917                 .data           = &arlan_drive_info,
 918                 .maxlen         = ARLAN_STR_SIZE,
 919                 .mode           = 0400,
 920                 .proc_handler   = &arlan_sysctl_inforxRing,
 921         },
 922         {
 923                 .ctl_name       = 152,
 924                 .procname       = "arlan0-18",
 925                 .data           = &arlan_drive_info,
 926                 .maxlen         = ARLAN_STR_SIZE,
 927                 .mode           = 0400,
 928                 .proc_handler   = &arlan_sysctl_info18,
 929         },
 930         {
 931                 .ctl_name       = 153,
 932                 .procname       = "arlan0-ring",
 933                 .data           = &arlan_drive_info,
 934                 .maxlen         = ARLAN_STR_SIZE,
 935                 .mode           = 0400,
 936                 .proc_handler   = &arlan_sysctl_info161719,
 937         },
 938         {
 939                 .ctl_name       = 154,
 940                 .procname       = "arlan0-shm-cpy",
 941                 .data           = &arlan_drive_info,
 942                 .maxlen         = ARLAN_STR_SIZE,
 943                 .mode           = 0400,
 944                 .proc_handler   = &arlan_sysctl_info,
 945         },
 946 #endif
 947         {
 948                 .ctl_name       = 155,
 949                 .procname       = "config0",
 950                 .data           = &conf_reset_result,
 951                 .maxlen         = 100,
 952                 .mode           = 0400,
 953                 .proc_handler   = &arlan_configure
 954         },
 955         {
 956                 .ctl_name       = 156,
 957                 .procname       = "reset0",
 958                 .data           = &conf_reset_result,
 959                 .maxlen         = 100,
 960                 .mode           = 0400,
 961                 .proc_handler   = &arlan_sysctl_reset,
 962         },
 963         { .ctl_name = 0 }
 964 };
 965
 966 static ctl_table arlan_conf_table1[] =
 967 {
 968
 969         ARLAN_SYSCTL_TABLE_TOTAL(1)
 970
 971 #ifdef ARLAN_PROC_SHM_DUMP
 972         {
 973                 .ctl_name       = 150,
 974                 .procname       = "arlan1-txRing",
 975                 .data           = &arlan_drive_info,
 976                 .maxlen         = ARLAN_STR_SIZE,
 977                 .mode           = 0400,
 978                 .proc_handler   = &arlan_sysctl_infotxRing,
 979         },
 980         {
 981                 .ctl_name       = 151,
 982                 .procname       = "arlan1-rxRing",
 983                 .data           = &arlan_drive_info,
 984                 .maxlen         = ARLAN_STR_SIZE,
 985                 .mode           = 0400,
 986                 .proc_handler   = &arlan_sysctl_inforxRing,
 987         },
 988         {
 989                 .ctl_name       = 152,
 990                 .procname       = "arlan1-18",
 991                 .data           = &arlan_drive_info,
 992                 .maxlen         = ARLAN_STR_SIZE,
 993                 .mode           = 0400,
 994                 .proc_handler   = &arlan_sysctl_info18,
 995         },
 996         {
 997                 .ctl_name       = 153,
 998                 .procname       = "arlan1-ring",
 999                 .data           = &arlan_drive_info,
1000                 .maxlen         = ARLAN_STR_SIZE,
1001                 .mode           = 0400,
1002                 .proc_handler   = &arlan_sysctl_info161719,
1003         },
1004         {
1005                 .ctl_name       = 154,
1006                 .procname       = "arlan1-shm-cpy",
1007                 .data           = &arlan_drive_info,
1008                 .maxlen         = ARLAN_STR_SIZE,
1009                 .mode           = 0400,
1010                 .proc_handler   = &arlan_sysctl_info,
1011         },
1012 #endif
1013         {
1014                 .ctl_name       = 155,
1015                 .procname       = "config1",
1016                 .data           = &conf_reset_result,
1017                 .maxlen         = 100,
1018                 .mode           = 0400,
1019                 .proc_handler   = &arlan_configure,
1020         },
1021         {
1022                 .ctl_name       = 156,
1023                 .procname       = "reset1",
1024                 .data           = &conf_reset_result,
1025                 .maxlen         = 100,
1026                 .mode           = 0400,
1027                 .proc_handler   = &arlan_sysctl_reset,
1028         },
1029         { .ctl_name = 0 }
1030 };
1031
1032 static ctl_table arlan_conf_table2[] =
1033 {
1034
1035         ARLAN_SYSCTL_TABLE_TOTAL(2)
1036
1037 #ifdef ARLAN_PROC_SHM_DUMP
1038         {
1039                 .ctl_name       = 150,
1040                 .procname       = "arlan2-txRing",
1041                 .data           = &arlan_drive_info,
1042                 .maxlen         = ARLAN_STR_SIZE,
1043                 .mode           = 0400,
1044                 .proc_handler   = &arlan_sysctl_infotxRing,
1045         },
1046         {
1047                 .ctl_name       = 151,
1048                 .procname       = "arlan2-rxRing",
1049                 .data           = &arlan_drive_info,
1050                 .maxlen         = ARLAN_STR_SIZE,
1051                 .mode           = 0400,
1052                 .proc_handler   = &arlan_sysctl_inforxRing,
1053         },
1054         {
1055                 .ctl_name       = 152,
1056                 .procname       = "arlan2-18",
1057                 .data           = &arlan_drive_info,
1058                 .maxlen         = ARLAN_STR_SIZE,
1059                 .mode           = 0400,
1060                 .proc_handler   = &arlan_sysctl_info18,
1061         },
1062         {
1063                 .ctl_name       = 153,
1064                 .procname       = "arlan2-ring",
1065                 .data           = &arlan_drive_info,
1066                 .maxlen         = ARLAN_STR_SIZE,
1067                 .mode           = 0400,
1068                 .proc_handler   = &arlan_sysctl_info161719,
1069         },
1070         {
1071                 .ctl_name       = 154,
1072                 .procname       = "arlan2-shm-cpy",
1073                 .data           = &arlan_drive_info,
1074                 .maxlen         = ARLAN_STR_SIZE,
1075                 .mode           = 0400,
1076                 .proc_handler   = &arlan_sysctl_info,
1077         },
1078 #endif
1079         {
1080                 .ctl_name       = 155,
1081                 .procname       = "config2",
1082                 .data           = &conf_reset_result,
1083                 .maxlen         = 100,
1084                 .mode           = 0400,
1085                 .proc_handler   = &arlan_configure,
1086         },
1087         {
1088                 .ctl_name       = 156,
1089                 .procname       = "reset2",
1090                 .data           = &conf_reset_result,
1091                 .maxlen         = 100,
1092                 .mode           = 0400,
1093                 .proc_handler   = &arlan_sysctl_reset,
1094         },
1095         { .ctl_name = 0 }
1096 };
1097
1098 static ctl_table arlan_conf_table3[] =
1099 {
1100
1101         ARLAN_SYSCTL_TABLE_TOTAL(3)
1102
1103 #ifdef ARLAN_PROC_SHM_DUMP
1104         {
1105                 .ctl_name       = 150,
1106                 .procname       = "arlan3-txRing",
1107                 .data           = &arlan_drive_info,
1108                 .maxlen         = ARLAN_STR_SIZE,
1109                 .mode           = 0400,
1110                 .proc_handler   = &arlan_sysctl_infotxRing,
1111         },
1112         {
1113                 .ctl_name       = 151,
1114                 .procname       = "arlan3-rxRing",
1115                 .data           = &arlan_drive_info,
1116                 .maxlen         = ARLAN_STR_SIZE,
1117                 .mode           = 0400,
1118                 .proc_handler   = &arlan_sysctl_inforxRing,
1119         },
1120         {
1121                 .ctl_name       = 152,
1122                 .procname       = "arlan3-18",
1123                 .data           = &arlan_drive_info,
1124                 .maxlen         = ARLAN_STR_SIZE,
1125                 .mode           = 0400,
1126                 .proc_handler   = &arlan_sysctl_info18,
1127         },
1128         {
1129                 .ctl_name       = 153,
1130                 .procname       = "arlan3-ring",
1131                 .data           = &arlan_drive_info,
1132                 .maxlen         = ARLAN_STR_SIZE,
1133                 .mode           = 0400,
1134                 .proc_handler   = &arlan_sysctl_info161719,
1135         },
1136         {
1137                 .ctl_name       = 154,
1138                 .procname       = "arlan3-shm-cpy",
1139                 .data           = &arlan_drive_info,
1140                 .maxlen         = ARLAN_STR_SIZE,
1141                 .mode           = 0400,
1142                 .proc_handler   = &arlan_sysctl_info,
1143         },
1144 #endif
1145         {
1146                 .ctl_name       = 155,
1147                 .procname       = "config3",
1148                 .data           = &conf_reset_result,
1149                 .maxlen         = 100,
1150                 .mode           = 0400,
1151                 .proc_handler   = &arlan_configure,
1152         },
1153         {
1154                 .ctl_name       = 156,
1155                 .procname       = "reset3",
1156                 .data           = &conf_reset_result,
1157                 .maxlen         = 100,
1158                 .mode           = 0400,
1159                 .proc_handler   = &arlan_sysctl_reset,
1160         },
1161         { .ctl_name = 0 }
1162 };
1163
1164
1165
1166 static ctl_table arlan_table[] =
1167 {
1168         {
1169                 .ctl_name       = 0,
1170                 .procname       = "arlan0",
1171                 .maxlen         = 0,
1172                 .mode           = 0600,
1173                 .child          = arlan_conf_table0,
1174         },
1175         {
1176                 .ctl_name       = 0,
1177                 .procname       = "arlan1",
1178                 .maxlen         = 0,
1179                 .mode           = 0600,
1180                 .child          = arlan_conf_table1,
1181         },
1182         {
1183                 .ctl_name       = 0,
1184                 .procname       = "arlan2",
1185                 .maxlen         = 0,
1186                 .mode           = 0600,
1187                 .child          = arlan_conf_table2,
1188         },
1189         {
1190                 .ctl_name       = 0,
1191                 .procname       = "arlan3",
1192                 .maxlen         = 0,
1193                 .mode           = 0600,
1194                 .child          = arlan_conf_table3,
1195         },
1196         { .ctl_name = 0 }
1197 };
1198
1199 #else
1200
1201 static ctl_table arlan_table[MAX_ARLANS + 1] =
1202 {
1203         { .ctl_name = 0 }
1204 };
1205 #endif
1206 #else
1207
1208 static ctl_table arlan_table[MAX_ARLANS + 1] =
1209 {
1210         { .ctl_name = 0 }
1211 };
1212 #endif
1213
1214
1215 // static int mmtu = 1234;
1216
1217 static ctl_table arlan_root_table[] =
1218 {
1219         {
1220                 .ctl_name       = 254,
1221                 .procname       = "arlan",
1222                 .maxlen         = 0,
1223                 .mode           = 0555,
1224                 .child          = arlan_table,
1225         },
1226         { .ctl_name = 0 }
1227 };
1228
1229 /* Make sure that /proc/sys/dev is there */
1230 //static ctl_table arlan_device_root_table[] =
1231 //{
1232 //      {CTL_DEV, "dev", NULL, 0, 0555, arlan_root_table},
1233 //      {0}
1234 //};
1235
1236
1237 #ifdef CONFIG_PROC_FS
1238 static struct ctl_table_header *arlan_device_sysctl_header;
1239
1240 int __init init_arlan_proc(void)
1241 {
1242
1243         int i = 0;
1244         if (arlan_device_sysctl_header)
1245                 return 0;
1246         for (i = 0; i < MAX_ARLANS && arlan_device[i]; i++)
1247                 arlan_table[i].ctl_name = i + 1;
1248         arlan_device_sysctl_header = register_sysctl_table(arlan_root_table, 0);
1249         if (!arlan_device_sysctl_header)
1250                 return -1;
1251
1252         return 0;
1253
1254 }
1255
1256 void __exit cleanup_arlan_proc(void)
1257 {
1258         unregister_sysctl_table(arlan_device_sysctl_header);
1259         arlan_device_sysctl_header = NULL;
1260
1261 }
1262 #endif