WebSVN – HelenOS – Diff – /tags/0.1.1/uspace/pci/libpci/access.c


/*
 *  The PCI Library -- User Access
 *
 *  Copyright (c) 1997--2003 Martin Mares <mj@ucw.cz>
 *
 *  May 8, 2006 - Modified and ported to HelenOS by Jakub Jermar.
 *
 *  Can be freely distributed and used under the terms of the GNU GPL.
 */
 
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
 
#include "internal.h"
 
static struct pci_methods *pci_methods[PCI_ACCESS_MAX] = {
    &pm_intel_conf1,
    &pm_intel_conf2,
};
 
struct pci_access *pci_alloc(void)
{
    struct pci_access *a = malloc(sizeof(struct pci_access));
    int i;
 
    if (!a)
        return NULL;
       
    bzero(a, sizeof(*a));
    for (i = 0; i < PCI_ACCESS_MAX; i++)
        if (pci_methods[i] && pci_methods[i]->config)
            pci_methods[i]->config(a);
    return a;
}
 
void *pci_malloc(struct pci_access *a, int size)
{
    void *x = malloc(size);
 
    if (!x)
        a->error("Out of memory (allocation of %d bytes failed)", size);
    return x;
}
 
void pci_mfree(void *x)
{
    if (x)
        free(x);
}
 
static void pci_generic_error(char *msg, ...)
{
    va_list args;
 
    va_start(args, msg);
    puts("pcilib: ");
    vprintf(msg, args);
    putchar('\n');
    exit(1);
}
 
static void pci_generic_warn(char *msg, ...)
{
    va_list args;
 
    va_start(args, msg);
    puts("pcilib: ");
    vprintf(msg, args);
    putchar('\n');
}
 
static void pci_generic_debug(char *msg, ...)
{
    va_list args;
 
    va_start(args, msg);
    vprintf(msg, args);
    va_end(args);
}
 
static void pci_null_debug(char *msg UNUSED, ...)
{
}
 
void pci_init(struct pci_access *a)
{
    if (!a->error)
        a->error = pci_generic_error;
    if (!a->warning)
        a->warning = pci_generic_warn;
    if (!a->debug)
        a->debug = pci_generic_debug;
    if (!a->debugging)
        a->debug = pci_null_debug;
 
    if (a->method) {
        if (a->method >= PCI_ACCESS_MAX || !pci_methods[a->method])
            a->error("This access method is not supported.");
        a->methods = pci_methods[a->method];
    } else {
        unsigned int i;
        for (i = 0; i < PCI_ACCESS_MAX; i++)
            if (pci_methods[i]) {
                a->debug("Trying method %d...", i);
                if (pci_methods[i]->detect(a)) {
                    a->debug("...OK\n");
                    a->methods = pci_methods[i];
                    a->method = i;
                    break;
                }
                a->debug("...No.\n");
            }
        if (!a->methods)
            a->error("Cannot find any working access method.");
    }
    a->debug("Decided to use %s\n", a->methods->name);
    a->methods->init(a);
}
 
void pci_cleanup(struct pci_access *a)
{
    struct pci_dev *d, *e;
 
    for (d = a->devices; d; d = e) {
        e = d->next;
        pci_free_dev(d);
    }
    if (a->methods)
        a->methods->cleanup(a);
    pci_free_name_list(a);
    pci_mfree(a);
}
 
void pci_scan_bus(struct pci_access *a)
{
    a->methods->scan(a);
}
 
struct pci_dev *pci_alloc_dev(struct pci_access *a)
{
    struct pci_dev *d = pci_malloc(a, sizeof(struct pci_dev));
 
    bzero(d, sizeof(*d));
    d->access = a;
    d->methods = a->methods;
    d->hdrtype = -1;
    if (d->methods->init_dev)
        d->methods->init_dev(d);
    return d;
}
 
