![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to lance.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Isaki's NoNo m68k/m88k emulator] / nono / vm|
Return to lance.cpp CVS log | Up to [Isaki's NoNo m68k/m88k emulator] / nono / vm |
1.1 root 1: //
2: // nono
1.1.1.4 root 3: // Copyright (C) 2020 nono project
4: // Licensed under nono-license.txt
1.1 root 5: //
6:
1.1.1.11 root 7: //
8: // Lance (AM7990)
9: //
10:
1.1 root 11: #include "lance.h"
1.1.1.11 root 12: #include "bitops.h"
1.1.1.20! root 13: #include "event.h"
1.1.1.7 root 14: #include "interrupt.h"
1.1.1.13 root 15: #include "mainbus.h"
1.1.1.17 root 16: #include "monitor.h"
1.1.1.11 root 17: #include "scheduler.h"
1.1.1.13 root 18: #include "subram.h"
1.1 root 19:
1.1.1.11 root 20: // コンストラクタ
1.1 root 21: LanceDevice::LanceDevice()
1.1.1.14 root 22: : inherited(OBJ_ETHERNET(0))
1.1 root 23: {
1.1.1.13 root 24: SetName("Lance");
25: ClearAlias();
26: AddAlias("Lance");
1.1.1.9 root 27: AddAlias("Ethernet");
1.1 root 28:
1.1.1.17 root 29: monitor = gMonitorManager->Regist(ID_MONITOR_LANCE, this);
30: monitor->func = ToMonitorCallback(&LanceDevice::MonitorUpdate);
31: monitor->SetSize(80, 34);
1.1 root 32: }
33:
1.1.1.11 root 34: // デストラクタ
1.1 root 35: LanceDevice::~LanceDevice()
36: {
37: }
38:
1.1.1.13 root 39: // 初期化
1.1 root 40: bool
41: LanceDevice::Init()
42: {
1.1.1.13 root 43: interrupt = GetInterruptDevice();
44: subram = GetSubRAMDevice();
1.1 root 45:
1.1.1.19 root 46: hostnet->SetPortName("Lance");
47:
1.1.1.13 root 48: // ホストからの受信コールバックを登録
1.1.1.14 root 49: scheduler->ConnectMessage(MessageID::HOSTNET_RX(0), this,
1.1.1.15 root 50: ToMessageCallback(&LanceDevice::RxMessage));
1.1 root 51:
1.1.1.20! root 52: auto evman = GetEventManager();
! 53: rx_event = evman->Regist(this, NULL, "Lance RX");
! 54: tx_event = evman->Regist(this, NULL, "Lance TX");
1.1.1.16 root 55:
1.1 root 56: return true;
57: }
58:
1.1.1.11 root 59: // リセット
1.1 root 60: void
1.1.1.11 root 61: LanceDevice::ResetHard(bool poweron)
1.1 root 62: {
63: reg.rap = 0;
64: ChipStop();
65: }
66:
1.1.1.15 root 67: busdata
1.1.1.16 root 68: LanceDevice::ReadPort(uint32 offset)
1.1 root 69: {
1.1.1.15 root 70: busdata data;
1.1 root 71:
1.1.1.8 root 72: switch (offset) {
1.1 root 73: case 0: // RDP
74: data = ReadData();
1.1.1.15 root 75: break;
1.1.1.3 root 76: case 1: // RAP
1.1 root 77: data = reg.rap;
1.1.1.16 root 78: putlog(2, "RAP -> %u", reg.rap);
1.1.1.15 root 79: break;
1.1.1.11 root 80: default:
1.1.1.16 root 81: VMPANIC("corrupted offset=%u", offset);
1.1.1.15 root 82: data = 0xffff;
83: break;
1.1 root 84: }
1.1.1.15 root 85:
86: // XXX wait?
1.1.1.16 root 87: data |= BusData::Size2;
1.1.1.15 root 88: return data;
1.1 root 89: }
90:
1.1.1.15 root 91: busdata
1.1.1.16 root 92: LanceDevice::WritePort(uint32 offset, uint32 data)
1.1 root 93: {
1.1.1.8 root 94: switch (offset) {
1.1 root 95: case 0: // RDP
96: WriteData(data);
1.1.1.15 root 97: break;
1.1.1.3 root 98: case 1: // RAP
1.1 root 99: reg.rap = data & 3;
1.1.1.15 root 100: break;
1.1.1.11 root 101: default:
1.1.1.16 root 102: VMPANIC("corrupted offset=%u", offset);
1.1.1.15 root 103: break;
1.1 root 104: }
1.1.1.15 root 105:
1.1.1.16 root 106: busdata r = BusData::Size2;
1.1.1.15 root 107: // XXX wait?
1.1.1.16 root 108: return r;
1.1 root 109: }
110:
1.1.1.15 root 111: busdata
1.1.1.16 root 112: LanceDevice::PeekPort(uint32 offset)
1.1 root 113: {
1.1.1.8 root 114: switch (offset) {
1.1.1.3 root 115: case 0: // RDP
116: // 今読めるはずのデータ。
117: // CSR[123] は STOP 中でなければ不定だがとりあえずそれは無視。
118: switch (reg.rap) {
119: case 0:
120: return reg.GetCSR0();
121: case 1:
122: return reg.iadr & 0xffff;
123: case 2:
124: return reg.iadr >> 16;
125: case 3:
126: return reg.csr3;
1.1.1.11 root 127: default:
1.1.1.13 root 128: break;
1.1.1.3 root 129: }
130: break;
131: case 1: // RAP
132: return reg.rap;
1.1.1.11 root 133: default:
1.1.1.13 root 134: break;
1.1.1.3 root 135: }
1.1.1.13 root 136: return 0xff;
1.1 root 137: }
138:
1.1.1.5 root 139: void
1.1.1.9 root 140: LanceDevice::MonitorUpdate(Monitor *, TextScreen& screen)
1.1 root 141: {
142: /*
143: CSR0: $1111 ERR BABL CERR MISS MERR RINT TINT IDON IADR:$123456
144: CSR3:$0004 BSWP ACON BCON
145:
146: MODE: $0000 PROM INTL DRTY COLL DTCR LOOP DTX DRX
1.1.1.15 root 147: PADR: 00:11:22:33:44:55 RDRP: $12345678 (RDRA=$123456 entries=32)
148: LADRF:$fedcba98'76543210 TDRP:
1.1 root 149:
150: <RMD> Current 00 OWN ERR OFLO CRC BUFF STP ENP BCNT=$123 MCNT=$123 buf=$123456
151: 01234567890123456789012345678901234567890 00
152: 00 OVCBSE $12345 $123/$123 00 OVCBSE $12345 $123/$123
153: <TMD> Current 00 OWN ERR STP ENP BUFF UFLO BCNT=$123 buf=$123456
154: 00 OSEBU $12345 $123
155: */
156:
157: // name を表示。(var & bit) ならオン(反転)表示。
158: // bitpos は 0..15 で [0] が MSB にあたる。
159: #define MonitorBit(var, bit, name) do { \
1.1.1.9 root 160: screen.Puts(x, y, TA::OnOff((var) & (bit)), name); \
1.1 root 161: x += strlen(name) + 1; \
162: } while (0)
163:
164: int x;
165: int y;
166: int i;
167:
1.1.1.9 root 168: screen.Clear();
1.1 root 169:
170: y = 0;
171: // CSR
172: uint16 csr0 = reg.GetCSR0();
1.1.1.9 root 173: screen.Print(0, y, "CSR0:$%04x", csr0);
174: MonitorReg(screen, 11, y, csr0 >> 8, csr0names);
175: MonitorReg(screen, 11, y + 1, csr0, csr0names + 8);
1.1 root 176:
1.1.1.9 root 177: screen.Print(54, y++, "IADR:$%06x", reg.iadr);
178: screen.Print(54, y, "CSR3:$%04x", reg.csr3);
1.1 root 179: // CSR3 は下位3ビットだけなので手動で配置
180: x = 65;
181: MonitorBit(reg.csr3, AM7990::CSR3_BSWP, csr3names[13]);
182: MonitorBit(reg.csr3, AM7990::CSR3_ACON, csr3names[14]);
183: MonitorBit(reg.csr3, AM7990::CSR3_BCON, csr3names[15]);
184: y++;
185:
1.1.1.9 root 186: screen.Puts(0, y, "<Initial Block>");
1.1 root 187: y++;
188: // MODE は bit15 と bit6-0 の8ビットだけ使われてるので
189: // 途中を省略して 8ビットとして表示する
1.1.1.9 root 190: screen.Print(0, y, "MODE:$%04x", initblock[0]);
1.1 root 191: x = 11;
192: MonitorBit(initblock[0], AM7990::IBMODE_PROM, ib_mode_names[0]);
193: MonitorBit(initblock[0], AM7990::IBMODE_INTL, ib_mode_names[1]);
194: MonitorBit(initblock[0], AM7990::IBMODE_DRTY, ib_mode_names[2]);
195: MonitorBit(initblock[0], AM7990::IBMODE_COLL, ib_mode_names[3]);
196: MonitorBit(initblock[0], AM7990::IBMODE_DTCR, ib_mode_names[4]);
197: MonitorBit(initblock[0], AM7990::IBMODE_LOOP, ib_mode_names[5]);
198: MonitorBit(initblock[0], AM7990::IBMODE_DTX, ib_mode_names[6]);
199: MonitorBit(initblock[0], AM7990::IBMODE_DRX, ib_mode_names[7]);
200: y++;
201:
1.1.1.9 root 202: screen.Print(0, y, "PADR: %02x:%02x:%02x:%02x:%02x:%02x",
1.1 root 203: initblock[1] & 0xff, initblock[1] >> 8,
204: initblock[2] & 0xff, initblock[2] >> 8,
205: initblock[3] & 0xff, initblock[3] >> 8);
1.1.1.15 root 206: screen.Print(0, y + 1, "LADRF:$%04x%04x'%04x%04x",
1.1 root 207: initblock[7],
208: initblock[6],
209: initblock[5],
210: initblock[4]);
211:
212: // RDRP
213: uint32 rdrp = initblock[8] | (initblock[9] << 16);
1.1.1.16 root 214: screen.Print(31, y, "RDRP:$%08x (RDRA=$%06x entries=%u)",
1.1 root 215: rdrp, rmd_base, rmd_num);
216: y++;
217:
218: // TDRP
219: uint32 tdrp = initblock[10] | (initblock[11] << 16);
1.1.1.16 root 220: screen.Print(31, y, "TDRP:$%08x (TDRA=$%06x entries=%u)",
1.1 root 221: tdrp, tmd_base, tmd_num);
222: y++;
223: y++;
224:
225: // RMD
1.1.1.9 root 226: screen.Puts(0, y, "<RMD>");
1.1 root 227:
228: uint16 rmd[4];
229: uint32 rmd_addr;
230: // 現行ディスクリプタは詳細表示
231: if (rmd_num > 0) {
232: rmd_addr = rmd_base + rmd_cur * 8;
233: for (int j = 0; j < countof(rmd); j++) {
234: rmd[j] = PeekMem(rmd_addr + j * 2);
235: }
236: x = 6;
1.1.1.16 root 237: screen.Print(x, y, "Current %02x", rmd_cur);
238: x += 11;
1.1 root 239: MonitorBit(rmd[1], AM7990::RMD1_OWN, rmd1_names[0]);
240: MonitorBit(rmd[1], AM7990::RMD1_ERR, rmd1_names[1]);
241: // 発生し得ないので省略 RMD1_FRAM rmd1_names[2]
242: MonitorBit(rmd[1], AM7990::RMD1_OFLO, rmd1_names[3]);
243: MonitorBit(rmd[1], AM7990::RMD1_CRC, rmd1_names[4]);
244: MonitorBit(rmd[1], AM7990::RMD1_BUFF, rmd1_names[5]);
245: MonitorBit(rmd[1], AM7990::RMD1_STP, rmd1_names[6]);
246: MonitorBit(rmd[1], AM7990::RMD1_ENP, rmd1_names[7]);
247: // BCNT は負数(2の補数)でエンコードされているので正数にデコード
1.1.1.9 root 248: screen.Print(x, y, "MCNT=$%03x BCNT=$%03x",
1.1 root 249: rmd[3] & 0xfff,
250: (-(int16)rmd[2]) & 0xfff);
251: x += 20;
1.1.1.9 root 252: screen.Print(x, y, "buf=$%06x", ((rmd[1] & 0xff) << 16) | rmd[0]);
1.1 root 253: }
254: y++;
255:
256: // 他は一覧表示
257: int rs;
258: if (rmd_num > 48) {
259: // 画面内に収まらないので仕方ないのでカーソルのある16個ブロックが
260: // 常に中央にくるようにローテートするのはどうか。
261: rs = (((rmd_cur - 16 + rmd_num) % rmd_num) / 16) * 16;
262: } else {
263: // 画面内に収まるので最初から書いていくだけ
264: rs = 0;
265: }
266: for (x = 0; x < 3; x++) {
267: for (i = 0; i < 16 && rs < rmd_num; i++) {
268: rmd_addr = rmd_base + rs * 8;
269: for (int j = 0; j < countof(rmd); j++) {
270: rmd[j] = PeekMem(rmd_addr + j * 2);
271: }
1.1.1.9 root 272: screen.Print(x * 27, y + i,
1.1 root 273: (rs == rmd_cur) ? TA::Em : TA::Normal,
274: "%02x %c%c%c%c%c%c $%05x $%03x/$%03x",
275: rs,
276: (rmd[1] & AM7990::RMD1_OWN) ? 'O' : '-',
277: (rmd[1] & AM7990::RMD1_OFLO) ? 'F' : '-',
278: (rmd[1] & AM7990::RMD1_CRC) ? 'C' : '-',
279: (rmd[1] & AM7990::RMD1_BUFF) ? 'B' : '-',
280: (rmd[1] & AM7990::RMD1_STP) ? 'S' : '-',
281: (rmd[1] & AM7990::RMD1_ENP) ? 'E' : '-',
282: ((rmd[1] & 0xff) << 16 | rmd[0]),
283: rmd[3] & 0xfff,
284: (-(int16)rmd[2]) & 0xfff);
285:
286: // 画面内に収まらない場合は折り返し。
287: // 収まる場合はこのまま rmd_num を超えればループを抜ける。
288: rs++;
289: if (rmd_num > 48 && rs >= rmd_num) {
290: rs = 0;
291: }
292: }
293: }
294: y += 17;
295:
296: // TMD
1.1.1.9 root 297: screen.Puts(0, y, "<TMD>");
1.1 root 298:
299: uint16 tmd[4];
300: uint32 tmd_addr;
301: // 現行ディスクリプタは詳細表示
302: if (tmd_num > 0) {
303: tmd_addr = tmd_base + tmd_cur * 8;
304: for (int j = 0; j < countof(tmd); j++) {
305: tmd[j] = PeekMem(tmd_addr + j * 2);
306: }
307: // MORE, ONE, DEF と LCOL, LCAR, RTRY, TDR は発生し得ないので省略
308: x = 6;
1.1.1.16 root 309: screen.Print(x, y, "Current %02x ", tmd_cur);
310: x += 11;
1.1 root 311: MonitorBit(tmd[1], AM7990::TMD1_OWN, tmd1_names[0]);
312: MonitorBit(tmd[1], AM7990::TMD1_ERR, tmd1_names[1]);
313: MonitorBit(tmd[1], AM7990::TMD1_STP, tmd1_names[6]);
314: MonitorBit(tmd[1], AM7990::TMD1_ENP, tmd1_names[7]);
315: x += 1;
316: MonitorBit(tmd[3], AM7990::TMD3_BUFF, tmd3_names[0]);
317: MonitorBit(tmd[3], AM7990::TMD3_UFLO, tmd3_names[1]);
318: // BCNT は負数(2の補数)でエンコードされているので正数にデコード
1.1.1.9 root 319: screen.Print(x, y, "BCNT=$%03x", (-(int16)tmd[2]) & 0xfff);
1.1 root 320: x += 10;
1.1.1.9 root 321: screen.Print(x, y, "buf=$%06x", ((tmd[1] & 0xff) << 16) | tmd[0]);
1.1 root 322: }
323: y++;
324:
325: // 他は一覧表示
326: int ts;
327: if (tmd_num > 24) {
328: // 画面内に収まらないので仕方ないのでカーソルのある16個ブロックが
329: // 常に中央にくるようにローテートするのはどうか。
330: ts = (((tmd_cur - 16 + tmd_num) % tmd_num) / 16) * 16;
331: } else {
332: // 画面内に収まるので最初から書いていくだけ
333: ts = 0;
334: }
335: for (x = 0; x < 3; x++) {
336: for (i = 0; i < 8 && ts < tmd_num; i++) {
337: tmd_addr = tmd_base + ts * 8;
338: for (int j = 0; j < countof(tmd); j++) {
339: tmd[j] = PeekMem(tmd_addr + j * 2);
340: }
1.1.1.9 root 341: screen.Print(x * 27, y + i,
1.1 root 342: (ts == tmd_cur) ? TA::Em : TA::Normal,
343: "%02x %c%c%c%c%c $%05x $%03x",
344: ts,
345: (tmd[1] & AM7990::TMD1_OWN) ? 'O' : '-',
346: (tmd[1] & AM7990::TMD1_STP) ? 'S' : '-',
347: (tmd[1] & AM7990::TMD1_ENP) ? 'E' : '-',
348: (tmd[3] & AM7990::TMD3_BUFF) ? 'B' : '-',
349: (tmd[3] & AM7990::TMD3_UFLO) ? 'U' : '-',
350: ((tmd[1] & 0xff) << 16 | tmd[0]),
351: (-(int16)tmd[2]) & 0xfff);
352:
353: // 画面内に収まらない場合は折り返し。
1.1.1.16 root 354: // 収まる場合はこのまま tmd_num を超えればループを抜ける。
1.1 root 355: ts++;
356: if (tmd_num > 24 && ts >= tmd_num) {
357: ts = 0;
358: }
359: }
360: }
361: }
362:
363: // レジスタをビットごとに表示する。
364: // data は下位8ビットのみ使用し、上位は無視する。
365: void
1.1.1.9 root 366: LanceDevice::MonitorReg(TextScreen& screen,
1.1.1.5 root 367: int x, int y, uint32 data, const char * const *names)
1.1 root 368: {
369: for (int i = 0; i < 8; i++) {
1.1.1.20! root 370: bool b = data & (1U << (7 - i));
1.1.1.9 root 371: screen.Puts(x + i * 5, y, TA::OnOff(b), names[i]);
1.1 root 372: }
373: }
374:
375:
376: // 現在選択されているレジスタを読み出す
377: uint32
378: LanceDevice::ReadData()
379: {
380: uint32 data;
381:
382: // XXX CSR[123] は STOP 中だけ読める。そうでない時は未定義値になる。
383: switch (reg.rap) {
384: case 0:
385: {
386: data = reg.GetCSR0();
387: const std::string name = CSR0ToString(data);
1.1.1.11 root 388: putlog(3, "CSR0 -> $%04x<%s>", data, name.c_str());
1.1 root 389: break;
390: }
391: case 1:
392: if (reg.IsSTOP()) {
393: data = reg.iadr & 0xffff;
1.1.1.16 root 394: putlog(2, "CSR%u -> $%04x", reg.rap, data);
1.1 root 395: } else {
396: data = 0xcccc & AM7990::CSR1_MASK;
1.1.1.16 root 397: putlog(2, "CSR%u -> $%04x (indefinate read)", reg.rap, data);
1.1 root 398: }
399: break;
400: case 2:
401: if (reg.IsSTOP()) {
402: data = reg.iadr >> 16;
1.1.1.16 root 403: putlog(2, "CSR%u -> $%04x", reg.rap, data);
1.1 root 404: } else {
405: data = 0xcccc & AM7990::CSR2_MASK;
1.1.1.16 root 406: putlog(2, "CSR%u -> $%04x (indefinate read)", reg.rap, data);
1.1 root 407: }
408: break;
409: case 3:
410: if (reg.IsSTOP()) {
411: data = reg.csr3;
412: const std::string name = CSR3ToString(data);
1.1.1.16 root 413: putlog(2, "CSR%u -> $%04x<%s>", reg.rap, data, name.c_str());
1.1 root 414: } else {
415: data = 0xcccc & AM7990::CSR3_MASK;
1.1.1.16 root 416: putlog(2, "CSR%u -> $%04x (indefinate read)", reg.rap, data);
1.1 root 417: }
418: break;
419: default:
1.1.1.16 root 420: VMPANIC("corrupted reg.rap=%u", reg.rap);
1.1.1.15 root 421: data = 0xffff;
1.1.1.13 root 422: break;
1.1 root 423: }
424: return data;
425: }
426:
427: // 現在選択されてるレジスタに data を書き込む
428: void
429: LanceDevice::WriteData(uint32 data)
430: {
431: switch (reg.rap) {
432: case 0:
433: {
434: // CSR0 は STOP ビットによらず書き込み可能
435: const std::string name = CSR0ToString(data);
436: putlog(2, "CSR0 <- $%04x<%s>", data, name.c_str());
437:
438: // STOP,STRT,INIT 全部立てると STOP のみ有効 (AM7990.pdf, p17)。
439: // STOP は実質リセットなので、これ立ってたらもうそれで終わりだろう。
440: if ((data & AM7990::CSR0_STOP)) {
441: ChipStop();
442: break;
443: }
444:
1.1.1.11 root 445: // INIT, STRT は立ち上がりで実行にしてみる。
446: // OpenBSD が割り込みクリアするために読んだ CSR0 をそのまま書いて
447: // くるようなので、毎回 INIT と STRT が走ってしまう。
448: // とりあえず立ち上がりでやってみる。
449: // XXX 要実機調査
450:
451: if (bit_rising(reg.csr0, data, AM7990::CSR0_INIT)) {
1.1 root 452: ChipInit();
453: }
1.1.1.11 root 454: if (bit_rising(reg.csr0, data, AM7990::CSR0_STRT)) {
1.1 root 455: ChipStart();
456: }
457:
458: // TDMD はセットオンリー (チップがクリアする)
459: if ((data & AM7990::CSR0_TDMD)) {
460: reg.csr0 |= AM7990::CSR0_TDMD;
1.1.1.9 root 461: // TX ポーリングの待ち時間ならこのあとすぐ起動
462: if (tx_phase == TXPhase::IDLE) {
463: ChangePhase(TXPhase::IDLE);
464: }
1.1 root 465: }
466:
467: // 書き込みがビットクリアになる人たち
468: if ((data & AM7990::CSR0_IDON)) {
469: reg.csr0 &= ~AM7990::CSR0_IDON;
470: }
471: if ((data & AM7990::CSR0_TINT)) {
472: reg.csr0 &= ~AM7990::CSR0_TINT;
473: }
474: if ((data & AM7990::CSR0_RINT)) {
475: reg.csr0 &= ~AM7990::CSR0_RINT;
476: }
477: if ((data & AM7990::CSR0_MERR)) {
478: reg.csr0 &= ~AM7990::CSR0_MERR;
479: }
480: if ((data & AM7990::CSR0_MISS)) {
481: reg.csr0 &= ~AM7990::CSR0_MISS;
482: }
483: if ((data & AM7990::CSR0_CERR)) {
484: reg.csr0 &= ~AM7990::CSR0_CERR;
485: }
486: if ((data & AM7990::CSR0_BABL)) {
487: reg.csr0 &= ~AM7990::CSR0_BABL;
488: }
489:
490: // INEA は %0 も %1 も書き込める
491: // INEA は STOP 中は設定できない
492: if (!reg.IsSTOP()) {
493: reg.csr0 &= ~AM7990::CSR0_INEA;
1.1.1.7 root 494: reg.csr0 |= data & AM7990::CSR0_INEA;
1.1 root 495: }
1.1.1.7 root 496:
497: ChangeInterrupt();
1.1 root 498: break;
499: }
500:
501: case 1:
502: // STOP 中のみ書き込み可能。そうでない時は無視する。
503: if (reg.IsSTOP()) {
504: reg.iadr = (reg.iadr & 0xff0000) | (data & AM7990::IADR_L_MASK);
505: putlog(2, "IDAR(L)=$%06x", reg.iadr);
1.1.1.11 root 506:
507: #if 0
508: // IADR 設定時にパフォーマンス測定用実時間表示
1.1.1.13 root 509: scheduler->PutlogRealtime();
1.1.1.11 root 510: #endif
1.1 root 511: }
512: break;
513:
514: case 2:
515: // STOP 中のみ書き込み可能。そうでない時は無視する。
516: if (reg.IsSTOP()) {
517: reg.iadr = ((data & AM7990::IADR_H_MASK) << 16)
518: | (reg.iadr & 0xffff);
519: putlog(2, "IDAR(H)=$%06x", reg.iadr);
520: }
521: break;
522:
523: case 3:
524: // STOP 中のみ書き込み可能。そうでない時は無視する。
525: if (reg.IsSTOP()) {
526: reg.csr3 = data & AM7990::CSR3_MASK;
527: const std::string name = CSR3ToString(reg.csr3);
528: putlog(2, "CSR3 <- $%04x<%s>", reg.csr3, name.c_str());
529: }
530: break;
531:
532: default:
1.1.1.16 root 533: VMPANIC("corrupted reg.rap=%u", reg.rap);
1.1 root 534: }
535: }
536:
537: // メモリアクセスについて。
1.1.1.11 root 538: // LANCE(AM7990) から見たメモリは、メインメモリではなく 3ポートSRAM
1.1.1.13 root 539: // (ここでは SubRAM デバイス)。
540: // LANCE のメモリバスは 16bit で、DAL15..8 が SubRAM の偶数アドレス、
541: // DAL7..0 が SubRAM の奇数アドレスに接続されている。
1.1.1.11 root 542: //
1.1.1.13 root 543: // LANCE | DAL15..DAL8 | DAL7..DAL0
544: // -------+-------------+------------
545: // SubRAM | +0 byte | +1 byte
546: // | +2 byte | +3 byte
1.1 root 547: //
1.1.1.11 root 548: // メモリアクセスは常にこの構成で、CSR3.BSWP はこの1ワードを SILO(FIFO) に
549: // 書き込む/から読み出す順序を入れ替えるもの。
1.1 root 550:
1.1.1.16 root 551: // メモリから1ワード読み込む。addr はワードアラインしていること。
552: uint32
553: LanceDevice::ReadMem(uint32 addr)
1.1 root 554: {
1.1.1.16 root 555: assertmsg((addr & 1) == 0, "addr=$%x", addr);
1.1 root 556:
557: // XXX 所要クロックを考察すること
1.1.1.16 root 558: busdata data = subram->Read2(addr);
559: return data.Data();
1.1 root 560: }
561:
1.1.1.16 root 562: // メモリに1ワード書き込む。addr はワードアラインしていること。
563: void
564: LanceDevice::WriteMem(uint32 addr, uint32 data)
1.1 root 565: {
1.1.1.16 root 566: assertmsg((addr & 1) == 0, "addr=$%x", addr);
1.1 root 567:
568: // XXX 所要クロックを考察すること
1.1.1.16 root 569: subram->Write2(addr, data);
1.1 root 570: }
571:
572: // メモリ (3ポートSRAM) から1ワードピークする。バスエラーは起きない。
1.1.1.16 root 573: uint32
574: LanceDevice::PeekMem(uint32 addr) const
1.1 root 575: {
1.1.1.16 root 576: busdata data = subram->Peek2(addr);
577: return data.Data();
1.1 root 578: }
579:
580: // INIT ビットによるチップ初期化。
581: void
582: LanceDevice::ChipInit()
583: {
1.1.1.11 root 584: putlog(1, "ChipInit");
585:
1.1 root 586: // INIT をセットすると STOP ビットはクリア
587: reg.csr0 |= AM7990::CSR0_INIT;
588: reg.csr0 &= ~AM7990::CSR0_STOP;
589:
590: // Initialization Block を読み込む
591: for (int i = 0; i < countof(initblock); i++) {
592: initblock[i] = ReadMem(reg.iadr + i * 2);
593: }
594: if (0) {
595: for (int i = 0; i < countof(initblock); i++) {
1.1.1.16 root 596: putlog(2, "initblock[%u] = $%04x", i, initblock[i]);
1.1 root 597: }
598: }
599:
600: // 送受信ディスクリプタ用の内部変数を設定
601: uint32 rdrp = initblock[8] | (initblock[9] << 16);
602: rmd_base = rdrp & 0xfffffc;
603: int rlen = rdrp >> 29;
1.1.1.20! root 604: rmd_num = (1U << rlen);
1.1 root 605:
606: uint32 tdrp = initblock[10] | (initblock[11] << 16);
607: tmd_base = tdrp & 0xfffffc;
608: int tlen = tdrp >> 29;
1.1.1.20! root 609: tmd_num = (1U << tlen);
1.1 root 610:
1.1.1.18 root 611: padr = MacAddr(
612: initblock[1] & 0xff,
613: initblock[1] >> 8,
614: initblock[2] & 0xff,
615: initblock[2] >> 8,
616: initblock[3] & 0xff,
617: initblock[3] >> 8);
1.1.1.11 root 618:
1.1.1.15 root 619: // LADRF は以下のように格納されていて、そのまま LADRF(63:00) に対応する。
620: // IADR+$08 LADRF(15:00)
621: // IADR+$0a LADRF(31:16)
622: // IADR+$0c LADRF(47:32)
623: // IADR+$0e LADRF(63:48)
1.1.1.18 root 624: ladrf = ((uint64)initblock[4] << 0)
625: | ((uint64)initblock[5] << 16)
626: | ((uint64)initblock[6] << 32)
627: | ((uint64)initblock[7] << 48);
628:
629: promisc = (initblock[0] & AM7990::IBMODE_PROM);
1.1.1.9 root 630:
1.1 root 631: // XXX 本当はいろいろ時間がかかりそうなはずだが
632: // 初期化完了
633: SetInterrupt(AM7990::CSR0_IDON);
634: }
635:
636: // STRT ビットによるスタート。
637: void
638: LanceDevice::ChipStart()
639: {
1.1.1.12 root 640: putlog(1, "Start");
1.1 root 641:
642: // STRT を書き込むと STOP はクリア
643: reg.csr0 |= AM7990::CSR0_STRT;
644: reg.csr0 &= ~AM7990::CSR0_STOP;
645:
646: // MODE の DTX がクリアなら TXON をセット?
647: // XXX 実際はタイミング違う気がする
648: // INIT で DTX==%0 ならトランスミッタがオンになり、
649: // トランスミッタがオンで STRT すると TXON がオンになる、ように読めるが
650: // トランスミッタは省略してみる。
651: // RX 側も同様。
652: if ((initblock[0] & AM7990::IBMODE_DTX) == 0) {
653: reg.csr0 |= AM7990::CSR0_TXON;
654: }
655: if ((initblock[0] & AM7990::IBMODE_DRX) == 0) {
656: reg.csr0 |= AM7990::CSR0_RXON;
657: }
658:
659: // 初回読み込みに備えて RMD1/TMD1 の先読みバッファを無効化する
660: rmd1_ahead = (uint32)-1;
661: tmd1_ahead = (uint32)-1;
662:
1.1.1.11 root 663: // バッファクリア
664: tx_packet.Clear();
665:
1.1.1.9 root 666: ChangePhase(TXPhase::IDLE, 0_nsec);
667: ChangePhase(RXPhase::IDLE, 0_nsec);
1.1.1.11 root 668:
669: // ホストの受信を開始する
670: hostnet->EnableRx(true);
1.1 root 671: }
672:
673: // STOP ビットによるチップリセット。
674: // ハードリセットもここに来る。
675: void
676: LanceDevice::ChipStop()
677: {
1.1.1.12 root 678: putlog(1, "Reset");
1.1 root 679:
680: // STOPセットで CSR0 は STOP セット、他は全クリア
681: reg.csr0 = AM7990::CSR0_STOP;
1.1.1.15 root 682: ChangeInterrupt();
1.1 root 683: // CSR1, 2 は不定
684: // CSR3 はクリア
685: reg.csr3 = 0;
686:
687: // 内部ポインタも戻す
688: tmd_cur = 0;
689: rmd_cur = 0;
690:
691: // イベントを(あれば)停止。
1.1.1.11 root 692: ChangePhase(RXPhase::STOP);
693: ChangePhase(TXPhase::STOP);
1.1 root 694:
1.1.1.11 root 695: // バッファクリア
696: rx_packet.Clear();
697: tx_packet.Clear();
1.1.1.9 root 698:
1.1.1.11 root 699: // ホストの受信を停止する
700: hostnet->EnableRx(false);
1.1 root 701: }
702:
1.1.1.7 root 703: // 割り込み要因を CSR0 にセットし、必要なら割り込みを上げる。
1.1 root 704: void
705: LanceDevice::SetInterrupt(uint32 bit)
706: {
707: reg.csr0 |= bit;
1.1.1.7 root 708: ChangeInterrupt();
1.1 root 709: }
710:
1.1.1.7 root 711: // 現状に合わせて割り込み信号線の状態を変える。
1.1 root 712: void
1.1.1.7 root 713: LanceDevice::ChangeInterrupt()
1.1 root 714: {
1.1.1.15 root 715: bool irq = (reg.IsINTR() && (reg.csr0 & AM7990::CSR0_INEA));
716: interrupt->ChangeINT(this, irq);
1.1 root 717: }
718:
719: // TXIDLE 送信アイドルフェーズ。
720: // ディスクリプタを所有できるかポーリングする。
1.1.1.9 root 721: // - 所有できれば TXCOPY フェーズへ。
722: // - 所有できない場合、TDMD オンなら即、
723: // オフなら 1.6ms 待ってから再び TXIDLE へ。
1.1 root 724: void
1.1.1.20! root 725: LanceDevice::TXIdle(Event *ev)
1.1 root 726: {
1.1.1.9 root 727: tx_phase = TXPhase::IDLE;
728:
729: // TDMD クリア
730: reg.csr0 &= ~AM7990::CSR0_TDMD;
731:
1.1 root 732: // TMD1 を読み込む
733: if ((int32)tmd1_ahead >= 0) {
734: // すでに先読みしてあればそれを使う
735: tmd1 = tmd1_ahead;
736: } else {
737: // 読み込む
738: uint32 tmd_addr = tmd_base + tmd_cur * 8;
739: tmd1 = ReadMem(tmd_addr + 2);
740: }
741: // どちらにしても先読みバッファは無効に戻す
742: tmd1_ahead = (uint32)-1;
743:
744: // その TMD1 に OWN と STP が立っているか
745: if ((tmd1 & AM7990::TMD1_OWN) && (tmd1 & AM7990::TMD1_STP)) {
746: // 取り込みへ
1.1.1.11 root 747: TXCopy();
1.1 root 748: return;
749: }
750:
1.1.1.9 root 751: // 立っていなければ次回は 1.6ms 後
752: ChangePhase(TXPhase::IDLE, 1.6_msec);
1.1 root 753: }
754:
755: // TXCOPY バッファ処理フェーズ。
756: // 現ディスクリプタのバッファの内容をメモリから読み込み、
757: // それにかかる時間相当分をウェイトする。
1.1.1.9 root 758: // - ENP ならウェイトした後 TXSEND フェーズへ。
759: // - 次 TMD が OWN できればウェイトした後 TXNEXT フェーズへ。
760: // - 次 TMD が OWN 出来なければウェイトした後 TXSEND フェーズ。
1.1 root 761: void
1.1.1.11 root 762: LanceDevice::TXCopy()
1.1 root 763: {
1.1.1.9 root 764: tx_phase = TXPhase::COPY;
765:
1.1 root 766: // TMD0, TMD2 は送信することが確定してから読み出す
767: uint32 tmd_addr = tmd_base + tmd_cur * 8;
768: uint16 tmd0 = ReadMem(tmd_addr);
769: uint16 tmd2 = ReadMem(tmd_addr + 4);
770:
1.1.1.11 root 771: // アドレスと送信バイト数。
772: // tmd2 には 2 の補数で送信バイト数が入っているので符号反転する。
773: uint32 src = ((tmd1 & 0x00ff) << 16) | tmd0;
774: int32 bcnt = -(int32)(int16)tmd2;
775:
776: // copycnt は bcnt のうち実際にコピーするバイト数
777: int32 copycnt;
778: if (tx_packet.length + bcnt > tx_packet.size()) {
779: // コピーするとバッファが溢れてしまう計算なら、溢れないように打ち切る。
780: copycnt = tx_packet.size() - tx_packet.length;
781: } else {
782: // 全部コピーできる。
783: copycnt = bcnt;
784: }
785:
786: // 送信パケットキュー上の書き込み中バッファに追記する
787: uint8 *dst = &tx_packet[tx_packet.length];
788: tx_packet.length += copycnt;
789:
1.1.1.13 root 790: // ここから、SubRAM からローカルの送信バッファにコピー
1.1.1.11 root 791: // XXX バーストコピー未対応
792: const uint32 srcend = src + bcnt;
793: const uint8 *dstend = dst + copycnt;
794:
795: // src が奇数アドレスから始まっている(そしてコピー可能な)場合
796: // (バッファを奇数アドレスから始めたりする奇特な人はいないと思うが)
797: if (__predict_false((src & 1) != 0) && dst < dstend) {
798: uint16 data = ReadMem(src & ~1);
799: if (reg.IsBSWP() == false) {
800: *dst++ = data >> 8;
801: } else {
802: *dst++ = data & 0xff;
803: }
804: src++;
805: }
1.1 root 806:
1.1.1.11 root 807: // 残り2バイト以上コピー可能な間 (ここで src はワード境界になっている)
808: const uint8 *dstend_even;
809: dstend_even = (const uint8 *)((uintptr_t)dstend & ~(uintptr_t)1);
810: while (dst < dstend_even) {
811: uint16 data = ReadMem(src);
812: if (reg.IsBSWP() == false) {
813: *dst++ = data & 0xff;
814: *dst++ = data >> 8;
815: } else {
816: *dst++ = data >> 8;
817: *dst++ = data & 0xff;
818: }
819: src += 2;
820: }
1.1 root 821:
1.1.1.11 root 822: // src が奇数アドレスで終わっている(そしてコピー可能な)場合
823: if (__predict_false(dst < dstend)) {
824: uint16 data = ReadMem(src);
825: if (reg.IsBSWP() == false) {
826: *dst++ = data & 0xff;
1.1 root 827: } else {
1.1.1.11 root 828: *dst++ = data >> 8;
1.1 root 829: }
1.1.1.11 root 830: src += 2;
831: }
832:
1.1.1.13 root 833: // tx_packet が一杯になったら後はディスクリプタが終わるまで SubRAM から
1.1.1.11 root 834: // 読み捨てる。tx_packet の長さに上限があるのはこっち(エミュレータ)の
835: // 都合であって LANCE はディスクリプタが終わるまで延々読み込んでは出力を
836: // 続けるようだ。ここでは同じだけ読み込むところ、それにかかる時間を求める
837: // ところを再現する。tx_packet がイーサネットフレーム長を超過していると
838: // この後 SEND フェーズで BABBLE ビットを立てるところも再現する。
839: // 正確には 1519バイト目の送信で立てるのだが、通常は起きない上に面倒
840: // なので省略。1519バイト以上のパケットをホストに流すこともしない。
841: while (src < srcend) {
842: ReadMem(src);
843: src += 2;
1.1 root 844: }
845:
1.1.1.9 root 846: // メモリからの転送にかかった時間をざっくり計算 XXX まだ適当
847: // そのウェイト後に指定のフェーズへ。
1.1.1.11 root 848: uint64 t = 700 * bcnt / 16;
1.1.1.9 root 849:
1.1 root 850: // ここが ENP なら、送信のため TXSEND フェーズへ
851: if ((tmd1 & AM7990::TMD1_ENP)) {
1.1.1.9 root 852: ChangePhase(TXPhase::SEND, t);
1.1 root 853: } else {
854: // 次のディスクリプタを先読み
855: tmd_addr = tmd_base + ((tmd_cur + 1) % tmd_num) * 8;
856: tmd1_ahead = ReadMem(tmd_addr + 2);
857:
858: if ((tmd1_ahead & AM7990::TMD1_OWN)) {
859: // 次ディスクリプタが所有できれば TXNEXT フェーズへ
1.1.1.9 root 860: ChangePhase(TXPhase::NEXT, t);
1.1 root 861: } else {
862: // この時点で所有できなければアンダーフロー。
863: // ここまでのバッファでパケットを送信するため TXSEND へ。
864: // エラーフラグの処理は TXSEND 側で行う。
1.1.1.9 root 865: ChangePhase(TXPhase::SEND, t);
1.1 root 866: }
867: }
868: }
869:
870: // TXSEND フェーズ。パケットを送信。
871: // ただし ENP でなければアンダーフローによるパケット送信なのでフラグ処理。
872: // その後 TXNEXT フェーズへ。
873: void
1.1.1.20! root 874: LanceDevice::TXSend(Event *ev)
1.1 root 875: {
1.1.1.9 root 876: tx_phase = TXPhase::SEND;
877:
1.1.1.11 root 878: if (__predict_false(tx_packet.length > 1518)) {
879: // 本当は 1519バイト目を送ったところで BABL を立てるのだが
880: // まず起きない上に面倒なので、ここで行う。
881: SetInterrupt(AM7990::CSR0_BABL);
882:
883: // 1519バイト以上のパケットはホストにも投げない。
884: } else {
885: // 送信
886: hostnet->Tx(tx_packet);
887: }
888: tx_packet.Clear();
1.1 root 889:
890: // ENP でなければアンダーフローによるものだった
891: if ((tmd1 & AM7990::TMD1_ENP) == 0) {
892: // TMD3 はここで書き出す
893: // XXX 読まずに書くだけもいいはず?
894: uint32 tmd_addr = tmd_base + tmd_cur * 8;
895: uint16 tmd3 = ReadMem(tmd_addr + 6);
896: tmd3 |= AM7990::TMD3_BUFF | AM7990::TMD3_UFLO;
897: WriteMem(tmd_addr + 6, tmd3);
898:
1.1.1.9 root 899: // TMD1 は TXNEXT フェーズで書き戻す
1.1 root 900: tmd1 |= AM7990::TMD1_ERR;
901: }
902:
903: // どちらにしても送信割り込み
904: SetInterrupt(AM7990::CSR0_TINT);
905:
1.1.1.9 root 906: ChangePhase(TXPhase::NEXT);
1.1 root 907: }
908:
909: // TXNEXT フェーズ。次のディスクリプタを指して TXIDLE へ。
910: void
1.1.1.20! root 911: LanceDevice::TXNext(Event *ev)
1.1 root 912: {
1.1.1.9 root 913: tx_phase = TXPhase::NEXT;
914:
1.1 root 915: // このディスクリプタの所有権を放棄
916: tmd1 &= ~AM7990::TMD1_OWN;
917: uint32 tmd_addr = tmd_base + tmd_cur * 8;
918: WriteMem(tmd_addr + 2, tmd1);
919:
1.1.1.9 root 920: // 即、次のディスクリプタの所有を試みる
1.1 root 921: tmd_cur = (tmd_cur + 1) % tmd_num;
1.1.1.9 root 922: ChangePhase(TXPhase::IDLE);
1.1 root 923: }
924:
1.1.1.9 root 925: // 指定時間後に TX フェーズを遷移する。
926: // (変化があれば)変更するではないことに注意。名前がアレだが IDLE フェーズは
927: // ポーリングしているので IDLE から IDLE への遷移も必ず起こす必要がある。
928: // TX か RX かは関数オーバーロードで区別している。
929: void
930: LanceDevice::ChangePhase(TXPhase new_phase, uint64 time)
1.1 root 931: {
1.1.1.20! root 932: tx_event->time = time;
1.1.1.9 root 933: switch (new_phase) {
1.1.1.11 root 934: case TXPhase::STOP:
1.1.1.13 root 935: scheduler->StopEvent(tx_event);
1.1.1.11 root 936: return;
1.1.1.9 root 937: case TXPhase::IDLE:
1.1.1.20! root 938: tx_event->func = ToEventCallback(&LanceDevice::TXIdle);
1.1.1.9 root 939: break;
940: case TXPhase::SEND:
1.1.1.20! root 941: tx_event->func = ToEventCallback(&LanceDevice::TXSend);
1.1.1.9 root 942: break;
943: case TXPhase::NEXT:
1.1.1.20! root 944: tx_event->func = ToEventCallback(&LanceDevice::TXNext);
1.1.1.9 root 945: break;
946: default:
1.1.1.16 root 947: assertmsg(false, "phase %u", (uint)new_phase);
1.1 root 948: }
1.1.1.13 root 949: scheduler->RestartEvent(tx_event);
1.1.1.9 root 950: }
1.1 root 951:
1.1.1.11 root 952: // 受信フェーズ遷移図
953: //
954: // +--------+
955: // | RXSTOP |<- - - (CSR0.STOP 書き込み / リセット)
956: // +--------+
957: // :
1.1.1.15 root 958: // : +‥‥‥+ <‥‥ RxMessage (パケット受信)
1.1.1.11 root 959: // v v :
960: // +-------------+ :
961: // +‥‥‥>| RXIDLE |‥‥+ Idle
962: // : +-------------+
963: // : | | ^
964: // : | | :
965: // : v | :
966: // : +--------+ | +--------+
967: // +‥| RXMISS | | | RXNEXT |
968: // +--------+ | +--------+
969: // | ^ |
970: // | : |
971: // v : v
972: // +-----------+
973: // | RXCOPY | 関数呼び出し ---->
974: // +-----------+ イベントによる遷移 ‥‥>
975:
1.1.1.15 root 976: // パケット受信通知。HostNet から (EthernetDevice 経由で) 呼ばれる。
1.1.1.9 root 977: void
1.1.1.15 root 978: LanceDevice::RxMessage(MessageID msgid, uint32 arg)
1.1.1.9 root 979: {
980: // RXIDLE ポーリングのウェイト中ならすぐに始める。
981: // そうでないときは RXIDLE に戻ったところで処理される。
982: if (rx_phase == RXPhase::IDLE) {
983: ChangePhase(RXPhase::IDLE);
984: }
1.1 root 985: }
986:
987: // RXIDLE 受信アイドルフェーズ。
988: // (最初の)ディスクリプタを所有できるかポーリングする。
989: void
1.1.1.20! root 990: LanceDevice::RXIdle(Event *ev)
1.1 root 991: {
1.1.1.9 root 992: rx_phase = RXPhase::IDLE;
993:
1.1.1.16 root 994: putlog(3, "%s[%u]", __func__, rmd_cur);
1.1.1.9 root 995:
1.1 root 996: // RMD1 を読み込む
997: if ((int32)rmd1_ahead >= 0) {
998: // すでにあればそれを使う
999: rmd1 = rmd1_ahead;
1000: } else {
1001: // 読み込む
1002: uint32 rmd_addr = rmd_base + rmd_cur * 8;
1003: rmd1 = ReadMem(rmd_addr + 2);
1004: }
1005: // どちらにしても先読みバッファは無効に戻す
1006: rmd1_ahead = (uint32)-1;
1007:
1.1.1.9 root 1008: // 受信しているか
1.1.1.11 root 1009: if (hostnet->Rx(&rx_packet)) {
1.1.1.9 root 1010: // その RMD1 に OWN が立っているか
1011: if ((rmd1 & AM7990::RMD1_OWN)) {
1012: // ここが STP になる
1013: rmd1 |= AM7990::RMD1_STP;
1.1.1.11 root 1014: // RXCOPY へ直接移行する。
1015: RXCopy();
1.1.1.9 root 1016: } else {
1.1.1.11 root 1017: // バッファが無いので MISS へ直接移行する。
1.1.1.9 root 1018: // MISS までの時間は受信処理によって表現されているはず
1.1.1.11 root 1019: RXMiss();
1.1.1.9 root 1020: }
1.1 root 1021: } else {
1.1.1.9 root 1022: if ((rmd1 & AM7990::RMD1_OWN)) {
1023: // ここが STP になる
1024: rmd1 |= AM7990::RMD1_STP;
1025: }
1026: // 1.6ms 待って再度 RXIDLE へ。
1027: ChangePhase(RXPhase::IDLE, 1.6_msec);
1.1 root 1028: }
1029: }
1030:
1031: // RXCOPY バッファ処理フェーズ。
1032: // 受信バッファからディスクリプタのバッファに書き込み、
1033: // 書き込みにかかる時間相当分をウェイトする。
1034: void
1.1.1.11 root 1035: LanceDevice::RXCopy()
1.1 root 1036: {
1.1.1.9 root 1037: rx_phase = RXPhase::COPY;
1038:
1.1.1.16 root 1039: putlog(1, "%s[%u]", __func__, rmd_cur);
1.1.1.9 root 1040:
1.1 root 1041: // RMD0, RMD2 は受信することが確定してから読み出す
1042: uint32 rmd_addr = rmd_base + rmd_cur * 8;
1043: uint16 rmd0 = ReadMem(rmd_addr);
1044: uint16 rmd2 = ReadMem(rmd_addr + 4);
1045:
1.1.1.11 root 1046: // アドレスと受信バッファのバイト数。
1.1 root 1047: uint32 bufdst = ((rmd1 & 0x00ff) << 16) | rmd0;
1048: uint32 dst = bufdst;
1.1.1.11 root 1049: // rmd2 は 2 の補数
1050: int32 bcnt = -(int32)(int16)rmd2;
1.1 root 1051:
1.1.1.11 root 1052: if (bcnt < rx_packet.length) {
1.1.1.16 root 1053: putlog(1, "will be remain: %d < %u", bcnt, rx_packet.length);
1.1.1.9 root 1054: }
1055:
1.1.1.11 root 1056: uint8 *src = &rx_packet[0];
1.1.1.16 root 1057: uint remsize = rx_packet.length;
1.1.1.11 root 1058:
1059: if (bcnt > remsize) {
1060: bcnt = remsize;
1061: }
1.1 root 1062:
1.1.1.11 root 1063: // コピー後の残りサイズにしておく
1064: remsize -= bcnt;
1065:
1066: // ローカルの受信バッファからディスクリプタバッファにコピー
1067: for (; bcnt > 0; ) {
1.1 root 1068: // XXX バーストコピー未対応
1069: uint16 data;
1.1.1.11 root 1070: if (bcnt >= 2 && (dst & 1) == 0) {
1.1 root 1071: // 2バイト以上残っててワード境界ならワードアクセス
1.1.1.11 root 1072: if (reg.IsBSWP() == false) {
1073: data = *src++;
1074: data |= (*src++) << 8;
1075: } else {
1076: data = (*src++) << 8;
1077: data |= *src++;
1078: }
1.1 root 1079: WriteMem(dst, data);
1080: dst += 2;
1.1.1.11 root 1081: bcnt -= 2;
1.1 root 1082: } else if ((dst & 1) == 0) {
1083: // 偶数アドレスへ1バイト
1084: // 奇数バイトには不定データが出るらしいがここでは 0 にする
1.1.1.11 root 1085: if (reg.IsBSWP() == false) {
1086: data = *src++;
1087: } else {
1088: data = (*src++) << 8;
1089: }
1.1 root 1090: WriteMem(dst, data);
1091: dst += 1;
1.1.1.11 root 1092: bcnt -= 1;
1.1 root 1093: } else {
1094: // 奇数アドレスへ1バイト
1095: // 偶数バイトには不定データが出るらしいがここでは 0 にする
1.1.1.11 root 1096: if (reg.IsBSWP() == false) {
1097: data = (*src++) << 8;
1098: } else {
1099: data = *src++;
1100: }
1.1 root 1101: WriteMem(dst & ~1, data);
1102: dst += 1;
1.1.1.11 root 1103: bcnt -= 1;
1.1 root 1104: }
1105: }
1106:
1107: // 全部書き出せたらここが ENP
1.1.1.11 root 1108: if (remsize == 0) {
1.1 root 1109: rmd1 |= AM7990::RMD1_ENP;
1110:
1111: // ENP なら MCNT を更新
1112: WriteMem(rmd_addr + 6, (dst - bufdst) & 0xfff);
1.1.1.9 root 1113: } else {
1114: rmd1 &= ~AM7990::RMD1_ENP;
1.1.1.16 root 1115: putlog(1, "copy remain %u", remsize);
1.1.1.11 root 1116:
1117: // 前詰めにコピーする
1118: memmove(&rx_packet[0], src, remsize);
1119: rx_packet.length = remsize;
1.1 root 1120: }
1121:
1122: // メモリへの転送にかかった時間をざっくり計算 XXX まだ適当
1123: // そのウェイト後に RXNEXT フェーズへ。
1.1.1.10 root 1124: uint64 t = 700 * (dst - bufdst) / 16;
1.1.1.9 root 1125: ChangePhase(RXPhase::NEXT, t);
1.1 root 1126: }
1127:
1128: // RXNEXT フェーズ。
1129: // ここが ENP なら、次のディスクリプタを指して RXIDLE へ。
1130: // ENP でなければ、
1131: // - 次のディスクリプタが所有できれば引き続き書き出すため RXCOPY へ。
1132: // - 次のディスクリプタが所有できなければエラーにして RXIDLE へ。
1133: void
1.1.1.20! root 1134: LanceDevice::RXNext(Event *ev)
1.1 root 1135: {
1.1.1.9 root 1136: rx_phase = RXPhase::NEXT;
1137:
1.1.1.16 root 1138: putlog(1, "%s[%u]", __func__, rmd_cur);
1.1 root 1139:
1.1.1.9 root 1140: bool is_chained = false;
1.1 root 1141:
1142: if ((rmd1 & AM7990::RMD1_ENP)) {
1143: // ENP なら、RXIDLE へ。
1.1.1.11 root 1144: rx_packet.Clear();
1.1.1.9 root 1145: ChangePhase(RXPhase::IDLE);
1.1 root 1146: } else {
1147: // 次のディスクリプタを先読み
1148: uint32 rmd_addr = rmd_base + ((rmd_cur + 1) % rmd_num) * 8;
1149: rmd1_ahead = ReadMem(rmd_addr + 2);
1150:
1151: if ((rmd1_ahead & AM7990::RMD1_OWN)) {
1152: // 次ディスクリプタが所有できれば RXCOPY へ。
1.1.1.9 root 1153: is_chained = true;
1.1 root 1154: } else {
1155: // この時点で所有できなければオーバーフロー。
1156: // XXX BUFF と OFLO の違いがよくわからん
1157: rmd1 |= AM7990::RMD1_BUFF | AM7990::RMD1_OFLO;
1158:
1.1.1.11 root 1159: // 書き込み先が無いのでこのパケットは打ち切ってみる
1160: rx_packet.Clear();
1161:
1.1 root 1162: // 次のディスクリプタをポールするため RXIDLE へ。
1.1.1.9 root 1163: ChangePhase(RXPhase::IDLE);
1.1 root 1164: }
1165: }
1166:
1167: // このディスクリプタの所有権を放棄
1168: rmd1 &= ~AM7990::RMD1_OWN;
1169: uint32 rmd_addr = rmd_base + rmd_cur * 8;
1170: WriteMem(rmd_addr + 2, rmd1);
1171:
1172: // 次のディスクリプタへ
1173: rmd_cur = (rmd_cur + 1) % rmd_num;
1174:
1.1.1.11 root 1175: // どちらにしても受信割り込み
1176: SetInterrupt(AM7990::CSR0_RINT);
1177:
1.1.1.9 root 1178: if (is_chained) {
1.1.1.11 root 1179: // 次のディスクリプタがある場合は RXCopy に直接遷移する。
1.1.1.9 root 1180: rmd1 = rmd1_ahead;
1181: rmd1_ahead = -1;
1.1.1.11 root 1182: RXCopy();
1.1.1.9 root 1183: }
1.1 root 1184: }
1185:
1186: // RXMISS 受信失敗処理。
1187: void
1.1.1.11 root 1188: LanceDevice::RXMiss()
1.1 root 1189: {
1.1.1.9 root 1190: rx_phase = RXPhase::MISS;
1191:
1192: putlog(1, "%s", __func__);
1.1 root 1193:
1194: // 受信データがあるのにディスクリプタを所有してなければエラー
1195: SetInterrupt(AM7990::CSR0_MISS | AM7990::CSR0_RINT);
1196:
1197: // 受信データを破棄。
1.1.1.11 root 1198: rx_packet.Clear();
1.1 root 1199:
1200: // そのまますぐにアイドルフェーズに戻るんだろうか
1.1.1.9 root 1201: ChangePhase(RXPhase::IDLE);
1.1 root 1202: }
1203:
1.1.1.18 root 1204: // この宛先アドレスを受信するかどうか。
1205: // これは HostNet スレッドで呼ばれる。
1206: int
1207: LanceDevice::HWAddrFilter(const MacAddr& dstaddr) const
1208: {
1209: if (promisc) {
1210: return HPF_PASS;
1211: }
1212:
1213: if (dstaddr.IsUnicast()) {
1214: if (dstaddr != padr) {
1215: return HPF_DROP_UNICAST;
1216: }
1217: } else {
1218: if (dstaddr.IsBroadcast()) {
1219: return HPF_PASS;
1220: }
1221:
1222: // マルチキャスト。
1223: //
1224: // AM7990 のマルチキャストフィルタ(ハッシュ) は宛先 MAC アドレスの
1225: // CRC (32ビット) のうち、下位6ビット *のビット順を逆順にしたもの*
1226: // を pos として、LADRF の下から pos ビット目が立っていれば受理する
1227: // というもの。
1228: // 31 7 6 5 4 3 2 1 0
1229: // +--- -+---+---+---+---+---+---+---+---+
1230: // CRC32(dstaddr) = | .. | X X | p0| p1| p2| p3| p4| p5|
1231: // +--- -+---+---+---+---+---+---+---+---+
1232: //
1233: // +---+---+---+---+---+---+
1234: // pos = | p5| p4| p3| p2| p1| p0|
1235: // +---+---+---+---+---+---+
1236:
1237: uint32 crc = EthernetDevice::CRC32(dstaddr);
1238: uint pos = bitrev8(crc) >> 2;
1239: bool mcast_pass = (ladrf & (1ULL << pos));
1240: putmsg(2, "mcast %02x:%02x:%02x:%02x:%02x:%02x pos=%u %s",
1241: dstaddr[0], dstaddr[1], dstaddr[2],
1242: dstaddr[3], dstaddr[4], dstaddr[5],
1243: pos, (mcast_pass ? "pass" : "drop"));
1244: if (mcast_pass == false) {
1245: return HPF_DROP_MULTICAST;
1246: }
1247: }
1248:
1249: return HPF_PASS;
1250: }
1251:
1.1.1.9 root 1252: // 指定時間後に RX フェーズを遷移する。
1253: // (変化があれば)変更するではないことに注意。名前がアレだが IDLE フェーズは
1254: // ポーリングしているので IDLE から IDLE への遷移も必ず起こす必要がある。
1255: // TX か RX かは関数オーバーロードで区別している。
1.1 root 1256: void
1.1.1.9 root 1257: LanceDevice::ChangePhase(RXPhase new_phase, uint64 time)
1.1 root 1258: {
1.1.1.20! root 1259: rx_event->time = time;
1.1.1.9 root 1260: switch (new_phase) {
1.1.1.11 root 1261: case RXPhase::STOP:
1.1.1.13 root 1262: scheduler->StopEvent(rx_event);
1.1.1.11 root 1263: return;
1.1.1.9 root 1264: case RXPhase::IDLE:
1.1.1.20! root 1265: rx_event->func = ToEventCallback(&LanceDevice::RXIdle);
1.1.1.9 root 1266: break;
1267: case RXPhase::NEXT:
1.1.1.20! root 1268: rx_event->func = ToEventCallback(&LanceDevice::RXNext);
1.1.1.9 root 1269: break;
1270: default:
1.1.1.16 root 1271: assertmsg(false, "phase %u", (uint)new_phase);
1.1.1.9 root 1272: }
1.1.1.13 root 1273: scheduler->RestartEvent(rx_event);
1.1 root 1274: }
1275:
1.1.1.9 root 1276:
1.1 root 1277: // ビット名文字列配列は [0] が MSB 側の順で並べる
1278:
1279: /*static*/ const char * const LanceDevice::csr0names[] = {
1280: "ERR", "BABL", "CERR", "MISS", "MERR", "RINT", "TINT", "IDON",
1281: "INTR", "INEA", "RXON", "TXON", "TDMD", "STOP", "STRT", "INIT",
1282: };
1283:
1284: /*static*/ const char * const LanceDevice::csr3names[] = {
1.1.1.8 root 1285: "", "", "", "", "", "", "", "",
1.1 root 1286: "", "", "", "", "", "BSWP", "ACON", "BCON",
1287: };
1288:
1289: /*static*/ const char * const LanceDevice::ib_mode_names[] = {
1290: "PROM", "INTL", "DRTY", "COLL", "DTCR", "LOOP", "DTX", "DRX",
1291: };
1292:
1293: /*static*/ const char * const LanceDevice::rmd1_names[] = {
1294: "OWN", "ERR", "FRAM", "OFLO", "CRC", "BUFF", "STP", "ENP",
1295: };
1296:
1297: /*static*/ const char * const LanceDevice::tmd1_names[] = {
1298: "OWN", "ERR", "----", "MORE", "ONE", "DEF", "STP", "ENP",
1299: };
1300:
1301: /*static*/ const char * const LanceDevice::tmd3_names[] = {
1302: "BUFF", "UFLO", "----", "LCOL", "LCAR", "BTRY", "", "",
1303: };
1304:
1305: // bits の立っているビット名を左から MSB->LSB の順で並べて返す
1306: const std::string
1307: LanceDevice::BitToString(const char * const name[], uint16 bits)
1308: {
1309: std::string str;
1310:
1311: while (bits) {
1312: int clz = __builtin_clz(bits) - 16;
1313: if (!str.empty()) {
1314: str += ",";
1315: }
1316: str += name[clz];
1317: bits ^= 1 << (15 - clz);
1318: }
1319: return str;
1320: }
1321:
1322: // CSR0 のビット名を返す
1323: const std::string
1324: LanceDevice::CSR0ToString(uint16 bits)
1325: {
1326: return BitToString(csr0names, bits);
1327: }
1328:
1329: // CSR3 のビット名を返す
1330: const std::string
1331: LanceDevice::CSR3ToString(uint16 bits)
1332: {
1333: return BitToString(csr3names, bits);
1334: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.