IMG_VOID DBGOPTBRG_dispatch(SYSBRG_sPacket *psPacket)
{
DBGOPTBRG_sCmdMsg sCommandMsg;
DBGOPTBRG_sRespMsg sResponseMsg;
if(SYSOSKM_CopyFromUser(&sCommandMsg, psPacket->pvCmdData, sizeof(sCommandMsg)))
IMG_ASSERT(!"failed to copy from user");
switch (sCommandMsg.eFuncId)
{
case DBGOPTBRG_Initialise_ID:
#if 0
#ifdef CONFIG_COMPAT
printk("bridge %d %s %s\n", is_compat_task(), __FUNCTION__, "DBGOPTBRG_Initialise");
#else
printk("bridge %s %s\n", __FUNCTION__, "DBGOPTBRG_Initialise");
#endif
#endif
sResponseMsg.sResp.sDBGOPTBRG_InitialiseResp.xDBGOPTBRG_InitialiseResp =
DBGOPTBRG_Initialise(
);
break;
case DBGOPTBRG_Deinitialise_ID:
#if 0
#ifdef CONFIG_COMPAT
printk("bridge %d %s %s\n", is_compat_task(), __FUNCTION__, "DBGOPTBRG_Deinitialise");
#else
printk("bridge %s %s\n", __FUNCTION__, "DBGOPTBRG_Deinitialise");
#endif
#endif
DBGOPTBRG_Deinitialise(
);
break;
case DBGOPTBRG_Set_ID:
#if 0
#ifdef CONFIG_COMPAT
printk("bridge %d %s %s\n", is_compat_task(), __FUNCTION__, "DBGOPTBRG_Set");
#else
printk("bridge %s %s\n", __FUNCTION__, "DBGOPTBRG_Set");
#endif
#endif
sResponseMsg.sResp.sDBGOPTBRG_SetResp.xDBGOPTBRG_SetResp =
DBGOPTBRG_Set(
sCommandMsg.sCmd.sDBGOPTBRG_SetCmd.sStrName,
sCommandMsg.sCmd.sDBGOPTBRG_SetCmd.eType,
sCommandMsg.sCmd.sDBGOPTBRG_SetCmd.sVal
);
break;
case DBGOPTBRG_Get_ID:
#if 0
#ifdef CONFIG_COMPAT
printk("bridge %d %s %s\n", is_compat_task(), __FUNCTION__, "DBGOPTBRG_Get");
#else
printk("bridge %s %s\n", __FUNCTION__, "DBGOPTBRG_Get");
#endif
#endif
sResponseMsg.sResp.sDBGOPTBRG_GetResp.xDBGOPTBRG_GetResp =
DBGOPTBRG_Get(
sCommandMsg.sCmd.sDBGOPTBRG_GetCmd.sStrName,
sCommandMsg.sCmd.sDBGOPTBRG_GetCmd.peType,
sCommandMsg.sCmd.sDBGOPTBRG_GetCmd.psVal
);
break;
case DBGOPTBRG_Clear_ID:
#if 0
#ifdef CONFIG_COMPAT
printk("bridge %d %s %s\n", is_compat_task(), __FUNCTION__, "DBGOPTBRG_Clear");
#else
printk("bridge %s %s\n", __FUNCTION__, "DBGOPTBRG_Clear");
#endif
#endif
DBGOPTBRG_Clear(
sCommandMsg.sCmd.sDBGOPTBRG_ClearCmd.sStrName
);
break;
case DBGOPTBRG_SetWithKey_ID:
#if 0
#ifdef CONFIG_COMPAT
printk("bridge %d %s %s\n", is_compat_task(), __FUNCTION__, "DBGOPTBRG_SetWithKey");
#else
printk("bridge %s %s\n", __FUNCTION__, "DBGOPTBRG_SetWithKey");
#endif
#endif
sResponseMsg.sResp.sDBGOPTBRG_SetWithKeyResp.xDBGOPTBRG_SetWithKeyResp =
DBGOPTBRG_SetWithKey(
sCommandMsg.sCmd.sDBGOPTBRG_SetWithKeyCmd.i32Key,
sCommandMsg.sCmd.sDBGOPTBRG_SetWithKeyCmd.sStrName,
sCommandMsg.sCmd.sDBGOPTBRG_SetWithKeyCmd.eType,
sCommandMsg.sCmd.sDBGOPTBRG_SetWithKeyCmd.sVal
);
break;
case DBGOPTBRG_GetWithKey_ID:
#if 0
#ifdef CONFIG_COMPAT
printk("bridge %d %s %s\n", is_compat_task(), __FUNCTION__, "DBGOPTBRG_GetWithKey");
#else
printk("bridge %s %s\n", __FUNCTION__, "DBGOPTBRG_GetWithKey");
#endif
#endif
sResponseMsg.sResp.sDBGOPTBRG_GetWithKeyResp.xDBGOPTBRG_GetWithKeyResp =
DBGOPTBRG_GetWithKey(
sCommandMsg.sCmd.sDBGOPTBRG_GetWithKeyCmd.i32Key,
sCommandMsg.sCmd.sDBGOPTBRG_GetWithKeyCmd.sStrName,
sCommandMsg.sCmd.sDBGOPTBRG_GetWithKeyCmd.peType,
sCommandMsg.sCmd.sDBGOPTBRG_GetWithKeyCmd.psVal
);
break;
case DBGOPTBRG_ClearWithKey_ID:
#if 0
#ifdef CONFIG_COMPAT
printk("bridge %d %s %s\n", is_compat_task(), __FUNCTION__, "DBGOPTBRG_ClearWithKey");
#else
printk("bridge %s %s\n", __FUNCTION__, "DBGOPTBRG_ClearWithKey");
#endif
#endif
DBGOPTBRG_ClearWithKey(
sCommandMsg.sCmd.sDBGOPTBRG_ClearWithKeyCmd.i32Key,
sCommandMsg.sCmd.sDBGOPTBRG_ClearWithKeyCmd.sStrName
);
break;
case DBGOPTBRG_ClearAll_ID:
#if 0
#ifdef CONFIG_COMPAT
printk("bridge %d %s %s\n", is_compat_task(), __FUNCTION__, "DBGOPTBRG_ClearAll");
#else
printk("bridge %s %s\n", __FUNCTION__, "DBGOPTBRG_ClearAll");
#endif
#endif
DBGOPTBRG_ClearAll(
);
break;
}
if(SYSOSKM_CopyToUser(psPacket->pvRespData, &sResponseMsg, sizeof(sResponseMsg)))
IMG_ASSERT(!"failed to copy to user");
}
void syscall_entry_probe(void *__data, struct pt_regs *regs, long id)
{
struct lttng_channel *chan = __data;
struct lttng_event *event, *unknown_event;
const struct trace_syscall_entry *table, *entry;
size_t table_len;
if (unlikely(is_compat_task())) {
table = compat_sc_table;
table_len = ARRAY_SIZE(compat_sc_table);
unknown_event = chan->sc_compat_unknown;
} else {
table = sc_table;
table_len = ARRAY_SIZE(sc_table);
unknown_event = chan->sc_unknown;
}
if (unlikely(id >= table_len)) {
syscall_entry_unknown(unknown_event, regs, id);
return;
}
if (unlikely(is_compat_task()))
event = chan->compat_sc_table[id];
else
event = chan->sc_table[id];
if (unlikely(!event)) {
syscall_entry_unknown(unknown_event, regs, id);
return;
}
entry = &table[id];
WARN_ON_ONCE(!entry);
switch (entry->nrargs) {
case 0:
{
void (*fptr)(void *__data) = entry->func;
fptr(event);
break;
}
case 1:
{
void (*fptr)(void *__data, unsigned long arg0) = entry->func;
unsigned long args[1];
syscall_get_arguments(current, regs, 0, entry->nrargs, args);
fptr(event, args[0]);
break;
}
case 2:
{
void (*fptr)(void *__data,
unsigned long arg0,
unsigned long arg1) = entry->func;
unsigned long args[2];
syscall_get_arguments(current, regs, 0, entry->nrargs, args);
fptr(event, args[0], args[1]);
break;
}
case 3:
{
void (*fptr)(void *__data,
unsigned long arg0,
unsigned long arg1,
unsigned long arg2) = entry->func;
unsigned long args[3];
syscall_get_arguments(current, regs, 0, entry->nrargs, args);
fptr(event, args[0], args[1], args[2]);
break;
}
case 4:
{
void (*fptr)(void *__data,
unsigned long arg0,
unsigned long arg1,
unsigned long arg2,
unsigned long arg3) = entry->func;
unsigned long args[4];
syscall_get_arguments(current, regs, 0, entry->nrargs, args);
fptr(event, args[0], args[1], args[2], args[3]);
break;
}
case 5:
{
void (*fptr)(void *__data,
unsigned long arg0,
unsigned long arg1,
unsigned long arg2,
unsigned long arg3,
unsigned long arg4) = entry->func;
unsigned long args[5];
syscall_get_arguments(current, regs, 0, entry->nrargs, args);
fptr(event, args[0], args[1], args[2], args[3], args[4]);
break;
}
case 6:
{
void (*fptr)(void *__data,
unsigned long arg0,
unsigned long arg1,
unsigned long arg2,
unsigned long arg3,
unsigned long arg4,
unsigned long arg5) = entry->func;
unsigned long args[6];
syscall_get_arguments(current, regs, 0, entry->nrargs, args);
fptr(event, args[0], args[1], args[2],
args[3], args[4], args[5]);
break;
}
default:
break;
}
}
int setup_vdso_pages(void)
{
struct page **pagelist;
unsigned long pages;
struct mm_struct *mm = current->mm;
unsigned long vdso_base = 0;
int retval = 0;
if (!vdso_ready)
return 0;
mm->context.vdso_base = 0;
pagelist = vdso_pagelist;
pages = vdso_pages;
#ifdef CONFIG_COMPAT
if (is_compat_task()) {
pagelist = vdso32_pagelist;
pages = vdso32_pages;
}
#endif
/*
* vDSO has a problem and was disabled, just don't "enable" it for the
* process.
*/
if (pages == 0)
return 0;
vdso_base = get_unmapped_area(NULL, vdso_base,
(pages << PAGE_SHIFT) +
((VDSO_ALIGNMENT - 1) & PAGE_MASK),
0, 0);
if (IS_ERR_VALUE(vdso_base)) {
retval = vdso_base;
return retval;
}
/* Add required alignment. */
vdso_base = ALIGN(vdso_base, VDSO_ALIGNMENT);
/*
* Put vDSO base into mm struct. We need to do this before calling
* install_special_mapping or the perf counter mmap tracking code
* will fail to recognise it as a vDSO (since arch_vma_name fails).
*/
mm->context.vdso_base = vdso_base;
/*
* our vma flags don't have VM_WRITE so by default, the process isn't
* allowed to write those pages.
* gdb can break that with ptrace interface, and thus trigger COW on
* those pages but it's then your responsibility to never do that on
* the "data" page of the vDSO or you'll stop getting kernel updates
* and your nice userland gettimeofday will be totally dead.
* It's fine to use that for setting breakpoints in the vDSO code
* pages though
*/
retval = install_special_mapping(mm, vdso_base,
pages << PAGE_SHIFT,
VM_READ|VM_EXEC |
VM_MAYREAD | VM_MAYWRITE | VM_MAYEXEC,
pagelist);
if (retval)
mm->context.vdso_base = 0;
return retval;
}
static int watchpoint_handler(unsigned long addr, unsigned int esr,
struct pt_regs *regs)
{
int i, step = 0, *kernel_step, access;
u32 ctrl_reg;
u64 val, alignment_mask;
struct perf_event *wp, **slots;
struct debug_info *debug_info;
struct arch_hw_breakpoint *info;
struct arch_hw_breakpoint_ctrl ctrl;
slots = this_cpu_ptr(wp_on_reg);
debug_info = ¤t->thread.debug;
for (i = 0; i < core_num_wrps; ++i) {
rcu_read_lock();
wp = slots[i];
if (wp == NULL)
goto unlock;
info = counter_arch_bp(wp);
/* AArch32 watchpoints are either 4 or 8 bytes aligned. */
if (is_compat_task()) {
if (info->ctrl.len == ARM_BREAKPOINT_LEN_8)
alignment_mask = 0x7;
else
alignment_mask = 0x3;
} else {
alignment_mask = 0x7;
}
/* Check if the watchpoint value matches. */
val = read_wb_reg(AARCH64_DBG_REG_WVR, i);
if (val != (addr & ~alignment_mask))
goto unlock;
/* Possible match, check the byte address select to confirm. */
ctrl_reg = read_wb_reg(AARCH64_DBG_REG_WCR, i);
decode_ctrl_reg(ctrl_reg, &ctrl);
if (!((1 << (addr & alignment_mask)) & ctrl.len))
goto unlock;
/*
* Check that the access type matches.
* 0 => load, otherwise => store
*/
access = (esr & AARCH64_ESR_ACCESS_MASK) ? HW_BREAKPOINT_W :
HW_BREAKPOINT_R;
if (!(access & hw_breakpoint_type(wp)))
goto unlock;
info->trigger = addr;
perf_bp_event(wp, regs);
/* Do we need to handle the stepping? */
if (is_default_overflow_handler(wp))
step = 1;
unlock:
rcu_read_unlock();
}
if (!step)
return 0;
/*
* We always disable EL0 watchpoints because the kernel can
* cause these to fire via an unprivileged access.
*/
toggle_bp_registers(AARCH64_DBG_REG_WCR, DBG_ACTIVE_EL0, 0);
if (user_mode(regs)) {
debug_info->wps_disabled = 1;
/* If we're already stepping a breakpoint, just return. */
if (debug_info->bps_disabled)
return 0;
if (test_thread_flag(TIF_SINGLESTEP))
debug_info->suspended_step = 1;
else
user_enable_single_step(current);
} else {
toggle_bp_registers(AARCH64_DBG_REG_WCR, DBG_ACTIVE_EL1, 0);
kernel_step = this_cpu_ptr(&stepping_kernel_bp);
if (*kernel_step != ARM_KERNEL_STEP_NONE)
return 0;
if (kernel_active_single_step()) {
*kernel_step = ARM_KERNEL_STEP_SUSPEND;
} else {
*kernel_step = ARM_KERNEL_STEP_ACTIVE;
kernel_enable_single_step(regs);
}
}
return 0;
}
IMG_VOID HOSTUTILS_dispatch(SYSBRG_sPacket *psPacket)
{
HOSTUTILS_sCmdMsg sCommandMsg;
HOSTUTILS_sRespMsg sResponseMsg;
if(SYSOSKM_CopyFromUser(&sCommandMsg, psPacket->pvCmdData, sizeof(sCommandMsg)))
IMG_ASSERT(!"failed to copy from user");
switch (sCommandMsg.eFuncId)
{
case COMMKM_Initialize_ID:
#if 0
#ifdef CONFIG_COMPAT
printk("bridge %d %s %s\n", is_compat_task(), __FUNCTION__, "COMMKM_Initialize");
#else
printk("bridge %s %s\n", __FUNCTION__, "COMMKM_Initialize");
#endif
#endif
sResponseMsg.sResp.sCOMMKM_InitializeResp.xCOMMKM_InitializeResp =
COMMKM_Initialize(
sCommandMsg.sCmd.sCOMMKM_InitializeCmd.ui32ConnId,
sCommandMsg.sCmd.sCOMMKM_InitializeCmd.apsWBDataInfo,
sCommandMsg.sCmd.sCOMMKM_InitializeCmd.pui32NumPipes,
sCommandMsg.sCmd.sCOMMKM_InitializeCmd.ui32MmuFlags,
sCommandMsg.sCmd.sCOMMKM_InitializeCmd.ui32MMUTileStride
);
break;
case COMMKM_OpenSocket_ID:
#if 0
#ifdef CONFIG_COMPAT
printk("bridge %d %s %s\n", is_compat_task(), __FUNCTION__, "COMMKM_OpenSocket");
#else
printk("bridge %s %s\n", __FUNCTION__, "COMMKM_OpenSocket");
#endif
#endif
sResponseMsg.sResp.sCOMMKM_OpenSocketResp.xCOMMKM_OpenSocketResp =
COMMKM_OpenSocket(
sCommandMsg.sCmd.sCOMMKM_OpenSocketCmd.ui32ConnId,
sCommandMsg.sCmd.sCOMMKM_OpenSocketCmd.ui32SockId,
sCommandMsg.sCmd.sCOMMKM_OpenSocketCmd.eCodec
);
break;
case COMMKM_SetupSocket_ID:
#if 0
#ifdef CONFIG_COMPAT
printk("bridge %d %s %s\n", is_compat_task(), __FUNCTION__, "COMMKM_SetupSocket");
#else
printk("bridge %s %s\n", __FUNCTION__, "COMMKM_SetupSocket");
#endif
#endif
sResponseMsg.sResp.sCOMMKM_SetupSocketResp.xCOMMKM_SetupSocketResp =
COMMKM_SetupSocket(
sCommandMsg.sCmd.sCOMMKM_SetupSocketCmd.ui32SockId,
sCommandMsg.sCmd.sCOMMKM_SetupSocketCmd.psBiasTables,
sCommandMsg.sCmd.sCOMMKM_SetupSocketCmd.ui16FrameHeight,
sCommandMsg.sCmd.sCOMMKM_SetupSocketCmd.ui16Width,
sCommandMsg.sCmd.sCOMMKM_SetupSocketCmd.bDoSerializedComm,
sCommandMsg.sCmd.sCOMMKM_SetupSocketCmd.ui8CtxtNum,
sCommandMsg.sCmd.sCOMMKM_SetupSocketCmd.usedSocket
);
break;
case COMMKM_CloseSocket_ID:
#if 0
#ifdef CONFIG_COMPAT
printk("bridge %d %s %s\n", is_compat_task(), __FUNCTION__, "COMMKM_CloseSocket");
#else
printk("bridge %s %s\n", __FUNCTION__, "COMMKM_CloseSocket");
#endif
#endif
sResponseMsg.sResp.sCOMMKM_CloseSocketResp.xCOMMKM_CloseSocketResp =
COMMKM_CloseSocket(
sCommandMsg.sCmd.sCOMMKM_CloseSocketCmd.ui32SockId
);
break;
case COMMKM_Send_ID:
#if 0
#ifdef CONFIG_COMPAT
printk("bridge %d %s %s\n", is_compat_task(), __FUNCTION__, "COMMKM_Send");
#else
printk("bridge %s %s\n", __FUNCTION__, "COMMKM_Send");
#endif
#endif
sResponseMsg.sResp.sCOMMKM_SendResp.xCOMMKM_SendResp =
COMMKM_Send(
sCommandMsg.sCmd.sCOMMKM_SendCmd.ui32SockId,
sCommandMsg.sCmd.sCOMMKM_SendCmd.msg_eCmdId,
sCommandMsg.sCmd.sCOMMKM_SendCmd.msg_ui32Data,
sCommandMsg.sCmd.sCOMMKM_SendCmd.msg_pCommandDataBuf,
sCommandMsg.sCmd.sCOMMKM_SendCmd.pui32WritebackVal
);
break;
case COMMKM_Recv_ID:
#if 0
#ifdef CONFIG_COMPAT
printk("bridge %d %s %s\n", is_compat_task(), __FUNCTION__, "COMMKM_Recv");
#else
printk("bridge %s %s\n", __FUNCTION__, "COMMKM_Recv");
#endif
#endif
sResponseMsg.sResp.sCOMMKM_RecvResp.xCOMMKM_RecvResp =
COMMKM_Recv(
sCommandMsg.sCmd.sCOMMKM_RecvCmd.ui32SockId,
sCommandMsg.sCmd.sCOMMKM_RecvCmd.pMsg,
sCommandMsg.sCmd.sCOMMKM_RecvCmd.bBlocking
);
break;
case COMMKM_LoadBias_ID:
#if 0
#ifdef CONFIG_COMPAT
printk("bridge %d %s %s\n", is_compat_task(), __FUNCTION__, "COMMKM_LoadBias");
#else
printk("bridge %s %s\n", __FUNCTION__, "COMMKM_LoadBias");
#endif
#endif
sResponseMsg.sResp.sCOMMKM_LoadBiasResp.xCOMMKM_LoadBiasResp =
COMMKM_LoadBias(
sCommandMsg.sCmd.sCOMMKM_LoadBiasCmd.psBiasTables,
sCommandMsg.sCmd.sCOMMKM_LoadBiasCmd.eStandard
);
break;
case COMMKM_GetFwConfigInt_ID:
#if 0
#ifdef CONFIG_COMPAT
printk("bridge %d %s %s\n", is_compat_task(), __FUNCTION__, "COMMKM_GetFwConfigInt");
#else
printk("bridge %s %s\n", __FUNCTION__, "COMMKM_GetFwConfigInt");
#endif
#endif
sResponseMsg.sResp.sCOMMKM_GetFwConfigIntResp.xCOMMKM_GetFwConfigIntResp =
COMMKM_GetFwConfigInt(
sCommandMsg.sCmd.sCOMMKM_GetFwConfigIntCmd.ui32ConnId,
sCommandMsg.sCmd.sCOMMKM_GetFwConfigIntCmd.name,
sCommandMsg.sCmd.sCOMMKM_GetFwConfigIntCmd.szNameSize
);
break;
case COMM_GetPipeUsage_ID:
#if 0
#ifdef CONFIG_COMPAT
printk("bridge %d %s %s\n", is_compat_task(), __FUNCTION__, "COMM_GetPipeUsage");
#else
printk("bridge %s %s\n", __FUNCTION__, "COMM_GetPipeUsage");
#endif
#endif
sResponseMsg.sResp.sCOMM_GetPipeUsageResp.xCOMM_GetPipeUsageResp =
COMM_GetPipeUsage(
sCommandMsg.sCmd.sCOMM_GetPipeUsageCmd.ui8Pipe
);
break;
case COMM_SetPipeUsage_ID:
#if 0
#ifdef CONFIG_COMPAT
printk("bridge %d %s %s\n", is_compat_task(), __FUNCTION__, "COMM_SetPipeUsage");
#else
printk("bridge %s %s\n", __FUNCTION__, "COMM_SetPipeUsage");
#endif
#endif
COMM_SetPipeUsage(
sCommandMsg.sCmd.sCOMM_SetPipeUsageCmd.ui8Pipe,
sCommandMsg.sCmd.sCOMM_SetPipeUsageCmd.ui8Val
);
break;
case COMMKM_IsIdle_ID:
#if 0
#ifdef CONFIG_COMPAT
printk("bridge %d %s %s\n", is_compat_task(), __FUNCTION__, "COMMKM_IsIdle");
#else
printk("bridge %s %s\n", __FUNCTION__, "COMMKM_IsIdle");
#endif
#endif
sResponseMsg.sResp.sCOMMKM_IsIdleResp.xCOMMKM_IsIdleResp =
COMMKM_IsIdle(
sCommandMsg.sCmd.sCOMMKM_IsIdleCmd.ui32SockId
);
break;
case TOPAZKM_IsIdle_ID:
#if 0
#ifdef CONFIG_COMPAT
printk("bridge %d %s %s\n", is_compat_task(), __FUNCTION__, "TOPAZKM_IsIdle");
#else
printk("bridge %s %s\n", __FUNCTION__, "TOPAZKM_IsIdle");
#endif
#endif
sResponseMsg.sResp.sTOPAZKM_IsIdleResp.xTOPAZKM_IsIdleResp =
TOPAZKM_IsIdle(
sCommandMsg.sCmd.sTOPAZKM_IsIdleCmd.ui32SockId
);
break;
case TOPAZKM_Suspend_ID:
#if 0
#ifdef CONFIG_COMPAT
printk("bridge %d %s %s\n", is_compat_task(), __FUNCTION__, "TOPAZKM_Suspend");
#else
printk("bridge %s %s\n", __FUNCTION__, "TOPAZKM_Suspend");
#endif
#endif
TOPAZKM_Suspend(
sCommandMsg.sCmd.sTOPAZKM_SuspendCmd.ui32ConnId
);
break;
case TOPAZKM_Resume_ID:
#if 0
#ifdef CONFIG_COMPAT
printk("bridge %d %s %s\n", is_compat_task(), __FUNCTION__, "TOPAZKM_Resume");
#else
printk("bridge %s %s\n", __FUNCTION__, "TOPAZKM_Resume");
#endif
#endif
TOPAZKM_Resume(
sCommandMsg.sCmd.sTOPAZKM_ResumeCmd.ui32ConnId
);
break;
case TOPAZKM_GetCoreDes1_ID:
#if 0
#ifdef CONFIG_COMPAT
printk("bridge %d %s %s\n", is_compat_task(), __FUNCTION__, "TOPAZKM_GetCoreDes1");
#else
printk("bridge %s %s\n", __FUNCTION__, "TOPAZKM_GetCoreDes1");
#endif
#endif
sResponseMsg.sResp.sTOPAZKM_GetCoreDes1Resp.xTOPAZKM_GetCoreDes1Resp =
TOPAZKM_GetCoreDes1(
);
break;
case TOPAZKM_GetCoreRev_ID:
#if 0
#ifdef CONFIG_COMPAT
printk("bridge %d %s %s\n", is_compat_task(), __FUNCTION__, "TOPAZKM_GetCoreRev");
#else
printk("bridge %s %s\n", __FUNCTION__, "TOPAZKM_GetCoreRev");
#endif
#endif
sResponseMsg.sResp.sTOPAZKM_GetCoreRevResp.xTOPAZKM_GetCoreRevResp =
TOPAZKM_GetCoreRev(
);
break;
case TOPAZKM_GetNumPipes_ID:
#if 0
#ifdef CONFIG_COMPAT
printk("bridge %d %s %s\n", is_compat_task(), __FUNCTION__, "TOPAZKM_GetNumPipes");
#else
printk("bridge %s %s\n", __FUNCTION__, "TOPAZKM_GetNumPipes");
#endif
#endif
sResponseMsg.sResp.sTOPAZKM_GetNumPipesResp.xTOPAZKM_GetNumPipesResp =
TOPAZKM_GetNumPipes(
);
break;
}
if(SYSOSKM_CopyToUser(psPacket->pvRespData, &sResponseMsg, sizeof(sResponseMsg)))
IMG_ASSERT(!"failed to copy to user");
}
/*
* Validate the arch-specific HW Breakpoint register settings.
*/
int arch_validate_hwbkpt_settings(struct perf_event *bp)
{
struct arch_hw_breakpoint *info = counter_arch_bp(bp);
int ret;
u64 alignment_mask, offset;
/* Build the arch_hw_breakpoint. */
ret = arch_build_bp_info(bp);
if (ret)
return ret;
/*
* Check address alignment.
* We don't do any clever alignment correction for watchpoints
* because using 64-bit unaligned addresses is deprecated for
* AArch64.
*
* AArch32 tasks expect some simple alignment fixups, so emulate
* that here.
*/
if (is_compat_task()) {
if (info->ctrl.len == ARM_BREAKPOINT_LEN_8)
alignment_mask = 0x7;
else
alignment_mask = 0x3;
offset = info->address & alignment_mask;
switch (offset) {
case 0:
/* Aligned */
break;
case 1:
/* Allow single byte watchpoint. */
if (info->ctrl.len == ARM_BREAKPOINT_LEN_1)
break;
case 2:
/* Allow halfword watchpoints and breakpoints. */
if (info->ctrl.len == ARM_BREAKPOINT_LEN_2)
break;
default:
return -EINVAL;
}
info->address &= ~alignment_mask;
info->ctrl.len <<= offset;
} else {
if (info->ctrl.type == ARM_BREAKPOINT_EXECUTE)
alignment_mask = 0x3;
else
alignment_mask = 0x7;
if (info->address & alignment_mask)
return -EINVAL;
}
/*
* Disallow per-task kernel breakpoints since these would
* complicate the stepping code.
*/
if (info->ctrl.privilege == AARCH64_BREAKPOINT_EL1 && bp->hw.bp_target)
return -EINVAL;
return 0;
}
/* static function definition */
int32_t msm_sensor_driver_probe(void *setting,
struct msm_sensor_info_t *probed_info, char *entity_name)
{
int32_t rc = 0;
struct msm_sensor_ctrl_t *s_ctrl = NULL;
struct msm_camera_cci_client *cci_client = NULL;
struct msm_camera_sensor_slave_info *slave_info = NULL;
struct msm_camera_slave_info *camera_info = NULL;
unsigned long mount_pos = 0;
/* Validate input parameters */
if (!setting) {
pr_err("failed: slave_info %p", setting);
return -EINVAL;
}
/* Allocate memory for slave info */
slave_info = kzalloc(sizeof(*slave_info), GFP_KERNEL);
if (!slave_info) {
pr_err("failed: no memory slave_info %p", slave_info);
return -ENOMEM;
}
#ifdef CONFIG_COMPAT
if (is_compat_task()) {
struct msm_camera_sensor_slave_info32 setting32;
if (copy_from_user((void *)&setting32, setting,
sizeof(setting32))) {
pr_err("failed: copy_from_user");
rc = -EFAULT;
goto free_slave_info;
}
strlcpy(slave_info->actuator_name, setting32.actuator_name,
sizeof(slave_info->actuator_name));
strlcpy(slave_info->eeprom_name, setting32.eeprom_name,
sizeof(slave_info->eeprom_name));
strlcpy(slave_info->sensor_name, setting32.sensor_name,
sizeof(slave_info->sensor_name));
strlcpy(slave_info->ois_name, setting32.ois_name,
sizeof(slave_info->ois_name));
strlcpy(slave_info->flash_name, setting32.flash_name,
sizeof(slave_info->flash_name));
slave_info->addr_type = setting32.addr_type;
slave_info->camera_id = setting32.camera_id;
slave_info->i2c_freq_mode = setting32.i2c_freq_mode;
slave_info->sensor_id_info = setting32.sensor_id_info;
slave_info->slave_addr = setting32.slave_addr;
slave_info->power_setting_array.size =
setting32.power_setting_array.size;
slave_info->power_setting_array.size_down =
setting32.power_setting_array.size_down;
slave_info->power_setting_array.size_down =
setting32.power_setting_array.size_down;
slave_info->power_setting_array.power_setting =
compat_ptr(setting32.power_setting_array.power_setting);
slave_info->power_setting_array.power_down_setting =
compat_ptr(setting32.
power_setting_array.power_down_setting);
slave_info->is_init_params_valid =
setting32.is_init_params_valid;
slave_info->sensor_init_params = setting32.sensor_init_params;
slave_info->is_flash_supported = setting32.is_flash_supported;
} else
#endif
{
if (copy_from_user(slave_info,
(void *)setting, sizeof(*slave_info))) {
pr_err("failed: copy_from_user");
rc = -EFAULT;
goto free_slave_info;
}
}
/* Print slave info */
CDBG("camera id %d", slave_info->camera_id);
CDBG("slave_addr 0x%x", slave_info->slave_addr);
CDBG("addr_type %d", slave_info->addr_type);
CDBG("sensor_id_reg_addr 0x%x",
slave_info->sensor_id_info.sensor_id_reg_addr);
CDBG("sensor_id 0x%x", slave_info->sensor_id_info.sensor_id);
CDBG("size_a %d", slave_info->power_setting_array.size_a); //
CDBG("size %d", slave_info->power_setting_array.size);
CDBG("size down_a %d", slave_info->power_setting_array.size_down_a); //
CDBG("size down %d", slave_info->power_setting_array.size_down);
if (slave_info->is_init_params_valid) {
CDBG("position %d",
slave_info->sensor_init_params.position);
CDBG("mount %d",
slave_info->sensor_init_params.sensor_mount_angle);
}
/* Validate camera id */
if (slave_info->camera_id >= MAX_CAMERAS) {
pr_err("failed: invalid camera id %d max %d",
slave_info->camera_id, MAX_CAMERAS);
rc = -EINVAL;
goto free_slave_info;
}
/* Extract s_ctrl from camera id */
s_ctrl = g_sctrl[slave_info->camera_id];
if (!s_ctrl) {
pr_err("failed: s_ctrl %p for camera_id %d", s_ctrl,
slave_info->camera_id);
rc = -EINVAL;
goto free_slave_info;
}
CDBG("s_ctrl[%d] %p", slave_info->camera_id, s_ctrl);
if (s_ctrl->is_probe_succeed == 1) {
/*
* Different sensor on this camera slot has been connected
* and probe already succeeded for that sensor. Ignore this
* probe
*/
if (slave_info->sensor_id_info.sensor_id ==
s_ctrl->sensordata->cam_slave_info->
sensor_id_info.sensor_id) {
pr_err("slot%d: sensor id%d already probed\n",
slave_info->camera_id,
s_ctrl->sensordata->cam_slave_info->
sensor_id_info.sensor_id);
msm_sensor_fill_sensor_info(s_ctrl,
probed_info, entity_name);
} else
pr_err("slot %d has some other sensor\n",
slave_info->camera_id);
rc = 0;
goto free_slave_info;
}
rc = msm_sensor_get_power_settings(setting, slave_info,
&s_ctrl->sensordata->power_info);
if (rc < 0) {
pr_err("failed");
goto free_slave_info;
}
camera_info = kzalloc(sizeof(struct msm_camera_slave_info), GFP_KERNEL);
if (!camera_info) {
pr_err("failed: no memory slave_info %p", camera_info);
goto free_slave_info;
}
s_ctrl->sensordata->slave_info = camera_info;
/* Fill sensor slave info */
camera_info->sensor_slave_addr = slave_info->slave_addr;
camera_info->sensor_id_reg_addr =
slave_info->sensor_id_info.sensor_id_reg_addr;
camera_info->sensor_id = slave_info->sensor_id_info.sensor_id;
/* Fill CCI master, slave address and CCI default params */
if (!s_ctrl->sensor_i2c_client) {
pr_err("failed: sensor_i2c_client %p",
s_ctrl->sensor_i2c_client);
rc = -EINVAL;
goto free_camera_info;
}
/* Fill sensor address type */
s_ctrl->sensor_i2c_client->addr_type = slave_info->addr_type;
if (s_ctrl->sensor_i2c_client->client)
s_ctrl->sensor_i2c_client->client->addr =
camera_info->sensor_slave_addr;
cci_client = s_ctrl->sensor_i2c_client->cci_client;
if (!cci_client) {
pr_err("failed: cci_client %p", cci_client);
goto free_camera_info;
}
cci_client->cci_i2c_master = s_ctrl->cci_i2c_master;
cci_client->sid = slave_info->slave_addr >> 1;
cci_client->retries = 3;
cci_client->id_map = 0;
cci_client->i2c_freq_mode = slave_info->i2c_freq_mode;
/* Parse and fill vreg params for powerup settings */
rc = msm_camera_fill_vreg_params(
s_ctrl->sensordata->power_info.cam_vreg,
s_ctrl->sensordata->power_info.num_vreg,
s_ctrl->sensordata->power_info.power_setting,
s_ctrl->sensordata->power_info.power_setting_size);
if (rc < 0) {
pr_err("failed: msm_camera_get_dt_power_setting_data rc %d",
rc);
goto free_camera_info;
}
/* Parse and fill vreg params for powerdown settings*/
rc = msm_camera_fill_vreg_params(
s_ctrl->sensordata->power_info.cam_vreg,
s_ctrl->sensordata->power_info.num_vreg,
s_ctrl->sensordata->power_info.power_down_setting,
s_ctrl->sensordata->power_info.power_down_setting_size);
if (rc < 0) {
pr_err("failed: msm_camera_fill_vreg_params for PDOWN rc %d",
rc);
goto free_camera_info;
}
/* Update sensor, actuator and eeprom name in
* sensor control structure */
s_ctrl->sensordata->sensor_name = slave_info->sensor_name;
s_ctrl->sensordata->eeprom_name = slave_info->eeprom_name;
s_ctrl->sensordata->actuator_name = slave_info->actuator_name;
s_ctrl->sensordata->ois_name = slave_info->ois_name;
/*
* Update eeporm subdevice Id by input eeprom name
*/
rc = msm_sensor_fill_eeprom_subdevid_by_name(s_ctrl);
if (rc < 0) {
pr_err("%s failed %d\n", __func__, __LINE__);
goto free_camera_info;
}
/*
* Update actuator subdevice Id by input actuator name
*/
rc = msm_sensor_fill_actuator_subdevid_by_name(s_ctrl);
if (rc < 0) {
pr_err("%s failed %d\n", __func__, __LINE__);
goto free_camera_info;
}
rc = msm_sensor_fill_ois_subdevid_by_name(s_ctrl);
if (rc < 0) {
pr_err("%s failed %d\n", __func__, __LINE__);
goto free_camera_info;
}
#if defined(CONFIG_LG_PROXY)
rc = msm_sensor_fill_proxy_subdevid_by_name(s_ctrl);
if (rc < 0) {
pr_err("%s failed %d\n", __func__, __LINE__);
goto free_camera_info;
}
#endif
/* Power up and probe sensor */
rc = s_ctrl->func_tbl->sensor_power_up(s_ctrl);
if (rc < 0) {
pr_err("%s power up failed", slave_info->sensor_name);
goto free_camera_info;
}
pr_err("%s probe succeeded", slave_info->sensor_name);
/*
Set probe succeeded flag to 1 so that no other camera shall
* probed on this slot
*/
s_ctrl->is_probe_succeed = 1;
/*
* Update the subdevice id of flash-src based on availability in kernel.
*/
if (slave_info->is_flash_supported == 0) {
s_ctrl->sensordata->sensor_info->
subdev_id[SUB_MODULE_LED_FLASH] = -1;
}
/*
* Create /dev/videoX node, comment for now until dummy /dev/videoX
* node is created and used by HAL
*/
if (s_ctrl->sensor_device_type == MSM_CAMERA_PLATFORM_DEVICE)
rc = msm_sensor_driver_create_v4l_subdev(s_ctrl);
else
rc = msm_sensor_driver_create_i2c_v4l_subdev(s_ctrl);
if (rc < 0) {
pr_err("failed: camera creat v4l2 rc %d", rc);
goto camera_power_down;
}
/* Power down */
s_ctrl->func_tbl->sensor_power_down(s_ctrl);
rc = msm_sensor_fill_slave_info_init_params(
slave_info,
s_ctrl->sensordata->sensor_info);
if (rc < 0) {
pr_err("%s Fill slave info failed", slave_info->sensor_name);
goto free_camera_info;
}
rc = msm_sensor_validate_slave_info(s_ctrl->sensordata->sensor_info);
if (rc < 0) {
pr_err("%s Validate slave info failed",
slave_info->sensor_name);
goto free_camera_info;
}
/* Update sensor mount angle and position in media entity flag */
mount_pos = s_ctrl->sensordata->sensor_info->position << 16;
mount_pos = mount_pos | ((s_ctrl->sensordata->sensor_info->
sensor_mount_angle / 90) << 8);
s_ctrl->msm_sd.sd.entity.flags = mount_pos | MEDIA_ENT_FL_DEFAULT;
/*Save sensor info*/
s_ctrl->sensordata->cam_slave_info = slave_info;
msm_sensor_fill_sensor_info(s_ctrl, probed_info, entity_name);
return rc;
camera_power_down:
s_ctrl->func_tbl->sensor_power_down(s_ctrl);
free_camera_info:
kfree(camera_info);
free_slave_info:
kfree(slave_info);
return rc;
}
int rt5677_ioctl_common(struct snd_hwdep *hw, struct file *file,
unsigned int cmd, unsigned long arg)
{
struct snd_soc_codec *codec = hw->private_data;
struct rt5677_priv *rt5677 = snd_soc_codec_get_drvdata(codec);
struct rt_codec_cmd __user *_rt_codec = (struct rt_codec_cmd *)arg;
struct rt_codec_cmd rt_codec;
int ret = -EFAULT;
u32 addr = RT5677_MIC_BUF_ADDR;
size_t size;
u32 mic_write_offset;
size_t bytes_to_user = 0;
size_t first_chunk_start, first_chunk_len;
size_t second_chunk_start, second_chunk_len;
#ifdef CONFIG_COMPAT
if (is_compat_task()) {
struct compat_rt_codec_cmd compat_rt_codec;
if (copy_from_user(&compat_rt_codec, _rt_codec,
sizeof(compat_rt_codec)))
return -EFAULT;
rt_codec.number = compat_rt_codec.number;
rt_codec.buf = compat_ptr(compat_rt_codec.buf);
} else
#endif
{
if (copy_from_user(&rt_codec, _rt_codec, sizeof(rt_codec)))
return -EFAULT;
}
dev_dbg(codec->dev, "%s: rt_codec.number=%zu, cmd=%u\n",
__func__, rt_codec.number, cmd);
size = sizeof(int) * rt_codec.number;
switch (cmd) {
case RT_READ_CODEC_DSP_IOCTL:
case RT_READ_CODEC_DSP_IOCTL_COMPAT:
/* Grab the first 4 bytes that holds the write pointer on the
dsp, and check to make sure that it points somewhere inside
the buffer. */
ret = rt5677_spi_read(addr, rt5677->mic_buf, 4);
if (ret)
return ret;
mic_write_offset = le32_to_cpup((u32 *)rt5677->mic_buf);
if (mic_write_offset < sizeof(u32) ||
mic_write_offset >= RT5677_MIC_BUF_SIZE) {
dev_err(codec->dev,
"Invalid offset in the mic buffer %d\n",
mic_write_offset);
return -EFAULT;
}
/* If the mic_read_offset is zero, this means it's the first
time that we've asked for streaming data. We should start
reading from the previous 2 seconds of audio from wherever
the mic_write_offset is currently (note that this needs to
wraparound the buffer). */
if (rt5677->mic_read_offset == 0) {
if (mic_write_offset <
RT5677_MIC_BUF_FIRST_READ_SIZE + sizeof(u32)) {
rt5677->mic_read_offset = (RT5677_MIC_BUF_SIZE -
(RT5677_MIC_BUF_FIRST_READ_SIZE -
(mic_write_offset - sizeof(u32))));
} else {
rt5677->mic_read_offset = (mic_write_offset -
RT5677_MIC_BUF_FIRST_READ_SIZE);
}
}
/* If the audio wrapped around, then we need to do the copy in
two passes, otherwise, we can do it on one. We should also
make sure that we don't read more bytes than we have in the
user buffer, or we'll just waste time. */
if (mic_write_offset < rt5677->mic_read_offset) {
/* Copy the audio from the last read offset until the
end of the buffer, then do the second chunk that
starts after the u32. */
first_chunk_start = rt5677->mic_read_offset;
first_chunk_len =
RT5677_MIC_BUF_SIZE - rt5677->mic_read_offset;
if (first_chunk_len > size) {
first_chunk_len = size;
second_chunk_start = 0;
second_chunk_len = 0;
} else {
second_chunk_start = sizeof(u32);
second_chunk_len =
mic_write_offset - sizeof(u32);
if (first_chunk_len + second_chunk_len > size) {
second_chunk_len =
size - first_chunk_len;
}
}
} else {
first_chunk_start = rt5677->mic_read_offset;
first_chunk_len =
mic_write_offset - rt5677->mic_read_offset;
if (first_chunk_len > size)
first_chunk_len = size;
second_chunk_start = 0;
second_chunk_len = 0;
}
ret = rt5677_spi_read(addr + first_chunk_start, rt5677->mic_buf,
first_chunk_len);
if (ret)
return ret;
bytes_to_user += first_chunk_len;
if (second_chunk_len) {
ret = rt5677_spi_read(addr + second_chunk_start,
rt5677->mic_buf + first_chunk_len,
second_chunk_len);
if (!ret)
bytes_to_user += second_chunk_len;
}
bytes_to_user -= copy_to_user(rt_codec.buf, rt5677->mic_buf,
bytes_to_user);
rt5677->mic_read_offset += bytes_to_user;
if (rt5677->mic_read_offset >= RT5677_MIC_BUF_SIZE) {
rt5677->mic_read_offset -=
RT5677_MIC_BUF_SIZE - sizeof(u32);
}
return bytes_to_user >> 1;
case RT_WRITE_CODEC_DSP_IOCTL:
case RT_WRITE_CODEC_DSP_IOCTL_COMPAT:
if (!rt5677->model_buf || rt5677->model_len < size) {
vfree(rt5677->model_buf);
rt5677->model_len = 0;
rt5677->model_buf = vmalloc(size);
if (!rt5677->model_buf)
return -ENOMEM;
}
if (copy_from_user(rt5677->model_buf, rt_codec.buf, size))
return -EFAULT;
rt5677->model_len = size;
return 0;
default:
return -ENOTSUPP;
}
}
long arch_ptrace(struct task_struct *child, long request,
unsigned long addr, unsigned long data)
{
unsigned long __user *datap = (long __user __force *)data;
unsigned long tmp;
long ret = -EIO;
char *childreg;
struct pt_regs copyregs;
switch (request) {
case PTRACE_PEEKUSR: /* Read register from pt_regs. */
if (addr >= PTREGS_SIZE)
break;
childreg = getregs(child, ©regs) + addr;
#ifdef CONFIG_COMPAT
if (is_compat_task()) {
if (addr & (sizeof(compat_long_t)-1))
break;
ret = put_user(*(compat_long_t *)childreg,
(compat_long_t __user *)datap);
} else
#endif
{
if (addr & (sizeof(long)-1))
break;
ret = put_user(*(long *)childreg, datap);
}
break;
case PTRACE_POKEUSR: /* Write register in pt_regs. */
if (addr >= PTREGS_SIZE)
break;
childreg = getregs(child, ©regs) + addr;
#ifdef CONFIG_COMPAT
if (is_compat_task()) {
if (addr & (sizeof(compat_long_t)-1))
break;
*(compat_long_t *)childreg = data;
} else
#endif
{
if (addr & (sizeof(long)-1))
break;
*(long *)childreg = data;
}
putregs(child, ©regs);
ret = 0;
break;
case PTRACE_GETREGS: /* Get all registers from the child. */
ret = copy_regset_to_user(child, &tile_user_regset_view,
REGSET_GPR, 0,
sizeof(struct pt_regs), datap);
break;
case PTRACE_SETREGS: /* Set all registers in the child. */
ret = copy_regset_from_user(child, &tile_user_regset_view,
REGSET_GPR, 0,
sizeof(struct pt_regs), datap);
break;
case PTRACE_GETFPREGS: /* Get the child FPU state. */
case PTRACE_SETFPREGS: /* Set the child FPU state. */
break;
case PTRACE_SETOPTIONS:
/* Support TILE-specific ptrace options. */
BUILD_BUG_ON(PTRACE_O_MASK_TILE & PTRACE_O_MASK);
tmp = data & PTRACE_O_MASK_TILE;
data &= ~PTRACE_O_MASK_TILE;
ret = ptrace_request(child, request, addr, data);
if (ret == 0) {
unsigned int flags = child->ptrace;
flags &= ~(PTRACE_O_MASK_TILE << PT_OPT_FLAG_SHIFT);
flags |= (tmp << PT_OPT_FLAG_SHIFT);
child->ptrace = flags;
}
break;
default:
#ifdef CONFIG_COMPAT
if (task_thread_info(current)->status & TS_COMPAT) {
ret = compat_ptrace_request(child, request,
addr, data);
break;
}
#endif
ret = ptrace_request(child, request, addr, data);
break;
}
return ret;
}
int copy_thread(unsigned long clone_flags, unsigned long new_stackp,
unsigned long arg, struct task_struct *p)
{
struct thread_info *ti;
struct fake_frame
{
struct stack_frame sf;
struct pt_regs childregs;
} *frame;
frame = container_of(task_pt_regs(p), struct fake_frame, childregs);
p->thread.ksp = (unsigned long) frame;
/* Save access registers to new thread structure. */
save_access_regs(&p->thread.acrs[0]);
/* start new process with ar4 pointing to the correct address space */
p->thread.mm_segment = get_fs();
/* Don't copy debug registers */
memset(&p->thread.per_user, 0, sizeof(p->thread.per_user));
memset(&p->thread.per_event, 0, sizeof(p->thread.per_event));
clear_tsk_thread_flag(p, TIF_SINGLE_STEP);
/* Initialize per thread user and system timer values */
ti = task_thread_info(p);
ti->user_timer = 0;
ti->system_timer = 0;
frame->sf.back_chain = 0;
/* new return point is ret_from_fork */
frame->sf.gprs[8] = (unsigned long) ret_from_fork;
/* fake return stack for resume(), don't go back to schedule */
frame->sf.gprs[9] = (unsigned long) frame;
/* Store access registers to kernel stack of new process. */
if (unlikely(p->flags & PF_KTHREAD)) {
/* kernel thread */
memset(&frame->childregs, 0, sizeof(struct pt_regs));
frame->childregs.psw.mask = PSW_KERNEL_BITS | PSW_MASK_DAT |
PSW_MASK_IO | PSW_MASK_EXT | PSW_MASK_MCHECK;
frame->childregs.psw.addr = PSW_ADDR_AMODE |
(unsigned long) kernel_thread_starter;
frame->childregs.gprs[9] = new_stackp; /* function */
frame->childregs.gprs[10] = arg;
frame->childregs.gprs[11] = (unsigned long) do_exit;
frame->childregs.orig_gpr2 = -1;
return 0;
}
frame->childregs = *current_pt_regs();
frame->childregs.gprs[2] = 0; /* child returns 0 on fork. */
frame->childregs.flags = 0;
if (new_stackp)
frame->childregs.gprs[15] = new_stackp;
/* Don't copy runtime instrumentation info */
p->thread.ri_cb = NULL;
frame->childregs.psw.mask &= ~PSW_MASK_RI;
/* Set a new TLS ? */
if (clone_flags & CLONE_SETTLS) {
unsigned long tls = frame->childregs.gprs[6];
if (is_compat_task()) {
p->thread.acrs[0] = (unsigned int)tls;
} else {
p->thread.acrs[0] = (unsigned int)(tls >> 32);
p->thread.acrs[1] = (unsigned int)tls;
}
}
/*
* Note that 'init' is a special process: it doesn't get signals it doesn't
* want to handle. Thus you cannot kill init even with a SIGKILL even by
* mistake.
*
* Note that we go through the signals twice: once to check the signals that
* the kernel can handle, and then we build all the user-level signal handling
* stack-frames in one go after that.
*/
void do_signal(struct pt_regs *regs)
{
siginfo_t info;
int signr;
struct k_sigaction ka;
sigset_t *oldset;
/*
* We want the common case to go fast, which
* is why we may in certain cases get here from
* kernel mode. Just return without doing anything
* if so.
*/
if (!user_mode(regs))
return;
if (test_thread_flag(TIF_RESTORE_SIGMASK))
oldset = ¤t->saved_sigmask;
else
oldset = ¤t->blocked;
/*
* Get signal to deliver. When running under ptrace, at this point
* the debugger may change all our registers, including the system
* call information.
*/
current_thread_info()->system_call =
test_thread_flag(TIF_SYSCALL) ? regs->int_code : 0;
signr = get_signal_to_deliver(&info, &ka, regs, NULL);
if (signr > 0) {
/* Whee! Actually deliver the signal. */
if (current_thread_info()->system_call) {
regs->int_code = current_thread_info()->system_call;
/* Check for system call restarting. */
switch (regs->gprs[2]) {
case -ERESTART_RESTARTBLOCK:
case -ERESTARTNOHAND:
regs->gprs[2] = -EINTR;
break;
case -ERESTARTSYS:
if (!(ka.sa.sa_flags & SA_RESTART)) {
regs->gprs[2] = -EINTR;
break;
}
/* fallthrough */
case -ERESTARTNOINTR:
regs->gprs[2] = regs->orig_gpr2;
regs->psw.addr =
__rewind_psw(regs->psw,
regs->int_code >> 16);
break;
}
}
/* No longer in a system call */
clear_thread_flag(TIF_SYSCALL);
if ((is_compat_task() ?
handle_signal32(signr, &ka, &info, oldset, regs) :
handle_signal(signr, &ka, &info, oldset, regs)) == 0) {
/*
* A signal was successfully delivered; the saved
* sigmask will have been stored in the signal frame,
* and will be restored by sigreturn, so we can simply
* clear the TIF_RESTORE_SIGMASK flag.
*/
if (test_thread_flag(TIF_RESTORE_SIGMASK))
clear_thread_flag(TIF_RESTORE_SIGMASK);
/*
* Let tracing know that we've done the handler setup.
*/
tracehook_signal_handler(signr, &info, &ka, regs,
test_thread_flag(TIF_SINGLE_STEP));
}
return;
}
long arch_ptrace(struct task_struct *child, long request, long addr, long data)
{
unsigned long __user *datap = (long __user __force *)data;
unsigned long tmp;
long ret = -EIO;
char *childreg;
struct pt_regs copyregs;
int ex1_offset;
switch (request) {
case PTRACE_PEEKUSR: /* Read register from pt_regs. */
if (addr < 0 || addr >= PTREGS_SIZE)
break;
childreg = (char *)task_pt_regs(child) + addr;
#ifdef CONFIG_COMPAT
if (is_compat_task()) {
if (addr & (sizeof(compat_long_t)-1))
break;
ret = put_user(*(compat_long_t *)childreg,
(compat_long_t __user *)datap);
} else
#endif
{
if (addr & (sizeof(long)-1))
break;
ret = put_user(*(long *)childreg, datap);
}
break;
case PTRACE_POKEUSR: /* Write register in pt_regs. */
if (addr < 0 || addr >= PTREGS_SIZE)
break;
childreg = (char *)task_pt_regs(child) + addr;
/* Guard against overwrites of the privilege level. */
ex1_offset = PTREGS_OFFSET_EX1;
#if defined(CONFIG_COMPAT) && defined(__BIG_ENDIAN)
if (is_compat_task()) /* point at low word */
ex1_offset += sizeof(compat_long_t);
#endif
if (addr == ex1_offset)
data = PL_ICS_EX1(USER_PL, EX1_ICS(data));
#ifdef CONFIG_COMPAT
if (is_compat_task()) {
if (addr & (sizeof(compat_long_t)-1))
break;
*(compat_long_t *)childreg = data;
} else
#endif
{
if (addr & (sizeof(long)-1))
break;
*(long *)childreg = data;
}
ret = 0;
break;
case PTRACE_GETREGS: /* Get all registers from the child. */
if (copy_to_user(datap, task_pt_regs(child),
sizeof(struct pt_regs)) == 0) {
ret = 0;
}
break;
case PTRACE_SETREGS: /* Set all registers in the child. */
if (copy_from_user(©regs, datap,
sizeof(struct pt_regs)) == 0) {
copyregs.ex1 =
PL_ICS_EX1(USER_PL, EX1_ICS(copyregs.ex1));
*task_pt_regs(child) = copyregs;
ret = 0;
}
break;
case PTRACE_GETFPREGS: /* Get the child FPU state. */
case PTRACE_SETFPREGS: /* Set the child FPU state. */
break;
case PTRACE_SETOPTIONS:
/* Support TILE-specific ptrace options. */
child->ptrace &= ~PT_TRACE_MASK_TILE;
tmp = data & PTRACE_O_MASK_TILE;
data &= ~PTRACE_O_MASK_TILE;
ret = ptrace_request(child, request, addr, data);
if (tmp & PTRACE_O_TRACEMIGRATE)
child->ptrace |= PT_TRACE_MIGRATE;
break;
default:
#ifdef CONFIG_COMPAT
if (task_thread_info(current)->status & TS_COMPAT) {
ret = compat_ptrace_request(child, request,
addr, data);
break;
}
#endif
ret = ptrace_request(child, request, addr, data);
break;
}
return ret;
}
/* static function definition */
int32_t msm_sensor_driver_probe(void *setting,
struct msm_sensor_info_t *probed_info, char *entity_name)
{
int32_t rc = 0;
struct msm_sensor_ctrl_t *s_ctrl = NULL;
struct msm_camera_cci_client *cci_client = NULL;
struct msm_camera_sensor_slave_info *slave_info = NULL;
struct msm_camera_slave_info *camera_info = NULL;
unsigned long mount_pos = 0;
/* Validate input parameters */
if (!setting) {
pr_err("failed: slave_info %p", setting);
return -EINVAL;
}
/* Allocate memory for slave info */
slave_info = kzalloc(sizeof(*slave_info), GFP_KERNEL);
if (!slave_info) {
pr_err("failed: no memory slave_info %p", slave_info);
return -ENOMEM;
}
#ifdef CONFIG_COMPAT
if (is_compat_task()) {
struct msm_camera_sensor_slave_info32 setting32;
if (copy_from_user((void *)&setting32, setting,
sizeof(setting32))) {
pr_err("failed: copy_from_user");
rc = -EFAULT;
goto free_slave_info;
}
strlcpy(slave_info->actuator_name, setting32.actuator_name,
sizeof(slave_info->actuator_name));
strlcpy(slave_info->eeprom_name, setting32.eeprom_name,
sizeof(slave_info->eeprom_name));
strlcpy(slave_info->sensor_name, setting32.sensor_name,
sizeof(slave_info->sensor_name));
strlcpy(slave_info->ois_name, setting32.ois_name,
sizeof(slave_info->ois_name));
strlcpy(slave_info->flash_name, setting32.flash_name,
sizeof(slave_info->flash_name));
slave_info->addr_type = setting32.addr_type;
slave_info->camera_id = setting32.camera_id;
slave_info->i2c_freq_mode = setting32.i2c_freq_mode;
slave_info->sensor_id_info = setting32.sensor_id_info;
slave_info->slave_addr = setting32.slave_addr;
slave_info->power_setting_array.size =
setting32.power_setting_array.size;
slave_info->power_setting_array.size_down =
setting32.power_setting_array.size_down;
slave_info->power_setting_array.size_down =
setting32.power_setting_array.size_down;
slave_info->power_setting_array.power_setting =
compat_ptr(setting32.power_setting_array.power_setting);
slave_info->power_setting_array.power_down_setting =
compat_ptr(setting32.
power_setting_array.power_down_setting);
slave_info->is_init_params_valid =
setting32.is_init_params_valid;
slave_info->sensor_init_params = setting32.sensor_init_params;
slave_info->is_flash_supported = setting32.is_flash_supported;
} else
#endif
{
if (copy_from_user(slave_info,
(void *)setting, sizeof(*slave_info))) {
pr_err("failed: copy_from_user");
rc = -EFAULT;
goto free_slave_info;
}
}
/* Print slave info */
CDBG("camera id %d", slave_info->camera_id);
CDBG("slave_addr 0x%x", slave_info->slave_addr);
CDBG("addr_type %d", slave_info->addr_type);
CDBG("sensor_id_reg_addr 0x%x",
slave_info->sensor_id_info.sensor_id_reg_addr);
CDBG("sensor_id 0x%x", slave_info->sensor_id_info.sensor_id);
CDBG("size %d", slave_info->power_setting_array.size);
CDBG("size down %d", slave_info->power_setting_array.size_down);
if (slave_info->is_init_params_valid) {
CDBG("position %d",
slave_info->sensor_init_params.position);
CDBG("mount %d",
slave_info->sensor_init_params.sensor_mount_angle);
}
/* Validate camera id */
if (slave_info->camera_id >= MAX_CAMERAS) {
pr_err("failed: invalid camera id %d max %d",
slave_info->camera_id, MAX_CAMERAS);
rc = -EINVAL;
goto free_slave_info;
}
/* Extract s_ctrl from camera id */
s_ctrl = g_sctrl[slave_info->camera_id];
if (!s_ctrl) {
pr_err("failed: s_ctrl %p for camera_id %d", s_ctrl,
slave_info->camera_id);
rc = -EINVAL;
goto free_slave_info;
}
CDBG("s_ctrl[%d] %p", slave_info->camera_id, s_ctrl);
if (s_ctrl->is_probe_succeed == 1) {
/*
* Different sensor on this camera slot has been connected
* and probe already succeeded for that sensor. Ignore this
* probe
*/
if (slave_info->sensor_id_info.sensor_id ==
s_ctrl->sensordata->cam_slave_info->
sensor_id_info.sensor_id) {
pr_err("slot%d: sensor id%d already probed\n",
slave_info->camera_id,
s_ctrl->sensordata->cam_slave_info->
sensor_id_info.sensor_id);
msm_sensor_fill_sensor_info(s_ctrl,
probed_info, entity_name);
} else
pr_err("slot %d has some other sensor\n",
slave_info->camera_id);
rc = 0;
goto free_slave_info;
}
rc = msm_sensor_get_power_settings(setting, slave_info,
&s_ctrl->sensordata->power_info);
if (rc < 0) {
pr_err("failed");
goto free_slave_info;
}
camera_info = kzalloc(sizeof(struct msm_camera_slave_info), GFP_KERNEL);
if (!camera_info) {
pr_err("failed: no memory slave_info %p", camera_info);
goto free_slave_info;
}
s_ctrl->sensordata->slave_info = camera_info;
/* Fill sensor slave info */
camera_info->sensor_slave_addr = slave_info->slave_addr;
camera_info->sensor_id_reg_addr =
slave_info->sensor_id_info.sensor_id_reg_addr;
camera_info->sensor_id = slave_info->sensor_id_info.sensor_id;
/* Fill CCI master, slave address and CCI default params */
if (!s_ctrl->sensor_i2c_client) {
pr_err("failed: sensor_i2c_client %p",
s_ctrl->sensor_i2c_client);
rc = -EINVAL;
goto free_camera_info;
}
/* Fill sensor address type */
s_ctrl->sensor_i2c_client->addr_type = slave_info->addr_type;
if (s_ctrl->sensor_i2c_client->client)
s_ctrl->sensor_i2c_client->client->addr =
camera_info->sensor_slave_addr;
cci_client = s_ctrl->sensor_i2c_client->cci_client;
if (!cci_client) {
pr_err("failed: cci_client %p", cci_client);
goto free_camera_info;
}
cci_client->cci_i2c_master = s_ctrl->cci_i2c_master;
cci_client->sid = slave_info->slave_addr >> 1;
cci_client->retries = 3;
cci_client->id_map = 0;
cci_client->i2c_freq_mode = slave_info->i2c_freq_mode;
/* Parse and fill vreg params for powerup settings */
rc = msm_camera_fill_vreg_params(
s_ctrl->sensordata->power_info.cam_vreg,
s_ctrl->sensordata->power_info.num_vreg,
s_ctrl->sensordata->power_info.power_setting,
s_ctrl->sensordata->power_info.power_setting_size);
if (rc < 0) {
pr_err("failed: msm_camera_get_dt_power_setting_data rc %d",
rc);
goto free_camera_info;
}
/* Parse and fill vreg params for powerdown settings*/
rc = msm_camera_fill_vreg_params(
s_ctrl->sensordata->power_info.cam_vreg,
s_ctrl->sensordata->power_info.num_vreg,
s_ctrl->sensordata->power_info.power_down_setting,
s_ctrl->sensordata->power_info.power_down_setting_size);
if (rc < 0) {
pr_err("failed: msm_camera_fill_vreg_params for PDOWN rc %d",
rc);
goto free_camera_info;
}
/* Update sensor, actuator and eeprom name in
* sensor control structure */
s_ctrl->sensordata->sensor_name = slave_info->sensor_name;
s_ctrl->sensordata->eeprom_name = slave_info->eeprom_name;
s_ctrl->sensordata->actuator_name = slave_info->actuator_name;
s_ctrl->sensordata->ois_name = slave_info->ois_name;
/*
* Update eeporm subdevice Id by input eeprom name
*/
rc = msm_sensor_fill_eeprom_subdevid_by_name(s_ctrl);
if (rc < 0) {
pr_err("%s failed %d\n", __func__, __LINE__);
goto free_camera_info;
}
/*
* Update actuator subdevice Id by input actuator name
*/
rc = msm_sensor_fill_actuator_subdevid_by_name(s_ctrl);
if (rc < 0) {
pr_err("%s failed %d\n", __func__, __LINE__);
goto free_camera_info;
}
rc = msm_sensor_fill_ois_subdevid_by_name(s_ctrl);
if (rc < 0) {
pr_err("%s failed %d\n", __func__, __LINE__);
goto free_camera_info;
}
#ifdef CONFIG_TCT_8X16_ALTO5
if (!strcmp(s_ctrl->sensordata->sensor_name, "ov5670_truly_ff") ||
!strcmp(s_ctrl->sensordata->sensor_name, "ov5670_truly"))
{
printk(KERN_DEBUG"%s:%d, free gpio %d for gpio_vdig\n", __func__, __LINE__,
s_ctrl->sensordata->power_info.gpio_conf->gpio_num_info->gpio_num[SENSOR_GPIO_VDIG]);
gpio_request(s_ctrl->sensordata->power_info.gpio_conf->gpio_num_info->gpio_num[SENSOR_GPIO_VDIG],
s_ctrl->sensordata->sensor_name);
gpio_free(s_ctrl->sensordata->power_info.gpio_conf->gpio_num_info->gpio_num[SENSOR_GPIO_VDIG]);
}
#endif // CONFIG_TCT_8X16_ALTO5
/* Power up and probe sensor */
rc = s_ctrl->func_tbl->sensor_power_up(s_ctrl);
if (rc < 0) {
pr_err("%s power up failed", slave_info->sensor_name);
goto free_camera_info;
}
#if defined(CONFIG_TCT_8X16_ALTO45_LATAM_B28)
/*
* Update actuator subdevice Id by input actuator name
*/
rc = msm_sensor_fill_actuator_subdevid_by_name(s_ctrl);
if (rc < 0) {
pr_err("%s failed %d\n", __func__, __LINE__);
goto free_camera_info;
}
#endif
/* add by [email protected], distinguish OV5670 Truly FF/AF module
through OTP VCM ID, 2014.8.13 */
#ifdef CONFIG_TCT_8X16_ALTO5
if (!strcmp(s_ctrl->sensordata->sensor_name, "ov5670_truly_ff") &&
ov5670_truly_otp_get_vcm_id(s_ctrl)) {
printk(KERN_ERR"%s:%d, detect error: ov5670 truly FF module have VCM ID\n",
__func__, __LINE__);
goto camera_power_down;
}
if (!strcmp(s_ctrl->sensordata->sensor_name, "ov5670_truly") &&
!ov5670_truly_otp_get_vcm_id(s_ctrl)) {
printk(KERN_ERR"%s:%d, detect error: ov5670 truly AF module have not VCM ID\n",
__func__, __LINE__);
goto camera_power_down;
}
#endif // CONFIG_TCT_8X16_ALTO5
//[PLATFROM]-ADD-SATRT TCTSZ.ZKX 2014.08.27
#ifdef CONFIG_TCT_8X16_POP10
if (!strcmp(s_ctrl->sensordata->sensor_name, "ov5670_truly_cm9607")){
uint16_t vcm_id;
vcm_id = ov5670_truly_otp_get_vcm_id(s_ctrl);
printk(KERN_ERR"%s, %d,vcm_id %d\n",__func__, __LINE__,vcm_id);
if(vcm_id != 0x00){
printk(KERN_ERR"%s:%d, detect error: ov5670 truly FF module have not VCM ID\n",
__func__, __LINE__);
goto camera_power_down;
}
}
printk("%s, this a %s\n",__func__,s_ctrl->sensordata->sensor_name);
if (!strcmp(s_ctrl->sensordata->sensor_name, "s5k5e2_sunny_p5s12e")){
if(s5k5e2_check_module(s_ctrl->sensor_i2c_client)==0x13){//FF camera should not have vcm id
printk("%s:%d, camera is not %s!!!\n",__func__, __LINE__,s_ctrl->sensordata->sensor_name);
goto camera_power_down;
}
else{
printk("%s:%d, camera is %s!!!\n",__func__, __LINE__,s_ctrl->sensordata->sensor_name);
}
}
else if(!strcmp(s_ctrl->sensordata->sensor_name, "s5k5e2_sunny_p5s13b")){
if(s5k5e2_check_module(s_ctrl->sensor_i2c_client)!=0x13){//AF camera should have vcm id, this module VCM id is 0x13
printk("%s:%d, camera is not %s!!!\n",__func__, __LINE__,s_ctrl->sensordata->sensor_name);
goto CAMERA_POWER_DOWN;
}
else{
printk("%s:%d, camera is %s!!!\n",__func__, __LINE__,s_ctrl->sensordata->sensor_name);
}
}
#endif // CONFIG_TCT_8X16_POP10
//[PLATFROM]-ADD-END TCTSZ.ZKX
pr_err("%s probe succeeded", slave_info->sensor_name);
/*
Set probe succeeded flag to 1 so that no other camera shall
* probed on this slot
*/
s_ctrl->is_probe_succeed = 1;
/*
* Update the subdevice id of flash-src based on availability in kernel.
*/
if (slave_info->is_flash_supported == 0) {
s_ctrl->sensordata->sensor_info->
subdev_id[SUB_MODULE_LED_FLASH] = -1;
}
/*
* Create /dev/videoX node, comment for now until dummy /dev/videoX
* node is created and used by HAL
*/
if (s_ctrl->sensor_device_type == MSM_CAMERA_PLATFORM_DEVICE)
rc = msm_sensor_driver_create_v4l_subdev(s_ctrl);
else
rc = msm_sensor_driver_create_i2c_v4l_subdev(s_ctrl);
if (rc < 0) {
pr_err("failed: camera creat v4l2 rc %d", rc);
goto camera_power_down;
}
/* Power down */
s_ctrl->func_tbl->sensor_power_down(s_ctrl);
rc = msm_sensor_fill_slave_info_init_params(
slave_info,
s_ctrl->sensordata->sensor_info);
if (rc < 0) {
pr_err("%s Fill slave info failed", slave_info->sensor_name);
goto free_camera_info;
}
rc = msm_sensor_validate_slave_info(s_ctrl->sensordata->sensor_info);
if (rc < 0) {
pr_err("%s Validate slave info failed",
slave_info->sensor_name);
goto free_camera_info;
}
/* Update sensor mount angle and position in media entity flag */
mount_pos = s_ctrl->sensordata->sensor_info->position << 16;
mount_pos = mount_pos | ((s_ctrl->sensordata->sensor_info->
sensor_mount_angle / 90) << 8);
s_ctrl->msm_sd.sd.entity.flags = mount_pos | MEDIA_ENT_FL_DEFAULT;
/*Save sensor info*/
s_ctrl->sensordata->cam_slave_info = slave_info;
msm_sensor_fill_sensor_info(s_ctrl, probed_info, entity_name);
return rc;
camera_power_down:
s_ctrl->func_tbl->sensor_power_down(s_ctrl);
free_camera_info:
kfree(camera_info);
free_slave_info:
kfree(slave_info);
return rc;
}
IMG_VOID MEMMGR_dispatch(SYSBRG_sPacket *psPacket)
{
MEMMGR_sCmdMsg sCommandMsg;
MEMMGR_sRespMsg sResponseMsg;
if(SYSOSKM_CopyFromUser(&sCommandMsg, psPacket->pvCmdData, sizeof(sCommandMsg)))
IMG_ASSERT(!"failed to copy from user");
switch (sCommandMsg.eFuncId)
{
case WriteMemRefToMemRef_ID:
#if 0
#ifdef CONFIG_COMPAT
printk("bridge %d %s %s\n", is_compat_task(), __FUNCTION__, "WriteMemRefToMemRef");
#else
printk("bridge %s %s\n", __FUNCTION__, "WriteMemRefToMemRef");
#endif
#endif
WriteMemRefToMemRef(
sCommandMsg.sCmd.sWriteMemRefToMemRefCmd.hDeviceMem,
sCommandMsg.sCmd.sWriteMemRefToMemRefCmd.ui32Offset,
sCommandMsg.sCmd.sWriteMemRefToMemRefCmd.ui32ManglerFuncIdExt,
sCommandMsg.sCmd.sWriteMemRefToMemRefCmd.hRefDeviceMem,
sCommandMsg.sCmd.sWriteMemRefToMemRefCmd.ui32RefOffset
);
break;
case TOPAZKM_MMUMAllocateHeapDeviceMemory_ID:
#if 0
#ifdef CONFIG_COMPAT
printk("bridge %d %s %s\n", is_compat_task(), __FUNCTION__, "TOPAZKM_MMUMAllocateHeapDeviceMemory");
#else
printk("bridge %s %s\n", __FUNCTION__, "TOPAZKM_MMUMAllocateHeapDeviceMemory");
#endif
#endif
sResponseMsg.sResp.sTOPAZKM_MMUMAllocateHeapDeviceMemoryResp.xTOPAZKM_MMUMAllocateHeapDeviceMemoryResp =
TOPAZKM_MMUMAllocateHeapDeviceMemory(
sCommandMsg.sCmd.sTOPAZKM_MMUMAllocateHeapDeviceMemoryCmd.ui32Size,
sCommandMsg.sCmd.sTOPAZKM_MMUMAllocateHeapDeviceMemoryCmd.ui32Alignment,
sCommandMsg.sCmd.sTOPAZKM_MMUMAllocateHeapDeviceMemoryCmd.ui32Heap,
sCommandMsg.sCmd.sTOPAZKM_MMUMAllocateHeapDeviceMemoryCmd.bSaveRestore,
sCommandMsg.sCmd.sTOPAZKM_MMUMAllocateHeapDeviceMemoryCmd.ppMemInfo,
sCommandMsg.sCmd.sTOPAZKM_MMUMAllocateHeapDeviceMemoryCmd.tileSensetive
);
break;
case TOPAZKM_StreamMMUMAllocateHeapDeviceMemory_ID:
#if 0
#ifdef CONFIG_COMPAT
printk("bridge %d %s %s\n", is_compat_task(), __FUNCTION__, "TOPAZKM_StreamMMUMAllocateHeapDeviceMemory");
#else
printk("bridge %s %s\n", __FUNCTION__, "TOPAZKM_StreamMMUMAllocateHeapDeviceMemory");
#endif
#endif
sResponseMsg.sResp.sTOPAZKM_StreamMMUMAllocateHeapDeviceMemoryResp.xTOPAZKM_StreamMMUMAllocateHeapDeviceMemoryResp =
TOPAZKM_StreamMMUMAllocateHeapDeviceMemory(
sCommandMsg.sCmd.sTOPAZKM_StreamMMUMAllocateHeapDeviceMemoryCmd.ui32StreamId,
sCommandMsg.sCmd.sTOPAZKM_StreamMMUMAllocateHeapDeviceMemoryCmd.ui32Size,
sCommandMsg.sCmd.sTOPAZKM_StreamMMUMAllocateHeapDeviceMemoryCmd.ui32Alignment,
sCommandMsg.sCmd.sTOPAZKM_StreamMMUMAllocateHeapDeviceMemoryCmd.ui32Heap,
sCommandMsg.sCmd.sTOPAZKM_StreamMMUMAllocateHeapDeviceMemoryCmd.bSaveRestore,
sCommandMsg.sCmd.sTOPAZKM_StreamMMUMAllocateHeapDeviceMemoryCmd.ppMemInfo,
sCommandMsg.sCmd.sTOPAZKM_StreamMMUMAllocateHeapDeviceMemoryCmd.tileSensetive
);
break;
case TOPAZKM_MMUMFreeDeviceMemory_ID:
#if 0
#ifdef CONFIG_COMPAT
printk("bridge %d %s %s\n", is_compat_task(), __FUNCTION__, "TOPAZKM_MMUMFreeDeviceMemory");
#else
printk("bridge %s %s\n", __FUNCTION__, "TOPAZKM_MMUMFreeDeviceMemory");
#endif
#endif
sResponseMsg.sResp.sTOPAZKM_MMUMFreeDeviceMemoryResp.xTOPAZKM_MMUMFreeDeviceMemoryResp =
TOPAZKM_MMUMFreeDeviceMemory(
sCommandMsg.sCmd.sTOPAZKM_MMUMFreeDeviceMemoryCmd.pMemInfo
);
break;
case TOPAZKM_MMUFlushMMUTableCache_ID:
#if 0
#ifdef CONFIG_COMPAT
printk("bridge %d %s %s\n", is_compat_task(), __FUNCTION__, "TOPAZKM_MMUFlushMMUTableCache");
#else
printk("bridge %s %s\n", __FUNCTION__, "TOPAZKM_MMUFlushMMUTableCache");
#endif
#endif
sResponseMsg.sResp.sTOPAZKM_MMUFlushMMUTableCacheResp.xTOPAZKM_MMUFlushMMUTableCacheResp =
TOPAZKM_MMUFlushMMUTableCache(
);
break;
case TOPAZKM_MapExternal_ID:
#if 0
#ifdef CONFIG_COMPAT
printk("bridge %d %s %s\n", is_compat_task(), __FUNCTION__, "TOPAZKM_MapExternal");
#else
printk("bridge %s %s\n", __FUNCTION__, "TOPAZKM_MapExternal");
#endif
#endif
sResponseMsg.sResp.sTOPAZKM_MapExternalResp.xTOPAZKM_MapExternalResp =
TOPAZKM_MapExternal(
sCommandMsg.sCmd.sTOPAZKM_MapExternalCmd.ui32BufLen,
sCommandMsg.sCmd.sTOPAZKM_MapExternalCmd.ui32PallocId,
sCommandMsg.sCmd.sTOPAZKM_MapExternalCmd.ui32Heap,
sCommandMsg.sCmd.sTOPAZKM_MapExternalCmd.ui32Alignment,
sCommandMsg.sCmd.sTOPAZKM_MapExternalCmd.memInfo
);
break;
case TOPAZKM_UnMapExternal_ID:
#if 0
#ifdef CONFIG_COMPAT
printk("bridge %d %s %s\n", is_compat_task(), __FUNCTION__, "TOPAZKM_UnMapExternal");
#else
printk("bridge %s %s\n", __FUNCTION__, "TOPAZKM_UnMapExternal");
#endif
#endif
sResponseMsg.sResp.sTOPAZKM_UnMapExternalResp.xTOPAZKM_UnMapExternalResp =
TOPAZKM_UnMapExternal(
sCommandMsg.sCmd.sTOPAZKM_UnMapExternalCmd.memInfo
);
break;
case TOPAZKM_MMCopyTiledBuffer_ID:
#if 0
#ifdef CONFIG_COMPAT
printk("bridge %d %s %s\n", is_compat_task(), __FUNCTION__, "TOPAZKM_MMCopyTiledBuffer");
#else
printk("bridge %s %s\n", __FUNCTION__, "TOPAZKM_MMCopyTiledBuffer");
#endif
#endif
sResponseMsg.sResp.sTOPAZKM_MMCopyTiledBufferResp.xTOPAZKM_MMCopyTiledBufferResp =
TOPAZKM_MMCopyTiledBuffer(
sCommandMsg.sCmd.sTOPAZKM_MMCopyTiledBufferCmd.pMemoryInfo,
sCommandMsg.sCmd.sTOPAZKM_MMCopyTiledBufferCmd.pcBuffer,
sCommandMsg.sCmd.sTOPAZKM_MMCopyTiledBufferCmd.ui32Size,
sCommandMsg.sCmd.sTOPAZKM_MMCopyTiledBufferCmd.ui32Offset,
sCommandMsg.sCmd.sTOPAZKM_MMCopyTiledBufferCmd.bToMemory
);
break;
}
if(SYSOSKM_CopyToUser(psPacket->pvRespData, &sResponseMsg, sizeof(sResponseMsg)))
IMG_ASSERT(!"failed to copy to user");
}
static long zfcp_cfdc_dev_ioctl(struct file *file, unsigned int command,
unsigned long arg)
{
struct zfcp_cfdc_data *data;
struct zfcp_cfdc_data __user *data_user;
struct zfcp_adapter *adapter;
struct zfcp_fsf_req *req;
struct zfcp_fsf_cfdc *fsf_cfdc;
int retval;
if (command != ZFCP_CFDC_IOC)
return -ENOTTY;
if (is_compat_task())
data_user = compat_ptr(arg);
else
data_user = (void __user *)arg;
if (!data_user)
return -EINVAL;
fsf_cfdc = kmalloc(sizeof(struct zfcp_fsf_cfdc), GFP_KERNEL);
if (!fsf_cfdc)
return -ENOMEM;
data = kmalloc(sizeof(struct zfcp_cfdc_data), GFP_KERNEL);
if (!data) {
retval = -ENOMEM;
goto no_mem_sense;
}
retval = copy_from_user(data, data_user, sizeof(*data));
if (retval) {
retval = -EFAULT;
goto free_buffer;
}
if (data->signature != 0xCFDCACDF) {
retval = -EINVAL;
goto free_buffer;
}
retval = zfcp_cfdc_set_fsf(fsf_cfdc, data->command);
adapter = zfcp_cfdc_get_adapter(data->devno);
if (!adapter) {
retval = -ENXIO;
goto free_buffer;
}
retval = zfcp_cfdc_sg_setup(data->command, fsf_cfdc->sg,
data_user->control_file);
if (retval)
goto adapter_put;
req = zfcp_fsf_control_file(adapter, fsf_cfdc);
if (IS_ERR(req)) {
retval = PTR_ERR(req);
goto free_sg;
}
if (req->status & ZFCP_STATUS_FSFREQ_ERROR) {
retval = -ENXIO;
goto free_fsf;
}
zfcp_cfdc_req_to_sense(data, req);
retval = copy_to_user(data_user, data, sizeof(*data_user));
if (retval) {
retval = -EFAULT;
goto free_fsf;
}
if (data->command & ZFCP_CFDC_UPLOAD)
retval = zfcp_cfdc_copy_to_user(&data_user->control_file,
fsf_cfdc->sg);
free_fsf:
zfcp_fsf_req_free(req);
free_sg:
zfcp_sg_free_table(fsf_cfdc->sg, ZFCP_CFDC_PAGES);
adapter_put:
zfcp_ccw_adapter_put(adapter);
free_buffer:
kfree(data);
no_mem_sense:
kfree(fsf_cfdc);
return retval;
}
int32_t msm_sensor_driver_probe(void *setting,
struct msm_sensor_info_t *probed_info, char *entity_name)
{
int32_t rc = 0;
struct msm_sensor_ctrl_t *s_ctrl = NULL;
struct msm_camera_cci_client *cci_client = NULL;
struct msm_camera_sensor_slave_info *slave_info = NULL;
struct msm_camera_slave_info *camera_info = NULL;
struct msm_sensor_cam_id_t *cam_id =NULL;
unsigned long mount_pos = 0;
int32_t index = -1;
uint32_t i = 0;
/* Validate input parameters */
if (!setting) {
pr_err("failed: slave_info %p", setting);
return -EINVAL;
}
/* Allocate memory for slave info */
slave_info = kzalloc(sizeof(*slave_info), GFP_KERNEL);
if (!slave_info) {
pr_err("failed: no memory slave_info %p", slave_info);
return -ENOMEM;
}
#ifdef CONFIG_COMPAT
if (is_compat_task()) {
struct msm_camera_sensor_slave_info32 setting32;
if (copy_from_user((void *)&setting32, setting,
sizeof(setting32))) {
pr_err("failed: copy_from_user");
rc = -EFAULT;
goto free_slave_info;
}
strlcpy(slave_info->actuator_name, setting32.actuator_name,
sizeof(slave_info->actuator_name));
strlcpy(slave_info->eeprom_name, setting32.eeprom_name,
sizeof(slave_info->eeprom_name));
strlcpy(slave_info->sensor_name, setting32.sensor_name,
sizeof(slave_info->sensor_name));
strlcpy(slave_info->ois_name, setting32.ois_name,
sizeof(slave_info->ois_name));
strlcpy(slave_info->flash_name, setting32.flash_name,
sizeof(slave_info->flash_name));
slave_info->addr_type = setting32.addr_type;
slave_info->camera_id = setting32.camera_id;
slave_info->i2c_freq_mode = setting32.i2c_freq_mode;
slave_info->sensor_id_info = setting32.sensor_id_info;
slave_info->slave_addr = setting32.slave_addr;
slave_info->power_setting_array.size =
setting32.power_setting_array.size;
slave_info->power_setting_array.size_down =
setting32.power_setting_array.size_down;
slave_info->power_setting_array.size_down =
setting32.power_setting_array.size_down;
slave_info->power_setting_array.power_setting =
compat_ptr(setting32.power_setting_array.power_setting);
slave_info->power_setting_array.power_down_setting =
compat_ptr(setting32.
power_setting_array.power_down_setting);
slave_info->is_init_params_valid =
setting32.is_init_params_valid;
slave_info->sensor_init_params = setting32.sensor_init_params;
slave_info->is_flash_supported = setting32.is_flash_supported;
} else
#endif
{
if (copy_from_user(slave_info,
(void *)setting, sizeof(*slave_info))) {
pr_err("failed: copy_from_user");
rc = -EFAULT;
goto free_slave_info;
}
}
/* Print slave info */
CDBG("camera id %d", slave_info->camera_id);
CDBG("slave_addr 0x%x", slave_info->slave_addr);
CDBG("addr_type %d", slave_info->addr_type);
CDBG("sensor_id_reg_addr 0x%x",
slave_info->sensor_id_info.sensor_id_reg_addr);
CDBG("sensor_id 0x%x", slave_info->sensor_id_info.sensor_id);
CDBG("size %d", slave_info->power_setting_array.size);
CDBG("size down %d", slave_info->power_setting_array.size_down);
/* Print dump reg info */
CDBG("dump_reg_num:%d \n", slave_info->dump_reg_num);
for(i = 0; i < slave_info->dump_reg_num; i++)
CDBG("load dump_reg_addr:0x%X,default value:0x%X \n",
slave_info->dump_reg_info[i].addr,
slave_info->dump_reg_info[i].value);
if (slave_info->is_init_params_valid) {
CDBG("position %d",
slave_info->sensor_init_params.position);
CDBG("mount %d",
slave_info->sensor_init_params.sensor_mount_angle);
}
/* Validate camera id */
if (slave_info->camera_id >= MAX_CAMERAS) {
pr_err("failed: invalid camera id %d max %d",
slave_info->camera_id, MAX_CAMERAS);
rc = -EINVAL;
goto free_slave_info;
}
/* Extract s_ctrl from camera id */
s_ctrl = g_sctrl[slave_info->camera_id];
if (!s_ctrl) {
pr_err("failed: s_ctrl %p for camera_id %d", s_ctrl,
slave_info->camera_id);
rc = -EINVAL;
goto free_slave_info;
}
CDBG("s_ctrl[%d] %p", slave_info->camera_id, s_ctrl);
if (s_ctrl->is_probe_succeed == 1) {
/*
* Different sensor on this camera slot has been connected
* and probe already succeeded for that sensor. Ignore this
* probe
*/
if (slave_info->sensor_id_info.sensor_id ==
s_ctrl->sensordata->cam_slave_info->
sensor_id_info.sensor_id) {
pr_err("slot%d: sensor id%d already probed\n",
slave_info->camera_id,
s_ctrl->sensordata->cam_slave_info->
sensor_id_info.sensor_id);
msm_sensor_fill_sensor_info(s_ctrl,
probed_info, entity_name);
} else
pr_err("slot %d has some other sensor\n",
slave_info->camera_id);
rc = 0;
goto free_slave_info;
}
if (s_ctrl->sensordata->special_support_size > 0) {
if (!msm_sensor_driver_is_special_support(s_ctrl,
slave_info->sensor_name)) {
pr_err("%s:%s is not support on this board\n",
__func__, slave_info->sensor_name);
rc = 0;
goto free_slave_info;
}
}
rc = msm_sensor_get_power_settings(setting, slave_info,
&s_ctrl->sensordata->power_info);
if (rc < 0) {
pr_err("failed");
goto free_slave_info;
}
camera_info = kzalloc(sizeof(struct msm_camera_slave_info), GFP_KERNEL);
if (!camera_info) {
pr_err("failed: no memory slave_info %p", camera_info);
goto free_slave_info;
}
s_ctrl->sensordata->slave_info = camera_info;
/* used for confirmed MCAM_ID */
cam_id = kzalloc(sizeof(*cam_id),GFP_KERNEL);
if(!cam_id){
pr_err("failed: no memory cam_id %p",cam_id);
rc = -ENOMEM;
goto free_camera_info;
}
if(slave_info->sensor_cam_id){
if (copy_from_user(cam_id,(void *)slave_info->sensor_cam_id,sizeof(*cam_id))) {
pr_err("sensor_cam_id failed: copy_from_user");
rc = -EFAULT;
goto free_camera_id;
}
camera_info->mcam_id = cam_id->cam_excepted_id;
CDBG("%s expect camera id %d",slave_info->sensor_name,camera_info->mcam_id);
}else{
CDBG("%s no need to match camera id",slave_info->sensor_name);
camera_info->mcam_id = 2;
}
/* Fill sensor slave info */
camera_info->sensor_slave_addr = slave_info->slave_addr;
camera_info->sensor_id_reg_addr =
slave_info->sensor_id_info.sensor_id_reg_addr;
camera_info->sensor_id = slave_info->sensor_id_info.sensor_id;
camera_info->sensor_id_data_type = slave_info->sensor_id_info.sensor_id_data_type;
//Fill dump reg info
if (0 != slave_info->dump_reg_num && slave_info->dump_reg_info) {
camera_info->dump_reg_num = slave_info->dump_reg_num;
camera_info->dump_reg_info = kzalloc( (sizeof (struct dump_reg_info_t)) *
slave_info->dump_reg_num, GFP_KERNEL);
if (!camera_info->dump_reg_info) {
pr_err("failed: no memory dump reg info %p", camera_info->dump_reg_info);
return -ENOMEM;
} else if (copy_from_user(camera_info->dump_reg_info,slave_info->dump_reg_info,
sizeof(struct dump_reg_info_t) * slave_info->dump_reg_num)) {
pr_err("failed: copy_dump_reg");
rc = -EFAULT;
kfree(camera_info->dump_reg_info);
return rc;
} else {
for(i = 0; i < (camera_info->dump_reg_num); i++)
CDBG("cam_dump_reg: 0x%X",
camera_info->dump_reg_info[i].addr);
}
} else {
pr_err("sensor %s have no dump_reg_info",slave_info->sensor_name);
}
/* Fill CCI master, slave address and CCI default params */
if (!s_ctrl->sensor_i2c_client) {
pr_err("failed: sensor_i2c_client %p",
s_ctrl->sensor_i2c_client);
rc = -EINVAL;
goto free_camera_info;
}
/* Fill sensor address type */
s_ctrl->sensor_i2c_client->addr_type = slave_info->addr_type;
if (s_ctrl->sensor_i2c_client->client)
s_ctrl->sensor_i2c_client->client->addr =
camera_info->sensor_slave_addr;
cci_client = s_ctrl->sensor_i2c_client->cci_client;
if (!cci_client) {
pr_err("failed: cci_client %p", cci_client);
goto free_camera_info;
}
cci_client->cci_i2c_master = s_ctrl->cci_i2c_master;
cci_client->sid = slave_info->slave_addr >> 1;
cci_client->retries = 3;
cci_client->id_map = 0;
cci_client->i2c_freq_mode = slave_info->i2c_freq_mode;
/* Parse and fill vreg params for powerup settings */
rc = msm_camera_fill_vreg_params(
s_ctrl->sensordata->power_info.cam_vreg,
s_ctrl->sensordata->power_info.num_vreg,
s_ctrl->sensordata->power_info.power_setting,
s_ctrl->sensordata->power_info.power_setting_size);
if (rc < 0) {
pr_err("failed: msm_camera_get_dt_power_setting_data rc %d",
rc);
goto free_camera_info;
}
/* Parse and fill vreg params for powerdown settings*/
rc = msm_camera_fill_vreg_params(
s_ctrl->sensordata->power_info.cam_vreg,
s_ctrl->sensordata->power_info.num_vreg,
s_ctrl->sensordata->power_info.power_down_setting,
s_ctrl->sensordata->power_info.power_down_setting_size);
if (rc < 0) {
pr_err("failed: msm_camera_fill_vreg_params for PDOWN rc %d",
rc);
goto free_camera_info;
}
/* Update sensor, actuator and eeprom name in
* sensor control structure */
s_ctrl->sensordata->sensor_name = slave_info->sensor_name;
s_ctrl->sensordata->eeprom_name = slave_info->eeprom_name;
s_ctrl->sensordata->actuator_name = slave_info->actuator_name;
s_ctrl->sensordata->ois_name = slave_info->ois_name;
/*
* Update eeporm subdevice Id by input eeprom name
*/
rc = msm_sensor_fill_eeprom_subdevid_by_name(s_ctrl);
if (rc < 0) {
pr_err("%s failed %d\n", __func__, __LINE__);
goto free_camera_info;
}
/*
* Update actuator subdevice Id by input actuator name
*/
rc = msm_sensor_fill_actuator_subdevid_by_name(s_ctrl);
if (rc < 0) {
pr_err("%s failed %d\n", __func__, __LINE__);
goto free_camera_info;
}
rc = msm_sensor_fill_ois_subdevid_by_name(s_ctrl);
if (rc < 0) {
pr_err("%s failed %d\n", __func__, __LINE__);
goto free_camera_info;
}
/* Power up and probe sensor */
rc = s_ctrl->func_tbl->sensor_power_up(s_ctrl);
if (rc < 0) {
pr_err("%s power up failed", slave_info->sensor_name);
goto free_camera_info;
}
if ( is_exist_otp_function(s_ctrl, &index)){
if(otp_function_lists[index].is_boot_load){
rc = otp_function_lists[index].sensor_otp_function(s_ctrl, index);
if (rc < 0){
pr_err("%s:%d failed rc %d\n", __func__,__LINE__, rc);
}
}
}
pr_err("%s probe succeeded", slave_info->sensor_name);
if (0 == slave_info->camera_id){
rc = app_info_set("camera_main", slave_info->sensor_name);
}
else if (1 == slave_info->camera_id){
rc = app_info_set("camera_slave", slave_info->sensor_name);
}
else{
pr_err("%s app_info_set id err", slave_info->sensor_name);
}
#ifdef CONFIG_HUAWEI_HW_DEV_DCT
if(0 == slave_info->camera_id) //detet main senor or sub sensor
{
set_hw_dev_flag(DEV_I2C_CAMERA_MAIN); //set sensor flag
}
else if (1 == slave_info->camera_id) //sub sensor
{
set_hw_dev_flag(DEV_I2C_CAMERA_SLAVE); //set sensor flag
}
else
{
pr_err("%s set_hw_dev_flag id err", slave_info->sensor_name);
}
#endif
/*
Set probe succeeded flag to 1 so that no other camera shall
* probed on this slot
*/
s_ctrl->is_probe_succeed = 1;
/*
* Update the subdevice id of flash-src based on availability in kernel.
*/
if (slave_info->is_flash_supported == 0) {
s_ctrl->sensordata->sensor_info->
subdev_id[SUB_MODULE_LED_FLASH] = -1;
}
/*
* Create /dev/videoX node, comment for now until dummy /dev/videoX
* node is created and used by HAL
*/
if (s_ctrl->sensor_device_type == MSM_CAMERA_PLATFORM_DEVICE)
rc = msm_sensor_driver_create_v4l_subdev(s_ctrl);
else
rc = msm_sensor_driver_create_i2c_v4l_subdev(s_ctrl);
if (rc < 0) {
pr_err("failed: camera creat v4l2 rc %d", rc);
goto camera_power_down;
}
/* Power down */
s_ctrl->func_tbl->sensor_power_down(s_ctrl);
rc = msm_sensor_fill_slave_info_init_params(
slave_info,
s_ctrl->sensordata->sensor_info);
if (rc < 0) {
pr_err("%s Fill slave info failed", slave_info->sensor_name);
goto free_camera_info;
}
rc = msm_sensor_validate_slave_info(s_ctrl->sensordata->sensor_info);
if (rc < 0) {
pr_err("%s Validate slave info failed",
slave_info->sensor_name);
goto free_camera_info;
}
/* Update sensor mount angle and position in media entity flag */
mount_pos = s_ctrl->sensordata->sensor_info->position << 16;
mount_pos = mount_pos | ((s_ctrl->sensordata->sensor_info->
sensor_mount_angle / 90) << 8);
s_ctrl->msm_sd.sd.entity.flags = mount_pos | MEDIA_ENT_FL_DEFAULT;
/*Save sensor info*/
s_ctrl->sensordata->cam_slave_info = slave_info;
msm_sensor_fill_sensor_info(s_ctrl, probed_info, entity_name);
return rc;
camera_power_down:
s_ctrl->func_tbl->sensor_power_down(s_ctrl);
free_camera_info:
kfree(camera_info);
free_camera_id:
kfree(cam_id);
free_slave_info:
kfree(slave_info);
return rc;
}
/*
* Construct an arch_hw_breakpoint from a perf_event.
*/
static int arch_build_bp_info(struct perf_event *bp)
{
struct arch_hw_breakpoint *info = counter_arch_bp(bp);
/* Type */
switch (bp->attr.bp_type) {
case HW_BREAKPOINT_X:
info->ctrl.type = ARM_BREAKPOINT_EXECUTE;
break;
case HW_BREAKPOINT_R:
info->ctrl.type = ARM_BREAKPOINT_LOAD;
break;
case HW_BREAKPOINT_W:
info->ctrl.type = ARM_BREAKPOINT_STORE;
break;
case HW_BREAKPOINT_RW:
info->ctrl.type = ARM_BREAKPOINT_LOAD | ARM_BREAKPOINT_STORE;
break;
default:
return -EINVAL;
}
/* Len */
switch (bp->attr.bp_len) {
case HW_BREAKPOINT_LEN_1:
info->ctrl.len = ARM_BREAKPOINT_LEN_1;
break;
case HW_BREAKPOINT_LEN_2:
info->ctrl.len = ARM_BREAKPOINT_LEN_2;
break;
case HW_BREAKPOINT_LEN_4:
info->ctrl.len = ARM_BREAKPOINT_LEN_4;
break;
case HW_BREAKPOINT_LEN_8:
info->ctrl.len = ARM_BREAKPOINT_LEN_8;
break;
default:
return -EINVAL;
}
/*
* On AArch64, we only permit breakpoints of length 4, whereas
* AArch32 also requires breakpoints of length 2 for Thumb.
* Watchpoints can be of length 1, 2, 4 or 8 bytes.
*/
if (info->ctrl.type == ARM_BREAKPOINT_EXECUTE) {
if (is_compat_task()) {
if (info->ctrl.len != ARM_BREAKPOINT_LEN_2 &&
info->ctrl.len != ARM_BREAKPOINT_LEN_4)
return -EINVAL;
} else if (info->ctrl.len != ARM_BREAKPOINT_LEN_4) {
/*
* FIXME: Some tools (I'm looking at you perf) assume
* that breakpoints should be sizeof(long). This
* is nonsense. For now, we fix up the parameter
* but we should probably return -EINVAL instead.
*/
info->ctrl.len = ARM_BREAKPOINT_LEN_4;
}
}
/* Address */
info->address = bp->attr.bp_addr;
/*
* Privilege
* Note that we disallow combined EL0/EL1 breakpoints because
* that would complicate the stepping code.
*/
if (arch_check_bp_in_kernelspace(bp))
info->ctrl.privilege = AARCH64_BREAKPOINT_EL1;
else
info->ctrl.privilege = AARCH64_BREAKPOINT_EL0;
/* Enabled? */
info->ctrl.enabled = !bp->attr.disabled;
return 0;
}
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;
}
#ifdef CONFIG_COMPAT
if (is_compat_task()) {
/* User space is 32-bit, use compat ioctl */
compat_android_wifi_priv_cmd compat_priv_cmd;
if (copy_from_user(&compat_priv_cmd, ifr->ifr_data, sizeof(compat_android_wifi_priv_cmd))) {
ret = -EFAULT;
goto exit;
}
priv_cmd.buf = compat_ptr(compat_priv_cmd.buf);
priv_cmd.used_len = compat_priv_cmd.used_len;
priv_cmd.total_len = compat_priv_cmd.total_len;
} else
#endif /* CONFIG_COMPAT */
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;
}
if (copy_from_user(command, (void *)priv_cmd.buf, priv_cmd.total_len)) {
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_MIRACAST:
bytes_written = rtw_android_set_miracast_mode(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 )
{
pwfd_info->rtsp_ctrlport = ( u16 ) get_int_from_command( priv_cmd.buf );
}
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 )
{
pwfd_info->wfd_device_type = ( u8 ) get_int_from_command( priv_cmd.buf );
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, (u8*)command);
break;
#endif //CONFIG_GTK_OL
case ANDROID_WIFI_CMD_P2P_DISABLE:
{
#ifdef CONFIG_P2P
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
u8 channel, ch_offset;
u16 bwmode;
rtw_p2p_enable(padapter, P2P_ROLE_DISABLE);
#endif // CONFIG_P2P
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;
if (copy_to_user((void *)priv_cmd.buf, command, bytes_written)) {
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;
}
static int32_t msm_sensor_get_power_up_settings(void *setting,
struct msm_camera_sensor_slave_info *slave_info,
struct msm_camera_power_ctrl_t *power_info)
{
int32_t rc = 0;
uint16_t size = 0;
uint16_t i = 0;
struct msm_sensor_power_setting *pu = NULL;
/* */
hw_rev_type rev_type = 0;
rev_type = lge_get_board_revno();
pr_err("%s:%d, rev_type:%d\n", __func__, __LINE__, rev_type);
if ((rev_type == HW_REV_A) && slave_info->power_setting_array.size_a)
size = slave_info->power_setting_array.size_a;
else //QCT
size = slave_info->power_setting_array.size;
/* */
/* Validate size */
if ((size == 0) || (size > MAX_POWER_CONFIG)) {
pr_err("failed: invalid power_setting size_up = %d\n", size);
return -EINVAL;
}
/* Allocate memory for power up setting */
pu = kzalloc(sizeof(*pu) * size, GFP_KERNEL);
if (!pu) {
pr_err("failed: no memory power_setting %p", pu);
return -ENOMEM;
}
#ifdef CONFIG_COMPAT
if (is_compat_task()) {
rc = msm_sensor_get_pw_settings_compat(pu,
slave_info->power_setting_array.
power_setting, size);
if (rc < 0) {
pr_err("failed");
kfree(pu);
return -EFAULT;
}
} else
#endif
/* */
{
switch(rev_type) {
case HW_REV_A:
if (slave_info->power_setting_array.power_setting_a != NULL){
if (copy_from_user(pu,
(void *)slave_info->power_setting_array.power_setting_a,
sizeof(*pu) * size)) {
pr_err("failed: copy_from_user");
kfree(pu);
return -EFAULT;
}
}else{
if (copy_from_user(pu,
(void *)slave_info->power_setting_array.power_setting,
sizeof(*pu) * size)) {
pr_err("failed: copy_from_user");
kfree(pu);
return -EFAULT;
}
}
break;
case HW_REV_B:
if (copy_from_user(pu,
(void *)slave_info->power_setting_array.power_setting,
sizeof(*pu) * size)) {
pr_err("failed: copy_from_user");
kfree(pu);
return -EFAULT;
}
break;
default: //QCT
if (copy_from_user(pu,
(void *)slave_info->power_setting_array.power_setting,
sizeof(*pu) * size)) {
pr_err("failed: copy_from_user");
kfree(pu);
return -EFAULT;
}
break;
}
}
/* */
/* Print power setting */
for (i = 0; i < size; i++) {
CDBG("UP seq_type %d seq_val %d config_val %ld delay %d",
pu[i].seq_type, pu[i].seq_val,
pu[i].config_val, pu[i].delay);
}
/* Fill power up setting and power up setting size */
power_info->power_setting = pu;
power_info->power_setting_size = size;
return rc;
}
/*
* Note that 'init' is a special process: it doesn't get signals it doesn't
* want to handle. Thus you cannot kill init even with a SIGKILL even by
* mistake.
*
* Note that we go through the signals twice: once to check the signals that
* the kernel can handle, and then we build all the user-level signal handling
* stack-frames in one go after that.
*/
void do_signal(struct pt_regs *regs)
{
unsigned long retval = 0, continue_addr = 0, restart_addr = 0;
siginfo_t info;
int signr;
struct k_sigaction ka;
sigset_t *oldset;
/*
* We want the common case to go fast, which
* is why we may in certain cases get here from
* kernel mode. Just return without doing anything
* if so.
*/
if (!user_mode(regs))
return;
if (test_thread_flag(TIF_RESTORE_SIGMASK))
oldset = ¤t->saved_sigmask;
else
oldset = ¤t->blocked;
/* Are we from a system call? */
if (regs->svcnr) {
continue_addr = regs->psw.addr;
restart_addr = continue_addr - regs->ilc;
retval = regs->gprs[2];
/* Prepare for system call restart. We do this here so that a
debugger will see the already changed PSW. */
switch (retval) {
case -ERESTARTNOHAND:
case -ERESTARTSYS:
case -ERESTARTNOINTR:
regs->gprs[2] = regs->orig_gpr2;
regs->psw.addr = restart_addr;
break;
case -ERESTART_RESTARTBLOCK:
regs->gprs[2] = -EINTR;
}
regs->svcnr = 0; /* Don't deal with this again. */
}
/* Get signal to deliver. When running under ptrace, at this point
the debugger may change all our registers ... */
signr = get_signal_to_deliver(&info, &ka, regs, NULL);
/* Depending on the signal settings we may need to revert the
decision to restart the system call. */
if (signr > 0 && regs->psw.addr == restart_addr) {
if (retval == -ERESTARTNOHAND
|| (retval == -ERESTARTSYS
&& !(current->sighand->action[signr-1].sa.sa_flags
& SA_RESTART))) {
regs->gprs[2] = -EINTR;
regs->psw.addr = continue_addr;
}
}
if (signr > 0) {
/* Whee! Actually deliver the signal. */
int ret;
#ifdef CONFIG_COMPAT
if (is_compat_task()) {
ret = handle_signal32(signr, &ka, &info, oldset, regs);
}
else
#endif
ret = handle_signal(signr, &ka, &info, oldset, regs);
if (!ret) {
/*
* A signal was successfully delivered; the saved
* sigmask will have been stored in the signal frame,
* and will be restored by sigreturn, so we can simply
* clear the TIF_RESTORE_SIGMASK flag.
*/
if (test_thread_flag(TIF_RESTORE_SIGMASK))
clear_thread_flag(TIF_RESTORE_SIGMASK);
/*
* If we would have taken a single-step trap
* for a normal instruction, act like we took
* one for the handler setup.
*/
if (current->thread.per_info.single_step)
set_thread_flag(TIF_SINGLE_STEP);
/*
* Let tracing know that we've done the handler setup.
*/
tracehook_signal_handler(signr, &info, &ka, regs,
test_thread_flag(TIF_SINGLE_STEP));
}
return;
}
/*
* If there's no signal to deliver, we just put the saved sigmask back.
*/
if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
clear_thread_flag(TIF_RESTORE_SIGMASK);
sigprocmask(SIG_SETMASK, ¤t->saved_sigmask, NULL);
}
/* Restart a different system call. */
if (retval == -ERESTART_RESTARTBLOCK
&& regs->psw.addr == continue_addr) {
regs->gprs[2] = __NR_restart_syscall;
set_thread_flag(TIF_RESTART_SVC);
}
}
int dasd_ioctl(struct block_device *bdev, fmode_t mode,
unsigned int cmd, unsigned long arg)
{
struct dasd_block *block;
struct dasd_device *base;
void __user *argp;
int rc;
if (is_compat_task())
argp = compat_ptr(arg);
else
argp = (void __user *)arg;
if ((_IOC_DIR(cmd) != _IOC_NONE) && !arg) {
PRINT_DEBUG("empty data ptr");
return -EINVAL;
}
base = dasd_device_from_gendisk(bdev->bd_disk);
if (!base)
return -ENODEV;
block = base->block;
rc = 0;
switch (cmd) {
case BIODASDDISABLE:
rc = dasd_ioctl_disable(bdev);
break;
case BIODASDENABLE:
rc = dasd_ioctl_enable(bdev);
break;
case BIODASDQUIESCE:
rc = dasd_ioctl_quiesce(block);
break;
case BIODASDRESUME:
rc = dasd_ioctl_resume(block);
break;
case BIODASDFMT:
rc = dasd_ioctl_format(bdev, argp);
break;
case BIODASDINFO:
rc = dasd_ioctl_information(block, cmd, argp);
break;
case BIODASDINFO2:
rc = dasd_ioctl_information(block, cmd, argp);
break;
case BIODASDPRRD:
rc = dasd_ioctl_read_profile(block, argp);
break;
case BIODASDPRRST:
rc = dasd_ioctl_reset_profile(block);
break;
case BLKROSET:
rc = dasd_ioctl_set_ro(bdev, argp);
break;
case DASDAPIVER:
rc = dasd_ioctl_api_version(argp);
break;
case BIODASDCMFENABLE:
rc = enable_cmf(base->cdev);
break;
case BIODASDCMFDISABLE:
rc = disable_cmf(base->cdev);
break;
case BIODASDREADALLCMB:
rc = dasd_ioctl_readall_cmb(block, cmd, argp);
break;
default:
/* if the discipline has an ioctl method try it. */
if (base->discipline->ioctl) {
rc = base->discipline->ioctl(block, cmd, argp);
if (rc == -ENOIOCTLCMD)
rc = -EINVAL;
} else
rc = -EINVAL;
}
dasd_put_device(base);
return rc;
}
static int32_t msm_flash_i2c_init(
struct msm_flash_ctrl_t *flash_ctrl,
struct msm_flash_cfg_data_t *flash_data)
{
int32_t rc = 0;
struct msm_flash_init_info_t *flash_init_info =
flash_data->cfg.flash_init_info;
struct msm_camera_i2c_reg_setting_array *settings = NULL;
#ifdef CONFIG_COMPAT
struct msm_sensor_power_setting_array32 *power_setting_array32 = NULL;
#endif
if (!flash_init_info || !flash_init_info->power_setting_array) {
pr_err("%s:%d failed: Null pointer\n", __func__, __LINE__);
return -EFAULT;
}
#ifdef CONFIG_COMPAT
if (is_compat_task()) {
power_setting_array32 = kzalloc(
sizeof(struct msm_sensor_power_setting_array32),
GFP_KERNEL);
if (!power_setting_array32) {
pr_err("%s mem allocation failed %d\n",
__func__, __LINE__);
return -ENOMEM;
}
if (copy_from_user(power_setting_array32,
(void *)flash_init_info->power_setting_array,
sizeof(struct msm_sensor_power_setting_array32))) {
pr_err("%s copy_from_user failed %d\n",
__func__, __LINE__);
return -EFAULT;
}
flash_ctrl->power_setting_array.size =
power_setting_array32->size;
flash_ctrl->power_setting_array.size_down =
power_setting_array32->size_down;
flash_ctrl->power_setting_array.power_down_setting =
compat_ptr(power_setting_array32->power_down_setting);
flash_ctrl->power_setting_array.power_setting =
compat_ptr(power_setting_array32->power_setting);
memcpy(&flash_ctrl->power_setting_array.power_down_setting_a,
&power_setting_array32->power_down_setting_a,
sizeof(power_setting_array32->power_down_setting_a));
memcpy(&flash_ctrl->power_setting_array.power_setting_a,
&power_setting_array32->power_setting_a,
sizeof(power_setting_array32->power_setting_a));
}
#endif
if (copy_from_user(&flash_ctrl->power_setting_array,
(void *)flash_init_info->power_setting_array,
sizeof(struct msm_sensor_power_setting_array))) {
pr_err("%s copy_from_user failed %d\n", __func__, __LINE__);
return -EFAULT;
}
flash_ctrl->power_info.power_setting =
flash_ctrl->power_setting_array.power_setting_a;
flash_ctrl->power_info.power_down_setting =
flash_ctrl->power_setting_array.power_down_setting_a;
flash_ctrl->power_info.power_setting_size =
flash_ctrl->power_setting_array.size;
flash_ctrl->power_info.power_down_setting_size =
flash_ctrl->power_setting_array.size_down;
rc = msm_camera_power_up(&flash_ctrl->power_info,
flash_ctrl->flash_device_type,
&flash_ctrl->flash_i2c_client);
if (rc < 0) {
pr_err("%s msm_camera_power_up failed %d\n",
__func__, __LINE__);
goto msm_flash_i2c_init_fail;
}
if (flash_data->cfg.flash_init_info->settings) {
settings = kzalloc(sizeof(
struct msm_camera_i2c_reg_setting_array), GFP_KERNEL);
if (!settings) {
pr_err("%s mem allocation failed %d\n",
__func__, __LINE__);
return -ENOMEM;
}
if (copy_from_user(settings, (void *)flash_init_info->settings,
sizeof(struct msm_camera_i2c_reg_setting_array))) {
kfree(settings);
pr_err("%s copy_from_user failed %d\n",
__func__, __LINE__);
return -EFAULT;
}
rc = msm_flash_i2c_write_table(flash_ctrl, settings);
kfree(settings);
if (rc < 0) {
pr_err("%s:%d msm_flash_i2c_write_table rc %d failed\n",
__func__, __LINE__, rc);
}
}
return 0;
msm_flash_i2c_init_fail:
return rc;
}
static int32_t msm_sensor_get_power_down_settings(void *setting,
struct msm_camera_sensor_slave_info *slave_info,
struct msm_camera_power_ctrl_t *power_info)
{
int32_t rc = 0;
uint16_t size_down = 0;
uint16_t i = 0;
struct msm_sensor_power_setting *pd = NULL;
/* DOWN */
size_down = slave_info->power_setting_array.size_down;
if (!size_down || size_down > MAX_POWER_CONFIG)
size_down = slave_info->power_setting_array.size;
/* Validate size_down */
if (size_down > MAX_POWER_CONFIG) {
pr_err("failed: invalid size_down %d", size_down);
return -EINVAL;
}
/* Allocate memory for power down setting */
pd = kzalloc(sizeof(*pd) * size_down, GFP_KERNEL);
if (!pd) {
pr_err("failed: no memory power_setting %p", pd);
return -EFAULT;
}
if (slave_info->power_setting_array.power_down_setting) {
#ifdef CONFIG_COMPAT
if (is_compat_task()) {
rc = msm_sensor_get_pw_settings_compat(
pd, slave_info->power_setting_array.
power_down_setting, size_down);
if (rc < 0) {
pr_err("failed");
kfree(pd);
return -EFAULT;
}
} else
#endif
if (copy_from_user(pd, (void *)slave_info->power_setting_array.
power_down_setting, sizeof(*pd) * size_down)) {
pr_err("failed: copy_from_user");
kfree(pd);
return -EFAULT;
}
} else {
rc = msm_sensor_create_pd_settings(setting, pd, size_down,
slave_info->power_setting_array.power_setting);
if (rc < 0) {
pr_err("failed");
kfree(pd);
return -EFAULT;
}
}
/* Fill power down setting and power down setting size */
power_info->power_down_setting = pd;
power_info->power_down_setting_size = size_down;
/* Print power setting */
for (i = 0; i < size_down; i++) {
CDBG("DOWN seq_type %d seq_val %d config_val %ld delay %d",
pd[i].seq_type, pd[i].seq_val,
pd[i].config_val, pd[i].delay);
}
return rc;
}
int __secure_computing(int this_syscall)
{
int mode = current->seccomp.mode;
int exit_sig = 0;
int *syscall;
u32 ret;
switch (mode) {
case SECCOMP_MODE_STRICT:
syscall = mode1_syscalls;
#ifdef CONFIG_COMPAT
if (is_compat_task())
syscall = mode1_syscalls_32;
#endif
do {
if (*syscall == this_syscall)
return 0;
} while (*++syscall);
exit_sig = SIGKILL;
ret = SECCOMP_RET_KILL;
break;
#ifdef CONFIG_SECCOMP_FILTER
case SECCOMP_MODE_FILTER: {
int data;
struct pt_regs *regs = task_pt_regs(current);
ret = seccomp_run_filters(this_syscall);
data = ret & SECCOMP_RET_DATA;
ret &= SECCOMP_RET_ACTION;
switch (ret) {
case SECCOMP_RET_ERRNO:
/* Set the low-order 16-bits as a errno. */
syscall_set_return_value(current, regs,
-data, 0);
goto skip;
case SECCOMP_RET_TRAP:
/* Show the handler the original registers. */
syscall_rollback(current, regs);
/* Let the filter pass back 16 bits of data. */
seccomp_send_sigsys(this_syscall, data);
goto skip;
case SECCOMP_RET_TRACE:
/* Skip these calls if there is no tracer. */
if (!ptrace_event_enabled(current, PTRACE_EVENT_SECCOMP)) {
syscall_set_return_value(current, regs,
-ENOSYS, 0);
goto skip;
}
/* Allow the BPF to provide the event message */
ptrace_event(PTRACE_EVENT_SECCOMP, data);
/*
* The delivery of a fatal signal during event
* notification may silently skip tracer notification.
* Terminating the task now avoids executing a system
* call that may not be intended.
*/
if (fatal_signal_pending(current))
break;
if (syscall_get_nr(current, regs) < 0)
goto skip; /* Explicit request to skip. */
return 0;
case SECCOMP_RET_ALLOW:
return 0;
case SECCOMP_RET_KILL:
default:
break;
}
exit_sig = SIGSYS;
break;
}
#endif
default:
BUG();
}
#ifdef SECCOMP_DEBUG
dump_stack();
#endif
audit_seccomp(this_syscall, exit_sig, ret);
do_exit(exit_sig);
#ifdef CONFIG_SECCOMP_FILTER
skip:
audit_seccomp(this_syscall, exit_sig, ret);
#endif
return -1;
}
