static irqreturn_t phone_active_irq_handler(int irq, void *_mc)
{
	int phone_reset = 0;
	int phone_active_value = 0;
	int phone_state = 0;
	struct modem_ctl *mc = (struct modem_ctl *)_mc;

	if (!mc->gpio_cp_reset || !mc->gpio_phone_active) {
		pr_err("[MODEM_IF] no gpio data\n");
		return IRQ_HANDLED;
	}

	phone_reset = gpio_get_value(mc->gpio_cp_reset);
	phone_active_value = gpio_get_value(mc->gpio_phone_active);

	if (phone_reset && phone_active_value) {
		phone_state = STATE_ONLINE;
		if (mc->iod && mc->iod->modem_state_changed)
			mc->iod->modem_state_changed(mc->iod, phone_state);
	} else if (phone_reset && !phone_active_value) {
		if (mc->phone_state == STATE_ONLINE) {
			phone_state = STATE_CRASH_EXIT;
			if (mc->iod && mc->iod->modem_state_changed)
				mc->iod->modem_state_changed(mc->iod,
						phone_state);
		}
	} else {
		phone_state = STATE_OFFLINE;
		if (mc->iod && mc->iod->modem_state_changed)
			mc->iod->modem_state_changed(mc->iod, phone_state);
	}

	if (phone_active_value)
		irq_set_irq_type(mc->irq_phone_active, IRQ_TYPE_LEVEL_LOW);
	else
		irq_set_irq_type(mc->irq_phone_active, IRQ_TYPE_LEVEL_HIGH);

	pr_info("phone_active_irq_handler : phone_state=%d\n", phone_state);

	return IRQ_HANDLED;
}
Example #2
0
static void __init n8x0_cbus_init(void)
{
	const int retu_irq_gpio = 108;

	if (gpio_request_one(retu_irq_gpio, GPIOF_IN, "Retu IRQ"))
		return;
	irq_set_irq_type(gpio_to_irq(retu_irq_gpio), IRQ_TYPE_EDGE_RISING);
	n8x0_i2c_board_info_3[0].irq = gpio_to_irq(retu_irq_gpio);
	i2c_register_board_info(3, n8x0_i2c_board_info_3,
				ARRAY_SIZE(n8x0_i2c_board_info_3));
	platform_device_register(&n8x0_cbus_device);
}
static int hi6401_irq_map(struct irq_domain *d, unsigned int virq,
			  irq_hw_number_t hw)
{
	struct hi6401_irq *irq = d->host_data;

	irq_set_chip_and_handler_name(virq, &hi6401_irqchip,
				      handle_simple_irq, "hi6401_irq");
	irq_set_chip_data(virq, irq);
	irq_set_irq_type(virq, IRQ_TYPE_NONE);

	return 0;
}
Example #4
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;
}
static void wacom_i2c_resume_work(struct work_struct *work)
{
struct wacom_i2c *wac_i2c =
	    container_of(work, struct wacom_i2c, resume_work.work);

#if defined(WACOM_PDCT_WORK_AROUND)
	irq_set_irq_type(wac_i2c->irq_pdct, IRQ_TYPE_EDGE_BOTH);
#endif

	wacom_enable_irq(wac_i2c, true);
	printk(KERN_DEBUG "epen:%s\n", __func__);
}
Example #6
0
/* interrupt happened due to transition/change of near/far proximity state */
irqreturn_t cm3663_irq_thread_fn(int irq, void *data)
{
	struct cm3663_data *ip = data;
	u8 val = 1;
	val = gpio_get_value(ip->pdata->irq);
	if (val < 0) {
		pr_err("%s: gpio_get_value error %d\n", __func__, val);
		return IRQ_HANDLED;
	}
	if (val)
		irq_set_irq_type(irq, IRQF_TRIGGER_LOW);
	else
		irq_set_irq_type(irq, IRQF_TRIGGER_HIGH);

	/* 0 is close, 1 is far */
	input_report_abs(ip->proximity_input_dev, ABS_DISTANCE, val);
	input_sync(ip->proximity_input_dev);
	wake_lock_timeout(&ip->prx_wake_lock, 3*HZ);

	return IRQ_HANDLED;
}
Example #7
0
void __init init_IRQ(void)
{
	int irq;

	mcf_maskimr(0xffffffff);

	for (irq = 0; (irq < NR_IRQS); irq++) {
		irq_set_chip(irq, &intc_irq_chip);
		irq_set_irq_type(irq, IRQ_TYPE_LEVEL_HIGH);
		irq_set_handler(irq, handle_level_irq);
	}
}
static irqreturn_t sim_detect_irq_handler(int irq, void *_mc)
{
	struct modem_ctl *mc = (struct modem_ctl *)_mc;

	pr_info("[MSM] <%s> gpio_sim_detect = %d\n",
		__func__, gpio_get_value(mc->gpio_sim_detect));

#if defined(CONFIG_MACH_GRANDE)
	if (gpio_get_value(mc->gpio_sim_detect))
		irq_set_irq_type(mc->irq_sim_detect, IRQ_TYPE_LEVEL_LOW);
	else
		irq_set_irq_type(mc->irq_sim_detect, IRQ_TYPE_LEVEL_HIGH);

	schedule_delayed_work(&mc->sim_det_dwork, msecs_to_jiffies(1000));
#else
	if (mc->iod && mc->iod->sim_state_changed)
		mc->iod->sim_state_changed(mc->iod,
		!gpio_get_value(mc->gpio_sim_detect));
#endif
	return IRQ_HANDLED;
}
void switch_int_to_host_and_mask(struct musb *musb)
{
#ifdef ID_PIN_USE_EX_EINT
	irq_set_irq_type(usb_iddig_number, IRQF_TRIGGER_LOW);
	disable_irq(usb_iddig_number);
#else
	musb_writel(musb->mregs, USB_L1INTM, (~IDDIG_INT_STATUS)&musb_readl(musb->mregs, USB_L1INTM));
	mb();
	musb_writel(musb->mregs, USB_L1INTP, IDDIG_INT_STATUS);
#endif
	DBG(0, "swtich_int_to_host_and_mask is done\n");
}
Example #10
0
static int gpio_irq_trigger_inversion(int irq)
{
        struct irq_desc *desc = NULL;
	int trigger_value = 0;
	int ret = 0;

	desc = irq_to_desc(irq);
	if (!desc) {
		hwlog_err("[%s]irq_desc null!\n", __func__);
		return IRQ_NONE;
	}

	trigger_value = desc->irq_data.state_use_accessors & IRQD_TRIGGER_MASK;
	if (trigger_value & IRQF_TRIGGER_LOW) {
		ret = irq_set_irq_type(irq, IRQF_TRIGGER_HIGH);
	} else {
		ret = irq_set_irq_type(irq, IRQF_TRIGGER_LOW);
	}

	return ret;
}
Example #11
0
static int lnw_gpio_irq_map(struct irq_domain *d, unsigned int virq,
			    irq_hw_number_t hw)
{
	struct lnw_gpio *lnw = d->host_data;

	irq_set_chip_and_handler_name(virq, &lnw_irqchip, handle_simple_irq,
				      "demux");
	irq_set_chip_data(virq, lnw);
	irq_set_irq_type(virq, IRQ_TYPE_NONE);

	return 0;
}
static void modem_link_pm_config_gpio(void)
{
    int ret = 0;

    unsigned gpio_link_enable = modem_link_pm_data.gpio_link_enable;
    unsigned gpio_link_active = modem_link_pm_data.gpio_link_active;
    unsigned gpio_link_hostwake = modem_link_pm_data.gpio_link_hostwake;
    unsigned gpio_link_slavewake = modem_link_pm_data.gpio_link_slavewake;

    if (gpio_link_enable) {
        ret = gpio_request(gpio_link_enable, "LINK_EN");
        if (ret) {
            mif_err("fail to request gpio %s:%d\n", "LINK_EN",
                    ret);
        }
        gpio_direction_output(gpio_link_enable, 0);
    }

    if (gpio_link_active) {
        ret = gpio_request(gpio_link_active, "LINK_ACTIVE");
        if (ret) {
            mif_err("fail to request gpio %s:%d\n", "LINK_ACTIVE",
                    ret);
        }
        gpio_direction_output(gpio_link_active, 0);
    }

    if (gpio_link_hostwake) {
        ret = gpio_request(gpio_link_hostwake, "HOSTWAKE");
        if (ret) {
            mif_err("fail to request gpio %s:%d\n", "HOSTWAKE",
                    ret);
        }
        gpio_direction_input(gpio_link_hostwake);
    }

    if (gpio_link_slavewake) {
        ret = gpio_request(gpio_link_slavewake, "SLAVEWAKE");
        if (ret) {
            mif_err("fail to request gpio %s:%d\n", "SLAVEWAKE",
                    ret);
        }
        gpio_direction_output(gpio_link_slavewake, 0);
    }

    if (gpio_link_hostwake)
        irq_set_irq_type(gpio_to_irq(gpio_link_hostwake),
                         IRQ_TYPE_EDGE_BOTH);

    active_ctl.gpio_initialized = 1;

    mif_info("modem_link_pm_config_gpio done\n");
}
static int pl061_irq_map(struct irq_domain *d, unsigned int virq,
			 irq_hw_number_t hw)
{
	struct pl061_gpio *chip = d->host_data;

	irq_set_chip_and_handler_name(virq, &pl061_irqchip, handle_simple_irq,
				      "pl061");
	irq_set_chip_data(virq, chip);
	irq_set_irq_type(virq, IRQ_TYPE_NONE);

	return 0;
}
Example #14
0
static int db1100_mmc1_cd_setup(void *mmc_host, int en)
{
	int ret = 0;

	if (en) {
		irq_set_irq_type(AU1100_GPIO20_INT, IRQ_TYPE_EDGE_BOTH);
		ret = request_irq(AU1100_GPIO20_INT, db1100_mmc_cd, 0,
				  "sd1_cd", mmc_host);
	} else
		free_irq(AU1100_GPIO20_INT, mmc_host);
	return ret;
}
static irqreturn_t ea313x_mci_detect_interrupt(int irq, void *data)
{
	struct lpc313x_mci_irq_data	*pdata = data;

	/* select the opposite level senstivity */
	int level = mci_get_cd(0) ? IRQ_TYPE_LEVEL_LOW : IRQ_TYPE_LEVEL_HIGH;

	irq_set_irq_type(pdata->irq, level);

	/* change the polarity of irq trigger */
	return pdata->irq_hdlr(irq, pdata->data);
}
Example #16
0
static void camera_focus_eint_func(unsigned long data)
{
	bool pressed = false;
	u8 old_state;

#if 1
	if(focuskey_eint_type == IRQ_TYPE_LEVEL_LOW)
	{
               old_state = (1);
	}
	else
	{
	       old_state = (0);
	}

	kpd_print("[Keypad]old_state = %d\n",(int)old_state);

       if(focuskey_eint_type == IRQ_TYPE_LEVEL_LOW)
       {
		pressed=true;
		irq_set_irq_type(focuskey_irq, IRQ_TYPE_LEVEL_HIGH);
		focuskey_eint_type = IRQ_TYPE_LEVEL_HIGH;
       }
       else
       {
		pressed=false;
		irq_set_irq_type(focuskey_irq, IRQ_TYPE_LEVEL_LOW);
		focuskey_eint_type = IRQ_TYPE_LEVEL_LOW;
       }
	//kpd_info("[Keypad]revert camera_focus_state = %d \n",(int)camera_capture_state);
	printk(KPD_SAY "(%s) [Keypad] HW keycode = %u\n",
				       pressed ? "pressed" : "released", KPD_CAM_FOCUS_MAP);
	//kpd_print("[Keypad]pressed = %d\n",(int)pressed);
	input_report_key(kpd_input_dev, KPD_CAM_FOCUS_MAP, pressed);
	input_sync(kpd_input_dev);
	enable_irq(focuskey_irq);

#endif

}
static void sii9234_cfg_gpio(void)
{
	printk(KERN_INFO "%s()\n", __func__);

	/* AP_MHL_SDA */
	s3c_gpio_cfgpin(GPIO_MHL_SDA_1_8V, S3C_GPIO_SFN(0x0));
	s3c_gpio_setpull(GPIO_MHL_SDA_1_8V, S3C_GPIO_PULL_NONE);

	/* AP_MHL_SCL */
	s3c_gpio_cfgpin(GPIO_MHL_SCL_1_8V, S3C_GPIO_SFN(0x1));
	s3c_gpio_setpull(GPIO_MHL_SCL_1_8V, S3C_GPIO_PULL_NONE);

	/* GPH1(6) XEINT 14 */
	s3c_gpio_cfgpin(GPIO_MHL_WAKE_UP, S3C_GPIO_INPUT);
	irq_set_irq_type(MHL_WAKEUP_IRQ, IRQ_TYPE_EDGE_RISING);
	s3c_gpio_setpull(GPIO_MHL_WAKE_UP, S3C_GPIO_PULL_DOWN);

	gpio_request(GPIO_MHL_INT, "MHL_INT");
	s5p_register_gpio_interrupt(GPIO_MHL_INT);
	s3c_gpio_setpull(GPIO_MHL_INT, S3C_GPIO_PULL_DOWN);
	irq_set_irq_type(MHL_INT_IRQ, IRQ_TYPE_EDGE_RISING);
	s3c_gpio_cfgpin(GPIO_MHL_INT, GPIO_MHL_INT_AF);

	s3c_gpio_cfgpin(GPIO_HDMI_EN, S3C_GPIO_OUTPUT);	/* HDMI_EN */
	gpio_set_value(GPIO_HDMI_EN, GPIO_LEVEL_LOW);
	s3c_gpio_setpull(GPIO_HDMI_EN, S3C_GPIO_PULL_NONE);

	s3c_gpio_cfgpin(GPIO_MHL_RST, S3C_GPIO_OUTPUT);
	s3c_gpio_setpull(GPIO_MHL_RST, S3C_GPIO_PULL_NONE);
	gpio_set_value(GPIO_MHL_RST, GPIO_LEVEL_LOW);

#if !defined(CONFIG_MACH_C1_KOR_LGT) && !defined(CONFIG_SAMSUNG_MHL_9290)
#if !defined(CONFIG_MACH_P4NOTE) && !defined(CONFIG_MACH_T0) && \
	!defined(CONFIG_MACH_M3) && !defined(CONFIG_MACH_SLP_T0_LTE)
	s3c_gpio_cfgpin(GPIO_MHL_SEL, S3C_GPIO_OUTPUT);
	s3c_gpio_setpull(GPIO_MHL_SEL, S3C_GPIO_PULL_NONE);
	gpio_set_value(GPIO_MHL_SEL, GPIO_LEVEL_LOW);
#endif
#endif
}
Example #18
0
static void __init zeus_init_irq(void)
{
	int level;
	int isa_irq;

	pxa27x_init_irq();

	/* Peripheral IRQs. It would be nice to move those inside driver
	   configuration, but it is not supported at the moment. */
	irq_set_irq_type(gpio_to_irq(ZEUS_AC97_GPIO), IRQ_TYPE_EDGE_RISING);
	irq_set_irq_type(gpio_to_irq(ZEUS_WAKEUP_GPIO), IRQ_TYPE_EDGE_RISING);
	irq_set_irq_type(gpio_to_irq(ZEUS_PTT_GPIO), IRQ_TYPE_EDGE_RISING);
	irq_set_irq_type(gpio_to_irq(ZEUS_EXTGPIO_GPIO),
			 IRQ_TYPE_EDGE_FALLING);
	irq_set_irq_type(gpio_to_irq(ZEUS_CAN_GPIO), IRQ_TYPE_EDGE_FALLING);

	/* Setup ISA IRQs */
	for (level = 0; level < ARRAY_SIZE(zeus_isa_irqs); level++) {
		isa_irq = zeus_bit_to_irq(level);
		irq_set_chip_and_handler(isa_irq, &zeus_irq_chip,
					 handle_edge_irq);
		irq_clear_status_flags(isa_irq, IRQ_NOREQUEST | IRQ_NOPROBE);
	}

	irq_set_irq_type(gpio_to_irq(ZEUS_ISA_GPIO), IRQ_TYPE_EDGE_RISING);
	irq_set_chained_handler(gpio_to_irq(ZEUS_ISA_GPIO), zeus_irq_handler);
}
static irqreturn_t mmc_gpio_cd_irqt(int irq, void *dev_id)
{
	
	struct mmc_host *host = dev_id;
	struct mmc_gpio *ctx = host->slot.handler_priv;
	int status;

	spin_lock(&host->lock_cd_pin);
	if (host->cd_pin_depth == 0) {
		if (enable_detection_workqueue) {
			disable_irq_nosync(host->slot.cd_irq);
			queue_delayed_work(enable_detection_workqueue, &host->enable_detect, msecs_to_jiffies(50));
			host->cd_pin_depth++;
		} else
			pr_err("%s detection workqueue is null\n", mmc_hostname(host));
	}
	spin_unlock(&host->lock_cd_pin);

	if (!host->ops)
		goto out;

	if (host->ops->card_event)
		host->ops->card_event(host);

	status = mmc_gpio_get_status(host);
	if (unlikely(status < 0))
		goto out;

	if (status ^ ctx->status) {
		pr_info("%s: slot status change detected (%d -> %d), GPIO_ACTIVE_%s\n",
				mmc_hostname(host), ctx->status, status,
				(host->caps2 & MMC_CAP2_CD_ACTIVE_HIGH) ?
				"HIGH" : "LOW");
		irq_set_irq_type(irq, (status == 0 ?
					IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING));
		ctx->status = status;
		
		host->caps |= host->caps_uhs;
		
		host->removed_cnt = 0;
		host->crc_count = 0;
		
		if (disable_auto_sd)
			goto out;
		
		mmc_detect_change(host, msecs_to_jiffies(host->extended_debounce + 200));
		mmc_gpio_send_uevent(host);
	}
out:

	return IRQ_HANDLED;
}
static irqreturn_t button_irq_handler(int irq, void *dev_id)
{
	int value1, value2;
	int retry_limit = 10;

#ifdef ACCIDENT_EAR_BTN
	static struct timeval accident_btn_last;
	static struct timeval accident_btn;
#endif

	if ((switch_get_state(&hi->sdev) == H2W_NO_DEVICE)
		|| (hi->btn_irq_available == 0)) {
			pr_err("%s: retrun_irq\n",
		__func__);

#ifdef ACCIDENT_EAR_BTN

		do_gettimeofday(&accident_btn);

		if(accident_btn.tv_usec - accident_btn_last.tv_usec < ACCIDENT_BTN_DELAY_MAX)
		{
			accident_btn_count++;
			pr_info("[%s] accident_btn_count=%d\n", __func__, accident_btn_count);
		}
		if(accident_btn_count > ACCIDENT_BTN_TIME_MAX)
		{
			accident_btn_count = 0;
			disable_irq_nosync(hi->irq_btn);
			pr_info("[%s] disable_irq(hi->irq_btn)\n", __func__);
		}
			
		accident_btn_last.tv_sec = accident_btn.tv_sec;
		accident_btn_last.tv_usec = accident_btn.tv_usec;
#endif
		return IRQ_HANDLED;
	}

	do {
		value1 = gpio_get_value(MSM_GPIO_EAR_SEND_END);
		irq_set_irq_type(hi->irq_btn, value1 ?
				IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING);
		value2 = gpio_get_value(MSM_GPIO_EAR_SEND_END);
	} while (value1 != value2 && retry_limit-- > 0);

	if (value1 == value2 && retry_limit > 0) {
		hi->btn_debounce_time = ktime_set(0, 60000000);
		hi->button_state = value1;
		hrtimer_start(&hi->btn_timer, hi->btn_debounce_time,
		HRTIMER_MODE_REL);
	}
	return IRQ_HANDLED;
}
Example #21
0
static void set_use_dec(void *data)
{
	int i;
	/* GPIO Pin Falling/Rising Edge Detect Disable */
	for (i=0; i < INPUT_PIN_NUM; i++) {
		irq_set_irq_type(irq_num[i], 0);
		disable_irq(irq_num[i]);

		free_irq(irq_num[i], (void *) 0);
		dprintk(KERN_INFO LIRC_DRIVER_NAME
			": freed IRQ %d\n", irq_num[i]);
	}
}	
Example #22
0
int __init setup_hd64461(void)
{
	int i, nid = cpu_to_node(boot_cpu_data);

	if (!MACH_HD64461)
		return 0;

	printk(KERN_INFO
	       "HD64461 configured at 0x%x on irq %d(mapped into %d to %d)\n",
	       HD64461_IOBASE, CONFIG_HD64461_IRQ, HD64461_IRQBASE,
	       HD64461_IRQBASE + 15);

/* Should be at processor specific part.. */
#if defined(CONFIG_CPU_SUBTYPE_SH7709)
	__raw_writew(0x2240, INTC_ICR1);
#endif
	__raw_writew(0xffff, HD64461_NIMR);

	/*  IRQ 80 -> 95 belongs to HD64461  */
	for (i = HD64461_IRQBASE; i < HD64461_IRQBASE + 16; i++) {
		unsigned int irq;

		irq = create_irq_nr(i, nid);
		if (unlikely(irq == 0)) {
			pr_err("%s: failed hooking irq %d for HD64461\n",
			       __func__, i);
			return -EBUSY;
		}

		if (unlikely(irq != i)) {
			pr_err("%s: got irq %d but wanted %d, bailing.\n",
			       __func__, irq, i);
			destroy_irq(irq);
			return -EINVAL;
		}

		irq_set_chip_and_handler(i, &hd64461_irq_chip,
					 handle_level_irq);
	}

	irq_set_chained_handler(CONFIG_HD64461_IRQ, hd64461_irq_demux);
	irq_set_irq_type(CONFIG_HD64461_IRQ, IRQ_TYPE_LEVEL_LOW);

#ifdef CONFIG_HD64461_ENABLER
	printk(KERN_INFO "HD64461: enabling PCMCIA devices\n");
	__raw_writeb(0x4c, HD64461_PCC1CSCIER);
	__raw_writeb(0x00, HD64461_PCC1CSCR);
#endif

	return 0;
}
Example #23
0
static void detection_work(struct work_struct *work)
{
	unsigned long irq_flags;
	int cable_in1;
	int mic_in = 0;
	/* Disable headset interrupt while detecting.*/
	local_irq_save(irq_flags);
	disable_irq(hs_data->hp_det_irq);
	local_irq_restore(irq_flags);

	irq_set_irq_type(hs_data->hook_det_irq, IRQF_TRIGGER_NONE);

	set_hs_micbias(ON);

	if (switch_get_state(&hs_data->sdev) != NO_DEVICE) {
		/* Delay for pin stable when being removed. */
		msleep(110);
	} else {
		/* Delay for pin stable when plugged. */
		msleep(1000);
	}

	/* Restore IRQs */
	local_irq_save(irq_flags);
	enable_irq(hs_data->hp_det_irq);
	local_irq_restore(irq_flags);

	if (gpio_get_value(JACK_GPIO) != 0) {
		/* Headset not plugged in */
		remove_headset();
		goto closed_micbias;
	}

	cable_in1 = gpio_get_value(JACK_GPIO);
	mic_in  = gpio_get_value(HS_HOOK_DET);
	if (cable_in1 == 0) {
		printk(KERN_INFO "HOOK_GPIO value: %d\n", mic_in);
		if (switch_get_state(&hs_data->sdev) == NO_DEVICE)
			insert_headset();
		else if (mic_in == 1)
			goto closed_micbias;
	} else{
		printk(KERN_INFO "HEADSET: Jack-in GPIO is low, but not a headset\n");
		goto closed_micbias;
	}
	return;

closed_micbias:
	set_hs_micbias(OFF);
	return;
}
Example #24
0
static int
pi433_start_rx(struct pi433_device *dev)
{
	int retval;

	/* return without action, if no pending read request */
	if (!dev->rx_active)
		return 0;

	/* setup for receiving */
	retval = rf69_set_rx_cfg(dev, &dev->rx_cfg);
	if (retval)
		return retval;

	/* setup rssi irq */
	retval = rf69_set_dio_mapping(dev->spi, DIO0, DIO_RSSI_DIO0);
	if (retval < 0)
		return retval;
	dev->irq_state[DIO0] = DIO_RSSI_DIO0;
	irq_set_irq_type(dev->irq_num[DIO0], IRQ_TYPE_EDGE_RISING);

	/* setup fifo level interrupt */
	retval = rf69_set_fifo_threshold(dev->spi, FIFO_SIZE - FIFO_THRESHOLD);
	if (retval < 0)
		return retval;
	retval = rf69_set_dio_mapping(dev->spi, DIO1, DIO_FIFO_LEVEL);
	if (retval < 0)
		return retval;
	dev->irq_state[DIO1] = DIO_FIFO_LEVEL;
	irq_set_irq_type(dev->irq_num[DIO1], IRQ_TYPE_EDGE_RISING);

	/* set module to receiving mode */
	retval = rf69_set_mode(dev->spi, receive);
	if (retval < 0)
		return retval;

	return 0;
}
Example #25
0
static irqreturn_t detect_irq_handler(int irq, void *dev_id)
{
	int value1, value2;
	int retry_limit = 10;
	
	H2W_DBG("");
	irq_set_irq_type(hi->irq_btn, IRQF_TRIGGER_LOW);
	do {
		value1 = gpio_get_value(hi->gpio_detect);
		irq_set_irq_type(hi->irq, value1 ?IRQF_TRIGGER_LOW : IRQF_TRIGGER_HIGH);
		value2 = gpio_get_value(hi->gpio_detect);
		H2W_DBG("value 1 [%d], value2 [%d]retry[%d]",value1,value2,retry_limit);

		
	} while (value1 != value2 && retry_limit-- > 0);

	H2W_DBG("value2 = %d (%d retries)", value2, (10-retry_limit));

	wake_lock_timeout(&hi->wake_lock, 2*HZ); // 2 second
		
	/*Attached*/	
	if (switch_get_state(&hi->sdev) == BIT_NO_DEVICE) {
		hrtimer_start(&hi->timer, hi->debounce_time, HRTIMER_MODE_REL);
		
		H2W_DBG("Plug in timer set \n");
	}
	/*Detached*/		
	else if(switch_get_state(&hi->sdev) == BIT_HEADSET
			|| switch_get_state(&hi->sdev) == BIT_HEADSET_SPEAKER_ONLY
	){
		//test gpio_set_value(hi->gpio_mic_mode, 0);
		hrtimer_start(&hi->timer, hi->unplug_debounce_time, HRTIMER_MODE_REL);
		
		H2W_DBG("Unplug timer set \n");
	}

	return IRQ_HANDLED;
}
static irqreturn_t button_irq_handler(int irq, void *dev_id)
{
	unsigned int irq_mask = IRQF_TRIGGER_HIGH | IRQF_TRIGGER_LOW;

	HS_DBG();

	hi->key_irq_type ^= irq_mask;
	irq_set_irq_type(hi->key_irq, hi->key_irq_type);

	wake_lock_timeout(&hi->hs_wake_lock, HS_WAKE_LOCK_TIMEOUT);
	queue_delayed_work(button_wq, &button_gpio_work, HS_JIFFIES_ZERO);

	return IRQ_HANDLED;
}
Example #27
0
static int opb_host_map(struct irq_domain *host, unsigned int virq,
		irq_hw_number_t hwirq)
{
	struct opb_pic *opb;

	opb = host->host_data;


	irq_set_chip_data(virq, opb);
	irq_set_chip_and_handler(virq, &opb_irq_chip, handle_level_irq);
	irq_set_irq_type(virq, IRQ_TYPE_NONE);

	return 0;
}
Example #28
0
static int
davinci_gpio_irq_map(struct irq_domain *d, unsigned int irq,
		     irq_hw_number_t hw)
{
	struct davinci_gpio_regs __iomem *g = gpio2regs(hw);

	irq_set_chip_and_handler_name(irq, &gpio_irqchip, handle_simple_irq,
				"davinci_gpio");
	irq_set_irq_type(irq, IRQ_TYPE_NONE);
	irq_set_chip_data(irq, (__force void *)g);
	irq_set_handler_data(irq, (void *)__gpio_mask(hw));

	return 0;
}
static int mpc8xxx_gpio_irq_map(struct irq_host *h, unsigned int virq,
                                irq_hw_number_t hw)
{
    struct mpc8xxx_gpio_chip *mpc8xxx_gc = h->host_data;

    if (mpc8xxx_gc->of_dev_id_data)
        mpc8xxx_irq_chip.irq_set_type = mpc8xxx_gc->of_dev_id_data;

    irq_set_chip_data(virq, h->host_data);
    irq_set_chip_and_handler(virq, &mpc8xxx_irq_chip, handle_level_irq);
    irq_set_irq_type(virq, IRQ_TYPE_NONE);

    return 0;
}
Example #30
0
static long link_pm_ioctl(struct file *file, unsigned int cmd,
						unsigned long arg)
{
	int value;
	struct link_pm_data *pm_data = file->private_data;
	struct modem_ctl *mc = if_usb_get_modemctl(pm_data);

	mif_info("%x\n", cmd);

	switch (cmd) {
	case IOCTL_LINK_CONTROL_ENABLE:
		if (copy_from_user(&value, (const void __user *)arg,
							sizeof(int)))
			return -EFAULT;
		if (pm_data->link_ldo_enable)
			pm_data->link_ldo_enable(!!value);
		if (pm_data->gpio_link_enable)
			gpio_set_value(pm_data->gpio_link_enable, value);
		break;
	case IOCTL_LINK_CONTROL_ACTIVE:
		if (copy_from_user(&value, (const void __user *)arg,
							sizeof(int)))
			return -EFAULT;
		gpio_set_value(pm_data->gpio_link_active, value);
		break;
	case IOCTL_LINK_GET_HOSTWAKE:
		return !gpio_get_value(pm_data->gpio_link_hostwake);
	case IOCTL_LINK_CONNECTED:
		return pm_data->usb_ld->if_usb_connected;
	case IOCTL_LINK_SET_BIAS_CLEAR:
		if (copy_from_user(&value, (const void __user *)arg,
							sizeof(int)))
			return -EFAULT;
		if (value) {
			gpio_direction_output(pm_data->gpio_link_slavewake, 0);
			gpio_direction_output(pm_data->gpio_link_hostwake, 0);
		} else {
			gpio_direction_output(pm_data->gpio_link_slavewake, 0);
			gpio_direction_input(pm_data->gpio_link_hostwake);
			irq_set_irq_type(pm_data->irq_link_hostwake,
				IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING);
		}
	case IOCTL_LINK_GET_PHONEACTIVE:
		return gpio_get_value(mc->gpio_phone_active);
	default:
		break;
	}

	return 0;
}