Commit 9c119ba54c0fcae72881948af3d37b47a2f8e1f9
Exists in
master
and in
39 other branches
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
- drivers/bluetooth/Makefile
- drivers/bluetooth/ath3k.c
- drivers/bluetooth/bluecard_cs.c
- drivers/bluetooth/bt3c_cs.c
- drivers/bluetooth/btuart_cs.c
- drivers/bluetooth/dtl1_cs.c
- drivers/connector/connector.c
- drivers/net/benet/be_main.c
- drivers/net/ixgbe/ixgbe_main.c
- drivers/net/netxen/netxen_nic_main.c
- drivers/net/sky2.c
- drivers/net/usb/cdc_ether.c
- include/linux/connector.h
- net/bluetooth/hidp/core.c
- net/bluetooth/l2cap.c
- net/dccp/ccid.c
- net/dccp/ccid.h
- net/dccp/probe.c
- net/key/af_key.c
- net/netfilter/nf_conntrack_netlink.c
- net/netfilter/nf_conntrack_sip.c
- net/netlink/af_netlink.c
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
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
drivers/bluetooth/btuart_cs.c
drivers/bluetooth/dtl1_cs.c
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(¬ify_lock); | |
225 | - list_for_each_entry(ent, ¬ify_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(¬ify_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(¬ify_lock); | |
377 | - list_for_each_entry_safe(ent, n, ¬ify_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(¬ify_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(¬ify_lock); | |
399 | - list_add(&ent->notify_entry, ¬ify_list); | |
400 | - mutex_unlock(¬ify_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 |
drivers/net/sky2.c
... | ... | @@ -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 |
net/dccp/ccid.c
... | ... | @@ -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, |
net/dccp/ccid.h
... | ... | @@ -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 */ |
net/dccp/probe.c
... | ... | @@ -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 |
net/key/af_key.c
... | ... | @@ -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) |