dau_driver.macos_xdma¶

Attributes¶

`DEFAULT_BACKEND`
`CANONICAL_SERVICE_NAME`
`DEFAULT_SERVICE_NAMES`
`REGISTER_BAR_INDICES`
`K_METHOD_READ_BAR`
`K_METHOD_WRITE_BAR`
`K_METHOD_DMA_WRITE`
`K_METHOD_DMA_READ`
`K_METHOD_GET_INFO`
`DMA_CHUNK_BYTES`
`MACOS_XDMA_DMA_CONSTRAINTS`

Classes¶

`MacOSXDMAServiceProbe`
`MacOSXDMAProbeResult`
`MacOSXDMAClientProtocol`	Base class for protocol classes.
`MacOSXDMADeviceInfo`
`MacOSXDMATransport`
`MacOSXDMAClient`
`_IOKitBindings`

Functions¶

`_check_bar_access`(bar_index, offset) → None	The user client hands these to the dext as unsigned 64-bit scalars; a
`discover_devices`([client_factory]) → list[dau_driver.device.DauDevice]
`probe_devices`([client_factory, service_names, ...]) → MacOSXDMAProbeResult
`_normalize_service_names`(*[, service_name, service_names]) → tuple[str, ...]
`_probe_status`(devices, clients, service_probes, failures) → str
`_probe_result`(*, status, devices, service_names, ...) → MacOSXDMAProbeResult
`_probe_message`(status, devices, service_names, ...) → str
`_format_service_probe_details`(service_probes) → str
`identify_device`(client, *[, index]) → dau_driver.device.DauDevice
`_find_register_window`(client) → tuple[int, int, int]
`_read_register_block_snapshot`(client, bar_index, ...) → dau_core.registers.RegisterBlockSnapshot
`_read_register`(client, bar_index, ...) → int
`main`([argv]) → int

Module Contents¶

dau_driver.macos_xdma.DEFAULT_BACKEND = 'macos-xdma'¶

dau_driver.macos_xdma.CANONICAL_SERVICE_NAME = 'com.dau-dev.xdma'¶

dau_driver.macos_xdma.DEFAULT_SERVICE_NAMES¶

dau_driver.macos_xdma.REGISTER_BAR_INDICES = (0, 1, 2, 3, 4, 5)¶

dau_driver.macos_xdma.K_METHOD_READ_BAR = 0¶

dau_driver.macos_xdma.K_METHOD_WRITE_BAR = 1¶

dau_driver.macos_xdma.K_METHOD_DMA_WRITE = 2¶

dau_driver.macos_xdma.K_METHOD_DMA_READ = 3¶

dau_driver.macos_xdma.K_METHOD_GET_INFO = 4¶

dau_driver.macos_xdma.DMA_CHUNK_BYTES = 8388608¶

dau_driver.macos_xdma.MACOS_XDMA_DMA_CONSTRAINTS¶

class dau_driver.macos_xdma.MacOSXDMAServiceProbe[source]¶

service_name: str¶

matched_services: int = 0¶

opened_clients: int = 0¶

error: str | None = None¶

class dau_driver.macos_xdma.MacOSXDMAProbeResult[source]¶

status: str¶

devices: tuple[dau_driver.device.DauDevice, ...]¶

service_names: tuple[str, ...]¶

service_probes: tuple[MacOSXDMAServiceProbe, ...]¶

failures: tuple[str, ...]¶

message: str¶

dau_driver.macos_xdma._check_bar_access(bar_index: int, offset: int) → None[source]¶: The user client hands these to the dext as unsigned 64-bit scalars; a negative offset would wrap to a huge one and address BAR space the caller never meant to touch.

class dau_driver.macos_xdma.MacOSXDMAClientProtocol[source]¶

Bases: Protocol

Base class for protocol classes.

Protocol classes are defined as:

class Proto(Protocol):
    def meth(self) -> int:
        ...

Such classes are primarily used with static type checkers that recognize structural subtyping (static duck-typing).

For example:

class C:
    def meth(self) -> int:
        return 0

def func(x: Proto) -> int:
    return x.meth()

func(C())  # Passes static type check

See PEP 544 for details. Protocol classes decorated with @typing.runtime_checkable act as simple-minded runtime protocols that check only the presence of given attributes, ignoring their type signatures. Protocol classes can be generic, they are defined as:

class GenProto[T](Protocol):
    def meth(self) -> T:
        ...

read_bar_u32(bar_index: int, offset: int) → int[source]¶

write_bar_u32(bar_index: int, offset: int, value: int) → None[source]¶

get_info() → MacOSXDMADeviceInfo[source]¶

dma_read(device_offset: int, length: int) → bytes[source]¶

dma_write(device_offset: int, data: bytes | bytearray | memoryview) → int[source]¶

close() → None[source]¶

class dau_driver.macos_xdma.MacOSXDMADeviceInfo[source]¶

vendor_id: int¶

device_id: int¶

subsystem_vendor_id: int¶

subsystem_device_id: int¶

class dau_driver.macos_xdma.MacOSXDMATransport[source]¶

client: MacOSXDMAClientProtocol¶

