coreboot June 2012

coreboot@coreboot.org

41 participants
241 discussions

Patch merged into coreboot/master: 4e52072 libpayload: Better error detection in USB mass storage
by gerrit＠coreboot.org 20 Jun '12

20 Jun '12

the following patch was just integrated into master: commit 4e520725dd227ade37be9274ac499671e50e7b93 Author: Nico Huber <nico.huber(a)secunet.com> Date: Mon May 21 14:05:41 2012 +0200 libpayload: Better error detection in USB mass storage This implements status transport (CSW) more closely to the standard (usbmassbulk_10). Change-Id: Ife516316e054d4e87ebe698dc487eeb9ebcfd38d Signed-off-by: Nico Huber <nico.huber(a)secunet.com> Build-Tested: build bot (Jenkins) at Wed Jun 20 19:31:59 2012, giving +1 Reviewed-By: Peter Stuge <peter(a)stuge.se> at Wed Jun 20 17:27:03 2012, giving +2 See http://review.coreboot.org/1072 for details. -gerrit

1 0

Patch merged into coreboot/master: b9f4b09 libpayload: Fix detach_contoller in the USB driver
by gerrit＠coreboot.org 20 Jun '12

20 Jun '12

the following patch was just integrated into master: commit b9f4b09e465b23cbaab10be2b637a6c82ae1e4cd Author: Anton Kochkov <anton.kochkov(a)gmail.com> Date: Wed Jun 20 03:57:18 2012 +0400 libpayload: Fix detach_contoller in the USB driver Fixed usb controllers linked list walking in detach_controller() function Change-Id: Ia97c7ec814f75d2b1bfe185f160fb4cd32aa6fdb Signed-off-by: Anton Kochkov <anton.kochkov(a)gmail.com> Build-Tested: build bot (Jenkins) at Wed Jun 20 02:32:45 2012, giving +1 Reviewed-By: Nico Huber <nico.huber(a)secunet.com> at Wed Jun 20 17:44:58 2012, giving +2 See http://review.coreboot.org/1105 for details. -gerrit

1 0

New patch to review for coreboot: f7add09 Don't use 64-bit constant 0x100000000 in linker scripts
by Nico Huber 20 Jun '12

20 Jun '12

Nico Huber (nico.huber(a)secunet.com) just uploaded a new patch set to gerrit, which you can find at http://review.coreboot.org/1129 -gerrit commit f7add093007f02659c5b7f077fbe13608db9c3a9 Author: Nico Huber <nico.huber(a)secunet.com> Date: Thu Jun 14 16:03:01 2012 +0200 Don't use 64-bit constant 0x100000000 in linker scripts The constant value 0x100000000 is used in linker scripts to calculate offsets from the end of 32-bit-addressed memory. There is nothing wrong with it, but 32-bit versions of ld do the calculation wrong. Change-Id: I4e27c6fd0c864b4d98f686588bf78c7aa48bcba8 Signed-off-by: Nico Huber <nico.huber(a)secunet.com> --- src/arch/x86/lib/id.lds | 2 +- src/northbridge/via/vx800/romstrap.lds | 2 +- src/southbridge/nvidia/ck804/romstrap.lds | 2 +- src/southbridge/nvidia/mcp55/romstrap.lds | 2 +- src/southbridge/sis/sis966/romstrap.lds | 2 +- src/southbridge/via/k8t890/romstrap.lds | 2 +- 6 files changed, 6 insertions(+), 6 deletions(-) diff --git a/src/arch/x86/lib/id.lds b/src/arch/x86/lib/id.lds index 9e31ee6..cfd091d 100644 --- a/src/arch/x86/lib/id.lds +++ b/src/arch/x86/lib/id.lds @@ -1,5 +1,5 @@ SECTIONS { - . = (0x100000000 - CONFIG_ID_SECTION_OFFSET) - (__id_end - __id_start); + . = (0xffffffff - CONFIG_ID_SECTION_OFFSET) - (__id_end - __id_start) + 1; .id (.): { *(.id) } diff --git a/src/northbridge/via/vx800/romstrap.lds b/src/northbridge/via/vx800/romstrap.lds index 4326b28..cd2b546 100644 --- a/src/northbridge/via/vx800/romstrap.lds +++ b/src/northbridge/via/vx800/romstrap.lds @@ -19,7 +19,7 @@ */ SECTIONS { - . = (0x100000000 - 0x2c) - (__romstrap_end - __romstrap_start); + . = (0xffffffff - 0x2c) - (__romstrap_end - __romstrap_start) + 1; .romstrap (.): { *(.romstrap) } diff --git a/src/southbridge/nvidia/ck804/romstrap.lds b/src/southbridge/nvidia/ck804/romstrap.lds index c2ad368..3b8f497 100644 --- a/src/southbridge/nvidia/ck804/romstrap.lds +++ b/src/southbridge/nvidia/ck804/romstrap.lds @@ -19,7 +19,7 @@ */ SECTIONS { - . = (0x100000000 - 0x10) - (__romstrap_end - __romstrap_start); + . = (0xffffffff - 0x10) - (__romstrap_end - __romstrap_start) + 1; .romstrap (.): { *(.romstrap) } diff --git a/src/southbridge/nvidia/mcp55/romstrap.lds b/src/southbridge/nvidia/mcp55/romstrap.lds index c08aa32..4dad422 100644 --- a/src/southbridge/nvidia/mcp55/romstrap.lds +++ b/src/southbridge/nvidia/mcp55/romstrap.lds @@ -20,7 +20,7 @@ */ SECTIONS { - . = (0x100000000 - 0x10) - (__romstrap_end - __romstrap_start); + . = (0xffffffff - 0x10) - (__romstrap_end - __romstrap_start) + 1; .romstrap (.): { *(.romstrap) } diff --git a/src/southbridge/sis/sis966/romstrap.lds b/src/southbridge/sis/sis966/romstrap.lds index c08aa32..4dad422 100644 --- a/src/southbridge/sis/sis966/romstrap.lds +++ b/src/southbridge/sis/sis966/romstrap.lds @@ -20,7 +20,7 @@ */ SECTIONS { - . = (0x100000000 - 0x10) - (__romstrap_end - __romstrap_start); + . = (0xffffffff - 0x10) - (__romstrap_end - __romstrap_start) + 1; .romstrap (.): { *(.romstrap) } diff --git a/src/southbridge/via/k8t890/romstrap.lds b/src/southbridge/via/k8t890/romstrap.lds index e2f470c..67deebc 100644 --- a/src/southbridge/via/k8t890/romstrap.lds +++ b/src/southbridge/via/k8t890/romstrap.lds @@ -22,7 +22,7 @@ /* Modified for K8T890 ROM strap by Rudolf Marek <r.marek(a)assembler.cz>. */ SECTIONS { - . = (0x100000000 - 0x2c) - (__romstrap_end - __romstrap_start); + . = (0xffffffff - 0x2c) - (__romstrap_end - __romstrap_start) + 1; .romstrap (.): { *(.romstrap) }

1 0

New patch to review for coreboot: 462841c libpayload: Add support for interrupt transfers in OHCI
by Nico Huber 20 Jun '12

20 Jun '12

