irqdomain.c 23.1 KB
Newer Older
1 2
#define pr_fmt(fmt)  "irq: " fmt

3 4 5
#include <linux/debugfs.h>
#include <linux/hardirq.h>
#include <linux/interrupt.h>
6
#include <linux/irq.h>
7
#include <linux/irqdesc.h>
8 9 10 11
#include <linux/irqdomain.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/of.h>
12
#include <linux/of_address.h>
13
#include <linux/seq_file.h>
14
#include <linux/slab.h>
15 16
#include <linux/smp.h>
#include <linux/fs.h>
17

18 19
#define IRQ_DOMAIN_MAP_LEGACY 0 /* driver allocated fixed range of irqs.
				 * ie. legacy 8259, gets irqs 1..15 */
20 21 22 23
#define IRQ_DOMAIN_MAP_NOMAP 1 /* no fast reverse mapping */
#define IRQ_DOMAIN_MAP_LINEAR 2 /* linear map of interrupts */
#define IRQ_DOMAIN_MAP_TREE 3 /* radix tree */

24 25 26
static LIST_HEAD(irq_domain_list);
static DEFINE_MUTEX(irq_domain_mutex);

27
static DEFINE_MUTEX(revmap_trees_mutex);
28
static struct irq_domain *irq_default_domain;
29 30

/**
31
 * irq_domain_alloc() - Allocate a new irq_domain data structure
32 33
 * @of_node: optional device-tree node of the interrupt controller
 * @revmap_type: type of reverse mapping to use
34
 * @ops: map/unmap domain callbacks
35
 * @host_data: Controller private data pointer
36
 *
37 38 39
 * Allocates and initialize and irq_domain structure.  Caller is expected to
 * register allocated irq_domain with irq_domain_register().  Returns pointer
 * to IRQ domain, or NULL on failure.
40
 */
41 42
static struct irq_domain *irq_domain_alloc(struct device_node *of_node,
					   unsigned int revmap_type,
43
					   const struct irq_domain_ops *ops,
44
					   void *host_data)
45
{
46
	struct irq_domain *domain;
47

48 49
	domain = kzalloc(sizeof(*domain), GFP_KERNEL);
	if (WARN_ON(!domain))
50 51 52
		return NULL;

	/* Fill structure */
53 54
	domain->revmap_type = revmap_type;
	domain->ops = ops;
55
	domain->host_data = host_data;
56
	domain->of_node = of_node_get(of_node);
57

58 59 60
	return domain;
}

61 62 63 64 65 66
static void irq_domain_free(struct irq_domain *domain)
{
	of_node_put(domain->of_node);
	kfree(domain);
}

67 68 69 70 71
static void irq_domain_add(struct irq_domain *domain)
{
	mutex_lock(&irq_domain_mutex);
	list_add(&domain->link, &irq_domain_list);
	mutex_unlock(&irq_domain_mutex);
72
	pr_debug("Allocated domain of type %d @0x%p\n",
73 74 75
		 domain->revmap_type, domain);
}

76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121
/**
 * irq_domain_remove() - Remove an irq domain.
 * @domain: domain to remove
 *
 * This routine is used to remove an irq domain. The caller must ensure
 * that all mappings within the domain have been disposed of prior to
 * use, depending on the revmap type.
 */
void irq_domain_remove(struct irq_domain *domain)
{
	mutex_lock(&irq_domain_mutex);

	switch (domain->revmap_type) {
	case IRQ_DOMAIN_MAP_LEGACY:
		/*
		 * Legacy domains don't manage their own irq_desc
		 * allocations, we expect the caller to handle irq_desc
		 * freeing on their own.
		 */
		break;
	case IRQ_DOMAIN_MAP_TREE:
		/*
		 * radix_tree_delete() takes care of destroying the root
		 * node when all entries are removed. Shout if there are
		 * any mappings left.
		 */
		WARN_ON(domain->revmap_data.tree.height);
		break;
	case IRQ_DOMAIN_MAP_LINEAR:
		kfree(domain->revmap_data.linear.revmap);
		domain->revmap_data.linear.size = 0;
		break;
	case IRQ_DOMAIN_MAP_NOMAP:
		break;
	}

	list_del(&domain->link);

	/*
	 * If the going away domain is the default one, reset it.
	 */
	if (unlikely(irq_default_domain == domain))
		irq_set_default_host(NULL);

	mutex_unlock(&irq_domain_mutex);

122
	pr_debug("Removed domain of type %d @0x%p\n",
123 124 125 126
		 domain->revmap_type, domain);

	irq_domain_free(domain);
}
127
EXPORT_SYMBOL_GPL(irq_domain_remove);
128

