static void ep93xx_gpio_irq_ack(struct irq_data *d) { int line = irq_to_gpio(d->irq); int port = line >> 3; int port_mask = 1 << (line & 7); if (irqd_get_trigger_type(d) == IRQ_TYPE_EDGE_BOTH) { gpio_int_type2[port] ^= port_mask; /* switch edge direction */ ep93xx_gpio_update_int_params(port); } writeb(port_mask, EP93XX_GPIO_REG(eoi_register_offset[port])); }
static unsigned int gpio_startup_irq(struct irq_data *data) { /* * This warning indicates that the type of the irq hasn't been set * before enabling the irq. This would normally be done by passing some * trigger flags to request_irq(). */ WARN(irqd_get_trigger_type(data) == IRQ_TYPE_NONE, "irq type not set before enabling gpio irq %d", data->irq); irq_gc_ack_clr_bit(data); irq_gc_mask_set_bit(data); return 0; }
static void ep93xx_gpio_irq_mask_ack(struct irq_data *d) { int line = irq_to_gpio(d->irq); int port = line >> 3; int port_mask = 1 << (line & 7); if (irqd_get_trigger_type(d) == IRQ_TYPE_EDGE_BOTH) gpio_int_type2[port] ^= port_mask; gpio_int_unmasked[port] &= ~port_mask; ep93xx_gpio_update_int_params(port); __raw_writeb(port_mask, EP93XX_GPIO_REG(eoi_register_offset[port])); }
static void oxnas_gpio_irq_unmask(struct irq_data *data) { struct gpio_chip *chip = irq_data_get_irq_chip_data(data); struct oxnas_gpio_bank *bank = gpiochip_get_data(chip); unsigned int type = irqd_get_trigger_type(data); u32 mask = BIT(data->hwirq); if (type & IRQ_TYPE_EDGE_RISING) writel(readl(bank->reg_base + RE_IRQ_ENABLE) | mask, bank->reg_base + RE_IRQ_ENABLE); if (type & IRQ_TYPE_EDGE_FALLING) writel(readl(bank->reg_base + FE_IRQ_ENABLE) | mask, bank->reg_base + FE_IRQ_ENABLE); }
static void gpio_irq_enable(struct irq_data *d) { struct davinci_gpio_regs __iomem *g = irq2regs(d->irq); u32 mask = (u32) irq_data_get_irq_handler_data(d); unsigned status = irqd_get_trigger_type(d); status &= IRQ_TYPE_EDGE_FALLING | IRQ_TYPE_EDGE_RISING; if (!status) status = IRQ_TYPE_EDGE_FALLING | IRQ_TYPE_EDGE_RISING; if (status & IRQ_TYPE_EDGE_FALLING) __raw_writel(mask, &g->set_falling); if (status & IRQ_TYPE_EDGE_RISING) __raw_writel(mask, &g->set_rising); }
static int rmi_spi_init_irq(struct spi_device *spi) { struct rmi_spi_xport *rmi_spi = spi_get_drvdata(spi); int irq_flags = irqd_get_trigger_type(irq_get_irq_data(rmi_spi->irq)); int ret; if (!irq_flags) irq_flags = IRQF_TRIGGER_LOW; ret = devm_request_threaded_irq(&spi->dev, rmi_spi->irq, NULL, rmi_spi_irq, irq_flags | IRQF_ONESHOT, dev_name(&spi->dev), rmi_spi); if (ret < 0) { dev_warn(&spi->dev, "Failed to register interrupt %d\n", rmi_spi->irq); return ret; } return 0; }
static int max8973_thermal_init(struct max8973_chip *mchip) { struct thermal_zone_device *tzd; struct irq_data *irq_data; unsigned long irq_flags = 0; int ret; if (mchip->id != MAX77621) return 0; tzd = devm_thermal_zone_of_sensor_register(mchip->dev, 0, mchip, &max77621_tz_ops); if (IS_ERR(tzd)) { ret = PTR_ERR(tzd); dev_err(mchip->dev, "Failed to register thermal sensor: %d\n", ret); return ret; } if (mchip->irq <= 0) return 0; irq_data = irq_get_irq_data(mchip->irq); if (irq_data) irq_flags = irqd_get_trigger_type(irq_data); ret = devm_request_threaded_irq(mchip->dev, mchip->irq, NULL, max8973_thermal_irq, IRQF_ONESHOT | IRQF_SHARED | irq_flags, dev_name(mchip->dev), mchip); if (ret < 0) { dev_err(mchip->dev, "Failed to request irq %d, %d\n", mchip->irq, ret); return ret; } return 0; }
void irq_modify_status(unsigned int irq, unsigned long clr, unsigned long set) { unsigned long flags, trigger, tmp; struct irq_desc *desc = irq_get_desc_lock(irq, &flags, 0); if (!desc) return; /* * Warn when a driver sets the no autoenable flag on an already * active interrupt. */ WARN_ON_ONCE(!desc->depth && (set & _IRQ_NOAUTOEN)); irq_settings_clr_and_set(desc, clr, set); trigger = irqd_get_trigger_type(&desc->irq_data); irqd_clear(&desc->irq_data, IRQD_NO_BALANCING | IRQD_PER_CPU | IRQD_TRIGGER_MASK | IRQD_LEVEL | IRQD_MOVE_PCNTXT); if (irq_settings_has_no_balance_set(desc)) irqd_set(&desc->irq_data, IRQD_NO_BALANCING); if (irq_settings_is_per_cpu(desc)) irqd_set(&desc->irq_data, IRQD_PER_CPU); if (irq_settings_can_move_pcntxt(desc)) irqd_set(&desc->irq_data, IRQD_MOVE_PCNTXT); if (irq_settings_is_level(desc)) irqd_set(&desc->irq_data, IRQD_LEVEL); tmp = irq_settings_get_trigger_mask(desc); if (tmp != IRQ_TYPE_NONE) trigger = tmp; irqd_set(&desc->irq_data, trigger); irq_put_desc_unlock(desc, flags); }
static irqreturn_t gpio_keys_gpio_isr(int irq, void *dev_id) { struct gpio_button_data *bdata = dev_id; BUG_ON(irq != bdata->irq); if (irqd_get_trigger_type(irq_get_irq_data(irq)) != bdata->irqflags) { pr_info("wake up cpu from deepsleep by gpio edge interrupt!"); irq_set_irq_type(bdata->irq, bdata->irqflags); } if (bdata->is_deepsleep) { bdata->is_deepsleep = false; } if (bdata->button->wakeup) pm_stay_awake(bdata->input->dev.parent); if (bdata->timer_debounce) mod_timer(&bdata->timer, jiffies + msecs_to_jiffies(bdata->timer_debounce)); else schedule_work(&bdata->work); return IRQ_HANDLED; }
/** * of_irq_to_resource - Decode a node's IRQ and return it as a resource * @dev: pointer to device tree node * @index: zero-based index of the irq * @r: pointer to resource structure to return result into. */ int of_irq_to_resource(struct device_node *dev, int index, struct resource *r) { int irq = irq_of_parse_and_map(dev, index); /* Only dereference the resource if both the * resource and the irq are valid. */ if (r && irq) { const char *name = NULL; memset(r, 0, sizeof(*r)); /* * Get optional "interrupts-names" property to add a name * to the resource. */ of_property_read_string_index(dev, "interrupt-names", index, &name); r->start = r->end = irq; r->flags = IORESOURCE_IRQ | irqd_get_trigger_type(irq_get_irq_data(irq)); r->name = name ? name : of_node_full_name(dev); } return irq; }
static int wl1271_probe(struct sdio_func *func, const struct sdio_device_id *id) { struct wlcore_platdev_data *pdev_data; struct wl12xx_sdio_glue *glue; struct resource res[2]; mmc_pm_flag_t mmcflags; int ret = -ENOMEM; int irq, wakeirq, num_irqs; const char *chip_family; /* We are only able to handle the wlan function */ if (func->num != 0x02) return -ENODEV; pdev_data = devm_kzalloc(&func->dev, sizeof(*pdev_data), GFP_KERNEL); if (!pdev_data) return -ENOMEM; pdev_data->if_ops = &sdio_ops; glue = devm_kzalloc(&func->dev, sizeof(*glue), GFP_KERNEL); if (!glue) return -ENOMEM; glue->dev = &func->dev; /* Grab access to FN0 for ELP reg. */ func->card->quirks |= MMC_QUIRK_LENIENT_FN0; /* Use block mode for transferring over one block size of data */ func->card->quirks |= MMC_QUIRK_BLKSZ_FOR_BYTE_MODE; ret = wlcore_probe_of(&func->dev, &irq, &wakeirq, pdev_data); if (ret) goto out; /* if sdio can keep power while host is suspended, enable wow */ mmcflags = sdio_get_host_pm_caps(func); dev_dbg(glue->dev, "sdio PM caps = 0x%x\n", mmcflags); if (mmcflags & MMC_PM_KEEP_POWER) pdev_data->pwr_in_suspend = true; sdio_set_drvdata(func, glue); /* Tell PM core that we don't need the card to be powered now */ pm_runtime_put_noidle(&func->dev); /* * Due to a hardware bug, we can't differentiate wl18xx from * wl12xx, because both report the same device ID. The only * way to differentiate is by checking the SDIO revision, * which is 3.00 on the wl18xx chips. */ if (func->card->cccr.sdio_vsn == SDIO_SDIO_REV_3_00) chip_family = "wl18xx"; else chip_family = "wl12xx"; glue->core = platform_device_alloc(chip_family, PLATFORM_DEVID_AUTO); if (!glue->core) { dev_err(glue->dev, "can't allocate platform_device"); ret = -ENOMEM; goto out; } glue->core->dev.parent = &func->dev; memset(res, 0x00, sizeof(res)); res[0].start = irq; res[0].flags = IORESOURCE_IRQ | irqd_get_trigger_type(irq_get_irq_data(irq)); res[0].name = "irq"; if (wakeirq > 0) { res[1].start = wakeirq; res[1].flags = IORESOURCE_IRQ | irqd_get_trigger_type(irq_get_irq_data(wakeirq)); res[1].name = "wakeirq"; num_irqs = 2; } else { num_irqs = 1; } ret = platform_device_add_resources(glue->core, res, num_irqs); if (ret) { dev_err(glue->dev, "can't add resources\n"); goto out_dev_put; } ret = platform_device_add_data(glue->core, pdev_data, sizeof(*pdev_data)); if (ret) { dev_err(glue->dev, "can't add platform data\n"); goto out_dev_put; } ret = platform_device_add(glue->core); if (ret) { dev_err(glue->dev, "can't add platform device\n"); goto out_dev_put; } return 0; out_dev_put: platform_device_put(glue->core); out: return ret; }
static int tda998x_create(struct i2c_client *client, struct tda998x_priv *priv) { struct device_node *np = client->dev.of_node; u32 video; int rev_lo, rev_hi, ret; unsigned short cec_addr; priv->vip_cntrl_0 = VIP_CNTRL_0_SWAP_A(2) | VIP_CNTRL_0_SWAP_B(3); priv->vip_cntrl_1 = VIP_CNTRL_1_SWAP_C(0) | VIP_CNTRL_1_SWAP_D(1); priv->vip_cntrl_2 = VIP_CNTRL_2_SWAP_E(4) | VIP_CNTRL_2_SWAP_F(5); priv->current_page = 0xff; priv->hdmi = client; /* CEC I2C address bound to TDA998x I2C addr by configuration pins */ cec_addr = 0x34 + (client->addr & 0x03); priv->cec = i2c_new_dummy(client->adapter, cec_addr); if (!priv->cec) return -ENODEV; priv->dpms = DRM_MODE_DPMS_OFF; mutex_init(&priv->mutex); /* protect the page access */ init_waitqueue_head(&priv->edid_delay_waitq); setup_timer(&priv->edid_delay_timer, tda998x_edid_delay_done, (unsigned long)priv); INIT_WORK(&priv->detect_work, tda998x_detect_work); /* wake up the device: */ cec_write(priv, REG_CEC_ENAMODS, CEC_ENAMODS_EN_RXSENS | CEC_ENAMODS_EN_HDMI); tda998x_reset(priv); /* read version: */ rev_lo = reg_read(priv, REG_VERSION_LSB); rev_hi = reg_read(priv, REG_VERSION_MSB); if (rev_lo < 0 || rev_hi < 0) { ret = rev_lo < 0 ? rev_lo : rev_hi; goto fail; } priv->rev = rev_lo | rev_hi << 8; /* mask off feature bits: */ priv->rev &= ~0x30; /* not-hdcp and not-scalar bit */ switch (priv->rev) { case TDA9989N2: dev_info(&client->dev, "found TDA9989 n2"); break; case TDA19989: dev_info(&client->dev, "found TDA19989"); break; case TDA19989N2: dev_info(&client->dev, "found TDA19989 n2"); break; case TDA19988: dev_info(&client->dev, "found TDA19988"); break; default: dev_err(&client->dev, "found unsupported device: %04x\n", priv->rev); goto fail; } /* after reset, enable DDC: */ reg_write(priv, REG_DDC_DISABLE, 0x00); /* set clock on DDC channel: */ reg_write(priv, REG_TX3, 39); /* if necessary, disable multi-master: */ if (priv->rev == TDA19989) reg_set(priv, REG_I2C_MASTER, I2C_MASTER_DIS_MM); cec_write(priv, REG_CEC_FRO_IM_CLK_CTRL, CEC_FRO_IM_CLK_CTRL_GHOST_DIS | CEC_FRO_IM_CLK_CTRL_IMCLK_SEL); /* initialize the optional IRQ */ if (client->irq) { int irqf_trigger; /* init read EDID waitqueue and HDP work */ init_waitqueue_head(&priv->wq_edid); /* clear pending interrupts */ reg_read(priv, REG_INT_FLAGS_0); reg_read(priv, REG_INT_FLAGS_1); reg_read(priv, REG_INT_FLAGS_2); irqf_trigger = irqd_get_trigger_type(irq_get_irq_data(client->irq)); ret = request_threaded_irq(client->irq, NULL, tda998x_irq_thread, irqf_trigger | IRQF_ONESHOT, "tda998x", priv); if (ret) { dev_err(&client->dev, "failed to request IRQ#%u: %d\n", client->irq, ret); goto fail; } /* enable HPD irq */ cec_write(priv, REG_CEC_RXSHPDINTENA, CEC_RXSHPDLEV_HPD); } /* enable EDID read irq: */ reg_set(priv, REG_INT_FLAGS_2, INT_FLAGS_2_EDID_BLK_RD); if (!np) return 0; /* non-DT */ /* get the optional video properties */ ret = of_property_read_u32(np, "video-ports", &video); if (ret == 0) { priv->vip_cntrl_0 = video >> 16; priv->vip_cntrl_1 = video >> 8; priv->vip_cntrl_2 = video; }
static int mag3110_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct i2c_adapter *adapter; struct input_dev *idev; struct mag3110_data *data; int ret = 0; struct regulator *vdd, *vdd_io; u32 pos = 0; struct device_node *of_node = client->dev.of_node; #if MAG3110_IRQ_USED struct irq_data *irq_data = irq_get_irq_data(client->irq); u32 irq_flag; bool shared_irq = of_property_read_bool(of_node, "shared-interrupt"); #endif vdd = NULL; vdd_io = NULL; vdd = devm_regulator_get(&client->dev, "vdd"); if (!IS_ERR(vdd)) { ret = regulator_enable(vdd); if (ret) { dev_err(&client->dev, "vdd set voltage error\n"); return ret; } } vdd_io = devm_regulator_get(&client->dev, "vddio"); if (!IS_ERR(vdd_io)) { ret = regulator_enable(vdd_io); if (ret) { dev_err(&client->dev, "vddio set voltage error\n"); return ret; } } adapter = to_i2c_adapter(client->dev.parent); if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE | I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_I2C_BLOCK)) return -EIO; dev_info(&client->dev, "check mag3110 chip ID\n"); ret = mag3110_read_reg(client, MAG3110_WHO_AM_I); if (MAG3110_ID != ret) { dev_err(&client->dev, "read chip ID 0x%x is not equal to 0x%x!\n", ret, MAG3110_ID); return -EINVAL; } data = kzalloc(sizeof(struct mag3110_data), GFP_KERNEL); if (!data) return -ENOMEM; data->client = client; i2c_set_clientdata(client, data); /* Init queue */ init_waitqueue_head(&data->waitq); data->hwmon_dev = hwmon_device_register(&client->dev); if (IS_ERR(data->hwmon_dev)) { dev_err(&client->dev, "hwmon register failed!\n"); ret = PTR_ERR(data->hwmon_dev); goto error_rm_dev_sysfs; } /*input poll device register */ data->poll_dev = input_allocate_polled_device(); if (!data->poll_dev) { dev_err(&client->dev, "alloc poll device failed!\n"); ret = -ENOMEM; goto error_rm_hwmon_dev; } data->poll_dev->poll = mag3110_dev_poll; data->poll_dev->poll_interval = POLL_INTERVAL; data->poll_dev->poll_interval_max = POLL_INTERVAL_MAX; idev = data->poll_dev->input; idev->name = MAG3110_DRV_NAME; idev->id.bustype = BUS_I2C; idev->evbit[0] = BIT_MASK(EV_ABS); input_set_abs_params(idev, ABS_X, -15000, 15000, 0, 0); input_set_abs_params(idev, ABS_Y, -15000, 15000, 0, 0); input_set_abs_params(idev, ABS_Z, -15000, 15000, 0, 0); ret = input_register_polled_device(data->poll_dev); if (ret) { dev_err(&client->dev, "register poll device failed!\n"); goto error_free_poll_dev; } /*create device group in sysfs as user interface */ ret = sysfs_create_group(&idev->dev.kobj, &mag3110_attr_group); if (ret) { dev_err(&client->dev, "create device file failed!\n"); ret = -EINVAL; goto error_rm_poll_dev; } #if MAG3110_IRQ_USED irq_flag = irqd_get_trigger_type(irq_data); irq_flag |= IRQF_ONESHOT; if (shared_irq) irq_flag |= IRQF_SHARED; ret = request_threaded_irq(client->irq, NULL, mag3110_irq_handler, irq_flag, client->dev.driver->name, idev); if (ret < 0) { dev_err(&client->dev, "failed to register irq %d!\n", client->irq); goto error_rm_dev_sysfs; } #endif /* Initialize mag3110 chip */ mag3110_init_client(client); mag3110_pdata = data; mag3110_pdata->active = MAG_STANDBY; ret = of_property_read_u32(of_node, "position", &pos); if (ret) pos = DEFAULT_POSITION; mag3110_pdata->position = (int)pos; dev_info(&client->dev, "mag3110 is probed\n"); return 0; error_rm_dev_sysfs: sysfs_remove_group(&client->dev.kobj, &mag3110_attr_group); error_rm_poll_dev: input_unregister_polled_device(data->poll_dev); error_free_poll_dev: input_free_polled_device(data->poll_dev); error_rm_hwmon_dev: hwmon_device_unregister(data->hwmon_dev); kfree(data); mag3110_pdata = NULL; return ret; }
int arizona_irq_init(struct arizona *arizona) { int flags = IRQF_ONESHOT; int ret, i; const struct regmap_irq_chip *aod, *irq; struct irq_data *irq_data; arizona->ctrlif_error = true; switch (arizona->type) { #ifdef CONFIG_MFD_WM5102 case WM5102: aod = &wm5102_aod; irq = &wm5102_irq; arizona->ctrlif_error = false; break; #endif #ifdef CONFIG_MFD_WM5110 case WM5110: case WM8280: aod = &wm5110_aod; switch (arizona->rev) { case 0 ... 2: irq = &wm5110_irq; break; default: irq = &wm5110_revd_irq; break; } arizona->ctrlif_error = false; break; #endif #ifdef CONFIG_MFD_WM8997 case WM8997: aod = &wm8997_aod; irq = &wm8997_irq; arizona->ctrlif_error = false; break; #endif #ifdef CONFIG_MFD_WM8998 case WM8998: case WM1814: aod = &wm8998_aod; irq = &wm8998_irq; arizona->ctrlif_error = false; break; #endif default: BUG_ON("Unknown Arizona class device" == NULL); return -EINVAL; } /* Disable all wake sources by default */ regmap_write(arizona->regmap, ARIZONA_WAKE_CONTROL, 0); /* Read the flags from the interrupt controller if not specified */ if (!arizona->pdata.irq_flags) { irq_data = irq_get_irq_data(arizona->irq); if (!irq_data) { dev_err(arizona->dev, "Invalid IRQ: %d\n", arizona->irq); return -EINVAL; } arizona->pdata.irq_flags = irqd_get_trigger_type(irq_data); switch (arizona->pdata.irq_flags) { case IRQF_TRIGGER_LOW: case IRQF_TRIGGER_HIGH: case IRQF_TRIGGER_RISING: case IRQF_TRIGGER_FALLING: break; case IRQ_TYPE_NONE: default: /* Device default */ arizona->pdata.irq_flags = IRQF_TRIGGER_LOW; break; } } if (arizona->pdata.irq_flags & (IRQF_TRIGGER_HIGH | IRQF_TRIGGER_RISING)) { ret = regmap_update_bits(arizona->regmap, ARIZONA_IRQ_CTRL_1, ARIZONA_IRQ_POL, 0); if (ret != 0) { dev_err(arizona->dev, "Couldn't set IRQ polarity: %d\n", ret); goto err; } } flags |= arizona->pdata.irq_flags; /* Allocate a virtual IRQ domain to distribute to the regmap domains */ arizona->virq = irq_domain_add_linear(NULL, 2, &arizona_domain_ops, arizona); if (!arizona->virq) { dev_err(arizona->dev, "Failed to add core IRQ domain\n"); ret = -EINVAL; goto err; } ret = regmap_add_irq_chip(arizona->regmap, irq_create_mapping(arizona->virq, 0), IRQF_ONESHOT, 0, aod, &arizona->aod_irq_chip); if (ret != 0) { dev_err(arizona->dev, "Failed to add AOD IRQs: %d\n", ret); goto err_domain; } ret = regmap_add_irq_chip(arizona->regmap, irq_create_mapping(arizona->virq, 1), IRQF_ONESHOT, 0, irq, &arizona->irq_chip); if (ret != 0) { dev_err(arizona->dev, "Failed to add main IRQs: %d\n", ret); goto err_aod; } /* Make sure the boot done IRQ is unmasked for resumes */ i = arizona_map_irq(arizona, ARIZONA_IRQ_BOOT_DONE); ret = request_threaded_irq(i, NULL, arizona_boot_done, IRQF_ONESHOT, "Boot done", arizona); if (ret != 0) { dev_err(arizona->dev, "Failed to request boot done %d: %d\n", arizona->irq, ret); goto err_boot_done; } /* Handle control interface errors in the core */ if (arizona->ctrlif_error) { i = arizona_map_irq(arizona, ARIZONA_IRQ_CTRLIF_ERR); ret = request_threaded_irq(i, NULL, arizona_ctrlif_err, IRQF_ONESHOT, "Control interface error", arizona); if (ret != 0) { dev_err(arizona->dev, "Failed to request CTRLIF_ERR %d: %d\n", arizona->irq, ret); goto err_ctrlif; } } /* Used to emulate edge trigger and to work around broken pinmux */ if (arizona->pdata.irq_gpio) { if (gpio_to_irq(arizona->pdata.irq_gpio) != arizona->irq) { dev_warn(arizona->dev, "IRQ %d is not GPIO %d (%d)\n", arizona->irq, arizona->pdata.irq_gpio, gpio_to_irq(arizona->pdata.irq_gpio)); arizona->irq = gpio_to_irq(arizona->pdata.irq_gpio); } ret = devm_gpio_request_one(arizona->dev, arizona->pdata.irq_gpio, GPIOF_IN, "arizona IRQ"); if (ret != 0) { dev_err(arizona->dev, "Failed to request IRQ GPIO %d:: %d\n", arizona->pdata.irq_gpio, ret); arizona->pdata.irq_gpio = 0; } } ret = request_threaded_irq(arizona->irq, NULL, arizona_irq_thread, flags, "arizona", arizona); if (ret != 0) { dev_err(arizona->dev, "Failed to request primary IRQ %d: %d\n", arizona->irq, ret); goto err_main_irq; } return 0; err_main_irq: if (arizona->ctrlif_error) free_irq(arizona_map_irq(arizona, ARIZONA_IRQ_CTRLIF_ERR), arizona); err_ctrlif: free_irq(arizona_map_irq(arizona, ARIZONA_IRQ_BOOT_DONE), arizona); err_boot_done: regmap_del_irq_chip(irq_create_mapping(arizona->virq, 1), arizona->irq_chip); err_aod: regmap_del_irq_chip(irq_create_mapping(arizona->virq, 0), arizona->aod_irq_chip); err_domain: err: return ret; }
static int madera_irq_probe(struct platform_device *pdev) { struct madera *madera = dev_get_drvdata(pdev->dev.parent); struct irq_data *irq_data; unsigned int irq_flags = 0; int ret; dev_dbg(&pdev->dev, "probe\n"); /* * Read the flags from the interrupt controller if not specified * by pdata */ irq_flags = madera->pdata.irq_flags; if (!irq_flags) { irq_data = irq_get_irq_data(madera->irq); if (!irq_data) { dev_err(&pdev->dev, "Invalid IRQ: %d\n", madera->irq); return -EINVAL; } irq_flags = irqd_get_trigger_type(irq_data); /* Codec defaults to trigger low, use this if no flags given */ if (irq_flags == IRQ_TYPE_NONE) irq_flags = IRQF_TRIGGER_LOW; } if (irq_flags & (IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING)) { dev_err(&pdev->dev, "Host interrupt not level-triggered\n"); return -EINVAL; } /* * The silicon always starts at active-low, check if we need to * switch to active-high. */ if (irq_flags & IRQF_TRIGGER_HIGH) { ret = regmap_update_bits(madera->regmap, MADERA_IRQ1_CTRL, MADERA_IRQ_POL_MASK, 0); if (ret) { dev_err(&pdev->dev, "Failed to set IRQ polarity: %d\n", ret); return ret; } } /* * NOTE: regmap registers this against the OF node of the parent of * the regmap - that is, against the mfd driver */ ret = regmap_add_irq_chip(madera->regmap, madera->irq, IRQF_ONESHOT, 0, &madera_irq_chip, &madera->irq_data); if (ret) { dev_err(&pdev->dev, "add_irq_chip failed: %d\n", ret); return ret; } /* Save dev in parent MFD struct so it is accessible to siblings */ madera->irq_dev = &pdev->dev; return 0; }
int arizona_irq_init(struct arizona *arizona) { int flags = IRQF_ONESHOT; int ret, i; struct regmap_irq_chip *aod, *irq; bool ctrlif_error = true; int irq_base; struct irq_data *irq_data; switch (arizona->type) { #ifdef CONFIG_MFD_WM5102 case WM5102: aod = &wm5102_aod; irq = &wm5102_irq; ctrlif_error = false; break; #endif #ifdef CONFIG_MFD_WM5110 case WM5110: aod = &wm5110_aod; irq = &wm5110_irq; ctrlif_error = false; break; #endif default: BUG_ON("Unknown Arizona class device" == NULL); return -EINVAL; } /* Disable all wake sources by default */ regmap_write(arizona->regmap, ARIZONA_WAKE_CONTROL, 0); /* Read the flags from the interrupt controller if not specified */ if (!arizona->pdata.irq_flags) { irq_data = irq_get_irq_data(arizona->irq); if (!irq_data) { dev_err(arizona->dev, "Invalid IRQ: %d\n", arizona->irq); return -EINVAL; } arizona->pdata.irq_flags = irqd_get_trigger_type(irq_data); switch (arizona->pdata.irq_flags) { case IRQF_TRIGGER_LOW: case IRQF_TRIGGER_HIGH: case IRQF_TRIGGER_RISING: case IRQF_TRIGGER_FALLING: break; case IRQ_TYPE_NONE: default: /* Device default */ arizona->pdata.irq_flags = IRQF_TRIGGER_LOW; break; } } if (arizona->pdata.irq_flags & (IRQF_TRIGGER_HIGH | IRQF_TRIGGER_RISING)) { ret = regmap_update_bits(arizona->regmap, ARIZONA_IRQ_CTRL_1, ARIZONA_IRQ_POL, 0); if (ret != 0) { dev_err(arizona->dev, "Couldn't set IRQ polarity: %d\n", ret); goto err; } } flags |= arizona->pdata.irq_flags; /* set up virtual IRQs */ irq_base = irq_alloc_descs(arizona->pdata.irq_base, 0, ARRAY_SIZE(arizona->virq), 0); if (irq_base < 0) { dev_warn(arizona->dev, "Failed to allocate IRQs: %d\n", irq_base); return irq_base; } arizona->virq[0] = irq_base; arizona->virq[1] = irq_base + 1; irq_base += 2; for (i = 0; i < ARRAY_SIZE(arizona->virq); i++) { irq_set_chip_and_handler(arizona->virq[i], &arizona_irq_chip, handle_edge_irq); irq_set_nested_thread(arizona->virq[i], 1); /* ARM needs us to explicitly flag the IRQ as valid * and will set them noprobe when we do so. */ #ifdef CONFIG_ARM set_irq_flags(arizona->virq[i], IRQF_VALID); #else irq_set_noprobe(arizona->virq[i]); #endif } ret = regmap_add_irq_chip(arizona->regmap, arizona->virq[0], IRQF_ONESHOT, irq_base, aod, &arizona->aod_irq_chip); if (ret != 0) { dev_err(arizona->dev, "Failed to add AOD IRQs: %d\n", ret); goto err_domain; } ret = regmap_add_irq_chip(arizona->regmap, arizona->virq[1], IRQF_ONESHOT, irq_base + ARIZONA_NUM_IRQ, irq, &arizona->irq_chip); if (ret != 0) { dev_err(arizona->dev, "Failed to add IRQs: %d\n", ret); goto err_aod; } /* Make sure the boot done IRQ is unmasked for resumes */ i = arizona_map_irq(arizona, ARIZONA_IRQ_BOOT_DONE); ret = request_threaded_irq(i, NULL, arizona_boot_done, IRQF_ONESHOT, "Boot done", arizona); if (ret != 0) { dev_err(arizona->dev, "Failed to request boot done %d: %d\n", arizona->irq, ret); goto err_boot_done; } /* Handle control interface errors in the core */ if (ctrlif_error) { i = arizona_map_irq(arizona, ARIZONA_IRQ_CTRLIF_ERR); ret = request_threaded_irq(i, NULL, arizona_ctrlif_err, IRQF_ONESHOT, "Control interface error", arizona); if (ret != 0) { dev_err(arizona->dev, "Failed to request CTRLIF_ERR %d: %d\n", arizona->irq, ret); goto err_ctrlif; } } /* Used to emulate edge trigger and to work around broken pinmux */ if (arizona->pdata.irq_gpio) { if (gpio_to_irq(arizona->pdata.irq_gpio) != arizona->irq) { dev_warn(arizona->dev, "IRQ %d is not GPIO %d (%d)\n", arizona->irq, arizona->pdata.irq_gpio, gpio_to_irq(arizona->pdata.irq_gpio)); arizona->irq = gpio_to_irq(arizona->pdata.irq_gpio); } ret = gpio_request_one(arizona->pdata.irq_gpio, GPIOF_IN, "arizona IRQ"); if (ret != 0) { dev_err(arizona->dev, "Failed to request IRQ GPIO %d:: %d\n", arizona->pdata.irq_gpio, ret); arizona->pdata.irq_gpio = 0; } } ret = request_threaded_irq(arizona->irq, NULL, arizona_irq_thread, flags, "arizona", arizona); if (ret != 0) { dev_err(arizona->dev, "Failed to request primary IRQ %d: %d\n", arizona->irq, ret); goto err_main_irq; } return 0; err_main_irq: free_irq(arizona_map_irq(arizona, ARIZONA_IRQ_CTRLIF_ERR), arizona); err_ctrlif: free_irq(arizona_map_irq(arizona, ARIZONA_IRQ_BOOT_DONE), arizona); err_boot_done: regmap_del_irq_chip(arizona->virq[1], arizona->irq_chip); err_aod: regmap_del_irq_chip(arizona->virq[0], arizona->aod_irq_chip); err_domain: err: return ret; }
static void __irq_do_set_handler(struct irq_desc *desc, irq_flow_handler_t handle, int is_chained, const char *name) { if (!handle) { handle = handle_bad_irq; } else { struct irq_data *irq_data = &desc->irq_data; #ifdef CONFIG_IRQ_DOMAIN_HIERARCHY /* * With hierarchical domains we might run into a * situation where the outermost chip is not yet set * up, but the inner chips are there. Instead of * bailing we install the handler, but obviously we * cannot enable/startup the interrupt at this point. */ while (irq_data) { if (irq_data->chip != &no_irq_chip) break; /* * Bail out if the outer chip is not set up * and the interrrupt supposed to be started * right away. */ if (WARN_ON(is_chained)) return; /* Try the parent */ irq_data = irq_data->parent_data; } #endif if (WARN_ON(!irq_data || irq_data->chip == &no_irq_chip)) return; } /* Uninstall? */ if (handle == handle_bad_irq) { if (desc->irq_data.chip != &no_irq_chip) mask_ack_irq(desc); irq_state_set_disabled(desc); if (is_chained) desc->action = NULL; desc->depth = 1; } desc->handle_irq = handle; desc->name = name; if (handle != handle_bad_irq && is_chained) { unsigned int type = irqd_get_trigger_type(&desc->irq_data); /* * We're about to start this interrupt immediately, * hence the need to set the trigger configuration. * But the .set_type callback may have overridden the * flow handler, ignoring that we're dealing with a * chained interrupt. Reset it immediately because we * do know better. */ if (type != IRQ_TYPE_NONE) { __irq_set_trigger(desc, type); desc->handle_irq = handle; } irq_settings_set_noprobe(desc); irq_settings_set_norequest(desc); irq_settings_set_nothread(desc); desc->action = &chained_action; irq_activate_and_startup(desc, IRQ_RESEND); } }
static int mpu3050_trigger_probe(struct iio_dev *indio_dev, int irq) { struct mpu3050 *mpu3050 = iio_priv(indio_dev); unsigned long irq_trig; int ret; mpu3050->trig = devm_iio_trigger_alloc(&indio_dev->dev, "%s-dev%d", indio_dev->name, indio_dev->id); if (!mpu3050->trig) return -ENOMEM; /* Check if IRQ is open drain */ if (of_property_read_bool(mpu3050->dev->of_node, "drive-open-drain")) mpu3050->irq_opendrain = true; irq_trig = irqd_get_trigger_type(irq_get_irq_data(irq)); /* * Configure the interrupt generator hardware to supply whatever * the interrupt is configured for, edges low/high level low/high, * we can provide it all. */ switch (irq_trig) { case IRQF_TRIGGER_RISING: dev_info(&indio_dev->dev, "pulse interrupts on the rising edge\n"); break; case IRQF_TRIGGER_FALLING: mpu3050->irq_actl = true; dev_info(&indio_dev->dev, "pulse interrupts on the falling edge\n"); break; case IRQF_TRIGGER_HIGH: mpu3050->irq_latch = true; dev_info(&indio_dev->dev, "interrupts active high level\n"); /* * With level IRQs, we mask the IRQ until it is processed, * but with edge IRQs (pulses) we can queue several interrupts * in the top half. */ irq_trig |= IRQF_ONESHOT; break; case IRQF_TRIGGER_LOW: mpu3050->irq_latch = true; mpu3050->irq_actl = true; irq_trig |= IRQF_ONESHOT; dev_info(&indio_dev->dev, "interrupts active low level\n"); break; default: /* This is the most preferred mode, if possible */ dev_err(&indio_dev->dev, "unsupported IRQ trigger specified (%lx), enforce " "rising edge\n", irq_trig); irq_trig = IRQF_TRIGGER_RISING; break; } /* An open drain line can be shared with several devices */ if (mpu3050->irq_opendrain) irq_trig |= IRQF_SHARED; ret = request_threaded_irq(irq, mpu3050_irq_handler, mpu3050_irq_thread, irq_trig, mpu3050->trig->name, mpu3050->trig); if (ret) { dev_err(mpu3050->dev, "can't get IRQ %d, error %d\n", irq, ret); return ret; } mpu3050->irq = irq; mpu3050->trig->dev.parent = mpu3050->dev; mpu3050->trig->ops = &mpu3050_trigger_ops; iio_trigger_set_drvdata(mpu3050->trig, indio_dev); ret = iio_trigger_register(mpu3050->trig); if (ret) return ret; indio_dev->trig = iio_trigger_get(mpu3050->trig); return 0; }
int st_sensors_allocate_trigger(struct iio_dev *indio_dev, const struct iio_trigger_ops *trigger_ops) { int err, irq; struct st_sensor_data *sdata = iio_priv(indio_dev); unsigned long irq_trig; sdata->trig = iio_trigger_alloc("%s-trigger", indio_dev->name); if (sdata->trig == NULL) { dev_err(&indio_dev->dev, "failed to allocate iio trigger.\n"); return -ENOMEM; } irq = sdata->get_irq_data_ready(indio_dev); irq_trig = irqd_get_trigger_type(irq_get_irq_data(irq)); /* * If the IRQ is triggered on falling edge, we need to mark the * interrupt as active low, if the hardware supports this. */ if (irq_trig == IRQF_TRIGGER_FALLING) { if (!sdata->sensor_settings->drdy_irq.addr_ihl) { dev_err(&indio_dev->dev, "falling edge specified for IRQ but hardware " "only support rising edge, will request " "rising edge\n"); irq_trig = IRQF_TRIGGER_RISING; } else { /* Set up INT active low i.e. falling edge */ err = st_sensors_write_data_with_mask(indio_dev, sdata->sensor_settings->drdy_irq.addr_ihl, sdata->sensor_settings->drdy_irq.mask_ihl, 1); if (err < 0) goto iio_trigger_free; dev_info(&indio_dev->dev, "interrupts on the falling edge\n"); } } else if (irq_trig == IRQF_TRIGGER_RISING) { dev_info(&indio_dev->dev, "interrupts on the rising edge\n"); } else { dev_err(&indio_dev->dev, "unsupported IRQ trigger specified (%lx), only " "rising and falling edges supported, enforce " "rising edge\n", irq_trig); irq_trig = IRQF_TRIGGER_RISING; } /* * If the interrupt pin is Open Drain, by definition this * means that the interrupt line may be shared with other * peripherals. But to do this we also need to have a status * register and mask to figure out if this sensor was firing * the IRQ or not, so we can tell the interrupt handle that * it was "our" interrupt. */ if (sdata->int_pin_open_drain && sdata->sensor_settings->drdy_irq.addr_stat_drdy) irq_trig |= IRQF_SHARED; err = request_threaded_irq(irq, iio_trigger_generic_data_rdy_poll, NULL, irq_trig, sdata->trig->name, sdata->trig); if (err) { dev_err(&indio_dev->dev, "failed to request trigger IRQ.\n"); goto iio_trigger_free; } iio_trigger_set_drvdata(sdata->trig, indio_dev); sdata->trig->ops = trigger_ops; sdata->trig->dev.parent = sdata->dev; err = iio_trigger_register(sdata->trig); if (err < 0) { dev_err(&indio_dev->dev, "failed to register iio trigger.\n"); goto iio_trigger_register_error; } indio_dev->trig = iio_trigger_get(sdata->trig); return 0; iio_trigger_register_error: free_irq(sdata->get_irq_data_ready(indio_dev), sdata->trig); iio_trigger_free: iio_trigger_free(sdata->trig); return err; }
int st_sensors_allocate_trigger(struct iio_dev *indio_dev, const struct iio_trigger_ops *trigger_ops) { int err, irq; struct st_sensor_data *sdata = iio_priv(indio_dev); unsigned long irq_trig; sdata->trig = iio_trigger_alloc("%s-trigger", indio_dev->name); if (sdata->trig == NULL) { dev_err(&indio_dev->dev, "failed to allocate iio trigger.\n"); return -ENOMEM; } irq = sdata->get_irq_data_ready(indio_dev); irq_trig = irqd_get_trigger_type(irq_get_irq_data(irq)); /* * If the IRQ is triggered on falling edge, we need to mark the * interrupt as active low, if the hardware supports this. */ if (irq_trig == IRQF_TRIGGER_FALLING) { if (!sdata->sensor_settings->drdy_irq.addr_ihl) { dev_err(&indio_dev->dev, "falling edge specified for IRQ but hardware " "only support rising edge, will request " "rising edge\n"); irq_trig = IRQF_TRIGGER_RISING; } else { /* Set up INT active low i.e. falling edge */ err = st_sensors_write_data_with_mask(indio_dev, sdata->sensor_settings->drdy_irq.addr_ihl, sdata->sensor_settings->drdy_irq.mask_ihl, 1); if (err < 0) goto iio_trigger_free; dev_info(&indio_dev->dev, "interrupts on the falling edge\n"); } } else if (irq_trig == IRQF_TRIGGER_RISING) { dev_info(&indio_dev->dev, "interrupts on the rising edge\n"); } else { dev_err(&indio_dev->dev, "unsupported IRQ trigger specified (%lx), only " "rising and falling edges supported, enforce " "rising edge\n", irq_trig); irq_trig = IRQF_TRIGGER_RISING; } err = request_threaded_irq(irq, iio_trigger_generic_data_rdy_poll, NULL, irq_trig, sdata->trig->name, sdata->trig); if (err) { dev_err(&indio_dev->dev, "failed to request trigger IRQ.\n"); goto iio_trigger_free; } iio_trigger_set_drvdata(sdata->trig, indio_dev); sdata->trig->ops = trigger_ops; sdata->trig->dev.parent = sdata->dev; err = iio_trigger_register(sdata->trig); if (err < 0) { dev_err(&indio_dev->dev, "failed to register iio trigger.\n"); goto iio_trigger_register_error; } indio_dev->trig = iio_trigger_get(sdata->trig); return 0; iio_trigger_register_error: free_irq(sdata->get_irq_data_ready(indio_dev), sdata->trig); iio_trigger_free: iio_trigger_free(sdata->trig); return err; }