interface.c revision 07d4e9af109221ab731c5aaf832e89776c64b013 
1/*
2 * interface.c - contains everything related to the user interface
3 *
4 * Some code, especially possible resource dumping is based on isapnp_proc.c (c) Jaroslav Kysela <perex@suse.cz>
5 * Copyright 2002 Adam Belay <ambx1@neo.rr.com>
6 */
7
8#include <linux/pnp.h>
9#include <linux/string.h>
10#include <linux/errno.h>
11#include <linux/list.h>
12#include <linux/types.h>
13#include <linux/stat.h>
14#include <linux/ctype.h>
15#include <linux/slab.h>
16#include <asm/uaccess.h>
17
18#include "base.h"
19
20struct pnp_info_buffer {
21	char *buffer;		/* pointer to begin of buffer */
22	char *curr;		/* current position in buffer */
23	unsigned long size;	/* current size */
24	unsigned long len;	/* total length of buffer */
25	int stop;		/* stop flag */
26	int error;		/* error code */
27};
28
29typedef struct pnp_info_buffer pnp_info_buffer_t;
30
31static int pnp_printf(pnp_info_buffer_t * buffer, char *fmt, ...)
32{
33	va_list args;
34	int res;
35
36	if (buffer->stop || buffer->error)
37		return 0;
38	va_start(args, fmt);
39	res = vsnprintf(buffer->curr, buffer->len - buffer->size, fmt, args);
40	va_end(args);
41	if (buffer->size + res >= buffer->len) {
42		buffer->stop = 1;
43		return 0;
44	}
45	buffer->curr += res;
46	buffer->size += res;
47	return res;
48}
49
50static void pnp_print_port(pnp_info_buffer_t * buffer, char *space,
51			   struct pnp_port *port)
52{
53	pnp_printf(buffer,
54		   "%sport 0x%x-0x%x, align 0x%x, size 0x%x, %i-bit address decoding\n",
55		   space, port->min, port->max,
56		   port->align ? (port->align - 1) : 0, port->size,
57		   port->flags & PNP_PORT_FLAG_16BITADDR ? 16 : 10);
58}
59
60static void pnp_print_irq(pnp_info_buffer_t * buffer, char *space,
61			  struct pnp_irq *irq)
62{
63	int first = 1, i;
64
65	pnp_printf(buffer, "%sirq ", space);
66	for (i = 0; i < PNP_IRQ_NR; i++)
67		if (test_bit(i, irq->map)) {
68			if (!first) {
69				pnp_printf(buffer, ",");
70			} else {
71				first = 0;
72			}
73			if (i == 2 || i == 9)
74				pnp_printf(buffer, "2/9");
75			else
76				pnp_printf(buffer, "%i", i);
77		}
78	if (bitmap_empty(irq->map, PNP_IRQ_NR))
79		pnp_printf(buffer, "<none>");
80	if (irq->flags & IORESOURCE_IRQ_HIGHEDGE)
81		pnp_printf(buffer, " High-Edge");
82	if (irq->flags & IORESOURCE_IRQ_LOWEDGE)
83		pnp_printf(buffer, " Low-Edge");
84	if (irq->flags & IORESOURCE_IRQ_HIGHLEVEL)
85		pnp_printf(buffer, " High-Level");
86	if (irq->flags & IORESOURCE_IRQ_LOWLEVEL)
87		pnp_printf(buffer, " Low-Level");
88	pnp_printf(buffer, "\n");
89}
90
91static void pnp_print_dma(pnp_info_buffer_t * buffer, char *space,
92			  struct pnp_dma *dma)
93{
94	int first = 1, i;
95	char *s;
96
97	pnp_printf(buffer, "%sdma ", space);
98	for (i = 0; i < 8; i++)
99		if (dma->map & (1 << i)) {
100			if (!first) {
101				pnp_printf(buffer, ",");
102			} else {
103				first = 0;
104			}
105			pnp_printf(buffer, "%i", i);
106		}
107	if (!dma->map)
108		pnp_printf(buffer, "<none>");
109	switch (dma->flags & IORESOURCE_DMA_TYPE_MASK) {
110	case IORESOURCE_DMA_8BIT:
111		s = "8-bit";
112		break;
113	case IORESOURCE_DMA_8AND16BIT:
114		s = "8-bit&16-bit";
115		break;
116	default:
117		s = "16-bit";
118	}
119	pnp_printf(buffer, " %s", s);
120	if (dma->flags & IORESOURCE_DMA_MASTER)
121		pnp_printf(buffer, " master");
122	if (dma->flags & IORESOURCE_DMA_BYTE)
123		pnp_printf(buffer, " byte-count");
124	if (dma->flags & IORESOURCE_DMA_WORD)
125		pnp_printf(buffer, " word-count");
126	switch (dma->flags & IORESOURCE_DMA_SPEED_MASK) {
127	case IORESOURCE_DMA_TYPEA:
128		s = "type-A";
129		break;
130	case IORESOURCE_DMA_TYPEB:
131		s = "type-B";
132		break;
133	case IORESOURCE_DMA_TYPEF:
134		s = "type-F";
135		break;
136	default:
137		s = "compatible";
138		break;
139	}
140	pnp_printf(buffer, " %s\n", s);
141}
142
143static void pnp_print_mem(pnp_info_buffer_t * buffer, char *space,
144			  struct pnp_mem *mem)
145{
146	char *s;
147
148	pnp_printf(buffer, "%sMemory 0x%x-0x%x, align 0x%x, size 0x%x",
149		   space, mem->min, mem->max, mem->align, mem->size);
150	if (mem->flags & IORESOURCE_MEM_WRITEABLE)
151		pnp_printf(buffer, ", writeable");
152	if (mem->flags & IORESOURCE_MEM_CACHEABLE)
153		pnp_printf(buffer, ", cacheable");
154	if (mem->flags & IORESOURCE_MEM_RANGELENGTH)
155		pnp_printf(buffer, ", range-length");
156	if (mem->flags & IORESOURCE_MEM_SHADOWABLE)
157		pnp_printf(buffer, ", shadowable");
158	if (mem->flags & IORESOURCE_MEM_EXPANSIONROM)
159		pnp_printf(buffer, ", expansion ROM");
160	switch (mem->flags & IORESOURCE_MEM_TYPE_MASK) {
161	case IORESOURCE_MEM_8BIT:
162		s = "8-bit";
163		break;
164	case IORESOURCE_MEM_8AND16BIT:
165		s = "8-bit&16-bit";
166		break;
167	case IORESOURCE_MEM_32BIT:
168		s = "32-bit";
169		break;
170	default:
171		s = "16-bit";
172	}
173	pnp_printf(buffer, ", %s\n", s);
174}
175
176static void pnp_print_option(pnp_info_buffer_t * buffer, char *space,
177			     struct pnp_option *option, int dep)
178{
179	char *s;
180	struct pnp_port *port;
181	struct pnp_irq *irq;
182	struct pnp_dma *dma;
183	struct pnp_mem *mem;
184
185	if (dep) {
186		switch (option->priority) {
187		case PNP_RES_PRIORITY_PREFERRED:
188			s = "preferred";
189			break;
190		case PNP_RES_PRIORITY_ACCEPTABLE:
191			s = "acceptable";
192			break;
193		case PNP_RES_PRIORITY_FUNCTIONAL:
194			s = "functional";
195			break;
196		default:
197			s = "invalid";
198		}
199		pnp_printf(buffer, "Dependent: %02i - Priority %s\n", dep, s);
200	}
201
202	for (port = option->port; port; port = port->next)
203		pnp_print_port(buffer, space, port);
204	for (irq = option->irq; irq; irq = irq->next)
205		pnp_print_irq(buffer, space, irq);
206	for (dma = option->dma; dma; dma = dma->next)
207		pnp_print_dma(buffer, space, dma);
208	for (mem = option->mem; mem; mem = mem->next)
209		pnp_print_mem(buffer, space, mem);
210}
211
212static ssize_t pnp_show_options(struct device *dmdev,
213				struct device_attribute *attr, char *buf)
214{
215	struct pnp_dev *dev = to_pnp_dev(dmdev);
216	struct pnp_option *independent = dev->independent;
217	struct pnp_option *dependent = dev->dependent;
218	int ret, dep = 1;
219
220	pnp_info_buffer_t *buffer = (pnp_info_buffer_t *)
221	    pnp_alloc(sizeof(pnp_info_buffer_t));
222	if (!buffer)
223		return -ENOMEM;
224
225	buffer->len = PAGE_SIZE;
226	buffer->buffer = buf;
227	buffer->curr = buffer->buffer;
228	if (independent)
229		pnp_print_option(buffer, "", independent, 0);
230
231	while (dependent) {
232		pnp_print_option(buffer, "   ", dependent, dep);
233		dependent = dependent->next;
234		dep++;
235	}
236	ret = (buffer->curr - buf);
237	kfree(buffer);
238	return ret;
239}
240
241static DEVICE_ATTR(options, S_IRUGO, pnp_show_options, NULL);
242
243static ssize_t pnp_show_current_resources(struct device *dmdev,
244					  struct device_attribute *attr,
245					  char *buf)
246{
247	struct pnp_dev *dev = to_pnp_dev(dmdev);
248	int i, ret;
249	pnp_info_buffer_t *buffer;
250
251	if (!dev)
252		return -EINVAL;
253
254	buffer = (pnp_info_buffer_t *) pnp_alloc(sizeof(pnp_info_buffer_t));
255	if (!buffer)
256		return -ENOMEM;
257	buffer->len = PAGE_SIZE;
258	buffer->buffer = buf;
259	buffer->curr = buffer->buffer;
260
261	pnp_printf(buffer, "state = ");
262	if (dev->active)
263		pnp_printf(buffer, "active\n");
264	else
265		pnp_printf(buffer, "disabled\n");
266
267	for (i = 0; i < PNP_MAX_PORT; i++) {
268		if (pnp_port_valid(dev, i)) {
269			pnp_printf(buffer, "io");
270			if (pnp_port_flags(dev, i) & IORESOURCE_DISABLED)
271				pnp_printf(buffer, " disabled\n");
272			else
273				pnp_printf(buffer, " 0x%llx-0x%llx\n",
274					   (unsigned long long)
275					   pnp_port_start(dev, i),
276					   (unsigned long long)pnp_port_end(dev,
277									    i));
278		}
279	}
280	for (i = 0; i < PNP_MAX_MEM; i++) {
281		if (pnp_mem_valid(dev, i)) {
282			pnp_printf(buffer, "mem");
283			if (pnp_mem_flags(dev, i) & IORESOURCE_DISABLED)
284				pnp_printf(buffer, " disabled\n");
285			else
286				pnp_printf(buffer, " 0x%llx-0x%llx\n",
287					   (unsigned long long)
288					   pnp_mem_start(dev, i),
289					   (unsigned long long)pnp_mem_end(dev,
290									   i));
291		}
292	}
293	for (i = 0; i < PNP_MAX_IRQ; i++) {
294		if (pnp_irq_valid(dev, i)) {
295			pnp_printf(buffer, "irq");
296			if (pnp_irq_flags(dev, i) & IORESOURCE_DISABLED)
297				pnp_printf(buffer, " disabled\n");
298			else
299				pnp_printf(buffer, " %lld\n",
300					   (unsigned long long)pnp_irq(dev, i));
301		}
302	}
303	for (i = 0; i < PNP_MAX_DMA; i++) {
304		if (pnp_dma_valid(dev, i)) {
305			pnp_printf(buffer, "dma");
306			if (pnp_dma_flags(dev, i) & IORESOURCE_DISABLED)
307				pnp_printf(buffer, " disabled\n");
308			else
309				pnp_printf(buffer, " %lld\n",
310					   (unsigned long long)pnp_dma(dev, i));
311		}
312	}
313	ret = (buffer->curr - buf);
314	kfree(buffer);
315	return ret;
316}
317
318extern struct semaphore pnp_res_mutex;
319
320static ssize_t
321pnp_set_current_resources(struct device *dmdev, struct device_attribute *attr,
322			  const char *ubuf, size_t count)
323{
324	struct pnp_dev *dev = to_pnp_dev(dmdev);
325	char *buf = (void *)ubuf;
326	int retval = 0;
327
328	if (dev->status & PNP_ATTACHED) {
329		retval = -EBUSY;
330		pnp_info("Device %s cannot be configured because it is in use.",
331			 dev->dev.bus_id);
332		goto done;
333	}
334
335	while (isspace(*buf))
336		++buf;
337	if (!strnicmp(buf, "disable", 7)) {
338		retval = pnp_disable_dev(dev);
339		goto done;
340	}
341	if (!strnicmp(buf, "activate", 8)) {
342		retval = pnp_activate_dev(dev);
343		goto done;
344	}
345	if (!strnicmp(buf, "fill", 4)) {
346		if (dev->active)
347			goto done;
348		retval = pnp_auto_config_dev(dev);
349		goto done;
350	}
351	if (!strnicmp(buf, "auto", 4)) {
352		if (dev->active)
353			goto done;
354		pnp_init_resource_table(&dev->res);
355		retval = pnp_auto_config_dev(dev);
356		goto done;
357	}
358	if (!strnicmp(buf, "clear", 5)) {
359		if (dev->active)
360			goto done;
361		pnp_init_resource_table(&dev->res);
362		goto done;
363	}
364	if (!strnicmp(buf, "get", 3)) {
365		down(&pnp_res_mutex);
366		if (pnp_can_read(dev))
367			dev->protocol->get(dev, &dev->res);
368		up(&pnp_res_mutex);
369		goto done;
370	}
371	if (!strnicmp(buf, "set", 3)) {
372		int nport = 0, nmem = 0, nirq = 0, ndma = 0;
373		if (dev->active)
374			goto done;
375		buf += 3;
376		pnp_init_resource_table(&dev->res);
377		down(&pnp_res_mutex);
378		while (1) {
379			while (isspace(*buf))
380				++buf;
381			if (!strnicmp(buf, "io", 2)) {
382				buf += 2;
383				while (isspace(*buf))
384					++buf;
385				dev->res.port_resource[nport].start =
386				    simple_strtoul(buf, &buf, 0);
387				while (isspace(*buf))
388					++buf;
389				if (*buf == '-') {
390					buf += 1;
391					while (isspace(*buf))
392						++buf;
393					dev->res.port_resource[nport].end =
394					    simple_strtoul(buf, &buf, 0);
395				} else
396					dev->res.port_resource[nport].end =
397					    dev->res.port_resource[nport].start;
398				dev->res.port_resource[nport].flags =
399				    IORESOURCE_IO;
400				nport++;
401				if (nport >= PNP_MAX_PORT)
402					break;
403				continue;
404			}
405			if (!strnicmp(buf, "mem", 3)) {
406				buf += 3;
407				while (isspace(*buf))
408					++buf;
409				dev->res.mem_resource[nmem].start =
410				    simple_strtoul(buf, &buf, 0);
411				while (isspace(*buf))
412					++buf;
413				if (*buf == '-') {
414					buf += 1;
415					while (isspace(*buf))
416						++buf;
417					dev->res.mem_resource[nmem].end =
418					    simple_strtoul(buf, &buf, 0);
419				} else
420					dev->res.mem_resource[nmem].end =
421					    dev->res.mem_resource[nmem].start;
422				dev->res.mem_resource[nmem].flags =
423				    IORESOURCE_MEM;
424				nmem++;
425				if (nmem >= PNP_MAX_MEM)
426					break;
427				continue;
428			}
429			if (!strnicmp(buf, "irq", 3)) {
430				buf += 3;
431				while (isspace(*buf))
432					++buf;
433				dev->res.irq_resource[nirq].start =
434				    dev->res.irq_resource[nirq].end =
435				    simple_strtoul(buf, &buf, 0);
436				dev->res.irq_resource[nirq].flags =
437				    IORESOURCE_IRQ;
438				nirq++;
439				if (nirq >= PNP_MAX_IRQ)
440					break;
441				continue;
442			}
443			if (!strnicmp(buf, "dma", 3)) {
444				buf += 3;
445				while (isspace(*buf))
446					++buf;
447				dev->res.dma_resource[ndma].start =
448				    dev->res.dma_resource[ndma].end =
449				    simple_strtoul(buf, &buf, 0);
450				dev->res.dma_resource[ndma].flags =
451				    IORESOURCE_DMA;
452				ndma++;
453				if (ndma >= PNP_MAX_DMA)
454					break;
455				continue;
456			}
457			break;
458		}
459		up(&pnp_res_mutex);
460		goto done;
461	}
462      done:
463	if (retval < 0)
464		return retval;
465	return count;
466}
467
468static DEVICE_ATTR(resources, S_IRUGO | S_IWUSR,
469		   pnp_show_current_resources, pnp_set_current_resources);
470
471static ssize_t pnp_show_current_ids(struct device *dmdev,
472				    struct device_attribute *attr, char *buf)
473{
474	char *str = buf;
475	struct pnp_dev *dev = to_pnp_dev(dmdev);
476	struct pnp_id *pos = dev->id;
477
478	while (pos) {
479		str += sprintf(str, "%s\n", pos->id);
480		pos = pos->next;
481	}
482	return (str - buf);
483}
484
485static DEVICE_ATTR(id, S_IRUGO, pnp_show_current_ids, NULL);
486
487int pnp_interface_attach_device(struct pnp_dev *dev)
488{
489	int rc = device_create_file(&dev->dev, &dev_attr_options);
490
491	if (rc)
492		goto err;
493	rc = device_create_file(&dev->dev, &dev_attr_resources);
494	if (rc)
495		goto err_opt;
496	rc = device_create_file(&dev->dev, &dev_attr_id);
497	if (rc)
498		goto err_res;
499
500	return 0;
501
502      err_res:
503	device_remove_file(&dev->dev, &dev_attr_resources);
504      err_opt:
505	device_remove_file(&dev->dev, &dev_attr_options);
506      err:
507	return rc;
508}
509