bar_index: int¶

read_u32(offset: int) → int[source]¶

write_u32(offset: int, value: int) → None[source]¶

read_dma(device_address: int, byte_count: int) → bytes[source]¶

write_dma(device_address: int, data: bytes | bytearray | memoryview) → int[source]¶

close() → None[source]¶

class dau_driver.macos_xdma.MacOSXDMAClient[source]¶

connection: int¶

service: int¶

bindings: _IOKitBindings¶

classmethod open_all(*, service_name: str | None = None, service_names: collections.abc.Sequence[str] | None = None) → tuple[MacOSXDMAClient, ...][source]¶

classmethod open_candidates(*, service_name: str | None = None, service_names: collections.abc.Sequence[str] | None = None) → tuple[tuple[MacOSXDMAClient, ...], tuple[MacOSXDMAServiceProbe, ...]][source]¶

classmethod _open_service_name(bindings: _IOKitBindings, service_name: str, seen_services: set[int]) → tuple[tuple[MacOSXDMAClient, ...], MacOSXDMAServiceProbe][source]¶

read_bar_u32(bar_index: int, offset: int) → int[source]¶

write_bar_u32(bar_index: int, offset: int, value: int) → None[source]¶

get_info() → MacOSXDMADeviceInfo[source]¶

dma_read(device_offset: int, length: int) → bytes[source]¶

dma_write(device_offset: int, data: bytes | bytearray | memoryview) → int[source]¶

close() → None[source]¶

class dau_driver.macos_xdma._IOKitBindings[source]¶

iokit: ctypes.CDLL¶

libsystem: ctypes.CDLL¶

classmethod load() → _IOKitBindings[source]¶

_configure_signatures() → None[source]¶

call_struct_in(connection: int, selector: int, scalars: collections.abc.Sequence[int], data: bytes | bytearray | memoryview) → None[source]¶

call_struct_out(connection: int, selector: int, scalars: collections.abc.Sequence[int], output_size: int) → bytes[source]¶

matching_iterators(service_name: str) → tuple[int, ...][source]¶

_matching_iterator(matcher_name: str, service_name: str) → int[source]¶

next_service(iterator: int) → int[source]¶

open_service(service: int) → int[source]¶

call_scalar(connection: int, selector: int, inputs: collections.abc.Sequence[int], output_count: int) → tuple[int, ...][source]¶

close(connection: int) → None[source]¶

release(obj: int) → None[source]¶

mach_task_self() → int[source]¶

dau_driver.macos_xdma.discover_devices(client_factory: collections.abc.Callable[[], collections.abc.Iterable[MacOSXDMAClientProtocol]] | None = None) → list[dau_driver.device.DauDevice][source]¶

dau_driver.macos_xdma.probe_devices(client_factory: collections.abc.Callable[[], collections.abc.Iterable[MacOSXDMAClientProtocol]] | None = None, *, service_names: collections.abc.Sequence[str] = DEFAULT_SERVICE_NAMES, service_probes: collections.abc.Sequence[MacOSXDMAServiceProbe] = ()) → MacOSXDMAProbeResult[source]¶

dau_driver.macos_xdma._normalize_service_names(*, service_name: str | None = None, service_names: collections.abc.Sequence[str] | None = None) → tuple[str, ...][source]¶

dau_driver.macos_xdma._probe_status(devices: tuple[dau_driver.device.DauDevice, ...], clients: tuple[MacOSXDMAClientProtocol, ...], service_probes: tuple[MacOSXDMAServiceProbe, ...], failures: tuple[str, ...]) → str[source]¶

dau_driver.macos_xdma._probe_result(*, status: str, devices: tuple[dau_driver.device.DauDevice, ...], service_names: tuple[str, ...], service_probes: tuple[MacOSXDMAServiceProbe, ...], failures: tuple[str, ...]) → MacOSXDMAProbeResult[source]¶

dau_driver.macos_xdma._probe_message(status: str, devices: tuple[dau_driver.device.DauDevice, ...], service_names: tuple[str, ...], service_probes: tuple[MacOSXDMAServiceProbe, ...], failures: tuple[str, ...]) → str[source]¶

dau_driver.macos_xdma._format_service_probe_details(service_probes: collections.abc.Sequence[MacOSXDMAServiceProbe]) → str[source]¶

dau_driver.macos_xdma.identify_device(client: MacOSXDMAClientProtocol, *, index: int = 0) → dau_driver.device.DauDevice[source]¶

dau_driver.macos_xdma._find_register_window(client: MacOSXDMAClientProtocol) → tuple[int, int, int][source]¶

dau_driver.macos_xdma._read_register_block_snapshot(client: MacOSXDMAClientProtocol, bar_index: int, register_window_offset: int) → dau_core.registers.RegisterBlockSnapshot[source]¶

dau_driver.macos_xdma._read_register(client: MacOSXDMAClientProtocol, bar_index: int, register_window_offset: int, offset: dau_core.registers.RegisterOffset) → int[source]¶

dau_driver.macos_xdma.main(argv: collections.abc.Sequence[str] | None = None) → int[source]¶