int pci_link_dev(struct pci_access *a, struct pci_dev *d)
{
    d->next = a->devices;
    a->devices = d;
 
    return 1;
}
 
struct pci_dev *pci_get_dev(struct pci_access *a, int domain, int bus,
                int dev, int func)
{
    struct pci_dev *d = pci_alloc_dev(a);
 
    d->domain = domain;
    d->bus = bus;
    d->dev = dev;
    d->func = func;
    return d;
}
 
void pci_free_dev(struct pci_dev *d)
{
    if (d->methods->cleanup_dev)
        d->methods->cleanup_dev(d);
    pci_mfree(d);
}
 
static inline void
pci_read_data(struct pci_dev *d, void *buf, int pos, int len)
{
    if (pos & (len - 1))
        d->access->error("Unaligned read: pos=%02x, len=%d", pos,
                 len);
    if (pos + len <= d->cache_len)
        memcpy(buf, d->cache + pos, len);
    else if (!d->methods->read(d, pos, buf, len))
        memset(buf, 0xff, len);
}
 
byte pci_read_byte(struct pci_dev *d, int pos)
{
    byte buf;
    pci_read_data(d, &buf, pos, 1);
    return buf;
}
 
word pci_read_word(struct pci_dev * d, int pos)
{
    word buf;
    pci_read_data(d, &buf, pos, 2);
    return le16_to_cpu(buf);
}
 
u32 pci_read_long(struct pci_dev * d, int pos)
{
    u32 buf;
    pci_read_data(d, &buf, pos, 4);
    return le32_to_cpu(buf);
}
 
int pci_read_block(struct pci_dev *d, int pos, byte * buf, int len)
{
    return d->methods->read(d, pos, buf, len);
}
 
static inline int
pci_write_data(struct pci_dev *d, void *buf, int pos, int len)
{
    if (pos & (len - 1))
        d->access->error("Unaligned write: pos=%02x,len=%d", pos, len);
    if (pos + len <= d->cache_len)
        memcpy(d->cache + pos, buf, len);
    return d->methods->write(d, pos, buf, len);
}
 
int pci_write_byte(struct pci_dev *d, int pos, byte data)
{
    return pci_write_data(d, &data, pos, 1);
}
 
int pci_write_word(struct pci_dev *d, int pos, word data)
{
    word buf = cpu_to_le16(data);
    return pci_write_data(d, &buf, pos, 2);
}
 
int pci_write_long(struct pci_dev *d, int pos, u32 data)
{
    u32 buf = cpu_to_le32(data);
    return pci_write_data(d, &buf, pos, 4);
}
 
int pci_write_block(struct pci_dev *d, int pos, byte * buf, int len)
{
    if (pos < d->cache_len) {
        int l = (pos + len >= d->cache_len) ? (d->cache_len - pos) : len;
        memcpy(d->cache + pos, buf, l);
    }
    return d->methods->write(d, pos, buf, len);
}
 
int pci_fill_info(struct pci_dev *d, int flags)
{
    if (flags & PCI_FILL_RESCAN) {
        flags &= ~PCI_FILL_RESCAN;
        d->known_fields = 0;
    }
    if (flags & ~d->known_fields)
        d->known_fields |= d->methods->fill_info(d, flags & ~d->known_fields);
    return d->known_fields;
}
 
void pci_setup_cache(struct pci_dev *d, byte * cache, int len)
{
    d->cache = cache;
    d->cache_len = len;
}
 

