irqdomain.c 20.0 KB
Newer Older
1 2 3
#include <linux/debugfs.h>
#include <linux/hardirq.h>
#include <linux/interrupt.h>
4
#include <linux/irq.h>
5
#include <linux/irqdesc.h>
6 7 8 9
#include <linux/irqdomain.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/of.h>
10
#include <linux/of_address.h>
11
#include <linux/seq_file.h>
12
#include <linux/slab.h>
13 14
#include <linux/smp.h>
#include <linux/fs.h>
15

16 17
#define IRQ_DOMAIN_MAP_LEGACY 0 /* driver allocated fixed range of irqs.
				 * ie. legacy 8259, gets irqs 1..15 */
18 19 20 21
#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 */

22 23 24
static LIST_HEAD(irq_domain_list);
static DEFINE_MUTEX(irq_domain_mutex);

25 26
static DEFINE_MUTEX(revmap_trees_mutex);
static unsigned int irq_virq_count = NR_IRQS;
27
static struct irq_domain *irq_default_domain;
28

29
static int default_irq_domain_match(struct irq_domain *d, struct device_node *np)
30
{
31
	return d->of_node != NULL && d->of_node == np;
32 33 34
}

/**
35
 * irq_domain_alloc() - Allocate a new irq_domain data structure
36 37
 * @of_node: optional device-tree node of the interrupt controller
 * @revmap_type: type of reverse mapping to use
38
 * @ops: map/unmap domain callbacks
39
 * @host_data: Controller private data pointer
40
 *
41 42 43
 * 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.
44
 */
45 46 47 48
static struct irq_domain *irq_domain_alloc(struct device_node *of_node,
					   unsigned int revmap_type,
					   struct irq_domain_ops *ops,
					   void *host_data)
49
{
50
	struct irq_domain *domain;
51

52 53
	domain = kzalloc(sizeof(*domain), GFP_KERNEL);
	if (WARN_ON(!domain))
54 55 56
		return NULL;

	/* Fill structure */
57 58
	domain->revmap_type = revmap_type;
	domain->ops = ops;
59
	domain->host_data = host_data;
60
	domain->of_node = of_node_get(of_node);
61

62 63
	if (domain->ops->match == NULL)
		domain->ops->match = default_irq_domain_match;
64

65 66 67 68 69 70 71 72 73 74 75 76
	return domain;
}

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);
	pr_debug("irq: Allocated domain of type %d @0x%p\n",
		 domain->revmap_type, domain);
}

77 78 79 80 81 82 83 84 85 86 87
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;
}

88 89 90
/**
 * irq_domain_add_legacy() - Allocate and register a legacy revmap irq_domain.
 * @of_node: pointer to interrupt controller's device tree node.
91 92 93 94 95
 * @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.
96 97 98 99 100 101 102 103
 * @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,
104 105 106
					 unsigned int size,
					 unsigned int first_irq,
					 irq_hw_number_t first_hwirq,
107 108 109
					 struct irq_domain_ops *ops,
					 void *host_data)
{
110
	struct irq_domain *domain;
111 112 113 114 115 116
	unsigned int i;

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

117 118 119 120
	domain->revmap_data.legacy.first_irq = first_irq;
	domain->revmap_data.legacy.first_hwirq = first_hwirq;
	domain->revmap_data.legacy.size = size;

121
	mutex_lock(&irq_domain_mutex);
122 123 124 125 126 127
	/* 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)) {
128 129 130 131
			mutex_unlock(&irq_domain_mutex);
			of_node_put(domain->of_node);
			kfree(domain);
			return NULL;
132 133 134
		}
	}

135 136 137 138
	/* 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;
139
		irq_data->domain = domain;
140 141 142 143 144 145 146 147 148 149
	}
	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;
150 151 152 153 154

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

		/* Clear norequest flags */
158
		irq_clear_status_flags(irq, IRQ_NOREQUEST);
