irqdomain.c 25.9 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/topology.h>
14
#include <linux/seq_file.h>
15
#include <linux/slab.h>
16 17
#include <linux/smp.h>
#include <linux/fs.h>
18 19 20 21

static LIST_HEAD(irq_domain_list);
static DEFINE_MUTEX(irq_domain_mutex);

22
static DEFINE_MUTEX(revmap_trees_mutex);
23
static struct irq_domain *irq_default_domain;
24 25

/**
26
 * irq_domain_alloc() - Allocate a new irq_domain data structure
27 28
 * @of_node: optional device-tree node of the interrupt controller
 * @revmap_type: type of reverse mapping to use
29
 * @ops: map/unmap domain callbacks
30
 * @host_data: Controller private data pointer
31
 *
32 33 34
 * 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.
35
 */
36 37
static struct irq_domain *irq_domain_alloc(struct device_node *of_node,
					   unsigned int revmap_type,
38
					   const struct irq_domain_ops *ops,
39
					   void *host_data)
40
{
41
	struct irq_domain *domain;
42

43 44
	domain = kzalloc_node(sizeof(*domain), GFP_KERNEL,
			      of_node_to_nid(of_node));
45
	if (WARN_ON(!domain))
46 47 48
		return NULL;

	/* Fill structure */
49 50
	domain->revmap_type = revmap_type;
	domain->ops = ops;
51
	domain->host_data = host_data;
52
	domain->of_node = of_node_get(of_node);
53

54 55 56
	return domain;
}

57 58 59 60 61 62
static void irq_domain_free(struct irq_domain *domain)
{
	of_node_put(domain->of_node);
	kfree(domain);
}

63 64 65 66 67
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);
68
	pr_debug("Allocated domain of type %d @0x%p\n",
69 70 71
		 domain->revmap_type, domain);
}

72 73 74 75 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
/**
 * 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);

118
	pr_debug("Removed domain of type %d @0x%p\n",
119 120 121 122
		 domain->revmap_type, domain);

	irq_domain_free(domain);
}
123
EXPORT_SYMBOL_GPL(irq_domain_remove);
124

125 126 127 128 129 130 131 132 133 134 135
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;
}

136 137 138 139
/**
 * irq_domain_add_simple() - Allocate and register a simple irq_domain.
 * @of_node: pointer to interrupt controller's device tree node.
 * @size: total number of irqs in mapping
140 141 142 143
 * @first_irq: first number of irq block assigned to the domain,
 *	pass zero to assign irqs on-the-fly. This will result in a
 *	linear IRQ domain so it is important to use irq_create_mapping()
 *	for each used IRQ, especially when SPARSE_IRQ is enabled.
144 145 146 147
 * @ops: map/unmap domain callbacks
 * @host_data: Controller private data pointer
 *
 * Allocates a legacy irq_domain if irq_base is positive or a linear
148 149
 * domain otherwise. For the legacy domain, IRQ descriptors will also
 * be allocated.
150 151 152 153 154 155 156 157 158 159 160 161 162
 *
 * This is intended to implement the expected behaviour for most
 * interrupt controllers which is that a linear mapping should
 * normally be used unless the system requires a legacy mapping in
 * order to support supplying interrupt numbers during non-DT
 * registration of devices.
 */
struct irq_domain *irq_domain_add_simple(struct device_node *of_node,
					 unsigned int size,
					 unsigned int first_irq,
					 const struct irq_domain_ops *ops,
					 void *host_data)
{
163 164 165 166 167 168 169 170 171 172 173 174 175 176
	if (first_irq > 0) {
		int irq_base;

		if (IS_ENABLED(CONFIG_SPARSE_IRQ)) {
			/*
			 * Set the descriptor allocator to search for a
			 * 1-to-1 mapping, such as irq_alloc_desc_at().
			 * Use of_node_to_nid() which is defined to
			 * numa_node_id() on platforms that have no custom
			 * implementation.
			 */
			irq_base = irq_alloc_descs(first_irq, first_irq, size,
						   of_node_to_nid(of_node));
			if (irq_base < 0) {
177 178
				pr_info("Cannot allocate irq_descs @ IRQ%d, assuming pre-allocated\n",
					first_irq);
179 180 181 182 183 184
				irq_base = first_irq;
			}
		} else
			irq_base = first_irq;

		return irq_domain_add_legacy(of_node, size, irq_base, 0,
185
					     ops, host_data);
186 187 188 189
	}

	/* A linear domain is the default */
	return irq_domain_add_linear(of_node, size, ops, host_data);
190
}
191
EXPORT_SYMBOL_GPL(irq_domain_add_simple);
192

