industrialio-core.c 31.6 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11
/* The industrial I/O core
 *
 * Copyright (c) 2008 Jonathan Cameron
 *
 * 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.
 *
 * Based on elements of hwmon and input subsystems.
 */

12 13
#define pr_fmt(fmt) "iio-core: " fmt

14 15 16 17 18 19 20 21
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/idr.h>
#include <linux/kdev_t.h>
#include <linux/err.h>
#include <linux/device.h>
#include <linux/fs.h>
#include <linux/poll.h>
22
#include <linux/sched.h>
23
#include <linux/wait.h>
24
#include <linux/cdev.h>
25
#include <linux/slab.h>
26
#include <linux/anon_inodes.h>
27
#include <linux/debugfs.h>
28
#include <linux/iio/iio.h>
29
#include "iio_core.h"
30
#include "iio_core_trigger.h"
31 32
#include <linux/iio/sysfs.h>
#include <linux/iio/events.h>
33
#include <linux/iio/buffer.h>
34

35
/* IDA to assign each registered device a unique id */
36
static DEFINE_IDA(iio_ida);
37

38
static dev_t iio_devt;
39 40

#define IIO_DEV_MAX 256
41
struct bus_type iio_bus_type = {
42 43
	.name = "iio",
};
44
EXPORT_SYMBOL(iio_bus_type);
45

46 47
static struct dentry *iio_debugfs_dentry;

48 49 50 51 52
static const char * const iio_direction[] = {
	[0] = "in",
	[1] = "out",
};

53
static const char * const iio_chan_type_name_spec[] = {
54
	[IIO_VOLTAGE] = "voltage",
55 56
	[IIO_CURRENT] = "current",
	[IIO_POWER] = "power",
57
	[IIO_ACCEL] = "accel",
58
	[IIO_ANGL_VEL] = "anglvel",
59
	[IIO_MAGN] = "magn",
60 61
	[IIO_LIGHT] = "illuminance",
	[IIO_INTENSITY] = "intensity",
62
	[IIO_PROXIMITY] = "proximity",
63
	[IIO_TEMP] = "temp",
64 65 66
	[IIO_INCLI] = "incli",
	[IIO_ROT] = "rot",
	[IIO_ANGL] = "angl",
67
	[IIO_TIMESTAMP] = "timestamp",
68
	[IIO_CAPACITANCE] = "capacitance",
69
	[IIO_ALTVOLTAGE] = "altvoltage",
70
	[IIO_CCT] = "cct",
71
	[IIO_PRESSURE] = "pressure",
72
	[IIO_HUMIDITYRELATIVE] = "humidityrelative",
73 74
};

75
static const char * const iio_modifier_names[] = {
76 77 78
	[IIO_MOD_X] = "x",
	[IIO_MOD_Y] = "y",
	[IIO_MOD_Z] = "z",
79
	[IIO_MOD_ROOT_SUM_SQUARED_X_Y] = "sqrt(x^2+y^2)",
80
	[IIO_MOD_SUM_SQUARED_X_Y_Z] = "x^2+y^2+z^2",
81 82
	[IIO_MOD_LIGHT_BOTH] = "both",
	[IIO_MOD_LIGHT_IR] = "ir",
83 84 85 86
	[IIO_MOD_LIGHT_CLEAR] = "clear",
	[IIO_MOD_LIGHT_RED] = "red",
	[IIO_MOD_LIGHT_GREEN] = "green",
	[IIO_MOD_LIGHT_BLUE] = "blue",
87 88 89 90
};

/* relies on pairs of these shared then separate */
static const char * const iio_chan_info_postfix[] = {
91 92
	[IIO_CHAN_INFO_RAW] = "raw",
	[IIO_CHAN_INFO_PROCESSED] = "input",
93 94 95 96 97 98 99 100
	[IIO_CHAN_INFO_SCALE] = "scale",
	[IIO_CHAN_INFO_OFFSET] = "offset",
	[IIO_CHAN_INFO_CALIBSCALE] = "calibscale",
	[IIO_CHAN_INFO_CALIBBIAS] = "calibbias",
	[IIO_CHAN_INFO_PEAK] = "peak_raw",
	[IIO_CHAN_INFO_PEAK_SCALE] = "peak_scale",
	[IIO_CHAN_INFO_QUADRATURE_CORRECTION_RAW] = "quadrature_correction_raw",
	[IIO_CHAN_INFO_AVERAGE_RAW] = "mean_raw",
101 102
	[IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY]
	= "filter_low_pass_3db_frequency",
103
	[IIO_CHAN_INFO_SAMP_FREQ] = "sampling_frequency",
104 105
	[IIO_CHAN_INFO_FREQUENCY] = "frequency",
	[IIO_CHAN_INFO_PHASE] = "phase",
106
	[IIO_CHAN_INFO_HARDWAREGAIN] = "hardwaregain",
107
	[IIO_CHAN_INFO_HYSTERESIS] = "hysteresis",
108
	[IIO_CHAN_INFO_INT_TIME] = "integration_time",
109 110
};

111 112 113 114 115
/**
 * iio_find_channel_from_si() - get channel from its scan index
 * @indio_dev:		device
 * @si:			scan index to match
 */
116 117 118 119 120 121 122 123 124 125 126
const struct iio_chan_spec
*iio_find_channel_from_si(struct iio_dev *indio_dev, int si)
{
	int i;

	for (i = 0; i < indio_dev->num_channels; i++)
		if (indio_dev->channels[i].scan_index == si)
			return &indio_dev->channels[i];
	return NULL;
}

127 128 129 130 131 132 133 134 135 136 137 138 139
/* This turns up an awful lot */
ssize_t iio_read_const_attr(struct device *dev,
			    struct device_attribute *attr,
			    char *buf)
{
	return sprintf(buf, "%s\n", to_iio_const_attr(attr)->string);
}
EXPORT_SYMBOL(iio_read_const_attr);

