Ansify some remaining function definitions in the kernel.
[dragonfly.git] / sys / dev / atm / hfa / fore_command.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_command.c,v 1.6 1999/08/28 00:41:49 peter Exp $
27  *      @(#) $DragonFly: src/sys/dev/atm/hfa/fore_command.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  * Command queue management
35  *
36  */
37
38 #include "fore_include.h"
39
40 /*
41  * Local variables
42  */
43 static struct t_atm_cause       fore_cause = {
44         T_ATM_ITU_CODING,
45         T_ATM_LOC_USER,
46         T_ATM_CAUSE_TEMPORARY_FAILURE,
47         {0, 0, 0, 0}
48 };
49
50
51 /*
52  * Allocate Command Queue Data Structures
53  *
54  * Arguments:
55  *      fup             pointer to device unit structure
56  *
57  * Returns:
58  *      0               allocations successful
59  *      else            allocation failed
60  */
61 int
62 fore_cmd_allocate(Fore_unit *fup)
63 {
64         caddr_t         memp;
65
66         /*
67          * Allocate non-cacheable memory for command status words
68          */
69         memp = atm_dev_alloc(sizeof(Q_status) * CMD_QUELEN,
70                         QSTAT_ALIGN, ATM_DEV_NONCACHE);
71         if (memp == NULL) {
72                 return (1);
73         }
74         fup->fu_cmd_stat = (Q_status *) memp;
75
76         memp = DMA_GET_ADDR(fup->fu_cmd_stat, sizeof(Q_status) * CMD_QUELEN,
77                         QSTAT_ALIGN, ATM_DEV_NONCACHE);
78         if (memp == NULL) {
79                 return (1);
80         }
81         fup->fu_cmd_statd = (Q_status *) memp;
82
83         /*
84          * Allocate memory for statistics buffer
85          */
86         memp = atm_dev_alloc(sizeof(Fore_stats), FORE_STATS_ALIGN, 0);
87         if (memp == NULL) {
88                 return (1);
89         }
90         fup->fu_stats = (Fore_stats *) memp;
91
92         /*
93          * Allocate memory for PROM buffer
94          */
95         memp = atm_dev_alloc(sizeof(Fore_prom), FORE_PROM_ALIGN, 0);
96         if (memp == NULL) {
97                 return (1);
98         }
99         fup->fu_prom = (Fore_prom *) memp;
100
101         return (0);
102 }
103
104
105 /*
106  * Command Queue Initialization
107  *
108  * Allocate and initialize the host-resident command queue structures
109  * and then initialize the CP-resident queue structures.
110  * 
111  * Called at interrupt level.
112  *
113  * Arguments:
114  *      fup             pointer to device unit structure
115  *
116  * Returns:
117  *      none
118  */
119 void
120 fore_cmd_initialize(Fore_unit *fup)
121 {
122         Aali            *aap = fup->fu_aali;
123         Cmd_queue       *cqp;
124         H_cmd_queue     *hcp;
125         Q_status        *qsp;
126         Q_status        *qsp_dma;
127         int             i;
128
129         /*
130          * Point to CP-resident command queue
131          */
132         cqp = (Cmd_queue *)(fup->fu_ram + CP_READ(aap->aali_cmd_q));
133
134         /*
135          * Point to host-resident command queue structures
136          */
137         hcp = fup->fu_cmd_q;
138         qsp = fup->fu_cmd_stat;
139         qsp_dma = fup->fu_cmd_statd;
140
141         /*
142          * Loop thru all queue entries and do whatever needs doing
143          */
144         for (i = 0; i < CMD_QUELEN; i++) {
145
146                 /*
147                  * Set queue status word to free
148                  */
149                 *qsp = QSTAT_FREE;
150
151                 /*
152                  * Set up host queue entry and link into ring
153                  */
154                 hcp->hcq_cpelem = cqp;
155                 hcp->hcq_status = qsp;
156                 if (i == (CMD_QUELEN - 1))
157                         hcp->hcq_next = fup->fu_cmd_q;
158                 else
159                         hcp->hcq_next = hcp + 1;
160
161                 /*
162                  * Now let the CP into the game
163                  */
164                 cqp->cmdq_status = (CP_dma) CP_WRITE(qsp_dma);
165
166                 /*
167                  * Bump all queue pointers
168                  */
169                 hcp++;
170                 qsp++;
171                 qsp_dma++;
172                 cqp++;
173         }
174
175         /*
176          * Initialize queue pointers
177          */
178         fup->fu_cmd_head = fup->fu_cmd_tail = fup->fu_cmd_q;
179
180         return;
181 }
182
183
184 /*
185  * Drain Command Queue
186  *
187  * This function will process and free all completed entries at the head 
188  * of the command queue. 
189  *
190  * May be called in interrupt state.  
191  * Must be called with interrupts locked out.
192  *
193  * Arguments:
194  *      fup             pointer to device unit structure
195  *
196  * Returns:
197  *      none
198  */
199 void
200 fore_cmd_drain(Fore_unit *fup)
201 {
202         H_cmd_queue     *hcp;
203         Fore_vcc        *fvp;
204
205         /*
206          * Process each completed entry
207          */
208         while (*fup->fu_cmd_head->hcq_status & QSTAT_COMPLETED) {
209
210                 hcp = fup->fu_cmd_head;
211
212                 /*
213                  * Process command completion
214                  */
215                 switch (hcp->hcq_code) {
216
217                 case CMD_ACT_VCCIN:
218                 case CMD_ACT_VCCOUT:
219                         fvp = hcp->hcq_arg;
220                         if (*hcp->hcq_status & QSTAT_ERROR) {
221                                 /*
222                                  * VCC activation failed - just abort vcc
223                                  */
224                                 if (fvp)
225                                         atm_cm_abort(fvp->fv_connvc,
226                                                 &fore_cause);
227                                 fup->fu_pif.pif_cmderrors++;
228                         } else {
229                                 /*
230                                  * Successful VCC activation
231                                  */
232                                 if (fvp) {
233                                         fvp->fv_state = CVS_ACTIVE;
234                                         fup->fu_open_vcc++;
235                                 }
236                         }
237                         break;
238
239                 case CMD_DACT_VCCIN:
240                 case CMD_DACT_VCCOUT:
241                         fvp = hcp->hcq_arg;
242                         if (*hcp->hcq_status & QSTAT_ERROR) {
243                                 /*
244                                  * VCC dactivation failed - whine
245                                  */
246                                 log(LOG_ERR, 
247                                    "fore_cmd_drain: DACT failed, vcc=(%d,%d)\n",
248                                         fvp->fv_connvc->cvc_vcc->vc_vpi,
249                                         fvp->fv_connvc->cvc_vcc->vc_vci);
250                                 fup->fu_pif.pif_cmderrors++;
251                         } else {
252                                 /*
253                                  * Successful VCC dactivation - so what?
254                                  */
255                         }
256                         break;
257
258                 case CMD_GET_STATS:
259                         if (*hcp->hcq_status & QSTAT_ERROR) {
260                                 /*
261                                  * Couldn't get stats
262                                  */
263                                 fup->fu_pif.pif_cmderrors++;
264                                 fup->fu_stats_ret = EIO;
265                         } else {
266                                 /*
267                                  * Stats are now in unit buffer
268                                  */
269                                 fup->fu_stats_ret = 0;
270                         }
271                         DMA_FREE_ADDR(fup->fu_stats, fup->fu_statsd,
272                                 sizeof(Fore_cp_stats), 0);
273                         fup->fu_flags &= ~FUF_STATCMD;
274
275                         /*
276                          * Flush received stats data
277                          */
278 #ifdef VAC
279                         if (vac)
280                                 vac_pageflush((addr_t)fup->fu_stats);
281 #endif
282
283 #if BYTE_ORDER == LITTLE_ENDIAN
284                         /*
285                          * Little endian machines receives the stats in
286                          * wrong byte order. Instead of swapping in user
287                          * land, swap here so that everything going out
288                          * of the kernel is in correct host order.
289                          */
290                         {
291                                 u_long *bp = (u_long *)fup->fu_stats;
292                                 int     loop;
293
294                                 for ( loop = 0; loop < sizeof(Fore_cp_stats)/
295                                     sizeof(long); loop++, bp++ )
296                                         *bp = ntohl(*bp);
297                         }
298 #endif  /* BYTE_ORDER == LITTLE_ENDIAN */
299
300                         /*
301                          * Poke whoever is waiting on the stats
302                          */
303                         wakeup((caddr_t)&fup->fu_stats);
304                         break;
305
306                 case CMD_GET_PROM:
307                         if (*hcp->hcq_status & QSTAT_ERROR) {
308                                 /*
309                                  * Couldn't get PROM data
310                                  */
311                                 fup->fu_pif.pif_cmderrors++;
312                                 log(LOG_ERR, 
313                                     "fore_cmd_drain: %s%d: GET_PROM failed\n",
314                                         fup->fu_pif.pif_name,
315                                         fup->fu_pif.pif_unit);
316                         } else {
317                                 Fore_prom       *fp = fup->fu_prom;
318
319                                 /*
320                                  * Flush received PROM data
321                                  */
322 #ifdef VAC
323                                 if (vac)
324                                         vac_pageflush((addr_t)fp);
325 #endif
326                                 /*
327                                  * Copy PROM info into config areas
328                                  */
329                                 KM_COPY(&fp->pr_mac[2],
330                                         &fup->fu_pif.pif_macaddr,
331                                         sizeof(struct mac_addr));
332                                 fup->fu_config.ac_macaddr = 
333                                         fup->fu_pif.pif_macaddr;
334                                 ksnprintf(fup->fu_config.ac_hard_vers,
335                                     sizeof(fup->fu_config.ac_hard_vers),
336                                         "%ld.%ld.%ld",
337                                         (fp->pr_hwver >> 16) & 0xff,
338                                         (fp->pr_hwver >> 8) & 0xff,
339                                         fp->pr_hwver & 0xff);
340                                 fup->fu_config.ac_serial = fp->pr_serno;
341                         }
342
343                         DMA_FREE_ADDR(fup->fu_prom, fup->fu_promd,
344                                 sizeof(Fore_prom), 0);
345                         break;
346
347                 default:
348                         log(LOG_ERR, "fore_cmd_drain: unknown command %ld\n",
349                                 hcp->hcq_code);
350                 }
351
352                 /*
353                  * Mark this entry free for use and bump head pointer
354                  * to the next entry in the queue
355                  */
356                 *hcp->hcq_status = QSTAT_FREE;
357                 fup->fu_cmd_head = hcp->hcq_next;
358         }
359
360         return;
361 }
362
363
364 /*
365  * Free Command Queue Data Structures
366  *
367  * Arguments:
368  *      fup             pointer to device unit structure
369  *
370  * Returns:
371  *      none
372  */
373 void
374 fore_cmd_free(Fore_unit *fup)
375 {
376         H_cmd_queue     *hcp;
377
378         /*
379          * Deal with any commands left on the queue
380          */
381         if (fup->fu_flags & CUF_INITED) {
382                 while (*fup->fu_cmd_head->hcq_status != QSTAT_FREE) {
383                         hcp = fup->fu_cmd_head;
384
385                         switch (hcp->hcq_code) {
386
387                         case CMD_GET_STATS:
388                                 /*
389                                  * Just in case someone is sleeping on this
390                                  */
391                                 fup->fu_stats_ret = EIO;
392                                 wakeup((caddr_t)&fup->fu_stats);
393                                 break;
394                         }
395
396                         *hcp->hcq_status = QSTAT_FREE;
397                         fup->fu_cmd_head = hcp->hcq_next;
398                 }
399         }
400
401         /*
402          * Free the statistics buffer
403          */
404         if (fup->fu_stats) {
405                 atm_dev_free(fup->fu_stats);
406                 fup->fu_stats = NULL;
407         }
408
409         /*
410          * Free the PROM buffer
411          */
412         if (fup->fu_prom) {
413                 atm_dev_free(fup->fu_prom);
414                 fup->fu_prom = NULL;
415         }
416
417         /*
418          * Free the status words
419          */
420         if (fup->fu_cmd_stat) {
421                 if (fup->fu_cmd_statd) {
422                         DMA_FREE_ADDR(fup->fu_cmd_stat, fup->fu_cmd_statd,
423                                 sizeof(Q_status) * CMD_QUELEN,
424                                 ATM_DEV_NONCACHE);
425                 }
426                 atm_dev_free((volatile void *)fup->fu_cmd_stat);
427                 fup->fu_cmd_stat = NULL;
428                 fup->fu_cmd_statd = NULL;
429         }
430
431         return;
432 }
433