DEBUG: Fix debug macros
[karo-tx-uboot.git] / include / common.h
1 /*
2  * (C) Copyright 2000-2009
3  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
4  *
5  * See file CREDITS for list of people who contributed to this
6  * project.
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License as
10  * published by the Free Software Foundation; either version 2 of
11  * the License, or (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
21  * MA 02111-1307 USA
22  */
23
24 #ifndef __COMMON_H_
25 #define __COMMON_H_     1
26
27 #undef  _LINUX_CONFIG_H
28 #define _LINUX_CONFIG_H 1       /* avoid reading Linux autoconf.h file  */
29
30 #ifndef __ASSEMBLY__            /* put C only stuff in this section */
31
32 typedef unsigned char           uchar;
33 typedef volatile unsigned long  vu_long;
34 typedef volatile unsigned short vu_short;
35 typedef volatile unsigned char  vu_char;
36
37 #include <config.h>
38 #include <asm-offsets.h>
39 #include <linux/bitops.h>
40 #include <linux/types.h>
41 #include <linux/string.h>
42 #include <asm/ptrace.h>
43 #include <stdarg.h>
44 #if defined(CONFIG_PCI) && (defined(CONFIG_4xx) && !defined(CONFIG_AP1000))
45 #include <pci.h>
46 #endif
47 #if defined(CONFIG_8xx)
48 #include <asm/8xx_immap.h>
49 #if defined(CONFIG_MPC852)      || defined(CONFIG_MPC852T)      || \
50     defined(CONFIG_MPC859)      || defined(CONFIG_MPC859T)      || \
51     defined(CONFIG_MPC859DSL)   || \
52     defined(CONFIG_MPC866)      || defined(CONFIG_MPC866T)      || \
53     defined(CONFIG_MPC866P)
54 # define CONFIG_MPC866_FAMILY 1
55 #elif defined(CONFIG_MPC870) \
56    || defined(CONFIG_MPC875) \
57    || defined(CONFIG_MPC880) \
58    || defined(CONFIG_MPC885)
59 # define CONFIG_MPC885_FAMILY   1
60 #endif
61 #if   defined(CONFIG_MPC860)       \
62    || defined(CONFIG_MPC860T)      \
63    || defined(CONFIG_MPC866_FAMILY) \
64    || defined(CONFIG_MPC885_FAMILY)
65 # define CONFIG_MPC86x 1
66 #endif
67 #elif defined(CONFIG_5xx)
68 #include <asm/5xx_immap.h>
69 #elif defined(CONFIG_MPC5xxx)
70 #include <mpc5xxx.h>
71 #elif defined(CONFIG_MPC512X)
72 #include <asm/immap_512x.h>
73 #elif defined(CONFIG_MPC8220)
74 #include <asm/immap_8220.h>
75 #elif defined(CONFIG_8260)
76 #if   defined(CONFIG_MPC8247) \
77    || defined(CONFIG_MPC8248) \
78    || defined(CONFIG_MPC8271) \
79    || defined(CONFIG_MPC8272)
80 #define CONFIG_MPC8272_FAMILY   1
81 #endif
82 #if defined(CONFIG_MPC8272_FAMILY)
83 #define CONFIG_MPC8260  1
84 #endif
85 #include <asm/immap_8260.h>
86 #endif
87 #ifdef CONFIG_MPC86xx
88 #include <mpc86xx.h>
89 #include <asm/immap_86xx.h>
90 #endif
91 #ifdef CONFIG_MPC85xx
92 #include <mpc85xx.h>
93 #include <asm/immap_85xx.h>
94 #endif
95 #ifdef CONFIG_MPC83xx
96 #include <mpc83xx.h>
97 #include <asm/immap_83xx.h>
98 #endif
99 #ifdef  CONFIG_4xx
100 #include <asm/ppc4xx.h>
101 #endif
102 #ifdef CONFIG_HYMOD
103 #include <board/hymod/hymod.h>
104 #endif
105 #ifdef CONFIG_ARM
106 #define asmlinkage      /* nothing */
107 #endif
108 #ifdef CONFIG_BLACKFIN
109 #include <asm/blackfin.h>
110 #endif
111 #ifdef CONFIG_SOC_DA8XX
112 #include <asm/arch/hardware.h>
113 #endif
114
115 #include <part.h>
116 #include <flash.h>
117 #include <image.h>
118
119 #ifdef DEBUG
120 #define _DEBUG  1
121 #else
122 #define _DEBUG  0
123 #endif
124
125 /*
126  * Output a debug text when condition "cond" is met. The "cond" should be
127  * computed by a preprocessor in the best case, allowing for the best
128  * optimization.
129  */
130 #define debug_cond(cond, fmt, args...)          \
131         do {                                    \
132                 if (cond)                       \
133                         printf(fmt, ##args);    \
134         } while (0)
135
136 #define debug(fmt, args...)                     \
137         debug_cond(_DEBUG, fmt, ##args)
138
139 /*
140  * An assertion is run-time check done in debug mode only. If DEBUG is not
141  * defined then it is skipped. If DEBUG is defined and the assertion fails,
142  * then it calls panic*( which may or may not reset/halt U-Boot (see
143  * CONFIG_PANIC_HANG), It is hoped that all failing assertions are found
144  * before release, and after release it is hoped that they don't matter. But
145  * in any case these failing assertions cannot be fixed with a reset (which
146  * may just do the same assertion again).
147  */
148 void __assert_fail(const char *assertion, const char *file, unsigned line,
149                    const char *function);
150 #define assert(x) \
151         ({ if (!(x) && _DEBUG) \
152                 __assert_fail(#x, __FILE__, __LINE__, __func__); })
153
154 #define error(fmt, args...) do {                                        \
155                 printf("ERROR: " fmt "\nat %s:%d/%s()\n",               \
156                         ##args, __FILE__, __LINE__, __func__);          \
157 } while (0)
158
159 #ifndef BUG
160 #define BUG() do { \
161         printf("BUG: failure at %s:%d/%s()!\n", __FILE__, __LINE__, __FUNCTION__); \
162         panic("BUG!"); \
163 } while (0)
164 #define BUG_ON(condition) do { if (unlikely((condition)!=0)) BUG(); } while(0)
165 #endif /* BUG */
166
167 /* Force a compilation error if condition is true */
168 #define BUILD_BUG_ON(condition) ((void)sizeof(char[1 - 2*!!(condition)]))
169
170 typedef void (interrupt_handler_t)(void *);
171
172 #include <asm/u-boot.h> /* boot information for Linux kernel */
173 #include <asm/global_data.h>    /* global data used for startup functions */
174
175 /*
176  * enable common handling for all TQM8xxL/M boards:
177  * - CONFIG_TQM8xxM will be defined for all TQM8xxM boards
178  * - CONFIG_TQM8xxL will be defined for all TQM8xxL _and_ TQM8xxM boards
179  *                  and for the TQM885D board
180  */
181 #if defined(CONFIG_TQM823M) || defined(CONFIG_TQM850M) || \
182     defined(CONFIG_TQM855M) || defined(CONFIG_TQM860M) || \
183     defined(CONFIG_TQM862M) || defined(CONFIG_TQM866M)
184 # ifndef CONFIG_TQM8xxM
185 #  define CONFIG_TQM8xxM
186 # endif
187 #endif
188 #if defined(CONFIG_TQM823L) || defined(CONFIG_TQM850L) || \
189     defined(CONFIG_TQM855L) || defined(CONFIG_TQM860L) || \
190     defined(CONFIG_TQM862L) || defined(CONFIG_TQM8xxM) || \
191     defined(CONFIG_TQM885D)
192 # ifndef CONFIG_TQM8xxL
193 #  define CONFIG_TQM8xxL
194 # endif
195 #endif
196
197 #ifndef CONFIG_SERIAL_MULTI
198
199 #if defined(CONFIG_8xx_CONS_SMC1) || defined(CONFIG_8xx_CONS_SMC2) \
200  || defined(CONFIG_8xx_CONS_SCC1) || defined(CONFIG_8xx_CONS_SCC2) \
201  || defined(CONFIG_8xx_CONS_SCC3) || defined(CONFIG_8xx_CONS_SCC4)
202
203 #define CONFIG_SERIAL_MULTI     1
204
205 #endif
206
207 #endif /* CONFIG_SERIAL_MULTI */
208
209 /*
210  * General Purpose Utilities
211  */
212 #define min(X, Y)                               \
213         ({ typeof (X) __x = (X);                \
214                 typeof (Y) __y = (Y);           \
215                 (__x < __y) ? __x : __y; })
216
217 #define max(X, Y)                               \
218         ({ typeof (X) __x = (X);                \
219                 typeof (Y) __y = (Y);           \
220                 (__x > __y) ? __x : __y; })
221
222 #define MIN(x, y)  min(x, y)
223 #define MAX(x, y)  max(x, y)
224
225 #if defined(CONFIG_ENV_IS_EMBEDDED)
226 #define TOTAL_MALLOC_LEN        CONFIG_SYS_MALLOC_LEN
227 #elif ( ((CONFIG_ENV_ADDR+CONFIG_ENV_SIZE) < CONFIG_SYS_MONITOR_BASE) || \
228         (CONFIG_ENV_ADDR >= (CONFIG_SYS_MONITOR_BASE + CONFIG_SYS_MONITOR_LEN)) ) || \
229       defined(CONFIG_ENV_IS_IN_NVRAM)
230 #define TOTAL_MALLOC_LEN        (CONFIG_SYS_MALLOC_LEN + CONFIG_ENV_SIZE)
231 #else
232 #define TOTAL_MALLOC_LEN        CONFIG_SYS_MALLOC_LEN
233 #endif
234
235 /**
236  * container_of - cast a member of a structure out to the containing structure
237  * @ptr:        the pointer to the member.
238  * @type:       the type of the container struct this is embedded in.
239  * @member:     the name of the member within the struct.
240  *
241  */
242 #define container_of(ptr, type, member) ({                      \
243         const typeof( ((type *)0)->member ) *__mptr = (ptr);    \
244         (type *)( (char *)__mptr - offsetof(type,member) );})
245
246 /*
247  * Function Prototypes
248  */
249
250 void    hang            (void) __attribute__ ((noreturn));
251
252 int     timer_init(void);
253 int     cpu_init(void);
254
255 /* */
256 phys_size_t initdram (int);
257 int     display_options (void);
258 void    print_size(unsigned long long, const char *);
259 int     print_buffer (ulong addr, void* data, uint width, uint count, uint linelen);
260
261 /* common/main.c */
262 void    main_loop       (void);
263 int     run_command     (const char *cmd, int flag);
264 #ifdef CONFIG_CMD_PXE
265 int run_command2(const char *cmd, int flag);
266 #endif
267 int     readline        (const char *const prompt);
268 int     readline_into_buffer    (const char *const prompt, char * buffer);
269 int     parse_line (char *, char *[]);
270 void    init_cmd_timeout(void);
271 void    reset_cmd_timeout(void);
272 #ifdef CONFIG_MENU
273 int     abortboot(int bootdelay);
274 #endif
275
276 /* arch/$(ARCH)/lib/board.c */
277 void    board_init_f  (ulong) __attribute__ ((noreturn));
278 void    board_init_r  (gd_t *, ulong) __attribute__ ((noreturn));
279 int     checkboard    (void);
280 int     checkflash    (void);
281 int     checkdram     (void);
282 int     last_stage_init(void);
283 extern ulong monitor_flash_len;
284 int mac_read_from_eeprom(void);
285 extern u8 _binary_dt_dtb_start[];       /* embedded device tree blob */
286
287 /* common/flash.c */
288 void flash_perror (int);
289
290 /* common/cmd_source.c */
291 int     source (ulong addr, const char *fit_uname);
292
293 extern ulong load_addr;         /* Default Load Address */
294 extern ulong save_addr;         /* Default Save Address */
295 extern ulong save_size;         /* Default Save Size */
296
297 /* common/cmd_doc.c */
298 void    doc_probe(unsigned long physadr);
299
300 /* common/cmd_net.c */
301 int do_tftpb(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
302
303 /* common/cmd_nvedit.c */
304 int     env_init     (void);
305 void    env_relocate (void);
306 int     envmatch     (uchar *, int);
307 char    *getenv      (const char *);
308 int     getenv_f     (const char *name, char *buf, unsigned len);
309 ulong getenv_ulong(const char *name, int base, ulong default_val);
310 int     saveenv      (void);
311 #ifdef CONFIG_PPC               /* ARM version to be fixed! */
312 int inline setenv    (const char *, const char *);
313 #else
314 int     setenv       (const char *, const char *);
315 int setenv_ulong(const char *varname, ulong value);
316 int setenv_addr(const char *varname, const void *addr);
317 #endif /* CONFIG_PPC */
318 #ifdef CONFIG_ARM
319 # include <asm/mach-types.h>
320 # include <asm/setup.h>
321 # include <asm/u-boot-arm.h>    /* ARM version to be fixed! */
322 #endif /* CONFIG_ARM */
323 #ifdef CONFIG_X86               /* x86 version to be fixed! */
324 # include <asm/u-boot-x86.h>
325 #endif /* CONFIG_X86 */
326 #ifdef CONFIG_SANDBOX
327 # include <asm/u-boot-sandbox.h>        /* TODO(sjg) what needs to be fixed? */
328 #endif
329 #ifdef CONFIG_NDS32
330 # include <asm/mach-types.h>
331 # include <asm/u-boot-nds32.h>
332 #endif /* CONFIG_NDS32 */
333
334 #ifdef CONFIG_AUTO_COMPLETE
335 int env_complete(char *var, int maxv, char *cmdv[], int maxsz, char *buf);
336 #endif
337 int get_env_id (void);
338
339 void    pci_init      (void);
340 void    pci_init_board(void);
341 void    pciinfo       (int, int);
342
343 #if defined(CONFIG_PCI) && (defined(CONFIG_4xx) && !defined(CONFIG_AP1000))
344     int    pci_pre_init        (struct pci_controller *);
345     int    is_pci_host         (struct pci_controller *);
346 #endif
347
348 #if defined(CONFIG_PCI) && (defined(CONFIG_440) || defined(CONFIG_405EX))
349 #   if defined(CONFIG_SYS_PCI_TARGET_INIT)
350         void    pci_target_init      (struct pci_controller *);
351 #   endif
352 #   if defined(CONFIG_SYS_PCI_MASTER_INIT)
353         void    pci_master_init      (struct pci_controller *);
354 #   endif
355 #if defined(CONFIG_440SPE) || \
356     defined(CONFIG_460EX) || defined(CONFIG_460GT) || \
357     defined(CONFIG_405EX)
358    void pcie_setup_hoses(int busno);
359 #endif
360 #endif
361
362 int     misc_init_f   (void);
363 int     misc_init_r   (void);
364
365 /* common/exports.c */
366 void    jumptable_init(void);
367
368 /* common/kallsysm.c */
369 const char *symbol_lookup(unsigned long addr, unsigned long *caddr);
370
371 /* api/api.c */
372 void    api_init (void);
373
374 /* common/memsize.c */
375 long    get_ram_size  (long *, long);
376
377 /* $(BOARD)/$(BOARD).c */
378 void    reset_phy     (void);
379 void    fdc_hw_init   (void);
380
381 /* $(BOARD)/eeprom.c */
382 void eeprom_init  (void);
383 #ifndef CONFIG_SPI
384 int  eeprom_probe (unsigned dev_addr, unsigned offset);
385 #endif
386 int  eeprom_read  (unsigned dev_addr, unsigned offset, uchar *buffer, unsigned cnt);
387 int  eeprom_write (unsigned dev_addr, unsigned offset, uchar *buffer, unsigned cnt);
388 #ifdef CONFIG_LWMON
389 extern uchar pic_read  (uchar reg);
390 extern void  pic_write (uchar reg, uchar val);
391 #endif
392
393 /*
394  * Set this up regardless of board
395  * type, to prevent errors.
396  */
397 #if defined(CONFIG_SPI) || !defined(CONFIG_SYS_I2C_EEPROM_ADDR)
398 # define CONFIG_SYS_DEF_EEPROM_ADDR 0
399 #else
400 #if !defined(CONFIG_ENV_EEPROM_IS_ON_I2C)
401 # define CONFIG_SYS_DEF_EEPROM_ADDR CONFIG_SYS_I2C_EEPROM_ADDR
402 #endif
403 #endif /* CONFIG_SPI || !defined(CONFIG_SYS_I2C_EEPROM_ADDR) */
404
405 #if defined(CONFIG_SPI)
406 extern void spi_init_f (void);
407 extern void spi_init_r (void);
408 extern ssize_t spi_read  (uchar *, int, uchar *, int);
409 extern ssize_t spi_write (uchar *, int, uchar *, int);
410 #endif
411
412 #ifdef CONFIG_RPXCLASSIC
413 void rpxclassic_init (void);
414 #endif
415
416 void rpxlite_init (void);
417
418 #ifdef CONFIG_MBX
419 /* $(BOARD)/mbx8xx.c */
420 void    mbx_init (void);
421 void    board_serial_init (void);
422 void    board_ether_init (void);
423 #endif
424
425 #ifdef CONFIG_HERMES
426 /* $(BOARD)/hermes.c */
427 void hermes_start_lxt980 (int speed);
428 #endif
429
430 #ifdef CONFIG_EVB64260
431 void  evb64260_init(void);
432 void  debug_led(int, int);
433 void  display_mem_map(void);
434 void  perform_soft_reset(void);
435 #endif
436
437 /* $(BOARD)/$(BOARD).c */
438 int board_early_init_f (void);
439 int board_late_init (void);
440 int board_postclk_init (void); /* after clocks/timebase, before env/serial */
441 int board_early_init_r (void);
442 void board_poweroff (void);
443
444 #if defined(CONFIG_SYS_DRAM_TEST)
445 int testdram(void);
446 #endif /* CONFIG_SYS_DRAM_TEST */
447
448 /* $(CPU)/start.S */
449 #if defined(CONFIG_5xx) || \
450     defined(CONFIG_8xx)
451 uint    get_immr      (uint);
452 #endif
453 uint    get_pir       (void);
454 #if defined(CONFIG_MPC5xxx)
455 uint    get_svr       (void);
456 #endif
457 uint    get_pvr       (void);
458 uint    get_svr       (void);
459 uint    rd_ic_cst     (void);
460 void    wr_ic_cst     (uint);
461 void    wr_ic_adr     (uint);
462 uint    rd_dc_cst     (void);
463 void    wr_dc_cst     (uint);
464 void    wr_dc_adr     (uint);
465 int     icache_status (void);
466 void    icache_enable (void);
467 void    icache_disable(void);
468 int     dcache_status (void);
469 void    dcache_enable (void);
470 void    dcache_disable(void);
471 void    mmu_disable(void);
472 void    relocate_code (ulong, gd_t *, ulong) __attribute__ ((noreturn));
473 ulong   get_endaddr   (void);
474 void    trap_init     (ulong);
475 #if defined (CONFIG_4xx)        || \
476     defined (CONFIG_MPC5xxx)    || \
477     defined (CONFIG_74xx_7xx)   || \
478     defined (CONFIG_74x)        || \
479     defined (CONFIG_75x)        || \
480     defined (CONFIG_74xx)       || \
481     defined (CONFIG_MPC8220)    || \
482     defined (CONFIG_MPC85xx)    || \
483     defined (CONFIG_MPC86xx)    || \
484     defined (CONFIG_MPC83xx)
485 unsigned char   in8(unsigned int);
486 void            out8(unsigned int, unsigned char);
487 unsigned short  in16(unsigned int);
488 unsigned short  in16r(unsigned int);
489 void            out16(unsigned int, unsigned short value);
490 void            out16r(unsigned int, unsigned short value);
491 unsigned long   in32(unsigned int);
492 unsigned long   in32r(unsigned int);
493 void            out32(unsigned int, unsigned long value);
494 void            out32r(unsigned int, unsigned long value);
495 void            ppcDcbf(unsigned long value);
496 void            ppcDcbi(unsigned long value);
497 void            ppcSync(void);
498 void            ppcDcbz(unsigned long value);
499 #endif
500 #if defined (CONFIG_MICROBLAZE)
501 unsigned short  in16(unsigned int);
502 void            out16(unsigned int, unsigned short value);
503 #endif
504
505 #if defined (CONFIG_MPC83xx)
506 void            ppcDWload(unsigned int *addr, unsigned int *ret);
507 void            ppcDWstore(unsigned int *addr, unsigned int *value);
508 void disable_addr_trans(void);
509 void enable_addr_trans(void);
510 #if defined(CONFIG_DDR_ECC) && !defined(CONFIG_ECC_INIT_VIA_DDRCONTROLLER)
511 void ddr_enable_ecc(unsigned int dram_size);
512 #endif
513 #endif
514
515 /* $(CPU)/cpu.c */
516 static inline int cpumask_next(int cpu, unsigned int mask)
517 {
518         for (cpu++; !((1 << cpu) & mask); cpu++)
519                 ;
520
521         return cpu;
522 }
523
524 #define for_each_cpu(iter, cpu, num_cpus, mask) \
525         for (iter = 0, cpu = cpumask_next(-1, mask); \
526                 iter < num_cpus; \
527                 iter++, cpu = cpumask_next(cpu, mask)) \
528
529 int     cpu_numcores  (void);
530 u32     cpu_mask      (void);
531 int     is_core_valid (unsigned int);
532 int     probecpu      (void);
533 int     checkcpu      (void);
534 int     checkicache   (void);
535 int     checkdcache   (void);
536 void    upmconfig     (unsigned int, unsigned int *, unsigned int);
537 ulong   get_tbclk     (void);
538 void    reset_cpu     (ulong addr);
539 #if defined (CONFIG_OF_LIBFDT) && defined (CONFIG_OF_BOARD_SETUP)
540 void ft_cpu_setup(void *blob, bd_t *bd);
541 #ifdef CONFIG_PCI
542 void ft_pci_setup(void *blob, bd_t *bd);
543 #endif
544 #endif
545
546
547 /* $(CPU)/serial.c */
548 int     serial_init   (void);
549 void    serial_setbrg (void);
550 void    serial_putc   (const char);
551 void    serial_putc_raw(const char);
552 void    serial_puts   (const char *);
553 int     serial_getc   (void);
554 int     serial_tstc   (void);
555
556 void    _serial_setbrg (const int);
557 void    _serial_putc   (const char, const int);
558 void    _serial_putc_raw(const char, const int);
559 void    _serial_puts   (const char *, const int);
560 int     _serial_getc   (const int);
561 int     _serial_tstc   (const int);
562
563 /* $(CPU)/speed.c */
564 int     get_clocks (void);
565 int     get_clocks_866 (void);
566 int     sdram_adjust_866 (void);
567 int     adjust_sdram_tbs_8xx (void);
568 #if defined(CONFIG_8260)
569 int     prt_8260_clks (void);
570 #elif defined(CONFIG_MPC5xxx)
571 int     prt_mpc5xxx_clks (void);
572 #endif
573 #if defined(CONFIG_MPC512X)
574 int     prt_mpc512xxx_clks (void);
575 #endif
576 #if defined(CONFIG_MPC8220)
577 int     prt_mpc8220_clks (void);
578 #endif
579 #ifdef CONFIG_4xx
580 ulong   get_OPB_freq (void);
581 ulong   get_PCI_freq (void);
582 #endif
583 #if defined(CONFIG_S3C24X0) || \
584     defined(CONFIG_LH7A40X) || \
585     defined(CONFIG_S3C6400) || \
586     defined(CONFIG_EP93XX)
587 ulong   get_FCLK (void);
588 ulong   get_HCLK (void);
589 ulong   get_PCLK (void);
590 ulong   get_UCLK (void);
591 #endif
592 #if defined(CONFIG_LH7A40X)
593 ulong   get_PLLCLK (void);
594 #endif
595 #if defined CONFIG_INCA_IP
596 uint    incaip_get_cpuclk (void);
597 #endif
598 #if defined(CONFIG_IMX)
599 ulong get_systemPLLCLK(void);
600 ulong get_FCLK(void);
601 ulong get_HCLK(void);
602 ulong get_BCLK(void);
603 ulong get_PERCLK1(void);
604 ulong get_PERCLK2(void);
605 ulong get_PERCLK3(void);
606 #endif
607 ulong   get_bus_freq  (ulong);
608 int get_serial_clock(void);
609
610 #if defined(CONFIG_MPC83xx) || defined(CONFIG_MPC85xx)
611 ulong get_ddr_freq(ulong);
612 #endif
613 #if defined(CONFIG_MPC85xx)
614 typedef MPC85xx_SYS_INFO sys_info_t;
615 void    get_sys_info  ( sys_info_t * );
616 #endif
617 #if defined(CONFIG_MPC86xx)
618 typedef MPC86xx_SYS_INFO sys_info_t;
619 void   get_sys_info  ( sys_info_t * );
620 static inline ulong get_ddr_freq(ulong dummy)
621 {
622         return get_bus_freq(dummy);
623 }
624 #endif
625
626 #if defined(CONFIG_4xx) || defined(CONFIG_IOP480)
627 #  if defined(CONFIG_440)
628 #       if defined(CONFIG_440SPE)
629          unsigned long determine_sysper(void);
630          unsigned long determine_pci_clock_per(void);
631 #       endif
632 #  endif
633 typedef PPC4xx_SYS_INFO sys_info_t;
634 int     ppc440spe_revB(void);
635 void    get_sys_info  ( sys_info_t * );
636 #endif
637
638 /* $(CPU)/cpu_init.c */
639 #if defined(CONFIG_8xx) || defined(CONFIG_8260)
640 void    cpu_init_f    (volatile immap_t *immr);
641 #endif
642 #if defined(CONFIG_4xx) || defined(CONFIG_MPC85xx) || defined(CONFIG_MCF52x2) ||defined(CONFIG_MPC86xx)
643 void    cpu_init_f    (void);
644 #endif
645
646 int     cpu_init_r    (void);
647 #if defined(CONFIG_8260)
648 int     prt_8260_rsr  (void);
649 #elif defined(CONFIG_MPC83xx)
650 int     prt_83xx_rsr  (void);
651 #endif
652
653 /* $(CPU)/interrupts.c */
654 int     interrupt_init     (void);
655 void    timer_interrupt    (struct pt_regs *);
656 void    external_interrupt (struct pt_regs *);
657 void    irq_install_handler(int, interrupt_handler_t *, void *);
658 void    irq_free_handler   (int);
659 void    reset_timer        (void);
660 ulong   get_timer          (ulong base);
661 void    enable_interrupts  (void);
662 int     disable_interrupts (void);
663
664 /* $(CPU)/.../commproc.c */
665 int     dpram_init (void);
666 uint    dpram_base(void);
667 uint    dpram_base_align(uint align);
668 uint    dpram_alloc(uint size);
669 uint    dpram_alloc_align(uint size,uint align);
670 void    bootcount_store (ulong);
671 ulong   bootcount_load (void);
672 #define BOOTCOUNT_MAGIC         0xB001C041
673
674 /* $(CPU)/.../<eth> */
675 void mii_init (void);
676
677 /* $(CPU)/.../lcd.c */
678 ulong   lcd_setmem (ulong);
679
680 /* $(CPU)/.../video.c */
681 ulong   video_setmem (ulong);
682
683 /* arch/$(ARCH)/lib/cache.c */
684 void    enable_caches(void);
685 void    flush_cache   (unsigned long, unsigned long);
686 void    flush_dcache_all(void);
687 void    flush_dcache_range(unsigned long start, unsigned long stop);
688 void    invalidate_dcache_range(unsigned long start, unsigned long stop);
689 void    invalidate_dcache_all(void);
690 void    invalidate_icache_all(void);
691
692 /* arch/$(ARCH)/lib/ticks.S */
693 unsigned long long get_ticks(void);
694 void    wait_ticks    (unsigned long);
695
696 /* arch/$(ARCH)/lib/time.c */
697 void    __udelay      (unsigned long);
698 ulong   usec2ticks    (unsigned long usec);
699 ulong   ticks2usec    (unsigned long ticks);
700 int     init_timebase (void);
701
702 /* lib/gunzip.c */
703 int gunzip(void *, int, unsigned char *, unsigned long *);
704 int zunzip(void *dst, int dstlen, unsigned char *src, unsigned long *lenp,
705                                                 int stoponerr, int offset);
706
707 /* lib/net_utils.c */
708 #include <net.h>
709 static inline IPaddr_t getenv_IPaddr (char *var)
710 {
711         return (string_to_ip(getenv(var)));
712 }
713
714 /* lib/qsort.c */
715 void qsort(void *base, size_t nmemb, size_t size,
716            int(*compar)(const void *, const void *));
717 int strcmp_compar(const void *, const void *);
718
719 /* lib/time.c */
720 void    udelay        (unsigned long);
721 void mdelay(unsigned long);
722
723 /* lib/uuid.c */
724 void uuid_str_to_bin(const char *uuid, unsigned char *out);
725 int uuid_str_valid(const char *uuid);
726
727 /* lib/vsprintf.c */
728 ulong   simple_strtoul(const char *cp,char **endp,unsigned int base);
729 int strict_strtoul(const char *cp, unsigned int base, unsigned long *res);
730 unsigned long long      simple_strtoull(const char *cp,char **endp,unsigned int base);
731 long    simple_strtol(const char *cp,char **endp,unsigned int base);
732 void    panic(const char *fmt, ...)
733                 __attribute__ ((format (__printf__, 1, 2), noreturn));
734 int     sprintf(char * buf, const char *fmt, ...)
735                 __attribute__ ((format (__printf__, 2, 3)));
736 int     vsprintf(char *buf, const char *fmt, va_list args);
737 char *simple_itoa(ulong i);
738
739 /* lib/strmhz.c */
740 char *  strmhz(char *buf, unsigned long hz);
741
742 /* lib/crc32.c */
743 #include <u-boot/crc.h>
744
745 /* common/console.c */
746 int     console_init_f(void);   /* Before relocation; uses the serial  stuff    */
747 int     console_init_r(void);   /* After  relocation; uses the console stuff    */
748 int     console_assign(int file, const char *devname);  /* Assign the console   */
749 int     ctrlc (void);
750 int     had_ctrlc (void);       /* have we had a Control-C since last clear? */
751 void    clear_ctrlc (void);     /* clear the Control-C condition */
752 int     disable_ctrlc (int);    /* 1 to disable, 0 to enable Control-C detect */
753
754 /*
755  * STDIO based functions (can always be used)
756  */
757 /* serial stuff */
758 int     serial_printf (const char *fmt, ...)
759                 __attribute__ ((format (__printf__, 1, 2)));
760 /* stdin */
761 int     getc(void);
762 int     tstc(void);
763
764 /* stdout */
765 void    putc(const char c);
766 void    puts(const char *s);
767 int     printf(const char *fmt, ...)
768                 __attribute__ ((format (__printf__, 1, 2)));
769 int     vprintf(const char *fmt, va_list args);
770
771 /* stderr */
772 #define eputc(c)                fputc(stderr, c)
773 #define eputs(s)                fputs(stderr, s)
774 #define eprintf(fmt,args...)    fprintf(stderr,fmt ,##args)
775
776 /*
777  * FILE based functions (can only be used AFTER relocation!)
778  */
779 #define stdin           0
780 #define stdout          1
781 #define stderr          2
782 #define MAX_FILES       3
783
784 int     fprintf(int file, const char *fmt, ...)
785                 __attribute__ ((format (__printf__, 2, 3)));
786 void    fputs(int file, const char *s);
787 void    fputc(int file, const char c);
788 int     ftstc(int file);
789 int     fgetc(int file);
790
791 /*
792  * CONSOLE multiplexing.
793  */
794 #ifdef CONFIG_CONSOLE_MUX
795 #include <iomux.h>
796 #endif
797
798 int     pcmcia_init (void);
799
800 #ifdef CONFIG_STATUS_LED
801 # include <status_led.h>
802 #endif
803 /*
804  * Board-specific Platform code can reimplement show_boot_progress () if needed
805  */
806 void show_boot_progress(int val);
807
808 /* Multicore arch functions */
809 #ifdef CONFIG_MP
810 int cpu_status(int nr);
811 int cpu_reset(int nr);
812 int cpu_disable(int nr);
813 int cpu_release(int nr, int argc, char * const argv[]);
814 #endif
815
816 #endif /* __ASSEMBLY__ */
817
818 #ifdef CONFIG_PPC
819 /*
820  * Has to be included outside of the #ifndef __ASSEMBLY__ section.
821  * Otherwise might lead to compilation errors in assembler files.
822  */
823 #include <asm/cache.h>
824 #endif
825
826 /* Put only stuff here that the assembler can digest */
827
828 #ifdef CONFIG_POST
829 #define CONFIG_HAS_POST
830 #ifndef CONFIG_POST_ALT_LIST
831 #define CONFIG_POST_STD_LIST
832 #endif
833 #endif
834
835 #ifdef CONFIG_INIT_CRITICAL
836 #error CONFIG_INIT_CRITICAL is deprecated!
837 #error Read section CONFIG_SKIP_LOWLEVEL_INIT in README.
838 #endif
839
840 #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
841
842 #define ROUND(a,b)              (((a) + (b) - 1) & ~((b) - 1))
843 #define DIV_ROUND(n,d)          (((n) + ((d)/2)) / (d))
844 #define DIV_ROUND_UP(n,d)       (((n) + (d) - 1) / (d))
845 #define roundup(x, y)           ((((x) + ((y) - 1)) / (y)) * (y))
846
847 #define ALIGN(x,a)              __ALIGN_MASK((x),(typeof(x))(a)-1)
848 #define __ALIGN_MASK(x,mask)    (((x)+(mask))&~(mask))
849
850 /*
851  * ARCH_DMA_MINALIGN is defined in asm/cache.h for each architecture.  It
852  * is used to align DMA buffers.
853  */
854 #ifndef __ASSEMBLY__
855 #include <asm/cache.h>
856 #endif
857
858 /*
859  * The ALLOC_CACHE_ALIGN_BUFFER macro is used to allocate a buffer on the
860  * stack that meets the minimum architecture alignment requirements for DMA.
861  * Such a buffer is useful for DMA operations where flushing and invalidating
862  * the cache before and after a read and/or write operation is required for
863  * correct operations.
864  *
865  * When called the macro creates an array on the stack that is sized such
866  * that:
867  *
868  * 1) The beginning of the array can be advanced enough to be aligned.
869  *
870  * 2) The size of the aligned portion of the array is a multiple of the minimum
871  *    architecture alignment required for DMA.
872  *
873  * 3) The aligned portion contains enough space for the original number of
874  *    elements requested.
875  *
876  * The macro then creates a pointer to the aligned portion of this array and
877  * assigns to the pointer the address of the first element in the aligned
878  * portion of the array.
879  *
880  * Calling the macro as:
881  *
882  *     ALLOC_CACHE_ALIGN_BUFFER(uint32_t, buffer, 1024);
883  *
884  * Will result in something similar to saying:
885  *
886  *     uint32_t    buffer[1024];
887  *
888  * The following differences exist:
889  *
890  * 1) The resulting buffer is guaranteed to be aligned to the value of
891  *    ARCH_DMA_MINALIGN.
892  *
893  * 2) The buffer variable created by the macro is a pointer to the specified
894  *    type, and NOT an array of the specified type.  This can be very important
895  *    if you want the address of the buffer, which you probably do, to pass it
896  *    to the DMA hardware.  The value of &buffer is different in the two cases.
897  *    In the macro case it will be the address of the pointer, not the address
898  *    of the space reserved for the buffer.  However, in the second case it
899  *    would be the address of the buffer.  So if you are replacing hard coded
900  *    stack buffers with this macro you need to make sure you remove the & from
901  *    the locations where you are taking the address of the buffer.
902  *
903  * Note that the size parameter is the number of array elements to allocate,
904  * not the number of bytes.
905  *
906  * This macro can not be used outside of function scope, or for the creation
907  * of a function scoped static buffer.  It can not be used to create a cache
908  * line aligned global buffer.
909  */
910 #define ALLOC_CACHE_ALIGN_BUFFER(type, name, size)                      \
911         char __##name[ROUND(size * sizeof(type), ARCH_DMA_MINALIGN) +   \
912                       ARCH_DMA_MINALIGN - 1];                           \
913                                                                         \
914         type *name = (type *) ALIGN((uintptr_t)__##name, ARCH_DMA_MINALIGN)
915
916 /* Pull in stuff for the build system */
917 #ifdef DO_DEPS_ONLY
918 # include <environment.h>
919 #endif
920
921 #endif  /* __COMMON_H_ */