static int __init iio_init(void)
{
	int ret;

140 141
	/* Register sysfs bus */
	ret  = bus_register(&iio_bus_type);
142
	if (ret < 0) {
143
		pr_err("could not register bus type\n");
144 145 146
		goto error_nothing;
	}

147 148
	ret = alloc_chrdev_region(&iio_devt, 0, IIO_DEV_MAX, "iio");
	if (ret < 0) {
149
		pr_err("failed to allocate char dev region\n");
150
		goto error_unregister_bus_type;
151
	}
152

153 154
	iio_debugfs_dentry = debugfs_create_dir("iio", NULL);

155 156
	return 0;

157 158
error_unregister_bus_type:
	bus_unregister(&iio_bus_type);
159 160 161 162 163 164
error_nothing:
	return ret;
}

static void __exit iio_exit(void)
{
165 166
	if (iio_devt)
		unregister_chrdev_region(iio_devt, IIO_DEV_MAX);
167
	bus_unregister(&iio_bus_type);
168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229
	debugfs_remove(iio_debugfs_dentry);
}

#if defined(CONFIG_DEBUG_FS)
static ssize_t iio_debugfs_read_reg(struct file *file, char __user *userbuf,
			      size_t count, loff_t *ppos)
{
	struct iio_dev *indio_dev = file->private_data;
	char buf[20];
	unsigned val = 0;
	ssize_t len;
	int ret;

	ret = indio_dev->info->debugfs_reg_access(indio_dev,
						  indio_dev->cached_reg_addr,
						  0, &val);
	if (ret)
		dev_err(indio_dev->dev.parent, "%s: read failed\n", __func__);

	len = snprintf(buf, sizeof(buf), "0x%X\n", val);

	return simple_read_from_buffer(userbuf, count, ppos, buf, len);
}

static ssize_t iio_debugfs_write_reg(struct file *file,
		     const char __user *userbuf, size_t count, loff_t *ppos)
{
	struct iio_dev *indio_dev = file->private_data;
	unsigned reg, val;
	char buf[80];
	int ret;

	count = min_t(size_t, count, (sizeof(buf)-1));
	if (copy_from_user(buf, userbuf, count))
		return -EFAULT;

	buf[count] = 0;

	ret = sscanf(buf, "%i %i", &reg, &val);

	switch (ret) {
	case 1:
		indio_dev->cached_reg_addr = reg;
		break;
	case 2:
		indio_dev->cached_reg_addr = reg;
		ret = indio_dev->info->debugfs_reg_access(indio_dev, reg,
							  val, NULL);
		if (ret) {
			dev_err(indio_dev->dev.parent, "%s: write failed\n",
				__func__);
			return ret;
		}
		break;
	default:
		return -EINVAL;
	}

	return count;
}

static const struct file_operations iio_debugfs_reg_fops = {
230
	.open = simple_open,
231 232 233 234 235 236 237
	.read = iio_debugfs_read_reg,
	.write = iio_debugfs_write_reg,
};

static void iio_device_unregister_debugfs(struct iio_dev *indio_dev)
{
	debugfs_remove_recursive(indio_dev->debugfs_dentry);
238 239
}

240 241 242 243 244 245 246
static int iio_device_register_debugfs(struct iio_dev *indio_dev)
{
	struct dentry *d;

	if (indio_dev->info->debugfs_reg_access == NULL)
		return 0;

247
	if (!iio_debugfs_dentry)
248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279
		return 0;

	indio_dev->debugfs_dentry =
		debugfs_create_dir(dev_name(&indio_dev->dev),
				   iio_debugfs_dentry);
	if (indio_dev->debugfs_dentry == NULL) {
		dev_warn(indio_dev->dev.parent,
			 "Failed to create debugfs directory\n");
		return -EFAULT;
	}

	d = debugfs_create_file("direct_reg_access", 0644,
				indio_dev->debugfs_dentry,
				indio_dev, &iio_debugfs_reg_fops);
	if (!d) {
		iio_device_unregister_debugfs(indio_dev);
		return -ENOMEM;
	}

	return 0;
}
#else
static int iio_device_register_debugfs(struct iio_dev *indio_dev)
{
	return 0;
}

static void iio_device_unregister_debugfs(struct iio_dev *indio_dev)
{
}
#endif /* CONFIG_DEBUG_FS */

280 281 282 283
static ssize_t iio_read_channel_ext_info(struct device *dev,
				     struct device_attribute *attr,
				     char *buf)
{
284
	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
285 286 287 288 289
	struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
	const struct iio_chan_spec_ext_info *ext_info;

	ext_info = &this_attr->c->ext_info[this_attr->address];

290
	return ext_info->read(indio_dev, ext_info->private, this_attr->c, buf);
291 292 293 294 295 296 297
}

static ssize_t iio_write_channel_ext_info(struct device *dev,
				     struct device_attribute *attr,
				     const char *buf,
					 size_t len)
{
298
	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
299 300 301 302 303
	struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
	const struct iio_chan_spec_ext_info *ext_info;

	ext_info = &this_attr->c->ext_info[this_attr->address];

304 305
	return ext_info->write(indio_dev, ext_info->private,
			       this_attr->c, buf, len);
306 307
}

308 309 310 311 312 313 314 315 316 317 318
ssize_t iio_enum_available_read(struct iio_dev *indio_dev,
	uintptr_t priv, const struct iio_chan_spec *chan, char *buf)
{
	const struct iio_enum *e = (const struct iio_enum *)priv;
	unsigned int i;
	size_t len = 0;

	if (!e->num_items)
		return 0;

	for (i = 0; i < e->num_items; ++i)
319
		len += scnprintf(buf + len, PAGE_SIZE - len, "%s ", e->items[i]);
320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342

	/* replace last space with a newline */
	buf[len - 1] = '\n';

	return len;
}
EXPORT_SYMBOL_GPL(iio_enum_available_read);

