WebSVN – HelenOS – Diff – /branches/dd/uspace/srv/pci/libpci/generic.c


/*
 *  The PCI Library -- Generic Direct Access Functions
 *
 *  Copyright (c) 1997--2000 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 <string.h>
 
#include "internal.h"
 
void pci_generic_scan_bus(struct pci_access *a, byte * busmap, int bus)
{
    int dev, multi, ht;
    struct pci_dev *t;
 
    a->debug("Scanning bus %02x for devices...\n", bus);
    if (busmap[bus]) {
        a->warning("Bus %02x seen twice (firmware bug). Ignored.",
               bus);
        return;
    }
    busmap[bus] = 1;
    t = pci_alloc_dev(a);
    t->bus = bus;
    for (dev = 0; dev < 32; dev++) {
        t->dev = dev;
        multi = 0;
        for (t->func = 0; !t->func || multi && t->func < 8;
             t->func++) {
            u32 vd = pci_read_long(t, PCI_VENDOR_ID);
            struct pci_dev *d;
 
            if (!vd || vd == 0xffffffff)
                continue;
            ht = pci_read_byte(t, PCI_HEADER_TYPE);
            if (!t->func)
                multi = ht & 0x80;
            ht &= 0x7f;
            d = pci_alloc_dev(a);
            d->bus = t->bus;
            d->dev = t->dev;
            d->func = t->func;
            d->vendor_id = vd & 0xffff;
            d->device_id = vd >> 16U;
            d->known_fields = PCI_FILL_IDENT;
            d->hdrtype = ht;
            pci_link_dev(a, d);
           
            switch (ht) {
            case PCI_HEADER_TYPE_NORMAL:
                break;
            case PCI_HEADER_TYPE_BRIDGE:
            case PCI_HEADER_TYPE_CARDBUS:
                pci_generic_scan_bus(a, busmap,
                             pci_read_byte(t,
                                   PCI_SECONDARY_BUS));
                break;
            default:
                a->debug
                    ("Device %04x:%02x:%02x.%d has unknown header type %02x.\n",
                     d->domain, d->bus, d->dev, d->func,
                     ht);
            }
        }
    }
    pci_free_dev(t);
}
 
void pci_generic_scan(struct pci_access *a)
{
    byte busmap[256];
 
    bzero(busmap, sizeof(busmap));
    pci_generic_scan_bus(a, busmap, 0);
}
 
int pci_generic_fill_info(struct pci_dev *d, int flags)
{
    struct pci_access *a = d->access;
 
    if ((flags & (PCI_FILL_BASES | PCI_FILL_ROM_BASE))
        && d->hdrtype < 0)
        d->hdrtype = pci_read_byte(d, PCI_HEADER_TYPE) & 0x7f;
    if (flags & PCI_FILL_IDENT) {
        d->vendor_id = pci_read_word(d, PCI_VENDOR_ID);
        d->device_id = pci_read_word(d, PCI_DEVICE_ID);
    }
    if (flags & PCI_FILL_IRQ)
        d->irq = pci_read_byte(d, PCI_INTERRUPT_LINE);
    if (flags & PCI_FILL_BASES) {
        int cnt = 0, i;
        bzero(d->base_addr, sizeof(d->base_addr));
        switch (d->hdrtype) {
        case PCI_HEADER_TYPE_NORMAL:
            cnt = 6;
            break;
        case PCI_HEADER_TYPE_BRIDGE:
            cnt = 2;
            break;
        case PCI_HEADER_TYPE_CARDBUS:
            cnt = 1;
            break;
        }
        if (cnt) {
            for (i = 0; i < cnt; i++) {
                u32 x = pci_read_long(d, PCI_BASE_ADDRESS_0 + i * 4);
                if (!x || x == (u32) ~ 0)
                    continue;
                if ((x & PCI_BASE_ADDRESS_SPACE) == PCI_BASE_ADDRESS_SPACE_IO)
                    d->base_addr[i] = x;
                else {
                    if ((x & PCI_BASE_ADDRESS_MEM_TYPE_MASK) != PCI_BASE_ADDRESS_MEM_TYPE_64)
                        d->base_addr[i] = x;
                    else if (i >= cnt - 1)
                        a->warning("%04x:%02x:%02x.%d: Invalid 64-bit address seen for BAR %d.",
                             d->domain, d->bus,
                             d->dev, d->func, i);
                    else {
                        u32 y = pci_read_long(d, PCI_BASE_ADDRESS_0 + (++i) * 4);
#ifdef PCI_HAVE_64BIT_ADDRESS
                        d->base_addr[i - 1] = x | (((pciaddr_t) y) << 32);
#else
                        if (y)
                            a->warning("%04x:%02x:%02x.%d 64-bit device address ignored.",
                                 d->domain,
                                 d->bus,
                                 d->dev,
                                 d->func);
                        else
                            d->base_addr[i - 1] = x;
#endif
                    }
                }
            }
        }
    }
    if (flags & PCI_FILL_ROM_BASE) {
        int reg = 0;
        d->rom_base_addr = 0;
        switch (d->hdrtype) {
        case PCI_HEADER_TYPE_NORMAL:
            reg = PCI_ROM_ADDRESS;
            break;
        case PCI_HEADER_TYPE_BRIDGE:
            reg = PCI_ROM_ADDRESS1;
            break;
        }
        if (reg) {
            u32 u = pci_read_long(d, reg);
            if (u != 0xffffffff)
                d->rom_base_addr = u;
        }
    }
    return flags & ~PCI_FILL_SIZES;
}
 
static int
pci_generic_block_op(struct pci_dev *d, int pos, byte * buf, int len,
             int (*r) (struct pci_dev * d, int pos, byte * buf,
                   int len))
{
    if ((pos & 1) && len >= 1) {
        if (!r(d, pos, buf, 1))
            return 0;
        pos++;
        buf++;
        len--;
    }
    if ((pos & 3) && len >= 2) {
        if (!r(d, pos, buf, 2))
            return 0;
        pos += 2;
        buf += 2;
        len -= 2;
    }
    while (len >= 4) {
        if (!r(d, pos, buf, 4))
            return 0;
        pos += 4;
        buf += 4;
        len -= 4;
    }
    if (len >= 2) {
        if (!r(d, pos, buf, 2))
            return 0;
        pos += 2;
        buf += 2;
        len -= 2;
    }
    if (len && !r(d, pos, buf, 1))
        return 0;
    return 1;
}
 
int pci_generic_block_read(struct pci_dev *d, int pos, byte * buf, int len)
{
    return pci_generic_block_op(d, pos, buf, len, d->access->methods->read);
}
 
int pci_generic_block_write(struct pci_dev *d, int pos, byte * buf, int len)
{
    return pci_generic_block_op(d, pos, buf, len, d->access->methods->write);
}
 

Rev 3022	Rev 4295
1	/*	1	/*
2	* The PCI Library -- Generic Direct Access Functions	2	* The PCI Library -- Generic Direct Access Functions
3	*	3	*
4	* Copyright (c) 1997--2000 Martin Mares <mj@ucw.cz>	4	* Copyright (c) 1997--2000 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 <string.h>	11	#include <string.h>
12		12
13	#include "internal.h"	13	#include "internal.h"
14		14
15	void pci_generic_scan_bus(struct pci_access a, byte busmap, int bus)	15	void pci_generic_scan_bus(struct pci_access a, byte busmap, int bus)
16	{	16	{
17	int dev, multi, ht;	17	int dev, multi, ht;
18	struct pci_dev *t;	18	struct pci_dev *t;
19		19
20	a->debug("Scanning bus %02x for devices...\n", bus);	20	a->debug("Scanning bus %02x for devices...\n", bus);
21	if (busmap[bus]) {	21	if (busmap[bus]) {
22	a->warning("Bus %02x seen twice (firmware bug). Ignored.",	22	a->warning("Bus %02x seen twice (firmware bug). Ignored.",
23	bus);	23	bus);
24	return;	24	return;
25	}	25	}
26	busmap[bus] = 1;	26	busmap[bus] = 1;
27	t = pci_alloc_dev(a);	27	t = pci_alloc_dev(a);
28	t->bus = bus;	28	t->bus = bus;
29	for (dev = 0; dev < 32; dev++) {	29	for (dev = 0; dev < 32; dev++) {
30	t->dev = dev;	30	t->dev = dev;
31	multi = 0;	31	multi = 0;
32	for (t->func = 0; !t->func \|\| multi && t->func < 8;	32	for (t->func = 0; !t->func \|\| multi && t->func < 8;
33	t->func++) {	33	t->func++) {
34	u32 vd = pci_read_long(t, PCI_VENDOR_ID);	34	u32 vd = pci_read_long(t, PCI_VENDOR_ID);
35	struct pci_dev *d;	35	struct pci_dev *d;
36		36
37	if (!vd \|\| vd == 0xffffffff)	37	if (!vd \|\| vd == 0xffffffff)
38	continue;	38	continue;
39	ht = pci_read_byte(t, PCI_HEADER_TYPE);	39	ht = pci_read_byte(t, PCI_HEADER_TYPE);
40	if (!t->func)	40	if (!t->func)
41	multi = ht & 0x80;	41	multi = ht & 0x80;
42	ht &= 0x7f;	42	ht &= 0x7f;
43	d = pci_alloc_dev(a);	43	d = pci_alloc_dev(a);
44	d->bus = t->bus;	44	d->bus = t->bus;
45	d->dev = t->dev;	45	d->dev = t->dev;
46	d->func = t->func;	46	d->func = t->func;
47	d->vendor_id = vd & 0xffff;	47	d->vendor_id = vd & 0xffff;
48	d->device_id = vd >> 16U;	48	d->device_id = vd >> 16U;
49	d->known_fields = PCI_FILL_IDENT;	49	d->known_fields = PCI_FILL_IDENT;
50	d->hdrtype = ht;	50	d->hdrtype = ht;
51	pci_link_dev(a, d);	51	pci_link_dev(a, d);
-		52
52	switch (ht) {	53	switch (ht) {
53	case PCI_HEADER_TYPE_NORMAL:	54	case PCI_HEADER_TYPE_NORMAL:
54	break;	55	break;
55	case PCI_HEADER_TYPE_BRIDGE:	56	case PCI_HEADER_TYPE_BRIDGE:
56	case PCI_HEADER_TYPE_CARDBUS:	57	case PCI_HEADER_TYPE_CARDBUS:
57	pci_generic_scan_bus(a, busmap,	58	pci_generic_scan_bus(a, busmap,
58	pci_read_byte(t,	59	pci_read_byte(t,
59	PCI_SECONDARY_BUS));	60	PCI_SECONDARY_BUS));
60	break;	61	break;
61	default:	62	default:
62	a->debug	63	a->debug
63	("Device %04x:%02x:%02x.%d has unknown header type %02x.\n",	64	("Device %04x:%02x:%02x.%d has unknown header type %02x.\n",
64	d->domain, d->bus, d->dev, d->func,	65	d->domain, d->bus, d->dev, d->func,
65	ht);	66	ht);
66	}	67	}
67	}	68	}
68	}	69	}
69	pci_free_dev(t);	70	pci_free_dev(t);
70	}	71	}
71		72
72	void pci_generic_scan(struct pci_access *a)	73	void pci_generic_scan(struct pci_access *a)
73	{	74	{
74	byte busmap[256];	75	byte busmap[256];
75		76
76	bzero(busmap, sizeof(busmap));	77	bzero(busmap, sizeof(busmap));
77	pci_generic_scan_bus(a, busmap, 0);	78	pci_generic_scan_bus(a, busmap, 0);
78	}	79	}
79		80
80	int pci_generic_fill_info(struct pci_dev *d, int flags)	81	int pci_generic_fill_info(struct pci_dev *d, int flags)
81	{	82	{
82	struct pci_access *a = d->access;	83	struct pci_access *a = d->access;
83		84
84	if ((flags & (PCI_FILL_BASES \| PCI_FILL_ROM_BASE))	85	if ((flags & (PCI_FILL_BASES \| PCI_FILL_ROM_BASE))
85	&& d->hdrtype < 0)	86	&& d->hdrtype < 0)
86	d->hdrtype = pci_read_byte(d, PCI_HEADER_TYPE) & 0x7f;	87	d->hdrtype = pci_read_byte(d, PCI_HEADER_TYPE) & 0x7f;
87	if (flags & PCI_FILL_IDENT) {	88	if (flags & PCI_FILL_IDENT) {
88	d->vendor_id = pci_read_word(d, PCI_VENDOR_ID);	89	d->vendor_id = pci_read_word(d, PCI_VENDOR_ID);
89	d->device_id = pci_read_word(d, PCI_DEVICE_ID);	90	d->device_id = pci_read_word(d, PCI_DEVICE_ID);
90	}	91	}
91	if (flags & PCI_FILL_IRQ)	92	if (flags & PCI_FILL_IRQ)
92	d->irq = pci_read_byte(d, PCI_INTERRUPT_LINE);	93	d->irq = pci_read_byte(d, PCI_INTERRUPT_LINE);
93	if (flags & PCI_FILL_BASES) {	94	if (flags & PCI_FILL_BASES) {
94	int cnt = 0, i;	95	int cnt = 0, i;
95	bzero(d->base_addr, sizeof(d->base_addr));	96	bzero(d->base_addr, sizeof(d->base_addr));
96	switch (d->hdrtype) {	97	switch (d->hdrtype) {
97	case PCI_HEADER_TYPE_NORMAL:	98	case PCI_HEADER_TYPE_NORMAL:
98	cnt = 6;	99	cnt = 6;
99	break;	100	break;
100	case PCI_HEADER_TYPE_BRIDGE:	101	case PCI_HEADER_TYPE_BRIDGE:
101	cnt = 2;	102	cnt = 2;
102	break;	103	break;
103	case PCI_HEADER_TYPE_CARDBUS:	104	case PCI_HEADER_TYPE_CARDBUS:
104	cnt = 1;	105	cnt = 1;
105	break;	106	break;
106	}	107	}
107	if (cnt) {	108	if (cnt) {
108	for (i = 0; i < cnt; i++) {	109	for (i = 0; i < cnt; i++) {
109	u32 x = pci_read_long(d, PCI_BASE_ADDRESS_0 + i * 4);	110	u32 x = pci_read_long(d, PCI_BASE_ADDRESS_0 + i * 4);
110	if (!x \|\| x == (u32) ~ 0)	111	if (!x \|\| x == (u32) ~ 0)
111	continue;	112	continue;
112	if ((x & PCI_BASE_ADDRESS_SPACE) == PCI_BASE_ADDRESS_SPACE_IO)	113	if ((x & PCI_BASE_ADDRESS_SPACE) == PCI_BASE_ADDRESS_SPACE_IO)
113	d->base_addr[i] = x;	114	d->base_addr[i] = x;
114	else {	115	else {
115	if ((x & PCI_BASE_ADDRESS_MEM_TYPE_MASK) != PCI_BASE_ADDRESS_MEM_TYPE_64)	116	if ((x & PCI_BASE_ADDRESS_MEM_TYPE_MASK) != PCI_BASE_ADDRESS_MEM_TYPE_64)
116	d->base_addr[i] = x;	117	d->base_addr[i] = x;
117	else if (i >= cnt - 1)	118	else if (i >= cnt - 1)
118	a->warning("%04x:%02x:%02x.%d: Invalid 64-bit address seen for BAR %d.",	119	a->warning("%04x:%02x:%02x.%d: Invalid 64-bit address seen for BAR %d.",
119	d->domain, d->bus,	120	d->domain, d->bus,
120	d->dev, d->func, i);	121	d->dev, d->func, i);
121	else {	122	else {
122	u32 y = pci_read_long(d, PCI_BASE_ADDRESS_0 + (++i) * 4);	123	u32 y = pci_read_long(d, PCI_BASE_ADDRESS_0 + (++i) * 4);
123	#ifdef PCI_HAVE_64BIT_ADDRESS	124	#ifdef PCI_HAVE_64BIT_ADDRESS
124	d->base_addr[i - 1] = x \| (((pciaddr_t) y) << 32);	125	d->base_addr[i - 1] = x \| (((pciaddr_t) y) << 32);
125	#else	126	#else
126	if (y)	127	if (y)
127	a->warning("%04x:%02x:%02x.%d 64-bit device address ignored.",	128	a->warning("%04x:%02x:%02x.%d 64-bit device address ignored.",
128	d->domain,	129	d->domain,
129	d->bus,	130	d->bus,
130	d->dev,	131	d->dev,
131	d->func);	132	d->func);
132	else	133	else
133	d->base_addr[i - 1] = x;	134	d->base_addr[i - 1] = x;
134	#endif	135	#endif
135	}	136	}
136	}	137	}
137	}	138	}
138	}	139	}
139	}	140	}
140	if (flags & PCI_FILL_ROM_BASE) {	141	if (flags & PCI_FILL_ROM_BASE) {
141	int reg = 0;	142	int reg = 0;
142	d->rom_base_addr = 0;	143	d->rom_base_addr = 0;
143	switch (d->hdrtype) {	144	switch (d->hdrtype) {
144	case PCI_HEADER_TYPE_NORMAL:	145	case PCI_HEADER_TYPE_NORMAL:
145	reg = PCI_ROM_ADDRESS;	146	reg = PCI_ROM_ADDRESS;
146	break;	147	break;
147	case PCI_HEADER_TYPE_BRIDGE:	148	case PCI_HEADER_TYPE_BRIDGE:
148	reg = PCI_ROM_ADDRESS1;	149	reg = PCI_ROM_ADDRESS1;
149	break;	150	break;
150	}	151	}
151	if (reg) {	152	if (reg) {
152	u32 u = pci_read_long(d, reg);	153	u32 u = pci_read_long(d, reg);
153	if (u != 0xffffffff)	154	if (u != 0xffffffff)
154	d->rom_base_addr = u;	155	d->rom_base_addr = u;
155	}	156	}
156	}	157	}
157	return flags & ~PCI_FILL_SIZES;	158	return flags & ~PCI_FILL_SIZES;
158	}	159	}
159		160
160	static int	161	static int
161	pci_generic_block_op(struct pci_dev d, int pos, byte buf, int len,	162	pci_generic_block_op(struct pci_dev d, int pos, byte buf, int len,
162	int (r) (struct pci_dev d, int pos, byte * buf,	163	int (r) (struct pci_dev d, int pos, byte * buf,
163	int len))	164	int len))
164	{	165	{
165	if ((pos & 1) && len >= 1) {	166	if ((pos & 1) && len >= 1) {
166	if (!r(d, pos, buf, 1))	167	if (!r(d, pos, buf, 1))
167	return 0;	168	return 0;
168	pos++;	169	pos++;
169	buf++;	170	buf++;
170	len--;	171	len--;
171	}	172	}
172	if ((pos & 3) && len >= 2) {	173	if ((pos & 3) && len >= 2) {
173	if (!r(d, pos, buf, 2))	174	if (!r(d, pos, buf, 2))
174	return 0;	175	return 0;
175	pos += 2;	176	pos += 2;
176	buf += 2;	177	buf += 2;
177	len -= 2;	178	len -= 2;
178	}	179	}
179	while (len >= 4) {	180	while (len >= 4) {
180	if (!r(d, pos, buf, 4))	181	if (!r(d, pos, buf, 4))
181	return 0;	182	return 0;
182	pos += 4;	183	pos += 4;
183	buf += 4;	184	buf += 4;
184	len -= 4;	185	len -= 4;
185	}	186	}
186	if (len >= 2) {	187	if (len >= 2) {
187	if (!r(d, pos, buf, 2))	188	if (!r(d, pos, buf, 2))
188	return 0;	189	return 0;
189	pos += 2;	190	pos += 2;
190	buf += 2;	191	buf += 2;
191	len -= 2;	192	len -= 2;
192	}	193	}
193	if (len && !r(d, pos, buf, 1))	194	if (len && !r(d, pos, buf, 1))
194	return 0;	195	return 0;
195	return 1;	196	return 1;
196	}	197	}
197		198
198	int pci_generic_block_read(struct pci_dev d, int pos, byte buf, int len)	199	int pci_generic_block_read(struct pci_dev d, int pos, byte buf, int len)
199	{	200	{
200	return pci_generic_block_op(d, pos, buf, len, d->access->methods->read);	201	return pci_generic_block_op(d, pos, buf, len, d->access->methods->read);
201	}	202	}
202		203
203	int pci_generic_block_write(struct pci_dev d, int pos, byte buf, int len)	204	int pci_generic_block_write(struct pci_dev d, int pos, byte buf, int len)
204	{	205	{
205	return pci_generic_block_op(d, pos, buf, len, d->access->methods->write);	206	return pci_generic_block_op(d, pos, buf, len, d->access->methods->write);
206	}	207	}
207		208

Subversion Repositories HelenOS

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