i386/linux/linux-2.3.21/drivers/net/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
   9 #include <linux/version.h>
  10
  11 /* void enableReceive(struct net_device* dev);
  12 */
  13
  14 static  int     arlan_command(struct net_device * dev, int command);
  15
  16
  17 #define ARLAN_STR_SIZE  0x2ff0
  18 #define DEV_ARLAN_INFO  1
  19 #define DEV_ARLAN       1
  20 #define SARLG(type,var) {\
  21         pos += sprintf(arlan_drive_info+pos, "%s\t=\t0x%x\n", #var, READSHMB(priva->card->var));        \
  22         }
  23
  24 #define SARLBN(type,var,nn) {\
  25         pos += sprintf(arlan_drive_info+pos, "%s\t=\t0x",#var);\
  26         for (i=0; i < nn; i++ ) pos += sprintf(arlan_drive_info+pos, "%02x",READSHMB(priva->card->var[i]));\
  27         pos += sprintf(arlan_drive_info+pos, "\n");     \
  28         }
  29
  30 #define SARLBNpln(type,var,nn) {\
  31         for (i=0; i < nn; i++ ) pos += sprintf(arlan_drive_info+pos, "%02x",READSHMB(priva->card->var[i]));\
  32         }
  33
  34 #define SARLSTR(var,nn) {\
  35         char tmpStr[400];\
  36         int  tmpLn = nn;\
  37         if (nn > 399 ) tmpLn = 399; \
  38         memcpy(tmpStr,(char *) priva->conf->var,tmpLn);\
  39         tmpStr[tmpLn] = 0; \
  40         pos += sprintf(arlan_drive_info+pos, "%s\t=\t%s \n",#var,priva->conf->var);\
  41         }
  42
  43 #define SARLUC(var)     SARLG(u_char, var)
  44 #define SARLUCN(var,nn) SARLBN(u_char,var, nn)
  45 #define SARLUS(var)     SARLG(u_short, var)
  46 #define SARLUSN(var,nn) SARLBN(u_short,var, nn)
  47 #define SARLUI(var)     SARLG(u_int, var)
  48
  49 #define SARLUSA(var) {\
  50         u_short tmpVar;\
  51         memcpy(&tmpVar, (short *) priva->conf->var,2); \
  52         pos += sprintf(arlan_drive_info+pos, "%s\t=\t0x%x\n",#var, tmpVar);\
  53 }
  54
  55 #define SARLUIA(var) {\
  56         u_int tmpVar;\
  57         memcpy(&tmpVar, (int* )priva->conf->var,4); \
  58         pos += sprintf(arlan_drive_info+pos, "%s\t=\t0x%x\n",#var, tmpVar);\
  59 }
  60
  61
  62 const char *arlan_diagnostic_info_string(struct net_device *dev)
  63 {
  64
  65         volatile struct arlan_shmem *arlan = ((struct arlan_private *) dev->priv)->card;
  66         u_char diagnosticInfo;
  67
  68         READSHM(diagnosticInfo, arlan->diagnosticInfo, u_char);
  69
  70         switch (diagnosticInfo)
  71         {
  72                 case 0xFF:
  73                         return "Diagnostic info is OK";
  74                 case 0xFE:
  75                         return "ERROR EPROM Checksum error ";
  76                 case 0xFD:
  77                         return "ERROR Local Ram Test Failed ";
  78                 case 0xFC:
  79                         return "ERROR SCC failure ";
  80                 case 0xFB:
  81                         return "ERROR BackBone failure ";
  82                 case 0xFA:
  83                         return "ERROR tranceiver not found ";
  84                 case 0xF9:
  85                         return "ERROR no more address space ";
  86                 case 0xF8:
  87                         return "ERROR Checksum error  ";
  88                 case 0xF7:
  89                         return "ERROR Missing SS Code";
  90                 case 0xF6:
  91                         return "ERROR Invalid config format";
  92                 case 0xF5:
  93                         return "ERROR Reserved errorcode F5";
  94                 case 0xF4:
  95                         return "ERROR Invalid spreading code/channel number";
  96                 case 0xF3:
  97                         return "ERROR Load Code Error";
  98                 case 0xF2:
  99                         return "ERROR Reserver errorcode F2 ";
 100                 case 0xF1:
 101                         return "ERROR Invalid command receivec by LAN card ";
 102                 case 0xF0:
 103                         return "ERROR Invalid parameter found in command ";
 104                 case 0xEF:
 105                         return "ERROR On-chip timer failure ";
 106                 case 0xEE:
 107                         return "ERROR T410 timer failure ";
 108                 case 0xED:
 109                         return "ERROR Too Many TxEnable commands ";
 110                 case 0xEC:
 111                         return "ERROR EEPROM error on radio module ";
 112                 default:
 113                         return "ERROR unknown Diagnostic info reply code ";
 114           }
 115 };
 116
 117 static const char *arlan_hardware_type_string(struct net_device *dev)
 118 {
 119         u_char hardwareType;
 120         volatile struct arlan_shmem *arlan = ((struct arlan_private *) dev->priv)->card;
 121
 122         READSHM(hardwareType, arlan->hardwareType, u_char);
 123         switch (hardwareType)
 124         {
 125                 case 0x00:
 126                         return "type A450";
 127                 case 0x01:
 128                         return "type A650 ";
 129                 case 0x04:
 130                         return "type TMA coproc";
 131                 case 0x0D:
 132                         return "type A650E ";
 133                 case 0x18:
 134                         return "type TMA coproc Australian";
 135                 case 0x19:
 136                         return "type A650A ";
 137                 case 0x26:
 138                         return "type TMA coproc European";
 139                 case 0x2E:
 140                         return "type A655 ";
 141                 case 0x2F:
 142                         return "type A655A ";
 143                 case 0x30:
 144                         return "type A655E ";
 145                 case 0x0B:
 146                         return "type A670 ";
 147                 case 0x0C:
 148                         return "type A670E ";
 149                 case 0x2D:
 150                         return "type A670A ";
 151                 case 0x0F:
 152                         return "type A411T";
 153                 case 0x16:
 154                         return "type A411TA";
 155                 case 0x1B:
 156                         return "type A440T";
 157                 case 0x1C:
 158                         return "type A412T";
 159                 case 0x1E:
 160                         return "type A412TA";
 161                 case 0x22:
 162                         return "type A411TE";
 163                 case 0x24:
 164                         return "type A412TE";
 165                 case 0x27:
 166                         return "type A671T ";
 167                 case 0x29:
 168                         return "type A671TA ";
 169                 case 0x2B:
 170                         return "type A671TE ";
 171                 case 0x31:
 172                         return "type A415T ";
 173                 case 0x33:
 174                         return "type A415TA ";
 175                 case 0x35:
 176                         return "type A415TE ";
 177                 case 0x37:
 178                         return "type A672";
 179                 case 0x39:
 180                         return "type A672A ";
 181                 case 0x3B:
 182                         return "type A672T";
 183                 case 0x6B:
 184                         return "type IC2200";
 185                 default:
 186                         return "type A672T";
 187         }
 188 }
 189
 190 static void arlan_print_diagnostic_info(struct net_device *dev)
 191 {
 192         int i;
 193         u_char diagnosticInfo;
 194         u_short diagnosticOffset;
 195         u_char hardwareType;
 196         volatile struct arlan_shmem *arlan = ((struct arlan_private *) dev->priv)->card;
 197
 198         //  ARLAN_DEBUG_ENTRY("arlan_print_diagnostic_info");
 199
 200         if (READSHMB(arlan->configuredStatusFlag) == 0)
 201                 printk("Arlan: Card NOT configured\n");
 202         else
 203                 printk("Arlan: Card is configured\n");
 204
 205         READSHM(diagnosticInfo, arlan->diagnosticInfo, u_char);
 206         READSHM(diagnosticOffset, arlan->diagnosticOffset, u_short);
 207
 208         printk(KERN_INFO "%s\n", arlan_diagnostic_info_string(dev));
 209
 210         if (diagnosticInfo != 0xff)
 211                 printk("%s arlan: Diagnostic Offset %d \n", dev->name, diagnosticOffset);
 212
 213         printk("arlan: LAN CODE ID = ");
 214         for (i = 0; i < 6; i++)
 215                 DEBUGSHM(1, "%03d:", arlan->lanCardNodeId[i], u_char);
 216         printk("\n");
 217
 218         printk("arlan: Arlan BroadCast address  = ");
 219         for (i = 0; i < 6; i++)
 220                 DEBUGSHM(1, "%03d:", arlan->broadcastAddress[i], u_char);
 221         printk("\n");
 222
 223         READSHM(hardwareType, arlan->hardwareType, u_char);
 224         printk(KERN_INFO "%s\n", arlan_hardware_type_string(dev));
 225
 226
 227         DEBUGSHM(1, "arlan: channelNumber=%d\n", arlan->channelNumber, u_char);
 228         DEBUGSHM(1, "arlan: channelSet=%d\n", arlan->channelSet, u_char);
 229         DEBUGSHM(1, "arlan: spreadingCode=%d\n", arlan->spreadingCode, u_char);
 230         DEBUGSHM(1, "arlan: radioNodeId=%d\n", arlan->radioNodeId, u_short);
 231         DEBUGSHM(1, "arlan: SID =%d\n", arlan->SID, u_short);
 232         DEBUGSHM(1, "arlan: rxOffset=%d\n", arlan->rxOffset, u_short);
 233
 234         DEBUGSHM(1, "arlan: registration mode is %d\n", arlan->registrationMode, u_char);
 235
 236         printk("arlan: name= ");
 237         IFDEBUG(1)
 238
 239         for (i = 0; i < 16; i++)
 240         {
 241                 char c;
 242                 READSHM(c, arlan->name[i], char);
 243                 if (c)
 244                         printk("%c", c);
 245         }
 246         printk("\n");
 247
 248 //   ARLAN_DEBUG_EXIT("arlan_print_diagnostic_info");
 249
 250 }
 251
 252
 253 /******************************         TEST    MEMORY  **************/
 254
 255 static int arlan_hw_test_memory(struct net_device *dev)
 256 {
 257         u_char *ptr;
 258         int i;
 259         int memlen = sizeof(struct arlan_shmem) - 0xF;  /* avoid control register */
 260         volatile char *arlan_mem = (char *) (dev->mem_start);
 261         volatile struct arlan_shmem *arlan = ((struct arlan_private *) dev->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
 324 static int arlan_setup_card_by_book(struct net_device *dev)
 325 {
 326         u_char irqLevel, configuredStatusFlag;
 327         volatile struct arlan_shmem *arlan = ((struct arlan_private *) dev->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 interupt */
 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
 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 *buffer, size_t * lenp)
 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);
 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 *buffer, size_t * lenp)
 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);
 674         return retv;
 675 }
 676
 677 static int arlan_sysctl_infotxRing(ctl_table * ctl, int write, struct file *filp,
 678                             void *buffer, size_t * lenp)
 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);
 703         return retv;
 704 }
 705
 706 static int arlan_sysctl_inforxRing(ctl_table * ctl, int write, struct file *filp,
 707                             void *buffer, size_t * lenp)
 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);
 731         return retv;
 732 }
 733
 734 static int arlan_sysctl_info18(ctl_table * ctl, int write, struct file *filp,
 735                         void *buffer, size_t * lenp)
 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);
 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 *buffer, size_t * lenp)
 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);
 793 }
 794
 795 int arlan_sysctl_reset(ctl_table * ctl, int write, struct file *filp,
 796                        void *buffer, size_t * lenp)
 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);
 816 }
 817
 818
 819 /* Place files in /proc/sys/dev/arlan */
 820 #define CTBLN(num,card,nam) \
 821         {num , #nam, &(arlan_conf[card].nam), \
 822          sizeof(int), 0600, NULL, &proc_dointvec}
 823
 824
 825 #define ARLAN_SYSCTL_TABLE_TOTAL(cardNo)\
 826         CTBLN(1,cardNo,spreadingCode),\
 827         CTBLN(2,cardNo, channelNumber),\
 828         CTBLN(3,cardNo, scramblingDisable),\
 829         CTBLN(4,cardNo, txAttenuation),\
 830         CTBLN(5,cardNo, systemId), \
 831         CTBLN(6,cardNo, maxDatagramSize),\
 832         CTBLN(7,cardNo, maxFrameSize),\
 833         CTBLN(8,cardNo, maxRetries),\
 834         CTBLN(9,cardNo, receiveMode),\
 835         CTBLN(10,cardNo, priority),\
 836         CTBLN(11,cardNo, rootOrRepeater),\
 837         CTBLN(12,cardNo, SID),\
 838         CTBLN(13,cardNo, registrationMode),\
 839         CTBLN(14,cardNo, registrationFill),\
 840         CTBLN(15,cardNo, localTalkAddress),\
 841         CTBLN(16,cardNo, codeFormat),\
 842         CTBLN(17,cardNo, numChannels),\
 843         CTBLN(18,cardNo, channel1),\
 844         CTBLN(19,cardNo, channel2),\
 845         CTBLN(20,cardNo, channel3),\
 846         CTBLN(21,cardNo, channel4),\
 847         CTBLN(22,cardNo, txClear),\
 848         CTBLN(23,cardNo, txRetries),\
 849         CTBLN(24,cardNo, txRouting),\
 850         CTBLN(25,cardNo, txScrambled),\
 851         CTBLN(26,cardNo, rxParameter),\
 852         CTBLN(27,cardNo, txTimeoutMs),\
 853         CTBLN(28,cardNo, waitCardTimeout),\
 854         CTBLN(29,cardNo, channelSet), \
 855         {30, "name", arlan_conf[cardNo].siteName, \
 856                 16, 0600, NULL, &proc_dostring},\
 857         CTBLN(31,cardNo,waitTime),\
 858         CTBLN(32,cardNo,lParameter),\
 859         CTBLN(33,cardNo,_15),\
 860         CTBLN(34,cardNo,headerSize),\
 861         CTBLN(35,cardNo,async),\
 862         CTBLN(36,cardNo,tx_delay_ms),\
 863         CTBLN(37,cardNo,retries),\
 864         CTBLN(38,cardNo,ReTransmitPacketMaxSize),\
 865         CTBLN(39,cardNo,waitReTransmitPacketMaxSize),\
 866         CTBLN(40,cardNo,fastReTransCount),\
 867         CTBLN(41,cardNo,driverRetransmissions),\
 868         CTBLN(42,cardNo,txAckTimeoutMs),\
 869         CTBLN(43,cardNo,registrationInterrupts),\
 870         CTBLN(44,cardNo,hardwareType),\
 871         CTBLN(45,cardNo,radioType),\
 872         CTBLN(46,cardNo,writeEEPROM),\
 873         CTBLN(47,cardNo,writeRadioType),\
 874         {48, "entry_exit_debug", &arlan_entry_and_exit_debug, \
 875                 sizeof(int), 0600, NULL, &proc_dointvec},\
 876         {49, "debug", &arlan_debug, \
 877                 sizeof(int), 0600, NULL, &proc_dointvec},\
 878         CTBLN(50,cardNo,in_speed),\
 879         CTBLN(51,cardNo,out_speed),\
 880         CTBLN(52,cardNo,in_speed10),\
 881         CTBLN(53,cardNo,out_speed10),\
 882         CTBLN(54,cardNo,in_speed_max),\
 883         CTBLN(55,cardNo,out_speed_max),\
 884         CTBLN(56,cardNo,measure_rate),\
 885         CTBLN(57,cardNo,pre_Command_Wait),\
 886         CTBLN(58,cardNo,rx_tweak1),\
 887         CTBLN(59,cardNo,rx_tweak2),\
 888         CTBLN(60,cardNo,tx_queue_len),\
 889
 890
 891
 892 static ctl_table arlan_conf_table0[] =
 893 {
 894         ARLAN_SYSCTL_TABLE_TOTAL(0)
 895
 896 #ifdef ARLAN_PROC_SHM_DUMP
 897         {150, "arlan0-txRing", &arlan_drive_info,
 898          ARLAN_STR_SIZE, 0400, NULL, &arlan_sysctl_infotxRing},
 899         {151, "arlan0-rxRing", &arlan_drive_info,
 900          ARLAN_STR_SIZE, 0400, NULL, &arlan_sysctl_inforxRing},
 901         {152, "arlan0-18", &arlan_drive_info,
 902          ARLAN_STR_SIZE, 0400, NULL, &arlan_sysctl_info18},
 903         {153, "arlan0-ring", &arlan_drive_info,
 904          ARLAN_STR_SIZE, 0400, NULL, &arlan_sysctl_info161719},
 905         {154, "arlan0-shm-cpy", &arlan_drive_info,
 906          ARLAN_STR_SIZE, 0400, NULL, &arlan_sysctl_info},
 907 #endif
 908         {155, "config0", &conf_reset_result, \
 909          100, 0400, NULL, &arlan_configure}, \
 910         {156, "reset0", &conf_reset_result, \
 911          100, 0400, NULL, &arlan_sysctl_reset}, \
 912         {0}
 913 };
 914
 915 static ctl_table arlan_conf_table1[] =
 916 {
 917
 918         ARLAN_SYSCTL_TABLE_TOTAL(1)
 919
 920 #ifdef ARLAN_PROC_SHM_DUMP
 921         {150, "arlan1-txRing", &arlan_drive_info,
 922          ARLAN_STR_SIZE, 0400, NULL, &arlan_sysctl_infotxRing},
 923         {151, "arlan1-rxRing", &arlan_drive_info,
 924          ARLAN_STR_SIZE, 0400, NULL, &arlan_sysctl_inforxRing},
 925         {152, "arlan1-18", &arlan_drive_info,
 926          ARLAN_STR_SIZE, 0400, NULL, &arlan_sysctl_info18},
 927         {153, "arlan1-ring", &arlan_drive_info,
 928          ARLAN_STR_SIZE, 0400, NULL, &arlan_sysctl_info161719},
 929         {154, "arlan1-shm-cpy", &arlan_drive_info,
 930          ARLAN_STR_SIZE, 0400, NULL, &arlan_sysctl_info},
 931 #endif
 932         {155, "config1", &conf_reset_result,
 933          100, 0400, NULL, &arlan_configure},
 934         {156, "reset1", &conf_reset_result,
 935          100, 0400, NULL, &arlan_sysctl_reset},
 936         {0}
 937 };
 938
 939 static ctl_table arlan_conf_table2[] =
 940 {
 941
 942         ARLAN_SYSCTL_TABLE_TOTAL(2)
 943
 944 #ifdef ARLAN_PROC_SHM_DUMP
 945         {150, "arlan2-txRing", &arlan_drive_info,
 946          ARLAN_STR_SIZE, 0400, NULL, &arlan_sysctl_infotxRing},
 947         {151, "arlan2-rxRing", &arlan_drive_info,
 948          ARLAN_STR_SIZE, 0400, NULL, &arlan_sysctl_inforxRing},
 949         {152, "arlan2-18", &arlan_drive_info,
 950          ARLAN_STR_SIZE, 0400, NULL, &arlan_sysctl_info18},
 951         {153, "arlan2-ring", &arlan_drive_info,
 952          ARLAN_STR_SIZE, 0400, NULL, &arlan_sysctl_info161719},
 953         {154, "arlan2-shm-cpy", &arlan_drive_info,
 954          ARLAN_STR_SIZE, 0400, NULL, &arlan_sysctl_info},
 955 #endif
 956         {155, "config2", &conf_reset_result,
 957          100, 0400, NULL, &arlan_configure},
 958         {156, "reset2", &conf_reset_result,
 959          100, 0400, NULL, &arlan_sysctl_reset},
 960         {0}
 961 };
 962
 963 static ctl_table arlan_conf_table3[] =
 964 {
 965
 966         ARLAN_SYSCTL_TABLE_TOTAL(3)
 967
 968 #ifdef ARLAN_PROC_SHM_DUMP
 969         {150, "arlan3-txRing", &arlan_drive_info,
 970          ARLAN_STR_SIZE, 0400, NULL, &arlan_sysctl_infotxRing},
 971         {151, "arlan3-rxRing", &arlan_drive_info,
 972          ARLAN_STR_SIZE, 0400, NULL, &arlan_sysctl_inforxRing},
 973         {152, "arlan3-18", &arlan_drive_info,
 974          ARLAN_STR_SIZE, 0400, NULL, &arlan_sysctl_info18},
 975         {153, "arlan3-ring", &arlan_drive_info,
 976          ARLAN_STR_SIZE, 0400, NULL, &arlan_sysctl_info161719},
 977         {154, "arlan3-shm-cpy", &arlan_drive_info,
 978          ARLAN_STR_SIZE, 0400, NULL, &arlan_sysctl_info},
 979 #endif
 980         {155, "config3", &conf_reset_result,
 981          100, 0400, NULL, &arlan_configure},
 982         {156, "reset3", &conf_reset_result,
 983          100, 0400, NULL, &arlan_sysctl_reset},
 984         {0}
 985 };
 986
 987
 988
 989 static ctl_table arlan_table[] =
 990 {
 991         {0, "arlan0", NULL, 0, 0600, arlan_conf_table0},
 992         {0, "arlan1", NULL, 0, 0600, arlan_conf_table1},
 993         {0, "arlan2", NULL, 0, 0600, arlan_conf_table2},
 994         {0, "arlan3", NULL, 0, 0600, arlan_conf_table3},
 995         {0}
 996 };
 997
 998 #else
 999
