← Back to branch summary

~ubuntu-branches/ubuntu/quantal/linux-backports-modules-3.5.0/quantal-updates

« back to all changes in this revision

Viewing changes to updates/cw-3.6/patches/16-bluetooth.patch

  • Committer: Package Import Robot
  • Author(s): Leann Ogasawara
  • Date: 2012-10-10 22:28:55 UTC
  • Revision ID: package-import@ubuntu.com-20121010222855-qepocc61xktv6gs9
Tags: 3.5.0-17.1
https://launchpad.net/bugs/1066123
* Open Quantal LBM
* Add compat-wireless 3.6
  -LP: #1066123

Show diffs side-by-side

added added

removed removed

Lines of Context:
updates/cw-3.6/patches/16-bluetooth.patch
 
1
These changes are required to backport blueooth. A lot can be optimized
 
2
here still, but for now we keep this here.
 
3
 
 
4
--- a/drivers/bluetooth/hci_ldisc.c
 
5
+++ b/drivers/bluetooth/hci_ldisc.c
 
6
@@ -302,8 +302,13 @@ static int hci_uart_tty_open(struct tty_
 
7
        /* FIXME: why is this needed. Note don't use ldisc_ref here as the
 
8
           open path is before the ldisc is referencable */
 
9
 
 
10
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,30))
 
11
        if (tty->ldisc->ops->flush_buffer)
 
12
                tty->ldisc->ops->flush_buffer(tty);
 
13
+#else
 
14
+       if (tty->ldisc.ops->flush_buffer)
 
15
+               tty->ldisc.ops->flush_buffer(tty);
 
16
+#endif
 
17
        tty_driver_flush_buffer(tty);
 
18
 
 
19
        return 0;
 
20
@@ -529,7 +534,11 @@ static int hci_uart_tty_ioctl(struct tty
 
21
                return hu->hdev_flags;
 
22
 
 
23
        default:
 
24
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,27))
 
25
                err = n_tty_ioctl_helper(tty, file, cmd, arg);
 
26
+#else
 
27
+               err = n_tty_ioctl(tty, file, cmd, arg);
 
28
+#endif
 
29
                break;
 
30
        };
 
31
 
 
32
--- a/net/bluetooth/af_bluetooth.c
 
33
+++ b/net/bluetooth/af_bluetooth.c
 
34
@@ -111,8 +111,12 @@ int bt_sock_unregister(int proto)
 
35
 }
 
36
 EXPORT_SYMBOL(bt_sock_unregister);
 
37
 
 
38
+#if defined(CONFIG_COMPAT_BT_SOCK_CREATE_NEEDS_KERN)
 
39
 static int bt_sock_create(struct net *net, struct socket *sock, int proto,
 
40
                          int kern)
 
41
+#else
 
42
+static int bt_sock_create(struct net *net, struct socket *sock, int proto)
 
43
+#endif
 
44
 {
 
45
        int err;
 
46
 
 
47
@@ -130,7 +134,11 @@ static int bt_sock_create(struct net *ne
 
48
        read_lock(&bt_proto_lock);
 
49
 
 
50
        if (bt_proto[proto] && try_module_get(bt_proto[proto]->owner)) {
 
51
+#if defined(CONFIG_COMPAT_BT_SOCK_CREATE_NEEDS_KERN)
 
52
                err = bt_proto[proto]->create(net, sock, proto, kern);
 
53
+#else
 
54
+               err = bt_proto[proto]->create(net, sock, proto);
 
55
+#endif
 
56
                if (!err)
 
57
                        bt_sock_reclassify_lock(sock->sk, proto);
 
58
                module_put(bt_proto[proto]->owner);
 
59
@@ -463,7 +471,11 @@ int bt_sock_ioctl(struct socket *sock, u
 
60
                if (sk->sk_state == BT_LISTEN)
 
61
                        return -EINVAL;
 
62
 
 
63
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,31))
 
64
                amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
 
65
+#else
 
66
+               amount = sk->sk_sndbuf - atomic_read(&sk->sk_wmem_alloc);
 
67
+#endif
 
68
                if (amount < 0)
 
69
                        amount = 0;
 
70
                err = put_user(amount, (int __user *) arg);
 
71
--- a/net/bluetooth/cmtp/capi.c
 
72
+++ b/net/bluetooth/cmtp/capi.c
 
73
@@ -384,7 +384,11 @@ static void cmtp_reset_ctr(struct capi_c
 
74
 
 
75
        BT_DBG("ctrl %p", ctrl);
 
76
 
 
77
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,30))
 
78
        capi_ctr_down(ctrl);
 
79
+#else
 
80
+       capi_ctr_reseted(ctrl);
 
81
+#endif
 
82
 
 
83
        atomic_inc(&session->terminate);
 
84
        wake_up_process(session->task);
 
85
--- a/net/bluetooth/hci_sock.c
 
86
+++ b/net/bluetooth/hci_sock.c
 
87
@@ -884,8 +884,13 @@ drop:
 
88
        goto done;
 
89
 }
 
