xref: /openbmc/u-boot/include/common.h (revision 0f44d33536a50ef65259c322fa2d4a058585caf9)
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  /* Allow sharing constants with type modifiers between C and assembly. */
19  #define _AC(X, Y)       (X##Y)
20  
21  #include <config.h>
22  #include <errno.h>
23  #include <time.h>
24  #include <asm-offsets.h>
25  #include <linux/bitops.h>
26  #include <linux/bug.h>
27  #include <linux/delay.h>
28  #include <linux/types.h>
29  #include <linux/printk.h>
30  #include <linux/string.h>
31  #include <linux/stringify.h>
32  #include <asm/ptrace.h>
33  #include <stdarg.h>
34  #include <stdio.h>
35  #include <linux/kernel.h>
36  
37  #include <part.h>
38  #include <flash.h>
39  #include <image.h>
40  
41  /* Bring in printf format macros if inttypes.h is included */
42  #define __STDC_FORMAT_MACROS
43  
44  #ifdef __LP64__
45  #define CONFIG_SYS_SUPPORT_64BIT_DATA
46  #endif
47  
48  #include <log.h>
49  
50  typedef void (interrupt_handler_t)(void *);
51  
52  #include <asm/u-boot.h> /* boot information for Linux kernel */
53  #include <asm/global_data.h>	/* global data used for startup functions */
54  
55  #if defined(CONFIG_ENV_IS_EMBEDDED)
56  #define TOTAL_MALLOC_LEN	CONFIG_SYS_MALLOC_LEN
57  #elif ( ((CONFIG_ENV_ADDR+CONFIG_ENV_SIZE) < CONFIG_SYS_MONITOR_BASE) || \
58  	(CONFIG_ENV_ADDR >= (CONFIG_SYS_MONITOR_BASE + CONFIG_SYS_MONITOR_LEN)) ) || \
59        defined(CONFIG_ENV_IS_IN_NVRAM)
60  #define	TOTAL_MALLOC_LEN	(CONFIG_SYS_MALLOC_LEN + CONFIG_ENV_SIZE)
61  #else
62  #define	TOTAL_MALLOC_LEN	CONFIG_SYS_MALLOC_LEN
63  #endif
64  
65  /*
66   * Function Prototypes
67   */
68  int dram_init(void);
69  
70  /**
71   * dram_init_banksize() - Set up DRAM bank sizes
72   *
73   * This can be implemented by boards to set up the DRAM bank information in
74   * gd->bd->bi_dram(). It is called just before relocation, after dram_init()
75   * is called.
76   *
77   * If this is not provided, a default implementation will try to set up a
78   * single bank. It will do this if CONFIG_NR_DRAM_BANKS and
79   * CONFIG_SYS_SDRAM_BASE are set. The bank will have a start address of
80   * CONFIG_SYS_SDRAM_BASE and the size will be determined by a call to
81   * get_effective_memsize().
82   *
83   * @return 0 if OK, -ve on error
84   */
85  int dram_init_banksize(void);
86  
87  void	hang		(void) __attribute__ ((noreturn));
88  
89  int	timer_init(void);
90  int	cpu_init(void);
91  
92  #include <display_options.h>
93  
94  /* common/main.c */
95  void	main_loop	(void);
96  int run_command(const char *cmd, int flag);
97  int run_command_repeatable(const char *cmd, int flag);
98  
99  /**
100   * Run a list of commands separated by ; or even \0
101   *
102   * Note that if 'len' is not -1, then the command does not need to be nul
103   * terminated, Memory will be allocated for the command in that case.
104   *
105   * @param cmd	List of commands to run, each separated bu semicolon
106   * @param len	Length of commands excluding terminator if known (-1 if not)
107   * @param flag	Execution flags (CMD_FLAG_...)
108   * @return 0 on success, or != 0 on error.
109   */
110  int run_command_list(const char *cmd, int len, int flag);
111  
112  /* arch/$(ARCH)/lib/board.c */
113  void board_init_f(ulong);
114  void board_init_r(gd_t *, ulong) __attribute__ ((noreturn));
115  
116  /**
117   * ulong board_init_f_alloc_reserve - allocate reserved area
118   *
119   * This function is called by each architecture very early in the start-up
120   * code to allow the C runtime to reserve space on the stack for writable
121   * 'globals' such as GD and the malloc arena.
122   *
123   * @top:	top of the reserve area, growing down.
124   * @return:	bottom of reserved area
125   */
126  ulong board_init_f_alloc_reserve(ulong top);
127  
128  /**
129   * board_init_f_init_reserve - initialize the reserved area(s)
130   *
131   * This function is called once the C runtime has allocated the reserved
132   * area on the stack. It must initialize the GD at the base of that area.
133   *
134   * @base:	top from which reservation was done
135   */
136  void board_init_f_init_reserve(ulong base);
137  
138  /**
139   * arch_setup_gd() - Set up the global_data pointer
140   *
141   * This pointer is special in some architectures and cannot easily be assigned
142   * to. For example on x86 it is implemented by adding a specific record to its
143   * Global Descriptor Table! So we we provide a function to carry out this task.
144   * For most architectures this can simply be:
145   *
146   *    gd = gd_ptr;
147   *
148   * @gd_ptr:	Pointer to global data
149   */
150  void arch_setup_gd(gd_t *gd_ptr);
151  
152  int checkboard(void);
153  int show_board_info(void);
154  int checkflash(void);
155  int checkdram(void);
156  int last_stage_init(void);
157  extern ulong monitor_flash_len;
158  int mac_read_from_eeprom(void);
159  extern u8 __dtb_dt_begin[];	/* embedded device tree blob */
160  extern u8 __dtb_dt_spl_begin[];	/* embedded device tree blob for SPL/TPL */
161  int set_cpu_clk_info(void);
162  int mdm_init(void);
163  int print_cpuinfo(void);
164  int update_flash_size(int flash_size);
165  int arch_early_init_r(void);
166  
167  /*
168   * setup_board_extra() - Fill in extra details in the bd_t structure
169   *
170   * @return 0 if OK, -ve on error
171   */
172  int setup_board_extra(void);
173  
174  /**
175   * arch_fsp_init() - perform firmware support package init
176   *
177   * Where U-Boot relies on binary blobs to handle part of the system init, this
178   * function can be used to set up the blobs. This is used on some Intel
179   * platforms.
180   */
181  int arch_fsp_init(void);
182  
183  /**
184   * arch_cpu_init_dm() - init CPU after driver model is available
185   *
186   * This is called immediately after driver model is available before
187   * relocation. This is similar to arch_cpu_init() but is able to reference
188   * devices
189   *
190   * @return 0 if OK, -ve on error
191   */
192  int arch_cpu_init_dm(void);
193  
194  /**
195   * Reserve all necessary stacks
196   *
197   * This is used in generic board init sequence in common/board_f.c. Each
198   * architecture could provide this function to tailor the required stacks.
199   *
200   * On entry gd->start_addr_sp is pointing to the suggested top of the stack.
201   * The callee ensures gd->start_add_sp is 16-byte aligned, so architectures
202   * require only this can leave it untouched.
203   *
204   * On exit gd->start_addr_sp and gd->irq_sp should be set to the respective
205   * positions of the stack. The stack pointer(s) will be set to this later.
206   * gd->irq_sp is only required, if the architecture needs it.
207   *
208   * @return 0 if no error
209   */
210  __weak int arch_reserve_stacks(void);
211  
212  /**
213   * Show the DRAM size in a board-specific way
214   *
215   * This is used by boards to display DRAM information in their own way.
216   *
217   * @param size	Size of DRAM (which should be displayed along with other info)
218   */
219  void board_show_dram(phys_size_t size);
220  
221  /**
222   * arch_fixup_fdt() - Write arch-specific information to fdt
223   *
224   * Defined in arch/$(ARCH)/lib/bootm-fdt.c
225   *
226   * @blob:	FDT blob to write to
227   * @return 0 if ok, or -ve FDT_ERR_... on failure
228   */
229  int arch_fixup_fdt(void *blob);
230  
231  int reserve_mmu(void);
232  /* common/flash.c */
233  void flash_perror (int);
234  
235  /* common/cmd_source.c */
236  int	source (ulong addr, const char *fit_uname);
237  
238  extern ulong load_addr;		/* Default Load Address */
239  extern ulong save_addr;		/* Default Save Address */
240  extern ulong save_size;		/* Default Save Size */
241  
242  /* common/cmd_net.c */
243  int do_tftpb(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
244  
245  /* common/cmd_fat.c */
246  int do_fat_fsload(cmd_tbl_t *, int, int, char * const []);
247  
248  /* common/cmd_ext2.c */
249  int do_ext2load(cmd_tbl_t *, int, int, char * const []);
250  
251  /* common/cmd_nvedit.c */
252  int	env_init     (void);
253  void	env_relocate (void);
254  int	envmatch     (uchar *, int);
255  
256  /**
257   * env_get() - Look up the value of an environment variable
258   *
259   * In U-Boot proper this can be called before relocation (which is when the
260   * environment is loaded from storage, i.e. GD_FLG_ENV_READY is 0). In that
261   * case this function calls env_get_f().
262   *
263   * @varname:	Variable to look up
264   * @return value of variable, or NULL if not found
265   */
266  char *env_get(const char *varname);
267  
268  /**
269   * env_get_f() - Look up the value of an environment variable (early)
270   *
271   * This function is called from env_get() if the environment has not been
272   * loaded yet (GD_FLG_ENV_READY flag is 0). Some environment locations will
273   * support reading the value (slowly) and some will not.
274   *
275   * @varname:	Variable to look up
276   * @return value of variable, or NULL if not found
277   */
278  int env_get_f(const char *name, char *buf, unsigned len);
279  
280  /**
281   * env_get_ulong() - Return an environment variable as an integer value
282   *
283   * Most U-Boot environment variables store hex values. For those which store
284   * (e.g.) base-10 integers, this function can be used to read the value.
285   *
286   * @name:	Variable to look up
287   * @base:	Base to use (e.g. 10 for base 10, 2 for binary)
288   * @default_val: Default value to return if no value is found
289   * @return the value found, or @default_val if none
290   */
291  ulong env_get_ulong(const char *name, int base, ulong default_val);
292  
293  /**
294   * env_get_hex() - Return an environment variable as a hex value
295   *
296   * Decode an environment as a hex number (it may or may not have a 0x
297   * prefix). If the environment variable cannot be found, or does not start
298   * with hex digits, the default value is returned.
299   *
300   * @varname:		Variable to decode
301   * @default_val:	Value to return on error
302   */
303  ulong env_get_hex(const char *varname, ulong default_val);
304  
305  /*
306   * Read an environment variable as a boolean
307   * Return -1 if variable does not exist (default to true)
308   */
309  int env_get_yesno(const char *var);
310  
311  /**
312   * env_set() - set an environment variable
313   *
314   * This sets or deletes the value of an environment variable. For setting the
315   * value the variable is created if it does not already exist.
316   *
317   * @varname: Variable to adjust
318   * @value: Value to set for the variable, or NULL or "" to delete the variable
319   * @return 0 if OK, 1 on error
320   */
321  int env_set(const char *varname, const char *value);
322  
323  /**
324   * env_set_ulong() - set an environment variable to an integer
325   *
326   * @varname: Variable to adjust
327   * @value: Value to set for the variable (will be converted to a string)
328   * @return 0 if OK, 1 on error
329   */
330  int env_set_ulong(const char *varname, ulong value);
331  
332  /**
333   * env_set_hex() - set an environment variable to a hex value
334   *
335   * @varname: Variable to adjust
336   * @value: Value to set for the variable (will be converted to a hex string)
337   * @return 0 if OK, 1 on error
338   */
339  int env_set_hex(const char *varname, ulong value);
340  
341  /**
342   * env_set_addr - Set an environment variable to an address in hex
343   *
344   * @varname:	Environment variable to set
345   * @addr:	Value to set it to
346   * @return 0 if ok, 1 on error
347   */
348  static inline int env_set_addr(const char *varname, const void *addr)
349  {
350  	return env_set_hex(varname, (ulong)addr);
351  }
352  
353  #ifdef CONFIG_AUTO_COMPLETE
354  int env_complete(char *var, int maxv, char *cmdv[], int maxsz, char *buf);
355  #endif
356  int get_env_id (void);
357  
358  void	pci_init      (void);
359  void	pci_init_board(void);
360  
361  #if defined(CONFIG_DTB_RESELECT)
362  int	embedded_dtb_select(void);
363  #endif
364  
365  int	misc_init_f   (void);
366  int	misc_init_r   (void);
367  #if defined(CONFIG_VID)
368  int	init_func_vid(void);
369  #endif
370  
371  /* common/exports.c */
372  void	jumptable_init(void);
373  
374  /* common/kallsysm.c */
375  const char *symbol_lookup(unsigned long addr, unsigned long *caddr);
376  
377  /* common/memsize.c */
378  long	get_ram_size  (long *, long);
379  phys_size_t get_effective_memsize(void);
380  
381  /* $(BOARD)/$(BOARD).c */
382  void	reset_phy     (void);
383  void	fdc_hw_init   (void);
384  
385  /* $(BOARD)/eeprom.c */
386  #ifdef CONFIG_CMD_EEPROM
387  void eeprom_init  (int bus);
388  int  eeprom_read  (unsigned dev_addr, unsigned offset, uchar *buffer, unsigned cnt);
389  int  eeprom_write (unsigned dev_addr, unsigned offset, uchar *buffer, unsigned cnt);
390  #else
391  /*
392   * Some EEPROM code is depecated because it used the legacy I2C interface. Add
393   * some macros here so we don't have to touch every one of those uses
394   */
395  #define eeprom_init(bus)
396  #define eeprom_read(dev_addr, offset, buffer, cnt) ((void)-ENOSYS)
397  #define eeprom_write(dev_addr, offset, buffer, cnt) ((void)-ENOSYS)
398  #endif
399  
400  /*
401   * Set this up regardless of board
402   * type, to prevent errors.
403   */
404  #if defined(CONFIG_SPI) || !defined(CONFIG_SYS_I2C_EEPROM_ADDR)
405  # define CONFIG_SYS_DEF_EEPROM_ADDR 0
406  #else
407  #if !defined(CONFIG_ENV_EEPROM_IS_ON_I2C)
408  # define CONFIG_SYS_DEF_EEPROM_ADDR CONFIG_SYS_I2C_EEPROM_ADDR
409  #endif
410  #endif /* CONFIG_SPI || !defined(CONFIG_SYS_I2C_EEPROM_ADDR) */
411  
412  #if defined(CONFIG_SPI)
413  extern void spi_init_f (void);
414  extern void spi_init_r (void);
415  extern ssize_t spi_read	 (uchar *, int, uchar *, int);
416  extern ssize_t spi_write (uchar *, int, uchar *, int);
417  #endif
418  
419  /* $(BOARD)/$(BOARD).c */
420  int board_early_init_f (void);
421  int board_fix_fdt (void *rw_fdt_blob); /* manipulate the U-Boot fdt before its relocation */
422  int board_late_init (void);
423  int board_postclk_init (void); /* after clocks/timebase, before env/serial */
424  int board_early_init_r (void);
425  void board_poweroff (void);
426  
427  #if defined(CONFIG_SYS_DRAM_TEST)
428  int testdram(void);
429  #endif /* CONFIG_SYS_DRAM_TEST */
430  
431  /* $(CPU)/start.S */
432  int	icache_status (void);
433  void	icache_enable (void);
434  void	icache_disable(void);
435  int	dcache_status (void);
436  void	dcache_enable (void);
437  void	dcache_disable(void);
438  void	mmu_disable(void);
439  #if defined(CONFIG_ARM)
440  void	relocate_code(ulong);
441  #else
442  void	relocate_code(ulong, gd_t *, ulong) __attribute__ ((noreturn));
443  #endif
444  ulong	get_endaddr   (void);
445  void	trap_init     (ulong);
446  
447  /* $(CPU)/cpu.c */
448  static inline int cpumask_next(int cpu, unsigned int mask)
449  {
450  	for (cpu++; !((1 << cpu) & mask); cpu++)
451  		;
452  
453  	return cpu;
454  }
455  
456  #define for_each_cpu(iter, cpu, num_cpus, mask) \
457  	for (iter = 0, cpu = cpumask_next(-1, mask); \
458  		iter < num_cpus; \
459  		iter++, cpu = cpumask_next(cpu, mask)) \
460  
461  int	cpu_numcores  (void);
462  int	cpu_num_dspcores(void);
463  u32	cpu_mask      (void);
464  u32	cpu_dsp_mask(void);
465  int	is_core_valid (unsigned int);
466  
467  /**
468   * arch_cpu_init() - basic cpu-dependent setup for an architecture
469   *
470   * This is called after early malloc is available. It should handle any
471   * CPU- or SoC- specific init needed to continue the init sequence. See
472   * board_f.c for where it is called. If this is not provided, a default
473   * version (which does nothing) will be used.
474   */
475  int arch_cpu_init(void);
476  
477  void s_init(void);
478  
479  int	checkcpu      (void);
480  int	checkicache   (void);
481  int	checkdcache   (void);
482  void	upmconfig     (unsigned int, unsigned int *, unsigned int);
483  ulong	get_tbclk     (void);
484  void	reset_misc    (void);
485  void	reset_cpu     (ulong addr);
486  void ft_cpu_setup(void *blob, bd_t *bd);
487  void ft_pci_setup(void *blob, bd_t *bd);
488  
489  void smp_set_core_boot_addr(unsigned long addr, int corenr);
490  void smp_kick_all_cpus(void);
491  
492  /* $(CPU)/serial.c */
493  int	serial_init   (void);
494  void	serial_setbrg (void);
495  void	serial_putc   (const char);
496  void	serial_putc_raw(const char);
497  void	serial_puts   (const char *);
498  int	serial_getc   (void);
499  int	serial_tstc   (void);
500  
501  /* $(CPU)/speed.c */
502  int	get_clocks (void);
503  ulong	get_bus_freq  (ulong);
504  int get_serial_clock(void);
505  
506  int	cpu_init_r    (void);
507  
508  /* $(CPU)/interrupts.c */
509  int	interrupt_init	   (void);
510  void	timer_interrupt	   (struct pt_regs *);
511  void	external_interrupt (struct pt_regs *);
512  void	irq_install_handler(int, interrupt_handler_t *, void *);
513  void	irq_free_handler   (int);
514  void	reset_timer	   (void);
515  
516  /* Return value of monotonic microsecond timer */
517  unsigned long timer_get_us(void);
518  
519  void	enable_interrupts  (void);
520  int	disable_interrupts (void);
521  
522  /* $(CPU)/.../commproc.c */
523  int	dpram_init (void);
524  uint	dpram_base(void);
525  uint	dpram_base_align(uint align);
526  uint	dpram_alloc(uint size);
527  uint	dpram_alloc_align(uint size,uint align);
528  void	bootcount_store (ulong);
529  ulong	bootcount_load (void);
530  #define BOOTCOUNT_MAGIC		0xB001C041
531  
532  /* $(CPU)/.../<eth> */
533  void mii_init (void);
534  
535  /* $(CPU)/.../lcd.c */
536  ulong	lcd_setmem (ulong);
537  
538  /* $(CPU)/.../video.c */
539  ulong	video_setmem (ulong);
540  
541  /* arch/$(ARCH)/lib/cache.c */
542  void	enable_caches(void);
543  void	flush_cache   (unsigned long, unsigned long);
544  void	flush_dcache_all(void);
545  void	flush_dcache_range(unsigned long start, unsigned long stop);
546  void	invalidate_dcache_range(unsigned long start, unsigned long stop);
547  void	invalidate_dcache_all(void);
548  void	invalidate_icache_all(void);
549  
550  enum {
551  	/* Disable caches (else flush caches but leave them active) */
552  	CBL_DISABLE_CACHES		= 1 << 0,
553  	CBL_SHOW_BOOTSTAGE_REPORT	= 1 << 1,
554  
555  	CBL_ALL				= 3,
556  };
557  
558  /**
559   * Clean up ready for linux
560   *
561   * @param flags		Flags to control what is done
562   */
563  int cleanup_before_linux_select(int flags);
564  
565  /* arch/$(ARCH)/lib/ticks.S */
566  uint64_t get_ticks(void);
567  void	wait_ticks    (unsigned long);
568  
569  /* arch/$(ARCH)/lib/time.c */
570  ulong	usec2ticks    (unsigned long usec);
571  ulong	ticks2usec    (unsigned long ticks);
572  
573  /* lib/gunzip.c */
574  int gzip_parse_header(const unsigned char *src, unsigned long len);
575  int gunzip(void *, int, unsigned char *, unsigned long *);
576  int zunzip(void *dst, int dstlen, unsigned char *src, unsigned long *lenp,
577  						int stoponerr, int offset);
578  
579  /**
580   * gzwrite progress indicators: defined weak to allow board-specific
581   * overrides:
582   *
583   *	gzwrite_progress_init called on startup
584   *	gzwrite_progress called during decompress/write loop
585   *	gzwrite_progress_finish called at end of loop to
586   *		indicate success (retcode=0) or failure
587   */
588  void gzwrite_progress_init(u64 expected_size);
589  
590  void gzwrite_progress(int iteration,
591  		     u64 bytes_written,
592  		     u64 total_bytes);
593  
594  void gzwrite_progress_finish(int retcode,
595  			     u64 totalwritten,
596  			     u64 totalsize,
597  			     u32 expected_crc,
598  			     u32 calculated_crc);
599  
600  /**
601   * decompress and write gzipped image from memory to block device
602   *
603   * @param	src		compressed image address
604   * @param	len		compressed image length in bytes
605   * @param	dev		block device descriptor
606   * @param	szwritebuf	bytes per write (pad to erase size)
607   * @param	startoffs	offset in bytes of first write
608   * @param	szexpected	expected uncompressed length
609   *				may be zero to use gzip trailer
610   *				for files under 4GiB
611   */
612  int gzwrite(unsigned char *src, int len,
613  	    struct blk_desc *dev,
614  	    unsigned long szwritebuf,
615  	    u64 startoffs,
616  	    u64 szexpected);
617  
618  /* lib/lz4_wrapper.c */
619  int ulz4fn(const void *src, size_t srcn, void *dst, size_t *dstn);
620  
621  /* lib/qsort.c */
622  void qsort(void *base, size_t nmemb, size_t size,
623  	   int(*compar)(const void *, const void *));
624  int strcmp_compar(const void *, const void *);
625  
626  /* lib/uuid.c */
627  #include <uuid.h>
628  
629  /* lib/vsprintf.c */
630  #include <vsprintf.h>
631  
632  /* lib/strmhz.c */
633  char *	strmhz(char *buf, unsigned long hz);
634  
635  /* lib/crc32.c */
636  #include <u-boot/crc.h>
637  
638  /* lib/rand.c */
639  #define RAND_MAX -1U
640  void srand(unsigned int seed);
641  unsigned int rand(void);
642  unsigned int rand_r(unsigned int *seedp);
643  
644  /*
645   * STDIO based functions (can always be used)
646   */
647  /* serial stuff */
648  int	serial_printf (const char *fmt, ...)
649  		__attribute__ ((format (__printf__, 1, 2)));
650  
651  /* lib/gzip.c */
652  int gzip(void *dst, unsigned long *lenp,
653  		unsigned char *src, unsigned long srclen);
654  int zzip(void *dst, unsigned long *lenp, unsigned char *src,
655  		unsigned long srclen, int stoponerr,
656  		int (*func)(unsigned long, unsigned long));
657  
658  /* lib/net_utils.c */
659  #include <net.h>
660  static inline struct in_addr env_get_ip(char *var)
661  {
662  	return string_to_ip(env_get(var));
663  }
664  
665  int	pcmcia_init (void);
666  
667  #ifdef CONFIG_LED_STATUS
668  # include <status_led.h>
669  #endif
670  
671  #include <bootstage.h>
672  
673  #ifdef CONFIG_SHOW_ACTIVITY
674  void show_activity(int arg);
675  #endif
676  
677  /* Multicore arch functions */
678  #ifdef CONFIG_MP
679  int cpu_status(int nr);
680  int cpu_reset(int nr);
681  int cpu_disable(int nr);
682  int cpu_release(int nr, int argc, char * const argv[]);
683  #endif
684  
685  #else	/* __ASSEMBLY__ */
686  
687  /* Drop a C type modifier (like in 3UL) for constants used in assembly. */
688  #define _AC(X, Y)       X
689  
690  #endif	/* __ASSEMBLY__ */
691  
692  /* Put only stuff here that the assembler can digest */
693  
694  /* Declare an unsigned long constant digestable both by C and an assembler. */
695  #define UL(x)           _AC(x, UL)
696  
697  #ifdef CONFIG_POST
698  #define CONFIG_HAS_POST
699  #ifndef CONFIG_POST_ALT_LIST
700  #define CONFIG_POST_STD_LIST
701  #endif
702  #endif
703  
704  #ifdef CONFIG_INIT_CRITICAL
705  #error CONFIG_INIT_CRITICAL is deprecated!
706  #error Read section CONFIG_SKIP_LOWLEVEL_INIT in README.
707  #endif
708  
709  #define ROUND(a,b)		(((a) + (b) - 1) & ~((b) - 1))
710  
711  /*
712   * check_member() - Check the offset of a structure member
713   *
714   * @structure:	Name of structure (e.g. global_data)
715   * @member:	Name of member (e.g. baudrate)
716   * @offset:	Expected offset in bytes
717   */
718  #define check_member(structure, member, offset) _Static_assert( \
719  	offsetof(struct structure, member) == offset, \
720  	"`struct " #structure "` offset for `" #member "` is not " #offset)
721  
722  /* Avoid using CONFIG_EFI_STUB directly as we may boot from other loaders */
723  #ifdef CONFIG_EFI_STUB
724  #define ll_boot_init()	false
725  #else
726  #define ll_boot_init()	true
727  #endif
728  
729  /* Pull in stuff for the build system */
730  #ifdef DO_DEPS_ONLY
731  # include <environment.h>
732  #endif
733  
734  #endif	/* __COMMON_H_ */
735