LXR linux/arch/powerpc/sysdev/msi

   1/*
   2 * Copyright 2006-2008, Michael Ellerman, IBM Corporation.
   3 *
   4 * This program is free software; you can redistribute it and/or
   5 * modify it under the terms of the GNU General Public License
   6 * as published by the Free Software Foundation; version 2 of the
   7 * License.
   8 *
   9 */
  10
  11#include <linux/slab.h>
  12#include <linux/kernel.h>
  13#include <linux/bitmap.h>
  14#include <linux/bootmem.h>
  15#include <asm/msi_bitmap.h>
  16#include <asm/setup.h>
  17
  18int msi_bitmap_alloc_hwirqs(struct msi_bitmap *bmp, int num)
  19{
  20        unsigned long flags;
  21        int offset, order = get_count_order(num);
  22
  23        spin_lock_irqsave(&bmp->lock, flags);
  24
  25        offset = bitmap_find_next_zero_area(bmp->bitmap, bmp->irq_count, 0,
  26                                            num, (1 << order) - 1);
  27        if (offset > bmp->irq_count)
  28                goto err;
  29
  30        bitmap_set(bmp->bitmap, offset, num);
  31        spin_unlock_irqrestore(&bmp->lock, flags);
  32
  33        pr_debug("msi_bitmap: allocated 0x%x at offset 0x%x\n", num, offset);
  34
  35        return offset;
  36err:
  37        spin_unlock_irqrestore(&bmp->lock, flags);
  38        return -ENOMEM;
  39}
  40EXPORT_SYMBOL(msi_bitmap_alloc_hwirqs);
  41
  42void msi_bitmap_free_hwirqs(struct msi_bitmap *bmp, unsigned int offset,
  43                            unsigned int num)
  44{
  45        unsigned long flags;
  46
  47        pr_debug("msi_bitmap: freeing 0x%x at offset 0x%x\n",
  48                 num, offset);
  49
  50        spin_lock_irqsave(&bmp->lock, flags);
  51        bitmap_clear(bmp->bitmap, offset, num);
  52        spin_unlock_irqrestore(&bmp->lock, flags);
  53}
  54EXPORT_SYMBOL(msi_bitmap_free_hwirqs);
  55
  56void msi_bitmap_reserve_hwirq(struct msi_bitmap *bmp, unsigned int hwirq)
  57{
  58        unsigned long flags;
  59
  60        pr_debug("msi_bitmap: reserving hwirq 0x%x\n", hwirq);
  61
  62        spin_lock_irqsave(&bmp->lock, flags);
  63        bitmap_allocate_region(bmp->bitmap, hwirq, 0);
  64        spin_unlock_irqrestore(&bmp->lock, flags);
  65}
  66
  67/**
  68 * msi_bitmap_reserve_dt_hwirqs - Reserve irqs specified in the device tree.
  69 * @bmp: pointer to the MSI bitmap.
  70 *
  71 * Looks in the device tree to see if there is a property specifying which
  72 * irqs can be used for MSI. If found those irqs reserved in the device tree
  73 * are reserved in the bitmap.
  74 *
  75 * Returns 0 for success, < 0 if there was an error, and > 0 if no property
  76 * was found in the device tree.
  77 **/
  78int msi_bitmap_reserve_dt_hwirqs(struct msi_bitmap *bmp)
  79{
  80        int i, j, len;
  81        const u32 *p;
  82
  83        if (!bmp->of_node)
  84                return 1;
  85
  86        p = of_get_property(bmp->of_node, "msi-available-ranges", &len);
  87        if (!p) {
  88                pr_debug("msi_bitmap: no msi-available-ranges property " \
  89                         "found on %s\n", bmp->of_node->full_name);
  90                return 1;
  91        }
  92
  93        if (len % (2 * sizeof(u32)) != 0) {
  94                printk(KERN_WARNING "msi_bitmap: Malformed msi-available-ranges"
  95                       " property on %s\n", bmp->of_node->full_name);
  96                return -EINVAL;
  97        }
  98
  99        bitmap_allocate_region(bmp->bitmap, 0, get_count_order(bmp->irq_count));
 100
 101        spin_lock(&bmp->lock);
 102
 103        /* Format is: (<u32 start> <u32 count>)+ */
 104        len /= 2 * sizeof(u32);
 105        for (i = 0; i < len; i++, p += 2) {
 106                for (j = 0; j < *(p + 1); j++)
 107                        bitmap_release_region(bmp->bitmap, *p + j, 0);
 108        }
 109
 110        spin_unlock(&bmp->lock);
 111
 112        return 0;
 113}
 114
 115int __init_refok msi_bitmap_alloc(struct msi_bitmap *bmp, unsigned int irq_count,
 116                     struct device_node *of_node)
 117{
 118        int size;
 119
 120        if (!irq_count)
 121                return -EINVAL;
 122
 123        size = BITS_TO_LONGS(irq_count) * sizeof(long);
 124        pr_debug("msi_bitmap: allocator bitmap size is 0x%x bytes\n", size);
 125
 126        bmp->bitmap_from_slab = slab_is_available();
 127        if (bmp->bitmap_from_slab)
 128                bmp->bitmap = kzalloc(size, GFP_KERNEL);
 129        else {
 130                bmp->bitmap = memblock_virt_alloc(size, 0);
 131                /* the bitmap won't be freed from memblock allocator */
 132                kmemleak_not_leak(bmp->bitmap);
 133        }
 134
 135        if (!bmp->bitmap) {
 136                pr_debug("msi_bitmap: ENOMEM allocating allocator bitmap!\n");
 137                return -ENOMEM;
 138        }
 139
 140        /* We zalloc'ed the bitmap, so all irqs are free by default */
 141        spin_lock_init(&bmp->lock);
 142        bmp->of_node = of_node_get(of_node);
 143        bmp->irq_count = irq_count;
 144
 145        return 0;
 146}
 147
 148void msi_bitmap_free(struct msi_bitmap *bmp)
 149{
 150        if (bmp->bitmap_from_slab)
 151                kfree(bmp->bitmap);
 152        of_node_put(bmp->of_node);
 153        bmp->bitmap = NULL;
 154}
 155
 156#ifdef CONFIG_MSI_BITMAP_SELFTEST
 157
 158static void __init test_basics(void)
 159{
 160        struct msi_bitmap bmp;
 161        int rc, i, size = 512;
 162
 163        /* Can't allocate a bitmap of 0 irqs */
 164        WARN_ON(msi_bitmap_alloc(&bmp, 0, NULL) == 0);
 165
 166        /* of_node may be NULL */
 167        WARN_ON(msi_bitmap_alloc(&bmp, size, NULL));
 168
 169        /* Should all be free by default */
 170        WARN_ON(bitmap_find_free_region(bmp.bitmap, size, get_count_order(size)));
 171        bitmap_release_region(bmp.bitmap, 0, get_count_order(size));
 172
 173        /* With no node, there's no msi-available-ranges, so expect > 0 */
 174        WARN_ON(msi_bitmap_reserve_dt_hwirqs(&bmp) <= 0);
 175
 176        /* Should all still be free */
 177        WARN_ON(bitmap_find_free_region(bmp.bitmap, size, get_count_order(size)));
 178        bitmap_release_region(bmp.bitmap, 0, get_count_order(size));
 179
 180        /* Check we can fill it up and then no more */
 181        for (i = 0; i < size; i++)
 182                WARN_ON(msi_bitmap_alloc_hwirqs(&bmp, 1) < 0);
 183
 184        WARN_ON(msi_bitmap_alloc_hwirqs(&bmp, 1) >= 0);
 185
 186        /* Should all be allocated */
 187        WARN_ON(bitmap_find_free_region(bmp.bitmap, size, 0) >= 0);
 188
 189        /* And if we free one we can then allocate another */
 190        msi_bitmap_free_hwirqs(&bmp, size / 2, 1);
 191        WARN_ON(msi_bitmap_alloc_hwirqs(&bmp, 1) != size / 2);
 192
 193        /* Free most of them for the alignment tests */
 194        msi_bitmap_free_hwirqs(&bmp, 3, size - 3);
 195
 196        /* Check we get a naturally aligned offset */
 197        rc = msi_bitmap_alloc_hwirqs(&bmp, 2);
 198        WARN_ON(rc < 0 && rc % 2 != 0);
 199        rc = msi_bitmap_alloc_hwirqs(&bmp, 4);
 200        WARN_ON(rc < 0 && rc % 4 != 0);
 201        rc = msi_bitmap_alloc_hwirqs(&bmp, 8);
 202        WARN_ON(rc < 0 && rc % 8 != 0);
 203        rc = msi_bitmap_alloc_hwirqs(&bmp, 9);
 204        WARN_ON(rc < 0 && rc % 16 != 0);
 205        rc = msi_bitmap_alloc_hwirqs(&bmp, 3);
 206        WARN_ON(rc < 0 && rc % 4 != 0);
 207        rc = msi_bitmap_alloc_hwirqs(&bmp, 7);
 208        WARN_ON(rc < 0 && rc % 8 != 0);
 209        rc = msi_bitmap_alloc_hwirqs(&bmp, 121);
 210        WARN_ON(rc < 0 && rc % 128 != 0);
 211
 212        msi_bitmap_free(&bmp);
 213
 214        /* Clients may WARN_ON bitmap == NULL for "not-allocated" */
 215        WARN_ON(bmp.bitmap != NULL);
 216}
 217
 218static void __init test_of_node(void)
 219{
 220        u32 prop_data[] = { 10, 10, 25, 3, 40, 1, 100, 100, 200, 20 };
 221        const char *expected_str = "0-9,20-24,28-39,41-99,220-255";
 222        char *prop_name = "msi-available-ranges";
 223        char *node_name = "/fakenode";
 224        struct device_node of_node;
 225        struct property prop;
 226        struct msi_bitmap bmp;
 227        int size = 256;
 228        DECLARE_BITMAP(expected, size);
 229
 230        /* There should really be a struct device_node allocator */
 231        memset(&of_node, 0, sizeof(of_node));
 232        of_node_init(&of_node);
 233        of_node.full_name = node_name;
 234
 235        WARN_ON(msi_bitmap_alloc(&bmp, size, &of_node));
 236
 237        /* No msi-available-ranges, so expect > 0 */
 238        WARN_ON(msi_bitmap_reserve_dt_hwirqs(&bmp) <= 0);
 239
 240        /* Should all still be free */
 241        WARN_ON(bitmap_find_free_region(bmp.bitmap, size, get_count_order(size)));
 242        bitmap_release_region(bmp.bitmap, 0, get_count_order(size));
 243
 244        /* Now create a fake msi-available-ranges property */
 245
 246        /* There should really .. oh whatever */
 247        memset(&prop, 0, sizeof(prop));
 248        prop.name = prop_name;
 249        prop.value = &prop_data;
 250        prop.length = sizeof(prop_data);
 251
 252        of_node.properties = &prop;
 253
 254        /* msi-available-ranges, so expect == 0 */
 255        WARN_ON(msi_bitmap_reserve_dt_hwirqs(&bmp));
 256
 257        /* Check we got the expected result */
 258        WARN_ON(bitmap_parselist(expected_str, expected, size));
 259        WARN_ON(!bitmap_equal(expected, bmp.bitmap, size));
 260
 261        msi_bitmap_free(&bmp);
 262        kfree(bmp.bitmap);
 263}
 264
 265static int __init msi_bitmap_selftest(void)
 266{
 267        printk(KERN_DEBUG "Running MSI bitmap self-tests ...\n");
 268
 269        test_basics();
 270        test_of_node();
 271
 272        return 0;
 273}
 274late_initcall(msi_bitmap_selftest);
 275#endif /* CONFIG_MSI_BITMAP_SELFTEST */
 276