Ansify some remaining function definitions in the kernel.
[dragonfly.git] / sys / dev / atm / hfa / fore_output.c
1 /*
2  *
3  * ===================================
4  * HARP  |  Host ATM Research Platform
5  * ===================================
6  *
7  *
8  * This Host ATM Research Platform ("HARP") file (the "Software") is
9  * made available by Network Computing Services, Inc. ("NetworkCS")
10  * "AS IS".  NetworkCS does not provide maintenance, improvements or
11  * support of any kind.
12  *
13  * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED,
14  * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
15  * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE
16  * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE.
17  * In no event shall NetworkCS be responsible for any damages, including
18  * but not limited to consequential damages, arising from or relating to
19  * any use of the Software or related support.
20  *
21  * Copyright 1994-1998 Network Computing Services, Inc.
22  *
23  * Copies of this Software may be made, however, the above copyright
24  * notice must be reproduced on all copies.
25  *
26  *      @(#) $FreeBSD: src/sys/dev/hfa/fore_output.c,v 1.5 2000/01/15 21:01:04 mks Exp $
27  *      @(#) $DragonFly: src/sys/dev/atm/hfa/fore_output.c,v 1.6 2008/03/01 22:03:13 swildner Exp $
28  */
29
30 /*
31  * FORE Systems 200-Series Adapter Support
32  * ---------------------------------------
33  *
34  * PDU output processing
35  *
36  */
37
38 #include "fore_include.h"
39
40 /*
41  * Local functions
42  */
43 static KBuffer *        fore_xmit_segment (Fore_unit *, KBuffer *,
44                                 H_xmit_queue *, int *, int *);
45 static void             fore_seg_dma_free (H_xmit_queue *, KBuffer *, int);
46
47
48 /*
49  * Output a PDU
50  * 
51  * This function is called via the common driver code after receiving a
52  * stack *_DATA* command.  The common code has already validated most of
53  * the request so we just need to check a few more Fore-specific details.
54  * Then we just build a transmit descriptor request for the PDU and issue 
55  * the command to the CP.  
56  *
57  * Arguments:
58  *      cup     pointer to device common unit
59  *      cvp     pointer to common VCC entry
60  *      m       pointer to output PDU buffer chain head
61  *
62  * Returns:
63  *      none
64  *
65  */
66 void
67 fore_output(Cmn_unit *cup, Cmn_vcc *cvp, KBuffer *m)
68 {
69         Fore_unit       *fup = (Fore_unit *)cup;
70         Fore_vcc        *fvp = (Fore_vcc *)cvp;
71         struct vccb     *vcp;
72         H_xmit_queue    *hxp;
73         Xmit_queue      *cqp;
74         Xmit_descr      *xdp;
75         int             retry, nsegs, pdulen;
76
77 #ifdef DIAGNOSTIC
78         if (atm_dev_print)
79                 atm_dev_pdu_print(cup, cvp, m, "fore_output");
80 #endif
81
82         vcp = fvp->fv_connvc->cvc_vcc;
83
84         /*
85          * If we're still waiting for activation to finish, delay for
86          * a little while before we toss the PDU
87          */
88         if (fvp->fv_state == CVS_INITED) {
89                 retry = 3;
90                 while (retry-- && (fvp->fv_state == CVS_INITED))
91                         DELAY(1000);
92                 if (fvp->fv_state != CVS_ACTIVE) {
93                         /*
94                          * Activation still hasn't finished, oh well....
95                          */
96                         fup->fu_stats->st_drv.drv_xm_notact++;
97                         vcp->vc_oerrors++;
98                         if (vcp->vc_nif)
99                                 vcp->vc_nif->nif_if.if_oerrors++;
100                         KB_FREEALL(m);
101                         return;
102                 }
103         }
104
105         /*
106          * Queue PDU at end of transmit queue
107          *
108          * If queue is full we'll delay a bit before tossing the PDU
109          */
110         crit_enter();
111         hxp = fup->fu_xmit_tail;
112         if (!((*hxp->hxq_status) & QSTAT_FREE)) {
113
114                 fup->fu_stats->st_drv.drv_xm_full++;
115                 retry = 3;
116                 do {
117                         DELAY(1000);
118
119                         DEVICE_LOCK((Cmn_unit *)fup);
120                         fore_xmit_drain(fup);
121                         DEVICE_UNLOCK((Cmn_unit *)fup);
122
123                 } while (--retry && (!((*hxp->hxq_status) & QSTAT_FREE)));
124
125                 if (!((*hxp->hxq_status) & QSTAT_FREE)) {
126                         /*
127                          * Queue is still full, bye-bye PDU
128                          */
129                         fup->fu_pif.pif_oerrors++;
130                         vcp->vc_oerrors++;
131                         if (vcp->vc_nif)
132                                 vcp->vc_nif->nif_if.if_oerrors++;
133                         KB_FREEALL(m);
134                         crit_exit();
135                         return;
136                 }
137         }
138
139         /*
140          * We've got a free transmit queue entry
141          */
142
143         /*
144          * Now build the transmit segment descriptors for this PDU
145          */
146         m = fore_xmit_segment(fup, m, hxp, &nsegs, &pdulen);
147         if (m == NULL) {
148                 /*
149                  * The build failed, buffer chain has been freed
150                  */
151                 vcp->vc_oerrors++;
152                 if (vcp->vc_nif)
153                         vcp->vc_nif->nif_if.if_oerrors++;
154                 crit_exit();
155                 return;
156         }
157
158         /*
159          * Set up the descriptor header
160          */
161         xdp = hxp->hxq_descr;
162         xdp->xd_cell_hdr = ATM_HDR_SET(vcp->vc_vpi, vcp->vc_vci, 0, 0);
163         xdp->xd_spec = XDS_SET_SPEC(0, fvp->fv_aal, nsegs, pdulen);
164         xdp->xd_rate = FORE_DEF_RATE;
165
166         /*
167          * Everything is ready to go, so officially claim the host queue
168          * entry and setup the CP-resident queue entry.  The CP will grab
169          * the PDU when the descriptor pointer is set.
170          */
171         fup->fu_xmit_tail = hxp->hxq_next;
172         hxp->hxq_buf = m;
173         hxp->hxq_vcc = fvp;
174         (*hxp->hxq_status) = QSTAT_PENDING;
175         cqp = hxp->hxq_cpelem;
176         cqp->cq_descr = (CP_dma)
177                 CP_WRITE((u_long)hxp->hxq_descr_dma | XMIT_SEGS_TO_BLKS(nsegs));
178
179         crit_exit();
180
181         /*
182          * See if there are any completed queue entries
183          */
184         DEVICE_LOCK((Cmn_unit *)fup);
185         fore_xmit_drain(fup);
186         DEVICE_UNLOCK((Cmn_unit *)fup);
187 }
188
189
190 /*
191  * Build Transmit Segment Descriptors
192  * 
193  * This function will take a supplied buffer chain of data to be transmitted
194  * and build the transmit segment descriptors for the data.  This will include 
195  * the dreaded operation of ensuring that the data for each transmit segment
196  * is full-word aligned and (except for the last segment) is an integral number
197  * of words in length.  If the data isn't already aligned and sized as
198  * required, then the data must be shifted (copied) into place - a sure
199  * performance killer.  Note that we rely on the fact that all buffer data
200  * areas are allocated with (at least) full-word alignments/lengths.
201  *
202  * If any errors are encountered, the buffer chain will be freed.
203  * 
204  * Arguments:
205  *      fup     pointer to device unit
206  *      m       pointer to output PDU buffer chain head
207  *      hxp     pointer to host transmit queue entry
208  *      segp    pointer to return the number of transmit segments
209  *      lenp    pointer to return the pdu length
210  *
211  * Returns:
212  *      m       build successful, pointer to (possibly new) head of 
213  *              output PDU buffer chain
214  *      NULL    build failed, buffer chain freed
215  *
216  */
217 static KBuffer *
218 fore_xmit_segment(Fore_unit *fup, KBuffer *m, H_xmit_queue *hxp, int *segp,
219                   int *lenp)
220 {
221         Xmit_descr      *xdp = hxp->hxq_descr;
222         Xmit_seg_descr  *xsp;
223         H_dma           *sdmap;
224         KBuffer         *m0, *m1, *mprev;
225         caddr_t         cp, bfr;
226         void            *dma;
227         int             pdulen, nsegs, len, align;
228         int             compressed = 0;
229
230         m0 = m;
231
232 retry:
233         xsp = xdp->xd_seg;
234         sdmap = hxp->hxq_dma;
235         mprev = NULL;
236         pdulen = 0;
237         nsegs = 0;
238
239         /*
240          * Loop thru each buffer in the chain, performing the necessary
241          * data positioning and then building a segment descriptor for
242          * that data.
243          */
244         while (m) {
245                 /*
246                  * Get rid of any zero-length buffers
247                  */
248                 if (KB_LEN(m) == 0) {
249                         if (mprev) {
250                                 KB_UNLINK(m, mprev, m1);
251                         } else {
252                                 KB_UNLINKHEAD(m, m1);
253                                 m0 = m1;
254                         }
255                         m = m1;
256                         continue;
257                 }
258
259                 /*
260                  * Make sure we don't try to use too many segments
261                  */
262                 if (nsegs >= XMIT_MAX_SEGS) {
263                         /*
264                          * First, free already allocated DMA addresses
265                          */
266                         fore_seg_dma_free(hxp, m0, nsegs);
267
268                         /*
269                          * Try to compress buffer chain (but only once)
270                          */
271                         if (compressed) {
272                                 KB_FREEALL(m0);
273                                 return (NULL);
274                         }
275
276                         fup->fu_stats->st_drv.drv_xm_maxpdu++;
277
278                         m = atm_dev_compress(m0);
279                         if (m == NULL) {
280                                 return (NULL);
281                         }
282
283                         /*
284                          * Build segment descriptors for compressed chain
285                          */
286                         m0 = m;
287                         compressed = 1;
288                         goto retry;
289                 }
290
291                 /*
292                  * Get start of data onto full-word alignment
293                  */
294                 KB_DATASTART(m, cp, caddr_t);
295                 if ((align = ((u_int)cp) & (XMIT_SEG_ALIGN - 1)) != 0) {
296                         /*
297                          * Gotta slide the data up
298                          */
299                         fup->fu_stats->st_drv.drv_xm_segnoal++;
300                         bfr = cp - align;
301                         KM_COPY(cp, bfr, KB_LEN(m));
302                         KB_HEADMOVE(m, -align);
303                 } else {
304                         /*
305                          * Data already aligned
306                          */
307                         bfr = cp;
308                 }
309
310                 /*
311                  * Now work on getting the data length correct
312                  */
313                 len = KB_LEN(m);
314                 while ((align = (len & (XMIT_SEG_ALIGN - 1))) &&
315                        (m1 = KB_NEXT(m))) {
316
317                         /*
318                          * Have to move some data from following buffer(s)
319                          * to word-fill this buffer
320                          */
321                         int     ncopy = MIN(XMIT_SEG_ALIGN - align, KB_LEN(m1));
322
323                         if (ncopy) {
324                                 /*
325                                  * Move data to current buffer
326                                  */
327                                 caddr_t         dest;
328
329                                 fup->fu_stats->st_drv.drv_xm_seglen++;
330                                 KB_DATASTART(m1, cp, caddr_t);
331                                 dest = bfr + len;
332                                 KB_HEADADJ(m1, -ncopy);
333                                 KB_TAILADJ(m, ncopy);
334                                 len += ncopy;
335                                 while (ncopy--) {
336                                         *dest++ = *cp++;
337                                 }
338                         }
339
340                         /*
341                          * If we've drained the buffer, free it
342                          */
343                         if (KB_LEN(m1) == 0) {
344                                 KBuffer         *m2;
345
346                                 KB_UNLINK(m1, m, m2);
347                         }
348                 }
349
350                 /*
351                  * Finally, build the segment descriptor
352                  */
353
354                 /*
355                  * Round last segment to fullword length (if needed)
356                  */
357                 if (len & (XMIT_SEG_ALIGN - 1))
358                         xsp->xsd_len = KB_LEN(m) =
359                                 (len + XMIT_SEG_ALIGN) & ~(XMIT_SEG_ALIGN - 1);
360                 else
361                         xsp->xsd_len = KB_LEN(m) = len;
362
363                 /*
364                  * Get a DMA address for the data
365                  */
366                 dma = DMA_GET_ADDR(bfr, xsp->xsd_len, XMIT_SEG_ALIGN, 0);
367                 if (dma == NULL) {
368                         fup->fu_stats->st_drv.drv_xm_segdma++;
369                         fore_seg_dma_free(hxp, m0, nsegs);
370                         KB_FREEALL(m0);
371                         return (NULL);
372                 }
373
374                 /*
375                  * Now we're really ready to call it a segment
376                  */
377                 *sdmap++ = xsp->xsd_buffer = (H_dma) dma;
378
379                 /*
380                  * Bump counters and get ready for next buffer
381                  */
382                 pdulen += len;
383                 nsegs++;
384                 xsp++;
385                 mprev = m;
386                 m = KB_NEXT(m);
387         }
388
389         /*
390          * Validate PDU length
391          */
392         if (pdulen > XMIT_MAX_PDULEN) {
393                 fup->fu_stats->st_drv.drv_xm_maxpdu++;
394                 fore_seg_dma_free(hxp, m0, nsegs);
395                 KB_FREEALL(m0);
396                 return (NULL);
397         }
398
399         /*
400          * Return the good news to the caller
401          */
402         *segp = nsegs;
403         *lenp = pdulen;
404
405         return (m0);
406 }
407
408
409 /*
410  * Free Transmit Segment Queue DMA addresses
411  * 
412  * Arguments:
413  *      hxp     pointer to host transmit queue entry
414  *      m0      pointer to output PDU buffer chain head
415  *      nsegs   number of processed transmit segments
416  *
417  * Returns:
418  *      none
419  *
420  */
421 static void
422 fore_seg_dma_free(H_xmit_queue *hxp, KBuffer *m0, int nsegs)
423 {
424         KBuffer         *m = m0;
425         H_dma           *sdmap = hxp->hxq_dma;
426         caddr_t         cp;
427         int             i;
428
429         for (i = 0; i < nsegs; i++) {
430                 KB_DATASTART(m, cp, caddr_t);
431                 DMA_FREE_ADDR(cp, *sdmap, KB_LEN(m), 0);
432                 m = KB_NEXT(m);
433                 sdmap++;
434         }
435 }
436