129 130 131 132 133 134 135 136 137 138 139
static unsigned int irq_domain_legacy_revmap(struct irq_domain *domain,
					     irq_hw_number_t hwirq)
{
	irq_hw_number_t first_hwirq = domain->revmap_data.legacy.first_hwirq;
	int size = domain->revmap_data.legacy.size;

	if (WARN_ON(hwirq < first_hwirq || hwirq >= first_hwirq + size))
		return 0;
	return hwirq - first_hwirq + domain->revmap_data.legacy.first_irq;
}

140 141 142
/**
 * irq_domain_add_legacy() - Allocate and register a legacy revmap irq_domain.
 * @of_node: pointer to interrupt controller's device tree node.
143 144 145 146 147
 * @size: total number of irqs in legacy mapping
 * @first_irq: first number of irq block assigned to the domain
 * @first_hwirq: first hwirq number to use for the translation. Should normally
 *               be '0', but a positive integer can be used if the effective
 *               hwirqs numbering does not begin at zero.
148 149 150 151 152 153 154 155
 * @ops: map/unmap domain callbacks
 * @host_data: Controller private data pointer
 *
 * Note: the map() callback will be called before this function returns
 * for all legacy interrupts except 0 (which is always the invalid irq for
 * a legacy controller).
 */
struct irq_domain *irq_domain_add_legacy(struct device_node *of_node,
156 157 158
					 unsigned int size,
					 unsigned int first_irq,
					 irq_hw_number_t first_hwirq,
159
					 const struct irq_domain_ops *ops,
160 161
					 void *host_data)
{
162
	struct irq_domain *domain;
163 164 165 166 167 168
	unsigned int i;

	domain = irq_domain_alloc(of_node, IRQ_DOMAIN_MAP_LEGACY, ops, host_data);
	if (!domain)
		return NULL;

169 170 171 172
	domain->revmap_data.legacy.first_irq = first_irq;
	domain->revmap_data.legacy.first_hwirq = first_hwirq;
	domain->revmap_data.legacy.size = size;

173
	mutex_lock(&irq_domain_mutex);
174 175 176 177 178 179
	/* Verify that all the irqs are available */
	for (i = 0; i < size; i++) {
		int irq = first_irq + i;
		struct irq_data *irq_data = irq_get_irq_data(irq);

		if (WARN_ON(!irq_data || irq_data->domain)) {
180
			mutex_unlock(&irq_domain_mutex);
181
			irq_domain_free(domain);
182
			return NULL;
183 184 185
		}
	}

186 187 188 189
	/* Claim all of the irqs before registering a legacy domain */
	for (i = 0; i < size; i++) {
		struct irq_data *irq_data = irq_get_irq_data(first_irq + i);
		irq_data->hwirq = first_hwirq + i;
190
		irq_data->domain = domain;
191 192 193 194 195 196 197 198 199 200
	}
	mutex_unlock(&irq_domain_mutex);

	for (i = 0; i < size; i++) {
		int irq = first_irq + i;
		int hwirq = first_hwirq + i;

		/* IRQ0 gets ignored */
		if (!irq)
			continue;
201 202 203 204 205

		/* Legacy flags are left to default at this point,
		 * one can then use irq_create_mapping() to
		 * explicitly change them
		 */
206
		ops->map(domain, irq, hwirq);
207 208

		/* Clear norequest flags */
209
		irq_clear_status_flags(irq, IRQ_NOREQUEST);
210
	}
211 212

	irq_domain_add(domain);
213 214
	return domain;
}
215
EXPORT_SYMBOL_GPL(irq_domain_add_legacy);
216 217 218 219

