git.oblomov.eu Git - linux-2.6/blob - drivers/net/wireless/arlan-proc.c

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