URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [isdn/] [sc/] [command.c] - Blame information for rev 62

Details | Compare with Previous | View Log


/* $Id: command.c,v 1.4.10.1 2001/09/23 22:24:59 kai Exp $
 *
 * Copyright (C) 1996  SpellCaster Telecommunications Inc.
 *
 * This software may be used and distributed according to the terms
 * of the GNU General Public License, incorporated herein by reference.
 *
 * For more information, please contact gpl-info@spellcast.com or write:
 *
 *     SpellCaster Telecommunications Inc.
 *     5621 Finch Avenue East, Unit #3
 *     Scarborough, Ontario  Canada
 *     M1B 2T9
 *     +1 (416) 297-8565
 *     +1 (416) 297-6433 Facsimile
 */
 
#include <linux/module.h>
#include "includes.h"           /* This must be first */
#include "hardware.h"
#include "message.h"
#include "card.h"
#include "scioc.h"
 
static int dial(int card, unsigned long channel, setup_parm setup);
static int hangup(int card, unsigned long channel);
static int answer(int card, unsigned long channel);
static int clreaz(int card, unsigned long channel);
static int seteaz(int card, unsigned long channel, char *);
static int setl2(int card, unsigned long arg);
static int setl3(int card, unsigned long arg);
static int acceptb(int card, unsigned long channel);
 
#ifdef DEBUG
/*
 * Translate command codes to strings
 */
static char *commands[] = { "ISDN_CMD_IOCTL",
                            "ISDN_CMD_DIAL",
                            "ISDN_CMD_ACCEPTB",
                            "ISDN_CMD_ACCEPTB",
                            "ISDN_CMD_HANGUP",
                            "ISDN_CMD_CLREAZ",
                            "ISDN_CMD_SETEAZ",
                            NULL,
                            NULL,
                            NULL,
                            "ISDN_CMD_SETL2",
                            NULL,
                            "ISDN_CMD_SETL3",
                            NULL,
                            NULL,
                            NULL,
                            NULL,
                            NULL, };
 
/*
 * Translates ISDN4Linux protocol codes to strings for debug messages
 */
static char *l3protos[] = { "ISDN_PROTO_L3_TRANS" };
static char *l2protos[] = { "ISDN_PROTO_L2_X75I",
                            "ISDN_PROTO_L2_X75UI",
                            "ISDN_PROTO_L2_X75BUI",
                            "ISDN_PROTO_L2_HDLC",
                            "ISDN_PROTO_L2_TRANS" };
#endif
 
int get_card_from_id(int driver)
{
        int i;
 
        for(i = 0 ; i < cinst ; i++) {
                if(sc_adapter[i]->driverId == driver)
                        return i;
        }
        return -ENODEV;
}
 
/*
 * command
 */
 
int command(isdn_ctrl *cmd)
{
        int card;
 
        card = get_card_from_id(cmd->driver);
        if(!IS_VALID_CARD(card)) {
                pr_debug("Invalid param: %d is not a valid card id\n", card);
                return -ENODEV;
        }
 
        /*
         * Dispatch the command
         */
        switch(cmd->command) {
        case ISDN_CMD_IOCTL:
        {
                unsigned long   cmdptr;
                scs_ioctl       ioc;
 
                memcpy(&cmdptr, cmd->parm.num, sizeof(unsigned long));
                if (copy_from_user(&ioc, (scs_ioctl __user *)cmdptr,
                                   sizeof(scs_ioctl))) {
                        pr_debug("%s: Failed to verify user space 0x%lx\n",
                                sc_adapter[card]->devicename, cmdptr);
                        return -EFAULT;
                }
                return sc_ioctl(card, &ioc);
        }
        case ISDN_CMD_DIAL:
                return dial(card, cmd->arg, cmd->parm.setup);
        case ISDN_CMD_HANGUP:
                return hangup(card, cmd->arg);
        case ISDN_CMD_ACCEPTD:
                return answer(card, cmd->arg);
        case ISDN_CMD_ACCEPTB:
                return acceptb(card, cmd->arg);
        case ISDN_CMD_CLREAZ:
                return clreaz(card, cmd->arg);
        case ISDN_CMD_SETEAZ:
                return seteaz(card, cmd->arg, cmd->parm.num);
        case ISDN_CMD_SETL2:
                return setl2(card, cmd->arg);
        case ISDN_CMD_SETL3:
                return setl3(card, cmd->arg);
        default:
                return -EINVAL;
        }
        return 0;
}
 
