USB Mouse 사용하기

 1;31 30       24 23    16 15   11 10    8 7      2 1 0
 2; +-+----------+--------+-------+-------+--------+--+
 3; |1| Reserved | Bus #  | Dev # | Func# | Offset |00|
 4; +-+----------+--------+-------+-------+--------+--+
 5; Bus 0, Device 1, Function 0, Register 0x00 (Vendor ID & Device ID)
 6mov eax, 0x80001000  ; Enable Bit(31) + Bus(0) + Device(1) + Function(0) + Offset(0x00)
 7mov dx, 0xCF8        ; CONFIG_ADDRESS 포트 번호
 8out dx, eax          ; CONFIG_ADDRESS(0xCF8)에 주소 설정
 9; 원하는 정보를 컨트롤러가 세팅해둠
10mov dx, 0xCFC        ; CONFIG_DATA 포트 번호
11in eax, dx           ; CONFIG_DATA(0xCFC)에서 Vendor ID, Device ID 읽기
12mov ebx, eax         ; 결과를 EBX에 저장

1#pragma once
2
3#include <stdint.h>
4
5extern "C" {
6  void IoOut32(uint16_t addr, uint32_t data);
7  uint32_t IoIn32(uint16_t addr);
8}

 1; asmfunc.asm
 2;
 3; System V AMD64 Calling Convention
 4; Registers: RDI, RSI, RDX, RCX, R8, R9
 5
 6bits 64
 7section .text
 8
 9; out 명령은 I/O 포트 주소인 op1 에 op2 의 값을 밀어넣는 명령이다.
10global IoOut32  ; void IoOut32(uint16_t addr, uint32_t data);
11IoOut32:
12    mov dx, di    ; dx = addr
13    mov eax, esi  ; eax = data
14    out dx, eax
15    ret
16
17; in 명령은 I/O 포트 주소인 op1 에서 데이터를 읽어 op2 에 저장하는 명령이다.
18global IoIn32  ; uint32_t IoIn32(uint16_t addr);
19IoIn32:
20    mov dx, di    ; dx = addr
21    in eax, dx
22    ret

 1uint32_t MakeAddress(uint8_t bus, uint8_t device,
 2                      uint8_t function, uint8_t reg_addr) {
 3  auto shl = [](uint32_t x, unsigned int bits) {
 4    return x << bits;
 5  };
 6
 7  return shl(1, 31)
 8      | shl(bus, 16)
 9      | shl(device, 11)
10      | shl(function, 8)
11      | (reg_addr & 0xfcu);    // 레지스터 오프셋 1byte 중 맨 마지막 2bit는 패딩
12}
13
14// 위의 기능들을 모두 합쳐서 원하는 장치의 VendorId를 읽어오는 함수를 구현
15uint16_t ReadVendorId(uint8_t bus, uint8_t device, uint8_t function) {
16  // IoOut32(0xcf8, addr)
17  WriteAddress(MakeAddress(bus, device, function, 0x00))
18  // IoIn32(0xcfc)
19  // 4byte를 LittleEndian 으로 꺼냈지만 하위 2byte만 VendorId 이다.
20  return ReadData() & 0xffffu;   
21}
22
23uint16_t ReadDeviceId(uint8_t bus, uint8_t device, uint8_t function) {
24  WriteAddress(MakeAddress(bus, device, function, 0x00))
25  // VendorId와 같은곳에서 꺼냈지만 상위 2byte만 DeviceId이다. 
26  return ReadData() >> 16;
27}

1uint8_t ReadHeaderType(uint8_t bus, uint8_t device, uint8_t function) {
2  WriteAddress(MakeAddress(bus, device, function, 0x0c));
3  return (ReadData() >> 16) & 0xffu;
4}
5
6bool IsSingleFunctionDevice(uint8_t header_type) {
7  return (header_type & 0x80u) == 0;
8}

1uint32_t ReadBusNumbers(uint8_t bus, uint8_t device, uint8_t function) {
2  WriteAddress(MakeAddress(bus, device, function, 0x18));
3  return ReadData();
4}

