/* UART 프레임을 비트로 짓고, *보율이 어긋난 수신기*로 다시 읽어 본다.
   하드웨어는 없다 --- 선 위의 전압을 잘게 썬 배열로 흉내 낸다.
   한 비트를 16칸으로 나누어(흔한 UART 가 정말 이렇게 샘플링한다) 시간을 표현한다. */
#include <stdio.h>
#include <stdint.h>
#include <string.h>

#define OS      16u        /* oversampling --- 한 비트를 몇 칸으로 나눌까 */
#define MAXW    4096u

/* 8N1: 시작 1 + 자료 8 + 정지 1 = 10비트. 자료는 *낮은 자리부터* 나간다. */
static size_t make_frame(unsigned char *w, uint8_t byte, unsigned parity_bits)
{
    size_t n = 0;
    for (unsigned i = 0; i < OS * 2; i++) w[n++] = 1;      /* 놀고 있을 때는 높다 */
    for (unsigned i = 0; i < OS; i++)     w[n++] = 0;      /* 시작 비트: 떨어뜨린다 */
    unsigned ones = 0;
    for (int b = 0; b < 8; b++) {
        unsigned bit = byte >> b & 1;                       /* LSB first */
        ones += bit;
        for (unsigned i = 0; i < OS; i++) w[n++] = (unsigned char)bit;
    }
    if (parity_bits) {                                      /* 짝수 패리티라면 */
        unsigned p = ones & 1;                              /* 1의 개수를 짝수로 맞춘다 */
        for (unsigned i = 0; i < OS; i++) w[n++] = (unsigned char)p;
    }
    for (unsigned i = 0; i < OS; i++)     w[n++] = 1;      /* 정지 비트: 다시 높다 */
    for (unsigned i = 0; i < OS * 2; i++) w[n++] = 1;
    return n;
}

/* 수신기: 시작 비트의 내려감을 찾고, 제 비트 길이로 한가운데를 찍어 읽는다.
   rx_bit 이 16 이 아니면 그만큼 보율이 어긋난 것이다. */
static int receive(const unsigned char *w, size_t n, double rx_bit,
                   uint8_t *out, int *stop_ok)
{
    size_t edge = 0;
    while (edge < n && w[edge] != 0) edge++;                /* 내려가는 자리 */
    if (edge >= n) return -1;

    double t0 = (double)edge;
    uint8_t v = 0;
    for (int b = 0; b < 8; b++) {
        double at = t0 + rx_bit * (b + 1) + rx_bit / 2.0;   /* (b+1)번째 비트의 한가운데 */
        size_t idx = (size_t)(at + 0.5);
        if (idx >= n) return -1;
        v |= (uint8_t)(w[idx] << b);
    }
    double sat = t0 + rx_bit * 9 + rx_bit / 2.0;            /* 정지 비트 자리 */
    *stop_ok = (sat < n) && w[(size_t)(sat + 0.5)] == 1;
    *out = v;
    return 0;
}

static void show_wave(const unsigned char *w, size_t n)
{
    printf("  ");
    for (size_t i = 0; i < n; i += OS / 2) putchar(w[i] ? '-' : '_');
    printf("\n  ");
    /* 비트 경계에 이름을 붙인다 */
    const char *lab[] = { "  ", "  ", "St", "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7", "Sp", "  ", "  " };
    for (size_t i = 0, k = 0; i < n; i += OS, k++)
        printf("%-*s", (int)(OS / (OS / 2)), k < sizeof lab / sizeof *lab ? lab[k] : "  ");
    printf("\n");
}