Rev 1963	Rev 1968
1	/*	1	/*
2	* The PCI Library -- User Access	2	* The PCI Library -- User Access
3	*	3	*
4	* Copyright (c) 1997--2003 Martin Mares <mj@ucw.cz>	4	* Copyright (c) 1997--2003 Martin Mares <mj@ucw.cz>
5	*	5	*
6	* May 8, 2006 - Modified and ported to HelenOS by Jakub Jermar.	6	* May 8, 2006 - Modified and ported to HelenOS by Jakub Jermar.
7	*	7	*
8	* Can be freely distributed and used under the terms of the GNU GPL.	8	* Can be freely distributed and used under the terms of the GNU GPL.
9	*/	9	*/
10		10
11	#include <stdio.h>	11	#include <stdio.h>
12	#include <stdlib.h>	12	#include <stdlib.h>
13	#include <stdarg.h>	13	#include <stdarg.h>
14	#include <string.h>	14	#include <string.h>
15		15
16	#include "internal.h"	16	#include "internal.h"
17		17
18	static struct pci_methods *pci_methods[PCI_ACCESS_MAX] = {	18	static struct pci_methods *pci_methods[PCI_ACCESS_MAX] = {
19	&pm_intel_conf1,	19	&pm_intel_conf1,
20	&pm_intel_conf2,	20	&pm_intel_conf2,
21	};	21	};
22		22
23	struct pci_access *pci_alloc(void)	23	struct pci_access *pci_alloc(void)
24	{	24	{
25	struct pci_access *a = malloc(sizeof(struct pci_access));	25	struct pci_access *a = malloc(sizeof(struct pci_access));
26	int i;	26	int i;
27		27
28	if (!a)	28	if (!a)
29	return NULL;	29	return NULL;
30		30
31	bzero(a, sizeof(*a));	31	bzero(a, sizeof(*a));
32	for (i = 0; i < PCI_ACCESS_MAX; i++)	32	for (i = 0; i < PCI_ACCESS_MAX; i++)
33	if (pci_methods[i] && pci_methods[i]->config)	33	if (pci_methods[i] && pci_methods[i]->config)
34	pci_methods[i]->config(a);	34	pci_methods[i]->config(a);
35	return a;	35	return a;
36	}	36	}
37		37
38	void pci_malloc(struct pci_access a, int size)	38	void pci_malloc(struct pci_access a, int size)
39	{	39	{
40	void *x = malloc(size);	40	void *x = malloc(size);
41		41
42	if (!x)	42	if (!x)
43	a->error("Out of memory (allocation of %d bytes failed)", size);	43	a->error("Out of memory (allocation of %d bytes failed)", size);
44	return x;	44	return x;
45	}	45	}
46		46
47	void pci_mfree(void *x)	47	void pci_mfree(void *x)
48	{	48	{
49	if (x)	49	if (x)
50	free(x);	50	free(x);
51	}	51	}
52		52
53	static void pci_generic_error(char *msg, ...)	53	static void pci_generic_error(char *msg, ...)
54	{	54	{
55	va_list args;	55	va_list args;
56		56
57	va_start(args, msg);	57	va_start(args, msg);
58	puts("pcilib: ");	58	puts("pcilib: ");
59	vprintf(msg, args);	59	vprintf(msg, args);
60	putchar('\n');	60	putchar('\n');
61	exit(1);	61	exit(1);
62	}	62	}
63		63
64	static void pci_generic_warn(char *msg, ...)	64	static void pci_generic_warn(char *msg, ...)
65	{	65	{
66	va_list args;	66	va_list args;
67		67
68	va_start(args, msg);	68	va_start(args, msg);
69	puts("pcilib: ");	69	puts("pcilib: ");
70	vprintf(msg, args);	70	vprintf(msg, args);
71	putchar('\n');	71	putchar('\n');
72	}	72	}
73		73
74	static void pci_generic_debug(char *msg, ...)	74	static void pci_generic_debug(char *msg, ...)
75	{	75	{
76	va_list args;	76	va_list args;
77		77
78	va_start(args, msg);	78	va_start(args, msg);
79	vprintf(msg, args);	79	vprintf(msg, args);
80	va_end(args);	80	va_end(args);
81	}	81	}
82		82
83	static void pci_null_debug(char *msg UNUSED, ...)	83	static void pci_null_debug(char *msg UNUSED, ...)
84	{	84	{
85	}	85	}
86		86
87	void pci_init(struct pci_access *a)	87	void pci_init(struct pci_access *a)
88	{	88	{
89	if (!a->error)	89	if (!a->error)
90	a->error = pci_generic_error;	90	a->error = pci_generic_error;
91	if (!a->warning)	91	if (!a->warning)
92	a->warning = pci_generic_warn;	92	a->warning = pci_generic_warn;
93	if (!a->debug)	93	if (!a->debug)
94	a->debug = pci_generic_debug;	94	a->debug = pci_generic_debug;
95	if (!a->debugging)	95	if (!a->debugging)
96	a->debug = pci_null_debug;	96	a->debug = pci_null_debug;
97		97
98	if (a->method) {	98	if (a->method) {
99	if (a->method >= PCI_ACCESS_MAX \|\| !pci_methods[a->method])	99	if (a->method >= PCI_ACCESS_MAX \|\| !pci_methods[a->method])
100	a->error("This access method is not supported.");	100	a->error("This access method is not supported.");
101	a->methods = pci_methods[a->method];	101	a->methods = pci_methods[a->method];
102	} else {	102	} else {
103	unsigned int i;	103	unsigned int i;
104	for (i = 0; i < PCI_ACCESS_MAX; i++)	104	for (i = 0; i < PCI_ACCESS_MAX; i++)
105	if (pci_methods[i]) {	105	if (pci_methods[i]) {
106	a->debug("Trying method %d...", i);	106	a->debug("Trying method %d...", i);
107	if (pci_methods[i]->detect(a)) {	107	if (pci_methods[i]->detect(a)) {
108	a->debug("...OK\n");	108	a->debug("...OK\n");
109	a->methods = pci_methods[i];	109	a->methods = pci_methods[i];
110	a->method = i;	110	a->method = i;
111	break;	111	break;
112	}	112	}
113	a->debug("...No.\n");	113	a->debug("...No.\n");
114	}	114	}
115	if (!a->methods)	115	if (!a->methods)
116	a->error("Cannot find any working access method.");	116	a->error("Cannot find any working access method.");
117	}	117	}
118	a->debug("Decided to use %s\n", a->methods->name);	118	a->debug("Decided to use %s\n", a->methods->name);
119	a->methods->init(a);	119	a->methods->init(a);
120	}	120	}
121		121
122	void pci_cleanup(struct pci_access *a)	122	void pci_cleanup(struct pci_access *a)
123	{	123	{
124	struct pci_dev d, e;	124	struct pci_dev d, e;
125		125
126	for (d = a->devices; d; d = e) {	126	for (d = a->devices; d; d = e) {
127	e = d->next;	127	e = d->next;
128	pci_free_dev(d);	128	pci_free_dev(d);
129	}	129	}
130	if (a->methods)	130	if (a->methods)
131	a->methods->cleanup(a);	131	a->methods->cleanup(a);
132	pci_free_name_list(a);	132	pci_free_name_list(a);
133	pci_mfree(a);	133	pci_mfree(a);
134	}	134	}
135		135
136	void pci_scan_bus(struct pci_access *a)	136	void pci_scan_bus(struct pci_access *a)
137	{	137	{
138	a->methods->scan(a);	138	a->methods->scan(a);
139	}	139	}
140		140
141	struct pci_dev pci_alloc_dev(struct pci_access a)	141	struct pci_dev pci_alloc_dev(struct pci_access a)
142	{	142	{
143	struct pci_dev *d = pci_malloc(a, sizeof(struct pci_dev));	143	struct pci_dev *d = pci_malloc(a, sizeof(struct pci_dev));
144		144
145	bzero(d, sizeof(*d));	145	bzero(d, sizeof(*d));
146	d->access = a;	146	d->access = a;
147	d->methods = a->methods;	147	d->methods = a->methods;
148	d->hdrtype = -1;	148	d->hdrtype = -1;
149	if (d->methods->init_dev)	149	if (d->methods->init_dev)
150	d->methods->init_dev(d);	150	d->methods->init_dev(d);
151	return d;	151	return d;
152	}	152	}
153		153
154	int pci_link_dev(struct pci_access a, struct pci_dev d)	154	int pci_link_dev(struct pci_access a, struct pci_dev d)
155	{	155	{
156	d->next = a->devices;	156	d->next = a->devices;
157	a->devices = d;	157	a->devices = d;
158		158
159	return 1;	159	return 1;
160	}	160	}
161		161
162	struct pci_dev pci_get_dev(struct pci_access a, int domain, int bus,	162	struct pci_dev pci_get_dev(struct pci_access a, int domain, int bus,
163	int dev, int func)	163	int dev, int func)
164	{	164	{
165	struct pci_dev *d = pci_alloc_dev(a);	165	struct pci_dev *d = pci_alloc_dev(a);
166		166
167	d->domain = domain;	167	d->domain = domain;
168	d->bus = bus;	168	d->bus = bus;
169	d->dev = dev;	169	d->dev = dev;
170	d->func = func;	170	d->func = func;
171	return d;	171	return d;
172	}	172	}
173		173
174	void pci_free_dev(struct pci_dev *d)	174	void pci_free_dev(struct pci_dev *d)
175	{	175	{
176	if (d->methods->cleanup_dev)	176	if (d->methods->cleanup_dev)
177	d->methods->cleanup_dev(d);	177	d->methods->cleanup_dev(d);
178	pci_mfree(d);	178	pci_mfree(d);
179	}	179	}
180		180
181	static inline void	181	static inline void
182	pci_read_data(struct pci_dev d, void buf, int pos, int len)	182	pci_read_data(struct pci_dev d, void buf, int pos, int len)
183	{	183	{
184	if (pos & (len - 1))	184	if (pos & (len - 1))
185	d->access->error("Unaligned read: pos=%02x, len=%d", pos,	185	d->access->error("Unaligned read: pos=%02x, len=%d", pos,
186	len);	186	len);
187	if (pos + len <= d->cache_len)	187	if (pos + len <= d->cache_len)
188	memcpy(buf, d->cache + pos, len);	188	memcpy(buf, d->cache + pos, len);
189	else if (!d->methods->read(d, pos, buf, len))	189	else if (!d->methods->read(d, pos, buf, len))
190	memset(buf, 0xff, len);	190	memset(buf, 0xff, len);
191	}	191	}
192		192
193	byte pci_read_byte(struct pci_dev *d, int pos)	193	byte pci_read_byte(struct pci_dev *d, int pos)
194	{	194	{
195	byte buf;	195	byte buf;
196	pci_read_data(d, &buf, pos, 1);	196	pci_read_data(d, &buf, pos, 1);
197	return buf;	197	return buf;
198	}	198	}
199		199
200	word pci_read_word(struct pci_dev * d, int pos)	200	word pci_read_word(struct pci_dev * d, int pos)
201	{	201	{
202	word buf;	202	word buf;
203	pci_read_data(d, &buf, pos, 2);	203	pci_read_data(d, &buf, pos, 2);
204	return le16_to_cpu(buf);	204	return le16_to_cpu(buf);
205	}	205	}
206		206
207	u32 pci_read_long(struct pci_dev * d, int pos)	207	u32 pci_read_long(struct pci_dev * d, int pos)
208	{	208	{
209	u32 buf;	209	u32 buf;
210	pci_read_data(d, &buf, pos, 4);	210	pci_read_data(d, &buf, pos, 4);
211	return le32_to_cpu(buf);	211	return le32_to_cpu(buf);
212	}	212	}
213		213
214	int pci_read_block(struct pci_dev d, int pos, byte buf, int len)	214	int pci_read_block(struct pci_dev d, int pos, byte buf, int len)
215	{	215	{
216	return d->methods->read(d, pos, buf, len);	216	return d->methods->read(d, pos, buf, len);
217	}	217	}
218		218
219	static inline int	219	static inline int
220	pci_write_data(struct pci_dev d, void buf, int pos, int len)	220	pci_write_data(struct pci_dev d, void buf, int pos, int len)
221	{	221	{
222	if (pos & (len - 1))	222	if (pos & (len - 1))
223	d->access->error("Unaligned write: pos=%02x,len=%d", pos, len);	223	d->access->error("Unaligned write: pos=%02x,len=%d", pos, len);
224	if (pos + len <= d->cache_len)	224	if (pos + len <= d->cache_len)
225	memcpy(d->cache + pos, buf, len);	225	memcpy(d->cache + pos, buf, len);
226	return d->methods->write(d, pos, buf, len);	226	return d->methods->write(d, pos, buf, len);
227	}	227	}
228		228
229	int pci_write_byte(struct pci_dev *d, int pos, byte data)	229	int pci_write_byte(struct pci_dev *d, int pos, byte data)
230	{	230	{
231	return pci_write_data(d, &data, pos, 1);	231	return pci_write_data(d, &data, pos, 1);
232	}	232	}
233		233
234	int pci_write_word(struct pci_dev *d, int pos, word data)	234	int pci_write_word(struct pci_dev *d, int pos, word data)
235	{	235	{
236	word buf = cpu_to_le16(data);	236	word buf = cpu_to_le16(data);
237	return pci_write_data(d, &buf, pos, 2);	237	return pci_write_data(d, &buf, pos, 2);
238	}	238	}
239		239
240	int pci_write_long(struct pci_dev *d, int pos, u32 data)	240	int pci_write_long(struct pci_dev *d, int pos, u32 data)
241	{	241	{
242	u32 buf = cpu_to_le32(data);	242	u32 buf = cpu_to_le32(data);
243	return pci_write_data(d, &buf, pos, 4);	243	return pci_write_data(d, &buf, pos, 4);
244	}	244	}
245		245
246	int pci_write_block(struct pci_dev d, int pos, byte buf, int len)	246	int pci_write_block(struct pci_dev d, int pos, byte buf, int len)
247	{	247	{
248	if (pos < d->cache_len) {	248	if (pos < d->cache_len) {
249	int l = (pos + len >= d->cache_len) ? (d->cache_len - pos) : len;	249	int l = (pos + len >= d->cache_len) ? (d->cache_len - pos) : len;
250	memcpy(d->cache + pos, buf, l);	250	memcpy(d->cache + pos, buf, l);
251	}	251	}
252	return d->methods->write(d, pos, buf, len);	252	return d->methods->write(d, pos, buf, len);
253	}	253	}
254		254
255	int pci_fill_info(struct pci_dev *d, int flags)	255	int pci_fill_info(struct pci_dev *d, int flags)
256	{	256	{
257	if (flags & PCI_FILL_RESCAN) {	257	if (flags & PCI_FILL_RESCAN) {
258	flags &= ~PCI_FILL_RESCAN;	258	flags &= ~PCI_FILL_RESCAN;
259	d->known_fields = 0;	259	d->known_fields = 0;
260	}	260	}
261	if (flags & ~d->known_fields)	261	if (flags & ~d->known_fields)
262	d->known_fields \|= d->methods->fill_info(d, flags & ~d->known_fields);	262	d->known_fields \|= d->methods->fill_info(d, flags & ~d->known_fields);
263	return d->known_fields;	263	return d->known_fields;
264	}	264	}
265		265
266	void pci_setup_cache(struct pci_dev d, byte cache, int len)	266	void pci_setup_cache(struct pci_dev d, byte cache, int len)
267	{	267	{
268	d->cache = cache;	268	d->cache = cache;
269	d->cache_len = len;	269	d->cache_len = len;
270	}	270	}
271		271

Subversion Repositories HelenOS

(root)/tags/0.1.1/uspace/pci/libpci/access.c – Rev 1963 → 1968