Nico Huber (nico.huber(a)secunet.com) just uploaded a new patch set to gerrit, which you can find at http://review.coreboot.org/1128 -gerrit commit 462841cea7b618c36b8eb532df6cb090e7f13741 Author: Nico Huber <nico.huber(a)secunet.com> Date: Wed Jun 20 14:58:21 2012 +0200 libpayload: Add support for interrupt transfers in OHCI This adds support for usb interrupt transfers to the OHCI driver. Basically this enables support for HID keyboard devices. For each interrupt transfer endpoint, two queues of transfer descriptors (TDs) are maintained: the first with initialized TDs is linked to the periodic schedule of the host controller (HC), the second holds processed TDs which will be polled by the usb class driver. The HC moves processed TDs from its schedule to a done queue. We periodically fetch all TDs from the done queue, to put them on the queue associated with the endpoint, where they can be polled from. Fully processed TDs (i.e. which have gone throuch all of this) will be reinitialized and put on the first queue again. Change-Id: Iaab72c04087b36c9f0f6e539e31b47060c190015 Signed-off-by: Nico Huber <nico.huber(a)secunet.com> --- payloads/libpayload/drivers/usb/ohci.c | 230 +++++++++++++++++++++++- payloads/libpayload/drivers/usb/ohci_private.h | 1 + 2 files changed, 223 insertions(+), 8 deletions(-) diff --git a/payloads/libpayload/drivers/usb/ohci.c b/payloads/libpayload/drivers/usb/ohci.c index 105f601..2e22ecf 100644 --- a/payloads/libpayload/drivers/usb/ohci.c +++ b/payloads/libpayload/drivers/usb/ohci.c @@ -144,6 +144,8 @@ ohci_init (pcidev_t addr) OHCI_INST (controller)->periodic_ed = periodic_ed; OHCI_INST (controller)->opreg->HcHCCA = virt_to_phys(OHCI_INST (controller)->hcca); + /* Make sure periodic schedule is enabled. */ + OHCI_INST (controller)->opreg->HcControl |= PeriodicListEnable; 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 OHCI_INST (controller)->opreg->HcInterruptEnable = 1<<31; @@ -482,33 +484,215 @@ ohci_bulk (endpoint_t *ep, int dalen, u8 *data, int finalize) return failure; } + +struct _intr_queue; + +struct _intrq_td { + volatile td_t td; + u8 *data; + struct _intrq_td *next; + struct _intr_queue *intrq; +}; + +struct _intr_queue { + volatile ed_t ed; + struct _intrq_td *head; + struct _intrq_td *tail; + u8 *data; + int reqsize; + endpoint_t *endp; + unsigned int remaining_tds; +}; + +typedef struct _intrq_td intrq_td_t; +typedef struct _intr_queue intr_queue_t; + +#define INTRQ_TD_FROM_TD(x) ((intrq_td_t *)x) + +static void +ohci_fill_intrq_td(intrq_td_t *const td, intr_queue_t *const intrq, + u8 *const data) +{ + memset(td, 0, sizeof(*td)); + td->td.config = TD_QUEUETYPE_INTR | + (intrq->endp->direction == IN + ? TD_DIRECTION_IN : TD_DIRECTION_OUT) | + TD_DELAY_INTERRUPT_ZERO | + TD_TOGGLE_FROM_ED | + TD_CC_NOACCESS; + td->td.current_buffer_pointer = virt_to_phys(data); + td->td.buffer_end = td->td.current_buffer_pointer + intrq->reqsize - 1; + td->intrq = intrq; + td->data = data; +} + /* create and hook-up an intr queue into device schedule */ -static void* -ohci_create_intr_queue (endpoint_t *ep, int reqsize, int reqcount, int reqtiming) +static void * +ohci_create_intr_queue(endpoint_t *const ep, const int reqsize, + const int reqcount, const int reqtiming) { - return NULL; + int i; + intrq_td_t *first_td = NULL, *last_td = NULL; + + if (reqsize > 4096) + return NULL; + + intr_queue_t *const intrq = + (intr_queue_t *)memalign(sizeof(intrq->ed), sizeof(*intrq)); + memset(intrq, 0, sizeof(*intrq)); + intrq->data = (u8 *)malloc(reqcount * reqsize); + intrq->reqsize = reqsize; + intrq->endp = ep; + + /* Create #reqcount TDs. */ + u8 *cur_data = intrq->data; + for (i = 0; i < reqcount; ++i) { + intrq_td_t *const td = memalign(sizeof(td->td), sizeof(*td)); + ++intrq->remaining_tds; + ohci_fill_intrq_td(td, intrq, cur_data); + cur_data += reqsize; + if (!first_td) + first_td = td; + else + last_td->td.next_td = virt_to_phys(&td->td); + last_td = td; + } + + /* Create last, dummy TD. */ + intrq_td_t *dummy_td = memalign(sizeof(dummy_td->td), sizeof(*dummy_td)); + memset(dummy_td, 0, sizeof(*dummy_td)); + dummy_td->intrq = intrq; + if (last_td) + last_td->td.next_td = virt_to_phys(&dummy_td->td); + last_td = dummy_td; + + /* Initialize ED. */ + intrq->ed.config = (ep->dev->address << ED_FUNC_SHIFT) | + ((ep->endpoint & 0xf) << ED_EP_SHIFT) | + (((ep->direction == IN) ? OHCI_IN : OHCI_OUT) << ED_DIR_SHIFT) | + (ep->dev->speed ? ED_LOWSPEED : 0) | + (ep->maxpacketsize << ED_MPS_SHIFT); + intrq->ed.tail_pointer = virt_to_phys(last_td); + intrq->ed.head_pointer = virt_to_phys(first_td) | + (ep->toggle ? ED_TOGGLE : 0); + + /* Insert ED into periodic table. */ + int nothing_placed = 1; + ohci_t *const ohci = OHCI_INST(ep->dev->controller); + u32 *const intr_table = ohci->hcca->HccaInterruptTable; + const u32 dummy_ptr = virt_to_phys(ohci->periodic_ed); + for (i = 0; i < 32; i += reqtiming) { + /* Advance to the next free position. */ + while ((i < 32) && (intr_table[i] != dummy_ptr)) ++i; + if (i < 32) { + intr_table[i] = virt_to_phys(&intrq->ed); + nothing_placed = 0; + } + } + if (nothing_placed) { + printf("Error: Failed to place ohci interrupt endpoint " + "descriptor into periodic table: no space left\n"); + ohci_destroy_intr_queue(ep, intrq); + return NULL; + } + + return intrq; } /* remove queue from device schedule, dropping all data that came in */ static void -ohci_destroy_intr_queue (endpoint_t *ep, void *q_) +ohci_destroy_intr_queue(endpoint_t *const ep, void *const q_) { + intr_queue_t *const intrq = (intr_queue_t *)q_; + + int i; + + /* Remove interrupt queue from periodic table. */ + ohci_t *const ohci = OHCI_INST(ep->dev->controller); + u32 *const intr_table = ohci->hcca->HccaInterruptTable; + for (i=0; i < 32; ++i) { + if (intr_table[i] == virt_to_phys(intrq)) + intr_table[i] = virt_to_phys(ohci->periodic_ed); + } + /* Wait for frame to finish. */ + mdelay(1); + + /* Free unprocessed TDs. */ + while ((intrq->ed.head_pointer & ~0x3) != intrq->ed.tail_pointer) { + td_t *const cur_td = + (td_t *)phys_to_virt(intrq->ed.head_pointer & ~0x3); + intrq->ed.head_pointer = cur_td->next_td; + free(INTRQ_TD_FROM_TD(cur_td)); + --intrq->remaining_tds; + } + /* Free final, dummy TD. */ + free(phys_to_virt(intrq->ed.head_pointer & ~0x3)); + /* Free data buffer. */ + free(intrq->data); + + /* Process done queue and free processed TDs. */ + ohci_process_done_queue(ohci, 1); + while (intrq->head) { + intrq_td_t *const cur_td = intrq->head; + intrq->head = intrq->head->next; + free(cur_td); + --intrq->remaining_tds; + } + if (intrq->remaining_tds) { + printf("error: ohci_destroy_intr_queue(): " + "freed all but %d TDs.\n", intrq->remaining_tds); + } + + free(intrq); + + /* Save data toggle. */ + ep->toggle = intrq->ed.head_pointer & ED_TOGGLE; } /* read one intr-packet from queue, if available. extend the queue for new input. return NULL if nothing new available. Recommended use: while (data=poll_intr_queue(q)) process(data); */ -static u8* -ohci_poll_intr_queue (void *q_) +static u8 * +ohci_poll_intr_queue(void *const q_) { - return NULL; + intr_queue_t *const intrq = (intr_queue_t *)q_; + + u8 *data = NULL; + + /* Process done queue first, then check if we have work to do. */ + ohci_process_done_queue(OHCI_INST(intrq->endp->dev->controller), 0); + + if (intrq->head) { + /* Save pointer to processed TD and advance. */ + intrq_td_t *const cur_td = intrq->head; + intrq->head = cur_td->next; + + /* Return data buffer of this TD. */ + data = cur_td->data; + + /* Requeue this TD (i.e. copy to dummy and requeue as dummy). */ + intrq_td_t *const dummy_td = + INTRQ_TD_FROM_TD(phys_to_virt(intrq->ed.tail_pointer)); + ohci_fill_intrq_td(dummy_td, intrq, cur_td->data); + /* Reset all but intrq pointer (i.e. init as dummy). */ + memset(cur_td, 0, sizeof(*cur_td)); + cur_td->intrq = intrq; + /* Insert into interrupt queue as dummy. */ + dummy_td->td.next_td = virt_to_phys(&cur_td->td); + intrq->ed.tail_pointer = virt_to_phys(&cur_td->td); + } + + return data; } static void ohci_process_done_queue(ohci_t *const ohci, const int spew_debug) { - int i; + int i, j; + + /* Temporary queue of interrupt queue TDs (to reverse order). */ + intrq_td_t *temp_tdq = NULL; /* Check if done head has been written. */ if (!(ohci->opreg->HcInterruptStatus & WritebackDoneHead)) @@ -532,6 +716,11 @@ ohci_process_done_queue(ohci_t *const ohci, const int spew_debug) /* Free processed async TDs. */ free((void *)done_td); break; + case TD_QUEUETYPE_INTR: + /* Save done TD if it comes from an interrupt queue. */ + INTRQ_TD_FROM_TD(done_td)->next = temp_tdq; + temp_tdq = INTRQ_TD_FROM_TD(done_td); + break; default: break; } @@ -539,5 +728,30 @@ ohci_process_done_queue(ohci_t *const ohci, const int spew_debug) } if (spew_debug) debug("Processed %d done TDs.\n", i); + + j = 0; + /* Process interrupt queue TDs in right order. */ + while (temp_tdq) { + /* Save pointer of current TD and advance. */ + intrq_td_t *const cur_td = temp_tdq; + temp_tdq = temp_tdq->next; + + /* The interrupt queue for the current TD. */ + intr_queue_t *const intrq = cur_td->intrq; + /* Append to interrupt queue. */ + if (!intrq->head) { + /* First element. */ + intrq->head = intrq->tail = cur_td; + } else { + /* Insert at tail. */ + intrq->tail->next = cur_td; + intrq->tail = cur_td; + } + /* It's always the last element. */ + cur_td->next = NULL; + ++j; + } + if (spew_debug) + debug("processed %d done tds, %d intr tds thereof.\n", i, j); } diff --git a/payloads/libpayload/drivers/usb/ohci_private.h b/payloads/libpayload/drivers/usb/ohci_private.h index 3826db0..a32203c 100644 --- a/payloads/libpayload/drivers/usb/ohci_private.h +++ b/payloads/libpayload/drivers/usb/ohci_private.h @@ -231,6 +231,7 @@ #define TD_QUEUETYPE_SHIFT 0 #define TD_QUEUETYPE_MASK MASK(TD_QUEUETYPE_SHIFT, 2) #define TD_QUEUETYPE_ASYNC (0 << TD_QUEUETYPE_SHIFT) +#define TD_QUEUETYPE_INTR (1 << TD_QUEUETYPE_SHIFT) #define TD_DIRECTION_SHIFT 19 #define TD_DIRECTION_MASK MASK(TD_DIRECTION_SHIFT, 2)