ssize_t iio_enum_read(struct iio_dev *indio_dev,
	uintptr_t priv, const struct iio_chan_spec *chan, char *buf)
{
	const struct iio_enum *e = (const struct iio_enum *)priv;
	int i;

	if (!e->get)
		return -EINVAL;

	i = e->get(indio_dev, chan);
	if (i < 0)
		return i;
	else if (i >= e->num_items)
		return -EINVAL;

343
	return snprintf(buf, PAGE_SIZE, "%s\n", e->items[i]);
344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370
}
EXPORT_SYMBOL_GPL(iio_enum_read);

ssize_t iio_enum_write(struct iio_dev *indio_dev,
	uintptr_t priv, const struct iio_chan_spec *chan, const char *buf,
	size_t len)
{
	const struct iio_enum *e = (const struct iio_enum *)priv;
	unsigned int i;
	int ret;

	if (!e->set)
		return -EINVAL;

	for (i = 0; i < e->num_items; i++) {
		if (sysfs_streq(buf, e->items[i]))
			break;
	}

	if (i == e->num_items)
		return -EINVAL;

	ret = e->set(indio_dev, chan, i);
	return ret ? ret : len;
}
EXPORT_SYMBOL_GPL(iio_enum_write);

371 372 373 374 375
/**
 * iio_format_value() - Formats a IIO value into its string representation
 * @buf: The buffer to which the formated value gets written
 * @type: One of the IIO_VAL_... constants. This decides how the val and val2
 *        parameters are formatted.
376
 * @vals: pointer to the values, exact meaning depends on the type parameter.
377
 */
378
ssize_t iio_format_value(char *buf, unsigned int type, int size, int *vals)
379
{
380
	unsigned long long tmp;
381
	bool scale_db = false;
382

383
	switch (type) {
384
	case IIO_VAL_INT:
385
		return sprintf(buf, "%d\n", vals[0]);
386 387 388
	case IIO_VAL_INT_PLUS_MICRO_DB:
		scale_db = true;
	case IIO_VAL_INT_PLUS_MICRO:
389 390 391
		if (vals[1] < 0)
			return sprintf(buf, "-%ld.%06u%s\n", abs(vals[0]),
					-vals[1],
392
				scale_db ? " dB" : "");
393
		else
394
			return sprintf(buf, "%d.%06u%s\n", vals[0], vals[1],
395 396
				scale_db ? " dB" : "");
	case IIO_VAL_INT_PLUS_NANO:
397 398 399
		if (vals[1] < 0)
			return sprintf(buf, "-%ld.%09u\n", abs(vals[0]),
					-vals[1]);
400
		else
401
			return sprintf(buf, "%d.%09u\n", vals[0], vals[1]);
402
	case IIO_VAL_FRACTIONAL:
403 404 405 406
		tmp = div_s64((s64)vals[0] * 1000000000LL, vals[1]);
		vals[1] = do_div(tmp, 1000000000LL);
		vals[0] = tmp;
		return sprintf(buf, "%d.%09u\n", vals[0], vals[1]);
407
	case IIO_VAL_FRACTIONAL_LOG2:
408 409 410 411 412 413 414 415 416 417 418 419 420 421 422
		tmp = (s64)vals[0] * 1000000000LL >> vals[1];
		vals[1] = do_div(tmp, 1000000000LL);
		vals[0] = tmp;
		return sprintf(buf, "%d.%09u\n", vals[0], vals[1]);
	case IIO_VAL_INT_MULTIPLE:
	{
		int i;
		int len = 0;

		for (i = 0; i < size; ++i)
			len += snprintf(&buf[len], PAGE_SIZE - len, "%d ",
								vals[i]);
		len += snprintf(&buf[len], PAGE_SIZE - len, "\n");
		return len;
	}
423
	default:
424
		return 0;
425
	}
426 427
}

428 429 430 431 432 433
static ssize_t iio_read_channel_info(struct device *dev,
				     struct device_attribute *attr,
				     char *buf)
{
	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
	struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
434 435 436 437 438 439 440 441 442 443 444 445
	int vals[INDIO_MAX_RAW_ELEMENTS];
	int ret;
	int val_len = 2;

	if (indio_dev->info->read_raw_multi)
		ret = indio_dev->info->read_raw_multi(indio_dev, this_attr->c,
							INDIO_MAX_RAW_ELEMENTS,
							vals, &val_len,
							this_attr->address);
	else
		ret = indio_dev->info->read_raw(indio_dev, this_attr->c,
				    &vals[0], &vals[1], this_attr->address);
446 447 448 449

	if (ret < 0)
		return ret;

450
	return iio_format_value(buf, ret, val_len, vals);
451 452
}

453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510
/**
 * iio_str_to_fixpoint() - Parse a fixed-point number from a string
 * @str: The string to parse
 * @fract_mult: Multiplier for the first decimal place, should be a power of 10
 * @integer: The integer part of the number
 * @fract: The fractional part of the number
 *
 * Returns 0 on success, or a negative error code if the string could not be
 * parsed.
 */
int iio_str_to_fixpoint(const char *str, int fract_mult,
	int *integer, int *fract)
{
	int i = 0, f = 0;
	bool integer_part = true, negative = false;

	if (str[0] == '-') {
		negative = true;
		str++;
	} else if (str[0] == '+') {
		str++;
	}

	while (*str) {
		if ('0' <= *str && *str <= '9') {
			if (integer_part) {
				i = i * 10 + *str - '0';
			} else {
				f += fract_mult * (*str - '0');
				fract_mult /= 10;
			}
		} else if (*str == '\n') {
			if (*(str + 1) == '\0')
				break;
			else
				return -EINVAL;
		} else if (*str == '.' && integer_part) {
			integer_part = false;
		} else {
			return -EINVAL;
		}
		str++;
	}

	if (negative) {
		if (i)
			i = -i;
		else
			f = -f;
	}

	*integer = i;
	*fract = f;

	return 0;
}
EXPORT_SYMBOL_GPL(iio_str_to_fixpoint);

