@johntalton/ftdi 1.0.0

package/src/ftdi.ts

@@ -0,0 +1,215 @@
+/** biome-ignore-all lint/style/noNestedTernary: <explanation> */
+import type { BitMode, ModemControl, RequestType } from './consts.ts'
+import { REQUESTS, RESET_USB } from './consts.ts'
+import { MPSSE } from './mpsse/mpsse.ts'
+import {
+	DeviceStatus,
+	type DeviceStatusInfo,
+	STATUS_PREFIX_LENGTH,
+} from './status.ts'
+
+export const USB_TRANSFER_OK: USBTransferStatus = 'ok'
+export const USB_TRANSFER_STALL: USBTransferStatus = 'stall'
+export const USB_TRANSFER_BABBLE: USBTransferStatus = 'babble'
+
+
+export const REQUEST_TYPE_VENDOR = 'vendor'
+export const RECIPIENT_DEVICE = 'device'
+
+export const INTERFACE_DIRECTION_IN = 'in'
+export const INTERFACE_DIRECTION_OUT = 'out'
+export const INTERFACE_TYPE_BULK = 'bulk'
+
+export const DEFAULT_CONFIGURATION_NUMBER = 1
+export const DEFAULT_INTERFACE_NUMBER = 0
+
+
+export function assertDataViewNotShared(view: DataView): asserts view is DataView & { buffer: ArrayBuffer } {
+	if (typeof SharedArrayBuffer !== 'undefined' && view.buffer instanceof SharedArrayBuffer) {
+		throw new TypeError('DataView cannot be backed by a SharedArrayBuffer')
+	}
+}
+
+export class FTDIDevice {
+	readonly #device
+	readonly #endpointBulkIn: number
+	readonly #endpointBulkOut: number
+	readonly #interfaceNumber: number
+	readonly #mpsse: MPSSE
+
+	static async from(device: USBDevice): Promise<FTDIDevice> {
+		const { interfaceNumber, epIn, epOut } = await FTDIDevice.#discoverEndpoints(device)
+		return new FTDIDevice(device, interfaceNumber, epIn, epOut)
+	}
+
+	constructor(device: USBDevice, interfaceNumber: number, epIn: number, epOut: number) {
+		this.#device = device
+		this.#endpointBulkIn = epIn
+		this.#endpointBulkOut = epOut
+		this.#interfaceNumber = interfaceNumber
+		this.#mpsse = new MPSSE(this)
+	}
+
+	get mpsse(): MPSSE { return this.#mpsse }
+
+	static async #discoverEndpoints(device: USBDevice): Promise<{ interfaceNumber: number, epIn: number, epOut: number}> {
+		if (device.configuration === null) {
+			await device.selectConfiguration(DEFAULT_CONFIGURATION_NUMBER)
+		}
+		await device.claimInterface(DEFAULT_INTERFACE_NUMBER)
+
+		if(device.configuration === null) {
+			throw new Error('Configuration is NULL')
+		}
+
+		const { interfaces } = device.configuration
+		const [ iface ] = interfaces
+		if(iface === undefined) { throw new Error('Interface is undefined') }
+		const { alternate, interfaceNumber } = iface
+		const { endpoints } = alternate
+
+		const epIn = endpoints.find(ep => ep.direction === INTERFACE_DIRECTION_IN && ep.type === INTERFACE_TYPE_BULK)
+		const epOut = endpoints.find(ep => ep.direction === INTERFACE_DIRECTION_OUT && ep.type === INTERFACE_TYPE_BULK)
+
+		if(epIn === undefined) { throw new Error('Endpoint In Bulk not found') }
+		if(epOut === undefined) { throw new Error('Endpoint Out Bulk not found') }
+
+		return {
+			interfaceNumber,
+			epIn: epIn.endpointNumber,
+			epOut: epOut.endpointNumber
+		}
+	}
+
+	async #requestIn(request: RequestType, length: number, index: number|undefined = undefined): Promise<USBInTransferResult> {
+		return this.#device.controlTransferIn({
+			requestType: REQUEST_TYPE_VENDOR,
+			recipient: RECIPIENT_DEVICE,
+			request,
+			value: 0,
+			index: index ?? this.#interfaceNumber
+		}, length)
+	}
+
+	async #requestOut(request: RequestType, value: number, index: number|undefined = undefined): Promise<USBOutTransferResult> {
+		return this.#device.controlTransferOut({
+			requestType: REQUEST_TYPE_VENDOR,
+			recipient: RECIPIENT_DEVICE,
+			request,
+			value,
+			index: index ?? this.#interfaceNumber
+		})
+	}
+
+	async reset(kind = RESET_USB.RESET): Promise<void> {
+		await this.#requestOut(REQUESTS.RESET, kind)
+	}
+
+	async setBitMode(mode: BitMode): Promise<void> {
+		const gpioInit = 0
+		const value = mode | gpioInit
+		await this.#requestOut(REQUESTS.SET_BITMODE, value)
+	}
+
+	async getModemStatus(): Promise<DeviceStatusInfo|undefined> {
+		const status = await this.#requestIn(REQUESTS.POLL_MODEM_STATUS, STATUS_PREFIX_LENGTH)
+		if(status.status !== USB_TRANSFER_OK) { throw new Error('status not ok') }
+		if(status.data === undefined) { throw new Error('undefined data') }
+		assertDataViewNotShared(status.data)
+		return DeviceStatus.parse(status.data)
+	}
+
+	async getLatencyTimer(): Promise<number> {
+		const result = await this.#requestIn(REQUESTS.GET_LATENCY_TIMER, 1)
+		if(result.status !== USB_TRANSFER_OK) { throw new Error('status not ok') }
+		if(result.data === undefined) { throw new Error('undefined data') }
+
+		const latency = result.data.getUint8(0)
+		return latency
+	}
+
+	async setLatencyTimer(latency: number): Promise<void> {
+		if(!Number.isInteger(latency)) { throw new TypeError('latency is not valid integer') }
+		if(latency < 0 || latency > 255) { throw new RangeError('latency out of range') }
+
+		const result = await this.#requestOut(REQUESTS.SET_LATENCY_TIMER, latency)
+		if(result.status !== USB_TRANSFER_OK) { throw new Error('status not ok') }
+	}
+
+	async readPins(): Promise<number> {
+		const result = await this.#requestIn(REQUESTS.READ_PINS, 1)
+		if(result.status !== USB_TRANSFER_OK) { throw new Error('status not ok') }
+		if(result.data === undefined) { throw new Error('undefined data') }
+		return result.data.getUint8(0)
+	}
+
+	async setModemControl(control: ModemControl): Promise<void> {
+		const DTR_ENABLE_BIT = 0x01_00
+		const RTS_ENABLE_BIT = 0x02_00
+		const DTR_SET = 0x01
+		const RTS_SET = 0x02
+
+		const setDTR = control.DataTerminalReady !== undefined
+		const setRTS = control.RequestToSend !== undefined
+		const dtrValue = setDTR ? DTR_ENABLE_BIT | (control.DataTerminalReady ? DTR_SET : 0) : 0
+		const rtsValue = setRTS ? RTS_ENABLE_BIT | (control.RequestToSend ? RTS_SET : 0) : 0
+
+		const value = dtrValue | rtsValue
+
+		const result = await this.#requestOut(REQUESTS.SET_MODEM_CTRL, value)
+		if(result.status !== USB_TRANSFER_OK) { throw new Error('status not ok') }
+	}
+
+	async setEventChar(data: number, enable = true): Promise<void> {
+		const ENABLE_BIT = 0x01_00
+
+		const value = enable ? ENABLE_BIT | data : data
+
+		const result = await this.#requestOut(REQUESTS.SET_EVENT_CHAR, value)
+		if(result.status !== USB_TRANSFER_OK) { throw new Error('status not ok') }
+	}
+
+	async setErrorChar(data: number, enable = true): Promise<void> {
+		const ENABLE_BIT = 0x01_00
+
+		const value = enable ? ENABLE_BIT | data : data
+
+		const result = await this.#requestOut(REQUESTS.SET_ERROR_CHAR, value)
+		if(result.status !== USB_TRANSFER_OK) { throw new Error('status not ok') }
+
+	}
+
+
+  async sendData(data: BufferSource): Promise<number> {
+    const result = await this.#device.transferOut(this.#endpointBulkOut, data)
+		if(result.status !== USB_TRANSFER_OK) { throw new Error('failure sending data') }
+		return result.bytesWritten
+  }
+
+	async readData(length: number): Promise<DataView<ArrayBuffer>> {
+		const result = await this.#device.transferIn(this.#endpointBulkIn, length)
+		if(result.status !== USB_TRANSFER_OK) { throw new Error('failure to read data') }
+		if(result.data === undefined) { throw new Error('result data undefined') }
+		assertDataViewNotShared(result.data)
+		return result.data
+	}
+
+	async readEEPROM(address: number, length: number): Promise<DataView<ArrayBuffer>> {
+		const result = await this.#requestIn(REQUESTS.READ_EEPROM, length, address)
+		if(result.status !== USB_TRANSFER_OK) { throw new Error('failure to read eeprom') }
+		if(result.data === undefined) { throw new Error('result data undefined') }
+		assertDataViewNotShared(result.data)
+
+		return result.data
+	}
+
+	async writeEEPROM(address: number, value: number): Promise<number> {
+		const result = await this.#requestOut(REQUESTS.WRITE_EEPROM, value, address)
+		if(result.status !== USB_TRANSFER_OK) { throw new Error('failure to read eeprom') }
+		return result.bytesWritten
+	}
+
+	// async eraseEEPROM(): Promise<void> {
+
+	// }
+}

