mirror of
https://github.com/torvalds/linux.git
synced 2024-12-07 03:21:32 +00:00
b15fc7c2c8
The kernel will complain anyway if it runs out of memory, so it is not necessary to print an extra error message when that happens and kzalloc() can be called directly instead of pnp_alloc() which then becomes redundant and can be dropped. Signed-off-by: Heiner Kallweit <hkallweit1@gmail.com> [ rjw: Subject and changelog edits ] Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
471 lines
11 KiB
C
471 lines
11 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* interface.c - contains everything related to the user interface
|
|
*
|
|
* Some code, especially possible resource dumping is based on isapnp_proc.c (c) Jaroslav Kysela <perex@perex.cz>
|
|
* Copyright 2002 Adam Belay <ambx1@neo.rr.com>
|
|
* Copyright (C) 2008 Hewlett-Packard Development Company, L.P.
|
|
* Bjorn Helgaas <bjorn.helgaas@hp.com>
|
|
*/
|
|
|
|
#include <linux/pnp.h>
|
|
#include <linux/string.h>
|
|
#include <linux/errno.h>
|
|
#include <linux/list.h>
|
|
#include <linux/types.h>
|
|
#include <linux/stat.h>
|
|
#include <linux/ctype.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/mutex.h>
|
|
|
|
#include <linux/uaccess.h>
|
|
|
|
#include "base.h"
|
|
|
|
struct pnp_info_buffer {
|
|
char *buffer; /* pointer to begin of buffer */
|
|
char *curr; /* current position in buffer */
|
|
unsigned long size; /* current size */
|
|
unsigned long len; /* total length of buffer */
|
|
int stop; /* stop flag */
|
|
int error; /* error code */
|
|
};
|
|
|
|
typedef struct pnp_info_buffer pnp_info_buffer_t;
|
|
|
|
__printf(2, 3)
|
|
static int pnp_printf(pnp_info_buffer_t * buffer, char *fmt, ...)
|
|
{
|
|
va_list args;
|
|
int res;
|
|
|
|
if (buffer->stop || buffer->error)
|
|
return 0;
|
|
va_start(args, fmt);
|
|
res = vsnprintf(buffer->curr, buffer->len - buffer->size, fmt, args);
|
|
va_end(args);
|
|
if (buffer->size + res >= buffer->len) {
|
|
buffer->stop = 1;
|
|
return 0;
|
|
}
|
|
buffer->curr += res;
|
|
buffer->size += res;
|
|
return res;
|
|
}
|
|
|
|
static void pnp_print_port(pnp_info_buffer_t * buffer, char *space,
|
|
struct pnp_port *port)
|
|
{
|
|
pnp_printf(buffer, "%sport %#llx-%#llx, align %#llx, size %#llx, "
|
|
"%i-bit address decoding\n", space,
|
|
(unsigned long long) port->min,
|
|
(unsigned long long) port->max,
|
|
port->align ? ((unsigned long long) port->align - 1) : 0,
|
|
(unsigned long long) port->size,
|
|
port->flags & IORESOURCE_IO_16BIT_ADDR ? 16 : 10);
|
|
}
|
|
|
|
static void pnp_print_irq(pnp_info_buffer_t * buffer, char *space,
|
|
struct pnp_irq *irq)
|
|
{
|
|
int first = 1, i;
|
|
|
|
pnp_printf(buffer, "%sirq ", space);
|
|
for (i = 0; i < PNP_IRQ_NR; i++)
|
|
if (test_bit(i, irq->map.bits)) {
|
|
if (!first) {
|
|
pnp_printf(buffer, ",");
|
|
} else {
|
|
first = 0;
|
|
}
|
|
if (i == 2 || i == 9)
|
|
pnp_printf(buffer, "2/9");
|
|
else
|
|
pnp_printf(buffer, "%i", i);
|
|
}
|
|
if (bitmap_empty(irq->map.bits, PNP_IRQ_NR))
|
|
pnp_printf(buffer, "<none>");
|
|
if (irq->flags & IORESOURCE_IRQ_HIGHEDGE)
|
|
pnp_printf(buffer, " High-Edge");
|
|
if (irq->flags & IORESOURCE_IRQ_LOWEDGE)
|
|
pnp_printf(buffer, " Low-Edge");
|
|
if (irq->flags & IORESOURCE_IRQ_HIGHLEVEL)
|
|
pnp_printf(buffer, " High-Level");
|
|
if (irq->flags & IORESOURCE_IRQ_LOWLEVEL)
|
|
pnp_printf(buffer, " Low-Level");
|
|
if (irq->flags & IORESOURCE_IRQ_OPTIONAL)
|
|
pnp_printf(buffer, " (optional)");
|
|
pnp_printf(buffer, "\n");
|
|
}
|
|
|
|
static void pnp_print_dma(pnp_info_buffer_t * buffer, char *space,
|
|
struct pnp_dma *dma)
|
|
{
|
|
int first = 1, i;
|
|
char *s;
|
|
|
|
pnp_printf(buffer, "%sdma ", space);
|
|
for (i = 0; i < 8; i++)
|
|
if (dma->map & (1 << i)) {
|
|
if (!first) {
|
|
pnp_printf(buffer, ",");
|
|
} else {
|
|
first = 0;
|
|
}
|
|
pnp_printf(buffer, "%i", i);
|
|
}
|
|
if (!dma->map)
|
|
pnp_printf(buffer, "<none>");
|
|
switch (dma->flags & IORESOURCE_DMA_TYPE_MASK) {
|
|
case IORESOURCE_DMA_8BIT:
|
|
s = "8-bit";
|
|
break;
|
|
case IORESOURCE_DMA_8AND16BIT:
|
|
s = "8-bit&16-bit";
|
|
break;
|
|
default:
|
|
s = "16-bit";
|
|
}
|
|
pnp_printf(buffer, " %s", s);
|
|
if (dma->flags & IORESOURCE_DMA_MASTER)
|
|
pnp_printf(buffer, " master");
|
|
if (dma->flags & IORESOURCE_DMA_BYTE)
|
|
pnp_printf(buffer, " byte-count");
|
|
if (dma->flags & IORESOURCE_DMA_WORD)
|
|
pnp_printf(buffer, " word-count");
|
|
switch (dma->flags & IORESOURCE_DMA_SPEED_MASK) {
|
|
case IORESOURCE_DMA_TYPEA:
|
|
s = "type-A";
|
|
break;
|
|
case IORESOURCE_DMA_TYPEB:
|
|
s = "type-B";
|
|
break;
|
|
case IORESOURCE_DMA_TYPEF:
|
|
s = "type-F";
|
|
break;
|
|
default:
|
|
s = "compatible";
|
|
break;
|
|
}
|
|
pnp_printf(buffer, " %s\n", s);
|
|
}
|
|
|
|
static void pnp_print_mem(pnp_info_buffer_t * buffer, char *space,
|
|
struct pnp_mem *mem)
|
|
{
|
|
char *s;
|
|
|
|
pnp_printf(buffer, "%sMemory %#llx-%#llx, align %#llx, size %#llx",
|
|
space, (unsigned long long) mem->min,
|
|
(unsigned long long) mem->max,
|
|
(unsigned long long) mem->align,
|
|
(unsigned long long) mem->size);
|
|
if (mem->flags & IORESOURCE_MEM_WRITEABLE)
|
|
pnp_printf(buffer, ", writeable");
|
|
if (mem->flags & IORESOURCE_MEM_CACHEABLE)
|
|
pnp_printf(buffer, ", cacheable");
|
|
if (mem->flags & IORESOURCE_MEM_RANGELENGTH)
|
|
pnp_printf(buffer, ", range-length");
|
|
if (mem->flags & IORESOURCE_MEM_SHADOWABLE)
|
|
pnp_printf(buffer, ", shadowable");
|
|
if (mem->flags & IORESOURCE_MEM_EXPANSIONROM)
|
|
pnp_printf(buffer, ", expansion ROM");
|
|
switch (mem->flags & IORESOURCE_MEM_TYPE_MASK) {
|
|
case IORESOURCE_MEM_8BIT:
|
|
s = "8-bit";
|
|
break;
|
|
case IORESOURCE_MEM_8AND16BIT:
|
|
s = "8-bit&16-bit";
|
|
break;
|
|
case IORESOURCE_MEM_32BIT:
|
|
s = "32-bit";
|
|
break;
|
|
default:
|
|
s = "16-bit";
|
|
}
|
|
pnp_printf(buffer, ", %s\n", s);
|
|
}
|
|
|
|
static void pnp_print_option(pnp_info_buffer_t * buffer, char *space,
|
|
struct pnp_option *option)
|
|
{
|
|
switch (option->type) {
|
|
case IORESOURCE_IO:
|
|
pnp_print_port(buffer, space, &option->u.port);
|
|
break;
|
|
case IORESOURCE_MEM:
|
|
pnp_print_mem(buffer, space, &option->u.mem);
|
|
break;
|
|
case IORESOURCE_IRQ:
|
|
pnp_print_irq(buffer, space, &option->u.irq);
|
|
break;
|
|
case IORESOURCE_DMA:
|
|
pnp_print_dma(buffer, space, &option->u.dma);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static ssize_t options_show(struct device *dmdev, struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
struct pnp_dev *dev = to_pnp_dev(dmdev);
|
|
pnp_info_buffer_t *buffer;
|
|
struct pnp_option *option;
|
|
int ret, dep = 0, set = 0;
|
|
char *indent;
|
|
|
|
buffer = kzalloc(sizeof(*buffer), GFP_KERNEL);
|
|
if (!buffer)
|
|
return -ENOMEM;
|
|
|
|
buffer->len = PAGE_SIZE;
|
|
buffer->buffer = buf;
|
|
buffer->curr = buffer->buffer;
|
|
|
|
list_for_each_entry(option, &dev->options, list) {
|
|
if (pnp_option_is_dependent(option)) {
|
|
indent = " ";
|
|
if (!dep || pnp_option_set(option) != set) {
|
|
set = pnp_option_set(option);
|
|
dep = 1;
|
|
pnp_printf(buffer, "Dependent: %02i - "
|
|
"Priority %s\n", set,
|
|
pnp_option_priority_name(option));
|
|
}
|
|
} else {
|
|
dep = 0;
|
|
indent = "";
|
|
}
|
|
pnp_print_option(buffer, indent, option);
|
|
}
|
|
|
|
ret = (buffer->curr - buf);
|
|
kfree(buffer);
|
|
return ret;
|
|
}
|
|
static DEVICE_ATTR_RO(options);
|
|
|
|
static ssize_t resources_show(struct device *dmdev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct pnp_dev *dev = to_pnp_dev(dmdev);
|
|
pnp_info_buffer_t *buffer;
|
|
struct pnp_resource *pnp_res;
|
|
struct resource *res;
|
|
int ret;
|
|
|
|
if (!dev)
|
|
return -EINVAL;
|
|
|
|
buffer = kzalloc(sizeof(*buffer), GFP_KERNEL);
|
|
if (!buffer)
|
|
return -ENOMEM;
|
|
|
|
buffer->len = PAGE_SIZE;
|
|
buffer->buffer = buf;
|
|
buffer->curr = buffer->buffer;
|
|
|
|
pnp_printf(buffer, "state = %s\n", dev->active ? "active" : "disabled");
|
|
|
|
list_for_each_entry(pnp_res, &dev->resources, list) {
|
|
res = &pnp_res->res;
|
|
|
|
pnp_printf(buffer, pnp_resource_type_name(res));
|
|
|
|
if (res->flags & IORESOURCE_DISABLED) {
|
|
pnp_printf(buffer, " disabled\n");
|
|
continue;
|
|
}
|
|
|
|
switch (pnp_resource_type(res)) {
|
|
case IORESOURCE_IO:
|
|
case IORESOURCE_MEM:
|
|
case IORESOURCE_BUS:
|
|
pnp_printf(buffer, " %#llx-%#llx%s\n",
|
|
(unsigned long long) res->start,
|
|
(unsigned long long) res->end,
|
|
res->flags & IORESOURCE_WINDOW ?
|
|
" window" : "");
|
|
break;
|
|
case IORESOURCE_IRQ:
|
|
case IORESOURCE_DMA:
|
|
pnp_printf(buffer, " %lld\n",
|
|
(unsigned long long) res->start);
|
|
break;
|
|
}
|
|
}
|
|
|
|
ret = (buffer->curr - buf);
|
|
kfree(buffer);
|
|
return ret;
|
|
}
|
|
|
|
static char *pnp_get_resource_value(char *buf,
|
|
unsigned long type,
|
|
resource_size_t *start,
|
|
resource_size_t *end,
|
|
unsigned long *flags)
|
|
{
|
|
if (start)
|
|
*start = 0;
|
|
if (end)
|
|
*end = 0;
|
|
if (flags)
|
|
*flags = 0;
|
|
|
|
/* TBD: allow for disabled resources */
|
|
|
|
buf = skip_spaces(buf);
|
|
if (start) {
|
|
*start = simple_strtoull(buf, &buf, 0);
|
|
if (end) {
|
|
buf = skip_spaces(buf);
|
|
if (*buf == '-') {
|
|
buf = skip_spaces(buf + 1);
|
|
*end = simple_strtoull(buf, &buf, 0);
|
|
} else
|
|
*end = *start;
|
|
}
|
|
}
|
|
|
|
/* TBD: allow for additional flags, e.g., IORESOURCE_WINDOW */
|
|
|
|
return buf;
|
|
}
|
|
|
|
static ssize_t resources_store(struct device *dmdev,
|
|
struct device_attribute *attr, const char *ubuf,
|
|
size_t count)
|
|
{
|
|
struct pnp_dev *dev = to_pnp_dev(dmdev);
|
|
char *buf = (void *)ubuf;
|
|
int retval = 0;
|
|
|
|
if (dev->status & PNP_ATTACHED) {
|
|
retval = -EBUSY;
|
|
dev_info(&dev->dev, "in use; can't configure\n");
|
|
goto done;
|
|
}
|
|
|
|
buf = skip_spaces(buf);
|
|
if (!strncasecmp(buf, "disable", 7)) {
|
|
retval = pnp_disable_dev(dev);
|
|
goto done;
|
|
}
|
|
if (!strncasecmp(buf, "activate", 8)) {
|
|
retval = pnp_activate_dev(dev);
|
|
goto done;
|
|
}
|
|
if (!strncasecmp(buf, "fill", 4)) {
|
|
if (dev->active)
|
|
goto done;
|
|
retval = pnp_auto_config_dev(dev);
|
|
goto done;
|
|
}
|
|
if (!strncasecmp(buf, "auto", 4)) {
|
|
if (dev->active)
|
|
goto done;
|
|
pnp_init_resources(dev);
|
|
retval = pnp_auto_config_dev(dev);
|
|
goto done;
|
|
}
|
|
if (!strncasecmp(buf, "clear", 5)) {
|
|
if (dev->active)
|
|
goto done;
|
|
pnp_init_resources(dev);
|
|
goto done;
|
|
}
|
|
if (!strncasecmp(buf, "get", 3)) {
|
|
mutex_lock(&pnp_res_mutex);
|
|
if (pnp_can_read(dev))
|
|
dev->protocol->get(dev);
|
|
mutex_unlock(&pnp_res_mutex);
|
|
goto done;
|
|
}
|
|
if (!strncasecmp(buf, "set", 3)) {
|
|
resource_size_t start;
|
|
resource_size_t end;
|
|
unsigned long flags;
|
|
|
|
if (dev->active)
|
|
goto done;
|
|
buf += 3;
|
|
pnp_init_resources(dev);
|
|
mutex_lock(&pnp_res_mutex);
|
|
while (1) {
|
|
buf = skip_spaces(buf);
|
|
if (!strncasecmp(buf, "io", 2)) {
|
|
buf = pnp_get_resource_value(buf + 2,
|
|
IORESOURCE_IO,
|
|
&start, &end,
|
|
&flags);
|
|
pnp_add_io_resource(dev, start, end, flags);
|
|
} else if (!strncasecmp(buf, "mem", 3)) {
|
|
buf = pnp_get_resource_value(buf + 3,
|
|
IORESOURCE_MEM,
|
|
&start, &end,
|
|
&flags);
|
|
pnp_add_mem_resource(dev, start, end, flags);
|
|
} else if (!strncasecmp(buf, "irq", 3)) {
|
|
buf = pnp_get_resource_value(buf + 3,
|
|
IORESOURCE_IRQ,
|
|
&start, NULL,
|
|
&flags);
|
|
pnp_add_irq_resource(dev, start, flags);
|
|
} else if (!strncasecmp(buf, "dma", 3)) {
|
|
buf = pnp_get_resource_value(buf + 3,
|
|
IORESOURCE_DMA,
|
|
&start, NULL,
|
|
&flags);
|
|
pnp_add_dma_resource(dev, start, flags);
|
|
} else if (!strncasecmp(buf, "bus", 3)) {
|
|
buf = pnp_get_resource_value(buf + 3,
|
|
IORESOURCE_BUS,
|
|
&start, &end,
|
|
NULL);
|
|
pnp_add_bus_resource(dev, start, end);
|
|
} else
|
|
break;
|
|
}
|
|
mutex_unlock(&pnp_res_mutex);
|
|
goto done;
|
|
}
|
|
|
|
done:
|
|
if (retval < 0)
|
|
return retval;
|
|
return count;
|
|
}
|
|
static DEVICE_ATTR_RW(resources);
|
|
|
|
static ssize_t id_show(struct device *dmdev, struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
char *str = buf;
|
|
struct pnp_dev *dev = to_pnp_dev(dmdev);
|
|
struct pnp_id *pos = dev->id;
|
|
|
|
while (pos) {
|
|
str += sprintf(str, "%s\n", pos->id);
|
|
pos = pos->next;
|
|
}
|
|
return (str - buf);
|
|
}
|
|
static DEVICE_ATTR_RO(id);
|
|
|
|
static struct attribute *pnp_dev_attrs[] = {
|
|
&dev_attr_resources.attr,
|
|
&dev_attr_options.attr,
|
|
&dev_attr_id.attr,
|
|
NULL,
|
|
};
|
|
|
|
static const struct attribute_group pnp_dev_group = {
|
|
.attrs = pnp_dev_attrs,
|
|
};
|
|
|
|
const struct attribute_group *pnp_dev_groups[] = {
|
|
&pnp_dev_group,
|
|
NULL,
|
|
};
|