[mirror_ubuntu-bionic-kernel.git] / drivers / staging / comedi / drivers.c

/*
    module/drivers.c
    functions for manipulating drivers

    COMEDI - Linux Control and Measurement Device Interface
    Copyright (C) 1997-2000 David A. Schleef <ds@schleef.org>

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
*/

#include <linux/device.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/kconfig.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/fcntl.h>
#include <linux/delay.h>
#include <linux/ioport.h>
#include <linux/mm.h>
#include <linux/slab.h>
#include <linux/highmem.h>	/* for SuSE brokenness */
#include <linux/vmalloc.h>
#include <linux/cdev.h>
#include <linux/dma-mapping.h>
#include <linux/io.h>
#include <linux/interrupt.h>
#include <linux/firmware.h>

#include "comedidev.h"
#include "comedi_internal.h"

struct comedi_driver *comedi_drivers;

int comedi_set_hw_dev(struct comedi_device *dev, struct device *hw_dev)
{
	if (hw_dev == dev->hw_dev)
		return 0;
	if (dev->hw_dev != NULL)
		return -EEXIST;
	dev->hw_dev = get_device(hw_dev);
	return 0;
}
EXPORT_SYMBOL_GPL(comedi_set_hw_dev);

static void comedi_clear_hw_dev(struct comedi_device *dev)
{
	put_device(dev->hw_dev);
	dev->hw_dev = NULL;
}

int comedi_alloc_subdevices(struct comedi_device *dev, int num_subdevices)
{
	struct comedi_subdevice *s;
	int i;

	if (num_subdevices < 1)
		return -EINVAL;

	s = kcalloc(num_subdevices, sizeof(*s), GFP_KERNEL);
	if (!s)
		return -ENOMEM;
	dev->subdevices = s;
	dev->n_subdevices = num_subdevices;

	for (i = 0; i < num_subdevices; ++i) {
		s = &dev->subdevices[i];
		s->device = dev;
		s->index = i;
		s->async_dma_dir = DMA_NONE;
		spin_lock_init(&s->spin_lock);
		s->minor = -1;
	}
	return 0;
}
EXPORT_SYMBOL_GPL(comedi_alloc_subdevices);

static void cleanup_device(struct comedi_device *dev)
{
	int i;
	struct comedi_subdevice *s;

	if (dev->subdevices) {
		for (i = 0; i < dev->n_subdevices; i++) {
			s = &dev->subdevices[i];
			if (s->runflags & SRF_FREE_SPRIV)
				kfree(s->private);
			comedi_free_subdevice_minor(s);
			if (s->async) {
				comedi_buf_alloc(dev, s, 0);
				kfree(s->async);
			}
		}
		kfree(dev->subdevices);
		dev->subdevices = NULL;
		dev->n_subdevices = 0;
	}
	kfree(dev->private);
	dev->private = NULL;
	dev->driver = NULL;
	dev->board_name = NULL;
	dev->board_ptr = NULL;
	dev->iobase = 0;
	dev->iolen = 0;
	dev->ioenabled = false;
	dev->irq = 0;
	dev->read_subdev = NULL;
	dev->write_subdev = NULL;
	dev->open = NULL;
	dev->close = NULL;
	comedi_clear_hw_dev(dev);
}

void comedi_device_detach(struct comedi_device *dev)
{
	dev->attached = false;
	if (dev->driver)
		dev->driver->detach(dev);
	cleanup_device(dev);
}

static int poll_invalid(struct comedi_device *dev, struct comedi_subdevice *s)
{
	return -EINVAL;
}

int insn_inval(struct comedi_device *dev, struct comedi_subdevice *s,
	       struct comedi_insn *insn, unsigned int *data)
{
	return -EINVAL;
}

static int insn_rw_emulate_bits(struct comedi_device *dev,
				struct comedi_subdevice *s,
				struct comedi_insn *insn, unsigned int *data)
{
	struct comedi_insn new_insn;
	int ret;
	static const unsigned channels_per_bitfield = 32;

	unsigned chan = CR_CHAN(insn->chanspec);
	const unsigned base_bitfield_channel =
	    (chan < channels_per_bitfield) ? 0 : chan;
	unsigned int new_data[2];
	memset(new_data, 0, sizeof(new_data));
	memset(&new_insn, 0, sizeof(new_insn));
	new_insn.insn = INSN_BITS;
	new_insn.chanspec = base_bitfield_channel;
	new_insn.n = 2;
	new_insn.subdev = insn->subdev;

	if (insn->insn == INSN_WRITE) {
		if (!(s->subdev_flags & SDF_WRITABLE))
			return -EINVAL;
		new_data[0] = 1 << (chan - base_bitfield_channel); /* mask */
		new_data[1] = data[0] ? (1 << (chan - base_bitfield_channel))
			      : 0; /* bits */
	}

	ret = s->insn_bits(dev, s, &new_insn, new_data);
	if (ret < 0)
		return ret;

	if (insn->insn == INSN_READ)
		data[0] = (new_data[1] >> (chan - base_bitfield_channel)) & 1;

	return 1;
}

static int __comedi_device_postconfig_async(struct comedi_device *dev,
					    struct comedi_subdevice *s)
{
	struct comedi_async *async;
	unsigned int buf_size;
	int ret;

