xhci: 获取设备描述符并配置endpoint (#50)

* 调整:使用宏定义来声明usb请求包

* new: 获取usb设备的config描述符

* new: 获取接口及端点描述符

* 临时修正系统根分区的挂载,使得能在真机上启动shell

* xhci: set_config

* bugfix: 解决之前错误的将control_endpoint信息绑定在xhci_hc下的bug

* xhci configure endpoint(存在bug

* 1

* 解决了configure endpoint出错的问题

* new: xhci驱动程序能够配置端点

* 删除trace usb的代码

xhci: 获取设备描述符并配置endpoint
存在问题:尚未能够正确初始化usb键盘,也没有将usb键盘相关的代码独立出来。
This commit is contained in:
login 2022-09-30 20:39:02 +08:00 committed by GitHub
parent 35345cae6c
commit fb417a5e81
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
9 changed files with 790 additions and 210 deletions

View File

@ -7,12 +7,14 @@
#include <common/string.h>
#include <common/block.h>
#include <filesystem/MBR.h>
#include <debug/bug.h>
struct pci_device_structure_header_t *ahci_devs[MAX_AHCI_DEVICES];
struct block_device_request_queue ahci_req_queue;
struct blk_gendisk ahci_gendisk0 = {0}; // 暂时硬性指定一个ahci_device
static int __first_port = -1; // 临时用于存储 ahci控制器的第一个可用端口 的变量
static uint32_t count_ahci_devices = 0;
@ -98,16 +100,17 @@ static int ahci_init_gendisk()
// todo: 支持GPT
((struct ahci_blk_private_data *)ahci_gendisk0.private_data)->ahci_ctrl_num = 0;
((struct ahci_blk_private_data *)ahci_gendisk0.private_data)->ahci_port_num = 0;
((struct ahci_blk_private_data *)ahci_gendisk0.private_data)->ahci_port_num = __first_port;
MBR_read_partition_table(&ahci_gendisk0, ((struct ahci_blk_private_data *)ahci_gendisk0.private_data)->part_table);
struct MBR_disk_partition_table_t *ptable = ((struct ahci_blk_private_data *)ahci_gendisk0.private_data)->part_table;
// 求出可用分区数量
for (int i = 0; i < 4; ++i)
{
// 分区可用
if (ptable->DPTE[i].type !=0)
if (ptable->DPTE[i].type != 0)
++ahci_gendisk0.part_cnt;
}
if (ahci_gendisk0.part_cnt)
@ -119,7 +122,7 @@ static int ahci_init_gendisk()
for (int i = 0; i < 4; ++i)
{
// 分区可用
if (ptable->DPTE[i].type !=0)
if (ptable->DPTE[i].type != 0)
{
// 初始化分区结构体
ahci_gendisk0.partition[cnt].bd_disk = &ahci_gendisk0;
@ -171,14 +174,13 @@ void ahci_init()
ahci_port_base_vaddr = (uint64_t)kmalloc(1048576, 0);
kdebug("ahci_port_base_vaddr=%#018lx", ahci_port_base_vaddr);
ahci_probe_port(0);
port_rebase(&ahci_devices[0].hba_mem->ports[0], 0);
// 初始化请求队列
ahci_req_queue.in_service = NULL;
wait_queue_init(&ahci_req_queue.wait_queue_list, NULL);
ahci_req_queue.request_count = 0;
ahci_init_gendisk();
BUG_ON(ahci_init_gendisk() != 0);
kinfo("AHCI initialized.");
}
@ -224,25 +226,28 @@ static void ahci_probe_port(const uint32_t device_num)
{
uint dt = check_type(&abar->ports[i]);
ahci_devices[i].type = dt;
if (dt == AHCI_DEV_SATA)
switch (dt)
{
case AHCI_DEV_SATA:
kdebug("SATA drive found at port %d", i);
}
else if (dt == AHCI_DEV_SATAPI)
{
goto found;
case AHCI_DEV_SATAPI:
kdebug("SATAPI drive found at port %d", i);
}
else if (dt == AHCI_DEV_SEMB)
{
goto found;
case AHCI_DEV_SEMB:
kdebug("SEMB drive found at port %d", i);
}
else if (dt == AHCI_DEV_PM)
{
goto found;
case AHCI_DEV_PM:
kdebug("PM drive found at port %d", i);
}
else
{
// kdebug("No drive found at port %d", i);
goto found;
found:;
port_rebase(&ahci_devices[0].hba_mem->ports[i], i);
if (__first_port == -1)
__first_port = i;
break;
default:
kdebug("No drive found at port %d", i);
break;
}
}
}
@ -599,7 +604,7 @@ static long ahci_query_disk()
ahci_req_queue.in_service = (struct block_device_request_packet *)pack;
list_del(&(ahci_req_queue.in_service->wait_queue.wait_list));
--ahci_req_queue.request_count;
// kdebug("ahci_query_disk");
long ret_val = 0;
switch (pack->blk_pak.cmd)
@ -615,7 +620,7 @@ static long ahci_query_disk()
ret_val = E_UNSUPPORTED_CMD;
break;
}
// kdebug("ahci_query_disk: retval=%d", ret_val);
// ahci_end_request();
return ret_val;
}

View File

@ -94,5 +94,5 @@ void apic_timer_init()
io_mfence();
irq_register(APIC_TIMER_IRQ_NUM, &apic_timer_ticks_result, &apic_timer_handler, 0, &apic_timer_intr_controller, "apic timer");
io_mfence();
kinfo("Successfully initialized apic timer for cpu %d", proc_current_cpu_id);
// kinfo("Successfully initialized apic timer for cpu %d", proc_current_cpu_id);
}

View File