package/src/i2c/i2c-template.ts

@@ -0,0 +1,156 @@
+/** biome-ignore-all lint/style/useConsistentArrayType: <explanation> */
+import {
+	CLOCK_BASE_12,
+	CLOCK_BASE_60,
+	Clock
+} from '../mpsse/clock.ts'
+import {
+	CLOCK_DIVISOR_COMMANDS,
+	FT232H_ONLY_COMMANDS,
+	H_COMMANDS,
+	HOST_AND_MPSSE_MODE_COMMANDS,
+	PIN_STATE_COMMANDS,
+	SHIFT_COMMAND
+} from '../mpsse/command.ts'
+import { MPSSETemplate } from '../mpsse/mpsse-template.ts'
+
+const SDA_PIN_MASK = 0b0000_0010
+const SCL_PIN_MASK = 0b0000_0001
+
+const SCL_HIGH_SDA_HIGH: number = SDA_PIN_MASK | SCL_PIN_MASK
+const SCL_HIGH_SDA_LOW: number = SCL_PIN_MASK
+const SCL_LOW_SDA_HIGH: number = SDA_PIN_MASK
+const SCL_LOW_SDA_LOW = 0
+
+const SDA_DIRECTION_OUT = 0b0000_0010
+const SCL_DIRECTION_OUT = 0b0000_0001
+const SDA_SCL_DIRECTION_OUT: number = SDA_DIRECTION_OUT | SCL_DIRECTION_OUT
+
+const OPEN_DRAIN_LOW_PIN_MASK = 0b0000_0111
+const OPEN_DRAIN_HIGH_PIN_MASK = 0b0000_0000
+
+export class I2CTemplate {
+	static initI2C(targetHertz: number, enableClockDivideBy5 = false): Uint8Array<ArrayBuffer> {
+		const clockBase = enableClockDivideBy5 ? CLOCK_BASE_12 : CLOCK_BASE_60
+		const divideBy5Command = enableClockDivideBy5 ? H_COMMANDS.ENABLE_CLOCK_DIVIDE_BY_FIVE : H_COMMANDS.DISABLE_CLOCK_DIVIDE_BY_FIVE
+
+		const divisor = Clock.clockDivisor(targetHertz, clockBase)
+		const divisorH = (divisor >> 8) & 0xFF
+		const divisorL = divisor & 0xFF
+
+		return Uint8Array.from([
+			divideBy5Command,
+			H_COMMANDS.ENABLE_THREE_PHASE_CLOCKING,
+			FT232H_ONLY_COMMANDS.SET_IO_ONLY_DRIVE_LOW, OPEN_DRAIN_LOW_PIN_MASK, OPEN_DRAIN_HIGH_PIN_MASK, // low pins as open-drain
+			PIN_STATE_COMMANDS.SET_DATA_BITS_LOW_BYTE, SCL_HIGH_SDA_HIGH, SDA_SCL_DIRECTION_OUT, // value, direction
+			CLOCK_DIVISOR_COMMANDS.SET_CLK_DIVISOR, divisorL, divisorH, // 0x4A, 0x01, // ~100kHz
+
+			HOST_AND_MPSSE_MODE_COMMANDS.SEND_IMMEDIATE
+		])
+	}
+
+	static #consumeAck(): Array<number> {
+		return [
+			...MPSSETemplate.gpioSetLow(SCL_LOW_SDA_HIGH, SDA_SCL_DIRECTION_OUT), // release SDA
+			...MPSSETemplate.shiftInBits(SHIFT_COMMAND.IN_MSB_BITS_POSITIVE_VE, 1),
+			...MPSSETemplate.gpioSetLow(SCL_LOW_SDA_LOW, SDA_SCL_DIRECTION_OUT), // regain
+		]
+	}
+
+	static #start(): Array<number> {
+		return [
+			// SDA: 1, SCL: 0
+			...MPSSETemplate.gpioSetLow(SCL_LOW_SDA_HIGH, SDA_SCL_DIRECTION_OUT),
+
+			// SDA: 1, SCL: 1  (release both lines)
+			...MPSSETemplate.gpioSetLow(SCL_HIGH_SDA_HIGH, SDA_SCL_DIRECTION_OUT),
+			...MPSSETemplate.gpioSetLow(SCL_HIGH_SDA_HIGH, SDA_SCL_DIRECTION_OUT),
+			...MPSSETemplate.gpioSetLow(SCL_HIGH_SDA_HIGH, SDA_SCL_DIRECTION_OUT),
+			...MPSSETemplate.gpioSetLow(SCL_HIGH_SDA_HIGH, SDA_SCL_DIRECTION_OUT),
+			...MPSSETemplate.gpioSetLow(SCL_HIGH_SDA_HIGH, SDA_SCL_DIRECTION_OUT),
+
+			// SDA: 0, SCL: 1   (low data while clock high)
+			...MPSSETemplate.gpioSetLow(SCL_HIGH_SDA_LOW, SDA_SCL_DIRECTION_OUT),
+			...MPSSETemplate.gpioSetLow(SCL_HIGH_SDA_LOW, SDA_SCL_DIRECTION_OUT),
+			...MPSSETemplate.gpioSetLow(SCL_HIGH_SDA_LOW, SDA_SCL_DIRECTION_OUT),
+			...MPSSETemplate.gpioSetLow(SCL_HIGH_SDA_LOW, SDA_SCL_DIRECTION_OUT),
+			...MPSSETemplate.gpioSetLow(SCL_HIGH_SDA_LOW, SDA_SCL_DIRECTION_OUT),
+
+			// SDA: 0, SCL: 0  (both low - hold start)
+			...MPSSETemplate.gpioSetLow(SCL_LOW_SDA_LOW, SDA_SCL_DIRECTION_OUT),
+			...MPSSETemplate.gpioSetLow(SCL_LOW_SDA_LOW, SDA_SCL_DIRECTION_OUT),
+			...MPSSETemplate.gpioSetLow(SCL_LOW_SDA_LOW, SDA_SCL_DIRECTION_OUT),
+			...MPSSETemplate.gpioSetLow(SCL_LOW_SDA_LOW, SDA_SCL_DIRECTION_OUT),
+			...MPSSETemplate.gpioSetLow(SCL_LOW_SDA_LOW, SDA_SCL_DIRECTION_OUT),
+		]
+	}
+
+	static startWithAddress(addr: number, write = false): Uint8Array<ArrayBuffer> {
+		const data = (addr << 1) | (write ? 0 : 1)
+
+		return Uint8Array.from([
+			...I2CTemplate.#start(),
+			...MPSSETemplate.shiftOutByte(SHIFT_COMMAND.OUT_MSB_BYTES_NEGATIVE_VE, 1, data),
+			...I2CTemplate.#consumeAck(),
+			HOST_AND_MPSSE_MODE_COMMANDS.SEND_IMMEDIATE
+		])
+	}
+
+	static writeByte(data: number): Uint8Array<ArrayBuffer> {
+		return Uint8Array.from([
+			...MPSSETemplate.shiftOutByte(SHIFT_COMMAND.OUT_MSB_BYTES_NEGATIVE_VE, 1, data),
+			...I2CTemplate.#consumeAck(),
+			HOST_AND_MPSSE_MODE_COMMANDS.SEND_IMMEDIATE
+		])
+	}
+
+	static repeatStartWithAddress(addr: number, write = false): Uint8Array<ArrayBuffer> {
+		const data = (addr << 1) | (write ? 0 : 1)
+
+		return Uint8Array.from([
+			...I2CTemplate.#start(),
+			...MPSSETemplate.gpioSetLow(SCL_LOW_SDA_HIGH, SDA_SCL_DIRECTION_OUT),
+			...MPSSETemplate.shiftOutByte(SHIFT_COMMAND.OUT_MSB_BYTES_NEGATIVE_VE, 1, data),
+			...I2CTemplate.#consumeAck(),
+			HOST_AND_MPSSE_MODE_COMMANDS.SEND_IMMEDIATE
+		])
+	}
+
+	static readData(ack = true): Uint8Array<ArrayBuffer> {
+		const MSB_ACK_BIT = 0x00
+		const MSB_NACK_BIT = 0x80
+		const data = ack ? MSB_ACK_BIT : MSB_NACK_BIT
+
+		return Uint8Array.from([
+			...MPSSETemplate.gpioSetLow(SCL_LOW_SDA_HIGH, SDA_SCL_DIRECTION_OUT),
+			...MPSSETemplate.shiftInByte(SHIFT_COMMAND.IN_MSB_BYTES_POSITIVE_VE, 1),
+			...MPSSETemplate.gpioSetLow(SCL_LOW_SDA_LOW, SDA_SCL_DIRECTION_OUT),
+			...MPSSETemplate.shiftOutBits(SHIFT_COMMAND.OUT_MSB_BITS_NEGATIVE_VE, 1, data),
+			HOST_AND_MPSSE_MODE_COMMANDS.SEND_IMMEDIATE
+		])
+	}
+
+	static stop(): Uint8Array<ArrayBuffer> {
+		return Uint8Array.from([
+			// Set SDA low, SCL low
+			...MPSSETemplate.gpioSetLow(SCL_LOW_SDA_LOW, SDA_SCL_DIRECTION_OUT),
+			...MPSSETemplate.gpioSetLow(SCL_LOW_SDA_LOW, SDA_SCL_DIRECTION_OUT),
+			...MPSSETemplate.gpioSetLow(SCL_LOW_SDA_LOW, SDA_SCL_DIRECTION_OUT),
+			...MPSSETemplate.gpioSetLow(SCL_LOW_SDA_LOW, SDA_SCL_DIRECTION_OUT),
+			...MPSSETemplate.gpioSetLow(SCL_LOW_SDA_LOW, SDA_SCL_DIRECTION_OUT),
+
+			// Set SDA low, SCL high
+			...MPSSETemplate.gpioSetLow(SCL_HIGH_SDA_LOW, SDA_SCL_DIRECTION_OUT),
+			...MPSSETemplate.gpioSetLow(SCL_HIGH_SDA_LOW, SDA_SCL_DIRECTION_OUT),
+			...MPSSETemplate.gpioSetLow(SCL_HIGH_SDA_LOW, SDA_SCL_DIRECTION_OUT),
+			...MPSSETemplate.gpioSetLow(SCL_HIGH_SDA_LOW, SDA_SCL_DIRECTION_OUT),
+			...MPSSETemplate.gpioSetLow(SCL_HIGH_SDA_LOW, SDA_SCL_DIRECTION_OUT),
+
+			// Set SDA, SCL high
+			...MPSSETemplate.gpioSetLow(SCL_HIGH_SDA_HIGH, SDA_SCL_DIRECTION_OUT),
+
+			//
+			HOST_AND_MPSSE_MODE_COMMANDS.SEND_IMMEDIATE
+		])
+	}
+}