159
	}
160 161

	irq_domain_add(domain);
162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177
	return domain;
}

/**
 * irq_domain_add_linear() - Allocate and register a legacy revmap irq_domain.
 * @of_node: pointer to interrupt controller's device tree node.
 * @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,
					 struct irq_domain_ops *ops,
					 void *host_data)
{
	struct irq_domain *domain;
	unsigned int *revmap;
178

179 180 181
	revmap = kzalloc(sizeof(*revmap) * size, GFP_KERNEL);
	if (WARN_ON(!revmap))
		return NULL;
182

183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222
	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;
}

struct irq_domain *irq_domain_add_nomap(struct device_node *of_node,
					 struct irq_domain_ops *ops,
					 void *host_data)
{
	struct irq_domain *domain = irq_domain_alloc(of_node,
					IRQ_DOMAIN_MAP_NOMAP, ops, host_data);
	if (domain)
		irq_domain_add(domain);
	return domain;
}

/**
 * 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,
					 struct irq_domain_ops *ops,
					 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);
	}
223
	return domain;
224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251
}

/**
 * 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;

	/* 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);
	list_for_each_entry(h, &irq_domain_list, link)
		if (h->ops->match(h, node)) {
			found = h;
			break;
		}
	mutex_unlock(&irq_domain_mutex);
	return found;
}
EXPORT_SYMBOL_GPL(irq_find_host);

/**
 * irq_set_default_host() - Set a "default" irq domain
252
 * @domain: default domain pointer
253 254 255 256 257 258
 *
 * 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.
 */
259
void irq_set_default_host(struct irq_domain *domain)
260
{
261
	pr_debug("irq: Default domain set to @0x%p\n", domain);
262

263
	irq_default_domain = domain;
264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281
}

/**
 * irq_set_virq_count() - Set the maximum number of linux irqs
 * @count: number of linux irqs, capped with NR_IRQS
 *
 * This is mainly for use by platforms like iSeries who want to program
 * the virtual irq number in the controller to avoid the reverse mapping
 */
void irq_set_virq_count(unsigned int count)
{
	pr_debug("irq: Trying to set virq count to %d\n", count);

	BUG_ON(count < NUM_ISA_INTERRUPTS);
	if (count < NR_IRQS)
		irq_virq_count = count;
}