@ -19,6 +19,19 @@
#define USB_TIME_RST_NOMORE 3 // No more than this between resets for root hubs
#define USB_TIME_RST_REC 10 // reset recovery
/**
* @brief usb描述符的头部
*
* String Descriptor:
* String Language Descriptor:
* string desc
*/
struct usb_desc_header
{
uint8_t len; // 整个描述符的大小(字节)
uint8_t type;
} __attribute__((packed));
/**
* @brief usb
*
@ -41,8 +54,85 @@ struct usb_device_desc
uint8_t serial_index;
uint8_t config; // number of configurations
} __attribute__((packed));
/**
* @brief usb设备配置信息描述符
*
*/
struct usb_config_desc
{
uint8_t len; // 当前描述符的大小(字节)
uint8_t type; // USB_DT_CONFIG
uint16_t total_len; /*
Total length of data returned for this
configuration. Includes the combined length
of all descriptors (configuration, interface,
endpoint, and class- or vendor-specific)
returned for this configuration
*/
uint8_t num_interfaces; // 当前conf对应的接口数量
uint8_t value; /*
Value to use as an argument to the
SetConfiguration() request to select this
configuration
*/
uint8_t index; // Index of string descriptor describing this configuration
uint8_t bmAttr; /*
Configuration characteristics:
D7: Reserved (1)
D6: Self-powered
D5: Remote Wakeup
D4...0: Reserved (0)
*/
uint8_t max_power; /*
conf上提供对应的功能
High-speed时2mA 50100mA的电流
Gen X speed时8mA
*/
} __attribute__((packed));
/**
* @brief usb接口描述符
*
*/
struct usb_interface_desc
{
uint8_t len;
uint8_t type; // USB_DT_INTERFACE
uint8_t interface_number; // 当前接口序号从0开始的
uint8_t alternate_setting; // used to select alt. setting
uint8_t num_endpoints; // 当前interface的端点数量
uint8_t interface_class; // Class code
uint8_t interface_sub_class; // Sub class code
uint8_t interface_protocol; // 协议 These codes are qualified by the value of thebInterfaceClass and the bInterfaceSubClass fields.
uint8_t index; // index of String Descriptor describing this interface
} __attribute__((packed));
/**
* @brief usb端点描述符
*
* usb3.2 Specification Table 9-26
*/
struct usb_endpoint_desc
{
uint8_t len;
uint8_t type; // descriptor type
uint8_t endpoint_addr; /* Bit 3...0: The endpoint number
Bit 6...4: Reserved, reset to zero
Bit 7: Direction, ignored for
control endpoints
0 = OUT endpoint
1 = IN endpoint
*/
uint8_t attributes;
uint16_t max_packet;
uint8_t interval;
};
// 从endpoint描述符中获取max burst size大小
#define usb_get_max_burst_from_ep(__ep_desc) (((__ep_desc)->max_packet & 0x1800) >> 11)
/**
* @brief usb设备请求包
*
@ -55,7 +145,7 @@ struct usb_request_packet_t
uint16_t index;
uint16_t length;
};
} __attribute__((packed));
// usb设备请求包的request_type字段的值
#define __USB_REQ_TYPE_H2D 0x00
#define __USB_REQ_TYPE_D2H 0x80
@ -73,6 +163,7 @@ struct usb_request_packet_t
#define USB_REQ_TYPE_GET_REQUEST (__USB_REQ_TYPE_D2H | __USB_REQ_TYPE_STANDARD | __USB_REQ_TYPE_DEVICE)
#define USB_REQ_TYPE_SET_REQUEST (__USB_REQ_TYPE_H2D | __USB_REQ_TYPE_STANDARD | __USB_REQ_TYPE_DEVICE)
#define USB_REQ_TYPE_SET_INTERFACE (__USB_REQ_TYPE_H2D | __USB_REQ_TYPE_STANDARD | __USB_REQ_TYPE_INTERFACE)
#define USB_REQ_TYPE_SET_CLASS_INTERFACE (__USB_REQ_TYPE_H2D | __USB_REQ_TYPE_CLASS | __USB_REQ_TYPE_INTERFACE)
// device requests
enum
@ -90,6 +181,21 @@ enum
USB_REQ_SET_INTERFACE,
// standard endpoint requests
USB_REQ_SYNCH_FRAME,
USB_REQ_SET_ENCRYPTION,
USB_REQ_GET_ENCRYPTION,
USB_REQ_SET_HANDSHAKE,
USB_REQ_GET_HANDSHAKE,
USB_REQ_SET_CONNECTION,
USB_REQ_SET_SECURITY_DATA,
USB_REQ_GET_SECURITY_DATA,
USB_REQ_SET_WUSB_DATA,
USB_REQ_LOOPBACK_DATA_WRITE,
USB_REQ_LOOPBACK_DATA_READ,
USB_REQ_SET_INTERFACE_DS,
USB_REQ_GET_FW_STATUS = 26,
USB_REQ_SET_FW_STATUS,
USB_REQ_SET_SEL = 48,
USB_REQ_SET_ISOCH_DELAY,
// Device specific
USB_REQ_GET_MAX_LUNS = 0xFE,
USB_REQ_BULK_ONLY_RESET
@ -109,6 +215,8 @@ enum
USB_DT_OTG,
USB_DT_DEBUG,
USB_DT_INTERFACE_ASSOSIATION,
USB_DT_BOS = 15,
USB_DT_DEVICE_CAPABILITY,
USB_DT_HID = 0x21,
USB_DT_HID_REPORT,
@ -117,7 +225,10 @@ enum
USB_DT_INTERFACE_FUNCTION = 0x24,
USB_DT_ENDPOINT_FUNCTION,
HUB = 0x29
// HUB = 0x29
USB_DT_SUPERSPEED_USB_ENDPOINT_COMPANION = 48,
USB_DT_SUPERSPEEDPLUS_ISOCHRONOUS_ENDPOINT_COMPANION,
};
// transfer types (Endpoint types) (USB 2.0 page 270)
@ -129,6 +240,49 @@ enum
USB_EP_INTERRUPT
};
/**
* @brief usb请求包
*
*/
#define DECLARE_USB_PACKET(pak_name, _trans_req_type, _trans_request, _trans_value, _trans_index, _transfer_length) \
struct usb_request_packet_t pak_name = {0}; \
pak_name.request_type = (_trans_req_type); \
pak_name.request = (_trans_request); \
pak_name.value = (_trans_value); \
pak_name.index = (_trans_index); \
pak_name.length = (_transfer_length);
/*
usb class codes
refs: https://www.usb.org/defined-class-codes
*/
enum
{
USB_CLASS_IF = 0x00,
USB_CLASS_AUDIO,
USB_CLASS_CDC,
USB_CLASS_HID,
USB_CLASS_PHYSICAL = 0x05,
USB_CLASS_IMAGE,
USB_CLASS_PRINTER,
USB_CLASS_MASS_STORAGE,
USB_CLASS_HUB,
USB_CLASS_CDC_DATA,
USB_CLASS_SMART_CARD,
USB_CLASS_CONTENT_SEC = 0x0d,
USB_CLASS_VIDEO,
USB_CLASS_PERSONAL_HEALTHCARE = 0x0f,
USB_CLASS_AV,
USB_CLASS_BILLBOARD,
USB_CLASS_TYPEC_BRIDGE,
USB_CLASS_I3C = 0x3c,
USB_CLASS_DIAGNOSTIC = 0xdc,
USB_CLASS_WIRELESS_CTRL = 0xe0,
USB_CLASS_MISC = 0xef,
USB_CLASS_APP_SPEC = 0xfe,
USB_CLASS_VENDOR_SPEC = 0XFF,
};
/**
* @brief usb驱动程序
*

View File

@ -0,0 +1,87 @@
#pragma once
/*
MMI/O的方式访问寄存器
32bit的寄存器中的偏移量8的位置开始读取1个字节
32bit的寄存器的0地址处开始读取32bit
*/
#define xhci_read_cap_reg32(id, offset) (__read4b(xhci_hc[id].vbase + (offset)))
#define xhci_get_ptr_cap_reg32(id, offset) ((uint32_t *)(xhci_hc[id].vbase + (offset)))
#define xhci_write_cap_reg32(id, offset, value) (__write4b(xhci_hc[id].vbase + (offset), (value)))
#define xhci_read_cap_reg64(id, offset) (__read8b(xhci_hc[id].vbase + (offset)))
#define xhci_get_ptr_reg64(id, offset) ((uint64_t *)(xhci_hc[id].vbase + (offset)))
#define xhci_write_cap_reg64(id, offset, value) (__write8b(xhci_hc[id].vbase + (offset), (value)))
#define xhci_read_op_reg8(id, offset) (*(uint8_t *)(xhci_hc[id].vbase_op + (offset)))
#define xhci_get_ptr_op_reg8(id, offset) ((uint8_t *)(xhci_hc[id].vbase_op + (offset)))
#define xhci_write_op_reg8(id, offset, value) (*(uint8_t *)(xhci_hc[id].vbase_op + (offset)) = (uint8_t)(value))
#define xhci_read_op_reg32(id, offset) (__read4b(xhci_hc[id].vbase_op + (offset)))
#define xhci_get_ptr_op_reg32(id, offset) ((uint32_t *)(xhci_hc[id].vbase_op + (offset)))
#define xhci_write_op_reg32(id, offset, value) (__write4b(xhci_hc[id].vbase_op + (offset), (value)))
#define xhci_read_op_reg64(id, offset) (__read8b(xhci_hc[id].vbase_op + (offset)))
#define xhci_get_ptr_op_reg64(id, offset) ((uint64_t *)(xhci_hc[id].vbase_op + (offset)))
#define xhci_write_op_reg64(id, offset, value) (__write8b(xhci_hc[id].vbase_op + (offset), (value)))
/**
* @brief
* @param id id
* @param num xhci中断寄存器组号
*/
#define xhci_calc_intr_vaddr(id, num) (xhci_hc[id].vbase + xhci_hc[id].rts_offset + XHCI_RT_IR0 + (num)*XHCI_IR_SIZE)
/**
* @brief /
* @param id id
* @param num xhci中断寄存器组号
* @param intr_offset
*/
#define xhci_read_intr_reg32(id, num, intr_offset) (__read4b(xhci_calc_intr_vaddr(id, num) + (intr_offset)))
#define xhci_write_intr_reg32(id, num, intr_offset, value) (__write4b(xhci_calc_intr_vaddr(id, num) + (intr_offset), (value)))
#define xhci_read_intr_reg64(id, num, intr_offset) (__read8b(xhci_calc_intr_vaddr(id, num) + (intr_offset)))
#define xhci_write_intr_reg64(id, num, intr_offset, value) (__write8b(xhci_calc_intr_vaddr(id, num) + (intr_offset), (value)))
#define xhci_is_aligned64(addr) (((addr)&0x3f) == 0) // 是否64bytes对齐
/**
* @brief
* @param cid id
* @param pid id
*/
#define XHCI_PORT_IS_USB2(cid, pid) ((xhci_hc[cid].ports[pid].flags & XHCI_PROTOCOL_INFO) == XHCI_PROTOCOL_USB2)
#define XHCI_PORT_IS_USB3(cid, pid) ((xhci_hc[cid].ports[pid].flags & XHCI_PROTOCOL_INFO) == XHCI_PROTOCOL_USB3)
#define XHCI_PORT_IS_USB2_HSO(cid, pid) ((xhci_hc[cid].ports[pid].flags & XHCI_PROTOCOL_HSO) == XHCI_PROTOCOL_HSO)
#define XHCI_PORT_HAS_PAIR(cid, pid) ((xhci_hc[cid].ports[pid].flags & XHCI_PROTOCOL_HAS_PAIR) == XHCI_PROTOCOL_HAS_PAIR)
#define XHCI_PORT_IS_ACTIVE(cid, pid) ((xhci_hc[cid].ports[pid].flags & XHCI_PROTOCOL_ACTIVE) == XHCI_PROTOCOL_ACTIVE)
#define XHCI_PORT_REGISTER_OFFSET(__port_id) (XHCI_OPS_PRS + 16 * (__port_id))
// 获取端口速度 full=1, low=2, high=3, super=4
#define xhci_get_port_speed(__id, __port_id) ((xhci_read_op_reg32((__id), XHCI_PORT_REGISTER_OFFSET(__port_id) + XHCI_PORT_PORTSC) >> 10) & 0xf)
/**
* @brief link TRB的命令dword3
*
*/
#define xhci_TRB_set_link_cmd(trb_vaddr) \
do \
{ \
struct xhci_TRB_normal_t *ptr = (struct xhci_TRB_normal_t *)(trb_vaddr); \
ptr->TRB_type = TRB_TYPE_LINK; \
ptr->ioc = 0; \
ptr->chain = 0; \
ptr->ent = 0; \
ptr->cycle = 1; \
} while (0)
// 设置endpoint结构体的dequeue_cycle_state bit
#define xhci_ep_set_dequeue_cycle_state(ep_ctx_ptr, state) ((ep_ctx_ptr)->tr_dequeue_ptr |= ((state)&1))
// 获取endpoint结构体的dequeue_cycle_state bit
#define xhci_ep_get_dequeue_cycle_state(ep_ctx_ptr) (((ep_ctx_ptr)->tr_dequeue_ptr) & 1)

