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 <maxk@qualcomm.com> 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 */ 39 void 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 } 48 EXPORT_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 */ 63 int 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 } 154 EXPORT_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 } 237 EXPORT_SYMBOL(bt_status); 238 239 /** 240 * bt_info() - Log Bluetooth information message 241 * @format: Message's format string 242 */ 243 void 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 } 257 EXPORT_SYMBOL(bt_info); 258 259 /** 260 * bt_warn() - Log Bluetooth warning message 261 * @format: Message's format string 262 */ 263 void 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 } 277 EXPORT_SYMBOL(bt_warn); 278 279 /** 280 * bt_err() - Log Bluetooth error message 281 * @format: Message's format string 282 */ 283 void 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 } 297 EXPORT_SYMBOL(bt_err); 298 299 #ifdef CONFIG_BT_FEATURE_DEBUG 300 static bool debug_enable; 301 302 void bt_dbg_set(bool enable) 303 { 304 debug_enable = enable; 305 } 306 307 bool 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 */ 316 void 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 } 333 EXPORT_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 */ 343 void 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 } 357 EXPORT_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 */ 366 void 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 } 380 EXPORT_SYMBOL(bt_err_ratelimited); 381