?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
introduce -cpu host target
[qemu/mdroth.git] / hw / pcnet.c
bloba184146e0d7bc3453acb0fce1e4998ce5c23d89a
1 /*
2 * QEMU AMD PC-Net II (Am79C970A) emulation
3 *
4 * Copyright (c) 2004 Antony T Curtis
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
24
25 /* This software was written to be compatible with the specification:
26 * AMD Am79C970A PCnet-PCI II Ethernet Controller Data-Sheet
27 * AMD Publication# 19436 Rev:E Amendment/0 Issue Date: June 2000
28 */
29
30 /*
31 * On Sparc32, this is the Lance (Am7990) part of chip STP2000 (Master I/O), also
32 * produced as NCR89C100. See
33 * http://www.ibiblio.org/pub/historic-linux/early-ports/Sparc/NCR/NCR89C100.txt
34 * and
35 * http://www.ibiblio.org/pub/historic-linux/early-ports/Sparc/NCR/NCR92C990.txt
36 */
37
38 #include "sysbus.h"
39 #include "pci.h"
40 #include "net.h"
41 #include "qemu-timer.h"
42 #include "qemu_socket.h"
43
44 //#define PCNET_DEBUG
45 //#define PCNET_DEBUG_IO
46 //#define PCNET_DEBUG_BCR
47 //#define PCNET_DEBUG_CSR
48 //#define PCNET_DEBUG_RMD
49 //#define PCNET_DEBUG_TMD
50 //#define PCNET_DEBUG_MATCH
51
52
53 #define PCNET_IOPORT_SIZE 0x20
54 #define PCNET_PNPMMIO_SIZE 0x20
55
56 #define PCNET_LOOPTEST_CRC 1
57 #define PCNET_LOOPTEST_NOCRC 2
58
59
60 typedef struct PCNetState_st PCNetState;
61
62 struct PCNetState_st {
63 PCIDevice *pci_dev;
64 VLANClientState *vc;
65 uint8_t macaddr[6];
66 QEMUTimer *poll_timer;
67 int rap, isr, lnkst;
68 uint32_t rdra, tdra;
69 uint8_t prom[16];
70 uint16_t csr[128];
71 uint16_t bcr[32];
72 uint64_t timer;
73 int mmio_index, xmit_pos, recv_pos;
74 uint8_t buffer[4096];
75 int tx_busy;
76 qemu_irq irq;
77 void (*phys_mem_read)(void *dma_opaque, target_phys_addr_t addr,
78 uint8_t *buf, int len, int do_bswap);
79 void (*phys_mem_write)(void *dma_opaque, target_phys_addr_t addr,
80 uint8_t *buf, int len, int do_bswap);
81 void *dma_opaque;
82 int looptest;
83 };
84
85 typedef struct {
86 PCIDevice pci_dev;
87 PCNetState state;
88 } PCIPCNetState;
89
90 typedef struct {
91 SysBusDevice busdev;
92 PCNetState state;
93 } SysBusPCNetState;
94
95 struct qemu_ether_header {
96 uint8_t ether_dhost[6];
97 uint8_t ether_shost[6];
98 uint16_t ether_type;
99 };
100
101 /* BUS CONFIGURATION REGISTERS */
102 #define BCR_MSRDA 0
103 #define BCR_MSWRA 1
104 #define BCR_MC 2
105 #define BCR_LNKST 4
106 #define BCR_LED1 5
107 #define BCR_LED2 6
108 #define BCR_LED3 7
109 #define BCR_FDC 9
110 #define BCR_BSBC 18
111 #define BCR_EECAS 19
112 #define BCR_SWS 20
113 #define BCR_PLAT 22
114
115 #define BCR_DWIO(S) !!((S)->bcr[BCR_BSBC] & 0x0080)
116 #define BCR_SSIZE32(S) !!((S)->bcr[BCR_SWS ] & 0x0100)
117 #define BCR_SWSTYLE(S) ((S)->bcr[BCR_SWS ] & 0x00FF)
118
119 #define CSR_INIT(S) !!(((S)->csr[0])&0x0001)
120 #define CSR_STRT(S) !!(((S)->csr[0])&0x0002)
121 #define CSR_STOP(S) !!(((S)->csr[0])&0x0004)
122 #define CSR_TDMD(S) !!(((S)->csr[0])&0x0008)
123 #define CSR_TXON(S) !!(((S)->csr[0])&0x0010)
124 #define CSR_RXON(S) !!(((S)->csr[0])&0x0020)
125 #define CSR_INEA(S) !!(((S)->csr[0])&0x0040)
126 #define CSR_BSWP(S) !!(((S)->csr[3])&0x0004)
127 #define CSR_LAPPEN(S) !!(((S)->csr[3])&0x0020)
128 #define CSR_DXSUFLO(S) !!(((S)->csr[3])&0x0040)
129 #define CSR_ASTRP_RCV(S) !!(((S)->csr[4])&0x0800)
130 #define CSR_DPOLL(S) !!(((S)->csr[4])&0x1000)
131 #define CSR_SPND(S) !!(((S)->csr[5])&0x0001)
132 #define CSR_LTINTEN(S) !!(((S)->csr[5])&0x4000)
133 #define CSR_TOKINTD(S) !!(((S)->csr[5])&0x8000)
134 #define CSR_DRX(S) !!(((S)->csr[15])&0x0001)
135 #define CSR_DTX(S) !!(((S)->csr[15])&0x0002)
136 #define CSR_LOOP(S) !!(((S)->csr[15])&0x0004)
137 #define CSR_DXMTFCS(S) !!(((S)->csr[15])&0x0008)
138 #define CSR_DRCVPA(S) !!(((S)->csr[15])&0x2000)
139 #define CSR_DRCVBC(S) !!(((S)->csr[15])&0x4000)
140 #define CSR_PROM(S) !!(((S)->csr[15])&0x8000)
141
142 #define CSR_CRBC(S) ((S)->csr[40])
143 #define CSR_CRST(S) ((S)->csr[41])
144 #define CSR_CXBC(S) ((S)->csr[42])
145 #define CSR_CXST(S) ((S)->csr[43])
146 #define CSR_NRBC(S) ((S)->csr[44])
147 #define CSR_NRST(S) ((S)->csr[45])
148 #define CSR_POLL(S) ((S)->csr[46])
149 #define CSR_PINT(S) ((S)->csr[47])
150 #define CSR_RCVRC(S) ((S)->csr[72])
151 #define CSR_XMTRC(S) ((S)->csr[74])
152 #define CSR_RCVRL(S) ((S)->csr[76])
153 #define CSR_XMTRL(S) ((S)->csr[78])
154 #define CSR_MISSC(S) ((S)->csr[112])
155
156 #define CSR_IADR(S) ((S)->csr[ 1] | ((S)->csr[ 2] << 16))
157 #define CSR_CRBA(S) ((S)->csr[18] | ((S)->csr[19] << 16))
158 #define CSR_CXBA(S) ((S)->csr[20] | ((S)->csr[21] << 16))
159 #define CSR_NRBA(S) ((S)->csr[22] | ((S)->csr[23] << 16))
160 #define CSR_BADR(S) ((S)->csr[24] | ((S)->csr[25] << 16))
161 #define CSR_NRDA(S) ((S)->csr[26] | ((S)->csr[27] << 16))
162 #define CSR_CRDA(S) ((S)->csr[28] | ((S)->csr[29] << 16))
163 #define CSR_BADX(S) ((S)->csr[30] | ((S)->csr[31] << 16))
164 #define CSR_NXDA(S) ((S)->csr[32] | ((S)->csr[33] << 16))
165 #define CSR_CXDA(S) ((S)->csr[34] | ((S)->csr[35] << 16))
166 #define CSR_NNRD(S) ((S)->csr[36] | ((S)->csr[37] << 16))
167 #define CSR_NNXD(S) ((S)->csr[38] | ((S)->csr[39] << 16))
168 #define CSR_PXDA(S) ((S)->csr[60] | ((S)->csr[61] << 16))
169 #define CSR_NXBA(S) ((S)->csr[64] | ((S)->csr[65] << 16))
170
171 #define PHYSADDR(S,A) \
172 (BCR_SSIZE32(S) ? (A) : (A) | ((0xff00 & (uint32_t)(s)->csr[2])<<16))
173
174 struct pcnet_initblk16 {
175 uint16_t mode;
176 uint16_t padr[3];
177 uint16_t ladrf[4];
178 uint32_t rdra;
179 uint32_t tdra;
180 };
181
182 struct pcnet_initblk32 {
183 uint16_t mode;
184 uint8_t rlen;
185 uint8_t tlen;
186 uint16_t padr[3];
187 uint16_t _res;
188 uint16_t ladrf[4];
189 uint32_t rdra;
190 uint32_t tdra;
191 };
192
193 struct pcnet_TMD {
194 uint32_t tbadr;
195 int16_t length;
196 int16_t status;
197 uint32_t misc;
198 uint32_t res;
199 };
200
201 #define TMDL_BCNT_MASK 0x0fff
202 #define TMDL_BCNT_SH 0
203 #define TMDL_ONES_MASK 0xf000
204 #define TMDL_ONES_SH 12
205
206 #define TMDS_BPE_MASK 0x0080
207 #define TMDS_BPE_SH 7
208 #define TMDS_ENP_MASK 0x0100
209 #define TMDS_ENP_SH 8
210 #define TMDS_STP_MASK 0x0200
211 #define TMDS_STP_SH 9
212 #define TMDS_DEF_MASK 0x0400
213 #define TMDS_DEF_SH 10
214 #define TMDS_ONE_MASK 0x0800
215 #define TMDS_ONE_SH 11
216 #define TMDS_LTINT_MASK 0x1000
217 #define TMDS_LTINT_SH 12
218 #define TMDS_NOFCS_MASK 0x2000
219 #define TMDS_NOFCS_SH 13
220 #define TMDS_ADDFCS_MASK TMDS_NOFCS_MASK
221 #define TMDS_ADDFCS_SH TMDS_NOFCS_SH
222 #define TMDS_ERR_MASK 0x4000
223 #define TMDS_ERR_SH 14
224 #define TMDS_OWN_MASK 0x8000
225 #define TMDS_OWN_SH 15
226
227 #define TMDM_TRC_MASK 0x0000000f
228 #define TMDM_TRC_SH 0
229 #define TMDM_TDR_MASK 0x03ff0000
230 #define TMDM_TDR_SH 16
231 #define TMDM_RTRY_MASK 0x04000000
232 #define TMDM_RTRY_SH 26
233 #define TMDM_LCAR_MASK 0x08000000
234 #define TMDM_LCAR_SH 27
235 #define TMDM_LCOL_MASK 0x10000000
236 #define TMDM_LCOL_SH 28
237 #define TMDM_EXDEF_MASK 0x20000000
238 #define TMDM_EXDEF_SH 29
239 #define TMDM_UFLO_MASK 0x40000000
240 #define TMDM_UFLO_SH 30
241 #define TMDM_BUFF_MASK 0x80000000
242 #define TMDM_BUFF_SH 31
243
244 struct pcnet_RMD {
245 uint32_t rbadr;
246 int16_t buf_length;
247 int16_t status;
248 uint32_t msg_length;
249 uint32_t res;
250 };
251
252 #define RMDL_BCNT_MASK 0x0fff
253 #define RMDL_BCNT_SH 0
254 #define RMDL_ONES_MASK 0xf000
255 #define RMDL_ONES_SH 12
256
257 #define RMDS_BAM_MASK 0x0010
258 #define RMDS_BAM_SH 4
259 #define RMDS_LFAM_MASK 0x0020
260 #define RMDS_LFAM_SH 5
261 #define RMDS_PAM_MASK 0x0040
262 #define RMDS_PAM_SH 6
263 #define RMDS_BPE_MASK 0x0080
264 #define RMDS_BPE_SH 7
265 #define RMDS_ENP_MASK 0x0100
266 #define RMDS_ENP_SH 8
267 #define RMDS_STP_MASK 0x0200
268 #define RMDS_STP_SH 9
269 #define RMDS_BUFF_MASK 0x0400
270 #define RMDS_BUFF_SH 10
271 #define RMDS_CRC_MASK 0x0800
272 #define RMDS_CRC_SH 11
273 #define RMDS_OFLO_MASK 0x1000
274 #define RMDS_OFLO_SH 12
275 #define RMDS_FRAM_MASK 0x2000
276 #define RMDS_FRAM_SH 13
277 #define RMDS_ERR_MASK 0x4000
278 #define RMDS_ERR_SH 14
279 #define RMDS_OWN_MASK 0x8000
280 #define RMDS_OWN_SH 15
281
282 #define RMDM_MCNT_MASK 0x00000fff
283 #define RMDM_MCNT_SH 0
284 #define RMDM_ZEROS_MASK 0x0000f000
285 #define RMDM_ZEROS_SH 12
286 #define RMDM_RPC_MASK 0x00ff0000
287 #define RMDM_RPC_SH 16
288 #define RMDM_RCC_MASK 0xff000000
289 #define RMDM_RCC_SH 24
290
291 #define SET_FIELD(regp, name, field, value) \
292 (*(regp) = (*(regp) & ~(name ## _ ## field ## _MASK)) \
293 | ((value) << name ## _ ## field ## _SH))
294
295 #define GET_FIELD(reg, name, field) \
296 (((reg) & name ## _ ## field ## _MASK) >> name ## _ ## field ## _SH)
297
298 #define PRINT_TMD(T) printf( \
299 "TMD0 : TBADR=0x%08x\n" \
300 "TMD1 : OWN=%d, ERR=%d, FCS=%d, LTI=%d, " \
301 "ONE=%d, DEF=%d, STP=%d, ENP=%d,\n" \
302 " BPE=%d, BCNT=%d\n" \
303 "TMD2 : BUF=%d, UFL=%d, EXD=%d, LCO=%d, " \
304 "LCA=%d, RTR=%d,\n" \
305 " TDR=%d, TRC=%d\n", \
306 (T)->tbadr, \
307 GET_FIELD((T)->status, TMDS, OWN), \
308 GET_FIELD((T)->status, TMDS, ERR), \
309 GET_FIELD((T)->status, TMDS, NOFCS), \
310 GET_FIELD((T)->status, TMDS, LTINT), \
311 GET_FIELD((T)->status, TMDS, ONE), \
312 GET_FIELD((T)->status, TMDS, DEF), \
313 GET_FIELD((T)->status, TMDS, STP), \
314 GET_FIELD((T)->status, TMDS, ENP), \
315 GET_FIELD((T)->status, TMDS, BPE), \
316 4096-GET_FIELD((T)->length, TMDL, BCNT), \
317 GET_FIELD((T)->misc, TMDM, BUFF), \
318 GET_FIELD((T)->misc, TMDM, UFLO), \
319 GET_FIELD((T)->misc, TMDM, EXDEF), \
320 GET_FIELD((T)->misc, TMDM, LCOL), \
321 GET_FIELD((T)->misc, TMDM, LCAR), \
322 GET_FIELD((T)->misc, TMDM, RTRY), \
323 GET_FIELD((T)->misc, TMDM, TDR), \
324 GET_FIELD((T)->misc, TMDM, TRC))
325
326 #define PRINT_RMD(R) printf( \
327 "RMD0 : RBADR=0x%08x\n" \
328 "RMD1 : OWN=%d, ERR=%d, FRAM=%d, OFLO=%d, " \
329 "CRC=%d, BUFF=%d, STP=%d, ENP=%d,\n " \
330 "BPE=%d, PAM=%d, LAFM=%d, BAM=%d, ONES=%d, BCNT=%d\n" \
331 "RMD2 : RCC=%d, RPC=%d, MCNT=%d, ZEROS=%d\n", \
332 (R)->rbadr, \
333 GET_FIELD((R)->status, RMDS, OWN), \
334 GET_FIELD((R)->status, RMDS, ERR), \
335 GET_FIELD((R)->status, RMDS, FRAM), \
336 GET_FIELD((R)->status, RMDS, OFLO), \
337 GET_FIELD((R)->status, RMDS, CRC), \
338 GET_FIELD((R)->status, RMDS, BUFF), \
339 GET_FIELD((R)->status, RMDS, STP), \
340 GET_FIELD((R)->status, RMDS, ENP), \
341 GET_FIELD((R)->status, RMDS, BPE), \
342 GET_FIELD((R)->status, RMDS, PAM), \
343 GET_FIELD((R)->status, RMDS, LFAM), \
344 GET_FIELD((R)->status, RMDS, BAM), \
345 GET_FIELD((R)->buf_length, RMDL, ONES), \
346 4096-GET_FIELD((R)->buf_length, RMDL, BCNT), \
347 GET_FIELD((R)->msg_length, RMDM, RCC), \
348 GET_FIELD((R)->msg_length, RMDM, RPC), \
349 GET_FIELD((R)->msg_length, RMDM, MCNT), \
350 GET_FIELD((R)->msg_length, RMDM, ZEROS))
351
352 static inline void pcnet_tmd_load(PCNetState *s, struct pcnet_TMD *tmd,
353 target_phys_addr_t addr)
354 {
355 if (!BCR_SSIZE32(s)) {
356 struct {
357 uint32_t tbadr;
358 int16_t length;
359 int16_t status;
360 } xda;
361 s->phys_mem_read(s->dma_opaque, addr, (void *)&xda, sizeof(xda), 0);
362 tmd->tbadr = le32_to_cpu(xda.tbadr) & 0xffffff;
363 tmd->length = le16_to_cpu(xda.length);
364 tmd->status = (le32_to_cpu(xda.tbadr) >> 16) & 0xff00;
365 tmd->misc = le16_to_cpu(xda.status) << 16;
366 tmd->res = 0;
367 } else {
368 s->phys_mem_read(s->dma_opaque, addr, (void *)tmd, sizeof(*tmd), 0);
369 le32_to_cpus(&tmd->tbadr);
370 le16_to_cpus((uint16_t *)&tmd->length);
371 le16_to_cpus((uint16_t *)&tmd->status);
372 le32_to_cpus(&tmd->misc);
373 le32_to_cpus(&tmd->res);
374 if (BCR_SWSTYLE(s) == 3) {
375 uint32_t tmp = tmd->tbadr;
376 tmd->tbadr = tmd->misc;
377 tmd->misc = tmp;
378 }
379 }
380 }
381
382 static inline void pcnet_tmd_store(PCNetState *s, const struct pcnet_TMD *tmd,
383 target_phys_addr_t addr)
384 {
385 if (!BCR_SSIZE32(s)) {
386 struct {
387 uint32_t tbadr;
388 int16_t length;
389 int16_t status;
390 } xda;
391 xda.tbadr = cpu_to_le32((tmd->tbadr & 0xffffff) |
392 ((tmd->status & 0xff00) << 16));
393 xda.length = cpu_to_le16(tmd->length);
394 xda.status = cpu_to_le16(tmd->misc >> 16);
395 s->phys_mem_write(s->dma_opaque, addr, (void *)&xda, sizeof(xda), 0);
396 } else {
397 struct {
398 uint32_t tbadr;
399 int16_t length;
400 int16_t status;
401 uint32_t misc;
402 uint32_t res;
403 } xda;
404 xda.tbadr = cpu_to_le32(tmd->tbadr);
405 xda.length = cpu_to_le16(tmd->length);
406 xda.status = cpu_to_le16(tmd->status);
407 xda.misc = cpu_to_le32(tmd->misc);
408 xda.res = cpu_to_le32(tmd->res);
409 if (BCR_SWSTYLE(s) == 3) {
410 uint32_t tmp = xda.tbadr;
411 xda.tbadr = xda.misc;
412 xda.misc = tmp;
413 }
414 s->phys_mem_write(s->dma_opaque, addr, (void *)&xda, sizeof(xda), 0);
415 }
416 }
417
418 static inline void pcnet_rmd_load(PCNetState *s, struct pcnet_RMD *rmd,
419 target_phys_addr_t addr)
420 {
421 if (!BCR_SSIZE32(s)) {
422 struct {
423 uint32_t rbadr;
424 int16_t buf_length;
425 int16_t msg_length;
426 } rda;
427 s->phys_mem_read(s->dma_opaque, addr, (void *)&rda, sizeof(rda), 0);
428 rmd->rbadr = le32_to_cpu(rda.rbadr) & 0xffffff;
429 rmd->buf_length = le16_to_cpu(rda.buf_length);
430 rmd->status = (le32_to_cpu(rda.rbadr) >> 16) & 0xff00;
431 rmd->msg_length = le16_to_cpu(rda.msg_length);
432 rmd->res = 0;
433 } else {
434 s->phys_mem_read(s->dma_opaque, addr, (void *)rmd, sizeof(*rmd), 0);
435 le32_to_cpus(&rmd->rbadr);
436 le16_to_cpus((uint16_t *)&rmd->buf_length);
437 le16_to_cpus((uint16_t *)&rmd->status);
438 le32_to_cpus(&rmd->msg_length);
439 le32_to_cpus(&rmd->res);
440 if (BCR_SWSTYLE(s) == 3) {
441 uint32_t tmp = rmd->rbadr;
442 rmd->rbadr = rmd->msg_length;
443 rmd->msg_length = tmp;
444 }
445 }
446 }
447
448 static inline void pcnet_rmd_store(PCNetState *s, struct pcnet_RMD *rmd,
449 target_phys_addr_t addr)
450 {
451 if (!BCR_SSIZE32(s)) {
452 struct {
453 uint32_t rbadr;
454 int16_t buf_length;
455 int16_t msg_length;
456 } rda;
457 rda.rbadr = cpu_to_le32((rmd->rbadr & 0xffffff) |
458 ((rmd->status & 0xff00) << 16));
459 rda.buf_length = cpu_to_le16(rmd->buf_length);
460 rda.msg_length = cpu_to_le16(rmd->msg_length);
461 s->phys_mem_write(s->dma_opaque, addr, (void *)&rda, sizeof(rda), 0);
462 } else {
463 struct {
464 uint32_t rbadr;
465 int16_t buf_length;
466 int16_t status;
467 uint32_t msg_length;
468 uint32_t res;
469 } rda;
470 rda.rbadr = cpu_to_le32(rmd->rbadr);
471 rda.buf_length = cpu_to_le16(rmd->buf_length);
472 rda.status = cpu_to_le16(rmd->status);
473 rda.msg_length = cpu_to_le32(rmd->msg_length);
474 rda.res = cpu_to_le32(rmd->res);
475 if (BCR_SWSTYLE(s) == 3) {
476 uint32_t tmp = rda.rbadr;
477 rda.rbadr = rda.msg_length;
478 rda.msg_length = tmp;
479 }
480 s->phys_mem_write(s->dma_opaque, addr, (void *)&rda, sizeof(rda), 0);
481 }
482 }
483
484
485 #define TMDLOAD(TMD,ADDR) pcnet_tmd_load(s,TMD,ADDR)
486
487 #define TMDSTORE(TMD,ADDR) pcnet_tmd_store(s,TMD,ADDR)
488
489 #define RMDLOAD(RMD,ADDR) pcnet_rmd_load(s,RMD,ADDR)
490
491 #define RMDSTORE(RMD,ADDR) pcnet_rmd_store(s,RMD,ADDR)
492
493 #if 1
494
495 #define CHECK_RMD(ADDR,RES) do { \
496 struct pcnet_RMD rmd; \
497 RMDLOAD(&rmd,(ADDR)); \
498 (RES) |= (GET_FIELD(rmd.buf_length, RMDL, ONES) != 15) \
499 || (GET_FIELD(rmd.msg_length, RMDM, ZEROS) != 0); \
500 } while (0)
501
502 #define CHECK_TMD(ADDR,RES) do { \
503 struct pcnet_TMD tmd; \
504 TMDLOAD(&tmd,(ADDR)); \
505 (RES) |= (GET_FIELD(tmd.length, TMDL, ONES) != 15); \
506 } while (0)
507
508 #else
509
510 #define CHECK_RMD(ADDR,RES) do { \
511 switch (BCR_SWSTYLE(s)) { \
512 case 0x00: \
513 do { \
514 uint16_t rda[4]; \
515 s->phys_mem_read(s->dma_opaque, (ADDR), \
516 (void *)&rda[0], sizeof(rda), 0); \
517 (RES) |= (rda[2] & 0xf000)!=0xf000; \
518 (RES) |= (rda[3] & 0xf000)!=0x0000; \
519 } while (0); \
520 break; \
521 case 0x01: \
522 case 0x02: \
523 do { \
524 uint32_t rda[4]; \
525 s->phys_mem_read(s->dma_opaque, (ADDR), \
526 (void *)&rda[0], sizeof(rda), 0); \
527 (RES) |= (rda[1] & 0x0000f000L)!=0x0000f000L; \
528 (RES) |= (rda[2] & 0x0000f000L)!=0x00000000L; \
529 } while (0); \
530 break; \
531 case 0x03: \
532 do { \
533 uint32_t rda[4]; \
534 s->phys_mem_read(s->dma_opaque, (ADDR), \
535 (void *)&rda[0], sizeof(rda), 0); \
536 (RES) |= (rda[0] & 0x0000f000L)!=0x00000000L; \
537 (RES) |= (rda[1] & 0x0000f000L)!=0x0000f000L; \
538 } while (0); \
539 break; \
540 } \
541 } while (0)
542
543 #define CHECK_TMD(ADDR,RES) do { \
544 switch (BCR_SWSTYLE(s)) { \
545 case 0x00: \
546 do { \
547 uint16_t xda[4]; \
548 s->phys_mem_read(s->dma_opaque, (ADDR), \
549 (void *)&xda[0], sizeof(xda), 0); \
550 (RES) |= (xda[2] & 0xf000)!=0xf000; \
551 } while (0); \
552 break; \
553 case 0x01: \
554 case 0x02: \
555 case 0x03: \
556 do { \
557 uint32_t xda[4]; \
558 s->phys_mem_read(s->dma_opaque, (ADDR), \
559 (void *)&xda[0], sizeof(xda), 0); \
560 (RES) |= (xda[1] & 0x0000f000L)!=0x0000f000L; \
561 } while (0); \
562 break; \
563 } \
564 } while (0)
565
566 #endif
567
568 #define PRINT_PKTHDR(BUF) do { \
569 struct qemu_ether_header *hdr = (void *)(BUF); \
570 printf("packet dhost=%02x:%02x:%02x:%02x:%02x:%02x, " \
571 "shost=%02x:%02x:%02x:%02x:%02x:%02x, " \
572 "type=0x%04x\n", \
573 hdr->ether_dhost[0],hdr->ether_dhost[1],hdr->ether_dhost[2], \
574 hdr->ether_dhost[3],hdr->ether_dhost[4],hdr->ether_dhost[5], \
575 hdr->ether_shost[0],hdr->ether_shost[1],hdr->ether_shost[2], \
576 hdr->ether_shost[3],hdr->ether_shost[4],hdr->ether_shost[5], \
577 be16_to_cpu(hdr->ether_type)); \
578 } while (0)
579
580 #define MULTICAST_FILTER_LEN 8
581
582 static inline uint32_t lnc_mchash(const uint8_t *ether_addr)
583 {
584 #define LNC_POLYNOMIAL 0xEDB88320UL
585 uint32_t crc = 0xFFFFFFFF;
586 int idx, bit;
587 uint8_t data;
588
589 for (idx = 0; idx < 6; idx++) {
590 for (data = *ether_addr++, bit = 0; bit < MULTICAST_FILTER_LEN; bit++) {
591 crc = (crc >> 1) ^ (((crc ^ data) & 1) ? LNC_POLYNOMIAL : 0);
592 data >>= 1;
593 }
594 }
595 return crc;
596 #undef LNC_POLYNOMIAL
597 }
598
599 #define CRC(crc, ch) (crc = (crc >> 8) ^ crctab[(crc ^ (ch)) & 0xff])
600
601 /* generated using the AUTODIN II polynomial
602 * x^32 + x^26 + x^23 + x^22 + x^16 +
603 * x^12 + x^11 + x^10 + x^8 + x^7 + x^5 + x^4 + x^2 + x^1 + 1
604 */
605 static const uint32_t crctab[256] = {
606 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba,
607 0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3,
608 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
609 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91,
610 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
611 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
612 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec,
613 0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5,
614 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
615 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
616 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940,
617 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
618 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116,
619 0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f,
620 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
621 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d,
622 0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a,
623 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
624 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818,
625 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
626 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
627 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457,
628 0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c,
629 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
630 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
631 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb,
632 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
633 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9,
634 0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086,
635 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
636 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4,
637 0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad,
638 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
639 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683,
640 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
641 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
642 0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe,
643 0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7,
644 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
645 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
646 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252,
647 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
648 0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60,
649 0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79,
650 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
651 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f,
652 0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04,
653 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
654 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a,
655 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
656 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
657 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21,
658 0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e,
659 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
660 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
661 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45,
662 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
663 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db,
664 0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0,
665 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
666 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6,
667 0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf,
668 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
669 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d,
670 };
671
672 static inline int padr_match(PCNetState *s, const uint8_t *buf, int size)
673 {
674 struct qemu_ether_header *hdr = (void *)buf;
675 uint8_t padr[6] = {
676 s->csr[12] & 0xff, s->csr[12] >> 8,
677 s->csr[13] & 0xff, s->csr[13] >> 8,
678 s->csr[14] & 0xff, s->csr[14] >> 8
679 };
680 int result = (!CSR_DRCVPA(s)) && !memcmp(hdr->ether_dhost, padr, 6);
681 #ifdef PCNET_DEBUG_MATCH
682 printf("packet dhost=%02x:%02x:%02x:%02x:%02x:%02x, "
683 "padr=%02x:%02x:%02x:%02x:%02x:%02x\n",
684 hdr->ether_dhost[0],hdr->ether_dhost[1],hdr->ether_dhost[2],
685 hdr->ether_dhost[3],hdr->ether_dhost[4],hdr->ether_dhost[5],
686 padr[0],padr[1],padr[2],padr[3],padr[4],padr[5]);
687 printf("padr_match result=%d\n", result);
688 #endif
689 return result;
690 }
691
692 static inline int padr_bcast(PCNetState *s, const uint8_t *buf, int size)
693 {
694 static const uint8_t BCAST[6] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
695 struct qemu_ether_header *hdr = (void *)buf;
696 int result = !CSR_DRCVBC(s) && !memcmp(hdr->ether_dhost, BCAST, 6);
697 #ifdef PCNET_DEBUG_MATCH
698 printf("padr_bcast result=%d\n", result);
699 #endif
700 return result;
701 }
702
703 static inline int ladr_match(PCNetState *s, const uint8_t *buf, int size)
704 {
705 struct qemu_ether_header *hdr = (void *)buf;
706 if ((*(hdr->ether_dhost)&0x01) &&
707 ((uint64_t *)&s->csr[8])[0] != 0LL) {
708 uint8_t ladr[8] = {
709 s->csr[8] & 0xff, s->csr[8] >> 8,
710 s->csr[9] & 0xff, s->csr[9] >> 8,
711 s->csr[10] & 0xff, s->csr[10] >> 8,
712 s->csr[11] & 0xff, s->csr[11] >> 8
713 };
714 int index = lnc_mchash(hdr->ether_dhost) >> 26;
715 return !!(ladr[index >> 3] & (1 << (index & 7)));
716 }
717 return 0;
718 }
719
720 static inline target_phys_addr_t pcnet_rdra_addr(PCNetState *s, int idx)
721 {
722 while (idx < 1) idx += CSR_RCVRL(s);
723 return s->rdra + ((CSR_RCVRL(s) - idx) * (BCR_SWSTYLE(s) ? 16 : 8));
724 }
725
726 static inline int64_t pcnet_get_next_poll_time(PCNetState *s, int64_t current_time)
727 {
728 int64_t next_time = current_time +
729 muldiv64(65536 - (CSR_SPND(s) ? 0 : CSR_POLL(s)),
730 ticks_per_sec, 33000000L);
731 if (next_time <= current_time)
732 next_time = current_time + 1;
733 return next_time;
734 }
735
736 static void pcnet_poll(PCNetState *s);
737 static void pcnet_poll_timer(void *opaque);
738
739 static uint32_t pcnet_csr_readw(PCNetState *s, uint32_t rap);
740 static void pcnet_csr_writew(PCNetState *s, uint32_t rap, uint32_t new_value);
741 static void pcnet_bcr_writew(PCNetState *s, uint32_t rap, uint32_t val);
742 static uint32_t pcnet_bcr_readw(PCNetState *s, uint32_t rap);
743
744 static void pcnet_s_reset(PCNetState *s)
745 {
746 #ifdef PCNET_DEBUG
747 printf("pcnet_s_reset\n");
748 #endif
749
750 s->lnkst = 0x40;
751 s->rdra = 0;
752 s->tdra = 0;
753 s->rap = 0;
754
755 s->bcr[BCR_BSBC] &= ~0x0080;
756
757 s->csr[0] = 0x0004;
758 s->csr[3] = 0x0000;
759 s->csr[4] = 0x0115;
760 s->csr[5] = 0x0000;
761 s->csr[6] = 0x0000;
762 s->csr[8] = 0;
763 s->csr[9] = 0;
764 s->csr[10] = 0;
765 s->csr[11] = 0;
766 s->csr[12] = le16_to_cpu(((uint16_t *)&s->prom[0])[0]);
767 s->csr[13] = le16_to_cpu(((uint16_t *)&s->prom[0])[1]);
768 s->csr[14] = le16_to_cpu(((uint16_t *)&s->prom[0])[2]);
769 s->csr[15] &= 0x21c4;
770 s->csr[72] = 1;
771 s->csr[74] = 1;
772 s->csr[76] = 1;
773 s->csr[78] = 1;
774 s->csr[80] = 0x1410;
775 s->csr[88] = 0x1003;
776 s->csr[89] = 0x0262;
777 s->csr[94] = 0x0000;
778 s->csr[100] = 0x0200;
779 s->csr[103] = 0x0105;
780 s->csr[103] = 0x0105;
781 s->csr[112] = 0x0000;
782 s->csr[114] = 0x0000;
783 s->csr[122] = 0x0000;
784 s->csr[124] = 0x0000;
785
786 s->tx_busy = 0;
787 }
788
789 static void pcnet_update_irq(PCNetState *s)
790 {
791 int isr = 0;
792 s->csr[0] &= ~0x0080;
793
794 #if 1
795 if (((s->csr[0] & ~s->csr[3]) & 0x5f00) ||
796 (((s->csr[4]>>1) & ~s->csr[4]) & 0x0115) ||
797 (((s->csr[5]>>1) & s->csr[5]) & 0x0048))
798 #else
799 if ((!(s->csr[3] & 0x4000) && !!(s->csr[0] & 0x4000)) /* BABL */ ||
800 (!(s->csr[3] & 0x1000) && !!(s->csr[0] & 0x1000)) /* MISS */ ||
801 (!(s->csr[3] & 0x0100) && !!(s->csr[0] & 0x0100)) /* IDON */ ||
802 (!(s->csr[3] & 0x0200) && !!(s->csr[0] & 0x0200)) /* TINT */ ||
803 (!(s->csr[3] & 0x0400) && !!(s->csr[0] & 0x0400)) /* RINT */ ||
804 (!(s->csr[3] & 0x0800) && !!(s->csr[0] & 0x0800)) /* MERR */ ||
805 (!(s->csr[4] & 0x0001) && !!(s->csr[4] & 0x0002)) /* JAB */ ||
806 (!(s->csr[4] & 0x0004) && !!(s->csr[4] & 0x0008)) /* TXSTRT */ ||
807 (!(s->csr[4] & 0x0010) && !!(s->csr[4] & 0x0020)) /* RCVO */ ||
808 (!(s->csr[4] & 0x0100) && !!(s->csr[4] & 0x0200)) /* MFCO */ ||
809 (!!(s->csr[5] & 0x0040) && !!(s->csr[5] & 0x0080)) /* EXDINT */ ||
810 (!!(s->csr[5] & 0x0008) && !!(s->csr[5] & 0x0010)) /* MPINT */)
811 #endif
812 {
813
814 isr = CSR_INEA(s);
815 s->csr[0] |= 0x0080;
816 }
817
818 if (!!(s->csr[4] & 0x0080) && CSR_INEA(s)) { /* UINT */
819 s->csr[4] &= ~0x0080;
820 s->csr[4] |= 0x0040;
821 s->csr[0] |= 0x0080;
822 isr = 1;
823 #ifdef PCNET_DEBUG
824 printf("pcnet user int\n");
825 #endif
826 }
827
828 #if 1
829 if (((s->csr[5]>>1) & s->csr[5]) & 0x0500)
830 #else
831 if ((!!(s->csr[5] & 0x0400) && !!(s->csr[5] & 0x0800)) /* SINT */ ||
832 (!!(s->csr[5] & 0x0100) && !!(s->csr[5] & 0x0200)) /* SLPINT */ )
833 #endif
834 {
835 isr = 1;
836 s->csr[0] |= 0x0080;
837 }
838
839 if (isr != s->isr) {
840 #ifdef PCNET_DEBUG
841 printf("pcnet: INTA=%d\n", isr);
842 #endif
843 }
844 qemu_set_irq(s->irq, isr);
845 s->isr = isr;
846 }
847
848 static void pcnet_init(PCNetState *s)
849 {
850 int rlen, tlen;
851 uint16_t padr[3], ladrf[4], mode;
852 uint32_t rdra, tdra;
853
854 #ifdef PCNET_DEBUG
855 printf("pcnet_init init_addr=0x%08x\n", PHYSADDR(s,CSR_IADR(s)));
856 #endif
857
858 if (BCR_SSIZE32(s)) {
859 struct pcnet_initblk32 initblk;
860 s->phys_mem_read(s->dma_opaque, PHYSADDR(s,CSR_IADR(s)),
861 (uint8_t *)&initblk, sizeof(initblk), 0);
862 mode = le16_to_cpu(initblk.mode);
863 rlen = initblk.rlen >> 4;
864 tlen = initblk.tlen >> 4;
865 ladrf[0] = le16_to_cpu(initblk.ladrf[0]);
866 ladrf[1] = le16_to_cpu(initblk.ladrf[1]);
867 ladrf[2] = le16_to_cpu(initblk.ladrf[2]);
868 ladrf[3] = le16_to_cpu(initblk.ladrf[3]);
869 padr[0] = le16_to_cpu(initblk.padr[0]);
870 padr[1] = le16_to_cpu(initblk.padr[1]);
871 padr[2] = le16_to_cpu(initblk.padr[2]);
872 rdra = le32_to_cpu(initblk.rdra);
873 tdra = le32_to_cpu(initblk.tdra);
874 } else {
875 struct pcnet_initblk16 initblk;
876 s->phys_mem_read(s->dma_opaque, PHYSADDR(s,CSR_IADR(s)),
877 (uint8_t *)&initblk, sizeof(initblk), 0);
878 mode = le16_to_cpu(initblk.mode);
879 ladrf[0] = le16_to_cpu(initblk.ladrf[0]);
880 ladrf[1] = le16_to_cpu(initblk.ladrf[1]);
881 ladrf[2] = le16_to_cpu(initblk.ladrf[2]);
882 ladrf[3] = le16_to_cpu(initblk.ladrf[3]);
883 padr[0] = le16_to_cpu(initblk.padr[0]);
884 padr[1] = le16_to_cpu(initblk.padr[1]);
885 padr[2] = le16_to_cpu(initblk.padr[2]);
886 rdra = le32_to_cpu(initblk.rdra);
887 tdra = le32_to_cpu(initblk.tdra);
888 rlen = rdra >> 29;
889 tlen = tdra >> 29;
890 rdra &= 0x00ffffff;
891 tdra &= 0x00ffffff;
892 }
893
894 #if defined(PCNET_DEBUG)
895 printf("rlen=%d tlen=%d\n", rlen, tlen);
896 #endif
897
898 CSR_RCVRL(s) = (rlen < 9) ? (1 << rlen) : 512;
899 CSR_XMTRL(s) = (tlen < 9) ? (1 << tlen) : 512;
900 s->csr[ 6] = (tlen << 12) | (rlen << 8);
901 s->csr[15] = mode;
902 s->csr[ 8] = ladrf[0];
903 s->csr[ 9] = ladrf[1];
904 s->csr[10] = ladrf[2];
905 s->csr[11] = ladrf[3];
906 s->csr[12] = padr[0];
907 s->csr[13] = padr[1];
908 s->csr[14] = padr[2];
909 s->rdra = PHYSADDR(s, rdra);
910 s->tdra = PHYSADDR(s, tdra);
911
912 CSR_RCVRC(s) = CSR_RCVRL(s);
913 CSR_XMTRC(s) = CSR_XMTRL(s);
914
915 #ifdef PCNET_DEBUG
916 printf("pcnet ss32=%d rdra=0x%08x[%d] tdra=0x%08x[%d]\n",
917 BCR_SSIZE32(s),
918 s->rdra, CSR_RCVRL(s), s->tdra, CSR_XMTRL(s));
919 #endif
920
921 s->csr[0] |= 0x0101;
922 s->csr[0] &= ~0x0004; /* clear STOP bit */
923 }
924
925 static void pcnet_start(PCNetState *s)
926 {
927 #ifdef PCNET_DEBUG
928 printf("pcnet_start\n");
929 #endif
930
931 if (!CSR_DTX(s))
932 s->csr[0] |= 0x0010; /* set TXON */
933
934 if (!CSR_DRX(s))
935 s->csr[0] |= 0x0020; /* set RXON */
936
937 s->csr[0] &= ~0x0004; /* clear STOP bit */
938 s->csr[0] |= 0x0002;
939 }
940
941 static void pcnet_stop(PCNetState *s)
942 {
943 #ifdef PCNET_DEBUG
944 printf("pcnet_stop\n");
945 #endif
946 s->csr[0] &= ~0x7feb;
947 s->csr[0] |= 0x0014;
948 s->csr[4] &= ~0x02c2;
949 s->csr[5] &= ~0x0011;
950 pcnet_poll_timer(s);
951 }
952
953 static void pcnet_rdte_poll(PCNetState *s)
954 {
955 s->csr[28] = s->csr[29] = 0;
956 if (s->rdra) {
957 int bad = 0;
958 #if 1
959 target_phys_addr_t crda = pcnet_rdra_addr(s, CSR_RCVRC(s));
960 target_phys_addr_t nrda = pcnet_rdra_addr(s, -1 + CSR_RCVRC(s));
961 target_phys_addr_t nnrd = pcnet_rdra_addr(s, -2 + CSR_RCVRC(s));
962 #else
963 target_phys_addr_t crda = s->rdra +
964 (CSR_RCVRL(s) - CSR_RCVRC(s)) *
965 (BCR_SWSTYLE(s) ? 16 : 8 );
966 int nrdc = CSR_RCVRC(s)<=1 ? CSR_RCVRL(s) : CSR_RCVRC(s)-1;
967 target_phys_addr_t nrda = s->rdra +
968 (CSR_RCVRL(s) - nrdc) *
969 (BCR_SWSTYLE(s) ? 16 : 8 );
970 int nnrc = nrdc<=1 ? CSR_RCVRL(s) : nrdc-1;
971 target_phys_addr_t nnrd = s->rdra +
972 (CSR_RCVRL(s) - nnrc) *
973 (BCR_SWSTYLE(s) ? 16 : 8 );
974 #endif
975
976 CHECK_RMD(crda, bad);
977 if (!bad) {
978 CHECK_RMD(nrda, bad);
979 if (bad || (nrda == crda)) nrda = 0;
980 CHECK_RMD(nnrd, bad);
981 if (bad || (nnrd == crda)) nnrd = 0;
982
983 s->csr[28] = crda & 0xffff;
984 s->csr[29] = crda >> 16;
985 s->csr[26] = nrda & 0xffff;
986 s->csr[27] = nrda >> 16;
987 s->csr[36] = nnrd & 0xffff;
988 s->csr[37] = nnrd >> 16;
989 #ifdef PCNET_DEBUG
990 if (bad) {
991 printf("pcnet: BAD RMD RECORDS AFTER 0x" TARGET_FMT_plx "\n",
992 crda);
993 }
994 } else {
995 printf("pcnet: BAD RMD RDA=0x" TARGET_FMT_plx "\n",
996 crda);
997 #endif
998 }
999 }
1000
1001 if (CSR_CRDA(s)) {
1002 struct pcnet_RMD rmd;
1003 RMDLOAD(&rmd, PHYSADDR(s,CSR_CRDA(s)));
1004 CSR_CRBC(s) = GET_FIELD(rmd.buf_length, RMDL, BCNT);
1005 CSR_CRST(s) = rmd.status;
1006 #ifdef PCNET_DEBUG_RMD_X
1007 printf("CRDA=0x%08x CRST=0x%04x RCVRC=%d RMDL=0x%04x RMDS=0x%04x RMDM=0x%08x\n",
1008 PHYSADDR(s,CSR_CRDA(s)), CSR_CRST(s), CSR_RCVRC(s),
1009 rmd.buf_length, rmd.status, rmd.msg_length);
1010 PRINT_RMD(&rmd);
1011 #endif
1012 } else {
1013 CSR_CRBC(s) = CSR_CRST(s) = 0;
1014 }
1015
1016 if (CSR_NRDA(s)) {
1017 struct pcnet_RMD rmd;
1018 RMDLOAD(&rmd, PHYSADDR(s,CSR_NRDA(s)));
1019 CSR_NRBC(s) = GET_FIELD(rmd.buf_length, RMDL, BCNT);
1020 CSR_NRST(s) = rmd.status;
1021 } else {
1022 CSR_NRBC(s) = CSR_NRST(s) = 0;
1023 }
1024
1025 }
1026
1027 static int pcnet_tdte_poll(PCNetState *s)
1028 {
1029 s->csr[34] = s->csr[35] = 0;
1030 if (s->tdra) {
1031 target_phys_addr_t cxda = s->tdra +
1032 (CSR_XMTRL(s) - CSR_XMTRC(s)) *
1033 (BCR_SWSTYLE(s) ? 16 : 8);
1034 int bad = 0;
1035 CHECK_TMD(cxda, bad);
1036 if (!bad) {
1037 if (CSR_CXDA(s) != cxda) {
1038 s->csr[60] = s->csr[34];
1039 s->csr[61] = s->csr[35];
1040 s->csr[62] = CSR_CXBC(s);
1041 s->csr[63] = CSR_CXST(s);
1042 }
1043 s->csr[34] = cxda & 0xffff;
1044 s->csr[35] = cxda >> 16;
1045 #ifdef PCNET_DEBUG_X
1046 printf("pcnet: BAD TMD XDA=0x%08x\n", cxda);
1047 #endif
1048 }
1049 }
1050
1051 if (CSR_CXDA(s)) {
1052 struct pcnet_TMD tmd;
1053
1054 TMDLOAD(&tmd, PHYSADDR(s,CSR_CXDA(s)));
1055
1056 CSR_CXBC(s) = GET_FIELD(tmd.length, TMDL, BCNT);
1057 CSR_CXST(s) = tmd.status;
1058 } else {
1059 CSR_CXBC(s) = CSR_CXST(s) = 0;
1060 }
1061
1062 return !!(CSR_CXST(s) & 0x8000);
1063 }
1064
1065 static int pcnet_can_receive(VLANClientState *vc)
1066 {
1067 PCNetState *s = vc->opaque;
1068 if (CSR_STOP(s) || CSR_SPND(s))
1069 return 0;
1070
1071 if (s->recv_pos > 0)
1072 return 0;
1073
1074 return sizeof(s->buffer)-16;
1075 }
1076
1077 #define MIN_BUF_SIZE 60
1078
1079 static ssize_t pcnet_receive(VLANClientState *vc, const uint8_t *buf, size_t size_)
1080 {
1081 PCNetState *s = vc->opaque;
1082 int is_padr = 0, is_bcast = 0, is_ladr = 0;
1083 uint8_t buf1[60];
1084 int remaining;
1085 int crc_err = 0;
1086 int size = size_;
1087
1088 if (CSR_DRX(s) || CSR_STOP(s) || CSR_SPND(s) || !size)
1089 return -1;
1090
1091 #ifdef PCNET_DEBUG
1092 printf("pcnet_receive size=%d\n", size);
1093 #endif
1094
1095 /* if too small buffer, then expand it */
1096 if (size < MIN_BUF_SIZE) {
1097 memcpy(buf1, buf, size);
1098 memset(buf1 + size, 0, MIN_BUF_SIZE - size);
1099 buf = buf1;
1100 size = MIN_BUF_SIZE;
1101 }
1102
1103 if (CSR_PROM(s)
1104 || (is_padr=padr_match(s, buf, size))
1105 || (is_bcast=padr_bcast(s, buf, size))
1106 || (is_ladr=ladr_match(s, buf, size))) {
1107
1108 pcnet_rdte_poll(s);
1109
1110 if (!(CSR_CRST(s) & 0x8000) && s->rdra) {
1111 struct pcnet_RMD rmd;
1112 int rcvrc = CSR_RCVRC(s)-1,i;
1113 target_phys_addr_t nrda;
1114 for (i = CSR_RCVRL(s)-1; i > 0; i--, rcvrc--) {
1115 if (rcvrc <= 1)
1116 rcvrc = CSR_RCVRL(s);
1117 nrda = s->rdra +
1118 (CSR_RCVRL(s) - rcvrc) *
1119 (BCR_SWSTYLE(s) ? 16 : 8 );
1120 RMDLOAD(&rmd, nrda);
1121 if (GET_FIELD(rmd.status, RMDS, OWN)) {
1122 #ifdef PCNET_DEBUG_RMD
1123 printf("pcnet - scan buffer: RCVRC=%d PREV_RCVRC=%d\n",
1124 rcvrc, CSR_RCVRC(s));
1125 #endif
1126 CSR_RCVRC(s) = rcvrc;
1127 pcnet_rdte_poll(s);
1128 break;
1129 }
1130 }
1131 }
1132
1133 if (!(CSR_CRST(s) & 0x8000)) {
1134 #ifdef PCNET_DEBUG_RMD
1135 printf("pcnet - no buffer: RCVRC=%d\n", CSR_RCVRC(s));
1136 #endif
1137 s->csr[0] |= 0x1000; /* Set MISS flag */
1138 CSR_MISSC(s)++;
1139 } else {
1140 uint8_t *src = s->buffer;
1141 target_phys_addr_t crda = CSR_CRDA(s);
1142 struct pcnet_RMD rmd;
1143 int pktcount = 0;
1144
1145 if (!s->looptest) {
1146 memcpy(src, buf, size);
1147 /* no need to compute the CRC */
1148 src[size] = 0;
1149 src[size + 1] = 0;
1150 src[size + 2] = 0;
1151 src[size + 3] = 0;
1152 size += 4;
1153 } else if (s->looptest == PCNET_LOOPTEST_CRC ||
1154 !CSR_DXMTFCS(s) || size < MIN_BUF_SIZE+4) {
1155 uint32_t fcs = ~0;
1156 uint8_t *p = src;
1157
1158 while (p != &src[size])
1159 CRC(fcs, *p++);
1160 *(uint32_t *)p = htonl(fcs);
1161 size += 4;
1162 } else {
1163 uint32_t fcs = ~0;
1164 uint8_t *p = src;
1165
1166 while (p != &src[size-4])
1167 CRC(fcs, *p++);
1168 crc_err = (*(uint32_t *)p != htonl(fcs));
1169 }
1170
1171 #ifdef PCNET_DEBUG_MATCH
1172 PRINT_PKTHDR(buf);
1173 #endif
1174
1175 RMDLOAD(&rmd, PHYSADDR(s,crda));
1176 /*if (!CSR_LAPPEN(s))*/
1177 SET_FIELD(&rmd.status, RMDS, STP, 1);
1178
1179 #define PCNET_RECV_STORE() do { \
1180 int count = MIN(4096 - GET_FIELD(rmd.buf_length, RMDL, BCNT),remaining); \
1181 target_phys_addr_t rbadr = PHYSADDR(s, rmd.rbadr); \
1182 s->phys_mem_write(s->dma_opaque, rbadr, src, count, CSR_BSWP(s)); \
1183 src += count; remaining -= count; \
1184 SET_FIELD(&rmd.status, RMDS, OWN, 0); \
1185 RMDSTORE(&rmd, PHYSADDR(s,crda)); \
1186 pktcount++; \
1187 } while (0)
1188
1189 remaining = size;
1190 PCNET_RECV_STORE();
1191 if ((remaining > 0) && CSR_NRDA(s)) {
1192 target_phys_addr_t nrda = CSR_NRDA(s);
1193 #ifdef PCNET_DEBUG_RMD
1194 PRINT_RMD(&rmd);
1195 #endif
1196 RMDLOAD(&rmd, PHYSADDR(s,nrda));
1197 if (GET_FIELD(rmd.status, RMDS, OWN)) {
1198 crda = nrda;
1199 PCNET_RECV_STORE();
1200 #ifdef PCNET_DEBUG_RMD
1201 PRINT_RMD(&rmd);
1202 #endif
1203 if ((remaining > 0) && (nrda=CSR_NNRD(s))) {
1204 RMDLOAD(&rmd, PHYSADDR(s,nrda));
1205 if (GET_FIELD(rmd.status, RMDS, OWN)) {
1206 crda = nrda;
1207 PCNET_RECV_STORE();
1208 }
1209 }
1210 }
1211 }
1212
1213 #undef PCNET_RECV_STORE
1214
1215 RMDLOAD(&rmd, PHYSADDR(s,crda));
1216 if (remaining == 0) {
1217 SET_FIELD(&rmd.msg_length, RMDM, MCNT, size);
1218 SET_FIELD(&rmd.status, RMDS, ENP, 1);
1219 SET_FIELD(&rmd.status, RMDS, PAM, !CSR_PROM(s) && is_padr);
1220 SET_FIELD(&rmd.status, RMDS, LFAM, !CSR_PROM(s) && is_ladr);
1221 SET_FIELD(&rmd.status, RMDS, BAM, !CSR_PROM(s) && is_bcast);
1222 if (crc_err) {
1223 SET_FIELD(&rmd.status, RMDS, CRC, 1);
1224 SET_FIELD(&rmd.status, RMDS, ERR, 1);
1225 }
1226 } else {
1227 SET_FIELD(&rmd.status, RMDS, OFLO, 1);
1228 SET_FIELD(&rmd.status, RMDS, BUFF, 1);
1229 SET_FIELD(&rmd.status, RMDS, ERR, 1);
1230 }
1231 RMDSTORE(&rmd, PHYSADDR(s,crda));
1232 s->csr[0] |= 0x0400;
1233
1234 #ifdef PCNET_DEBUG
1235 printf("RCVRC=%d CRDA=0x%08x BLKS=%d\n",
1236 CSR_RCVRC(s), PHYSADDR(s,CSR_CRDA(s)), pktcount);
1237 #endif
1238 #ifdef PCNET_DEBUG_RMD
1239 PRINT_RMD(&rmd);
1240 #endif
1241
1242 while (pktcount--) {
1243 if (CSR_RCVRC(s) <= 1)
1244 CSR_RCVRC(s) = CSR_RCVRL(s);
1245 else
1246 CSR_RCVRC(s)--;
1247 }
1248
1249 pcnet_rdte_poll(s);
1250
1251 }
1252 }
1253
1254 pcnet_poll(s);
1255 pcnet_update_irq(s);
1256
1257 return size_;
1258 }
1259
1260 static void pcnet_transmit(PCNetState *s)
1261 {
1262 target_phys_addr_t xmit_cxda = 0;
1263 int count = CSR_XMTRL(s)-1;
1264 int add_crc = 0;
1265
1266 s->xmit_pos = -1;
1267
1268 if (!CSR_TXON(s)) {
1269 s->csr[0] &= ~0x0008;
1270 return;
1271 }
1272
1273 s->tx_busy = 1;
1274
1275 txagain:
1276 if (pcnet_tdte_poll(s)) {
1277 struct pcnet_TMD tmd;
1278
1279 TMDLOAD(&tmd, PHYSADDR(s,CSR_CXDA(s)));
1280
1281 #ifdef PCNET_DEBUG_TMD
1282 printf(" TMDLOAD 0x%08x\n", PHYSADDR(s,CSR_CXDA(s)));
1283 PRINT_TMD(&tmd);
1284 #endif
1285 if (GET_FIELD(tmd.status, TMDS, STP)) {
1286 s->xmit_pos = 0;
1287 xmit_cxda = PHYSADDR(s,CSR_CXDA(s));
1288 if (BCR_SWSTYLE(s) != 1)
1289 add_crc = GET_FIELD(tmd.status, TMDS, ADDFCS);
1290 }
1291 if (!GET_FIELD(tmd.status, TMDS, ENP)) {
1292 int bcnt = 4096 - GET_FIELD(tmd.length, TMDL, BCNT);
1293 s->phys_mem_read(s->dma_opaque, PHYSADDR(s, tmd.tbadr),
1294 s->buffer + s->xmit_pos, bcnt, CSR_BSWP(s));
1295 s->xmit_pos += bcnt;
1296 } else if (s->xmit_pos >= 0) {
1297 int bcnt = 4096 - GET_FIELD(tmd.length, TMDL, BCNT);
1298 s->phys_mem_read(s->dma_opaque, PHYSADDR(s, tmd.tbadr),
1299 s->buffer + s->xmit_pos, bcnt, CSR_BSWP(s));
1300 s->xmit_pos += bcnt;
1301 #ifdef PCNET_DEBUG
1302 printf("pcnet_transmit size=%d\n", s->xmit_pos);
1303 #endif
1304 if (CSR_LOOP(s)) {
1305 if (BCR_SWSTYLE(s) == 1)
1306 add_crc = !GET_FIELD(tmd.status, TMDS, NOFCS);
1307 s->looptest = add_crc ? PCNET_LOOPTEST_CRC : PCNET_LOOPTEST_NOCRC;
1308 pcnet_receive(s->vc, s->buffer, s->xmit_pos);
1309 s->looptest = 0;
1310 } else
1311 if (s->vc)
1312 qemu_send_packet(s->vc, s->buffer, s->xmit_pos);
1313
1314 s->csr[0] &= ~0x0008; /* clear TDMD */
1315 s->csr[4] |= 0x0004; /* set TXSTRT */
1316 s->xmit_pos = -1;
1317 }
1318
1319 SET_FIELD(&tmd.status, TMDS, OWN, 0);
1320 TMDSTORE(&tmd, PHYSADDR(s,CSR_CXDA(s)));
1321 if (!CSR_TOKINTD(s) || (CSR_LTINTEN(s) && GET_FIELD(tmd.status, TMDS, LTINT)))
1322 s->csr[0] |= 0x0200; /* set TINT */
1323
1324 if (CSR_XMTRC(s)<=1)
1325 CSR_XMTRC(s) = CSR_XMTRL(s);
1326 else
1327 CSR_XMTRC(s)--;
1328 if (count--)
1329 goto txagain;
1330
1331 } else
1332 if (s->xmit_pos >= 0) {
1333 struct pcnet_TMD tmd;
1334 TMDLOAD(&tmd, xmit_cxda);
1335 SET_FIELD(&tmd.misc, TMDM, BUFF, 1);
1336 SET_FIELD(&tmd.misc, TMDM, UFLO, 1);
1337 SET_FIELD(&tmd.status, TMDS, ERR, 1);
1338 SET_FIELD(&tmd.status, TMDS, OWN, 0);
1339 TMDSTORE(&tmd, xmit_cxda);
1340 s->csr[0] |= 0x0200; /* set TINT */
1341 if (!CSR_DXSUFLO(s)) {
1342 s->csr[0] &= ~0x0010;
1343 } else
1344 if (count--)
1345 goto txagain;
1346 }
1347
1348 s->tx_busy = 0;
1349 }
1350
1351 static void pcnet_poll(PCNetState *s)
1352 {
1353 if (CSR_RXON(s)) {
1354 pcnet_rdte_poll(s);
1355 }
1356
1357 if (CSR_TDMD(s) ||
1358 (CSR_TXON(s) && !CSR_DPOLL(s) && pcnet_tdte_poll(s)))
1359 {
1360 /* prevent recursion */
1361 if (s->tx_busy)
1362 return;
1363
1364 pcnet_transmit(s);
1365 }
1366 }
1367
1368 static void pcnet_poll_timer(void *opaque)
1369 {
1370 PCNetState *s = opaque;
1371
1372 qemu_del_timer(s->poll_timer);
1373
1374 if (CSR_TDMD(s)) {
1375 pcnet_transmit(s);
1376 }
1377
1378 pcnet_update_irq(s);
1379
1380 if (!CSR_STOP(s) && !CSR_SPND(s) && !CSR_DPOLL(s)) {
1381 uint64_t now = qemu_get_clock(vm_clock) * 33;
1382 if (!s->timer || !now)
1383 s->timer = now;
1384 else {
1385 uint64_t t = now - s->timer + CSR_POLL(s);
1386 if (t > 0xffffLL) {
1387 pcnet_poll(s);
1388 CSR_POLL(s) = CSR_PINT(s);
1389 } else
1390 CSR_POLL(s) = t;
1391 }
1392 qemu_mod_timer(s->poll_timer,
1393 pcnet_get_next_poll_time(s,qemu_get_clock(vm_clock)));
1394 }
1395 }
1396
1397
1398 static void pcnet_csr_writew(PCNetState *s, uint32_t rap, uint32_t new_value)
1399 {
1400 uint16_t val = new_value;
1401 #ifdef PCNET_DEBUG_CSR
1402 printf("pcnet_csr_writew rap=%d val=0x%04x\n", rap, val);
1403 #endif
1404 switch (rap) {
1405 case 0:
1406 s->csr[0] &= ~(val & 0x7f00); /* Clear any interrupt flags */
1407
1408 s->csr[0] = (s->csr[0] & ~0x0040) | (val & 0x0048);
1409
1410 val = (val & 0x007f) | (s->csr[0] & 0x7f00);
1411
1412 /* IFF STOP, STRT and INIT are set, clear STRT and INIT */
1413 if ((val&7) == 7)
1414 val &= ~3;
1415
1416 if (!CSR_STOP(s) && (val & 4))
1417 pcnet_stop(s);
1418
1419 if (!CSR_INIT(s) && (val & 1))
1420 pcnet_init(s);
1421
1422 if (!CSR_STRT(s) && (val & 2))
1423 pcnet_start(s);
1424
1425 if (CSR_TDMD(s))
1426 pcnet_transmit(s);
1427
1428 return;
1429 case 1:
1430 case 2:
1431 case 8:
1432 case 9:
1433 case 10:
1434 case 11:
1435 case 12:
1436 case 13:
1437 case 14:
1438 case 15:
1439 case 18: /* CRBAL */
1440 case 19: /* CRBAU */
1441 case 20: /* CXBAL */
1442 case 21: /* CXBAU */
1443 case 22: /* NRBAU */
1444 case 23: /* NRBAU */
1445 case 24:
1446 case 25:
1447 case 26:
1448 case 27:
1449 case 28:
1450 case 29:
1451 case 30:
1452 case 31:
1453 case 32:
1454 case 33:
1455 case 34:
1456 case 35:
1457 case 36:
1458 case 37:
1459 case 38:
1460 case 39:
1461 case 40: /* CRBC */
1462 case 41:
1463 case 42: /* CXBC */
1464 case 43:
1465 case 44:
1466 case 45:
1467 case 46: /* POLL */
1468 case 47: /* POLLINT */
1469 case 72:
1470 case 74:
1471 case 76: /* RCVRL */
1472 case 78: /* XMTRL */
1473 case 112:
1474 if (CSR_STOP(s) || CSR_SPND(s))
1475 break;
1476 return;
1477 case 3:
1478 break;
1479 case 4:
1480 s->csr[4] &= ~(val & 0x026a);
1481 val &= ~0x026a; val |= s->csr[4] & 0x026a;
1482 break;
1483 case 5:
1484 s->csr[5] &= ~(val & 0x0a90);
1485 val &= ~0x0a90; val |= s->csr[5] & 0x0a90;
1486 break;
1487 case 16:
1488 pcnet_csr_writew(s,1,val);
1489 return;
1490 case 17:
1491 pcnet_csr_writew(s,2,val);
1492 return;
1493 case 58:
1494 pcnet_bcr_writew(s,BCR_SWS,val);
1495 break;
1496 default:
1497 return;
1498 }
1499 s->csr[rap] = val;
1500 }
1501
1502 static uint32_t pcnet_csr_readw(PCNetState *s, uint32_t rap)
1503 {
1504 uint32_t val;
1505 switch (rap) {
1506 case 0:
1507 pcnet_update_irq(s);
1508 val = s->csr[0];
1509 val |= (val & 0x7800) ? 0x8000 : 0;
1510 break;
1511 case 16:
1512 return pcnet_csr_readw(s,1);
1513 case 17:
1514 return pcnet_csr_readw(s,2);
1515 case 58:
1516 return pcnet_bcr_readw(s,BCR_SWS);
1517 case 88:
1518 val = s->csr[89];
1519 val <<= 16;
1520 val |= s->csr[88];
1521 break;
1522 default:
1523 val = s->csr[rap];
1524 }
1525 #ifdef PCNET_DEBUG_CSR
1526 printf("pcnet_csr_readw rap=%d val=0x%04x\n", rap, val);
1527 #endif
1528 return val;
1529 }
1530
1531 static void pcnet_bcr_writew(PCNetState *s, uint32_t rap, uint32_t val)
1532 {
1533 rap &= 127;
1534 #ifdef PCNET_DEBUG_BCR
1535 printf("pcnet_bcr_writew rap=%d val=0x%04x\n", rap, val);
1536 #endif
1537 switch (rap) {
1538 case BCR_SWS:
1539 if (!(CSR_STOP(s) || CSR_SPND(s)))
1540 return;
1541 val &= ~0x0300;
1542 switch (val & 0x00ff) {
1543 case 0:
1544 val |= 0x0200;
1545 break;
1546 case 1:
1547 val |= 0x0100;
1548 break;
1549 case 2:
1550 case 3:
1551 val |= 0x0300;
1552 break;
1553 default:
1554 printf("Bad SWSTYLE=0x%02x\n", val & 0xff);
1555 val = 0x0200;
1556 break;
1557 }
1558 #ifdef PCNET_DEBUG
1559 printf("BCR_SWS=0x%04x\n", val);
1560 #endif
1561 case BCR_LNKST:
1562 case BCR_LED1:
1563 case BCR_LED2:
1564 case BCR_LED3:
1565 case BCR_MC:
1566 case BCR_FDC:
1567 case BCR_BSBC:
1568 case BCR_EECAS:
1569 case BCR_PLAT:
1570 s->bcr[rap] = val;
1571 break;
1572 default:
1573 break;
1574 }
1575 }
1576
1577 static uint32_t pcnet_bcr_readw(PCNetState *s, uint32_t rap)
1578 {
1579 uint32_t val;
1580 rap &= 127;
1581 switch (rap) {
1582 case BCR_LNKST:
1583 case BCR_LED1:
1584 case BCR_LED2:
1585 case BCR_LED3:
1586 val = s->bcr[rap] & ~0x8000;
1587 val |= (val & 0x017f & s->lnkst) ? 0x8000 : 0;
1588 break;
1589 default:
1590 val = rap < 32 ? s->bcr[rap] : 0;
1591 break;
1592 }
1593 #ifdef PCNET_DEBUG_BCR
1594 printf("pcnet_bcr_readw rap=%d val=0x%04x\n", rap, val);
1595 #endif
1596 return val;
1597 }
1598
1599 static void pcnet_h_reset(void *opaque)
1600 {
1601 PCNetState *s = opaque;
1602 int i;
1603 uint16_t checksum;
1604
1605 /* Initialize the PROM */
1606
1607 memcpy(s->prom, s->macaddr, 6);
1608 s->prom[12] = s->prom[13] = 0x00;
1609 s->prom[14] = s->prom[15] = 0x57;
1610
1611 for (i = 0,checksum = 0; i < 16; i++)
1612 checksum += s->prom[i];
1613 *(uint16_t *)&s->prom[12] = cpu_to_le16(checksum);
1614
1615
1616 s->bcr[BCR_MSRDA] = 0x0005;
1617 s->bcr[BCR_MSWRA] = 0x0005;
1618 s->bcr[BCR_MC ] = 0x0002;
1619 s->bcr[BCR_LNKST] = 0x00c0;
1620 s->bcr[BCR_LED1 ] = 0x0084;
1621 s->bcr[BCR_LED2 ] = 0x0088;
1622 s->bcr[BCR_LED3 ] = 0x0090;
1623 s->bcr[BCR_FDC ] = 0x0000;
1624 s->bcr[BCR_BSBC ] = 0x9001;
1625 s->bcr[BCR_EECAS] = 0x0002;
1626 s->bcr[BCR_SWS ] = 0x0200;
1627 s->bcr[BCR_PLAT ] = 0xff06;
1628
1629 pcnet_s_reset(s);
1630 }
1631
1632 static void pcnet_aprom_writeb(void *opaque, uint32_t addr, uint32_t val)
1633 {
1634 PCNetState *s = opaque;
1635 #ifdef PCNET_DEBUG
1636 printf("pcnet_aprom_writeb addr=0x%08x val=0x%02x\n", addr, val);
1637 #endif
1638 /* Check APROMWE bit to enable write access */
1639 if (pcnet_bcr_readw(s,2) & 0x80)
1640 s->prom[addr & 15] = val;
1641 }
1642
1643 static uint32_t pcnet_aprom_readb(void *opaque, uint32_t addr)
1644 {
1645 PCNetState *s = opaque;
1646 uint32_t val = s->prom[addr &= 15];
1647 #ifdef PCNET_DEBUG
1648 printf("pcnet_aprom_readb addr=0x%08x val=0x%02x\n", addr, val);
1649 #endif
1650 return val;
1651 }
1652
1653 static void pcnet_ioport_writew(void *opaque, uint32_t addr, uint32_t val)
1654 {
1655 PCNetState *s = opaque;
1656 pcnet_poll_timer(s);
1657 #ifdef PCNET_DEBUG_IO
1658 printf("pcnet_ioport_writew addr=0x%08x val=0x%04x\n", addr, val);
1659 #endif
1660 if (!BCR_DWIO(s)) {
1661 switch (addr & 0x0f) {
1662 case 0x00: /* RDP */
1663 pcnet_csr_writew(s, s->rap, val);
1664 break;
1665 case 0x02:
1666 s->rap = val & 0x7f;
1667 break;
1668 case 0x06:
1669 pcnet_bcr_writew(s, s->rap, val);
1670 break;
1671 }
1672 }
1673 pcnet_update_irq(s);
1674 }
1675
1676 static uint32_t pcnet_ioport_readw(void *opaque, uint32_t addr)
1677 {
1678 PCNetState *s = opaque;
1679 uint32_t val = -1;
1680 pcnet_poll_timer(s);
1681 if (!BCR_DWIO(s)) {
1682 switch (addr & 0x0f) {
1683 case 0x00: /* RDP */
1684 val = pcnet_csr_readw(s, s->rap);
1685 break;
1686 case 0x02:
1687 val = s->rap;
1688 break;
1689 case 0x04:
1690 pcnet_s_reset(s);
1691 val = 0;
1692 break;
1693 case 0x06:
1694 val = pcnet_bcr_readw(s, s->rap);
1695 break;
1696 }
1697 }
1698 pcnet_update_irq(s);
1699 #ifdef PCNET_DEBUG_IO
1700 printf("pcnet_ioport_readw addr=0x%08x val=0x%04x\n", addr, val & 0xffff);
1701 #endif
1702 return val;
1703 }
1704
1705 static void pcnet_ioport_writel(void *opaque, uint32_t addr, uint32_t val)
1706 {
1707 PCNetState *s = opaque;
1708 pcnet_poll_timer(s);
1709 #ifdef PCNET_DEBUG_IO
1710 printf("pcnet_ioport_writel addr=0x%08x val=0x%08x\n", addr, val);
1711 #endif
1712 if (BCR_DWIO(s)) {
1713 switch (addr & 0x0f) {
1714 case 0x00: /* RDP */
1715 pcnet_csr_writew(s, s->rap, val & 0xffff);
1716 break;
1717 case 0x04:
1718 s->rap = val & 0x7f;
1719 break;
1720 case 0x0c:
1721 pcnet_bcr_writew(s, s->rap, val & 0xffff);
1722 break;
1723 }
1724 } else
1725 if ((addr & 0x0f) == 0) {
1726 /* switch device to dword i/o mode */
1727 pcnet_bcr_writew(s, BCR_BSBC, pcnet_bcr_readw(s, BCR_BSBC) | 0x0080);
1728 #ifdef PCNET_DEBUG_IO
1729 printf("device switched into dword i/o mode\n");
1730 #endif
1731 }
1732 pcnet_update_irq(s);
1733 }
1734
1735 static uint32_t pcnet_ioport_readl(void *opaque, uint32_t addr)
1736 {
1737 PCNetState *s = opaque;
1738 uint32_t val = -1;
1739 pcnet_poll_timer(s);
1740 if (BCR_DWIO(s)) {
1741 switch (addr & 0x0f) {
1742 case 0x00: /* RDP */
1743 val = pcnet_csr_readw(s, s->rap);
1744 break;
1745 case 0x04:
1746 val = s->rap;
1747 break;
1748 case 0x08:
1749 pcnet_s_reset(s);
1750 val = 0;
1751 break;
1752 case 0x0c:
1753 val = pcnet_bcr_readw(s, s->rap);
1754 break;
1755 }
1756 }
1757 pcnet_update_irq(s);
1758 #ifdef PCNET_DEBUG_IO
1759 printf("pcnet_ioport_readl addr=0x%08x val=0x%08x\n", addr, val);
1760 #endif
1761 return val;
1762 }
1763
1764 static void pcnet_ioport_map(PCIDevice *pci_dev, int region_num,
1765 uint32_t addr, uint32_t size, int type)
1766 {
1767 PCNetState *d = &((PCIPCNetState *)pci_dev)->state;
1768
1769 #ifdef PCNET_DEBUG_IO
1770 printf("pcnet_ioport_map addr=0x%04x size=0x%04x\n", addr, size);
1771 #endif
1772
1773 register_ioport_write(addr, 16, 1, pcnet_aprom_writeb, d);
1774 register_ioport_read(addr, 16, 1, pcnet_aprom_readb, d);
1775
1776 register_ioport_write(addr + 0x10, 0x10, 2, pcnet_ioport_writew, d);
1777 register_ioport_read(addr + 0x10, 0x10, 2, pcnet_ioport_readw, d);
1778 register_ioport_write(addr + 0x10, 0x10, 4, pcnet_ioport_writel, d);
1779 register_ioport_read(addr + 0x10, 0x10, 4, pcnet_ioport_readl, d);
1780 }
1781
1782 static void pcnet_mmio_writeb(void *opaque, target_phys_addr_t addr, uint32_t val)
1783 {
1784 PCNetState *d = opaque;
1785 #ifdef PCNET_DEBUG_IO
1786 printf("pcnet_mmio_writeb addr=0x" TARGET_FMT_plx" val=0x%02x\n", addr,
1787 val);
1788 #endif
1789 if (!(addr & 0x10))
1790 pcnet_aprom_writeb(d, addr & 0x0f, val);
1791 }
1792
1793 static uint32_t pcnet_mmio_readb(void *opaque, target_phys_addr_t addr)
1794 {
1795 PCNetState *d = opaque;
1796 uint32_t val = -1;
1797 if (!(addr & 0x10))
1798 val = pcnet_aprom_readb(d, addr & 0x0f);
1799 #ifdef PCNET_DEBUG_IO
1800 printf("pcnet_mmio_readb addr=0x" TARGET_FMT_plx " val=0x%02x\n", addr,
1801 val & 0xff);
1802 #endif
1803 return val;
1804 }
1805
1806 static void pcnet_mmio_writew(void *opaque, target_phys_addr_t addr, uint32_t val)
1807 {
1808 PCNetState *d = opaque;
1809 #ifdef PCNET_DEBUG_IO
1810 printf("pcnet_mmio_writew addr=0x" TARGET_FMT_plx " val=0x%04x\n", addr,
1811 val);
1812 #endif
1813 if (addr & 0x10)
1814 pcnet_ioport_writew(d, addr & 0x0f, val);
1815 else {
1816 addr &= 0x0f;
1817 pcnet_aprom_writeb(d, addr, val & 0xff);
1818 pcnet_aprom_writeb(d, addr+1, (val & 0xff00) >> 8);
1819 }
1820 }
1821
1822 static uint32_t pcnet_mmio_readw(void *opaque, target_phys_addr_t addr)
1823 {
1824 PCNetState *d = opaque;
1825 uint32_t val = -1;
1826 if (addr & 0x10)
1827 val = pcnet_ioport_readw(d, addr & 0x0f);
1828 else {
1829 addr &= 0x0f;
1830 val = pcnet_aprom_readb(d, addr+1);
1831 val <<= 8;
1832 val |= pcnet_aprom_readb(d, addr);
1833 }
1834 #ifdef PCNET_DEBUG_IO
1835 printf("pcnet_mmio_readw addr=0x" TARGET_FMT_plx" val = 0x%04x\n", addr,
1836 val & 0xffff);
1837 #endif
1838 return val;
1839 }
1840
1841 static void pcnet_mmio_writel(void *opaque, target_phys_addr_t addr, uint32_t val)
1842 {
1843 PCNetState *d = opaque;
1844 #ifdef PCNET_DEBUG_IO
1845 printf("pcnet_mmio_writel addr=0x" TARGET_FMT_plx" val=0x%08x\n", addr,
1846 val);
1847 #endif
1848 if (addr & 0x10)
1849 pcnet_ioport_writel(d, addr & 0x0f, val);
1850 else {
1851 addr &= 0x0f;
1852 pcnet_aprom_writeb(d, addr, val & 0xff);
1853 pcnet_aprom_writeb(d, addr+1, (val & 0xff00) >> 8);
1854 pcnet_aprom_writeb(d, addr+2, (val & 0xff0000) >> 16);
1855 pcnet_aprom_writeb(d, addr+3, (val & 0xff000000) >> 24);
1856 }
1857 }
1858
1859 static uint32_t pcnet_mmio_readl(void *opaque, target_phys_addr_t addr)
1860 {
1861 PCNetState *d = opaque;
1862 uint32_t val;
1863 if (addr & 0x10)
1864 val = pcnet_ioport_readl(d, addr & 0x0f);
1865 else {
1866 addr &= 0x0f;
1867 val = pcnet_aprom_readb(d, addr+3);
1868 val <<= 8;
1869 val |= pcnet_aprom_readb(d, addr+2);
1870 val <<= 8;
1871 val |= pcnet_aprom_readb(d, addr+1);
1872 val <<= 8;
1873 val |= pcnet_aprom_readb(d, addr);
1874 }
1875 #ifdef PCNET_DEBUG_IO
1876 printf("pcnet_mmio_readl addr=0x" TARGET_FMT_plx " val=0x%08x\n", addr,
1877 val);
1878 #endif
1879 return val;
1880 }
1881
1882
1883 static void pcnet_save(QEMUFile *f, void *opaque)
1884 {
1885 PCNetState *s = opaque;
1886 unsigned int i;
1887
1888 if (s->pci_dev)
1889 pci_device_save(s->pci_dev, f);
1890
1891 qemu_put_sbe32(f, s->rap);
1892 qemu_put_sbe32(f, s->isr);
1893 qemu_put_sbe32(f, s->lnkst);
1894 qemu_put_be32s(f, &s->rdra);
1895 qemu_put_be32s(f, &s->tdra);
1896 qemu_put_buffer(f, s->prom, 16);
1897 for (i = 0; i < 128; i++)
1898 qemu_put_be16s(f, &s->csr[i]);
1899 for (i = 0; i < 32; i++)
1900 qemu_put_be16s(f, &s->bcr[i]);
1901 qemu_put_be64s(f, &s->timer);
1902 qemu_put_sbe32(f, s->xmit_pos);
1903 qemu_put_sbe32(f, s->recv_pos);
1904 qemu_put_buffer(f, s->buffer, 4096);
1905 qemu_put_sbe32(f, s->tx_busy);
1906 qemu_put_timer(f, s->poll_timer);
1907 }
1908
1909 static int pcnet_load(QEMUFile *f, void *opaque, int version_id)
1910 {
1911 PCNetState *s = opaque;
1912 int i, ret;
1913
1914 if (version_id != 2)
1915 return -EINVAL;
1916
1917 if (s->pci_dev) {
1918 ret = pci_device_load(s->pci_dev, f);
1919 if (ret < 0)
1920 return ret;
1921 }
1922
1923 qemu_get_sbe32s(f, &s->rap);
1924 qemu_get_sbe32s(f, &s->isr);
1925 qemu_get_sbe32s(f, &s->lnkst);
1926 qemu_get_be32s(f, &s->rdra);
1927 qemu_get_be32s(f, &s->tdra);
1928 qemu_get_buffer(f, s->prom, 16);
1929 for (i = 0; i < 128; i++)
1930 qemu_get_be16s(f, &s->csr[i]);
1931 for (i = 0; i < 32; i++)
1932 qemu_get_be16s(f, &s->bcr[i]);
1933 qemu_get_be64s(f, &s->timer);
1934 qemu_get_sbe32s(f, &s->xmit_pos);
1935 qemu_get_sbe32s(f, &s->recv_pos);
1936 qemu_get_buffer(f, s->buffer, 4096);
1937 qemu_get_sbe32s(f, &s->tx_busy);
1938 qemu_get_timer(f, s->poll_timer);
1939
1940 return 0;
1941 }
1942
1943 static void pcnet_common_cleanup(PCNetState *d)
1944 {
1945 unregister_savevm("pcnet", d);
1946
1947 qemu_del_timer(d->poll_timer);
1948 qemu_free_timer(d->poll_timer);
1949 }
1950
1951 static void pcnet_common_init(DeviceState *dev, PCNetState *s,
1952 NetCleanup *cleanup)
1953 {
1954 s->poll_timer = qemu_new_timer(vm_clock, pcnet_poll_timer, s);
1955
1956 qdev_get_macaddr(dev, s->macaddr);
1957 s->vc = qdev_get_vlan_client(dev,
1958 pcnet_can_receive, pcnet_receive, NULL,
1959 cleanup, s);
1960 pcnet_h_reset(s);
1961 register_savevm("pcnet", -1, 2, pcnet_save, pcnet_load, s);
1962 }
1963
1964 /* PCI interface */
1965
1966 static CPUWriteMemoryFunc *pcnet_mmio_write[] = {
1967 (CPUWriteMemoryFunc *)&pcnet_mmio_writeb,
1968 (CPUWriteMemoryFunc *)&pcnet_mmio_writew,
1969 (CPUWriteMemoryFunc *)&pcnet_mmio_writel
1970 };
1971
1972 static CPUReadMemoryFunc *pcnet_mmio_read[] = {
1973 (CPUReadMemoryFunc *)&pcnet_mmio_readb,
1974 (CPUReadMemoryFunc *)&pcnet_mmio_readw,
1975 (CPUReadMemoryFunc *)&pcnet_mmio_readl
1976 };
1977
1978 static void pcnet_mmio_map(PCIDevice *pci_dev, int region_num,
1979 uint32_t addr, uint32_t size, int type)
1980 {
1981 PCIPCNetState *d = (PCIPCNetState *)pci_dev;
1982
1983 #ifdef PCNET_DEBUG_IO
1984 printf("pcnet_mmio_map addr=0x%08x 0x%08x\n", addr, size);
1985 #endif
1986
1987 cpu_register_physical_memory(addr, PCNET_PNPMMIO_SIZE, d->state.mmio_index);
1988 }
1989
1990 static void pci_physical_memory_write(void *dma_opaque, target_phys_addr_t addr,
1991 uint8_t *buf, int len, int do_bswap)
1992 {
1993 cpu_physical_memory_write(addr, buf, len);
1994 }
1995
1996 static void pci_physical_memory_read(void *dma_opaque, target_phys_addr_t addr,
1997 uint8_t *buf, int len, int do_bswap)
1998 {
1999 cpu_physical_memory_read(addr, buf, len);
2000 }
2001
2002 static void pci_pcnet_cleanup(VLANClientState *vc)
2003 {
2004 PCNetState *d = vc->opaque;
2005
2006 pcnet_common_cleanup(d);
2007 }
2008
2009 static int pci_pcnet_uninit(PCIDevice *dev)
2010 {
2011 PCIPCNetState *d = (PCIPCNetState *)dev;
2012
2013 cpu_unregister_io_memory(d->state.mmio_index);
2014
2015 return 0;
2016 }
2017
2018 static void pci_pcnet_init(PCIDevice *pci_dev)
2019 {
2020 PCIPCNetState *d = (PCIPCNetState *)pci_dev;
2021 PCNetState *s = &d->state;
2022 uint8_t *pci_conf;
2023
2024 #if 0
2025 printf("sizeof(RMD)=%d, sizeof(TMD)=%d\n",
2026 sizeof(struct pcnet_RMD), sizeof(struct pcnet_TMD));
2027 #endif
2028
2029 pci_dev->unregister = pci_pcnet_uninit;
2030
2031 pci_conf = pci_dev->config;
2032
2033 pci_config_set_vendor_id(pci_conf, PCI_VENDOR_ID_AMD);
2034 pci_config_set_device_id(pci_conf, PCI_DEVICE_ID_AMD_LANCE);
2035 *(uint16_t *)&pci_conf[0x04] = cpu_to_le16(0x0007);
2036 *(uint16_t *)&pci_conf[0x06] = cpu_to_le16(0x0280);
2037 pci_conf[0x08] = 0x10;
2038 pci_conf[0x09] = 0x00;
2039 pci_config_set_class(pci_conf, PCI_CLASS_NETWORK_ETHERNET);
2040 pci_conf[PCI_HEADER_TYPE] = PCI_HEADER_TYPE_NORMAL; // header_type
2041
2042 *(uint32_t *)&pci_conf[0x10] = cpu_to_le32(0x00000001);
2043 *(uint32_t *)&pci_conf[0x14] = cpu_to_le32(0x00000000);
2044
2045 pci_conf[0x3d] = 1; // interrupt pin 0
2046 pci_conf[0x3e] = 0x06;
2047 pci_conf[0x3f] = 0xff;
2048
2049 /* Handler for memory-mapped I/O */
2050 s->mmio_index =
2051 cpu_register_io_memory(pcnet_mmio_read, pcnet_mmio_write, &d->state);
2052
2053 pci_register_bar((PCIDevice *)d, 0, PCNET_IOPORT_SIZE,
2054 PCI_ADDRESS_SPACE_IO, pcnet_ioport_map);
2055
2056 pci_register_bar((PCIDevice *)d, 1, PCNET_PNPMMIO_SIZE,
2057 PCI_ADDRESS_SPACE_MEM, pcnet_mmio_map);
2058
2059 s->irq = pci_dev->irq[0];
2060 s->phys_mem_read = pci_physical_memory_read;
2061 s->phys_mem_write = pci_physical_memory_write;
2062 s->pci_dev = pci_dev;
2063
2064 pcnet_common_init(&pci_dev->qdev, s, pci_pcnet_cleanup);
2065 }
2066
2067 /* SPARC32 interface */
2068
2069 #if defined (TARGET_SPARC) && !defined(TARGET_SPARC64) // Avoid compile failure
2070 #include "sun4m.h"
2071
2072 static void parent_lance_reset(void *opaque, int irq, int level)
2073 {
2074 SysBusPCNetState *d = opaque;
2075 if (level)
2076 pcnet_h_reset(&d->state);
2077 }
2078
2079 static void lance_mem_writew(void *opaque, target_phys_addr_t addr,
2080 uint32_t val)
2081 {
2082 SysBusPCNetState *d = opaque;
2083 #ifdef PCNET_DEBUG_IO
2084 printf("lance_mem_writew addr=" TARGET_FMT_plx " val=0x%04x\n", addr,
2085 val & 0xffff);
2086 #endif
2087 pcnet_ioport_writew(&d->state, addr, val & 0xffff);
2088 }
2089
2090 static uint32_t lance_mem_readw(void *opaque, target_phys_addr_t addr)
2091 {
2092 SysBusPCNetState *d = opaque;
2093 uint32_t val;
2094
2095 val = pcnet_ioport_readw(&d->state, addr);
2096 #ifdef PCNET_DEBUG_IO
2097 printf("lance_mem_readw addr=" TARGET_FMT_plx " val = 0x%04x\n", addr,
2098 val & 0xffff);
2099 #endif
2100
2101 return val & 0xffff;
2102 }
2103
2104 static CPUReadMemoryFunc *lance_mem_read[3] = {
2105 NULL,
2106 lance_mem_readw,
2107 NULL,
2108 };
2109
2110 static CPUWriteMemoryFunc *lance_mem_write[3] = {
2111 NULL,
2112 lance_mem_writew,
2113 NULL,
2114 };
2115
2116 static void lance_cleanup(VLANClientState *vc)
2117 {
2118 PCNetState *d = vc->opaque;
2119
2120 pcnet_common_cleanup(d);
2121 }
2122
2123 static void lance_init(SysBusDevice *dev)
2124 {
2125 SysBusPCNetState *d = FROM_SYSBUS(SysBusPCNetState, dev);
2126 PCNetState *s = &d->state;
2127
2128 s->mmio_index =
2129 cpu_register_io_memory(lance_mem_read, lance_mem_write, d);
2130
2131 s->dma_opaque = qdev_get_prop_ptr(&dev->qdev, "dma");
2132
2133 qdev_init_gpio_in(&dev->qdev, parent_lance_reset, 1);
2134
2135 sysbus_init_mmio(dev, 4, s->mmio_index);
2136
2137 sysbus_init_irq(dev, &s->irq);
2138
2139 s->phys_mem_read = ledma_memory_read;
2140 s->phys_mem_write = ledma_memory_write;
2141
2142 pcnet_common_init(&dev->qdev, s, lance_cleanup);
2143 }
2144 #endif /* TARGET_SPARC */
2145
2146 static void pcnet_register_devices(void)
2147 {
2148 pci_qdev_register("pcnet", sizeof(PCIPCNetState), pci_pcnet_init);
2149 #if defined (TARGET_SPARC) && !defined(TARGET_SPARC64)
2150 sysbus_register_dev("lance", sizeof(SysBusPCNetState), lance_init);
2151 #endif
2152 }
2153
2154 device_init(pcnet_register_devices)
various patches