src/devices/dev_rtl8139c.c

/*
 *  Copyright (C) 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_rtl8139c.c,v 1.3 2007/04/22 03:57:38 debug Exp $
 *
 *  Realtek 8139-style NIC.
 *
 *  TODO: Pretty much everything.
 */

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

#include "cpu.h"
#include "device.h"
#include "emul.h"
#include "interrupt.h"
#include "machine.h"
#include "memory.h"
#include "misc.h"
#include "net.h"


#include "rtl81x9reg.h"


#define DEV_RTL8139C_LENGTH     0x100
#define EEPROM_SIZE             0x100

struct rtl8139c_data {
        struct interrupt        irq;
        unsigned char           macaddr[6];

        /*  Registers:  */
        uint8_t                 rl_command;
        uint8_t                 rl_eecmd;

        /*  EEPROM:  */
        int                     eeprom_address_width;
        int                     eeprom_selected;
        int8_t                  eeprom_cur_cmd_bit;
        uint16_t                eeprom_cur_cmd;
        uint16_t                eeprom_cur_data;
        uint16_t                eeprom_reg[EEPROM_SIZE];
};


/*
 *  eeprom_clk():
 *
 *  Called whenever the eeprom CLK bit is toggled from 0 to 1.
 */
static void eeprom_clk(struct rtl8139c_data *d)
{
        int data_in = d->rl_eecmd & RL_EE_DATAIN? 1 : 0;

        if (d->eeprom_cur_cmd_bit < d->eeprom_address_width + 4) {
                d->eeprom_cur_cmd <<= 1;
                d->eeprom_cur_cmd |= data_in;
        }

        if (d->eeprom_cur_cmd_bit == d->eeprom_address_width + 3) {
                int cmd = d->eeprom_cur_cmd >> d->eeprom_address_width;
                int addr = d->eeprom_cur_cmd & ((1<<d->eeprom_address_width)-1);

                debug("[ rtl8139c eeprom cmd=0x%x addr=0x%02x ]\n", cmd, addr);

                switch (cmd) {

                case RL_9346_READ:
                        d->eeprom_cur_data = d->eeprom_reg[addr % EEPROM_SIZE];
                        break;

                default:fatal("[ rtl8139c eeprom: only the read command has"
                            " been implemented. sorry. ]\n");
                        exit(1);
                }
        }

        /*  Data output: (Note: Only the READ command has been implemented.)  */
        if (d->eeprom_cur_cmd_bit >= d->eeprom_address_width + 4) {
                int cur_out_bit = d->eeprom_cur_cmd_bit -
                    (d->eeprom_address_width + 4);
                int bit = d->eeprom_cur_data & (1 << (15-cur_out_bit));

                if (bit)
                        d->rl_eecmd |= RL_EE_DATAOUT;
                else
                        d->rl_eecmd &= ~RL_EE_DATAOUT;
        }

        d->eeprom_cur_cmd_bit ++;

        if (d->eeprom_cur_cmd_bit >= d->eeprom_address_width + 4 + 16) {
                d->eeprom_cur_cmd = 0;
                d->eeprom_cur_cmd_bit = 0;
        }
}


