lisa/android_kernel_xiaomi_sm8350
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
c73e4486bc
android_kernel_xiaomi_sm8350/drivers/net/wireless/arlan-proc.c
Linus Torvalds 1da177e4c3 Linux-2.6.12-rc2 
Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.

Let it rip!
2005-04-16 15:20:36 -07:00

1263 lines
29 KiB
C
Raw Blame History

#include <linux/config.h>
#include "arlan.h"
#include <linux/sysctl.h>
#ifdef CONFIG_PROC_FS
/* void enableReceive(struct net_device* dev);
*/
#define ARLAN_STR_SIZE 0x2ff0
#define DEV_ARLAN_INFO 1
#define DEV_ARLAN 1
#define SARLG(type,var) {\
pos += sprintf(arlan_drive_info+pos, "%s\t=\t0x%x\n", #var, READSHMB(priva->card->var)); \
}
#define SARLBN(type,var,nn) {\
pos += sprintf(arlan_drive_info+pos, "%s\t=\t0x",#var);\
for (i=0; i < nn; i++ ) pos += sprintf(arlan_drive_info+pos, "%02x",READSHMB(priva->card->var[i]));\
pos += sprintf(arlan_drive_info+pos, "\n"); \
}
#define SARLBNpln(type,var,nn) {\
for (i=0; i < nn; i++ ) pos += sprintf(arlan_drive_info+pos, "%02x",READSHMB(priva->card->var[i]));\
}
#define SARLSTR(var,nn) {\
char tmpStr[400];\
int tmpLn = nn;\
if (nn > 399 ) tmpLn = 399; \
memcpy(tmpStr,(char *) priva->conf->var,tmpLn);\
tmpStr[tmpLn] = 0; \
pos += sprintf(arlan_drive_info+pos, "%s\t=\t%s \n",#var,priva->conf->var);\
}
#define SARLUC(var) SARLG(u_char, var)
#define SARLUCN(var,nn) SARLBN(u_char,var, nn)
#define SARLUS(var) SARLG(u_short, var)
#define SARLUSN(var,nn) SARLBN(u_short,var, nn)
#define SARLUI(var) SARLG(u_int, var)
#define SARLUSA(var) {\
u_short tmpVar;\
memcpy(&tmpVar, (short *) priva->conf->var,2); \
pos += sprintf(arlan_drive_info+pos, "%s\t=\t0x%x\n",#var, tmpVar);\
}
#define SARLUIA(var) {\
u_int tmpVar;\
memcpy(&tmpVar, (int* )priva->conf->var,4); \
pos += sprintf(arlan_drive_info+pos, "%s\t=\t0x%x\n",#var, tmpVar);\
}
static const char *arlan_diagnostic_info_string(struct net_device *dev)
{
struct arlan_private *priv = netdev_priv(dev);
volatile struct arlan_shmem __iomem *arlan = priv->card;
u_char diagnosticInfo;
READSHM(diagnosticInfo, arlan->diagnosticInfo, u_char);
switch (diagnosticInfo)
{
case 0xFF:
return "Diagnostic info is OK";
case 0xFE:
return "ERROR EPROM Checksum error ";
case 0xFD:
return "ERROR Local Ram Test Failed ";
case 0xFC:
return "ERROR SCC failure ";
case 0xFB:
return "ERROR BackBone failure ";
case 0xFA:
return "ERROR transceiver not found ";
case 0xF9:
return "ERROR no more address space ";
case 0xF8:
return "ERROR Checksum error ";
case 0xF7:
return "ERROR Missing SS Code";
case 0xF6:
return "ERROR Invalid config format";
case 0xF5:
return "ERROR Reserved errorcode F5";
case 0xF4:
return "ERROR Invalid spreading code/channel number";
case 0xF3:
return "ERROR Load Code Error";
case 0xF2:
return "ERROR Reserver errorcode F2 ";
case 0xF1:
return "ERROR Invalid command receivec by LAN card ";
case 0xF0:
return "ERROR Invalid parameter found in command ";
case 0xEF:
return "ERROR On-chip timer failure ";
case 0xEE:
return "ERROR T410 timer failure ";
case 0xED:
return "ERROR Too Many TxEnable commands ";
case 0xEC:
return "ERROR EEPROM error on radio module ";
default:
return "ERROR unknown Diagnostic info reply code ";
}
}
static const char *arlan_hardware_type_string(struct net_device *dev)
{
u_char hardwareType;
struct arlan_private *priv = netdev_priv(dev);
volatile struct arlan_shmem __iomem *arlan = priv->card;
READSHM(hardwareType, arlan->hardwareType, u_char);
switch (hardwareType)
{
case 0x00:
return "type A450";
case 0x01:
return "type A650 ";
case 0x04:
return "type TMA coproc";
case 0x0D:
return "type A650E ";
case 0x18:
return "type TMA coproc Australian";
case 0x19:
return "type A650A ";
case 0x26:
return "type TMA coproc European";
case 0x2E:
return "type A655 ";
case 0x2F:
return "type A655A ";
case 0x30:
return "type A655E ";
case 0x0B:
return "type A670 ";
case 0x0C:
return "type A670E ";
case 0x2D:
return "type A670A ";
case 0x0F:
return "type A411T";
case 0x16:
return "type A411TA";
case 0x1B:
return "type A440T";
case 0x1C:
return "type A412T";
case 0x1E:
return "type A412TA";
case 0x22:
return "type A411TE";
case 0x24:
return "type A412TE";
case 0x27:
return "type A671T ";
case 0x29:
return "type A671TA ";
case 0x2B:
return "type A671TE ";
case 0x31:
return "type A415T ";
case 0x33:
return "type A415TA ";
case 0x35:
return "type A415TE ";
case 0x37:
return "type A672";
case 0x39:
return "type A672A ";
case 0x3B:
return "type A672T";
case 0x6B:
return "type IC2200";
default:
return "type A672T";
}
}
#ifdef ARLAN_DEBUGGING
static void arlan_print_diagnostic_info(struct net_device *dev)
{
int i;
u_char diagnosticInfo;
u_short diagnosticOffset;
u_char hardwareType;
struct arlan_private *priv = netdev_priv(dev);
volatile struct arlan_shmem __iomem *arlan = priv->card;
// ARLAN_DEBUG_ENTRY("arlan_print_diagnostic_info");
if (READSHMB(arlan->configuredStatusFlag) == 0)
printk("Arlan: Card NOT configured\n");
else
printk("Arlan: Card is configured\n");
READSHM(diagnosticInfo, arlan->diagnosticInfo, u_char);
READSHM(diagnosticOffset, arlan->diagnosticOffset, u_short);
printk(KERN_INFO "%s\n", arlan_diagnostic_info_string(dev));
if (diagnosticInfo != 0xff)
printk("%s arlan: Diagnostic Offset %d \n", dev->name, diagnosticOffset);
printk("arlan: LAN CODE ID = ");
for (i = 0; i < 6; i++)
DEBUGSHM(1, "%03d:", arlan->lanCardNodeId[i], u_char);
printk("\n");
printk("arlan: Arlan BroadCast address = ");
for (i = 0; i < 6; i++)
DEBUGSHM(1, "%03d:", arlan->broadcastAddress[i], u_char);
printk("\n");
READSHM(hardwareType, arlan->hardwareType, u_char);
printk(KERN_INFO "%s\n", arlan_hardware_type_string(dev));
DEBUGSHM(1, "arlan: channelNumber=%d\n", arlan->channelNumber, u_char);
DEBUGSHM(1, "arlan: channelSet=%d\n", arlan->channelSet, u_char);
DEBUGSHM(1, "arlan: spreadingCode=%d\n", arlan->spreadingCode, u_char);
DEBUGSHM(1, "arlan: radioNodeId=%d\n", arlan->radioNodeId, u_short);
DEBUGSHM(1, "arlan: SID =%d\n", arlan->SID, u_short);
DEBUGSHM(1, "arlan: rxOffset=%d\n", arlan->rxOffset, u_short);
DEBUGSHM(1, "arlan: registration mode is %d\n", arlan->registrationMode, u_char);
printk("arlan: name= ");
IFDEBUG(1)
for (i = 0; i < 16; i++)
{
char c;
READSHM(c, arlan->name[i], char);
if (c)
printk("%c", c);
}
printk("\n");
// ARLAN_DEBUG_EXIT("arlan_print_diagnostic_info");
}
/****************************** TEST MEMORY **************/
static int arlan_hw_test_memory(struct net_device *dev)
{
u_char *ptr;
int i;
int memlen = sizeof(struct arlan_shmem) - 0xF; /* avoid control register */
volatile char *arlan_mem = (char *) (dev->mem_start);
struct arlan_private *priv = netdev_priv(dev);
volatile struct arlan_shmem __iomem *arlan = priv->card;
char pattern;
ptr = NULL;
/* hold card in reset state */
setHardwareReset(dev);
/* test memory */
pattern = 0;
for (i = 0; i < memlen; i++)
WRITESHM(arlan_mem[i], ((u_char) pattern++), u_char);
pattern = 0;
for (i = 0; i < memlen; i++)
{
char res;
READSHM(res, arlan_mem[i], char);
if (res != pattern++)
{
printk(KERN_ERR "Arlan driver memory test 1 failed \n");
return -1;
}
}
pattern = 0;
for (i = 0; i < memlen; i++)
WRITESHM(arlan_mem[i], ~(pattern++), char);
pattern = 0;
for (i = 0; i < memlen; i++)
{
char res;
READSHM(res, arlan_mem[i], char);
if (res != ~(pattern++))
{
printk(KERN_ERR "Arlan driver memory test 2 failed \n");
return -1;
}
}
/* zero memory */
for (i = 0; i < memlen; i++)
WRITESHM(arlan_mem[i], 0x00, char);
IFDEBUG(1) printk(KERN_INFO "Arlan: memory tests ok\n");
/* set reset flag and then release reset */
WRITESHM(arlan->resetFlag, 0xff, u_char);
clearChannelAttention(dev);
clearHardwareReset(dev);
/* wait for reset flag to become zero, we'll wait for two seconds */
if (arlan_command(dev, ARLAN_COMMAND_LONG_WAIT_NOW))
{
printk(KERN_ERR "%s arlan: failed to come back from memory test\n", dev->name);
return -1;
}
return 0;
}
static int arlan_setup_card_by_book(struct net_device *dev)
{
u_char irqLevel, configuredStatusFlag;
struct arlan_private *priv = netdev_priv(dev);
volatile struct arlan_shmem __iomem *arlan = priv->card;
// ARLAN_DEBUG_ENTRY("arlan_setup_card");
READSHM(configuredStatusFlag, arlan->configuredStatusFlag, u_char);
IFDEBUG(10)
if (configuredStatusFlag != 0)
IFDEBUG(10) printk("arlan: CARD IS CONFIGURED\n");
else
IFDEBUG(10) printk("arlan: card is NOT configured\n");
if (testMemory || (READSHMB(arlan->diagnosticInfo) != 0xff))
if (arlan_hw_test_memory(dev))
return -1;
DEBUGSHM(4, "arlan configuredStatus = %d \n", arlan->configuredStatusFlag, u_char);
DEBUGSHM(4, "arlan driver diagnostic: 0x%2x\n", arlan->diagnosticInfo, u_char);
/* issue nop command - no interrupt */
arlan_command(dev, ARLAN_COMMAND_NOOP);
if (arlan_command(dev, ARLAN_COMMAND_WAIT_NOW) != 0)
return -1;
IFDEBUG(50) printk("1st Noop successfully executed !!\n");
/* try to turn on the arlan interrupts */
clearClearInterrupt(dev);
setClearInterrupt(dev);
setInterruptEnable(dev);
/* issue nop command - with interrupt */
arlan_command(dev, ARLAN_COMMAND_NOOPINT);
if (arlan_command(dev, ARLAN_COMMAND_WAIT_NOW) != 0)
return -1;
IFDEBUG(50) printk("2nd Noop successfully executed !!\n");
READSHM(irqLevel, arlan->irqLevel, u_char)
if (irqLevel != dev->irq)
{
IFDEBUG(1) printk(KERN_WARNING "arlan dip switches set irq to %d\n", irqLevel);
printk(KERN_WARNING "device driver irq set to %d - does not match\n", dev->irq);
dev->irq = irqLevel;
}
else
IFDEBUG(2) printk("irq level is OK\n");
IFDEBUG(3) arlan_print_diagnostic_info(dev);
arlan_command(dev, ARLAN_COMMAND_CONF);
READSHM(configuredStatusFlag, arlan->configuredStatusFlag, u_char);
if (configuredStatusFlag == 0)
{
printk(KERN_WARNING "arlan configure failed\n");
return -1;
}
arlan_command(dev, ARLAN_COMMAND_LONG_WAIT_NOW);
arlan_command(dev, ARLAN_COMMAND_RX);
arlan_command(dev, ARLAN_COMMAND_LONG_WAIT_NOW);
printk(KERN_NOTICE "%s: arlan driver version %s loaded\n",
dev->name, arlan_version);
// ARLAN_DEBUG_EXIT("arlan_setup_card");
return 0; /* no errors */
}
#endif
#ifdef ARLAN_PROC_INTERFACE
#ifdef ARLAN_PROC_SHM_DUMP
static char arlan_drive_info[ARLAN_STR_SIZE] = "A655\n\0";
static int arlan_sysctl_info(ctl_table * ctl, int write, struct file *filp,
void __user *buffer, size_t * lenp, loff_t *ppos)
{
int i;
int retv, pos, devnum;
struct arlan_private *priva = NULL;
struct net_device *dev;
pos = 0;
if (write)
{
printk("wrirte: ");
for (i = 0; i < 100; i++)
printk("adi %x \n", arlan_drive_info[i]);
}
if (ctl->procname == NULL || arlan_drive_info == NULL)
{
printk(KERN_WARNING " procname is NULL in sysctl_table or arlan_drive_info is NULL \n at arlan module\n ");
return -1;
}
devnum = ctl->procname[5] - '0';
if (devnum < 0 || devnum > MAX_ARLANS - 1)
{
printk(KERN_WARNING "too strange devnum in procfs parse\n ");
return -1;
}
else if (arlan_device[devnum] == NULL)
{
if (ctl->procname)
pos += sprintf(arlan_drive_info + pos, "\t%s\n\n", ctl->procname);
pos += sprintf(arlan_drive_info + pos, "No device found here \n");
goto final;
}
else
priva = arlan_device[devnum]->priv;
if (priva == NULL)
{
printk(KERN_WARNING " Could not find the device private in arlan procsys, bad\n ");
return -1;
}
dev = arlan_device[devnum];
memcpy_fromio(priva->conf, priva->card, sizeof(struct arlan_shmem));
pos = sprintf(arlan_drive_info, "Arlan info \n");
/* Header Signature */
SARLSTR(textRegion, 48);
SARLUC(resetFlag);
pos += sprintf(arlan_drive_info + pos, "diagnosticInfo\t=\t%s \n", arlan_diagnostic_info_string(dev));
SARLUC(diagnosticInfo);
SARLUS(diagnosticOffset);
SARLUCN(_1, 12);
SARLUCN(lanCardNodeId, 6);
SARLUCN(broadcastAddress, 6);
pos += sprintf(arlan_drive_info + pos, "hardwareType =\t %s \n", arlan_hardware_type_string(dev));
SARLUC(hardwareType);
SARLUC(majorHardwareVersion);
SARLUC(minorHardwareVersion);
SARLUC(radioModule);
SARLUC(defaultChannelSet);
SARLUCN(_2, 47);
/* Control/Status Block - 0x0080 */
SARLUC(interruptInProgress);
SARLUC(cntrlRegImage);
SARLUCN(_3, 14);
SARLUC(commandByte);
SARLUCN(commandParameter, 15);
/* Receive Status - 0x00a0 */
SARLUC(rxStatus);
SARLUC(rxFrmType);
SARLUS(rxOffset);
SARLUS(rxLength);
SARLUCN(rxSrc, 6);
SARLUC(rxBroadcastFlag);
SARLUC(rxQuality);
SARLUC(scrambled);
SARLUCN(_4, 1);
/* Transmit Status - 0x00b0 */
SARLUC(txStatus);
SARLUC(txAckQuality);
SARLUC(numRetries);
SARLUCN(_5, 14);
SARLUCN(registeredRouter, 6);
SARLUCN(backboneRouter, 6);
SARLUC(registrationStatus);
SARLUC(configuredStatusFlag);
SARLUCN(_6, 1);
SARLUCN(ultimateDestAddress, 6);
SARLUCN(immedDestAddress, 6);
SARLUCN(immedSrcAddress, 6);
SARLUS(rxSequenceNumber);
SARLUC(assignedLocaltalkAddress);
SARLUCN(_7, 27);
/* System Parameter Block */
/* - Driver Parameters (Novell Specific) */
SARLUS(txTimeout);
SARLUS(transportTime);
SARLUCN(_8, 4);
/* - Configuration Parameters */
SARLUC(irqLevel);
SARLUC(spreadingCode);
SARLUC(channelSet);
SARLUC(channelNumber);
SARLUS(radioNodeId);
SARLUCN(_9, 2);
SARLUC(scramblingDisable);
SARLUC(radioType);
SARLUS(routerId);
SARLUCN(_10, 9);
SARLUC(txAttenuation);
SARLUIA(systemId);
SARLUS(globalChecksum);
SARLUCN(_11, 4);
SARLUS(maxDatagramSize);
SARLUS(maxFrameSize);
SARLUC(maxRetries);
SARLUC(receiveMode);
SARLUC(priority);
SARLUC(rootOrRepeater);
SARLUCN(specifiedRouter, 6);
SARLUS(fastPollPeriod);
SARLUC(pollDecay);
SARLUSA(fastPollDelay);
SARLUC(arlThreshold);
SARLUC(arlDecay);
SARLUCN(_12, 1);
SARLUS(specRouterTimeout);
SARLUCN(_13, 5);
/* Scrambled Area */
SARLUIA(SID);
SARLUCN(encryptionKey, 12);
SARLUIA(_14);
SARLUSA(waitTime);
SARLUSA(lParameter);
SARLUCN(_15, 3);
SARLUS(headerSize);
SARLUS(sectionChecksum);
SARLUC(registrationMode);
SARLUC(registrationFill);
SARLUS(pollPeriod);
SARLUS(refreshPeriod);
SARLSTR(name, 16);
SARLUCN(NID, 6);
SARLUC(localTalkAddress);
SARLUC(codeFormat);
SARLUC(numChannels);
SARLUC(channel1);
SARLUC(channel2);
SARLUC(channel3);
SARLUC(channel4);
SARLUCN(SSCode, 59);
/* SARLUCN( _16, 0x140);
*/
/* Statistics Block - 0x0300 */
SARLUC(hostcpuLock);
SARLUC(lancpuLock);
SARLUCN(resetTime, 18);
SARLUIA(numDatagramsTransmitted);
SARLUIA(numReTransmissions);
SARLUIA(numFramesDiscarded);
SARLUIA(numDatagramsReceived);
SARLUIA(numDuplicateReceivedFrames);
SARLUIA(numDatagramsDiscarded);
SARLUS(maxNumReTransmitDatagram);
SARLUS(maxNumReTransmitFrames);
SARLUS(maxNumConsecutiveDuplicateFrames);
/* misaligned here so we have to go to characters */
SARLUIA(numBytesTransmitted);
SARLUIA(numBytesReceived);
SARLUIA(numCRCErrors);
SARLUIA(numLengthErrors);
SARLUIA(numAbortErrors);
SARLUIA(numTXUnderruns);
SARLUIA(numRXOverruns);
SARLUIA(numHoldOffs);
SARLUIA(numFramesTransmitted);
SARLUIA(numFramesReceived);
SARLUIA(numReceiveFramesLost);
SARLUIA(numRXBufferOverflows);
SARLUIA(numFramesDiscardedAddrMismatch);
SARLUIA(numFramesDiscardedSIDMismatch);
SARLUIA(numPollsTransmistted);
SARLUIA(numPollAcknowledges);
SARLUIA(numStatusTimeouts);
SARLUIA(numNACKReceived);
SARLUS(auxCmd);
SARLUCN(dumpPtr, 4);
SARLUC(dumpVal);
SARLUC(wireTest);
/* next 4 seems too long for procfs, over single page ?
SARLUCN( _17, 0x86);
SARLUCN( txBuffer, 0x800);
SARLUCN( rxBuffer, 0x800);
SARLUCN( _18, 0x0bff);
*/
pos += sprintf(arlan_drive_info + pos, "rxRing\t=\t0x");
for (i = 0; i < 0x50; i++)
pos += sprintf(arlan_drive_info + pos, "%02x", ((char *) priva->conf)[priva->conf->rxOffset + i]);
pos += sprintf(arlan_drive_info + pos, "\n");
SARLUC(configStatus);
SARLUC(_22);
SARLUC(progIOCtrl);
SARLUC(shareMBase);
SARLUC(controlRegister);
pos += sprintf(arlan_drive_info + pos, " total %d chars\n", pos);
if (ctl)
if (ctl->procname)
pos += sprintf(arlan_drive_info + pos, " driver name : %s\n", ctl->procname);
final:
*lenp = pos;
if (!write)
retv = proc_dostring(ctl, write, filp, buffer, lenp, ppos);
else
{
*lenp = 0;
return -1;
}
return retv;
}
static int arlan_sysctl_info161719(ctl_table * ctl, int write, struct file *filp,
void __user *buffer, size_t * lenp, loff_t *ppos)
{
int i;
int retv, pos, devnum;
struct arlan_private *priva = NULL;
pos = 0;
devnum = ctl->procname[5] - '0';
if (arlan_device[devnum] == NULL)
{
pos += sprintf(arlan_drive_info + pos, "No device found here \n");
goto final;
}
else
priva = arlan_device[devnum]->priv;
if (priva == NULL)
{
printk(KERN_WARNING " Could not find the device private in arlan procsys, bad\n ");
return -1;
}
memcpy_fromio(priva->conf, priva->card, sizeof(struct arlan_shmem));
SARLUCN(_16, 0xC0);
SARLUCN(_17, 0x6A);
SARLUCN(_18, 14);
SARLUCN(_19, 0x86);
SARLUCN(_21, 0x3fd);
final:
*lenp = pos;
retv = proc_dostring(ctl, write, filp, buffer, lenp, ppos);
return retv;
}
static int arlan_sysctl_infotxRing(ctl_table * ctl, int write, struct file *filp,
void __user *buffer, size_t * lenp, loff_t *ppos)
{
int i;
int retv, pos, devnum;
struct arlan_private *priva = NULL;
pos = 0;
devnum = ctl->procname[5] - '0';
if (arlan_device[devnum] == NULL)
{
pos += sprintf(arlan_drive_info + pos, "No device found here \n");
goto final;
}
else
priva = arlan_device[devnum]->priv;
if (priva == NULL)
{
printk(KERN_WARNING " Could not find the device private in arlan procsys, bad\n ");
return -1;
}
memcpy_fromio(priva->conf, priva->card, sizeof(struct arlan_shmem));
SARLBNpln(u_char, txBuffer, 0x800);
final:
*lenp = pos;
retv = proc_dostring(ctl, write, filp, buffer, lenp, ppos);
return retv;
}
static int arlan_sysctl_inforxRing(ctl_table * ctl, int write, struct file *filp,
void __user *buffer, size_t * lenp, loff_t *ppos)
{
int i;
int retv, pos, devnum;
struct arlan_private *priva = NULL;
pos = 0;
devnum = ctl->procname[5] - '0';
if (arlan_device[devnum] == NULL)
{
pos += sprintf(arlan_drive_info + pos, "No device found here \n");
goto final;
} else
priva = arlan_device[devnum]->priv;
if (priva == NULL)
{
printk(KERN_WARNING " Could not find the device private in arlan procsys, bad\n ");
return -1;
}
memcpy_fromio(priva->conf, priva->card, sizeof(struct arlan_shmem));
SARLBNpln(u_char, rxBuffer, 0x800);
final:
*lenp = pos;
retv = proc_dostring(ctl, write, filp, buffer, lenp, ppos);
return retv;
}
static int arlan_sysctl_info18(ctl_table * ctl, int write, struct file *filp,
void __user *buffer, size_t * lenp, loff_t *ppos)
{
int i;
int retv, pos, devnum;
struct arlan_private *priva = NULL;
pos = 0;
devnum = ctl->procname[5] - '0';
if (arlan_device[devnum] == NULL)
{
pos += sprintf(arlan_drive_info + pos, "No device found here \n");
goto final;
}
else
priva = arlan_device[devnum]->priv;
if (priva == NULL)
{
printk(KERN_WARNING " Could not find the device private in arlan procsys, bad\n ");
return -1;
}
memcpy_fromio(priva->conf, priva->card, sizeof(struct arlan_shmem));
SARLBNpln(u_char, _18, 0x800);
final:
*lenp = pos;
retv = proc_dostring(ctl, write, filp, buffer, lenp, ppos);
return retv;
}
#endif /* #ifdef ARLAN_PROC_SHM_DUMP */
static char conf_reset_result[200];
static int arlan_configure(ctl_table * ctl, int write, struct file *filp,
void __user *buffer, size_t * lenp, loff_t *ppos)
{
int pos = 0;
int devnum = ctl->procname[6] - '0';
struct arlan_private *priv;
if (devnum < 0 || devnum > MAX_ARLANS - 1)
{
printk(KERN_WARNING "too strange devnum in procfs parse\n ");
return -1;
}
else if (arlan_device[devnum] != NULL)
{
priv = arlan_device[devnum]->priv;
arlan_command(arlan_device[devnum], ARLAN_COMMAND_CLEAN_AND_CONF);
}
else
return -1;
*lenp = pos;
return proc_dostring(ctl, write, filp, buffer, lenp, ppos);
}
static int arlan_sysctl_reset(ctl_table * ctl, int write, struct file *filp,
void __user *buffer, size_t * lenp, loff_t *ppos)
{
int pos = 0;
int devnum = ctl->procname[5] - '0';
struct arlan_private *priv;
if (devnum < 0 || devnum > MAX_ARLANS - 1)
{
printk(KERN_WARNING "too strange devnum in procfs parse\n ");
return -1;
}
else if (arlan_device[devnum] != NULL)
{
priv = arlan_device[devnum]->priv;
arlan_command(arlan_device[devnum], ARLAN_COMMAND_CLEAN_AND_RESET);
} else
return -1;
*lenp = pos + 3;
return proc_dostring(ctl, write, filp, buffer, lenp, ppos);
}
/* Place files in /proc/sys/dev/arlan */
#define CTBLN(num,card,nam) \
{ .ctl_name = num,\
.procname = #nam,\
.data = &(arlan_conf[card].nam),\
.maxlen = sizeof(int), .mode = 0600, .proc_handler = &proc_dointvec}
#ifdef ARLAN_DEBUGGING
#define ARLAN_PROC_DEBUG_ENTRIES \
{ .ctl_name = 48, .procname = "entry_exit_debug",\
.data = &arlan_entry_and_exit_debug,\
.maxlen = sizeof(int), .mode = 0600, .proc_handler = &proc_dointvec},\
{ .ctl_name = 49, .procname = "debug", .data = &arlan_debug,\
.maxlen = sizeof(int), .mode = 0600, .proc_handler = &proc_dointvec},
#else
#define ARLAN_PROC_DEBUG_ENTRIES
#endif
#define ARLAN_SYSCTL_TABLE_TOTAL(cardNo)\
CTBLN(1,cardNo,spreadingCode),\
CTBLN(2,cardNo, channelNumber),\
CTBLN(3,cardNo, scramblingDisable),\
CTBLN(4,cardNo, txAttenuation),\
CTBLN(5,cardNo, systemId), \
CTBLN(6,cardNo, maxDatagramSize),\
CTBLN(7,cardNo, maxFrameSize),\
CTBLN(8,cardNo, maxRetries),\
CTBLN(9,cardNo, receiveMode),\
CTBLN(10,cardNo, priority),\
CTBLN(11,cardNo, rootOrRepeater),\
CTBLN(12,cardNo, SID),\
CTBLN(13,cardNo, registrationMode),\
CTBLN(14,cardNo, registrationFill),\
CTBLN(15,cardNo, localTalkAddress),\
CTBLN(16,cardNo, codeFormat),\
CTBLN(17,cardNo, numChannels),\
CTBLN(18,cardNo, channel1),\
CTBLN(19,cardNo, channel2),\
CTBLN(20,cardNo, channel3),\
CTBLN(21,cardNo, channel4),\
CTBLN(22,cardNo, txClear),\
CTBLN(23,cardNo, txRetries),\
CTBLN(24,cardNo, txRouting),\
CTBLN(25,cardNo, txScrambled),\
CTBLN(26,cardNo, rxParameter),\
CTBLN(27,cardNo, txTimeoutMs),\
CTBLN(28,cardNo, waitCardTimeout),\
CTBLN(29,cardNo, channelSet), \
{.ctl_name = 30, .procname = "name",\
.data = arlan_conf[cardNo].siteName,\
.maxlen = 16, .mode = 0600, .proc_handler = &proc_dostring},\
CTBLN(31,cardNo,waitTime),\
CTBLN(32,cardNo,lParameter),\
CTBLN(33,cardNo,_15),\
CTBLN(34,cardNo,headerSize),\
CTBLN(36,cardNo,tx_delay_ms),\
CTBLN(37,cardNo,retries),\
CTBLN(38,cardNo,ReTransmitPacketMaxSize),\
CTBLN(39,cardNo,waitReTransmitPacketMaxSize),\
CTBLN(40,cardNo,fastReTransCount),\
CTBLN(41,cardNo,driverRetransmissions),\
CTBLN(42,cardNo,txAckTimeoutMs),\
CTBLN(43,cardNo,registrationInterrupts),\
CTBLN(44,cardNo,hardwareType),\
CTBLN(45,cardNo,radioType),\
CTBLN(46,cardNo,writeEEPROM),\
CTBLN(47,cardNo,writeRadioType),\
ARLAN_PROC_DEBUG_ENTRIES\
CTBLN(50,cardNo,in_speed),\
CTBLN(51,cardNo,out_speed),\
CTBLN(52,cardNo,in_speed10),\
CTBLN(53,cardNo,out_speed10),\
CTBLN(54,cardNo,in_speed_max),\
CTBLN(55,cardNo,out_speed_max),\
CTBLN(56,cardNo,measure_rate),\
CTBLN(57,cardNo,pre_Command_Wait),\
CTBLN(58,cardNo,rx_tweak1),\
CTBLN(59,cardNo,rx_tweak2),\
CTBLN(60,cardNo,tx_queue_len),\
static ctl_table arlan_conf_table0[] =
{
ARLAN_SYSCTL_TABLE_TOTAL(0)
#ifdef ARLAN_PROC_SHM_DUMP
{
.ctl_name = 150,
.procname = "arlan0-txRing",
.data = &arlan_drive_info,
.maxlen = ARLAN_STR_SIZE,
.mode = 0400,
.proc_handler = &arlan_sysctl_infotxRing,
},
{
.ctl_name = 151,
.procname = "arlan0-rxRing",
.data = &arlan_drive_info,
.maxlen = ARLAN_STR_SIZE,
.mode = 0400,
.proc_handler = &arlan_sysctl_inforxRing,
},
{
.ctl_name = 152,
.procname = "arlan0-18",
.data = &arlan_drive_info,
.maxlen = ARLAN_STR_SIZE,
.mode = 0400,
.proc_handler = &arlan_sysctl_info18,
},
{
.ctl_name = 153,
.procname = "arlan0-ring",
.data = &arlan_drive_info,
.maxlen = ARLAN_STR_SIZE,
.mode = 0400,
.proc_handler = &arlan_sysctl_info161719,
},
{
.ctl_name = 154,
.procname = "arlan0-shm-cpy",
.data = &arlan_drive_info,
.maxlen = ARLAN_STR_SIZE,
.mode = 0400,
.proc_handler = &arlan_sysctl_info,
},
#endif
{
.ctl_name = 155,
.procname = "config0",
.data = &conf_reset_result,
.maxlen = 100,
.mode = 0400,
.proc_handler = &arlan_configure
},
{
.ctl_name = 156,
.procname = "reset0",
.data = &conf_reset_result,
.maxlen = 100,
.mode = 0400,
.proc_handler = &arlan_sysctl_reset,
},
{ .ctl_name = 0 }
};
static ctl_table arlan_conf_table1[] =
{
ARLAN_SYSCTL_TABLE_TOTAL(1)
#ifdef ARLAN_PROC_SHM_DUMP
{
.ctl_name = 150,
.procname = "arlan1-txRing",
.data = &arlan_drive_info,
.maxlen = ARLAN_STR_SIZE,
.mode = 0400,
.proc_handler = &arlan_sysctl_infotxRing,
},
{
.ctl_name = 151,
.procname = "arlan1-rxRing",
.data = &arlan_drive_info,
.maxlen = ARLAN_STR_SIZE,
.mode = 0400,
.proc_handler = &arlan_sysctl_inforxRing,
},
{
.ctl_name = 152,
.procname = "arlan1-18",
.data = &arlan_drive_info,
.maxlen = ARLAN_STR_SIZE,
.mode = 0400,
.proc_handler = &arlan_sysctl_info18,
},
{
.ctl_name = 153,
.procname = "arlan1-ring",
.data = &arlan_drive_info,
.maxlen = ARLAN_STR_SIZE,
.mode = 0400,
.proc_handler = &arlan_sysctl_info161719,
},
{
.ctl_name = 154,
.procname = "arlan1-shm-cpy",
.data = &arlan_drive_info,
.maxlen = ARLAN_STR_SIZE,
.mode = 0400,
.proc_handler = &arlan_sysctl_info,
},
#endif
{
.ctl_name = 155,
.procname = "config1",
.data = &conf_reset_result,
.maxlen = 100,
.mode = 0400,
.proc_handler = &arlan_configure,
},
{
.ctl_name = 156,
.procname = "reset1",
.data = &conf_reset_result,
.maxlen = 100,
.mode = 0400,
.proc_handler = &arlan_sysctl_reset,
},
{ .ctl_name = 0 }
};
static ctl_table arlan_conf_table2[] =
{
ARLAN_SYSCTL_TABLE_TOTAL(2)
#ifdef ARLAN_PROC_SHM_DUMP
{
.ctl_name = 150,
.procname = "arlan2-txRing",
.data = &arlan_drive_info,
.maxlen = ARLAN_STR_SIZE,
.mode = 0400,
.proc_handler = &arlan_sysctl_infotxRing,
},
{
.ctl_name = 151,
.procname = "arlan2-rxRing",
.data = &arlan_drive_info,
.maxlen = ARLAN_STR_SIZE,
.mode = 0400,
.proc_handler = &arlan_sysctl_inforxRing,
},
{
.ctl_name = 152,
.procname = "arlan2-18",
.data = &arlan_drive_info,
.maxlen = ARLAN_STR_SIZE,
.mode = 0400,
.proc_handler = &arlan_sysctl_info18,
},
{
.ctl_name = 153,
.procname = "arlan2-ring",
.data = &arlan_drive_info,
.maxlen = ARLAN_STR_SIZE,
.mode = 0400,
.proc_handler = &arlan_sysctl_info161719,
},
{
.ctl_name = 154,
.procname = "arlan2-shm-cpy",
.data = &arlan_drive_info,
.maxlen = ARLAN_STR_SIZE,
.mode = 0400,
.proc_handler = &arlan_sysctl_info,
},
#endif
{
.ctl_name = 155,
.procname = "config2",
.data = &conf_reset_result,
.maxlen = 100,
.mode = 0400,
.proc_handler = &arlan_configure,
},
{
.ctl_name = 156,
.procname = "reset2",
.data = &conf_reset_result,
.maxlen = 100,
.mode = 0400,
.proc_handler = &arlan_sysctl_reset,
},
{ .ctl_name = 0 }
};
static ctl_table arlan_conf_table3[] =
{
ARLAN_SYSCTL_TABLE_TOTAL(3)
#ifdef ARLAN_PROC_SHM_DUMP
{
.ctl_name = 150,
.procname = "arlan3-txRing",
.data = &arlan_drive_info,
.maxlen = ARLAN_STR_SIZE,
.mode = 0400,
.proc_handler = &arlan_sysctl_infotxRing,
},
{
.ctl_name = 151,
.procname = "arlan3-rxRing",
.data = &arlan_drive_info,
.maxlen = ARLAN_STR_SIZE,
.mode = 0400,
.proc_handler = &arlan_sysctl_inforxRing,
},
{
.ctl_name = 152,
.procname = "arlan3-18",
.data = &arlan_drive_info,
.maxlen = ARLAN_STR_SIZE,
.mode = 0400,
.proc_handler = &arlan_sysctl_info18,
},
{
.ctl_name = 153,
.procname = "arlan3-ring",
.data = &arlan_drive_info,
.maxlen = ARLAN_STR_SIZE,
.mode = 0400,
.proc_handler = &arlan_sysctl_info161719,
},
{
.ctl_name = 154,
.procname = "arlan3-shm-cpy",
.data = &arlan_drive_info,
.maxlen = ARLAN_STR_SIZE,
.mode = 0400,
.proc_handler = &arlan_sysctl_info,
},
#endif
{
.ctl_name = 155,
.procname = "config3",
.data = &conf_reset_result,
.maxlen = 100,
.mode = 0400,
.proc_handler = &arlan_configure,
},
{
.ctl_name = 156,
.procname = "reset3",
.data = &conf_reset_result,
.maxlen = 100,
.mode = 0400,
.proc_handler = &arlan_sysctl_reset,
},
{ .ctl_name = 0 }
};
static ctl_table arlan_table[] =
{
{
.ctl_name = 0,
.procname = "arlan0",
.maxlen = 0,
.mode = 0600,
.child = arlan_conf_table0,
},
{
.ctl_name = 0,
.procname = "arlan1",
.maxlen = 0,
.mode = 0600,
.child = arlan_conf_table1,
},
{
.ctl_name = 0,
.procname = "arlan2",
.maxlen = 0,
.mode = 0600,
.child = arlan_conf_table2,
},
{
.ctl_name = 0,
.procname = "arlan3",
.maxlen = 0,
.mode = 0600,
.child = arlan_conf_table3,
},
{ .ctl_name = 0 }
};
#else
static ctl_table arlan_table[MAX_ARLANS + 1] =
{
{ .ctl_name = 0 }
};
#endif
#else
static ctl_table arlan_table[MAX_ARLANS + 1] =
{
{ .ctl_name = 0 }
};
#endif
// static int mmtu = 1234;
static ctl_table arlan_root_table[] =
{
{
.ctl_name = 254,
.procname = "arlan",
.maxlen = 0,
.mode = 0555,
.child = arlan_table,
},
{ .ctl_name = 0 }
};
/* Make sure that /proc/sys/dev is there */
//static ctl_table arlan_device_root_table[] =
//{
// {CTL_DEV, "dev", NULL, 0, 0555, arlan_root_table},
// {0}
//};
#ifdef CONFIG_PROC_FS
static struct ctl_table_header *arlan_device_sysctl_header;
int __init init_arlan_proc(void)
{
int i = 0;
if (arlan_device_sysctl_header)
return 0;
for (i = 0; i < MAX_ARLANS && arlan_device[i]; i++)
arlan_table[i].ctl_name = i + 1;
arlan_device_sysctl_header = register_sysctl_table(arlan_root_table, 0);
if (!arlan_device_sysctl_header)
return -1;
return 0;
}
void __exit cleanup_arlan_proc(void)
{
unregister_sysctl_table(arlan_device_sysctl_header);
arlan_device_sysctl_header = NULL;
}
#endif
Reference in New Issue View Git Blame Copy Permalink