Subversion Repositories freemyipod

Rev

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

Rev 336 Rev 346
Line 47... Line 47...
47 
#include "hmacsha1.h"
 47 
#include "hmacsha1.h"
48 
#endif
 48 
#endif
49 
#ifdef USB_HAVE_TARGET_SPECIFIC_REQUESTS
 49 
#ifdef USB_HAVE_TARGET_SPECIFIC_REQUESTS
50 
#include "usbtarget.h"
 50 
#include "usbtarget.h"
51 
#endif
 51 
#endif
- 
 
 52 
#ifdef HAVE_STORAGE
- 
 
 53 
#include "storage.h"
- 
 
 54 
#include "disk.h"
- 
 
 55 
#include "file.h"
- 
 
 56 
#include "dir.h"
- 
 
 57 
#include "errno.h"
- 
 
 58 
#endif
52 
 
 59 
 
53 
 
 60 
 
54 
static uint8_t ctrlresp[2] CACHEALIGN_ATTR;
 61 
static uint8_t ctrlresp[2] CACHEALIGN_ATTR;
55 
static uint32_t dbgrecvbuf[0x80] CACHEALIGN_ATTR;
 62 
static uint32_t dbgrecvbuf[0x80] CACHEALIGN_ATTR;
56 
static uint32_t dbgsendbuf[0x80] CACHEALIGN_ATTR;
 63 
static uint32_t dbgsendbuf[0x80] CACHEALIGN_ATTR;
Line 71... Line 78...
71 
    DBGACTION_EXECFIRMWARE,
 78 
    DBGACTION_EXECFIRMWARE,
72 
    DBGACTION_READBOOTFLASH,
 79 
    DBGACTION_READBOOTFLASH,
73 
    DBGACTION_WRITEBOOTFLASH,
 80 
    DBGACTION_WRITEBOOTFLASH,
74 
    DBGACTION_HWKEYAES,
 81 
    DBGACTION_HWKEYAES,
75 
    DBGACTION_HMACSHA1,
 82 
    DBGACTION_HMACSHA1,
76 
    DBGACTION_TARGETSPECIFIC
 83 
    DBGACTION_TARGETSPECIFIC,
- 
 
 84 
    DBGACTION_STORAGE
77 
};
 85 
};
78 
 
 86 
 
79 
static uint32_t dbgstack[0x100] STACK_ATTR;
 87 
static uint32_t dbgstack[0x200] STACK_ATTR;
80 
struct wakeup dbgwakeup IBSS_ATTR;
 88 
struct wakeup dbgwakeup IBSS_ATTR;
81 
extern struct scheduler_thread* scheduler_threads;
 89 
extern struct scheduler_thread* scheduler_threads;
- 
 
 90 
extern struct scheduler_thread* current_thread;
82 
static enum dbgaction_t dbgaction IBSS_ATTR;
 91 
static enum dbgaction_t dbgaction IBSS_ATTR;
83 
static int dbgi2cbus;
 92 
static int dbgi2cbus;
84 
static int dbgi2cslave;
 93 
static int dbgi2cslave;
85 
static int dbgactionaddr;
 94 
static int dbgactionaddr;
86 
static int dbgactionoffset;
 95 
static int dbgactionoffset;
Line 578... Line 587...
578 
            dbgactionaddr = dbgrecvbuf[1];
 587 
            dbgactionaddr = dbgrecvbuf[1];
579 
            dbgactionlength = dbgrecvbuf[2];
 588 
            dbgactionlength = dbgrecvbuf[2];
580 
            dbgactionoffset = dbgrecvbuf[3];
 589 
            dbgactionoffset = dbgrecvbuf[3];
581 
            break;
 590 
            break;
582 
#endif
 591 
#endif
- 
 
 592 
#ifdef HAVE_STORAGE
- 
 
 593 
        case 27:  // STORAGE_GET_INFO
- 
 
 594 
        case 28:  // STORAGE_READ_SECTORS_MD
- 
 
 595 
        case 29:  // STORAGE_WRITE_SECTORS_MD
- 
 
 596 
        case 30:  // FILE_OPEN
