src/devices/bus_pci.c

/*
 *  Copyright (C) 2004-2005  Anders Gavare.  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 *  1. Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *  2. Redistributions in binary form must reproduce the above copyright  
 *     notice, this list of conditions and the following disclaimer in the 
 *     documentation and/or other materials provided with the distribution.
 *  3. The name of the author may not be used to endorse or promote products
 *     derived from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 *  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *  ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE   
 *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 *  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 *  OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 *  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 *  OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 *  SUCH DAMAGE.
 *   
 *
 *  $Id: bus_pci.c,v 1.12 2005/09/27 23:18:32 debug Exp $
 *  
 *  This is a generic PCI bus device, used by even lower level devices.
 *  For example, the "gt" device used in Cobalt machines contains a PCI
 *  device.
 *
 *  TODO:  This more or less just a dummy bus device, so far.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "memory.h"
#include "misc.h"

#include "bus_pci.h"

/*  #define debug fatal  */


/*
 *  bus_pci_access():
 *
 *  relative_addr should be either BUS_PCI_ADDR or BUS_PCI_DATA. The uint64_t
 *  pointed to by data should contain the word to be written to the pci bus,
 *  or a placeholder for information read from the bus.
 *
 *  Returns 1 if ok, 0 on error.
 */
int bus_pci_access(struct cpu *cpu, struct memory *mem, uint64_t relative_addr,
        uint64_t *data, int writeflag, struct pci_data *pci_data)
{
        struct pci_device *dev, *found;
        int bus, device, function, registernr;

        if (writeflag == MEM_READ)
                *data = 0;

        switch (relative_addr) {
        case BUS_PCI_ADDR:
                if (writeflag == MEM_WRITE) {
                        debug("[ bus_pci: write to  PCI ADDR: data = 0x%016llx"
                            " ]\n", (long long)*data);
                        pci_data->pci_addr = *data;
                } else {
                        debug("[ bus_pci: read from PCI ADDR (data = "
                            "0x%016llx) ]\n", (long long)pci_data->pci_addr);
                        *data = pci_data->pci_addr;
                }
                break;
        case BUS_PCI_DATA:
                if (writeflag == MEM_WRITE) {
                        debug("[ bus_pci: write to PCI DATA: data = "
                            "0x%016llx ]\n", (long long)*data);
                        if (*data == 0xffffffffULL)
                                pci_data->last_was_write_ffffffff = 1;
                } else {
                        /*  Get the bus, device, and function numbers from
                            the address:  */
                        bus        = (pci_data->pci_addr >> 16) & 0xff;
                        device     = (pci_data->pci_addr >> 11) & 0x1f;
                        function   = (pci_data->pci_addr >> 8)  & 0x7;
                        registernr = (pci_data->pci_addr)       & 0xff;

                        /*  Scan through the list of pci_device entries.  */
                        dev = pci_data->first_device;
                        found = NULL;

                        while (dev != NULL && found == NULL) {
                                if (dev->bus == bus &&
                                    dev->function == function &&
                                    dev->device == device)
                                        found = dev;
                                dev = dev->next;
                        }

                        if (found == NULL) {
                                if ((pci_data->pci_addr & 0xff) == 0)
                                        *data = 0xffffffff;
                                else
                                        *data = 0;
                                return 1;
                        }

                        *data = 0;

                        if (pci_data->last_was_write_ffffffff &&
                            registernr >= 0x10 && registernr <= 0x24) {
                                /*  TODO:  real length!!!  */
                                *data = 0x00400000 - 1;
                        } else if (found->read_register != NULL)
                                *data = found->read_register(registernr);

                        pci_data->last_was_write_ffffffff = 0;

                        debug("[ bus_pci: read from PCI DATA, addr = 0x%08lx "
                            "(bus %i, device %i, function %i, register "
                            "0x%02x): 0x%08lx ]\n", (long)pci_data->pci_addr,
                            bus, device, function, registernr, (long)*data);
                }

                break;
        default:
                if (writeflag==MEM_READ) {
                        debug("[ bus_pci: read from unimplemented addr "
                            "0x%x ]\n", (int)relative_addr);
                        *data = 0;
                } else {
                        debug("[ bus_pci: write to unimplemented addr "
                            "0x%x:", (int)relative_addr);
                }
        }

        return 1;
}


/*
 *  bus_pci_add():
 *
 *  Add a PCI device to a bus_pci device.
 */
