include: move various macros to include/linux/kernel.h
[platform/kernel/u-boot.git] / include / common.h
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_ARM
74 #define asmlinkage      /* nothing */
75 #endif
76 #ifdef CONFIG_BLACKFIN
77 #include <asm/blackfin.h>
78 #endif
79 #ifdef CONFIG_SOC_DA8XX
80 #include <asm/arch/hardware.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 /*
101  * Output a debug text when condition "cond" is met. The "cond" should be
102  * computed by a preprocessor in the best case, allowing for the best
103  * optimization.
104  */
105 #define debug_cond(cond, fmt, args...)          \
106         do {                                    \
107                 if (cond)                       \
108                         printf(fmt, ##args);    \
109         } while (0)
110
111 #define debug(fmt, args...)                     \
112         debug_cond(_DEBUG, fmt, ##args)
113
114 /*
115  * An assertion is run-time check done in debug mode only. If DEBUG is not
116  * defined then it is skipped. If DEBUG is defined and the assertion fails,
117  * then it calls panic*( which may or may not reset/halt U-Boot (see
118  * CONFIG_PANIC_HANG), It is hoped that all failing assertions are found
119  * before release, and after release it is hoped that they don't matter. But
120  * in any case these failing assertions cannot be fixed with a reset (which
121  * may just do the same assertion again).
122  */
123 void __assert_fail(const char *assertion, const char *file, unsigned line,
124                    const char *function);
125 #define assert(x) \
126         ({ if (!(x) && _DEBUG) \
127                 __assert_fail(#x, __FILE__, __LINE__, __func__); })
128
129 #define error(fmt, args...) do {                                        \
130                 printf("ERROR: " fmt "\nat %s:%d/%s()\n",               \
131                         ##args, __FILE__, __LINE__, __func__);          \
132 } while (0)
133
134 #ifndef BUG
135 #define BUG() do { \
136         printf("BUG: failure at %s:%d/%s()!\n", __FILE__, __LINE__, __FUNCTION__); \
137         panic("BUG!"); \
138 } while (0)
139 #define BUG_ON(condition) do { if (unlikely((condition)!=0)) BUG(); } while(0)
140 #endif /* BUG */
141
142 /* Force a compilation error if condition is true */
143 #define BUILD_BUG_ON(condition) ((void)sizeof(char[1 - 2*!!(condition)]))
144
145 typedef void (interrupt_handler_t)(void *);
146
147 #include <asm/u-boot.h> /* boot information for Linux kernel */
148 #include <asm/global_data.h>    /* global data used for startup functions */
149
150 /*
151  * enable common handling for all TQM8xxL/M boards:
152  * - CONFIG_TQM8xxM will be defined for all TQM8xxM boards
153  * - CONFIG_TQM8xxL will be defined for all TQM8xxL _and_ TQM8xxM boards
154  *                  and for the TQM885D board
155  */
156 #if defined(CONFIG_TQM823M) || defined(CONFIG_TQM850M) || \
157     defined(CONFIG_TQM855M) || defined(CONFIG_TQM860M) || \
158     defined(CONFIG_TQM862M) || defined(CONFIG_TQM866M)
159 # ifndef CONFIG_TQM8xxM
160 #  define CONFIG_TQM8xxM
161 # endif
162 #endif
163 #if defined(CONFIG_TQM823L) || defined(CONFIG_TQM850L) || \
164     defined(CONFIG_TQM855L) || defined(CONFIG_TQM860L) || \
165     defined(CONFIG_TQM862L) || defined(CONFIG_TQM8xxM) || \
166     defined(CONFIG_TQM885D)
167 # ifndef CONFIG_TQM8xxL
168 #  define CONFIG_TQM8xxL
169 # endif
170 #endif
171
172 #if defined(CONFIG_ENV_IS_EMBEDDED)
173 #define TOTAL_MALLOC_LEN        CONFIG_SYS_MALLOC_LEN
174 #elif ( ((CONFIG_ENV_ADDR+CONFIG_ENV_SIZE) < CONFIG_SYS_MONITOR_BASE) || \
175         (CONFIG_ENV_ADDR >= (CONFIG_SYS_MONITOR_BASE + CONFIG_SYS_MONITOR_LEN)) ) || \
176       defined(CONFIG_ENV_IS_IN_NVRAM)
177 #define TOTAL_MALLOC_LEN        (CONFIG_SYS_MALLOC_LEN + CONFIG_ENV_SIZE)
178 #else
179 #define TOTAL_MALLOC_LEN        CONFIG_SYS_MALLOC_LEN
180 #endif
181
182 /*
183  * Function Prototypes
184  */
185
186 void    hang            (void) __attribute__ ((noreturn));
187
188 int     timer_init(void);
189 int     cpu_init(void);
190
191 /* */
192 phys_size_t initdram (int);
193 int     display_options (void);
194
195 /**
196  * print_size() - Print a size with a suffic
197  *
198  * print sizes as "xxx KiB", "xxx.y KiB", "xxx MiB", "xxx.y MiB",
199  * xxx GiB, xxx.y GiB, etc as needed; allow for optional trailing string
200  * (like "\n")
201  *
202  * @size:       Size to print
203  * @suffix      String to print after the size
204  */
205 void print_size(uint64_t size, const char *suffix);
206
207 int print_buffer(ulong addr, const void *data, uint width, uint count,
208                  uint linelen);
209
210 /* common/main.c */
211 void    main_loop       (void);
212 int run_command(const char *cmd, int flag);
213 int run_command_repeatable(const char *cmd, int flag);
214
215 /**
216  * Run a list of commands separated by ; or even \0
217  *
218  * Note that if 'len' is not -1, then the command does not need to be nul
219  * terminated, Memory will be allocated for the command in that case.
220  *
221  * @param cmd   List of commands to run, each separated bu semicolon
222  * @param len   Length of commands excluding terminator if known (-1 if not)
223  * @param flag  Execution flags (CMD_FLAG_...)
224  * @return 0 on success, or != 0 on error.
225  */
226 int run_command_list(const char *cmd, int len, int flag);
227 extern char console_buffer[];
228
229 /* arch/$(ARCH)/lib/board.c */
230 void    board_init_f(ulong);
231 void    board_init_r  (gd_t *, ulong) __attribute__ ((noreturn));
232 int     checkboard    (void);
233 int     checkflash    (void);
234 int     checkdram     (void);
235 int     last_stage_init(void);
236 extern ulong monitor_flash_len;
237 int mac_read_from_eeprom(void);
238 extern u8 __dtb_dt_begin[];     /* embedded device tree blob */
239 int set_cpu_clk_info(void);
240 int mdm_init(void);
241 #if defined(CONFIG_DISPLAY_CPUINFO)
242 int print_cpuinfo(void);
243 #else
244 static inline int print_cpuinfo(void)
245 {
246         return 0;
247 }
248 #endif
249 int update_flash_size(int flash_size);
250 int arch_early_init_r(void);
251
252 /**
253  * Show the DRAM size in a board-specific way
254  *
255  * This is used by boards to display DRAM information in their own way.
256  *
257  * @param size  Size of DRAM (which should be displayed along with other info)
258  */
259 void board_show_dram(ulong size);
260
261 /**
262  * arch_fixup_fdt() - Write arch-specific information to fdt
263  *
264  * Defined in arch/$(ARCH)/lib/bootm-fdt.c
265  *
266  * @blob:       FDT blob to write to
267  * @return 0 if ok, or -ve FDT_ERR_... on failure
268  */
269 int arch_fixup_fdt(void *blob);
270
271 /* common/flash.c */
272 void flash_perror (int);
273
274 /* common/cmd_source.c */
275 int     source (ulong addr, const char *fit_uname);
276
277 extern ulong load_addr;         /* Default Load Address */
278 extern ulong save_addr;         /* Default Save Address */
279 extern ulong save_size;         /* Default Save Size */
280
281 /* common/cmd_doc.c */
282 void    doc_probe(unsigned long physadr);
283
284 /* common/cmd_net.c */
285 int do_tftpb(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
286
287 /* common/cmd_fat.c */
288 int do_fat_fsload(cmd_tbl_t *, int, int, char * const []);
289
290 /* common/cmd_ext2.c */
291 int do_ext2load(cmd_tbl_t *, int, int, char * const []);
292
293 /* common/cmd_nvedit.c */
294 int     env_init     (void);
295 void    env_relocate (void);
296 int     envmatch     (uchar *, int);
297
298 /* Avoid unfortunate conflict with libc's getenv() */
299 #ifdef CONFIG_SANDBOX
300 #define getenv uboot_getenv
301 #endif
302 char    *getenv      (const char *);
303 int     getenv_f     (const char *name, char *buf, unsigned len);
304 ulong getenv_ulong(const char *name, int base, ulong default_val);
305
306 /**
307  * getenv_hex() - Return an environment variable as a hex value
308  *
309  * Decode an environment as a hex number (it may or may not have a 0x
310  * prefix). If the environment variable cannot be found, or does not start
311  * with hex digits, the default value is returned.
312  *
313  * @varname:            Variable to decode
314  * @default_val:        Value to return on error
315  */
316 ulong getenv_hex(const char *varname, ulong default_val);
317
318 /*
319  * Read an environment variable as a boolean
320  * Return -1 if variable does not exist (default to true)
321  */
322 int getenv_yesno(const char *var);
323 int     saveenv      (void);
324 int     setenv       (const char *, const char *);
325 int setenv_ulong(const char *varname, ulong value);
326 int setenv_hex(const char *varname, ulong value);
327 /**
328  * setenv_addr - Set an environment variable to an address in hex
329  *
330  * @varname:    Environment variable to set
331  * @addr:       Value to set it to
332  * @return 0 if ok, 1 on error
333  */
334 static inline int setenv_addr(const char *varname, const void *addr)
335 {
336         return setenv_hex(varname, (ulong)addr);
337 }
338
339 #ifdef CONFIG_ARM
340 # include <asm/mach-types.h>
341 # include <asm/setup.h>
342 # include <asm/u-boot-arm.h>    /* ARM version to be fixed! */
343 #endif /* CONFIG_ARM */
344 #ifdef CONFIG_X86               /* x86 version to be fixed! */
345 # include <asm/u-boot-x86.h>
346 #endif /* CONFIG_X86 */
347 #ifdef CONFIG_SANDBOX
348 # include <asm/u-boot-sandbox.h>        /* TODO(sjg) what needs to be fixed? */
349 #endif
350 #ifdef CONFIG_NDS32
351 # include <asm/mach-types.h>
352 # include <asm/setup.h>
353 # include <asm/u-boot-nds32.h>
354 #endif /* CONFIG_NDS32 */
355 #ifdef CONFIG_MIPS
356 # include <asm/u-boot-mips.h>
357 #endif /* CONFIG_MIPS */
358 #ifdef CONFIG_ARC
359 # include <asm/u-boot-arc.h>
360 #endif /* CONFIG_ARC */
361
362 #ifdef CONFIG_AUTO_COMPLETE
363 int env_complete(char *var, int maxv, char *cmdv[], int maxsz, char *buf);
364 #endif
365 int get_env_id (void);
366
367 void    pci_init      (void);
368 void    pci_init_board(void);
369 void    pciinfo       (int, int);
370
371 #if defined(CONFIG_PCI) && defined(CONFIG_4xx)
372     int    pci_pre_init        (struct pci_controller *);
373     int    is_pci_host         (struct pci_controller *);
374 #endif
375
376 #if defined(CONFIG_PCI) && (defined(CONFIG_440) || defined(CONFIG_405EX))
377 #   if defined(CONFIG_SYS_PCI_TARGET_INIT)
378         void    pci_target_init      (struct pci_controller *);
379 #   endif
380 #   if defined(CONFIG_SYS_PCI_MASTER_INIT)
381         void    pci_master_init      (struct pci_controller *);
382 #   endif
383 #if defined(CONFIG_440SPE) || \
384     defined(CONFIG_460EX) || defined(CONFIG_460GT) || \
385     defined(CONFIG_405EX)
386    void pcie_setup_hoses(int busno);
387 #endif
388 #endif
389
390 int     misc_init_f   (void);
391 int     misc_init_r   (void);
392
393 /* common/exports.c */
394 void    jumptable_init(void);
395
396 /* common/kallsysm.c */
397 const char *symbol_lookup(unsigned long addr, unsigned long *caddr);
398
399 /* api/api.c */
400 void    api_init (void);
401
402 /* common/memsize.c */
403 long    get_ram_size  (long *, long);
404 phys_size_t get_effective_memsize(void);
405
406 /* $(BOARD)/$(BOARD).c */
407 void    reset_phy     (void);
408 void    fdc_hw_init   (void);
409
410 /* $(BOARD)/eeprom.c */
411 void eeprom_init  (void);
412 #ifndef CONFIG_SPI
413 int  eeprom_probe (unsigned dev_addr, unsigned offset);
414 #endif
415 int  eeprom_read  (unsigned dev_addr, unsigned offset, uchar *buffer, unsigned cnt);
416 int  eeprom_write (unsigned dev_addr, unsigned offset, uchar *buffer, unsigned cnt);
417 #ifdef CONFIG_LWMON
418 extern uchar pic_read  (uchar reg);
419 extern void  pic_write (uchar reg, uchar val);
420 #endif
421
422 /*
423  * Set this up regardless of board
424  * type, to prevent errors.
425  */
426 #if defined(CONFIG_SPI) || !defined(CONFIG_SYS_I2C_EEPROM_ADDR)
427 # define CONFIG_SYS_DEF_EEPROM_ADDR 0
428 #else
429 #if !defined(CONFIG_ENV_EEPROM_IS_ON_I2C)
430 # define CONFIG_SYS_DEF_EEPROM_ADDR CONFIG_SYS_I2C_EEPROM_ADDR
431 #endif
432 #endif /* CONFIG_SPI || !defined(CONFIG_SYS_I2C_EEPROM_ADDR) */
433
434 #if defined(CONFIG_SPI)
435 extern void spi_init_f (void);
436 extern void spi_init_r (void);
437 extern ssize_t spi_read  (uchar *, int, uchar *, int);
438 extern ssize_t spi_write (uchar *, int, uchar *, int);
439 #endif
440
441 #ifdef CONFIG_HERMES
442 /* $(BOARD)/hermes.c */
443 void hermes_start_lxt980 (int speed);
444 #endif
445
446 #ifdef CONFIG_EVB64260
447 void  evb64260_init(void);
448 void  debug_led(int, int);
449 void  display_mem_map(void);
450 void  perform_soft_reset(void);
451 #endif
452
453 /* $(BOARD)/$(BOARD).c */
454 int board_early_init_f (void);
455 int board_late_init (void);
456 int board_postclk_init (void); /* after clocks/timebase, before env/serial */
457 int board_early_init_r (void);
458 void board_poweroff (void);
459
460 #if defined(CONFIG_SYS_DRAM_TEST)
461 int testdram(void);
462 #endif /* CONFIG_SYS_DRAM_TEST */
463
464 /* $(CPU)/start.S */
465 #if defined(CONFIG_5xx) || \
466     defined(CONFIG_8xx)
467 uint    get_immr      (uint);
468 #endif
469 uint    get_pir       (void);
470 #if defined(CONFIG_MPC5xxx)
471 uint    get_svr       (void);
472 #endif
473 uint    get_pvr       (void);
474 uint    get_svr       (void);
475 uint    rd_ic_cst     (void);
476 void    wr_ic_cst     (uint);
477 void    wr_ic_adr     (uint);
478 uint    rd_dc_cst     (void);
479 void    wr_dc_cst     (uint);
480 void    wr_dc_adr     (uint);
481 int     icache_status (void);
482 void    icache_enable (void);
483 void    icache_disable(void);
484 int     dcache_status (void);
485 void    dcache_enable (void);
486 void    dcache_disable(void);
487 void    mmu_disable(void);
488 #if defined(CONFIG_ARM)
489 void    relocate_code(ulong);
490 #else
491 void    relocate_code(ulong, gd_t *, ulong) __attribute__ ((noreturn));
492 #endif
493 ulong   get_endaddr   (void);
494 void    trap_init     (ulong);
495 #if defined (CONFIG_4xx)        || \
496     defined (CONFIG_MPC5xxx)    || \
497     defined (CONFIG_74xx_7xx)   || \
498     defined (CONFIG_74x)        || \
499     defined (CONFIG_75x)        || \
500     defined (CONFIG_74xx)       || \
501     defined (CONFIG_MPC85xx)    || \
502     defined (CONFIG_MPC86xx)    || \
503     defined (CONFIG_MPC83xx)
504 unsigned char   in8(unsigned int);
505 void            out8(unsigned int, unsigned char);
506 unsigned short  in16(unsigned int);
507 unsigned short  in16r(unsigned int);
508 void            out16(unsigned int, unsigned short value);
509 void            out16r(unsigned int, unsigned short value);
510 unsigned long   in32(unsigned int);
511 unsigned long   in32r(unsigned int);
512 void            out32(unsigned int, unsigned long value);
513 void            out32r(unsigned int, unsigned long value);
514 void            ppcDcbf(unsigned long value);
515 void            ppcDcbi(unsigned long value);
516 void            ppcSync(void);
517 void            ppcDcbz(unsigned long value);
518 #endif
519 #if defined (CONFIG_MICROBLAZE)
520 unsigned short  in16(unsigned int);
521 void            out16(unsigned int, unsigned short value);
522 #endif
523
524 #if defined (CONFIG_MPC83xx)
525 void            ppcDWload(unsigned int *addr, unsigned int *ret);
526 void            ppcDWstore(unsigned int *addr, unsigned int *value);
527 void disable_addr_trans(void);
528 void enable_addr_trans(void);
529 #if defined(CONFIG_DDR_ECC) && !defined(CONFIG_ECC_INIT_VIA_DDRCONTROLLER)
530 void ddr_enable_ecc(unsigned int dram_size);
531 #endif
532 #endif
533
534 /*
535  * Return the current value of a monotonically increasing microsecond timer.
536  * Granularity may be larger than 1us if hardware does not support this.
537  */
538 ulong timer_get_us(void);
539
540 /* $(CPU)/cpu.c */
541 static inline int cpumask_next(int cpu, unsigned int mask)
542 {
543         for (cpu++; !((1 << cpu) & mask); cpu++)
544                 ;
545
546         return cpu;
547 }
548
549 #define for_each_cpu(iter, cpu, num_cpus, mask) \
550         for (iter = 0, cpu = cpumask_next(-1, mask); \
551                 iter < num_cpus; \
552                 iter++, cpu = cpumask_next(cpu, mask)) \
553
554 int     cpu_numcores  (void);
555 u32     cpu_mask      (void);
556 int     is_core_valid (unsigned int);
557 int     probecpu      (void);
558 int     checkcpu      (void);
559 int     checkicache   (void);
560 int     checkdcache   (void);
561 void    upmconfig     (unsigned int, unsigned int *, unsigned int);
562 ulong   get_tbclk     (void);
563 void    reset_misc    (void);
564 void    reset_cpu     (ulong addr);
565 #if defined (CONFIG_OF_LIBFDT) && defined (CONFIG_OF_BOARD_SETUP)
566 void ft_cpu_setup(void *blob, bd_t *bd);
567 #ifdef CONFIG_PCI
568 void ft_pci_setup(void *blob, bd_t *bd);
569 #endif
570 #endif
571
572 void smp_set_core_boot_addr(unsigned long addr, int corenr);
573 void smp_kick_all_cpus(void);
574
575 /* $(CPU)/serial.c */
576 int     serial_init   (void);
577 void    serial_setbrg (void);
578 void    serial_putc   (const char);
579 void    serial_putc_raw(const char);
580 void    serial_puts   (const char *);
581 int     serial_getc   (void);
582 int     serial_tstc   (void);
583
584 /* These versions take a stdio_dev pointer */
585 struct stdio_dev;
586 int serial_stub_getc(struct stdio_dev *sdev);
587 int serial_stub_tstc(struct stdio_dev *sdev);
588
589 /* $(CPU)/speed.c */
590 int     get_clocks (void);
591 int     get_clocks_866 (void);
592 int     sdram_adjust_866 (void);
593 int     adjust_sdram_tbs_8xx (void);
594 #if defined(CONFIG_MPC8260)
595 int     prt_8260_clks (void);
596 #elif defined(CONFIG_MPC5xxx)
597 int     prt_mpc5xxx_clks (void);
598 #endif
599 #ifdef CONFIG_4xx
600 ulong   get_OPB_freq (void);
601 ulong   get_PCI_freq (void);
602 #endif
603 #if defined(CONFIG_S3C24X0) || \
604     defined(CONFIG_LH7A40X) || \
605     defined(CONFIG_EP93XX)
606 ulong   get_FCLK (void);
607 ulong   get_HCLK (void);
608 ulong   get_PCLK (void);
609 ulong   get_UCLK (void);
610 #endif
611 #if defined(CONFIG_LH7A40X)
612 ulong   get_PLLCLK (void);
613 #endif
614 #if defined(CONFIG_IMX)
615 ulong get_systemPLLCLK(void);
616 ulong get_FCLK(void);
617 ulong get_HCLK(void);
618 ulong get_BCLK(void);
619 ulong get_PERCLK1(void);
620 ulong get_PERCLK2(void);
621 ulong get_PERCLK3(void);
622 #endif
623 ulong   get_bus_freq  (ulong);
624 int get_serial_clock(void);
625
626 #if defined(CONFIG_MPC85xx)
627 typedef MPC85xx_SYS_INFO sys_info_t;
628 void    get_sys_info  ( sys_info_t * );
629 #  if defined(CONFIG_OF_LIBFDT)
630         void ft_fixup_cpu(void *, u64);
631         void ft_fixup_num_cores(void *);
632 #  endif
633 #endif
634 #if defined(CONFIG_MPC86xx)
635 typedef MPC86xx_SYS_INFO sys_info_t;
636 void   get_sys_info  ( sys_info_t * );
637 static inline ulong get_ddr_freq(ulong dummy)
638 {
639         return get_bus_freq(dummy);
640 }
641 #else
642 ulong get_ddr_freq(ulong);
643 #endif
644
645 #if defined(CONFIG_4xx)
646 #  if defined(CONFIG_440)
647 #       if defined(CONFIG_440SPE)
648          unsigned long determine_sysper(void);
649          unsigned long determine_pci_clock_per(void);
650 #       endif
651 #  endif
652 typedef PPC4xx_SYS_INFO sys_info_t;
653 int     ppc440spe_revB(void);
654 void    get_sys_info  ( sys_info_t * );
655 #endif
656
657 /* $(CPU)/cpu_init.c */
658 #if defined(CONFIG_8xx) || defined(CONFIG_MPC8260)
659 void    cpu_init_f    (volatile immap_t *immr);
660 #endif
661 #if defined(CONFIG_4xx) || defined(CONFIG_MCF52x2) || defined(CONFIG_MPC86xx)
662 void    cpu_init_f    (void);
663 #endif
664 #ifdef CONFIG_MPC85xx
665 ulong cpu_init_f(void);
666 #endif
667
668 int     cpu_init_r    (void);
669 #if defined(CONFIG_MPC8260)
670 int     prt_8260_rsr  (void);
671 #elif defined(CONFIG_MPC83xx)
672 int     prt_83xx_rsr  (void);
673 #endif
674
675 /* $(CPU)/interrupts.c */
676 int     interrupt_init     (void);
677 void    timer_interrupt    (struct pt_regs *);
678 void    external_interrupt (struct pt_regs *);
679 void    irq_install_handler(int, interrupt_handler_t *, void *);
680 void    irq_free_handler   (int);
681 void    reset_timer        (void);
682 ulong   get_timer          (ulong base);
683
684 /* Return value of monotonic microsecond timer */
685 unsigned long timer_get_us(void);
686
687 void    enable_interrupts  (void);
688 int     disable_interrupts (void);
689
690 /* $(CPU)/.../commproc.c */
691 int     dpram_init (void);
692 uint    dpram_base(void);
693 uint    dpram_base_align(uint align);
694 uint    dpram_alloc(uint size);
695 uint    dpram_alloc_align(uint size,uint align);
696 void    bootcount_store (ulong);
697 ulong   bootcount_load (void);
698 #define BOOTCOUNT_MAGIC         0xB001C041
699
700 /* $(CPU)/.../<eth> */
701 void mii_init (void);
702
703 /* $(CPU)/.../lcd.c */
704 ulong   lcd_setmem (ulong);
705
706 /* $(CPU)/.../video.c */
707 ulong   video_setmem (ulong);
708
709 /* arch/$(ARCH)/lib/cache.c */
710 void    enable_caches(void);
711 void    flush_cache   (unsigned long, unsigned long);
712 void    flush_dcache_all(void);
713 void    flush_dcache_range(unsigned long start, unsigned long stop);
714 void    invalidate_dcache_range(unsigned long start, unsigned long stop);
715 void    invalidate_dcache_all(void);
716 void    invalidate_icache_all(void);
717
718 /* arch/$(ARCH)/lib/ticks.S */
719 uint64_t get_ticks(void);
720 void    wait_ticks    (unsigned long);
721
722 /* arch/$(ARCH)/lib/time.c */
723 void    __udelay      (unsigned long);
724 ulong   usec2ticks    (unsigned long usec);
725 ulong   ticks2usec    (unsigned long ticks);
726 int     init_timebase (void);
727
728 /* lib/gunzip.c */
729 int gunzip(void *, int, unsigned char *, unsigned long *);
730 int zunzip(void *dst, int dstlen, unsigned char *src, unsigned long *lenp,
731                                                 int stoponerr, int offset);
732
733 /* lib/qsort.c */
734 void qsort(void *base, size_t nmemb, size_t size,
735            int(*compar)(const void *, const void *));
736 int strcmp_compar(const void *, const void *);
737
738 /* lib/time.c */
739 void    udelay        (unsigned long);
740 void mdelay(unsigned long);
741
742 /* lib/uuid.c */
743 #include <uuid.h>
744
745 /* lib/vsprintf.c */
746 #include <vsprintf.h>
747
748 /* lib/strmhz.c */
749 char *  strmhz(char *buf, unsigned long hz);
750
751 /* lib/crc32.c */
752 #include <u-boot/crc.h>
753
754 /* lib/rand.c */
755 #define RAND_MAX -1U
756 void srand(unsigned int seed);
757 unsigned int rand(void);
758 unsigned int rand_r(unsigned int *seedp);
759
760 /* common/console.c */
761 int     console_init_f(void);   /* Before relocation; uses the serial  stuff    */
762 int     console_init_r(void);   /* After  relocation; uses the console stuff    */
763 int     console_assign(int file, const char *devname);  /* Assign the console   */
764 int     ctrlc (void);
765 int     had_ctrlc (void);       /* have we had a Control-C since last clear? */
766 void    clear_ctrlc (void);     /* clear the Control-C condition */
767 int     disable_ctrlc (int);    /* 1 to disable, 0 to enable Control-C detect */
768 int confirm_yesno(void);        /*  1 if input is "y", "Y", "yes" or "YES" */
769 /*
770  * STDIO based functions (can always be used)
771  */
772 /* serial stuff */
773 int     serial_printf (const char *fmt, ...)
774                 __attribute__ ((format (__printf__, 1, 2)));
775 /* stdin */
776 int     getc(void);
777 int     tstc(void);
778
779 /* stdout */
780 void    putc(const char c);
781 void    puts(const char *s);
782 int     printf(const char *fmt, ...)
783                 __attribute__ ((format (__printf__, 1, 2)));
784 int     vprintf(const char *fmt, va_list args);
785
786 /* stderr */
787 #define eputc(c)                fputc(stderr, c)
788 #define eputs(s)                fputs(stderr, s)
789 #define eprintf(fmt,args...)    fprintf(stderr,fmt ,##args)
790
791 /*
792  * FILE based functions (can only be used AFTER relocation!)
793  */
794 #define stdin           0
795 #define stdout          1
796 #define stderr          2
797 #define MAX_FILES       3
798
799 int     fprintf(int file, const char *fmt, ...)
800                 __attribute__ ((format (__printf__, 2, 3)));
801 void    fputs(int file, const char *s);
802 void    fputc(int file, const char c);
803 int     ftstc(int file);
804 int     fgetc(int file);
805
806 /* lib/gzip.c */
807 int gzip(void *dst, unsigned long *lenp,
808                 unsigned char *src, unsigned long srclen);
809 int zzip(void *dst, unsigned long *lenp, unsigned char *src,
810                 unsigned long srclen, int stoponerr,
811                 int (*func)(unsigned long, unsigned long));
812
813 /* lib/net_utils.c */
814 #include <net.h>
815 static inline IPaddr_t getenv_IPaddr(char *var)
816 {
817         return string_to_ip(getenv(var));
818 }
819
820 /*
821  * CONSOLE multiplexing.
822  */
823 #ifdef CONFIG_CONSOLE_MUX
824 #include <iomux.h>
825 #endif
826
827 int     pcmcia_init (void);
828
829 #ifdef CONFIG_STATUS_LED
830 # include <status_led.h>
831 #endif
832
833 #include <bootstage.h>
834
835 #ifdef CONFIG_SHOW_ACTIVITY
836 void show_activity(int arg);
837 #endif
838
839 /* Multicore arch functions */
840 #ifdef CONFIG_MP
841 int cpu_status(int nr);
842 int cpu_reset(int nr);
843 int cpu_disable(int nr);
844 int cpu_release(int nr, int argc, char * const argv[]);
845 #endif
846
847 /* Define a null map_sysmem() if the architecture doesn't use it */
848 # ifndef CONFIG_ARCH_MAP_SYSMEM
849 static inline void *map_sysmem(phys_addr_t paddr, unsigned long len)
850 {
851         return (void *)(uintptr_t)paddr;
852 }
853
854 static inline void unmap_sysmem(const void *vaddr)
855 {
856 }
857
858 static inline phys_addr_t map_to_sysmem(const void *ptr)
859 {
860         return (phys_addr_t)(uintptr_t)ptr;
861 }
862 # endif
863
864 #endif /* __ASSEMBLY__ */
865
866 #ifdef CONFIG_PPC
867 /*
868  * Has to be included outside of the #ifndef __ASSEMBLY__ section.
869  * Otherwise might lead to compilation errors in assembler files.
870  */
871 #include <asm/cache.h>
872 #endif
873
874 /* Put only stuff here that the assembler can digest */
875
876 #ifdef CONFIG_POST
877 #define CONFIG_HAS_POST
878 #ifndef CONFIG_POST_ALT_LIST
879 #define CONFIG_POST_STD_LIST
880 #endif
881 #endif
882
883 #ifdef CONFIG_INIT_CRITICAL
884 #error CONFIG_INIT_CRITICAL is deprecated!
885 #error Read section CONFIG_SKIP_LOWLEVEL_INIT in README.
886 #endif
887
888 #define ROUND(a,b)              (((a) + (b) - 1) & ~((b) - 1))
889
890 /*
891  * ARCH_DMA_MINALIGN is defined in asm/cache.h for each architecture.  It
892  * is used to align DMA buffers.
893  */
894 #ifndef __ASSEMBLY__
895 #include <asm/cache.h>
896 #endif
897
898 /*
899  * The ALLOC_CACHE_ALIGN_BUFFER macro is used to allocate a buffer on the
900  * stack that meets the minimum architecture alignment requirements for DMA.
901  * Such a buffer is useful for DMA operations where flushing and invalidating
902  * the cache before and after a read and/or write operation is required for
903  * correct operations.
904  *
905  * When called the macro creates an array on the stack that is sized such
906  * that:
907  *
908  * 1) The beginning of the array can be advanced enough to be aligned.
909  *
910  * 2) The size of the aligned portion of the array is a multiple of the minimum
911  *    architecture alignment required for DMA.
912  *
913  * 3) The aligned portion contains enough space for the original number of
914  *    elements requested.
915  *
916  * The macro then creates a pointer to the aligned portion of this array and
917  * assigns to the pointer the address of the first element in the aligned
918  * portion of the array.
919  *
920  * Calling the macro as:
921  *
922  *     ALLOC_CACHE_ALIGN_BUFFER(uint32_t, buffer, 1024);
923  *
924  * Will result in something similar to saying:
925  *
926  *     uint32_t    buffer[1024];
927  *
928  * The following differences exist:
929  *
930  * 1) The resulting buffer is guaranteed to be aligned to the value of
931  *    ARCH_DMA_MINALIGN.
932  *
933  * 2) The buffer variable created by the macro is a pointer to the specified
934  *    type, and NOT an array of the specified type.  This can be very important
935  *    if you want the address of the buffer, which you probably do, to pass it
936  *    to the DMA hardware.  The value of &buffer is different in the two cases.
937  *    In the macro case it will be the address of the pointer, not the address
938  *    of the space reserved for the buffer.  However, in the second case it
939  *    would be the address of the buffer.  So if you are replacing hard coded
940  *    stack buffers with this macro you need to make sure you remove the & from
941  *    the locations where you are taking the address of the buffer.
942  *
943  * Note that the size parameter is the number of array elements to allocate,
944  * not the number of bytes.
945  *
946  * This macro can not be used outside of function scope, or for the creation
947  * of a function scoped static buffer.  It can not be used to create a cache
948  * line aligned global buffer.
949  */
950 #define PAD_COUNT(s, pad) (((s) - 1) / (pad) + 1)
951 #define PAD_SIZE(s, pad) (PAD_COUNT(s, pad) * pad)
952 #define ALLOC_ALIGN_BUFFER_PAD(type, name, size, align, pad)            \
953         char __##name[ROUND(PAD_SIZE((size) * sizeof(type), pad), align)  \
954                       + (align - 1)];                                   \
955                                                                         \
956         type *name = (type *) ALIGN((uintptr_t)__##name, align)
957 #define ALLOC_ALIGN_BUFFER(type, name, size, align)             \
958         ALLOC_ALIGN_BUFFER_PAD(type, name, size, align, 1)
959 #define ALLOC_CACHE_ALIGN_BUFFER_PAD(type, name, size, pad)             \
960         ALLOC_ALIGN_BUFFER_PAD(type, name, size, ARCH_DMA_MINALIGN, pad)
961 #define ALLOC_CACHE_ALIGN_BUFFER(type, name, size)                      \
962         ALLOC_ALIGN_BUFFER(type, name, size, ARCH_DMA_MINALIGN)
963
964 /*
965  * DEFINE_CACHE_ALIGN_BUFFER() is similar to ALLOC_CACHE_ALIGN_BUFFER, but it's
966  * purpose is to allow allocating aligned buffers outside of function scope.
967  * Usage of this macro shall be avoided or used with extreme care!
968  */
969 #define DEFINE_ALIGN_BUFFER(type, name, size, align)                    \
970         static char __##name[roundup(size * sizeof(type), align)]       \
971                         __aligned(align);                               \
972                                                                         \
973         static type *name = (type *)__##name
974 #define DEFINE_CACHE_ALIGN_BUFFER(type, name, size)                     \
975         DEFINE_ALIGN_BUFFER(type, name, size, ARCH_DMA_MINALIGN)
976
977 /* Pull in stuff for the build system */
978 #ifdef DO_DEPS_ONLY
979 # include <environment.h>
980 #endif
981
982 #endif  /* __COMMON_H_ */