void do_booti_linux (boot_img_hdr *hdr)
{
char *bootargs;
ulong initrd_start, initrd_end;
void (*theKernel)(int zero, int arch, uint params);
bd_t *bd = gd->bd;
theKernel = (void (*)(int, int, uint))(hdr->kernel_addr);
initrd_start = hdr->ramdisk_addr;
initrd_end = initrd_start + hdr->ramdisk_size;
printf(" Initrd start : %p , Initrd end : %p",initrd_start, initrd_end);
#if defined (CONFIG_SETUP_MEMORY_TAGS)
setup_start_tag (bd);
#ifdef CONFIG_SERIAL_TAG
setup_serial_tag (¶ms);
#endif
#ifdef CONFIG_REVISION_TAG
setup_revision_tag (¶ms);
#endif
#ifdef CONFIG_SETUP_MEMORY_TAGS
setup_memory_tags (bd);
#endif
#ifdef CONFIG_CMDLINE_TAG
bootargs = getenv("bootargs");
if (bootargs == NULL ||
*bootargs == '\0') {
bootargs = hdr->cmdline;
}
setup_commandline_tag (bd, bootargs);
#endif
#ifdef CONFIG_INITRD_TAG
if (hdr->ramdisk_size)
setup_initrd_tag (bd, initrd_start, initrd_end);
#endif
#if defined (CONFIG_VFD) || defined (CONFIG_LCD)
setup_videolfb_tag ((gd_t *) gd);
#endif
setup_modelid_tag (¶ms);
setup_end_tag (bd);
#endif
/* we assume that the kernel is in place */
printf ("\nStarting kernel ...\n\n");
#ifdef CONFIG_USB_DEVICE
{
extern void udc_disconnect (void);
udc_disconnect ();
}
#endif
cleanup_before_linux ();
theKernel (0, bd->bi_arch_number, bd->bi_boot_params);
}
/* *
* usbd_proc_write - implement proc file system write.
* @file
* @buf
* @count
* @pos
*
* Proc file system write function, used to signal monitor actions complete.
* (Hotplug script (or whatever) writes to the file to signal the completion
* of the script.) An ugly hack.
*/
static ssize_t usbd_proc_write (struct file *file, const char *buf, size_t count, loff_t * pos)
{
struct usb_device_instance *device;
size_t n = count;
char command[64];
char *cp = command;
int i = 0;
MOD_INC_USE_COUNT;
//printk(KERN_DEBUG "%s: count=%u\n",__FUNCTION__,count);
while ((n > 0) && (i < 64)) {
// Not too efficient, but it shouldn't matter
if (copy_from_user (cp++, buf + (count - n), 1)) {
count = -EFAULT;
break;
}
*cp = '\0';
i++;
n -= 1;
//printk(KERN_DEBUG "%s: %u/%u %02x\n",__FUNCTION__,count-n,count,c);
}
if (!strncmp (command, "plug", 4)) {
udc_connect ();
}
else if (!strncmp (command, "unplug", 6)) {
udc_disconnect ();
if ((device = device_array[0])) {
usbd_device_event (device, DEVICE_RESET, 0);
}
}
MOD_DEC_USE_COUNT;
return (count);
}
static void announce_and_cleanup(void)
{
printf("\nStarting kernel ...\n\n");
#ifdef CONFIG_USB_DEVICE
{
extern void udc_disconnect(void);
udc_disconnect();
}
#endif
cleanup_before_linux();
}
/*
* usbd_pm_callback
* @dev:
* @rqst:
* @unused:
*
* Used to signal power management events.
*/
static int bi_pm_event (struct pm_dev *pm_dev, pm_request_t request, void *unused)
{
struct usb_device_instance *device;
dbg_pm (0, "request: %d pm_dev: %p data: %p", request, pm_dev, pm_dev->data);
if (!(device = pm_dev->data)) {
dbg_pm (0, "DATA NULL, NO DEVICE");
return 0;
}
switch (request) {
#if defined(CONFIG_IRIS)
case PM_STANDBY:
case PM_BLANK:
#endif
case PM_SUSPEND:
dbg_pm (0, "PM_SUSPEND");
if (!pm_suspended) {
pm_suspended = 1;
dbg_init (1, "MOD_INC_USE_COUNT %d", GET_USE_COUNT (THIS_MODULE));
udc_disconnect (); // disable USB pullup if we can
udc_disable_interrupts (device); // disable interupts
udc_disable (); // disable UDC
dbg_pm (0, "PM_SUSPEND: finished");
}
break;
#if defined(CONFIG_IRIS)
case PM_UNBLANK:
#endif
case PM_RESUME:
dbg_pm (0, "PM_RESUME");
if (pm_suspended) {
// probe for device
if (udc_init ()) {
dbg_init (0, "udc_init failed");
//return -EINVAL;
}
udc_enable (device); // enable UDC
udc_all_interrupts (device); // enable interrupts
udc_connect (); // enable USB pullup if we can
//udc_set_address(device->address);
//udc_reset_ep(0);
pm_suspended = 0;
dbg_init (1, "MOD_INC_USE_COUNT %d", GET_USE_COUNT (THIS_MODULE));
dbg_pm (0, "PM_RESUME: finished");
}
break;
}
return 0;
}
int board_init(void)
{
/* We have RAM, disable cache */
dcache_disable();
icache_disable();
gd->bd->bi_arch_number = MACH_TYPE_H2200;
/* adress of boot parameters */
gd->bd->bi_boot_params = 0xa0000100;
/* Let host see that device is disconnected */
udc_disconnect();
mdelay(500);
return 0;
}
static int
bi_udc_suspend(struct device *dev, u32 state, u32 level)
{
struct usb_device_instance *device = device_array[0];
switch (level) {
case SUSPEND_POWER_DOWN:
dbg_pm (0, "SUSPEND_POWER_DOWN");
dbg_init (1, "MOD_INC_USE_COUNT %d",
GET_USE_COUNT (THIS_MODULE));
udc_disconnect (); /* disable USB pullup */
if (device)
udc_disable_interrupts (device); /* disable interrupts */
udc_disable (); /* disable UDC */
dbg_pm (0, "SUSPEND_POWER_DOWN: finished");
break;
}
return 0;
}
/**
* bi_udc_exit - Stop using the USB Device Controller
*
* Stop using the USB Device Controller.
*
* Shutdown and free dma channels, de-register the interrupt handler.
*/
void bi_udc_exit(void)
{
int i;
dbg_init(1, "Unloading %s", udc_name());
for (i = 0; i < udc_max_endpoints(); i++) {
udc_disable_ep(i);
}
// free io and irq
udc_disconnect();
udc_disable();
udc_release_io();
udc_release_udc_irq();
if (have_cable_irq) {
udc_release_cable_irq();
}
}
void do_booti_linux (boot_img_hdr *hdr)
{
ulong initrd_start, initrd_end;
void (*theKernel)(int zero, int arch, uint params);
bd_t *bd = gd->bd;
int machid = bd->bi_arch_number;
#ifdef CONFIG_CMDLINE_TAG
char *commandline = getenv("bootargs");
char *machidString = getenv("machid");
/* If no bootargs env, just use hdr command line */
if (!commandline)
commandline = (char *)hdr->cmdline;
if (machidString)
machid = simple_strtoul(machidString, NULL, 16);
/* XXX: in production, you should always use boot.img 's cmdline !!! */
printf("kernel cmdline: \n");
printf("\tuse %s ", getenv("bootargs") ? "uboot" : "boot.img");
printf("command line:\n\t%s \n", commandline);
printf ("\tUsing machid 0x%x\n", machid);
#endif
theKernel = (void (*)(int, int, uint))(hdr->kernel_addr);
initrd_start = hdr->ramdisk_addr;
initrd_end = initrd_start + hdr->ramdisk_size;
#if defined (CONFIG_SETUP_MEMORY_TAGS)
setup_start_tag(bd);
#ifdef CONFIG_SERIAL_TAG
setup_serial_tag (¶ms);
#endif
#ifdef CONFIG_REVISION_TAG
setup_revision_tag (¶ms);
#endif
#ifdef CONFIG_SETUP_MEMORY_TAGS
setup_memory_tags (bd);
#endif
#ifdef CONFIG_CMDLINE_TAG
setup_commandline_tag (bd, commandline);
#endif
#ifdef CONFIG_INITRD_TAG
if (hdr->ramdisk_size)
setup_initrd_tag (bd, initrd_start, initrd_end);
#endif
#if defined (CONFIG_VFD) || defined (CONFIG_LCD)
setup_videolfb_tag ((gd_t *) gd);
#endif
setup_end_tag (bd);
#endif
/* we assume that the kernel is in place */
printf ("\nStarting kernel ...\n\n");
#ifdef CONFIG_USB_DEVICE
{
extern void udc_disconnect (void);
udc_disconnect ();
}
#endif
cleanup_before_linux ();
theKernel (0, machid, bd->bi_boot_params);
}
void do_booti_linux (boot_img_hdr *hdr)
{
ulong initrd_start, initrd_end;
void (*theKernel)(int zero, int arch, uint params);
bd_t *bd = gd->bd;
theKernel = (void (*)(int, int, uint))(hdr->kernel_addr);
initrd_start = hdr->ramdisk_addr;
initrd_end = initrd_start + hdr->ramdisk_size;
#if defined (CONFIG_SETUP_MEMORY_TAGS)
setup_start_tag (bd);
#ifdef CONFIG_SERIAL_TAG
setup_serial_tag (¶ms);
#endif
#ifdef CONFIG_REVISION_TAG
setup_revision_tag (¶ms);
#endif
#ifdef CONFIG_REVISION16_TAG
setup_revision16_tag (¶ms);
#endif
#ifdef CONFIG_SERIAL16_TAG
setup_serial16_tag (¶ms);
#endif
#ifdef CONFIG_MACADDR_TAG
setup_macaddr_tag (¶ms);
#endif
#ifdef CONFIG_BOOTMODE_TAG
setup_bootmode_tag (¶ms);
#endif
#ifdef CONFIG_GYROCAL_TAG
setup_gyrocal_tag (¶ms);
#endif
#ifdef CONFIG_PRODUCTID_TAG
setup_productid_tag (¶ms);
#endif
#ifdef CONFIG_SETUP_MEMORY_TAGS
setup_memory_tags (bd);
#endif
#ifdef CONFIG_CMDLINE_TAG
setup_commandline_tag (bd, hdr->cmdline);
#endif
#ifdef CONFIG_INITRD_TAG
if (hdr->ramdisk_size)
setup_initrd_tag (bd, initrd_start, initrd_end);
#endif
#if defined (CONFIG_VFD) || defined (CONFIG_LCD)
setup_videolfb_tag ((gd_t *) gd);
#endif
setup_end_tag (bd);
#endif
/* we assume that the kernel is in place */
printf ("\nStarting kernel ...\n\n");
#ifdef CONFIG_USB_DEVICE
{
extern void udc_disconnect (void);
udc_disconnect ();
}
#endif
cleanup_before_linux ();
theKernel (0, bd->bi_arch_number, bd->bi_boot_params);
}
int do_neo1973 ( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
int i;
if (!strcmp(argv[1], "info")) {
printf("FIC Neo1973 Hardware Revision 0x%04x\n", get_board_rev());
} else if (!strcmp(argv[1], "power-off")) {
neo1973_poweroff();
} else if (!strcmp(argv[1], "charger") || !strcmp(argv[1], "charge")) {
if (argc < 3)
goto out_help;
if (!strcmp(argv[2], "status") || !strcmp(argv[2], "state")) {
printf("%s\n", neo1973_get_charge_status());
} else if (!strcmp(argv[2], "autofast")) {
neo1973_set_charge_mode(NEO1973_CHGCMD_AUTOFAST);
} else if (!strcmp(argv[2], "!autofast")) {
neo1973_set_charge_mode(NEO1973_CHGCMD_NO_AUTOFAST);
} else if (!strcmp(argv[2], "off")) {
neo1973_set_charge_mode(NEO1973_CHGCMD_OFF);
} else if (!strcmp(argv[2], "fast")) {
neo1973_set_charge_mode(NEO1973_CHGCMD_FAST);
} else
goto out_help;
} else if (!strcmp(argv[1], "backlight")) {
if (argc < 3)
goto out_help;
if (!strcmp(argv[2], "on"))
neo1973_backlight(1);
else
neo1973_backlight(0);
} else if (!strcmp(argv[1], "led")) {
long led = simple_strtol(argv[2], NULL, 10);
if (argc < 4)
goto out_help;
if (!strcmp(argv[3], "on"))
neo1973_led(led, 1);
else
neo1973_led(led, 0);
} else if (!strcmp(argv[1], "vibrator")) {
if (argc < 3)
goto out_help;
if (!strcmp(argv[2], "on"))
neo1973_vibrator(1);
else
neo1973_vibrator(0);
} else if (!strcmp(argv[1], "gsm")) {
if (argc < 3)
goto out_help;
if (!strcmp(argv[2], "on"))
neo1973_gsm(1);
else if (!strcmp(argv[2], "off"))
neo1973_gsm(0);
else if (!strcmp(argv[2], "version"))
neo1973_gsmver();
} else if (!strcmp(argv[1], "gps")) {
if (argc < 3)
goto out_help;
if (!strcmp(argv[2], "on"))
neo1973_gps(1);
else
neo1973_gps(0);
} else if (!strcmp(argv[1], "udc")) {
if (argc < 3)
goto out_help;
if (!strcmp(argv[2], "pullup")) {
if (argc < 4)
goto out_help;
if (!strcmp(argv[3], "on"))
udc_connect();
else
udc_disconnect();
} else
goto out_help;
} else {
out_help:
printf("Usage:\n%s\n", cmdtp->usage);
return 1;
}
return 0;
}
int do_bootm_linux(int flag, int argc, char *argv[], bootm_headers_t *images)
{
bd_t *bd = gd->bd;
char *s;
int machid = bd->bi_arch_number;
void (*theKernel)(int zero, int arch, uint params);
#ifdef CONFIG_CMDLINE_TAG
char *commandline = getenv ("bootargs");
#endif
#ifdef CONFIG_MARVELL_TAG
char *env;
#endif
if ((flag != 0) && (flag != BOOTM_STATE_OS_GO))
return 1;
theKernel = (void (*)(int, int, uint))images->ep;
s = getenv ("machid");
if (s) {
machid = simple_strtoul (s, NULL, 16);
printf ("Using machid 0x%x from environment\n", machid);
}
show_boot_progress (15);
debug ("## Transferring control to Linux (at address %08lx) ...\n",
(ulong) theKernel);
#if defined (CONFIG_SETUP_MEMORY_TAGS) || \
defined (CONFIG_CMDLINE_TAG) || \
defined (CONFIG_INITRD_TAG) || \
defined (CONFIG_SERIAL_TAG) || \
defined (CONFIG_REVISION_TAG) || \
defined (CONFIG_LCD) || \
defined (CONFIG_VFD) || \
defined (CONFIG_MARVELL_TAG)
setup_start_tag (bd);
#ifdef CONFIG_SERIAL_TAG
setup_serial_tag (¶ms);
#endif
#ifdef CONFIG_REVISION_TAG
setup_revision_tag (¶ms);
#endif
#ifdef CONFIG_SETUP_MEMORY_TAGS
setup_memory_tags (bd);
#endif
#ifdef CONFIG_CMDLINE_TAG
setup_commandline_tag (bd, commandline);
#endif
#ifdef CONFIG_INITRD_TAG
if (images->rd_start && images->rd_end)
setup_initrd_tag (bd, images->rd_start, images->rd_end);
#endif
#if defined (CONFIG_VFD) || defined (CONFIG_LCD)
setup_videolfb_tag ((gd_t *) gd);
#endif
#if defined (CONFIG_MARVELL_TAG)
env = getenv("passDramInitTag");
if(((strcmp(env,"yes") == 0) || (strcmp(env,"Yes") == 0))) {
setup_marvell_tag();
}
#endif
setup_end_tag (bd);
#endif
/* we assume that the kernel is in place */
printf ("\nStarting kernel ...\n\n");
#ifdef CONFIG_USB_DEVICE
{
extern void udc_disconnect (void);
udc_disconnect ();
}
#endif
cleanup_before_linux ();
theKernel (0, machid, bd->bi_boot_params);
/* does not return */
return 1;
}
int do_bootm_linux(int flag, int argc, char *argv[], bootm_headers_t *images)
{
bd_t *bd = gd->bd;
char *s;
int machid = bd->bi_arch_number;
void (*theKernel)(int zero, int arch, uint params);
#ifdef CONFIG_CMDLINE_TAG
char *commandline = getenv("bootargs");
#endif
/*
* allow the PREP bootm subcommand, it is required for bootm to work
*/
if (flag & BOOTM_STATE_OS_PREP)
return 0;
if ((flag != 0) && (flag != BOOTM_STATE_OS_GO))
return 1;
theKernel = (void (*)(int, int, uint))images->ep;
s = getenv("machid");
if (s) {
machid = simple_strtoul(s, NULL, 16);
printf("Using machid 0x%x from environment\n", machid);
}
bootstage_mark(BOOTSTAGE_ID_RUN_OS);
debug("## Transferring control to Linux (at address %08lx) ...\n",
(ulong)theKernel);
#if defined(CONFIG_SETUP_MEMORY_TAGS) || \
defined(CONFIG_CMDLINE_TAG) || \
defined(CONFIG_INITRD_TAG) || \
defined(CONFIG_SERIAL_TAG) || \
defined(CONFIG_REVISION_TAG)
setup_start_tag(bd);
#ifdef CONFIG_SERIAL_TAG
setup_serial_tag(¶ms);
#endif
#ifdef CONFIG_REVISION_TAG
setup_revision_tag(¶ms);
#endif
#ifdef CONFIG_SETUP_MEMORY_TAGS
setup_memory_tags(bd);
#endif
#ifdef CONFIG_CMDLINE_TAG
setup_commandline_tag(bd, commandline);
#endif
#ifdef CONFIG_INITRD_TAG
if (images->rd_start && images->rd_end)
setup_initrd_tag(bd, images->rd_start, images->rd_end);
#endif
setup_end_tag(bd);
#endif
/* we assume that the kernel is in place */
printf("\nStarting kernel ...\n\n");
#ifdef CONFIG_USB_DEVICE
{
extern void udc_disconnect(void);
udc_disconnect();
}
#endif
cleanup_before_linux();
theKernel(0, machid, bd->bi_boot_params);
/* does not return */
return 1;
}
/**
* bi_device_event - handle generic bus event
* @device: device pointer
* @event: interrupt event
*
* Called by usb core layer to inform bus of an event.
*/
int bi_device_event(struct usb_device_instance *device, usb_device_event_t event, int data)
{
sie_info * sie_data;
cy_priv_t * cy_priv;
otg_t * otg;
sie_data = (sie_info *) device->bus->privdata;
cy_priv = (cy_priv_t *) sie_data->cy_priv;
otg = (otg_t *) cy_priv->otg;
//printk(KERN_DEBUG "bi_device_event: event: %d\n", event);
if (!device) {
return 0;
}
switch (event) {
case DEVICE_UNKNOWN:
break;
case DEVICE_INIT:
break;
case DEVICE_CREATE: // XXX should this stuff be in DEVICE_INIT?
bi_config(device);
// enable udc, enable interrupts, enable connect
udc_enable(device);
udc_all_interrupts(device);
udc_connect();
break;
case DEVICE_HUB_CONFIGURED:
break;
case DEVICE_RESET:
device->address = 0;
udc_set_address(device->address, device);
udc_reset_ep(0, device);
udc_all_interrupts(device); // XXX
break;
case DEVICE_ADDRESS_ASSIGNED:
udc_set_address(device->address, device);
device->status = USBD_OK;
break;
case DEVICE_CONFIGURED:
bi_config(device);
break;
case DEVICE_DE_CONFIGURED:
udc_reset_ep(1, device);
udc_reset_ep(2, device);
udc_reset_ep(3, device);
break;
case DEVICE_SET_INTERFACE:
bi_config(device);
break;
case DEVICE_SET_FEATURE:
break;
case DEVICE_CLEAR_FEATURE:
break;
case DEVICE_BUS_INACTIVE:
// disable suspend interrupt
udc_suspended_interrupts(device);
// XXX check on linkup and sl11
// if we are no longer connected then force a reset
if (!udc_connected()) {
usbd_device_event_irq(device, DEVICE_RESET, 0);
}
break;
case DEVICE_BUS_ACTIVITY:
// enable suspend interrupt
udc_all_interrupts(device);
break;
case DEVICE_POWER_INTERRUPTION:
break;
case DEVICE_HUB_RESET:
break;
case DEVICE_DESTROY:
udc_disconnect();
bi_disable_endpoints(device);
udc_disable_interrupts(device);
udc_disable();
break;
case DEVICE_BUS_REQUEST:
otg->b_bus_req = TRUE;
update_otg_state(otg);
break;
case DEVICE_BUS_RELEASE:
otg->b_bus_req = FALSE;
update_otg_state(otg);
break;
case DEVICE_RCV_URB_RECYCLED:
udc_rcv_urb_recycled();
break;
case DEVICE_ACCEPT_HNP:
otg->b_hnp_en = TRUE;
update_otg_state(otg);
break;
case DEVICE_REQUEST_SRP:
//otg->srp_start_flag = TRUE;
otg->b_bus_req = TRUE;
otg->b_se0_srp = TRUE;
update_otg_state(otg);
break;
case DEVICE_FUNCTION_PRIVATE:
break;
}
return 0;
}
/**
* bi_device_event - handle generic bus event
* @device: device pointer
* @event: interrupt event
*
* Called by usb core layer to inform bus of an event.
*/
int bi_device_event (struct usb_device_instance *device, usb_device_event_t event, int data)
{
//printk(KERN_DEBUG "bi_device_event: event: %d\n", event);
if (!device) {
return 0;
}
dbg_usbe (1,"%s", USBD_DEVICE_EVENTS(event));
switch (event) {
case DEVICE_UNKNOWN:
break;
case DEVICE_INIT:
break;
case DEVICE_CREATE: // XXX should this stuff be in DEVICE_INIT?
// enable upstream port
//ep0_enable(device);
// for net_create
bi_config (device);
// enable udc, enable interrupts, enable connect
printk(KERN_INFO"bi_device_event: call udc_enable\n");
udc_enable (device);
printk(KERN_INFO"bi_device_event: call udc_all_interrupts\n");
// XXX verify
udc_suspended_interrupts (device);
//udc_all_interrupts (device);
dbg_usbe (1, "CREATE done");
break;
case DEVICE_HUB_CONFIGURED:
udc_connect ();
break;
case DEVICE_RESET:
device->address = 0;
udc_set_address (device->address);
udc_reset_ep (0);
// XXX verify
udc_suspended_interrupts (device);
dbg_usbe (1, "DEVICE RESET done: %d", device->address);
break;
case DEVICE_ADDRESS_ASSIGNED:
udc_set_address (device->address);
device->status = USBD_OK;
// XXX verify
udc_all_interrupts (device); // XXX
break;
case DEVICE_CONFIGURED:
device->status = USBD_OK;
bi_config (device);
break;
case DEVICE_DE_CONFIGURED:
{
int ep;
for (ep = 1; ep < udc_max_endpoints (); ep++)
udc_reset_ep (ep);
}
break;
case DEVICE_SET_INTERFACE:
bi_config (device);
break;
case DEVICE_SET_FEATURE:
break;
case DEVICE_CLEAR_FEATURE:
break;
case DEVICE_BUS_INACTIVE:
// disable suspend interrupt
udc_suspended_interrupts (device);
// XXX check on linkup and sl11
// if we are no longer connected then force a reset
if (!udc_connected ()) {
usbd_device_event_irq (device, DEVICE_RESET, 0);
}
break;
case DEVICE_BUS_ACTIVITY:
// enable suspend interrupt
udc_all_interrupts (device);
break;
case DEVICE_POWER_INTERRUPTION:
break;
case DEVICE_HUB_RESET:
break;
case DEVICE_DESTROY:
udc_disconnect ();
bi_disable_endpoints (device);
udc_disable_interrupts (device);
udc_disable ();
break;
case DEVICE_FUNCTION_PRIVATE:
break;
}
return 0;
}
int ticker_thread (void *data)
{
struct timer_list ticker;
// detach
lock_kernel ();
exit_mm (current);
exit_files (current);
exit_fs (current);
// setsid equivalent, used at start of kernel thread, no error checks needed, or at least none made :).
current->leader = 1;
current->session = current->pgrp = current->pid;
current->tty = NULL;
current->tty_old_pgrp = 0;
// Name this thread
sprintf (current->comm, "usbd-bi");
// setup signal handler
current->exit_signal = SIGCHLD;
spin_lock (¤t->sigmask_lock);
flush_signals (current);
spin_unlock (¤t->sigmask_lock);
// XXX Run at a high priority, ahead of sync and friends
// current->nice = -20;
current->policy = SCHED_OTHER;
unlock_kernel ();
// setup timer
init_timer (&ticker);
ticker.data = 0;
ticker.function = ticker_tick;
// let startup continue
up (&ticker_sem_start);
// process loop
for (ticker_timer_set = ticker_terminating = 0; !ticker_terminating;) {
char buf[100];
char *cp;
if (!ticker_timer_set) {
mod_timer (&ticker, jiffies + HZ * RETRYTIME);
}
// wait for someone to tell us to do something
down (&ticker_sem_work);
if (udc_interrupts != udc_interrupts_last) {
dbg_tick (3, "--------------");
}
// do some work
memset (buf, 0, sizeof (buf));
cp = buf;
if (dbgflg_usbdbi_tick) {
unsigned long flags;
local_irq_save (flags);
dbg_tick (2, "[%d]", udc_interrupts);
udc_regs ();
local_irq_restore (flags);
}
#if 0
// XXX
#if defined(CONFIG_SA1110_CALYPSO) && defined(CONFIG_PM) && defined(CONFIG_USBD_TRAFFIC_KEEPAWAKE)
/* Check for rx/tx activity, and reset the sleep timer if present */
if (device->usbd_rxtx_timestamp != device->usbd_last_rxtx_timestamp) {
extern void resetSleepTimer (void);
dbg_tick (7, "resetting sleep timer");
resetSleepTimer ();
device->usbd_last_rxtx_timestamp = device->usbd_rxtx_timestamp;
}
#endif
#endif
#if 0
/* Check for TX endpoint stall. If the endpoint has
stalled, we have probably run into the DMA/TCP window
problem, and the only thing we can do is disconnect
from the bus, then reconnect (and re-enumerate...). */
if (reconnect > 0 && 0 >= --reconnect) {
dbg_init (0, "TX stall disconnect finished");
udc_connect ();
} else if (0 != USBD_STALL_TIMEOUT_SECONDS) {
// Stall watchdog unleashed
unsigned long now, tx_waiting;
now = jiffies;
tx_waiting = (now - tx_queue_head_timestamp (now)) / HZ;
if (tx_waiting > USBD_STALL_TIMEOUT_SECONDS) {
/* The URB at the head of the queue has waited too long */
reconnect = USBD_STALL_DISCONNECT_DURATION;
dbg_init (0, "TX stalled, disconnecting for %d seconds", reconnect);
udc_disconnect ();
}
}
#endif
}
// remove timer
del_timer (&ticker);
// let the process stopping us know we are done and return
up (&ticker_sem_start);
return 0;
}
void do_bootm_linux (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[],
bootm_headers_t *images)
{
ulong initrd_start, initrd_end;
ulong ep = 0;
bd_t *bd = gd->bd;
char *s;
int machid = bd->bi_arch_number;
void (*theKernel)(int zero, int arch, uint params);
int ret;
#ifdef CONFIG_CMDLINE_TAG
char *commandline = getenv ("bootargs");
#endif
/* find kernel entry point */
if (images->legacy_hdr_valid) {
ep = image_get_ep (&images->legacy_hdr_os_copy);
#if defined(CONFIG_FIT)
} else if (images->fit_uname_os) {
ret = fit_image_get_entry (images->fit_hdr_os,
images->fit_noffset_os, &ep);
if (ret) {
puts ("Can't get entry point property!\n");
goto error;
}
#endif
} else {
puts ("Could not find kernel entry point!\n");
goto error;
}
theKernel = (void (*)(int, int, uint))ep;
s = getenv ("machid");
if (s) {
machid = simple_strtoul (s, NULL, 16);
printf ("Using machid 0x%x from environment\n", machid);
}
ret = boot_get_ramdisk (argc, argv, images, IH_ARCH_ARM,
&initrd_start, &initrd_end);
if (ret)
goto error;
show_boot_progress (15);
debug ("## Transferring control to Linux (at address %08lx) ...\n",
(ulong) theKernel);
#if defined (CONFIG_SETUP_MEMORY_TAGS) || \
defined (CONFIG_CMDLINE_TAG) || \
defined (CONFIG_INITRD_TAG) || \
defined (CONFIG_SERIAL_TAG) || \
defined (CONFIG_REVISION_TAG) || \
defined (CONFIG_LCD) || \
defined (CONFIG_VFD)
setup_start_tag (bd);
#ifdef CONFIG_SERIAL_TAG
setup_serial_tag (¶ms);
#endif
#ifdef CONFIG_REVISION_TAG
setup_revision_tag (¶ms);
#endif
#ifdef CONFIG_SETUP_MEMORY_TAGS
setup_memory_tags (bd);
#endif
#ifdef CONFIG_CMDLINE_TAG
setup_commandline_tag (bd, commandline);
#endif
#ifdef CONFIG_INITRD_TAG
if (initrd_start && initrd_end)
setup_initrd_tag (bd, initrd_start, initrd_end);
#endif
#if defined (CONFIG_VFD) || defined (CONFIG_LCD)
setup_videolfb_tag ((gd_t *) gd);
#endif
setup_end_tag (bd);
#endif
/* we assume that the kernel is in place */
printf ("\nStarting kernel ...\n\n");
#ifdef CONFIG_USB_DEVICE
{
extern void udc_disconnect (void);
udc_disconnect ();
}
#endif
cleanup_before_linux ();
theKernel (0, machid, bd->bi_boot_params);
/* does not return */
return;
error:
do_reset (cmdtp, flag, argc, argv);
return;
}
/* bi_modexit - decommission bus interface driver
*/
void __exit bi_modexit(void)
{
struct usb_bus_instance *bus;
struct usb_device_instance *device;
struct bi_data *data;
dbgENTER(dbgflg_usbdbi_init,1);
if ((device = device_array[0])) {
// XXX moved to usbd_deregister_device()
//device->status = USBD_CLOSING;
udc_disconnect();
udc_disable();
// XXX XXX
if (dbgflg_usbdbi_tick > 0) {
ticker_killoff();
}
bus = device->bus;
data = bus->privdata;
// XXX
usbd_device_event(device, DEVICE_RESET, 0);
usbd_device_event(device, DEVICE_POWER_INTERRUPTION, 0);
usbd_device_event(device, DEVICE_HUB_RESET, 0);
dbg_init(1,"DEVICE_DESTROY");
usbd_device_event(device, DEVICE_DESTROY, 0);
dbg_init(1,"DISABLE ENDPOINTS");
bi_disable_endpoints(device);
dbg_init(1,"UDC_DISABLE");
//udc_disable();
dbg_init(1,"BI_UDC_EXIT");
bi_udc_exit();
device_array[0] = NULL;
bus->privdata = NULL;
#ifdef CONFIG_PM
dbg_init(1,"PM_UNREGISTER(pm_dev#%p)",pm_dev);
if (pm_dev) {
pm_unregister(pm_dev);
}
#endif
dbg_init(1,"DEREGISTER DEVICE");
usbd_deregister_device(device);
bus->device = NULL;
dbg_init(1,"kfree(data#%p)",data);
if (data) {
kfree(data);
}
if (bus->serial_number_str) {
kfree(bus->serial_number_str);
}
dbg_init(1,"DEREGISTER BUS");
usbd_deregister_bus(bus);
}
else {
dbg_init(0,"device is NULL");
}
dbg_init(1,"BI_EXIT");
bi_exit();
dbgLEAVE(dbgflg_usbdbi_init,1);
}
void do_bootm_linux (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[],
ulong addr, ulong *len_ptr, int verify)
{
ulong len = 0, checksum;
ulong initrd_start, initrd_end;
ulong data;
void (*theKernel)(int zero, int arch, uint params);
image_header_t *hdr = &header;
bd_t *bd = gd->bd;
#ifdef CONFIG_CMDLINE_TAG
char *commandline = getenv ("bootargs");
#endif
theKernel = (void (*)(int, int, uint))ntohl(hdr->ih_ep);
/*
* Check if there is an initrd image
*/
if (argc >= 3) {
SHOW_BOOT_PROGRESS (9);
addr = simple_strtoul (argv[2], NULL, 16);
printf ("## Loading Ramdisk Image at %08lx ...\n", addr);
/* Copy header so we can blank CRC field for re-calculation */
#ifdef CONFIG_HAS_DATAFLASH
if (addr_dataflash (addr)) {
read_dataflash (addr, sizeof (image_header_t),
(char *) &header);
} else
#endif
memcpy (&header, (char *) addr,
sizeof (image_header_t));
if (ntohl (hdr->ih_magic) != IH_MAGIC) {
printf ("Bad Magic Number\n");
SHOW_BOOT_PROGRESS (-10);
do_reset (cmdtp, flag, argc, argv);
}
data = (ulong) & header;
len = sizeof (image_header_t);
checksum = ntohl (hdr->ih_hcrc);
hdr->ih_hcrc = 0;
if (crc32 (0, (unsigned char *) data, len) != checksum) {
printf ("Bad Header Checksum\n");
SHOW_BOOT_PROGRESS (-11);
do_reset (cmdtp, flag, argc, argv);
}
SHOW_BOOT_PROGRESS (10);
print_image_hdr (hdr);
data = addr + sizeof (image_header_t);
len = ntohl (hdr->ih_size);
#ifdef CONFIG_HAS_DATAFLASH
if (addr_dataflash (addr)) {
read_dataflash (data, len, (char *) CFG_LOAD_ADDR);
data = CFG_LOAD_ADDR;
}
#endif
if (verify) {
ulong csum = 0;
printf (" Verifying Checksum ... ");
csum = crc32 (0, (unsigned char *) data, len);
if (csum != ntohl (hdr->ih_dcrc)) {
printf ("Bad Data CRC\n");
SHOW_BOOT_PROGRESS (-12);
do_reset (cmdtp, flag, argc, argv);
}
printf ("OK\n");
}
SHOW_BOOT_PROGRESS (11);
if ((hdr->ih_os != IH_OS_LINUX) ||
(hdr->ih_arch != IH_CPU_ARM) ||
(hdr->ih_type != IH_TYPE_RAMDISK)) {
printf ("No Linux ARM Ramdisk Image\n");
SHOW_BOOT_PROGRESS (-13);
do_reset (cmdtp, flag, argc, argv);
}
#if defined(CONFIG_B2) || defined(CONFIG_EVB4510) || defined(CONFIG_ARMADILLO)
/*
*we need to copy the ramdisk to SRAM to let Linux boot
*/
memmove ((void *) ntohl(hdr->ih_load), (uchar *)data, len);
data = ntohl(hdr->ih_load);
#endif /* CONFIG_B2 || CONFIG_EVB4510 */
/*
* Now check if we have a multifile image
*/
} else if ((hdr->ih_type == IH_TYPE_MULTI) && (len_ptr[1])) {
ulong tail = ntohl (len_ptr[0]) % 4;
int i;
SHOW_BOOT_PROGRESS (13);
/* skip kernel length and terminator */
data = (ulong) (&len_ptr[2]);
/* skip any additional image length fields */
for (i = 1; len_ptr[i]; ++i)
data += 4;
/* add kernel length, and align */
data += ntohl (len_ptr[0]);
if (tail) {
data += 4 - tail;
}
len = ntohl (len_ptr[1]);
} else {
/*
* no initrd image
*/
SHOW_BOOT_PROGRESS (14);
len = data = 0;
}
#ifdef DEBUG
if (!data) {
printf ("No initrd\n");
}
#endif
if (data) {
initrd_start = data;
initrd_end = initrd_start + len;
} else {
initrd_start = 0;
initrd_end = 0;
}
SHOW_BOOT_PROGRESS (15);
debug ("## Transferring control to Linux (at address %08lx) ...\n",
(ulong) theKernel);
#if defined (CONFIG_SETUP_MEMORY_TAGS) || \
defined (CONFIG_CMDLINE_TAG) || \
defined (CONFIG_INITRD_TAG) || \
defined (CONFIG_SERIAL_TAG) || \
defined (CONFIG_REVISION_TAG) || \
defined (CONFIG_LCD) || \
defined (CONFIG_VFD)
setup_start_tag (bd);
#ifdef CONFIG_SERIAL_TAG
setup_serial_tag (¶ms);
#endif
#ifdef CONFIG_REVISION_TAG
setup_revision_tag (¶ms);
#endif
#ifdef CONFIG_SETUP_MEMORY_TAGS
setup_memory_tags (bd);
#endif
#ifdef CONFIG_CMDLINE_TAG
setup_commandline_tag (bd, commandline);
#endif
#ifdef CONFIG_INITRD_TAG
if (initrd_start && initrd_end)
setup_initrd_tag (bd, initrd_start, initrd_end);
#endif
#if defined (CONFIG_VFD) || defined (CONFIG_LCD)
setup_videolfb_tag ((gd_t *) gd);
#endif
setup_modelid_tag(¶ms);
setup_cpuid_tag(¶ms);
setup_end_tag (bd);
#endif
/* we assume that the kernel is in place */
printf ("\nStarting kernel ...\n\n");
#ifdef CONFIG_USB_DEVICE
{
extern void udc_disconnect (void);
udc_disconnect ();
}
#endif
cleanup_before_linux ();
theKernel (0, bd->bi_arch_number, bd->bi_boot_params);
}
int do_bootm_linux(int flag, int argc, char *argv[], bootm_headers_t *images)
{
bd_t *bd = gd->bd;
char *s;
int machid = bd->bi_arch_number;
void (*theKernel)(int zero, int arch, uint params);
#ifdef CONFIG_CMDLINE_TAG
char *commandline = getenv ("bootargs");
#if !CONFIG_MFG
#if defined(CONFIG_MX53_BEJ) || defined(CONFIG_MX53_BEJ2)
extern char key_status_at_startup[6];
extern char *mx53_bej_boot_version;
extern int kernel_dev;
char *autorun,*serialno,*macaddr,*testkey;
char kpp[16],ver[32],buff[1024];
strncpy(buff,commandline,sizeof(buff));
buff[(sizeof(buff)/sizeof(buff[0]))-1]='\0';
#ifdef CONFIG_SDTEST
if((testkey=getenv("testkey")) != NULL){
strncat(buff," kpp=",sizeof(buff));
strncat(buff,testkey,sizeof(buff));
}
else
{
strncat(buff," kpp=M_R-_",sizeof(buff));
}
// printf(" %s\n",buff);
#else
sprintf(kpp," kpp=%s",key_status_at_startup);
strncat(buff,kpp,sizeof(buff));
printf(kpp);
#endif
puts("\n");
sprintf(ver," bootVer=%s",mx53_bej_boot_version);
strncat(buff,ver,sizeof(buff));
printf(ver);
puts("\n");
if(autorun=getenv("autorun")){
strncat(buff," autorun=\"",sizeof(buff));
strncat(buff,autorun,sizeof(buff));
strncat(buff,"\"",sizeof(buff));
printf(" autorun=\"%s\"\n",autorun);
}
switch(kernel_dev){
case 10:
strncat(buff," kernelfrom=eMMC",sizeof(buff));
printf(" kernelfrom=eMMC\n");
break;
case 20:
#ifdef CONFIG_SDTEST
strncat(buff," kernelfrom=SDcard_test",sizeof(buff));
printf(" kernelfrom=SDcard_test\n");
#else
strncat(buff," kernelfrom=SDcard",sizeof(buff));
printf(" kernelfrom=SDcard\n");
#endif
break;
}
if(macaddr=getenv("macaddr"))
{
strncat(buff," macaddr=",sizeof(buff));
strncat(buff,macaddr,sizeof(buff));
printf(" macaddr=%s\n",macaddr);
}
if(serialno=getenv("serialno"))
{
strncat(buff," androidboot.serialno=",sizeof(buff));
strncat(buff,serialno,sizeof(buff));
printf(" serialno=%s\n",serialno);
}
commandline=buff;
#endif
#endif
#endif
if ((flag != 0) && (flag != BOOTM_STATE_OS_GO))
return 1;
theKernel = (void (*)(int, int, uint))images->ep;
s = getenv ("machid");
if (s) {
machid = simple_strtoul (s, NULL, 16);
printf ("Using machid 0x%x from environment\n", machid);
}
show_boot_progress (15);
debug ("## Transferring control to Linux (at address %08lx) ...\n",
(ulong) theKernel);
#if defined (CONFIG_SETUP_MEMORY_TAGS) || \
defined (CONFIG_CMDLINE_TAG) || \
defined (CONFIG_INITRD_TAG) || \
defined (CONFIG_SERIAL_TAG) || \
defined (CONFIG_REVISION_TAG) || \
defined (CONFIG_LCD) || \
defined (CONFIG_VFD)
setup_start_tag (bd);
#ifdef CONFIG_SERIAL_TAG
setup_serial_tag (¶ms);
#endif
#ifdef CONFIG_REVISION_TAG
setup_revision_tag (¶ms);
#endif
#ifdef CONFIG_SETUP_MEMORY_TAGS
setup_memory_tags (bd);
#endif
#ifdef CONFIG_CMDLINE_TAG
setup_commandline_tag (bd, commandline);
#endif
#ifdef CONFIG_INITRD_TAG
if (images->rd_start && images->rd_end)
setup_initrd_tag (bd, images->rd_start, images->rd_end);
#endif
#if defined (CONFIG_VFD) || defined (CONFIG_LCD)
setup_videolfb_tag ((gd_t *) gd);
#endif
setup_end_tag (bd);
#endif
/* we assume that the kernel is in place */
printf ("\nStarting kernel ...\n\n");
#ifdef CONFIG_USB_DEVICE
{
extern void udc_disconnect (void);
udc_disconnect ();
}
#endif
cleanup_before_linux ();
theKernel (0, machid, bd->bi_boot_params);
/* does not return */
return 1;
}