282
static int irq_setup_virq(struct irq_domain *domain, unsigned int virq,
283 284 285 286 287
			    irq_hw_number_t hwirq)
{
	struct irq_data *irq_data = irq_get_irq_data(virq);

	irq_data->hwirq = hwirq;
288 289
	irq_data->domain = domain;
	if (domain->ops->map(domain, virq, hwirq)) {
290 291 292 293 294 295 296 297 298 299 300 301 302
		pr_debug("irq: -> mapping failed, freeing\n");
		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
303
 * @domain: domain to allocate the irq for or NULL for default domain
304 305 306 307 308
 *
 * 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.
 */
309
unsigned int irq_create_direct_mapping(struct irq_domain *domain)
310 311 312
{
	unsigned int virq;

313 314
	if (domain == NULL)
		domain = irq_default_domain;
315

316 317
	BUG_ON(domain == NULL);
	WARN_ON(domain->revmap_type != IRQ_DOMAIN_MAP_NOMAP);
318 319

	virq = irq_alloc_desc_from(1, 0);
320
	if (!virq) {
321
		pr_debug("irq: create_direct virq allocation failed\n");
322
		return 0;
323 324 325 326 327 328 329 330 331 332
	}
	if (virq >= irq_virq_count) {
		pr_err("ERROR: no free irqs available below %i maximum\n",
			irq_virq_count);
		irq_free_desc(virq);
		return 0;
	}

	pr_debug("irq: create_direct obtained virq %d\n", virq);

333
	if (irq_setup_virq(domain, virq, virq)) {
334
		irq_free_desc(virq);
335
		return 0;
336 337 338 339 340 341 342
	}

	return virq;
}

/**
 * irq_create_mapping() - Map a hardware interrupt into linux irq space
343 344
 * @domain: domain owning this hardware interrupt or NULL for default domain
 * @hwirq: hardware irq number in that domain space
345 346 347 348 349 350
 *
 * 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.
 */
351
unsigned int irq_create_mapping(struct irq_domain *domain,
352 353 354 355
				irq_hw_number_t hwirq)
{
	unsigned int virq, hint;

356
	pr_debug("irq: irq_create_mapping(0x%p, 0x%lx)\n", domain, hwirq);
357

358 359 360 361
	/* Look for default domain if nececssary */
	if (domain == NULL)
		domain = irq_default_domain;
	if (domain == NULL) {
362
		printk(KERN_WARNING "irq_create_mapping called for"
363
		       " NULL domain, hwirq=%lx\n", hwirq);
364
		WARN_ON(1);
365
		return 0;
366
	}
367
	pr_debug("irq: -> using domain @%p\n", domain);
368 369

	/* Check if mapping already exists */
370
	virq = irq_find_mapping(domain, hwirq);
371
	if (virq) {
372 373 374 375 376
		pr_debug("irq: -> existing mapping on virq %d\n", virq);
		return virq;
	}

	/* Get a virtual interrupt number */
377 378 379 380 381 382 383 384 385 386 387 388 389
	if (domain->revmap_type == IRQ_DOMAIN_MAP_LEGACY)
		return irq_domain_legacy_revmap(domain, hwirq);

	/* Allocate a virtual interrupt number */
	hint = hwirq % irq_virq_count;
	if (hint == 0)
		hint++;
	virq = irq_alloc_desc_from(hint, 0);
	if (!virq)
		virq = irq_alloc_desc_from(1, 0);
	if (!virq) {
		pr_debug("irq: -> virq allocation failed\n");
		return 0;
390 391
	}

392 393
	if (irq_setup_virq(domain, virq, hwirq)) {
		if (domain->revmap_type != IRQ_DOMAIN_MAP_LEGACY)
394
			irq_free_desc(virq);
395
		return 0;
396 397
	}

398 399
	pr_debug("irq: irq %lu on domain %s mapped to virtual irq %u\n",
		hwirq, domain->of_node ? domain->of_node->full_name : "null", virq);
400 401 402 403 404 405 406 407

	return virq;
}
EXPORT_SYMBOL_GPL(irq_create_mapping);

unsigned int irq_create_of_mapping(struct device_node *controller,
				   const u32 *intspec, unsigned int intsize)
{
408
	struct irq_domain *domain;
409 410 411 412
	irq_hw_number_t hwirq;
	unsigned int type = IRQ_TYPE_NONE;
	unsigned int virq;

413 414 415
	domain = controller ? irq_find_host(controller) : irq_default_domain;
	if (!domain) {
		printk(KERN_WARNING "irq: no irq domain found for %s !\n",
416
		       controller->full_name);
417
		return 0;
418 419
	}

420 421
	/* If domain has no translation, then we assume interrupt line */
	if (domain->ops->xlate == NULL)
422 423
		hwirq = intspec[0];
	else {
424
		if (domain->ops->xlate(domain, controller, intspec, intsize,
425
				     &hwirq, &type))
426
			return 0;
427 428 429
	}

	/* Create mapping */
430
	virq = irq_create_mapping(domain, hwirq);
431
	if (!virq)
432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448
		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);
449
	struct irq_domain *domain;
450 451
	irq_hw_number_t hwirq;

452
	if (!virq || !irq_data)
453 454
		return;

455 456
	domain = irq_data->domain;
	if (WARN_ON(domain == NULL))
457 458 459
		return;

	/* Never unmap legacy interrupts */
460
	if (domain->revmap_type == IRQ_DOMAIN_MAP_LEGACY)
461 462 463 464 465 466 467 468 469 470 471
		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 */
472 473
	if (domain->ops->unmap)
		domain->ops->unmap(domain, virq);
474 475 476 477
	smp_mb();

	/* Clear reverse map */
	hwirq = irq_data->hwirq;
478
	switch(domain->revmap_type) {
479
	case IRQ_DOMAIN_MAP_LINEAR:
480 481
		if (hwirq < domain->revmap_data.linear.size)
			domain->revmap_data.linear.revmap[hwirq] = 0;
482 483 484
		break;
	case IRQ_DOMAIN_MAP_TREE:
		mutex_lock(&revmap_trees_mutex);
485
		radix_tree_delete(&domain->revmap_data.tree, hwirq);
486 487 488 489 490 491 492 493 494 495
		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.
496 497
 * @domain: domain owning this hardware interrupt
 * @hwirq: hardware irq number in that domain space
498 499 500 501 502
 *
 * 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.
 */
503
unsigned int irq_find_mapping(struct irq_domain *domain,
504 505 506 507 508
			      irq_hw_number_t hwirq)
{
	unsigned int i;
	unsigned int hint = hwirq % irq_virq_count;

509 510 511 512
	/* Look for default domain if nececssary */
	if (domain == NULL)
		domain = irq_default_domain;
	if (domain == NULL)
513
		return 0;
514 515

	/* legacy -> bail early */
516
	if (domain->revmap_type == IRQ_DOMAIN_MAP_LEGACY)
517
		return irq_domain_legacy_revmap(domain, hwirq);
518 519 520 521 522 523 524

	/* 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);
525
		if (data && (data->domain == domain) && (data->hwirq == hwirq))
526 527 528 529 530
			return i;
		i++;
		if (i >= irq_virq_count)
			i = 1;
	} while(i != hint);
531
	return 0;
532 533 534 535 536
}
EXPORT_SYMBOL_GPL(irq_find_mapping);

/**
 * irq_radix_revmap_lookup() - Find a linux irq from a hw irq number.
537 538
 * @domain: domain owning this hardware interrupt
 * @hwirq: hardware irq number in that domain space
539 540 541 542
 *
 * This is a fast path, for use by irq controller code that uses radix tree
 * revmaps
 */
543
unsigned int irq_radix_revmap_lookup(struct irq_domain *domain,
544 545 546 547
				     irq_hw_number_t hwirq)
{
	struct irq_data *irq_data;

548 549
	if (WARN_ON_ONCE(domain->revmap_type != IRQ_DOMAIN_MAP_TREE))
		return irq_find_mapping(domain, hwirq);
550 551 552 553 554 555

	/*
	 * Freeing an irq can delete nodes along the path to
	 * do the lookup via call_rcu.
	 */
	rcu_read_lock();
556
	irq_data = radix_tree_lookup(&domain->revmap_data.tree, hwirq);
557 558 559 560 561 562 563
	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.
	 */
564
	return irq_data ? irq_data->irq : irq_find_mapping(domain, hwirq);
565 566 567 568
}

/**
 * irq_radix_revmap_insert() - Insert a hw irq to linux irq number mapping.
569
 * @domain: domain owning this hardware interrupt
570
 * @virq: linux irq number
571
 * @hwirq: hardware irq number in that domain space
572 573 574 575
 *
 * This is for use by irq controllers that use a radix tree reverse
 * mapping for fast lookup.
 */
576
void irq_radix_revmap_insert(struct irq_domain *domain, unsigned int virq,
577 578 579 580
			     irq_hw_number_t hwirq)
{
	struct irq_data *irq_data = irq_get_irq_data(virq);

581
	if (WARN_ON(domain->revmap_type != IRQ_DOMAIN_MAP_TREE))
582 583
		return;

584
	if (virq) {
585
		mutex_lock(&revmap_trees_mutex);
586
		radix_tree_insert(&domain->revmap_data.tree, hwirq, irq_data);
587 588 589 590 591 592
		mutex_unlock(&revmap_trees_mutex);
	}
}

/**
 * irq_linear_revmap() - Find a linux irq from a hw irq number.
593 594
 * @domain: domain owning this hardware interrupt
 * @hwirq: hardware irq number in that domain space
595 596 597 598 599
 *
 * 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
 */
600
unsigned int irq_linear_revmap(struct irq_domain *domain,
601 602 603 604
			       irq_hw_number_t hwirq)
{
	unsigned int *revmap;

605 606
	if (WARN_ON_ONCE(domain->revmap_type != IRQ_DOMAIN_MAP_LINEAR))
		return irq_find_mapping(domain, hwirq);
607 608

	/* Check revmap bounds */
609 610
	if (unlikely(hwirq >= domain->revmap_data.linear.size))
		return irq_find_mapping(domain, hwirq);
611 612

	/* Check if revmap was allocated */
613
	revmap = domain->revmap_data.linear.revmap;
614
	if (unlikely(revmap == NULL))
615
		return irq_find_mapping(domain, hwirq);
616 617

	/* Fill up revmap with slow path if no mapping found */
618
	if (unlikely(!revmap[hwirq]))
619
		revmap[hwirq] = irq_find_mapping(domain, hwirq);
620 621 622 623 624 625 626 627 628 629 630 631 632 633 634

	return revmap[hwirq];
}

#ifdef CONFIG_VIRQ_DEBUG
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;

	seq_printf(m, "%-5s  %-7s  %-15s  %-18s  %s\n", "virq", "hwirq",
635
		      "chip name", "chip data", "domain name");
636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695

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

			if (desc->irq_data.domain->of_node)
				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)
{
	if (debugfs_create_file("virq_mapping", S_IRUGO, powerpc_debugfs_root,
				 NULL, &virq_debug_fops) == NULL)
		return -ENOMEM;

	return 0;
}
__initcall(irq_debugfs_init);
#endif /* CONFIG_VIRQ_DEBUG */

696 697
int irq_domain_simple_map(struct irq_domain *d, unsigned int irq,
			  irq_hw_number_t hwirq)
698
{
699
	return 0;
700
}
701

702
int irq_domain_simple_xlate(struct irq_domain *d,
703 704 705 706 707 708 709 710 711 712 713 714 715 716 717
			    struct device_node *controller,
			    const u32 *intspec, unsigned int intsize,
			    unsigned long *out_hwirq, unsigned int *out_type)
{
	if (d->of_node != controller)
		return -EINVAL;
	if (intsize < 1)
		return -EINVAL;
	*out_hwirq = intspec[0];
	*out_type = IRQ_TYPE_NONE;
	if (intsize > 1)
		*out_type = intspec[1] & IRQ_TYPE_SENSE_MASK;
	return 0;
}

718 719 720 721 722 723 724
struct irq_domain_ops irq_domain_simple_ops = {
	.map = irq_domain_simple_map,
	.xlate = irq_domain_simple_xlate,
};
EXPORT_SYMBOL_GPL(irq_domain_simple_ops);

#ifdef CONFIG_OF_IRQ
725 726
void irq_domain_add_simple(struct device_node *controller, int irq_base)
{
727 728
	irq_domain_add_legacy(controller, 32, irq_base, 0,
			      &irq_domain_simple_ops, NULL);
729 730 731 732 733 734 735
}
EXPORT_SYMBOL_GPL(irq_domain_add_simple);

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 已提交
736
	pr_debug("looking for phys_base=%llx, irq_start=%i\n",
737 738 739 740 741 742
		(unsigned long long) phys_base, (int) irq_start);
	node = of_find_matching_node_by_address(NULL, match, phys_base);
	if (node)
		irq_domain_add_simple(node, irq_start);
}
EXPORT_SYMBOL_GPL(irq_domain_generate_simple);
743
#endif