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