/**
 * irq_domain_add_linear() - Allocate and register a legacy revmap irq_domain.
 * @of_node: pointer to interrupt controller's device tree node.
220
 * @size: Number of interrupts in the domain.
221 222 223 224 225
 * @ops: map/unmap domain callbacks
 * @host_data: Controller private data pointer
 */
struct irq_domain *irq_domain_add_linear(struct device_node *of_node,
					 unsigned int size,
226
					 const struct irq_domain_ops *ops,
227 228 229 230
					 void *host_data)
{
	struct irq_domain *domain;
	unsigned int *revmap;
231

232 233 234
	revmap = kzalloc(sizeof(*revmap) * size, GFP_KERNEL);
	if (WARN_ON(!revmap))
		return NULL;
235

236 237 238 239 240 241 242 243 244 245
	domain = irq_domain_alloc(of_node, IRQ_DOMAIN_MAP_LINEAR, ops, host_data);
	if (!domain) {
		kfree(revmap);
		return NULL;
	}
	domain->revmap_data.linear.size = size;
	domain->revmap_data.linear.revmap = revmap;
	irq_domain_add(domain);
	return domain;
}
246
EXPORT_SYMBOL_GPL(irq_domain_add_linear);
247 248

struct irq_domain *irq_domain_add_nomap(struct device_node *of_node,
249
					 unsigned int max_irq,
250
					 const struct irq_domain_ops *ops,
251 252 253 254
					 void *host_data)
{
	struct irq_domain *domain = irq_domain_alloc(of_node,
					IRQ_DOMAIN_MAP_NOMAP, ops, host_data);
255 256
	if (domain) {
		domain->revmap_data.nomap.max_irq = max_irq ? max_irq : ~0;
257
		irq_domain_add(domain);
258
	}
259 260
	return domain;
}
261
EXPORT_SYMBOL_GPL(irq_domain_add_nomap);
262 263 264 265 266 267 268 269 270 271

/**
 * irq_domain_add_tree()
 * @of_node: pointer to interrupt controller's device tree node.
 * @ops: map/unmap domain callbacks
 *
 * Note: The radix tree will be allocated later during boot automatically
 * (the reverse mapping will use the slow path until that happens).
 */
struct irq_domain *irq_domain_add_tree(struct device_node *of_node,
272
					 const struct irq_domain_ops *ops,
273 274 275 276 277 278 279 280
					 void *host_data)
{
	struct irq_domain *domain = irq_domain_alloc(of_node,
					IRQ_DOMAIN_MAP_TREE, ops, host_data);
	if (domain) {
		INIT_RADIX_TREE(&domain->revmap_data.tree, GFP_KERNEL);
		irq_domain_add(domain);
	}
281
	return domain;
282
}
283
EXPORT_SYMBOL_GPL(irq_domain_add_tree);
284 285 286 287 288 289 290 291

/**
 * irq_find_host() - Locates a domain for a given device node
 * @node: device-tree node of the interrupt controller
 */
struct irq_domain *irq_find_host(struct device_node *node)
{
	struct irq_domain *h, *found = NULL;
292
	int rc;
293 294 295 296 297 298 299

	/* We might want to match the legacy controller last since
	 * it might potentially be set to match all interrupts in
	 * the absence of a device node. This isn't a problem so far
	 * yet though...
	 */
	mutex_lock(&irq_domain_mutex);
300 301 302 303 304 305 306
	list_for_each_entry(h, &irq_domain_list, link) {
		if (h->ops->match)
			rc = h->ops->match(h, node);
		else
			rc = (h->of_node != NULL) && (h->of_node == node);

		if (rc) {
307 308 309
			found = h;
			break;
		}
310
	}
311 312 313 314 315 316 317
	mutex_unlock(&irq_domain_mutex);
	return found;
}
EXPORT_SYMBOL_GPL(irq_find_host);