package/src/i2c/i2c.ts

@@ -0,0 +1,210 @@
+/** biome-ignore-all lint/style/noNestedTernary: preserve const assign */
+/** biome-ignore-all lint/performance/noAwaitInLoops: simplify impl */
+/** biome-ignore-all lint/style/useConsistentArrayType: <explanation> */
+import type {
+	I2CAddress,
+	I2CBufferSource,
+	I2CBus,
+	I2CCommand,
+	I2CReadResult,
+	I2CWriteResult
+} from '@johntalton/and-other-delights'
+import type { FTDIDevice } from '../ftdi.ts'
+import { CLOCK_DEFAULT_STANDARD_MODE_100_kHz } from '../mpsse/clock.ts'
+import { DeviceStatus } from '../status.ts'
+import { DEFAULT_DATA_READ_SIZE, Util } from '../util.ts'
+import { I2CTemplate } from './i2c-template.ts'
+import { range } from './range.ts'
+
+export function checkAck(data: Uint8Array<ArrayBuffer>): boolean {
+	if(data.byteLength !== 1) {
+		console.log('more ack', data)
+		// throw new Error('not just an ack')
+	}
+	const [ byte ] = data
+	if(byte === undefined) { return false }
+
+	return  (byte & 0b0000_0001) === 0
+}
+
+export async function sendAndReadACK(device: FTDIDevice, transaction: Uint8Array<ArrayBuffer>): Promise<boolean> {
+	await device.sendData(transaction)
+	const response = await Util.pollData(device)
+	return checkAck(response)
+}
+
+export async function readData(device: FTDIDevice, length: number, targetBuffer?: I2CBufferSource): Promise<I2CBufferSource> {
+	const buffer = (targetBuffer === undefined) ?
+		new Uint8Array(length) :
+		(ArrayBuffer.isView(targetBuffer) ?
+			new Uint8Array(targetBuffer.buffer, targetBuffer.byteOffset, length) :
+			new Uint8Array(targetBuffer, 0, length))
+
+	// c0 low - RX-LED-emulation
+	// await device.mpsse.setGpioHigh(0b0000_0000, 0b0000_0001)
+
+	for(let offset = 0; offset < length; offset += 1) {
+		const ack = offset + 1 < length // is last byte
+
+		const readByteTransaction = I2CTemplate.readData(ack)
+		await device.sendData(readByteTransaction)
+		const byteReadResponse = await Util.pollData(device)
+
+		buffer.set(new Uint8Array(byteReadResponse.buffer, byteReadResponse.byteOffset, 1), offset)
+	}
+
+	// c0 high - RX-LED-emulation
+	// await device.mpsse.setGpioHigh(0b0000_0001, 0b0000_0001)
+
+	return buffer
+}
+
+export async function writeData(device: FTDIDevice, length: number, buffer: I2CBufferSource): Promise<void> {
+	const u8 = ArrayBuffer.isView(buffer) ?
+		new Uint8Array(buffer.buffer, buffer.byteOffset, length) :
+		new Uint8Array(buffer, 0, length)
+
+	for(let i = 0; i < length; i += 1) {
+		const data = u8[i]
+		if(data === undefined) { throw new Error('data byte undefined') }
+
+		const writeAck = await sendAndReadACK(device, I2CTemplate.writeByte(data))
+		if(!writeAck) { throw new Error('write data nack') }
+	}
+}
+
+export interface FT232HBusOptions {
+	enableClockDivideBy5?: boolean
+	targetClockHz?: number
+}
+
+export class FT232HBus implements I2CBus {
+	readonly name = 'FT232H'
+	readonly supportsScan = true
+	readonly supportsMultiByteDataAddress = false
+
+	readonly #device: FTDIDevice
+
+	static async init(device: FTDIDevice, options?: FT232HBusOptions): Promise<void> {
+		const transaction = I2CTemplate.initI2C(options?.targetClockHz ?? CLOCK_DEFAULT_STANDARD_MODE_100_kHz, options?.enableClockDivideBy5 ?? false)
+		await device.sendData(transaction)
+
+		// todo this is direct read, not pollData
+		const result = await device.readData(DEFAULT_DATA_READ_SIZE)
+		const status = DeviceStatus.parse(result)
+		console.log('init status', status)
+	}
+
+	constructor(device: FTDIDevice) {
+		this.#device = device
+	}
+
+	// biome-ignore lint/nursery/useThisInClassMethods: close is a noop
+	close(): void {
+		// noop
+	}
+
+	async scan(): Promise<I2CAddress[]> {
+		const result: Array<I2CAddress> = []
+
+		const I2C_RANGE_START = 0x08
+		const I2C_RANGE_END = 0x77
+
+		for(const addr of range(I2C_RANGE_START, I2C_RANGE_END)) {
+			//
+			const startAck = await sendAndReadACK(this.#device, I2CTemplate.startWithAddress(addr, true))
+			if(startAck) { result.push(addr) }
+
+			// todo reset or send stop?
+		}
+
+		return result
+	}
+
+	// biome-ignore lint/nursery/useThisInClassMethods: no impl
+	async sendByte(_address: I2CAddress, _byteValue: number): Promise<void> {
+		throw new Error('Method not implemented.')
+	}
+
+	async readI2cBlock(address: I2CAddress, cmd: I2CCommand, length: number, targetBuffer?: I2CBufferSource): Promise<I2CReadResult> {
+		//
+		const startAck = await sendAndReadACK(this.#device, I2CTemplate.startWithAddress(address, true))
+		if(!startAck) { throw new Error('start with address nack') }
+
+		//
+		const cmdBuffer = Uint8Array.from(Array.isArray(cmd) ? cmd : [ cmd ])
+		await writeData(this.#device, cmdBuffer.byteLength, cmdBuffer)
+
+		//
+		const repeatStartAck = await sendAndReadACK(this.#device, I2CTemplate.repeatStartWithAddress(address))
+		if(!repeatStartAck) { throw new Error('repeat start nack') }
+
+		//
+		const buffer = await readData(this.#device, length, targetBuffer)
+
+		//
+		await this.#device.sendData(I2CTemplate.stop())
+
+		return {
+			bytesRead: length,
+			buffer
+		}
+	}
+
+	async writeI2cBlock(address: I2CAddress, cmd: I2CCommand, length: number, buffer: I2CBufferSource): Promise<I2CWriteResult> {
+		if(Array.isArray(cmd)) { throw new Error('single command byte only') }
+
+		//
+		const startAck = await sendAndReadACK(this.#device, I2CTemplate.startWithAddress(address, true))
+		if(!startAck) { throw new Error('start with address nack') }
+
+		//
+		const cmdBuffer = Uint8Array.from(Array.isArray(cmd) ? cmd : [ cmd ])
+		await writeData(this.#device, cmdBuffer.byteLength, cmdBuffer)
+
+		//
+		await writeData(this.#device, length, buffer)
+
+		//
+		await this.#device.sendData(I2CTemplate.stop())
+
+		return {
+			bytesWritten: length,
+			buffer
+		}
+	}
+
+	async i2cRead(address: I2CAddress, length: number, targetBuffer?: I2CBufferSource): Promise<I2CReadResult> {
+		//
+		const startAck = await sendAndReadACK(this.#device, I2CTemplate.startWithAddress(address))
+		if(!startAck) { throw new Error('start with address nack') }
+
+		//
+		const buffer = await readData(this.#device, length, targetBuffer)
+
+		//
+		await this.#device.sendData(I2CTemplate.stop())
+
+		return {
+			bytesRead: length,
+			buffer
+		}
+	}
+
+	async i2cWrite(address: I2CAddress, length: number, buffer: I2CBufferSource): Promise<I2CWriteResult> {
+		//
+		const startAck = await sendAndReadACK(this.#device, I2CTemplate.startWithAddress(address, true))
+		if(!startAck) { throw new Error('start with address nack') }
+
+		//
+		await writeData(this.#device, length, buffer)
+
+		//
+		await this.#device.sendData(I2CTemplate.stop())
+
+		return {
+			bytesWritten: length,
+			buffer
+		}
+	}
+}

package/src/i2c/index.ts

@@ -0,0 +1,4 @@
+/** biome-ignore-all lint/performance/noBarrelFile: barrel */
+/** biome-ignore-all lint/performance/noReExportAll: barrel */
+export * from './i2c.ts'
+export * from './i2c-template.ts'

package/src/i2c/range.ts

@@ -0,0 +1,6 @@
+
+export function* range(start: number, end: number, step = 1): Generator<number> {
+	for(let i = start; i <= end; i += step) {
+		yield i
+	}
+}

package/src/index.ts

@@ -0,0 +1,8 @@
+/** biome-ignore-all lint/performance/noBarrelFile: barrel */
+/** biome-ignore-all lint/performance/noReExportAll: barrel */
+export * from './consts.ts'
+export * from './eeprom.ts'
+export * from './ftdi.ts'
+export * from './mpsse/index.ts'
+export * from './status.ts'
+export * from './util.ts'

package/src/mpsse/clock.ts

@@ -0,0 +1,36 @@
+
+export const CLOCK_BASE_12 = 12_000_000  // 91 Hz - 6 MHz
+export const CLOCK_BASE_60 = 60_000_000  // 457 Hz - 30 MHz
+
+export const DIVISOR_MIN = 0
+export const DIVISOR_MAX = 0xFF_FF
+
+
+export const CLOCK_DEFAULT_STANDARD_MODE_100_kHz = 100 * 1000
+export const CLOCK_DEFAULT_FAST_MODE_400_kHz = 400 * 1000
+export const CLOCK_DEFAULT_FAST_MODE_PLUS_1_MHz = 1 * 1000 * 1000
+export const CLOCK_DEFAULT_HIGH_SPEED_MODE_3_4_MHz = 3.4 * 1000 * 1000
+export const CLOCK_DEFAULT_ULTRA_FAST_MODE_5_MHz = 5 * 1000 * 1000
+
+
+export type ClockBase = typeof CLOCK_BASE_12 | typeof CLOCK_BASE_60
+
+export class Clock {
+	static clockHz(divisor: number, base: ClockBase): number {
+		return (base / ((1 + divisor) * 2))
+	}
+
+	static clockDivisor(hertz: number, base: ClockBase): number {
+		const raw =  Math.trunc(base / (hertz * 2)) - 1
+
+		if(raw < DIVISOR_MIN) { return DIVISOR_MIN }
+		if(raw > DIVISOR_MAX) { return DIVISOR_MAX }
+		return raw
+	}
+
+	static hertzToHuman(hertz: number): string {
+		if(hertz >= (1000 * 1000)) { return `${hertz / (1000 * 1000)} MHz`}
+		if(hertz >= (1000)) { return `${hertz / (1000)} kHz`}
+		return `${hertz} Hz`
+	}
+}