/*****************************************************************************
Function : VOS_SmP
Description: Lock the resource for synchronization, if the resource is none
then block, otherwise the number of the resource --
Input : ulSmID -- the ID of the resource to lock
ulTimeOutInMillSec -- the time to wait(0 for ever)
Return : VOS_OK on success and errno on failure
*****************************************************************************/
VOS_UINT32 VOS_SmP( VOS_SEM Sm_ID, VOS_UINT32 ulTimeOutInMillSec )
{
SEM_CONTROL_BLOCK *temp_Ptr;
VOS_INT32 timeintick;
VOS_INT lRetValue;
temp_Ptr = (SEM_CONTROL_BLOCK *)Sm_ID;
if ( temp_Ptr != temp_Ptr->SemId )
{
VOS_SetErrorNo(VOS_ERRNO_SEMA4_P_IDERR);
return (VOS_ERRNO_SEMA4_P_IDERR);
}
if (VOS_SEM_CTRL_BLK_IDLE == temp_Ptr->Flag)
{
VOS_SetErrorNo(VOS_ERRNO_SEMA4_P_NOTACTIVE);
return(VOS_ERRNO_SEMA4_P_NOTACTIVE);
}
if (ulTimeOutInMillSec == 0)
{
down(&(temp_Ptr->sem));
return VOS_OK;
}
timeintick = ((ulTimeOutInMillSec*HZ)/1000);
lRetValue = down_timeout(&(temp_Ptr->sem), timeintick);
if ( VOS_OK == lRetValue )
{
return VOS_OK;
}
else if ( -ETIME == lRetValue )
{
VOS_SetErrorNo(VOS_ERRNO_SEMA4_P_TIMEOUT);
return VOS_ERRNO_SEMA4_P_TIMEOUT;
}
else
{
}
VOS_SetErrorNo (VOS_ERRNO_SEMA4_P_CANOTP);
return VOS_ERRNO_SEMA4_P_CANOTP;
}
int hwSimIsDone(int timeout)
{
long jeffies;
if(timeout == -1)
{
if(down_interruptible(&hwSimInfo.simIsDone) == 0)
return DV_OK;
else
return DV_ERROR;
}
jeffies = msecs_to_jiffies(timeout);
if(down_timeout(&hwSimInfo.simIsDone, jeffies) == 0)
return DV_OK;
else
return DV_ERROR;
}
void ath6kl_sdio_init_msm(void)
{
int ret;
sema_init(&wifi_control_sem, 1);
down(&wifi_control_sem);
ret = platform_driver_register(&ath6kl_sdio_device);
/* Waiting callback after platform_driver_register */
if (down_timeout(&wifi_control_sem, msecs_to_jiffies(5000)) != 0) {
ret = -EINVAL;
printk(KERN_INFO "platform_driver_register timeout\n");
return;
}
return;
}
size_t connection_read_data(struct connection *conn, void *buffer, uint32_t len,
int32_t timeout)
{
size_t ret = 0;
MCDRV_ASSERT(buffer != NULL);
MCDRV_ASSERT(conn->socket_descriptor != NULL);
MCDRV_DBG_VERBOSE(mc_kapi, "read data len = %u for PID = %u",
len, conn->sequence_magic);
do {
/*
* Wait until data is available or timeout
* msecs_to_jiffies(-1) -> wait forever for the sem
*/
if (down_timeout(&(conn->data_available_sem),
msecs_to_jiffies(timeout))) {
MCDRV_DBG_VERBOSE(mc_kapi,
"Timeout reading the data sem");
ret = -2;
break;
}
if (mutex_lock_interruptible(&(conn->data_lock))) {
MCDRV_DBG_ERROR(mc_kapi,
"interrupted reading the data sem");
ret = -1;
break;
}
/* Have data, use it */
if (conn->data_len > 0)
ret = connection_read_data_msg(conn, buffer, len);
mutex_unlock(&(conn->data_lock));
/* There is still some data left */
if (conn->data_len > 0)
up(&conn->data_available_sem);
} while (0);
return ret;
}
TZ_RESULT KREE_ServSemaphoreDownTimeout(u32 op, u8 param[REE_SERVICE_BUFFER_SIZE])
{
struct semaphore *sema;
u32 *in;
long jiffies;
int *out;
int ret;
in = (u32 *) ¶m[0];
sema = (struct semaphore *)in[0];
jiffies = (long)in[1];
ret = down_timeout(sema, jiffies);
out = (int *)¶m[0];
*out = ret;
return TZ_RESULT_SUCCESS;
}
int wl_android_wifictrl_func_add(void)
{
int ret = 0;
sema_init(&wifi_control_sem, 0);
ret = wifi_add_dev();
if (ret) {
DHD_ERROR(("%s: platform_driver_register failed\n", __FUNCTION__));
return ret;
}
g_wifidev_registered = 1;
if (down_timeout(&wifi_control_sem, msecs_to_jiffies(1000)) != 0) {
ret = -EINVAL;
DHD_ERROR(("%s: platform_driver_register timeout\n", __FUNCTION__));
}
return ret;
}
int rtw_android_wifictrl_func_add(void)
{
int ret = 0;
sema_init(&wifi_control_sem, 0);
ret = wifi_add_dev();
if (ret) {
DBG_871X("%s: platform_driver_register failed\n", __FUNCTION__);
return ret;
}
g_wifidev_registered = 1;
/* Waiting callback after platform_driver_register is done or exit with error */
if (down_timeout(&wifi_control_sem, msecs_to_jiffies(1000)) != 0) {
ret = -EINVAL;
DBG_871X("%s: platform_driver_register timeout\n", __FUNCTION__);
}
return ret;
}
static int tmsi_release(struct inode *inode, struct file *file) {
struct tmsi_data* dev;
int retval = 0;
info("Tmsi Release\n");
dev = (struct tmsi_data*) file->private_data;
if (!dev)
return -ENODEV;
dev->releasing = 1;
if (dev->fei)
{
//We have front end info, so just to be sure, we send a stop message
info("Sending stop request\n");
retval = tmsi_write_data(dev, dev->fei, dev->fei_size);
//We are waiting for stop confirmation, for a while....
down_timeout(dev->release_sem, HZ);
//It will be deallocated in write callback
dev->fei=NULL;
}
tmsi_release_dev(dev);
return retval;
}
static int ve_spc_read_sys_cfg(int func, int offset, uint32_t *data)
{
int ret;
if (down_timeout(&info->sem, usecs_to_jiffies(TIMEOUT_US)))
return -ETIME;
init_completion(&info->done);
info->cur_rsp_mask = RESPONSE_MASK(SPC_SYS_CFG);
/* Set the control value */
writel(SYSCFG_START | func | offset >> 2, info->baseaddr + COMMS);
ret = ve_spc_waitforcompletion(SPC_SYS_CFG);
if (ret == 0)
*data = readl(info->baseaddr + SYSCFG_RDATA);
info->cur_rsp_mask = 0;
up(&info->sem);
return ret;
}
static ssize_t tmsi_read(struct file *file, char *buffer, size_t count, loff_t *ppos) {
struct tmsi_data* dev;
char* temp_buffer = NULL;
int retval = 0;
size_t true_count;
dev = (struct tmsi_data*) file->private_data;
if (down_timeout(dev->fifo_sem, HZ / 2) != 0)
return -ETIME;
while (down_trylock(dev->fifo_sem) == 0);
temp_buffer = kmalloc(count, GFP_KERNEL);
if (!temp_buffer) {
retval = -ENOMEM;
goto exit;
}
#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,35)
true_count = kfifo_out_spinlocked(dev->packet_buffer, temp_buffer, count, &dev->buffer_lock);
#elif LINUX_VERSION_CODE > KERNEL_VERSION(2,6,32)
true_count = kfifo_out_locked(dev->packet_buffer, temp_buffer, count, &dev->buffer_lock);
#else
true_count = kfifo_get(dev->packet_buffer, temp_buffer, count);
#endif
/* if the read was successful, copy the data to userspace */
if (copy_to_user(buffer, temp_buffer, true_count))
retval = -EFAULT;
else
retval = true_count;
kfree(temp_buffer);
exit:
if (kfifo_len(dev->packet_buffer) > 0)
up(dev->fifo_sem);
return retval;
}
static unsigned char ttyio_in(int timeout)
{
struct spk_ldisc_data *ldisc_data = speakup_tty->disc_data;
char rv;
if (down_timeout(&ldisc_data->sem, usecs_to_jiffies(timeout)) == -ETIME) {
if (timeout)
pr_warn("spk_ttyio: timeout (%d) while waiting for input\n",
timeout);
return 0xff;
}
rv = ldisc_data->buf;
/* Make sure we have read buf before we set buf_free to let
* the producer overwrite it */
mb();
ldisc_data->buf_free = true;
/* Let TTY push more characters */
tty_schedule_flip(speakup_tty->port);
return rv;
}
static int mxc_elcdif_fb_pan_display(struct fb_var_screeninfo *var,
struct fb_info *info)
{
struct mxc_elcdif_fb_data *data =
(struct mxc_elcdif_fb_data *)info->par;
unsigned long base = 0;
if (data->cur_blank != FB_BLANK_UNBLANK) {
dev_err(info->device, "can't do pan display when fb "
"is blank\n");
return -EINVAL;
}
if (var->xoffset > 0) {
dev_dbg(info->device, "x panning not supported\n");
return -EINVAL;
}
if ((var->yoffset + var->yres > var->yres_virtual)) {
dev_err(info->device, "y panning exceeds\n");
return -EINVAL;
}
/* update framebuffer visual */
base = (var->yoffset * var->xres_virtual + var->xoffset);
base = (var->bits_per_pixel) * base / 8;
base += info->fix.smem_start;
if (down_timeout(&data->flip_sem, HZ / 2)) {
dev_err(info->device, "timeout when waiting for flip irq\n");
return -ETIMEDOUT;
}
__raw_writel(base, elcdif_base + HW_ELCDIF_NEXT_BUF);
data->panning = 1;
return mxc_elcdif_fb_wait_for_frame_done(info);
}
/*
* TODO: Support for units > 1?
*/
acpi_status acpi_os_wait_semaphore(acpi_handle handle, u32 units, u16 timeout)
{
acpi_status status = AE_OK;
struct semaphore *sem = (struct semaphore *)handle;
long jiffies;
int ret = 0;
if (!sem || (units < 1))
return AE_BAD_PARAMETER;
if (units > 1)
return AE_SUPPORT;
ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Waiting for semaphore[%p|%d|%d]\n",
handle, units, timeout));
if (timeout == ACPI_WAIT_FOREVER)
jiffies = MAX_SCHEDULE_TIMEOUT;
else
jiffies = msecs_to_jiffies(timeout);
ret = down_timeout(sem, jiffies);
if (ret)
status = AE_TIME;
if (ACPI_FAILURE(status)) {
ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
"Failed to acquire semaphore[%p|%d|%d], %s",
handle, units, timeout,
acpi_format_exception(status)));
} else {
ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
"Acquired semaphore[%p|%d|%d]", handle,
units, timeout));
}
return status;
}
static struct sk_buff *dequeue_rx_queue(struct rx_queue *q, long timeout) {
unsigned long flags;
struct sk_buff *skb = NULL;
if (timeout == 0) {
if (0==down_interruptible(&q->rx_sem)) {
spin_lock_irqsave(&q->spin, flags);
skb = q->skb;
q->skb = NULL;
while(!down_trylock(&q->rx_sem));
spin_unlock_irqrestore(&q->spin, flags);
}
} else if (0==down_timeout(&q->rx_sem, msecs_to_jiffies(timeout))) {
spin_lock_irqsave(&q->spin, flags);
skb = q->skb;
q->skb = NULL;
while(!down_trylock(&q->rx_sem)){
printk(KERN_ERR "Spinning\n");
}
spin_unlock_irqrestore(&q->spin, flags);
}
return skb;
}
WILC_ErrNo WILC_SemaphoreAcquire(WILC_SemaphoreHandle* pHandle,
tstrWILC_SemaphoreAttrs* pstrAttrs)
{
WILC_ErrNo s32RetStatus = WILC_SUCCESS;
#ifndef CONFIG_WILC_SEMAPHORE_TIMEOUT
while(down_interruptible(pHandle)); //jude
#else
if(pstrAttrs == WILC_NULL)
{
down(pHandle);
}
else
{
s32RetStatus = down_timeout(pHandle, msecs_to_jiffies(pstrAttrs->u32TimeOut));
}
#endif
if(s32RetStatus == 0)
{
return WILC_SUCCESS;
}
else if (s32RetStatus == -ETIME)
{
return WILC_TIMEOUT;
}
else
{
return WILC_FAIL;
}
return WILC_SUCCESS;
}
int mt_down_timeout(struct semaphore *sem, long jiffies)
{
return down_timeout(sem,jiffies);
}
void validate_lbr(void) {
#ifdef ARMOR_JIT
uint8_t hash[DIGEST_LENGTH];
int i;
struct lbr_t lbr;
struct timeval time;
unsigned long jit_start_j, jit_stop_j, jit_delta_j;
printk("total validate lbr state %ld\n",total_count++);
get_cpu();
get_lbr(&lbr);
dump_lbr(&lbr);
put_cpu();
if (disable_jit) {
printk("[validation] -- WARNING -- JIT disabled!\n");
return;
}
printdj(true,"[validation] JIT: Acquiring lock...\n");
mutex_lock(&validation_lock);
printdj(true,"[validation] JIT: Lookup\n");
ARMOR_STAT_INC(jit_lookups);
/* Compute a hash of the lbr and look it up in the cache. */
hash_lbr(hash,&lbr);
for (i = 0; i < jit_cache.hashes; i++) {
if (memcmp(jit_cache.hash[i], hash, DIGEST_LENGTH) == 0) {
ARMOR_STAT_INC(jit_cache_hits);
#ifdef ARMOR_DEBUG_JIT
printk("[validation] LBR state is valid (found in JIT cache)\n");
#endif
mutex_unlock(&validation_lock);
return;
}
}
/* Not found in cache. Let's ask Dennis. Using Enes' semaphore design. */
ARMOR_STAT_INC(jit_requests);
jit_work = &lbr;
printdj(true, "[validation] JIT: Request\n");
/* Start the timers. */
jit_start_j = jiffies;
up(&jit_work_cond);
printdj(true, "[validation] JIT: Waiting\n");
if (down_timeout(&jit_result_cond, jit_waittime) < 0) {
printk("[validation] JIT: Timeout\n");
ARMOR_STAT_INC(jit_timeouts);
disable_jit = 1;
mutex_unlock(&validation_lock);
return;
}
/* Stop the timers. */
jit_stop_j = jiffies;
jit_delta_j = jit_stop_j - jit_start_j;
/* JIT may be faster than we can measure jiffies. If this happens, assume a
* half jiffie was used.
* http://stackoverflow.com/questions/10392735/am-i-too-fast-to-count-jiffies
*/
if (jit_delta_j == 0) jit_delta_j = stats.jit_lookups % 2;
printdj(true, "That took us %lu jiffies\n", jit_delta_j);
jiffies_to_timeval(jit_delta_j, &time);
ARMOR_STAT_ADD(jit_sec, time.tv_sec);
ARMOR_STAT_ADD(jit_usec, time.tv_usec);
printdj(true, "[validation] JIT: Processing result\n");
if (jit_result == 0) {
printk("[validation] -- WARNING -- LBR state rendered *INVALID* by jit-analyzer\n");
ARMOR_STAT_INC(jit_misses);
// kill_pid(task_pid(current), SIGKILL, 1);
printk("[validation] -- WARNING -- ASSUMING VALID\n");
goto assume_valid;
}
if (jit_result == 2) {
printk("[validation] -- WARNING -- LBR state not validated due to uninstrumentable function\n");
ARMOR_STAT_INC(jit_unsupported);
printk("[validation] -- WARNING -- ASSUMING VALID\n");
goto assume_valid;
}
if (jit_result == 1) {
ARMOR_STAT_INC(jit_hits);
assume_valid:
/* Dennis' says it is ok. Let's add it to the - circular - cache so he
* can take some time off next time. */
/* TODO, this should probably be a sorted linked list so that we can do a binary search? */
memcpy(jit_cache.hash[jit_cache.hashes], hash, DIGEST_LENGTH);
jit_cache.hashes = (jit_cache.hashes + 1) % JIT_CACHE_SIZE;
#ifdef ARMOR_DEBUG_JIT
printk("[validation] LBR state is valid\n");
#endif
}
mutex_unlock(&validation_lock);
return;
#else
struct lbr_t lbr;
get_cpu();
get_lbr(&lbr);
dump_lbr(&lbr);
put_cpu();
return;
#endif // ARMOR_JIT
}
/*lint --e{713}*/
static int cshell_recv_thread(void *arg)
{
cshell_ctx_t *cshell_ctx = &g_cshell_ctx;
u32 write_size = 0;
u32 free_buf_size = 0;
u32 send_sz = 0;
long sem_wait_jeff = SEM_WAIT_MAX_JIF;
int icc_ret = CSHELL_OK;
ACM_WR_ASYNC_INFO acm_wt_info = {0};
/* coverity[no_escape] */
while (1)
{
if(0 != down_timeout(&(cshell_ctx->cshell_recv_sem), sem_wait_jeff))
cshell_log.a2c_sem_timeout_times++;
if ((!cshell_ctx->icc_chan_opened) || (0 == g_cshell_ctx.ccshell_work_flg) || !cshell_get_bit(USB_CSHELL))
{
sem_wait_jeff = SEM_WAIT_MAX_JIF;
continue;
}
if(0 == bsp_acm_ioctl(cshell_ctx->cshell_acm_fd, (u32)ACM_IOCTL_GET_RD_BUFF, &acm_wt_info))
{
/* 获取剩余buffer长度 */
free_buf_size = CSHELL_BUFFER_SIZE - cshell_ctx->recv_mem.buf_size;
/* 获取可写入buffer的数据长度，多余部分丢弃 */
write_size = (free_buf_size < (u32)acm_wt_info.u32Size) ? free_buf_size : acm_wt_info.u32Size;
/* 将数据拷贝至缓冲buffer并更新buffer长度 */
#ifdef FEATURE_USB_ZERO_COPY
memcpy(cshell_ctx->recv_mem.buf + cshell_ctx->recv_mem.buf_size, acm_wt_info.pVirAddr, write_size);
#else
memcpy(cshell_ctx->recv_mem.buf + cshell_ctx->recv_mem.buf_size, acm_wt_info.pBuffer, write_size);
#endif
cshell_ctx->recv_mem.buf_size += write_size;
(void)bsp_acm_ioctl(cshell_ctx->cshell_acm_fd, ACM_IOCTL_RETURN_BUFF, &acm_wt_info);
}
while(cshell_ctx->recv_mem.buf_size)
{
send_sz = cshell_ctx->recv_mem.buf_size > CSHELL_MAX_SEND_SZ ? CSHELL_MAX_SEND_SZ : cshell_ctx->recv_mem.buf_size;
icc_ret = (int)bsp_icc_send((u32)ICC_CPU_MODEM, (cshell_ctx->icc_channel_id << 16), cshell_ctx->recv_mem.buf, send_sz);
if((icc_ret > (int)send_sz) || (icc_ret < 0))
{
cshell_log.a2c_send_fail_times++;
sem_wait_jeff = SEM_WAIT_JIF;
break;
}
else if(icc_ret < (int)send_sz)
{
cshell_ctx->recv_mem.buf_size -= (u32)icc_ret;
memcpy(cshell_ctx->recv_buf, cshell_ctx->recv_mem.buf+icc_ret,(cshell_ctx->recv_mem.buf_size));
memcpy(cshell_ctx->recv_mem.buf, cshell_ctx->recv_buf, (cshell_ctx->recv_mem.buf_size));
sem_wait_jeff = SEM_WAIT_JIF;
break;
}
else
{
cshell_ctx->recv_mem.buf_size -= (u32)icc_ret;
sem_wait_jeff = SEM_WAIT_MAX_JIF;
}
}
cshell_log.bluetooth_send_cmd_times += 1;
}
return 0;
}
static int dhd_wifi_platform_load_sdio(void)
{
int i;
int err = 0;
wifi_adapter_info_t *adapter;
BCM_REFERENCE(i);
BCM_REFERENCE(adapter);
/* Sanity check on the module parameters
* - Both watchdog and DPC as tasklets are ok
* - If both watchdog and DPC are threads, TX must be deferred
*/
if (!(dhd_watchdog_prio < 0 && dhd_dpc_prio < 0) &&
!(dhd_watchdog_prio >= 0 && dhd_dpc_prio >= 0 && dhd_deferred_tx))
return -EINVAL;
#if defined(BCMLXSDMMC)
if (dhd_wifi_platdata == NULL) {
DHD_ERROR(("DHD wifi platform data is required for Android build\n"));
return -EINVAL;
}
sema_init(&dhd_registration_sem, 0);
/* power up all adapters */
for (i = 0; i < dhd_wifi_platdata->num_adapters; i++) {
bool chip_up = FALSE;
int retry = POWERUP_MAX_RETRY;
struct semaphore dhd_chipup_sem;
adapter = &dhd_wifi_platdata->adapters[i];
DHD_ERROR(("Power-up adapter '%s'\n", adapter->name));
DHD_INFO((" - irq %d [flags %d], firmware: %s, nvram: %s\n",
adapter->irq_num, adapter->intr_flags, adapter->fw_path, adapter->nv_path));
DHD_INFO((" - bus type %d, bus num %d, slot num %d\n\n",
adapter->bus_type, adapter->bus_num, adapter->slot_num));
do {
sema_init(&dhd_chipup_sem, 0);
err = dhd_bus_reg_sdio_notify(&dhd_chipup_sem);
if (err) {
DHD_ERROR(("%s dhd_bus_reg_sdio_notify fail(%d)\n\n",
__FUNCTION__, err));
return err;
}
err = wifi_platform_set_power(adapter, TRUE, WIFI_TURNON_DELAY);
if (err) {
/* WL_REG_ON state unknown, Power off forcely */
wifi_platform_set_power(adapter, FALSE, WIFI_TURNOFF_DELAY);
continue;
} else {
wifi_platform_bus_enumerate(adapter, TRUE);
err = 0;
}
if (down_timeout(&dhd_chipup_sem, msecs_to_jiffies(POWERUP_WAIT_MS)) == 0) {
dhd_bus_unreg_sdio_notify();
chip_up = TRUE;
break;
}
DHD_ERROR(("failed to power up %s, %d retry left\n", adapter->name, retry));
dhd_bus_unreg_sdio_notify();
wifi_platform_set_power(adapter, FALSE, WIFI_TURNOFF_DELAY);
wifi_platform_bus_enumerate(adapter, FALSE);
} while (retry--);
if (!chip_up) {
DHD_ERROR(("failed to power up %s, max retry reached**\n", adapter->name));
return -ENODEV;
}
}
err = dhd_bus_register();
if (err) {
DHD_ERROR(("%s: sdio_register_driver failed\n", __FUNCTION__));
goto fail;
}
/*
* Wait till MMC sdio_register_driver callback called and made driver attach.
* It's needed to make sync up exit from dhd insmod and
* Kernel MMC sdio device callback registration
*/
err = down_timeout(&dhd_registration_sem, msecs_to_jiffies(DHD_REGISTRATION_TIMEOUT));
if (err) {
DHD_ERROR(("%s: sdio_register_driver timeout or error \n", __FUNCTION__));
dhd_bus_unregister();
goto fail;
}
return err;
fail:
/* power down all adapters */
for (i = 0; i < dhd_wifi_platdata->num_adapters; i++) {
adapter = &dhd_wifi_platdata->adapters[i];
wifi_platform_set_power(adapter, FALSE, WIFI_TURNOFF_DELAY);
wifi_platform_bus_enumerate(adapter, FALSE);
}
#else
/* x86 bring-up PC needs no power-up operations */
err = dhd_bus_register();
#endif
return err;
}
int test_rproc_msg_send(unsigned int sync_id,
unsigned char rp_id,
unsigned int msg_len,
unsigned int msg_num,
struct test_rproc_cb *rproc_cb)
{
int ret = 0;
rproc_msg_t tx_buffer[8] = {0};
rproc_msg_t ack_buffer[8] = {0};
struct semaphore *complete_sema;
unsigned int start_slice = 0;
unsigned int end_slice = 0;
unsigned int sync_task_cnt = 0;
if (sync_id > 0x3) {
printk(KERN_ERR "wrong sync id!\n");
return -1;
}
if (msg_len > 8) {
printk(KERN_ERR "illegal message length!\n");
return -1;
}
if(rproc_cb) {
down(&task_mutex_sema);
rproc_cb->sync_task_cnt--;
sync_task_cnt = rproc_cb->sync_task_cnt;
up(&task_mutex_sema);
if ((0 == sync_task_cnt)
&& (TEST_RPROC_NULL != rproc_cb->sync_sema)) {
rproc_cb->start_slice = test_rproc_get_slice();
up(rproc_cb->sync_sema);
}
/*进程同步*/
if (TEST_RPROC_NULL != rproc_cb->sync_sema) {
down(rproc_cb->sync_sema);
up(rproc_cb->sync_sema);
}
}
tx_buffer[0] = (OBJ_TEST << 16) | (CMD_TEST << 8)/*0x00120500*/;
memcpy((void*)&tx_buffer[1], (void*)&data_buf[0], sizeof(tx_buffer) - sizeof(tx_buffer[0]));
switch(sync_id)
{
case 0:/*同步发送同步消息*/
while(msg_num--){
ret = RPROC_SYNC_SEND(rp_id,tx_buffer, msg_len,SYNC_MSG,ack_buffer,msg_len);
if (ret || (((OBJ_TEST << 16) | (CMD_TEST << 8)) != ack_buffer[0]) || (0x12345678 != ack_buffer[1])) {
printk(KERN_ERR "rproc send error, ret %d, rp %d, sync %d, ack[0x%x][0x%x]!\r\n",
ret, rp_id, sync_id, ack_buffer[0], ack_buffer[1]);
return -1;
}
if(rproc_cb)
rproc_cb->msg_count++;
}
break;
case 1:/*同步发送异步消息*/
while(msg_num--){
ret = RPROC_SYNC_SEND(rp_id ,tx_buffer, msg_len,ASYNC_MSG,NULL,0);
if (ret) {
printk(KERN_ERR "rproc send error, ret %d, rp %d, sync %d!\r\n", ret, rp_id, sync_id);
return -1;
}
if(rproc_cb)
rproc_cb->msg_count++;
}
break;
case 2:/*异步发送同步消息*/
while (msg_num--) {
complete_sema = (struct semaphore*)kmalloc(sizeof(struct semaphore), GFP_KERNEL);
sema_init(complete_sema, 0);
ret = RPROC_ASYNC_SEND(rp_id,tx_buffer,msg_len,SYNC_MSG,rporc_async_callback,complete_sema);
if (ret) {
printk(KERN_ERR "rproc send error, ret %d, rp %d, sync %d!\r\n", ret, rp_id, sync_id);
kfree(complete_sema);
return -1;
}
start_slice = test_rproc_get_slice();
if (0 != down_timeout(complete_sema, msecs_to_jiffies(1000)))
{
printk(KERN_ERR "msg_send timeout rp_id:%d rproc async send err!\r\n", rp_id);
/*如果超时,不能释放内存*/
/*kfree(complete_sema);*/
return -1;
}
end_slice = test_rproc_get_slice();
printk(KERN_INFO "async send sync msg spend %d slice!\r\n",
test_rproc_slice_diff(start_slice, end_slice));
kfree(complete_sema);
if(rproc_cb)
rproc_cb->msg_count++;
}
break;
case 3:/*异步发送异步消息*/
while (msg_num--) {
ret = RPROC_ASYNC_SEND(rp_id,tx_buffer,msg_len,ASYNC_MSG,rporc_async_callback,NULL);
if (ret) {
printk(KERN_ERR "rproc send error, ret %d, rp %d, sync %d!\r\n", ret, rp_id, sync_id);
return ret;
}
if(rproc_cb)
rproc_cb->msg_count++;
}
break;
default:
printk(KERN_ERR "wrong sync ID!\n");
return -1;
}
printk(KERN_INFO "rproc send ok, rp %d, sync %d!\n", rp_id, sync_id);
return ret;
}
/*****************************************************************************
函 数 名 : hifireset_task
功能描述 : 用于处理HIFI复位。
输入参数 : 无
输出参数 : 无
返 回 值 : int
*****************************************************************************/
int hifireset_task(void *arg)
{
int iresult = BSP_RESET_OK;
#ifdef _DRV_LLT_
#else
for ( ; ; )
#endif
{
down(&(g_reset_assistant_hifi.sem_wait_hifireset));
printk(KERN_INFO "%s: enter hifireset_task\n", __FUNCTION__);
printk(KERN_INFO "%s: hifi reset int is coming!\n", __FUNCTION__);
reset_for_savelog("\n=============hifi reset=============\n");
/*调用回调函数*/
iresult = hifireset_runcbfun(MDRV_RESET_CB_BEFORE);
if (BSP_RESET_OK != iresult)
{
printk(KERN_ERR "%s: fail to run cb func before hifi reset\n", __FUNCTION__);
/*复位系统*/
do_reset_system(RESET_TYPE_HIFIRESET_RUNCB_STEP1_FAIL);
return BSP_RESET_ERROR;
}
#ifdef _DRV_LLT_
#else
if (0 != down_timeout(&(g_reset_assistant_hifi.sem_wait_mcu_msg_hifireset), msecs_to_jiffies(RESET_WAIT_TIMEOUT_MAILMSG)))
{
/*复位系统*/
printk(KERN_ERR "%s: fail to get mail from mcu,reset system\n", __FUNCTION__);
/*do_reset_system(RESET_TYPE_FAILGET_MSG_FROM_MCU);*/
return BSP_RESET_ERROR;
}
printk(KERN_INFO "%s: to load hifi bin!\n", __FUNCTION__);
reset_for_savelog("To load hifi bin\n");
/*重新加载HIFI映像*/
iresult = hifireset_loadhifibin();
if (BSP_RESET_OK != iresult)
{
reset_for_savelog("fail to load hifi bin\n");
printk(KERN_ERR "%s: fail to load hifi bin! reset system\n", __FUNCTION__);
/*复位系统*/
do_reset_system(RESET_TYPE_HIFIRESET_LOAD_BIN_FAIL);
return BSP_RESET_ERROR;
}
#endif
printk(KERN_INFO "%s: to run cb fun after hifi reset!\n", __FUNCTION__);
reset_for_savelog("To run cb func after hifi reset\n");
/*HIFI加载完毕后，调用回调函数*/
iresult = hifireset_runcbfun(MDRV_RESET_CB_AFTER);
/*恢复中断使能*/
finish_reset_sub();
if (BSP_RESET_OK != iresult)
{
printk(KERN_ERR "%s: fail to run cb fun after hifi reset! reset system\n", __FUNCTION__);
/*复位系统*/
do_reset_system(RESET_TYPE_HIFIRESET_RUNCB_STEP2_FAIL);
return BSP_RESET_ERROR;
}
printk(KERN_INFO "%s: reset hifi successfully!\n", __FUNCTION__);
reset_for_savelog("hifi reset ok\n");
#ifndef _DRV_LLT_
check_doreset_for_noc();
#endif
}
}
static int /*__init*/ esp_sdio_init(void)
{
#define ESP_WAIT_UP_TIME_MS 11000
int err;
u64 ver;
int retry = 3;
bool powerup = false;
int edf_ret = 0;
esp_dbg(ESP_DBG_TRACE, "%s \n", __func__);
#ifdef DRIVER_VER
ver = DRIVER_VER;
esp_dbg(ESP_SHOW, "\n***** EAGLE DRIVER VER:%llx*****\n\n", ver);
#endif
edf_ret = esp_debugfs_init();
request_init_conf();
esp_wakelock_init();
esp_wake_lock();
do {
sema_init(&esp_powerup_sem, 0);
sif_platform_target_poweron();
sif_platform_rescan_card(1);
err = sdio_register_driver(&esp_sdio_dummy_driver);
if (err) {
esp_dbg(ESP_DBG_ERROR, "eagle sdio driver registration failed, error code: %d\n", err);
goto _fail;
}
if (down_timeout(&esp_powerup_sem,
msecs_to_jiffies(ESP_WAIT_UP_TIME_MS)) == 0)
{
powerup = true;
msleep(200);
break;
}
esp_dbg(ESP_SHOW, "%s ------ RETRY ------ \n", __func__);
sif_record_retry_config();
sdio_unregister_driver(&esp_sdio_dummy_driver);
sif_platform_rescan_card(0);
sif_platform_target_poweroff();
} while (retry--);
if (!powerup) {
esp_dbg(ESP_DBG_ERROR, "eagle sdio can not power up!\n");
err = -ENODEV;
goto _fail;
}
esp_dbg(ESP_SHOW, "%s power up OK\n", __func__);
sdio_unregister_driver(&esp_sdio_dummy_driver);
sif_sdio_state = ESP_SDIO_STATE_FIRST_INIT;
sema_init(&esp_powerup_sem, 0);
sdio_register_driver(&esp_sdio_driver);
if ((down_timeout(&esp_powerup_sem,
msecs_to_jiffies(ESP_WAIT_UP_TIME_MS)) == 0 ) && sif_get_ate_config() == 0) {
if(sif_sdio_state == ESP_SDIO_STATE_FIRST_NORMAL_EXIT){
sdio_unregister_driver(&esp_sdio_driver);
sif_platform_rescan_card(0);
msleep(100);
sif_platform_rescan_card(1);
sif_sdio_state = ESP_SDIO_STATE_SECOND_INIT;
sdio_register_driver(&esp_sdio_driver);
}
}
esp_register_early_suspend();
esp_wake_unlock();
return err;
_fail:
esp_wake_unlock();
esp_wakelock_destroy();
return err;
}
/**
*
* Input Arguments
* csx_info -
* csx_simorph_info -
*
* Output Arguments
* csx_handle - unique ID of I/O point to add
*
* @return
* 0 - success
* -(ve) - Error code
*/
int csx_sigmorph_add_point(CSX_IO_POINT_INFO *csx_info,
CSX_SIGMORPH_INFO *csx_sigmorph_info,
CSX_IO_HANDLE *csx_handle)
{
int err = -1;
int available_index = -1;
int gist_handle = GIST_INVALID_HANDLE;
CSX_IO_HANDLE handle;
CSX_IO_POINT_FNCS csx_ops;
CSX_MODULE_FNCS *csx_mod_ops;
CSX_SIGMORPH_IO_POINT_INFO *slot;
err =
down_timeout(&csx_sigmorph_sem,
CSX_SIGMORPH_SEMAPHORE_TIME_WAIT_JIFFIES);
if (err) {
return err;
}
available_index = csx_sigmorph_get_available_index(csx_info);
if (!CSX_SIGMORPH_ISVALID_INDEX(available_index)) {
printk(KERN_ERR
"%s: No available ports. Remove unused points\n",
__FUNCTION__);
*csx_handle = CSX_HANDLE_INVALID;
up(&csx_sigmorph_sem);
return -ENOSPC;
}
do {
slot = &point_registry[available_index];
(void)memset(slot, 0, sizeof(CSX_SIGMORPH_IO_POINT_INFO));
(void)memcpy(&slot->csx_io_point_info, csx_info,
sizeof(CSX_IO_POINT_INFO));
point_registry_active++;
slot->io_point_active = CSX_POINT_ENABLE;
if (csx_sigmorph_info->capture_raw.filename[0]) {
gist_handle =
gist_alloc_writer(&
(csx_sigmorph_info->capture_raw));
if (gist_handle == GIST_INVALID_HANDLE) {
err = -EINVAL;
break;
}
slot->capture_raw_hndl = gist_handle;
slot->options_priv |= CSX_SIGMORPH_CAPTURE_RAW;
}
if (csx_sigmorph_info->capture_procd.filename[0]) {
gist_handle =
gist_alloc_writer(&
(csx_sigmorph_info->capture_procd));
if (gist_handle == GIST_INVALID_HANDLE) {
err = -EINVAL;
break;
}
slot->capture_proc_hndl = gist_handle;
slot->options_priv |= CSX_SIGMORPH_CAPTURE_PROCD;
}
if (csx_sigmorph_info->inject.filename[0]) {
gist_handle =
gist_alloc_reader(&(csx_sigmorph_info->inject));
if (gist_handle == GIST_INVALID_HANDLE) {
err = -EINVAL;
break;
}
slot->inject_hndl = gist_handle;
slot->options_priv |= CSX_SIGMORPH_INJECT;
}
if (csx_sigmorph_info->stream_gain) {
slot->stream_gain = csx_sigmorph_info->stream_gain;
slot->options_priv |= CSX_SIGMORPH_AMPSTRM;
}
if (csx_sigmorph_info->inject_gain) {
slot->inject_gain = csx_sigmorph_info->inject_gain;
slot->options_priv |= CSX_SIGMORPH_AMPINJ;
}
if (csx_sigmorph_info->mix == CSX_SIGMORPH_MIX_ENABLE) {
CSX_SIGMORPH_DEBUG("enable MIXING operation");
slot->options_priv |= CSX_SIGMORPH_MIX;
}
handle = csx_sigmorph_generate_io_point_handle(available_index);
slot->csx_io_point_handle = handle;
/* Register function with HAL module */
csx_ops.csxCallback = &csx_sigmorph_callback;
csx_mod_ops = csx_get_module_fncp(csx_info->csx_module_id);
if (csx_mod_ops->csx_module_set_point) {
CSX_SIGMORPH_DEBUG("Set module device point");
err = csx_mod_ops->csx_module_set_point
(csx_info->csx_device_id, csx_info->csx_point_id,
&csx_ops, (void *)handle);
if (err) {
printk(KERN_ERR
"Attempt to set HAL module point failed\n");
break;
}
} else {
printk(KERN_ERR
"CSX module selected for SIGMORPH not registered\n");
err = -EINVAL;
break;
}
*csx_handle = handle;
point_registry_count++;
} while (0); /* END critical section */
if (err) {
(void)csx_sigmorph_cleanup_point(available_index);
*csx_handle = GIST_INVALID_HANDLE;
}
up(&csx_sigmorph_sem);
return err;
}
static long img_scale_ioctl(struct file *file,
unsigned int cmd,
unsigned long arg)
{
int ret = 0;
uint8_t param[PARAM_SIZE];
uint32_t param_size;
void *data = param;
param_size = _IOC_SIZE(cmd);
printk("img_scale_ioctl, io number 0x%x, param_size %d \n",
_IOC_NR(cmd),
param_size);
if (param_size) {
if (copy_from_user(data, (void*)arg, param_size)) {
printk("img_scale_ioctl, failed to copy_from_user \n");
ret = -EFAULT;
goto exit;
}
}
if (SCALE_IO_IS_DONE == cmd) {
ret = down_timeout(&(((struct scale_user *)(file->private_data))->sem_done), msecs_to_jiffies(100));
if (ret) {
printk("img_scale_ioctl, failed to down, 0x%x \n", ret);
ret = -ERESTARTSYS;
goto exit;
} else {
if (frm_rtn.type) {
SCALE_TRACE("abnormal scale done \n");
ret = -1;
goto exit;
}
if (copy_to_user((void*)arg, &frm_rtn, sizeof(struct scale_frame))) {
printk("img_scale_ioctl, failed to copy_to_user \n");
ret = -EFAULT;
goto exit;
}
}
} else {
if (cur_task_pid == INVALID_USER_ID)
{
mutex_lock(&scale_param_cfg_mutex);
cur_task_pid = ((struct scale_user *)(file->private_data))->pid;
}else if (cur_task_pid != ((struct scale_user *)(file->private_data))->pid){
mutex_lock(&scale_param_cfg_mutex);
}
ret = scale_cfg(_IOC_NR(cmd), data);
if (SCALE_IO_STOP == cmd) {
cur_task_pid = INVALID_USER_ID;
mutex_unlock(&scale_param_cfg_mutex);
}
}
exit:
if (ret) {
SCALE_TRACE("img_scale_ioctl, error code 0x%x \n", ret);
}
return ret;
}
int unicam_videobuf_stop_streaming(struct vb2_queue *q)
{
struct soc_camera_device *icd = soc_camera_from_vb2q(q);
struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
struct unicam_camera_dev *unicam_dev = ici->priv;
CSL_CAM_FRAME_st_t cslCamFrame;
int ret = 0;
unsigned long flags;
if (down_interruptible(&unicam_dev->stop_processing_sem) == 0) {
if (unicam_dev->streaming)
csl_cam_register_display(unicam_dev->cslCamHandle);
} else
dev_err(unicam_dev->dev, "Unable to dump regs because stop_processing_sem acquire failed\n");
/* grab the lock */
spin_lock_irqsave(&unicam_dev->lock, flags);
dprintk("-enter");
dprintk("disabling csi");
iprintk("stopping stream");
if (!unicam_dev->streaming) {
dev_err(unicam_dev->dev, "stream already turned off\n");
goto out;
}
/*
* stop streaming before grabing spin lock
* since this function can sleep.
* */
if (unicam_dev->active) {
unicam_dev->stopping = true;
spin_unlock_irqrestore(&unicam_dev->lock, flags);
ret = down_timeout(&unicam_dev->stop_sem,
msecs_to_jiffies(500));
if (ret == -ETIME)
pr_err("Unicam: semaphore timed out waiting to STOP\n");
} else {
spin_unlock_irqrestore(&unicam_dev->lock, flags);
}
usleep_range(50, 60); /*TODO: Need to double-check with ASIC team*/
spin_lock_irqsave(&unicam_dev->lock, flags);
/* disable frame interrupts */
cslCamFrame.int_enable = CSL_CAM_INT_DISABLE;
cslCamFrame.int_line_count = 0;
cslCamFrame.capture_mode = UNICAM_CAPTURE_MODE;
cslCamFrame.capture_size = 0;
if (csl_cam_set_frame_control(unicam_dev->cslCamHandle, &cslCamFrame)) {
dev_err(unicam_dev->dev,
"csl_cam_set_frame_control(): FAILED\n");
ret = -1;
}
/* disable receiver */
if (csl_cam_rx_stop(unicam_dev->cslCamHandle)) {
dev_err(unicam_dev->dev, "csl_cam_rx_stop(): FAILED\n");
ret = -1;
}
if (csl_cam_close(unicam_dev->cslCamHandle)) {
dev_err(unicam_dev->dev, "cals_cam_exit(): FAILED\n");
ret = -1;
}
if (csl_cam_exit()) {
dev_err(unicam_dev->dev, "csl_cam_exit(): FAILED\n");
ret = -1;
}
unicam_dev->active = NULL;
unicam_dev->streaming = 0;
out:
dprintk("-exit");
spin_unlock_irqrestore(&unicam_dev->lock, flags);
up(&unicam_dev->stop_processing_sem);
/* Stopping stream after stopping unicam */
ret = v4l2_subdev_call(sd, video, s_stream, 0);
if (ret < 0 && ret != -ENOIOCTLCMD) {
dev_err(unicam_dev->dev, "failed to stop sensor streaming\n");
ret = -1;
}
return ret;
}
//timeout return < 0
int Semaphore_waittimeout(NandSemaphore *sem,long jiffies)
{
return down_timeout((struct semaphore *)(*sem),jiffies);
}
int rtw_android_priv_cmd(struct net_device *net, struct ifreq *ifr, int cmd)
{
int ret = 0;
char *command = NULL;
int cmd_num;
int bytes_written = 0;
#ifdef CONFIG_PNO_SUPPORT
uint cmdlen = 0;
uint pno_enable = 0;
#endif
android_wifi_priv_cmd priv_cmd;
_adapter* padapter = ( _adapter * ) rtw_netdev_priv(net);
#ifdef CONFIG_WFD
struct wifi_display_info *pwfd_info;
#endif
rtw_lock_suspend();
if (!ifr->ifr_data) {
ret = -EINVAL;
goto exit;
}
if (copy_from_user(&priv_cmd, ifr->ifr_data, sizeof(android_wifi_priv_cmd))) {
ret = -EFAULT;
goto exit;
}
if ( padapter->registrypriv.mp_mode == 1) {
ret = -EFAULT;
goto exit;
}
//DBG_871X("%s priv_cmd.buf=%p priv_cmd.total_len=%d priv_cmd.used_len=%d\n",__func__,priv_cmd.buf,priv_cmd.total_len,priv_cmd.used_len);
command = rtw_zmalloc(priv_cmd.total_len);
if (!command)
{
DBG_871X("%s: failed to allocate memory\n", __FUNCTION__);
ret = -ENOMEM;
goto exit;
}
if (!access_ok(VERIFY_READ, priv_cmd.buf, priv_cmd.total_len)){
DBG_871X("%s: failed to access memory\n", __FUNCTION__);
ret = -EFAULT;
goto exit;
}
#ifdef CONFIG_COMPAT
if (copy_from_user(command, compat_ptr(priv_cmd.buf), (unsigned long) priv_cmd.total_len)) {
#else
if (copy_from_user(command, (void *)priv_cmd.buf, priv_cmd.total_len)) {
#endif
ret = -EFAULT;
goto exit;
}
DBG_871X("%s: Android private cmd \"%s\" on %s\n"
, __FUNCTION__, command, ifr->ifr_name);
cmd_num = rtw_android_cmdstr_to_num(command);
switch(cmd_num) {
case ANDROID_WIFI_CMD_START:
//bytes_written = wl_android_wifi_on(net);
goto response;
case ANDROID_WIFI_CMD_SETFWPATH:
goto response;
}
if (!g_wifi_on) {
DBG_871X("%s: Ignore private cmd \"%s\" - iface %s is down\n"
,__FUNCTION__, command, ifr->ifr_name);
ret = 0;
goto exit;
}
switch(cmd_num) {
case ANDROID_WIFI_CMD_STOP:
//bytes_written = wl_android_wifi_off(net);
break;
case ANDROID_WIFI_CMD_SCAN_ACTIVE:
//rtw_set_scan_mode((_adapter *)rtw_netdev_priv(net), SCAN_ACTIVE);
#ifdef CONFIG_PLATFORM_MSTAR
#ifdef CONFIG_IOCTL_CFG80211
adapter_wdev_data((_adapter *)rtw_netdev_priv(net))->bandroid_scan = _TRUE;
#endif //CONFIG_IOCTL_CFG80211
#endif //CONFIG_PLATFORM_MSTAR
break;
case ANDROID_WIFI_CMD_SCAN_PASSIVE:
//rtw_set_scan_mode((_adapter *)rtw_netdev_priv(net), SCAN_PASSIVE);
break;
case ANDROID_WIFI_CMD_RSSI:
bytes_written = rtw_android_get_rssi(net, command, priv_cmd.total_len);
break;
case ANDROID_WIFI_CMD_LINKSPEED:
bytes_written = rtw_android_get_link_speed(net, command, priv_cmd.total_len);
break;
case ANDROID_WIFI_CMD_MACADDR:
bytes_written = rtw_android_get_macaddr(net, command, priv_cmd.total_len);
break;
case ANDROID_WIFI_CMD_BLOCK:
bytes_written = rtw_android_set_block(net, command, priv_cmd.total_len);
break;
case ANDROID_WIFI_CMD_RXFILTER_START:
//bytes_written = net_os_set_packet_filter(net, 1);
break;
case ANDROID_WIFI_CMD_RXFILTER_STOP:
//bytes_written = net_os_set_packet_filter(net, 0);
break;
case ANDROID_WIFI_CMD_RXFILTER_ADD:
//int filter_num = *(command + strlen(CMD_RXFILTER_ADD) + 1) - '0';
//bytes_written = net_os_rxfilter_add_remove(net, TRUE, filter_num);
break;
case ANDROID_WIFI_CMD_RXFILTER_REMOVE:
//int filter_num = *(command + strlen(CMD_RXFILTER_REMOVE) + 1) - '0';
//bytes_written = net_os_rxfilter_add_remove(net, FALSE, filter_num);
break;
case ANDROID_WIFI_CMD_BTCOEXSCAN_START:
/* TBD: BTCOEXSCAN-START */
break;
case ANDROID_WIFI_CMD_BTCOEXSCAN_STOP:
/* TBD: BTCOEXSCAN-STOP */
break;
case ANDROID_WIFI_CMD_BTCOEXMODE:
#if 0
uint mode = *(command + strlen(CMD_BTCOEXMODE) + 1) - '0';
if (mode == 1)
net_os_set_packet_filter(net, 0); /* DHCP starts */
else
net_os_set_packet_filter(net, 1); /* DHCP ends */
#ifdef WL_CFG80211
bytes_written = wl_cfg80211_set_btcoex_dhcp(net, command);
#endif
#endif
break;
case ANDROID_WIFI_CMD_SETSUSPENDOPT:
//bytes_written = wl_android_set_suspendopt(net, command, priv_cmd.total_len);
break;
case ANDROID_WIFI_CMD_SETBAND:
bytes_written = rtw_android_setband(net, command, priv_cmd.total_len);
break;
case ANDROID_WIFI_CMD_GETBAND:
bytes_written = rtw_android_getband(net, command, priv_cmd.total_len);
break;
case ANDROID_WIFI_CMD_COUNTRY:
bytes_written = rtw_android_set_country(net, command, priv_cmd.total_len);
break;
#ifdef CONFIG_PNO_SUPPORT
case ANDROID_WIFI_CMD_PNOSSIDCLR_SET:
//bytes_written = dhd_dev_pno_reset(net);
break;
case ANDROID_WIFI_CMD_PNOSETUP_SET:
bytes_written = rtw_android_pno_setup(net, command, priv_cmd.total_len);
break;
case ANDROID_WIFI_CMD_PNOENABLE_SET:
cmdlen = strlen(android_wifi_cmd_str[ANDROID_WIFI_CMD_PNOENABLE_SET]);
pno_enable = *(command + cmdlen + 1) - '0';
bytes_written = rtw_android_pno_enable(net, pno_enable);
break;
#endif
case ANDROID_WIFI_CMD_P2P_DEV_ADDR:
bytes_written = rtw_android_get_p2p_dev_addr(net, command, priv_cmd.total_len);
break;
case ANDROID_WIFI_CMD_P2P_SET_NOA:
//int skip = strlen(CMD_P2P_SET_NOA) + 1;
//bytes_written = wl_cfg80211_set_p2p_noa(net, command + skip, priv_cmd.total_len - skip);
break;
case ANDROID_WIFI_CMD_P2P_GET_NOA:
//bytes_written = wl_cfg80211_get_p2p_noa(net, command, priv_cmd.total_len);
break;
case ANDROID_WIFI_CMD_P2P_SET_PS:
//int skip = strlen(CMD_P2P_SET_PS) + 1;
//bytes_written = wl_cfg80211_set_p2p_ps(net, command + skip, priv_cmd.total_len - skip);
break;
#ifdef CONFIG_IOCTL_CFG80211
case ANDROID_WIFI_CMD_SET_AP_WPS_P2P_IE:
{
int skip = strlen(android_wifi_cmd_str[ANDROID_WIFI_CMD_SET_AP_WPS_P2P_IE]) + 3;
bytes_written = rtw_cfg80211_set_mgnt_wpsp2pie(net, command + skip, priv_cmd.total_len - skip, *(command + skip - 2) - '0');
break;
}
#endif //CONFIG_IOCTL_CFG80211
#ifdef CONFIG_WFD
case ANDROID_WIFI_CMD_WFD_ENABLE:
{
// Commented by Albert 2012/07/24
// We can enable the WFD function by using the following command:
// wpa_cli driver wfd-enable
pwfd_info = &padapter->wfd_info;
if( padapter->wdinfo.driver_interface == DRIVER_CFG80211 )
pwfd_info->wfd_enable = _TRUE;
break;
}
case ANDROID_WIFI_CMD_WFD_DISABLE:
{
// Commented by Albert 2012/07/24
// We can disable the WFD function by using the following command:
// wpa_cli driver wfd-disable
pwfd_info = &padapter->wfd_info;
if( padapter->wdinfo.driver_interface == DRIVER_CFG80211 )
pwfd_info->wfd_enable = _FALSE;
break;
}
case ANDROID_WIFI_CMD_WFD_SET_TCPPORT:
{
// Commented by Albert 2012/07/24
// We can set the tcp port number by using the following command:
// wpa_cli driver wfd-set-tcpport = 554
pwfd_info = &padapter->wfd_info;
if( padapter->wdinfo.driver_interface == DRIVER_CFG80211 )
{
#ifdef CONFIG_COMPAT
pwfd_info->rtsp_ctrlport = ( u16 ) get_int_from_command( compat_ptr(priv_cmd.buf) );
#else
pwfd_info->rtsp_ctrlport = ( u16 ) get_int_from_command( priv_cmd.buf );
#endif
}
break;
}
case ANDROID_WIFI_CMD_WFD_SET_MAX_TPUT:
{
break;
}
case ANDROID_WIFI_CMD_WFD_SET_DEVTYPE:
{
// Commented by Albert 2012/08/28
// Specify the WFD device type ( WFD source/primary sink )
pwfd_info = &padapter->wfd_info;
if( padapter->wdinfo.driver_interface == DRIVER_CFG80211 )
{
#ifdef CONFIG_COMPAT
pwfd_info->wfd_device_type = ( u8 ) get_int_from_command( compat_ptr(priv_cmd.buf) );
#else
pwfd_info->wfd_device_type = ( u8 ) get_int_from_command( priv_cmd.buf );
#endif
pwfd_info->wfd_device_type &= WFD_DEVINFO_DUAL;
}
break;
}
#endif
case ANDROID_WIFI_CMD_CHANGE_DTIM:
{
#ifdef CONFIG_LPS
u8 dtim;
u8 *ptr = (u8 *) &priv_cmd.buf;
ptr += 9;//string command length of "SET_DTIM";
dtim = rtw_atoi(ptr);
DBG_871X("DTIM=%d\n", dtim);
rtw_lps_change_dtim_cmd(padapter, dtim);
#endif
}
break;
case ANDROID_WIFI_CMD_HOSTAPD_SET_MACADDR_ACL:
{
padapter->stapriv.acl_list.mode = ( u8 ) get_int_from_command(command);
DBG_871X("%s ANDROID_WIFI_CMD_HOSTAPD_SET_MACADDR_ACL mode:%d\n", __FUNCTION__, padapter->stapriv.acl_list.mode);
break;
}
case ANDROID_WIFI_CMD_HOSTAPD_ACL_ADD_STA:
{
u8 addr[ETH_ALEN] = {0x00};
macstr2num(addr, command+strlen("HOSTAPD_ACL_ADD_STA")+3); // 3 is space bar + "=" + space bar these 3 chars
rtw_acl_add_sta(padapter, addr);
break;
}
case ANDROID_WIFI_CMD_HOSTAPD_ACL_REMOVE_STA:
{
u8 addr[ETH_ALEN] = {0x00};
macstr2num(addr, command+strlen("HOSTAPD_ACL_REMOVE_STA")+3); // 3 is space bar + "=" + space bar these 3 chars
rtw_acl_remove_sta(padapter, addr);
break;
}
#ifdef CONFIG_GTK_OL
case ANDROID_WIFI_CMD_GTK_REKEY_OFFLOAD:
rtw_gtk_offload(net, priv_cmd.buf);
break;
#endif //CONFIG_GTK_OL
case ANDROID_WIFI_CMD_P2P_DISABLE:
{
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct wifidirect_info *pwdinfo= &(padapter->wdinfo);
u8 channel, ch_offset;
u16 bwmode;
rtw_p2p_enable(padapter, P2P_ROLE_DISABLE);
break;
}
default:
DBG_871X("Unknown PRIVATE command %s - ignored\n", command);
snprintf(command, 3, "OK");
bytes_written = strlen("OK");
}
response:
if (bytes_written >= 0) {
if ((bytes_written == 0) && (priv_cmd.total_len > 0))
command[0] = '\0';
if (bytes_written >= priv_cmd.total_len) {
DBG_871X("%s: bytes_written = %d\n", __FUNCTION__, bytes_written);
bytes_written = priv_cmd.total_len;
} else {
bytes_written++;
}
priv_cmd.used_len = bytes_written;
#ifdef CONFIG_COMPAT
if (copy_to_user(compat_ptr(priv_cmd.buf), command, bytes_written)) {
#else
if (copy_to_user((void *)priv_cmd.buf, command, bytes_written)) {
#endif
DBG_871X("%s: failed to copy data to user buffer\n", __FUNCTION__);
ret = -EFAULT;
}
}
else {
ret = bytes_written;
}
exit:
rtw_unlock_suspend();
if (command) {
rtw_mfree(command, priv_cmd.total_len);
}
return ret;
}
/**
* Functions for Android WiFi card detection
*/
#if defined(RTW_ENABLE_WIFI_CONTROL_FUNC)
static int g_wifidev_registered = 0;
static struct semaphore wifi_control_sem;
static struct wifi_platform_data *wifi_control_data = NULL;
static struct resource *wifi_irqres = NULL;
static int wifi_add_dev(void);
static void wifi_del_dev(void);
int rtw_android_wifictrl_func_add(void)
{
int ret = 0;
sema_init(&wifi_control_sem, 0);
ret = wifi_add_dev();
if (ret) {
DBG_871X("%s: platform_driver_register failed\n", __FUNCTION__);
return ret;
}
g_wifidev_registered = 1;
/* Waiting callback after platform_driver_register is done or exit with error */
if (down_timeout(&wifi_control_sem, msecs_to_jiffies(1000)) != 0) {
ret = -EINVAL;
DBG_871X("%s: platform_driver_register timeout\n", __FUNCTION__);
}
return ret;
}
void rtw_android_wifictrl_func_del(void)
{
if (g_wifidev_registered)
{
wifi_del_dev();
g_wifidev_registered = 0;
}
}
void *wl_android_prealloc(int section, unsigned long size)
{
void *alloc_ptr = NULL;
if (wifi_control_data && wifi_control_data->mem_prealloc) {
alloc_ptr = wifi_control_data->mem_prealloc(section, size);
if (alloc_ptr) {
DBG_871X("success alloc section %d\n", section);
if (size != 0L)
memset(alloc_ptr, 0, size);
return alloc_ptr;
}
}
DBG_871X("can't alloc section %d\n", section);
return NULL;
}
static long scale_k_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
int ret = 0;
struct scale_k_private *scale_private;
struct scale_k_file *fd;
struct scale_frame_param_t frame_params;
struct scale_slice_param_t slice_params;
fd = file->private_data;
if (!fd) {
ret = - EFAULT;
printk("scale_k_ioctl error: fd null \n");
goto ioctl_exit;
}
scale_private = fd->scale_private;
if (!scale_private) {
ret = -EFAULT;
printk("scale_k_ioctl erro: scale private null \n");
goto ioctl_exit;
}
switch (cmd) {
case SCALE_IO_START:
down(&scale_private->start_sem);
ret = scale_k_module_en(fd->dn);
if (unlikely(ret)) {
printk("rot_k_ioctl erro: scale_module_en\n");
up(&scale_private->start_sem);
goto ioctl_exit;
}
ret = scale_k_isr_reg(scale_k_irq, &fd->drv_private);
if (unlikely(ret)) {
printk("rot_k_ioctl error: scale_k_isr_reg\n");
scale_k_module_dis(fd->dn);
up(&scale_private->start_sem);
goto ioctl_exit;
}
ret = copy_from_user(&frame_params, (struct scale_frame_param_t *)arg, sizeof(frame_params));
if (ret) {
printk("rot_k_ioctl error: get frame param info \n");
scale_k_module_dis(fd->dn);
up(&scale_private->start_sem);
goto ioctl_exit;
}
ret = scale_k_start(&frame_params, &fd->drv_private.path_info);
if (ret) {
printk("rot_k_ioctl error: frame start \n");
scale_k_module_dis(fd->dn);
up(&scale_private->start_sem);
goto ioctl_exit;
}
ret = down_timeout(&fd->scale_done_sem, msecs_to_jiffies(5000));
if (ret) {
printk("scale_k_ioctl error: interruptible time out\n");
goto ioctl_out;
}
scale_k_stop();
scale_k_module_dis(fd->dn);
up(&scale_private->start_sem);
break;
case SCALE_IO_CONTINUE:
/*Caution: slice scale is not supported by current driver.Please do not use it*/
ret = copy_from_user(&slice_params, (struct scale_slice_param_t *)arg, sizeof(slice_params));
if (ret) {
printk("rot_k_ioctl error: get slice param info \n");
goto ioctl_exit;
}
ret = scale_k_continue(&slice_params, &fd->drv_private.path_info);
if (ret) {
printk("rot_k_ioctl error: continue \n");
}
break;
default:
break;
}
ioctl_exit:
return ret;
ioctl_out:
dcam_resize_end();
scale_k_stop();
scale_k_module_dis(fd->dn);
up(&scale_private->start_sem);
return ret;
}
int do_rpc_io(ItcRpcMsg *req)
{
static DEFINE_SPINLOCK(io_lock);
unsigned long flags;
MsgStruct msgBuf;
ItcRpcMsg response;
RpcMsgQueue msgQueueItem;
int timeout_cnt = 0;
DECLARE_MUTEX(sema);
// Construct a message
memset((void *)&msgBuf, 0, sizeof(MsgStruct));
msgBuf.msgLen = sizeof(ItcRpcMsg)/4;
memcpy((void *)&msgBuf.msgData[0], (void *)req, sizeof(ItcRpcMsg));
#if DEBUG_DQM_IO
printk(">>>> %s %08lx %08lx %08lx %08lx\n",
__func__, msgBuf.msgData[0], msgBuf.msgData[1], msgBuf.msgData[2], msgBuf.msgData[3]);
#endif
memset(&response, 0, sizeof(response));
msgQueueItem.xid = req->xid;
msgQueueItem.response = &response;
msgQueueItem.sema = &sema;
msgQueueItem.next = NULL;
add_to_msg_queue(&msgQueueItem);
down(&sema);
spin_lock_irqsave(&io_lock, flags);
if(hostDqmSendMessage(&msgBuf, dqmchannel.dqmTxHandle))
{
printk("%s:%d - Can not send rpc message!\n", __func__, __LINE__);
spin_unlock_irqrestore(&io_lock, flags);
return -1;
}
hostDqmEnableDqmQInt(dqmchannel.dqmRxHandle);
spin_unlock_irqrestore(&io_lock, flags);
enable_brcm_irq(INTERRUPT_ID_VFLASH);
while (down_timeout(&sema, rpc_io_timeout))
{
timeout_cnt++;
vflash_isr(-1, NULL);
if (timeout_cnt >= 60) {
dump_msg_queue();
extract_from_msg_queue(msgQueueItem.xid);
return -ETIMEDOUT;
}
else if ((timeout_cnt >= RPC_TIMEOUT_RESEND_CNT) &&
(timeout_cnt % RPC_TIMEOUT_RESEND_CNT == 0)) {
printk("%s: TIMEOUT resending %08lx\n", __func__, msgQueueItem.xid);
spin_lock_irqsave(&io_lock, flags);
if(hostDqmSendMessage(&msgBuf, dqmchannel.dqmTxHandle))
{
printk("%s:%d - Can not send rpc message!\n", __func__, __LINE__);
spin_unlock_irqrestore(&io_lock, flags);
return -1;
}
spin_unlock_irqrestore(&io_lock, flags);
}
}
#if DEBUG_DQM_IO
if (timeout_cnt)
{
printk("%s: %d timeouts but I got a reply for msg %08lx\n",
__func__, timeout_cnt, msgQueueItem.xid);
}
#endif
return response.u0;
}
static int csx_sigmorph_cleanup_point(int index)
{
int err = -1;
CSX_IO_HANDLE csx_io_handle;
CSX_MODULE_FNCS *csx_mod_ops;
CSX_IO_POINT_INFO *csx_info;
CSX_IO_POINT_FNCS csx_ops;
CSX_SIGMORPH_IO_POINT_INFO *rcrd = &point_registry[index];
(void)memset(&csx_ops, 0, sizeof(CSX_IO_POINT_FNCS));
err =
down_timeout(&csx_sigmorph_sem,
CSX_SIGMORPH_SEMAPHORE_TIME_WAIT_JIFFIES);
if (err) {
return err;
}
/* BEGIN critical section */
do {
csx_io_handle = rcrd->csx_io_point_handle;
csx_info = &rcrd->csx_io_point_info;
csx_mod_ops = csx_get_module_fncp(csx_info->csx_module_id);
if (rcrd->io_point_active == CSX_POINT_ENABLE) {
/* remove callbacks from kernel module */
if (csx_mod_ops->csx_module_set_point) {
(void)csx_mod_ops->
csx_module_set_point(csx_info->
csx_device_id,
csx_info->csx_point_id,
&csx_ops,
(void *)csx_io_handle);
}
/* Release GIST workers */
if (rcrd->capture_raw_hndl != GIST_INVALID_HANDLE) {
CSX_SIGMORPH_DEBUG
("Deleting GIST writer (0x%08X)",
rcrd->capture_raw_hndl);
(void)gist_free_writer(rcrd->capture_raw_hndl);
}
if (rcrd->capture_proc_hndl != GIST_INVALID_HANDLE) {
CSX_SIGMORPH_DEBUG
("Deleting GIST writer (0x%08X)",
rcrd->capture_proc_hndl);
(void)gist_free_writer(rcrd->capture_proc_hndl);
}
if (rcrd->inject_hndl != GIST_INVALID_HANDLE) {
CSX_SIGMORPH_DEBUG
("Deleting GIST reader (0x%08X)",
rcrd->inject_hndl);
(void)gist_free_reader(rcrd->inject_hndl);
}
/* retain rcrd slot */
CSX_SIGMORPH_DEBUG("Removing/ disabling I/O point (%d)",
index);
(void)memset(rcrd, 0,
sizeof(CSX_SIGMORPH_IO_POINT_INFO));
rcrd->io_point_active = CSX_POINT_DISABLE;
point_registry_active--;
} else {
err = -EINVAL;
}
/* END Critical section */
} while (0);
up(&csx_sigmorph_sem);
return err;
}