/**
 * irq_set_default_host() - Set a "default" irq domain
318
 * @domain: default domain pointer
319 320 321 322 323 324
 *
 * For convenience, it's possible to set a "default" domain that will be used
 * whenever NULL is passed to irq_create_mapping(). It makes life easier for
 * platforms that want to manipulate a few hard coded interrupt numbers that
 * aren't properly represented in the device-tree.
 */
325
void irq_set_default_host(struct irq_domain *domain)
326
{
327
	pr_debug("Default domain set to @0x%p\n", domain);
328

329
	irq_default_domain = domain;
330
}
331
EXPORT_SYMBOL_GPL(irq_set_default_host);
332

333
static int irq_setup_virq(struct irq_domain *domain, unsigned int virq,
334 335 336 337 338
			    irq_hw_number_t hwirq)
{
	struct irq_data *irq_data = irq_get_irq_data(virq);

	irq_data->hwirq = hwirq;
339 340
	irq_data->domain = domain;
	if (domain->ops->map(domain, virq, hwirq)) {
341
		pr_debug("irq-%i==>hwirq-0x%lx mapping failed\n", virq, hwirq);
342 343 344 345 346 347 348 349 350 351 352 353
		irq_data->domain = NULL;
		irq_data->hwirq = 0;
		return -1;
	}

	irq_clear_status_flags(virq, IRQ_NOREQUEST);

	return 0;
}

/**
 * irq_create_direct_mapping() - Allocate an irq for direct mapping
354
 * @domain: domain to allocate the irq for or NULL for default domain
355 356 357 358 359
 *
 * This routine is used for irq controllers which can choose the hardware
 * interrupt numbers they generate. In such a case it's simplest to use
 * the linux irq as the hardware interrupt number.
 */
360
unsigned int irq_create_direct_mapping(struct irq_domain *domain)
361 362 363
{
	unsigned int virq;

364 365
	if (domain == NULL)
		domain = irq_default_domain;
366

367 368
	BUG_ON(domain == NULL);
	WARN_ON(domain->revmap_type != IRQ_DOMAIN_MAP_NOMAP);
369 370

	virq = irq_alloc_desc_from(1, 0);
371
	if (!virq) {
372
		pr_debug("create_direct virq allocation failed\n");
373
		return 0;
374
	}
375
	if (virq >= domain->revmap_data.nomap.max_irq) {
376
		pr_err("ERROR: no free irqs available below %i maximum\n",
377
			domain->revmap_data.nomap.max_irq);
378 379 380
		irq_free_desc(virq);
		return 0;
	}
381
	pr_debug("create_direct obtained virq %d\n", virq);
382

383
	if (irq_setup_virq(domain, virq, virq)) {
384
		irq_free_desc(virq);
385
		return 0;
386 387 388 389
	}

	return virq;
}
390
EXPORT_SYMBOL_GPL(irq_create_direct_mapping);
391 392 393

/**
 * irq_create_mapping() - Map a hardware interrupt into linux irq space
394 395
 * @domain: domain owning this hardware interrupt or NULL for default domain
 * @hwirq: hardware irq number in that domain space
396 397 398 399 400 401
 *
 * Only one mapping per hardware interrupt is permitted. Returns a linux
 * irq number.
 * If the sense/trigger is to be specified, set_irq_type() should be called
 * on the number returned from that call.
 */
