static void check_usb_vbus_state(int state)
{
struct device_node *np = NULL;
struct platform_device *pdev = NULL;
pr_info("%s vbus state = %d\n", __func__, state);
np = of_find_compatible_node(NULL, NULL, "samsung,exynos5-dwusb3");
if (np) {
pdev = of_find_device_by_node(np);
of_node_put(np);
if (pdev) {
pr_info("%s: get the %s platform_device\n",
__func__, pdev->name);
dwc3_exynos_vbus_event(&pdev->dev, state);
goto end;
}
}
np = of_find_compatible_node(NULL, NULL, "samsung,exynos_udc");
if (np) {
pdev = of_find_device_by_node(np);
of_node_put(np);
if (pdev) {
pr_info("%s: get the %s platform_device\n",
__func__, pdev->name);
exynos_otg_vbus_event(pdev, state);
goto end;
}
}
pr_err("%s: failed to get the platform_device\n", __func__);
end:
return;
}
static struct bbc_i2c_bus * __init attach_one_i2c(struct of_device *op, int index)
{
struct bbc_i2c_bus *bp;
struct device_node *dp;
int entry;
bp = kzalloc(sizeof(*bp), GFP_KERNEL);
if (!bp)
return NULL;
bp->i2c_control_regs = of_ioremap(&op->resource[0], 0, 0x2, "bbc_i2c_regs");
if (!bp->i2c_control_regs)
goto fail;
bp->i2c_bussel_reg = of_ioremap(&op->resource[1], 0, 0x1, "bbc_i2c_bussel");
if (!bp->i2c_bussel_reg)
goto fail;
bp->waiting = 0;
init_waitqueue_head(&bp->wq);
if (request_irq(op->irqs[0], bbc_i2c_interrupt,
IRQF_SHARED, "bbc_i2c", bp))
goto fail;
bp->index = index;
bp->op = op;
spin_lock_init(&bp->lock);
entry = 0;
for (dp = op->node->child;
dp && entry < 8;
dp = dp->sibling, entry++) {
struct of_device *child_op;
child_op = of_find_device_by_node(dp);
bp->devs[entry].device = child_op;
bp->devs[entry].client_claimed = 0;
}
writeb(I2C_PCF_PIN, bp->i2c_control_regs + 0x0);
bp->own = readb(bp->i2c_control_regs + 0x01);
writeb(I2C_PCF_PIN | I2C_PCF_ES1, bp->i2c_control_regs + 0x0);
bp->clock = readb(bp->i2c_control_regs + 0x01);
printk(KERN_INFO "i2c-%d: Regs at %p, %d devices, own %02x, clock %02x.\n",
bp->index, bp->i2c_control_regs, entry, bp->own, bp->clock);
reset_one_i2c(bp);
return bp;
fail:
if (bp->i2c_bussel_reg)
of_iounmap(&op->resource[1], bp->i2c_bussel_reg, 1);
if (bp->i2c_control_regs)
of_iounmap(&op->resource[0], bp->i2c_control_regs, 2);
kfree(bp);
return NULL;
}
/**
* of_get_named_gpio_flags() - Get a GPIO number and flags to use with GPIO API
* @np: device node to get GPIO from
* @propname: property name containing gpio specifier(s)
* @index: index of the GPIO
* @flags: a flags pointer to fill in
*
* Returns GPIO number to use with GPIO API, or one of the errno value on the
* error condition. If @flags is not NULL the function also fills in flags for
* the GPIO.
*/
int of_get_named_gpio_flags(struct device_node *np, const char *propname,
int index, enum of_gpio_flags *flags)
{
struct of_phandle_args out_args;
struct device_d *dev;
int ret;
ret = of_parse_phandle_with_args(np, propname, "#gpio-cells",
index, &out_args);
if (ret) {
pr_debug("%s: cannot parse %s property: %d\n",
__func__, propname, ret);
return ret;
}
dev = of_find_device_by_node(out_args.np);
if (!dev) {
pr_err("%s: unable to find device of node %s: %d\n",
__func__, out_args.np->full_name, ret);
return ret;
}
ret = gpio_get_num(dev, out_args.args[0]);
if (ret < 0) {
pr_err("%s: unable to get gpio num of device %s: %d\n",
__func__, dev_name(dev), ret);
return ret;
}
if (flags)
*flags = out_args.args[1];
return ret;
}
static int mhl_tx_get_dt_data(struct device *dev_)
{
int rc = 0;
struct device_node *of_node = NULL;
struct platform_device *op = NULL;
of_node = dev_->of_node;
if (!of_node) {
pr_err("%s: invalid of_node\n", __func__);
goto error;
}
op = of_find_device_by_node(of_node->parent);
if (!op) {
pr_err("%s: invalid op\n", __func__);
goto error;
}
mhl_clk = clk_get(&op->dev, "");
if (!mhl_clk) {
pr_err("%s: invalid clk\n", __func__);
goto error;
}
rc = get_gpios_from_device_tree(of_node);
if (rc) {
pr_err("%s: error gpio init\n", __func__);
goto error;
}
return 0;
error:
pr_err("%s: ret due to err\n", __func__);
return rc;
} /* mhl_tx_get_dt_data */
static int tegra132_ccplex_suspend(void)
{
int i;
struct device_node *node;
pll_x_rate = clk_get_rate(clks[TEGRA132_PLL_X]);
for (i = 0; i < BURST_POLICY_REG_SIZE; i++)
cclk_burst_policy_ctx[i] = car_readl(CCLK_BURST_POLICY, i);
if (!dfll_pdev) {
node = of_find_compatible_node(NULL, NULL,
"nvidia,tegra132-dfll");
if (node)
dfll_pdev = of_find_device_by_node(node);
of_node_put(node);
if (!dfll_pdev)
pr_err("dfll node not found. no suspend for dfll\n");
}
if (dfll_pdev)
tegra_dfll_suspend(dfll_pdev);
return 0;
}
static int stm32_sai_set_sync(struct stm32_sai_data *sai_client,
struct device_node *np_provider,
int synco, int synci)
{
struct platform_device *pdev = of_find_device_by_node(np_provider);
struct stm32_sai_data *sai_provider;
int ret;
if (!pdev) {
dev_err(&sai_client->pdev->dev,
"Device not found for node %pOFn\n", np_provider);
return -ENODEV;
}
sai_provider = platform_get_drvdata(pdev);
if (!sai_provider) {
dev_err(&sai_client->pdev->dev,
"SAI sync provider data not found\n");
return -EINVAL;
}
/* Configure sync client */
ret = stm32_sai_sync_conf_client(sai_client, synci);
if (ret < 0)
return ret;
/* Configure sync provider */
return stm32_sai_sync_conf_provider(sai_provider, synco);
}
static int dpaa_get_ts_info(struct net_device *net_dev,
struct ethtool_ts_info *info)
{
struct device *dev = net_dev->dev.parent;
struct device_node *mac_node = dev->of_node;
struct device_node *fman_node = NULL, *ptp_node = NULL;
struct platform_device *ptp_dev = NULL;
struct qoriq_ptp *ptp = NULL;
info->phc_index = -1;
fman_node = of_get_parent(mac_node);
if (fman_node)
ptp_node = of_parse_phandle(fman_node, "ptimer-handle", 0);
if (ptp_node)
ptp_dev = of_find_device_by_node(ptp_node);
if (ptp_dev)
ptp = platform_get_drvdata(ptp_dev);
if (ptp)
info->phc_index = ptp->phc_index;
info->so_timestamping = SOF_TIMESTAMPING_TX_HARDWARE |
SOF_TIMESTAMPING_RX_HARDWARE |
SOF_TIMESTAMPING_RAW_HARDWARE;
info->tx_types = (1 << HWTSTAMP_TX_OFF) |
(1 << HWTSTAMP_TX_ON);
info->rx_filters = (1 << HWTSTAMP_FILTER_NONE) |
(1 << HWTSTAMP_FILTER_ALL);
return 0;
}
static int __init caam_sm_test_init(void)
{
struct device_node *dev_node;
struct platform_device *pdev;
/*
* Do of_find_compatible_node() then of_find_device_by_node()
* once a functional device tree is available
*/
dev_node = of_find_compatible_node(NULL, NULL, "fsl,sec-v4.0");
if (!dev_node) {
dev_node = of_find_compatible_node(NULL, NULL, "fsl,sec4.0");
if (!dev_node)
return -ENODEV;
}
pdev = of_find_device_by_node(dev_node);
if (!pdev)
return -ENODEV;
of_node_put(dev_node);
caam_sm_example_init(pdev);
return 0;
}
static int dsi_get_phy(struct msm_dsi *msm_dsi)
{
struct platform_device *pdev = msm_dsi->pdev;
struct platform_device *phy_pdev;
struct device_node *phy_node;
phy_node = of_parse_phandle(pdev->dev.of_node, "phys", 0);
if (!phy_node) {
dev_err(&pdev->dev, "cannot find phy device\n");
return -ENXIO;
}
phy_pdev = of_find_device_by_node(phy_node);
if (phy_pdev)
msm_dsi->phy = platform_get_drvdata(phy_pdev);
of_node_put(phy_node);
if (!phy_pdev || !msm_dsi->phy) {
dev_err(&pdev->dev, "%s: phy driver is not ready\n", __func__);
return -EPROBE_DEFER;
}
msm_dsi->phy_dev = get_device(&phy_pdev->dev);
return 0;
}
static int __init caam_secvio_init(void)
{
struct device_node *dev_node;
struct platform_device *pdev;
/*
* Do of_find_compatible_node() then of_find_device_by_node()
* once a functional device tree is available
*/
dev_node = of_find_compatible_node(NULL, NULL, "fsl,sec-v4.0");
if (!dev_node) {
dev_node = of_find_compatible_node(NULL, NULL,
"arm,imx6-caam-secvio");
if (!dev_node)
return -ENODEV;
}
pdev = of_find_device_by_node(dev_node);
if (!pdev)
return -ENODEV;
of_node_put(dev_node);
return caam_secvio_startup(pdev);
}
int setup_opps(void)
{
struct device_node *np;
struct platform_device *pdev;
int err;
np = of_find_node_by_name(NULL, "gpu");
if (!np) {
pr_err("Failed to find DT entry for Mali\n");
return -EFAULT;
}
pdev = of_find_device_by_node(np);
if (!pdev) {
pr_err("Failed to find device for Mali\n");
of_node_put(np);
return -EFAULT;
}
err = init_juno_opps_from_scpi(&pdev->dev);
of_node_put(np);
return err;
}
/* Register FIMC, FIMC-LITE and CSIS media entities */
static int fimc_md_register_platform_entities(struct fimc_md *fmd,
struct device_node *parent)
{
struct device_node *node;
int ret = 0;
for_each_available_child_of_node(parent, node) {
struct platform_device *pdev;
int plat_entity = -1;
pdev = of_find_device_by_node(node);
if (!pdev)
continue;
/* If driver of any entity isn't ready try all again later. */
if (!strcmp(node->name, CSIS_OF_NODE_NAME))
plat_entity = IDX_CSIS;
else if (!strcmp(node->name, FIMC_IS_OF_NODE_NAME))
plat_entity = IDX_IS_ISP;
else if (!strcmp(node->name, FIMC_LITE_OF_NODE_NAME))
plat_entity = IDX_FLITE;
else if (!strcmp(node->name, FIMC_OF_NODE_NAME) &&
!of_property_read_bool(node, "samsung,lcd-wb"))
plat_entity = IDX_FIMC;
if (plat_entity >= 0)
ret = fimc_md_register_platform_entity(fmd, pdev,
plat_entity);
put_device(&pdev->dev);
if (ret < 0)
break;
}
return ret;
}
/* Link integrity check is sometimes failed without external the power.
* This is a workaround for this failure. Enabling the USB clk help
* this issue.
*/
static void anx7808_get_usb_clk(struct i2c_client *client)
{
struct anx7808_data *anx7808 = i2c_get_clientdata(client);
struct device_node *dev_node = client->dev.of_node;
struct device_node *node;
struct platform_device *pdev;
node = of_parse_phandle(dev_node, "analogix,usb", 0);
if (!node) {
pr_warn("can't find dwc-usb3-msm phandle\n");
return;
}
pdev = of_find_device_by_node(node);
if (!pdev) {
pr_warn("can't find the device by node\n");
return;
}
anx7808->usb_clk = clk_get(&pdev->dev, "ref_clk");
if (IS_ERR(anx7808->usb_clk)) {
pr_warn("can't get usb3 ref_clk\n");
return;
}
atomic_set(&anx7808->usb_clk_count, 0);
pr_info("clk: %d\n", (int)clk_get_rate(anx7808->usb_clk));
}
unsigned int irq_of_parse_and_map(struct device_node *node, int index)
{
struct of_device *op = of_find_device_by_node(node);
if (!op || index >= op->num_irqs)
return 0;
return op->irqs[index];
}
int of_address_to_resource(struct device_node *node, int index,
struct resource *r)
{
struct platform_device *op = of_find_device_by_node(node);
if (!op || index >= op->num_resources)
return -EINVAL;
memcpy(r, &op->archdata.resource[index], sizeof(*r));
return 0;
}
void __iomem *of_iomap(struct device_node *node, int index)
{
struct platform_device *op = of_find_device_by_node(node);
struct resource *r;
if (!op || index >= op->num_resources)
return NULL;
r = &op->archdata.resource[index];
return of_ioremap(r, 0, resource_size(r), (char *) r->name);
}
static int hdmi_i2c2_hack_init(struct device *dev)
{
struct device_node *node;
node = of_parse_phandle(dev->of_node, "mcasp-gpio", 0);
if (!node)
return -ENODEV;
mcasp = of_find_device_by_node(node);
return 0;
}
struct bcm2835_smi_instance *bcm2835_smi_get(struct device_node *node)
{
struct platform_device *pdev;
if (!node)
return NULL;
pdev = of_find_device_by_node(node);
if (!pdev)
return NULL;
return platform_get_drvdata(pdev);
}
int __init init_common(struct tsens_device *tmdev)
{
void __iomem *tm_base, *srot_base;
struct resource *res;
u32 code;
int ret;
struct platform_device *op = of_find_device_by_node(tmdev->dev->of_node);
u16 ctrl_offset = tmdev->reg_offsets[SROT_CTRL_OFFSET];
if (!op)
return -EINVAL;
if (op->num_resources > 1) {
/* DT with separate SROT and TM address space */
tmdev->tm_offset = 0;
res = platform_get_resource(op, IORESOURCE_MEM, 1);
srot_base = devm_ioremap_resource(&op->dev, res);
if (IS_ERR(srot_base))
return PTR_ERR(srot_base);
tmdev->srot_map = devm_regmap_init_mmio(tmdev->dev, srot_base,
&tsens_srot_config);
if (IS_ERR(tmdev->srot_map))
return PTR_ERR(tmdev->srot_map);
} else {
/* old DTs where SROT and TM were in a contiguous 2K block */
tmdev->tm_offset = 0x1000;
}
res = platform_get_resource(op, IORESOURCE_MEM, 0);
tm_base = devm_ioremap_resource(&op->dev, res);
if (IS_ERR(tm_base))
return PTR_ERR(tm_base);
tmdev->tm_map = devm_regmap_init_mmio(tmdev->dev, tm_base, &tsens_config);
if (IS_ERR(tmdev->tm_map))
return PTR_ERR(tmdev->tm_map);
if (tmdev->srot_map) {
ret = regmap_read(tmdev->srot_map, ctrl_offset, &code);
if (ret)
return ret;
if (!(code & TSENS_EN)) {
dev_err(tmdev->dev, "tsens device is not enabled\n");
return -ENODEV;
}
}
return 0;
}
static int __init lirc_rpi_init(void)
{
struct device_node *node;
int result;
/* Init read buffer. */
result = lirc_buffer_init(&rbuf, sizeof(int), RBUF_LEN);
if (result < 0)
return -ENOMEM;
result = platform_driver_register(&lirc_rpi_driver);
if (result) {
printk(KERN_ERR LIRC_DRIVER_NAME
": lirc register returned %d\n", result);
goto exit_buffer_free;
}
node = of_find_compatible_node(NULL, NULL,
lirc_rpi_of_match[0].compatible);
if (node) {
/* DT-enabled */
lirc_rpi_dev = of_find_device_by_node(node);
WARN_ON(lirc_rpi_dev->dev.of_node != node);
of_node_put(node);
}
else {
lirc_rpi_dev = platform_device_alloc(LIRC_DRIVER_NAME, 0);
if (!lirc_rpi_dev) {
result = -ENOMEM;
goto exit_driver_unregister;
}
result = platform_device_add(lirc_rpi_dev);
if (result)
goto exit_device_put;
}
return 0;
exit_device_put:
platform_device_put(lirc_rpi_dev);
exit_driver_unregister:
platform_driver_unregister(&lirc_rpi_driver);
exit_buffer_free:
lirc_buffer_free(&rbuf);
return result;
}
/*
**************************************************************************
* FunctionName: k3_socgpio_get_id_value;
* Description : get sensor id value;
* Input :gpio_name:camera senor id_pin's name;
* Output :value:camera sensor id_pin's value,ether 0 or 1,if ret < 0 ,it can not get id_pin value ;
* ReturnValue:ret:if ret < 0 means error ,can not get right id_pin's value,if not ,means the value is right;
* Other :NA;
**************************************************************************
*/
int k3_socgpio_get_id_value(char *gpio_name)
{
int ret = -EINVAL;
struct device_node *np = NULL;
struct platform_device *pdev =NULL;
int gpio_pin;
enum of_gpio_flags gpio_flags;
print_debug("enter %s", __func__);
np = of_find_compatible_node(NULL, NULL, "hisi,hisi_isp");
if (NULL == np) {
print_error("the device node hisi_isp is null\n");
return -1;
}
pdev = of_find_device_by_node(np);
if (NULL == pdev) {
print_error("the device hisi_isp is null\n");
return -1;
}
gpio_pin = of_get_gpio_by_prop(np, gpio_name, 0, 0, &gpio_flags);
if (!gpio_is_valid(gpio_pin)) {
print_error("%s:huawei, pin read %s error.\n", __FUNCTION__, gpio_name);
return -1;
}
print_info("%s: huawei, pin read %s:%d.\n", __FUNCTION__, gpio_name, gpio_pin);
ret = gpio_request(gpio_pin, gpio_name);
if (ret < 0) {
print_error("%s: request camera gpio - %d(%s) failed, result = %d.",
__func__, gpio_pin, gpio_name, ret);
return -EINVAL;
}
ret = gpio_get_value(gpio_pin);
if (ret < 0) {
print_error("%s: fail to get value on gpio - %d(%s), result = %d.",
__func__, gpio_pin, gpio_name, ret);
}
gpio_free(gpio_pin);
print_debug("leave %s", __func__);
return ret;
}
/* Public Key Cryptography module initialization handler */
static int __init caam_pkc_init(void)
{
struct device_node *dev_node;
struct platform_device *pdev;
struct device *ctrldev;
struct caam_drv_private *priv;
u32 cha_inst, pk_inst;
int err;
dev_node = of_find_compatible_node(NULL, NULL, "fsl,sec-v4.0");
if (!dev_node) {
dev_node = of_find_compatible_node(NULL, NULL, "fsl,sec4.0");
if (!dev_node)
return -ENODEV;
}
pdev = of_find_device_by_node(dev_node);
if (!pdev) {
of_node_put(dev_node);
return -ENODEV;
}
ctrldev = &pdev->dev;
priv = dev_get_drvdata(ctrldev);
of_node_put(dev_node);
/*
* If priv is NULL, it's probably because the caam driver wasn't
* properly initialized (e.g. RNG4 init failed). Thus, bail out here.
*/
if (!priv)
return -ENODEV;
/* Determine public key hardware accelerator presence. */
cha_inst = rd_reg32(&priv->ctrl->perfmon.cha_num_ls);
pk_inst = (cha_inst & CHA_ID_LS_PK_MASK) >> CHA_ID_LS_PK_SHIFT;
/* Do not register algorithms if PKHA is not present. */
if (!pk_inst)
return -ENODEV;
err = crypto_register_akcipher(&caam_rsa);
if (err)
dev_warn(ctrldev, "%s alg registration failed\n",
caam_rsa.base.cra_driver_name);
else
dev_info(ctrldev, "caam pkc algorithms registered in /proc/crypto\n");
return err;
}
/**
* zynq_pm_remap_ocm() - Remap OCM
* Returns a pointer to the mapped memory or NULL.
*
* Remap the OCM.
*/
static void __iomem *zynq_pm_remap_ocm(void)
{
struct device_node *np;
const char *comp = "xlnx,zynq-ocmc-1.0";
void __iomem *base = NULL;
np = of_find_compatible_node(NULL, NULL, comp);
if (np) {
struct device *dev;
unsigned long pool_addr;
unsigned long pool_addr_virt;
struct gen_pool *pool;
of_node_put(np);
dev = &(of_find_device_by_node(np)->dev);
/* Get OCM pool from device tree or platform data */
pool = dev_get_gen_pool(dev);
if (!pool) {
pr_warn("%s: OCM pool is not available\n", __func__);
return NULL;
}
pool_addr_virt = gen_pool_alloc(pool, zynq_sys_suspend_sz);
if (!pool_addr_virt) {
pr_warn("%s: Can't get OCM poll\n", __func__);
return NULL;
}
pool_addr = gen_pool_virt_to_phys(pool, pool_addr_virt);
if (!pool_addr) {
pr_warn("%s: Can't get physical address of OCM pool\n",
__func__);
return NULL;
}
base = __arm_ioremap(pool_addr, zynq_sys_suspend_sz,
MT_MEMORY_RWX);
if (!base) {
pr_warn("%s: IOremap OCM pool failed\n", __func__);
return NULL;
}
pr_debug("%s: Remap OCM %s from %lx to %lx\n", __func__, comp,
pool_addr_virt, (unsigned long)base);
} else {
pr_warn("%s: no compatible node found for '%s'\n", __func__,
comp);
}
return base;
}
static int msm_hdmi_audio_codec_rx_probe(struct snd_soc_codec *codec)
{
struct msm_hdmi_audio_codec_rx_data *codec_data;
struct device_node *of_node_parent = NULL;
codec_data = kzalloc(sizeof(struct msm_hdmi_audio_codec_rx_data),
GFP_KERNEL);
pr_info("%s++\n",__func__);
if (!codec_data) {
dev_err(codec->dev, "%s(): fail to allocate dai data\n",
__func__);
return -ENOMEM;
}
of_node_parent = of_get_parent(codec->dev->of_node);
if (!of_node_parent) {
dev_err(codec->dev, "%s(): Parent device tree node not found\n",
__func__);
kfree(codec_data);
return -ENODEV;
}
codec_data->hdmi_core_pdev = of_find_device_by_node(of_node_parent);
if (!codec_data->hdmi_core_pdev) {
dev_err(codec->dev, "%s(): can't get parent pdev\n", __func__);
kfree(codec_data);
return -ENODEV;
}
if (msm_hdmi_register_audio_codec(codec_data->hdmi_core_pdev,
&codec_data->hdmi_ops)) {
dev_err(codec->dev, "%s(): can't register with hdmi core",
__func__);
kfree(codec_data);
return -ENODEV;
}
dev_set_drvdata(codec->dev, codec_data);
dev_dbg(codec->dev, "%s(): registerd %s with HDMI core\n",
__func__, codec->name);
if(codec_data->hdmi_ops.hdmi_cable_status)
pr_info("%s: hdmi_cable_status is ok\n",__func__);
else
pr_info("%s: hdmi_cable_status is null\n",__func__);
pr_info("%s--\n",__func__);
return 0;
}
/*
* Try to find the node inside the DT. If it is available attach out
* platform_nand_data
*/
static int __init oxnas_register_nand(void)
{
struct device_node *node;
struct platform_device *pdev;
node = of_find_compatible_node(NULL, NULL, "plxtech,nand-nas782x");
if (!node)
return -ENOENT;
pdev = of_find_device_by_node(node);
if (!pdev)
return -EINVAL;
pdev->dev.platform_data = &oxnas_nand_data;
of_node_put(node);
return 0;
}
static void *ti_am335x_xbar_route_allocate(struct of_phandle_args *dma_spec,
struct of_dma *ofdma)
{
struct platform_device *pdev = of_find_device_by_node(ofdma->of_node);
struct ti_am335x_xbar_data *xbar = platform_get_drvdata(pdev);
struct ti_am335x_xbar_map *map;
if (dma_spec->args_count != 3)
return ERR_PTR(-EINVAL);
if (dma_spec->args[2] >= xbar->xbar_events) {
dev_err(&pdev->dev, "Invalid XBAR event number: %d\n",
dma_spec->args[2]);
return ERR_PTR(-EINVAL);
}
if (dma_spec->args[0] >= xbar->dma_requests) {
dev_err(&pdev->dev, "Invalid DMA request line number: %d\n",
dma_spec->args[0]);
return ERR_PTR(-EINVAL);
}
/* The of_node_put() will be done in the core for the node */
dma_spec->np = of_parse_phandle(ofdma->of_node, "dma-masters", 0);
if (!dma_spec->np) {
dev_err(&pdev->dev, "Can't get DMA master\n");
return ERR_PTR(-EINVAL);
}
map = kzalloc(sizeof(*map), GFP_KERNEL);
if (!map) {
of_node_put(dma_spec->np);
return ERR_PTR(-ENOMEM);
}
map->dma_line = (u16)dma_spec->args[0];
map->mux_val = (u16)dma_spec->args[2];
dma_spec->args[2] = 0;
dma_spec->args_count = 2;
dev_dbg(&pdev->dev, "Mapping XBAR event%u to DMA%u\n",
map->mux_val, map->dma_line);
ti_am335x_xbar_write(xbar->iomem, map->dma_line, map->mux_val);
return map;
}
static void *ti_dra7_xbar_route_allocate(struct of_phandle_args *dma_spec,
struct of_dma *ofdma)
{
struct platform_device *pdev = of_find_device_by_node(ofdma->of_node);
struct ti_dra7_xbar_data *xbar = platform_get_drvdata(pdev);
struct ti_dra7_xbar_map *map;
if (dma_spec->args[0] >= xbar->xbar_requests) {
dev_err(&pdev->dev, "Invalid XBAR request number: %d\n",
dma_spec->args[0]);
return ERR_PTR(-EINVAL);
}
/* The of_node_put() will be done in the core for the node */
dma_spec->np = of_parse_phandle(ofdma->of_node, "dma-masters", 0);
if (!dma_spec->np) {
dev_err(&pdev->dev, "Can't get DMA master\n");
return ERR_PTR(-EINVAL);
}
map = kzalloc(sizeof(*map), GFP_KERNEL);
if (!map) {
of_node_put(dma_spec->np);
return ERR_PTR(-ENOMEM);
}
mutex_lock(&xbar->mutex);
map->xbar_out = find_first_zero_bit(xbar->dma_inuse,
xbar->dma_requests);
mutex_unlock(&xbar->mutex);
if (map->xbar_out == xbar->dma_requests) {
dev_err(&pdev->dev, "Run out of free DMA requests\n");
kfree(map);
return ERR_PTR(-ENOMEM);
}
set_bit(map->xbar_out, xbar->dma_inuse);
map->xbar_in = (u16)dma_spec->args[0];
dma_spec->args[0] = map->xbar_out + xbar->dma_offset;
dev_dbg(&pdev->dev, "Mapping XBAR%u to DMA%d\n",
map->xbar_in, map->xbar_out);
ti_dra7_xbar_write(xbar->iomem, map->xbar_out, map->xbar_in);
return map;
}
static int fimc_is_register_subdevs(struct fimc_is *is)
{
struct device_node *adapter, *child;
int ret;
ret = fimc_isp_subdev_create(&is->isp);
if (ret < 0)
return ret;
for_each_compatible_node(adapter, NULL, FIMC_IS_I2C_COMPATIBLE) {
if (!of_find_device_by_node(adapter)) {
of_node_put(adapter);
return -EPROBE_DEFER;
}
for_each_available_child_of_node(adapter, child) {
struct i2c_client *client;
struct v4l2_subdev *sd;
client = of_find_i2c_device_by_node(child);
if (!client)
goto e_retry;
sd = i2c_get_clientdata(client);
if (!sd)
goto e_retry;
/* FIXME: Add support for multiple sensors. */
if (WARN_ON(is->sensor))
continue;
is->sensor = sd_to_fimc_is_sensor(sd);
if (fimc_is_parse_sensor_config(is->sensor, child)) {
dev_warn(&is->pdev->dev, "DT parse error: %s\n",
child->full_name);
}
pr_debug("%s(): registered subdev: %p\n",
__func__, sd->name);
}
}
return 0;
e_retry:
of_node_put(child);
return -EPROBE_DEFER;
}
struct tegra_mipi_device *tegra_mipi_request(struct device *device)
{
struct device_node *np = device->of_node;
struct tegra_mipi_device *dev;
struct of_phandle_args args;
int err;
err = of_parse_phandle_with_args(np, "nvidia,mipi-calibrate",
"#nvidia,mipi-calibrate-cells", 0,
&args);
if (err < 0)
return ERR_PTR(err);
dev = kzalloc(sizeof(*dev), GFP_KERNEL);
if (!dev) {
err = -ENOMEM;
goto out;
}
dev->pdev = of_find_device_by_node(args.np);
if (!dev->pdev) {
err = -ENODEV;
goto free;
}
dev->mipi = platform_get_drvdata(dev->pdev);
if (!dev->mipi) {
err = -EPROBE_DEFER;
goto put;
}
of_node_put(args.np);
dev->pads = args.args[0];
dev->device = device;
return dev;
put:
platform_device_put(dev->pdev);
free:
kfree(dev);
out:
of_node_put(args.np);
return ERR_PTR(err);
}
/* Take the archdata values for IOMMU, STC, and HOSTDATA found in
* BUS and propagate to all child of_device objects.
*/
void of_propagate_archdata(struct of_device *bus)
{
struct dev_archdata *bus_sd = &bus->dev.archdata;
struct device_node *bus_dp = bus->node;
struct device_node *dp;
for (dp = bus_dp->child; dp; dp = dp->sibling) {
struct of_device *op = of_find_device_by_node(dp);
op->dev.archdata.iommu = bus_sd->iommu;
op->dev.archdata.stc = bus_sd->stc;
op->dev.archdata.host_controller = bus_sd->host_controller;
op->dev.archdata.numa_node = bus_sd->numa_node;
if (dp->child)
of_propagate_archdata(op);
}
}
