Merge commit 'jwb/next' into next
[linux-2.6] / drivers / usb / host / fhci-tds.c
1 /*
2  * Freescale QUICC Engine USB Host Controller Driver
3  *
4  * Copyright (c) Freescale Semicondutor, Inc. 2006.
5  *               Shlomi Gridish <gridish@freescale.com>
6  *               Jerry Huang <Chang-Ming.Huang@freescale.com>
7  * Copyright (c) Logic Product Development, Inc. 2007
8  *               Peter Barada <peterb@logicpd.com>
9  * Copyright (c) MontaVista Software, Inc. 2008.
10  *               Anton Vorontsov <avorontsov@ru.mvista.com>
11  *
12  * This program is free software; you can redistribute  it and/or modify it
13  * under  the terms of  the GNU General  Public License as published by the
14  * Free Software Foundation;  either version 2 of the  License, or (at your
15  * option) any later version.
16  */
17
18 #include <linux/kernel.h>
19 #include <linux/types.h>
20 #include <linux/errno.h>
21 #include <linux/list.h>
22 #include <linux/io.h>
23 #include <linux/usb.h>
24 #include "../core/hcd.h"
25 #include "fhci.h"
26
27 #define DUMMY_BD_BUFFER  0xdeadbeef
28 #define DUMMY2_BD_BUFFER 0xbaadf00d
29
30 /* Transaction Descriptors bits */
31 #define TD_R            0x8000 /* ready bit */
32 #define TD_W            0x2000 /* wrap bit */
33 #define TD_I            0x1000 /* interrupt on completion */
34 #define TD_L            0x0800 /* last */
35 #define TD_TC           0x0400 /* transmit CRC */
36 #define TD_CNF          0x0200 /* CNF - Must be always 1 */
37 #define TD_LSP          0x0100 /* Low-speed transaction */
38 #define TD_PID          0x00c0 /* packet id */
39 #define TD_RXER         0x0020 /* Rx error or not */
40
41 #define TD_NAK          0x0010 /* No ack. */
42 #define TD_STAL         0x0008 /* Stall recieved */
43 #define TD_TO           0x0004 /* time out */
44 #define TD_UN           0x0002 /* underrun */
45 #define TD_NO           0x0010 /* Rx Non Octet Aligned Packet */
46 #define TD_AB           0x0008 /* Frame Aborted */
47 #define TD_CR           0x0004 /* CRC Error */
48 #define TD_OV           0x0002 /* Overrun */
49 #define TD_BOV          0x0001 /* Buffer Overrun */
50
51 #define TD_ERRORS       (TD_NAK | TD_STAL | TD_TO | TD_UN | \
52                          TD_NO | TD_AB | TD_CR | TD_OV | TD_BOV)
53
54 #define TD_PID_DATA0    0x0080 /* Data 0 toggle */
55 #define TD_PID_DATA1    0x00c0 /* Data 1 toggle */
56 #define TD_PID_TOGGLE   0x00c0 /* Data 0/1 toggle mask */
57
58 #define TD_TOK_SETUP    0x0000
59 #define TD_TOK_OUT      0x4000
60 #define TD_TOK_IN       0x8000
61 #define TD_ISO          0x1000
62 #define TD_ENDP         0x0780
63 #define TD_ADDR         0x007f
64
65 #define TD_ENDP_SHIFT 7
66
67 struct usb_td {
68         __be16 status;
69         __be16 length;
70         __be32 buf_ptr;
71         __be16 extra;
72         __be16 reserved;
73 };
74
75 static struct usb_td __iomem *next_bd(struct usb_td __iomem *base,
76                                       struct usb_td __iomem *td,
77                                       u16 status)
78 {
79         if (status & TD_W)
80                 return base;
81         else
82                 return ++td;
83 }
84
85 void fhci_push_dummy_bd(struct endpoint *ep)
86 {
87         if (ep->already_pushed_dummy_bd == false) {
88                 u16 td_status = in_be16(&ep->empty_td->status);
89
90                 out_be32(&ep->empty_td->buf_ptr, DUMMY_BD_BUFFER);
91                 /* get the next TD in the ring */
92                 ep->empty_td = next_bd(ep->td_base, ep->empty_td, td_status);
93                 ep->already_pushed_dummy_bd = true;
94         }
95 }
96
97 /* destroy an USB endpoint */
98 void fhci_ep0_free(struct fhci_usb *usb)
99 {
100         struct endpoint *ep;
101         int size;
102
103         ep = usb->ep0;
104         if (ep) {
105                 if (ep->td_base)
106                         cpm_muram_free(cpm_muram_offset(ep->td_base));
107
108                 if (ep->conf_frame_Q) {
109                         size = cq_howmany(ep->conf_frame_Q);
110                         for (; size; size--) {
111                                 struct packet *pkt = cq_get(ep->conf_frame_Q);
112
113                                 kfree(pkt);
114                         }
115                         cq_delete(ep->conf_frame_Q);
116                 }
117
118                 if (ep->empty_frame_Q) {
119                         size = cq_howmany(ep->empty_frame_Q);
120                         for (; size; size--) {
121                                 struct packet *pkt = cq_get(ep->empty_frame_Q);
122
123                                 kfree(pkt);
124                         }
125                         cq_delete(ep->empty_frame_Q);
126                 }
127
128                 if (ep->dummy_packets_Q) {
129                         size = cq_howmany(ep->dummy_packets_Q);
130                         for (; size; size--) {
131                                 u8 *buff = cq_get(ep->dummy_packets_Q);
132
133                                 kfree(buff);
134                         }
135                         cq_delete(ep->dummy_packets_Q);
136                 }
137
138                 kfree(ep);
139                 usb->ep0 = NULL;
140         }
141 }
142
143 /*
144  * create the endpoint structure
145  *
146  * arguments:
147  * usb          A pointer to the data structure of the USB
148  * data_mem     The data memory partition(BUS)
149  * ring_len     TD ring length
150  */
151 u32 fhci_create_ep(struct fhci_usb *usb, enum fhci_mem_alloc data_mem,
152                            u32 ring_len)
153 {
154         struct endpoint *ep;
155         struct usb_td __iomem *td;
156         unsigned long ep_offset;
157         char *err_for = "enpoint PRAM";
158         int ep_mem_size;
159         u32 i;
160
161         /* we need at least 3 TDs in the ring */
162         if (!(ring_len > 2)) {
163                 fhci_err(usb->fhci, "illegal TD ring length parameters\n");
164                 return -EINVAL;
165         }
166
167         ep = kzalloc(sizeof(*ep), GFP_KERNEL);
168         if (!ep)
169                 return -ENOMEM;
170
171         ep_mem_size = ring_len * sizeof(*td) + sizeof(struct fhci_ep_pram);
172         ep_offset = cpm_muram_alloc(ep_mem_size, 32);
173         if (IS_ERR_VALUE(ep_offset))
174                 goto err;
175         ep->td_base = cpm_muram_addr(ep_offset);
176
177         /* zero all queue pointers */
178         ep->conf_frame_Q = cq_new(ring_len + 2);
179         ep->empty_frame_Q = cq_new(ring_len + 2);
180         ep->dummy_packets_Q = cq_new(ring_len + 2);
181         if (!ep->conf_frame_Q || !ep->empty_frame_Q || !ep->dummy_packets_Q) {
182                 err_for = "frame_queues";
183                 goto err;
184         }
185
186         for (i = 0; i < (ring_len + 1); i++) {
187                 struct packet *pkt;
188                 u8 *buff;
189
190                 pkt = kmalloc(sizeof(*pkt), GFP_KERNEL);
191                 if (!pkt) {
192                         err_for = "frame";
193                         goto err;
194                 }
195
196                 buff = kmalloc(1028 * sizeof(*buff), GFP_KERNEL);
197                 if (!buff) {
198                         kfree(pkt);
199                         err_for = "buffer";
200                         goto err;
201                 }
202                 cq_put(ep->empty_frame_Q, pkt);
203                 cq_put(ep->dummy_packets_Q, buff);
204         }
205
206         /* we put the endpoint parameter RAM right behind the TD ring */
207         ep->ep_pram_ptr = (void __iomem *)ep->td_base + sizeof(*td) * ring_len;
208
209         ep->conf_td = ep->td_base;
210         ep->empty_td = ep->td_base;
211
212         ep->already_pushed_dummy_bd = false;
213
214         /* initialize tds */
215         td = ep->td_base;
216         for (i = 0; i < ring_len; i++) {
217                 out_be32(&td->buf_ptr, 0);
218                 out_be16(&td->status, 0);
219                 out_be16(&td->length, 0);
220                 out_be16(&td->extra, 0);
221                 td++;
222         }
223         td--;
224         out_be16(&td->status, TD_W); /* for last TD set Wrap bit */
225         out_be16(&td->length, 0);
226
227         /* endpoint structure has been created */
228         usb->ep0 = ep;
229
230         return 0;
231 err:
232         fhci_ep0_free(usb);
233         kfree(ep);
234         fhci_err(usb->fhci, "no memory for the %s\n", err_for);
235         return -ENOMEM;
236 }
237
238 /*
239  * initialize the endpoint register according to the given parameters
240  *
241  * artuments:
242  * usb          A pointer to the data strucutre of the USB
243  * ep           A pointer to the endpoint structre
244  * data_mem     The data memory partition(BUS)
245  */
246 void fhci_init_ep_registers(struct fhci_usb *usb, struct endpoint *ep,
247                             enum fhci_mem_alloc data_mem)
248 {
249         u8 rt;
250
251         /* set the endpoint registers according to the endpoint */
252         out_be16(&usb->fhci->regs->usb_ep[0],
253                  USB_TRANS_CTR | USB_EP_MF | USB_EP_RTE);
254         out_be16(&usb->fhci->pram->ep_ptr[0],
255                  cpm_muram_offset(ep->ep_pram_ptr));
256
257         rt = (BUS_MODE_BO_BE | BUS_MODE_GBL);
258 #ifdef MULTI_DATA_BUS
259         if (data_mem == MEM_SECONDARY)
260                 rt |= BUS_MODE_DTB;
261 #endif
262         out_8(&ep->ep_pram_ptr->rx_func_code, rt);
263         out_8(&ep->ep_pram_ptr->tx_func_code, rt);
264         out_be16(&ep->ep_pram_ptr->rx_buff_len, 1028);
265         out_be16(&ep->ep_pram_ptr->rx_base, 0);
266         out_be16(&ep->ep_pram_ptr->tx_base, cpm_muram_offset(ep->td_base));
267         out_be16(&ep->ep_pram_ptr->rx_bd_ptr, 0);
268         out_be16(&ep->ep_pram_ptr->tx_bd_ptr, cpm_muram_offset(ep->td_base));
269         out_be32(&ep->ep_pram_ptr->tx_state, 0);
270 }
271
272 /*
273  * Collect the submitted frames and inform the application about them
274  * It is also prepearing the TDs for new frames. If the Tx interrupts
275  * are diabled, the application should call that routine to get
276  * confirmation about the submitted frames. Otherwise, the routine is
277  * called frome the interrupt service routine during the Tx interrupt.
278  * In that case the application is informed by calling the application
279  * specific 'fhci_transaction_confirm' routine
280  */
281 static void fhci_td_transaction_confirm(struct fhci_usb *usb)
282 {
283         struct endpoint *ep = usb->ep0;
284         struct packet *pkt;
285         struct usb_td __iomem *td;
286         u16 extra_data;
287         u16 td_status;
288         u16 td_length;
289         u32 buf;
290
291         /*
292          * collect transmitted BDs from the chip. The routine clears all BDs
293          * with R bit = 0 and the pointer to data buffer is not NULL, that is
294          * BDs which point to the transmitted data buffer
295          */
296         while (1) {
297                 td = ep->conf_td;
298                 td_status = in_be16(&td->status);
299                 td_length = in_be16(&td->length);
300                 buf = in_be32(&td->buf_ptr);
301                 extra_data = in_be16(&td->extra);
302
303                 /* check if the TD is empty */
304                 if (!(!(td_status & TD_R) && ((td_status & ~TD_W) || buf)))
305                         break;
306                 /* check if it is a dummy buffer */
307                 else if ((buf == DUMMY_BD_BUFFER) && !(td_status & ~TD_W))
308                         break;
309
310                 /* mark TD as empty */
311                 clrbits16(&td->status, ~TD_W);
312                 out_be16(&td->length, 0);
313                 out_be32(&td->buf_ptr, 0);
314                 out_be16(&td->extra, 0);
315                 /* advance the TD pointer */
316                 ep->conf_td = next_bd(ep->td_base, ep->conf_td, td_status);
317
318                 /* check if it is a dummy buffer(type2) */
319                 if ((buf == DUMMY2_BD_BUFFER) && !(td_status & ~TD_W))
320                         continue;
321
322                 pkt = cq_get(ep->conf_frame_Q);
323                 if (!pkt)
324                         fhci_err(usb->fhci, "no frame to confirm\n");
325
326                 if (td_status & TD_ERRORS) {
327                         if (td_status & TD_RXER) {
328                                 if (td_status & TD_CR)
329                                         pkt->status = USB_TD_RX_ER_CRC;
330                                 else if (td_status & TD_AB)
331                                         pkt->status = USB_TD_RX_ER_BITSTUFF;
332                                 else if (td_status & TD_OV)
333                                         pkt->status = USB_TD_RX_ER_OVERUN;
334                                 else if (td_status & TD_BOV)
335                                         pkt->status = USB_TD_RX_DATA_OVERUN;
336                                 else if (td_status & TD_NO)
337                                         pkt->status = USB_TD_RX_ER_NONOCT;
338                                 else
339                                         fhci_err(usb->fhci, "illegal error "
340                                                  "occured\n");
341                         } else if (td_status & TD_NAK)
342                                 pkt->status = USB_TD_TX_ER_NAK;
343                         else if (td_status & TD_TO)
344                                 pkt->status = USB_TD_TX_ER_TIMEOUT;
345                         else if (td_status & TD_UN)
346                                 pkt->status = USB_TD_TX_ER_UNDERUN;
347                         else if (td_status & TD_STAL)
348                                 pkt->status = USB_TD_TX_ER_STALL;
349                         else
350                                 fhci_err(usb->fhci, "illegal error occured\n");
351                 } else if ((extra_data & TD_TOK_IN) &&
352                                 pkt->len > td_length - CRC_SIZE) {
353                         pkt->status = USB_TD_RX_DATA_UNDERUN;
354                 }
355
356                 if (extra_data & TD_TOK_IN)
357                         pkt->len = td_length - CRC_SIZE;
358                 else if (pkt->info & PKT_ZLP)
359                         pkt->len = 0;
360                 else
361                         pkt->len = td_length;
362
363                 fhci_transaction_confirm(usb, pkt);
364         }
365 }
366
367 /*
368  * Submitting a data frame to a specified endpoint of a USB device
369  * The frame is put in the driver's transmit queue for this endpoint
370  *
371  * Arguments:
372  * usb          A pointer to the USB structure
373  * pkt          A pointer to the user frame structure
374  * trans_type   Transaction tyep - IN,OUT or SETUP
375  * dest_addr    Device address - 0~127
376  * dest_ep      Endpoint number of the device - 0~16
377  * trans_mode   Pipe type - ISO,Interrupt,bulk or control
378  * dest_speed   USB speed - Low speed or FULL speed
379  * data_toggle  Data sequence toggle - 0 or 1
380  */
381 u32 fhci_host_transaction(struct fhci_usb *usb,
382                           struct packet *pkt,
383                           enum fhci_ta_type trans_type,
384                           u8 dest_addr,
385                           u8 dest_ep,
386                           enum fhci_tf_mode trans_mode,
387                           enum fhci_speed dest_speed, u8 data_toggle)
388 {
389         struct endpoint *ep = usb->ep0;
390         struct usb_td __iomem *td;
391         u16 extra_data;
392         u16 td_status;
393
394         fhci_usb_disable_interrupt(usb);
395         /* start from the next BD that should be filled */
396         td = ep->empty_td;
397         td_status = in_be16(&td->status);
398
399         if (td_status & TD_R && in_be16(&td->length)) {
400                 /* if the TD is not free */
401                 fhci_usb_enable_interrupt(usb);
402                 return -1;
403         }
404
405         /* get the next TD in the ring */
406         ep->empty_td = next_bd(ep->td_base, ep->empty_td, td_status);
407         fhci_usb_enable_interrupt(usb);
408         pkt->priv_data = td;
409         out_be32(&td->buf_ptr, virt_to_phys(pkt->data));
410         /* sets up transaction parameters - addr,endp,dir,and type */
411         extra_data = (dest_ep << TD_ENDP_SHIFT) | dest_addr;
412         switch (trans_type) {
413         case FHCI_TA_IN:
414                 extra_data |= TD_TOK_IN;
415                 break;
416         case FHCI_TA_OUT:
417                 extra_data |= TD_TOK_OUT;
418                 break;
419         case FHCI_TA_SETUP:
420                 extra_data |= TD_TOK_SETUP;
421                 break;
422         }
423         if (trans_mode == FHCI_TF_ISO)
424                 extra_data |= TD_ISO;
425         out_be16(&td->extra, extra_data);
426
427         /* sets up the buffer descriptor */
428         td_status = ((td_status & TD_W) | TD_R | TD_L | TD_I | TD_CNF);
429         if (!(pkt->info & PKT_NO_CRC))
430                 td_status |= TD_TC;
431
432         switch (trans_type) {
433         case FHCI_TA_IN:
434                 if (data_toggle)
435                         pkt->info |= PKT_PID_DATA1;
436                 else
437                         pkt->info |= PKT_PID_DATA0;
438                 break;
439         default:
440                 if (data_toggle) {
441                         td_status |= TD_PID_DATA1;
442                         pkt->info |= PKT_PID_DATA1;
443                 } else {
444                         td_status |= TD_PID_DATA0;
445                         pkt->info |= PKT_PID_DATA0;
446                 }
447                 break;
448         }
449
450         if ((dest_speed == FHCI_LOW_SPEED) &&
451             (usb->port_status == FHCI_PORT_FULL))
452                 td_status |= TD_LSP;
453
454         out_be16(&td->status, td_status);
455
456         /* set up buffer length */
457         if (trans_type == FHCI_TA_IN)
458                 out_be16(&td->length, pkt->len + CRC_SIZE);
459         else
460                 out_be16(&td->length, pkt->len);
461
462         /* put the frame to the confirmation queue */
463         cq_put(ep->conf_frame_Q, pkt);
464
465         if (cq_howmany(ep->conf_frame_Q) == 1)
466                 out_8(&usb->fhci->regs->usb_comm, USB_CMD_STR_FIFO);
467
468         return 0;
469 }
470
471 /* Reset the Tx BD ring */
472 void fhci_flush_bds(struct fhci_usb *usb)
473 {
474         u16 extra_data;
475         u16 td_status;
476         u32 buf;
477         struct usb_td __iomem *td;
478         struct endpoint *ep = usb->ep0;
479
480         td = ep->td_base;
481         while (1) {
482                 td_status = in_be16(&td->status);
483                 buf = in_be32(&td->buf_ptr);
484                 extra_data = in_be16(&td->extra);
485
486                 /* if the TD is not empty - we'll confirm it as Timeout */
487                 if (td_status & TD_R)
488                         out_be16(&td->status, (td_status & ~TD_R) | TD_TO);
489                 /* if this TD is dummy - let's skip this TD */
490                 else if (in_be32(&td->buf_ptr) == DUMMY_BD_BUFFER)
491                         out_be32(&td->buf_ptr, DUMMY2_BD_BUFFER);
492                 /* if this is the last TD - break */
493                 if (td_status & TD_W)
494                         break;
495
496                 td++;
497         }
498
499         fhci_td_transaction_confirm(usb);
500
501         td = ep->td_base;
502         do {
503                 out_be16(&td->status, 0);
504                 out_be16(&td->length, 0);
505                 out_be32(&td->buf_ptr, 0);
506                 out_be16(&td->extra, 0);
507                 td++;
508         } while (!(in_be16(&td->status) & TD_W));
509         out_be16(&td->status, TD_W); /* for last TD set Wrap bit */
510         out_be16(&td->length, 0);
511         out_be32(&td->buf_ptr, 0);
512         out_be16(&td->extra, 0);
513
514         out_be16(&ep->ep_pram_ptr->tx_bd_ptr,
515                  in_be16(&ep->ep_pram_ptr->tx_base));
516         out_be32(&ep->ep_pram_ptr->tx_state, 0);
517         out_be16(&ep->ep_pram_ptr->tx_cnt, 0);
518         ep->empty_td = ep->td_base;
519         ep->conf_td = ep->td_base;
520 }
521
522 /*
523  * Flush all transmitted packets from TDs in the actual frame.
524  * This routine is called when something wrong with the controller and
525  * we want to get rid of the actual frame and start again next frame
526  */
527 void fhci_flush_actual_frame(struct fhci_usb *usb)
528 {
529         u8 mode;
530         u16 tb_ptr;
531         u16 extra_data;
532         u16 td_status;
533         u32 buf_ptr;
534         struct usb_td __iomem *td;
535         struct endpoint *ep = usb->ep0;
536
537         /* disable the USB controller */
538         mode = in_8(&usb->fhci->regs->usb_mod);
539         out_8(&usb->fhci->regs->usb_mod, mode & ~USB_MODE_EN);
540
541         tb_ptr = in_be16(&ep->ep_pram_ptr->tx_bd_ptr);
542         td = cpm_muram_addr(tb_ptr);
543         td_status = in_be16(&td->status);
544         buf_ptr = in_be32(&td->buf_ptr);
545         extra_data = in_be16(&td->extra);
546         do {
547                 if (td_status & TD_R) {
548                         out_be16(&td->status, (td_status & ~TD_R) | TD_TO);
549                 } else {
550                         out_be32(&td->buf_ptr, 0);
551                         ep->already_pushed_dummy_bd = false;
552                         break;
553                 }
554
555                 /* advance the TD pointer */
556                 td = next_bd(ep->td_base, td, td_status);
557                 td_status = in_be16(&td->status);
558                 buf_ptr = in_be32(&td->buf_ptr);
559                 extra_data = in_be16(&td->extra);
560         } while ((td_status & TD_R) || buf_ptr);
561
562         fhci_td_transaction_confirm(usb);
563
564         out_be16(&ep->ep_pram_ptr->tx_bd_ptr,
565                  in_be16(&ep->ep_pram_ptr->tx_base));
566         out_be32(&ep->ep_pram_ptr->tx_state, 0);
567         out_be16(&ep->ep_pram_ptr->tx_cnt, 0);
568         ep->empty_td = ep->td_base;
569         ep->conf_td = ep->td_base;
570
571         usb->actual_frame->frame_status = FRAME_TIMER_END_TRANSMISSION;
572
573         /* reset the event register */
574         out_be16(&usb->fhci->regs->usb_event, 0xffff);
575         /* enable the USB controller */
576         out_8(&usb->fhci->regs->usb_mod, mode | USB_MODE_EN);
577 }
578
579 /* handles Tx confirm and Tx error interrupt */
580 void fhci_tx_conf_interrupt(struct fhci_usb *usb)
581 {
582         fhci_td_transaction_confirm(usb);
583
584         /*
585          * Schedule another transaction to this frame only if we have
586          * already confirmed all transaction in the frame.
587          */
588         if (((fhci_get_sof_timer_count(usb) < usb->max_frame_usage) ||
589              (usb->actual_frame->frame_status & FRAME_END_TRANSMISSION)) &&
590             (list_empty(&usb->actual_frame->tds_list)))
591                 fhci_schedule_transactions(usb);
592 }
593
594 void fhci_host_transmit_actual_frame(struct fhci_usb *usb)
595 {
596         u16 tb_ptr;
597         u16 td_status;
598         struct usb_td __iomem *td;
599         struct endpoint *ep = usb->ep0;
600
601         tb_ptr = in_be16(&ep->ep_pram_ptr->tx_bd_ptr);
602         td = cpm_muram_addr(tb_ptr);
603
604         if (in_be32(&td->buf_ptr) == DUMMY_BD_BUFFER) {
605                 struct usb_td __iomem *old_td = td;
606
607                 ep->already_pushed_dummy_bd = false;
608                 td_status = in_be16(&td->status);
609                 /* gets the next TD in the ring */
610                 td = next_bd(ep->td_base, td, td_status);
611                 tb_ptr = cpm_muram_offset(td);
612                 out_be16(&ep->ep_pram_ptr->tx_bd_ptr, tb_ptr);
613
614                 /* start transmit only if we have something in the TDs */
615                 if (in_be16(&td->status) & TD_R)
616                         out_8(&usb->fhci->regs->usb_comm, USB_CMD_STR_FIFO);
617
618                 if (in_be32(&ep->conf_td->buf_ptr) == DUMMY_BD_BUFFER) {
619                         out_be32(&old_td->buf_ptr, 0);
620                         ep->conf_td = next_bd(ep->td_base, ep->conf_td,
621                                               td_status);
622                 } else {
623                         out_be32(&old_td->buf_ptr, DUMMY2_BD_BUFFER);
624                 }
625         }
626 }