M7350/kernel/arch/arm/mach-msm/pmic_debugfs.c
2024-09-09 08:52:07 +00:00

1157 lines
25 KiB
C

/* Copyright (c) 2009, The Linux Foundation. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 and
* only version 2 as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
*/
#include <linux/module.h>
#include <linux/init.h>
#include <linux/debugfs.h>
#include <linux/err.h>
#include <linux/uaccess.h>
#include <mach/pmic.h>
static int debug_lp_mode_control(char *buf, int size)
{
enum switch_cmd cmd;
enum vreg_lp_id id;
int cnt;
cnt = sscanf(buf, "%u %u", &cmd, &id);
if (cnt < 2) {
printk(KERN_ERR "%s: sscanf failed cnt=%d", __func__, cnt);
return -EINVAL;
}
if (pmic_lp_mode_control(cmd, id) < 0)
return -EFAULT;
return size;
}
static int debug_vreg_set_level(char *buf, int size)
{
enum vreg_id vreg;
int level;
int cnt;
cnt = sscanf(buf, "%u %u", &vreg, &level);
if (cnt < 2) {
printk(KERN_ERR "%s: sscanf failed cnt=%d", __func__, cnt);
return -EINVAL;
}
if (pmic_vreg_set_level(vreg, level) < 0)
return -EFAULT;
return size;
}
static int debug_vreg_pull_down_switch(char *buf, int size)
{
enum switch_cmd cmd;
enum vreg_pdown_id id;
int cnt;
cnt = sscanf(buf, "%u %u", &cmd, &id);
if (cnt < 2) {
printk(KERN_ERR "%s: sscanf failed cnt=%d", __func__, cnt);
return -EINVAL;
}
if (pmic_vreg_pull_down_switch(cmd, id) < 0)
return -EFAULT;
return size;
}
static int debug_secure_mpp_control_digital_output(char *buf, int size)
{
enum mpp_which which;
enum mpp_dlogic_level level;
enum mpp_dlogic_out_ctrl out;
int cnt;
cnt = sscanf(buf, "%u %u %u", &which, &level, &out);
if (cnt < 3) {
printk(KERN_ERR "%s: sscanf failed cnt=%d" , __func__, cnt);
return -EINVAL;
}
if (pmic_secure_mpp_control_digital_output(which, level, out) < 0)
return -EFAULT;
return size;
}
static int debug_secure_mpp_config_i_sink(char *buf, int size)
{
enum mpp_which which;
enum mpp_i_sink_level level;
enum mpp_i_sink_switch onoff;
int cnt;
cnt = sscanf(buf, "%u %u %u", &which, &level, &onoff);
if (cnt < 3) {
printk(KERN_ERR "%s: sscanf failed cnt=%d" , __func__, cnt);
return -EINVAL;
}
if (pmic_secure_mpp_config_i_sink(which, level, onoff) < 0)
return -EFAULT;
return size;
}
static int debug_secure_mpp_config_digital_input(char *buf, int size)
{
enum mpp_which which;
enum mpp_dlogic_level level;
enum mpp_dlogic_in_dbus dbus;
int cnt;
cnt = sscanf(buf, "%u %u %u", &which, &level, &dbus);
if (cnt < 3) {
printk(KERN_ERR "%s: sscanf failed cnt=%d" , __func__, cnt);
return -EINVAL;
}
if (pmic_secure_mpp_config_digital_input(which, level, dbus) < 0)
return -EFAULT;
return size;
}
static int debug_rtc_start(char *buf, int size)
{
uint time;
struct rtc_time *hal;
int cnt;
cnt = sscanf(buf, "%d", &time);
if (cnt < 1) {
printk(KERN_ERR "%s: sscanf failed cnt=%d" , __func__, cnt);
return -EINVAL;
}
hal = (struct rtc_time *)&time;
if (pmic_rtc_start(hal) < 0)
return -EFAULT;
return size;
}
static int debug_rtc_stop(char *buf, int size)
{
if (pmic_rtc_stop() < 0)
return -EFAULT;
return size;
}
static int debug_rtc_get_time(char *buf, int size)
{
uint time;
struct rtc_time *hal;
hal = (struct rtc_time *)&time;
if (pmic_rtc_get_time(hal) < 0)
return -EFAULT;
return snprintf(buf, size, "%d\n", time);
}
static int debug_rtc_alarm_ndx;
int debug_rtc_enable_alarm(char *buf, int size)
{
enum rtc_alarm alarm;
struct rtc_time *hal;
uint time;
int cnt;
cnt = sscanf(buf, "%u %u", &alarm, &time);
if (cnt < 2) {
printk(KERN_ERR "%s: sscanf failed cnt=%d" , __func__, cnt);
return -EINVAL;
}
hal = (struct rtc_time *)&time;
if (pmic_rtc_enable_alarm(alarm, hal) < 0)
return -EFAULT;
debug_rtc_alarm_ndx = alarm;
return size;
}
static int debug_rtc_disable_alarm(char *buf, int size)
{
enum rtc_alarm alarm;
int cnt;
cnt = sscanf(buf, "%u", &alarm);
if (cnt < 1) {
printk(KERN_ERR "%s: sscanf failed cnt=%d" , __func__, cnt);
return -EINVAL;
}
if (pmic_rtc_disable_alarm(alarm) < 0)
return -EFAULT;
return size;
}
static int debug_rtc_get_alarm_time(char *buf, int size)
{
uint time;
struct rtc_time *hal;
hal = (struct rtc_time *)&time;
if (pmic_rtc_get_alarm_time(debug_rtc_alarm_ndx, hal) < 0)
return -EFAULT;
return snprintf(buf, size, "%d\n", time);
}
static int debug_rtc_get_alarm_status(char *buf, int size)
{
int status;;
if (pmic_rtc_get_alarm_status(&status) < 0)
return -EFAULT;
return snprintf(buf, size, "%d\n", status);
}
static int debug_rtc_set_time_adjust(char *buf, int size)
{
uint adjust;
int cnt;
cnt = sscanf(buf, "%d", &adjust);
if (cnt < 1) {
printk(KERN_ERR "%s: sscanf failed cnt=%d" , __func__, cnt);
return -EINVAL;
}
if (pmic_rtc_set_time_adjust(adjust) < 0)
return -EFAULT;
return size;
}
static int debug_rtc_get_time_adjust(char *buf, int size)
{
int adjust;;
if (pmic_rtc_get_time_adjust(&adjust) < 0)
return -EFAULT;
return snprintf(buf, size, "%d\n", adjust);
}
static int debug_set_led_intensity(char *buf, int size)
{
enum ledtype type;
int level;
int cnt;
cnt = sscanf(buf, "%u %d", &type, &level);
if (cnt < 2) {
printk(KERN_ERR "%s: sscanf failed cnt=%d" , __func__, cnt);
return -EINVAL;
}
if (pmic_set_led_intensity(type, level) < 0)
return -EFAULT;
return size;
}
static int debug_flash_led_set_current(char *buf, int size)
{
int milliamps;
int cnt;
cnt = sscanf(buf, "%d", &milliamps);
if (cnt < 1) {
printk(KERN_ERR "%s: sscanf failed cnt=%d" , __func__, cnt);
return -EINVAL;
}
if (pmic_flash_led_set_current(milliamps) < 0)
return -EFAULT;
return size;
}
static int debug_flash_led_set_mode(char *buf, int size)
{
uint mode;
int cnt;
cnt = sscanf(buf, "%d", &mode);
if (cnt < 1) {
printk(KERN_ERR "%s: sscanf failed cnt=%d" , __func__, cnt);
return -EINVAL;
}
if (pmic_flash_led_set_mode(mode) < 0)
return -EFAULT;
return size;
}
static int debug_flash_led_set_polarity(char *buf, int size)
{
int pol;
int cnt;
cnt = sscanf(buf, "%d", &pol);
if (cnt < 1) {
printk(KERN_ERR "%s: sscanf failed cnt=%d" , __func__, cnt);
return -EINVAL;
}
if (pmic_flash_led_set_polarity(pol) < 0)
return -EFAULT;
return size;
}
static int debug_speaker_cmd(char *buf, int size)
{
int cmd;
int cnt;
cnt = sscanf(buf, "%d", &cmd);
if (cnt < 1) {
printk(KERN_ERR "%s: sscanf failed cnt=%d" , __func__, cnt);
return -EINVAL;
}
if (pmic_speaker_cmd(cmd) < 0)
return -EFAULT;
return size;
}
static int debug_set_speaker_gain(char *buf, int size)
{
int gain;
int cnt;
cnt = sscanf(buf, "%d", &gain);
if (cnt < 1) {
printk(KERN_ERR "%s: sscanf failed cnt=%d" , __func__, cnt);
return -EINVAL;
}
if (pmic_set_speaker_gain(gain) < 0)
return -EFAULT;
return size;
}
static int debug_mic_en(char *buf, int size)
{
int enable;
int cnt;
cnt = sscanf(buf, "%d", &enable);
if (cnt < 1) {
printk(KERN_ERR "%s: sscanf failed cnt=%d" , __func__, cnt);
return -EINVAL;
}
if (pmic_mic_en(enable) < 0)
return -EFAULT;
return size;
}
static int debug_mic_is_en(char *buf, int size)
{
int enabled;
if (pmic_mic_is_en(&enabled) < 0)
return -EFAULT;
return snprintf(buf, size, "%d\n", enabled);
}
static int debug_mic_set_volt(char *buf, int size)
{
int vol;
int cnt;
cnt = sscanf(buf, "%d", &vol);
if (cnt < 1) {
printk(KERN_ERR "%s: sscanf failed cnt=%d" , __func__, cnt);
return -EINVAL;
}
if (pmic_mic_set_volt(vol) < 0)
return -EFAULT;
return size;
}
static int debug_mic_get_volt(char *buf, int size)
{
uint vol;
if (pmic_mic_get_volt(&vol) < 0)
return -EFAULT;
return snprintf(buf, size, "%d\n", vol);
}
static int debug_spkr_en_right_chan(char *buf, int size)
{
int enable;
int cnt;
cnt = sscanf(buf, "%d", &enable);
if (cnt < 1) {
printk(KERN_ERR "%s: sscanf failed cnt=%d" , __func__, cnt);
return -EINVAL;
}
if (pmic_spkr_en_right_chan(enable) < 0)
return -EFAULT;
return size;
}
static int debug_spkr_is_right_chan_en(char *buf, int size)
{
int enabled;
if (pmic_spkr_is_right_chan_en(&enabled) < 0)
return -EFAULT;
return snprintf(buf, size, "%d\n", enabled);
}
static int debug_spkr_en_left_chan(char *buf, int size)
{
int enable;
int cnt;
cnt = sscanf(buf, "%d", &enable);
if (cnt < 1) {
printk(KERN_ERR "%s: sscanf failed cnt=%d" , __func__, cnt);
return -EINVAL;
}
if (pmic_spkr_en_left_chan(enable) < 0)
return -EFAULT;
return size;
}
static int debug_spkr_is_left_chan_en(char *buf, int size)
{
int enabled;
if (pmic_spkr_is_left_chan_en(&enabled) < 0)
return -EFAULT;
return snprintf(buf, size, "%d\n", enabled);
}
static int debug_set_spkr_configuration(char *buf, int size)
{
struct spkr_config_mode cfg;
int cnt;
cnt = sscanf(buf, "%d %d %d %d %d %d %d %d",
&cfg.is_right_chan_en,
&cfg.is_left_chan_en,
&cfg.is_right_left_chan_added,
&cfg.is_stereo_en,
&cfg.is_usb_with_hpf_20hz,
&cfg.is_mux_bypassed,
&cfg.is_hpf_en,
&cfg.is_sink_curr_from_ref_volt_cir_en);
if (cnt < 8) {
printk(KERN_ERR "%s: sscanf failed cnt=%d" , __func__, cnt);
return -EINVAL;
}
if (pmic_set_spkr_configuration(&cfg) < 0)
return -EFAULT;
return size;
}
static int debug_get_spkr_configuration(char *buf, int size)
{
struct spkr_config_mode cfg;
if (pmic_get_spkr_configuration(&cfg) < 0)
return -EFAULT;
return snprintf(buf, size, "%d %d %d %d %d %d %d %d\n",
cfg.is_right_chan_en,
cfg.is_left_chan_en,
cfg.is_right_left_chan_added,
cfg.is_stereo_en,
cfg.is_usb_with_hpf_20hz,
cfg.is_mux_bypassed,
cfg.is_hpf_en,
cfg.is_sink_curr_from_ref_volt_cir_en);
}
static int debug_set_speaker_delay(char *buf, int size)
{
int delay;
int cnt;
cnt = sscanf(buf, "%d", &delay);
if (cnt < 1) {
printk(KERN_ERR "%s: sscanf failed cnt=%d" , __func__, cnt);
return -EINVAL;
}
if (pmic_set_speaker_delay(delay) < 0)
return -EFAULT;
return size;
}
static int debug_speaker_1k6_zin_enable(char *buf, int size)
{
uint enable;
int cnt;
cnt = sscanf(buf, "%u", &enable);
if (cnt < 1) {
printk(KERN_ERR "%s: sscanf failed cnt=%d" , __func__, cnt);
return -EINVAL;
}
if (pmic_speaker_1k6_zin_enable(enable) < 0)
return -EFAULT;
return size;
}
static int debug_spkr_set_mux_hpf_corner_freq(char *buf, int size)
{
int freq;
int cnt;
cnt = sscanf(buf, "%d", &freq);
if (cnt < 1) {
printk(KERN_ERR "%s: sscanf failed cnt=%d" , __func__, cnt);
return -EINVAL;
}
if (pmic_spkr_set_mux_hpf_corner_freq(freq) < 0)
return -EFAULT;
return size;
}
static int debug_spkr_get_mux_hpf_corner_freq(char *buf, int size)
{
uint freq;
if (pmic_spkr_get_mux_hpf_corner_freq(&freq) < 0)
return -EFAULT;
return snprintf(buf, size, "%d\n", freq);
}
static int debug_spkr_add_right_left_chan(char *buf, int size)
{
int enable;
int cnt;
cnt = sscanf(buf, "%d", &enable);
if (cnt < 1) {
printk(KERN_ERR "%s: sscanf failed cnt=%d" , __func__, cnt);
return -EINVAL;
}
if (pmic_spkr_add_right_left_chan(enable) < 0)
return -EFAULT;
return size;
}
static int debug_spkr_is_right_left_chan_added(char *buf, int size)
{
int enabled;
if (pmic_spkr_is_right_left_chan_added(&enabled) < 0)
return -EFAULT;
return snprintf(buf, size, "%d\n", enabled);
}
static int debug_spkr_en_stereo(char *buf, int size)
{
int enable;
int cnt;
cnt = sscanf(buf, "%d", &enable);
if (cnt < 1) {
printk(KERN_ERR "%s: sscanf failed cnt=%d" , __func__, cnt);
return -EINVAL;
}
if (pmic_spkr_en_stereo(enable) < 0)
return -EFAULT;
return size;
}
static int debug_spkr_is_stereo_en(char *buf, int size)
{
int enabled;
if (pmic_spkr_is_stereo_en(&enabled) < 0)
return -EFAULT;
return snprintf(buf, size, "%d\n", enabled);
}
static int debug_spkr_select_usb_with_hpf_20hz(char *buf, int size)
{
int enable;
int cnt;
cnt = sscanf(buf, "%d", &enable);
if (cnt < 1) {
printk(KERN_ERR "%s: sscanf failed cnt=%d" , __func__, cnt);
return -EINVAL;
}
if (pmic_spkr_select_usb_with_hpf_20hz(enable) < 0)
return -EFAULT;
return size;
}
static int debug_spkr_is_usb_with_hpf_20hz(char *buf, int size)
{
int enabled;
if (pmic_spkr_is_usb_with_hpf_20hz(&enabled) < 0)
return -EFAULT;
return snprintf(buf, size, "%d\n", enabled);
}
static int debug_spkr_bypass_mux(char *buf, int size)
{
int enable;
int cnt;
cnt = sscanf(buf, "%d", &enable);
if (cnt < 1) {
printk(KERN_ERR "%s: sscanf failed cnt=%d" , __func__, cnt);
return -EINVAL;
}
if (pmic_spkr_bypass_mux(enable) < 0)
return -EFAULT;
return size;
}
static int debug_spkr_is_mux_bypassed(char *buf, int size)
{
int enabled;
if (pmic_spkr_is_mux_bypassed(&enabled) < 0)
return -EFAULT;
return snprintf(buf, size, "%d\n", enabled);
}
static int debug_spkr_en_hpf(char *buf, int size)
{
int enable;
int cnt;
cnt = sscanf(buf, "%d", &enable);
if (cnt < 1) {
printk(KERN_ERR "%s: sscanf failed cnt=%d" , __func__, cnt);
return -EINVAL;
}
if (pmic_spkr_en_hpf(enable) < 0)
return -EFAULT;
return size;
}
static int debug_spkr_is_hpf_en(char *buf, int size)
{
int enabled;
if (pmic_spkr_is_hpf_en(&enabled) < 0)
return -EFAULT;
return snprintf(buf, size, "%d\n", enabled);
}
static int debug_spkr_en_sink_curr_from_ref_volt_cir(char *buf, int size)
{
int enable;
int cnt;
cnt = sscanf(buf, "%d", &enable);
if (cnt < 1) {
printk(KERN_ERR "%s: sscanf failed cnt=%d" , __func__, cnt);
return -EINVAL;
}
if (pmic_spkr_en_sink_curr_from_ref_volt_cir(enable) < 0)
return -EFAULT;
return size;
}
static int debug_spkr_is_sink_curr_from_ref_volt_cir_en(char *buf, int size)
{
int enabled;
if (pmic_spkr_is_sink_curr_from_ref_volt_cir_en(&enabled) < 0)
return -EFAULT;
return snprintf(buf, size, "%d\n", enabled);
}
static int debug_vib_mot_set_volt(char *buf, int size)
{
int vol;
int cnt;
cnt = sscanf(buf, "%d", &vol);
if (cnt < 1) {
printk(KERN_ERR "%s: sscanf failed cnt=%d" , __func__, cnt);
return -EINVAL;
}
if (pmic_vib_mot_set_volt(vol) < 0)
return -EFAULT;
return size;
}
static int debug_vib_mot_set_mode(char *buf, int size)
{
int mode;
int cnt;
cnt = sscanf(buf, "%d", &mode);
if (cnt < 1) {
printk(KERN_ERR "%s: sscanf failed cnt=%d" , __func__, cnt);
return -EINVAL;
}
if (pmic_vib_mot_set_mode(mode) < 0)
return -EFAULT;
return size;
}
static int debug_vib_mot_set_polarity(char *buf, int size)
{
int pol;
int cnt;
cnt = sscanf(buf, "%d", &pol);
if (cnt < 1) {
printk(KERN_ERR "%s: sscanf failed cnt=%d" , __func__, cnt);
return -EINVAL;
}
if (pmic_vib_mot_set_polarity(pol) < 0)
return -EFAULT;
return size;
}
static int debug_vid_en(char *buf, int size)
{
int enable;
int cnt;
cnt = sscanf(buf, "%d", &enable);
if (cnt < 1) {
printk(KERN_ERR "%s: sscanf failed cnt=%d" , __func__, cnt);
return -EINVAL;
}
if (pmic_vid_en(enable) < 0)
return -EFAULT;
return size;
}
static int debug_vid_is_en(char *buf, int size)
{
int enabled;
if (pmic_vid_is_en(&enabled) < 0)
return -EFAULT;
return snprintf(buf, size, "%d\n", enabled);
}
static int debug_vid_load_detect_en(char *buf, int size)
{
int enable;
int cnt;
cnt = sscanf(buf, "%d", &enable);
if (cnt < 1) {
printk(KERN_ERR "%s: sscanf failed cnt=%d" , __func__, cnt);
return -EINVAL;
}
if (pmic_vid_load_detect_en(enable) < 0)
return -EFAULT;
return size;
}
/**************************************************
* speaker indexed by left_right
**************************************************/
static enum spkr_left_right debug_spkr_left_right = LEFT_SPKR;
static int debug_spkr_en(char *buf, int size)
{
int left_right;
int enable;
int cnt;
cnt = sscanf(buf, "%d %d", &left_right, &enable);
if (cnt < 2) {
printk(KERN_ERR "%s: sscanf failed cnt=%d" , __func__, cnt);
return -EINVAL;
}
if (pmic_spkr_en(left_right, enable) >= 0) {
debug_spkr_left_right = left_right;
return size;
}
return -EFAULT;
}
static int debug_spkr_is_en(char *buf, int size)
{
int enabled;
if (pmic_spkr_is_en(debug_spkr_left_right, &enabled) < 0)
return -EFAULT;
return snprintf(buf, size, "%d\n", enabled);
}
static int debug_spkr_set_gain(char *buf, int size)
{
int left_right;
int enable;
int cnt;
cnt = sscanf(buf, "%d %d", &left_right, &enable);
if (cnt < 2) {
printk(KERN_ERR "%s: sscanf failed cnt=%d" , __func__, cnt);
return -EINVAL;
}
if (pmic_spkr_set_gain(left_right, enable) >= 0) {
debug_spkr_left_right = left_right;
return size;
}
return -EFAULT;
}
static int debug_spkr_get_gain(char *buf, int size)
{
uint gain;
if (pmic_spkr_get_gain(debug_spkr_left_right, &gain) < 0)
return -EFAULT;
return snprintf(buf, size, "%d\n", gain);
}
static int debug_spkr_set_delay(char *buf, int size)
{
int left_right;
int delay;
int cnt;
cnt = sscanf(buf, "%d %d", &left_right, &delay);
if (cnt < 2) {
printk(KERN_ERR "%s: sscanf failed cnt=%d" , __func__, cnt);
return -EINVAL;
}
if (pmic_spkr_set_delay(left_right, delay) >= 0) {
debug_spkr_left_right = left_right;
return size;
}
return -EFAULT;
}
static int debug_spkr_get_delay(char *buf, int size)
{
uint delay;
if (pmic_spkr_get_delay(debug_spkr_left_right, &delay) < 0)
return -EFAULT;
return snprintf(buf, size, "%d\n", delay);
}
static int debug_spkr_en_mute(char *buf, int size)
{
int left_right;
int enable;
int cnt;
cnt = sscanf(buf, "%d %d", &left_right, &enable);
if (cnt < 2) {
printk(KERN_ERR "%s: sscanf failed cnt=%d" , __func__, cnt);
return -EINVAL;
}
if (pmic_spkr_en_mute(left_right, enable) >= 0) {
debug_spkr_left_right = left_right;
return size;
}
return -EFAULT;
}
static int debug_spkr_is_mute_en(char *buf, int size)
{
int enabled;
if (pmic_spkr_is_mute_en(debug_spkr_left_right, &enabled) < 0)
return -EFAULT;
return snprintf(buf, size, "%d\n", enabled);
}
/*******************************************************************
* debug function table
*******************************************************************/
struct pmic_debug_desc {
int (*get) (char *, int);
int (*set) (char *, int);
};
struct pmic_debug_desc pmic_debug[] = {
{NULL, NULL}, /*LIB_NULL_PROC */
{NULL, NULL}, /* LIB_RPC_GLUE_CODE_INFO_REMOTE_PROC */
{NULL, debug_lp_mode_control}, /* LP_MODE_CONTROL_PROC */
{NULL, debug_vreg_set_level}, /*VREG_SET_LEVEL_PROC */
{NULL, debug_vreg_pull_down_switch}, /*VREG_PULL_DOWN_SWITCH_PROC */
{NULL, debug_secure_mpp_control_digital_output},
/* SECURE_MPP_CONFIG_DIGITAL_OUTPUT_PROC */
/*SECURE_MPP_CONFIG_I_SINK_PROC */
{NULL, debug_secure_mpp_config_i_sink},
{NULL, debug_rtc_start}, /*RTC_START_PROC */
{NULL, debug_rtc_stop}, /* RTC_STOP_PROC */
{debug_rtc_get_time, NULL}, /* RTC_GET_TIME_PROC */
{NULL, debug_rtc_enable_alarm}, /* RTC_ENABLE_ALARM_PROC */
{NULL , debug_rtc_disable_alarm}, /*RTC_DISABLE_ALARM_PROC */
{debug_rtc_get_alarm_time, NULL}, /* RTC_GET_ALARM_TIME_PROC */
{debug_rtc_get_alarm_status, NULL}, /* RTC_GET_ALARM_STATUS_PROC */
{NULL, debug_rtc_set_time_adjust}, /* RTC_SET_TIME_ADJUST_PROC */
{debug_rtc_get_time_adjust, NULL}, /* RTC_GET_TIME_ADJUST_PROC */
{NULL, debug_set_led_intensity}, /* SET_LED_INTENSITY_PROC */
{NULL, debug_flash_led_set_current}, /* FLASH_LED_SET_CURRENT_PROC */
{NULL, debug_flash_led_set_mode}, /* FLASH_LED_SET_MODE_PROC */
{NULL, debug_flash_led_set_polarity}, /* FLASH_LED_SET_POLARITY_PROC */
{NULL, debug_speaker_cmd}, /* SPEAKER_CMD_PROC */
{NULL, debug_set_speaker_gain}, /* SET_SPEAKER_GAIN_PROC */
{NULL, debug_vib_mot_set_volt}, /* VIB_MOT_SET_VOLT_PROC */
{NULL, debug_vib_mot_set_mode}, /* VIB_MOT_SET_MODE_PROC */
{NULL, debug_vib_mot_set_polarity}, /* VIB_MOT_SET_POLARITY_PROC */
{NULL, debug_vid_en}, /* VID_EN_PROC */
{debug_vid_is_en, NULL}, /* VID_IS_EN_PROC */
{NULL, debug_vid_load_detect_en}, /* VID_LOAD_DETECT_EN_PROC */
{NULL, debug_mic_en}, /* MIC_EN_PROC */
{debug_mic_is_en, NULL}, /* MIC_IS_EN_PROC */
{NULL, debug_mic_set_volt}, /* MIC_SET_VOLT_PROC */
{debug_mic_get_volt, NULL}, /* MIC_GET_VOLT_PROC */
{NULL, debug_spkr_en_right_chan}, /* SPKR_EN_RIGHT_CHAN_PROC */
{debug_spkr_is_right_chan_en, NULL}, /* SPKR_IS_RIGHT_CHAN_EN_PROC */
{NULL, debug_spkr_en_left_chan}, /* SPKR_EN_LEFT_CHAN_PROC */
{debug_spkr_is_left_chan_en, NULL}, /* SPKR_IS_LEFT_CHAN_EN_PROC */
{NULL, debug_set_spkr_configuration}, /* SET_SPKR_CONFIGURATION_PROC */
{debug_get_spkr_configuration, NULL}, /* GET_SPKR_CONFIGURATION_PROC */
{debug_spkr_get_gain, NULL}, /* SPKR_GET_GAIN_PROC */
{debug_spkr_is_en, NULL}, /* SPKR_IS_EN_PROC */
{NULL, debug_spkr_en_mute}, /* SPKR_EN_MUTE_PROC */
{debug_spkr_is_mute_en, NULL}, /* SPKR_IS_MUTE_EN_PROC */
{NULL, debug_spkr_set_delay}, /* SPKR_SET_DELAY_PROC */
{debug_spkr_get_delay, NULL}, /* SPKR_GET_DELAY_PROC */
/* SECURE_MPP_CONFIG_DIGITAL_INPUT_PROC */
{NULL, debug_secure_mpp_config_digital_input},
{NULL, debug_set_speaker_delay}, /* SET_SPEAKER_DELAY_PROC */
{NULL, debug_speaker_1k6_zin_enable}, /* SPEAKER_1K6_ZIN_ENABLE_PROC */
/* SPKR_SET_MUX_HPF_CORNER_FREQ_PROC */
{NULL, debug_spkr_set_mux_hpf_corner_freq},
/* SPKR_GET_MUX_HPF_CORNER_FREQ_PROC */
{debug_spkr_get_mux_hpf_corner_freq, NULL},
/* SPKR_IS_RIGHT_LEFT_CHAN_ADDED_PROC */
{debug_spkr_is_right_left_chan_added, NULL},
{NULL, debug_spkr_en_stereo}, /* SPKR_EN_STEREO_PROC */
{debug_spkr_is_stereo_en, NULL}, /* SPKR_IS_STEREO_EN_PROC */
/* SPKR_SELECT_USB_WITH_HPF_20HZ_PROC */
{NULL, debug_spkr_select_usb_with_hpf_20hz},
/* SPKR_IS_USB_WITH_HPF_20HZ_PROC */
{debug_spkr_is_usb_with_hpf_20hz, NULL},
{NULL, debug_spkr_bypass_mux}, /* SPKR_BYPASS_MUX_PROC */
{debug_spkr_is_mux_bypassed, NULL}, /* SPKR_IS_MUX_BYPASSED_PROC */
{NULL, debug_spkr_en_hpf}, /* SPKR_EN_HPF_PROC */
{ debug_spkr_is_hpf_en, NULL}, /* SPKR_IS_HPF_EN_PROC */
/* SPKR_EN_SINK_CURR_FROM_REF_VOLT_CIR_PROC */
{NULL, debug_spkr_en_sink_curr_from_ref_volt_cir},
/* SPKR_IS_SINK_CURR_FROM_REF_VOLT_CIR_EN_PROC */
{debug_spkr_is_sink_curr_from_ref_volt_cir_en, NULL},
/* SPKR_ADD_RIGHT_LEFT_CHAN_PROC */
{NULL, debug_spkr_add_right_left_chan},
{NULL, debug_spkr_set_gain}, /* SPKR_SET_GAIN_PROC */
{NULL , debug_spkr_en}, /* SPKR_EN_PROC */
};
/***********************************************************************/
#define PROC_END (sizeof(pmic_debug)/sizeof(struct pmic_debug_desc))
#define PMIC_DEBUG_BUF 512
static int debug_proc; /* PROC's index */
static char debug_buf[PMIC_DEBUG_BUF];
static int proc_index_set(void *data, u64 val)
{
int ndx;
ndx = (int)val;
if (ndx >= 0 && ndx <= PROC_END)
debug_proc = ndx;
return 0;
}
static int proc_index_get(void *data, u64 *val)
{
*val = (u64)debug_proc;
return 0;
}
DEFINE_SIMPLE_ATTRIBUTE(
proc_index_fops,
proc_index_get,
proc_index_set,
"%llu\n");
static int pmic_debugfs_open(struct inode *inode, struct file *file)
{
/* non-seekable */
file->f_mode &= ~(FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE);
return 0;
}
static int pmic_debugfs_release(struct inode *inode, struct file *file)
{
return 0;
}
static ssize_t pmic_debugfs_write(
struct file *file,
const char __user *buff,
size_t count,
loff_t *ppos)
{
struct pmic_debug_desc *pd;
int len = 0;
printk(KERN_INFO "%s: proc=%d count=%d *ppos=%d\n",
__func__, debug_proc, count, (uint)*ppos);
if (count > sizeof(debug_buf))
return -EFAULT;
if (copy_from_user(debug_buf, buff, count))
return -EFAULT;
debug_buf[count] = 0; /* end of string */
pd = &pmic_debug[debug_proc];
if (pd->set) {
len = pd->set(debug_buf, count);
printk(KERN_INFO "%s: len=%d\n", __func__, len);
return len;
}
return 0;
}
static ssize_t pmic_debugfs_read(
struct file *file,
char __user *buff,
size_t count,
loff_t *ppos)
{
struct pmic_debug_desc *pd;
int len = 0;
printk(KERN_INFO "%s: proc=%d count=%d *ppos=%d\n",
__func__, debug_proc, count, (uint)*ppos);
pd = &pmic_debug[debug_proc];
if (*ppos)
return 0; /* the end */
if (pd->get) {
len = pd->get(debug_buf, sizeof(debug_buf));
if (len > 0) {
if (len > count)
len = count;
if (copy_to_user(buff, debug_buf, len))
return -EFAULT;
}
}
printk(KERN_INFO "%s: len=%d\n", __func__, len);
if (len < 0)
return 0;
*ppos += len; /* increase offset */
return len;
}
static const struct file_operations pmic_debugfs_fops = {
.open = pmic_debugfs_open,
.release = pmic_debugfs_release,
.read = pmic_debugfs_read,
.write = pmic_debugfs_write,
};
static int __init pmic_debugfs_init(void)
{
struct dentry *dent = debugfs_create_dir("pmic", NULL);
if (IS_ERR(dent)) {
printk(KERN_ERR "%s(%d): debugfs_create_dir fail, error %ld\n",
__FILE__, __LINE__, PTR_ERR(dent));
return -1;
}
if (debugfs_create_file("index", 0644, dent, 0, &proc_index_fops)
== NULL) {
printk(KERN_ERR "%s(%d): debugfs_create_file: index fail\n",
__FILE__, __LINE__);
return -1;
}
if (debugfs_create_file("debug", 0644, dent, 0, &pmic_debugfs_fops)
== NULL) {
printk(KERN_ERR "%s(%d): debugfs_create_file: debug fail\n",
__FILE__, __LINE__);
return -1;
}
debug_proc = 0;
debug_rtc_alarm_ndx = 0;
return 0;
}
late_initcall(pmic_debugfs_init);