Subversion Repositories freemyipod

Rev

Rev 436 | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 436 Rev 438
Line 79... Line 79...
79 
    DBGACTION_READBOOTFLASH,
 79 
    DBGACTION_READBOOTFLASH,
80 
    DBGACTION_WRITEBOOTFLASH,
 80 
    DBGACTION_WRITEBOOTFLASH,
81 
    DBGACTION_HWKEYAES,
 81 
    DBGACTION_HWKEYAES,
82 
    DBGACTION_HMACSHA1,
 82 
    DBGACTION_HMACSHA1,
83 
    DBGACTION_TARGETSPECIFIC,
 83 
    DBGACTION_TARGETSPECIFIC,
84 
    DBGACTION_STORAGE
 84 
    DBGACTION_STORAGE,
- 
 
 85 
    DBGACTION_MALLOC,
- 
 
 86 
    DBGACTION_MEMALIGN,
- 
 
 87 
    DBGACTION_REALLOC,
- 
 
 88 
    DBGACTION_REOWNALLOC,
- 
 
 89 
    DBGACTION_FREE
85 
};
 90 
};
86 
 
 91 
 
87 
static struct scheduler_thread dbgthread_handle IBSS_ATTR;
 92 
static struct scheduler_thread dbgthread_handle IBSS_ATTR;
88 
static uint32_t dbgstack[0x200] STACK_ATTR;
 93 
static uint32_t dbgstack[0x200] STACK_ATTR;
89 
struct wakeup dbgwakeup IBSS_ATTR;
 94 
struct wakeup dbgwakeup IBSS_ATTR;
Line 105... Line 110...
105 
static struct wakeup dbgconrecvwakeup IBSS_ATTR;
 110 
static struct wakeup dbgconrecvwakeup IBSS_ATTR;
106 
static bool dbgconsoleattached IBSS_ATTR;
 111 
static bool dbgconsoleattached IBSS_ATTR;
107 
 
 112 
 
108 
static const char dbgconoverflowstr[] = "\n\n[overflowed]\n\n";
 113 
static const char dbgconoverflowstr[] = "\n\n[overflowed]\n\n";
109 
 
 114 
 
110 
extern int _initstart;   // These aren't ints at all, but gcc complains about void types being
 115 
extern int _poolstart;   // These aren't ints at all, but gcc complains about void types being
111 
extern int _sdramstart;  // used here, and we only need the address, so just make it happy...
 116 
extern int _poolend;     // used here, and we only need the address, so just make it happy...
112 
 
 117 
 
113 
 
 118 
 
114 
static struct usb_device_descriptor CACHEALIGN_ATTR device_descriptor =
 119 
static struct usb_device_descriptor CACHEALIGN_ATTR device_descriptor =
115 
{
 120 
{
116 
    .bLength            = sizeof(struct usb_device_descriptor),
 121 
    .bLength            = sizeof(struct usb_device_descriptor),
Line 371... Line 376...
371 
                dbgsendbuf[1] = 0x02000200;
 376 
                dbgsendbuf[1] = 0x02000200;
372 
                dbgsendbuf[2] = usb_drv_get_max_out_size();
 377 
                dbgsendbuf[2] = usb_drv_get_max_out_size();
373 
                dbgsendbuf[3] = usb_drv_get_max_in_size();
 378 
                dbgsendbuf[3] = usb_drv_get_max_in_size();
374 
                break;
 379 
                break;
375 
            case 2:  // GET USER MEMORY INFO
 380 
            case 2:  // GET USER MEMORY INFO
376 
                dbgsendbuf[1] = (uint32_t)&_initstart;
 381 
                dbgsendbuf[1] = (uint32_t)&_poolstart;
377 
                dbgsendbuf[2] = (uint32_t)&_sdramstart;
 382 
                dbgsendbuf[2] = (uint32_t)&_poolend;
378 
                break;
 383 
                break;
379 
            default:
 384 
            default:
380 
                dbgsendbuf[0] = 2;
 385 
                dbgsendbuf[0] = 2;
381 
            }
 386 
            }
382 
            break;
 387 
            break;
Line 535... Line 540...
535 
        case 18:  // KILL THREAD
 540 
        case 18:  // KILL THREAD
536 
            thread_terminate((struct scheduler_thread*)(dbgrecvbuf[1]));
 541 
            thread_terminate((struct scheduler_thread*)(dbgrecvbuf[1]));
537 
            dbgsendbuf[0] = 1;
 542 
            dbgsendbuf[0] = 1;
