projects / ppcskel.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
new hottie: calloc != memalign. after s/calloc/memalign the HC
[ppcskel.git] / usb / host / ohci.c
diff --git a/usb/host/ohci.c b/usb/host/ohci.c
index 777eaac7638b919232dd3c50d4b625247a8c4833..89f3fd22be5a5f0868f8b58ad2e9511a4abf3be2 100644 (file)
--- a/usb/host/ohci.c
+++ b/usb/host/ohci.c
@@ -31,7 +31,8 @@ static struct ohci_hcca hcca_oh0;
 static struct endpoint_descriptor *allocate_endpoint()
 {
        struct endpoint_descriptor *ep;
-       ep = (struct endpoint_descriptor *)calloc(sizeof(struct endpoint_descriptor), 16);
+       //memalign instead of calloc doesn't work here?! WTF
+       ep = (struct endpoint_descriptor *)memalign(sizeof(struct endpoint_descriptor), 16);
        ep->flags = ACCESS_LE(OHCI_ENDPOINT_GENERAL_FORMAT);
        ep->headp = ep->tailp = ep->nexted = ACCESS_LE(0);
        return ep;
@@ -40,13 +41,14 @@ static struct endpoint_descriptor *allocate_endpoint()
 static struct general_td *allocate_general_td(size_t bsize)
 {
        struct general_td *td;
-       td = (struct general_td *)calloc(sizeof(struct general_td), 16);
+       td = (struct general_td *)memalign(sizeof(struct general_td), 16);
        td->flags = ACCESS_LE(0);
        td->nexttd = ACCESS_LE(virt_to_phys(td));
        if(bsize == 0) {
                td->cbp = td->be = ACCESS_LE(0);
        } else {
-               td->cbp = ACCESS_LE(virt_to_phys(malloc(bsize)));
+               //td->cbp = ACCESS_LE(virt_to_phys(memalign(bsize, 16))); //memailgn required here?
+               td->cbp = ACCESS_LE(virt_to_phys(malloc(bsize))); //memailgn required here?
                td->be = ACCESS_LE(ACCESS_LE(td->cbp) + bsize - 1);
        }
        return td;
@@ -102,8 +104,8 @@ static void control_quirk()
                 * Load the special empty ED and tell the controller to
                 * process the control list.
                 */
-               sync_after_write(ed, 64);
-               sync_after_write(td, 64);
+               sync_after_write(ed, 16);
+               sync_after_write(td, 16);
                write32(OHCI0_HC_CTRL_HEAD_ED, virt_to_phys(ed));
 
                status = read32(OHCI0_HC_CONTROL);
@@ -155,22 +157,14 @@ u8 hcdi_enqueue(usb_transfer_descriptor *td) {
        control_quirk();
 
        printf( "===========================\n"
-                       "===========================\n"
-                       "done head (vor sync): 0x%08X\n", ACCESS_LE(hcca_oh0.done_head));
+                       "===========================\n");
        sync_before_read(&hcca_oh0, 256);
        printf("done head (nach sync): 0x%08X\n", ACCESS_LE(hcca_oh0.done_head));
-       printf("HCCA->frame_no after %d seconds: %d\n", 0, ACCESS_LE(hcca_oh0.frame_no));
-       printf("HCCA->frame_no WITHOUT conversion macro: %d\n", hcca_oh0.frame_no);
-       if(!first) {
-               first = 1;
-               udelay(1000000);
-               sync_before_read(&hcca_oh0, 256);
-               printf("HCCA->frame_no after %d seconds: %d\n", 1, ACCESS_LE(hcca_oh0.frame_no));
-               printf("HCCA->frame_no WITHOUT conversion macro: %d\n", hcca_oh0.frame_no);
-       }
+       printf("HCCA->frame_no: %d\nhcca->hccapad1: %d\n", ((ACCESS_LE(hcca_oh0.frame_no) & 0xffff0000)>>16), ACCESS_LE(hcca_oh0.frame_no)&0xffff );
+       if(hcca_oh0.done_head) printf("WWWWWWWWOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTT\n");
 
        struct general_td *tmptd = allocate_general_td(td->actlen);
-       (void) memcpy((void*) (phys_to_virt(ACCESS_LE(tmptd->cbp))), td->buffer, td->actlen); /* throws dsi exception after some time :X */
+       (void) memcpy((void*) (phys_to_virt(ACCESS_LE(tmptd->cbp))), td->buffer, td->actlen); 
 
        tmptd->flags &= ACCESS_LE(~OHCI_TD_DIRECTION_PID_MASK);
        switch(td->pid) {
@@ -189,22 +183,18 @@ u8 hcdi_enqueue(usb_transfer_descriptor *td) {
        }
        tmptd->flags |= ACCESS_LE((td->togl) ? OHCI_TD_TOGGLE_1 : OHCI_TD_TOGGLE_0);
 
-       printf("tmptd hexump (before):\n");
+       printf("tmptd hexdump (before) 0x%08X:\n", tmptd);
        hexdump(tmptd, sizeof(struct general_td));
-       printf("tmptd-cbp hexump (before):\n");
-       hexdump((void*) (phys_to_virt(ACCESS_LE(tmptd->cbp))), td->actlen);
+       printf("tmptd->cbp hexdump (before) 0x%08X:\n", tmptd->cbp);
+       hexdump((void*) phys_to_virt(ACCESS_LE(tmptd->cbp)), td->actlen);
 
-       sync_after_write((void*) ACCESS_LE(tmptd->cbp), td->actlen);
+       sync_after_write((void*) phys_to_virt(ACCESS_LE(tmptd->cbp)), td->actlen);
        sync_after_write(tmptd, sizeof(struct general_td));
 
        struct endpoint_descriptor *dummyconfig = allocate_endpoint();
 
-       u32 current2 = read32(OHCI0_HC_CTRL_CURRENT_ED);
-       printf("current2: 0x%08X\n", current2);
-
 #define ED_MASK2 ~0 /*((u32)~0x0f) */
 #define ED_MASK ((u32)~0x0f) 
-       printf("tmpdt & ED_MASK: 0x%08X\n", virt_to_phys((void*) ((u32)tmptd & ED_MASK)));
        dummyconfig->tailp = dummyconfig->headp = ACCESS_LE(virt_to_phys((void*) ((u32)tmptd & ED_MASK)));
 
        dummyconfig->flags |= ACCESS_LE(OHCI_ENDPOINT_LOW_SPEED | 
@@ -212,10 +202,13 @@ u8 hcdi_enqueue(usb_transfer_descriptor *td) {
                OHCI_ENDPOINT_SET_ENDPOINT_NUMBER(td->endpoint) |
                OHCI_ENDPOINT_SET_MAX_PACKET_SIZE(td->maxp));
 
-       sync_after_write(dummyconfig, 64);
+       printf("dummyconfig hexdump (before) 0x%08X:\n", dummyconfig);
+       hexdump((void*) dummyconfig, 16);
+
+       sync_after_write(dummyconfig, 16);
        write32(OHCI0_HC_CTRL_HEAD_ED, virt_to_phys(dummyconfig));
 
-       printf("OHCI_CTRL_CLE: 0x%08X\n", read32(OHCI0_HC_CONTROL)&OHCI_CTRL_CLE);
+       printf("OHCI_CTRL_CLE: 0x%08X || ", read32(OHCI0_HC_CONTROL)&OHCI_CTRL_CLE);
        printf("OHCI_CLF: 0x%08X\n", read32(OHCI0_HC_COMMAND_STATUS)&OHCI_CLF);
        set32(OHCI0_HC_CONTROL, OHCI_CTRL_CLE);
        write32(OHCI0_HC_COMMAND_STATUS, OHCI_CLF);
@@ -229,34 +222,29 @@ u8 hcdi_enqueue(usb_transfer_descriptor *td) {
                current = read32(OHCI0_HC_CTRL_CURRENT_ED);
        }
 
-       udelay(2000);
-       udelay(2000);
-       udelay(2000);
+       udelay(20000);
        current = read32(OHCI0_HC_CTRL_CURRENT_ED);
        printf("current: 0x%08X\n", current);
        printf("+++++++++++++++++++++++++++++\n");
-       udelay(2000);
-       udelay(2000);
-       udelay(2000);
-       udelay(2000);
-       udelay(2000);
-       udelay(2000);
-       udelay(2000);
-       udelay(2000);
+       udelay(20000);
+
 
        sync_before_read(tmptd, sizeof(struct general_td));
-       printf("tmptd hexump (after):\n");
+       printf("tmptd hexdump (after) 0x%08X:\n", tmptd);
        hexdump(tmptd, sizeof(struct general_td));
 
-       sync_before_read((void*) ACCESS_LE(tmptd->cbp), td->actlen);
-       printf("tmptd-cbp hexump (after):\n");
-       hexdump((void*) (phys_to_virt(ACCESS_LE(tmptd->cbp))), td->actlen);
+       sync_before_read((void*) phys_to_virt(ACCESS_LE(tmptd->cbp)), td->actlen);
+       printf("tmptd->cbp hexdump (after) 0x%08X:\n", tmptd->cbp);
+       hexdump((void*) phys_to_virt(ACCESS_LE(tmptd->cbp)), td->actlen);
+
+       sync_before_read(dummyconfig, 16);
+       printf("dummyconfig hexdump (after) 0x%08X:\n", dummyconfig);
+       hexdump((void*) dummyconfig, 16);
 
-       printf("done head (vor sync): 0x%08X\n", ACCESS_LE(hcca_oh0.done_head));
        sync_before_read(&hcca_oh0, 256);
        printf("done head (nach sync): 0x%08X\n", ACCESS_LE(hcca_oh0.done_head));
 
-       free(tmptd);
+       //free(tmptd);
        return 0;
 }
 
@@ -357,8 +345,10 @@ void hcdi_irq()
        flags &= read32(OHCI0_HC_INT_ENABLE);
 
        /* nothing to do? */
-       if (flags == 0)
+       if (flags == 0) {
+               printf("OHCI Interrupt occured: but not for you! WTF?!\n");
                return;
+       }
 
        printf("OHCI Interrupt occured: ");
        /* UnrecoverableError */
enhanced ppcskel for the great bootmii project; irq, sha1 and ohci support