GNUBoot
/
coreboot-kgpe-d16
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

libpayload: usb: Fix spacing issues 

Found by:
find payloads/libpayload/drivers/usb -type f -name "*.[ch]" | xargs \
util/lint/checkpatch.pl --types SPACING -q --fix-inplace -f

Change-Id: Id23e2e573e475c6d795812a4b2df9aeffbcaaaf4
Signed-off-by: Yidi Lin <yidilin@chromium.org>
Reviewed-on: https://review.coreboot.org/c/coreboot/+/66596
Reviewed-by: Yu-Ping Wu <yupingso@google.com>
Tested-by: build bot (Jenkins) <no-reply@coreboot.org>
This commit is contained in:
Yidi Lin 2022-08-10 14:59:18 +08:00 committed by Martin Roth
parent ad6b27e9ef
commit 5ef258b3f6
24 changed files with 623 additions and 623 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
payloads/libpayload/drivers/usb/dwc2.h
View File

@ -17,6 +17,6 @@
#include <usb/usb.h> #include <usb/usb.h>
hci_t *dwc2_init(void *bar); hci_t *dwc2_init(void *bar);
void dwc2_rh_init (usbdev_t *dev); void dwc2_rh_init(usbdev_t *dev);
#endif #endif

32
payloads/libpayload/drivers/usb/ehci.c
View File