538 
            size = 16;
 543 
            size = 16;
539 
            break;
 544 
            break;
540 
        case 19:  // KILL THREAD
 545 
        case 19:  // CREATE THREAD
541 
            dbgsendbuf[0] = 1;
 546 
            dbgsendbuf[0] = 1;
542 
            dbgsendbuf[1] = (uint32_t)thread_create(NULL, (const char*)(dbgsendbuf[1]),
 547 
            dbgsendbuf[1] = (uint32_t)thread_create(NULL, (const char*)(dbgsendbuf[1]),
543 
                                                    (const void*)(dbgsendbuf[2]),
 548 
                                                    (const void*)(dbgsendbuf[2]),
544 
                                                    (char*)(dbgsendbuf[3]),
 549 
                                                    (char*)(dbgsendbuf[3]),
545 
                                                    dbgsendbuf[4], (enum thread_type)dbgsendbuf[5],
 550 
                                                    dbgsendbuf[4], (enum thread_type)dbgsendbuf[5],
Line 571... Line 576...
571 
            break;
 576 
            break;
572 
#endif
 577 
#endif
573 
        case 24:  // EXECFIRMWARE
 578 
        case 24:  // EXECFIRMWARE
574 
            if (set_dbgaction(DBGACTION_EXECFIRMWARE, 0)) break;
 579 
            if (set_dbgaction(DBGACTION_EXECFIRMWARE, 0)) break;
575 
            dbgactionaddr = dbgrecvbuf[1];
 580 
            dbgactionaddr = dbgrecvbuf[1];
- 
 
 581 
            dbgactionoffset = dbgrecvbuf[2];
- 
 
 582 
            dbgactionlength = dbgrecvbuf[3];
576 
            break;
 583 
            break;
577 
#ifdef HAVE_HWKEYAES
 584 
#ifdef HAVE_HWKEYAES
578 
        case 25:  // HWKEYAES
 585 
        case 25:  // HWKEYAES
579 
            if (set_dbgaction(DBGACTION_HWKEYAES, 0)) break;
 586 
            if (set_dbgaction(DBGACTION_HWKEYAES, 0)) break;
580 
            dbgactiontype = ((uint8_t*)dbgrecvbuf)[4];
 587 
            dbgactiontype = ((uint8_t*)dbgrecvbuf)[4];
Line 621... Line 628...
621 
#endif
 628 
#endif
622 
            if (!set_dbgaction(DBGACTION_STORAGE, 0))
 629 
            if (!set_dbgaction(DBGACTION_STORAGE, 0))
623 
                memcpy(dbgasyncsendbuf, dbgrecvbuf, sizeof(dbgasyncsendbuf));
 630 
                memcpy(dbgasyncsendbuf, dbgrecvbuf, sizeof(dbgasyncsendbuf));
624 
            break;
 631 
            break;
625 
#endif
 632 
#endif
- 
 
 633 
        case 52:  // MALLOC
- 
 
 634 
            if (set_dbgaction(DBGACTION_MALLOC, 0)) break;
- 
 
 635 
            dbgactionlength = dbgrecvbuf[1];
- 
 
 636 
            break;
- 
 
 637 
        case 53:  // MEMALIGN
- 
 
 638 
            if (set_dbgaction(DBGACTION_MEMALIGN, 0)) break;
- 
 
 639 
            dbgactionoffset = dbgrecvbuf[1];
- 
 
 640 
            dbgactionlength = dbgrecvbuf[2];
- 
 
 641 
            break;
- 
 
 642 
        case 54:  // REALLOC
- 
 
 643 
            if (set_dbgaction(DBGACTION_REALLOC, 0)) break;
- 
 
 644 
            dbgactionaddr = dbgrecvbuf[1];
- 
 
 645 
            dbgactionlength = dbgrecvbuf[2];
- 
 
 646 
            break;
- 
 
 647 
        case 55:  // REOWNALLOC
- 
 
 648 
            if (set_dbgaction(DBGACTION_REOWNALLOC, 0)) break;
- 
 
 649 
            dbgactionaddr = dbgrecvbuf[1];
- 
 
 650 
            dbgactionoffset = dbgrecvbuf[2];
- 
 
 651 
            break;
- 
 
 652 
        case 56:  // FREE
- 
 
 653 
            if (set_dbgaction(DBGACTION_FREE, 0)) break;
- 
 
 654 
            dbgactionaddr = dbgrecvbuf[1];
- 
 
 655 
            break;
626 
        default:
 656 
        default:
627 
            dbgsendbuf[0] = 2;
 657 
            dbgsendbuf[0] = 2;
628 
            size = 16;
 658 
            size = 16;
629 
        }
 659 
        }