	if ((s->subdev_flags & (SDF_CMD_READ | SDF_CMD_WRITE)) == 0) {
		dev_warn(dev->class_dev,
			 "async subdevices must support SDF_CMD_READ or SDF_CMD_WRITE\n");
		return -EINVAL;
	}
	if (!s->do_cmdtest) {
		dev_warn(dev->class_dev,
			 "async subdevices must have a do_cmdtest() function\n");
		return -EINVAL;
	}

	async = kzalloc(sizeof(*async), GFP_KERNEL);
	if (!async)
		return -ENOMEM;

	init_waitqueue_head(&async->wait_head);
	async->subdevice = s;
	s->async = async;

	async->max_bufsize = comedi_default_buf_maxsize_kb * 1024;
	buf_size = comedi_default_buf_size_kb * 1024;
	if (buf_size > async->max_bufsize)
		buf_size = async->max_bufsize;

	if (comedi_buf_alloc(dev, s, buf_size) < 0) {
		dev_warn(dev->class_dev, "Buffer allocation failed\n");
		return -ENOMEM;
	}
	if (s->buf_change) {
		ret = s->buf_change(dev, s, buf_size);
		if (ret < 0)
			return ret;
	}

	comedi_alloc_subdevice_minor(s);

	return 0;
}

static int __comedi_device_postconfig(struct comedi_device *dev)
{
	struct comedi_subdevice *s;
	int ret;
	int i;

	for (i = 0; i < dev->n_subdevices; i++) {
		s = &dev->subdevices[i];

		if (s->type == COMEDI_SUBD_UNUSED)
			continue;

		if (s->len_chanlist == 0)
			s->len_chanlist = 1;

		if (s->do_cmd) {
			ret = __comedi_device_postconfig_async(dev, s);
			if (ret)
				return ret;
		}

		if (!s->range_table && !s->range_table_list)
			s->range_table = &range_unknown;

		if (!s->insn_read && s->insn_bits)
			s->insn_read = insn_rw_emulate_bits;
		if (!s->insn_write && s->insn_bits)
			s->insn_write = insn_rw_emulate_bits;

		if (!s->insn_read)
			s->insn_read = insn_inval;
		if (!s->insn_write)
			s->insn_write = insn_inval;
		if (!s->insn_bits)
			s->insn_bits = insn_inval;
		if (!s->insn_config)
			s->insn_config = insn_inval;

		if (!s->poll)
			s->poll = poll_invalid;
	}

	return 0;
}

/* do a little post-config cleanup */
static int comedi_device_postconfig(struct comedi_device *dev)
{
	int ret;

	ret = __comedi_device_postconfig(dev);
	if (ret < 0)
		return ret;
	smp_wmb();
	dev->attached = true;
	return 0;
}

/*
 * Generic recognize function for drivers that register their supported
 * board names.
 *
 * 'driv->board_name' points to a 'const char *' member within the
 * zeroth element of an array of some private board information
 * structure, say 'struct foo_board' containing a member 'const char
 * *board_name' that is initialized to point to a board name string that
 * is one of the candidates matched against this function's 'name'
 * parameter.
 *
 * 'driv->offset' is the size of the private board information
 * structure, say 'sizeof(struct foo_board)', and 'driv->num_names' is
 * the length of the array of private board information structures.
 *
 * If one of the board names in the array of private board information
 * structures matches the name supplied to this function, the function
 * returns a pointer to the pointer to the board name, otherwise it
 * returns NULL.  The return value ends up in the 'board_ptr' member of
 * a 'struct comedi_device' that the low-level comedi driver's
 * 'attach()' hook can convert to a point to a particular element of its
 * array of private board information structures by subtracting the
 * offset of the member that points to the board name.  (No subtraction
 * is required if the board name pointer is the first member of the
 * private board information structure, which is generally the case.)
 */
static void *comedi_recognize(struct comedi_driver *driv, const char *name)
{
	char **name_ptr = (char **)driv->board_name;
	int i;

	for (i = 0; i < driv->num_names; i++) {
		if (strcmp(*name_ptr, name) == 0)
			return name_ptr;
		name_ptr = (void *)name_ptr + driv->offset;
	}

	return NULL;
}

static void comedi_report_boards(struct comedi_driver *driv)
{
	unsigned int i;
	const char *const *name_ptr;

	pr_info("comedi: valid board names for %s driver are:\n",
		driv->driver_name);

	name_ptr = driv->board_name;
	for (i = 0; i < driv->num_names; i++) {
		pr_info(" %s\n", *name_ptr);
		name_ptr = (const char **)((char *)name_ptr + driv->offset);
	}

	if (driv->num_names == 0)
		pr_info(" %s\n", driv->driver_name);
}

/**
 * comedi_load_firmware() - Request and load firmware for a device.
 * @dev: comedi_device struct
 * @hw_device: device struct for the comedi_device
 * @name: the name of the firmware image
 * @cb: callback to the upload the firmware image
 * @context: private context from the driver
 */