90
 
 
91
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,31))
 
92
 static int hci_sock_setsockopt(struct socket *sock, int level, int optname,
 
93
                               char __user *optval, unsigned int len)
 
94
+#else
 
95
+static int hci_sock_setsockopt(struct socket *sock, int level, int optname,
 
96
+                              char __user *optval, int len)
 
97
+#endif
 
98
 {
 
99
        struct hci_ufilter uf = { .opcode = 0 };
 
100
        struct sock *sk = sock->sk;
 
101
@@ -1059,8 +1064,12 @@ static struct proto hci_sk_proto = {
 
102
        .obj_size       = sizeof(struct hci_pinfo)
 
103
 };
 
104
 
 
105
+#if defined(CONFIG_COMPAT_BT_SOCK_CREATE_NEEDS_KERN)
 
106
 static int hci_sock_create(struct net *net, struct socket *sock, int protocol,
 
107
                           int kern)
 
108
+#else
 
109
+static int hci_sock_create(struct net *net, struct socket *sock, int protocol)
 
110
+#endif
 
111
 {
 
112
        struct sock *sk;
 
113
 
 
114
--- a/net/bluetooth/hci_sysfs.c
 
115
+++ b/net/bluetooth/hci_sysfs.c
 
116
@@ -71,7 +71,11 @@ static struct attribute_group bt_link_gr
 
117
        .attrs = bt_link_attrs,
 
118
 };
 
119
 
 
120
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,31))
 
121
 static const struct attribute_group *bt_link_groups[] = {
 
122
+#else
 
123
+static struct attribute_group *bt_link_groups[] = {
 
124
+#endif
 
125
        &bt_link_group,
 
126
        NULL
 
127
 };
 
128
@@ -140,7 +144,11 @@ void hci_conn_del_sysfs(struct hci_conn
 
129
                dev = device_find_child(&conn->dev, NULL, __match_tty);
 
130
                if (!dev)
 
131
                        break;
 
132
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,29))
 
133
                device_move(dev, NULL, DPM_ORDER_DEV_LAST);
 
134
+#else
 
135
+               device_move(dev, NULL);
 
136
+#endif
 
137
                put_device(dev);
 
138
        }
 
139
 
 
140
@@ -378,7 +386,11 @@ static struct attribute_group bt_host_gr
 
141
        .attrs = bt_host_attrs,
 
142
 };
 
143
 
 
144
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,31))
 
145
 static const struct attribute_group *bt_host_groups[] = {
 
146
+#else
 
147
+static struct attribute_group *bt_host_groups[] = {
 
148
+#endif
 
149
        &bt_host_group,
 
150
        NULL
 
151
 };
 
152
--- a/net/bluetooth/hidp/core.c
 
153
+++ b/net/bluetooth/hidp/core.c
 
154
@@ -380,6 +380,7 @@ err:
 
155
        return ret;
 
156
 }
 
157
 
 
158
+#if defined(CONFIG_COMPAT_BT_SOCK_CREATE_NEEDS_KERN)
 
159
 static int hidp_output_raw_report(struct hid_device *hid, unsigned char *data, size_t count,
 
160
                unsigned char report_type)
 
161
 {
 
162
@@ -438,6 +439,16 @@ err:
 
163
        mutex_unlock(&session->report_mutex);
 
164
        return ret;
 
165
 }
 
166
+#elif (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,27))
 
167
+static int hidp_output_raw_report(struct hid_device *hid, unsigned char *data, size_t count)
 
168
+{
 
169
+       if (hidp_send_ctrl_message(hid->driver_data,
 
170
+                       HIDP_TRANS_SET_REPORT | HIDP_DATA_RTYPE_FEATURE,
 
171
+                       data, count))
 
172
+               return -ENOMEM;
 
173
+       return count;
 
174
+}
 
