]> git.sur5r.net Git - u-boot/blob - include/vsprintf.h
rockchip: pinctrl: rk3399: add support for I2C[123467]
[u-boot] / include / vsprintf.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 __VSPRINTF_H
9 #define __VSPRINTF_H
10
11 #include <stdarg.h>
12 #include <linux/types.h>
13
14 ulong simple_strtoul(const char *cp, char **endp, unsigned int base);
15
16 /**
17  * strict_strtoul - convert a string to an unsigned long strictly
18  * @param cp    The string to be converted
19  * @param base  The number base to use
20  * @param res   The converted result value
21  * @return 0 if conversion is successful and *res is set to the converted
22  * value, otherwise it returns -EINVAL and *res is set to 0.
23  *
24  * strict_strtoul converts a string to an unsigned long only if the
25  * string is really an unsigned long string, any string containing
26  * any invalid char at the tail will be rejected and -EINVAL is returned,
27  * only a newline char at the tail is acceptible because people generally
28  * change a module parameter in the following way:
29  *
30  *      echo 1024 > /sys/module/e1000/parameters/copybreak
31  *
32  * echo will append a newline to the tail.
33  *
34  * simple_strtoul just ignores the successive invalid characters and
35  * return the converted value of prefix part of the string.
36  *
37  * Copied this function from Linux 2.6.38 commit ID:
38  * 521cb40b0c44418a4fd36dc633f575813d59a43d
39  *
40  */
41 int strict_strtoul(const char *cp, unsigned int base, unsigned long *res);
42 unsigned long long simple_strtoull(const char *cp, char **endp,
43                                         unsigned int base);
44 long simple_strtol(const char *cp, char **endp, unsigned int base);
45
46 /**
47  * trailing_strtol() - extract a trailing integer from a string
48  *
49  * Given a string this finds a trailing number on the string and returns it.
50  * For example, "abc123" would return 123.
51  *
52  * @str:        String to exxamine
53  * @return training number if found, else -1
54  */
55 long trailing_strtol(const char *str);
56
57 /**
58  * trailing_strtoln() - extract a trailing integer from a fixed-length string
59  *
60  * Given a fixed-length string this finds a trailing number on the string
61  * and returns it. For example, "abc123" would return 123. Only the
62  * characters between @str and @end - 1 are examined. If @end is NULL, it is
63  * set to str + strlen(str).
64  *
65  * @str:        String to exxamine
66  * @end:        Pointer to end of string to examine, or NULL to use the
67  *              whole string
68  * @return training number if found, else -1
69  */
70 long trailing_strtoln(const char *str, const char *end);
71
72 /**
73  * panic() - Print a message and reset/hang
74  *
75  * Prints a message on the console(s) and then resets. If CONFIG_PANIC_HANG is
76  * defined, then it will hang instead of resetting.
77  *
78  * @param fmt:  printf() format string for message, which should not include
79  *              \n, followed by arguments
80  */
81 void panic(const char *fmt, ...)
82                 __attribute__ ((format (__printf__, 1, 2), noreturn));
83
84 /**
85  * panic_str() - Print a message and reset/hang
86  *
87  * Prints a message on the console(s) and then resets. If CONFIG_PANIC_HANG is
88  * defined, then it will hang instead of resetting.
89  *
90  * This function can be used instead of panic() when your board does not
91  * already use printf(), * to keep code size small.
92  *
93  * @param fmt:  string to display, which should not include \n
94  */
95 void panic_str(const char *str) __attribute__ ((noreturn));
96
97 /**
98  * Format a string and place it in a buffer
99  *
100  * @param buf   The buffer to place the result into
101  * @param fmt   The format string to use
102  * @param ...   Arguments for the format string
103  *
104  * The function returns the number of characters written
105  * into @buf.
106  *
107  * See the vsprintf() documentation for format string extensions over C99.
108  */
109 int sprintf(char *buf, const char *fmt, ...)
110                 __attribute__ ((format (__printf__, 2, 3)));
111
112 /**
113  * Format a string and place it in a buffer (va_list version)
114  *
115  * @param buf   The buffer to place the result into
116  * @param fmt   The format string to use
117  * @param args  Arguments for the format string
118  * @return the number of characters which have been written into
119  * the @buf not including the trailing '\0'.
120  *
121  * If you're not already dealing with a va_list consider using scnprintf().
122  *
123  * See the vsprintf() documentation for format string extensions over C99.
124  */
125 int vsprintf(char *buf, const char *fmt, va_list args);
126 char *simple_itoa(ulong i);
127
128 /**
129  * Format a string and place it in a buffer
130  *
131  * @param buf   The buffer to place the result into
132  * @param size  The size of the buffer, including the trailing null space
133  * @param fmt   The format string to use
134  * @param ...   Arguments for the format string
135  * @return the number of characters which would be
136  * generated for the given input, excluding the trailing null,
137  * as per ISO C99.  If the return is greater than or equal to
138  * @size, the resulting string is truncated.
139  *
140  * See the vsprintf() documentation for format string extensions over C99.
141  */
142 int snprintf(char *buf, size_t size, const char *fmt, ...)
143                 __attribute__ ((format (__printf__, 3, 4)));
144
145 /**
146  * Format a string and place it in a buffer
147  *
148  * @param buf   The buffer to place the result into
149  * @param size  The size of the buffer, including the trailing null space
150  * @param fmt   The format string to use
151  * @param ...   Arguments for the format string
152  *
153  * The return value is the number of characters written into @buf not including
154  * the trailing '\0'. If @size is == 0 the function returns 0.
155  *
156  * See the vsprintf() documentation for format string extensions over C99.
157  */
158 int scnprintf(char *buf, size_t size, const char *fmt, ...)
159                 __attribute__ ((format (__printf__, 3, 4)));
160
161 /**
162  * Format a string and place it in a buffer (base function)
163  *
164  * @param buf   The buffer to place the result into
165  * @param size  The size of the buffer, including the trailing null space
166  * @param fmt   The format string to use
167  * @param args  Arguments for the format string
168  * @return The number characters which would be generated for the given
169  * input, excluding the trailing '\0', as per ISO C99. Note that fewer
170  * characters may be written if this number of characters is >= size.
171  *
172  * This function follows C99 vsnprintf, but has some extensions:
173  * %pS output the name of a text symbol
174  * %pF output the name of a function pointer
175  * %pR output the address range in a struct resource
176  *
177  * The function returns the number of characters which would be
178  * generated for the given input, excluding the trailing '\0',
179  * as per ISO C99.
180  *
181  * Call this function if you are already dealing with a va_list.
182  * You probably want snprintf() instead.
183  */
184 int vsnprintf(char *buf, size_t size, const char *fmt, va_list args);
185
186 /**
187  * Format a string and place it in a buffer (va_list version)
188  *
189  * @param buf   The buffer to place the result into
190  * @param size  The size of the buffer, including the trailing null space
191  * @param fmt   The format string to use
192  * @param args  Arguments for the format string
193  * @return the number of characters which have been written into
194  * the @buf not including the trailing '\0'. If @size is == 0 the function
195  * returns 0.
196  *
197  * If you're not already dealing with a va_list consider using scnprintf().
198  *
199  * See the vsprintf() documentation for format string extensions over C99.
200  */
201 int vscnprintf(char *buf, size_t size, const char *fmt, va_list args);
202
203 /**
204  * print_grouped_ull() - print a value with digits grouped by ','
205  *
206  * This prints a value with grouped digits, like 12,345,678 to make it easier
207  * to read.
208  *
209  * @val:        Value to print
210  * @digits:     Number of digiits to print
211  */
212 void print_grouped_ull(unsigned long long int_val, int digits);
213
214 bool str2off(const char *p, loff_t *num);
215 bool str2long(const char *p, ulong *num);
216 #endif