1 0

New patch to review for coreboot: 8f0e148 libpayload: Adjust timeouts and delays in OHCI driver
by Nico Huber 20 Jun '12

20 Jun '12

Nico Huber (nico.huber(a)secunet.com) just uploaded a new patch set to gerrit, which you can find at http://review.coreboot.org/1127 -gerrit commit 8f0e148abe2490e677ed5f3ac588aea860c29c44 Author: Nico Huber <nico.huber(a)secunet.com> Date: Tue Jun 19 10:27:00 2012 +0200 libpayload: Adjust timeouts and delays in OHCI driver This sets the timeout for control and bulk transfers to 2s per transfer descriptor (like we set it in the EHCI driver). It also adds delays around the disabling of control and bulk list access to overcome some race conditions. Change-Id: Ia2d1db890fca51c7d9477de163d55030e0c5a04a Signed-off-by: Nico Huber <nico.huber(a)secunet.com> --- payloads/libpayload/drivers/usb/ohci.c | 13 +++++++++---- 1 files changed, 9 insertions(+), 4 deletions(-) diff --git a/payloads/libpayload/drivers/usb/ohci.c b/payloads/libpayload/drivers/usb/ohci.c index 6d98cc1..105f601 100644 --- a/payloads/libpayload/drivers/usb/ohci.c +++ b/payloads/libpayload/drivers/usb/ohci.c @@ -203,11 +203,10 @@ static int wait_for_ed(usbdev_t *dev, ed_t *head, int pages) { /* wait for results */ - /* TODO: how long to wait? - * give 50ms per page plus another 100ms for now - * this should even work with low-speed + /* TOTEST: how long to wait? + * give 2s per TD (2 pages) plus another 2s for now */ - int timeout = pages*50 + 100; + int timeout = pages*1000 + 2000; while (((head->head_pointer & ~3) != head->tail_pointer) && !(head->head_pointer & 1) && ((((td_t*)phys_to_virt(head->head_pointer & ~3))->config @@ -361,7 +360,10 @@ ohci_control (usbdev_t *dev, direction_t dir, int drlen, void *devreq, int dalen int failure = wait_for_ed(dev, head, (dalen==0)?0:(last_page - first_page + 1)); + /* Wait some frames before and one after disabling list access. */ + mdelay(4); OHCI_INST(dev->controller)->opreg->HcControl &= ~ControlListEnable; + mdelay(1); /* free memory */ ohci_free_ed(head); @@ -462,7 +464,10 @@ ohci_bulk (endpoint_t *ep, int dalen, u8 *data, int finalize) int failure = wait_for_ed(ep->dev, head, (dalen==0)?0:(last_page - first_page + 1)); + /* Wait some frames before and one after disabling list access. */ + mdelay(4); OHCI_INST(ep->dev->controller)->opreg->HcControl &= ~BulkListEnable; + mdelay(1); ep->toggle = head->head_pointer & ED_TOGGLE;