DEVICE_ACCESS(rtl8139c)
{
        struct rtl8139c_data *d = (struct rtl8139c_data *) extra;
        uint64_t idata = 0, odata = 0;

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

        switch (relative_addr) {

        case RL_COMMAND:
                if (writeflag == MEM_WRITE) {
                        if (idata & RL_CMD_RESET) {
                                /*  Reset. TODO  */

                                /*  ... and then clear the reset bit:  */
                                idata &= ~RL_CMD_RESET;
                        }

                        d->rl_command = idata;
                } else {
                        odata = d->rl_command;
                }
                break;

        case RL_EECMD:
                if (writeflag == MEM_WRITE) {
                        uint8_t old = d->rl_eecmd;
                        d->rl_eecmd = idata;

                        if (!d->eeprom_selected && d->rl_eecmd & RL_EE_SEL) {
                                /*  Reset eeprom cmd bit state:  */
                                d->eeprom_cur_cmd = 0;
                                d->eeprom_cur_cmd_bit = 0;
                        }
                        d->eeprom_selected = d->rl_eecmd & RL_EE_SEL;

                        if (idata & RL_EE_CLK && !(old & RL_EE_CLK))
                                eeprom_clk(d);
                } else {
                        odata = d->rl_eecmd;
                }
                break;

        case 0x82:
                /*  Unknown address, but OpenBSD's re driver writes
                    a 0x01 to this address, in re_reset().  */
                if (writeflag == MEM_WRITE) {
                        if (idata != 0x01) {
                                fatal("rtl8139c: unimplemented write to"
                                    " register 0x82.\n");
                                exit(1);
                        }
                }
                break;

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

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

        return 1;
}


DEVINIT(rtl8139c)
{
        char *name2;
        size_t nlen = 100;
        struct rtl8139c_data *d = malloc(sizeof(struct rtl8139c_data));

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

        INTERRUPT_CONNECT(devinit->interrupt_path, d->irq);

        net_generate_unique_mac(devinit->machine, d->macaddr);

        /*  TODO: eeprom address width = 6 on 8129?  */
        d->eeprom_address_width = 8;
        d->eeprom_reg[0] = 0x8139;
        d->eeprom_reg[7] = d->macaddr[0] + (d->macaddr[1] << 8);
        d->eeprom_reg[8] = d->macaddr[2] + (d->macaddr[3] << 8);
        d->eeprom_reg[9] = d->macaddr[4] + (d->macaddr[5] << 8);

        name2 = malloc(nlen);
        if (name2 == NULL) {
                fprintf(stderr, "out of memory\n");
                exit(1);
        }
        snprintf(name2, nlen, "%s [%02x:%02x:%02x:%02x:%02x:%02x]",
            devinit->name, d->macaddr[0], d->macaddr[1], d->macaddr[2],
            d->macaddr[3], d->macaddr[4], d->macaddr[5]);

        memory_device_register(devinit->machine->memory, name2,
            devinit->addr, DEV_RTL8139C_LENGTH, dev_rtl8139c_access, (void *)d,
            DM_DEFAULT, NULL);

        net_add_nic(devinit->machine->emul->net, d, d->macaddr);

        return 1;
}

1	/*
2	* Copyright (C) 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_rtl8139c.c,v 1.3 2007/04/22 03:57:38 debug Exp $
29	*
30	* Realtek 8139-style NIC.
31	*
32	* TODO: Pretty much everything.
33	*/
34
35	#include <stdio.h>
36	#include <stdlib.h>
37	#include <string.h>
38
39	#include "cpu.h"
40	#include "device.h"
41	#include "emul.h"
42	#include "interrupt.h"
43	#include "machine.h"
44	#include "memory.h"
45	#include "misc.h"
46	#include "net.h"
47
48
49	#include "rtl81x9reg.h"
50
51
52	#define DEV_RTL8139C_LENGTH 0x100
53	#define EEPROM_SIZE 0x100
54
55	struct rtl8139c_data {
56	struct interrupt irq;
57	unsigned char macaddr[6];
58
59	/* Registers: */
60	uint8_t rl_command;
61	uint8_t rl_eecmd;
62
63	/* EEPROM: */
64	int eeprom_address_width;
65	int eeprom_selected;
66	int8_t eeprom_cur_cmd_bit;
67	uint16_t eeprom_cur_cmd;
68	uint16_t eeprom_cur_data;
69	uint16_t eeprom_reg[EEPROM_SIZE];
70	};
71
72
73	/*
74	* eeprom_clk():
75	*
76	* Called whenever the eeprom CLK bit is toggled from 0 to 1.
77	*/
78	static void eeprom_clk(struct rtl8139c_data *d)
79	{
80	int data_in = d->rl_eecmd & RL_EE_DATAIN? 1 : 0;
81
82	if (d->eeprom_cur_cmd_bit < d->eeprom_address_width + 4) {
83	d->eeprom_cur_cmd <<= 1;
84	d->eeprom_cur_cmd \|= data_in;
85	}
86
87	if (d->eeprom_cur_cmd_bit == d->eeprom_address_width + 3) {
88	int cmd = d->eeprom_cur_cmd >> d->eeprom_address_width;
89	int addr = d->eeprom_cur_cmd & ((1<<d->eeprom_address_width)-1);
90
91	debug("[ rtl8139c eeprom cmd=0x%x addr=0x%02x ]\n", cmd, addr);
92
93	switch (cmd) {
94
95	case RL_9346_READ:
96	d->eeprom_cur_data = d->eeprom_reg[addr % EEPROM_SIZE];
97	break;
98
99	default:fatal("[ rtl8139c eeprom: only the read command has"
100	" been implemented. sorry. ]\n");
101	exit(1);
102	}
103	}
104
105	/* Data output: (Note: Only the READ command has been implemented.) */
106	if (d->eeprom_cur_cmd_bit >= d->eeprom_address_width + 4) {
107	int cur_out_bit = d->eeprom_cur_cmd_bit -
108	(d->eeprom_address_width + 4);
109	int bit = d->eeprom_cur_data & (1 << (15-cur_out_bit));
110
111	if (bit)
112	d->rl_eecmd \|= RL_EE_DATAOUT;
113	else
114	d->rl_eecmd &= ~RL_EE_DATAOUT;
115	}
116
117	d->eeprom_cur_cmd_bit ++;
118
119	if (d->eeprom_cur_cmd_bit >= d->eeprom_address_width + 4 + 16) {
120	d->eeprom_cur_cmd = 0;
121	d->eeprom_cur_cmd_bit = 0;
122	}
123	}
124
125
126	DEVICE_ACCESS(rtl8139c)
127	{
128	struct rtl8139c_data d = (struct rtl8139c_data ) extra;
129	uint64_t idata = 0, odata = 0;
130
131	if (writeflag == MEM_WRITE)
132	idata = memory_readmax64(cpu, data, len);
133
134	switch (relative_addr) {
135
136	case RL_COMMAND:
137	if (writeflag == MEM_WRITE) {
138	if (idata & RL_CMD_RESET) {
139	/* Reset. TODO */
140
141	/* ... and then clear the reset bit: */
142	idata &= ~RL_CMD_RESET;
143	}
144
145	d->rl_command = idata;
146	} else {
147	odata = d->rl_command;
148	}
149	break;
150
151	case RL_EECMD:
152	if (writeflag == MEM_WRITE) {
153	uint8_t old = d->rl_eecmd;
154	d->rl_eecmd = idata;
155
156	if (!d->eeprom_selected && d->rl_eecmd & RL_EE_SEL) {
157	/* Reset eeprom cmd bit state: */
158	d->eeprom_cur_cmd = 0;
159	d->eeprom_cur_cmd_bit = 0;
160	}
161	d->eeprom_selected = d->rl_eecmd & RL_EE_SEL;
162
163	if (idata & RL_EE_CLK && !(old & RL_EE_CLK))
164	eeprom_clk(d);
165	} else {
166	odata = d->rl_eecmd;
167	}
168	break;
169
170	case 0x82:
171	/* Unknown address, but OpenBSD's re driver writes
172	a 0x01 to this address, in re_reset(). */
173	if (writeflag == MEM_WRITE) {
174	if (idata != 0x01) {
175	fatal("rtl8139c: unimplemented write to"
176	" register 0x82.\n");
177	exit(1);
178	}
179	}
180	break;
181
182	default:if (writeflag == MEM_WRITE) {
183	fatal("[ rtl8139c: unimplemented write to "
184	"offset 0x%x: data=0x%x ]\n", (int)
185	relative_addr, (int)idata);
186	} else {
187	fatal("[ rtl8139c: unimplemented read from "
188	"offset 0x%x ]\n", (int)relative_addr);
189	}
190	exit(1);
191	}
192
193	if (writeflag == MEM_READ)
194	memory_writemax64(cpu, data, len, odata);
195
196	return 1;
197	}
198
199
200	DEVINIT(rtl8139c)
201	{
202	char *name2;
203	size_t nlen = 100;
204	struct rtl8139c_data *d = malloc(sizeof(struct rtl8139c_data));
205
206	if (d == NULL) {
207	fprintf(stderr, "out of memory\n");
208	exit(1);
209	}
210	memset(d, 0, sizeof(struct rtl8139c_data));
211
212	INTERRUPT_CONNECT(devinit->interrupt_path, d->irq);
213
214	net_generate_unique_mac(devinit->machine, d->macaddr);
215
216	/* TODO: eeprom address width = 6 on 8129? */
217	d->eeprom_address_width = 8;
218	d->eeprom_reg[0] = 0x8139;
219	d->eeprom_reg[7] = d->macaddr[0] + (d->macaddr[1] << 8);
220	d->eeprom_reg[8] = d->macaddr[2] + (d->macaddr[3] << 8);
221	d->eeprom_reg[9] = d->macaddr[4] + (d->macaddr[5] << 8);
222
223	name2 = malloc(nlen);
224	if (name2 == NULL) {
225	fprintf(stderr, "out of memory\n");
226	exit(1);
227	}
228	snprintf(name2, nlen, "%s [%02x:%02x:%02x:%02x:%02x:%02x]",
229	devinit->name, d->macaddr[0], d->macaddr[1], d->macaddr[2],
230	d->macaddr[3], d->macaddr[4], d->macaddr[5]);
231
232	memory_device_register(devinit->machine->memory, name2,
233	devinit->addr, DEV_RTL8139C_LENGTH, dev_rtl8139c_access, (void *)d,
234	DM_DEFAULT, NULL);
235
236	net_add_nic(devinit->machine->emul->net, d, d->macaddr);
237
238	return 1;
239	}
240