Commit 71c62902 authored by Greg Kroah-Hartman's avatar Greg Kroah-Hartman
Browse files

Merge tag 'iio-for-v3.7e' of... 

Merge tag 'iio-for-v3.7e' of git://git.kernel.org/pub/scm/linux/kernel/git/jic23/iio into staging-next

Fifth round of new drivers and device support for the IIO
subsystem in the 3.7 cycle.

Here we have a mixed bag of new stuff, minor fixes and
more major fixes for drivers added earlier in this cycle.

1) A number of fixes for the HID sensors code added in previous
pull request.  Typical stuff that has become apparent as more eyes
have looked at the code post merging. Similar case for the ad5755 dac.

2) Cleanups of error handing in inkern.c - again typical stuff to see
as code comes into heavier use and people notice the naughty short
cuts that snuck in originally and kindly fix them.

3) A series from Lars that removes some incorrect error handling
from the remove functions of a number of drivers.  These have been
there for a very long time hence I'm not pushing these out for the
3.6 cycle.

4) Support for more parts in the ad7780 driver.

5) A driver for the adcs on the lp8788 power management unit

6) A client driver for IIO to allow it's ADCs to be used for
battery status measurement.  Note this driver has some dependencies
on some utility functions added to IIO in this series, hence it is
coming via this tree rather than Anton's.

7) A null pointer dereference bug in the 'fake' driver. I'm not
doing this as a fix for the 3.6 cycle because it only effects
'fake' hardware and that code is typically only used by people
investigating how IIO works as part of writing new drivers. Hence
it's hardly a critical fix.
parents 9970eeae 3fff2274

drivers/hid/hid-sensor-hub.c