1 0

New patch to review for coreboot: ac87dc9 libpayload: Fix initialization of OHCI driver
by Nico Huber 20 Jun '12

20 Jun '12

Nico Huber (nico.huber(a)secunet.com) just uploaded a new patch set to gerrit, which you can find at http://review.coreboot.org/1126 -gerrit commit ac87dc97d32ca8c8cfa5aa163fbe7358b4dd3608 Author: Nico Huber <nico.huber(a)secunet.com> Date: Wed Jun 20 11:37:17 2012 +0200 libpayload: Fix initialization of OHCI driver This fixes some memory corruption, leaking and padding issues within the initialization of the OHCI driver. Change-Id: If6891f2a53e339d32c4324f4c9e0b1ed07596a60 Signed-off-by: Nico Huber <nico.huber(a)secunet.com> --- payloads/libpayload/drivers/usb/ohci.c | 14 +++++++++----- payloads/libpayload/drivers/usb/ohci_private.h | 22 ++++++++++++---------- 2 files changed, 21 insertions(+), 15 deletions(-) diff --git a/payloads/libpayload/drivers/usb/ohci.c b/payloads/libpayload/drivers/usb/ohci.c index be6d5e3..6d98cc1 100644 --- a/payloads/libpayload/drivers/usb/ohci.c +++ b/payloads/libpayload/drivers/usb/ohci.c @@ -129,17 +129,20 @@ ohci_init (pcidev_t addr) } int interval = OHCI_INST (controller)->opreg->HcFmInterval; - td_t *periodic_td = memalign(sizeof(*periodic_td), sizeof(*periodic_td)); - memset((void*)periodic_td, 0, sizeof(*periodic_td)); - for (i=0; i<32; i++) OHCI_INST (controller)->hcca->HccaInterruptTable[i] = virt_to_phys(periodic_td); - /* TODO: build HCCA data structures */ - 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) */ OHCI_INST (controller)->opreg->HcFmInterval = interval; OHCI_INST (controller)->hcca = memalign(256, 256); memset((void*)OHCI_INST (controller)->hcca, 0, 256); + /* Initialize interrupt table. */ + u32 *const intr_table = OHCI_INST(controller)->hcca->HccaInterruptTable; + ed_t *const periodic_ed = memalign(sizeof(ed_t), sizeof(ed_t)); + memset((void *)periodic_ed, 0, sizeof(*periodic_ed)); + for (i = 0; i < 32; ++i) + intr_table[i] = virt_to_phys(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->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 @@ -167,6 +170,7 @@ ohci_shutdown (hci_t *controller) ohci_stop(controller); OHCI_INST (controller)->roothub->destroy (OHCI_INST (controller)-> roothub); + free ((void *)OHCI_INST (controller)->periodic_ed); free (OHCI_INST (controller)); free (controller); } diff --git a/payloads/libpayload/drivers/usb/ohci_private.h b/payloads/libpayload/drivers/usb/ohci_private.h index 0bcae03..3826db0 100644 --- a/payloads/libpayload/drivers/usb/ohci_private.h +++ b/payloads/libpayload/drivers/usb/ohci_private.h @@ -189,22 +189,15 @@ volatile u32 HcRhPortStatus[]; } __attribute__ ((packed)) opreg_t; - typedef struct { + typedef struct { /* should be 256 bytes according to spec */ u32 HccaInterruptTable[32]; volatile u16 HccaFrameNumber; volatile u16 HccaPad1; volatile u32 HccaDoneHead; - u8 reserved[116]; // pad to 256 byte + u8 reserved[116]; /* pad according to spec */ + u8 what[4]; /* really pad to 256 as spec only covers 252 */ } __attribute__ ((packed)) hcca_t; - typedef struct ohci { - opreg_t *opreg; - hcca_t *hcca; - usbdev_t *roothub; - } ohci_t; - - typedef enum { OHCI_SETUP=0, OHCI_OUT=1, OHCI_IN=2, OHCI_FROM_TD=3 } ohci_pid_t; - typedef volatile struct { u32 config; u32 tail_pointer; @@ -259,4 +252,13 @@ #define OHCI_INST(controller) ((ohci_t*)((controller)->instance)) + typedef struct ohci { + opreg_t *opreg; + hcca_t *hcca; + usbdev_t *roothub; + ed_t *periodic_ed; + } ohci_t; + + typedef enum { OHCI_SETUP=0, OHCI_OUT=1, OHCI_IN=2, OHCI_FROM_TD=3 } ohci_pid_t; + #endif

1 0

New patch to review for coreboot: 54017e5 libpayload: Implement correct done queue processing for OHCI
by Nico Huber 20 Jun '12

20 Jun '12