402
unsigned int irq_create_mapping(struct irq_domain *domain,
403 404
				irq_hw_number_t hwirq)
{
405 406
	unsigned int hint;
	int virq;
407

408
	pr_debug("irq_create_mapping(0x%p, 0x%lx)\n", domain, hwirq);
409

410 411 412 413
	/* Look for default domain if nececssary */
	if (domain == NULL)
		domain = irq_default_domain;
	if (domain == NULL) {
414 415
		pr_warning("irq_create_mapping called for"
			   " NULL domain, hwirq=%lx\n", hwirq);
416
		WARN_ON(1);
417
		return 0;
418
	}
419
	pr_debug("-> using domain @%p\n", domain);
420 421

	/* Check if mapping already exists */
422
	virq = irq_find_mapping(domain, hwirq);
423
	if (virq) {
424
		pr_debug("-> existing mapping on virq %d\n", virq);
425 426 427 428
		return virq;
	}

	/* Get a virtual interrupt number */
429 430 431 432
	if (domain->revmap_type == IRQ_DOMAIN_MAP_LEGACY)
		return irq_domain_legacy_revmap(domain, hwirq);

	/* Allocate a virtual interrupt number */
433
	hint = hwirq % nr_irqs;
434 435 436
	if (hint == 0)
		hint++;
	virq = irq_alloc_desc_from(hint, 0);
437
	if (virq <= 0)
438
		virq = irq_alloc_desc_from(1, 0);
439
	if (virq <= 0) {
440
		pr_debug("-> virq allocation failed\n");
441
		return 0;
442 443
	}

444 445
	if (irq_setup_virq(domain, virq, hwirq)) {
		if (domain->revmap_type != IRQ_DOMAIN_MAP_LEGACY)
446
			irq_free_desc(virq);
447
		return 0;
448 449
	}

450
	pr_debug("irq %lu on domain %s mapped to virtual irq %u\n",
451
		hwirq, domain->of_node ? domain->of_node->full_name : "null", virq);
452 453 454 455 456 457 458 459

	return virq;
}
EXPORT_SYMBOL_GPL(irq_create_mapping);

unsigned int irq_create_of_mapping(struct device_node *controller,
				   const u32 *intspec, unsigned int intsize)
{
460
	struct irq_domain *domain;
461 462 463 464
	irq_hw_number_t hwirq;
	unsigned int type = IRQ_TYPE_NONE;
	unsigned int virq;

465 466
	domain = controller ? irq_find_host(controller) : irq_default_domain;
	if (!domain) {
467 468 469 470 471 472 473 474 475 476 477 478
#ifdef CONFIG_MIPS
		/*
		 * Workaround to avoid breaking interrupt controller drivers
		 * that don't yet register an irq_domain.  This is temporary
		 * code. ~~~gcl, Feb 24, 2012
		 *
		 * Scheduled for removal in Linux v3.6.  That should be enough
		 * time.
		 */
		if (intsize > 0)
			return intspec[0];
#endif
479 480
		pr_warning("no irq domain found for %s !\n",
			   controller->full_name);
481
		return 0;
482 483
	}

484 485
	/* If domain has no translation, then we assume interrupt line */
	if (domain->ops->xlate == NULL)
486 487
		hwirq = intspec[0];
	else {
488
		if (domain->ops->xlate(domain, controller, intspec, intsize,
489
				     &hwirq, &type))
490
			return 0;
491 492 493
	}

	/* Create mapping */
494
	virq = irq_create_mapping(domain, hwirq);
495
	if (!virq)
496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512
		return virq;

	/* Set type if specified and different than the current one */
	if (type != IRQ_TYPE_NONE &&
	    type != (irqd_get_trigger_type(irq_get_irq_data(virq))))
		irq_set_irq_type(virq, type);
	return virq;
}
EXPORT_SYMBOL_GPL(irq_create_of_mapping);

/**
 * irq_dispose_mapping() - Unmap an interrupt
 * @virq: linux irq number of the interrupt to unmap
 */
void irq_dispose_mapping(unsigned int virq)
{
	struct irq_data *irq_data = irq_get_irq_data(virq);
513
	struct irq_domain *domain;
514 515
	irq_hw_number_t hwirq;

516
	if (!virq || !irq_data)
517 518
		return;

519 520
	domain = irq_data->domain;
	if (WARN_ON(domain == NULL))
521 522 523
		return;

	/* Never unmap legacy interrupts */
524
	if (domain->revmap_type == IRQ_DOMAIN_MAP_LEGACY)
525 526 527 528 529 530 531 532 533 534 535
		return;

	irq_set_status_flags(virq, IRQ_NOREQUEST);

	/* remove chip and handler */
	irq_set_chip_and_handler(virq, NULL, NULL);

	/* Make sure it's completed */
	synchronize_irq(virq);

	/* Tell the PIC about it */
536 537
	if (domain->ops->unmap)
		domain->ops->unmap(domain, virq);
538 539 540 541
	smp_mb();

	/* Clear reverse map */
	hwirq = irq_data->hwirq;
542
	switch(domain->revmap_type) {
543
	case IRQ_DOMAIN_MAP_LINEAR:
544 545
		if (hwirq < domain->revmap_data.linear.size)
			domain->revmap_data.linear.revmap[hwirq] = 0;
546 547 548
		break;
	case IRQ_DOMAIN_MAP_TREE:
		mutex_lock(&revmap_trees_mutex);
549
		radix_tree_delete(&domain->revmap_data.tree, hwirq);
550 551 552 553 554 555 556 557 558 559
		mutex_unlock(&revmap_trees_mutex);
		break;
	}

	irq_free_desc(virq);
}
EXPORT_SYMBOL_GPL(irq_dispose_mapping);

