GNU Linux-libre 4.4.284-gnu1
[releases.git] / drivers / isdn / hardware / eicon / idifunc.c
1 /* $Id: idifunc.c,v 1.14.4.4 2004/08/28 20:03:53 armin Exp $
2  *
3  * Driver for Eicon DIVA Server ISDN cards.
4  * User Mode IDI Interface
5  *
6  * Copyright 2000-2003 by Armin Schindler (mac@melware.de)
7  * Copyright 2000-2003 Cytronics & Melware (info@melware.de)
8  *
9  * This software may be used and distributed according to the terms
10  * of the GNU General Public License, incorporated herein by reference.
11  */
12
13 #include "platform.h"
14 #include "di_defs.h"
15 #include "divasync.h"
16 #include "um_xdi.h"
17 #include "um_idi.h"
18
19 #define DBG_MINIMUM  (DL_LOG + DL_FTL + DL_ERR)
20 #define DBG_DEFAULT  (DBG_MINIMUM + DL_XLOG + DL_REG)
21
22 extern char *DRIVERRELEASE_IDI;
23
24 extern void DIVA_DIDD_Read(void *, int);
25 extern int diva_user_mode_idi_create_adapter(const DESCRIPTOR *, int);
26 extern void diva_user_mode_idi_remove_adapter(int);
27
28 static dword notify_handle;
29 static DESCRIPTOR DAdapter;
30 static DESCRIPTOR MAdapter;
31
32 static void no_printf(unsigned char *x, ...)
33 {
34         /* dummy debug function */
35 }
36
37 #include "debuglib.c"
38
39 /*
40  * stop debug
41  */
42 static void stop_dbg(void)
43 {
44         DbgDeregister();
45         memset(&MAdapter, 0, sizeof(MAdapter));
46         dprintf = no_printf;
47 }
48
49 typedef struct _udiva_card {
50         struct list_head list;
51         int Id;
52         DESCRIPTOR d;
53 } udiva_card;
54
55 static LIST_HEAD(cards);
56 static diva_os_spin_lock_t ll_lock;
57
58 /*
59  * find card in list
60  */
61 static udiva_card *find_card_in_list(DESCRIPTOR *d)
62 {
63         udiva_card *card;
64         struct list_head *tmp;
65         diva_os_spin_lock_magic_t old_irql;
66
67         diva_os_enter_spin_lock(&ll_lock, &old_irql, "find card");
68         list_for_each(tmp, &cards) {
69                 card = list_entry(tmp, udiva_card, list);
70                 if (card->d.request == d->request) {
71                         diva_os_leave_spin_lock(&ll_lock, &old_irql,
72                                                 "find card");
73                         return (card);
74                 }
75         }
76         diva_os_leave_spin_lock(&ll_lock, &old_irql, "find card");
77         return ((udiva_card *) NULL);
78 }
79
80 /*
81  * new card
82  */
83 static void um_new_card(DESCRIPTOR *d)
84 {
85         int adapter_nr = 0;
86         udiva_card *card = NULL;
87         IDI_SYNC_REQ sync_req;
88         diva_os_spin_lock_magic_t old_irql;
89
90         if (!(card = diva_os_malloc(0, sizeof(udiva_card)))) {
91                 DBG_ERR(("cannot get buffer for card"));
92                 return;
93         }
94         memcpy(&card->d, d, sizeof(DESCRIPTOR));
95         sync_req.xdi_logical_adapter_number.Req = 0;
96         sync_req.xdi_logical_adapter_number.Rc =
97                 IDI_SYNC_REQ_XDI_GET_LOGICAL_ADAPTER_NUMBER;
98         card->d.request((ENTITY *)&sync_req);
99         adapter_nr =
100                 sync_req.xdi_logical_adapter_number.info.logical_adapter_number;
101         card->Id = adapter_nr;
102         if (!(diva_user_mode_idi_create_adapter(d, adapter_nr))) {
103                 diva_os_enter_spin_lock(&ll_lock, &old_irql, "add card");
104                 list_add_tail(&card->list, &cards);
105                 diva_os_leave_spin_lock(&ll_lock, &old_irql, "add card");
106         } else {
107                 DBG_ERR(("could not create user mode idi card %d",
108                          adapter_nr));
109                 diva_os_free(0, card);
110         }
111 }
112
113 /*
114  * remove card
115  */
116 static void um_remove_card(DESCRIPTOR *d)
117 {
118         diva_os_spin_lock_magic_t old_irql;
119         udiva_card *card = NULL;
120
121         if (!(card = find_card_in_list(d))) {
122                 DBG_ERR(("cannot find card to remove"));
123                 return;
124         }
125         diva_user_mode_idi_remove_adapter(card->Id);
126         diva_os_enter_spin_lock(&ll_lock, &old_irql, "remove card");
127         list_del(&card->list);
128         diva_os_leave_spin_lock(&ll_lock, &old_irql, "remove card");
129         DBG_LOG(("idi proc entry removed for card %d", card->Id));
130         diva_os_free(0, card);
131 }
132
133 /*
134  * remove all adapter
135  */
136 static void __exit remove_all_idi_proc(void)
137 {
138         udiva_card *card;
139         diva_os_spin_lock_magic_t old_irql;
140
141 rescan:
142         diva_os_enter_spin_lock(&ll_lock, &old_irql, "remove all");
143         if (!list_empty(&cards)) {
144                 card = list_entry(cards.next, udiva_card, list);
145                 list_del(&card->list);
146                 diva_os_leave_spin_lock(&ll_lock, &old_irql, "remove all");
147                 diva_user_mode_idi_remove_adapter(card->Id);
148                 diva_os_free(0, card);
149                 goto rescan;
150         }
151         diva_os_leave_spin_lock(&ll_lock, &old_irql, "remove all");
152 }
153
154 /*
155  * DIDD notify callback
156  */
157 static void *didd_callback(void *context, DESCRIPTOR *adapter,
158                            int removal)
159 {
160         if (adapter->type == IDI_DADAPTER) {
161                 DBG_ERR(("Notification about IDI_DADAPTER change ! Oops."));
162                 return (NULL);
163         } else if (adapter->type == IDI_DIMAINT) {
164                 if (removal) {
165                         stop_dbg();
166                 } else {
167                         memcpy(&MAdapter, adapter, sizeof(MAdapter));
168                         dprintf = (DIVA_DI_PRINTF) MAdapter.request;
169                         DbgRegister("User IDI", DRIVERRELEASE_IDI, DBG_DEFAULT);
170                 }
171         } else if ((adapter->type > 0) && (adapter->type < 16)) {       /* IDI Adapter */
172                 if (removal) {
173                         um_remove_card(adapter);
174                 } else {
175                         um_new_card(adapter);
176                 }
177         }
178         return (NULL);
179 }
180
181 /*
182  * connect DIDD
183  */
184 static int __init connect_didd(void)
185 {
186         int x = 0;
187         int dadapter = 0;
188         IDI_SYNC_REQ req;
189         DESCRIPTOR DIDD_Table[MAX_DESCRIPTORS];
190
191         DIVA_DIDD_Read(DIDD_Table, sizeof(DIDD_Table));
192
193         for (x = 0; x < MAX_DESCRIPTORS; x++) {
194                 if (DIDD_Table[x].type == IDI_DADAPTER) {       /* DADAPTER found */
195                         dadapter = 1;
196                         memcpy(&DAdapter, &DIDD_Table[x], sizeof(DAdapter));
197                         req.didd_notify.e.Req = 0;
198                         req.didd_notify.e.Rc =
199                                 IDI_SYNC_REQ_DIDD_REGISTER_ADAPTER_NOTIFY;
200                         req.didd_notify.info.callback = (void *)didd_callback;
201                         req.didd_notify.info.context = NULL;
202                         DAdapter.request((ENTITY *)&req);
203                         if (req.didd_notify.e.Rc != 0xff) {
204                                 stop_dbg();
205                                 return (0);
206                         }
207                         notify_handle = req.didd_notify.info.handle;
208                 } else if (DIDD_Table[x].type == IDI_DIMAINT) { /* MAINT found */
209                         memcpy(&MAdapter, &DIDD_Table[x], sizeof(DAdapter));
210                         dprintf = (DIVA_DI_PRINTF) MAdapter.request;
211                         DbgRegister("User IDI", DRIVERRELEASE_IDI, DBG_DEFAULT);
212                 } else if ((DIDD_Table[x].type > 0)
213                            && (DIDD_Table[x].type < 16)) {      /* IDI Adapter found */
214                         um_new_card(&DIDD_Table[x]);
215                 }
216         }
217
218         if (!dadapter) {
219                 stop_dbg();
220         }
221
222         return (dadapter);
223 }
224
225 /*
226  *  Disconnect from DIDD
227  */
228 static void __exit disconnect_didd(void)
229 {
230         IDI_SYNC_REQ req;
231
232         stop_dbg();
233
234         req.didd_notify.e.Req = 0;
235         req.didd_notify.e.Rc = IDI_SYNC_REQ_DIDD_REMOVE_ADAPTER_NOTIFY;
236         req.didd_notify.info.handle = notify_handle;
237         DAdapter.request((ENTITY *)&req);
238 }
239
240 /*
241  * init
242  */
243 int __init idifunc_init(void)
244 {
245         diva_os_initialize_spin_lock(&ll_lock, "idifunc");
246
247         if (diva_user_mode_idi_init()) {
248                 DBG_ERR(("init: init failed."));
249                 return (0);
250         }
251
252         if (!connect_didd()) {
253                 diva_user_mode_idi_finit();
254                 DBG_ERR(("init: failed to connect to DIDD."));
255                 return (0);
256         }
257         return (1);
258 }
259
260 /*
261  * finit
262  */
263 void __exit idifunc_finit(void)
264 {
265         diva_user_mode_idi_finit();
266         disconnect_didd();
267         remove_all_idi_proc();
268 }