int main(void)
{
    unsigned char w[MAXW];
    const uint8_t byte = 'K';       /* 0x4B = 0100 1011 */

    printf("== the byte to send ==\n");
    printf("  '%c' = 0x%02X = binary %c%c%c%c%c%c%c%c (most significant first)\n\n", byte, byte,
           "01"[byte >> 7 & 1], "01"[byte >> 6 & 1], "01"[byte >> 5 & 1], "01"[byte >> 4 & 1],
           "01"[byte >> 3 & 1], "01"[byte >> 2 & 1], "01"[byte >> 1 & 1], "01"[byte & 1]);

    size_t n = make_frame(w, byte, 0);
    printf("== the shape on the wire (8N1) --- low=_ high=- ==\n");
    show_wave(w, n);
    printf("  * data goes least significant bit first, so it looks reversed to the eye.\n\n");

    printf("== timing ==\n");
    printf("  %-10s %-14s %-14s %s\n", "baud", "one bit", "one frame (10 bits)", "bytes per second");
    const long bauds[] = { 300, 9600, 19200, 115200, 921600 };
    for (unsigned i = 0; i < sizeof bauds / sizeof *bauds; i++) {
        double bit_us = 1e6 / (double)bauds[i];
        printf("  %-10ld %-14.3f %-14.1f %.0f\n", bauds[i], bit_us, bit_us * 10,
               (double)bauds[i] / 10.0);
    }
    printf("  (microseconds. 8N1 spends 10 bits on one byte, so 20%% is overhead)\n\n");

    printf("== when the receiver's baud rate is off ==\n");
    printf("  the receiver samples the middle using its own bit length; the error shifts it.\n\n");
    printf("  %-12s %-10s %-8s %-8s %s\n", "rx baud", "error", "value read", "stop bit", "result");
    struct { const char *name; double factor; } rx[] = {
        { "9600",   1.00 }, { "9700",   9600.0 / 9700 }, { "9900", 9600.0 / 9900 },
        { "10100",  9600.0 / 10100 }, { "10600", 9600.0 / 10600 }, { "19200", 9600.0 / 19200 },
    };
    for (unsigned i = 0; i < sizeof rx / sizeof *rx; i++) {
        uint8_t got; int stop_ok;
        double rx_bit = OS * rx[i].factor;
        if (receive(w, n, rx_bit, &got, &stop_ok) != 0) { printf("  %-12s could not read\n", rx[i].name); continue; }
        double err = (1.0 / rx[i].factor - 1.0) * 100.0;
        printf("  %-12s %+7.1f%%  0x%02X     %-8s %s\n", rx[i].name, err, got,
               stop_ok ? "ok" : "broken",
               got == byte && stop_ok ? "'K' --- correct"
               : got == byte ? "value right, frame lost"
               : "character corrupted");
    }

    /* 임계점을 *찾아본다* --- 통설을 옮겨 적는 대신 프로그램이 재게 한다 */
    double lo = 0, hi = 0;
    for (double e = -20.0; e <= 20.0; e += 0.05) {
        double rx_bit = OS / (1.0 + e / 100.0);
        uint8_t g; int ok;
        int good = receive(w, n, rx_bit, &g, &ok) == 0 && g == byte && ok;
        if (good && lo == 0 && hi == 0) lo = e;
        if (good) hi = e;
    }
    printf("\n  range of error where the character survives here: %+.1f%% to %+.1f%%\n", lo, hi);
    printf("  * the arithmetic agrees. The stop bit is sampled at 9.5 bit times,\n");
    printf("    and that instant must fall within that bit (one bit wide), so\n");
    printf("    0.5 / 9.5 = %.1f%% is the margin on one side.\n", 0.5 / 9.5 * 100.0);
    printf("  * yet practice uses 2 to 3%% as the rule. This %.1f%% is shared by both ends\n",
           0.5 / 9.5 * 100.0);
    printf("    (the sender drifts too), oscillators move with temperature and supply,\n");
    printf("    and a real receiver samples three points and takes a majority.\n");
    printf("    The theoretical limit and the design budget are different numbers.\n");

    printf("\n== what parity catches ==\n");
    size_t np = make_frame(w, byte, 1);
    uint8_t got; int stop_ok;
    receive(w, np, OS, &got, &stop_ok);
    unsigned ones = 0; for (int b = 0; b < 8; b++) ones += byte >> b & 1;
    printf("  '%c' has %u ones -> even parity bit = %u\n", byte, ones, ones & 1);
    printf("  one flipped bit changes the parity, so it is caught.\n");
    printf("  two flipped bits leave the parity unchanged, so it is not --- parity\n");
    printf("  is a device for noticing an error, not for correcting one.\n");
    return 0;
}

/* I2C 거래 하나를 신호 차례로 짓고, 그 차례를 다시 읽어 해독한다.
   선은 둘뿐이다: SCL(클록)과 SDA(자료). 둘 다 「끌어내리기만」 할 수 있다(오픈 드레인). */
#include <stdio.h>
#include <stdint.h>
#include <string.h>

enum { EV_START, EV_BIT, EV_ACK, EV_NACK, EV_RSTART, EV_STOP };