int comedi_load_firmware(struct comedi_device *dev,
			 struct device *device,
			 const char *name,
			 int (*cb)(struct comedi_device *dev,
				   const u8 *data, size_t size,
				   unsigned long context),
			 unsigned long context)
{
	const struct firmware *fw;
	int ret;

	if (!cb)
		return -EINVAL;

	ret = request_firmware(&fw, name, device);
	if (ret == 0) {
		ret = cb(dev, fw->data, fw->size, context);
		release_firmware(fw);
	}

	return ret;
}
EXPORT_SYMBOL_GPL(comedi_load_firmware);

/**
 * __comedi_request_region() - Request an I/O reqion for a legacy driver.
 * @dev: comedi_device struct
 * @start: base address of the I/O reqion
 * @len: length of the I/O region
 */
int __comedi_request_region(struct comedi_device *dev,
			    unsigned long start, unsigned long len)
{
	if (!start) {
		dev_warn(dev->class_dev,
			 "%s: a I/O base address must be specified\n",
			 dev->board_name);
		return -EINVAL;
	}

	if (!request_region(start, len, dev->board_name)) {
		dev_warn(dev->class_dev, "%s: I/O port conflict (%#lx,%lu)\n",
			 dev->board_name, start, len);
		return -EIO;
	}

	return 0;
}
EXPORT_SYMBOL_GPL(__comedi_request_region);

/**
 * comedi_request_region() - Request an I/O reqion for a legacy driver.
 * @dev: comedi_device struct
 * @start: base address of the I/O reqion
 * @len: length of the I/O region
 */
int comedi_request_region(struct comedi_device *dev,
			  unsigned long start, unsigned long len)
{
	int ret;

	ret = __comedi_request_region(dev, start, len);
	if (ret == 0) {
		dev->iobase = start;
		dev->iolen = len;
	}

	return ret;
}
EXPORT_SYMBOL_GPL(comedi_request_region);

/**
 * comedi_legacy_detach() - A generic (*detach) function for legacy drivers.
 * @dev: comedi_device struct
 */
void comedi_legacy_detach(struct comedi_device *dev)
{
	if (dev->irq) {
		free_irq(dev->irq, dev);
		dev->irq = 0;
	}
	if (dev->iobase && dev->iolen) {
		release_region(dev->iobase, dev->iolen);
		dev->iobase = 0;
		dev->iolen = 0;
	}
}
EXPORT_SYMBOL_GPL(comedi_legacy_detach);

int comedi_device_attach(struct comedi_device *dev, struct comedi_devconfig *it)
{
	struct comedi_driver *driv;
	int ret;

	if (dev->attached)
		return -EBUSY;

	for (driv = comedi_drivers; driv; driv = driv->next) {
		if (!try_module_get(driv->module))
			continue;
		if (driv->num_names) {
			dev->board_ptr = comedi_recognize(driv, it->board_name);
			if (dev->board_ptr)
				break;
		} else if (strcmp(driv->driver_name, it->board_name) == 0)
			break;
		module_put(driv->module);
	}
	if (driv == NULL) {
		/*  recognize has failed if we get here */
		/*  report valid board names before returning error */
		for (driv = comedi_drivers; driv; driv = driv->next) {
			if (!try_module_get(driv->module))
				continue;
			comedi_report_boards(driv);
			module_put(driv->module);
		}
		return -EIO;
	}
	if (driv->attach == NULL) {
		/* driver does not support manual configuration */
		dev_warn(dev->class_dev,
			 "driver '%s' does not support attach using comedi_config\n",
			 driv->driver_name);
		module_put(driv->module);
		return -ENOSYS;
	}
	/* initialize dev->driver here so
	 * comedi_error() can be called from attach */
	dev->driver = driv;
	dev->board_name = dev->board_ptr ? *(const char **)dev->board_ptr
					 : dev->driver->driver_name;
	ret = driv->attach(dev, it);
	if (ret >= 0)
		ret = comedi_device_postconfig(dev);
	if (ret < 0) {
		comedi_device_detach(dev);
		module_put(dev->driver->module);
	}
	/* On success, the driver module count has been incremented. */
	return ret;
}

int comedi_auto_config(struct device *hardware_device,
		       struct comedi_driver *driver, unsigned long context)
{
	struct comedi_device *dev;
	int ret;

	if (!hardware_device) {
		pr_warn("BUG! comedi_auto_config called with NULL hardware_device\n");
		return -EINVAL;
	}
	if (!driver) {
		dev_warn(hardware_device,
			 "BUG! comedi_auto_config called with NULL comedi driver\n");
		return -EINVAL;
	}

	if (!driver->auto_attach) {
		dev_warn(hardware_device,
			 "BUG! comedi driver '%s' has no auto_attach handler\n",
			 driver->driver_name);
		return -EINVAL;
	}

	dev = comedi_alloc_board_minor(hardware_device);
	if (IS_ERR(dev))
		return PTR_ERR(dev);
	/* Note: comedi_alloc_board_minor() locked dev->mutex. */

	dev->driver = driver;
	dev->board_name = dev->driver->driver_name;
	ret = driver->auto_attach(dev, context);
	if (ret >= 0)
		ret = comedi_device_postconfig(dev);
	if (ret < 0)
		comedi_device_detach(dev);
	mutex_unlock(&dev->mutex);

	if (ret < 0)
		comedi_release_hardware_device(hardware_device);
	return ret;
}
EXPORT_SYMBOL_GPL(comedi_auto_config);

