osl_t *
osl_attach(void *pdev, bool pkttag)
{
osl_t *osh;
osh = kmalloc(sizeof(osl_t), GFP_ATOMIC);
ASSERT(osh);
bzero(osh, sizeof(osl_t));
/*
* check the cases where
* 1.Error code Added to bcmerror table, but forgot to add it to the OS
* dependent error code
* 2. Error code is added to the bcmerror table, but forgot to add the
* corresponding errorstring(dummy call to bcmerrorstr)
*/
bcmerrorstr(0);
ASSERT(ABS(BCME_LAST) == (ARRAYSIZE(linuxbcmerrormap) - 1));
osh->magic = OS_HANDLE_MAGIC;
osh->malloced = 0;
osh->failed = 0;
osh->dbgmem_list = NULL;
osh->pdev = pdev;
osh->pub.pkttag = pkttag;
return osh;
}
static int
dhd_doiovar(dhd_pub_t *dhd_pub, const bcm_iovar_t *vi, uint32 actionid,
const char *name, void *params, int plen, void *arg, int len, int val_size)
{
int bcmerror = 0;
int32 int_val = 0;
DHD_TRACE(("%s: Enter\n", __FUNCTION__));
if ((bcmerror = bcm_iovar_lencheck(vi, arg, len, IOV_ISSET(actionid))) != 0)
goto exit;
if (plen >= (int)sizeof(int_val))
bcopy(params, &int_val, sizeof(int_val));
switch (actionid) {
case IOV_GVAL(IOV_VERSION):
/* Need to have checked buffer length */
strncpy((char*)arg, dhd_version, len);
break;
case IOV_GVAL(IOV_MSGLEVEL):
int_val = (int32)dhd_msg_level;
bcopy(&int_val, arg, val_size);
break;
case IOV_SVAL(IOV_MSGLEVEL):
dhd_msg_level = int_val;
break;
case IOV_GVAL(IOV_BCMERRORSTR):
strncpy((char *)arg, bcmerrorstr(dhd_pub->bcmerror), BCME_STRLEN);
((char *)arg)[BCME_STRLEN - 1] = 0x00;
break;
case IOV_GVAL(IOV_BCMERROR):
int_val = (int32)dhd_pub->bcmerror;
bcopy(&int_val, arg, val_size);
break;
case IOV_GVAL(IOV_WDTICK):
int_val = (int32)dhd_watchdog_ms;
bcopy(&int_val, arg, val_size);
break;
case IOV_SVAL(IOV_WDTICK):
if (!dhd_pub->up) {
bcmerror = BCME_NOTUP;
break;
}
dhd_os_wd_timer(dhd_pub, (uint)int_val);
break;
case IOV_GVAL(IOV_DUMP):
bcmerror = dhd_dump(dhd_pub, arg, len);
break;
case IOV_SVAL(IOV_CLEARCOUNTS):
dhd_pub->tx_packets = dhd_pub->rx_packets = 0;
dhd_pub->tx_errors = dhd_pub->rx_errors = 0;
dhd_pub->tx_ctlpkts = dhd_pub->rx_ctlpkts = 0;
dhd_pub->tx_ctlerrs = dhd_pub->rx_ctlerrs = 0;
dhd_pub->rx_dropped = 0;
dhd_pub->rx_readahead_cnt = 0;
dhd_pub->tx_realloc = 0;
dhd_pub->rx_flushed = 0;
memset(&dhd_pub->dstats, 0, sizeof(dhd_pub->dstats));
dhd_bus_clearcounts(dhd_pub);
break;
case IOV_GVAL(IOV_IOCTLTIMEOUT):
{
int_val = (int32)dhd_os_get_ioctl_resp_timeout();
bcopy(&int_val, arg, sizeof(int_val));
break;
}
case IOV_SVAL(IOV_IOCTLTIMEOUT):
{
if (int_val <= 0)
bcmerror = BCME_BADARG;
else
dhd_os_set_ioctl_resp_timeout((unsigned int)int_val);
break;
}
default:
bcmerror = BCME_UNSUPPORTED;
break;
}
exit:
return bcmerror;
}
static int
dhd_doiovar(dhd_pub_t *dhd_pub, const bcm_iovar_t *vi, uint32 actionid, const char *name,
void *params, int plen, void *arg, int len, int val_size)
{
int bcmerror = 0;
int32 int_val = 0;
DHD_TRACE(("%s: Enter\n", __FUNCTION__));
DHD_TRACE(("%s: actionid = %d; name %s\n", __FUNCTION__, actionid, name));
if ((bcmerror = bcm_iovar_lencheck(vi, arg, len, IOV_ISSET(actionid))) != 0)
goto exit;
if (plen >= (int)sizeof(int_val))
bcopy(params, &int_val, sizeof(int_val));
switch (actionid) {
case IOV_GVAL(IOV_VERSION):
/* Need to have checked buffer length */
strncpy((char*)arg, dhd_version, len);
break;
case IOV_GVAL(IOV_MSGLEVEL):
int_val = (int32)dhd_msg_level;
bcopy(&int_val, arg, val_size);
break;
case IOV_SVAL(IOV_MSGLEVEL):
dhd_msg_level = int_val;
break;
case IOV_GVAL(IOV_BCMERRORSTR):
strncpy((char *)arg, bcmerrorstr(dhd_pub->bcmerror), BCME_STRLEN);
((char *)arg)[BCME_STRLEN - 1] = 0x00;
break;
case IOV_GVAL(IOV_BCMERROR):
int_val = (int32)dhd_pub->bcmerror;
bcopy(&int_val, arg, val_size);
break;
case IOV_GVAL(IOV_WDTICK):
int_val = (int32)dhd_watchdog_ms;
bcopy(&int_val, arg, val_size);
break;
case IOV_SVAL(IOV_WDTICK):
if (!dhd_pub->up) {
bcmerror = BCME_NOTUP;
break;
}
dhd_os_wd_timer(dhd_pub, (uint)int_val);
break;
case IOV_GVAL(IOV_DUMP):
bcmerror = dhd_dump(dhd_pub, arg, len);
break;
#ifdef DHD_DEBUG
case IOV_GVAL(IOV_DCONSOLE_POLL):
int_val = (int32)dhd_console_ms;
bcopy(&int_val, arg, val_size);
break;
case IOV_SVAL(IOV_DCONSOLE_POLL):
dhd_console_ms = (uint)int_val;
break;
case IOV_SVAL(IOV_CONS):
if (len > 0)
bcmerror = dhd_bus_console_in(dhd_pub, arg, len - 1);
break;
#endif /* DHD_DEBUG */
case IOV_SVAL(IOV_CLEARCOUNTS):
dhd_pub->tx_packets = dhd_pub->rx_packets = 0;
dhd_pub->tx_errors = dhd_pub->rx_errors = 0;
dhd_pub->tx_ctlpkts = dhd_pub->rx_ctlpkts = 0;
dhd_pub->tx_ctlerrs = dhd_pub->rx_ctlerrs = 0;
dhd_pub->rx_dropped = 0;
dhd_pub->rx_readahead_cnt = 0;
dhd_pub->tx_realloc = 0;
dhd_pub->wd_dpc_sched = 0;
memset(&dhd_pub->dstats, 0, sizeof(dhd_pub->dstats));
dhd_bus_clearcounts(dhd_pub);
break;
case IOV_GVAL(IOV_IOCTLTIMEOUT): {
int_val = (int32)dhd_os_get_ioctl_resp_timeout();
bcopy(&int_val, arg, sizeof(int_val));
break;
}
case IOV_SVAL(IOV_IOCTLTIMEOUT): {
if (int_val <= 0)
bcmerror = BCME_BADARG;
else
dhd_os_set_ioctl_resp_timeout((unsigned int)int_val);
break;
}
case IOV_GVAL(IOV_BUS_TYPE):
/* The dhd application query the driver to check if its usb or sdio. */
#ifdef BCMDHDUSB
int_val = BUS_TYPE_USB;
#endif
int_val = BUS_TYPE_SDIO;
bcopy(&int_val, arg, val_size);
break;
#ifdef WLMEDIA_HTSF
case IOV_GVAL(IOV_WLPKTDLYSTAT_SZ):
int_val = dhd_pub->htsfdlystat_sz;
bcopy(&int_val, arg, val_size);
break;
case IOV_SVAL(IOV_WLPKTDLYSTAT_SZ):
dhd_pub->htsfdlystat_sz = int_val & 0xff;
printf("Setting tsfdlystat_sz:%d\n", dhd_pub->htsfdlystat_sz);
break;
#endif
case IOV_SVAL(IOV_CHANGEMTU):
int_val &= 0xffff;
bcmerror = dhd_change_mtu(dhd_pub, int_val, 0);
break;
default:
bcmerror = BCME_UNSUPPORTED;
break;
}
exit:
DHD_TRACE(("%s: actionid %d, bcmerror %d\n", __FUNCTION__, actionid, bcmerror));
return bcmerror;
}
int
dhdcdc_query_ioctl(dhd_pub_t *dhd, int ifidx, uint cmd, void *buf, uint len)
{
dhd_prot_t *prot = dhd->prot;
cdc_ioctl_t *msg = &prot->msg;
void *info;
int ret = 0, retries = 0;
uint32 id, flags = 0;
DHD_TRACE(("%s: Enter\n", __FUNCTION__));
DHD_CTL(("%s: cmd %d len %d\n", __FUNCTION__, cmd, len));
/* Respond "bcmerror" and "bcmerrorstr" with local cache */
if (cmd == WLC_GET_VAR && buf)
{
if (!strcmp((char *)buf, "bcmerrorstr"))
{
strncpy((char *)buf, bcmerrorstr(dhd->dongle_error), BCME_STRLEN);
goto done;
}
else if (!strcmp((char *)buf, "bcmerror"))
{
*(int *)buf = dhd->dongle_error;
goto done;
}
}
memset(msg, 0, sizeof(cdc_ioctl_t));
msg->cmd = htol32(cmd);
msg->len = htol32(len);
msg->flags = (++prot->reqid << CDCF_IOC_ID_SHIFT);
CDC_SET_IF_IDX(msg, ifidx);
msg->flags = htol32(msg->flags);
if (buf)
memcpy(prot->buf, buf, len);
if ((ret = dhdcdc_msg(dhd)) < 0) {
DHD_ERROR(("dhdcdc_query_ioctl: dhdcdc_msg failed w/status %d\n", ret));
goto done;
}
retry:
/* wait for interrupt and get first fragment */
if ((ret = dhdcdc_cmplt(dhd, prot->reqid, len)) < 0)
goto done;
flags = ltoh32(msg->flags);
id = (flags & CDCF_IOC_ID_MASK) >> CDCF_IOC_ID_SHIFT;
if ((id < prot->reqid) && (++retries < RETRIES))
goto retry;
if (id != prot->reqid) {
DHD_ERROR(("%s: %s: unexpected request id %d (expected %d)\n",
dhd_ifname(dhd, ifidx), __FUNCTION__, id, prot->reqid));
ret = -EINVAL;
goto done;
}
/* Check info buffer */
info = (void*)&msg[1];
/* Copy info buffer */
if (buf)
{
if (ret < (int)len)
len = ret;
memcpy(buf, info, len);
}
/* Check the ERROR flag */
if (flags & CDCF_IOC_ERROR)
{
ret = ltoh32(msg->status);
/* Cache error from dongle */
dhd->dongle_error = ret;
}
done:
return ret;
}
int dhd_preinit_config(dhd_pub_t *dhd, int ifidx)
{
mm_segment_t old_fs;
struct kstat stat;
struct file *fp = NULL;
unsigned int len;
char *buf = NULL, *p, *name, *value;
int ret = 0;
char *config_path;
config_path = CONFIG_BCMDHD_CONFIG_PATH;
if (!config_path)
{
printk(KERN_ERR "config_path can't read. \n");
return 0;
}
old_fs = get_fs();
set_fs(get_ds());
if ((ret = vfs_stat(config_path, &stat))) {
set_fs(old_fs);
printk(KERN_ERR "%s: Failed to get information (%d)\n",
config_path, ret);
return ret;
}
set_fs(old_fs);
if (!(buf = MALLOC(dhd->osh, stat.size + 1))) {
printk(KERN_ERR "Failed to allocate memory %llu bytes\n", stat.size);
return -ENOMEM;
}
printk("dhd_preinit_config : config path : %s \n", config_path);
if (!(fp = dhd_os_open_image(config_path)) ||
(len = dhd_os_get_image_block(buf, stat.size, fp)) < 0)
goto err;
buf[stat.size] = '\0';
for (p = buf; *p; p++) {
if (isspace(*p))
continue;
for (name = p++; *p && !isspace(*p); p++) {
if (*p == '=') {
*p = '\0';
p++;
for (value = p; *p && !isspace(*p); p++);
*p = '\0';
if ((ret = dhd_preinit_proc(dhd, ifidx, name, value)) < 0) {
printk(KERN_ERR "%s: %s=%s\n",
bcmerrorstr(ret), name, value);
}
break;
}
}
}
ret = 0;
out:
if (fp)
dhd_os_close_image(fp);
if (buf)
MFREE(dhd->osh, buf, stat.size+1);
return ret;
err:
ret = -1;
goto out;
}
