net/bluetooth/lib.c

0001 /*
0002    BlueZ - Bluetooth protocol stack for Linux
0003    Copyright (C) 2000-2001 Qualcomm Incorporated
0004
0005    Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
0006
0007    This program is free software; you can redistribute it and/or modify
0008    it under the terms of the GNU General Public License version 2 as
0009    published by the Free Software Foundation;
0010
0011    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
0012    OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
0013    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
0014    IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
0015    CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
0016    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
0017    ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
0018    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
0019
0020    ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
0021    COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
0022    SOFTWARE IS DISCLAIMED.
0023 */
0024
0025 /* Bluetooth kernel library. */
0026
0027 #define pr_fmt(fmt) "Bluetooth: " fmt
0028
0029 #include <linux/export.h>
0030
0031 #include <net/bluetooth/bluetooth.h>
0032
0033 void baswap(bdaddr_t *dst, const bdaddr_t *src)
0034 {
0035     const unsigned char *s = (const unsigned char *)src;
0036     unsigned char *d = (unsigned char *)dst;
0037     unsigned int i;
0038
0039     for (i = 0; i < 6; i++)
0040         d[i] = s[5 - i];
0041 }
0042 EXPORT_SYMBOL(baswap);
0043
0044 /* Bluetooth error codes to Unix errno mapping */
0045 int bt_to_errno(__u16 code)
0046 {
0047     switch (code) {
0048     case 0:
0049         return 0;
0050
0051     case 0x01:
0052         return EBADRQC;
0053
0054     case 0x02:
0055         return ENOTCONN;
0056
0057     case 0x03:
0058         return EIO;
0059
0060     case 0x04:
0061     case 0x3c:
0062         return EHOSTDOWN;
0063
0064     case 0x05:
0065         return EACCES;
0066
0067     case 0x06:
0068         return EBADE;
0069
0070     case 0x07:
0071         return ENOMEM;
0072
0073     case 0x08:
0074         return ETIMEDOUT;
0075
0076     case 0x09:
0077         return EMLINK;
0078
0079     case 0x0a:
0080         return EMLINK;
0081
0082     case 0x0b:
0083         return EALREADY;
0084
0085     case 0x0c:
0086         return EBUSY;
0087
0088     case 0x0d:
0089     case 0x0e:
0090     case 0x0f:
0091         return ECONNREFUSED;
0092
0093     case 0x10:
0094         return ETIMEDOUT;
0095
0096     case 0x11:
0097     case 0x27:
0098     case 0x29:
0099     case 0x20:
0100         return EOPNOTSUPP;
0101
0102     case 0x12:
0103         return EINVAL;
0104
0105     case 0x13:
0106     case 0x14:
0107     case 0x15:
0108         return ECONNRESET;
0109
0110     case 0x16:
0111         return ECONNABORTED;
0112
0113     case 0x17:
0114         return ELOOP;
0115
0116     case 0x18:
0117         return EACCES;
0118
0119     case 0x1a:
0120         return EPROTONOSUPPORT;
0121
0122     case 0x1b:
0123         return ECONNREFUSED;
0124
0125     case 0x19:
0126     case 0x1e:
0127     case 0x23:
0128     case 0x24:
0129     case 0x25:
0130         return EPROTO;
0131
0132     default:
0133         return ENOSYS;
0134     }
0135 }
0136 EXPORT_SYMBOL(bt_to_errno);
0137
0138 /* Unix errno to Bluetooth error codes mapping */
0139 __u8 bt_status(int err)
0140 {
0141     /* Don't convert if already positive value */
0142     if (err >= 0)
0143         return err;
0144
0145     switch (err) {
0146     case -EBADRQC:
0147         return 0x01;
0148
0149     case -ENOTCONN:
0150         return 0x02;
0151
0152     case -EIO:
0153         return 0x03;
0154
0155     case -EHOSTDOWN:
0156         return 0x04;
0157
0158     case -EACCES:
0159         return 0x05;
0160
0161     case -EBADE:
0162         return 0x06;
0163
0164     case -ENOMEM:
0165         return 0x07;
0166
0167     case -ETIMEDOUT:
0168         return 0x08;
0169
0170     case -EMLINK:
0171         return 0x09;
0172
0173     case EALREADY:
0174         return 0x0b;
0175
0176     case -EBUSY:
0177         return 0x0c;
0178
0179     case -ECONNREFUSED:
0180         return 0x0d;
0181
0182     case -EOPNOTSUPP:
0183         return 0x11;
0184
0185     case -EINVAL:
0186         return 0x12;
0187
0188     case -ECONNRESET:
0189         return 0x13;
0190
0191     case -ECONNABORTED:
0192         return 0x16;
0193
0194     case ELOOP:
0195         return 0x17;
0196
0197     case -EPROTONOSUPPORT:
0198         return 0x1a;
0199
0200     case -EPROTO:
0201         return 0x19;
0202
0203     default:
0204         return 0x1f;
0205     }
0206 }
0207 EXPORT_SYMBOL(bt_status);
0208
0209 void bt_info(const char *format, ...)
0210 {
0211     struct va_format vaf;
0212     va_list args;
0213
0214     va_start(args, format);
0215
0216     vaf.fmt = format;
0217     vaf.va = &args;
0218
0219     pr_info("%pV", &vaf);
0220
0221     va_end(args);
0222 }
0223 EXPORT_SYMBOL(bt_info);
0224
0225 void bt_warn(const char *format, ...)
0226 {
0227     struct va_format vaf;
0228     va_list args;
0229
0230     va_start(args, format);
0231
0232     vaf.fmt = format;
0233     vaf.va = &args;
0234
0235     pr_warn("%pV", &vaf);
0236
0237     va_end(args);
0238 }
0239 EXPORT_SYMBOL(bt_warn);
0240
0241 void bt_err(const char *format, ...)
0242 {
0243     struct va_format vaf;
0244     va_list args;
0245
0246     va_start(args, format);
0247
0248     vaf.fmt = format;
0249     vaf.va = &args;
0250
0251     pr_err("%pV", &vaf);
0252
0253     va_end(args);
0254 }
0255 EXPORT_SYMBOL(bt_err);
0256
0257 #ifdef CONFIG_BT_FEATURE_DEBUG
0258 static bool debug_enable;
0259
0260 void bt_dbg_set(bool enable)
0261 {
0262     debug_enable = enable;
0263 }
0264
0265 bool bt_dbg_get(void)
0266 {
0267     return debug_enable;
0268 }
0269
0270 void bt_dbg(const char *format, ...)
0271 {
0272     struct va_format vaf;
0273     va_list args;
0274
0275     if (likely(!debug_enable))
0276         return;
0277
0278     va_start(args, format);
0279
0280     vaf.fmt = format;
0281     vaf.va = &args;
0282
0283     printk(KERN_DEBUG pr_fmt("%pV"), &vaf);
0284
0285     va_end(args);
0286 }
0287 EXPORT_SYMBOL(bt_dbg);
0288 #endif
0289
0290 void bt_warn_ratelimited(const char *format, ...)
0291 {
0292     struct va_format vaf;
0293     va_list args;
0294
0295     va_start(args, format);
0296
0297     vaf.fmt = format;
0298     vaf.va = &args;
0299
0300     pr_warn_ratelimited("%pV", &vaf);
0301
0302     va_end(args);
0303 }
0304 EXPORT_SYMBOL(bt_warn_ratelimited);
0305
0306 void bt_err_ratelimited(const char *format, ...)
0307 {
0308     struct va_format vaf;
0309     va_list args;
0310
0311     va_start(args, format);
0312
0313     vaf.fmt = format;
0314     vaf.va = &args;
0315
0316     pr_err_ratelimited("%pV", &vaf);
0317
0318     va_end(args);
0319 }
0320 EXPORT_SYMBOL(bt_err_ratelimited);