[Cdi-devel] [PATCH] UHCI, USB, MSC
Max Reitz ·
+ UHCI/USB/MSC (MSDs erscheinen als CDI.storage), der Schreibsupport ist große Glückssache, Treiber nur unter QEMU erfolgreich getestet... Signed-off-by: Max Reitz <xanclic at googlemail.com> --- usb/include/msd.h | 104 +++++++++ usb/include/uhci.h | 110 ++++++++++ usb/include/usb.h | 287 +++++++++++++++++++++++++ usb/main.c | 451 +++++++++++++++++++++++++++++++++++++++ usb/msd.c | 599 ++++++++++++++++++++++++++++++++++++++++++++++++++++ usb/uhci.c | 339 +++++++++++++++++++++++++++++ 6 files changed, 1890 insertions(+), 0 deletions(-) create mode 100644 usb/include/msd.h create mode 100644 usb/include/uhci.h create mode 100644 usb/include/usb.h create mode 100644 usb/main.c create mode 100644 usb/msd.c create mode 100644 usb/uhci.c diff --git a/usb/include/msd.h b/usb/include/msd.h new file mode 100644 index 0000000..99c796d --- /dev/null +++ b/usb/include/msd.h @@ -0,0 +1,104 @@ +/****************************************************************************** + * Copyright (c) 2009 Max Reitz * + * * + * Permission is hereby granted, free of charge, to any person obtaining a * + * copy of this software and associated documentation files (the "Software"), * + * to deal in the Software without restriction, including without limitation * + * the rights to use, copy, modify, merge, publish, distribute, sublicense, * + * and/or sell copies of the Software, and to permit persons to whom the * + * Software is furnished to do so, subject to the following conditions: * + * * + * The above copyright notice and this permission notice shall be included in * + * all copies or substantial portions of the Software. * + * * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * + * DEALINGS IN THE SOFTWARE. * + ******************************************************************************/ + +#ifndef _CDI__USB__MSD_H +#define _CDI__USB__MSD_H + +#include <stdint.h> + +#include "cdi/storage.h" + +#include "usb.h" + + +//"USBC" +#define CBW_SIGNATURE 0x43425355 +struct command_block_wrapper +{ + uint32_t cbw_signature; + uint32_t cbw_tag; + uint32_t cbw_data_transfer_length; + uint8_t cbw_flags; + uint8_t cbw_lun; + uint8_t cbw_cb_length; + uint8_t cbw_cb[16]; +} __attribute__((packed)); + +//"USBS" +#define CSW_SIGNATURE 0x53425355 +struct command_status_wrapper +{ + uint32_t csw_signature; + uint32_t csw_tag; + uint32_t csw_data_residue; + uint8_t csw_status; +} __attribute__((packed)); + +struct msc_sense +{ + unsigned error : 7; + unsigned valid : 1; + uint8_t rsvd0; + 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)); + +struct msd_capacity +{ + uint32_t last_lba; + uint32_t block_length; +} __attribute__((packed)); + +struct cdi_msd +{ + struct cdi_storage_device cdi_device; + struct usb_device *usb_device; + 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)); + + +#define MSC_CMD_REZERO 0x01 +#define MSC_CMD_SENSE 0x03 +#define MSC_CMD_CAPACITY 0x25 +#define MSC_CMD_READ10 0x28 +#define MSC_CMD_WRITE10 0x2A +#define MSC_CMD_SEEK 0x2B +#define MSC_CMD_READ12 0xA8 +#define MSC_CMD_WRITE12 0xAA + +#endif diff --git a/usb/include/uhci.h b/usb/include/uhci.h new file mode 100644 index 0000000..0158bd2 --- /dev/null +++ b/usb/include/uhci.h @@ -0,0 +1,110 @@ +/****************************************************************************** + * Copyright (c) 2009 Max Reitz * + * * + * Permission is hereby granted, free of charge, to any person obtaining a * + * copy of this software and associated documentation files (the "Software"), * + * to deal in the Software without restriction, including without limitation * + * the rights to use, copy, modify, merge, publish, distribute, sublicense, * + * and/or sell copies of the Software, and to permit persons to whom the * + * Software is furnished to do so, subject to the following conditions: * + * * + * The above copyright notice and this permission notice shall be included in * + * all copies or substantial portions of the Software. * + * * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * + * DEALINGS IN THE SOFTWARE. * + ******************************************************************************/ + +#ifndef _CDI__USB__UHCI_H +#define _CDI__USB__UHCI_H + +#include <stdint.h> + +#include "cdi/misc.h" +#include "cdi/pci.h" + +#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_RPORTS 0x10 +#define UHCI_PORTSC1 0x10 //w +#define UHCI_PORTSC2 0x12 //w + +#define MAXP 0x0080 +#define GRESET 0x0004 +#define HCRESET 0x0002 +#define USB_RUN 0x0001 + +#define RPORT_RESET 0x0200 +#define RPORT_LOSPD 0x0100 //Low speed device attached +#define RPORT_ENABLE 0x0004 +#define RPORT_CSC 0x0002 //Connect status change +#define RPORT_DEVICE 0x0001 + + +struct uhci +{ + struct hci gen_hci; + uint16_t pbase; + uintptr_t phys_frame_list; + uint32_t *frame_list; + int root_ports; +}; + +struct uhci_qh +{ + volatile uint32_t next; + volatile uint32_t transfer; +} __attribute__((packed)); + +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; + + uint32_t buffer; + + uint32_t user[4]; +} __attribute__((packed)); + +struct transfer +{ + void *virt; + uintptr_t phys; + volatile int error; +}; + +#endif diff --git a/usb/include/usb.h b/usb/include/usb.h new file mode 100644 index 0000000..2c435d8 --- /dev/null +++ b/usb/include/usb.h @@ -0,0 +1,287 @@ +/****************************************************************************** + * Copyright (c) 2009 Max Reitz * + * * + * Permission is hereby granted, free of charge, to any person obtaining a * + * copy of this software and associated documentation files (the "Software"), * + * to deal in the Software without restriction, including without limitation * + * the rights to use, copy, modify, merge, publish, distribute, sublicense, * + * and/or sell copies of the Software, and to permit persons to whom the * + * Software is furnished to do so, subject to the following conditions: * + * * + * The above copyright notice and this permission notice shall be included in * + * all copies or substantial portions of the Software. * + * * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * + * DEALINGS IN THE SOFTWARE. * + ******************************************************************************/ + +#ifndef _CDI__USB__USB_H +#define _CDI__USB__USB_H + +#include <stdint.h> + +#include "cdi/misc.h" +#include "cdi/pci.h" + + +#define PACKET_SETUP 0x2D +#define PACKET_IN 0x69 +#define PACKET_OUT 0xE1 + +#define NO_DATA 0x01 +#define DEV_TO_HOST 0x80 +#define HOST_TO_DEV 0x00 +#define STD_REQUEST 0x00 +#define CLS_REQUEST 0x20 +#define VEN_REQUEST 0x40 +#define REC_DEVICE 0x00 +#define REC_INTERFACE 0x01 +#define REC_ENDPOINT 0x02 +#define REC_OTHER 0x03 + +#define GET_STATUS 0 +#define CLEAR_FEATURE 1 +#define SET_FEATURE 3 +#define SET_ADDRESS 5 +#define GET_DESCRIPTOR 6 +#define SET_DESCRIPTOR 7 +#define GET_CONFIGURATION 8 +#define SET_CONFIGURATION 9 +#define GET_INTERFACE 10 +#define SET_INTERFACE 11 +#define SYNC_FRAME 12 + +#define PORT_DEVICE 0x0001 +#define PORT_ENABLED 0x0002 +#define PORT_SUSPENDED 0x0004 +#define PORT_OVERCURRENT 0x0008 +#define PORT_RESET 0x0010 +#define PORT_POWER 0x0100 +#define PORT_LOWSPEED 0x0200 +#define PORT_HIGHSPEED 0x0400 +#define PORT_TEST 0x0800 +#define PORT_INDICATOR 0x1000 + +#define PORTF_CONNECTION 0 +#define PORTF_ENABLE 1 +#define PORTF_SUSPEND 2 +#define PORTF_OVERCURRENT 3 +#define PORTF_RESET 4 +#define PORTF_POWER 8 +#define PORTF_LOWSPEED 9 +#define PORTF_HIGHSPEED 10 +#define PORTF_C_CONNECTION 16 +#define PORTF_C_ENABLE 17 +#define PORTF_C_SUSPEND 18 +#define PORTF_C_OVERCURRENT 19 +#define PORTF_C_RESET 20 +#define PORTF_TEST 21 +#define PORTF_INDICATOR 22 + +#define DESC_DEVICE 1 +#define DESC_CONFIGURATION 2 +#define DESC_STRING 3 +#define DESC_INTERFACE 4 +#define DESC_ENDPOINT 5 +#define DESC_DEVICE_QUALIFIER 6 +#define DESC_OTHER_SPEED_CONFIGURATION 7 +#define DESC_INTERFACE_POWER 8 + +#define USB_NO_ERROR 0x00 +#define USB_STALLED 0x01 +#define USB_BUFFER_ERROR 0x02 +#define USB_BABBLE 0x04 +#define USB_NAK 0x08 +#define USB_CRC 0x10 +#define USB_TIMEOUT 0x20 +#define USB_BITSTUFF 0x40 +#define USB_TRIVIAL_ERROR 0x80 + +#define USB_TOD_SETUP 0x0001 +#define USB_TOD_SETUP_DATA_IN 0x0002 +#define USB_TOD_SETUP_DATA_OUT 0x0004 +#define USB_TOD_SETUP_ACK_IN 0x0008 +#define USB_TOD_SETUP_ACK_OUT 0x0010 +#define USB_TOD_COMMAND 0x0020 +#define USB_TOD_DATA_IN 0x0040 +#define USB_TOD_DATA_OUT 0x0080 +#define USB_TOD_STATUS 0x0100 + +#define USB_TODS_SETUP 0 +#define USB_TODS_SETUP_DATA_IN 1 +#define USB_TODS_SETUP_DATA_OUT 2 +#define USB_TODS_SETUP_ACK_IN 3 +#define USB_TODS_SETUP_ACK_OUT 4 +#define USB_TODS_COMMAND 5 +#define USB_TODS_DATA_IN 6 +#define USB_TODS_DATA_OUT 7 +#define USB_TODS_STATUS 8 + + +typedef enum +{ + HCI_UHCI, + HCI_OHCI, + HCI_EHCI +} hci_type_t; + +struct cdi_hci +{ + struct cdi_device cdi_device; + struct hci *hci; +}; + +struct usb_device; + +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 *); +}; + +struct setup_packet +{ + uint8_t request_type; + uint8_t request; + uint16_t value; + uint16_t index; + uint16_t length; +} __attribute__((packed)); + +struct device_desc +{ + uint8_t length; + uint8_t descriptor_type; + uint16_t bcdUSB; + uint8_t class_id; + uint8_t subclass_id; + uint8_t protocol_id; + uint8_t max_packet_size0; + uint16_t vendor_id; + uint16_t device_id; + uint16_t bcdDevice; + uint8_t iManufacturer; + uint8_t iProduct; + uint8_t iSerialNumber; + uint8_t num_configurations; +} __attribute__((packed)); + +struct config_desc +{ + uint8_t length; + uint8_t descriptor_type; + uint16_t total_length; + uint8_t num_interfaces; + uint8_t config_value; + uint8_t iConfiguration; + uint8_t attributes; + uint8_t max_power; +} __attribute__((packed)); + +struct interface_desc +{ + uint8_t length; + uint8_t descriptor_type; + uint8_t interface_number; + uint8_t alternate_setting; + uint8_t num_endpoints; + uint8_t interface_class; + uint8_t interface_subclass; + uint8_t interface_protocol; + uint8_t iInterface; +} __attribute__((packed)); + +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)); + +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)); + +typedef enum +{ + USBDC_COMPOSITE = 0x00, + USBDC_AUDIO = 0x01, + USBDC_COMM_CDC = 0x02, + USBDC_HID = 0x03, + USBDC_PID = 0x05, + USBDC_IMAGE = 0x06, + USBDC_PRINTER = 0x07, + USBDC_MSC = 0x08, + USBDC_HUB = 0x09, + USBDC_CDC_DATA = 0x0A, + USBDC_CHIP = 0x0B, + USBDC_SECURITY = 0x0D, + USBDC_VIDEO = 0x0E, + USBDC_HEALTH = 0x0F, + USBDC_DIAGNOSIS = 0xDC, + USBDC_WIRELESS = 0xE0, + USBDC_MISC = 0xEF, + USBDC_SOFT_SPEC = 0xFE, + USBDC_VENDOR_SPEC = 0xFF +} usb_class_t; + +struct class_data +{ + usb_class_t type; +}; + +struct usb_device +{ + struct hci *hci; + int id; + int port; + int low_speed; + struct device_desc *device; + struct config_desc *config; + struct interface_desc *interface; + struct class_data *classd; + int stalled; + int locked; + int expects; +}; + +struct msclass_data +{ + struct class_data gen_class; + struct endpoint_desc *bulk_ep_in; + struct endpoint_desc *bulk_ep_out; +}; + + +#include "uhci.h" + + +#define HCI_STRUCT_SIZE sizeof(struct uhci) + + +int do_packet(struct usb_device *device, int type, int endpoint, uintptr_t phys_data, int length, int datatoggle, int type_of_data); +void enumerate_hci(struct hci *); +struct cdi_driver *init_uhcd(void); +void init_msc_driver(void); +void register_msd(struct usb_device *usbdev); +void uhci_init(struct cdi_device *cdi_hci); + +#endif diff --git a/usb/main.c b/usb/main.c new file mode 100644 index 0000000..c06f15d --- /dev/null +++ b/usb/main.c @@ -0,0 +1,451 @@ +/****************************************************************************** + * Copyright (c) 2009 Max Reitz * + * * + * Permission is hereby granted, free of charge, to any person obtaining a * + * copy of this software and associated documentation files (the "Software"), * + * to deal in the Software without restriction, including without limitation * + * the rights to use, copy, modify, merge, publish, distribute, sublicense, * + * and/or sell copies of the Software, and to permit persons to whom the * + * Software is furnished to do so, subject to the following conditions: * + * * + * The above copyright notice and this permission notice shall be included in * + * all copies or substantial portions of the Software. * + * * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * + * DEALINGS IN THE SOFTWARE. * + ******************************************************************************/ + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include "cdi/io.h" +#include "cdi/misc.h" +#include "cdi/pci.h" + +#include "usb.h" + +#define DEBUG + +#ifdef DEBUG +#include <stdarg.h> +#define dprintf(fmt, args...) printf("[usb] " fmt, ##args) +#define _dprintf(fmt, args...) printf(fmt, ##args) +#else +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 int usb_dev_ids = 1; + +static void usb_init(void); +static void enumerate_hub(struct usb_device *usbdev); + +#ifdef CDI_STANDALONE +int main(void) +#else +int init_usb(void) +#endif +{ + cdi_init(); + + memset(devices, 0, 128 * sizeof(struct usb_device *)); + + usb_init(); + + cdi_run_drivers(); + + return 0; +} + +static const int next_data_type[9] = { + USB_TOD_SETUP_DATA_IN | USB_TOD_SETUP_DATA_OUT | USB_TOD_SETUP_ACK_IN, + USB_TOD_SETUP_ACK_OUT, + USB_TOD_SETUP_ACK_IN, + USB_TOD_SETUP | USB_TOD_COMMAND, + USB_TOD_SETUP | USB_TOD_COMMAND, + USB_TOD_DATA_IN | USB_TOD_DATA_OUT | USB_TOD_STATUS, + USB_TOD_STATUS, + USB_TOD_STATUS, + USB_TOD_SETUP | USB_TOD_COMMAND +}; + +/*static const char *tod_name[9] = { + "SETUP", + "SETUP DS IN", + "SETUP DS OUT", + "SETUP ACK IN", + "SETUP ACK OUT", + "COMMAND", + "DATA IN", + "DATA OUT", + "STATUS" +};*/ + +/** +* Verarbeitet ein USB-Paket. +* +* @param device Das USB-Gerät +* @param type Der Typ des Pakets (PACKET_IN, PACKET_OUT, PACKET_SETUP) +* @param endpoint Der gewünschte Endpoint (0 bis 15) +* @param phys_data Die physische Adresse des zu verwendenden Datenpuffers +* @param length Die Länge des Puffers +* @param datatoggle Gibt an, ob DATA0 (0) oder DATA1 (1) verwendet werden soll +* @param type_of_data Typ der Daten (zur Sicherheit, damit es kein doofes STALL gibt) +*/ + +int do_packet(struct usb_device *device, int type, int endpoint, uintptr_t phys_data, int length, int datatoggle, int type_of_data) +{ + int error; + int tod_short; + + if (!(device->expects & type_of_data)) { + dprintf("Expected 0x%04X, got 0x%04X...?\n", device->expects, type_of_data); + for (;;); + } + type_of_data >>= 1; + for (tod_short = 0; type_of_data; tod_short++) { + type_of_data >>= 1; + } + //dprintf("TOD: %s\n", tod_name[tod_short]); + device->expects = next_data_type[tod_short]; + endpoint &= 0x07; + type &= 0xFF; + 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, + type, device->id, endpoint, + device->low_speed, phys_data, length, + datatoggle); + if (error == USB_STALLED) + { + printf("[usb] ENDPOINT %i DES GERÄTS %i STALLED!\n", endpoint, device->id); + device->stalled = 1; + } + 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) +{ + void *rbuf; + int rval, no_data; + struct setup_packet *setup; + uintptr_t pbuf, psetup; + + no_data = direction & NO_DATA; + if (!no_data && (cdi_alloc_phys_mem(length, &rbuf, (void **)&pbuf) == -1)) { + return NULL; + } + if (cdi_alloc_phys_mem(sizeof(struct setup_packet), + (void **)&setup, (void **)&psetup) == -1) { + return NULL; + } + direction &= 0x80; + if ((direction == HOST_TO_DEV) && length && (buffer != NULL)) { + memcpy(rbuf, buffer, length); + } + setup->request_type = direction | (rtype & 0x60) | (recipient & 0x1F); + setup->request = request; + setup->value = value; + setup->index = index; + setup->length = length; + if (do_packet(device, PACKET_SETUP, 0, psetup, sizeof(struct setup_packet), + 0, USB_TOD_SETUP) != USB_NO_ERROR) { + return NULL; + } + cdi_sleep_ms(20); + if (no_data) + { + rval = USB_NO_ERROR; + rbuf = (void *)0xFFFFFFFF; //Kein Fehler, aber auch keine Daten + } + else + { + if (direction == DEV_TO_HOST) { + rval = do_packet(device, PACKET_IN, 0, pbuf, length, 1, + USB_TOD_SETUP_DATA_IN); + } else { + rval = do_packet(device, PACKET_OUT, 0, pbuf, length, 1, + USB_TOD_SETUP_DATA_OUT); + } + } + if (rval == USB_NO_ERROR) + { + cdi_sleep_ms(20); + if (no_data || (direction == HOST_TO_DEV)) { + rval = do_packet(device, PACKET_IN, 0, 0, 0, 1, USB_TOD_SETUP_ACK_IN); + } else { + rval = do_packet(device, PACKET_OUT, 0, 0, 0, 1, USB_TOD_SETUP_ACK_OUT); + } + } + return (rval == USB_NO_ERROR) ? rbuf : NULL; +} + +static void usb_init(void) +{ + struct cdi_pci_device *dev; + struct hci *hci; + struct cdi_hci *cdi_hci; + struct cdi_driver *uhcd; + char *dev_name; + int i; + + init_msc_driver(); + + memset(ccdriver_take_device, 0, sizeof(void (*)(struct usb_device *)) * 0x100); + ccdriver_take_device[8] = ®ister_msd; + ccdriver_take_device[9] = &enumerate_hub; + + ehci = cdi_list_create(); + ohci = cdi_list_create(); + uhci = cdi_list_create(); + + 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++) + { + if ((dev->class_id != 0x0C) || (dev->subclass_id != 0x03)) { + cdi_pci_device_destroy(dev); + } else { + switch (dev->interface_id) + { + case 0x00: + hci = malloc(HCI_STRUCT_SIZE); + hci->pcidev = dev; + hci->type = HCI_UHCI; + cdi_list_push(uhci, hci); + break; + case 0x10: + hci = malloc(HCI_STRUCT_SIZE); + hci->pcidev = dev; + hci->type = HCI_OHCI; + cdi_list_push(ohci, hci); + break; + case 0x20: + hci = malloc(HCI_STRUCT_SIZE); + hci->pcidev = dev; + hci->type = HCI_EHCI; + cdi_list_push(ehci, hci); + } + } + } + + 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)); + + uhcd = init_uhcd(); + + 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); + sprintf(dev_name, "uhci%i", i); + cdi_hci->cdi_device.name = dev_name; + hci->find_devices = NULL; + cdi_hci->hci = hci; + //cdi_list_push(uhcd->devices, cdi_hci); + //^ Das ist zwar sehr schön, geht so aber leider nicht + dprintf("%s registriert.\n", dev_name); + cdi_hci->cdi_device.driver = uhcd; + uhci_init(&cdi_hci->cdi_device); + } + + cdi_list_destroy(ehci); + cdi_list_destroy(ohci); + cdi_list_destroy(uhci); +} + +static void enum_device(struct usb_device *usbdev) +{ + struct device_desc *dev_desc; + struct config_desc *conf_desc; + struct interface_desc *if_desc, *best_if; + char *name; + void *position; + int i, id; + + usbdev->stalled = 0; + 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); + 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); + do_control(usbdev, HOST_TO_DEV | NO_DATA, NULL, 0, STD_REQUEST, REC_DEVICE, + SET_ADDRESS, (id = usb_dev_ids++), 0); + usbdev->id = id; + _dprintf("%i\n", id); + 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); + if (name == NULL) { + return; + } + dprintf(" -> Hersteller: "); + for (i = 2; i < name[0]; i += 2) { + _dprintf("%c", name[i]); + } + _dprintf("\n"); + } + 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); + if (name == NULL) { + return; + } + dprintf(" -> Produkt: "); + for (i = 2; i < name[0]; i += 2) { + _dprintf("%c", name[i]); + } + _dprintf("\n"); + } + devices[id] = usbdev; + //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); + 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); + 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) + { + name = do_control(usbdev, DEV_TO_HOST, NULL, 64, STD_REQUEST, + REC_DEVICE, GET_DESCRIPTOR, + (DESC_STRING << 8) | conf_desc->iConfiguration, 0); + if (name == NULL) { + return; + } + dprintf("Verwende Konfiguration "); + for (i = 2; i < name[0]; i += 2) { + _dprintf("%c", name[i]); + } + _dprintf(".\n"); + } + position = conf_desc; + position += sizeof(struct config_desc); + 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! + { + best_if = if_desc; + break; + } + 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); + usbdev->interface = best_if; + 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); + if (name == NULL) { + return; + } + dprintf("Verwende Interface "); + for (i = 2; i < name[0]; i += 2) { + _dprintf("%c", name[i]); + } + _dprintf(".\n"); + } + dprintf("Konfiguration: %i:%i (%i)\n", conf_desc->config_value, + 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); + } +} + +static void enumerate_hub(struct usb_device *usbdev) +{ + struct hub_desc *hub_desc; + struct usb_device *down; + uint16_t *port_status; + int i; + + //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++) + { + port_status = do_control(usbdev, DEV_TO_HOST, NULL, 4, CLS_REQUEST, + 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); + 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); + //Reset sollte jetzt eigtl. schon beendet sein + //(do_control wartet ja 50 ms) + down = malloc(sizeof(struct usb_device)); + down->hci = usbdev->hci; + down->id = 0; + down->port = i; + down->low_speed = (port_status[0] & PORT_LOWSPEED) && 1; + enum_device(down); + } +} + +void enumerate_hci(struct hci *hci) +{ + struct usb_device *usbdev; + cdi_list_t usb_devices; + + if (hci->find_devices != NULL) + { + usb_devices = hci->find_devices(hci); + 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 new file mode 100644 index 0000000..11fbd6a --- /dev/null +++ b/usb/msd.c @@ -0,0 +1,599 @@ +/****************************************************************************** + * Copyright (c) 2009 Max Reitz * + * * + * Permission is hereby granted, free of charge, to any person obtaining a * + * copy of this software and associated documentation files (the "Software"), * + * to deal in the Software without restriction, including without limitation * + * the rights to use, copy, modify, merge, publish, distribute, sublicense, * + * and/or sell copies of the Software, and to permit persons to whom the * + * Software is furnished to do so, subject to the following conditions: * + * * + * The above copyright notice and this permission notice shall be included in * + * all copies or substantial portions of the Software. * + * * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * + * DEALINGS IN THE SOFTWARE. * + ******************************************************************************/ + +#include <stdint.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include "cdi/misc.h" +#include "cdi/storage.h" + +#include "msd.h" +#include "usb.h" + +//DEBUG definieren, um einige Debugmeldungen anzuzeigen +#define DEBUG +//FULLDEBUG definieren, um ALLE Debugmeldungen anzuzeigen +#define FULLDEBUG + +#if defined FULLDEBUG && !defined DEBUG +#define DEBUG +#endif + +#ifdef DEBUG +#define dprintf(fmt, args...) printf("[usb-msc] " fmt, ##args) +#define _dprintf(fmt, args...) printf(fmt, ##args) +#else +static int dprintf(const char *fmt, ...) +{ + return 0; +} +#define _dprintf(fmt, args...) dprintf(fmt, ##args) +#endif + +#ifdef FULLDEBUG +#define fdprintf(fmt, args...) printf("[usb-msc] " fmt, ##args) +#else +static int fdprintf(const char *fmt, ...) +{ + return 0; +} +#endif + +static uint32_t cbw_tag = 1; + +static const char *driver_name = "usb-msc"; + +static struct cdi_storage_driver cdi_driver; + +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); + +//TODO: CDI-Funktion wäre hier sicher nützlich... +#define CPU_IS_LITTLE_ENDIAN + +#define change_endianess_32(_) ((((_)&0xFF000000)>>24)|(((_)&0xFF0000)>>8)|(((_)&0xFF00)<<8)|(((_)&0xFF)<<24)) +#ifdef CPU_IS_LITTLE_ENDIAN +#define CPU2BE(_) change_endianess_32(_) +#define CPU2LE(_) (_) +#define BE2CPU(_) change_endianess_32(_) +#define LE2CPU(_) (_) +#else +#define CPU2BE(_) (_) +#define CPU2LE(_) change_endianess_32(_) +#define BE2CPU(_) (_) +#define LE2CPU(_) change_endianess_32(_) +#endif + +//Das muss definiert werden, um vor einem Befehl zu warten, bis das MSD fertig +//ist. Theoretisch ist das äußerst sinnvoll, praktisch hängt sich der Treiber +//bisweilen auf - das sollte allerdings mit dem Timeout gegessen sein +/** +#define WAIT_FOR_MSD_READY +*/ + +//TODO: Storage bietet eine SCSI-Klasse. Die könnte man durchaus benutzen. xD + +void init_msc_driver() +{ + struct cdi_driver *stddrv = (struct cdi_driver *)&cdi_driver; + stddrv->type = CDI_STORAGE; + stddrv->name = driver_name; + stddrv->init_device = &init_msd; + stddrv->remove_device = &deinit_msd; + stddrv->destroy = &kill_driver; + cdi_driver.read_blocks = &msd_cdi_read; + cdi_driver.write_blocks = &msd_cdi_write; + cdi_storage_driver_init(&cdi_driver); + cdi_storage_driver_register(&cdi_driver); +} + +void register_msd(struct usb_device *usbdev) +{ + struct cdi_storage_device *strgdev; + struct cdi_msd *cdimsd; + struct msclass_data *msc; + struct endpoint_desc *ep_desc; + void *address; + int i; + uint32_t bs, bc; + uint64_t size; + static int msdnum = 0; + + 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) { + return; + } + cdimsd->usb_device = usbdev; + cdimsd->offset = 0; + strgdev = (struct cdi_storage_device *)cdimsd; + strgdev->dev.type = CDI_STORAGE; + strgdev->dev.name = malloc(10); + 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) + { + free((void *)strgdev->dev.name); + free(strgdev); + return; + } + usbdev->classd = (struct class_data *)msc; + 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++) + { + ep_desc = address; + 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 + msc->bulk_ep_out = ep_desc; + } + address += sizeof(struct endpoint_desc); + } + 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)) + { + strgdev->block_size = 0; + strgdev->block_count = 0; + dprintf("Konnte Größe für %s nicht ermitteln.\n", strgdev->dev.name); + } + else + { + strgdev->block_size = bs; + strgdev->block_count = bc; + size = bs; + size *= bc; + dprintf("%s: %i * %i B (ca. %i MB).\n", strgdev->dev.name, bc, bs, size >> 20); + } + cdi_storage_device_init(strgdev); + cdi_list_push(cdi_driver.drv.devices, strgdev); + get_partitions(strgdev); +} + +static void init_msd(struct cdi_device *cdi_dev) +{ + //Hier wird nichts gemacht, da die Partitionen schon in register_msd() + //erkannt werden MÜSSEN. Somit läuft die ganze Initialisierung dort ab. +} + +static void kill_driver(struct cdi_driver *cdi_msc_driver) +{ + //TODO: Man könnte doch noch irgendwie die Geräte entfernen +} + +static void deinit_msd(struct cdi_device *cdi_msd) +{ + //TODO: Und gerade hier... +} + +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; + 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) { + return 0; + } + if (cdi_alloc_phys_mem(sizeof(struct msd_capacity), + (void **)&cap, (void **)&pcap) == -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 = sizeof(struct msd_capacity); + 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 + if (do_packet(usbdev, PACKET_OUT, msc->bulk_ep_out->endpoint_address, pcbw, + 0x1F, 0, USB_TOD_COMMAND) != USB_NO_ERROR) { + return 0; + } + cdi_sleep_ms(20); + if (do_packet(usbdev, PACKET_IN, msc->bulk_ep_in->endpoint_address, pcap, + sizeof(struct msd_capacity), 0, USB_TOD_DATA_IN) + != USB_NO_ERROR) { + return 0; + } + cdi_sleep_ms(5); + if (do_packet(usbdev, PACKET_IN, msc->bulk_ep_in->endpoint_address, pcsw, + 0x0D, 0, USB_TOD_STATUS) != USB_NO_ERROR) { + return 0; + } + cdi_sleep_ms(5); + if ((csw->csw_signature != CSW_SIGNATURE) || + (csw->csw_tag != expected_tag) || + csw->csw_status) { + return 0; + } + *block_size = BE2CPU(cap->block_length); + *block_count = BE2CPU(cap->last_lba) + 1; + return 1; +} + +#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 (do_packet(usbdev, PACKET_OUT, msc->bulk_ep_out->endpoint_address, pcbw, + 0x1F, 0, USB_TOD_COMMAND) != USB_NO_ERROR) { + return 0; + } + cdi_sleep_ms(7); + if (do_packet(usbdev, PACKET_IN, msc->bulk_ep_in->endpoint_address, pcsw, + 0x0D, 0, USB_TOD_STATUS) != 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; +} +#endif + +static inline int tsl(volatile int *variable) +{ + int rval; + rval = *variable; + *variable = 1; + 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 int msd_cdi_read(struct cdi_storage_device *strgdev, uint64_t start, uint64_t count, void *buffer) +{ + void *vb; + uintptr_t pb; + int bs = strgdev->block_size, error; +#ifdef WAIT_FOR_MSD_READY + int j; +#endif + uint32_t i; + struct usb_device *usbdev = ((struct cdi_msd *)strgdev)->usb_device; + + 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) + { + dprintf("Blockspeicher konnte nicht allociert werden.\n"); + return -1; + } + if (!count) + { + dprintf("Leere Leseanfrage.\n"); + return 0; + } + while (tsl(&usbdev->locked)) + { +#ifndef CDI_STANDALONE + __asm__ __volatile__ ("hlt"); +#endif + } + 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) + { + dprintf("Lesefehler 0x%X bei Block %i.\n", error, i); + usbdev->locked = 0; + return -1; + } + 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) +{ + struct msclass_data *msc; + struct command_block_wrapper *cbw; + struct command_status_wrapper *csw; + uintptr_t pcbw, pcsw; + 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) { + return USB_TRIVIAL_ERROR; + } + if (!phys_buffer || !length) { + return USB_TRIVIAL_ERROR; + } + 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 = length; + 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[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[7] = (sectors & 0x0000FF00) >> 8; + cbw->cbw_cb[8] = sectors & 0x000000FF; + error = do_packet(usbdev, PACKET_OUT, msc->bulk_ep_out->endpoint_address, + pcbw, 0x1F, 0, USB_TOD_COMMAND); + if (error != USB_NO_ERROR) { + return error; + } + cdi_sleep_ms(20); + error = do_packet(usbdev, PACKET_IN, msc->bulk_ep_in->endpoint_address, + phys_buffer, length, 0, USB_TOD_DATA_IN); + if (error != USB_NO_ERROR) { + return error; + } + cdi_sleep_ms(5); + error = do_packet(usbdev, PACKET_IN, msc->bulk_ep_in->endpoint_address, + pcsw, 0x0D, 0, USB_TOD_STATUS); + 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 int msd_cdi_write(struct cdi_storage_device *strgdev, uint64_t start, uint64_t count, void *buffer) +{ + void *vb; + uintptr_t pb; + int bs = strgdev->block_size, error; +#ifdef WAIT_FOR_MSD_READY + int j; +#endif + uint32_t i; + struct usb_device *usbdev = ((struct cdi_msd *)strgdev)->usb_device; + + 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) + { + dprintf("Blockspeicher zum Schreiben konnte nicht allociert werden.\n"); + return -1; + } + while (tsl(&usbdev->locked)) + { +#ifndef CDI_STANDALONE + __asm__ __volatile__ ("hlt"); +#endif + } + 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) + { + dprintf("Schreibfehler 0x%X bei Block %i.\n", error, i); + usbdev->locked = 0; + return -1; + } + } + usbdev->locked = 0; + return 0; +} + +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; + struct command_status_wrapper *csw; + uintptr_t pcbw, pcsw; + 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) { + return USB_TRIVIAL_ERROR; + } + if (!phys_buffer || !length) { + return USB_TRIVIAL_ERROR; + } + 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 = length; + 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[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[7] = (sectors & 0x0000FF00) >> 8; + cbw->cbw_cb[8] = sectors & 0x000000FF; + error = do_packet(usbdev, PACKET_OUT, msc->bulk_ep_out->endpoint_address, + pcbw, 0x1F, 0, USB_TOD_COMMAND); + if (error != USB_NO_ERROR) { + return error; + } + cdi_sleep_ms(20); + error = do_packet(usbdev, PACKET_OUT, msc->bulk_ep_out->endpoint_address, + phys_buffer, length, 0, USB_TOD_DATA_OUT); + if (error != USB_NO_ERROR) { + return error; + } + cdi_sleep_ms(5); + error = do_packet(usbdev, PACKET_IN, msc->bulk_ep_in->endpoint_address, + pcsw, 0x0D, 0, USB_TOD_STATUS); + 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; +} + +static void get_partitions(struct cdi_storage_device *cdistrg) +{ + void *mbr; + struct part_table_entry *partition; + struct cdi_msd *cdimsd, *base_cdimsd = (struct cdi_msd *)cdistrg; + int i, j = 0; + + mbr = malloc(512); + if (msd_cdi_read(cdistrg, 0, 1, mbr) != USB_NO_ERROR) { + dprintf("MBR konnte nicht eingelesen werden.\n"); + return; + } + 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)) + { + cdimsd = malloc(sizeof(struct cdi_msd)); + if (cdimsd == NULL) { + break; + } + cdimsd->offset = partition[i].start; + 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) + { + free(cdimsd); + break; + } + 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); + cdi_storage_device_init((struct cdi_storage_device *)cdimsd); + cdi_list_push(cdi_driver.drv.devices, cdimsd); + } + } + _dprintf("\n"); +} diff --git a/usb/uhci.c b/usb/uhci.c new file mode 100644 index 0000000..c09075c --- /dev/null +++ b/usb/uhci.c @@ -0,0 +1,339 @@ +/****************************************************************************** + * Copyright (c) 2009 Max Reitz * + * * + * Permission is hereby granted, free of charge, to any person obtaining a * + * copy of this software and associated documentation files (the "Software"), * + * to deal in the Software without restriction, including without limitation * + * the rights to use, copy, modify, merge, publish, distribute, sublicense, * + * and/or sell copies of the Software, and to permit persons to whom the * + * Software is furnished to do so, subject to the following conditions: * + * * + * The above copyright notice and this permission notice shall be included in * + * all copies or substantial portions of the Software. * + * * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * + * DEALINGS IN THE SOFTWARE. * + ******************************************************************************/ + +#include <stdlib.h> +#include <string.h> + +#include "cdi/io.h" +#include "cdi/lists.h" +#include "cdi/misc.h" +#include "cdi/pci.h" + +#include "uhci.h" +#include "usb.h" + +#define DEBUG + +#ifdef DEBUG +#include <stdio.h> +#include <stdarg.h> +#define dprintf(fmt, args...) printf("[uhci] " fmt, ##args) +#define _dprintf(fmt, args...) printf(fmt, ##args) +#else +static int dprintf(const char *fmt, ...) +{ + return 0; +} +#define _dprintf(fmt, args...) dprintf(fmt, ##args) +#endif + +static const char *driver_name = "uhci"; + +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 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); +static void uhci_deinit(struct cdi_device *cdi_hci); +static void uhci_kill(struct cdi_driver *cdi_hcd); + + +struct cdi_driver *init_uhcd() +{ + active_transfers = cdi_list_create(); + cdi_driver.type = CDI_UNKNOWN; + cdi_driver.name = driver_name; + cdi_driver.init_device = &uhci_init; + cdi_driver.remove_device = &uhci_deinit; + cdi_driver.destroy = &uhci_kill; + cdi_driver_init(&cdi_driver); + cdi_driver_register(&cdi_driver); + return &cdi_driver; +} + +static void uhci_kill(struct cdi_driver *cdi_hcd) +{ + //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 +} + +void uhci_init(struct cdi_device *cdi_hci) +{ + struct hci *gen_hci = ((struct cdi_hci *)cdi_hci)->hci; + struct uhci *uhci = (struct uhci *)gen_hci; + struct cdi_pci_resource *res; + int i, size = 0x14; + + //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) + { + size = res->length ? res->length : 0x14; + if (cdi_ioports_alloc(res->start, size) == -1) + { + dprintf("I/O-Ports konnten nicht reserviert werden.\n"); + return; + } + uhci->pbase = res->start; + break; + } + } + 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) + { + dprintf("Frame List konnte nicht allociert werden!\n"); + return; + } + cdi_register_irq(gen_hci->pcidev->irq, &uhci_handler, cdi_hci); + uhci->root_ports = (size - 0x10) >> 1; + 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); + for (i = 0; i < 1024; i++) { + uhci->frame_list[i] = 1; //Invalid + } + dprintf("Resetten...\n"); + //HC zurücksetzen + cdi_outw(uhci->pbase + UHCI_USBCMD, MAXP | HCRESET); + for (i = 0; (cdi_inw(uhci->pbase + UHCI_USBCMD) & HCRESET) && (i < 50); i++) { + cdi_sleep_ms(10); + } + //Reset auf dem USB treiben + cdi_outw(uhci->pbase + UHCI_USBCMD, MAXP | GRESET); + for (i = 0; (cdi_inw(uhci->pbase + UHCI_USBCMD) & GRESET) && (i < 50); i++) { + cdi_sleep_ms(10); + } + //Alle Interrupts senden + 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 + //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); + } + dprintf(" Fertig\n"); + gen_hci->find_devices = &get_devices; + gen_hci->activate_device = &activate_device; + gen_hci->do_packet = &enqueue_request; + gen_hci->get_frame = &get_current_frame; + + enumerate_hci(gen_hci); +} + +static cdi_list_t get_devices(struct hci *gen_hci) +{ + struct uhci *uhci = (struct uhci *)gen_hci; + struct usb_device *dev; + cdi_list_t dlist = cdi_list_create(); + int i; + + 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)) + { + _dprintf("-"); + continue; + } + _dprintf("!"); + dev = malloc(sizeof(struct usb_device)); + dev->hci = gen_hci; + dev->id = 0; + dev->port = i; + dev->low_speed = + (cdi_inw(uhci->pbase + UHCI_RPORTS + 2*i) & RPORT_LOSPD) && 1; + cdi_list_push(dlist, dev); + } + _dprintf("\n"); + return dlist; +} + +static void activate_device(struct hci *gen_hci, struct usb_device *device) +{ + struct uhci *uhci = (struct uhci *)gen_hci; + + 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); + cdi_sleep_ms(20); +} + +static int get_current_frame(struct hci *gen_hci) +{ + return cdi_inw(((struct uhci *)gen_hci)->pbase + UHCI_FRNUM); +} + +static inline int tsl(volatile int *variable) +{ + int rval; + rval = *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) +{ + struct uhci *uhci = (struct uhci *)gen_hci; + struct uhci_td *td; + struct uhci_qh *qh; + uintptr_t ptd, pqh; + struct transfer *addr; + + if (cdi_alloc_phys_mem(sizeof(struct uhci_td), + (void **)&td, (void **)&ptd) == -1) { + return USB_TRIVIAL_ERROR; + } + if (cdi_alloc_phys_mem(sizeof(struct uhci_qh), + (void **)&qh, (void **)&pqh) == -1) { + return USB_TRIVIAL_ERROR; + } + while (tsl(&locked)) + { +#ifndef CDI_STANDALONE + __asm__ __volatile__ ("hlt"); +#endif + } + qh->next = 1; //Invalid + qh->transfer = ptd; + memset(td, 0, sizeof(struct uhci_td)); + td->next = 1; //Invalid + td->active = 1; + td->ioc = 1; + td->data_toggle = datatoggle; + td->low_speed = low_speed; + td->errors = 1; + td->pid = type; + td->device = device; + td->endpoint = endpoint; + td->maxlen = length ? length-1 : 0x7FF; + td->buffer = phys_data; + addr = malloc(sizeof(struct transfer)); + addr->virt = td; + addr->phys = ptd; + 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"); + } +#endif + while (addr->error == 0xFFFF) + { +#ifndef CDI_STANDALONE + __asm__ __volatile__ ("hlt"); +#endif + } + uhci->frame_list[frame] = 1; + locked = 0; + return addr->error; +} + +static void uhci_handler(struct cdi_device *cdi_hci) +{ + struct uhci *uhci = (struct uhci *)((struct cdi_hci *)cdi_hci)->hci; + int status = cdi_inw(uhci->pbase + UHCI_USBSTS), i; + struct transfer *addr; + struct uhci_td *td; + + 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) + { + 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++) + { + td = addr->virt; + if (td->active) { + continue; + } + addr->error = USB_NO_ERROR; + cdi_list_remove(active_transfers, i--); + if (td->stalled_err) + { + dprintf("ENDPOINT STALLED\n"); + addr->error |= USB_STALLED; + } + 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"); + addr->error |= USB_BABBLE; + } + if (td->nak) + { + dprintf("NAK empfangen\n"); + addr->error |= USB_NAK; + } + if (td->crc_time_err) + { + dprintf("CRC-Fehler oder Timeout\n"); + addr->error |= USB_CRC | USB_TIMEOUT; + } + if (td->bitstuff_err) + { + dprintf("Bitstufffehler\n"); + addr->error |= USB_BITSTUFF; + } + //TODO: free(td) - dazu wäre eine CDI-Funktion nützlich + } + } + cdi_outw(uhci->pbase + UHCI_USBSTS, status); +} -- 1.6.0.2