View File

@ -1,4 +1,5 @@
#include "xhci.h"
#include "internal.h"
#include <common/kprint.h>
#include <debug/bug.h>
#include <common/spinlock.h>
@ -38,14 +39,23 @@ static int xhci_hc_init_intr(int id);
static int xhci_hc_start_ports(int id);
static int xhci_send_command(int id, struct xhci_TRB_t *trb, const bool do_ring);
static uint64_t xhci_initialize_slot(const int id, const int slot_id, const int port, const int speed, const int max_packet);
static void xhci_initialize_ep(const int id, const uint64_t slot_vaddr, const int slot_id, const int ep_num, const int max_packet, const int type, const int direction, const int speed, const int ep_interval);
static uint64_t xhci_initialize_slot(const int id, const int port, const int speed, const int max_packet);
static void xhci_initialize_ep(const int id, const uint64_t slot_vaddr, const int port_id, const int ep_num, const int max_packet, const int max_burst, const int type, const int direction, const int speed, const int ep_interval);
static int xhci_set_address(const int id, const uint64_t slot_vaddr, const int slot_id, const bool block);
static int xhci_control_in(const int id, void *target, const int in_size, const int slot_id, const int max_packet);
static int xhci_setup_stage(struct xhci_ep_ring_info_t *ep, const struct usb_request_packet_t *packet, const uint8_t direction);
static int xhci_data_stage(struct xhci_ep_ring_info_t *ep, uint64_t buf_vaddr, uint8_t trb_type, const uint32_t size, uint8_t direction, const int max_packet, const uint64_t status_vaddr);
static int xhci_status_stage(const int id, uint8_t direction, uint64_t status_buf_vaddr);
static int xhci_control_in(const int id, struct usb_request_packet_t *packet, void *target, const int port_id, const int max_packet);
static int xhci_control_out(const int id, struct usb_request_packet_t *packet, void *target, const int slot_id, const int max_packet);
static int xhci_setup_stage(struct xhci_ep_info_t *ep, const struct usb_request_packet_t *packet, const uint8_t direction);
static int xhci_data_stage(struct xhci_ep_info_t *ep, uint64_t buf_vaddr, uint8_t trb_type, const uint32_t size, uint8_t direction, const int max_packet, const uint64_t status_vaddr);
static int xhci_status_stage(struct xhci_ep_info_t *ep, uint8_t direction, uint64_t status_buf_vaddr);
static int xhci_wait_for_interrupt(const int id, uint64_t status_vaddr);
static inline int xhci_get_desc(const int id, const int port_id, void *target, const uint16_t desc_type, const uint8_t desc_index, const uint16_t lang_id, const uint16_t length);
static int xhci_get_config_desc(const int id, const int port_id, struct usb_config_desc *conf_desc);
static inline int xhci_get_config_desc_full(const int id, const int port_id, const struct usb_config_desc *conf_desc, void *target);
static int xhci_get_interface_desc(const void *in_buf, const uint8_t if_num, struct usb_interface_desc **if_desc);
static inline int xhci_get_endpoint_desc(const struct usb_interface_desc *if_desc, const uint8_t ep_num, struct usb_endpoint_desc **ep_desc);
static int xhci_get_descriptor(const int id, const int port_id, struct usb_device_desc *dev_desc);
static int xhci_configure_port(const int id, const int port_id);
static int xhci_configure_endpoint(const int id, const int port_id, const uint8_t ep_num, const uint8_t ep_type, struct usb_endpoint_desc *ep_desc);
hardware_intr_controller xhci_hc_intr_controller =
{
@ -56,87 +66,6 @@ hardware_intr_controller xhci_hc_intr_controller =
.ack = apic_local_apic_edge_ack,
};
/*
MMI/O的方式访问寄存器
32bit的寄存器中的偏移量8的位置开始读取1个字节
32bit的寄存器的0地址处开始读取32bit
*/
#define xhci_read_cap_reg32(id, offset) (__read4b(xhci_hc[id].vbase + (offset)))
#define xhci_get_ptr_cap_reg32(id, offset) ((uint32_t *)(xhci_hc[id].vbase + (offset)))
#define xhci_write_cap_reg32(id, offset, value) (__write4b(xhci_hc[id].vbase + (offset), (value)))
#define xhci_read_cap_reg64(id, offset) (__read8b(xhci_hc[id].vbase + (offset)))
#define xhci_get_ptr_reg64(id, offset) ((uint64_t *)(xhci_hc[id].vbase + (offset)))
#define xhci_write_cap_reg64(id, offset, value) (__write8b(xhci_hc[id].vbase + (offset), (value)))
#define xhci_read_op_reg8(id, offset) (*(uint8_t *)(xhci_hc[id].vbase_op + (offset)))
#define xhci_get_ptr_op_reg8(id, offset) ((uint8_t *)(xhci_hc[id].vbase_op + (offset)))
#define xhci_write_op_reg8(id, offset, value) (*(uint8_t *)(xhci_hc[id].vbase_op + (offset)) = (uint8_t)(value))
#define xhci_read_op_reg32(id, offset) (__read4b(xhci_hc[id].vbase_op + (offset)))
#define xhci_get_ptr_op_reg32(id, offset) ((uint32_t *)(xhci_hc[id].vbase_op + (offset)))
#define xhci_write_op_reg32(id, offset, value) (__write4b(xhci_hc[id].vbase_op + (offset), (value)))
#define xhci_read_op_reg64(id, offset) (__read8b(xhci_hc[id].vbase_op + (offset)))
#define xhci_get_ptr_op_reg64(id, offset) ((uint64_t *)(xhci_hc[id].vbase_op + (offset)))
#define xhci_write_op_reg64(id, offset, value) (__write8b(xhci_hc[id].vbase_op + (offset), (value)))
/**
* @brief
* @param id id
* @param num xhci中断寄存器组号
*/
#define xhci_calc_intr_vaddr(id, num) (xhci_hc[id].vbase + xhci_hc[id].rts_offset + XHCI_RT_IR0 + (num)*XHCI_IR_SIZE)
/**
* @brief /
* @param id id
* @param num xhci中断寄存器组号
* @param intr_offset
*/
#define xhci_read_intr_reg32(id, num, intr_offset) (__read4b(xhci_calc_intr_vaddr(id, num) + (intr_offset)))
#define xhci_write_intr_reg32(id, num, intr_offset, value) (__write4b(xhci_calc_intr_vaddr(id, num) + (intr_offset), (value)))
#define xhci_read_intr_reg64(id, num, intr_offset) (__read8b(xhci_calc_intr_vaddr(id, num) + (intr_offset)))
#define xhci_write_intr_reg64(id, num, intr_offset, value) (__write8b(xhci_calc_intr_vaddr(id, num) + (intr_offset), (value)))
#define xhci_is_aligned64(addr) (((addr)&0x3f) == 0) // 是否64bytes对齐
/**
* @brief
* @param cid id
* @param pid id
*/
#define XHCI_PORT_IS_USB2(cid, pid) ((xhci_hc[cid].ports[pid].flags & XHCI_PROTOCOL_INFO) == XHCI_PROTOCOL_USB2)
#define XHCI_PORT_IS_USB3(cid, pid) ((xhci_hc[cid].ports[pid].flags & XHCI_PROTOCOL_INFO) == XHCI_PROTOCOL_USB3)
#define XHCI_PORT_IS_USB2_HSO(cid, pid) ((xhci_hc[cid].ports[pid].flags & XHCI_PROTOCOL_HSO) == XHCI_PROTOCOL_HSO)
#define XHCI_PORT_HAS_PAIR(cid, pid) ((xhci_hc[cid].ports[pid].flags & XHCI_PROTOCOL_HAS_PAIR) == XHCI_PROTOCOL_HAS_PAIR)
#define XHCI_PORT_IS_ACTIVE(cid, pid) ((xhci_hc[cid].ports[pid].flags & XHCI_PROTOCOL_ACTIVE) == XHCI_PROTOCOL_ACTIVE)
/**
* @brief link TRB的命令dword3
*
*/
#define xhci_TRB_set_link_cmd(trb_vaddr) \
do \
{ \
struct xhci_TRB_normal_t *ptr = (struct xhci_TRB_normal_t *)(trb_vaddr); \
ptr->TRB_type = TRB_TYPE_LINK; \
ptr->ioc = 0; \
ptr->chain = 0; \
ptr->ent = 0; \
ptr->cycle = 1; \
} while (0)
// 设置endpoint结构体的dequeue_cycle_state bit
#define xhci_ep_set_dequeue_cycle_state(ep_ctx_ptr, state) ((ep_ctx_ptr)->tr_dequeue_ptr |= ((state)&1))
// 获取endpoint结构体的dequeue_cycle_state bit
#define xhci_ep_get_dequeue_cycle_state(ep_ctx_ptr) (((ep_ctx_ptr)->tr_dequeue_ptr) & 1)
/**
* @brief controller数组之中寻找可用插槽
*
@ -252,7 +181,7 @@ static __always_inline void __xhci_write_doorbell(const int id, const uint16_t s
* @param ep_info
* @param trb trb
*/
static __always_inline void __xhci_write_trb(struct xhci_ep_ring_info_t *ep_info, struct xhci_TRB_t *trb)
static __always_inline void __xhci_write_trb(struct xhci_ep_info_t *ep_info, struct xhci_TRB_t *trb)
{
memcpy((void *)ep_info->current_ep_ring_vaddr, trb, sizeof(struct xhci_TRB_t));
@ -269,6 +198,18 @@ static __always_inline void __xhci_write_trb(struct xhci_ep_ring_info_t *ep_info
}
}
/**
* @brief
*
* @param id id
* @param port_id id
* @return
*/
static __always_inline uint64_t xhci_get_device_context_vaddr(const int id, const int port_id)
{
return phys_2_virt(__read8b(xhci_hc[id].dcbaap_vaddr + (xhci_hc[id].ports[port_id].slot_id * sizeof(uint64_t))));
}
/**
* @brief xhci主机控制器
*
@ -715,6 +656,7 @@ void xhci_hc_irq_handler(uint64_t irq_num, uint64_t cid, struct pt_regs *regs)
if (((iman0 & 3) == 3) || (dequeue_reg & 8)) // 中断被启用且pending不为0
{
// kdebug("to handle");
// 写入1以清除该interrupter的pending bit
xhci_write_intr_reg32(cid, 0, XHCI_IR_MAN, iman0 | 3);
io_mfence();
@ -723,10 +665,16 @@ void xhci_hc_irq_handler(uint64_t irq_num, uint64_t cid, struct pt_regs *regs)
// 暂存当前trb的起始地址
uint64_t last_event_ring_vaddr = xhci_hc[cid].current_event_ring_vaddr;
xhci_get_trb(&event_trb, xhci_hc[cid].current_event_ring_vaddr);
{
struct xhci_TRB_cmd_complete_t *event_trb_ptr = (struct xhci_TRB_cmd_complete_t *)&event_trb;
// kdebug("TRB_type=%d, comp_code=%d", event_trb_ptr->TRB_type, event_trb_ptr->code);
}
while ((event_trb.command & 1) == xhci_hc[cid].current_event_ring_cycle) // 循环处理处于当前周期的所有event ring
{
struct xhci_TRB_cmd_complete_t *event_trb_ptr = (struct xhci_TRB_cmd_complete_t *)&event_trb;
// kdebug("TRB_type=%d, comp_code=%d", event_trb_ptr->TRB_type, event_trb_ptr->code);
if ((event_trb.command & (1 << 2)) == 0) // 当前event trb不是由于short packet产生的
{
// kdebug("event_trb_ptr->code=%d", event_trb_ptr->code);
@ -851,7 +799,7 @@ static int xhci_reset_port(const int id, const int port)
io_mfence();
if (val & (1 << 21))
break;
// QEMU对usb的模拟有bug因此需要检测这里
// QEMU对usb的模拟有bug因此需要检测这里
#ifdef __QEMU_EMULATION__
if (XHCI_PORT_IS_USB3(id, port) && (val & (1 << 31)) == 0)
@ -911,22 +859,19 @@ static int xhci_reset_port(const int id, const int port)
* set the slot->hub, ->mtt, ->ttt, ->etc, items.
*
* @param id id
* @param slot_id enable_slot命令分配的插槽id
* @param port
* @param speed
* @param max_packet
* @return uint64_t
*/
static uint64_t xhci_initialize_slot(const int id, const int slot_id, const int port, const int speed, const int max_packet)
static uint64_t xhci_initialize_slot(const int id, const int port, const int speed, const int max_packet)
{
// 暂时只初始化slot和control EP0
// 申请上下文数据结构所占用的内存空间
uint64_t device_context_vaddr = (uint64_t)kzalloc(xhci_hc[id].context_size * 2, 0);
// 为所有的endpoint分配上下文空间
// todo: 按需分配上下文空间
uint64_t device_context_vaddr = (uint64_t)kzalloc(xhci_hc[id].context_size * 32, 0);
// kdebug("slot id=%d, device_context_vaddr=%#018lx, port=%d", slot_id, device_context_vaddr, port);
// 写到数组中
__write8b(xhci_hc[id].dcbaap_vaddr + (slot_id * sizeof(uint64_t)), virt_2_phys(device_context_vaddr));
__write8b(xhci_hc[id].dcbaap_vaddr + (xhci_hc[id].ports[port].slot_id * sizeof(uint64_t)), virt_2_phys(device_context_vaddr));
struct xhci_slot_context_t slot_ctx = {0};
slot_ctx.entries = 1;
slot_ctx.speed = speed;
@ -940,7 +885,8 @@ static uint64_t xhci_initialize_slot(const int id, const int slot_id, const int
// 将slot信息写入上下文空间
__write_slot(device_context_vaddr, &slot_ctx);
xhci_initialize_ep(id, device_context_vaddr, slot_id, XHCI_EP_CONTROL, max_packet, USB_EP_CONTROL, 0, speed, 0);
// 初始化控制端点
xhci_initialize_ep(id, device_context_vaddr, port, XHCI_EP_CONTROL, max_packet, 0, USB_EP_CONTROL, 0, speed, 0);
return device_context_vaddr;
}
@ -950,7 +896,7 @@ static uint64_t xhci_initialize_slot(const int id, const int slot_id, const int
*
* @param id id
* @param slot_vaddr slot上下文的虚拟地址
* @param slot_id id
* @param port_id id
* @param ep_num slot上下文区域内的编号
* @param max_packet
* @param type
@ -958,36 +904,59 @@ static uint64_t xhci_initialize_slot(const int id, const int slot_id, const int
* @param speed
* @param ep_interval
*/
static void xhci_initialize_ep(const int id, const uint64_t slot_vaddr, const int slot_id, const int ep_num, const int max_packet, const int type, const int direction, const int speed, const int ep_interval)
static void xhci_initialize_ep(const int id, const uint64_t slot_vaddr, const int port_id, const int ep_num, const int max_packet, const int max_burst, const int type, const int direction, const int speed, const int ep_interval)
{
// 由于目前只实现获取设备的描述符因此暂时只支持control ep
if (type != USB_EP_CONTROL)
if (type != USB_EP_CONTROL && type != USB_EP_INTERRUPT)
return;
struct xhci_ep_context_t ep_ctx = {0};
memset(&ep_ctx, 0, sizeof(struct xhci_ep_context_t));
xhci_hc[id].control_ep_info.ep_ring_vbase = xhci_create_ring(XHCI_TRBS_PER_RING);
xhci_hc[id].ports[port_id].ep_info[ep_num].ep_ring_vbase = xhci_create_ring(XHCI_TRBS_PER_RING);
// 申请ep的 transfer ring
ep_ctx.tr_dequeue_ptr = virt_2_phys(xhci_hc[id].control_ep_info.ep_ring_vbase);
ep_ctx.tr_dequeue_ptr = virt_2_phys(xhci_hc[id].ports[port_id].ep_info[ep_num].ep_ring_vbase);
xhci_ep_set_dequeue_cycle_state(&ep_ctx, XHCI_TRB_CYCLE_ON);
xhci_hc[id].control_ep_info.current_ep_ring_vaddr = xhci_hc[id].control_ep_info.ep_ring_vbase;
xhci_hc[id].control_ep_info.current_ep_ring_cycle = xhci_ep_get_dequeue_cycle_state(&ep_ctx);
xhci_hc[id].ports[port_id].ep_info[ep_num].current_ep_ring_vaddr = xhci_hc[id].ports[port_id].ep_info[ep_num].ep_ring_vbase;
xhci_hc[id].ports[port_id].ep_info[ep_num].current_ep_ring_cycle = xhci_ep_get_dequeue_cycle_state(&ep_ctx);
// kdebug("ep_ctx.tr_dequeue_ptr = %#018lx", ep_ctx.tr_dequeue_ptr);
// kdebug("xhci_hc[id].control_ep_info.current_ep_ring_cycle = %d", xhci_hc[id].control_ep_info.current_ep_ring_cycle);
kdebug("max_packet=%d, max_burst=%d", max_packet, max_burst);
switch (type)
{
case USB_EP_CONTROL: // Control ep
// 设置初始值
ep_ctx.max_packet_size = max_packet;
ep_ctx.linear_stream_array = 0;
ep_ctx.max_primary_streams = 0;
ep_ctx.mult = 0;
ep_ctx.ep_state = XHCI_EP_STATE_DISABLED;
ep_ctx.hid = 0;
ep_ctx.ep_type = XHCI_EP_TYPE_CONTROL;
ep_ctx.average_trb_len = 8; // 所有的control ep的该值均为8
ep_ctx.err_cnt = 3;
ep_ctx.max_burst_size = max_burst;
ep_ctx.interval = ep_interval;
break;
case USB_EP_INTERRUPT:
ep_ctx.max_packet_size = max_packet & 0x7ff;
ep_ctx.max_burst_size = max_burst;
ep_ctx.ep_state = XHCI_EP_STATE_DISABLED;
ep_ctx.mult = 0;
ep_ctx.err_cnt = 3;
ep_ctx.max_esti_payload_hi = ((max_packet * (max_burst + 1)) >> 8) & 0xff;
ep_ctx.max_esti_payload_lo = ((max_packet * (max_burst + 1))) & 0xff;
ep_ctx.interval = ep_interval;
ep_ctx.average_trb_len = 8; // todo: It's not sure how much to fill in this value
// ep_ctx.ep_type = XHCI_EP_TYPE_INTR_IN;
ep_ctx.ep_type = ((ep_num % 2) ? XHCI_EP_TYPE_INTR_IN : XHCI_EP_TYPE_INTR_OUT);
break;
default:
break;
}
// 设置初始值
ep_ctx.max_packet_size = max_packet;
ep_ctx.linear_stream_array = 0;
ep_ctx.max_primary_streams = 0;
ep_ctx.mult = 0;
ep_ctx.ep_state = XHCI_EP_STATE_DISABLED;
ep_ctx.hid = 0;
ep_ctx.ep_type = 4;
ep_ctx.average_trb_len = 8; // 所有的control ep的该值均为8
ep_ctx.err_cnt = 3;
ep_ctx.max_burst_size = 0;
ep_ctx.interval = ep_interval;
// 将ep的信息写入到slot上下文中对应的ep的块中
__write_ep(id, slot_vaddr, ep_num, &ep_ctx);
}
@ -1007,7 +976,7 @@ static int xhci_set_address(const int id, const uint64_t slot_vaddr, const int s
struct xhci_slot_context_t slot;
struct xhci_ep_context_t ep;
// 创建输入上下文缓冲区
uint64_t input_ctx_buffer = (uint64_t)kzalloc(xhci_hc[id].context_size * 32, 0);
uint64_t input_ctx_buffer = (uint64_t)kzalloc(xhci_hc[id].context_size * 33, 0);
// 置位input control context和slot context的add bit
__write4b(input_ctx_buffer + 4, 0x3);
@ -1063,7 +1032,7 @@ failed:;
* @param direction
* @return int TRB数量
*/
static int xhci_setup_stage(struct xhci_ep_ring_info_t *ep, const struct usb_request_packet_t *packet, const uint8_t direction)
static int xhci_setup_stage(struct xhci_ep_info_t *ep, const struct usb_request_packet_t *packet, const uint8_t direction)
{
// kdebug("ep->current_ep_ring_cycle=%d", ep->current_ep_ring_cycle);
struct xhci_TRB_setup_stage_t trb = {0};
@ -1097,7 +1066,7 @@ static int xhci_setup_stage(struct xhci_ep_ring_info_t *ep, const struct usb_req
* @param status_vaddr event data TRB的缓冲区416
* @return int TRB数量
*/
static int xhci_data_stage(struct xhci_ep_ring_info_t *ep, uint64_t buf_vaddr, uint8_t trb_type, const uint32_t size, uint8_t direction, const int max_packet, const uint64_t status_vaddr)
static int xhci_data_stage(struct xhci_ep_info_t *ep, uint64_t buf_vaddr, uint8_t trb_type, const uint32_t size, uint8_t direction, const int max_packet, const uint64_t status_vaddr)
{
if (size == 0)
return 0;
@ -1148,25 +1117,26 @@ static int xhci_data_stage(struct xhci_ep_ring_info_t *ep, uint64_t buf_vaddr, u
/**
* @brief xhci status stage TRB到control ep的transfer ring
*
* @param id id
* @param ep
* @param direction h2d:0, d2h:1
* @param status_buf_vaddr
* @return int TRB数量
*/
static int xhci_status_stage(const int id, uint8_t direction, uint64_t status_buf_vaddr)
static int xhci_status_stage(struct xhci_ep_info_t *ep, uint8_t direction, uint64_t status_buf_vaddr)
{
// kdebug("write status stage trb");
{
struct xhci_TRB_status_stage_t trb = {0};
// 写入status stage trb
trb.intr_target = 0;
trb.cycle = xhci_hc[id].control_ep_info.current_ep_ring_cycle;
trb.cycle = ep->current_ep_ring_cycle;
trb.ent = 0;
trb.ioc = 1;
trb.TRB_type = TRB_TYPE_STATUS_STAGE;
trb.dir = direction;
__xhci_write_trb(&xhci_hc[id].control_ep_info, (struct xhci_TRB_t *)&trb);
__xhci_write_trb(ep, (struct xhci_TRB_t *)&trb);
}
{
@ -1177,10 +1147,11 @@ static int xhci_status_stage(const int id, uint8_t direction, uint64_t status_bu
trb.TRB_type = TRB_TYPE_EVENT_DATA;
trb.ioc = 1;
trb.cycle = xhci_hc[id].control_ep_info.current_ep_ring_cycle;
trb.cycle = ep->current_ep_ring_cycle;
__xhci_write_trb(&xhci_hc[id].control_ep_info, (struct xhci_TRB_t *)&trb);
__xhci_write_trb(ep, (struct xhci_TRB_t *)&trb);
}
return 2;
}
@ -1227,27 +1198,26 @@ static int xhci_wait_for_interrupt(const int id, uint64_t status_vaddr)
* @brief control endpoint读取信息
*
* @param id id
* @param packet usb数据包
* @param target
* @param in_size
* @param slot_id id
* @param port_id id
* @param max_packet
* @return int
*/
static int xhci_control_in(const int id, void *target, const int in_size, const int slot_id, const int max_packet)
static int xhci_control_in(const int id, struct usb_request_packet_t *packet, void *target, const int port_id, const int max_packet)
{
uint64_t status_buf_vaddr = (uint64_t)kzalloc(16, 0); // 本来是要申请4bytes的buffer的但是因为xhci控制器需要16bytes对齐因此申请16bytes
uint64_t data_buf_vaddr = (uint64_t)kzalloc(256, 0);
uint64_t data_buf_vaddr = 0;
int retval = 0;
struct usb_request_packet_t packet = {0};
packet.request_type = USB_REQ_TYPE_GET_REQUEST;
packet.request = USB_REQ_GET_DESCRIPTOR;
packet.value = (USB_DT_DEVICE << 8);
packet.length = in_size;
// 往control ep写入一个setup stage trb
xhci_setup_stage(&xhci_hc[id].control_ep_info, &packet, XHCI_DIR_IN);
xhci_data_stage(&xhci_hc[id].control_ep_info, data_buf_vaddr, TRB_TYPE_DATA_STAGE, in_size, XHCI_DIR_IN_BIT, max_packet, status_buf_vaddr);
xhci_setup_stage(&xhci_hc[id].ports[port_id].ep_info[XHCI_EP_CONTROL], packet, XHCI_DIR_IN);
if (packet->length)
{
data_buf_vaddr = (uint64_t)kzalloc(packet->length, 0);
xhci_data_stage(&xhci_hc[id].ports[port_id].ep_info[XHCI_EP_CONTROL], data_buf_vaddr, TRB_TYPE_DATA_STAGE, packet->length, XHCI_DIR_IN_BIT, max_packet, status_buf_vaddr);
}
/*
QEMU doesn't quite handle SETUP/DATA/STATUS transactions correctly.
@ -1263,15 +1233,15 @@ static int xhci_control_in(const int id, void *target, const int in_size, const
#ifndef __QEMU_EMULATION__
// 如果不是qemu虚拟机则可以直接发起传输
// kdebug(" not qemu");
__xhci_write_doorbell(id, slot_id, XHCI_EP_CONTROL);
__xhci_write_doorbell(id, xhci_hc[id].ports[port_id].slot_id, XHCI_EP_CONTROL);
retval = xhci_wait_for_interrupt(id, status_buf_vaddr);
if (unlikely(retval != 0))
goto failed;
#endif
memset((void *)status_buf_vaddr, 0, 16);
xhci_status_stage(id, XHCI_DIR_OUT_BIT, status_buf_vaddr);
xhci_status_stage(&xhci_hc[id].ports[port_id].ep_info[XHCI_EP_CONTROL], XHCI_DIR_OUT_BIT, status_buf_vaddr);
__xhci_write_doorbell(id, slot_id, XHCI_EP_CONTROL);
__xhci_write_doorbell(id, xhci_hc[id].ports[port_id].slot_id, XHCI_EP_CONTROL);
retval = xhci_wait_for_interrupt(id, status_buf_vaddr);
@ -1279,8 +1249,9 @@ static int xhci_control_in(const int id, void *target, const int in_size, const
goto failed;
// 将读取到的数据拷贝到目标区域
memcpy(target, (void *)data_buf_vaddr, in_size);
retval = in_size;
if (packet->length)
memcpy(target, (void *)data_buf_vaddr, packet->length);
retval = packet->length;
goto done;
failed:;
@ -1289,31 +1260,217 @@ failed:;
done:;
// 释放内存
kfree((void *)status_buf_vaddr);
kfree((void *)data_buf_vaddr);
if (packet->length)
kfree((void *)data_buf_vaddr);
return retval;
}
/**
* @brief
* @brief control ep输出信息
*
* @param id id
* @param packet usb数据包
* @param target
* @param port_id id
* @param max_packet
* @return int
*/
static int xhci_control_out(const int id, struct usb_request_packet_t *packet, void *target, const int port_id, const int max_packet)
{
uint64_t status_buf_vaddr = (uint64_t)kzalloc(16, 0);
uint64_t data_buf_vaddr = 0;
int retval = 0;
// 往control ep写入一个setup stage trb
xhci_setup_stage(&xhci_hc[id].ports[port_id].ep_info[XHCI_EP_CONTROL], packet, XHCI_DIR_OUT);
if (packet->length)
{
data_buf_vaddr = (uint64_t)kzalloc(packet->length, 0);
xhci_data_stage(&xhci_hc[id].ports[port_id].ep_info[XHCI_EP_CONTROL], data_buf_vaddr, TRB_TYPE_DATA_STAGE, packet->length, XHCI_DIR_OUT_BIT, max_packet, status_buf_vaddr);
}
#ifndef __QEMU_EMULATION__
// 如果不是qemu虚拟机则可以直接发起传输
__xhci_write_doorbell(id, xhci_hc[id].ports[port_id].slot_id, XHCI_EP_CONTROL);
retval = xhci_wait_for_interrupt(id, status_buf_vaddr);
if (unlikely(retval != 0))
goto failed;
#endif
memset((void *)status_buf_vaddr, 0, 16);
xhci_status_stage(&xhci_hc[id].ports[port_id].ep_info[XHCI_EP_CONTROL], XHCI_DIR_IN_BIT, status_buf_vaddr);
__xhci_write_doorbell(id, xhci_hc[id].ports[port_id].slot_id, XHCI_EP_CONTROL);
#ifndef __QEMU_EMULATION__
// qemu对于这个操作的处理有问题status_buf并不会被修改。而真机不存在该问题
retval = xhci_wait_for_interrupt(id, status_buf_vaddr);
#endif
if (unlikely(retval != 0))
goto failed;
// 将读取到的数据拷贝到目标区域
if (packet->length)
memcpy(target, (void *)data_buf_vaddr, packet->length);
retval = packet->length;
goto done;
failed:;
kdebug("wait 4 interrupt failed");
retval = 0;
done:;
// 释放内存
kfree((void *)status_buf_vaddr);
if (packet->length)
kfree((void *)data_buf_vaddr);
return retval;
}
/**
* @brief
*
* @param id
* @param port_id
* @param target
* @param desc_type
* @param desc_index
* @param lang_id id0
* @param length
* @return int
*/
static inline int xhci_get_desc(const int id, const int port_id, void *target, const uint16_t desc_type, const uint8_t desc_index, const uint16_t lang_id, const uint16_t length)
{
struct usb_device_desc *dev_desc = xhci_hc[id].ports[port_id].dev_desc;
int count;
BUG_ON(dev_desc == NULL);
// 设备端口没有对应的描述符
if (unlikely(dev_desc == NULL))
return -EINVAL;
DECLARE_USB_PACKET(ctrl_in_packet, USB_REQ_TYPE_GET_REQUEST, USB_REQ_GET_DESCRIPTOR, (desc_type << 8) | desc_index, lang_id, length);
count = xhci_control_in(id, &ctrl_in_packet, target, port_id, dev_desc->max_packet_size);
if (unlikely(count == 0))
return -EAGAIN;
return 0;
}
static inline int xhci_set_configuration(const int id, const int port_id, const uint8_t conf_value)
{
struct usb_device_desc *dev_desc = xhci_hc[id].ports[port_id].dev_desc;
int count;
BUG_ON(dev_desc == NULL);
// 设备端口没有对应的描述符
if (unlikely(dev_desc == NULL))
return -EINVAL;
DECLARE_USB_PACKET(ctrl_out_packet, USB_REQ_TYPE_SET_REQUEST, USB_REQ_SET_CONFIGURATION, conf_value & 0xff, 0, 0);
kdebug("set conf: to control out");
count = xhci_control_out(id, &ctrl_out_packet, NULL, port_id, dev_desc->max_packet_size);
kdebug("set conf: count=%d", count);
return 0;
}
/**
* @brief usb config_desc
*
* @param id id
* @param port_id id
* @param conf_desc conf_desc
* @return int
*/
static int xhci_get_descriptor(const int id, const int port_id)
static int xhci_get_config_desc(const int id, const int port_id, struct usb_config_desc *conf_desc)
{
if (unlikely(conf_desc == NULL))
return -EINVAL;
kdebug("to get conf for port %d", port_id);
int retval = xhci_get_desc(id, port_id, conf_desc, USB_DT_CONFIG, 0, 0, 9);
if (unlikely(retval != 0))
return retval;
kdebug("port %d got conf ok. type=%d, len=%d, total_len=%d, num_interfaces=%d, max_power=%dmA", port_id, conf_desc->type, conf_desc->len, conf_desc->total_len, conf_desc->num_interfaces, (xhci_get_port_speed(id, port_id) == XHCI_PORT_SPEED_SUPER) ? (conf_desc->max_power * 8) : (conf_desc->max_power * 2));
return 0;
}
/**
* @brief config descconfinterfaceendpoint
*
* @param id id
* @param port_id id
* @param conf_desc config_desc
* @param target
* @return int
*/
static inline int xhci_get_config_desc_full(const int id, const int port_id, const struct usb_config_desc *conf_desc, void *target)
{
if (unlikely(conf_desc == NULL || target == NULL))
return -EINVAL;
return xhci_get_desc(id, port_id, target, USB_DT_CONFIG, 0, 0, conf_desc->total_len);
}
/**
* @brief conf_desc数据中获取指定的interface_desc的指针
*
* @param in_buf conf_desc的缓冲区
* @param if_num
* @param if_desc
* @return int
*/
static int xhci_get_interface_desc(const void *in_buf, const uint8_t if_num, struct usb_interface_desc **if_desc)
{
if (unlikely(if_desc == NULL || in_buf == NULL))
return -EINVAL;
kdebug("to get interface.");
// 判断接口index是否合理
if (if_num >= ((struct usb_config_desc *)in_buf)->num_interfaces)
return -EINVAL;
struct usb_interface_desc *ptr = (struct usb_interface_desc *)(in_buf + sizeof(struct usb_config_desc));
for (int i = 0; i < if_num; ++i)
{
ptr = (struct usb_interface_desc *)(((uint64_t)ptr) + sizeof(struct usb_interface_desc) + sizeof(struct usb_endpoint_desc) * ptr->num_endpoints);
}
// 返回结果
*if_desc = ptr;
kdebug("get interface desc ok. interface_number=%d, num_endpoints=%d, class=%d, subclass=%d", ptr->interface_number, ptr->num_endpoints, ptr->interface_class, ptr->interface_sub_class);
return 0;
}
/**
* @brief
*
* @param if_desc
* @param ep_num
* @param ep_desc
* @return int
*/
static inline int xhci_get_endpoint_desc(const struct usb_interface_desc *if_desc, const uint8_t ep_num, struct usb_endpoint_desc **ep_desc)
{
if (unlikely(if_desc == NULL || ep_desc == NULL))
return -EINVAL;
BUG_ON(ep_num >= if_desc->num_endpoints);
*ep_desc = (struct usb_endpoint_desc *)((uint64_t)(if_desc + 1) + ep_num * sizeof(struct usb_endpoint_desc));
kdebug("get endpoint desc: ep_addr=%d, max_packet=%d, attr=%#06x, interval=%d", (*ep_desc)->endpoint_addr, (*ep_desc)->max_packet, (*ep_desc)->attributes, (*ep_desc)->interval);
return 0;
}
/**
* @brief
*
* @param id id
* @param port_id id
* @param dev_desc
* @return int
*/
static int xhci_get_descriptor(const int id, const int port_id, struct usb_device_desc *dev_desc)
{
int retval = 0;
int count = 0;
struct usb_device_desc dev_desc = {0};
uint32_t dword;
// 计算port register set相对于operational registers基地址的偏移量
uint32_t port_register_offset = XHCI_OPS_PRS + 16 * port_id;
// 读取指定端口的port sc寄存器
dword = xhci_read_op_reg32(id, port_register_offset + XHCI_PORT_PORTSC);
if (unlikely(dev_desc == NULL))
return -EINVAL;
// 读取端口速度。 full=1, low=2, high=3, super=4
uint32_t speed = ((dword >> 10) & 0xf);
uint32_t speed = xhci_get_port_speed(id, port_id);
/*
* Some devices will only send the first 8 bytes of the device descriptor
@ -1349,11 +1506,15 @@ static int xhci_get_descriptor(const int id, const int port_id)
break;
}
}
else
return -EAGAIN; // slot id 不合法
xhci_hc[id].ports[port_id].slot_id = slot_id;
// kdebug("speed=%d", speed);
// 初始化接口的上下文
uint64_t slot_vaddr = xhci_initialize_slot(id, slot_id, port_id, speed, max_packet);
uint64_t slot_vaddr = xhci_initialize_slot(id, port_id, speed, max_packet);
retval = xhci_set_address(id, slot_vaddr, slot_id, true);
// kdebug("set addr again");
// 再次发送 set_address命令
// kdebug("to set addr again");
@ -1361,16 +1522,19 @@ static int xhci_get_descriptor(const int id, const int port_id)
if (retval != 0)
return retval;
// kdebug("ctrl in again");
count = xhci_control_in(id, &dev_desc, 18, slot_id, max_packet);
memset(dev_desc, 0, sizeof(struct usb_device_desc));
DECLARE_USB_PACKET(ctrl_in_packet, USB_REQ_TYPE_GET_REQUEST, USB_REQ_GET_DESCRIPTOR, (USB_DT_DEVICE << 8), 0, 18);
count = xhci_control_in(id, &ctrl_in_packet, dev_desc, port_id, max_packet);
if (unlikely(count == 0))
return -EAGAIN;
/*
TODO: if the dev_desc.max_packet was different than what we have as max_packet,
TODO: if the dev_desc->max_packet was different than what we have as max_packet,
you would need to change it here and in the slot context by doing a
evaluate_slot_context call.
*/
xhci_hc[id].ports[port_id].dev_desc = dev_desc;
// print the descriptor
printk(" Found USB Device:\n"
" port: %i\n"
@ -1388,12 +1552,11 @@ static int xhci_get_descriptor(const int id, const int port_id)
" product index: %i\n"
" serial index: %i\n"
" number of configs: %i\n",
port_id, dev_desc.len, dev_desc.type, dev_desc.usb_version >> 8, dev_desc.usb_version & 0xFF, dev_desc._class, dev_desc.subclass,
dev_desc.protocol, dev_desc.max_packet_size, dev_desc.vendor_id, dev_desc.product_id,
(dev_desc.device_rel & 0xF000) >> 12, (dev_desc.device_rel & 0x0F00) >> 8,
(dev_desc.device_rel & 0x00F0) >> 4, (dev_desc.device_rel & 0x000F) >> 0,
dev_desc.manufacturer_index, dev_desc.procuct_index, dev_desc.serial_index, dev_desc.config);
port_id, dev_desc->len, dev_desc->type, dev_desc->usb_version >> 8, dev_desc->usb_version & 0xFF, dev_desc->_class, dev_desc->subclass,
dev_desc->protocol, dev_desc->max_packet_size, dev_desc->vendor_id, dev_desc->product_id,
(dev_desc->device_rel & 0xF000) >> 12, (dev_desc->device_rel & 0x0F00) >> 8,
(dev_desc->device_rel & 0x00F0) >> 4, (dev_desc->device_rel & 0x000F) >> 0,
dev_desc->manufacturer_index, dev_desc->procuct_index, dev_desc->serial_index, dev_desc->config);
return 0;
}
@ -1422,8 +1585,12 @@ static int xhci_hc_start_ports(int id)
// 否则reset函数会把它给设置为未激活并且标志配对的usb2端口是激活的
{
// kdebug("reset port %d ok", id);
if (xhci_get_descriptor(id, i) == 0)
struct usb_device_desc dev_desc = {0};
if (xhci_get_descriptor(id, i, &dev_desc) == 0)
{
xhci_configure_port(id, i);
++cnt;
}
kdebug("usb3 port %d get desc ok", i);
}
}
@ -1443,8 +1610,12 @@ static int xhci_hc_start_ports(int id)
{
// kdebug("reset port %d ok", id);
if (xhci_get_descriptor(id, i) == 0)
struct usb_device_desc dev_desc = {0};
if (xhci_get_descriptor(id, i, &dev_desc) == 0)
{
xhci_configure_port(id, i);
++cnt;
}
kdebug("USB2 port %d get desc ok", i);
}
}
@ -1453,6 +1624,151 @@ static int xhci_hc_start_ports(int id)
return 0;
}
/**
* @brief HID设备的IDLE数据包
*
* @param id
* @param port_id
* @param if_desc
* @return int
*/
static int xhci_hid_set_idle(const int id, const int port_id, struct usb_interface_desc *if_desc)
{
struct usb_device_desc *dev_desc = xhci_hc[id].ports[port_id].dev_desc;
if (unlikely(dev_desc) == NULL)
{
BUG_ON(1);
return -EINVAL;
}
DECLARE_USB_PACKET(ctrl_out_packet, USB_REQ_TYPE_SET_CLASS_INTERFACE, 0x0a, 0, 0, 0);
xhci_control_out(id, &ctrl_out_packet, NULL, port_id, dev_desc->max_packet_size);
kdebug("xhci set idle done!");
return 0;
}
/**
* @brief configure endpoint命令
*
* @param id id
* @param port_id
* @param ep_num
* @param ep_type
* @param ep_desc
* @return int
*/
static int xhci_configure_endpoint(const int id, const int port_id, const uint8_t ep_num, const uint8_t ep_type, struct usb_endpoint_desc *ep_desc)
{
int retval = 0;
uint64_t slot_context_vaddr = xhci_get_device_context_vaddr(id, port_id);
xhci_initialize_ep(id, slot_context_vaddr, port_id, ep_num, xhci_hc[id].ports[port_id].dev_desc->max_packet_size,
usb_get_max_burst_from_ep(ep_desc), ep_type, (ep_num % 2) ? XHCI_DIR_IN_BIT : XHCI_DIR_OUT_BIT,
xhci_get_port_speed(id, port_id), ep_desc->interval);
struct xhci_slot_context_t slot;
struct xhci_ep_context_t ep = {0};
// 创建输入上下文缓冲区
uint64_t input_ctx_buffer = (uint64_t)kzalloc(xhci_hc[id].context_size * 33, 0);
// 置位对应的add bit
__write4b(input_ctx_buffer + 4, (1 << ep_num)|1);
__write4b(input_ctx_buffer + 0x1c, 1);
// 拷贝slot上下文
__read_from_slot(&slot, slot_context_vaddr);
// 设置该端口的最大端点号。注意,必须设置这里,否则会出错
slot.entries = (ep_num > slot.entries) ? ep_num : slot.entries;
__write_slot(input_ctx_buffer + xhci_hc[id].context_size, &slot);
// __write_ep(id, input_ctx_buffer, 2, &ep);
// kdebug("ep_num=%d", ep_num);
// 拷贝将要被配置的端点的信息
__read_from_ep(id, slot_context_vaddr, ep_num, &ep);
// kdebug("ep.tr_dequeue_ptr=%#018lx", ep.tr_dequeue_ptr);
ep.err_cnt = 3;
// 加一是因为input_context头部比slot_context多了一个input_control_ctx
__write_ep(id, input_ctx_buffer, ep_num + 1, &ep);
struct xhci_TRB_normal_t trb = {0};
trb.buf_paddr = virt_2_phys(input_ctx_buffer);
trb.TRB_type = TRB_TYPE_CONFIG_EP;
trb.cycle = xhci_hc[id].cmd_trb_cycle;
trb.Reserved |= (((uint16_t)xhci_hc[id].ports[port_id].slot_id) << 8) & 0xffff;
// kdebug("addr=%#018lx", ((struct xhci_TRB_t *)&trb)->param);
// kdebug("status=%#018lx", ((struct xhci_TRB_t *)&trb)->status);
// kdebug("command=%#018lx", ((struct xhci_TRB_t *)&trb)->command);
retval = xhci_send_command(id, (struct xhci_TRB_t *)&trb, true);
if (unlikely(retval != 0))
{
kerror("port_id:%d, configure endpoint %d failed", port_id, ep_num);
goto failed;
}
struct xhci_TRB_cmd_complete_t *trb_done = (struct xhci_TRB_cmd_complete_t *)&trb;
if (trb_done->code == TRB_COMP_TRB_SUCCESS) // 成功执行
{
// 如果要从控制器获取刚刚设置的设备地址的话可以在这里读取slot context
ksuccess("port_id:%d, ep:%d successfully configured.", port_id, ep_num);
retval = 0;
}
else
retval = -EAGAIN;
done:;
failed:;
kfree((void *)input_ctx_buffer);
return retval;
}
/**
* @brief
*
* @param id id
* @param port_id id
* @param full_conf config
* @return int
*/
static int xhci_configure_port(const int id, const int port_id)
{
void *full_conf = NULL;
struct usb_interface_desc *if_desc = NULL;
struct usb_endpoint_desc *ep_desc = NULL;
// hint: 暂时只考虑对键盘的初始化
// 获取完整的config
{
struct usb_config_desc conf_desc = {0};
xhci_get_config_desc(id, port_id, &conf_desc);
full_conf = kzalloc(conf_desc.total_len, 0);
xhci_get_config_desc_full(id, port_id, &conf_desc, full_conf);
}
xhci_get_interface_desc(full_conf, 0, &if_desc);
if (if_desc->interface_class == USB_CLASS_HID)
{
// 由于暂时只支持键盘,因此把键盘的驱动也写在这里
// todo: 分离usb键盘驱动
xhci_get_endpoint_desc(if_desc, 0, &ep_desc);
// kdebug("to set conf, val=%#010lx", ((struct usb_config_desc *)full_conf)->value);
xhci_set_configuration(id, port_id, ((struct usb_config_desc *)full_conf)->value);
// kdebug("set conf ok");
// todo: configure endpoint
xhci_configure_endpoint(id, port_id, ep_desc->endpoint_addr, USB_EP_INTERRUPT, ep_desc);
xhci_hid_set_idle(id, port_id, if_desc);
// 获取report desc
// todo: parse hid report
}
kfree(full_conf);
return 0;
}
/**
* @brief xhci主机控制器的中断控制
*

View File

@ -492,6 +492,13 @@ struct xhci_ep_context_t
#define XHCI_PROTOCOL_HAS_PAIR (1 << 2) // 当前位被置位,意味着当前端口具有一个与之配对的端口
#define XHCI_PROTOCOL_ACTIVE (1 << 3) // 当前端口是这个配对中,被激活的端口
struct xhci_ep_info_t
{
uint64_t ep_ring_vbase; // transfer ring的基地址
uint64_t current_ep_ring_vaddr; // transfer ring下一个要写入的地址
uint8_t current_ep_ring_cycle; // 当前ep的cycle bit
};
/**
* @brief xhci端口信息
*
@ -502,14 +509,11 @@ struct xhci_port_info_t
uint8_t paired_port_num; // 与当前端口所配对的另一个端口相同物理接口的不同速度的port
uint8_t offset; // offset of this port within this protocal
uint8_t reserved;
uint8_t slot_id; // address device获得的slot id
struct usb_device_desc *dev_desc; // 指向设备描述符结构体的指针
struct xhci_ep_info_t ep_info[32]; // 各个端点的信息
} __attribute__((packed));
struct xhci_ep_ring_info_t
{
uint64_t ep_ring_vbase; // transfer ring的基地址
uint64_t current_ep_ring_vaddr; // transfer ring下一个要写入的地址
uint8_t current_ep_ring_cycle; // 当前ep的cycle bit
};
struct xhci_host_controller_t
{
struct pci_device_structure_general_device_t *pci_dev_hdr; // 指向pci header结构体的指针
@ -537,7 +541,6 @@ struct xhci_host_controller_t
uint64_t current_event_ring_vaddr; // 下一个要读取的event TRB的虚拟地址
uint64_t scratchpad_buf_array_vaddr; // 草稿行缓冲区数组的虚拟地址
struct xhci_port_info_t ports[XHCI_MAX_ROOT_HUB_PORTS]; // 指向端口信息数组的指针(由于端口offset是从1开始的因此该数组第0项为空)
struct xhci_ep_ring_info_t control_ep_info; // 控制端点的信息
};
// Common TRB types
@ -623,6 +626,21 @@ enum
/* 224 - 225 vendor defined info */
};
/**
* @brief xhci endpoint类型
*
*/
enum
{
XHCI_EP_TYPE_INVALID = 0,
XHCI_EP_TYPE_ISO_OUT,
XHCI_EP_TYPE_BULK_OUT,
XHCI_EP_TYPE_INTR_OUT,
XHCI_EP_TYPE_CONTROL,
XHCI_EP_TYPE_ISO_IN,
XHCI_EP_TYPE_BULK_IN,
XHCI_EP_TYPE_INTR_IN,
};
/**
* @brief xhci控制器
*

View File

@ -18,17 +18,15 @@ extern struct blk_gendisk ahci_gendisk0;
/**
* @brief fat32文件系统
*
* @param ahci_ctrl_num ahci控制器编号
* @param ahci_port_num ahci控制器端口编号
* @param blk_dev
* @param part_num
*
* @return struct vfs_super_block_t *
*/
struct vfs_superblock_t *fat32_register_partition(uint8_t ahci_ctrl_num, uint8_t ahci_port_num, uint8_t part_num)
struct vfs_superblock_t *fat32_register_partition(struct block_device *blk_dev, uint8_t part_num)
{
// 挂载文件系统到vfs
return vfs_mount_fs("/", "FAT32", (ahci_gendisk0.partition + 0));
return vfs_mount_fs("/", "FAT32", blk_dev);
}
/**
@ -1259,6 +1257,6 @@ void fat32_init()
vfs_register_filesystem(&fat32_fs_type);
// 挂载根文件系统
fat32_register_partition(0, 0, 0);
fat32_register_partition(ahci_gendisk0.partition + 0, 0);
kinfo("FAT32 initialized.");
}

View File

@ -167,11 +167,12 @@ typedef struct fat32_inode_info_t fat32_inode_info_t;
/**
* @brief fat32文件系统
*
* @param ahci_ctrl_num ahci控制器编号
* @param ahci_port_num ahci控制器端口编号
* @param blk_dev
* @param part_num
*
* @return struct vfs_super_block_t *
*/
struct vfs_superblock_t *fat32_register_partition(uint8_t ahci_ctrl_num, uint8_t ahci_port_num, uint8_t part_num);
struct vfs_superblock_t *fat32_register_partition(struct block_device *blk_dev, uint8_t part_num);
/**
* @brief fat32文件系统的超级块
@ -179,7 +180,7 @@ struct vfs_superblock_t *fat32_register_partition(uint8_t ahci_ctrl_num, uint8_t
* @param blk
* @return struct vfs_superblock_t*
*/
struct vfs_superblock_t *fat32_read_superblock(struct block_device* blk);
struct vfs_superblock_t *fat32_read_superblock(struct block_device *blk);
/**
* @brief

View File

@ -486,7 +486,8 @@ ul initial_kernel_thread(ul arg)
rootfs_umount();
// 使用单独的内核线程来初始化usb驱动程序
int usb_pid = kernel_thread(usb_init, 0, 0);
// 注释由于目前usb驱动程序不完善因此先将其注释掉
// int usb_pid = kernel_thread(usb_init, 0, 0);
kinfo("LZ4 lib Version=%s", LZ4_versionString());
@ -495,7 +496,7 @@ ul initial_kernel_thread(ul arg)
ktest_start(ktest_test_bitree, 0),
ktest_start(ktest_test_kfifo, 0),
ktest_start(ktest_test_mutex, 0),
usb_pid,
// usb_pid,
};
kinfo("Waiting test thread exit...");
// 等待测试进程退出