src/devices/dev_mpc40x.c

/*
 *  Copyright (C) 2005-2007  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: dev_cpc700.c,v 1.10 2007/01/29 19:03:16 debug Exp $
 *  
 *  IBM CPC700 bridge; PCI and interrupt controller.
 */

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

#include "bus_pci.h"
#include "cpu.h"
#include "device.h"
#include "machine.h"
#include "memory.h"
#include "misc.h"

#include "cpc700reg.h"


struct cpc700_data {
        struct interrupt ppc_irq;       /*  Connected to the CPU  */

        uint32_t        sr;             /*  Interrupt Status register  */
        uint32_t        er;             /*  Interrupt Enable register  */

        struct pci_data *pci_data;      /*  PCI bus  */
};


void cpc700_interrupt_assert(struct interrupt *interrupt)
{
        struct cpc700_data *d = interrupt->extra;
        d->sr |= (1 << interrupt->line);
        if (d->sr & d->er)
                INTERRUPT_ASSERT(d->ppc_irq);
}
void cpc700_interrupt_deassert(struct interrupt *interrupt)
{
        struct cpc700_data *d = interrupt->extra;
        d->sr &= ~(1 << interrupt->line);
        if (!(d->sr & d->er))
                INTERRUPT_DEASSERT(d->ppc_irq);
}


/*
 *  dev_cpc700_pci_access():
 *
 *  Passes PCI indirect addr and data accesses onto bus_pci.
 */
DEVICE_ACCESS(cpc700_pci)
{
        uint64_t idata = 0, odata = 0;
        int bus, dev, func, reg;
        struct cpc700_data *d = extra;

        if (writeflag == MEM_WRITE)
                idata = memory_readmax64(cpu, data, len|MEM_PCI_LITTLE_ENDIAN);

        switch (relative_addr) {
        case 0: /*  Address:  */
                bus_pci_decompose_1(idata, &bus, &dev, &func, &reg);
                bus_pci_setaddr(cpu, d->pci_data, bus, dev, func, reg);
                break;

        case 4: /*  Data:  */
                bus_pci_data_access(cpu, d->pci_data, writeflag == MEM_READ?
                    &odata : &idata, len, writeflag);
                break;
        }

        if (writeflag == MEM_READ)
                memory_writemax64(cpu, data, len|MEM_PCI_LITTLE_ENDIAN, odata);

        return 1;
}


/*
 *  dev_cpc700_int_access():
 *
 *  The interrupt controller.
 */
DEVICE_ACCESS(cpc700_int)
{
        struct cpc700_data *d = extra;
        uint64_t idata = 0, odata = 0;

        if (writeflag == MEM_WRITE)
                idata = memory_readmax64(cpu, data, len);

        switch (relative_addr) {

        case CPC_UIC_SR:
                /*  Status register (cleared by writing ones):  */
                if (writeflag == MEM_READ) {
                        odata = d->sr;
                } else {
                        d->sr &= ~idata;
                        if (!(d->sr & d->er))
                                INTERRUPT_DEASSERT(d->ppc_irq);
                }
                break;

        case CPC_UIC_SRS:
                /*  Status register set:  */
                if (writeflag == MEM_READ) {
                        fatal("[ cpc700_int: read from CPC_UIC_SRS? ]\n");
                        odata = d->sr;
                } else {
                        d->sr = idata;
                        if (d->sr & d->er)
                                INTERRUPT_ASSERT(d->ppc_irq);
                        else
                                INTERRUPT_DEASSERT(d->ppc_irq);
                }
                break;

        case CPC_UIC_ER:
                /*  Enable register:  */
                if (writeflag == MEM_READ) {
                        odata = d->er;
                } else {
                        d->er = idata;
                        if (d->sr & d->er)
                                INTERRUPT_ASSERT(d->ppc_irq);
                        else
                                INTERRUPT_DEASSERT(d->ppc_irq);
                }
                break;

        case CPC_UIC_MSR:
                /*  Masked status:  */
                if (writeflag == MEM_READ) {
                        odata = d->sr & d->er;
                } else {
                        fatal("[ cpc700_int: write to CPC_UIC_MSR? ]\n");
                }
                break;

        default:if (writeflag == MEM_WRITE) {
                        fatal("[ cpc700_int: unimplemented write to "
                            "offset 0x%x: data=0x%x ]\n", (int)
                            relative_addr, (int)idata);
                } else {
                        fatal("[ cpc700_int: unimplemented read from "
                            "offset 0x%x ]\n", (int)relative_addr);
                }
        }

        if (writeflag == MEM_READ)
                memory_writemax64(cpu, data, len, odata);

        return 1;
}