193 194 195
/**
 * irq_domain_add_legacy() - Allocate and register a legacy revmap irq_domain.
 * @of_node: pointer to interrupt controller's device tree node.
196 197 198 199 200
 * @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.
201 202 203 204 205 206 207 208
 * @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,
209 210 211
					 unsigned int size,
					 unsigned int first_irq,
					 irq_hw_number_t first_hwirq,
212
					 const struct irq_domain_ops *ops,
213 214
					 void *host_data)
{
215
	struct irq_domain *domain;
216 217 218 219 220 221
	unsigned int i;

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

222 223 224 225
	domain->revmap_data.legacy.first_irq = first_irq;
	domain->revmap_data.legacy.first_hwirq = first_hwirq;
	domain->revmap_data.legacy.size = size;

226
	mutex_lock(&irq_domain_mutex);
227 228 229 230 231 232
	/* 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)) {
233
			mutex_unlock(&irq_domain_mutex);
234
			irq_domain_free(domain);
235
			return NULL;
236 237 238
		}
	}

239 240 241 242
	/* 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;
243
		irq_data->domain = domain;
244 245 246 247 248 249 250 251 252 253
	}
	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;
254 255 256 257 258

		/* Legacy flags are left to default at this point,
		 * one can then use irq_create_mapping() to
		 * explicitly change them
		 */
259 260
		if (ops->map)
			ops->map(domain, irq, hwirq);
261 262

		/* Clear norequest flags */
263
		irq_clear_status_flags(irq, IRQ_NOREQUEST);
264
	}
265 266

	irq_domain_add(domain);
267 268
	return domain;
}
269
EXPORT_SYMBOL_GPL(irq_domain_add_legacy);
270 271

/**
272
 * irq_domain_add_linear() - Allocate and register a linear revmap irq_domain.
273
 * @of_node: pointer to interrupt controller's device tree node.
274
 * @size: Number of interrupts in the domain.
275 276 277 278 279
 * @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,
280
					 const struct irq_domain_ops *ops,
281 282 283 284
					 void *host_data)
{
	struct irq_domain *domain;
	unsigned int *revmap;
285

286 287
	revmap = kzalloc_node(sizeof(*revmap) * size, GFP_KERNEL,
			      of_node_to_nid(of_node));
288 289
	if (WARN_ON(!revmap))
		return NULL;
290

291 292 293 294 295 296 297 298 299 300
	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;
}
301
EXPORT_SYMBOL_GPL(irq_domain_add_linear);
302 303

struct irq_domain *irq_domain_add_nomap(struct device_node *of_node,
304
					 unsigned int max_irq,
305
					 const struct irq_domain_ops *ops,
306 307 308 309
					 void *host_data)
{
	struct irq_domain *domain = irq_domain_alloc(of_node,
					IRQ_DOMAIN_MAP_NOMAP, ops, host_data);
310 311
	if (domain) {
		domain->revmap_data.nomap.max_irq = max_irq ? max_irq : ~0;
312
		irq_domain_add(domain);
313
	}
314 315
	return domain;
}
316
EXPORT_SYMBOL_GPL(irq_domain_add_nomap);
317 318 319 320 321 322 323 324 325 326

/**
 * 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,
327
					 const struct irq_domain_ops *ops,
328 329 330 331 332 333 334 335
					 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);
	}
336
	return domain;
337
}
338
EXPORT_SYMBOL_GPL(irq_domain_add_tree);
339 340 341 342 343 344 345 346

/**
 * 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;
347
	int rc;
348 349 350 351 352 353 354

	/* 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);
355 356 357 358 359 360 361
	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) {
362 363 364
			found = h;
			break;
		}
365
	}
366 367 368 369 370 371 372
	mutex_unlock(&irq_domain_mutex);
	return found;
}
EXPORT_SYMBOL_GPL(irq_find_host);

/**
 * irq_set_default_host() - Set a "default" irq domain
373
 * @domain: default domain pointer
374 375 376 377 378 379
 *
 * 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.
 */
