static int armada375_usb_phy_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; struct phy *phy; struct phy_provider *phy_provider; void __iomem *usb_cluster_base; struct resource *res; struct armada375_cluster_phy *cluster_phy; cluster_phy = devm_kzalloc(dev, sizeof(*cluster_phy), GFP_KERNEL); if (!cluster_phy) return -ENOMEM; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); usb_cluster_base = devm_ioremap_resource(&pdev->dev, res); if (IS_ERR(usb_cluster_base)) return PTR_ERR(usb_cluster_base); phy = devm_phy_create(dev, NULL, &armada375_usb_phy_ops); if (IS_ERR(phy)) { dev_err(dev, "failed to create PHY\n"); return PTR_ERR(phy); } cluster_phy->phy = phy; cluster_phy->reg = usb_cluster_base; dev_set_drvdata(dev, cluster_phy); phy_provider = devm_of_phy_provider_register(&pdev->dev, armada375_usb_phy_xlate); return PTR_ERR_OR_ZERO(phy_provider); }
static int ad7414_probe(struct i2c_client *client, const struct i2c_device_id *dev_id) { struct device *dev = &client->dev; struct ad7414_data *data; struct device *hwmon_dev; int conf; if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_READ_WORD_DATA)) return -EOPNOTSUPP; data = devm_kzalloc(dev, sizeof(struct ad7414_data), GFP_KERNEL); if (!data) return -ENOMEM; data->client = client; mutex_init(&data->lock); dev_info(&client->dev, "chip found\n"); /* Make sure the chip is powered up. */ conf = i2c_smbus_read_byte_data(client, AD7414_REG_CONF); if (conf < 0) dev_warn(dev, "ad7414_probe unable to read config register.\n"); else { conf &= ~(1 << 7); i2c_smbus_write_byte_data(client, AD7414_REG_CONF, conf); } hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name, data, ad7414_groups); return PTR_ERR_OR_ZERO(hwmon_dev); }
static int max1668_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct i2c_adapter *adapter = client->adapter; struct device *dev = &client->dev; struct device *hwmon_dev; struct max1668_data *data; if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) return -ENODEV; data = devm_kzalloc(dev, sizeof(struct max1668_data), GFP_KERNEL); if (!data) return -ENOMEM; data->client = client; data->type = id->driver_data; mutex_init(&data->update_lock); /* sysfs hooks */ data->groups[0] = &max1668_group_common; if (data->type == max1668 || data->type == max1989) data->groups[1] = &max1668_group_unique; hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name, data, data->groups); return PTR_ERR_OR_ZERO(hwmon_dev); }
static int ds3232_probe(struct device *dev, struct regmap *regmap, int irq, const char *name) { struct ds3232 *ds3232; int ret; ds3232 = devm_kzalloc(dev, sizeof(*ds3232), GFP_KERNEL); if (!ds3232) return -ENOMEM; ds3232->regmap = regmap; ds3232->irq = irq; ds3232->dev = dev; dev_set_drvdata(dev, ds3232); ret = ds3232_check_rtc_status(dev); if (ret) return ret; if (ds3232->irq > 0) { ret = devm_request_threaded_irq(dev, ds3232->irq, NULL, ds3232_irq, IRQF_SHARED | IRQF_ONESHOT, name, dev); if (ret) { ds3232->irq = 0; dev_err(dev, "unable to request IRQ\n"); } else device_init_wakeup(dev, 1); } ds3232->rtc = devm_rtc_device_register(dev, name, &ds3232_rtc_ops, THIS_MODULE); return PTR_ERR_OR_ZERO(ds3232->rtc); }
static int exynos_dp_video_phy_probe(struct platform_device *pdev) { struct exynos_dp_video_phy *state; struct device *dev = &pdev->dev; const struct of_device_id *match; struct phy_provider *phy_provider; struct phy *phy; state = devm_kzalloc(dev, sizeof(*state), GFP_KERNEL); if (!state) return -ENOMEM; state->regs = syscon_regmap_lookup_by_phandle(dev->of_node, "samsung,pmu-syscon"); if (IS_ERR(state->regs)) { dev_err(dev, "Failed to lookup PMU regmap\n"); return PTR_ERR(state->regs); } match = of_match_node(exynos_dp_video_phy_of_match, dev->of_node); state->drvdata = match->data; phy = devm_phy_create(dev, NULL, &exynos_dp_video_phy_ops); if (IS_ERR(phy)) { dev_err(dev, "failed to create Display Port PHY\n"); return PTR_ERR(phy); } phy_set_drvdata(phy, state); phy_provider = devm_of_phy_provider_register(dev, of_phy_simple_xlate); return PTR_ERR_OR_ZERO(phy_provider); }
static int pcf2127_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct pcf2127 *pcf2127; dev_dbg(&client->dev, "%s\n", __func__); if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) return -ENODEV; pcf2127 = devm_kzalloc(&client->dev, sizeof(struct pcf2127), GFP_KERNEL); if (!pcf2127) return -ENOMEM; dev_info(&client->dev, "chip found, driver version " DRV_VERSION "\n"); i2c_set_clientdata(client, pcf2127); pcf2127->rtc = devm_rtc_device_register(&client->dev, pcf2127_driver.driver.name, &pcf2127_rtc_ops, THIS_MODULE); return PTR_ERR_OR_ZERO(pcf2127->rtc); }
int aarch32_setup_vectors_page(struct linux_binprm *bprm, int uses_interp) { struct mm_struct *mm = current->mm; unsigned long addr = AARCH32_VECTORS_BASE; static const struct vm_special_mapping spec = { .name = "[vectors]", .pages = vectors_page, }; void *ret; if (down_write_killable(&mm->mmap_sem)) return -EINTR; current->mm->context.vdso = (void *)addr; /* Map vectors page at the high address. */ ret = _install_special_mapping(mm, addr, PAGE_SIZE, VM_READ|VM_EXEC|VM_MAYREAD|VM_MAYEXEC, &spec); up_write(&mm->mmap_sem); return PTR_ERR_OR_ZERO(ret); } #endif /* CONFIG_COMPAT */ static struct vm_special_mapping vdso_spec[2] __ro_after_init = { { .name = "[vvar]", }, { .name = "[vdso]", }, };
static int hix5hd2_sata_phy_probe(struct platform_device *pdev) { struct phy_provider *phy_provider; struct device *dev = &pdev->dev; struct resource *res; struct phy *phy; struct hix5hd2_priv *priv; priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); if (!priv) return -ENOMEM; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); priv->base = devm_ioremap(dev, res->start, resource_size(res)); if (!priv->base) return -ENOMEM; priv->peri_ctrl = syscon_regmap_lookup_by_phandle(dev->of_node, "hisilicon,peripheral-syscon"); if (IS_ERR(priv->peri_ctrl)) priv->peri_ctrl = NULL; phy = devm_phy_create(dev, NULL, &hix5hd2_sata_phy_ops); if (IS_ERR(phy)) { dev_err(dev, "failed to create PHY\n"); return PTR_ERR(phy); } phy_set_drvdata(phy, priv); phy_provider = devm_of_phy_provider_register(dev, of_phy_simple_xlate); return PTR_ERR_OR_ZERO(phy_provider); }
static int __init fid_mod_init(void) { seq_type_proc_dir = lprocfs_register(LUSTRE_SEQ_NAME, proc_lustre_root, NULL, NULL); return PTR_ERR_OR_ZERO(seq_type_proc_dir); }
static int smsc47m192_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct device *dev = &client->dev; struct device *hwmon_dev; struct smsc47m192_data *data; int config; data = devm_kzalloc(dev, sizeof(struct smsc47m192_data), GFP_KERNEL); if (!data) return -ENOMEM; data->client = client; data->vrm = vid_which_vrm(); mutex_init(&data->update_lock); /* Initialize the SMSC47M192 chip */ smsc47m192_init_client(client); /* sysfs hooks */ data->groups[0] = &smsc47m192_group; /* Pin 110 is either in4 (+12V) or VID4 */ config = i2c_smbus_read_byte_data(client, SMSC47M192_REG_CONFIG); if (!(config & 0x20)) data->groups[1] = &smsc47m192_group_in4; hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name, data, data->groups); return PTR_ERR_OR_ZERO(hwmon_dev); }
static int lm70_probe(struct spi_device *spi) { const struct of_device_id *match; struct device *hwmon_dev; struct lm70 *p_lm70; int chip; match = of_match_device(lm70_of_ids, &spi->dev); if (match) chip = (int)(uintptr_t)match->data; else chip = spi_get_device_id(spi)->driver_data; /* signaling is SPI_MODE_0 */ if (spi->mode & (SPI_CPOL | SPI_CPHA)) return -EINVAL; /* NOTE: we assume 8-bit words, and convert to 16 bits manually */ p_lm70 = devm_kzalloc(&spi->dev, sizeof(*p_lm70), GFP_KERNEL); if (!p_lm70) return -ENOMEM; mutex_init(&p_lm70->lock); p_lm70->chip = chip; p_lm70->spi = spi; hwmon_dev = devm_hwmon_device_register_with_groups(&spi->dev, spi->modalias, p_lm70, lm70_groups); return PTR_ERR_OR_ZERO(hwmon_dev); }
static int __init marxbot_usbh1_init(void) { struct usb_phy *phy; struct platform_device *pdev; phy = kzalloc(sizeof(*phy), GFP_KERNEL); if (!phy) return -ENOMEM; phy->otg = kzalloc(sizeof(struct usb_otg), GFP_KERNEL); if (!phy->otg) { kfree(phy); return -ENOMEM; } phy->label = "ISP1105"; phy->init = marxbot_isp1105_init; phy->otg->set_vbus = marxbot_isp1105_set_vbus; usbh1_pdata.otg = phy; pdev = imx31_add_mxc_ehci_hs(1, &usbh1_pdata); return PTR_ERR_OR_ZERO(pdev); }
static int max31790_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct i2c_adapter *adapter = client->adapter; struct device *dev = &client->dev; struct max31790_data *data; struct device *hwmon_dev; int err; if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA)) return -ENODEV; data = devm_kzalloc(dev, sizeof(struct max31790_data), GFP_KERNEL); if (!data) return -ENOMEM; data->client = client; mutex_init(&data->update_lock); /* * Initialize the max31790 chip */ err = max31790_init_client(client, data); if (err) return err; hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name, data, &max31790_chip_info, NULL); return PTR_ERR_OR_ZERO(hwmon_dev); }
static int __init fid_init(void) { seq_debugfs_dir = ldebugfs_register(LUSTRE_SEQ_NAME, debugfs_lustre_root, NULL, NULL); return PTR_ERR_OR_ZERO(seq_debugfs_dir); }
static int da9052_rtc_probe(struct platform_device *pdev) { struct da9052_rtc *rtc; int ret; rtc = devm_kzalloc(&pdev->dev, sizeof(struct da9052_rtc), GFP_KERNEL); if (!rtc) return -ENOMEM; rtc->da9052 = dev_get_drvdata(pdev->dev.parent); platform_set_drvdata(pdev, rtc); ret = da9052_reg_write(rtc->da9052, DA9052_BBAT_CONT_REG, 0xFE); if (ret < 0) { rtc_err(rtc, "Failed to setup RTC battery charging: %d\n", ret); return ret; } ret = da9052_reg_update(rtc->da9052, DA9052_ALARM_Y_REG, DA9052_ALARM_Y_TICK_ON, 0); if (ret != 0) rtc_err(rtc, "Failed to disable TICKS: %d\n", ret); ret = da9052_request_irq(rtc->da9052, DA9052_IRQ_ALARM, "ALM", da9052_rtc_irq, rtc); if (ret != 0) { rtc_err(rtc, "irq registration failed: %d\n", ret); return ret; } rtc->rtc = devm_rtc_device_register(&pdev->dev, pdev->name, &da9052_rtc_ops, THIS_MODULE); return PTR_ERR_OR_ZERO(rtc->rtc); }
static int ovl_real_fdget_meta(const struct file *file, struct fd *real, bool allow_meta) { struct inode *inode = file_inode(file); struct inode *realinode; real->flags = 0; real->file = file->private_data; if (allow_meta) realinode = ovl_inode_real(inode); else realinode = ovl_inode_realdata(inode); /* Has it been copied up since we'd opened it? */ if (unlikely(file_inode(real->file) != realinode)) { real->flags = FDPUT_FPUT; real->file = ovl_open_realfile(file, realinode); return PTR_ERR_OR_ZERO(real->file); } /* Did the flags change since open? */ if (unlikely((file->f_flags ^ real->file->f_flags) & ~O_NOATIME)) return ovl_change_flags(real->file, file->f_flags); return 0; }
static int __init nps_get_timer_clk(struct device_node *node, unsigned long *timer_freq, struct clk **clk) { int ret; *clk = of_clk_get(node, 0); ret = PTR_ERR_OR_ZERO(*clk); if (ret) { pr_err("timer missing clk\n"); return ret; } ret = clk_prepare_enable(*clk); if (ret) { pr_err("Couldn't enable parent clk\n"); clk_put(*clk); return ret; } *timer_freq = clk_get_rate(*clk); if (!(*timer_freq)) { pr_err("Couldn't get clk rate\n"); clk_disable_unprepare(*clk); clk_put(*clk); return -EINVAL; } return 0; }
static int gemini_rtc_probe(struct platform_device *pdev) { struct gemini_rtc *rtc; struct device *dev = &pdev->dev; struct resource *res; int ret; rtc = devm_kzalloc(&pdev->dev, sizeof(*rtc), GFP_KERNEL); if (unlikely(!rtc)) return -ENOMEM; platform_set_drvdata(pdev, rtc); res = platform_get_resource(pdev, IORESOURCE_IRQ, 0); if (!res) return -ENODEV; rtc->rtc_irq = res->start; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!res) return -ENODEV; rtc->rtc_base = devm_ioremap(dev, res->start, resource_size(res)); ret = devm_request_irq(dev, rtc->rtc_irq, gemini_rtc_interrupt, IRQF_SHARED, pdev->name, dev); if (unlikely(ret)) return ret; rtc->rtc_dev = rtc_device_register(pdev->name, dev, &gemini_rtc_ops, THIS_MODULE); return PTR_ERR_OR_ZERO(rtc->rtc_dev); }
static int __init fail_iommu_debugfs(void) { struct dentry *dir = fault_create_debugfs_attr("fail_iommu", NULL, &fail_iommu); return PTR_ERR_OR_ZERO(dir); }
int ip_tunnel_init_net(struct net *net, int ip_tnl_net_id, struct rtnl_link_ops *ops, char *devname) { struct ip_tunnel_net *itn = net_generic(net, ip_tnl_net_id); struct ip_tunnel_parm parms; unsigned int i; for (i = 0; i < IP_TNL_HASH_SIZE; i++) INIT_HLIST_HEAD(&itn->tunnels[i]); if (!ops) { itn->fb_tunnel_dev = NULL; return 0; } memset(&parms, 0, sizeof(parms)); if (devname) strlcpy(parms.name, devname, IFNAMSIZ); rtnl_lock(); itn->fb_tunnel_dev = __ip_tunnel_create(net, ops, &parms); /* FB netdevice is special: we have one, and only one per netns. * Allowing to move it to another netns is clearly unsafe. */ if (!IS_ERR(itn->fb_tunnel_dev)) { itn->fb_tunnel_dev->features |= NETIF_F_NETNS_LOCAL; itn->fb_tunnel_dev->mtu = ip_tunnel_bind_dev(itn->fb_tunnel_dev); ip_tunnel_add(itn, netdev_priv(itn->fb_tunnel_dev)); } rtnl_unlock(); return PTR_ERR_OR_ZERO(itn->fb_tunnel_dev); }
/* resume dev_replace procedure that was interrupted by unmount */ int btrfs_resume_dev_replace_async(struct btrfs_fs_info *fs_info) { struct task_struct *task; struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace; btrfs_dev_replace_lock(dev_replace); switch (dev_replace->replace_state) { case BTRFS_IOCTL_DEV_REPLACE_STATE_NEVER_STARTED: case BTRFS_IOCTL_DEV_REPLACE_STATE_FINISHED: case BTRFS_IOCTL_DEV_REPLACE_STATE_CANCELED: btrfs_dev_replace_unlock(dev_replace); return 0; case BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED: break; case BTRFS_IOCTL_DEV_REPLACE_STATE_SUSPENDED: dev_replace->replace_state = BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED; break; } if (!dev_replace->tgtdev || !dev_replace->tgtdev->bdev) { btrfs_info(fs_info, "cannot continue dev_replace, tgtdev is missing"); btrfs_info(fs_info, "you may cancel the operation after 'mount -o degraded'"); btrfs_dev_replace_unlock(dev_replace); return 0; } btrfs_dev_replace_unlock(dev_replace); WARN_ON(atomic_xchg( &fs_info->mutually_exclusive_operation_running, 1)); task = kthread_run(btrfs_dev_replace_kthread, fs_info, "btrfs-devrepl"); return PTR_ERR_OR_ZERO(task); }
static int cpuid_device_create(int cpu) { struct device *dev; dev = device_create(cpuid_class, NULL, MKDEV(CPUID_MAJOR, cpu), NULL, "cpu%d", cpu); return PTR_ERR_OR_ZERO(dev); }
static int msr_device_create(int cpu) { struct device *dev; dev = device_create(msr_class, NULL, MKDEV(MSR_MAJOR, cpu), NULL, "msr%d", cpu); return PTR_ERR_OR_ZERO(dev); }
static int __init iio_sw_device_init(void) { iio_devices_group = configfs_register_default_group(&iio_configfs_subsys.su_group, "devices", &iio_devices_group_type); return PTR_ERR_OR_ZERO(iio_devices_group); }
static int rockchip_dp_phy_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; struct device_node *np = dev->of_node; struct phy_provider *phy_provider; struct rockchip_dp_phy *dp; struct phy *phy; int ret; if (!np) return -ENODEV; if (!dev->parent || !dev->parent->of_node) return -ENODEV; dp = devm_kzalloc(dev, sizeof(*dp), GFP_KERNEL); if (IS_ERR(dp)) return -ENOMEM; dp->dev = dev; dp->phy_24m = devm_clk_get(dev, "24m"); if (IS_ERR(dp->phy_24m)) { dev_err(dev, "cannot get clock 24m\n"); return PTR_ERR(dp->phy_24m); } ret = clk_set_rate(dp->phy_24m, 24000000); if (ret < 0) { dev_err(dp->dev, "cannot set clock phy_24m %d\n", ret); return ret; } dp->grf = syscon_node_to_regmap(dev->parent->of_node); if (IS_ERR(dp->grf)) { dev_err(dev, "rk3288-dp needs the General Register Files syscon\n"); return PTR_ERR(dp->grf); } ret = regmap_write(dp->grf, GRF_SOC_CON12, GRF_EDP_REF_CLK_SEL_INTER | GRF_EDP_REF_CLK_SEL_INTER_HIWORD_MASK); if (ret != 0) { dev_err(dp->dev, "Could not config GRF edp ref clk: %d\n", ret); return ret; } phy = devm_phy_create(dev, np, &rockchip_dp_phy_ops); if (IS_ERR(phy)) { dev_err(dev, "failed to create phy\n"); return PTR_ERR(phy); } phy_set_drvdata(phy, dp); phy_provider = devm_of_phy_provider_register(dev, of_phy_simple_xlate); return PTR_ERR_OR_ZERO(phy_provider); }
static int msm_hdmi_register_audio_driver(struct hdmi *hdmi, struct device *dev) { hdmi->audio_pdev = platform_device_register_data(dev, HDMI_CODEC_DRV_NAME, PLATFORM_DEVID_AUTO, &codec_data, sizeof(codec_data)); return PTR_ERR_OR_ZERO(hdmi->audio_pdev); }
static int __init da8xx_cfgchip_register_div4p5(struct device *dev, struct regmap *regmap) { struct da8xx_cfgchip_gate_clk *gate; gate = da8xx_cfgchip_gate_clk_register(dev, &da8xx_div4p5ena_info, regmap); return PTR_ERR_OR_ZERO(gate); }
int brcms_debugfs_attach(struct brcms_pub *drvr) { if (!root_folder) return -ENODEV; drvr->dbgfs_dir = debugfs_create_dir( dev_name(&drvr->wlc->hw->d11core->dev), root_folder); return PTR_ERR_OR_ZERO(drvr->dbgfs_dir); }
int dss_debugfs_create_file(const char *name, void (*write)(struct seq_file *)) { struct dentry *d; d = debugfs_create_file(name, S_IRUGO, dss_debugfs_dir, write, &dss_debug_fops); return PTR_ERR_OR_ZERO(d); }
static int tmp103_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct device *dev = &client->dev; struct device *hwmon_dev; struct regmap *regmap; int ret; regmap = devm_regmap_init_i2c(client, &tmp103_regmap_config); if (IS_ERR(regmap)) { dev_err(dev, "failed to allocate register map\n"); return PTR_ERR(regmap); } ret = regmap_update_bits(regmap, TMP103_CONF_REG, TMP103_CONFIG_MASK, TMP103_CONFIG); if (ret < 0) { dev_err(&client->dev, "error writing config register\n"); return ret; } i2c_set_clientdata(client, regmap); hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name, regmap, tmp103_groups); return PTR_ERR_OR_ZERO(hwmon_dev); }