/**
 * irq_find_mapping() - Find a linux irq from an hw irq number.
560 561
 * @domain: domain owning this hardware interrupt
 * @hwirq: hardware irq number in that domain space
562 563 564 565 566
 *
 * This is a slow path, for use by generic code. It's expected that an
 * irq controller implementation directly calls the appropriate low level
 * mapping function.
 */
567
unsigned int irq_find_mapping(struct irq_domain *domain,
568 569 570
			      irq_hw_number_t hwirq)
{
	unsigned int i;
571
	unsigned int hint = hwirq % nr_irqs;
572

573 574 575 576
	/* Look for default domain if nececssary */
	if (domain == NULL)
		domain = irq_default_domain;
	if (domain == NULL)
577
		return 0;
578 579

	/* legacy -> bail early */
580
	if (domain->revmap_type == IRQ_DOMAIN_MAP_LEGACY)
581
		return irq_domain_legacy_revmap(domain, hwirq);
582 583 584 585 586 587 588

	/* Slow path does a linear search of the map */
	if (hint == 0)
		hint = 1;
	i = hint;
	do {
		struct irq_data *data = irq_get_irq_data(i);
589
		if (data && (data->domain == domain) && (data->hwirq == hwirq))
590 591
			return i;
		i++;
592
		if (i >= nr_irqs)
593 594
			i = 1;
	} while(i != hint);
595
	return 0;
596 597 598 599 600
}
EXPORT_SYMBOL_GPL(irq_find_mapping);

/**
 * irq_radix_revmap_lookup() - Find a linux irq from a hw irq number.
601 602
 * @domain: domain owning this hardware interrupt
 * @hwirq: hardware irq number in that domain space
603 604 605 606
 *
 * This is a fast path, for use by irq controller code that uses radix tree
 * revmaps
 */
607
unsigned int irq_radix_revmap_lookup(struct irq_domain *domain,
608 609 610 611
				     irq_hw_number_t hwirq)
{
	struct irq_data *irq_data;

612 613
	if (WARN_ON_ONCE(domain->revmap_type != IRQ_DOMAIN_MAP_TREE))
		return irq_find_mapping(domain, hwirq);
614 615 616 617 618 619

	/*
	 * Freeing an irq can delete nodes along the path to
	 * do the lookup via call_rcu.
	 */
	rcu_read_lock();
620
	irq_data = radix_tree_lookup(&domain->revmap_data.tree, hwirq);
621 622 623 624 625 626 627
	rcu_read_unlock();

	/*
	 * If found in radix tree, then fine.
	 * Else fallback to linear lookup - this should not happen in practice
	 * as it means that we failed to insert the node in the radix tree.
	 */
628
	return irq_data ? irq_data->irq : irq_find_mapping(domain, hwirq);
629
}
630
EXPORT_SYMBOL_GPL(irq_radix_revmap_lookup);
631 632 633

/**
 * irq_radix_revmap_insert() - Insert a hw irq to linux irq number mapping.
634
 * @domain: domain owning this hardware interrupt
635
 * @virq: linux irq number
636
 * @hwirq: hardware irq number in that domain space
637 638 639 640
 *
 * This is for use by irq controllers that use a radix tree reverse
 * mapping for fast lookup.
 */