511 512 513 514 515
static ssize_t iio_write_channel_info(struct device *dev,
				      struct device_attribute *attr,
				      const char *buf,
				      size_t len)
{
516
	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
517
	struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
518 519
	int ret, fract_mult = 100000;
	int integer, fract;
520 521

	/* Assumes decimal - precision based on number of digits */
522
	if (!indio_dev->info->write_raw)
523
		return -EINVAL;
524 525 526 527 528 529 530 531 532 533 534 535 536 537

	if (indio_dev->info->write_raw_get_fmt)
		switch (indio_dev->info->write_raw_get_fmt(indio_dev,
			this_attr->c, this_attr->address)) {
		case IIO_VAL_INT_PLUS_MICRO:
			fract_mult = 100000;
			break;
		case IIO_VAL_INT_PLUS_NANO:
			fract_mult = 100000000;
			break;
		default:
			return -EINVAL;
		}

538 539 540
	ret = iio_str_to_fixpoint(buf, fract_mult, &integer, &fract);
	if (ret)
		return ret;
541

542
	ret = indio_dev->info->write_raw(indio_dev, this_attr->c,
543
					 integer, fract, this_attr->address);
544 545 546 547 548 549
	if (ret)
		return ret;

	return len;
}

550
static
551 552 553 554 555 556 557 558 559 560
int __iio_device_attr_init(struct device_attribute *dev_attr,
			   const char *postfix,
			   struct iio_chan_spec const *chan,
			   ssize_t (*readfunc)(struct device *dev,
					       struct device_attribute *attr,
					       char *buf),
			   ssize_t (*writefunc)(struct device *dev,
						struct device_attribute *attr,
						const char *buf,
						size_t len),
561
			   enum iio_shared_by shared_by)
562
{
563
	int ret = 0;
564
	char *name = NULL;
565
	char *full_postfix;
566 567
	sysfs_attr_init(&dev_attr->attr);

568
	/* Build up postfix of <extend_name>_<modifier>_postfix */
569
	if (chan->modified && (shared_by == IIO_SEPARATE)) {
570 571 572 573 574 575 576 577 578 579 580 581
		if (chan->extend_name)
			full_postfix = kasprintf(GFP_KERNEL, "%s_%s_%s",
						 iio_modifier_names[chan
								    ->channel2],
						 chan->extend_name,
						 postfix);
		else
			full_postfix = kasprintf(GFP_KERNEL, "%s_%s",
						 iio_modifier_names[chan
								    ->channel2],
						 postfix);
	} else {
582
		if (chan->extend_name == NULL || shared_by != IIO_SEPARATE)
583 584 585 586 587 588 589
			full_postfix = kstrdup(postfix, GFP_KERNEL);
		else
			full_postfix = kasprintf(GFP_KERNEL,
						 "%s_%s",
						 chan->extend_name,
						 postfix);
	}
590 591
	if (full_postfix == NULL)
		return -ENOMEM;
592

593
	if (chan->differential) { /* Differential can not have modifier */
594
		switch (shared_by) {
595
		case IIO_SHARED_BY_ALL:
596
			name = kasprintf(GFP_KERNEL, "%s", full_postfix);
597 598
			break;
		case IIO_SHARED_BY_DIR:
599
			name = kasprintf(GFP_KERNEL, "%s_%s",
600 601 602
						iio_direction[chan->output],
						full_postfix);
			break;
603
		case IIO_SHARED_BY_TYPE:
604
			name = kasprintf(GFP_KERNEL, "%s_%s-%s_%s",
605 606 607 608
					    iio_direction[chan->output],
					    iio_chan_type_name_spec[chan->type],
					    iio_chan_type_name_spec[chan->type],
					    full_postfix);
609 610 611 612 613 614 615
			break;
		case IIO_SEPARATE:
			if (!chan->indexed) {
				WARN_ON("Differential channels must be indexed\n");
				ret = -EINVAL;
				goto error_free_full_postfix;
			}
616
			name = kasprintf(GFP_KERNEL,
617
					    "%s_%s%d-%s%d_%s",
618 619 620 621 622 623
					    iio_direction[chan->output],
					    iio_chan_type_name_spec[chan->type],
					    chan->channel,
					    iio_chan_type_name_spec[chan->type],
					    chan->channel2,
					    full_postfix);
624
			break;
625 626
		}
	} else { /* Single ended */
627
		switch (shared_by) {
628
		case IIO_SHARED_BY_ALL:
629
			name = kasprintf(GFP_KERNEL, "%s", full_postfix);
630 631
			break;
		case IIO_SHARED_BY_DIR:
632
			name = kasprintf(GFP_KERNEL, "%s_%s",
633 634 635
						iio_direction[chan->output],
						full_postfix);
			break;
636
		case IIO_SHARED_BY_TYPE:
637
			name = kasprintf(GFP_KERNEL, "%s_%s_%s",
638 639 640
					    iio_direction[chan->output],
					    iio_chan_type_name_spec[chan->type],
					    full_postfix);
641 642 643 644
			break;

		case IIO_SEPARATE:
			if (chan->indexed)
645
				name = kasprintf(GFP_KERNEL, "%s_%s%d_%s",
646 647 648 649 650
						    iio_direction[chan->output],
						    iio_chan_type_name_spec[chan->type],
						    chan->channel,
						    full_postfix);
			else
651
				name = kasprintf(GFP_KERNEL, "%s_%s_%s",
652 653 654 655 656
						    iio_direction[chan->output],
						    iio_chan_type_name_spec[chan->type],
						    full_postfix);
			break;
		}
657
	}
658
	if (name == NULL) {
659 660 661
		ret = -ENOMEM;
		goto error_free_full_postfix;
	}
662
	dev_attr->attr.name = name;
663 664 665 666 667 668 669 670 671 672

	if (readfunc) {
		dev_attr->attr.mode |= S_IRUGO;
		dev_attr->show = readfunc;
	}

	if (writefunc) {
		dev_attr->attr.mode |= S_IWUSR;
		dev_attr->store = writefunc;
	}
673

674 675
error_free_full_postfix:
	kfree(full_postfix);
676

677 678 679
	return ret;
}

