litmus-rt.git - The LITMUS^RT kernel.

diff options

author	Linus Torvalds <torvalds@linux-foundation.org>	2015-02-21 16:40:41 -0500
committer	Linus Torvalds <torvalds@linux-foundation.org>	2015-02-21 16:40:41 -0500
commit	cd50b70ccd5c87794ec28bfb87b7fba9961eb0ae (patch)
tree	3714f7d57ebe3e07f56cd4b4f389a404b716ca37 /scripts/gdb/vmlinux-gdb.py
parent	2bfedd1d9f470506d98cb5662ced381c38225968 (diff)
parent	3466b547e37b988723dc93465b7cb06b4b1f731f (diff)

Merge tag 'pm+acpi-3.20-rc1-3' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm

Pull one more batch of power management and ACPI updates from Rafael Wysocki: "These are mostly fixes on top of the previously merged recent PM and ACPI material. First, one commit that broke the ACPI LPSS (Low-Power Subsystem) driver on a Dell box is reverted and there are two stable-candidate fixes for that driver. Another fix cleans up two recently added ACPI EC messages that look odd and the printk level of a noisy debug message in the core ACPI resources handling code is reduced. In addition to that we have two stable-candidate fixes for the s3c cpufreq driver, two cpuidle powernv driver updates related to Device Trees and a PNP subsystem cleanup that will allow us to get rid of some old ugliness going forward. Also there is a new blacklist entry for the ACPI backlight code. Specifics: - Revert a recent ACPI LPSS driver commit that prevented the touchpad driver from loading on Dell XPS13 (Jarkko Nikula). - Make the ACPI LPSS driver disable the I2C controllers and deassert SPI host controllers resets at startup on Intel BayTrail and Braswell SoCs in case they have been left in wrong states by the platform firmware which then may casuse fatal controller driver failures during resume from hibernation (Mika Westerberg). - Make two recently added ACPI EC messages look better (Scot Doyle). - Reduce the printk level of a recently added debug message related to ACPI resources that may become noisy in some cases (Rafael J Wysocki). - Add a new ACPI backlight blacklist entry for Samsung Series 9 (900X3C/900X3D/900X3E/900X4C/900X4D) laptops where the native backlight interface doesn't work while the ACPI based one does (Jens Reyer). - Make the PNP sybsystem's core code use __request_region() followed by __release_region() instead of __check_region() which then will allow us to get rid of the latter as it has no more users (Jakub Sitnicki). - Fix a build breakage and an issue with two __init functions that may be called after initialization in the s3c cpufreq driver (Arnd Bergmann). - Make the powernv cpuidle driver read target_residency values for idle states from a Device Tree (as we have the suitable DT bindings for that now) and improve the parsing of the powermgmt DT node in that driver (Preeti U Murthy)" * tag 'pm+acpi-3.20-rc1-3' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm: cpuidle: powernv: Avoid endianness conversions while parsing DT cpufreq: s3c: remove last use of resume_clocks callback cpufreq: s3c: remove incorrect __init annotations ACPI / LPSS: Deassert resets for SPI host controllers on Braswell ACPI / LPSS: Always disable I2C host controllers ACPI / resources: Change pr_info() to pr_debug() for debug information ACPI / video: Disable native backlight on Samsung Series 9 laptops cpuidle: powernv: Read target_residency value of idle states from DT if available Revert "ACPI / LPSS: Remove non-existing clock control from Intel Lynxpoint I2C" ACPI / EC: Remove non-standard log emphasis PNP: Switch from __check_region() to __request_region()

Diffstat (limited to 'scripts/gdb/vmlinux-gdb.py')

0 files changed, 0 insertions, 0 deletions

