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