/*
 * start the onboard firmware
 */
int startproc(int card)
{
        int status;
 
        if(!IS_VALID_CARD(card)) {
                pr_debug("Invalid param: %d is not a valid card id\n", card);
                return -ENODEV;
        }
 
        /*
         * send start msg
         */
        status = sendmessage(card, CMPID,cmReqType2,
                          cmReqClass0,
                          cmReqStartProc,
                          0,0,NULL);
        pr_debug("%s: Sent startProc\n", sc_adapter[card]->devicename);
 
        return status;
}
 
 
/*
 * Dials the number passed in
 */
static int dial(int card, unsigned long channel, setup_parm setup)
{
        int status;
        char Phone[48];
 
        if(!IS_VALID_CARD(card)) {
                pr_debug("Invalid param: %d is not a valid card id\n", card);
                return -ENODEV;
        }
 
        /*extract ISDN number to dial from eaz/msn string*/
        strcpy(Phone,setup.phone);
 
        /*send the connection message*/
        status = sendmessage(card, CEPID,ceReqTypePhy,
                                ceReqClass1,
                                ceReqPhyConnect,
                                (unsigned char) channel+1,
                                strlen(Phone),
                                (unsigned int *) Phone);
 
        pr_debug("%s: Dialing %s on channel %lu\n",
                sc_adapter[card]->devicename, Phone, channel+1);
 
        return status;
}
 
/*
 * Answer an incoming call
 */
static int answer(int card, unsigned long channel)
{
        if(!IS_VALID_CARD(card)) {
                pr_debug("Invalid param: %d is not a valid card id\n", card);
                return -ENODEV;
        }
 
        if(setup_buffers(card, channel+1)) {
                hangup(card, channel+1);
                return -ENOBUFS;
        }
 
        indicate_status(card, ISDN_STAT_BCONN,channel,NULL);
        pr_debug("%s: Answered incoming call on channel %lu\n",
                sc_adapter[card]->devicename, channel+1);
        return 0;
}
 
/*
 * Hangup up the call on specified channel
 */
static int hangup(int card, unsigned long channel)
{
        int status;
 
        if(!IS_VALID_CARD(card)) {
                pr_debug("Invalid param: %d is not a valid card id\n", card);
                return -ENODEV;
        }
 
        status = sendmessage(card, CEPID, ceReqTypePhy,
                                                 ceReqClass1,
                                                 ceReqPhyDisconnect,
                                                 (unsigned char) channel+1,
                                                 0,
                                                 NULL);
        pr_debug("%s: Sent HANGUP message to channel %lu\n",
                sc_adapter[card]->devicename, channel+1);
        return status;
}
 
/*
 * Set the layer 2 protocol (X.25, HDLC, Raw)
 */
static int setl2(int card, unsigned long arg)
{
        int status =0;
        int protocol,channel;
 
        if(!IS_VALID_CARD(card)) {
                pr_debug("Invalid param: %d is not a valid card id\n", card);
                return -ENODEV;
        }
        protocol = arg >> 8;
        channel = arg & 0xff;
        sc_adapter[card]->channel[channel].l2_proto = protocol;
 
        /*
         * check that the adapter is also set to the correct protocol
         */
        pr_debug("%s: Sending GetFrameFormat for channel %d\n",
                sc_adapter[card]->devicename, channel+1);
        status = sendmessage(card, CEPID, ceReqTypeCall,
                                ceReqClass0,
                                ceReqCallGetFrameFormat,
                                (unsigned char)channel+1,
                                1,
                                (unsigned int *) protocol);
        if(status)
                return status;
        return 0;
}
 