175
+#endif
 
176
 
 
177
 static void hidp_idle_timeout(unsigned long arg)
 
178
 {
 
179
@@ -739,8 +750,14 @@ static int hidp_session(void *arg)
 
180
        }
 
181
 
 
182
        if (session->hid) {
 
183
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,27))
 
184
                hid_destroy_device(session->hid);
 
185
                session->hid = NULL;
 
186
+#else
 
187
+               if (session->hid->claimed & HID_CLAIMED_INPUT)
 
188
+                       hidinput_disconnect(session->hid);
 
189
+               hid_free_device(session->hid);
 
190
+#endif
 
191
        }
 
192
 
 
193
        /* Wakeup user-space polling for socket errors */
 
194
@@ -851,6 +868,70 @@ static void hidp_close(struct hid_device
 
195
 {
 
196
 }
 
197
 
 
198
+#if (LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,27))
 
199
+static const struct {
 
200
+       __u16 idVendor;
 
201
+       __u16 idProduct;
 
202
+       unsigned quirks;
 
203
+} hidp_blacklist[] = {
 
204
+       /* Apple wireless Mighty Mouse */
 
205
+       { 0x05ac, 0x030c, HID_QUIRK_MIGHTYMOUSE | HID_QUIRK_INVERT_HWHEEL },
 
206
+
 
207
+       { }     /* Terminating entry */
 
208
+};
 
209
+static void hidp_setup_quirks(struct hid_device *hid)
 
210
+{
 
211
+       unsigned int n;
 
212
+
 
213
+       for (n = 0; hidp_blacklist[n].idVendor; n++)
 
214
+               if (hidp_blacklist[n].idVendor == le16_to_cpu(hid->vendor) &&
 
215
+                               hidp_blacklist[n].idProduct == le16_to_cpu(hid->product))
 
216
+                       hid->quirks = hidp_blacklist[n].quirks;
 
217
+}
 
218
+
 
219
+static void hidp_setup_hid(struct hidp_session *session,
 
220
+                               struct hidp_connadd_req *req)
 
221
+{
 
222
+       struct hid_device *hid = session->hid;
 
223
+       struct hid_report *report;
 
224
+       bdaddr_t src, dst;
 
225
+
 
226
+       session->hid = hid;
 
227
+
 
228
+       hid->driver_data = session;
 
229
+
 
230
+       baswap(&src, &bt_sk(session->ctrl_sock->sk)->src);
 
231
+       baswap(&dst, &bt_sk(session->ctrl_sock->sk)->dst);
 
232
+
 
233
+       hid->bus     = BUS_BLUETOOTH;
 
234
+       hid->vendor  = req->vendor;
 
235
+       hid->product = req->product;
 
236
+       hid->version = req->version;
 
237
+       hid->country = req->country;
 
238
+
 
239
+       strncpy(hid->name, req->name, 128);
 
240
+       strncpy(hid->phys, batostr(&src), 64);
 
241
+       strncpy(hid->uniq, batostr(&dst), 64);
 
242
+
 
243
+       hid->dev = hidp_get_device(session);
 
244
+       hid->hid_open  = hidp_open;
 
245
+       hid->hid_close = hidp_close;
 
246
+
 
247
+       hid->hidinput_input_event = hidp_hidinput_event;
 
248
+
 
249
+       hidp_setup_quirks(hid);
 
250
+
 
251
+       list_for_each_entry(report, &hid->report_enum[HID_INPUT_REPORT].report_list, list)
 
252
+               hidp_send_report(session, report);
 
253
+
 
254
+       list_for_each_entry(report, &hid->report_enum[HID_FEATURE_REPORT].report_list, list)
 
255
+               hidp_send_report(session, report);
 
256
+
 
257
+       if (hidinput_connect(hid) == 0)
 
258
+               hid->claimed |= HID_CLAIMED_INPUT;
 
259
+}
 
260
+#else
 
261
+
 
262
 static int hidp_parse(struct hid_device *hid)
 
263
 {
 
264
        struct hidp_session *session = hid->driver_data;
 
265
@@ -938,7 +1019,9 @@ static int hidp_setup_hid(struct hidp_se
 
266
        hid->dev.parent = &session->conn->dev;
 
267
        hid->ll_driver = &hidp_hid_driver;
 
268
 
 
269
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,38))
 
270
        hid->hid_get_raw_report = hidp_get_raw_report;
 
271
+#endif
 
272
        hid->hid_output_raw_report = hidp_output_raw_report;
 
273
 
 
274
        return 0;
 
275
@@ -949,6 +1032,7 @@ fault:
 
276
 
 
277
        return err;
 
278
 }
 