@ -119,17 +119,17 @@ static void dump_qh(ehci_qh_t *cur)
} }
#endif #endif
static void ehci_start (hci_t *controller) static void ehci_start(hci_t *controller)
{ {
EHCI_INST(controller)->operation->usbcmd |= HC_OP_RS; EHCI_INST(controller)->operation->usbcmd |= HC_OP_RS;
} }
static void ehci_stop (hci_t *controller) static void ehci_stop(hci_t *controller)
{ {
EHCI_INST(controller)->operation->usbcmd &= ~HC_OP_RS; EHCI_INST(controller)->operation->usbcmd &= ~HC_OP_RS;
} }
static void ehci_reset (hci_t *controller) static void ehci_reset(hci_t *controller)
{ {
short count = 0; short count = 0;
ehci_stop(controller); ehci_stop(controller);
@ -148,7 +148,7 @@ static void ehci_reset (hci_t *controller)
usb_debug("ehci_reset(): reset failed!\n"); usb_debug("ehci_reset(): reset failed!\n");
} }
static void ehci_reinit (hci_t *controller) static void ehci_reinit(hci_t *controller)
{ {
} }
@ -174,7 +174,7 @@ static int ehci_set_periodic_schedule(ehci_t *ehcic, int enable)
return 0; return 0;
} }
static void ehci_shutdown (hci_t *controller) static void ehci_shutdown(hci_t *controller)
{ {
detach_controller(controller); detach_controller(controller);
@ -192,7 +192,7 @@ static void ehci_shutdown (hci_t *controller)
free(controller); free(controller);
} }
enum { EHCI_OUT=0, EHCI_IN=1, EHCI_SETUP=2 }; enum { EHCI_OUT = 0, EHCI_IN = 1, EHCI_SETUP = 2 };
/* returns handled bytes. assumes that the fields it writes are empty on entry */ /* returns handled bytes. assumes that the fields it writes are empty on entry */
static int fill_td(qtd_t *td, void* data, int datalen) static int fill_td(qtd_t *td, void* data, int datalen)
@ -341,7 +341,7 @@ static int ehci_process_async_schedule(
return result; return result;
} }
static int ehci_bulk (endpoint_t *ep, int size, u8 *src, int finalize) static int ehci_bulk(endpoint_t *ep, int size, u8 *src, int finalize)
{ {
int result = 0; int result = 0;
u8 *end = src + size; u8 *end = src + size;
@ -430,7 +430,7 @@ oom:
} }
/* FIXME: Handle control transfers as 3 QHs, so the 2nd stage can be >0x4000 bytes */ /* FIXME: Handle control transfers as 3 QHs, so the 2nd stage can be >0x4000 bytes */
static int ehci_control (usbdev_t *dev, direction_t dir, int drlen, void *setup, static int ehci_control(usbdev_t *dev, direction_t dir, int drlen, void *setup,
int dalen, u8 *src) int dalen, u8 *src)
{ {
u8 *data = src; u8 *data = src;
@ -771,11 +771,11 @@ static u8 *ehci_poll_intr_queue(void *const queue)
} }
hci_t * hci_t *
ehci_init (unsigned long physical_bar) ehci_init(unsigned long physical_bar)
{ {
int i; int i;
hci_t *controller = new_controller (); hci_t *controller = new_controller();
controller->instance = xzalloc(sizeof (ehci_t)); controller->instance = xzalloc(sizeof(ehci_t));
controller->reg_base = (uintptr_t)physical_bar; controller->reg_base = (uintptr_t)physical_bar;
controller->type = EHCI; controller->type = EHCI;
controller->start = ehci_start; controller->start = ehci_start;
@ -791,7 +791,7 @@ ehci_init (unsigned long physical_bar)
controller->create_intr_queue = ehci_create_intr_queue; controller->create_intr_queue = ehci_create_intr_queue;
controller->destroy_intr_queue = ehci_destroy_intr_queue; controller->destroy_intr_queue = ehci_destroy_intr_queue;
controller->poll_intr_queue = ehci_poll_intr_queue; controller->poll_intr_queue = ehci_poll_intr_queue;
init_device_entry (controller, 0); init_device_entry(controller, 0);
EHCI_INST(controller)->capabilities = phys_to_virt(physical_bar); EHCI_INST(controller)->capabilities = phys_to_virt(physical_bar);
EHCI_INST(controller)->operation = (hc_op_t *)(phys_to_virt(physical_bar) + EHCI_INST(controller)->capabilities->caplength); EHCI_INST(controller)->operation = (hc_op_t *)(phys_to_virt(physical_bar) + EHCI_INST(controller)->capabilities->caplength);
@ -848,23 +848,23 @@ ehci_init (unsigned long physical_bar)
controller->devices[0]->controller = controller; controller->devices[0]->controller = controller;
controller->devices[0]->init = ehci_rh_init; controller->devices[0]->init = ehci_rh_init;
controller->devices[0]->init (controller->devices[0]); controller->devices[0]->init(controller->devices[0]);
return controller; return controller;
} }
#if CONFIG(LP_USB_PCI) #if CONFIG(LP_USB_PCI)
hci_t * hci_t *
ehci_pci_init (pcidev_t addr) ehci_pci_init(pcidev_t addr)
{ {
hci_t *controller; hci_t *controller;
u32 reg_base; u32 reg_base;
u16 pci_command = pci_read_config16(addr, PCI_COMMAND); u16 pci_command = pci_read_config16(addr, PCI_COMMAND);
pci_command = (pci_command | PCI_COMMAND_MEMORY) & ~PCI_COMMAND_IO ; pci_command = (pci_command | PCI_COMMAND_MEMORY) & ~PCI_COMMAND_IO;
pci_write_config16(addr, PCI_COMMAND, pci_command); pci_write_config16(addr, PCI_COMMAND, pci_command);
reg_base = pci_read_config32 (addr, USBBASE); reg_base = pci_read_config32(addr, USBBASE);
/* default value for frame length adjust */ /* default value for frame length adjust */
pci_write_config8(addr, FLADJ, FLADJ_framelength(60000)); pci_write_config8(addr, FLADJ, FLADJ_framelength(60000));

6
payloads/libpayload/drivers/usb/ehci.h
View File

@ -32,9 +32,9 @@
#include <pci.h> #include <pci.h>
#include <usb/usb.h> #include <usb/usb.h>
hci_t *ehci_pci_init (pcidev_t addr); hci_t *ehci_pci_init(pcidev_t addr);
hci_t *ehci_init (unsigned long physical_bar); hci_t *ehci_init(unsigned long physical_bar);
void ehci_rh_init (usbdev_t *dev); void ehci_rh_init(usbdev_t *dev);
#endif #endif

30
payloads/libpayload/drivers/usb/ehci_rh.c
View File

@ -46,7 +46,7 @@ typedef struct {
#define RH_INST(dev) ((rh_inst_t*)(dev)->data) #define RH_INST(dev) ((rh_inst_t*)(dev)->data)
static void static void
ehci_rh_destroy (usbdev_t *dev) ehci_rh_destroy(usbdev_t *dev)
{ {
int port; int port;
@ -59,12 +59,12 @@ ehci_rh_destroy (usbdev_t *dev)
} }
} }
free (RH_INST(dev)->devices); free(RH_INST(dev)->devices);
free (RH_INST(dev)); free(RH_INST(dev));
} }
static void static void
ehci_rh_hand_over_port (usbdev_t *dev, int port) ehci_rh_hand_over_port(usbdev_t *dev, int port)
{ {
usb_debug("giving up port %x, it's USB1\n", port+1); usb_debug("giving up port %x, it's USB1\n", port+1);
@ -89,14 +89,14 @@ ehci_rh_hand_over_port (usbdev_t *dev, int port)
} }
static void static void
ehci_rh_scanport (usbdev_t *dev, int port) ehci_rh_scanport(usbdev_t *dev, int port)
{ {
usb_speed port_speed; usb_speed port_speed;
if (RH_INST(dev)->devices[port]!=-1) { if (RH_INST(dev)->devices[port] != -1) {
usb_debug("Unregister device at port %x\n", port+1); usb_debug("Unregister device at port %x\n", port+1);
usb_detach_device(dev->controller, RH_INST(dev)->devices[port]); usb_detach_device(dev->controller, RH_INST(dev)->devices[port]);
RH_INST(dev)->devices[port]=-1; RH_INST(dev)->devices[port] = -1;
} }
/* device connected, handle */ /* device connected, handle */
if (RH_INST(dev)->ports[port] & P_CURR_CONN_STATUS) { if (RH_INST(dev)->ports[port] & P_CURR_CONN_STATUS) {
@ -153,10 +153,10 @@ ehci_rh_scanport (usbdev_t *dev, int port)
} }
static int static int
ehci_rh_report_port_changes (usbdev_t *dev) ehci_rh_report_port_changes(usbdev_t *dev)
{ {
int i; int i;
for (i=0; i<RH_INST(dev)->n_ports; i++) { for (i = 0; i < RH_INST(dev)->n_ports; i++) {
if (RH_INST(dev)->ports[i] & P_CONN_STATUS_CHANGE) if (RH_INST(dev)->ports[i] & P_CONN_STATUS_CHANGE)
return i; return i;
} }
@ -164,15 +164,15 @@ ehci_rh_report_port_changes (usbdev_t *dev)
} }
static void static void
ehci_rh_poll (usbdev_t *dev) ehci_rh_poll(usbdev_t *dev)
{ {
int port; int port;
while ((port = ehci_rh_report_port_changes (dev)) != -1) while ((port = ehci_rh_report_port_changes(dev)) != -1)
ehci_rh_scanport (dev, port); ehci_rh_scanport(dev, port);
} }
void void
ehci_rh_init (usbdev_t *dev) ehci_rh_init(usbdev_t *dev)
{ {
int i; int i;
dev->destroy = ehci_rh_destroy; dev->destroy = ehci_rh_destroy;
@ -192,7 +192,7 @@ ehci_rh_init (usbdev_t *dev)
& HCS_PORT_POWER_CONTROL) { & HCS_PORT_POWER_CONTROL) {
usb_debug("host controller has port power control, " usb_debug("host controller has port power control, "
"giving power to all ports.\n"); "giving power to all ports.\n");
for (i=0; i < RH_INST(dev)->n_ports; i++) for (i = 0; i < RH_INST(dev)->n_ports; i++)
RH_INST(dev)->ports[i] |= P_PP; RH_INST(dev)->ports[i] |= P_PP;
} }
mdelay(20); // ehci spec 2.3.9 mdelay(20); // ehci spec 2.3.9
@ -201,7 +201,7 @@ ehci_rh_init (usbdev_t *dev)
dev->address = 0; dev->address = 0;
dev->hub = -1; dev->hub = -1;
dev->port = -1; dev->port = -1;
for (i=0; i < RH_INST(dev)->n_ports; i++) { for (i = 0; i < RH_INST(dev)->n_ports; i++) {
RH_INST(dev)->devices[i] = -1; RH_INST(dev)->devices[i] = -1;
ehci_rh_scanport(dev, i); ehci_rh_scanport(dev, i);
} }

2
payloads/libpayload/drivers/usb/generic_hub.h
View File

@ -45,7 +45,7 @@ typedef struct generic_hub_ops {
/* returns 1 if the port is enabled */ /* returns 1 if the port is enabled */
int (*port_enabled)(usbdev_t *, int port); int (*port_enabled)(usbdev_t *, int port);
/* returns speed if port is enabled, negative value if not */ /* returns speed if port is enabled, negative value if not */
usb_speed (*port_speed)(usbdev_t *, int port); usb_speed(*port_speed)(usbdev_t *, int port);
/* enables (powers up) a port (optional) */ /* enables (powers up) a port (optional) */
int (*enable_port)(usbdev_t *, int port); int (*enable_port)(usbdev_t *, int port);

118
payloads/libpayload/drivers/usb/ohci.c
View File

@ -34,21 +34,21 @@
#include "ohci_private.h" #include "ohci_private.h"
#include "ohci.h" #include "ohci.h"
static void ohci_start (hci_t *controller); static void ohci_start(hci_t *controller);
static void ohci_stop (hci_t *controller); static void ohci_stop(hci_t *controller);
static void ohci_reset (hci_t *controller); static void ohci_reset(hci_t *controller);
static void ohci_shutdown (hci_t *controller); static void ohci_shutdown(hci_t *controller);
static int ohci_bulk (endpoint_t *ep, int size, u8 *data, int finalize); static int ohci_bulk(endpoint_t *ep, int size, u8 *data, int finalize);
static int ohci_control (usbdev_t *dev, direction_t dir, int drlen, void *devreq, static int ohci_control(usbdev_t *dev, direction_t dir, int drlen, void *devreq,
int dalen, u8 *data); int dalen, u8 *data);
static void* ohci_create_intr_queue (endpoint_t *ep, int reqsize, int reqcount, int reqtiming); static void* ohci_create_intr_queue(endpoint_t *ep, int reqsize, int reqcount, int reqtiming);
static void ohci_destroy_intr_queue (endpoint_t *ep, void *queue); static void ohci_destroy_intr_queue(endpoint_t *ep, void *queue);
static u8* ohci_poll_intr_queue (void *queue); static u8* ohci_poll_intr_queue(void *queue);
static int ohci_process_done_queue(ohci_t *ohci, int spew_debug); static int ohci_process_done_queue(ohci_t *ohci, int spew_debug);
#ifdef USB_DEBUG #ifdef USB_DEBUG
static void static void
dump_td (td_t *cur) dump_td(td_t *cur)
{ {
usb_debug("+---------------------------------------------------+\n"); usb_debug("+---------------------------------------------------+\n");
if (((cur->config & (3UL << 19)) >> 19) == 0) if (((cur->config & (3UL << 19)) >> 19) == 0)
@ -81,7 +81,7 @@ dump_td (td_t *cur)
} }
static void static void
dump_ed (ed_t *cur) dump_ed(ed_t *cur)
{ {
td_t *tmp_td = NULL; td_t *tmp_td = NULL;
usb_debug("+===================================================+\n"); usb_debug("+===================================================+\n");
@ -120,7 +120,7 @@ dump_ed (ed_t *cur)
#endif #endif
static void static void
ohci_reset (hci_t *controller) ohci_reset(hci_t *controller)
{ {
if (controller == NULL) if (controller == NULL)
return; return;
@ -132,7 +132,7 @@ ohci_reset (hci_t *controller)
} }
static void static void
ohci_reinit (hci_t *controller) ohci_reinit(hci_t *controller)
{ {
} }
@ -167,12 +167,12 @@ static const char *direction[] = {
#endif #endif
hci_t * hci_t *
ohci_init (unsigned long physical_bar) ohci_init(unsigned long physical_bar)
{ {
int i; int i;
hci_t *controller = new_controller (); hci_t *controller = new_controller();
controller->instance = xzalloc(sizeof (ohci_t)); controller->instance = xzalloc(sizeof(ohci_t));
controller->reg_base = (uintptr_t)physical_bar; controller->reg_base = (uintptr_t)physical_bar;
controller->type = OHCI; controller->type = OHCI;
controller->start = ohci_start; controller->start = ohci_start;
@ -188,33 +188,33 @@ ohci_init (unsigned long physical_bar)
controller->create_intr_queue = ohci_create_intr_queue; controller->create_intr_queue = ohci_create_intr_queue;
controller->destroy_intr_queue = ohci_destroy_intr_queue; controller->destroy_intr_queue = ohci_destroy_intr_queue;
controller->poll_intr_queue = ohci_poll_intr_queue; controller->poll_intr_queue = ohci_poll_intr_queue;
init_device_entry (controller, 0); init_device_entry(controller, 0);
OHCI_INST (controller)->roothub = controller->devices[0]; OHCI_INST(controller)->roothub = controller->devices[0];
OHCI_INST (controller)->opreg = (opreg_t*)phys_to_virt(physical_bar); OHCI_INST(controller)->opreg = (opreg_t*)phys_to_virt(physical_bar);
usb_debug("OHCI Version %x.%x\n", (OHCI_INST (controller)->opreg->HcRevision >> 4) & 0xf, OHCI_INST (controller)->opreg->HcRevision & 0xf); usb_debug("OHCI Version %x.%x\n", (OHCI_INST(controller)->opreg->HcRevision >> 4) & 0xf, OHCI_INST(controller)->opreg->HcRevision & 0xf);
if ((OHCI_INST (controller)->opreg->HcControl & HostControllerFunctionalStateMask) == USBReset) { if ((OHCI_INST(controller)->opreg->HcControl & HostControllerFunctionalStateMask) == USBReset) {
/* cold boot */ /* cold boot */
OHCI_INST (controller)->opreg->HcControl &= ~RemoteWakeupConnected; OHCI_INST(controller)->opreg->HcControl &= ~RemoteWakeupConnected;
OHCI_INST (controller)->opreg->HcFmInterval = (11999 * FrameInterval) | ((((11999 - 210)*6)/7) * FSLargestDataPacket); OHCI_INST(controller)->opreg->HcFmInterval = (11999 * FrameInterval) | ((((11999 - 210)*6)/7) * FSLargestDataPacket);
/* TODO: right value for PowerOnToPowerGoodTime ? */ /* TODO: right value for PowerOnToPowerGoodTime ? */
OHCI_INST (controller)->opreg->HcRhDescriptorA = NoPowerSwitching | NoOverCurrentProtection | (10 * PowerOnToPowerGoodTime); OHCI_INST(controller)->opreg->HcRhDescriptorA = NoPowerSwitching | NoOverCurrentProtection | (10 * PowerOnToPowerGoodTime);
OHCI_INST (controller)->opreg->HcRhDescriptorB = (0 * DeviceRemovable); OHCI_INST(controller)->opreg->HcRhDescriptorB = (0 * DeviceRemovable);
udelay(100); /* TODO: reset asserting according to USB spec */ udelay(100); /* TODO: reset asserting according to USB spec */
} else if ((OHCI_INST (controller)->opreg->HcControl & HostControllerFunctionalStateMask) != USBOperational) { } else if ((OHCI_INST(controller)->opreg->HcControl & HostControllerFunctionalStateMask) != USBOperational) {
OHCI_INST (controller)->opreg->HcControl = (OHCI_INST (controller)->opreg->HcControl & ~HostControllerFunctionalStateMask) | USBResume; OHCI_INST(controller)->opreg->HcControl = (OHCI_INST(controller)->opreg->HcControl & ~HostControllerFunctionalStateMask) | USBResume;
udelay(100); /* TODO: resume time according to USB spec */ udelay(100); /* TODO: resume time according to USB spec */
} }
int interval = OHCI_INST (controller)->opreg->HcFmInterval; int interval = OHCI_INST(controller)->opreg->HcFmInterval;
OHCI_INST (controller)->opreg->HcCommandStatus = HostControllerReset; OHCI_INST(controller)->opreg->HcCommandStatus = HostControllerReset;
udelay (10); /* at most 10us for reset to complete. State must be set to Operational within 2ms (5.1.1.4) */ udelay(10); /* at most 10us for reset to complete. State must be set to Operational within 2ms (5.1.1.4) */
OHCI_INST (controller)->opreg->HcFmInterval = interval; OHCI_INST(controller)->opreg->HcFmInterval = interval;
OHCI_INST (controller)->hcca = dma_memalign(256, 256); OHCI_INST(controller)->hcca = dma_memalign(256, 256);
if (!OHCI_INST(controller)->hcca) if (!OHCI_INST(controller)->hcca)
fatal("Not enough DMA memory for OHCI HCCA.\n"); fatal("Not enough DMA memory for OHCI HCCA.\n");
memset((void*)OHCI_INST (controller)->hcca, 0, 256); memset((void*)OHCI_INST(controller)->hcca, 0, 256);
if (dma_initialized()) { if (dma_initialized()) {
OHCI_INST(controller)->dma_buffer = dma_memalign(4096, DMA_SIZE); OHCI_INST(controller)->dma_buffer = dma_memalign(4096, DMA_SIZE);
@ -230,66 +230,66 @@ ohci_init (unsigned long physical_bar)
memset((void *)periodic_ed, 0, sizeof(*periodic_ed)); memset((void *)periodic_ed, 0, sizeof(*periodic_ed));
for (i = 0; i < 32; ++i) for (i = 0; i < 32; ++i)
intr_table[i] = virt_to_phys(periodic_ed); intr_table[i] = virt_to_phys(periodic_ed);
OHCI_INST (controller)->periodic_ed = periodic_ed; OHCI_INST(controller)->periodic_ed = periodic_ed;
OHCI_INST (controller)->opreg->HcHCCA = virt_to_phys(OHCI_INST (controller)->hcca); OHCI_INST(controller)->opreg->HcHCCA = virt_to_phys(OHCI_INST(controller)->hcca);
/* Make sure periodic schedule is enabled. */ /* Make sure periodic schedule is enabled. */
OHCI_INST (controller)->opreg->HcControl |= PeriodicListEnable; OHCI_INST(controller)->opreg->HcControl |= PeriodicListEnable;
OHCI_INST (controller)->opreg->HcControl &= ~IsochronousEnable; // unused by this driver OHCI_INST(controller)->opreg->HcControl &= ~IsochronousEnable; // unused by this driver
// disable everything, contrary to what OHCI spec says in 5.1.1.4, as we don't need IRQs // disable everything, contrary to what OHCI spec says in 5.1.1.4, as we don't need IRQs
OHCI_INST (controller)->opreg->HcInterruptEnable = 1 << 31; OHCI_INST(controller)->opreg->HcInterruptEnable = 1 << 31;
OHCI_INST (controller)->opreg->HcInterruptDisable = ~(1 << 31); OHCI_INST(controller)->opreg->HcInterruptDisable = ~(1 << 31);
OHCI_INST (controller)->opreg->HcInterruptStatus = ~0; OHCI_INST(controller)->opreg->HcInterruptStatus = ~0;
OHCI_INST (controller)->opreg->HcPeriodicStart = (((OHCI_INST (controller)->opreg->HcFmInterval & FrameIntervalMask) / 10) * 9); OHCI_INST(controller)->opreg->HcPeriodicStart = (((OHCI_INST(controller)->opreg->HcFmInterval & FrameIntervalMask) / 10) * 9);
OHCI_INST (controller)->opreg->HcControl = (OHCI_INST (controller)->opreg->HcControl & ~HostControllerFunctionalStateMask) | USBOperational; OHCI_INST(controller)->opreg->HcControl = (OHCI_INST(controller)->opreg->HcControl & ~HostControllerFunctionalStateMask) | USBOperational;
mdelay(100); mdelay(100);
controller->devices[0]->controller = controller; controller->devices[0]->controller = controller;
controller->devices[0]->init = ohci_rh_init; controller->devices[0]->init = ohci_rh_init;
controller->devices[0]->init (controller->devices[0]); controller->devices[0]->init(controller->devices[0]);
return controller; return controller;
} }
#if CONFIG(LP_USB_PCI) #if CONFIG(LP_USB_PCI)
hci_t * hci_t *
ohci_pci_init (pcidev_t addr) ohci_pci_init(pcidev_t addr)
{ {
u32 reg_base; u32 reg_base;
/* regarding OHCI spec, Appendix A, BAR_OHCI register description, Table A-4 /* regarding OHCI spec, Appendix A, BAR_OHCI register description, Table A-4
* BASE ADDRESS only [31-12] bits. All other usually 0, but not all. * BASE ADDRESS only [31-12] bits. All other usually 0, but not all.
* OHCI mandates MMIO, so bit 0 is clear */ * OHCI mandates MMIO, so bit 0 is clear */
reg_base = pci_read_config32 (addr, 0x10) & 0xfffff000; reg_base = pci_read_config32(addr, 0x10) & 0xfffff000;
return ohci_init((unsigned long)reg_base); return ohci_init((unsigned long)reg_base);
} }
#endif #endif
static void static void
ohci_shutdown (hci_t *controller) ohci_shutdown(hci_t *controller)
{ {
if (controller == 0) if (controller == 0)
return; return;
detach_controller (controller); detach_controller(controller);
ohci_stop(controller); ohci_stop(controller);
ohci_reset(controller); ohci_reset(controller);
free (OHCI_INST (controller)->hcca); free(OHCI_INST(controller)->hcca);
free ((void *)OHCI_INST (controller)->periodic_ed); free((void *)OHCI_INST(controller)->periodic_ed);
free (OHCI_INST (controller)); free(OHCI_INST(controller));
free (controller); free(controller);
} }
static void static void
ohci_start (hci_t *controller) ohci_start(hci_t *controller)
{ {
OHCI_INST (controller)->opreg->HcControl |= PeriodicListEnable; OHCI_INST(controller)->opreg->HcControl |= PeriodicListEnable;
} }
static void static void
ohci_stop (hci_t *controller) ohci_stop(hci_t *controller)
{ {
OHCI_INST (controller)->opreg->HcControl &= ~PeriodicListEnable; OHCI_INST(controller)->opreg->HcControl &= ~PeriodicListEnable;
} }
#define OHCI_SLEEP_TIME_US 1000 #define OHCI_SLEEP_TIME_US 1000
@ -330,7 +330,7 @@ wait_for_ed(usbdev_t *dev, ed_t *head, int pages)
} }
static void static void
ohci_free_ed (ed_t *const head) ohci_free_ed(ed_t *const head)
{ {
/* In case the transfer canceled, we have to free unprocessed TDs. */ /* In case the transfer canceled, we have to free unprocessed TDs. */
while ((head->head_pointer & ~0x3) != head->tail_pointer) { while ((head->head_pointer & ~0x3) != head->tail_pointer) {
@ -351,7 +351,7 @@ ohci_free_ed (ed_t *const head)
} }
static int static int
ohci_control (usbdev_t *dev, direction_t dir, int drlen, void *setup, int dalen, ohci_control(usbdev_t *dev, direction_t dir, int drlen, void *setup, int dalen,
unsigned char *src) unsigned char *src)
{ {
u8 *data = src; u8 *data = src;
@ -501,7 +501,7 @@ ohci_control (usbdev_t *dev, direction_t dir, int drlen, void *setup, int dalen,
/* finalize == 1: if data is of packet aligned size, add a zero length packet */ /* finalize == 1: if data is of packet aligned size, add a zero length packet */
static int static int
ohci_bulk (endpoint_t *ep, int dalen, u8 *src, int finalize) ohci_bulk(endpoint_t *ep, int dalen, u8 *src, int finalize)
{ {
int i; int i;
td_t *cur, *next; td_t *cur, *next;
@ -763,7 +763,7 @@ ohci_destroy_intr_queue(endpoint_t *const ep, void *const q_)
/* Remove interrupt queue from periodic table. */ /* Remove interrupt queue from periodic table. */
ohci_t *const ohci = OHCI_INST(ep->dev->controller); ohci_t *const ohci = OHCI_INST(ep->dev->controller);
u32 *const intr_table = ohci->hcca->HccaInterruptTable; u32 *const intr_table = ohci->hcca->HccaInterruptTable;
for (i=0; i < 32; ++i) { for (i = 0; i < 32; ++i) {
if (intr_table[i] == virt_to_phys(intrq)) if (intr_table[i] == virt_to_phys(intrq))
intr_table[i] = virt_to_phys(ohci->periodic_ed); intr_table[i] = virt_to_phys(ohci->periodic_ed);
} }

6
payloads/libpayload/drivers/usb/ohci.h
View File

@ -32,9 +32,9 @@
#include <pci.h> #include <pci.h>
#include <usb/usb.h> #include <usb/usb.h>
hci_t *ohci_pci_init (pcidev_t addr); hci_t *ohci_pci_init(pcidev_t addr);
hci_t *ohci_init (unsigned long physical_bar); hci_t *ohci_init(unsigned long physical_bar);
void ohci_rh_init (usbdev_t *dev); void ohci_rh_init(usbdev_t *dev);
#endif #endif

2
payloads/libpayload/drivers/usb/ohci_private.h
View File

@ -262,6 +262,6 @@
void *dma_buffer; void *dma_buffer;
} ohci_t; } ohci_t;
typedef enum { OHCI_SETUP=0, OHCI_OUT=1, OHCI_IN=2, OHCI_FROM_TD=3 } ohci_pid_t; typedef enum { OHCI_SETUP = 0, OHCI_OUT = 1, OHCI_IN = 2, OHCI_FROM_TD = 3 } ohci_pid_t;
#endif #endif

76
payloads/libpayload/drivers/usb/ohci_rh.c
View File

@ -40,7 +40,7 @@ typedef struct {
#define RH_INST(dev) ((rh_inst_t*)(dev)->data) #define RH_INST(dev) ((rh_inst_t*)(dev)->data)
static void static void
ohci_rh_enable_port (usbdev_t *dev, int port) ohci_rh_enable_port(usbdev_t *dev, int port)
{ {
/* Reset RH port should hold 50ms with pulses of at least 10ms and /* Reset RH port should hold 50ms with pulses of at least 10ms and
* gaps of at most 3ms (usb20 spec 7.1.7.5). * gaps of at most 3ms (usb20 spec 7.1.7.5).
@ -54,15 +54,15 @@ ohci_rh_enable_port (usbdev_t *dev, int port)
return; return;
/* start reset */ /* start reset */
OHCI_INST (dev->controller)->opreg->HcRhPortStatus[port] = OHCI_INST(dev->controller)->opreg->HcRhPortStatus[port] =
SetPortReset; SetPortReset;
int timeout = 200; /* timeout after 200 * 500us == 100ms */ int timeout = 200; /* timeout after 200 * 500us == 100ms */
while ((OHCI_INST (dev->controller)->opreg->HcRhPortStatus[port] while ((OHCI_INST(dev->controller)->opreg->HcRhPortStatus[port]
& PortResetStatus) & PortResetStatus)
&& timeout--) { && timeout--) {
udelay(500); total_delay--; udelay(500); total_delay--;
} }
if (OHCI_INST (dev->controller)->opreg->HcRhPortStatus[port] if (OHCI_INST(dev->controller)->opreg->HcRhPortStatus[port]
& PortResetStatus) { & PortResetStatus) {
usb_debug("Warning: root-hub port reset timed out.\n"); usb_debug("Warning: root-hub port reset timed out.\n");
break; break;
@ -72,24 +72,24 @@ ohci_rh_enable_port (usbdev_t *dev, int port)
"should be at least 10ms.\n", "should be at least 10ms.\n",
(200-timeout)/2); (200-timeout)/2);
/* clear reset status change */ /* clear reset status change */
OHCI_INST (dev->controller)->opreg->HcRhPortStatus[port] = OHCI_INST(dev->controller)->opreg->HcRhPortStatus[port] =
PortResetStatusChange; PortResetStatusChange;
usb_debug ("rh port reset finished after %dms.\n", (200-timeout)/2); usb_debug("rh port reset finished after %dms.\n", (200-timeout)/2);
} }
} }
/* disable root hub */ /* disable root hub */
static void static void
ohci_rh_disable_port (usbdev_t *dev, int port) ohci_rh_disable_port(usbdev_t *dev, int port)
{ {
if (RH_INST (dev)->port[port] != -1) { if (RH_INST(dev)->port[port] != -1) {
usb_detach_device(dev->controller, RH_INST (dev)->port[port]); usb_detach_device(dev->controller, RH_INST(dev)->port[port]);
RH_INST (dev)->port[port] = -1; RH_INST(dev)->port[port] = -1;
} }
OHCI_INST (dev->controller)->opreg->HcRhPortStatus[port] = ClearPortEnable; // disable port OHCI_INST(dev->controller)->opreg->HcRhPortStatus[port] = ClearPortEnable; // disable port
int timeout = 50; /* timeout after 50 * 100us == 5ms */ int timeout = 50; /* timeout after 50 * 100us == 5ms */
while ((OHCI_INST (dev->controller)->opreg->HcRhPortStatus[port] while ((OHCI_INST(dev->controller)->opreg->HcRhPortStatus[port]
& PortEnableStatus) & PortEnableStatus)
&& timeout--) { && timeout--) {
udelay(100); udelay(100);
@ -97,7 +97,7 @@ ohci_rh_disable_port (usbdev_t *dev, int port)
} }
static void static void
ohci_rh_scanport (usbdev_t *dev, int port) ohci_rh_scanport(usbdev_t *dev, int port)
{ {
if (port >= RH_INST(dev)->numports) { if (port >= RH_INST(dev)->numports) {
usb_debug("Invalid port %d\n", port); usb_debug("Invalid port %d\n", port);
@ -105,9 +105,9 @@ ohci_rh_scanport (usbdev_t *dev, int port)
} }
/* device registered, and device change logged, so something must have happened */ /* device registered, and device change logged, so something must have happened */
if (RH_INST (dev)->port[port] != -1) { if (RH_INST(dev)->port[port] != -1) {
usb_detach_device(dev->controller, RH_INST (dev)->port[port]); usb_detach_device(dev->controller, RH_INST(dev)->port[port]);
RH_INST (dev)->port[port] = -1; RH_INST(dev)->port[port] = -1;
} }
/* no device attached /* no device attached
@ -115,24 +115,24 @@ ohci_rh_scanport (usbdev_t *dev, int port)
if (!(OHCI_INST(dev->controller)->opreg->HcRhPortStatus[port] & CurrentConnectStatus)) if (!(OHCI_INST(dev->controller)->opreg->HcRhPortStatus[port] & CurrentConnectStatus))
return; return;
OHCI_INST (dev->controller)->opreg->HcRhPortStatus[port] = ConnectStatusChange; // clear port state change OHCI_INST(dev->controller)->opreg->HcRhPortStatus[port] = ConnectStatusChange; // clear port state change
ohci_rh_enable_port (dev, port); ohci_rh_enable_port(dev, port);
mdelay(100); // wait for signal to stabilize mdelay(100); // wait for signal to stabilize
if (!(OHCI_INST(dev->controller)->opreg->HcRhPortStatus[port] & PortEnableStatus)) { if (!(OHCI_INST(dev->controller)->opreg->HcRhPortStatus[port] & PortEnableStatus)) {
usb_debug ("port enable failed\n"); usb_debug("port enable failed\n");
return; return;
} }
usb_speed speed = (OHCI_INST(dev->controller)->opreg->HcRhPortStatus[port] & LowSpeedDeviceAttached) != 0; usb_speed speed = (OHCI_INST(dev->controller)->opreg->HcRhPortStatus[port] & LowSpeedDeviceAttached) != 0;
RH_INST (dev)->port[port] = usb_attach_device(dev->controller, dev->address, port, speed); RH_INST(dev)->port[port] = usb_attach_device(dev->controller, dev->address, port, speed);
} }
static int static int
ohci_rh_report_port_changes (usbdev_t *dev) ohci_rh_report_port_changes(usbdev_t *dev)
{ {
ohci_t *const ohcic = OHCI_INST (dev->controller); ohci_t *const ohcic = OHCI_INST(dev->controller);
int i; int i;
@ -150,18 +150,18 @@ ohci_rh_report_port_changes (usbdev_t *dev)
} }
static void static void
ohci_rh_destroy (usbdev_t *dev) ohci_rh_destroy(usbdev_t *dev)
{ {
int i; int i;
for (i = 0; i < RH_INST (dev)->numports; i++) for (i = 0; i < RH_INST(dev)->numports; i++)
ohci_rh_disable_port (dev, i); ohci_rh_disable_port(dev, i);
free (RH_INST (dev)); free(RH_INST(dev));
} }
static void static void
ohci_rh_poll (usbdev_t *dev) ohci_rh_poll(usbdev_t *dev)
{ {
ohci_t *const ohcic = OHCI_INST (dev->controller); ohci_t *const ohcic = OHCI_INST(dev->controller);
int port; int port;
@ -172,26 +172,26 @@ ohci_rh_poll (usbdev_t *dev)
usb_debug("root hub status change\n"); usb_debug("root hub status change\n");
/* Scan ports with changed connection status. */ /* Scan ports with changed connection status. */
while ((port = ohci_rh_report_port_changes (dev)) != -1) while ((port = ohci_rh_report_port_changes(dev)) != -1)
ohci_rh_scanport (dev, port); ohci_rh_scanport(dev, port);
} }
void void
ohci_rh_init (usbdev_t *dev) ohci_rh_init(usbdev_t *dev)
{ {
int i; int i;
dev->destroy = ohci_rh_destroy; dev->destroy = ohci_rh_destroy;
dev->poll = ohci_rh_poll; dev->poll = ohci_rh_poll;
dev->data = xmalloc (sizeof (rh_inst_t)); dev->data = xmalloc(sizeof(rh_inst_t));
RH_INST (dev)->numports = OHCI_INST (dev->controller)->opreg->HcRhDescriptorA & NumberDownstreamPortsMask; RH_INST(dev)->numports = OHCI_INST(dev->controller)->opreg->HcRhDescriptorA & NumberDownstreamPortsMask;
RH_INST (dev)->port = xmalloc(sizeof(int) * RH_INST (dev)->numports); RH_INST(dev)->port = xmalloc(sizeof(int) * RH_INST(dev)->numports);
usb_debug("%d ports registered\n", RH_INST (dev)->numports); usb_debug("%d ports registered\n", RH_INST(dev)->numports);
for (i = 0; i < RH_INST (dev)->numports; i++) { for (i = 0; i < RH_INST(dev)->numports; i++) {
ohci_rh_enable_port (dev, i); ohci_rh_enable_port(dev, i);
RH_INST (dev)->port[i] = -1; RH_INST(dev)->port[i] = -1;
} }
/* we can set them here because a root hub _really_ shouldn't /* we can set them here because a root hub _really_ shouldn't

284
payloads/libpayload/drivers/usb/uhci.c
View File

@ -34,30 +34,30 @@
#include "uhci.h" #include "uhci.h"
#include "uhci_private.h" #include "uhci_private.h"
static void uhci_start (hci_t *controller); static void uhci_start(hci_t *controller);
static void uhci_stop (hci_t *controller); static void uhci_stop(hci_t *controller);
static void uhci_reset (hci_t *controller); static void uhci_reset(hci_t *controller);
static void uhci_shutdown (hci_t *controller); static void uhci_shutdown(hci_t *controller);
static int uhci_bulk (endpoint_t *ep, int size, u8 *data, int finalize); static int uhci_bulk(endpoint_t *ep, int size, u8 *data, int finalize);
static int uhci_control (usbdev_t *dev, direction_t dir, int drlen, void *devreq, static int uhci_control(usbdev_t *dev, direction_t dir, int drlen, void *devreq,
int dalen, u8 *data); int dalen, u8 *data);
static void* uhci_create_intr_queue (endpoint_t *ep, int reqsize, int reqcount, int reqtiming); static void* uhci_create_intr_queue(endpoint_t *ep, int reqsize, int reqcount, int reqtiming);
static void uhci_destroy_intr_queue (endpoint_t *ep, void *queue); static void uhci_destroy_intr_queue(endpoint_t *ep, void *queue);
static u8* uhci_poll_intr_queue (void *queue); static u8* uhci_poll_intr_queue(void *queue);
#if 0 #if 0
/* dump uhci */ /* dump uhci */
static void static void
uhci_dump (hci_t *controller) uhci_dump(hci_t *controller)
{ {
usb_debug ("dump:\nUSBCMD: %x\n", uhci_reg_read16 (controller, USBCMD)); usb_debug("dump:\nUSBCMD: %x\n", uhci_reg_read16(controller, USBCMD));
usb_debug ("USBSTS: %x\n", uhci_reg_read16 (controller, USBSTS)); usb_debug("USBSTS: %x\n", uhci_reg_read16(controller, USBSTS));
usb_debug ("USBINTR: %x\n", uhci_reg_read16 (controller, USBINTR)); usb_debug("USBINTR: %x\n", uhci_reg_read16(controller, USBINTR));
usb_debug ("FRNUM: %x\n", uhci_reg_read16 (controller, FRNUM)); usb_debug("FRNUM: %x\n", uhci_reg_read16(controller, FRNUM));
usb_debug ("FLBASEADD: %x\n", uhci_reg_read32 (controller, FLBASEADD)); usb_debug("FLBASEADD: %x\n", uhci_reg_read32(controller, FLBASEADD));
usb_debug ("SOFMOD: %x\n", uhci_reg_read8 (controller, SOFMOD)); usb_debug("SOFMOD: %x\n", uhci_reg_read8(controller, SOFMOD));
usb_debug ("PORTSC1: %x\n", uhci_reg_read16 (controller, PORTSC1)); usb_debug("PORTSC1: %x\n", uhci_reg_read16(controller, PORTSC1));
usb_debug ("PORTSC2: %x\n", uhci_reg_read16 (controller, PORTSC2)); usb_debug("PORTSC2: %x\n", uhci_reg_read16(controller, PORTSC2));
} }
#endif #endif
@ -109,52 +109,52 @@ static void td_dump(td_t *td)
} }
static void static void
uhci_reset (hci_t *controller) uhci_reset(hci_t *controller)
{ {
/* reset */ /* reset */
uhci_reg_write16 (controller, USBCMD, 4); /* Global Reset */ uhci_reg_write16(controller, USBCMD, 4); /* Global Reset */
mdelay (50); /* uhci spec 2.1.1: at least 10ms */ mdelay(50); /* uhci spec 2.1.1: at least 10ms */
uhci_reg_write16 (controller, USBCMD, 0); uhci_reg_write16(controller, USBCMD, 0);
mdelay (10); mdelay(10);
uhci_reg_write16 (controller, USBCMD, 2); /* Host Controller Reset */ uhci_reg_write16(controller, USBCMD, 2); /* Host Controller Reset */
/* wait for controller to finish reset */ /* wait for controller to finish reset */
/* TOTEST: how long to wait? 100ms for now */ /* TOTEST: how long to wait? 100ms for now */
int timeout = 200; /* time out after 200 * 500us == 100ms */ int timeout = 200; /* time out after 200 * 500us == 100ms */
while (((uhci_reg_read16 (controller, USBCMD) & 2) != 0) && timeout--) while (((uhci_reg_read16(controller, USBCMD) & 2) != 0) && timeout--)
udelay (500); udelay(500);
if (timeout < 0) if (timeout < 0)
usb_debug ("Warning: uhci: host controller reset timed out.\n"); usb_debug("Warning: uhci: host controller reset timed out.\n");
} }
static void static void
uhci_reinit (hci_t *controller) uhci_reinit(hci_t *controller)
{ {
uhci_reg_write32 (controller, FLBASEADD, uhci_reg_write32(controller, FLBASEADD,
(u32) virt_to_phys (UHCI_INST (controller)-> (u32) virt_to_phys(UHCI_INST(controller)->
framelistptr)); framelistptr));
//usb_debug ("framelist at %p\n",UHCI_INST(controller)->framelistptr); //usb_debug ("framelist at %p\n",UHCI_INST(controller)->framelistptr);
/* disable irqs */ /* disable irqs */
uhci_reg_write16 (controller, USBINTR, 0); uhci_reg_write16(controller, USBINTR, 0);
/* reset framelist index */ /* reset framelist index */
uhci_reg_write16 (controller, FRNUM, 0); uhci_reg_write16(controller, FRNUM, 0);
uhci_reg_write16(controller, USBCMD, uhci_reg_write16(controller, USBCMD,
uhci_reg_read16(controller, USBCMD) | 0xc0); // max packets, configure flag uhci_reg_read16(controller, USBCMD) | 0xc0); // max packets, configure flag
uhci_start (controller); uhci_start(controller);
} }
hci_t * hci_t *
uhci_pci_init (pcidev_t addr) uhci_pci_init(pcidev_t addr)
{ {
int i; int i;
u16 reg16; u16 reg16;
hci_t *controller = new_controller (); hci_t *controller = new_controller();
controller->pcidev = addr; controller->pcidev = addr;
controller->instance = xzalloc(sizeof (uhci_t)); controller->instance = xzalloc(sizeof(uhci_t));
controller->type = UHCI; controller->type = UHCI;
controller->start = uhci_start; controller->start = uhci_start;
controller->stop = uhci_stop; controller->stop = uhci_stop;
@ -169,27 +169,27 @@ uhci_pci_init (pcidev_t addr)
controller->create_intr_queue = uhci_create_intr_queue; controller->create_intr_queue = uhci_create_intr_queue;
controller->destroy_intr_queue = uhci_destroy_intr_queue; controller->destroy_intr_queue = uhci_destroy_intr_queue;
controller->poll_intr_queue = uhci_poll_intr_queue; controller->poll_intr_queue = uhci_poll_intr_queue;
init_device_entry (controller, 0); init_device_entry(controller, 0);
UHCI_INST (controller)->roothub = controller->devices[0]; UHCI_INST(controller)->roothub = controller->devices[0];
/* ~1 clears the register type indicator that is set to 1 /* ~1 clears the register type indicator that is set to 1
* for IO space */ * for IO space */
controller->reg_base = pci_read_config32 (addr, 0x20) & ~1; controller->reg_base = pci_read_config32(addr, 0x20) & ~1;
/* kill legacy support handler */ /* kill legacy support handler */
uhci_stop (controller); uhci_stop(controller);
mdelay (1); mdelay(1);
uhci_reg_write16 (controller, USBSTS, 0x3f); uhci_reg_write16(controller, USBSTS, 0x3f);
reg16 = pci_read_config16(addr, 0xc0); reg16 = pci_read_config16(addr, 0xc0);
reg16 &= 0xdf80; reg16 &= 0xdf80;
pci_write_config16 (addr, 0xc0, reg16); pci_write_config16(addr, 0xc0, reg16);
UHCI_INST (controller)->framelistptr = memalign (0x1000, 1024 * sizeof (flistp_t)); /* 4kb aligned to 4kb */ UHCI_INST(controller)->framelistptr = memalign(0x1000, 1024 * sizeof(flistp_t)); /* 4kb aligned to 4kb */
if (! UHCI_INST (controller)->framelistptr) if (!UHCI_INST (controller)->framelistptr)
fatal("Not enough memory for USB frame list pointer.\n"); fatal("Not enough memory for USB frame list pointer.\n");
memset (UHCI_INST (controller)->framelistptr, 0, memset(UHCI_INST(controller)->framelistptr, 0,
1024 * sizeof (flistp_t)); 1024 * sizeof(flistp_t));
/* According to the *BSD UHCI code, this one is needed on some /* According to the *BSD UHCI code, this one is needed on some
PIIX chips, because otherwise they misbehave. It must be PIIX chips, because otherwise they misbehave. It must be
@ -203,70 +203,70 @@ uhci_pci_init (pcidev_t addr)
fatal("Not enough memory for chipset workaround.\n"); fatal("Not enough memory for chipset workaround.\n");
memset(antiberserk, 0, sizeof(td_t)); memset(antiberserk, 0, sizeof(td_t));
UHCI_INST (controller)->qh_prei = memalign (16, sizeof (qh_t)); UHCI_INST(controller)->qh_prei = memalign(16, sizeof(qh_t));
UHCI_INST (controller)->qh_intr = memalign (16, sizeof (qh_t)); UHCI_INST(controller)->qh_intr = memalign(16, sizeof(qh_t));
UHCI_INST (controller)->qh_data = memalign (16, sizeof (qh_t)); UHCI_INST(controller)->qh_data = memalign(16, sizeof(qh_t));
UHCI_INST (controller)->qh_last = memalign (16, sizeof (qh_t)); UHCI_INST(controller)->qh_last = memalign(16, sizeof(qh_t));
if (! UHCI_INST (controller)->qh_prei || if (!UHCI_INST (controller)->qh_prei ||
! UHCI_INST (controller)->qh_intr || !UHCI_INST (controller)->qh_intr ||
! UHCI_INST (controller)->qh_data || !UHCI_INST (controller)->qh_data ||
! UHCI_INST (controller)->qh_last) !UHCI_INST (controller)->qh_last)
fatal("Not enough memory for USB controller queues.\n"); fatal("Not enough memory for USB controller queues.\n");
UHCI_INST (controller)->qh_prei->headlinkptr = UHCI_INST(controller)->qh_prei->headlinkptr =
virt_to_phys (UHCI_INST (controller)->qh_intr) | FLISTP_QH; virt_to_phys(UHCI_INST(controller)->qh_intr) | FLISTP_QH;
UHCI_INST (controller)->qh_prei->elementlinkptr = 0 | FLISTP_TERMINATE; UHCI_INST(controller)->qh_prei->elementlinkptr = 0 | FLISTP_TERMINATE;
UHCI_INST (controller)->qh_intr->headlinkptr = UHCI_INST(controller)->qh_intr->headlinkptr =
virt_to_phys (UHCI_INST (controller)->qh_data) | FLISTP_QH; virt_to_phys(UHCI_INST(controller)->qh_data) | FLISTP_QH;
UHCI_INST (controller)->qh_intr->elementlinkptr = 0 | FLISTP_TERMINATE; UHCI_INST(controller)->qh_intr->elementlinkptr = 0 | FLISTP_TERMINATE;
UHCI_INST (controller)->qh_data->headlinkptr = UHCI_INST(controller)->qh_data->headlinkptr =
virt_to_phys (UHCI_INST (controller)->qh_last) | FLISTP_QH; virt_to_phys(UHCI_INST(controller)->qh_last) | FLISTP_QH;
UHCI_INST (controller)->qh_data->elementlinkptr = 0 | FLISTP_TERMINATE; UHCI_INST(controller)->qh_data->elementlinkptr = 0 | FLISTP_TERMINATE;
UHCI_INST (controller)->qh_last->headlinkptr = virt_to_phys (UHCI_INST (controller)->qh_data) | FLISTP_TERMINATE; UHCI_INST(controller)->qh_last->headlinkptr = virt_to_phys(UHCI_INST(controller)->qh_data) | FLISTP_TERMINATE;
UHCI_INST (controller)->qh_last->elementlinkptr = virt_to_phys (antiberserk) | FLISTP_TERMINATE; UHCI_INST(controller)->qh_last->elementlinkptr = virt_to_phys(antiberserk) | FLISTP_TERMINATE;
for (i = 0; i < 1024; i++) { for (i = 0; i < 1024; i++) {
UHCI_INST (controller)->framelistptr[i] = UHCI_INST(controller)->framelistptr[i] =
virt_to_phys (UHCI_INST (controller)->qh_prei) | FLISTP_QH; virt_to_phys(UHCI_INST(controller)->qh_prei) | FLISTP_QH;
} }
controller->devices[0]->controller = controller; controller->devices[0]->controller = controller;
controller->devices[0]->init = uhci_rh_init; controller->devices[0]->init = uhci_rh_init;
controller->devices[0]->init (controller->devices[0]); controller->devices[0]->init(controller->devices[0]);
uhci_reset (controller); uhci_reset(controller);
uhci_reinit (controller); uhci_reinit(controller);
return controller; return controller;
} }
static void static void
uhci_shutdown (hci_t *controller) uhci_shutdown(hci_t *controller)
{ {
if (controller == 0) if (controller == 0)
return; return;
detach_controller (controller); detach_controller(controller);
uhci_reg_write16(controller, USBCMD, uhci_reg_write16(controller, USBCMD,
uhci_reg_read16(controller, USBCMD) & 0); // stop work uhci_reg_read16(controller, USBCMD) & 0); // stop work
free (UHCI_INST (controller)->framelistptr); free(UHCI_INST(controller)->framelistptr);
free (UHCI_INST (controller)->qh_prei); free(UHCI_INST(controller)->qh_prei);
free (UHCI_INST (controller)->qh_intr); free(UHCI_INST(controller)->qh_intr);
free (UHCI_INST (controller)->qh_data); free(UHCI_INST(controller)->qh_data);
free (UHCI_INST (controller)->qh_last); free(UHCI_INST(controller)->qh_last);
free (UHCI_INST (controller)); free(UHCI_INST(controller));
free (controller); free(controller);
} }
static void static void
uhci_start (hci_t *controller) uhci_start(hci_t *controller)
{ {
uhci_reg_write16(controller, USBCMD, uhci_reg_write16(controller, USBCMD,
uhci_reg_read16(controller, USBCMD) | 1); // start work on schedule uhci_reg_read16(controller, USBCMD) | 1); // start work on schedule
} }
static void static void
uhci_stop (hci_t *controller) uhci_stop(hci_t *controller)
{ {
uhci_reg_write16(controller, USBCMD, uhci_reg_write16(controller, USBCMD,
uhci_reg_read16(controller, USBCMD) & ~1); // stop work on schedule uhci_reg_read16(controller, USBCMD) & ~1); // stop work on schedule
@ -277,31 +277,31 @@ uhci_stop (hci_t *controller)
#define GET_TD(x) ((void*)(((unsigned int)(x))&~0xf)) #define GET_TD(x) ((void*)(((unsigned int)(x))&~0xf))
static td_t * static td_t *
wait_for_completed_qh (hci_t *controller, qh_t *qh) wait_for_completed_qh(hci_t *controller, qh_t *qh)
{ {
int timeout = UHCI_TIMEOUT; int timeout = UHCI_TIMEOUT;
void *current = GET_TD (qh->elementlinkptr); void *current = GET_TD(qh->elementlinkptr);
while (((qh->elementlinkptr & FLISTP_TERMINATE) == 0) && (timeout-- > 0)) { while (((qh->elementlinkptr & FLISTP_TERMINATE) == 0) && (timeout-- > 0)) {
if (current != GET_TD (qh->elementlinkptr)) { if (current != GET_TD(qh->elementlinkptr)) {
current = GET_TD (qh->elementlinkptr); current = GET_TD(qh->elementlinkptr);
timeout = UHCI_TIMEOUT; timeout = UHCI_TIMEOUT;
} }
uhci_reg_write16(controller, USBSTS, uhci_reg_write16(controller, USBSTS,
uhci_reg_read16(controller, USBSTS) | 0); // clear resettable registers uhci_reg_read16(controller, USBSTS) | 0); // clear resettable registers
udelay(UHCI_SLEEP_TIME_US); udelay(UHCI_SLEEP_TIME_US);
} }
return (GET_TD (qh->elementlinkptr) == return (GET_TD(qh->elementlinkptr) ==
0) ? 0 : GET_TD (phys_to_virt (qh->elementlinkptr)); 0) ? 0 : GET_TD(phys_to_virt(qh->elementlinkptr));
} }
static int static int
maxlen (int size) maxlen(int size)
{ {
return (size - 1) & 0x7ff; return (size - 1) & 0x7ff;
} }
static int static int
min (int a, int b) min(int a, int b)
{ {
if (a < b) if (a < b)
return a; return a;
@ -310,7 +310,7 @@ min (int a, int b)
} }
static int static int
uhci_control (usbdev_t *dev, direction_t dir, int drlen, void *devreq, int dalen, uhci_control(usbdev_t *dev, direction_t dir, int drlen, void *devreq, int dalen,
unsigned char *data) unsigned char *data)
{ {
int endp = 0; /* this is control: always 0 */ int endp = 0; /* this is control: always 0 */
@ -318,13 +318,13 @@ uhci_control (usbdev_t *dev, direction_t dir, int drlen, void *devreq, int dalen
int count = (2 + (dalen + mlen - 1) / mlen); int count = (2 + (dalen + mlen - 1) / mlen);
unsigned short req = ((unsigned short *) devreq)[0]; unsigned short req = ((unsigned short *) devreq)[0];
int i; int i;
td_t *tds = memalign (16, sizeof (td_t) * count); td_t *tds = memalign(16, sizeof(td_t) * count);
if (!tds) if (!tds)
fatal("Not enough memory for uhci control.\n"); fatal("Not enough memory for uhci control.\n");
memset (tds, 0, sizeof (td_t) * count); memset(tds, 0, sizeof(td_t) * count);
count--; /* to compensate for 0-indexed array */ count--; /* to compensate for 0-indexed array */
for (i = 0; i < count; i++) { for (i = 0; i < count; i++) {
tds[i].ptr = virt_to_phys (&tds[i + 1]) | TD_DEPTH_FIRST; tds[i].ptr = virt_to_phys(&tds[i + 1]) | TD_DEPTH_FIRST;
} }
tds[count].ptr = 0 | TD_DEPTH_FIRST | TD_TERMINATE; tds[count].ptr = 0 | TD_DEPTH_FIRST | TD_TERMINATE;
@ -333,7 +333,7 @@ uhci_control (usbdev_t *dev, direction_t dir, int drlen, void *devreq, int dalen
endp << TD_EP_SHIFT | endp << TD_EP_SHIFT |
TD_TOGGLE_DATA0 | TD_TOGGLE_DATA0 |
maxlen(drlen) << TD_MAXLEN_SHIFT; maxlen(drlen) << TD_MAXLEN_SHIFT;
tds[0].bufptr = virt_to_phys (devreq); tds[0].bufptr = virt_to_phys(devreq);
tds[0].ctrlsts = (3 << TD_COUNTER_SHIFT) | tds[0].ctrlsts = (3 << TD_COUNTER_SHIFT) |
(dev->speed?TD_LOWSPEED:0) | (dev->speed?TD_LOWSPEED:0) |
TD_STATUS_ACTIVE; TD_STATUS_ACTIVE;
@ -347,9 +347,9 @@ uhci_control (usbdev_t *dev, direction_t dir, int drlen, void *devreq, int dalen
} }
tds[i].token |= dev->address << TD_DEVADDR_SHIFT | tds[i].token |= dev->address << TD_DEVADDR_SHIFT |
endp << TD_EP_SHIFT | endp << TD_EP_SHIFT |
maxlen (min (mlen, dalen)) << TD_MAXLEN_SHIFT | maxlen(min(mlen, dalen)) << TD_MAXLEN_SHIFT |
toggle << TD_TOGGLE_SHIFT; toggle << TD_TOGGLE_SHIFT;
tds[i].bufptr = virt_to_phys (data); tds[i].bufptr = virt_to_phys(data);
tds[i].ctrlsts = (3 << TD_COUNTER_SHIFT) | tds[i].ctrlsts = (3 << TD_COUNTER_SHIFT) |
(dev->speed?TD_LOWSPEED:0) | (dev->speed?TD_LOWSPEED:0) |
TD_STATUS_ACTIVE; TD_STATUS_ACTIVE;
@ -367,42 +367,42 @@ uhci_control (usbdev_t *dev, direction_t dir, int drlen, void *devreq, int dalen
tds[count].ctrlsts = (0 << TD_COUNTER_SHIFT) | /* as Linux 2.4.10 does */ tds[count].ctrlsts = (0 << TD_COUNTER_SHIFT) | /* as Linux 2.4.10 does */
(dev->speed?TD_LOWSPEED:0) | (dev->speed?TD_LOWSPEED:0) |
TD_STATUS_ACTIVE; TD_STATUS_ACTIVE;
UHCI_INST (dev->controller)->qh_data->elementlinkptr = UHCI_INST(dev->controller)->qh_data->elementlinkptr =
virt_to_phys (tds) & ~(FLISTP_QH | FLISTP_TERMINATE); virt_to_phys(tds) & ~(FLISTP_QH | FLISTP_TERMINATE);
td_t *td = wait_for_completed_qh (dev->controller, td_t *td = wait_for_completed_qh(dev->controller,
UHCI_INST (dev->controller)-> UHCI_INST(dev->controller)->
qh_data); qh_data);
int result; int result;
if (td == 0) { if (td == 0) {
result = 0; result = 0;
} else { } else {
usb_debug ("control packet, req %x\n", req); usb_debug("control packet, req %x\n", req);
td_dump (td); td_dump(td);
result = -1; result = -1;
} }
free (tds); free(tds);
return result; return result;
} }
static td_t * static td_t *
create_schedule (int numpackets) create_schedule(int numpackets)
{ {
if (numpackets == 0) if (numpackets == 0)
return 0; return 0;
td_t *tds = memalign (16, sizeof (td_t) * numpackets); td_t *tds = memalign(16, sizeof(td_t) * numpackets);
if (!tds) if (!tds)
fatal("Not enough memory for packets scheduling.\n"); fatal("Not enough memory for packets scheduling.\n");
memset (tds, 0, sizeof (td_t) * numpackets); memset(tds, 0, sizeof(td_t) * numpackets);
int i; int i;
for (i = 0; i < numpackets; i++) { for (i = 0; i < numpackets; i++) {
tds[i].ptr = virt_to_phys (&tds[i + 1]) | TD_DEPTH_FIRST; tds[i].ptr = virt_to_phys(&tds[i + 1]) | TD_DEPTH_FIRST;
} }
tds[numpackets - 1].ptr = 0 | TD_TERMINATE; tds[numpackets - 1].ptr = 0 | TD_TERMINATE;
return tds; return tds;
} }
static void static void
fill_schedule (td_t *td, endpoint_t *ep, int length, unsigned char *data, fill_schedule(td_t *td, endpoint_t *ep, int length, unsigned char *data,
int *toggle) int *toggle)
{ {
switch (ep->direction) { switch (ep->direction) {
@ -412,9 +412,9 @@ fill_schedule (td_t *td, endpoint_t *ep, int length, unsigned char *data,
} }
td->token |= ep->dev->address << TD_DEVADDR_SHIFT | td->token |= ep->dev->address << TD_DEVADDR_SHIFT |
(ep->endpoint & 0xf) << TD_EP_SHIFT | (ep->endpoint & 0xf) << TD_EP_SHIFT |
maxlen (length) << TD_MAXLEN_SHIFT | maxlen(length) << TD_MAXLEN_SHIFT |
(*toggle & 1) << TD_TOGGLE_SHIFT; (*toggle & 1) << TD_TOGGLE_SHIFT;
td->bufptr = virt_to_phys (data); td->bufptr = virt_to_phys(data);
td->ctrlsts = ((ep->direction == SETUP?3:0) << TD_COUNTER_SHIFT) | td->ctrlsts = ((ep->direction == SETUP?3:0) << TD_COUNTER_SHIFT) |
(ep->dev->speed?TD_LOWSPEED:0) | (ep->dev->speed?TD_LOWSPEED:0) |
TD_STATUS_ACTIVE; TD_STATUS_ACTIVE;
@ -422,23 +422,23 @@ fill_schedule (td_t *td, endpoint_t *ep, int length, unsigned char *data,
} }
static int static int
run_schedule (usbdev_t *dev, td_t *td) run_schedule(usbdev_t *dev, td_t *td)
{ {
UHCI_INST (dev->controller)->qh_data->elementlinkptr = UHCI_INST(dev->controller)->qh_data->elementlinkptr =
virt_to_phys (td) & ~(FLISTP_QH | FLISTP_TERMINATE); virt_to_phys(td) & ~(FLISTP_QH | FLISTP_TERMINATE);
td = wait_for_completed_qh (dev->controller, td = wait_for_completed_qh(dev->controller,
UHCI_INST (dev->controller)->qh_data); UHCI_INST(dev->controller)->qh_data);
if (td == 0) { if (td == 0) {
return 0; return 0;
} else { } else {
td_dump (td); td_dump(td);
return 1; return 1;
} }
} }
/* finalize == 1: if data is of packet aligned size, add a zero length packet */ /* finalize == 1: if data is of packet aligned size, add a zero length packet */
static int static int
uhci_bulk (endpoint_t *ep, int size, u8 *data, int finalize) uhci_bulk(endpoint_t *ep, int size, u8 *data, int finalize)
{ {
int maxpsize = ep->maxpacketsize; int maxpsize = ep->maxpacketsize;
if (maxpsize == 0) if (maxpsize == 0)
@ -449,21 +449,21 @@ uhci_bulk (endpoint_t *ep, int size, u8 *data, int finalize)
} }
if (numpackets == 0) if (numpackets == 0)
return 0; return 0;
td_t *tds = create_schedule (numpackets); td_t *tds = create_schedule(numpackets);
int i = 0, toggle = ep->toggle; int i = 0, toggle = ep->toggle;
while ((size > 0) || ((size == 0) && (finalize != 0))) { while ((size > 0) || ((size == 0) && (finalize != 0))) {
fill_schedule (&tds[i], ep, min (size, maxpsize), data, fill_schedule(&tds[i], ep, min(size, maxpsize), data,
&toggle); &toggle);
i++; i++;
data += maxpsize; data += maxpsize;
size -= maxpsize; size -= maxpsize;
} }
if (run_schedule (ep->dev, tds) == 1) { if (run_schedule(ep->dev, tds) == 1) {
free (tds); free(tds);
return -1; return -1;
} }
ep->toggle = toggle; ep->toggle = toggle;
free (tds); free(tds);
return 0; return 0;
} }
@ -479,7 +479,7 @@ typedef struct {
/* create and hook-up an intr queue into device schedule */ /* create and hook-up an intr queue into device schedule */
static void* static void*
uhci_create_intr_queue (endpoint_t *ep, int reqsize, int reqcount, int reqtiming) uhci_create_intr_queue(endpoint_t *ep, int reqsize, int reqcount, int reqtiming)
{ {
u8 *data = malloc(reqsize*reqcount); u8 *data = malloc(reqsize*reqcount);
td_t *tds = memalign(16, sizeof(td_t) * reqcount); td_t *tds = memalign(16, sizeof(td_t) * reqcount);
@ -501,10 +501,10 @@ uhci_create_intr_queue (endpoint_t *ep, int reqsize, int reqcount, int reqtiming
q->reqsize = reqsize; q->reqsize = reqsize;
q->last_td = &tds[reqcount - 1]; q->last_td = &tds[reqcount - 1];
memset (tds, 0, sizeof (td_t) * reqcount); memset(tds, 0, sizeof(td_t) * reqcount);
int i; int i;
for (i = 0; i < reqcount; i++) { for (i = 0; i < reqcount; i++) {
tds[i].ptr = virt_to_phys (&tds[i + 1]); tds[i].ptr = virt_to_phys(&tds[i + 1]);
switch (ep->direction) { switch (ep->direction) {
case IN: tds[i].token = UHCI_IN; break; case IN: tds[i].token = UHCI_IN; break;
@ -513,9 +513,9 @@ uhci_create_intr_queue (endpoint_t *ep, int reqsize, int reqcount, int reqtiming
} }
tds[i].token |= ep->dev->address << TD_DEVADDR_SHIFT | tds[i].token |= ep->dev->address << TD_DEVADDR_SHIFT |
(ep->endpoint & 0xf) << TD_EP_SHIFT | (ep->endpoint & 0xf) << TD_EP_SHIFT |
maxlen (reqsize) << TD_MAXLEN_SHIFT | maxlen(reqsize) << TD_MAXLEN_SHIFT |
(ep->toggle & 1) << TD_TOGGLE_SHIFT; (ep->toggle & 1) << TD_TOGGLE_SHIFT;
tds[i].bufptr = virt_to_phys (data); tds[i].bufptr = virt_to_phys(data);
tds[i].ctrlsts = (0 << TD_COUNTER_SHIFT) | tds[i].ctrlsts = (0 << TD_COUNTER_SHIFT) |
(ep->dev->speed?TD_LOWSPEED:0) | (ep->dev->speed?TD_LOWSPEED:0) |
TD_STATUS_ACTIVE; TD_STATUS_ACTIVE;
@ -549,7 +549,7 @@ uhci_create_intr_queue (endpoint_t *ep, int reqsize, int reqcount, int reqtiming
/* remove queue from device schedule, dropping all data that came in */ /* remove queue from device schedule, dropping all data that came in */
static void static void
uhci_destroy_intr_queue (endpoint_t *ep, void *q_) uhci_destroy_intr_queue(endpoint_t *ep, void *q_)
{ {
intr_q *const q = (intr_q*)q_; intr_q *const q = (intr_q*)q_;
@ -574,7 +574,7 @@ uhci_destroy_intr_queue (endpoint_t *ep, void *q_)
Recommended use: while (data=poll_intr_queue(q)) process(data); Recommended use: while (data=poll_intr_queue(q)) process(data);
*/ */
static u8* static u8*
uhci_poll_intr_queue (void *q_) uhci_poll_intr_queue(void *q_)
{ {
intr_q *q = (intr_q*)q_; intr_q *q = (intr_q*)q_;
if ((q->tds[q->lastread].ctrlsts & TD_STATUS_ACTIVE) == 0) { if ((q->tds[q->lastread].ctrlsts & TD_STATUS_ACTIVE) == 0) {
@ -605,37 +605,37 @@ uhci_poll_intr_queue (void *q_)
} }
void void
uhci_reg_write32 (hci_t *ctrl, usbreg reg, u32 value) uhci_reg_write32(hci_t *ctrl, usbreg reg, u32 value)
{ {
outl (value, ctrl->reg_base + reg); outl(value, ctrl->reg_base + reg);
} }
u32 u32
uhci_reg_read32 (hci_t *ctrl, usbreg reg) uhci_reg_read32(hci_t *ctrl, usbreg reg)
{ {
return inl (ctrl->reg_base + reg); return inl(ctrl->reg_base + reg);
} }
void void
uhci_reg_write16 (hci_t *ctrl, usbreg reg, u16 value) uhci_reg_write16(hci_t *ctrl, usbreg reg, u16 value)
{ {
outw (value, ctrl->reg_base + reg); outw(value, ctrl->reg_base + reg);
} }
u16 u16
uhci_reg_read16 (hci_t *ctrl, usbreg reg) uhci_reg_read16(hci_t *ctrl, usbreg reg)
{ {
return inw (ctrl->reg_base + reg); return inw(ctrl->reg_base + reg);
} }
void void
uhci_reg_write8 (hci_t *ctrl, usbreg reg, u8 value) uhci_reg_write8(hci_t *ctrl, usbreg reg, u8 value)
{ {
outb (value, ctrl->reg_base + reg); outb(value, ctrl->reg_base + reg);
} }
u8 u8
uhci_reg_read8 (hci_t *ctrl, usbreg reg) uhci_reg_read8(hci_t *ctrl, usbreg reg)
{ {
return inb (ctrl->reg_base + reg); return inb(ctrl->reg_base + reg);
} }

4
payloads/libpayload/drivers/usb/uhci.h
View File

@ -32,8 +32,8 @@
#include <pci.h> #include <pci.h>
#include <usb/usb.h> #include <usb/usb.h>
hci_t *uhci_pci_init (pcidev_t addr); hci_t *uhci_pci_init(pcidev_t addr);
void uhci_rh_init (usbdev_t *dev); void uhci_rh_init(usbdev_t *dev);
#endif #endif

12
payloads/libpayload/drivers/usb/uhci_private.h
View File

@ -80,12 +80,12 @@ typedef struct {
0x12 0x12
} usbreg; } usbreg;
void uhci_reg_write32 (hci_t *ctrl, usbreg reg, u32 value); void uhci_reg_write32(hci_t *ctrl, usbreg reg, u32 value);
u32 uhci_reg_read32 (hci_t *ctrl, usbreg reg); u32 uhci_reg_read32(hci_t *ctrl, usbreg reg);
void uhci_reg_write16 (hci_t *ctrl, usbreg reg, u16 value); void uhci_reg_write16(hci_t *ctrl, usbreg reg, u16 value);
u16 uhci_reg_read16 (hci_t *ctrl, usbreg reg); u16 uhci_reg_read16(hci_t *ctrl, usbreg reg);
void uhci_reg_write8 (hci_t *ctrl, usbreg reg, u8 value); void uhci_reg_write8(hci_t *ctrl, usbreg reg, u8 value);
u8 uhci_reg_read8 (hci_t *ctrl, usbreg reg); u8 uhci_reg_read8(hci_t *ctrl, usbreg reg);
typedef struct uhci { typedef struct uhci {
flistp_t *framelistptr; flistp_t *framelistptr;

72
payloads/libpayload/drivers/usb/uhci_rh.c
View File

@ -39,7 +39,7 @@ typedef struct {
#define RH_INST(dev) ((rh_inst_t*)(dev)->data) #define RH_INST(dev) ((rh_inst_t*)(dev)->data)
static void static void
uhci_rh_enable_port (usbdev_t *dev, int port) uhci_rh_enable_port(usbdev_t *dev, int port)
{ {
u16 value; u16 value;
hci_t *controller = dev->controller; hci_t *controller = dev->controller;
@ -57,10 +57,10 @@ uhci_rh_enable_port (usbdev_t *dev, int port)
uhci_reg_write16(controller, port, uhci_reg_write16(controller, port,
uhci_reg_read16(controller, port) | 1 << 9); /* reset */ uhci_reg_read16(controller, port) | 1 << 9); /* reset */
mdelay (30); // >10ms mdelay(30); // >10ms
uhci_reg_write16(controller, port, uhci_reg_write16(controller, port,
uhci_reg_read16(controller, port) & ~(1 << 9)); uhci_reg_read16(controller, port) & ~(1 << 9));
mdelay (1); // >5.3us per spec, <3ms because some devices make trouble mdelay(1); // >5.3us per spec, <3ms because some devices make trouble
uhci_reg_write16(controller, port, uhci_reg_write16(controller, port,
uhci_reg_read16(controller, port) | 1 << 2); /* enable */ uhci_reg_read16(controller, port) | 1 << 2); /* enable */
@ -68,7 +68,7 @@ uhci_rh_enable_port (usbdev_t *dev, int port)
/* TOTEST: how long to wait? 100ms for now */ /* TOTEST: how long to wait? 100ms for now */
int timeout = 200; /* time out after 200 * 500us == 100ms */ int timeout = 200; /* time out after 200 * 500us == 100ms */
do { do {
value = uhci_reg_read16 (controller, port); value = uhci_reg_read16(controller, port);
udelay(500); timeout--; udelay(500); timeout--;
} while (((value & (1 << 2)) == 0) && (value & 0x01) && timeout); } while (((value & (1 << 2)) == 0) && (value & 0x01) && timeout);
if (!timeout) if (!timeout)
@ -77,7 +77,7 @@ uhci_rh_enable_port (usbdev_t *dev, int port)
/* disable root hub */ /* disable root hub */
static void static void
uhci_rh_disable_port (usbdev_t *dev, int port) uhci_rh_disable_port(usbdev_t *dev, int port)
{ {
hci_t *controller = dev->controller; hci_t *controller = dev->controller;
if (port == 1) if (port == 1)
@ -95,7 +95,7 @@ uhci_rh_disable_port (usbdev_t *dev, int port)
/* TOTEST: how long to wait? 100ms for now */ /* TOTEST: how long to wait? 100ms for now */
int timeout = 200; /* time out after 200 * 500us == 100ms */ int timeout = 200; /* time out after 200 * 500us == 100ms */
do { do {
value = uhci_reg_read16 (controller, port); value = uhci_reg_read16(controller, port);
udelay(500); timeout--; udelay(500); timeout--;
} while (((value & (1 << 2)) != 0) && timeout); } while (((value & (1 << 2)) != 0) && timeout);
if (!timeout) if (!timeout)
@ -103,7 +103,7 @@ uhci_rh_disable_port (usbdev_t *dev, int port)
} }
static void static void
uhci_rh_scanport (usbdev_t *dev, int port) uhci_rh_scanport(usbdev_t *dev, int port)
{ {
int portsc, offset; int portsc, offset;
if (port == 1) { if (port == 1) {
@ -116,42 +116,42 @@ uhci_rh_scanport (usbdev_t *dev, int port)
usb_debug("Invalid port %d\n", port); usb_debug("Invalid port %d\n", port);
return; return;
} }
int devno = RH_INST (dev)->port[offset]; int devno = RH_INST(dev)->port[offset];
if ((devno != -1) && (dev->controller->devices[devno] != 0)) { if ((devno != -1) && (dev->controller->devices[devno] != 0)) {
usb_detach_device(dev->controller, devno); usb_detach_device(dev->controller, devno);
RH_INST (dev)->port[offset] = -1; RH_INST(dev)->port[offset] = -1;
} }
uhci_reg_write16(dev->controller, portsc, uhci_reg_write16(dev->controller, portsc,
uhci_reg_read16(dev->controller, portsc) | (1 << 3) | (1 << 2)); // clear port state change, enable port uhci_reg_read16(dev->controller, portsc) | (1 << 3) | (1 << 2)); // clear port state change, enable port
mdelay(100); // wait for signal to stabilize mdelay(100); // wait for signal to stabilize
if ((uhci_reg_read16 (dev->controller, portsc) & 1) != 0) { if ((uhci_reg_read16(dev->controller, portsc) & 1) != 0) {
// device attached // device attached
uhci_rh_disable_port (dev, port); uhci_rh_disable_port(dev, port);
uhci_rh_enable_port (dev, port); uhci_rh_enable_port(dev, port);
usb_speed speed = ((uhci_reg_read16 (dev->controller, portsc) >> 8) & 1); usb_speed speed = ((uhci_reg_read16(dev->controller, portsc) >> 8) & 1);
RH_INST (dev)->port[offset] = usb_attach_device(dev->controller, dev->address, portsc, speed); RH_INST(dev)->port[offset] = usb_attach_device(dev->controller, dev->address, portsc, speed);
} }
} }
static int static int
uhci_rh_report_port_changes (usbdev_t *dev) uhci_rh_report_port_changes(usbdev_t *dev)
{ {
u16 stored, real; u16 stored, real;
stored = (RH_INST (dev)->port[0] == -1); stored = (RH_INST(dev)->port[0] == -1);
real = ((uhci_reg_read16 (dev->controller, PORTSC1) & 1) == 0); real = ((uhci_reg_read16(dev->controller, PORTSC1) & 1) == 0);
if (stored != real) { if (stored != real) {
usb_debug("change on port 1\n"); usb_debug("change on port 1\n");
return 1; return 1;
} }
stored = (RH_INST (dev)->port[1] == -1); stored = (RH_INST(dev)->port[1] == -1);
real = ((uhci_reg_read16 (dev->controller, PORTSC2) & 1) == 0); real = ((uhci_reg_read16(dev->controller, PORTSC2) & 1) == 0);
if (stored != real) { if (stored != real) {
usb_debug("change on port 2\n"); usb_debug("change on port 2\n");
return 2; return 2;
@ -159,11 +159,11 @@ uhci_rh_report_port_changes (usbdev_t *dev)
// maybe detach+attach happened between two scans? // maybe detach+attach happened between two scans?
if ((uhci_reg_read16 (dev->controller, PORTSC1) & 2) > 0) { if ((uhci_reg_read16(dev->controller, PORTSC1) & 2) > 0) {
usb_debug("possibly re-attached on port 1\n"); usb_debug("possibly re-attached on port 1\n");
return 1; return 1;
} }
if ((uhci_reg_read16 (dev->controller, PORTSC2) & 2) > 0) { if ((uhci_reg_read16(dev->controller, PORTSC2) & 2) > 0) {
usb_debug("possibly re-attached on port 2\n"); usb_debug("possibly re-attached on port 2\n");
return 2; return 2;
} }
@ -173,35 +173,35 @@ uhci_rh_report_port_changes (usbdev_t *dev)
} }
static void static void
uhci_rh_destroy (usbdev_t *dev) uhci_rh_destroy(usbdev_t *dev)
{ {
usb_detach_device (dev->controller, 1); usb_detach_device(dev->controller, 1);
usb_detach_device (dev->controller, 2); usb_detach_device(dev->controller, 2);
uhci_rh_disable_port (dev, 1); uhci_rh_disable_port(dev, 1);
uhci_rh_disable_port (dev, 2); uhci_rh_disable_port(dev, 2);
free (RH_INST (dev)); free(RH_INST(dev));
} }
static void static void
uhci_rh_poll (usbdev_t *dev) uhci_rh_poll(usbdev_t *dev)
{ {
int port; int port;
while ((port = uhci_rh_report_port_changes (dev)) != -1) while ((port = uhci_rh_report_port_changes(dev)) != -1)
uhci_rh_scanport (dev, port); uhci_rh_scanport(dev, port);
} }
void void
uhci_rh_init (usbdev_t *dev) uhci_rh_init(usbdev_t *dev)
{ {
dev->destroy = uhci_rh_destroy; dev->destroy = uhci_rh_destroy;
dev->poll = uhci_rh_poll; dev->poll = uhci_rh_poll;
uhci_rh_enable_port (dev, 1); uhci_rh_enable_port(dev, 1);
uhci_rh_enable_port (dev, 2); uhci_rh_enable_port(dev, 2);
dev->data = xmalloc (sizeof (rh_inst_t)); dev->data = xmalloc(sizeof(rh_inst_t));
RH_INST (dev)->port[0] = -1; RH_INST(dev)->port[0] = -1;
RH_INST (dev)->port[1] = -1; RH_INST(dev)->port[1] = -1;
/* we can set them here because a root hub _really_ shouldn't /* we can set them here because a root hub _really_ shouldn't
appear elsewhere */ appear elsewhere */

142
payloads/libpayload/drivers/usb/usb.c
View File

@ -37,16 +37,16 @@
hci_t *usb_hcs = 0; hci_t *usb_hcs = 0;
hci_t * hci_t *
new_controller (void) new_controller(void)
{ {
hci_t *controller = xzalloc(sizeof (hci_t)); hci_t *controller = xzalloc(sizeof(hci_t));
controller->next = usb_hcs; controller->next = usb_hcs;
usb_hcs = controller; usb_hcs = controller;
return controller; return controller;
} }
void void
detach_controller (hci_t *controller) detach_controller(hci_t *controller)
{ {
if (controller == NULL) if (controller == NULL)
return; return;
@ -71,7 +71,7 @@ detach_controller (hci_t *controller)
* Shut down all controllers * Shut down all controllers
*/ */
int int
usb_exit (void) usb_exit(void)
{ {
while (usb_hcs != NULL) { while (usb_hcs != NULL) {
usb_hcs->shutdown(usb_hcs); usb_hcs->shutdown(usb_hcs);
@ -83,7 +83,7 @@ usb_exit (void)
* Polls all hubs on all USB controllers, to find out about device changes * Polls all hubs on all USB controllers, to find out about device changes
*/ */
void void
usb_poll (void) usb_poll(void)
{ {
if (usb_hcs == 0) if (usb_hcs == 0)
return; return;
@ -96,7 +96,7 @@ usb_poll (void)
int i; int i;
for (i = 0; i < 128; i++) { for (i = 0; i < 128; i++) {
if (controller->devices[i] != 0) { if (controller->devices[i] != 0) {
controller->devices[i]->poll (controller->devices[i]); controller->devices[i]->poll(controller->devices[i]);
} }
} }
controller = controller->next; controller = controller->next;
@ -104,7 +104,7 @@ usb_poll (void)
} }
usbdev_t * usbdev_t *
init_device_entry (hci_t *controller, int i) init_device_entry(hci_t *controller, int i)
{ {
usbdev_t *dev = calloc(1, sizeof(usbdev_t)); usbdev_t *dev = calloc(1, sizeof(usbdev_t));
if (!dev) { if (!dev) {
@ -119,12 +119,12 @@ init_device_entry (hci_t *controller, int i)
dev->hub = -1; dev->hub = -1;
dev->port = -1; dev->port = -1;
dev->init = usb_nop_init; dev->init = usb_nop_init;
dev->init (controller->devices[i]); dev->init(controller->devices[i]);
return dev; return dev;
} }
int int
set_feature (usbdev_t *dev, int endp, int feature, int rtype) set_feature(usbdev_t *dev, int endp, int feature, int rtype)
{ {
dev_req_t dr; dev_req_t dr;
@ -135,11 +135,11 @@ set_feature (usbdev_t *dev, int endp, int feature, int rtype)
dr.wIndex = endp; dr.wIndex = endp;
dr.wLength = 0; dr.wLength = 0;
return dev->controller->control (dev, OUT, sizeof (dr), &dr, 0, 0); return dev->controller->control(dev, OUT, sizeof(dr), &dr, 0, 0);
} }
int int
get_status (usbdev_t *dev, int intf, int rtype, int len, void *data) get_status(usbdev_t *dev, int intf, int rtype, int len, void *data)
{ {
dev_req_t dr; dev_req_t dr;
@ -150,7 +150,7 @@ get_status (usbdev_t *dev, int intf, int rtype, int len, void *data)
dr.wIndex = intf; dr.wIndex = intf;
dr.wLength = len; dr.wLength = len;
return dev->controller->control (dev, IN, sizeof (dr), &dr, len, data); return dev->controller->control(dev, IN, sizeof(dr), &dr, len, data);
} }
/* /*
@ -186,7 +186,7 @@ get_descriptor(usbdev_t *dev, int rtype, int desc_type, int desc_idx,
} }
int int
set_configuration (usbdev_t *dev) set_configuration(usbdev_t *dev)
{ {
dev_req_t dr; dev_req_t dr;
@ -196,11 +196,11 @@ set_configuration (usbdev_t *dev)
dr.wIndex = 0; dr.wIndex = 0;
dr.wLength = 0; dr.wLength = 0;
return dev->controller->control (dev, OUT, sizeof (dr), &dr, 0, 0); return dev->controller->control(dev, OUT, sizeof(dr), &dr, 0, 0);
} }
int int
clear_feature (usbdev_t *dev, int endp, int feature, int rtype) clear_feature(usbdev_t *dev, int endp, int feature, int rtype)
{ {
dev_req_t dr; dev_req_t dr;
@ -211,21 +211,21 @@ clear_feature (usbdev_t *dev, int endp, int feature, int rtype)
dr.wIndex = endp; dr.wIndex = endp;
dr.wLength = 0; dr.wLength = 0;
return dev->controller->control (dev, OUT, sizeof (dr), &dr, 0, 0) < 0; return dev->controller->control(dev, OUT, sizeof(dr), &dr, 0, 0) < 0;
} }
int int
clear_stall (endpoint_t *ep) clear_stall(endpoint_t *ep)
{ {
int ret = clear_feature (ep->dev, ep->endpoint, ENDPOINT_HALT, int ret = clear_feature(ep->dev, ep->endpoint, ENDPOINT_HALT,
gen_bmRequestType (host_to_device, standard_type, endp_recp)); gen_bmRequestType(host_to_device, standard_type, endp_recp));
ep->toggle = 0; ep->toggle = 0;
return ret; return ret;
} }
/* returns free address or -1 */ /* returns free address or -1 */
static int static int
get_free_address (hci_t *controller) get_free_address(hci_t *controller)
{ {
int i = controller->latest_address + 1; int i = controller->latest_address + 1;
for (; i != controller->latest_address; i++) { for (; i != controller->latest_address; i++) {
@ -240,7 +240,7 @@ get_free_address (hci_t *controller)
return i; return i;
} }
} }
usb_debug ("no free address found\n"); usb_debug("no free address found\n");
return -1; // no free address return -1; // no free address
} }
@ -342,15 +342,15 @@ usb_decode_interval(usb_speed speed, const endpoint_type type, const unsigned ch
} }
usbdev_t * usbdev_t *
generic_set_address (hci_t *controller, usb_speed speed, generic_set_address(hci_t *controller, usb_speed speed,
int hubport, int hubaddr) int hubport, int hubaddr)
{ {
int adr = get_free_address (controller); // address to set int adr = get_free_address(controller); // address to set
if (adr < 0) if (adr < 0)
return NULL; return NULL;
dev_req_t dr; dev_req_t dr;
memset (&dr, 0, sizeof (dr)); memset(&dr, 0, sizeof(dr));
dr.data_dir = host_to_device; dr.data_dir = host_to_device;
dr.req_type = standard_type; dr.req_type = standard_type;
dr.req_recp = dev_recp; dr.req_recp = dev_recp;
@ -374,19 +374,19 @@ generic_set_address (hci_t *controller, usb_speed speed,
dev->endpoints[0].toggle = 0; dev->endpoints[0].toggle = 0;
dev->endpoints[0].direction = SETUP; dev->endpoints[0].direction = SETUP;
dev->endpoints[0].type = CONTROL; dev->endpoints[0].type = CONTROL;
if (dev->controller->control (dev, OUT, sizeof (dr), &dr, 0, 0) < 0) { if (dev->controller->control(dev, OUT, sizeof(dr), &dr, 0, 0) < 0) {
usb_debug ("set_address failed\n"); usb_debug("set_address failed\n");
usb_detach_device (controller, adr); usb_detach_device(controller, adr);
return NULL; return NULL;
} }
mdelay (SET_ADDRESS_MDELAY); mdelay(SET_ADDRESS_MDELAY);
u8 buf[8]; u8 buf[8];
dev->address = adr; dev->address = adr;
if (get_descriptor (dev, DR_DESC, DT_DEV, 0, buf, sizeof(buf)) if (get_descriptor(dev, DR_DESC, DT_DEV, 0, buf, sizeof(buf))
!= sizeof(buf)) { != sizeof(buf)) {
usb_debug("first get_descriptor(DT_DEV) failed\n"); usb_debug("first get_descriptor(DT_DEV) failed\n");
usb_detach_device (controller, adr); usb_detach_device(controller, adr);
return NULL; return NULL;
} }
dev->endpoints[0].maxpacketsize = usb_decode_mps0(speed, buf[7]); dev->endpoints[0].maxpacketsize = usb_decode_mps0(speed, buf[7]);
@ -395,45 +395,45 @@ generic_set_address (hci_t *controller, usb_speed speed,
} }
static int static int
set_address (hci_t *controller, usb_speed speed, int hubport, int hubaddr) set_address(hci_t *controller, usb_speed speed, int hubport, int hubaddr)
{ {
usbdev_t *dev = controller->set_address(controller, speed, usbdev_t *dev = controller->set_address(controller, speed,
hubport, hubaddr); hubport, hubaddr);
if (!dev) { if (!dev) {
usb_debug ("set_address failed\n"); usb_debug("set_address failed\n");
return -1; return -1;
} }
dev->descriptor = malloc(sizeof(*dev->descriptor)); dev->descriptor = malloc(sizeof(*dev->descriptor));
if (!dev->descriptor || get_descriptor (dev, DR_DESC, DT_DEV, 0, if (!dev->descriptor || get_descriptor(dev, DR_DESC, DT_DEV, 0,
dev->descriptor, sizeof(*dev->descriptor)) dev->descriptor, sizeof(*dev->descriptor))
!= sizeof(*dev->descriptor)) { != sizeof(*dev->descriptor)) {
usb_debug ("get_descriptor(DT_DEV) failed\n"); usb_debug("get_descriptor(DT_DEV) failed\n");
usb_detach_device (controller, dev->address); usb_detach_device(controller, dev->address);
return -1; return -1;
} }
usb_debug ("* found device (0x%04x:0x%04x, USB %x.%x, MPS0: %d)\n", usb_debug("* found device (0x%04x:0x%04x, USB %x.%x, MPS0: %d)\n",
dev->descriptor->idVendor, dev->descriptor->idProduct, dev->descriptor->idVendor, dev->descriptor->idProduct,
dev->descriptor->bcdUSB >> 8, dev->descriptor->bcdUSB & 0xff, dev->descriptor->bcdUSB >> 8, dev->descriptor->bcdUSB & 0xff,
dev->endpoints[0].maxpacketsize); dev->endpoints[0].maxpacketsize);
dev->quirks = usb_quirk_check(dev->descriptor->idVendor, dev->quirks = usb_quirk_check(dev->descriptor->idVendor,
dev->descriptor->idProduct); dev->descriptor->idProduct);
usb_debug ("device has %d configurations\n", usb_debug("device has %d configurations\n",
dev->descriptor->bNumConfigurations); dev->descriptor->bNumConfigurations);
if (dev->descriptor->bNumConfigurations == 0) { if (dev->descriptor->bNumConfigurations == 0) {
/* device isn't usable */ /* device isn't usable */
usb_debug ("... no usable configuration!\n"); usb_debug("... no usable configuration!\n");
usb_detach_device (controller, dev->address); usb_detach_device(controller, dev->address);
return -1; return -1;
} }
u16 buf[2]; u16 buf[2];
if (get_descriptor (dev, DR_DESC, DT_CFG, 0, buf, sizeof(buf)) if (get_descriptor(dev, DR_DESC, DT_CFG, 0, buf, sizeof(buf))
!= sizeof(buf)) { != sizeof(buf)) {
usb_debug ("first get_descriptor(DT_CFG) failed\n"); usb_debug("first get_descriptor(DT_CFG) failed\n");
usb_detach_device (controller, dev->address); usb_detach_device(controller, dev->address);
return -1; return -1;
} }
/* workaround for some USB devices: wait until they're ready, or /* workaround for some USB devices: wait until they're ready, or
@ -441,20 +441,20 @@ set_address (hci_t *controller, usb_speed speed, int hubport, int hubaddr)
mdelay(1); mdelay(1);
dev->configuration = malloc(buf[1]); dev->configuration = malloc(buf[1]);
if (!dev->configuration) { if (!dev->configuration) {
usb_debug ("could not allocate %d bytes for DT_CFG\n", buf[1]); usb_debug("could not allocate %d bytes for DT_CFG\n", buf[1]);
usb_detach_device (controller, dev->address); usb_detach_device(controller, dev->address);
return -1; return -1;
} }
if (get_descriptor (dev, DR_DESC, DT_CFG, 0, dev->configuration, if (get_descriptor(dev, DR_DESC, DT_CFG, 0, dev->configuration,
buf[1]) != buf[1]) { buf[1]) != buf[1]) {
usb_debug ("get_descriptor(DT_CFG) failed\n"); usb_debug("get_descriptor(DT_CFG) failed\n");
usb_detach_device (controller, dev->address); usb_detach_device(controller, dev->address);
return -1; return -1;
} }
configuration_descriptor_t *cd = dev->configuration; configuration_descriptor_t *cd = dev->configuration;
if (cd->wTotalLength != buf[1]) { if (cd->wTotalLength != buf[1]) {
usb_debug ("configuration descriptor size changed, aborting\n"); usb_debug("configuration descriptor size changed, aborting\n");
usb_detach_device (controller, dev->address); usb_detach_device(controller, dev->address);
return -1; return -1;
} }
@ -464,11 +464,11 @@ set_address (hci_t *controller, usb_speed speed, int hubport, int hubaddr)
* else for the time being. If you need it, see the SetInterface and * else for the time being. If you need it, see the SetInterface and
* GetInterface functions in the USB specification and set it yourself. * GetInterface functions in the USB specification and set it yourself.
*/ */
usb_debug ("device has %x interfaces\n", cd->bNumInterfaces); usb_debug("device has %x interfaces\n", cd->bNumInterfaces);
int ifnum = usb_interface_check(dev->descriptor->idVendor, int ifnum = usb_interface_check(dev->descriptor->idVendor,
dev->descriptor->idProduct); dev->descriptor->idProduct);
if (cd->bNumInterfaces > 1 && ifnum < 0) if (cd->bNumInterfaces > 1 && ifnum < 0)
usb_debug ("NOTICE: Your device has multiple interfaces and\n" usb_debug("NOTICE: Your device has multiple interfaces and\n"
"this driver will only use the first one. That may\n" "this driver will only use the first one. That may\n"
"be the wrong choice and cause the device to not\n" "be the wrong choice and cause the device to not\n"
"work correctly. Please report this case\n" "work correctly. Please report this case\n"
@ -483,20 +483,20 @@ set_address (hci_t *controller, usb_speed speed, int hubport, int hubaddr)
/* Find our interface (or the first good one if we don't know) */ /* Find our interface (or the first good one if we don't know) */
for (ptr = (void *)dev->configuration + sizeof(*cd); ; ptr += ptr[0]) { for (ptr = (void *)dev->configuration + sizeof(*cd); ; ptr += ptr[0]) {
if (ptr + 2 > end || !ptr[0] || ptr + ptr[0] > end) { if (ptr + 2 > end || !ptr[0] || ptr + ptr[0] > end) {
usb_debug ("Couldn't find usable DT_INTF\n"); usb_debug("Couldn't find usable DT_INTF\n");
usb_detach_device (controller, dev->address); usb_detach_device(controller, dev->address);
return -1; return -1;
} }
if (ptr[1] != DT_INTF) if (ptr[1] != DT_INTF)
continue; continue;
intf = (void *)ptr; intf = (void *)ptr;
if (intf->bLength != sizeof(*intf)) { if (intf->bLength != sizeof(*intf)) {
usb_debug ("Skipping broken DT_INTF\n"); usb_debug("Skipping broken DT_INTF\n");
continue; continue;
} }
if (ifnum >= 0 && intf->bInterfaceNumber != ifnum) if (ifnum >= 0 && intf->bInterfaceNumber != ifnum)
continue; continue;
usb_debug ("Interface %d: class 0x%x, sub 0x%x. proto 0x%x\n", usb_debug("Interface %d: class 0x%x, sub 0x%x. proto 0x%x\n",
intf->bInterfaceNumber, intf->bInterfaceClass, intf->bInterfaceNumber, intf->bInterfaceClass,
intf->bInterfaceSubClass, intf->bInterfaceProtocol); intf->bInterfaceSubClass, intf->bInterfaceProtocol);
ptr += sizeof(*intf); ptr += sizeof(*intf);
@ -516,7 +516,7 @@ set_address (hci_t *controller, usb_speed speed, int hubport, int hubaddr)
static const char *transfertypes[4] = { static const char *transfertypes[4] = {
"control", "isochronous", "bulk", "interrupt" "control", "isochronous", "bulk", "interrupt"
}; };
usb_debug (" #Endpoint %d (%s), max packet size %x, type %s\n", usb_debug(" #Endpoint %d (%s), max packet size %x, type %s\n",
desc->bEndpointAddress & 0x7f, desc->bEndpointAddress & 0x7f,
(desc->bEndpointAddress & 0x80) ? "in" : "out", (desc->bEndpointAddress & 0x80) ? "in" : "out",
desc->wMaxPacketSize, desc->wMaxPacketSize,
@ -529,15 +529,15 @@ set_address (hci_t *controller, usb_speed speed, int hubport, int hubaddr)
ep->maxpacketsize = desc->wMaxPacketSize; ep->maxpacketsize = desc->wMaxPacketSize;
ep->direction = (desc->bEndpointAddress & 0x80) ? IN : OUT; ep->direction = (desc->bEndpointAddress & 0x80) ? IN : OUT;
ep->type = desc->bmAttributes & 0x3; ep->type = desc->bmAttributes & 0x3;
ep->interval = usb_decode_interval (dev->speed, ep->type, ep->interval = usb_decode_interval(dev->speed, ep->type,
desc->bInterval); desc->bInterval);
} }
if ((controller->finish_device_config && if ((controller->finish_device_config &&
controller->finish_device_config(dev)) || controller->finish_device_config(dev)) ||
set_configuration(dev) < 0) { set_configuration(dev) < 0) {
usb_debug ("Could not finalize device configuration\n"); usb_debug("Could not finalize device configuration\n");
usb_detach_device (controller, dev->address); usb_detach_device(controller, dev->address);
return -1; return -1;
} }
@ -572,12 +572,12 @@ set_address (hci_t *controller, usb_speed speed, int hubport, int hubaddr)
usb_debug("communication\n"); usb_debug("communication\n");
break; break;
case hid_device: case hid_device:
usb_debug ("HID\n"); usb_debug("HID\n");
#if CONFIG(LP_USB_HID) #if CONFIG(LP_USB_HID)
dev->init = usb_hid_init; dev->init = usb_hid_init;
return dev->address; return dev->address;
#else #else
usb_debug ("NOTICE: USB HID support not compiled in\n"); usb_debug("NOTICE: USB HID support not compiled in\n");
#endif #endif
break; break;
case physical_device: case physical_device:
@ -590,21 +590,21 @@ set_address (hci_t *controller, usb_speed speed, int hubport, int hubaddr)
usb_debug("printer\n"); usb_debug("printer\n");
break; break;
case msc_device: case msc_device:
usb_debug ("MSC\n"); usb_debug("MSC\n");
#if CONFIG(LP_USB_MSC) #if CONFIG(LP_USB_MSC)
dev->init = usb_msc_init; dev->init = usb_msc_init;
return dev->address; return dev->address;
#else #else
usb_debug ("NOTICE: USB MSC support not compiled in\n"); usb_debug("NOTICE: USB MSC support not compiled in\n");
#endif #endif
break; break;
case hub_device: case hub_device:
usb_debug ("hub\n"); usb_debug("hub\n");
#if CONFIG(LP_USB_HUB) #if CONFIG(LP_USB_HUB)
dev->init = usb_hub_init; dev->init = usb_hub_init;
return dev->address; return dev->address;
#else #else
usb_debug ("NOTICE: USB hub support not compiled in\n"); usb_debug("NOTICE: USB hub support not compiled in\n");
#endif #endif
break; break;
case cdc_device: case cdc_device:
@ -647,7 +647,7 @@ usb_detach_device(hci_t *controller, int devno)
/* check if device exists, as we may have /* check if device exists, as we may have
been called yet by the USB class driver */ been called yet by the USB class driver */
if (controller->devices[devno]) { if (controller->devices[devno]) {
controller->devices[devno]->destroy (controller->devices[devno]); controller->devices[devno]->destroy(controller->devices[devno]);
if (controller->destroy_device) if (controller->destroy_device)
controller->destroy_device(controller, devno); controller->destroy_device(controller, devno);
@ -668,27 +668,27 @@ int
usb_attach_device(hci_t *controller, int hubaddress, int port, usb_speed speed) usb_attach_device(hci_t *controller, int hubaddress, int port, usb_speed speed)
{ {
static const char *speeds[] = { "full", "low", "high", "super", "ultra" }; static const char *speeds[] = { "full", "low", "high", "super", "ultra" };
usb_debug ("%sspeed device\n", (speed < sizeof(speeds) / sizeof(char*)) usb_debug("%sspeed device\n", (speed < sizeof(speeds) / sizeof(char*))
? speeds[speed] : "invalid value - no"); ? speeds[speed] : "invalid value - no");
int newdev = set_address (controller, speed, port, hubaddress); int newdev = set_address(controller, speed, port, hubaddress);
if (newdev == -1) if (newdev == -1)
return -1; return -1;
usbdev_t *newdev_t = controller->devices[newdev]; usbdev_t *newdev_t = controller->devices[newdev];
// determine responsible driver - current done in set_address // determine responsible driver - current done in set_address
newdev_t->init (newdev_t); newdev_t->init(newdev_t);
/* init() may have called usb_detach_device() yet, so check */ /* init() may have called usb_detach_device() yet, so check */
return controller->devices[newdev] ? newdev : -1; return controller->devices[newdev] ? newdev : -1;
} }
static void static void
usb_generic_destroy (usbdev_t *dev) usb_generic_destroy(usbdev_t *dev)
{ {
if (usb_generic_remove) if (usb_generic_remove)
usb_generic_remove(dev); usb_generic_remove(dev);
} }
void void
usb_generic_init (usbdev_t *dev) usb_generic_init(usbdev_t *dev)
{ {
dev->data = NULL; dev->data = NULL;
dev->destroy = usb_generic_destroy; dev->destroy = usb_generic_destroy;

8
payloads/libpayload/drivers/usb/usb_dev.c
View File

@ -29,22 +29,22 @@
#include <usb/usb.h> #include <usb/usb.h>
static void static void
usb_nop_destroy (usbdev_t *dev) usb_nop_destroy(usbdev_t *dev)
{ {
usb_nop_init (dev); usb_nop_init(dev);
dev->address = -1; dev->address = -1;
dev->hub = -1; dev->hub = -1;
dev->port = -1; dev->port = -1;
} }
static void static void
usb_nop_poll (usbdev_t *dev) usb_nop_poll(usbdev_t *dev)
{ {
return; return;
} }
void void
usb_nop_init (usbdev_t *dev) usb_nop_init(usbdev_t *dev)
{ {
dev->descriptor = NULL; dev->descriptor = NULL;
dev->configuration = NULL; dev->configuration = NULL;

64
payloads/libpayload/drivers/usb/usbhid.c
View File

@ -62,7 +62,7 @@ typedef struct {
#define HID_INST(dev) ((usbhid_inst_t*)(dev)->data) #define HID_INST(dev) ((usbhid_inst_t*)(dev)->data)
static void static void
usb_hid_destroy (usbdev_t *dev) usb_hid_destroy(usbdev_t *dev)
{ {
if (HID_INST(dev)->queue) { if (HID_INST(dev)->queue) {
int i; int i;
@ -82,7 +82,7 @@ usb_hid_destroy (usbdev_t *dev)
free(HID_INST(dev)->descriptor); free(HID_INST(dev)->descriptor);
HID_INST(dev)->descriptor = NULL; HID_INST(dev)->descriptor = NULL;
free (dev->data); free(dev->data);
} }
/* keybuffer is global to all USB keyboards */ /* keybuffer is global to all USB keyboards */
@ -268,14 +268,14 @@ usb_hid_process_keyboard_event(usbhid_inst_t *const inst,
if (current->modifiers & 0x01) /* Left-Ctrl */ modifiers |= KB_MOD_CTRL; if (current->modifiers & 0x01) /* Left-Ctrl */ modifiers |= KB_MOD_CTRL;
if (current->modifiers & 0x02) /* Left-Shift */ modifiers |= KB_MOD_SHIFT; if (current->modifiers & 0x02) /* Left-Shift */ modifiers |= KB_MOD_SHIFT;
if (current->modifiers & 0x04) /* Left-Alt */ modifiers |= KB_MOD_ALT; if (current->modifiers & 0x04) /* Left-Alt */ modifiers |= KB_MOD_ALT;
if (current->modifiers & 0x08) /* Left-GUI */ ; if (current->modifiers & 0x08) /* Left-GUI */;
if (current->modifiers & 0x10) /* Right-Ctrl */ modifiers |= KB_MOD_CTRL; if (current->modifiers & 0x10) /* Right-Ctrl */ modifiers |= KB_MOD_CTRL;
if (current->modifiers & 0x20) /* Right-Shift */ modifiers |= KB_MOD_SHIFT; if (current->modifiers & 0x20) /* Right-Shift */ modifiers |= KB_MOD_SHIFT;
if (current->modifiers & 0x40) /* Right-AltGr */ modifiers |= KB_MOD_ALT; if (current->modifiers & 0x40) /* Right-AltGr */ modifiers |= KB_MOD_ALT;
if (current->modifiers & 0x80) /* Right-GUI */ ; if (current->modifiers & 0x80) /* Right-GUI */;
if ((current->modifiers & 0x05) && ((current->keys[0] == 0x4c) || if ((current->modifiers & 0x05) && ((current->keys[0] == 0x4c) ||
(current->keys[0]==0x63))) { (current->keys[0] == 0x63))) {
/* vulcan nerve pinch */ /* vulcan nerve pinch */
if (reset_handler) if (reset_handler)
reset_handler(); reset_handler();
@ -297,14 +297,14 @@ usb_hid_process_keyboard_event(usbhid_inst_t *const inst,
inst->lastkeypress = 0; inst->lastkeypress = 0;
for (i=0; i<6; i++) { for (i = 0; i < 6; i++) {
int j; int j;
int skip = 0; int skip = 0;
// No more keys? skip // No more keys? skip
if (current->keys[i] == 0) if (current->keys[i] == 0)
return; return;
for (j=0; j<6; j++) { for (j = 0; j < 6; j++) {
if (current->keys[i] == previous->keys[j]) { if (current->keys[i] == previous->keys[j]) {
skip = 1; skip = 1;
break; break;
@ -328,7 +328,7 @@ usb_hid_process_keyboard_event(usbhid_inst_t *const inst,
if (keypress == -1) { if (keypress == -1) {
/* Debug: Print unknown keys */ /* Debug: Print unknown keys */
usb_debug ("usbhid: <%x> %x [ %x %x %x %x %x %x ] %d\n", usb_debug("usbhid: <%x> %x [ %x %x %x %x %x %x ] %d\n",
current->modifiers, current->repeats, current->modifiers, current->repeats,
current->keys[0], current->keys[1], current->keys[0], current->keys[1],
current->keys[2], current->keys[3], current->keys[2], current->keys[3],
@ -347,12 +347,12 @@ usb_hid_process_keyboard_event(usbhid_inst_t *const inst,
} }
static void static void
usb_hid_poll (usbdev_t *dev) usb_hid_poll(usbdev_t *dev)
{ {
usb_hid_keyboard_event_t current; usb_hid_keyboard_event_t current;
const u8 *buf; const u8 *buf;
while ((buf=dev->controller->poll_intr_queue (HID_INST(dev)->queue))) { while ((buf = dev->controller->poll_intr_queue (HID_INST(dev)->queue))) {
memcpy(&current.buffer, buf, 8); memcpy(&current.buffer, buf, 8);
usb_hid_process_keyboard_event(HID_INST(dev), &current); usb_hid_process_keyboard_event(HID_INST(dev), &current);
HID_INST(dev)->previous = current; HID_INST(dev)->previous = current;
@ -360,7 +360,7 @@ usb_hid_poll (usbdev_t *dev)
} }
static void static void
usb_hid_set_idle (usbdev_t *dev, interface_descriptor_t *interface, u16 duration) usb_hid_set_idle(usbdev_t *dev, interface_descriptor_t *interface, u16 duration)
{ {
dev_req_t dr; dev_req_t dr;
dr.data_dir = host_to_device; dr.data_dir = host_to_device;
@ -370,11 +370,11 @@ usb_hid_set_idle (usbdev_t *dev, interface_descriptor_t *interface, u16 duration
dr.wValue = (duration >> 2) << 8; dr.wValue = (duration >> 2) << 8;
dr.wIndex = interface->bInterfaceNumber; dr.wIndex = interface->bInterfaceNumber;
dr.wLength = 0; dr.wLength = 0;
dev->controller->control (dev, OUT, sizeof (dev_req_t), &dr, 0, 0); dev->controller->control(dev, OUT, sizeof(dev_req_t), &dr, 0, 0);
} }
static void static void
usb_hid_set_protocol (usbdev_t *dev, interface_descriptor_t *interface, hid_proto proto) usb_hid_set_protocol(usbdev_t *dev, interface_descriptor_t *interface, hid_proto proto)
{ {
dev_req_t dr; dev_req_t dr;
dr.data_dir = host_to_device; dr.data_dir = host_to_device;
@ -384,7 +384,7 @@ usb_hid_set_protocol (usbdev_t *dev, interface_descriptor_t *interface, hid_prot
dr.wValue = proto; dr.wValue = proto;
dr.wIndex = interface->bInterfaceNumber; dr.wIndex = interface->bInterfaceNumber;
dr.wLength = 0; dr.wLength = 0;
dev->controller->control (dev, OUT, sizeof (dev_req_t), &dr, 0, 0); dev->controller->control(dev, OUT, sizeof(dev_req_t), &dr, 0, 0);
} }
static struct console_input_driver cons = { static struct console_input_driver cons = {
@ -393,12 +393,12 @@ static struct console_input_driver cons = {
.input_type = CONSOLE_INPUT_TYPE_USB, .input_type = CONSOLE_INPUT_TYPE_USB,
}; };
static int usb_hid_set_layout (const char *country) static int usb_hid_set_layout(const char *country)
{ {
/* FIXME should be per keyboard */ /* FIXME should be per keyboard */
int i; int i;
for (i=0; i<ARRAY_SIZE(keyboard_layouts); i++) { for (i = 0; i < ARRAY_SIZE(keyboard_layouts); i++) {
if (strncmp(keyboard_layouts[i].country, country, if (strncmp(keyboard_layouts[i].country, country,
strlen(keyboard_layouts[i].country))) strlen(keyboard_layouts[i].country)))
continue; continue;
@ -417,13 +417,13 @@ static int usb_hid_set_layout (const char *country)
} }
void void
usb_hid_init (usbdev_t *dev) usb_hid_init(usbdev_t *dev)
{ {
static int installed = 0; static int installed = 0;
if (!installed) { if (!installed) {
installed = 1; installed = 1;
console_add_input_driver (&cons); console_add_input_driver(&cons);
} }
configuration_descriptor_t *cd = (configuration_descriptor_t*)dev->configuration; configuration_descriptor_t *cd = (configuration_descriptor_t*)dev->configuration;
@ -431,31 +431,31 @@ usb_hid_init (usbdev_t *dev)
if (interface->bInterfaceSubClass == hid_subclass_boot) { if (interface->bInterfaceSubClass == hid_subclass_boot) {
u8 countrycode; u8 countrycode;
usb_debug (" supports boot interface..\n"); usb_debug(" supports boot interface..\n");
usb_debug (" it's a %s\n", usb_debug(" it's a %s\n",
boot_protos[interface->bInterfaceProtocol]); boot_protos[interface->bInterfaceProtocol]);
switch (interface->bInterfaceProtocol) { switch (interface->bInterfaceProtocol) {
case hid_boot_proto_keyboard: case hid_boot_proto_keyboard:
dev->data = xzalloc (sizeof (usbhid_inst_t)); dev->data = xzalloc(sizeof(usbhid_inst_t));
usb_debug (" configuring...\n"); usb_debug(" configuring...\n");
usb_hid_set_protocol(dev, interface, hid_proto_boot); usb_hid_set_protocol(dev, interface, hid_proto_boot);
usb_hid_set_idle(dev, interface, KEYBOARD_REPEAT_MS); usb_hid_set_idle(dev, interface, KEYBOARD_REPEAT_MS);
usb_debug (" activating...\n"); usb_debug(" activating...\n");
hid_descriptor_t *desc = malloc(sizeof(hid_descriptor_t)); hid_descriptor_t *desc = malloc(sizeof(hid_descriptor_t));
if (!desc || get_descriptor(dev, gen_bmRequestType( if (!desc || get_descriptor(dev, gen_bmRequestType(
device_to_host, standard_type, iface_recp), device_to_host, standard_type, iface_recp),
0x21, 0, desc, sizeof(*desc)) != sizeof(*desc)) { 0x21, 0, desc, sizeof(*desc)) != sizeof(*desc)) {
usb_debug ("get_descriptor(HID) failed\n"); usb_debug("get_descriptor(HID) failed\n");
usb_detach_device (dev->controller, dev->address); usb_detach_device(dev->controller, dev->address);
return; return;
} }
HID_INST (dev)->descriptor = desc; HID_INST(dev)->descriptor = desc;
countrycode = desc->bCountryCode; countrycode = desc->bCountryCode;
/* 35 countries defined: */ /* 35 countries defined: */
if (countrycode >= ARRAY_SIZE(countries)) if (countrycode >= ARRAY_SIZE(countries))
countrycode = 0; countrycode = 0;
usb_debug (" Keyboard has %s layout (country code %02x)\n", usb_debug(" Keyboard has %s layout (country code %02x)\n",
countries[countrycode][0], countrycode); countries[countrycode][0], countrycode);
/* Set keyboard layout accordingly */ /* Set keyboard layout accordingly */
@ -473,15 +473,15 @@ usb_hid_init (usbdev_t *dev)
break; break;
} }
if (i >= dev->num_endp) { if (i >= dev->num_endp) {
usb_debug ("Could not find HID endpoint\n"); usb_debug("Could not find HID endpoint\n");
usb_detach_device (dev->controller, dev->address); usb_detach_device(dev->controller, dev->address);
return; return;
} }
usb_debug (" found endpoint %x for interrupt-in\n", i); usb_debug(" found endpoint %x for interrupt-in\n", i);
/* 20 buffers of 8 bytes, for every 10 msecs */ /* 20 buffers of 8 bytes, for every 10 msecs */
HID_INST(dev)->queue = dev->controller->create_intr_queue (&dev->endpoints[i], 8, 20, 10); HID_INST(dev)->queue = dev->controller->create_intr_queue(&dev->endpoints[i], 8, 20, 10);
keycount = 0; keycount = 0;
usb_debug (" configuration done.\n"); usb_debug(" configuration done.\n");
break; break;
case hid_boot_proto_mouse: case hid_boot_proto_mouse:
usb_debug("NOTICE: USB mice are not supported.\n"); usb_debug("NOTICE: USB mice are not supported.\n");

14
payloads/libpayload/drivers/usb/usbhub.c
View File

@ -72,11 +72,11 @@ static int
usb_hub_port_status_changed(usbdev_t *const dev, const int port) usb_hub_port_status_changed(usbdev_t *const dev, const int port)
{ {
unsigned short buf[2]; unsigned short buf[2];
int ret = get_status (dev, port, DR_PORT, sizeof(buf), buf); int ret = get_status(dev, port, DR_PORT, sizeof(buf), buf);
if (ret >= 0) { if (ret >= 0) {
ret = buf[1] & PORT_CONNECTION; ret = buf[1] & PORT_CONNECTION;
if (ret) if (ret)
clear_feature (dev, port, SEL_C_PORT_CONNECTION, clear_feature(dev, port, SEL_C_PORT_CONNECTION,
DR_PORT); DR_PORT);
} }
return ret; return ret;
@ -86,7 +86,7 @@ static int
usb_hub_port_connected(usbdev_t *const dev, const int port) usb_hub_port_connected(usbdev_t *const dev, const int port)
{ {
unsigned short buf[2]; unsigned short buf[2];
int ret = get_status (dev, port, DR_PORT, sizeof(buf), buf); int ret = get_status(dev, port, DR_PORT, sizeof(buf), buf);
if (ret >= 0) if (ret >= 0)
ret = buf[0] & PORT_CONNECTION; ret = buf[0] & PORT_CONNECTION;
return ret; return ret;
@ -96,7 +96,7 @@ static int
usb_hub_port_in_reset(usbdev_t *const dev, const int port) usb_hub_port_in_reset(usbdev_t *const dev, const int port)
{ {
unsigned short buf[2]; unsigned short buf[2];
int ret = get_status (dev, port, DR_PORT, sizeof(buf), buf); int ret = get_status(dev, port, DR_PORT, sizeof(buf), buf);
if (ret >= 0) if (ret >= 0)
ret = buf[0] & PORT_RESET; ret = buf[0] & PORT_RESET;
return ret; return ret;
@ -106,7 +106,7 @@ static int
usb_hub_port_enabled(usbdev_t *const dev, const int port) usb_hub_port_enabled(usbdev_t *const dev, const int port)
{ {
unsigned short buf[2]; unsigned short buf[2];
int ret = get_status (dev, port, DR_PORT, sizeof(buf), buf); int ret = get_status(dev, port, DR_PORT, sizeof(buf), buf);
if (ret >= 0) if (ret >= 0)
ret = buf[0] & PORT_ENABLE; ret = buf[0] & PORT_ENABLE;
return ret; return ret;
@ -116,7 +116,7 @@ static usb_speed
usb_hub_port_speed(usbdev_t *const dev, const int port) usb_hub_port_speed(usbdev_t *const dev, const int port)
{ {
unsigned short buf[2]; unsigned short buf[2];
int ret = get_status (dev, port, DR_PORT, sizeof(buf), buf); int ret = get_status(dev, port, DR_PORT, sizeof(buf), buf);
if (ret >= 0 && (buf[0] & PORT_ENABLE)) { if (ret >= 0 && (buf[0] & PORT_ENABLE)) {
/* SuperSpeed hubs can only have SuperSpeed devices. */ /* SuperSpeed hubs can only have SuperSpeed devices. */
if (is_usb_speed_ss(dev->speed)) if (is_usb_speed_ss(dev->speed))
@ -144,7 +144,7 @@ usb_hub_enable_port(usbdev_t *const dev, const int port)
static int static int
usb_hub_start_port_reset(usbdev_t *const dev, const int port) usb_hub_start_port_reset(usbdev_t *const dev, const int port)
{ {
return set_feature (dev, port, SEL_PORT_RESET, DR_PORT); return set_feature(dev, port, SEL_PORT_RESET, DR_PORT);
} }
static void usb_hub_set_hub_depth(usbdev_t *const dev) static void usb_hub_set_hub_depth(usbdev_t *const dev)

4
payloads/libpayload/drivers/usb/usbinit.c
View File

@ -52,7 +52,7 @@ static int usb_controller_initialize(int bus, int dev, int func)
pcidev_t pci_device; pcidev_t pci_device;
u32 pciid; u32 pciid;
pci_device = PCI_DEV (bus, dev, func); pci_device = PCI_DEV(bus, dev, func);
class = pci_read_config32(pci_device, 8); class = pci_read_config32(pci_device, 8);
pciid = pci_read_config32(pci_device, 0); pciid = pci_read_config32(pci_device, 0);
@ -73,7 +73,7 @@ static int usb_controller_initialize(int bus, int dev, int func)
case 0x00: case 0x00:
#if CONFIG(LP_USB_UHCI) #if CONFIG(LP_USB_UHCI)
usb_debug("UHCI controller\n"); usb_debug("UHCI controller\n");
uhci_pci_init (pci_device); uhci_pci_init(pci_device);
#else #else
usb_debug("UHCI controller (not supported)\n"); usb_debug("UHCI controller (not supported)\n");
#endif #endif

300
payloads/libpayload/drivers/usb/usbmsc.c
View File

@ -67,29 +67,29 @@ static const char *msc_protocol_strings[0x51] = {
}; };
static void static void
usb_msc_create_disk (usbdev_t *dev) usb_msc_create_disk(usbdev_t *dev)
{ {
if (usbdisk_create) { if (usbdisk_create) {
usbdisk_create (dev); usbdisk_create(dev);
MSC_INST (dev)->usbdisk_created = 1; MSC_INST(dev)->usbdisk_created = 1;
} }
} }
static void static void
usb_msc_remove_disk (usbdev_t *dev) usb_msc_remove_disk(usbdev_t *dev)
{ {
if (MSC_INST (dev)->usbdisk_created && usbdisk_remove) { if (MSC_INST(dev)->usbdisk_created && usbdisk_remove) {
usbdisk_remove (dev); usbdisk_remove(dev);
MSC_INST (dev)->usbdisk_created = 0; MSC_INST(dev)->usbdisk_created = 0;
} }
} }
static void static void
usb_msc_destroy (usbdev_t *dev) usb_msc_destroy(usbdev_t *dev)
{ {
if (dev->data) { if (dev->data) {
usb_msc_remove_disk (dev); usb_msc_remove_disk(dev);
free (dev->data); free(dev->data);
} }
dev->data = 0; dev->data = 0;
} }
@ -136,17 +136,17 @@ enum {
}; };
static int static int
request_sense (usbdev_t *dev); request_sense(usbdev_t *dev);
static int static int
request_sense_no_media (usbdev_t *dev); request_sense_no_media(usbdev_t *dev);
static void static void
usb_msc_poll (usbdev_t *dev); usb_msc_poll(usbdev_t *dev);
static int static int
reset_transport (usbdev_t *dev) reset_transport(usbdev_t *dev)
{ {
dev_req_t dr; dev_req_t dr;
memset (&dr, 0, sizeof (dr)); memset(&dr, 0, sizeof(dr));
dr.bmRequestType = 0; dr.bmRequestType = 0;
dr.data_dir = host_to_device; dr.data_dir = host_to_device;
#ifndef QEMU #ifndef QEMU
@ -158,15 +158,15 @@ reset_transport (usbdev_t *dev)
dr.wIndex = 0; dr.wIndex = 0;
dr.wLength = 0; dr.wLength = 0;
if (MSC_INST (dev)->quirks & USB_MSC_QUIRK_NO_RESET) if (MSC_INST(dev)->quirks & USB_MSC_QUIRK_NO_RESET)
return MSC_COMMAND_FAIL; return MSC_COMMAND_FAIL;
/* if any of these fails, detach device, as we are lost */ /* if any of these fails, detach device, as we are lost */
if (dev->controller->control (dev, OUT, sizeof (dr), &dr, 0, 0) < 0 || if (dev->controller->control(dev, OUT, sizeof(dr), &dr, 0, 0) < 0 ||
clear_stall (MSC_INST (dev)->bulk_in) || clear_stall(MSC_INST(dev)->bulk_in) ||
clear_stall (MSC_INST (dev)->bulk_out)) { clear_stall(MSC_INST(dev)->bulk_out)) {
usb_debug ("Detaching unresponsive device.\n"); usb_debug("Detaching unresponsive device.\n");
usb_detach_device (dev->controller, dev->address); usb_detach_device(dev->controller, dev->address);
return MSC_COMMAND_DETACHED; return MSC_COMMAND_DETACHED;
} }
/* return fail as we are only called in case of failure */ /* return fail as we are only called in case of failure */
@ -175,9 +175,9 @@ reset_transport (usbdev_t *dev)
/* device may stall this command, so beware! */ /* device may stall this command, so beware! */
static void static void
initialize_luns (usbdev_t *dev) initialize_luns(usbdev_t *dev)
{ {
usbmsc_inst_t *msc = MSC_INST (dev); usbmsc_inst_t *msc = MSC_INST(dev);
dev_req_t dr; dev_req_t dr;
dr.bmRequestType = 0; dr.bmRequestType = 0;
dr.data_dir = device_to_host; dr.data_dir = device_to_host;
@ -189,9 +189,9 @@ initialize_luns (usbdev_t *dev)
dr.wValue = 0; dr.wValue = 0;
dr.wIndex = 0; dr.wIndex = 0;
dr.wLength = 1; dr.wLength = 1;
if (MSC_INST (dev)->quirks & USB_MSC_QUIRK_NO_LUNS || if (MSC_INST(dev)->quirks & USB_MSC_QUIRK_NO_LUNS ||
dev->controller->control (dev, IN, sizeof (dr), &dr, dev->controller->control(dev, IN, sizeof(dr), &dr,
sizeof (msc->num_luns), &msc->num_luns) < 0) sizeof(msc->num_luns), &msc->num_luns) < 0)
msc->num_luns = 0; /* assume only 1 lun if req fails */ msc->num_luns = 0; /* assume only 1 lun if req fails */
msc->num_luns++; /* Get Max LUN returns number of last LUN */ msc->num_luns++; /* Get Max LUN returns number of last LUN */
msc->lun = 0; msc->lun = 0;
@ -200,10 +200,10 @@ initialize_luns (usbdev_t *dev)
unsigned int tag; unsigned int tag;
static void static void
wrap_cbw (cbw_t *cbw, int datalen, cbw_direction dir, const u8 *cmd, wrap_cbw(cbw_t *cbw, int datalen, cbw_direction dir, const u8 *cmd,
int cmdlen, u8 lun) int cmdlen, u8 lun)
{ {
memset (cbw, 0, sizeof (cbw_t)); memset(cbw, 0, sizeof(cbw_t));
/* commands are typically shorter, but we don't want overflows */ /* commands are typically shorter, but we don't want overflows */
if (cmdlen > sizeof(cbw->CBWCB)) { if (cmdlen > sizeof(cbw->CBWCB)) {
@ -216,37 +216,37 @@ wrap_cbw (cbw_t *cbw, int datalen, cbw_direction dir, const u8 *cmd,
cbw->dCBWDataTransferLength = datalen; cbw->dCBWDataTransferLength = datalen;
cbw->bmCBWFlags = dir; cbw->bmCBWFlags = dir;
memcpy (cbw->CBWCB, cmd, cmdlen); memcpy(cbw->CBWCB, cmd, cmdlen);
cbw->bCBWCBLength = cmdlen; cbw->bCBWCBLength = cmdlen;
} }
static int static int
get_csw (endpoint_t *ep, csw_t *csw) get_csw(endpoint_t *ep, csw_t *csw)
{ {
hci_t *ctrlr = ep->dev->controller; hci_t *ctrlr = ep->dev->controller;
int ret = ctrlr->bulk (ep, sizeof (csw_t), (u8 *) csw, 1); int ret = ctrlr->bulk(ep, sizeof(csw_t), (u8 *) csw, 1);
/* Some broken sticks send a zero-length packet at the end of their data /* Some broken sticks send a zero-length packet at the end of their data
transfer which would show up here. Skip it to get the actual CSW. */ transfer which would show up here. Skip it to get the actual CSW. */
if (ret == 0) if (ret == 0)
ret = ctrlr->bulk (ep, sizeof (csw_t), (u8 *) csw, 1); ret = ctrlr->bulk(ep, sizeof(csw_t), (u8 *) csw, 1);
if (ret < 0) { if (ret < 0) {
clear_stall (ep); clear_stall(ep);
ret = ctrlr->bulk (ep, sizeof (csw_t), (u8 *) csw, 1); ret = ctrlr->bulk(ep, sizeof(csw_t), (u8 *) csw, 1);
if (ret < 0) if (ret < 0)
return reset_transport (ep->dev); return reset_transport(ep->dev);
} }
if (ret != sizeof(csw_t) || csw->dCSWTag != tag || if (ret != sizeof(csw_t) || csw->dCSWTag != tag ||
csw->dCSWSignature != csw_signature) { csw->dCSWSignature != csw_signature) {
usb_debug ("MSC: received malformed CSW\n"); usb_debug("MSC: received malformed CSW\n");
return reset_transport (ep->dev); return reset_transport(ep->dev);
} }
return MSC_COMMAND_OK; return MSC_COMMAND_OK;
} }
static int static int
execute_command (usbdev_t *dev, cbw_direction dir, const u8 *cb, int cblen, execute_command(usbdev_t *dev, cbw_direction dir, const u8 *cb, int cblen,
u8 *buf, int buflen, int residue_ok) u8 *buf, int buflen, int residue_ok)
{ {
cbw_t cbw; cbw_t cbw;
@ -256,23 +256,23 @@ execute_command (usbdev_t *dev, cbw_direction dir, const u8 *cb, int cblen,
if ((cb[0] == 0x1b) && (cb[4] == 1)) { //start command, always succeed if ((cb[0] == 0x1b) && (cb[4] == 1)) { //start command, always succeed
always_succeed = 1; always_succeed = 1;
} }
wrap_cbw (&cbw, buflen, dir, cb, cblen, MSC_INST (dev)->lun); wrap_cbw(&cbw, buflen, dir, cb, cblen, MSC_INST(dev)->lun);
if (dev->controller-> if (dev->controller->
bulk (MSC_INST (dev)->bulk_out, sizeof (cbw), (u8 *) &cbw, 0) < 0) { bulk(MSC_INST(dev)->bulk_out, sizeof(cbw), (u8 *) &cbw, 0) < 0) {
return reset_transport (dev); return reset_transport(dev);
} }
if (buflen > 0) { if (buflen > 0) {
if (dir == cbw_direction_data_in) { if (dir == cbw_direction_data_in) {
if (dev->controller-> if (dev->controller->
bulk (MSC_INST (dev)->bulk_in, buflen, buf, 0) < 0) bulk(MSC_INST(dev)->bulk_in, buflen, buf, 0) < 0)
clear_stall (MSC_INST (dev)->bulk_in); clear_stall(MSC_INST(dev)->bulk_in);
} else { } else {
if (dev->controller-> if (dev->controller->
bulk (MSC_INST (dev)->bulk_out, buflen, buf, 0) < 0) bulk(MSC_INST(dev)->bulk_out, buflen, buf, 0) < 0)
clear_stall (MSC_INST (dev)->bulk_out); clear_stall(MSC_INST(dev)->bulk_out);
} }
} }
int ret = get_csw (MSC_INST (dev)->bulk_in, &csw); int ret = get_csw(MSC_INST(dev)->bulk_in, &csw);
if (ret) { if (ret) {
return ret; return ret;
} else if (always_succeed == 1) { } else if (always_succeed == 1) {
@ -280,7 +280,7 @@ execute_command (usbdev_t *dev, cbw_direction dir, const u8 *cb, int cblen,
return MSC_COMMAND_OK; return MSC_COMMAND_OK;
} else if (csw.bCSWStatus == 2) { } else if (csw.bCSWStatus == 2) {
/* phase error, reset transport */ /* phase error, reset transport */
return reset_transport (dev); return reset_transport(dev);
} else if (csw.bCSWStatus == 0) { } else if (csw.bCSWStatus == 0) {
if ((csw.dCSWDataResidue == 0) || residue_ok) if ((csw.dCSWDataResidue == 0) || residue_ok)
/* no error, exit */ /* no error, exit */
@ -296,9 +296,9 @@ execute_command (usbdev_t *dev, cbw_direction dir, const u8 *cb, int cblen,
/* If command was TEST UNIT READY determine if the /* If command was TEST UNIT READY determine if the
* device is of removable type indicating no media * device is of removable type indicating no media
* found. */ * found. */
return request_sense_no_media (dev); return request_sense_no_media(dev);
/* error "check condition" or reserved error */ /* error "check condition" or reserved error */
ret = request_sense (dev); ret = request_sense(dev);
/* return fail or the status of request_sense if it's worse */ /* return fail or the status of request_sense if it's worse */
return ret ? ret : MSC_COMMAND_FAIL; return ret ? ret : MSC_COMMAND_FAIL;
} }
@ -342,11 +342,11 @@ typedef struct {
* @return 0 on success, 1 on failure * @return 0 on success, 1 on failure
*/ */
int int
readwrite_blocks_512 (usbdev_t *dev, int start, int n, readwrite_blocks_512(usbdev_t *dev, int start, int n,
cbw_direction dir, u8 *buf) cbw_direction dir, u8 *buf)
{ {
int blocksize_divider = MSC_INST(dev)->blocksize / 512; int blocksize_divider = MSC_INST(dev)->blocksize / 512;
return readwrite_blocks (dev, start / blocksize_divider, return readwrite_blocks(dev, start / blocksize_divider,
n / blocksize_divider, dir, buf); n / blocksize_divider, dir, buf);
} }
@ -363,10 +363,10 @@ readwrite_blocks_512 (usbdev_t *dev, int start, int n,
* @return 0 on success, 1 on failure * @return 0 on success, 1 on failure
*/ */
static int static int
readwrite_chunk (usbdev_t *dev, int start, int n, cbw_direction dir, u8 *buf) readwrite_chunk(usbdev_t *dev, int start, int n, cbw_direction dir, u8 *buf)
{ {
cmdblock_t cb; cmdblock_t cb;
memset (&cb, 0, sizeof (cb)); memset(&cb, 0, sizeof(cb));
if (dir == cbw_direction_data_in) { if (dir == cbw_direction_data_in) {
// read // read
cb.command = 0x28; cb.command = 0x28;
@ -374,10 +374,10 @@ readwrite_chunk (usbdev_t *dev, int start, int n, cbw_direction dir, u8 *buf)
// write // write
cb.command = 0x2a; cb.command = 0x2a;
} }
cb.block = htonl (start); cb.block = htonl(start);
cb.numblocks = htonw (n); cb.numblocks = htonw(n);
return execute_command (dev, dir, (u8 *) &cb, sizeof (cb), buf, return execute_command(dev, dir, (u8 *) &cb, sizeof(cb), buf,
n * MSC_INST(dev)->blocksize, 0) n * MSC_INST(dev)->blocksize, 0)
!= MSC_COMMAND_OK ? 1 : 0; != MSC_COMMAND_OK ? 1 : 0;
} }
@ -399,14 +399,14 @@ readwrite_chunk (usbdev_t *dev, int start, int n, cbw_direction dir, u8 *buf)
* @return 0 on success, 1 on failure * @return 0 on success, 1 on failure
*/ */
int int
readwrite_blocks (usbdev_t *dev, int start, int n, cbw_direction dir, u8 *buf) readwrite_blocks(usbdev_t *dev, int start, int n, cbw_direction dir, u8 *buf)
{ {
int chunk_size = MAX_CHUNK_BYTES / MSC_INST(dev)->blocksize; int chunk_size = MAX_CHUNK_BYTES / MSC_INST(dev)->blocksize;
int chunk; int chunk;
/* Read as many full chunks as needed. */ /* Read as many full chunks as needed. */
for (chunk = 0; chunk < (n / chunk_size); chunk++) { for (chunk = 0; chunk < (n / chunk_size); chunk++) {
if (readwrite_chunk (dev, start + (chunk * chunk_size), if (readwrite_chunk(dev, start + (chunk * chunk_size),
chunk_size, dir, chunk_size, dir,
buf + (chunk * MAX_CHUNK_BYTES)) buf + (chunk * MAX_CHUNK_BYTES))
!= MSC_COMMAND_OK) != MSC_COMMAND_OK)
@ -415,7 +415,7 @@ readwrite_blocks (usbdev_t *dev, int start, int n, cbw_direction dir, u8 *buf)
/* Read any remaining partial chunk at the end. */ /* Read any remaining partial chunk at the end. */
if (n % chunk_size) { if (n % chunk_size) {
if (readwrite_chunk (dev, start + (chunk * chunk_size), if (readwrite_chunk(dev, start + (chunk * chunk_size),
n % chunk_size, dir, n % chunk_size, dir,
buf + (chunk * MAX_CHUNK_BYTES)) buf + (chunk * MAX_CHUNK_BYTES))
!= MSC_COMMAND_OK) != MSC_COMMAND_OK)
@ -429,29 +429,29 @@ readwrite_blocks (usbdev_t *dev, int start, int n, cbw_direction dir, u8 *buf)
On certain errors, that's necessary to get devices out of On certain errors, that's necessary to get devices out of
a special state called "Contingent Allegiance Condition" */ a special state called "Contingent Allegiance Condition" */
static int static int
request_sense (usbdev_t *dev) request_sense(usbdev_t *dev)
{ {
u8 buf[19]; u8 buf[19];
cmdblock6_t cb; cmdblock6_t cb;
memset (&cb, 0, sizeof (cb)); memset(&cb, 0, sizeof(cb));
cb.command = 0x3; cb.command = 0x3;
cb.length = sizeof (buf); cb.length = sizeof(buf);
return execute_command (dev, cbw_direction_data_in, (u8 *) &cb, return execute_command(dev, cbw_direction_data_in, (u8 *) &cb,
sizeof (cb), buf, sizeof (buf), 1); sizeof(cb), buf, sizeof(buf), 1);
} }
static int request_sense_no_media (usbdev_t *dev) static int request_sense_no_media(usbdev_t *dev)
{ {
u8 buf[19]; u8 buf[19];
int ret; int ret;
cmdblock6_t cb; cmdblock6_t cb;
memset (&cb, 0, sizeof (cb)); memset(&cb, 0, sizeof(cb));
cb.command = 0x3; cb.command = 0x3;
cb.length = sizeof (buf); cb.length = sizeof(buf);
ret = execute_command (dev, cbw_direction_data_in, (u8 *) &cb, ret = execute_command(dev, cbw_direction_data_in, (u8 *) &cb,
sizeof (cb), buf, sizeof (buf), 1); sizeof(cb), buf, sizeof(buf), 1);
if (ret) if (ret)
return ret; return ret;
@ -466,45 +466,45 @@ static int request_sense_no_media (usbdev_t *dev)
/* No media is present. Return MSC_COMMAND_OK while marking the disk /* No media is present. Return MSC_COMMAND_OK while marking the disk
* not ready. */ * not ready. */
usb_debug ("Empty media found.\n"); usb_debug("Empty media found.\n");
MSC_INST (dev)->ready = USB_MSC_NOT_READY; MSC_INST(dev)->ready = USB_MSC_NOT_READY;
return MSC_COMMAND_OK; return MSC_COMMAND_OK;
} }
static int static int
test_unit_ready (usbdev_t *dev) test_unit_ready(usbdev_t *dev)
{ {
cmdblock6_t cb; cmdblock6_t cb;
memset (&cb, 0, sizeof (cb)); // full initialization for T-U-R memset(&cb, 0, sizeof(cb)); // full initialization for T-U-R
return execute_command (dev, cbw_direction_data_out, (u8 *) &cb, return execute_command(dev, cbw_direction_data_out, (u8 *) &cb,
sizeof (cb), 0, 0, 0); sizeof(cb), 0, 0, 0);
} }
static int static int
spin_up (usbdev_t *dev) spin_up(usbdev_t *dev)
{ {
cmdblock6_t cb; cmdblock6_t cb;
memset (&cb, 0, sizeof (cb)); memset(&cb, 0, sizeof(cb));
cb.command = 0x1b; cb.command = 0x1b;
cb.start = 1; cb.start = 1;
return execute_command (dev, cbw_direction_data_out, (u8 *) &cb, return execute_command(dev, cbw_direction_data_out, (u8 *) &cb,
sizeof (cb), 0, 0, 0); sizeof(cb), 0, 0, 0);
} }
static int static int
read_capacity (usbdev_t *dev) read_capacity(usbdev_t *dev)
{ {
cmdblock_t cb; cmdblock_t cb;
memset (&cb, 0, sizeof (cb)); memset(&cb, 0, sizeof(cb));
cb.command = 0x25; // read capacity cb.command = 0x25; // read capacity
u32 buf[2]; u32 buf[2];
usb_debug ("Reading capacity of mass storage device.\n"); usb_debug("Reading capacity of mass storage device.\n");
int count = 0, ret; int count = 0, ret;
while (count++ < 20) { while (count++ < 20) {
switch (ret = execute_command switch (ret = execute_command
(dev, cbw_direction_data_in, (u8 *) &cb, (dev, cbw_direction_data_in, (u8 *) &cb,
sizeof (cb), (u8 *)buf, 8, 0)) { sizeof(cb), (u8 *)buf, 8, 0)) {
case MSC_COMMAND_OK: case MSC_COMMAND_OK:
break; break;
case MSC_COMMAND_FAIL: case MSC_COMMAND_FAIL:
@ -516,24 +516,24 @@ read_capacity (usbdev_t *dev)
} }
if (count >= 20) { if (count >= 20) {
// still not successful, assume 2tb in 512byte sectors, which is just the same garbage as any other number, but probably more usable. // still not successful, assume 2tb in 512byte sectors, which is just the same garbage as any other number, but probably more usable.
usb_debug (" assuming 2 TB with 512-byte sectors as READ CAPACITY didn't answer.\n"); usb_debug(" assuming 2 TB with 512-byte sectors as READ CAPACITY didn't answer.\n");
MSC_INST (dev)->numblocks = 0xffffffff; MSC_INST(dev)->numblocks = 0xffffffff;
MSC_INST (dev)->blocksize = 512; MSC_INST(dev)->blocksize = 512;
} else { } else {
MSC_INST (dev)->numblocks = ntohl(buf[0]) + 1; MSC_INST(dev)->numblocks = ntohl(buf[0]) + 1;
MSC_INST (dev)->blocksize = ntohl(buf[1]); MSC_INST(dev)->blocksize = ntohl(buf[1]);
} }
usb_debug (" %d %d-byte sectors (%d MB)\n", MSC_INST (dev)->numblocks, usb_debug(" %d %d-byte sectors (%d MB)\n", MSC_INST(dev)->numblocks,
MSC_INST (dev)->blocksize, MSC_INST(dev)->blocksize,
/* round down high block counts to avoid integer overflow */ /* round down high block counts to avoid integer overflow */
MSC_INST (dev)->numblocks > 1000000 MSC_INST(dev)->numblocks > 1000000
? (MSC_INST (dev)->numblocks / 1000) * MSC_INST (dev)->blocksize / 1000 : ? (MSC_INST(dev)->numblocks / 1000) * MSC_INST(dev)->blocksize / 1000 :
MSC_INST (dev)->numblocks * MSC_INST (dev)->blocksize / 1000 / 1000); MSC_INST(dev)->numblocks * MSC_INST(dev)->blocksize / 1000 / 1000);
return MSC_COMMAND_OK; return MSC_COMMAND_OK;
} }
static int static int
usb_msc_test_unit_ready (usbdev_t *dev) usb_msc_test_unit_ready(usbdev_t *dev)
{ {
int i; int i;
time_t start_time_secs; time_t start_time_secs;
@ -543,21 +543,21 @@ usb_msc_test_unit_ready (usbdev_t *dev)
* devices which fail to respond. */ * devices which fail to respond. */
const int timeout_secs = 5; const int timeout_secs = 5;
usb_debug (" Waiting for device to become ready..."); usb_debug(" Waiting for device to become ready...");
/* Initially mark the device ready. */ /* Initially mark the device ready. */
MSC_INST (dev)->ready = USB_MSC_READY; MSC_INST(dev)->ready = USB_MSC_READY;
gettimeofday (&tv, NULL); gettimeofday(&tv, NULL);
start_time_secs = tv.tv_sec; start_time_secs = tv.tv_sec;
while (tv.tv_sec - start_time_secs < timeout_secs) { while (tv.tv_sec - start_time_secs < timeout_secs) {
switch (test_unit_ready (dev)) { switch (test_unit_ready(dev)) {
case MSC_COMMAND_OK: case MSC_COMMAND_OK:
break; break;
case MSC_COMMAND_FAIL: case MSC_COMMAND_FAIL:
mdelay (100); mdelay(100);
usb_debug ("."); usb_debug(".");
gettimeofday (&tv, NULL); gettimeofday(&tv, NULL);
continue; continue;
default: default:
/* Device detached, return immediately */ /* Device detached, return immediately */
@ -566,27 +566,27 @@ usb_msc_test_unit_ready (usbdev_t *dev)
break; break;
} }
if (!(tv.tv_sec - start_time_secs < timeout_secs)) { if (!(tv.tv_sec - start_time_secs < timeout_secs)) {
usb_debug ("timeout. Device not ready.\n"); usb_debug("timeout. Device not ready.\n");
MSC_INST (dev)->ready = USB_MSC_NOT_READY; MSC_INST(dev)->ready = USB_MSC_NOT_READY;
} }
/* Don't bother spinning up the storage device if the device is not /* Don't bother spinning up the storage device if the device is not
* ready. This can happen when empty card readers are present. * ready. This can happen when empty card readers are present.
* Polling will pick it back up if readiness changes. */ * Polling will pick it back up if readiness changes. */
if (!MSC_INST (dev)->ready) if (!MSC_INST(dev)->ready)
return MSC_INST (dev)->ready; return MSC_INST(dev)->ready;
usb_debug ("ok.\n"); usb_debug("ok.\n");
usb_debug (" spin up"); usb_debug(" spin up");
for (i = 0; i < 30; i++) { for (i = 0; i < 30; i++) {
usb_debug ("."); usb_debug(".");
switch (spin_up (dev)) { switch (spin_up(dev)) {
case MSC_COMMAND_OK: case MSC_COMMAND_OK:
usb_debug (" OK."); usb_debug(" OK.");
break; break;
case MSC_COMMAND_FAIL: case MSC_COMMAND_FAIL:
mdelay (100); mdelay(100);
continue; continue;
default: default:
/* Device detached, return immediately */ /* Device detached, return immediately */
@ -594,30 +594,30 @@ usb_msc_test_unit_ready (usbdev_t *dev)
} }
break; break;
} }
usb_debug ("\n"); usb_debug("\n");
if (read_capacity (dev) == MSC_COMMAND_DETACHED) if (read_capacity(dev) == MSC_COMMAND_DETACHED)
return USB_MSC_DETACHED; return USB_MSC_DETACHED;
return MSC_INST (dev)->ready; return MSC_INST(dev)->ready;
} }
void void
usb_msc_init (usbdev_t *dev) usb_msc_init(usbdev_t *dev)
{ {
configuration_descriptor_t *cd = configuration_descriptor_t *cd =
(configuration_descriptor_t *) dev->configuration; (configuration_descriptor_t *) dev->configuration;
interface_descriptor_t *interface = interface_descriptor_t *interface =
(interface_descriptor_t *) (((char *) cd) + cd->bLength); (interface_descriptor_t *) (((char *) cd) + cd->bLength);
usb_debug (" it uses %s command set\n", usb_debug(" it uses %s command set\n",
msc_subclass_strings[interface->bInterfaceSubClass]); msc_subclass_strings[interface->bInterfaceSubClass]);
usb_debug (" it uses %s protocol\n", usb_debug(" it uses %s protocol\n",
msc_protocol_strings[interface->bInterfaceProtocol]); msc_protocol_strings[interface->bInterfaceProtocol]);
if (interface->bInterfaceProtocol != 0x50) { if (interface->bInterfaceProtocol != 0x50) {
usb_debug (" Protocol not supported.\n"); usb_debug(" Protocol not supported.\n");
usb_detach_device (dev->controller, dev->address); usb_detach_device(dev->controller, dev->address);
return; return;
} }
@ -625,15 +625,15 @@ usb_msc_init (usbdev_t *dev)
(interface->bInterfaceSubClass != 5) && // ATAPI 8070 (interface->bInterfaceSubClass != 5) && // ATAPI 8070
(interface->bInterfaceSubClass != 6)) { // SCSI (interface->bInterfaceSubClass != 6)) { // SCSI
/* Other protocols, such as ATAPI don't seem to be very popular. looks like ATAPI would be really easy to add, if necessary. */ /* Other protocols, such as ATAPI don't seem to be very popular. looks like ATAPI would be really easy to add, if necessary. */
usb_debug (" Interface SubClass not supported.\n"); usb_debug(" Interface SubClass not supported.\n");
usb_detach_device (dev->controller, dev->address); usb_detach_device(dev->controller, dev->address);
return; return;
} }
usb_msc_force_init (dev, 0); usb_msc_force_init(dev, 0);
} }
void usb_msc_force_init (usbdev_t *dev, u32 quirks) void usb_msc_force_init(usbdev_t *dev, u32 quirks)
{ {
int i; int i;
@ -643,14 +643,14 @@ void usb_msc_force_init (usbdev_t *dev, u32 quirks)
dev->destroy = usb_msc_destroy; dev->destroy = usb_msc_destroy;
dev->poll = usb_msc_poll; dev->poll = usb_msc_poll;
dev->data = malloc (sizeof (usbmsc_inst_t)); dev->data = malloc(sizeof(usbmsc_inst_t));
if (!dev->data) if (!dev->data)
fatal("Not enough memory for USB MSC device.\n"); fatal("Not enough memory for USB MSC device.\n");
MSC_INST (dev)->bulk_in = 0; MSC_INST(dev)->bulk_in = 0;
MSC_INST (dev)->bulk_out = 0; MSC_INST(dev)->bulk_out = 0;
MSC_INST (dev)->usbdisk_created = 0; MSC_INST(dev)->usbdisk_created = 0;
MSC_INST (dev)->quirks = quirks; MSC_INST(dev)->quirks = quirks;
for (i = 1; i <= dev->num_endp; i++) { for (i = 1; i <= dev->num_endp; i++) {
if (dev->endpoints[i].endpoint == 0) if (dev->endpoints[i].endpoint == 0)
@ -658,56 +658,56 @@ void usb_msc_force_init (usbdev_t *dev, u32 quirks)
if (dev->endpoints[i].type != BULK) if (dev->endpoints[i].type != BULK)
continue; continue;
if ((dev->endpoints[i].direction == IN) if ((dev->endpoints[i].direction == IN)
&& (MSC_INST (dev)->bulk_in == 0)) && (MSC_INST(dev)->bulk_in == 0))
MSC_INST (dev)->bulk_in = &dev->endpoints[i]; MSC_INST(dev)->bulk_in = &dev->endpoints[i];
if ((dev->endpoints[i].direction == OUT) if ((dev->endpoints[i].direction == OUT)
&& (MSC_INST (dev)->bulk_out == 0)) && (MSC_INST(dev)->bulk_out == 0))
MSC_INST (dev)->bulk_out = &dev->endpoints[i]; MSC_INST(dev)->bulk_out = &dev->endpoints[i];
} }
if (MSC_INST (dev)->bulk_in == 0) { if (MSC_INST(dev)->bulk_in == 0) {
usb_debug("couldn't find bulk-in endpoint.\n"); usb_debug("couldn't find bulk-in endpoint.\n");
usb_detach_device (dev->controller, dev->address); usb_detach_device(dev->controller, dev->address);
return; return;
} }
if (MSC_INST (dev)->bulk_out == 0) { if (MSC_INST(dev)->bulk_out == 0) {
usb_debug("couldn't find bulk-out endpoint.\n"); usb_debug("couldn't find bulk-out endpoint.\n");
usb_detach_device (dev->controller, dev->address); usb_detach_device(dev->controller, dev->address);
return; return;
} }
usb_debug (" using endpoint %x as in, %x as out\n", usb_debug(" using endpoint %x as in, %x as out\n",
MSC_INST (dev)->bulk_in->endpoint, MSC_INST(dev)->bulk_in->endpoint,
MSC_INST (dev)->bulk_out->endpoint); MSC_INST(dev)->bulk_out->endpoint);
/* Some sticks need a little more time to get ready after SET_CONFIG. */ /* Some sticks need a little more time to get ready after SET_CONFIG. */
udelay(50); udelay(50);
initialize_luns (dev); initialize_luns(dev);
usb_debug (" has %d luns\n", MSC_INST (dev)->num_luns); usb_debug(" has %d luns\n", MSC_INST(dev)->num_luns);
/* Test if unit is ready (nothing to do if it isn't). */ /* Test if unit is ready (nothing to do if it isn't). */
if (usb_msc_test_unit_ready (dev) != USB_MSC_READY) if (usb_msc_test_unit_ready(dev) != USB_MSC_READY)
return; return;
/* Create the disk. */ /* Create the disk. */
usb_msc_create_disk (dev); usb_msc_create_disk(dev);
} }
static void static void
usb_msc_poll (usbdev_t *dev) usb_msc_poll(usbdev_t *dev)
{ {
usbmsc_inst_t *msc = MSC_INST (dev); usbmsc_inst_t *msc = MSC_INST(dev);
int prev_ready = msc->ready; int prev_ready = msc->ready;
if (usb_msc_test_unit_ready (dev) == USB_MSC_DETACHED) if (usb_msc_test_unit_ready(dev) == USB_MSC_DETACHED)
return; return;
if (!prev_ready && msc->ready) { if (!prev_ready && msc->ready) {
usb_debug ("USB msc: not ready -> ready (lun %d)\n", msc->lun); usb_debug("USB msc: not ready -> ready (lun %d)\n", msc->lun);
usb_msc_create_disk (dev); usb_msc_create_disk(dev);
} else if (prev_ready && !msc->ready) { } else if (prev_ready && !msc->ready) {
usb_debug ("USB msc: ready -> not ready (lun %d)\n", msc->lun); usb_debug("USB msc: ready -> not ready (lun %d)\n", msc->lun);
usb_msc_remove_disk (dev); usb_msc_remove_disk(dev);
} else if (!prev_ready && !msc->ready) { } else if (!prev_ready && !msc->ready) {
u8 new_lun = (msc->lun + 1) % msc->num_luns; u8 new_lun = (msc->lun + 1) % msc->num_luns;
usb_debug("USB msc: not ready (lun %d) -> lun %d\n", msc->lun, usb_debug("USB msc: not ready (lun %d) -> lun %d\n", msc->lun,

32
payloads/libpayload/drivers/usb/xhci.c
View File

@ -34,17 +34,17 @@
#include "xhci_private.h" #include "xhci_private.h"
#include "xhci.h" #include "xhci.h"
static void xhci_start (hci_t *controller); static void xhci_start(hci_t *controller);
static void xhci_stop (hci_t *controller); static void xhci_stop(hci_t *controller);
static void xhci_reset (hci_t *controller); static void xhci_reset(hci_t *controller);
static void xhci_reinit (hci_t *controller); static void xhci_reinit(hci_t *controller);
static void xhci_shutdown (hci_t *controller); static void xhci_shutdown(hci_t *controller);
static int xhci_bulk (endpoint_t *ep, int size, u8 *data, int finalize); static int xhci_bulk(endpoint_t *ep, int size, u8 *data, int finalize);
static int xhci_control (usbdev_t *dev, direction_t dir, int drlen, void *devreq, static int xhci_control(usbdev_t *dev, direction_t dir, int drlen, void *devreq,
int dalen, u8 *data); int dalen, u8 *data);
static void* xhci_create_intr_queue (endpoint_t *ep, int reqsize, int reqcount, int reqtiming); static void* xhci_create_intr_queue(endpoint_t *ep, int reqsize, int reqcount, int reqtiming);
static void xhci_destroy_intr_queue (endpoint_t *ep, void *queue); static void xhci_destroy_intr_queue(endpoint_t *ep, void *queue);
static u8* xhci_poll_intr_queue (void *queue); static u8* xhci_poll_intr_queue(void *queue);
/* /*
* Some structures must not cross page boundaries. To get this, * Some structures must not cross page boundaries. To get this,
@ -151,7 +151,7 @@ xhci_wait_ready(xhci_t *const xhci)
} }
hci_t * hci_t *
xhci_init (unsigned long physical_bar) xhci_init(unsigned long physical_bar)
{ {
int i; int i;
@ -167,7 +167,7 @@ xhci_init (unsigned long physical_bar)
controller->bulk = xhci_bulk; controller->bulk = xhci_bulk;
controller->control = xhci_control; controller->control = xhci_control;
controller->set_address = xhci_set_address; controller->set_address = xhci_set_address;
controller->finish_device_config= xhci_finish_device_config; controller->finish_device_config = xhci_finish_device_config;
controller->destroy_device = xhci_destroy_dev; controller->destroy_device = xhci_destroy_dev;
controller->create_intr_queue = xhci_create_intr_queue; controller->create_intr_queue = xhci_create_intr_queue;
controller->destroy_intr_queue = xhci_destroy_intr_queue; controller->destroy_intr_queue = xhci_destroy_intr_queue;
@ -306,7 +306,7 @@ _free_xhci:
#if CONFIG(LP_USB_PCI) #if CONFIG(LP_USB_PCI)
hci_t * hci_t *
xhci_pci_init (pcidev_t addr) xhci_pci_init(pcidev_t addr)
{ {
u32 reg_addr; u32 reg_addr;
hci_t *controller; hci_t *controller;
@ -358,7 +358,7 @@ xhci_reset(hci_t *const controller)
} }
static void static void
xhci_reinit (hci_t *controller) xhci_reinit(hci_t *controller)
{ {
xhci_t *const xhci = XHCI_INST(controller); xhci_t *const xhci = XHCI_INST(controller);
@ -464,7 +464,7 @@ xhci_shutdown(hci_t *const controller)
} }
static void static void
xhci_start (hci_t *controller) xhci_start(hci_t *controller)
{ {
xhci_t *const xhci = XHCI_INST(controller); xhci_t *const xhci = XHCI_INST(controller);
@ -474,7 +474,7 @@ xhci_start (hci_t *controller)
} }
static void static void
xhci_stop (hci_t *controller) xhci_stop(hci_t *controller)
{ {
xhci_t *const xhci = XHCI_INST(controller); xhci_t *const xhci = XHCI_INST(controller);

6
payloads/libpayload/drivers/usb/xhci.h
View File

@ -32,9 +32,9 @@
#include <pci.h> #include <pci.h>
#include <usb/usb.h> #include <usb/usb.h>
hci_t *xhci_pci_init (pcidev_t addr); hci_t *xhci_pci_init(pcidev_t addr);
hci_t *xhci_init (unsigned long physical_bar); hci_t *xhci_init(unsigned long physical_bar);
void xhci_rh_init (usbdev_t *dev); void xhci_rh_init(usbdev_t *dev);
#endif #endif

6
payloads/libpayload/drivers/usb/xhci_devconf.c
View File

@ -124,7 +124,7 @@ xhci_make_inputctx(const size_t ctxsize)
} }
usbdev_t * usbdev_t *
xhci_set_address (hci_t *controller, usb_speed speed, int hubport, int hubaddr) xhci_set_address(hci_t *controller, usb_speed speed, int hubport, int hubaddr)
{ {
xhci_t *const xhci = XHCI_INST(controller); xhci_t *const xhci = XHCI_INST(controller);
const size_t ctxsize = CTXSIZE(xhci); const size_t ctxsize = CTXSIZE(xhci);
@ -162,7 +162,7 @@ xhci_set_address (hci_t *controller, usb_speed speed, int hubport, int hubaddr)
for (i = 0; i < NUM_EPS; i++, dma_buffer += ctxsize) for (i = 0; i < NUM_EPS; i++, dma_buffer += ctxsize)
di->ctx.ep[i] = dma_buffer; di->ctx.ep[i] = dma_buffer;
*ic->add = (1 << 0) /* Slot Context */ | (1 << 1) /* EP0 Context */ ; *ic->add = (1 << 0) /* Slot Context */ | (1 << 1) /* EP0 Context */;
SC_SET(ROUTE, ic->dev.slot, xhci_gen_route(xhci, hubport, hubaddr)); SC_SET(ROUTE, ic->dev.slot, xhci_gen_route(xhci, hubport, hubaddr));
SC_SET(SPEED1, ic->dev.slot, speed + 1); SC_SET(SPEED1, ic->dev.slot, speed + 1);
@ -288,7 +288,7 @@ xhci_finish_hub_config(usbdev_t *const dev, inputctx_t *const ic)
static size_t static size_t
xhci_bound_interval(const endpoint_t *const ep) xhci_bound_interval(const endpoint_t *const ep)
{ {
if ( (ep->dev->speed == LOW_SPEED && if ((ep->dev->speed == LOW_SPEED &&
(ep->type == ISOCHRONOUS || (ep->type == ISOCHRONOUS ||
ep->type == INTERRUPT)) || ep->type == INTERRUPT)) ||
(ep->dev->speed == FULL_SPEED && (ep->dev->speed == FULL_SPEED &&

22
payloads/libpayload/drivers/usb/xhci_private.h
View File

@ -40,7 +40,7 @@
#ifdef XHCI_SPEW_DEBUG #ifdef XHCI_SPEW_DEBUG
# define xhci_spew(fmt, args...) xhci_debug(fmt, ##args) # define xhci_spew(fmt, args...) xhci_debug(fmt, ##args)
#else #else
# define xhci_spew(fmt, args...) do {} while(0) # define xhci_spew(fmt, args...) do {} while (0)
#endif #endif
#define MASK(startbit, lenbit) (((1<<(lenbit))-1)<<(startbit)) #define MASK(startbit, lenbit) (((1<<(lenbit))-1)<<(startbit))
@ -377,7 +377,7 @@ typedef struct xhci {
u32 hccparams; u32 hccparams;
u32 dboff; u32 dboff;
u32 rtsoff; u32 rtsoff;
} __packed *capreg; } __packed * capreg;
/* opreg is R/W is most places, so volatile access is necessary. /* opreg is R/W is most places, so volatile access is necessary.
volatile means that the compiler seeks byte writes if possible, volatile means that the compiler seeks byte writes if possible,
@ -444,7 +444,7 @@ typedef struct xhci {
u32 portli; /* 0x408 + 4 * port */ u32 portli; /* 0x408 + 4 * port */
u32 res; /* 0x40C + 4 * port */ u32 res; /* 0x40C + 4 * port */
} __packed prs[]; } __packed prs[];
} __packed *opreg; } __packed * opreg;
/* R/W, volatile, MMIO -> no bitfields */ /* R/W, volatile, MMIO -> no bitfields */
volatile struct hcrreg { volatile struct hcrreg {
@ -460,7 +460,7 @@ typedef struct xhci {
u32 erdp_lo; u32 erdp_lo;
u32 erdp_hi; u32 erdp_hi;
} __packed intrrs[]; // up to 1024, but maximum host specific, given in capreg->MaxIntrs } __packed intrrs[]; // up to 1024, but maximum host specific, given in capreg->MaxIntrs
} __packed *hcrreg; } __packed * hcrreg;
/* R/W, volatile, MMIO -> no bitfields */ /* R/W, volatile, MMIO -> no bitfields */
volatile u32 *dbreg; volatile u32 *dbreg;
@ -486,7 +486,7 @@ typedef struct xhci {
void *xhci_align(const size_t min_align, const size_t size); void *xhci_align(const size_t min_align, const size_t size);
void xhci_init_cycle_ring(transfer_ring_t *, const size_t ring_size); void xhci_init_cycle_ring(transfer_ring_t *, const size_t ring_size);
usbdev_t *xhci_set_address (hci_t *, usb_speed speed, int hubport, int hubaddr); usbdev_t *xhci_set_address(hci_t *, usb_speed speed, int hubport, int hubaddr);
int xhci_finish_device_config(usbdev_t *); int xhci_finish_device_config(usbdev_t *);
void xhci_destroy_dev(hci_t *, int slot_id); void xhci_destroy_dev(hci_t *, int slot_id);
@ -523,12 +523,12 @@ void xhci_dump_inputctx(const inputctx_t *);
void xhci_dump_transfer_trb(const trb_t *); void xhci_dump_transfer_trb(const trb_t *);
void xhci_dump_transfer_trbs(const trb_t *first, const trb_t *last); void xhci_dump_transfer_trbs(const trb_t *first, const trb_t *last);
#else #else
#define xhci_dump_slotctx(args...) do {} while(0) #define xhci_dump_slotctx(args...) do {} while (0)
#define xhci_dump_epctx(args...) do {} while(0) #define xhci_dump_epctx(args...) do {} while (0)
#define xhci_dump_devctx(args...) do {} while(0) #define xhci_dump_devctx(args...) do {} while (0)
#define xhci_dump_inputctx(args...) do {} while(0) #define xhci_dump_inputctx(args...) do {} while (0)
#define xhci_dump_transfer_trb(args...) do {} while(0) #define xhci_dump_transfer_trb(args...) do {} while (0)
#define xhci_dump_transfer_trbs(args...) do {} while(0) #define xhci_dump_transfer_trbs(args...) do {} while (0)
#endif #endif
#endif #endif

2
payloads/libpayload/drivers/usb/xhci_rh.c
View File

@ -149,7 +149,7 @@ static const generic_hub_ops_t xhci_rh_ops = {
}; };
void void
xhci_rh_init (usbdev_t *dev) xhci_rh_init(usbdev_t *dev)
{ {
/* we can set them here because a root hub _really_ shouldn't /* we can set them here because a root hub _really_ shouldn't
appear elsewhere */ appear elsewhere */