int __init buzz_init_mmc(unsigned int sys_rev)
{
uint32_t id;
wifi_status_cb = NULL;
sdslot_vreg_enabled = 0;
printk(KERN_INFO "%s\n", __func__);
/* initial WIFI_SHUTDOWN */
id = PCOM_GPIO_CFG(BUZZ_GPIO_WIFI_EN, 0, GPIO_OUTPUT, GPIO_NO_PULL, GPIO_2MA),
msm_proc_comm(PCOM_RPC_GPIO_TLMM_CONFIG_EX, &id, 0);
msm_add_sdcc(1, &buzz_wifi_data, 0, 0);
if (opt_disable_sdcard) {
printk(KERN_INFO "buzz: SD-Card interface disabled\n");
goto done;
}
vreg_sdslot = vreg_get(0, "gp6");
if (IS_ERR(vreg_sdslot))
return PTR_ERR(vreg_sdslot);
set_irq_wake(MSM_GPIO_TO_INT(BUZZ_GPIO_SDMC_CD_N), 1);
msm_add_sdcc(2, &buzz_sdslot_data,
MSM_GPIO_TO_INT(BUZZ_GPIO_SDMC_CD_N),
IORESOURCE_IRQ_LOWEDGE | IORESOURCE_IRQ_HIGHEDGE);
done:
return 0;
}
int sapphire_init_gpio(void)
{
int i;
if (!machine_is_sapphire())
return 0;
DBG("%d,%d\r\n",SAPPHIRE_INT_START, SAPPHIRE_INT_END);
DBG("NR_MSM_IRQS=%d, NR_GPIO_IRQS=%d\r\n", NR_MSM_IRQS, NR_GPIO_IRQS);
for(i = SAPPHIRE_INT_START; i <= SAPPHIRE_INT_END; i++) {
set_irq_chip(i, &sapphire_gpio_irq_chip);
set_irq_handler(i, handle_edge_irq);
set_irq_flags(i, IRQF_VALID);
}
register_gpio_chip(&sapphire_gpio_chip);
register_gpio_chip(&sapphire_h2w_gpio_chip);
/*setup CPLD INT connecting to SOC's gpio 17 */
set_irq_type(MSM_GPIO_TO_INT(17), IRQF_TRIGGER_HIGH);
set_irq_chained_handler(MSM_GPIO_TO_INT(17), sapphire_gpio_irq_handler);
set_irq_wake(MSM_GPIO_TO_INT(17), 1);
if(sysdev_class_register(&sapphire_sysdev_class) == 0)
sysdev_register(&sapphire_irq_device);
return 0;
}
static int __init msm_serial_probe(struct platform_device *pdev)
{
struct msm_port *msm_port;
struct resource *resource;
struct uart_port *port;
#ifdef CONFIG_SERIAL_MSM_RX_WAKEUP
struct msm_serial_platform_data *pdata = pdev->dev.platform_data;
#endif
if (unlikely(pdev->id < 0 || pdev->id >= UART_NR))
return -ENXIO;
printk(KERN_INFO "msm_serial: detected port #%d\n", pdev->id);
port = get_port_from_line(pdev->id);
port->dev = &pdev->dev;
msm_port = UART_TO_MSM(port);
msm_port->clk = clk_get(&pdev->dev, "uart_clk");
if (unlikely(IS_ERR(msm_port->clk)))
return PTR_ERR(msm_port->clk);
port->uartclk = clk_get_rate(msm_port->clk);
resource = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (unlikely(!resource))
return -ENXIO;
port->mapbase = resource->start;
port->irq = platform_get_irq(pdev, 0);
if (unlikely(port->irq < 0))
return -ENXIO;
platform_set_drvdata(pdev, port);
if (unlikely(set_irq_wake(port->irq, 1)))
return -ENXIO;
#ifdef CONFIG_SERIAL_MSM_RX_WAKEUP
if (pdata == NULL)
msm_port->wakeup.irq = -1;
else {
msm_port->wakeup.irq = pdata->wakeup_irq;
msm_port->wakeup.ignore = 1;
msm_port->wakeup.inject_rx = pdata->inject_rx_on_wakeup;
msm_port->wakeup.rx_to_inject = pdata->rx_to_inject;
if (unlikely(msm_port->wakeup.irq <= 0))
return -EINVAL;
}
#endif
#ifdef CONFIG_SERIAL_MSM_CLOCK_CONTROL
msm_port->clk_state = MSM_CLK_PORT_OFF;
hrtimer_init(&msm_port->clk_off_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
msm_port->clk_off_timer.function = msm_serial_clock_off;
msm_port->clk_off_delay = ktime_set(0, 1000000); /* 1 ms */
#endif
return uart_add_one_port(&msm_uart_driver, port);
}
int bcmsdh_register_oob_intr(void *dhdp)
{
int error = 0;
SDLX_MSG(("%s Enter\n", __func__));
sdhcinfo->oob_flags =
IORESOURCE_IRQ | IORESOURCE_IRQ_HIGHLEVEL |
IORESOURCE_IRQ_SHAREABLE;
dev_set_drvdata(sdhcinfo->dev, dhdp);
if (!sdhcinfo->oob_irq_registered) {
SDLX_MSG(("%s IRQ=%d Type=%X\n", __func__,
(int)sdhcinfo->oob_irq, (int)sdhcinfo->oob_flags));
/* Refer to customer Host IRQ docs about
proper irqflags definition */
error =
request_irq(sdhcinfo->oob_irq, wlan_oob_irq,
sdhcinfo->oob_flags, "bcmsdh_sdmmc", NULL);
if (error)
return -ENODEV;
set_irq_wake(sdhcinfo->oob_irq, 1);
sdhcinfo->oob_irq_registered = true;
}
return 0;
}
int __init desirec_init_mmc(unsigned int sys_rev)
{
wifi_status_cb = NULL;
sdslot_vreg_enabled = 0;
vreg_wifi_osc = vreg_get(0, "gp4");
if (IS_ERR(vreg_wifi_osc))
return PTR_ERR(vreg_wifi_osc);
vreg_set_level(vreg_wifi_osc, 1800);
msm_add_sdcc(1, &desirec_wifi_data, 0, 0); /* r porting 29: change func*/
if (opt_disable_sdcard) {
printk(KERN_INFO "desirec: SD-Card interface disabled\n");
goto done;
}
vreg_sdslot = vreg_get(0, "gp6");
if (IS_ERR(vreg_sdslot))
return PTR_ERR(vreg_sdslot);
set_irq_wake(MSM_GPIO_TO_INT(DESIREC_GPIO_SDMC_CD_N), 1);
msm_add_sdcc(2, &desirec_sdslot_data, MSM_GPIO_TO_INT(DESIREC_GPIO_SDMC_CD_N),
IORESOURCE_IRQ_LOWEDGE | IORESOURCE_IRQ_HIGHEDGE); /* r porting 29 */
done:
return 0;
}
int gp2a_off(struct gp2a_data *gp2a, int type)
{
u8 value;
int err = 0;
gprintk("gp2a_off(%d)\n",type);
if(type == PROXIMITY || type == ALL)
{
#if USE_INTERRUPT
gprintk("disable irq for proximity \n");
#if !defined(CONFIG_MACH_RANT3)
set_irq_wake(gp2a->irq, 0);
#endif
disable_irq_nosync(gp2a ->irq);
#endif
// SSD : Software shutdown function ( 0:shutdown mode, 1:opteration mode )
value = 0x02; // VCON enable, SSD disable
err = opt_i2c_write((u8)(REGS_OPMOD),&value);
}
#ifdef LIGHT_SENSOR_ENABLED
if(type ==LIGHT)
{
gprintk("[LIGHT_SENSOR] timer cancel for light sensor\n");
hrtimer_cancel(&gp2a->timer);
/* In case light sensor is off, set the default backlight level */
//lcdc_set_backlight_autobrightness(app_bl_level);
light_enable = OFF;
}
#endif
return err;
}
int bluetooth_enable_irq(int enable, struct platform_device *pdev)
{
int ret;
if (enable) {
set_irq_type(host_wake_irq , IRQ_TYPE_EDGE_RISING);
ret = request_irq(host_wake_irq , bt_host_wake_isr, 0, pdev->name, NULL);
if (ret < 0)
return ret;
set_irq_wake(host_wake_irq, 1);
}
else {
set_irq_wake(host_wake_irq, 0);
free_irq(host_wake_irq, NULL);
}
return ret;
}
static int __init msm_mpm_init(void)
{
unsigned int irq = MSM_MPM_IPC_IRQ;
int rc;
bitmap_set(msm_mpm_gic_irqs_mask, 0, NR_MSM_IRQS - 1);
bitmap_set(msm_mpm_gpio_irqs_mask, NR_MSM_IRQS,
MSM_MPM_NR_APPS_IRQS - 1);
rc = request_irq(irq, msm_mpm_irq,
IRQF_TRIGGER_RISING, "mpm_drv", msm_mpm_irq);
if (rc) {
pr_err("%s: failed to request irq %u: %d\n",
__func__, irq, rc);
goto init_bail;
}
rc = set_irq_wake(irq, 1);
if (rc) {
pr_err("%s: failed to set wakeup irq %u: %d\n",
__func__, irq, rc);
goto init_free_bail;
}
return 0;
init_free_bail:
free_irq(irq, msm_mpm_irq);
init_bail:
return rc;
}
static int bcm_bt_lpm_probe(struct platform_device *pdev)
{
int irq;
int ret;
struct bcm_bt_lpm_platform_data *pdata = pdev->dev.platform_data;
if (bt_lpm.request_clock_off_locked != NULL) {
printk(KERN_ERR "Cannot register two bcm_bt_lpm drivers\n");
return -EINVAL;
}
bt_lpm.gpio_wake = pdata->gpio_wake;
bt_lpm.gpio_host_wake = pdata->gpio_host_wake;
bt_lpm.request_clock_off_locked = pdata->request_clock_off_locked;
bt_lpm.request_clock_on_locked = pdata->request_clock_on_locked;
hrtimer_init(&bt_lpm.enter_lpm_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
bt_lpm.enter_lpm_delay = ktime_set(1, 0); /* 1 sec */
bt_lpm.enter_lpm_timer.function = enter_lpm;
gpio_set_value(bt_lpm.gpio_wake, 0);
bt_lpm.host_wake = 0;
irq = gpio_to_irq(bt_lpm.gpio_host_wake);
ret = request_irq(irq, host_wake_isr,
IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
"bt host_wake", NULL);
if (ret)
return ret;
ret = set_irq_wake(irq, 1);
if (ret)
return ret;
return 0;
}
static uint32_t msm_sdcc_setup_power(struct device *dv, unsigned int vdd)
{
int rc = 0;
struct platform_device *pdev;
static int first_setup = 1;
pdev = container_of(dv, struct platform_device, dev);
rc = msm_sdcc_setup_gpio(pdev->id, !!vdd);
if (rc)
goto out;
rc = msm_sdcc_setup_vreg(pdev->id, !!vdd);
/* if first called related to sdcc1,
* irq should be registered as wakeup source
* [email protected], 2010-02-19
*/
if (vdd && first_setup) {
struct mmc_platform_data *pdata = pdev->dev.platform_data;
if (pdev->id == 1) {
first_setup = 0;
set_irq_wake(pdata->status_irq, 1);
}
}
out:
return rc;
}
/**********************************************************
** Function: Jack detection-in gpio configuration function
** Parameter: none
** Return value: if sucess, then returns 0
**
************************************************************/
static int jack_config_gpio()
{
int ret;
printk("HEADSET: Config Jack-in detection gpio\n");
tegra_gpio_enable(JACK_GPIO);
ret = gpio_request(JACK_GPIO, "h2w_detect");
ret = gpio_direction_input(JACK_GPIO);
hs_data->irq = gpio_to_irq(JACK_GPIO);
ret = request_irq(hs_data->irq, detect_irq_handler,
IRQF_TRIGGER_FALLING|IRQF_TRIGGER_RISING, "h2w_detect", NULL);
ret = set_irq_wake(hs_data->irq, 1);
if (gpio_get_value(JACK_GPIO) == 0){
jack_alive = true;
insert_headset();
}else {
jack_alive = false;
remove_headset();
}
return 0;
}
/**
* Stops the Sleep-Mode Protocol on the Host.
*/
static void
dhd_disable_hwakeup(void)
{
if (set_irq_wake(dhd_wifi_sleep->host_wake_irq, 0))
DHD_ERROR(("Couldn't disable hostwake IRQ wakeup mode\n"));
}
static int mpr084_driver_register(struct mpr084_data *data)
{
struct input_dev *idev;
int ret = 0;
if (data->kpirq) {
ret =
request_irq(data->kpirq, mpr084_keypadirq,
IRQF_TRIGGER_FALLING, DRIVER_NAME, data);
if (!ret) {
init_completion(&data->kpirq_completion);
set_irq_wake(data->kpirq, 1);
} else {
printk(KERN_ERR "%s: cannot grab irq %d\n",
__func__, data->kpirq);
}
}
idev = input_allocate_device();
data->idev = idev;
input_set_drvdata(idev, data);
idev->name = DRIVER_NAME;
idev->open = mpr084_idev_open;
idev->close = mpr084_idev_close;
if (!ret)
ret = input_register_device(idev);
return ret;
}
void hPlatform_freeInterrupt(void *tnet_drv)
{
TWlanDrvIfObj *drv = tnet_drv;
set_irq_wake(drv->irq, 0);
free_irq(drv->irq, drv);
gpio_free(WLAN_EN);
}
static int adp5587_remove(struct i2c_client *client)
{
struct adp5587_data *client_data = i2c_get_clientdata(client);
set_irq_wake(client->irq, 0);
free_irq(client->irq, client_data);
input_unregister_device(client_data->input_dev);
kfree(client_data);
return 0;
}
static int gpio_keypad_request_irqs(struct gpio_kp *kp)
{
int i;
int err;
unsigned int irq;
unsigned long request_flags;
struct gpio_event_matrix_info *mi = kp->keypad_info;
switch (mi->flags & (GPIOKPF_ACTIVE_HIGH|GPIOKPF_LEVEL_TRIGGERED_IRQ)) {
default:
request_flags = IRQF_TRIGGER_FALLING;
break;
case GPIOKPF_ACTIVE_HIGH:
request_flags = IRQF_TRIGGER_RISING;
break;
case GPIOKPF_LEVEL_TRIGGERED_IRQ:
request_flags = IRQF_TRIGGER_LOW;
break;
case GPIOKPF_LEVEL_TRIGGERED_IRQ | GPIOKPF_ACTIVE_HIGH:
request_flags = IRQF_TRIGGER_HIGH;
break;
}
for (i = 0; i < mi->ninputs; i++) {
err = irq = gpio_to_irq(mi->input_gpios[i]);
if (err < 0)
goto err_gpio_get_irq_num_failed;
err = request_irq(irq, gpio_keypad_irq_handler, request_flags,
"gpio_kp", kp);
if (err) {
pr_err("gpiomatrix: request_irq failed for input %d, "
"irq %d\n", mi->input_gpios[i], irq);
goto err_request_irq_failed;
}
#ifndef CONFIG_ZTE_PLATFORM
err = set_irq_wake(irq, 1);
if (err) {
pr_err("gpiomatrix: set_irq_wake failed for input %d, "
"irq %d\n", mi->input_gpios[i], irq);
}
#endif
disable_irq(irq);
if (kp->disabled_irq) {
kp->disabled_irq = 0;
enable_irq(irq);
}
}
return 0;
for (i = mi->noutputs - 1; i >= 0; i--) {
free_irq(gpio_to_irq(mi->input_gpios[i]), kp);
err_request_irq_failed:
err_gpio_get_irq_num_failed:
;
}
return err;
}
static int gpio_keypad_request_irqs(struct gpio_kp *kp)
{
int i;
int err;
unsigned int irq;
unsigned long request_flags;
struct gpio_event_matrix_info *mi = kp->keypad_info;
unsigned long flags;
switch (mi->flags & (GPIOKPF_ACTIVE_HIGH|GPIOKPF_LEVEL_TRIGGERED_IRQ)) {
default:
request_flags = IRQF_TRIGGER_FALLING;
break;
case GPIOKPF_ACTIVE_HIGH:
request_flags = IRQF_TRIGGER_RISING;
break;
case GPIOKPF_LEVEL_TRIGGERED_IRQ:
request_flags = IRQF_TRIGGER_LOW;
break;
case GPIOKPF_LEVEL_TRIGGERED_IRQ | GPIOKPF_ACTIVE_HIGH:
request_flags = IRQF_TRIGGER_HIGH;
break;
}
start_to_setup_irq = 1;
for (i = 0; i < mi->ninputs; i++) {
err = irq = gpio_to_irq(mi->input_gpios[i]);
if (err < 0)
goto err_gpio_get_irq_num_failed;
irq_disable = 0;
err = request_irq(irq, gpio_keypad_irq_handler, request_flags,
"gpio_kp", kp);
if (err) {
pr_err("gpiomatrix: request_irq failed for input %d, "
"irq %d\n", mi->input_gpios[i], irq);
goto err_request_irq_failed;
}
err = set_irq_wake(irq, 1);
if (err) {
pr_err("gpiomatrix: set_irq_wake failed for input %d, "
"irq %d\n", mi->input_gpios[i], irq);
}
spin_lock_irqsave(&gpio_keypad_lock,flags);
if(irq_disable == 0) disable_irq(irq);
spin_unlock_irqrestore(&gpio_keypad_lock,flags);
}
start_to_setup_irq = 0;
return 0;
for (i = mi->ninputs - 1; i >= 0; i--) {
free_irq(gpio_to_irq(mi->input_gpios[i]), kp);
err_request_irq_failed:
err_gpio_get_irq_num_failed:
;
}
return err;
}
void bcmsdh_unregister_oob_intr(void)
{
SDLX_MSG(("%s: Enter\n", __func__));
set_irq_wake(sdhcinfo->oob_irq, 0);
disable_irq(sdhcinfo->oob_irq); /* just in case.. */
free_irq(sdhcinfo->oob_irq, NULL);
sdhcinfo->oob_irq_registered = false;
}
/*****************************************************************************************
*
* function : gp2a_on
* description : This function is power-on function for optical sensor.
*
* int type : Sensor type. Two values is available (PROXIMITY,LIGHT).
* it support power-on function separately.
*
*
*/
int gp2a_on(struct gp2a_data *gp2a, int type)
{
u8 value;
int err = 0;
#ifdef LIGHT_SENSOR_ENABLED
ktime_t light_polling_time;
#endif
gprintk("gp2a_on(%d)\n",type);
gprintk("gp2a power on voltage up \n");
if(type == PROXIMITY)
{
gprintk("[PROXIMITY] go nomal mode : power on \n");
// ASD : Select switch for analog sleep function ( 0:ineffective, 1:effective )
// OCON[1:0] : Select switches for enabling/disabling VOUT terminal
// ( 00:enable, 11:force to go High, 10:forcr to go Low )
value = 0x18; // 11:force to go High
err = opt_i2c_write((u8)(REGS_CON),&value);
if(err < 0) return err;
#if defined(CONFIG_MACH_RANT3)
value = 0x2F; // HYSD enable
#else
value = 0x40; // HYSD enable
#endif
err = opt_i2c_write((u8)(REGS_HYS),&value);
if(err < 0) return err;
// VCON : VOUT terminal output method control ( 0:normal mode, 1:interrupt mode )
// SSD : Software shutdown function ( 0:shutdown mode, 1:opteration mode )
value = 0x03; // VCON enable, SSD enable
err = opt_i2c_write((u8)(REGS_OPMOD),&value);
if(err < 0) return err;
#if USE_INTERRUPT
gprintk("enable irq for proximity\n");
enable_irq(gp2a ->irq);
#if !defined(CONFIG_MACH_RANT3)
set_irq_wake(gp2a->irq, 1);
#endif
#endif
// OCON[1:0] : Select switches for enabling/disabling VOUT terminal
// ( 00:enable, 11:force to go High, 10:forcr to go Low )
value = 0x00; // 00:enable
err = opt_i2c_write((u8)(REGS_CON),&value);
}
#ifdef LIGHT_SENSOR_ENABLED
if(type == LIGHT)
{
gprintk(KERN_INFO "[LIGHT_SENSOR] timer start for light sensor\n");
//hrtimer_start(&gp2a->timer,ktime_set(light_init_period/2,0),HRTIMER_MODE_REL);
hrtimer_start(&gp2a->timer,ktime_set(0,500000000),HRTIMER_MODE_REL);
light_enable = ON;
}
#endif
return err;
}
int __init x3proto_gpio_setup(void)
{
int ilsel;
int ret, i;
ilsel = ilsel_enable(ILSEL_KEY);
if (unlikely(ilsel < 0))
return ilsel;
ret = gpiochip_add(&x3proto_gpio_chip);
if (unlikely(ret))
goto err_gpio;
for (i = 0; i < NR_BASEBOARD_GPIOS; i++) {
unsigned long flags;
int irq = create_irq();
if (unlikely(irq < 0)) {
ret = -EINVAL;
goto err_irq;
}
spin_lock_irqsave(&x3proto_gpio_lock, flags);
x3proto_gpio_irq_map[i] = irq;
set_irq_chip_and_handler_name(irq, &dummy_irq_chip,
handle_simple_irq, "gpio");
spin_unlock_irqrestore(&x3proto_gpio_lock, flags);
}
pr_info("registering '%s' support, handling GPIOs %u -> %u, "
"bound to IRQ %u\n",
x3proto_gpio_chip.label, x3proto_gpio_chip.base,
x3proto_gpio_chip.base + x3proto_gpio_chip.ngpio,
ilsel);
set_irq_chained_handler(ilsel, x3proto_gpio_irq_handler);
set_irq_wake(ilsel, 1);
return 0;
err_irq:
for (; i >= 0; --i)
if (x3proto_gpio_irq_map[i])
destroy_irq(x3proto_gpio_irq_map[i]);
ret = gpiochip_remove(&x3proto_gpio_chip);
if (unlikely(ret))
pr_err("Failed deregistering GPIO\n");
err_gpio:
synchronize_irq(ilsel);
ilsel_disable(ILSEL_KEY);
return ret;
}
static void keypad_volumnkey_wake_ctrl(void)
{
int err;
if( sleep_volumnkey_awake == OFF)
{
if( sleep_volumnkey_awake_state == ON )
{
err = set_irq_wake(gpio_to_irq(VOLUMN_UP_KEYSENSE), OFF);
if (err) {
pr_err("volumnkey_wake: set_irq_wake failed for input %d, "
"err %d\n", VOLUMN_UP_KEYSENSE, err);
}
err = set_irq_wake(gpio_to_irq(VOLUMN_DN_KEYSENSE), OFF);
if (err) {
pr_err("volumnkey_wake: set_irq_wake failed for input %d, "
"err %d\n", VOLUMN_UP_KEYSENSE, err);
}
sleep_volumnkey_awake_state = OFF;
}
}
else
{
if( sleep_volumnkey_awake_state == OFF )
{
err = set_irq_wake(gpio_to_irq(VOLUMN_UP_KEYSENSE), ON);
if (err) {
pr_err("volumnkey_wake: set_irq_wake failed for input %d, "
"err %d\n", VOLUMN_UP_KEYSENSE, err);
}
err = set_irq_wake(gpio_to_irq(VOLUMN_DN_KEYSENSE), ON);
if (err) {
pr_err("volumnkey_wake: set_irq_wake failed for input %d, "
"err %d\n", VOLUMN_UP_KEYSENSE, err);
}
sleep_volumnkey_awake_state = ON;
}
}
}
void hPlatform_freeInterrupt( void *tnet_drv )
{
TWlanDrvIfObj *drv = tnet_drv;
if (drv->irq == 0)
return;
set_irq_wake(drv->irq, 0);
free_irq(drv->irq, drv);
}
static void insert_headset(void)
{
unsigned long irq_flags;
int jpole;
H2W_DBG("");
#ifdef CONFIG_LGE_AUDIO_HEADSET_PROTECT
gpio_set_value(hi->gpio_mic_bias_en, 1);
msleep(100);
#endif
jpole = gpio_get_value(hi->gpio_jpole);
if(jpole) // 3pole
{
hi->ignore_btn = 1;
H2W_DBG("insert_headset_no-mic-headset \n");
switch_set_state(&hi->sdev, LGE_NO_MIC_HEADSET);
//kiwone, 2009.12.24 , to fix bug
//no mic headset insert->no mic headset eject->4pole headset insert->button key do not work.
/* Enable button irq */
local_irq_save(irq_flags);
enable_irq(hi->irq_btn);
set_irq_wake(hi->irq_btn, 1);
local_irq_restore(irq_flags);
hi->debounce_time = ktime_set(0, 20000000); /* 20 ms */
hi->unplug_debounce_time = ktime_set(0, 100000000); // add eklee
gpio_set_value(hi->gpio_mic_bias_en, 0);
}
else
{ // 4pole
hi->ignore_btn =0;
H2W_DBG("insert_headset_headset \n");
switch_set_state(&hi->sdev, LGE_HEADSET);
/* Enable button irq */
local_irq_save(irq_flags);
enable_irq(hi->irq_btn);
set_irq_wake(hi->irq_btn, 1);
local_irq_restore(irq_flags);
hi->debounce_time = ktime_set(0, 20000000); /* 20 ms */
hi->unplug_debounce_time = ktime_set(0, 100000000); // add eklee
}
}
int __init vision_init_mmc(unsigned int sys_rev)
{
uint32_t id;
wifi_status_cb = NULL;
/*sdslot_vreg_enabled = 0;*/
printk(KERN_INFO "vision: %s\n", __func__);
/* SDC2: MoviNAND */
/*
register_msm_irq_mask(INT_SDC2_0);
register_msm_irq_mask(INT_SDC2_1);
*/
config_gpio_table(movinand_on_gpio_table,
ARRAY_SIZE(movinand_on_gpio_table));
#if 0
msm_add_sdcc(2, &vision_movinand_data, 0, 0);
#endif
/* initial WIFI_SHUTDOWN# */
id = PCOM_GPIO_CFG(VISION_GPIO_WIFI_SHUTDOWN_N, 0, GPIO_OUTPUT, GPIO_NO_PULL, GPIO_2MA),
msm_proc_comm(PCOM_RPC_GPIO_TLMM_CONFIG_EX, &id, 0);
gpio_set_value(VISION_GPIO_WIFI_SHUTDOWN_N, 0);
msm_add_sdcc(3, &vision_wifi_data);
#if 0
register_msm_irq_mask(INT_SDC4_0);
register_msm_irq_mask(INT_SDC4_1);
#endif
#if 0
if (opt_disable_sdcard) {
printk(KERN_INFO "vision: SD-Card interface disabled\n");
goto done;
}
vreg_sdslot = vreg_get(0, "gp10");
if (IS_ERR(vreg_sdslot))
return PTR_ERR(vreg_sdslot);
set_irq_wake(MSM_GPIO_TO_INT(VISION_SDMC_CD_N_TO_SYS), 1);
msm_add_sdcc(4, &vision_sdslot_data,
MSM_GPIO_TO_INT(VISION_SDMC_CD_N_TO_SYS),
IORESOURCE_IRQ_LOWEDGE | IORESOURCE_IRQ_HIGHEDGE);
done:
#endif
/* reset eMMC for write protection test */
gpio_set_value(VISION_GPIO_EMMC_RST, 0); /* this should not work!!! */
udelay(100);
gpio_set_value(VISION_GPIO_EMMC_RST, 1);
return 0;
}
int __init mahimahi_init_mmc(unsigned int sys_rev, unsigned debug_uart)
{
uint32_t id;
printk("%s()+\n", __func__);
/* initial WIFI_SHUTDOWN# */
id = PCOM_GPIO_CFG(MAHIMAHI_GPIO_WIFI_SHUTDOWN_N, 0, GPIO_OUTPUT, GPIO_NO_PULL, GPIO_2MA),
msm_proc_comm(PCOM_RPC_GPIO_TLMM_CONFIG_EX, &id, 0);
msm_add_sdcc(1, &mahimahi_wifi_data, 0, 0);
if (debug_uart) {
pr_info("%s: sdcard disabled due to debug uart\n", __func__);
goto done;
}
if (opt_disable_sdcard) {
pr_info("%s: sdcard disabled on cmdline\n", __func__);
goto done;
}
sdslot_vreg_enabled = 0;
if (is_cdma_version(sys_rev)) {
/* In the CDMA version, sdslot is supplied by a gpio. */
int rc = gpio_request(MAHIMAHI_CDMA_SD_2V85_EN, "sdslot_en");
if (rc < 0) {
pr_err("%s: gpio_request(%d) failed: %d\n", __func__,
MAHIMAHI_CDMA_SD_2V85_EN, rc);
return rc;
}
mahimahi_sdslot_data.translate_vdd = mahimahi_cdma_sdslot_switchvdd;
} else {
/* in UMTS version, sdslot is supplied by pmic */
sdslot_vreg = vreg_get(0, "gp6");
if (IS_ERR(sdslot_vreg))
return PTR_ERR(sdslot_vreg);
}
if (system_rev > 0)
msm_add_sdcc(2, &mahimahi_sdslot_data, 0, 0);
else {
mahimahi_sdslot_data.status = mahimahi_sdslot_status_rev0;
mahimahi_sdslot_data.register_status_notify = NULL;
set_irq_wake(MSM_GPIO_TO_INT(MAHIMAHI_GPIO_SDMC_CD_REV0_N), 1);
msm_add_sdcc(2, &mahimahi_sdslot_data,
MSM_GPIO_TO_INT(MAHIMAHI_GPIO_SDMC_CD_REV0_N),
IORESOURCE_IRQ_LOWEDGE | IORESOURCE_IRQ_HIGHEDGE);
}
done:
printk("%s()-\n", __func__);
return 0;
}
static void bma250_release(struct input_dev *dev)
{
int rc;
struct driver_data *dd = input_get_drvdata(dev);
rc = set_irq_wake(dd->ic_dev->irq, 0);
if (rc)
dev_err(&dd->ic_dev->dev,
"%s: set_irq_wake failed with error %d\n",
__func__, rc);
free_irq(dd->ic_dev->irq, &dd->ic_dev->dev);
}
int __init bravo_init_mmc(unsigned int sys_rev)
{
uint32_t id;
struct cnf_driver *microp_sdcard_detect;
wifi_status_cb = NULL;
printk(KERN_INFO "%s()+\n", __func__);
/* initial WIFI_SHUTDOWN# */
id = PCOM_GPIO_CFG(127, 0, GPIO_OUTPUT, GPIO_NO_PULL, GPIO_2MA),
msm_proc_comm(PCOM_RPC_GPIO_TLMM_CONFIG_EX, &id, 0);
gpio_set_value(127, 0);
msm_add_sdcc(1, &bravo_wifi_data, 0, 0);
if (opt_disable_sdcard) {
pr_info("%s: sdcard disabled on cmdline\n", __func__);
goto done;
}
sdslot_vreg_enabled = 0;
sdslot_vreg = vreg_get(0, "gp6");
if (IS_ERR(sdslot_vreg))
return PTR_ERR(sdslot_vreg);
if (bravo_sd_gpio()) {
set_irq_wake(MSM_GPIO_TO_INT(BRAVO_GPIO_SDMC_CD_N), 1);
msm_add_sdcc(2, &bravo_sdslot_data,
MSM_GPIO_TO_INT(BRAVO_GPIO_SDMC_CD_N),
IORESOURCE_IRQ_LOWEDGE | IORESOURCE_IRQ_HIGHEDGE);
} else {
microp_sdcard_detect = kzalloc(sizeof(struct cnf_driver),
GFP_KERNEL);
if (microp_sdcard_detect) {
microp_sdcard_detect->name = "sdcard_detect";
microp_sdcard_detect->func = (void *) µp_check_status;
} else {
printk(KERN_ERR "%s: Alloc SD callback func error\n",
__func__);
goto done;
}
cnf_driver_register(microp_sdcard_detect);
msm_add_sdcc(2, &bravo_sdslot_data, 0, 0);
}
done:
printk(KERN_INFO "%s()-\n", __func__);
return 0;
}
void check_hook_key_state_work_func(struct work_struct *work)
{
int hook_key_status = 0;
int rc = 0;
unsigned long irq_flags;
HEADSET_DBG("");
if ( HSD_HEADSET != g_headset_type )
{
HEADSET_INFO("Headset remove!! or may ear phone noise !!");
return;
}
hook_key_status = gpio_get_value(headset_data.hook_gpio);
if ( 1 == hook_key_status )
{
button_pressed();
atomic_set(&headset_data.is_button_press, 1);
rc = set_irq_type(headset_data.hook_irq, IRQF_TRIGGER_LOW);
if (rc)
HEADSET_ERR( "change hook key detection type as low fail!!");
}
else
{
if ( 1 == atomic_read(&headset_data.is_button_press))
{
button_released();
atomic_set(&headset_data.is_button_press, 0);
rc = set_irq_type(headset_data.hook_irq, IRQF_TRIGGER_HIGH);
HEADSET_DBG("Hook Key release change hook key detection type as high");
if (rc)
HEADSET_ERR("change hook key detection type as high fail!!");
}
}
if ( HSD_IRQ_DISABLE == headset_data.hook_irq_status)
{
local_irq_save(irq_flags);
enable_irq(headset_data.hook_irq);
headset_data.hook_irq_status = HSD_IRQ_ENABLE;
set_irq_wake(headset_data.hook_irq, 1);
local_irq_restore(irq_flags);
}
}
static int __init msm_init_gpio(void)
{
int i;
for (i = NR_MSM_IRQS; i < NR_MSM_IRQS + NR_GPIO_IRQS; i++) {
set_irq_chip(i, &msm_gpio_irq_chip);
set_irq_handler(i, handle_edge_irq);
set_irq_flags(i, IRQF_VALID);
}
for (i = 0; i < ARRAY_SIZE(msm_gpio_chips); i++) {
writel(0, msm_gpio_chips[i].regs.int_en);
register_gpio_chip(&msm_gpio_chips[i].chip);
}
set_irq_chained_handler(INT_GPIO_GROUP1, msm_gpio_irq_handler);
set_irq_chained_handler(INT_GPIO_GROUP2, msm_gpio_irq_handler);
set_irq_wake(INT_GPIO_GROUP1, 1);
set_irq_wake(INT_GPIO_GROUP2, 2);
return 0;
}
struct pm_irq_chip * pm8xxx_irq_init(struct device *dev,
const struct pm8xxx_irq_platform_data *pdata)
{
struct pm_irq_chip *chip;
int devirq, rc;
unsigned int pmirq;
if (!pdata) {
pr_err("No platform data\n");
return ERR_PTR(-EINVAL);
}
devirq = pdata->devirq;
if (devirq < 0) {
pr_err("missing devirq\n");
rc = devirq;
return ERR_PTR(-EINVAL);
}
chip = kzalloc(sizeof(struct pm_irq_chip)
+ sizeof(u8) * pdata->irq_cdata.nirqs, GFP_KERNEL);
if (!chip) {
pr_err("Cannot alloc pm_irq_chip struct\n");
return ERR_PTR(-EINVAL);
}
chip->dev = dev;
chip->devirq = devirq;
chip->irq_base = pdata->irq_base;
chip->num_irqs = pdata->irq_cdata.nirqs;
chip->num_blocks = DIV_ROUND_UP(chip->num_irqs, 8);
chip->num_masters = DIV_ROUND_UP(chip->num_blocks, 8);
spin_lock_init(&chip->pm_irq_lock);
for (pmirq = 0; pmirq < chip->num_irqs; pmirq++) {
irq_set_chip_and_handler(chip->irq_base + pmirq,
&pm8xxx_irq_chip,
handle_level_irq);
irq_set_chip_data(chip->irq_base + pmirq, chip);
#ifdef CONFIG_ARM
set_irq_flags(chip->irq_base + pmirq, IRQF_VALID);
#else
irq_set_noprobe(chip->irq_base + pmirq);
#endif
}
irq_set_irq_type(devirq, pdata->irq_trigger_flag);
irq_set_handler_data(devirq, chip);
irq_set_chained_handler(devirq, pm8xxx_irq_handler);
set_irq_wake(devirq, 1);
return chip;
}