641
void irq_radix_revmap_insert(struct irq_domain *domain, unsigned int virq,
642 643 644 645
			     irq_hw_number_t hwirq)
{
	struct irq_data *irq_data = irq_get_irq_data(virq);

646
	if (WARN_ON(domain->revmap_type != IRQ_DOMAIN_MAP_TREE))
647 648
		return;

649
	if (virq) {
650
		mutex_lock(&revmap_trees_mutex);
651
		radix_tree_insert(&domain->revmap_data.tree, hwirq, irq_data);
652 653 654
		mutex_unlock(&revmap_trees_mutex);
	}
}
655
EXPORT_SYMBOL_GPL(irq_radix_revmap_insert);
656 657 658

/**
 * irq_linear_revmap() - Find a linux irq from a hw irq number.
659 660
 * @domain: domain owning this hardware interrupt
 * @hwirq: hardware irq number in that domain space
661 662 663 664 665
 *
 * This is a fast path, for use by irq controller code that uses linear
 * revmaps. It does fallback to the slow path if the revmap doesn't exist
 * yet and will create the revmap entry with appropriate locking
 */
666
unsigned int irq_linear_revmap(struct irq_domain *domain,
667 668 669 670
			       irq_hw_number_t hwirq)
{
	unsigned int *revmap;

671 672
	if (WARN_ON_ONCE(domain->revmap_type != IRQ_DOMAIN_MAP_LINEAR))
		return irq_find_mapping(domain, hwirq);
673 674

	/* Check revmap bounds */
675 676
	if (unlikely(hwirq >= domain->revmap_data.linear.size))
		return irq_find_mapping(domain, hwirq);
677 678

	/* Check if revmap was allocated */
679
	revmap = domain->revmap_data.linear.revmap;
680
	if (unlikely(revmap == NULL))
681
		return irq_find_mapping(domain, hwirq);
682 683

	/* Fill up revmap with slow path if no mapping found */
684
	if (unlikely(!revmap[hwirq]))
685
		revmap[hwirq] = irq_find_mapping(domain, hwirq);
686 687 688

	return revmap[hwirq];
}
689
EXPORT_SYMBOL_GPL(irq_linear_revmap);
690

691
#ifdef CONFIG_IRQ_DOMAIN_DEBUG
692 693 694 695 696 697 698 699 700
static int virq_debug_show(struct seq_file *m, void *private)
{
	unsigned long flags;
	struct irq_desc *desc;
	const char *p;
	static const char none[] = "none";
	void *data;
	int i;

G
Grant Likely 已提交
701
	seq_printf(m, "%-5s  %-7s  %-15s  %-*s  %s\n", "irq", "hwirq",
702 703
		      "chip name", (int)(2 * sizeof(void *) + 2), "chip data",
		      "domain name");
704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725

	for (i = 1; i < nr_irqs; i++) {
		desc = irq_to_desc(i);
		if (!desc)
			continue;

		raw_spin_lock_irqsave(&desc->lock, flags);

		if (desc->action && desc->action->handler) {
			struct irq_chip *chip;

			seq_printf(m, "%5d  ", i);
			seq_printf(m, "0x%05lx  ", desc->irq_data.hwirq);

			chip = irq_desc_get_chip(desc);
			if (chip && chip->name)
				p = chip->name;
			else
				p = none;
			seq_printf(m, "%-15s  ", p);

			data = irq_desc_get_chip_data(desc);
G
Grant Likely 已提交
726
			seq_printf(m, data ? "0x%p  " : "  %p  ", data);
727

728
			if (desc->irq_data.domain && desc->irq_data.domain->of_node)
729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754
				p = desc->irq_data.domain->of_node->full_name;
			else
				p = none;
			seq_printf(m, "%s\n", p);
		}

		raw_spin_unlock_irqrestore(&desc->lock, flags);
	}

	return 0;
}

static int virq_debug_open(struct inode *inode, struct file *file)
{
	return single_open(file, virq_debug_show, inode->i_private);
}

static const struct file_operations virq_debug_fops = {
	.open = virq_debug_open,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
};