- 
 
 597 
        case 31:  // FILESIZE
- 
 
 598 
        case 32:  // READ
- 
 
 599 
        case 33:  // WRITE
- 
 
 600 
        case 34:  // LSEEK
- 
 
 601 
        case 35:  // FTRUNCATE
- 
 
 602 
        case 36:  // FSYNC
- 
 
 603 
        case 37:  // CLOSE
- 
 
 604 
        case 38:  // CLOSE_MONITOR_FILES
- 
 
 605 
        case 39:  // RELEASE_FILES
- 
 
 606 
        case 40:  // REMOVE
- 
 
 607 
        case 41:  // RENAME
- 
 
 608 
        case 42:  // OPENDIR
- 
 
 609 
        case 43:  // READDIR
- 
 
 610 
        case 44:  // CLOSEDIR
- 
 
 611 
        case 45:  // CLOSE_MONITOR_DIRS
- 
 
 612 
        case 46:  // RELEASE_DIRS
- 
 
 613 
        case 47:  // MKDIR
- 
 
 614 
        case 48:  // RMDIR
- 
 
 615 
        case 49:  // ERRNO
- 
 
 616 
#ifdef HAVE_HOTSWAP
- 
 
 617 
        case 50:  // DISK_MOUNT
- 
 
 618 
        case 51:  // DISK_UNMOUNT
- 
 
 619 
#endif
- 
 
 620 
            if (!set_dbgaction(DBGACTION_STORAGE, 0))
- 
 
 621 
                memcpy(dbgasyncsendbuf, dbgrecvbuf, sizeof(dbgasyncsendbuf));
- 
 
 622 
            break;
- 
 
 623 
#endif
583 
        default:
 624 
        default:
584 
            dbgsendbuf[0] = 2;
 625 
            dbgsendbuf[0] = 2;
585 
            size = 16;
 626 
            size = 16;
586 
        }
 627 
        }
587 
        usb_setup_dbg_listener();
 628 
        usb_setup_dbg_listener();
Line 706... Line 747...
706 
                int size = usb_target_handle_request(dbgasyncsendbuf, sizeof(dbgasyncsendbuf));
 747 
                int size = usb_target_handle_request(dbgasyncsendbuf, sizeof(dbgasyncsendbuf));
707 
                if (size) usb_drv_send_nonblocking(dbgendpoints[1], dbgasyncsendbuf, size);
 748 
                if (size) usb_drv_send_nonblocking(dbgendpoints[1], dbgasyncsendbuf, size);
708 
                break;
 749 
                break;
709 
            }
 750 
            }
710 
#endif
 751 
#endif
- 
 
 752 
#ifdef HAVE_STORAGE
- 
 
 753 
            case DBGACTION_STORAGE:
- 
 
 754 
                switch(dbgasyncsendbuf[0])