1struct Device {
2  uint8_t bus, device, function, header_type;
3};
4
5// 글로벌 변수를 헤더파일에서 정의할땐 inline을 붙인다. (이전에는 extern)
6inline std::array<Device, 32> devices;
7inline int num_device;
8
9Error ScanAllBus();

 1Error ScanAllBus() {
 2  num_device = 0;
 3
 4  auto header_type = ReadHeaderType(0, 0, 0);
 5  uint8_t functions = IsSingleFunctionDevice(header_type) ? 1 : 8;
 6  for (uint8_t function = 0; function < functions; ++function) {
 7    // 싱글펑션은 무조건 0번에 있다.
 8    // 멀티펑션인 경우 펑션은 순서대로라는 보장이 없어서 확인되면 ScanBus 호출
 9    if (ReadVendorId(0, 0, function) == 0xffffu) {
10      continue;
11    }
12    // 멀티펑션인 경우 펑션n은 버스n의 호스트브릿지가 된다고 저자가 주장한다. 
13    if (auto err = ScanBus(function)) {
14      return err;
15    }
16  }
17  return Error::kSuccess;
18}

 1// 디바이스 객체를 생성해서 전역 디바이스 목록에 추가 
 2Error AddDevice(uint8_t bus, uint8_t device,
 3                uint8_t function, uint8_t header_type) {
 4  if (num_device == devices.size()) {
 5    return Error::kFull;
 6  }
 7
 8  devices[num_device] = Device{bus, device, function, header_type};
 9  ++num_device;
10  return Error::kSuccess;
11}
12
13// 펑션(내부칩? 논리적장치?)을 검사해서 발견된 장치 추가
14Error ScanFunction(uint8_t bus, uint8_t device, uint8_t function) {
15  auto header_type = ReadHeaderType(bus, device, function);
16  if (auto err = AddDevice(bus, device, function, header_type)) {
17    return err;
18  }
19
20  auto class_code = ReadClassCode(bus, device, function);
21  uint8_t base = (class_code >> 24) & 0xffu;
22  uint8_t sub = (class_code >> 16) & 0xffu;
23  // 만약 PCI 브릿지 클래스인 경우
24  if (base == 0x06u && sub == 0x04u) {
25    // 세컨더리 버스 번호를 찾아서 재귀적으로 스캔한다.
26    auto bus_numbers = ReadBusNumbers(bus, device, function);
27    uint8_t secondary_bus = (bus_numbers >> 8) & 0xffu;
28    return ScanBus(secondary_bus);
29  }
30
31  return Error::kSuccess;
32}

 1// main.cpp
 2// 전체 버스를 스캔하고, 각 장치의 VendorId, ClassCode, HeaderType을 출력한다.
 3  auto err = pci::ScanAllBus();
 4  printk("ScanAllBus: %s\n", err.Name());
 5
 6  for (int i = 0; i < pci::num_device; ++i) {
 7    const auto& dev = pci::devices[i];
 8    auto vendor_id = pci::ReadVendorId(dev.bus, dev.device, dev.function);
 9    auto class_code = pci::ReadClassCode(dev.bus, dev.device, dev.function);
10    printk("%d.%d.%d: vend %04x, class %08x, head %02x\n",
11        dev.bus, dev.device, dev.function,
12        vendor_id, class_code, dev.header_type);
13  }

 1// main.cpp
 2pci::Device* xhc_dev = nullptr;
 3for (int i = 0; i < pci::num_device; ++i) {
 4  // base 0xc : 시리얼 버스 장치 
 5  // sub  0x3 : USB 장치
 6  // interface 0x30 : xHCI 장치
 7  // 이 세 조건이 맞아야 USB xHCI 장치가 된다. 
 8  if (pci::devices[i].class_code.Match(0x0cu, 0x03u, 0x30u)) {
 9    xhc_dev = &pci::devices[i];
10    // Intel 의 VendorId 가 보이면 break 처리해서 Intel 제품을 우선처리
11    if (0x8086 == pci::ReadVendorId(*xhc_dev)) {
12      break;
13    }
14  }
15}

 1// pci.cpp
 2  constexpr uint8_t CalcBarAddress(unsigned int bar_index) {
 3    // PCI Conf Space의 0x10 부터 시작하며 한개당 4byte 크기
 4    return 0x10 + 4 * bar_index;
 5  }
 6
 7  WithError<uint64_t> ReadBar(Device& device, unsigned int bar_index) {
 8    // 6번 인덱스는 없음. 64bit BAR를 가져오려 해도 인덱스는 0,2,4 로 접근한다. 
 9    if (bar_index >= 6) {
10      return {0, MAKE_ERROR(Error::kIndexOutOfRange)};
11    }
12    const auto addr = CalcBarAddress(bar_index);
13    const auto bar = ReadConfReg(device, addr);   // BAR 값 읽어옴
14
15    // flag 값을 확인해서 3번째 bit가 0이면 32bit BAR로 판단하고 바로 주소값을 리턴
16    if ((bar & 4u) == 0) {
17      return {bar, MAKE_ERROR(Error::kSuccess)};
18    }
19
20    // 64bit BAR는 0,2,4 인덱스밖에 접근할 수 없다.
21    if (bar_index >= 5) {
22      return {0, MAKE_ERROR(Error::kIndexOutOfRange)};
23    }
24
25    // 상위 BAR를 읽어온다 (1,3,5 인덱스)
26    const auto bar_upper = ReadConfReg(device, addr + 4);
27    return {
28      // (상위 BAR << 32) | 하위 BAR
29      bar | (static_cast<uint64_t>(bar_upper) << 32),
30      MAKE_ERROR(Error::kSuccess)
31    };
32  }