279
+#endif
 
280
 
 
281
 int hidp_add_connection(struct hidp_connadd_req *req, struct socket *ctrl_sock, struct socket *intr_sock)
 
282
 {
 
283
@@ -964,6 +1048,39 @@ int hidp_add_connection(struct hidp_conn
 
284
 
 
285
        BT_DBG("rd_data %p rd_size %d", req->rd_data, req->rd_size);
 
286
 
 
287
+#if (LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,27))
 
288
+       if (req->rd_size > 0) {
 
289
+               unsigned char *buf = kmalloc(req->rd_size, GFP_KERNEL);
 
290
+
 
291
+               if (!buf) {
 
292
+                       kfree(session);
 
293
+                       return -ENOMEM;
 
294
+               }
 
295
+
 
296
+               if (copy_from_user(buf, req->rd_data, req->rd_size)) {
 
297
+                       kfree(buf);
 
298
+                       kfree(session);
 
299
+                       return -EFAULT;
 
300
+               }
 
301
+
 
302
+               session->hid = hid_parse_report(buf, req->rd_size);
 
303
+
 
304
+               kfree(buf);
 
305
+
 
306
+               if (!session->hid) {
 
307
+                       kfree(session);
 
308
+                       return -EINVAL;
 
309
+               }
 
310
+       }
 
311
+
 
312
+       if (!session->hid) {
 
313
+               session->input = input_allocate_device();
 
314
+               if (!session->input) {
 
315
+                       kfree(session);
 
316
+                       return -ENOMEM;
 
317
+               }
 
318
+       }
 
319
+#endif
 
320
        down_write(&hidp_session_sem);
 
321
 
 
322
        s = __hidp_get_session(&bt_sk(ctrl_sock->sk)->dst);
 
323
@@ -1011,6 +1128,7 @@ int hidp_add_connection(struct hidp_conn
 
324
 
 
325
        __hidp_link_session(session);
 
326
 
 
327
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,27))
 
328
        if (req->rd_size > 0) {
 
329
                err = hidp_setup_hid(session, req);
 
330
                if (err)
 
331
@@ -1022,6 +1140,16 @@ int hidp_add_connection(struct hidp_conn
 
332
                if (err < 0)
 
333
                        goto purge;
 
334
        }
 
335
+#else
 
336
+       if (session->input) {
 
337
+               err = hidp_setup_input(session, req);
 
338
+               if (err < 0)
 
339
+                       goto failed;
 
340
+       }
 
341
+
 
342
+       if (session->hid)
 
343
+               hidp_setup_hid(session, req);
 
344
+#endif
 
345
 
 
346
        hidp_set_timer(session);
 
347
 
 
348
@@ -1080,6 +1208,7 @@ unlink:
 
349
                session->input = NULL;
 
350
        }
 
351
 
 
352
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,27))
 
353
        if (session->hid) {
 
354
                hid_destroy_device(session->hid);
 
355
                session->hid = NULL;
 
356
@@ -1093,10 +1222,15 @@ purge:
 
357
 
 
358
        skb_queue_purge(&session->ctrl_transmit);
 
359
        skb_queue_purge(&session->intr_transmit);
 
360
+#endif
 
361
 
 
362
 failed:
 
363
        up_write(&hidp_session_sem);
 
364
 
 
365
+#if (LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,27))
 
366
+       if (session->hid)
 
367
+               hid_free_device(session->hid);
 
368
+#endif
 
369
        kfree(session);
 
370
        return err;
 
371
 }
 
372
--- a/net/bluetooth/rfcomm/sock.c
 
373
+++ b/net/bluetooth/rfcomm/sock.c
 
374
@@ -306,8 +306,13 @@ static struct sock *rfcomm_sock_alloc(st
 
375
        return sk;
 
376
 }
 
377
 
 
378
+#if defined(CONFIG_COMPAT_BT_SOCK_CREATE_NEEDS_KERN)
 
379
 static int rfcomm_sock_create(struct net *net, struct socket *sock,
 
380
                              int protocol, int kern)
 
381
+#else
 
382
+static int rfcomm_sock_create(struct net *net, struct socket *sock,
 
383
+                             int protocol)
 