struct ev { int kind; int val; const char *note; };

static struct ev log_[256];
static int n_ev;

static void put(int kind, int val, const char *note)
{ log_[n_ev++] = (struct ev){ kind, val, note }; }

/* 바이트 하나 --- 높은 자리부터 여덟 비트, 그다음 아홉 번째 클록이 ACK 자리 */
static void put_byte(uint8_t b, const char *what, int acked)
{
    for (int i = 7; i >= 0; i--) put(EV_BIT, b >> i & 1, i == 7 ? what : NULL);
    put(acked ? EV_ACK : EV_NACK, acked ? 0 : 1, NULL);
}

static const char *kind_name(int k)
{
    switch (k) {
    case EV_START:  return "START";
    case EV_RSTART: return "repeated START";
    case EV_STOP:   return "STOP";
    case EV_ACK:    return "ACK";
    case EV_NACK:   return "NACK";
    default:        return "bits";
    }
}

int main(void)
{
    const uint8_t dev = 0x3C;      /* 7비트 장치 주소 */
    const uint8_t reg = 0x00, val = 0xAF;

    printf("== why the address is confusing ==\n");
    printf("  the 7-bit address 0x%02X is shifted one place on the wire (last bit is read/write).\n", dev);
    printf("    write: 0x%02X << 1 | 0 = 0x%02X\n", dev, dev << 1);
    printf("    read : 0x%02X << 1 | 1 = 0x%02X\n", dev, dev << 1 | 1);
    printf("  so datasheets call the same device 0x%02X in one place and 0x%02X in another.\n\n",
           dev, dev << 1);

    /* ── 쓰기 거래: 장치에게 「레지스터 0 에 0xAF 를 써라」 ── */
    put(EV_START, 0, "the controller takes the bus");
    put_byte((uint8_t)(dev << 1 | 0), "device address + write", 1);
    put_byte(reg, "register number", 1);
    put_byte(val, "value to write", 1);
    put(EV_STOP, 0, "release the bus");

    /* ── 읽기 거래: 반복 START 로 방향만 바꾼다 ── */
    put(EV_START, 0, "take it again");
    put_byte((uint8_t)(dev << 1 | 0), "device address + write", 1);
    put_byte(reg, "say which register to read first", 1);
    put(EV_RSTART, 0, "* START again without STOP --- nobody can cut in meanwhile");
    put_byte((uint8_t)(dev << 1 | 1), "device address + read", 1);
    put_byte(val, "the value the device returned", 0);   /* 마지막 바이트는 주인이 NACK 로 끝을 알린다 */
    put(EV_STOP, 0, "end");

    printf("== the order on the wire ==\n");
    int bitpos = 0; uint8_t acc = 0;
    for (int i = 0; i < n_ev; i++) {
        struct ev *e = &log_[i];
        if (e->kind == EV_BIT) {
            acc = (uint8_t)(acc << 1 | e->val);
            if (++bitpos == 8) {
                printf("  %-12s 0x%02X  %s\n", "byte", acc,
                       log_[i - 7].note ? log_[i - 7].note : "");
                bitpos = 0; acc = 0;
            }
        } else {
            printf("  %-12s %s%s\n", kind_name(e->kind),
                   e->kind == EV_ACK ? "the device pulled SDA down = received" :
                   e->kind == EV_NACK ? "nobody pulled it down = absent, or done" : "",
                   e->note ? e->note : "");
        }
    }

    printf("\n== what means what ==\n");
    printf("  START : SDA falls while SCL is high   (deliberately breaking the rule that\n");
    printf("  STOP  : SDA rises while SCL is high    data changes only while SCL is low)\n");
    printf("  ACK   : on the ninth clock the receiver pulls SDA down\n");
    printf("  NACK  : nobody pulls it down and the line stays high --- absent and enough look alike\n");

    printf("\n== timing ==\n");
    int bits = 0, extra = 0;
    for (int i = 0; i < n_ev; i++)
        (log_[i].kind == EV_BIT) ? bits++ : (log_[i].kind == EV_ACK || log_[i].kind == EV_NACK) ? bits++ : extra++;
    printf("  clocks in these two transactions: %d (data and ACK bits), %d markers\n", bits, extra);
    printf("  %-14s %-14s %s\n", "speed mode", "clock", "time for these two transactions");
    struct { const char *name; double hz; } modes[] = {
        { "standard", 100e3 }, { "fast", 400e3 }, { "fast plus", 1e6 }, { "high speed", 3.4e6 },
    };
    for (unsigned i = 0; i < sizeof modes / sizeof *modes; i++)
        printf("  %-14s %-14.1f %.1f microseconds\n", modes[i].name, modes[i].hz / 1000,
               bits / modes[i].hz * 1e6);
    printf("  (clock in kHz; markers and wait states are not counted)\n");

    printf("\n== why the lines are only ever pulled down ==\n");
    printf("  if two devices speak at once, one pushing 5V and one pushing 0V, current\n");
    printf("  flows straight through and damages the chips. I2C lets nobody push (open drain)\n");
    printf("  and leaves the raising to a resistor. So speaking at once is safe,\n");
    printf("  and the property that zero wins gives arbitration and ACK for free.\n");
    return 0;
}