/*
 * Set the layer 3 protocol
 */
static int setl3(int card, unsigned long channel)
{
        int protocol = channel >> 8;
 
        if(!IS_VALID_CARD(card)) {
                pr_debug("Invalid param: %d is not a valid card id\n", card);
                return -ENODEV;
        }
 
        sc_adapter[card]->channel[channel].l3_proto = protocol;
        return 0;
}
 
static int acceptb(int card, unsigned long channel)
{
        if(!IS_VALID_CARD(card)) {
                pr_debug("Invalid param: %d is not a valid card id\n", card);
                return -ENODEV;
        }
 
        if(setup_buffers(card, channel+1))
        {
                hangup(card, channel+1);
                return -ENOBUFS;
        }
 
        pr_debug("%s: B-Channel connection accepted on channel %lu\n",
                sc_adapter[card]->devicename, channel+1);
        indicate_status(card, ISDN_STAT_BCONN, channel, NULL);
        return 0;
}
 
static int clreaz(int card, unsigned long arg)
{
        if(!IS_VALID_CARD(card)) {
                pr_debug("Invalid param: %d is not a valid card id\n", card);
                return -ENODEV;
        }
 
        strcpy(sc_adapter[card]->channel[arg].eazlist, "");
        sc_adapter[card]->channel[arg].eazclear = 1;
        pr_debug("%s: EAZ List cleared for channel %lu\n",
                sc_adapter[card]->devicename, arg+1);
        return 0;
}
 
static int seteaz(int card, unsigned long arg, char *num)
{
        if(!IS_VALID_CARD(card)) {
                pr_debug("Invalid param: %d is not a valid card id\n", card);
                return -ENODEV;
        }
 
        strcpy(sc_adapter[card]->channel[arg].eazlist, num);
        sc_adapter[card]->channel[arg].eazclear = 0;
        pr_debug("%s: EAZ list for channel %lu set to: %s\n",
                sc_adapter[card]->devicename, arg+1,
                sc_adapter[card]->channel[arg].eazlist);
        return 0;
}
 
int reset(int card)
{
        unsigned long flags;
 
        if(!IS_VALID_CARD(card)) {
                pr_debug("Invalid param: %d is not a valid card id\n", card);
                return -ENODEV;
        }
 
        indicate_status(card, ISDN_STAT_STOP, 0, NULL);
 
        if(sc_adapter[card]->EngineUp) {
                del_timer(&sc_adapter[card]->stat_timer);
        }
 
        sc_adapter[card]->EngineUp = 0;
 
        spin_lock_irqsave(&sc_adapter[card]->lock, flags);
        init_timer(&sc_adapter[card]->reset_timer);
        sc_adapter[card]->reset_timer.function = sc_check_reset;
        sc_adapter[card]->reset_timer.data = card;
        sc_adapter[card]->reset_timer.expires = jiffies + CHECKRESET_TIME;
        add_timer(&sc_adapter[card]->reset_timer);
        spin_unlock_irqrestore(&sc_adapter[card]->lock, flags);
 
        outb(0x1,sc_adapter[card]->ioport[SFT_RESET]);
 
        pr_debug("%s: Adapter Reset\n", sc_adapter[card]->devicename);
        return 0;
}
 
void flushreadfifo (int card)
{
        while(inb(sc_adapter[card]->ioport[FIFO_STATUS]) & RF_HAS_DATA)
                inb(sc_adapter[card]->ioport[FIFO_READ]);
}

Browse

Tools

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [isdn/] [sc/] [command.c] - Blame information for rev 62

Line No.	Rev	Author	Line
1	62	marcus.erl	`/* $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			`}`