680
static void __iio_device_attr_deinit(struct device_attribute *dev_attr)
681 682 683 684 685 686 687 688 689 690 691 692 693
{
	kfree(dev_attr->attr.name);
}

int __iio_add_chan_devattr(const char *postfix,
			   struct iio_chan_spec const *chan,
			   ssize_t (*readfunc)(struct device *dev,
					       struct device_attribute *attr,
					       char *buf),
			   ssize_t (*writefunc)(struct device *dev,
						struct device_attribute *attr,
						const char *buf,
						size_t len),
694
			   u64 mask,
695
			   enum iio_shared_by shared_by,
696 697 698 699 700 701
			   struct device *dev,
			   struct list_head *attr_list)
{
	int ret;
	struct iio_dev_attr *iio_attr, *t;

702
	iio_attr = kzalloc(sizeof(*iio_attr), GFP_KERNEL);
703 704
	if (iio_attr == NULL)
		return -ENOMEM;
705 706
	ret = __iio_device_attr_init(&iio_attr->dev_attr,
				     postfix, chan,
707
				     readfunc, writefunc, shared_by);
708 709 710 711 712 713 714
	if (ret)
		goto error_iio_dev_attr_free;
	iio_attr->c = chan;
	iio_attr->address = mask;
	list_for_each_entry(t, attr_list, l)
		if (strcmp(t->dev_attr.attr.name,
			   iio_attr->dev_attr.attr.name) == 0) {
715
			if (shared_by == IIO_SEPARATE)
716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731
				dev_err(dev, "tried to double register : %s\n",
					t->dev_attr.attr.name);
			ret = -EBUSY;
			goto error_device_attr_deinit;
		}
	list_add(&iio_attr->l, attr_list);

	return 0;

error_device_attr_deinit:
	__iio_device_attr_deinit(&iio_attr->dev_attr);
error_iio_dev_attr_free:
	kfree(iio_attr);
	return ret;
}

732 733 734 735
static int iio_device_add_info_mask_type(struct iio_dev *indio_dev,
					 struct iio_chan_spec const *chan,
					 enum iio_shared_by shared_by,
					 const long *infomask)
736
{
737
	int i, ret, attrcount = 0;
738

739
	for_each_set_bit(i, infomask, sizeof(infomask)*8) {
740 741
		if (i >= ARRAY_SIZE(iio_chan_info_postfix))
			return -EINVAL;
742 743 744 745 746
		ret = __iio_add_chan_devattr(iio_chan_info_postfix[i],
					     chan,
					     &iio_read_channel_info,
					     &iio_write_channel_info,
					     i,
747
					     shared_by,
748 749
					     &indio_dev->dev,
					     &indio_dev->channel_attr_list);
750
		if ((ret == -EBUSY) && (shared_by != IIO_SEPARATE))
751
			continue;
752 753
		else if (ret < 0)
			return ret;
754 755
		attrcount++;
	}
756

757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781
	return attrcount;
}

static int iio_device_add_channel_sysfs(struct iio_dev *indio_dev,
					struct iio_chan_spec const *chan)
{
	int ret, attrcount = 0;
	const struct iio_chan_spec_ext_info *ext_info;

	if (chan->channel < 0)
		return 0;
	ret = iio_device_add_info_mask_type(indio_dev, chan,
					    IIO_SEPARATE,
					    &chan->info_mask_separate);
	if (ret < 0)
		return ret;
	attrcount += ret;

	ret = iio_device_add_info_mask_type(indio_dev, chan,
					    IIO_SHARED_BY_TYPE,
					    &chan->info_mask_shared_by_type);
	if (ret < 0)
		return ret;
	attrcount += ret;

782 783 784 785 786 787 788 789 790 791 792 793 794 795
	ret = iio_device_add_info_mask_type(indio_dev, chan,
					    IIO_SHARED_BY_DIR,
					    &chan->info_mask_shared_by_dir);
	if (ret < 0)
		return ret;
	attrcount += ret;

	ret = iio_device_add_info_mask_type(indio_dev, chan,
					    IIO_SHARED_BY_ALL,
					    &chan->info_mask_shared_by_all);
	if (ret < 0)
		return ret;
	attrcount += ret;

796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813
	if (chan->ext_info) {
		unsigned int i = 0;
		for (ext_info = chan->ext_info; ext_info->name; ext_info++) {
			ret = __iio_add_chan_devattr(ext_info->name,
					chan,
					ext_info->read ?
					    &iio_read_channel_ext_info : NULL,
					ext_info->write ?
					    &iio_write_channel_ext_info : NULL,
					i,
					ext_info->shared,
					&indio_dev->dev,
					&indio_dev->channel_attr_list);
			i++;
			if (ret == -EBUSY && ext_info->shared)
				continue;

			if (ret)
814
				return ret;
815 816 817 818 819

			attrcount++;
		}
	}

820
	return attrcount;
821 822
}

