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