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