384
+#endif
 
385
 {
 
386
        struct sock *sk;
 
387
 
 
388
@@ -662,7 +667,11 @@ static int rfcomm_sock_setsockopt_old(st
 
389
        return err;
 
390
 }
 
391
 
 
392
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,31))
 
393
 static int rfcomm_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen)
 
394
+#else
 
395
+static int rfcomm_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, int optlen)
 
396
+#endif
 
397
 {
 
398
        struct sock *sk = sock->sk;
 
399
        struct bt_security sec;
 
400
--- a/net/bluetooth/rfcomm/tty.c
 
401
+++ b/net/bluetooth/rfcomm/tty.c
 
402
@@ -713,8 +713,12 @@ static int rfcomm_tty_open(struct tty_st
 
403
        remove_wait_queue(&dev->wait, &wait);
 
404
 
 
405
        if (err == 0)
 
406
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,29))
 
407
                device_move(dev->tty_dev, rfcomm_get_device(dev),
 
408
                            DPM_ORDER_DEV_AFTER_PARENT);
 
409
+#else
 
410
+               device_move(dev->tty_dev, rfcomm_get_device(dev));
 
411
+#endif
 
412
 
 
413
        rfcomm_tty_copy_pending(dev);
 
414
 
 
415
@@ -738,7 +742,11 @@ static void rfcomm_tty_close(struct tty_
 
416
        if (!--dev->port.count) {
 
417
                spin_unlock_irqrestore(&dev->port.lock, flags);
 
418
                if (dev->tty_dev->parent)
 
419
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,29))
 
420
                        device_move(dev->tty_dev, NULL, DPM_ORDER_DEV_LAST);
 
421
+#else
 
422
+                       device_move(dev->tty_dev, NULL);
 
423
+#endif
 
424
 
 
425
                /* Close DLC and dettach TTY */
 
426
                rfcomm_dlc_close(dev->dlc, 0);
 
427
@@ -814,7 +822,11 @@ static int rfcomm_tty_write_room(struct
 
428
        return room;
 
429
 }
 
430
 
 
431
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,38))
 
432
 static int rfcomm_tty_ioctl(struct tty_struct *tty, unsigned int cmd, unsigned long arg)
 
433
+#else
 
434
+static int rfcomm_tty_ioctl(struct tty_struct *tty, struct file *filp, unsigned int cmd, unsigned long arg)
 
435
+#endif
 
436
 {
 
437
        BT_DBG("tty %p cmd 0x%02x", tty, cmd);
 
438
 
 
439
@@ -1073,7 +1085,11 @@ static void rfcomm_tty_hangup(struct tty
 
440
        }
 
441
 }
 
442
 
 
443
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,38))
 
444
 static int rfcomm_tty_tiocmget(struct tty_struct *tty)
 
445
+#else
 
446
+static int rfcomm_tty_tiocmget(struct tty_struct *tty, struct file *filp)
 
447
+#endif
 
448
 {
 
449
        struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
 
450
 
 
451
@@ -1082,7 +1098,11 @@ static int rfcomm_tty_tiocmget(struct tt
 
452
        return dev->modem_status;
 
453
 }
 
454
 
 
455
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,38))
 
456
 static int rfcomm_tty_tiocmset(struct tty_struct *tty, unsigned int set, unsigned int clear)
 
457
+#else
 
458
+static int rfcomm_tty_tiocmset(struct tty_struct *tty, struct file *filp, unsigned int set, unsigned int clear)
 
459
+#endif
 
460
 {
 
461
        struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
 
462
        struct rfcomm_dlc *dlc = dev->dlc;
 
463
--- a/net/bluetooth/sco.c
 
464
+++ b/net/bluetooth/sco.c
 
465
@@ -432,8 +432,12 @@ static struct sock *sco_sock_alloc(struc
 
466
        return sk;
 
467
 }
 
468
 
 
469
+#if defined(CONFIG_COMPAT_BT_SOCK_CREATE_NEEDS_KERN)
 
470
 static int sco_sock_create(struct net *net, struct socket *sock, int protocol,
 
471
                           int kern)
 
472
+#else
 
473
+static int sco_sock_create(struct net *net, struct socket *sock, int protocol)
 
474
+#endif
 
475
 {
 
476
        struct sock *sk;
 
477
 
 
478
@@ -662,7 +666,11 @@ static int sco_sock_sendmsg(struct kiocb
 
479
        return err;
 
480
 }
 
481
 
 
482
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,31))
 
