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) ; }