static int atomisp_pci_probe(struct pci_dev *dev,
const struct pci_device_id *id)
{
const struct atomisp_platform_data *pdata;
struct atomisp_device *isp;
unsigned int start;
void __iomem *base;
int err;
if (!dev) {
dev_err(&dev->dev, "atomisp: error device ptr\n");
return -EINVAL;
}
atomisp_pci_vendor = id->vendor;
atomisp_pci_device = id->device;
pdata = atomisp_get_platform_data();
if (pdata == NULL) {
dev_err(&dev->dev, "no platform data available\n");
return -ENODEV;
}
err = pcim_enable_device(dev);
if (err) {
dev_err(&dev->dev, "Failed to enable CI ISP device (%d)\n",
err);
return err;
}
start = pci_resource_start(dev, ATOM_ISP_PCI_BAR);
v4l2_dbg(1, dbg_level, &atomisp_dev, "start: 0x%x\n", start);
err = pcim_iomap_regions(dev, 1 << ATOM_ISP_PCI_BAR, pci_name(dev));
if (err) {
dev_err(&dev->dev, "Failed to I/O memory remapping (%d)\n",
err);
return err;
}
base = pcim_iomap_table(dev)[ATOM_ISP_PCI_BAR];
v4l2_dbg(1, dbg_level, &atomisp_dev, "base: %p\n", base);
atomisp_io_base = base;
v4l2_dbg(1, dbg_level, &atomisp_dev, "atomisp_io_base: %p\n",
atomisp_io_base);
isp = devm_kzalloc(&dev->dev, sizeof(struct atomisp_device), GFP_KERNEL);
if (!isp) {
dev_err(&dev->dev, "Failed to alloc CI ISP structure\n");
return -ENOMEM;
}
isp->pdev = dev;
isp->dev = &dev->dev;
isp->sw_contex.power_state = ATOM_ISP_POWER_UP;
isp->pci_root = pci_get_bus_and_slot(0, 0);
if (!isp->pci_root) {
dev_err(&dev->dev, "Unable to find PCI host\n");
return -ENODEV;
}
isp->saved_regs.ispmmadr = start;
mutex_init(&isp->mutex);
mutex_init(&isp->streamoff_mutex);
spin_lock_init(&isp->lock);
init_completion(&isp->init_done);
isp->media_dev.driver_version = ATOMISP_CSS_VERSION_20;
switch (id->device & ATOMISP_PCI_DEVICE_SOC_MASK) {
case ATOMISP_PCI_DEVICE_SOC_MRFLD:
case ATOMISP_PCI_DEVICE_SOC_BYT:
isp->media_dev.hw_revision =
(ATOMISP_HW_REVISION_ISP2400
<< ATOMISP_HW_REVISION_SHIFT) |
#ifdef CONFIG_ISP2400
ATOMISP_HW_STEPPING_A0;
#else
ATOMISP_HW_STEPPING_B0;
#endif
break;
default:
/* Medfield and Clovertrail. */
isp->media_dev.hw_revision =
(ATOMISP_HW_REVISION_ISP2300
<< ATOMISP_HW_REVISION_SHIFT) |
(dev->revision < 0x09 ?
ATOMISP_HW_STEPPING_A0 : ATOMISP_HW_STEPPING_B0);
}
isp->max_isr_latency = ATOMISP_MAX_ISR_LATENCY;
if ((pdata->spid->platform_family_id == INTEL_CLVTP_PHONE ||
pdata->spid->platform_family_id == INTEL_CLVT_TABLET) &&
isp->pdev->revision < 0x09) {
/* Workaround for Cloverview(+) older than stepping B0 */
isp->max_isr_latency = CSTATE_EXIT_LATENCY_C1;
}
/* Load isp firmware from user space */
isp->firmware = load_firmware(&dev->dev);
if (!isp->firmware) {
err = -ENOENT;
dev_err(&dev->dev, "Load firmwares failed\n");
goto load_fw_fail;
}
isp->wdt_work_queue = alloc_workqueue(isp->v4l2_dev.name, 0, 1);
if (isp->wdt_work_queue == NULL) {
dev_err(&dev->dev, "Failed to initialize wdt work queue\n");
err = -ENOMEM;
goto wdt_work_queue_fail;
}
INIT_WORK(&isp->wdt_work, atomisp_wdt_work);
isp->delayed_init_workq =
alloc_workqueue(isp->v4l2_dev.name, WQ_CPU_INTENSIVE, 1);
if (isp->delayed_init_workq == NULL) {
dev_err(&dev->dev, "Failed to initialize delayed init workq\n");
err = -ENOMEM;
goto delayed_init_work_queue_fail;
}
INIT_WORK(&isp->delayed_init_work, atomisp_delayed_init_work);
pci_set_master(dev);
pci_set_drvdata(dev, isp);
err = pci_enable_msi(dev);
if (err) {
dev_err(&dev->dev, "Failed to enable msi (%d)\n", err);
goto enable_msi_fail;
}
err = devm_request_threaded_irq(&dev->dev, dev->irq,
atomisp_isr, atomisp_isr_thread,
IRQF_SHARED, "isp_irq", isp);
if (err) {
dev_err(&dev->dev, "Failed to request irq (%d)\n", err);
goto enable_msi_fail;
}
setup_timer(&isp->wdt, atomisp_wdt, (unsigned long)isp);
atomisp_msi_irq_init(isp, dev);
pm_qos_add_request(&isp->pm_qos, PM_QOS_CPU_DMA_LATENCY,
PM_QOS_DEFAULT_VALUE);
if (IS_ISP2400) {
u32 reg32;
/*
* for MRFLD, Software/firmware needs to write a 1 to bit 0 of
* the register at CSI_RECEIVER_SELECTION_REG to enable SH CSI
* backend write 0 will enable Arasan CSI backend, which has
* bugs(like sighting:4567697 and 4567699) and will be removed
* in B0
*/
atomisp_css2_hw_store_32(MRFLD_CSI_RECEIVER_SELECTION_REG, 1);
pci_read_config_dword(dev, PCI_I_CONTROL, ®32);
reg32 |= MRFLD_PCI_I_CONTROL_ENABLE_READ_COMBINING
| MRFLD_PCI_I_CONTROL_ENABLE_WRITE_COMBINING;
pci_write_config_dword(dev, PCI_I_CONTROL, reg32);
}
err = atomisp_initialize_modules(isp);
if (err < 0) {
dev_err(&dev->dev, "atomisp_initialize_modules (%d)\n", err);
goto enable_msi_fail;
}
err = atomisp_register_entities(isp);
if (err < 0) {
dev_err(&dev->dev, "atomisp_register_entities failed (%d)\n",
err);
goto enable_msi_fail;
}
atomisp_acc_init(isp);
/* save the iunit context only once after all the values are init'ed. */
atomisp_save_iunit_reg(isp);
pm_runtime_put_noidle(&dev->dev);
pm_runtime_allow(&dev->dev);
err = hmm_pool_register(repool_pgnr, HMM_POOL_TYPE_RESERVED);
if (err)
dev_err(&dev->dev, "Failed to register reserved memory pool.\n");
return 0;
enable_msi_fail:
destroy_workqueue(isp->delayed_init_workq);
delayed_init_work_queue_fail:
destroy_workqueue(isp->wdt_work_queue);
wdt_work_queue_fail:
release_firmware(isp->firmware);
load_fw_fail:
pci_dev_put(isp->pci_root);
return err;
}
static int psfreedom_bind(struct usb_gadget *gadget)
{
struct psfreedom_device *dev;
int err = 0;
dev = kzalloc(sizeof(*dev), GFP_KERNEL);
if (!dev) {
return -ENOMEM;
}
spin_lock_init(&dev->lock);
usb_gadget_set_selfpowered (gadget);
dev->gadget = gadget;
set_gadget_data(gadget, dev);
INFO(dev, "%s, version: " PSFREEDOM_VERSION " - " DRIVER_VERSION "\n",
longname);
load_firmware (dev, supported_firmwares[0].version);
/* preallocate control response and buffer */
dev->req = alloc_ep_req(gadget->ep0,
max (sizeof (port3_config_desc),
dev->port1_config_desc_size) + USB_BUFSIZ);
if (!dev->req) {
err = -ENOMEM;
goto fail;
}
dev->req->complete = psfreedom_setup_complete;
gadget->ep0->driver_data = dev;
/* Bind the hub and devices */
err = hub_bind (gadget, dev);
if (err < 0)
goto fail;
err = devices_bind (gadget, dev);
if (err < 0)
goto fail;
DBG(dev, "psfreedom_bind finished ok\n");
setup_timer(&psfreedom_state_machine_timer, psfreedom_state_machine_timeout,
(unsigned long) gadget);
psfreedom_disconnect (gadget);
/* Create the /proc filesystem */
dev->proc_dir = proc_mkdir (PROC_DIR_NAME, NULL);
if (dev->proc_dir) {
printk(KERN_INFO "/proc/%s/ created\n", PROC_DIR_NAME);
create_proc_fs (dev, &dev->proc_status_entry,
PROC_STATUS_NAME, proc_status_read, NULL);
create_proc_fs (dev, &dev->proc_version_entry,
PROC_VERSION_NAME, proc_version_read, NULL);
create_proc_fs (dev, &dev->proc_payload_entry,
PROC_PAYLOAD_NAME, proc_payload_read, proc_payload_write);
create_proc_fs (dev, &dev->proc_shellcode_entry,
PROC_SHELLCODE_NAME, proc_shellcode_read, proc_shellcode_write);
create_proc_fs (dev, &dev->proc_supported_firmwares_entry,
PROC_SUPPORTED_FIRMWARES_NAME, proc_supported_firmwares_read, NULL);
create_proc_fs (dev, &dev->proc_fw_version_entry,
PROC_FW_VERSION_NAME, proc_fw_version_read, proc_fw_version_write);
create_proc_fs (dev, &dev->proc_stage2_entry,
PROC_STAGE2_NAME, NULL, proc_stage2_write);
/* that's it for now..*/
}
/* By default don't use asbestos */
dev->stage2_payload = NULL;
dev->stage2_payload_size = 0;
return 0;
fail:
psfreedom_unbind(gadget);
return err;
}
static int __devinit atomisp_pci_probe(struct pci_dev *dev,
const struct pci_device_id *id)
{
struct atomisp_device *isp = NULL;
unsigned int start, len;
void __iomem *base = NULL;
int err = 0;
if (!dev) {
v4l2_err(&atomisp_dev, "atomisp: erorr device ptr\n");
return -EINVAL;
}
atomisp_pci_vendor = id->vendor;
atomisp_pci_device = id->device;
err = pci_enable_device(dev);
if (err) {
v4l2_err(&atomisp_dev,
"Failed to enable CI ISP device\n");
return err;
}
start = pci_resource_start(dev, 0);
len = pci_resource_len(dev, 0);
err = pci_request_region(dev, 0, atomisp_pci_driver.name);
if (err) {
v4l2_err(&atomisp_dev,
"Failed to request region 0x%1x-0x%Lx\n",
start, (unsigned long long)pci_resource_end(dev,
0));
goto request_region_fail;
}
base = ioremap_nocache(start, len);
if (!base) {
v4l2_err(&atomisp_dev,
"Failed to I/O memory remapping\n");
err = -ENOMEM;
goto ioremap_fail;
}
isp = kzalloc(sizeof(struct atomisp_device), GFP_KERNEL);
if (!isp) {
v4l2_err(&atomisp_dev, "Failed to alloc CI ISP structure\n");
goto kzalloc_fail;
}
isp->sw_contex.probed = false;
isp->sw_contex.init = false;
isp->pdev = dev;
isp->dev = &dev->dev;
isp->sw_contex.power_state = ATOM_ISP_POWER_UP;
isp->hw_contex.pci_root = pci_get_bus_and_slot(0, 0);
/* Load isp firmware from user space */
/*
* fixing me:
* MRFLD VP does not use firmware loading
* from file system
*/
if (!IS_MRFLD) {
isp->firmware = load_firmware(&dev->dev);
if (!isp->firmware) {
v4l2_err(&atomisp_dev, "Load firmwares failed\n");
goto load_fw_fail;
}
}
err = atomisp_initialize_modules(isp);
if (err < 0) {
v4l2_err(&atomisp_dev, "atomisp_initialize_modules\n");
goto init_mod_fail;
}
err = atomisp_register_entities(isp);
if (err < 0) {
v4l2_err(&atomisp_dev, "atomisp_register_entities failed\n");
goto init_mod_fail;
}
init_completion(&isp->wq_frame_complete);
init_completion(&isp->dis_state_complete);
spin_lock_init(&isp->irq_lock);
isp->work_queue = create_singlethread_workqueue(isp->v4l2_dev.name);
if (isp->work_queue == NULL) {
v4l2_err(&atomisp_dev, "Failed to initialize work queue\n");
goto work_queue_fail;
}
INIT_WORK(&isp->work, atomisp_work);
isp->hw_contex.ispmmadr = start;
pci_set_master(dev);
atomisp_io_base = base;
isp->tvnorm = tvnorms;
mutex_init(&isp->input_lock);
/* isp_lock is to protect race access of css functions */
mutex_init(&isp->isp_lock);
isp->sw_contex.updating_uptr = false;
isp->isp3a_stat_ready = false;
pci_set_drvdata(dev, isp);
err = pci_enable_msi(dev);
if (err) {
v4l2_err(&atomisp_dev,
"Failed to enable msi\n");
goto enable_msi_fail;
}
err = request_irq(dev->irq, atomisp_isr,
IRQF_SHARED, "isp_irq", isp);
if (err) {
v4l2_err(&atomisp_dev,
"Failed to request irq\n");
goto request_irq_fail;
}
setup_timer(&isp->wdt, atomisp_wdt_wakeup_dog, (unsigned long)isp);
atomisp_msi_irq_init(isp, dev);
pm_qos_add_request(&isp->pm_qos, PM_QOS_CPU_DMA_LATENCY,
PM_QOS_DEFAULT_VALUE);
/*
* fixing me!
* MRFLD VP does not implement
* PM Core
*/
#ifdef CONFIG_PM
if (!IS_MRFLD) {
pm_runtime_put_noidle(&dev->dev);
pm_runtime_allow(&dev->dev);
}
#endif
isp->sw_contex.probed = true;
err = hmm_pool_register(repool_pgnr, HMM_POOL_TYPE_RESERVED);
if (err)
v4l2_err(&atomisp_dev,
"Failed to register reserved memory pool.\n");
return 0;
request_irq_fail:
pci_disable_msi(dev);
enable_msi_fail:
pci_set_drvdata(dev, NULL);
destroy_workqueue(isp->work_queue);
work_queue_fail:
atomisp_unregister_entities(isp);
init_mod_fail:
release_firmware(isp->firmware);
load_fw_fail:
kfree(isp);
kzalloc_fail:
iounmap(base);
ioremap_fail:
pci_release_region(dev, 0);
request_region_fail:
pci_disable_device(dev);
return err;
}
void main(void)
{
unsigned char* loadbuffer;
int buffer_size;
int rc;
int(*kernel_entry)(void);
/* Make sure interrupts are disabled */
set_irq_level(IRQ_DISABLED);
set_fiq_status(FIQ_DISABLED);
system_init();
kernel_init();
/* Now enable interrupts */
set_irq_level(IRQ_ENABLED);
set_fiq_status(FIQ_ENABLED);
lcd_init();
backlight_init();
font_init();
button_init();
usb_init();
power_init();
// enable_irq();
// enable_fiq();
adc_init();
lcd_setfont(FONT_SYSFIXED);
/* Show debug messages if button is pressed */
// if(button_read_device())
verbose = true;
printf("Rockbox boot loader");
printf("Version %s", rbversion);
/* Enter USB mode without USB thread */
if(usb_detect() == USB_INSERTED)
{
const char msg[] = "Bootloader USB mode";
reset_screen();
lcd_putsxy( (LCD_WIDTH - (SYSFONT_WIDTH * strlen(msg))) / 2,
(LCD_HEIGHT - SYSFONT_HEIGHT) / 2, msg);
lcd_update();
ide_power_enable(true);
storage_enable(false);
sleep(HZ/20);
usb_enable(true);
while (usb_detect() == USB_INSERTED)
{
storage_spin(); /* Prevent the drive from spinning down */
sleep(HZ);
}
usb_enable(false);
reset_screen();
lcd_update();
}
sleep(50);
printf("ATA");
rc = storage_init();
if(rc)
{
reset_screen();
error(EATA, rc, true);
}
printf("filesystem");
filesystem_init();
printf("mount");
rc = disk_mount_all();
if (rc<=0)
{
error(EDISK,rc, true);
}
printf("Loading firmware");
loadbuffer = (unsigned char*) 0x00900000;
buffer_size = (unsigned char*)0x01900000 - loadbuffer;
rc = load_firmware(loadbuffer, BOOTFILE, buffer_size);
if(rc <= EFILE_EMPTY)
error(EBOOTFILE, rc, true);
kernel_entry = (void*) loadbuffer;
rc = kernel_entry();
/* Should not get here! */
return rc;
}
int main(void)
{
unsigned char* loadbuffer;
int buffer_size;
int rc;
int(*kernel_entry)(void);
led_init();
clear_leds(LED_ALL);
/* NB: something in system_init() prevents H-JTAG from downloading */
/* system_init(); */
kernel_init();
/* enable_interrupt(IRQ_FIQ_STATUS); */
backlight_init();
lcd_init();
lcd_setfont(FONT_SYSFIXED);
button_init();
dma_init();
uart_init();
uart_init_device(DEBUG_UART_PORT);
/* mini2440_test(); */
/* Show debug messages if button is pressed */
int touch_data;
if(button_read_device(&touch_data) & BUTTON_MENU)
verbose = true;
printf("Rockbox boot loader");
printf("Version " RBVERSION);
rc = storage_init();
if(rc)
{
reset_screen();
error(EATA, rc, true);
}
disk_init(IF_MD(0));
rc = disk_mount_all();
if (rc<=0)
{
error(EDISK,rc, true);
}
printf("Loading firmware");
/* Flush out anything pending first */
commit_discard_idcache();
loadbuffer = (unsigned char*) 0x31000000;
buffer_size = (unsigned char*)0x31400000 - loadbuffer;
rc = load_firmware(loadbuffer, BOOTFILE, buffer_size);
if(rc <= 0)
error(EBOOTFILE, rc, true);
printf("Loaded firmware %d\n", rc);
/* storage_close(); */
system_prepare_fw_start();
commit_discard_idcache();
kernel_entry = (void*) loadbuffer;
rc = kernel_entry();
/* end stop - should not get here */
led_flash(LED_ALL, LED_NONE);
while (1); /* avoid warning */
}
void main(void)
{
unsigned char* loadbuffer;
int buffer_size;
int rc;
int(*kernel_entry)(void);
system_init();
kernel_init(); /* Need the kernel to sleep */
enable_interrupt(IRQ_FIQ_STATUS);
lcd_init();
backlight_init();
button_init();
font_init();
adc_init();
lcd_setfont(FONT_SYSFIXED);
/* These checks should only run if the bootloader is flashed */
if(GSTATUS3&0x02)
{
GSTATUS3&=0xFFFFFFFD;
if(!(GPGDAT&BUTTON_POWER) && charger_inserted())
{
while(!(GPGDAT&BUTTON_POWER) && charger_inserted())
{
char msg[20];
if(charging_state())
{
snprintf(msg,sizeof(msg),"Charging");
}
else
{
snprintf(msg,sizeof(msg),"Charge Complete");
}
reset_screen();
lcd_putsxy( (LCD_WIDTH - (SYSFONT_WIDTH * strlen(msg))) / 2,
(LCD_HEIGHT - SYSFONT_HEIGHT) / 2, msg);
lcd_update();
#if defined(HAVE_RTC_ALARM)
/* Check if the alarm went off while charging */
if(rtc_check_alarm_flag())
{
GSTATUS3=1; /* Normally this is set in crt0.s */
break;
}
#endif
}
if(!(GPGDAT&BUTTON_POWER)
#if defined(HAVE_RTC_ALARM)
&& !GSTATUS3
#endif
)
{
shutdown();
}
}
if(button_hold())
{
const char msg[] = "HOLD is enabled";
reset_screen();
lcd_putsxy( (LCD_WIDTH - (SYSFONT_WIDTH * strlen(msg))) / 2,
(LCD_HEIGHT - SYSFONT_HEIGHT) / 2, msg);
lcd_update();
sleep(2*HZ);
shutdown();
}
}
power_init();
usb_init();
/* Enter USB mode without USB thread */
if(usb_detect() == USB_INSERTED)
{
const char msg[] = "Bootloader USB mode";
reset_screen();
lcd_putsxy( (LCD_WIDTH - (SYSFONT_WIDTH * strlen(msg))) / 2,
(LCD_HEIGHT - SYSFONT_HEIGHT) / 2, msg);
lcd_update();
storage_enable(false);
sleep(HZ/20);
usb_enable(true);
while (usb_detect() == USB_INSERTED)
sleep(HZ);
usb_enable(false);
reset_screen();
lcd_update();
}
reset_screen();
/* Show debug messages if button is pressed */
if(button_read_device()&BUTTON_A)
verbose = true;
printf("Rockbox boot loader");
printf("Version %s", rbversion);
sleep(50); /* ATA seems to error without this pause */
rc = storage_init();
if(rc)
{
reset_screen();
error(EATA, rc, true);
}
filesystem_init();
rc = disk_mount_all();
if (rc<=0)
{
error(EDISK, rc, true);
}
printf("Loading firmware");
/* Flush out anything pending first */
commit_discard_idcache();
loadbuffer = (unsigned char*) 0x31000000;
buffer_size = (unsigned char*)0x31400000 - loadbuffer;
rc = load_firmware(loadbuffer, BOOTFILE, buffer_size);
if(rc <= EFILE_EMPTY)
error(EBOOTFILE, rc, true);
storage_close();
system_prepare_fw_start();
commit_discard_idcache();
kernel_entry = (void*) loadbuffer;
rc = kernel_entry();
#if 0
/* Halt */
while (1)
core_idle();
#else
/* Return and restart */
#endif
}
// enable PWM
static bool PWM_enable(int channel, const char *pin_name) {
if (NULL != pwm[channel].name) {
return true; // already configured
}
// find slots and ocp paths
if (!load_firmware(pin_name)) {
return false; // failed
}
// wait a bit for the pwm device to appear.
// is this long enough or should the whole code below be in a retry loop?
usleep(10000);
char *config = malloc(CONST_STRLEN(OCP_PWM_PREFIX)
+ strlen(pin_name)
+ sizeof((char)('\0')));
if (NULL == config) {
return false; // failed
}
strcpy(config, OCP_PWM_PREFIX);
strcat(config, pin_name);
size_t length = strlen(config);
// find pwm path
DIR *dir = opendir(ocp);
if (NULL == dir) {
goto done; // failed
}
struct dirent *dp;
while (NULL != (dp = readdir(dir))) {
if (0 == strncmp(dp->d_name, config, length)) {
pwm[channel].name = malloc(strlen(ocp)
+ sizeof((char)('/'))
+ strlen(dp->d_name) + CONST_STRLEN(DUTY)
+ sizeof((char)('\0')));
if (NULL == pwm[channel].name) {
break; // failed
}
strcpy(pwm[channel].name, ocp);
strcat(pwm[channel].name, "/");
strcat(pwm[channel].name, dp->d_name);
strcat(pwm[channel].name, DUTY);
// wait up to 5 seconds for the pwm driver to appear.
// is the device tree populated in the background?
for (int i = 0; i < 500; ++i) {
pwm[channel].fd = open(pwm[channel].name, O_RDWR);
if (pwm[channel].fd >= 0) {
break;
}
usleep(10000);
}
if (pwm[channel].fd < 0) {
fprintf(stderr, "PWM failed to appear\n"); fflush(stderr);
free(pwm[channel].name);
pwm[channel].name = NULL;
break; // failed
}
// set duty = zero
lseek(pwm[channel].fd, 0, SEEK_SET);
write(pwm[channel].fd, "0\n", 2);
char buffer[4096];
// set zero duty => zero output
strcpy(buffer, ocp);
strcat(buffer, "/");
strcat(buffer, dp->d_name);
strcat(buffer, POLARITY);
int fd = open(buffer, O_WRONLY);
write(fd, "0\n", 2);
close(fd);
// read and save period?
// ???currently seems to be fixed to 500000
pwm[channel].period = 500000;
// start
strcpy(buffer, ocp);
strcat(buffer, "/");
strcat(buffer, dp->d_name);
strcat(buffer, RUN);
fd = open(buffer, O_WRONLY);
write(fd, "1\n", 2);
close(fd);
break;
}
}
closedir(dir);
done:
free(config);
return NULL != pwm[channel].name;
}
void* main(void)
{
#ifdef TCCBOOT
int rc;
unsigned char* loadbuffer = (unsigned char*)LOAD_ADDRESS;
#endif
system_init();
power_init();
kernel_init();
enable_irq();
lcd_init();
adc_init();
button_init();
backlight_init();
font_init();
lcd_setfont(FONT_SYSFIXED);
show_logo();
_backlight_on();
/* Only load the firmware if TCCBOOT is defined - this ensures SDRAM_START is
available for loading the firmware. Otherwise display the debug screen. */
#ifdef TCCBOOT
printf("Rockbox boot loader");
printf("Version " RBVERSION);
printf("ATA");
rc = storage_init();
if(rc)
{
reset_screen();
error(EATA, rc, true);
}
printf("mount");
rc = disk_mount_all();
if (rc<=0)
{
error(EDISK,rc, true);
}
rc = load_firmware(loadbuffer, BOOTFILE, MAX_LOAD_SIZE);
if (rc <= EFILE_EMPTY)
{
error(EBOOTFILE,rc, true);
}
else
{
int(*kernel_entry)(void) = (void *) loadbuffer;
disable_irq();
rc = kernel_entry();
}
panicf("Boot failed!");
#else
show_debug_screen();
#endif
return 0;
}
void* main(void)
{
char buf[256];
int i;
int btn;
int rc;
bool haveramos;
bool button_was_held;
struct partinfo* pinfo;
unsigned short* identify_info;
/* Check the button hold status as soon as possible - to
give the user maximum chance to turn it off in order to
reset the settings in rockbox. */
button_was_held = button_hold();
system_init();
kernel_init();
#ifndef HAVE_BACKLIGHT_INVERSION
backlight_init(); /* Turns on the backlight */
#endif
lcd_init();
font_init();
#ifdef HAVE_LCD_COLOR
lcd_set_foreground(LCD_WHITE);
lcd_set_background(LCD_BLACK);
lcd_clear_display();
#endif
#if 0
/* ADC and button drivers are not yet implemented */
adc_init();
button_init();
#endif
btn=key_pressed();
/* Enable bootloader messages */
if (btn==BUTTON_RIGHT)
verbose = true;
lcd_setfont(FONT_SYSFIXED);
printf("Rockbox boot loader");
printf("Version: " RBVERSION);
printf("IPOD version: 0x%08x", IPOD_HW_REVISION);
i=ata_init();
if (i==0) {
identify_info=ata_get_identify();
/* Show model */
for (i=0; i < 20; i++) {
((unsigned short*)buf)[i]=htobe16(identify_info[i+27]);
}
buf[40]=0;
for (i=39; i && buf[i]==' '; i--) {
buf[i]=0;
}
printf(buf);
} else {
printf("ATA: %d", i);
}
disk_init();
rc = disk_mount_all();
if (rc<=0)
{
printf("No partition found");
fatal_error();
}
pinfo = disk_partinfo(1);
printf("Partition 1: 0x%02x %ld sectors",
pinfo->type, pinfo->size);
if (button_was_held || (btn==BUTTON_MENU)) {
/* If either the hold switch was on, or the Menu button was held, then
try the Apple firmware */
printf("Loading original firmware...");
/* First try an apple_os.ipod file on the FAT32 partition
(either in .rockbox or the root)
*/
rc=load_firmware(loadbuffer, "apple_os.ipod", MAX_LOADSIZE);
if (rc > 0) {
printf("apple_os.ipod loaded.");
return (void*)DRAM_START;
} else if (rc == EFILE_NOT_FOUND) {
/* If apple_os.ipod doesn't exist, then check if there is an Apple
firmware image in RAM */
haveramos = (memcmp((void*)(DRAM_START+0x20),"portalplayer",12)==0);
if (haveramos) {
/* We have a copy of the retailos in RAM, lets just run it. */
return (void*)DRAM_START;
}
} else {
printf("Error!");
printf("Can't load apple_os.ipod:");
printf(loader_strerror(rc));
}
/* Everything failed - just loop forever */
printf("No RetailOS detected");
} else if (btn==BUTTON_PLAY) {
printf("Loading Linux...");
rc=load_raw_firmware(loadbuffer, "/linux.bin", MAX_LOADSIZE);
if (rc <= EFILE_EMPTY) {
printf("Error!");
printf("Can't load linux.bin:");
printf(loader_strerror(rc));
} else {
return (void*)DRAM_START;
}
} else {
printf("Loading Rockbox...");
rc=load_firmware(loadbuffer, BOOTFILE, MAX_LOADSIZE);
if (rc > 0) {
printf("Rockbox loaded.");
return (void*)DRAM_START;
} else if (rc == EFILE_NOT_FOUND) {
/* if rockbox.ipod doesn't exist, then check if there is a Rockbox
image in RAM */
haveramos = (memcmp((void*)(DRAM_START+0x20),"Rockbox\1",8)==0);
if (haveramos) {
/* We have a copy of Rockbox in RAM, lets just run it. */
return (void*)DRAM_START;
}
}
printf("Error!");
printf("Can't load " BOOTFILE ": ");
printf(loader_strerror(rc));
}
/* If we get to here, then we haven't been able to load any firmware */
fatal_error();
/* We never get here, but keep gcc happy */
return (void*)0;
}
void main(uint32_t arg, uint32_t addr)
{
unsigned char* loadbuffer;
int buffer_size;
void(*kernel_entry)(void);
int ret;
system_init();
kernel_init();
power_init();
enable_irq();
lcd_init();
lcd_clear_display();
lcd_update();
backlight_init();
button_init();
//button_debug_screen();
printf("Boot version: %s", RBVERSION);
printf("arg=%x addr=%x", arg, addr);
#ifdef SANSA_FUZEPLUS
extern void imx233_mmc_disable_window(void);
if(arg == 0xfee1dead)
{
printf("Disable MMC window.");
imx233_mmc_disable_window();
}
#endif
ret = storage_init();
if(ret < 0)
error(EATA, ret, true);
/* NOTE: allow disk_init and disk_mount_all to fail since we can do USB after.
* We need this order to determine the correct logical sector size */
while(!disk_init(IF_MV(0)))
printf("disk_init failed!");
if((ret = disk_mount_all()) <= 0)
error(EDISK, ret, false);
if(usb_detect() == USB_INSERTED)
usb_mode(HZ);
printf("Loading firmware");
loadbuffer = (unsigned char*)loadaddress;
buffer_size = (int)(loadaddressend - loadaddress);
while((ret = load_firmware(loadbuffer, BOOTFILE, buffer_size)) < 0)
{
error(EBOOTFILE, ret, true);
}
kernel_entry = (void*) loadbuffer;
printf("Executing");
disable_interrupt(IRQ_FIQ_STATUS);
commit_discard_idcache();
kernel_entry();
printf("ERR: Failed to boot");
/* never returns */
while(1) ;
}