void comedi_auto_unconfig(struct device *hardware_device)
{
	if (hardware_device == NULL)
		return;
	comedi_release_hardware_device(hardware_device);
}
EXPORT_SYMBOL_GPL(comedi_auto_unconfig);

int comedi_driver_register(struct comedi_driver *driver)
{
	driver->next = comedi_drivers;
	comedi_drivers = driver;

	return 0;
}
EXPORT_SYMBOL_GPL(comedi_driver_register);

int comedi_driver_unregister(struct comedi_driver *driver)
{
	struct comedi_driver *prev;
	int i;

	/* check for devices using this driver */
	for (i = 0; i < COMEDI_NUM_BOARD_MINORS; i++) {
		struct comedi_device *dev = comedi_dev_from_minor(i);

		if (!dev)
			continue;

		mutex_lock(&dev->mutex);
		if (dev->attached && dev->driver == driver) {
			if (dev->use_count)
				dev_warn(dev->class_dev,
					 "BUG! detaching device with use_count=%d\n",
					 dev->use_count);
			comedi_device_detach(dev);
		}
		mutex_unlock(&dev->mutex);
	}

	if (comedi_drivers == driver) {
		comedi_drivers = driver->next;
		return 0;
	}

	for (prev = comedi_drivers; prev->next; prev = prev->next) {
		if (prev->next == driver) {
			prev->next = driver->next;
			return 0;
		}
	}
	return -EINVAL;
}
EXPORT_SYMBOL_GPL(comedi_driver_unregister);
Commit	Line	Data
ed9eccbe DS	1	/*
	2	module/drivers.c
	3	functions for manipulating drivers
	4
	5	COMEDI - Linux Control and Measurement Device Interface
	6	Copyright (C) 1997-2000 David A. Schleef <ds@schleef.org>
	7
	8	This program is free software; you can redistribute it and/or modify
	9	it under the terms of the GNU General Public License as published by
	10	the Free Software Foundation; either version 2 of the License, or
	11	(at your option) any later version.
	12
	13	This program is distributed in the hope that it will be useful,
	14	but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	GNU General Public License for more details.
ed9eccbe DS	17	*/
ed9eccbe DS	18
ed9eccbe DS	19	#include <linux/device.h>
ed9eccbe DS	20	#include <linux/module.h>
ed9eccbe	21	#include <linux/errno.h>
78b10615	22	#include <linux/kconfig.h>
ed9eccbe DS	23	#include <linux/kernel.h>
	24	#include <linux/sched.h>
	25	#include <linux/fcntl.h>
	26	#include <linux/delay.h>
	27	#include <linux/ioport.h>
	28	#include <linux/mm.h>
	29	#include <linux/slab.h>
ed9eccbe DS	30	#include <linux/highmem.h> /* for SuSE brokenness */
	31	#include <linux/vmalloc.h>
	32	#include <linux/cdev.h>
	33	#include <linux/dma-mapping.h>
5617f9da	34	#include <linux/io.h>
3d1fe3f7	35	#include <linux/interrupt.h>
9ff8b151	36	#include <linux/firmware.h>
ed9eccbe	37
242e7ad9	38	#include "comedidev.h"
3a5fa275	39	#include "comedi_internal.h"
242e7ad9	40
139dfbdf	41	struct comedi_driver *comedi_drivers;
ed9eccbe	42
da717511 IA	43	int comedi_set_hw_dev(struct comedi_device dev, struct device hw_dev)
da717511 IA	44	{
de06d7c6 IA	45	if (hw_dev == dev->hw_dev)
	46	return 0;
	47	if (dev->hw_dev != NULL)
	48	return -EEXIST;
da717511	49	dev->hw_dev = get_device(hw_dev);
da717511 IA	50	return 0;
	51	}
	52	EXPORT_SYMBOL_GPL(comedi_set_hw_dev);
	53
de06d7c6 IA	54	static void comedi_clear_hw_dev(struct comedi_device *dev)
	55	{
	56	put_device(dev->hw_dev);
	57	dev->hw_dev = NULL;
	58	}
	59
8b9ba6e5	60	int comedi_alloc_subdevices(struct comedi_device *dev, int num_subdevices)
2f0b9d08	61	{
03afcf47	62	struct comedi_subdevice *s;
8b9ba6e5	63	int i;
2f0b9d08	64
7f801c41 HS	65	if (num_subdevices < 1)
7f801c41 HS	66	return -EINVAL;
03afcf47 HS	67
	68	s = kcalloc(num_subdevices, sizeof(*s), GFP_KERNEL);
	69	if (!s)
2f0b9d08	70	return -ENOMEM;
03afcf47	71	dev->subdevices = s;
fba1d0fa	72	dev->n_subdevices = num_subdevices;
03afcf47	73
2f0b9d08	74	for (i = 0; i < num_subdevices; ++i) {
5e4c58ce	75	s = &dev->subdevices[i];
03afcf47	76	s->device = dev;
90a35c15	77	s->index = i;
03afcf47 HS	78	s->async_dma_dir = DMA_NONE;
	79	spin_lock_init(&s->spin_lock);
	80	s->minor = -1;
2f0b9d08 HS	81	}
	82	return 0;
	83	}
	84	EXPORT_SYMBOL_GPL(comedi_alloc_subdevices);
	85
