1 /* The industrial I/O core, trigger handling functions 2 * 3 * Copyright (c) 2008 Jonathan Cameron 4 * 5 * This program is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 as published by 7 * the Free Software Foundation. 8 */ 9 10 #include <linux/kernel.h> 11 #include <linux/idr.h> 12 #include <linux/err.h> 13 #include <linux/device.h> 14 #include <linux/interrupt.h> 15 #include <linux/list.h> 16 #include <linux/slab.h> 17 18 #include <linux/iio/iio.h> 19 #include <linux/iio/trigger.h> 20 #include "iio_core.h" 21 #include "iio_core_trigger.h" 22 #include <linux/iio/trigger_consumer.h> 23 24 /* RFC - Question of approach 25 * Make the common case (single sensor single trigger) 26 * simple by starting trigger capture from when first sensors 27 * is added. 28 * 29 * Complex simultaneous start requires use of 'hold' functionality 30 * of the trigger. (not implemented) 31 * 32 * Any other suggestions? 33 */ 34 35 static DEFINE_IDA(iio_trigger_ida); 36 37 /* Single list of all available triggers */ 38 static LIST_HEAD(iio_trigger_list); 39 static DEFINE_MUTEX(iio_trigger_list_lock); 40 41 /** 42 * iio_trigger_read_name() - retrieve useful identifying name 43 * @dev: device associated with the iio_trigger 44 * @attr: pointer to the device_attribute structure that is 45 * being processed 46 * @buf: buffer to print the name into 47 * 48 * Return: a negative number on failure or the number of written 49 * characters on success. 50 */ 51 static ssize_t iio_trigger_read_name(struct device *dev, 52 struct device_attribute *attr, 53 char *buf) 54 { 55 struct iio_trigger *trig = to_iio_trigger(dev); 56 return sprintf(buf, "%s\n", trig->name); 57 } 58 59 static DEVICE_ATTR(name, S_IRUGO, iio_trigger_read_name, NULL); 60 61 static struct attribute *iio_trig_dev_attrs[] = { 62 &dev_attr_name.attr, 63 NULL, 64 }; 65 ATTRIBUTE_GROUPS(iio_trig_dev); 66 67 static struct iio_trigger *__iio_trigger_find_by_name(const char *name); 68 69 int iio_trigger_register(struct iio_trigger *trig_info) 70 { 71 int ret; 72 73 /* trig_info->ops is required for the module member */ 74 if (!trig_info->ops) 75 return -EINVAL; 76 77 trig_info->id = ida_simple_get(&iio_trigger_ida, 0, 0, GFP_KERNEL); 78 if (trig_info->id < 0) 79 return trig_info->id; 80 81 /* Set the name used for the sysfs directory etc */ 82 dev_set_name(&trig_info->dev, "trigger%ld", 83 (unsigned long) trig_info->id); 84 85 ret = device_add(&trig_info->dev); 86 if (ret) 87 goto error_unregister_id; 88 89 /* Add to list of available triggers held by the IIO core */ 90 mutex_lock(&iio_trigger_list_lock); 91 if (__iio_trigger_find_by_name(trig_info->name)) { 92 pr_err("Duplicate trigger name '%s'\n", trig_info->name); 93 ret = -EEXIST; 94 goto error_device_del; 95 } 96 list_add_tail(&trig_info->list, &iio_trigger_list); 97 mutex_unlock(&iio_trigger_list_lock); 98 99 return 0; 100 101 error_device_del: 102 mutex_unlock(&iio_trigger_list_lock); 103 device_del(&trig_info->dev); 104 error_unregister_id: 105 ida_simple_remove(&iio_trigger_ida, trig_info->id); 106 return ret; 107 } 108 EXPORT_SYMBOL(iio_trigger_register); 109 110 void iio_trigger_unregister(struct iio_trigger *trig_info) 111 { 112 mutex_lock(&iio_trigger_list_lock); 113 list_del(&trig_info->list); 114 mutex_unlock(&iio_trigger_list_lock); 115 116 ida_simple_remove(&iio_trigger_ida, trig_info->id); 117 /* Possible issue in here */ 118 device_del(&trig_info->dev); 119 } 120 EXPORT_SYMBOL(iio_trigger_unregister); 121 122 /* Search for trigger by name, assuming iio_trigger_list_lock held */ 123 static struct iio_trigger *__iio_trigger_find_by_name(const char *name) 124 { 125 struct iio_trigger *iter; 126 127 list_for_each_entry(iter, &iio_trigger_list, list) 128 if (!strcmp(iter->name, name)) 129 return iter; 130 131 return NULL; 132 } 133 134 static struct iio_trigger *iio_trigger_find_by_name(const char *name, 135 size_t len) 136 { 137 struct iio_trigger *trig = NULL, *iter; 138 139 mutex_lock(&iio_trigger_list_lock); 140 list_for_each_entry(iter, &iio_trigger_list, list) 141 if (sysfs_streq(iter->name, name)) { 142 trig = iter; 143 break; 144 } 145 mutex_unlock(&iio_trigger_list_lock); 146 147 return trig; 148 } 149 150 void iio_trigger_poll(struct iio_trigger *trig) 151 { 152 int i; 153 154 if (!atomic_read(&trig->use_count)) { 155 atomic_set(&trig->use_count, CONFIG_IIO_CONSUMERS_PER_TRIGGER); 156 157 for (i = 0; i < CONFIG_IIO_CONSUMERS_PER_TRIGGER; i++) { 158 if (trig->subirqs[i].enabled) 159 generic_handle_irq(trig->subirq_base + i); 160 else 161 iio_trigger_notify_done(trig); 162 } 163 } 164 } 165 EXPORT_SYMBOL(iio_trigger_poll); 166 167 irqreturn_t iio_trigger_generic_data_rdy_poll(int irq, void *private) 168 { 169 iio_trigger_poll(private); 170 return IRQ_HANDLED; 171 } 172 EXPORT_SYMBOL(iio_trigger_generic_data_rdy_poll); 173 174 void iio_trigger_poll_chained(struct iio_trigger *trig) 175 { 176 int i; 177 178 if (!atomic_read(&trig->use_count)) { 179 atomic_set(&trig->use_count, CONFIG_IIO_CONSUMERS_PER_TRIGGER); 180 181 for (i = 0; i < CONFIG_IIO_CONSUMERS_PER_TRIGGER; i++) { 182 if (trig->subirqs[i].enabled) 183 handle_nested_irq(trig->subirq_base + i); 184 else 185 iio_trigger_notify_done(trig); 186 } 187 } 188 } 189 EXPORT_SYMBOL(iio_trigger_poll_chained); 190 191 void iio_trigger_notify_done(struct iio_trigger *trig) 192 { 193 if (atomic_dec_and_test(&trig->use_count) && trig->ops->try_reenable) 194 if (trig->ops->try_reenable(trig)) 195 /* Missed an interrupt so launch new poll now */ 196 iio_trigger_poll(trig); 197 } 198 EXPORT_SYMBOL(iio_trigger_notify_done); 199 200 /* Trigger Consumer related functions */ 201 static int iio_trigger_get_irq(struct iio_trigger *trig) 202 { 203 int ret; 204 mutex_lock(&trig->pool_lock); 205 ret = bitmap_find_free_region(trig->pool, 206 CONFIG_IIO_CONSUMERS_PER_TRIGGER, 207 ilog2(1)); 208 mutex_unlock(&trig->pool_lock); 209 if (ret >= 0) 210 ret += trig->subirq_base; 211 212 return ret; 213 } 214 215 static void iio_trigger_put_irq(struct iio_trigger *trig, int irq) 216 { 217 mutex_lock(&trig->pool_lock); 218 clear_bit(irq - trig->subirq_base, trig->pool); 219 mutex_unlock(&trig->pool_lock); 220 } 221 222 /* Complexity in here. With certain triggers (datardy) an acknowledgement 223 * may be needed if the pollfuncs do not include the data read for the 224 * triggering device. 225 * This is not currently handled. Alternative of not enabling trigger unless 226 * the relevant function is in there may be the best option. 227 */ 228 /* Worth protecting against double additions? */ 229 static int iio_trigger_attach_poll_func(struct iio_trigger *trig, 230 struct iio_poll_func *pf) 231 { 232 int ret = 0; 233 bool notinuse 234 = bitmap_empty(trig->pool, CONFIG_IIO_CONSUMERS_PER_TRIGGER); 235 236 /* Prevent the module from being removed whilst attached to a trigger */ 237 __module_get(pf->indio_dev->info->driver_module); 238 239 /* Get irq number */ 240 pf->irq = iio_trigger_get_irq(trig); 241 if (pf->irq < 0) 242 goto out_put_module; 243 244 /* Request irq */ 245 ret = request_threaded_irq(pf->irq, pf->h, pf->thread, 246 pf->type, pf->name, 247 pf); 248 if (ret < 0) 249 goto out_put_irq; 250 251 /* Enable trigger in driver */ 252 if (trig->ops->set_trigger_state && notinuse) { 253 ret = trig->ops->set_trigger_state(trig, true); 254 if (ret < 0) 255 goto out_free_irq; 256 } 257 258 return ret; 259 260 out_free_irq: 261 free_irq(pf->irq, pf); 262 out_put_irq: 263 iio_trigger_put_irq(trig, pf->irq); 264 out_put_module: 265 module_put(pf->indio_dev->info->driver_module); 266 return ret; 267 } 268 269 static int iio_trigger_detach_poll_func(struct iio_trigger *trig, 270 struct iio_poll_func *pf) 271 { 272 int ret = 0; 273 bool no_other_users 274 = (bitmap_weight(trig->pool, 275 CONFIG_IIO_CONSUMERS_PER_TRIGGER) 276 == 1); 277 if (trig->ops->set_trigger_state && no_other_users) { 278 ret = trig->ops->set_trigger_state(trig, false); 279 if (ret) 280 return ret; 281 } 282 iio_trigger_put_irq(trig, pf->irq); 283 free_irq(pf->irq, pf); 284 module_put(pf->indio_dev->info->driver_module); 285 286 return ret; 287 } 288 289 irqreturn_t iio_pollfunc_store_time(int irq, void *p) 290 { 291 struct iio_poll_func *pf = p; 292 pf->timestamp = iio_get_time_ns(pf->indio_dev); 293 return IRQ_WAKE_THREAD; 294 } 295 EXPORT_SYMBOL(iio_pollfunc_store_time); 296 297 struct iio_poll_func 298 *iio_alloc_pollfunc(irqreturn_t (*h)(int irq, void *p), 299 irqreturn_t (*thread)(int irq, void *p), 300 int type, 301 struct iio_dev *indio_dev, 302 const char *fmt, 303 ...) 304 { 305 va_list vargs; 306 struct iio_poll_func *pf; 307 308 pf = kmalloc(sizeof *pf, GFP_KERNEL); 309 if (pf == NULL) 310 return NULL; 311 va_start(vargs, fmt); 312 pf->name = kvasprintf(GFP_KERNEL, fmt, vargs); 313 va_end(vargs); 314 if (pf->name == NULL) { 315 kfree(pf); 316 return NULL; 317 } 318 pf->h = h; 319 pf->thread = thread; 320 pf->type = type; 321 pf->indio_dev = indio_dev; 322 323 return pf; 324 } 325 EXPORT_SYMBOL_GPL(iio_alloc_pollfunc); 326 327 void iio_dealloc_pollfunc(struct iio_poll_func *pf) 328 { 329 kfree(pf->name); 330 kfree(pf); 331 } 332 EXPORT_SYMBOL_GPL(iio_dealloc_pollfunc); 333 334 /** 335 * iio_trigger_read_current() - trigger consumer sysfs query current trigger 336 * @dev: device associated with an industrial I/O device 337 * @attr: pointer to the device_attribute structure that 338 * is being processed 339 * @buf: buffer where the current trigger name will be printed into 340 * 341 * For trigger consumers the current_trigger interface allows the trigger 342 * used by the device to be queried. 343 * 344 * Return: a negative number on failure, the number of characters written 345 * on success or 0 if no trigger is available 346 */ 347 static ssize_t iio_trigger_read_current(struct device *dev, 348 struct device_attribute *attr, 349 char *buf) 350 { 351 struct iio_dev *indio_dev = dev_to_iio_dev(dev); 352 353 if (indio_dev->trig) 354 return sprintf(buf, "%s\n", indio_dev->trig->name); 355 return 0; 356 } 357 358 /** 359 * iio_trigger_write_current() - trigger consumer sysfs set current trigger 360 * @dev: device associated with an industrial I/O device 361 * @attr: device attribute that is being processed 362 * @buf: string buffer that holds the name of the trigger 363 * @len: length of the trigger name held by buf 364 * 365 * For trigger consumers the current_trigger interface allows the trigger 366 * used for this device to be specified at run time based on the trigger's 367 * name. 368 * 369 * Return: negative error code on failure or length of the buffer 370 * on success 371 */ 372 static ssize_t iio_trigger_write_current(struct device *dev, 373 struct device_attribute *attr, 374 const char *buf, 375 size_t len) 376 { 377 struct iio_dev *indio_dev = dev_to_iio_dev(dev); 378 struct iio_trigger *oldtrig = indio_dev->trig; 379 struct iio_trigger *trig; 380 int ret; 381 382 mutex_lock(&indio_dev->mlock); 383 if (indio_dev->currentmode == INDIO_BUFFER_TRIGGERED) { 384 mutex_unlock(&indio_dev->mlock); 385 return -EBUSY; 386 } 387 mutex_unlock(&indio_dev->mlock); 388 389 trig = iio_trigger_find_by_name(buf, len); 390 if (oldtrig == trig) 391 return len; 392 393 if (trig && indio_dev->info->validate_trigger) { 394 ret = indio_dev->info->validate_trigger(indio_dev, trig); 395 if (ret) 396 return ret; 397 } 398 399 if (trig && trig->ops->validate_device) { 400 ret = trig->ops->validate_device(trig, indio_dev); 401 if (ret) 402 return ret; 403 } 404 405 indio_dev->trig = trig; 406 407 if (oldtrig) { 408 if (indio_dev->modes & INDIO_EVENT_TRIGGERED) 409 iio_trigger_detach_poll_func(oldtrig, 410 indio_dev->pollfunc_event); 411 iio_trigger_put(oldtrig); 412 } 413 if (indio_dev->trig) { 414 iio_trigger_get(indio_dev->trig); 415 if (indio_dev->modes & INDIO_EVENT_TRIGGERED) 416 iio_trigger_attach_poll_func(indio_dev->trig, 417 indio_dev->pollfunc_event); 418 } 419 420 return len; 421 } 422 423 static DEVICE_ATTR(current_trigger, S_IRUGO | S_IWUSR, 424 iio_trigger_read_current, 425 iio_trigger_write_current); 426 427 static struct attribute *iio_trigger_consumer_attrs[] = { 428 &dev_attr_current_trigger.attr, 429 NULL, 430 }; 431 432 static const struct attribute_group iio_trigger_consumer_attr_group = { 433 .name = "trigger", 434 .attrs = iio_trigger_consumer_attrs, 435 }; 436 437 static void iio_trig_release(struct device *device) 438 { 439 struct iio_trigger *trig = to_iio_trigger(device); 440 int i; 441 442 if (trig->subirq_base) { 443 for (i = 0; i < CONFIG_IIO_CONSUMERS_PER_TRIGGER; i++) { 444 irq_modify_status(trig->subirq_base + i, 445 IRQ_NOAUTOEN, 446 IRQ_NOREQUEST | IRQ_NOPROBE); 447 irq_set_chip(trig->subirq_base + i, 448 NULL); 449 irq_set_handler(trig->subirq_base + i, 450 NULL); 451 } 452 453 irq_free_descs(trig->subirq_base, 454 CONFIG_IIO_CONSUMERS_PER_TRIGGER); 455 } 456 kfree(trig->name); 457 kfree(trig); 458 } 459 460 static struct device_type iio_trig_type = { 461 .release = iio_trig_release, 462 .groups = iio_trig_dev_groups, 463 }; 464 465 static void iio_trig_subirqmask(struct irq_data *d) 466 { 467 struct irq_chip *chip = irq_data_get_irq_chip(d); 468 struct iio_trigger *trig 469 = container_of(chip, 470 struct iio_trigger, subirq_chip); 471 trig->subirqs[d->irq - trig->subirq_base].enabled = false; 472 } 473 474 static void iio_trig_subirqunmask(struct irq_data *d) 475 { 476 struct irq_chip *chip = irq_data_get_irq_chip(d); 477 struct iio_trigger *trig 478 = container_of(chip, 479 struct iio_trigger, subirq_chip); 480 trig->subirqs[d->irq - trig->subirq_base].enabled = true; 481 } 482 483 static struct iio_trigger *viio_trigger_alloc(const char *fmt, va_list vargs) 484 { 485 struct iio_trigger *trig; 486 trig = kzalloc(sizeof *trig, GFP_KERNEL); 487 if (trig) { 488 int i; 489 trig->dev.type = &iio_trig_type; 490 trig->dev.bus = &iio_bus_type; 491 device_initialize(&trig->dev); 492 493 mutex_init(&trig->pool_lock); 494 trig->subirq_base 495 = irq_alloc_descs(-1, 0, 496 CONFIG_IIO_CONSUMERS_PER_TRIGGER, 497 0); 498 if (trig->subirq_base < 0) { 499 kfree(trig); 500 return NULL; 501 } 502 503 trig->name = kvasprintf(GFP_KERNEL, fmt, vargs); 504 if (trig->name == NULL) { 505 irq_free_descs(trig->subirq_base, 506 CONFIG_IIO_CONSUMERS_PER_TRIGGER); 507 kfree(trig); 508 return NULL; 509 } 510 trig->subirq_chip.name = trig->name; 511 trig->subirq_chip.irq_mask = &iio_trig_subirqmask; 512 trig->subirq_chip.irq_unmask = &iio_trig_subirqunmask; 513 for (i = 0; i < CONFIG_IIO_CONSUMERS_PER_TRIGGER; i++) { 514 irq_set_chip(trig->subirq_base + i, 515 &trig->subirq_chip); 516 irq_set_handler(trig->subirq_base + i, 517 &handle_simple_irq); 518 irq_modify_status(trig->subirq_base + i, 519 IRQ_NOREQUEST | IRQ_NOAUTOEN, 520 IRQ_NOPROBE); 521 } 522 get_device(&trig->dev); 523 } 524 525 return trig; 526 } 527 528 struct iio_trigger *iio_trigger_alloc(const char *fmt, ...) 529 { 530 struct iio_trigger *trig; 531 va_list vargs; 532 533 va_start(vargs, fmt); 534 trig = viio_trigger_alloc(fmt, vargs); 535 va_end(vargs); 536 537 return trig; 538 } 539 EXPORT_SYMBOL(iio_trigger_alloc); 540 541 void iio_trigger_free(struct iio_trigger *trig) 542 { 543 if (trig) 544 put_device(&trig->dev); 545 } 546 EXPORT_SYMBOL(iio_trigger_free); 547 548 static void devm_iio_trigger_release(struct device *dev, void *res) 549 { 550 iio_trigger_free(*(struct iio_trigger **)res); 551 } 552 553 static int devm_iio_trigger_match(struct device *dev, void *res, void *data) 554 { 555 struct iio_trigger **r = res; 556 557 if (!r || !*r) { 558 WARN_ON(!r || !*r); 559 return 0; 560 } 561 562 return *r == data; 563 } 564 565 /** 566 * devm_iio_trigger_alloc - Resource-managed iio_trigger_alloc() 567 * @dev: Device to allocate iio_trigger for 568 * @fmt: trigger name format. If it includes format 569 * specifiers, the additional arguments following 570 * format are formatted and inserted in the resulting 571 * string replacing their respective specifiers. 572 * 573 * Managed iio_trigger_alloc. iio_trigger allocated with this function is 574 * automatically freed on driver detach. 575 * 576 * If an iio_trigger allocated with this function needs to be freed separately, 577 * devm_iio_trigger_free() must be used. 578 * 579 * RETURNS: 580 * Pointer to allocated iio_trigger on success, NULL on failure. 581 */ 582 struct iio_trigger *devm_iio_trigger_alloc(struct device *dev, 583 const char *fmt, ...) 584 { 585 struct iio_trigger **ptr, *trig; 586 va_list vargs; 587 588 ptr = devres_alloc(devm_iio_trigger_release, sizeof(*ptr), 589 GFP_KERNEL); 590 if (!ptr) 591 return NULL; 592 593 /* use raw alloc_dr for kmalloc caller tracing */ 594 va_start(vargs, fmt); 595 trig = viio_trigger_alloc(fmt, vargs); 596 va_end(vargs); 597 if (trig) { 598 *ptr = trig; 599 devres_add(dev, ptr); 600 } else { 601 devres_free(ptr); 602 } 603 604 return trig; 605 } 606 EXPORT_SYMBOL_GPL(devm_iio_trigger_alloc); 607 608 /** 609 * devm_iio_trigger_free - Resource-managed iio_trigger_free() 610 * @dev: Device this iio_dev belongs to 611 * @iio_trig: the iio_trigger associated with the device 612 * 613 * Free iio_trigger allocated with devm_iio_trigger_alloc(). 614 */ 615 void devm_iio_trigger_free(struct device *dev, struct iio_trigger *iio_trig) 616 { 617 int rc; 618 619 rc = devres_release(dev, devm_iio_trigger_release, 620 devm_iio_trigger_match, iio_trig); 621 WARN_ON(rc); 622 } 623 EXPORT_SYMBOL_GPL(devm_iio_trigger_free); 624 625 void iio_device_register_trigger_consumer(struct iio_dev *indio_dev) 626 { 627 indio_dev->groups[indio_dev->groupcounter++] = 628 &iio_trigger_consumer_attr_group; 629 } 630 631 void iio_device_unregister_trigger_consumer(struct iio_dev *indio_dev) 632 { 633 /* Clean up an associated but not attached trigger reference */ 634 if (indio_dev->trig) 635 iio_trigger_put(indio_dev->trig); 636 } 637 638 int iio_triggered_buffer_postenable(struct iio_dev *indio_dev) 639 { 640 return iio_trigger_attach_poll_func(indio_dev->trig, 641 indio_dev->pollfunc); 642 } 643 EXPORT_SYMBOL(iio_triggered_buffer_postenable); 644 645 int iio_triggered_buffer_predisable(struct iio_dev *indio_dev) 646 { 647 return iio_trigger_detach_poll_func(indio_dev->trig, 648 indio_dev->pollfunc); 649 } 650 EXPORT_SYMBOL(iio_triggered_buffer_predisable); 651