Update Sparc parts in documentation
[qemu/qemu_0_9_1_stable.git] / hw / mipsnet.c
blobbebfd4d805e6b9cf86753ab0dcd65cb734ebeb18
1 #include "vl.h"
3 #define DEBUG_MIPSNET_SEND
4 #define DEBUG_MIPSNET_RECEIVE
5 //#define DEBUG_MIPSNET_DATA
6 #define DEBUG_MIPSNET_IRQ
8 /* MIPSnet register offsets */
10 #define MIPSNET_DEV_ID 0x00
11 # define MIPSNET_DEV_ID_STRING "MIPSNET0"
12 #define MIPSNET_BUSY 0x08
13 #define MIPSNET_RX_DATA_COUNT 0x0c
14 #define MIPSNET_TX_DATA_COUNT 0x10
15 #define MIPSNET_INT_CTL 0x14
16 # define MIPSNET_INTCTL_TXDONE 0x00000001
17 # define MIPSNET_INTCTL_RXDONE 0x00000002
18 # define MIPSNET_INTCTL_TESTBIT 0x80000000
19 #define MIPSNET_INTERRUPT_INFO 0x18
20 #define MIPSNET_RX_DATA_BUFFER 0x1c
21 #define MIPSNET_TX_DATA_BUFFER 0x20
23 #define MAX_ETH_FRAME_SIZE 1514
25 typedef struct MIPSnetState {
26 uint32_t busy;
27 uint32_t rx_count;
28 uint32_t rx_read;
29 uint32_t tx_count;
30 uint32_t tx_written;
31 uint32_t intctl;
32 uint8_t rx_buffer[MAX_ETH_FRAME_SIZE];
33 uint8_t tx_buffer[MAX_ETH_FRAME_SIZE];
34 qemu_irq irq;
35 VLANClientState *vc;
36 NICInfo *nd;
37 } MIPSnetState;
39 static void mipsnet_reset(MIPSnetState *s)
41 s->busy = 1;
42 s->rx_count = 0;
43 s->rx_read = 0;
44 s->tx_count = 0;
45 s->tx_written = 0;
46 s->intctl = 0;
47 memset(s->rx_buffer, 0, MAX_ETH_FRAME_SIZE);
48 memset(s->tx_buffer, 0, MAX_ETH_FRAME_SIZE);
51 static void mipsnet_update_irq(MIPSnetState *s)
53 int isr = !!s->intctl;
54 #ifdef DEBUG_MIPSNET_IRQ
55 printf("mipsnet: Set IRQ to %d (%02x)\n", isr, s->intctl);
56 #endif
57 qemu_set_irq(s->irq, isr);
60 static int mipsnet_buffer_full(MIPSnetState *s)
62 if (s->rx_count >= MAX_ETH_FRAME_SIZE)
63 return 1;
64 return 0;
67 static int mipsnet_can_receive(void *opaque)
69 MIPSnetState *s = opaque;
71 if (s->busy)
72 return 0;
73 return !mipsnet_buffer_full(s);
76 static void mipsnet_receive(void *opaque, const uint8_t *buf, int size)
78 MIPSnetState *s = opaque;
80 #ifdef DEBUG_MIPSNET_RECEIVE
81 printf("mipsnet: receiving len=%d\n", size);
82 #endif
83 if (!mipsnet_can_receive(opaque))
84 return;
86 s->busy = 1;
88 /* Just accept everything. */
90 /* Write packet data. */
91 memcpy(s->rx_buffer, buf, size);
93 s->rx_count = size;
94 s->rx_read = 0;
96 /* Now we can signal we have received something. */
97 s->intctl |= MIPSNET_INTCTL_RXDONE;
98 mipsnet_update_irq(s);
101 static uint32_t mipsnet_ioport_read(void *opaque, uint32_t addr)
103 MIPSnetState *s = opaque;
104 int ret = 0;
105 const char *devid = MIPSNET_DEV_ID_STRING;
107 addr &= 0x3f;
108 switch (addr) {
109 case MIPSNET_DEV_ID:
110 ret = *((uint32_t *)&devid);
111 break;
112 case MIPSNET_DEV_ID + 4:
113 ret = *((uint32_t *)(&devid + 4));
114 break;
115 case MIPSNET_BUSY:
116 ret = s->busy;
117 break;
118 case MIPSNET_RX_DATA_COUNT:
119 ret = s->rx_count;
120 break;
121 case MIPSNET_TX_DATA_COUNT:
122 ret = s->tx_count;
123 break;
124 case MIPSNET_INT_CTL:
125 ret = s->intctl;
126 s->intctl &= ~MIPSNET_INTCTL_TESTBIT;
127 break;
128 case MIPSNET_INTERRUPT_INFO:
129 /* XXX: This seems to be a per-VPE interrupt number. */
130 ret = 0;
131 break;
132 case MIPSNET_RX_DATA_BUFFER:
133 if (s->rx_count) {
134 s->rx_count--;
135 ret = s->rx_buffer[s->rx_read++];
137 break;
138 /* Reads as zero. */
139 case MIPSNET_TX_DATA_BUFFER:
140 default:
141 break;
143 #ifdef DEBUG_MIPSNET_DATA
144 printf("mipsnet: read addr=0x%02x val=0x%02x\n", addr, ret);
145 #endif
146 return ret;
149 static void mipsnet_ioport_write(void *opaque, uint32_t addr, uint32_t val)
151 MIPSnetState *s = opaque;
153 addr &= 0x3f;
154 #ifdef DEBUG_MIPSNET_DATA
155 printf("mipsnet: write addr=0x%02x val=0x%02x\n", addr, val);
156 #endif
157 switch (addr) {
158 case MIPSNET_TX_DATA_COUNT:
159 s->tx_count = (val <= MAX_ETH_FRAME_SIZE) ? val : 0;
160 s->tx_written = 0;
161 break;
162 case MIPSNET_INT_CTL:
163 if (val & MIPSNET_INTCTL_TXDONE) {
164 s->intctl &= ~MIPSNET_INTCTL_TXDONE;
165 } else if (val & MIPSNET_INTCTL_RXDONE) {
166 s->intctl &= ~MIPSNET_INTCTL_RXDONE;
167 } else if (val & MIPSNET_INTCTL_TESTBIT) {
168 mipsnet_reset(s);
169 s->intctl |= MIPSNET_INTCTL_TESTBIT;
170 } else if (!val) {
171 /* ACK testbit interrupt, flag was cleared on read. */
173 s->busy = !!s->intctl;
174 mipsnet_update_irq(s);
175 break;
176 case MIPSNET_TX_DATA_BUFFER:
177 s->tx_buffer[s->tx_written++] = val;
178 if (s->tx_written == s->tx_count) {
179 /* Send buffer. */
180 #ifdef DEBUG_MIPSNET_SEND
181 printf("mipsnet: sending len=%d\n", s->tx_count);
182 #endif
183 qemu_send_packet(s->vc, s->tx_buffer, s->tx_count);
184 s->tx_count = s->tx_written = 0;
185 s->intctl |= MIPSNET_INTCTL_TXDONE;
186 s->busy = 1;
187 mipsnet_update_irq(s);
189 break;
190 /* Read-only registers */
191 case MIPSNET_DEV_ID:
192 case MIPSNET_BUSY:
193 case MIPSNET_RX_DATA_COUNT:
194 case MIPSNET_INTERRUPT_INFO:
195 case MIPSNET_RX_DATA_BUFFER:
196 default:
197 break;
201 static void mipsnet_save(QEMUFile *f, void *opaque)
203 MIPSnetState *s = opaque;
205 qemu_put_be32s(f, &s->busy);
206 qemu_put_be32s(f, &s->rx_count);
207 qemu_put_be32s(f, &s->rx_read);
208 qemu_put_be32s(f, &s->tx_count);
209 qemu_put_be32s(f, &s->tx_written);
210 qemu_put_be32s(f, &s->intctl);
211 qemu_put_buffer(f, s->rx_buffer, MAX_ETH_FRAME_SIZE);
212 qemu_put_buffer(f, s->tx_buffer, MAX_ETH_FRAME_SIZE);
215 static int mipsnet_load(QEMUFile *f, void *opaque, int version_id)
217 MIPSnetState *s = opaque;
219 if (version_id > 0)
220 return -EINVAL;
222 qemu_get_be32s(f, &s->busy);
223 qemu_get_be32s(f, &s->rx_count);
224 qemu_get_be32s(f, &s->rx_read);
225 qemu_get_be32s(f, &s->tx_count);
226 qemu_get_be32s(f, &s->tx_written);
227 qemu_get_be32s(f, &s->intctl);
228 qemu_get_buffer(f, s->rx_buffer, MAX_ETH_FRAME_SIZE);
229 qemu_get_buffer(f, s->tx_buffer, MAX_ETH_FRAME_SIZE);
231 return 0;
234 void mipsnet_init (int base, qemu_irq irq, NICInfo *nd)
236 MIPSnetState *s;
238 s = qemu_mallocz(sizeof(MIPSnetState));
239 if (!s)
240 return;
242 register_ioport_write(base, 36, 1, mipsnet_ioport_write, s);
243 register_ioport_read(base, 36, 1, mipsnet_ioport_read, s);
244 register_ioport_write(base, 36, 2, mipsnet_ioport_write, s);
245 register_ioport_read(base, 36, 2, mipsnet_ioport_read, s);
246 register_ioport_write(base, 36, 4, mipsnet_ioport_write, s);
247 register_ioport_read(base, 36, 4, mipsnet_ioport_read, s);
249 s->irq = irq;
250 s->nd = nd;
251 if (nd && nd->vlan) {
252 s->vc = qemu_new_vlan_client(nd->vlan, mipsnet_receive,
253 mipsnet_can_receive, s);
254 } else {
255 s->vc = NULL;
258 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
259 "mipsnet macaddr=%02x:%02x:%02x:%02x:%02x:%02x",
260 s->nd->macaddr[0],
261 s->nd->macaddr[1],
262 s->nd->macaddr[2],
263 s->nd->macaddr[3],
264 s->nd->macaddr[4],
265 s->nd->macaddr[5]);
267 mipsnet_reset(s);
268 register_savevm("mipsnet", 0, 0, mipsnet_save, mipsnet_load, s);