1// SPDX-License-Identifier: GPL-2.0
   2
   3#define pr_fmt(fmt)  "irq: " fmt
   4
   5#include <linux/acpi.h>
   6#include <linux/debugfs.h>
   7#include <linux/hardirq.h>
   8#include <linux/interrupt.h>
   9#include <linux/irq.h>
  10#include <linux/irqdesc.h>
  11#include <linux/irqdomain.h>
  12#include <linux/module.h>
  13#include <linux/mutex.h>
  14#include <linux/of.h>
  15#include <linux/of_address.h>
  16#include <linux/of_irq.h>
  17#include <linux/topology.h>
  18#include <linux/seq_file.h>
  19#include <linux/slab.h>
  20#include <linux/smp.h>
  21#include <linux/fs.h>
  22
  23static LIST_HEAD(irq_domain_list);
  24static DEFINE_MUTEX(irq_domain_mutex);
  25
  26static struct irq_domain *irq_default_domain;
  27
  28static int irq_domain_alloc_irqs_locked(struct irq_domain *domain, int irq_base,
  29					unsigned int nr_irqs, int node, void *arg,
  30					bool realloc, const struct irq_affinity_desc *affinity);
  31static void irq_domain_check_hierarchy(struct irq_domain *domain);
  32
  33struct irqchip_fwid {
  34	struct fwnode_handle	fwnode;
  35	unsigned int		type;
  36	char			*name;
  37	phys_addr_t		*pa;
  38};
  39
  40#ifdef CONFIG_GENERIC_IRQ_DEBUGFS
  41static void debugfs_add_domain_dir(struct irq_domain *d);
  42static void debugfs_remove_domain_dir(struct irq_domain *d);
  43#else
  44static inline void debugfs_add_domain_dir(struct irq_domain *d) { }
  45static inline void debugfs_remove_domain_dir(struct irq_domain *d) { }
  46#endif
  47
  48static const char *irqchip_fwnode_get_name(const struct fwnode_handle *fwnode)
  49{
  50	struct irqchip_fwid *fwid = container_of(fwnode, struct irqchip_fwid, fwnode);
  51
  52	return fwid->name;
  53}
  54
  55const struct fwnode_operations irqchip_fwnode_ops = {
  56	.get_name = irqchip_fwnode_get_name,
  57};
  58EXPORT_SYMBOL_GPL(irqchip_fwnode_ops);
  59
  60/**
  61 * __irq_domain_alloc_fwnode - Allocate a fwnode_handle suitable for
  62 *                           identifying an irq domain
  63 * @type:	Type of irqchip_fwnode. See linux/irqdomain.h
  64 * @id:		Optional user provided id if name != NULL
  65 * @name:	Optional user provided domain name
  66 * @pa:		Optional user-provided physical address
  67 *
  68 * Allocate a struct irqchip_fwid, and return a pointer to the embedded
  69 * fwnode_handle (or NULL on failure).
  70 *
  71 * Note: The types IRQCHIP_FWNODE_NAMED and IRQCHIP_FWNODE_NAMED_ID are
  72 * solely to transport name information to irqdomain creation code. The
  73 * node is not stored. For other types the pointer is kept in the irq
  74 * domain struct.
  75 */
  76struct fwnode_handle *__irq_domain_alloc_fwnode(unsigned int type, int id,
  77						const char *name,
  78						phys_addr_t *pa)
  79{
  80	struct irqchip_fwid *fwid;
  81	char *n;
  82
  83	fwid = kzalloc(sizeof(*fwid), GFP_KERNEL);
  84
  85	switch (type) {
  86	case IRQCHIP_FWNODE_NAMED:
  87		n = kasprintf(GFP_KERNEL, "%s", name);
  88		break;
  89	case IRQCHIP_FWNODE_NAMED_ID:
  90		n = kasprintf(GFP_KERNEL, "%s-%d", name, id);
  91		break;
  92	default:
  93		n = kasprintf(GFP_KERNEL, "irqchip@%pa", pa);
  94		break;
  95	}
  96
  97	if (!fwid || !n) {
  98		kfree(fwid);
  99		kfree(n);
 100		return NULL;
 101	}
 102
 103	fwid->type = type;
 104	fwid->name = n;
 105	fwid->pa = pa;
 106	fwnode_init(&fwid->fwnode, &irqchip_fwnode_ops);
 107	return &fwid->fwnode;
 108}
 109EXPORT_SYMBOL_GPL(__irq_domain_alloc_fwnode);
 110
 111/**
 112 * irq_domain_free_fwnode - Free a non-OF-backed fwnode_handle
 113 *
 114 * Free a fwnode_handle allocated with irq_domain_alloc_fwnode.
 115 */
 116void irq_domain_free_fwnode(struct fwnode_handle *fwnode)
 117{
 118	struct irqchip_fwid *fwid;
 119
 120	if (!fwnode || WARN_ON(!is_fwnode_irqchip(fwnode)))
 121		return;
 122
 123	fwid = container_of(fwnode, struct irqchip_fwid, fwnode);
 124	kfree(fwid->name);
 125	kfree(fwid);
 126}
 127EXPORT_SYMBOL_GPL(irq_domain_free_fwnode);
 128
 129static struct irq_domain *__irq_domain_create(struct fwnode_handle *fwnode,
 130					      unsigned int size,
 131					      irq_hw_number_t hwirq_max,
 132					      int direct_max,
 133					      const struct irq_domain_ops *ops,
 134					      void *host_data)
 
 
 
 
 
 
 
 
 
 
 
 135{
 136	struct irqchip_fwid *fwid;
 137	struct irq_domain *domain;
 138
 139	static atomic_t unknown_domains;
 140
 141	if (WARN_ON((size && direct_max) ||
 142		    (!IS_ENABLED(CONFIG_IRQ_DOMAIN_NOMAP) && direct_max) ||
 143		    (direct_max && (direct_max != hwirq_max))))
 144		return NULL;
 145
 146	domain = kzalloc_node(struct_size(domain, revmap, size),
 147			      GFP_KERNEL, of_node_to_nid(to_of_node(fwnode)));
 148	if (!domain)
 149		return NULL;
 150
 151	if (is_fwnode_irqchip(fwnode)) {
 152		fwid = container_of(fwnode, struct irqchip_fwid, fwnode);
 153
 154		switch (fwid->type) {
 155		case IRQCHIP_FWNODE_NAMED:
 156		case IRQCHIP_FWNODE_NAMED_ID:
 157			domain->fwnode = fwnode;
 158			domain->name = kstrdup(fwid->name, GFP_KERNEL);
 159			if (!domain->name) {
 160				kfree(domain);
 161				return NULL;
 162			}
 163			domain->flags |= IRQ_DOMAIN_NAME_ALLOCATED;
 164			break;
 165		default:
 166			domain->fwnode = fwnode;
 167			domain->name = fwid->name;
 168			break;
 169		}
 170	} else if (is_of_node(fwnode) || is_acpi_device_node(fwnode) ||
 171		   is_software_node(fwnode)) {
 172		char *name;
 173
 174		/*
 175		 * fwnode paths contain '/', which debugfs is legitimately
 176		 * unhappy about. Replace them with ':', which does
 177		 * the trick and is not as offensive as '\'...
 178		 */
 179		name = kasprintf(GFP_KERNEL, "%pfw", fwnode);
 180		if (!name) {
 181			kfree(domain);
 182			return NULL;
 183		}
 184
 185		domain->name = strreplace(name, '/', ':');
 
 
 186		domain->fwnode = fwnode;
 187		domain->flags |= IRQ_DOMAIN_NAME_ALLOCATED;
 188	}
 189
 190	if (!domain->name) {
 191		if (fwnode)
 192			pr_err("Invalid fwnode type for irqdomain\n");
 193		domain->name = kasprintf(GFP_KERNEL, "unknown-%d",
 194					 atomic_inc_return(&unknown_domains));
 195		if (!domain->name) {
 196			kfree(domain);
 197			return NULL;
 198		}
 199		domain->flags |= IRQ_DOMAIN_NAME_ALLOCATED;
 200	}
 201
 202	fwnode_handle_get(fwnode);
 203	fwnode_dev_initialized(fwnode, true);
 204
 205	/* Fill structure */
 206	INIT_RADIX_TREE(&domain->revmap_tree, GFP_KERNEL);
 
 207	domain->ops = ops;
 208	domain->host_data = host_data;
 209	domain->hwirq_max = hwirq_max;
 210
 211	if (direct_max)
 
 212		domain->flags |= IRQ_DOMAIN_FLAG_NO_MAP;
 
 213
 214	domain->revmap_size = size;
 215
 216	/*
 217	 * Hierarchical domains use the domain lock of the root domain
 218	 * (innermost domain).
 219	 *
 220	 * For non-hierarchical domains (as for root domains), the root
 221	 * pointer is set to the domain itself so that &domain->root->mutex
 222	 * always points to the right lock.
 223	 */
 224	mutex_init(&domain->mutex);
 225	domain->root = domain;
 226
 227	irq_domain_check_hierarchy(domain);
 228
 229	return domain;
 230}
 231
 232static void __irq_domain_publish(struct irq_domain *domain)
 233{
 234	mutex_lock(&irq_domain_mutex);
 235	debugfs_add_domain_dir(domain);
 236	list_add(&domain->link, &irq_domain_list);
 237	mutex_unlock(&irq_domain_mutex);
 238
 239	pr_debug("Added domain %s\n", domain->name);
 240}
 241
 242/**
 243 * __irq_domain_add() - Allocate a new irq_domain data structure
 244 * @fwnode: firmware node for the interrupt controller
 245 * @size: Size of linear map; 0 for radix mapping only
 246 * @hwirq_max: Maximum number of interrupts supported by controller
 247 * @direct_max: Maximum value of direct maps; Use ~0 for no limit; 0 for no
 248 *              direct mapping
 249 * @ops: domain callbacks
 250 * @host_data: Controller private data pointer
 251 *
 252 * Allocates and initializes an irq_domain structure.
 253 * Returns pointer to IRQ domain, or NULL on failure.
 254 */
 255struct irq_domain *__irq_domain_add(struct fwnode_handle *fwnode, unsigned int size,
 256				    irq_hw_number_t hwirq_max, int direct_max,
 257				    const struct irq_domain_ops *ops,
 258				    void *host_data)
 259{
 260	struct irq_domain *domain;
 261
 262	domain = __irq_domain_create(fwnode, size, hwirq_max, direct_max,
 263				     ops, host_data);
 264	if (domain)
 265		__irq_domain_publish(domain);
 266
 267	return domain;
 268}
 269EXPORT_SYMBOL_GPL(__irq_domain_add);
 270
 271/**
 272 * irq_domain_remove() - Remove an irq domain.
 273 * @domain: domain to remove
 274 *
 275 * This routine is used to remove an irq domain. The caller must ensure
 276 * that all mappings within the domain have been disposed of prior to
 277 * use, depending on the revmap type.
 278 */
 279void irq_domain_remove(struct irq_domain *domain)
 280{
 281	mutex_lock(&irq_domain_mutex);
 282	debugfs_remove_domain_dir(domain);
 283
 284	WARN_ON(!radix_tree_empty(&domain->revmap_tree));
 285
 286	list_del(&domain->link);
 287
 288	/*
 289	 * If the going away domain is the default one, reset it.
 290	 */
 291	if (unlikely(irq_default_domain == domain))
 292		irq_set_default_host(NULL);
 293
 294	mutex_unlock(&irq_domain_mutex);
 295
 296	pr_debug("Removed domain %s\n", domain->name);
 297
 298	fwnode_dev_initialized(domain->fwnode, false);
 299	fwnode_handle_put(domain->fwnode);
 300	if (domain->flags & IRQ_DOMAIN_NAME_ALLOCATED)
 301		kfree(domain->name);
 302	kfree(domain);
 303}
 304EXPORT_SYMBOL_GPL(irq_domain_remove);
 305
 306void irq_domain_update_bus_token(struct irq_domain *domain,
 307				 enum irq_domain_bus_token bus_token)
 308{
 309	char *name;
 310
 311	if (domain->bus_token == bus_token)
 312		return;
 313
 314	mutex_lock(&irq_domain_mutex);
 315
 316	domain->bus_token = bus_token;
 317
 318	name = kasprintf(GFP_KERNEL, "%s-%d", domain->name, bus_token);
 319	if (!name) {
 320		mutex_unlock(&irq_domain_mutex);
 321		return;
 322	}
 323
 324	debugfs_remove_domain_dir(domain);
 325
 326	if (domain->flags & IRQ_DOMAIN_NAME_ALLOCATED)
 327		kfree(domain->name);
 328	else
 329		domain->flags |= IRQ_DOMAIN_NAME_ALLOCATED;
 330
 331	domain->name = name;
 332	debugfs_add_domain_dir(domain);
 333
 334	mutex_unlock(&irq_domain_mutex);
 335}
 336EXPORT_SYMBOL_GPL(irq_domain_update_bus_token);
 337
 338/**
 339 * irq_domain_create_simple() - Register an irq_domain and optionally map a range of irqs
 340 * @fwnode: firmware node for the interrupt controller
 341 * @size: total number of irqs in mapping
 342 * @first_irq: first number of irq block assigned to the domain,
 343 *	pass zero to assign irqs on-the-fly. If first_irq is non-zero, then
 344 *	pre-map all of the irqs in the domain to virqs starting at first_irq.
 345 * @ops: domain callbacks
 346 * @host_data: Controller private data pointer
 347 *
 348 * Allocates an irq_domain, and optionally if first_irq is positive then also
 349 * allocate irq_descs and map all of the hwirqs to virqs starting at first_irq.
 350 *
 351 * This is intended to implement the expected behaviour for most
 352 * interrupt controllers. If device tree is used, then first_irq will be 0 and
 353 * irqs get mapped dynamically on the fly. However, if the controller requires
 354 * static virq assignments (non-DT boot) then it will set that up correctly.
 355 */
 356struct irq_domain *irq_domain_create_simple(struct fwnode_handle *fwnode,
 357					    unsigned int size,
 358					    unsigned int first_irq,
 359					    const struct irq_domain_ops *ops,
 360					    void *host_data)
 361{
 362	struct irq_domain *domain;
 363
 364	domain = __irq_domain_add(fwnode, size, size, 0, ops, host_data);
 365	if (!domain)
 366		return NULL;
 367
 368	if (first_irq > 0) {
 369		if (IS_ENABLED(CONFIG_SPARSE_IRQ)) {
 370			/* attempt to allocated irq_descs */
 371			int rc = irq_alloc_descs(first_irq, first_irq, size,
 372						 of_node_to_nid(to_of_node(fwnode)));
 373			if (rc < 0)
 374				pr_info("Cannot allocate irq_descs @ IRQ%d, assuming pre-allocated\n",
 375					first_irq);
 376		}
 377		irq_domain_associate_many(domain, first_irq, 0, size);
 378	}
 379
 380	return domain;
 381}
 382EXPORT_SYMBOL_GPL(irq_domain_create_simple);
 383
 384/**
 385 * irq_domain_add_legacy() - Allocate and register a legacy revmap irq_domain.
 386 * @of_node: pointer to interrupt controller's device tree node.
 387 * @size: total number of irqs in legacy mapping
 388 * @first_irq: first number of irq block assigned to the domain
 389 * @first_hwirq: first hwirq number to use for the translation. Should normally
 390 *               be '0', but a positive integer can be used if the effective
 391 *               hwirqs numbering does not begin at zero.
 392 * @ops: map/unmap domain callbacks
 393 * @host_data: Controller private data pointer
 394 *
 395 * Note: the map() callback will be called before this function returns
 396 * for all legacy interrupts except 0 (which is always the invalid irq for
 397 * a legacy controller).
 398 */
 399struct irq_domain *irq_domain_add_legacy(struct device_node *of_node,
 400					 unsigned int size,
 401					 unsigned int first_irq,
 402					 irq_hw_number_t first_hwirq,
 403					 const struct irq_domain_ops *ops,
 404					 void *host_data)
 405{
 406	return irq_domain_create_legacy(of_node_to_fwnode(of_node), size,
 407					first_irq, first_hwirq, ops, host_data);
 408}
 409EXPORT_SYMBOL_GPL(irq_domain_add_legacy);
 410
 411struct irq_domain *irq_domain_create_legacy(struct fwnode_handle *fwnode,
 412					 unsigned int size,
 413					 unsigned int first_irq,
 414					 irq_hw_number_t first_hwirq,
 415					 const struct irq_domain_ops *ops,
 416					 void *host_data)
 417{
 418	struct irq_domain *domain;
 419
 420	domain = __irq_domain_add(fwnode, first_hwirq + size, first_hwirq + size, 0, ops, host_data);
 421	if (domain)
 422		irq_domain_associate_many(domain, first_irq, first_hwirq, size);
 423
 424	return domain;
 425}
 426EXPORT_SYMBOL_GPL(irq_domain_create_legacy);
 427
 428/**
 429 * irq_find_matching_fwspec() - Locates a domain for a given fwspec
 430 * @fwspec: FW specifier for an interrupt
 431 * @bus_token: domain-specific data
 432 */
 433struct irq_domain *irq_find_matching_fwspec(struct irq_fwspec *fwspec,
 434					    enum irq_domain_bus_token bus_token)
 435{
 436	struct irq_domain *h, *found = NULL;
 437	struct fwnode_handle *fwnode = fwspec->fwnode;
 438	int rc;
 439
 440	/* We might want to match the legacy controller last since
 441	 * it might potentially be set to match all interrupts in
 442	 * the absence of a device node. This isn't a problem so far
 443	 * yet though...
 444	 *
 445	 * bus_token == DOMAIN_BUS_ANY matches any domain, any other
 446	 * values must generate an exact match for the domain to be
 447	 * selected.
 448	 */
 449	mutex_lock(&irq_domain_mutex);
 450	list_for_each_entry(h, &irq_domain_list, link) {
 451		if (h->ops->select && fwspec->param_count)
 452			rc = h->ops->select(h, fwspec, bus_token);
 453		else if (h->ops->match)
 454			rc = h->ops->match(h, to_of_node(fwnode), bus_token);
 455		else
 456			rc = ((fwnode != NULL) && (h->fwnode == fwnode) &&
 457			      ((bus_token == DOMAIN_BUS_ANY) ||
 458			       (h->bus_token == bus_token)));
 459
 460		if (rc) {
 461			found = h;
 462			break;
 463		}
 464	}
 465	mutex_unlock(&irq_domain_mutex);
 466	return found;
 467}
 468EXPORT_SYMBOL_GPL(irq_find_matching_fwspec);
 469
 470/**
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 471 * irq_set_default_host() - Set a "default" irq domain
 472 * @domain: default domain pointer
 473 *
 474 * For convenience, it's possible to set a "default" domain that will be used
 475 * whenever NULL is passed to irq_create_mapping(). It makes life easier for
 476 * platforms that want to manipulate a few hard coded interrupt numbers that
 477 * aren't properly represented in the device-tree.
 478 */
 479void irq_set_default_host(struct irq_domain *domain)
 480{
 481	pr_debug("Default domain set to @0x%p\n", domain);
 482
 483	irq_default_domain = domain;
 484}
 485EXPORT_SYMBOL_GPL(irq_set_default_host);
 486
 487/**
 488 * irq_get_default_host() - Retrieve the "default" irq domain
 489 *
 490 * Returns: the default domain, if any.
 491 *
 492 * Modern code should never use this. This should only be used on
 493 * systems that cannot implement a firmware->fwnode mapping (which
 494 * both DT and ACPI provide).
 495 */
 496struct irq_domain *irq_get_default_host(void)
 497{
 498	return irq_default_domain;
 499}
 500EXPORT_SYMBOL_GPL(irq_get_default_host);
 501
 502static bool irq_domain_is_nomap(struct irq_domain *domain)
 503{
 504	return IS_ENABLED(CONFIG_IRQ_DOMAIN_NOMAP) &&
 505	       (domain->flags & IRQ_DOMAIN_FLAG_NO_MAP);
 506}
 507
 508static void irq_domain_clear_mapping(struct irq_domain *domain,
 509				     irq_hw_number_t hwirq)
 510{
 511	lockdep_assert_held(&domain->root->mutex);
 512
 513	if (irq_domain_is_nomap(domain))
 514		return;
 515
 
 516	if (hwirq < domain->revmap_size)
 517		rcu_assign_pointer(domain->revmap[hwirq], NULL);
 518	else
 519		radix_tree_delete(&domain->revmap_tree, hwirq);
 
 520}
 521
 522static void irq_domain_set_mapping(struct irq_domain *domain,
 523				   irq_hw_number_t hwirq,
 524				   struct irq_data *irq_data)
 525{
 526	/*
 527	 * This also makes sure that all domains point to the same root when
 528	 * called from irq_domain_insert_irq() for each domain in a hierarchy.
 529	 */
 530	lockdep_assert_held(&domain->root->mutex);
 531
 532	if (irq_domain_is_nomap(domain))
 533		return;
 534
 
 535	if (hwirq < domain->revmap_size)
 536		rcu_assign_pointer(domain->revmap[hwirq], irq_data);
 537	else
 538		radix_tree_insert(&domain->revmap_tree, hwirq, irq_data);
 
 539}
 540
 541static void irq_domain_disassociate(struct irq_domain *domain, unsigned int irq)
 542{
 543	struct irq_data *irq_data = irq_get_irq_data(irq);
 544	irq_hw_number_t hwirq;
 545
 546	if (WARN(!irq_data || irq_data->domain != domain,
 547		 "virq%i doesn't exist; cannot disassociate\n", irq))
 548		return;
 549
 550	hwirq = irq_data->hwirq;
 551
 552	mutex_lock(&domain->root->mutex);
 553
 554	irq_set_status_flags(irq, IRQ_NOREQUEST);
 555
 556	/* remove chip and handler */
 557	irq_set_chip_and_handler(irq, NULL, NULL);
 558
 559	/* Make sure it's completed */
 560	synchronize_irq(irq);
 561
 562	/* Tell the PIC about it */
 563	if (domain->ops->unmap)
 564		domain->ops->unmap(domain, irq);
 565	smp_mb();
 566
 567	irq_data->domain = NULL;
 568	irq_data->hwirq = 0;
 569	domain->mapcount--;
 570
 571	/* Clear reverse map for this hwirq */
 572	irq_domain_clear_mapping(domain, hwirq);
 573
 574	mutex_unlock(&domain->root->mutex);
 575}
 576
 577static int irq_domain_associate_locked(struct irq_domain *domain, unsigned int virq,
 578				       irq_hw_number_t hwirq)
 579{
 580	struct irq_data *irq_data = irq_get_irq_data(virq);
 581	int ret;
 582
 583	if (WARN(hwirq >= domain->hwirq_max,
 584		 "error: hwirq 0x%x is too large for %s\n", (int)hwirq, domain->name))
 585		return -EINVAL;
 586	if (WARN(!irq_data, "error: virq%i is not allocated", virq))
 587		return -EINVAL;
 588	if (WARN(irq_data->domain, "error: virq%i is already associated", virq))
 589		return -EINVAL;
 590
 
 591	irq_data->hwirq = hwirq;
 592	irq_data->domain = domain;
 593	if (domain->ops->map) {
 594		ret = domain->ops->map(domain, virq, hwirq);
 595		if (ret != 0) {
 596			/*
 597			 * If map() returns -EPERM, this interrupt is protected
 598			 * by the firmware or some other service and shall not
 599			 * be mapped. Don't bother telling the user about it.
 600			 */
 601			if (ret != -EPERM) {
 602				pr_info("%s didn't like hwirq-0x%lx to VIRQ%i mapping (rc=%d)\n",
 603				       domain->name, hwirq, virq, ret);
 604			}
 605			irq_data->domain = NULL;
 606			irq_data->hwirq = 0;
 
 607			return ret;
 608		}
 
 
 
 
 609	}
 610
 611	domain->mapcount++;
 612	irq_domain_set_mapping(domain, hwirq, irq_data);
 
 613
 614	irq_clear_status_flags(virq, IRQ_NOREQUEST);
 615
 616	return 0;
 617}
 618
 619int irq_domain_associate(struct irq_domain *domain, unsigned int virq,
 620			 irq_hw_number_t hwirq)
 621{
 622	int ret;
 623
 624	mutex_lock(&domain->root->mutex);
 625	ret = irq_domain_associate_locked(domain, virq, hwirq);
 626	mutex_unlock(&domain->root->mutex);
 627
 628	return ret;
 629}
 630EXPORT_SYMBOL_GPL(irq_domain_associate);
 631
 632void irq_domain_associate_many(struct irq_domain *domain, unsigned int irq_base,
 633			       irq_hw_number_t hwirq_base, int count)
 634{
 635	struct device_node *of_node;
 636	int i;
 637
 638	of_node = irq_domain_get_of_node(domain);
 639	pr_debug("%s(%s, irqbase=%i, hwbase=%i, count=%i)\n", __func__,
 640		of_node_full_name(of_node), irq_base, (int)hwirq_base, count);
 641
 642	for (i = 0; i < count; i++)
 643		irq_domain_associate(domain, irq_base + i, hwirq_base + i);
 
 644}
 645EXPORT_SYMBOL_GPL(irq_domain_associate_many);
 646
 647#ifdef CONFIG_IRQ_DOMAIN_NOMAP
 648/**
 649 * irq_create_direct_mapping() - Allocate an irq for direct mapping
 650 * @domain: domain to allocate the irq for or NULL for default domain
 651 *
 652 * This routine is used for irq controllers which can choose the hardware
 653 * interrupt numbers they generate. In such a case it's simplest to use
 654 * the linux irq as the hardware interrupt number. It still uses the linear
 655 * or radix tree to store the mapping, but the irq controller can optimize
 656 * the revmap path by using the hwirq directly.
 657 */
 658unsigned int irq_create_direct_mapping(struct irq_domain *domain)
 659{
 660	struct device_node *of_node;
 661	unsigned int virq;
 662
 663	if (domain == NULL)
 664		domain = irq_default_domain;
 665
 666	of_node = irq_domain_get_of_node(domain);
 667	virq = irq_alloc_desc_from(1, of_node_to_nid(of_node));
 668	if (!virq) {
 669		pr_debug("create_direct virq allocation failed\n");
 670		return 0;
 671	}
 672	if (virq >= domain->hwirq_max) {
 673		pr_err("ERROR: no free irqs available below %lu maximum\n",
 674			domain->hwirq_max);
 675		irq_free_desc(virq);
 676		return 0;
 677	}
 678	pr_debug("create_direct obtained virq %d\n", virq);
 679
 680	if (irq_domain_associate(domain, virq, virq)) {
 681		irq_free_desc(virq);
 682		return 0;
 683	}
 684
 685	return virq;
 686}
 687EXPORT_SYMBOL_GPL(irq_create_direct_mapping);
 688#endif
 689
 690static unsigned int irq_create_mapping_affinity_locked(struct irq_domain *domain,
 691						       irq_hw_number_t hwirq,
 692						       const struct irq_affinity_desc *affinity)
 693{
 694	struct device_node *of_node = irq_domain_get_of_node(domain);
 695	int virq;
 696
 697	pr_debug("irq_create_mapping(0x%p, 0x%lx)\n", domain, hwirq);
 698
 699	/* Allocate a virtual interrupt number */
 700	virq = irq_domain_alloc_descs(-1, 1, hwirq, of_node_to_nid(of_node),
 701				      affinity);
 702	if (virq <= 0) {
 703		pr_debug("-> virq allocation failed\n");
 704		return 0;
 705	}
 706
 707	if (irq_domain_associate_locked(domain, virq, hwirq)) {
 708		irq_free_desc(virq);
 709		return 0;
 710	}
 711
 712	pr_debug("irq %lu on domain %s mapped to virtual irq %u\n",
 713		hwirq, of_node_full_name(of_node), virq);
 714
 715	return virq;
 716}
 717
 718/**
 719 * irq_create_mapping_affinity() - Map a hardware interrupt into linux irq space
 720 * @domain: domain owning this hardware interrupt or NULL for default domain
 721 * @hwirq: hardware irq number in that domain space
 722 * @affinity: irq affinity
 723 *
 724 * Only one mapping per hardware interrupt is permitted. Returns a linux
 725 * irq number.
 726 * If the sense/trigger is to be specified, set_irq_type() should be called
 727 * on the number returned from that call.
 728 */
 729unsigned int irq_create_mapping_affinity(struct irq_domain *domain,
 730					 irq_hw_number_t hwirq,
 731					 const struct irq_affinity_desc *affinity)
 732{
 
 733	int virq;
 734
 
 
 735	/* Look for default domain if necessary */
 736	if (domain == NULL)
 737		domain = irq_default_domain;
 738	if (domain == NULL) {
 739		WARN(1, "%s(, %lx) called with NULL domain\n", __func__, hwirq);
 740		return 0;
 741	}
 
 742
 743	mutex_lock(&domain->root->mutex);
 744
 745	/* Check if mapping already exists */
 746	virq = irq_find_mapping(domain, hwirq);
 747	if (virq) {
 748		pr_debug("existing mapping on virq %d\n", virq);
 749		goto out;
 
 
 
 
 
 
 
 
 750	}
 751
 752	virq = irq_create_mapping_affinity_locked(domain, hwirq, affinity);
 753out:
 754	mutex_unlock(&domain->root->mutex);
 
 
 
 
 755
 756	return virq;
 757}
 758EXPORT_SYMBOL_GPL(irq_create_mapping_affinity);
 759
 760static int irq_domain_translate(struct irq_domain *d,
 761				struct irq_fwspec *fwspec,
 762				irq_hw_number_t *hwirq, unsigned int *type)
 763{
 764#ifdef CONFIG_IRQ_DOMAIN_HIERARCHY
 765	if (d->ops->translate)
 766		return d->ops->translate(d, fwspec, hwirq, type);
 767#endif
 768	if (d->ops->xlate)
 769		return d->ops->xlate(d, to_of_node(fwspec->fwnode),
 770				     fwspec->param, fwspec->param_count,
 771				     hwirq, type);
 772
 773	/* If domain has no translation, then we assume interrupt line */
 774	*hwirq = fwspec->param[0];
 775	return 0;
 776}
 777
 778void of_phandle_args_to_fwspec(struct device_node *np, const u32 *args,
 779			       unsigned int count, struct irq_fwspec *fwspec)
 
 780{
 781	int i;
 782
 783	fwspec->fwnode = of_node_to_fwnode(np);
 784	fwspec->param_count = count;
 785
 786	for (i = 0; i < count; i++)
 787		fwspec->param[i] = args[i];
 788}
 789EXPORT_SYMBOL_GPL(of_phandle_args_to_fwspec);
 790
 791unsigned int irq_create_fwspec_mapping(struct irq_fwspec *fwspec)
 792{
 793	struct irq_domain *domain;
 794	struct irq_data *irq_data;
 795	irq_hw_number_t hwirq;
 796	unsigned int type = IRQ_TYPE_NONE;
 797	int virq;
 798
 799	if (fwspec->fwnode) {
 800		domain = irq_find_matching_fwspec(fwspec, DOMAIN_BUS_WIRED);
 801		if (!domain)
 802			domain = irq_find_matching_fwspec(fwspec, DOMAIN_BUS_ANY);
 803	} else {
 804		domain = irq_default_domain;
 805	}
 806
 807	if (!domain) {
 808		pr_warn("no irq domain found for %s !\n",
 809			of_node_full_name(to_of_node(fwspec->fwnode)));
 810		return 0;
 811	}
 812
 813	if (irq_domain_translate(domain, fwspec, &hwirq, &type))
 814		return 0;
 815
 816	/*
 817	 * WARN if the irqchip returns a type with bits
 818	 * outside the sense mask set and clear these bits.
 819	 */
 820	if (WARN_ON(type & ~IRQ_TYPE_SENSE_MASK))
 821		type &= IRQ_TYPE_SENSE_MASK;
 822
 823	mutex_lock(&domain->root->mutex);
 824
 825	/*
 826	 * If we've already configured this interrupt,
 827	 * don't do it again, or hell will break loose.
 828	 */
 829	virq = irq_find_mapping(domain, hwirq);
 830	if (virq) {
 831		/*
 832		 * If the trigger type is not specified or matches the
 833		 * current trigger type then we are done so return the
 834		 * interrupt number.
 835		 */
 836		if (type == IRQ_TYPE_NONE || type == irq_get_trigger_type(virq))
 837			goto out;
 838
 839		/*
 840		 * If the trigger type has not been set yet, then set
 841		 * it now and return the interrupt number.
 842		 */
 843		if (irq_get_trigger_type(virq) == IRQ_TYPE_NONE) {
 844			irq_data = irq_get_irq_data(virq);
 845			if (!irq_data) {
 846				virq = 0;
 847				goto out;
 848			}
 849
 850			irqd_set_trigger_type(irq_data, type);
 851			goto out;
 852		}
 853
 854		pr_warn("type mismatch, failed to map hwirq-%lu for %s!\n",
 855			hwirq, of_node_full_name(to_of_node(fwspec->fwnode)));
 856		virq = 0;
 857		goto out;
 858	}
 859
 860	if (irq_domain_is_hierarchy(domain)) {
 861		virq = irq_domain_alloc_irqs_locked(domain, -1, 1, NUMA_NO_NODE,
 862						    fwspec, false, NULL);
 863		if (virq <= 0) {
 864			virq = 0;
 865			goto out;
 866		}
 867	} else {
 868		/* Create mapping */
 869		virq = irq_create_mapping_affinity_locked(domain, hwirq, NULL);
 870		if (!virq)
 871			goto out;
 872	}
 873
 874	irq_data = irq_get_irq_data(virq);
 875	if (WARN_ON(!irq_data)) {
 876		virq = 0;
 877		goto out;
 
 
 
 878	}
 879
 880	/* Store trigger type */
 881	irqd_set_trigger_type(irq_data, type);
 882out:
 883	mutex_unlock(&domain->root->mutex);
 884
 885	return virq;
 886}
 887EXPORT_SYMBOL_GPL(irq_create_fwspec_mapping);
 888
 889unsigned int irq_create_of_mapping(struct of_phandle_args *irq_data)
 890{
 891	struct irq_fwspec fwspec;
 892
 893	of_phandle_args_to_fwspec(irq_data->np, irq_data->args,
 894				  irq_data->args_count, &fwspec);
 895
 896	return irq_create_fwspec_mapping(&fwspec);
 897}
 898EXPORT_SYMBOL_GPL(irq_create_of_mapping);
 899
 900/**
 901 * irq_dispose_mapping() - Unmap an interrupt
 902 * @virq: linux irq number of the interrupt to unmap
 903 */
 904void irq_dispose_mapping(unsigned int virq)
 905{
 906	struct irq_data *irq_data = irq_get_irq_data(virq);
 907	struct irq_domain *domain;
 908
 909	if (!virq || !irq_data)
 910		return;
 911
 912	domain = irq_data->domain;
 913	if (WARN_ON(domain == NULL))
 914		return;
 915
 916	if (irq_domain_is_hierarchy(domain)) {
 917		irq_domain_free_irqs(virq, 1);
 918	} else {
 919		irq_domain_disassociate(domain, virq);
 920		irq_free_desc(virq);
 921	}
 922}
 923EXPORT_SYMBOL_GPL(irq_dispose_mapping);
 924
 925/**
 926 * __irq_resolve_mapping() - Find a linux irq from a hw irq number.
 927 * @domain: domain owning this hardware interrupt
 928 * @hwirq: hardware irq number in that domain space
 929 * @irq: optional pointer to return the Linux irq if required
 930 *
 931 * Returns the interrupt descriptor.
 932 */
 933struct irq_desc *__irq_resolve_mapping(struct irq_domain *domain,
 934				       irq_hw_number_t hwirq,
 935				       unsigned int *irq)
 936{
 937	struct irq_desc *desc = NULL;
 938	struct irq_data *data;
 939
 940	/* Look for default domain if necessary */
 941	if (domain == NULL)
 942		domain = irq_default_domain;
 943	if (domain == NULL)
 944		return desc;
 945
 946	if (irq_domain_is_nomap(domain)) {
 947		if (hwirq < domain->hwirq_max) {
 948			data = irq_domain_get_irq_data(domain, hwirq);
 949			if (data && data->hwirq == hwirq)
 950				desc = irq_data_to_desc(data);
 951			if (irq && desc)
 952				*irq = hwirq;
 953		}
 954
 955		return desc;
 956	}
 957
 958	rcu_read_lock();
 959	/* Check if the hwirq is in the linear revmap. */
 960	if (hwirq < domain->revmap_size)
 961		data = rcu_dereference(domain->revmap[hwirq]);
 962	else
 963		data = radix_tree_lookup(&domain->revmap_tree, hwirq);
 964
 965	if (likely(data)) {
 966		desc = irq_data_to_desc(data);
 967		if (irq)
 968			*irq = data->irq;
 969	}
 970
 971	rcu_read_unlock();
 972	return desc;
 973}
 974EXPORT_SYMBOL_GPL(__irq_resolve_mapping);
 975
 976/**
 977 * irq_domain_xlate_onecell() - Generic xlate for direct one cell bindings
 978 *
 979 * Device Tree IRQ specifier translation function which works with one cell
 980 * bindings where the cell value maps directly to the hwirq number.
 981 */
 982int irq_domain_xlate_onecell(struct irq_domain *d, struct device_node *ctrlr,
 983			     const u32 *intspec, unsigned int intsize,
 984			     unsigned long *out_hwirq, unsigned int *out_type)
 985{
 986	if (WARN_ON(intsize < 1))
 987		return -EINVAL;
 988	*out_hwirq = intspec[0];
 989	*out_type = IRQ_TYPE_NONE;
 990	return 0;
 991}
 992EXPORT_SYMBOL_GPL(irq_domain_xlate_onecell);
 993
 994/**
 995 * irq_domain_xlate_twocell() - Generic xlate for direct two cell bindings
 996 *
 997 * Device Tree IRQ specifier translation function which works with two cell
 998 * bindings where the cell values map directly to the hwirq number
 999 * and linux irq flags.
1000 */
1001int irq_domain_xlate_twocell(struct irq_domain *d, struct device_node *ctrlr,
1002			const u32 *intspec, unsigned int intsize,
1003			irq_hw_number_t *out_hwirq, unsigned int *out_type)
1004{
1005	struct irq_fwspec fwspec;
1006
1007	of_phandle_args_to_fwspec(ctrlr, intspec, intsize, &fwspec);
1008	return irq_domain_translate_twocell(d, &fwspec, out_hwirq, out_type);
1009}
1010EXPORT_SYMBOL_GPL(irq_domain_xlate_twocell);
1011
1012/**
1013 * irq_domain_xlate_onetwocell() - Generic xlate for one or two cell bindings
1014 *
1015 * Device Tree IRQ specifier translation function which works with either one
1016 * or two cell bindings where the cell values map directly to the hwirq number
1017 * and linux irq flags.
1018 *
1019 * Note: don't use this function unless your interrupt controller explicitly
1020 * supports both one and two cell bindings.  For the majority of controllers
1021 * the _onecell() or _twocell() variants above should be used.
1022 */
1023int irq_domain_xlate_onetwocell(struct irq_domain *d,
1024				struct device_node *ctrlr,
1025				const u32 *intspec, unsigned int intsize,
1026				unsigned long *out_hwirq, unsigned int *out_type)
1027{
1028	if (WARN_ON(intsize < 1))
1029		return -EINVAL;
1030	*out_hwirq = intspec[0];
1031	if (intsize > 1)
1032		*out_type = intspec[1] & IRQ_TYPE_SENSE_MASK;
1033	else
1034		*out_type = IRQ_TYPE_NONE;
1035	return 0;
1036}
1037EXPORT_SYMBOL_GPL(irq_domain_xlate_onetwocell);
1038
1039const struct irq_domain_ops irq_domain_simple_ops = {
1040	.xlate = irq_domain_xlate_onetwocell,
1041};
1042EXPORT_SYMBOL_GPL(irq_domain_simple_ops);
1043
1044/**
1045 * irq_domain_translate_onecell() - Generic translate for direct one cell
1046 * bindings
1047 */
1048int irq_domain_translate_onecell(struct irq_domain *d,
1049				 struct irq_fwspec *fwspec,
1050				 unsigned long *out_hwirq,
1051				 unsigned int *out_type)
1052{
1053	if (WARN_ON(fwspec->param_count < 1))
1054		return -EINVAL;
1055	*out_hwirq = fwspec->param[0];
1056	*out_type = IRQ_TYPE_NONE;
1057	return 0;
1058}
1059EXPORT_SYMBOL_GPL(irq_domain_translate_onecell);
1060
1061/**
1062 * irq_domain_translate_twocell() - Generic translate for direct two cell
1063 * bindings
1064 *
1065 * Device Tree IRQ specifier translation function which works with two cell
1066 * bindings where the cell values map directly to the hwirq number
1067 * and linux irq flags.
1068 */
1069int irq_domain_translate_twocell(struct irq_domain *d,
1070				 struct irq_fwspec *fwspec,
1071				 unsigned long *out_hwirq,
1072				 unsigned int *out_type)
1073{
1074	if (WARN_ON(fwspec->param_count < 2))
1075		return -EINVAL;
1076	*out_hwirq = fwspec->param[0];
1077	*out_type = fwspec->param[1] & IRQ_TYPE_SENSE_MASK;
1078	return 0;
1079}
1080EXPORT_SYMBOL_GPL(irq_domain_translate_twocell);
1081
1082int irq_domain_alloc_descs(int virq, unsigned int cnt, irq_hw_number_t hwirq,
1083			   int node, const struct irq_affinity_desc *affinity)
1084{
1085	unsigned int hint;
1086
1087	if (virq >= 0) {
1088		virq = __irq_alloc_descs(virq, virq, cnt, node, THIS_MODULE,
1089					 affinity);
1090	} else {
1091		hint = hwirq % nr_irqs;
1092		if (hint == 0)
1093			hint++;
1094		virq = __irq_alloc_descs(-1, hint, cnt, node, THIS_MODULE,
1095					 affinity);
1096		if (virq <= 0 && hint > 1) {
1097			virq = __irq_alloc_descs(-1, 1, cnt, node, THIS_MODULE,
1098						 affinity);
1099		}
1100	}
1101
1102	return virq;
1103}
1104
1105/**
1106 * irq_domain_reset_irq_data - Clear hwirq, chip and chip_data in @irq_data
1107 * @irq_data:	The pointer to irq_data
1108 */
1109void irq_domain_reset_irq_data(struct irq_data *irq_data)
1110{
1111	irq_data->hwirq = 0;
1112	irq_data->chip = &no_irq_chip;
1113	irq_data->chip_data = NULL;
1114}
1115EXPORT_SYMBOL_GPL(irq_domain_reset_irq_data);
1116
1117#ifdef	CONFIG_IRQ_DOMAIN_HIERARCHY
1118/**
1119 * irq_domain_create_hierarchy - Add a irqdomain into the hierarchy
1120 * @parent:	Parent irq domain to associate with the new domain
1121 * @flags:	Irq domain flags associated to the domain
1122 * @size:	Size of the domain. See below
1123 * @fwnode:	Optional fwnode of the interrupt controller
1124 * @ops:	Pointer to the interrupt domain callbacks
1125 * @host_data:	Controller private data pointer
1126 *
1127 * If @size is 0 a tree domain is created, otherwise a linear domain.
1128 *
1129 * If successful the parent is associated to the new domain and the
1130 * domain flags are set.
1131 * Returns pointer to IRQ domain, or NULL on failure.
1132 */
1133struct irq_domain *irq_domain_create_hierarchy(struct irq_domain *parent,
1134					    unsigned int flags,
1135					    unsigned int size,
1136					    struct fwnode_handle *fwnode,
1137					    const struct irq_domain_ops *ops,
1138					    void *host_data)
1139{
1140	struct irq_domain *domain;
1141
1142	if (size)
1143		domain = __irq_domain_create(fwnode, size, size, 0, ops, host_data);
1144	else
1145		domain = __irq_domain_create(fwnode, 0, ~0, 0, ops, host_data);
1146
1147	if (domain) {
1148		if (parent)
1149			domain->root = parent->root;
1150		domain->parent = parent;
1151		domain->flags |= flags;
1152
1153		__irq_domain_publish(domain);
1154	}
1155
1156	return domain;
1157}
1158EXPORT_SYMBOL_GPL(irq_domain_create_hierarchy);
1159
1160static void irq_domain_insert_irq(int virq)
1161{
1162	struct irq_data *data;
1163
1164	for (data = irq_get_irq_data(virq); data; data = data->parent_data) {
1165		struct irq_domain *domain = data->domain;
1166
1167		domain->mapcount++;
1168		irq_domain_set_mapping(domain, data->hwirq, data);
 
 
 
 
1169	}
1170
1171	irq_clear_status_flags(virq, IRQ_NOREQUEST);
1172}
1173
1174static void irq_domain_remove_irq(int virq)
1175{
1176	struct irq_data *data;
1177
1178	irq_set_status_flags(virq, IRQ_NOREQUEST);
1179	irq_set_chip_and_handler(virq, NULL, NULL);
1180	synchronize_irq(virq);
1181	smp_mb();
1182
1183	for (data = irq_get_irq_data(virq); data; data = data->parent_data) {
1184		struct irq_domain *domain = data->domain;
1185		irq_hw_number_t hwirq = data->hwirq;
1186
1187		domain->mapcount--;
1188		irq_domain_clear_mapping(domain, hwirq);
1189	}
1190}
1191
1192static struct irq_data *irq_domain_insert_irq_data(struct irq_domain *domain,
1193						   struct irq_data *child)
1194{
1195	struct irq_data *irq_data;
1196
1197	irq_data = kzalloc_node(sizeof(*irq_data), GFP_KERNEL,
1198				irq_data_get_node(child));
1199	if (irq_data) {
1200		child->parent_data = irq_data;
1201		irq_data->irq = child->irq;
1202		irq_data->common = child->common;
1203		irq_data->domain = domain;
1204	}
1205
1206	return irq_data;
1207}
1208
1209static void __irq_domain_free_hierarchy(struct irq_data *irq_data)
1210{
1211	struct irq_data *tmp;
1212
1213	while (irq_data) {
1214		tmp = irq_data;
1215		irq_data = irq_data->parent_data;
1216		kfree(tmp);
1217	}
1218}
1219
1220static void irq_domain_free_irq_data(unsigned int virq, unsigned int nr_irqs)
1221{
1222	struct irq_data *irq_data, *tmp;
1223	int i;
1224
1225	for (i = 0; i < nr_irqs; i++) {
1226		irq_data = irq_get_irq_data(virq + i);
1227		tmp = irq_data->parent_data;
1228		irq_data->parent_data = NULL;
1229		irq_data->domain = NULL;
1230
1231		__irq_domain_free_hierarchy(tmp);
1232	}
1233}
1234
1235/**
1236 * irq_domain_disconnect_hierarchy - Mark the first unused level of a hierarchy
1237 * @domain:	IRQ domain from which the hierarchy is to be disconnected
1238 * @virq:	IRQ number where the hierarchy is to be trimmed
1239 *
1240 * Marks the @virq level belonging to @domain as disconnected.
1241 * Returns -EINVAL if @virq doesn't have a valid irq_data pointing
1242 * to @domain.
1243 *
1244 * Its only use is to be able to trim levels of hierarchy that do not
1245 * have any real meaning for this interrupt, and that the driver marks
1246 * as such from its .alloc() callback.
1247 */
1248int irq_domain_disconnect_hierarchy(struct irq_domain *domain,
1249				    unsigned int virq)
1250{
1251	struct irq_data *irqd;
1252
1253	irqd = irq_domain_get_irq_data(domain, virq);
1254	if (!irqd)
1255		return -EINVAL;
1256
1257	irqd->chip = ERR_PTR(-ENOTCONN);
1258	return 0;
1259}
1260EXPORT_SYMBOL_GPL(irq_domain_disconnect_hierarchy);
1261
1262static int irq_domain_trim_hierarchy(unsigned int virq)
1263{
1264	struct irq_data *tail, *irqd, *irq_data;
1265
1266	irq_data = irq_get_irq_data(virq);
1267	tail = NULL;
1268
1269	/* The first entry must have a valid irqchip */
1270	if (!irq_data->chip || IS_ERR(irq_data->chip))
1271		return -EINVAL;
1272
1273	/*
1274	 * Validate that the irq_data chain is sane in the presence of
1275	 * a hierarchy trimming marker.
1276	 */
1277	for (irqd = irq_data->parent_data; irqd; irq_data = irqd, irqd = irqd->parent_data) {
1278		/* Can't have a valid irqchip after a trim marker */
1279		if (irqd->chip && tail)
1280			return -EINVAL;
1281
1282		/* Can't have an empty irqchip before a trim marker */
1283		if (!irqd->chip && !tail)
1284			return -EINVAL;
1285
1286		if (IS_ERR(irqd->chip)) {
1287			/* Only -ENOTCONN is a valid trim marker */
1288			if (PTR_ERR(irqd->chip) != -ENOTCONN)
1289				return -EINVAL;
1290
1291			tail = irq_data;
1292		}
1293	}
1294
1295	/* No trim marker, nothing to do */
1296	if (!tail)
1297		return 0;
1298
1299	pr_info("IRQ%d: trimming hierarchy from %s\n",
1300		virq, tail->parent_data->domain->name);
1301
1302	/* Sever the inner part of the hierarchy...  */
1303	irqd = tail;
1304	tail = tail->parent_data;
1305	irqd->parent_data = NULL;
1306	__irq_domain_free_hierarchy(tail);
1307
1308	return 0;
1309}
1310
1311static int irq_domain_alloc_irq_data(struct irq_domain *domain,
1312				     unsigned int virq, unsigned int nr_irqs)
1313{
1314	struct irq_data *irq_data;
1315	struct irq_domain *parent;
1316	int i;
1317
1318	/* The outermost irq_data is embedded in struct irq_desc */
1319	for (i = 0; i < nr_irqs; i++) {
1320		irq_data = irq_get_irq_data(virq + i);
1321		irq_data->domain = domain;
1322
1323		for (parent = domain->parent; parent; parent = parent->parent) {
1324			irq_data = irq_domain_insert_irq_data(parent, irq_data);
1325			if (!irq_data) {
1326				irq_domain_free_irq_data(virq, i + 1);
1327				return -ENOMEM;
1328			}
1329		}
1330	}
1331
1332	return 0;
1333}
1334
1335/**
1336 * irq_domain_get_irq_data - Get irq_data associated with @virq and @domain
1337 * @domain:	domain to match
1338 * @virq:	IRQ number to get irq_data
1339 */
1340struct irq_data *irq_domain_get_irq_data(struct irq_domain *domain,
1341					 unsigned int virq)
1342{
1343	struct irq_data *irq_data;
1344
1345	for (irq_data = irq_get_irq_data(virq); irq_data;
1346	     irq_data = irq_data->parent_data)
1347		if (irq_data->domain == domain)
1348			return irq_data;
1349
1350	return NULL;
1351}
1352EXPORT_SYMBOL_GPL(irq_domain_get_irq_data);
1353
1354/**
1355 * irq_domain_set_hwirq_and_chip - Set hwirq and irqchip of @virq at @domain
1356 * @domain:	Interrupt domain to match
1357 * @virq:	IRQ number
1358 * @hwirq:	The hwirq number
1359 * @chip:	The associated interrupt chip
1360 * @chip_data:	The associated chip data
1361 */
1362int irq_domain_set_hwirq_and_chip(struct irq_domain *domain, unsigned int virq,
1363				  irq_hw_number_t hwirq,
1364				  const struct irq_chip *chip,
1365				  void *chip_data)
1366{
1367	struct irq_data *irq_data = irq_domain_get_irq_data(domain, virq);
1368
1369	if (!irq_data)
1370		return -ENOENT;
1371
1372	irq_data->hwirq = hwirq;
1373	irq_data->chip = (struct irq_chip *)(chip ? chip : &no_irq_chip);
1374	irq_data->chip_data = chip_data;
1375
1376	return 0;
1377}
1378EXPORT_SYMBOL_GPL(irq_domain_set_hwirq_and_chip);
1379
1380/**
1381 * irq_domain_set_info - Set the complete data for a @virq in @domain
1382 * @domain:		Interrupt domain to match
1383 * @virq:		IRQ number
1384 * @hwirq:		The hardware interrupt number
1385 * @chip:		The associated interrupt chip
1386 * @chip_data:		The associated interrupt chip data
1387 * @handler:		The interrupt flow handler
1388 * @handler_data:	The interrupt flow handler data
1389 * @handler_name:	The interrupt handler name
1390 */
1391void irq_domain_set_info(struct irq_domain *domain, unsigned int virq,
1392			 irq_hw_number_t hwirq, const struct irq_chip *chip,
1393			 void *chip_data, irq_flow_handler_t handler,
1394			 void *handler_data, const char *handler_name)
1395{
1396	irq_domain_set_hwirq_and_chip(domain, virq, hwirq, chip, chip_data);
1397	__irq_set_handler(virq, handler, 0, handler_name);
1398	irq_set_handler_data(virq, handler_data);
1399}
1400EXPORT_SYMBOL(irq_domain_set_info);
1401
1402/**
1403 * irq_domain_free_irqs_common - Clear irq_data and free the parent
1404 * @domain:	Interrupt domain to match
1405 * @virq:	IRQ number to start with
1406 * @nr_irqs:	The number of irqs to free
1407 */
1408void irq_domain_free_irqs_common(struct irq_domain *domain, unsigned int virq,
1409				 unsigned int nr_irqs)
1410{
1411	struct irq_data *irq_data;
1412	int i;
1413
1414	for (i = 0; i < nr_irqs; i++) {
1415		irq_data = irq_domain_get_irq_data(domain, virq + i);
1416		if (irq_data)
1417			irq_domain_reset_irq_data(irq_data);
1418	}
1419	irq_domain_free_irqs_parent(domain, virq, nr_irqs);
1420}
1421EXPORT_SYMBOL_GPL(irq_domain_free_irqs_common);
1422
1423/**
1424 * irq_domain_free_irqs_top - Clear handler and handler data, clear irqdata and free parent
1425 * @domain:	Interrupt domain to match
1426 * @virq:	IRQ number to start with
1427 * @nr_irqs:	The number of irqs to free
1428 */
1429void irq_domain_free_irqs_top(struct irq_domain *domain, unsigned int virq,
1430			      unsigned int nr_irqs)
1431{
1432	int i;
1433
1434	for (i = 0; i < nr_irqs; i++) {
1435		irq_set_handler_data(virq + i, NULL);
1436		irq_set_handler(virq + i, NULL);
1437	}
1438	irq_domain_free_irqs_common(domain, virq, nr_irqs);
1439}
1440
1441static void irq_domain_free_irqs_hierarchy(struct irq_domain *domain,
1442					   unsigned int irq_base,
1443					   unsigned int nr_irqs)
1444{
1445	unsigned int i;
1446
1447	if (!domain->ops->free)
1448		return;
1449
1450	for (i = 0; i < nr_irqs; i++) {
1451		if (irq_domain_get_irq_data(domain, irq_base + i))
1452			domain->ops->free(domain, irq_base + i, 1);
1453	}
1454}
1455
1456int irq_domain_alloc_irqs_hierarchy(struct irq_domain *domain,
1457				    unsigned int irq_base,
1458				    unsigned int nr_irqs, void *arg)
1459{
1460	if (!domain->ops->alloc) {
1461		pr_debug("domain->ops->alloc() is NULL\n");
1462		return -ENOSYS;
1463	}
1464
1465	return domain->ops->alloc(domain, irq_base, nr_irqs, arg);
1466}
1467
1468static int irq_domain_alloc_irqs_locked(struct irq_domain *domain, int irq_base,
1469					unsigned int nr_irqs, int node, void *arg,
1470					bool realloc, const struct irq_affinity_desc *affinity)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1471{
1472	int i, ret, virq;
1473
 
 
 
 
 
 
1474	if (realloc && irq_base >= 0) {
1475		virq = irq_base;
1476	} else {
1477		virq = irq_domain_alloc_descs(irq_base, nr_irqs, 0, node,
1478					      affinity);
1479		if (virq < 0) {
1480			pr_debug("cannot allocate IRQ(base %d, count %d)\n",
1481				 irq_base, nr_irqs);
1482			return virq;
1483		}
1484	}
1485
1486	if (irq_domain_alloc_irq_data(domain, virq, nr_irqs)) {
1487		pr_debug("cannot allocate memory for IRQ%d\n", virq);
1488		ret = -ENOMEM;
1489		goto out_free_desc;
1490	}
1491
 
1492	ret = irq_domain_alloc_irqs_hierarchy(domain, virq, nr_irqs, arg);
1493	if (ret < 0)
 
1494		goto out_free_irq_data;
 
1495
1496	for (i = 0; i < nr_irqs; i++) {
1497		ret = irq_domain_trim_hierarchy(virq + i);
1498		if (ret)
 
1499			goto out_free_irq_data;
 
1500	}
1501
1502	for (i = 0; i < nr_irqs; i++)
1503		irq_domain_insert_irq(virq + i);
 
1504
1505	return virq;
1506
1507out_free_irq_data:
1508	irq_domain_free_irq_data(virq, nr_irqs);
1509out_free_desc:
1510	irq_free_descs(virq, nr_irqs);
1511	return ret;
1512}
1513
1514/**
1515 * __irq_domain_alloc_irqs - Allocate IRQs from domain
1516 * @domain:	domain to allocate from
1517 * @irq_base:	allocate specified IRQ number if irq_base >= 0
1518 * @nr_irqs:	number of IRQs to allocate
1519 * @node:	NUMA node id for memory allocation
1520 * @arg:	domain specific argument
1521 * @realloc:	IRQ descriptors have already been allocated if true
1522 * @affinity:	Optional irq affinity mask for multiqueue devices
1523 *
1524 * Allocate IRQ numbers and initialized all data structures to support
1525 * hierarchy IRQ domains.
1526 * Parameter @realloc is mainly to support legacy IRQs.
1527 * Returns error code or allocated IRQ number
1528 *
1529 * The whole process to setup an IRQ has been split into two steps.
1530 * The first step, __irq_domain_alloc_irqs(), is to allocate IRQ
1531 * descriptor and required hardware resources. The second step,
1532 * irq_domain_activate_irq(), is to program the hardware with preallocated
1533 * resources. In this way, it's easier to rollback when failing to
1534 * allocate resources.
1535 */
1536int __irq_domain_alloc_irqs(struct irq_domain *domain, int irq_base,
1537			    unsigned int nr_irqs, int node, void *arg,
1538			    bool realloc, const struct irq_affinity_desc *affinity)
1539{
1540	int ret;
1541
1542	if (domain == NULL) {
1543		domain = irq_default_domain;
1544		if (WARN(!domain, "domain is NULL; cannot allocate IRQ\n"))
1545			return -EINVAL;
1546	}
1547
1548	mutex_lock(&domain->root->mutex);
1549	ret = irq_domain_alloc_irqs_locked(domain, irq_base, nr_irqs, node, arg,
1550					   realloc, affinity);
1551	mutex_unlock(&domain->root->mutex);
1552
1553	return ret;
1554}
1555EXPORT_SYMBOL_GPL(__irq_domain_alloc_irqs);
1556
1557/* The irq_data was moved, fix the revmap to refer to the new location */
1558static void irq_domain_fix_revmap(struct irq_data *d)
1559{
1560	void __rcu **slot;
1561
1562	lockdep_assert_held(&d->domain->root->mutex);
1563
1564	if (irq_domain_is_nomap(d->domain))
1565		return;
1566
1567	/* Fix up the revmap. */
 
1568	if (d->hwirq < d->domain->revmap_size) {
1569		/* Not using radix tree */
1570		rcu_assign_pointer(d->domain->revmap[d->hwirq], d);
1571	} else {
1572		slot = radix_tree_lookup_slot(&d->domain->revmap_tree, d->hwirq);
1573		if (slot)
1574			radix_tree_replace_slot(&d->domain->revmap_tree, slot, d);
1575	}
 
1576}
1577
1578/**
1579 * irq_domain_push_irq() - Push a domain in to the top of a hierarchy.
1580 * @domain:	Domain to push.
1581 * @virq:	Irq to push the domain in to.
1582 * @arg:	Passed to the irq_domain_ops alloc() function.
1583 *
1584 * For an already existing irqdomain hierarchy, as might be obtained
1585 * via a call to pci_enable_msix(), add an additional domain to the
1586 * head of the processing chain.  Must be called before request_irq()
1587 * has been called.
1588 */
1589int irq_domain_push_irq(struct irq_domain *domain, int virq, void *arg)
1590{
1591	struct irq_data *irq_data = irq_get_irq_data(virq);
1592	struct irq_data *parent_irq_data;
1593	struct irq_desc *desc;
1594	int rv = 0;
1595
1596	/*
1597	 * Check that no action has been set, which indicates the virq
1598	 * is in a state where this function doesn't have to deal with
1599	 * races between interrupt handling and maintaining the
1600	 * hierarchy.  This will catch gross misuse.  Attempting to
1601	 * make the check race free would require holding locks across
1602	 * calls to struct irq_domain_ops->alloc(), which could lead
1603	 * to deadlock, so we just do a simple check before starting.
1604	 */
1605	desc = irq_to_desc(virq);
1606	if (!desc)
1607		return -EINVAL;
1608	if (WARN_ON(desc->action))
1609		return -EBUSY;
1610
1611	if (domain == NULL)
1612		return -EINVAL;
1613
1614	if (WARN_ON(!irq_domain_is_hierarchy(domain)))
1615		return -EINVAL;
1616
1617	if (!irq_data)
1618		return -EINVAL;
1619
1620	if (domain->parent != irq_data->domain)
1621		return -EINVAL;
1622
1623	parent_irq_data = kzalloc_node(sizeof(*parent_irq_data), GFP_KERNEL,
1624				       irq_data_get_node(irq_data));
1625	if (!parent_irq_data)
1626		return -ENOMEM;
1627
1628	mutex_lock(&domain->root->mutex);
1629
1630	/* Copy the original irq_data. */
1631	*parent_irq_data = *irq_data;
1632
1633	/*
1634	 * Overwrite the irq_data, which is embedded in struct irq_desc, with
1635	 * values for this domain.
1636	 */
1637	irq_data->parent_data = parent_irq_data;
1638	irq_data->domain = domain;
1639	irq_data->mask = 0;
1640	irq_data->hwirq = 0;
1641	irq_data->chip = NULL;
1642	irq_data->chip_data = NULL;
1643
1644	/* May (probably does) set hwirq, chip, etc. */
1645	rv = irq_domain_alloc_irqs_hierarchy(domain, virq, 1, arg);
1646	if (rv) {
1647		/* Restore the original irq_data. */
1648		*irq_data = *parent_irq_data;
1649		kfree(parent_irq_data);
1650		goto error;
1651	}
1652
1653	irq_domain_fix_revmap(parent_irq_data);
1654	irq_domain_set_mapping(domain, irq_data->hwirq, irq_data);
 
1655error:
1656	mutex_unlock(&domain->root->mutex);
1657
1658	return rv;
1659}
1660EXPORT_SYMBOL_GPL(irq_domain_push_irq);
1661
1662/**
1663 * irq_domain_pop_irq() - Remove a domain from the top of a hierarchy.
1664 * @domain:	Domain to remove.
1665 * @virq:	Irq to remove the domain from.
1666 *
1667 * Undo the effects of a call to irq_domain_push_irq().  Must be
1668 * called either before request_irq() or after free_irq().
1669 */
1670int irq_domain_pop_irq(struct irq_domain *domain, int virq)
1671{
1672	struct irq_data *irq_data = irq_get_irq_data(virq);
1673	struct irq_data *parent_irq_data;
1674	struct irq_data *tmp_irq_data;
1675	struct irq_desc *desc;
1676
1677	/*
1678	 * Check that no action is set, which indicates the virq is in
1679	 * a state where this function doesn't have to deal with races
1680	 * between interrupt handling and maintaining the hierarchy.
1681	 * This will catch gross misuse.  Attempting to make the check
1682	 * race free would require holding locks across calls to
1683	 * struct irq_domain_ops->free(), which could lead to
1684	 * deadlock, so we just do a simple check before starting.
1685	 */
1686	desc = irq_to_desc(virq);
1687	if (!desc)
1688		return -EINVAL;
1689	if (WARN_ON(desc->action))
1690		return -EBUSY;
1691
1692	if (domain == NULL)
1693		return -EINVAL;
1694
1695	if (!irq_data)
1696		return -EINVAL;
1697
1698	tmp_irq_data = irq_domain_get_irq_data(domain, virq);
1699
1700	/* We can only "pop" if this domain is at the top of the list */
1701	if (WARN_ON(irq_data != tmp_irq_data))
1702		return -EINVAL;
1703
1704	if (WARN_ON(irq_data->domain != domain))
1705		return -EINVAL;
1706
1707	parent_irq_data = irq_data->parent_data;
1708	if (WARN_ON(!parent_irq_data))
1709		return -EINVAL;
1710
1711	mutex_lock(&domain->root->mutex);
1712
1713	irq_data->parent_data = NULL;
1714
1715	irq_domain_clear_mapping(domain, irq_data->hwirq);
1716	irq_domain_free_irqs_hierarchy(domain, virq, 1);
1717
1718	/* Restore the original irq_data. */
1719	*irq_data = *parent_irq_data;
1720
1721	irq_domain_fix_revmap(irq_data);
1722
1723	mutex_unlock(&domain->root->mutex);
1724
1725	kfree(parent_irq_data);
1726
1727	return 0;
1728}
1729EXPORT_SYMBOL_GPL(irq_domain_pop_irq);
1730
1731/**
1732 * irq_domain_free_irqs - Free IRQ number and associated data structures
1733 * @virq:	base IRQ number
1734 * @nr_irqs:	number of IRQs to free
1735 */
1736void irq_domain_free_irqs(unsigned int virq, unsigned int nr_irqs)
1737{
1738	struct irq_data *data = irq_get_irq_data(virq);
1739	struct irq_domain *domain;
1740	int i;
1741
1742	if (WARN(!data || !data->domain || !data->domain->ops->free,
1743		 "NULL pointer, cannot free irq\n"))
1744		return;
1745
1746	domain = data->domain;
1747
1748	mutex_lock(&domain->root->mutex);
1749	for (i = 0; i < nr_irqs; i++)
1750		irq_domain_remove_irq(virq + i);
1751	irq_domain_free_irqs_hierarchy(domain, virq, nr_irqs);
1752	mutex_unlock(&domain->root->mutex);
1753
1754	irq_domain_free_irq_data(virq, nr_irqs);
1755	irq_free_descs(virq, nr_irqs);
1756}
1757
1758/**
1759 * irq_domain_alloc_irqs_parent - Allocate interrupts from parent domain
1760 * @domain:	Domain below which interrupts must be allocated
1761 * @irq_base:	Base IRQ number
1762 * @nr_irqs:	Number of IRQs to allocate
1763 * @arg:	Allocation data (arch/domain specific)
1764 */
1765int irq_domain_alloc_irqs_parent(struct irq_domain *domain,
1766				 unsigned int irq_base, unsigned int nr_irqs,
1767				 void *arg)
1768{
1769	if (!domain->parent)
1770		return -ENOSYS;
1771
1772	return irq_domain_alloc_irqs_hierarchy(domain->parent, irq_base,
1773					       nr_irqs, arg);
1774}
1775EXPORT_SYMBOL_GPL(irq_domain_alloc_irqs_parent);
1776
1777/**
1778 * irq_domain_free_irqs_parent - Free interrupts from parent domain
1779 * @domain:	Domain below which interrupts must be freed
1780 * @irq_base:	Base IRQ number
1781 * @nr_irqs:	Number of IRQs to free
1782 */
1783void irq_domain_free_irqs_parent(struct irq_domain *domain,
1784				 unsigned int irq_base, unsigned int nr_irqs)
1785{
1786	if (!domain->parent)
1787		return;
1788
1789	irq_domain_free_irqs_hierarchy(domain->parent, irq_base, nr_irqs);
1790}
1791EXPORT_SYMBOL_GPL(irq_domain_free_irqs_parent);
1792
1793static void __irq_domain_deactivate_irq(struct irq_data *irq_data)
1794{
1795	if (irq_data && irq_data->domain) {
1796		struct irq_domain *domain = irq_data->domain;
1797
1798		if (domain->ops->deactivate)
1799			domain->ops->deactivate(domain, irq_data);
1800		if (irq_data->parent_data)
1801			__irq_domain_deactivate_irq(irq_data->parent_data);
1802	}
1803}
1804
1805static int __irq_domain_activate_irq(struct irq_data *irqd, bool reserve)
1806{
1807	int ret = 0;
1808
1809	if (irqd && irqd->domain) {
1810		struct irq_domain *domain = irqd->domain;
1811
1812		if (irqd->parent_data)
1813			ret = __irq_domain_activate_irq(irqd->parent_data,
1814							reserve);
1815		if (!ret && domain->ops->activate) {
1816			ret = domain->ops->activate(domain, irqd, reserve);
1817			/* Rollback in case of error */
1818			if (ret && irqd->parent_data)
1819				__irq_domain_deactivate_irq(irqd->parent_data);
1820		}
1821	}
1822	return ret;
1823}
1824
1825/**
1826 * irq_domain_activate_irq - Call domain_ops->activate recursively to activate
1827 *			     interrupt
1828 * @irq_data:	Outermost irq_data associated with interrupt
1829 * @reserve:	If set only reserve an interrupt vector instead of assigning one
1830 *
1831 * This is the second step to call domain_ops->activate to program interrupt
1832 * controllers, so the interrupt could actually get delivered.
1833 */
1834int irq_domain_activate_irq(struct irq_data *irq_data, bool reserve)
1835{
1836	int ret = 0;
1837
1838	if (!irqd_is_activated(irq_data))
1839		ret = __irq_domain_activate_irq(irq_data, reserve);
1840	if (!ret)
1841		irqd_set_activated(irq_data);
1842	return ret;
1843}
1844
1845/**
1846 * irq_domain_deactivate_irq - Call domain_ops->deactivate recursively to
1847 *			       deactivate interrupt
1848 * @irq_data: outermost irq_data associated with interrupt
1849 *
1850 * It calls domain_ops->deactivate to program interrupt controllers to disable
1851 * interrupt delivery.
1852 */
1853void irq_domain_deactivate_irq(struct irq_data *irq_data)
1854{
1855	if (irqd_is_activated(irq_data)) {
1856		__irq_domain_deactivate_irq(irq_data);
1857		irqd_clr_activated(irq_data);
1858	}
1859}
1860
1861static void irq_domain_check_hierarchy(struct irq_domain *domain)
1862{
1863	/* Hierarchy irq_domains must implement callback alloc() */
1864	if (domain->ops->alloc)
1865		domain->flags |= IRQ_DOMAIN_FLAG_HIERARCHY;
1866}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1867#else	/* CONFIG_IRQ_DOMAIN_HIERARCHY */
1868/**
1869 * irq_domain_get_irq_data - Get irq_data associated with @virq and @domain
1870 * @domain:	domain to match
1871 * @virq:	IRQ number to get irq_data
1872 */
1873struct irq_data *irq_domain_get_irq_data(struct irq_domain *domain,
1874					 unsigned int virq)
1875{
1876	struct irq_data *irq_data = irq_get_irq_data(virq);
1877
1878	return (irq_data && irq_data->domain == domain) ? irq_data : NULL;
1879}
1880EXPORT_SYMBOL_GPL(irq_domain_get_irq_data);
1881
1882/**
1883 * irq_domain_set_info - Set the complete data for a @virq in @domain
1884 * @domain:		Interrupt domain to match
1885 * @virq:		IRQ number
1886 * @hwirq:		The hardware interrupt number
1887 * @chip:		The associated interrupt chip
1888 * @chip_data:		The associated interrupt chip data
1889 * @handler:		The interrupt flow handler
1890 * @handler_data:	The interrupt flow handler data
1891 * @handler_name:	The interrupt handler name
1892 */
1893void irq_domain_set_info(struct irq_domain *domain, unsigned int virq,
1894			 irq_hw_number_t hwirq, const struct irq_chip *chip,
1895			 void *chip_data, irq_flow_handler_t handler,
1896			 void *handler_data, const char *handler_name)
1897{
1898	irq_set_chip_and_handler_name(virq, chip, handler, handler_name);
1899	irq_set_chip_data(virq, chip_data);
1900	irq_set_handler_data(virq, handler_data);
1901}
1902
1903static int irq_domain_alloc_irqs_locked(struct irq_domain *domain, int irq_base,
1904					unsigned int nr_irqs, int node, void *arg,
1905					bool realloc, const struct irq_affinity_desc *affinity)
1906{
1907	return -EINVAL;
1908}
1909
1910static void irq_domain_check_hierarchy(struct irq_domain *domain)
1911{
1912}
1913#endif	/* CONFIG_IRQ_DOMAIN_HIERARCHY */
1914
1915#ifdef CONFIG_GENERIC_IRQ_DEBUGFS
1916#include "internals.h"
1917
1918static struct dentry *domain_dir;
1919
1920static void
1921irq_domain_debug_show_one(struct seq_file *m, struct irq_domain *d, int ind)
1922{
1923	seq_printf(m, "%*sname:   %s\n", ind, "", d->name);
1924	seq_printf(m, "%*ssize:   %u\n", ind + 1, "", d->revmap_size);
1925	seq_printf(m, "%*smapped: %u\n", ind + 1, "", d->mapcount);
1926	seq_printf(m, "%*sflags:  0x%08x\n", ind +1 , "", d->flags);
1927	if (d->ops && d->ops->debug_show)
1928		d->ops->debug_show(m, d, NULL, ind + 1);
1929#ifdef	CONFIG_IRQ_DOMAIN_HIERARCHY
1930	if (!d->parent)
1931		return;
1932	seq_printf(m, "%*sparent: %s\n", ind + 1, "", d->parent->name);
1933	irq_domain_debug_show_one(m, d->parent, ind + 4);
1934#endif
1935}
1936
1937static int irq_domain_debug_show(struct seq_file *m, void *p)
1938{
1939	struct irq_domain *d = m->private;
1940
1941	/* Default domain? Might be NULL */
1942	if (!d) {
1943		if (!irq_default_domain)
1944			return 0;
1945		d = irq_default_domain;
1946	}
1947	irq_domain_debug_show_one(m, d, 0);
1948	return 0;
1949}
1950DEFINE_SHOW_ATTRIBUTE(irq_domain_debug);
1951
1952static void debugfs_add_domain_dir(struct irq_domain *d)
1953{
1954	if (!d->name || !domain_dir)
1955		return;
1956	debugfs_create_file(d->name, 0444, domain_dir, d,
1957			    &irq_domain_debug_fops);
1958}
1959
1960static void debugfs_remove_domain_dir(struct irq_domain *d)
1961{
1962	debugfs_lookup_and_remove(d->name, domain_dir);
1963}
1964
1965void __init irq_domain_debugfs_init(struct dentry *root)
1966{
1967	struct irq_domain *d;
1968
1969	domain_dir = debugfs_create_dir("domains", root);
1970
1971	debugfs_create_file("default", 0444, domain_dir, NULL,
1972			    &irq_domain_debug_fops);
1973	mutex_lock(&irq_domain_mutex);
1974	list_for_each_entry(d, &irq_domain_list, link)
1975		debugfs_add_domain_dir(d);
1976	mutex_unlock(&irq_domain_mutex);
1977}
1978#endif