/* SPI 는 「고리 모양으로 이어 붙인 시프트 레지스터 둘」이다.
   클록마다 한 비트씩 서로 밀어 넣는다 --- 그래서 주고받기가 *동시에* 일어난다. */
#include <stdio.h>
#include <stdint.h>

static void bits8(uint8_t v, char *out)
{ for (int i = 0; i < 8; i++) out[i] = (char)('0' + (v >> (7 - i) & 1)); out[8] = 0; }

int main(void)
{
    uint8_t m = 0xA5;      /* 주인이 보낼 값 */
    uint8_t s = 0x3C;      /* 장치가 보낼 값 (미리 제 레지스터에 넣어 둔다) */
    char mb[9], sb[9];

    bits8(m, mb); bits8(s, sb);
    printf("== at the start ==\n");
    printf("  controller register : 0x%02X (%s)\n", m, mb);
    printf("  device register     : 0x%02X (%s)\n\n", s, sb);

    printf("== one bit per clock ==\n");
    printf("  %-6s %-6s %-6s %-12s %-12s\n", "clock", "MOSI", "MISO", "controller", "device");
    for (int c = 1; c <= 8; c++) {
        unsigned mosi = m >> 7 & 1;          /* 주인이 내놓는 비트 (높은 자리부터) */
        unsigned miso = s >> 7 & 1;          /* 장치가 내놓는 비트 */
        m = (uint8_t)(m << 1 | miso);        /* 서로의 비트를 낮은 자리로 받아 넣는다 */
        s = (uint8_t)(s << 1 | mosi);
        bits8(m, mb); bits8(s, sb);
        printf("  %-6d %-6u %-6u %-12s %-12s\n", c, mosi, miso, mb, sb);
    }

    printf("\n== after eight clocks ==\n");
    printf("  controller register : 0x%02X  <- what the device sent\n", m);
    printf("  device register     : 0x%02X  <- what the controller sent\n", s);
    printf("  * sending and receiving finished in the same eight clocks. Full duplex is\n");
    printf("    free because the two registers form one ring. Even with nothing to receive\n");
    printf("    something must be sent (usually 0x00 or 0xFF): a dummy byte.\n");

    printf("\n== the four modes --- which edge presents, which samples ==\n");
    printf("  %-8s %-6s %-6s %-16s %s\n", "mode", "CPOL", "CPHA", "SCK at rest", "sampling edge");
    for (int mode = 0; mode < 4; mode++) {
        int cpol = mode >> 1, cpha = mode & 1;
        printf("  %-8d %-6d %-6d %-16s %s\n", mode, cpol, cpha,
               cpol ? "high" : "low",
               cpha == 0 ? (cpol ? "falling (first edge)" : "rising (first edge)")
                         : (cpol ? "rising (second edge)" : "falling (second edge)"));
    }

    printf("\n== when the mode is mismatched ==\n");
    uint8_t src = 0xA5, wrong = 0, prev = 0;
    for (int c = 0; c < 8; c++) {
        unsigned bit = src >> (7 - c) & 1;
        wrong = (uint8_t)(wrong << 1 | prev);   /* 한 모서리 늦게 읽으면 *직전* 비트를 본다 */
        prev = bit;
    }
    bits8(0xA5, mb); bits8(wrong, sb);
    printf("  sent 0xA5 (%s)\n", mb);
    printf("  read with one edge of error: 0x%02X (%s)  <- everything shifted one place\n", wrong, sb);
    printf("  * so when SPI gives half-right values, suspect the mode first.\n");

    printf("\n== speed ==\n");
    printf("  SPI has no start, stop, address or ACK. Exactly eight clocks per byte.\n");
    printf("  %-14s %-16s %s\n", "SCK", "bytes per second", "compared");
    struct { const char *name; double hz; } sck[] = {
        { "1 MHz", 1e6 }, { "10 MHz", 10e6 }, { "50 MHz", 50e6 },
    };
    const double i2c_std = 100e3 / 9.0;      /* I2C 표준 모드: 바이트마다 9비트 */
    for (unsigned i = 0; i < sizeof sck / sizeof *sck; i++)
        printf("  %-14s %-16.0f %.0f times I2C standard (100 kHz)\n", sck[i].name, sck[i].hz / 8,
               (sck[i].hz / 8) / i2c_std);
    printf("  (UART spends 10 bits per byte, I2C 9, SPI 8 --- no overhead)\n");
    return 0;
}