DEVINIT(cpc700)
{
        struct cpc700_data *d;
        char tmp[300];
        int i;

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

        /*  Connect to the CPU's interrupt pin:  */
        INTERRUPT_CONNECT(devinit->interrupt_path, d->ppc_irq);

        /*  Register 32 CPC700 interrupts:  */
        for (i=0; i<32; i++) {
                struct interrupt template;
                char n[300];
                snprintf(n, sizeof(n), "%s.cpc700.%i",
                    devinit->interrupt_path, i);
                memset(&template, 0, sizeof(template));
                template.line = i;
                template.name = n;
                template.extra = d;
                template.interrupt_assert = cpc700_interrupt_assert;
                template.interrupt_deassert = cpc700_interrupt_deassert;
                interrupt_handler_register(&template);
        }

        /*  Register a PCI bus:  */
        snprintf(tmp, sizeof(tmp), "%s.cpc700", devinit->interrupt_path);
        d->pci_data = bus_pci_init(
            devinit->machine,
            tmp,                /*  pciirq path  */
            0,                  /*  pci device io offset  */
            0,                  /*  pci device mem offset  */
            CPC_PCI_IO_BASE,    /*  PCI portbase  */
            CPC_PCI_MEM_BASE,   /*  PCI membase: TODO  */
            tmp,                /*  PCI irqbase  */
            0,                  /*  ISA portbase: TODO  */
            0,                  /*  ISA membase: TODO  */
            tmp);               /*  ISA irqbase  */

        switch (devinit->machine->machine_type) {

        case MACHINE_PMPPC:
                bus_pci_add(devinit->machine, d->pci_data,
                    devinit->machine->memory, 0, 0, 0, "heuricon_pmppc");
                break;

        default:fatal("!\n! WARNING: cpc700 for non-implemented machine"
                    " type\n!\n");
                exit(1);
        }

        /*  PCI configuration registers:  */
        memory_device_register(devinit->machine->memory, "cpc700_pci",
            CPC_PCICFGADR, 8, dev_cpc700_pci_access, d, DM_DEFAULT, NULL);

        /*  Interrupt controller:  */
        memory_device_register(devinit->machine->memory, "cpc700_int",
            CPC_UIC_BASE, CPC_UIC_SIZE, dev_cpc700_int_access, d,
            DM_DEFAULT, NULL);

        /*  Two serial ports:  */
        snprintf(tmp, sizeof(tmp), "ns16550 irq=%s.cpc700.%i addr=0x%llx "
            "name2=tty0", devinit->interrupt_path, 31 - CPC_IB_UART_0,
            (long long)CPC_COM0);
        devinit->machine->main_console_handle = (size_t)
            device_add(devinit->machine, tmp);
        snprintf(tmp, sizeof(tmp), "ns16550 irq=%s.cpc700.%i addr=0x%llx "
            "name2=tty1", devinit->interrupt_path, 31 - CPC_IB_UART_1,
            (long long)CPC_COM1);
        device_add(devinit->machine, tmp);

        devinit->return_ptr = d->pci_data;

        return 1;
}

