projects/linux·blob master · refs

380 lines · 6.4 KiB

1// SPDX-License-Identifier: GPL-2.0
2/*
3 BlueZ - Bluetooth protocol stack for Linux
4 Copyright (C) 2000-2001 Qualcomm Incorporated
5
6 Written 2000,2001 by Maxim Krasnyansky <[email protected]>
7
8 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
9 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
10 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
11 IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
12 CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
13 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16
17 ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
18 COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
19 SOFTWARE IS DISCLAIMED.
20*/
21
22/* Bluetooth kernel library. */
23
24#define pr_fmt(fmt) "Bluetooth: " fmt
25
26#include <linux/export.h>
27
28#include <net/bluetooth/bluetooth.h>
29
30/**
31 * baswap() - Swaps the order of a bd address
32 * @dst: Pointer to a bdaddr_t struct that will store the swapped
33 * bd address.
34 * @src: Pointer to the bdaddr_t struct to be swapped.
35 *
36 * This function reverses the byte order of a Bluetooth device
37 * address.
38 */
39void baswap(bdaddr_t *dst, const bdaddr_t *src)
40{
41 const unsigned char *s = (const unsigned char *)src;
42 unsigned char *d = (unsigned char *)dst;
43 unsigned int i;
44
45 for (i = 0; i < 6; i++)
46 d[i] = s[5 - i];
47}
48EXPORT_SYMBOL(baswap);
49
50/**
51 * bt_to_errno() - Bluetooth error codes to standard errno
52 * @code: Bluetooth error code to be converted
53 *
54 * This function takes a Bluetooth error code as input and converts
55 * it to an equivalent Unix/standard errno value.
56 *
57 * Return:
58 *
59 * If the bt error code is known, an equivalent Unix errno value
60 * is returned.
61 * If the given bt error code is not known, ENOSYS is returned.
62 */
63int bt_to_errno(__u16 code)
64{
65 switch (code) {
66 case 0:
67 return 0;
68
69 case 0x01:
70 return EBADRQC;
71
72 case 0x02:
73 return ENOTCONN;
74
75 case 0x03:
76 return EIO;
77
78 case 0x04:
79 case 0x3c:
80 return EHOSTDOWN;
81
82 case 0x05:
83 return EACCES;
84
85 case 0x06:
86 return EBADE;
87
88 case 0x07:
89 return ENOMEM;
90
91 case 0x08:
92 return ETIMEDOUT;
93
94 case 0x09:
95 return EMLINK;
96
97 case 0x0a:
98 return EMLINK;
99
100 case 0x0b:
101 return EALREADY;
102
103 case 0x0c:
104 return EBUSY;
105
106 case 0x0d:
107 case 0x0e:
108 case 0x0f:
109 return ECONNREFUSED;
110
111 case 0x10:
112 return ETIMEDOUT;
113
114 case 0x11:
115 case 0x27:
116 case 0x29:
117 case 0x20:
118 return EOPNOTSUPP;
119
120 case 0x12:
121 return EINVAL;
122
123 case 0x13:
124 case 0x14:
125 case 0x15:
126 return ECONNRESET;
127
128 case 0x16:
129 return ECONNABORTED;
130
131 case 0x17:
132 return ELOOP;
133
134 case 0x18:
135 return EACCES;
136
137 case 0x1a:
138 return EPROTONOSUPPORT;
139
140 case 0x1b:
141 return ECONNREFUSED;
142
143 case 0x19:
144 case 0x1e:
145 case 0x23:
146 case 0x24:
147 case 0x25:
148 return EPROTO;
149
150 default:
151 return ENOSYS;
152 }
153}
154EXPORT_SYMBOL(bt_to_errno);
155
156/**
157 * bt_status() - Standard errno value to Bluetooth error code
158 * @err: Unix/standard errno value to be converted
159 *
160 * This function converts a standard/Unix errno value to an
161 * equivalent Bluetooth error code.
162 *
163 * Return: Bluetooth error code.
164 *
165 * If the given errno is not found, 0x1f is returned by default
166 * which indicates an unspecified error.
167 * For err >= 0, no conversion is performed, and the same value
168 * is immediately returned.
169 */
170__u8 bt_status(int err)
171{
172 if (err >= 0)
173 return err;
174
175 switch (err) {
176 case -EBADRQC:
177 return 0x01;
178
179 case -ENOTCONN:
180 return 0x02;
181
182 case -EIO:
183 return 0x03;
184
185 case -EHOSTDOWN:
186 return 0x04;
187
188 case -EACCES:
189 return 0x05;
190
191 case -EBADE:
192 return 0x06;
193
194 case -ENOMEM:
195 return 0x07;
196
197 case -ETIMEDOUT:
198 return 0x08;
199
200 case -EMLINK:
201 return 0x09;
202
203 case -EALREADY:
204 return 0x0b;
205
206 case -EBUSY:
207 return 0x0c;
208
209 case -ECONNREFUSED:
210 return 0x0d;
211
212 case -EOPNOTSUPP:
213 return 0x11;
214
215 case -EINVAL:
216 return 0x12;
217
218 case -ECONNRESET:
219 return 0x13;
220
221 case -ECONNABORTED:
222 return 0x16;
223
224 case -ELOOP:
225 return 0x17;
226
227 case -EPROTONOSUPPORT:
228 return 0x1a;
229
230 case -EPROTO:
231 return 0x19;
232
233 default:
234 return 0x1f;
235 }
236}
237EXPORT_SYMBOL(bt_status);
238
239/**
240 * bt_info() - Log Bluetooth information message
241 * @format: Message's format string
242 */
243void bt_info(const char *format, ...)
244{
245 struct va_format vaf;
246 va_list args;
247
248 va_start(args, format);
249
250 vaf.fmt = format;
251 vaf.va = &args;
252
253 pr_info("%pV", &vaf);
254
255 va_end(args);
256}
257EXPORT_SYMBOL(bt_info);
258
259/**
260 * bt_warn() - Log Bluetooth warning message
261 * @format: Message's format string
262 */
263void bt_warn(const char *format, ...)
264{
265 struct va_format vaf;
266 va_list args;
267
268 va_start(args, format);
269
270 vaf.fmt = format;
271 vaf.va = &args;
272
273 pr_warn("%pV", &vaf);
274
275 va_end(args);
276}
277EXPORT_SYMBOL(bt_warn);
278
279/**
280 * bt_err() - Log Bluetooth error message
281 * @format: Message's format string
282 */
283void bt_err(const char *format, ...)
284{
285 struct va_format vaf;
286 va_list args;
287
288 va_start(args, format);
289
290 vaf.fmt = format;
291 vaf.va = &args;
292
293 pr_err("%pV", &vaf);
294
295 va_end(args);
296}
297EXPORT_SYMBOL(bt_err);
298
299#ifdef CONFIG_BT_FEATURE_DEBUG
300static bool debug_enable;
301
302void bt_dbg_set(bool enable)
303{
304 debug_enable = enable;
305}
306
307bool bt_dbg_get(void)
308{
309 return debug_enable;
310}
311
312/**
313 * bt_dbg() - Log Bluetooth debugging message
314 * @format: Message's format string
315 */
316void bt_dbg(const char *format, ...)
317{
318 struct va_format vaf;
319 va_list args;
320
321 if (likely(!debug_enable))
322 return;
323
324 va_start(args, format);
325
326 vaf.fmt = format;
327 vaf.va = &args;
328
329 printk(KERN_DEBUG pr_fmt("%pV"), &vaf);
330
331 va_end(args);
332}
333EXPORT_SYMBOL(bt_dbg);
334#endif
335
336/**
337 * bt_warn_ratelimited() - Log rate-limited Bluetooth warning message
338 * @format: Message's format string
339 *
340 * This functions works like bt_warn, but it uses rate limiting
341 * to prevent the message from being logged too often.
342 */
343void bt_warn_ratelimited(const char *format, ...)
344{
345 struct va_format vaf;
346 va_list args;
347
348 va_start(args, format);
349
350 vaf.fmt = format;
351 vaf.va = &args;
352
353 pr_warn_ratelimited("%pV", &vaf);
354
355 va_end(args);
356}
357EXPORT_SYMBOL(bt_warn_ratelimited);
358
359/**
360 * bt_err_ratelimited() - Log rate-limited Bluetooth error message
361 * @format: Message's format string
362 *
363 * This functions works like bt_err, but it uses rate limiting
364 * to prevent the message from being logged too often.
365 */
366void bt_err_ratelimited(const char *format, ...)
367{
368 struct va_format vaf;
369 va_list args;
370
371 va_start(args, format);
372
373 vaf.fmt = format;
374 vaf.va = &args;
375
376 pr_err_ratelimited("%pV", &vaf);
377
378 va_end(args);
379}
380EXPORT_SYMBOL(bt_err_ratelimited);