380
void irq_set_default_host(struct irq_domain *domain)
381
{
382
	pr_debug("Default domain set to @0x%p\n", domain);
383

384
	irq_default_domain = domain;
385
}
386
EXPORT_SYMBOL_GPL(irq_set_default_host);
387

388 389 390 391 392 393 394 395 396 397
static void irq_domain_disassociate_many(struct irq_domain *domain,
					 unsigned int irq_base, int count)
{
	/*
	 * disassociate in reverse order;
	 * not strictly necessary, but nice for unwinding
	 */
	while (count--) {
		int irq = irq_base + count;
		struct irq_data *irq_data = irq_get_irq_data(irq);
398
		irq_hw_number_t hwirq;
399 400 401 402

		if (WARN_ON(!irq_data || irq_data->domain != domain))
			continue;

403
		hwirq = irq_data->hwirq;
404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434
		irq_set_status_flags(irq, IRQ_NOREQUEST);

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

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

		/* Tell the PIC about it */
		if (domain->ops->unmap)
			domain->ops->unmap(domain, irq);
		smp_mb();

		irq_data->domain = NULL;
		irq_data->hwirq = 0;

		/* Clear reverse map */
		switch(domain->revmap_type) {
		case IRQ_DOMAIN_MAP_LINEAR:
			if (hwirq < domain->revmap_data.linear.size)
				domain->revmap_data.linear.revmap[hwirq] = 0;
			break;
		case IRQ_DOMAIN_MAP_TREE:
			mutex_lock(&revmap_trees_mutex);
			radix_tree_delete(&domain->revmap_data.tree, hwirq);
			mutex_unlock(&revmap_trees_mutex);
			break;
		}
	}
}

435 436
int irq_domain_associate_many(struct irq_domain *domain, unsigned int irq_base,
			      irq_hw_number_t hwirq_base, int count)
437
{
438 439
	unsigned int virq = irq_base;
	irq_hw_number_t hwirq = hwirq_base;
440
	int i, ret;
441

442 443
	pr_debug("%s(%s, irqbase=%i, hwbase=%i, count=%i)\n", __func__,
		of_node_full_name(domain->of_node), irq_base, (int)hwirq_base, count);
444

445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460
	for (i = 0; i < count; i++) {
		struct irq_data *irq_data = irq_get_irq_data(virq + i);

		if (WARN(!irq_data, "error: irq_desc not allocated; "
			 "irq=%i hwirq=0x%x\n", virq + i, (int)hwirq + i))
			return -EINVAL;
		if (WARN(irq_data->domain, "error: irq_desc already associated; "
			 "irq=%i hwirq=0x%x\n", virq + i, (int)hwirq + i))
			return -EINVAL;
	};

	for (i = 0; i < count; i++, virq++, hwirq++) {
		struct irq_data *irq_data = irq_get_irq_data(virq);

		irq_data->hwirq = hwirq;
		irq_data->domain = domain;
461 462 463
		if (domain->ops->map) {
			ret = domain->ops->map(domain, virq, hwirq);
			if (ret != 0) {
464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480
				/*
				 * If map() returns -EPERM, this interrupt is protected
				 * by the firmware or some other service and shall not
				 * be mapped.
				 *
				 * Since on some platforms we blindly try to map everything
				 * we end up with a log full of backtraces.
				 *
				 * So instead, we silently fail on -EPERM, it is the
				 * responsibility of the PIC driver to display a relevant
				 * message if needed.
				 */
				if (ret != -EPERM) {
					pr_err("irq-%i==>hwirq-0x%lx mapping failed: %d\n",
					       virq, hwirq, ret);
					WARN_ON(1);
				}
481 482 483 484
				irq_data->domain = NULL;
				irq_data->hwirq = 0;
				goto err_unmap;
			}
485 486 487 488 489 490 491 492 493
		}

		switch (domain->revmap_type) {
		case IRQ_DOMAIN_MAP_LINEAR:
			if (hwirq < domain->revmap_data.linear.size)
				domain->revmap_data.linear.revmap[hwirq] = virq;
			break;
		case IRQ_DOMAIN_MAP_TREE:
			mutex_lock(&revmap_trees_mutex);
494
			radix_tree_insert(&domain->revmap_data.tree, hwirq, irq_data);
495 496 497
			mutex_unlock(&revmap_trees_mutex);
			break;
		}
498

499 500
		irq_clear_status_flags(virq, IRQ_NOREQUEST);
	}
501 502

	return 0;
503 504 505 506

 err_unmap:
	irq_domain_disassociate_many(domain, irq_base, i);
	return -EINVAL;
507
}
508
EXPORT_SYMBOL_GPL(irq_domain_associate_many);
509 510 511