1  const WithError<uint64_t> xhc_bar = pci::ReadBar(*xhc_dev, 0);
2  Log(kDebug, "ReadBar: %s\n", xhc_bar.error.Name());
3  // 0xf의 역과 & 하는 이유는 하위 4bit는 플래그 값으로 베이스주소가 오염됐기 때문
4  const uint64_t xhc_mmio_base = xhc_bar.value & ~static_cast<uint64_t>(0xf);
5  Log(kDebug, "xHC mmio_base = %08lx\n", xhc_mmio_base);

 1  usb::xhci::Controller xhc{xhc_mmio_base};
 2  xhc.Run();
 3
 4  usb::HIDMouseDriver::default_observer = MouseObserver;
 5  for (int i = 1; i <= xhc.MaxPorts(); ++i) {
 6    auto port = xhc.PortAt(i);
 7
 8    if (port.IsConnected()) {
 9      if (auto err = ConfigurePort(xhc, port)) {
10        Log(kError, "failed to configure port: %s at %s:%d\n",
11            err.Name(), err.File(), err.Line());
12        continue;
13      }
14    }
15  }
16
17// HID 이벤트를 계속해서 요청하고 처리하는 함수를 호출한다.
18  while (1) {
19    // 이 함수는 xhc와 같은 공간(usb::xhci)에 정의되어 있다
20    if (auto err = ProcessEvent(xhc)) {
21      Log(kError, "Error while ProcessEvent: %s at %s:%d\n",
22          err.Name(), err.File(), err.Line());
23    }
24  }

 1  Error ProcessEvent(Controller& xhc) {
 2    if (!xhc.PrimaryEventRing()->HasFront()) {
 3      return MAKE_ERROR(Error::kSuccess);
 4    }
 5
 6    Error err = MAKE_ERROR(Error::kNotImplemented);
 7    auto event_trb = xhc.PrimaryEventRing()->Front();
 8    if (auto trb = TRBDynamicCast<TransferEventTRB>(event_trb)) {
 9      err = OnEvent(xhc, *trb);
10    } else if (auto trb = TRBDynamicCast<PortStatusChangeEventTRB>(event_trb)) {
11      err = OnEvent(xhc, *trb);
12    } else if (auto trb = TRBDynamicCast<CommandCompletionEventTRB>(event_trb)) {
13      err = OnEvent(xhc, *trb);
14    }
15    xhc.PrimaryEventRing()->Pop();
16
17    return err;
18  }