Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux

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

+292 -280
+12 -1
drivers/bluetooth/Kconfig
··· 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 - endmenu 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. 199 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 + 210 + endmenu
+1
drivers/bluetooth/Makefile
··· 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
+187
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");
+3 -1
drivers/bluetooth/bluecard_cs.c
··· 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;
+3 -1
drivers/bluetooth/bt3c_cs.c
··· 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
+3 -1
drivers/bluetooth/btuart_cs.c
··· 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
+3 -1
drivers/bluetooth/dtl1_cs.c
··· 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
-175
drivers/connector/connector.c
··· 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; ··· 199 210 } 200 211 201 212 /* 202 - * Notification routing. 203 - * 204 - * Gets id and checks if there are notification request for it's idx 205 - * and val. If there are such requests notify the listeners with the 206 - * given notify event. 207 - * 208 - */ 209 - static void cn_notify(struct cb_id *id, u32 notify_event) 210 - { 211 - struct cn_ctl_entry *ent; 212 - 213 - mutex_lock(&notify_lock); 214 - list_for_each_entry(ent, &notify_list, notify_entry) { 215 - int i; 216 - struct cn_notify_req *req; 217 - struct cn_ctl_msg *ctl = ent->msg; 218 - int idx_found, val_found; 219 - 220 - idx_found = val_found = 0; 221 - 222 - req = (struct cn_notify_req *)ctl->data; 223 - for (i = 0; i < ctl->idx_notify_num; ++i, ++req) { 224 - if (id->idx >= req->first && 225 - id->idx < req->first + req->range) { 226 - idx_found = 1; 227 - break; 228 - } 229 - } 230 - 231 - for (i = 0; i < ctl->val_notify_num; ++i, ++req) { 232 - if (id->val >= req->first && 233 - id->val < req->first + req->range) { 234 - val_found = 1; 235 - break; 236 - } 237 - } 238 - 239 - if (idx_found && val_found) { 240 - struct cn_msg m = { .ack = notify_event, }; 241 - 242 - memcpy(&m.id, id, sizeof(m.id)); 243 - cn_netlink_send(&m, ctl->group, GFP_KERNEL); 244 - } 245 - } 246 - mutex_unlock(&notify_lock); 247 - } 248 - 249 - /* 250 213 * Callback add routing - adds callback with given ID and name. 251 214 * If there is registered callback with the same ID it will not be added. 252 215 * ··· 217 276 if (err) 218 277 return err; 219 278 220 - cn_notify(id, 0); 221 - 222 279 return 0; 223 280 } 224 281 EXPORT_SYMBOL_GPL(cn_add_callback); ··· 234 295 struct cn_dev *dev = &cdev; 235 296 236 297 cn_queue_del_callback(dev->cbdev, id); 237 - cn_notify(id, 1); 238 298 } 239 299 EXPORT_SYMBOL_GPL(cn_del_callback); 240 - 241 - /* 242 - * Checks two connector's control messages to be the same. 243 - * Returns 1 if they are the same or if the first one is corrupted. 244 - */ 245 - static int cn_ctl_msg_equals(struct cn_ctl_msg *m1, struct cn_ctl_msg *m2) 246 - { 247 - int i; 248 - struct cn_notify_req *req1, *req2; 249 - 250 - if (m1->idx_notify_num != m2->idx_notify_num) 251 - return 0; 252 - 253 - if (m1->val_notify_num != m2->val_notify_num) 254 - return 0; 255 - 256 - if (m1->len != m2->len) 257 - return 0; 258 - 259 - if ((m1->idx_notify_num + m1->val_notify_num) * sizeof(*req1) != 260 - m1->len) 261 - return 1; 262 - 263 - req1 = (struct cn_notify_req *)m1->data; 264 - req2 = (struct cn_notify_req *)m2->data; 265 - 266 - for (i = 0; i < m1->idx_notify_num; ++i) { 267 - if (req1->first != req2->first || req1->range != req2->range) 268 - return 0; 269 - req1++; 270 - req2++; 271 - } 272 - 273 - for (i = 0; i < m1->val_notify_num; ++i) { 274 - if (req1->first != req2->first || req1->range != req2->range) 275 - return 0; 276 - req1++; 277 - req2++; 278 - } 279 - 280 - return 1; 281 - } 282 - 283 - /* 284 - * Main connector device's callback. 285 - * 286 - * Used for notification of a request's processing. 287 - */ 288 - static void cn_callback(struct cn_msg *msg, struct netlink_skb_parms *nsp) 289 - { 290 - struct cn_ctl_msg *ctl; 291 - struct cn_ctl_entry *ent; 292 - u32 size; 293 - 294 - if (msg->len < sizeof(*ctl)) 295 - return; 296 - 297 - ctl = (struct cn_ctl_msg *)msg->data; 298 - 299 - size = (sizeof(*ctl) + ((ctl->idx_notify_num + 300 - ctl->val_notify_num) * 301 - sizeof(struct cn_notify_req))); 302 - 303 - if (msg->len != size) 304 - return; 305 - 306 - if (ctl->len + sizeof(*ctl) != msg->len) 307 - return; 308 - 309 - /* 310 - * Remove notification. 311 - */ 312 - if (ctl->group == 0) { 313 - struct cn_ctl_entry *n; 314 - 315 - mutex_lock(&notify_lock); 316 - list_for_each_entry_safe(ent, n, &notify_list, notify_entry) { 317 - if (cn_ctl_msg_equals(ent->msg, ctl)) { 318 - list_del(&ent->notify_entry); 319 - kfree(ent); 320 - } 321 - } 322 - mutex_unlock(&notify_lock); 323 - 324 - return; 325 - } 326 - 327 - size += sizeof(*ent); 328 - 329 - ent = kzalloc(size, GFP_KERNEL); 330 - if (!ent) 331 - return; 332 - 333 - ent->msg = (struct cn_ctl_msg *)(ent + 1); 334 - 335 - memcpy(ent->msg, ctl, size - sizeof(*ent)); 336 - 337 - mutex_lock(&notify_lock); 338 - list_add(&ent->notify_entry, &notify_list); 339 - mutex_unlock(&notify_lock); 340 - } 341 300 342 301 static int cn_proc_show(struct seq_file *m, void *v) 343 302 { ··· 274 437 static int __devinit cn_init(void) 275 438 { 276 439 struct cn_dev *dev = &cdev; 277 - int err; 278 440 279 441 dev->input = cn_rx_skb; 280 - dev->id.idx = cn_idx; 281 - dev->id.val = cn_val; 282 442 283 443 dev->nls = netlink_kernel_create(&init_net, NETLINK_CONNECTOR, 284 444 CN_NETLINK_USERS + 0xf, ··· 291 457 292 458 cn_already_initialized = 1; 293 459 294 - err = cn_add_callback(&dev->id, "connector", &cn_callback); 295 - if (err) { 296 - cn_already_initialized = 0; 297 - cn_queue_free_dev(dev->cbdev); 298 - netlink_kernel_release(dev->nls); 299 - return -EINVAL; 300 - } 301 - 302 460 proc_net_fops_create(&init_net, "connector", S_IRUGO, &cn_file_ops); 303 461 304 462 return 0; ··· 304 478 305 479 proc_net_remove(&init_net, "connector"); 306 480 307 - cn_del_callback(&dev->id); 308 481 cn_queue_free_dev(dev->cbdev); 309 482 netlink_kernel_release(dev->nls); 310 483 }
+2 -2
drivers/net/benet/be_main.c
··· 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 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
+5 -2
drivers/net/ixgbe/ixgbe_main.c
··· 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, ··· 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) &&
+3 -1
drivers/net/netxen/netxen_nic_main.c
··· 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)) { ··· 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
+3 -5
drivers/net/sky2.c
··· 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 } ··· 1619 1622 return count; 1620 1623 } 1621 1624 1622 - static void sky2_tx_unmap(struct pci_dev *pdev, 1623 - const struct tx_ring_info *re) 1625 + static void sky2_tx_unmap(struct pci_dev *pdev, struct tx_ring_info *re) 1624 1626 { 1625 1627 if (re->flags & TX_MAP_SINGLE) 1626 1628 pci_unmap_single(pdev, pci_unmap_addr(re, mapaddr), ··· 1629 1633 pci_unmap_page(pdev, pci_unmap_addr(re, mapaddr), 1630 1634 pci_unmap_len(re, maplen), 1631 1635 PCI_DMA_TODEVICE); 1636 + re->flags = 0; 1632 1637 } 1633 1638 1634 1639 /* ··· 1836 1839 dev->stats.tx_packets++; 1837 1840 dev->stats.tx_bytes += skb->len; 1838 1841 1842 + re->skb = NULL; 1839 1843 dev_kfree_skb_any(skb); 1840 1844 1841 1845 sky2->tx_next = RING_NEXT(idx, sky2->tx_ring_size);
+1 -1
drivers/net/usb/cdc_ether.c
··· 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,
-32
include/linux/connector.h
··· 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 */ ··· 69 72 70 73 __u16 len; /* Length of the following data */ 71 74 __u16 flags; 72 - __u8 data[0]; 73 - }; 74 - 75 - /* 76 - * Notify structure - requests notification about 77 - * registering/unregistering idx/val in range [first, first+range]. 78 - */ 79 - struct cn_notify_req { 80 - __u32 first; 81 - __u32 range; 82 - }; 83 - 84 - /* 85 - * Main notification control message 86 - * *_notify_num - number of appropriate cn_notify_req structures after 87 - * this struct. 88 - * group - notification receiver's idx. 89 - * len - total length of the attached data. 90 - */ 91 - struct cn_ctl_msg { 92 - __u32 idx_notify_num; 93 - __u32 val_notify_num; 94 - __u32 group; 95 - __u32 len; 96 75 __u8 data[0]; 97 76 }; 98 77 ··· 122 149 struct cn_callback_data data; 123 150 124 151 u32 seq, group; 125 - }; 126 - 127 - struct cn_ctl_entry { 128 - struct list_head notify_entry; 129 - struct cn_ctl_msg *msg; 130 152 }; 131 153 132 154 struct cn_dev {
+36 -34
net/bluetooth/hidp/core.c
··· 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 { ··· 315 282 316 283 static int hidp_output_raw_report(struct hid_device *hid, unsigned char *data, size_t count) 317 284 { 318 - if (hidp_queue_report(hid->driver_data, data, count)) 285 + if (hidp_send_ctrl_message(hid->driver_data, 286 + HIDP_TRANS_SET_REPORT | HIDP_DATA_RTYPE_FEATURE, 287 + data, count)) 319 288 return -ENOMEM; 320 289 return count; 321 290 } ··· 340 305 { 341 306 if (session->idle_to > 0) 342 307 del_timer(&session->timer); 343 - } 344 - 345 - static int __hidp_send_ctrl_message(struct hidp_session *session, 346 - unsigned char hdr, unsigned char *data, int size) 347 - { 348 - struct sk_buff *skb; 349 - 350 - BT_DBG("session %p data %p size %d", session, data, size); 351 - 352 - if (!(skb = alloc_skb(size + 1, GFP_ATOMIC))) { 353 - BT_ERR("Can't allocate memory for new frame"); 354 - return -ENOMEM; 355 - } 356 - 357 - *skb_put(skb, 1) = hdr; 358 - if (data && size > 0) 359 - memcpy(skb_put(skb, size), data, size); 360 - 361 - skb_queue_tail(&session->ctrl_transmit, skb); 362 - 363 - return 0; 364 - } 365 - 366 - static inline int hidp_send_ctrl_message(struct hidp_session *session, 367 - unsigned char hdr, unsigned char *data, int size) 368 - { 369 - int err; 370 - 371 - err = __hidp_send_ctrl_message(session, hdr, data, size); 372 - 373 - hidp_schedule(session); 374 - 375 - return err; 376 308 } 377 309 378 310 static void hidp_process_handshake(struct hidp_session *session,
+6 -8
net/bluetooth/l2cap.c
··· 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) { 1375 1374 l2cap_send_disconn_req(pi->conn, sk); 1376 1375 break; 1377 1376 } 1377 + 1378 + tx_skb = skb_clone(skb, GFP_ATOMIC); 1378 1379 1379 1380 bt_cb(skb)->retries++; 1380 1381 ··· 3519 3518 struct l2cap_pinfo *pi; 3520 3519 u16 control, len; 3521 3520 u8 tx_seq; 3522 - int err; 3523 3521 3524 3522 sk = l2cap_get_chan_by_scid(&conn->chan_list, cid); 3525 3523 if (!sk) { ··· 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); ··· 3600 3602 else 3601 3603 pi->expected_tx_seq = tx_seq + 1; 3602 3604 3603 - err = l2cap_sar_reassembly_sdu(sk, skb, control); 3605 + l2cap_sar_reassembly_sdu(sk, skb, control); 3604 3606 3605 3607 goto done; 3606 3608
+1 -1
net/dccp/ccid.c
··· 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,
+5 -3
net/dccp/ccid.h
··· 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 ··· 51 49 const char *ccid_name; 52 50 struct kmem_cache *ccid_hc_rx_slab, 53 51 *ccid_hc_tx_slab; 54 - char ccid_hc_rx_slab_name[32]; 55 - char ccid_hc_tx_slab_name[32]; 52 + char ccid_hc_rx_slab_name[CCID_SLAB_NAME_LENGTH]; 53 + char ccid_hc_tx_slab_name[CCID_SLAB_NAME_LENGTH]; 56 54 __u32 ccid_hc_rx_obj_size, 57 55 ccid_hc_tx_obj_size; 58 56 /* Interface Routines */
+2 -2
net/dccp/probe.c
··· 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
+8 -7
net/key/af_key.c
··· 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 ··· 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;
+2 -1
net/netfilter/nf_conntrack_netlink.c
··· 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)
+1 -1
net/netfilter/nf_conntrack_sip.c
··· 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;
+5
net/netlink/af_netlink.c
··· 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)