/**
 * irq_create_direct_mapping() - Allocate an irq for direct mapping
512
 * @domain: domain to allocate the irq for or NULL for default domain
513 514 515 516 517
 *
 * 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.
 */
518
unsigned int irq_create_direct_mapping(struct irq_domain *domain)
519 520 521
{
	unsigned int virq;

522 523
	if (domain == NULL)
		domain = irq_default_domain;
524

525 526
	if (WARN_ON(!domain || domain->revmap_type != IRQ_DOMAIN_MAP_NOMAP))
		return 0;
527

528
	virq = irq_alloc_desc_from(1, of_node_to_nid(domain->of_node));
529
	if (!virq) {
530
		pr_debug("create_direct virq allocation failed\n");
531
		return 0;
532
	}
533
	if (virq >= domain->revmap_data.nomap.max_irq) {
534
		pr_err("ERROR: no free irqs available below %i maximum\n",
535
			domain->revmap_data.nomap.max_irq);
536 537 538
		irq_free_desc(virq);
		return 0;
	}
539
	pr_debug("create_direct obtained virq %d\n", virq);
540

541
	if (irq_domain_associate(domain, virq, virq)) {
542
		irq_free_desc(virq);
543
		return 0;
544 545 546 547
	}

	return virq;
}
548
EXPORT_SYMBOL_GPL(irq_create_direct_mapping);
549 550 551

/**
 * irq_create_mapping() - Map a hardware interrupt into linux irq space
552 553
 * @domain: domain owning this hardware interrupt or NULL for default domain
 * @hwirq: hardware irq number in that domain space
554 555 556 557 558 559
 *
 * 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.
 */
560
unsigned int irq_create_mapping(struct irq_domain *domain,
561 562
				irq_hw_number_t hwirq)
{
563 564
	unsigned int hint;
	int virq;
565

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

568 569 570 571
	/* Look for default domain if nececssary */
	if (domain == NULL)
		domain = irq_default_domain;
	if (domain == NULL) {
572 573
		pr_warning("irq_create_mapping called for"
			   " NULL domain, hwirq=%lx\n", hwirq);
574
		WARN_ON(1);
575
		return 0;
576
	}
577
	pr_debug("-> using domain @%p\n", domain);
578 579

	/* Check if mapping already exists */
580
	virq = irq_find_mapping(domain, hwirq);
581
	if (virq) {
582
		pr_debug("-> existing mapping on virq %d\n", virq);
583 584 585 586
		return virq;
	}

	/* Get a virtual interrupt number */
587 588 589 590
	if (domain->revmap_type == IRQ_DOMAIN_MAP_LEGACY)
		return irq_domain_legacy_revmap(domain, hwirq);

	/* Allocate a virtual interrupt number */
591
	hint = hwirq % nr_irqs;
592 593
	if (hint == 0)
		hint++;
594
	virq = irq_alloc_desc_from(hint, of_node_to_nid(domain->of_node));
595
	if (virq <= 0)
596
		virq = irq_alloc_desc_from(1, of_node_to_nid(domain->of_node));
597
	if (virq <= 0) {
598
		pr_debug("-> virq allocation failed\n");
599
		return 0;
600 601
	}

602
	if (irq_domain_associate(domain, virq, hwirq)) {
603
		irq_free_desc(virq);
604
		return 0;
605 606
	}

607
	pr_debug("irq %lu on domain %s mapped to virtual irq %u\n",
608
		hwirq, of_node_full_name(domain->of_node), virq);
609 610 611 612 613

	return virq;
}
EXPORT_SYMBOL_GPL(irq_create_mapping);