71b5f4f1	86	static void cleanup_device(struct comedi_device *dev)
ed9eccbe DS	87	{
ed9eccbe DS	88	int i;
34c43922	89	struct comedi_subdevice *s;
ed9eccbe DS	90
	91	if (dev->subdevices) {
	92	for (i = 0; i < dev->n_subdevices; i++) {
5e4c58ce	93	s = &dev->subdevices[i];
588ba6dc HS	94	if (s->runflags & SRF_FREE_SPRIV)
588ba6dc HS	95	kfree(s->private);
ed9eccbe DS	96	comedi_free_subdevice_minor(s);
	97	if (s->async) {
	98	comedi_buf_alloc(dev, s, 0);
	99	kfree(s->async);
	100	}
	101	}
	102	kfree(dev->subdevices);
	103	dev->subdevices = NULL;
	104	dev->n_subdevices = 0;
	105	}
dedd1325 BP	106	kfree(dev->private);
dedd1325 BP	107	dev->private = NULL;
7029a874	108	dev->driver = NULL;
ed9eccbe DS	109	dev->board_name = NULL;
	110	dev->board_ptr = NULL;
	111	dev->iobase = 0;
316f97f1	112	dev->iolen = 0;
00ca6884	113	dev->ioenabled = false;
ed9eccbe DS	114	dev->irq = 0;
	115	dev->read_subdev = NULL;
	116	dev->write_subdev = NULL;
	117	dev->open = NULL;
	118	dev->close = NULL;
de06d7c6	119	comedi_clear_hw_dev(dev);
ed9eccbe DS	120	}
ed9eccbe DS	121
016599f5	122	void comedi_device_detach(struct comedi_device *dev)
ed9eccbe	123	{
a7401cdd	124	dev->attached = false;
5617f9da	125	if (dev->driver)
ed9eccbe	126	dev->driver->detach(dev);
ed9eccbe DS	127	cleanup_device(dev);
	128	}
	129
01fca378	130	static int poll_invalid(struct comedi_device dev, struct comedi_subdevice s)
ed9eccbe	131	{
01fca378	132	return -EINVAL;
ed9eccbe DS	133	}
ed9eccbe DS	134
01fca378 HS	135	int insn_inval(struct comedi_device dev, struct comedi_subdevice s,
01fca378 HS	136	struct comedi_insn insn, unsigned int data)
ed9eccbe	137	{
01fca378	138	return -EINVAL;
ed9eccbe DS	139	}
ed9eccbe DS	140
01fca378 HS	141	static int insn_rw_emulate_bits(struct comedi_device *dev,
	142	struct comedi_subdevice *s,
	143	struct comedi_insn insn, unsigned int data)
ed9eccbe	144	{
01fca378 HS	145	struct comedi_insn new_insn;
	146	int ret;
	147	static const unsigned channels_per_bitfield = 32;
ed9eccbe	148
01fca378 HS	149	unsigned chan = CR_CHAN(insn->chanspec);
	150	const unsigned base_bitfield_channel =
	151	(chan < channels_per_bitfield) ? 0 : chan;
	152	unsigned int new_data[2];
	153	memset(new_data, 0, sizeof(new_data));
	154	memset(&new_insn, 0, sizeof(new_insn));
	155	new_insn.insn = INSN_BITS;
	156	new_insn.chanspec = base_bitfield_channel;
	157	new_insn.n = 2;
	158	new_insn.subdev = insn->subdev;
ed9eccbe	159
01fca378 HS	160	if (insn->insn == INSN_WRITE) {
	161	if (!(s->subdev_flags & SDF_WRITABLE))
	162	return -EINVAL;
	163	new_data[0] = 1 << (chan - base_bitfield_channel); /* mask */
	164	new_data[1] = data[0] ? (1 << (chan - base_bitfield_channel))
	165	: 0; /* bits */
ed9eccbe DS	166	}
ed9eccbe DS	167
01fca378 HS	168	ret = s->insn_bits(dev, s, &new_insn, new_data);
	169	if (ret < 0)
	170	return ret;
ed9eccbe	171
01fca378 HS	172	if (insn->insn == INSN_READ)
	173	data[0] = (new_data[1] >> (chan - base_bitfield_channel)) & 1;
	174
	175	return 1;
ed9eccbe DS	176	}
ed9eccbe DS	177
40f58a65 HS	178	static int __comedi_device_postconfig_async(struct comedi_device *dev,
	179	struct comedi_subdevice *s)
	180	{
	181	struct comedi_async *async;
	182	unsigned int buf_size;
	183	int ret;
	184
57b71c3e HS	185	if ((s->subdev_flags & (SDF_CMD_READ \| SDF_CMD_WRITE)) == 0) {
	186	dev_warn(dev->class_dev,
	187	"async subdevices must support SDF_CMD_READ or SDF_CMD_WRITE\n");
	188	return -EINVAL;
	189	}
	190	if (!s->do_cmdtest) {
	191	dev_warn(dev->class_dev,
	192	"async subdevices must have a do_cmdtest() function\n");
	193	return -EINVAL;
	194	}
40f58a65 HS	195
40f58a65 HS	196	async = kzalloc(sizeof(*async), GFP_KERNEL);
78110bb8	197	if (!async)
40f58a65	198	return -ENOMEM;
78110bb8	199
40f58a65 HS	200	init_waitqueue_head(&async->wait_head);
	201	async->subdevice = s;
	202	s->async = async;
	203
	204	async->max_bufsize = comedi_default_buf_maxsize_kb * 1024;
	205	buf_size = comedi_default_buf_size_kb * 1024;
	206	if (buf_size > async->max_bufsize)
	207	buf_size = async->max_bufsize;
	208
	209	if (comedi_buf_alloc(dev, s, buf_size) < 0) {
	210	dev_warn(dev->class_dev, "Buffer allocation failed\n");
	211	return -ENOMEM;
	212	}
	213	if (s->buf_change) {
	214	ret = s->buf_change(dev, s, buf_size);
	215	if (ret < 0)
	216	return ret;
	217	}
	218
f65cc544	219	comedi_alloc_subdevice_minor(s);
40f58a65 HS	220
	221	return 0;
	222	}
	223
	224	static int __comedi_device_postconfig(struct comedi_device *dev)
