static int mmc328x_init_probe(struct platform_device *pdev)
{
unsigned char data[16] = {0};
int res = 0;
int ret33 = 0;
if (get_hw_revision() == 0x09) {
printk("[SENSOR] hw_revision : 0x09\n ");
vreg_sensor = regulator_get(NULL, "vmmc2");
ret33 = regulator_enable(vreg_sensor);
if (ret33) {
printk("[SENSOR] Error, %s: vreg enable failed (%d)\n", __func__, ret33);
}
}
pr_info("mmc328x driver: probe\n");
g_client = omap_gpio_i2c_init(OMAP_GPIO_FM_SDA , OMAP_GPIO_FM_SCL, MMC328X_I2C_ADDR, 200);
res = misc_register(&mmc328x_device);
if (res) {
pr_err("%s: mmc328x_device register failed\n", __FUNCTION__);
goto out;
}
res = device_create_file(mmc328x_device.this_device, &dev_attr_mmc328x);
if (res) {
pr_err("%s: device_create_file failed\n", __FUNCTION__);
goto out_deregister;
}
res = sysfs_create_group(&mmc328x_device.this_device->kobj,&mmc328x_group);
if (res < 0){
pr_info("failed to create sysfs files\n");
goto out_sysinfo;
}
/* send SET/RESET cmd to mag sensor first of all */
#ifdef CONFIG_SENSORS_MMC328X
data[0] = MMC328X_REG_CTRL;
data[1] = MMC328X_CTRL_RRM;
if (mmc328x_i2c_tx_data(data, 2) < 0) {
}
msleep(MMC328X_DELAY_RRM);
data[0] = MMC328X_REG_CTRL;
data[1] = MMC328X_CTRL_TM;
if (mmc328x_i2c_tx_data(data, 2) < 0) {
}
msleep(5*MMC328X_DELAY_TM);
#endif
data[0] = MMC328X_REG_CTRL;
data[1] = MMC328X_CTRL_RM;
if (mmc328x_i2c_tx_data(data, 2) < 0) {
/* assume RM always success */
}
#ifndef CONFIG_SENSORS_MMC328X
/* wait external capacitor charging done for next RM */
msleep(MMC328X_DELAY_RM);
#else
msleep(10*MMC328X_DELAY_RM);
data[0] = MMC328X_REG_CTRL;
data[1] = MMC328X_CTRL_TM;
if (mmc328x_i2c_tx_data(data, 2) < 0) {
}
#endif
#if defined(CONFIG_HAS_EARLYSUSPEND)
early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
early_suspend.suspend = (void *)mmc328x_magnetic_suspend;
early_suspend.resume = (void *)mmc328x_magnetic_resume;
register_early_suspend(&early_suspend);
#endif
return 0;
out_sysinfo:
sysfs_remove_group(&mmc328x_device.this_device->kobj,&mmc328x_group);
out_deregister:
misc_deregister(&mmc328x_device);
out:
return res;
}
static int msm8960_audrx_init(struct snd_soc_pcm_runtime *rtd)
{
int err;
#ifdef CONFIG_PANTECH_SND //kdkim
#if defined(T_STARQ) || defined(T_OSCAR) || defined(T_EF45K) || defined(T_EF46L) || defined(T_EF47S)
int ret = 0;
int hw_rev;
#endif
#endif
struct snd_soc_codec *codec = rtd->codec;
struct snd_soc_dapm_context *dapm = &codec->dapm;
#ifndef CONFIG_PANTECH_SND //Qualcomm original...kdkim
struct pm_gpio jack_gpio_cfg = {
.direction = PM_GPIO_DIR_IN,
.pull = PM_GPIO_PULL_UP_1P5,
.function = PM_GPIO_FUNC_NORMAL,
.vin_sel = 2,
.inv_int_pol = 0,
};
#endif
pr_debug("%s()\n", __func__);
if (machine_is_msm8960_liquid()) {
top_spk_pamp_gpio = (PM8921_GPIO_PM_TO_SYS(19));
bottom_spk_pamp_gpio = (PM8921_GPIO_PM_TO_SYS(18));
}
rtd->pmdown_time = 0;
err = snd_soc_add_controls(codec, tabla_msm8960_controls,
ARRAY_SIZE(tabla_msm8960_controls));
if (err < 0)
return err;
snd_soc_dapm_new_controls(dapm, msm8960_dapm_widgets,
ARRAY_SIZE(msm8960_dapm_widgets));
#ifdef CONFIG_PANTECH_SND
if(wcd9310_tablaVersionStatusGet()) //Tabla CS Version
snd_soc_dapm_add_routes(dapm, common_cs_audio_map,
ARRAY_SIZE(common_cs_audio_map));
else //Tabla ES Version
snd_soc_dapm_add_routes(dapm, common_audio_map,
ARRAY_SIZE(common_audio_map));
#else //Qualcomm Original Source
snd_soc_dapm_add_routes(dapm, common_audio_map,
ARRAY_SIZE(common_audio_map));
#endif
snd_soc_dapm_enable_pin(dapm, "Ext Spk Bottom Pos");
snd_soc_dapm_enable_pin(dapm, "Ext Spk Bottom Neg");
snd_soc_dapm_enable_pin(dapm, "Ext Spk Top Pos");
snd_soc_dapm_enable_pin(dapm, "Ext Spk Top Neg");
snd_soc_dapm_sync(dapm);
err = snd_soc_jack_new(codec, "Headset Jack",
(SND_JACK_HEADSET | SND_JACK_OC_HPHL |
SND_JACK_OC_HPHR),
&hs_jack);
if (err) {
pr_err("failed to create new jack\n");
return err;
}
err = snd_soc_jack_new(codec, "Button Jack",
TABLA_JACK_BUTTON_MASK, &button_jack);
if (err) {
pr_err("failed to create new jack\n");
return err;
}
#ifdef CONFIG_PANTECH_SND //kdkim
hw_rev = get_hw_revision();
pr_debug("########### msm8960 hw_rev : %d\n", hw_rev);
#if defined(T_STARQ)
if(hw_rev < 5) {
mbhc_cfg.gpio = 0;
mbhc_cfg.gpio_irq = 0;
}
#elif defined(T_OSCAR)
if(hw_rev < 4) { /*revision is checked by elecjang 20120326*/
mbhc_cfg.gpio = 0;
mbhc_cfg.gpio_irq = 0;
}
#elif defined(T_EF47S) || defined(T_EF45K)
if(hw_rev < 5) {
mbhc_cfg.gpio = 0;
mbhc_cfg.gpio_irq = 0;
}
#elif defined(T_EF46L)
if(hw_rev < 4) {
mbhc_cfg.gpio = 0;
mbhc_cfg.gpio_irq = 0;
}
#endif
#endif
#ifdef CONFIG_PANTECH_SND //kdkim
#if defined(T_STARQ) || defined(T_OSCAR) || defined(T_EF45K) || defined(T_EF46L) || defined(T_EF47S)
if (mbhc_cfg.gpio) {
ret = gpio_request(JACK_DETECT_GPIO, "headset_detect");
if(ret){
pr_err("%s: gpio_request failed %d\n", __func__,
ret);
headset_gpio_config = false;
gpio_free(JACK_DETECT_GPIO);
}
ret = gpio_direction_input(mbhc_cfg.gpio);
if(ret){
pr_err("%s: gpio_direction_input failed %d\n", __func__,
ret);
headset_gpio_config = false;
gpio_free(JACK_DETECT_GPIO);
}
mbhc_cfg.gpio_irq = gpio_to_irq(mbhc_cfg.gpio);
}
#endif
#else //Qualcomm original
if (GPIO_DETECT_USED) {
mbhc_cfg.gpio = PM8921_GPIO_PM_TO_SYS(JACK_DETECT_GPIO);
mbhc_cfg.gpio_irq = JACK_DETECT_INT;
}
if (mbhc_cfg.gpio) {
err = pm8xxx_gpio_config(mbhc_cfg.gpio, &jack_gpio_cfg);
if (err) {
pr_err("%s: pm8xxx_gpio_config failed %d\n", __func__,
err);
return err;
}
}
#endif
err = tabla_hs_detect(codec, &mbhc_cfg);
return err;
}
static struct snd_soc_dsp_link lpa_fe_media = {
.playback = true,
.trigger = {
SND_SOC_DSP_TRIGGER_POST,
SND_SOC_DSP_TRIGGER_POST
},
};
static struct snd_soc_dsp_link fe_media = {
.playback = true,
.capture = true,
.trigger = {
SND_SOC_DSP_TRIGGER_POST,
SND_SOC_DSP_TRIGGER_POST
},
};
/* bi-directional media definition for hostless PCM device */
static struct snd_soc_dsp_link bidir_hl_media = {
.playback = true,
.capture = true,
.trigger = {
SND_SOC_DSP_TRIGGER_POST,
SND_SOC_DSP_TRIGGER_POST
},
};
static struct snd_soc_dsp_link hdmi_rx_hl = {
.playback = true,
.trigger = {
SND_SOC_DSP_TRIGGER_POST,
SND_SOC_DSP_TRIGGER_POST
},
};
static int msm8960_slim_0_rx_be_hw_params_fixup(struct snd_soc_pcm_runtime *rtd,
struct snd_pcm_hw_params *params)
{
struct snd_interval *rate = hw_param_interval(params,
SNDRV_PCM_HW_PARAM_RATE);
struct snd_interval *channels = hw_param_interval(params,
SNDRV_PCM_HW_PARAM_CHANNELS);
pr_debug("%s()\n", __func__);
rate->min = rate->max = 48000;
channels->min = channels->max = msm8960_slim_0_rx_ch;
return 0;
}
static int msm8960_slim_0_tx_be_hw_params_fixup(struct snd_soc_pcm_runtime *rtd,
struct snd_pcm_hw_params *params)
{
struct snd_interval *rate = hw_param_interval(params,
SNDRV_PCM_HW_PARAM_RATE);
struct snd_interval *channels = hw_param_interval(params,
SNDRV_PCM_HW_PARAM_CHANNELS);
pr_debug("%s()\n", __func__);
rate->min = rate->max = 48000;
channels->min = channels->max = msm8960_slim_0_tx_ch;
return 0;
}
static int msm8960_be_hw_params_fixup(struct snd_soc_pcm_runtime *rtd,
struct snd_pcm_hw_params *params)
{
struct snd_interval *rate = hw_param_interval(params,
SNDRV_PCM_HW_PARAM_RATE);
pr_debug("%s()\n", __func__);
rate->min = rate->max = 48000;
return 0;
}
static int msm8960_hdmi_be_hw_params_fixup(struct snd_soc_pcm_runtime *rtd,
struct snd_pcm_hw_params *params)
{
struct snd_interval *rate = hw_param_interval(params,
SNDRV_PCM_HW_PARAM_RATE);
struct snd_interval *channels = hw_param_interval(params,
SNDRV_PCM_HW_PARAM_CHANNELS);
pr_debug("%s channels->min %u channels->max %u ()\n", __func__,
channels->min, channels->max);
rate->min = rate->max = 48000;
return 0;
}
static int msm8960_btsco_be_hw_params_fixup(struct snd_soc_pcm_runtime *rtd,
struct snd_pcm_hw_params *params)
{
struct snd_interval *rate = hw_param_interval(params,
SNDRV_PCM_HW_PARAM_RATE);
struct snd_interval *channels = hw_param_interval(params,
SNDRV_PCM_HW_PARAM_CHANNELS);
rate->min = rate->max = msm8960_btsco_rate;
channels->min = channels->max = msm8960_btsco_ch;
return 0;
}
static int msm8960_auxpcm_be_params_fixup(struct snd_soc_pcm_runtime *rtd,
struct snd_pcm_hw_params *params)
{
struct snd_interval *rate = hw_param_interval(params,
SNDRV_PCM_HW_PARAM_RATE);
struct snd_interval *channels = hw_param_interval(params,
SNDRV_PCM_HW_PARAM_CHANNELS);
/* PCM only supports mono output with 8khz sample rate */
rate->min = rate->max = 8000;
channels->min = channels->max = 1;
return 0;
}
static int msm8960_aux_pcm_get_gpios(void)
{
int ret = 0;
pr_debug("%s\n", __func__);
ret = gpio_request(GPIO_AUX_PCM_DOUT, "AUX PCM DOUT");
if (ret < 0) {
pr_err("%s: Failed to request gpio(%d): AUX PCM DOUT",
__func__, GPIO_AUX_PCM_DOUT);
goto fail_dout;
}
ret = gpio_request(GPIO_AUX_PCM_DIN, "AUX PCM DIN");
if (ret < 0) {
pr_err("%s: Failed to request gpio(%d): AUX PCM DIN",
__func__, GPIO_AUX_PCM_DIN);
goto fail_din;
}
ret = gpio_request(GPIO_AUX_PCM_SYNC, "AUX PCM SYNC");
if (ret < 0) {
pr_err("%s: Failed to request gpio(%d): AUX PCM SYNC",
__func__, GPIO_AUX_PCM_SYNC);
goto fail_sync;
}
ret = gpio_request(GPIO_AUX_PCM_CLK, "AUX PCM CLK");
if (ret < 0) {
pr_err("%s: Failed to request gpio(%d): AUX PCM CLK",
__func__, GPIO_AUX_PCM_CLK);
goto fail_clk;
}
return 0;
fail_clk:
gpio_free(GPIO_AUX_PCM_SYNC);
fail_sync:
gpio_free(GPIO_AUX_PCM_DIN);
fail_din:
gpio_free(GPIO_AUX_PCM_DOUT);
fail_dout:
return ret;
}
static int msm8960_aux_pcm_free_gpios(void)
{
gpio_free(GPIO_AUX_PCM_DIN);
gpio_free(GPIO_AUX_PCM_DOUT);
gpio_free(GPIO_AUX_PCM_SYNC);
gpio_free(GPIO_AUX_PCM_CLK);
return 0;
}
static int msm8960_startup(struct snd_pcm_substream *substream)
{
pr_debug("%s(): substream = %s stream = %d\n", __func__,
substream->name, substream->stream);
return 0;
}
static int msm8960_auxpcm_startup(struct snd_pcm_substream *substream)
{
int ret = 0;
pr_debug("%s(): substream = %s\n", __func__, substream->name);
ret = msm8960_aux_pcm_get_gpios();
if (ret < 0) {
pr_err("%s: Aux PCM GPIO request failed\n", __func__);
return -EINVAL;
}
return 0;
}
static void msm8960_auxpcm_shutdown(struct snd_pcm_substream *substream)
{
pr_debug("%s(): substream = %s\n", __func__, substream->name);
msm8960_aux_pcm_free_gpios();
}
int main(int argc, char **argv)
{
int c;
char fname[MAX_IMAGE_FNAME];
const char *software_select = NULL;
int opt_i = 0;
int opt_e = 0;
int opt_s = 0;
int opt_w = 0;
struct hw_type hwrev;
char image_url[MAX_URL];
int opt_d = 0;
RECOVERY_STATUS result;
#ifdef CONFIG_WEBSERVER
char weboptions[1024];
char **av = NULL;
int ac = 0;
#endif
memset(&flashdesc, 0, sizeof(flashdesc));
memset(main_options, 0, sizeof(main_options));
strcpy(main_options, "vhi:se:");
#ifdef CONFIG_MTD
strcat(main_options, "b:");
#endif
#ifdef CONFIG_DOWNLOAD
strcat(main_options, "d:");
#endif
#ifdef CONFIG_WEBSERVER
strcat(main_options, "w:");
#endif
memset(fname, 0, sizeof(fname));
printf("%s\n", BANNER);
printf("Licensed under GPLv2. See source distribution for detailed "
"copyright notices.\n\n");
/* Process options with getopt */
while ((c = getopt_long(argc, argv, main_options,
long_options, NULL)) != EOF) {
switch (c) {
case 'v':
verbose++;
break;
#ifdef CONFIG_MTD
case 'b':
mtd_set_ubiblacklist(optarg);
break;
#endif
case 'i':
strncpy(fname, optarg, sizeof(fname));
opt_i = 1;
break;
case 'e':
software_select = optarg;
opt_e = 1;
break;
case 'h':
usage(argv[0]);
exit(0);
break;
#ifdef CONFIG_DOWNLOAD
case 'd':
strncpy(image_url, optarg, sizeof(image_url));
opt_d = 1;
break;
#endif
case 's': /* run as server */
opt_s = 1;
break;
#ifdef CONFIG_WEBSERVER
case 'w':
snprintf(weboptions, sizeof(weboptions), "%s %s", argv[0], optarg);
av = splitargs(weboptions, &ac);
opt_w = 1;
break;
#endif
default:
usage(argv[0]);
exit(1);
break;
}
}
swupdate_init(&swcfg);
lua_handlers_init();
if(!get_hw_revision(&hwrev))
printf("Running on %s Revision %s\n", hwrev.boardname, hwrev.revision);
print_registered_handlers();
notify_init();
if (opt_e) {
if (parse_image_selector(software_select, &swcfg)) {
fprintf(stderr, "Incorrect select option format\n");
exit(1);
}
fprintf(stderr, "software set: %s mode: %s\n",
swcfg.software_set, swcfg.running_mode);
}
network_daemon = start_thread(network_initializer, &swcfg);
if (opt_i) {
install_from_file(fname);
cleanup_files(&swcfg);
notify(SUCCESS, 0, 0);
}
if (opt_d) {
result =download_from_url(image_url);
if (result == SUCCESS)
exit(0);
else
exit(1);
}
/* Start embedded web server */
#if defined(CONFIG_MONGOOSE)
if (opt_w)
start_mongoose(ac, av);
#endif
if (opt_w || opt_s)
pthread_join(network_daemon, NULL);
}
