/*!
* @brief emu_glue_read_sense
*
* This function returns the EMU state information.
* The parameter to the function indicates if the interrupt status flags should be cleared
* after reading the value of the sense bits. If the parameter is non zero, the interrupt
* status flags for the VBUS, ID, and SE1 interrupts should be cleared.
* If zero, the interrupt status flags should be left unchanged
*
* @param clear_int_flags see description
*
* @return unsigned long int representing the current state of the EMU state information
*/
unsigned long emu_glue_read_sense(unsigned long clear_int_flags)
{
int value_read;
unsigned long emu_glue_sense_read = 0;
/* Read Atlas Sense 0 register bits */
power_ic_get_reg_value(POWER_IC_REG_ATLAS_INT_SENSE_0, 0,
&(value_read), 24);
/* Get all EMU sense bit states from the power ic */
emu_glue_sense_read = value_read & (EMU_SENSE_CHGCURR | EMU_SENSE_DPLUS | EMU_SENSE_DMINUS | \
EMU_SENSE_VBUS_4V4 | EMU_SENSE_VBUS_2V0 | EMU_SENSE_VBUS_0V8 | \
EMU_SENSE_ID_FLOAT | EMU_SENSE_ID_GROUND | EMU_SENSE_SE1 );
/* OR in the state of the cradle detect line */
emu_glue_sense_read |= (EMU_GET_CRADLE_DETECT() ? EMU_SENSE_CRADLE_DETECT : 0);
/* Get accessory power setting */
power_ic_get_reg_value(POWER_IC_REG_ATLAS_CHARGE_USB_1, 5, &(value_read), 1);
emu_glue_sense_read |= value_read;
/* Clear interrupt flags if requested */
if (clear_int_flags != 0)
{
power_ic_set_reg_value(POWER_IC_REG_ATLAS_INT_STAT_0, 0,
CLEAR_ACCY_INTERRUPT_1, 24);
}
return emu_glue_sense_read;
}
int power_ic_rtc_get_time(struct timeval *power_ic_time)
{
int tod_reg_val = 0;
int day_reg_val = 0;
int err = 0;
err = power_ic_get_reg_value(RTC_TOD_REG, POWER_IC_TIME_REG_BIT,
&tod_reg_val, POWER_IC_TOD_NUM_BITS);
err = power_ic_get_reg_value(RTC_DAY_REG, POWER_IC_TIME_REG_BIT,
&day_reg_val, POWER_IC_DAY_NUM_BITS);
power_ic_time->tv_sec = tod_reg_val + day_reg_val * POWER_IC_NUM_SEC_PER_DAY;
power_ic_time->tv_usec = 0;
printk("Get RTC Time \n RTC_TOD = %d \n RTC_DAY = %d \n tv_sec = %d Error = %d \n", tod_reg_val,
day_reg_val,(int)power_ic_time->tv_sec, err );
return err;
}
int power_ic_get_num_power_cuts(int * power_cuts)
{
int err = 0;
err = power_ic_get_reg_value(RTC_POWER_CUT_REG, POWER_IC_POWER_CUT_BIT,
power_cuts, POWER_IC_POWER_CUT_NUM_BITS);
return (err);
}
int power_ic_rtc_get_time_alarm(struct timeval *power_ic_time)
{
int toda_reg_val = 0;
int daya_reg_val = 0;
int err = 0;
err = power_ic_get_reg_value(RTC_TODA_REG, POWER_IC_TIME_REG_BIT,
&toda_reg_val, POWER_IC_TOD_NUM_BITS);
err = power_ic_get_reg_value(RTC_DAYA_REG, POWER_IC_TIME_REG_BIT,
&daya_reg_val, POWER_IC_DAY_NUM_BITS);
power_ic_time->tv_sec = toda_reg_val + daya_reg_val * POWER_IC_NUM_SEC_PER_DAY;
power_ic_time->tv_usec = 0;
tracemsg(_k_d("Get RTC Alarm Time \n RTC_TODA = %d \n RTC_DAYA = %d \n tv_sec = %d Error = %d \n"), toda_reg_val,
daya_reg_val,(int)power_ic_time->tv_sec, err );
return err;
}
int power_ic_periph_is_usb_pull_up_enabled (void)
{
int value;
/* Read the bit from the EMU One Chip */
if (power_ic_get_reg_value (USB_PU_REG, USB_PU_INDEX, &value, USB_PU_NUM_BITS) != 0)
{
value = 0;
}
return value;
}
static int emu_proc_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
{
unsigned int ret_val = 0;
POWER_IC_EMU_GLUE_READ_SENSE_T read_sense;
POWER_IC_EMU_GLUE_TRANSCEIVER_PARAMS_T trans_params;
POWER_IC_FET_CONTROL_T fet_ctrl;
/* prev lockout status */
static bool prev_emu_hw_lockout_state = false;
/* what devices were connected before lockout */
static MOTO_ACCY_MASK_T connected_device_before_lock = 0;
MOTO_ACCY_MASK_T connected_device;
/* Get the actual command from the ioctl request. */
unsigned int cmd_num = _IOC_NR(cmd);
if ((cmd_num >= POWER_IC_IOC_CMD_EMU_GLUE_BASE) && (cmd_num <= POWER_IC_IOC_CMD_EMU_GLUE_LAST_CMD))
{
tracemsg(_k_d("EMU GLUE control ioctl(), request 0x%X (cmd 0x%X)"),(int) cmd, _IOC_NR(cmd));
/* Handle the request. */
switch(cmd)
{
case POWER_IC_IOCTL_CMD_EMU_GLUE_READ_SENSE:
/* Fetch the data passed from user space. */
if(copy_from_user((void *)&read_sense, (void *)arg, sizeof(read_sense)) != 0)
{
tracemsg(_k_d("error copying data from user space."));
ret_val = -EFAULT;
}
else
{
/* Read the sense and clear the interrupt if requested */
read_sense.sense = emu_glue_read_sense(read_sense.clear_int_flags);
/* Only the sense value read needs to be sent back to the caller. */
if(put_user(read_sense.sense,&(((POWER_IC_EMU_GLUE_READ_SENSE_T *)arg)->sense)) != 0)
{
tracemsg(_k_d("error copying read bits to user space."));
ret_val = -EFAULT;
}
}
break;
case POWER_IC_IOCTL_CMD_EMU_GLUE_LOCKOUT_CHANGES:
power_ic_emu_hw_locked = (bool)(arg == 0 ? 0 : 1);
if (power_ic_emu_hw_locked)
{
/* Make sure the hardware is not already locked */
if (prev_emu_hw_lockout_state == false)
{
/* If the EMU hardware needs to be locked, keep track of
the currently connected accessory */
connected_device_before_lock = moto_accy_get_all_devices();
}
}
else
{
/* If the EMU hardware was previously locked but is now unlocked the accessory may need
to be reconfigured. */
if (prev_emu_hw_lockout_state == true)
{
connected_device = moto_accy_get_all_devices();
if (connected_device_before_lock == connected_device)
{
if ((ACCY_BITMASK_ISSET(connected_device, MOTO_ACCY_TYPE_HEADSET_EMU_MONO)) ||
(ACCY_BITMASK_ISSET(connected_device, MOTO_ACCY_TYPE_HEADSET_EMU_STEREO)))
{
audio_config.id_pull_down = 0;
audio_config.conn_mode = 0;
emu_util_set_emu_headset_mode(audio_config.headset_mode);
}
else if ((ACCY_BITMASK_ISSET(connected_device, MOTO_ACCY_TYPE_CARKIT_MID)) ||
(ACCY_BITMASK_ISSET(connected_device, MOTO_ACCY_TYPE_CARKIT_FAST)))
{
audio_config.headset_mode = MOTO_ACCY_HEADSET_MODE_NONE;
EMU_SET_EMU_CONN_MODE(audio_config.conn_mode);
EMU_SET_ID_PULL_DOWN(audio_config.id_pull_down);
}
else
{
audio_config.headset_mode = MOTO_ACCY_HEADSET_MODE_NONE;
audio_config.conn_mode = POWER_IC_EMU_CONN_MODE_USB;
audio_config.id_pull_down = 0;
}
}
else
{
audio_config.headset_mode = MOTO_ACCY_HEADSET_MODE_NONE;
audio_config.conn_mode = POWER_IC_EMU_CONN_MODE_USB;
audio_config.id_pull_down = 0;
}
}
}
prev_emu_hw_lockout_state = power_ic_emu_hw_locked;
break;
case POWER_IC_IOCTL_CMD_EMU_GLUE_GET_FET_CONTROL:
if ((power_ic_get_reg_value(POWER_IC_REG_ATLAS_CHARGER_0, 10, (int *)&(fet_ctrl), 2)) != 0)
{
ret_val = -EIO;
}
/* Only the sense value read needs to be sent back to the caller. */
else if(put_user(fet_ctrl, (((int *)arg))) != 0)
{
tracemsg(_k_d("error copying read bits to user space."));
ret_val = -EFAULT;
}
break;
case POWER_IC_IOCTL_CMD_EMU_GLUE_SET_FET_CONTROL:
power_ic_set_reg_value(POWER_IC_REG_ATLAS_CHARGER_0, 10,
arg, 2);
break;
case POWER_IC_IOCTL_CMD_EMU_GLUE_SET_VBUS_5K_PD:
power_ic_set_reg_value(POWER_IC_REG_ATLAS_CHARGER_0, 19,
(arg == 0 ? 0 : 1), 1);
break;
case POWER_IC_IOCTL_CMD_EMU_GLUE_SET_VBUS_70K_PD:
power_ic_set_reg_value(POWER_IC_REG_ATLAS_USB_0, 6,
(arg == 0 ? 0 : 1), 1);
break;
case POWER_IC_IOCTL_CMD_EMU_GLUE_SET_REVERSE_MODE:
power_ic_set_reg_value(POWER_IC_REG_ATLAS_CHARGE_USB_1, 5,
(arg == 0 ? 0 : 1), 1);
break;
case POWER_IC_IOCTL_CMD_EMU_GLUE_SET_ID_PU:
power_ic_set_reg_value(POWER_IC_REG_ATLAS_USB_0, 22,
(arg == 0 ? 0 : 1), 1);
break;
case POWER_IC_IOCTL_CMD_EMU_GLUE_SET_ID_PD:
power_ic_set_reg_value(POWER_IC_REG_ATLAS_USB_0, 20,
(arg == 0 ? 0 : 1), 1);
break;
case POWER_IC_IOCTL_CMD_EMU_GLUE_SET_ID_STEREO_PU:
power_ic_set_reg_value(POWER_IC_REG_ATLAS_CHARGE_USB_1, 8,
(arg == 0 ? 0 : 1), 1);
break;
case POWER_IC_IOCTL_CMD_EMU_GLUE_SET_CONN_MODE:
power_ic_set_reg_value(POWER_IC_REG_ATLAS_USB_0, 14,
arg, 3);
break;
case POWER_IC_IOCTL_CMD_EMU_GLUE_SET_DPLUS_150K_PU:
power_ic_set_reg_value(POWER_IC_REG_ATLAS_USB_0, 5,
(arg == 0 ? 0 : 1), 1);
break;
case POWER_IC_IOCTL_CMD_EMU_GLUE_SET_DPLUS_1_5K_PU:
power_ic_set_reg_value(POWER_IC_REG_ATLAS_USB_0, 2,
(arg == 0 ? 0 : 1), 1);
break;
case POWER_IC_IOCTL_CMD_EMU_GLUE_SET_LOW_SPEED_MODE:
power_ic_set_reg_value(POWER_IC_REG_ATLAS_USB_0, 0,
(arg == 0 ? 0 : 1), 1);
break;
case POWER_IC_IOCTL_CMD_EMU_GLUE_SET_USB_SUSPEND:
power_ic_set_reg_value(POWER_IC_REG_ATLAS_USB_0, 1,
(arg == 0 ? 0 : 1), 1);
break;
case POWER_IC_IOCTL_CMD_EMU_GLUE_SET_TRANSCEIVER_PARAMS:
/* Fetch the data passed from user space. */
if(copy_from_user((void *)&trans_params, (void *)arg, sizeof(trans_params)) != 0)
{
tracemsg(_k_d("error copying data from user space."));
ret_val = -EFAULT;
}
else
{
/* Call local function */
emu_glue_set_transceiver_params(trans_params);
}
break;
case POWER_IC_IOCTL_CMD_EMU_GLUE_SET_ID_INT_MASK:
power_ic_set_reg_value(POWER_IC_REG_ATLAS_INT_MASK_0, 19,
arg, 1);
break;
case POWER_IC_IOCTL_CMD_EMU_GLUE_SET_VBUS_INT_MASK:
power_ic_set_reg_value(POWER_IC_REG_ATLAS_INT_MASK_0, 16,
arg, 1);
break;
case POWER_IC_IOCTL_CMD_EMU_GLUE_SET_SE1_INT_MASK:
power_ic_set_reg_value(POWER_IC_REG_ATLAS_INT_MASK_0, 21,
arg, 1);
break;
default: /* This shouldn't be able to happen, but just in case... */
tracemsg(_k_d("=> 0x%X unsupported emu proc ioctl command"), (int) cmd);
ret_val = -ENOTTY;
break;
}
}
else /* The driver doesn't support this request. */
{
tracemsg(_k_d("0x%X unsupported ioctl command"), (int) cmd);
ret_val = -ENOTTY;
}
return ret_val;
}