823 824 825 826 827 828 829 830 831
/**
 * iio_free_chan_devattr_list() - Free a list of IIO device attributes
 * @attr_list: List of IIO device attributes
 *
 * This function frees the memory allocated for each of the IIO device
 * attributes in the list. Note: if you want to reuse the list after calling
 * this function you have to reinitialize it using INIT_LIST_HEAD().
 */
void iio_free_chan_devattr_list(struct list_head *attr_list)
832
{
833 834 835 836 837 838
	struct iio_dev_attr *p, *n;

	list_for_each_entry_safe(p, n, attr_list, l) {
		kfree(p->dev_attr.attr.name);
		kfree(p);
	}
839 840
}

841 842 843 844
static ssize_t iio_show_dev_name(struct device *dev,
				 struct device_attribute *attr,
				 char *buf)
{
845
	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
846
	return snprintf(buf, PAGE_SIZE, "%s\n", indio_dev->name);
847 848 849 850
}

static DEVICE_ATTR(name, S_IRUGO, iio_show_dev_name, NULL);

851
static int iio_device_register_sysfs(struct iio_dev *indio_dev)
852
{
853
	int i, ret = 0, attrcount, attrn, attrcount_orig = 0;
854
	struct iio_dev_attr *p;
855
	struct attribute **attr;
856

857
	/* First count elements in any existing group */
858 859
	if (indio_dev->info->attrs) {
		attr = indio_dev->info->attrs->attrs;
860 861
		while (*attr++ != NULL)
			attrcount_orig++;
862
	}
863
	attrcount = attrcount_orig;
864 865
	/*
	 * New channel registration method - relies on the fact a group does
Peter Meerwald's avatar
Peter Meerwald committed
866
	 * not need to be initialized if its name is NULL.
867
	 */
868 869 870 871
	if (indio_dev->channels)
		for (i = 0; i < indio_dev->num_channels; i++) {
			ret = iio_device_add_channel_sysfs(indio_dev,
							   &indio_dev
872 873 874
							   ->channels[i]);
			if (ret < 0)
				goto error_clear_attrs;
875
			attrcount += ret;
876
		}
877

878
	if (indio_dev->name)
879 880
		attrcount++;

881 882 883
	indio_dev->chan_attr_group.attrs = kcalloc(attrcount + 1,
						   sizeof(indio_dev->chan_attr_group.attrs[0]),
						   GFP_KERNEL);
884
	if (indio_dev->chan_attr_group.attrs == NULL) {
885 886
		ret = -ENOMEM;
		goto error_clear_attrs;
887
	}
888
	/* Copy across original attributes */
889 890 891 892
	if (indio_dev->info->attrs)
		memcpy(indio_dev->chan_attr_group.attrs,
		       indio_dev->info->attrs->attrs,
		       sizeof(indio_dev->chan_attr_group.attrs[0])
893 894 895
		       *attrcount_orig);
	attrn = attrcount_orig;
	/* Add all elements from the list. */
896 897 898 899
	list_for_each_entry(p, &indio_dev->channel_attr_list, l)
		indio_dev->chan_attr_group.attrs[attrn++] = &p->dev_attr.attr;
	if (indio_dev->name)
		indio_dev->chan_attr_group.attrs[attrn++] = &dev_attr_name.attr;
900

901 902
	indio_dev->groups[indio_dev->groupcounter++] =
		&indio_dev->chan_attr_group;
903

904
	return 0;
905

906
error_clear_attrs:
907
	iio_free_chan_devattr_list(&indio_dev->channel_attr_list);
908

909
	return ret;
910 911
}

912
static void iio_device_unregister_sysfs(struct iio_dev *indio_dev)
913
{
914

915
	iio_free_chan_devattr_list(&indio_dev->channel_attr_list);
916
	kfree(indio_dev->chan_attr_group.attrs);
917 918 919 920
}

static void iio_dev_release(struct device *device)
{
921
	struct iio_dev *indio_dev = dev_to_iio_dev(device);
922 923 924 925
	if (indio_dev->modes & INDIO_BUFFER_TRIGGERED)
		iio_device_unregister_trigger_consumer(indio_dev);
	iio_device_unregister_eventset(indio_dev);
	iio_device_unregister_sysfs(indio_dev);
926

927 928
	iio_buffer_put(indio_dev->buffer);

929 930
	ida_simple_remove(&iio_ida, indio_dev->id);
	kfree(indio_dev);
931 932
}

Guenter Roeck's avatar
Guenter Roeck committed
933
struct device_type iio_device_type = {
934 935 936 937
	.name = "iio_device",
	.release = iio_dev_release,
};

938 939 940 941
/**
 * iio_device_alloc() - allocate an iio_dev from a driver
 * @sizeof_priv:	Space to allocate for private structure.
 **/
942
struct iio_dev *iio_device_alloc(int sizeof_priv)
943
{
944 945 946 947 948 949 950 951 952 953 954 955
	struct iio_dev *dev;
	size_t alloc_size;

	alloc_size = sizeof(struct iio_dev);
	if (sizeof_priv) {
		alloc_size = ALIGN(alloc_size, IIO_ALIGN);
		alloc_size += sizeof_priv;
	}
	/* ensure 32-byte alignment of whole construct ? */
	alloc_size += IIO_ALIGN - 1;

	dev = kzalloc(alloc_size, GFP_KERNEL);
956 957

	if (dev) {
958
		dev->dev.groups = dev->groups;
Guenter Roeck's avatar
Guenter Roeck committed
959
		dev->dev.type = &iio_device_type;
960
		dev->dev.bus = &iio_bus_type;
961 962 963
		device_initialize(&dev->dev);
		dev_set_drvdata(&dev->dev, (void *)dev);
		mutex_init(&dev->mlock);
964
		mutex_init(&dev->info_exist_lock);
965
		INIT_LIST_HEAD(&dev->channel_attr_list);
966 967 968 969

		dev->id = ida_simple_get(&iio_ida, 0, 0, GFP_KERNEL);
		if (dev->id < 0) {
			/* cannot use a dev_err as the name isn't available */
970
			pr_err("failed to get device id\n");
971 972 973 974
			kfree(dev);
			return NULL;
		}
		dev_set_name(&dev->dev, "iio:device%d", dev->id);
975
		INIT_LIST_HEAD(&dev->buffer_list);
976 977 978 979
	}

	return dev;
}
980
EXPORT_SYMBOL(iio_device_alloc);
981