Nico Huber (nico.huber(a)secunet.com) just uploaded a new patch set to gerrit, which you can find at http://review.coreboot.org/1125 -gerrit commit 54017e57d2430c50efdd838488e333a2e2d3935d Author: Nico Huber <nico.huber(a)secunet.com> Date: Wed Jun 20 10:08:06 2012 +0200 libpayload: Implement correct done queue processing for OHCI This adds correct processing of the done queue of the OHCI host controller (HC). We will always process the done queue after a control or bulk transfer. Unfortunately, it's hard to tell when the HC will write out the done queue, so we have do free the transfer descriptors later and have to allocate them one by one. To distinguish different types of TDs (e.g. async vs. interrupt transfers) on the done queue, they are flagged in the lsb of there .config field. We can utilize this bit for our own purpose, as it's reserved and the host controller won't interpret it and preserves its state. Change-Id: I3b2271ae6221cdd50fc0f94582afdfe52bf7e797 Signed-off-by: Nico Huber <nico.huber(a)secunet.com> --- payloads/libpayload/drivers/usb/ohci.c | 192 +++++++++++++++--------- payloads/libpayload/drivers/usb/ohci_private.h | 21 ++- 2 files changed, 137 insertions(+), 76 deletions(-) diff --git a/payloads/libpayload/drivers/usb/ohci.c b/payloads/libpayload/drivers/usb/ohci.c index 4b3aa39..be6d5e3 100644 --- a/payloads/libpayload/drivers/usb/ohci.c +++ b/payloads/libpayload/drivers/usb/ohci.c @@ -44,6 +44,7 @@ static int ohci_control (usbdev_t *dev, direction_t dir, int drlen, void *devreq 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 u8* ohci_poll_intr_queue (void *queue); +static void ohci_process_done_queue(ohci_t *ohci, int spew_debug); static void ohci_reset (hci_t *controller) @@ -197,8 +198,6 @@ dump_td(td_t *cur, int level) static int wait_for_ed(usbdev_t *dev, ed_t *head, int pages) { - td_t *cur; - /* wait for results */ /* TODO: how long to wait? * give 50ms per page plus another 100ms for now @@ -225,35 +224,8 @@ wait_for_ed(usbdev_t *dev, ed_t *head, int pages) if (timeout < 0) printf("Error: ohci: endpoint " "descriptor processing timed out.\n"); -#if 0 - /* XXX: The following debugging code may follow invalid lists and - * cause a reboot. - */ -#ifdef USB_DEBUG - if (OHCI_INST(dev->controller)->opreg->HcInterruptStatus & WritebackDoneHead) { - debug("done queue:\n"); - debug("%x, %x\n", OHCI_INST(dev->controller)->hcca->HccaDoneHead, phys_to_virt(OHCI_INST(dev->controller)->hcca->HccaDoneHead)); - if ((OHCI_INST(dev->controller)->hcca->HccaDoneHead & ~1) == 0) { - debug("HcInterruptStatus %x\n", OHCI_INST(dev->controller)->opreg->HcInterruptStatus); - } - td_t *done_queue = NULL; - td_t *done_head = (td_t*)phys_to_virt(OHCI_INST(dev->controller)->hcca->HccaDoneHead); - while (1) { - td_t *oldnext = (td_t*)phys_to_virt(done_head->next_td); - if (oldnext == done_queue) break; /* last element refers to second to last, ie. endless loop */ - if (oldnext == phys_to_virt(0)) break; /* last element of done list == first element of real list */ - debug("head is %x, pointing to %x. requeueing to %x\n", done_head, oldnext, done_queue); - done_head->next_td = (u32)done_queue; - done_queue = done_head; - done_head = oldnext; - } - for (cur = done_queue; cur != 0; cur = (td_t*)cur->next_td) { - dump_td(cur, 1); - } - OHCI_INST(dev->controller)->opreg->HcInterruptStatus &= ~WritebackDoneHead; - } -#endif -#endif + /* Clear the done queue. */ + ohci_process_done_queue(OHCI_INST(dev->controller), 1); if (head->head_pointer & 1) { debug("HALTED!\n"); @@ -262,12 +234,31 @@ wait_for_ed(usbdev_t *dev, ed_t *head, int pages) return 0; } +static void +ohci_free_ed (ed_t *const head) +{ + /* In case the transfer canceled, we have to free unprocessed TDs. */ + while ((head->head_pointer & ~0x3) != head->tail_pointer) { + /* Save current TD pointer. */ + td_t *const cur_td = + (td_t*)phys_to_virt(head->head_pointer & ~0x3); + /* Advance head pointer. */ + head->head_pointer = cur_td->next_td; + /* Free current TD. */ + free((void *)cur_td); + } + + /* Always free the dummy TD */ + if ((head->head_pointer & ~0x3) == head->tail_pointer) + free(phys_to_virt(head->head_pointer & ~0x3)); + /* and the ED. */ + free((void *)head); +} + static int ohci_control (usbdev_t *dev, direction_t dir, int drlen, void *devreq, int dalen, unsigned char *data) { - int i; - td_t *cur; // pages are specified as 4K in OHCI, so don't use getpagesize() @@ -275,30 +266,31 @@ ohci_control (usbdev_t *dev, direction_t dir, int drlen, void *devreq, int dalen int last_page = (unsigned long)(data+dalen-1)/4096; if (last_page < first_page) last_page = first_page; int pages = (dalen==0)?0:(last_page - first_page + 1); - int td_count = (pages+1)/2; - td_t *tds = memalign(sizeof(td_t), (td_count+3)*sizeof(td_t)); - memset((void*)tds, 0, (td_count+3)*sizeof(td_t)); + /* First TD. */ + td_t *const first_td = (td_t *)memalign(sizeof(td_t), sizeof(td_t)); + memset((void *)first_td, 0, sizeof(*first_td)); + cur = first_td; - for (i=0; i < td_count + 3; i++) { - tds[i].next_td = virt_to_phys(&tds[i+1]); - } - tds[td_count + 3].next_td = 0; - - tds[0].config = TD_DIRECTION_SETUP | - TD_DELAY_INTERRUPT_NODELAY | + cur->config = TD_DIRECTION_SETUP | + TD_DELAY_INTERRUPT_NOINTR | TD_TOGGLE_FROM_TD | TD_TOGGLE_DATA0 | TD_CC_NOACCESS; - tds[0].current_buffer_pointer = virt_to_phys(devreq); - tds[0].buffer_end = virt_to_phys(devreq + drlen - 1); - - cur = &tds[0]; + cur->current_buffer_pointer = virt_to_phys(devreq); + cur->buffer_end = virt_to_phys(devreq + drlen - 1); while (pages > 0) { - cur++; + /* One more TD. */ + td_t *const next = (td_t *)memalign(sizeof(td_t), sizeof(td_t)); + memset((void *)next, 0, sizeof(*next)); + /* Linked to the previous. */ + cur->next_td = virt_to_phys(next); + /* Advance to the new TD. */ + cur = next; + cur->config = (dir == IN ? TD_DIRECTION_IN : TD_DIRECTION_OUT) | - TD_DELAY_INTERRUPT_NODELAY | + TD_DELAY_INTERRUPT_NOINTR | TD_TOGGLE_FROM_ED | TD_CC_NOACCESS; cur->current_buffer_pointer = virt_to_phys(data); @@ -323,17 +315,26 @@ ohci_control (usbdev_t *dev, direction_t dir, int drlen, void *devreq, int dalen } } - cur++; + /* One more TD. */ + td_t *const next_td = (td_t *)memalign(sizeof(td_t), sizeof(td_t)); + memset((void *)next_td, 0, sizeof(*next_td)); + /* Linked to the previous. */ + cur->next_td = virt_to_phys(next_td); + /* Advance to the new TD. */ + cur = next_td; cur->config = (dir == IN ? TD_DIRECTION_OUT : TD_DIRECTION_IN) | - TD_DELAY_INTERRUPT_NODELAY | + TD_DELAY_INTERRUPT_ZERO | /* Write done head after this TD. */ TD_TOGGLE_FROM_TD | TD_TOGGLE_DATA1 | TD_CC_NOACCESS; cur->current_buffer_pointer = 0; cur->buffer_end = 0; - /* final dummy TD */ - cur++; + /* Final dummy TD. */ + td_t *const final_td = (td_t *)memalign(sizeof(td_t), sizeof(td_t)); + memset((void *)final_td, 0, sizeof(*final_td)); + /* Linked to the previous. */ + cur->next_td = virt_to_phys(final_td); /* Data structures */ ed_t *head = memalign(sizeof(ed_t), sizeof(ed_t)); @@ -343,10 +344,11 @@ ohci_control (usbdev_t *dev, direction_t dir, int drlen, void *devreq, int dalen (OHCI_FROM_TD << ED_DIR_SHIFT) | (dev->speed?ED_LOWSPEED:0) | (dev->endpoints[0].maxpacketsize << ED_MPS_SHIFT); - head->tail_pointer = virt_to_phys(cur); - head->head_pointer = virt_to_phys(tds); + head->tail_pointer = virt_to_phys(final_td); + head->head_pointer = virt_to_phys(first_td); - debug("doing control transfer with %x. first_td at %x\n", head->config & ED_FUNC_MASK, virt_to_phys(tds)); + debug("doing control transfer with %x. first_td at %x\n", + head->config & ED_FUNC_MASK, virt_to_phys(first_td)); /* activate schedule */ OHCI_INST(dev->controller)->opreg->HcControlHeadED = virt_to_phys(head); @@ -358,8 +360,7 @@ ohci_control (usbdev_t *dev, direction_t dir, int drlen, void *devreq, int dalen OHCI_INST(dev->controller)->opreg->HcControl &= ~ControlListEnable; /* free memory */ - free((void*)tds); - free((void*)head); + ohci_free_ed(head); return failure; } @@ -371,7 +372,7 @@ ohci_bulk (endpoint_t *ep, int dalen, u8 *data, int finalize) int i; debug("bulk: %x bytes from %x, finalize: %x, maxpacketsize: %x\n", dalen, data, finalize, ep->maxpacketsize); - td_t *cur; + td_t *cur, *next; // pages are specified as 4K in OHCI, so don't use getpagesize() int first_page = (unsigned long)data / 4096; @@ -384,16 +385,16 @@ ohci_bulk (endpoint_t *ep, int dalen, u8 *data, int finalize) td_count++; } - td_t *tds = memalign(sizeof(td_t), (td_count+1)*sizeof(td_t)); - memset((void*)tds, 0, (td_count+1)*sizeof(td_t)); - - for (i=0; i < td_count; i++) { - tds[i].next_td = virt_to_phys(&tds[i+1]); - } + /* First TD. */ + td_t *const first_td = (td_t *)memalign(sizeof(td_t), sizeof(td_t)); + memset((void *)first_td, 0, sizeof(*first_td)); + cur = next = first_td; - for (cur = tds; cur->next_td != 0; cur++) { + for (i = 0; i < td_count; ++i) { + /* Advance to next TD. */ + cur = next; cur->config = (ep->direction == IN ? TD_DIRECTION_IN : TD_DIRECTION_OUT) | - TD_DELAY_INTERRUPT_NODELAY | + TD_DELAY_INTERRUPT_NOINTR | TD_TOGGLE_FROM_ED | TD_CC_NOACCESS; cur->current_buffer_pointer = virt_to_phys(data); @@ -422,8 +423,18 @@ ohci_bulk (endpoint_t *ep, int dalen, u8 *data, int finalize) dalen -= second_page_size; data += second_page_size; } + /* One more TD. */ + next = (td_t *)memalign(sizeof(td_t), sizeof(td_t)); + memset((void *)next, 0, sizeof(*next)); + /* Linked to the previous. */ + cur->next_td = virt_to_phys(next); } + /* Write done head after last TD. */ + cur->config &= ~TD_DELAY_INTERRUPT_MASK; + /* Advance to final, dummy TD. */ + cur = next; + /* Data structures */ ed_t *head = memalign(sizeof(ed_t), sizeof(ed_t)); memset((void*)head, 0, sizeof(*head)); @@ -433,10 +444,12 @@ ohci_bulk (endpoint_t *ep, int dalen, u8 *data, int finalize) (ep->dev->speed?ED_LOWSPEED:0) | (ep->maxpacketsize << ED_MPS_SHIFT); head->tail_pointer = virt_to_phys(cur); - head->head_pointer = virt_to_phys(tds) | (ep->toggle?ED_TOGGLE:0); + head->head_pointer = virt_to_phys(first_td) | (ep->toggle?ED_TOGGLE:0); - debug("doing bulk transfer with %x(%x). first_td at %x, last %x\n", head->config & ED_FUNC_MASK, - (head->config & ED_EP_MASK) >> ED_EP_SHIFT, virt_to_phys(tds), virt_to_phys(cur)); + debug("doing bulk transfer with %x(%x). first_td at %x, last %x\n", + head->config & ED_FUNC_MASK, + (head->config & ED_EP_MASK) >> ED_EP_SHIFT, + virt_to_phys(first_td), virt_to_phys(cur)); /* activate schedule */ OHCI_INST(ep->dev->controller)->opreg->HcBulkHeadED = virt_to_phys(head); @@ -450,8 +463,7 @@ ohci_bulk (endpoint_t *ep, int dalen, u8 *data, int finalize) ep->toggle = head->head_pointer & ED_TOGGLE; /* free memory */ - free((void*)tds); - free((void*)head); + ohci_free_ed(head); if (failure) { /* try cleanup */ @@ -484,3 +496,39 @@ ohci_poll_intr_queue (void *q_) return NULL; } +static void +ohci_process_done_queue(ohci_t *const ohci, const int spew_debug) +{ + int i; + + /* Check if done head has been written. */ + if (!(ohci->opreg->HcInterruptStatus & WritebackDoneHead)) + return; + /* Fetch current done head. + Lsb is only interesting for hw interrupts. */ + u32 phys_done_queue = ohci->hcca->HccaDoneHead & ~1; + /* Tell host controller, he may overwrite the done head pointer. */ + ohci->opreg->HcInterruptStatus = WritebackDoneHead; + + i = 0; + /* Process done queue (it's in reversed order). */ + while (phys_done_queue) { + td_t *const done_td = (td_t *)phys_to_virt(phys_done_queue); + + /* Advance pointer to next TD. */ + phys_done_queue = done_td->next_td; + + switch (done_td->config & TD_QUEUETYPE_MASK) { + case TD_QUEUETYPE_ASYNC: + /* Free processed async TDs. */ + free((void *)done_td); + break; + default: + break; + } + ++i; + } + if (spew_debug) + debug("Processed %d done TDs.\n", i); +} + diff --git a/payloads/libpayload/drivers/usb/ohci_private.h b/payloads/libpayload/drivers/usb/ohci_private.h index a60b294..0bcae03 100644 --- a/payloads/libpayload/drivers/usb/ohci_private.h +++ b/payloads/libpayload/drivers/usb/ohci_private.h @@ -191,9 +191,9 @@ typedef struct { u32 HccaInterruptTable[32]; - u16 HccaFrameNumber; - u16 HccaPad1; - u32 HccaDoneHead; + volatile u16 HccaFrameNumber; + volatile u16 HccaPad1; + volatile u32 HccaDoneHead; u8 reserved[116]; // pad to 256 byte } __attribute__ ((packed)) hcca_t; @@ -229,12 +229,25 @@ u32 next_td; u32 buffer_end; } __attribute__ ((packed)) td_t; +/* + * Bits 0 through 17 of .config won't be interpreted by the host controller + * (HC) and, after processing the TD, the HC has to ensure those bits have + * the same state as before. So we are free to use those bits for our own + * purpose. + */ +#define TD_QUEUETYPE_SHIFT 0 +#define TD_QUEUETYPE_MASK MASK(TD_QUEUETYPE_SHIFT, 2) +#define TD_QUEUETYPE_ASYNC (0 << TD_QUEUETYPE_SHIFT) + #define TD_DIRECTION_SHIFT 19 #define TD_DIRECTION_MASK MASK(TD_DIRECTION_SHIFT, 2) #define TD_DIRECTION_SETUP OHCI_SETUP << TD_DIRECTION_SHIFT #define TD_DIRECTION_IN OHCI_IN << TD_DIRECTION_SHIFT #define TD_DIRECTION_OUT OHCI_OUT << TD_DIRECTION_SHIFT -#define TD_DELAY_INTERRUPT_NODELAY (7 << 21) +#define TD_DELAY_INTERRUPT_SHIFT 21 +#define TD_DELAY_INTERRUPT_MASK MASK(TD_DELAY_INTERRUPT_SHIFT, 3) +#define TD_DELAY_INTERRUPT_ZERO 0 +#define TD_DELAY_INTERRUPT_NOINTR (7 << TD_DELAY_INTERRUPT_SHIFT) #define TD_TOGGLE_DATA0 0 #define TD_TOGGLE_DATA1 (1 << 24) #define TD_TOGGLE_FROM_ED 0

