?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Only use /dev/shm hack when kqemu is enabled.
[qemu/mini2440.git] / hw / rtl8139.c
blob49c4c916b7b4d6909a66e4e97835f33cb0bfbe9d
1 /**
2 * QEMU RTL8139 emulation
3 *
4 * Copyright (c) 2006 Igor Kovalenko
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 * Modifications:
25 * 2006-Jan-28 Mark Malakanov : TSAD and CSCR implementation (for Windows driver)
26 *
27 */
28
29 #include "vl.h"
30
31
32 /* debug RTL8139 card */
33 //#define DEBUG_RTL8139 1
34
35 /* debug RTL8139 card C+ mode only */
36 //#define DEBUG_RTL8139CP 1
37
38 /* RTL8139 provides frame CRC with received packet, this feature seems to be
39 ignored by most drivers, disabled by default */
40 //#define RTL8139_CALCULATE_RXCRC 1
41
42
43 #if defined(RTL8139_CALCULATE_RXCRC)
44 /* For crc32 */
45 #include <zlib.h>
46 #endif
47
48 #define SET_MASKED(input, mask, curr) \
49 ( ( (input) & ~(mask) ) | ( (curr) & (mask) ) )
50
51 /* arg % size for size which is a power of 2 */
52 #define MOD2(input, size) \
53 ( ( input ) & ( size - 1 ) )
54
55 /* Symbolic offsets to registers. */
56 enum RTL8139_registers {
57 MAC0 = 0, /* Ethernet hardware address. */
58 MAR0 = 8, /* Multicast filter. */
59 TxStatus0 = 0x10, /* Transmit status (Four 32bit registers). */
60 TxAddr0 = 0x20, /* Tx descriptors (also four 32bit). */
61 RxBuf = 0x30,
62 ChipCmd = 0x37,
63 RxBufPtr = 0x38,
64 RxBufAddr = 0x3A,
65 IntrMask = 0x3C,
66 IntrStatus = 0x3E,
67 TxConfig = 0x40,
68 RxConfig = 0x44,
69 Timer = 0x48, /* A general-purpose counter. */
70 RxMissed = 0x4C, /* 24 bits valid, write clears. */
71 Cfg9346 = 0x50,
72 Config0 = 0x51,
73 Config1 = 0x52,
74 FlashReg = 0x54,
75 MediaStatus = 0x58,
76 Config3 = 0x59,
77 Config4 = 0x5A, /* absent on RTL-8139A */
78 HltClk = 0x5B,
79 MultiIntr = 0x5C,
80 PCIRevisionID = 0x5E,
81 TxSummary = 0x60, /* TSAD register. Transmit Status of All Descriptors*/
82 BasicModeCtrl = 0x62,
83 BasicModeStatus = 0x64,
84 NWayAdvert = 0x66,
85 NWayLPAR = 0x68,
86 NWayExpansion = 0x6A,
87 /* Undocumented registers, but required for proper operation. */
88 FIFOTMS = 0x70, /* FIFO Control and test. */
89 CSCR = 0x74, /* Chip Status and Configuration Register. */
90 PARA78 = 0x78,
91 PARA7c = 0x7c, /* Magic transceiver parameter register. */
92 Config5 = 0xD8, /* absent on RTL-8139A */
93 /* C+ mode */
94 TxPoll = 0xD9, /* Tell chip to check Tx descriptors for work */
95 RxMaxSize = 0xDA, /* Max size of an Rx packet (8169 only) */
96 CpCmd = 0xE0, /* C+ Command register (C+ mode only) */
97 IntrMitigate = 0xE2, /* rx/tx interrupt mitigation control */
98 RxRingAddrLO = 0xE4, /* 64-bit start addr of Rx ring */
99 RxRingAddrHI = 0xE8, /* 64-bit start addr of Rx ring */
100 TxThresh = 0xEC, /* Early Tx threshold */
101 };
102
103 enum ClearBitMasks {
104 MultiIntrClear = 0xF000,
105 ChipCmdClear = 0xE2,
106 Config1Clear = (1<<7)|(1<<6)|(1<<3)|(1<<2)|(1<<1),
107 };
108
109 enum ChipCmdBits {
110 CmdReset = 0x10,
111 CmdRxEnb = 0x08,
112 CmdTxEnb = 0x04,
113 RxBufEmpty = 0x01,
114 };
115
116 /* C+ mode */
117 enum CplusCmdBits {
118 CPlusRxEnb = 0x0002,
119 CPlusTxEnb = 0x0001,
120 };
121
122 /* Interrupt register bits, using my own meaningful names. */
123 enum IntrStatusBits {
124 PCIErr = 0x8000,
125 PCSTimeout = 0x4000,
126 RxFIFOOver = 0x40,
127 RxUnderrun = 0x20,
128 RxOverflow = 0x10,
129 TxErr = 0x08,
130 TxOK = 0x04,
131 RxErr = 0x02,
132 RxOK = 0x01,
133
134 RxAckBits = RxFIFOOver | RxOverflow | RxOK,
135 };
136
137 enum TxStatusBits {
138 TxHostOwns = 0x2000,
139 TxUnderrun = 0x4000,
140 TxStatOK = 0x8000,
141 TxOutOfWindow = 0x20000000,
142 TxAborted = 0x40000000,
143 TxCarrierLost = 0x80000000,
144 };
145 enum RxStatusBits {
146 RxMulticast = 0x8000,
147 RxPhysical = 0x4000,
148 RxBroadcast = 0x2000,
149 RxBadSymbol = 0x0020,
150 RxRunt = 0x0010,
151 RxTooLong = 0x0008,
152 RxCRCErr = 0x0004,
153 RxBadAlign = 0x0002,
154 RxStatusOK = 0x0001,
155 };
156
157 /* Bits in RxConfig. */
158 enum rx_mode_bits {
159 AcceptErr = 0x20,
160 AcceptRunt = 0x10,
161 AcceptBroadcast = 0x08,
162 AcceptMulticast = 0x04,
163 AcceptMyPhys = 0x02,
164 AcceptAllPhys = 0x01,
165 };
166
167 /* Bits in TxConfig. */
168 enum tx_config_bits {
169
170 /* Interframe Gap Time. Only TxIFG96 doesn't violate IEEE 802.3 */
171 TxIFGShift = 24,
172 TxIFG84 = (0 << TxIFGShift), /* 8.4us / 840ns (10 / 100Mbps) */
173 TxIFG88 = (1 << TxIFGShift), /* 8.8us / 880ns (10 / 100Mbps) */
174 TxIFG92 = (2 << TxIFGShift), /* 9.2us / 920ns (10 / 100Mbps) */
175 TxIFG96 = (3 << TxIFGShift), /* 9.6us / 960ns (10 / 100Mbps) */
176
177 TxLoopBack = (1 << 18) | (1 << 17), /* enable loopback test mode */
178 TxCRC = (1 << 16), /* DISABLE appending CRC to end of Tx packets */
179 TxClearAbt = (1 << 0), /* Clear abort (WO) */
180 TxDMAShift = 8, /* DMA burst value (0-7) is shifted this many bits */
181 TxRetryShift = 4, /* TXRR value (0-15) is shifted this many bits */
182
183 TxVersionMask = 0x7C800000, /* mask out version bits 30-26, 23 */
184 };
185
186
187 /* Transmit Status of All Descriptors (TSAD) Register */
188 enum TSAD_bits {
189 TSAD_TOK3 = 1<<15, // TOK bit of Descriptor 3
190 TSAD_TOK2 = 1<<14, // TOK bit of Descriptor 2
191 TSAD_TOK1 = 1<<13, // TOK bit of Descriptor 1
192 TSAD_TOK0 = 1<<12, // TOK bit of Descriptor 0
193 TSAD_TUN3 = 1<<11, // TUN bit of Descriptor 3
194 TSAD_TUN2 = 1<<10, // TUN bit of Descriptor 2
195 TSAD_TUN1 = 1<<9, // TUN bit of Descriptor 1
196 TSAD_TUN0 = 1<<8, // TUN bit of Descriptor 0
197 TSAD_TABT3 = 1<<07, // TABT bit of Descriptor 3
198 TSAD_TABT2 = 1<<06, // TABT bit of Descriptor 2
199 TSAD_TABT1 = 1<<05, // TABT bit of Descriptor 1
200 TSAD_TABT0 = 1<<04, // TABT bit of Descriptor 0
201 TSAD_OWN3 = 1<<03, // OWN bit of Descriptor 3
202 TSAD_OWN2 = 1<<02, // OWN bit of Descriptor 2
203 TSAD_OWN1 = 1<<01, // OWN bit of Descriptor 1
204 TSAD_OWN0 = 1<<00, // OWN bit of Descriptor 0
205 };
206
207
208 /* Bits in Config1 */
209 enum Config1Bits {
210 Cfg1_PM_Enable = 0x01,
211 Cfg1_VPD_Enable = 0x02,
212 Cfg1_PIO = 0x04,
213 Cfg1_MMIO = 0x08,
214 LWAKE = 0x10, /* not on 8139, 8139A */
215 Cfg1_Driver_Load = 0x20,
216 Cfg1_LED0 = 0x40,
217 Cfg1_LED1 = 0x80,
218 SLEEP = (1 << 1), /* only on 8139, 8139A */
219 PWRDN = (1 << 0), /* only on 8139, 8139A */
220 };
221
222 /* Bits in Config3 */
223 enum Config3Bits {
224 Cfg3_FBtBEn = (1 << 0), /* 1 = Fast Back to Back */
225 Cfg3_FuncRegEn = (1 << 1), /* 1 = enable CardBus Function registers */
226 Cfg3_CLKRUN_En = (1 << 2), /* 1 = enable CLKRUN */
227 Cfg3_CardB_En = (1 << 3), /* 1 = enable CardBus registers */
228 Cfg3_LinkUp = (1 << 4), /* 1 = wake up on link up */
229 Cfg3_Magic = (1 << 5), /* 1 = wake up on Magic Packet (tm) */
230 Cfg3_PARM_En = (1 << 6), /* 0 = software can set twister parameters */
231 Cfg3_GNTSel = (1 << 7), /* 1 = delay 1 clock from PCI GNT signal */
232 };
233
234 /* Bits in Config4 */
235 enum Config4Bits {
236 LWPTN = (1 << 2), /* not on 8139, 8139A */
237 };
238
239 /* Bits in Config5 */
240 enum Config5Bits {
241 Cfg5_PME_STS = (1 << 0), /* 1 = PCI reset resets PME_Status */
242 Cfg5_LANWake = (1 << 1), /* 1 = enable LANWake signal */
243 Cfg5_LDPS = (1 << 2), /* 0 = save power when link is down */
244 Cfg5_FIFOAddrPtr = (1 << 3), /* Realtek internal SRAM testing */
245 Cfg5_UWF = (1 << 4), /* 1 = accept unicast wakeup frame */
246 Cfg5_MWF = (1 << 5), /* 1 = accept multicast wakeup frame */
247 Cfg5_BWF = (1 << 6), /* 1 = accept broadcast wakeup frame */
248 };
249
250 enum RxConfigBits {
251 /* rx fifo threshold */
252 RxCfgFIFOShift = 13,
253 RxCfgFIFONone = (7 << RxCfgFIFOShift),
254
255 /* Max DMA burst */
256 RxCfgDMAShift = 8,
257 RxCfgDMAUnlimited = (7 << RxCfgDMAShift),
258
259 /* rx ring buffer length */
260 RxCfgRcv8K = 0,
261 RxCfgRcv16K = (1 << 11),
262 RxCfgRcv32K = (1 << 12),
263 RxCfgRcv64K = (1 << 11) | (1 << 12),
264
265 /* Disable packet wrap at end of Rx buffer. (not possible with 64k) */
266 RxNoWrap = (1 << 7),
267 };
268
269 /* Twister tuning parameters from RealTek.
270 Completely undocumented, but required to tune bad links on some boards. */
271 /*
272 enum CSCRBits {
273 CSCR_LinkOKBit = 0x0400,
274 CSCR_LinkChangeBit = 0x0800,
275 CSCR_LinkStatusBits = 0x0f000,
276 CSCR_LinkDownOffCmd = 0x003c0,
277 CSCR_LinkDownCmd = 0x0f3c0,
278 */
279 enum CSCRBits {
280 CSCR_Testfun = 1<<15, /* 1 = Auto-neg speeds up internal timer, WO, def 0 */
281 CSCR_LD = 1<<9, /* Active low TPI link disable signal. When low, TPI still transmits link pulses and TPI stays in good link state. def 1*/
282 CSCR_HEART_BIT = 1<<8, /* 1 = HEART BEAT enable, 0 = HEART BEAT disable. HEART BEAT function is only valid in 10Mbps mode. def 1*/
283 CSCR_JBEN = 1<<7, /* 1 = enable jabber function. 0 = disable jabber function, def 1*/
284 CSCR_F_LINK_100 = 1<<6, /* Used to login force good link in 100Mbps for diagnostic purposes. 1 = DISABLE, 0 = ENABLE. def 1*/
285 CSCR_F_Connect = 1<<5, /* Assertion of this bit forces the disconnect function to be bypassed. def 0*/
286 CSCR_Con_status = 1<<3, /* This bit indicates the status of the connection. 1 = valid connected link detected; 0 = disconnected link detected. RO def 0*/
287 CSCR_Con_status_En = 1<<2, /* Assertion of this bit configures LED1 pin to indicate connection status. def 0*/
288 CSCR_PASS_SCR = 1<<0, /* Bypass Scramble, def 0*/
289 };
290
291 enum Cfg9346Bits {
292 Cfg9346_Lock = 0x00,
293 Cfg9346_Unlock = 0xC0,
294 };
295
296 typedef enum {
297 CH_8139 = 0,
298 CH_8139_K,
299 CH_8139A,
300 CH_8139A_G,
301 CH_8139B,
302 CH_8130,
303 CH_8139C,
304 CH_8100,
305 CH_8100B_8139D,
306 CH_8101,
307 } chip_t;
308
309 enum chip_flags {
310 HasHltClk = (1 << 0),
311 HasLWake = (1 << 1),
312 };
313
314 #define HW_REVID(b30, b29, b28, b27, b26, b23, b22) \
315 (b30<<30 | b29<<29 | b28<<28 | b27<<27 | b26<<26 | b23<<23 | b22<<22)
316 #define HW_REVID_MASK HW_REVID(1, 1, 1, 1, 1, 1, 1)
317
318 /* Size is 64 * 16bit words */
319 #define EEPROM_9346_ADDR_BITS 6
320 #define EEPROM_9346_SIZE (1 << EEPROM_9346_ADDR_BITS)
321 #define EEPROM_9346_ADDR_MASK (EEPROM_9346_SIZE - 1)
322
323 enum Chip9346Operation
324 {
325 Chip9346_op_mask = 0xc0, /* 10 zzzzzz */
326 Chip9346_op_read = 0x80, /* 10 AAAAAA */
327 Chip9346_op_write = 0x40, /* 01 AAAAAA D(15)..D(0) */
328 Chip9346_op_ext_mask = 0xf0, /* 11 zzzzzz */
329 Chip9346_op_write_enable = 0x30, /* 00 11zzzz */
330 Chip9346_op_write_all = 0x10, /* 00 01zzzz */
331 Chip9346_op_write_disable = 0x00, /* 00 00zzzz */
332 };
333
334 enum Chip9346Mode
335 {
336 Chip9346_none = 0,
337 Chip9346_enter_command_mode,
338 Chip9346_read_command,
339 Chip9346_data_read, /* from output register */
340 Chip9346_data_write, /* to input register, then to contents at specified address */
341 Chip9346_data_write_all, /* to input register, then filling contents */
342 };
343
344 typedef struct EEprom9346
345 {
346 uint16_t contents[EEPROM_9346_SIZE];
347 int mode;
348 uint32_t tick;
349 uint8_t address;
350 uint16_t input;
351 uint16_t output;
352
353 uint8_t eecs;
354 uint8_t eesk;
355 uint8_t eedi;
356 uint8_t eedo;
357 } EEprom9346;
358
359 typedef struct RTL8139State {
360 uint8_t phys[8]; /* mac address */
361 uint8_t mult[8]; /* multicast mask array */
362
363 uint32_t TxStatus[4]; /* TxStatus0 */
364 uint32_t TxAddr[4]; /* TxAddr0 */
365 uint32_t RxBuf; /* Receive buffer */
366 uint32_t RxBufferSize;/* internal variable, receive ring buffer size in C mode */
367 uint32_t RxBufPtr;
368 uint32_t RxBufAddr;
369
370 uint16_t IntrStatus;
371 uint16_t IntrMask;
372
373 uint32_t TxConfig;
374 uint32_t RxConfig;
375 uint32_t RxMissed;
376
377 uint16_t CSCR;
378
379 uint8_t Cfg9346;
380 uint8_t Config0;
381 uint8_t Config1;
382 uint8_t Config3;
383 uint8_t Config4;
384 uint8_t Config5;
385
386 uint8_t clock_enabled;
387 uint8_t bChipCmdState;
388
389 uint16_t MultiIntr;
390
391 uint16_t BasicModeCtrl;
392 uint16_t BasicModeStatus;
393 uint16_t NWayAdvert;
394 uint16_t NWayLPAR;
395 uint16_t NWayExpansion;
396
397 uint16_t CpCmd;
398 uint8_t TxThresh;
399
400 int irq;
401 PCIDevice *pci_dev;
402 VLANClientState *vc;
403 uint8_t macaddr[6];
404 int rtl8139_mmio_io_addr;
405
406 /* C ring mode */
407 uint32_t currTxDesc;
408
409 /* C+ mode */
410 uint32_t currCPlusRxDesc;
411 uint32_t currCPlusTxDesc;
412
413 uint32_t RxRingAddrLO;
414 uint32_t RxRingAddrHI;
415
416 EEprom9346 eeprom;
417
418 } RTL8139State;
419
420 void prom9346_decode_command(EEprom9346 *eeprom, uint8_t command)
421 {
422 #if defined(DEBUG_RTL8139)
423 printf("RTL8139: eeprom command 0x%02x\n", command);
424 #endif
425
426 switch (command & Chip9346_op_mask)
427 {
428 case Chip9346_op_read:
429 {
430 eeprom->address = command & EEPROM_9346_ADDR_MASK;
431 eeprom->output = eeprom->contents[eeprom->address];
432 eeprom->eedo = 0;
433 eeprom->tick = 0;
434 eeprom->mode = Chip9346_data_read;
435 #if defined(DEBUG_RTL8139)
436 printf("RTL8139: eeprom read from address 0x%02x data=0x%04x\n",
437 eeprom->address, eeprom->output);
438 #endif
439 }
440 break;
441
442 case Chip9346_op_write:
443 {
444 eeprom->address = command & EEPROM_9346_ADDR_MASK;
445 eeprom->input = 0;
446 eeprom->tick = 0;
447 eeprom->mode = Chip9346_none; /* Chip9346_data_write */
448 #if defined(DEBUG_RTL8139)
449 printf("RTL8139: eeprom begin write to address 0x%02x\n",
450 eeprom->address);
451 #endif
452 }
453 break;
454 default:
455 eeprom->mode = Chip9346_none;
456 switch (command & Chip9346_op_ext_mask)
457 {
458 case Chip9346_op_write_enable:
459 #if defined(DEBUG_RTL8139)
460 printf("RTL8139: eeprom write enabled\n");
461 #endif
462 break;
463 case Chip9346_op_write_all:
464 #if defined(DEBUG_RTL8139)
465 printf("RTL8139: eeprom begin write all\n");
466 #endif
467 break;
468 case Chip9346_op_write_disable:
469 #if defined(DEBUG_RTL8139)
470 printf("RTL8139: eeprom write disabled\n");
471 #endif
472 break;
473 }
474 break;
475 }
476 }
477
478 void prom9346_shift_clock(EEprom9346 *eeprom)
479 {
480 int bit = eeprom->eedi?1:0;
481
482 ++ eeprom->tick;
483
484 #if defined(DEBUG_RTL8139)
485 printf("eeprom: tick %d eedi=%d eedo=%d\n", eeprom->tick, eeprom->eedi, eeprom->eedo);
486 #endif
487
488 switch (eeprom->mode)
489 {
490 case Chip9346_enter_command_mode:
491 if (bit)
492 {
493 eeprom->mode = Chip9346_read_command;
494 eeprom->tick = 0;
495 eeprom->input = 0;
496 #if defined(DEBUG_RTL8139)
497 printf("eeprom: +++ synchronized, begin command read\n");
498 #endif
499 }
500 break;
501
502 case Chip9346_read_command:
503 eeprom->input = (eeprom->input << 1) | (bit & 1);
504 if (eeprom->tick == 8)
505 {
506 prom9346_decode_command(eeprom, eeprom->input & 0xff);
507 }
508 break;
509
510 case Chip9346_data_read:
511 eeprom->eedo = (eeprom->output & 0x8000)?1:0;
512 eeprom->output <<= 1;
513 if (eeprom->tick == 16)
514 {
515 ++eeprom->address;
516 eeprom->address &= EEPROM_9346_ADDR_MASK;
517 eeprom->output = eeprom->contents[eeprom->address];
518 eeprom->tick = 0;
519
520 #if defined(DEBUG_RTL8139)
521 printf("eeprom: +++ read next address 0x%02x data=0x%04x\n",
522 eeprom->address, eeprom->output);
523 #endif
524 }
525 break;
526
527 case Chip9346_data_write:
528 eeprom->input = (eeprom->input << 1) | (bit & 1);
529 if (eeprom->tick == 16)
530 {
531 #if defined(DEBUG_RTL8139)
532 printf("RTL8139: eeprom write to address 0x%02x data=0x%04x\n",
533 eeprom->address, eeprom->input);
534 #endif
535 eeprom->contents[eeprom->address] = eeprom->input;
536 eeprom->mode = Chip9346_none; /* waiting for next command after CS cycle */
537 eeprom->tick = 0;
538 eeprom->input = 0;
539 }
540 break;
541
542 case Chip9346_data_write_all:
543 eeprom->input = (eeprom->input << 1) | (bit & 1);
544 if (eeprom->tick == 16)
545 {
546 int i;
547 for (i = 0; i < EEPROM_9346_SIZE; i++)
548 {
549 eeprom->contents[i] = eeprom->input;
550 }
551 #if defined(DEBUG_RTL8139)
552 printf("RTL8139: eeprom filled with data=0x%04x\n",
553 eeprom->input);
554 #endif
555 eeprom->mode = Chip9346_enter_command_mode;
556 eeprom->tick = 0;
557 eeprom->input = 0;
558 }
559 break;
560
561 default:
562 break;
563 }
564 }
565
566 int prom9346_get_wire(RTL8139State *s)
567 {
568 EEprom9346 *eeprom = &s->eeprom;
569 if (!eeprom->eecs)
570 return 0;
571
572 return eeprom->eedo;
573 }
574
575 void prom9346_set_wire(RTL8139State *s, int eecs, int eesk, int eedi)
576 {
577 EEprom9346 *eeprom = &s->eeprom;
578 uint8_t old_eecs = eeprom->eecs;
579 uint8_t old_eesk = eeprom->eesk;
580
581 eeprom->eecs = eecs;
582 eeprom->eesk = eesk;
583 eeprom->eedi = eedi;
584
585 #if defined(DEBUG_RTL8139)
586 printf("eeprom: +++ wires CS=%d SK=%d DI=%d DO=%d\n", eeprom->eecs, eeprom->eesk, eeprom->eedi, eeprom->eedo);
587 #endif
588
589 if (!old_eecs && eecs)
590 {
591 /* Synchronize start */
592 eeprom->tick = 0;
593 eeprom->input = 0;
594 eeprom->output = 0;
595 eeprom->mode = Chip9346_enter_command_mode;
596
597 #if defined(DEBUG_RTL8139)
598 printf("=== eeprom: begin access, enter command mode\n");
599 #endif
600
601 }
602
603 if (!eecs)
604 {
605 #if defined(DEBUG_RTL8139)
606 printf("=== eeprom: end access\n");
607 #endif
608 return;
609 }
610
611 if (!old_eesk && eesk)
612 {
613 /* SK front rules */
614 prom9346_shift_clock(eeprom);
615 }
616 }
617
618 static void rtl8139_update_irq(RTL8139State *s)
619 {
620 int isr;
621 isr = (s->IntrStatus & s->IntrMask) & 0xffff;
622 #if defined(DEBUG_RTL8139)
623 printf("RTL8139: Set IRQ line %d to %d (%04x %04x)\n",
624 s->irq, isr ? 1 : 0, s->IntrStatus, s->IntrMask);
625 #endif
626 if (s->irq == 16) {
627 /* PCI irq */
628 pci_set_irq(s->pci_dev, 0, (isr != 0));
629 } else {
630 /* ISA irq */
631 pic_set_irq(s->irq, (isr != 0));
632 }
633 }
634
635 #define POLYNOMIAL 0x04c11db6
636
637 /* From FreeBSD */
638 /* XXX: optimize */
639 static int compute_mcast_idx(const uint8_t *ep)
640 {
641 uint32_t crc;
642 int carry, i, j;
643 uint8_t b;
644
645 crc = 0xffffffff;
646 for (i = 0; i < 6; i++) {
647 b = *ep++;
648 for (j = 0; j < 8; j++) {
649 carry = ((crc & 0x80000000L) ? 1 : 0) ^ (b & 0x01);
650 crc <<= 1;
651 b >>= 1;
652 if (carry)
653 crc = ((crc ^ POLYNOMIAL) | carry);
654 }
655 }
656 return (crc >> 26);
657 }
658
659 static int rtl8139_RxWrap(RTL8139State *s)
660 {
661 /* wrapping enabled; assume 1.5k more buffer space if size < 65536 */
662 return (s->RxConfig & (1 << 7));
663 }
664
665 static int rtl8139_receiver_enabled(RTL8139State *s)
666 {
667 return s->bChipCmdState & CmdRxEnb;
668 }
669
670 static int rtl8139_transmitter_enabled(RTL8139State *s)
671 {
672 return s->bChipCmdState & CmdTxEnb;
673 }
674
675 static int rtl8139_cp_receiver_enabled(RTL8139State *s)
676 {
677 return s->CpCmd & CPlusRxEnb;
678 }
679
680 static int rtl8139_cp_transmitter_enabled(RTL8139State *s)
681 {
682 return s->CpCmd & CPlusTxEnb;
683 }
684
685 static void rtl8139_write_buffer(RTL8139State *s, const void *buf, int size)
686 {
687 if (s->RxBufAddr + size > s->RxBufferSize)
688 {
689 int wrapped = MOD2(s->RxBufAddr + size, s->RxBufferSize);
690
691 /* write packet data */
692 if (wrapped && s->RxBufferSize < 65536 && !rtl8139_RxWrap(s))
693 {
694 #if defined(DEBUG_RTL8139)
695 printf(">>> RTL8139: rx packet wrapped in buffer at %d\n", size-wrapped);
696 #endif
697
698 if (size > wrapped)
699 {
700 cpu_physical_memory_write( s->RxBuf + s->RxBufAddr,
701 buf, size-wrapped );
702 }
703
704 /* reset buffer pointer */
705 s->RxBufAddr = 0;
706
707 cpu_physical_memory_write( s->RxBuf + s->RxBufAddr,
708 buf + (size-wrapped), wrapped );
709
710 s->RxBufAddr = wrapped;
711
712 return;
713 }
714 }
715
716 /* non-wrapping path or overwrapping enabled */
717 cpu_physical_memory_write( s->RxBuf + s->RxBufAddr, buf, size );
718
719 s->RxBufAddr += size;
720 }
721
722 #define MIN_BUF_SIZE 60
723 static inline target_phys_addr_t rtl8139_addr64(uint32_t low, uint32_t high)
724 {
725 #if TARGET_PHYS_ADDR_BITS > 32
726 return low | ((target_phys_addr_t)high << 32);
727 #else
728 return low;
729 #endif
730 }
731
732 static int rtl8139_can_receive(void *opaque)
733 {
734 RTL8139State *s = opaque;
735 int avail;
736
737 /* Recieve (drop) packets if card is disabled. */
738 if (!s->clock_enabled)
739 return 1;
740 if (!rtl8139_receiver_enabled(s))
741 return 1;
742
743 if (rtl8139_cp_receiver_enabled(s)) {
744 /* ??? Flow control not implemented in c+ mode.
745 This is a hack to work around slirp deficiencies anyway. */
746 return 1;
747 } else {
748 avail = MOD2(s->RxBufferSize + s->RxBufPtr - s->RxBufAddr,
749 s->RxBufferSize);
750 return (avail == 0 || avail >= 1514);
751 }
752 }
753
754 static void rtl8139_receive(void *opaque, const uint8_t *buf, int size)
755 {
756 RTL8139State *s = opaque;
757
758 uint32_t packet_header = 0;
759
760 uint8_t buf1[60];
761 static const uint8_t broadcast_macaddr[6] =
762 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
763
764 #if defined(DEBUG_RTL8139)
765 printf(">>> RTL8139: received len=%d\n", size);
766 #endif
767
768 /* test if board clock is stopped */
769 if (!s->clock_enabled)
770 {
771 #if defined(DEBUG_RTL8139)
772 printf("RTL8139: stopped ==========================\n");
773 #endif
774 return;
775 }
776
777 /* first check if receiver is enabled */
778
779 if (!rtl8139_receiver_enabled(s))
780 {
781 #if defined(DEBUG_RTL8139)
782 printf("RTL8139: receiver disabled ================\n");
783 #endif
784 return;
785 }
786
787 /* XXX: check this */
788 if (s->RxConfig & AcceptAllPhys) {
789 /* promiscuous: receive all */
790 #if defined(DEBUG_RTL8139)
791 printf(">>> RTL8139: packet received in promiscuous mode\n");
792 #endif
793
794 } else {
795 if (!memcmp(buf, broadcast_macaddr, 6)) {
796 /* broadcast address */
797 if (!(s->RxConfig & AcceptBroadcast))
798 {
799 #if defined(DEBUG_RTL8139)
800 printf(">>> RTL8139: broadcast packet rejected\n");
801 #endif
802 return;
803 }
804
805 packet_header |= RxBroadcast;
806
807 #if defined(DEBUG_RTL8139)
808 printf(">>> RTL8139: broadcast packet received\n");
809 #endif
810 } else if (buf[0] & 0x01) {
811 /* multicast */
812 if (!(s->RxConfig & AcceptMulticast))
813 {
814 #if defined(DEBUG_RTL8139)
815 printf(">>> RTL8139: multicast packet rejected\n");
816 #endif
817 return;
818 }
819
820 int mcast_idx = compute_mcast_idx(buf);
821
822 if (!(s->mult[mcast_idx >> 3] & (1 << (mcast_idx & 7))))
823 {
824 #if defined(DEBUG_RTL8139)
825 printf(">>> RTL8139: multicast address mismatch\n");
826 #endif
827 return;
828 }
829
830 packet_header |= RxMulticast;
831
832 #if defined(DEBUG_RTL8139)
833 printf(">>> RTL8139: multicast packet received\n");
834 #endif
835 } else if (s->phys[0] == buf[0] &&
836 s->phys[1] == buf[1] &&
837 s->phys[2] == buf[2] &&
838 s->phys[3] == buf[3] &&
839 s->phys[4] == buf[4] &&
840 s->phys[5] == buf[5]) {
841 /* match */
842 if (!(s->RxConfig & AcceptMyPhys))
843 {
844 #if defined(DEBUG_RTL8139)
845 printf(">>> RTL8139: rejecting physical address matching packet\n");
846 #endif
847 return;
848 }
849
850 packet_header |= RxPhysical;
851
852 #if defined(DEBUG_RTL8139)
853 printf(">>> RTL8139: physical address matching packet received\n");
854 #endif
855
856 } else {
857
858 #if defined(DEBUG_RTL8139)
859 printf(">>> RTL8139: unknown packet\n");
860 #endif
861 return;
862 }
863 }
864
865 /* if too small buffer, then expand it */
866 if (size < MIN_BUF_SIZE) {
867 memcpy(buf1, buf, size);
868 memset(buf1 + size, 0, MIN_BUF_SIZE - size);
869 buf = buf1;
870 size = MIN_BUF_SIZE;
871 }
872
873 if (rtl8139_cp_receiver_enabled(s))
874 {
875 #if defined(DEBUG_RTL8139)
876 printf("RTL8139: in C+ Rx mode ================\n");
877 #endif
878
879 /* begin C+ receiver mode */
880
881 /* w0 ownership flag */
882 #define CP_RX_OWN (1<<31)
883 /* w0 end of ring flag */
884 #define CP_RX_EOR (1<<30)
885 /* w0 bits 0...12 : buffer size */
886 #define CP_RX_BUFFER_SIZE_MASK ((1<<13) - 1)
887 /* w1 tag available flag */
888 #define CP_RX_TAVA (1<<16)
889 /* w1 bits 0...15 : VLAN tag */
890 #define CP_RX_VLAN_TAG_MASK ((1<<16) - 1)
891 /* w2 low 32bit of Rx buffer ptr */
892 /* w3 high 32bit of Rx buffer ptr */
893
894 int descriptor = s->currCPlusRxDesc;
895 target_phys_addr_t cplus_rx_ring_desc;
896
897 cplus_rx_ring_desc = rtl8139_addr64(s->RxRingAddrLO, s->RxRingAddrHI);
898 cplus_rx_ring_desc += 16 * descriptor;
899
900 #ifdef DEBUG_RTL8139
901 printf("RTL8139: +++ C+ mode reading RX descriptor %d from host memory at %08x %08x = 0x%8lx\n",
902 descriptor, s->RxRingAddrHI, s->RxRingAddrLO, cplus_rx_ring_desc);
903 #endif
904
905 uint32_t val, rxdw0,rxdw1,rxbufLO,rxbufHI;
906
907 cpu_physical_memory_read(cplus_rx_ring_desc, (uint8_t *)&val, 4);
908 rxdw0 = le32_to_cpu(val);
909 cpu_physical_memory_read(cplus_rx_ring_desc+4, (uint8_t *)&val, 4);
910 rxdw1 = le32_to_cpu(val);
911 cpu_physical_memory_read(cplus_rx_ring_desc+8, (uint8_t *)&val, 4);
912 rxbufLO = le32_to_cpu(val);
913 cpu_physical_memory_read(cplus_rx_ring_desc+12, (uint8_t *)&val, 4);
914 rxbufHI = le32_to_cpu(val);
915
916 #ifdef DEBUG_RTL8139
917 printf("RTL8139: +++ C+ mode RX descriptor %d %08x %08x %08x %08x\n",
918 descriptor,
919 rxdw0, rxdw1, rxbufLO, rxbufHI);
920 #endif
921
922 if (!(rxdw0 & CP_RX_OWN))
923 {
924 #if defined(DEBUG_RTL8139)
925 printf("RTL8139: C+ Rx mode : descriptor %d is owned by host\n", descriptor);
926 #endif
927 s->IntrStatus |= RxOverflow;
928 ++s->RxMissed;
929 rtl8139_update_irq(s);
930 return;
931 }
932
933 uint32_t rx_space = rxdw0 & CP_RX_BUFFER_SIZE_MASK;
934
935 if (size+4 > rx_space)
936 {
937 #if defined(DEBUG_RTL8139)
938 printf("RTL8139: C+ Rx mode : descriptor %d size %d received %d + 4\n",
939 descriptor, rx_space, size);
940 #endif
941 s->IntrStatus |= RxOverflow;
942 ++s->RxMissed;
943 rtl8139_update_irq(s);
944 return;
945 }
946
947 target_phys_addr_t rx_addr = rtl8139_addr64(rxbufLO, rxbufHI);
948
949 /* receive/copy to target memory */
950 cpu_physical_memory_write( rx_addr, buf, size );
951
952 /* write checksum */
953 #if defined (RTL8139_CALCULATE_RXCRC)
954 val = cpu_to_le32(crc32(~0, buf, size));
955 #else
956 val = 0;
957 #endif
958 cpu_physical_memory_write( rx_addr+size, (uint8_t *)&val, 4);
959
960 /* first segment of received packet flag */
961 #define CP_RX_STATUS_FS (1<<29)
962 /* last segment of received packet flag */
963 #define CP_RX_STATUS_LS (1<<28)
964 /* multicast packet flag */
965 #define CP_RX_STATUS_MAR (1<<26)
966 /* physical-matching packet flag */
967 #define CP_RX_STATUS_PAM (1<<25)
968 /* broadcast packet flag */
969 #define CP_RX_STATUS_BAR (1<<24)
970 /* runt packet flag */
971 #define CP_RX_STATUS_RUNT (1<<19)
972 /* crc error flag */
973 #define CP_RX_STATUS_CRC (1<<18)
974 /* IP checksum error flag */
975 #define CP_RX_STATUS_IPF (1<<15)
976 /* UDP checksum error flag */
977 #define CP_RX_STATUS_UDPF (1<<14)
978 /* TCP checksum error flag */
979 #define CP_RX_STATUS_TCPF (1<<13)
980
981 /* transfer ownership to target */
982 rxdw0 &= ~CP_RX_OWN;
983
984 /* set first segment bit */
985 rxdw0 |= CP_RX_STATUS_FS;
986
987 /* set last segment bit */
988 rxdw0 |= CP_RX_STATUS_LS;
989
990 /* set received packet type flags */
991 if (packet_header & RxBroadcast)
992 rxdw0 |= CP_RX_STATUS_BAR;
993 if (packet_header & RxMulticast)
994 rxdw0 |= CP_RX_STATUS_MAR;
995 if (packet_header & RxPhysical)
996 rxdw0 |= CP_RX_STATUS_PAM;
997
998 /* set received size */
999 rxdw0 &= ~CP_RX_BUFFER_SIZE_MASK;
1000 rxdw0 |= (size+4);
1001
1002 /* reset VLAN tag flag */
1003 rxdw1 &= ~CP_RX_TAVA;
1004
1005 /* update ring data */
1006 val = cpu_to_le32(rxdw0);
1007 cpu_physical_memory_write(cplus_rx_ring_desc, (uint8_t *)&val, 4);
1008 val = cpu_to_le32(rxdw1);
1009 cpu_physical_memory_write(cplus_rx_ring_desc+4, (uint8_t *)&val, 4);
1010
1011 /* seek to next Rx descriptor */
1012 if (rxdw0 & CP_RX_EOR)
1013 {
1014 s->currCPlusRxDesc = 0;
1015 }
1016 else
1017 {
1018 ++s->currCPlusRxDesc;
1019 }
1020
1021 #if defined(DEBUG_RTL8139)
1022 printf("RTL8139: done C+ Rx mode ----------------\n");
1023 #endif
1024
1025 }
1026 else
1027 {
1028 #if defined(DEBUG_RTL8139)
1029 printf("RTL8139: in ring Rx mode ================\n");
1030 #endif
1031 /* begin ring receiver mode */
1032 int avail = MOD2(s->RxBufferSize + s->RxBufPtr - s->RxBufAddr, s->RxBufferSize);
1033
1034 /* if receiver buffer is empty then avail == 0 */
1035
1036 if (avail != 0 && size + 8 >= avail)
1037 {
1038 #if defined(DEBUG_RTL8139)
1039 printf("rx overflow: rx buffer length %d head 0x%04x read 0x%04x === available 0x%04x need 0x%04x\n",
1040 s->RxBufferSize, s->RxBufAddr, s->RxBufPtr, avail, size + 8);
1041 #endif
1042 s->IntrStatus |= RxOverflow;
1043 ++s->RxMissed;
1044 rtl8139_update_irq(s);
1045 return;
1046 }
1047
1048 packet_header |= RxStatusOK;
1049
1050 packet_header |= (((size+4) << 16) & 0xffff0000);
1051
1052 /* write header */
1053 uint32_t val = cpu_to_le32(packet_header);
1054
1055 rtl8139_write_buffer(s, (uint8_t *)&val, 4);
1056
1057 rtl8139_write_buffer(s, buf, size);
1058
1059 /* write checksum */
1060 #if defined (RTL8139_CALCULATE_RXCRC)
1061 val = cpu_to_le32(crc32(~0, buf, size));
1062 #else
1063 val = 0;
1064 #endif
1065
1066 rtl8139_write_buffer(s, (uint8_t *)&val, 4);
1067
1068 /* correct buffer write pointer */
1069 s->RxBufAddr = MOD2((s->RxBufAddr + 3) & ~0x3, s->RxBufferSize);
1070
1071 /* now we can signal we have received something */
1072
1073 #if defined(DEBUG_RTL8139)
1074 printf(" received: rx buffer length %d head 0x%04x read 0x%04x\n",
1075 s->RxBufferSize, s->RxBufAddr, s->RxBufPtr);
1076 #endif
1077
1078 }
1079
1080 s->IntrStatus |= RxOK;
1081 rtl8139_update_irq(s);
1082 }
1083
1084 static void rtl8139_reset_rxring(RTL8139State *s, uint32_t bufferSize)
1085 {
1086 s->RxBufferSize = bufferSize;
1087 s->RxBufPtr = 0;
1088 s->RxBufAddr = 0;
1089 }
1090
1091 static void rtl8139_reset(RTL8139State *s)
1092 {
1093 int i;
1094
1095 /* restore MAC address */
1096 memcpy(s->phys, s->macaddr, 6);
1097
1098 /* reset interrupt mask */
1099 s->IntrStatus = 0;
1100 s->IntrMask = 0;
1101
1102 rtl8139_update_irq(s);
1103
1104 /* prepare eeprom */
1105 s->eeprom.contents[0] = 0x8129;
1106 memcpy(&s->eeprom.contents[7], s->macaddr, 6);
1107
1108 /* mark all status registers as owned by host */
1109 for (i = 0; i < 4; ++i)
1110 {
1111 s->TxStatus[i] = TxHostOwns;
1112 }
1113
1114 s->currTxDesc = 0;
1115 s->currCPlusRxDesc = 0;
1116 s->currCPlusTxDesc = 0;
1117
1118 s->RxRingAddrLO = 0;
1119 s->RxRingAddrHI = 0;
1120
1121 s->RxBuf = 0;
1122
1123 rtl8139_reset_rxring(s, 8192);
1124
1125 /* ACK the reset */
1126 s->TxConfig = 0;
1127
1128 #if 0
1129 // s->TxConfig |= HW_REVID(1, 0, 0, 0, 0, 0, 0); // RTL-8139 HasHltClk
1130 s->clock_enabled = 0;
1131 #else
1132 s->TxConfig |= HW_REVID(1, 1, 1, 0, 1, 0, 0); // RTL-8139C HasLWake
1133 s->clock_enabled = 1;
1134 #endif
1135
1136 s->bChipCmdState = CmdReset; /* RxBufEmpty bit is calculated on read from ChipCmd */;
1137
1138 /* set initial state data */
1139 s->Config0 = 0x0; /* No boot ROM */
1140 s->Config1 = 0xC; /* IO mapped and MEM mapped registers available */
1141 s->Config3 = 0x1; /* fast back-to-back compatible */
1142 s->Config5 = 0x0;
1143
1144 s->CSCR = CSCR_F_LINK_100 | CSCR_HEART_BIT | CSCR_LD;
1145
1146 s->CpCmd = 0x0; /* reset C+ mode */
1147
1148 // s->BasicModeCtrl = 0x3100; // 100Mbps, full duplex, autonegotiation
1149 // s->BasicModeCtrl = 0x2100; // 100Mbps, full duplex
1150 s->BasicModeCtrl = 0x1000; // autonegotiation
1151
1152 s->BasicModeStatus = 0x7809;
1153 //s->BasicModeStatus |= 0x0040; /* UTP medium */
1154 s->BasicModeStatus |= 0x0020; /* autonegotiation completed */
1155 s->BasicModeStatus |= 0x0004; /* link is up */
1156
1157 s->NWayAdvert = 0x05e1; /* all modes, full duplex */
1158 s->NWayLPAR = 0x05e1; /* all modes, full duplex */
1159 s->NWayExpansion = 0x0001; /* autonegotiation supported */
1160 }
1161
1162 static void rtl8139_ChipCmd_write(RTL8139State *s, uint32_t val)
1163 {
1164 val &= 0xff;
1165
1166 #ifdef DEBUG_RTL8139
1167 printf("RTL8139: ChipCmd write val=0x%08x\n", val);
1168 #endif
1169
1170 if (val & CmdReset)
1171 {
1172 #ifdef DEBUG_RTL8139
1173 printf("RTL8139: ChipCmd reset\n");
1174 #endif
1175 rtl8139_reset(s);
1176 }
1177 if (val & CmdRxEnb)
1178 {
1179 #ifdef DEBUG_RTL8139
1180 printf("RTL8139: ChipCmd enable receiver\n");
1181 #endif
1182 }
1183 if (val & CmdTxEnb)
1184 {
1185 #ifdef DEBUG_RTL8139
1186 printf("RTL8139: ChipCmd enable transmitter\n");
1187 #endif
1188 }
1189
1190 /* mask unwriteable bits */
1191 val = SET_MASKED(val, 0xe3, s->bChipCmdState);
1192
1193 /* Deassert reset pin before next read */
1194 val &= ~CmdReset;
1195
1196 s->bChipCmdState = val;
1197 }
1198
1199 static int rtl8139_RxBufferEmpty(RTL8139State *s)
1200 {
1201 int unread = MOD2(s->RxBufferSize + s->RxBufAddr - s->RxBufPtr, s->RxBufferSize);
1202
1203 if (unread != 0)
1204 {
1205 #ifdef DEBUG_RTL8139
1206 printf("RTL8139: receiver buffer data available 0x%04x\n", unread);
1207 #endif
1208 return 0;
1209 }
1210
1211 #ifdef DEBUG_RTL8139
1212 printf("RTL8139: receiver buffer is empty\n");
1213 #endif
1214
1215 return 1;
1216 }
1217
1218 static uint32_t rtl8139_ChipCmd_read(RTL8139State *s)
1219 {
1220 uint32_t ret = s->bChipCmdState;
1221
1222 if (rtl8139_RxBufferEmpty(s))
1223 ret |= RxBufEmpty;
1224
1225 #ifdef DEBUG_RTL8139
1226 printf("RTL8139: ChipCmd read val=0x%04x\n", ret);
1227 #endif
1228
1229 return ret;
1230 }
1231
1232 static void rtl8139_CpCmd_write(RTL8139State *s, uint32_t val)
1233 {
1234 val &= 0xffff;
1235
1236 #ifdef DEBUG_RTL8139
1237 printf("RTL8139C+ command register write(w) val=0x%04x\n", val);
1238 #endif
1239
1240 /* mask unwriteable bits */
1241 val = SET_MASKED(val, 0xff84, s->CpCmd);
1242
1243 s->CpCmd = val;
1244 }
1245
1246 static uint32_t rtl8139_CpCmd_read(RTL8139State *s)
1247 {
1248 uint32_t ret = s->CpCmd;
1249
1250 #ifdef DEBUG_RTL8139
1251 printf("RTL8139C+ command register read(w) val=0x%04x\n", ret);
1252 #endif
1253
1254 return ret;
1255 }
1256
1257 int rtl8139_config_writeable(RTL8139State *s)
1258 {
1259 if (s->Cfg9346 & Cfg9346_Unlock)
1260 {
1261 return 1;
1262 }
1263
1264 #ifdef DEBUG_RTL8139
1265 printf("RTL8139: Configuration registers are write-protected\n");
1266 #endif
1267
1268 return 0;
1269 }
1270
1271 static void rtl8139_BasicModeCtrl_write(RTL8139State *s, uint32_t val)
1272 {
1273 val &= 0xffff;
1274
1275 #ifdef DEBUG_RTL8139
1276 printf("RTL8139: BasicModeCtrl register write(w) val=0x%04x\n", val);
1277 #endif
1278
1279 /* mask unwriteable bits */
1280 uint32 mask = 0x4cff;
1281
1282 if (1 || !rtl8139_config_writeable(s))
1283 {
1284 /* Speed setting and autonegotiation enable bits are read-only */
1285 mask |= 0x3000;
1286 /* Duplex mode setting is read-only */
1287 mask |= 0x0100;
1288 }
1289
1290 val = SET_MASKED(val, mask, s->BasicModeCtrl);
1291
1292 s->BasicModeCtrl = val;
1293 }
1294
1295 static uint32_t rtl8139_BasicModeCtrl_read(RTL8139State *s)
1296 {
1297 uint32_t ret = s->BasicModeCtrl;
1298
1299 #ifdef DEBUG_RTL8139
1300 printf("RTL8139: BasicModeCtrl register read(w) val=0x%04x\n", ret);
1301 #endif
1302
1303 return ret;
1304 }
1305
1306 static void rtl8139_BasicModeStatus_write(RTL8139State *s, uint32_t val)
1307 {
1308 val &= 0xffff;
1309
1310 #ifdef DEBUG_RTL8139
1311 printf("RTL8139: BasicModeStatus register write(w) val=0x%04x\n", val);
1312 #endif
1313
1314 /* mask unwriteable bits */
1315 val = SET_MASKED(val, 0xff3f, s->BasicModeStatus);
1316
1317 s->BasicModeStatus = val;
1318 }
1319
1320 static uint32_t rtl8139_BasicModeStatus_read(RTL8139State *s)
1321 {
1322 uint32_t ret = s->BasicModeStatus;
1323
1324 #ifdef DEBUG_RTL8139
1325 printf("RTL8139: BasicModeStatus register read(w) val=0x%04x\n", ret);
1326 #endif
1327
1328 return ret;
1329 }
1330
1331 static void rtl8139_Cfg9346_write(RTL8139State *s, uint32_t val)
1332 {
1333 val &= 0xff;
1334
1335 #ifdef DEBUG_RTL8139
1336 printf("RTL8139: Cfg9346 write val=0x%02x\n", val);
1337 #endif
1338
1339 /* mask unwriteable bits */
1340 val = SET_MASKED(val, 0x31, s->Cfg9346);
1341
1342 uint32_t opmode = val & 0xc0;
1343 uint32_t eeprom_val = val & 0xf;
1344
1345 if (opmode == 0x80) {
1346 /* eeprom access */
1347 int eecs = (eeprom_val & 0x08)?1:0;
1348 int eesk = (eeprom_val & 0x04)?1:0;
1349 int eedi = (eeprom_val & 0x02)?1:0;
1350 prom9346_set_wire(s, eecs, eesk, eedi);
1351 } else if (opmode == 0x40) {
1352 /* Reset. */
1353 val = 0;
1354 rtl8139_reset(s);
1355 }
1356
1357 s->Cfg9346 = val;
1358 }
1359
1360 static uint32_t rtl8139_Cfg9346_read(RTL8139State *s)
1361 {
1362 uint32_t ret = s->Cfg9346;
1363
1364 uint32_t opmode = ret & 0xc0;
1365
1366 if (opmode == 0x80)
1367 {
1368 /* eeprom access */
1369 int eedo = prom9346_get_wire(s);
1370 if (eedo)
1371 {
1372 ret |= 0x01;
1373 }
1374 else
1375 {
1376 ret &= ~0x01;
1377 }
1378 }
1379
1380 #ifdef DEBUG_RTL8139
1381 printf("RTL8139: Cfg9346 read val=0x%02x\n", ret);
1382 #endif
1383
1384 return ret;
1385 }
1386
1387 static void rtl8139_Config0_write(RTL8139State *s, uint32_t val)
1388 {
1389 val &= 0xff;
1390
1391 #ifdef DEBUG_RTL8139
1392 printf("RTL8139: Config0 write val=0x%02x\n", val);
1393 #endif
1394
1395 if (!rtl8139_config_writeable(s))
1396 return;
1397
1398 /* mask unwriteable bits */
1399 val = SET_MASKED(val, 0xf8, s->Config0);
1400
1401 s->Config0 = val;
1402 }
1403
1404 static uint32_t rtl8139_Config0_read(RTL8139State *s)
1405 {
1406 uint32_t ret = s->Config0;
1407
1408 #ifdef DEBUG_RTL8139
1409 printf("RTL8139: Config0 read val=0x%02x\n", ret);
1410 #endif
1411
1412 return ret;
1413 }
1414
1415 static void rtl8139_Config1_write(RTL8139State *s, uint32_t val)
1416 {
1417 val &= 0xff;
1418
1419 #ifdef DEBUG_RTL8139
1420 printf("RTL8139: Config1 write val=0x%02x\n", val);
1421 #endif
1422
1423 if (!rtl8139_config_writeable(s))
1424 return;
1425
1426 /* mask unwriteable bits */
1427 val = SET_MASKED(val, 0xC, s->Config1);
1428
1429 s->Config1 = val;
1430 }
1431
1432 static uint32_t rtl8139_Config1_read(RTL8139State *s)
1433 {
1434 uint32_t ret = s->Config1;
1435
1436 #ifdef DEBUG_RTL8139
1437 printf("RTL8139: Config1 read val=0x%02x\n", ret);
1438 #endif
1439
1440 return ret;
1441 }
1442
1443 static void rtl8139_Config3_write(RTL8139State *s, uint32_t val)
1444 {
1445 val &= 0xff;
1446
1447 #ifdef DEBUG_RTL8139
1448 printf("RTL8139: Config3 write val=0x%02x\n", val);
1449 #endif
1450
1451 if (!rtl8139_config_writeable(s))
1452 return;
1453
1454 /* mask unwriteable bits */
1455 val = SET_MASKED(val, 0x8F, s->Config3);
1456
1457 s->Config3 = val;
1458 }
1459
1460 static uint32_t rtl8139_Config3_read(RTL8139State *s)
1461 {
1462 uint32_t ret = s->Config3;
1463
1464 #ifdef DEBUG_RTL8139
1465 printf("RTL8139: Config3 read val=0x%02x\n", ret);
1466 #endif
1467
1468 return ret;
1469 }
1470
1471 static void rtl8139_Config4_write(RTL8139State *s, uint32_t val)
1472 {
1473 val &= 0xff;
1474
1475 #ifdef DEBUG_RTL8139
1476 printf("RTL8139: Config4 write val=0x%02x\n", val);
1477 #endif
1478
1479 if (!rtl8139_config_writeable(s))
1480 return;
1481
1482 /* mask unwriteable bits */
1483 val = SET_MASKED(val, 0x0a, s->Config4);
1484
1485 s->Config4 = val;
1486 }
1487
1488 static uint32_t rtl8139_Config4_read(RTL8139State *s)
1489 {
1490 uint32_t ret = s->Config4;
1491
1492 #ifdef DEBUG_RTL8139
1493 printf("RTL8139: Config4 read val=0x%02x\n", ret);
1494 #endif
1495
1496 return ret;
1497 }
1498
1499 static void rtl8139_Config5_write(RTL8139State *s, uint32_t val)
1500 {
1501 val &= 0xff;
1502
1503 #ifdef DEBUG_RTL8139
1504 printf("RTL8139: Config5 write val=0x%02x\n", val);
1505 #endif
1506
1507 /* mask unwriteable bits */
1508 val = SET_MASKED(val, 0x80, s->Config5);
1509
1510 s->Config5 = val;
1511 }
1512
1513 static uint32_t rtl8139_Config5_read(RTL8139State *s)
1514 {
1515 uint32_t ret = s->Config5;
1516
1517 #ifdef DEBUG_RTL8139
1518 printf("RTL8139: Config5 read val=0x%02x\n", ret);
1519 #endif
1520
1521 return ret;
1522 }
1523
1524 static void rtl8139_TxConfig_write(RTL8139State *s, uint32_t val)
1525 {
1526 if (!rtl8139_transmitter_enabled(s))
1527 {
1528 #ifdef DEBUG_RTL8139
1529 printf("RTL8139: transmitter disabled; no TxConfig write val=0x%08x\n", val);
1530 #endif
1531 return;
1532 }
1533
1534 #ifdef DEBUG_RTL8139
1535 printf("RTL8139: TxConfig write val=0x%08x\n", val);
1536 #endif
1537
1538 val = SET_MASKED(val, TxVersionMask | 0x8070f80f, s->TxConfig);
1539
1540 s->TxConfig = val;
1541 }
1542
1543 static void rtl8139_TxConfig_writeb(RTL8139State *s, uint32_t val)
1544 {
1545 #ifdef DEBUG_RTL8139
1546 printf("RTL8139C TxConfig via write(b) val=0x%02x\n", val);
1547 #endif
1548 uint32_t tc = s->TxConfig;
1549 tc &= 0xFFFFFF00;
1550 tc |= (val & 0x000000FF);
1551 rtl8139_TxConfig_write(s, tc);
1552 }
1553
1554 static uint32_t rtl8139_TxConfig_read(RTL8139State *s)
1555 {
1556 uint32_t ret = s->TxConfig;
1557
1558 #ifdef DEBUG_RTL8139
1559 printf("RTL8139: TxConfig read val=0x%04x\n", ret);
1560 #endif
1561
1562 return ret;
1563 }
1564
1565 static void rtl8139_RxConfig_write(RTL8139State *s, uint32_t val)
1566 {
1567 #ifdef DEBUG_RTL8139
1568 printf("RTL8139: RxConfig write val=0x%08x\n", val);
1569 #endif
1570
1571 /* mask unwriteable bits */
1572 val = SET_MASKED(val, 0xf0fc0040, s->RxConfig);
1573
1574 s->RxConfig = val;
1575
1576 /* reset buffer size and read/write pointers */
1577 rtl8139_reset_rxring(s, 8192 << ((s->RxConfig >> 11) & 0x3));
1578
1579 #ifdef DEBUG_RTL8139
1580 printf("RTL8139: RxConfig write reset buffer size to %d\n", s->RxBufferSize);
1581 #endif
1582 }
1583
1584 static uint32_t rtl8139_RxConfig_read(RTL8139State *s)
1585 {
1586 uint32_t ret = s->RxConfig;
1587
1588 #ifdef DEBUG_RTL8139
1589 printf("RTL8139: RxConfig read val=0x%08x\n", ret);
1590 #endif
1591
1592 return ret;
1593 }
1594
1595 static int rtl8139_transmit_one(RTL8139State *s, int descriptor)
1596 {
1597 if (!rtl8139_transmitter_enabled(s))
1598 {
1599 #ifdef DEBUG_RTL8139
1600 printf("RTL8139: +++ cannot transmit from descriptor %d: transmitter disabled\n", descriptor);
1601 #endif
1602 return 0;
1603 }
1604
1605 if (s->TxStatus[descriptor] & TxHostOwns)
1606 {
1607 #ifdef DEBUG_RTL8139
1608 printf("RTL8139: +++ cannot transmit from descriptor %d: owned by host (%08x)\n", descriptor, s->TxStatus[descriptor]);
1609 #endif
1610 return 0;
1611 }
1612
1613 #ifdef DEBUG_RTL8139
1614 printf("RTL8139: +++ transmitting from descriptor %d\n", descriptor);
1615 #endif
1616
1617 int txsize = s->TxStatus[descriptor] & 0x1fff;
1618 uint8_t txbuffer[0x2000];
1619
1620 #ifdef DEBUG_RTL8139
1621 printf("RTL8139: +++ transmit reading %d bytes from host memory at 0x%08x\n", txsize, s->TxAddr[descriptor]);
1622 #endif
1623 cpu_physical_memory_read(s->TxAddr[descriptor], txbuffer, txsize);
1624
1625 qemu_send_packet(s->vc, txbuffer, txsize);
1626
1627 /* Mark descriptor as transferred */
1628 s->TxStatus[descriptor] |= TxHostOwns;
1629 s->TxStatus[descriptor] |= TxStatOK;
1630
1631 #ifdef DEBUG_RTL8139
1632 printf("RTL8139: +++ transmitted %d bytes from descriptor %d\n", txsize, descriptor);
1633 #endif
1634
1635 /* update interrupt */
1636 s->IntrStatus |= TxOK;
1637 rtl8139_update_irq(s);
1638
1639 return 1;
1640 }
1641
1642 static int rtl8139_cplus_transmit_one(RTL8139State *s)
1643 {
1644 if (!rtl8139_transmitter_enabled(s))
1645 {
1646 #ifdef DEBUG_RTL8139
1647 printf("RTL8139: +++ C+ mode: transmitter disabled\n");
1648 #endif
1649 return 0;
1650 }
1651
1652 if (!rtl8139_cp_transmitter_enabled(s))
1653 {
1654 #ifdef DEBUG_RTL8139
1655 printf("RTL8139: +++ C+ mode: C+ transmitter disabled\n");
1656 #endif
1657 return 0 ;
1658 }
1659
1660 int descriptor = s->currCPlusTxDesc;
1661
1662 target_phys_addr_t cplus_tx_ring_desc =
1663 rtl8139_addr64(s->TxAddr[0], s->TxAddr[1]);
1664
1665 /* Normal priority ring */
1666 cplus_tx_ring_desc += 16 * descriptor;
1667
1668 #ifdef DEBUG_RTL8139
1669 printf("RTL8139: +++ C+ mode reading TX descriptor %d from host memory at %08x0x%08x = 0x%8lx\n",
1670 descriptor, s->TxAddr[1], s->TxAddr[0], cplus_tx_ring_desc);
1671 #endif
1672
1673 uint32_t val, txdw0,txdw1,txbufLO,txbufHI;
1674
1675 cpu_physical_memory_read(cplus_tx_ring_desc, (uint8_t *)&val, 4);
1676 txdw0 = le32_to_cpu(val);
1677 cpu_physical_memory_read(cplus_tx_ring_desc+4, (uint8_t *)&val, 4);
1678 txdw1 = le32_to_cpu(val);
1679 cpu_physical_memory_read(cplus_tx_ring_desc+8, (uint8_t *)&val, 4);
1680 txbufLO = le32_to_cpu(val);
1681 cpu_physical_memory_read(cplus_tx_ring_desc+12, (uint8_t *)&val, 4);
1682 txbufHI = le32_to_cpu(val);
1683
1684 #ifdef DEBUG_RTL8139
1685 printf("RTL8139: +++ C+ mode TX descriptor %d %08x %08x %08x %08x\n",
1686 descriptor,
1687 txdw0, txdw1, txbufLO, txbufHI);
1688 #endif
1689
1690 /* w0 ownership flag */
1691 #define CP_TX_OWN (1<<31)
1692 /* w0 end of ring flag */
1693 #define CP_TX_EOR (1<<30)
1694 /* first segment of received packet flag */
1695 #define CP_TX_FS (1<<29)
1696 /* last segment of received packet flag */
1697 #define CP_TX_LS (1<<28)
1698 /* large send packet flag */
1699 #define CP_TX_LGSEN (1<<27)
1700 /* IP checksum offload flag */
1701 #define CP_TX_IPCS (1<<18)
1702 /* UDP checksum offload flag */
1703 #define CP_TX_UDPCS (1<<17)
1704 /* TCP checksum offload flag */
1705 #define CP_TX_TCPCS (1<<16)
1706
1707 /* w0 bits 0...15 : buffer size */
1708 #define CP_TX_BUFFER_SIZE (1<<16)
1709 #define CP_TX_BUFFER_SIZE_MASK (CP_TX_BUFFER_SIZE - 1)
1710 /* w1 tag available flag */
1711 #define CP_RX_TAGC (1<<17)
1712 /* w1 bits 0...15 : VLAN tag */
1713 #define CP_TX_VLAN_TAG_MASK ((1<<16) - 1)
1714 /* w2 low 32bit of Rx buffer ptr */
1715 /* w3 high 32bit of Rx buffer ptr */
1716
1717 /* set after transmission */
1718 /* FIFO underrun flag */
1719 #define CP_TX_STATUS_UNF (1<<25)
1720 /* transmit error summary flag, valid if set any of three below */
1721 #define CP_TX_STATUS_TES (1<<23)
1722 /* out-of-window collision flag */
1723 #define CP_TX_STATUS_OWC (1<<22)
1724 /* link failure flag */
1725 #define CP_TX_STATUS_LNKF (1<<21)
1726 /* excessive collisions flag */
1727 #define CP_TX_STATUS_EXC (1<<20)
1728
1729 if (!(txdw0 & CP_TX_OWN))
1730 {
1731 #if defined(DEBUG_RTL8139)
1732 printf("RTL8139: C+ Tx mode : descriptor %d is owned by host\n", descriptor);
1733 #endif
1734 return 0 ;
1735 }
1736
1737 #ifdef DEBUG_RTL8139
1738 printf("RTL8139: +++ C+ Tx mode : transmitting from descriptor %d\n", descriptor);
1739 #endif
1740
1741 int txsize = txdw0 & CP_TX_BUFFER_SIZE_MASK;
1742 target_phys_addr_t tx_addr = rtl8139_addr64(txbufLO, txbufHI);
1743
1744 uint8_t txbuffer[CP_TX_BUFFER_SIZE];
1745
1746 #ifdef DEBUG_RTL8139
1747 printf("RTL8139: +++ C+ mode transmit reading %d bytes from host memory at 0x%08x\n", txsize, tx_addr);
1748 #endif
1749 cpu_physical_memory_read(tx_addr, txbuffer, txsize);
1750
1751 /* transmit the packet */
1752 qemu_send_packet(s->vc, txbuffer, txsize);
1753
1754 /* transfer ownership to target */
1755 txdw0 &= ~CP_RX_OWN;
1756
1757 /* reset error indicator bits */
1758 txdw0 &= ~CP_TX_STATUS_UNF;
1759 txdw0 &= ~CP_TX_STATUS_TES;
1760 txdw0 &= ~CP_TX_STATUS_OWC;
1761 txdw0 &= ~CP_TX_STATUS_LNKF;
1762 txdw0 &= ~CP_TX_STATUS_EXC;
1763
1764 /* update ring data */
1765 val = cpu_to_le32(txdw0);
1766 cpu_physical_memory_write(cplus_tx_ring_desc, (uint8_t *)&val, 4);
1767 // val = cpu_to_le32(txdw1);
1768 // cpu_physical_memory_write(cplus_tx_ring_desc+4, &val, 4);
1769
1770 /* seek to next Rx descriptor */
1771 if (txdw0 & CP_TX_EOR)
1772 {
1773 s->currCPlusTxDesc = 0;
1774 }
1775 else
1776 {
1777 ++s->currCPlusTxDesc;
1778 }
1779
1780 #ifdef DEBUG_RTL8139
1781 printf("RTL8139: +++ C+ mode transmitted %d bytes from descriptor %d\n", txsize, descriptor);
1782 #endif
1783 return 1;
1784 }
1785
1786 static void rtl8139_cplus_transmit(RTL8139State *s)
1787 {
1788 int txcount = 0;
1789
1790 while (rtl8139_cplus_transmit_one(s))
1791 {
1792 ++txcount;
1793 }
1794
1795 /* Mark transfer completed */
1796 if (!txcount)
1797 {
1798 #ifdef DEBUG_RTL8139
1799 printf("RTL8139: C+ mode : transmitter queue stalled, current TxDesc = %d\n", s->currCPlusTxDesc);
1800 #endif
1801 }
1802 else
1803 {
1804 /* update interrupt status */
1805 s->IntrStatus |= TxOK;
1806 rtl8139_update_irq(s);
1807 }
1808 }
1809
1810 static void rtl8139_transmit(RTL8139State *s)
1811 {
1812 int descriptor = s->currTxDesc, txcount = 0;
1813
1814 /*while*/
1815 if (rtl8139_transmit_one(s, descriptor))
1816 {
1817 ++s->currTxDesc;
1818 s->currTxDesc %= 4;
1819 ++txcount;
1820 }
1821
1822 /* Mark transfer completed */
1823 if (!txcount)
1824 {
1825 #ifdef DEBUG_RTL8139
1826 printf("RTL8139: transmitter queue stalled, current TxDesc = %d\n", s->currTxDesc);
1827 #endif
1828 }
1829 }
1830
1831 static void rtl8139_TxStatus_write(RTL8139State *s, uint32_t txRegOffset, uint32_t val)
1832 {
1833
1834 int descriptor = txRegOffset/4;
1835 #ifdef DEBUG_RTL8139
1836 printf("RTL8139: TxStatus write offset=0x%x val=0x%08x descriptor=%d\n", txRegOffset, val, descriptor);
1837 #endif
1838
1839 /* mask only reserved bits */
1840 val &= ~0xff00c000; /* these bits are reset on write */
1841 val = SET_MASKED(val, 0x00c00000, s->TxStatus[descriptor]);
1842
1843 s->TxStatus[descriptor] = val;
1844
1845 /* attempt to start transmission */
1846 rtl8139_transmit(s);
1847 }
1848
1849 static uint32_t rtl8139_TxStatus_read(RTL8139State *s, uint32_t txRegOffset)
1850 {
1851 uint32_t ret = s->TxStatus[txRegOffset/4];
1852
1853 #ifdef DEBUG_RTL8139
1854 printf("RTL8139: TxStatus read offset=0x%x val=0x%08x\n", txRegOffset, ret);
1855 #endif
1856
1857 return ret;
1858 }
1859
1860 static uint16_t rtl8139_TSAD_read(RTL8139State *s)
1861 {
1862 uint16_t ret = 0;
1863
1864 /* Simulate TSAD, it is read only anyway */
1865
1866 ret = ((s->TxStatus[3] & TxStatOK )?TSAD_TOK3:0)
1867 |((s->TxStatus[2] & TxStatOK )?TSAD_TOK2:0)
1868 |((s->TxStatus[1] & TxStatOK )?TSAD_TOK1:0)
1869 |((s->TxStatus[0] & TxStatOK )?TSAD_TOK0:0)
1870
1871 |((s->TxStatus[3] & TxUnderrun)?TSAD_TUN3:0)
1872 |((s->TxStatus[2] & TxUnderrun)?TSAD_TUN2:0)
1873 |((s->TxStatus[1] & TxUnderrun)?TSAD_TUN1:0)
1874 |((s->TxStatus[0] & TxUnderrun)?TSAD_TUN0:0)
1875
1876 |((s->TxStatus[3] & TxAborted )?TSAD_TABT3:0)
1877 |((s->TxStatus[2] & TxAborted )?TSAD_TABT2:0)
1878 |((s->TxStatus[1] & TxAborted )?TSAD_TABT1:0)
1879 |((s->TxStatus[0] & TxAborted )?TSAD_TABT0:0)
1880
1881 |((s->TxStatus[3] & TxHostOwns )?TSAD_OWN3:0)
1882 |((s->TxStatus[2] & TxHostOwns )?TSAD_OWN2:0)
1883 |((s->TxStatus[1] & TxHostOwns )?TSAD_OWN1:0)
1884 |((s->TxStatus[0] & TxHostOwns )?TSAD_OWN0:0) ;
1885
1886
1887 #ifdef DEBUG_RTL8139
1888 printf("RTL8139: TSAD read val=0x%04x\n", ret);
1889 #endif
1890
1891 return ret;
1892 }
1893
1894 static uint16_t rtl8139_CSCR_read(RTL8139State *s)
1895 {
1896 uint16_t ret = s->CSCR;
1897
1898 #ifdef DEBUG_RTL8139
1899 printf("RTL8139: CSCR read val=0x%04x\n", ret);
1900 #endif
1901
1902 return ret;
1903 }
1904
1905 static void rtl8139_TxAddr_write(RTL8139State *s, uint32_t txAddrOffset, uint32_t val)
1906 {
1907 #ifdef DEBUG_RTL8139
1908 printf("RTL8139: TxAddr write offset=0x%x val=0x%08x\n", txAddrOffset, val);
1909 #endif
1910
1911 s->TxAddr[txAddrOffset/4] = le32_to_cpu(val);
1912 }
1913
1914 static uint32_t rtl8139_TxAddr_read(RTL8139State *s, uint32_t txAddrOffset)
1915 {
1916 uint32_t ret = cpu_to_le32(s->TxAddr[txAddrOffset/4]);
1917
1918 #ifdef DEBUG_RTL8139
1919 printf("RTL8139: TxAddr read offset=0x%x val=0x%08x\n", txAddrOffset, ret);
1920 #endif
1921
1922 return ret;
1923 }
1924
1925 static void rtl8139_RxBufPtr_write(RTL8139State *s, uint32_t val)
1926 {
1927 #ifdef DEBUG_RTL8139
1928 printf("RTL8139: RxBufPtr write val=0x%04x\n", val);
1929 #endif
1930
1931 /* this value is off by 16 */
1932 s->RxBufPtr = MOD2(val + 0x10, s->RxBufferSize);
1933
1934 #if defined(DEBUG_RTL8139)
1935 printf(" CAPR write: rx buffer length %d head 0x%04x read 0x%04x\n",
1936 s->RxBufferSize, s->RxBufAddr, s->RxBufPtr);
1937 #endif
1938 }
1939
1940 static uint32_t rtl8139_RxBufPtr_read(RTL8139State *s)
1941 {
1942 /* this value is off by 16 */
1943 uint32_t ret = s->RxBufPtr - 0x10;
1944
1945 #ifdef DEBUG_RTL8139
1946 printf("RTL8139: RxBufPtr read val=0x%04x\n", ret);
1947 #endif
1948
1949 return ret;
1950 }
1951
1952 static void rtl8139_RxBuf_write(RTL8139State *s, uint32_t val)
1953 {
1954 #ifdef DEBUG_RTL8139
1955 printf("RTL8139: RxBuf write val=0x%08x\n", val);
1956 #endif
1957
1958 s->RxBuf = val;
1959
1960 /* may need to reset rxring here */
1961 }
1962
1963 static uint32_t rtl8139_RxBuf_read(RTL8139State *s)
1964 {
1965 uint32_t ret = s->RxBuf;
1966
1967 #ifdef DEBUG_RTL8139
1968 printf("RTL8139: RxBuf read val=0x%08x\n", ret);
1969 #endif
1970
1971 return ret;
1972 }
1973
1974 static void rtl8139_IntrMask_write(RTL8139State *s, uint32_t val)
1975 {
1976 #ifdef DEBUG_RTL8139
1977 printf("RTL8139: IntrMask write(w) val=0x%04x\n", val);
1978 #endif
1979
1980 /* mask unwriteable bits */
1981 val = SET_MASKED(val, 0x1e00, s->IntrMask);
1982
1983 s->IntrMask = val;
1984
1985 rtl8139_update_irq(s);
1986 }
1987
1988 static uint32_t rtl8139_IntrMask_read(RTL8139State *s)
1989 {
1990 uint32_t ret = s->IntrMask;
1991
1992 #ifdef DEBUG_RTL8139
1993 printf("RTL8139: IntrMask read(w) val=0x%04x\n", ret);
1994 #endif
1995
1996 return ret;
1997 }
1998
1999 static void rtl8139_IntrStatus_write(RTL8139State *s, uint32_t val)
2000 {
2001 #ifdef DEBUG_RTL8139
2002 printf("RTL8139: IntrStatus write(w) val=0x%04x\n", val);
2003 #endif
2004
2005 #if 0
2006
2007 /* writing to ISR has no effect */
2008
2009 return;
2010
2011 #else
2012 uint16_t newStatus = s->IntrStatus & ~val;
2013
2014 /* mask unwriteable bits */
2015 newStatus = SET_MASKED(newStatus, 0x1e00, s->IntrStatus);
2016
2017 /* writing 1 to interrupt status register bit clears it */
2018 s->IntrStatus = 0;
2019 rtl8139_update_irq(s);
2020
2021 s->IntrStatus = newStatus;
2022 rtl8139_update_irq(s);
2023 #endif
2024 }
2025
2026 static uint32_t rtl8139_IntrStatus_read(RTL8139State *s)
2027 {
2028 uint32_t ret = s->IntrStatus;
2029
2030 #ifdef DEBUG_RTL8139
2031 printf("RTL8139: IntrStatus read(w) val=0x%04x\n", ret);
2032 #endif
2033
2034 #if 0
2035
2036 /* reading ISR clears all interrupts */
2037 s->IntrStatus = 0;
2038
2039 rtl8139_update_irq(s);
2040
2041 #endif
2042
2043 return ret;
2044 }
2045
2046 static void rtl8139_MultiIntr_write(RTL8139State *s, uint32_t val)
2047 {
2048 #ifdef DEBUG_RTL8139
2049 printf("RTL8139: MultiIntr write(w) val=0x%04x\n", val);
2050 #endif
2051
2052 /* mask unwriteable bits */
2053 val = SET_MASKED(val, 0xf000, s->MultiIntr);
2054
2055 s->MultiIntr = val;
2056 }
2057
2058 static uint32_t rtl8139_MultiIntr_read(RTL8139State *s)
2059 {
2060 uint32_t ret = s->MultiIntr;
2061
2062 #ifdef DEBUG_RTL8139
2063 printf("RTL8139: MultiIntr read(w) val=0x%04x\n", ret);
2064 #endif
2065
2066 return ret;
2067 }
2068
2069 static void rtl8139_io_writeb(void *opaque, uint8_t addr, uint32_t val)
2070 {
2071 RTL8139State *s = opaque;
2072
2073 addr &= 0xff;
2074
2075 switch (addr)
2076 {
2077 case MAC0 ... MAC0+5:
2078 s->phys[addr - MAC0] = val;
2079 break;
2080 case MAC0+6 ... MAC0+7:
2081 /* reserved */
2082 break;
2083 case MAR0 ... MAR0+7:
2084 s->mult[addr - MAR0] = val;
2085 break;
2086 case ChipCmd:
2087 rtl8139_ChipCmd_write(s, val);
2088 break;
2089 case Cfg9346:
2090 rtl8139_Cfg9346_write(s, val);
2091 break;
2092 case TxConfig: /* windows driver sometimes writes using byte-lenth call */
2093 rtl8139_TxConfig_writeb(s, val);
2094 break;
2095 case Config0:
2096 rtl8139_Config0_write(s, val);
2097 break;
2098 case Config1:
2099 rtl8139_Config1_write(s, val);
2100 break;
2101 case Config3:
2102 rtl8139_Config3_write(s, val);
2103 break;
2104 case Config4:
2105 rtl8139_Config4_write(s, val);
2106 break;
2107 case Config5:
2108 rtl8139_Config5_write(s, val);
2109 break;
2110 case MediaStatus:
2111 /* ignore */
2112 #ifdef DEBUG_RTL8139
2113 printf("RTL8139: not implemented write(b) to MediaStatus val=0x%02x\n", val);
2114 #endif
2115 break;
2116
2117 case HltClk:
2118 #ifdef DEBUG_RTL8139
2119 printf("RTL8139: HltClk write val=0x%08x\n", val);
2120 #endif
2121 if (val == 'R')
2122 {
2123 s->clock_enabled = 1;
2124 }
2125 else if (val == 'H')
2126 {
2127 s->clock_enabled = 0;
2128 }
2129 break;
2130
2131 case TxThresh:
2132 #ifdef DEBUG_RTL8139
2133 printf("RTL8139C+ TxThresh write(b) val=0x%02x\n", val);
2134 #endif
2135 s->TxThresh = val;
2136 break;
2137
2138 case TxPoll:
2139 #ifdef DEBUG_RTL8139
2140 printf("RTL8139C+ TxPoll write(b) val=0x%02x\n", val);
2141 #endif
2142 if (val & (1 << 7))
2143 {
2144 #ifdef DEBUG_RTL8139
2145 printf("RTL8139C+ TxPoll high priority transmission (not implemented)\n");
2146 #endif
2147 //rtl8139_cplus_transmit(s);
2148 }
2149 if (val & (1 << 6))
2150 {
2151 #ifdef DEBUG_RTL8139
2152 printf("RTL8139C+ TxPoll normal priority transmission\n");
2153 #endif
2154 rtl8139_cplus_transmit(s);
2155 }
2156
2157 break;
2158
2159 default:
2160 #ifdef DEBUG_RTL8139
2161 printf("RTL8139: not implemented write(b) addr=0x%x val=0x%02x\n", addr, val);
2162 #endif
2163 break;
2164 }
2165 }
2166
2167 static void rtl8139_io_writew(void *opaque, uint8_t addr, uint32_t val)
2168 {
2169 RTL8139State *s = opaque;
2170
2171 addr &= 0xfe;
2172
2173 switch (addr)
2174 {
2175 case IntrMask:
2176 rtl8139_IntrMask_write(s, val);
2177 break;
2178
2179 case IntrStatus:
2180 rtl8139_IntrStatus_write(s, val);
2181 break;
2182
2183 case MultiIntr:
2184 rtl8139_MultiIntr_write(s, val);
2185 break;
2186
2187 case RxBufPtr:
2188 rtl8139_RxBufPtr_write(s, val);
2189 break;
2190
2191 case BasicModeCtrl:
2192 rtl8139_BasicModeCtrl_write(s, val);
2193 break;
2194 case BasicModeStatus:
2195 rtl8139_BasicModeStatus_write(s, val);
2196 break;
2197 case NWayAdvert:
2198 #ifdef DEBUG_RTL8139
2199 printf("RTL8139: NWayAdvert write(w) val=0x%04x\n", val);
2200 #endif
2201 s->NWayAdvert = val;
2202 break;
2203 case NWayLPAR:
2204 #ifdef DEBUG_RTL8139
2205 printf("RTL8139: forbidden NWayLPAR write(w) val=0x%04x\n", val);
2206 #endif
2207 break;
2208 case NWayExpansion:
2209 #ifdef DEBUG_RTL8139
2210 printf("RTL8139: NWayExpansion write(w) val=0x%04x\n", val);
2211 #endif
2212 s->NWayExpansion = val;
2213 break;
2214
2215 case CpCmd:
2216 rtl8139_CpCmd_write(s, val);
2217 break;
2218
2219 default:
2220 #ifdef DEBUG_RTL8139
2221 printf("RTL8139: ioport write(w) addr=0x%x val=0x%04x via write(b)\n", addr, val);
2222 #endif
2223
2224 #ifdef TARGET_WORDS_BIGENDIAN
2225 rtl8139_io_writeb(opaque, addr, (val >> 8) & 0xff);
2226 rtl8139_io_writeb(opaque, addr + 1, val & 0xff);
2227 #else
2228 rtl8139_io_writeb(opaque, addr, val & 0xff);
2229 rtl8139_io_writeb(opaque, addr + 1, (val >> 8) & 0xff);
2230 #endif
2231 break;
2232 }
2233 }
2234
2235 static void rtl8139_io_writel(void *opaque, uint8_t addr, uint32_t val)
2236 {
2237 RTL8139State *s = opaque;
2238
2239 addr &= 0xfc;
2240
2241 switch (addr)
2242 {
2243 case RxMissed:
2244 #ifdef DEBUG_RTL8139
2245 printf("RTL8139: RxMissed clearing on write\n");
2246 #endif
2247 s->RxMissed = 0;
2248 break;
2249
2250 case TxConfig:
2251 rtl8139_TxConfig_write(s, val);
2252 break;
2253
2254 case RxConfig:
2255 rtl8139_RxConfig_write(s, val);
2256 break;
2257
2258 case TxStatus0 ... TxStatus0+4*4-1:
2259 rtl8139_TxStatus_write(s, addr-TxStatus0, val);
2260 break;
2261
2262 case TxAddr0 ... TxAddr0+4*4-1:
2263 rtl8139_TxAddr_write(s, addr-TxAddr0, val);
2264 break;
2265
2266 case RxBuf:
2267 rtl8139_RxBuf_write(s, val);
2268 break;
2269
2270 case RxRingAddrLO:
2271 #ifdef DEBUG_RTL8139
2272 printf("RTL8139: C+ RxRing low bits write val=0x%08x\n", val);
2273 #endif
2274 s->RxRingAddrLO = val;
2275 break;
2276
2277 case RxRingAddrHI:
2278 #ifdef DEBUG_RTL8139
2279 printf("RTL8139: C+ RxRing high bits write val=0x%08x\n", val);
2280 #endif
2281 s->RxRingAddrHI = val;
2282 break;
2283
2284 default:
2285 #ifdef DEBUG_RTL8139
2286 printf("RTL8139: ioport write(l) addr=0x%x val=0x%08x via write(b)\n", addr, val);
2287 #endif
2288 #ifdef TARGET_WORDS_BIGENDIAN
2289 rtl8139_io_writeb(opaque, addr, (val >> 24) & 0xff);
2290 rtl8139_io_writeb(opaque, addr + 1, (val >> 16) & 0xff);
2291 rtl8139_io_writeb(opaque, addr + 2, (val >> 8) & 0xff);
2292 rtl8139_io_writeb(opaque, addr + 3, val & 0xff);
2293 #else
2294 rtl8139_io_writeb(opaque, addr, val & 0xff);
2295 rtl8139_io_writeb(opaque, addr + 1, (val >> 8) & 0xff);
2296 rtl8139_io_writeb(opaque, addr + 2, (val >> 16) & 0xff);
2297 rtl8139_io_writeb(opaque, addr + 3, (val >> 24) & 0xff);
2298 #endif
2299 break;
2300 }
2301 }
2302
2303 static uint32_t rtl8139_io_readb(void *opaque, uint8_t addr)
2304 {
2305 RTL8139State *s = opaque;
2306 int ret;
2307
2308 addr &= 0xff;
2309
2310 switch (addr)
2311 {
2312 case MAC0 ... MAC0+5:
2313 ret = s->phys[addr - MAC0];
2314 break;
2315 case MAC0+6 ... MAC0+7:
2316 ret = 0;
2317 break;
2318 case MAR0 ... MAR0+7:
2319 ret = s->mult[addr - MAR0];
2320 break;
2321 case ChipCmd:
2322 ret = rtl8139_ChipCmd_read(s);
2323 break;
2324 case Cfg9346:
2325 ret = rtl8139_Cfg9346_read(s);
2326 break;
2327 case Config0:
2328 ret = rtl8139_Config0_read(s);
2329 break;
2330 case Config1:
2331 ret = rtl8139_Config1_read(s);
2332 break;
2333 case Config3:
2334 ret = rtl8139_Config3_read(s);
2335 break;
2336 case Config4:
2337 ret = rtl8139_Config4_read(s);
2338 break;
2339 case Config5:
2340 ret = rtl8139_Config5_read(s);
2341 break;
2342
2343 case MediaStatus:
2344 ret = 0xd0;
2345 #ifdef DEBUG_RTL8139
2346 printf("RTL8139: MediaStatus read 0x%x\n", ret);
2347 #endif
2348 break;
2349
2350 case HltClk:
2351 ret = s->clock_enabled;
2352 #ifdef DEBUG_RTL8139
2353 printf("RTL8139: HltClk read 0x%x\n", ret);
2354 #endif
2355 break;
2356
2357 case PCIRevisionID:
2358 ret = 0x10;
2359 #ifdef DEBUG_RTL8139
2360 printf("RTL8139: PCI Revision ID read 0x%x\n", ret);
2361 #endif
2362 break;
2363
2364 case TxThresh:
2365 ret = s->TxThresh;
2366 #ifdef DEBUG_RTL8139
2367 printf("RTL8139C+ TxThresh read(b) val=0x%02x\n", ret);
2368 #endif
2369 break;
2370
2371 case 0x43: /* Part of TxConfig register. Windows driver tries to read it */
2372 ret = s->TxConfig >> 24;
2373 #ifdef DEBUG_RTL8139
2374 printf("RTL8139C TxConfig at 0x43 read(b) val=0x%02x\n", ret);
2375 #endif
2376 break;
2377
2378 default:
2379 #ifdef DEBUG_RTL8139
2380 printf("RTL8139: not implemented read(b) addr=0x%x\n", addr);
2381 #endif
2382 ret = 0;
2383 break;
2384 }
2385
2386 return ret;
2387 }
2388
2389 static uint32_t rtl8139_io_readw(void *opaque, uint8_t addr)
2390 {
2391 RTL8139State *s = opaque;
2392 uint32_t ret;
2393
2394 addr &= 0xfe; /* mask lower bit */
2395
2396 switch (addr)
2397 {
2398 case IntrMask:
2399 ret = rtl8139_IntrMask_read(s);
2400 break;
2401
2402 case IntrStatus:
2403 ret = rtl8139_IntrStatus_read(s);
2404 break;
2405
2406 case MultiIntr:
2407 ret = rtl8139_MultiIntr_read(s);
2408 break;
2409
2410 case RxBufPtr:
2411 ret = rtl8139_RxBufPtr_read(s);
2412 break;
2413
2414 case BasicModeCtrl:
2415 ret = rtl8139_BasicModeCtrl_read(s);
2416 break;
2417 case BasicModeStatus:
2418 ret = rtl8139_BasicModeStatus_read(s);
2419 break;
2420 case NWayAdvert:
2421 ret = s->NWayAdvert;
2422 #ifdef DEBUG_RTL8139
2423 printf("RTL8139: NWayAdvert read(w) val=0x%04x\n", ret);
2424 #endif
2425 break;
2426 case NWayLPAR:
2427 ret = s->NWayLPAR;
2428 #ifdef DEBUG_RTL8139
2429 printf("RTL8139: NWayLPAR read(w) val=0x%04x\n", ret);
2430 #endif
2431 break;
2432 case NWayExpansion:
2433 ret = s->NWayExpansion;
2434 #ifdef DEBUG_RTL8139
2435 printf("RTL8139: NWayExpansion read(w) val=0x%04x\n", ret);
2436 #endif
2437 break;
2438
2439 case CpCmd:
2440 ret = rtl8139_CpCmd_read(s);
2441 break;
2442
2443 case TxSummary:
2444 ret = rtl8139_TSAD_read(s);
2445 break;
2446
2447 case CSCR:
2448 ret = rtl8139_CSCR_read(s);
2449 break;
2450
2451 default:
2452 #ifdef DEBUG_RTL8139
2453 printf("RTL8139: ioport read(w) addr=0x%x via read(b)\n", addr);
2454 #endif
2455
2456 #ifdef TARGET_WORDS_BIGENDIAN
2457 ret = rtl8139_io_readb(opaque, addr) << 8;
2458 ret |= rtl8139_io_readb(opaque, addr + 1);
2459 #else
2460 ret = rtl8139_io_readb(opaque, addr);
2461 ret |= rtl8139_io_readb(opaque, addr + 1) << 8;
2462 #endif
2463
2464 #ifdef DEBUG_RTL8139
2465 printf("RTL8139: ioport read(w) addr=0x%x val=0x%04x\n", addr, ret);
2466 #endif
2467 break;
2468 }
2469
2470 return ret;
2471 }
2472
2473 static uint32_t rtl8139_io_readl(void *opaque, uint8_t addr)
2474 {
2475 RTL8139State *s = opaque;
2476 uint32_t ret;
2477
2478 addr &= 0xfc; /* also mask low 2 bits */
2479
2480 switch (addr)
2481 {
2482 case RxMissed:
2483 ret = s->RxMissed;
2484
2485 #ifdef DEBUG_RTL8139
2486 printf("RTL8139: RxMissed read val=0x%08x\n", ret);
2487 #endif
2488 break;
2489
2490 case TxConfig:
2491 ret = rtl8139_TxConfig_read(s);
2492 break;
2493
2494 case RxConfig:
2495 ret = rtl8139_RxConfig_read(s);
2496 break;
2497
2498 case TxStatus0 ... TxStatus0+4*4-1:
2499 ret = rtl8139_TxStatus_read(s, addr-TxStatus0);
2500 break;
2501
2502 case TxAddr0 ... TxAddr0+4*4-1:
2503 ret = rtl8139_TxAddr_read(s, addr-TxAddr0);
2504 break;
2505
2506 case RxBuf:
2507 ret = rtl8139_RxBuf_read(s);
2508 break;
2509
2510 case RxRingAddrLO:
2511 ret = s->RxRingAddrLO;
2512 #ifdef DEBUG_RTL8139
2513 printf("RTL8139: C+ RxRing low bits read val=0x%08x\n", ret);
2514 #endif
2515 break;
2516
2517 case RxRingAddrHI:
2518 ret = s->RxRingAddrHI;
2519 #ifdef DEBUG_RTL8139
2520 printf("RTL8139: C+ RxRing high bits read val=0x%08x\n", ret);
2521 #endif
2522 break;
2523
2524 default:
2525 #ifdef DEBUG_RTL8139
2526 printf("RTL8139: ioport read(l) addr=0x%x via read(b)\n", addr);
2527 #endif
2528
2529 #ifdef TARGET_WORDS_BIGENDIAN
2530 ret = rtl8139_io_readb(opaque, addr) << 24;
2531 ret |= rtl8139_io_readb(opaque, addr + 1) << 16;
2532 ret |= rtl8139_io_readb(opaque, addr + 2) << 8;
2533 ret |= rtl8139_io_readb(opaque, addr + 3);
2534 #else
2535 ret = rtl8139_io_readb(opaque, addr);
2536 ret |= rtl8139_io_readb(opaque, addr + 1) << 8;
2537 ret |= rtl8139_io_readb(opaque, addr + 2) << 16;
2538 ret |= rtl8139_io_readb(opaque, addr + 3) << 24;
2539 #endif
2540
2541 #ifdef DEBUG_RTL8139
2542 printf("RTL8139: read(l) addr=0x%x val=%08x\n", addr, ret);
2543 #endif
2544 break;
2545 }
2546
2547 return ret;
2548 }
2549
2550 /* */
2551
2552 static void rtl8139_ioport_writeb(void *opaque, uint32_t addr, uint32_t val)
2553 {
2554 rtl8139_io_writeb(opaque, addr & 0xFF, val);
2555 }
2556
2557 static void rtl8139_ioport_writew(void *opaque, uint32_t addr, uint32_t val)
2558 {
2559 rtl8139_io_writew(opaque, addr & 0xFF, val);
2560 }
2561
2562 static void rtl8139_ioport_writel(void *opaque, uint32_t addr, uint32_t val)
2563 {
2564 rtl8139_io_writel(opaque, addr & 0xFF, val);
2565 }
2566
2567 static uint32_t rtl8139_ioport_readb(void *opaque, uint32_t addr)
2568 {
2569 return rtl8139_io_readb(opaque, addr & 0xFF);
2570 }
2571
2572 static uint32_t rtl8139_ioport_readw(void *opaque, uint32_t addr)
2573 {
2574 return rtl8139_io_readw(opaque, addr & 0xFF);
2575 }
2576
2577 static uint32_t rtl8139_ioport_readl(void *opaque, uint32_t addr)
2578 {
2579 return rtl8139_io_readl(opaque, addr & 0xFF);
2580 }
2581
2582 /* */
2583
2584 static void rtl8139_mmio_writeb(void *opaque, target_phys_addr_t addr, uint32_t val)
2585 {
2586 rtl8139_io_writeb(opaque, addr & 0xFF, val);
2587 }
2588
2589 static void rtl8139_mmio_writew(void *opaque, target_phys_addr_t addr, uint32_t val)
2590 {
2591 rtl8139_io_writew(opaque, addr & 0xFF, val);
2592 }
2593
2594 static void rtl8139_mmio_writel(void *opaque, target_phys_addr_t addr, uint32_t val)
2595 {
2596 rtl8139_io_writel(opaque, addr & 0xFF, val);
2597 }
2598
2599 static uint32_t rtl8139_mmio_readb(void *opaque, target_phys_addr_t addr)
2600 {
2601 return rtl8139_io_readb(opaque, addr & 0xFF);
2602 }
2603
2604 static uint32_t rtl8139_mmio_readw(void *opaque, target_phys_addr_t addr)
2605 {
2606 return rtl8139_io_readw(opaque, addr & 0xFF);
2607 }
2608
2609 static uint32_t rtl8139_mmio_readl(void *opaque, target_phys_addr_t addr)
2610 {
2611 return rtl8139_io_readl(opaque, addr & 0xFF);
2612 }
2613
2614 /* */
2615
2616 static void rtl8139_save(QEMUFile* f,void* opaque)
2617 {
2618 RTL8139State* s=(RTL8139State*)opaque;
2619 int i;
2620
2621 qemu_put_buffer(f, s->phys, 6);
2622 qemu_put_buffer(f, s->mult, 8);
2623
2624 for (i=0; i<4; ++i)
2625 {
2626 qemu_put_be32s(f, &s->TxStatus[i]); /* TxStatus0 */
2627 }
2628 for (i=0; i<4; ++i)
2629 {
2630 qemu_put_be32s(f, &s->TxAddr[i]); /* TxAddr0 */
2631 }
2632
2633 qemu_put_be32s(f, &s->RxBuf); /* Receive buffer */
2634 qemu_put_be32s(f, &s->RxBufferSize);/* internal variable, receive ring buffer size in C mode */
2635 qemu_put_be32s(f, &s->RxBufPtr);
2636 qemu_put_be32s(f, &s->RxBufAddr);
2637
2638 qemu_put_be16s(f, &s->IntrStatus);
2639 qemu_put_be16s(f, &s->IntrMask);
2640
2641 qemu_put_be32s(f, &s->TxConfig);
2642 qemu_put_be32s(f, &s->RxConfig);
2643 qemu_put_be32s(f, &s->RxMissed);
2644 qemu_put_be16s(f, &s->CSCR);
2645
2646 qemu_put_8s(f, &s->Cfg9346);
2647 qemu_put_8s(f, &s->Config0);
2648 qemu_put_8s(f, &s->Config1);
2649 qemu_put_8s(f, &s->Config3);
2650 qemu_put_8s(f, &s->Config4);
2651 qemu_put_8s(f, &s->Config5);
2652
2653 qemu_put_8s(f, &s->clock_enabled);
2654 qemu_put_8s(f, &s->bChipCmdState);
2655
2656 qemu_put_be16s(f, &s->MultiIntr);
2657
2658 qemu_put_be16s(f, &s->BasicModeCtrl);
2659 qemu_put_be16s(f, &s->BasicModeStatus);
2660 qemu_put_be16s(f, &s->NWayAdvert);
2661 qemu_put_be16s(f, &s->NWayLPAR);
2662 qemu_put_be16s(f, &s->NWayExpansion);
2663
2664 qemu_put_be16s(f, &s->CpCmd);
2665 qemu_put_8s(f, &s->TxThresh);
2666
2667 qemu_put_be32s(f, &s->irq);
2668 qemu_put_buffer(f, s->macaddr, 6);
2669 qemu_put_be32s(f, &s->rtl8139_mmio_io_addr);
2670
2671 qemu_put_be32s(f, &s->currTxDesc);
2672 qemu_put_be32s(f, &s->currCPlusRxDesc);
2673 qemu_put_be32s(f, &s->currCPlusTxDesc);
2674 qemu_put_be32s(f, &s->RxRingAddrLO);
2675 qemu_put_be32s(f, &s->RxRingAddrHI);
2676
2677 for (i=0; i<EEPROM_9346_SIZE; ++i)
2678 {
2679 qemu_put_be16s(f, &s->eeprom.contents[i]);
2680 }
2681 qemu_put_be32s(f, &s->eeprom.mode);
2682 qemu_put_be32s(f, &s->eeprom.tick);
2683 qemu_put_8s(f, &s->eeprom.address);
2684 qemu_put_be16s(f, &s->eeprom.input);
2685 qemu_put_be16s(f, &s->eeprom.output);
2686
2687 qemu_put_8s(f, &s->eeprom.eecs);
2688 qemu_put_8s(f, &s->eeprom.eesk);
2689 qemu_put_8s(f, &s->eeprom.eedi);
2690 qemu_put_8s(f, &s->eeprom.eedo);
2691 }
2692
2693 static int rtl8139_load(QEMUFile* f,void* opaque,int version_id)
2694 {
2695 RTL8139State* s=(RTL8139State*)opaque;
2696 int i;
2697
2698 if (version_id != 1)
2699 return -EINVAL;
2700
2701 qemu_get_buffer(f, s->phys, 6);
2702 qemu_get_buffer(f, s->mult, 8);
2703
2704 for (i=0; i<4; ++i)
2705 {
2706 qemu_get_be32s(f, &s->TxStatus[i]); /* TxStatus0 */
2707 }
2708 for (i=0; i<4; ++i)
2709 {
2710 qemu_get_be32s(f, &s->TxAddr[i]); /* TxAddr0 */
2711 }
2712
2713 qemu_get_be32s(f, &s->RxBuf); /* Receive buffer */
2714 qemu_get_be32s(f, &s->RxBufferSize);/* internal variable, receive ring buffer size in C mode */
2715 qemu_get_be32s(f, &s->RxBufPtr);
2716 qemu_get_be32s(f, &s->RxBufAddr);
2717
2718 qemu_get_be16s(f, &s->IntrStatus);
2719 qemu_get_be16s(f, &s->IntrMask);
2720
2721 qemu_get_be32s(f, &s->TxConfig);
2722 qemu_get_be32s(f, &s->RxConfig);
2723 qemu_get_be32s(f, &s->RxMissed);
2724 qemu_get_be16s(f, &s->CSCR);
2725
2726 qemu_get_8s(f, &s->Cfg9346);
2727 qemu_get_8s(f, &s->Config0);
2728 qemu_get_8s(f, &s->Config1);
2729 qemu_get_8s(f, &s->Config3);
2730 qemu_get_8s(f, &s->Config4);
2731 qemu_get_8s(f, &s->Config5);
2732
2733 qemu_get_8s(f, &s->clock_enabled);
2734 qemu_get_8s(f, &s->bChipCmdState);
2735
2736 qemu_get_be16s(f, &s->MultiIntr);
2737
2738 qemu_get_be16s(f, &s->BasicModeCtrl);
2739 qemu_get_be16s(f, &s->BasicModeStatus);
2740 qemu_get_be16s(f, &s->NWayAdvert);
2741 qemu_get_be16s(f, &s->NWayLPAR);
2742 qemu_get_be16s(f, &s->NWayExpansion);
2743
2744 qemu_get_be16s(f, &s->CpCmd);
2745 qemu_get_8s(f, &s->TxThresh);
2746
2747 qemu_get_be32s(f, &s->irq);
2748 qemu_get_buffer(f, s->macaddr, 6);
2749 qemu_get_be32s(f, &s->rtl8139_mmio_io_addr);
2750
2751 qemu_get_be32s(f, &s->currTxDesc);
2752 qemu_get_be32s(f, &s->currCPlusRxDesc);
2753 qemu_get_be32s(f, &s->currCPlusTxDesc);
2754 qemu_get_be32s(f, &s->RxRingAddrLO);
2755 qemu_get_be32s(f, &s->RxRingAddrHI);
2756
2757 for (i=0; i<EEPROM_9346_SIZE; ++i)
2758 {
2759 qemu_get_be16s(f, &s->eeprom.contents[i]);
2760 }
2761 qemu_get_be32s(f, &s->eeprom.mode);
2762 qemu_get_be32s(f, &s->eeprom.tick);
2763 qemu_get_8s(f, &s->eeprom.address);
2764 qemu_get_be16s(f, &s->eeprom.input);
2765 qemu_get_be16s(f, &s->eeprom.output);
2766
2767 qemu_get_8s(f, &s->eeprom.eecs);
2768 qemu_get_8s(f, &s->eeprom.eesk);
2769 qemu_get_8s(f, &s->eeprom.eedi);
2770 qemu_get_8s(f, &s->eeprom.eedo);
2771
2772 return 0;
2773 }
2774
2775 /***********************************************************/
2776 /* PCI RTL8139 definitions */
2777
2778 typedef struct PCIRTL8139State {
2779 PCIDevice dev;
2780 RTL8139State rtl8139;
2781 } PCIRTL8139State;
2782
2783 static void rtl8139_mmio_map(PCIDevice *pci_dev, int region_num,
2784 uint32_t addr, uint32_t size, int type)
2785 {
2786 PCIRTL8139State *d = (PCIRTL8139State *)pci_dev;
2787 RTL8139State *s = &d->rtl8139;
2788
2789 cpu_register_physical_memory(addr + 0, 0x100, s->rtl8139_mmio_io_addr);
2790 }
2791
2792 static void rtl8139_ioport_map(PCIDevice *pci_dev, int region_num,
2793 uint32_t addr, uint32_t size, int type)
2794 {
2795 PCIRTL8139State *d = (PCIRTL8139State *)pci_dev;
2796 RTL8139State *s = &d->rtl8139;
2797
2798 register_ioport_write(addr, 0x100, 1, rtl8139_ioport_writeb, s);
2799 register_ioport_read( addr, 0x100, 1, rtl8139_ioport_readb, s);
2800
2801 register_ioport_write(addr, 0x100, 2, rtl8139_ioport_writew, s);
2802 register_ioport_read( addr, 0x100, 2, rtl8139_ioport_readw, s);
2803
2804 register_ioport_write(addr, 0x100, 4, rtl8139_ioport_writel, s);
2805 register_ioport_read( addr, 0x100, 4, rtl8139_ioport_readl, s);
2806 }
2807
2808 static CPUReadMemoryFunc *rtl8139_mmio_read[3] = {
2809 rtl8139_mmio_readb,
2810 rtl8139_mmio_readw,
2811 rtl8139_mmio_readl,
2812 };
2813
2814 static CPUWriteMemoryFunc *rtl8139_mmio_write[3] = {
2815 rtl8139_mmio_writeb,
2816 rtl8139_mmio_writew,
2817 rtl8139_mmio_writel,
2818 };
2819
2820 void pci_rtl8139_init(PCIBus *bus, NICInfo *nd)
2821 {
2822 PCIRTL8139State *d;
2823 RTL8139State *s;
2824 uint8_t *pci_conf;
2825
2826 d = (PCIRTL8139State *)pci_register_device(bus,
2827 "RTL8139", sizeof(PCIRTL8139State),
2828 -1,
2829 NULL, NULL);
2830 pci_conf = d->dev.config;
2831 pci_conf[0x00] = 0xec; /* Realtek 8139 */
2832 pci_conf[0x01] = 0x10;
2833 pci_conf[0x02] = 0x39;
2834 pci_conf[0x03] = 0x81;
2835 pci_conf[0x04] = 0x05; /* command = I/O space, Bus Master */
2836 pci_conf[0x08] = 0x20; /* 0x10 */ /* PCI revision ID; >=0x20 is for 8139C+ */
2837 pci_conf[0x0a] = 0x00; /* ethernet network controller */
2838 pci_conf[0x0b] = 0x02;
2839 pci_conf[0x0e] = 0x00; /* header_type */
2840 pci_conf[0x3d] = 1; /* interrupt pin 0 */
2841 pci_conf[0x34] = 0xdc;
2842
2843 s = &d->rtl8139;
2844
2845 /* I/O handler for memory-mapped I/O */
2846 s->rtl8139_mmio_io_addr =
2847 cpu_register_io_memory(0, rtl8139_mmio_read, rtl8139_mmio_write, s);
2848
2849 pci_register_io_region(&d->dev, 0, 0x100,
2850 PCI_ADDRESS_SPACE_IO, rtl8139_ioport_map);
2851
2852 pci_register_io_region(&d->dev, 1, 0x100,
2853 PCI_ADDRESS_SPACE_MEM, rtl8139_mmio_map);
2854
2855 s->irq = 16; /* PCI interrupt */
2856 s->pci_dev = (PCIDevice *)d;
2857 memcpy(s->macaddr, nd->macaddr, 6);
2858 rtl8139_reset(s);
2859 s->vc = qemu_new_vlan_client(nd->vlan, rtl8139_receive,
2860 rtl8139_can_receive, s);
2861
2862 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
2863 "rtl8139 pci macaddr=%02x:%02x:%02x:%02x:%02x:%02x",
2864 s->macaddr[0],
2865 s->macaddr[1],
2866 s->macaddr[2],
2867 s->macaddr[3],
2868 s->macaddr[4],
2869 s->macaddr[5]);
2870
2871 /* XXX: instance number ? */
2872 register_savevm("rtl8139", 0, 1, rtl8139_save, rtl8139_load, s);
2873 register_savevm("rtl8139_pci", 0, 1, generic_pci_save, generic_pci_load,
2874 &d->dev);
2875 }
Samsung s3c2440 and arm920t support for the mini2440 dev board