From 656765bac6c2b951cc5ae9581c3ce6ca0b949e6b Mon Sep 17 00:00:00 2001 From: PaulStoffregen Date: Sat, 18 Feb 2017 12:03:10 -0800 Subject: [PATCH] All debug printing through USBHost class --- USBHost.h | 35 +++++++++++- ehci.cpp | 144 +++++++++++++++++++++--------------------------- enumeration.cpp | 47 +++++++--------- hub.cpp | 86 +++++++++++++---------------- keyboard.cpp | 18 +++--- print.cpp | 12 ---- 6 files changed, 162 insertions(+), 180 deletions(-) diff --git a/USBHost.h b/USBHost.h index cb0f5e7..a35d0df 100644 --- a/USBHost.h +++ b/USBHost.h @@ -158,14 +158,45 @@ private: static void free_Pipe(Pipe_t *q); static Transfer_t * allocate_Transfer(void); static void free_Transfer(Transfer_t *q); + static bool allocate_interrupt_pipe_bandwidth(uint32_t speed, uint32_t maxlen, + uint32_t interval, uint32_t direction, uint32_t *offset_out, + uint32_t *smask_out, uint32_t *cmask_out); protected: static void print(const Transfer_t *transfer); static void print(const Transfer_t *first, const Transfer_t *last); static void print_token(uint32_t token); static void print(const Pipe_t *pipe); static void print_hexbytes(const void *ptr, uint32_t len); - static void print(const char *s); - static void print(const char *s, int num); + static void print(const char *s) { Serial.print(s); } + static void print(int n) { Serial.print(n); } + static void print(unsigned int n) { Serial.print(n); } + static void print(long n) { Serial.print(n); } + static void print(unsigned long n) { Serial.print(n); } + static void println(const char *s) { Serial.println(s); } + static void println(int n) { Serial.println(n); } + static void println(unsigned int n) { Serial.println(n); } + static void println(long n) { Serial.println(n); } + static void println(unsigned long n) { Serial.println(n); } + static void println() { Serial.println(); } + static void print(uint32_t n, uint8_t b) { Serial.print(n, b); } + static void println(uint32_t n, uint8_t b) { Serial.print(n, b); } + static void println(const char *s, int n) { + Serial.print(s); Serial.println(n); } + static void println(const char *s, unsigned int n) { + Serial.print(s); Serial.println(n); } + static void println(const char *s, long n) { + Serial.print(s); Serial.println(n); } + static void println(const char *s, unsigned long n) { + Serial.print(s); Serial.println(n); } + static void println(const char *s, int n, uint8_t b) { + Serial.print(s); Serial.println(n, b); } + static void println(const char *s, unsigned int n, uint8_t b) { + Serial.print(s); Serial.println(n, b); } + static void println(const char *s, long n, uint8_t b) { + Serial.print(s); Serial.println(n, b); } + static void println(const char *s, unsigned long n, uint8_t b) { + Serial.print(s); Serial.println(n, b); } + static void mk_setup(setup_t &s, uint32_t bmRequestType, uint32_t bRequest, uint32_t wValue, uint32_t wIndex, uint32_t wLength) { s.word1 = bmRequestType | (bRequest << 8) | (wValue << 16); diff --git a/ehci.cpp b/ehci.cpp index 2422164..d6c0a72 100644 --- a/ehci.cpp +++ b/ehci.cpp @@ -48,9 +48,6 @@ static void add_to_async_followup_list(Transfer_t *first, Transfer_t *last); static void remove_from_async_followup_list(Transfer_t *transfer); static void add_to_periodic_followup_list(Transfer_t *first, Transfer_t *last); static void remove_from_periodic_followup_list(Transfer_t *transfer); -static bool allocate_interrupt_pipe_bandwidth(uint32_t speed, uint32_t maxlen, - uint32_t interval, uint32_t direction, uint32_t *offset, uint32_t *smask, - uint32_t *cmask); void USBHost::begin() { @@ -59,24 +56,20 @@ void USBHost::begin() GPIOE_PDDR |= (1<<6); GPIOE_PSOR = (1<<6); // turn on USB host power delay(10); - Serial.print("sizeof Device = "); - Serial.println(sizeof(Device_t)); - Serial.print("sizeof Pipe = "); - Serial.println(sizeof(Pipe_t)); - Serial.print("sizeof Transfer = "); - Serial.println(sizeof(Transfer_t)); + println("sizeof Device = ", sizeof(Device_t)); + println("sizeof Pipe = ", sizeof(Pipe_t)); + println("sizeof Transfer = ", sizeof(Transfer_t)); // configure the MPU to allow USBHS DMA to access memory MPU_RGDAAC0 |= 0x30000000; - //Serial.print("MPU_RGDAAC0 = "); - //Serial.println(MPU_RGDAAC0, HEX); + //println("MPU_RGDAAC0 = ", MPU_RGDAAC0, HEX); // turn on clocks MCG_C1 |= MCG_C1_IRCLKEN; // enable MCGIRCLK 32kHz OSC0_CR |= OSC_ERCLKEN; SIM_SOPT2 |= SIM_SOPT2_USBREGEN; // turn on USB regulator SIM_SOPT2 &= ~SIM_SOPT2_USBSLSRC; // use IRC for slow clock - print("power up USBHS PHY"); + println("power up USBHS PHY"); SIM_USBPHYCTL |= SIM_USBPHYCTL_USBDISILIM; // disable USB current limit //SIM_USBPHYCTL = SIM_USBPHYCTL_USBDISILIM | SIM_USBPHYCTL_USB3VOUTTRG(6); // pg 237 SIM_SCGC3 |= SIM_SCGC3_USBHSDCD | SIM_SCGC3_USBHSPHY | SIM_SCGC3_USBHS; @@ -94,8 +87,7 @@ void USBHost::begin() while ((USBPHY_PLL_SIC & USBPHY_PLL_SIC_PLL_LOCK) == 0) { count++; } - //Serial.print("PLL locked, waited "); - //Serial.println(count); + //println("PLL locked, waited ", count); // turn on power to PHY USBPHY_PWD = 0; @@ -119,7 +111,7 @@ void USBHost::begin() while (USBHS_USBCMD & USBHS_USBCMD_RST) { //count++; } - //print(" reset waited ", count); + //println(" reset waited ", count); init_Device_Pipe_Transfer_memory(); for (int i=0; i < 32; i++) { @@ -165,12 +157,9 @@ void USBHost::begin() //USBHS_PORTSC1 |= USBHS_PORTSC_PFSC; // force 12 Mbit/sec //USBHS_PORTSC1 |= USBHS_PORTSC_PHCD; // phy off - //Serial.print("USBHS_ASYNCLISTADDR = "); - //Serial.println(USBHS_ASYNCLISTADDR, HEX); - //Serial.print("USBHS_PERIODICLISTBASE = "); - //Serial.println(USBHS_PERIODICLISTBASE, HEX); - //Serial.print("periodictable = "); - //Serial.println((uint32_t)periodictable, HEX); + //println("USBHS_ASYNCLISTADDR = ", USBHS_ASYNCLISTADDR, HEX); + //println("USBHS_PERIODICLISTBASE = ", USBHS_PERIODICLISTBASE, HEX); + //println("periodictable = ", (uint32_t)periodictable, HEX); // enable interrupts, after this point interruts to all the work attachInterruptVector(IRQ_USBHS, isr); @@ -207,31 +196,29 @@ void USBHost::isr() uint32_t stat = USBHS_USBSTS; USBHS_USBSTS = stat; // clear pending interrupts //stat &= USBHS_USBINTR; // mask away unwanted interrupts - Serial.println(); - Serial.print("ISR: "); - Serial.print(stat, HEX); - Serial.println(); - //if (stat & USBHS_USBSTS_UI) Serial.println(" USB Interrupt"); - if (stat & USBHS_USBSTS_UEI) Serial.println(" USB Error"); - if (stat & USBHS_USBSTS_PCI) Serial.println(" Port Change"); - //if (stat & USBHS_USBSTS_FRI) Serial.println(" Frame List Rollover"); - if (stat & USBHS_USBSTS_SEI) Serial.println(" System Error"); - if (stat & USBHS_USBSTS_AAI) Serial.println(" Async Advance (doorbell)"); - if (stat & USBHS_USBSTS_URI) Serial.println(" Reset Recv"); - //if (stat & USBHS_USBSTS_SRI) Serial.println(" SOF"); - if (stat & USBHS_USBSTS_SLI) Serial.println(" Suspend"); - if (stat & USBHS_USBSTS_HCH) Serial.println(" Host Halted"); - //if (stat & USBHS_USBSTS_RCL) Serial.println(" Reclamation"); - //if (stat & USBHS_USBSTS_PS) Serial.println(" Periodic Sched En"); - //if (stat & USBHS_USBSTS_AS) Serial.println(" Async Sched En"); - if (stat & USBHS_USBSTS_NAKI) Serial.println(" NAK"); - if (stat & USBHS_USBSTS_UAI) Serial.println(" USB Async"); - if (stat & USBHS_USBSTS_UPI) Serial.println(" USB Periodic"); - if (stat & USBHS_USBSTS_TI0) Serial.println(" Timer0"); - if (stat & USBHS_USBSTS_TI1) Serial.println(" Timer1"); + println(); + println("ISR: ", stat, HEX); + //if (stat & USBHS_USBSTS_UI) println(" USB Interrupt"); + if (stat & USBHS_USBSTS_UEI) println(" USB Error"); + if (stat & USBHS_USBSTS_PCI) println(" Port Change"); + //if (stat & USBHS_USBSTS_FRI) println(" Frame List Rollover"); + if (stat & USBHS_USBSTS_SEI) println(" System Error"); + if (stat & USBHS_USBSTS_AAI) println(" Async Advance (doorbell)"); + if (stat & USBHS_USBSTS_URI) println(" Reset Recv"); + //if (stat & USBHS_USBSTS_SRI) println(" SOF"); + if (stat & USBHS_USBSTS_SLI) println(" Suspend"); + if (stat & USBHS_USBSTS_HCH) println(" Host Halted"); + //if (stat & USBHS_USBSTS_RCL) println(" Reclamation"); + //if (stat & USBHS_USBSTS_PS) println(" Periodic Sched En"); + //if (stat & USBHS_USBSTS_AS) println(" Async Sched En"); + if (stat & USBHS_USBSTS_NAKI) println(" NAK"); + if (stat & USBHS_USBSTS_UAI) println(" USB Async"); + if (stat & USBHS_USBSTS_UPI) println(" USB Periodic"); + if (stat & USBHS_USBSTS_TI0) println(" Timer0"); + if (stat & USBHS_USBSTS_TI1) println(" Timer1"); if (stat & USBHS_USBSTS_UAI) { // completed qTD(s) from the async schedule - Serial.println("Async Followup"); + println("Async Followup"); //print(async_followup_first, async_followup_last); Transfer_t *p = async_followup_first; while (p) { @@ -249,7 +236,7 @@ void USBHost::isr() //print(async_followup_first, async_followup_last); } if (stat & USBHS_USBSTS_UPI) { // completed qTD(s) from the periodic schedule - Serial.println("Periodic Followup"); + println("Periodic Followup"); Transfer_t *p = periodic_followup_first; while (p) { if (followup_Transfer(p)) { @@ -267,16 +254,14 @@ void USBHost::isr() if (stat & USBHS_USBSTS_PCI) { // port change detected const uint32_t portstat = USBHS_PORTSC1; - Serial.print("port change: "); - Serial.print(portstat, HEX); - Serial.println(); + println("port change: ", portstat, HEX); USBHS_PORTSC1 = portstat | (USBHS_PORTSC_OCC|USBHS_PORTSC_PEC|USBHS_PORTSC_CSC); if (portstat & USBHS_PORTSC_OCC) { - Serial.println(" overcurrent change"); + println(" overcurrent change"); } if (portstat & USBHS_PORTSC_CSC) { if (portstat & USBHS_PORTSC_CCS) { - Serial.println(" connect"); + println(" connect"); if (port_state == PORT_STATE_DISCONNECTED || port_state == PORT_STATE_DEBOUNCE) { // 100 ms debounce (USB 2.0: TATTDB, page 150 & 188) @@ -287,7 +272,7 @@ void USBHost::isr() stat &= ~USBHS_USBSTS_TI0; } } else { - Serial.println(" disconnect"); + println(" disconnect"); port_state = PORT_STATE_DISCONNECTED; USBPHY_CTRL_CLR = USBPHY_CTRL_ENHOSTDISCONDETECT; // TODO: delete & clean up device state... @@ -295,9 +280,9 @@ void USBHost::isr() } if (portstat & USBHS_PORTSC_PEC) { // PEC bit only detects disable - Serial.println(" disable"); + println(" disable"); } else if (port_state == PORT_STATE_RESET && portstat & USBHS_PORTSC_PE) { - Serial.println(" port enabled"); + println(" port enabled"); port_state = PORT_STATE_RECOVERY; // 10 ms reset recover (USB 2.0: TRSTRCY, page 151 & 188) USBHS_GPTIMER0LD = 10000; // microseconds @@ -308,19 +293,19 @@ void USBHost::isr() } } if (portstat & USBHS_PORTSC_FPR) { - Serial.println(" force resume"); + println(" force resume"); } } if (stat & USBHS_USBSTS_TI0) { // timer 0 - Serial.println("timer"); + println("timer"); if (port_state == PORT_STATE_DEBOUNCE) { port_state = PORT_STATE_RESET; USBHS_PORTSC1 |= USBHS_PORTSC_PR; // begin reset sequence - Serial.println(" begin reset"); + println(" begin reset"); } else if (port_state == PORT_STATE_RECOVERY) { port_state = PORT_STATE_ACTIVE; - Serial.println(" end recovery"); + println(" end recovery"); // HCSPARAMS TTCTRL page 1671 uint32_t speed = (USBHS_PORTSC1 >> 26) & 3; @@ -366,7 +351,7 @@ Pipe_t * USBHost::new_Pipe(Device_t *dev, uint32_t type, uint32_t endpoint, Transfer_t *halt; uint32_t c=0, dtc=0, smask=0, cmask=0, offset=0; - Serial.println("new_Pipe"); + println("new_Pipe"); pipe = allocate_Pipe(); if (!pipe) return NULL; halt = allocate_Transfer(); @@ -416,12 +401,12 @@ Pipe_t * USBHost::new_Pipe(Device_t *dev, uint32_t type, uint32_t endpoint, pipe->qh.horizontal_link = (uint32_t)&(pipe->qh) | 2; // 2=QH USBHS_ASYNCLISTADDR = (uint32_t)&(pipe->qh); USBHS_USBCMD |= USBHS_USBCMD_ASE; // enable async schedule - //Serial.println(" first in async list"); + //println(" first in async list"); } else { // EHCI 1.0: section 4.8.1, page 72 pipe->qh.horizontal_link = list->qh.horizontal_link; list->qh.horizontal_link = (uint32_t)&(pipe->qh) | 2; - //Serial.println(" added to async list"); + //println(" added to async list"); } } else if (type == 3) { // interrupt: add to periodic schedule @@ -436,8 +421,7 @@ Pipe_t * USBHost::new_Pipe(Device_t *dev, uint32_t type, uint32_t endpoint, // quick hack for testing, just put it into the first table entry pipe->qh.horizontal_link = periodictable[0]; periodictable[0] = (uint32_t)&(pipe->qh) | 2; // 2=QH - Serial.print("init periodictable with "); - Serial.println(periodictable[0], HEX); + println("init periodictable with ", periodictable[0], HEX); } return pipe; } @@ -476,7 +460,7 @@ bool USBHost::queue_Control_Transfer(Device_t *dev, setup_t *setup, void *buf, U Transfer_t *transfer, *data, *status; uint32_t status_direction; - Serial.println("new_Control_Transfer"); + println("new_Control_Transfer"); if (setup->wLength > 16384) return false; // max 16K data for control transfer = allocate_Transfer(); if (!transfer) return false; @@ -501,8 +485,7 @@ bool USBHost::queue_Control_Transfer(Device_t *dev, setup_t *setup, void *buf, U transfer->qtd.next = (uint32_t)status; status_direction = 1; // always IN, USB 2.0 page 226 } - //Serial.print("setup address "); - //Serial.println((uint32_t)setup, HEX); + //println("setup address ", (uint32_t)setup, HEX); init_qTD(transfer, setup, 8, 2, 0, false); init_qTD(status, NULL, 0, status_direction, 1, true); status->pipe = dev->control_pipe; @@ -526,7 +509,7 @@ bool USBHost::queue_Data_Transfer(Pipe_t *pipe, void *buffer, uint32_t len, USBD // TODO: option for zero length packet? Maybe in Pipe_t fields? - Serial.println("new_Data_Transfer"); + println("new_Data_Transfer"); // allocate qTDs transfer = allocate_Transfer(); if (!transfer) return false; @@ -628,8 +611,7 @@ bool USBHost::queue_Transfer(Pipe_t *pipe, Transfer_t *transfer) static bool followup_Transfer(Transfer_t *transfer) { - //Serial.print(" Followup "); - //Serial.println((uint32_t)transfer, HEX); + //println(" Followup ", (uint32_t)transfer, HEX); if (!(transfer->qtd.token & 0x80)) { // TODO: check error status @@ -641,7 +623,7 @@ static bool followup_Transfer(Transfer_t *transfer) } } // do callback function... - //Serial.println(" completed"); + //println(" completed"); return true; } return false; @@ -744,11 +726,11 @@ static uint32_t max4(uint32_t n1, uint32_t n2, uint32_t n3, uint32_t n4) // smask: [out] Start Mask // cmask: [out] Complete Mask // -static bool allocate_interrupt_pipe_bandwidth(uint32_t speed, uint32_t maxlen, +bool USBHost::allocate_interrupt_pipe_bandwidth(uint32_t speed, uint32_t maxlen, uint32_t interval, uint32_t direction, uint32_t *offset_out, uint32_t *smask_out, uint32_t *cmask_out) { - Serial.println("allocate_interrupt_pipe_bandwidth"); + println("allocate_interrupt_pipe_bandwidth"); maxlen = (maxlen * 76459) >> 16; // worst case bit stuffing if (speed == 2) { // high speed 480 Mbit/sec @@ -766,10 +748,10 @@ static bool allocate_interrupt_pipe_bandwidth(uint32_t speed, uint32_t maxlen, min_offset = offset; } } - Serial.print(" min_bw = "); - Serial.print(min_bw); - Serial.print(", at offset = "); - Serial.println(min_offset); + print(" min_bw = "); + print(min_bw); + print(", at offset = "); + println(min_offset); if (min_bw > 187) return false; for (uint32_t i=min_offset; i < PERIODIC_LIST_SIZE*8; i += interval) { uframe_bandwidth[i] += stime; @@ -821,12 +803,12 @@ static bool allocate_interrupt_pipe_bandwidth(uint32_t speed, uint32_t maxlen, } } } - Serial.print(" min_bw = "); - Serial.println(min_bw); - Serial.print(", at offset = "); - Serial.print(min_offset); - Serial.print(", shift= "); - Serial.println(min_shift); + print(" min_bw = "); + println(min_bw); + print(", at offset = "); + print(min_offset); + print(", shift= "); + println(min_shift); if (min_bw > 187) return false; for (uint32_t i=min_offset; i < PERIODIC_LIST_SIZE; i += interval) { uint32_t n = (i << 3) + min_shift; diff --git a/enumeration.cpp b/enumeration.cpp index 5cf35b9..737f733 100644 --- a/enumeration.cpp +++ b/enumeration.cpp @@ -57,14 +57,14 @@ Device_t * USBHost::new_Device(uint32_t speed, uint32_t hub_addr, uint32_t hub_p { Device_t *dev; - Serial.print("new_Device: "); + print("new_Device: "); switch (speed) { - case 0: Serial.print("12"); break; - case 1: Serial.print("1.5"); break; - case 2: Serial.print("480"); break; - default: Serial.print("??"); + case 0: print("12"); break; + case 1: print("1.5"); break; + case 2: print("480"); break; + default: print("??"); } - Serial.println(" Mbit/sec"); + println(" Mbit/sec"); dev = allocate_Device(); if (!dev) return NULL; memset(dev, 0, sizeof(Device_t)); @@ -100,7 +100,7 @@ void USBHost::enumeration(const Transfer_t *transfer) return; } - Serial.println("enumeration:"); + println("enumeration:"); //print_hexbytes(transfer->buffer, transfer->length); //print(transfer); dev = transfer->pipe->device; @@ -199,8 +199,7 @@ void USBHost::enumeration(const Transfer_t *transfer) return; case 12: // read 9 bytes, request all of config desc enumlen = enumbuf[2] | (enumbuf[3] << 8); - Serial.print("Config data length = "); - Serial.println(enumlen); + println("Config data length = ", enumlen); if (enumlen > sizeof(enumbuf)) { // TODO: how to handle device with too much config data } @@ -209,10 +208,8 @@ void USBHost::enumeration(const Transfer_t *transfer) dev->enum_state = 13; return; case 13: // read all config desc, send set config - Serial.print("bNumInterfaces = "); - Serial.println(enumbuf[4]); - Serial.print("bConfigurationValue = "); - Serial.println(enumbuf[5]); + println("bNumInterfaces = ", enumbuf[4]); + println("bConfigurationValue = ", enumbuf[5]); dev->bmAttributes = enumbuf[7]; dev->bMaxPower = enumbuf[8]; // TODO: actually do something with interface descriptor? @@ -259,16 +256,16 @@ void USBHost::claim_drivers(Device_t *dev) while (p < end) { uint8_t desclen = *p; uint8_t desctype = *(p+1); - Serial.print("Descriptor "); - Serial.print(desctype); - Serial.print(" = "); - if (desctype == 4) Serial.println("INTERFACE"); - else if (desctype == 5) Serial.println("ENDPOINT"); - else if (desctype == 6) Serial.println("DEV_QUALIFIER"); - else if (desctype == 7) Serial.println("OTHER_SPEED"); - else if (desctype == 11) Serial.println("IAD"); - else if (desctype == 33) Serial.println("HID"); - else Serial.println(" ???"); + print("Descriptor "); + print(desctype); + print(" = "); + if (desctype == 4) println("INTERFACE"); + else if (desctype == 5) println("ENDPOINT"); + else if (desctype == 6) println("DEV_QUALIFIER"); + else if (desctype == 7) println("OTHER_SPEED"); + else if (desctype == 11) println("IAD"); + else if (desctype == 33) println("HID"); + else println(" ???"); if (desctype == 11 && desclen == 8) { // TODO: parse IAD, ask drivers for claim // TODO: how to skip over all interfaces IAD represented @@ -308,15 +305,11 @@ static uint32_t assign_addr(void) static void pipe_set_maxlen(Pipe_t *pipe, uint32_t maxlen) { - Serial.print("pipe_set_maxlen "); - Serial.println(maxlen); pipe->qh.capabilities[0] = (pipe->qh.capabilities[0] & 0x8000FFFF) | (maxlen << 16); } static void pipe_set_addr(Pipe_t *pipe, uint32_t addr) { - Serial.print("pipe_set_addr "); - Serial.println(addr); pipe->qh.capabilities[0] = (pipe->qh.capabilities[0] & 0xFFFFFF80) | addr; } diff --git a/hub.cpp b/hub.cpp index cbdd7e4..2855c9d 100644 --- a/hub.cpp +++ b/hub.cpp @@ -35,8 +35,7 @@ bool USBHub::claim(Device_t *dev, int type, const uint8_t *descriptors, uint32_t // only claim entire device, never at interface level if (type != 0) return false; - Serial.print("USBHub claim_device this="); - Serial.println((uint32_t)this, HEX); + println("USBHub claim_device this=", (uint32_t)this, HEX); // check for HUB type if (dev->bDeviceClass != 9 || dev->bDeviceSubClass != 0) return false; @@ -56,20 +55,17 @@ bool USBHub::claim(Device_t *dev, int type, const uint8_t *descriptors, uint32_t if (maxsize == 0) return false; if (maxsize > 1) return false; // do hub chips with > 7 ports exist? - Serial.println(descriptors[9]); - Serial.println(descriptors[10]); - Serial.println(descriptors[11], HEX); - Serial.println(maxsize); + println(descriptors[9]); + println(descriptors[10]); + println(descriptors[11], HEX); + println(maxsize); // bDeviceProtocol = 0 is full speed // bDeviceProtocol = 1 is high speed single TT // bDeviceProtocol = 2 is high speed multiple TT - Serial.print("bDeviceClass = "); - Serial.println(dev->bDeviceClass); - Serial.print("bDeviceSubClass = "); - Serial.println(dev->bDeviceSubClass); - Serial.print("bDeviceProtocol = "); - Serial.println(dev->bDeviceProtocol); + println("bDeviceClass = ", dev->bDeviceClass); + println("bDeviceSubClass = ", dev->bDeviceSubClass); + println("bDeviceProtocol = ", dev->bDeviceProtocol); changepipe = NULL; changebits = 0; @@ -118,7 +114,7 @@ void USBHub::reset(uint32_t port) void USBHub::control(const Transfer_t *transfer) { - Serial.println("USBHub control callback"); + println("USBHub control callback"); print_hexbytes(transfer->buffer, transfer->length); if (state == 0) { @@ -130,9 +126,9 @@ void USBHub::control(const Transfer_t *transfer) powertime = hub_desc[5]; // TODO: do we need to use the DeviceRemovable // bits to mke synthetic device connect events? - Serial.print("Hub has "); - Serial.print(numports); - Serial.println(" ports"); + print("Hub has "); + print(numports); + println(" ports"); state = 1; poweron(1); } @@ -140,12 +136,10 @@ void USBHub::control(const Transfer_t *transfer) // turn on power to all ports poweron(++state); } else if (state == numports) { - Serial.println("power turned on to all ports"); - Serial.print("device addr = "); - Serial.println(device->address); + println("power turned on to all ports"); + println("device addr = ", device->address); changepipe = new_Pipe(device, 3, endpoint, 1, 1, 512); - Serial.print("pipe cap1 = "); - Serial.println(changepipe->qh.capabilities[0], HEX); + println("pipe cap1 = ", changepipe->qh.capabilities[0], HEX); changepipe->callback_function = callback; queue_Data_Transfer(changepipe, &changebits, 1, this); state = 255; @@ -153,7 +147,7 @@ void USBHub::control(const Transfer_t *transfer) // up and running... switch (setup.word1) { case 0x000000A0: // get hub status - Serial.println("New Hub Status"); + println("New Hub Status"); clearstatus(0); return; case 0x000000A3: // get port status @@ -161,12 +155,11 @@ void USBHub::control(const Transfer_t *transfer) clearstatus(setup.wIndex); return; case 0x00100120: // clear hub status - Serial.println("Hub Status Cleared"); + println("Hub Status Cleared"); changebits &= ~1; break; case 0x00100123: // clear port status - Serial.print("Port Status Cleared, port="); - Serial.println(setup.wIndex); + println("Port Status Cleared, port=", setup.wIndex); changebits &= ~(1 << setup.wIndex); break; } @@ -176,15 +169,14 @@ void USBHub::control(const Transfer_t *transfer) void USBHub::callback(const Transfer_t *transfer) { - Serial.println("HUB Callback (static)"); + println("HUB Callback (static)"); if (transfer->driver) ((USBHub *)(transfer->driver))->status_change(transfer); } void USBHub::status_change(const Transfer_t *transfer) { - Serial.println("HUB Callback (member)"); - Serial.print("status = "); - Serial.println(changebits, HEX); + println("HUB Callback (member)"); + println("status = ", changebits, HEX); // TODO: do something with the status change info update_status(); queue_Data_Transfer(changepipe, &changebits, 1, this); @@ -208,42 +200,42 @@ void USBHub::new_port_status(uint32_t port, uint32_t status) uint32_t priorstatus = portstatus[port - 1]; portstatus[port] = status; - Serial.print("New Port Status, port="); - Serial.print(port); - Serial.print(", status="); - Serial.println(status, HEX); + print("New Port Status, port="); + print(port); + print(", status="); + println(status, HEX); // status bits, USB 2.0: 11.24.2.7.1 page 427 - if (status & 0x0001) Serial.println(" Device is present: "); + if (status & 0x0001) println(" Device is present: "); if (status & 0x0002) { - Serial.println(" Enabled, speed = "); + println(" Enabled, speed = "); if (status & 0x0200) { - Serial.print("1.5"); + print("1.5"); } else { if (status & 0x0400) { - Serial.print("480"); + print("480"); } else { - Serial.print("12"); + print("12"); } } - Serial.println(" Mbit/sec"); + println(" Mbit/sec"); } - if (status & 0x0004) Serial.println(" Suspended"); - if (status & 0x0008) Serial.println(" Over-current"); - if (status & 0x0010) Serial.println(" Reset"); - if (status & 0x0100) Serial.println(" Has Power"); - if (status & 0x0800) Serial.println(" Test Mode"); - if (status & 0x1000) Serial.println(" Software Controls LEDs"); + if (status & 0x0004) println(" Suspended"); + if (status & 0x0008) println(" Over-current"); + if (status & 0x0010) println(" Reset"); + if (status & 0x0100) println(" Has Power"); + if (status & 0x0800) println(" Test Mode"); + if (status & 0x1000) println(" Software Controls LEDs"); if ((status & 0x0001) && !(priorstatus & 0x0001)) { - Serial.println(" connect"); + println(" connect"); // 100 ms debounce (USB 2.0: TATTDB, page 150 & 188) delay(100); // TODO: horribly bad... need timing events reset(port); // TODO... reset timer? } else if (!(status & 0x0001) && (priorstatus & 0x0001)) { - Serial.println(" disconnect"); + println(" disconnect"); } diff --git a/keyboard.cpp b/keyboard.cpp index 466bd13..42784f2 100644 --- a/keyboard.cpp +++ b/keyboard.cpp @@ -33,8 +33,7 @@ KeyboardController::KeyboardController() bool KeyboardController::claim(Device_t *dev, int type, const uint8_t *descriptors, uint32_t len) { - Serial.print("KeyboardController claim this="); - Serial.println((uint32_t)this, HEX); + println("KeyboardController claim this=", (uint32_t)this, HEX); // only claim at interface level if (type != 1) return false; @@ -50,19 +49,16 @@ bool KeyboardController::claim(Device_t *dev, int type, const uint8_t *descripto if (descriptors[18] != 7) return false; if (descriptors[19] != 5) return false; // endpoint descriptor uint32_t endpoint = descriptors[20]; - Serial.print("ep = "); - Serial.println(endpoint, HEX); + println("ep = ", endpoint, HEX); if ((endpoint & 0xF0) != 0x80) return false; // must be IN direction endpoint &= 0x0F; if (endpoint == 0) return false; if (descriptors[21] != 3) return false; // must be interrupt type uint32_t size = descriptors[22] | (descriptors[23] << 8); - Serial.print("packet size = "); - Serial.println(size); + println("packet size = ", size); if (size != 8) return false; // must be 8 bytes for Keyboard Boot Protocol uint32_t interval = descriptors[24]; - Serial.print("polling interval = "); - Serial.println(interval); + println("polling interval = ", interval); datapipe = new_Pipe(dev, 3, endpoint, 1, 8, 64); datapipe->callback_function = callback; queue_Data_Transfer(datapipe, report, 8, this); @@ -71,7 +67,7 @@ bool KeyboardController::claim(Device_t *dev, int type, const uint8_t *descripto void KeyboardController::callback(const Transfer_t *transfer) { - Serial.println("KeyboardController Callback (static)"); + println("KeyboardController Callback (static)"); if (transfer->driver) { ((KeyboardController *)(transfer->driver))->new_data(transfer); } @@ -79,8 +75,8 @@ void KeyboardController::callback(const Transfer_t *transfer) void KeyboardController::new_data(const Transfer_t *transfer) { - Serial.println("KeyboardController Callback (member)"); - Serial.print(" KB Data: "); + println("KeyboardController Callback (member)"); + print(" KB Data: "); print_hexbytes(transfer->buffer, 8); // TODO: parse the new data queue_Data_Transfer(datapipe, report, 8, this); diff --git a/print.cpp b/print.cpp index 9ab6ab0..9c54f89 100644 --- a/print.cpp +++ b/print.cpp @@ -138,15 +138,3 @@ void USBHost::print_hexbytes(const void *ptr, uint32_t len) Serial.println(); } -void USBHost::print(const char *s) -{ - Serial.println(s); -} - -void USBHost::print(const char *s, int num) -{ - Serial.print(s); - Serial.println(num); -} - -