1 0

New patch to review for coreboot: 0d93130 libpayload: Add dummy queue heads to EHCI interrupt frame list
by Nico Huber 20 Jun '12

20 Jun '12

Nico Huber (nico.huber(a)secunet.com) just uploaded a new patch set to gerrit, which you can find at http://review.coreboot.org/1124 -gerrit commit 0d93130883dd16165344d56447c29ee5913a5695 Author: Nico Huber <nico.huber(a)secunet.com> Date: Thu Jun 14 13:27:39 2012 +0200 libpayload: Add dummy queue heads to EHCI interrupt frame list This introduces a dummy queue head in the interrupt frame list of the EHCI host controller. It's a workaround for broken controllers which follow pointers from this list even if the terminate bit is set. Fortunately, they do honor the bit in queue heads and having an empty QH in the list doesn't violate the standard. The linux kernel has a similar workaround for AMD SB700, SB800, and Hudson-2/3 platforms. We observed this bug with an AMD SB600. Change-Id: Ibbb66dea5fddc89c7995a24d746bedf6bfa887be Signed-off-by: Nico Huber <nico.huber(a)secunet.com> --- payloads/libpayload/drivers/usb/ehci.c | 24 +++++++++++++++++++++--- payloads/libpayload/drivers/usb/ehci_private.h | 1 + 2 files changed, 22 insertions(+), 3 deletions(-) diff --git a/payloads/libpayload/drivers/usb/ehci.c b/payloads/libpayload/drivers/usb/ehci.c index d99901a..8843876 100644 --- a/payloads/libpayload/drivers/usb/ehci.c +++ b/payloads/libpayload/drivers/usb/ehci.c @@ -83,6 +83,9 @@ static void ehci_shutdown (hci_t *controller) /* Free periodic frame list */ free(phys_to_virt(EHCI_INST(controller)->operation->periodiclistbase)); + /* Free dummy QH */ + free(EHCI_INST(controller)->dummy_qh); + EHCI_INST(controller)->operation->configflag = 0; } @@ -521,9 +524,11 @@ static void *ehci_create_intr_queue( int nothing_placed = 1; u32 *const ps = (u32 *)phys_to_virt(EHCI_INST(ep->dev->controller) ->operation->periodiclistbase); + const u32 dummy_ptr = virt_to_phys(EHCI_INST( + ep->dev->controller)->dummy_qh) | PS_TYPE_QH; for (i = 0; i < 1024; i += reqtiming) { /* advance to the next free position */ - while ((i < 1024) && !(ps[i] & PS_TERMINATE)) ++i; + while ((i < 1024) && (ps[i] != dummy_ptr)) ++i; if (i < 1024) { ps[i] = virt_to_phys(&intrq->qh) | PS_TYPE_QH; nothing_placed = 0; @@ -547,9 +552,11 @@ static void ehci_destroy_intr_queue(endpoint_t *const ep, void *const queue) int i; u32 *const ps = (u32 *)phys_to_virt(EHCI_INST( ep->dev->controller)->operation->periodiclistbase); + const u32 dummy_ptr = virt_to_phys(EHCI_INST( + ep->dev->controller)->dummy_qh) | PS_TYPE_QH; for (i = 0; i < 1024; ++i) { if ((ps[i] & PS_PTR_MASK) == virt_to_phys(&intrq->qh)) - ps[i] = PS_TERMINATE; + ps[i] = dummy_ptr; } /* wait 1ms for frame to end */ @@ -660,8 +667,19 @@ ehci_init (pcidev_t addr) u32 *const periodic_list = (u32 *)memalign(4096, 1024 * sizeof(u32)); if (!periodic_list) fatal("Not enough memory creating EHCI periodic frame list.\n"); + + /* + * Insert dummy QH in periodic frame list + * This helps with broken host controllers + * and doesn't violate the standard. + */ + EHCI_INST(controller)->dummy_qh = (ehci_qh_t *)memalign(32, sizeof(ehci_qh_t)); + memset(EHCI_INST(controller)->dummy_qh, 0, + sizeof(*EHCI_INST(controller)->dummy_qh)); + EHCI_INST(controller)->dummy_qh->horiz_link_ptr = QH_TERMINATE; for (i = 0; i < 1024; ++i) - periodic_list[i] = PS_TERMINATE; + periodic_list[i] = virt_to_phys(EHCI_INST(controller)->dummy_qh) + | PS_TYPE_QH; /* Make sure periodic schedule is disabled */ ehci_set_periodic_schedule(EHCI_INST(controller), 0); diff --git a/payloads/libpayload/drivers/usb/ehci_private.h b/payloads/libpayload/drivers/usb/ehci_private.h index a97336b..3276e23 100644 --- a/payloads/libpayload/drivers/usb/ehci_private.h +++ b/payloads/libpayload/drivers/usb/ehci_private.h @@ -132,6 +132,7 @@ typedef volatile struct { typedef struct ehci { hc_cap_t *capabilities; hc_op_t *operation; + ehci_qh_t *dummy_qh; } ehci_t; #define PS_TERMINATE 1

