int ps3_free_vuart_irq(unsigned int virq) { int result; result = lv1_deconfigure_virtual_uart_irq(); if (result) { pr_debug("%s:%d: lv1_configure_virtual_uart_irq failed: %s\n", __func__, __LINE__, ps3_result(result)); return result; } irq_dispose_mapping(virq); return result; }
static int ehci_hcd_grlib_remove(struct platform_device *op) { struct usb_hcd *hcd = dev_get_drvdata(&op->dev); dev_set_drvdata(&op->dev, NULL); dev_dbg(&op->dev, "stopping GRLIB GRUSBHC EHCI USB Controller\n"); usb_remove_hcd(hcd); irq_dispose_mapping(hcd->irq); usb_put_hcd(hcd); return 0; }
void bcom_task_free(struct bcom_task *tsk) { /* Stop the task */ bcom_disable_task(tsk->tasknum); /* Clear TDT */ bcom_eng->tdt[tsk->tasknum].start = 0; bcom_eng->tdt[tsk->tasknum].stop = 0; /* Free everything */ irq_dispose_mapping(tsk->irq); bcom_sram_free(tsk->bd); kfree(tsk->cookie); kfree(tsk); }
static int fsl_ssi_remove(struct platform_device *pdev) { struct fsl_ssi_private *ssi_private = dev_get_drvdata(&pdev->dev); platform_device_unregister(ssi_private->pdev); snd_soc_unregister_dai(&pdev->dev); device_remove_file(&pdev->dev, &ssi_private->dev_attr); free_irq(ssi_private->irq, ssi_private); irq_dispose_mapping(ssi_private->irq); kfree(ssi_private); dev_set_drvdata(&pdev->dev, NULL); return 0; }
static int ohci_hcd_ppc_of_remove(struct platform_device *op) { struct usb_hcd *hcd = platform_get_drvdata(op); dev_dbg(&op->dev, "stopping PPC-OF USB Controller\n"); usb_remove_hcd(hcd); iounmap(hcd->regs); irq_dispose_mapping(hcd->irq); release_mem_region(hcd->rsrc_start, hcd->rsrc_len); usb_put_hcd(hcd); return 0; }
static int ehci_hcd_hlwd_remove(struct of_device *op) { struct usb_hcd *hcd = dev_get_drvdata(&op->dev); dev_set_drvdata(&op->dev, NULL); dev_dbg(&op->dev, "stopping " DRV_MODULE_NAME " USB Controller\n"); usb_remove_hcd(hcd); iounmap(hcd->regs); irq_dispose_mapping(hcd->irq); dma_release_declared_memory(&op->dev); usb_put_hcd(hcd); return 0; }
static void bcma_gpio_irq_domain_exit(struct bcma_drv_cc *cc) { struct gpio_chip *chip = &cc->gpio; int gpio; if (cc->core->bus->hosttype != BCMA_HOSTTYPE_SOC) return; bcma_cc_mask32(cc, BCMA_CC_IRQMASK, ~BCMA_CC_IRQ_GPIO); free_irq(bcma_core_irq(cc->core, 0), cc); for (gpio = 0; gpio < chip->ngpio; gpio++) { int irq = irq_find_mapping(cc->irq_domain, gpio); irq_dispose_mapping(irq); } irq_domain_remove(cc->irq_domain); }
static int sja1000_ofp_remove(struct platform_device *ofdev) { struct net_device *dev = platform_get_drvdata(ofdev); struct sja1000_priv *priv = netdev_priv(dev); struct device_node *np = ofdev->dev.of_node; struct resource res; unregister_sja1000dev(dev); free_sja1000dev(dev); iounmap(priv->reg_base); irq_dispose_mapping(dev->irq); of_address_to_resource(np, 0, &res); release_mem_region(res.start, resource_size(&res)); return 0; }
static int mpc85xx_l2_err_remove(struct of_device *op) { struct edac_device_ctl_info *edac_dev = dev_get_drvdata(&op->dev); struct mpc85xx_l2_pdata *pdata = edac_dev->pvt_info; debugf0("%s()\n", __func__); if (edac_op_state == EDAC_OPSTATE_INT) { out_be32(pdata->l2_vbase + MPC85XX_L2_ERRINTEN, 0); irq_dispose_mapping(pdata->irq); } out_be32(pdata->l2_vbase + MPC85XX_L2_ERRDIS, orig_l2_err_disable); edac_device_del_device(&op->dev); edac_device_free_ctl_info(edac_dev); return 0; }
static void ssb_gpio_irq_extif_domain_exit(struct ssb_bus *bus) { struct ssb_extif *extif = &bus->extif; struct gpio_chip *chip = &bus->gpio; int gpio; if (bus->bustype != SSB_BUSTYPE_SSB) return; free_irq(ssb_mips_irq(bus->extif.dev) + 2, extif); for (gpio = 0; gpio < chip->ngpio; gpio++) { int irq = irq_find_mapping(bus->irq_domain, gpio); irq_dispose_mapping(irq); } irq_domain_remove(bus->irq_domain); }
int ps3_free_event_irq(unsigned int virq) { int result; pr_debug(" -> %s:%d\n", __func__, __LINE__); result = lv1_destruct_event_receive_port(virq_to_hw(virq)); if (result) pr_debug("%s:%d: lv1_destruct_event_receive_port failed: %s\n", __func__, __LINE__, ps3_result(result)); irq_dispose_mapping(virq); pr_debug(" <- %s:%d\n", __func__, __LINE__); return result; }
static int __devinit mbref_uio_of_probe(struct of_device *op, const struct of_device_id *match) { struct uio_info *uioinfo; struct resource resources[MAX_UIO_MAPS]; int i, ret; uioinfo = kzalloc(sizeof(*uioinfo), GFP_KERNEL); if (!uioinfo) { pr_err("%s: %s: unable to kmalloc uioinfo\n", DRIVER_NAME, op->node->full_name); return -ENOMEM; } uioinfo->name = DRIVER_NAME; /* alternetive: op->node->name */ uioinfo->version = DRIVER_VERS; uioinfo->irq = irq_of_parse_and_map(op->node, 0); if (!uioinfo->irq) uioinfo->irq = UIO_IRQ_NONE; else pr_info("%s: %s: IRQ%li\n", uioinfo->name, op->node->full_name, uioinfo->irq); for (i = 0; i < MAX_UIO_MAPS; ++i) if (of_address_to_resource(op->node, i, &resources[i])) break; else pr_info("%s: %s: 0x%08X-0x%08X\n", uioinfo->name, op->node->full_name, resources[i].start, resources[i].end); ret = __mbref_uio_pdrv_probe(&op->dev, uioinfo, resources, i); if (ret) goto err_cleanup; pr_info("%s: %s: registered\n", uioinfo->name, op->node->full_name); return 0; err_cleanup: if (uioinfo->irq != UIO_IRQ_NONE) irq_dispose_mapping(uioinfo->irq); kfree(uioinfo); return ret; }
static int uhci_hcd_grlib_remove(struct platform_device *op) { struct usb_hcd *hcd = dev_get_drvdata(&op->dev); dev_set_drvdata(&op->dev, NULL); dev_dbg(&op->dev, "stopping GRLIB GRUSBHC UHCI USB Controller\n"); usb_remove_hcd(hcd); iounmap(hcd->regs); irq_dispose_mapping(hcd->irq); release_mem_region(hcd->rsrc_start, hcd->rsrc_len); usb_put_hcd(hcd); return 0; }
static void ssb_gpio_irq_chipco_domain_exit(struct ssb_bus *bus) { struct ssb_chipcommon *chipco = &bus->chipco; struct gpio_chip *chip = &bus->gpio; int gpio; if (bus->bustype != SSB_BUSTYPE_SSB) return; chipco_mask32(chipco, SSB_CHIPCO_IRQMASK, ~SSB_CHIPCO_IRQ_GPIO); free_irq(ssb_mips_irq(bus->chipco.dev) + 2, chipco); for (gpio = 0; gpio < chip->ngpio; gpio++) { int irq = irq_find_mapping(bus->irq_domain, gpio); irq_dispose_mapping(irq); } irq_domain_remove(bus->irq_domain); }
int ps3_free_irq(unsigned int virq) { int result; const struct ps3_private *pd = get_irq_chip_data(virq); pr_debug("%s:%d: node %lu, cpu %d, virq %u\n", __func__, __LINE__, pd->node, pd->cpu, virq); result = lv1_disconnect_irq_plug_ext(pd->node, pd->cpu, virq); if (result) pr_info("%s:%d: lv1_disconnect_irq_plug_ext failed: %s\n", __func__, __LINE__, ps3_result(result)); set_irq_chip_data(virq, NULL); irq_dispose_mapping(virq); return result; }
static int ssb_gpio_irq_chipco_domain_init(struct ssb_bus *bus) { struct ssb_chipcommon *chipco = &bus->chipco; struct gpio_chip *chip = &bus->gpio; int gpio, hwirq, err; if (bus->bustype != SSB_BUSTYPE_SSB) return 0; bus->irq_domain = irq_domain_add_linear(NULL, chip->ngpio, &irq_domain_simple_ops, chipco); if (!bus->irq_domain) { err = -ENODEV; goto err_irq_domain; } for (gpio = 0; gpio < chip->ngpio; gpio++) { int irq = irq_create_mapping(bus->irq_domain, gpio); irq_set_chip_data(irq, bus); irq_set_chip_and_handler(irq, &ssb_gpio_irq_chipco_chip, handle_simple_irq); } hwirq = ssb_mips_irq(bus->chipco.dev) + 2; err = request_irq(hwirq, ssb_gpio_irq_chipco_handler, IRQF_SHARED, "gpio", bus); if (err) goto err_req_irq; ssb_chipco_gpio_intmask(&bus->chipco, ~0, 0); chipco_set32(chipco, SSB_CHIPCO_IRQMASK, SSB_CHIPCO_IRQ_GPIO); return 0; err_req_irq: for (gpio = 0; gpio < chip->ngpio; gpio++) { int irq = irq_find_mapping(bus->irq_domain, gpio); irq_dispose_mapping(irq); } irq_domain_remove(bus->irq_domain); err_irq_domain: return err; }
/* * Try to register a serial port */ static int __devinit of_platform_serial_probe(struct of_device *ofdev, const struct of_device_id *id) { struct of_serial_info *info; struct uart_port port; int port_type; int ret; if (of_find_property(ofdev->node, "used-by-rtas", NULL)) return -EBUSY; info = kmalloc(sizeof(*info), GFP_KERNEL); if (info == NULL) return -ENOMEM; port_type = (unsigned long)id->data; ret = of_platform_serial_setup(ofdev, port_type, &port); if (ret) goto out; switch (port_type) { case PORT_8250 ... PORT_MAX_8250: ret = serial8250_register_port(&port); break; default: /* need to add code for these */ case PORT_UNKNOWN: dev_info(&ofdev->dev, "Unknown serial port found, ignored\n"); ret = -ENODEV; break; } if (ret < 0) goto out; info->type = port_type; info->line = ret; ofdev->dev.driver_data = info; return 0; out: kfree(info); irq_dispose_mapping(port.irq); return ret; }
static int bcma_gpio_irq_domain_init(struct bcma_drv_cc *cc) { struct gpio_chip *chip = &cc->gpio; int gpio, hwirq, err; if (cc->core->bus->hosttype != BCMA_HOSTTYPE_SOC) return 0; cc->irq_domain = irq_domain_add_linear(NULL, chip->ngpio, &irq_domain_simple_ops, cc); if (!cc->irq_domain) { err = -ENODEV; goto err_irq_domain; } for (gpio = 0; gpio < chip->ngpio; gpio++) { int irq = irq_create_mapping(cc->irq_domain, gpio); irq_set_chip_data(irq, cc); irq_set_chip_and_handler(irq, &bcma_gpio_irq_chip, handle_simple_irq); } hwirq = bcma_core_irq(cc->core, 0); err = request_irq(hwirq, bcma_gpio_irq_handler, IRQF_SHARED, "gpio", cc); if (err) goto err_req_irq; bcma_chipco_gpio_intmask(cc, ~0, 0); bcma_cc_set32(cc, BCMA_CC_IRQMASK, BCMA_CC_IRQ_GPIO); return 0; err_req_irq: for (gpio = 0; gpio < chip->ngpio; gpio++) { int irq = irq_find_mapping(cc->irq_domain, gpio); irq_dispose_mapping(irq); } irq_domain_remove(cc->irq_domain); err_irq_domain: return err; }
static int ps3_virq_setup(enum ps3_cpu_binding cpu, unsigned long outlet, unsigned int *virq) { int result; struct ps3_private *pd; /* This defines the default interrupt distribution policy. */ if (cpu == PS3_BINDING_CPU_ANY) cpu = 0; pd = &per_cpu(ps3_private, cpu); *virq = irq_create_mapping(NULL, outlet); if (*virq == NO_IRQ) { pr_debug("%s:%d: irq_create_mapping failed: outlet %lu\n", __func__, __LINE__, outlet); result = -ENOMEM; goto fail_create; } pr_debug("%s:%d: outlet %lu => cpu %u, virq %u\n", __func__, __LINE__, outlet, cpu, *virq); result = irq_set_chip_data(*virq, pd); if (result) { pr_debug("%s:%d: irq_set_chip_data failed\n", __func__, __LINE__); goto fail_set; } ps3_chip_mask(irq_get_irq_data(*virq)); return result; fail_set: irq_dispose_mapping(*virq); fail_create: return result; }
static int mpc52xx_fec_mdio_remove(struct of_device *of) { struct device *dev = &of->dev; struct mii_bus *bus = dev_get_drvdata(dev); struct mpc52xx_fec_mdio_priv *priv = bus->priv; int i; mdiobus_unregister(bus); dev_set_drvdata(dev, NULL); iounmap(priv->regs); for (i=0; i<PHY_MAX_ADDR; i++) if (bus->irq[i] != PHY_POLL) irq_dispose_mapping(bus->irq[i]); kfree(priv); kfree(bus->irq); mdiobus_free(bus); return 0; }
static int mpc85xx_mc_err_remove(struct of_device *op) { struct mem_ctl_info *mci = dev_get_drvdata(&op->dev); struct mpc85xx_mc_pdata *pdata = mci->pvt_info; debugf0("%s()\n", __func__); if (edac_op_state == EDAC_OPSTATE_INT) { out_be32(pdata->mc_vbase + MPC85XX_MC_ERR_INT_EN, 0); irq_dispose_mapping(pdata->irq); } out_be32(pdata->mc_vbase + MPC85XX_MC_ERR_DISABLE, orig_ddr_err_disable); out_be32(pdata->mc_vbase + MPC85XX_MC_ERR_SBE, orig_ddr_err_sbe); edac_mc_del_mc(&op->dev); edac_mc_free(mci); return 0; }
static int ehci_hcd_ppc_of_remove(struct of_device *op) { struct usb_hcd *hcd = dev_get_drvdata(&op->dev); struct ehci_hcd *ehci = hcd_to_ehci(hcd); struct device_node *np; struct resource res; dev_set_drvdata(&op->dev, NULL); dev_dbg(&op->dev, "stopping PPC-OF USB Controller\n"); usb_remove_hcd(hcd); iounmap(hcd->regs); irq_dispose_mapping(hcd->irq); release_mem_region(hcd->rsrc_start, hcd->rsrc_len); /* use request_mem_region to test if the ohci driver is loaded. if so * ensure the ohci core is operational. */ if (ehci->has_amcc_usb23) { np = of_find_compatible_node(NULL, NULL, "ibm,usb-ohci-440epx"); if (np != NULL) { if (!of_address_to_resource(np, 0, &res)) if (!request_mem_region(res.start, 0x4, hcd_name)) set_ohci_hcfs(ehci, 1); else release_mem_region(res.start, 0x4); else pr_debug(__FILE__ ": no ohci offset in fdt\n"); of_node_put(np); } iounmap(ehci->ohci_hcctrl_reg); } usb_put_hcd(hcd); return 0; }
void kvmppc_xive_native_cleanup_vcpu(struct kvm_vcpu *vcpu) { struct kvmppc_xive_vcpu *xc = vcpu->arch.xive_vcpu; int i; if (!kvmppc_xive_enabled(vcpu)) return; if (!xc) return; pr_devel("native_cleanup_vcpu(cpu=%d)\n", xc->server_num); /* Ensure no interrupt is still routed to that VP */ xc->valid = false; kvmppc_xive_disable_vcpu_interrupts(vcpu); /* Disable the VP */ xive_native_disable_vp(xc->vp_id); /* Free the queues & associated interrupts */ for (i = 0; i < KVMPPC_XIVE_Q_COUNT; i++) { /* Free the escalation irq */ if (xc->esc_virq[i]) { free_irq(xc->esc_virq[i], vcpu); irq_dispose_mapping(xc->esc_virq[i]); kfree(xc->esc_virq_names[i]); xc->esc_virq[i] = 0; } /* Free the queue */ kvmppc_xive_native_cleanup_queue(vcpu, i); } /* Free the VP */ kfree(xc); /* Cleanup the vcpu */ vcpu->arch.irq_type = KVMPPC_IRQ_DEFAULT; vcpu->arch.xive_vcpu = NULL; }
static int mpc85xx_pci_err_remove(struct of_device *op) { struct edac_pci_ctl_info *pci = dev_get_drvdata(&op->dev); struct mpc85xx_pci_pdata *pdata = pci->pvt_info; debugf0("%s()\n", __func__); out_be32(pdata->pci_vbase + MPC85XX_PCI_ERR_CAP_DR, orig_pci_err_cap_dr); out_be32(pdata->pci_vbase + MPC85XX_PCI_ERR_EN, orig_pci_err_en); edac_pci_del_device(pci->dev); if (edac_op_state == EDAC_OPSTATE_INT) irq_dispose_mapping(pdata->irq); edac_pci_free_ctl_info(pci); return 0; }
static void __init opal_irq_init(struct device_node *dn) { const __be32 *irqs; int i, irqlen; /* Get interrupt property */ irqs = of_get_property(opal_node, "opal-interrupts", &irqlen); pr_debug("Found %d interrupts reserved for OPAL\n", irqs ? (irqlen / 4) : 0); /* Install interrupt handlers */ opal_irq_count = irqlen / 4; opal_irqs = kzalloc(opal_irq_count * sizeof(unsigned int), GFP_KERNEL); for (i = 0; irqs && i < opal_irq_count; i++, irqs++) { unsigned int irq, virq; int rc; /* Get hardware and virtual IRQ */ irq = be32_to_cpup(irqs); virq = irq_create_mapping(NULL, irq); if (virq == NO_IRQ) { pr_warn("Failed to map irq 0x%x\n", irq); continue; } /* Install interrupt handler */ rc = request_irq(virq, opal_interrupt, 0, "opal", NULL); if (rc) { irq_dispose_mapping(virq); pr_warn("Error %d requesting irq %d (0x%x)\n", rc, virq, irq); continue; } /* Cache IRQ */ opal_irqs[i] = virq; } }
static int __devinit sja1000_ofp_probe(struct of_device *ofdev, const struct of_device_id *id) { struct device_node *np = ofdev->node; struct net_device *dev; struct sja1000_priv *priv; struct resource res; const u32 *prop; int err, irq, res_size, prop_size; void __iomem *base; err = of_address_to_resource(np, 0, &res); if (err) { dev_err(&ofdev->dev, "invalid address\n"); return err; } res_size = resource_size(&res); if (!request_mem_region(res.start, res_size, DRV_NAME)) { dev_err(&ofdev->dev, "couldn't request %#llx..%#llx\n", (unsigned long long)res.start, (unsigned long long)res.end); return -EBUSY; } base = ioremap_nocache(res.start, res_size); if (!base) { dev_err(&ofdev->dev, "couldn't ioremap %#llx..%#llx\n", (unsigned long long)res.start, (unsigned long long)res.end); err = -ENOMEM; goto exit_release_mem; } irq = irq_of_parse_and_map(np, 0); if (irq == NO_IRQ) { dev_err(&ofdev->dev, "no irq found\n"); err = -ENODEV; goto exit_unmap_mem; } dev = alloc_sja1000dev(0); if (!dev) { err = -ENOMEM; goto exit_dispose_irq; } priv = netdev_priv(dev); priv->read_reg = sja1000_ofp_read_reg; priv->write_reg = sja1000_ofp_write_reg; prop = of_get_property(np, "nxp,external-clock-frequency", &prop_size); if (prop && (prop_size == sizeof(u32))) priv->can.clock.freq = *prop / 2; else priv->can.clock.freq = SJA1000_OFP_CAN_CLOCK; /* default */ prop = of_get_property(np, "nxp,tx-output-mode", &prop_size); if (prop && (prop_size == sizeof(u32))) priv->ocr |= *prop & OCR_MODE_MASK; else priv->ocr |= OCR_MODE_NORMAL; /* default */ prop = of_get_property(np, "nxp,tx-output-config", &prop_size); if (prop && (prop_size == sizeof(u32))) priv->ocr |= (*prop << OCR_TX_SHIFT) & OCR_TX_MASK; else priv->ocr |= OCR_TX0_PULLDOWN; /* default */ prop = of_get_property(np, "nxp,clock-out-frequency", &prop_size); if (prop && (prop_size == sizeof(u32)) && *prop) { u32 divider = priv->can.clock.freq * 2 / *prop; if (divider > 1) priv->cdr |= divider / 2 - 1; else priv->cdr |= CDR_CLKOUT_MASK; } else { priv->cdr |= CDR_CLK_OFF; /* default */ } prop = of_get_property(np, "nxp,no-comparator-bypass", NULL); if (!prop) priv->cdr |= CDR_CBP; /* default */ priv->irq_flags = IRQF_SHARED; priv->reg_base = base; dev->irq = irq; dev_info(&ofdev->dev, "reg_base=0x%p irq=%d clock=%d ocr=0x%02x cdr=0x%02x\n", priv->reg_base, dev->irq, priv->can.clock.freq, priv->ocr, priv->cdr); dev_set_drvdata(&ofdev->dev, dev); SET_NETDEV_DEV(dev, &ofdev->dev); err = register_sja1000dev(dev); if (err) { dev_err(&ofdev->dev, "registering %s failed (err=%d)\n", DRV_NAME, err); goto exit_free_sja1000; } return 0; exit_free_sja1000: free_sja1000dev(dev); exit_dispose_irq: irq_dispose_mapping(irq); exit_unmap_mem: iounmap(base); exit_release_mem: release_mem_region(res.start, res_size); return err; }
static int __devinit fsl_ssi_probe(struct platform_device *pdev, const struct of_device_id *match) { struct fsl_ssi_private *ssi_private; int ret = 0; struct device_attribute *dev_attr = NULL; struct device_node *np = pdev->dev.of_node; const char *p, *sprop; const uint32_t *iprop; struct resource res; char name[64]; /* SSIs that are not connected on the board should have a * status = "disabled" * property in their device tree nodes. */ if (!of_device_is_available(np)) return -ENODEV; /* Check for a codec-handle property. */ if (!of_get_property(np, "codec-handle", NULL)) { dev_err(&pdev->dev, "missing codec-handle property\n"); return -ENODEV; } /* We only support the SSI in "I2S Slave" mode */ sprop = of_get_property(np, "fsl,mode", NULL); if (!sprop || strcmp(sprop, "i2s-slave")) { dev_notice(&pdev->dev, "mode %s is unsupported\n", sprop); return -ENODEV; } /* The DAI name is the last part of the full name of the node. */ p = strrchr(np->full_name, '/') + 1; ssi_private = kzalloc(sizeof(struct fsl_ssi_private) + strlen(p), GFP_KERNEL); if (!ssi_private) { dev_err(&pdev->dev, "could not allocate DAI object\n"); return -ENOMEM; } strcpy(ssi_private->name, p); /* Initialize this copy of the CPU DAI driver structure */ memcpy(&ssi_private->cpu_dai_drv, &fsl_ssi_dai_template, sizeof(fsl_ssi_dai_template)); ssi_private->cpu_dai_drv.name = ssi_private->name; /* Get the addresses and IRQ */ ret = of_address_to_resource(np, 0, &res); if (ret) { dev_err(&pdev->dev, "could not determine device resources\n"); kfree(ssi_private); return ret; } ssi_private->ssi = ioremap(res.start, 1 + res.end - res.start); ssi_private->ssi_phys = res.start; ssi_private->irq = irq_of_parse_and_map(np, 0); /* Are the RX and the TX clocks locked? */ if (of_find_property(np, "fsl,ssi-asynchronous", NULL)) ssi_private->asynchronous = 1; else ssi_private->cpu_dai_drv.symmetric_rates = 1; /* Determine the FIFO depth. */ iprop = of_get_property(np, "fsl,fifo-depth", NULL); if (iprop) ssi_private->fifo_depth = *iprop; else /* Older 8610 DTs didn't have the fifo-depth property */ ssi_private->fifo_depth = 8; /* Initialize the the device_attribute structure */ dev_attr = &ssi_private->dev_attr; dev_attr->attr.name = "statistics"; dev_attr->attr.mode = S_IRUGO; dev_attr->show = fsl_sysfs_ssi_show; ret = device_create_file(&pdev->dev, dev_attr); if (ret) { dev_err(&pdev->dev, "could not create sysfs %s file\n", ssi_private->dev_attr.attr.name); goto error; } /* Register with ASoC */ dev_set_drvdata(&pdev->dev, ssi_private); ret = snd_soc_register_dai(&pdev->dev, &ssi_private->cpu_dai_drv); if (ret) { dev_err(&pdev->dev, "failed to register DAI: %d\n", ret); goto error; } /* Trigger the machine driver's probe function. The platform driver * name of the machine driver is taken from the /model property of the * device tree. We also pass the address of the CPU DAI driver * structure. */ sprop = of_get_property(of_find_node_by_path("/"), "model", NULL); /* Sometimes the model name has a "fsl," prefix, so we strip that. */ p = strrchr(sprop, ','); if (p) sprop = p + 1; snprintf(name, sizeof(name), "snd-soc-%s", sprop); make_lowercase(name); ssi_private->pdev = platform_device_register_data(&pdev->dev, name, 0, NULL, 0); if (IS_ERR(ssi_private->pdev)) { ret = PTR_ERR(ssi_private->pdev); dev_err(&pdev->dev, "failed to register platform: %d\n", ret); goto error; } return 0; error: snd_soc_unregister_dai(&pdev->dev); dev_set_drvdata(&pdev->dev, NULL); if (dev_attr) device_remove_file(&pdev->dev, dev_attr); irq_dispose_mapping(ssi_private->irq); iounmap(ssi_private->ssi); kfree(ssi_private); return ret; }
static int __devinit tdm_fsl_starlite_probe(struct of_device *ofdev, const struct of_device_id *match) { int ret = 0; struct tdm_priv *priv; struct resource res; priv = kmalloc(sizeof(struct tdm_priv), GFP_KERNEL); if (!priv) { ret = -ENOMEM; goto err_alloc; } dev_set_drvdata(&ofdev->dev, priv); priv->device = &ofdev->dev; ret = of_address_to_resource(ofdev->node, 0, &res); if (ret) { ret = -EINVAL; goto err_resource; } priv->ptdm_base = res.start; priv->tdm_regs = of_iomap(ofdev->node, 0); if (!priv->tdm_regs) { ret = -ENOMEM; goto err_tdmregs; } priv->dmac_regs = of_iomap(ofdev->node, 1); if (!priv->dmac_regs) { ret = -ENOMEM; goto err_dmacreg; } /* tdmrd tmdtd at immrbar+0x16100 */ priv->data_regs = (struct tdm_data *)(TDM_DATAREG_OFFSET + (u8 *)priv->tdm_regs); /* TDMCLK_DIV_VAL_RX/TX at TDMBASE+0x180 */ priv->clk_regs = (struct tdm_clock *)(TDM_CLKREG_OFFSET + (u8 *)priv->tdm_regs); /* irqs mapping for tdm err/dmac err, dmac done */ priv->tdm_err_intr = irq_of_parse_and_map(ofdev->node, 0); if (priv->tdm_err_intr == NO_IRQ) { ret = -EINVAL; goto err_tdmerr_irqmap; } priv->dmac_done_intr = irq_of_parse_and_map(ofdev->node, 1); if (priv->dmac_done_intr == NO_IRQ) { ret = -EINVAL; goto err_dmacdone_irqmap; } ret = request_irq(priv->tdm_err_intr, tdm_err_isr, 0, "tdm_err_isr", priv); if (ret) goto err_tdmerrisr; ret = request_irq(priv->dmac_done_intr, dmac_done_isr, 0, "dmac_done_isr", priv); if (ret) goto err_dmacdoneisr; priv->cfg.loopback = e_TDM_PROCESS_NORMAL; priv->cfg.num_ch = TDM_ACTIVE_CHANNELS; priv->cfg.ch_type = TDM_CHANNEL_TYPE; priv->cfg.ch_width = TDM_SLOT_WIDTH; priv->cfg.num_frames = NUM_OF_FRAMES; priv->adap = &tdm_fsl_starlite_ops; /* Wait q initilization */ priv->adap->tdm_rx_flag = 0; /* todo - these should be configured by dts or init time */ priv->adap->adap_mode = e_TDM_ADAPTER_MODE_NONE; priv->adap->tdm_mode = priv->cfg.loopback; priv->adap->max_num_ports = priv->cfg.num_ch; tdm_set_adapdata(priv->adap, priv); priv->adap->parent = &ofdev->dev; ret = 0; ret = tdm_add_adapter(priv->adap); if (ret < 0) { dev_err(priv->device, "failed to add adapter\n"); goto fail_adapter; } ret = init_tdm(priv); if (ret) goto err_tdminit; ret = tdm_fsl_starlite_reg_init(priv); if (ret) goto err_tdminit; spin_lock_init(&priv->tdmlock); spin_lock(&priv->tdmlock); priv->tdm_active = 0; spin_unlock(&priv->tdmlock); if (tdmen) { ret = tdm_fsl_starlite_enable(priv->adap); if (!ret) goto err_tdminit; } return 0; err_tdminit: fail_adapter: free_irq(priv->dmac_done_intr, priv); err_dmacdoneisr: free_irq(priv->tdm_err_intr, priv); err_tdmerrisr: irq_dispose_mapping(priv->dmac_done_intr); err_dmacdone_irqmap: irq_dispose_mapping(priv->tdm_err_intr); err_tdmerr_irqmap: iounmap(priv->dmac_regs); err_dmacreg: iounmap(priv->tdm_regs); err_tdmregs: err_resource: dev_set_drvdata(&ofdev->dev, NULL); kfree(priv); err_alloc: return ret; }
static int tdm_fsl_probe(struct platform_device *ofdev) { int ret = 0; struct tdm_priv *priv; struct resource res; priv = kzalloc(sizeof(struct tdm_priv), GFP_KERNEL); if (!priv) { ret = -ENOMEM; goto err_alloc; } dev_set_drvdata(&ofdev->dev, priv); priv->device = &ofdev->dev; ret = of_address_to_resource(ofdev->dev.of_node, 0, &res); if (ret) { ret = -EINVAL; goto err_resource; } priv->ptdm_base = (u32)res.start; priv->tdm_regs = of_iomap(ofdev->dev.of_node, 0); if (!priv->tdm_regs) { ret = -ENOMEM; goto err_tdmregs; } priv->dmac_regs = of_iomap(ofdev->dev.of_node, 1); if (!priv->dmac_regs) { ret = -ENOMEM; goto err_dmacreg; } /* tdmrd tmdtd at immrbar+0x16100 */ priv->data_regs = (struct tdm_data *)(TDM_DATAREG_OFFSET + (u8 *)priv->tdm_regs); /* TDMCLK_DIV_VAL_RX/TX at TDMBASE+0x180 */ priv->clk_regs = (struct tdm_clock *)(TDM_CLKREG_OFFSET + (u8 *)priv->tdm_regs); priv->dmac_done_intr = irq_of_parse_and_map(ofdev->dev.of_node, 0); if (priv->dmac_done_intr == NO_IRQ) { ret = -EINVAL; goto err_dmacdone_irqmap; } ret = request_irq(priv->dmac_done_intr, dmac_done_isr, 0, "dmac_done_isr", priv); if (ret) goto err_dmacdoneisr; priv->adap = &tdm_fsl_ops; /* Wait q initilization */ priv->adap->tdm_rx_flag = 0; /* todo - these should be configured by dts or init time */ tdm_set_adapdata(priv->adap, priv); priv->adap->parent = &ofdev->dev; ret = tdm_add_adapter(priv->adap); if (ret < 0) { dev_err(priv->device, "failed to add adapter\n"); goto fail_adapter; } ret = init_tdm(priv); if (ret) goto err_tdminit; ret = tdm_fsl_reg_init(priv); if (ret) goto err_tdminit; spin_lock_init(&priv->tdmlock); spin_lock(&priv->tdmlock); priv->tdm_active = 0; spin_unlock(&priv->tdmlock); if (tdmen) { ret = tdm_fsl_enable(priv->adap); if (!ret) goto err_tdminit; } return 0; err_tdminit: fail_adapter: free_irq(priv->dmac_done_intr, priv); err_dmacdoneisr: free_irq(priv->tdm_err_intr, priv); err_dmacdone_irqmap: irq_dispose_mapping(priv->dmac_done_intr); err_dmacreg: iounmap(priv->dmac_regs); err_tdmregs: err_resource: dev_set_drvdata(&ofdev->dev, NULL); kfree(priv); err_alloc: return ret; }
/* * Init JobR independent of platform property detection */ static int caam_jr_init(struct device *dev) { struct caam_drv_private_jr *jrp; dma_addr_t inpbusaddr, outbusaddr; int i, error; jrp = dev_get_drvdata(dev); /* Connect job ring interrupt handler. */ for_each_possible_cpu(i) tasklet_init(&jrp->irqtask[i], caam_jr_dequeue, (unsigned long)dev); error = request_irq(jrp->irq, caam_jr_interrupt, IRQF_SHARED, "caam-jr", dev); if (error) { dev_err(dev, "can't connect JobR %d interrupt (%d)\n", jrp->ridx, jrp->irq); irq_dispose_mapping(jrp->irq); jrp->irq = 0; return -EINVAL; } error = caam_reset_hw_jr(dev); if (error) return error; jrp->inpring = kzalloc(sizeof(dma_addr_t) * JOBR_DEPTH, GFP_KERNEL | GFP_DMA); jrp->outring = kzalloc(sizeof(struct jr_outentry) * JOBR_DEPTH, GFP_KERNEL | GFP_DMA); jrp->entinfo = kzalloc(sizeof(struct caam_jrentry_info) * JOBR_DEPTH, GFP_KERNEL); if ((jrp->inpring == NULL) || (jrp->outring == NULL) || (jrp->entinfo == NULL)) { dev_err(dev, "can't allocate job rings for %d\n", jrp->ridx); return -ENOMEM; } for (i = 0; i < JOBR_DEPTH; i++) jrp->entinfo[i].desc_addr_dma = !0; /* Setup rings */ inpbusaddr = dma_map_single(dev, jrp->inpring, sizeof(u32 *) * JOBR_DEPTH, DMA_TO_DEVICE); if (dma_mapping_error(dev, inpbusaddr)) { dev_err(dev, "caam_jr_init(): can't map input ring\n"); kfree(jrp->inpring); kfree(jrp->outring); kfree(jrp->entinfo); return -EIO; } outbusaddr = dma_map_single(dev, jrp->outring, sizeof(struct jr_outentry) * JOBR_DEPTH, DMA_FROM_DEVICE); if (dma_mapping_error(dev, outbusaddr)) { dev_err(dev, "caam_jr_init(): can't map output ring\n"); dma_unmap_single(dev, inpbusaddr, sizeof(u32 *) * JOBR_DEPTH, DMA_TO_DEVICE); kfree(jrp->inpring); kfree(jrp->outring); kfree(jrp->entinfo); return -EIO; } jrp->inp_ring_write_index = 0; jrp->out_ring_read_index = 0; jrp->head = 0; jrp->tail = 0; wr_reg64(&jrp->rregs->inpring_base, inpbusaddr); wr_reg64(&jrp->rregs->outring_base, outbusaddr); wr_reg32(&jrp->rregs->inpring_size, JOBR_DEPTH); wr_reg32(&jrp->rregs->outring_size, JOBR_DEPTH); jrp->ringsize = JOBR_DEPTH; spin_lock_init(&jrp->inplock); spin_lock_init(&jrp->outlock); /* Select interrupt coalescing parameters */ setbits32(&jrp->rregs->rconfig_lo, JOBR_INTC | (JOBR_INTC_COUNT_THLD << JRCFG_ICDCT_SHIFT) | (JOBR_INTC_TIME_THLD << JRCFG_ICTT_SHIFT)); jrp->assign = JOBR_UNASSIGNED; return 0; }