static int mdio_gpio_probe(struct platform_device *pdev) { struct mdio_gpio_platform_data *pdata; struct mii_bus *new_bus; int ret, bus_id; if (pdev->dev.of_node) { pdata = mdio_gpio_of_get_data(pdev); bus_id = of_alias_get_id(pdev->dev.of_node, "mdio-gpio"); if (bus_id < 0) { dev_warn(&pdev->dev, "failed to get alias id\n"); bus_id = 0; } } else { pdata = dev_get_platdata(&pdev->dev); bus_id = pdev->id; } if (!pdata) return -ENODEV; new_bus = mdio_gpio_bus_init(&pdev->dev, pdata, bus_id); if (!new_bus) return -ENODEV; if (pdev->dev.of_node) ret = of_mdiobus_register(new_bus, pdev->dev.of_node); else ret = mdiobus_register(new_bus); if (ret) mdio_gpio_bus_deinit(&pdev->dev); return ret; }
static int am335x_phy_probe(struct platform_device *pdev) { struct am335x_phy *am_phy; struct device *dev = &pdev->dev; int ret; am_phy = devm_kzalloc(dev, sizeof(*am_phy), GFP_KERNEL); if (!am_phy) return -ENOMEM; am_phy->phy_ctrl = am335x_get_phy_control(dev); if (!am_phy->phy_ctrl) return -EPROBE_DEFER; am_phy->id = of_alias_get_id(pdev->dev.of_node, "phy"); if (am_phy->id < 0) { dev_err(&pdev->dev, "Missing PHY id: %d\n", am_phy->id); return am_phy->id; } ret = usb_phy_gen_create_phy(dev, &am_phy->usb_phy_gen, NULL); if (ret) return ret; ret = usb_add_phy_dev(&am_phy->usb_phy_gen.phy); if (ret) return ret; am_phy->usb_phy_gen.phy.init = am335x_init; am_phy->usb_phy_gen.phy.shutdown = am335x_shutdown; platform_set_drvdata(pdev, am_phy); return 0; }
static int serial_pxa_probe_dt(struct platform_device *pdev, struct uart_pxa_port *sport) { struct device_node *np = pdev->dev.of_node; int ret; if (!np) return 1; /* device tree is used */ if (uart_dma) sport->dma_enable = 1; ret = of_alias_get_id(np, "serial"); if (ret < 0) { dev_err(&pdev->dev, "failed to get alias id, errno %d\n", ret); return ret; } sport->port.line = ret; if (of_property_read_u32(np, "lpm-qos", &sport->lpm_qos)) { dev_err(&pdev->dev, "cannot find lpm-qos in device tree\n"); return -EINVAL; } if (of_property_read_u32(np, "edge-wakeup-gpio", &sport->edge_wakeup_gpio)) dev_info(&pdev->dev, "no edge-wakeup-gpio defined\n"); return 0; }
static int tegra_uart_parse_dt(struct platform_device *pdev, struct tegra_uart_port *tup) { struct device_node *np = pdev->dev.of_node; u32 of_dma[2]; int port; if (of_property_read_u32_array(np, "nvidia,dma-request-selector", of_dma, 2) >= 0) { tup->dma_req_sel = of_dma[1]; } else { dev_err(&pdev->dev, "missing dma requestor in device tree\n"); return -EINVAL; } port = of_alias_get_id(np, "serial"); if (port < 0) { dev_err(&pdev->dev, "failed to get alias id, errno %d\n", port); return port; } tup->uport.line = port; tup->enable_modem_interrupt = of_property_read_bool(np, "nvidia,enable-modem-interrupt"); return 0; }
static int mdio_gpio_probe(struct platform_device *pdev) { struct mdio_gpio_info *bitbang; struct mii_bus *new_bus; int ret, bus_id; bitbang = devm_kzalloc(&pdev->dev, sizeof(*bitbang), GFP_KERNEL); if (!bitbang) return -ENOMEM; ret = mdio_gpio_get_data(&pdev->dev, bitbang); if (ret) return ret; if (pdev->dev.of_node) { bus_id = of_alias_get_id(pdev->dev.of_node, "mdio-gpio"); if (bus_id < 0) { dev_warn(&pdev->dev, "failed to get alias id\n"); bus_id = 0; } } else { bus_id = pdev->id; } new_bus = mdio_gpio_bus_init(&pdev->dev, bitbang, bus_id); if (!new_bus) return -ENODEV; ret = of_mdiobus_register(new_bus, pdev->dev.of_node); if (ret) mdio_gpio_bus_deinit(&pdev->dev); return ret; }
static int tegra_uart_parse_dt(struct platform_device *pdev, struct tegra_uart_port *tup) { struct device_node *np = pdev->dev.of_node; int port; int index; port = of_alias_get_id(np, "serial"); if (port < 0) { dev_err(&pdev->dev, "failed to get alias id, errno %d\n", port); return port; } tup->uport.line = port; tup->enable_modem_interrupt = of_property_read_bool(np, "nvidia,enable-modem-interrupt"); index = of_property_match_string(np, "dma-names", "rx"); if (index < 0) { tup->use_rx_pio = true; dev_info(&pdev->dev, "RX in PIO mode\n"); } tup->enable_rx_buffer_throttle = of_property_read_bool(np, "nvidia,enable-rx-buffer-throttling"); if (tup->enable_rx_buffer_throttle) dev_info(&pdev->dev, "Rx buffer throttling enabled\n"); return 0; }
static int clps711x_gpio_probe(struct platform_device *pdev) { struct device_node *np = pdev->dev.of_node; void __iomem *dat, *dir; struct gpio_chip *gc; struct resource *res; int err, id; if (!np) return -ENODEV; id = of_alias_get_id(np, "gpio"); if ((id < 0) || (id > 4)) return -ENODEV; gc = devm_kzalloc(&pdev->dev, sizeof(*gc), GFP_KERNEL); if (!gc) return -ENOMEM; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); dat = devm_ioremap_resource(&pdev->dev, res); if (IS_ERR(dat)) return PTR_ERR(dat); res = platform_get_resource(pdev, IORESOURCE_MEM, 1); dir = devm_ioremap_resource(&pdev->dev, res); if (IS_ERR(dir)) return PTR_ERR(dir); switch (id) { case 3: /* PORTD is inverted logic for direction register */ err = bgpio_init(gc, &pdev->dev, 1, dat, NULL, NULL, NULL, dir, 0); break; default: err = bgpio_init(gc, &pdev->dev, 1, dat, NULL, NULL, dir, NULL, 0); break; } if (err) return err; switch (id) { case 4: /* PORTE is 3 lines only */ gc->ngpio = 3; break; default: break; } gc->base = -1; gc->owner = THIS_MODULE; platform_set_drvdata(pdev, gc); return devm_gpiochip_add_data(&pdev->dev, gc, NULL); }
static int bcmgenet_mii_register(struct bcmgenet_priv *priv) { struct platform_device *pdev = priv->pdev; struct bcmgenet_platform_data *pdata = pdev->dev.platform_data; struct device_node *dn = pdev->dev.of_node; struct unimac_mdio_pdata ppd; struct platform_device *ppdev; struct resource *pres, res; int id, ret; pres = platform_get_resource(pdev, IORESOURCE_MEM, 0); memset(&res, 0, sizeof(res)); memset(&ppd, 0, sizeof(ppd)); ppd.wait_func = bcmgenet_mii_wait; ppd.wait_func_data = priv; ppd.bus_name = "bcmgenet MII bus"; /* Unimac MDIO bus controller starts at UniMAC offset + MDIO_CMD * and is 2 * 32-bits word long, 8 bytes total. */ res.start = pres->start + GENET_UMAC_OFF + UMAC_MDIO_CMD; res.end = res.start + 8; res.flags = IORESOURCE_MEM; if (dn) id = of_alias_get_id(dn, "eth"); else id = pdev->id; ppdev = platform_device_alloc(UNIMAC_MDIO_DRV_NAME, id); if (!ppdev) return -ENOMEM; /* Retain this platform_device pointer for later cleanup */ priv->mii_pdev = ppdev; ppdev->dev.parent = &pdev->dev; ppdev->dev.of_node = bcmgenet_mii_of_find_mdio(priv); if (pdata) bcmgenet_mii_pdata_init(priv, &ppd); ret = platform_device_add_resources(ppdev, &res, 1); if (ret) goto out; ret = platform_device_add_data(ppdev, &ppd, sizeof(ppd)); if (ret) goto out; ret = platform_device_add(ppdev); if (ret) goto out; return 0; out: platform_device_put(ppdev); return ret; }
static int digicolor_uart_probe(struct platform_device *pdev) { struct device_node *np = pdev->dev.of_node; int irq, ret, index; struct digicolor_port *dp; struct resource *res; struct clk *uart_clk; if (!np) { dev_err(&pdev->dev, "Missing device tree node\n"); return -ENXIO; } index = of_alias_get_id(np, "serial"); if (index < 0 || index >= DIGICOLOR_USART_NR) return -EINVAL; dp = devm_kzalloc(&pdev->dev, sizeof(*dp), GFP_KERNEL); if (!dp) return -ENOMEM; uart_clk = devm_clk_get(&pdev->dev, NULL); if (IS_ERR(uart_clk)) return PTR_ERR(uart_clk); res = platform_get_resource(pdev, IORESOURCE_MEM, 0); dp->port.mapbase = res->start; dp->port.membase = devm_ioremap_resource(&pdev->dev, res); if (IS_ERR(dp->port.membase)) return PTR_ERR(dp->port.membase); irq = platform_get_irq(pdev, 0); if (irq < 0) return irq; dp->port.irq = irq; dp->port.iotype = UPIO_MEM; dp->port.uartclk = clk_get_rate(uart_clk); dp->port.fifosize = 16; dp->port.dev = &pdev->dev; dp->port.ops = &digicolor_uart_ops; dp->port.line = index; dp->port.type = PORT_DIGICOLOR; spin_lock_init(&dp->port.lock); digicolor_ports[index] = &dp->port; platform_set_drvdata(pdev, &dp->port); INIT_DELAYED_WORK(&dp->rx_poll_work, digicolor_rx_poll); ret = devm_request_irq(&pdev->dev, dp->port.irq, digicolor_uart_int, 0, dev_name(&pdev->dev), &dp->port); if (ret) return ret; return uart_add_one_port(&digicolor_uart, &dp->port); }
static int clps711x_gpio_probe(struct device_d *dev) { struct resource *iores; int err, id = dev->id; void __iomem *dat, *dir = NULL, *dir_inv = NULL; struct bgpio_chip *bgc; if (dev->device_node) id = of_alias_get_id(dev->device_node, "gpio"); if (id < 0 || id > 4) return -ENODEV; iores = dev_request_mem_resource(dev, 0); if (IS_ERR(iores)) return PTR_ERR(iores); dat = IOMEM(iores->start); switch (id) { case 3: iores = dev_request_mem_resource(dev, 1); if (IS_ERR(iores)) return PTR_ERR(iores); dir_inv = IOMEM(iores->start); break; default: iores = dev_request_mem_resource(dev, 1); if (IS_ERR(iores)) return PTR_ERR(iores); dir = IOMEM(iores->start); break; } bgc = xzalloc(sizeof(struct bgpio_chip)); err = bgpio_init(bgc, dev, 1, dat, NULL, NULL, dir, dir_inv, 0); if (err) goto out_err; bgc->gc.base = id * 8; switch (id) { case 4: bgc->gc.ngpio = 3; break; default: break; } err = gpiochip_add(&bgc->gc); out_err: if (err) free(bgc); return err; }
static int meson_uart_probe(struct platform_device *pdev) { struct resource *res_mem, *res_irq; struct uart_port *port; struct clk *clk; int ret = 0; if (pdev->dev.of_node) pdev->id = of_alias_get_id(pdev->dev.of_node, "serial"); if (pdev->id < 0 || pdev->id >= AML_UART_PORT_NUM) return -EINVAL; res_mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!res_mem) return -ENODEV; res_irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0); if (!res_irq) return -ENODEV; if (meson_ports[pdev->id]) { dev_err(&pdev->dev, "port %d already allocated\n", pdev->id); return -EBUSY; } port = devm_kzalloc(&pdev->dev, sizeof(struct uart_port), GFP_KERNEL); if (!port) return -ENOMEM; clk = clk_get(&pdev->dev, NULL); if (IS_ERR(clk)) return PTR_ERR(clk); port->uartclk = clk_get_rate(clk); port->iotype = UPIO_MEM; port->mapbase = res_mem->start; port->irq = res_irq->start; port->flags = UPF_BOOT_AUTOCONF | UPF_IOREMAP | UPF_LOW_LATENCY; port->dev = &pdev->dev; port->line = pdev->id; port->type = PORT_MESON; port->x_char = 0; port->ops = &meson_uart_ops; port->fifosize = 64; meson_ports[pdev->id] = port; platform_set_drvdata(pdev, port); ret = uart_add_one_port(&meson_uart_driver, port); if (ret) meson_ports[pdev->id] = NULL; return ret; }
static int stmmac_probe_config_dt(struct platform_device *pdev, struct plat_stmmacenet_data *plat, const char **mac) { struct device_node *np = pdev->dev.of_node; struct stmmac_dma_cfg *dma_cfg; if (!np) return -ENODEV; *mac = of_get_mac_address(np); plat->interface = of_get_phy_mode(np); plat->bus_id = of_alias_get_id(np, "ethernet"); if (plat->bus_id < 0) plat->bus_id = 0; of_property_read_u32(np, "snps,phy-addr", &plat->phy_addr); plat->mdio_bus_data = devm_kzalloc(&pdev->dev, sizeof(struct stmmac_mdio_bus_data), GFP_KERNEL); /* * Currently only the properties needed on SPEAr600 * are provided. All other properties should be added * once needed on other platforms. */ if (of_device_is_compatible(np, "st,spear600-gmac") || of_device_is_compatible(np, "snps,dwmac-3.70a") || of_device_is_compatible(np, "snps,dwmac")) { plat->has_gmac = 1; plat->pmt = 1; } if (of_device_is_compatible(np, "snps,dwmac-3.610") || of_device_is_compatible(np, "snps,dwmac-3.710")) { plat->enh_desc = 1; plat->bugged_jumbo = 1; plat->force_sf_dma_mode = 1; } dma_cfg = devm_kzalloc(&pdev->dev, sizeof(*dma_cfg), GFP_KERNEL); if (!dma_cfg) return -ENOMEM; plat->dma_cfg = dma_cfg; of_property_read_u32(np, "snps,pbl", &dma_cfg->pbl); dma_cfg->fixed_burst = of_property_read_bool(np, "snps,fixed-burst"); dma_cfg->mixed_burst = of_property_read_bool(np, "snps,mixed-burst"); return 0; }
static int atmel_asoc_wm8904_remove(struct platform_device *pdev) { struct snd_soc_card *card = platform_get_drvdata(pdev); struct snd_soc_dai_link *dailink = &atmel_asoc_wm8904_dailink; int id; id = of_alias_get_id((struct device_node *)dailink->cpu_of_node, "ssc"); snd_soc_unregister_card(card); atmel_ssc_put_audio(id); return 0; }
static int clps711x_probe(struct device_d *dev) { struct clps711x_uart *s; int err, id = dev->id; char syscon_dev[8]; if (dev->device_node) id = of_alias_get_id(dev->device_node, "serial"); if (id != 0 && id != 1) return -EINVAL; s = xzalloc(sizeof(struct clps711x_uart)); s->uart_clk = clk_get(dev, NULL); if (IS_ERR(s->uart_clk)) { err = PTR_ERR(s->uart_clk); goto out_err; } s->base = dev_get_mem_region(dev, 0); if (!dev->device_node) { sprintf(syscon_dev, "syscon%i", id + 1); s->syscon = syscon_base_lookup_by_pdevname(syscon_dev); } else { s->syscon = syscon_base_lookup_by_phandle(dev->device_node, "syscon"); } if (IS_ERR(s->syscon)) { err = PTR_ERR(s->syscon); goto out_err; } dev->priv = s; s->cdev.dev = dev; s->cdev.tstc = clps711x_tstc; s->cdev.putc = clps711x_putc; s->cdev.getc = clps711x_getc; s->cdev.flush = clps711x_flush; s->cdev.setbrg = clps711x_setbaudrate; clps711x_init_port(&s->cdev); err = console_register(&s->cdev); out_err: if (err) free(s); return err; }
static int am335x_phy_probe(struct platform_device *pdev) { struct am335x_phy *am_phy; struct device *dev = &pdev->dev; int ret; am_phy = devm_kzalloc(dev, sizeof(*am_phy), GFP_KERNEL); if (!am_phy) return -ENOMEM; am_phy->phy_ctrl = am335x_get_phy_control(dev); if (!am_phy->phy_ctrl) return -EPROBE_DEFER; am_phy->id = of_alias_get_id(pdev->dev.of_node, "phy"); if (am_phy->id < 0) { dev_err(&pdev->dev, "Missing PHY id: %d\n", am_phy->id); return am_phy->id; } am_phy->dr_mode = of_usb_get_dr_mode_by_phy(pdev->dev.of_node, -1); ret = usb_phy_gen_create_phy(dev, &am_phy->usb_phy_gen, NULL); if (ret) return ret; ret = usb_add_phy_dev(&am_phy->usb_phy_gen.phy); if (ret) return ret; am_phy->usb_phy_gen.phy.init = am335x_init; am_phy->usb_phy_gen.phy.shutdown = am335x_shutdown; platform_set_drvdata(pdev, am_phy); device_init_wakeup(dev, true); /* * If we leave PHY wakeup enabled then AM33XX wakes up * immediately from DS0. To avoid this we mark dev->power.can_wakeup * to false. The same is checked in suspend routine to decide * on whether to enable PHY wakeup or not. * PHY wakeup works fine in standby mode, there by allowing us to * handle remote wakeup, wakeup on disconnect and connect. */ device_set_wakeup_enable(dev, false); phy_ctrl_power(am_phy->phy_ctrl, am_phy->id, am_phy->dr_mode, false); return 0; }
static int get_parent_node_id(struct device_node *node, const char *property, const char *stem) { struct device_node *pnode; unsigned int value = -ENODEV; pnode = of_parse_phandle(node, property, 0); if (NULL == pnode) { printk(KERN_ERR "err: fail to get node[%s]", property); return value; } value = of_alias_get_id(pnode, stem); return value; }
static void dw8250_quirks(struct uart_port *p, struct dw8250_data *data) { if (p->dev->of_node) { struct device_node *np = p->dev->of_node; int id; /* get index of serial line, if found in DT aliases */ id = of_alias_get_id(np, "serial"); if (id >= 0) p->line = id; #ifdef CONFIG_64BIT if (of_device_is_compatible(np, "cavium,octeon-3860-uart")) { p->serial_in = dw8250_serial_inq; p->serial_out = dw8250_serial_outq; p->flags = UPF_SKIP_TEST | UPF_SHARE_IRQ | UPF_FIXED_TYPE; p->type = PORT_OCTEON; data->usr_reg = 0x27; data->skip_autocfg = true; } #endif if (of_device_is_big_endian(p->dev->of_node)) { p->iotype = UPIO_MEM32BE; p->serial_in = dw8250_serial_in32be; p->serial_out = dw8250_serial_out32be; } } else if (has_acpi_companion(p->dev)) { const struct acpi_device_id *id; id = acpi_match_device(p->dev->driver->acpi_match_table, p->dev); if (id && !strcmp(id->id, "APMC0D08")) { p->iotype = UPIO_MEM32; p->regshift = 2; p->serial_in = dw8250_serial_in32; data->uart_16550_compatible = true; } p->set_termios = dw8250_set_termios; } /* Platforms with iDMA */ if (platform_get_resource_byname(to_platform_device(p->dev), IORESOURCE_MEM, "lpss_priv")) { p->set_termios = dw8250_set_termios; data->dma.rx_param = p->dev->parent; data->dma.tx_param = p->dev->parent; data->dma.fn = dw8250_idma_filter; } }
int dev_read_alias_seq(struct udevice *dev, int *devnump) { ofnode node = dev_ofnode(dev); const char *uc_name = dev->uclass->uc_drv->name; int ret; if (ofnode_is_np(node)) { ret = of_alias_get_id(ofnode_to_np(node), uc_name); if (ret >= 0) *devnump = ret; } else { ret = fdtdec_get_alias_seq(gd->fdt_blob, uc_name, ofnode_to_offset(node), devnump); } return ret; }
static int tegra_uart_parse_dt(struct platform_device *pdev, struct tegra_uart_port *tup) { struct device_node *np = pdev->dev.of_node; int port; port = of_alias_get_id(np, "serial"); if (port < 0) { dev_err(&pdev->dev, "failed to get alias id, errno %d\n", port); return port; } tup->uport.line = port; tup->enable_modem_interrupt = of_property_read_bool(np, "nvidia,enable-modem-interrupt"); return 0; }
static int serial_pxa_probe_dt(struct platform_device *pdev, struct uart_pxa_port *sport) { struct device_node *np = pdev->dev.of_node; int ret; if (!np) return 1; ret = of_alias_get_id(np, "serial"); if (ret < 0) { dev_err(&pdev->dev, "failed to get alias id, errno %d\n", ret); return ret; } sport->port.line = ret; return 0; }
static void __init clps711x_timer_init(struct device_node *np) { unsigned int irq = irq_of_parse_and_map(np, 0); struct clk *clock = of_clk_get(np, 0); void __iomem *base = of_iomap(np, 0); switch (of_alias_get_id(np, "timer")) { case CLPS711X_CLKSRC_CLOCKSOURCE: BUG_ON(_clps711x_clksrc_init(clock, base)); break; case CLPS711X_CLKSRC_CLOCKEVENT: BUG_ON(_clps711x_clkevt_init(clock, base, irq)); break; default: break; } }
int omapdss_register_display(struct omap_dss_device *dssdev) { struct omap_dss_driver *drv = dssdev->driver; int id; /* * Note: this presumes all the displays are either using DT or non-DT, * which normally should be the case. This also presumes that all * displays either have an DT alias, or none has. */ if (dssdev->dev->of_node) { id = of_alias_get_id(dssdev->dev->of_node, "display"); if (id < 0) id = disp_num_counter++; } else { id = disp_num_counter++; } snprintf(dssdev->alias, sizeof(dssdev->alias), "display%d", id); /* Use 'label' property for name, if it exists */ if (dssdev->dev->of_node) of_property_read_string(dssdev->dev->of_node, "label", &dssdev->name); if (dssdev->name == NULL) dssdev->name = dssdev->alias; pax_open_kernel(); if (drv && drv->get_resolution == NULL) *(void **)&drv->get_resolution = omapdss_default_get_resolution; if (drv && drv->get_recommended_bpp == NULL) *(void **)&drv->get_recommended_bpp = omapdss_default_get_recommended_bpp; if (drv && drv->get_timings == NULL) *(void **)&drv->get_timings = omapdss_default_get_timings; pax_close_kernel(); mutex_lock(&panel_list_mutex); list_add_tail(&dssdev->panel_list, &panel_list); mutex_unlock(&panel_list_mutex); return 0; }
static void console_set_stdoutpath(struct console_device *cdev) { int id; char *str; if (!cdev->linux_console_name) return; id = of_alias_get_id(cdev->dev->device_node, "serial"); if (id < 0) return; str = asprintf("console=%s%d,%dn8", cdev->linux_console_name, id, cdev->baudrate); globalvar_add_simple("linux.bootargs.console", str); free(str); }
static int etraxfs_uart_probe(struct platform_device *pdev) { struct device_node *np = pdev->dev.of_node; struct uart_cris_port *up; int dev_id; if (!np) return -ENODEV; dev_id = of_alias_get_id(np, "serial"); if (dev_id < 0) dev_id = 0; if (dev_id >= UART_NR) return -EINVAL; if (etraxfs_uart_ports[dev_id]) return -EBUSY; up = devm_kzalloc(&pdev->dev, sizeof(struct uart_cris_port), GFP_KERNEL); if (!up) return -ENOMEM; up->irq = irq_of_parse_and_map(np, 0); up->regi_ser = of_iomap(np, 0); up->port.dev = &pdev->dev; up->gpios = mctrl_gpio_init(&pdev->dev, 0); if (IS_ERR(up->gpios)) return PTR_ERR(up->gpios); cris_serial_port_init(&up->port, dev_id); etraxfs_uart_ports[dev_id] = up; platform_set_drvdata(pdev, &up->port); uart_add_one_port(&etraxfs_uart_driver, &up->port); return 0; }
static int ulite_probe(struct platform_device *pdev) { struct resource *res, *res2; int id = pdev->id; #ifdef CONFIG_OF const __be32 *prop; /* Look for a serialN alias */ id = of_alias_get_id(pdev->dev.of_node, "serial"); if (id < 0) { dev_warn(&pdev->dev, "failed to get alias id, errno %d\n", id); /* Fall back to old port-number property */ prop = of_get_property(pdev->dev.of_node, "port-number", NULL); if (!prop) { dev_warn(&pdev->dev, "failed to get port-number\n"); id = -1; } else id = be32_to_cpup(prop); } /* we can't register ids which are greater than number of uartlites */ if (id >= ULITE_NR_UARTS) { dev_warn(&pdev->dev, "Extern number of allocated uartlite entries " "ULITE_NR_UARTS, id %d\n", id); return -ENODEV; } #endif res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!res) return -ENODEV; res2 = platform_get_resource(pdev, IORESOURCE_IRQ, 0); if (!res2) return -ENODEV; return ulite_assign(&pdev->dev, id, res->start, res2->start); }
static int sprd_probe_dt_alias(int index, struct device *dev) { struct device_node *np; int ret = index; if (!IS_ENABLED(CONFIG_OF)) return ret; np = dev->of_node; if (!np) return ret; ret = of_alias_get_id(np, "serial"); if (IS_ERR_VALUE(ret)) ret = index; else if (ret >= ARRAY_SIZE(sprd_port) || sprd_port[ret] != NULL) { dev_warn(dev, "requested serial port %d not available.\n", ret); ret = index; } return ret; }
static int am335x_phy_probe(struct device_d *dev) { struct resource *iores; int ret; am_usbphy = xzalloc(sizeof(*am_usbphy)); if (!am_usbphy) return -ENOMEM; iores = dev_request_mem_resource(dev, 0); if (IS_ERR(iores)) { ret = PTR_ERR(iores); goto err_free; } am_usbphy->base = IOMEM(iores->start); am_usbphy->phy_ctrl = am335x_get_phy_control(dev); if (!am_usbphy->phy_ctrl) return -ENODEV; am_usbphy->id = of_alias_get_id(dev->device_node, "phy"); if (am_usbphy->id < 0) { dev_err(dev, "Missing PHY id: %d\n", am_usbphy->id); return am_usbphy->id; } am_usbphy->phy.init = am335x_init; dev->priv = am_usbphy; dev_info(dev, "am_usbphy %p enabled\n", &am_usbphy->phy); return 0; err_free: free(am_usbphy); return ret; };
static struct stm32_port *stm32_of_get_stm32_port(struct platform_device *pdev) { struct device_node *np = pdev->dev.of_node; int id; if (!np) return NULL; id = of_alias_get_id(np, "serial"); if (id < 0) { dev_err(&pdev->dev, "failed to get alias id, errno %d\n", id); return NULL; } if (WARN_ON(id >= STM32_MAX_PORTS)) return NULL; stm32_ports[id].hw_flow_control = of_property_read_bool(np, "st,hw-flow-ctrl"); stm32_ports[id].port.line = id; stm32_ports[id].last_res = RX_BUF_L; return &stm32_ports[id]; }
static int serial_omap_probe(struct platform_device *pdev) { struct uart_omap_port *up; struct resource *mem, *irq, *dma_tx, *dma_rx; struct omap_uart_port_info *omap_up_info = pdev->dev.platform_data; int ret = -ENOSPC; if (pdev->dev.of_node) omap_up_info = of_get_uart_port_info(&pdev->dev); mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!mem) { dev_err(&pdev->dev, "no mem resource?\n"); return -ENODEV; } irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0); if (!irq) { dev_err(&pdev->dev, "no irq resource?\n"); return -ENODEV; } if (!devm_request_mem_region(&pdev->dev, mem->start, resource_size(mem), pdev->dev.driver->name)) { dev_err(&pdev->dev, "memory region already claimed\n"); return -EBUSY; } dma_rx = platform_get_resource_byname(pdev, IORESOURCE_DMA, "rx"); if (!dma_rx) return -ENXIO; dma_tx = platform_get_resource_byname(pdev, IORESOURCE_DMA, "tx"); if (!dma_tx) return -ENXIO; up = devm_kzalloc(&pdev->dev, sizeof(*up), GFP_KERNEL); if (!up) return -ENOMEM; up->pdev = pdev; up->port.dev = &pdev->dev; up->port.type = PORT_OMAP; up->port.iotype = UPIO_MEM; up->port.irq = irq->start; up->port.regshift = 2; up->port.fifosize = 64; up->port.ops = &serial_omap_pops; if (pdev->dev.of_node) up->port.line = of_alias_get_id(pdev->dev.of_node, "serial"); else up->port.line = pdev->id; if (up->port.line < 0) { dev_err(&pdev->dev, "failed to get alias/pdev id, errno %d\n", up->port.line); ret = -ENODEV; goto err_port_line; } sprintf(up->name, "OMAP UART%d", up->port.line); up->port.mapbase = mem->start; up->port.membase = devm_ioremap(&pdev->dev, mem->start, resource_size(mem)); if (!up->port.membase) { dev_err(&pdev->dev, "can't ioremap UART\n"); ret = -ENOMEM; goto err_ioremap; } up->port.flags = omap_up_info->flags; up->port.uartclk = omap_up_info->uartclk; if (!up->port.uartclk) { up->port.uartclk = DEFAULT_CLK_SPEED; dev_warn(&pdev->dev, "No clock speed specified: using default:" "%d\n", DEFAULT_CLK_SPEED); } up->uart_dma.uart_base = mem->start; up->errata = omap_up_info->errata; if (omap_up_info->dma_enabled) { up->uart_dma.uart_dma_tx = dma_tx->start; up->uart_dma.uart_dma_rx = dma_rx->start; up->use_dma = 1; up->uart_dma.rx_buf_size = omap_up_info->dma_rx_buf_size; up->uart_dma.rx_timeout = omap_up_info->dma_rx_timeout; up->uart_dma.rx_poll_rate = omap_up_info->dma_rx_poll_rate; spin_lock_init(&(up->uart_dma.tx_lock)); spin_lock_init(&(up->uart_dma.rx_lock)); up->uart_dma.tx_dma_channel = OMAP_UART_DMA_CH_FREE; up->uart_dma.rx_dma_channel = OMAP_UART_DMA_CH_FREE; } up->latency = PM_QOS_CPU_DMA_LAT_DEFAULT_VALUE; up->calc_latency = PM_QOS_CPU_DMA_LAT_DEFAULT_VALUE; pm_qos_add_request(&up->pm_qos_request, PM_QOS_CPU_DMA_LATENCY, up->latency); serial_omap_uart_wq = create_singlethread_workqueue(up->name); INIT_WORK(&up->qos_work, serial_omap_uart_qos_work); pm_runtime_use_autosuspend(&pdev->dev); pm_runtime_set_autosuspend_delay(&pdev->dev, omap_up_info->autosuspend_timeout); pm_runtime_irq_safe(&pdev->dev); pm_runtime_enable(&pdev->dev); pm_runtime_get_sync(&pdev->dev); ui[up->port.line] = up; serial_omap_add_console_port(up); ret = uart_add_one_port(&serial_omap_reg, &up->port); if (ret != 0) goto err_add_port; pm_runtime_put(&pdev->dev); platform_set_drvdata(pdev, up); return 0; err_add_port: pm_runtime_put(&pdev->dev); pm_runtime_disable(&pdev->dev); err_ioremap: err_port_line: dev_err(&pdev->dev, "[UART%d]: failure [%s]: %d\n", pdev->id, __func__, ret); return ret; }
static int dw8250_probe_of(struct uart_port *p, struct dw8250_data *data) { struct device_node *np = p->dev->of_node; struct uart_8250_port *up = up_to_u8250p(p); u32 val; bool has_ucv = true; int id; #ifdef CONFIG_64BIT if (of_device_is_compatible(np, "cavium,octeon-3860-uart")) { p->serial_in = dw8250_serial_inq; p->serial_out = dw8250_serial_outq; p->flags = UPF_SKIP_TEST | UPF_SHARE_IRQ | UPF_FIXED_TYPE; p->type = PORT_OCTEON; data->usr_reg = 0x27; has_ucv = false; } else #endif if (!of_property_read_u32(np, "reg-io-width", &val)) { switch (val) { case 1: break; case 4: p->iotype = UPIO_MEM32; p->serial_in = dw8250_serial_in32; p->serial_out = dw8250_serial_out32; break; default: dev_err(p->dev, "unsupported reg-io-width (%u)\n", val); return -EINVAL; } } if (has_ucv) dw8250_setup_port(up); /* if we have a valid fifosize, try hooking up DMA here */ if (p->fifosize) { up->dma = &data->dma; up->dma->rxconf.src_maxburst = p->fifosize / 4; up->dma->txconf.dst_maxburst = p->fifosize / 4; } if (!of_property_read_u32(np, "reg-shift", &val)) p->regshift = val; /* get index of serial line, if found in DT aliases */ id = of_alias_get_id(np, "serial"); if (id >= 0) p->line = id; if (of_property_read_bool(np, "dcd-override")) { /* Always report DCD as active */ data->msr_mask_on |= UART_MSR_DCD; data->msr_mask_off |= UART_MSR_DDCD; } if (of_property_read_bool(np, "dsr-override")) { /* Always report DSR as active */ data->msr_mask_on |= UART_MSR_DSR; data->msr_mask_off |= UART_MSR_DDSR; } if (of_property_read_bool(np, "cts-override")) { /* Always report CTS as active */ data->msr_mask_on |= UART_MSR_CTS; data->msr_mask_off |= UART_MSR_DCTS; } if (of_property_read_bool(np, "ri-override")) { /* Always report Ring indicator as inactive */ data->msr_mask_off |= UART_MSR_RI; data->msr_mask_off |= UART_MSR_TERI; } return 0; }