LXR linux/drivers/pnp/support.c

   1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * support.c - standard functions for the use of pnp protocol drivers
   4 *
   5 * Copyright 2003 Adam Belay <ambx1@neo.rr.com>
   6 * Copyright (C) 2008 Hewlett-Packard Development Company, L.P.
   7 *      Bjorn Helgaas <bjorn.helgaas@hp.com>
   8 */
   9
  10#include <linux/module.h>
  11#include <linux/ctype.h>
  12#include <linux/pnp.h>
  13#include "base.h"
  14
  15/**
  16 * pnp_is_active - Determines if a device is active based on its current
  17 *      resources
  18 * @dev: pointer to the desired PnP device
  19 */
  20int pnp_is_active(struct pnp_dev *dev)
  21{
  22        /*
  23         * I don't think this is very reliable because pnp_disable_dev()
  24         * only clears out auto-assigned resources.
  25         */
  26        if (!pnp_port_start(dev, 0) && pnp_port_len(dev, 0) <= 1 &&
  27            !pnp_mem_start(dev, 0) && pnp_mem_len(dev, 0) <= 1 &&
  28            pnp_irq(dev, 0) == -1 && pnp_dma(dev, 0) == -1)
  29                return 0;
  30        else
  31                return 1;
  32}
  33
  34EXPORT_SYMBOL(pnp_is_active);
  35
  36/*
  37 * Functionally similar to acpi_ex_eisa_id_to_string(), but that's
  38 * buried in the ACPI CA, and we can't depend on it being present.
  39 */
  40void pnp_eisa_id_to_string(u32 id, char *str)
  41{
  42        id = be32_to_cpu(id);
  43
  44        /*
  45         * According to the specs, the first three characters are five-bit
  46         * compressed ASCII, and the left-over high order bit should be zero.
  47         * However, the Linux ISAPNP code historically used six bits for the
  48         * first character, and there seem to be IDs that depend on that,
  49         * e.g., "nEC8241" in the Linux 8250_pnp serial driver and the
  50         * FreeBSD sys/pc98/cbus/sio_cbus.c driver.
  51         */
  52        str[0] = 'A' + ((id >> 26) & 0x3f) - 1;
  53        str[1] = 'A' + ((id >> 21) & 0x1f) - 1;
  54        str[2] = 'A' + ((id >> 16) & 0x1f) - 1;
  55        str[3] = hex_asc_hi(id >> 8);
  56        str[4] = hex_asc_lo(id >> 8);
  57        str[5] = hex_asc_hi(id);
  58        str[6] = hex_asc_lo(id);
  59        str[7] = '\0';
  60}
  61
  62char *pnp_resource_type_name(struct resource *res)
  63{
  64        switch (pnp_resource_type(res)) {
  65        case IORESOURCE_IO:
  66                return "io";
  67        case IORESOURCE_MEM:
  68                return "mem";
  69        case IORESOURCE_IRQ:
  70                return "irq";
  71        case IORESOURCE_DMA:
  72                return "dma";
  73        case IORESOURCE_BUS:
  74                return "bus";
  75        }
  76        return "unknown";
  77}
  78
  79void dbg_pnp_show_resources(struct pnp_dev *dev, char *desc)
  80{
  81        struct pnp_resource *pnp_res;
  82
  83        if (list_empty(&dev->resources))
  84                pnp_dbg(&dev->dev, "%s: no current resources\n", desc);
  85        else {
  86                pnp_dbg(&dev->dev, "%s: current resources:\n", desc);
  87                list_for_each_entry(pnp_res, &dev->resources, list)
  88                        pnp_dbg(&dev->dev, "%pr\n", &pnp_res->res);
  89        }
  90}
  91
  92char *pnp_option_priority_name(struct pnp_option *option)
  93{
  94        switch (pnp_option_priority(option)) {
  95        case PNP_RES_PRIORITY_PREFERRED:
  96                return "preferred";
  97        case PNP_RES_PRIORITY_ACCEPTABLE:
  98                return "acceptable";
  99        case PNP_RES_PRIORITY_FUNCTIONAL:
 100                return "functional";
 101        }
 102        return "invalid";
 103}
 104
 105void dbg_pnp_show_option(struct pnp_dev *dev, struct pnp_option *option)
 106{
 107        char buf[128];
 108        int len = 0, i;
 109        struct pnp_port *port;
 110        struct pnp_mem *mem;
 111        struct pnp_irq *irq;
 112        struct pnp_dma *dma;
 113
 114        if (pnp_option_is_dependent(option))
 115                len += scnprintf(buf + len, sizeof(buf) - len,
 116                                 "  dependent set %d (%s) ",
 117                                 pnp_option_set(option),
 118                                 pnp_option_priority_name(option));
 119        else
 120                len += scnprintf(buf + len, sizeof(buf) - len,
 121                                 "  independent ");
 122
 123        switch (option->type) {
 124        case IORESOURCE_IO:
 125                port = &option->u.port;
 126                len += scnprintf(buf + len, sizeof(buf) - len, "io  min %#llx "
 127                                 "max %#llx align %lld size %lld flags %#x",
 128                                 (unsigned long long) port->min,
 129                                 (unsigned long long) port->max,
 130                                 (unsigned long long) port->align,
 131                                 (unsigned long long) port->size, port->flags);
 132                break;
 133        case IORESOURCE_MEM:
 134                mem = &option->u.mem;
 135                len += scnprintf(buf + len, sizeof(buf) - len, "mem min %#llx "
 136                                 "max %#llx align %lld size %lld flags %#x",
 137                                 (unsigned long long) mem->min,
 138                                 (unsigned long long) mem->max,
 139                                 (unsigned long long) mem->align,
 140                                 (unsigned long long) mem->size, mem->flags);
 141                break;
 142        case IORESOURCE_IRQ:
 143                irq = &option->u.irq;
 144                len += scnprintf(buf + len, sizeof(buf) - len, "irq");
 145                if (bitmap_empty(irq->map.bits, PNP_IRQ_NR))
 146                        len += scnprintf(buf + len, sizeof(buf) - len,
 147                                         " <none>");
 148                else {
 149                        for (i = 0; i < PNP_IRQ_NR; i++)
 150                                if (test_bit(i, irq->map.bits))
 151                                        len += scnprintf(buf + len,
 152                                                         sizeof(buf) - len,
 153                                                         " %d", i);
 154                }
 155                len += scnprintf(buf + len, sizeof(buf) - len, " flags %#x",
 156                                 irq->flags);
 157                if (irq->flags & IORESOURCE_IRQ_OPTIONAL)
 158                        len += scnprintf(buf + len, sizeof(buf) - len,
 159                                         " (optional)");
 160                break;
 161        case IORESOURCE_DMA:
 162                dma = &option->u.dma;
 163                len += scnprintf(buf + len, sizeof(buf) - len, "dma");
 164                if (!dma->map)
 165                        len += scnprintf(buf + len, sizeof(buf) - len,
 166                                         " <none>");
 167                else {
 168                        for (i = 0; i < 8; i++)
 169                                if (dma->map & (1 << i))
 170                                        len += scnprintf(buf + len,
 171                                                         sizeof(buf) - len,
 172                                                         " %d", i);
 173                }
 174                len += scnprintf(buf + len, sizeof(buf) - len, " (bitmask %#x) "
 175                                 "flags %#x", dma->map, dma->flags);
 176                break;
 177        }
 178        pnp_dbg(&dev->dev, "%s\n", buf);
 179}
 180