614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651
/**
 * irq_create_strict_mappings() - Map a range of hw irqs to fixed linux irqs
 * @domain: domain owning the interrupt range
 * @irq_base: beginning of linux IRQ range
 * @hwirq_base: beginning of hardware IRQ range
 * @count: Number of interrupts to map
 *
 * This routine is used for allocating and mapping a range of hardware
 * irqs to linux irqs where the linux irq numbers are at pre-defined
 * locations. For use by controllers that already have static mappings
 * to insert in to the domain.
 *
 * Non-linear users can use irq_create_identity_mapping() for IRQ-at-a-time
 * domain insertion.
 *
 * 0 is returned upon success, while any failure to establish a static
 * mapping is treated as an error.
 */
int irq_create_strict_mappings(struct irq_domain *domain, unsigned int irq_base,
			       irq_hw_number_t hwirq_base, int count)
{
	int ret;

	ret = irq_alloc_descs(irq_base, irq_base, count,
			      of_node_to_nid(domain->of_node));
	if (unlikely(ret < 0))
		return ret;

	ret = irq_domain_associate_many(domain, irq_base, hwirq_base, count);
	if (unlikely(ret < 0)) {
		irq_free_descs(irq_base, count);
		return ret;
	}

	return 0;
}
EXPORT_SYMBOL_GPL(irq_create_strict_mappings);

652 653 654
unsigned int irq_create_of_mapping(struct device_node *controller,
				   const u32 *intspec, unsigned int intsize)
{
655
	struct irq_domain *domain;
656 657 658 659
	irq_hw_number_t hwirq;
	unsigned int type = IRQ_TYPE_NONE;
	unsigned int virq;

660 661
	domain = controller ? irq_find_host(controller) : irq_default_domain;
	if (!domain) {
662 663 664 665 666 667 668 669 670 671 672 673
#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
674
		pr_warning("no irq domain found for %s !\n",
675
			   of_node_full_name(controller));
676
		return 0;
677 678
	}

679 680
	/* If domain has no translation, then we assume interrupt line */
	if (domain->ops->xlate == NULL)
681 682
		hwirq = intspec[0];
	else {
683
		if (domain->ops->xlate(domain, controller, intspec, intsize,
684
				     &hwirq, &type))
685
			return 0;
686 687 688
	}

	/* Create mapping */
689
	virq = irq_create_mapping(domain, hwirq);
690
	if (!virq)
691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707
		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);
708
	struct irq_domain *domain;
709

710
	if (!virq || !irq_data)
711 712
		return;

713 714
	domain = irq_data->domain;
	if (WARN_ON(domain == NULL))
715 716 717
		return;

	/* Never unmap legacy interrupts */
718
	if (domain->revmap_type == IRQ_DOMAIN_MAP_LEGACY)
719 720
		return;

721
	irq_domain_disassociate_many(domain, virq, 1);
722 723 724 725 726 727
	irq_free_desc(virq);
}
EXPORT_SYMBOL_GPL(irq_dispose_mapping);

/**
 * irq_find_mapping() - Find a linux irq from an hw irq number.
728 729
 * @domain: domain owning this hardware interrupt
 * @hwirq: hardware irq number in that domain space
730
 */
