?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[ARM] pxa: Gumstix Verdex PCMCIA support
[linux-2.6/verdex.git] / drivers / net / wireless / arlan-proc.c
bloba8b689635a3ba1a45862bc99ccf9813e09ecf41c
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,
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, 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,
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, buffer, lenp, ppos);
673 return retv;
674 }
675
676 static int arlan_sysctl_infotxRing(ctl_table * ctl, int write,
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, buffer, lenp, ppos);
702 return retv;
703 }
704
705 static int arlan_sysctl_inforxRing(ctl_table * ctl, int write,
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, buffer, lenp, ppos);
730 return retv;
731 }
732
733 static int arlan_sysctl_info18(ctl_table * ctl, int write,
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, 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,
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, buffer, lenp, ppos);
792 }
793
794 static int arlan_sysctl_reset(ctl_table * ctl, int write,
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, 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
Verdex Pro support