1 0

New patch to review for coreboot: 31887a0 libpayload: Add interrupt-queue underrun recovery to EHCI
by Nico Huber 20 Jun '12

20 Jun '12

Nico Huber (nico.huber(a)secunet.com) just uploaded a new patch set to gerrit, which you can find at http://review.coreboot.org/1123 -gerrit commit 31887a042a68fb05a6718183aaa1eded4ea3e4a1 Author: Nico Huber <nico.huber(a)secunet.com> Date: Thu Jun 14 13:08:36 2012 +0200 libpayload: Add interrupt-queue underrun recovery to EHCI If the queue of an interrupt transfer runs out, we have to reset the queue head. This also introduces the use of a spare transfer descriptor (TD) in interrupt queues, which assures, that a processed TD won't be reused until the host controller has written it back from his overlay. Change-Id: Id0eeb2808b77f1c187f164eb34bd66f8f399938b Signed-off-by: Nico Huber <nico.huber(a)secunet.com> --- payloads/libpayload/drivers/usb/ehci.c | 41 ++++++++++++++++++++----------- 1 files changed, 26 insertions(+), 15 deletions(-) diff --git a/payloads/libpayload/drivers/usb/ehci.c b/payloads/libpayload/drivers/usb/ehci.c index 9e17571..d99901a 100644 --- a/payloads/libpayload/drivers/usb/ehci.c +++ b/payloads/libpayload/drivers/usb/ehci.c @@ -410,6 +410,7 @@ typedef struct { volatile ehci_qh_t qh; intr_qtd_t *head; intr_qtd_t *tail; + intr_qtd_t *spare; u8 *data; endpoint_t *endp; int reqsize; @@ -466,7 +467,11 @@ static void *ehci_create_intr_queue( intr_queue_t *const intrq = (intr_queue_t *)memalign(32, sizeof(intr_queue_t)); - u8 *data = (u8 *)malloc(reqsize * reqcount); + /* + * reqcount data chunks + * plus one more spare, which we'll leave out of queue + */ + u8 *data = (u8 *)malloc(reqsize * (reqcount + 1)); if (!intrq || !data) fatal("Not enough memory to create USB interrupt queue.\n"); intrq->data = data; @@ -490,6 +495,10 @@ static void *ehci_create_intr_queue( } intrq->tail = cur_td; + /* create spare qTD */ + intrq->spare = (intr_qtd_t *)memalign(32, sizeof(intr_qtd_t)); + fill_intr_queue_td(intrq, intrq->spare, data); + /* initialize QH */ const int endp = ep->endpoint & 0xf; memset(&intrq->qh, 0, sizeof(intrq->qh)); @@ -558,6 +567,7 @@ static void ehci_destroy_intr_queue(endpoint_t *const ep, void *const queue) /* free current interrupt qTD */ free(to_free); } + free(intrq->spare); free(intrq->data); free(intrq); } @@ -569,9 +579,7 @@ static u8 *ehci_poll_intr_queue(void *const queue) u8 *ret = NULL; /* process if head qTD is inactive AND QH has been moved forward */ - if (!(intrq->head->td.token & QTD_ACTIVE) && - (intrq->qh.current_td_ptr != - virt_to_phys(&intrq->head->td))) { + if (!(intrq->head->td.token & QTD_ACTIVE)) { if (!(intrq->head->td.token & QTD_STATUS_MASK)) ret = intrq->head->data; else @@ -579,18 +587,21 @@ static u8 *ehci_poll_intr_queue(void *const queue) "status == 0x%02x\n", intrq->head->td.token & QTD_STATUS_MASK); - /* save and advance our head ptr */ - intr_qtd_t *const new_td = intrq->head; - intrq->head = intrq->head->next; - - /* reuse executed qTD */ - fill_intr_queue_td(intrq, new_td, new_td->data); - - /* at last insert reused qTD at the - * end and advance our tail ptr */ - intrq->tail->td.next_qtd = virt_to_phys(&new_td->td); - intrq->tail->next = new_td; + /* insert spare qTD at the end and advance our tail ptr */ + fill_intr_queue_td(intrq, intrq->spare, intrq->spare->data); + intrq->tail->td.next_qtd = virt_to_phys(&intrq->spare->td); + intrq->tail->next = intrq->spare; intrq->tail = intrq->tail->next; + + /* reuse executed qTD as spare one and advance our head ptr */ + intrq->spare = intrq->head; + intrq->head = intrq->head->next; + } + /* reset queue if we fully processed it after underrun */ + else if (intrq->qh.td.next_qtd & QTD_TERMINATE) { + debug("resetting underrun ehci interrupt queue.\n"); + memset(&intrq->qh.td, 0, sizeof(intrq->qh.td)); + intrq->qh.td.next_qtd = virt_to_phys(&intrq->head->td); } return ret; }

