1157 lines
25 KiB
C
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);
|