void bus_pci_add(struct machine *machine, struct pci_data *pci_data,
        struct memory *mem, int bus, int device, int function,
        void (*init)(struct machine *, struct memory *),
        uint32_t (*read_register)(int reg))
{
        struct pci_device *new_device;

        if (pci_data == NULL) {
                fatal("bus_pci_add(): pci_data == NULL!\n");
                exit(1);
        }

        /*  Make sure this bus/device/function number isn't already in use:  */
        new_device = pci_data->first_device;
        while (new_device != NULL) {
                if (new_device->bus == bus &&
                    new_device->device == device &&
                    new_device->function == function) {
                        fatal("bus_pci_add(): (bus %i, device %i, function"
                            " %i) already in use\n", bus, device, function);
                        return;
                }
                new_device = new_device->next;
        }

        new_device = malloc(sizeof(struct pci_device));
        if (new_device == NULL) {
                fprintf(stderr, "out of memory\n");
                exit(1);
        }

        memset(new_device, 0, sizeof(struct pci_device));
        new_device->bus           = bus;
        new_device->device        = device;
        new_device->function      = function;
        new_device->init          = init;
        new_device->read_register = read_register;

        /*  Add the new device first in the PCI bus' chain:  */
        new_device->next = pci_data->first_device;
        pci_data->first_device = new_device;

        /*  Call the PCI device' init function:  */
        if (init != NULL)
                init(machine, mem);
}


/*
 *  bus_pci_init():
 *
 *  This doesn't register a device, but instead returns a pointer to a struct
 *  which should be passed to bus_pci_access() when accessing the PCI bus.
 */
struct pci_data *bus_pci_init(int irq_nr)
{
        struct pci_data *d;

        d = malloc(sizeof(struct pci_data));
        if (d == NULL) {
                fprintf(stderr, "out of memory\n");
                exit(1);
        }
        memset(d, 0, sizeof(struct pci_data));
        d->irq_nr = irq_nr;

        return d;
}

