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

Configure Feed

Select the types of activity you want to include in your feed.

Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-2.6

* git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-2.6:
[TCP]: Add return value indication to tcp_prune_ofo_queue().
PS3: gelic: fix the oops on the broken IE returned from the hypervisor
b43legacy: fix DMA mapping leakage
mac80211: remove message on receiving unexpected unencrypted frames
Update rt2x00 MAINTAINERS entry
Add rfkill to MAINTAINERS file
rfkill: Fix device type check when toggling states
b43legacy: Fix usage of struct device used for DMAing
ssb: Fix usage of struct device used for DMAing
MAINTAINERS: move to generic repository for iwlwifi
b43legacy: fix initvals loading on bcm4303
rtl8187: Add missing priv->vif assignments
netconsole: only set CON_PRINTBUFFER if the user specifies a netconsole
[CAN]: Update documentation of struct sockaddr_can
MAINTAINERS: isdn4linux@listserv.isdn4linux.de is subscribers-only
[TCP]: Fix never pruned tcp out-of-order queue.
[NET_SCHED] sch_api: fix qdisc_tree_decrease_qlen() loop

Linus Torvalds b4b8f579 424b00e2

+173 -112
+4 -4
Documentation/networking/can.txt
··· 281 281 sa_family_t can_family; 282 282 int can_ifindex; 283 283 union { 284 - struct { canid_t rx_id, tx_id; } tp16; 285 - struct { canid_t rx_id, tx_id; } tp20; 286 - struct { canid_t rx_id, tx_id; } mcnet; 287 - struct { canid_t rx_id, tx_id; } isotp; 284 + /* transport protocol class address info (e.g. ISOTP) */ 285 + struct { canid_t rx_id, tx_id; } tp; 286 + 287 + /* reserved for future CAN protocols address information */ 288 288 } can_addr; 289 289 }; 290 290
+11 -3
MAINTAINERS
··· 2116 2116 L: linux-wireless@vger.kernel.org 2117 2117 L: ipw3945-devel@lists.sourceforge.net 2118 2118 W: http://intellinuxwireless.org 2119 - T: git git://git.kernel.org/pub/scm/linux/kernel/git/rchatre/iwlwifi-2.6.git 2119 + T: git kernel.org:/pub/scm/linux/kernel/git/iwlwifi/iwlwifi-2.6.git 2120 2120 S: Supported 2121 2121 2122 2122 IOC3 ETHERNET DRIVER ··· 2197 2197 ISDN SUBSYSTEM 2198 2198 P: Karsten Keil 2199 2199 M: kkeil@suse.de 2200 - L: isdn4linux@listserv.isdn4linux.de 2200 + L: isdn4linux@listserv.isdn4linux.de (subscribers-only) 2201 2201 W: http://www.isdn4linux.de 2202 2202 T: git kernel.org:/pub/scm/linux/kernel/kkeil/isdn-2.6.git 2203 2203 S: Maintained ··· 2205 2205 ISDN SUBSYSTEM (Eicon active card driver) 2206 2206 P: Armin Schindler 2207 2207 M: mac@melware.de 2208 - L: isdn4linux@listserv.isdn4linux.de 2208 + L: isdn4linux@listserv.isdn4linux.de (subscribers-only) 2209 2209 W: http://www.melware.de 2210 2210 S: Maintained 2211 2211 ··· 3280 3280 L: rt2400-devel@lists.sourceforge.net 3281 3281 W: http://rt2x00.serialmonkey.com/ 3282 3282 S: Maintained 3283 + T: git kernel.org:/pub/scm/linux/kernel/git/ivd/rt2x00.git 3283 3284 F: drivers/net/wireless/rt2x00/ 3284 3285 3285 3286 RAMDISK RAM BLOCK DEVICE DRIVER ··· 3342 3341 L: reiserfs-devel@vger.kernel.org 3343 3342 W: http://www.namesys.com 3344 3343 S: Supported 3344 + 3345 + RFKILL 3346 + P: Ivo van Doorn 3347 + M: IvDoorn@gmail.com 3348 + L: netdev@vger.kernel.org 3349 + S: Maintained 3350 + F: net/rfkill 3345 3351 3346 3352 ROCKETPORT DRIVER 3347 3353 P: Comtrol Corp.
+26 -26
drivers/net/b44.c
··· 148 148 unsigned long offset, 149 149 enum dma_data_direction dir) 150 150 { 151 - dma_sync_single_range_for_device(sdev->dev, dma_base, 151 + dma_sync_single_range_for_device(sdev->dma_dev, dma_base, 152 152 offset & dma_desc_align_mask, 153 153 dma_desc_sync_size, dir); 154 154 } ··· 158 158 unsigned long offset, 159 159 enum dma_data_direction dir) 160 160 { 161 - dma_sync_single_range_for_cpu(sdev->dev, dma_base, 161 + dma_sync_single_range_for_cpu(sdev->dma_dev, dma_base, 162 162 offset & dma_desc_align_mask, 163 163 dma_desc_sync_size, dir); 164 164 } ··· 613 613 614 614 BUG_ON(skb == NULL); 615 615 616 - dma_unmap_single(bp->sdev->dev, 616 + dma_unmap_single(bp->sdev->dma_dev, 617 617 rp->mapping, 618 618 skb->len, 619 619 DMA_TO_DEVICE); ··· 653 653 if (skb == NULL) 654 654 return -ENOMEM; 655 655 656 - mapping = dma_map_single(bp->sdev->dev, skb->data, 656 + mapping = dma_map_single(bp->sdev->dma_dev, skb->data, 657 657 RX_PKT_BUF_SZ, 658 658 DMA_FROM_DEVICE); 659 659 ··· 663 663 mapping + RX_PKT_BUF_SZ > DMA_30BIT_MASK) { 664 664 /* Sigh... */ 665 665 if (!dma_mapping_error(mapping)) 666 - dma_unmap_single(bp->sdev->dev, mapping, 666 + dma_unmap_single(bp->sdev->dma_dev, mapping, 667 667 RX_PKT_BUF_SZ, DMA_FROM_DEVICE); 668 668 dev_kfree_skb_any(skb); 669 669 skb = __netdev_alloc_skb(bp->dev, RX_PKT_BUF_SZ, GFP_ATOMIC|GFP_DMA); 670 670 if (skb == NULL) 671 671 return -ENOMEM; 672 - mapping = dma_map_single(bp->sdev->dev, skb->data, 672 + mapping = dma_map_single(bp->sdev->dma_dev, skb->data, 673 673 RX_PKT_BUF_SZ, 674 674 DMA_FROM_DEVICE); 675 675 if (dma_mapping_error(mapping) || 676 676 mapping + RX_PKT_BUF_SZ > DMA_30BIT_MASK) { 677 677 if (!dma_mapping_error(mapping)) 678 - dma_unmap_single(bp->sdev->dev, mapping, RX_PKT_BUF_SZ,DMA_FROM_DEVICE); 678 + dma_unmap_single(bp->sdev->dma_dev, mapping, RX_PKT_BUF_SZ,DMA_FROM_DEVICE); 679 679 dev_kfree_skb_any(skb); 680 680 return -ENOMEM; 681 681 } ··· 750 750 dest_idx * sizeof(dest_desc), 751 751 DMA_BIDIRECTIONAL); 752 752 753 - dma_sync_single_for_device(bp->sdev->dev, le32_to_cpu(src_desc->addr), 753 + dma_sync_single_for_device(bp->sdev->dma_dev, le32_to_cpu(src_desc->addr), 754 754 RX_PKT_BUF_SZ, 755 755 DMA_FROM_DEVICE); 756 756 } ··· 772 772 struct rx_header *rh; 773 773 u16 len; 774 774 775 - dma_sync_single_for_cpu(bp->sdev->dev, map, 775 + dma_sync_single_for_cpu(bp->sdev->dma_dev, map, 776 776 RX_PKT_BUF_SZ, 777 777 DMA_FROM_DEVICE); 778 778 rh = (struct rx_header *) skb->data; ··· 806 806 skb_size = b44_alloc_rx_skb(bp, cons, bp->rx_prod); 807 807 if (skb_size < 0) 808 808 goto drop_it; 809 - dma_unmap_single(bp->sdev->dev, map, 809 + dma_unmap_single(bp->sdev->dma_dev, map, 810 810 skb_size, DMA_FROM_DEVICE); 811 811 /* Leave out rx_header */ 812 812 skb_put(skb, len + RX_PKT_OFFSET); ··· 966 966 goto err_out; 967 967 } 968 968 969 - mapping = dma_map_single(bp->sdev->dev, skb->data, len, DMA_TO_DEVICE); 969 + mapping = dma_map_single(bp->sdev->dma_dev, skb->data, len, DMA_TO_DEVICE); 970 970 if (dma_mapping_error(mapping) || mapping + len > DMA_30BIT_MASK) { 971 971 struct sk_buff *bounce_skb; 972 972 973 973 /* Chip can't handle DMA to/from >1GB, use bounce buffer */ 974 974 if (!dma_mapping_error(mapping)) 975 - dma_unmap_single(bp->sdev->dev, mapping, len, 975 + dma_unmap_single(bp->sdev->dma_dev, mapping, len, 976 976 DMA_TO_DEVICE); 977 977 978 978 bounce_skb = __dev_alloc_skb(len, GFP_ATOMIC | GFP_DMA); 979 979 if (!bounce_skb) 980 980 goto err_out; 981 981 982 - mapping = dma_map_single(bp->sdev->dev, bounce_skb->data, 982 + mapping = dma_map_single(bp->sdev->dma_dev, bounce_skb->data, 983 983 len, DMA_TO_DEVICE); 984 984 if (dma_mapping_error(mapping) || mapping + len > DMA_30BIT_MASK) { 985 985 if (!dma_mapping_error(mapping)) 986 - dma_unmap_single(bp->sdev->dev, mapping, 986 + dma_unmap_single(bp->sdev->dma_dev, mapping, 987 987 len, DMA_TO_DEVICE); 988 988 dev_kfree_skb_any(bounce_skb); 989 989 goto err_out; ··· 1082 1082 1083 1083 if (rp->skb == NULL) 1084 1084 continue; 1085 - dma_unmap_single(bp->sdev->dev, rp->mapping, RX_PKT_BUF_SZ, 1085 + dma_unmap_single(bp->sdev->dma_dev, rp->mapping, RX_PKT_BUF_SZ, 1086 1086 DMA_FROM_DEVICE); 1087 1087 dev_kfree_skb_any(rp->skb); 1088 1088 rp->skb = NULL; ··· 1094 1094 1095 1095 if (rp->skb == NULL) 1096 1096 continue; 1097 - dma_unmap_single(bp->sdev->dev, rp->mapping, rp->skb->len, 1097 + dma_unmap_single(bp->sdev->dma_dev, rp->mapping, rp->skb->len, 1098 1098 DMA_TO_DEVICE); 1099 1099 dev_kfree_skb_any(rp->skb); 1100 1100 rp->skb = NULL; ··· 1117 1117 memset(bp->tx_ring, 0, B44_TX_RING_BYTES); 1118 1118 1119 1119 if (bp->flags & B44_FLAG_RX_RING_HACK) 1120 - dma_sync_single_for_device(bp->sdev->dev, bp->rx_ring_dma, 1120 + dma_sync_single_for_device(bp->sdev->dma_dev, bp->rx_ring_dma, 1121 1121 DMA_TABLE_BYTES, 1122 1122 DMA_BIDIRECTIONAL); 1123 1123 1124 1124 if (bp->flags & B44_FLAG_TX_RING_HACK) 1125 - dma_sync_single_for_device(bp->sdev->dev, bp->tx_ring_dma, 1125 + dma_sync_single_for_device(bp->sdev->dma_dev, bp->tx_ring_dma, 1126 1126 DMA_TABLE_BYTES, 1127 1127 DMA_TO_DEVICE); 1128 1128 ··· 1144 1144 bp->tx_buffers = NULL; 1145 1145 if (bp->rx_ring) { 1146 1146 if (bp->flags & B44_FLAG_RX_RING_HACK) { 1147 - dma_unmap_single(bp->sdev->dev, bp->rx_ring_dma, 1147 + dma_unmap_single(bp->sdev->dma_dev, bp->rx_ring_dma, 1148 1148 DMA_TABLE_BYTES, 1149 1149 DMA_BIDIRECTIONAL); 1150 1150 kfree(bp->rx_ring); 1151 1151 } else 1152 - dma_free_coherent(bp->sdev->dev, DMA_TABLE_BYTES, 1152 + dma_free_coherent(bp->sdev->dma_dev, DMA_TABLE_BYTES, 1153 1153 bp->rx_ring, bp->rx_ring_dma); 1154 1154 bp->rx_ring = NULL; 1155 1155 bp->flags &= ~B44_FLAG_RX_RING_HACK; 1156 1156 } 1157 1157 if (bp->tx_ring) { 1158 1158 if (bp->flags & B44_FLAG_TX_RING_HACK) { 1159 - dma_unmap_single(bp->sdev->dev, bp->tx_ring_dma, 1159 + dma_unmap_single(bp->sdev->dma_dev, bp->tx_ring_dma, 1160 1160 DMA_TABLE_BYTES, 1161 1161 DMA_TO_DEVICE); 1162 1162 kfree(bp->tx_ring); 1163 1163 } else 1164 - dma_free_coherent(bp->sdev->dev, DMA_TABLE_BYTES, 1164 + dma_free_coherent(bp->sdev->dma_dev, DMA_TABLE_BYTES, 1165 1165 bp->tx_ring, bp->tx_ring_dma); 1166 1166 bp->tx_ring = NULL; 1167 1167 bp->flags &= ~B44_FLAG_TX_RING_HACK; ··· 1187 1187 goto out_err; 1188 1188 1189 1189 size = DMA_TABLE_BYTES; 1190 - bp->rx_ring = dma_alloc_coherent(bp->sdev->dev, size, &bp->rx_ring_dma, gfp); 1190 + bp->rx_ring = dma_alloc_coherent(bp->sdev->dma_dev, size, &bp->rx_ring_dma, gfp); 1191 1191 if (!bp->rx_ring) { 1192 1192 /* Allocation may have failed due to pci_alloc_consistent 1193 1193 insisting on use of GFP_DMA, which is more restrictive ··· 1199 1199 if (!rx_ring) 1200 1200 goto out_err; 1201 1201 1202 - rx_ring_dma = dma_map_single(bp->sdev->dev, rx_ring, 1202 + rx_ring_dma = dma_map_single(bp->sdev->dma_dev, rx_ring, 1203 1203 DMA_TABLE_BYTES, 1204 1204 DMA_BIDIRECTIONAL); 1205 1205 ··· 1214 1214 bp->flags |= B44_FLAG_RX_RING_HACK; 1215 1215 } 1216 1216 1217 - bp->tx_ring = dma_alloc_coherent(bp->sdev->dev, size, &bp->tx_ring_dma, gfp); 1217 + bp->tx_ring = dma_alloc_coherent(bp->sdev->dma_dev, size, &bp->tx_ring_dma, gfp); 1218 1218 if (!bp->tx_ring) { 1219 1219 /* Allocation may have failed due to dma_alloc_coherent 1220 1220 insisting on use of GFP_DMA, which is more restrictive ··· 1226 1226 if (!tx_ring) 1227 1227 goto out_err; 1228 1228 1229 - tx_ring_dma = dma_map_single(bp->sdev->dev, tx_ring, 1229 + tx_ring_dma = dma_map_single(bp->sdev->dma_dev, tx_ring, 1230 1230 DMA_TABLE_BYTES, 1231 1231 DMA_TO_DEVICE); 1232 1232
+4 -1
drivers/net/netconsole.c
··· 730 730 731 731 static struct console netconsole = { 732 732 .name = "netcon", 733 - .flags = CON_ENABLED | CON_PRINTBUFFER, 733 + .flags = CON_ENABLED, 734 734 .write = write_msg, 735 735 }; 736 736 ··· 749 749 err = PTR_ERR(nt); 750 750 goto fail; 751 751 } 752 + /* Dump existing printks when we register */ 753 + netconsole.flags |= CON_PRINTBUFFER; 754 + 752 755 spin_lock_irqsave(&target_list_lock, flags); 753 756 list_add(&nt->list, &target_list); 754 757 spin_unlock_irqrestore(&target_list_lock, flags);
+8 -3
drivers/net/ps3_gelic_wireless.c
··· 512 512 data, len); 513 513 memset(ie_info, 0, sizeof(struct ie_info)); 514 514 515 - while (0 < data_left) { 515 + while (2 <= data_left) { 516 516 item_id = *pos++; 517 517 item_len = *pos++; 518 + data_left -= 2; 519 + 520 + if (data_left < item_len) 521 + break; 518 522 519 523 switch (item_id) { 520 524 case MFIE_TYPE_GENERIC: 521 - if (!memcmp(pos, wpa_oui, OUI_LEN) && 525 + if ((OUI_LEN + 1 <= item_len) && 526 + !memcmp(pos, wpa_oui, OUI_LEN) && 522 527 pos[OUI_LEN] == 0x01) { 523 528 ie_info->wpa.data = pos - 2; 524 529 ie_info->wpa.len = item_len + 2; ··· 540 535 break; 541 536 } 542 537 pos += item_len; 543 - data_left -= item_len + 2; 538 + data_left -= item_len; 544 539 } 545 540 pr_debug("%s: wpa=%p,%d wpa2=%p,%d\n", __func__, 546 541 ie_info->wpa.data, ie_info->wpa.len,
+14 -13
drivers/net/wireless/b43/dma.c
··· 373 373 dma_addr_t dmaaddr; 374 374 375 375 if (tx) { 376 - dmaaddr = dma_map_single(ring->dev->dev->dev, 376 + dmaaddr = dma_map_single(ring->dev->dev->dma_dev, 377 377 buf, len, DMA_TO_DEVICE); 378 378 } else { 379 - dmaaddr = dma_map_single(ring->dev->dev->dev, 379 + dmaaddr = dma_map_single(ring->dev->dev->dma_dev, 380 380 buf, len, DMA_FROM_DEVICE); 381 381 } 382 382 ··· 388 388 dma_addr_t addr, size_t len, int tx) 389 389 { 390 390 if (tx) { 391 - dma_unmap_single(ring->dev->dev->dev, addr, len, DMA_TO_DEVICE); 391 + dma_unmap_single(ring->dev->dev->dma_dev, 392 + addr, len, DMA_TO_DEVICE); 392 393 } else { 393 - dma_unmap_single(ring->dev->dev->dev, 394 + dma_unmap_single(ring->dev->dev->dma_dev, 394 395 addr, len, DMA_FROM_DEVICE); 395 396 } 396 397 } ··· 401 400 dma_addr_t addr, size_t len) 402 401 { 403 402 B43_WARN_ON(ring->tx); 404 - dma_sync_single_for_cpu(ring->dev->dev->dev, 403 + dma_sync_single_for_cpu(ring->dev->dev->dma_dev, 405 404 addr, len, DMA_FROM_DEVICE); 406 405 } 407 406 ··· 410 409 dma_addr_t addr, size_t len) 411 410 { 412 411 B43_WARN_ON(ring->tx); 413 - dma_sync_single_for_device(ring->dev->dev->dev, 412 + dma_sync_single_for_device(ring->dev->dev->dma_dev, 414 413 addr, len, DMA_FROM_DEVICE); 415 414 } 416 415 ··· 426 425 427 426 static int alloc_ringmemory(struct b43_dmaring *ring) 428 427 { 429 - struct device *dev = ring->dev->dev->dev; 428 + struct device *dma_dev = ring->dev->dev->dma_dev; 430 429 gfp_t flags = GFP_KERNEL; 431 430 432 431 /* The specs call for 4K buffers for 30- and 32-bit DMA with 4K ··· 440 439 */ 441 440 if (ring->type == B43_DMA_64BIT) 442 441 flags |= GFP_DMA; 443 - ring->descbase = dma_alloc_coherent(dev, B43_DMA_RINGMEMSIZE, 442 + ring->descbase = dma_alloc_coherent(dma_dev, B43_DMA_RINGMEMSIZE, 444 443 &(ring->dmabase), flags); 445 444 if (!ring->descbase) { 446 445 b43err(ring->dev->wl, "DMA ringmemory allocation failed\n"); ··· 453 452 454 453 static void free_ringmemory(struct b43_dmaring *ring) 455 454 { 456 - struct device *dev = ring->dev->dev->dev; 455 + struct device *dma_dev = ring->dev->dev->dma_dev; 457 456 458 - dma_free_coherent(dev, B43_DMA_RINGMEMSIZE, 457 + dma_free_coherent(dma_dev, B43_DMA_RINGMEMSIZE, 459 458 ring->descbase, ring->dmabase); 460 459 } 461 460 ··· 855 854 goto err_kfree_meta; 856 855 857 856 /* test for ability to dma to txhdr_cache */ 858 - dma_test = dma_map_single(dev->dev->dev, 857 + dma_test = dma_map_single(dev->dev->dma_dev, 859 858 ring->txhdr_cache, 860 859 b43_txhdr_size(dev), 861 860 DMA_TO_DEVICE); ··· 870 869 if (!ring->txhdr_cache) 871 870 goto err_kfree_meta; 872 871 873 - dma_test = dma_map_single(dev->dev->dev, 872 + dma_test = dma_map_single(dev->dev->dma_dev, 874 873 ring->txhdr_cache, 875 874 b43_txhdr_size(dev), 876 875 DMA_TO_DEVICE); ··· 884 883 } 885 884 } 886 885 887 - dma_unmap_single(dev->dev->dev, 886 + dma_unmap_single(dev->dev->dma_dev, 888 887 dma_test, b43_txhdr_size(dev), 889 888 DMA_TO_DEVICE); 890 889 }
+31 -24
drivers/net/wireless/b43legacy/dma.c
··· 393 393 dma_addr_t dmaaddr; 394 394 395 395 if (tx) 396 - dmaaddr = dma_map_single(ring->dev->dev->dev, 396 + dmaaddr = dma_map_single(ring->dev->dev->dma_dev, 397 397 buf, len, 398 398 DMA_TO_DEVICE); 399 399 else 400 - dmaaddr = dma_map_single(ring->dev->dev->dev, 400 + dmaaddr = dma_map_single(ring->dev->dev->dma_dev, 401 401 buf, len, 402 402 DMA_FROM_DEVICE); 403 403 ··· 411 411 int tx) 412 412 { 413 413 if (tx) 414 - dma_unmap_single(ring->dev->dev->dev, 414 + dma_unmap_single(ring->dev->dev->dma_dev, 415 415 addr, len, 416 416 DMA_TO_DEVICE); 417 417 else 418 - dma_unmap_single(ring->dev->dev->dev, 418 + dma_unmap_single(ring->dev->dev->dma_dev, 419 419 addr, len, 420 420 DMA_FROM_DEVICE); 421 421 } ··· 427 427 { 428 428 B43legacy_WARN_ON(ring->tx); 429 429 430 - dma_sync_single_for_cpu(ring->dev->dev->dev, 430 + dma_sync_single_for_cpu(ring->dev->dev->dma_dev, 431 431 addr, len, DMA_FROM_DEVICE); 432 432 } 433 433 ··· 438 438 { 439 439 B43legacy_WARN_ON(ring->tx); 440 440 441 - dma_sync_single_for_device(ring->dev->dev->dev, 441 + dma_sync_single_for_device(ring->dev->dev->dma_dev, 442 442 addr, len, DMA_FROM_DEVICE); 443 443 } 444 444 ··· 458 458 459 459 static int alloc_ringmemory(struct b43legacy_dmaring *ring) 460 460 { 461 - struct device *dev = ring->dev->dev->dev; 461 + struct device *dma_dev = ring->dev->dev->dma_dev; 462 462 463 - ring->descbase = dma_alloc_coherent(dev, B43legacy_DMA_RINGMEMSIZE, 463 + ring->descbase = dma_alloc_coherent(dma_dev, B43legacy_DMA_RINGMEMSIZE, 464 464 &(ring->dmabase), GFP_KERNEL); 465 465 if (!ring->descbase) { 466 466 b43legacyerr(ring->dev->wl, "DMA ringmemory allocation" ··· 474 474 475 475 static void free_ringmemory(struct b43legacy_dmaring *ring) 476 476 { 477 - struct device *dev = ring->dev->dev->dev; 477 + struct device *dma_dev = ring->dev->dev->dma_dev; 478 478 479 - dma_free_coherent(dev, B43legacy_DMA_RINGMEMSIZE, 479 + dma_free_coherent(dma_dev, B43legacy_DMA_RINGMEMSIZE, 480 480 ring->descbase, ring->dmabase); 481 481 } 482 482 ··· 585 585 586 586 /* Check if a DMA mapping address is invalid. */ 587 587 static bool b43legacy_dma_mapping_error(struct b43legacy_dmaring *ring, 588 - dma_addr_t addr, 589 - size_t buffersize) 588 + dma_addr_t addr, 589 + size_t buffersize, 590 + bool dma_to_device) 590 591 { 591 592 if (unlikely(dma_mapping_error(addr))) 592 593 return 1; ··· 595 594 switch (ring->type) { 596 595 case B43legacy_DMA_30BIT: 597 596 if ((u64)addr + buffersize > (1ULL << 30)) 598 - return 1; 597 + goto address_error; 599 598 break; 600 599 case B43legacy_DMA_32BIT: 601 600 if ((u64)addr + buffersize > (1ULL << 32)) 602 - return 1; 601 + goto address_error; 603 602 break; 604 603 case B43legacy_DMA_64BIT: 605 604 /* Currently we can't have addresses beyond 64 bits in the kernel. */ ··· 608 607 609 608 /* The address is OK. */ 610 609 return 0; 610 + 611 + address_error: 612 + /* We can't support this address. Unmap it again. */ 613 + unmap_descbuffer(ring, addr, buffersize, dma_to_device); 614 + 615 + return 1; 611 616 } 612 617 613 618 static int setup_rx_descbuffer(struct b43legacy_dmaring *ring, ··· 633 626 return -ENOMEM; 634 627 dmaaddr = map_descbuffer(ring, skb->data, 635 628 ring->rx_buffersize, 0); 636 - if (b43legacy_dma_mapping_error(ring, dmaaddr, ring->rx_buffersize)) { 629 + if (b43legacy_dma_mapping_error(ring, dmaaddr, ring->rx_buffersize, 0)) { 637 630 /* ugh. try to realloc in zone_dma */ 638 631 gfp_flags |= GFP_DMA; 639 632 ··· 646 639 ring->rx_buffersize, 0); 647 640 } 648 641 649 - if (b43legacy_dma_mapping_error(ring, dmaaddr, ring->rx_buffersize)) { 642 + if (b43legacy_dma_mapping_error(ring, dmaaddr, ring->rx_buffersize, 0)) { 650 643 dev_kfree_skb_any(skb); 651 644 return -EIO; 652 645 } ··· 893 886 goto err_kfree_meta; 894 887 895 888 /* test for ability to dma to txhdr_cache */ 896 - dma_test = dma_map_single(dev->dev->dev, ring->txhdr_cache, 889 + dma_test = dma_map_single(dev->dev->dma_dev, ring->txhdr_cache, 897 890 sizeof(struct b43legacy_txhdr_fw3), 898 891 DMA_TO_DEVICE); 899 892 900 893 if (b43legacy_dma_mapping_error(ring, dma_test, 901 - sizeof(struct b43legacy_txhdr_fw3))) { 894 + sizeof(struct b43legacy_txhdr_fw3), 1)) { 902 895 /* ugh realloc */ 903 896 kfree(ring->txhdr_cache); 904 897 ring->txhdr_cache = kcalloc(nr_slots, ··· 907 900 if (!ring->txhdr_cache) 908 901 goto err_kfree_meta; 909 902 910 - dma_test = dma_map_single(dev->dev->dev, 903 + dma_test = dma_map_single(dev->dev->dma_dev, 911 904 ring->txhdr_cache, 912 905 sizeof(struct b43legacy_txhdr_fw3), 913 906 DMA_TO_DEVICE); 914 907 915 908 if (b43legacy_dma_mapping_error(ring, dma_test, 916 - sizeof(struct b43legacy_txhdr_fw3))) 909 + sizeof(struct b43legacy_txhdr_fw3), 1)) 917 910 goto err_kfree_txhdr_cache; 918 911 } 919 912 920 - dma_unmap_single(dev->dev->dev, 913 + dma_unmap_single(dev->dev->dma_dev, 921 914 dma_test, sizeof(struct b43legacy_txhdr_fw3), 922 915 DMA_TO_DEVICE); 923 916 } ··· 1242 1235 meta_hdr->dmaaddr = map_descbuffer(ring, (unsigned char *)header, 1243 1236 sizeof(struct b43legacy_txhdr_fw3), 1); 1244 1237 if (b43legacy_dma_mapping_error(ring, meta_hdr->dmaaddr, 1245 - sizeof(struct b43legacy_txhdr_fw3))) { 1238 + sizeof(struct b43legacy_txhdr_fw3), 1)) { 1246 1239 ring->current_slot = old_top_slot; 1247 1240 ring->used_slots = old_used_slots; 1248 1241 return -EIO; ··· 1261 1254 1262 1255 meta->dmaaddr = map_descbuffer(ring, skb->data, skb->len, 1); 1263 1256 /* create a bounce buffer in zone_dma on mapping failure. */ 1264 - if (b43legacy_dma_mapping_error(ring, meta->dmaaddr, skb->len)) { 1257 + if (b43legacy_dma_mapping_error(ring, meta->dmaaddr, skb->len, 1)) { 1265 1258 bounce_skb = __dev_alloc_skb(skb->len, GFP_ATOMIC | GFP_DMA); 1266 1259 if (!bounce_skb) { 1267 1260 ring->current_slot = old_top_slot; ··· 1275 1268 skb = bounce_skb; 1276 1269 meta->skb = skb; 1277 1270 meta->dmaaddr = map_descbuffer(ring, skb->data, skb->len, 1); 1278 - if (b43legacy_dma_mapping_error(ring, meta->dmaaddr, skb->len)) { 1271 + if (b43legacy_dma_mapping_error(ring, meta->dmaaddr, skb->len, 1)) { 1279 1272 ring->current_slot = old_top_slot; 1280 1273 ring->used_slots = old_used_slots; 1281 1274 err = -EIO;
+2
drivers/net/wireless/b43legacy/main.c
··· 1488 1488 } 1489 1489 if (!fw->initvals) { 1490 1490 switch (dev->phy.type) { 1491 + case B43legacy_PHYTYPE_B: 1491 1492 case B43legacy_PHYTYPE_G: 1492 1493 if ((rev >= 5) && (rev <= 10)) 1493 1494 filename = "b0g0initvals5"; ··· 1506 1505 } 1507 1506 if (!fw->initvals_band) { 1508 1507 switch (dev->phy.type) { 1508 + case B43legacy_PHYTYPE_B: 1509 1509 case B43legacy_PHYTYPE_G: 1510 1510 if ((rev >= 5) && (rev <= 10)) 1511 1511 filename = "b0g0bsinitvals5";
+3
drivers/net/wireless/rtl8187_dev.c
··· 509 509 return -EOPNOTSUPP; 510 510 } 511 511 512 + priv->vif = conf->vif; 513 + 512 514 rtl818x_iowrite8(priv, &priv->map->EEPROM_CMD, RTL818X_EEPROM_CMD_CONFIG); 513 515 for (i = 0; i < ETH_ALEN; i++) 514 516 rtl818x_iowrite8(priv, &priv->map->MAC[i], ··· 525 523 { 526 524 struct rtl8187_priv *priv = dev->priv; 527 525 priv->mode = IEEE80211_IF_TYPE_MNTR; 526 + priv->vif = NULL; 528 527 } 529 528 530 529 static int rtl8187_config(struct ieee80211_hw *dev, struct ieee80211_conf *conf)
+8 -6
drivers/ssb/main.c
··· 436 436 #ifdef CONFIG_SSB_PCIHOST 437 437 sdev->irq = bus->host_pci->irq; 438 438 dev->parent = &bus->host_pci->dev; 439 + sdev->dma_dev = &bus->host_pci->dev; 439 440 #endif 440 441 break; 441 442 case SSB_BUSTYPE_PCMCIA: 442 443 #ifdef CONFIG_SSB_PCMCIAHOST 443 444 sdev->irq = bus->host_pcmcia->irq.AssignedIRQ; 444 445 dev->parent = &bus->host_pcmcia->dev; 446 + sdev->dma_dev = &bus->host_pcmcia->dev; 445 447 #endif 446 448 break; 447 449 case SSB_BUSTYPE_SSB: 450 + sdev->dma_dev = dev; 448 451 break; 449 452 } 450 453 ··· 1021 1018 1022 1019 int ssb_dma_set_mask(struct ssb_device *ssb_dev, u64 mask) 1023 1020 { 1024 - struct device *dev = ssb_dev->dev; 1021 + struct device *dma_dev = ssb_dev->dma_dev; 1025 1022 1026 1023 #ifdef CONFIG_SSB_PCIHOST 1027 - if (ssb_dev->bus->bustype == SSB_BUSTYPE_PCI && 1028 - !dma_supported(dev, mask)) 1029 - return -EIO; 1024 + if (ssb_dev->bus->bustype == SSB_BUSTYPE_PCI) 1025 + return dma_set_mask(dma_dev, mask); 1030 1026 #endif 1031 - dev->coherent_dma_mask = mask; 1032 - dev->dma_mask = &dev->coherent_dma_mask; 1027 + dma_dev->coherent_dma_mask = mask; 1028 + dma_dev->dma_mask = &dma_dev->coherent_dma_mask; 1033 1029 1034 1030 return 0; 1035 1031 }
+4
include/linux/ssb/ssb.h
··· 129 129 const struct ssb_bus_ops *ops; 130 130 131 131 struct device *dev; 132 + /* Pointer to the device that has to be used for 133 + * any DMA related operation. */ 134 + struct device *dma_dev; 135 + 132 136 struct ssb_bus *bus; 133 137 struct ssb_device_id id; 134 138
+52 -26
net/ipv4/tcp_input.c
··· 3841 3841 } 3842 3842 } 3843 3843 3844 + static int tcp_prune_ofo_queue(struct sock *sk); 3844 3845 static int tcp_prune_queue(struct sock *sk); 3846 + 3847 + static inline int tcp_try_rmem_schedule(struct sock *sk, unsigned int size) 3848 + { 3849 + if (atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf || 3850 + !sk_rmem_schedule(sk, size)) { 3851 + 3852 + if (tcp_prune_queue(sk) < 0) 3853 + return -1; 3854 + 3855 + if (!sk_rmem_schedule(sk, size)) { 3856 + if (!tcp_prune_ofo_queue(sk)) 3857 + return -1; 3858 + 3859 + if (!sk_rmem_schedule(sk, size)) 3860 + return -1; 3861 + } 3862 + } 3863 + return 0; 3864 + } 3845 3865 3846 3866 static void tcp_data_queue(struct sock *sk, struct sk_buff *skb) 3847 3867 { ··· 3912 3892 if (eaten <= 0) { 3913 3893 queue_and_out: 3914 3894 if (eaten < 0 && 3915 - (atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf || 3916 - !sk_rmem_schedule(sk, skb->truesize))) { 3917 - if (tcp_prune_queue(sk) < 0 || 3918 - !sk_rmem_schedule(sk, skb->truesize)) 3919 - goto drop; 3920 - } 3895 + tcp_try_rmem_schedule(sk, skb->truesize)) 3896 + goto drop; 3897 + 3921 3898 skb_set_owner_r(skb, sk); 3922 3899 __skb_queue_tail(&sk->sk_receive_queue, skb); 3923 3900 } ··· 3983 3966 3984 3967 TCP_ECN_check_ce(tp, skb); 3985 3968 3986 - if (atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf || 3987 - !sk_rmem_schedule(sk, skb->truesize)) { 3988 - if (tcp_prune_queue(sk) < 0 || 3989 - !sk_rmem_schedule(sk, skb->truesize)) 3990 - goto drop; 3991 - } 3969 + if (tcp_try_rmem_schedule(sk, skb->truesize)) 3970 + goto drop; 3992 3971 3993 3972 /* Disable header prediction. */ 3994 3973 tp->pred_flags = 0; ··· 4211 4198 } 4212 4199 } 4213 4200 4201 + /* 4202 + * Purge the out-of-order queue. 4203 + * Return true if queue was pruned. 4204 + */ 4205 + static int tcp_prune_ofo_queue(struct sock *sk) 4206 + { 4207 + struct tcp_sock *tp = tcp_sk(sk); 4208 + int res = 0; 4209 + 4210 + if (!skb_queue_empty(&tp->out_of_order_queue)) { 4211 + NET_INC_STATS_BH(LINUX_MIB_OFOPRUNED); 4212 + __skb_queue_purge(&tp->out_of_order_queue); 4213 + 4214 + /* Reset SACK state. A conforming SACK implementation will 4215 + * do the same at a timeout based retransmit. When a connection 4216 + * is in a sad state like this, we care only about integrity 4217 + * of the connection not performance. 4218 + */ 4219 + if (tp->rx_opt.sack_ok) 4220 + tcp_sack_reset(&tp->rx_opt); 4221 + sk_mem_reclaim(sk); 4222 + res = 1; 4223 + } 4224 + return res; 4225 + } 4226 + 4214 4227 /* Reduce allocated memory if we can, trying to get 4215 4228 * the socket within its memory limits again. 4216 4229 * ··· 4270 4231 /* Collapsing did not help, destructive actions follow. 4271 4232 * This must not ever occur. */ 4272 4233 4273 - /* First, purge the out_of_order queue. */ 4274 - if (!skb_queue_empty(&tp->out_of_order_queue)) { 4275 - NET_INC_STATS_BH(LINUX_MIB_OFOPRUNED); 4276 - __skb_queue_purge(&tp->out_of_order_queue); 4277 - 4278 - /* Reset SACK state. A conforming SACK implementation will 4279 - * do the same at a timeout based retransmit. When a connection 4280 - * is in a sad state like this, we care only about integrity 4281 - * of the connection not performance. 4282 - */ 4283 - if (tcp_is_sack(tp)) 4284 - tcp_sack_reset(&tp->rx_opt); 4285 - sk_mem_reclaim(sk); 4286 - } 4234 + tcp_prune_ofo_queue(sk); 4287 4235 4288 4236 if (atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf) 4289 4237 return 0;
+2 -5
net/mac80211/rx.c
··· 1050 1050 if (unlikely(!(rx->fc & IEEE80211_FCTL_PROTECTED) && 1051 1051 (rx->fc & IEEE80211_FCTL_FTYPE) == IEEE80211_FTYPE_DATA && 1052 1052 (rx->fc & IEEE80211_FCTL_STYPE) != IEEE80211_STYPE_NULLFUNC && 1053 - (rx->key || rx->sdata->drop_unencrypted))) { 1054 - if (net_ratelimit()) 1055 - printk(KERN_DEBUG "%s: RX non-WEP frame, but expected " 1056 - "encryption\n", rx->dev->name); 1053 + (rx->key || rx->sdata->drop_unencrypted))) 1057 1054 return -EACCES; 1058 - } 1055 + 1059 1056 return 0; 1060 1057 } 1061 1058
+1 -1
net/rfkill/rfkill.c
··· 92 92 rfkill_states[type] = state; 93 93 94 94 list_for_each_entry(rfkill, &rfkill_list, node) { 95 - if (!rfkill->user_claim) 95 + if ((!rfkill->user_claim) && (rfkill->type == type)) 96 96 rfkill_toggle_radio(rfkill, state); 97 97 } 98 98
+3
net/sched/sch_api.c
··· 386 386 if (n == 0) 387 387 return; 388 388 while ((parentid = sch->parent)) { 389 + if (TC_H_MAJ(parentid) == TC_H_MAJ(TC_H_INGRESS)) 390 + return; 391 + 389 392 sch = qdisc_lookup(sch->dev, TC_H_MAJ(parentid)); 390 393 if (sch == NULL) { 391 394 WARN_ON(parentid != TC_H_ROOT);