[cdi-devel] [PATCH] "Better" indent, wait for ACK instead of sleep
max at tyndur.org ·
From: Max Reitz <max@ŧyndur.org> * indent done with the program "indent" + While a USB device is not ready, it sends NAK in response to IN/OUT - it is a lot better to wait for an ACK instead of sleeping randomly. Signed-off-by: Max Reitz <max at tyndur.org> --- usb/include/msd.h | 50 +++---- usb/include/uhci.h | 80 ++++++------ usb/include/usb.h | 67 ++++------ usb/main.c | 192 ++++++++++++-------------- usb/msd.c | 377 +++++++++++++++++++++++----------------------------- usb/uhci.c | 117 +++++++---------- 6 files changed, 392 insertions(+), 491 deletions(-) diff --git a/usb/include/msd.h b/usb/include/msd.h index 99c796d..cc3bb4d 100644 --- a/usb/include/msd.h +++ b/usb/include/msd.h @@ -32,8 +32,7 @@ //"USBC" #define CBW_SIGNATURE 0x43425355 -struct command_block_wrapper -{ +struct command_block_wrapper { uint32_t cbw_signature; uint32_t cbw_tag; uint32_t cbw_data_transfer_length; @@ -41,55 +40,50 @@ struct command_block_wrapper uint8_t cbw_lun; uint8_t cbw_cb_length; uint8_t cbw_cb[16]; -} __attribute__((packed)); +} __attribute__ ((packed)); //"USBS" #define CSW_SIGNATURE 0x53425355 -struct command_status_wrapper -{ +struct command_status_wrapper { uint32_t csw_signature; uint32_t csw_tag; uint32_t csw_data_residue; uint8_t csw_status; -} __attribute__((packed)); +} __attribute__ ((packed)); -struct msc_sense -{ - unsigned error : 7; - unsigned valid : 1; +struct msc_sense { + unsigned error:7; + unsigned valid:1; uint8_t rsvd0; - unsigned sense_key : 4; - unsigned rsvd1 : 4; + unsigned sense_key:4; + unsigned rsvd1:4; uint32_t information; uint8_t additional_length; uint32_t rsvd2; uint8_t additional_code; uint8_t additional_code_qualifier; uint32_t rsvd; -} __attribute__((packed)); +} __attribute__ ((packed)); -struct msd_capacity -{ +struct msd_capacity { uint32_t last_lba; uint32_t block_length; -} __attribute__((packed)); +} __attribute__ ((packed)); -struct cdi_msd -{ +struct cdi_msd { struct cdi_storage_device cdi_device; struct usb_device *usb_device; - uint32_t offset; //Für Partitionen + uint32_t offset; //Für Partitionen }; -struct part_table_entry -{ - uint8_t active; - uint8_t begin_chs[3]; - uint8_t type; - uint8_t end_chs[3]; - uint32_t start; - uint32_t size; -} __attribute__((packed)); +struct part_table_entry { + uint8_t active; + uint8_t begin_chs[3]; + uint8_t type; + uint8_t end_chs[3]; + uint32_t start; + uint32_t size; +} __attribute__ ((packed)); #define MSC_CMD_REZERO 0x01 diff --git a/usb/include/uhci.h b/usb/include/uhci.h index 0158bd2..bf22c4a 100644 --- a/usb/include/uhci.h +++ b/usb/include/uhci.h @@ -31,15 +31,15 @@ #include "usb.h" -#define UHCI_USBCMD 0x00 //w -#define UHCI_USBSTS 0x02 //w -#define UHCI_USBINTR 0x04 //w -#define UHCI_FRNUM 0x06 //w -#define UHCI_FRBASEADD 0x08 //l -#define UHCI_SOFMOD 0x0C //b +#define UHCI_USBCMD 0x00 //w +#define UHCI_USBSTS 0x02 //w +#define UHCI_USBINTR 0x04 //w +#define UHCI_FRNUM 0x06 //w +#define UHCI_FRBASEADD 0x08 //l +#define UHCI_SOFMOD 0x0C //b #define UHCI_RPORTS 0x10 -#define UHCI_PORTSC1 0x10 //w -#define UHCI_PORTSC2 0x12 //w +#define UHCI_PORTSC1 0x10 //w +#define UHCI_PORTSC2 0x12 //w #define MAXP 0x0080 #define GRESET 0x0004 @@ -47,14 +47,13 @@ #define USB_RUN 0x0001 #define RPORT_RESET 0x0200 -#define RPORT_LOSPD 0x0100 //Low speed device attached +#define RPORT_LOSPD 0x0100 //Low speed device attached #define RPORT_ENABLE 0x0004 -#define RPORT_CSC 0x0002 //Connect status change +#define RPORT_CSC 0x0002 //Connect status change #define RPORT_DEVICE 0x0001 -struct uhci -{ +struct uhci { struct hci gen_hci; uint16_t pbase; uintptr_t phys_frame_list; @@ -62,46 +61,43 @@ struct uhci int root_ports; }; -struct uhci_qh -{ +struct uhci_qh { volatile uint32_t next; volatile uint32_t transfer; -} __attribute__((packed)); +} __attribute__ ((packed)); -struct uhci_td -{ +struct uhci_td { volatile uint32_t next; - unsigned trans_len : 11; - unsigned rsvd0 : 6; - unsigned bitstuff_err : 1; - unsigned crc_time_err : 1; - unsigned nak : 1; - unsigned babble : 1; - unsigned buf_err : 1; - unsigned stalled_err : 1; - unsigned active : 1; - unsigned ioc : 1; - unsigned isochronous : 1; - unsigned low_speed : 1; - unsigned errors : 2; - unsigned spd : 1; - unsigned rsvd1 : 2; - - unsigned pid : 8; - unsigned device : 7; - unsigned endpoint : 4; - unsigned data_toggle : 1; - unsigned rsvd2 : 1; - unsigned maxlen : 11; + unsigned trans_len:11; + unsigned rsvd0:6; + unsigned bitstuff_err:1; + unsigned crc_time_err:1; + unsigned nak:1; + unsigned babble:1; + unsigned buf_err:1; + unsigned stalled_err:1; + unsigned active:1; + unsigned ioc:1; + unsigned isochronous:1; + unsigned low_speed:1; + unsigned errors:2; + unsigned spd:1; + unsigned rsvd1:2; + + unsigned pid:8; + unsigned device:7; + unsigned endpoint:4; + unsigned data_toggle:1; + unsigned rsvd2:1; + unsigned maxlen:11; uint32_t buffer; uint32_t user[4]; -} __attribute__((packed)); +} __attribute__ ((packed)); -struct transfer -{ +struct transfer { void *virt; uintptr_t phys; volatile int error; diff --git a/usb/include/usb.h b/usb/include/usb.h index cca698a..9ec8b37 100644 --- a/usb/include/usb.h +++ b/usb/include/usb.h @@ -30,8 +30,8 @@ enum usb_packet_type { PACKET_SETUP = 0x2D, - PACKET_IN = 0x69, - PACKET_OUT = 0xE1, + PACKET_IN = 0x69, + PACKET_OUT = 0xE1 }; #define NO_DATA 0x01 @@ -124,42 +124,39 @@ enum usb_packet_type { #define USB_TODS_STATUS 8 -typedef enum -{ +typedef enum { HCI_UHCI, HCI_OHCI, HCI_EHCI } hci_type_t; -struct cdi_hci -{ +struct cdi_hci { struct cdi_device cdi_device; struct hci *hci; }; struct usb_device; -struct hci -{ +struct hci { struct cdi_pci_device *pcidev; hci_type_t type; - cdi_list_t (*find_devices)(struct hci *); - void (*activate_device)(struct hci *, struct usb_device *); - int (*do_packet)(struct hci *, int frame, int type, int device, int endpoint, int low_speed, uintptr_t phys_data, int length, int datatoggle); - int (*get_frame)(struct hci *); + cdi_list_t (*find_devices) (struct hci *); + void (*activate_device) (struct hci *, struct usb_device *); + int (*do_packet) (struct hci *, int frame, int type, int device, + int endpoint, int low_speed, uintptr_t phys_data, + int length, int datatoggle); + int (*get_frame) (struct hci *); }; -struct setup_packet -{ +struct setup_packet { uint8_t request_type; uint8_t request; uint16_t value; uint16_t index; uint16_t length; -} __attribute__((packed)); +} __attribute__ ((packed)); -struct device_desc -{ +struct device_desc { uint8_t length; uint8_t descriptor_type; uint16_t bcdUSB; @@ -174,10 +171,9 @@ struct device_desc uint8_t iProduct; uint8_t iSerialNumber; uint8_t num_configurations; -} __attribute__((packed)); +} __attribute__ ((packed)); -struct config_desc -{ +struct config_desc { uint8_t length; uint8_t descriptor_type; uint16_t total_length; @@ -186,10 +182,9 @@ struct config_desc uint8_t iConfiguration; uint8_t attributes; uint8_t max_power; -} __attribute__((packed)); +} __attribute__ ((packed)); -struct interface_desc -{ +struct interface_desc { uint8_t length; uint8_t descriptor_type; uint8_t interface_number; @@ -199,30 +194,27 @@ struct interface_desc uint8_t interface_subclass; uint8_t interface_protocol; uint8_t iInterface; -} __attribute__((packed)); +} __attribute__ ((packed)); -struct endpoint_desc -{ +struct endpoint_desc { uint8_t length; uint8_t descriptor_type; uint8_t endpoint_address; uint8_t attributes; uint16_t max_packet_size; uint8_t interval; -} __attribute__((packed)); +} __attribute__ ((packed)); -struct hub_desc -{ +struct hub_desc { uint8_t length; uint8_t descriptor_type; uint8_t nbr_ports; uint16_t hub_characteristics; uint8_t pwron2pwrgood; uint8_t hub_contr_current; -} __attribute__((packed)); +} __attribute__ ((packed)); -typedef enum -{ +typedef enum { USBDC_COMPOSITE = 0x00, USBDC_AUDIO = 0x01, USBDC_COMM_CDC = 0x02, @@ -244,13 +236,11 @@ typedef enum USBDC_VENDOR_SPEC = 0xFF } usb_class_t; -struct class_data -{ +struct class_data { usb_class_t type; }; -struct usb_device -{ +struct usb_device { struct hci *hci; int id; int port; @@ -264,8 +254,7 @@ struct usb_device int expects; }; -struct msclass_data -{ +struct msclass_data { struct class_data gen_class; struct endpoint_desc *bulk_ep_in; struct endpoint_desc *bulk_ep_out; @@ -294,7 +283,7 @@ struct usb_packet { #define HCI_STRUCT_SIZE sizeof(struct uhci) -int usb_do_packet(struct usb_device *device, struct usb_packet* packet); +int usb_do_packet(struct usb_device *device, struct usb_packet *packet); void enumerate_hci(struct hci *); struct cdi_driver *init_uhcd(void); void init_msc_driver(void); diff --git a/usb/main.c b/usb/main.c index 9200613..51ef95b 100644 --- a/usb/main.c +++ b/usb/main.c @@ -41,12 +41,13 @@ static int dprintf(const char *fmt, ...) { return 0; } + #define _dprintf(fmt, args...) dprintf(fmt, ##args) #endif static struct usb_device *devices[128]; static cdi_list_t ehci, ohci, uhci; -static void (*ccdriver_take_device[0x100])(struct usb_device *); +static void (*ccdriver_take_device[0x100]) (struct usb_device *); static int usb_dev_ids = 1; static void usb_init(void); @@ -94,18 +95,18 @@ static const int next_data_type[9] = { };*/ /** -* Verarbeitet ein USB-Paket. -* -* @param device Das USB-Gerät -*/ + * Verarbeitet ein USB-Paket. + * + * @param device Das USB-Gerät + */ -int usb_do_packet(struct usb_device *device, struct usb_packet* packet) +int usb_do_packet(struct usb_device *device, struct usb_packet *packet) { - int error; + int error = USB_NAK; int tod_short; if (!(device->expects & packet->type_of_data)) { - dprintf("Expected 0x%04X, got 0x%04X...?\n", device->expects, + dprintf("0x%04X erwartet, 0x%04X bekommen...?\n", device->expects, packet->type_of_data); // FIXME Das ist keine elegante Loesung des Problems for (;;); @@ -118,18 +119,18 @@ int usb_do_packet(struct usb_device *device, struct usb_packet* packet) device->expects = next_data_type[tod_short]; packet->endpoint &= 0x07; packet->type &= 0xFF; - if (device->stalled) //TODO: Irgendwie entstallen, evtl.? oO - { + if (device->stalled) { + //TODO: Irgendwie entstallen, evtl.? oO dprintf("Zugriff auf stalled-Gerät verweigert.\n"); return USB_STALLED; } - error = device->hci->do_packet(device->hci, - (device->hci->get_frame(device->hci) + 3) & 0x3FF, - packet->type, device->id, packet->endpoint, - device->low_speed, packet->phys_data, packet->length, - packet->datatoggle); - if (error == USB_STALLED) - { + while (error == USB_NAK) { + error = device->hci->do_packet(device->hci, + (device->hci->get_frame(device->hci) + 3) & 0x3FF, + packet->type, device->id, packet->endpoint, device->low_speed, + packet->phys_data, packet->length, packet->datatoggle); + } + if (error == USB_STALLED) { printf("[usb] ENDPOINT %i DES GERÄTS %i STALLED!\n", packet->endpoint, device->id); device->stalled = 1; @@ -137,7 +138,8 @@ int usb_do_packet(struct usb_device *device, struct usb_packet* packet) return error; } -static void *do_control(struct usb_device *device, int direction, void *buffer, int length, int rtype, int recipient, int request, int value, int index) +static void *do_control(struct usb_device *device, int direction, void *buffer, + int length, int rtype, int recipient, int request, int value, int index) { void *rbuf; int rval, no_data; @@ -149,7 +151,7 @@ static void *do_control(struct usb_device *device, int direction, void *buffer, return NULL; } if (cdi_alloc_phys_mem(sizeof(struct setup_packet), - (void **)&setup, (void **)&psetup) == -1) { + (void **)&setup, (void **)&psetup) == -1) { return NULL; } direction &= 0x80; @@ -163,12 +165,12 @@ static void *do_control(struct usb_device *device, int direction, void *buffer, setup->length = length; struct usb_packet setup_packet = { - .type = PACKET_SETUP, - .endpoint = 0, - .phys_data = psetup, - .length = sizeof(*setup), - .datatoggle = 0, - .type_of_data = USB_TOD_SETUP, + .type = PACKET_SETUP, + .endpoint = 0, + .phys_data = psetup, + .length = sizeof(*setup), + .datatoggle = 0, + .type_of_data = USB_TOD_SETUP, }; @@ -177,43 +179,38 @@ static void *do_control(struct usb_device *device, int direction, void *buffer, } cdi_sleep_ms(20); - if (no_data) - { + if (no_data) { rval = USB_NO_ERROR; - rbuf = (void *)0xFFFFFFFF; //Kein Fehler, aber auch keine Daten - } - else - { + rbuf = (void *)0xFFFFFFFF; //Kein Fehler, aber auch keine Daten + } else { struct usb_packet data_packet = { - .type = (direction == DEV_TO_HOST ? - PACKET_IN : PACKET_OUT), - .endpoint = 0, - .phys_data = pbuf, - .length = length, - .datatoggle = 1, - .type_of_data = (direction == DEV_TO_HOST ? - USB_TOD_SETUP_DATA_IN : USB_TOD_SETUP_DATA_OUT), + .type = (direction == DEV_TO_HOST ? PACKET_IN : PACKET_OUT), + .endpoint = 0, + .phys_data = pbuf, + .length = length, + .datatoggle = 1, + .type_of_data = (direction == DEV_TO_HOST ? + USB_TOD_SETUP_DATA_IN : USB_TOD_SETUP_DATA_OUT), }; rval = usb_do_packet(device, &data_packet); } - if (rval == USB_NO_ERROR) - { + if (rval == USB_NO_ERROR) { struct usb_packet ack_packet = { - .endpoint = 0, - .phys_data = 0, - .length = 0, - .datatoggle = 1, + .endpoint = 0, + .phys_data = 0, + .length = 0, + .datatoggle = 1, }; cdi_sleep_ms(20); if (no_data || (direction == HOST_TO_DEV)) { - ack_packet.type = PACKET_IN; + ack_packet.type = PACKET_IN; ack_packet.type_of_data = USB_TOD_SETUP_ACK_IN; } else { - ack_packet.type = PACKET_OUT; + ack_packet.type = PACKET_OUT; ack_packet.type_of_data = USB_TOD_SETUP_ACK_OUT; } @@ -233,7 +230,8 @@ static void usb_init(void) init_msc_driver(); - memset(ccdriver_take_device, 0, sizeof(void (*)(struct usb_device *)) * 0x100); + memset(ccdriver_take_device, 0, + sizeof(void (*)(struct usb_device *)) * 0x100); ccdriver_take_device[8] = ®ister_msd; ccdriver_take_device[9] = &enumerate_hub; @@ -243,13 +241,11 @@ static void usb_init(void) cdi_list_t pci_devices = cdi_list_create(); cdi_pci_get_all_devices(pci_devices); - for (i = 0; (dev = cdi_list_get(pci_devices, i)) != NULL; i++) - { + for (i = 0; (dev = cdi_list_get(pci_devices, i)) != NULL; i++) { if ((dev->class_id != 0x0C) || (dev->subclass_id != 0x03)) { cdi_pci_device_destroy(dev); } else { - switch (dev->interface_id) - { + switch (dev->interface_id) { case 0x00: hci = malloc(HCI_STRUCT_SIZE); hci->pcidev = dev; @@ -273,14 +269,12 @@ static void usb_init(void) cdi_list_destroy(pci_devices); - dprintf("%i EHCIs, %i OHCIs und %i UHCIs gefunden.\n", cdi_list_size(ehci), - cdi_list_size(ohci), - cdi_list_size(uhci)); + dprintf("%i EHCIs, %i OHCIs und %i UHCIs gefunden.\n", + cdi_list_size(ehci), cdi_list_size(ohci), cdi_list_size(uhci)); uhcd = init_uhcd(); - for (i = 0; (hci = cdi_list_pop(uhci)) != NULL; i++) - { + for (i = 0; (hci = cdi_list_pop(uhci)) != NULL; i++) { cdi_hci = malloc(sizeof(struct cdi_hci)); cdi_hci->cdi_device.type = CDI_UNKNOWN; dev_name = malloc(10); @@ -313,23 +307,21 @@ static void enum_device(struct usb_device *usbdev) usbdev->locked = 0; usbdev->expects = USB_TOD_SETUP | USB_TOD_COMMAND; dev_desc = do_control(usbdev, DEV_TO_HOST, NULL, sizeof(*dev_desc), - STD_REQUEST, REC_DEVICE, GET_DESCRIPTOR, - DESC_DEVICE << 8, 0); + STD_REQUEST, REC_DEVICE, GET_DESCRIPTOR, DESC_DEVICE << 8, 0); if (dev_desc == NULL) { return; } usbdev->device = dev_desc; dprintf("0x%04X:0x%04X (%i) -> ", dev_desc->vendor_id, dev_desc->device_id, - dev_desc->class_id); + dev_desc->class_id); do_control(usbdev, HOST_TO_DEV | NO_DATA, NULL, 0, STD_REQUEST, REC_DEVICE, - SET_ADDRESS, (id = usb_dev_ids++), 0); + SET_ADDRESS, (id = usb_dev_ids++), 0); usbdev->id = id; _dprintf("%i\n", id); - if (dev_desc->iManufacturer) - { + if (dev_desc->iManufacturer) { name = do_control(usbdev, DEV_TO_HOST, NULL, 64, STD_REQUEST, - REC_DEVICE, GET_DESCRIPTOR, - (DESC_STRING << 8) | dev_desc->iManufacturer, 0); + REC_DEVICE, GET_DESCRIPTOR, + (DESC_STRING << 8) | dev_desc->iManufacturer, 0); if (name == NULL) { return; } @@ -339,11 +331,10 @@ static void enum_device(struct usb_device *usbdev) } _dprintf("\n"); } - if (dev_desc->iProduct) - { + if (dev_desc->iProduct) { name = do_control(usbdev, DEV_TO_HOST, NULL, 64, STD_REQUEST, - REC_DEVICE, GET_DESCRIPTOR, - (DESC_STRING << 8) | dev_desc->iProduct, 0); + REC_DEVICE, GET_DESCRIPTOR, + (DESC_STRING << 8) | dev_desc->iProduct, 0); if (name == NULL) { return; } @@ -354,27 +345,25 @@ static void enum_device(struct usb_device *usbdev) _dprintf("\n"); } devices[id] = usbdev; - //TODO: Man kann doch nicht immer den ersten nehmen... + //TODO: Man kann doch nicht immer den ersten nehmen... conf_desc = do_control(usbdev, DEV_TO_HOST, NULL, - sizeof(struct config_desc), STD_REQUEST, REC_DEVICE, - GET_DESCRIPTOR, DESC_CONFIGURATION << 8, 0); + sizeof(struct config_desc), STD_REQUEST, + REC_DEVICE, GET_DESCRIPTOR, DESC_CONFIGURATION << 8, 0); if (conf_desc == NULL) { return; } conf_desc = do_control(usbdev, DEV_TO_HOST, NULL, conf_desc->total_length, - STD_REQUEST, REC_DEVICE, GET_DESCRIPTOR, - DESC_CONFIGURATION << 8, 0); + STD_REQUEST, REC_DEVICE, GET_DESCRIPTOR, DESC_CONFIGURATION << 8, 0); if (conf_desc == NULL) { return; } usbdev->config = conf_desc; do_control(usbdev, HOST_TO_DEV, NULL, 0, STD_REQUEST, REC_DEVICE, - SET_CONFIGURATION, conf_desc->config_value, 0); - if (conf_desc->iConfiguration) - { + SET_CONFIGURATION, conf_desc->config_value, 0); + if (conf_desc->iConfiguration) { name = do_control(usbdev, DEV_TO_HOST, NULL, 64, STD_REQUEST, - REC_DEVICE, GET_DESCRIPTOR, - (DESC_STRING << 8) | conf_desc->iConfiguration, 0); + REC_DEVICE, GET_DESCRIPTOR, + (DESC_STRING << 8) | conf_desc->iConfiguration, 0); if (name == NULL) { return; } @@ -386,25 +375,25 @@ static void enum_device(struct usb_device *usbdev) } position = conf_desc; position += sizeof(struct config_desc); - best_if = position; //Standard-IF - for (i = 0; i < conf_desc->num_interfaces; i++) - { + best_if = position; //Standard-IF + for (i = 0; i < conf_desc->num_interfaces; i++) { if_desc = position; - if (if_desc->interface_class == 8) //TODO: Mehr Klassencodes natürlich! - { + //TODO: Mehr Klassencodes natürlich! + if (if_desc->interface_class == 8) { best_if = if_desc; break; } - position += sizeof(struct interface_desc) + if_desc->num_endpoints * sizeof(struct endpoint_desc); + position += + sizeof(struct interface_desc) + + if_desc->num_endpoints * sizeof(struct endpoint_desc); } do_control(usbdev, HOST_TO_DEV, NULL, 0, STD_REQUEST, REC_DEVICE, - SET_INTERFACE, best_if->interface_number, 0); + SET_INTERFACE, best_if->interface_number, 0); usbdev->interface = best_if; - if (best_if->iInterface) - { + if (best_if->iInterface) { name = do_control(usbdev, DEV_TO_HOST, NULL, 64, STD_REQUEST, - REC_DEVICE, GET_DESCRIPTOR, - (DESC_STRING << 8) | best_if->iInterface, 0); + REC_DEVICE, GET_DESCRIPTOR, + (DESC_STRING << 8) | best_if->iInterface, 0); if (name == NULL) { return; } @@ -415,10 +404,9 @@ static void enum_device(struct usb_device *usbdev) _dprintf(".\n"); } dprintf("Konfiguration: %i:%i (%i)\n", conf_desc->config_value, - best_if->interface_number, - best_if->interface_class); + best_if->interface_number, best_if->interface_class); if (ccdriver_take_device[best_if->interface_class] != NULL) { - ccdriver_take_device[best_if->interface_class](usbdev); + ccdriver_take_device[best_if->interface_class] (usbdev); } } @@ -432,22 +420,20 @@ static void enumerate_hub(struct usb_device *usbdev) //Mehr als 8 Ports sollte es nicht geben, die Größe des Deskriptors wird //daher wohl nicht größer als sizeof()+16 werden hub_desc = do_control(usbdev, DEV_TO_HOST, NULL, sizeof(*hub_desc) + 16, - CLS_REQUEST, REC_DEVICE, GET_DESCRIPTOR, - DESC_DEVICE << 8, 0); - for (i = 0; i < hub_desc->nbr_ports; i++) - { + CLS_REQUEST, REC_DEVICE, GET_DESCRIPTOR, DESC_DEVICE << 8, 0); + for (i = 0; i < hub_desc->nbr_ports; i++) { port_status = do_control(usbdev, DEV_TO_HOST, NULL, 4, CLS_REQUEST, - REC_OTHER, GET_STATUS, 0, i+1); + REC_OTHER, GET_STATUS, 0, i + 1); if (!(port_status[0] & PORT_DEVICE)) { continue; } //Strom an do_control(usbdev, HOST_TO_DEV, NULL, 0, CLS_REQUEST, REC_OTHER, - SET_FEATURE, PORTF_POWER, i+1); + SET_FEATURE, PORTF_POWER, i + 1); cdi_sleep_ms(hub_desc->pwron2pwrgood * 2); //Resetten do_control(usbdev, HOST_TO_DEV, NULL, 0, CLS_REQUEST, REC_OTHER, - SET_FEATURE, PORTF_RESET, i+1); + SET_FEATURE, PORTF_RESET, i + 1); //Reset sollte jetzt eigtl. schon beendet sein //(do_control wartet ja 50 ms) down = malloc(sizeof(struct usb_device)); @@ -464,11 +450,9 @@ void enumerate_hci(struct hci *hci) struct usb_device *usbdev; cdi_list_t usb_devices; - if (hci->find_devices != NULL) - { + if (hci->find_devices != NULL) { usb_devices = hci->find_devices(hci); - while ((usbdev = cdi_list_pop(usb_devices)) != NULL) - { + while ((usbdev = cdi_list_pop(usb_devices)) != NULL) { hci->activate_device(hci, usbdev); cdi_sleep_ms(50); enum_device(usbdev); diff --git a/usb/msd.c b/usb/msd.c index 0f9b79e..9614473 100644 --- a/usb/msd.c +++ b/usb/msd.c @@ -48,6 +48,7 @@ static int dprintf(const char *fmt, ...) { return 0; } + #define _dprintf(fmt, args...) dprintf(fmt, ##args) #endif @@ -70,9 +71,12 @@ static void deinit_msd(struct cdi_device *cdi_msd); static void get_partitions(struct cdi_storage_device *cdistrg); static void init_msd(struct cdi_device *cdi_msd); static void kill_driver(struct cdi_driver *cdi_msc_driver); -static int msd_cdi_read(struct cdi_storage_device *strgdev, uint64_t start, uint64_t count, void *buffer); -static int msd_cdi_write(struct cdi_storage_device *strgdev, uint64_t start, uint64_t count, void *buffer); -static int msd_get_capacity(struct usb_device *usbdev, uint32_t *block_size, uint32_t *block_count); +static int msd_cdi_read(struct cdi_storage_device *strgdev, uint64_t start, + uint64_t count, void *buffer); +static int msd_cdi_write(struct cdi_storage_device *strgdev, uint64_t start, + uint64_t count, void *buffer); +static int msd_get_capacity(struct usb_device *usbdev, uint32_t *block_size, + uint32_t *block_count); //TODO: CDI-Funktion wäre hier sicher nützlich... #define CPU_IS_LITTLE_ENDIAN @@ -125,10 +129,9 @@ void register_msd(struct usb_device *usbdev) uint64_t size; static int msdnum = 0; - if (usbdev->interface->interface_protocol != 0x50) - { - dprintf("Es werden nur bulk-only-Interfaces unterstützt.\n"); - return; + if (usbdev->interface->interface_protocol != 0x50) { + dprintf("Es werden nur bulk-only-Interfaces unterstützt.\n"); + return; } cdimsd = malloc(sizeof(struct cdi_msd)); if (cdimsd == NULL) { @@ -139,15 +142,13 @@ void register_msd(struct usb_device *usbdev) strgdev = (struct cdi_storage_device *)cdimsd; strgdev->dev.type = CDI_STORAGE; strgdev->dev.name = malloc(10); - if (strgdev->dev.name == NULL) - { + if (strgdev->dev.name == NULL) { free(strgdev); return; } sprintf((char *)strgdev->dev.name, "msd%i", msdnum++); msc = malloc(sizeof(struct msclass_data)); - if (msc == NULL) - { + if (msc == NULL) { free((void *)strgdev->dev.name); free(strgdev); return; @@ -156,38 +157,30 @@ void register_msd(struct usb_device *usbdev) msc->bulk_ep_in = NULL; msc->bulk_ep_out = NULL; address = (void *)usbdev->interface + sizeof(struct interface_desc); - for (i = 0; i < usbdev->interface->num_endpoints; i++) - { + for (i = 0; i < usbdev->interface->num_endpoints; i++) { ep_desc = address; - if ((ep_desc->endpoint_address & 0x80) && - (ep_desc->attributes == 0x02) && - (msc->bulk_ep_in == NULL)) { //BULK-IN + if ((ep_desc->endpoint_address & 0x80) && (ep_desc->attributes == 0x02) && (msc->bulk_ep_in == NULL)) { //BULK-IN msc->bulk_ep_in = ep_desc; - } else if (!(ep_desc->endpoint_address & 0x80) && - (ep_desc->attributes == 0x02) && - (msc->bulk_ep_out == NULL)) { //BULK-OUT + } else if (!(ep_desc->endpoint_address & 0x80) && (ep_desc->attributes == 0x02) && (msc->bulk_ep_out == NULL)) { //BULK-OUT msc->bulk_ep_out = ep_desc; } address += sizeof(struct endpoint_desc); } - if ((msc->bulk_ep_in == NULL) || (msc->bulk_ep_out == NULL)) - { + if ((msc->bulk_ep_in == NULL) || (msc->bulk_ep_out == NULL)) { dprintf("Nicht genügend Endpoints gefunden.\n"); return; } - if (!msd_get_capacity(usbdev, &bs, &bc)) - { + if (!msd_get_capacity(usbdev, &bs, &bc)) { strgdev->block_size = 0; strgdev->block_count = 0; dprintf("Konnte Größe für %s nicht ermitteln.\n", strgdev->dev.name); - } - else - { + } else { strgdev->block_size = bs; strgdev->block_count = bc; size = bs; size *= bc; - dprintf("%s: %i * %i B (ca. %lld MB).\n", strgdev->dev.name, bc, bs, size >> 20); + dprintf("%s: %i * %i B (ca. %lld MB).\n", strgdev->dev.name, bc, bs, + size >> 20); } cdi_storage_device_init(strgdev); cdi_list_push(cdi_driver.drv.devices, strgdev); @@ -210,58 +203,81 @@ static void deinit_msd(struct cdi_device *cdi_msd) //TODO: Und gerade hier... } -static int write_cmd(struct usb_device* usbdev, uintptr_t src) +static int write_cmd(struct usb_device *usbdev, uintptr_t src) { - struct msclass_data *msc = (struct msclass_data*) usbdev->classd; + struct msclass_data *msc = (struct msclass_data *)usbdev->classd; struct usb_packet cmd_packet = { - .type = PACKET_OUT, - .endpoint = msc->bulk_ep_out->endpoint_address, - .phys_data = src, - .length = 0x1F, - .datatoggle = 0, - .type_of_data = USB_TOD_COMMAND, + .type = PACKET_OUT, + .endpoint = msc->bulk_ep_out->endpoint_address, + .phys_data = src, + .length = 0x1F, + .datatoggle = 0, + .type_of_data = USB_TOD_COMMAND, }; return usb_do_packet(usbdev, &cmd_packet); } -static int read_status(struct usb_device* usbdev, uintptr_t dest) +/** + * Liest den Status von einem MSD + * + * @param usbdev Das bewusste Gerät + * @param expected_tag Das erwartete Tag + * + * @return Wenn der Status OK ist USB_NO_ERROR, sonst entsprechender Fehler + */ + +static int read_status(struct usb_device *usbdev, uint32_t expected_tag) { - struct msclass_data *msc = (struct msclass_data*) usbdev->classd; + uintptr_t pcsw; + struct msclass_data *msc = (struct msclass_data *)usbdev->classd; + struct command_status_wrapper *csw; + int error; + + if (cdi_alloc_phys_mem(sizeof(struct command_status_wrapper), + (void **)&csw, (void **)&pcsw) == -1) { + return USB_TRIVIAL_ERROR; + } + struct usb_packet status_packet = { - .type = PACKET_IN, - .endpoint = msc->bulk_ep_in->endpoint_address, - .phys_data = dest, - .length = 0x0D, - .datatoggle = 0, - .type_of_data = USB_TOD_STATUS, + .type = PACKET_IN, + .endpoint = msc->bulk_ep_in->endpoint_address, + .phys_data = pcsw, + .length = 0x0D, + .datatoggle = 0, + .type_of_data = USB_TOD_STATUS, }; - return usb_do_packet(usbdev, &status_packet); + error = usb_do_packet(usbdev, &status_packet); + if (error != USB_NO_ERROR) { + return error; + } + if ((csw->csw_signature != CSW_SIGNATURE) || + (csw->csw_tag != expected_tag) || csw->csw_status) { + return USB_CRC; //Watt weiß denn ich + } + + return USB_NO_ERROR; } -static int msd_get_capacity(struct usb_device *usbdev, uint32_t *block_size, uint32_t *block_count) +static int msd_get_capacity(struct usb_device *usbdev, uint32_t *block_size, + uint32_t *block_count) { struct msclass_data *msc; struct command_block_wrapper *cbw; - struct command_status_wrapper *csw; struct msd_capacity *cap; - uintptr_t pcbw, pcsw, pcap; + uintptr_t pcbw, pcap; uint32_t expected_tag; if ((usbdev == NULL) || (block_size == NULL) || (block_count == NULL)) { return 0; } if (cdi_alloc_phys_mem(sizeof(struct command_block_wrapper), - (void **)&cbw, (void **)&pcbw) == -1) { - return 0; - } - if (cdi_alloc_phys_mem(sizeof(struct command_status_wrapper), - (void **)&csw, (void **)&pcsw) == -1) { + (void **)&cbw, (void **)&pcbw) == -1) { return 0; } if (cdi_alloc_phys_mem(sizeof(struct msd_capacity), - (void **)&cap, (void **)&pcap) == -1) { + (void **)&cap, (void **)&pcap) == -1) { return 0; } msc = (struct msclass_data *)usbdev->classd; @@ -269,42 +285,30 @@ static int msd_get_capacity(struct usb_device *usbdev, uint32_t *block_size, uin cbw->cbw_signature = CBW_SIGNATURE; cbw->cbw_tag = (expected_tag = cbw_tag++); cbw->cbw_data_transfer_length = sizeof(struct msd_capacity); - cbw->cbw_flags = 0x80; //IN - cbw->cbw_lun = 0; //Was weiß ich, wie viele LUNs datt Dingens hat? + cbw->cbw_flags = 0x80; //IN + cbw->cbw_lun = 0; //Was weiß ich, wie viele LUNs datt Dingens hat? cbw->cbw_cb_length = 12; cbw->cbw_cb[0] = MSC_CMD_CAPACITY; - cbw->cbw_cb[1] = 0; //LUN: 0 + cbw->cbw_cb[1] = 0; //LUN: 0 if (write_cmd(usbdev, pcbw) != USB_NO_ERROR) { return 0; } - cdi_sleep_ms(20); - struct usb_packet in_packet = { - .type = PACKET_IN, - .endpoint = msc->bulk_ep_in->endpoint_address, - .phys_data = pcap, - .length = sizeof(*cap), - .datatoggle = 0, - .type_of_data = USB_TOD_DATA_IN, + .type = PACKET_IN, + .endpoint = msc->bulk_ep_in->endpoint_address, + .phys_data = pcap, + .length = sizeof(*cap), + .datatoggle = 0, + .type_of_data = USB_TOD_DATA_IN, }; if (usb_do_packet(usbdev, &in_packet) != USB_NO_ERROR) { return 0; } - cdi_sleep_ms(5); - - if (read_status(usbdev, pcsw) != USB_NO_ERROR) { - return 0; - } - - cdi_sleep_ms(5); - - if ((csw->csw_signature != CSW_SIGNATURE) || - (csw->csw_tag != expected_tag) || - csw->csw_status) { + if (read_status(usbdev, expected_tag) != USB_NO_ERROR) { return 0; } @@ -317,46 +321,33 @@ static int msd_get_capacity(struct usb_device *usbdev, uint32_t *block_size, uin #ifdef WAIT_FOR_MSD_READY static int msd_ready(struct usb_device *usbdev) { - struct msclass_data *msc; - struct command_block_wrapper *cbw; - struct command_status_wrapper *csw; - uintptr_t pcbw, pcsw; - uint32_t expected_tag; - - if (cdi_alloc_phys_mem(sizeof(struct command_block_wrapper), - (void **)&cbw, (void **)&pcbw) == -1) { - return 0; - } - if (cdi_alloc_phys_mem(sizeof(struct command_status_wrapper), - (void **)&csw, (void **)&pcsw) == -1) { - return 0; - } - msc = (struct msclass_data *)usbdev->classd; - memset(cbw, 0, 0x1F); - cbw->cbw_signature = CBW_SIGNATURE; - cbw->cbw_tag = (expected_tag = cbw_tag++); - cbw->cbw_data_transfer_length = 0; - cbw->cbw_flags = 0x80; //IN - cbw->cbw_lun = 0; //Was weiß ich, wie viele LUNs datt Dingens hat? - cbw->cbw_cb_length = 12; //Alles null, also "Test unit ready" - - if (write_cmd(usbdev, pcbw) != USB_NO_ERROR) { - return 0; - } - - cdi_sleep_ms(7); - if (read_status(usbdev, pcsw) != USB_NO_ERROR) { - return 0; - } - - cdi_sleep_ms(4); - if ((csw->csw_signature != CSW_SIGNATURE) || - (csw->csw_tag != expected_tag) || - csw->csw_status) { - return 0; - } - - return 1; + struct msclass_data *msc; + struct command_block_wrapper *cbw; + uintptr_t pcbw; + uint32_t expected_tag; + + if (cdi_alloc_phys_mem(sizeof(struct command_block_wrapper), + (void **)&cbw, (void **)&pcbw) == -1) { + return 0; + } + msc = (struct msclass_data *)usbdev->classd; + memset(cbw, 0, 0x1F); + cbw->cbw_signature = CBW_SIGNATURE; + cbw->cbw_tag = (expected_tag = cbw_tag++); + cbw->cbw_data_transfer_length = 0; + cbw->cbw_flags = 0x80; //IN + cbw->cbw_lun = 0; //Was weiß ich, wie viele LUNs datt Dingens hat? + cbw->cbw_cb_length = 12; //Alles null, also "Test unit ready" + + if (write_cmd(usbdev, pcbw) != USB_NO_ERROR) { + return 0; + } + + if (read_status(usbdev, expected_tag) != USB_NO_ERROR) { + return 0; + } + + return 1; } #endif @@ -368,9 +359,11 @@ static inline int tsl(volatile int *variable) return rval; } -static uint32_t msd_read(struct usb_device *usbdev, uint32_t lba, uint16_t sectors, uintptr_t phys_buffer, size_t length); +static uint32_t msd_read(struct usb_device *usbdev, uint32_t lba, + uint16_t sectors, uintptr_t phys_buffer, size_t length); -static int msd_cdi_read(struct cdi_storage_device *strgdev, uint64_t start, uint64_t count, void *buffer) +static int msd_cdi_read(struct cdi_storage_device *strgdev, uint64_t start, + uint64_t count, void *buffer) { void *vb; uintptr_t pb; @@ -383,57 +376,48 @@ static int msd_cdi_read(struct cdi_storage_device *strgdev, uint64_t start, uint fdprintf("read(%i, %i)\n", (int)start, (int)count); start += ((struct cdi_msd *)strgdev)->offset; - if (cdi_alloc_phys_mem(bs, &vb, (void **)&pb) == -1) - { + if (cdi_alloc_phys_mem(bs, &vb, (void **)&pb) == -1) { dprintf("Blockspeicher konnte nicht allociert werden.\n"); return -1; } - if (!count) - { + if (!count) { dprintf("Leere Leseanfrage.\n"); return 0; } - while (tsl(&usbdev->locked)) - { + while (tsl(&usbdev->locked)) { #ifndef CDI_STANDALONE - __asm__ __volatile__ ("hlt"); + __asm__ __volatile__("hlt"); #endif } - for (i = 0; i < count; i++) - { + for (i = 0; i < count; i++) { #ifdef WAIT_FOR_MSD_READY for (j = 0; !msd_ready(usbdev) && (j < 10); j++) { cdi_sleep_ms(20); } #endif error = msd_read(usbdev, start + i, 1, pb, bs); - if (error != USB_NO_ERROR) - { + if (error != USB_NO_ERROR) { dprintf("Lesefehler 0x%X bei Block %i.\n", error, i); usbdev->locked = 0; return -1; } - memcpy(buffer + i*bs, vb, bs); + memcpy(buffer + i * bs, vb, bs); } usbdev->locked = 0; return 0; } -static uint32_t msd_read(struct usb_device *usbdev, uint32_t lba, uint16_t sectors, uintptr_t phys_buffer, size_t length) +static uint32_t msd_read(struct usb_device *usbdev, uint32_t lba, + uint16_t sectors, uintptr_t phys_buffer, size_t length) { struct msclass_data *msc; struct command_block_wrapper *cbw; - struct command_status_wrapper *csw; - uintptr_t pcbw, pcsw; + uintptr_t pcbw; uint32_t expected_tag; int error; if (cdi_alloc_phys_mem(sizeof(struct command_block_wrapper), - (void **)&cbw, (void **)&pcbw) == -1) { - return USB_TRIVIAL_ERROR; - } - if (cdi_alloc_phys_mem(sizeof(struct command_status_wrapper), - (void **)&csw, (void **)&pcsw) == -1) { + (void **)&cbw, (void **)&pcbw) == -1) { return USB_TRIVIAL_ERROR; } if (!phys_buffer || !length) { @@ -444,61 +428,50 @@ static uint32_t msd_read(struct usb_device *usbdev, uint32_t lba, uint16_t secto cbw->cbw_signature = CBW_SIGNATURE; cbw->cbw_tag = (expected_tag = cbw_tag++); cbw->cbw_data_transfer_length = length; - cbw->cbw_flags = 0x80; //IN - cbw->cbw_lun = 0; //Was weiß ich, wie viele LUNs datt Dingens hat? + cbw->cbw_flags = 0x80; //IN + cbw->cbw_lun = 0; //Was weiß ich, wie viele LUNs datt Dingens hat? cbw->cbw_cb_length = 12; cbw->cbw_cb[0] = MSC_CMD_READ10; - cbw->cbw_cb[1] = 0; //LUN: 0 + cbw->cbw_cb[1] = 0; //LUN: 0 cbw->cbw_cb[2] = (lba & 0xFF000000) >> 24; cbw->cbw_cb[3] = (lba & 0x00FF0000) >> 16; cbw->cbw_cb[4] = (lba & 0x0000FF00) >> 8; - cbw->cbw_cb[5] = lba & 0x000000FF; + cbw->cbw_cb[5] = lba & 0x000000FF; cbw->cbw_cb[7] = (sectors & 0x0000FF00) >> 8; - cbw->cbw_cb[8] = sectors & 0x000000FF; + cbw->cbw_cb[8] = sectors & 0x000000FF; error = write_cmd(usbdev, pcbw); if (error != USB_NO_ERROR) { return error; } - cdi_sleep_ms(20); struct usb_packet in_packet = { - .type = PACKET_IN, - .endpoint = msc->bulk_ep_in->endpoint_address, - .phys_data = phys_buffer, - .length = length, - .datatoggle = 0, - .type_of_data = USB_TOD_DATA_IN, + .type = PACKET_IN, + .endpoint = msc->bulk_ep_in->endpoint_address, + .phys_data = phys_buffer, + .length = length, + .datatoggle = 0, + .type_of_data = USB_TOD_DATA_IN, }; error = usb_do_packet(usbdev, &in_packet); if (error != USB_NO_ERROR) { return error; } - cdi_sleep_ms(5); - error = read_status(usbdev, pcsw); + error = read_status(usbdev, expected_tag); if (error != USB_NO_ERROR) { return error; } - cdi_sleep_ms(4); - if ((csw->csw_signature != CSW_SIGNATURE) || - (csw->csw_tag != expected_tag) || - csw->csw_status) - { - dprintf("0x%08X 0x%08X==0x%08X 0x%02X\n", csw->csw_signature, - csw->csw_tag, - expected_tag, - csw->csw_status); - return USB_CRC; //Watt weiß denn ich... - } return USB_NO_ERROR; } -static uint32_t msd_write(struct usb_device *usbdev, uint32_t lba, uint16_t sectors, uintptr_t phys_buffer, size_t length); +static uint32_t msd_write(struct usb_device *usbdev, uint32_t lba, + uint16_t sectors, uintptr_t phys_buffer, size_t length); -static int msd_cdi_write(struct cdi_storage_device *strgdev, uint64_t start, uint64_t count, void *buffer) +static int msd_cdi_write(struct cdi_storage_device *strgdev, uint64_t start, + uint64_t count, void *buffer) { void *vb; uintptr_t pb; @@ -511,28 +484,24 @@ static int msd_cdi_write(struct cdi_storage_device *strgdev, uint64_t start, uin fdprintf("write(%i, %i)\n", (int)start, (int)count); start += ((struct cdi_msd *)strgdev)->offset; - if (cdi_alloc_phys_mem(bs, &vb, (void **)&pb) == -1) - { + if (cdi_alloc_phys_mem(bs, &vb, (void **)&pb) == -1) { dprintf("Blockspeicher zum Schreiben konnte nicht allociert werden.\n"); return -1; } - while (tsl(&usbdev->locked)) - { + while (tsl(&usbdev->locked)) { #ifndef CDI_STANDALONE - __asm__ __volatile__ ("hlt"); + __asm__ __volatile__("hlt"); #endif } - for (i = 0; i < count; i++) - { - memcpy(vb, buffer + i*bs, bs); + for (i = 0; i < count; i++) { + memcpy(vb, buffer + i * bs, bs); #ifdef WAIT_FOR_MSD_READY for (j = 0; !msd_ready(usbdev) && (j < 10); j++) { cdi_sleep_ms(20); } #endif error = msd_write(usbdev, start + i, 1, pb, bs); - if (error != USB_NO_ERROR) - { + if (error != USB_NO_ERROR) { dprintf("Schreibfehler 0x%X bei Block %i.\n", error, i); usbdev->locked = 0; return -1; @@ -542,7 +511,8 @@ static int msd_cdi_write(struct cdi_storage_device *strgdev, uint64_t start, uin return 0; } -static uint32_t msd_write(struct usb_device *usbdev, uint32_t lba, uint16_t sectors, uintptr_t phys_buffer, size_t length) +static uint32_t msd_write(struct usb_device *usbdev, uint32_t lba, + uint16_t sectors, uintptr_t phys_buffer, size_t length) { struct msclass_data *msc; struct command_block_wrapper *cbw; @@ -552,11 +522,11 @@ static uint32_t msd_write(struct usb_device *usbdev, uint32_t lba, uint16_t sect int error; if (cdi_alloc_phys_mem(sizeof(struct command_block_wrapper), - (void **)&cbw, (void **)&pcbw) == -1) { + (void **)&cbw, (void **)&pcbw) == -1) { return USB_TRIVIAL_ERROR; } if (cdi_alloc_phys_mem(sizeof(struct command_status_wrapper), - (void **)&csw, (void **)&pcsw) == -1) { + (void **)&csw, (void **)&pcsw) == -1) { return USB_TRIVIAL_ERROR; } if (!phys_buffer || !length) { @@ -567,31 +537,30 @@ static uint32_t msd_write(struct usb_device *usbdev, uint32_t lba, uint16_t sect cbw->cbw_signature = CBW_SIGNATURE; cbw->cbw_tag = (expected_tag = cbw_tag++); cbw->cbw_data_transfer_length = length; - cbw->cbw_flags = 0x00; //OUT - cbw->cbw_lun = 0; //Was weiß ich, wie viele LUNs datt Dingens hat? + cbw->cbw_flags = 0x00; //OUT + cbw->cbw_lun = 0; //Was weiß ich, wie viele LUNs datt Dingens hat? cbw->cbw_cb_length = 12; cbw->cbw_cb[0] = MSC_CMD_WRITE10; - cbw->cbw_cb[1] = 0; //LUN: 0 + cbw->cbw_cb[1] = 0; //LUN: 0 cbw->cbw_cb[2] = (lba & 0xFF000000) >> 24; cbw->cbw_cb[3] = (lba & 0x00FF0000) >> 16; cbw->cbw_cb[4] = (lba & 0x0000FF00) >> 8; - cbw->cbw_cb[5] = lba & 0x000000FF; + cbw->cbw_cb[5] = lba & 0x000000FF; cbw->cbw_cb[7] = (sectors & 0x0000FF00) >> 8; - cbw->cbw_cb[8] = sectors & 0x000000FF; + cbw->cbw_cb[8] = sectors & 0x000000FF; error = write_cmd(usbdev, pcbw); if (error != USB_NO_ERROR) { return error; } - cdi_sleep_ms(20); struct usb_packet out_packet = { - .type = PACKET_OUT, - .endpoint = msc->bulk_ep_out->endpoint_address, - .phys_data = phys_buffer, - .length = length, - .datatoggle = 0, - .type_of_data = USB_TOD_DATA_OUT, + .type = PACKET_OUT, + .endpoint = msc->bulk_ep_out->endpoint_address, + .phys_data = phys_buffer, + .length = length, + .datatoggle = 0, + .type_of_data = USB_TOD_DATA_OUT, }; error = usb_do_packet(usbdev, &out_packet); @@ -599,23 +568,11 @@ static uint32_t msd_write(struct usb_device *usbdev, uint32_t lba, uint16_t sect return error; } - cdi_sleep_ms(5); - error = read_status(usbdev, pcsw); + error = read_status(usbdev, expected_tag); if (error != USB_NO_ERROR) { return error; } - cdi_sleep_ms(4); - if ((csw->csw_signature != CSW_SIGNATURE) || - (csw->csw_tag != expected_tag) || - csw->csw_status) - { - dprintf("0x%08X 0x%08X==0x%08X 0x%02X\n", csw->csw_signature, - csw->csw_tag, - expected_tag, - csw->csw_status); - return USB_CRC; - } return USB_NO_ERROR; } @@ -631,15 +588,15 @@ static void get_partitions(struct cdi_storage_device *cdistrg) dprintf("MBR konnte nicht eingelesen werden.\n"); return; } - if (((uint16_t *)mbr)[255] != 0xAA55) { + if (((uint16_t *) mbr)[255] != 0xAA55) { return; } partition = mbr + 0x1BE; dprintf("Partitionen auf %s:", cdistrg->dev.name); - for (i = 0; i < 4; i++) - { - if (partition[i].type && partition[i].size && (partition[i].start + partition[i].size < cdistrg->block_count)) - { + for (i = 0; i < 4; i++) { + if (partition[i].type && partition[i].size + && (partition[i].start + partition[i].size < + cdistrg->block_count)) { cdimsd = malloc(sizeof(struct cdi_msd)); if (cdimsd == NULL) { break; @@ -648,12 +605,12 @@ static void get_partitions(struct cdi_storage_device *cdistrg) cdimsd->usb_device = base_cdimsd->usb_device; cdimsd->cdi_device.dev.type = CDI_STORAGE; cdimsd->cdi_device.dev.name = malloc(14); - if (cdimsd->cdi_device.dev.name == NULL) - { + if (cdimsd->cdi_device.dev.name == NULL) { free(cdimsd); break; } - sprintf((char *)cdimsd->cdi_device.dev.name, "%sp%i", cdistrg->dev.name, j++); + sprintf((char *)cdimsd->cdi_device.dev.name, "%sp%i", + cdistrg->dev.name, j++); cdimsd->cdi_device.block_size = base_cdimsd->cdi_device.block_size; cdimsd->cdi_device.block_count = partition[i].size; _dprintf(" %s", cdimsd->cdi_device.dev.name); diff --git a/usb/uhci.c b/usb/uhci.c index 799d526..6cdc44c 100644 --- a/usb/uhci.c +++ b/usb/uhci.c @@ -43,6 +43,7 @@ static int dprintf(const char *fmt, ...) { return 0; } + #define _dprintf(fmt, args...) dprintf(fmt, ##args) #endif @@ -52,7 +53,9 @@ static struct cdi_driver cdi_driver; static cdi_list_t active_transfers; static void uhci_handler(struct cdi_device *dev); -static int enqueue_request(struct hci *gen_hci, int frame, int type, int device, int endpoint, int low_speed, uintptr_t phys_data, int length, int datatoggle); +static int enqueue_request(struct hci *gen_hci, int frame, int type, + int device, int endpoint, int low_speed, + uintptr_t phys_data, int length, int datatoggle); static cdi_list_t get_devices(struct hci *gen_hci); static void activate_device(struct hci *gen_hci, struct usb_device *device); static int get_current_frame(struct hci *gen_hci); @@ -75,14 +78,13 @@ struct cdi_driver *init_uhcd() static void uhci_kill(struct cdi_driver *cdi_hcd) { - //TODO: Da geht doch noch was + //TODO: Da geht doch noch was } static void uhci_deinit(struct cdi_device *cdi_hci) { - cdi_outw(((struct uhci *)((struct cdi_hci *)cdi_hci)->hci)->pbase + UHCI_USBCMD, - MAXP); //HC anhalten - //TODO: Hier doch auch + cdi_outw(((struct uhci *)((struct cdi_hci *)cdi_hci)->hci)->pbase + UHCI_USBCMD, MAXP); //HC anhalten + //TODO: Hier doch auch } void uhci_init(struct cdi_device *cdi_hci) @@ -95,13 +97,10 @@ void uhci_init(struct cdi_device *cdi_hci) //cdi_pci_alloc_ioports(gen_hci->pcidev); uhci->pbase = 0; for (i = 0; (res = cdi_list_get(gen_hci->pcidev->resources, i)) != NULL; - i++) - { - if (res->type == CDI_PCI_IOPORTS) - { + i++) { + if (res->type == CDI_PCI_IOPORTS) { size = res->length ? res->length : 0x14; - if (cdi_ioports_alloc(res->start, size) == -1) - { + if (cdi_ioports_alloc(res->start, size) == -1) { dprintf("I/O-Ports konnten nicht reserviert werden.\n"); return; } @@ -109,14 +108,12 @@ void uhci_init(struct cdi_device *cdi_hci) break; } } - if (!uhci->pbase) - { + if (!uhci->pbase) { dprintf("I/O-Basis nicht gefunden!\n"); return; } if (cdi_alloc_phys_mem(4096, (void **)&uhci->frame_list, - (void **)&uhci->phys_frame_list) == -1) - { + (void **)&uhci->phys_frame_list) == -1) { dprintf("Frame List konnte nicht allociert werden!\n"); return; } @@ -125,9 +122,10 @@ void uhci_init(struct cdi_device *cdi_hci) if (uhci->root_ports > 7) { //Laut Linuxkernel ist das so "weird", dass da was nicht stimmen kann... uhci->root_ports = 2; } - dprintf("UHC mit I/O 0x%04X (%i Ports) und IRQ %i\n", uhci->pbase, uhci->root_ports, gen_hci->pcidev->irq); + dprintf("UHC mit I/O 0x%04X (%i Ports) und IRQ %i\n", uhci->pbase, + uhci->root_ports, gen_hci->pcidev->irq); for (i = 0; i < 1024; i++) { - uhci->frame_list[i] = 1; //Invalid + uhci->frame_list[i] = 1; //Invalid } dprintf("Resetten...\n"); //HC zurücksetzen @@ -144,10 +142,10 @@ void uhci_init(struct cdi_device *cdi_hci) cdi_outw(uhci->pbase + UHCI_USBINTR, 0xF); //Framelistadresse eintragen cdi_outl(uhci->pbase + UHCI_FRBASEADD, uhci->phys_frame_list); - cdi_outw(uhci->pbase + UHCI_FRNUM, 0); //Frame zurücksetzen + cdi_outw(uhci->pbase + UHCI_FRNUM, 0); //Frame zurücksetzen //Ports abschalten, damit selektiv eingeschaltet werden kann (Enumeration) for (i = 0; i < uhci->root_ports; i++) { - cdi_outw(uhci->pbase + UHCI_RPORTS + i*2, RPORT_CSC); + cdi_outw(uhci->pbase + UHCI_RPORTS + i * 2, RPORT_CSC); } dprintf(" Fertig\n"); gen_hci->find_devices = &get_devices; @@ -167,10 +165,8 @@ static cdi_list_t get_devices(struct hci *gen_hci) dprintf("Geräte finden: "); cdi_outw(uhci->pbase + UHCI_USBCMD, USB_RUN); - for (i = 0; i < uhci->root_ports; i++) - { - if (!(cdi_inw(uhci->pbase + UHCI_RPORTS + 2*i) & RPORT_DEVICE)) - { + for (i = 0; i < uhci->root_ports; i++) { + if (!(cdi_inw(uhci->pbase + UHCI_RPORTS + 2 * i) & RPORT_DEVICE)) { _dprintf("-"); continue; } @@ -180,7 +176,7 @@ static cdi_list_t get_devices(struct hci *gen_hci) dev->id = 0; dev->port = i; dev->low_speed = - (cdi_inw(uhci->pbase + UHCI_RPORTS + 2*i) & RPORT_LOSPD) && 1; + (cdi_inw(uhci->pbase + UHCI_RPORTS + 2 * i) & RPORT_LOSPD) && 1; cdi_list_push(dlist, dev); } _dprintf("\n"); @@ -193,7 +189,7 @@ static void activate_device(struct hci *gen_hci, struct usb_device *device) dprintf("Gerät an Port %i wird aktiviert.\n", device->port); cdi_outw(uhci->pbase + UHCI_RPORTS + 2 * device->port, - RPORT_RESET | RPORT_ENABLE | RPORT_CSC); + RPORT_RESET | RPORT_ENABLE | RPORT_CSC); cdi_sleep_ms(20); } @@ -209,34 +205,37 @@ static inline int tsl(volatile int *variable) *variable = 1; return rval; } + static volatile int locked = 0; -static int enqueue_request(struct hci *gen_hci, int frame, int type, int device, int endpoint, int low_speed, uintptr_t phys_data, int length, int datatoggle) +static int enqueue_request(struct hci *gen_hci, int frame, int type, + int device, int endpoint, int low_speed, + uintptr_t phys_data, int length, int datatoggle) { struct uhci *uhci = (struct uhci *)gen_hci; struct uhci_td *td; struct uhci_qh *qh; uintptr_t ptd, pqh; struct transfer *addr; + int timeout; if (cdi_alloc_phys_mem(sizeof(struct uhci_td), - (void **)&td, (void **)&ptd) == -1) { + (void **)&td, (void **)&ptd) == -1) { return USB_TRIVIAL_ERROR; } if (cdi_alloc_phys_mem(sizeof(struct uhci_qh), - (void **)&qh, (void **)&pqh) == -1) { + (void **)&qh, (void **)&pqh) == -1) { return USB_TRIVIAL_ERROR; } - while (tsl(&locked)) - { + while (tsl(&locked)) { #ifndef CDI_STANDALONE - __asm__ __volatile__ ("hlt"); + __asm__ __volatile__("hlt"); #endif } - qh->next = 1; //Invalid + qh->next = 1; //Invalid qh->transfer = ptd; memset(td, 0, sizeof(struct uhci_td)); - td->next = 1; //Invalid + td->next = 1; //Invalid td->active = 1; td->ioc = 1; td->data_toggle = datatoggle; @@ -245,7 +244,7 @@ static int enqueue_request(struct hci *gen_hci, int frame, int type, int device, td->pid = type; td->device = device; td->endpoint = endpoint; - td->maxlen = length ? length-1 : 0x7FF; + td->maxlen = length ? length - 1 : 0x7FF; td->buffer = phys_data; addr = malloc(sizeof(struct transfer)); addr->virt = td; @@ -253,20 +252,12 @@ static int enqueue_request(struct hci *gen_hci, int frame, int type, int device, addr->error = 0xFFFF; cdi_list_push(active_transfers, addr); uhci->frame_list[frame] = pqh | 2; -#ifdef CDI_STANDALONE - /*int cframe = get_current_frame(gen_hci), nframe; - nframe = (cframe > frame) ? frame + 1024 : frame; //Überläufe korrigieren - //Annähern, wann er wohl fertig ist - cdi_sleep_ms(nframe + 30 - get_current_frame(gen_hci));*/ -#else - while (!(qh->transfer & 1)) { - __asm__ __volatile__ ("hlt"); + for (timeout = 0; !(qh->transfer & 1) && (timeout < 1000); timeout++) { + cdi_sleep_ms(1); } -#endif - while (addr->error == 0xFFFF) - { + while ((timeout < 1000) && (addr->error == 0xFFFF)) { #ifndef CDI_STANDALONE - __asm__ __volatile__ ("hlt"); + __asm__ __volatile__("hlt"); #endif } uhci->frame_list[frame] = 1; @@ -281,54 +272,44 @@ static void uhci_handler(struct cdi_device *cdi_hci) struct transfer *addr; struct uhci_td *td; - if (!status) { //Also, von hier kommt der IRQ nicht. + if (!status) { //Also, von hier kommt der IRQ nicht. return; } if (status & ~0x0001) { dprintf("Unerwarteter IRQ 0x%04X von %s\n", status, cdi_hci->name); } - if (status & 0x10) - { + if (status & 0x10) { printf("[uhci] SCHWERWIEGENDER FEHLER - HC WIRD ANGEHALTEN\n"); - cdi_outw(uhci->pbase + UHCI_USBCMD, MAXP | HCRESET); //FU! - } - else - { - for (i = 0; (addr = cdi_list_get(active_transfers, i)) != NULL; i++) - { + cdi_outw(uhci->pbase + UHCI_USBCMD, MAXP | HCRESET); //FU! + } else { + for (i = 0; (addr = cdi_list_get(active_transfers, i)) != NULL; i++) { td = addr->virt; if (td->active) { continue; } addr->error = USB_NO_ERROR; cdi_list_remove(active_transfers, i--); - if (td->stalled_err) - { + if (td->stalled_err) { dprintf("ENDPOINT STALLED\n"); addr->error |= USB_STALLED; } - if (td->buf_err) - { + if (td->buf_err) { dprintf("Pufferüberlauf oder Underrun\n"); addr->error |= USB_BUFFER_ERROR; } - if (td->babble) - { - dprintf("Puh, da war ein Gerät wohl sehr gesprächig: Babble.\n"); + if (td->babble) { + dprintf("Da war ein Gerät wohl sehr gesprächig: Babble.\n"); addr->error |= USB_BABBLE; } - if (td->nak) - { + if (td->nak) { dprintf("NAK empfangen\n"); addr->error |= USB_NAK; } - if (td->crc_time_err) - { + if (td->crc_time_err) { dprintf("CRC-Fehler oder Timeout\n"); addr->error |= USB_CRC | USB_TIMEOUT; } - if (td->bitstuff_err) - { + if (td->bitstuff_err) { dprintf("Bitstufffehler\n"); addr->error |= USB_BITSTUFF; } -- 1.6.3.3