projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'davem-next' of master.kernel.org:/pub/scm/linux/kernel/git/jgarzik...
[deliverable/linux.git] / net / bluetooth / bnep / core.c
1 /*
2 BNEP implementation for Linux Bluetooth stack (BlueZ).
3 Copyright (C) 2001-2002 Inventel Systemes
4 Written 2001-2002 by
5 Clément Moreau <clement.moreau@inventel.fr>
6 David Libault <david.libault@inventel.fr>
7
8 Copyright (C) 2002 Maxim Krasnyansky <maxk@qualcomm.com>
9
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License version 2 as
12 published by the Free Software Foundation;
13
14 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
15 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
17 IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
18 CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
19 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
20 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
21 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
22
23 ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
24 COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
25 SOFTWARE IS DISCLAIMED.
26 */
27
28 #include <linux/module.h>
29
30 #include <linux/kernel.h>
31 #include <linux/sched.h>
32 #include <linux/signal.h>
33 #include <linux/init.h>
34 #include <linux/wait.h>
35 #include <linux/freezer.h>
36 #include <linux/errno.h>
37 #include <linux/net.h>
38 #include <net/sock.h>
39
40 #include <linux/socket.h>
41 #include <linux/file.h>
42
43 #include <linux/netdevice.h>
44 #include <linux/etherdevice.h>
45 #include <linux/skbuff.h>
46
47 #include <asm/unaligned.h>
48
49 #include <net/bluetooth/bluetooth.h>
50 #include <net/bluetooth/hci_core.h>
51 #include <net/bluetooth/l2cap.h>
52
53 #include "bnep.h"
54
55 #ifndef CONFIG_BT_BNEP_DEBUG
56 #undef BT_DBG
57 #define BT_DBG(D...)
58 #endif
59
60 #define VERSION "1.2"
61
62 static LIST_HEAD(bnep_session_list);
63 static DECLARE_RWSEM(bnep_session_sem);
64
65 static struct bnep_session *__bnep_get_session(u8 *dst)
66 {
67 struct bnep_session *s;
68 struct list_head *p;
69
70 BT_DBG("");
71
72 list_for_each(p, &bnep_session_list) {
73 s = list_entry(p, struct bnep_session, list);
74 if (!compare_ether_addr(dst, s->eh.h_source))
75 return s;
76 }
77 return NULL;
78 }
79
80 static void __bnep_link_session(struct bnep_session *s)
81 {
82 /* It's safe to call __module_get() here because sessions are added
83 by the socket layer which has to hold the refference to this module.
84 */
85 __module_get(THIS_MODULE);
86 list_add(&s->list, &bnep_session_list);
87 }
88
89 static void __bnep_unlink_session(struct bnep_session *s)
90 {
91 list_del(&s->list);
92 module_put(THIS_MODULE);
93 }
94
95 static int bnep_send(struct bnep_session *s, void *data, size_t len)
96 {
97 struct socket *sock = s->sock;
98 struct kvec iv = { data, len };
99
100 return kernel_sendmsg(sock, &s->msg, &iv, 1, len);
101 }
102
103 static int bnep_send_rsp(struct bnep_session *s, u8 ctrl, u16 resp)
104 {
105 struct bnep_control_rsp rsp;
106 rsp.type = BNEP_CONTROL;
107 rsp.ctrl = ctrl;
108 rsp.resp = htons(resp);
109 return bnep_send(s, &rsp, sizeof(rsp));
110 }
111
112 #ifdef CONFIG_BT_BNEP_PROTO_FILTER
113 static inline void bnep_set_default_proto_filter(struct bnep_session *s)
114 {
115 /* (IPv4, ARP) */
116 s->proto_filter[0].start = ETH_P_IP;
117 s->proto_filter[0].end = ETH_P_ARP;
118 /* (RARP, AppleTalk) */
119 s->proto_filter[1].start = ETH_P_RARP;
120 s->proto_filter[1].end = ETH_P_AARP;
121 /* (IPX, IPv6) */
122 s->proto_filter[2].start = ETH_P_IPX;
123 s->proto_filter[2].end = ETH_P_IPV6;
124 }
125 #endif
126
127 static int bnep_ctrl_set_netfilter(struct bnep_session *s, __be16 *data, int len)
128 {
129 int n;
130
131 if (len < 2)
132 return -EILSEQ;
133
134 n = get_unaligned_be16(data);
135 data++; len -= 2;
136
137 if (len < n)
138 return -EILSEQ;
139
140 BT_DBG("filter len %d", n);
141
142 #ifdef CONFIG_BT_BNEP_PROTO_FILTER
143 n /= 4;
144 if (n <= BNEP_MAX_PROTO_FILTERS) {
145 struct bnep_proto_filter *f = s->proto_filter;
146 int i;
147
148 for (i = 0; i < n; i++) {
149 f[i].start = get_unaligned_be16(data++);
150 f[i].end = get_unaligned_be16(data++);
151
152 BT_DBG("proto filter start %d end %d",
153 f[i].start, f[i].end);
154 }
155
156 if (i < BNEP_MAX_PROTO_FILTERS)
157 memset(f + i, 0, sizeof(*f));
158
159 if (n == 0)
160 bnep_set_default_proto_filter(s);
161
162 bnep_send_rsp(s, BNEP_FILTER_NET_TYPE_RSP, BNEP_SUCCESS);
163 } else {
164 bnep_send_rsp(s, BNEP_FILTER_NET_TYPE_RSP, BNEP_FILTER_LIMIT_REACHED);
165 }
166 #else
167 bnep_send_rsp(s, BNEP_FILTER_NET_TYPE_RSP, BNEP_FILTER_UNSUPPORTED_REQ);
168 #endif
169 return 0;
170 }
171
172 static int bnep_ctrl_set_mcfilter(struct bnep_session *s, u8 *data, int len)
173 {
174 int n;
175
176 if (len < 2)
177 return -EILSEQ;
178
179 n = get_unaligned_be16(data);
180 data += 2; len -= 2;
181
182 if (len < n)
183 return -EILSEQ;
184
185 BT_DBG("filter len %d", n);
186
187 #ifdef CONFIG_BT_BNEP_MC_FILTER
188 n /= (ETH_ALEN * 2);
189
190 if (n > 0) {
191 s->mc_filter = 0;
192
193 /* Always send broadcast */
194 set_bit(bnep_mc_hash(s->dev->broadcast), (ulong *) &s->mc_filter);
195
196 /* Add address ranges to the multicast hash */
197 for (; n > 0; n--) {
198 u8 a1[6], *a2;
199
200 memcpy(a1, data, ETH_ALEN); data += ETH_ALEN;
201 a2 = data; data += ETH_ALEN;
202
203 BT_DBG("mc filter %s -> %s",
204 batostr((void *) a1), batostr((void *) a2));
205
206 #define INCA(a) { int i = 5; while (i >=0 && ++a[i--] == 0); }
207
208 /* Iterate from a1 to a2 */
209 set_bit(bnep_mc_hash(a1), (ulong *) &s->mc_filter);
210 while (memcmp(a1, a2, 6) < 0 && s->mc_filter != ~0LL) {
211 INCA(a1);
212 set_bit(bnep_mc_hash(a1), (ulong *) &s->mc_filter);
213 }
214 }
215 }
216
217 BT_DBG("mc filter hash 0x%llx", s->mc_filter);
218
219 bnep_send_rsp(s, BNEP_FILTER_MULTI_ADDR_RSP, BNEP_SUCCESS);
220 #else
221 bnep_send_rsp(s, BNEP_FILTER_MULTI_ADDR_RSP, BNEP_FILTER_UNSUPPORTED_REQ);
222 #endif
223 return 0;
224 }
225
226 static int bnep_rx_control(struct bnep_session *s, void *data, int len)
227 {
228 u8 cmd = *(u8 *)data;
229 int err = 0;
230
231 data++; len--;
232
233 switch (cmd) {
234 case BNEP_CMD_NOT_UNDERSTOOD:
235 case BNEP_SETUP_CONN_REQ:
236 case BNEP_SETUP_CONN_RSP:
237 case BNEP_FILTER_NET_TYPE_RSP:
238 case BNEP_FILTER_MULTI_ADDR_RSP:
239 /* Ignore these for now */
240 break;
241
242 case BNEP_FILTER_NET_TYPE_SET:
243 err = bnep_ctrl_set_netfilter(s, data, len);
244 break;
245
246 case BNEP_FILTER_MULTI_ADDR_SET:
247 err = bnep_ctrl_set_mcfilter(s, data, len);
248 break;
249
250 default: {
251 u8 pkt[3];
252 pkt[0] = BNEP_CONTROL;
253 pkt[1] = BNEP_CMD_NOT_UNDERSTOOD;
254 pkt[2] = cmd;
255 bnep_send(s, pkt, sizeof(pkt));
256 }
257 break;
258 }
259
260 return err;
261 }
262
263 static int bnep_rx_extension(struct bnep_session *s, struct sk_buff *skb)
264 {
265 struct bnep_ext_hdr *h;
266 int err = 0;
267
268 do {
269 h = (void *) skb->data;
270 if (!skb_pull(skb, sizeof(*h))) {
271 err = -EILSEQ;
272 break;
273 }
274
275 BT_DBG("type 0x%x len %d", h->type, h->len);
276
277 switch (h->type & BNEP_TYPE_MASK) {
278 case BNEP_EXT_CONTROL:
279 bnep_rx_control(s, skb->data, skb->len);
280 break;
281
282 default:
283 /* Unknown extension, skip it. */
284 break;
285 }
286
287 if (!skb_pull(skb, h->len)) {
288 err = -EILSEQ;
289 break;
290 }
291 } while (!err && (h->type & BNEP_EXT_HEADER));
292
293 return err;
294 }
295
296 static u8 __bnep_rx_hlen[] = {
297 ETH_HLEN, /* BNEP_GENERAL */
298 0, /* BNEP_CONTROL */
299 2, /* BNEP_COMPRESSED */
300 ETH_ALEN + 2, /* BNEP_COMPRESSED_SRC_ONLY */
301 ETH_ALEN + 2 /* BNEP_COMPRESSED_DST_ONLY */
302 };
303 #define BNEP_RX_TYPES (sizeof(__bnep_rx_hlen) - 1)
304
305 static inline int bnep_rx_frame(struct bnep_session *s, struct sk_buff *skb)
306 {
307 struct net_device *dev = s->dev;
308 struct sk_buff *nskb;
309 u8 type;
310
311 dev->last_rx = jiffies;
312 s->stats.rx_bytes += skb->len;
313
314 type = *(u8 *) skb->data; skb_pull(skb, 1);
315
316 if ((type & BNEP_TYPE_MASK) > BNEP_RX_TYPES)
317 goto badframe;
318
319 if ((type & BNEP_TYPE_MASK) == BNEP_CONTROL) {
320 bnep_rx_control(s, skb->data, skb->len);
321 kfree_skb(skb);
322 return 0;
323 }
324
325 skb_reset_mac_header(skb);
326
327 /* Verify and pull out header */
328 if (!skb_pull(skb, __bnep_rx_hlen[type & BNEP_TYPE_MASK]))
329 goto badframe;
330
331 s->eh.h_proto = get_unaligned((__be16 *) (skb->data - 2));
332
333 if (type & BNEP_EXT_HEADER) {
334 if (bnep_rx_extension(s, skb) < 0)
335 goto badframe;
336 }
337
338 /* Strip 802.1p header */
339 if (ntohs(s->eh.h_proto) == 0x8100) {
340 if (!skb_pull(skb, 4))
341 goto badframe;
342 s->eh.h_proto = get_unaligned((__be16 *) (skb->data - 2));
343 }
344
345 /* We have to alloc new skb and copy data here :(. Because original skb
346 * may not be modified and because of the alignment requirements. */
347 nskb = alloc_skb(2 + ETH_HLEN + skb->len, GFP_KERNEL);
348 if (!nskb) {
349 s->stats.rx_dropped++;
350 kfree_skb(skb);
351 return -ENOMEM;
352 }
353 skb_reserve(nskb, 2);
354
355 /* Decompress header and construct ether frame */
356 switch (type & BNEP_TYPE_MASK) {
357 case BNEP_COMPRESSED:
358 memcpy(__skb_put(nskb, ETH_HLEN), &s->eh, ETH_HLEN);
359 break;
360
361 case BNEP_COMPRESSED_SRC_ONLY:
362 memcpy(__skb_put(nskb, ETH_ALEN), s->eh.h_dest, ETH_ALEN);
363 memcpy(__skb_put(nskb, ETH_ALEN), skb_mac_header(skb), ETH_ALEN);
364 put_unaligned(s->eh.h_proto, (__be16 *) __skb_put(nskb, 2));
365 break;
366
367 case BNEP_COMPRESSED_DST_ONLY:
368 memcpy(__skb_put(nskb, ETH_ALEN), skb_mac_header(skb),
369 ETH_ALEN);
370 memcpy(__skb_put(nskb, ETH_ALEN + 2), s->eh.h_source,
371 ETH_ALEN + 2);
372 break;
373
374 case BNEP_GENERAL:
375 memcpy(__skb_put(nskb, ETH_ALEN * 2), skb_mac_header(skb),
376 ETH_ALEN * 2);
377 put_unaligned(s->eh.h_proto, (__be16 *) __skb_put(nskb, 2));
378 break;
379 }
380
381 skb_copy_from_linear_data(skb, __skb_put(nskb, skb->len), skb->len);
382 kfree_skb(skb);
383
384 s->stats.rx_packets++;
385 nskb->ip_summed = CHECKSUM_NONE;
386 nskb->protocol = eth_type_trans(nskb, dev);
387 netif_rx_ni(nskb);
388 return 0;
389
390 badframe:
391 s->stats.rx_errors++;
392 kfree_skb(skb);
393 return 0;
394 }
395
396 static u8 __bnep_tx_types[] = {
397 BNEP_GENERAL,
398 BNEP_COMPRESSED_SRC_ONLY,
399 BNEP_COMPRESSED_DST_ONLY,
400 BNEP_COMPRESSED
401 };
402
403 static inline int bnep_tx_frame(struct bnep_session *s, struct sk_buff *skb)
404 {
405 struct ethhdr *eh = (void *) skb->data;
406 struct socket *sock = s->sock;
407 struct kvec iv[3];
408 int len = 0, il = 0;
409 u8 type = 0;
410
411 BT_DBG("skb %p dev %p type %d", skb, skb->dev, skb->pkt_type);
412
413 if (!skb->dev) {
414 /* Control frame sent by us */
415 goto send;
416 }
417
418 iv[il++] = (struct kvec) { &type, 1 };
419 len++;
420
421 if (!compare_ether_addr(eh->h_dest, s->eh.h_source))
422 type |= 0x01;
423
424 if (!compare_ether_addr(eh->h_source, s->eh.h_dest))
425 type |= 0x02;
426
427 if (type)
428 skb_pull(skb, ETH_ALEN * 2);
429
430 type = __bnep_tx_types[type];
431 switch (type) {
432 case BNEP_COMPRESSED_SRC_ONLY:
433 iv[il++] = (struct kvec) { eh->h_source, ETH_ALEN };
434 len += ETH_ALEN;
435 break;
436
437 case BNEP_COMPRESSED_DST_ONLY:
438 iv[il++] = (struct kvec) { eh->h_dest, ETH_ALEN };
439 len += ETH_ALEN;
440 break;
441 }
442
443 send:
444 iv[il++] = (struct kvec) { skb->data, skb->len };
445 len += skb->len;
446
447 /* FIXME: linearize skb */
448 {
449 len = kernel_sendmsg(sock, &s->msg, iv, il, len);
450 }
451 kfree_skb(skb);
452
453 if (len > 0) {
454 s->stats.tx_bytes += len;
455 s->stats.tx_packets++;
456 return 0;
457 }
458
459 return len;
460 }
461
462 static int bnep_session(void *arg)
463 {
464 struct bnep_session *s = arg;
465 struct net_device *dev = s->dev;
466 struct sock *sk = s->sock->sk;
467 struct sk_buff *skb;
468 wait_queue_t wait;
469
470 BT_DBG("");
471
472 daemonize("kbnepd %s", dev->name);
473 set_user_nice(current, -15);
474
475 init_waitqueue_entry(&wait, current);
476 add_wait_queue(sk->sk_sleep, &wait);
477 while (!atomic_read(&s->killed)) {
478 set_current_state(TASK_INTERRUPTIBLE);
479
480 // RX
481 while ((skb = skb_dequeue(&sk->sk_receive_queue))) {
482 skb_orphan(skb);
483 bnep_rx_frame(s, skb);
484 }
485
486 if (sk->sk_state != BT_CONNECTED)
487 break;
488
489 // TX
490 while ((skb = skb_dequeue(&sk->sk_write_queue)))
491 if (bnep_tx_frame(s, skb))
492 break;
493 netif_wake_queue(dev);
494
495 schedule();
496 }
497 set_current_state(TASK_RUNNING);
498 remove_wait_queue(sk->sk_sleep, &wait);
499
500 /* Cleanup session */
501 down_write(&bnep_session_sem);
502
503 /* Delete network device */
504 unregister_netdev(dev);
505
506 /* Release the socket */
507 fput(s->sock->file);
508
509 __bnep_unlink_session(s);
510
511 up_write(&bnep_session_sem);
512 free_netdev(dev);
513 return 0;
514 }
515
516 static struct device *bnep_get_device(struct bnep_session *session)
517 {
518 bdaddr_t *src = &bt_sk(session->sock->sk)->src;
519 bdaddr_t *dst = &bt_sk(session->sock->sk)->dst;
520 struct hci_dev *hdev;
521 struct hci_conn *conn;
522
523 hdev = hci_get_route(dst, src);
524 if (!hdev)
525 return NULL;
526
527 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, dst);
528
529 hci_dev_put(hdev);
530
531 return conn ? &conn->dev : NULL;
532 }
533
534 int bnep_add_connection(struct bnep_connadd_req *req, struct socket *sock)
535 {
536 struct net_device *dev;
537 struct bnep_session *s, *ss;
538 u8 dst[ETH_ALEN], src[ETH_ALEN];
539 int err;
540
541 BT_DBG("");
542
543 baswap((void *) dst, &bt_sk(sock->sk)->dst);
544 baswap((void *) src, &bt_sk(sock->sk)->src);
545
546 /* session struct allocated as private part of net_device */
547 dev = alloc_netdev(sizeof(struct bnep_session),
548 (*req->device) ? req->device : "bnep%d",
549 bnep_net_setup);
550 if (!dev)
551 return -ENOMEM;
552
553 down_write(&bnep_session_sem);
554
555 ss = __bnep_get_session(dst);
556 if (ss && ss->state == BT_CONNECTED) {
557 err = -EEXIST;
558 goto failed;
559 }
560
561 s = dev->priv;
562
563 /* This is rx header therefore addresses are swapped.
564 * ie eh.h_dest is our local address. */
565 memcpy(s->eh.h_dest, &src, ETH_ALEN);
566 memcpy(s->eh.h_source, &dst, ETH_ALEN);
567 memcpy(dev->dev_addr, s->eh.h_dest, ETH_ALEN);
568
569 s->dev = dev;
570 s->sock = sock;
571 s->role = req->role;
572 s->state = BT_CONNECTED;
573
574 s->msg.msg_flags = MSG_NOSIGNAL;
575
576 #ifdef CONFIG_BT_BNEP_MC_FILTER
577 /* Set default mc filter */
578 set_bit(bnep_mc_hash(dev->broadcast), (ulong *) &s->mc_filter);
579 #endif
580
581 #ifdef CONFIG_BT_BNEP_PROTO_FILTER
582 /* Set default protocol filter */
583 bnep_set_default_proto_filter(s);
584 #endif
585
586 SET_NETDEV_DEV(dev, bnep_get_device(s));
587
588 err = register_netdev(dev);
589 if (err) {
590 goto failed;
591 }
592
593 __bnep_link_session(s);
594
595 err = kernel_thread(bnep_session, s, CLONE_KERNEL);
596 if (err < 0) {
597 /* Session thread start failed, gotta cleanup. */
598 unregister_netdev(dev);
599 __bnep_unlink_session(s);
600 goto failed;
601 }
602
603 up_write(&bnep_session_sem);
604 strcpy(req->device, dev->name);
605 return 0;
606
607 failed:
608 up_write(&bnep_session_sem);
609 free_netdev(dev);
610 return err;
611 }
612
613 int bnep_del_connection(struct bnep_conndel_req *req)
614 {
615 struct bnep_session *s;
616 int err = 0;
617
618 BT_DBG("");
619
620 down_read(&bnep_session_sem);
621
622 s = __bnep_get_session(req->dst);
623 if (s) {
624 /* Wakeup user-space which is polling for socket errors.
625 * This is temporary hack untill we have shutdown in L2CAP */
626 s->sock->sk->sk_err = EUNATCH;
627
628 /* Kill session thread */
629 atomic_inc(&s->killed);
630 wake_up_interruptible(s->sock->sk->sk_sleep);
631 } else
632 err = -ENOENT;
633
634 up_read(&bnep_session_sem);
635 return err;
636 }
637
638 static void __bnep_copy_ci(struct bnep_conninfo *ci, struct bnep_session *s)
639 {
640 memcpy(ci->dst, s->eh.h_source, ETH_ALEN);
641 strcpy(ci->device, s->dev->name);
642 ci->flags = s->flags;
643 ci->state = s->state;
644 ci->role = s->role;
645 }
646
647 int bnep_get_connlist(struct bnep_connlist_req *req)
648 {
649 struct list_head *p;
650 int err = 0, n = 0;
651
652 down_read(&bnep_session_sem);
653
654 list_for_each(p, &bnep_session_list) {
655 struct bnep_session *s;
656 struct bnep_conninfo ci;
657
658 s = list_entry(p, struct bnep_session, list);
659
660 __bnep_copy_ci(&ci, s);
661
662 if (copy_to_user(req->ci, &ci, sizeof(ci))) {
663 err = -EFAULT;
664 break;
665 }
666
667 if (++n >= req->cnum)
668 break;
669
670 req->ci++;
671 }
672 req->cnum = n;
673
674 up_read(&bnep_session_sem);
675 return err;
676 }
677
678 int bnep_get_conninfo(struct bnep_conninfo *ci)
679 {
680 struct bnep_session *s;
681 int err = 0;
682
683 down_read(&bnep_session_sem);
684
685 s = __bnep_get_session(ci->dst);
686 if (s)
687 __bnep_copy_ci(ci, s);
688 else
689 err = -ENOENT;
690
691 up_read(&bnep_session_sem);
692 return err;
693 }
694
695 static int __init bnep_init(void)
696 {
697 char flt[50] = "";
698
699 l2cap_load();
700
701 #ifdef CONFIG_BT_BNEP_PROTO_FILTER
702 strcat(flt, "protocol ");
703 #endif
704
705 #ifdef CONFIG_BT_BNEP_MC_FILTER
706 strcat(flt, "multicast");
707 #endif
708
709 BT_INFO("BNEP (Ethernet Emulation) ver %s", VERSION);
710 if (flt[0])
711 BT_INFO("BNEP filters: %s", flt);
712
713 bnep_sock_init();
714 return 0;
715 }
716
717 static void __exit bnep_exit(void)
718 {
719 bnep_sock_cleanup();
720 }
721
722 module_init(bnep_init);
723 module_exit(bnep_exit);
724
725 MODULE_AUTHOR("David Libault <david.libault@inventel.fr>, Maxim Krasnyansky <maxk@qualcomm.com>");
726 MODULE_DESCRIPTION("Bluetooth BNEP ver " VERSION);
727 MODULE_VERSION(VERSION);
728 MODULE_LICENSE("GPL");
729 MODULE_ALIAS("bt-proto-4");
Linux kernel - Deliverables
This page took 0.059904 seconds and 5 git commands to generate.