/*! * @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; }