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 | #include "vl.h" |
---|
31 | |
---|
32 | //#define PCNET_DEBUG |
---|
33 | //#define PCNET_DEBUG_IO |
---|
34 | //#define PCNET_DEBUG_BCR |
---|
35 | //#define PCNET_DEBUG_CSR |
---|
36 | //#define PCNET_DEBUG_RMD |
---|
37 | //#define PCNET_DEBUG_TMD |
---|
38 | //#define PCNET_DEBUG_MATCH |
---|
39 | |
---|
40 | |
---|
41 | #define PCNET_IOPORT_SIZE 0x20 |
---|
42 | #define PCNET_PNPMMIO_SIZE 0x20 |
---|
43 | |
---|
44 | |
---|
45 | typedef struct PCNetState_st PCNetState; |
---|
46 | |
---|
47 | struct PCNetState_st { |
---|
48 | PCIDevice dev; |
---|
49 | VLANClientState *vc; |
---|
50 | NICInfo *nd; |
---|
51 | QEMUTimer *poll_timer; |
---|
52 | int mmio_io_addr, rap, isr, lnkst; |
---|
53 | target_phys_addr_t rdra, tdra; |
---|
54 | uint8_t prom[16]; |
---|
55 | uint16_t csr[128]; |
---|
56 | uint16_t bcr[32]; |
---|
57 | uint64_t timer; |
---|
58 | int xmit_pos, recv_pos; |
---|
59 | uint8_t buffer[4096]; |
---|
60 | int tx_busy; |
---|
61 | }; |
---|
62 | |
---|
63 | /* XXX: using bitfields for target memory structures is almost surely |
---|
64 | not portable, so it should be suppressed ASAP */ |
---|
65 | #ifdef __GNUC__ |
---|
66 | #define PACKED_FIELD(A) A __attribute__ ((packed)) |
---|
67 | #else |
---|
68 | #error FixMe |
---|
69 | #endif |
---|
70 | |
---|
71 | struct qemu_ether_header { |
---|
72 | uint8_t ether_dhost[6]; |
---|
73 | uint8_t ether_shost[6]; |
---|
74 | uint16_t ether_type; |
---|
75 | }; |
---|
76 | |
---|
77 | /* BUS CONFIGURATION REGISTERS */ |
---|
78 | #define BCR_MSRDA 0 |
---|
79 | #define BCR_MSWRA 1 |
---|
80 | #define BCR_MC 2 |
---|
81 | #define BCR_LNKST 4 |
---|
82 | #define BCR_LED1 5 |
---|
83 | #define BCR_LED2 6 |
---|
84 | #define BCR_LED3 7 |
---|
85 | #define BCR_FDC 9 |
---|
86 | #define BCR_BSBC 18 |
---|
87 | #define BCR_EECAS 19 |
---|
88 | #define BCR_SWS 20 |
---|
89 | #define BCR_PLAT 22 |
---|
90 | |
---|
91 | #define BCR_DWIO(S) !!((S)->bcr[BCR_BSBC] & 0x0080) |
---|
92 | #define BCR_SSIZE32(S) !!((S)->bcr[BCR_SWS ] & 0x0100) |
---|
93 | #define BCR_SWSTYLE(S) ((S)->bcr[BCR_SWS ] & 0x00FF) |
---|
94 | |
---|
95 | #define CSR_INIT(S) !!(((S)->csr[0])&0x0001) |
---|
96 | #define CSR_STRT(S) !!(((S)->csr[0])&0x0002) |
---|
97 | #define CSR_STOP(S) !!(((S)->csr[0])&0x0004) |
---|
98 | #define CSR_TDMD(S) !!(((S)->csr[0])&0x0008) |
---|
99 | #define CSR_TXON(S) !!(((S)->csr[0])&0x0010) |
---|
100 | #define CSR_RXON(S) !!(((S)->csr[0])&0x0020) |
---|
101 | #define CSR_INEA(S) !!(((S)->csr[0])&0x0040) |
---|
102 | #define CSR_LAPPEN(S) !!(((S)->csr[3])&0x0020) |
---|
103 | #define CSR_DXSUFLO(S) !!(((S)->csr[3])&0x0040) |
---|
104 | #define CSR_ASTRP_RCV(S) !!(((S)->csr[4])&0x0800) |
---|
105 | #define CSR_DPOLL(S) !!(((S)->csr[4])&0x1000) |
---|
106 | #define CSR_SPND(S) !!(((S)->csr[5])&0x0001) |
---|
107 | #define CSR_LTINTEN(S) !!(((S)->csr[5])&0x4000) |
---|
108 | #define CSR_TOKINTD(S) !!(((S)->csr[5])&0x8000) |
---|
109 | #define CSR_DRX(S) !!(((S)->csr[15])&0x0001) |
---|
110 | #define CSR_DTX(S) !!(((S)->csr[15])&0x0002) |
---|
111 | #define CSR_LOOP(S) !!(((S)->csr[15])&0x0004) |
---|
112 | #define CSR_DRCVPA(S) !!(((S)->csr[15])&0x2000) |
---|
113 | #define CSR_DRCVBC(S) !!(((S)->csr[15])&0x4000) |
---|
114 | #define CSR_PROM(S) !!(((S)->csr[15])&0x8000) |
---|
115 | |
---|
116 | #define CSR_CRBC(S) ((S)->csr[40]) |
---|
117 | #define CSR_CRST(S) ((S)->csr[41]) |
---|
118 | #define CSR_CXBC(S) ((S)->csr[42]) |
---|
119 | #define CSR_CXST(S) ((S)->csr[43]) |
---|
120 | #define CSR_NRBC(S) ((S)->csr[44]) |
---|
121 | #define CSR_NRST(S) ((S)->csr[45]) |
---|
122 | #define CSR_POLL(S) ((S)->csr[46]) |
---|
123 | #define CSR_PINT(S) ((S)->csr[47]) |
---|
124 | #define CSR_RCVRC(S) ((S)->csr[72]) |
---|
125 | #define CSR_XMTRC(S) ((S)->csr[74]) |
---|
126 | #define CSR_RCVRL(S) ((S)->csr[76]) |
---|
127 | #define CSR_XMTRL(S) ((S)->csr[78]) |
---|
128 | #define CSR_MISSC(S) ((S)->csr[112]) |
---|
129 | |
---|
130 | #define CSR_IADR(S) ((S)->csr[ 1] | ((S)->csr[ 2] << 16)) |
---|
131 | #define CSR_CRBA(S) ((S)->csr[18] | ((S)->csr[19] << 16)) |
---|
132 | #define CSR_CXBA(S) ((S)->csr[20] | ((S)->csr[21] << 16)) |
---|
133 | #define CSR_NRBA(S) ((S)->csr[22] | ((S)->csr[23] << 16)) |
---|
134 | #define CSR_BADR(S) ((S)->csr[24] | ((S)->csr[25] << 16)) |
---|
135 | #define CSR_NRDA(S) ((S)->csr[26] | ((S)->csr[27] << 16)) |
---|
136 | #define CSR_CRDA(S) ((S)->csr[28] | ((S)->csr[29] << 16)) |
---|
137 | #define CSR_BADX(S) ((S)->csr[30] | ((S)->csr[31] << 16)) |
---|
138 | #define CSR_NXDA(S) ((S)->csr[32] | ((S)->csr[33] << 16)) |
---|
139 | #define CSR_CXDA(S) ((S)->csr[34] | ((S)->csr[35] << 16)) |
---|
140 | #define CSR_NNRD(S) ((S)->csr[36] | ((S)->csr[37] << 16)) |
---|
141 | #define CSR_NNXD(S) ((S)->csr[38] | ((S)->csr[39] << 16)) |
---|
142 | #define CSR_PXDA(S) ((S)->csr[60] | ((S)->csr[61] << 16)) |
---|
143 | #define CSR_NXBA(S) ((S)->csr[64] | ((S)->csr[65] << 16)) |
---|
144 | |
---|
145 | #define PHYSADDR(S,A) \ |
---|
146 | (BCR_SSIZE32(S) ? (A) : (A) | ((0xff00 & (uint32_t)(s)->csr[2])<<16)) |
---|
147 | |
---|
148 | struct pcnet_initblk16 { |
---|
149 | uint16_t mode; |
---|
150 | uint16_t padr1; |
---|
151 | uint16_t padr2; |
---|
152 | uint16_t padr3; |
---|
153 | uint16_t ladrf1; |
---|
154 | uint16_t ladrf2; |
---|
155 | uint16_t ladrf3; |
---|
156 | uint16_t ladrf4; |
---|
157 | unsigned PACKED_FIELD(rdra:24); |
---|
158 | unsigned PACKED_FIELD(res1:5); |
---|
159 | unsigned PACKED_FIELD(rlen:3); |
---|
160 | unsigned PACKED_FIELD(tdra:24); |
---|
161 | unsigned PACKED_FIELD(res2:5); |
---|
162 | unsigned PACKED_FIELD(tlen:3); |
---|
163 | }; |
---|
164 | |
---|
165 | struct pcnet_initblk32 { |
---|
166 | uint16_t mode; |
---|
167 | unsigned PACKED_FIELD(res1:4); |
---|
168 | unsigned PACKED_FIELD(rlen:4); |
---|
169 | unsigned PACKED_FIELD(res2:4); |
---|
170 | unsigned PACKED_FIELD(tlen:4); |
---|
171 | uint16_t padr1; |
---|
172 | uint16_t padr2; |
---|
173 | uint16_t padr3; |
---|
174 | uint16_t _res; |
---|
175 | uint16_t ladrf1; |
---|
176 | uint16_t ladrf2; |
---|
177 | uint16_t ladrf3; |
---|
178 | uint16_t ladrf4; |
---|
179 | uint32_t rdra; |
---|
180 | uint32_t tdra; |
---|
181 | }; |
---|
182 | |
---|
183 | struct pcnet_TMD { |
---|
184 | struct { |
---|
185 | unsigned tbadr:32; |
---|
186 | } tmd0; |
---|
187 | struct { |
---|
188 | unsigned PACKED_FIELD(bcnt:12), PACKED_FIELD(ones:4), PACKED_FIELD(res:7), PACKED_FIELD(bpe:1); |
---|
189 | unsigned PACKED_FIELD(enp:1), PACKED_FIELD(stp:1), PACKED_FIELD(def:1), PACKED_FIELD(one:1); |
---|
190 | unsigned PACKED_FIELD(ltint:1), PACKED_FIELD(nofcs:1), PACKED_FIELD(err:1), PACKED_FIELD(own:1); |
---|
191 | } tmd1; |
---|
192 | struct { |
---|
193 | unsigned PACKED_FIELD(trc:4), PACKED_FIELD(res:12); |
---|
194 | unsigned PACKED_FIELD(tdr:10), PACKED_FIELD(rtry:1), PACKED_FIELD(lcar:1); |
---|
195 | unsigned PACKED_FIELD(lcol:1), PACKED_FIELD(exdef:1), PACKED_FIELD(uflo:1), PACKED_FIELD(buff:1); |
---|
196 | } tmd2; |
---|
197 | struct { |
---|
198 | unsigned res:32; |
---|
199 | } tmd3; |
---|
200 | }; |
---|
201 | |
---|
202 | struct pcnet_RMD { |
---|
203 | struct { |
---|
204 | unsigned rbadr:32; |
---|
205 | } rmd0; |
---|
206 | struct { |
---|
207 | unsigned PACKED_FIELD(bcnt:12), PACKED_FIELD(ones:4), PACKED_FIELD(res:4); |
---|
208 | unsigned PACKED_FIELD(bam:1), PACKED_FIELD(lafm:1), PACKED_FIELD(pam:1), PACKED_FIELD(bpe:1); |
---|
209 | unsigned PACKED_FIELD(enp:1), PACKED_FIELD(stp:1), PACKED_FIELD(buff:1), PACKED_FIELD(crc:1); |
---|
210 | unsigned PACKED_FIELD(oflo:1), PACKED_FIELD(fram:1), PACKED_FIELD(err:1), PACKED_FIELD(own:1); |
---|
211 | } rmd1; |
---|
212 | struct { |
---|
213 | unsigned PACKED_FIELD(mcnt:12), PACKED_FIELD(zeros:4); |
---|
214 | unsigned PACKED_FIELD(rpc:8), PACKED_FIELD(rcc:8); |
---|
215 | } rmd2; |
---|
216 | struct { |
---|
217 | unsigned res:32; |
---|
218 | } rmd3; |
---|
219 | }; |
---|
220 | |
---|
221 | |
---|
222 | #define PRINT_TMD(T) printf( \ |
---|
223 | "TMD0 : TBADR=0x%08x\n" \ |
---|
224 | "TMD1 : OWN=%d, ERR=%d, FCS=%d, LTI=%d, " \ |
---|
225 | "ONE=%d, DEF=%d, STP=%d, ENP=%d,\n" \ |
---|
226 | " BPE=%d, BCNT=%d\n" \ |
---|
227 | "TMD2 : BUF=%d, UFL=%d, EXD=%d, LCO=%d, " \ |
---|
228 | "LCA=%d, RTR=%d,\n" \ |
---|
229 | " TDR=%d, TRC=%d\n", \ |
---|
230 | (T)->tmd0.tbadr, \ |
---|
231 | (T)->tmd1.own, (T)->tmd1.err, (T)->tmd1.nofcs, \ |
---|
232 | (T)->tmd1.ltint, (T)->tmd1.one, (T)->tmd1.def, \ |
---|
233 | (T)->tmd1.stp, (T)->tmd1.enp, (T)->tmd1.bpe, \ |
---|
234 | 4096-(T)->tmd1.bcnt, \ |
---|
235 | (T)->tmd2.buff, (T)->tmd2.uflo, (T)->tmd2.exdef,\ |
---|
236 | (T)->tmd2.lcol, (T)->tmd2.lcar, (T)->tmd2.rtry, \ |
---|
237 | (T)->tmd2.tdr, (T)->tmd2.trc) |
---|
238 | |
---|
239 | #define PRINT_RMD(R) printf( \ |
---|
240 | "RMD0 : RBADR=0x%08x\n" \ |
---|
241 | "RMD1 : OWN=%d, ERR=%d, FRAM=%d, OFLO=%d, " \ |
---|
242 | "CRC=%d, BUFF=%d, STP=%d, ENP=%d,\n " \ |
---|
243 | "BPE=%d, PAM=%d, LAFM=%d, BAM=%d, ONES=%d, BCNT=%d\n" \ |
---|
244 | "RMD2 : RCC=%d, RPC=%d, MCNT=%d, ZEROS=%d\n", \ |
---|
245 | (R)->rmd0.rbadr, \ |
---|
246 | (R)->rmd1.own, (R)->rmd1.err, (R)->rmd1.fram, \ |
---|
247 | (R)->rmd1.oflo, (R)->rmd1.crc, (R)->rmd1.buff, \ |
---|
248 | (R)->rmd1.stp, (R)->rmd1.enp, (R)->rmd1.bpe, \ |
---|
249 | (R)->rmd1.pam, (R)->rmd1.lafm, (R)->rmd1.bam, \ |
---|
250 | (R)->rmd1.ones, 4096-(R)->rmd1.bcnt, \ |
---|
251 | (R)->rmd2.rcc, (R)->rmd2.rpc, (R)->rmd2.mcnt, \ |
---|
252 | (R)->rmd2.zeros) |
---|
253 | |
---|
254 | static inline void pcnet_tmd_load(PCNetState *s, struct pcnet_TMD *tmd, target_phys_addr_t addr) |
---|
255 | { |
---|
256 | if (!BCR_SWSTYLE(s)) { |
---|
257 | uint16_t xda[4]; |
---|
258 | cpu_physical_memory_read(addr, |
---|
259 | (void *)&xda[0], sizeof(xda)); |
---|
260 | ((uint32_t *)tmd)[0] = (xda[0]&0xffff) | |
---|
261 | ((xda[1]&0x00ff) << 16); |
---|
262 | ((uint32_t *)tmd)[1] = (xda[2]&0xffff)| |
---|
263 | ((xda[1] & 0xff00) << 16); |
---|
264 | ((uint32_t *)tmd)[2] = |
---|
265 | (xda[3] & 0xffff) << 16; |
---|
266 | ((uint32_t *)tmd)[3] = 0; |
---|
267 | } |
---|
268 | else |
---|
269 | if (BCR_SWSTYLE(s) != 3) |
---|
270 | cpu_physical_memory_read(addr, (void *)tmd, 16); |
---|
271 | else { |
---|
272 | uint32_t xda[4]; |
---|
273 | cpu_physical_memory_read(addr, |
---|
274 | (void *)&xda[0], sizeof(xda)); |
---|
275 | ((uint32_t *)tmd)[0] = xda[2]; |
---|
276 | ((uint32_t *)tmd)[1] = xda[1]; |
---|
277 | ((uint32_t *)tmd)[2] = xda[0]; |
---|
278 | ((uint32_t *)tmd)[3] = xda[3]; |
---|
279 | } |
---|
280 | } |
---|
281 | |
---|
282 | static inline void pcnet_tmd_store(PCNetState *s, struct pcnet_TMD *tmd, target_phys_addr_t addr) |
---|
283 | { |
---|
284 | if (!BCR_SWSTYLE(s)) { |
---|
285 | uint16_t xda[4]; |
---|
286 | xda[0] = ((uint32_t *)tmd)[0] & 0xffff; |
---|
287 | xda[1] = ((((uint32_t *)tmd)[0]>>16)&0x00ff) | |
---|
288 | ((((uint32_t *)tmd)[1]>>16)&0xff00); |
---|
289 | xda[2] = ((uint32_t *)tmd)[1] & 0xffff; |
---|
290 | xda[3] = ((uint32_t *)tmd)[2] >> 16; |
---|
291 | cpu_physical_memory_write(addr, |
---|
292 | (void *)&xda[0], sizeof(xda)); |
---|
293 | } |
---|
294 | else { |
---|
295 | if (BCR_SWSTYLE(s) != 3) |
---|
296 | cpu_physical_memory_write(addr, (void *)tmd, 16); |
---|
297 | else { |
---|
298 | uint32_t xda[4]; |
---|
299 | xda[0] = ((uint32_t *)tmd)[2]; |
---|
300 | xda[1] = ((uint32_t *)tmd)[1]; |
---|
301 | xda[2] = ((uint32_t *)tmd)[0]; |
---|
302 | xda[3] = ((uint32_t *)tmd)[3]; |
---|
303 | cpu_physical_memory_write(addr, |
---|
304 | (void *)&xda[0], sizeof(xda)); |
---|
305 | } |
---|
306 | } |
---|
307 | } |
---|
308 | |
---|
309 | static inline void pcnet_rmd_load(PCNetState *s, struct pcnet_RMD *rmd, target_phys_addr_t addr) |
---|
310 | { |
---|
311 | if (!BCR_SWSTYLE(s)) { |
---|
312 | uint16_t rda[4]; |
---|
313 | cpu_physical_memory_read(addr, |
---|
314 | (void *)&rda[0], sizeof(rda)); |
---|
315 | ((uint32_t *)rmd)[0] = (rda[0]&0xffff)| |
---|
316 | ((rda[1] & 0x00ff) << 16); |
---|
317 | ((uint32_t *)rmd)[1] = (rda[2]&0xffff)| |
---|
318 | ((rda[1] & 0xff00) << 16); |
---|
319 | ((uint32_t *)rmd)[2] = rda[3] & 0xffff; |
---|
320 | ((uint32_t *)rmd)[3] = 0; |
---|
321 | } |
---|
322 | else |
---|
323 | if (BCR_SWSTYLE(s) != 3) |
---|
324 | cpu_physical_memory_read(addr, (void *)rmd, 16); |
---|
325 | else { |
---|
326 | uint32_t rda[4]; |
---|
327 | cpu_physical_memory_read(addr, |
---|
328 | (void *)&rda[0], sizeof(rda)); |
---|
329 | ((uint32_t *)rmd)[0] = rda[2]; |
---|
330 | ((uint32_t *)rmd)[1] = rda[1]; |
---|
331 | ((uint32_t *)rmd)[2] = rda[0]; |
---|
332 | ((uint32_t *)rmd)[3] = rda[3]; |
---|
333 | } |
---|
334 | } |
---|
335 | |
---|
336 | static inline void pcnet_rmd_store(PCNetState *s, struct pcnet_RMD *rmd, target_phys_addr_t addr) |
---|
337 | { |
---|
338 | if (!BCR_SWSTYLE(s)) { |
---|
339 | uint16_t rda[4]; \ |
---|
340 | rda[0] = ((uint32_t *)rmd)[0] & 0xffff; \ |
---|
341 | rda[1] = ((((uint32_t *)rmd)[0]>>16)&0xff)|\ |
---|
342 | ((((uint32_t *)rmd)[1]>>16)&0xff00);\ |
---|
343 | rda[2] = ((uint32_t *)rmd)[1] & 0xffff; \ |
---|
344 | rda[3] = ((uint32_t *)rmd)[2] & 0xffff; \ |
---|
345 | cpu_physical_memory_write(addr, \ |
---|
346 | (void *)&rda[0], sizeof(rda)); \ |
---|
347 | } |
---|
348 | else { |
---|
349 | if (BCR_SWSTYLE(s) != 3) |
---|
350 | cpu_physical_memory_write(addr, (void *)rmd, 16); |
---|
351 | else { |
---|
352 | uint32_t rda[4]; |
---|
353 | rda[0] = ((uint32_t *)rmd)[2]; |
---|
354 | rda[1] = ((uint32_t *)rmd)[1]; |
---|
355 | rda[2] = ((uint32_t *)rmd)[0]; |
---|
356 | rda[3] = ((uint32_t *)rmd)[3]; |
---|
357 | cpu_physical_memory_write(addr, |
---|
358 | (void *)&rda[0], sizeof(rda)); |
---|
359 | } |
---|
360 | } |
---|
361 | } |
---|
362 | |
---|
363 | |
---|
364 | #define TMDLOAD(TMD,ADDR) pcnet_tmd_load(s,TMD,ADDR) |
---|
365 | |
---|
366 | #define TMDSTORE(TMD,ADDR) pcnet_tmd_store(s,TMD,ADDR) |
---|
367 | |
---|
368 | #define RMDLOAD(RMD,ADDR) pcnet_rmd_load(s,RMD,ADDR) |
---|
369 | |
---|
370 | #define RMDSTORE(RMD,ADDR) pcnet_rmd_store(s,RMD,ADDR) |
---|
371 | |
---|
372 | #if 1 |
---|
373 | |
---|
374 | #define CHECK_RMD(ADDR,RES) do { \ |
---|
375 | struct pcnet_RMD rmd; \ |
---|
376 | RMDLOAD(&rmd,(ADDR)); \ |
---|
377 | (RES) |= (rmd.rmd1.ones != 15) \ |
---|
378 | || (rmd.rmd2.zeros != 0); \ |
---|
379 | } while (0) |
---|
380 | |
---|
381 | #define CHECK_TMD(ADDR,RES) do { \ |
---|
382 | struct pcnet_TMD tmd; \ |
---|
383 | TMDLOAD(&tmd,(ADDR)); \ |
---|
384 | (RES) |= (tmd.tmd1.ones != 15); \ |
---|
385 | } while (0) |
---|
386 | |
---|
387 | #else |
---|
388 | |
---|
389 | #define CHECK_RMD(ADDR,RES) do { \ |
---|
390 | switch (BCR_SWSTYLE(s)) { \ |
---|
391 | case 0x00: \ |
---|
392 | do { \ |
---|
393 | uint16_t rda[4]; \ |
---|
394 | cpu_physical_memory_read((ADDR), \ |
---|
395 | (void *)&rda[0], sizeof(rda)); \ |
---|
396 | (RES) |= (rda[2] & 0xf000)!=0xf000; \ |
---|
397 | (RES) |= (rda[3] & 0xf000)!=0x0000; \ |
---|
398 | } while (0); \ |
---|
399 | break; \ |
---|
400 | case 0x01: \ |
---|
401 | case 0x02: \ |
---|
402 | do { \ |
---|
403 | uint32_t rda[4]; \ |
---|
404 | cpu_physical_memory_read((ADDR), \ |
---|
405 | (void *)&rda[0], sizeof(rda)); \ |
---|
406 | (RES) |= (rda[1] & 0x0000f000L)!=0x0000f000L; \ |
---|
407 | (RES) |= (rda[2] & 0x0000f000L)!=0x00000000L; \ |
---|
408 | } while (0); \ |
---|
409 | break; \ |
---|
410 | case 0x03: \ |
---|
411 | do { \ |
---|
412 | uint32_t rda[4]; \ |
---|
413 | cpu_physical_memory_read((ADDR), \ |
---|
414 | (void *)&rda[0], sizeof(rda)); \ |
---|
415 | (RES) |= (rda[0] & 0x0000f000L)!=0x00000000L; \ |
---|
416 | (RES) |= (rda[1] & 0x0000f000L)!=0x0000f000L; \ |
---|
417 | } while (0); \ |
---|
418 | break; \ |
---|
419 | } \ |
---|
420 | } while (0) |
---|
421 | |
---|
422 | #define CHECK_TMD(ADDR,RES) do { \ |
---|
423 | switch (BCR_SWSTYLE(s)) { \ |
---|
424 | case 0x00: \ |
---|
425 | do { \ |
---|
426 | uint16_t xda[4]; \ |
---|
427 | cpu_physical_memory_read((ADDR), \ |
---|
428 | (void *)&xda[0], sizeof(xda)); \ |
---|
429 | (RES) |= (xda[2] & 0xf000)!=0xf000;\ |
---|
430 | } while (0); \ |
---|
431 | break; \ |
---|
432 | case 0x01: \ |
---|
433 | case 0x02: \ |
---|
434 | case 0x03: \ |
---|
435 | do { \ |
---|
436 | uint32_t xda[4]; \ |
---|
437 | cpu_physical_memory_read((ADDR), \ |
---|
438 | (void *)&xda[0], sizeof(xda)); \ |
---|
439 | (RES) |= (xda[1] & 0x0000f000L)!=0x0000f000L; \ |
---|
440 | } while (0); \ |
---|
441 | break; \ |
---|
442 | } \ |
---|
443 | } while (0) |
---|
444 | |
---|
445 | #endif |
---|
446 | |
---|
447 | #define PRINT_PKTHDR(BUF) do { \ |
---|
448 | struct qemu_ether_header *hdr = (void *)(BUF); \ |
---|
449 | printf("packet dhost=%02x:%02x:%02x:%02x:%02x:%02x, " \ |
---|
450 | "shost=%02x:%02x:%02x:%02x:%02x:%02x, " \ |
---|
451 | "type=0x%04x (bcast=%d)\n", \ |
---|
452 | hdr->ether_dhost[0],hdr->ether_dhost[1],hdr->ether_dhost[2], \ |
---|
453 | hdr->ether_dhost[3],hdr->ether_dhost[4],hdr->ether_dhost[5], \ |
---|
454 | hdr->ether_shost[0],hdr->ether_shost[1],hdr->ether_shost[2], \ |
---|
455 | hdr->ether_shost[3],hdr->ether_shost[4],hdr->ether_shost[5], \ |
---|
456 | be16_to_cpu(hdr->ether_type), \ |
---|
457 | !!ETHER_IS_MULTICAST(hdr->ether_dhost)); \ |
---|
458 | } while (0) |
---|
459 | |
---|
460 | #define MULTICAST_FILTER_LEN 8 |
---|
461 | |
---|
462 | static inline uint32_t lnc_mchash(const uint8_t *ether_addr) |
---|
463 | { |
---|
464 | #define LNC_POLYNOMIAL 0xEDB88320UL |
---|
465 | uint32_t crc = 0xFFFFFFFF; |
---|
466 | int idx, bit; |
---|
467 | uint8_t data; |
---|
468 | |
---|
469 | for (idx = 0; idx < 6; idx++) { |
---|
470 | for (data = *ether_addr++, bit = 0; bit < MULTICAST_FILTER_LEN; bit++) { |
---|
471 | crc = (crc >> 1) ^ (((crc ^ data) & 1) ? LNC_POLYNOMIAL : 0); |
---|
472 | data >>= 1; |
---|
473 | } |
---|
474 | } |
---|
475 | return crc; |
---|
476 | #undef LNC_POLYNOMIAL |
---|
477 | } |
---|
478 | |
---|
479 | #define CRC(crc, ch) (crc = (crc >> 8) ^ crctab[(crc ^ (ch)) & 0xff]) |
---|
480 | |
---|
481 | /* generated using the AUTODIN II polynomial |
---|
482 | * x^32 + x^26 + x^23 + x^22 + x^16 + |
---|
483 | * x^12 + x^11 + x^10 + x^8 + x^7 + x^5 + x^4 + x^2 + x^1 + 1 |
---|
484 | */ |
---|
485 | static const uint32_t crctab[256] = { |
---|
486 | 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, |
---|
487 | 0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3, |
---|
488 | 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, |
---|
489 | 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, |
---|
490 | 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, |
---|
491 | 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, |
---|
492 | 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, |
---|
493 | 0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5, |
---|
494 | 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172, |
---|
495 | 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, |
---|
496 | 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, |
---|
497 | 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59, |
---|
498 | 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, |
---|
499 | 0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f, |
---|
500 | 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, |
---|
501 | 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, |
---|
502 | 0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a, |
---|
503 | 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433, |
---|
504 | 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, |
---|
505 | 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01, |
---|
506 | 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, |
---|
507 | 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, |
---|
508 | 0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c, |
---|
509 | 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65, |
---|
510 | 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, |
---|
511 | 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, |
---|
512 | 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0, |
---|
513 | 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, |
---|
514 | 0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086, |
---|
515 | 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f, |
---|
516 | 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, |
---|
517 | 0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, |
---|
518 | 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, |
---|
519 | 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, |
---|
520 | 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, |
---|
521 | 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, |
---|
522 | 0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, |
---|
523 | 0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7, |
---|
524 | 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc, |
---|
525 | 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, |
---|
526 | 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, |
---|
527 | 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b, |
---|
528 | 0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, |
---|
529 | 0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79, |
---|
530 | 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, |
---|
531 | 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, |
---|
532 | 0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, |
---|
533 | 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d, |
---|
534 | 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, |
---|
535 | 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713, |
---|
536 | 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, |
---|
537 | 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, |
---|
538 | 0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e, |
---|
539 | 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777, |
---|
540 | 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, |
---|
541 | 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, |
---|
542 | 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2, |
---|
543 | 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, |
---|
544 | 0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0, |
---|
545 | 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9, |
---|
546 | 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, |
---|
547 | 0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf, |
---|
548 | 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94, |
---|
549 | 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d, |
---|
550 | }; |
---|
551 | |
---|
552 | static inline int padr_match(PCNetState *s, const uint8_t *buf, int size) |
---|
553 | { |
---|
554 | struct qemu_ether_header *hdr = (void *)buf; |
---|
555 | uint8_t padr[6] = { |
---|
556 | s->csr[12] & 0xff, s->csr[12] >> 8, |
---|
557 | s->csr[13] & 0xff, s->csr[13] >> 8, |
---|
558 | s->csr[14] & 0xff, s->csr[14] >> 8 |
---|
559 | }; |
---|
560 | int result = (!CSR_DRCVPA(s)) && !memcmp(hdr->ether_dhost, padr, 6); |
---|
561 | #ifdef PCNET_DEBUG_MATCH |
---|
562 | printf("packet dhost=%02x:%02x:%02x:%02x:%02x:%02x, " |
---|
563 | "padr=%02x:%02x:%02x:%02x:%02x:%02x\n", |
---|
564 | hdr->ether_dhost[0],hdr->ether_dhost[1],hdr->ether_dhost[2], |
---|
565 | hdr->ether_dhost[3],hdr->ether_dhost[4],hdr->ether_dhost[5], |
---|
566 | padr[0],padr[1],padr[2],padr[3],padr[4],padr[5]); |
---|
567 | printf("padr_match result=%d\n", result); |
---|
568 | #endif |
---|
569 | return result; |
---|
570 | } |
---|
571 | |
---|
572 | static inline int padr_bcast(PCNetState *s, const uint8_t *buf, int size) |
---|
573 | { |
---|
574 | static uint8_t BCAST[6] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; |
---|
575 | struct qemu_ether_header *hdr = (void *)buf; |
---|
576 | int result = !CSR_DRCVBC(s) && !memcmp(hdr->ether_dhost, BCAST, 6); |
---|
577 | #ifdef PCNET_DEBUG_MATCH |
---|
578 | printf("padr_bcast result=%d\n", result); |
---|
579 | #endif |
---|
580 | return result; |
---|
581 | } |
---|
582 | |
---|
583 | static inline int ladr_match(PCNetState *s, const uint8_t *buf, int size) |
---|
584 | { |
---|
585 | struct qemu_ether_header *hdr = (void *)buf; |
---|
586 | if ((*(hdr->ether_dhost)&0x01) && |
---|
587 | ((uint64_t *)&s->csr[8])[0] != 0LL) { |
---|
588 | uint8_t ladr[8] = { |
---|
589 | s->csr[8] & 0xff, s->csr[8] >> 8, |
---|
590 | s->csr[9] & 0xff, s->csr[9] >> 8, |
---|
591 | s->csr[10] & 0xff, s->csr[10] >> 8, |
---|
592 | s->csr[11] & 0xff, s->csr[11] >> 8 |
---|
593 | }; |
---|
594 | int index = lnc_mchash(hdr->ether_dhost) >> 26; |
---|
595 | return !!(ladr[index >> 3] & (1 << (index & 7))); |
---|
596 | } |
---|
597 | return 0; |
---|
598 | } |
---|
599 | |
---|
600 | static inline target_phys_addr_t pcnet_rdra_addr(PCNetState *s, int idx) |
---|
601 | { |
---|
602 | while (idx < 1) idx += CSR_RCVRL(s); |
---|
603 | return s->rdra + ((CSR_RCVRL(s) - idx) * (BCR_SWSTYLE(s) ? 16 : 8)); |
---|
604 | } |
---|
605 | |
---|
606 | static inline int64_t pcnet_get_next_poll_time(PCNetState *s, int64_t current_time) |
---|
607 | { |
---|
608 | int64_t next_time = current_time + |
---|
609 | muldiv64(65536 - (CSR_SPND(s) ? 0 : CSR_POLL(s)), |
---|
610 | ticks_per_sec, 33000000L); |
---|
611 | if (next_time <= current_time) |
---|
612 | next_time = current_time + 1; |
---|
613 | return next_time; |
---|
614 | } |
---|
615 | |
---|
616 | static void pcnet_poll(PCNetState *s); |
---|
617 | static void pcnet_poll_timer(void *opaque); |
---|
618 | |
---|
619 | static uint32_t pcnet_csr_readw(PCNetState *s, uint32_t rap); |
---|
620 | static void pcnet_csr_writew(PCNetState *s, uint32_t rap, uint32_t new_value); |
---|
621 | static void pcnet_bcr_writew(PCNetState *s, uint32_t rap, uint32_t val); |
---|
622 | static uint32_t pcnet_bcr_readw(PCNetState *s, uint32_t rap); |
---|
623 | |
---|
624 | static void pcnet_s_reset(PCNetState *s) |
---|
625 | { |
---|
626 | #ifdef PCNET_DEBUG |
---|
627 | printf("pcnet_s_reset\n"); |
---|
628 | #endif |
---|
629 | |
---|
630 | s->lnkst = 0x40; |
---|
631 | s->rdra = 0; |
---|
632 | s->tdra = 0; |
---|
633 | s->rap = 0; |
---|
634 | |
---|
635 | s->bcr[BCR_BSBC] &= ~0x0080; |
---|
636 | |
---|
637 | s->csr[0] = 0x0004; |
---|
638 | s->csr[3] = 0x0000; |
---|
639 | s->csr[4] = 0x0115; |
---|
640 | s->csr[5] = 0x0000; |
---|
641 | s->csr[6] = 0x0000; |
---|
642 | s->csr[8] = 0; |
---|
643 | s->csr[9] = 0; |
---|
644 | s->csr[10] = 0; |
---|
645 | s->csr[11] = 0; |
---|
646 | s->csr[12] = le16_to_cpu(((uint16_t *)&s->prom[0])[0]); |
---|
647 | s->csr[13] = le16_to_cpu(((uint16_t *)&s->prom[0])[1]); |
---|
648 | s->csr[14] = le16_to_cpu(((uint16_t *)&s->prom[0])[2]); |
---|
649 | s->csr[15] &= 0x21c4; |
---|
650 | s->csr[72] = 1; |
---|
651 | s->csr[74] = 1; |
---|
652 | s->csr[76] = 1; |
---|
653 | s->csr[78] = 1; |
---|
654 | s->csr[80] = 0x1410; |
---|
655 | s->csr[88] = 0x1003; |
---|
656 | s->csr[89] = 0x0262; |
---|
657 | s->csr[94] = 0x0000; |
---|
658 | s->csr[100] = 0x0200; |
---|
659 | s->csr[103] = 0x0105; |
---|
660 | s->csr[103] = 0x0105; |
---|
661 | s->csr[112] = 0x0000; |
---|
662 | s->csr[114] = 0x0000; |
---|
663 | s->csr[122] = 0x0000; |
---|
664 | s->csr[124] = 0x0000; |
---|
665 | |
---|
666 | s->tx_busy = 0; |
---|
667 | } |
---|
668 | |
---|
669 | static void pcnet_update_irq(PCNetState *s) |
---|
670 | { |
---|
671 | int isr = 0; |
---|
672 | s->csr[0] &= ~0x0080; |
---|
673 | |
---|
674 | #if 1 |
---|
675 | if (((s->csr[0] & ~s->csr[3]) & 0x5f00) || |
---|
676 | (((s->csr[4]>>1) & ~s->csr[4]) & 0x0115) || |
---|
677 | (((s->csr[5]>>1) & s->csr[5]) & 0x0048)) |
---|
678 | #else |
---|
679 | if ((!(s->csr[3] & 0x4000) && !!(s->csr[0] & 0x4000)) /* BABL */ || |
---|
680 | (!(s->csr[3] & 0x1000) && !!(s->csr[0] & 0x1000)) /* MISS */ || |
---|
681 | (!(s->csr[3] & 0x0100) && !!(s->csr[0] & 0x0100)) /* IDON */ || |
---|
682 | (!(s->csr[3] & 0x0200) && !!(s->csr[0] & 0x0200)) /* TINT */ || |
---|
683 | (!(s->csr[3] & 0x0400) && !!(s->csr[0] & 0x0400)) /* RINT */ || |
---|
684 | (!(s->csr[3] & 0x0800) && !!(s->csr[0] & 0x0800)) /* MERR */ || |
---|
685 | (!(s->csr[4] & 0x0001) && !!(s->csr[4] & 0x0002)) /* JAB */ || |
---|
686 | (!(s->csr[4] & 0x0004) && !!(s->csr[4] & 0x0008)) /* TXSTRT */ || |
---|
687 | (!(s->csr[4] & 0x0010) && !!(s->csr[4] & 0x0020)) /* RCVO */ || |
---|
688 | (!(s->csr[4] & 0x0100) && !!(s->csr[4] & 0x0200)) /* MFCO */ || |
---|
689 | (!!(s->csr[5] & 0x0040) && !!(s->csr[5] & 0x0080)) /* EXDINT */ || |
---|
690 | (!!(s->csr[5] & 0x0008) && !!(s->csr[5] & 0x0010)) /* MPINT */) |
---|
691 | #endif |
---|
692 | { |
---|
693 | |
---|
694 | isr = CSR_INEA(s); |
---|
695 | s->csr[0] |= 0x0080; |
---|
696 | } |
---|
697 | |
---|
698 | if (!!(s->csr[4] & 0x0080) && CSR_INEA(s)) { /* UINT */ |
---|
699 | s->csr[4] &= ~0x0080; |
---|
700 | s->csr[4] |= 0x0040; |
---|
701 | s->csr[0] |= 0x0080; |
---|
702 | isr = 1; |
---|
703 | #ifdef PCNET_DEBUG |
---|
704 | printf("pcnet user int\n"); |
---|
705 | #endif |
---|
706 | } |
---|
707 | |
---|
708 | #if 1 |
---|
709 | if (((s->csr[5]>>1) & s->csr[5]) & 0x0500) |
---|
710 | #else |
---|
711 | if ((!!(s->csr[5] & 0x0400) && !!(s->csr[5] & 0x0800)) /* SINT */ || |
---|
712 | (!!(s->csr[5] & 0x0100) && !!(s->csr[5] & 0x0200)) /* SLPINT */ ) |
---|
713 | #endif |
---|
714 | { |
---|
715 | isr = 1; |
---|
716 | s->csr[0] |= 0x0080; |
---|
717 | } |
---|
718 | |
---|
719 | if (isr != s->isr) { |
---|
720 | #ifdef PCNET_DEBUG |
---|
721 | printf("pcnet: INTA=%d\n", isr); |
---|
722 | #endif |
---|
723 | } |
---|
724 | pci_set_irq(&s->dev, 0, isr); |
---|
725 | s->isr = isr; |
---|
726 | } |
---|
727 | |
---|
728 | static void pcnet_init(PCNetState *s) |
---|
729 | { |
---|
730 | #ifdef PCNET_DEBUG |
---|
731 | printf("pcnet_init init_addr=0x%08x\n", PHYSADDR(s,CSR_IADR(s))); |
---|
732 | #endif |
---|
733 | |
---|
734 | #define PCNET_INIT() do { \ |
---|
735 | cpu_physical_memory_read(PHYSADDR(s,CSR_IADR(s)), \ |
---|
736 | (uint8_t *)&initblk, sizeof(initblk)); \ |
---|
737 | s->csr[15] = le16_to_cpu(initblk.mode); \ |
---|
738 | CSR_RCVRL(s) = (initblk.rlen < 9) ? (1 << initblk.rlen) : 512; \ |
---|
739 | CSR_XMTRL(s) = (initblk.tlen < 9) ? (1 << initblk.tlen) : 512; \ |
---|
740 | s->csr[ 6] = (initblk.tlen << 12) | (initblk.rlen << 8); \ |
---|
741 | s->csr[ 8] = le16_to_cpu(initblk.ladrf1); \ |
---|
742 | s->csr[ 9] = le16_to_cpu(initblk.ladrf2); \ |
---|
743 | s->csr[10] = le16_to_cpu(initblk.ladrf3); \ |
---|
744 | s->csr[11] = le16_to_cpu(initblk.ladrf4); \ |
---|
745 | s->csr[12] = le16_to_cpu(initblk.padr1); \ |
---|
746 | s->csr[13] = le16_to_cpu(initblk.padr2); \ |
---|
747 | s->csr[14] = le16_to_cpu(initblk.padr3); \ |
---|
748 | s->rdra = PHYSADDR(s,initblk.rdra); \ |
---|
749 | s->tdra = PHYSADDR(s,initblk.tdra); \ |
---|
750 | } while (0) |
---|
751 | |
---|
752 | if (BCR_SSIZE32(s)) { |
---|
753 | struct pcnet_initblk32 initblk; |
---|
754 | PCNET_INIT(); |
---|
755 | #ifdef PCNET_DEBUG |
---|
756 | printf("initblk.rlen=0x%02x, initblk.tlen=0x%02x\n", |
---|
757 | initblk.rlen, initblk.tlen); |
---|
758 | #endif |
---|
759 | } else { |
---|
760 | struct pcnet_initblk16 initblk; |
---|
761 | PCNET_INIT(); |
---|
762 | #ifdef PCNET_DEBUG |
---|
763 | printf("initblk.rlen=0x%02x, initblk.tlen=0x%02x\n", |
---|
764 | initblk.rlen, initblk.tlen); |
---|
765 | #endif |
---|
766 | } |
---|
767 | |
---|
768 | #undef PCNET_INIT |
---|
769 | |
---|
770 | CSR_RCVRC(s) = CSR_RCVRL(s); |
---|
771 | CSR_XMTRC(s) = CSR_XMTRL(s); |
---|
772 | |
---|
773 | #ifdef PCNET_DEBUG |
---|
774 | printf("pcnet ss32=%d rdra=0x%08x[%d] tdra=0x%08x[%d]\n", |
---|
775 | BCR_SSIZE32(s), |
---|
776 | s->rdra, CSR_RCVRL(s), s->tdra, CSR_XMTRL(s)); |
---|
777 | #endif |
---|
778 | |
---|
779 | s->csr[0] |= 0x0101; |
---|
780 | s->csr[0] &= ~0x0004; /* clear STOP bit */ |
---|
781 | } |
---|
782 | |
---|
783 | static void pcnet_start(PCNetState *s) |
---|
784 | { |
---|
785 | #ifdef PCNET_DEBUG |
---|
786 | printf("pcnet_start\n"); |
---|
787 | #endif |
---|
788 | |
---|
789 | if (!CSR_DTX(s)) |
---|
790 | s->csr[0] |= 0x0010; /* set TXON */ |
---|
791 | |
---|
792 | if (!CSR_DRX(s)) |
---|
793 | s->csr[0] |= 0x0020; /* set RXON */ |
---|
794 | |
---|
795 | s->csr[0] &= ~0x0004; /* clear STOP bit */ |
---|
796 | s->csr[0] |= 0x0002; |
---|
797 | } |
---|
798 | |
---|
799 | static void pcnet_stop(PCNetState *s) |
---|
800 | { |
---|
801 | #ifdef PCNET_DEBUG |
---|
802 | printf("pcnet_stop\n"); |
---|
803 | #endif |
---|
804 | s->csr[0] &= ~0x7feb; |
---|
805 | s->csr[0] |= 0x0014; |
---|
806 | s->csr[4] &= ~0x02c2; |
---|
807 | s->csr[5] &= ~0x0011; |
---|
808 | pcnet_poll_timer(s); |
---|
809 | } |
---|
810 | |
---|
811 | static void pcnet_rdte_poll(PCNetState *s) |
---|
812 | { |
---|
813 | s->csr[28] = s->csr[29] = 0; |
---|
814 | if (s->rdra) { |
---|
815 | int bad = 0; |
---|
816 | #if 1 |
---|
817 | target_phys_addr_t crda = pcnet_rdra_addr(s, CSR_RCVRC(s)); |
---|
818 | target_phys_addr_t nrda = pcnet_rdra_addr(s, -1 + CSR_RCVRC(s)); |
---|
819 | target_phys_addr_t nnrd = pcnet_rdra_addr(s, -2 + CSR_RCVRC(s)); |
---|
820 | #else |
---|
821 | target_phys_addr_t crda = s->rdra + |
---|
822 | (CSR_RCVRL(s) - CSR_RCVRC(s)) * |
---|
823 | (BCR_SWSTYLE(s) ? 16 : 8 ); |
---|
824 | int nrdc = CSR_RCVRC(s)<=1 ? CSR_RCVRL(s) : CSR_RCVRC(s)-1; |
---|
825 | target_phys_addr_t nrda = s->rdra + |
---|
826 | (CSR_RCVRL(s) - nrdc) * |
---|
827 | (BCR_SWSTYLE(s) ? 16 : 8 ); |
---|
828 | int nnrc = nrdc<=1 ? CSR_RCVRL(s) : nrdc-1; |
---|
829 | target_phys_addr_t nnrd = s->rdra + |
---|
830 | (CSR_RCVRL(s) - nnrc) * |
---|
831 | (BCR_SWSTYLE(s) ? 16 : 8 ); |
---|
832 | #endif |
---|
833 | |
---|
834 | CHECK_RMD(PHYSADDR(s,crda), bad); |
---|
835 | if (!bad) { |
---|
836 | CHECK_RMD(PHYSADDR(s,nrda), bad); |
---|
837 | if (bad || (nrda == crda)) nrda = 0; |
---|
838 | CHECK_RMD(PHYSADDR(s,nnrd), bad); |
---|
839 | if (bad || (nnrd == crda)) nnrd = 0; |
---|
840 | |
---|
841 | s->csr[28] = crda & 0xffff; |
---|
842 | s->csr[29] = crda >> 16; |
---|
843 | s->csr[26] = nrda & 0xffff; |
---|
844 | s->csr[27] = nrda >> 16; |
---|
845 | s->csr[36] = nnrd & 0xffff; |
---|
846 | s->csr[37] = nnrd >> 16; |
---|
847 | #ifdef PCNET_DEBUG |
---|
848 | if (bad) { |
---|
849 | printf("pcnet: BAD RMD RECORDS AFTER 0x%08x\n", |
---|
850 | PHYSADDR(s,crda)); |
---|
851 | } |
---|
852 | } else { |
---|
853 | printf("pcnet: BAD RMD RDA=0x%08x\n", PHYSADDR(s,crda)); |
---|
854 | #endif |
---|
855 | } |
---|
856 | } |
---|
857 | |
---|
858 | if (CSR_CRDA(s)) { |
---|
859 | struct pcnet_RMD rmd; |
---|
860 | RMDLOAD(&rmd, PHYSADDR(s,CSR_CRDA(s))); |
---|
861 | CSR_CRBC(s) = rmd.rmd1.bcnt; |
---|
862 | CSR_CRST(s) = ((uint32_t *)&rmd)[1] >> 16; |
---|
863 | #ifdef PCNET_DEBUG_RMD_X |
---|
864 | printf("CRDA=0x%08x CRST=0x%04x RCVRC=%d RMD1=0x%08x RMD2=0x%08x\n", |
---|
865 | PHYSADDR(s,CSR_CRDA(s)), CSR_CRST(s), CSR_RCVRC(s), |
---|
866 | ((uint32_t *)&rmd)[1], ((uint32_t *)&rmd)[2]); |
---|
867 | PRINT_RMD(&rmd); |
---|
868 | #endif |
---|
869 | } else { |
---|
870 | CSR_CRBC(s) = CSR_CRST(s) = 0; |
---|
871 | } |
---|
872 | |
---|
873 | if (CSR_NRDA(s)) { |
---|
874 | struct pcnet_RMD rmd; |
---|
875 | RMDLOAD(&rmd, PHYSADDR(s,CSR_NRDA(s))); |
---|
876 | CSR_NRBC(s) = rmd.rmd1.bcnt; |
---|
877 | CSR_NRST(s) = ((uint32_t *)&rmd)[1] >> 16; |
---|
878 | } else { |
---|
879 | CSR_NRBC(s) = CSR_NRST(s) = 0; |
---|
880 | } |
---|
881 | |
---|
882 | } |
---|
883 | |
---|
884 | static int pcnet_tdte_poll(PCNetState *s) |
---|
885 | { |
---|
886 | s->csr[34] = s->csr[35] = 0; |
---|
887 | if (s->tdra) { |
---|
888 | target_phys_addr_t cxda = s->tdra + |
---|
889 | (CSR_XMTRL(s) - CSR_XMTRC(s)) * |
---|
890 | (BCR_SWSTYLE(s) ? 16 : 8 ); |
---|
891 | int bad = 0; |
---|
892 | CHECK_TMD(PHYSADDR(s, cxda),bad); |
---|
893 | if (!bad) { |
---|
894 | if (CSR_CXDA(s) != cxda) { |
---|
895 | s->csr[60] = s->csr[34]; |
---|
896 | s->csr[61] = s->csr[35]; |
---|
897 | s->csr[62] = CSR_CXBC(s); |
---|
898 | s->csr[63] = CSR_CXST(s); |
---|
899 | } |
---|
900 | s->csr[34] = cxda & 0xffff; |
---|
901 | s->csr[35] = cxda >> 16; |
---|
902 | #ifdef PCNET_DEBUG |
---|
903 | } else { |
---|
904 | printf("pcnet: BAD TMD XDA=0x%08x\n", PHYSADDR(s,cxda)); |
---|
905 | #endif |
---|
906 | } |
---|
907 | } |
---|
908 | |
---|
909 | if (CSR_CXDA(s)) { |
---|
910 | struct pcnet_TMD tmd; |
---|
911 | |
---|
912 | TMDLOAD(&tmd, PHYSADDR(s,CSR_CXDA(s))); |
---|
913 | |
---|
914 | CSR_CXBC(s) = tmd.tmd1.bcnt; |
---|
915 | CSR_CXST(s) = ((uint32_t *)&tmd)[1] >> 16; |
---|
916 | } else { |
---|
917 | CSR_CXBC(s) = CSR_CXST(s) = 0; |
---|
918 | } |
---|
919 | |
---|
920 | return !!(CSR_CXST(s) & 0x8000); |
---|
921 | } |
---|
922 | |
---|
923 | static int pcnet_can_receive(void *opaque) |
---|
924 | { |
---|
925 | PCNetState *s = opaque; |
---|
926 | if (CSR_STOP(s) || CSR_SPND(s)) |
---|
927 | return 0; |
---|
928 | |
---|
929 | if (s->recv_pos > 0) |
---|
930 | return 0; |
---|
931 | |
---|
932 | return sizeof(s->buffer)-16; |
---|
933 | } |
---|
934 | |
---|
935 | #define MIN_BUF_SIZE 60 |
---|
936 | |
---|
937 | static void pcnet_receive(void *opaque, const uint8_t *buf, int size) |
---|
938 | { |
---|
939 | PCNetState *s = opaque; |
---|
940 | int is_padr = 0, is_bcast = 0, is_ladr = 0; |
---|
941 | uint8_t buf1[60]; |
---|
942 | |
---|
943 | if (CSR_DRX(s) || CSR_STOP(s) || CSR_SPND(s) || !size) |
---|
944 | return; |
---|
945 | |
---|
946 | #ifdef PCNET_DEBUG |
---|
947 | printf("pcnet_receive size=%d\n", size); |
---|
948 | #endif |
---|
949 | |
---|
950 | /* if too small buffer, then expand it */ |
---|
951 | if (size < MIN_BUF_SIZE) { |
---|
952 | memcpy(buf1, buf, size); |
---|
953 | memset(buf1 + size, 0, MIN_BUF_SIZE - size); |
---|
954 | buf = buf1; |
---|
955 | size = MIN_BUF_SIZE; |
---|
956 | } |
---|
957 | |
---|
958 | if (CSR_PROM(s) |
---|
959 | || (is_padr=padr_match(s, buf, size)) |
---|
960 | || (is_bcast=padr_bcast(s, buf, size)) |
---|
961 | || (is_ladr=ladr_match(s, buf, size))) { |
---|
962 | |
---|
963 | pcnet_rdte_poll(s); |
---|
964 | |
---|
965 | if (!(CSR_CRST(s) & 0x8000) && s->rdra) { |
---|
966 | struct pcnet_RMD rmd; |
---|
967 | int rcvrc = CSR_RCVRC(s)-1,i; |
---|
968 | target_phys_addr_t nrda; |
---|
969 | for (i = CSR_RCVRL(s)-1; i > 0; i--, rcvrc--) { |
---|
970 | if (rcvrc <= 1) |
---|
971 | rcvrc = CSR_RCVRL(s); |
---|
972 | nrda = s->rdra + |
---|
973 | (CSR_RCVRL(s) - rcvrc) * |
---|
974 | (BCR_SWSTYLE(s) ? 16 : 8 ); |
---|
975 | RMDLOAD(&rmd, PHYSADDR(s,nrda)); |
---|
976 | if (rmd.rmd1.own) { |
---|
977 | #ifdef PCNET_DEBUG_RMD |
---|
978 | printf("pcnet - scan buffer: RCVRC=%d PREV_RCVRC=%d\n", |
---|
979 | rcvrc, CSR_RCVRC(s)); |
---|
980 | #endif |
---|
981 | CSR_RCVRC(s) = rcvrc; |
---|
982 | pcnet_rdte_poll(s); |
---|
983 | break; |
---|
984 | } |
---|
985 | } |
---|
986 | } |
---|
987 | |
---|
988 | if (!(CSR_CRST(s) & 0x8000)) { |
---|
989 | #ifdef PCNET_DEBUG_RMD |
---|
990 | printf("pcnet - no buffer: RCVRC=%d\n", CSR_RCVRC(s)); |
---|
991 | #endif |
---|
992 | s->csr[0] |= 0x1000; /* Set MISS flag */ |
---|
993 | CSR_MISSC(s)++; |
---|
994 | } else { |
---|
995 | uint8_t *src = &s->buffer[8]; |
---|
996 | target_phys_addr_t crda = CSR_CRDA(s); |
---|
997 | struct pcnet_RMD rmd; |
---|
998 | int pktcount = 0; |
---|
999 | |
---|
1000 | memcpy(src, buf, size); |
---|
1001 | |
---|
1002 | #if 1 |
---|
1003 | /* no need to compute the CRC */ |
---|
1004 | src[size] = 0; |
---|
1005 | src[size + 1] = 0; |
---|
1006 | src[size + 2] = 0; |
---|
1007 | src[size + 3] = 0; |
---|
1008 | size += 4; |
---|
1009 | #else |
---|
1010 | /* XXX: avoid CRC generation */ |
---|
1011 | if (!CSR_ASTRP_RCV(s)) { |
---|
1012 | uint32_t fcs = ~0; |
---|
1013 | uint8_t *p = src; |
---|
1014 | |
---|
1015 | while (size < 46) { |
---|
1016 | src[size++] = 0; |
---|
1017 | } |
---|
1018 | |
---|
1019 | while (p != &src[size]) { |
---|
1020 | CRC(fcs, *p++); |
---|
1021 | } |
---|
1022 | ((uint32_t *)&src[size])[0] = htonl(fcs); |
---|
1023 | size += 4; /* FCS at end of packet */ |
---|
1024 | } else size += 4; |
---|
1025 | #endif |
---|
1026 | |
---|
1027 | #ifdef PCNET_DEBUG_MATCH |
---|
1028 | PRINT_PKTHDR(buf); |
---|
1029 | #endif |
---|
1030 | |
---|
1031 | RMDLOAD(&rmd, PHYSADDR(s,crda)); |
---|
1032 | /*if (!CSR_LAPPEN(s))*/ |
---|
1033 | rmd.rmd1.stp = 1; |
---|
1034 | |
---|
1035 | #define PCNET_RECV_STORE() do { \ |
---|
1036 | int count = MIN(4096 - rmd.rmd1.bcnt,size); \ |
---|
1037 | target_phys_addr_t rbadr = PHYSADDR(s, rmd.rmd0.rbadr); \ |
---|
1038 | cpu_physical_memory_write(rbadr, src, count); \ |
---|
1039 | src += count; size -= count; \ |
---|
1040 | rmd.rmd2.mcnt = count; rmd.rmd1.own = 0; \ |
---|
1041 | RMDSTORE(&rmd, PHYSADDR(s,crda)); \ |
---|
1042 | pktcount++; \ |
---|
1043 | } while (0) |
---|
1044 | |
---|
1045 | PCNET_RECV_STORE(); |
---|
1046 | if ((size > 0) && CSR_NRDA(s)) { |
---|
1047 | target_phys_addr_t nrda = CSR_NRDA(s); |
---|
1048 | RMDLOAD(&rmd, PHYSADDR(s,nrda)); |
---|
1049 | if (rmd.rmd1.own) { |
---|
1050 | crda = nrda; |
---|
1051 | PCNET_RECV_STORE(); |
---|
1052 | if ((size > 0) && (nrda=CSR_NNRD(s))) { |
---|
1053 | RMDLOAD(&rmd, PHYSADDR(s,nrda)); |
---|
1054 | if (rmd.rmd1.own) { |
---|
1055 | crda = nrda; |
---|
1056 | PCNET_RECV_STORE(); |
---|
1057 | } |
---|
1058 | } |
---|
1059 | } |
---|
1060 | } |
---|
1061 | |
---|
1062 | #undef PCNET_RECV_STORE |
---|
1063 | |
---|
1064 | RMDLOAD(&rmd, PHYSADDR(s,crda)); |
---|
1065 | if (size == 0) { |
---|
1066 | rmd.rmd1.enp = 1; |
---|
1067 | rmd.rmd1.pam = !CSR_PROM(s) && is_padr; |
---|
1068 | rmd.rmd1.lafm = !CSR_PROM(s) && is_ladr; |
---|
1069 | rmd.rmd1.bam = !CSR_PROM(s) && is_bcast; |
---|
1070 | } else { |
---|
1071 | rmd.rmd1.oflo = 1; |
---|
1072 | rmd.rmd1.buff = 1; |
---|
1073 | rmd.rmd1.err = 1; |
---|
1074 | } |
---|
1075 | RMDSTORE(&rmd, PHYSADDR(s,crda)); |
---|
1076 | s->csr[0] |= 0x0400; |
---|
1077 | |
---|
1078 | #ifdef PCNET_DEBUG |
---|
1079 | printf("RCVRC=%d CRDA=0x%08x BLKS=%d\n", |
---|
1080 | CSR_RCVRC(s), PHYSADDR(s,CSR_CRDA(s)), pktcount); |
---|
1081 | #endif |
---|
1082 | #ifdef PCNET_DEBUG_RMD |
---|
1083 | PRINT_RMD(&rmd); |
---|
1084 | #endif |
---|
1085 | |
---|
1086 | while (pktcount--) { |
---|
1087 | if (CSR_RCVRC(s) <= 1) |
---|
1088 | CSR_RCVRC(s) = CSR_RCVRL(s); |
---|
1089 | else |
---|
1090 | CSR_RCVRC(s)--; |
---|
1091 | } |
---|
1092 | |
---|
1093 | pcnet_rdte_poll(s); |
---|
1094 | |
---|
1095 | } |
---|
1096 | } |
---|
1097 | |
---|
1098 | pcnet_poll(s); |
---|
1099 | pcnet_update_irq(s); |
---|
1100 | } |
---|
1101 | |
---|
1102 | static void pcnet_transmit(PCNetState *s) |
---|
1103 | { |
---|
1104 | target_phys_addr_t xmit_cxda = 0; |
---|
1105 | int count = CSR_XMTRL(s)-1; |
---|
1106 | s->xmit_pos = -1; |
---|
1107 | |
---|
1108 | if (!CSR_TXON(s)) { |
---|
1109 | s->csr[0] &= ~0x0008; |
---|
1110 | return; |
---|
1111 | } |
---|
1112 | |
---|
1113 | s->tx_busy = 1; |
---|
1114 | |
---|
1115 | txagain: |
---|
1116 | if (pcnet_tdte_poll(s)) { |
---|
1117 | struct pcnet_TMD tmd; |
---|
1118 | |
---|
1119 | TMDLOAD(&tmd, PHYSADDR(s,CSR_CXDA(s))); |
---|
1120 | |
---|
1121 | #ifdef PCNET_DEBUG_TMD |
---|
1122 | printf(" TMDLOAD 0x%08x\n", PHYSADDR(s,CSR_CXDA(s))); |
---|
1123 | PRINT_TMD(&tmd); |
---|
1124 | #endif |
---|
1125 | if (tmd.tmd1.stp) { |
---|
1126 | s->xmit_pos = 0; |
---|
1127 | if (!tmd.tmd1.enp) { |
---|
1128 | cpu_physical_memory_read(PHYSADDR(s, tmd.tmd0.tbadr), |
---|
1129 | s->buffer, 4096 - tmd.tmd1.bcnt); |
---|
1130 | s->xmit_pos += 4096 - tmd.tmd1.bcnt; |
---|
1131 | } |
---|
1132 | xmit_cxda = PHYSADDR(s,CSR_CXDA(s)); |
---|
1133 | } |
---|
1134 | if (tmd.tmd1.enp && (s->xmit_pos >= 0)) { |
---|
1135 | cpu_physical_memory_read(PHYSADDR(s, tmd.tmd0.tbadr), |
---|
1136 | s->buffer + s->xmit_pos, 4096 - tmd.tmd1.bcnt); |
---|
1137 | s->xmit_pos += 4096 - tmd.tmd1.bcnt; |
---|
1138 | #ifdef PCNET_DEBUG |
---|
1139 | printf("pcnet_transmit size=%d\n", s->xmit_pos); |
---|
1140 | #endif |
---|
1141 | if (CSR_LOOP(s)) |
---|
1142 | pcnet_receive(s, s->buffer, s->xmit_pos); |
---|
1143 | else |
---|
1144 | qemu_send_packet(s->vc, s->buffer, s->xmit_pos); |
---|
1145 | |
---|
1146 | s->csr[0] &= ~0x0008; /* clear TDMD */ |
---|
1147 | s->csr[4] |= 0x0004; /* set TXSTRT */ |
---|
1148 | s->xmit_pos = -1; |
---|
1149 | } |
---|
1150 | |
---|
1151 | tmd.tmd1.own = 0; |
---|
1152 | TMDSTORE(&tmd, PHYSADDR(s,CSR_CXDA(s))); |
---|
1153 | if (!CSR_TOKINTD(s) || (CSR_LTINTEN(s) && tmd.tmd1.ltint)) |
---|
1154 | s->csr[0] |= 0x0200; /* set TINT */ |
---|
1155 | |
---|
1156 | if (CSR_XMTRC(s)<=1) |
---|
1157 | CSR_XMTRC(s) = CSR_XMTRL(s); |
---|
1158 | else |
---|
1159 | CSR_XMTRC(s)--; |
---|
1160 | if (count--) |
---|
1161 | goto txagain; |
---|
1162 | |
---|
1163 | } else |
---|
1164 | if (s->xmit_pos >= 0) { |
---|
1165 | struct pcnet_TMD tmd; |
---|
1166 | TMDLOAD(&tmd, PHYSADDR(s,xmit_cxda)); |
---|
1167 | tmd.tmd2.buff = tmd.tmd2.uflo = tmd.tmd1.err = 1; |
---|
1168 | tmd.tmd1.own = 0; |
---|
1169 | TMDSTORE(&tmd, PHYSADDR(s,xmit_cxda)); |
---|
1170 | s->csr[0] |= 0x0200; /* set TINT */ |
---|
1171 | if (!CSR_DXSUFLO(s)) { |
---|
1172 | s->csr[0] &= ~0x0010; |
---|
1173 | } else |
---|
1174 | if (count--) |
---|
1175 | goto txagain; |
---|
1176 | } |
---|
1177 | |
---|
1178 | s->tx_busy = 0; |
---|
1179 | } |
---|
1180 | |
---|
1181 | static void pcnet_poll(PCNetState *s) |
---|
1182 | { |
---|
1183 | if (CSR_RXON(s)) { |
---|
1184 | pcnet_rdte_poll(s); |
---|
1185 | } |
---|
1186 | |
---|
1187 | if (CSR_TDMD(s) || |
---|
1188 | (CSR_TXON(s) && !CSR_DPOLL(s) && pcnet_tdte_poll(s))) |
---|
1189 | { |
---|
1190 | /* prevent recursion */ |
---|
1191 | if (s->tx_busy) |
---|
1192 | return; |
---|
1193 | |
---|
1194 | pcnet_transmit(s); |
---|
1195 | } |
---|
1196 | } |
---|
1197 | |
---|
1198 | static void pcnet_poll_timer(void *opaque) |
---|
1199 | { |
---|
1200 | PCNetState *s = opaque; |
---|
1201 | |
---|
1202 | qemu_del_timer(s->poll_timer); |
---|
1203 | |
---|
1204 | if (CSR_TDMD(s)) { |
---|
1205 | pcnet_transmit(s); |
---|
1206 | } |
---|
1207 | |
---|
1208 | pcnet_update_irq(s); |
---|
1209 | |
---|
1210 | if (!CSR_STOP(s) && !CSR_SPND(s) && !CSR_DPOLL(s)) { |
---|
1211 | uint64_t now = qemu_get_clock(vm_clock) * 33; |
---|
1212 | if (!s->timer || !now) |
---|
1213 | s->timer = now; |
---|
1214 | else { |
---|
1215 | uint64_t t = now - s->timer + CSR_POLL(s); |
---|
1216 | if (t > 0xffffLL) { |
---|
1217 | pcnet_poll(s); |
---|
1218 | CSR_POLL(s) = CSR_PINT(s); |
---|
1219 | } else |
---|
1220 | CSR_POLL(s) = t; |
---|
1221 | } |
---|
1222 | qemu_mod_timer(s->poll_timer, |
---|
1223 | pcnet_get_next_poll_time(s,qemu_get_clock(vm_clock))); |
---|
1224 | } |
---|
1225 | } |
---|
1226 | |
---|
1227 | |
---|
1228 | static void pcnet_csr_writew(PCNetState *s, uint32_t rap, uint32_t new_value) |
---|
1229 | { |
---|
1230 | uint16_t val = new_value; |
---|
1231 | #ifdef PCNET_DEBUG_CSR |
---|
1232 | printf("pcnet_csr_writew rap=%d val=0x%04x\n", rap, val); |
---|
1233 | #endif |
---|
1234 | switch (rap) { |
---|
1235 | case 0: |
---|
1236 | s->csr[0] &= ~(val & 0x7f00); /* Clear any interrupt flags */ |
---|
1237 | |
---|
1238 | s->csr[0] = (s->csr[0] & ~0x0040) | (val & 0x0048); |
---|
1239 | |
---|
1240 | val = (val & 0x007f) | (s->csr[0] & 0x7f00); |
---|
1241 | |
---|
1242 | /* IFF STOP, STRT and INIT are set, clear STRT and INIT */ |
---|
1243 | if ((val&7) == 7) |
---|
1244 | val &= ~3; |
---|
1245 | |
---|
1246 | if (!CSR_STOP(s) && (val & 4)) |
---|
1247 | pcnet_stop(s); |
---|
1248 | |
---|
1249 | if (!CSR_INIT(s) && (val & 1)) |
---|
1250 | pcnet_init(s); |
---|
1251 | |
---|
1252 | if (!CSR_STRT(s) && (val & 2)) |
---|
1253 | pcnet_start(s); |
---|
1254 | |
---|
1255 | if (CSR_TDMD(s)) |
---|
1256 | pcnet_transmit(s); |
---|
1257 | |
---|
1258 | return; |
---|
1259 | case 1: |
---|
1260 | case 2: |
---|
1261 | case 8: |
---|
1262 | case 9: |
---|
1263 | case 10: |
---|
1264 | case 11: |
---|
1265 | case 12: |
---|
1266 | case 13: |
---|
1267 | case 14: |
---|
1268 | case 15: |
---|
1269 | case 18: /* CRBAL */ |
---|
1270 | case 19: /* CRBAU */ |
---|
1271 | case 20: /* CXBAL */ |
---|
1272 | case 21: /* CXBAU */ |
---|
1273 | case 22: /* NRBAU */ |
---|
1274 | case 23: /* NRBAU */ |
---|
1275 | case 24: |
---|
1276 | case 25: |
---|
1277 | case 26: |
---|
1278 | case 27: |
---|
1279 | case 28: |
---|
1280 | case 29: |
---|
1281 | case 30: |
---|
1282 | case 31: |
---|
1283 | case 32: |
---|
1284 | case 33: |
---|
1285 | case 34: |
---|
1286 | case 35: |
---|
1287 | case 36: |
---|
1288 | case 37: |
---|
1289 | case 38: |
---|
1290 | case 39: |
---|
1291 | case 40: /* CRBC */ |
---|
1292 | case 41: |
---|
1293 | case 42: /* CXBC */ |
---|
1294 | case 43: |
---|
1295 | case 44: |
---|
1296 | case 45: |
---|
1297 | case 46: /* POLL */ |
---|
1298 | case 47: /* POLLINT */ |
---|
1299 | case 72: |
---|
1300 | case 74: |
---|
1301 | case 76: /* RCVRL */ |
---|
1302 | case 78: /* XMTRL */ |
---|
1303 | case 112: |
---|
1304 | if (CSR_STOP(s) || CSR_SPND(s)) |
---|
1305 | break; |
---|
1306 | return; |
---|
1307 | case 3: |
---|
1308 | break; |
---|
1309 | case 4: |
---|
1310 | s->csr[4] &= ~(val & 0x026a); |
---|
1311 | val &= ~0x026a; val |= s->csr[4] & 0x026a; |
---|
1312 | break; |
---|
1313 | case 5: |
---|
1314 | s->csr[5] &= ~(val & 0x0a90); |
---|
1315 | val &= ~0x0a90; val |= s->csr[5] & 0x0a90; |
---|
1316 | break; |
---|
1317 | case 16: |
---|
1318 | pcnet_csr_writew(s,1,val); |
---|
1319 | return; |
---|
1320 | case 17: |
---|
1321 | pcnet_csr_writew(s,2,val); |
---|
1322 | return; |
---|
1323 | case 58: |
---|
1324 | pcnet_bcr_writew(s,BCR_SWS,val); |
---|
1325 | break; |
---|
1326 | default: |
---|
1327 | return; |
---|
1328 | } |
---|
1329 | s->csr[rap] = val; |
---|
1330 | } |
---|
1331 | |
---|
1332 | static uint32_t pcnet_csr_readw(PCNetState *s, uint32_t rap) |
---|
1333 | { |
---|
1334 | uint32_t val; |
---|
1335 | switch (rap) { |
---|
1336 | case 0: |
---|
1337 | pcnet_update_irq(s); |
---|
1338 | val = s->csr[0]; |
---|
1339 | val |= (val & 0x7800) ? 0x8000 : 0; |
---|
1340 | break; |
---|
1341 | case 16: |
---|
1342 | return pcnet_csr_readw(s,1); |
---|
1343 | case 17: |
---|
1344 | return pcnet_csr_readw(s,2); |
---|
1345 | case 58: |
---|
1346 | return pcnet_bcr_readw(s,BCR_SWS); |
---|
1347 | case 88: |
---|
1348 | val = s->csr[89]; |
---|
1349 | val <<= 16; |
---|
1350 | val |= s->csr[88]; |
---|
1351 | break; |
---|
1352 | default: |
---|
1353 | val = s->csr[rap]; |
---|
1354 | } |
---|
1355 | #ifdef PCNET_DEBUG_CSR |
---|
1356 | printf("pcnet_csr_readw rap=%d val=0x%04x\n", rap, val); |
---|
1357 | #endif |
---|
1358 | return val; |
---|
1359 | } |
---|
1360 | |
---|
1361 | static void pcnet_bcr_writew(PCNetState *s, uint32_t rap, uint32_t val) |
---|
1362 | { |
---|
1363 | rap &= 127; |
---|
1364 | #ifdef PCNET_DEBUG_BCR |
---|
1365 | printf("pcnet_bcr_writew rap=%d val=0x%04x\n", rap, val); |
---|
1366 | #endif |
---|
1367 | switch (rap) { |
---|
1368 | case BCR_SWS: |
---|
1369 | if (!(CSR_STOP(s) || CSR_SPND(s))) |
---|
1370 | return; |
---|
1371 | val &= ~0x0300; |
---|
1372 | switch (val & 0x00ff) { |
---|
1373 | case 0: |
---|
1374 | val |= 0x0200; |
---|
1375 | break; |
---|
1376 | case 1: |
---|
1377 | val |= 0x0100; |
---|
1378 | break; |
---|
1379 | case 2: |
---|
1380 | case 3: |
---|
1381 | val |= 0x0300; |
---|
1382 | break; |
---|
1383 | default: |
---|
1384 | printf("Bad SWSTYLE=0x%02x\n", val & 0xff); |
---|
1385 | val = 0x0200; |
---|
1386 | break; |
---|
1387 | } |
---|
1388 | #ifdef PCNET_DEBUG |
---|
1389 | printf("BCR_SWS=0x%04x\n", val); |
---|
1390 | #endif |
---|
1391 | case BCR_LNKST: |
---|
1392 | case BCR_LED1: |
---|
1393 | case BCR_LED2: |
---|
1394 | case BCR_LED3: |
---|
1395 | case BCR_MC: |
---|
1396 | case BCR_FDC: |
---|
1397 | case BCR_BSBC: |
---|
1398 | case BCR_EECAS: |
---|
1399 | case BCR_PLAT: |
---|
1400 | s->bcr[rap] = val; |
---|
1401 | break; |
---|
1402 | default: |
---|
1403 | break; |
---|
1404 | } |
---|
1405 | } |
---|
1406 | |
---|
1407 | static uint32_t pcnet_bcr_readw(PCNetState *s, uint32_t rap) |
---|
1408 | { |
---|
1409 | uint32_t val; |
---|
1410 | rap &= 127; |
---|
1411 | switch (rap) { |
---|
1412 | case BCR_LNKST: |
---|
1413 | case BCR_LED1: |
---|
1414 | case BCR_LED2: |
---|
1415 | case BCR_LED3: |
---|
1416 | val = s->bcr[rap] & ~0x8000; |
---|
1417 | val |= (val & 0x017f & s->lnkst) ? 0x8000 : 0; |
---|
1418 | break; |
---|
1419 | default: |
---|
1420 | val = rap < 32 ? s->bcr[rap] : 0; |
---|
1421 | break; |
---|
1422 | } |
---|
1423 | #ifdef PCNET_DEBUG_BCR |
---|
1424 | printf("pcnet_bcr_readw rap=%d val=0x%04x\n", rap, val); |
---|
1425 | #endif |
---|
1426 | return val; |
---|
1427 | } |
---|
1428 | |
---|
1429 | static void pcnet_h_reset(PCNetState *s) |
---|
1430 | { |
---|
1431 | int i; |
---|
1432 | uint16_t checksum; |
---|
1433 | |
---|
1434 | /* Initialize the PROM */ |
---|
1435 | |
---|
1436 | memcpy(s->prom, s->nd->macaddr, 6); |
---|
1437 | s->prom[12] = s->prom[13] = 0x00; |
---|
1438 | s->prom[14] = s->prom[15] = 0x57; |
---|
1439 | |
---|
1440 | for (i = 0,checksum = 0; i < 16; i++) |
---|
1441 | checksum += s->prom[i]; |
---|
1442 | *(uint16_t *)&s->prom[12] = cpu_to_le16(checksum); |
---|
1443 | |
---|
1444 | |
---|
1445 | s->bcr[BCR_MSRDA] = 0x0005; |
---|
1446 | s->bcr[BCR_MSWRA] = 0x0005; |
---|
1447 | s->bcr[BCR_MC ] = 0x0002; |
---|
1448 | s->bcr[BCR_LNKST] = 0x00c0; |
---|
1449 | s->bcr[BCR_LED1 ] = 0x0084; |
---|
1450 | s->bcr[BCR_LED2 ] = 0x0088; |
---|
1451 | s->bcr[BCR_LED3 ] = 0x0090; |
---|
1452 | s->bcr[BCR_FDC ] = 0x0000; |
---|
1453 | s->bcr[BCR_BSBC ] = 0x9001; |
---|
1454 | s->bcr[BCR_EECAS] = 0x0002; |
---|
1455 | s->bcr[BCR_SWS ] = 0x0200; |
---|
1456 | s->bcr[BCR_PLAT ] = 0xff06; |
---|
1457 | |
---|
1458 | pcnet_s_reset(s); |
---|
1459 | } |
---|
1460 | |
---|
1461 | static void pcnet_aprom_writeb(void *opaque, uint32_t addr, uint32_t val) |
---|
1462 | { |
---|
1463 | PCNetState *s = opaque; |
---|
1464 | #ifdef PCNET_DEBUG |
---|
1465 | printf("pcnet_aprom_writeb addr=0x%08x val=0x%02x\n", addr, val); |
---|
1466 | #endif |
---|
1467 | /* Check APROMWE bit to enable write access */ |
---|
1468 | if (pcnet_bcr_readw(s,2) & 0x80) |
---|
1469 | s->prom[addr & 15] = val; |
---|
1470 | } |
---|
1471 | |
---|
1472 | static uint32_t pcnet_aprom_readb(void *opaque, uint32_t addr) |
---|
1473 | { |
---|
1474 | PCNetState *s = opaque; |
---|
1475 | uint32_t val = s->prom[addr &= 15]; |
---|
1476 | #ifdef PCNET_DEBUG |
---|
1477 | printf("pcnet_aprom_readb addr=0x%08x val=0x%02x\n", addr, val); |
---|
1478 | #endif |
---|
1479 | return val; |
---|
1480 | } |
---|
1481 | |
---|
1482 | static void pcnet_ioport_writew(void *opaque, uint32_t addr, uint32_t val) |
---|
1483 | { |
---|
1484 | PCNetState *s = opaque; |
---|
1485 | pcnet_poll_timer(s); |
---|
1486 | #ifdef PCNET_DEBUG_IO |
---|
1487 | printf("pcnet_ioport_writew addr=0x%08x val=0x%04x\n", addr, val); |
---|
1488 | #endif |
---|
1489 | if (!BCR_DWIO(s)) { |
---|
1490 | switch (addr & 0x0f) { |
---|
1491 | case 0x00: /* RDP */ |
---|
1492 | pcnet_csr_writew(s, s->rap, val); |
---|
1493 | break; |
---|
1494 | case 0x02: |
---|
1495 | s->rap = val & 0x7f; |
---|
1496 | break; |
---|
1497 | case 0x06: |
---|
1498 | pcnet_bcr_writew(s, s->rap, val); |
---|
1499 | break; |
---|
1500 | } |
---|
1501 | } |
---|
1502 | pcnet_update_irq(s); |
---|
1503 | } |
---|
1504 | |
---|
1505 | static uint32_t pcnet_ioport_readw(void *opaque, uint32_t addr) |
---|
1506 | { |
---|
1507 | PCNetState *s = opaque; |
---|
1508 | uint32_t val = -1; |
---|
1509 | pcnet_poll_timer(s); |
---|
1510 | if (!BCR_DWIO(s)) { |
---|
1511 | switch (addr & 0x0f) { |
---|
1512 | case 0x00: /* RDP */ |
---|
1513 | val = pcnet_csr_readw(s, s->rap); |
---|
1514 | break; |
---|
1515 | case 0x02: |
---|
1516 | val = s->rap; |
---|
1517 | break; |
---|
1518 | case 0x04: |
---|
1519 | pcnet_s_reset(s); |
---|
1520 | val = 0; |
---|
1521 | break; |
---|
1522 | case 0x06: |
---|
1523 | val = pcnet_bcr_readw(s, s->rap); |
---|
1524 | break; |
---|
1525 | } |
---|
1526 | } |
---|
1527 | pcnet_update_irq(s); |
---|
1528 | #ifdef PCNET_DEBUG_IO |
---|
1529 | printf("pcnet_ioport_readw addr=0x%08x val=0x%04x\n", addr, val & 0xffff); |
---|
1530 | #endif |
---|
1531 | return val; |
---|
1532 | } |
---|
1533 | |
---|
1534 | static void pcnet_ioport_writel(void *opaque, uint32_t addr, uint32_t val) |
---|
1535 | { |
---|
1536 | PCNetState *s = opaque; |
---|
1537 | pcnet_poll_timer(s); |
---|
1538 | #ifdef PCNET_DEBUG_IO |
---|
1539 | printf("pcnet_ioport_writel addr=0x%08x val=0x%08x\n", addr, val); |
---|
1540 | #endif |
---|
1541 | if (BCR_DWIO(s)) { |
---|
1542 | switch (addr & 0x0f) { |
---|
1543 | case 0x00: /* RDP */ |
---|
1544 | pcnet_csr_writew(s, s->rap, val & 0xffff); |
---|
1545 | break; |
---|
1546 | case 0x04: |
---|
1547 | s->rap = val & 0x7f; |
---|
1548 | break; |
---|
1549 | case 0x0c: |
---|
1550 | pcnet_bcr_writew(s, s->rap, val & 0xffff); |
---|
1551 | break; |
---|
1552 | } |
---|
1553 | } else |
---|
1554 | if ((addr & 0x0f) == 0) { |
---|
1555 | /* switch device to dword i/o mode */ |
---|
1556 | pcnet_bcr_writew(s, BCR_BSBC, pcnet_bcr_readw(s, BCR_BSBC) | 0x0080); |
---|
1557 | #ifdef PCNET_DEBUG_IO |
---|
1558 | printf("device switched into dword i/o mode\n"); |
---|
1559 | #endif |
---|
1560 | } |
---|
1561 | pcnet_update_irq(s); |
---|
1562 | } |
---|
1563 | |
---|
1564 | static uint32_t pcnet_ioport_readl(void *opaque, uint32_t addr) |
---|
1565 | { |
---|
1566 | PCNetState *s = opaque; |
---|
1567 | uint32_t val = -1; |
---|
1568 | pcnet_poll_timer(s); |
---|
1569 | if (BCR_DWIO(s)) { |
---|
1570 | switch (addr & 0x0f) { |
---|
1571 | case 0x00: /* RDP */ |
---|
1572 | val = pcnet_csr_readw(s, s->rap); |
---|
1573 | break; |
---|
1574 | case 0x04: |
---|
1575 | val = s->rap; |
---|
1576 | break; |
---|
1577 | case 0x08: |
---|
1578 | pcnet_s_reset(s); |
---|
1579 | val = 0; |
---|
1580 | break; |
---|
1581 | case 0x0c: |
---|
1582 | val = pcnet_bcr_readw(s, s->rap); |
---|
1583 | break; |
---|
1584 | } |
---|
1585 | } |
---|
1586 | pcnet_update_irq(s); |
---|
1587 | #ifdef PCNET_DEBUG_IO |
---|
1588 | printf("pcnet_ioport_readl addr=0x%08x val=0x%08x\n", addr, val); |
---|
1589 | #endif |
---|
1590 | return val; |
---|
1591 | } |
---|
1592 | |
---|
1593 | static void pcnet_ioport_map(PCIDevice *pci_dev, int region_num, |
---|
1594 | uint32_t addr, uint32_t size, int type) |
---|
1595 | { |
---|
1596 | PCNetState *d = (PCNetState *)pci_dev; |
---|
1597 | |
---|
1598 | #ifdef PCNET_DEBUG_IO |
---|
1599 | printf("pcnet_ioport_map addr=0x%04x size=0x%04x\n", addr, size); |
---|
1600 | #endif |
---|
1601 | |
---|
1602 | register_ioport_write(addr, 16, 1, pcnet_aprom_writeb, d); |
---|
1603 | register_ioport_read(addr, 16, 1, pcnet_aprom_readb, d); |
---|
1604 | |
---|
1605 | register_ioport_write(addr + 0x10, 0x10, 2, pcnet_ioport_writew, d); |
---|
1606 | register_ioport_read(addr + 0x10, 0x10, 2, pcnet_ioport_readw, d); |
---|
1607 | register_ioport_write(addr + 0x10, 0x10, 4, pcnet_ioport_writel, d); |
---|
1608 | register_ioport_read(addr + 0x10, 0x10, 4, pcnet_ioport_readl, d); |
---|
1609 | } |
---|
1610 | |
---|
1611 | static void pcnet_mmio_writeb(void *opaque, target_phys_addr_t addr, uint32_t val) |
---|
1612 | { |
---|
1613 | PCNetState *d = opaque; |
---|
1614 | #ifdef PCNET_DEBUG_IO |
---|
1615 | printf("pcnet_mmio_writeb addr=0x%08x val=0x%02x\n", addr, val); |
---|
1616 | #endif |
---|
1617 | if (!(addr & 0x10)) |
---|
1618 | pcnet_aprom_writeb(d, addr & 0x0f, val); |
---|
1619 | } |
---|
1620 | |
---|
1621 | static uint32_t pcnet_mmio_readb(void *opaque, target_phys_addr_t addr) |
---|
1622 | { |
---|
1623 | PCNetState *d = opaque; |
---|
1624 | uint32_t val = -1; |
---|
1625 | if (!(addr & 0x10)) |
---|
1626 | val = pcnet_aprom_readb(d, addr & 0x0f); |
---|
1627 | #ifdef PCNET_DEBUG_IO |
---|
1628 | printf("pcnet_mmio_readb addr=0x%08x val=0x%02x\n", addr, val & 0xff); |
---|
1629 | #endif |
---|
1630 | return val; |
---|
1631 | } |
---|
1632 | |
---|
1633 | static void pcnet_mmio_writew(void *opaque, target_phys_addr_t addr, uint32_t val) |
---|
1634 | { |
---|
1635 | PCNetState *d = opaque; |
---|
1636 | #ifdef PCNET_DEBUG_IO |
---|
1637 | printf("pcnet_mmio_writew addr=0x%08x val=0x%04x\n", addr, val); |
---|
1638 | #endif |
---|
1639 | if (addr & 0x10) |
---|
1640 | pcnet_ioport_writew(d, addr & 0x0f, val); |
---|
1641 | else { |
---|
1642 | addr &= 0x0f; |
---|
1643 | pcnet_aprom_writeb(d, addr, val & 0xff); |
---|
1644 | pcnet_aprom_writeb(d, addr+1, (val & 0xff00) >> 8); |
---|
1645 | } |
---|
1646 | } |
---|
1647 | |
---|
1648 | static uint32_t pcnet_mmio_readw(void *opaque, target_phys_addr_t addr) |
---|
1649 | { |
---|
1650 | PCNetState *d = opaque; |
---|
1651 | uint32_t val = -1; |
---|
1652 | if (addr & 0x10) |
---|
1653 | val = pcnet_ioport_readw(d, addr & 0x0f); |
---|
1654 | else { |
---|
1655 | addr &= 0x0f; |
---|
1656 | val = pcnet_aprom_readb(d, addr+1); |
---|
1657 | val <<= 8; |
---|
1658 | val |= pcnet_aprom_readb(d, addr); |
---|
1659 | } |
---|
1660 | #ifdef PCNET_DEBUG_IO |
---|
1661 | printf("pcnet_mmio_readw addr=0x%08x val = 0x%04x\n", addr, val & 0xffff); |
---|
1662 | #endif |
---|
1663 | return val; |
---|
1664 | } |
---|
1665 | |
---|
1666 | static void pcnet_mmio_writel(void *opaque, target_phys_addr_t addr, uint32_t val) |
---|
1667 | { |
---|
1668 | PCNetState *d = opaque; |
---|
1669 | #ifdef PCNET_DEBUG_IO |
---|
1670 | printf("pcnet_mmio_writel addr=0x%08x val=0x%08x\n", addr, val); |
---|
1671 | #endif |
---|
1672 | if (addr & 0x10) |
---|
1673 | pcnet_ioport_writel(d, addr & 0x0f, val); |
---|
1674 | else { |
---|
1675 | addr &= 0x0f; |
---|
1676 | pcnet_aprom_writeb(d, addr, val & 0xff); |
---|
1677 | pcnet_aprom_writeb(d, addr+1, (val & 0xff00) >> 8); |
---|
1678 | pcnet_aprom_writeb(d, addr+2, (val & 0xff0000) >> 16); |
---|
1679 | pcnet_aprom_writeb(d, addr+3, (val & 0xff000000) >> 24); |
---|
1680 | } |
---|
1681 | } |
---|
1682 | |
---|
1683 | static uint32_t pcnet_mmio_readl(void *opaque, target_phys_addr_t addr) |
---|
1684 | { |
---|
1685 | PCNetState *d = opaque; |
---|
1686 | uint32_t val; |
---|
1687 | if (addr & 0x10) |
---|
1688 | val = pcnet_ioport_readl(d, addr & 0x0f); |
---|
1689 | else { |
---|
1690 | addr &= 0x0f; |
---|
1691 | val = pcnet_aprom_readb(d, addr+3); |
---|
1692 | val <<= 8; |
---|
1693 | val |= pcnet_aprom_readb(d, addr+2); |
---|
1694 | val <<= 8; |
---|
1695 | val |= pcnet_aprom_readb(d, addr+1); |
---|
1696 | val <<= 8; |
---|
1697 | val |= pcnet_aprom_readb(d, addr); |
---|
1698 | } |
---|
1699 | #ifdef PCNET_DEBUG_IO |
---|
1700 | printf("pcnet_mmio_readl addr=0x%08x val=0x%08x\n", addr, val); |
---|
1701 | #endif |
---|
1702 | return val; |
---|
1703 | } |
---|
1704 | |
---|
1705 | |
---|
1706 | static CPUWriteMemoryFunc *pcnet_mmio_write[] = { |
---|
1707 | (CPUWriteMemoryFunc *)&pcnet_mmio_writeb, |
---|
1708 | (CPUWriteMemoryFunc *)&pcnet_mmio_writew, |
---|
1709 | (CPUWriteMemoryFunc *)&pcnet_mmio_writel |
---|
1710 | }; |
---|
1711 | |
---|
1712 | static CPUReadMemoryFunc *pcnet_mmio_read[] = { |
---|
1713 | (CPUReadMemoryFunc *)&pcnet_mmio_readb, |
---|
1714 | (CPUReadMemoryFunc *)&pcnet_mmio_readw, |
---|
1715 | (CPUReadMemoryFunc *)&pcnet_mmio_readl |
---|
1716 | }; |
---|
1717 | |
---|
1718 | static void pcnet_mmio_map(PCIDevice *pci_dev, int region_num, |
---|
1719 | uint32_t addr, uint32_t size, int type) |
---|
1720 | { |
---|
1721 | PCNetState *d = (PCNetState *)pci_dev; |
---|
1722 | |
---|
1723 | #ifdef PCNET_DEBUG_IO |
---|
1724 | printf("pcnet_ioport_map addr=0x%08x 0x%08x\n", addr, size); |
---|
1725 | #endif |
---|
1726 | |
---|
1727 | cpu_register_physical_memory(addr, PCNET_PNPMMIO_SIZE, d->mmio_io_addr); |
---|
1728 | } |
---|
1729 | |
---|
1730 | |
---|
1731 | static void pcnet_save(QEMUFile *f, void *opaque) |
---|
1732 | { |
---|
1733 | PCNetState *s = opaque; |
---|
1734 | unsigned int i; |
---|
1735 | |
---|
1736 | qemu_put_be32s(f, &s->rap); |
---|
1737 | qemu_put_be32s(f, &s->isr); |
---|
1738 | qemu_put_be32s(f, &s->lnkst); |
---|
1739 | qemu_put_be32s(f, &s->rdra); |
---|
1740 | qemu_put_be32s(f, &s->tdra); |
---|
1741 | qemu_put_buffer(f, s->prom, 16); |
---|
1742 | for (i = 0; i < 128; i++) |
---|
1743 | qemu_put_be16s(f, &s->csr[i]); |
---|
1744 | for (i = 0; i < 32; i++) |
---|
1745 | qemu_put_be16s(f, &s->bcr[i]); |
---|
1746 | qemu_put_be64s(f, &s->timer); |
---|
1747 | qemu_put_be32s(f, &s->xmit_pos); |
---|
1748 | qemu_put_be32s(f, &s->recv_pos); |
---|
1749 | qemu_put_buffer(f, s->buffer, 4096); |
---|
1750 | qemu_put_be32s(f, &s->tx_busy); |
---|
1751 | qemu_put_timer(f, s->poll_timer); |
---|
1752 | } |
---|
1753 | |
---|
1754 | static int pcnet_load(QEMUFile *f, void *opaque, int version_id) |
---|
1755 | { |
---|
1756 | PCNetState *s = opaque; |
---|
1757 | int i, ret; |
---|
1758 | |
---|
1759 | if (version_id != 1) |
---|
1760 | return -EINVAL; |
---|
1761 | |
---|
1762 | qemu_get_be32s(f, &s->rap); |
---|
1763 | qemu_get_be32s(f, &s->isr); |
---|
1764 | qemu_get_be32s(f, &s->lnkst); |
---|
1765 | qemu_get_be32s(f, &s->rdra); |
---|
1766 | qemu_get_be32s(f, &s->tdra); |
---|
1767 | qemu_get_buffer(f, s->prom, 16); |
---|
1768 | for (i = 0; i < 128; i++) |
---|
1769 | qemu_get_be16s(f, &s->csr[i]); |
---|
1770 | for (i = 0; i < 32; i++) |
---|
1771 | qemu_get_be16s(f, &s->bcr[i]); |
---|
1772 | qemu_get_be64s(f, &s->timer); |
---|
1773 | qemu_get_be32s(f, &s->xmit_pos); |
---|
1774 | qemu_get_be32s(f, &s->recv_pos); |
---|
1775 | qemu_get_buffer(f, s->buffer, 4096); |
---|
1776 | qemu_get_be32s(f, &s->tx_busy); |
---|
1777 | qemu_get_timer(f, s->poll_timer); |
---|
1778 | |
---|
1779 | return 0; |
---|
1780 | } |
---|
1781 | |
---|
1782 | void pci_pcnet_init(PCIBus *bus, NICInfo *nd) |
---|
1783 | { |
---|
1784 | PCNetState *d; |
---|
1785 | uint8_t *pci_conf; |
---|
1786 | int instance; |
---|
1787 | |
---|
1788 | #if 0 |
---|
1789 | printf("sizeof(RMD)=%d, sizeof(TMD)=%d\n", |
---|
1790 | sizeof(struct pcnet_RMD), sizeof(struct pcnet_TMD)); |
---|
1791 | #endif |
---|
1792 | |
---|
1793 | d = (PCNetState *)pci_register_device(bus, "PCNet", sizeof(PCNetState), |
---|
1794 | -1, NULL, NULL); |
---|
1795 | |
---|
1796 | pci_conf = d->dev.config; |
---|
1797 | |
---|
1798 | *(uint16_t *)&pci_conf[0x00] = cpu_to_le16(0x1022); |
---|
1799 | *(uint16_t *)&pci_conf[0x02] = cpu_to_le16(0x2000); |
---|
1800 | *(uint16_t *)&pci_conf[0x04] = cpu_to_le16(0x0007); |
---|
1801 | *(uint16_t *)&pci_conf[0x06] = cpu_to_le16(0x0280); |
---|
1802 | pci_conf[0x08] = 0x10; |
---|
1803 | pci_conf[0x09] = 0x00; |
---|
1804 | pci_conf[0x0a] = 0x00; // ethernet network controller |
---|
1805 | pci_conf[0x0b] = 0x02; |
---|
1806 | pci_conf[0x0e] = 0x00; // header_type |
---|
1807 | |
---|
1808 | *(uint32_t *)&pci_conf[0x10] = cpu_to_le32(0x00000001); |
---|
1809 | *(uint32_t *)&pci_conf[0x14] = cpu_to_le32(0x00000000); |
---|
1810 | |
---|
1811 | pci_conf[0x3d] = 1; // interrupt pin 0 |
---|
1812 | pci_conf[0x3e] = 0x06; |
---|
1813 | pci_conf[0x3f] = 0xff; |
---|
1814 | |
---|
1815 | /* Handler for memory-mapped I/O */ |
---|
1816 | d->mmio_io_addr = |
---|
1817 | cpu_register_io_memory(0, pcnet_mmio_read, pcnet_mmio_write, d); |
---|
1818 | |
---|
1819 | pci_register_io_region((PCIDevice *)d, 0, PCNET_IOPORT_SIZE, |
---|
1820 | PCI_ADDRESS_SPACE_IO, pcnet_ioport_map); |
---|
1821 | |
---|
1822 | pci_register_io_region((PCIDevice *)d, 1, PCNET_PNPMMIO_SIZE, |
---|
1823 | PCI_ADDRESS_SPACE_MEM, pcnet_mmio_map); |
---|
1824 | |
---|
1825 | d->poll_timer = qemu_new_timer(vm_clock, pcnet_poll_timer, d); |
---|
1826 | |
---|
1827 | d->nd = nd; |
---|
1828 | |
---|
1829 | d->vc = qemu_new_vlan_client(nd->vlan, pcnet_receive, |
---|
1830 | pcnet_can_receive, d); |
---|
1831 | |
---|
1832 | instance = pci_bus_num(bus) << 8 | d->dev.devfn; |
---|
1833 | register_savevm("pcnet", instance, 1, pcnet_save, pcnet_load, d); |
---|
1834 | register_savevm("pcnet_pci", instance, 1, generic_pci_save, |
---|
1835 | generic_pci_load, &d->dev); |
---|
1836 | |
---|
1837 | snprintf(d->vc->info_str, sizeof(d->vc->info_str), |
---|
1838 | "pcnet macaddr=%02x:%02x:%02x:%02x:%02x:%02x", |
---|
1839 | d->nd->macaddr[0], |
---|
1840 | d->nd->macaddr[1], |
---|
1841 | d->nd->macaddr[2], |
---|
1842 | d->nd->macaddr[3], |
---|
1843 | d->nd->macaddr[4], |
---|
1844 | d->nd->macaddr[5]); |
---|
1845 | |
---|
1846 | pcnet_h_reset(d); |
---|
1847 | } |
---|