ed9eccbe	225	{
34c43922	226	struct comedi_subdevice *s;
ed9eccbe	227	int ret;
40f58a65	228	int i;
ed9eccbe DS	229
ed9eccbe DS	230	for (i = 0; i < dev->n_subdevices; i++) {
5e4c58ce	231	s = &dev->subdevices[i];
ed9eccbe DS	232
	233	if (s->type == COMEDI_SUBD_UNUSED)
	234	continue;
	235
	236	if (s->len_chanlist == 0)
	237	s->len_chanlist = 1;
	238
	239	if (s->do_cmd) {
40f58a65 HS	240	ret = __comedi_device_postconfig_async(dev, s);
	241	if (ret)
	242	return ret;
ed9eccbe DS	243	}
	244
	245	if (!s->range_table && !s->range_table_list)
	246	s->range_table = &range_unknown;
	247
	248	if (!s->insn_read && s->insn_bits)
	249	s->insn_read = insn_rw_emulate_bits;
	250	if (!s->insn_write && s->insn_bits)
	251	s->insn_write = insn_rw_emulate_bits;
	252
	253	if (!s->insn_read)
	254	s->insn_read = insn_inval;
	255	if (!s->insn_write)
	256	s->insn_write = insn_inval;
	257	if (!s->insn_bits)
	258	s->insn_bits = insn_inval;
	259	if (!s->insn_config)
	260	s->insn_config = insn_inval;
	261
	262	if (!s->poll)
	263	s->poll = poll_invalid;
	264	}
	265
	266	return 0;
	267	}
	268
01fca378	269	/* do a little post-config cleanup */
01fca378 HS	270	static int comedi_device_postconfig(struct comedi_device *dev)
01fca378 HS	271	{
b2a644b4 IA	272	int ret;
	273
	274	ret = __comedi_device_postconfig(dev);
ae5dd5fc	275	if (ret < 0)
01fca378	276	return ret;
01fca378	277	smp_wmb();
a7401cdd	278	dev->attached = true;
01fca378 HS	279	return 0;
	280	}
	281
4e2f002f IA	282	/*
	283	* Generic recognize function for drivers that register their supported
	284	* board names.
	285	*
	286	* 'driv->board_name' points to a 'const char *' member within the
	287	* zeroth element of an array of some private board information
	288	* structure, say 'struct foo_board' containing a member 'const char
	289	* *board_name' that is initialized to point to a board name string that
	290	* is one of the candidates matched against this function's 'name'
	291	* parameter.
	292	*
	293	* 'driv->offset' is the size of the private board information
	294	* structure, say 'sizeof(struct foo_board)', and 'driv->num_names' is
	295	* the length of the array of private board information structures.
	296	*
	297	* If one of the board names in the array of private board information
	298	* structures matches the name supplied to this function, the function
	299	* returns a pointer to the pointer to the board name, otherwise it
	300	* returns NULL. The return value ends up in the 'board_ptr' member of
	301	* a 'struct comedi_device' that the low-level comedi driver's
	302	* 'attach()' hook can convert to a point to a particular element of its
	303	* array of private board information structures by subtracting the
	304	* offset of the member that points to the board name. (No subtraction
	305	* is required if the board name pointer is the first member of the
	306	* private board information structure, which is generally the case.)
	307	*/
7029a874	308	static void comedi_recognize(struct comedi_driver driv, const char *name)
ed9eccbe	309	{
1c9de58a DC	310	char name_ptr = (char )driv->board_name;
	311	int i;
	312
ed9eccbe DS	313	for (i = 0; i < driv->num_names; i++) {
ed9eccbe DS	314	if (strcmp(*name_ptr, name) == 0)
1c9de58a DC	315	return name_ptr;
1c9de58a DC	316	name_ptr = (void *)name_ptr + driv->offset;
ed9eccbe DS	317	}
	318
	319	return NULL;
	320	}
	321
