USB CDC ACM support + code refactor (#211)
* part1: code refactor * part2: config serialization * usb cdc acm support --------- Co-authored-by: Arkadiusz Wójcik <wojcik.arkadiusz@outlook.com> @ikskuhwch-ch32v003
Arkadiusz Wójcik
2 months ago
committed by
GitHub
parent
063ade2a3c
commit
3af91ea8f9
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,254 @@
|
||||
const std = @import("std");
|
||||
|
||||
const types = @import("types.zig");
|
||||
const utils = @import("utils.zig");
|
||||
|
||||
const DescType = types.DescType;
|
||||
const bos = utils.BosConfig;
|
||||
|
||||
pub const DescSubType = enum(u8) {
|
||||
Header = 0x00,
|
||||
CallManagement = 0x01,
|
||||
ACM = 0x02,
|
||||
Union = 0x06,
|
||||
|
||||
pub fn from_u16(v: u16) ?@This() {
|
||||
return std.meta.intToEnum(@This(), v) catch null;
|
||||
}
|
||||
};
|
||||
|
||||
pub const CdcManagementRequestType = enum(u8) {
|
||||
SetLineCoding = 0x20,
|
||||
GetLineCoding = 0x21,
|
||||
SetControlLineState = 0x22,
|
||||
SendBreak = 0x23,
|
||||
|
||||
pub fn from_u8(v: u8) ?@This() {
|
||||
return std.meta.intToEnum(@This(), v) catch null;
|
||||
}
|
||||
};
|
||||
|
||||
pub const CdcCommSubClassType = enum(u8) {
|
||||
AbstractControlModel = 2
|
||||
};
|
||||
|
||||
pub const CdcHeaderDescriptor = extern struct {
|
||||
length: u8 = 5,
|
||||
// Type of this descriptor, must be `ClassSpecific`.
|
||||
descriptor_type: DescType = DescType.CsInterface,
|
||||
// Subtype of this descriptor, must be `Header`.
|
||||
descriptor_subtype: DescSubType = DescSubType.Header,
|
||||
// USB Class Definitions for Communication Devices Specification release
|
||||
// number in binary-coded decimal. Typically 0x01_10.
|
||||
bcd_cdc: u16 align(1),
|
||||
|
||||
pub fn serialize(self: *const @This()) [5]u8 {
|
||||
var out: [5]u8 = undefined;
|
||||
out[0] = out.len;
|
||||
out[1] = @intFromEnum(self.descriptor_type);
|
||||
out[2] = @intFromEnum(self.descriptor_subtype);
|
||||
out[3] = @intCast(self.bcd_cdc & 0xff);
|
||||
out[4] = @intCast((self.bcd_cdc >> 8) & 0xff);
|
||||
return out;
|
||||
}
|
||||
};
|
||||
|
||||
pub const CdcCallManagementDescriptor = extern struct {
|
||||
length: u8 = 5,
|
||||
// Type of this descriptor, must be `ClassSpecific`.
|
||||
descriptor_type: DescType = DescType.CsInterface,
|
||||
// Subtype of this descriptor, must be `CallManagement`.
|
||||
descriptor_subtype: DescSubType = DescSubType.CallManagement,
|
||||
// Capabilities. Should be 0x00 for use as a serial device.
|
||||
capabilities: u8,
|
||||
// Data interface number.
|
||||
data_interface: u8,
|
||||
|
||||
pub fn serialize(self: *const @This()) [5]u8 {
|
||||
var out: [5]u8 = undefined;
|
||||
out[0] = out.len;
|
||||
out[1] = @intFromEnum(self.descriptor_type);
|
||||
out[2] = @intFromEnum(self.descriptor_subtype);
|
||||
out[3] = self.capabilities;
|
||||
out[4] = self.data_interface;
|
||||
return out;
|
||||
}
|
||||
};
|
||||
|
||||
pub const CdcAcmDescriptor = extern struct {
|
||||
length: u8 = 4,
|
||||
// Type of this descriptor, must be `ClassSpecific`.
|
||||
descriptor_type: DescType = DescType.CsInterface,
|
||||
// Subtype of this descriptor, must be `ACM`.
|
||||
descriptor_subtype: DescSubType = DescSubType.ACM,
|
||||
// Capabilities. Should be 0x02 for use as a serial device.
|
||||
capabilities: u8,
|
||||
|
||||
pub fn serialize(self: *const @This()) [4]u8 {
|
||||
var out: [4]u8 = undefined;
|
||||
out[0] = out.len;
|
||||
out[1] = @intFromEnum(self.descriptor_type);
|
||||
out[2] = @intFromEnum(self.descriptor_subtype);
|
||||
out[3] = self.capabilities;
|
||||
return out;
|
||||
}
|
||||
};
|
||||
|
||||
pub const CdcUnionDescriptor = extern struct {
|
||||
length: u8 = 5,
|
||||
// Type of this descriptor, must be `ClassSpecific`.
|
||||
descriptor_type: DescType = DescType.CsInterface,
|
||||
// Subtype of this descriptor, must be `Union`.
|
||||
descriptor_subtype: DescSubType = DescSubType.Union,
|
||||
// The interface number of the communication or data class interface
|
||||
// designated as the master or controlling interface for the union.
|
||||
master_interface: u8,
|
||||
// The interface number of the first slave or associated interface in the
|
||||
// union.
|
||||
slave_interface_0: u8,
|
||||
|
||||
pub fn serialize(self: *const @This()) [5]u8 {
|
||||
var out: [5]u8 = undefined;
|
||||
out[0] = out.len;
|
||||
out[1] = @intFromEnum(self.descriptor_type);
|
||||
out[2] = @intFromEnum(self.descriptor_subtype);
|
||||
out[3] = self.master_interface;
|
||||
out[4] = self.slave_interface_0;
|
||||
return out;
|
||||
}
|
||||
};
|
||||
|
||||
pub const CdcLineCoding = extern struct {
|
||||
bit_rate: u32 align(1),
|
||||
stop_bits: u8,
|
||||
parity: u8,
|
||||
data_bits: u8,
|
||||
};
|
||||
|
||||
pub const CdcClassDriver = struct {
|
||||
|
||||
device: ?types.UsbDevice = null,
|
||||
ep_notif: u8 = 0,
|
||||
ep_in: u8 = 0,
|
||||
ep_out: u8 = 0,
|
||||
|
||||
line_coding: CdcLineCoding = undefined,
|
||||
|
||||
pub fn write(self: *@This(), data: []const u8) void {
|
||||
// TODO - ugly hack, current limitation 63 chars (in future endpoints should implement ring buffers)
|
||||
const max_size = 63;
|
||||
var buf: [64]u8 = undefined;
|
||||
const size = @min(data.len, max_size);
|
||||
@memcpy(buf[0..size], data[0..size]);
|
||||
buf[max_size-2] = '\r';
|
||||
buf[max_size-1] = '\n';
|
||||
const data_packet = buf[0..size];
|
||||
|
||||
if (self.device.?.ready() == false) {
|
||||
return;
|
||||
}
|
||||
self.device.?.endpoint_transfer(self.ep_in, data_packet);
|
||||
}
|
||||
|
||||
fn init(ptr: *anyopaque, device: types.UsbDevice) void {
|
||||
var self: *CdcClassDriver = @ptrCast(@alignCast(ptr));
|
||||
self.device = device;
|
||||
self.line_coding = .{
|
||||
.bit_rate = 115200,
|
||||
.stop_bits = 0,
|
||||
.parity = 0,
|
||||
.data_bits = 8
|
||||
};
|
||||
}
|
||||
|
||||
fn open(ptr: *anyopaque, cfg: []const u8) !usize {
|
||||
var self: *CdcClassDriver = @ptrCast(@alignCast(ptr));
|
||||
var curr_cfg = cfg;
|
||||
|
||||
if (bos.try_get_desc_as(types.InterfaceDescriptor, curr_cfg)) |desc_itf| {
|
||||
if (desc_itf.interface_class != @intFromEnum(types.ClassCode.Cdc)) return types.DriverErrors.UnsupportedInterfaceClassType;
|
||||
if (desc_itf.interface_subclass != @intFromEnum(CdcCommSubClassType.AbstractControlModel)) return types.DriverErrors.UnsupportedInterfaceSubClassType;
|
||||
} else {
|
||||
return types.DriverErrors.ExpectedInterfaceDescriptor;
|
||||
}
|
||||
|
||||
curr_cfg = bos.get_desc_next(curr_cfg);
|
||||
|
||||
while (curr_cfg.len > 0 and bos.get_desc_type(curr_cfg) == DescType.CsInterface) {
|
||||
curr_cfg = bos.get_desc_next(curr_cfg);
|
||||
}
|
||||
|
||||
if (bos.try_get_desc_as(types.EndpointDescriptor, curr_cfg)) |desc_ep| {
|
||||
self.ep_notif = desc_ep.endpoint_address;
|
||||
curr_cfg = bos.get_desc_next(curr_cfg);
|
||||
}
|
||||
|
||||
if (bos.try_get_desc_as(types.InterfaceDescriptor, curr_cfg)) |desc_itf| {
|
||||
if (desc_itf.interface_class == @intFromEnum(types.ClassCode.CdcData)) {
|
||||
curr_cfg = bos.get_desc_next(curr_cfg);
|
||||
for (0..2) |_| {
|
||||
if (bos.try_get_desc_as(types.EndpointDescriptor, curr_cfg)) |desc_ep| {
|
||||
switch (types.Endpoint.dir_from_address(desc_ep.endpoint_address)) {
|
||||
.In => { self.ep_in = desc_ep.endpoint_address; },
|
||||
.Out => { self.ep_out = desc_ep.endpoint_address; },
|
||||
}
|
||||
self.device.?.endpoint_open(curr_cfg[0..desc_ep.length]);
|
||||
curr_cfg = bos.get_desc_next(curr_cfg);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return cfg.len - curr_cfg.len;
|
||||
}
|
||||
|
||||
fn class_control(ptr: *anyopaque, stage: types.ControlStage, setup: *const types.SetupPacket) bool {
|
||||
var self: *CdcClassDriver = @ptrCast(@alignCast(ptr));
|
||||
|
||||
if (CdcManagementRequestType.from_u8(setup.request)) |request| {
|
||||
switch (request) {
|
||||
.SetLineCoding => {
|
||||
switch (stage) {
|
||||
.Setup => {
|
||||
// HACK, we should handle data phase somehow to read sent line_coding
|
||||
self.device.?.control_ack(setup);
|
||||
},
|
||||
else => {}
|
||||
}
|
||||
},
|
||||
.GetLineCoding => {
|
||||
if (stage == .Setup) {
|
||||
self.device.?.control_transfer(setup, std.mem.asBytes(&self.line_coding));
|
||||
}
|
||||
},
|
||||
.SetControlLineState => {
|
||||
switch (stage) {
|
||||
.Setup => {
|
||||
self.device.?.control_ack(setup);
|
||||
},
|
||||
else => {}
|
||||
}
|
||||
},
|
||||
.SendBreak => {
|
||||
switch (stage) {
|
||||
.Setup => {
|
||||
self.device.?.control_ack(setup);
|
||||
},
|
||||
else => {}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
pub fn driver(self: *@This()) types.UsbClassDriver {
|
||||
return .{
|
||||
.ptr = self,
|
||||
.fn_init = init,
|
||||
.fn_open = open,
|
||||
.fn_class_control = class_control
|
||||
};
|
||||
}
|
||||
};
|
||||
@ -1,112 +0,0 @@
|
||||
/// Describes a device. This is the most broad description in USB and is
|
||||
/// typically the first thing the host asks for.
|
||||
pub const Device = extern struct {
|
||||
/// Version of the device descriptor / USB protocol, in binary-coded
|
||||
/// decimal. This is typically `0x01_10` for USB 1.1.
|
||||
bcdUSB: u16,
|
||||
/// Class of device, giving a broad functional area.
|
||||
bDeviceClass: u8,
|
||||
/// SubClass of device, refining the class.
|
||||
bDeviceSubClass: u8,
|
||||
/// Protocol within the subclass.
|
||||
bDeviceProtocol: u8,
|
||||
/// Maximum unit of data this device can move.
|
||||
bMaxPacketSize0: u8,
|
||||
/// ID of product vendor.
|
||||
idVendor: u16,
|
||||
/// ID of product.
|
||||
idProduct: u16,
|
||||
/// Device version number, as BCD again.
|
||||
bcdDevice: u16,
|
||||
/// Index of manufacturer name in string descriptor table.
|
||||
iManufacturer: u8,
|
||||
/// Index of product name in string descriptor table.
|
||||
iPRoduct: u8,
|
||||
/// Index of serial number in string descriptor table.
|
||||
iSerialNumber: u8,
|
||||
/// Number of configurations supported by this device.
|
||||
bNumConfigurations: u8,
|
||||
};
|
||||
|
||||
pub const Interface = extern struct {
|
||||
bInterfaceNumber: u8,
|
||||
bAlternateSetting: u8,
|
||||
bNumEndpoints: u8,
|
||||
bInterfaceClass: u8,
|
||||
bInterfaceSubClass: u8,
|
||||
bInterfaceProtocol: u8,
|
||||
iInterface: u8,
|
||||
};
|
||||
|
||||
/// Description of a single available device configuration.
|
||||
pub const Configuration = extern struct {
|
||||
/// Total length of all descriptors in this configuration, concatenated.
|
||||
/// This will include this descriptor, plus at least one interface
|
||||
/// descriptor, plus each interface descriptor's endpoint descriptors.
|
||||
wTotalLength: u16,
|
||||
/// Number of interface descriptors in this configuration.
|
||||
bNumInterfaces: u8,
|
||||
/// Number to use when requesting this configuration via a
|
||||
/// `SetConfiguration` request.
|
||||
bConfigurationValue: u8,
|
||||
/// Index of this configuration's name in the string descriptor table.
|
||||
iConfiguration: u8,
|
||||
/// Bit set of device attributes:
|
||||
///
|
||||
/// - Bit 7 should be set (indicates that device can be bus powered in USB
|
||||
/// 1.0).
|
||||
/// - Bit 6 indicates that the device can be self-powered.
|
||||
/// - Bit 5 indicates that the device can signal remote wakeup of the host
|
||||
/// (like a keyboard).
|
||||
/// - The rest are reserved and should be zero.
|
||||
bmAttributes: u8,
|
||||
/// Maximum device power consumption in units of 2mA.
|
||||
bMaxPower: u8,
|
||||
};
|
||||
|
||||
pub const InterfaceAssociation = extern struct {
|
||||
bFirstInterface: u8,
|
||||
bInterfaceCount: u8,
|
||||
bFunctionClass: u8,
|
||||
bFunctionSubClass: u8,
|
||||
bFunctionProtocol: u8,
|
||||
iFunction: u8,
|
||||
};
|
||||
|
||||
/// Describes an endpoint within an interface
|
||||
pub const Endpoint = extern struct {
|
||||
/// Address of this endpoint, where the bottom 4 bits give the endpoint
|
||||
/// number (0..15) and the top bit distinguishes IN (1) from OUT (0).
|
||||
bEndpointAddress: u8,
|
||||
/// Endpoint attributes; the most relevant part is the bottom 2 bits, which
|
||||
/// control the transfer type using the values from `TransferType`.
|
||||
bmAttributes: u8,
|
||||
/// Maximum packet size this endpoint can accept/produce.
|
||||
wMaxPacketSize: u16,
|
||||
/// Interval for polling interrupt/isochronous endpoints (which we don't
|
||||
/// currently support) in milliseconds.
|
||||
bInterval: u8,
|
||||
};
|
||||
|
||||
pub const BOS = extern struct {
|
||||
/// The number of bytes in this descriptor and all of its subordinate
|
||||
/// descriptors
|
||||
wTotalLength: u16,
|
||||
/// The numbre of device capability descriptors subordinate to this BOS
|
||||
/// descriptor
|
||||
bNumDeviceCaps: u8,
|
||||
|
||||
};
|
||||
|
||||
pub const Utf16Le = struct {
|
||||
bytes: []const u8,
|
||||
};
|
||||
|
||||
/// For string descriptor zero: an array of one or more language identifier
|
||||
/// codes, for other string descriptors, a unicode UTF-16LE string
|
||||
pub const String = extern struct {
|
||||
string_or_lang: union {
|
||||
bSTRING: Utf16Le,
|
||||
wLANGID: []const u8,
|
||||
};
|
||||
};
|
||||
@ -0,0 +1,56 @@
|
||||
const types = @import("types.zig");
|
||||
const hid = @import("hid.zig");
|
||||
const cdc = @import("cdc.zig");
|
||||
|
||||
pub const DescriptorsConfigTemplates = struct {
|
||||
pub const config_descriptor_len = 9;
|
||||
|
||||
pub fn config_descriptor(config_num: u8, interfaces_num: u8, string_index: u8, total_len: u16, attributes: u8, max_power_ma: u9) [9]u8 {
|
||||
const desc1 = types.ConfigurationDescriptor { .total_length = total_len, .num_interfaces = interfaces_num, .configuration_value = config_num, .configuration_s = string_index, .attributes = 0b01000000 | attributes, .max_power = max_power_ma/2 };
|
||||
return desc1.serialize();
|
||||
}
|
||||
|
||||
pub const cdc_descriptor_len = 8 + 9 + 5 + 5 + 4 + 5 + 7 + 9 + 7 + 7;
|
||||
|
||||
pub fn cdc_descriptor(interface_number: u8, string_index: u8, endpoint_notifi_address: u8, endpoint_notifi_size: u16, endpoint_out_address: u8, endpoint_in_address: u8, endpoint_size: u16) [cdc_descriptor_len]u8 {
|
||||
const desc1 = types.InterfaceAssociationDescriptor { .first_interface = interface_number, .interface_count = 2, .function_class = 2, .function_subclass = 2, .function_protocol = 0, .function = 0 };
|
||||
const desc2 = types.InterfaceDescriptor { .interface_number = interface_number, .alternate_setting = 0, .num_endpoints = 1, .interface_class = 2, .interface_subclass = 2, .interface_protocol = 0, .interface_s = string_index };
|
||||
const desc3 = cdc.CdcHeaderDescriptor { .descriptor_type = .CsInterface, .descriptor_subtype = .Header, .bcd_cdc = 0x0120 };
|
||||
const desc4 = cdc.CdcCallManagementDescriptor { .descriptor_type = .CsInterface, .descriptor_subtype = .CallManagement, .capabilities = 0, .data_interface = interface_number + 1 };
|
||||
const desc5 = cdc.CdcAcmDescriptor { .descriptor_type = .CsInterface, .descriptor_subtype = .ACM, .capabilities = 6 };
|
||||
const desc6 = cdc.CdcUnionDescriptor { .descriptor_type = .CsInterface, .descriptor_subtype = .Union, .master_interface = interface_number, .slave_interface_0 = interface_number + 1 };
|
||||
const desc7 = types.EndpointDescriptor { .endpoint_address = endpoint_notifi_address, .attributes = @intFromEnum(types.TransferType.Interrupt), .max_packet_size = endpoint_notifi_size, .interval = 16 };
|
||||
const desc8 = types.InterfaceDescriptor { .interface_number = interface_number + 1, .alternate_setting = 0, .num_endpoints = 2, .interface_class = 10, .interface_subclass = 0, .interface_protocol = 0, .interface_s = 0 };
|
||||
const desc9 = types.EndpointDescriptor { .endpoint_address = endpoint_out_address, .attributes = @intFromEnum(types.TransferType.Bulk), .max_packet_size = endpoint_size, .interval = 0 };
|
||||
const desc10 = types.EndpointDescriptor { .endpoint_address = endpoint_in_address, .attributes = @intFromEnum(types.TransferType.Bulk), .max_packet_size = endpoint_size, .interval = 0 };
|
||||
return desc1.serialize() ++ desc2.serialize() ++ desc3.serialize() ++ desc4.serialize() ++ desc5.serialize() ++ desc6.serialize() ++ desc7.serialize() ++ desc8.serialize() ++ desc9.serialize() ++ desc10.serialize();
|
||||
}
|
||||
|
||||
pub const hid_in_descriptor_len = 9 + 9 + 7;
|
||||
|
||||
pub fn hid_in_descriptor(interface_number: u8, string_index: u8, boot_protocol: u8, report_desc_len: u16, endpoint_in_address: u8, endpoint_size: u16, endpoint_interval: u16) [hid_in_descriptor_len]u8 {
|
||||
const desc1 = types.InterfaceDescriptor { .interface_number = interface_number, .alternate_setting = 0, .num_endpoints = 1, .interface_class = 3, .interface_subclass = if (boot_protocol > 0) 1 else 0, .interface_protocol = boot_protocol, .interface_s = string_index };
|
||||
const desc2 = hid.HidDescriptor { .bcd_hid = 0x0111, .country_code = 0, .num_descriptors = 1, .report_length = report_desc_len };
|
||||
const desc3 = types.EndpointDescriptor { .endpoint_address = endpoint_in_address, .attributes = @intFromEnum(types.TransferType.Interrupt), .max_packet_size = endpoint_size, .interval = endpoint_interval };
|
||||
return desc1.serialize() ++ desc2.serialize() ++ desc3.serialize();
|
||||
}
|
||||
|
||||
pub const hid_in_out_descriptor_len = 9 + 9 + 7 + 7;
|
||||
|
||||
pub fn hid_in_out_descriptor(interface_number: u8, string_index: u8, boot_protocol: u8, report_desc_len: u16, endpoint_out_address: u8, endpoint_in_address: u8, endpoint_size: u16, endpoint_interval: u16) [hid_in_out_descriptor_len]u8 {
|
||||
const desc1 = types.InterfaceDescriptor { .interface_number = interface_number, .alternate_setting = 0, .num_endpoints = 2, .interface_class = 3, .interface_subclass = if (boot_protocol > 0) 1 else 0, .interface_protocol = boot_protocol, .interface_s = string_index };
|
||||
const desc2 = hid.HidDescriptor { .bcd_hid = 0x0111, .country_code = 0, .num_descriptors = 1, .report_length = report_desc_len };
|
||||
const desc3 = types.EndpointDescriptor { .endpoint_address = endpoint_out_address, .attributes = @intFromEnum(types.TransferType.Interrupt), .max_packet_size = endpoint_size, .interval = endpoint_interval };
|
||||
const desc4 = types.EndpointDescriptor { .endpoint_address = endpoint_in_address, .attributes = @intFromEnum(types.TransferType.Interrupt), .max_packet_size = endpoint_size, .interval = endpoint_interval };
|
||||
return desc1.serialize() ++ desc2.serialize() ++ desc3.serialize() ++ desc4.serialize();
|
||||
}
|
||||
|
||||
pub const vendor_descriptor_len = 9 + 7 + 7;
|
||||
|
||||
pub fn vendor_descriptor(interface_number: u8, string_index: u8, endpoint_out_address: u8, endpoint_in_address: u8, endpoint_size: u16) [vendor_descriptor_len]u8 {
|
||||
const desc1 = types.InterfaceDescriptor { .interface_number = interface_number, .alternate_setting = 0, .num_endpoints = 2, .interface_class = 0xff, .interface_subclass = 0, .interface_protocol = 0, .interface_s = string_index };
|
||||
const desc2 = types.EndpointDescriptor { .endpoint_address = endpoint_out_address, .attributes = @intFromEnum(types.TransferType.Bulk), .max_packet_size = endpoint_size, .interval = 0 };
|
||||
const desc3 = types.EndpointDescriptor { .endpoint_address = endpoint_in_address, .attributes = @intFromEnum(types.TransferType.Bulk), .max_packet_size = endpoint_size, .interval = 0 };
|
||||
return desc1.serialize() ++ desc2.serialize() ++ desc3.serialize();
|
||||
}
|
||||
};
|
||||
@ -0,0 +1,476 @@
|
||||
const std = @import("std");
|
||||
|
||||
pub const DescType = enum(u8) {
|
||||
Device = 0x01,
|
||||
Config = 0x02,
|
||||
String = 0x03,
|
||||
Interface = 0x04,
|
||||
Endpoint = 0x05,
|
||||
DeviceQualifier = 0x06,
|
||||
InterfaceAssociation = 0x0b,
|
||||
CsDevice = 0x21,
|
||||
CsConfig = 0x22,
|
||||
CsString = 0x23,
|
||||
CsInterface = 0x24,
|
||||
CsEndpoint = 0x25,
|
||||
|
||||
pub fn from_u8(v: u8) ?@This() {
|
||||
return std.meta.intToEnum(@This(), v) catch null;
|
||||
}
|
||||
};
|
||||
|
||||
pub const ClassCode = enum(u8) {
|
||||
Unspecified = 0,
|
||||
Audio = 1,
|
||||
Cdc = 2,
|
||||
Hid = 3,
|
||||
CdcData = 10,
|
||||
};
|
||||
|
||||
/// Types of transfer that can be indicated by the `attributes` field on `EndpointDescriptor`.
|
||||
pub const TransferType = enum(u2) {
|
||||
Control = 0,
|
||||
Isochronous = 1,
|
||||
Bulk = 2,
|
||||
Interrupt = 3,
|
||||
|
||||
pub fn from_u8(v: u8) ?@This() {
|
||||
return std.meta.intToEnum(@This(), v) catch null;
|
||||
}
|
||||
|
||||
pub inline fn as_number(self: @This()) u2 {
|
||||
return @intFromEnum(self);
|
||||
}
|
||||
};
|
||||
|
||||
pub const ControlStage = enum {
|
||||
Idle,
|
||||
Setup,
|
||||
Data,
|
||||
Ack
|
||||
};
|
||||
|
||||
/// The types of USB SETUP requests that we understand.
|
||||
pub const SetupRequest = enum(u8) {
|
||||
GetDescriptor = 0x06,
|
||||
SetAddress = 0x05,
|
||||
SetConfiguration = 0x09,
|
||||
|
||||
pub fn from_u8(v: u8) ?@This() {
|
||||
return std.meta.intToEnum(@This(), v) catch null;
|
||||
}
|
||||
};
|
||||
|
||||
/// USB deals in two different transfer directions, called OUT (host-to-device)
|
||||
/// and IN (device-to-host). In the vast majority of cases, OUT is represented
|
||||
/// by a 0 byte, and IN by an `0x80` byte.
|
||||
pub const Dir = enum(u1) {
|
||||
Out = 0,
|
||||
In = 1,
|
||||
|
||||
pub const DIR_IN_MASK = 0x80;
|
||||
|
||||
pub inline fn as_number(self: @This()) u1 {
|
||||
return @intFromEnum(self);
|
||||
}
|
||||
|
||||
pub inline fn as_number_reversed(self: @This()) u1 {
|
||||
return ~@intFromEnum(self);
|
||||
}
|
||||
};
|
||||
|
||||
pub const Endpoint = struct {
|
||||
pub inline fn to_address(num: u8, dir: Dir) u8 {
|
||||
return switch (dir) {
|
||||
.Out => num,
|
||||
.In => num | Dir.DIR_IN_MASK
|
||||
};
|
||||
}
|
||||
|
||||
pub inline fn num_from_address(addr: u8) u8 {
|
||||
return addr & ~@as(u8, @intCast(Dir.DIR_IN_MASK));
|
||||
}
|
||||
|
||||
pub inline fn dir_from_address(addr: u8) Dir {
|
||||
return if (addr & Dir.DIR_IN_MASK != 0) Dir.In else Dir.Out;
|
||||
}
|
||||
|
||||
pub const EP0_OUT_IDX = 0;
|
||||
pub const EP0_IN_IDX = 1;
|
||||
|
||||
pub const EP0_IN_ADDR: u8 = to_address(0, .In);
|
||||
pub const EP0_OUT_ADDR: u8 = to_address(0, .Out);
|
||||
};
|
||||
|
||||
pub const RequestType = packed struct(u8) {
|
||||
recipient: Recipient,
|
||||
type: Type,
|
||||
direction: Dir,
|
||||
|
||||
const Type = enum(u2) {
|
||||
Standard,
|
||||
Class,
|
||||
Vendor,
|
||||
Other
|
||||
};
|
||||
|
||||
/// RequestType is created from raw bytes using std.mem.bytesToValue, we need to support all potential values if we don't want to crash such conversion
|
||||
const Recipient = enum(u5) {
|
||||
Device,
|
||||
Interface,
|
||||
Endpoint,
|
||||
Other,
|
||||
Reserved1,
|
||||
Reserved2,
|
||||
Reserved3,
|
||||
Reserved4,
|
||||
Reserved5,
|
||||
Reserved6,
|
||||
Reserved7,
|
||||
Reserved8,
|
||||
Reserved9,
|
||||
Reserved10,
|
||||
Reserved11,
|
||||
Reserved12,
|
||||
Reserved13,
|
||||
Reserved14,
|
||||
Reserved15,
|
||||
Reserved16,
|
||||
Reserved17,
|
||||
Reserved18,
|
||||
Reserved19,
|
||||
Reserved20,
|
||||
Reserved21,
|
||||
Reserved22,
|
||||
Reserved23,
|
||||
Reserved24,
|
||||
Reserved25,
|
||||
Reserved26,
|
||||
Reserved27,
|
||||
Reserved28
|
||||
};
|
||||
};
|
||||
|
||||
/// Layout of an 8-byte USB SETUP packet.
|
||||
pub const SetupPacket = extern struct {
|
||||
/// Request metadata: recipient, type, direction.
|
||||
request_type: RequestType,
|
||||
/// Request. Standard setup requests are in the `SetupRequest` enum.
|
||||
/// Devices can extend this with additional types as long as they don't
|
||||
/// conflict.
|
||||
request: u8,
|
||||
/// A simple argument of up to 16 bits, specific to the request.
|
||||
value: u16,
|
||||
/// Not used in the requests we support.
|
||||
index: u16,
|
||||
/// If data will be transferred after this request (in the direction given
|
||||
/// by `request_type`), this gives the number of bytes (OUT) or maximum
|
||||
/// number of bytes (IN).
|
||||
length: u16,
|
||||
};
|
||||
|
||||
/// Describes an endpoint within an interface
|
||||
pub const EndpointDescriptor = extern struct {
|
||||
pub const const_descriptor_type = DescType.Endpoint;
|
||||
|
||||
length: u8 = 7,
|
||||
/// Type of this descriptor, must be `Endpoint`.
|
||||
descriptor_type: DescType = const_descriptor_type,
|
||||
/// Address of this endpoint, where the bottom 4 bits give the endpoint
|
||||
/// number (0..15) and the top bit distinguishes IN (1) from OUT (0).
|
||||
endpoint_address: u8,
|
||||
/// Endpoint attributes; the most relevant part is the bottom 2 bits, which
|
||||
/// control the transfer type using the values from `TransferType`.
|
||||
attributes: u8,
|
||||
/// Maximum packet size this endpoint can accept/produce.
|
||||
max_packet_size: u16 align(1),
|
||||
/// Interval for polling interrupt/isochronous endpoints (which we don't
|
||||
/// currently support) in milliseconds.
|
||||
interval: u8,
|
||||
|
||||
pub fn serialize(self: *const @This()) [7]u8 {
|
||||
var out: [7]u8 = undefined;
|
||||
out[0] = out.len;
|
||||
out[1] = @intFromEnum(self.descriptor_type);
|
||||
out[2] = self.endpoint_address;
|
||||
out[3] = self.attributes;
|
||||
out[4] = @intCast(self.max_packet_size & 0xff);
|
||||
out[5] = @intCast((self.max_packet_size >> 8) & 0xff);
|
||||
out[6] = self.interval;
|
||||
return out;
|
||||
}
|
||||
};
|
||||
|
||||
/// Description of an interface within a configuration.
|
||||
pub const InterfaceDescriptor = extern struct {
|
||||
pub const const_descriptor_type = DescType.Interface;
|
||||
|
||||
length: u8 = 9,
|
||||
/// Type of this descriptor, must be `Interface`.
|
||||
descriptor_type: DescType = const_descriptor_type,
|
||||
/// ID of this interface.
|
||||
interface_number: u8,
|
||||
/// Allows a single `interface_number` to have several alternate interface
|
||||
/// settings, where each alternate increments this field. Normally there's
|
||||
/// only one, and `alternate_setting` is zero.
|
||||
alternate_setting: u8,
|
||||
/// Number of endpoint descriptors in this interface.
|
||||
num_endpoints: u8,
|
||||
/// Interface class code, distinguishing the type of interface.
|
||||
interface_class: u8,
|
||||
/// Interface subclass code, refining the class of interface.
|
||||
interface_subclass: u8,
|
||||
/// Protocol within the interface class/subclass.
|
||||
interface_protocol: u8,
|
||||
/// Index of interface name within string descriptor table.
|
||||
interface_s: u8,
|
||||
|
||||
pub fn serialize(self: *const @This()) [9]u8 {
|
||||
var out: [9]u8 = undefined;
|
||||
out[0] = out.len;
|
||||
out[1] = @intFromEnum(self.descriptor_type);
|
||||
out[2] = self.interface_number;
|
||||
out[3] = self.alternate_setting;
|
||||
out[4] = self.num_endpoints;
|
||||
out[5] = self.interface_class;
|
||||
out[6] = self.interface_subclass;
|
||||
out[7] = self.interface_protocol;
|
||||
out[8] = self.interface_s;
|
||||
return out;
|
||||
}
|
||||
};
|
||||
|
||||
/// USB interface association descriptor (IAD) allows the device to group interfaces that belong to a function.
|
||||
pub const InterfaceAssociationDescriptor = extern struct {
|
||||
pub const const_descriptor_type = DescType.InterfaceAssociation;
|
||||
|
||||
length: u8 = 8,
|
||||
// Type of this descriptor, must be `InterfaceAssociation`.
|
||||
descriptor_type: DescType = const_descriptor_type,
|
||||
// First interface number of the set of interfaces that follow this
|
||||
// descriptor.
|
||||
first_interface: u8,
|
||||
// The number of interfaces that follow this descriptor that are considered
|
||||
// associated.
|
||||
interface_count: u8,
|
||||
// The interface class used for associated interfaces.
|
||||
function_class: u8,
|
||||
// The interface subclass used for associated interfaces.
|
||||
function_subclass: u8,
|
||||
// The interface protocol used for associated interfaces.
|
||||
function_protocol: u8,
|
||||
// Index of the string descriptor describing the associated interfaces.
|
||||
function: u8,
|
||||
|
||||
pub fn serialize(self: *const @This()) [8]u8 {
|
||||
var out: [8]u8 = undefined;
|
||||
out[0] = out.len;
|
||||
out[1] = @intFromEnum(self.descriptor_type);
|
||||
out[2] = self.first_interface;
|
||||
out[3] = self.interface_count;
|
||||
out[4] = self.function_class;
|
||||
out[5] = self.function_subclass;
|
||||
out[6] = self.function_protocol;
|
||||
out[7] = self.function;
|
||||
return out;
|
||||
}
|
||||
};
|
||||
|
||||
/// Description of a single available device configuration.
|
||||
pub const ConfigurationDescriptor = extern struct {
|
||||
pub const const_descriptor_type = DescType.Config;
|
||||
|
||||
length: u8 = 9,
|
||||
/// Type of this descriptor, must be `Config`.
|
||||
descriptor_type: DescType = const_descriptor_type,
|
||||
/// Total length of all descriptors in this configuration, concatenated.
|
||||
/// This will include this descriptor, plus at least one interface
|
||||
/// descriptor, plus each interface descriptor's endpoint descriptors.
|
||||
total_length: u16 align(1),
|
||||
/// Number of interface descriptors in this configuration.
|
||||
num_interfaces: u8,
|
||||
/// Number to use when requesting this configuration via a
|
||||
/// `SetConfiguration` request.
|
||||
configuration_value: u8,
|
||||
/// Index of this configuration's name in the string descriptor table.
|
||||
configuration_s: u8,
|
||||
/// Bit set of device attributes:
|
||||
///
|
||||
/// - Bit 7 should be set (indicates that device can be bus powered in USB
|
||||
/// 1.0).
|
||||
/// - Bit 6 indicates that the device can be self-powered.
|
||||
/// - Bit 5 indicates that the device can signal remote wakeup of the host
|
||||
/// (like a keyboard).
|
||||
/// - The rest are reserved and should be zero.
|
||||
attributes: u8,
|
||||
/// Maximum device power consumption in units of 2mA.
|
||||
max_power: u8,
|
||||
|
||||
pub fn serialize(self: *const @This()) [9]u8 {
|
||||
var out: [9]u8 = undefined;
|
||||
out[0] = out.len;
|
||||
out[1] = @intFromEnum(self.descriptor_type);
|
||||
out[2] = @intCast(self.total_length & 0xff);
|
||||
out[3] = @intCast((self.total_length >> 8) & 0xff);
|
||||
out[4] = self.num_interfaces;
|
||||
out[5] = self.configuration_value;
|
||||
out[6] = self.configuration_s;
|
||||
out[7] = self.attributes;
|
||||
out[8] = self.max_power;
|
||||
return out;
|
||||
}
|
||||
};
|
||||
|
||||
/// Describes a device. This is the most broad description in USB and is
|
||||
/// typically the first thing the host asks for.
|
||||
pub const DeviceDescriptor = extern struct {
|
||||
pub const const_descriptor_type = DescType.Device;
|
||||
|
||||
length: u8 = 18,
|
||||
/// Type of this descriptor, must be `Device`.
|
||||
descriptor_type: DescType = const_descriptor_type,
|
||||
/// Version of the device descriptor / USB protocol, in binary-coded
|
||||
/// decimal. This is typically `0x01_10` for USB 1.1.
|
||||
bcd_usb: u16 align(1),
|
||||
/// Class of device, giving a broad functional area.
|
||||
device_class: u8,
|
||||
/// Subclass of device, refining the class.
|
||||
device_subclass: u8,
|
||||
/// Protocol within the subclass.
|
||||
device_protocol: u8,
|
||||
/// Maximum unit of data this device can move.
|
||||
max_packet_size0: u8,
|
||||
/// ID of product vendor.
|
||||
vendor: u16 align(1),
|
||||
/// ID of product.
|
||||
product: u16 align(1),
|
||||
/// Device version number, as BCD again.
|
||||
bcd_device: u16 align(1),
|
||||
/// Index of manufacturer name in string descriptor table.
|
||||
manufacturer_s: u8,
|
||||
/// Index of product name in string descriptor table.
|
||||
product_s: u8,
|
||||
/// Index of serial number in string descriptor table.
|
||||
serial_s: u8,
|
||||
/// Number of configurations supported by this device.
|
||||
num_configurations: u8,
|
||||
|
||||
pub fn serialize(self: *const @This()) [18]u8 {
|
||||
var out: [18]u8 = undefined;
|
||||
out[0] = out.len;
|
||||
out[1] = @intFromEnum(self.descriptor_type);
|
||||
out[2] = @intCast(self.bcd_usb & 0xff);
|
||||
out[3] = @intCast((self.bcd_usb >> 8) & 0xff);
|
||||
out[4] = self.device_class;
|
||||
out[5] = self.device_subclass;
|
||||
out[6] = self.device_protocol;
|
||||
out[7] = self.max_packet_size0;
|
||||
out[8] = @intCast(self.vendor & 0xff);
|
||||
out[9] = @intCast((self.vendor >> 8) & 0xff);
|
||||
out[10] = @intCast(self.product & 0xff);
|
||||
out[11] = @intCast((self.product >> 8) & 0xff);
|
||||
out[12] = @intCast(self.bcd_device & 0xff);
|
||||
out[13] = @intCast((self.bcd_device >> 8) & 0xff);
|
||||
out[14] = self.manufacturer_s;
|
||||
out[15] = self.product_s;
|
||||
out[16] = self.serial_s;
|
||||
out[17] = self.num_configurations;
|
||||
return out;
|
||||
}
|
||||
};
|
||||
|
||||
/// USB Device Qualifier Descriptor
|
||||
/// This descriptor is mostly the same as the DeviceDescriptor
|
||||
pub const DeviceQualifierDescriptor = extern struct {
|
||||
pub const const_descriptor_type = DescType.DeviceQualifier;
|
||||
|
||||
length: u8 = 10,
|
||||
/// Type of this descriptor, must be `Device`.
|
||||
descriptor_type: DescType = const_descriptor_type,
|
||||
/// Version of the device descriptor / USB protocol, in binary-coded
|
||||
/// decimal. This is typically `0x01_10` for USB 1.1.
|
||||
bcd_usb: u16 align(1),
|
||||
/// Class of device, giving a broad functional area.
|
||||
device_class: u8,
|
||||
/// Subclass of device, refining the class.
|
||||
device_subclass: u8,
|
||||
/// Protocol within the subclass.
|
||||
device_protocol: u8,
|
||||
/// Maximum unit of data this device can move.
|
||||
max_packet_size0: u8,
|
||||
/// Number of configurations supported by this device.
|
||||
num_configurations: u8,
|
||||
/// Reserved for future use; must be 0
|
||||
reserved: u8 = 0,
|
||||
|
||||
pub fn serialize(self: *const @This()) [10]u8 {
|
||||
var out: [10]u8 = undefined;
|
||||
out[0] = out.len;
|
||||
out[1] = @intFromEnum(self.descriptor_type);
|
||||
out[2] = @intCast(self.bcd_usb & 0xff);
|
||||
out[3] = @intCast((self.bcd_usb >> 8) & 0xff);
|
||||
out[4] = self.device_class;
|
||||
out[5] = self.device_subclass;
|
||||
out[6] = self.device_protocol;
|
||||
out[7] = self.max_packet_size0;
|
||||
out[8] = self.num_configurations;
|
||||
out[9] = self.reserved;
|
||||
return out;
|
||||
}
|
||||
};
|
||||
|
||||
pub const DriverErrors = error {
|
||||
ExpectedInterfaceDescriptor,
|
||||
UnsupportedInterfaceClassType,
|
||||
UnsupportedInterfaceSubClassType,
|
||||
UnexpectedDescriptor
|
||||
};
|
||||
|
||||
pub const UsbDevice = struct {
|
||||
fn_ready: *const fn () bool,
|
||||
fn_control_transfer: *const fn (setup: *const SetupPacket, data: []const u8) void,
|
||||
fn_control_ack: *const fn (setup: *const SetupPacket) void,
|
||||
fn_endpoint_open: *const fn (ep_desc: []const u8) void,
|
||||
fn_endpoint_transfer: *const fn (ep_addr: u8, data: []const u8) void,
|
||||
|
||||
pub fn ready(self: *@This()) bool {
|
||||
return self.fn_ready();
|
||||
}
|
||||
|
||||
pub fn control_transfer(self: *@This(), setup: *const SetupPacket, data: []const u8) void {
|
||||
return self.fn_control_transfer(setup, data);
|
||||
}
|
||||
|
||||
pub fn control_ack(self: *@This(), setup: *const SetupPacket) void {
|
||||
return self.fn_control_ack(setup);
|
||||
}
|
||||
|
||||
pub fn endpoint_open(self: *@This(), ep_desc: []const u8) void {
|
||||
return self.fn_endpoint_open(ep_desc);
|
||||
}
|
||||
|
||||
pub fn endpoint_transfer(self: *@This(), ep_addr: u8, data: []const u8) void {
|
||||
return self.fn_endpoint_transfer(ep_addr, data);
|
||||
}
|
||||
};
|
||||
|
||||
/// USB Class driver interface
|
||||
pub const UsbClassDriver = struct {
|
||||
ptr: *anyopaque,
|
||||
fn_init: *const fn (ptr: *anyopaque, device: UsbDevice) void,
|
||||
fn_open: *const fn (ptr: *anyopaque, cfg: []const u8) anyerror!usize,
|
||||
fn_class_control: *const fn (ptr: *anyopaque, stage: ControlStage, setup: *const SetupPacket) bool,
|
||||
|
||||
pub fn init(self: *@This(), device: UsbDevice) void {
|
||||
return self.fn_init(self.ptr, device);
|
||||
}
|
||||
|
||||
/// Driver open (set config) operation. Must return length of consumed driver config data.
|
||||
pub fn open(self: *@This(), cfg: []const u8) !usize {
|
||||
return self.fn_open(self.ptr, cfg);
|
||||
}
|
||||
|
||||
pub fn class_control(self: *@This(), stage: ControlStage, setup: *const SetupPacket) bool {
|
||||
return self.fn_class_control(self.ptr, stage, setup);
|
||||
}
|
||||
};
|
||||
@ -0,0 +1,53 @@
|
||||
const std = @import("std");
|
||||
const types = @import("types.zig");
|
||||
|
||||
pub const BosConfig = struct {
|
||||
const DESC_OFFSET_LEN = 0;
|
||||
const DESC_OFFSET_TYPE = 1;
|
||||
|
||||
pub fn get_desc_len(bos_cfg: []const u8) u8 {
|
||||
return bos_cfg[DESC_OFFSET_LEN];
|
||||
}
|
||||
|
||||
pub fn get_desc_type(bos_cfg: []const u8) ?types.DescType {
|
||||
return types.DescType.from_u8(bos_cfg[DESC_OFFSET_TYPE]);
|
||||
}
|
||||
|
||||
pub fn get_data_u8(bos_cfg: []const u8, offset: u16) u8 {
|
||||
return bos_cfg[offset];
|
||||
}
|
||||
|
||||
pub fn get_data_u16(bos_cfg: []const u8, offset: u16) u16 {
|
||||
const low_byte: u16 = bos_cfg[offset];
|
||||
const high_byte: u16 = bos_cfg[offset+1];
|
||||
return (high_byte << 8) | low_byte;
|
||||
}
|
||||
|
||||
/// Only for temporal u8 fields use as u16 fields will have wrong values because BOS endianness
|
||||
pub fn get_desc_as(comptime T: type, bos_cfg: []const u8) *const T {
|
||||
return @ptrCast(@constCast(bos_cfg.ptr));
|
||||
}
|
||||
|
||||
/// Only for temporal u8 fields use as u16 fields will have wrong values because BOS endianness
|
||||
pub fn try_get_desc_as(comptime T: type, bos_cfg: []const u8) ?*const T {
|
||||
if (bos_cfg.len == 0) return null;
|
||||
const exp_desc_type = @field(T, "const_descriptor_type");
|
||||
const cfg_desc_type = bos_cfg[DESC_OFFSET_TYPE];
|
||||
if (cfg_desc_type != @intFromEnum(exp_desc_type)) {
|
||||
return null;
|
||||
}
|
||||
else {
|
||||
return @constCast(@ptrCast(bos_cfg.ptr));
|
||||
}
|
||||
}
|
||||
|
||||
pub fn get_desc_next(bos_cfg: []const u8) []const u8 {
|
||||
const len = bos_cfg[DESC_OFFSET_LEN];
|
||||
return bos_cfg[len..];
|
||||
}
|
||||
};
|
||||
|
||||
test "Test try_get_desc_as" {
|
||||
const cfg = [_]u8{ 7, 5, 129, 3, 8, 0, 16 };
|
||||
try std.testing.expect(BosConfig.try_get_desc_as(types.EndpointDescriptor, cfg[0..]) != null);
|
||||
}
|
||||
@ -0,0 +1,26 @@
|
||||
const std = @import("std");
|
||||
|
||||
const types = @import("types.zig");
|
||||
|
||||
pub const VendorClassDriver = struct {
|
||||
|
||||
fn init(_: *anyopaque, _: types.UsbDevice) void {
|
||||
}
|
||||
|
||||
fn open(_: *anyopaque, _: []const u8) !usize {
|
||||
return 0;
|
||||
}
|
||||
|
||||
pub fn class_control(_: *anyopaque, _: types.ControlStage, _: *const types.SetupPacket) bool {
|
||||
return true;
|
||||
}
|
||||
|
||||
pub fn driver(self: *@This()) types.UsbClassDriver {
|
||||
return .{
|
||||
.ptr = self,
|
||||
.fn_init = init,
|
||||
.fn_open = open,
|
||||
.fn_class_control = class_control
|
||||
};
|
||||
}
|
||||
};
|
||||
@ -0,0 +1,105 @@
|
||||
const std = @import("std");
|
||||
const microzig = @import("microzig");
|
||||
|
||||
const rp2040 = microzig.hal;
|
||||
const flash = rp2040.flash;
|
||||
const time = rp2040.time;
|
||||
const gpio = rp2040.gpio;
|
||||
const clocks = rp2040.clocks;
|
||||
const usb = rp2040.usb;
|
||||
|
||||
const led = gpio.num(25);
|
||||
const uart = rp2040.uart.num(0);
|
||||
const baud_rate = 115200;
|
||||
const uart_tx_pin = gpio.num(0);
|
||||
const uart_rx_pin = gpio.num(1);
|
||||
|
||||
const usb_config_len = usb.templates.config_descriptor_len + usb.templates.cdc_descriptor_len;
|
||||
const usb_config_descriptor =
|
||||
usb.templates.config_descriptor(1, 2, 0, usb_config_len, 0xc0, 100) ++
|
||||
usb.templates.cdc_descriptor(0, 4, usb.Endpoint.to_address(1, .In), 8, usb.Endpoint.to_address(2, .Out), usb.Endpoint.to_address(2, .In), 64);
|
||||
|
||||
var driver_cdc = usb.cdc.CdcClassDriver{};
|
||||
var drivers = [_]usb.types.UsbClassDriver{ driver_cdc.driver() };
|
||||
|
||||
// This is our device configuration
|
||||
pub var DEVICE_CONFIGURATION: usb.DeviceConfiguration = .{
|
||||
.device_descriptor = &.{
|
||||
.descriptor_type = usb.DescType.Device,
|
||||
.bcd_usb = 0x0200,
|
||||
.device_class = 0xEF,
|
||||
.device_subclass = 2,
|
||||
.device_protocol = 1,
|
||||
.max_packet_size0 = 64,
|
||||
.vendor = 0x2E8A,
|
||||
.product = 0x000a,
|
||||
.bcd_device = 0x0100,
|
||||
.manufacturer_s = 1,
|
||||
.product_s = 2,
|
||||
.serial_s = 0,
|
||||
.num_configurations = 1,
|
||||
},
|
||||
.config_descriptor = &usb_config_descriptor,
|
||||
.lang_descriptor = "\x04\x03\x09\x04", // length || string descriptor (0x03) || Engl (0x0409)
|
||||
.descriptor_strings = &.{
|
||||
&usb.utils.utf8ToUtf16Le("Raspberry Pi"),
|
||||
&usb.utils.utf8ToUtf16Le("Pico Test Device"),
|
||||
&usb.utils.utf8ToUtf16Le("someserial"),
|
||||
&usb.utils.utf8ToUtf16Le("Board CDC"),
|
||||
},
|
||||
.drivers = &drivers
|
||||
};
|
||||
|
||||
pub fn panic(message: []const u8, _: ?*std.builtin.StackTrace, _: ?usize) noreturn {
|
||||
std.log.err("panic: {s}", .{message});
|
||||
@breakpoint();
|
||||
while (true) {}
|
||||
}
|
||||
|
||||
pub const microzig_options = .{
|
||||
.log_level = .debug,
|
||||
.logFn = rp2040.uart.log,
|
||||
};
|
||||
|
||||
pub fn main() !void {
|
||||
led.set_function(.sio);
|
||||
led.set_direction(.out);
|
||||
led.put(1);
|
||||
|
||||
uart.apply(.{
|
||||
.baud_rate = baud_rate,
|
||||
.tx_pin = uart_tx_pin,
|
||||
.rx_pin = uart_rx_pin,
|
||||
.clock_config = rp2040.clock_config,
|
||||
});
|
||||
|
||||
rp2040.uart.init_logger(uart);
|
||||
|
||||
// First we initialize the USB clock
|
||||
rp2040.usb.Usb.init_clk();
|
||||
// Then initialize the USB device using the configuration defined above
|
||||
rp2040.usb.Usb.init_device(&DEVICE_CONFIGURATION) catch unreachable;
|
||||
var old: u64 = time.get_time_since_boot().to_us();
|
||||
var new: u64 = 0;
|
||||
|
||||
var i: u32 = 0;
|
||||
var buf: [1024]u8 = undefined;
|
||||
while (true) {
|
||||
// You can now poll for USB events
|
||||
rp2040.usb.Usb.task(
|
||||
false, // debug output over UART [Y/n]
|
||||
) catch unreachable;
|
||||
|
||||
new = time.get_time_since_boot().to_us();
|
||||
if (new - old > 500000) {
|
||||
old = new;
|
||||
led.toggle();
|
||||
i += 1;
|
||||
// uart log
|
||||
std.log.info("cdc test: {}\r\n", .{i});
|
||||
// usb log (at this moment 63 bytes is max limit per single call)
|
||||
const text = std.fmt.bufPrint(&buf, "cdc test: {}\r\n", .{i}) catch &.{};
|
||||
driver_cdc.write(text);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,169 +0,0 @@
|
||||
const std = @import("std");
|
||||
const microzig = @import("microzig");
|
||||
|
||||
const rp2040 = microzig.hal;
|
||||
const flash = rp2040.flash;
|
||||
const time = rp2040.time;
|
||||
const gpio = rp2040.gpio;
|
||||
const clocks = rp2040.clocks;
|
||||
const usb = rp2040.usb;
|
||||
|
||||
const led = gpio.num(25);
|
||||
const uart = rp2040.uart.num(0);
|
||||
const baud_rate = 115200;
|
||||
const uart_tx_pin = gpio.num(0);
|
||||
const uart_rx_pin = gpio.num(1);
|
||||
|
||||
// First we define two callbacks that will be used by the endpoints we define next...
|
||||
fn ep1_in_callback(dc: *usb.DeviceConfiguration, data: []const u8) void {
|
||||
_ = data;
|
||||
// The host has collected the data we repeated onto
|
||||
// EP1! Set up to receive more data on EP1.
|
||||
usb.Usb.callbacks.usb_start_rx(
|
||||
dc.endpoints[2], // EP1_OUT_CFG,
|
||||
64,
|
||||
);
|
||||
}
|
||||
|
||||
fn ep1_out_callback(dc: *usb.DeviceConfiguration, data: []const u8) void {
|
||||
// We've gotten data from the host on our custom
|
||||
// EP1! Set up EP1 to repeat it.
|
||||
usb.Usb.callbacks.usb_start_tx(
|
||||
dc.endpoints[3], // EP1_IN_CFG,
|
||||
data,
|
||||
);
|
||||
}
|
||||
|
||||
// The endpoints EP0_IN and EP0_OUT are already defined but you can
|
||||
// add your own endpoints to...
|
||||
pub var EP1_OUT_CFG: usb.EndpointConfiguration = .{
|
||||
.descriptor = &usb.EndpointDescriptor{
|
||||
.descriptor_type = usb.DescType.Endpoint,
|
||||
.endpoint_address = usb.Dir.Out.endpoint(1),
|
||||
.attributes = @intFromEnum(usb.TransferType.Bulk),
|
||||
.max_packet_size = 64,
|
||||
.interval = 0,
|
||||
},
|
||||
.endpoint_control_index = 2,
|
||||
.buffer_control_index = 3,
|
||||
.data_buffer_index = 2,
|
||||
.next_pid_1 = false,
|
||||
// The callback will be executed if we got an interrupt on EP1_OUT
|
||||
.callback = ep1_out_callback,
|
||||
};
|
||||
|
||||
pub var EP1_IN_CFG: usb.EndpointConfiguration = .{
|
||||
.descriptor = &usb.EndpointDescriptor{
|
||||
.descriptor_type = usb.DescType.Endpoint,
|
||||
.endpoint_address = usb.Dir.In.endpoint(1),
|
||||
.attributes = @intFromEnum(usb.TransferType.Bulk),
|
||||
.max_packet_size = 64,
|
||||
.interval = 0,
|
||||
},
|
||||
.endpoint_control_index = 1,
|
||||
.buffer_control_index = 2,
|
||||
.data_buffer_index = 3,
|
||||
.next_pid_1 = false,
|
||||
// The callback will be executed if we got an interrupt on EP1_IN
|
||||
.callback = ep1_in_callback,
|
||||
};
|
||||
|
||||
// This is our device configuration
|
||||
pub var DEVICE_CONFIGURATION: usb.DeviceConfiguration = .{
|
||||
.device_descriptor = &.{
|
||||
.descriptor_type = usb.DescType.Device,
|
||||
.bcd_usb = 0x0110,
|
||||
.device_class = 0,
|
||||
.device_subclass = 0,
|
||||
.device_protocol = 0,
|
||||
.max_packet_size0 = 64,
|
||||
.vendor = 0,
|
||||
.product = 1,
|
||||
.bcd_device = 0,
|
||||
.manufacturer_s = 1,
|
||||
.product_s = 2,
|
||||
.serial_s = 0,
|
||||
.num_configurations = 1,
|
||||
},
|
||||
.interface_descriptor = &.{
|
||||
.descriptor_type = usb.DescType.Interface,
|
||||
.interface_number = 0,
|
||||
.alternate_setting = 0,
|
||||
// We have two endpoints (EP0 IN/OUT don't count)
|
||||
.num_endpoints = 2,
|
||||
.interface_class = 0xff,
|
||||
.interface_subclass = 0,
|
||||
.interface_protocol = 0,
|
||||
.interface_s = 0,
|
||||
},
|
||||
.config_descriptor = &.{
|
||||
.descriptor_type = usb.DescType.Config,
|
||||
// This is calculated via the sizes of underlying descriptors contained in this configuration.
|
||||
// ConfigurationDescriptor(9) + InterfaceDescriptor(9) * 1 + EndpointDescriptor(8) * 2
|
||||
.total_length = 34,
|
||||
.num_interfaces = 1,
|
||||
.configuration_value = 1,
|
||||
.configuration_s = 0,
|
||||
.attributes = 0xc0,
|
||||
.max_power = 0x32,
|
||||
},
|
||||
.lang_descriptor = "\x04\x03\x09\x04", // length || string descriptor (0x03) || Engl (0x0409)
|
||||
.descriptor_strings = &.{
|
||||
// ugly unicode :|
|
||||
"R\x00a\x00s\x00p\x00b\x00e\x00r\x00r\x00y\x00 \x00P\x00i\x00",
|
||||
"P\x00i\x00c\x00o\x00 \x00T\x00e\x00s\x00t\x00 \x00D\x00e\x00v\x00i\x00c\x00e\x00",
|
||||
},
|
||||
// Here we pass all endpoints to the config
|
||||
// Dont forget to pass EP0_[IN|OUT] in the order seen below!
|
||||
.endpoints = .{
|
||||
&usb.EP0_OUT_CFG,
|
||||
&usb.EP0_IN_CFG,
|
||||
&EP1_OUT_CFG,
|
||||
&EP1_IN_CFG,
|
||||
},
|
||||
};
|
||||
|
||||
pub fn panic(message: []const u8, _: ?*std.builtin.StackTrace, _: ?usize) noreturn {
|
||||
std.log.err("panic: {s}", .{message});
|
||||
@breakpoint();
|
||||
while (true) {}
|
||||
}
|
||||
|
||||
pub const microzig_options = .{
|
||||
.log_level = .debug,
|
||||
.logFn = rp2040.uart.log,
|
||||
};
|
||||
|
||||
pub fn main() !void {
|
||||
led.set_function(.sio);
|
||||
led.set_direction(.out);
|
||||
led.put(1);
|
||||
|
||||
uart.apply(.{
|
||||
.baud_rate = baud_rate,
|
||||
.tx_pin = uart_tx_pin,
|
||||
.rx_pin = uart_rx_pin,
|
||||
.clock_config = rp2040.clock_config,
|
||||
});
|
||||
|
||||
rp2040.uart.init_logger(uart);
|
||||
|
||||
// First we initialize the USB clock
|
||||
rp2040.usb.Usb.init_clk();
|
||||
// Then initialize the USB device using the configuration defined above
|
||||
rp2040.usb.Usb.init_device(&DEVICE_CONFIGURATION) catch unreachable;
|
||||
var old: u64 = time.get_time_since_boot().to_us();
|
||||
var new: u64 = 0;
|
||||
while (true) {
|
||||
// You can now poll for USB events
|
||||
rp2040.usb.Usb.task(
|
||||
false, // debug output over UART [Y/n]
|
||||
) catch unreachable;
|
||||
|
||||
new = time.get_time_since_boot().to_us();
|
||||
if (new - old > 500000) {
|
||||
old = new;
|
||||
led.toggle();
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue