]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
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 | ||
8d65af78 | 405 | static int arlan_sysctl_info(ctl_table * ctl, int write, |
1da177e4 LT |
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 | |
6dbc9c89 | 438 | priva = netdev_priv(arlan_device[devnum]); |
1da177e4 LT |
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) | |
8d65af78 | 632 | retv = proc_dostring(ctl, write, buffer, lenp, ppos); |
1da177e4 LT |
633 | else |
634 | { | |
635 | *lenp = 0; | |
636 | return -1; | |
637 | } | |
638 | return retv; | |
639 | } | |
640 | ||
641 | ||
8d65af78 | 642 | static int arlan_sysctl_info161719(ctl_table * ctl, int write, |
1da177e4 LT |
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 | |
6dbc9c89 | 657 | priva = netdev_priv(arlan_device[devnum]); |
1da177e4 LT |
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; | |
8d65af78 | 672 | retv = proc_dostring(ctl, write, buffer, lenp, ppos); |
1da177e4 LT |
673 | return retv; |
674 | } | |
675 | ||
8d65af78 | 676 | static int arlan_sysctl_infotxRing(ctl_table * ctl, int write, |
1da177e4 LT |
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 | |
6dbc9c89 | 691 | priva = netdev_priv(arlan_device[devnum]); |
1da177e4 LT |
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; | |
8d65af78 | 701 | retv = proc_dostring(ctl, write, buffer, lenp, ppos); |
1da177e4 LT |
702 | return retv; |
703 | } | |
704 | ||
8d65af78 | 705 | static int arlan_sysctl_inforxRing(ctl_table * ctl, int write, |
1da177e4 LT |
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 | |
6dbc9c89 | 719 | priva = netdev_priv(arlan_device[devnum]); |
1da177e4 LT |
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; | |
8d65af78 | 729 | retv = proc_dostring(ctl, write, buffer, lenp, ppos); |
1da177e4 LT |
730 | return retv; |
731 | } | |
732 | ||
8d65af78 | 733 | static int arlan_sysctl_info18(ctl_table * ctl, int write, |
1da177e4 LT |
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 | |
6dbc9c89 | 748 | priva = netdev_priv(arlan_device[devnum]); |
1da177e4 LT |
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; | |
8d65af78 | 759 | retv = proc_dostring(ctl, write, buffer, lenp, ppos); |
1da177e4 LT |
760 | return retv; |
761 | } | |
762 | ||
763 | ||
764 | #endif /* #ifdef ARLAN_PROC_SHM_DUMP */ | |
765 | ||
766 | ||
767 | static char conf_reset_result[200]; | |
768 | ||
8d65af78 | 769 | static int arlan_configure(ctl_table * ctl, int write, |
1da177e4 LT |
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 | { | |
6dbc9c89 | 783 | priv = netdev_priv(arlan_device[devnum]); |
1da177e4 LT |
784 | |
785 | arlan_command(arlan_device[devnum], ARLAN_COMMAND_CLEAN_AND_CONF); | |
786 | } | |
787 | else | |
788 | return -1; | |
789 | ||
790 | *lenp = pos; | |
8d65af78 | 791 | return proc_dostring(ctl, write, buffer, lenp, ppos); |
1da177e4 LT |
792 | } |
793 | ||
8d65af78 | 794 | static int arlan_sysctl_reset(ctl_table * ctl, int write, |
1da177e4 LT |
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 | { | |
6dbc9c89 | 808 | priv = netdev_priv(arlan_device[devnum]); |
1da177e4 LT |
809 | arlan_command(arlan_device[devnum], ARLAN_COMMAND_CLEAN_AND_RESET); |
810 | ||
811 | } else | |
812 | return -1; | |
813 | *lenp = pos + 3; | |
8d65af78 | 814 | return proc_dostring(ctl, write, buffer, lenp, ppos); |
1da177e4 LT |
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 | ||
1da177e4 LT |
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 | { | |
59fc5313 | 1212 | .ctl_name = CTL_ARLAN, |
1da177e4 LT |
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 | ||
1da177e4 LT |
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; | |
0b4d4147 | 1239 | arlan_device_sysctl_header = register_sysctl_table(arlan_root_table); |
1da177e4 LT |
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 |