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

Subversion Repositories HelenOS

(root)/branches/dd/uspace/srv/pci/libpci/access.c – Rev 3022 → 4221