1000 static ctl_table arlan_table[MAX_ARLANS + 1] =
1001 {
1002         {0}
1003 };
1004 #endif
1005 #else
1006
1007 static ctl_table arlan_table[MAX_ARLANS + 1] =
1008 {
1009         {0}
1010 };
1011 #endif
1012
1013 static int mmtu = 1234;
1014
1015 static ctl_table arlan_root_table[] =
1016 {
1017         {254, "arlan", NULL, 0, 0555, arlan_table},
1018         {0}
1019 };
1020
1021 /* Make sure that /proc/sys/dev is there */
1022 static ctl_table arlan_device_root_table[] =
1023 {
1024         {CTL_DEV, "dev", NULL, 0, 0555, arlan_root_table},
1025         {0}
1026 };
1027
1028
1029
1030 static struct ctl_table_header *arlan_device_sysctl_header = NULL;
1031
1032 int init_arlan_proc(void)
1033 {
1034
1035         int i = 0;
1036         if (arlan_device_sysctl_header)
1037                 return 0;
1038         for (i = 0; i < MAX_ARLANS && arlan_device[i]; i++)
1039                 arlan_table[i].ctl_name = i + 1;
1040         arlan_device_sysctl_header = register_sysctl_table(arlan_root_table, 0);
1041         if (!arlan_device_sysctl_header)
1042                 return -1;
1043
1044         return 0;
1045
1046 };
1047
1048
1049
1050 #ifdef MODULE
1051
1052 int init_module(void)
1053 {
1054
1055         return init_arlan_proc();
1056 };
1057
1058 void cleanup_module(void)
1059 {
1060         unregister_sysctl_table(arlan_device_sysctl_header);
1061         arlan_device_sysctl_header = NULL;
1062
1063         return;
1064 };
1065
1066 #endif                          // MODULE