static int tegra_w1_probe(struct platform_device *pdev) { struct tegra_w1_platform_data *plat = pdev->dev.platform_data; struct tegra_w1_dev *dev = NULL; int rc; dev_dbg(&pdev->dev, "%s: %p\n", __func__, pdev); if (!plat) { dev_err(&pdev->dev, "no platform data?\n"); return -EINVAL; } dev = kzalloc(sizeof(*dev), GFP_KERNEL); if (!dev) { dev_err(&pdev->dev, "out of memory\n"); return -ENOMEM; } if (NvRmOwrOpen(s_hRmGlobal, pdev->id, &dev->rm_owr) != NvSuccess) { dev_err(&pdev->dev, "unable to open RM One-Wire API\n"); rc = -ENODEV; goto fail; } dev->pin_map = plat->pinmux; dev->pdev = pdev; dev->bus_master.data = dev; dev->bus_master.read_byte = tegra_w1_read_byte; dev->bus_master.write_byte = tegra_w1_write_byte; dev->bus_master.read_bit = tegra_w1_read_bit; dev->bus_master.write_bit = tegra_w1_write_bit; dev->bus_master.touch_bit = tegra_w1_touch_bit; dev->bus_master.reset_bus = tegra_w1_reset_bus; if (tegra_w1_reset_bus(dev)) { dev_err(&pdev->dev, "No device present\n"); rc = -ENODEV; goto fail; } rc = w1_add_master_device(&dev->bus_master); if (rc) { dev_err(&pdev->dev, "failed to add device: %d\n", rc); goto fail; } platform_set_drvdata(pdev, dev); return 0; fail: if (dev) { if (dev->rm_owr) NvRmOwrClose(dev->rm_owr); kfree(dev); } return rc; }
static int mxc_w1_probe(struct platform_device *pdev) { struct mxc_w1_device *mdev; unsigned long clkrate; struct resource *res; unsigned int clkdiv; int err; mdev = devm_kzalloc(&pdev->dev, sizeof(struct mxc_w1_device), GFP_KERNEL); if (!mdev) return -ENOMEM; mdev->clk = devm_clk_get(&pdev->dev, NULL); if (IS_ERR(mdev->clk)) return PTR_ERR(mdev->clk); clkrate = clk_get_rate(mdev->clk); if (clkrate < 10000000) dev_warn(&pdev->dev, "Low clock frequency causes improper function\n"); clkdiv = DIV_ROUND_CLOSEST(clkrate, 1000000); clkrate /= clkdiv; if ((clkrate < 980000) || (clkrate > 1020000)) dev_warn(&pdev->dev, "Incorrect time base frequency %lu Hz\n", clkrate); res = platform_get_resource(pdev, IORESOURCE_MEM, 0); mdev->regs = devm_ioremap_resource(&pdev->dev, res); if (IS_ERR(mdev->regs)) return PTR_ERR(mdev->regs); err = clk_prepare_enable(mdev->clk); if (err) return err; /* Software reset 1-Wire module */ writeb(MXC_W1_RESET_RST, mdev->regs + MXC_W1_RESET); writeb(0, mdev->regs + MXC_W1_RESET); writeb(clkdiv - 1, mdev->regs + MXC_W1_TIME_DIVIDER); mdev->bus_master.data = mdev; mdev->bus_master.reset_bus = mxc_w1_ds2_reset_bus; mdev->bus_master.touch_bit = mxc_w1_ds2_touch_bit; platform_set_drvdata(pdev, mdev); err = w1_add_master_device(&mdev->bus_master); if (err) clk_disable_unprepare(mdev->clk); return err; }
static int __init w1_gpio_probe(struct platform_device *pdev) { struct w1_bus_master *master; struct w1_gpio_platform_data *pdata = pdev->dev.platform_data; int err; if (!pdata) return -ENXIO; master = kzalloc(sizeof(struct w1_bus_master), GFP_KERNEL); if (!master) return -ENOMEM; err = gpio_request(pdata->pin, "w1"); if (err) goto free_master; master->data = pdata; master->read_bit = w1_gpio_read_bit; if (pdata->is_open_drain) { gpio_direction_output(pdata->pin, 1); master->write_bit = w1_gpio_write_bit_val; } else { gpio_direction_input(pdata->pin); master->write_bit = w1_gpio_write_bit_dir; } err = w1_add_master_device(master); if (err) goto free_gpio; if (pdata->enable_external_pullup) pdata->enable_external_pullup(1); platform_set_drvdata(pdev, master); return 0; free_gpio: gpio_free(pdata->pin); free_master: kfree(master); return err; }
static int __init w1_gpio_probe(struct platform_device *pdev) { struct w1_bus_master *master; struct w1_gpio_platform_data *pdata = pdev->dev.platform_data; struct device_node *node; char *key; unsigned int is_open_drain; int ret; int err; if (!pdata) { pr_err("%s: tring to allocate mem for pdata'\n", __func__); pdata = kzalloc(sizeof(struct w1_gpio_platform_data), GFP_KERNEL); if (!pdata) return -ENOMEM; pdev->dev.platform_data =(void *) pdata; } /* parse device tree */ node = pdev->dev.of_node; key = "qcom,gpio-pin"; ret = of_property_read_u32(node, key, &(pdata->pin)); if (ret) { pr_err("%s: missing DT key '%s'\n", __func__, key); goto free_pdata; } key = "qcom,is-open-drain"; ret = of_property_read_u32(node, key, &(is_open_drain)); if (ret) { pr_err("%s: missing DT key '%s'\n", __func__, key); goto free_pdata; } pdata->is_open_drain = is_open_drain?1:0; master = kzalloc(sizeof(struct w1_bus_master), GFP_KERNEL); if (!master) return -ENOMEM; err = gpio_request(pdata->pin, "w1"); if (err) goto free_master; master->data = pdata; master->read_bit = w1_gpio_read_bit; if (pdata->is_open_drain) { gpio_direction_output(pdata->pin, 1); master->write_bit = w1_gpio_write_bit_val; } else { gpio_direction_input(pdata->pin); master->write_bit = w1_gpio_write_bit_dir; } err = w1_add_master_device(master); if (err) goto free_gpio; if (pdata->enable_external_pullup) pdata->enable_external_pullup(1); platform_set_drvdata(pdev, master); return 0; free_gpio: gpio_free(pdata->pin); free_master: kfree(master); free_pdata: kfree(pdata); return err; }
static int __init w1_gpio_probe(struct platform_device *pdev) { struct w1_bus_master *master; struct w1_gpio_platform_data *pdata; struct pinctrl *pinctrl; int err; pinctrl = devm_pinctrl_get_select_default(&pdev->dev); if (IS_ERR(pinctrl)) dev_warn(&pdev->dev, "unable to select pin group\n"); if (of_have_populated_dt()) { err = w1_gpio_probe_dt(pdev); if (err < 0) { dev_err(&pdev->dev, "Failed to parse DT\n"); return err; } } pdata = pdev->dev.platform_data; if (!pdata) { dev_err(&pdev->dev, "No configuration data\n"); return -ENXIO; } master = kzalloc(sizeof(struct w1_bus_master), GFP_KERNEL); if (!master) { dev_err(&pdev->dev, "Out of memory\n"); return -ENOMEM; } err = gpio_request(pdata->pin, "w1"); if (err) { dev_err(&pdev->dev, "gpio_request (pin) failed\n"); goto free_master; } if (gpio_is_valid(pdata->ext_pullup_enable_pin)) { err = gpio_request_one(pdata->ext_pullup_enable_pin, GPIOF_INIT_LOW, "w1 pullup"); if (err < 0) { dev_err(&pdev->dev, "gpio_request_one " "(ext_pullup_enable_pin) failed\n"); goto free_gpio; } } master->data = pdata; master->read_bit = w1_gpio_read_bit; if (pdata->is_open_drain) { gpio_direction_output(pdata->pin, 1); master->write_bit = w1_gpio_write_bit_val; } else { gpio_direction_input(pdata->pin); master->write_bit = w1_gpio_write_bit_dir; } err = w1_add_master_device(master); if (err) { dev_err(&pdev->dev, "w1_add_master device failed\n"); goto free_gpio_ext_pu; } if (pdata->enable_external_pullup) pdata->enable_external_pullup(1); if (gpio_is_valid(pdata->ext_pullup_enable_pin)) gpio_set_value(pdata->ext_pullup_enable_pin, 1); platform_set_drvdata(pdev, master); return 0; free_gpio_ext_pu: if (gpio_is_valid(pdata->ext_pullup_enable_pin)) gpio_free(pdata->ext_pullup_enable_pin); free_gpio: gpio_free(pdata->pin); free_master: kfree(master); return err; }
static int __devinit matrox_w1_probe(struct pci_dev *pdev, const struct pci_device_id *ent) { struct matrox_device *dev; int err; assert(pdev != NULL); assert(ent != NULL); if (pdev->vendor != PCI_VENDOR_ID_MATROX || pdev->device != PCI_DEVICE_ID_MATROX_G400) return -ENODEV; dev = kmalloc(sizeof(struct matrox_device) + sizeof(struct w1_bus_master), GFP_KERNEL); if (!dev) { dev_err(&pdev->dev, "%s: Failed to create new matrox_device object.\n", __func__); return -ENOMEM; } memset(dev, 0, sizeof(struct matrox_device) + sizeof(struct w1_bus_master)); dev->bus_master = (struct w1_bus_master *)(dev + 1); /* * True for G400, for some other we need resource 0, see drivers/video/matrox/matroxfb_base.c */ dev->phys_addr = pci_resource_start(pdev, 1); dev->virt_addr = ioremap_nocache(dev->phys_addr, 16384); if (!dev->virt_addr) { dev_err(&pdev->dev, "%s: failed to ioremap(0x%lx, %d).\n", __func__, dev->phys_addr, 16384); err = -EIO; goto err_out_free_device; } dev->base_addr = dev->virt_addr + MATROX_BASE; dev->port_index = dev->base_addr + MATROX_PORT_INDEX_OFFSET; dev->port_data = dev->base_addr + MATROX_PORT_DATA_OFFSET; dev->data_mask = (MATROX_G400_DDC_DATA); matrox_w1_hw_init(dev); dev->bus_master->data = dev; dev->bus_master->read_bit = &matrox_w1_read_ddc_bit; dev->bus_master->write_bit = &matrox_w1_write_ddc_bit; err = w1_add_master_device(dev->bus_master); if (err) goto err_out_free_device; pci_set_drvdata(pdev, dev); dev->found = 1; dev_info(&pdev->dev, "Matrox G400 GPIO transport layer for 1-wire.\n"); return 0; err_out_free_device: kfree(dev); return err; }
static int ds2482_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct ds2482_data *data; int err = -ENODEV; int temp1; int idx; if (!(data = kzalloc(sizeof(struct ds2482_data), GFP_KERNEL))) { err = -ENOMEM; goto exit; } data->client = client; i2c_set_clientdata(client, data); /* Reset the device (sets the read_ptr to status) */ if (ds2482_send_cmd(data, DS2482_CMD_RESET) < 0) { dev_warn(&client->dev, "DS2482 reset failed.\n"); goto exit_free; } /* Sleep at least 525ns to allow the reset to complete */ ndelay(525); /* Read the status byte - only reset bit and line should be set */ temp1 = i2c_smbus_read_byte(client); if (temp1 != (DS2482_REG_STS_LL | DS2482_REG_STS_RST)) { dev_warn(&client->dev, "DS2482 reset status " "0x%02X - not a DS2482\n", temp1); goto exit_free; } /* Detect the 8-port version */ data->w1_count = 1; if (ds2482_set_channel(data, 7) == 0) data->w1_count = 8; /* Set all config items to 0 (off) */ ds2482_send_cmd_data(data, DS2482_CMD_WRITE_CONFIG, 0xF0); mutex_init(&data->access_lock); /* Register 1-wire interface(s) */ for (idx = 0; idx < data->w1_count; idx++) { data->w1_ch[idx].pdev = data; data->w1_ch[idx].channel = idx; /* Populate all the w1 bus master stuff */ data->w1_ch[idx].w1_bm.data = &data->w1_ch[idx]; data->w1_ch[idx].w1_bm.read_byte = ds2482_w1_read_byte; data->w1_ch[idx].w1_bm.write_byte = ds2482_w1_write_byte; data->w1_ch[idx].w1_bm.touch_bit = ds2482_w1_touch_bit; data->w1_ch[idx].w1_bm.triplet = ds2482_w1_triplet; data->w1_ch[idx].w1_bm.reset_bus = ds2482_w1_reset_bus; err = w1_add_master_device(&data->w1_ch[idx].w1_bm); if (err) { data->w1_ch[idx].pdev = NULL; goto exit_w1_remove; } } return 0; exit_w1_remove: for (idx = 0; idx < data->w1_count; idx++) { if (data->w1_ch[idx].pdev != NULL) w1_remove_master_device(&data->w1_ch[idx].w1_bm); } exit_free: kfree(data); exit: return err; }
static int w1_gpio_msm_probe(struct platform_device *pdev) { struct w1_bus_master *master; struct w1_gpio_msm_platform_data *pdata; int err; printk(KERN_ERR "\nw1_gpio_msm_probe start\n"); if (of_have_populated_dt()) { err = w1_gpio_msm_probe_dt(pdev); if (err < 0) { dev_err(&pdev->dev, "Failed to parse DT\n"); return err; } } pdata = pdev->dev.platform_data; if (!pdata) { dev_err(&pdev->dev, "No configuration data\n"); return -ENXIO; } master = kzalloc(sizeof(struct w1_bus_master), GFP_KERNEL); if (!master) { dev_err(&pdev->dev, "Out of memory\n"); return -ENOMEM; } spin_lock_init(&w1_gpio_msm_lock); err = gpio_request(pdata->pin, "w1"); if (err) { dev_err(&pdev->dev, "gpio_request (pin) failed\n"); goto free_master; } if (gpio_is_valid(pdata->ext_pullup_enable_pin)) { err = gpio_request_one(pdata->ext_pullup_enable_pin, GPIOF_INIT_LOW, "w1 pullup"); if (err < 0) { dev_err(&pdev->dev, "gpio_request_one " "(ext_pullup_enable_pin) failed\n"); goto free_gpio; } } master->data = pdata; master->read_bit = w1_gpio_read_bit_val; master->touch_bit = w1_gpio_touch_bit; master->read_byte = w1_gpio_read_8; master->write_byte = w1_gpio_write_8; master->read_block = w1_gpio_read_block; master->write_block = w1_gpio_write_block; master->triplet = w1_gpio_triplet; master->reset_bus = w1_gpio_reset_bus; master->set_pullup = w1_gpio_set_pullup; if (pdata->is_open_drain) { gpio_direction_output(pdata->pin, 1); master->write_bit = w1_gpio_write_bit_val; } else { gpio_direction_input(pdata->pin); master->write_bit = w1_gpio_write_bit_dir; } err = w1_add_master_device(master); if (err) { dev_err(&pdev->dev, "w1_add_master device failed\n"); goto free_gpio_ext_pu; } if (pdata->enable_external_pullup) pdata->enable_external_pullup(1); if (gpio_is_valid(pdata->ext_pullup_enable_pin)) gpio_set_value_msm(pdata->ext_pullup_enable_pin, 1); platform_set_drvdata(pdev, master); return 0; free_gpio_ext_pu: if (gpio_is_valid(pdata->ext_pullup_enable_pin)) gpio_free(pdata->ext_pullup_enable_pin); free_gpio: gpio_free(pdata->pin); free_master: kfree(master); return err; }
static int w1_gpio_msm_probe(struct platform_device *pdev) { struct w1_bus_master *master; struct w1_gpio_msm_platform_data *pdata; struct input_dev *input; int err; int ret, irq; int temp_irq; printk(KERN_ERR "\nw1_gpio_msm_probe start\n"); if (of_have_populated_dt()) { err = w1_gpio_msm_probe_dt(pdev); if (err < 0) { dev_err(&pdev->dev, "Failed to parse DT\n"); return err; } } pdata = pdev->dev.platform_data; if (!pdata) { dev_err(&pdev->dev, "No configuration data\n"); return -ENXIO; } master = kzalloc(sizeof(struct w1_bus_master), GFP_KERNEL); if (!master) { dev_err(&pdev->dev, "Out of memory\n"); return -ENOMEM; } temp_irq = pdata->irq_gpio; if (temp_irq >= 0) { pr_info("%s: IRQ mode is enabled\n", __func__); irq = gpio_to_irq(pdata->irq_gpio); INIT_DELAYED_WORK(&master->w1_irqwork, w1_irqwork); schedule_delayed_work(&master->w1_irqwork, 10); master->irq_mode=true; } /* add for sending uevent */ input = input_allocate_device(); if (!input) { err = -ENODEV; goto free_master; /* need to change*/ } master->input = input; input_set_drvdata(input, master); input->name = "w1"; input->phys = "w1"; input->dev.parent = &pdev->dev; input->evbit[0] |= BIT_MASK(EV_SW); input_set_capability(input, EV_SW, SW_W1); input->open = hall_open; input->close = hall_close; /* Enable auto repeat feature of Linux input subsystem */ __set_bit(EV_REP, input->evbit); err = input_register_device(input); if(err) { dev_err(&pdev->dev, "input_register_device failed!\n"); goto free_input; } spin_lock_init(&w1_gpio_msm_lock); err = gpio_request(pdata->pin, "w1"); if (err) { dev_err(&pdev->dev, "gpio_request (pin) failed\n"); goto free_input; } if (gpio_is_valid(pdata->ext_pullup_enable_pin)) { err = gpio_request_one(pdata->ext_pullup_enable_pin, GPIOF_INIT_LOW, "w1 pullup"); if (err < 0) { dev_err(&pdev->dev, "gpio_request_one " "(ext_pullup_enable_pin) failed\n"); goto free_gpio; } } master->data = pdata; master->read_bit = w1_gpio_read_bit_val; master->touch_bit = w1_gpio_touch_bit; master->read_byte = w1_gpio_read_8; master->write_byte = w1_gpio_write_8; master->read_block = w1_gpio_read_block; master->write_block = w1_gpio_write_block; master->triplet = w1_gpio_triplet; master->reset_bus = w1_gpio_reset_bus; master->set_pullup = w1_gpio_set_pullup; if (pdata->is_open_drain) { gpio_direction_output(pdata->pin, 1); master->write_bit = w1_gpio_write_bit_val; } else { gpio_direction_input(pdata->pin); master->write_bit = w1_gpio_write_bit_dir; } err = w1_add_master_device(master); if (err) { dev_err(&pdev->dev, "w1_add_master device failed\n"); goto free_gpio_ext_pu; } if (master->irq_mode) { REQUEST_IRQ(irq, "w1-detect"); enable_irq_wake(irq); } if (pdata->enable_external_pullup) pdata->enable_external_pullup(1); if (gpio_is_valid(pdata->ext_pullup_enable_pin)) gpio_set_value_msm(pdata->ext_pullup_enable_pin, 1); platform_set_drvdata(pdev, master); return 0; free_gpio_ext_pu: if (gpio_is_valid(pdata->ext_pullup_enable_pin)) gpio_free(pdata->ext_pullup_enable_pin); free_gpio: gpio_free(pdata->pin); free_input: kfree(input); free_master: kfree(master); return err; }
static int w1_gpio_probe(struct platform_device *pdev) { struct w1_bus_master *master; struct w1_gpio_platform_data *pdata = pdev->dev.platform_data; int err; if(pdata == NULL) { if (of_have_populated_dt()) { err = w1_gpio_probe_dt(pdev); if (err < 0) return err; } } pdata = dev_get_platdata(&pdev->dev); if (!pdata) { dev_err(&pdev->dev, "No configuration data\n"); return -ENXIO; } master = devm_kzalloc(&pdev->dev, sizeof(struct w1_bus_master), GFP_KERNEL); if (!master) { dev_err(&pdev->dev, "Out of memory\n"); return -ENOMEM; } w1_gpio_pin_orig = pdata->pin; w1_gpio_pullup_pin_orig = pdata->ext_pullup_enable_pin; w1_gpio_pullup_orig = pdata->parasitic_power; if(gpio_is_valid(w1_gpio_pin)) { pdata->pin = w1_gpio_pin; pdata->ext_pullup_enable_pin = -1; pdata->parasitic_power = -1; } pdata->parasitic_power |= w1_gpio_pullup; if(gpio_is_valid(w1_gpio_pullup_pin)) { pdata->ext_pullup_enable_pin = w1_gpio_pullup_pin; } dev_info(&pdev->dev, "gpio pin %d, external pullup pin %d, parasitic power %d\n", pdata->pin, pdata->ext_pullup_enable_pin, pdata->parasitic_power); err = devm_gpio_request(&pdev->dev, pdata->pin, "w1"); if (err) { dev_err(&pdev->dev, "gpio_request (pin) failed\n"); return err; } if (gpio_is_valid(pdata->ext_pullup_enable_pin)) { err = devm_gpio_request_one(&pdev->dev, pdata->ext_pullup_enable_pin, GPIOF_INIT_LOW, "w1 pullup"); if (err < 0) { dev_err(&pdev->dev, "gpio_request_one " "(ext_pullup_enable_pin) failed\n"); return err; } } master->data = pdata; master->read_bit = w1_gpio_read_bit; if (pdata->is_open_drain) { gpio_direction_output(pdata->pin, 1); master->write_bit = w1_gpio_write_bit_val; } else { gpio_direction_input(pdata->pin); master->write_bit = w1_gpio_write_bit_dir; master->set_pullup = w1_gpio_set_pullup; } if (pdata->parasitic_power) { if (pdata->is_open_drain) printk(KERN_ERR "w1-gpio 'pullup'(parasitic power) " "option doesn't work with open drain GPIO\n"); else master->bitbang_pullup = w1_gpio_bitbang_pullup; } err = w1_add_master_device(master); if (err) { dev_err(&pdev->dev, "w1_add_master device failed\n"); return err; } if (pdata->enable_external_pullup) pdata->enable_external_pullup(1); if (gpio_is_valid(pdata->ext_pullup_enable_pin)) gpio_set_value(pdata->ext_pullup_enable_pin, 1); platform_set_drvdata(pdev, master); return 0; }
static int w1_gpio_probe(struct platform_device *pdev) { struct w1_bus_master *master; struct w1_gpio_platform_data *pdata; struct pinctrl *pinctrl; int err; pinctrl = devm_pinctrl_get_select_default(&pdev->dev); if (IS_ERR(pinctrl)) dev_warn(&pdev->dev, "unable to select pin group\n"); if (of_have_populated_dt()) { err = w1_gpio_probe_dt(pdev); if (err < 0) { dev_err(&pdev->dev, "Failed to parse DT\n"); return err; } } pdata = pdev->dev.platform_data; if (!pdata) { dev_err(&pdev->dev, "No configuration data\n"); return -ENXIO; } master = kzalloc(sizeof(struct w1_bus_master), GFP_KERNEL); if (!master) { dev_err(&pdev->dev, "Out of memory\n"); return -ENOMEM; } err = gpio_request(pdata->pin, "w1"); if (err) { dev_err(&pdev->dev, "gpio_request (pin) failed\n"); goto free_master; } if (gpio_is_valid(pdata->ext_pullup_enable_pin)) { err = gpio_request_one(pdata->ext_pullup_enable_pin, GPIOF_INIT_LOW, "w1 pullup"); if (err < 0) { dev_err(&pdev->dev, "gpio_request_one " "(ext_pullup_enable_pin) failed\n"); goto free_gpio; } } master->data = pdata; master->read_bit = w1_gpio_read_bit; if (pdata->is_open_drain) { gpio_direction_output(pdata->pin, 1); master->write_bit = w1_gpio_write_bit_val; } else { gpio_direction_input(pdata->pin); master->write_bit = w1_gpio_write_bit_dir; } err = w1_add_master_device(master); if (err) { dev_err(&pdev->dev, "w1_add_master device failed\n"); goto free_gpio_ext_pu; } /* voltage regulator support */ pdata->regulator_en = 0; pdata->w1_gpio_vdd = regulator_get(&pdev->dev, "w1_vdd"); if (IS_ERR(pdata->w1_gpio_vdd)) { pdata->w1_gpio_vdd = NULL; dev_err(&pdev->dev, "%s: Failed to get w1_vdd regulator\n", __func__); } else { dev_err(&pdev->dev, "w1-vdd regulator is initially %s\n", regulator_is_enabled(pdata->w1_gpio_vdd) ? "on" : "off"); err = regulator_enable(pdata->w1_gpio_vdd); if (err) { pr_err("%s: Error %d enabling w1-vdd regulator\n", __func__, err); goto free_regulator; } else { pdata->regulator_en = 1; } } if (pdata->enable_external_pullup) pdata->enable_external_pullup(1); if (gpio_is_valid(pdata->ext_pullup_enable_pin)) gpio_set_value(pdata->ext_pullup_enable_pin, 1); platform_set_drvdata(pdev, master); return 0; free_regulator: if (pdata->w1_gpio_vdd != NULL) regulator_put(pdata->w1_gpio_vdd); free_gpio_ext_pu: if (gpio_is_valid(pdata->ext_pullup_enable_pin)) gpio_free(pdata->ext_pullup_enable_pin); free_gpio: gpio_free(pdata->pin); free_master: kfree(master); return err; }
static int w1_gpio_probe(struct platform_device *pdev) { struct w1_bus_master *master; struct w1_gpio_platform_data *pdata; int err; if (of_have_populated_dt()) { err = w1_gpio_probe_dt(pdev); if (err < 0) return err; } pdata = dev_get_platdata(&pdev->dev); if (!pdata) { dev_err(&pdev->dev, "No configuration data\n"); return -ENXIO; } master = devm_kzalloc(&pdev->dev, sizeof(struct w1_bus_master), GFP_KERNEL); if (!master) { dev_err(&pdev->dev, "Out of memory\n"); return -ENOMEM; } err = devm_gpio_request(&pdev->dev, pdata->pin, "w1"); if (err) { dev_err(&pdev->dev, "gpio_request (pin) failed\n"); return err; } if (gpio_is_valid(pdata->ext_pullup_enable_pin)) { err = devm_gpio_request_one(&pdev->dev, pdata->ext_pullup_enable_pin, GPIOF_INIT_LOW, "w1 pullup"); if (err < 0) { dev_err(&pdev->dev, "gpio_request_one " "(ext_pullup_enable_pin) failed\n"); return err; } } master->data = pdata; master->read_bit = w1_gpio_read_bit; if (pdata->is_open_drain) { gpio_direction_output(pdata->pin, 1); master->write_bit = w1_gpio_write_bit_val; } else { gpio_direction_input(pdata->pin); master->write_bit = w1_gpio_write_bit_dir; master->set_pullup = w1_gpio_set_pullup; } err = w1_add_master_device(master); if (err) { dev_err(&pdev->dev, "w1_add_master device failed\n"); return err; } if (pdata->enable_external_pullup) pdata->enable_external_pullup(1); if (gpio_is_valid(pdata->ext_pullup_enable_pin)) gpio_set_value(pdata->ext_pullup_enable_pin, 1); platform_set_drvdata(pdev, master); return 0; }