483
 static int sco_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen)
 
484
+#else
 
485
+static int sco_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, int optlen)
 
486
+#endif
 
487
 {
 
488
        struct sock *sk = sock->sk;
 
489
        int err = 0;
 
490
--- a/net/bluetooth/bnep/sock.c
 
491
+++ b/net/bluetooth/bnep/sock.c
 
492
@@ -180,8 +180,12 @@ static struct proto bnep_proto = {
 
493
        .obj_size       = sizeof(struct bt_sock)
 
494
 };
 
495
 
 
496
+#if defined(CONFIG_COMPAT_BT_SOCK_CREATE_NEEDS_KERN)
 
497
 static int bnep_sock_create(struct net *net, struct socket *sock, int protocol,
 
498
                            int kern)
 
499
+#else
 
500
+static int bnep_sock_create(struct net *net, struct socket *sock, int protocol)
 
501
+#endif
 
502
 {
 
503
        struct sock *sk;
 
504
 
 
505
--- a/net/bluetooth/cmtp/sock.c
 
506
+++ b/net/bluetooth/cmtp/sock.c
 
507
@@ -189,8 +189,12 @@ static struct proto cmtp_proto = {
 
508
        .obj_size       = sizeof(struct bt_sock)
 
509
 };
 
510
 
 
511
+#if defined(CONFIG_COMPAT_BT_SOCK_CREATE_NEEDS_KERN)
 
512
 static int cmtp_sock_create(struct net *net, struct socket *sock, int protocol,
 
513
                            int kern)
 
514
+#else
 
515
+static int cmtp_sock_create(struct net *net, struct socket *sock, int protocol)
 
516
+#endif
 
517
 {
 
518
        struct sock *sk;
 
519
 
 
520
--- a/net/bluetooth/hidp/sock.c
 
521
+++ b/net/bluetooth/hidp/sock.c
 
522
@@ -229,8 +229,12 @@ static struct proto hidp_proto = {
 
523
        .obj_size       = sizeof(struct bt_sock)
 
524
 };
 
525
 
 
526
+#if defined(CONFIG_COMPAT_BT_SOCK_CREATE_NEEDS_KERN)
 
527
 static int hidp_sock_create(struct net *net, struct socket *sock, int protocol,
 
528
                            int kern)
 
529
+#else
 
530
+static int hidp_sock_create(struct net *net, struct socket *sock, int protocol)
 
531
+#endif
 
532
 {
 
533
        struct sock *sk;
 
534
 
 
535
--- a/net/bluetooth/l2cap_sock.c
 
536
+++ b/net/bluetooth/l2cap_sock.c
 
537
@@ -560,7 +560,14 @@ static int l2cap_sock_setsockopt_old(str
 
538
        return err;
 
539
 }
 
540
 
 
541
+
 
542
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,31))
 
543
 static int l2cap_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen)
 
544
+#else
 
545
+static int l2cap_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, int optlen)
 
546
+#endif
 
547
+
 
548
+
 
549
 {
 
550
        struct sock *sk = sock->sk;
 
551
        struct l2cap_chan *chan = l2cap_pi(sk)->chan;
 
552
@@ -1188,8 +1195,12 @@ static struct sock *l2cap_sock_alloc(str
 
553
        return sk;
 
554
 }
 
555
 
 
556
+#if defined(CONFIG_COMPAT_BT_SOCK_CREATE_NEEDS_KERN)
 
557
 static int l2cap_sock_create(struct net *net, struct socket *sock, int protocol,
 
558
                             int kern)
 
559
+#else
 
560
+static int l2cap_sock_create(struct net *net, struct socket *sock, int protocol)
 
561
+#endif
 
562
 {
 
563
        struct sock *sk;
 
564
 
 
565
@@ -1201,7 +1212,11 @@ static int l2cap_sock_create(struct net
 
566
                        sock->type != SOCK_DGRAM && sock->type != SOCK_RAW)
 
567
                return -ESOCKTNOSUPPORT;
 
568
 
 
569
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,32))
 
570
        if (sock->type == SOCK_RAW && !kern && !capable(CAP_NET_RAW))
 
571
+#else
 
572
+       if (sock->type == SOCK_RAW && !capable(CAP_NET_RAW))
 
573
+#endif
 
574
                return -EPERM;
 
575
 
 
576
        sock->ops = &l2cap_sock_ops;