1	/*
2	* Copyright (C) 2004-2005 Anders Gavare. All rights reserved.
3	*
4	* Redistribution and use in source and binary forms, with or without
5	* modification, are permitted provided that the following conditions are met:
6	*
7	* 1. Redistributions of source code must retain the above copyright
8	* notice, this list of conditions and the following disclaimer.
9	* 2. Redistributions in binary form must reproduce the above copyright
10	* notice, this list of conditions and the following disclaimer in the
11	* documentation and/or other materials provided with the distribution.
12	* 3. The name of the author may not be used to endorse or promote products
13	* derived from this software without specific prior written permission.
14	*
15	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18	* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25	* SUCH DAMAGE.
26	*
27	*
28	* $Id: bus_pci.c,v 1.12 2005/09/27 23:18:32 debug Exp $
29	*
30	* This is a generic PCI bus device, used by even lower level devices.
31	* For example, the "gt" device used in Cobalt machines contains a PCI
32	* device.
33	*
34	* TODO: This more or less just a dummy bus device, so far.
35	*/
36
37	#include <stdio.h>
38	#include <stdlib.h>
39	#include <string.h>
40
41	#include "memory.h"
42	#include "misc.h"
43
44	#include "bus_pci.h"
45
46	/* #define debug fatal */
47
48
49	/*
50	* bus_pci_access():
51	*
52	* relative_addr should be either BUS_PCI_ADDR or BUS_PCI_DATA. The uint64_t
53	* pointed to by data should contain the word to be written to the pci bus,
54	* or a placeholder for information read from the bus.
55	*
56	* Returns 1 if ok, 0 on error.
57	*/
58	int bus_pci_access(struct cpu cpu, struct memory mem, uint64_t relative_addr,
59	uint64_t data, int writeflag, struct pci_data pci_data)
60	{
61	struct pci_device dev, found;
62	int bus, device, function, registernr;
63
64	if (writeflag == MEM_READ)
65	*data = 0;
66
67	switch (relative_addr) {
68	case BUS_PCI_ADDR:
69	if (writeflag == MEM_WRITE) {
70	debug("[ bus_pci: write to PCI ADDR: data = 0x%016llx"
71	" ]\n", (long long)*data);
72	pci_data->pci_addr = *data;
73	} else {
74	debug("[ bus_pci: read from PCI ADDR (data = "
75	"0x%016llx) ]\n", (long long)pci_data->pci_addr);
76	*data = pci_data->pci_addr;
77	}
78	break;
79	case BUS_PCI_DATA:
80	if (writeflag == MEM_WRITE) {
81	debug("[ bus_pci: write to PCI DATA: data = "
82	"0x%016llx ]\n", (long long)*data);
83	if (*data == 0xffffffffULL)
84	pci_data->last_was_write_ffffffff = 1;
85	} else {
86	/* Get the bus, device, and function numbers from
87	the address: */
88	bus = (pci_data->pci_addr >> 16) & 0xff;
89	device = (pci_data->pci_addr >> 11) & 0x1f;
90	function = (pci_data->pci_addr >> 8) & 0x7;
91	registernr = (pci_data->pci_addr) & 0xff;
92
93	/* Scan through the list of pci_device entries. */
94	dev = pci_data->first_device;
95	found = NULL;
96
97	while (dev != NULL && found == NULL) {
98	if (dev->bus == bus &&
99	dev->function == function &&
100	dev->device == device)
101	found = dev;
102	dev = dev->next;
103	}
104
105	if (found == NULL) {
106	if ((pci_data->pci_addr & 0xff) == 0)
107	*data = 0xffffffff;
108	else
109	*data = 0;
110	return 1;
111	}
112
113	*data = 0;
114
115	if (pci_data->last_was_write_ffffffff &&
116	registernr >= 0x10 && registernr <= 0x24) {
117	/* TODO: real length!!! */
118	*data = 0x00400000 - 1;
119	} else if (found->read_register != NULL)
120	*data = found->read_register(registernr);
121
122	pci_data->last_was_write_ffffffff = 0;
123
124	debug("[ bus_pci: read from PCI DATA, addr = 0x%08lx "
125	"(bus %i, device %i, function %i, register "
126	"0x%02x): 0x%08lx ]\n", (long)pci_data->pci_addr,
127	bus, device, function, registernr, (long)*data);
128	}
129
130	break;
131	default:
132	if (writeflag==MEM_READ) {
133	debug("[ bus_pci: read from unimplemented addr "
134	"0x%x ]\n", (int)relative_addr);
135	*data = 0;
136	} else {
137	debug("[ bus_pci: write to unimplemented addr "
138	"0x%x:", (int)relative_addr);
139	}
140	}
141
142	return 1;
143	}
144
145
146	/*
147	* bus_pci_add():
148	*
149	* Add a PCI device to a bus_pci device.
150	*/
151	void bus_pci_add(struct machine machine, struct pci_data pci_data,
152	struct memory *mem, int bus, int device, int function,
153	void (init)(struct machine , struct memory *),
154	uint32_t (*read_register)(int reg))
155	{
156	struct pci_device *new_device;
157
158	if (pci_data == NULL) {
159	fatal("bus_pci_add(): pci_data == NULL!\n");
160	exit(1);
161	}
162
163	/* Make sure this bus/device/function number isn't already in use: */
164	new_device = pci_data->first_device;
165	while (new_device != NULL) {
166	if (new_device->bus == bus &&
167	new_device->device == device &&
168	new_device->function == function) {
169	fatal("bus_pci_add(): (bus %i, device %i, function"
170	" %i) already in use\n", bus, device, function);
171	return;
172	}
173	new_device = new_device->next;
174	}
175
176	new_device = malloc(sizeof(struct pci_device));
177	if (new_device == NULL) {
178	fprintf(stderr, "out of memory\n");
179	exit(1);
180	}
181
182	memset(new_device, 0, sizeof(struct pci_device));
183	new_device->bus = bus;
184	new_device->device = device;
185	new_device->function = function;
186	new_device->init = init;
187	new_device->read_register = read_register;
188
189	/* Add the new device first in the PCI bus' chain: */
190	new_device->next = pci_data->first_device;
191	pci_data->first_device = new_device;
192
193	/* Call the PCI device' init function: */
194	if (init != NULL)
195	init(machine, mem);
196	}
197
198
199	/*
200	* bus_pci_init():
201	*
202	* This doesn't register a device, but instead returns a pointer to a struct
203	* which should be passed to bus_pci_access() when accessing the PCI bus.
204	*/
205	struct pci_data *bus_pci_init(int irq_nr)
206	{
207	struct pci_data *d;
208
209	d = malloc(sizeof(struct pci_data));
210	if (d == NULL) {
211	fprintf(stderr, "out of memory\n");
212	exit(1);
213	}
214	memset(d, 0, sizeof(struct pci_data));
215	d->irq_nr = irq_nr;
216
217	return d;
218	}
219