1	/*
2	* Copyright (C) 2005-2007 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: dev_cpc700.c,v 1.10 2007/01/29 19:03:16 debug Exp $
29	*
30	* IBM CPC700 bridge; PCI and interrupt controller.
31	*/
32
33	#include <stdio.h>
34	#include <stdlib.h>
35	#include <string.h>
36
37	#include "bus_pci.h"
38	#include "cpu.h"
39	#include "device.h"
40	#include "machine.h"
41	#include "memory.h"
42	#include "misc.h"
43
44	#include "cpc700reg.h"
45
46
47	struct cpc700_data {
48	struct interrupt ppc_irq; /* Connected to the CPU */
49
50	uint32_t sr; /* Interrupt Status register */
51	uint32_t er; /* Interrupt Enable register */
52
53	struct pci_data pci_data; / PCI bus */
54	};
55
56
57	void cpc700_interrupt_assert(struct interrupt *interrupt)
58	{
59	struct cpc700_data *d = interrupt->extra;
60	d->sr \|= (1 << interrupt->line);
61	if (d->sr & d->er)
62	INTERRUPT_ASSERT(d->ppc_irq);
63	}
64	void cpc700_interrupt_deassert(struct interrupt *interrupt)
65	{
66	struct cpc700_data *d = interrupt->extra;
67	d->sr &= ~(1 << interrupt->line);
68	if (!(d->sr & d->er))
69	INTERRUPT_DEASSERT(d->ppc_irq);
70	}
71
72
73	/*
74	* dev_cpc700_pci_access():
75	*
76	* Passes PCI indirect addr and data accesses onto bus_pci.
77	*/
78	DEVICE_ACCESS(cpc700_pci)
79	{
80	uint64_t idata = 0, odata = 0;
81	int bus, dev, func, reg;
82	struct cpc700_data *d = extra;
83
84	if (writeflag == MEM_WRITE)
85	idata = memory_readmax64(cpu, data, len\|MEM_PCI_LITTLE_ENDIAN);
86
87	switch (relative_addr) {
88	case 0: /* Address: */
89	bus_pci_decompose_1(idata, &bus, &dev, &func, &reg);
90	bus_pci_setaddr(cpu, d->pci_data, bus, dev, func, reg);
91	break;
92
93	case 4: /* Data: */
94	bus_pci_data_access(cpu, d->pci_data, writeflag == MEM_READ?
95	&odata : &idata, len, writeflag);
96	break;
97	}
98
99	if (writeflag == MEM_READ)
100	memory_writemax64(cpu, data, len\|MEM_PCI_LITTLE_ENDIAN, odata);
101
102	return 1;
103	}
104
105
106	/*
107	* dev_cpc700_int_access():
108	*
109	* The interrupt controller.
110	*/
111	DEVICE_ACCESS(cpc700_int)
112	{
113	struct cpc700_data *d = extra;
114	uint64_t idata = 0, odata = 0;
115
116	if (writeflag == MEM_WRITE)
117	idata = memory_readmax64(cpu, data, len);
118
119	switch (relative_addr) {
120
121	case CPC_UIC_SR:
122	/* Status register (cleared by writing ones): */
123	if (writeflag == MEM_READ) {
124	odata = d->sr;
125	} else {
126	d->sr &= ~idata;
127	if (!(d->sr & d->er))
128	INTERRUPT_DEASSERT(d->ppc_irq);
129	}
130	break;
131
132	case CPC_UIC_SRS:
133	/* Status register set: */
134	if (writeflag == MEM_READ) {
135	fatal("[ cpc700_int: read from CPC_UIC_SRS? ]\n");
136	odata = d->sr;
137	} else {
138	d->sr = idata;
139	if (d->sr & d->er)
140	INTERRUPT_ASSERT(d->ppc_irq);
141	else
142	INTERRUPT_DEASSERT(d->ppc_irq);
143	}
144	break;
145
146	case CPC_UIC_ER:
147	/* Enable register: */
148	if (writeflag == MEM_READ) {
149	odata = d->er;
150	} else {
151	d->er = idata;
152	if (d->sr & d->er)
153	INTERRUPT_ASSERT(d->ppc_irq);
154	else
155	INTERRUPT_DEASSERT(d->ppc_irq);
156	}
157	break;
158
159	case CPC_UIC_MSR:
160	/* Masked status: */
161	if (writeflag == MEM_READ) {
162	odata = d->sr & d->er;
163	} else {
164	fatal("[ cpc700_int: write to CPC_UIC_MSR? ]\n");
165	}
166	break;
167
168	default:if (writeflag == MEM_WRITE) {
169	fatal("[ cpc700_int: unimplemented write to "
170	"offset 0x%x: data=0x%x ]\n", (int)
171	relative_addr, (int)idata);
172	} else {
173	fatal("[ cpc700_int: unimplemented read from "
174	"offset 0x%x ]\n", (int)relative_addr);
175	}
176	}
177
178	if (writeflag == MEM_READ)
179	memory_writemax64(cpu, data, len, odata);
180
181	return 1;
182	}
183
184
185	DEVINIT(cpc700)
186	{
187	struct cpc700_data *d;
188	char tmp[300];
189	int i;
190
191	d = malloc(sizeof(struct cpc700_data));
192	if (d == NULL) {
193	fprintf(stderr, "out of memory\n");
194	exit(1);
195	}
196	memset(d, 0, sizeof(struct cpc700_data));
197
198	/* Connect to the CPU's interrupt pin: */
199	INTERRUPT_CONNECT(devinit->interrupt_path, d->ppc_irq);
200
201	/* Register 32 CPC700 interrupts: */
202	for (i=0; i<32; i++) {
203	struct interrupt template;
204	char n[300];
205	snprintf(n, sizeof(n), "%s.cpc700.%i",
206	devinit->interrupt_path, i);
207	memset(&template, 0, sizeof(template));
208	template.line = i;
209	template.name = n;
210	template.extra = d;
211	template.interrupt_assert = cpc700_interrupt_assert;
212	template.interrupt_deassert = cpc700_interrupt_deassert;
213	interrupt_handler_register(&template);
214	}
215
216	/* Register a PCI bus: */
217	snprintf(tmp, sizeof(tmp), "%s.cpc700", devinit->interrupt_path);
218	d->pci_data = bus_pci_init(
219	devinit->machine,
220	tmp, /* pciirq path */
221	0, /* pci device io offset */
222	0, /* pci device mem offset */
223	CPC_PCI_IO_BASE, /* PCI portbase */
224	CPC_PCI_MEM_BASE, /* PCI membase: TODO */
225	tmp, /* PCI irqbase */
226	0, /* ISA portbase: TODO */
227	0, /* ISA membase: TODO */
228	tmp); /* ISA irqbase */
229
230	switch (devinit->machine->machine_type) {
231
232	case MACHINE_PMPPC:
233	bus_pci_add(devinit->machine, d->pci_data,
234	devinit->machine->memory, 0, 0, 0, "heuricon_pmppc");
235	break;
236
237	default:fatal("!\n! WARNING: cpc700 for non-implemented machine"
238	" type\n!\n");
239	exit(1);
240	}
241
242	/* PCI configuration registers: */
243	memory_device_register(devinit->machine->memory, "cpc700_pci",
244	CPC_PCICFGADR, 8, dev_cpc700_pci_access, d, DM_DEFAULT, NULL);
245
246	/* Interrupt controller: */
247	memory_device_register(devinit->machine->memory, "cpc700_int",
248	CPC_UIC_BASE, CPC_UIC_SIZE, dev_cpc700_int_access, d,
249	DM_DEFAULT, NULL);
250
251	/* Two serial ports: */
252	snprintf(tmp, sizeof(tmp), "ns16550 irq=%s.cpc700.%i addr=0x%llx "
253	"name2=tty0", devinit->interrupt_path, 31 - CPC_IB_UART_0,
254	(long long)CPC_COM0);
255	devinit->machine->main_console_handle = (size_t)
256	device_add(devinit->machine, tmp);
257	snprintf(tmp, sizeof(tmp), "ns16550 irq=%s.cpc700.%i addr=0x%llx "
258	"name2=tty1", devinit->interrupt_path, 31 - CPC_IB_UART_1,
259	(long long)CPC_COM1);
260	device_add(devinit->machine, tmp);
261
262	devinit->return_ptr = d->pci_data;
263
264	return 1;
265	}
266