ARM: tegra: dvfs: Add interface to set fmax at vmin
[linux-3.10.git] / lib / string_helpers.c
1 /*
2  * Helpers for formatting and printing strings
3  *
4  * Copyright 31 August 2008 James Bottomley
5  * Copyright (C) 2013, Intel Corporation
6  */
7 #include <linux/kernel.h>
8 #include <linux/math64.h>
9 #include <linux/export.h>
10 #include <linux/ctype.h>
11 #include <linux/string_helpers.h>
12
13 /**
14  * string_get_size - get the size in the specified units
15  * @size:       The size to be converted
16  * @units:      units to use (powers of 1000 or 1024)
17  * @buf:        buffer to format to
18  * @len:        length of buffer
19  *
20  * This function returns a string formatted to 3 significant figures
21  * giving the size in the required units.  Returns 0 on success or
22  * error on failure.  @buf is always zero terminated.
23  *
24  */
25 int string_get_size(u64 size, const enum string_size_units units,
26                     char *buf, int len)
27 {
28         static const char *units_10[] = { "B", "kB", "MB", "GB", "TB", "PB",
29                                    "EB", "ZB", "YB", NULL};
30         static const char *units_2[] = {"B", "KiB", "MiB", "GiB", "TiB", "PiB",
31                                  "EiB", "ZiB", "YiB", NULL };
32         static const char **units_str[] = {
33                 [STRING_UNITS_10] =  units_10,
34                 [STRING_UNITS_2] = units_2,
35         };
36         static const unsigned int divisor[] = {
37                 [STRING_UNITS_10] = 1000,
38                 [STRING_UNITS_2] = 1024,
39         };
40         int i, j;
41         u64 remainder = 0, sf_cap;
42         char tmp[8];
43
44         tmp[0] = '\0';
45         i = 0;
46         if (size >= divisor[units]) {
47                 while (size >= divisor[units] && units_str[units][i]) {
48                         remainder = do_div(size, divisor[units]);
49                         i++;
50                 }
51
52                 sf_cap = size;
53                 for (j = 0; sf_cap*10 < 1000; j++)
54                         sf_cap *= 10;
55
56                 if (j) {
57                         remainder *= 1000;
58                         do_div(remainder, divisor[units]);
59                         snprintf(tmp, sizeof(tmp), ".%03lld",
60                                  (unsigned long long)remainder);
61                         tmp[j+1] = '\0';
62                 }
63         }
64
65         snprintf(buf, len, "%lld%s %s", (unsigned long long)size,
66                  tmp, units_str[units][i]);
67
68         return 0;
69 }
70 EXPORT_SYMBOL(string_get_size);
71
72 static bool unescape_space(char **src, char **dst)
73 {
74         char *p = *dst, *q = *src;
75
76         switch (*q) {
77         case 'n':
78                 *p = '\n';
79                 break;
80         case 'r':
81                 *p = '\r';
82                 break;
83         case 't':
84                 *p = '\t';
85                 break;
86         case 'v':
87                 *p = '\v';
88                 break;
89         case 'f':
90                 *p = '\f';
91                 break;
92         default:
93                 return false;
94         }
95         *dst += 1;
96         *src += 1;
97         return true;
98 }
99
100 static bool unescape_octal(char **src, char **dst)
101 {
102         char *p = *dst, *q = *src;
103         u8 num;
104
105         if (isodigit(*q) == 0)
106                 return false;
107
108         num = (*q++) & 7;
109         while (num < 32 && isodigit(*q) && (q - *src < 3)) {
110                 num <<= 3;
111                 num += (*q++) & 7;
112         }
113         *p = num;
114         *dst += 1;
115         *src = q;
116         return true;
117 }
118
119 static bool unescape_hex(char **src, char **dst)
120 {
121         char *p = *dst, *q = *src;
122         int digit;
123         u8 num;
124
125         if (*q++ != 'x')
126                 return false;
127
128         num = digit = hex_to_bin(*q++);
129         if (digit < 0)
130                 return false;
131
132         digit = hex_to_bin(*q);
133         if (digit >= 0) {
134                 q++;
135                 num = (num << 4) | digit;
136         }
137         *p = num;
138         *dst += 1;
139         *src = q;
140         return true;
141 }
142
143 static bool unescape_special(char **src, char **dst)
144 {
145         char *p = *dst, *q = *src;
146
147         switch (*q) {
148         case '\"':
149                 *p = '\"';
150                 break;
151         case '\\':
152                 *p = '\\';
153                 break;
154         case 'a':
155                 *p = '\a';
156                 break;
157         case 'e':
158                 *p = '\e';
159                 break;
160         default:
161                 return false;
162         }
163         *dst += 1;
164         *src += 1;
165         return true;
166 }
167
168 int string_unescape(char *src, char *dst, size_t size, unsigned int flags)
169 {
170         char *out = dst;
171
172         while (*src && --size) {
173                 if (src[0] == '\\' && src[1] != '\0' && size > 1) {
174                         src++;
175                         size--;
176
177                         if (flags & UNESCAPE_SPACE &&
178                                         unescape_space(&src, &out))
179                                 continue;
180
181                         if (flags & UNESCAPE_OCTAL &&
182                                         unescape_octal(&src, &out))
183                                 continue;
184
185                         if (flags & UNESCAPE_HEX &&
186                                         unescape_hex(&src, &out))
187                                 continue;
188
189                         if (flags & UNESCAPE_SPECIAL &&
190                                         unescape_special(&src, &out))
191                                 continue;
192
193                         *out++ = '\\';
194                 }
195                 *out++ = *src++;
196         }
197         *out = '\0';
198
199         return out - dst;
200 }
201 EXPORT_SYMBOL(string_unescape);