static void acm_received(uint32_t _tkn, int32_t _amt)
{
int attempts;
for(attempts = 0; attempts < 5; attempts++)
{
if(task_start(&acm_parse_task, &acm_parse, (void*)_amt))
break;
bufferPrintf("ACM: Worker already running, yielding...\n");
task_yield();
}
}
void cmd_multitouch_setup(int argc, char** argv)
{
if(argc < 3)
{
bufferPrintf("%s <constructed fw> <constructed fw len>\r\n", argv[0]);
return;
}
uint8_t* constructedFW = (uint8_t*) parseNumber(argv[1]);
uint32_t constructedFWLen = parseNumber(argv[2]);
multitouch_setup(constructedFW, constructedFWLen);
}
void cmd_audiohw_speaker_vol(int argc, char** argv)
{
if(argc < 2)
{
bufferPrintf("%s <loudspeaker volume> [speaker volume] (between 0 and 100... 'speaker' is the one next to your ear)\r\n", argv[0]);
return;
}
int vol = parseNumber(argv[1]);
loudspeaker_vol(vol);
bufferPrintf("Set loudspeaker volume to: %d\r\n", vol);
if(argc > 2)
{
vol = parseNumber(argv[2]);
speaker_vol(vol);
bufferPrintf("Set speaker volume to: %d\r\n", vol);
}
}
void cmd_time(int argc, char** argv) {
int day;
int month;
int year;
int hour;
int minute;
int second;
int day_of_week;
pmu_date(&year, &month, &day, &day_of_week, &hour, &minute, &second);
bufferPrintf("Current time: %02d:%02d:%02d, %s %02d/%02d/%02d GMT\r\n", hour, minute, second, get_dayofweek_str(day_of_week), month, day, year);
//bufferPrintf("Current time: %02d:%02d:%02d, %s %02d/%02d/20%02d\r\n", pmu_get_hours(), pmu_get_minutes(), pmu_get_seconds(), pmu_get_dayofweek_str(), pmu_get_month(), pmu_get_day(), pmu_get_year());
//bufferPrintf("Current time: %llu\n", pmu_get_epoch());
}
void displayFileLSLine(HFSPlusCatalogFile* file, const char* name) {
bufferPrintf("%06o ", file->permissions.fileMode);
bufferPrintf("%3d ", file->permissions.ownerID);
bufferPrintf("%3d ", file->permissions.groupID);
bufferPrintf("%12Ld ", file->dataFork.logicalSize);
bufferPrintf(" ");
bufferPrintf("%s\r\n", name);
}
error_t block_device_register(block_device_t *_bdev)
{
EnterCriticalSection();
LinkedList *prev = bdev_list.prev;
_bdev->list_ptr.prev = prev;
_bdev->list_ptr.next = &bdev_list;
prev->next = &_bdev->list_ptr;
bdev_list.prev = &_bdev->list_ptr;
LeaveCriticalSection();
bufferPrintf("bdev: Registered new device, 0x%p.\n", _bdev);
return block_device_setup(_bdev);
}
static error_t cmd_wlan_prog_real(int argc, char** argv)
{
if(argc < 3) {
bufferPrintf("Usage: %s <address> <len>\r\n", argv[0]);
return -1;
}
uint32_t address = parseNumber(argv[1]);
uint32_t len = parseNumber(argv[2]);
wlan_prog_real((void*) address, len);
return 0;
}
void buffer_dump_memory(uint32_t start, int length) {
uint32_t curPos = start;
int x = 0;
while(curPos < (start + length)) {
if(x == 0) {
bufferPrintf("0x%08x:", (unsigned int) curPos);
}
bufferPrintf(" %08x", (unsigned int) GET_REG(curPos));
if(x == 1) {
bufferPrintf(" ");
}
if(x == 3) {
bufferPrintf("\r\n");
x = 0;
} else {
x++;
}
curPos += 4;
}
bufferPrintf("\r\n");
}
error_t bufzone_finished_allocs(bufzone_t* _zone)
{
uint8_t* buff;
if (_zone->state != 1) {
bufferPrintf("bufzone_finished_allocs: bad state\r\n");
return EINVAL;
}
_zone->size = ROUND_UP(_zone->size, 64);
buff = yaftl_alloc(_zone->size);
if (!buff) {
bufferPrintf("bufzone_finished_alloc: No buffer.\r\n");
return EINVAL;
}
_zone->buffer = (uint32_t)buff;
_zone->endOfBuffer = (uint32_t)(buff + _zone->size);
_zone->state = 2;
return SUCCESS;
}
static error_t cmd_install(int argc, char** argv)
{
if((argc > 2 && argc < 4) || argc > 4)
{
bufferPrintf("Usage: %s <address> <len>\n", argv[0]);
return EINVAL;
}
if(argc == 4)
{
uint32_t offset = parseNumber(argv[1]);
uint32_t len = parseNumber(argv[2]);
bufferPrintf("Installing OIB from 0x%08x:%d.\n", offset, len);
images_install((void*)offset, len, fourcc("ibot"), fourcc("ibox"));
}
else
{
bufferPrintf("Starting Install/Upgrade...\r\n");
images_install(&_start, (uint32_t)&OpenIBootEnd - (uint32_t)&_start, fourcc("ibot"), fourcc("ibox"));
}
return SUCCESS;
}
void OpenIBootConsole()
{
init_modules();
bufferPrintf( " ___ _ ____ _ \r\n"
" / _ \\ _ __ ___ _ __ (_) __ ) ___ ___ | |_ \r\n"
"| | | | '_ \\ / _ \\ '_ \\| | _ \\ / _ \\ / _ \\| __|\r\n"
"| |_| | |_) | __/ | | | | |_) | (_) | (_) | |_ \r\n"
" \\___/| .__/ \\___|_| |_|_|____/ \\___/ \\___/ \\__|\r\n"
" |_| \r\n"
"\r\n"
"version: %s\r\n", OPENIBOOT_VERSION_STR);
DebugPrintf(" DEBUG MODE\r\n");
}
void multitouch_on()
{
if(!MultitouchOn)
{
bufferPrintf("multitouch: powering on\r\n");
gpio_pin_output(MT_GPIO_POWER, 0);
udelay(200000);
gpio_pin_output(MT_GPIO_POWER, 1);
udelay(15000);
MultitouchOn = TRUE;
fingerData=0;
}
}
static error_t virtual_block_to_physical_block(vfl_vsvfl_device_t *_vfl, uint32_t _vBank, uint32_t _vBlock, uint32_t *_pBlock)
{
uint32_t pCE, pPage;
if(!_vfl->virtual_to_physical) {
bufferPrintf("vsvfl: virtual_to_physical hasn't been initialized yet!\r\n");
return EINVAL;
}
_vfl->virtual_to_physical(_vfl, _vBank, _vfl->geometry.pages_per_block * _vBlock, &pCE, &pPage);
*_pBlock = pPage / _vfl->geometry.pages_per_block;
return SUCCESS;
}
static void processCommand(char* command) {
int argc;
char** argv = tokenize(command, &argc);
if(strcmp(argv[0], "sendfile") == 0) {
if(argc >= 2) {
// enter file mode
EnterCriticalSection();
if(dataRecvBuffer == commandRecvBuffer) {
dataRecvBuffer = (uint8_t*) parseNumber(argv[1]);
}
LeaveCriticalSection();
free(argv);
return;
}
}
if(strcmp(argv[0], "getfile") == 0) {
if(argc >= 3) {
// enter file mode
EnterCriticalSection();
if(sendFileBytesLeft == 0) {
sendFilePtr = (uint8_t*) parseNumber(argv[1]);
sendFileBytesLeft = parseNumber(argv[2]);
}
LeaveCriticalSection();
free(argv);
return;
}
}
OPIBCommand* curCommand = CommandList;
int success = FALSE;
while(curCommand->name != NULL) {
if(strcmp(argv[0], curCommand->name) == 0) {
curCommand->routine(argc, argv);
success = TRUE;
break;
}
curCommand++;
}
if(!success) {
bufferPrintf("unknown command: %s\r\n", command);
}
free(argv);
}
error_t task_sleep(int _ms)
{
EnterCriticalSection();
if(CurrentRunning == IRQTask)
{
LeaveCriticalSection();
bufferPrintf("tasks: You can't suspend an ISR.\r\n");
return EINVAL;
}
TaskDescriptor *next = CurrentRunning->taskList.next;
if(next == CurrentRunning)
{
LeaveCriticalSection();
bufferPrintf("tasks: Last thread cannot sleep!\n");
uint64_t start = timer_get_system_microtime();
while(!has_elapsed(start, _ms*1000));
return SUCCESS;
}
uint32_t ticks = _ms * 1000;
TaskDescriptor *task = CurrentRunning;
//bufferPrintf("tasks: Putting task %p to sleep for %d ms.\n", task, _ms);
task_remove(task);
event_add(&task->sleepEvent, ticks, &task_wake_event, task);
SwapTask(next);
LeaveCriticalSection();
return SUCCESS;
}
void cmd_ramdisk(int argc, char** argv) {
uint32_t address;
uint32_t size;
if(argc < 3) {
address = 0x09000000;
size = received_file_size;
} else {
address = parseNumber(argv[1]);
size = parseNumber(argv[2]);
}
set_ramdisk((void*) address, size);
bufferPrintf("Loaded ramdisk at %08x - %08x\r\n", address, address + size);
}
static error_t physical_block_to_virtual_block(vfl_vsvfl_device_t *_vfl, uint32_t _pBlock, uint32_t *_vBank, uint32_t *_vBlock)
{
uint32_t vBank, vPage;
if(!_vfl->physical_to_virtual) {
bufferPrintf("vsvfl: physical_to_virtual hasn't been initialized yet!\r\n");
return EINVAL;
}
_vfl->physical_to_virtual(_vfl, 0, _vfl->geometry.pages_per_block * _pBlock, &vBank, &vPage);
*_vBank = vBank / _vfl->geometry.num_ce;
*_vBlock = vPage / _vfl->geometry.pages_per_block;
return SUCCESS;
}
int radio_setup_3g()
{
gpio_pulldown_configure(RADIO_BB_PULLDOWN, GPIOPDDown);
pmu_gpio(RADIO_GPIO_BB_ON, TRUE, OFF);
udelay(100000);
gpio_pin_output(RADIO_GPIO_RADIO_ON, ON);
udelay(100000);
gpio_pin_output(RADIO_GPIO_BB_RESET, ON);
udelay(100000);
gpio_pin_output(RADIO_GPIO_BB_RESET, OFF);
udelay(100000);
gpio_pin_use_as_input(RADIO_GPIO_RESET_DETECT);
if(gpio_pin_state(RADIO_GPIO_RESET_DETECT) != 1)
{
bufferPrintf("radio: comm board not present, powered on, or at+xdrv=10,2 had been issued.\r\n");
return -1;
}
bufferPrintf("radio: comm board detected.\r\n");
if(!radio_wait_for_ok(10))
{
bufferPrintf("radio: no response from baseband!\r\n");
return -1;
}
RadioAvailable = TRUE;
bufferPrintf("radio: ready.\r\n");
speaker_setup();
return 0;
}
int radio_setup_2g()
{
gpio_pin_output(RADIO_GPIO_BB_MUX_SEL, OFF);
gpio_pulldown_configure(RADIO_BB_PULLDOWN, GPIOPDDown);
gpio_pin_output(RADIO_GPIO_BB_ON, OFF);
udelay(100000);
gpio_pin_output(RADIO_GPIO_RADIO_ON, ON);
udelay(100000);
gpio_pin_output(RADIO_GPIO_BB_RESET, ON);
udelay(100000);
gpio_pin_output(RADIO_GPIO_BB_RESET, OFF);
udelay(100000);
gpio_pin_use_as_input(RADIO_GPIO_BB_DETECT);
if(gpio_pin_state(RADIO_GPIO_BB_DETECT) != 0)
{
bufferPrintf("radio: comm board not present, powered on, or at+xdrv=10,2 had been issued.\r\n");
return -1;
}
bufferPrintf("radio: comm board detected.\r\n");
if(!radio_wait_for_ok(10))
{
bufferPrintf("radio: no response from baseband!\r\n");
return -1;
}
bufferPrintf("radio: setting speed to 750000 baud.\r\n");
radio_write("at+ipr=750000\r\n");
// wait a millisecond for the command to totally clear uart
// I wasn't able to detect this condition with uart registers (looking at FIFO count, transmitter empty)
udelay(1000);
uart_set_baud_rate(RADIO_UART, 750000);
if(!radio_wait_for_ok(10))
{
bufferPrintf("radio: no response from baseband!\r\n");
return -1;
}
RadioAvailable = TRUE;
bufferPrintf("radio: ready.\r\n");
speaker_setup();
return 0;
}
void cmd_audiohw_play_pcm(int argc, char** argv)
{
if(argc < 3) {
bufferPrintf("Usage: %s <address> <len> [use-headphones]\r\n", argv[0]);
return;
}
uint32_t address = parseNumber(argv[1]);
uint32_t len = parseNumber(argv[2]);
uint32_t useHeadphones = 0;
if(argc > 3)
useHeadphones = parseNumber(argv[3]);
if(useHeadphones)
{
bufferPrintf("playing PCM 0x%x - 0x%x using headphones\r\n", address, address + len);
audiohw_play_pcm((void*)address, len, FALSE);
} else
{
bufferPrintf("playing PCM 0x%x - 0x%x using speakers\r\n", address, address + len);
audiohw_play_pcm((void*)address, len, TRUE);
}
}
void cmd_multitouch_setup(int argc, char** argv)
{
if(argc < 5)
{
bufferPrintf("%s <a-speed fw> <a-speed fw len> <main fw> <main fw len>\r\n", argv[0]);
return;
}
uint8_t* aspeedFW = (uint8_t*) parseNumber(argv[1]);
uint32_t aspeedFWLen = parseNumber(argv[2]);
uint8_t* mainFW = (uint8_t*) parseNumber(argv[3]);
uint32_t mainFWLen = parseNumber(argv[4]);
multitouch_setup(aspeedFW, aspeedFWLen, mainFW, mainFWLen);
}
void images_append(void* data, int len) {
if(MaxOffset >= 0xfc000 || (MaxOffset + len) >= 0xfc000) {
bufferPrintf("writing image of size %d at %x would overflow NOR!\r\n", len, MaxOffset);
} else {
nor_write(data, MaxOffset, len);
// Destroy any following image
if((MaxOffset + len) < 0xfc000) {
uint8_t zero = 0;
nor_write(&zero, MaxOffset + len, 1);
}
images_release();
images_setup();
}
}
void doAES(int enc, void* data, int size, AESKeyType _keyType, const void* key, AESKeyLen keyLen, const void* iv)
{
uint32_t keyType = 0;
uint8_t* buff = NULL;
switch(_keyType)
{
case AESCustom:
switch(keyLen)
{
case AES128:
keyType = 0 << 28;
break;
case AES192:
keyType = 1 << 28;
break;
case AES256:
keyType = 2 << 28;
break;
default:
return;
}
break;
case AESGID:
keyType = 512 | (2 << 28);
break;
case AESUID:
keyType = 513 | (2 << 28);
break;
default:
return;
}
buff = memalign(DMA_ALIGN, size);
if (!buff) {
bufferPrintf("out of memory.\r\n");
goto return_free;
}
memcpy(buff, data, size);
aes_crypto_cmd(enc, buff, buff, size, keyType, (void*)key, (void*)iv);
memcpy(data, buff, size);
return_free:
if(buff)
free(buff);
}
static uint16_t virtual_block_to_physical_block(uint16_t virtualBank, uint16_t virtualBlock) {
if(isGoodBlock(pstVFLCxt[virtualBank].badBlockTable, virtualBlock))
return virtualBlock;
int pwDesPbn;
for(pwDesPbn = 0; pwDesPbn < pstVFLCxt[virtualBank].numReservedBlocks; pwDesPbn++) {
if(pstVFLCxt[virtualBank].reservedBlockPoolMap[pwDesPbn] == virtualBlock) {
if(pwDesPbn >= Data->blocksPerBank) {
bufferPrintf("ftl: Destination physical block for remapping is greater than number of blocks per bank!");
}
return pstVFLCxt[virtualBank].reservedBlockPoolStart + pwDesPbn;
}
}
return virtualBlock;
}
static int add_block_to_scrub_list(vfl_vsvfl_device_t *_vfl, uint32_t _ce, uint32_t _block) {
if(is_block_in_scrub_list(_vfl, _ce, _block))
return 0;
if(_vfl->contexts[_ce].scrub_list_length > 0x13) {
bufferPrintf("vfl: too many scrubs!\r\n");
return 0;
}
if(!vfl_check_checksum(_vfl, _ce))
system_panic("vfl_add_block_to_scrub_list: failed checksum\r\n");
_vfl->contexts[_ce].scrub_list[_vfl->contexts[_ce].scrub_list_length++] = _block;
vfl_gen_checksum(_vfl, _ce);
return vsvfl_store_vfl_cxt(_vfl, _ce);
}
static void usb_flush_fifo(int _fifo)
{
bufferPrintf("USB: Flushing %d.\n", _fifo);
EnterCriticalSection();
// Wait until FIFOs aren't being accessed
while((GET_REG(USB + GRSTCTL) & GRSTCTL_AHBIDLE) == 0);
// Flush FIFOs
SET_REG(USB+GRSTCTL, ((_fifo & GRSTCTL_TXFFNUM_MASK) << GRSTCTL_TXFFNUM_SHIFT) | GRSTCTL_TXFFLUSH);
// Wait for FIFOs to be flushed
while(GET_REG(USB+GRSTCTL) & GRSTCTL_TXFFLUSH);
LeaveCriticalSection();
}
int miu_setup() {
#ifdef CONFIG_IPOD2G
if(POWER_ID_EPOCH(GET_REG(POWER + POWER_ID)) != chipid_get_power_epoch()) {
#else
if(POWER_ID_EPOCH(*((uint8_t*)(POWER + POWER_ID))) != 3) {
#endif
// Epoch mismatch
bufferPrintf("miu: epoch mismatch\r\n");
return -1;
}
#ifndef CONFIG_IPOD2G
clock_set_bottom_bits_38100000(1);
#endif
return 0;
}
const char* ARMv7DOpcodeBranchConditionalT1::format()
{
if (condition() == 0xe)
return defaultFormat();
if (condition() == 0xf) {
appendInstructionName("svc");
appendUnsignedImmediate(offset());
return m_formatBuffer;
}
bufferPrintf(" b%-6.6s", conditionName(condition()));
appendPCRelativeOffset(static_cast<int32_t>(offset()) + 2);
return m_formatBuffer;
}
void init_boot_modules()
{
if(init_boot_done)
return;
init_boot_done = TRUE;
bufferPrintf("init: Initializing boot modules.\n");
initfn_t *fn = &init_boot_init;
fn++;
while(*fn)
{
(*fn)();
fn++;
}
}
static int acm_send()
{
if(acm_file_recv_left > 0)
{
acm_busy = TRUE;
return 1;
}
if(acm_file_send_left > 0)
{
acm_busy = TRUE;
int amt = acm_file_send_left;
if(amt > acm_usb_mps)
amt = acm_usb_mps;
memcpy(acm_send_buffer, acm_file_ptr, amt);
acm_file_ptr += amt;
acm_file_send_left -= amt;
usb_send_bulk(ACM_EP_SEND, acm_send_buffer, amt);
if(acm_file_send_left == 0)
bufferPrintf("ACM: Sent file (finished at 0x%08x)!\n", acm_file_ptr);
return 1;
}
if(getScrollbackLen() > 0)
{
acm_busy = TRUE;
int amt = getScrollbackLen();
if(amt > acm_usb_mps)
amt = acm_usb_mps;
bufferFlush(acm_send_buffer, amt);
usb_send_bulk(ACM_EP_SEND, acm_send_buffer, amt);
return 1;
}
acm_busy = FALSE;
return 0;
}