/* PCI 설정 공간(256바이트)을 필드대로 짓고 되읽는다. 그리고 BAR 의 *크기를 알아내는*
   고전적인 수법 --- 전부 1을 써 보고 되읽기 --- 을 장치 흉내로 재현한다. */
#include <stdio.h>
#include <stdint.h>
#include <string.h>

static unsigned char cfg[256];
/* 각 BAR 가 실제로 요구하는 크기. 장치가 하드웨어로 정해 두는 값이다. */
static uint32_t bar_size[6] = { 16u << 20, 0, 256u << 20, 0, 0, 256 };
static int bar_is_io[6]     = { 0, 0, 0, 0, 0, 1 };
static int bar_is_64[6]     = { 0, 0, 1, 0, 0, 0 };   /* BAR2+3 이 짝을 이룬다 */

static uint32_t rd32(unsigned off)
{ uint32_t v = 0; for (int i = 3; i >= 0; i--) v = v << 8 | cfg[off + i]; return v; }
static void wr32(unsigned off, uint32_t v)
{ for (int i = 0; i < 4; i++) cfg[off + i] = (unsigned char)(v >> (8 * i)); }
static uint16_t rd16(unsigned off) { return (uint16_t)(cfg[off] | cfg[off + 1] << 8); }

/* 장치 흉내: BAR 에 값을 쓰면, 크기보다 낮은 비트는 장치가 *0 으로 굳혀* 돌려준다. */
static void bar_write(int i, uint32_t v)
{
    unsigned off = 0x10 + 4u * (unsigned)i;
    uint32_t low = bar_is_io[i] ? 1u : (uint32_t)(bar_is_64[i] ? 0x4 : 0x0);
    uint32_t mask = ~(bar_size[i] - 1);
    wr32(off, (v & mask) | low);
}

