extractedLnx/linux-2.6.30/drivers/staging/rt2870/rt_ate.c_RtmpDoAte.c
VOID RtmpDoAte(
IN PRTMP_ADAPTER pAdapter,
IN struct iwreq *wrq)
{
unsigned short Command_Id;
struct ate_racfghdr *pRaCfg;
INT Status = NDIS_STATUS_SUCCESS;
if((pRaCfg = kmalloc(sizeof(struct ate_racfghdr), GFP_KERNEL)) == NULL)
{
Status = -EINVAL;
return;
}
NdisZeroMemory(pRaCfg, sizeof(struct ate_racfghdr));
if (copy_from_user((PUCHAR)pRaCfg, wrq->u.data.pointer, wrq->u.data.length))
{
Status = -EFAULT;
kfree(pRaCfg);
return;
}
Command_Id = ntohs(pRaCfg->command_id);
ATEDBGPRINT(RT_DEBUG_TRACE,("\n%s: Command_Id = 0x%04x !\n", __func__, Command_Id));
switch (Command_Id)
{
// We will get this command when QA starts.
case RACFG_CMD_ATE_START:
{
ATEDBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_START\n"));
// prepare feedback as soon as we can to avoid QA timeout.
pRaCfg->length = htons(2);
pRaCfg->status = htons(0);
wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
+ sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
+ sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
ATEDBGPRINT(RT_DEBUG_TRACE, ("wrq->u.data.length = %d\n", wrq->u.data.length));
if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
{
ATEDBGPRINT(RT_DEBUG_TRACE, ("copy_to_user() fail in case RACFG_CMD_ATE_START\n"));
Status = -EFAULT;
}
else
{
ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_ATE_START is done !\n"));
}
Set_ATE_Proc(pAdapter, "ATESTART");
}
break;
// We will get this command either QA is closed or ated is killed by user.
case RACFG_CMD_ATE_STOP:
{
#ifndef UCOS
INT32 ret;
#endif // !UCOS //
ATEDBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_STOP\n"));
// Distinguish this command came from QA(via ated)
// or ate daemon according to the existence of pid in payload.
// No need to prepare feedback if this cmd came directly from ate daemon.
pRaCfg->length = ntohs(pRaCfg->length);
if (pRaCfg->length == sizeof(pAdapter->ate.AtePid))
{
// This command came from QA.
// Get the pid of ATE daemon.
memcpy((UCHAR *)&pAdapter->ate.AtePid,
(&pRaCfg->data[0]) - 2/* == &(pRaCfg->status) */,
sizeof(pAdapter->ate.AtePid));
// prepare feedback as soon as we can to avoid QA timeout.
pRaCfg->length = htons(2);
pRaCfg->status = htons(0);
wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
+ sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
+ sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
ATEDBGPRINT(RT_DEBUG_TRACE, ("wrq->u.data.length = %d\n", wrq->u.data.length));
if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
{
ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_ATE_STOP\n"));
Status = -EFAULT;
}
//
// kill ATE daemon when leaving ATE mode.
// We must kill ATE daemon first before setting ATESTOP,
// or Microsoft will report sth. wrong.
#ifndef UCOS
ret = KILL_THREAD_PID(pAdapter->ate.AtePid, SIGTERM, 1);
if (ret)
{
ATEDBGPRINT(RT_DEBUG_ERROR, ("%s: unable to signal thread\n", pAdapter->net_dev->name));
}
#endif // !UCOS //
}
// AP might have in ATE_STOP mode due to cmd from QA.
if (ATE_ON(pAdapter))
{
// Someone has killed ate daemon while QA GUI is still open.
Set_ATE_Proc(pAdapter, "ATESTOP");
ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_AP_START is done !\n"));
}
}
break;
case RACFG_CMD_RF_WRITE_ALL:
{
UINT32 R1, R2, R3, R4;
USHORT channel;
memcpy(&R1, pRaCfg->data-2, 4);
memcpy(&R2, pRaCfg->data+2, 4);
memcpy(&R3, pRaCfg->data+6, 4);
memcpy(&R4, pRaCfg->data+10, 4);
memcpy(&channel, pRaCfg->data+14, 2);
pAdapter->LatchRfRegs.R1 = ntohl(R1);
pAdapter->LatchRfRegs.R2 = ntohl(R2);
pAdapter->LatchRfRegs.R3 = ntohl(R3);
pAdapter->LatchRfRegs.R4 = ntohl(R4);
pAdapter->LatchRfRegs.Channel = ntohs(channel);
RTMP_RF_IO_WRITE32(pAdapter, pAdapter->LatchRfRegs.R1);
RTMP_RF_IO_WRITE32(pAdapter, pAdapter->LatchRfRegs.R2);
RTMP_RF_IO_WRITE32(pAdapter, pAdapter->LatchRfRegs.R3);
RTMP_RF_IO_WRITE32(pAdapter, pAdapter->LatchRfRegs.R4);
// prepare feedback
pRaCfg->length = htons(2);
pRaCfg->status = htons(0);
wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
+ sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
+ sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
ATEDBGPRINT(RT_DEBUG_TRACE, ("wrq->u.data.length = %d\n", wrq->u.data.length));
if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
{
ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_RF_WRITE_ALL\n"));
Status = -EFAULT;
}
else
{
ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_RF_WRITE_ALL is done !\n"));
}
}
break;
case RACFG_CMD_E2PROM_READ16:
{
USHORT offset, value, tmp;
offset = ntohs(pRaCfg->status);
/* "tmp" is expecially for some compilers... */
RT28xx_EEPROM_READ16(pAdapter, offset, tmp);
value = tmp;
value = htons(value);
ATEDBGPRINT(RT_DEBUG_TRACE,("EEPROM Read offset = 0x%04x, value = 0x%04x\n", offset, value));
// prepare feedback
pRaCfg->length = htons(4);
pRaCfg->status = htons(0);
memcpy(pRaCfg->data, &value, 2);
wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
+ sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
+ sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
ATEDBGPRINT(RT_DEBUG_TRACE, ("sizeof(struct ate_racfghdr) = %d\n", sizeof(struct ate_racfghdr)));
ATEDBGPRINT(RT_DEBUG_TRACE, ("wrq->u.data.length = %d\n", wrq->u.data.length));
if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
{
ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_E2PROM_READ16\n"));
Status = -EFAULT;
}
else
{
ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_E2PROM_READ16 is done !\n"));
}
}
break;
case RACFG_CMD_E2PROM_WRITE16:
{
USHORT offset, value;
offset = ntohs(pRaCfg->status);
memcpy(&value, pRaCfg->data, 2);
value = ntohs(value);
RT28xx_EEPROM_WRITE16(pAdapter, offset, value);
// prepare feedback
pRaCfg->length = htons(2);
pRaCfg->status = htons(0);
wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
+ sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
+ sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
{
ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_E2PROM_WRITE16\n"));
Status = -EFAULT;
}
else
{
ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_E2PROM_WRITE16 is done !\n"));
}
}
break;
case RACFG_CMD_E2PROM_READ_ALL:
{
USHORT buffer[EEPROM_SIZE/2];
rt_ee_read_all(pAdapter,(USHORT *)buffer);
memcpy_exs(pAdapter, pRaCfg->data, (UCHAR *)buffer, EEPROM_SIZE);
// prepare feedback
pRaCfg->length = htons(2+EEPROM_SIZE);
pRaCfg->status = htons(0);
wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
+ sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
+ sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
{
ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_E2PROM_READ_ALL\n"));
Status = -EFAULT;
}
else
{
ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_E2PROM_READ_ALL is done !\n"));
}
}
break;
case RACFG_CMD_E2PROM_WRITE_ALL:
{
USHORT buffer[EEPROM_SIZE/2];
NdisZeroMemory((UCHAR *)buffer, EEPROM_SIZE);
memcpy_exs(pAdapter, (UCHAR *)buffer, (UCHAR *)&pRaCfg->status, EEPROM_SIZE);
rt_ee_write_all(pAdapter,(USHORT *)buffer);
// prepare feedback
pRaCfg->length = htons(2);
pRaCfg->status = htons(0);
wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
+ sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
+ sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
{
ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_E2PROM_WRITE_ALL\n"));
Status = -EFAULT;
}
else
{
ATEDBGPRINT(RT_DEBUG_ERROR, ("RACFG_CMD_E2PROM_WRITE_ALL is done !\n"));
}
}
break;
case RACFG_CMD_IO_READ:
{
UINT32 offset;
UINT32 value;
memcpy(&offset, &pRaCfg->status, 4);
offset = ntohl(offset);
// We do not need the base address.
// So just extract the offset out.
offset &= 0x0000FFFF;
RTMP_IO_READ32(pAdapter, offset, &value);
value = htonl(value);
// prepare feedback
pRaCfg->length = htons(6);
pRaCfg->status = htons(0);
memcpy(pRaCfg->data, &value, 4);
wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
+ sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
+ sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
{
ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_IO_READ\n"));
Status = -EFAULT;
}
else
{
ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_IO_READ is done !\n"));
}
}
break;
case RACFG_CMD_IO_WRITE:
{
UINT32 offset, value;
memcpy(&offset, pRaCfg->data-2, 4);
memcpy(&value, pRaCfg->data+2, 4);
offset = ntohl(offset);
// We do not need the base address.
// So just extract out the offset.
offset &= 0x0000FFFF;
value = ntohl(value);
ATEDBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_IO_WRITE: offset = %x, value = %x\n", offset, value));
RTMP_IO_WRITE32(pAdapter, offset, value);
// prepare feedback
pRaCfg->length = htons(2);
pRaCfg->status = htons(0);
wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
+ sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
+ sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
{
ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_IO_WRITE\n"));
Status = -EFAULT;
}
else
{
ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_IO_WRITE is done !\n"));
}
}
break;
case RACFG_CMD_IO_READ_BULK:
{
UINT32 offset;
USHORT len;
memcpy(&offset, &pRaCfg->status, 4);
offset = ntohl(offset);
// We do not need the base address.
// So just extract the offset.
offset &= 0x0000FFFF;
memcpy(&len, pRaCfg->data+2, 2);
len = ntohs(len);
if (len > 371)
{
ATEDBGPRINT(RT_DEBUG_TRACE,("len is too large, make it smaller\n"));
pRaCfg->length = htons(2);
pRaCfg->status = htons(1);
break;
}
RTMP_IO_READ_BULK(pAdapter, pRaCfg->data, (UCHAR *)offset, len*4);// unit in four bytes
// prepare feedback
pRaCfg->length = htons(2+len*4);// unit in four bytes
pRaCfg->status = htons(0);
wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
+ sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
+ sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
{
ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_IO_READ_BULK\n"));
Status = -EFAULT;
}
else
{
ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_IO_READ_BULK is done !\n"));
}
}
break;
case RACFG_CMD_BBP_READ8:
{
USHORT offset;
UCHAR value;
value = 0;
offset = ntohs(pRaCfg->status);
if (ATE_ON(pAdapter))
{
ATE_BBP_IO_READ8_BY_REG_ID(pAdapter, offset, &value);
}
else
{
RTMP_BBP_IO_READ8_BY_REG_ID(pAdapter, offset, &value);
}
// prepare feedback
pRaCfg->length = htons(3);
pRaCfg->status = htons(0);
pRaCfg->data[0] = value;
ATEDBGPRINT(RT_DEBUG_TRACE,("BBP value = %x\n", value));
wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
+ sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
+ sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
{
ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_BBP_READ8\n"));
Status = -EFAULT;
}
else
{
ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_BBP_READ8 is done !\n"));
}
}
break;
case RACFG_CMD_BBP_WRITE8:
{
USHORT offset;
UCHAR value;
offset = ntohs(pRaCfg->status);
memcpy(&value, pRaCfg->data, 1);
if (ATE_ON(pAdapter))
{
ATE_BBP_IO_WRITE8_BY_REG_ID(pAdapter, offset, value);
}
else
{
RTMP_BBP_IO_WRITE8_BY_REG_ID(pAdapter, offset, value);
}
if ((offset == BBP_R1) || (offset == BBP_R3))
{
SyncTxRxConfig(pAdapter, offset, value);
}
// prepare feedback
pRaCfg->length = htons(2);
pRaCfg->status = htons(0);
wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
+ sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
+ sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
{
ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_BBP_WRITE8\n"));
Status = -EFAULT;
}
else
{
ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_BBP_WRITE8 is done !\n"));
}
}
break;
case RACFG_CMD_BBP_READ_ALL:
{
USHORT j;
for (j = 0; j < 137; j++)
{
pRaCfg->data[j] = 0;
if (ATE_ON(pAdapter))
{
ATE_BBP_IO_READ8_BY_REG_ID(pAdapter, j, &pRaCfg->data[j]);
}
else
{
RTMP_BBP_IO_READ8_BY_REG_ID(pAdapter, j, &pRaCfg->data[j]);
}
}
// prepare feedback
pRaCfg->length = htons(2+137);
pRaCfg->status = htons(0);
wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
+ sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
+ sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
{
ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_BBP_READ_ALL\n"));
Status = -EFAULT;
}
else
{
ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_BBP_READ_ALL is done !\n"));
}
}
break;
case RACFG_CMD_ATE_E2PROM_READ_BULK:
{
USHORT offset;
USHORT len;
USHORT buffer[EEPROM_SIZE/2];
offset = ntohs(pRaCfg->status);
memcpy(&len, pRaCfg->data, 2);
len = ntohs(len);
rt_ee_read_all(pAdapter,(USHORT *)buffer);
if (offset + len <= EEPROM_SIZE)
memcpy_exs(pAdapter, pRaCfg->data, (UCHAR *)buffer+offset, len);
else
ATEDBGPRINT(RT_DEBUG_ERROR, ("exceed EEPROM size\n"));
// prepare feedback
pRaCfg->length = htons(2+len);
pRaCfg->status = htons(0);
wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
+ sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
+ sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
{
ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_ATE_E2PROM_READ_BULK\n"));
Status = -EFAULT;
}
else
{
ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_ATE_E2PROM_READ_BULK is done !\n"));
}
}
break;
case RACFG_CMD_ATE_E2PROM_WRITE_BULK:
{
USHORT offset;
USHORT len;
USHORT buffer[EEPROM_SIZE/2];
offset = ntohs(pRaCfg->status);
memcpy(&len, pRaCfg->data, 2);
len = ntohs(len);
rt_ee_read_all(pAdapter,(USHORT *)buffer);
memcpy_exs(pAdapter, (UCHAR *)buffer + offset, (UCHAR *)pRaCfg->data + 2, len);
rt_ee_write_all(pAdapter,(USHORT *)buffer);
// prepare feedback
pRaCfg->length = htons(2);
pRaCfg->status = htons(0);
wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
+ sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
+ sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
{
ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_ATE_E2PROM_WRITE_BULK\n"));
Status = -EFAULT;
}
else
{
ATEDBGPRINT(RT_DEBUG_ERROR, ("RACFG_CMD_ATE_E2PROM_WRITE_BULK is done !\n"));
}
}
break;
case RACFG_CMD_ATE_IO_WRITE_BULK:
{
UINT32 offset, i, value;
USHORT len;
memcpy(&offset, &pRaCfg->status, 4);
offset = ntohl(offset);
memcpy(&len, pRaCfg->data+2, 2);
len = ntohs(len);
for (i = 0; i < len; i += 4)
{
memcpy_exl(pAdapter, (UCHAR *)&value, pRaCfg->data+4+i, 4);
printk("Write %x %x\n", offset + i, value);
RTMP_IO_WRITE32(pAdapter, (offset +i) & 0xffff, value);
}
// prepare feedback
pRaCfg->length = htons(2);
pRaCfg->status = htons(0);
wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
+ sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
+ sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
{
ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_ATE_IO_WRITE_BULK\n"));
Status = -EFAULT;
}
else
{
ATEDBGPRINT(RT_DEBUG_ERROR, ("RACFG_CMD_ATE_IO_WRITE_BULK is done !\n"));
}
}
break;
case RACFG_CMD_ATE_BBP_READ_BULK:
{
USHORT offset;
USHORT len;
USHORT j;
offset = ntohs(pRaCfg->status);
memcpy(&len, pRaCfg->data, 2);
len = ntohs(len);
for (j = offset; j < (offset+len); j++)
{
pRaCfg->data[j - offset] = 0;
if (pAdapter->ate.Mode == ATE_STOP)
{
RTMP_BBP_IO_READ8_BY_REG_ID(pAdapter, j, &pRaCfg->data[j - offset]);
}
else
{
ATE_BBP_IO_READ8_BY_REG_ID(pAdapter, j, &pRaCfg->data[j - offset]);
}
}
// prepare feedback
pRaCfg->length = htons(2+len);
pRaCfg->status = htons(0);
wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
+ sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
+ sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
{
ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_ATE_BBP_READ_BULK\n"));
Status = -EFAULT;
}
else
{
ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_ATE_BBP_READ_BULK is done !\n"));
}
}
break;
case RACFG_CMD_ATE_BBP_WRITE_BULK:
{
USHORT offset;
USHORT len;
USHORT j;
UCHAR *value;
offset = ntohs(pRaCfg->status);
memcpy(&len, pRaCfg->data, 2);
len = ntohs(len);
for (j = offset; j < (offset+len); j++)
{
value = pRaCfg->data + 2 + (j - offset);
if (pAdapter->ate.Mode == ATE_STOP)
{
RTMP_BBP_IO_WRITE8_BY_REG_ID(pAdapter, j, *value);
}
else
{
ATE_BBP_IO_WRITE8_BY_REG_ID(pAdapter, j, *value);
}
}
// prepare feedback
pRaCfg->length = htons(2);
pRaCfg->status = htons(0);
wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
+ sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
+ sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
{
ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_ATE_BBP_WRITE_BULK\n"));
Status = -EFAULT;
}
else
{
ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_ATE_BBP_WRITE_BULK is done !\n"));
}
}
break;
#ifdef CONFIG_RALINK_RT3052
case RACFG_CMD_ATE_RF_READ_BULK:
{
USHORT offset;
USHORT len;
USHORT j;
offset = ntohs(pRaCfg->status);
memcpy(&len, pRaCfg->data, 2);
len = ntohs(len);
for (j = offset; j < (offset+len); j++)
{
pRaCfg->data[j - offset] = 0;
RT30xxReadRFRegister(pAdapter, j, &pRaCfg->data[j - offset]);
}
// prepare feedback
pRaCfg->length = htons(2+len);
pRaCfg->status = htons(0);
wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
+ sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
+ sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
{
ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_ATE_RF_READ_BULK\n"));
Status = -EFAULT;
}
else
{
ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_ATE_RF_READ_BULK is done !\n"));
}
}
break;
case RACFG_CMD_ATE_RF_WRITE_BULK:
{
USHORT offset;
USHORT len;
USHORT j;
UCHAR *value;
offset = ntohs(pRaCfg->status);
memcpy(&len, pRaCfg->data, 2);
len = ntohs(len);
for (j = offset; j < (offset+len); j++)
{
value = pRaCfg->data + 2 + (j - offset);
RT30xxWriteRFRegister(pAdapter, j, *value);
}
// prepare feedback
pRaCfg->length = htons(2);
pRaCfg->status = htons(0);
wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
+ sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
+ sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
{
ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_ATE_RF_WRITE_BULK\n"));
Status = -EFAULT;
}
else
{
ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_ATE_RF_WRITE_BULK is done !\n"));
}
}
break;
#endif
case RACFG_CMD_GET_NOISE_LEVEL:
{
UCHAR channel;
INT32 buffer[3][10];/* 3 : RxPath ; 10 : no. of per rssi samples */
channel = (ntohs(pRaCfg->status) & 0x00FF);
CalNoiseLevel(pAdapter, channel, buffer);
memcpy_exl(pAdapter, (UCHAR *)pRaCfg->data, (UCHAR *)&(buffer[0][0]), (sizeof(INT32)*3*10));
// prepare feedback
pRaCfg->length = htons(2 + (sizeof(INT32)*3*10));
pRaCfg->status = htons(0);
wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
+ sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
+ sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
{
ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_GET_NOISE_LEVEL\n"));
Status = -EFAULT;
}
else
{
ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_GET_NOISE_LEVEL is done !\n"));
}
}
break;
case RACFG_CMD_GET_COUNTER:
{
memcpy_exl(pAdapter, &pRaCfg->data[0], (UCHAR *)&pAdapter->ate.U2M, 4);
memcpy_exl(pAdapter, &pRaCfg->data[4], (UCHAR *)&pAdapter->ate.OtherData, 4);
memcpy_exl(pAdapter, &pRaCfg->data[8], (UCHAR *)&pAdapter->ate.Beacon, 4);
memcpy_exl(pAdapter, &pRaCfg->data[12], (UCHAR *)&pAdapter->ate.OtherCount, 4);
memcpy_exl(pAdapter, &pRaCfg->data[16], (UCHAR *)&pAdapter->ate.TxAc0, 4);
memcpy_exl(pAdapter, &pRaCfg->data[20], (UCHAR *)&pAdapter->ate.TxAc1, 4);
memcpy_exl(pAdapter, &pRaCfg->data[24], (UCHAR *)&pAdapter->ate.TxAc2, 4);
memcpy_exl(pAdapter, &pRaCfg->data[28], (UCHAR *)&pAdapter->ate.TxAc3, 4);
memcpy_exl(pAdapter, &pRaCfg->data[32], (UCHAR *)&pAdapter->ate.TxHCCA, 4);
memcpy_exl(pAdapter, &pRaCfg->data[36], (UCHAR *)&pAdapter->ate.TxMgmt, 4);
memcpy_exl(pAdapter, &pRaCfg->data[40], (UCHAR *)&pAdapter->ate.RSSI0, 4);
memcpy_exl(pAdapter, &pRaCfg->data[44], (UCHAR *)&pAdapter->ate.RSSI1, 4);
memcpy_exl(pAdapter, &pRaCfg->data[48], (UCHAR *)&pAdapter->ate.RSSI2, 4);
memcpy_exl(pAdapter, &pRaCfg->data[52], (UCHAR *)&pAdapter->ate.SNR0, 4);
memcpy_exl(pAdapter, &pRaCfg->data[56], (UCHAR *)&pAdapter->ate.SNR1, 4);
pRaCfg->length = htons(2+60);
pRaCfg->status = htons(0);
wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
+ sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
+ sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
{
ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_GET_COUNTER\n"));
Status = -EFAULT;
}
else
{
ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_GET_COUNTER is done !\n"));
}
}
break;
case RACFG_CMD_CLEAR_COUNTER:
{
pAdapter->ate.U2M = 0;
pAdapter->ate.OtherData = 0;
pAdapter->ate.Beacon = 0;
pAdapter->ate.OtherCount = 0;
pAdapter->ate.TxAc0 = 0;
pAdapter->ate.TxAc1 = 0;
pAdapter->ate.TxAc2 = 0;
pAdapter->ate.TxAc3 = 0;
pAdapter->ate.TxHCCA = 0;
pAdapter->ate.TxMgmt = 0;
pAdapter->ate.TxDoneCount = 0;
pRaCfg->length = htons(2);
pRaCfg->status = htons(0);
wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
+ sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
+ sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
{
ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_CLEAR_COUNTER\n"));
Status = -EFAULT;
}
else
{
ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_CLEAR_COUNTER is done !\n"));
}
}
break;
case RACFG_CMD_TX_START:
{
USHORT *p;
USHORT err = 1;
UCHAR Bbp22Value = 0, Bbp24Value = 0;
if ((pAdapter->ate.TxStatus != 0) && (pAdapter->ate.Mode & ATE_TXFRAME))
{
ATEDBGPRINT(RT_DEBUG_TRACE,("Ate Tx is already running, to run next Tx, you must stop it first\n"));
err = 2;
goto TX_START_ERROR;
}
else if ((pAdapter->ate.TxStatus != 0) && !(pAdapter->ate.Mode & ATE_TXFRAME))
{
int i = 0;
while ((i++ < 10) && (pAdapter->ate.TxStatus != 0))
{
RTMPusecDelay(5000);
}
// force it to stop
pAdapter->ate.TxStatus = 0;
pAdapter->ate.TxDoneCount = 0;
//pAdapter->ate.Repeat = 0;
pAdapter->ate.bQATxStart = FALSE;
}
// If pRaCfg->length == 0, this "RACFG_CMD_TX_START" is for Carrier test or Carrier Suppression.
if (ntohs(pRaCfg->length) != 0)
{
// Get frame info
#ifdef RT2870
NdisMoveMemory(&pAdapter->ate.TxInfo, pRaCfg->data - 2, 4);
#ifdef RT_BIG_ENDIAN
RTMPDescriptorEndianChange((PUCHAR) &pAdapter->ate.TxInfo, TYPE_TXINFO);
#endif // RT_BIG_ENDIAN //
#endif // RT2870 //
NdisMoveMemory(&pAdapter->ate.TxWI, pRaCfg->data + 2, 16);
#ifdef RT_BIG_ENDIAN
RTMPWIEndianChange((PUCHAR)&pAdapter->ate.TxWI, TYPE_TXWI);
#endif // RT_BIG_ENDIAN //
NdisMoveMemory(&pAdapter->ate.TxCount, pRaCfg->data + 18, 4);
pAdapter->ate.TxCount = ntohl(pAdapter->ate.TxCount);
p = (USHORT *)(&pRaCfg->data[22]);
//p = pRaCfg->data + 22;
// always use QID_AC_BE
pAdapter->ate.QID = 0;
p = (USHORT *)(&pRaCfg->data[24]);
//p = pRaCfg->data + 24;
pAdapter->ate.HLen = ntohs(*p);
if (pAdapter->ate.HLen > 32)
{
ATEDBGPRINT(RT_DEBUG_ERROR,("pAdapter->ate.HLen > 32\n"));
err = 3;
goto TX_START_ERROR;
}
NdisMoveMemory(&pAdapter->ate.Header, pRaCfg->data + 26, pAdapter->ate.HLen);
pAdapter->ate.PLen = ntohs(pRaCfg->length) - (pAdapter->ate.HLen + 28);
if (pAdapter->ate.PLen > 32)
{
ATEDBGPRINT(RT_DEBUG_ERROR,("pAdapter->ate.PLen > 32\n"));
err = 4;
goto TX_START_ERROR;
}
NdisMoveMemory(&pAdapter->ate.Pattern, pRaCfg->data + 26 + pAdapter->ate.HLen, pAdapter->ate.PLen);
pAdapter->ate.DLen = pAdapter->ate.TxWI.MPDUtotalByteCount - pAdapter->ate.HLen;
}
ATE_BBP_IO_READ8_BY_REG_ID(pAdapter, BBP_R22, &Bbp22Value);
switch (Bbp22Value)
{
case BBP22_TXFRAME:
{
if (pAdapter->ate.TxCount == 0)
{
}
ATEDBGPRINT(RT_DEBUG_TRACE,("START TXFRAME\n"));
pAdapter->ate.bQATxStart = TRUE;
Set_ATE_Proc(pAdapter, "TXFRAME");
}
break;
case BBP22_TXCONT_OR_CARRSUPP:
{
ATEDBGPRINT(RT_DEBUG_TRACE,("BBP22_TXCONT_OR_CARRSUPP\n"));
ATE_BBP_IO_READ8_BY_REG_ID(pAdapter, 24, &Bbp24Value);
switch (Bbp24Value)
{
case BBP24_TXCONT:
{
ATEDBGPRINT(RT_DEBUG_TRACE,("START TXCONT\n"));
pAdapter->ate.bQATxStart = TRUE;
Set_ATE_Proc(pAdapter, "TXCONT");
}
break;
case BBP24_CARRSUPP:
{
ATEDBGPRINT(RT_DEBUG_TRACE,("START TXCARRSUPP\n"));
pAdapter->ate.bQATxStart = TRUE;
pAdapter->ate.Mode |= ATE_TXCARRSUPP;
}
break;
default:
{
ATEDBGPRINT(RT_DEBUG_ERROR,("Unknown Start TX subtype !"));
}
break;
}
}
break;
case BBP22_TXCARR:
{
ATEDBGPRINT(RT_DEBUG_TRACE,("START TXCARR\n"));
pAdapter->ate.bQATxStart = TRUE;
Set_ATE_Proc(pAdapter, "TXCARR");
}
break;
default:
{
ATEDBGPRINT(RT_DEBUG_ERROR,("Unknown Start TX subtype !"));
}
break;
}
if (pAdapter->ate.bQATxStart == TRUE)
{
// prepare feedback
pRaCfg->length = htons(2);
pRaCfg->status = htons(0);
wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
+ sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
+ sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
{
ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() was failed in case RACFG_CMD_TX_START\n"));
Status = -EFAULT;
}
else
{
ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_TX_START is done !\n"));
}
break;
}
TX_START_ERROR:
// prepare feedback
pRaCfg->length = htons(2);
pRaCfg->status = htons(err);
wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
+ sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
+ sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
{
ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_TX_START\n"));
Status = -EFAULT;
}
else
{
ATEDBGPRINT(RT_DEBUG_TRACE, ("feedback of TX_START_ERROR is done !\n"));
}
}
break;
case RACFG_CMD_GET_TX_STATUS:
{
UINT32 count;
// prepare feedback
pRaCfg->length = htons(6);
pRaCfg->status = htons(0);
count = htonl(pAdapter->ate.TxDoneCount);
NdisMoveMemory(pRaCfg->data, &count, 4);
wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
+ sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
+ sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
{
ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_GET_TX_STATUS\n"));
Status = -EFAULT;
}
else
{
ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_GET_TX_STATUS is done !\n"));
}
}
break;
case RACFG_CMD_TX_STOP:
{
ATEDBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_TX_STOP\n"));
Set_ATE_Proc(pAdapter, "TXSTOP");
// prepare feedback
pRaCfg->length = htons(2);
pRaCfg->status = htons(0);
wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
+ sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
+ sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
{
ATEDBGPRINT(RT_DEBUG_TRACE, ("copy_to_user() fail in case RACFG_CMD_TX_STOP\n"));
Status = -EFAULT;
}
else
{
ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_TX_STOP is done !\n"));
}
}
break;
case RACFG_CMD_RX_START:
{
ATEDBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_RX_START\n"));
pAdapter->ate.bQARxStart = TRUE;
Set_ATE_Proc(pAdapter, "RXFRAME");
// prepare feedback
pRaCfg->length = htons(2);
pRaCfg->status = htons(0);
wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
+ sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
+ sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
{
ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_RX_START\n"));
Status = -EFAULT;
}
else
{
ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_RX_START is done !\n"));
}
}
break;
case RACFG_CMD_RX_STOP:
{
ATEDBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_RX_STOP\n"));
Set_ATE_Proc(pAdapter, "RXSTOP");
// prepare feedback
pRaCfg->length = htons(2);
pRaCfg->status = htons(0);
wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
+ sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
+ sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
{
ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_RX_STOP\n"));
Status = -EFAULT;
}
else
{
ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_RX_STOP is done !\n"));
}
}
break;
/* The following cases are for new ATE GUI(not QA). */
/*==================================================*/
case RACFG_CMD_ATE_START_TX_CARRIER:
{
ATEDBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_START_TX_CARRIER\n"));
Set_ATE_Proc(pAdapter, "TXCARR");
pRaCfg->length = htons(2);
pRaCfg->status = htons(0);
wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
+ sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
+ sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
ATEDBGPRINT(RT_DEBUG_TRACE, ("wrq->u.data.length = %d\n", wrq->u.data.length));
if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
{
ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_ATE_START_TX_CARRIER\n"));
Status = -EFAULT;
}
else
{
ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_ATE_START_TX_CARRIER is done !\n"));
}
}
break;
case RACFG_CMD_ATE_START_TX_CONT:
{
ATEDBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_START_TX_CONT\n"));
Set_ATE_Proc(pAdapter, "TXCONT");
pRaCfg->length = htons(2);
pRaCfg->status = htons(0);
wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
+ sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
+ sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
ATEDBGPRINT(RT_DEBUG_TRACE, ("wrq->u.data.length = %d\n", wrq->u.data.length));
if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
{
ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_ATE_START_TX_CONT\n"));
Status = -EFAULT;
}
else
{
ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_ATE_START_TX_CONT is done !\n"));
}
}
break;
case RACFG_CMD_ATE_START_TX_FRAME:
{
ATEDBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_START_TX_FRAME\n"));
Set_ATE_Proc(pAdapter, "TXFRAME");
pRaCfg->length = htons(2);
pRaCfg->status = htons(0);
wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
+ sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
+ sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
ATEDBGPRINT(RT_DEBUG_TRACE, ("wrq->u.data.length = %d\n", wrq->u.data.length));
if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
{
ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_ATE_START_TX_FRAME\n"));
Status = -EFAULT;
}
else
{
ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_ATE_START_TX_FRAME is done !\n"));
}
}
break;
case RACFG_CMD_ATE_SET_BW:
{
SHORT value = 0;
UCHAR str[LEN_OF_ARG];
NdisZeroMemory(str, LEN_OF_ARG);
ATEDBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_SET_BW\n"));
memcpy((PUCHAR)&value, (PUCHAR)&(pRaCfg->status), 2);
value = ntohs(value);
sprintf((PCHAR)str, "%d", value);
Set_ATE_TX_BW_Proc(pAdapter, str);
// prepare feedback
pRaCfg->length = htons(2);
pRaCfg->status = htons(0);
wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
+ sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
+ sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
{
ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_ATE_SET_BW\n"));
Status = -EFAULT;
}
else
{
ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_ATE_SET_BW is done !\n"));
}
}
break;
case RACFG_CMD_ATE_SET_TX_POWER0:
{
SHORT value = 0;
UCHAR str[LEN_OF_ARG];
NdisZeroMemory(str, LEN_OF_ARG);
ATEDBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_SET_TX_POWER0\n"));
memcpy((PUCHAR)&value, (PUCHAR)&(pRaCfg->status), 2);
value = ntohs(value);
sprintf((PCHAR)str, "%d", value);
Set_ATE_TX_POWER0_Proc(pAdapter, str);
// prepare feedback
pRaCfg->length = htons(2);
pRaCfg->status = htons(0);
wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
+ sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
+ sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
{
ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_ATE_SET_TX_POWER0\n"));
Status = -EFAULT;
}
else
{
ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_ATE_SET_TX_POWER0 is done !\n"));
}
}
break;
case RACFG_CMD_ATE_SET_TX_POWER1:
{
SHORT value = 0;
UCHAR str[LEN_OF_ARG];
NdisZeroMemory(str, LEN_OF_ARG);
ATEDBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_SET_TX_POWER1\n"));
memcpy((PUCHAR)&value, (PUCHAR)&(pRaCfg->status), 2);
value = ntohs(value);
sprintf((PCHAR)str, "%d", value);
Set_ATE_TX_POWER1_Proc(pAdapter, str);
// prepare feedback
pRaCfg->length = htons(2);
pRaCfg->status = htons(0);
wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
+ sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
+ sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
{
ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_ATE_SET_TX_POWER1\n"));
Status = -EFAULT;
}
else
{
ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_ATE_SET_TX_POWER1 is done !\n"));
}
}
break;
case RACFG_CMD_ATE_SET_FREQ_OFFSET:
{
SHORT value = 0;
UCHAR str[LEN_OF_ARG];
NdisZeroMemory(str, LEN_OF_ARG);
ATEDBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_SET_FREQ_OFFSET\n"));
memcpy((PUCHAR)&value, (PUCHAR)&(pRaCfg->status), 2);
value = ntohs(value);
sprintf((PCHAR)str, "%d", value);
Set_ATE_TX_FREQOFFSET_Proc(pAdapter, str);
// prepare feedback
pRaCfg->length = htons(2);
pRaCfg->status = htons(0);
wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
+ sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
+ sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
{
ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_ATE_SET_FREQ_OFFSET\n"));
Status = -EFAULT;
}
else
{
ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_ATE_SET_FREQ_OFFSET is done !\n"));
}
}
break;
case RACFG_CMD_ATE_GET_STATISTICS:
{
ATEDBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_GET_STATISTICS\n"));
memcpy_exl(pAdapter, &pRaCfg->data[0], (UCHAR *)&pAdapter->ate.TxDoneCount, 4);
memcpy_exl(pAdapter, &pRaCfg->data[4], (UCHAR *)&pAdapter->WlanCounters.RetryCount.u.LowPart, 4);
memcpy_exl(pAdapter, &pRaCfg->data[8], (UCHAR *)&pAdapter->WlanCounters.FailedCount.u.LowPart, 4);
memcpy_exl(pAdapter, &pRaCfg->data[12], (UCHAR *)&pAdapter->WlanCounters.RTSSuccessCount.u.LowPart, 4);
memcpy_exl(pAdapter, &pRaCfg->data[16], (UCHAR *)&pAdapter->WlanCounters.RTSFailureCount.u.LowPart, 4);
memcpy_exl(pAdapter, &pRaCfg->data[20], (UCHAR *)&pAdapter->WlanCounters.ReceivedFragmentCount.QuadPart, 4);
memcpy_exl(pAdapter, &pRaCfg->data[24], (UCHAR *)&pAdapter->WlanCounters.FCSErrorCount.u.LowPart, 4);
memcpy_exl(pAdapter, &pRaCfg->data[28], (UCHAR *)&pAdapter->Counters8023.RxNoBuffer, 4);
memcpy_exl(pAdapter, &pRaCfg->data[32], (UCHAR *)&pAdapter->WlanCounters.FrameDuplicateCount.u.LowPart, 4);
memcpy_exl(pAdapter, &pRaCfg->data[36], (UCHAR *)&pAdapter->RalinkCounters.OneSecFalseCCACnt, 4);
if (pAdapter->ate.RxAntennaSel == 0)
{
INT32 RSSI0 = 0;
INT32 RSSI1 = 0;
INT32 RSSI2 = 0;
RSSI0 = (INT32)(pAdapter->ate.LastRssi0 - pAdapter->BbpRssiToDbmDelta);
RSSI1 = (INT32)(pAdapter->ate.LastRssi1 - pAdapter->BbpRssiToDbmDelta);
RSSI2 = (INT32)(pAdapter->ate.LastRssi2 - pAdapter->BbpRssiToDbmDelta);
memcpy_exl(pAdapter, &pRaCfg->data[40], (UCHAR *)&RSSI0, 4);
memcpy_exl(pAdapter, &pRaCfg->data[44], (UCHAR *)&RSSI1, 4);
memcpy_exl(pAdapter, &pRaCfg->data[48], (UCHAR *)&RSSI2, 4);
pRaCfg->length = htons(2+52);
}
else
{
INT32 RSSI0 = 0;
RSSI0 = (INT32)(pAdapter->ate.LastRssi0 - pAdapter->BbpRssiToDbmDelta);
memcpy_exl(pAdapter, &pRaCfg->data[40], (UCHAR *)&RSSI0, 4);
pRaCfg->length = htons(2+44);
}
pRaCfg->status = htons(0);
wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
+ sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
+ sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
{
ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_ATE_GET_STATISTICS\n"));
Status = -EFAULT;
}
else
{
ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_ATE_GET_STATISTICS is done !\n"));
}
}
break;
case RACFG_CMD_ATE_RESET_COUNTER:
{
SHORT value = 1;
UCHAR str[LEN_OF_ARG];
NdisZeroMemory(str, LEN_OF_ARG);
ATEDBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_RESET_COUNTER\n"));
sprintf((PCHAR)str, "%d", value);
Set_ResetStatCounter_Proc(pAdapter, str);
pAdapter->ate.TxDoneCount = 0;
pRaCfg->length = htons(2);
pRaCfg->status = htons(0);
wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
+ sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
+ sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
{
ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_ATE_RESET_COUNTER\n"));
Status = -EFAULT;
}
else
{
ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_ATE_RESET_COUNTER is done !\n"));
}
}
break;
case RACFG_CMD_ATE_SEL_TX_ANTENNA:
{
SHORT value = 0;
UCHAR str[LEN_OF_ARG];
NdisZeroMemory(str, LEN_OF_ARG);
ATEDBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_SEL_TX_ANTENNA\n"));
memcpy((PUCHAR)&value, (PUCHAR)&(pRaCfg->status), 2);
value = ntohs(value);
sprintf((PCHAR)str, "%d", value);
Set_ATE_TX_Antenna_Proc(pAdapter, str);
// prepare feedback
pRaCfg->length = htons(2);
pRaCfg->status = htons(0);
wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
+ sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
+ sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
{
ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_ATE_SEL_TX_ANTENNA\n"));
Status = -EFAULT;
}
else
{
ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_ATE_SEL_TX_ANTENNA is done !\n"));
}
}
break;
case RACFG_CMD_ATE_SEL_RX_ANTENNA:
{
SHORT value = 0;
UCHAR str[LEN_OF_ARG];
NdisZeroMemory(str, LEN_OF_ARG);
ATEDBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_SEL_RX_ANTENNA\n"));
memcpy((PUCHAR)&value, (PUCHAR)&(pRaCfg->status), 2);
value = ntohs(value);
sprintf((PCHAR)str, "%d", value);
Set_ATE_RX_Antenna_Proc(pAdapter, str);
// prepare feedback
pRaCfg->length = htons(2);
pRaCfg->status = htons(0);
wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
+ sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
+ sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
{
ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_ATE_SEL_RX_ANTENNA\n"));
Status = -EFAULT;
}
else
{
ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_ATE_SEL_RX_ANTENNA is done !\n"));
}
}
break;
case RACFG_CMD_ATE_SET_PREAMBLE:
{
SHORT value = 0;
UCHAR str[LEN_OF_ARG];
NdisZeroMemory(str, LEN_OF_ARG);
ATEDBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_SET_PREAMBLE\n"));
memcpy((PUCHAR)&value, (PUCHAR)&(pRaCfg->status), 2);
value = ntohs(value);
sprintf((PCHAR)str, "%d", value);
Set_ATE_TX_MODE_Proc(pAdapter, str);
// prepare feedback
pRaCfg->length = htons(2);
pRaCfg->status = htons(0);
wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
+ sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
+ sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
{
ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_ATE_SET_PREAMBLE\n"));
Status = -EFAULT;
}
else
{
ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_ATE_SET_PREAMBLE is done !\n"));
}
}
break;
case RACFG_CMD_ATE_SET_CHANNEL:
{
SHORT value = 0;
UCHAR str[LEN_OF_ARG];
NdisZeroMemory(str, LEN_OF_ARG);
ATEDBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_SET_CHANNEL\n"));
memcpy((PUCHAR)&value, (PUCHAR)&(pRaCfg->status), 2);
value = ntohs(value);
sprintf((PCHAR)str, "%d", value);
Set_ATE_CHANNEL_Proc(pAdapter, str);
// prepare feedback
pRaCfg->length = htons(2);
pRaCfg->status = htons(0);
wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
+ sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
+ sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
{
ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_ATE_SET_CHANNEL\n"));
Status = -EFAULT;
}
else
{
ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_ATE_SET_CHANNEL is done !\n"));
}
}
break;
case RACFG_CMD_ATE_SET_ADDR1:
{
ATEDBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_SET_ADDR1\n"));
// Addr is an array of UCHAR,
// so no need to perform endian swap.
memcpy(pAdapter->ate.Addr1, (PUCHAR)(pRaCfg->data - 2), MAC_ADDR_LEN);
// prepare feedback
pRaCfg->length = htons(2);
pRaCfg->status = htons(0);
wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
+ sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
+ sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
{
ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_ATE_SET_ADDR1\n"));
Status = -EFAULT;
}
else
{
ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_ATE_SET_ADDR1 is done !\n (ADDR1 = %2X:%2X:%2X:%2X:%2X:%2X)\n", pAdapter->ate.Addr1[0],
pAdapter->ate.Addr1[1], pAdapter->ate.Addr1[2], pAdapter->ate.Addr1[3], pAdapter->ate.Addr1[4], pAdapter->ate.Addr1[5]));
}
}
break;
case RACFG_CMD_ATE_SET_ADDR2:
{
ATEDBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_SET_ADDR2\n"));
// Addr is an array of UCHAR,
// so no need to perform endian swap.
memcpy(pAdapter->ate.Addr2, (PUCHAR)(pRaCfg->data - 2), MAC_ADDR_LEN);
// prepare feedback
pRaCfg->length = htons(2);
pRaCfg->status = htons(0);
wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
+ sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
+ sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
{
ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_ATE_SET_ADDR2\n"));
Status = -EFAULT;
}
else
{
ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_ATE_SET_ADDR2 is done !\n (ADDR2 = %2X:%2X:%2X:%2X:%2X:%2X)\n", pAdapter->ate.Addr2[0],
pAdapter->ate.Addr2[1], pAdapter->ate.Addr2[2], pAdapter->ate.Addr2[3], pAdapter->ate.Addr2[4], pAdapter->ate.Addr2[5]));
}
}
break;
case RACFG_CMD_ATE_SET_ADDR3:
{
ATEDBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_SET_ADDR3\n"));
// Addr is an array of UCHAR,
// so no need to perform endian swap.
memcpy(pAdapter->ate.Addr3, (PUCHAR)(pRaCfg->data - 2), MAC_ADDR_LEN);
// prepare feedback
pRaCfg->length = htons(2);
pRaCfg->status = htons(0);
wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
+ sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
+ sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
{
ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_ATE_SET_ADDR3\n"));
Status = -EFAULT;
}
else
{
ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_ATE_SET_ADDR3 is done !\n (ADDR3 = %2X:%2X:%2X:%2X:%2X:%2X)\n", pAdapter->ate.Addr3[0],
pAdapter->ate.Addr3[1], pAdapter->ate.Addr3[2], pAdapter->ate.Addr3[3], pAdapter->ate.Addr3[4], pAdapter->ate.Addr3[5]));
}
}
break;
case RACFG_CMD_ATE_SET_RATE:
{
SHORT value = 0;
UCHAR str[LEN_OF_ARG];
NdisZeroMemory(str, LEN_OF_ARG);
ATEDBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_SET_RATE\n"));
memcpy((PUCHAR)&value, (PUCHAR)&(pRaCfg->status), 2);
value = ntohs(value);
sprintf((PCHAR)str, "%d", value);
Set_ATE_TX_MCS_Proc(pAdapter, str);
// prepare feedback
pRaCfg->length = htons(2);
pRaCfg->status = htons(0);
wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
+ sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
+ sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
{
ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_ATE_SET_RATE\n"));
Status = -EFAULT;
}
else
{
ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_ATE_SET_RATE is done !\n"));
}
}
break;
case RACFG_CMD_ATE_SET_TX_FRAME_LEN:
{
SHORT value = 0;
UCHAR str[LEN_OF_ARG];
NdisZeroMemory(str, LEN_OF_ARG);
ATEDBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_SET_TX_FRAME_LEN\n"));
memcpy((PUCHAR)&value, (PUCHAR)&(pRaCfg->status), 2);
value = ntohs(value);
sprintf((PCHAR)str, "%d", value);
Set_ATE_TX_LENGTH_Proc(pAdapter, str);
// prepare feedback
pRaCfg->length = htons(2);
pRaCfg->status = htons(0);
wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
+ sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
+ sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
{
ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_ATE_SET_TX_FRAME_LEN\n"));
Status = -EFAULT;
}
else
{
ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_ATE_SET_TX_FRAME_LEN is done !\n"));
}
}
break;
case RACFG_CMD_ATE_SET_TX_FRAME_COUNT:
{
USHORT value = 0;
UCHAR str[LEN_OF_ARG];
NdisZeroMemory(str, LEN_OF_ARG);
ATEDBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_SET_TX_FRAME_COUNT\n"));
memcpy((PUCHAR)&value, (PUCHAR)&(pRaCfg->status), 2);
value = ntohs(value);
{
sprintf((PCHAR)str, "%d", value);
Set_ATE_TX_COUNT_Proc(pAdapter, str);
}
// prepare feedback
pRaCfg->length = htons(2);
pRaCfg->status = htons(0);
wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
+ sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
+ sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
{
ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_ATE_SET_TX_FRAME_COUNT\n"));
Status = -EFAULT;
}
else
{
ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_ATE_SET_TX_FRAME_COUNT is done !\n"));
}
}
break;
case RACFG_CMD_ATE_START_RX_FRAME:
{
ATEDBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_RX_START\n"));
Set_ATE_Proc(pAdapter, "RXFRAME");
// prepare feedback
pRaCfg->length = htons(2);
pRaCfg->status = htons(0);
wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
+ sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
+ sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
{
ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_RX_START\n"));
Status = -EFAULT;
}
else
{
ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_RX_START is done !\n"));
}
}
break;
default:
break;
}
ASSERT(pRaCfg != NULL);
if (pRaCfg != NULL)
{
kfree(pRaCfg);
}
return;
}
Generated by GNU enscript 1.6.4.