- 
 
 755 
                {
- 
 
 756 
                case 27:  // STORAGE_GET_INFO
- 
 
 757 
                    dbgasyncsendbuf[0] = 1;
- 
 
 758 
                    storage_get_info(dbgasyncsendbuf[1],
- 
 
 759 
                                     (struct storage_info*)&dbgasyncsendbuf[4]);
- 
 
 760 
                    dbgasyncsendbuf[1] = 1;
- 
 
 761 
                    usb_drv_send_nonblocking(dbgendpoints[1], dbgasyncsendbuf,
- 
 
 762 
                                             16 + sizeof(struct storage_info));
- 
 
 763 
                    break;
- 
 
 764 
                case 28:  // STORAGE_READ_SECTORS_MD
- 
 
 765 
                {
- 
 
 766 
                    dbgasyncsendbuf[0] = 1;
- 
 
 767 
                    int rc = storage_read_sectors_md(dbgasyncsendbuf[1],
- 
 
 768 
                                                     dbgasyncsendbuf[2]
- 
 
 769 
                                                   | (((uint64_t)(dbgasyncsendbuf[3]) << 32)),
- 
 
 770 
                                                     dbgasyncsendbuf[4],
- 
 
 771 
                                                     (void*)(dbgasyncsendbuf[5]));
- 
 
 772 
                    dbgasyncsendbuf[1] = (uint32_t)rc;
- 
 
 773 
                    usb_drv_send_nonblocking(dbgendpoints[1], dbgasyncsendbuf, 16);
- 
 
 774 
                    break;
- 
 
 775 
                }
- 
 
 776 
                case 29:  // STORAGE_WRITE_SECTORS_MD
- 
 
 777 
                {
- 
 
 778 
                    dbgasyncsendbuf[0] = 1;
- 
 
 779 
                    int rc = storage_write_sectors_md(dbgasyncsendbuf[1],
- 
 
 780 
                                                      dbgasyncsendbuf[2]
- 
 
 781 
                                                    | (((uint64_t)(dbgasyncsendbuf[3]) << 32)),
- 
 
 782 
                                                      dbgasyncsendbuf[4],
- 
 
 783 
                                                      (void*)(dbgasyncsendbuf[5]));
- 
 
 784 
                    dbgasyncsendbuf[1] = (uint32_t)rc;
- 
 
 785 
                    usb_drv_send_nonblocking(dbgendpoints[1], dbgasyncsendbuf, 16);
- 
 
 786 
                    break;
- 
 
 787 
                }
- 
 
 788 
                case 30:  // FILE_OPEN
- 
 
 789 
                {
- 
 
 790 
                    dbgasyncsendbuf[0] = 1;
- 
 
 791 
                    int fd = file_open((char*)(&dbgasyncsendbuf[4]), (int)(dbgasyncsendbuf[1]));
- 
 
 792 
                    dbgasyncsendbuf[1] = (uint32_t)fd;
- 
 
 793 
                    usb_drv_send_nonblocking(dbgendpoints[1], dbgasyncsendbuf, 16);
- 
 
 794 
                    break;
- 
 
 795 
                }
- 
 
 796 
                case 31:  // FILESIZE
- 
 
 797 
                    dbgasyncsendbuf[0] = 1;
- 
 
 798 
                    dbgasyncsendbuf[1] = (uint32_t)filesize((int)(dbgasyncsendbuf[1]));
- 
 
 799 
                    usb_drv_send_nonblocking(dbgendpoints[1], dbgasyncsendbuf, 16);
- 
 
 800 
                    break;
- 
 
 801 
                case 32:  // READ
- 
 
 802 
                    dbgasyncsendbuf[0] = 1;
- 
 
 803 
                    dbgasyncsendbuf[1] = (uint32_t)read((int)(dbgasyncsendbuf[1]),
- 
 
 804 
                                                        (void*)(dbgasyncsendbuf[2]),
- 
 
 805 
                                                        (size_t)(dbgasyncsendbuf[3]));
- 
 
 806 
                    usb_drv_send_nonblocking(dbgendpoints[1], dbgasyncsendbuf, 16);
- 
 
 807 
                    break;
- 
 
 808 
                case 33:  // WRITE
- 
 
 809 
                    dbgasyncsendbuf[0] = 1;
- 
 
 810 
                    dbgasyncsendbuf[1] = (uint32_t)write((int)(dbgasyncsendbuf[1]),
- 
 
 811 
                                                         (void*)(dbgasyncsendbuf[2]),
- 
 
 812 
                                                         (size_t)(dbgasyncsendbuf[3]));
- 
 
 813 
                    usb_drv_send_nonblocking(dbgendpoints[1], dbgasyncsendbuf, 16);
- 
 
 814 
                    break;
- 
 
 815 
                case 34:  // LSEEK
- 
 
 816 
                    dbgasyncsendbuf[0] = 1;
- 
 
 817 
                    dbgasyncsendbuf[1] = (uint32_t)lseek((int)(dbgasyncsendbuf[1]),
- 
 
 818 
                                                         (off_t)(dbgasyncsendbuf[2]),
- 
 
 819 
                                                         (int)(dbgasyncsendbuf[3]));
- 
 
 820 
                    usb_drv_send_nonblocking(dbgendpoints[1], dbgasyncsendbuf, 16);
- 
 
 821 
                    break;
- 
 
 822 
                case 35:  // FTRUNCATE
- 
 
 823 
                    dbgasyncsendbuf[0] = 1;
- 
 
 824 
                    dbgasyncsendbuf[1] = (uint32_t)ftruncate((int)(dbgasyncsendbuf[1]),
- 
 
 825 
                                                             (off_t)(dbgasyncsendbuf[2]));
- 
 
 826 
                    usb_drv_send_nonblocking(dbgendpoints[1], dbgasyncsendbuf, 16);
- 
 
 827 
                    break;
- 
 
 828 
                case 36:  // FSYNC
- 
 
 829 
                    dbgasyncsendbuf[0] = 1;
- 
 
 830 
                    dbgasyncsendbuf[1] = (uint32_t)fsync((int)(dbgasyncsendbuf[1]));
- 
 
 831 
                    usb_drv_send_nonblocking(dbgendpoints[1], dbgasyncsendbuf, 16);
- 
 
 832 
                    break;
- 
 
 833 
                case 37:  // CLOSE
- 
 
 834 
                    dbgasyncsendbuf[0] = 1;
- 
 
 835 
                    dbgasyncsendbuf[1] = (uint32_t)close((int)(dbgasyncsendbuf[1]));
- 
 
 836 
                    usb_drv_send_nonblocking(dbgendpoints[1], dbgasyncsendbuf, 16);
- 
 
 837 
                    break;
- 
 
 838 
                case 38:  // CLOSE_MONITOR_FILES
- 
 
 839 
                    dbgasyncsendbuf[0] = 1;
- 
 
 840 
                    dbgasyncsendbuf[1] = (uint32_t)close_all_of_process(current_thread);
- 
 
 841 
                    usb_drv_send_nonblocking(dbgendpoints[1], dbgasyncsendbuf, 16);
- 
 
 842 
                    break;
- 
 
 843 
                case 39:  // RELEASE_FILES
- 
 
 844 
                    dbgasyncsendbuf[0] = 1;
- 
 
 845 
                    dbgasyncsendbuf[1] = (uint32_t)release_files((int)(dbgasyncsendbuf[1]));
- 
 
 846 
                    usb_drv_send_nonblocking(dbgendpoints[1], dbgasyncsendbuf, 16);
- 
 
 847 
                    break;
- 
 
 848 
                case 40:  // REMOVE
- 
 
 849 
                    dbgasyncsendbuf[0] = 1;
- 
 
 850 
                    dbgasyncsendbuf[1] = (uint32_t)remove((char*)(&dbgasyncsendbuf[4]));
- 
 
 851 
                    usb_drv_send_nonblocking(dbgendpoints[1], dbgasyncsendbuf, 16);
- 
 
 852 
                    break;
- 
 
 853 
                case 41:  // RENAME
- 
 
 854 
                    dbgasyncsendbuf[0] = 1;
- 
 
 855 
                    dbgasyncsendbuf[1] = (uint32_t)rename((char*)(&dbgasyncsendbuf[4]),
- 
 
 856 
                                                          (char*)(&dbgasyncsendbuf[66]));
- 
 
 857 
                    usb_drv_send_nonblocking(dbgendpoints[1], dbgasyncsendbuf, 16);
- 
 
 858 
                    break;
- 
 
 859 
                case 42:  // OPENDIR
- 
 
 860 
                    dbgasyncsendbuf[0] = 1;
- 
 
 861 
                    dbgasyncsendbuf[1] = (uint32_t)opendir((char*)(&dbgasyncsendbuf[4]));
- 
 
 862 
                    usb_drv_send_nonblocking(dbgendpoints[1], dbgasyncsendbuf, 16);
- 
 
 863 
                    break;
- 
 
 864 
                case 43:  // READDIR
- 
 
 865 
                    dbgasyncsendbuf[0] = 1;
- 
 
 866 
                    dbgasyncsendbuf[3] = (uint32_t)readdir((DIR*)(dbgasyncsendbuf[1]));
- 
 
 867 
                    dbgasyncsendbuf[1] = 1;
- 
 
 868 
                    dbgasyncsendbuf[2] = MAX_PATH;
- 
 
 869 
                    usb_drv_send_nonblocking(dbgendpoints[1], dbgasyncsendbuf, 16);
- 
 
 870 
                    break;
- 
 
 871 
                case 44:  // CLOSEDIR
- 
 
 872 
                    dbgasyncsendbuf[0] = 1;
- 
 
 873 
                    dbgasyncsendbuf[1] = (uint32_t)closedir((DIR*)(dbgasyncsendbuf[1]));
- 
 
 874 
                    usb_drv_send_nonblocking(dbgendpoints[1], dbgasyncsendbuf, 16);
- 
 
 875 
                    break;
- 
 
 876 
                case 45:  // CLOSE_MONITOR_DIRS
- 
 
 877 
                    dbgasyncsendbuf[0] = 1;
- 
 
 878 
                    dbgasyncsendbuf[1] = (uint32_t)closedir_all_of_process(current_thread);
- 
 
 879 
                    usb_drv_send_nonblocking(dbgendpoints[1], dbgasyncsendbuf, 16);
- 
 
 880 
                    break;
- 
 
 881 
                case 46:  // RELEASE_DIRS
- 
 
 882 
                    dbgasyncsendbuf[0] = 1;
- 
 
 883 
                    dbgasyncsendbuf[1] = (uint32_t)release_dirs((int)(dbgasyncsendbuf[1]));
- 
 
 884 
                    usb_drv_send_nonblocking(dbgendpoints[1], dbgasyncsendbuf, 16);
- 
 
 885 
                    break;
- 
 
 886 
                case 47:  // MKDIR
- 
 
 887 
                    dbgasyncsendbuf[0] = 1;
- 
 
 888 
                    dbgasyncsendbuf[1] = (uint32_t)mkdir((char*)(&dbgasyncsendbuf[4]));
- 
 
 889 
                    usb_drv_send_nonblocking(dbgendpoints[1], dbgasyncsendbuf, 16);
- 
 
 890 
                    break;
- 
 
 891 
                case 48:  // RMDIR
- 
 
 892 
                    dbgasyncsendbuf[0] = 1;
- 
 
 893 
                    dbgasyncsendbuf[1] = (uint32_t)rmdir((char*)(&dbgasyncsendbuf[4]));
- 
 
 894 
                    usb_drv_send_nonblocking(dbgendpoints[1], dbgasyncsendbuf, 16);
- 
 
 895 
                    break;
- 
 
 896 
                case 49:  // ERRNO
- 
 
 897 
                    dbgasyncsendbuf[0] = 1;
- 
 
 898 
                    dbgasyncsendbuf[1] = (uint32_t)errno;
- 
 
 899 
                    usb_drv_send_nonblocking(dbgendpoints[1], dbgasyncsendbuf, 16);
- 
 
 900 
                    break;
- 
 
 901 
#ifdef HAVE_HOTSWAP
- 
 
 902 
                case 50:  // DISK_MOUNT
- 
 
 903 
                    dbgasyncsendbuf[0] = 1;
- 
 
 904 
                    dbgasyncsendbuf[1] = (uint32_t)disk_mount((int)(dbgasyncsendbuf[1]));
- 
 
 905 
                    usb_drv_send_nonblocking(dbgendpoints[1], dbgasyncsendbuf, 16);
- 
 
 906 
                    break;
- 
 
 907 
                case 51:  // DISK_UNMOUNT
- 
 
 908 
                    dbgasyncsendbuf[0] = 1;
- 
 
 909 
                    dbgasyncsendbuf[1] = (uint32_t)disk_unmount((int)(dbgasyncsendbuf[1]));
- 
 
 910 
                    usb_drv_send_nonblocking(dbgendpoints[1], dbgasyncsendbuf, 16);
- 
 
 911 
                    break;
- 
 
 912 
#endif
- 
 
 913 
                }
- 
 
 914 
                break;
- 
 
 915 
#endif
711 
            }
 916 
            }
712 
            dbgaction = DBGACTION_IDLE;
 917 
            dbgaction = DBGACTION_IDLE;
713 
        }
 918 
        }
714 
    }
 919 
    }
715 
}
 920 
}