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 pf->irq = iio_trigger_get_irq(trig); 214 ret = request_threaded_irq(pf->irq, pf->h, pf->thread, 215 pf->type, pf->name, 216 pf); 217 if (ret < 0) { 218 module_put(pf->indio_dev->info->driver_module); 219 return ret; 220 } 221 222 if (trig->ops && trig->ops->set_trigger_state && notinuse) { 223 ret = trig->ops->set_trigger_state(trig, true); 224 if (ret < 0) 225 module_put(pf->indio_dev->info->driver_module); 226 } 227 228 return ret; 229 } 230 231 static int iio_trigger_detach_poll_func(struct iio_trigger *trig, 232 struct iio_poll_func *pf) 233 { 234 int ret = 0; 235 bool no_other_users 236 = (bitmap_weight(trig->pool, 237 CONFIG_IIO_CONSUMERS_PER_TRIGGER) 238 == 1); 239 if (trig->ops && trig->ops->set_trigger_state && no_other_users) { 240 ret = trig->ops->set_trigger_state(trig, false); 241 if (ret) 242 return ret; 243 } 244 iio_trigger_put_irq(trig, pf->irq); 245 free_irq(pf->irq, pf); 246 module_put(pf->indio_dev->info->driver_module); 247 248 return ret; 249 } 250 251 irqreturn_t iio_pollfunc_store_time(int irq, void *p) 252 { 253 struct iio_poll_func *pf = p; 254 pf->timestamp = iio_get_time_ns(); 255 return IRQ_WAKE_THREAD; 256 } 257 EXPORT_SYMBOL(iio_pollfunc_store_time); 258 259 struct iio_poll_func 260 *iio_alloc_pollfunc(irqreturn_t (*h)(int irq, void *p), 261 irqreturn_t (*thread)(int irq, void *p), 262 int type, 263 struct iio_dev *indio_dev, 264 const char *fmt, 265 ...) 266 { 267 va_list vargs; 268 struct iio_poll_func *pf; 269 270 pf = kmalloc(sizeof *pf, GFP_KERNEL); 271 if (pf == NULL) 272 return NULL; 273 va_start(vargs, fmt); 274 pf->name = kvasprintf(GFP_KERNEL, fmt, vargs); 275 va_end(vargs); 276 if (pf->name == NULL) { 277 kfree(pf); 278 return NULL; 279 } 280 pf->h = h; 281 pf->thread = thread; 282 pf->type = type; 283 pf->indio_dev = indio_dev; 284 285 return pf; 286 } 287 EXPORT_SYMBOL_GPL(iio_alloc_pollfunc); 288 289 void iio_dealloc_pollfunc(struct iio_poll_func *pf) 290 { 291 kfree(pf->name); 292 kfree(pf); 293 } 294 EXPORT_SYMBOL_GPL(iio_dealloc_pollfunc); 295 296 /** 297 * iio_trigger_read_current() - trigger consumer sysfs query current trigger 298 * @dev: device associated with an industrial I/O device 299 * @attr: pointer to the device_attribute structure that 300 * is being processed 301 * @buf: buffer where the current trigger name will be printed into 302 * 303 * For trigger consumers the current_trigger interface allows the trigger 304 * used by the device to be queried. 305 * 306 * Return: a negative number on failure, the number of characters written 307 * on success or 0 if no trigger is available 308 */ 309 static ssize_t iio_trigger_read_current(struct device *dev, 310 struct device_attribute *attr, 311 char *buf) 312 { 313 struct iio_dev *indio_dev = dev_to_iio_dev(dev); 314 315 if (indio_dev->trig) 316 return sprintf(buf, "%s\n", indio_dev->trig->name); 317 return 0; 318 } 319 320 /** 321 * iio_trigger_write_current() - trigger consumer sysfs set current trigger 322 * @dev: device associated with an industrial I/O device 323 * @attr: device attribute that is being processed 324 * @buf: string buffer that holds the name of the trigger 325 * @len: length of the trigger name held by buf 326 * 327 * For trigger consumers the current_trigger interface allows the trigger 328 * used for this device to be specified at run time based on the trigger's 329 * name. 330 * 331 * Return: negative error code on failure or length of the buffer 332 * on success 333 */ 334 static ssize_t iio_trigger_write_current(struct device *dev, 335 struct device_attribute *attr, 336 const char *buf, 337 size_t len) 338 { 339 struct iio_dev *indio_dev = dev_to_iio_dev(dev); 340 struct iio_trigger *oldtrig = indio_dev->trig; 341 struct iio_trigger *trig; 342 int ret; 343 344 mutex_lock(&indio_dev->mlock); 345 if (indio_dev->currentmode == INDIO_BUFFER_TRIGGERED) { 346 mutex_unlock(&indio_dev->mlock); 347 return -EBUSY; 348 } 349 mutex_unlock(&indio_dev->mlock); 350 351 trig = iio_trigger_find_by_name(buf, len); 352 if (oldtrig == trig) 353 return len; 354 355 if (trig && indio_dev->info->validate_trigger) { 356 ret = indio_dev->info->validate_trigger(indio_dev, trig); 357 if (ret) 358 return ret; 359 } 360 361 if (trig && trig->ops && trig->ops->validate_device) { 362 ret = trig->ops->validate_device(trig, indio_dev); 363 if (ret) 364 return ret; 365 } 366 367 indio_dev->trig = trig; 368 369 if (oldtrig) { 370 if (indio_dev->modes & INDIO_EVENT_TRIGGERED) 371 iio_trigger_detach_poll_func(oldtrig, 372 indio_dev->pollfunc_event); 373 iio_trigger_put(oldtrig); 374 } 375 if (indio_dev->trig) { 376 iio_trigger_get(indio_dev->trig); 377 if (indio_dev->modes & INDIO_EVENT_TRIGGERED) 378 iio_trigger_attach_poll_func(indio_dev->trig, 379 indio_dev->pollfunc_event); 380 } 381 382 return len; 383 } 384 385 static DEVICE_ATTR(current_trigger, S_IRUGO | S_IWUSR, 386 iio_trigger_read_current, 387 iio_trigger_write_current); 388 389 static struct attribute *iio_trigger_consumer_attrs[] = { 390 &dev_attr_current_trigger.attr, 391 NULL, 392 }; 393 394 static const struct attribute_group iio_trigger_consumer_attr_group = { 395 .name = "trigger", 396 .attrs = iio_trigger_consumer_attrs, 397 }; 398 399 static void iio_trig_release(struct device *device) 400 { 401 struct iio_trigger *trig = to_iio_trigger(device); 402 int i; 403 404 if (trig->subirq_base) { 405 for (i = 0; i < CONFIG_IIO_CONSUMERS_PER_TRIGGER; i++) { 406 irq_modify_status(trig->subirq_base + i, 407 IRQ_NOAUTOEN, 408 IRQ_NOREQUEST | IRQ_NOPROBE); 409 irq_set_chip(trig->subirq_base + i, 410 NULL); 411 irq_set_handler(trig->subirq_base + i, 412 NULL); 413 } 414 415 irq_free_descs(trig->subirq_base, 416 CONFIG_IIO_CONSUMERS_PER_TRIGGER); 417 } 418 kfree(trig->name); 419 kfree(trig); 420 } 421 422 static struct device_type iio_trig_type = { 423 .release = iio_trig_release, 424 .groups = iio_trig_dev_groups, 425 }; 426 427 static void iio_trig_subirqmask(struct irq_data *d) 428 { 429 struct irq_chip *chip = irq_data_get_irq_chip(d); 430 struct iio_trigger *trig 431 = container_of(chip, 432 struct iio_trigger, subirq_chip); 433 trig->subirqs[d->irq - trig->subirq_base].enabled = false; 434 } 435 436 static void iio_trig_subirqunmask(struct irq_data *d) 437 { 438 struct irq_chip *chip = irq_data_get_irq_chip(d); 439 struct iio_trigger *trig 440 = container_of(chip, 441 struct iio_trigger, subirq_chip); 442 trig->subirqs[d->irq - trig->subirq_base].enabled = true; 443 } 444 445 static struct iio_trigger *viio_trigger_alloc(const char *fmt, va_list vargs) 446 { 447 struct iio_trigger *trig; 448 trig = kzalloc(sizeof *trig, GFP_KERNEL); 449 if (trig) { 450 int i; 451 trig->dev.type = &iio_trig_type; 452 trig->dev.bus = &iio_bus_type; 453 device_initialize(&trig->dev); 454 455 mutex_init(&trig->pool_lock); 456 trig->subirq_base 457 = irq_alloc_descs(-1, 0, 458 CONFIG_IIO_CONSUMERS_PER_TRIGGER, 459 0); 460 if (trig->subirq_base < 0) { 461 kfree(trig); 462 return NULL; 463 } 464 465 trig->name = kvasprintf(GFP_KERNEL, fmt, vargs); 466 if (trig->name == NULL) { 467 irq_free_descs(trig->subirq_base, 468 CONFIG_IIO_CONSUMERS_PER_TRIGGER); 469 kfree(trig); 470 return NULL; 471 } 472 trig->subirq_chip.name = trig->name; 473 trig->subirq_chip.irq_mask = &iio_trig_subirqmask; 474 trig->subirq_chip.irq_unmask = &iio_trig_subirqunmask; 475 for (i = 0; i < CONFIG_IIO_CONSUMERS_PER_TRIGGER; i++) { 476 irq_set_chip(trig->subirq_base + i, 477 &trig->subirq_chip); 478 irq_set_handler(trig->subirq_base + i, 479 &handle_simple_irq); 480 irq_modify_status(trig->subirq_base + i, 481 IRQ_NOREQUEST | IRQ_NOAUTOEN, 482 IRQ_NOPROBE); 483 } 484 get_device(&trig->dev); 485 } 486 487 return trig; 488 } 489 490 struct iio_trigger *iio_trigger_alloc(const char *fmt, ...) 491 { 492 struct iio_trigger *trig; 493 va_list vargs; 494 495 va_start(vargs, fmt); 496 trig = viio_trigger_alloc(fmt, vargs); 497 va_end(vargs); 498 499 return trig; 500 } 501 EXPORT_SYMBOL(iio_trigger_alloc); 502 503 void iio_trigger_free(struct iio_trigger *trig) 504 { 505 if (trig) 506 put_device(&trig->dev); 507 } 508 EXPORT_SYMBOL(iio_trigger_free); 509 510 static void devm_iio_trigger_release(struct device *dev, void *res) 511 { 512 iio_trigger_free(*(struct iio_trigger **)res); 513 } 514 515 static int devm_iio_trigger_match(struct device *dev, void *res, void *data) 516 { 517 struct iio_trigger **r = res; 518 519 if (!r || !*r) { 520 WARN_ON(!r || !*r); 521 return 0; 522 } 523 524 return *r == data; 525 } 526 527 /** 528 * devm_iio_trigger_alloc - Resource-managed iio_trigger_alloc() 529 * @dev: Device to allocate iio_trigger for 530 * @fmt: trigger name format. If it includes format 531 * specifiers, the additional arguments following 532 * format are formatted and inserted in the resulting 533 * string replacing their respective specifiers. 534 * 535 * Managed iio_trigger_alloc. iio_trigger allocated with this function is 536 * automatically freed on driver detach. 537 * 538 * If an iio_trigger allocated with this function needs to be freed separately, 539 * devm_iio_trigger_free() must be used. 540 * 541 * RETURNS: 542 * Pointer to allocated iio_trigger on success, NULL on failure. 543 */ 544 struct iio_trigger *devm_iio_trigger_alloc(struct device *dev, 545 const char *fmt, ...) 546 { 547 struct iio_trigger **ptr, *trig; 548 va_list vargs; 549 550 ptr = devres_alloc(devm_iio_trigger_release, sizeof(*ptr), 551 GFP_KERNEL); 552 if (!ptr) 553 return NULL; 554 555 /* use raw alloc_dr for kmalloc caller tracing */ 556 va_start(vargs, fmt); 557 trig = viio_trigger_alloc(fmt, vargs); 558 va_end(vargs); 559 if (trig) { 560 *ptr = trig; 561 devres_add(dev, ptr); 562 } else { 563 devres_free(ptr); 564 } 565 566 return trig; 567 } 568 EXPORT_SYMBOL_GPL(devm_iio_trigger_alloc); 569 570 /** 571 * devm_iio_trigger_free - Resource-managed iio_trigger_free() 572 * @dev: Device this iio_dev belongs to 573 * @iio_trig: the iio_trigger associated with the device 574 * 575 * Free iio_trigger allocated with devm_iio_trigger_alloc(). 576 */ 577 void devm_iio_trigger_free(struct device *dev, struct iio_trigger *iio_trig) 578 { 579 int rc; 580 581 rc = devres_release(dev, devm_iio_trigger_release, 582 devm_iio_trigger_match, iio_trig); 583 WARN_ON(rc); 584 } 585 EXPORT_SYMBOL_GPL(devm_iio_trigger_free); 586 587 void iio_device_register_trigger_consumer(struct iio_dev *indio_dev) 588 { 589 indio_dev->groups[indio_dev->groupcounter++] = 590 &iio_trigger_consumer_attr_group; 591 } 592 593 void iio_device_unregister_trigger_consumer(struct iio_dev *indio_dev) 594 { 595 /* Clean up an associated but not attached trigger reference */ 596 if (indio_dev->trig) 597 iio_trigger_put(indio_dev->trig); 598 } 599 600 int iio_triggered_buffer_postenable(struct iio_dev *indio_dev) 601 { 602 return iio_trigger_attach_poll_func(indio_dev->trig, 603 indio_dev->pollfunc); 604 } 605 EXPORT_SYMBOL(iio_triggered_buffer_postenable); 606 607 int iio_triggered_buffer_predisable(struct iio_dev *indio_dev) 608 { 609 return iio_trigger_detach_poll_func(indio_dev->trig, 610 indio_dev->pollfunc); 611 } 612 EXPORT_SYMBOL(iio_triggered_buffer_predisable); 613