devres.c

Go to the documentation of this file.

#include <linux/pci.h>
#include <linux/io.h>
#include <linux/gfp.h>
#include <linux/export.h>

void devm_ioremap_release(struct device *dev, void *res)
{
    iounmap(*(void __iomem **)res);
}

static int devm_ioremap_match(struct device *dev, void *res, void *match_data)
{
    return *(void **)res == match_data;
}

void __iomem *devm_ioremap(struct device *dev, resource_size_t offset,
               unsigned long size)
{
    void __iomem **ptr, *addr;

    ptr = devres_alloc(devm_ioremap_release, sizeof(*ptr), GFP_KERNEL);
    if (!ptr)
        return NULL;

    addr = ioremap(offset, size);
    if (addr) {
        *ptr = addr;
        devres_add(dev, ptr);
    } else
        devres_free(ptr);

    return addr;
}
EXPORT_SYMBOL(devm_ioremap);

void __iomem *devm_ioremap_nocache(struct device *dev, resource_size_t offset,
                   unsigned long size)
{
    void __iomem **ptr, *addr;

    ptr = devres_alloc(devm_ioremap_release, sizeof(*ptr), GFP_KERNEL);
    if (!ptr)
        return NULL;

    addr = ioremap_nocache(offset, size);
    if (addr) {
        *ptr = addr;
        devres_add(dev, ptr);
    } else
        devres_free(ptr);

    return addr;
}
EXPORT_SYMBOL(devm_ioremap_nocache);

void devm_iounmap(struct device *dev, void __iomem *addr)
{
    WARN_ON(devres_destroy(dev, devm_ioremap_release, devm_ioremap_match,
                   (void *)addr));
    iounmap(addr);
}
EXPORT_SYMBOL(devm_iounmap);

void __iomem *devm_request_and_ioremap(struct device *dev,
            struct resource *res)
{
    resource_size_t size;
    const char *name;
    void __iomem *dest_ptr;

    BUG_ON(!dev);

    if (!res || resource_type(res) != IORESOURCE_MEM) {
        dev_err(dev, "invalid resource\n");
        return NULL;
    }

    size = resource_size(res);
    name = res->name ?: dev_name(dev);

    if (!devm_request_mem_region(dev, res->start, size, name)) {
        dev_err(dev, "can't request region for resource %pR\n", res);
        return NULL;
    }

    if (res->flags & IORESOURCE_CACHEABLE)
        dest_ptr = devm_ioremap(dev, res->start, size);
    else
        dest_ptr = devm_ioremap_nocache(dev, res->start, size);

    if (!dest_ptr) {
        dev_err(dev, "ioremap failed for resource %pR\n", res);
        devm_release_mem_region(dev, res->start, size);
    }

    return dest_ptr;
}
EXPORT_SYMBOL(devm_request_and_ioremap);

#ifdef CONFIG_HAS_IOPORT
/*
 * Generic iomap devres
 */
static void devm_ioport_map_release(struct device *dev, void *res)
{
    ioport_unmap(*(void __iomem **)res);
}

static int devm_ioport_map_match(struct device *dev, void *res,
                 void *match_data)
{
    return *(void **)res == match_data;
}

void __iomem * devm_ioport_map(struct device *dev, unsigned long port,
                   unsigned int nr)
{
    void __iomem **ptr, *addr;

    ptr = devres_alloc(devm_ioport_map_release, sizeof(*ptr), GFP_KERNEL);
    if (!ptr)
        return NULL;

    addr = ioport_map(port, nr);
    if (addr) {
        *ptr = addr;
        devres_add(dev, ptr);
    } else
        devres_free(ptr);

    return addr;
}
EXPORT_SYMBOL(devm_ioport_map);

void devm_ioport_unmap(struct device *dev, void __iomem *addr)
{
    ioport_unmap(addr);
    WARN_ON(devres_destroy(dev, devm_ioport_map_release,
                   devm_ioport_map_match, (void *)addr));
}
EXPORT_SYMBOL(devm_ioport_unmap);

#ifdef CONFIG_PCI
/*
 * PCI iomap devres
 */
#define PCIM_IOMAP_MAX  PCI_ROM_RESOURCE

struct pcim_iomap_devres {
    void __iomem *table[PCIM_IOMAP_MAX];
};

