static int setup_devices() {
// Basic prerequisites for everything else
miu_setup();
power_setup();
clock_setup();
// Need interrupts for everything afterwards
interrupt_setup();
gpio_setup();
// For scheduling/sleeping niceties
timer_setup();
event_setup();
wdt_setup();
// Other devices
usb_shutdown();
uart_setup();
i2c_setup();
dma_setup();
spi_setup();
return 0;
}
static int setup_devices() {
// Basic prerequisites for everything else
miu_setup();
power_setup();
clock_setup();
// Need interrupts for everything afterwards
interrupt_setup();
// gpio_setup(); // Not yet
// For scheduling/sleeping niceties
timer_setup();
event_setup();
#ifndef CONFIG_IPHONE_4
wdt_setup();
#endif
// Other devices
usb_shutdown();
#ifndef CONFIG_IPHONE_4
uart_setup();
i2c_setup();
dma_setup();
spi_setup();
#endif
return 0;
}
void shutdown_drivers()
{
// some drivers require a shutdown
enet_quiesce();
usb_shutdown();
}
void platform_init()
{
arm_setup();
mmu_setup();
tasks_setup();
// Basic prerequisites for everything else
miu_setup();
power_setup();
clock_setup();
// Need interrupts for everything afterwards
interrupt_setup();
gpio_setup();
// For scheduling/sleeping niceties
timer_setup();
event_setup();
// Other devices
usb_shutdown();
uart_setup();
i2c_setup();
// DMA currently f***s up. Need to check why. -- Bluerise
// dma_setup();
LeaveCriticalSection();
framebuffer_hook(); // TODO: Remove once LCD implemented -- Ricky26
framebuffer_setdisplaytext(TRUE);
}
int main(int argc, char *argv[])
{
int listenfd;
int res = 0;
int lfd;
struct flock lock;
char pids[10];
parse_opts(argc, argv);
argc -= optind;
argv += optind;
if (!foreground) {
verbose += LL_WARNING;
log_enable_syslog();
} else {
verbose += LL_NOTICE;
}
/* set log level to specified verbosity */
log_level = verbose;
usbmuxd_log(LL_NOTICE, "usbmuxd v%s starting up", PACKAGE_VERSION);
should_exit = 0;
should_discover = 0;
set_signal_handlers();
signal(SIGPIPE, SIG_IGN);
res = lfd = open(lockfile, O_WRONLY|O_CREAT, 0644);
if(res == -1) {
usbmuxd_log(LL_FATAL, "Could not open lockfile");
goto terminate;
}
lock.l_type = F_WRLCK;
lock.l_whence = SEEK_SET;
lock.l_start = 0;
lock.l_len = 0;
lock.l_pid = 0;
fcntl(lfd, F_GETLK, &lock);
close(lfd);
if (lock.l_type != F_UNLCK) {
if (opt_exit) {
if (lock.l_pid && !kill(lock.l_pid, 0)) {
usbmuxd_log(LL_NOTICE, "Sending signal %d to instance with pid %d", exit_signal, lock.l_pid);
res = 0;
if (kill(lock.l_pid, exit_signal) < 0) {
usbmuxd_log(LL_FATAL, "Could not deliver signal %d to pid %d", exit_signal, lock.l_pid);
res = -1;
}
goto terminate;
} else {
usbmuxd_log(LL_ERROR, "Could not determine pid of the other running instance!");
res = -1;
goto terminate;
}
} else {
if (!opt_disable_hotplug) {
usbmuxd_log(LL_ERROR, "Another instance is already running (pid %d). exiting.", lock.l_pid);
res = -1;
} else {
usbmuxd_log(LL_NOTICE, "Another instance is already running (pid %d). Telling it to check for devices.", lock.l_pid);
if (lock.l_pid && !kill(lock.l_pid, 0)) {
usbmuxd_log(LL_NOTICE, "Sending signal SIGUSR2 to instance with pid %d", lock.l_pid);
res = 0;
if (kill(lock.l_pid, SIGUSR2) < 0) {
usbmuxd_log(LL_FATAL, "Could not deliver SIGUSR2 to pid %d", lock.l_pid);
res = -1;
}
} else {
usbmuxd_log(LL_ERROR, "Could not determine pid of the other running instance!");
res = -1;
}
}
goto terminate;
}
}
unlink(lockfile);
if (opt_exit) {
usbmuxd_log(LL_NOTICE, "No running instance found, none killed. Exiting.");
goto terminate;
}
if (!foreground) {
if ((res = daemonize()) < 0) {
fprintf(stderr, "usbmuxd: FATAL: Could not daemonize!\n");
usbmuxd_log(LL_FATAL, "Could not daemonize!");
goto terminate;
}
}
// now open the lockfile and place the lock
res = lfd = open(lockfile, O_WRONLY|O_CREAT|O_TRUNC|O_EXCL, 0644);
if(res < 0) {
usbmuxd_log(LL_FATAL, "Could not open lockfile");
goto terminate;
}
lock.l_type = F_WRLCK;
lock.l_whence = SEEK_SET;
lock.l_start = 0;
lock.l_len = 0;
if ((res = fcntl(lfd, F_SETLK, &lock)) < 0) {
usbmuxd_log(LL_FATAL, "Lockfile locking failed!");
goto terminate;
}
sprintf(pids, "%d", getpid());
if ((size_t)(res = write(lfd, pids, strlen(pids))) != strlen(pids)) {
usbmuxd_log(LL_FATAL, "Could not write pidfile!");
if(res >= 0)
res = -2;
goto terminate;
}
// set number of file descriptors to higher value
struct rlimit rlim;
getrlimit(RLIMIT_NOFILE, &rlim);
rlim.rlim_max = 65536;
setrlimit(RLIMIT_NOFILE, (const struct rlimit*)&rlim);
usbmuxd_log(LL_INFO, "Creating socket");
res = listenfd = create_socket();
if(listenfd < 0)
goto terminate;
#ifdef HAVE_LIBIMOBILEDEVICE
const char* userprefdir = config_get_config_dir();
struct stat fst;
memset(&fst, '\0', sizeof(struct stat));
if (stat(userprefdir, &fst) < 0) {
if (mkdir(userprefdir, 0775) < 0) {
usbmuxd_log(LL_FATAL, "Failed to create required directory '%s': %s", userprefdir, strerror(errno));
res = -1;
goto terminate;
}
if (stat(userprefdir, &fst) < 0) {
usbmuxd_log(LL_FATAL, "stat() failed after creating directory '%s': %s", userprefdir, strerror(errno));
res = -1;
goto terminate;
}
}
// make sure permission bits are set correctly
if (fst.st_mode != 02775) {
if (chmod(userprefdir, 02775) < 0) {
usbmuxd_log(LL_WARNING, "chmod(%s, 02775) failed: %s", userprefdir, strerror(errno));
}
}
#endif
// drop elevated privileges
if (drop_privileges && (getuid() == 0 || geteuid() == 0)) {
struct passwd *pw;
if (!drop_user) {
usbmuxd_log(LL_FATAL, "No user to drop privileges to?");
res = -1;
goto terminate;
}
pw = getpwnam(drop_user);
if (!pw) {
usbmuxd_log(LL_FATAL, "Dropping privileges failed, check if user '%s' exists!", drop_user);
res = -1;
goto terminate;
}
if (pw->pw_uid == 0) {
usbmuxd_log(LL_INFO, "Not dropping privileges to root");
} else {
#ifdef HAVE_LIBIMOBILEDEVICE
/* make sure the non-privileged user has proper access to the config directory */
if ((fst.st_uid != pw->pw_uid) || (fst.st_gid != pw->pw_gid)) {
if (chown(userprefdir, pw->pw_uid, pw->pw_gid) < 0) {
usbmuxd_log(LL_WARNING, "chown(%s, %d, %d) failed: %s", userprefdir, pw->pw_uid, pw->pw_gid, strerror(errno));
}
}
#endif
if ((res = initgroups(drop_user, pw->pw_gid)) < 0) {
usbmuxd_log(LL_FATAL, "Failed to drop privileges (cannot set supplementary groups)");
goto terminate;
}
if ((res = setgid(pw->pw_gid)) < 0) {
usbmuxd_log(LL_FATAL, "Failed to drop privileges (cannot set group ID to %d)", pw->pw_gid);
goto terminate;
}
if ((res = setuid(pw->pw_uid)) < 0) {
usbmuxd_log(LL_FATAL, "Failed to drop privileges (cannot set user ID to %d)", pw->pw_uid);
goto terminate;
}
// security check
if (setuid(0) != -1) {
usbmuxd_log(LL_FATAL, "Failed to drop privileges properly!");
res = -1;
goto terminate;
}
if (getuid() != pw->pw_uid || getgid() != pw->pw_gid) {
usbmuxd_log(LL_FATAL, "Failed to drop privileges properly!");
res = -1;
goto terminate;
}
usbmuxd_log(LL_NOTICE, "Successfully dropped privileges to '%s'", drop_user);
}
}
client_init();
device_init();
usbmuxd_log(LL_INFO, "Initializing USB");
if((res = usb_init()) < 0)
goto terminate;
usbmuxd_log(LL_INFO, "%d device%s detected", res, (res==1)?"":"s");
usbmuxd_log(LL_NOTICE, "Initialization complete");
if (report_to_parent)
if((res = notify_parent(0)) < 0)
goto terminate;
if(opt_disable_hotplug) {
usbmuxd_log(LL_NOTICE, "Automatic device discovery on hotplug disabled.");
usb_autodiscover(0); // discovery to be triggered by new instance
}
if (opt_enable_exit) {
usbmuxd_log(LL_NOTICE, "Enabled exit on SIGUSR1 if no devices are attached. Start a new instance with \"--exit\" to trigger.");
}
res = main_loop(listenfd);
if(res < 0)
usbmuxd_log(LL_FATAL, "main_loop failed");
usbmuxd_log(LL_NOTICE, "usbmuxd shutting down");
device_kill_connections();
usb_shutdown();
device_shutdown();
client_shutdown();
usbmuxd_log(LL_NOTICE, "Shutdown complete");
terminate:
log_disable_syslog();
if (res < 0)
res = -res;
else
res = 0;
if (report_to_parent)
notify_parent(res);
return res;
}
void shutdown_drivers() {
// some drivers require a shutdown
enet_quiesce();
usb_shutdown();
data_breakpoint(NULL,0,0);
}
void
usb_msd_shutdown (void)
{
usb_shutdown ();
usb_msd->state = USB_MSD_STATE_UNINIT;
}
static void usb_rx_cmd_complete(struct usb_request *req, unsigned actual, int status)
{
if(status != 0) return;
if(actual > 4095) actual = 4095;
cmdbuf[actual] = 0;
dprintf("\n> %s\n",cmdbuf);
// dprintf("usb_rx_cmd_complete() '%s'\n", cmdbuf);
if(memcmp(cmdbuf, "reboot", 6) == 0) {
tx_status("OKAY");
rx_cmd();
mdelay(100);
board_reboot();
}
#if 0
if(memcmp(cmdbuf, "debug:", 6) == 0) {
void debug(char *cmd, char *resp);
memcpy(cmdbuf, "OKAY", 5);
tx_status(cmdbuf);
rx_cmd();
mdelay(5000);
dprintf("NOW!\n");
debug(cmdbuf + 6, cmdbuf + 4);
return;
}
#endif
if(memcmp(cmdbuf, "getvar:", 7) == 0) {
char response[64];
strcpy(response,"OKAY");
if(!strcmp(cmdbuf + 7, "version")) {
strcpy(response + 4, VERSION);
} else if(!strcmp(cmdbuf + 7, "product")) {
strcpy(response + 4, PRODUCTNAME);
} else if(!strcmp(cmdbuf + 7, "serialno")) {
strcpy(response + 4, serialno);
} else {
board_getvar(cmdbuf + 7, response + 4);
}
tx_status(response);
rx_cmd();
return;
}
if(memcmp(cmdbuf, "download:", 9) == 0) {
char status[16];
rx_addr = kernel_addr;
rx_length = hex2unsigned(cmdbuf + 9);
if (rx_length > (64*1024*1024)) {
tx_status("FAILdata too large");
rx_cmd();
return;
}
kernel_size = rx_length;
dprintf("recv data addr=%x size=%x\n", rx_addr, rx_length);
strcpy(status,"DATA");
num_to_hex8(rx_length, status + 4);
tx_status(status);
rx_data();
return;
}
if(memcmp(cmdbuf, "erase:", 6) == 0){
struct ptentry *ptn;
ptn = flash_find_ptn(cmdbuf + 6);
if(ptn == 0) {
tx_status("FAILpartition does not exist");
rx_cmd();
return;
}
dprintf("erasing '%s'\n", ptn->name);
cprintf("erasing '%s'", ptn->name);
if(flash_erase(ptn)) {
tx_status("FAILfailed to erase partition");
rx_cmd();
cprintf(" - FAIL\n");
return;
} else {
dprintf("partition '%s' erased\n", ptn->name);
cprintf(" - OKAY\n");
}
tx_status("OKAY");
rx_cmd();
return;
}
if(memcmp(cmdbuf, "flash:", 6) == 0){
struct ptentry *ptn;
int extra = 0;
ptn = flash_find_ptn(cmdbuf + 6);
if(kernel_size == 0) {
tx_status("FAILno image downloaded");
rx_cmd();
return;
}
if(ptn == 0) {
tx_status("FAILpartition does not exist");
rx_cmd();
return;
}
if(!strcmp(ptn->name,"boot") || !strcmp(ptn->name,"recovery")) {
if(memcmp((void*) kernel_addr, BOOT_MAGIC, BOOT_MAGIC_SIZE)) {
tx_status("FAILimage is not a boot image");
rx_cmd();
return;
}
}
#if REQUIRE_SIGNATURE
{
unsigned char digest[DIGEST_SIZE];
compute_digest((void*) kernel_addr, kernel_size, digest);
if (is_signature_okay(digest, signature, key_engineering)) {
dprintf("verified by engineering key\n");
} else {
tx_status("FAILsignature did not verify");
rx_cmd();
return;
}
}
#endif
if(!strcmp(ptn->name,"system") || !strcmp(ptn->name,"userdata")) {
extra = 64;
} else {
kernel_size = (kernel_size + 2047) & (~2047);
}
dprintf("writing %d bytes to '%s'\n",
kernel_size, ptn->name);
cprintf("writing '%s' (%d bytes)", ptn->name, kernel_size);
if(flash_write(ptn, extra, (void*) kernel_addr, kernel_size)) {
tx_status("FAILflash write failure");
rx_cmd();
cprintf(" - FAIL\n");
return;
} else {
dprintf("partition '%s' updated\n", ptn->name);
cprintf(" - OKAY\n");
}
tx_status("OKAY");
rx_cmd();
return;
}
if(memcmp(cmdbuf, "boot", 4) == 0) {
if(init_boot_linux()) {
tx_status("FAILinvalid boot image");
rx_cmd();
return;
}
dprintf("booting linux...\n");
cprintf("\nbooting linux...\n");
tx_status("OKAY");
mdelay(10);
usb_shutdown();
boot_linux();
return;
}
if(memcmp(cmdbuf, "signature", 9) == 0) {
if (kernel_size != SIGNATURE_SIZE) {
tx_status("FAILsignature not 256 bytes long");
rx_cmd();
return;
}
memcpy(signature, (void*)kernel_addr, SIGNATURE_SIZE);
tx_status("OKAY");
rx_cmd();
return;
}
tx_status("FAILinvalid command");
rx_cmd();
}
void usb_serial_class::end()
{
usb_shutdown();
delay(25);
}
int usb_setup(USBEnumerateHandler hEnumerate, USBStartHandler hStart)
{
usb_shutdown();
// This is not relevant to the hardware,
// and usb_setup is called when setting up a new
// USB protocol. So we should reset the EP
// handlers here! -- Ricky26
memset(endpoint_handlers, 0, sizeof(endpoint_handlers));
startHandler = hStart;
enumerateHandler = hEnumerate;
setupHandler = NULL;
if(usb_inited)
return 0;
if(controlSendBuffer == NULL)
controlSendBuffer = memalign(DMA_ALIGN, CONTROL_SEND_BUFFER_LEN);
if(controlRecvBuffer == NULL)
controlRecvBuffer = memalign(DMA_ALIGN, CONTROL_RECV_BUFFER_LEN);
InEPRegs = (USBEPRegisters*)(USB + USB_INREGS);
OutEPRegs = (USBEPRegisters*)(USB + USB_OUTREGS);
change_state(USBStart);
initializeDescriptors();
// Initialize our data structures
memset(usb_message_queue, 0, sizeof(usb_message_queue));
#ifdef USB_PHY_1G
// Power on hardware
power_ctrl(POWER_USB, ON);
udelay(USB_START_DELAYUS);
#else
// Wait for USB hardware to come alive
udelay(10000);
#endif
// Set up the hardware
clock_gate_switch(USB_OTGCLOCKGATE, ON);
clock_gate_switch(USB_PHYCLOCKGATE, ON);
#ifdef USB_PHY_1G
clock_gate_switch(EDRAM_CLOCKGATE, ON);
#endif
// power on OTG
SET_REG(USB + PCGCCTL, (GET_REG(USB + PCGCCTL) & (~PCGCCTL_ONOFF_MASK)) | PCGCCTL_ON);
udelay(USB_ONOFFSTART_DELAYUS);
// Generate a soft disconnect on host
//SET_REG(USB + DCTL, GET_REG(USB + DCTL) | DCTL_SFTDISCONNECT);
//udelay(USB_SFTDISCONNECT_DELAYUS);
// Initialise PHY
usb_phy_init();
bufferPrintf("USB: Hardware Configuration\n"
" HWCFG1 = 0x%08x\n"
" HWCFG2 = 0x%08x\n"
" HWCFG3 = 0x%08x\n"
" HWCFG4 = 0x%08x\n",
GET_REG(USB+GHWCFG1),
GET_REG(USB+GHWCFG2),
GET_REG(USB+GHWCFG3),
GET_REG(USB+GHWCFG4));
usb_inited = TRUE;
interrupt_install(USB_INTERRUPT, usbIRQHandler, 0);
// Start USB
usb_start();
return 0;
}
