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

+1

drivers/net/gianfar.c

··· 491 491 492 492 dev_set_drvdata(&ofdev->dev, NULL); 493 493 494 + unregister_netdev(dev); 494 495 iounmap(priv->regs); 495 496 free_netdev(priv->ndev); 496 497

+67 -53

drivers/net/wireless/ipw2x00/ipw2200.c

··· 2874 2874 return 0; 2875 2875 } 2876 2876 2877 - static int ipw_fw_dma_add_buffer(struct ipw_priv *priv, 2878 - u32 src_phys, u32 dest_address, u32 length) 2877 + static int ipw_fw_dma_add_buffer(struct ipw_priv *priv, dma_addr_t *src_address, 2878 + int nr, u32 dest_address, u32 len) 2879 2879 { 2880 - u32 bytes_left = length; 2881 - u32 src_offset = 0; 2882 - u32 dest_offset = 0; 2883 - int status = 0; 2880 + int ret, i; 2881 + u32 size; 2882 + 2884 2883 IPW_DEBUG_FW(">> \n"); 2885 - IPW_DEBUG_FW_INFO("src_phys=0x%x dest_address=0x%x length=0x%x\n", 2886 - src_phys, dest_address, length); 2887 - while (bytes_left > CB_MAX_LENGTH) { 2888 - status = ipw_fw_dma_add_command_block(priv, 2889 - src_phys + src_offset, 2890 - dest_address + 2891 - dest_offset, 2892 - CB_MAX_LENGTH, 0, 0); 2893 - if (status) { 2884 + IPW_DEBUG_FW_INFO("nr=%d dest_address=0x%x len=0x%x\n", 2885 + nr, dest_address, len); 2886 + 2887 + for (i = 0; i < nr; i++) { 2888 + size = min_t(u32, len - i * CB_MAX_LENGTH, CB_MAX_LENGTH); 2889 + ret = ipw_fw_dma_add_command_block(priv, src_address[i], 2890 + dest_address + 2891 + i * CB_MAX_LENGTH, size, 2892 + 0, 0); 2893 + if (ret) { 2894 2894 IPW_DEBUG_FW_INFO(": Failed\n"); 2895 2895 return -1; 2896 2896 } else 2897 2897 IPW_DEBUG_FW_INFO(": Added new cb\n"); 2898 - 2899 - src_offset += CB_MAX_LENGTH; 2900 - dest_offset += CB_MAX_LENGTH; 2901 - bytes_left -= CB_MAX_LENGTH; 2902 - } 2903 - 2904 - /* add the buffer tail */ 2905 - if (bytes_left > 0) { 2906 - status = 2907 - ipw_fw_dma_add_command_block(priv, src_phys + src_offset, 2908 - dest_address + dest_offset, 2909 - bytes_left, 0, 0); 2910 - if (status) { 2911 - IPW_DEBUG_FW_INFO(": Failed on the buffer tail\n"); 2912 - return -1; 2913 - } else 2914 - IPW_DEBUG_FW_INFO 2915 - (": Adding new cb - the buffer tail\n"); 2916 2898 } 2917 2899 2918 2900 IPW_DEBUG_FW("<< \n"); ··· 3142 3160 3143 3161 static int ipw_load_firmware(struct ipw_priv *priv, u8 * data, size_t len) 3144 3162 { 3145 - int rc = -1; 3163 + int ret = -1; 3146 3164 int offset = 0; 3147 3165 struct fw_chunk *chunk; 3148 - dma_addr_t shared_phys; 3149 - u8 *shared_virt; 3166 + int total_nr = 0; 3167 + int i; 3168 + struct pci_pool *pool; 3169 + u32 *virts[CB_NUMBER_OF_ELEMENTS_SMALL]; 3170 + dma_addr_t phys[CB_NUMBER_OF_ELEMENTS_SMALL]; 3150 3171 3151 3172 IPW_DEBUG_TRACE("<< : \n"); 3152 - shared_virt = pci_alloc_consistent(priv->pci_dev, len, &shared_phys); 3153 3173 3154 - if (!shared_virt) 3174 + pool = pci_pool_create("ipw2200", priv->pci_dev, CB_MAX_LENGTH, 0, 0); 3175 + if (!pool) { 3176 + IPW_ERROR("pci_pool_create failed\n"); 3155 3177 return -ENOMEM; 3156 - 3157 - memmove(shared_virt, data, len); 3178 + } 3158 3179 3159 3180 /* Start the Dma */ 3160 - rc = ipw_fw_dma_enable(priv); 3181 + ret = ipw_fw_dma_enable(priv); 3161 3182 3162 3183 /* the DMA is already ready this would be a bug. */ 3163 3184 BUG_ON(priv->sram_desc.last_cb_index > 0); 3164 3185 3165 3186 do { 3187 + u32 chunk_len; 3188 + u8 *start; 3189 + int size; 3190 + int nr = 0; 3191 + 3166 3192 chunk = (struct fw_chunk *)(data + offset); 3167 3193 offset += sizeof(struct fw_chunk); 3194 + chunk_len = le32_to_cpu(chunk->length); 3195 + start = data + offset; 3196 + 3197 + nr = (chunk_len + CB_MAX_LENGTH - 1) / CB_MAX_LENGTH; 3198 + for (i = 0; i < nr; i++) { 3199 + virts[total_nr] = pci_pool_alloc(pool, GFP_KERNEL, 3200 + &phys[total_nr]); 3201 + if (!virts[total_nr]) { 3202 + ret = -ENOMEM; 3203 + goto out; 3204 + } 3205 + size = min_t(u32, chunk_len - i * CB_MAX_LENGTH, 3206 + CB_MAX_LENGTH); 3207 + memcpy(virts[total_nr], start, size); 3208 + start += size; 3209 + total_nr++; 3210 + /* We don't support fw chunk larger than 64*8K */ 3211 + BUG_ON(total_nr > CB_NUMBER_OF_ELEMENTS_SMALL); 3212 + } 3213 + 3168 3214 /* build DMA packet and queue up for sending */ 3169 3215 /* dma to chunk->address, the chunk->length bytes from data + 3170 3216 * offeset*/ 3171 3217 /* Dma loading */ 3172 - rc = ipw_fw_dma_add_buffer(priv, shared_phys + offset, 3173 - le32_to_cpu(chunk->address), 3174 - le32_to_cpu(chunk->length)); 3175 - if (rc) { 3218 + ret = ipw_fw_dma_add_buffer(priv, &phys[total_nr - nr], 3219 + nr, le32_to_cpu(chunk->address), 3220 + chunk_len); 3221 + if (ret) { 3176 3222 IPW_DEBUG_INFO("dmaAddBuffer Failed\n"); 3177 3223 goto out; 3178 3224 } 3179 3225 3180 - offset += le32_to_cpu(chunk->length); 3226 + offset += chunk_len; 3181 3227 } while (offset < len); 3182 3228 3183 3229 /* Run the DMA and wait for the answer */ 3184 - rc = ipw_fw_dma_kick(priv); 3185 - if (rc) { 3230 + ret = ipw_fw_dma_kick(priv); 3231 + if (ret) { 3186 3232 IPW_ERROR("dmaKick Failed\n"); 3187 3233 goto out; 3188 3234 } 3189 3235 3190 - rc = ipw_fw_dma_wait(priv); 3191 - if (rc) { 3236 + ret = ipw_fw_dma_wait(priv); 3237 + if (ret) { 3192 3238 IPW_ERROR("dmaWaitSync Failed\n"); 3193 3239 goto out; 3194 3240 } 3195 - out: 3196 - pci_free_consistent(priv->pci_dev, len, shared_virt, shared_phys); 3197 - return rc; 3241 + out: 3242 + for (i = 0; i < total_nr; i++) 3243 + pci_pool_free(pool, virts[i], phys[i]); 3244 + 3245 + pci_pool_destroy(pool); 3246 + 3247 + return ret; 3198 3248 } 3199 3249 3200 3250 /* stop nic */

+2 -2

include/net/pkt_sched.h

··· 61 61 } 62 62 63 63 struct qdisc_watchdog { 64 - struct tasklet_hrtimer timer; 65 - struct Qdisc *qdisc; 64 + struct hrtimer timer; 65 + struct Qdisc *qdisc; 66 66 }; 67 67 68 68 extern void qdisc_watchdog_init(struct qdisc_watchdog *wd, struct Qdisc *qdisc);

+1 -1

net/core/sock.c

··· 1025 1025 sk->sk_prot = sk->sk_prot_creator = prot; 1026 1026 sock_lock_init(sk); 1027 1027 sock_net_set(sk, get_net(net)); 1028 + atomic_set(&sk->sk_wmem_alloc, 1); 1028 1029 } 1029 1030 1030 1031 return sk; ··· 1873 1872 */ 1874 1873 smp_wmb(); 1875 1874 atomic_set(&sk->sk_refcnt, 1); 1876 - atomic_set(&sk->sk_wmem_alloc, 1); 1877 1875 atomic_set(&sk->sk_drops, 0); 1878 1876 } 1879 1877 EXPORT_SYMBOL(sock_init_data);

+7 -5

net/sched/sch_api.c

··· 458 458 static enum hrtimer_restart qdisc_watchdog(struct hrtimer *timer) 459 459 { 460 460 struct qdisc_watchdog *wd = container_of(timer, struct qdisc_watchdog, 461 - timer.timer); 461 + timer); 462 462 463 463 wd->qdisc->flags &= ~TCQ_F_THROTTLED; 464 464 __netif_schedule(qdisc_root(wd->qdisc)); ··· 468 468 469 469 void qdisc_watchdog_init(struct qdisc_watchdog *wd, struct Qdisc *qdisc) 470 470 { 471 - tasklet_hrtimer_init(&wd->timer, qdisc_watchdog, 472 - CLOCK_MONOTONIC, HRTIMER_MODE_ABS); 471 + hrtimer_init(&wd->timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS); 472 + wd->timer.function = qdisc_watchdog; 473 473 wd->qdisc = qdisc; 474 474 } 475 475 EXPORT_SYMBOL(qdisc_watchdog_init); ··· 485 485 wd->qdisc->flags |= TCQ_F_THROTTLED; 486 486 time = ktime_set(0, 0); 487 487 time = ktime_add_ns(time, PSCHED_TICKS2NS(expires)); 488 - tasklet_hrtimer_start(&wd->timer, time, HRTIMER_MODE_ABS); 488 + hrtimer_start(&wd->timer, time, HRTIMER_MODE_ABS); 489 489 } 490 490 EXPORT_SYMBOL(qdisc_watchdog_schedule); 491 491 492 492 void qdisc_watchdog_cancel(struct qdisc_watchdog *wd) 493 493 { 494 - tasklet_hrtimer_cancel(&wd->timer); 494 + hrtimer_cancel(&wd->timer); 495 495 wd->qdisc->flags &= ~TCQ_F_THROTTLED; 496 496 } 497 497 EXPORT_SYMBOL(qdisc_watchdog_cancel); ··· 1456 1456 nlh = NLMSG_NEW(skb, pid, seq, event, sizeof(*tcm), flags); 1457 1457 tcm = NLMSG_DATA(nlh); 1458 1458 tcm->tcm_family = AF_UNSPEC; 1459 + tcm->tcm__pad1 = 0; 1460 + tcm->tcm__pad2 = 0; 1459 1461 tcm->tcm_ifindex = qdisc_dev(q)->ifindex; 1460 1462 tcm->tcm_parent = q->handle; 1461 1463 tcm->tcm_handle = q->handle;

+11 -14

net/sched/sch_cbq.c

··· 163 163 psched_time_t now_rt; /* Cached real time */ 164 164 unsigned pmask; 165 165 166 - struct tasklet_hrtimer delay_timer; 166 + struct hrtimer delay_timer; 167 167 struct qdisc_watchdog watchdog; /* Watchdog timer, 168 168 started when CBQ has 169 169 backlog, but cannot ··· 503 503 cl->undertime = q->now + delay; 504 504 505 505 if (delay > 0) { 506 - struct hrtimer *ht; 507 - 508 506 sched += delay + cl->penalty; 509 507 cl->penalized = sched; 510 508 cl->cpriority = TC_CBQ_MAXPRIO; ··· 510 512 511 513 expires = ktime_set(0, 0); 512 514 expires = ktime_add_ns(expires, PSCHED_TICKS2NS(sched)); 513 - ht = &q->delay_timer.timer; 514 - if (hrtimer_try_to_cancel(ht) && 515 - ktime_to_ns(ktime_sub(hrtimer_get_expires(ht), 516 - expires)) > 0) 517 - hrtimer_set_expires(ht, expires); 518 - hrtimer_restart(ht); 515 + if (hrtimer_try_to_cancel(&q->delay_timer) && 516 + ktime_to_ns(ktime_sub( 517 + hrtimer_get_expires(&q->delay_timer), 518 + expires)) > 0) 519 + hrtimer_set_expires(&q->delay_timer, expires); 520 + hrtimer_restart(&q->delay_timer); 519 521 cl->delayed = 1; 520 522 cl->xstats.overactions++; 521 523 return; ··· 591 593 static enum hrtimer_restart cbq_undelay(struct hrtimer *timer) 592 594 { 593 595 struct cbq_sched_data *q = container_of(timer, struct cbq_sched_data, 594 - delay_timer.timer); 596 + delay_timer); 595 597 struct Qdisc *sch = q->watchdog.qdisc; 596 598 psched_time_t now; 597 599 psched_tdiff_t delay = 0; ··· 621 623 622 624 time = ktime_set(0, 0); 623 625 time = ktime_add_ns(time, PSCHED_TICKS2NS(now + delay)); 624 - tasklet_hrtimer_start(&q->delay_timer, time, HRTIMER_MODE_ABS); 626 + hrtimer_start(&q->delay_timer, time, HRTIMER_MODE_ABS); 625 627 } 626 628 627 629 sch->flags &= ~TCQ_F_THROTTLED; ··· 1214 1216 q->tx_class = NULL; 1215 1217 q->tx_borrowed = NULL; 1216 1218 qdisc_watchdog_cancel(&q->watchdog); 1217 - tasklet_hrtimer_cancel(&q->delay_timer); 1219 + hrtimer_cancel(&q->delay_timer); 1218 1220 q->toplevel = TC_CBQ_MAXLEVEL; 1219 1221 q->now = psched_get_time(); 1220 1222 q->now_rt = q->now; ··· 1397 1399 q->link.minidle = -0x7FFFFFFF; 1398 1400 1399 1401 qdisc_watchdog_init(&q->watchdog, sch); 1400 - tasklet_hrtimer_init(&q->delay_timer, cbq_undelay, 1401 - CLOCK_MONOTONIC, HRTIMER_MODE_ABS); 1402 + hrtimer_init(&q->delay_timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS); 1402 1403 q->delay_timer.function = cbq_undelay; 1403 1404 q->toplevel = TC_CBQ_MAXLEVEL; 1404 1405 q->now = psched_get_time();

Configure Feed

Configure Feed