1 0

New patch to review for coreboot: 6f974f6 libpayload: Correct interchanged parameters in OHCI driver
by Nico Huber 20 Jun '12

20 Jun '12

Nico Huber (nico.huber(a)secunet.com) just uploaded a new patch set to gerrit, which you can find at http://review.coreboot.org/1122 -gerrit commit 6f974f68ec5db45302bf5c89e94475be2d354422 Author: Nico Huber <nico.huber(a)secunet.com> Date: Wed Jun 13 15:49:09 2012 +0200 libpayload: Correct interchanged parameters in OHCI driver In ohci_private.h some invocations of a MASK macro were called with its parameters interchanged. This fixes it with the hope not to break anything nasty. Change-Id: I56cb483b208442b497dbd32ce993cc53d1fba1e5 Signed-off-by: Nico Huber <nico.huber(a)secunet.com> --- payloads/libpayload/drivers/usb/ohci_private.h | 10 +++++----- 1 files changed, 5 insertions(+), 5 deletions(-) diff --git a/payloads/libpayload/drivers/usb/ohci_private.h b/payloads/libpayload/drivers/usb/ohci_private.h index d0b8ffc..a60b294 100644 --- a/payloads/libpayload/drivers/usb/ohci_private.h +++ b/payloads/libpayload/drivers/usb/ohci_private.h @@ -215,11 +215,11 @@ #define ED_TOGGLE 2 #define ED_FUNC_SHIFT 0 -#define ED_FUNC_MASK MASK(7, 0) +#define ED_FUNC_MASK MASK(0, 7) #define ED_EP_SHIFT 7 -#define ED_EP_MASK MASK(4, 7) +#define ED_EP_MASK MASK(7, 4) #define ED_DIR_SHIFT 11 -#define ED_DIR_MASK MASK(2, 11) +#define ED_DIR_MASK MASK(11, 2) #define ED_LOWSPEED (1 << 13) #define ED_MPS_SHIFT 16 @@ -230,7 +230,7 @@ u32 buffer_end; } __attribute__ ((packed)) td_t; #define TD_DIRECTION_SHIFT 19 -#define TD_DIRECTION_MASK MASK(2, TD_DIRECTION_SHIFT) +#define TD_DIRECTION_MASK MASK(TD_DIRECTION_SHIFT, 2) #define TD_DIRECTION_SETUP OHCI_SETUP << TD_DIRECTION_SHIFT #define TD_DIRECTION_IN OHCI_IN << TD_DIRECTION_SHIFT #define TD_DIRECTION_OUT OHCI_OUT << TD_DIRECTION_SHIFT @@ -240,7 +240,7 @@ #define TD_TOGGLE_FROM_ED 0 #define TD_TOGGLE_FROM_TD (1 << 25) #define TD_CC_SHIFT 28 -#define TD_CC_MASK MASK(4, TD_CC_SHIFT) +#define TD_CC_MASK MASK(TD_CC_SHIFT, 4) #define TD_CC_NOERR 0 #define TD_CC_NOACCESS (14 << TD_CC_SHIFT) /* the lower of the two values, so "no access" can be tested with >= */

1 0

← Newer
1
...
8
9
10
11
12
13
14
...
25
Older →

Jump to page:

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

2003

2002

coreboot June 2012