static void pcim_iomap_release(struct device *gendev, void *res)
{
    struct pci_dev *dev = container_of(gendev, struct pci_dev, dev);
    struct pcim_iomap_devres *this = res;
    int i;

    for (i = 0; i < PCIM_IOMAP_MAX; i++)
        if (this->table[i])
            pci_iounmap(dev, this->table[i]);
}

void __iomem * const * pcim_iomap_table(struct pci_dev *pdev)
{
    struct pcim_iomap_devres *dr, *new_dr;

    dr = devres_find(&pdev->dev, pcim_iomap_release, NULL, NULL);
    if (dr)
        return dr->table;

    new_dr = devres_alloc(pcim_iomap_release, sizeof(*new_dr), GFP_KERNEL);
    if (!new_dr)
        return NULL;
    dr = devres_get(&pdev->dev, new_dr, NULL, NULL);
    return dr->table;
}
EXPORT_SYMBOL(pcim_iomap_table);

void __iomem * pcim_iomap(struct pci_dev *pdev, int bar, unsigned long maxlen)
{
    void __iomem **tbl;

    BUG_ON(bar >= PCIM_IOMAP_MAX);

    tbl = (void __iomem **)pcim_iomap_table(pdev);
    if (!tbl || tbl[bar])   /* duplicate mappings not allowed */
        return NULL;

    tbl[bar] = pci_iomap(pdev, bar, maxlen);
    return tbl[bar];
}
EXPORT_SYMBOL(pcim_iomap);

void pcim_iounmap(struct pci_dev *pdev, void __iomem *addr)
{
    void __iomem **tbl;
    int i;

    pci_iounmap(pdev, addr);

    tbl = (void __iomem **)pcim_iomap_table(pdev);
    BUG_ON(!tbl);

    for (i = 0; i < PCIM_IOMAP_MAX; i++)
        if (tbl[i] == addr) {
            tbl[i] = NULL;
            return;
        }
    WARN_ON(1);
}
EXPORT_SYMBOL(pcim_iounmap);

int pcim_iomap_regions(struct pci_dev *pdev, int mask, const char *name)
{
    void __iomem * const *iomap;
    int i, rc;

    iomap = pcim_iomap_table(pdev);
    if (!iomap)
        return -ENOMEM;

    for (i = 0; i < DEVICE_COUNT_RESOURCE; i++) {
        unsigned long len;

        if (!(mask & (1 << i)))
            continue;

        rc = -EINVAL;
        len = pci_resource_len(pdev, i);
        if (!len)
            goto err_inval;

        rc = pci_request_region(pdev, i, name);
        if (rc)
            goto err_inval;

        rc = -ENOMEM;
        if (!pcim_iomap(pdev, i, 0))
            goto err_region;
    }

    return 0;

 err_region:
    pci_release_region(pdev, i);
 err_inval:
    while (--i >= 0) {
        if (!(mask & (1 << i)))
            continue;
        pcim_iounmap(pdev, iomap[i]);
        pci_release_region(pdev, i);
    }

    return rc;
}
EXPORT_SYMBOL(pcim_iomap_regions);

int pcim_iomap_regions_request_all(struct pci_dev *pdev, int mask,
                   const char *name)
{
    int request_mask = ((1 << 6) - 1) & ~mask;
    int rc;

    rc = pci_request_selected_regions(pdev, request_mask, name);
    if (rc)
        return rc;

    rc = pcim_iomap_regions(pdev, mask, name);
    if (rc)
        pci_release_selected_regions(pdev, request_mask);
    return rc;
}
EXPORT_SYMBOL(pcim_iomap_regions_request_all);

void pcim_iounmap_regions(struct pci_dev *pdev, int mask)
{
    void __iomem * const *iomap;
    int i;

    iomap = pcim_iomap_table(pdev);
    if (!iomap)
        return;

    for (i = 0; i < DEVICE_COUNT_RESOURCE; i++) {
        if (!(mask & (1 << i)))
            continue;

        pcim_iounmap(pdev, iomap[i]);
        pci_release_region(pdev, i);
    }
}
EXPORT_SYMBOL(pcim_iounmap_regions);
#endif /* CONFIG_PCI */
#endif /* CONFIG_HAS_IOPORT */