731
unsigned int irq_find_mapping(struct irq_domain *domain,
732 733
			      irq_hw_number_t hwirq)
{
734
	struct irq_data *data;
735

736 737 738 739
	/* Look for default domain if nececssary */
	if (domain == NULL)
		domain = irq_default_domain;
	if (domain == NULL)
740
		return 0;
741

742 743
	switch (domain->revmap_type) {
	case IRQ_DOMAIN_MAP_LEGACY:
744
		return irq_domain_legacy_revmap(domain, hwirq);
745 746 747 748 749 750 751 752 753 754 755
	case IRQ_DOMAIN_MAP_LINEAR:
		return irq_linear_revmap(domain, hwirq);
	case IRQ_DOMAIN_MAP_TREE:
		rcu_read_lock();
		data = radix_tree_lookup(&domain->revmap_data.tree, hwirq);
		rcu_read_unlock();
		if (data)
			return data->irq;
		break;
	case IRQ_DOMAIN_MAP_NOMAP:
		data = irq_get_irq_data(hwirq);
756
		if (data && (data->domain == domain) && (data->hwirq == hwirq))
757 758 759 760
			return hwirq;
		break;
	}

761
	return 0;
762 763 764 765 766
}
EXPORT_SYMBOL_GPL(irq_find_mapping);

/**
 * irq_linear_revmap() - Find a linux irq from a hw irq number.
767 768
 * @domain: domain owning this hardware interrupt
 * @hwirq: hardware irq number in that domain space
769
 *
770 771
 * This is a fast path that can be called directly by irq controller code to
 * save a handful of instructions.
772
 */
773
unsigned int irq_linear_revmap(struct irq_domain *domain,
774 775
			       irq_hw_number_t hwirq)
{
776
	BUG_ON(domain->revmap_type != IRQ_DOMAIN_MAP_LINEAR);
777

778 779 780
	/* Check revmap bounds; complain if exceeded */
	if (WARN_ON(hwirq >= domain->revmap_data.linear.size))
		return 0;
781

782
	return domain->revmap_data.linear.revmap[hwirq];
783
}
784
EXPORT_SYMBOL_GPL(irq_linear_revmap);
785

786
#ifdef CONFIG_IRQ_DOMAIN_DEBUG
787 788 789 790 791 792 793 794 795
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;

796
	seq_printf(m, "%-5s  %-7s  %-15s  %-*s  %s\n", "irq", "hwirq",
797 798
		      "chip name", (int)(2 * sizeof(void *) + 2), "chip data",
		      "domain name");
799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820

	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);
821
			seq_printf(m, data ? "0x%p  " : "  %p  ", data);
822

823 824
			if (desc->irq_data.domain)
				p = of_node_full_name(desc->irq_data.domain->of_node);
825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849
			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)
{
850
	if (debugfs_create_file("irq_domain_mapping", S_IRUGO, NULL,
851 852 853 854 855 856
				 NULL, &virq_debug_fops) == NULL)
		return -ENOMEM;

	return 0;
}
__initcall(irq_debugfs_init);
857
#endif /* CONFIG_IRQ_DOMAIN_DEBUG */
858

859 860 861 862 863 864 865 866 867
/**
 * 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)
868
{
869
	if (WARN_ON(intsize < 1))
870 871 872 873 874
		return -EINVAL;
	*out_hwirq = intspec[0];
	*out_type = IRQ_TYPE_NONE;
	return 0;
}
875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918
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);
919

920
const struct irq_domain_ops irq_domain_simple_ops = {
921
	.xlate = irq_domain_xlate_onetwocell,
922 923 924 925
};
EXPORT_SYMBOL_GPL(irq_domain_simple_ops);

#ifdef CONFIG_OF_IRQ
926 927 928 929
void irq_domain_generate_simple(const struct of_device_id *match,
				u64 phys_base, unsigned int irq_start)
{
	struct device_node *node;
Grant Likely's avatar
Grant Likely committed
930
	pr_debug("looking for phys_base=%llx, irq_start=%i\n",
931 932 933
		(unsigned long long) phys_base, (int) irq_start);
	node = of_find_matching_node_by_address(NULL, match, phys_base);
	if (node)
934 935
		irq_domain_add_legacy(node, 32, irq_start, 0,
				      &irq_domain_simple_ops, NULL);
936 937
}
EXPORT_SYMBOL_GPL(irq_domain_generate_simple);
938
#endif