7029a874	322	static void comedi_report_boards(struct comedi_driver *driv)
ed9eccbe DS	323	{
	324	unsigned int i;
	325	const char const name_ptr;
	326
4f870fe6 IA	327	pr_info("comedi: valid board names for %s driver are:\n",
4f870fe6 IA	328	driv->driver_name);
ed9eccbe DS	329
	330	name_ptr = driv->board_name;
	331	for (i = 0; i < driv->num_names; i++) {
4f870fe6	332	pr_info(" %s\n", *name_ptr);
ed9eccbe DS	333	name_ptr = (const char *)((char )name_ptr + driv->offset);
	334	}
	335
	336	if (driv->num_names == 0)
4f870fe6	337	pr_info(" %s\n", driv->driver_name);
ed9eccbe DS	338	}
ed9eccbe DS	339
9ff8b151 HS	340	/**
	341	* comedi_load_firmware() - Request and load firmware for a device.
	342	* @dev: comedi_device struct
	343	* @hw_device: device struct for the comedi_device
	344	* @name: the name of the firmware image
	345	* @cb: callback to the upload the firmware image
d569541e	346	* @context: private context from the driver
9ff8b151 HS	347	*/
	348	int comedi_load_firmware(struct comedi_device *dev,
	349	struct device *device,
	350	const char *name,
	351	int (cb)(struct comedi_device dev,
d569541e HS	352	const u8 *data, size_t size,
	353	unsigned long context),
	354	unsigned long context)
9ff8b151 HS	355	{
	356	const struct firmware *fw;
	357	int ret;
	358
	359	if (!cb)
	360	return -EINVAL;
	361
	362	ret = request_firmware(&fw, name, device);
	363	if (ret == 0) {
d569541e	364	ret = cb(dev, fw->data, fw->size, context);
9ff8b151 HS	365	release_firmware(fw);
	366	}
	367
	368	return ret;
	369	}
	370	EXPORT_SYMBOL_GPL(comedi_load_firmware);
	371
f375ac5f	372	/**
ca8b2964	373	* __comedi_request_region() - Request an I/O reqion for a legacy driver.
f375ac5f HS	374	* @dev: comedi_device struct
	375	* @start: base address of the I/O reqion
	376	* @len: length of the I/O region
	377	*/
ca8b2964 HS	378	int __comedi_request_region(struct comedi_device *dev,
ca8b2964 HS	379	unsigned long start, unsigned long len)
f375ac5f HS	380	{
	381	if (!start) {
	382	dev_warn(dev->class_dev,
	383	"%s: a I/O base address must be specified\n",
	384	dev->board_name);
	385	return -EINVAL;
	386	}
	387
	388	if (!request_region(start, len, dev->board_name)) {
	389	dev_warn(dev->class_dev, "%s: I/O port conflict (%#lx,%lu)\n",
	390	dev->board_name, start, len);
	391	return -EIO;
	392	}
f375ac5f HS	393
	394	return 0;
	395	}
ca8b2964 HS	396	EXPORT_SYMBOL_GPL(__comedi_request_region);
	397
	398	/**
	399	* comedi_request_region() - Request an I/O reqion for a legacy driver.
	400	* @dev: comedi_device struct
	401	* @start: base address of the I/O reqion
	402	* @len: length of the I/O region
	403	*/
	404	int comedi_request_region(struct comedi_device *dev,
	405	unsigned long start, unsigned long len)
	406	{
	407	int ret;
	408
	409	ret = __comedi_request_region(dev, start, len);
316f97f1	410	if (ret == 0) {
ca8b2964	411	dev->iobase = start;
316f97f1 HS	412	dev->iolen = len;
316f97f1 HS	413	}
ca8b2964 HS	414
	415	return ret;
	416	}
f375ac5f HS	417	EXPORT_SYMBOL_GPL(comedi_request_region);
f375ac5f HS	418
316f97f1 HS	419	/**
	420	* comedi_legacy_detach() - A generic (*detach) function for legacy drivers.
	421	* @dev: comedi_device struct
	422	*/
	423	void comedi_legacy_detach(struct comedi_device *dev)
	424	{
3d1fe3f7 HS	425	if (dev->irq) {
	426	free_irq(dev->irq, dev);
	427	dev->irq = 0;
	428	}
316f97f1 HS	429	if (dev->iobase && dev->iolen) {
	430	release_region(dev->iobase, dev->iolen);
	431	dev->iobase = 0;
	432	dev->iolen = 0;
	433	}
	434	}
	435	EXPORT_SYMBOL_GPL(comedi_legacy_detach);
	436