+7 −22
Original line number Diff line number Diff line
@@ -173,7 +173,7 @@ int sensor_hub_register_callback(struct hid_sensor_hub_device *hsdev, 
			spin_unlock(&pdata->dyn_callback_lock);

			return -EINVAL;

		}

	callback = kzalloc(sizeof(*callback), GFP_KERNEL);

	callback = kzalloc(sizeof(*callback), GFP_ATOMIC);

	if (!callback) {

		spin_unlock(&pdata->dyn_callback_lock);

		return -ENOMEM;
@@ -214,9 +214,6 @@ int sensor_hub_set_feature(struct hid_sensor_hub_device *hsdev, u32 report_id, 
	struct sensor_hub_data *data =  hid_get_drvdata(hsdev->hdev);

	int ret = 0;



	if (report_id < 0)

		return -EINVAL;



	mutex_lock(&data->mutex);

	report = sensor_hub_report(report_id, hsdev->hdev, HID_FEATURE_REPORT);

	if (!report || (field_index >=  report->maxfield)) {
@@ -241,9 +238,6 @@ int sensor_hub_get_feature(struct hid_sensor_hub_device *hsdev, u32 report_id, 
	struct sensor_hub_data *data =  hid_get_drvdata(hsdev->hdev);

	int ret = 0;



	if (report_id < 0)

		return -EINVAL;



	mutex_lock(&data->mutex);

	report = sensor_hub_report(report_id, hsdev->hdev, HID_FEATURE_REPORT);

	if (!report || (field_index >=  report->maxfield)) {
@@ -271,9 +265,6 @@ int sensor_hub_input_attr_get_raw_value(struct hid_sensor_hub_device *hsdev, 
	struct hid_report *report;

	int ret_val = 0;



	if (report_id < 0)

		return -EINVAL;



	mutex_lock(&data->mutex);

	memset(&data->pending, 0, sizeof(data->pending));

	init_completion(&data->pending.ready);
@@ -462,7 +453,7 @@ static int sensor_hub_raw_event(struct hid_device *hdev, 
		if (pdata->pending.status && pdata->pending.attr_usage_id ==

				report->field[i]->usage->hid) {

			hid_dbg(hdev, "data was pending ...\n");

			pdata->pending.raw_data = kmalloc(sz, GFP_KERNEL);

			pdata->pending.raw_data = kmalloc(sz, GFP_ATOMIC);

			if (pdata->pending.raw_data) {

				memcpy(pdata->pending.raw_data, ptr, sz);

				pdata->pending.raw_size  = sz;
@@ -539,7 +530,6 @@ static int sensor_hub_probe(struct hid_device *hdev, 
	}

	INIT_LIST_HEAD(&hdev->inputs);



	hdev->claimed = HID_CLAIMED_INPUT;

	ret = hid_hw_start(hdev, 0);

	if (ret) {

		hid_err(hdev, "hw start failed\n");
@@ -565,8 +555,7 @@ static int sensor_hub_probe(struct hid_device *hdev, 
						sizeof(struct mfd_cell),

						GFP_KERNEL);

	if (sd->hid_sensor_hub_client_devs == NULL) {

		hid_err(hdev,

			"Failed to allocate memory for mfd cells\n");

		hid_err(hdev, "Failed to allocate memory for mfd cells\n");

			ret = -ENOMEM;

			goto err_close;

	}
@@ -578,10 +567,9 @@ static int sensor_hub_probe(struct hid_device *hdev, 
			name = kasprintf(GFP_KERNEL, "HID-SENSOR-%x",

						field->physical);

			if (name  == NULL) {

				hid_err(hdev,

					"Failed MFD device name\n");

				hid_err(hdev, "Failed MFD device name\n");

					ret = -ENOMEM;

					goto err_free_cells;

					goto err_free_names;

			}

			sd->hid_sensor_hub_client_devs[

				sd->hid_sensor_client_cnt].name = name;
@@ -596,7 +584,7 @@ static int sensor_hub_probe(struct hid_device *hdev, 
		}

	}

	ret = mfd_add_devices(&hdev->dev, 0, sd->hid_sensor_hub_client_devs,

		sd->hid_sensor_client_cnt, NULL, 0);

		sd->hid_sensor_client_cnt, NULL, 0, NULL);

	if (ret < 0)

		goto err_free_names;
@@ -605,10 +593,8 @@ static int sensor_hub_probe(struct hid_device *hdev, 
err_free_names:

	for (i = 0; i < sd->hid_sensor_client_cnt ; ++i)

		kfree(sd->hid_sensor_hub_client_devs[i].name);

err_free_cells:

	kfree(sd->hid_sensor_hub_client_devs);

err_close:

	hid_hw_stop(hdev);

	hid_hw_close(hdev);

err_stop_hw:

	hid_hw_stop(hdev);
@@ -627,9 +613,8 @@ static void sensor_hub_remove(struct hid_device *hdev) 
	int i;



	hid_dbg(hdev, " hardware removed\n");

	hdev->claimed &= ~HID_CLAIMED_INPUT;

	hid_hw_stop(hdev);

	hid_hw_close(hdev);

	hid_hw_stop(hdev);

	spin_lock_irqsave(&data->lock, flags);

	if (data->pending.status)

		complete(&data->pending.ready);

drivers/iio/adc/Kconfig

+6 −0
Original line number Diff line number Diff line
@@ -54,4 +54,10 @@ config AT91_ADC 
	help

	  Say yes here to build support for Atmel AT91 ADC.



config LP8788_ADC

	bool "LP8788 ADC driver"

	depends on MFD_LP8788

	help

	  Say yes here to build support for TI LP8788 ADC.



endmenu

drivers/iio/adc/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -7,3 +7,4 @@ obj-$(CONFIG_AD7266) += ad7266.o 
obj-$(CONFIG_AD7476) += ad7476.o

obj-$(CONFIG_AD7791) += ad7791.o

obj-$(CONFIG_AT91_ADC) += at91_adc.o

obj-$(CONFIG_LP8788_ADC) += lp8788_adc.o

drivers/iio/adc/lp8788_adc.c

0 → 100644
+264 −0
Original line number Diff line number Diff line 
/*

 * TI LP8788 MFD - ADC driver

 *

 * Copyright 2012 Texas Instruments

 *

 * Author: Milo(Woogyom) Kim <milo.kim@ti.com>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation.

 */



#include <linux/delay.h>

#include <linux/iio/iio.h>

#include <linux/iio/driver.h>

#include <linux/iio/machine.h>

#include <linux/mfd/lp8788.h>

#include <linux/module.h>

#include <linux/mutex.h>

#include <linux/platform_device.h>

#include <linux/slab.h>



/* register address */

#define LP8788_ADC_CONF			0x60

#define LP8788_ADC_RAW			0x61

#define LP8788_ADC_DONE			0x63



#define ADC_CONV_START			1



struct lp8788_adc {

	struct lp8788 *lp;

	struct iio_map *map;

	struct mutex lock;

};



static const int lp8788_scale[LPADC_MAX] = {

	[LPADC_VBATT_5P5] = 1343101,

	[LPADC_VIN_CHG]   = 3052503,

	[LPADC_IBATT]     = 610500,

	[LPADC_IC_TEMP]   = 61050,

	[LPADC_VBATT_6P0] = 1465201,

	[LPADC_VBATT_5P0] = 1221001,

	[LPADC_ADC1]      = 610500,

	[LPADC_ADC2]      = 610500,

	[LPADC_VDD]       = 1025641,

	[LPADC_VCOIN]     = 757020,

	[LPADC_ADC3]      = 610500,

	[LPADC_ADC4]      = 610500,

};



static int lp8788_get_adc_result(struct lp8788_adc *adc, enum lp8788_adc_id id,

				int *val)

{

	unsigned int msb;

	unsigned int lsb;

	unsigned int result;

	u8 data;

	u8 rawdata[2];

	int size = ARRAY_SIZE(rawdata);

	int retry = 5;

	int ret;



	data = (id << 1) | ADC_CONV_START;

	ret = lp8788_write_byte(adc->lp, LP8788_ADC_CONF, data);

	if (ret)

		goto err_io;



	/* retry until adc conversion is done */

	data = 0;

	while (retry--) {

		usleep_range(100, 200);



		ret = lp8788_read_byte(adc->lp, LP8788_ADC_DONE, &data);

		if (ret)

			goto err_io;



		/* conversion done */

		if (data)

			break;

	}



	ret = lp8788_read_multi_bytes(adc->lp, LP8788_ADC_RAW, rawdata, size);

	if (ret)

		goto err_io;



	msb = (rawdata[0] << 4) & 0x00000ff0;

	lsb = (rawdata[1] >> 4) & 0x0000000f;

	result = msb | lsb;

	*val = result;



	return 0;



err_io:

	return ret;

}



static int lp8788_adc_read_raw(struct iio_dev *indio_dev,

			struct iio_chan_spec const *chan,

			int *val, int *val2, long mask)

{

	struct lp8788_adc *adc = iio_priv(indio_dev);

	enum lp8788_adc_id id = chan->channel;

	int ret;



	mutex_lock(&adc->lock);



	switch (mask) {

	case IIO_CHAN_INFO_RAW:

		ret = lp8788_get_adc_result(adc, id, val) ? -EIO : IIO_VAL_INT;

		break;

	case IIO_CHAN_INFO_SCALE:

		*val = lp8788_scale[id] / 1000000;

		*val2 = lp8788_scale[id] % 1000000;

		ret = IIO_VAL_INT_PLUS_MICRO;

		break;

	default:

		ret = -EINVAL;

		break;

	}



	mutex_unlock(&adc->lock);



	return ret;

}



static const struct iio_info lp8788_adc_info = {

	.read_raw = &lp8788_adc_read_raw,

	.driver_module = THIS_MODULE,

};



#define LP8788_CHAN(_id, _type) {				\

		.type = _type,					\

		.indexed = 1,					\

		.channel = LPADC_##_id,				\

		.info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |	\

			IIO_CHAN_INFO_SCALE_SEPARATE_BIT,	\

		.datasheet_name = #_id,				\

}



static const struct iio_chan_spec lp8788_adc_channels[] = {

	[LPADC_VBATT_5P5] = LP8788_CHAN(VBATT_5P5, IIO_VOLTAGE),

	[LPADC_VIN_CHG]   = LP8788_CHAN(VIN_CHG, IIO_VOLTAGE),

	[LPADC_IBATT]     = LP8788_CHAN(IBATT, IIO_CURRENT),

	[LPADC_IC_TEMP]   = LP8788_CHAN(IC_TEMP, IIO_TEMP),

	[LPADC_VBATT_6P0] = LP8788_CHAN(VBATT_6P0, IIO_VOLTAGE),

	[LPADC_VBATT_5P0] = LP8788_CHAN(VBATT_5P0, IIO_VOLTAGE),

	[LPADC_ADC1]      = LP8788_CHAN(ADC1, IIO_VOLTAGE),

	[LPADC_ADC2]      = LP8788_CHAN(ADC2, IIO_VOLTAGE),

	[LPADC_VDD]       = LP8788_CHAN(VDD, IIO_VOLTAGE),

	[LPADC_VCOIN]     = LP8788_CHAN(VCOIN, IIO_VOLTAGE),

	[LPADC_ADC3]      = LP8788_CHAN(ADC3, IIO_VOLTAGE),

	[LPADC_ADC4]      = LP8788_CHAN(ADC4, IIO_VOLTAGE),

};



/* default maps used by iio consumer (lp8788-charger driver) */

static struct iio_map lp8788_default_iio_maps[] = {

	{

		.consumer_dev_name = "lp8788-charger",

		.consumer_channel = "lp8788_vbatt_5p0",

		.adc_channel_label = "VBATT_5P0",

	},

	{

		.consumer_dev_name = "lp8788-charger",

		.consumer_channel = "lp8788_adc1",

		.adc_channel_label = "ADC1",

	},

	{ }

};



static int lp8788_iio_map_register(struct iio_dev *indio_dev,

				struct lp8788_platform_data *pdata,

				struct lp8788_adc *adc)

{

	struct iio_map *map;

	int ret;



	map = (!pdata || !pdata->adc_pdata) ?

		lp8788_default_iio_maps : pdata->adc_pdata;



	ret = iio_map_array_register(indio_dev, map);

	if (ret) {

		dev_err(adc->lp->dev, "iio map err: %d\n", ret);

		return ret;

	}



	adc->map = map;

	return 0;

}



static inline void lp8788_iio_map_unregister(struct iio_dev *indio_dev,

				struct lp8788_adc *adc)

{

	iio_map_array_unregister(indio_dev, adc->map);

}



static int __devinit lp8788_adc_probe(struct platform_device *pdev)

{

	struct lp8788 *lp = dev_get_drvdata(pdev->dev.parent);

	struct iio_dev *indio_dev;

	struct lp8788_adc *adc;

	int ret;



	indio_dev = iio_device_alloc(sizeof(*adc));

	if (!indio_dev)

		return -ENOMEM;



	adc = iio_priv(indio_dev);

	adc->lp = lp;

	platform_set_drvdata(pdev, indio_dev);



	ret = lp8788_iio_map_register(indio_dev, lp->pdata, adc);

	if (ret)

		goto err_iio_map;



	mutex_init(&adc->lock);



	indio_dev->dev.parent = lp->dev;

	indio_dev->name = pdev->name;

	indio_dev->modes = INDIO_DIRECT_MODE;

	indio_dev->info = &lp8788_adc_info;

	indio_dev->channels = lp8788_adc_channels;

	indio_dev->num_channels = ARRAY_SIZE(lp8788_adc_channels);



	ret = iio_device_register(indio_dev);

	if (ret) {

		dev_err(lp->dev, "iio dev register err: %d\n", ret);

		goto err_iio_device;

	}



	return 0;



err_iio_device:

	lp8788_iio_map_unregister(indio_dev, adc);

err_iio_map:

	iio_device_free(indio_dev);

	return ret;

}



static int __devexit lp8788_adc_remove(struct platform_device *pdev)

{

	struct iio_dev *indio_dev = platform_get_drvdata(pdev);

	struct lp8788_adc *adc = iio_priv(indio_dev);



	iio_device_unregister(indio_dev);

	lp8788_iio_map_unregister(indio_dev, adc);

	iio_device_free(indio_dev);



	return 0;

}



static struct platform_driver lp8788_adc_driver = {

	.probe = lp8788_adc_probe,

	.remove = __devexit_p(lp8788_adc_remove),

	.driver = {

		.name = LP8788_DEV_ADC,

		.owner = THIS_MODULE,

	},

};

module_platform_driver(lp8788_adc_driver);



MODULE_DESCRIPTION("Texas Instruments LP8788 ADC Driver");

MODULE_AUTHOR("Milo Kim");

MODULE_LICENSE("GPL");

MODULE_ALIAS("platform:lp8788-adc");

drivers/iio/common/hid-sensors/hid-sensor-trigger.c

+1 −0
Original line number Diff line number Diff line
@@ -56,6 +56,7 @@ void hid_sensor_remove_trigger(struct iio_dev *indio_dev) 
{

	iio_trigger_unregister(indio_dev->trig);

	iio_trigger_free(indio_dev->trig);

	indio_dev->trig = NULL;

}

EXPORT_SYMBOL(hid_sensor_remove_trigger);

CRA Git | Maintained and supported by SUSTech CRA and CCSE