static int adis16260_probe(struct spi_device *spi) { struct iio_dev *indio_dev; struct adis *adis; int ret; /* setup the industrialio driver allocated elements */ indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*adis)); if (!indio_dev) return -ENOMEM; adis = iio_priv(indio_dev); /* this is only used for removal purposes */ spi_set_drvdata(spi, indio_dev); indio_dev->name = spi_get_device_id(spi)->name; indio_dev->dev.parent = &spi->dev; indio_dev->info = &adis16260_info; indio_dev->channels = adis16260_channels; indio_dev->num_channels = ARRAY_SIZE(adis16260_channels); indio_dev->modes = INDIO_DIRECT_MODE; ret = adis_init(adis, indio_dev, spi, &adis16260_data); if (ret) return ret; ret = adis_setup_buffer_and_trigger(adis, indio_dev, NULL); if (ret) return ret; /* Get the device into a sane initial state */ ret = adis_initial_startup(adis); if (ret) goto error_cleanup_buffer_trigger; ret = iio_device_register(indio_dev); if (ret) goto error_cleanup_buffer_trigger; return 0; error_cleanup_buffer_trigger: adis_cleanup_buffer_and_trigger(adis, indio_dev); return ret; }
static int __devinit ad1836_spi_probe(struct spi_device *spi) { struct ad1836_priv *ad1836; int ret; ad1836 = kzalloc(sizeof(struct ad1836_priv), GFP_KERNEL); if (ad1836 == NULL) return -ENOMEM; ad1836->type = spi_get_device_id(spi)->driver_data; spi_set_drvdata(spi, ad1836); ret = snd_soc_register_codec(&spi->dev, &soc_codec_dev_ad1836, &ad183x_dais[ad1836->type], 1); if (ret < 0) kfree(ad1836); return ret; }
static int __devinit arizona_spi_probe(struct spi_device *spi) { const struct spi_device_id *id = spi_get_device_id(spi); struct arizona *arizona; const struct regmap_config *regmap_config; int ret; switch (id->driver_data) { #ifdef CONFIG_MFD_WM5102 case WM5102: regmap_config = &wm5102_spi_regmap; break; #endif #ifdef CONFIG_MFD_WM5110 case WM5110: regmap_config = &wm5110_spi_regmap; break; #endif default: dev_err(&spi->dev, "Unknown device type %ld\n", id->driver_data); return -EINVAL; } arizona = devm_kzalloc(&spi->dev, sizeof(*arizona), GFP_KERNEL); if (arizona == NULL) return -ENOMEM; arizona->regmap = devm_regmap_init_spi(spi, regmap_config); if (IS_ERR(arizona->regmap)) { ret = PTR_ERR(arizona->regmap); dev_err(&spi->dev, "Failed to allocate register map: %d\n", ret); return ret; } arizona->type = id->driver_data; arizona->dev = &spi->dev; arizona->irq = spi->irq; return arizona_dev_init(arizona); }
static int __devinit da9052_spi_probe(struct spi_device *spi) { int ret; const struct spi_device_id *id = spi_get_device_id(spi); struct da9052 *da9052 = kzalloc(sizeof(struct da9052), GFP_KERNEL); if (!da9052) return -ENOMEM; spi->mode = SPI_MODE_0 | SPI_CPOL; spi->bits_per_word = 8; spi_setup(spi); da9052->dev = &spi->dev; da9052->chip_irq = spi->irq; dev_set_drvdata(&spi->dev, da9052); da9052_regmap_config.read_flag_mask = 1; da9052_regmap_config.write_flag_mask = 0; da9052->regmap = regmap_init_spi(spi, &da9052_regmap_config); if (IS_ERR(da9052->regmap)) { ret = PTR_ERR(da9052->regmap); dev_err(&spi->dev, "Failed to allocate register map: %d\n", ret); goto err; } ret = da9052_device_init(da9052, id->driver_data); if (ret != 0) goto err_regmap; return 0; err_regmap: regmap_exit(da9052->regmap); err: kfree(da9052); return ret; }
int adis16260_probe_trigger(struct iio_dev *indio_dev) { int ret; struct adis16260_state *st = indio_dev->dev_data; st->trig = iio_allocate_trigger("%s-dev%d", spi_get_device_id(st->us)->name, indio_dev->id); if (st->trig == NULL) { ret = -ENOMEM; goto error_ret; } ret = request_irq(st->us->irq, &iio_trigger_generic_data_rdy_poll, IRQF_TRIGGER_RISING, "adis16260", st->trig); if (ret) goto error_free_trig; st->trig->dev.parent = &st->us->dev; st->trig->owner = THIS_MODULE; st->trig->private_data = st; st->trig->set_trigger_state = &adis16260_data_rdy_trigger_set_state; ret = iio_trigger_register(st->trig); /* select default trigger */ indio_dev->trig = st->trig; if (ret) goto error_free_irq; return 0; error_free_irq: free_irq(st->us->irq, st->trig); error_free_trig: iio_free_trigger(st->trig); error_ret: return ret; }
static int ad1836_spi_probe(struct spi_device *spi) { struct ad1836_priv *ad1836; int ret; ad1836 = devm_kzalloc(&spi->dev, sizeof(struct ad1836_priv), GFP_KERNEL); if (ad1836 == NULL) return -ENOMEM; ad1836->regmap = devm_regmap_init_spi(spi, &ad1836_regmap_config); if (IS_ERR(ad1836->regmap)) return PTR_ERR(ad1836->regmap); ad1836->type = spi_get_device_id(spi)->driver_data; spi_set_drvdata(spi, ad1836); ret = snd_soc_register_codec(&spi->dev, &soc_codec_dev_ad1836, &ad183x_dais[ad1836->type], 1); return ret; }
int ad7476_register_ring_funcs_and_init(struct iio_dev *indio_dev) { struct ad7476_state *st = iio_priv(indio_dev); int ret = 0; indio_dev->ring = iio_sw_rb_allocate(indio_dev); if (!indio_dev->ring) { ret = -ENOMEM; goto error_ret; } /* Effectively select the ring buffer implementation */ indio_dev->ring->access = &ring_sw_access_funcs; indio_dev->pollfunc = iio_alloc_pollfunc(NULL, &ad7476_trigger_handler, IRQF_ONESHOT, indio_dev, "%s_consumer%d", spi_get_device_id(st->spi)->name, indio_dev->id); if (indio_dev->pollfunc == NULL) { ret = -ENOMEM; goto error_deallocate_sw_rb; } /* Ring buffer functions - here trigger setup related */ indio_dev->ring->setup_ops = &ad7476_ring_setup_ops; indio_dev->ring->scan_timestamp = true; /* Flag that polled ring buffering is possible */ indio_dev->modes |= INDIO_RING_TRIGGERED; return 0; error_deallocate_sw_rb: iio_sw_rb_free(indio_dev->ring); error_ret: return ret; }
static int adc128_probe(struct spi_device *spi) { struct iio_dev *indio_dev; struct adc128 *adc; int ret; indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*adc)); if (!indio_dev) return -ENOMEM; adc = iio_priv(indio_dev); adc->spi = spi; spi_set_drvdata(spi, indio_dev); indio_dev->dev.parent = &spi->dev; indio_dev->name = spi_get_device_id(spi)->name; indio_dev->modes = INDIO_DIRECT_MODE; indio_dev->info = &adc128_info; indio_dev->channels = adc128_channels; indio_dev->num_channels = ARRAY_SIZE(adc128_channels); adc->reg = devm_regulator_get(&spi->dev, "vref"); if (IS_ERR(adc->reg)) return PTR_ERR(adc->reg); ret = regulator_enable(adc->reg); if (ret < 0) return ret; mutex_init(&adc->lock); ret = iio_device_register(indio_dev); return ret; }
static int da9052_spi_probe(struct spi_device *spi) { struct regmap_config config; int ret; const struct spi_device_id *id = spi_get_device_id(spi); struct da9052 *da9052; da9052 = devm_kzalloc(&spi->dev, sizeof(struct da9052), GFP_KERNEL); if (!da9052) return -ENOMEM; spi->mode = SPI_MODE_0; spi->bits_per_word = 8; spi_setup(spi); da9052->dev = &spi->dev; da9052->chip_irq = spi->irq; spi_set_drvdata(spi, da9052); config = da9052_regmap_config; config.read_flag_mask = 1; config.reg_bits = 7; config.pad_bits = 1; config.val_bits = 8; config.use_single_rw = 1; da9052->regmap = devm_regmap_init_spi(spi, &config); if (IS_ERR(da9052->regmap)) { ret = PTR_ERR(da9052->regmap); dev_err(&spi->dev, "Failed to allocate register map: %d\n", ret); return ret; } return da9052_device_init(da9052, id->driver_data); }
static int ad7298_probe(struct spi_device *spi) { struct ad7298_platform_data *pdata = spi->dev.platform_data; struct ad7298_state *st; struct iio_dev *indio_dev = iio_device_alloc(sizeof(*st)); int ret; if (indio_dev == NULL) return -ENOMEM; st = iio_priv(indio_dev); if (pdata && pdata->ext_ref) st->ext_ref = AD7298_EXTREF; if (st->ext_ref) { st->reg = regulator_get(&spi->dev, "vref"); if (IS_ERR(st->reg)) { ret = PTR_ERR(st->reg); goto error_free; } ret = regulator_enable(st->reg); if (ret) goto error_put_reg; } spi_set_drvdata(spi, indio_dev); st->spi = spi; indio_dev->name = spi_get_device_id(spi)->name; indio_dev->dev.parent = &spi->dev; indio_dev->modes = INDIO_DIRECT_MODE; indio_dev->channels = ad7298_channels; indio_dev->num_channels = ARRAY_SIZE(ad7298_channels); indio_dev->info = &ad7298_info; /* Setup default message */ st->scan_single_xfer[0].tx_buf = &st->tx_buf[0]; st->scan_single_xfer[0].len = 2; st->scan_single_xfer[0].cs_change = 1; st->scan_single_xfer[1].tx_buf = &st->tx_buf[1]; st->scan_single_xfer[1].len = 2; st->scan_single_xfer[1].cs_change = 1; st->scan_single_xfer[2].rx_buf = &st->rx_buf[0]; st->scan_single_xfer[2].len = 2; spi_message_init(&st->scan_single_msg); spi_message_add_tail(&st->scan_single_xfer[0], &st->scan_single_msg); spi_message_add_tail(&st->scan_single_xfer[1], &st->scan_single_msg); spi_message_add_tail(&st->scan_single_xfer[2], &st->scan_single_msg); ret = iio_triggered_buffer_setup(indio_dev, NULL, &ad7298_trigger_handler, NULL); if (ret) goto error_disable_reg; ret = iio_device_register(indio_dev); if (ret) goto error_cleanup_ring; return 0; error_cleanup_ring: iio_triggered_buffer_cleanup(indio_dev); error_disable_reg: if (st->ext_ref) regulator_disable(st->reg); error_put_reg: if (st->ext_ref) regulator_put(st->reg); error_free: iio_device_free(indio_dev); return ret; }
static int ad5504_probe(struct spi_device *spi) { struct ad5504_platform_data *pdata = spi->dev.platform_data; struct iio_dev *indio_dev; struct ad5504_state *st; struct regulator *reg; int ret, voltage_uv = 0; indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*st)); if (!indio_dev) return -ENOMEM; reg = devm_regulator_get(&spi->dev, "vcc"); if (!IS_ERR(reg)) { ret = regulator_enable(reg); if (ret) return ret; ret = regulator_get_voltage(reg); if (ret < 0) goto error_disable_reg; voltage_uv = ret; } spi_set_drvdata(spi, indio_dev); st = iio_priv(indio_dev); if (voltage_uv) st->vref_mv = voltage_uv / 1000; else if (pdata) st->vref_mv = pdata->vref_mv; else dev_warn(&spi->dev, "reference voltage unspecified\n"); st->reg = reg; st->spi = spi; indio_dev->dev.parent = &spi->dev; indio_dev->name = spi_get_device_id(st->spi)->name; indio_dev->info = &ad5504_info; if (spi_get_device_id(st->spi)->driver_data == ID_AD5501) indio_dev->num_channels = 1; else indio_dev->num_channels = 4; indio_dev->channels = ad5504_channels; indio_dev->modes = INDIO_DIRECT_MODE; if (spi->irq) { ret = devm_request_threaded_irq(&spi->dev, spi->irq, NULL, &ad5504_event_handler, IRQF_TRIGGER_FALLING | IRQF_ONESHOT, spi_get_device_id(st->spi)->name, indio_dev); if (ret) goto error_disable_reg; } ret = iio_device_register(indio_dev); if (ret) goto error_disable_reg; return 0; error_disable_reg: if (!IS_ERR(reg)) regulator_disable(reg); return ret; }
static int __devinit st7586fb_probe (struct spi_device *spi) { int chip = spi_get_device_id(spi)->driver_data; struct st7586fb_platform_data *pdata = spi->dev.platform_data; int vmem_size = (WIDTH + 2) / 3 * HEIGHT; u8 *vmem; struct fb_info *info; struct st7586fb_par *par; int retval = -ENOMEM; if (chip != ST7586_DISPLAY_LEGO_EV3) { pr_err("%s: only the %s device is supported\n", DRVNAME, to_spi_driver(spi->dev.driver)->id_table->name); return -EINVAL; } if (!pdata) { pr_err("%s: platform data required for rst and a0 info\n", DRVNAME); return -EINVAL; } vmem = (u8 *)kmalloc(vmem_size, GFP_KERNEL); if (!vmem) return retval; // Zero memory for easy detection if any new data has been written to screenbuffer memset(vmem, 0, vmem_size); info = framebuffer_alloc(sizeof(struct st7586fb_par), &spi->dev); if (!info) goto fballoc_fail; info->screen_base = vmem; info->fbops = &st7586fb_ops; info->fix = st7586fb_fix; info->fix.smem_start = virt_to_phys(vmem); info->fix.smem_len = vmem_size; info->var = st7586fb_var; info->var.red.offset = 0; info->var.red.length = 1; info->var.green.offset = 0; info->var.green.length = 1; info->var.blue.offset = 0; info->var.blue.length = 1; info->var.transp.offset = 0; info->var.transp.length = 0; info->flags = FBINFO_FLAG_DEFAULT | FBINFO_VIRTFB; info->fbdefio = &st7586fb_defio; fb_deferred_io_init(info); par = info->par; par->info = info; par->spi = spi; par->rst = pdata->rst_gpio; par->a0 = pdata->a0_gpio; par->cs = pdata->cs_gpio; par->buf = kmalloc(1, GFP_KERNEL); INIT_DELAYED_WORK(&par->dwork, st7586fb_deferred_work); retval = register_framebuffer(info); if (retval < 0) goto fbreg_fail; spi_set_drvdata(spi, info); retval = st7586fb_request_gpios(par); // Move initing of display to ioctl call to avoid dispaly flickering // as dispaly has already been inited in uboot // retval |= st7586fb_init_display(par); if (retval < 0) goto init_fail; printk(KERN_INFO "fb%d: %s frame buffer device, using %d.%d KiB of video memory\n", info->node, info->fix.id, vmem_size / 1024, vmem_size % 1024 * 10 / 1024); return 0; init_fail: spi_set_drvdata(spi, NULL); fbreg_fail: kfree(par->buf); framebuffer_release(info); fballoc_fail: kfree(vmem); return retval; }
static int arizona_spi_probe(struct spi_device *spi) { const struct spi_device_id *id = spi_get_device_id(spi); struct arizona *arizona; const struct regmap_config *regmap_config; const struct regmap_config *regmap_32bit_config = NULL; unsigned long type; int ret; if (spi->dev.of_node) type = arizona_of_get_type(&spi->dev); else type = id->driver_data; switch (type) { #ifdef CONFIG_MFD_WM5102 case WM5102: regmap_config = &wm5102_spi_regmap; break; #endif #ifdef CONFIG_MFD_FLORIDA case WM8280: case WM5110: regmap_config = &florida_spi_regmap; break; #endif #ifdef CONFIG_MFD_CLEARWATER case WM8285: case WM1840: regmap_config = &clearwater_16bit_spi_regmap; regmap_32bit_config = &clearwater_32bit_spi_regmap; break; #endif #ifdef CONFIG_MFD_LARGO case WM1831: case CS47L24: regmap_config = &largo_spi_regmap; break; #endif #ifdef CONFIG_MFD_MARLEY case CS47L35: regmap_config = &marley_16bit_spi_regmap; regmap_32bit_config = &marley_32bit_spi_regmap; break; #endif #ifdef CONFIG_MFD_MOON case CS47L90: case CS47L91: regmap_config = &moon_16bit_spi_regmap; regmap_32bit_config = &moon_32bit_spi_regmap; break; #endif default: dev_err(&spi->dev, "Unknown device type %ld\n", id->driver_data); return -EINVAL; } arizona = devm_kzalloc(&spi->dev, sizeof(*arizona), GFP_KERNEL); if (arizona == NULL) return -ENOMEM; arizona->regmap = devm_regmap_init_spi(spi, regmap_config); if (IS_ERR(arizona->regmap)) { ret = PTR_ERR(arizona->regmap); dev_err(&spi->dev, "Failed to allocate register map: %d\n", ret); return ret; } if (regmap_32bit_config) { arizona->regmap_32bit = devm_regmap_init_spi(spi, regmap_32bit_config); if (IS_ERR(arizona->regmap_32bit)) { ret = PTR_ERR(arizona->regmap_32bit); dev_err(&spi->dev, "Failed to allocate dsp register map: %d\n", ret); return ret; } } arizona->type = id->driver_data; arizona->dev = &spi->dev; arizona->irq = spi->irq; return arizona_dev_init(arizona); }
static int adc1x8s102_probe(struct spi_device *spi) { struct adc1x8s102_platform_data *pdata = spi->dev.platform_data; struct adc1x8s102_state *st; struct iio_dev *indio_dev = iio_device_alloc(sizeof(*st)); int ret; if (NULL == indio_dev) { dev_crit(&spi->dev, "Cannot allocate memory for indio_dev\n"); return -ENOMEM; } st = iio_priv(indio_dev); if (NULL == pdata) { dev_err(&spi->dev, "Cannot get adc1x8s102 platform data\n"); return -EFAULT; } st->ext_vin = pdata->ext_vin; /* Use regulator, if available. */ st->reg = regulator_get(&spi->dev, "vref"); if (IS_ERR(st->reg)) { ret = PTR_ERR(st->reg); dev_warn(&spi->dev, "Cannot get 'vref' regulator\n"); goto error_free; } ret = regulator_enable(st->reg); if (ret < 0) { dev_warn(&spi->dev, "Cannot enable vref regulator\n"); goto error_put_reg; } spi_set_drvdata(spi, indio_dev); st->spi = spi; indio_dev->name = spi_get_device_id(spi)->name; indio_dev->dev.parent = &spi->dev; indio_dev->modes = INDIO_DIRECT_MODE; indio_dev->channels = adc1x8s102_channels; indio_dev->num_channels = ARRAY_SIZE(adc1x8s102_channels); indio_dev->info = &adc1x8s102_info; /* Setup default message */ st->scan_single_xfer.tx_buf = st->tx_buf; st->scan_single_xfer.rx_buf = st->rx_buf; st->scan_single_xfer.len = 2 * sizeof(__be16); st->scan_single_xfer.cs_change = 0; spi_message_init(&st->scan_single_msg); spi_message_add_tail(&st->scan_single_xfer, &st->scan_single_msg); ret = iio_triggered_buffer_setup(indio_dev, NULL, &adc1x8s102_trigger_handler, NULL); if (ret) goto error_disable_reg; ret = iio_device_register(indio_dev); if (ret) { dev_err(&spi->dev, "Failed to register IIO device\n"); goto error_cleanup_ring; } return 0; error_cleanup_ring: iio_triggered_buffer_cleanup(indio_dev); error_disable_reg: regulator_disable(st->reg); error_put_reg: regulator_put(st->reg); error_free: iio_device_free(indio_dev); return ret; }
static int __devinit ad9834_probe(struct spi_device *spi) { struct ad9834_platform_data *pdata = spi->dev.platform_data; struct ad9834_state *st; struct iio_dev *indio_dev; struct regulator *reg; int ret; if (!pdata) { dev_dbg(&spi->dev, "no platform data?\n"); return -ENODEV; } reg = regulator_get(&spi->dev, "vcc"); if (!IS_ERR(reg)) { ret = regulator_enable(reg); if (ret) goto error_put_reg; } indio_dev = iio_allocate_device(sizeof(*st)); if (indio_dev == NULL) { ret = -ENOMEM; goto error_disable_reg; } spi_set_drvdata(spi, indio_dev); st = iio_priv(indio_dev); st->mclk = pdata->mclk; st->spi = spi; st->devid = spi_get_device_id(spi)->driver_data; st->reg = reg; indio_dev->dev.parent = &spi->dev; indio_dev->name = spi_get_device_id(spi)->name; switch (st->devid) { case ID_AD9833: case ID_AD9837: indio_dev->info = &ad9833_info; break; default: indio_dev->info = &ad9834_info; break; } indio_dev->modes = INDIO_DIRECT_MODE; /* Setup default messages */ st->xfer.tx_buf = &st->data; st->xfer.len = 2; spi_message_init(&st->msg); spi_message_add_tail(&st->xfer, &st->msg); st->freq_xfer[0].tx_buf = &st->freq_data[0]; st->freq_xfer[0].len = 2; st->freq_xfer[0].cs_change = 1; st->freq_xfer[1].tx_buf = &st->freq_data[1]; st->freq_xfer[1].len = 2; spi_message_init(&st->freq_msg); spi_message_add_tail(&st->freq_xfer[0], &st->freq_msg); spi_message_add_tail(&st->freq_xfer[1], &st->freq_msg); st->control = AD9834_B28 | AD9834_RESET; if (!pdata->en_div2) st->control |= AD9834_DIV2; if (!pdata->en_signbit_msb_out && (st->devid == ID_AD9834)) st->control |= AD9834_SIGN_PIB; st->data = cpu_to_be16(AD9834_REG_CMD | st->control); ret = spi_sync(st->spi, &st->msg); if (ret) { dev_err(&spi->dev, "device init failed\n"); goto error_free_device; } ret = ad9834_write_frequency(st, AD9834_REG_FREQ0, pdata->freq0); if (ret) goto error_free_device; ret = ad9834_write_frequency(st, AD9834_REG_FREQ1, pdata->freq1); if (ret) goto error_free_device; ret = ad9834_write_phase(st, AD9834_REG_PHASE0, pdata->phase0); if (ret) goto error_free_device; ret = ad9834_write_phase(st, AD9834_REG_PHASE1, pdata->phase1); if (ret) goto error_free_device; ret = iio_device_register(indio_dev); if (ret) goto error_free_device; return 0; error_free_device: iio_free_device(indio_dev); error_disable_reg: if (!IS_ERR(reg)) regulator_disable(reg); error_put_reg: if (!IS_ERR(reg)) regulator_put(reg); return ret; }
static int __devinit st7735fb_probe (struct spi_device *spi) { int chip = spi_get_device_id(spi)->driver_data; struct st7735fb_platform_data *pdata = spi->dev.platform_data; int vmem_size = WIDTH*HEIGHT*BPP/8; u8 *vmem; struct fb_info *info; struct st7735fb_par *par; int retval = -ENOMEM; if (chip != ST7735_DISPLAY_AF_TFT18) { pr_err("%s: only the %s device is supported\n", DRVNAME, to_spi_driver(spi->dev.driver)->id_table->name); return -EINVAL; } if (!pdata) { pr_err("%s: platform data required for rst and dc info\n", DRVNAME); return -EINVAL; } vmem = vzalloc(vmem_size); if (!vmem) return retval; info = framebuffer_alloc(sizeof(struct st7735fb_par), &spi->dev); if (!info) goto fballoc_fail; info->screen_base = (u8 __force __iomem *)vmem; info->fbops = &st7735fb_ops; info->fix = st7735fb_fix; info->fix.smem_len = vmem_size; info->var = st7735fb_var; /* Choose any packed pixel format as long as it's RGB565 */ info->var.red.offset = 11; info->var.red.length = 5; info->var.green.offset = 5; info->var.green.length = 6; info->var.blue.offset = 0; info->var.blue.length = 5; info->var.transp.offset = 0; info->var.transp.length = 0; info->flags = FBINFO_FLAG_DEFAULT | FBINFO_VIRTFB; info->fbdefio = &st7735fb_defio; fb_deferred_io_init(info); par = info->par; par->info = info; par->spi = spi; par->rst = pdata->rst_gpio; par->dc = pdata->dc_gpio; #ifdef __LITTLE_ENDIAN /* Allocate swapped shadow buffer */ vmem = vzalloc(vmem_size); if (!vmem) return retval; par->ssbuf = vmem; #endif retval = register_framebuffer(info); if (retval < 0) goto fbreg_fail; spi_set_drvdata(spi, info); retval = st7735fb_init_display(par); if (retval < 0) goto init_fail; printk(KERN_INFO "fb%d: %s frame buffer device,\n\tusing %d KiB of video memory\n", info->node, info->fix.id, vmem_size); return 0; /* TODO: release gpios on fail */ init_fail: spi_set_drvdata(spi, NULL); fbreg_fail: framebuffer_release(info); fballoc_fail: vfree(vmem); return retval; }
static int ws_eink_spi_probe(struct spi_device *spi) { struct fb_info *info; int retval = 0; struct waveshare_eink_platform_data *pdata; const struct spi_device_id *spi_id; const struct waveshare_eink_device_properties *dev_props; struct ws_eink_fb_par *par; int vmem_size; pdata = spi->dev.platform_data; if (!pdata) { dev_err(&spi->dev, "Required platform data was not provided"); return -EINVAL; } spi_id = spi_get_device_id(spi); if (!spi_id) { dev_err(&spi->dev, "device id not supported!\n"); return -EINVAL; } dev_props = (const struct waveshare_eink_device_properties *) spi_id->driver_data; if (!dev_props) { dev_err(&spi->dev, "device definition lacks driver_data\n"); return -EINVAL; } info = framebuffer_alloc(sizeof(struct ws_eink_fb_par), &spi->dev); if (!info) return -ENOMEM; vmem_size = dev_props->width * dev_props->height * dev_props->bpp / 8; info->screen_base = vzalloc(vmem_size); if (!info->screen_base) { retval = -ENOMEM; goto screen_base_fail; } info->fbops = &ws_eink_ops; WARN_ON(strlcpy(info->fix.id, "waveshare_eink", sizeof(info->fix.id)) >= sizeof(info->fix.id)); info->fix.type = FB_TYPE_PACKED_PIXELS; info->fix.visual = FB_VISUAL_PSEUDOCOLOR; info->fix.smem_len = vmem_size; info->fix.xpanstep = 0; info->fix.ypanstep = 0; info->fix.ywrapstep = 0; info->fix.line_length = dev_props->width * dev_props->bpp / 8; info->var.xres = dev_props->width; info->var.yres = dev_props->height; info->var.xres_virtual = dev_props->width; info->var.yres_virtual = dev_props->height; info->var.bits_per_pixel = dev_props->bpp; info->flags = FBINFO_FLAG_DEFAULT | FBINFO_VIRTFB; info->fbdefio = &ws_eink_defio; fb_deferred_io_init(info); par = info->par; par->info = info; par->spi = spi; par->props = dev_props; par->rst = pdata->rst_gpio; par->dc = pdata->dc_gpio; par->busy = pdata->busy_gpio; par->ssbuf = vzalloc(vmem_size); if (!par->ssbuf) { retval = -ENOMEM; goto ssbuf_alloc_fail; } retval = register_framebuffer(info); if (retval < 0) { dev_err(&spi->dev, "framebuffer registration failed"); goto fbreg_fail; } spi_set_drvdata(spi, info); retval = ws_eink_init_display(par); if (retval) { dev_err(&spi->dev, "display initialization failed"); goto disp_init_fail; } dev_dbg(&spi->dev, "fb%d: %s frame buffer device,\n\tusing %d KiB of video memory\n", info->node, info->fix.id, vmem_size); return 0; disp_init_fail: framebuffer_release(info); fbreg_fail: vfree(par->ssbuf); ssbuf_alloc_fail: vfree(info->screen_base); screen_base_fail: vfree(info->screen_base); return retval; }
static int mc13xxx_spi_read(void *context, const void *reg, size_t reg_size, void *val, size_t val_size) { unsigned char w[4] = { *((unsigned char *) reg), 0, 0, 0}; unsigned char r[4]; unsigned char *p = val; struct device *dev = context; struct spi_device *spi = to_spi_device(dev); struct spi_transfer t = { .tx_buf = w, .rx_buf = r, .len = 4, }; struct spi_message m; int ret; if (val_size != 3 || reg_size != 1) return -ENOTSUPP; spi_message_init(&m); spi_message_add_tail(&t, &m); ret = spi_sync(spi, &m); memcpy(p, &r[1], 3); return ret; } static int mc13xxx_spi_write(void *context, const void *data, size_t count) { struct device *dev = context; struct spi_device *spi = to_spi_device(dev); if (count != 4) return -ENOTSUPP; return spi_write(spi, data, count); } /* * We cannot use regmap-spi generic bus implementation here. * The MC13783 chip will get corrupted if CS signal is deasserted * and on i.Mx31 SoC (the target SoC for MC13783 PMIC) the SPI controller * has the following errata (DSPhl22960): * "The CSPI negates SS when the FIFO becomes empty with * SSCTL= 0. Software cannot guarantee that the FIFO will not * drain because of higher priority interrupts and the * non-realtime characteristics of the operating system. As a * result, the SS will negate before all of the data has been * transferred to/from the peripheral." * We workaround this by accessing the SPI controller with a * single transfert. */ static struct regmap_bus regmap_mc13xxx_bus = { .write = mc13xxx_spi_write, .read = mc13xxx_spi_read, }; static int mc13xxx_spi_probe(struct spi_device *spi) { const struct of_device_id *of_id; struct spi_driver *sdrv = to_spi_driver(spi->dev.driver); struct mc13xxx *mc13xxx; struct mc13xxx_platform_data *pdata = dev_get_platdata(&spi->dev); int ret; of_id = of_match_device(mc13xxx_dt_ids, &spi->dev); if (of_id) sdrv->id_table = &mc13xxx_device_id[(enum mc13xxx_id) of_id->data]; mc13xxx = kzalloc(sizeof(*mc13xxx), GFP_KERNEL); if (!mc13xxx) return -ENOMEM; dev_set_drvdata(&spi->dev, mc13xxx); spi->mode = SPI_MODE_0 | SPI_CS_HIGH; mc13xxx->dev = &spi->dev; mutex_init(&mc13xxx->lock); mc13xxx->regmap = regmap_init(&spi->dev, ®map_mc13xxx_bus, &spi->dev, &mc13xxx_regmap_spi_config); if (IS_ERR(mc13xxx->regmap)) { ret = PTR_ERR(mc13xxx->regmap); dev_err(mc13xxx->dev, "Failed to initialize register map: %d\n", ret); dev_set_drvdata(&spi->dev, NULL); kfree(mc13xxx); return ret; } ret = mc13xxx_common_init(mc13xxx, pdata, spi->irq); if (ret) { dev_set_drvdata(&spi->dev, NULL); } else { const struct spi_device_id *devid = spi_get_device_id(spi); if (!devid || devid->driver_data != mc13xxx->ictype) dev_warn(mc13xxx->dev, "device id doesn't match auto detection!\n"); } return ret; } static int __devexit mc13xxx_spi_remove(struct spi_device *spi) { struct mc13xxx *mc13xxx = dev_get_drvdata(&spi->dev); mc13xxx_common_cleanup(mc13xxx); return 0; } static struct spi_driver mc13xxx_spi_driver = { .id_table = mc13xxx_device_id, .driver = { .name = "mc13xxx", .owner = THIS_MODULE, .of_match_table = mc13xxx_dt_ids, }, .probe = mc13xxx_spi_probe, .remove = __devexit_p(mc13xxx_spi_remove), };
static int __devinit ad7298_probe(struct spi_device *spi) { struct ad7298_platform_data *pdata = spi->dev.platform_data; struct ad7298_state *st; int ret, regdone = 0; struct iio_dev *indio_dev = iio_allocate_device(sizeof(*st)); if (indio_dev == NULL) return -ENOMEM; st = iio_priv(indio_dev); st->reg = regulator_get(&spi->dev, "vcc"); if (!IS_ERR(st->reg)) { ret = regulator_enable(st->reg); if (ret) goto error_put_reg; } spi_set_drvdata(spi, indio_dev); st->spi = spi; indio_dev->name = spi_get_device_id(spi)->name; indio_dev->dev.parent = &spi->dev; indio_dev->modes = INDIO_DIRECT_MODE; indio_dev->channels = ad7298_channels; indio_dev->num_channels = ARRAY_SIZE(ad7298_channels); indio_dev->info = &ad7298_info; /* Setup default message */ st->scan_single_xfer[0].tx_buf = &st->tx_buf[0]; st->scan_single_xfer[0].len = 2; st->scan_single_xfer[0].cs_change = 1; st->scan_single_xfer[1].tx_buf = &st->tx_buf[1]; st->scan_single_xfer[1].len = 2; st->scan_single_xfer[1].cs_change = 1; st->scan_single_xfer[2].rx_buf = &st->rx_buf[0]; st->scan_single_xfer[2].len = 2; spi_message_init(&st->scan_single_msg); spi_message_add_tail(&st->scan_single_xfer[0], &st->scan_single_msg); spi_message_add_tail(&st->scan_single_xfer[1], &st->scan_single_msg); spi_message_add_tail(&st->scan_single_xfer[2], &st->scan_single_msg); if (pdata && pdata->vref_mv) { st->int_vref_mv = pdata->vref_mv; st->ext_ref = AD7298_EXTREF; } else { st->int_vref_mv = AD7298_INTREF_mV; } ret = ad7298_register_ring_funcs_and_init(indio_dev); if (ret) goto error_disable_reg; ret = iio_device_register(indio_dev); if (ret) goto error_disable_reg; regdone = 1; ret = iio_ring_buffer_register_ex(indio_dev->ring, 0, &ad7298_channels[1], /* skip temp0 */ ARRAY_SIZE(ad7298_channels) - 1); if (ret) goto error_cleanup_ring; return 0; error_cleanup_ring: ad7298_ring_cleanup(indio_dev); error_disable_reg: if (!IS_ERR(st->reg)) regulator_disable(st->reg); error_put_reg: if (!IS_ERR(st->reg)) regulator_put(st->reg); if (regdone) iio_device_unregister(indio_dev); else iio_free_device(indio_dev); return ret; }
static int adis16260_read_raw(struct iio_dev *indio_dev, struct iio_chan_spec const *chan, int *val, int *val2, long mask) { struct adis *adis = iio_priv(indio_dev); int ret; u8 addr; s16 val16; switch (mask) { case IIO_CHAN_INFO_RAW: return adis_single_conversion(indio_dev, chan, ADIS16260_ERROR_ACTIVE, val); case IIO_CHAN_INFO_SCALE: switch (chan->type) { case IIO_ANGL_VEL: *val = 0; if (spi_get_device_id(adis->spi)->driver_data) { /* 0.01832 degree / sec */ *val2 = IIO_DEGREE_TO_RAD(18320); } else { /* 0.07326 degree / sec */ *val2 = IIO_DEGREE_TO_RAD(73260); } return IIO_VAL_INT_PLUS_MICRO; case IIO_INCLI: *val = 0; *val2 = IIO_DEGREE_TO_RAD(36630); return IIO_VAL_INT_PLUS_MICRO; case IIO_VOLTAGE: if (chan->channel == 0) { *val = 1; *val2 = 831500; /* 1.8315 mV */ } else { *val = 0; *val2 = 610500; /* 610.5 uV */ } return IIO_VAL_INT_PLUS_MICRO; case IIO_TEMP: *val = 145; *val2 = 300000; /* 0.1453 C */ return IIO_VAL_INT_PLUS_MICRO; default: return -EINVAL; } case IIO_CHAN_INFO_OFFSET: *val = 250000 / 1453; /* 25 C = 0x00 */ return IIO_VAL_INT; case IIO_CHAN_INFO_CALIBBIAS: addr = adis16260_addresses[chan->scan_index][0]; ret = adis_read_reg_16(adis, addr, &val16); if (ret) return ret; *val = sign_extend32(val16, 11); return IIO_VAL_INT; case IIO_CHAN_INFO_CALIBSCALE: addr = adis16260_addresses[chan->scan_index][1]; ret = adis_read_reg_16(adis, addr, &val16); if (ret) return ret; *val = val16; return IIO_VAL_INT; case IIO_CHAN_INFO_SAMP_FREQ: ret = adis_read_reg_16(adis, ADIS16260_SMPL_PRD, &val16); if (ret) return ret; if (spi_get_device_id(adis->spi)->driver_data) /* If an adis16251 */ *val = (val16 & ADIS16260_SMPL_PRD_TIME_BASE) ? 8 : 256; else *val = (val16 & ADIS16260_SMPL_PRD_TIME_BASE) ? 66 : 2048; *val /= (val16 & ADIS16260_SMPL_PRD_DIV_MASK) + 1; return IIO_VAL_INT; } return -EINVAL; }
static int __devinit ad5624r_probe(struct spi_device *spi) { struct ad5624r_state *st; int ret, voltage_uv = 0; st = kzalloc(sizeof(*st), GFP_KERNEL); if (st == NULL) { ret = -ENOMEM; goto error_ret; } spi_set_drvdata(spi, st); st->reg = regulator_get(&spi->dev, "vcc"); if (!IS_ERR(st->reg)) { ret = regulator_enable(st->reg); if (ret) goto error_put_reg; voltage_uv = regulator_get_voltage(st->reg); } st->chip_info = &ad5624r_chip_info_tbl[spi_get_device_id(spi)->driver_data]; if (voltage_uv) st->vref_mv = voltage_uv / 1000; else st->vref_mv = st->chip_info->int_vref_mv; st->us = spi; st->indio_dev = iio_allocate_device(0); if (st->indio_dev == NULL) { ret = -ENOMEM; goto error_disable_reg; } st->indio_dev->dev.parent = &spi->dev; st->indio_dev->name = spi_get_device_id(spi)->name; st->indio_dev->info = &ad5624r_info; st->indio_dev->dev_data = (void *)(st); st->indio_dev->modes = INDIO_DIRECT_MODE; ret = iio_device_register(st->indio_dev); if (ret) goto error_free_dev; ret = ad5624r_spi_write(spi, AD5624R_CMD_INTERNAL_REFER_SETUP, 0, !!voltage_uv, 16); if (ret) goto error_free_dev; return 0; error_free_dev: iio_free_device(st->indio_dev); error_disable_reg: if (!IS_ERR(st->reg)) regulator_disable(st->reg); error_put_reg: if (!IS_ERR(st->reg)) regulator_put(st->reg); kfree(st); error_ret: return ret; }
static int __devinit ad7887_probe(struct spi_device *spi) { struct ad7887_platform_data *pdata = spi->dev.platform_data; struct ad7887_state *st; int ret, voltage_uv = 0; st = kzalloc(sizeof(*st), GFP_KERNEL); if (st == NULL) { ret = -ENOMEM; goto error_ret; } st->reg = regulator_get(&spi->dev, "vcc"); if (!IS_ERR(st->reg)) { ret = regulator_enable(st->reg); if (ret) goto error_put_reg; voltage_uv = regulator_get_voltage(st->reg); } st->chip_info = &ad7887_chip_info_tbl[spi_get_device_id(spi)->driver_data]; spi_set_drvdata(spi, st); atomic_set(&st->protect_ring, 0); st->spi = spi; st->indio_dev = iio_allocate_device(); if (st->indio_dev == NULL) { ret = -ENOMEM; goto error_disable_reg; } /* Estabilish that the iio_dev is a child of the spi device */ st->indio_dev->dev.parent = &spi->dev; st->indio_dev->attrs = &ad7887_attribute_group; st->indio_dev->dev_data = (void *)(st); st->indio_dev->driver_module = THIS_MODULE; st->indio_dev->modes = INDIO_DIRECT_MODE; /* Setup default message */ st->tx_cmd_buf[0] = AD7887_CH_AIN0 | AD7887_PM_MODE4 | ((pdata && pdata->use_onchip_ref) ? 0 : AD7887_REF_DIS); st->xfer[0].rx_buf = &st->data[0]; st->xfer[0].tx_buf = &st->tx_cmd_buf[0]; st->xfer[0].len = 2; spi_message_init(&st->msg[AD7887_CH0]); spi_message_add_tail(&st->xfer[0], &st->msg[AD7887_CH0]); if (pdata && pdata->en_dual) { st->tx_cmd_buf[0] |= AD7887_DUAL | AD7887_REF_DIS; st->tx_cmd_buf[2] = AD7887_CH_AIN1 | AD7887_DUAL | AD7887_REF_DIS | AD7887_PM_MODE4; st->tx_cmd_buf[4] = AD7887_CH_AIN0 | AD7887_DUAL | AD7887_REF_DIS | AD7887_PM_MODE4; st->tx_cmd_buf[6] = AD7887_CH_AIN1 | AD7887_DUAL | AD7887_REF_DIS | AD7887_PM_MODE4; st->xfer[1].rx_buf = &st->data[0]; st->xfer[1].tx_buf = &st->tx_cmd_buf[2]; st->xfer[1].len = 2; st->xfer[2].rx_buf = &st->data[2]; st->xfer[2].tx_buf = &st->tx_cmd_buf[4]; st->xfer[2].len = 2; spi_message_init(&st->msg[AD7887_CH0_CH1]); spi_message_add_tail(&st->xfer[1], &st->msg[AD7887_CH0_CH1]); spi_message_add_tail(&st->xfer[2], &st->msg[AD7887_CH0_CH1]); st->xfer[3].rx_buf = &st->data[0]; st->xfer[3].tx_buf = &st->tx_cmd_buf[6]; st->xfer[3].len = 2; spi_message_init(&st->msg[AD7887_CH1]); spi_message_add_tail(&st->xfer[3], &st->msg[AD7887_CH1]); st->en_dual = true; if (pdata && pdata->vref_mv) st->int_vref_mv = pdata->vref_mv; else if (voltage_uv) st->int_vref_mv = voltage_uv / 1000; else dev_warn(&spi->dev, "reference voltage unspecified\n"); } else { if (pdata && pdata->vref_mv) st->int_vref_mv = pdata->vref_mv; else if (pdata && pdata->use_onchip_ref) st->int_vref_mv = st->chip_info->int_vref_mv; else dev_warn(&spi->dev, "reference voltage unspecified\n"); } ret = ad7887_register_ring_funcs_and_init(st->indio_dev); if (ret) goto error_free_device; ret = iio_device_register(st->indio_dev); if (ret) goto error_free_device; ret = iio_ring_buffer_register(st->indio_dev->ring, 0); if (ret) goto error_cleanup_ring; return 0; error_cleanup_ring: ad7887_ring_cleanup(st->indio_dev); iio_device_unregister(st->indio_dev); error_free_device: iio_free_device(st->indio_dev); error_disable_reg: if (!IS_ERR(st->reg)) regulator_disable(st->reg); error_put_reg: if (!IS_ERR(st->reg)) regulator_put(st->reg); kfree(st); error_ret: return ret; }