/* * Copyright (c) 2006, Intel Corporation. * * This file is released under the GPLv2. * * Copyright (C) 2006-2008 Intel Corporation * Author: Anil S Keshavamurthy <anil.s.keshavamurthy@intel.com> */ #include "iova.h" void init_iova_domain(struct iova_domain *iovad, unsigned long pfn_32bit) { spin_lock_init(&iovad->iova_alloc_lock); spin_lock_init(&iovad->iova_rbtree_lock); iovad->rbroot = RB_ROOT; iovad->cached32_node = NULL; iovad->dma_32bit_pfn = pfn_32bit; } static struct rb_node * __get_cached_rbnode(struct iova_domain *iovad, unsigned long *limit_pfn) { if ((*limit_pfn != iovad->dma_32bit_pfn) || (iovad->cached32_node == NULL)) return rb_last(&iovad->rbroot); else { struct rb_node *prev_node = rb_prev(iovad->cached32_node); struct iova *curr_iova = container_of(iovad->cached32_node, struct iova, node); *limit_pfn = curr_iova->pfn_lo - 1; return prev_node; } } static void __cached_rbnode_insert_update(struct iova_domain *iovad, unsigned long limit_pfn, struct iova *new) { if (limit_pfn != iovad->dma_32bit_pfn) return; iovad->cached32_node = &new->node; } static void __cached_rbnode_delete_update(struct iova_domain *iovad, struct iova *free) { struct iova *cached_iova; struct rb_node *curr; if (!iovad->cached32_node) return; curr = iovad->cached32_node; cached_iova = container_of(curr, struct iova, node); if (free->pfn_lo >= cached_iova->pfn_lo) iovad->cached32_node = rb_next(&free->node); } /* Computes the padding size required, to make the * the start address naturally aligned on its size */ static int iova_get_pad_size(int size, unsigned int limit_pfn) { unsigned int pad_size = 0; unsigned int order = ilog2(size); if (order) pad_size = (limit_pfn + 1) % (1 << order); return pad_size; } static int __alloc_and_insert_iova_range(struct iova_domain *iovad, unsigned long size, unsigned long limit_pfn, struct iova *new, bool size_aligned) { struct rb_node *prev, *curr = NULL; unsigned long flags; unsigned long saved_pfn; unsigned int pad_size = 0; /* Walk the tree backwards */ spin_lock_irqsave(&iovad->iova_rbtree_lock, flags); saved_pfn = limit_pfn; curr = __get_cached_rbnode(iovad, &limit_pfn); prev = curr; while (curr) { struct iova *curr_iova = container_of(curr, struct iova, node); if (limit_pfn < curr_iova->pfn_lo) goto move_left; else if (limit_pfn < curr_iova->pfn_hi) goto adjust_limit_pfn; else { if (size_aligned) pad_size = iova_get_pad_size(size, limit_pfn); if ((curr_iova->pfn_hi + size + pad_size) <= limit_pfn) break; /* found a free slot */ } adjust_limit_pfn: limit_pfn = curr_iova->pfn_lo - 1; move_left: prev = curr; curr = rb_prev(curr); } if (!curr) { if (size_aligned) pad_size = iova_get_pad_size(size, limit_pfn); if ((IOVA_START_PFN + size + pad_size) > limit_pfn) { spin_unlock_irqrestore(&iovad->iova_rbtree_lock, flags); return -ENOMEM; } } /* pfn_lo will point to size aligned address if size_aligned is set */ new->pfn_lo = limit_pfn - (size + pad_size) + 1; new->pfn_hi = new->pfn_lo + size - 1; /* Insert the new_iova into domain rbtree by holding writer lock */ /* Add new node and rebalance tree. */ { struct rb_node **entry = &((prev)), *parent = NULL; /* Figure out where to put new node */ while (*entry) { struct iova *this = container_of(*entry, struct iova, node); parent = *entry; if (new->pfn_lo < this->pfn_lo) entry = &((*entry)->rb_left); else if (new->pfn_lo > this->pfn_lo) entry = &((*entry)->rb_right); else BUG(); /* this should not happen */ } /* Add new node and rebalance tree. */ rb_link_node(&new->node, parent, entry); rb_insert_color(&new->node, &iovad->rbroot); } __cached_rbnode_insert_update(iovad, saved_pfn, new); spin_unlock_irqrestore(&iovad->iova_rbtree_lock, flags); return 0; } static void iova_insert_rbtree(struct rb_root *root, struct iova *iova) { struct rb_node **new = &(root->rb_node), *parent = NULL; /* Figure out where to put new node */ while (*new) { struct iova *this = container_of(*new, struct iova, node); parent = *new; if (iova->pfn_lo < this->pfn_lo) new = &((*new)->rb_left); else if (iova->pfn_lo > this->pfn_lo) new = &((*new)->rb_right); else BUG(); /* this should not happen */ } /* Add new node and rebalance tree. */ rb_link_node(&iova->node, parent, new); rb_insert_color(&iova->node, root); } /** * alloc_iova - allocates an iova * @iovad - iova domain in question * @size - size of page frames to allocate * @limit_pfn - max limit address * @size_aligned - set if size_aligned address range is required * This function allocates an iova in the range limit_pfn to IOVA_START_PFN * looking from limit_pfn instead from IOVA_START_PFN. If the size_aligned * flag is set then the allocated address iova->pfn_lo will be naturally * aligned on roundup_power_of_two(size). */ struct iova * alloc_iova(struct iova_domain *iovad, unsigned long size, unsigned long limit_pfn, bool size_aligned) { unsigned long flags; struct iova *new_iova; int ret; new_iova = alloc_iova_mem(); if (!new_iova) return NULL; /* If size aligned is set then round the size to * to next power of two. */ if (size_aligned) size = __roundup_pow_of_two(size); spin_lock_irqsave(&iovad->iova_alloc_lock, flags); ret = __alloc_and_insert_iova_range(iovad, size, limit_pfn, new_iova, size_aligned); spin_unlock_irqrestore(&iovad->iova_alloc_lock, flags); if (ret) { free_iova_mem(new_iova); return NULL; } return new_iova; } /** * find_iova - find's an iova for a given pfn * @iovad - iova domain in question. * pfn - page frame number * This function finds and returns an iova belonging to the * given doamin which matches the given pfn. */ struct iova *find_iova(struct iova_domain *iovad, unsigned long pfn) { unsigned long flags; struct rb_node *node; /* Take the lock so that no other thread is manipulating the rbtree */ spin_lock_irqsave(&iovad->iova_rbtree_lock, flags); node = iovad->rbroot.rb_node; while (node) { struct iova *iova = container_of(node, struct iova, node); /* If pfn falls within iova's range, return iova */ if ((pfn >= iova->pfn_lo) && (pfn <= iova->pfn_hi)) { spin_unlock_irqrestore(&iovad->iova_rbtree_lock, flags); /* We are not holding the lock while this iova * is referenced by the caller as the same thread * which called this function also calls __free_iova() * and it is by desing that only one thread can possibly * reference a particular iova and hence no conflict. */ return iova; } if (pfn < iova->pfn_lo) node = node->rb_left; else if (pfn > iova->pfn_lo) node = node->rb_right; } spin_unlock_irqrestore(&iovad->iova_rbtree_lock, flags); return NULL; } /** * __free_iova - frees the given iova * @iovad: iova domain in question. * @iova: iova in question. * Frees the given iova belonging to the giving domain */ void __free_iova(struct iova_domain *iovad, struct iova *iova) { unsigned long flags; spin_lock_irqsave(&iovad->iova_rbtree_lock, flags); __cached_rbnode_delete_update(iovad, iova); rb_erase(&iova->node, &iovad->rbroot); spin_unlock_irqrestore(&iovad->iova_rbtree_lock, flags); free_iova_mem(iova); } /** * free_iova - finds and frees the iova for a given pfn * @iovad: - iova domain in question. * @pfn: - pfn that is allocated previously * This functions finds an iova for a given pfn and then * frees the iova from that domain. */ void free_iova(struct iova_domain *iovad, unsigned long pfn) { struct iova *iova = find_iova(iovad, pfn); if (iova) __free_iova(iovad, iova); } /** * put_iova_domain - destroys the iova doamin * @iovad: - iova domain in question. * All the iova's in that domain are destroyed. */ void put_iova_domain(struct iova_domain *iovad) { struct rb_node *node; unsigned long flags; spin_lock_irqsave(&iovad->iova_rbtree_lock, flags); node = rb_first(&iovad->rbroot); while (node) { struct iova *iova = container_of(node, struct iova, node); rb_erase(node, &iovad->rbroot); free_iova_mem(iova); node = rb_first(&iovad->rbroot); } spin_unlock_irqrestore(&iovad->iova_rbtree_lock, flags); } static int __is_range_overlap(struct rb_node *node, unsigned long pfn_lo, unsigned long pfn_hi) {


context:
space:
mode: