Commit 9c119ba54c0fcae72881948af3d37b47a2f8e1f9

Authored by David S. Miller

Merge branch 'master' of master.kernel.org:/pub/scm/linux/kernel/git/davem/net-2.6

Showing 23 changed files Side-by-side Diff

drivers/bluetooth/Kconfig
... ... @@ -195,5 +195,17 @@
195 195 Say Y here to compile support for Marvell BT-over-SDIO driver
196 196 into the kernel or say M to compile it as module.
197 197  
  198 +config BT_ATH3K
  199 + tristate "Atheros firmware download driver"
  200 + depends on BT_HCIBTUSB
  201 + select FW_LOADER
  202 + help
  203 + Bluetooth firmware download driver.
  204 + This driver loads the firmware into the Atheros Bluetooth
  205 + chipset.
  206 +
  207 + Say Y here to compile support for "Atheros firmware download driver"
  208 + into the kernel or say M to compile it as module (ath3k).
  209 +
198 210 endmenu
drivers/bluetooth/Makefile
... ... @@ -15,6 +15,7 @@
15 15 obj-$(CONFIG_BT_HCIBTUSB) += btusb.o
16 16 obj-$(CONFIG_BT_HCIBTSDIO) += btsdio.o
17 17  
  18 +obj-$(CONFIG_BT_ATH3K) += ath3k.o
18 19 obj-$(CONFIG_BT_MRVL) += btmrvl.o
19 20 obj-$(CONFIG_BT_MRVL_SDIO) += btmrvl_sdio.o
20 21  
drivers/bluetooth/ath3k.c
  1 +/*
  2 + * Copyright (c) 2008-2009 Atheros Communications Inc.
  3 + *
  4 + * This program is free software; you can redistribute it and/or modify
  5 + * it under the terms of the GNU General Public License as published by
  6 + * the Free Software Foundation; either version 2 of the License, or
  7 + * (at your option) any later version.
  8 + *
  9 + * This program is distributed in the hope that it will be useful,
  10 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  12 + * GNU General Public License for more details.
  13 + *
  14 + * You should have received a copy of the GNU General Public License
  15 + * along with this program; if not, write to the Free Software
  16 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  17 + *
  18 + */
  19 +
  20 +
  21 +#include <linux/module.h>
  22 +#include <linux/kernel.h>
  23 +#include <linux/init.h>
  24 +#include <linux/slab.h>
  25 +#include <linux/types.h>
  26 +#include <linux/errno.h>
  27 +#include <linux/device.h>
  28 +#include <linux/firmware.h>
  29 +#include <linux/usb.h>
  30 +#include <net/bluetooth/bluetooth.h>
  31 +
  32 +#define VERSION "1.0"
  33 +
  34 +
  35 +static struct usb_device_id ath3k_table[] = {
  36 + /* Atheros AR3011 */
  37 + { USB_DEVICE(0x0CF3, 0x3000) },
  38 + { } /* Terminating entry */
  39 +};
  40 +
  41 +MODULE_DEVICE_TABLE(usb, ath3k_table);
  42 +
  43 +#define USB_REQ_DFU_DNLOAD 1
  44 +#define BULK_SIZE 4096
  45 +
  46 +struct ath3k_data {
  47 + struct usb_device *udev;
  48 + u8 *fw_data;
  49 + u32 fw_size;
  50 + u32 fw_sent;
  51 +};
  52 +
  53 +static int ath3k_load_firmware(struct ath3k_data *data,
  54 + unsigned char *firmware,
  55 + int count)
  56 +{
  57 + u8 *send_buf;
  58 + int err, pipe, len, size, sent = 0;
  59 +
  60 + BT_DBG("ath3k %p udev %p", data, data->udev);
  61 +
  62 + pipe = usb_sndctrlpipe(data->udev, 0);
  63 +
  64 + if ((usb_control_msg(data->udev, pipe,
  65 + USB_REQ_DFU_DNLOAD,
  66 + USB_TYPE_VENDOR, 0, 0,
  67 + firmware, 20, USB_CTRL_SET_TIMEOUT)) < 0) {
  68 + BT_ERR("Can't change to loading configuration err");
  69 + return -EBUSY;
  70 + }
  71 + sent += 20;
  72 + count -= 20;
  73 +
  74 + send_buf = kmalloc(BULK_SIZE, GFP_ATOMIC);
  75 + if (!send_buf) {
  76 + BT_ERR("Can't allocate memory chunk for firmware");
  77 + return -ENOMEM;
  78 + }
  79 +
  80 + while (count) {
  81 + size = min_t(uint, count, BULK_SIZE);
  82 + pipe = usb_sndbulkpipe(data->udev, 0x02);
  83 + memcpy(send_buf, firmware + sent, size);
  84 +
  85 + err = usb_bulk_msg(data->udev, pipe, send_buf, size,
  86 + &len, 3000);
  87 +
  88 + if (err || (len != size)) {
  89 + BT_ERR("Error in firmware loading err = %d,"
  90 + "len = %d, size = %d", err, len, size);
  91 + goto error;
  92 + }
  93 +
  94 + sent += size;
  95 + count -= size;
  96 + }
  97 +
  98 + kfree(send_buf);
  99 + return 0;
  100 +
  101 +error:
  102 + kfree(send_buf);
  103 + return err;
  104 +}
  105 +
  106 +static int ath3k_probe(struct usb_interface *intf,
  107 + const struct usb_device_id *id)
  108 +{
  109 + const struct firmware *firmware;
  110 + struct usb_device *udev = interface_to_usbdev(intf);
  111 + struct ath3k_data *data;
  112 + int size;
  113 +
  114 + BT_DBG("intf %p id %p", intf, id);
  115 +
  116 + if (intf->cur_altsetting->desc.bInterfaceNumber != 0)
  117 + return -ENODEV;
  118 +
  119 + data = kzalloc(sizeof(*data), GFP_KERNEL);
  120 + if (!data)
  121 + return -ENOMEM;
  122 +
  123 + data->udev = udev;
  124 +
  125 + if (request_firmware(&firmware, "ath3k-1.fw", &udev->dev) < 0) {
  126 + kfree(data);
  127 + return -EIO;
  128 + }
  129 +
  130 + size = max_t(uint, firmware->size, 4096);
  131 + data->fw_data = kmalloc(size, GFP_KERNEL);
  132 + if (!data->fw_data) {
  133 + release_firmware(firmware);
  134 + kfree(data);
  135 + return -ENOMEM;
  136 + }
  137 +
  138 + memcpy(data->fw_data, firmware->data, firmware->size);
  139 + data->fw_size = firmware->size;
  140 + data->fw_sent = 0;
  141 + release_firmware(firmware);
  142 +
  143 + usb_set_intfdata(intf, data);
  144 + if (ath3k_load_firmware(data, data->fw_data, data->fw_size)) {
  145 + usb_set_intfdata(intf, NULL);
  146 + return -EIO;
  147 + }
  148 +
  149 + return 0;
  150 +}
  151 +
  152 +static void ath3k_disconnect(struct usb_interface *intf)
  153 +{
  154 + struct ath3k_data *data = usb_get_intfdata(intf);
  155 +
  156 + BT_DBG("ath3k_disconnect intf %p", intf);
  157 +
  158 + kfree(data->fw_data);
  159 + kfree(data);
  160 +}
  161 +
  162 +static struct usb_driver ath3k_driver = {
  163 + .name = "ath3k",
  164 + .probe = ath3k_probe,
  165 + .disconnect = ath3k_disconnect,
  166 + .id_table = ath3k_table,
  167 +};
  168 +
  169 +static int __init ath3k_init(void)
  170 +{
  171 + BT_INFO("Atheros AR30xx firmware driver ver %s", VERSION);
  172 + return usb_register(&ath3k_driver);
  173 +}
  174 +
  175 +static void __exit ath3k_exit(void)
  176 +{
  177 + usb_deregister(&ath3k_driver);
  178 +}
  179 +
  180 +module_init(ath3k_init);
  181 +module_exit(ath3k_exit);
  182 +
  183 +MODULE_AUTHOR("Atheros Communications");
  184 +MODULE_DESCRIPTION("Atheros AR30xx firmware driver");
  185 +MODULE_VERSION(VERSION);
  186 +MODULE_LICENSE("GPL");
  187 +MODULE_FIRMWARE("ath3k-1.fw");
drivers/bluetooth/bluecard_cs.c
... ... @@ -503,7 +503,9 @@
503 503 unsigned int iobase;
504 504 unsigned char reg;
505 505  
506   - BUG_ON(!info->hdev);
  506 + if (!info || !info->hdev)
  507 + /* our irq handler is shared */
  508 + return IRQ_NONE;
507 509  
508 510 if (!test_bit(CARD_READY, &(info->hw_state)))
509 511 return IRQ_HANDLED;
drivers/bluetooth/bt3c_cs.c
... ... @@ -345,7 +345,9 @@
345 345 int iir;
346 346 irqreturn_t r = IRQ_NONE;
347 347  
348   - BUG_ON(!info->hdev);
  348 + if (!info || !info->hdev)
  349 + /* our irq handler is shared */
  350 + return IRQ_NONE;
349 351  
350 352 iobase = info->p_dev->io.BasePort1;
351 353  
drivers/bluetooth/btuart_cs.c
... ... @@ -295,7 +295,9 @@
295 295 int iir, lsr;
296 296 irqreturn_t r = IRQ_NONE;
297 297  
298   - BUG_ON(!info->hdev);
  298 + if (!info || !info->hdev)
  299 + /* our irq handler is shared */
  300 + return IRQ_NONE;
299 301  
300 302 iobase = info->p_dev->io.BasePort1;
301 303  
drivers/bluetooth/dtl1_cs.c
... ... @@ -299,7 +299,9 @@
299 299 int iir, lsr;
300 300 irqreturn_t r = IRQ_NONE;
301 301  
302   - BUG_ON(!info->hdev);
  302 + if (!info || !info->hdev)
  303 + /* our irq handler is shared */
  304 + return IRQ_NONE;
303 305  
304 306 iobase = info->p_dev->io.BasePort1;
305 307  
drivers/connector/connector.c
... ... @@ -36,17 +36,6 @@
36 36 MODULE_AUTHOR("Evgeniy Polyakov <zbr@ioremap.net>");
37 37 MODULE_DESCRIPTION("Generic userspace <-> kernelspace connector.");
38 38  
39   -static u32 cn_idx = CN_IDX_CONNECTOR;
40   -static u32 cn_val = CN_VAL_CONNECTOR;
41   -
42   -module_param(cn_idx, uint, 0);
43   -module_param(cn_val, uint, 0);
44   -MODULE_PARM_DESC(cn_idx, "Connector's main device idx.");
45   -MODULE_PARM_DESC(cn_val, "Connector's main device val.");
46   -
47   -static DEFINE_MUTEX(notify_lock);
48   -static LIST_HEAD(notify_list);
49   -
50 39 static struct cn_dev cdev;
51 40  
52 41 static int cn_already_initialized;
... ... @@ -210,54 +199,6 @@
210 199 }
211 200  
212 201 /*
213   - * Notification routing.
214   - *
215   - * Gets id and checks if there are notification request for it's idx
216   - * and val. If there are such requests notify the listeners with the
217   - * given notify event.
218   - *
219   - */
220   -static void cn_notify(struct cb_id *id, u32 notify_event)
221   -{
222   - struct cn_ctl_entry *ent;
223   -
224   - mutex_lock(&notify_lock);
225   - list_for_each_entry(ent, &notify_list, notify_entry) {
226   - int i;
227   - struct cn_notify_req *req;
228   - struct cn_ctl_msg *ctl = ent->msg;
229   - int idx_found, val_found;
230   -
231   - idx_found = val_found = 0;
232   -
233   - req = (struct cn_notify_req *)ctl->data;
234   - for (i = 0; i < ctl->idx_notify_num; ++i, ++req) {
235   - if (id->idx >= req->first &&
236   - id->idx < req->first + req->range) {
237   - idx_found = 1;
238   - break;
239   - }
240   - }
241   -
242   - for (i = 0; i < ctl->val_notify_num; ++i, ++req) {
243   - if (id->val >= req->first &&
244   - id->val < req->first + req->range) {
245   - val_found = 1;
246   - break;
247   - }
248   - }
249   -
250   - if (idx_found && val_found) {
251   - struct cn_msg m = { .ack = notify_event, };
252   -
253   - memcpy(&m.id, id, sizeof(m.id));
254   - cn_netlink_send(&m, ctl->group, GFP_KERNEL);
255   - }
256   - }
257   - mutex_unlock(&notify_lock);
258   -}
259   -
260   -/*
261 202 * Callback add routing - adds callback with given ID and name.
262 203 * If there is registered callback with the same ID it will not be added.
263 204 *
... ... @@ -276,8 +217,6 @@
276 217 if (err)
277 218 return err;
278 219  
279   - cn_notify(id, 0);
280   -
281 220 return 0;
282 221 }
283 222 EXPORT_SYMBOL_GPL(cn_add_callback);
284 223  
... ... @@ -295,111 +234,9 @@
295 234 struct cn_dev *dev = &cdev;
296 235  
297 236 cn_queue_del_callback(dev->cbdev, id);
298   - cn_notify(id, 1);
299 237 }
300 238 EXPORT_SYMBOL_GPL(cn_del_callback);
301 239  
302   -/*
303   - * Checks two connector's control messages to be the same.
304   - * Returns 1 if they are the same or if the first one is corrupted.
305   - */
306   -static int cn_ctl_msg_equals(struct cn_ctl_msg *m1, struct cn_ctl_msg *m2)
307   -{
308   - int i;
309   - struct cn_notify_req *req1, *req2;
310   -
311   - if (m1->idx_notify_num != m2->idx_notify_num)
312   - return 0;
313   -
314   - if (m1->val_notify_num != m2->val_notify_num)
315   - return 0;
316   -
317   - if (m1->len != m2->len)
318   - return 0;
319   -
320   - if ((m1->idx_notify_num + m1->val_notify_num) * sizeof(*req1) !=
321   - m1->len)
322   - return 1;
323   -
324   - req1 = (struct cn_notify_req *)m1->data;
325   - req2 = (struct cn_notify_req *)m2->data;
326   -
327   - for (i = 0; i < m1->idx_notify_num; ++i) {
328   - if (req1->first != req2->first || req1->range != req2->range)
329   - return 0;
330   - req1++;
331   - req2++;
332   - }
333   -
334   - for (i = 0; i < m1->val_notify_num; ++i) {
335   - if (req1->first != req2->first || req1->range != req2->range)
336   - return 0;
337   - req1++;
338   - req2++;
339   - }
340   -
341   - return 1;
342   -}
343   -
344   -/*
345   - * Main connector device's callback.
346   - *
347   - * Used for notification of a request's processing.
348   - */
349   -static void cn_callback(struct cn_msg *msg, struct netlink_skb_parms *nsp)
350   -{
351   - struct cn_ctl_msg *ctl;
352   - struct cn_ctl_entry *ent;
353   - u32 size;
354   -
355   - if (msg->len < sizeof(*ctl))
356   - return;
357   -
358   - ctl = (struct cn_ctl_msg *)msg->data;
359   -
360   - size = (sizeof(*ctl) + ((ctl->idx_notify_num +
361   - ctl->val_notify_num) *
362   - sizeof(struct cn_notify_req)));
363   -
364   - if (msg->len != size)
365   - return;
366   -
367   - if (ctl->len + sizeof(*ctl) != msg->len)
368   - return;
369   -
370   - /*
371   - * Remove notification.
372   - */
373   - if (ctl->group == 0) {
374   - struct cn_ctl_entry *n;
375   -
376   - mutex_lock(&notify_lock);
377   - list_for_each_entry_safe(ent, n, &notify_list, notify_entry) {
378   - if (cn_ctl_msg_equals(ent->msg, ctl)) {
379   - list_del(&ent->notify_entry);
380   - kfree(ent);
381   - }
382   - }
383   - mutex_unlock(&notify_lock);
384   -
385   - return;
386   - }
387   -
388   - size += sizeof(*ent);
389   -
390   - ent = kzalloc(size, GFP_KERNEL);
391   - if (!ent)
392   - return;
393   -
394   - ent->msg = (struct cn_ctl_msg *)(ent + 1);
395   -
396   - memcpy(ent->msg, ctl, size - sizeof(*ent));
397   -
398   - mutex_lock(&notify_lock);
399   - list_add(&ent->notify_entry, &notify_list);
400   - mutex_unlock(&notify_lock);
401   -}
402   -
403 240 static int cn_proc_show(struct seq_file *m, void *v)
404 241 {
405 242 struct cn_queue_dev *dev = cdev.cbdev;
406 243  
... ... @@ -437,11 +274,8 @@
437 274 static int __devinit cn_init(void)
438 275 {
439 276 struct cn_dev *dev = &cdev;
440   - int err;
441 277  
442 278 dev->input = cn_rx_skb;
443   - dev->id.idx = cn_idx;
444   - dev->id.val = cn_val;
445 279  
446 280 dev->nls = netlink_kernel_create(&init_net, NETLINK_CONNECTOR,
447 281 CN_NETLINK_USERS + 0xf,
... ... @@ -457,14 +291,6 @@
457 291  
458 292 cn_already_initialized = 1;
459 293  
460   - err = cn_add_callback(&dev->id, "connector", &cn_callback);
461   - if (err) {
462   - cn_already_initialized = 0;
463   - cn_queue_free_dev(dev->cbdev);
464   - netlink_kernel_release(dev->nls);
465   - return -EINVAL;
466   - }
467   -
468 294 proc_net_fops_create(&init_net, "connector", S_IRUGO, &cn_file_ops);
469 295  
470 296 return 0;
... ... @@ -478,7 +304,6 @@
478 304  
479 305 proc_net_remove(&init_net, "connector");
480 306  
481   - cn_del_callback(&dev->id);
482 307 cn_queue_free_dev(dev->cbdev);
483 308 netlink_kernel_release(dev->nls);
484 309 }
drivers/net/benet/be_main.c
... ... @@ -1350,7 +1350,7 @@
1350 1350 int isr;
1351 1351  
1352 1352 isr = ioread32(adapter->csr + CEV_ISR0_OFFSET +
1353   - be_pci_func(adapter) * CEV_ISR_SIZE);
  1353 + (adapter->tx_eq.q.id/ 8) * CEV_ISR_SIZE);
1354 1354 if (!isr)
1355 1355 return IRQ_NONE;
1356 1356  
... ... @@ -2168,7 +2168,7 @@
2168 2168 cmd->va = pci_alloc_consistent(adapter->pdev, cmd->size, &cmd->dma);
2169 2169 if (cmd->va == NULL)
2170 2170 return -1;
2171   - memset(cmd->va, cmd->size, 0);
  2171 + memset(cmd->va, 0, cmd->size);
2172 2172 return 0;
2173 2173 }
2174 2174  
drivers/net/ixgbe/ixgbe_main.c
... ... @@ -5384,7 +5384,7 @@
5384 5384 ixgbe_unmap_and_free_tx_resource(adapter, tx_buffer_info);
5385 5385 }
5386 5386  
5387   - return count;
  5387 + return 0;
5388 5388 }
5389 5389  
5390 5390 static void ixgbe_tx_queue(struct ixgbe_adapter *adapter,
5391 5391  
... ... @@ -5534,8 +5534,11 @@
5534 5534 struct ixgbe_adapter *adapter = netdev_priv(dev);
5535 5535 int txq = smp_processor_id();
5536 5536  
5537   - if (adapter->flags & IXGBE_FLAG_FDIR_HASH_CAPABLE)
  5537 + if (adapter->flags & IXGBE_FLAG_FDIR_HASH_CAPABLE) {
  5538 + while (unlikely(txq >= dev->real_num_tx_queues))
  5539 + txq -= dev->real_num_tx_queues;
5538 5540 return txq;
  5541 + }
5539 5542  
5540 5543 #ifdef IXGBE_FCOE
5541 5544 if ((adapter->flags & IXGBE_FLAG_FCOE_ENABLED) &&
drivers/net/netxen/netxen_nic_main.c
... ... @@ -1995,7 +1995,7 @@
1995 1995 netif_wake_queue(adapter->netdev);
1996 1996  
1997 1997 clear_bit(__NX_RESETTING, &adapter->state);
1998   -
  1998 + return;
1999 1999 } else {
2000 2000 clear_bit(__NX_RESETTING, &adapter->state);
2001 2001 if (!netxen_nic_reset_context(adapter)) {
2002 2002  
... ... @@ -2323,7 +2323,9 @@
2323 2323  
2324 2324 netxen_nic_down(adapter, netdev);
2325 2325  
  2326 + rtnl_lock();
2326 2327 netxen_nic_detach(adapter);
  2328 + rtnl_unlock();
2327 2329  
2328 2330 status = NXRD32(adapter, NETXEN_PEG_HALT_STATUS1);
2329 2331  
... ... @@ -1025,11 +1025,8 @@
1025 1025 static inline struct sky2_tx_le *get_tx_le(struct sky2_port *sky2, u16 *slot)
1026 1026 {
1027 1027 struct sky2_tx_le *le = sky2->tx_le + *slot;
1028   - struct tx_ring_info *re = sky2->tx_ring + *slot;
1029 1028  
1030 1029 *slot = RING_NEXT(*slot, sky2->tx_ring_size);
1031   - re->flags = 0;
1032   - re->skb = NULL;
1033 1030 le->ctrl = 0;
1034 1031 return le;
1035 1032 }
... ... @@ -1622,8 +1619,7 @@
1622 1619 return count;
1623 1620 }
1624 1621  
1625   -static void sky2_tx_unmap(struct pci_dev *pdev,
1626   - const struct tx_ring_info *re)
  1622 +static void sky2_tx_unmap(struct pci_dev *pdev, struct tx_ring_info *re)
1627 1623 {
1628 1624 if (re->flags & TX_MAP_SINGLE)
1629 1625 pci_unmap_single(pdev, pci_unmap_addr(re, mapaddr),
... ... @@ -1633,6 +1629,7 @@
1633 1629 pci_unmap_page(pdev, pci_unmap_addr(re, mapaddr),
1634 1630 pci_unmap_len(re, maplen),
1635 1631 PCI_DMA_TODEVICE);
  1632 + re->flags = 0;
1636 1633 }
1637 1634  
1638 1635 /*
... ... @@ -1839,6 +1836,7 @@
1839 1836 dev->stats.tx_packets++;
1840 1837 dev->stats.tx_bytes += skb->len;
1841 1838  
  1839 + re->skb = NULL;
1842 1840 dev_kfree_skb_any(skb);
1843 1841  
1844 1842 sky2->tx_next = RING_NEXT(idx, sky2->tx_ring_size);
drivers/net/usb/cdc_ether.c
... ... @@ -419,7 +419,7 @@
419 419  
420 420 static const struct driver_info cdc_info = {
421 421 .description = "CDC Ethernet Device",
422   - .flags = FLAG_ETHER | FLAG_LINK_INTR,
  422 + .flags = FLAG_ETHER,
423 423 // .check_connect = cdc_check_connect,
424 424 .bind = cdc_bind,
425 425 .unbind = usbnet_cdc_unbind,
include/linux/connector.h
... ... @@ -24,9 +24,6 @@
24 24  
25 25 #include <linux/types.h>
26 26  
27   -#define CN_IDX_CONNECTOR 0xffffffff
28   -#define CN_VAL_CONNECTOR 0xffffffff
29   -
30 27 /*
31 28 * Process Events connector unique ids -- used for message routing
32 29 */
... ... @@ -75,30 +72,6 @@
75 72 __u8 data[0];
76 73 };
77 74  
78   -/*
79   - * Notify structure - requests notification about
80   - * registering/unregistering idx/val in range [first, first+range].
81   - */
82   -struct cn_notify_req {
83   - __u32 first;
84   - __u32 range;
85   -};
86   -
87   -/*
88   - * Main notification control message
89   - * *_notify_num - number of appropriate cn_notify_req structures after
90   - * this struct.
91   - * group - notification receiver's idx.
92   - * len - total length of the attached data.
93   - */
94   -struct cn_ctl_msg {
95   - __u32 idx_notify_num;
96   - __u32 val_notify_num;
97   - __u32 group;
98   - __u32 len;
99   - __u8 data[0];
100   -};
101   -
102 75 #ifdef __KERNEL__
103 76  
104 77 #include <asm/atomic.h>
... ... @@ -149,11 +122,6 @@
149 122 struct cn_callback_data data;
150 123  
151 124 u32 seq, group;
152   -};
153   -
154   -struct cn_ctl_entry {
155   - struct list_head notify_entry;
156   - struct cn_ctl_msg *msg;
157 125 };
158 126  
159 127 struct cn_dev {
net/bluetooth/hidp/core.c
... ... @@ -243,6 +243,39 @@
243 243 input_sync(dev);
244 244 }
245 245  
  246 +static int __hidp_send_ctrl_message(struct hidp_session *session,
  247 + unsigned char hdr, unsigned char *data, int size)
  248 +{
  249 + struct sk_buff *skb;
  250 +
  251 + BT_DBG("session %p data %p size %d", session, data, size);
  252 +
  253 + if (!(skb = alloc_skb(size + 1, GFP_ATOMIC))) {
  254 + BT_ERR("Can't allocate memory for new frame");
  255 + return -ENOMEM;
  256 + }
  257 +
  258 + *skb_put(skb, 1) = hdr;
  259 + if (data && size > 0)
  260 + memcpy(skb_put(skb, size), data, size);
  261 +
  262 + skb_queue_tail(&session->ctrl_transmit, skb);
  263 +
  264 + return 0;
  265 +}
  266 +
  267 +static inline int hidp_send_ctrl_message(struct hidp_session *session,
  268 + unsigned char hdr, unsigned char *data, int size)
  269 +{
  270 + int err;
  271 +
  272 + err = __hidp_send_ctrl_message(session, hdr, data, size);
  273 +
  274 + hidp_schedule(session);
  275 +
  276 + return err;
  277 +}
  278 +
246 279 static int hidp_queue_report(struct hidp_session *session,
247 280 unsigned char *data, int size)
248 281 {
... ... @@ -282,7 +315,9 @@
282 315  
283 316 static int hidp_output_raw_report(struct hid_device *hid, unsigned char *data, size_t count)
284 317 {
285   - if (hidp_queue_report(hid->driver_data, data, count))
  318 + if (hidp_send_ctrl_message(hid->driver_data,
  319 + HIDP_TRANS_SET_REPORT | HIDP_DATA_RTYPE_FEATURE,
  320 + data, count))
286 321 return -ENOMEM;
287 322 return count;
288 323 }
... ... @@ -305,39 +340,6 @@
305 340 {
306 341 if (session->idle_to > 0)
307 342 del_timer(&session->timer);
308   -}
309   -
310   -static int __hidp_send_ctrl_message(struct hidp_session *session,
311   - unsigned char hdr, unsigned char *data, int size)
312   -{
313   - struct sk_buff *skb;
314   -
315   - BT_DBG("session %p data %p size %d", session, data, size);
316   -
317   - if (!(skb = alloc_skb(size + 1, GFP_ATOMIC))) {
318   - BT_ERR("Can't allocate memory for new frame");
319   - return -ENOMEM;
320   - }
321   -
322   - *skb_put(skb, 1) = hdr;
323   - if (data && size > 0)
324   - memcpy(skb_put(skb, size), data, size);
325   -
326   - skb_queue_tail(&session->ctrl_transmit, skb);
327   -
328   - return 0;
329   -}
330   -
331   -static inline int hidp_send_ctrl_message(struct hidp_session *session,
332   - unsigned char hdr, unsigned char *data, int size)
333   -{
334   - int err;
335   -
336   - err = __hidp_send_ctrl_message(session, hdr, data, size);
337   -
338   - hidp_schedule(session);
339   -
340   - return err;
341 343 }
342 344  
343 345 static void hidp_process_handshake(struct hidp_session *session,
net/bluetooth/l2cap.c
... ... @@ -1368,7 +1368,6 @@
1368 1368  
1369 1369 while ((skb = sk->sk_send_head) && (!l2cap_tx_window_full(sk)) &&
1370 1370 !(pi->conn_state & L2CAP_CONN_REMOTE_BUSY)) {
1371   - tx_skb = skb_clone(skb, GFP_ATOMIC);
1372 1371  
1373 1372 if (pi->remote_max_tx &&
1374 1373 bt_cb(skb)->retries == pi->remote_max_tx) {
... ... @@ -1376,6 +1375,8 @@
1376 1375 break;
1377 1376 }
1378 1377  
  1378 + tx_skb = skb_clone(skb, GFP_ATOMIC);
  1379 +
1379 1380 bt_cb(skb)->retries++;
1380 1381  
1381 1382 control = get_unaligned_le16(tx_skb->data + L2CAP_HDR_SIZE);
... ... @@ -3518,7 +3519,6 @@
3518 3519 struct l2cap_pinfo *pi;
3519 3520 u16 control, len;
3520 3521 u8 tx_seq;
3521   - int err;
3522 3522  
3523 3523 sk = l2cap_get_chan_by_scid(&conn->chan_list, cid);
3524 3524 if (!sk) {
3525 3525  
3526 3526  
... ... @@ -3570,13 +3570,11 @@
3570 3570 goto drop;
3571 3571  
3572 3572 if (__is_iframe(control))
3573   - err = l2cap_data_channel_iframe(sk, control, skb);
  3573 + l2cap_data_channel_iframe(sk, control, skb);
3574 3574 else
3575   - err = l2cap_data_channel_sframe(sk, control, skb);
  3575 + l2cap_data_channel_sframe(sk, control, skb);
3576 3576  
3577   - if (!err)
3578   - goto done;
3579   - break;
  3577 + goto done;
3580 3578  
3581 3579 case L2CAP_MODE_STREAMING:
3582 3580 control = get_unaligned_le16(skb->data);
... ... @@ -3602,7 +3600,7 @@
3602 3600 else
3603 3601 pi->expected_tx_seq = tx_seq + 1;
3604 3602  
3605   - err = l2cap_sar_reassembly_sdu(sk, skb, control);
  3603 + l2cap_sar_reassembly_sdu(sk, skb, control);
3606 3604  
3607 3605 goto done;
3608 3606  
... ... @@ -83,7 +83,7 @@
83 83 va_list args;
84 84  
85 85 va_start(args, fmt);
86   - vsnprintf(slab_name_fmt, sizeof(slab_name_fmt), fmt, args);
  86 + vsnprintf(slab_name_fmt, CCID_SLAB_NAME_LENGTH, fmt, args);
87 87 va_end(args);
88 88  
89 89 slab = kmem_cache_create(slab_name_fmt, sizeof(struct ccid) + obj_size, 0,
... ... @@ -19,7 +19,9 @@
19 19 #include <linux/list.h>
20 20 #include <linux/module.h>
21 21  
22   -#define CCID_MAX 255
  22 +/* maximum value for a CCID (RFC 4340, 19.5) */
  23 +#define CCID_MAX 255
  24 +#define CCID_SLAB_NAME_LENGTH 32
23 25  
24 26 struct tcp_info;
25 27  
... ... @@ -49,8 +51,8 @@
49 51 const char *ccid_name;
50 52 struct kmem_cache *ccid_hc_rx_slab,
51 53 *ccid_hc_tx_slab;
52   - char ccid_hc_rx_slab_name[32];
53   - char ccid_hc_tx_slab_name[32];
  54 + char ccid_hc_rx_slab_name[CCID_SLAB_NAME_LENGTH];
  55 + char ccid_hc_tx_slab_name[CCID_SLAB_NAME_LENGTH];
54 56 __u32 ccid_hc_rx_obj_size,
55 57 ccid_hc_tx_obj_size;
56 58 /* Interface Routines */
... ... @@ -161,8 +161,8 @@
161 161 if (!proc_net_fops_create(&init_net, procname, S_IRUSR, &dccpprobe_fops))
162 162 goto err0;
163 163  
164   - ret = try_then_request_module((register_jprobe(&dccp_send_probe) == 0),
165   - "dccp");
  164 + try_then_request_module((ret = register_jprobe(&dccp_send_probe)) == 0,
  165 + "dccp");
166 166 if (ret)
167 167 goto err1;
168 168  
... ... @@ -3793,9 +3793,9 @@
3793 3793  
3794 3794 static void __exit ipsec_pfkey_exit(void)
3795 3795 {
3796   - unregister_pernet_subsys(&pfkey_net_ops);
3797 3796 xfrm_unregister_km(&pfkeyv2_mgr);
3798 3797 sock_unregister(PF_KEY);
  3798 + unregister_pernet_subsys(&pfkey_net_ops);
3799 3799 proto_unregister(&key_proto);
3800 3800 }
3801 3801  
3802 3802  
3803 3803  
3804 3804  
3805 3805  
... ... @@ -3806,21 +3806,22 @@
3806 3806 if (err != 0)
3807 3807 goto out;
3808 3808  
3809   - err = sock_register(&pfkey_family_ops);
  3809 + err = register_pernet_subsys(&pfkey_net_ops);
3810 3810 if (err != 0)
3811 3811 goto out_unregister_key_proto;
  3812 + err = sock_register(&pfkey_family_ops);
  3813 + if (err != 0)
  3814 + goto out_unregister_pernet;
3812 3815 err = xfrm_register_km(&pfkeyv2_mgr);
3813 3816 if (err != 0)
3814 3817 goto out_sock_unregister;
3815   - err = register_pernet_subsys(&pfkey_net_ops);
3816   - if (err != 0)
3817   - goto out_xfrm_unregister_km;
3818 3818 out:
3819 3819 return err;
3820   -out_xfrm_unregister_km:
3821   - xfrm_unregister_km(&pfkeyv2_mgr);
  3820 +
3822 3821 out_sock_unregister:
3823 3822 sock_unregister(PF_KEY);
  3823 +out_unregister_pernet:
  3824 + unregister_pernet_subsys(&pfkey_net_ops);
3824 3825 out_unregister_key_proto:
3825 3826 proto_unregister(&key_proto);
3826 3827 goto out;
net/netfilter/nf_conntrack_netlink.c
... ... @@ -1437,8 +1437,9 @@
1437 1437 struct nlattr *nest_parms;
1438 1438  
1439 1439 memset(&m, 0xFF, sizeof(m));
1440   - m.src.u.all = mask->src.u.all;
1441 1440 memcpy(&m.src.u3, &mask->src.u3, sizeof(m.src.u3));
  1441 + m.src.u.all = mask->src.u.all;
  1442 + m.dst.protonum = tuple->dst.protonum;
1442 1443  
1443 1444 nest_parms = nla_nest_start(skb, CTA_EXPECT_MASK | NLA_F_NESTED);
1444 1445 if (!nest_parms)
net/netfilter/nf_conntrack_sip.c
... ... @@ -376,7 +376,7 @@
376 376 dptr += hdr->len;
377 377 else if (hdr->cname && limit - dptr >= hdr->clen + 1 &&
378 378 strnicmp(dptr, hdr->cname, hdr->clen) == 0 &&
379   - !isalpha(*(dptr + hdr->clen + 1)))
  379 + !isalpha(*(dptr + hdr->clen)))
380 380 dptr += hdr->clen;
381 381 else
382 382 continue;
net/netlink/af_netlink.c
... ... @@ -455,8 +455,13 @@
455 455 if (nl_table[protocol].registered &&
456 456 try_module_get(nl_table[protocol].module))
457 457 module = nl_table[protocol].module;
  458 + else
  459 + err = -EPROTONOSUPPORT;
458 460 cb_mutex = nl_table[protocol].cb_mutex;
459 461 netlink_unlock_table();
  462 +
  463 + if (err < 0)
  464 + goto out;
460 465  
461 466 err = __netlink_create(net, sock, cb_mutex, protocol);
462 467 if (err < 0)