Merge branch 'next' of git://git.kernel.org/pub/scm/linux/kernel/git/davej/cpufreq
[linux-2.6] / drivers / isdn / sc / command.c
1 /* $Id: command.c,v 1.4.10.1 2001/09/23 22:24:59 kai Exp $
2  *
3  * Copyright (C) 1996  SpellCaster Telecommunications Inc.
4  *
5  * This software may be used and distributed according to the terms
6  * of the GNU General Public License, incorporated herein by reference.
7  *
8  * For more information, please contact gpl-info@spellcast.com or write:
9  *
10  *     SpellCaster Telecommunications Inc.
11  *     5621 Finch Avenue East, Unit #3
12  *     Scarborough, Ontario  Canada
13  *     M1B 2T9
14  *     +1 (416) 297-8565
15  *     +1 (416) 297-6433 Facsimile
16  */
17
18 #include <linux/module.h>
19 #include "includes.h"           /* This must be first */
20 #include "hardware.h"
21 #include "message.h"
22 #include "card.h"
23 #include "scioc.h"
24
25 static int dial(int card, unsigned long channel, setup_parm setup);
26 static int hangup(int card, unsigned long channel);
27 static int answer(int card, unsigned long channel);
28 static int clreaz(int card, unsigned long channel);
29 static int seteaz(int card, unsigned long channel, char *);
30 static int setl2(int card, unsigned long arg);
31 static int setl3(int card, unsigned long arg);
32 static int acceptb(int card, unsigned long channel);
33
34 #ifdef DEBUG
35 /*
36  * Translate command codes to strings
37  */
38 static char *commands[] = { "ISDN_CMD_IOCTL",
39                             "ISDN_CMD_DIAL",
40                             "ISDN_CMD_ACCEPTB",
41                             "ISDN_CMD_ACCEPTB",
42                             "ISDN_CMD_HANGUP",
43                             "ISDN_CMD_CLREAZ",
44                             "ISDN_CMD_SETEAZ",
45                             NULL,
46                             NULL,
47                             NULL,
48                             "ISDN_CMD_SETL2",
49                             NULL,
50                             "ISDN_CMD_SETL3",
51                             NULL,
52                             NULL,
53                             NULL,
54                             NULL,
55                             NULL, };
56
57 /*
58  * Translates ISDN4Linux protocol codes to strings for debug messages
59  */
60 static char *l3protos[] = { "ISDN_PROTO_L3_TRANS" };
61 static char *l2protos[] = { "ISDN_PROTO_L2_X75I",
62                             "ISDN_PROTO_L2_X75UI",
63                             "ISDN_PROTO_L2_X75BUI",
64                             "ISDN_PROTO_L2_HDLC",
65                             "ISDN_PROTO_L2_TRANS" };
66 #endif
67
68 int get_card_from_id(int driver)
69 {
70         int i;
71
72         for(i = 0 ; i < cinst ; i++) {
73                 if(sc_adapter[i]->driverId == driver)
74                         return i;
75         }
76         return -ENODEV;
77 }
78
79 /* 
80  * command
81  */
82
83 int command(isdn_ctrl *cmd)
84 {
85         int card;
86
87         card = get_card_from_id(cmd->driver);
88         if(!IS_VALID_CARD(card)) {
89                 pr_debug("Invalid param: %d is not a valid card id\n", card);
90                 return -ENODEV;
91         }
92
93         /*
94          * Dispatch the command
95          */
96         switch(cmd->command) {
97         case ISDN_CMD_IOCTL:
98         {
99                 unsigned long   cmdptr;
100                 scs_ioctl       ioc;
101
102                 memcpy(&cmdptr, cmd->parm.num, sizeof(unsigned long));
103                 if (copy_from_user(&ioc, (scs_ioctl __user *)cmdptr,
104                                    sizeof(scs_ioctl))) {
105                         pr_debug("%s: Failed to verify user space 0x%lx\n",
106                                 sc_adapter[card]->devicename, cmdptr);
107                         return -EFAULT;
108                 }
109                 return sc_ioctl(card, &ioc);
110         }
111         case ISDN_CMD_DIAL:
112                 return dial(card, cmd->arg, cmd->parm.setup);
113         case ISDN_CMD_HANGUP:
114                 return hangup(card, cmd->arg);
115         case ISDN_CMD_ACCEPTD:
116                 return answer(card, cmd->arg);
117         case ISDN_CMD_ACCEPTB:
118                 return acceptb(card, cmd->arg);
119         case ISDN_CMD_CLREAZ:
120                 return clreaz(card, cmd->arg);
121         case ISDN_CMD_SETEAZ:
122                 return seteaz(card, cmd->arg, cmd->parm.num);
123         case ISDN_CMD_SETL2:
124                 return setl2(card, cmd->arg);
125         case ISDN_CMD_SETL3:
126                 return setl3(card, cmd->arg);
127         default:
128                 return -EINVAL;
129         }
130         return 0;
131 }
132
133 /*
134  * start the onboard firmware
135  */
136 int startproc(int card) 
137 {
138         int status;
139
140         if(!IS_VALID_CARD(card)) {
141                 pr_debug("Invalid param: %d is not a valid card id\n", card);
142                 return -ENODEV;
143         }
144
145         /*
146          * send start msg 
147          */
148         status = sendmessage(card, CMPID,cmReqType2,
149                           cmReqClass0,
150                           cmReqStartProc,
151                           0,0,NULL);
152         pr_debug("%s: Sent startProc\n", sc_adapter[card]->devicename);
153         
154         return status;
155 }
156
157
158 /*
159  * Dials the number passed in 
160  */
161 static int dial(int card, unsigned long channel, setup_parm setup)
162 {
163         int status;
164         char Phone[48];
165   
166         if(!IS_VALID_CARD(card)) {
167                 pr_debug("Invalid param: %d is not a valid card id\n", card);
168                 return -ENODEV;
169         }
170
171         /*extract ISDN number to dial from eaz/msn string*/ 
172         strcpy(Phone,setup.phone); 
173
174         /*send the connection message*/
175         status = sendmessage(card, CEPID,ceReqTypePhy,
176                                 ceReqClass1,
177                                 ceReqPhyConnect,
178                                 (unsigned char) channel+1, 
179                                 strlen(Phone),
180                                 (unsigned int *) Phone);
181
182         pr_debug("%s: Dialing %s on channel %lu\n",
183                 sc_adapter[card]->devicename, Phone, channel+1);
184         
185         return status;
186 }
187
188 /*
189  * Answer an incoming call 
190  */
191 static int answer(int card, unsigned long channel)
192 {
193         if(!IS_VALID_CARD(card)) {
194                 pr_debug("Invalid param: %d is not a valid card id\n", card);
195                 return -ENODEV;
196         }
197
198         if(setup_buffers(card, channel+1)) {
199                 hangup(card, channel+1);
200                 return -ENOBUFS;
201         }
202
203         indicate_status(card, ISDN_STAT_BCONN,channel,NULL);
204         pr_debug("%s: Answered incoming call on channel %lu\n",
205                 sc_adapter[card]->devicename, channel+1);
206         return 0;
207 }
208
209 /*
210  * Hangup up the call on specified channel
211  */
212 static int hangup(int card, unsigned long channel)
213 {
214         int status;
215
216         if(!IS_VALID_CARD(card)) {
217                 pr_debug("Invalid param: %d is not a valid card id\n", card);
218                 return -ENODEV;
219         }
220
221         status = sendmessage(card, CEPID, ceReqTypePhy,
222                                                  ceReqClass1,
223                                                  ceReqPhyDisconnect,
224                                                  (unsigned char) channel+1,
225                                                  0,
226                                                  NULL);
227         pr_debug("%s: Sent HANGUP message to channel %lu\n",
228                 sc_adapter[card]->devicename, channel+1);
229         return status;
230 }
231
232 /*
233  * Set the layer 2 protocol (X.25, HDLC, Raw)
234  */
235 static int setl2(int card, unsigned long arg)
236 {
237         int status =0;
238         int protocol,channel;
239
240         if(!IS_VALID_CARD(card)) {
241                 pr_debug("Invalid param: %d is not a valid card id\n", card);
242                 return -ENODEV;
243         }
244         protocol = arg >> 8;
245         channel = arg & 0xff;
246         sc_adapter[card]->channel[channel].l2_proto = protocol;
247
248         /*
249          * check that the adapter is also set to the correct protocol
250          */
251         pr_debug("%s: Sending GetFrameFormat for channel %d\n",
252                 sc_adapter[card]->devicename, channel+1);
253         status = sendmessage(card, CEPID, ceReqTypeCall,
254                                 ceReqClass0,
255                                 ceReqCallGetFrameFormat,
256                                 (unsigned char)channel+1,
257                                 1,
258                                 (unsigned int *) protocol);
259         if(status) 
260                 return status;
261         return 0;
262 }
263
264 /*
265  * Set the layer 3 protocol
266  */
267 static int setl3(int card, unsigned long channel)
268 {
269         int protocol = channel >> 8;
270
271         if(!IS_VALID_CARD(card)) {
272                 pr_debug("Invalid param: %d is not a valid card id\n", card);
273                 return -ENODEV;
274         }
275
276         sc_adapter[card]->channel[channel].l3_proto = protocol;
277         return 0;
278 }
279
280 static int acceptb(int card, unsigned long channel)
281 {
282         if(!IS_VALID_CARD(card)) {
283                 pr_debug("Invalid param: %d is not a valid card id\n", card);
284                 return -ENODEV;
285         }
286
287         if(setup_buffers(card, channel+1))
288         {
289                 hangup(card, channel+1);
290                 return -ENOBUFS;
291         }
292
293         pr_debug("%s: B-Channel connection accepted on channel %lu\n",
294                 sc_adapter[card]->devicename, channel+1);
295         indicate_status(card, ISDN_STAT_BCONN, channel, NULL);
296         return 0;
297 }
298
299 static int clreaz(int card, unsigned long arg)
300 {
301         if(!IS_VALID_CARD(card)) {
302                 pr_debug("Invalid param: %d is not a valid card id\n", card);
303                 return -ENODEV;
304         }
305
306         strcpy(sc_adapter[card]->channel[arg].eazlist, "");
307         sc_adapter[card]->channel[arg].eazclear = 1;
308         pr_debug("%s: EAZ List cleared for channel %lu\n",
309                 sc_adapter[card]->devicename, arg+1);
310         return 0;
311 }
312
313 static int seteaz(int card, unsigned long arg, char *num)
314 {
315         if(!IS_VALID_CARD(card)) {
316                 pr_debug("Invalid param: %d is not a valid card id\n", card);
317                 return -ENODEV;
318         }
319
320         strcpy(sc_adapter[card]->channel[arg].eazlist, num);
321         sc_adapter[card]->channel[arg].eazclear = 0;
322         pr_debug("%s: EAZ list for channel %lu set to: %s\n",
323                 sc_adapter[card]->devicename, arg+1,
324                 sc_adapter[card]->channel[arg].eazlist);
325         return 0;
326 }
327
328 int reset(int card)
329 {
330         unsigned long flags;
331
332         if(!IS_VALID_CARD(card)) {
333                 pr_debug("Invalid param: %d is not a valid card id\n", card);
334                 return -ENODEV;
335         }
336
337         indicate_status(card, ISDN_STAT_STOP, 0, NULL);
338
339         if(sc_adapter[card]->EngineUp) {
340                 del_timer(&sc_adapter[card]->stat_timer);
341         }
342
343         sc_adapter[card]->EngineUp = 0;
344
345         spin_lock_irqsave(&sc_adapter[card]->lock, flags);
346         init_timer(&sc_adapter[card]->reset_timer);
347         sc_adapter[card]->reset_timer.function = sc_check_reset;
348         sc_adapter[card]->reset_timer.data = card;
349         sc_adapter[card]->reset_timer.expires = jiffies + CHECKRESET_TIME;
350         add_timer(&sc_adapter[card]->reset_timer);
351         spin_unlock_irqrestore(&sc_adapter[card]->lock, flags);
352
353         outb(0x1,sc_adapter[card]->ioport[SFT_RESET]);
354
355         pr_debug("%s: Adapter Reset\n", sc_adapter[card]->devicename);
356         return 0;
357 }
358
359 void flushreadfifo (int card)
360 {
361         while(inb(sc_adapter[card]->ioport[FIFO_STATUS]) & RF_HAS_DATA)
362                 inb(sc_adapter[card]->ioport[FIFO_READ]);
363 }