projects / openwrt.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
bcm47xx: Remove FIXME
[openwrt.git] / target / linux / ixp4xx / patches-2.6.23 / 012-velocity_BE.patch
1 diff -uprN linux-2.6.23.orig/drivers/net/via-velocity.c linux-2.6.23/drivers/net/via-velocity.c
2 --- linux-2.6.23.orig/drivers/net/via-velocity.c 2007-10-09 15:31:38.000000000 -0500
3 +++ linux-2.6.23/drivers/net/via-velocity.c 2007-10-11 00:53:45.000000000 -0500
4 @@ -96,11 +96,31 @@ MODULE_AUTHOR("VIA Networking Technologi
5 MODULE_LICENSE("GPL");
6 MODULE_DESCRIPTION("VIA Networking Velocity Family Gigabit Ethernet Adapter Driver");
7
8 +/* Valid values for vdebug (additive, this is a bitmask):
9 + * 0x00 => off
10 + * 0x01 => always on
11 + * 0x02 => additional detail on tx (rx, too, if anyone implements same)
12 + * 0x04 => detail the initialization process
13 + * 0x08 => spot debug detail; to be used as developers see fit
14 + */
15 +static int vdebug = 0;
16 +
17 +/* HAIL - these macros are for the normal 0x01-type tracing... */
18 +#define HAIL(S) \
19 + if (vdebug&1) printk(KERN_NOTICE "%s\n", (S));
20 +#define HAILS(S,T) \
21 + if (vdebug&1) printk(KERN_NOTICE "%s -> status=0x%x\n", (S), (T));
22 +
23 #define VELOCITY_PARAM(N,D) \
24 static int N[MAX_UNITS]=OPTION_DEFAULT;\
25 module_param_array(N, int, NULL, 0); \
26 MODULE_PARM_DESC(N, D);
27
28 +#define VELO_DEBUG_MIN 0
29 +#define VELO_DEBUG_MAX 255
30 +#define VELO_DEBUG_DEF 0
31 +VELOCITY_PARAM(velo_debug, "Debug level");
32 +
33 #define RX_DESC_MIN 64
34 #define RX_DESC_MAX 255
35 #define RX_DESC_DEF 64
36 @@ -385,12 +405,12 @@ static void __devinit velocity_set_int_o
37 if (val == -1)
38 *opt = def;
39 else if (val < min || val > max) {
40 - VELOCITY_PRT(MSG_LEVEL_INFO, KERN_NOTICE "%s: the value of parameter %s is invalid, the valid range is (%d-%d)\n",
41 - devname, name, min, max);
42 + VELOCITY_PRT(MSG_LEVEL_INFO, KERN_NOTICE "via-velocity: the value of parameter %s is invalid, the valid range is (%d-%d)\n",
43 + name, min, max);
44 *opt = def;
45 } else {
46 - VELOCITY_PRT(MSG_LEVEL_INFO, KERN_INFO "%s: set value of parameter %s to %d\n",
47 - devname, name, val);
48 + VELOCITY_PRT(MSG_LEVEL_INFO, KERN_INFO "via-velocity: set value of parameter %s to %d\n",
49 + name, val);
50 *opt = val;
51 }
52 }
53 @@ -415,12 +435,12 @@ static void __devinit velocity_set_bool_
54 if (val == -1)
55 *opt |= (def ? flag : 0);
56 else if (val < 0 || val > 1) {
57 - printk(KERN_NOTICE "%s: the value of parameter %s is invalid, the valid range is (0-1)\n",
58 - devname, name);
59 + printk(KERN_NOTICE "via-velocity: the value of parameter %s is invalid, the valid range is (0-1)\n",
60 + name);
61 *opt |= (def ? flag : 0);
62 } else {
63 - printk(KERN_INFO "%s: set parameter %s to %s\n",
64 - devname, name, val ? "TRUE" : "FALSE");
65 + printk(KERN_INFO "via-velocity: set parameter %s to %s\n",
66 + name, val ? "TRUE" : "FALSE");
67 *opt |= (val ? flag : 0);
68 }
69 }
70 @@ -438,6 +458,7 @@ static void __devinit velocity_set_bool_
71 static void __devinit velocity_get_options(struct velocity_opt *opts, int index, char *devname)
72 {
73
74 + velocity_set_int_opt(&opts->velo_debug, velo_debug[index], VELO_DEBUG_MIN, VELO_DEBUG_MAX, VELO_DEBUG_DEF, "velo_debug", devname);
75 velocity_set_int_opt(&opts->rx_thresh, rx_thresh[index], RX_THRESH_MIN, RX_THRESH_MAX, RX_THRESH_DEF, "rx_thresh", devname);
76 velocity_set_int_opt(&opts->DMA_length, DMA_length[index], DMA_LENGTH_MIN, DMA_LENGTH_MAX, DMA_LENGTH_DEF, "DMA_length", devname);
77 velocity_set_int_opt(&opts->numrx, RxDescriptors[index], RX_DESC_MIN, RX_DESC_MAX, RX_DESC_DEF, "RxDescriptors", devname);
78 @@ -452,6 +473,7 @@ static void __devinit velocity_get_optio
79 velocity_set_int_opt((int *) &opts->wol_opts, wol_opts[index], WOL_OPT_MIN, WOL_OPT_MAX, WOL_OPT_DEF, "Wake On Lan options", devname);
80 velocity_set_int_opt((int *) &opts->int_works, int_works[index], INT_WORKS_MIN, INT_WORKS_MAX, INT_WORKS_DEF, "Interrupt service works", devname);
81 opts->numrx = (opts->numrx & ~3);
82 + vdebug = opts->velo_debug;
83 }
84
85 /**
86 @@ -466,6 +488,8 @@ static void velocity_init_cam_filter(str
87 {
88 struct mac_regs __iomem * regs = vptr->mac_regs;
89
90 + HAIL("velocity_init_cam_filter");
91 +
92 /* Turn on MCFG_PQEN, turn off MCFG_RTGOPT */
93 WORD_REG_BITS_SET(MCFG_PQEN, MCFG_RTGOPT, &regs->MCFG);
94 WORD_REG_BITS_ON(MCFG_VIDFR, &regs->MCFG);
95 @@ -484,14 +508,12 @@ static void velocity_init_cam_filter(str
96 WORD_REG_BITS_ON(MCFG_RTGOPT, &regs->MCFG);
97
98 mac_set_cam(regs, 0, (u8 *) & (vptr->options.vid), VELOCITY_VLAN_ID_CAM);
99 - vptr->vCAMmask[0] |= 1;
100 - mac_set_cam_mask(regs, vptr->vCAMmask, VELOCITY_VLAN_ID_CAM);
101 } else {
102 u16 temp = 0;
103 mac_set_cam(regs, 0, (u8 *) &temp, VELOCITY_VLAN_ID_CAM);
104 - temp = 1;
105 - mac_set_cam_mask(regs, (u8 *) &temp, VELOCITY_VLAN_ID_CAM);
106 }
107 + vptr->vCAMmask[0] |= 1;
108 + mac_set_cam_mask(regs, vptr->vCAMmask, VELOCITY_VLAN_ID_CAM);
109 }
110
111 /**
112 @@ -508,13 +530,15 @@ static void velocity_rx_reset(struct vel
113 struct mac_regs __iomem * regs = vptr->mac_regs;
114 int i;
115
116 + HAIL("velocity_rx_reset");
117 vptr->rd_dirty = vptr->rd_filled = vptr->rd_curr = 0;
118
119 /*
120 * Init state, all RD entries belong to the NIC
121 */
122 for (i = 0; i < vptr->options.numrx; ++i)
123 - vptr->rd_ring[i].rdesc0.owner = OWNED_BY_NIC;
124 + /* vptr->rd_ring[i].rdesc0.owner = OWNED_BY_NIC; BE */
125 + vptr->rd_ring[i].rdesc0 |= cpu_to_le32(BE_OWNED_BY_NIC); /* BE */
126
127 writew(vptr->options.numrx, &regs->RBRDU);
128 writel(vptr->rd_pool_dma, &regs->RDBaseLo);
129 @@ -537,12 +561,15 @@ static void velocity_init_registers(stru
130 struct mac_regs __iomem * regs = vptr->mac_regs;
131 int i, mii_status;
132
133 + if (vdebug&5) printk(KERN_NOTICE "velocity_init_registers: entering\n");
134 +
135 mac_wol_reset(regs);
136
137 switch (type) {
138 case VELOCITY_INIT_RESET:
139 case VELOCITY_INIT_WOL:
140
141 + if (vdebug&4) printk(KERN_NOTICE "velocity_init_registers: RESET or WOL\n");
142 netif_stop_queue(vptr->dev);
143
144 /*
145 @@ -570,12 +597,13 @@ static void velocity_init_registers(stru
146
147 case VELOCITY_INIT_COLD:
148 default:
149 + if (vdebug&4) printk(KERN_NOTICE "velocity_init_registers: COLD or default\n");
150 /*
151 * Do reset
152 */
153 velocity_soft_reset(vptr);
154 + if (vdebug&4) printk(KERN_NOTICE "velocity_init_registers: soft reset complete.\n");
155 mdelay(5);
156 -
157 mac_eeprom_reload(regs);
158 for (i = 0; i < 6; i++) {
159 writeb(vptr->dev->dev_addr[i], &(regs->PAR[i]));
160 @@ -593,11 +621,16 @@ static void velocity_init_registers(stru
161 */
162 BYTE_REG_BITS_SET(CFGB_OFSET, (CFGB_CRANDOM | CFGB_CAP | CFGB_MBA | CFGB_BAKOPT), &regs->CFGB);
163
164 + if (vdebug&4) printk(KERN_NOTICE "velocity_init_registers: Initializing CAM filter\n");
165 /*
166 * Init CAM filter
167 */
168 + if (vdebug&8) printk(KERN_NOTICE "velocity: spot debug: about to init CAM filters\n");
169 + mdelay(5); /* MJW - ARM processors, kernel 2.6.19 - this fixes oopses and hangs */
170 velocity_init_cam_filter(vptr);
171 + if (vdebug&8) printk(KERN_NOTICE "velocity: spot debug: init CAM filters complete\n");
172
173 + if (vdebug&4) printk(KERN_NOTICE "velocity_init_registers: Setting packet filter\n");
174 /*
175 * Set packet filter: Receive directed and broadcast address
176 */
177 @@ -607,10 +640,12 @@ static void velocity_init_registers(stru
178 * Enable MII auto-polling
179 */
180 enable_mii_autopoll(regs);
181 + if (vdebug&4) printk(KERN_NOTICE "velocity_init_registers: enable_mii_autopoll complete.\n");
182
183 vptr->int_mask = INT_MASK_DEF;
184
185 - writel(cpu_to_le32(vptr->rd_pool_dma), &regs->RDBaseLo);
186 + /* writel(cpu_to_le32(vptr->rd_pool_dma), &regs->RDBaseLo); BE */
187 + writel((vptr->rd_pool_dma), &regs->RDBaseLo); /* BE */
188 writew(vptr->options.numrx - 1, &regs->RDCSize);
189 mac_rx_queue_run(regs);
190 mac_rx_queue_wake(regs);
191 @@ -618,10 +653,13 @@ static void velocity_init_registers(stru
192 writew(vptr->options.numtx - 1, &regs->TDCSize);
193
194 for (i = 0; i < vptr->num_txq; i++) {
195 - writel(cpu_to_le32(vptr->td_pool_dma[i]), &(regs->TDBaseLo[i]));
196 + /* writel(cpu_to_le32(vptr->td_pool_dma[i]), &(regs->TDBaseLo[i])); BE */
197 + writel((vptr->td_pool_dma[i]), &(regs->TDBaseLo[i])); /* BE */
198 mac_tx_queue_run(regs, i);
199 }
200
201 + if (vdebug&4) printk(KERN_NOTICE "velocity_init_registers: DMA settings complete.\n");
202 +
203 init_flow_control_register(vptr);
204
205 writel(CR0_STOP, &regs->CR0Clr);
206 @@ -640,8 +678,10 @@ static void velocity_init_registers(stru
207
208 enable_flow_control_ability(vptr);
209 mac_hw_mibs_init(regs);
210 + if (vdebug&4) printk(KERN_NOTICE "velocity_init_registers: Set interrupt mask\n");
211 mac_write_int_mask(vptr->int_mask, regs);
212 mac_clear_isr(regs);
213 + if (vdebug&4) printk(KERN_NOTICE "velocity_init_registers: complete.\n");
214
215 }
216 }
217 @@ -659,6 +699,7 @@ static int velocity_soft_reset(struct ve
218 struct mac_regs __iomem * regs = vptr->mac_regs;
219 int i = 0;
220
221 + HAIL("velocity_soft_reset");
222 writel(CR0_SFRST, &regs->CR0Set);
223
224 for (i = 0; i < W_MAX_TIMEOUT; i++) {
225 @@ -722,6 +763,7 @@ static int __devinit velocity_found1(str
226 VELOCITY_FULL_DRV_NAM, VELOCITY_VERSION);
227 printk(KERN_INFO "Copyright (c) 2002, 2003 VIA Networking Technologies, Inc.\n");
228 printk(KERN_INFO "Copyright (c) 2004 Red Hat Inc.\n");
229 + printk(KERN_INFO "BE support, misc. fixes MJW 01Jan2007 - may be unstable\n");
230 first = 0;
231 }
232
233 @@ -934,6 +976,7 @@ static int velocity_init_rings(struct ve
234 dma_addr_t pool_dma;
235 u8 *pool;
236
237 + HAIL("velocity_init_rings");
238 /*
239 * Allocate all RD/TD rings a single pool
240 */
241 @@ -996,6 +1039,7 @@ static int velocity_init_rings(struct ve
242 static void velocity_free_rings(struct velocity_info *vptr)
243 {
244 int size;
245 + HAIL("velocity_free_rings");
246
247 size = vptr->options.numrx * sizeof(struct rx_desc) +
248 vptr->options.numtx * sizeof(struct tx_desc) * vptr->num_txq;
249 @@ -1012,6 +1056,7 @@ static inline void velocity_give_many_rx
250 struct mac_regs __iomem *regs = vptr->mac_regs;
251 int avail, dirty, unusable;
252
253 + HAIL("velocity_give_many_rx_descs");
254 /*
255 * RD number must be equal to 4X per hardware spec
256 * (programming guide rev 1.20, p.13)
257 @@ -1025,7 +1070,8 @@ static inline void velocity_give_many_rx
258 dirty = vptr->rd_dirty - unusable;
259 for (avail = vptr->rd_filled & 0xfffc; avail; avail--) {
260 dirty = (dirty > 0) ? dirty - 1 : vptr->options.numrx - 1;
261 - vptr->rd_ring[dirty].rdesc0.owner = OWNED_BY_NIC;
262 + /* vptr->rd_ring[dirty].rdesc0.owner = OWNED_BY_NIC; BE */
263 + vptr->rd_ring[dirty].rdesc0 |= cpu_to_le32(BE_OWNED_BY_NIC); /* BE */
264 }
265
266 writew(vptr->rd_filled & 0xfffc, &regs->RBRDU);
267 @@ -1035,12 +1081,14 @@ static inline void velocity_give_many_rx
268 static int velocity_rx_refill(struct velocity_info *vptr)
269 {
270 int dirty = vptr->rd_dirty, done = 0, ret = 0;
271 + HAIL("velocity_rx_refill");
272
273 do {
274 struct rx_desc *rd = vptr->rd_ring + dirty;
275
276 /* Fine for an all zero Rx desc at init time as well */
277 - if (rd->rdesc0.owner == OWNED_BY_NIC)
278 + /* if (rd->rdesc0.owner == OWNED_BY_NIC) BE */
279 + if (rd->rdesc0 & cpu_to_le32(BE_OWNED_BY_NIC)) /* BE */
280 break;
281
282 if (!vptr->rd_info[dirty].skb) {
283 @@ -1075,6 +1123,7 @@ static int velocity_init_rd_ring(struct
284 unsigned int rsize = sizeof(struct velocity_rd_info) *
285 vptr->options.numrx;
286
287 + HAIL("velocity_init_rd_ring");
288 vptr->rd_info = kmalloc(rsize, GFP_KERNEL);
289 if(vptr->rd_info == NULL)
290 goto out;
291 @@ -1104,6 +1153,7 @@ static void velocity_free_rd_ring(struct
292 {
293 int i;
294
295 + HAIL("velocity_free_rd_ring");
296 if (vptr->rd_info == NULL)
297 return;
298
299 @@ -1145,6 +1195,7 @@ static int velocity_init_td_ring(struct
300 unsigned int tsize = sizeof(struct velocity_td_info) *
301 vptr->options.numtx;
302
303 + HAIL("velocity_init_td_ring");
304 /* Init the TD ring entries */
305 for (j = 0; j < vptr->num_txq; j++) {
306 curr = vptr->td_pool_dma[j];
307 @@ -1181,6 +1232,7 @@ static void velocity_free_td_ring_entry(
308 struct velocity_td_info * td_info = &(vptr->td_infos[q][n]);
309 int i;
310
311 + HAIL("velocity_free_td_ring_entry");
312 if (td_info == NULL)
313 return;
314
315 @@ -1210,6 +1262,7 @@ static void velocity_free_td_ring(struct
316 {
317 int i, j;
318
319 + HAIL("velocity_free_td_ring");
320 for (j = 0; j < vptr->num_txq; j++) {
321 if (vptr->td_infos[j] == NULL)
322 continue;
323 @@ -1237,34 +1290,42 @@ static int velocity_rx_srv(struct veloci
324 struct net_device_stats *stats = &vptr->stats;
325 int rd_curr = vptr->rd_curr;
326 int works = 0;
327 + u16 wRSR; /* BE */
328
329 + HAILS("velocity_rx_srv", status);
330 do {
331 struct rx_desc *rd = vptr->rd_ring + rd_curr;
332
333 if (!vptr->rd_info[rd_curr].skb)
334 break;
335
336 - if (rd->rdesc0.owner == OWNED_BY_NIC)
337 + /* if (rd->rdesc0.owner == OWNED_BY_NIC) BE */
338 + if (rd->rdesc0 & cpu_to_le32(BE_OWNED_BY_NIC)) /* BE */
339 break;
340
341 rmb();
342
343 + wRSR = (u16)(cpu_to_le32(rd->rdesc0)); /* BE */
344 /*
345 * Don't drop CE or RL error frame although RXOK is off
346 */
347 - if ((rd->rdesc0.RSR & RSR_RXOK) || (!(rd->rdesc0.RSR & RSR_RXOK) && (rd->rdesc0.RSR & (RSR_CE | RSR_RL)))) {
348 + /* if ((rd->rdesc0.RSR & RSR_RXOK) || (!(rd->rdesc0.RSR & RSR_RXOK) && (rd->rdesc0.RSR & (RSR_CE | RSR_RL)))) { BE */
349 + if ((wRSR & RSR_RXOK) || (!(wRSR & RSR_RXOK) && (wRSR & (RSR_CE | RSR_RL)))) { /* BE */
350 if (velocity_receive_frame(vptr, rd_curr) < 0)
351 stats->rx_dropped++;
352 } else {
353 - if (rd->rdesc0.RSR & RSR_CRC)
354 + /* if (rd->rdesc0.RSR & RSR_CRC) BE */
355 + if (wRSR & RSR_CRC) /* BE */
356 stats->rx_crc_errors++;
357 - if (rd->rdesc0.RSR & RSR_FAE)
358 + /* if (rd->rdesc0.RSR & RSR_FAE) BE */
359 + if (wRSR & RSR_FAE) /* BE */
360 stats->rx_frame_errors++;
361
362 stats->rx_dropped++;
363 }
364
365 - rd->inten = 1;
366 + /* rd->inten = 1; BE */
367 + rd->ltwo |= cpu_to_le32(BE_INT_ENABLE); /* BE */
368
369 vptr->dev->last_rx = jiffies;
370
371 @@ -1295,13 +1356,21 @@ static int velocity_rx_srv(struct veloci
372
373 static inline void velocity_rx_csum(struct rx_desc *rd, struct sk_buff *skb)
374 {
375 + u8 bCSM;
376 + HAIL("velocity_rx_csum");
377 skb->ip_summed = CHECKSUM_NONE;
378
379 - if (rd->rdesc1.CSM & CSM_IPKT) {
380 - if (rd->rdesc1.CSM & CSM_IPOK) {
381 - if ((rd->rdesc1.CSM & CSM_TCPKT) ||
382 - (rd->rdesc1.CSM & CSM_UDPKT)) {
383 - if (!(rd->rdesc1.CSM & CSM_TUPOK)) {
384 +// if (rd->rdesc1.CSM & CSM_IPKT) {
385 +// if (rd->rdesc1.CSM & CSM_IPOK) {
386 +// if ((rd->rdesc1.CSM & CSM_TCPKT) ||
387 +// (rd->rdesc1.CSM & CSM_UDPKT)) {
388 +// if (!(rd->rdesc1.CSM & CSM_TUPOK)) {
389 + bCSM = (u8)(cpu_to_le32(rd->rdesc1) >> 16); /* BE */
390 + if (bCSM & CSM_IPKT) {
391 + if (bCSM & CSM_IPOK) {
392 + if ((bCSM & CSM_TCPKT) ||
393 + (bCSM & CSM_UDPKT)) {
394 + if (!(bCSM & CSM_TUPOK)) { /* BE */
395 return;
396 }
397 }
398 @@ -1327,9 +1396,11 @@ static inline int velocity_rx_copy(struc
399 {
400 int ret = -1;
401
402 + HAIL("velocity_rx_copy");
403 if (pkt_size < rx_copybreak) {
404 struct sk_buff *new_skb;
405
406 + HAIL("velocity_rx_copy (working...)");
407 new_skb = dev_alloc_skb(pkt_size + 2);
408 if (new_skb) {
409 new_skb->dev = vptr->dev;
410 @@ -1360,10 +1431,12 @@ static inline int velocity_rx_copy(struc
411 static inline void velocity_iph_realign(struct velocity_info *vptr,
412 struct sk_buff *skb, int pkt_size)
413 {
414 + HAIL("velocity_iph_realign");
415 /* FIXME - memmove ? */
416 if (vptr->flags & VELOCITY_FLAGS_IP_ALIGN) {
417 int i;
418
419 + HAIL("velocity_iph_realign (working...)");
420 for (i = pkt_size; i >= 0; i--)
421 *(skb->data + i + 2) = *(skb->data + i);
422 skb_reserve(skb, 2);
423 @@ -1382,19 +1455,27 @@ static inline void velocity_iph_realign(
424 static int velocity_receive_frame(struct velocity_info *vptr, int idx)
425 {
426 void (*pci_action)(struct pci_dev *, dma_addr_t, size_t, int);
427 + u16 pkt_len; /* BE */
428 + u16 wRSR; /* BE */
429 + struct sk_buff *skb;
430 struct net_device_stats *stats = &vptr->stats;
431 struct velocity_rd_info *rd_info = &(vptr->rd_info[idx]);
432 struct rx_desc *rd = &(vptr->rd_ring[idx]);
433 - int pkt_len = rd->rdesc0.len;
434 - struct sk_buff *skb;
435 + /* int pkt_len = rd->rdesc0.len BE */;
436 +
437 + pkt_len = ((cpu_to_le32(rd->rdesc0) >> 16) & 0x00003FFFUL); /* BE */
438 + wRSR = (u16)(cpu_to_le32(rd->rdesc0)); /* BE */
439
440 - if (rd->rdesc0.RSR & (RSR_STP | RSR_EDP)) {
441 + HAIL("velocity_receive_frame");
442 + /* if (rd->rdesc0.RSR & (RSR_STP | RSR_EDP)) { BE */
443 + if (wRSR & (RSR_STP | RSR_EDP)) { /* BE */
444 VELOCITY_PRT(MSG_LEVEL_VERBOSE, KERN_ERR " %s : the received frame span multple RDs.\n", vptr->dev->name);
445 stats->rx_length_errors++;
446 return -EINVAL;
447 }
448
449 - if (rd->rdesc0.RSR & RSR_MAR)
450 + /* if (rd->rdesc0.RSR & RSR_MAR) BE */
451 + if (wRSR & RSR_MAR) /* BE */
452 vptr->stats.multicast++;
453
454 skb = rd_info->skb;
455 @@ -1407,7 +1488,8 @@ static int velocity_receive_frame(struct
456 */
457
458 if (vptr->flags & VELOCITY_FLAGS_VAL_PKT_LEN) {
459 - if (rd->rdesc0.RSR & RSR_RL) {
460 + /* if (rd->rdesc0.RSR & RSR_RL) { BE */
461 + if (wRSR & RSR_RL) { /* BE */
462 stats->rx_length_errors++;
463 return -EINVAL;
464 }
465 @@ -1451,6 +1533,7 @@ static int velocity_alloc_rx_buf(struct
466 struct rx_desc *rd = &(vptr->rd_ring[idx]);
467 struct velocity_rd_info *rd_info = &(vptr->rd_info[idx]);
468
469 + HAIL("velocity_alloc_rx_buf");
470 rd_info->skb = dev_alloc_skb(vptr->rx_buf_sz + 64);
471 if (rd_info->skb == NULL)
472 return -ENOMEM;
473 @@ -1468,10 +1551,14 @@ static int velocity_alloc_rx_buf(struct
474 */
475
476 *((u32 *) & (rd->rdesc0)) = 0;
477 - rd->len = cpu_to_le32(vptr->rx_buf_sz);
478 - rd->inten = 1;
479 + /* rd->len = cpu_to_le32(vptr->rx_buf_sz); BE */
480 + /* rd->inten = 1; BE */
481 rd->pa_low = cpu_to_le32(rd_info->skb_dma);
482 - rd->pa_high = 0;
483 + /* rd->pa_high = 0; BE */
484 + rd->ltwo &= cpu_to_le32(0xC000FFFFUL); /* BE */
485 + rd->ltwo |= cpu_to_le32((vptr->rx_buf_sz << 16)); /* BE */
486 + rd->ltwo |= cpu_to_le32(BE_INT_ENABLE); /* BE */
487 + rd->ltwo &= cpu_to_le32(0xFFFF0000UL); /* BE */
488 return 0;
489 }
490
491 @@ -1492,9 +1579,11 @@ static int velocity_tx_srv(struct veloci
492 int full = 0;
493 int idx;
494 int works = 0;
495 + u16 wTSR; /* BE */
496 struct velocity_td_info *tdinfo;
497 struct net_device_stats *stats = &vptr->stats;
498
499 + HAILS("velocity_tx_srv", status);
500 for (qnum = 0; qnum < vptr->num_txq; qnum++) {
501 for (idx = vptr->td_tail[qnum]; vptr->td_used[qnum] > 0;
502 idx = (idx + 1) % vptr->options.numtx) {
503 @@ -1505,22 +1594,29 @@ static int velocity_tx_srv(struct veloci
504 td = &(vptr->td_rings[qnum][idx]);
505 tdinfo = &(vptr->td_infos[qnum][idx]);
506
507 - if (td->tdesc0.owner == OWNED_BY_NIC)
508 + /* if (td->tdesc0.owner == OWNED_BY_NIC) BE */
509 + if (td->tdesc0 & cpu_to_le32(BE_OWNED_BY_NIC)) /* BE */
510 break;
511
512 if ((works++ > 15))
513 break;
514
515 - if (td->tdesc0.TSR & TSR0_TERR) {
516 + wTSR = (u16)cpu_to_le32(td->tdesc0);
517 + /* if (td->tdesc0.TSR & TSR0_TERR) { BE */
518 + if (wTSR & TSR0_TERR) { /* BE */
519 stats->tx_errors++;
520 stats->tx_dropped++;
521 - if (td->tdesc0.TSR & TSR0_CDH)
522 + /* if (td->tdesc0.TSR & TSR0_CDH) BE */
523 + if (wTSR & TSR0_CDH) /* BE */
524 stats->tx_heartbeat_errors++;
525 - if (td->tdesc0.TSR & TSR0_CRS)
526 + /* if (td->tdesc0.TSR & TSR0_CRS) BE */
527 + if (wTSR & TSR0_CRS) /* BE */
528 stats->tx_carrier_errors++;
529 - if (td->tdesc0.TSR & TSR0_ABT)
530 + /* if (td->tdesc0.TSR & TSR0_ABT) BE */
531 + if (wTSR & TSR0_ABT) /* BE */
532 stats->tx_aborted_errors++;
533 - if (td->tdesc0.TSR & TSR0_OWC)
534 + /* if (td->tdesc0.TSR & TSR0_OWC) BE */
535 + if (wTSR & TSR0_OWC) /* BE */
536 stats->tx_window_errors++;
537 } else {
538 stats->tx_packets++;
539 @@ -1609,6 +1705,7 @@ static void velocity_print_link_status(s
540
541 static void velocity_error(struct velocity_info *vptr, int status)
542 {
543 + HAILS("velocity_error", status);
544
545 if (status & ISR_TXSTLI) {
546 struct mac_regs __iomem * regs = vptr->mac_regs;
547 @@ -1698,6 +1795,7 @@ static void velocity_free_tx_buf(struct
548 struct sk_buff *skb = tdinfo->skb;
549 int i;
550
551 + HAIL("velocity_free_tx_buf");
552 /*
553 * Don't unmap the pre-allocated tx_bufs
554 */
555 @@ -1901,6 +1999,7 @@ static int velocity_xmit(struct sk_buff
556 struct velocity_td_info *tdinfo;
557 unsigned long flags;
558 int index;
559 + u32 lbufsz; /* BE */
560
561 int pktlen = skb->len;
562
563 @@ -1917,9 +2016,18 @@ static int velocity_xmit(struct sk_buff
564 td_ptr = &(vptr->td_rings[qnum][index]);
565 tdinfo = &(vptr->td_infos[qnum][index]);
566
567 - td_ptr->tdesc1.TCPLS = TCPLS_NORMAL;
568 - td_ptr->tdesc1.TCR = TCR0_TIC;
569 - td_ptr->td_buf[0].queue = 0;
570 + td_ptr->tdesc0 = 0x00000000UL; /* BE */
571 + td_ptr->tdesc1 = 0x00000000UL; /* BE */
572 +
573 + /* td_ptr->tdesc1.TCPLS = TCPLS_NORMAL; BE */
574 + td_ptr->tdesc1 &= cpu_to_le32(0xfcffffffUL); /* BE */
575 + td_ptr->tdesc1 |= cpu_to_le32(((u32)TCPLS_NORMAL) << 24); /* BE */
576 +
577 + /* td_ptr->tdesc1.TCR = TCR0_TIC; BE */
578 + td_ptr->tdesc1 |= cpu_to_le32(BE_TCR_TIC); /* BE */
579 +
580 + /* td_ptr->td_buf[0].queue = 0; BE */
581 + td_ptr->td_buf[0].ltwo &= cpu_to_le32(~BE_QUEUE_ENABLE); /* BE */
582
583 /*
584 * Pad short frames.
585 @@ -1931,20 +2039,36 @@ static int velocity_xmit(struct sk_buff
586 memset(tdinfo->buf + skb->len, 0, ETH_ZLEN - skb->len);
587 tdinfo->skb = skb;
588 tdinfo->skb_dma[0] = tdinfo->buf_dma;
589 - td_ptr->tdesc0.pktsize = pktlen;
590 + /* td_ptr->tdesc0.pktsize = pktlen; */
591 + td_ptr->tdesc0 &= cpu_to_le32(0xc000ffffUL); /* BE */
592 + lbufsz = pktlen; /* Assign, and make sure it's unsigned 32 bits - BE */
593 + lbufsz = lbufsz << 16; /* BE - shift over */
594 + td_ptr->tdesc0 |= cpu_to_le32(lbufsz); /* BE */
595 +
596 td_ptr->td_buf[0].pa_low = cpu_to_le32(tdinfo->skb_dma[0]);
597 - td_ptr->td_buf[0].pa_high = 0;
598 - td_ptr->td_buf[0].bufsize = td_ptr->tdesc0.pktsize;
599 + /* td_ptr->td_buf[0].pa_high = 0; */
600 + /* td_ptr->td_buf[0].bufsize = td_ptr->tdesc0.pktsize; */
601 + td_ptr->td_buf[0].ltwo = cpu_to_le32(lbufsz); /* BE */
602 tdinfo->nskb_dma = 1;
603 - td_ptr->tdesc1.CMDZ = 2;
604 + /* td_ptr->tdesc1.CMDZ = 2; */
605 + td_ptr->tdesc1 &= cpu_to_le32(0x0fffffffUL); /* BE */
606 + td_ptr->tdesc1 |= cpu_to_le32(((u32)0x2) << 28); /* BE */
607 } else
608 #ifdef VELOCITY_ZERO_COPY_SUPPORT
609 + /*
610 + * BE - NOTE on the VELOCITY_ZERO_COPY_SUPPORT:
611 + * This block of code has NOT been patched up for BE support, as
612 + * it is certainly broken -- if it compiles at all. Since the BE
613 + * fixes depend on the broken code, attempts to convert to BE support
614 + * would almost certainly confuse more than help.
615 + */
616 if (skb_shinfo(skb)->nr_frags > 0) {
617 int nfrags = skb_shinfo(skb)->nr_frags;
618 tdinfo->skb = skb;
619 if (nfrags > 6) {
620 skb_copy_from_linear_data(skb, tdinfo->buf, skb->len);
621 tdinfo->skb_dma[0] = tdinfo->buf_dma;
622 + /* BE: Er, exactly what value are we assigning in this next line? */
623 td_ptr->tdesc0.pktsize =
624 td_ptr->td_buf[0].pa_low = cpu_to_le32(tdinfo->skb_dma[0]);
625 td_ptr->td_buf[0].pa_high = 0;
626 @@ -1961,6 +2085,7 @@ static int velocity_xmit(struct sk_buff
627 /* FIXME: support 48bit DMA later */
628 td_ptr->td_buf[i].pa_low = cpu_to_le32(tdinfo->skb_dma);
629 td_ptr->td_buf[i].pa_high = 0;
630 + /* BE: This next line can't be right: */
631 td_ptr->td_buf[i].bufsize = skb->len->skb->data_len;
632
633 for (i = 0; i < nfrags; i++) {
634 @@ -1978,7 +2103,7 @@ static int velocity_xmit(struct sk_buff
635 }
636
637 } else
638 -#endif
639 +#endif /* (broken) VELOCITY_ZERO_COPY_SUPPORT */
640 {
641 /*
642 * Map the linear network buffer into PCI space and
643 @@ -1986,19 +2111,30 @@ static int velocity_xmit(struct sk_buff
644 */
645 tdinfo->skb = skb;
646 tdinfo->skb_dma[0] = pci_map_single(vptr->pdev, skb->data, pktlen, PCI_DMA_TODEVICE);
647 - td_ptr->tdesc0.pktsize = pktlen;
648 + /* td_ptr->tdesc0.pktsize = pktlen; BE */
649 + td_ptr->tdesc0 &= cpu_to_le32(0xc000ffffUL); /* BE */
650 + lbufsz = pktlen; /* Assign, and make sure it's unsigned 32 bits - BE */
651 + lbufsz = lbufsz << 16; /* BE */
652 + td_ptr->tdesc0 |= cpu_to_le32(lbufsz); /* BE */
653 td_ptr->td_buf[0].pa_low = cpu_to_le32(tdinfo->skb_dma[0]);
654 - td_ptr->td_buf[0].pa_high = 0;
655 - td_ptr->td_buf[0].bufsize = td_ptr->tdesc0.pktsize;
656 + /* td_ptr->td_buf[0].pa_high = 0; BE */
657 + /* td_ptr->td_buf[0].bufsize = td_ptr->tdesc0.pktsize; BE */
658 + td_ptr->td_buf[0].ltwo = cpu_to_le32(lbufsz); /* BE */
659 +
660 tdinfo->nskb_dma = 1;
661 - td_ptr->tdesc1.CMDZ = 2;
662 + /* td_ptr->tdesc1.CMDZ = 2; BE */
663 + td_ptr->tdesc1 &= cpu_to_le32(0x0fffffffUL); /* BE */
664 + td_ptr->tdesc1 |= cpu_to_le32(((u32)0x2) << 28);/* BE */
665 }
666
667 if (vptr->flags & VELOCITY_FLAGS_TAGGING) {
668 - td_ptr->tdesc1.pqinf.VID = (vptr->options.vid & 0xfff);
669 - td_ptr->tdesc1.pqinf.priority = 0;
670 - td_ptr->tdesc1.pqinf.CFI = 0;
671 - td_ptr->tdesc1.TCR |= TCR0_VETAG;
672 + /* td_ptr->tdesc1.pqinf.priority = 0; BE */
673 + /* td_ptr->tdesc1.pqinf.CFI = 0; BE */
674 + td_ptr->tdesc1 &= cpu_to_le32(0xFFFF0000UL); /* BE */
675 + /* td_ptr->tdesc1.pqinf.VID = (vptr->options.vid & 0xfff); BE */
676 + td_ptr->tdesc1 |= cpu_to_le32((vptr->options.vid & 0xfff)); /* BE */
677 + /* td_ptr->tdesc1.TCR |= TCR0_VETAG; BE */
678 + td_ptr->tdesc1 |= cpu_to_le32(BE_TCR_VETAG); /* BE */
679 }
680
681 /*
682 @@ -2008,26 +2144,34 @@ static int velocity_xmit(struct sk_buff
683 && (skb->ip_summed == CHECKSUM_PARTIAL)) {
684 const struct iphdr *ip = ip_hdr(skb);
685 if (ip->protocol == IPPROTO_TCP)
686 - td_ptr->tdesc1.TCR |= TCR0_TCPCK;
687 + /* td_ptr->tdesc1.TCR |= TCR0_TCPCK; BE */
688 + td_ptr->tdesc1 |= cpu_to_le32(BE_TCR_TCPCK); /* BE */
689 else if (ip->protocol == IPPROTO_UDP)
690 - td_ptr->tdesc1.TCR |= (TCR0_UDPCK);
691 - td_ptr->tdesc1.TCR |= TCR0_IPCK;
692 - }
693 + /* td_ptr->tdesc1.TCR |= (TCR0_UDPCK); BE */
694 + td_ptr->tdesc1 |= cpu_to_le32(BE_TCR_UDPCK); /* BE */
695 + /* td_ptr->tdesc1.TCR |= TCR0_IPCK; BE */
696 + td_ptr->tdesc1 |= cpu_to_le32(BE_TCR_IPCK); /* BE */
697 + }
698 {
699
700 int prev = index - 1;
701
702 if (prev < 0)
703 prev = vptr->options.numtx - 1;
704 - td_ptr->tdesc0.owner = OWNED_BY_NIC;
705 + /* td_ptr->tdesc0.owner = OWNED_BY_NIC; BE */
706 + td_ptr->tdesc0 |= cpu_to_le32(BE_OWNED_BY_NIC); /* BE */
707 vptr->td_used[qnum]++;
708 vptr->td_curr[qnum] = (index + 1) % vptr->options.numtx;
709
710 if (AVAIL_TD(vptr, qnum) < 1)
711 netif_stop_queue(dev);
712
713 - td_ptr = &(vptr->td_rings[qnum][prev]);
714 - td_ptr->td_buf[0].queue = 1;
715 + td_ptr = &(vptr->td_rings[qnum][prev]);
716 + /* td_ptr->td_buf[0].queue = 1; BE */
717 + td_ptr->td_buf[0].ltwo |= cpu_to_le32(BE_QUEUE_ENABLE); /* BE */
718 + if (vdebug&2) printk(KERN_NOTICE "velocity_xmit: (%s) len=%d idx=%d tdesc0=0x%x tdesc1=0x%x ltwo=0x%x\n",
719 + (pktlen<ETH_ZLEN) ? "short" : "normal", pktlen, index,
720 + td_ptr->tdesc0, td_ptr->tdesc1, td_ptr->td_buf[0].ltwo);
721 mac_tx_queue_wake(vptr->mac_regs, qnum);
722 }
723 dev->trans_start = jiffies;
724 @@ -2053,7 +2197,7 @@ static int velocity_intr(int irq, void *
725 u32 isr_status;
726 int max_count = 0;
727
728 -
729 + HAIL("velocity_intr");
730 spin_lock(&vptr->lock);
731 isr_status = mac_read_isr(vptr->mac_regs);
732
733 @@ -2072,7 +2216,10 @@ static int velocity_intr(int irq, void *
734
735 while (isr_status != 0) {
736 mac_write_isr(vptr->mac_regs, isr_status);
737 - if (isr_status & (~(ISR_PRXI | ISR_PPRXI | ISR_PTXI | ISR_PPTXI)))
738 + HAILS("velocity_intr",isr_status);
739 + /* MJW - velocity_error is ALWAYS called; need to mask off some other flags */
740 + /* if (isr_status & (~(ISR_PRXI | ISR_PPRXI | ISR_PTXI | ISR_PPTXI))) */
741 + if (isr_status & (~(ISR_PRXI | ISR_PPRXI | ISR_PTXI | ISR_PPTXI | ISR_PTX0I | ISR_ISR0)))
742 velocity_error(vptr, isr_status);
743 if (isr_status & (ISR_PRXI | ISR_PPRXI))
744 max_count += velocity_rx_srv(vptr, isr_status);
745 @@ -2110,6 +2257,7 @@ static void velocity_set_multi(struct ne
746 int i;
747 struct dev_mc_list *mclist;
748
749 + HAIL("velocity_set_multi");
750 if (dev->flags & IFF_PROMISC) { /* Set promiscuous. */
751 writel(0xffffffff, &regs->MARCAM[0]);
752 writel(0xffffffff, &regs->MARCAM[4]);
753 @@ -2153,6 +2301,7 @@ static struct net_device_stats *velocity
754 {
755 struct velocity_info *vptr = netdev_priv(dev);
756
757 + HAIL("net_device_stats");
758 /* If the hardware is down, don't touch MII */
759 if(!netif_running(dev))
760 return &vptr->stats;
761 @@ -2197,6 +2346,7 @@ static int velocity_ioctl(struct net_dev
762 struct velocity_info *vptr = netdev_priv(dev);
763 int ret;
764
765 + HAIL("velocity_ioctl");
766 /* If we are asked for information and the device is power
767 saving then we need to bring the device back up to talk to it */
768
769 @@ -2415,6 +2565,7 @@ static int velocity_mii_read(struct mac_
770 {
771 u16 ww;
772
773 + HAIL("velocity_mii_read");
774 /*
775 * Disable MIICR_MAUTO, so that mii addr can be set normally
776 */
777 @@ -2451,6 +2602,7 @@ static int velocity_mii_write(struct mac
778 {
779 u16 ww;
780
781 + HAIL("velocity_mii_write");
782 /*
783 * Disable MIICR_MAUTO, so that mii addr can be set normally
784 */
785 diff -uprN linux-2.6.23.orig/drivers/net/via-velocity.h linux-2.6.23/drivers/net/via-velocity.h
786 --- linux-2.6.23.orig/drivers/net/via-velocity.h 2007-10-09 15:31:38.000000000 -0500
787 +++ linux-2.6.23/drivers/net/via-velocity.h 2007-10-11 00:53:45.000000000 -0500
788 @@ -196,64 +196,70 @@
789 * Receive descriptor
790 */
791
792 -struct rdesc0 {
793 - u16 RSR; /* Receive status */
794 - u16 len:14; /* Received packet length */
795 - u16 reserved:1;
796 - u16 owner:1; /* Who owns this buffer ? */
797 -};
798 -
799 -struct rdesc1 {
800 - u16 PQTAG;
801 - u8 CSM;
802 - u8 IPKT;
803 -};
804 +//struct rdesc0 {
805 +// u16 RSR; /* Receive status */
806 +// u16 len:14; /* Received packet length */
807 +// u16 reserved:1;
808 +// u16 owner:1; /* Who owns this buffer ? */
809 +//};
810 +
811 +//struct rdesc1 {
812 +// u16 PQTAG;
813 +// u8 CSM;
814 +// u8 IPKT;
815 +//};
816
817 struct rx_desc {
818 - struct rdesc0 rdesc0;
819 - struct rdesc1 rdesc1;
820 +// struct rdesc0 rdesc0;
821 +// struct rdesc1 rdesc1;
822 + u32 rdesc0;
823 + u32 rdesc1;
824 u32 pa_low; /* Low 32 bit PCI address */
825 - u16 pa_high; /* Next 16 bit PCI address (48 total) */
826 - u16 len:15; /* Frame size */
827 - u16 inten:1; /* Enable interrupt */
828 +// u16 pa_high; /* Next 16 bit PCI address (48 total) */
829 +// u16 len:15; /* Frame size */
830 +// u16 inten:1; /* Enable interrupt */
831 + u32 ltwo;
832 } __attribute__ ((__packed__));
833
834 /*
835 * Transmit descriptor
836 */
837
838 -struct tdesc0 {
839 - u16 TSR; /* Transmit status register */
840 - u16 pktsize:14; /* Size of frame */
841 - u16 reserved:1;
842 - u16 owner:1; /* Who owns the buffer */
843 -};
844 -
845 -struct pqinf { /* Priority queue info */
846 - u16 VID:12;
847 - u16 CFI:1;
848 - u16 priority:3;
849 -} __attribute__ ((__packed__));
850 -
851 -struct tdesc1 {
852 - struct pqinf pqinf;
853 - u8 TCR;
854 - u8 TCPLS:2;
855 - u8 reserved:2;
856 - u8 CMDZ:4;
857 -} __attribute__ ((__packed__));
858 +//struct tdesc0 {
859 +// u16 TSR; /* Transmit status register */
860 +// u16 pktsize:14; /* Size of frame */
861 +// u16 reserved:1;
862 +// u16 owner:1; /* Who owns the buffer */
863 +//};
864 +
865 +//struct pqinf { /* Priority queue info */
866 +// u16 VID:12;
867 +// u16 CFI:1;
868 +// u16 priority:3;
869 +//} __attribute__ ((__packed__));
870 +
871 +//struct tdesc1 {
872 +// struct pqinf pqinf;
873 +// u8 TCR;
874 +// u8 TCPLS:2;
875 +// u8 reserved:2;
876 +// u8 CMDZ:4;
877 +//} __attribute__ ((__packed__));
878
879 struct td_buf {
880 u32 pa_low;
881 - u16 pa_high;
882 - u16 bufsize:14;
883 - u16 reserved:1;
884 - u16 queue:1;
885 +// u16 pa_high;
886 +// u16 bufsize:14;
887 +// u16 reserved:1;
888 +// u16 queue:1;
889 + u32 ltwo;
890 } __attribute__ ((__packed__));
891
892 struct tx_desc {
893 - struct tdesc0 tdesc0;
894 - struct tdesc1 tdesc1;
895 +// struct tdesc0 tdesc0;
896 +// struct tdesc1 tdesc1;
897 + u32 tdesc0;
898 + u32 tdesc1;
899 struct td_buf td_buf[7];
900 };
901
902 @@ -279,6 +285,16 @@ enum velocity_owner {
903 OWNED_BY_NIC = 1
904 };
905
906 +/* Constants added for the BE fixes */
907 +#define BE_OWNED_BY_NIC 0x80000000UL
908 +#define BE_INT_ENABLE 0x80000000UL
909 +#define BE_QUEUE_ENABLE 0x80000000UL
910 +#define BE_TCR_TIC 0x00800000UL
911 +#define BE_TCR_VETAG 0x00200000UL
912 +#define BE_TCR_TCPCK 0x00040000UL
913 +#define BE_TCR_UDPCK 0x00080000UL
914 +#define BE_TCR_IPCK 0x00100000UL
915 +
916
917 /*
918 * MAC registers and macros.
919 @@ -1698,6 +1714,7 @@ enum velocity_flow_cntl_type {
920 };
921
922 struct velocity_opt {
923 + int velo_debug; /* debug flag */
924 int numrx; /* Number of RX descriptors */
925 int numtx; /* Number of TX descriptors */
926 enum speed_opt spd_dpx; /* Media link mode */
Personal OpenWRT clone
This page took 0.077973 seconds and 5 git commands to generate.