static int __init irq_debugfs_init(void)
{
755
	if (debugfs_create_file("irq_domain_mapping", S_IRUGO, NULL,
756 757 758 759 760 761
				 NULL, &virq_debug_fops) == NULL)
		return -ENOMEM;

	return 0;
}
__initcall(irq_debugfs_init);
762
#endif /* CONFIG_IRQ_DOMAIN_DEBUG */
763

764 765
static int irq_domain_simple_map(struct irq_domain *d, unsigned int irq,
				 irq_hw_number_t hwirq)
766
{
767
	return 0;
768
}
769

770 771 772 773 774 775 776 777 778
/**
 * irq_domain_xlate_onecell() - Generic xlate for direct one cell bindings
 *
 * Device Tree IRQ specifier translation function which works with one cell
 * bindings where the cell value maps directly to the hwirq number.
 */
int irq_domain_xlate_onecell(struct irq_domain *d, struct device_node *ctrlr,
			     const u32 *intspec, unsigned int intsize,
			     unsigned long *out_hwirq, unsigned int *out_type)
779
{
780
	if (WARN_ON(intsize < 1))
781 782 783 784 785
		return -EINVAL;
	*out_hwirq = intspec[0];
	*out_type = IRQ_TYPE_NONE;
	return 0;
}
786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829
EXPORT_SYMBOL_GPL(irq_domain_xlate_onecell);

/**
 * irq_domain_xlate_twocell() - Generic xlate for direct two cell bindings
 *
 * Device Tree IRQ specifier translation function which works with two cell
 * bindings where the cell values map directly to the hwirq number
 * and linux irq flags.
 */
int irq_domain_xlate_twocell(struct irq_domain *d, struct device_node *ctrlr,
			const u32 *intspec, unsigned int intsize,
			irq_hw_number_t *out_hwirq, unsigned int *out_type)
{
	if (WARN_ON(intsize < 2))
		return -EINVAL;
	*out_hwirq = intspec[0];
	*out_type = intspec[1] & IRQ_TYPE_SENSE_MASK;
	return 0;
}
EXPORT_SYMBOL_GPL(irq_domain_xlate_twocell);

/**
 * irq_domain_xlate_onetwocell() - Generic xlate for one or two cell bindings
 *
 * Device Tree IRQ specifier translation function which works with either one
 * or two cell bindings where the cell values map directly to the hwirq number
 * and linux irq flags.
 *
 * Note: don't use this function unless your interrupt controller explicitly
 * supports both one and two cell bindings.  For the majority of controllers
 * the _onecell() or _twocell() variants above should be used.
 */
int irq_domain_xlate_onetwocell(struct irq_domain *d,
				struct device_node *ctrlr,
				const u32 *intspec, unsigned int intsize,
				unsigned long *out_hwirq, unsigned int *out_type)
{
	if (WARN_ON(intsize < 1))
		return -EINVAL;
	*out_hwirq = intspec[0];
	*out_type = (intsize > 1) ? intspec[1] : IRQ_TYPE_NONE;
	return 0;
}
EXPORT_SYMBOL_GPL(irq_domain_xlate_onetwocell);
830

831
const struct irq_domain_ops irq_domain_simple_ops = {
832
	.map = irq_domain_simple_map,
833
	.xlate = irq_domain_xlate_onetwocell,
834 835 836 837
};
EXPORT_SYMBOL_GPL(irq_domain_simple_ops);

#ifdef CONFIG_OF_IRQ
838 839 840 841
void irq_domain_generate_simple(const struct of_device_id *match,
				u64 phys_base, unsigned int irq_start)
{
	struct device_node *node;
G
Grant Likely 已提交
842
	pr_debug("looking for phys_base=%llx, irq_start=%i\n",
843 844 845
		(unsigned long long) phys_base, (int) irq_start);
	node = of_find_matching_node_by_address(NULL, match, phys_base);
	if (node)
846 847
		irq_domain_add_legacy(node, 32, irq_start, 0,
				      &irq_domain_simple_ops, NULL);
848 849
}
EXPORT_SYMBOL_GPL(irq_domain_generate_simple);
850
#endif