v2.4.8 -> v2.4.8.1
[opensuse:kernel.git] / drivers / isdn / eicon / common.c
1
2 /*
3  *
4  * Copyright (C) Eicon Technology Corporation, 2000.
5  *
6  * Eicon File Revision :    1.15  
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2, or (at your option)
11  * any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY OF ANY KIND WHATSOEVER INCLUDING ANY 
15  * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
16  * See the GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21  *
22  */
23
24
25 #include "eicon.h"
26 #include "sys.h"
27 #include "idi.h"
28 #include "constant.h"
29 #include "divas.h"
30 #include "pc.h"
31 #include "pr_pc.h"
32
33 #include "uxio.h"
34
35 #define DIVAS_LOAD_CMD          0x02
36 #define DIVAS_START_CMD         0x03
37 #define DIVAS_IRQ_RESET         0xC18
38 #define DIVAS_IRQ_RESET_VAL     0xFE
39
40 #define PCI_LATENCY     PCI_LATENCY_TIMER
41 #define PCI_INTERRUPT   PCI_INTERRUPT_LINE
42
43 #define TEST_INT_DIVAS          0x11
44 #define TEST_INT_DIVAS_BRI      0x12
45 #define TEST_INT_DIVAS_Q        0x13
46
47 #define DIVAS_RESET     0x81
48 #define DIVAS_LED1      0x04
49 #define DIVAS_LED2      0x08
50 #define DIVAS_LED3      0x20
51 #define DIVAS_LED4      0x40
52
53 #define DIVAS_SIGNATURE 0x4447
54
55 #define MP_PROTOCOL_ADDR 0xA0011000
56
57 #define PLX_IOBASE      0
58 #define DIVAS_IOBASE    1
59
60 typedef struct {
61                 dword cmd;
62                 dword addr;
63                 dword len;
64                 dword err;
65                 dword live;
66                 dword reserved[(0x1020>>2)-6];
67                 dword signature;
68                 byte  data[1];
69 } diva_server_boot_t;
70
71 int             DivasCardNext;
72 card_t  DivasCards[MAX_CARDS];
73
74 dia_config_t *DivasConfig(card_t *, dia_config_t *);
75
76 static
77 DESCRIPTOR DIDD_Table[32];
78
79 void    DIVA_DIDD_Read( DESCRIPTOR *table, int tablelength )
80 {
81         memset(table, 0, tablelength);
82
83         if (tablelength > sizeof(DIDD_Table))
84           tablelength = sizeof(DIDD_Table);
85
86         if(tablelength % sizeof(DESCRIPTOR)) {
87           tablelength /= sizeof(DESCRIPTOR);
88           tablelength *= sizeof(DESCRIPTOR);
89         }
90
91         if (tablelength > 0)
92           memcpy((void *)table, (void *)DIDD_Table, tablelength);
93
94         return;
95 }
96
97 void    DIVA_DIDD_Write(DESCRIPTOR *table, int tablelength)
98 {
99         if (tablelength > sizeof(DIDD_Table))
100           tablelength = sizeof(DIDD_Table);
101
102         memcpy((void *)DIDD_Table, (void *)table, tablelength);
103
104         return;
105 }
106
107 static
108 void    init_idi_tab(void)
109 {
110     DESCRIPTOR d[32];
111
112     memset(d, 0, sizeof(d));
113
114     d[0].type = IDI_DIMAINT;  /* identify the DIMAINT entry */
115     d[0].channels = 0; /* zero channels associated with dimaint*/
116     d[0].features = 0; /* no features associated with dimaint */
117     d[0].request = (IDI_CALL) DivasPrintf;
118     
119     DIVA_DIDD_Write(d, sizeof(d));
120
121     return;
122 }
123
124 /*
125  * I/O routines for memory mapped cards
126  */
127
128 byte mem_in(ADAPTER *a, void *adr)
129 {
130         card_t                  *card = a->io;
131         unsigned char   *b, *m;
132         byte                    value;
133
134         m = b = UxCardMemAttach(card->hw, DIVAS_SHARED_MEMORY);
135
136         m += (unsigned int) adr;
137
138         value = UxCardMemIn(card->hw, m);
139
140         UxCardMemDetach(card->hw, b);
141
142         return value;
143 }
144
145 word mem_inw(ADAPTER *a, void *adr)
146 {
147         card_t                  *card = a->io;
148         unsigned char   *b, *m;
149         word                    value;
150
151         m = b = UxCardMemAttach(card->hw, DIVAS_SHARED_MEMORY);
152
153         m += (unsigned int) adr;
154
155         value = UxCardMemInW(card->hw, m);
156
157         UxCardMemDetach(card->hw, b);
158
159         return value;
160 }
161
162 void mem_in_buffer(ADAPTER *a, void *adr, void *P, word length)
163 {
164         card_t                  *card = a->io;
165         unsigned char   *b, *m;
166
167         m = b = UxCardMemAttach(card->hw, DIVAS_SHARED_MEMORY);
168
169         m += (unsigned int) adr;
170
171         UxCardMemInBuffer(card->hw, m, P, length);
172
173         UxCardMemDetach(card->hw, b);
174
175         return;
176 }
177
178 void mem_look_ahead(ADAPTER *a, PBUFFER *RBuffer, ENTITY *e)
179 {
180         card_t                  *card = a->io;
181         unsigned char   *b, *m;
182
183         m = b = UxCardMemAttach(card->hw, DIVAS_SHARED_MEMORY);
184
185         m += (dword) &RBuffer->length;
186         card->RBuffer.length = UxCardMemInW(card->hw, m);
187
188         m = b;
189         m += (dword) &RBuffer->P;
190         UxCardMemInBuffer(card->hw, m, card->RBuffer.P, card->RBuffer.length);
191
192         e->RBuffer = (DBUFFER *) &card->RBuffer;
193
194         UxCardMemDetach(card->hw, b);
195
196         return;
197 }
198
199 void mem_out(ADAPTER *a, void *adr, byte data)
200 {
201         card_t                  *card = a->io;
202         unsigned char   *b, *m;
203
204         m = b = UxCardMemAttach(card->hw, DIVAS_SHARED_MEMORY);
205
206         m += (unsigned int) adr;
207
208         UxCardMemOut(card->hw, m, data);
209
210         UxCardMemDetach(card->hw, b);
211
212         return;
213 }
214
215 void mem_outw(ADAPTER *a, void *adr, word data)
216 {
217         card_t                  *card = a->io;
218         unsigned char   *b, *m;
219
220         m = b = UxCardMemAttach(card->hw, DIVAS_SHARED_MEMORY);
221
222         m += (unsigned int) adr;
223
224         UxCardMemOutW(card->hw, m, data);
225
226         UxCardMemDetach(card->hw, b);
227
228         return;
229 }
230
231 void mem_out_buffer(ADAPTER *a, void *adr, void *P, word length)
232 {
233         card_t                  *card = a->io;
234         unsigned char   *b, *m;
235
236         m = b = UxCardMemAttach(card->hw, DIVAS_SHARED_MEMORY);
237
238         m += (unsigned int) adr;
239
240         UxCardMemOutBuffer(card->hw, m, P, length);
241
242         UxCardMemDetach(card->hw, b);
243
244         return;
245 }
246
247 void mem_inc(ADAPTER *a, void *adr)
248 {
249         word                    value;
250         card_t                  *card = a->io;
251         unsigned char   *b, *m;
252
253         m = b = UxCardMemAttach(card->hw, DIVAS_SHARED_MEMORY);
254
255         m += (unsigned int) adr;
256
257         value = UxCardMemInW(card->hw, m);
258         value++;
259         UxCardMemOutW(card->hw, m, value);
260
261         UxCardMemDetach(card->hw, b);
262
263         return;
264 }
265
266 /*
267  * I/O routines for I/O mapped cards
268  */
269
270 byte io_in(ADAPTER *a, void *adr)
271 {
272         card_t              *card = a->io;
273         byte                value;
274         byte    *DivasIOBase = NULL;
275
276         DivasIOBase = UxCardMemAttach(card->hw, DIVAS_IOBASE);
277
278         value = UxCardIoIn(card->hw, DivasIOBase, adr);
279
280         UxCardMemDetach(card->hw, DivasIOBase);
281
282     return value;
283 }
284
285 word io_inw(ADAPTER *a, void *adr)
286 {
287         card_t          *card = a->io;
288         word            value;
289         byte    *DivasIOBase = NULL;
290
291         DivasIOBase = UxCardMemAttach(card->hw, DIVAS_IOBASE);
292
293         value = UxCardIoInW(card->hw, DivasIOBase, adr);
294
295         UxCardMemDetach(card->hw, DivasIOBase);
296
297         return value;
298 }
299
300 void io_in_buffer(ADAPTER *a, void *adr, void *P, word length)
301 {
302         card_t *card = a->io;
303         byte *DivasIOBase = NULL;
304
305         DivasIOBase = UxCardMemAttach(card->hw, DIVAS_IOBASE);
306
307         UxCardIoInBuffer(card->hw, DivasIOBase, adr, P,length);
308
309         UxCardMemDetach(card->hw, DivasIOBase);
310
311     return;
312 }
313
314 void io_look_ahead(ADAPTER *a, PBUFFER *RBuffer, ENTITY *e)
315 {
316         card_t *card = a->io;
317         byte *DivasIOBase = NULL;
318
319         DivasIOBase = UxCardMemAttach(card->hw, DIVAS_IOBASE);
320
321         card->RBuffer.length = UxCardIoInW(card->hw, DivasIOBase, (byte *) RBuffer);
322
323         UxCardIoInBuffer(card->hw, DivasIOBase, &RBuffer->P, card->RBuffer.P, card->RBuffer.length);
324
325         UxCardMemDetach(card->hw, DivasIOBase);
326
327         e->RBuffer = (DBUFFER *) &card->RBuffer;
328
329     return;
330 }
331
332 void io_out(ADAPTER *a, void *adr, byte data)
333 {
334         card_t          *card = a->io;
335         byte    *DivasIOBase = NULL;
336
337         DivasIOBase = UxCardMemAttach(card->hw, DIVAS_IOBASE);
338
339         UxCardIoOut(card->hw, DivasIOBase, adr, data);
340
341         UxCardMemDetach(card->hw, DivasIOBase);
342
343     return;
344 }
345
346 void io_outw(ADAPTER *a, void *adr, word data)
347 {
348         card_t          *card = a->io;
349         byte    *DivasIOBase = NULL;
350
351         DivasIOBase = UxCardMemAttach(card->hw, DIVAS_IOBASE);
352
353         UxCardIoOutW(card->hw, DivasIOBase, adr, data);
354
355         UxCardMemDetach(card->hw, DivasIOBase);
356
357     return;
358 }
359
360 void io_out_buffer(ADAPTER *a, void *adr, void *P, word length)
361 {
362         card_t          *card = a->io;
363         byte *DivasIOBase = NULL;
364
365         DivasIOBase = UxCardMemAttach(card->hw, DIVAS_IOBASE);
366
367         UxCardIoOutBuffer(card->hw, DivasIOBase, adr, P, length);
368
369         UxCardMemDetach(card->hw, DivasIOBase);
370
371     return;
372 }
373
374 void io_inc(ADAPTER *a, void *adr)
375 {
376         word            value;
377         card_t          *card = a->io;
378         byte *DivasIOBase;
379
380         DivasIOBase = UxCardMemAttach(card->hw, DIVAS_IOBASE);
381
382         value = UxCardIoInW(card->hw, DivasIOBase, adr);
383         
384         value++;
385
386         UxCardIoOutW(card->hw, DivasIOBase, adr, value);
387
388         UxCardMemDetach(card->hw, DivasIOBase);
389
390     return;
391 }
392
393 static
394 void test_int(card_t *card)
395
396 {
397         byte *shared, *DivasIOBase;
398
399         switch (card->test_int_pend)
400         {
401                 case TEST_INT_DIVAS:
402                         DPRINTF(("divas: test interrupt pending"));
403                         shared = UxCardMemAttach(card->hw, DIVAS_SHARED_MEMORY);
404
405                         if (UxCardMemIn(card->hw, &shared[0x3FE]))
406                         {
407                                 UxCardMemOut(card->hw, 
408                                                                 &(((struct pr_ram *)shared)->RcOutput), 0);
409                                 UxCardMemDetach(card->hw, shared);
410                 (*card->reset_int)(card);
411                                 shared = UxCardMemAttach(card->hw, DIVAS_SHARED_MEMORY);
412                                 UxCardMemOut(card->hw, &shared[0x3FE], 0);
413                                 DPRINTF(("divas: test interrupt cleared"));
414                         }
415
416                         UxCardMemDetach(card->hw, shared);
417
418                         card->test_int_pend = 0;
419                         break;
420
421                 case TEST_INT_DIVAS_BRI:
422                         DPRINTF(("divas: BRI test interrupt pending"));
423                         (*card->reset_int)(card);
424                         DivasIOBase = UxCardMemAttach(card->hw, DIVAS_IOBASE);
425                         UxCardIoOutW(card->hw, DivasIOBase, (void *) 0x3FE, 0);
426                         UxCardMemDetach(card->hw, DivasIOBase);
427                         DPRINTF(("divas: test interrupt cleared"));
428                         card->test_int_pend = 0;
429                         break;
430
431                 case TEST_INT_DIVAS_Q:
432                         DPRINTF(("divas: 4BRI test interrupt pending"));
433                         (*card->reset_int)(card);
434                         card->test_int_pend = 0;
435                         break;
436
437                 default:
438                         DPRINTF(("divas: unknown test interrupt pending"));
439                         return;
440         }
441         return;
442 }
443
444 void card_isr (void *dev_id)
445 {
446         card_t *card = (card_t *) dev_id;
447         ADAPTER *a = &card->a;
448         int ipl;
449
450         if (card->test_int_pend)
451         {
452                 ipl = UxCardLock(card->hw);
453                 card->int_pend=0;
454                 test_int(card);
455                 UxCardUnlock(card->hw,ipl);
456                 return;
457         }
458         
459         if(card->card_isr)
460         {
461                 (*(card->card_isr))(card);
462         }
463         else
464         {
465                 ipl = UxCardLock(card->hw);
466         
467                 if ((card->test_int)(a))
468                 {
469                         (card->reset_int)(card);
470                 }
471                 
472                 UxCardUnlock(card->hw,ipl);
473                 
474         }
475
476 }
477
478 int DivasCardNew(dia_card_t *card_info)
479 {
480         card_t *card;
481         byte b;
482         static boolean_t first_call = TRUE;
483         boolean_t NeedISRandReset = FALSE;
484
485         DPRINTF(("divas: new card "));
486
487         if (first_call)
488         {
489                 first_call = FALSE;
490                 init_idi_tab();
491         }
492
493         DivasConfigGet(card_info);
494         
495         if (DivasCardNext == DIM(DivasCards))
496         {
497                 KDPRINTF((KERN_WARNING "Divas: no space available for new card"));
498                 return -1;
499         }
500
501         card = &DivasCards[DivasCardNext];
502
503         card->state = DIA_UNKNOWN;
504
505         card->cfg = *card_info;
506
507         card->a.io = card;
508
509         if (UxCardHandleGet(&card->hw, card_info))
510         {
511                 KDPRINTF((KERN_WARNING "Divas: cannot get OS specific handle for card"));
512                 return -1;
513         }
514
515         if (card_info->card_type == DIA_CARD_TYPE_DIVA_SERVER_B)
516         {
517                 DivasBriPatch(card);
518                 card_info->io_base = card->cfg.io_base;
519         }
520
521         switch (card_info->card_type)
522         {
523                 case DIA_CARD_TYPE_DIVA_SERVER:
524                         if (DivasPriInit(card, card_info))
525                         {
526                                 return -1;
527                         }
528                         NeedISRandReset = TRUE;
529                         break;
530
531                 case DIA_CARD_TYPE_DIVA_SERVER_B:
532                         if (DivasBriInit(card, card_info))
533                         {
534                                 return -1;
535                         }
536                         NeedISRandReset = TRUE;
537                         break;
538
539                 case DIA_CARD_TYPE_DIVA_SERVER_Q:
540                         if (Divas4BriInit(card, card_info))
541                         {
542                                 return -1;
543                         }
544
545                         if (card_info->name[6] == '0')
546                         {
547                                 NeedISRandReset = TRUE;
548                         }
549                         else // Need to set paramater for ISR anyway
550                         {
551                                 card->hw->user_isr_arg = card;
552                                 card->hw->user_isr = card_isr;
553                         }
554                         break;   
555
556                 default:
557                         KDPRINTF((KERN_WARNING "Divas: unsupported card type (%d)", card_info->card_type));
558                         return -1;
559         }
560
561         if (NeedISRandReset)
562         {
563                 if (UxIsrInstall(card->hw, card_isr, card))
564                 {
565                         KDPRINTF((KERN_WARNING "Divas: Install ISR failed (IRQ %d)", card->cfg.irq));
566                         UxCardHandleFree(card->hw);
567                         return -1;
568                 }
569
570                 b = card->cfg.irq;
571
572                 UxPciConfigWrite(card->hw, sizeof(b), PCI_INTERRUPT_LINE, &b);
573
574                 if (card_info->card_type != DIA_CARD_TYPE_DIVA_SERVER_Q)
575                 {
576                         if ((*card->card_reset)(card))
577                         {
578                                 KDPRINTF((KERN_WARNING "Divas: Adapter reset failed"));
579                                 return -1;
580                         }
581                         card->state = DIA_RESET;
582                 }
583
584                 NeedISRandReset = FALSE;
585         }
586
587         DivasCardNext++;
588
589         return 0;
590 }
591
592 void    *get_card(int card_id)
593 {
594         int i;
595
596         for (i=0; i < DivasCardNext; i++)
597         {
598                 if (DivasCards[i].cfg.card_id == card_id)
599                 {
600                         return(&DivasCards[i]);
601                 }
602         }
603
604         DPRINTF(("divas: get_card() : no such card id (%d)", card_id));
605
606         return NULL;
607 }
608
609 int DivasCardConfig(dia_config_t *config)
610 {
611         card_t *card;
612         int status;
613
614         DPRINTF(("divas: configuring card"));
615
616         card = get_card(config->card_id);
617         if (!card)
618         {
619                 return -1;
620         }
621
622         config = DivasConfig(card, config);
623
624         status = (*card->card_config)(card, config);
625
626         if (!status)
627         {
628                 card->state = DIA_CONFIGURED;
629         }
630         return status;
631 }
632
633 int DivasCardLoad(dia_load_t *load)
634 {
635         card_t *card;
636         int     status;
637
638         card = get_card(load->card_id);
639         if (!card)
640         {
641                 return -1;
642         }
643
644         if (card->state == DIA_RUNNING)
645         {
646                 (*card->card_reset)(card);
647         }
648
649         status = (*card->card_load)(card, load);
650         if (!status)
651         {
652                 card->state = DIA_LOADED;
653         }
654         return status;
655 }
656
657 static int idi_register(card_t *card, byte channels)
658 {
659     DESCRIPTOR d[32];
660     int length, num_entities;
661
662         DPRINTF(("divas: registering card with IDI"));
663
664         num_entities = (channels > 2) ? MAX_PENTITIES : MAX_ENTITIES;
665         card->e_tbl = UxAlloc(sizeof(E_INFO) * num_entities);
666
667         if (!card->e_tbl)
668         {
669                 KDPRINTF((KERN_WARNING "Divas: IDI register failed - no memory available"));
670                 return -1;
671         }
672
673         bzero(card->e_tbl, sizeof(E_INFO) * num_entities);
674         card->e_max = num_entities;
675
676     DIVA_DIDD_Read(d, sizeof(d));
677
678         for(length=0; length < DIM(d); length++)
679           if (d[length].type == 0) break;
680
681         if (length >= DIM(d))
682         {
683                 KDPRINTF((KERN_WARNING "Divas: IDI register failed - table full"));
684                 return -1;
685         }
686
687         switch (card->cfg.card_type)
688         {
689                 case DIA_CARD_TYPE_DIVA_SERVER:
690                 d[length].type = IDI_ADAPTER_PR;
691                 /* d[length].serial = card->serial_no; */
692                 break;
693
694                 case DIA_CARD_TYPE_DIVA_SERVER_B:
695                 d[length].type = IDI_ADAPTER_MAESTRA;
696                 /* d[length].serial = card->serial_no; */
697                 break;
698
699                 // 4BRI is treated as 4 BRI adapters
700                 case DIA_CARD_TYPE_DIVA_SERVER_Q:
701                 d[length].type = IDI_ADAPTER_MAESTRA;
702                 /* d[length].serial = card->cfg.serial; */
703         }
704
705         d[length].features = 0;
706         d[length].features |= DI_FAX3|DI_MODEM|DI_POST|DI_V110|DI_V120;
707
708         if ( card->hw->features & PROTCAP_MANIF )
709         {
710                 d[length].features |= DI_MANAGE ;
711         }
712         if ( card->hw->features & PROTCAP_V_42 )
713         {
714                 d[length].features |= DI_V_42 ;
715         }
716         if ( card->hw->features & PROTCAP_EXTD_FAX )
717         {
718                 d[length].features |= DI_EXTD_FAX ;
719         }
720
721         d[length].channels = channels;
722         d[length].request = DivasIdiRequest[card - DivasCards];
723
724         length++;
725
726         DIVA_DIDD_Write(d, sizeof(d));
727
728     return 0;
729 }
730
731 int DivasCardStart(int card_id)
732 {
733         card_t *card;
734         byte channels;
735         int status;
736
737         DPRINTF(("divas: starting card"));
738
739         card = get_card(card_id);
740         if (!card)
741         {
742                 return -1;
743         }
744
745         status = (*card->card_start)(card, &channels);
746         if (status)
747         {
748                 return status;
749         }
750
751         /* 4BRI == 4 x BRI so call idi_register 4 times each with 2 channels */
752         if (card->cfg.card_type == DIA_CARD_TYPE_DIVA_SERVER_Q)
753         {
754                 int i;
755                 card_t *FourBRISlave;
756
757                 for (i=3; i >= 0; i--)
758                 {
759                         FourBRISlave = get_card(card_id - i); /* 0, 1, 2, 3 */
760                         if (FourBRISlave)
761                         {
762                                 idi_register(FourBRISlave, 2);
763                                 FourBRISlave->state = DIA_RUNNING;
764                         }
765                 }
766                 card->serial_no = card->cfg.serial;
767
768                 DPRINTF(("divas: card id %d (4BRI), serial no. 0x%x ready with %d channels", 
769                                 card_id - 3, card->serial_no, (int) channels));
770         }
771         else
772         {
773                 status = idi_register(card, channels);
774                 if (!status)
775                 {
776                         card->state = DIA_RUNNING;
777                         DPRINTF(("divas: card id %d, serial no. 0x%x ready with %d channels", 
778                                                 card_id, card->serial_no, (int) channels));
779                 }
780         }
781
782         return status;
783 }
784
785 int DivasGetMem(mem_block_t *mem_block)
786 {
787         card_t *card;
788         word    card_id = mem_block->card_id;
789
790         card = get_card(card_id);
791         if (!card)
792         {
793                 return 0;
794         }
795
796         return (*card->card_mem_get)(card, mem_block);
797 }
798
799
800 /*
801  * Deleyed Procedure Call for handling interrupts from card
802  */
803
804 void    DivaDoCardDpc(card_t *card)
805 {
806         ADAPTER *a;
807
808         a = &card->a;
809
810         if(UxInterlockedIncrement(card->hw, &card->dpc_reentered) > 1)
811         {
812                 return;
813         }
814
815         do{
816                 if((*(card->test_int))(a))
817                 {
818                         (*(card->dpc))(a);
819                         (*(card->clear_int))(a);
820                 }
821                         (*(card->out))(a);
822         }while(UxInterlockedDecrement(card->hw, &card->dpc_reentered));
823                         
824 }
825
826 void    DivasDoDpc(void *pData)
827 {
828         card_t  *card = DivasCards;
829         int     i = DivasCardNext;
830         
831         while(i--)
832         {
833                 DivaDoCardDpc(card++);
834         }
835 }
836
837 void    DivasDoRequestDpc(void *pData)
838 {
839         DivasDoDpc(pData);
840 }
841
842 /*
843  * DivasGetNum
844  * Returns the number of active adapters
845  */
846
847 int DivasGetNum(void)
848 {
849         return(DivasCardNext);
850 }
851
852 /*
853  * DivasGetList
854  * Returns a list of active adapters
855  */
856 int DivasGetList(dia_card_list_t *card_list)
857 {
858         int i;
859
860         memset(card_list, 0, sizeof(dia_card_list_t));
861
862         for(i = 0; i < DivasCardNext; i++)
863         {
864                 card_list->card_type = DivasCards[i].cfg.card_type;
865                 card_list->card_slot = DivasCards[i].cfg.slot;
866                 card_list->state     = DivasCards[i].state;
867                 card_list++;
868         }
869
870         return 0;
871
872 }
873
874 /*
875  * control logging for specified card
876  */
877
878 void    DivasLog(dia_log_t *log)
879 {
880         card_t *card;
881
882         card = get_card(log->card_id);
883         if (!card)
884         {
885                 return;
886         }
887
888         card->log_types = log->log_types;
889
890         return;
891 }
892