int main(void)
{
    /* ── 머리말 필드 ── */
    wr32(0x00, 0x10FA8086u);           /* 0x00 제조사 0x8086, 0x02 장치 0x10FA */
    wr32(0x04, 0x00100007u);           /* 0x04 명령: 메모리·IO·버스마스터 켬 / 0x06 상태 */
    wr32(0x08, 0x02000003u);           /* 0x08 개정 03, 0x09~0x0B 분류: 02 00 00 = 이더넷 */
    wr32(0x0C, 0x00000010u);           /* 0x0C 캐시줄 16, 0x0E 머리말 종류 0 */
    for (int i = 0; i < 6; i++)
        if (bar_size[i])
            /* 입출력 공간은 64 KiB 짜리 좁은 세계라 주소도 작다(옛 x86 의 흔적) */
            bar_write(i, bar_is_io[i] ? 0xC000u : 0xF0000000u + (uint32_t)i * 0x1000000u);
    wr32(0x2C, 0x00108086u);           /* 하위 시스템 */
    cfg[0x34] = 0x50;                  /* 능력 목록의 첫 자리 */
    cfg[0x3C] = 11;                    /* 인터럽트 선 (옛 방식) */
    cfg[0x3D] = 1;                     /* 인터럽트 핀 A */
    /* 능력 목록: MSI(0x05) → PCIe(0x10) → 끝 */
    cfg[0x50] = 0x05; cfg[0x51] = 0x60;
    cfg[0x60] = 0x10; cfg[0x61] = 0x00;

    printf("== configuration space header (type 0) ==\n");
    printf("  %-8s %-6s %-18s %s\n", "offset", "size", "name", "value");
    printf("  0x00     2      vendor ID          0x%04X%s\n", rd16(0x00),
           rd16(0x00) == 0x8086 ? " (Intel)" : "");
    printf("  0x02     2      device ID          0x%04X\n", rd16(0x02));
    printf("  0x04     2      command            0x%04X  [IO %s · memory %s · bus master %s]\n",
           rd16(0x04), rd16(0x04) & 1 ? "on" : "off", rd16(0x04) & 2 ? "on" : "off",
           rd16(0x04) & 4 ? "on" : "off");
    printf("  0x06     2      status             0x%04X  [capability list %s]\n", rd16(0x06),
           rd16(0x06) & 0x10 ? "present" : "absent");
    printf("  0x08     1      revision           0x%02X\n", cfg[0x08]);
    printf("  0x09-0B  3      class              %02X %02X %02X = %s\n",
           cfg[0x0B], cfg[0x0A], cfg[0x09],
           cfg[0x0B] == 0x02 ? "network controller (Ethernet)" : "other");
    printf("  0x0E     1      header type        0x%02X  (0=device, 1=bridge)\n", cfg[0x0E]);
    printf("  0x34     1      capability pointer 0x%02X\n", cfg[0x34]);
    printf("  0x3C-3D  2      interrupt line/pin %u / %c\n\n", cfg[0x3C], 'A' + cfg[0x3D] - 1);

    printf("== decoding the BARs ==\n");
    printf("  %-6s %-14s %-12s %-10s %s\n", "BAR", "raw value", "kind", "note", "base address");
    for (int i = 0; i < 6; i++) {
        uint32_t v = rd32(0x10 + 4u * (unsigned)i);
        if (v == 0) { printf("  BAR%-3d (unused)\n", i); continue; }
        if (v & 1) {
            printf("  BAR%-3d 0x%08X     %-12s %-10s 0x%08X\n", i, v, "I/O space", "---",
                   v & ~0x3u);
        } else {
            const char *w = ((v >> 1) & 3) == 2 ? "64-bit" : "32-bit";
            printf("  BAR%-3d 0x%08X     %-12s %-10s 0x%08X\n", i, v, "memory space",
                   w, v & ~0xFu);
            if (((v >> 1) & 3) == 2) { printf("  BAR%-3d (upper 32 bits of the BAR above)\n", i + 1); i++; }
        }
    }

    printf("\n== how the size is found --- write all ones and read back ==\n");
    printf("  a device holds the bits below its requested size at zero.\n");
    printf("  so write all ones and the zeros read back tell you the size.\n\n");
    for (int i = 0; i < 6; i++) {
        if (!bar_size[i]) continue;
        unsigned off = 0x10 + 4u * (unsigned)i;
        uint32_t saved = rd32(off);
        bar_write(i, 0xFFFFFFFFu);                 /* ① 전부 1을 쓴다 */
        uint32_t probe = rd32(off);                /* ② 되읽는다 */
        uint32_t mask = probe & (bar_is_io[i] ? ~0x3u : ~0xFu);
        uint32_t size = ~mask + 1;                 /* ③ 뒤집고 1을 더하면 크기 */
        bar_write(i, saved);                       /* ④ 원래 값을 되돌려 놓는다 */
        printf("  BAR%d: read back 0x%08X -> size %u bytes (%s)  %s\n", i, probe, size,
               size >= (1u << 20) ? "in MiB" : size >= 1024 ? "in KiB" : "bytes",
               size == bar_size[i] ? "matches what the device asked for" : "does not match");
    }
    printf("\n  * these four steps are what real firmware and kernels do. Forget the last one\n");
    printf("    (restoring) and the device lands at the wrong address and the machine hangs.\n");

    printf("\n== walking the capability list ==\n");
    unsigned p = cfg[0x34];
    while (p) {
        unsigned id = cfg[p], next = cfg[p + 1];
        printf("  0x%02X: capability 0x%02X (%s) -> next 0x%02X\n", p, id,
               id == 0x05 ? "MSI --- an interrupt sent as a memory write" :
               id == 0x10 ? "PCI Express" : "other", next);
        p = next;
    }
    printf("  * it is a linked list. Zero means the end --- following the chain tells you\n");
    printf("    what this device knows how to do.\n");
    return 0;
}