static long g2d_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
g2d_params params;
int ret = -1;
struct g2d_dma_info dma_info;
switch(cmd) {
case G2D_GET_MEMORY :
ret = copy_to_user((unsigned int *)arg,
&(g2d_dev->reserved_mem.base), sizeof(g2d_dev->reserved_mem.base));
if (ret) {
FIMG2D_ERROR("error : copy_to_user\n");
return -EINVAL;
}
return 0;
case G2D_GET_MEMORY_SIZE :
ret = copy_to_user((unsigned int *)arg,
&(g2d_dev->reserved_mem.size), sizeof(g2d_dev->reserved_mem.size));
if (ret) {
FIMG2D_ERROR("error : copy_to_user\n");
return -EINVAL;
}
return 0;
case G2D_DMA_CACHE_CLEAN :
case G2D_DMA_CACHE_FLUSH :
mutex_lock(&g2d_dev->lock);
ret = copy_from_user(&dma_info, (struct g2d_dma_info *)arg, sizeof(dma_info));
if (ret) {
FIMG2D_ERROR("error : copy_from_user\n");
mutex_unlock(&g2d_dev->lock);
return -EINVAL;
}
if (dma_info.addr == 0) {
FIMG2D_ERROR("addr Null Error!!!\n");
mutex_unlock(&g2d_dev->lock);
return -EINVAL;
}
g2d_mem_cache_op(cmd, (void *)dma_info.addr, dma_info.size);
mutex_unlock(&g2d_dev->lock);
return 0;
case G2D_SYNC :
g2d_check_fifo_state_wait(g2d_dev);
ret = 0;
goto g2d_ioctl_done;
case G2D_RESET :
g2d_reset(g2d_dev);
FIMG2D_ERROR("G2D TimeOut Error\n");
ret = 0;
goto g2d_ioctl_done;
case G2D_BLIT:
if (atomic_read(&g2d_dev->ready_to_run) == 0)
goto g2d_ioctl_done2;
mutex_lock(&g2d_dev->lock);
g2d_clk_enable(g2d_dev);
if (copy_from_user(¶ms, (struct g2d_params *)arg, sizeof(g2d_params))) {
FIMG2D_ERROR("error : copy_from_user\n");
goto g2d_ioctl_done;
}
g2d_dev->irq_handled = 0;
atomic_set(&g2d_dev->in_use, 1);
if (atomic_read(&g2d_dev->ready_to_run) == 0)
goto g2d_ioctl_done;
if (!g2d_do_blit(g2d_dev, ¶ms)) {
g2d_dev->irq_handled = 1;
goto g2d_ioctl_done;
}
if (!(params.flag.render_mode & G2D_HYBRID_MODE)) {
if(!(file->f_flags & O_NONBLOCK)) {
if (!g2d_wait_for_finish(g2d_dev, ¶ms))
goto g2d_ioctl_done;
}
} else {
ret = 0;
goto g2d_ioctl_done2;
}
ret = 0;
break;
default :
goto g2d_ioctl_done2;
break;
}
g2d_ioctl_done :
g2d_clk_disable(g2d_dev);
mutex_unlock(&g2d_dev->lock);
atomic_set(&g2d_dev->in_use, 0);
g2d_ioctl_done2 :
return ret;
}
static int bcm_download_config_file(struct bcm_mini_adapter *Adapter,
struct bcm_firmware_info *psFwInfo)
{
int retval = STATUS_SUCCESS;
B_UINT32 value = 0;
if (Adapter->pstargetparams == NULL) {
Adapter->pstargetparams =
kmalloc(sizeof(struct bcm_target_params), GFP_KERNEL);
if (Adapter->pstargetparams == NULL)
return -ENOMEM;
}
if (psFwInfo->u32FirmwareLength != sizeof(struct bcm_target_params))
return -EIO;
retval = copy_from_user(Adapter->pstargetparams,
psFwInfo->pvMappedFirmwareAddress,
psFwInfo->u32FirmwareLength);
if (retval) {
kfree(Adapter->pstargetparams);
Adapter->pstargetparams = NULL;
return -EFAULT;
}
/* Parse the structure and then Download the Firmware */
beceem_parse_target_struct(Adapter);
/* Initializing the NVM. */
BcmInitNVM(Adapter);
retval = InitLedSettings(Adapter);
if (retval)
return retval;
if (Adapter->LEDInfo.led_thread_running &
BCM_LED_THREAD_RUNNING_ACTIVELY) {
Adapter->LEDInfo.bLedInitDone = false;
Adapter->DriverState = DRIVER_INIT;
wake_up(&Adapter->LEDInfo.notify_led_event);
}
if (Adapter->LEDInfo.led_thread_running &
BCM_LED_THREAD_RUNNING_ACTIVELY) {
Adapter->DriverState = FW_DOWNLOAD;
wake_up(&Adapter->LEDInfo.notify_led_event);
}
/* Initialize the DDR Controller */
retval = ddr_init(Adapter);
if (retval)
return retval;
value = 0;
wrmalt(Adapter, EEPROM_CAL_DATA_INTERNAL_LOC - 4,
&value, sizeof(value));
wrmalt(Adapter, EEPROM_CAL_DATA_INTERNAL_LOC - 8,
&value, sizeof(value));
if (Adapter->eNVMType == NVM_FLASH) {
retval = PropagateCalParamsFromFlashToMemory(Adapter);
if (retval)
return retval;
}
retval = buffDnldVerify(Adapter, (PUCHAR)Adapter->pstargetparams,
sizeof(struct bcm_target_params), CONFIG_BEGIN_ADDR);
if (retval)
BCM_DEBUG_PRINT(Adapter, DBG_TYPE_INITEXIT,
MP_INIT, DBG_LVL_ALL,
"configuration file not downloaded properly");
else
Adapter->bCfgDownloaded = TRUE;
return retval;
}
static long alarm_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
int rv = 0;
unsigned long flags;
struct timespec new_alarm_time;
struct timespec new_rtc_time;
struct timespec tmp_time;
enum android_alarm_type alarm_type = ANDROID_ALARM_IOCTL_TO_TYPE(cmd);
uint32_t alarm_type_mask = 1U << alarm_type;
if (alarm_type >= ANDROID_ALARM_TYPE_COUNT)
return -EINVAL;
if (ANDROID_ALARM_BASE_CMD(cmd) != ANDROID_ALARM_GET_TIME(0)) {
if ((file->f_flags & O_ACCMODE) == O_RDONLY)
return -EPERM;
if (file->private_data == NULL &&
cmd != ANDROID_ALARM_SET_RTC) {
spin_lock_irqsave(&alarm_slock, flags);
if (alarm_opened) {
spin_unlock_irqrestore(&alarm_slock, flags);
return -EBUSY;
}
alarm_opened = 1;
file->private_data = (void *)1;
spin_unlock_irqrestore(&alarm_slock, flags);
}
}
switch (ANDROID_ALARM_BASE_CMD(cmd)) {
case ANDROID_ALARM_CLEAR(0):
spin_lock_irqsave(&alarm_slock, flags);
pr_alarm(IO, "alarm %d clear\n", alarm_type);
alarm_try_to_cancel(&alarms[alarm_type]);
if (alarm_pending) {
alarm_pending &= ~alarm_type_mask;
if (!alarm_pending && !wait_pending)
wake_unlock(&alarm_wake_lock);
}
alarm_enabled &= ~alarm_type_mask;
spin_unlock_irqrestore(&alarm_slock, flags);
break;
case ANDROID_ALARM_SET_OLD:
case ANDROID_ALARM_SET_AND_WAIT_OLD:
if (get_user(new_alarm_time.tv_sec, (int __user *)arg)) {
rv = -EFAULT;
goto err1;
}
new_alarm_time.tv_nsec = 0;
goto from_old_alarm_set;
case ANDROID_ALARM_SET_AND_WAIT(0):
case ANDROID_ALARM_SET(0):
if (copy_from_user(&new_alarm_time, (void __user *)arg,
sizeof(new_alarm_time))) {
rv = -EFAULT;
goto err1;
}
from_old_alarm_set:
spin_lock_irqsave(&alarm_slock, flags);
pr_alarm(IO, "alarm %d set %ld.%09ld\n", alarm_type,
new_alarm_time.tv_sec, new_alarm_time.tv_nsec);
alarm_enabled |= alarm_type_mask;
alarm_start_range(&alarms[alarm_type],
timespec_to_ktime(new_alarm_time),
timespec_to_ktime(new_alarm_time));
spin_unlock_irqrestore(&alarm_slock, flags);
if (ANDROID_ALARM_BASE_CMD(cmd) != ANDROID_ALARM_SET_AND_WAIT(0)
&& cmd != ANDROID_ALARM_SET_AND_WAIT_OLD)
break;
/* fall though */
case ANDROID_ALARM_WAIT:
spin_lock_irqsave(&alarm_slock, flags);
pr_alarm(IO, "alarm wait\n");
if (!alarm_pending && wait_pending) {
wake_unlock(&alarm_wake_lock);
wait_pending = 0;
}
spin_unlock_irqrestore(&alarm_slock, flags);
rv = wait_event_interruptible(alarm_wait_queue, alarm_pending);
if (rv)
goto err1;
spin_lock_irqsave(&alarm_slock, flags);
rv = alarm_pending;
wait_pending = 1;
alarm_pending = 0;
spin_unlock_irqrestore(&alarm_slock, flags);
break;
case ANDROID_ALARM_SET_RTC:
if (copy_from_user(&new_rtc_time, (void __user *)arg,
sizeof(new_rtc_time))) {
rv = -EFAULT;
goto err1;
}
rv = alarm_set_rtc(new_rtc_time);
spin_lock_irqsave(&alarm_slock, flags);
alarm_pending |= ANDROID_ALARM_TIME_CHANGE_MASK;
wake_up(&alarm_wait_queue);
spin_unlock_irqrestore(&alarm_slock, flags);
if (rv < 0)
goto err1;
break;
#ifdef CONFIG_HUAWEI_FEATURE_POWEROFF_ALARM
/*set rtc alarm time ioctl case*/
case ANDROID_ALARM_SET_POWERUP_RTC:
if (copy_from_user(&new_alarm_time, (void __user *)arg,
sizeof(new_alarm_time))) {
rv = -EFAULT;
goto err1;
}
printk("Set alarm time sec is %ld\n",new_alarm_time.tv_sec);
msmrtc_remote_rtc_set_alarm(&new_alarm_time);
break;
#endif /*CONFIG_HUAWEI_FEATURE_POWEROFF_ALARM*/
case ANDROID_ALARM_GET_TIME(0):
switch (alarm_type) {
case ANDROID_ALARM_RTC_WAKEUP:
case ANDROID_ALARM_RTC:
getnstimeofday(&tmp_time);
break;
case ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP:
case ANDROID_ALARM_ELAPSED_REALTIME:
tmp_time =
ktime_to_timespec(alarm_get_elapsed_realtime());
break;
case ANDROID_ALARM_TYPE_COUNT:
case ANDROID_ALARM_SYSTEMTIME:
ktime_get_ts(&tmp_time);
break;
}
if (copy_to_user((void __user *)arg, &tmp_time,
sizeof(tmp_time))) {
rv = -EFAULT;
goto err1;
}
break;
default:
rv = -EINVAL;
goto err1;
}
err1:
return rv;
}
static int wpa_set_associate(PSDevice pDevice,
struct viawget_wpa_param *param)
{
PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
PWLAN_IE_SSID pItemSSID;
BYTE abyNullAddr[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
BYTE abyWPAIE[64];
int ret = 0;
BOOL bwepEnabled=FALSE;
// set key type & algorithm
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pairwise_suite = %d\n", param->u.wpa_associate.pairwise_suite);
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "group_suite = %d\n", param->u.wpa_associate.group_suite);
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "key_mgmt_suite = %d\n", param->u.wpa_associate.key_mgmt_suite);
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "auth_alg = %d\n", param->u.wpa_associate.auth_alg);
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "mode = %d\n", param->u.wpa_associate.mode);
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "wpa_ie_len = %d\n", param->u.wpa_associate.wpa_ie_len);
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Roaming dBm = %d\n", param->u.wpa_associate.roam_dbm); //Davidwang
if (param->u.wpa_associate.wpa_ie &&
copy_from_user(&abyWPAIE[0], param->u.wpa_associate.wpa_ie, param->u.wpa_associate.wpa_ie_len))
return -EINVAL;
if (param->u.wpa_associate.mode == 1)
pMgmt->eConfigMode = WMAC_CONFIG_IBSS_STA;
else
pMgmt->eConfigMode = WMAC_CONFIG_ESS_STA;
// set bssid
if (memcmp(param->u.wpa_associate.bssid, &abyNullAddr[0], 6) != 0)
memcpy(pMgmt->abyDesireBSSID, param->u.wpa_associate.bssid, 6);
// set ssid
memset(pMgmt->abyDesireSSID, 0, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
pItemSSID = (PWLAN_IE_SSID)pMgmt->abyDesireSSID;
pItemSSID->byElementID = WLAN_EID_SSID;
pItemSSID->len = param->u.wpa_associate.ssid_len;
memcpy(pItemSSID->abySSID, param->u.wpa_associate.ssid, pItemSSID->len);
if (param->u.wpa_associate.wpa_ie_len == 0) {
if (param->u.wpa_associate.auth_alg & AUTH_ALG_SHARED_KEY)
pMgmt->eAuthenMode = WMAC_AUTH_SHAREKEY;
else
pMgmt->eAuthenMode = WMAC_AUTH_OPEN;
} else if (abyWPAIE[0] == RSN_INFO_ELEM) {
if (param->u.wpa_associate.key_mgmt_suite == KEY_MGMT_PSK)
pMgmt->eAuthenMode = WMAC_AUTH_WPA2PSK;
else
pMgmt->eAuthenMode = WMAC_AUTH_WPA2;
} else {
if (param->u.wpa_associate.key_mgmt_suite == KEY_MGMT_WPA_NONE)
pMgmt->eAuthenMode = WMAC_AUTH_WPANONE;
else if (param->u.wpa_associate.key_mgmt_suite == KEY_MGMT_PSK)
pMgmt->eAuthenMode = WMAC_AUTH_WPAPSK;
else
pMgmt->eAuthenMode = WMAC_AUTH_WPA;
}
switch (param->u.wpa_associate.pairwise_suite) {
case CIPHER_CCMP:
pDevice->eEncryptionStatus = Ndis802_11Encryption3Enabled;
break;
case CIPHER_TKIP:
pDevice->eEncryptionStatus = Ndis802_11Encryption2Enabled;
break;
case CIPHER_WEP40:
case CIPHER_WEP104:
pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled;
bwepEnabled = TRUE;
// printk("****************wpa_set_associate:set CIPHER_WEP40_104\n");
break;
case CIPHER_NONE:
if (param->u.wpa_associate.group_suite == CIPHER_CCMP)
pDevice->eEncryptionStatus = Ndis802_11Encryption3Enabled;
else
pDevice->eEncryptionStatus = Ndis802_11Encryption2Enabled;
break;
default:
pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
};
pMgmt->Roam_dbm = param->u.wpa_associate.roam_dbm;
// if ((pMgmt->Roam_dbm > 40)&&(pMgmt->Roam_dbm<80))
// pDevice->bEnableRoaming = TRUE;
if (pMgmt->eAuthenMode == WMAC_AUTH_SHAREKEY) { //@wep-sharekey
pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled;
pMgmt->bShareKeyAlgorithm = TRUE;
}
else if (pMgmt->eAuthenMode == WMAC_AUTH_OPEN) {
if(bwepEnabled==TRUE) { //@open-wep
pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled;
}
else { //@only open
pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
}
}
//mike save old encryption status
pDevice->eOldEncryptionStatus = pDevice->eEncryptionStatus;
if (pDevice->eEncryptionStatus != Ndis802_11EncryptionDisabled)
pDevice->bEncryptionEnable = TRUE;
else
pDevice->bEncryptionEnable = FALSE;
if ((pMgmt->eAuthenMode == WMAC_AUTH_SHAREKEY) ||
((pMgmt->eAuthenMode == WMAC_AUTH_OPEN) && (bwepEnabled==TRUE))) {
//mike re-comment:open-wep && sharekey-wep needn't do initial key!!
}
else
KeyvInitTable(pDevice,&pDevice->sKey);
spin_lock_irq(&pDevice->lock);
pDevice->bLinkPass = FALSE;
ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_SLOW);
memset(pMgmt->abyCurrBSSID, 0, 6);
pMgmt->eCurrState = WMAC_STATE_IDLE;
netif_stop_queue(pDevice->dev);
//20080701-02,<Add> by Mike Liu
/*******search if ap_scan=2 ,which is associating request in hidden ssid mode ****/
{
PKnownBSS pCurr = NULL;
pCurr = BSSpSearchBSSList(pDevice,
pMgmt->abyDesireBSSID,
pMgmt->abyDesireSSID,
pDevice->eConfigPHYMode
);
if (pCurr == NULL){
printk("wpa_set_associate---->hidden mode site survey before associate.......\n");
bScheduleCommand((void *) pDevice,
WLAN_CMD_BSSID_SCAN,
pMgmt->abyDesireSSID);
};
}
/****************************************************************/
bScheduleCommand((void *) pDevice, WLAN_CMD_SSID, NULL);
spin_unlock_irq(&pDevice->lock);
return ret;
}
long arch_ptrace(struct task_struct *child, long request, long addr, long data)
{
int i, ret;
unsigned long __user *p = (void __user *)(unsigned long)data;
switch (request) {
/* when I and D space are separate, these will need to be fixed. */
case PTRACE_PEEKTEXT: /* read word at location addr. */
case PTRACE_PEEKDATA: {
unsigned long tmp;
int copied;
ret = -EIO;
copied = access_process_vm(child, addr, &tmp, sizeof(tmp), 0);
if (copied != sizeof(tmp))
break;
ret = put_user(tmp, p);
break;
}
/* read the word at location addr in the USER area. */
case PTRACE_PEEKUSR:
ret = peek_user(child, addr, data);
break;
/* when I and D space are separate, this will have to be fixed. */
case PTRACE_POKETEXT: /* write the word at location addr. */
case PTRACE_POKEDATA:
ret = -EIO;
if (access_process_vm(child, addr, &data, sizeof(data),
1) != sizeof(data))
break;
ret = 0;
break;
case PTRACE_POKEUSR: /* write the word at location addr in the USER area */
ret = poke_user(child, addr, data);
break;
case PTRACE_SYSCALL: /* continue and stop at next (return from) syscall */
case PTRACE_CONT: { /* restart after signal. */
ret = -EIO;
if (!valid_signal(data))
break;
set_singlestepping(child, 0);
if (request == PTRACE_SYSCALL) {
set_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
}
else {
clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
}
child->exit_code = data;
wake_up_process(child);
ret = 0;
break;
}
/*
* make the child exit. Best I can do is send it a sigkill.
* perhaps it should be put in the status that it wants to
* exit.
*/
case PTRACE_KILL: {
ret = 0;
if (child->exit_state == EXIT_ZOMBIE) /* already dead */
break;
set_singlestepping(child, 0);
child->exit_code = SIGKILL;
wake_up_process(child);
break;
}
case PTRACE_SINGLESTEP: { /* set the trap flag. */
ret = -EIO;
if (!valid_signal(data))
break;
clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
set_singlestepping(child, 1);
child->exit_code = data;
/* give it a chance to run. */
wake_up_process(child);
ret = 0;
break;
}
case PTRACE_DETACH:
/* detach a process that was attached. */
ret = ptrace_detach(child, data);
break;
#ifdef PTRACE_GETREGS
case PTRACE_GETREGS: { /* Get all gp regs from the child. */
if (!access_ok(VERIFY_WRITE, p, MAX_REG_OFFSET)) {
ret = -EIO;
break;
}
for ( i = 0; i < MAX_REG_OFFSET; i += sizeof(long) ) {
__put_user(getreg(child, i), p);
p++;
}
ret = 0;
break;
}
#endif
#ifdef PTRACE_SETREGS
case PTRACE_SETREGS: { /* Set all gp regs in the child. */
unsigned long tmp = 0;
if (!access_ok(VERIFY_READ, p, MAX_REG_OFFSET)) {
ret = -EIO;
break;
}
for ( i = 0; i < MAX_REG_OFFSET; i += sizeof(long) ) {
__get_user(tmp, p);
putreg(child, i, tmp);
p++;
}
ret = 0;
break;
}
#endif
#ifdef PTRACE_GETFPREGS
case PTRACE_GETFPREGS: /* Get the child FPU state. */
ret = get_fpregs(data, child);
break;
#endif
#ifdef PTRACE_SETFPREGS
case PTRACE_SETFPREGS: /* Set the child FPU state. */
ret = set_fpregs(data, child);
break;
#endif
#ifdef PTRACE_GETFPXREGS
case PTRACE_GETFPXREGS: /* Get the child FPU state. */
ret = get_fpxregs(data, child);
break;
#endif
#ifdef PTRACE_SETFPXREGS
case PTRACE_SETFPXREGS: /* Set the child FPU state. */
ret = set_fpxregs(data, child);
break;
#endif
case PTRACE_GET_THREAD_AREA:
ret = ptrace_get_thread_area(child, addr,
(struct user_desc __user *) data);
break;
case PTRACE_SET_THREAD_AREA:
ret = ptrace_set_thread_area(child, addr,
(struct user_desc __user *) data);
break;
case PTRACE_FAULTINFO: {
/* Take the info from thread->arch->faultinfo,
* but transfer max. sizeof(struct ptrace_faultinfo).
* On i386, ptrace_faultinfo is smaller!
*/
ret = copy_to_user(p, &child->thread.arch.faultinfo,
sizeof(struct ptrace_faultinfo));
if(ret)
break;
break;
}
#ifdef PTRACE_LDT
case PTRACE_LDT: {
struct ptrace_ldt ldt;
if(copy_from_user(&ldt, p, sizeof(ldt))){
ret = -EIO;
break;
}
/* This one is confusing, so just punt and return -EIO for
* now
*/
ret = -EIO;
break;
}
#endif
#ifdef CONFIG_PROC_MM
case PTRACE_SWITCH_MM: {
struct mm_struct *old = child->mm;
struct mm_struct *new = proc_mm_get_mm(data);
if(IS_ERR(new)){
ret = PTR_ERR(new);
break;
}
atomic_inc(&new->mm_users);
child->mm = new;
child->active_mm = new;
mmput(old);
ret = 0;
break;
}
#endif
default:
ret = ptrace_request(child, request, addr, data);
break;
}
return ret;
}
static int
aps_12d_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
unsigned long arg)
{
void __user *argp = (void __user *)arg;
short flag;
switch (cmd)
{
case ECS_IOCTL_APP_SET_LFLAG:
if (copy_from_user(&flag, argp, sizeof(flag)))
return -EFAULT;
break;
case ECS_IOCTL_APP_SET_PFLAG:
if (copy_from_user(&flag, argp, sizeof(flag)))
return -EFAULT;
break;
case ECS_IOCTL_APP_SET_DELAY:
/*<BU5D08118 zhangtao 20100419 begin*/
if (copy_from_user(&flag, argp, sizeof(flag)))
/*BU5D08118 zhangtao 20100419 end>*/
return -EFAULT;
break;
default:
break;
}
switch (cmd)
{
case ECS_IOCTL_APP_SET_LFLAG:
atomic_set(&l_flag, flag);
break;
case ECS_IOCTL_APP_GET_LFLAG: /*get open acceleration sensor flag*/
flag = atomic_read(&l_flag);
break;
case ECS_IOCTL_APP_SET_PFLAG:
atomic_set(&p_flag, flag);
/* <DTS2010100800714 liugaofei 20101008 begin */
if( flag )
{
/*
* this means the proximity sensor is open.
* so init the range_index to zero
*/
range_index = 0;
}
/* DTS2010100800714 liugaofei 20101008 end */
break;
case ECS_IOCTL_APP_GET_PFLAG: /*get open acceleration sensor flag*/
flag = atomic_read(&p_flag);
break;
case ECS_IOCTL_APP_SET_DELAY:
if(flag)
aps_12d_delay = flag;
else
/* < DTS2010102103994 zhangtao 20101112 begin */
aps_12d_delay = 20; /*200ms*/
/* DTS2010102103994 zhangtao 20101112 end > */
break;
case ECS_IOCTL_APP_GET_DELAY:
flag = aps_12d_delay;
break;
/* < DTS2011071500961 liujinggang 20110715 begin */
/*get value of proximity and light*/
case ECS_IOCTL_APP_GET_PDATA_VALVE:
flag = proximity_data_value;
break;
case ECS_IOCTL_APP_GET_LDATA_VALVE:
flag = light_data_value;
break;
/* DTS2011071500961 liujinggang 20110715 end > */
default:
break;
}
switch (cmd)
{
case ECS_IOCTL_APP_GET_LFLAG:
if (copy_to_user(argp, &flag, sizeof(flag)))
return -EFAULT;
break;
case ECS_IOCTL_APP_GET_PFLAG:
if (copy_to_user(argp, &flag, sizeof(flag)))
return -EFAULT;
break;
case ECS_IOCTL_APP_GET_DELAY:
if (copy_to_user(argp, &flag, sizeof(flag)))
return -EFAULT;
break;
/* < DTS2011071500961 liujinggang 20110715 begin */
/*get value of proximity and light*/
case ECS_IOCTL_APP_GET_PDATA_VALVE:
if (copy_to_user(argp, &flag, sizeof(flag)))
return -EFAULT;
break;
case ECS_IOCTL_APP_GET_LDATA_VALVE:
if (copy_to_user(argp, &flag, sizeof(flag)))
return -EFAULT;
break;
/* DTS2011071500961 liujinggang 20110715 end > */
default:
break;
}
return 0;
}
SYSCALL_DEFINE6(copy_file_range, int, fd_in, loff_t __user *, off_in,
int, fd_out, loff_t __user *, off_out,
size_t, len, unsigned int, flags)
{
loff_t pos_in;
loff_t pos_out;
struct fd f_in;
struct fd f_out;
ssize_t ret = -EBADF;
f_in = fdget(fd_in);
if (!f_in.file)
goto out2;
f_out = fdget(fd_out);
if (!f_out.file)
goto out1;
ret = -EFAULT;
if (off_in) {
if (copy_from_user(&pos_in, off_in, sizeof(loff_t)))
goto out;
} else {
pos_in = f_in.file->f_pos;
}
if (off_out) {
if (copy_from_user(&pos_out, off_out, sizeof(loff_t)))
goto out;
} else {
pos_out = f_out.file->f_pos;
}
ret = vfs_copy_file_range(f_in.file, pos_in, f_out.file, pos_out, len,
flags);
if (ret > 0) {
pos_in += ret;
pos_out += ret;
if (off_in) {
if (copy_to_user(off_in, &pos_in, sizeof(loff_t)))
ret = -EFAULT;
} else {
f_in.file->f_pos = pos_in;
}
if (off_out) {
if (copy_to_user(off_out, &pos_out, sizeof(loff_t)))
ret = -EFAULT;
} else {
f_out.file->f_pos = pos_out;
}
}
out:
fdput(f_out);
out1:
fdput(f_in);
out2:
return ret;
}
int devinet_ioctl(struct net *net, unsigned int cmd, void __user *arg)
{
struct ifreq ifr;
struct sockaddr_in sin_orig;
struct sockaddr_in *sin = (struct sockaddr_in *)&ifr.ifr_addr;
struct in_device *in_dev;
struct in_ifaddr **ifap = NULL;
struct in_ifaddr *ifa = NULL;
struct net_device *dev;
char *colon;
int ret = -EFAULT;
int tryaddrmatch = 0;
/*
* Fetch the caller's info block into kernel space
*/
if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
goto out;
ifr.ifr_name[IFNAMSIZ - 1] = 0;
/* save original address for comparison */
memcpy(&sin_orig, sin, sizeof(*sin));
colon = strchr(ifr.ifr_name, ':');
if (colon)
*colon = 0;
dev_load(net, ifr.ifr_name);
switch (cmd) {
case SIOCGIFADDR: /* Get interface address */
case SIOCGIFBRDADDR: /* Get the broadcast address */
case SIOCGIFDSTADDR: /* Get the destination address */
case SIOCGIFNETMASK: /* Get the netmask for the interface */
/* Note that these ioctls will not sleep,
so that we do not impose a lock.
One day we will be forced to put shlock here (I mean SMP)
*/
tryaddrmatch = (sin_orig.sin_family == AF_INET);
memset(sin, 0, sizeof(*sin));
sin->sin_family = AF_INET;
break;
case SIOCSIFFLAGS:
ret = -EACCES;
if (!capable(CAP_NET_ADMIN))
goto out;
break;
case SIOCSIFADDR: /* Set interface address (and family) */
case SIOCSIFBRDADDR: /* Set the broadcast address */
case SIOCSIFDSTADDR: /* Set the destination address */
case SIOCSIFNETMASK: /* Set the netmask for the interface */
case SIOCKILLADDR: /* Nuke all sockets on this address */
ret = -EACCES;
if (!capable(CAP_NET_ADMIN))
goto out;
ret = -EINVAL;
if (sin->sin_family != AF_INET)
goto out;
break;
default:
ret = -EINVAL;
goto out;
}
rtnl_lock();
ret = -ENODEV;
if ((dev = __dev_get_by_name(net, ifr.ifr_name)) == NULL)
goto done;
if (colon)
*colon = ':';
if ((in_dev = __in_dev_get_rtnl(dev)) != NULL) {
if (tryaddrmatch) {
/* Matthias Andree */
/* compare label and address (4.4BSD style) */
/* note: we only do this for a limited set of ioctls
and only if the original address family was AF_INET.
This is checked above. */
for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
ifap = &ifa->ifa_next) {
if (!strcmp(ifr.ifr_name, ifa->ifa_label) &&
sin_orig.sin_addr.s_addr ==
ifa->ifa_address) {
break; /* found */
}
}
}
/* we didn't get a match, maybe the application is
4.3BSD-style and passed in junk so we fall back to
comparing just the label */
if (!ifa) {
for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
ifap = &ifa->ifa_next)
if (!strcmp(ifr.ifr_name, ifa->ifa_label))
break;
}
}
ret = -EADDRNOTAVAIL;
if (!ifa && cmd != SIOCSIFADDR && cmd != SIOCSIFFLAGS
&& cmd != SIOCKILLADDR)
goto done;
switch (cmd) {
case SIOCGIFADDR: /* Get interface address */
sin->sin_addr.s_addr = ifa->ifa_local;
goto rarok;
case SIOCGIFBRDADDR: /* Get the broadcast address */
sin->sin_addr.s_addr = ifa->ifa_broadcast;
goto rarok;
case SIOCGIFDSTADDR: /* Get the destination address */
sin->sin_addr.s_addr = ifa->ifa_address;
goto rarok;
case SIOCGIFNETMASK: /* Get the netmask for the interface */
sin->sin_addr.s_addr = ifa->ifa_mask;
goto rarok;
case SIOCSIFFLAGS:
if (colon) {
ret = -EADDRNOTAVAIL;
if (!ifa)
break;
ret = 0;
if (!(ifr.ifr_flags & IFF_UP))
inet_del_ifa(in_dev, ifap, 1);
break;
}
ret = dev_change_flags(dev, ifr.ifr_flags);
break;
case SIOCSIFADDR: /* Set interface address (and family) */
ret = -EINVAL;
if (inet_abc_len(sin->sin_addr.s_addr) < 0)
break;
if (!ifa) {
ret = -ENOBUFS;
if ((ifa = inet_alloc_ifa()) == NULL)
break;
if (colon)
memcpy(ifa->ifa_label, ifr.ifr_name, IFNAMSIZ);
else
memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
} else {
ret = 0;
if (ifa->ifa_local == sin->sin_addr.s_addr)
break;
inet_del_ifa(in_dev, ifap, 0);
ifa->ifa_broadcast = 0;
ifa->ifa_scope = 0;
}
ifa->ifa_address = ifa->ifa_local = sin->sin_addr.s_addr;
if (!(dev->flags & IFF_POINTOPOINT)) {
ifa->ifa_prefixlen = inet_abc_len(ifa->ifa_address);
ifa->ifa_mask = inet_make_mask(ifa->ifa_prefixlen);
if ((dev->flags & IFF_BROADCAST) &&
ifa->ifa_prefixlen < 31)
ifa->ifa_broadcast = ifa->ifa_address |
~ifa->ifa_mask;
} else {
ifa->ifa_prefixlen = 32;
ifa->ifa_mask = inet_make_mask(32);
}
ret = inet_set_ifa(dev, ifa);
break;
case SIOCSIFBRDADDR: /* Set the broadcast address */
ret = 0;
if (ifa->ifa_broadcast != sin->sin_addr.s_addr) {
inet_del_ifa(in_dev, ifap, 0);
ifa->ifa_broadcast = sin->sin_addr.s_addr;
inet_insert_ifa(ifa);
}
break;
case SIOCSIFDSTADDR: /* Set the destination address */
ret = 0;
if (ifa->ifa_address == sin->sin_addr.s_addr)
break;
ret = -EINVAL;
if (inet_abc_len(sin->sin_addr.s_addr) < 0)
break;
ret = 0;
inet_del_ifa(in_dev, ifap, 0);
ifa->ifa_address = sin->sin_addr.s_addr;
inet_insert_ifa(ifa);
break;
case SIOCSIFNETMASK: /* Set the netmask for the interface */
/*
* The mask we set must be legal.
*/
ret = -EINVAL;
if (bad_mask(sin->sin_addr.s_addr, 0))
break;
ret = 0;
if (ifa->ifa_mask != sin->sin_addr.s_addr) {
__be32 old_mask = ifa->ifa_mask;
inet_del_ifa(in_dev, ifap, 0);
ifa->ifa_mask = sin->sin_addr.s_addr;
ifa->ifa_prefixlen = inet_mask_len(ifa->ifa_mask);
/* See if current broadcast address matches
* with current netmask, then recalculate
* the broadcast address. Otherwise it's a
* funny address, so don't touch it since
* the user seems to know what (s)he's doing...
*/
if ((dev->flags & IFF_BROADCAST) &&
(ifa->ifa_prefixlen < 31) &&
(ifa->ifa_broadcast ==
(ifa->ifa_local|~old_mask))) {
ifa->ifa_broadcast = (ifa->ifa_local |
~sin->sin_addr.s_addr);
}
inet_insert_ifa(ifa);
}
break;
case SIOCKILLADDR: /* Nuke all connections on this address */
ret = 0;
tcp_v4_nuke_addr(sin->sin_addr.s_addr);
break;
}
done:
rtnl_unlock();
out:
return ret;
rarok:
rtnl_unlock();
ret = copy_to_user(arg, &ifr, sizeof(struct ifreq)) ? -EFAULT : 0;
goto out;
}
static int mxc_ldb_ioctl(struct inode *inode, struct file *file,
unsigned int cmd, unsigned long arg)
{
int ret = 0;
uint32_t reg;
switch (cmd) {
case LDB_BGREF_RMODE:
{
ldb_bgref_parm parm;
if (copy_from_user(&parm, (ldb_bgref_parm *) arg,
sizeof(ldb_bgref_parm)))
return -EFAULT;
spin_lock(&ldb_lock);
reg = __raw_readl(ldb.control_reg);
if (parm.bgref_mode == LDB_EXT_REF)
__raw_writel((reg & ~LDB_BGREF_RMODE_MASK) |
LDB_BGREF_RMODE_EXT, ldb.control_reg);
else if (parm.bgref_mode == LDB_INT_REF)
__raw_writel((reg & ~LDB_BGREF_RMODE_MASK) |
LDB_BGREF_RMODE_INT, ldb.control_reg);
spin_unlock(&ldb_lock);
break;
}
case LDB_VSYNC_POL:
{
ldb_vsync_parm parm;
if (copy_from_user(&parm, (ldb_vsync_parm *) arg,
sizeof(ldb_vsync_parm)))
return -EFAULT;
spin_lock(&ldb_lock);
reg = __raw_readl(ldb.control_reg);
if (parm.vsync_mode == LDB_VS_ACT_H) {
if (parm.di == 0)
__raw_writel((reg &
~LDB_DI0_VS_POL_MASK) |
LDB_DI0_VS_POL_ACT_HIGH,
ldb.control_reg);
else
__raw_writel((reg &
~LDB_DI1_VS_POL_MASK) |
LDB_DI1_VS_POL_ACT_HIGH,
ldb.control_reg);
} else if (parm.vsync_mode == LDB_VS_ACT_L) {
if (parm.di == 0)
__raw_writel((reg &
~LDB_DI0_VS_POL_MASK) |
LDB_DI0_VS_POL_ACT_LOW,
ldb.control_reg);
else
__raw_writel((reg &
~LDB_DI1_VS_POL_MASK) |
LDB_DI1_VS_POL_ACT_LOW,
ldb.control_reg);
}
spin_unlock(&ldb_lock);
break;
}
case LDB_BIT_MAP:
{
ldb_bitmap_parm parm;
if (copy_from_user(&parm, (ldb_bitmap_parm *) arg,
sizeof(ldb_bitmap_parm)))
return -EFAULT;
spin_lock(&ldb_lock);
reg = __raw_readl(ldb.control_reg);
if (parm.bitmap_mode == LDB_BIT_MAP_SPWG) {
if (parm.channel == 0)
__raw_writel((reg & ~LDB_BIT_MAP_CH0_MASK) |
LDB_BIT_MAP_CH0_SPWG,
ldb.control_reg);
else
__raw_writel((reg & ~LDB_BIT_MAP_CH0_MASK) |
LDB_BIT_MAP_CH1_SPWG,
ldb.control_reg);
} else if (parm.bitmap_mode == LDB_BIT_MAP_JEIDA) {
if (parm.channel == 0)
__raw_writel((reg & ~LDB_BIT_MAP_CH0_MASK) |
LDB_BIT_MAP_CH0_JEIDA,
ldb.control_reg);
else
__raw_writel((reg & ~LDB_BIT_MAP_CH0_MASK) |
LDB_BIT_MAP_CH1_JEIDA,
ldb.control_reg);
}
spin_unlock(&ldb_lock);
break;
}
case LDB_DATA_WIDTH:
{
ldb_data_width_parm parm;
if (copy_from_user(&parm, (ldb_data_width_parm *) arg,
sizeof(ldb_data_width_parm)))
return -EFAULT;
spin_lock(&ldb_lock);
reg = __raw_readl(ldb.control_reg);
if (parm.data_width == 24) {
if (parm.channel == 0)
__raw_writel((reg & ~LDB_DATA_WIDTH_CH0_MASK) |
LDB_DATA_WIDTH_CH0_24,
ldb.control_reg);
else
__raw_writel((reg & ~LDB_DATA_WIDTH_CH0_MASK) |
LDB_DATA_WIDTH_CH1_24,
ldb.control_reg);
} else if (parm.data_width == 18) {
if (parm.channel == 0)
__raw_writel((reg & ~LDB_DATA_WIDTH_CH0_MASK) |
LDB_DATA_WIDTH_CH0_18,
ldb.control_reg);
else
__raw_writel((reg & ~LDB_DATA_WIDTH_CH0_MASK) |
LDB_DATA_WIDTH_CH1_18,
ldb.control_reg);
}
spin_unlock(&ldb_lock);
break;
}
case LDB_CHAN_MODE:
{
ldb_chan_mode_parm parm;
struct clk *pll4_clk;
unsigned long pll4_rate = 0;
if (copy_from_user(&parm, (ldb_chan_mode_parm *) arg,
sizeof(ldb_chan_mode_parm)))
return -EFAULT;
spin_lock(&ldb_lock);
/* TODO:Set the correct pll4 rate for all situations */
pll4_clk = clk_get(g_ldb_dev, "pll4");
pll4_rate = clk_get_rate(pll4_clk);
pll4_rate = 455000000;
clk_set_rate(pll4_clk, pll4_rate);
clk_put(pll4_clk);
reg = __raw_readl(ldb.control_reg);
switch (parm.channel_mode) {
case LDB_CHAN_MODE_SIN:
if (parm.di == 0) {
ldb.chan_mode_opt = LDB_SIN_DI0;
ldb.ldb_di_clk[0] = clk_get(g_ldb_dev,
"ldb_di0_clk");
clk_set_rate(ldb.ldb_di_clk[0], pll4_rate/7);
clk_put(ldb.ldb_di_clk[0]);
__raw_writel((reg & ~LDB_CH0_MODE_MASK) |
LDB_CH0_MODE_EN_TO_DI0,
ldb.control_reg);
} else {
ldb.chan_mode_opt = LDB_SIN_DI1;
ldb.ldb_di_clk[1] = clk_get(g_ldb_dev,
"ldb_di1_clk");
clk_set_rate(ldb.ldb_di_clk[1], pll4_rate/7);
clk_put(ldb.ldb_di_clk[1]);
__raw_writel((reg & ~LDB_CH1_MODE_MASK) |
LDB_CH1_MODE_EN_TO_DI1,
ldb.control_reg);
}
break;
case LDB_CHAN_MODE_SEP:
ldb.chan_mode_opt = LDB_SEP;
ldb.ldb_di_clk[0] = clk_get(g_ldb_dev, "ldb_di0_clk");
clk_set_rate(ldb.ldb_di_clk[0], pll4_rate/7);
clk_put(ldb.ldb_di_clk[0]);
ldb.ldb_di_clk[1] = clk_get(g_ldb_dev, "ldb_di1_clk");
clk_set_rate(ldb.ldb_di_clk[1], pll4_rate/7);
clk_put(ldb.ldb_di_clk[1]);
__raw_writel((reg & ~(LDB_CH0_MODE_MASK |
LDB_CH1_MODE_MASK)) |
LDB_CH0_MODE_EN_TO_DI0 |
LDB_CH1_MODE_EN_TO_DI1,
ldb.control_reg);
break;
case LDB_CHAN_MODE_DUL:
case LDB_CHAN_MODE_SPL:
ldb.ldb_di_clk[0] = clk_get(g_ldb_dev, "ldb_di0_clk");
ldb.ldb_di_clk[1] = clk_get(g_ldb_dev, "ldb_di1_clk");
if (parm.di == 0) {
if (parm.channel_mode == LDB_CHAN_MODE_DUL) {
ldb.chan_mode_opt = LDB_DUL_DI0;
clk_set_rate(ldb.ldb_di_clk[0],
pll4_rate/7);
} else {
ldb.chan_mode_opt = LDB_SPL_DI0;
clk_set_rate(ldb.ldb_di_clk[0],
2*pll4_rate/7);
clk_set_rate(ldb.ldb_di_clk[1],
2*pll4_rate/7);
reg = __raw_readl(ldb.control_reg);
__raw_writel(reg | LDB_SPLIT_MODE_EN,
ldb.control_reg);
}
reg = __raw_readl(ldb.control_reg);
__raw_writel((reg & ~(LDB_CH0_MODE_MASK |
LDB_CH1_MODE_MASK)) |
LDB_CH0_MODE_EN_TO_DI0 |
LDB_CH1_MODE_EN_TO_DI0,
ldb.control_reg);
} else {
if (parm.channel_mode == LDB_CHAN_MODE_DUL) {
ldb.chan_mode_opt = LDB_DUL_DI1;
clk_set_rate(ldb.ldb_di_clk[1],
pll4_rate/7);
} else {
ldb.chan_mode_opt = LDB_SPL_DI1;
clk_set_rate(ldb.ldb_di_clk[0],
2*pll4_rate/7);
clk_set_rate(ldb.ldb_di_clk[1],
2*pll4_rate/7);
reg = __raw_readl(ldb.control_reg);
__raw_writel(reg | LDB_SPLIT_MODE_EN,
ldb.control_reg);
}
reg = __raw_readl(ldb.control_reg);
__raw_writel((reg & ~(LDB_CH0_MODE_MASK |
LDB_CH1_MODE_MASK)) |
LDB_CH0_MODE_EN_TO_DI1 |
LDB_CH1_MODE_EN_TO_DI1,
ldb.control_reg);
}
clk_put(ldb.ldb_di_clk[0]);
clk_put(ldb.ldb_di_clk[1]);
break;
default:
ret = -EINVAL;
break;
}
spin_unlock(&ldb_lock);
break;
}
case LDB_ENABLE:
{
int ipu_di;
if (copy_from_user(&ipu_di, (int *) arg, sizeof(int)))
return -EFAULT;
ldb_enable(ipu_di);
break;
}
case LDB_DISABLE:
{
int ipu_di;
if (copy_from_user(&ipu_di, (int *) arg, sizeof(int)))
return -EFAULT;
ldb_disable(ipu_di);
break;
}
default:
ret = -EINVAL;
break;
}
return ret;
}
/**
* usb_tranzport_write
*/
static ssize_t usb_tranzport_write(struct file *file,
const char __user *buffer, size_t count,
loff_t *ppos)
{
struct usb_tranzport *dev;
size_t bytes_to_write;
int retval = 0;
dev = file->private_data;
/* verify that we actually have some data to write */
if (count == 0)
goto exit;
/* lock this object */
if (mutex_lock_interruptible(&dev->mtx)) {
retval = -ERESTARTSYS;
goto exit;
}
/* verify that the device wasn't unplugged */
if (dev->intf == NULL) {
retval = -ENODEV;
err("No device or device unplugged %d\n", retval);
goto unlock_exit;
}
/* wait until previous transfer is finished */
if (dev->interrupt_out_busy) {
if (file->f_flags & O_NONBLOCK) {
retval = -EAGAIN;
goto unlock_exit;
}
retval = wait_event_interruptible(dev->write_wait,
!dev->interrupt_out_busy);
if (retval < 0)
goto unlock_exit;
}
/* write the data into interrupt_out_buffer from userspace */
bytes_to_write = min(count,
write_buffer_size *
dev->interrupt_out_endpoint_size);
if (bytes_to_write < count)
dev_warn(&dev->intf->dev,
"Write buffer overflow, %zd bytes dropped\n",
count - bytes_to_write);
dbg_info(&dev->intf->dev,
"%s: count = %zd, bytes_to_write = %zd\n", __func__,
count, bytes_to_write);
if (copy_from_user(dev->interrupt_out_buffer, buffer, bytes_to_write)) {
retval = -EFAULT;
goto unlock_exit;
}
if (dev->interrupt_out_endpoint == NULL) {
err("Endpoint should not be be null!\n");
goto unlock_exit;
}
/* send off the urb */
usb_fill_int_urb(dev->interrupt_out_urb,
interface_to_usbdev(dev->intf),
usb_sndintpipe(interface_to_usbdev(dev->intf),
dev->interrupt_out_endpoint->
bEndpointAddress),
dev->interrupt_out_buffer, bytes_to_write,
usb_tranzport_interrupt_out_callback, dev,
dev->interrupt_out_interval);
dev->interrupt_out_busy = 1;
wmb();
retval = usb_submit_urb(dev->interrupt_out_urb, GFP_KERNEL);
if (retval) {
dev->interrupt_out_busy = 0;
err("Couldn't submit interrupt_out_urb %d\n", retval);
goto unlock_exit;
}
retval = bytes_to_write;
unlock_exit:
/* unlock the device */
mutex_unlock(&dev->mtx);
exit:
return retval;
}
static long link_pm_ioctl(struct file *file, unsigned int cmd,
unsigned long arg)
{
int value, err = 0;
struct task_struct *task = get_current();
struct link_pm_data *pm_data = file->private_data;
struct usb_link_device *usb_ld = pm_data->usb_ld;
char taskname[TASK_COMM_LEN];
pr_info("mif: %s: 0x%08x\n", __func__, cmd);
switch (cmd) {
case IOCTL_LINK_CONTROL_ACTIVE:
if (copy_from_user(&value, (const void __user *)arg,
sizeof(int)))
return -EFAULT;
gpio_set_value(pm_data->gpio_link_active, value);
break;
case IOCTL_LINK_GET_HOSTWAKE:
return !gpio_get_value(pm_data->gpio_link_hostwake);
case IOCTL_LINK_CONNECTED:
return pm_data->usb_ld->if_usb_connected;
case IOCTL_LINK_PORT_ON: /* hub only */
/* ignore cp host wakeup irq, set the hub_init_lock when AP try
CP off and release hub_init_lock when CP boot done */
pm_data->hub_init_lock = 0;
if (pm_data->root_hub) {
pm_runtime_resume(pm_data->root_hub);
pm_runtime_forbid(pm_data->root_hub->parent);
}
if (pm_data->port_enable) {
err = pm_data->port_enable(2, 1);
if (err < 0) {
pr_err("mif: %s: hub on fail err=%d\n",
__func__, err);
goto exit;
}
pm_data->hub_status = HUB_STATE_RESUMMING;
}
break;
case IOCTL_LINK_PORT_OFF: /* hub only */
if (pm_data->usb_ld->if_usb_connected) {
struct usb_device *udev =
pm_data->usb_ld->usbdev->parent;
pm_runtime_get_sync(&udev->dev);
if (udev->state != USB_STATE_NOTATTACHED) {
usb_force_disconnect(udev);
pr_info("force disconnect maybe cp-reset!!\n");
}
pm_runtime_put_autosuspend(&udev->dev);
}
err = link_pm_hub_standby(pm_data);
if (err < 0) {
pr_err("mif: %s: usb3503 active fail\n", __func__);
goto exit;
}
pm_data->hub_init_lock = 1;
pm_data->hub_handshake_done = 0;
break;
case IOCTL_LINK_BLOCK_AUTOSUSPEND: /* block autosuspend forever */
mif_info("blocked autosuspend by `%s(%d)'\n",
get_task_comm(taskname, task), task->pid);
pm_data->block_autosuspend = true;
if (usb_ld->usbdev)
pm_runtime_forbid(&usb_ld->usbdev->dev);
else {
mif_err("Block autosuspend failed\n");
err = -ENODEV;
}
break;
case IOCTL_LINK_ENABLE_AUTOSUSPEND: /* Enable autosuspend */
mif_info("autosuspend enabled by `%s(%d)'\n",
get_task_comm(taskname, task), task->pid);
pm_data->block_autosuspend = false;
if (usb_ld->usbdev)
pm_runtime_allow(&usb_ld->usbdev->dev);
else {
mif_err("Enable autosuspend failed\n");
err = -ENODEV;
}
break;
default:
break;
}
exit:
return err;
}
/* ------------------- device --------------------- */
static long audqcelp_in_ioctl(struct file *file,
unsigned int cmd, unsigned long arg)
{
struct audio_in *audio = file->private_data;
int rc = 0;
if (cmd == AUDIO_GET_STATS) {
struct msm_audio_stats stats;
stats.byte_count = atomic_read(&audio->in_bytes);
stats.sample_count = atomic_read(&audio->in_samples);
if (copy_to_user((void *) arg, &stats, sizeof(stats)))
return -EFAULT;
return rc;
}
mutex_lock(&audio->lock);
switch (cmd) {
case AUDIO_START: {
uint32_t freq;
freq = 48000;
MM_DBG("AUDIO_START\n");
if (audio->in_call && (audio->voice_state !=
VOICE_STATE_INCALL)) {
rc = -EPERM;
break;
}
rc = msm_snddev_request_freq(&freq, audio->enc_id,
SNDDEV_CAP_TX, AUDDEV_CLNT_ENC);
MM_DBG("sample rate configured %d\n", freq);
if (rc < 0) {
MM_DBG(" Sample rate can not be set, return code %d\n",
rc);
msm_snddev_withdraw_freq(audio->enc_id,
SNDDEV_CAP_TX, AUDDEV_CLNT_ENC);
MM_DBG("msm_snddev_withdraw_freq\n");
break;
}
rc = audqcelp_in_enable(audio);
if (!rc) {
rc =
wait_event_interruptible_timeout(audio->wait_enable,
audio->running != 0, 1*HZ);
MM_DBG("state %d rc = %d\n", audio->running, rc);
if (audio->running == 0)
rc = -ENODEV;
else
rc = 0;
}
audio->stopped = 0;
break;
}
case AUDIO_STOP: {
rc = audqcelp_in_disable(audio);
rc = msm_snddev_withdraw_freq(audio->enc_id,
SNDDEV_CAP_TX, AUDDEV_CLNT_ENC);
MM_DBG("msm_snddev_withdraw_freq\n");
audio->stopped = 1;
break;
}
case AUDIO_FLUSH: {
if (audio->stopped) {
/* Make sure we're stopped and we wake any threads
* that might be blocked holding the read_lock.
* While audio->stopped read threads will always
* exit immediately.
*/
wake_up(&audio->wait);
mutex_lock(&audio->read_lock);
audqcelp_in_flush(audio);
mutex_unlock(&audio->read_lock);
}
break;
}
case AUDIO_SET_STREAM_CONFIG: {
struct msm_audio_stream_config cfg;
if (copy_from_user(&cfg, (void *) arg, sizeof(cfg))) {
rc = -EFAULT;
break;
}
/* Allow only single frame */
if (cfg.buffer_size != (FRAME_SIZE - 8))
rc = -EINVAL;
else
audio->buffer_size = cfg.buffer_size;
break;
}
case AUDIO_GET_STREAM_CONFIG: {
struct msm_audio_stream_config cfg;
memset(&cfg, 0, sizeof(cfg));
cfg.buffer_size = audio->buffer_size;
cfg.buffer_count = FRAME_NUM;
if (copy_to_user((void *) arg, &cfg, sizeof(cfg)))
rc = -EFAULT;
break;
}
case AUDIO_GET_QCELP_ENC_CONFIG: {
if (copy_to_user((void *) arg, &audio->cfg, sizeof(audio->cfg)))
rc = -EFAULT;
break;
}
case AUDIO_SET_QCELP_ENC_CONFIG: {
struct msm_audio_qcelp_enc_config cfg;
if (copy_from_user(&cfg, (void *) arg, sizeof(cfg))) {
rc = -EFAULT;
break;
}
MM_DBG("0X%8x, 0x%8x, 0x%8x\n", cfg.min_bit_rate, \
cfg.max_bit_rate, cfg.cdma_rate);
if (cfg.min_bit_rate > CDMA_RATE_FULL || \
cfg.min_bit_rate < CDMA_RATE_EIGHTH) {
MM_ERR("invalid min bitrate\n");
rc = -EFAULT;
break;
}
if (cfg.max_bit_rate > CDMA_RATE_FULL || \
cfg.max_bit_rate < CDMA_RATE_EIGHTH) {
MM_ERR("invalid max bitrate\n");
rc = -EFAULT;
break;
}
/* Recording Does not support Erase and Blank */
if (cfg.cdma_rate > CDMA_RATE_FULL ||
cfg.cdma_rate < CDMA_RATE_EIGHTH) {
MM_ERR("invalid qcelp cdma rate\n");
rc = -EFAULT;
break;
}
memcpy(&audio->cfg, &cfg, sizeof(cfg));
break;
}
case AUDIO_SET_INCALL: {
struct msm_voicerec_mode cfg;
unsigned long flags;
if (copy_from_user(&cfg, (void *) arg, sizeof(cfg))) {
rc = -EFAULT;
break;
}
if (cfg.rec_mode != VOC_REC_BOTH &&
cfg.rec_mode != VOC_REC_UPLINK &&
cfg.rec_mode != VOC_REC_DOWNLINK) {
MM_ERR("invalid rec_mode\n");
rc = -EINVAL;
break;
} else {
spin_lock_irqsave(&audio->dev_lock, flags);
if (cfg.rec_mode == VOC_REC_UPLINK)
audio->source = VOICE_UL_SOURCE_MIX_MASK;
else if (cfg.rec_mode == VOC_REC_DOWNLINK)
audio->source = VOICE_DL_SOURCE_MIX_MASK;
else
audio->source = VOICE_DL_SOURCE_MIX_MASK |
VOICE_UL_SOURCE_MIX_MASK ;
audio->in_call = 1;
spin_unlock_irqrestore(&audio->dev_lock, flags);
}
break;
}
case AUDIO_GET_SESSION_ID: {
if (copy_to_user((void *) arg, &audio->enc_id,
sizeof(unsigned short))) {
rc = -EFAULT;
}
break;
}
default:
rc = -EINVAL;
}
mutex_unlock(&audio->lock);
return rc;
}
/*****************************************************************************
* btwaln_em_ioctl
*****************************************************************************/
static int btwlan_em_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
BTWLAN_EM_DEBUG("btwlan_em_ioctl ++\n");
if(!pbtwlan_em)
{
BTWLAN_EM_ALERT("btwlan_em_ioctl failed get valid struct\n");
return -EFAULT;
}
switch(cmd)
{
case BTWLAN_EM_IOCTL_SET_BTPWR:
{
unsigned long btpwr = 0;
if (copy_from_user(&btpwr, (void*)arg, sizeof(unsigned long)))
return -EFAULT;
BTWLAN_EM_DEBUG("BTWLAN_EM_IOCTL_SET_BTPWR:%d\n", (int)btpwr);
mutex_lock(&pbtwlan_em->sem);
if (btpwr){
mt_bt_power_on();
}
else{
mt_bt_power_off();
}
mutex_unlock(&pbtwlan_em->sem);
break;
}
case BTWLAN_EM_IOCTL_SET_WIFIPWR:
{
unsigned long wifipwr = 0;
if (copy_from_user(&wifipwr, (void*)arg, sizeof(unsigned long)))
return -EFAULT;
BTWLAN_EM_DEBUG("BTWLAN_EM_IOCTL_SET_WIFIPWR:%d\n", (int)wifipwr);
mutex_lock(&pbtwlan_em->sem);
if (wifipwr){
mt_wifi_power_on();
}
else{
mt_wifi_power_off();
}
mutex_unlock(&pbtwlan_em->sem);
break;
}
case BT_IOCTL_SET_EINT:
{
unsigned long bt_eint = 0;
if (copy_from_user(&bt_eint, (void*)arg, sizeof(unsigned long)))
return -EFAULT;
BTWLAN_EM_DEBUG("BT_IOCTL_SET_EINT:%d\n", bt_eint);
mutex_lock(&pbtwlan_em->sem);
if (bt_eint){
mt65xx_eint_unmask(CUST_EINT_BT_NUM);
BTWLAN_EM_DEBUG("Set enable BT EINT\n");
}
else{
mt65xx_eint_mask(CUST_EINT_BT_NUM);
BTWLAN_EM_DEBUG("Set disable BT EINT\n");
eint_mask = 1;
wake_up_interruptible(&eint_wait);
}
mutex_unlock(&pbtwlan_em->sem);
break;
}
default:
BTWLAN_EM_ALERT("btwlan_em_ioctl not support\n");
return -EPERM;
}
BTWLAN_EM_DEBUG("btwlan_em_ioctl --\n");
return 0;
}
/* --------------------------------------------------------------------------
* ioctl: let user programs configure this interface
*/
int vni_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
{
int err;
struct net_device *slave;
struct vni_private *priv = netdev_priv(dev);
/* hold a local (kernel-space) copy of the configuration data */
struct vni_userinfo info;
/* and a pointer into user space as well */
struct vni_userinfo *uptr = (struct vni_userinfo *)ifr->ifr_data;
/* only authorized users can control the interface */
if (cmd == SIOCINSANESETINFO && !capable(CAP_NET_ADMIN))
return -EPERM;
/* process the command */
switch(cmd) {
case SIOCINSANEGETINFO: /* return configuration to user space */
/* interface name */
memset(info.name, 0, VNI_NAMELEN);
if (priv->priv_device)
strncpy(info.name, priv->priv_device->name, VNI_NAMELEN-1);
/* parameters */
info.mode = priv->priv_mode;
/* return the data structure to user space */
err = copy_to_user(uptr, &info, sizeof(info));
if (err) return err;
break;
case SIOCINSANESETINFO:
/* retrieve the data structure from user space */
err = copy_from_user(&info, uptr, sizeof(info));
if (err) return err;
printk("name: %s", info.name);
/* interface name */
slave = __dev_get_by_name(&init_net, info.name);
if (!slave)
return -ENODEV;
if (slave->type != ARPHRD_ETHER && slave->type != ARPHRD_LOOPBACK)
return -EINVAL;
/* The interface is good, get hold of it */
priv->priv_device = slave;
if (slave->header_ops)
dev->header_ops = &vni_header_ops;
else
dev->header_ops = NULL;
/* also, and clone its IP, MAC and other information */
memcpy(dev->dev_addr, slave->dev_addr, sizeof(slave->dev_addr));
memcpy(dev->broadcast, slave->broadcast, sizeof(slave->broadcast));
/* accept the parameters (no checks here) */
priv->priv_mode = info.mode;
break;
default:
return -EOPNOTSUPP;
}
return 0;
}
/* FIXME: add request firmware ioctl */
static long mfc_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
struct mfc_inst_ctx *mfc_ctx;
int ret, ex_ret;
struct mfc_common_args in_param;
struct mfc_buf_alloc_arg buf_arg;
int port;
struct mfc_dev *dev;
int i;
struct mfc_set_config_arg *set_cnf_arg;
mfc_ctx = (struct mfc_inst_ctx *)file->private_data;
if (!mfc_ctx)
return -EINVAL;
dev = mfc_ctx->dev;
mutex_lock(&dev->lock);
ret = copy_from_user(&in_param, (struct mfc_common_args *)arg,
sizeof(struct mfc_common_args));
if (ret < 0) {
mfc_err("failed to copy parameters\n");
ret = -EIO;
in_param.ret_code = MFC_INVALID_PARAM_FAIL;
goto out_ioctl;
}
mutex_unlock(&dev->lock);
/* FIXME: add locking */
mfc_dbg("cmd: 0x%08x\n", cmd);
switch (cmd) {
case IOCTL_MFC_DEC_INIT:
mutex_lock(&dev->lock);
if (mfc_chk_inst_state(mfc_ctx, INST_STATE_CREATE) < 0) {
mfc_err("IOCTL_MFC_DEC_INIT invalid state: 0x%08x\n",
mfc_ctx->state);
in_param.ret_code = MFC_STATE_INVALID;
ret = -EINVAL;
break;
}
mfc_clock_on();
in_param.ret_code = mfc_init_decoding(mfc_ctx, &(in_param.args));
ret = in_param.ret_code;
mfc_clock_off();
mutex_unlock(&dev->lock);
break;
case IOCTL_MFC_ENC_INIT:
mutex_lock(&dev->lock);
if (mfc_chk_inst_state(mfc_ctx, INST_STATE_CREATE) < 0) {
mfc_err("IOCTL_MFC_ENC_INIT invalid state: 0x%08x\n",
mfc_ctx->state);
in_param.ret_code = MFC_STATE_INVALID;
ret = -EINVAL;
break;
}
mfc_clock_on();
in_param.ret_code = mfc_init_encoding(mfc_ctx, &(in_param.args));
ret = in_param.ret_code;
mfc_clock_off();
mutex_unlock(&dev->lock);
break;
case IOCTL_MFC_DEC_EXE:
mutex_lock(&dev->lock);
mfc_clock_on();
in_param.ret_code = mfc_exec_decoding(mfc_ctx, &(in_param.args));
ret = in_param.ret_code;
mfc_clock_off();
mutex_unlock(&dev->lock);
break;
case IOCTL_MFC_ENC_EXE:
mutex_lock(&dev->lock);
mfc_clock_on();
in_param.ret_code = mfc_exec_encoding(mfc_ctx, &(in_param.args));
ret = in_param.ret_code;
mfc_clock_off();
mutex_unlock(&dev->lock);
break;
case IOCTL_MFC_GET_IN_BUF:
if (in_param.args.mem_alloc.type == ENCODER) {
buf_arg.type = ENCODER;
port = 1;
} else {
buf_arg.type = DECODER;
port = 0;
}
/* FIXME: consider the size */
buf_arg.size = in_param.args.mem_alloc.buff_size;
/*
buf_arg.mapped = in_param.args.mem_alloc.mapped_addr;
*/
/* FIXME: encodeing linear: 2KB, tile: 8KB */
buf_arg.align = ALIGN_2KB;
if (buf_arg.type == ENCODER)
in_param.ret_code = mfc_alloc_buf(mfc_ctx, &buf_arg, MBT_DPB | port);
else
in_param.ret_code = mfc_alloc_buf(mfc_ctx, &buf_arg, MBT_CPB | port);
#if defined(CONFIG_VIDEO_MFC_VCM_UMP)
in_param.args.mem_alloc.secure_id = buf_arg.secure_id;
#elif defined(CONFIG_S5P_VMEM)
in_param.args.mem_alloc.cookie = buf_arg.cookie;
#else
in_param.args.mem_alloc.offset = buf_arg.offset;
#endif
ret = in_param.ret_code;
break;
case IOCTL_MFC_FREE_BUF:
in_param.ret_code =
mfc_free_buf(mfc_ctx, in_param.args.mem_free.key);
ret = in_param.ret_code;
break;
case IOCTL_MFC_GET_REAL_ADDR:
in_param.args.real_addr.addr =
mfc_get_buf_real(mfc_ctx->id, in_param.args.real_addr.key);
mfc_dbg("real addr: 0x%08x", in_param.args.real_addr.addr);
if (in_param.args.real_addr.addr)
in_param.ret_code = MFC_OK;
else
in_param.ret_code = MFC_MEM_INVALID_ADDR_FAIL;
ret = in_param.ret_code;
break;
case IOCTL_MFC_GET_MMAP_SIZE:
if (mfc_chk_inst_state(mfc_ctx, INST_STATE_CREATE) < 0) {
mfc_err("IOCTL_MFC_GET_MMAP_SIZE invalid state: \
0x%08x\n", mfc_ctx->state);
in_param.ret_code = MFC_STATE_INVALID;
ret = -EINVAL;
break;
}
in_param.ret_code = MFC_OK;
ret = 0;
for (i = 0; i < dev->mem_ports; i++)
ret += mfc_mem_data_size(i);
break;
#if defined(CONFIG_VIDEO_MFC_VCM_UMP)
case IOCTL_MFC_SET_IN_BUF:
if (in_param.args.mem_alloc.type == ENCODER) {
buf_arg.secure_id = in_param.args.mem_alloc.secure_id;
buf_arg.align = ALIGN_2KB;
port = 1;
ret = mfc_vcm_bind_from_others(mfc_ctx, &buf_arg, MBT_OTHER | port);
}
else {
in_param.args.real_addr.addr =
mfc_ump_get_virt(in_param.args.real_addr.key);
mfc_dbg("real addr: 0x%08x", in_param.args.real_addr.addr);
if (in_param.args.real_addr.addr)
in_param.ret_code = MFC_OK;
else
in_param.ret_code = MFC_MEM_INVALID_ADDR_FAIL;
ret = in_param.ret_code;
}
break;
#endif
case IOCTL_MFC_SET_CONFIG:
/* FIXME: mfc_chk_inst_state*/
/* RMVME: need locking ? */
mutex_lock(&dev->lock);
/* in_param.ret_code = mfc_set_config(mfc_ctx, &(in_param.args)); */
set_cnf_arg = (struct mfc_set_config_arg *)&in_param.args;
in_param.ret_code = mfc_set_inst_cfg(mfc_ctx, set_cnf_arg->in_config_param, set_cnf_arg->in_config_value);
ret = in_param.ret_code;
mutex_unlock(&dev->lock);
break;
case IOCTL_MFC_GET_CONFIG:
/* FIXME: */
/* FIXME: mfc_chk_inst_state */
/* RMVME: need locking ? */
in_param.ret_code = MFC_OK;
ret = MFC_OK;
break;
case IOCTL_MFC_SET_BUF_CACHE:
mfc_ctx->buf_cache_type = in_param.args.mem_alloc.buf_cache_type;
in_param.ret_code = MFC_OK;
break;
default:
mfc_err("failed to execute ioctl cmd: 0x%08x\n", cmd);
in_param.ret_code = MFC_INVALID_PARAM_FAIL;
ret = -EINVAL;
}
static long acdb_ioctl(struct file *f,
unsigned int cmd, unsigned long arg)
{
int32_t result = 0;
int32_t size;
int32_t map_fd;
uint32_t topology;
uint32_t data[MAX_IOCTL_DATA];
struct msm_spk_prot_status prot_status;
struct msm_spk_prot_status acdb_spk_status;
pr_debug("%s\n", __func__);
mutex_lock(&acdb_data.acdb_mutex);
switch (cmd) {
case AUDIO_REGISTER_PMEM:
pr_debug("AUDIO_REGISTER_PMEM\n");
result = deregister_memory();
if (result < 0)
pr_err("%s: deregister_memory failed returned %d!\n",
__func__, result);
if (copy_from_user(&map_fd, (void *)arg, sizeof(map_fd))) {
pr_err("%s: fail to copy memory handle!\n", __func__);
result = -EFAULT;
} else {
acdb_data.map_handle = map_fd;
result = register_memory();
}
goto done;
case AUDIO_DEREGISTER_PMEM:
pr_debug("AUDIO_DEREGISTER_PMEM\n");
result = deregister_memory();
goto done;
case AUDIO_SET_VOICE_RX_TOPOLOGY:
if (copy_from_user(&topology, (void *)arg,
sizeof(topology))) {
pr_err("%s: fail to copy topology!\n", __func__);
result = -EFAULT;
}
store_voice_rx_topology(topology);
goto done;
case AUDIO_SET_VOICE_TX_TOPOLOGY:
if (copy_from_user(&topology, (void *)arg,
sizeof(topology))) {
pr_err("%s: fail to copy topology!\n", __func__);
result = -EFAULT;
}
store_voice_tx_topology(topology);
goto done;
case AUDIO_SET_ADM_RX_TOPOLOGY:
if (copy_from_user(&topology, (void *)arg,
sizeof(topology))) {
pr_err("%s: fail to copy topology!\n", __func__);
result = -EFAULT;
}
store_adm_rx_topology(topology);
goto done;
case AUDIO_SET_ADM_TX_TOPOLOGY:
if (copy_from_user(&topology, (void *)arg,
sizeof(topology))) {
pr_err("%s: fail to copy topology!\n", __func__);
result = -EFAULT;
}
store_adm_tx_topology(topology);
goto done;
case AUDIO_SET_ASM_TOPOLOGY:
if (copy_from_user(&topology, (void *)arg,
sizeof(topology))) {
pr_err("%s: fail to copy topology!\n", __func__);
result = -EFAULT;
}
store_asm_topology(topology);
goto done;
case AUDIO_SET_SPEAKER_PROT:
if (copy_from_user(&acdb_data.spk_prot_cfg, (void *)arg,
sizeof(acdb_data.spk_prot_cfg))) {
pr_err("%s fail to copy spk_prot_cfg\n", __func__);
result = -EFAULT;
}
goto done;
case AUDIO_GET_SPEAKER_PROT:
/*Indicates calibration was succesfull*/
if (acdb_data.spk_prot_cfg.mode == MSM_SPKR_PROT_CALIBRATED) {
prot_status.r0 = acdb_data.spk_prot_cfg.r0;
prot_status.status = 0;
} else if (acdb_data.spk_prot_cfg.mode ==
MSM_SPKR_PROT_CALIBRATION_IN_PROGRESS) {
/*Call AFE to query the status*/
acdb_spk_status.status = -EINVAL;
acdb_spk_status.r0 = -1;
get_spk_protection_status(&acdb_spk_status);
prot_status.r0 = acdb_spk_status.r0;
prot_status.status = acdb_spk_status.status;
if (!acdb_spk_status.status) {
acdb_data.spk_prot_cfg.mode =
MSM_SPKR_PROT_CALIBRATED;
acdb_data.spk_prot_cfg.r0 = prot_status.r0;
}
} else {
/*Indicates calibration data is invalid*/
prot_status.status = -EINVAL;
prot_status.r0 = -1;
}
if (copy_to_user((void *)arg, &prot_status,
sizeof(prot_status))) {
pr_err("%s: Failed to update prot_status\n", __func__);
}
goto done;
case AUDIO_REGISTER_VOCPROC_VOL_TABLE:
result = register_vocvol_table();
goto done;
case AUDIO_DEREGISTER_VOCPROC_VOL_TABLE:
result = deregister_vocvol_table();
goto done;
case AUDIO_SET_HW_DELAY_RX:
result = store_hw_delay(RX_CAL, (void *)arg);
goto done;
case AUDIO_SET_HW_DELAY_TX:
result = store_hw_delay(TX_CAL, (void *)arg);
goto done;
case AUDIO_SET_META_INFO:
result = store_meta_info((void *)arg);
goto done;
}
if (copy_from_user(&size, (void *) arg, sizeof(size))) {
result = -EFAULT;
goto done;
}
if ((size <= 0) || (size > sizeof(data))) {
pr_err("%s: Invalid size sent to driver: %d\n",
__func__, size);
result = -EFAULT;
goto done;
}
switch (cmd) {
case AUDIO_SET_VOCPROC_COL_CAL:
result = store_voice_col_data(VOCPROC_CAL,
size, (uint32_t *)arg);
goto done;
case AUDIO_SET_VOCSTRM_COL_CAL:
result = store_voice_col_data(VOCSTRM_CAL,
size, (uint32_t *)arg);
goto done;
case AUDIO_SET_VOCVOL_COL_CAL:
result = store_voice_col_data(VOCVOL_CAL,
size, (uint32_t *)arg);
goto done;
}
if (copy_from_user(data, (void *)(arg + sizeof(size)), size)) {
pr_err("%s: fail to copy table size %d\n", __func__, size);
result = -EFAULT;
goto done;
}
if (data == NULL) {
pr_err("%s: NULL pointer sent to driver!\n", __func__);
result = -EFAULT;
goto done;
}
if (size > sizeof(struct cal_block))
pr_err("%s: More cal data for ioctl 0x%x then expected, size received: %d\n",
__func__, cmd, size);
switch (cmd) {
case AUDIO_SET_AUDPROC_TX_CAL:
result = store_audproc_cal(TX_CAL, (struct cal_block *)data);
goto done;
case AUDIO_SET_AUDPROC_RX_CAL:
result = store_audproc_cal(RX_CAL, (struct cal_block *)data);
goto done;
case AUDIO_SET_AUDPROC_TX_STREAM_CAL:
result = store_audstrm_cal(TX_CAL, (struct cal_block *)data);
goto done;
case AUDIO_SET_AUDPROC_RX_STREAM_CAL:
result = store_audstrm_cal(RX_CAL, (struct cal_block *)data);
goto done;
case AUDIO_SET_AUDPROC_TX_VOL_CAL:
result = store_audvol_cal(TX_CAL, (struct cal_block *)data);
goto done;
case AUDIO_SET_AUDPROC_RX_VOL_CAL:
result = store_audvol_cal(RX_CAL, (struct cal_block *)data);
goto done;
case AUDIO_SET_AFE_TX_CAL:
result = store_afe_cal(TX_CAL, (struct cal_block *)data);
goto done;
case AUDIO_SET_AFE_RX_CAL:
result = store_afe_cal(RX_CAL, (struct cal_block *)data);
goto done;
case AUDIO_SET_VOCPROC_CAL:
result = store_vocproc_cal((struct cal_block *)data);
goto done;
case AUDIO_SET_VOCPROC_STREAM_CAL:
result = store_vocstrm_cal((struct cal_block *)data);
goto done;
case AUDIO_SET_VOCPROC_VOL_CAL:
result = store_vocvol_cal((struct cal_block *)data);
goto done;
case AUDIO_SET_VOCPROC_DEV_CFG_CAL:
result = store_vocproc_dev_cfg_cal((struct cal_block *)data);
goto done;
case AUDIO_SET_SIDETONE_CAL:
store_sidetone_cal((struct sidetone_cal *)data);
goto done;
case AUDIO_SET_ANC_CAL:
result = store_anc_cal((struct cal_block *)data);
goto done;
case AUDIO_SET_LSM_CAL:
result = store_lsm_cal((struct cal_block *)data);
goto done;
case AUDIO_SET_ADM_CUSTOM_TOPOLOGY:
result = store_adm_custom_topology((struct cal_block *)data);
goto done;
case AUDIO_SET_ASM_CUSTOM_TOPOLOGY:
result = store_asm_custom_topology((struct cal_block *)data);
goto done;
case AUDIO_SET_AANC_CAL:
result = store_aanc_cal((struct cal_block *)data);
goto done;
case AUDIO_LISTEN_SET_ULP_LSM_CAL:
result = store_ulp_lsm_cal((struct cal_block *) data);
goto done;
case AUDIO_LISTEN_SET_ULP_AFE_CAL:
result = store_ulp_afe_cal((struct cal_block *) data);
goto done;
default:
pr_err("ACDB=> ACDB ioctl not found!\n");
result = -EFAULT;
goto done;
}
done:
mutex_unlock(&acdb_data.acdb_mutex);
return result;
}
static int s3cfb_ioctl(struct fb_info *fb, unsigned int cmd, unsigned long arg)
{
struct s3cfb_global *fbdev =
platform_get_drvdata(to_platform_device(fb->device));
struct fb_var_screeninfo *var = &fb->var;
struct s3cfb_window *win = fb->par;
struct s3cfb_lcd *lcd = fbdev->lcd;
struct fb_fix_screeninfo *fix = &fb->fix;
struct s3cfb_next_info next_fb_info;
int ret = 0;
union {
struct s3cfb_user_window user_window;
struct s3cfb_user_plane_alpha user_alpha;
struct s3cfb_user_chroma user_chroma;
int vsync;
} p;
switch (cmd) {
case FBIO_WAITFORVSYNC:
s3cfb_wait_for_vsync(fbdev);
break;
case S3CFB_WIN_POSITION:
if (copy_from_user(&p.user_window,
(struct s3cfb_user_window __user *)arg,
sizeof(p.user_window)))
ret = -EFAULT;
else {
if (p.user_window.x < 0)
p.user_window.x = 0;
if (p.user_window.y < 0)
p.user_window.y = 0;
if (p.user_window.x + var->xres > lcd->width)
win->x = lcd->width - var->xres;
else
win->x = p.user_window.x;
if (p.user_window.y + var->yres > lcd->height)
win->y = lcd->height - var->yres;
else
win->y = p.user_window.y;
s3cfb_set_window_position(fbdev, win->id);
}
break;
case S3CFB_WIN_SET_PLANE_ALPHA:
if (copy_from_user(&p.user_alpha,
(struct s3cfb_user_plane_alpha __user *)arg,
sizeof(p.user_alpha)))
ret = -EFAULT;
else {
win->alpha.mode = PLANE_BLENDING;
win->alpha.channel = p.user_alpha.channel;
win->alpha.value =
S3CFB_AVALUE(p.user_alpha.red,
p.user_alpha.green, p.user_alpha.blue);
s3cfb_set_alpha_blending(fbdev, win->id);
}
break;
case S3CFB_WIN_SET_CHROMA:
if (copy_from_user(&p.user_chroma,
(struct s3cfb_user_chroma __user *)arg,
sizeof(p.user_chroma)))
ret = -EFAULT;
else {
win->chroma.enabled = p.user_chroma.enabled;
win->chroma.key = S3CFB_CHROMA(p.user_chroma.red,
p.user_chroma.green,
p.user_chroma.blue);
s3cfb_set_chroma_key(fbdev, win->id);
}
break;
case S3CFB_SET_VSYNC_INT:
if (get_user(p.vsync, (int __user *)arg))
ret = -EFAULT;
else {
if (p.vsync)
s3cfb_set_global_interrupt(fbdev, 1);
s3cfb_set_vsync_interrupt(fbdev, p.vsync);
}
break;
case S3CFB_GET_CURR_FB_INFO:
next_fb_info.phy_start_addr = fix->smem_start;
next_fb_info.xres = var->xres;
next_fb_info.yres = var->yres;
next_fb_info.xres_virtual = var->xres_virtual;
next_fb_info.yres_virtual = var->yres_virtual;
next_fb_info.xoffset = var->xoffset;
next_fb_info.yoffset = var->yoffset;
next_fb_info.lcd_offset_x = 0;
next_fb_info.lcd_offset_y = 0;
if (copy_to_user((void *)arg,
(struct s3cfb_next_info *) &next_fb_info,
sizeof(struct s3cfb_next_info)))
return -EFAULT;
break;
}
return ret;
}
int ralink_nvram_ioctl(struct inode *inode, struct file *file, unsigned int req,
unsigned long arg)
#endif
{
int index, len;
const char *p;
nvram_ioctl_t *nvr;
char *value;
switch (req) {
case RALINK_NVRAM_IOCTL_GET:
nvr = (nvram_ioctl_t __user *)arg;
p = nvram_get(nvr->index, nvr->name);
if (p == NULL)
p = "";
len = strlen(p) + 1;
if (nvr->size < len) {
nvr->size = len;
return -EOVERFLOW;
}
if (copy_to_user(nvr->value, p, strlen(p) + 1))
return -EFAULT;
break;
case RALINK_NVRAM_IOCTL_GETALL:
nvr = (nvram_ioctl_t __user *)arg;
index = nvr->index;
len = fb[index].flash_max_len - sizeof(fb[index].env.crc);
if (nvram_getall(index, fb[index].env.data) == 0) {
if (copy_to_user(nvr->value, fb[index].env.data, len))
return -EFAULT;
}
break;
case RALINK_NVRAM_IOCTL_SET:
nvr = (nvram_ioctl_t *)arg;
len = ((nvr->size + MAX_VALUE_LEN) / MAX_VALUE_LEN) * MAX_VALUE_LEN; // Align size+1 bytes to MAX_VALUE_LEN boundary
if ((len > MAX_PERMITTED_VALUE_LEN) || (len < 0))
return -EOVERFLOW;
value = (char *)kzalloc(len, GFP_KERNEL);
if (!value)
return -ENOMEM;
if (copy_from_user(value, nvr->value, nvr->size)) {
KFREE(value);
return -EFAULT;
}
nvram_set(nvr->index, nvr->name, value);
KFREE(value);
break;
case RALINK_NVRAM_IOCTL_COMMIT:
nvr = (nvram_ioctl_t __user *)arg;
nvram_commit(nvr->index);
break;
case RALINK_NVRAM_IOCTL_CLEAR:
nvr = (nvram_ioctl_t __user *)arg;
nvram_clear(nvr->index);
default:
break;
}
return 0;
}
int32_t msm_sensor_config(struct msm_sensor_ctrl_t *s_ctrl, void __user *argp)
{
struct sensor_cfg_data cdata;
long rc = 0;
if (copy_from_user(&cdata,
(void *)argp,
sizeof(struct sensor_cfg_data)))
return -EFAULT;
mutex_lock(s_ctrl->msm_sensor_mutex);
printk("msm_sensor_config: cfgtype = %d\n", /* */
cdata.cfgtype);
switch (cdata.cfgtype) {
case CFG_SET_FPS:
case CFG_SET_PICT_FPS:
if (s_ctrl->func_tbl->
sensor_set_fps == NULL) {
rc = -EFAULT;
break;
}
rc = s_ctrl->func_tbl->
sensor_set_fps(
s_ctrl,
&(cdata.cfg.fps));
break;
case CFG_SET_EXP_GAIN:
if (s_ctrl->func_tbl->
sensor_write_exp_gain == NULL) {
rc = -EFAULT;
break;
}
rc =
s_ctrl->func_tbl->
sensor_write_exp_gain(
s_ctrl,
cdata.cfg.exp_gain.gain,
cdata.cfg.exp_gain.line);
s_ctrl->prev_gain = cdata.cfg.exp_gain.gain;
s_ctrl->prev_line = cdata.cfg.exp_gain.line;
break;
case CFG_SET_PICT_EXP_GAIN:
if (s_ctrl->func_tbl->
sensor_write_snapshot_exp_gain == NULL) {
rc = -EFAULT;
break;
}
rc =
s_ctrl->func_tbl->
sensor_write_snapshot_exp_gain(
s_ctrl,
cdata.cfg.exp_gain.gain,
cdata.cfg.exp_gain.line);
break;
case CFG_SET_MODE:
if (s_ctrl->func_tbl->
sensor_set_sensor_mode == NULL) {
rc = -EFAULT;
break;
}
rc = s_ctrl->func_tbl->
sensor_set_sensor_mode(
s_ctrl,
cdata.mode,
cdata.rs);
break;
//
// for YUV sensor[JB]
#ifdef CONFIG_MACH_LGE
case CFG_SET_WB:
rc = s_ctrl->func_tbl->
sensor_set_wb(
s_ctrl,
cdata.cfg.wb_val);
break;
case CFG_SET_EFFECT:
rc = s_ctrl->func_tbl->
sensor_set_effect(
s_ctrl,
cdata.cfg.effect);
break;
case CFG_SET_BRIGHTNESS:
rc = s_ctrl->func_tbl->
sensor_set_brightness(
s_ctrl,
cdata.cfg.brightness);
break;
case CFG_SET_SOC_FPS:
rc = s_ctrl->func_tbl->
sensor_set_soc_minmax_fps(
s_ctrl,
cdata.cfg.fps_range.minfps,
cdata.cfg.fps_range.maxfps);
break;
#else
case CFG_SET_EFFECT:
break;
#endif
//
case CFG_SENSOR_INIT:
if (s_ctrl->func_tbl->
sensor_mode_init == NULL) {
rc = -EFAULT;
break;
}
rc = s_ctrl->func_tbl->
sensor_mode_init(
s_ctrl,
cdata.mode,
&(cdata.cfg.init_info));
break;
case CFG_GET_OUTPUT_INFO:
if (s_ctrl->func_tbl->
sensor_get_output_info == NULL) {
rc = -EFAULT;
break;
}
rc = s_ctrl->func_tbl->
sensor_get_output_info(
s_ctrl,
&cdata.cfg.output_info);
if (copy_to_user((void *)argp,
&cdata,
sizeof(struct sensor_cfg_data)))
rc = -EFAULT;
break;
//Start :[email protected] for calibration 2012.03.25
case CFG_GET_CALIB_DATA:
if (s_ctrl->func_tbl->sensor_get_eeprom_data
== NULL) {
rc = -EFAULT;
break;
}
rc = s_ctrl->func_tbl->sensor_get_eeprom_data(
s_ctrl,
&cdata);
if (copy_to_user((void *)argp,
&cdata,
sizeof(cdata)))
rc = -EFAULT;
break;
//End :[email protected] for calibration 2012.03.25
case CFG_START_STREAM:
if (s_ctrl->func_tbl->sensor_start_stream == NULL) {
rc = -EFAULT;
break;
}
s_ctrl->func_tbl->sensor_start_stream(s_ctrl);
break;
case CFG_STOP_STREAM:
if (s_ctrl->func_tbl->sensor_stop_stream == NULL) {
rc = -EFAULT;
break;
}
s_ctrl->func_tbl->sensor_stop_stream(s_ctrl);
break;
case CFG_GET_CSI_PARAMS:
if (s_ctrl->func_tbl->sensor_get_csi_params == NULL) {
rc = -EFAULT;
break;
}
rc = s_ctrl->func_tbl->sensor_get_csi_params(
s_ctrl,
&cdata.cfg.csi_lane_params);
if (copy_to_user((void *)argp,
&cdata,
sizeof(struct sensor_cfg_data)))
rc = -EFAULT;
break;
default:
rc = -EFAULT;
break;
}
mutex_unlock(s_ctrl->msm_sensor_mutex);
return rc;
}
int wpa_set_keys(PSDevice pDevice, void *ctx, BOOL fcpfkernel)
{
struct viawget_wpa_param *param=ctx;
PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
DWORD dwKeyIndex = 0;
BYTE abyKey[MAX_KEY_LEN];
BYTE abySeq[MAX_KEY_LEN];
QWORD KeyRSC;
// NDIS_802_11_KEY_RSC KeyRSC;
BYTE byKeyDecMode = KEY_CTL_WEP;
int ret = 0;
int uu, ii;
if (param->u.wpa_key.alg_name > WPA_ALG_CCMP)
return -EINVAL;
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "param->u.wpa_key.alg_name = %d \n", param->u.wpa_key.alg_name);
if (param->u.wpa_key.alg_name == WPA_ALG_NONE) {
pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
pDevice->bEncryptionEnable = FALSE;
pDevice->byKeyIndex = 0;
pDevice->bTransmitKey = FALSE;
for (uu=0; uu<MAX_KEY_TABLE; uu++) {
MACvDisableKeyEntry(pDevice, uu);
}
return ret;
}
spin_unlock_irq(&pDevice->lock);
if(param->u.wpa_key.key && fcpfkernel) {
memcpy(&abyKey[0], param->u.wpa_key.key, param->u.wpa_key.key_len);
}
else {
if (param->u.wpa_key.key &&
copy_from_user(&abyKey[0], param->u.wpa_key.key, param->u.wpa_key.key_len)) {
spin_lock_irq(&pDevice->lock);
return -EINVAL;
}
}
spin_lock_irq(&pDevice->lock);
dwKeyIndex = (DWORD)(param->u.wpa_key.key_index);
if (param->u.wpa_key.alg_name == WPA_ALG_WEP) {
if (dwKeyIndex > 3) {
return -EINVAL;
}
else {
if (param->u.wpa_key.set_tx) {
pDevice->byKeyIndex = (BYTE)dwKeyIndex;
pDevice->bTransmitKey = TRUE;
dwKeyIndex |= (1 << 31);
}
KeybSetDefaultKey( pDevice,
&(pDevice->sKey),
dwKeyIndex & ~(BIT30 | USE_KEYRSC),
param->u.wpa_key.key_len,
NULL,
abyKey,
KEY_CTL_WEP
);
}
pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled;
pDevice->bEncryptionEnable = TRUE;
return ret;
}
spin_unlock_irq(&pDevice->lock);
if(param->u.wpa_key.seq && fcpfkernel) {
memcpy(&abySeq[0], param->u.wpa_key.seq, param->u.wpa_key.seq_len);
}
else {
if (param->u.wpa_key.seq &&
copy_from_user(&abySeq[0], param->u.wpa_key.seq, param->u.wpa_key.seq_len)) {
spin_lock_irq(&pDevice->lock);
return -EINVAL;
}
}
spin_lock_irq(&pDevice->lock);
if (param->u.wpa_key.seq_len > 0) {
for (ii = 0 ; ii < param->u.wpa_key.seq_len ; ii++) {
if (ii < 4)
LODWORD(KeyRSC) |= (abySeq[ii] << (ii * 8));
else
HIDWORD(KeyRSC) |= (abySeq[ii] << ((ii-4) * 8));
//KeyRSC |= (abySeq[ii] << (ii * 8));
}
dwKeyIndex |= 1 << 29;
}
if (param->u.wpa_key.key_index >= MAX_GROUP_KEY) {
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "return dwKeyIndex > 3\n");
return -EINVAL;
}
if (param->u.wpa_key.alg_name == WPA_ALG_TKIP) {
pDevice->eEncryptionStatus = Ndis802_11Encryption2Enabled;
}
if (param->u.wpa_key.alg_name == WPA_ALG_CCMP) {
pDevice->eEncryptionStatus = Ndis802_11Encryption3Enabled;
}
if (param->u.wpa_key.set_tx)
dwKeyIndex |= (1 << 31);
if (pDevice->eEncryptionStatus == Ndis802_11Encryption3Enabled)
byKeyDecMode = KEY_CTL_CCMP;
else if (pDevice->eEncryptionStatus == Ndis802_11Encryption2Enabled)
byKeyDecMode = KEY_CTL_TKIP;
else
byKeyDecMode = KEY_CTL_WEP;
// Fix HCT test that set 256 bits KEY and Ndis802_11Encryption3Enabled
if (pDevice->eEncryptionStatus == Ndis802_11Encryption3Enabled) {
if (param->u.wpa_key.key_len == MAX_KEY_LEN)
byKeyDecMode = KEY_CTL_TKIP;
else if (param->u.wpa_key.key_len == WLAN_WEP40_KEYLEN)
byKeyDecMode = KEY_CTL_WEP;
else if (param->u.wpa_key.key_len == WLAN_WEP104_KEYLEN)
byKeyDecMode = KEY_CTL_WEP;
} else if (pDevice->eEncryptionStatus == Ndis802_11Encryption2Enabled) {
if (param->u.wpa_key.key_len == WLAN_WEP40_KEYLEN)
byKeyDecMode = KEY_CTL_WEP;
else if (param->u.wpa_key.key_len == WLAN_WEP104_KEYLEN)
byKeyDecMode = KEY_CTL_WEP;
}
// Check TKIP key length
if ((byKeyDecMode == KEY_CTL_TKIP) &&
(param->u.wpa_key.key_len != MAX_KEY_LEN)) {
// TKIP Key must be 256 bits
//DBG_PRN_WLAN03(("return NDIS_STATUS_INVALID_DATA - TKIP Key must be 256 bits\n"));
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "return- TKIP Key must be 256 bits!\n");
return -EINVAL;
}
// Check AES key length
if ((byKeyDecMode == KEY_CTL_CCMP) &&
(param->u.wpa_key.key_len != AES_KEY_LEN)) {
// AES Key must be 128 bits
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "return - AES Key must be 128 bits\n");
return -EINVAL;
}
if (is_broadcast_ether_addr(¶m->addr[0]) || (param->addr == NULL)) {
/* if broadcast, set the key as every key entry's group key */
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Groupe Key Assign.\n");
if ((KeybSetAllGroupKey(pDevice,
&(pDevice->sKey),
dwKeyIndex,
param->u.wpa_key.key_len,
(PQWORD) &(KeyRSC),
(PBYTE)abyKey,
byKeyDecMode
) == TRUE) &&
(KeybSetDefaultKey(pDevice,
&(pDevice->sKey),
dwKeyIndex,
param->u.wpa_key.key_len,
(PQWORD) &(KeyRSC),
(PBYTE)abyKey,
byKeyDecMode
) == TRUE) ) {
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "GROUP Key Assign.\n");
} else {
//DBG_PRN_WLAN03(("return NDIS_STATUS_INVALID_DATA -KeybSetDefaultKey Fail.0\n"));
return -EINVAL;
}
} else {
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Pairwise Key Assign.\n");
// BSSID not 0xffffffffffff
// Pairwise Key can't be WEP
if (byKeyDecMode == KEY_CTL_WEP) {
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Pairwise Key can't be WEP\n");
return -EINVAL;
}
dwKeyIndex |= (1 << 30); // set pairwise key
if (pMgmt->eConfigMode == WMAC_CONFIG_IBSS_STA) {
//DBG_PRN_WLAN03(("return NDIS_STATUS_INVALID_DATA - WMAC_CONFIG_IBSS_STA\n"));
return -EINVAL;
}
if (KeybSetKey(pDevice,
&(pDevice->sKey),
¶m->addr[0],
dwKeyIndex,
param->u.wpa_key.key_len,
(PQWORD) &(KeyRSC),
(PBYTE)abyKey,
byKeyDecMode
) == TRUE) {
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Pairwise Key Set\n");
} else {
// Key Table Full
if (!compare_ether_addr(¶m->addr[0], pDevice->abyBSSID)) {
//DBG_PRN_WLAN03(("return NDIS_STATUS_INVALID_DATA -Key Table Full.2\n"));
return -EINVAL;
} else {
// Save Key and configure just before associate/reassociate to BSSID
// we do not implement now
return -EINVAL;
}
}
} // BSSID not 0xffffffffffff
if ((ret == 0) && ((param->u.wpa_key.set_tx) != 0)) {
pDevice->byKeyIndex = (BYTE)param->u.wpa_key.key_index;
pDevice->bTransmitKey = TRUE;
}
pDevice->bEncryptionEnable = TRUE;
/*
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " key=%x-%x-%x-%x-%x-xxxxx \n",
pMgmt->sNodeDBTable[iNodeIndex].abyWepKey[byKeyIndex][0],
pMgmt->sNodeDBTable[iNodeIndex].abyWepKey[byKeyIndex][1],
pMgmt->sNodeDBTable[iNodeIndex].abyWepKey[byKeyIndex][2],
pMgmt->sNodeDBTable[iNodeIndex].abyWepKey[byKeyIndex][3],
pMgmt->sNodeDBTable[iNodeIndex].abyWepKey[byKeyIndex][4]
);
*/
return ret;
}
static int gt91xx_config_write_proc(struct file *file, const char *buffer, unsigned long count, void *data)
{
s32 ret = 0;
char temp[16] = {0}; // for store special format cmd
char mode_str[8] = {0};
unsigned int mode;
u8 buf[1];
GTP_DEBUG("write count %ld", count);
if (count > GTP_CONFIG_MAX_LENGTH)
{
GTP_ERROR("size not match [%d:%ld]", GTP_CONFIG_MAX_LENGTH, count);
return -EFAULT;
}
/**********************************************/
/* for store special format cmd */
if (copy_from_user(temp, buffer, sizeof(temp)))
{
GTP_ERROR("copy from user fail 2");
return -EFAULT;
}
sscanf(temp, "%s %d", (char *)&mode_str, &mode);
if(strcmp(mode_str, "switch") == 0)
{
if(mode == 0)// turn off
tpd_off();
else if(mode == 1)//turn on
tpd_on();
else
GTP_ERROR("error mode :%d", mode);
return count;
}
//force clear config
if(strcmp(mode_str, "clear_config") == 0)
{
GTP_INFO("Force clear config");
buf[0] = 0x10;
ret = i2c_write_bytes(i2c_client_point, GTP_REG_SLEEP, buf, 1);
return count;
}
if (copy_from_user(&config[2], buffer, count))
{
GTP_ERROR("copy from user fail");
return -EFAULT;
}
/***********clk operate reseved****************/
/**********************************************/
ret = gtp_send_cfg(i2c_client_point);
abs_x_max = (config[RESOLUTION_LOC + 1] << 8) + config[RESOLUTION_LOC];
abs_y_max = (config[RESOLUTION_LOC + 3] << 8) + config[RESOLUTION_LOC + 2];
int_type = (config[TRIGGER_LOC]) & 0x03;
if (ret < 0)
{
GTP_ERROR("send config failed.");
}
return count;
}
int wpa_ioctl(PSDevice pDevice, struct iw_point *p)
{
struct viawget_wpa_param *param;
int ret = 0;
int wpa_ioctl = 0;
if (p->length < sizeof(struct viawget_wpa_param) ||
p->length > VIAWGET_WPA_MAX_BUF_SIZE || !p->pointer)
return -EINVAL;
param = kmalloc((int)p->length, (int)GFP_KERNEL);
if (param == NULL)
return -ENOMEM;
if (copy_from_user(param, p->pointer, p->length)) {
ret = -EFAULT;
goto out;
}
switch (param->cmd) {
case VIAWGET_SET_WPA:
ret = wpa_set_wpa(pDevice, param);
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "VIAWGET_SET_WPA \n");
break;
case VIAWGET_SET_KEY:
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "VIAWGET_SET_KEY \n");
spin_lock_irq(&pDevice->lock);
ret = wpa_set_keys(pDevice, param, FALSE);
spin_unlock_irq(&pDevice->lock);
break;
case VIAWGET_SET_SCAN:
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "VIAWGET_SET_SCAN \n");
ret = wpa_set_scan(pDevice, param);
break;
case VIAWGET_GET_SCAN:
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "VIAWGET_GET_SCAN\n");
ret = wpa_get_scan(pDevice, param);
wpa_ioctl = 1;
break;
case VIAWGET_GET_SSID:
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "VIAWGET_GET_SSID \n");
ret = wpa_get_ssid(pDevice, param);
wpa_ioctl = 1;
break;
case VIAWGET_GET_BSSID:
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "VIAWGET_GET_BSSID \n");
ret = wpa_get_bssid(pDevice, param);
wpa_ioctl = 1;
break;
case VIAWGET_SET_ASSOCIATE:
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "VIAWGET_SET_ASSOCIATE \n");
ret = wpa_set_associate(pDevice, param);
break;
case VIAWGET_SET_DISASSOCIATE:
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "VIAWGET_SET_DISASSOCIATE \n");
ret = wpa_set_disassociate(pDevice, param);
break;
case VIAWGET_SET_DROP_UNENCRYPT:
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "VIAWGET_SET_DROP_UNENCRYPT \n");
break;
case VIAWGET_SET_DEAUTHENTICATE:
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "VIAWGET_SET_DEAUTHENTICATE \n");
break;
default:
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "wpa_ioctl: unknown cmd=%d\n",
param->cmd);
return -EOPNOTSUPP;
break;
}
if ((ret == 0) && wpa_ioctl) {
if (copy_to_user(p->pointer, param, p->length)) {
ret = -EFAULT;
goto out;
}
}
out:
if (param != NULL)
kfree(param);
return ret;
}
static int set_serial_info(struct tty_struct *tty, struct serial_state *state,
struct serial_struct __user * new_info)
{
struct tty_port *port = &state->tport;
struct serial_struct new_serial;
bool change_spd;
int retval = 0;
if (copy_from_user(&new_serial,new_info,sizeof(new_serial)))
return -EFAULT;
tty_lock(tty);
change_spd = ((new_serial.flags ^ port->flags) & ASYNC_SPD_MASK) ||
new_serial.custom_divisor != state->custom_divisor;
if (new_serial.irq || new_serial.port != state->port ||
new_serial.xmit_fifo_size != state->xmit_fifo_size) {
tty_unlock(tty);
return -EINVAL;
}
if (!serial_isroot()) {
if ((new_serial.baud_base != state->baud_base) ||
(new_serial.close_delay != port->close_delay) ||
(new_serial.xmit_fifo_size != state->xmit_fifo_size) ||
((new_serial.flags & ~ASYNC_USR_MASK) !=
(port->flags & ~ASYNC_USR_MASK))) {
tty_unlock(tty);
return -EPERM;
}
port->flags = ((port->flags & ~ASYNC_USR_MASK) |
(new_serial.flags & ASYNC_USR_MASK));
state->custom_divisor = new_serial.custom_divisor;
goto check_and_exit;
}
if (new_serial.baud_base < 9600) {
tty_unlock(tty);
return -EINVAL;
}
/*
* OK, past this point, all the error checking has been done.
* At this point, we start making changes.....
*/
state->baud_base = new_serial.baud_base;
port->flags = ((port->flags & ~ASYNC_FLAGS) |
(new_serial.flags & ASYNC_FLAGS));
state->custom_divisor = new_serial.custom_divisor;
port->close_delay = new_serial.close_delay * HZ/100;
port->closing_wait = new_serial.closing_wait * HZ/100;
port->low_latency = (port->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
check_and_exit:
if (tty_port_initialized(port)) {
if (change_spd) {
/* warn about deprecation unless clearing */
if (new_serial.flags & ASYNC_SPD_MASK)
dev_warn_ratelimited(tty->dev, "use of SPD flags is deprecated\n");
change_speed(tty, state, NULL);
}
} else
retval = startup(tty, state);
tty_unlock(tty);
return retval;
}
/* XXX! Fixme test for user defined attributes */
int presto_set_ext_attr(struct inode *inode,
const char *name, void *buffer,
size_t buffer_len, int flags)
{
int error;
struct presto_cache *cache;
struct presto_file_set *fset;
struct lento_vfs_context info;
struct dentry *dentry;
int minor = presto_i2m(inode);
char *buf = NULL;
ENTRY;
if (minor < 0) {
EXIT;
return -1;
}
if ( ISLENTO(minor) ) {
EXIT;
return -EINVAL;
}
/* BAD...vfs should really pass down the dentry to use, especially
* since every other operation in iops does. But for now
* we do a reverse mapping from inode to the first dentry
*/
if (list_empty(&inode->i_dentry)) {
printk("No alias for inode %d\n", (int) inode->i_ino);
EXIT;
return -EINVAL;
}
dentry = list_entry(inode->i_dentry.next, struct dentry, d_alias);
error = presto_prep(dentry, &cache, &fset);
if ( error ) {
EXIT;
return error;
}
if ((buffer != NULL) && (buffer_len != 0)) {
/* If buffer is a user space pointer copy it to kernel space
* and reset the flag. We do this since the journal functions need
* access to the contents of the buffer, and the file system
* does not care. When we actually invoke the function, we remove
* the EXT_ATTR_FLAG_USER flag.
*
* XXX:Check if the "fs does not care" assertion is always true -SHP
* (works for ext3)
*/
if (flags & EXT_ATTR_FLAG_USER) {
PRESTO_ALLOC(buf, char *, buffer_len);
if (!buf) {
printk("InterMezzo: out of memory!!!\n");
return -ENOMEM;
}
if (copy_from_user(buf, buffer, buffer_len))
return -EFAULT;
} else
buf = buffer;
} else
buf = buffer;
if ( presto_get_permit(inode) < 0 ) {
EXIT;
if (buffer_len && (flags & EXT_ATTR_FLAG_USER))
PRESTO_FREE(buf, buffer_len);
return -EROFS;
}
/* Simulate presto_setup_info */
memset(&info, 0, sizeof(info));
/* For now redundant..but we keep it around just in case */
info.flags = LENTO_FL_IGNORE_TIME;
if (!ISLENTO(cache->cache_psdev->uc_minor))
info.flags |= LENTO_FL_KML;
/* We pass in the kernel space pointer and reset the
* EXT_ATTR_FLAG_USER flag.
* See comments above.
*/
/* Note that mode is already set by VFS so we send in a NULL */
error = presto_do_set_ext_attr(fset, dentry, name, buf,
buffer_len, flags & ~EXT_ATTR_FLAG_USER,
NULL, &info);
presto_put_permit(inode);
if (buffer_len && (flags & EXT_ATTR_FLAG_USER))
PRESTO_FREE(buf, buffer_len);
EXIT;
return error;
}
static int
akmem_ioctl(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg)
{
int res;
switch (cmd) {
case AKMEMIOCTL_ALLOC:
{
struct akmem_alloc alloc_arg;
struct akmem_segment segments[AKMEM_MAX_LEAVES];
if (copy_from_user(&alloc_arg, (char *)arg, sizeof(alloc_arg)))
return (-EFAULT);
if (AKMEM_MAX_LEAVES < alloc_arg.nsegments)
return (-EINVAL);
if (copy_from_user(segments, alloc_arg.segments,
sizeof(*segments) * alloc_arg.nsegments))
return (-EFAULT);
alloc_arg.segments = segments;
return akmem_alloc(&alloc_arg, &akmem_map);
}
case AKMEMIOCTL_COMMIT:
{
struct akmem_exec exec_arg;
char **argv;
char *buf;
int i, j, len;
if (akmem_map == NULL)
return (-EINVAL);
if (copy_from_user(&exec_arg, (char *)arg, sizeof(exec_arg)))
return (-EFAULT);
if ((buf = kmalloc(akmem_pagesize(), GFP_KERNEL)) == NULL)
return (-ENOMEM);
j = sizeof(char*) * exec_arg.argc;
argv = (char**)buf;
for (i = 0; i < exec_arg.argc; i++) {
len = strlen_user(exec_arg.argv[i]);
if (len == 0)
return (-EFAULT);
len -= 1;
if (akmem_pagesize() - j <= len)
return (AKMEM_EINVAL);
if (copy_from_user(&buf[j], exec_arg.argv[i], len+1))
return (-EFAULT);
argv[i] = &buf[j];
j += len + 1;
}
res = akmem_commit(akmem_map, &exec_arg,
akmem_bootinfo, akmem_bootinfo_size,
NULL, 0);
if (res == 0)
commited = 1;
kfree(buf);
return (res);
}
case AKMEMIOCTL_RAWCOMMIT:
{
struct akmem_rawexec exec_arg;
if (akmem_map == NULL)
return (-EINVAL);
if (copy_from_user(&exec_arg, (char *)arg, sizeof(exec_arg)))
return (-EFAULT);
res = akmem_rawcommit(akmem_map, &exec_arg);
if (res == 0)
commited = 1;
return (res);
}
}
return (-ENOTTY);
}
int32_t msm_sensor_config(struct msm_sensor_ctrl_t *s_ctrl, void __user *argp)
{
struct sensor_cfg_data cdata;
long rc = 0;
if (copy_from_user(&cdata,
(void *)argp,
sizeof(struct sensor_cfg_data)))
return -EFAULT;
mutex_lock(s_ctrl->msm_sensor_mutex);
CDBG("msm_sensor_config: cfgtype = %d\n",
cdata.cfgtype);
switch (cdata.cfgtype) {
case CFG_SET_FPS:
case CFG_SET_PICT_FPS:
if (s_ctrl->func_tbl->
sensor_set_fps == NULL) {
rc = -EFAULT;
break;
}
rc = s_ctrl->func_tbl->
sensor_set_fps(
s_ctrl,
&(cdata.cfg.fps));
break;
case CFG_SET_EXP_GAIN:
if (s_ctrl->func_tbl->
sensor_write_exp_gain == NULL) {
rc = -EFAULT;
break;
}
rc =
s_ctrl->func_tbl->
sensor_write_exp_gain(
s_ctrl,
cdata.cfg.exp_gain.gain,
cdata.cfg.exp_gain.line);
s_ctrl->prev_gain = cdata.cfg.exp_gain.gain;
s_ctrl->prev_line = cdata.cfg.exp_gain.line;
break;
case CFG_SET_PICT_EXP_GAIN:
if (s_ctrl->func_tbl->
sensor_write_snapshot_exp_gain == NULL) {
rc = -EFAULT;
break;
}
rc =
s_ctrl->func_tbl->
sensor_write_snapshot_exp_gain(
s_ctrl,
cdata.cfg.exp_gain.gain,
cdata.cfg.exp_gain.line);
break;
case CFG_SET_MODE:
if (s_ctrl->func_tbl->
sensor_set_sensor_mode == NULL) {
rc = -EFAULT;
break;
}
rc = s_ctrl->func_tbl->
sensor_set_sensor_mode(
s_ctrl,
cdata.mode,
cdata.rs);
if (rc < 0) {
pr_err("%s: i2c read/write failed \n",__func__);
i2c_error_flag = true;
}
break;
case CFG_SET_EFFECT:
CDBG("case CFG_SET_EFFECT:");
if (s_ctrl->func_tbl->
sensor_set_effect == NULL) {
rc = -EFAULT;
break;
}
rc = s_ctrl->func_tbl->
sensor_set_effect(s_ctrl,cdata.cfg.effect);
if(rc < 0){
pr_err("%s: i2c read/write failed \n",__func__);
i2c_error_flag = true;
}
break;
case CFG_SET_SCENE_SELECT:
CDBG("case CFG_SET_SCENE_SELECT");
if (s_ctrl->func_tbl->
sensor_set_scene == NULL) {
rc = -EFAULT;
break;
}
rc = s_ctrl->func_tbl->
sensor_set_scene(
s_ctrl,cdata.cfg.scene);
break;
case CFG_SET_PICT_SIZE:
CDBG("case CFG_SET_PICT_SIZE");
break;
case CFG_SET_WB:
CDBG("case CFG_SET_WB");
if (s_ctrl->func_tbl->
sensor_set_wb == NULL) {
rc = -EFAULT;
break;
}
rc = s_ctrl->func_tbl->
sensor_set_wb( s_ctrl,cdata.cfg.wb_val);
if (rc < 0) {
pr_err("%s: i2c read/write failed \n",__func__);
i2c_error_flag = true;
}
break;
case CFG_SET_ANTIBANDING:
CDBG("case CFG_SET_ANTIBANDING");
if (s_ctrl->func_tbl->
sensor_set_antibanding == NULL) {
rc = -EFAULT;
break;
}
rc = s_ctrl->func_tbl->
sensor_set_antibanding(
s_ctrl,cdata.cfg.antibanding);
if (rc < 0) {
pr_err("%s: i2c read/write failed \n",__func__);
i2c_error_flag = true;
}
break;
case CFG_SET_EXP_COMPENSATION:
CDBG("case CFG_SET_EXP_COMPENSATION");
if (s_ctrl->func_tbl->
sensor_set_exp_compensation == NULL) {
rc = -EFAULT;
break;
}
rc = s_ctrl->func_tbl->
sensor_set_exp_compensation(
s_ctrl,cdata.cfg.exp_compensation);
if (rc < 0) {
pr_err("%s: i2c read/write failed \n",__func__);
i2c_error_flag = true;
}
break;
case CFG_SENSOR_INIT:
if (s_ctrl->func_tbl->
sensor_mode_init == NULL) {
rc = -EFAULT;
break;
}
rc = s_ctrl->func_tbl->
sensor_mode_init(
s_ctrl,
cdata.mode,
&(cdata.cfg.init_info));
if(rc < 0){
pr_err("%s: i2c read/write failed \n",__func__);
i2c_error_flag = true;
}
break;
case CFG_GET_OUTPUT_INFO:
if (s_ctrl->func_tbl->
sensor_get_output_info == NULL) {
rc = -EFAULT;
break;
}
rc = s_ctrl->func_tbl->
sensor_get_output_info(
s_ctrl,
&cdata.cfg.output_info);
if (copy_to_user((void *)argp,
&cdata,
sizeof(struct sensor_cfg_data)))
rc = -EFAULT;
break;
case CFG_GET_EEPROM_DATA:
if (s_ctrl->sensor_eeprom_client == NULL ||
s_ctrl->sensor_eeprom_client->
func_tbl.eeprom_get_data == NULL) {
rc = -EFAULT;
break;
}
rc = s_ctrl->sensor_eeprom_client->
func_tbl.eeprom_get_data(
s_ctrl->sensor_eeprom_client,
&cdata.cfg.eeprom_data);
if (copy_to_user((void *)argp,
&cdata,
sizeof(struct sensor_eeprom_data_t)))
rc = -EFAULT;
break;
case CFG_GET_MAKER_NOTE:
CDBG("case CFG_GET_MAKER_NOTE");
if (s_ctrl->func_tbl->
sensor_get_maker_note == NULL) {
rc = -EFAULT;
break;
}
rc = s_ctrl->func_tbl->
sensor_get_maker_note(s_ctrl,
&(cdata.cfg.get_exif_maker_note) );
if (rc < 0) {
pr_err("%s: i2c read/write failed \n",__func__);
i2c_error_flag = true;
}
if (copy_to_user((void *)argp, &cdata,
sizeof(struct sensor_cfg_data))) {
rc = -EFAULT;
}
break;
case CFG_GET_PARAM_EXIF:
CDBG("case CFG_GET_PARAM_EXIF");
if (s_ctrl->func_tbl->
sensor_get_exif_param == NULL) {
rc = -EFAULT;
break;
}
rc = s_ctrl->func_tbl->
sensor_get_exif_param(s_ctrl,
&(cdata.cfg.get_exif_param) );
if (rc < 0) {
pr_err("%s: i2c read/write failed \n",__func__);
i2c_error_flag = true;
}
if (rc >= 0) {
if (copy_to_user((void *)argp, &cdata,
sizeof(struct sensor_cfg_data))) {
rc = -EFAULT;
}
}
break;
case CFG_GET_EEPROM_READ:
CDBG("case CFG_GET_EEPROM_READ");
if (s_ctrl->func_tbl->
sensor_get_eeprom_otp_info == NULL) {
rc = -EFAULT;
break;
}
rc = s_ctrl->func_tbl->
sensor_get_eeprom_otp_info(s_ctrl,
&(cdata.cfg.eeprom_otp_info) );
if (copy_to_user((void *)argp, &cdata,
sizeof(struct sensor_cfg_data))) {
rc = -EFAULT;
}
break;
case CFG_SET_FRAME_RATE_MODE:
CDBG("case CFG_SET_FRAME_RATE_MODE");
if (s_ctrl->func_tbl->
sensor_set_frame_rate_mode == NULL) {
rc = -EFAULT;
break;
}
rc = s_ctrl->func_tbl->
sensor_set_frame_rate_mode(
s_ctrl,cdata.cfg.frame_rate_mode);
break;
case CFG_GET_HDR_BRIGHTNESS:
CDBG("case CFG_GET_HDR_BRIGHTNESS");
if (s_ctrl->func_tbl->
sensor_get_hdr_brightness == NULL) {
rc = -EFAULT;
break;
}
rc = s_ctrl->func_tbl->
sensor_get_hdr_brightness(s_ctrl,
&(cdata.cfg.hdr_brightness) );
if (rc < 0) {
pr_err("%s: i2c read/write failed \n",__func__);
i2c_error_flag = true;
}
if (rc >= 0) {
if (copy_to_user((void *)argp, &cdata,
sizeof(struct sensor_cfg_data))) {
rc = -EFAULT;
}
}
break;
case CFG_SET_HDR_BRIGHTNESS:
CDBG("case CFG_SET_HDR_BRIGHTNESS");
if (s_ctrl->func_tbl->
sensor_set_hdr_brightness == NULL) {
rc = -EFAULT;
break;
}
rc = s_ctrl->func_tbl->
sensor_set_hdr_brightness(s_ctrl,
cdata.cfg.hdr_brightness );
if (rc < 0) {
pr_err("%s: i2c read/write failed \n",__func__);
i2c_error_flag = true;
}
break;
case CFG_SET_CAP_MODE_ENABLE:
CDBG("case CFG_SET_CAP_MODE_ENABLE");
if (s_ctrl->func_tbl->
sensor_set_cap_mode_enable == NULL) {
rc = -EFAULT;
break;
}
rc = s_ctrl->func_tbl->
sensor_set_cap_mode_enable(
s_ctrl,cdata.cfg.cap_mode_enable);
if (rc < 0) {
pr_err("%s: i2c read/write failed \n",__func__);
i2c_error_flag = true;
}
break;
case CFG_GET_DEVICE_ID:
CDBG("case CFG_GET_DEVICE_ID");
if (s_ctrl->func_tbl->
sensor_get_device_id == NULL) {
rc = -EFAULT;
break;
}
rc = s_ctrl->func_tbl->
sensor_get_device_id(s_ctrl,
&(cdata.cfg.device_id) );
if (rc < 0) {
pr_err("%s: i2c read/write failed \n",__func__);
i2c_error_flag = true;
}
if (rc >= 0) {
if (copy_to_user((void *)argp, &cdata,
sizeof(struct sensor_cfg_data))) {
rc = -EFAULT;
}
}
break;
#if defined(FEATURE_DVE021_DVE072_DVE043)
case CFG_GET_TEMPERATURE_VAL:
CDBG("case CFG_GET_TEMPERATURE_VAL");
rc = msm_mctl_get_DVE073_temperature_val(&cdata.cfg.temperature);
if (rc < 0) {
pr_err("%s: get temperature failed \n",__func__);
}
if (rc >= 0) {
if (copy_to_user((void *)argp, &cdata,
sizeof(struct sensor_cfg_data))){
rc = -EFAULT;
}
}
break;
#endif
case CFG_GET_EXPOSURE_INFO:
CDBG("case CFG_GET_EXPOSURE_INFO");
if (s_ctrl->func_tbl->
sensor_get_exposure_info == NULL) {
rc = -EFAULT;
break;
}
rc = s_ctrl->func_tbl->
sensor_get_exposure_info(s_ctrl,
&(cdata.cfg.fine_integration_time) );
if (rc < 0) {
pr_err("%s: sensor_get_exposure_info failed \n",__func__);
i2c_error_flag = true;
}
if (rc >= 0) {
if (copy_to_user((void *)argp, &cdata,
sizeof(struct sensor_cfg_data))) {
rc = -EFAULT;
}
}
break;
default:
rc = -EFAULT;
break;
}
mutex_unlock(s_ctrl->msm_sensor_mutex);
return rc;
}
ssize_t rw_copy_check_uvector(int type, const struct iovec __user * uvector,
unsigned long nr_segs, unsigned long fast_segs,
struct iovec *fast_pointer,
struct iovec **ret_pointer,
int check_access)
{
unsigned long seg;
ssize_t ret;
struct iovec *iov = fast_pointer;
/*
* SuS says "The readv() function *may* fail if the iovcnt argument
* was less than or equal to 0, or greater than {IOV_MAX}. Linux has
* traditionally returned zero for zero segments, so...
*/
if (nr_segs == 0) {
ret = 0;
goto out;
}
/*
* First get the "struct iovec" from user memory and
* verify all the pointers
*/
if (nr_segs > UIO_MAXIOV) {
ret = -EINVAL;
goto out;
}
if (nr_segs > fast_segs) {
iov = kmalloc(nr_segs*sizeof(struct iovec), GFP_KERNEL);
if (iov == NULL) {
ret = -ENOMEM;
goto out;
}
}
if (copy_from_user(iov, uvector, nr_segs*sizeof(*uvector))) {
ret = -EFAULT;
goto out;
}
/*
* According to the Single Unix Specification we should return EINVAL
* if an element length is < 0 when cast to ssize_t or if the
* total length would overflow the ssize_t return value of the
* system call.
*
* Linux caps all read/write calls to MAX_RW_COUNT, and avoids the
* overflow case.
*/
ret = 0;
for (seg = 0; seg < nr_segs; seg++) {
void __user *buf = iov[seg].iov_base;
ssize_t len = (ssize_t)iov[seg].iov_len;
/* see if we we're about to use an invalid len or if
* it's about to overflow ssize_t */
if (len < 0) {
ret = -EINVAL;
goto out;
}
if (check_access
&& unlikely(!access_ok(vrfy_dir(type), buf, len))) {
ret = -EFAULT;
goto out;
}
if (len > MAX_RW_COUNT - ret) {
len = MAX_RW_COUNT - ret;
iov[seg].iov_len = len;
}
ret += len;
}
out:
*ret_pointer = iov;
return ret;
}
static ssize_t wdm_write
(struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
{
u8 *buf;
int rv = -EMSGSIZE, r, we;
struct wdm_device *desc = file->private_data;
struct usb_ctrlrequest *req;
if (count > desc->wMaxCommand)
count = desc->wMaxCommand;
spin_lock_irq(&desc->iuspin);
we = desc->werr;
desc->werr = 0;
spin_unlock_irq(&desc->iuspin);
if (we < 0)
return -EIO;
r = mutex_lock_interruptible(&desc->wlock); /* concurrent writes */
rv = -ERESTARTSYS;
if (r)
goto outnl;
r = usb_autopm_get_interface(desc->intf);
if (r < 0)
goto outnp;
if (!(file->f_flags & O_NONBLOCK))
r = wait_event_interruptible(desc->wait, !test_bit(WDM_IN_USE,
&desc->flags));
else
if (test_bit(WDM_IN_USE, &desc->flags))
r = -EAGAIN;
if (r < 0)
goto out;
if (test_bit(WDM_DISCONNECTING, &desc->flags)) {
rv = -ENODEV;
goto out;
}
desc->outbuf = buf = kmalloc(count, GFP_KERNEL);
if (!buf) {
rv = -ENOMEM;
goto out;
}
r = copy_from_user(buf, buffer, count);
if (r > 0) {
kfree(buf);
rv = -EFAULT;
goto out;
}
req = desc->orq;
usb_fill_control_urb(
desc->command,
interface_to_usbdev(desc->intf),
/* using common endpoint 0 */
usb_sndctrlpipe(interface_to_usbdev(desc->intf), 0),
(unsigned char *)req,
buf,
count,
wdm_out_callback,
desc
);
req->bRequestType = (USB_DIR_OUT | USB_TYPE_CLASS |
USB_RECIP_INTERFACE);
req->bRequest = USB_CDC_SEND_ENCAPSULATED_COMMAND;
req->wValue = 0;
req->wIndex = desc->inum;
req->wLength = cpu_to_le16(count);
set_bit(WDM_IN_USE, &desc->flags);
rv = usb_submit_urb(desc->command, GFP_KERNEL);
if (rv < 0) {
kfree(buf);
clear_bit(WDM_IN_USE, &desc->flags);
dev_err(&desc->intf->dev, "Tx URB error: %d\n", rv);
} else {
dev_dbg(&desc->intf->dev, "Tx URB has been submitted index=%d",
req->wIndex);
}
out:
usb_autopm_put_interface(desc->intf);
outnp:
mutex_unlock(&desc->wlock);
outnl:
return rv < 0 ? rv : count;
}
static int gc_commit_wrapper(struct gccommit *gccommit)
{
int ret = 0;
struct gccommit kgccommit;
struct gcbuffer *head = NULL;
struct gcbuffer *tail;
struct gcbuffer *ubuffer;
struct gcbuffer *kbuffer = NULL;
struct gcfixup *ufixup;
struct gcfixup *nfixup;
struct gcfixup *kfixup = NULL;
int tablesize;
/* Get IOCTL parameters. */
if (copy_from_user(&kgccommit, gccommit, sizeof(struct gccommit))) {
GCPRINT(NULL, 0, GC_MOD_PREFIX
"failed to read data.\n",
__func__, __LINE__);
kgccommit.gcerror = GCERR_USER_READ;
goto exit;
}
/* Make a copy of the user buffer structures. */
ubuffer = kgccommit.buffer;
while (ubuffer != NULL) {
/* Allocate a buffer structure. */
kgccommit.gcerror = get_buffer(&kbuffer);
if (kgccommit.gcerror != GCERR_NONE)
goto exit;
/* Add to the list. */
if (head == NULL)
head = kbuffer;
else
tail->next = kbuffer;
tail = kbuffer;
/* Reset user pointers in the kernel structure. */
kbuffer->fixuphead = NULL;
kbuffer->next = NULL;
/* Get the data from the user. */
if (copy_from_user(kbuffer, ubuffer, sizeof(struct gcbuffer))) {
GCPRINT(NULL, 0, GC_MOD_PREFIX
"failed to read data.\n",
__func__, __LINE__);
kgccommit.gcerror = GCERR_USER_READ;
goto exit;
}
/* Get the next user buffer. */
ubuffer = kbuffer->next;
kbuffer->next = NULL;
/* Get fixups and reset them in the kernel copy. */
ufixup = kbuffer->fixuphead;
kbuffer->fixuphead = NULL;
/* Copy all fixups. */
while (ufixup != NULL) {
/* Allocare a fixup structure. */
kgccommit.gcerror = get_fixup(&kfixup);
if (kgccommit.gcerror != GCERR_NONE)
goto exit;
/* Add to the list. */
if (kbuffer->fixuphead == NULL)
kbuffer->fixuphead = kfixup;
else
kbuffer->fixuptail->next = kfixup;
kbuffer->fixuptail = kfixup;
/* Get the data from the user. */
if (copy_from_user(kfixup, ufixup,
offsetof(struct gcfixup, fixup))) {
GCPRINT(NULL, 0, GC_MOD_PREFIX
" failed to read data.\n",
__func__, __LINE__);
kgccommit.gcerror = GCERR_USER_READ;
goto exit;
}
/* Get the next fixup. */
nfixup = kfixup->next;
kfixup->next = NULL;
/* Compute the size of the fixup table. */
tablesize = kfixup->count * sizeof(struct gcfixupentry);
/* Get the fixup table. */
if (copy_from_user(kfixup->fixup, ufixup->fixup,
tablesize)) {
GCPRINT(NULL, 0, GC_MOD_PREFIX
"failed to read data.\n",
__func__, __LINE__);
kgccommit.gcerror = GCERR_USER_READ;
goto exit;
}
/* Advance to the next. */
ufixup = nfixup;
}
}