01fca378	437	int comedi_device_attach(struct comedi_device dev, struct comedi_devconfig it)
ed9eccbe	438	{
01fca378 HS	439	struct comedi_driver *driv;
	440	int ret;
	441
	442	if (dev->attached)
	443	return -EBUSY;
	444
	445	for (driv = comedi_drivers; driv; driv = driv->next) {
	446	if (!try_module_get(driv->module))
	447	continue;
	448	if (driv->num_names) {
	449	dev->board_ptr = comedi_recognize(driv, it->board_name);
	450	if (dev->board_ptr)
	451	break;
	452	} else if (strcmp(driv->driver_name, it->board_name) == 0)
	453	break;
	454	module_put(driv->module);
	455	}
	456	if (driv == NULL) {
	457	/* recognize has failed if we get here */
	458	/* report valid board names before returning error */
	459	for (driv = comedi_drivers; driv; driv = driv->next) {
	460	if (!try_module_get(driv->module))
	461	continue;
	462	comedi_report_boards(driv);
	463	module_put(driv->module);
	464	}
	465	return -EIO;
	466	}
	467	if (driv->attach == NULL) {
	468	/* driver does not support manual configuration */
	469	dev_warn(dev->class_dev,
	470	"driver '%s' does not support attach using comedi_config\n",
	471	driv->driver_name);
	472	module_put(driv->module);
	473	return -ENOSYS;
	474	}
	475	/* initialize dev->driver here so
	476	* comedi_error() can be called from attach */
	477	dev->driver = driv;
34b68400 HS	478	dev->board_name = dev->board_ptr ? (const char *)dev->board_ptr
34b68400 HS	479	: dev->driver->driver_name;
01fca378	480	ret = driv->attach(dev, it);
74ece108 IA	481	if (ret >= 0)
74ece108 IA	482	ret = comedi_device_postconfig(dev);
01fca378	483	if (ret < 0) {
016599f5	484	comedi_device_detach(dev);
dcd7b8bd	485	module_put(dev->driver->module);
01fca378	486	}
b2a644b4 IA	487	/* On success, the driver module count has been incremented. */
b2a644b4 IA	488	return ret;
ed9eccbe DS	489	}
ed9eccbe DS	490
a588da1d IA	491	int comedi_auto_config(struct device *hardware_device,
a588da1d IA	492	struct comedi_driver *driver, unsigned long context)
f4011670	493	{
6013a9a5	494	struct comedi_device *dev;
f4011670 IA	495	int ret;
f4011670 IA	496
f08e0ac5 IA	497	if (!hardware_device) {
	498	pr_warn("BUG! comedi_auto_config called with NULL hardware_device\n");
	499	return -EINVAL;
	500	}
	501	if (!driver) {
	502	dev_warn(hardware_device,
	503	"BUG! comedi_auto_config called with NULL comedi driver\n");
	504	return -EINVAL;
	505	}
	506
a588da1d IA	507	if (!driver->auto_attach) {
	508	dev_warn(hardware_device,
	509	"BUG! comedi driver '%s' has no auto_attach handler\n",
	510	driver->driver_name);
	511	return -EINVAL;
	512	}
	513
6013a9a5 HS	514	dev = comedi_alloc_board_minor(hardware_device);
	515	if (IS_ERR(dev))
	516	return PTR_ERR(dev);
	517	/* Note: comedi_alloc_board_minor() locked dev->mutex. */
f4011670	518
6013a9a5	519	dev->driver = driver;
34b68400	520	dev->board_name = dev->driver->driver_name;
6013a9a5	521	ret = driver->auto_attach(dev, context);
74ece108	522	if (ret >= 0)
6013a9a5	523	ret = comedi_device_postconfig(dev);
b2a644b4	524	if (ret < 0)
6013a9a5 HS	525	comedi_device_detach(dev);
6013a9a5 HS	526	mutex_unlock(&dev->mutex);
f4011670 IA	527
f4011670 IA	528	if (ret < 0)
f5b31e15	529	comedi_release_hardware_device(hardware_device);
f4011670 IA	530	return ret;
f4011670 IA	531	}
8ed705af IA	532	EXPORT_SYMBOL_GPL(comedi_auto_config);
	533
	534	void comedi_auto_unconfig(struct device *hardware_device)
ed9eccbe	535	{
c43435d7 IA	536	if (hardware_device == NULL)
c43435d7 IA	537	return;
3346b798	538	comedi_release_hardware_device(hardware_device);
ed9eccbe	539	}
8ed705af	540	EXPORT_SYMBOL_GPL(comedi_auto_unconfig);
1ae6b20b HS	541
	542	int comedi_driver_register(struct comedi_driver *driver)
	543	{
	544	driver->next = comedi_drivers;
	545	comedi_drivers = driver;
	546
	547	return 0;
	548	}
5660e742	549	EXPORT_SYMBOL_GPL(comedi_driver_register);
1ae6b20b HS	550
	551	int comedi_driver_unregister(struct comedi_driver *driver)
	552	{
	553	struct comedi_driver *prev;
	554	int i;
	555
	556	/* check for devices using this driver */
	557	for (i = 0; i < COMEDI_NUM_BOARD_MINORS; i++) {
	558	struct comedi_device *dev = comedi_dev_from_minor(i);
	559
	560	if (!dev)
	561	continue;
	562
	563	mutex_lock(&dev->mutex);
	564	if (dev->attached && dev->driver == driver) {
	565	if (dev->use_count)
	566	dev_warn(dev->class_dev,
	567	"BUG! detaching device with use_count=%d\n",
	568	dev->use_count);
	569	comedi_device_detach(dev);
	570	}
	571	mutex_unlock(&dev->mutex);
	572	}
	573
	574	if (comedi_drivers == driver) {
	575	comedi_drivers = driver->next;
	576	return 0;
	577	}
	578
	579	for (prev = comedi_drivers; prev->next; prev = prev->next) {
	580	if (prev->next == driver) {
	581	prev->next = driver->next;
	582	return 0;
	583	}
	584	}
	585	return -EINVAL;
	586	}
5660e742	587	EXPORT_SYMBOL_GPL(comedi_driver_unregister);