982 983 984 985
/**
 * iio_device_free() - free an iio_dev from a driver
 * @dev:		the iio_dev associated with the device
 **/
986
void iio_device_free(struct iio_dev *dev)
987
{
988 989
	if (dev)
		put_device(&dev->dev);
990
}
991
EXPORT_SYMBOL(iio_device_free);
992

993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007
static void devm_iio_device_release(struct device *dev, void *res)
{
	iio_device_free(*(struct iio_dev **)res);
}

static int devm_iio_device_match(struct device *dev, void *res, void *data)
{
	struct iio_dev **r = res;
	if (!r || !*r) {
		WARN_ON(!r || !*r);
		return 0;
	}
	return *r == data;
}

1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021
/**
 * devm_iio_device_alloc - Resource-managed iio_device_alloc()
 * @dev:		Device to allocate iio_dev for
 * @sizeof_priv:	Space to allocate for private structure.
 *
 * Managed iio_device_alloc. iio_dev allocated with this function is
 * automatically freed on driver detach.
 *
 * If an iio_dev allocated with this function needs to be freed separately,
 * devm_iio_device_free() must be used.
 *
 * RETURNS:
 * Pointer to allocated iio_dev on success, NULL on failure.
 */
1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043
struct iio_dev *devm_iio_device_alloc(struct device *dev, int sizeof_priv)
{
	struct iio_dev **ptr, *iio_dev;

	ptr = devres_alloc(devm_iio_device_release, sizeof(*ptr),
			   GFP_KERNEL);
	if (!ptr)
		return NULL;

	/* use raw alloc_dr for kmalloc caller tracing */
	iio_dev = iio_device_alloc(sizeof_priv);
	if (iio_dev) {
		*ptr = iio_dev;
		devres_add(dev, ptr);
	} else {
		devres_free(ptr);
	}

	return iio_dev;
}
EXPORT_SYMBOL_GPL(devm_iio_device_alloc);

1044 1045 1046 1047 1048 1049 1050
/**
 * devm_iio_device_free - Resource-managed iio_device_free()
 * @dev:		Device this iio_dev belongs to
 * @iio_dev:		the iio_dev associated with the device
 *
 * Free iio_dev allocated with devm_iio_device_alloc().
 */
1051 1052 1053 1054 1055 1056 1057 1058 1059 1060
void devm_iio_device_free(struct device *dev, struct iio_dev *iio_dev)
{
	int rc;

	rc = devres_release(dev, devm_iio_device_release,
			    devm_iio_device_match, iio_dev);
	WARN_ON(rc);
}
EXPORT_SYMBOL_GPL(devm_iio_device_free);

1061
/**
1062
 * iio_chrdev_open() - chrdev file open for buffer access and ioctls
1063 1064 1065
 **/
static int iio_chrdev_open(struct inode *inode, struct file *filp)
{
1066
	struct iio_dev *indio_dev = container_of(inode->i_cdev,
1067
						struct iio_dev, chrdev);
1068 1069 1070 1071

	if (test_and_set_bit(IIO_BUSY_BIT_POS, &indio_dev->flags))
		return -EBUSY;

1072 1073
	iio_device_get(indio_dev);

1074
	filp->private_data = indio_dev;
1075

1076
	return 0;
1077 1078 1079
}

/**
1080
 * iio_chrdev_release() - chrdev file close buffer access and ioctls
1081 1082 1083
 **/
static int iio_chrdev_release(struct inode *inode, struct file *filp)
{
1084 1085 1086
	struct iio_dev *indio_dev = container_of(inode->i_cdev,
						struct iio_dev, chrdev);
	clear_bit(IIO_BUSY_BIT_POS, &indio_dev->flags);
1087 1088
	iio_device_put(indio_dev);

1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099
	return 0;
}

/* Somewhat of a cross file organization violation - ioctls here are actually
 * event related */
static long iio_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
	struct iio_dev *indio_dev = filp->private_data;
	int __user *ip = (int __user *)arg;
	int fd;

1100 1101 1102
	if (!indio_dev->info)
		return -ENODEV;

1103 1104 1105 1106 1107 1108 1109 1110 1111
	if (cmd == IIO_GET_EVENT_FD_IOCTL) {
		fd = iio_event_getfd(indio_dev);
		if (copy_to_user(ip, &fd, sizeof(fd)))
			return -EFAULT;
		return 0;
	}
	return -EINVAL;
}

1112 1113
static const struct file_operations iio_buffer_fileops = {
	.read = iio_buffer_read_first_n_outer_addr,
1114 1115
	.release = iio_chrdev_release,
	.open = iio_chrdev_open,
1116
	.poll = iio_buffer_poll_addr,
1117 1118 1119 1120 1121 1122
	.owner = THIS_MODULE,
	.llseek = noop_llseek,
	.unlocked_ioctl = iio_ioctl,
	.compat_ioctl = iio_ioctl,
};

1123 1124
static const struct iio_buffer_setup_ops noop_ring_setup_ops;

1125 1126 1127 1128
/**
 * iio_device_register() - register a device with the IIO subsystem
 * @indio_dev:		Device structure filled by the device driver
 **/
