static void ite_remove(struct pnp_dev *pdev) { struct ite_dev *dev = pnp_get_drvdata(pdev); unsigned long flags; ite_dbg("%s called", __func__); spin_lock_irqsave(&dev->lock, flags); /* disable hardware */ dev->params.disable(dev); spin_unlock_irqrestore(&dev->lock, flags); /* free resources */ free_irq(dev->cir_irq, dev); release_region(dev->cir_addr, dev->params.io_region_size); rc_unregister_device(dev->rdev); kfree(dev); }
void img_ir_remove_raw(struct img_ir_priv *priv) { struct img_ir_priv_raw *raw = &priv->raw; struct rc_dev *rdev = raw->rdev; u32 irq_en; if (!rdev) return; /* switch off and disable raw (edge) interrupts */ spin_lock_irq(&priv->lock); raw->rdev = NULL; irq_en = img_ir_read(priv, IMG_IR_IRQ_ENABLE); irq_en &= ~IMG_IR_IRQ_EDGE; img_ir_write(priv, IMG_IR_IRQ_ENABLE, irq_en); img_ir_write(priv, IMG_IR_IRQ_CLEAR, IMG_IR_IRQ_EDGE); spin_unlock_irq(&priv->lock); rc_unregister_device(rdev); del_timer_sync(&raw->timer); }
static int sunxi_ir_remove(struct platform_device *pdev) { unsigned long flags; struct sunxi_ir *ir = platform_get_drvdata(pdev); clk_disable_unprepare(ir->clk); clk_disable_unprepare(ir->apb_clk); if (ir->rst) reset_control_assert(ir->rst); spin_lock_irqsave(&ir->ir_lock, flags); /* disable IR IRQ */ writel(0, ir->base + SUNXI_IR_RXINT_REG); /* clear All Rx Interrupt Status */ writel(REG_RXSTA_CLEARALL, ir->base + SUNXI_IR_RXSTA_REG); /* disable IR */ writel(0, ir->base + SUNXI_IR_CTL_REG); spin_unlock_irqrestore(&ir->ir_lock, flags); rc_unregister_device(ir->rc); return 0; }
static int lme2510_int_service(struct dvb_usb_adapter *adap) { struct dvb_usb_device *d = adap->dev; struct rc_dev *rc; int ret; info("STA Configuring Remote"); rc = rc_allocate_device(); if (!rc) return -ENOMEM; usb_make_path(d->udev, d->rc_phys, sizeof(d->rc_phys)); strlcat(d->rc_phys, "/ir0", sizeof(d->rc_phys)); rc->input_name = "LME2510 Remote Control"; rc->input_phys = d->rc_phys; rc->map_name = RC_MAP_LME2510; rc->driver_name = "LME 2510"; usb_to_input_id(d->udev, &rc->input_id); ret = rc_register_device(rc); if (ret) { rc_free_device(rc); return ret; } d->rc_dev = rc; /* Start the Interupt */ ret = lme2510_int_read(adap); if (ret < 0) { rc_unregister_device(rc); info("INT Unable to start Interupt Service"); return -ENODEV; } return 0; }
/* allocate memory, probe hardware, and initialize everything */ static int ite_probe(struct pnp_dev *pdev, const struct pnp_device_id *dev_id) { const struct ite_dev_params *dev_desc = NULL; struct ite_dev *itdev = NULL; struct rc_dev *rdev = NULL; int ret = -ENOMEM; int model_no; int io_rsrc_no; ite_dbg("%s called", __func__); itdev = kzalloc(sizeof(struct ite_dev), GFP_KERNEL); if (!itdev) return ret; /* input device for IR remote (and tx) */ rdev = rc_allocate_device(); if (!rdev) goto exit_free_dev_rdev; itdev->rdev = rdev; ret = -ENODEV; /* get the model number */ model_no = (int)dev_id->driver_data; ite_pr(KERN_NOTICE, "Auto-detected model: %s\n", ite_dev_descs[model_no].model); if (model_number >= 0 && model_number < ARRAY_SIZE(ite_dev_descs)) { model_no = model_number; ite_pr(KERN_NOTICE, "The model has been fixed by a module " "parameter."); } ite_pr(KERN_NOTICE, "Using model: %s\n", ite_dev_descs[model_no].model); /* get the description for the device */ dev_desc = &ite_dev_descs[model_no]; io_rsrc_no = dev_desc->io_rsrc_no; /* validate pnp resources */ if (!pnp_port_valid(pdev, io_rsrc_no) || pnp_port_len(pdev, io_rsrc_no) != dev_desc->io_region_size) { dev_err(&pdev->dev, "IR PNP Port not valid!\n"); goto exit_free_dev_rdev; } if (!pnp_irq_valid(pdev, 0)) { dev_err(&pdev->dev, "PNP IRQ not valid!\n"); goto exit_free_dev_rdev; } /* store resource values */ itdev->cir_addr = pnp_port_start(pdev, io_rsrc_no); itdev->cir_irq = pnp_irq(pdev, 0); /* initialize spinlocks */ spin_lock_init(&itdev->lock); /* initialize raw event */ init_ir_raw_event(&itdev->rawir); /* set driver data into the pnp device */ pnp_set_drvdata(pdev, itdev); itdev->pdev = pdev; /* initialize waitqueues for transmission */ init_waitqueue_head(&itdev->tx_queue); init_waitqueue_head(&itdev->tx_ended); /* copy model-specific parameters */ itdev->params = *dev_desc; /* apply any overrides */ if (sample_period > 0) itdev->params.sample_period = sample_period; if (tx_carrier_freq > 0) itdev->params.tx_carrier_freq = tx_carrier_freq; if (tx_duty_cycle > 0 && tx_duty_cycle <= 100) itdev->params.tx_duty_cycle = tx_duty_cycle; if (rx_low_carrier_freq > 0) itdev->params.rx_low_carrier_freq = rx_low_carrier_freq; if (rx_high_carrier_freq > 0) itdev->params.rx_high_carrier_freq = rx_high_carrier_freq; /* print out parameters */ ite_pr(KERN_NOTICE, "TX-capable: %d\n", (int) itdev->params.hw_tx_capable); ite_pr(KERN_NOTICE, "Sample period (ns): %ld\n", (long) itdev->params.sample_period); ite_pr(KERN_NOTICE, "TX carrier frequency (Hz): %d\n", (int) itdev->params.tx_carrier_freq); ite_pr(KERN_NOTICE, "TX duty cycle (%%): %d\n", (int) itdev->params.tx_duty_cycle); ite_pr(KERN_NOTICE, "RX low carrier frequency (Hz): %d\n", (int) itdev->params.rx_low_carrier_freq); ite_pr(KERN_NOTICE, "RX high carrier frequency (Hz): %d\n", (int) itdev->params.rx_high_carrier_freq); /* set up hardware initial state */ itdev->params.init_hardware(itdev); /* set up ir-core props */ rdev->priv = itdev; rdev->driver_type = RC_DRIVER_IR_RAW; rdev->allowed_protos = RC_BIT_ALL; rdev->open = ite_open; rdev->close = ite_close; rdev->s_idle = ite_s_idle; rdev->s_rx_carrier_range = ite_set_rx_carrier_range; rdev->min_timeout = ITE_MIN_IDLE_TIMEOUT; rdev->max_timeout = ITE_MAX_IDLE_TIMEOUT; rdev->timeout = ITE_IDLE_TIMEOUT; rdev->rx_resolution = ITE_BAUDRATE_DIVISOR * itdev->params.sample_period; rdev->tx_resolution = ITE_BAUDRATE_DIVISOR * itdev->params.sample_period; /* set up transmitter related values if needed */ if (itdev->params.hw_tx_capable) { rdev->tx_ir = ite_tx_ir; rdev->s_tx_carrier = ite_set_tx_carrier; rdev->s_tx_duty_cycle = ite_set_tx_duty_cycle; } rdev->input_name = dev_desc->model; rdev->input_id.bustype = BUS_HOST; rdev->input_id.vendor = PCI_VENDOR_ID_ITE; rdev->input_id.product = 0; rdev->input_id.version = 0; rdev->driver_name = ITE_DRIVER_NAME; rdev->map_name = RC_MAP_RC6_MCE; ret = rc_register_device(rdev); if (ret) goto exit_free_dev_rdev; ret = -EBUSY; /* now claim resources */ if (!request_region(itdev->cir_addr, dev_desc->io_region_size, ITE_DRIVER_NAME)) goto exit_unregister_device; if (request_irq(itdev->cir_irq, ite_cir_isr, IRQF_SHARED, ITE_DRIVER_NAME, (void *)itdev)) goto exit_release_cir_addr; ite_pr(KERN_NOTICE, "driver has been successfully loaded\n"); return 0; exit_release_cir_addr: release_region(itdev->cir_addr, itdev->params.io_region_size); exit_unregister_device: rc_unregister_device(rdev); exit_free_dev_rdev: rc_free_device(rdev); kfree(itdev); return ret; }
static void __exit loop_exit(void) { rc_unregister_device(loopdev.dev); }
static int gpio_ir_recv_probe(struct platform_device *pdev) { struct gpio_rc_dev *gpio_dev; struct rc_dev *rcdev; const struct gpio_ir_recv_platform_data *pdata = pdev->dev.platform_data; int rc; if (pdev->dev.of_node) { struct gpio_ir_recv_platform_data *dtpdata = devm_kzalloc(&pdev->dev, sizeof(*dtpdata), GFP_KERNEL); if (!dtpdata) return -ENOMEM; rc = gpio_ir_recv_get_devtree_pdata(&pdev->dev, dtpdata); if (rc) return rc; pdata = dtpdata; } if (!pdata) return -EINVAL; if (pdata->gpio_nr < 0) return -EINVAL; gpio_dev = kzalloc(sizeof(struct gpio_rc_dev), GFP_KERNEL); if (!gpio_dev) return -ENOMEM; rcdev = rc_allocate_device(); if (!rcdev) { rc = -ENOMEM; goto err_allocate_device; } rcdev->priv = gpio_dev; rcdev->driver_type = RC_DRIVER_IR_RAW; rcdev->input_name = GPIO_IR_DEVICE_NAME; rcdev->input_phys = GPIO_IR_DEVICE_NAME "/input0"; rcdev->input_id.bustype = BUS_HOST; rcdev->input_id.vendor = 0x0001; rcdev->input_id.product = 0x0001; rcdev->input_id.version = 0x0100; rcdev->dev.parent = &pdev->dev; rcdev->driver_name = GPIO_IR_DRIVER_NAME; if (pdata->allowed_protos) rcdev->allowed_protos = pdata->allowed_protos; else rcdev->allowed_protos = RC_BIT_ALL; rcdev->map_name = pdata->map_name ?: RC_MAP_EMPTY; gpio_dev->rcdev = rcdev; gpio_dev->gpio_nr = pdata->gpio_nr; gpio_dev->active_low = pdata->active_low; rc = gpio_request(pdata->gpio_nr, "gpio-ir-recv"); if (rc < 0) goto err_gpio_request; rc = gpio_direction_input(pdata->gpio_nr); if (rc < 0) goto err_gpio_direction_input; rc = rc_register_device(rcdev); if (rc < 0) { dev_err(&pdev->dev, "failed to register rc device\n"); goto err_register_rc_device; } platform_set_drvdata(pdev, gpio_dev); rc = request_any_context_irq(gpio_to_irq(pdata->gpio_nr), gpio_ir_recv_irq, IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING, "gpio-ir-recv-irq", gpio_dev); if (rc < 0) goto err_request_irq; return 0; err_request_irq: platform_set_drvdata(pdev, NULL); rc_unregister_device(rcdev); rcdev = NULL; err_register_rc_device: err_gpio_direction_input: gpio_free(pdata->gpio_nr); err_gpio_request: rc_free_device(rcdev); err_allocate_device: kfree(gpio_dev); return rc; }
static int __devinit gpio_ir_recv_probe(struct platform_device *pdev) { struct gpio_rc_dev *gpio_dev; struct rc_dev *rcdev; const struct gpio_ir_recv_platform_data *pdata = pdev->dev.platform_data; int rc; if (!pdata) return -EINVAL; if (pdata->gpio_nr < 0) return -EINVAL; gpio_dev = kzalloc(sizeof(struct gpio_rc_dev), GFP_KERNEL); if (!gpio_dev) return -ENOMEM; rcdev = rc_allocate_device(); if (!rcdev) { rc = -ENOMEM; goto err_allocate_device; } rcdev->driver_type = RC_DRIVER_IR_RAW; rcdev->allowed_protos = RC_TYPE_ALL; rcdev->input_name = GPIO_IR_DEVICE_NAME; rcdev->input_id.bustype = BUS_HOST; rcdev->driver_name = GPIO_IR_DRIVER_NAME; rcdev->map_name = RC_MAP_SAMSUNG_NECX; gpio_dev->rcdev = rcdev; gpio_dev->gpio_nr = pdata->gpio_nr; gpio_dev->active_low = pdata->active_low; gpio_dev->can_wakeup = pdata->can_wakeup; gpio_dev->gpio_irq_latency = pdata->swfi_latency + 1; gpio_dev->pm_qos_vote = 0; rc = gpio_request(pdata->gpio_nr, "gpio-ir-recv"); if (rc < 0) goto err_gpio_request; gpio_dev->can_sleep = gpio_cansleep(pdata->gpio_nr); rc = gpio_direction_input(pdata->gpio_nr); if (rc < 0) goto err_gpio_direction_input; rc = rc_register_device(rcdev); if (rc < 0) { dev_err(&pdev->dev, "failed to register rc device\n"); goto err_register_rc_device; } platform_set_drvdata(pdev, gpio_dev); rc = request_any_context_irq(gpio_to_irq(pdata->gpio_nr), gpio_ir_recv_irq, IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING, "gpio-ir-recv-irq", gpio_dev); if (rc < 0) goto err_request_irq; if (gpio_dev->can_wakeup) { pm_qos_add_request(&gpio_dev->pm_qos_req, PM_QOS_CPU_DMA_LATENCY, PM_QOS_DEFAULT_VALUE); device_init_wakeup(&pdev->dev, pdata->can_wakeup); setup_timer(&gpio_dev->gpio_ir_timer, gpio_ir_timer, (unsigned long)gpio_dev); } return 0; err_request_irq: platform_set_drvdata(pdev, NULL); rc_unregister_device(rcdev); err_register_rc_device: err_gpio_direction_input: gpio_free(pdata->gpio_nr); err_gpio_request: rc_free_device(rcdev); rcdev = NULL; err_allocate_device: kfree(gpio_dev); return rc; }
static int st_rc_probe(struct platform_device *pdev) { int ret = -EINVAL; struct rc_dev *rdev; struct device *dev = &pdev->dev; struct resource *res; struct st_rc_device *rc_dev; struct device_node *np = pdev->dev.of_node; const char *rx_mode; rc_dev = devm_kzalloc(dev, sizeof(struct st_rc_device), GFP_KERNEL); if (!rc_dev) return -ENOMEM; rdev = rc_allocate_device(RC_DRIVER_IR_RAW); if (!rdev) return -ENOMEM; if (np && !of_property_read_string(np, "rx-mode", &rx_mode)) { if (!strcmp(rx_mode, "uhf")) { rc_dev->rxuhfmode = true; } else if (!strcmp(rx_mode, "infrared")) { rc_dev->rxuhfmode = false; } else { dev_err(dev, "Unsupported rx mode [%s]\n", rx_mode); goto err; } } else { goto err; } rc_dev->sys_clock = devm_clk_get(dev, NULL); if (IS_ERR(rc_dev->sys_clock)) { dev_err(dev, "System clock not found\n"); ret = PTR_ERR(rc_dev->sys_clock); goto err; } rc_dev->irq = platform_get_irq(pdev, 0); if (rc_dev->irq < 0) { ret = rc_dev->irq; goto err; } res = platform_get_resource(pdev, IORESOURCE_MEM, 0); rc_dev->base = devm_ioremap_resource(dev, res); if (IS_ERR(rc_dev->base)) { ret = PTR_ERR(rc_dev->base); goto err; } if (rc_dev->rxuhfmode) rc_dev->rx_base = rc_dev->base + 0x40; else rc_dev->rx_base = rc_dev->base; rc_dev->rstc = reset_control_get_optional_exclusive(dev, NULL); if (IS_ERR(rc_dev->rstc)) { ret = PTR_ERR(rc_dev->rstc); goto err; } rc_dev->dev = dev; platform_set_drvdata(pdev, rc_dev); st_rc_hardware_init(rc_dev); rdev->allowed_protocols = RC_PROTO_BIT_ALL_IR_DECODER; /* rx sampling rate is 10Mhz */ rdev->rx_resolution = 100; rdev->timeout = US_TO_NS(MAX_SYMB_TIME); rdev->priv = rc_dev; rdev->open = st_rc_open; rdev->close = st_rc_close; rdev->driver_name = IR_ST_NAME; rdev->map_name = RC_MAP_EMPTY; rdev->device_name = "ST Remote Control Receiver"; ret = rc_register_device(rdev); if (ret < 0) goto clkerr; rc_dev->rdev = rdev; if (devm_request_irq(dev, rc_dev->irq, st_rc_rx_interrupt, 0, IR_ST_NAME, rc_dev) < 0) { dev_err(dev, "IRQ %d register failed\n", rc_dev->irq); ret = -EINVAL; goto rcerr; } /* enable wake via this device */ device_init_wakeup(dev, true); dev_pm_set_wake_irq(dev, rc_dev->irq); /** * for LIRC_MODE_MODE2 or LIRC_MODE_PULSE or LIRC_MODE_RAW * lircd expects a long space first before a signal train to sync. */ st_rc_send_lirc_timeout(rdev); dev_info(dev, "setup in %s mode\n", rc_dev->rxuhfmode ? "UHF" : "IR"); return ret; rcerr: rc_unregister_device(rdev); rdev = NULL; clkerr: clk_disable_unprepare(rc_dev->sys_clock); err: rc_free_device(rdev); dev_err(dev, "Unable to register device (%d)\n", ret); return ret; }
int cec_register_adapter(struct cec_adapter *adap, struct device *parent) { int res; if (IS_ERR_OR_NULL(adap)) return 0; if (WARN_ON(!parent)) return -EINVAL; adap->owner = parent->driver->owner; adap->devnode.dev.parent = parent; #ifdef CONFIG_MEDIA_CEC_RC if (adap->capabilities & CEC_CAP_RC) { adap->rc->dev.parent = parent; res = rc_register_device(adap->rc); if (res) { pr_err("cec-%s: failed to prepare input device\n", adap->name); rc_free_device(adap->rc); adap->rc = NULL; return res; } } #endif res = cec_devnode_register(&adap->devnode, adap->owner); if (res) { #ifdef CONFIG_MEDIA_CEC_RC /* Note: rc_unregister also calls rc_free */ rc_unregister_device(adap->rc); adap->rc = NULL; #endif return res; } dev_set_drvdata(&adap->devnode.dev, adap); #ifdef CONFIG_DEBUG_FS if (!top_cec_dir) return 0; adap->cec_dir = debugfs_create_dir(dev_name(&adap->devnode.dev), top_cec_dir); if (IS_ERR_OR_NULL(adap->cec_dir)) { pr_warn("cec-%s: Failed to create debugfs dir\n", adap->name); return 0; } adap->status_file = debugfs_create_devm_seqfile(&adap->devnode.dev, "status", adap->cec_dir, cec_adap_status); if (IS_ERR_OR_NULL(adap->status_file)) { pr_warn("cec-%s: Failed to create status file\n", adap->name); debugfs_remove_recursive(adap->cec_dir); adap->cec_dir = NULL; return 0; } if (!adap->ops->error_inj_show || !adap->ops->error_inj_parse_line) return 0; adap->error_inj_file = debugfs_create_file("error-inj", 0644, adap->cec_dir, adap, &cec_error_inj_fops); if (IS_ERR_OR_NULL(adap->error_inj_file)) pr_warn("cec-%s: Failed to create error-inj file\n", adap->name); #endif return 0; }
int mantis_exit(struct mantis_pci *mantis) { rc_unregister_device(mantis->rc); rc_map_unregister(&ir_mantis_map); return 0; }
void sms_ir_exit(struct smscore_device_t *coredev) { rc_unregister_device(coredev->ir.dev); pr_debug("\n"); }
static int meson_ir_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; struct device_node *node = dev->of_node; struct resource *res; const char *map_name; struct meson_ir *ir; int ret; ir = devm_kzalloc(dev, sizeof(struct meson_ir), GFP_KERNEL); if (!ir) return -ENOMEM; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); ir->reg = devm_ioremap_resource(dev, res); if (IS_ERR(ir->reg)) { dev_err(dev, "failed to map registers\n"); return PTR_ERR(ir->reg); } ir->irq = platform_get_irq(pdev, 0); if (ir->irq < 0) { dev_err(dev, "no irq resource\n"); return ir->irq; } ir->rc = rc_allocate_device(); if (!ir->rc) { dev_err(dev, "failed to allocate rc device\n"); return -ENOMEM; } ir->rc->priv = ir; ir->rc->input_name = DRIVER_NAME; ir->rc->input_phys = DRIVER_NAME "/input0"; ir->rc->input_id.bustype = BUS_HOST; map_name = of_get_property(node, "linux,rc-map-name", NULL); ir->rc->map_name = map_name ? map_name : RC_MAP_EMPTY; ir->rc->dev.parent = dev; ir->rc->driver_type = RC_DRIVER_IR_RAW; ir->rc->allowed_protocols = RC_BIT_ALL; ir->rc->rx_resolution = US_TO_NS(MESON_TRATE); ir->rc->timeout = MS_TO_NS(200); ir->rc->driver_name = DRIVER_NAME; spin_lock_init(&ir->lock); platform_set_drvdata(pdev, ir); ret = rc_register_device(ir->rc); if (ret) { dev_err(dev, "failed to register rc device\n"); goto out_free; } ret = devm_request_irq(dev, ir->irq, meson_ir_irq, 0, "ir-meson", ir); if (ret) { dev_err(dev, "failed to request irq\n"); goto out_unreg; } /* Reset the decoder */ meson_ir_set_mask(ir, IR_DEC_REG1, REG1_RESET, REG1_RESET); meson_ir_set_mask(ir, IR_DEC_REG1, REG1_RESET, 0); /* Set general operation mode */ meson_ir_set_mask(ir, IR_DEC_REG1, REG1_MODE_MASK, REG1_MODE_GENERAL); /* Set rate */ meson_ir_set_mask(ir, IR_DEC_REG0, REG0_RATE_MASK, MESON_TRATE - 1); /* IRQ on rising and falling edges */ meson_ir_set_mask(ir, IR_DEC_REG1, REG1_IRQSEL_MASK, REG1_IRQSEL_RISE_FALL); /* Enable the decoder */ meson_ir_set_mask(ir, IR_DEC_REG1, REG1_ENABLE, REG1_ENABLE); dev_info(dev, "receiver initialized\n"); return 0; out_unreg: rc_unregister_device(ir->rc); ir->rc = NULL; out_free: rc_free_device(ir->rc); return ret; }