1 /* 2 * (C) Copyright 2000-2009 3 * Wolfgang Denk, DENX Software Engineering, wd@denx.de. 4 * 5 * SPDX-License-Identifier: GPL-2.0+ 6 */ 7 8 #ifndef __COMMON_H_ 9 #define __COMMON_H_ 1 10 11 #ifndef __ASSEMBLY__ /* put C only stuff in this section */ 12 13 typedef unsigned char uchar; 14 typedef volatile unsigned long vu_long; 15 typedef volatile unsigned short vu_short; 16 typedef volatile unsigned char vu_char; 17 18 #include <config.h> 19 #include <asm-offsets.h> 20 #include <linux/bitops.h> 21 #include <linux/types.h> 22 #include <linux/string.h> 23 #include <linux/stringify.h> 24 #include <asm/ptrace.h> 25 #include <stdarg.h> 26 #include <linux/kernel.h> 27 #if defined(CONFIG_PCI) && defined(CONFIG_4xx) 28 #include <pci.h> 29 #endif 30 #if defined(CONFIG_8xx) 31 #include <asm/8xx_immap.h> 32 #if defined(CONFIG_MPC859) || defined(CONFIG_MPC859T) || \ 33 defined(CONFIG_MPC866) || \ 34 defined(CONFIG_MPC866P) 35 # define CONFIG_MPC866_FAMILY 1 36 #elif defined(CONFIG_MPC885) 37 # define CONFIG_MPC885_FAMILY 1 38 #endif 39 #if defined(CONFIG_MPC860) \ 40 || defined(CONFIG_MPC860T) \ 41 || defined(CONFIG_MPC866_FAMILY) \ 42 || defined(CONFIG_MPC885_FAMILY) 43 # define CONFIG_MPC86x 1 44 #endif 45 #elif defined(CONFIG_5xx) 46 #include <asm/5xx_immap.h> 47 #elif defined(CONFIG_MPC5xxx) 48 #include <mpc5xxx.h> 49 #elif defined(CONFIG_MPC512X) 50 #include <asm/immap_512x.h> 51 #elif defined(CONFIG_MPC8260) 52 #if defined(CONFIG_MPC8247) \ 53 || defined(CONFIG_MPC8272) 54 #define CONFIG_MPC8272_FAMILY 1 55 #endif 56 #include <asm/immap_8260.h> 57 #endif 58 #ifdef CONFIG_MPC86xx 59 #include <mpc86xx.h> 60 #include <asm/immap_86xx.h> 61 #endif 62 #ifdef CONFIG_MPC85xx 63 #include <mpc85xx.h> 64 #include <asm/immap_85xx.h> 65 #endif 66 #ifdef CONFIG_MPC83xx 67 #include <mpc83xx.h> 68 #include <asm/immap_83xx.h> 69 #endif 70 #ifdef CONFIG_4xx 71 #include <asm/ppc4xx.h> 72 #endif 73 #ifdef CONFIG_BLACKFIN 74 #include <asm/blackfin.h> 75 #endif 76 #ifdef CONFIG_SOC_DA8XX 77 #include <asm/arch/hardware.h> 78 #endif 79 #ifdef CONFIG_FSL_LSCH3 80 #include <asm/arch/immap_lsch3.h> 81 #endif 82 83 #include <part.h> 84 #include <flash.h> 85 #include <image.h> 86 87 /* Bring in printf format macros if inttypes.h is included */ 88 #define __STDC_FORMAT_MACROS 89 90 #ifdef __LP64__ 91 #define CONFIG_SYS_SUPPORT_64BIT_DATA 92 #endif 93 94 #ifdef DEBUG 95 #define _DEBUG 1 96 #else 97 #define _DEBUG 0 98 #endif 99 100 #ifndef pr_fmt 101 #define pr_fmt(fmt) fmt 102 #endif 103 104 /* 105 * Output a debug text when condition "cond" is met. The "cond" should be 106 * computed by a preprocessor in the best case, allowing for the best 107 * optimization. 108 */ 109 #define debug_cond(cond, fmt, args...) \ 110 do { \ 111 if (cond) \ 112 printf(pr_fmt(fmt), ##args); \ 113 } while (0) 114 115 #define debug(fmt, args...) \ 116 debug_cond(_DEBUG, fmt, ##args) 117 118 /* 119 * An assertion is run-time check done in debug mode only. If DEBUG is not 120 * defined then it is skipped. If DEBUG is defined and the assertion fails, 121 * then it calls panic*( which may or may not reset/halt U-Boot (see 122 * CONFIG_PANIC_HANG), It is hoped that all failing assertions are found 123 * before release, and after release it is hoped that they don't matter. But 124 * in any case these failing assertions cannot be fixed with a reset (which 125 * may just do the same assertion again). 126 */ 127 void __assert_fail(const char *assertion, const char *file, unsigned line, 128 const char *function); 129 #define assert(x) \ 130 ({ if (!(x) && _DEBUG) \ 131 __assert_fail(#x, __FILE__, __LINE__, __func__); }) 132 133 #define error(fmt, args...) do { \ 134 printf("ERROR: " pr_fmt(fmt) "\nat %s:%d/%s()\n", \ 135 ##args, __FILE__, __LINE__, __func__); \ 136 } while (0) 137 138 #ifndef BUG 139 #define BUG() do { \ 140 printf("BUG: failure at %s:%d/%s()!\n", __FILE__, __LINE__, __FUNCTION__); \ 141 panic("BUG!"); \ 142 } while (0) 143 #define BUG_ON(condition) do { if (unlikely((condition)!=0)) BUG(); } while(0) 144 #endif /* BUG */ 145 146 /* Force a compilation error if condition is true */ 147 #define BUILD_BUG_ON(condition) ((void)sizeof(char[1 - 2*!!(condition)])) 148 149 typedef void (interrupt_handler_t)(void *); 150 151 #include <asm/u-boot.h> /* boot information for Linux kernel */ 152 #include <asm/global_data.h> /* global data used for startup functions */ 153 154 /* 155 * enable common handling for all TQM8xxL/M boards: 156 * - CONFIG_TQM8xxM will be defined for all TQM8xxM boards 157 * - CONFIG_TQM8xxL will be defined for all TQM8xxL _and_ TQM8xxM boards 158 * and for the TQM885D board 159 */ 160 #if defined(CONFIG_TQM823M) || defined(CONFIG_TQM850M) || \ 161 defined(CONFIG_TQM855M) || defined(CONFIG_TQM860M) || \ 162 defined(CONFIG_TQM862M) || defined(CONFIG_TQM866M) 163 # ifndef CONFIG_TQM8xxM 164 # define CONFIG_TQM8xxM 165 # endif 166 #endif 167 #if defined(CONFIG_TQM823L) || defined(CONFIG_TQM850L) || \ 168 defined(CONFIG_TQM855L) || defined(CONFIG_TQM860L) || \ 169 defined(CONFIG_TQM862L) || defined(CONFIG_TQM8xxM) || \ 170 defined(CONFIG_TQM885D) 171 # ifndef CONFIG_TQM8xxL 172 # define CONFIG_TQM8xxL 173 # endif 174 #endif 175 176 #if defined(CONFIG_ENV_IS_EMBEDDED) 177 #define TOTAL_MALLOC_LEN CONFIG_SYS_MALLOC_LEN 178 #elif ( ((CONFIG_ENV_ADDR+CONFIG_ENV_SIZE) < CONFIG_SYS_MONITOR_BASE) || \ 179 (CONFIG_ENV_ADDR >= (CONFIG_SYS_MONITOR_BASE + CONFIG_SYS_MONITOR_LEN)) ) || \ 180 defined(CONFIG_ENV_IS_IN_NVRAM) 181 #define TOTAL_MALLOC_LEN (CONFIG_SYS_MALLOC_LEN + CONFIG_ENV_SIZE) 182 #else 183 #define TOTAL_MALLOC_LEN CONFIG_SYS_MALLOC_LEN 184 #endif 185 186 /* 187 * Function Prototypes 188 */ 189 int dram_init(void); 190 191 void hang (void) __attribute__ ((noreturn)); 192 193 int timer_init(void); 194 int cpu_init(void); 195 196 /* */ 197 phys_size_t initdram (int); 198 199 #include <display_options.h> 200 201 /* common/main.c */ 202 void main_loop (void); 203 int run_command(const char *cmd, int flag); 204 int run_command_repeatable(const char *cmd, int flag); 205 206 /** 207 * Run a list of commands separated by ; or even \0 208 * 209 * Note that if 'len' is not -1, then the command does not need to be nul 210 * terminated, Memory will be allocated for the command in that case. 211 * 212 * @param cmd List of commands to run, each separated bu semicolon 213 * @param len Length of commands excluding terminator if known (-1 if not) 214 * @param flag Execution flags (CMD_FLAG_...) 215 * @return 0 on success, or != 0 on error. 216 */ 217 int run_command_list(const char *cmd, int len, int flag); 218 extern char console_buffer[]; 219 220 /* arch/$(ARCH)/lib/board.c */ 221 void board_init_f(ulong); 222 void board_init_r(gd_t *, ulong) __attribute__ ((noreturn)); 223 224 /** 225 * board_init_f_mem() - Allocate global data and set stack position 226 * 227 * This function is called by each architecture very early in the start-up 228 * code to set up the environment for board_init_f(). It allocates space for 229 * global_data (see include/asm-generic/global_data.h) and places the stack 230 * below this. 231 * 232 * This function requires a stack[1] Normally this is at @top. The function 233 * starts allocating space from 64 bytes below @top. First it creates space 234 * for global_data. Then it calls arch_setup_gd() which sets gd to point to 235 * the global_data space and can reserve additional bytes of space if 236 * required). Finally it allocates early malloc() memory 237 * (CONFIG_SYS_MALLOC_F_LEN). The new top of the stack is just below this, 238 * and it returned by this function. 239 * 240 * [1] Strictly speaking it would be possible to implement this function 241 * in C on many archs such that it does not require a stack. However this 242 * does not seem hugely important as only 64 byte are wasted. The 64 bytes 243 * are used to handle the calling standard which generally requires pushing 244 * addresses or registers onto the stack. We should be able to get away with 245 * less if this becomes important. 246 * 247 * @top: Top of available memory, also normally the top of the stack 248 * @return: New stack location 249 */ 250 ulong board_init_f_mem(ulong top); 251 252 /** 253 * arch_setup_gd() - Set up the global_data pointer 254 * 255 * This pointer is special in some architectures and cannot easily be assigned 256 * to. For example on x86 it is implemented by adding a specific record to its 257 * Global Descriptor Table! So we we provide a function to carry out this task. 258 * For most architectures this can simply be: 259 * 260 * gd = gd_ptr; 261 * 262 * @gd_ptr: Pointer to global data 263 */ 264 void arch_setup_gd(gd_t *gd_ptr); 265 266 int checkboard(void); 267 int show_board_info(void); 268 int checkflash(void); 269 int checkdram(void); 270 int last_stage_init(void); 271 extern ulong monitor_flash_len; 272 int mac_read_from_eeprom(void); 273 extern u8 __dtb_dt_begin[]; /* embedded device tree blob */ 274 int set_cpu_clk_info(void); 275 int mdm_init(void); 276 #if defined(CONFIG_DISPLAY_CPUINFO) 277 int print_cpuinfo(void); 278 #else 279 static inline int print_cpuinfo(void) 280 { 281 return 0; 282 } 283 #endif 284 int update_flash_size(int flash_size); 285 int arch_early_init_r(void); 286 287 /** 288 * arch_cpu_init_dm() - init CPU after driver model is available 289 * 290 * This is called immediately after driver model is available before 291 * relocation. This is similar to arch_cpu_init() but is able to reference 292 * devices 293 * 294 * @return 0 if OK, -ve on error 295 */ 296 int arch_cpu_init_dm(void); 297 298 /** 299 * Reserve all necessary stacks 300 * 301 * This is used in generic board init sequence in common/board_f.c. Each 302 * architecture could provide this function to tailor the required stacks. 303 * 304 * On entry gd->start_addr_sp is pointing to the suggested top of the stack. 305 * The callee ensures gd->start_add_sp is 16-byte aligned, so architectures 306 * require only this can leave it untouched. 307 * 308 * On exit gd->start_addr_sp and gd->irq_sp should be set to the respective 309 * positions of the stack. The stack pointer(s) will be set to this later. 310 * gd->irq_sp is only required, if the architecture needs it. 311 * 312 * @return 0 if no error 313 */ 314 __weak int arch_reserve_stacks(void); 315 316 /** 317 * Show the DRAM size in a board-specific way 318 * 319 * This is used by boards to display DRAM information in their own way. 320 * 321 * @param size Size of DRAM (which should be displayed along with other info) 322 */ 323 void board_show_dram(phys_size_t size); 324 325 /** 326 * arch_fixup_fdt() - Write arch-specific information to fdt 327 * 328 * Defined in arch/$(ARCH)/lib/bootm-fdt.c 329 * 330 * @blob: FDT blob to write to 331 * @return 0 if ok, or -ve FDT_ERR_... on failure 332 */ 333 int arch_fixup_fdt(void *blob); 334 335 /* common/flash.c */ 336 void flash_perror (int); 337 338 /* common/cmd_source.c */ 339 int source (ulong addr, const char *fit_uname); 340 341 extern ulong load_addr; /* Default Load Address */ 342 extern ulong save_addr; /* Default Save Address */ 343 extern ulong save_size; /* Default Save Size */ 344 345 /* common/cmd_doc.c */ 346 void doc_probe(unsigned long physadr); 347 348 /* common/cmd_net.c */ 349 int do_tftpb(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]); 350 351 /* common/cmd_fat.c */ 352 int do_fat_fsload(cmd_tbl_t *, int, int, char * const []); 353 354 /* common/cmd_ext2.c */ 355 int do_ext2load(cmd_tbl_t *, int, int, char * const []); 356 357 /* common/cmd_nvedit.c */ 358 int env_init (void); 359 void env_relocate (void); 360 int envmatch (uchar *, int); 361 362 /* Avoid unfortunate conflict with libc's getenv() */ 363 #ifdef CONFIG_SANDBOX 364 #define getenv uboot_getenv 365 #endif 366 char *getenv (const char *); 367 int getenv_f (const char *name, char *buf, unsigned len); 368 ulong getenv_ulong(const char *name, int base, ulong default_val); 369 370 /** 371 * getenv_hex() - Return an environment variable as a hex value 372 * 373 * Decode an environment as a hex number (it may or may not have a 0x 374 * prefix). If the environment variable cannot be found, or does not start 375 * with hex digits, the default value is returned. 376 * 377 * @varname: Variable to decode 378 * @default_val: Value to return on error 379 */ 380 ulong getenv_hex(const char *varname, ulong default_val); 381 382 /* 383 * Read an environment variable as a boolean 384 * Return -1 if variable does not exist (default to true) 385 */ 386 int getenv_yesno(const char *var); 387 int saveenv (void); 388 int setenv (const char *, const char *); 389 int setenv_ulong(const char *varname, ulong value); 390 int setenv_hex(const char *varname, ulong value); 391 /** 392 * setenv_addr - Set an environment variable to an address in hex 393 * 394 * @varname: Environment variable to set 395 * @addr: Value to set it to 396 * @return 0 if ok, 1 on error 397 */ 398 static inline int setenv_addr(const char *varname, const void *addr) 399 { 400 return setenv_hex(varname, (ulong)addr); 401 } 402 403 #ifdef CONFIG_ARM 404 # include <asm/mach-types.h> 405 # include <asm/setup.h> 406 # include <asm/u-boot-arm.h> /* ARM version to be fixed! */ 407 #endif /* CONFIG_ARM */ 408 #ifdef CONFIG_X86 /* x86 version to be fixed! */ 409 # include <asm/u-boot-x86.h> 410 #endif /* CONFIG_X86 */ 411 #ifdef CONFIG_SANDBOX 412 # include <asm/u-boot-sandbox.h> /* TODO(sjg) what needs to be fixed? */ 413 #endif 414 #ifdef CONFIG_NDS32 415 # include <asm/mach-types.h> 416 # include <asm/setup.h> 417 # include <asm/u-boot-nds32.h> 418 #endif /* CONFIG_NDS32 */ 419 #ifdef CONFIG_MIPS 420 # include <asm/u-boot-mips.h> 421 #endif /* CONFIG_MIPS */ 422 #ifdef CONFIG_ARC 423 # include <asm/u-boot-arc.h> 424 #endif /* CONFIG_ARC */ 425 426 #ifdef CONFIG_AUTO_COMPLETE 427 int env_complete(char *var, int maxv, char *cmdv[], int maxsz, char *buf); 428 #endif 429 int get_env_id (void); 430 431 void pci_init (void); 432 void pci_init_board(void); 433 void pciinfo (int, int); 434 435 #if defined(CONFIG_PCI) && defined(CONFIG_4xx) 436 int pci_pre_init (struct pci_controller *); 437 int is_pci_host (struct pci_controller *); 438 #endif 439 440 #if defined(CONFIG_PCI) && (defined(CONFIG_440) || defined(CONFIG_405EX)) 441 # if defined(CONFIG_SYS_PCI_TARGET_INIT) 442 void pci_target_init (struct pci_controller *); 443 # endif 444 # if defined(CONFIG_SYS_PCI_MASTER_INIT) 445 void pci_master_init (struct pci_controller *); 446 # endif 447 #if defined(CONFIG_440SPE) || \ 448 defined(CONFIG_460EX) || defined(CONFIG_460GT) || \ 449 defined(CONFIG_405EX) 450 void pcie_setup_hoses(int busno); 451 #endif 452 #endif 453 454 int misc_init_f (void); 455 int misc_init_r (void); 456 457 /* common/exports.c */ 458 void jumptable_init(void); 459 460 /* common/kallsysm.c */ 461 const char *symbol_lookup(unsigned long addr, unsigned long *caddr); 462 463 /* api/api.c */ 464 void api_init (void); 465 466 /* common/memsize.c */ 467 long get_ram_size (long *, long); 468 phys_size_t get_effective_memsize(void); 469 470 /* $(BOARD)/$(BOARD).c */ 471 void reset_phy (void); 472 void fdc_hw_init (void); 473 474 /* $(BOARD)/eeprom.c */ 475 void eeprom_init (void); 476 #ifndef CONFIG_SPI 477 int eeprom_probe (unsigned dev_addr, unsigned offset); 478 #endif 479 int eeprom_read (unsigned dev_addr, unsigned offset, uchar *buffer, unsigned cnt); 480 int eeprom_write (unsigned dev_addr, unsigned offset, uchar *buffer, unsigned cnt); 481 482 /* 483 * Set this up regardless of board 484 * type, to prevent errors. 485 */ 486 #if defined(CONFIG_SPI) || !defined(CONFIG_SYS_I2C_EEPROM_ADDR) 487 # define CONFIG_SYS_DEF_EEPROM_ADDR 0 488 #else 489 #if !defined(CONFIG_ENV_EEPROM_IS_ON_I2C) 490 # define CONFIG_SYS_DEF_EEPROM_ADDR CONFIG_SYS_I2C_EEPROM_ADDR 491 #endif 492 #endif /* CONFIG_SPI || !defined(CONFIG_SYS_I2C_EEPROM_ADDR) */ 493 494 #if defined(CONFIG_SPI) 495 extern void spi_init_f (void); 496 extern void spi_init_r (void); 497 extern ssize_t spi_read (uchar *, int, uchar *, int); 498 extern ssize_t spi_write (uchar *, int, uchar *, int); 499 #endif 500 501 /* $(BOARD)/$(BOARD).c */ 502 int board_early_init_f (void); 503 int board_late_init (void); 504 int board_postclk_init (void); /* after clocks/timebase, before env/serial */ 505 int board_early_init_r (void); 506 void board_poweroff (void); 507 508 #if defined(CONFIG_SYS_DRAM_TEST) 509 int testdram(void); 510 #endif /* CONFIG_SYS_DRAM_TEST */ 511 512 /* $(CPU)/start.S */ 513 #if defined(CONFIG_5xx) || \ 514 defined(CONFIG_8xx) 515 uint get_immr (uint); 516 #endif 517 #if defined(CONFIG_MPC5xxx) 518 uint get_svr (void); 519 #endif 520 uint get_pvr (void); 521 uint get_svr (void); 522 uint rd_ic_cst (void); 523 void wr_ic_cst (uint); 524 void wr_ic_adr (uint); 525 uint rd_dc_cst (void); 526 void wr_dc_cst (uint); 527 void wr_dc_adr (uint); 528 int icache_status (void); 529 void icache_enable (void); 530 void icache_disable(void); 531 int dcache_status (void); 532 void dcache_enable (void); 533 void dcache_disable(void); 534 void mmu_disable(void); 535 #if defined(CONFIG_ARM) 536 void relocate_code(ulong); 537 #else 538 void relocate_code(ulong, gd_t *, ulong) __attribute__ ((noreturn)); 539 #endif 540 ulong get_endaddr (void); 541 void trap_init (ulong); 542 #if defined (CONFIG_4xx) || \ 543 defined (CONFIG_MPC5xxx) || \ 544 defined (CONFIG_MPC85xx) || \ 545 defined (CONFIG_MPC86xx) || \ 546 defined (CONFIG_MPC83xx) 547 unsigned char in8(unsigned int); 548 void out8(unsigned int, unsigned char); 549 unsigned short in16(unsigned int); 550 unsigned short in16r(unsigned int); 551 void out16(unsigned int, unsigned short value); 552 void out16r(unsigned int, unsigned short value); 553 unsigned long in32(unsigned int); 554 unsigned long in32r(unsigned int); 555 void out32(unsigned int, unsigned long value); 556 void out32r(unsigned int, unsigned long value); 557 void ppcDcbf(unsigned long value); 558 void ppcDcbi(unsigned long value); 559 void ppcSync(void); 560 void ppcDcbz(unsigned long value); 561 #endif 562 #if defined (CONFIG_MICROBLAZE) 563 unsigned short in16(unsigned int); 564 void out16(unsigned int, unsigned short value); 565 #endif 566 567 #if defined (CONFIG_MPC83xx) 568 void ppcDWload(unsigned int *addr, unsigned int *ret); 569 void ppcDWstore(unsigned int *addr, unsigned int *value); 570 void disable_addr_trans(void); 571 void enable_addr_trans(void); 572 #if defined(CONFIG_DDR_ECC) && !defined(CONFIG_ECC_INIT_VIA_DDRCONTROLLER) 573 void ddr_enable_ecc(unsigned int dram_size); 574 #endif 575 #endif 576 577 /* 578 * Return the current value of a monotonically increasing microsecond timer. 579 * Granularity may be larger than 1us if hardware does not support this. 580 */ 581 ulong timer_get_us(void); 582 583 /* $(CPU)/cpu.c */ 584 static inline int cpumask_next(int cpu, unsigned int mask) 585 { 586 for (cpu++; !((1 << cpu) & mask); cpu++) 587 ; 588 589 return cpu; 590 } 591 592 #define for_each_cpu(iter, cpu, num_cpus, mask) \ 593 for (iter = 0, cpu = cpumask_next(-1, mask); \ 594 iter < num_cpus; \ 595 iter++, cpu = cpumask_next(cpu, mask)) \ 596 597 int cpu_numcores (void); 598 int cpu_num_dspcores(void); 599 u32 cpu_mask (void); 600 u32 cpu_dsp_mask(void); 601 int is_core_valid (unsigned int); 602 int probecpu (void); 603 int checkcpu (void); 604 int checkicache (void); 605 int checkdcache (void); 606 void upmconfig (unsigned int, unsigned int *, unsigned int); 607 ulong get_tbclk (void); 608 void reset_misc (void); 609 void reset_cpu (ulong addr); 610 #if defined (CONFIG_OF_LIBFDT) && defined (CONFIG_OF_BOARD_SETUP) 611 void ft_cpu_setup(void *blob, bd_t *bd); 612 #ifdef CONFIG_PCI 613 void ft_pci_setup(void *blob, bd_t *bd); 614 #endif 615 #endif 616 617 void smp_set_core_boot_addr(unsigned long addr, int corenr); 618 void smp_kick_all_cpus(void); 619 620 /* $(CPU)/serial.c */ 621 int serial_init (void); 622 void serial_setbrg (void); 623 void serial_putc (const char); 624 void serial_putc_raw(const char); 625 void serial_puts (const char *); 626 int serial_getc (void); 627 int serial_tstc (void); 628 629 /* These versions take a stdio_dev pointer */ 630 struct stdio_dev; 631 int serial_stub_getc(struct stdio_dev *sdev); 632 int serial_stub_tstc(struct stdio_dev *sdev); 633 634 /* $(CPU)/speed.c */ 635 int get_clocks (void); 636 int get_clocks_866 (void); 637 int sdram_adjust_866 (void); 638 int adjust_sdram_tbs_8xx (void); 639 #if defined(CONFIG_MPC8260) 640 int prt_8260_clks (void); 641 #elif defined(CONFIG_MPC5xxx) 642 int prt_mpc5xxx_clks (void); 643 #endif 644 #ifdef CONFIG_4xx 645 ulong get_OPB_freq (void); 646 ulong get_PCI_freq (void); 647 #endif 648 #if defined(CONFIG_S3C24X0) || \ 649 defined(CONFIG_LH7A40X) || \ 650 defined(CONFIG_EP93XX) 651 ulong get_FCLK (void); 652 ulong get_HCLK (void); 653 ulong get_PCLK (void); 654 ulong get_UCLK (void); 655 #endif 656 #if defined(CONFIG_LH7A40X) 657 ulong get_PLLCLK (void); 658 #endif 659 #if defined(CONFIG_IMX) 660 ulong get_systemPLLCLK(void); 661 ulong get_FCLK(void); 662 ulong get_HCLK(void); 663 ulong get_BCLK(void); 664 ulong get_PERCLK1(void); 665 ulong get_PERCLK2(void); 666 ulong get_PERCLK3(void); 667 #endif 668 ulong get_bus_freq (ulong); 669 int get_serial_clock(void); 670 671 #if defined(CONFIG_MPC85xx) 672 typedef MPC85xx_SYS_INFO sys_info_t; 673 void get_sys_info ( sys_info_t * ); 674 # if defined(CONFIG_OF_LIBFDT) 675 void ft_fixup_cpu(void *, u64); 676 void ft_fixup_num_cores(void *); 677 # endif 678 #endif 679 #if defined(CONFIG_MPC86xx) 680 typedef MPC86xx_SYS_INFO sys_info_t; 681 void get_sys_info ( sys_info_t * ); 682 static inline ulong get_ddr_freq(ulong dummy) 683 { 684 return get_bus_freq(dummy); 685 } 686 #else 687 ulong get_ddr_freq(ulong); 688 #endif 689 690 #if defined(CONFIG_4xx) 691 # if defined(CONFIG_440) 692 # if defined(CONFIG_440SPE) 693 unsigned long determine_sysper(void); 694 unsigned long determine_pci_clock_per(void); 695 # endif 696 # endif 697 typedef PPC4xx_SYS_INFO sys_info_t; 698 int ppc440spe_revB(void); 699 void get_sys_info ( sys_info_t * ); 700 #endif 701 702 /* $(CPU)/cpu_init.c */ 703 #if defined(CONFIG_8xx) || defined(CONFIG_MPC8260) 704 void cpu_init_f (volatile immap_t *immr); 705 #endif 706 #if defined(CONFIG_4xx) || defined(CONFIG_MCF52x2) || defined(CONFIG_MPC86xx) 707 void cpu_init_f (void); 708 #endif 709 #ifdef CONFIG_MPC85xx 710 ulong cpu_init_f(void); 711 #endif 712 713 int cpu_init_r (void); 714 #if defined(CONFIG_MPC8260) 715 int prt_8260_rsr (void); 716 #elif defined(CONFIG_MPC83xx) 717 int prt_83xx_rsr (void); 718 #endif 719 720 /* $(CPU)/interrupts.c */ 721 int interrupt_init (void); 722 void timer_interrupt (struct pt_regs *); 723 void external_interrupt (struct pt_regs *); 724 void irq_install_handler(int, interrupt_handler_t *, void *); 725 void irq_free_handler (int); 726 void reset_timer (void); 727 ulong get_timer (ulong base); 728 729 /* Return value of monotonic microsecond timer */ 730 unsigned long timer_get_us(void); 731 732 void enable_interrupts (void); 733 int disable_interrupts (void); 734 735 /* $(CPU)/.../commproc.c */ 736 int dpram_init (void); 737 uint dpram_base(void); 738 uint dpram_base_align(uint align); 739 uint dpram_alloc(uint size); 740 uint dpram_alloc_align(uint size,uint align); 741 void bootcount_store (ulong); 742 ulong bootcount_load (void); 743 #define BOOTCOUNT_MAGIC 0xB001C041 744 745 /* $(CPU)/.../<eth> */ 746 void mii_init (void); 747 748 /* $(CPU)/.../lcd.c */ 749 ulong lcd_setmem (ulong); 750 751 /* $(CPU)/.../video.c */ 752 ulong video_setmem (ulong); 753 754 /* arch/$(ARCH)/lib/cache.c */ 755 void enable_caches(void); 756 void flush_cache (unsigned long, unsigned long); 757 void flush_dcache_all(void); 758 void flush_dcache_range(unsigned long start, unsigned long stop); 759 void invalidate_dcache_range(unsigned long start, unsigned long stop); 760 void invalidate_dcache_all(void); 761 void invalidate_icache_all(void); 762 763 enum { 764 /* Disable caches (else flush caches but leave them active) */ 765 CBL_DISABLE_CACHES = 1 << 0, 766 CBL_SHOW_BOOTSTAGE_REPORT = 1 << 1, 767 768 CBL_ALL = 3, 769 }; 770 771 /** 772 * Clean up ready for linux 773 * 774 * @param flags Flags to control what is done 775 */ 776 int cleanup_before_linux_select(int flags); 777 778 /* arch/$(ARCH)/lib/ticks.S */ 779 uint64_t get_ticks(void); 780 void wait_ticks (unsigned long); 781 782 /* arch/$(ARCH)/lib/time.c */ 783 void __udelay (unsigned long); 784 ulong usec2ticks (unsigned long usec); 785 ulong ticks2usec (unsigned long ticks); 786 int init_timebase (void); 787 788 /* lib/gunzip.c */ 789 int gunzip(void *, int, unsigned char *, unsigned long *); 790 int zunzip(void *dst, int dstlen, unsigned char *src, unsigned long *lenp, 791 int stoponerr, int offset); 792 793 /** 794 * gzwrite progress indicators: defined weak to allow board-specific 795 * overrides: 796 * 797 * gzwrite_progress_init called on startup 798 * gzwrite_progress called during decompress/write loop 799 * gzwrite_progress_finish called at end of loop to 800 * indicate success (retcode=0) or failure 801 */ 802 void gzwrite_progress_init(u64 expected_size); 803 804 void gzwrite_progress(int iteration, 805 u64 bytes_written, 806 u64 total_bytes); 807 808 void gzwrite_progress_finish(int retcode, 809 u64 totalwritten, 810 u64 totalsize, 811 u32 expected_crc, 812 u32 calculated_crc); 813 814 /** 815 * decompress and write gzipped image from memory to block device 816 * 817 * @param src compressed image address 818 * @param len compressed image length in bytes 819 * @param dev block device descriptor 820 * @param szwritebuf bytes per write (pad to erase size) 821 * @param startoffs offset in bytes of first write 822 * @param szexpected expected uncompressed length 823 * may be zero to use gzip trailer 824 * for files under 4GiB 825 */ 826 int gzwrite(unsigned char *src, int len, 827 struct block_dev_desc *dev, 828 unsigned long szwritebuf, 829 u64 startoffs, 830 u64 szexpected); 831 832 /* lib/lz4_wrapper.c */ 833 int ulz4fn(const void *src, size_t srcn, void *dst, size_t *dstn); 834 835 /* lib/qsort.c */ 836 void qsort(void *base, size_t nmemb, size_t size, 837 int(*compar)(const void *, const void *)); 838 int strcmp_compar(const void *, const void *); 839 840 /* lib/time.c */ 841 void udelay (unsigned long); 842 void mdelay(unsigned long); 843 844 /* lib/uuid.c */ 845 #include <uuid.h> 846 847 /* lib/vsprintf.c */ 848 #include <vsprintf.h> 849 850 /* lib/strmhz.c */ 851 char * strmhz(char *buf, unsigned long hz); 852 853 /* lib/crc32.c */ 854 #include <u-boot/crc.h> 855 856 /* lib/rand.c */ 857 #define RAND_MAX -1U 858 void srand(unsigned int seed); 859 unsigned int rand(void); 860 unsigned int rand_r(unsigned int *seedp); 861 862 /* common/console.c */ 863 int console_init_f(void); /* Before relocation; uses the serial stuff */ 864 int console_init_r(void); /* After relocation; uses the console stuff */ 865 int console_assign(int file, const char *devname); /* Assign the console */ 866 int ctrlc (void); 867 int had_ctrlc (void); /* have we had a Control-C since last clear? */ 868 void clear_ctrlc (void); /* clear the Control-C condition */ 869 int disable_ctrlc (int); /* 1 to disable, 0 to enable Control-C detect */ 870 int confirm_yesno(void); /* 1 if input is "y", "Y", "yes" or "YES" */ 871 /* 872 * STDIO based functions (can always be used) 873 */ 874 /* serial stuff */ 875 int serial_printf (const char *fmt, ...) 876 __attribute__ ((format (__printf__, 1, 2))); 877 /* stdin */ 878 int getc(void); 879 int tstc(void); 880 881 /* stdout */ 882 #if defined(CONFIG_SPL_BUILD) && !defined(CONFIG_SPL_SERIAL_SUPPORT) 883 #define putc(...) do { } while (0) 884 #define puts(...) do { } while (0) 885 #define printf(...) do { } while (0) 886 #define vprintf(...) do { } while (0) 887 #else 888 void putc(const char c); 889 void puts(const char *s); 890 int printf(const char *fmt, ...) 891 __attribute__ ((format (__printf__, 1, 2))); 892 int vprintf(const char *fmt, va_list args); 893 #endif 894 895 /* stderr */ 896 #define eputc(c) fputc(stderr, c) 897 #define eputs(s) fputs(stderr, s) 898 #define eprintf(fmt,args...) fprintf(stderr,fmt ,##args) 899 900 /* 901 * FILE based functions (can only be used AFTER relocation!) 902 */ 903 #define stdin 0 904 #define stdout 1 905 #define stderr 2 906 #define MAX_FILES 3 907 908 int fprintf(int file, const char *fmt, ...) 909 __attribute__ ((format (__printf__, 2, 3))); 910 void fputs(int file, const char *s); 911 void fputc(int file, const char c); 912 int ftstc(int file); 913 int fgetc(int file); 914 915 /* lib/gzip.c */ 916 int gzip(void *dst, unsigned long *lenp, 917 unsigned char *src, unsigned long srclen); 918 int zzip(void *dst, unsigned long *lenp, unsigned char *src, 919 unsigned long srclen, int stoponerr, 920 int (*func)(unsigned long, unsigned long)); 921 922 /* lib/net_utils.c */ 923 #include <net.h> 924 static inline struct in_addr getenv_ip(char *var) 925 { 926 return string_to_ip(getenv(var)); 927 } 928 929 /* 930 * CONSOLE multiplexing. 931 */ 932 #ifdef CONFIG_CONSOLE_MUX 933 #include <iomux.h> 934 #endif 935 936 int pcmcia_init (void); 937 938 #ifdef CONFIG_STATUS_LED 939 # include <status_led.h> 940 #endif 941 942 #include <bootstage.h> 943 944 #ifdef CONFIG_SHOW_ACTIVITY 945 void show_activity(int arg); 946 #endif 947 948 /* Multicore arch functions */ 949 #ifdef CONFIG_MP 950 int cpu_status(int nr); 951 int cpu_reset(int nr); 952 int cpu_disable(int nr); 953 int cpu_release(int nr, int argc, char * const argv[]); 954 #endif 955 956 #endif /* __ASSEMBLY__ */ 957 958 #ifdef CONFIG_PPC 959 /* 960 * Has to be included outside of the #ifndef __ASSEMBLY__ section. 961 * Otherwise might lead to compilation errors in assembler files. 962 */ 963 #include <asm/cache.h> 964 #endif 965 966 /* Put only stuff here that the assembler can digest */ 967 968 #ifdef CONFIG_POST 969 #define CONFIG_HAS_POST 970 #ifndef CONFIG_POST_ALT_LIST 971 #define CONFIG_POST_STD_LIST 972 #endif 973 #endif 974 975 #ifdef CONFIG_INIT_CRITICAL 976 #error CONFIG_INIT_CRITICAL is deprecated! 977 #error Read section CONFIG_SKIP_LOWLEVEL_INIT in README. 978 #endif 979 980 #define ROUND(a,b) (((a) + (b) - 1) & ~((b) - 1)) 981 982 /* 983 * check_member() - Check the offset of a structure member 984 * 985 * @structure: Name of structure (e.g. global_data) 986 * @member: Name of member (e.g. baudrate) 987 * @offset: Expected offset in bytes 988 */ 989 #define check_member(structure, member, offset) _Static_assert( \ 990 offsetof(struct structure, member) == offset, \ 991 "`struct " #structure "` offset for `" #member "` is not " #offset) 992 993 /* Avoid using CONFIG_EFI_STUB directly as we may boot from other loaders */ 994 #ifdef CONFIG_EFI_STUB 995 #define ll_boot_init() false 996 #else 997 #define ll_boot_init() true 998 #endif 999 1000 /* Pull in stuff for the build system */ 1001 #ifdef DO_DEPS_ONLY 1002 # include <environment.h> 1003 #endif 1004 1005 #endif /* __COMMON_H_ */ 1006