1129
int iio_device_register(struct iio_dev *indio_dev)
1130 1131 1132
{
	int ret;

Guenter Roeck's avatar
Guenter Roeck committed
1133 1134 1135 1136
	/* If the calling driver did not initialize of_node, do it here */
	if (!indio_dev->dev.of_node && indio_dev->dev.parent)
		indio_dev->dev.of_node = indio_dev->dev.parent->of_node;

1137
	/* configure elements for the chrdev */
1138
	indio_dev->dev.devt = MKDEV(MAJOR(iio_devt), indio_dev->id);
1139

1140 1141 1142 1143
	ret = iio_device_register_debugfs(indio_dev);
	if (ret) {
		dev_err(indio_dev->dev.parent,
			"Failed to register debugfs interfaces\n");
1144
		return ret;
1145
	}
1146
	ret = iio_device_register_sysfs(indio_dev);
1147
	if (ret) {
1148
		dev_err(indio_dev->dev.parent,
1149
			"Failed to register sysfs interfaces\n");
1150
		goto error_unreg_debugfs;
1151
	}
1152
	ret = iio_device_register_eventset(indio_dev);
1153
	if (ret) {
1154
		dev_err(indio_dev->dev.parent,
1155
			"Failed to register event set\n");
1156 1157
		goto error_free_sysfs;
	}
1158 1159
	if (indio_dev->modes & INDIO_BUFFER_TRIGGERED)
		iio_device_register_trigger_consumer(indio_dev);
1160

1161 1162 1163 1164
	if ((indio_dev->modes & INDIO_ALL_BUFFER_MODES) &&
		indio_dev->setup_ops == NULL)
		indio_dev->setup_ops = &noop_ring_setup_ops;

1165 1166
	cdev_init(&indio_dev->chrdev, &iio_buffer_fileops);
	indio_dev->chrdev.owner = indio_dev->info->driver_module;
1167
	indio_dev->chrdev.kobj.parent = &indio_dev->dev.kobj;
1168
	ret = cdev_add(&indio_dev->chrdev, indio_dev->dev.devt, 1);
1169
	if (ret < 0)
1170
		goto error_unreg_eventset;
1171

1172 1173 1174 1175 1176 1177 1178
	ret = device_add(&indio_dev->dev);
	if (ret < 0)
		goto error_cdev_del;

	return 0;
error_cdev_del:
	cdev_del(&indio_dev->chrdev);
1179
error_unreg_eventset:
1180
	iio_device_unregister_eventset(indio_dev);
1181
error_free_sysfs:
1182
	iio_device_unregister_sysfs(indio_dev);
1183 1184
error_unreg_debugfs:
	iio_device_unregister_debugfs(indio_dev);
1185 1186 1187 1188
	return ret;
}
EXPORT_SYMBOL(iio_device_register);

1189 1190 1191 1192
/**
 * iio_device_unregister() - unregister a device from the IIO subsystem
 * @indio_dev:		Device structure representing the device.
 **/
1193
void iio_device_unregister(struct iio_dev *indio_dev)
1194
{
1195
	mutex_lock(&indio_dev->info_exist_lock);
1196 1197 1198

	device_del(&indio_dev->dev);

1199 1200
	if (indio_dev->chrdev.dev)
		cdev_del(&indio_dev->chrdev);
1201
	iio_device_unregister_debugfs(indio_dev);
1202

1203 1204
	iio_disable_all_buffers(indio_dev);

1205
	indio_dev->info = NULL;
1206 1207 1208 1209

	iio_device_wakeup_eventset(indio_dev);
	iio_buffer_wakeup_poll(indio_dev);

1210
	mutex_unlock(&indio_dev->info_exist_lock);
1211 1212
}
EXPORT_SYMBOL(iio_device_unregister);
1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271

static void devm_iio_device_unreg(struct device *dev, void *res)
{
	iio_device_unregister(*(struct iio_dev **)res);
}

/**
 * devm_iio_device_register - Resource-managed iio_device_register()
 * @dev:	Device to allocate iio_dev for
 * @indio_dev:	Device structure filled by the device driver
 *
 * Managed iio_device_register.  The IIO device registered with this
 * function is automatically unregistered on driver detach. This function
 * calls iio_device_register() internally. Refer to that function for more
 * information.
 *
 * If an iio_dev registered with this function needs to be unregistered
 * separately, devm_iio_device_unregister() must be used.
 *
 * RETURNS:
 * 0 on success, negative error number on failure.
 */
int devm_iio_device_register(struct device *dev, struct iio_dev *indio_dev)
{
	struct iio_dev **ptr;
	int ret;

	ptr = devres_alloc(devm_iio_device_unreg, sizeof(*ptr), GFP_KERNEL);
	if (!ptr)
		return -ENOMEM;

	*ptr = indio_dev;
	ret = iio_device_register(indio_dev);
	if (!ret)
		devres_add(dev, ptr);
	else
		devres_free(ptr);

	return ret;
}
EXPORT_SYMBOL_GPL(devm_iio_device_register);

/**
 * devm_iio_device_unregister - Resource-managed iio_device_unregister()
 * @dev:	Device this iio_dev belongs to
 * @indio_dev:	the iio_dev associated with the device
 *
 * Unregister iio_dev registered with devm_iio_device_register().
 */
void devm_iio_device_unregister(struct device *dev, struct iio_dev *indio_dev)
{
	int rc;

	rc = devres_release(dev, devm_iio_device_unreg,
			    devm_iio_device_match, indio_dev);
	WARN_ON(rc);
}
EXPORT_SYMBOL_GPL(devm_iio_device_unregister);

1272 1273 1274
subsys_initcall(iio_init);
module_exit(iio_exit);

1275
MODULE_AUTHOR("Jonathan Cameron <jic23@kernel.org>");
1276 1277
MODULE_DESCRIPTION("Industrial I/O core");
MODULE_LICENSE("GPL");