630 
        usb_setup_dbg_listener();
 660 
        usb_setup_dbg_listener();
Line 710... Line 740...
710 
                break;
 740 
                break;
711 
            case DBGACTION_EXECFIRMWARE:
 741 
            case DBGACTION_EXECFIRMWARE:
712 
                shutdown(false);
 742 
                shutdown(false);
713 
                dbgasyncsendbuf[0] = 1;
 743 
                dbgasyncsendbuf[0] = 1;
714 
                usb_drv_send_nonblocking(dbgendpoints[1], dbgasyncsendbuf, 16);
 744 
                usb_drv_send_nonblocking(dbgendpoints[1], dbgasyncsendbuf, 16);
715 
                execfirmware((void*)dbgactionaddr);
 745 
                execfirmware((void*)dbgactionaddr, (void*)dbgactionoffset,
- 
 
 746 
                             (size_t)dbgactionlength);
716 
#ifdef HAVE_BOOTFLASH
 747 
#ifdef HAVE_BOOTFLASH
717 
            case DBGACTION_READBOOTFLASH:
 748 
            case DBGACTION_READBOOTFLASH:
718 
                bootflash_readraw((void*)dbgactionaddr, dbgactionoffset, dbgactionlength);
 749 
                bootflash_readraw((void*)dbgactionaddr, dbgactionoffset, dbgactionlength);
719 
                dbgasyncsendbuf[0] = 1;
 750 
                dbgasyncsendbuf[0] = 1;
720 
                usb_drv_send_nonblocking(dbgendpoints[1], dbgasyncsendbuf, 16);
 751 
                usb_drv_send_nonblocking(dbgendpoints[1], dbgasyncsendbuf, 16);
Line 910... Line 941...
910 
                    break;
 941 
                    break;
911 
#endif
 942 
#endif
912 
                }
 943 
                }
913 
                break;
 944 
                break;
914 
#endif
 945 
#endif
- 
 
 946 
            case DBGACTION_MALLOC:
- 
 
 947 
                dbgasyncsendbuf[0] = 1;
- 
 
 948 
                dbgasyncsendbuf[1] = (uint32_t)malloc((size_t)dbgactionlength);
- 
 
 949 
                usb_drv_send_nonblocking(dbgendpoints[1], dbgasyncsendbuf, 16);
- 
 
 950 
                break;
- 
 
 951 
            case DBGACTION_MEMALIGN:
- 
 
 952 
                dbgasyncsendbuf[0] = 1;
- 
 
 953 
                dbgasyncsendbuf[1] = (uint32_t)memalign((size_t)dbgactionoffset,
- 
 
 954 
                                                        (size_t)dbgactionlength);
- 
 
 955 
                usb_drv_send_nonblocking(dbgendpoints[1], dbgasyncsendbuf, 16);
- 
 
 956 
                break;
- 
 
 957 
            case DBGACTION_REALLOC:
- 
 
 958 
                dbgasyncsendbuf[0] = 1;
- 
 
 959 
                dbgasyncsendbuf[1] = (uint32_t)realloc((void*)dbgactionaddr,
- 
 
 960 
                                                       (size_t)dbgactionlength);
- 
 
 961 
                usb_drv_send_nonblocking(dbgendpoints[1], dbgasyncsendbuf, 16);
- 
 
 962 
                break;
- 
 
 963 
            case DBGACTION_REOWNALLOC:
- 
 
 964 
                dbgasyncsendbuf[0] = 1;
- 
 
 965 
                reownalloc((void*)dbgactionaddr, (void*)dbgactionoffset);
- 
 
 966 
                usb_drv_send_nonblocking(dbgendpoints[1], dbgasyncsendbuf, 16);
- 
 
 967 
                break;
- 
 
 968 
            case DBGACTION_FREE:
- 
 
 969 
                dbgasyncsendbuf[0] = 1;
- 
 
 970 
                free((void*)dbgactionaddr);
- 
 
 971 
                usb_drv_send_nonblocking(dbgendpoints[1], dbgasyncsendbuf, 16);
- 
 
 972 
                break;
915 
            }
 973 
            }
916 
            dbgaction = DBGACTION_IDLE;
 974 
            dbgaction = DBGACTION_IDLE;
917 
        }
 975 
        }
918 
    }
 976 
    }
919 
}
 977 
}