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	dpavlin	4	/*
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	dpavlin	14	* $Id: bus_pci.c,v 1.12 2005/09/27 23:18:32 debug Exp $
29	dpavlin	4	*
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	dpavlin	14	/* #define debug fatal */
47	dpavlin	4
48	dpavlin	14
49	dpavlin	4	/*
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	dpavlin	14	if (pci_data == NULL) {
159			fatal("bus_pci_add(): pci_data == NULL!\n");
160			exit(1);
161			}
162
163	dpavlin	4	/* 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