e1000: simplify case handling gigabit at half duplex
[linux-2.6] / drivers / net / irda / litelink-sir.c
1 /*********************************************************************
2  *                
3  * Filename:      litelink.c
4  * Version:       1.1
5  * Description:   Driver for the Parallax LiteLink dongle
6  * Status:        Stable
7  * Author:        Dag Brattli <dagb@cs.uit.no>
8  * Created at:    Fri May  7 12:50:33 1999
9  * Modified at:   Fri Dec 17 09:14:23 1999
10  * Modified by:   Dag Brattli <dagb@cs.uit.no>
11  * 
12  *     Copyright (c) 1999 Dag Brattli, All Rights Reserved.
13  *     
14  *     This program is free software; you can redistribute it and/or 
15  *     modify it under the terms of the GNU General Public License as 
16  *     published by the Free Software Foundation; either version 2 of 
17  *     the License, or (at your option) any later version.
18  * 
19  *     This program is distributed in the hope that it will be useful,
20  *     but WITHOUT ANY WARRANTY; without even the implied warranty of
21  *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22  *     GNU General Public License for more details.
23  * 
24  *     You should have received a copy of the GNU General Public License 
25  *     along with this program; if not, write to the Free Software 
26  *     Foundation, Inc., 59 Temple Place, Suite 330, Boston, 
27  *     MA 02111-1307 USA
28  *     
29  ********************************************************************/
30
31 /*
32  * Modified at:   Thu Jan 15 2003
33  * Modified by:   Eugene Crosser <crosser@average.org>
34  *
35  * Convert to "new" IRDA infrastructure for kernel 2.6
36  */
37
38 #include <linux/module.h>
39 #include <linux/delay.h>
40 #include <linux/init.h>
41
42 #include <net/irda/irda.h>
43
44 #include "sir-dev.h"
45
46 #define MIN_DELAY 25      /* 15 us, but wait a little more to be sure */
47 #define MAX_DELAY 10000   /* 1 ms */
48
49 static int litelink_open(struct sir_dev *dev);
50 static int litelink_close(struct sir_dev *dev);
51 static int litelink_change_speed(struct sir_dev *dev, unsigned speed);
52 static int litelink_reset(struct sir_dev *dev);
53
54 /* These are the baudrates supported - 9600 must be last one! */
55 static unsigned baud_rates[] = { 115200, 57600, 38400, 19200, 9600 };
56
57 static struct dongle_driver litelink = {
58         .owner          = THIS_MODULE,
59         .driver_name    = "Parallax LiteLink",
60         .type           = IRDA_LITELINK_DONGLE,
61         .open           = litelink_open,
62         .close          = litelink_close,
63         .reset          = litelink_reset,
64         .set_speed      = litelink_change_speed,
65 };
66
67 static int __init litelink_sir_init(void)
68 {
69         return irda_register_dongle(&litelink);
70 }
71
72 static void __exit litelink_sir_cleanup(void)
73 {
74         irda_unregister_dongle(&litelink);
75 }
76
77 static int litelink_open(struct sir_dev *dev)
78 {
79         struct qos_info *qos = &dev->qos;
80
81         IRDA_DEBUG(2, "%s()\n", __FUNCTION__);
82
83         /* Power up dongle */
84         sirdev_set_dtr_rts(dev, TRUE, TRUE);
85
86         /* Set the speeds we can accept */
87         qos->baud_rate.bits &= IR_115200|IR_57600|IR_38400|IR_19200|IR_9600;
88         qos->min_turn_time.bits = 0x7f; /* Needs 0.01 ms */
89         irda_qos_bits_to_value(qos);
90
91         /* irda thread waits 50 msec for power settling */
92
93         return 0;
94 }
95
96 static int litelink_close(struct sir_dev *dev)
97 {
98         IRDA_DEBUG(2, "%s()\n", __FUNCTION__);
99
100         /* Power off dongle */
101         sirdev_set_dtr_rts(dev, FALSE, FALSE);
102
103         return 0;
104 }
105
106 /*
107  * Function litelink_change_speed (task)
108  *
109  *    Change speed of the Litelink dongle. To cycle through the available 
110  *    baud rates, pulse RTS low for a few ms.  
111  */
112 static int litelink_change_speed(struct sir_dev *dev, unsigned speed)
113 {
114         int i;
115
116         IRDA_DEBUG(2, "%s()\n", __FUNCTION__);
117
118         /* dongle already reset by irda-thread - current speed (dongle and
119          * port) is the default speed (115200 for litelink!)
120          */
121
122         /* Cycle through avaiable baudrates until we reach the correct one */
123         for (i = 0; baud_rates[i] != speed; i++) {
124
125                 /* end-of-list reached due to invalid speed request */
126                 if (baud_rates[i] == 9600)
127                         break;
128
129                 /* Set DTR, clear RTS */
130                 sirdev_set_dtr_rts(dev, FALSE, TRUE);
131
132                 /* Sleep a minimum of 15 us */
133                 udelay(MIN_DELAY);
134
135                 /* Set DTR, Set RTS */
136                 sirdev_set_dtr_rts(dev, TRUE, TRUE);
137
138                 /* Sleep a minimum of 15 us */
139                 udelay(MIN_DELAY);
140         }
141
142         dev->speed = baud_rates[i];
143
144         /* invalid baudrate should not happen - but if, we return -EINVAL and
145          * the dongle configured for 9600 so the stack has a chance to recover
146          */
147
148         return (dev->speed == speed) ? 0 : -EINVAL;
149 }
150
151 /*
152  * Function litelink_reset (task)
153  *
154  *      Reset the Litelink type dongle.
155  *
156  */
157 static int litelink_reset(struct sir_dev *dev)
158 {
159         IRDA_DEBUG(2, "%s()\n", __FUNCTION__);
160
161         /* probably the power-up can be dropped here, but with only
162          * 15 usec delay it's not worth the risk unless somebody with
163          * the hardware confirms it doesn't break anything...
164          */
165
166         /* Power on dongle */
167         sirdev_set_dtr_rts(dev, TRUE, TRUE);
168
169         /* Sleep a minimum of 15 us */
170         udelay(MIN_DELAY);
171
172         /* Clear RTS to reset dongle */
173         sirdev_set_dtr_rts(dev, TRUE, FALSE);
174
175         /* Sleep a minimum of 15 us */
176         udelay(MIN_DELAY);
177
178         /* Go back to normal mode */
179         sirdev_set_dtr_rts(dev, TRUE, TRUE);
180
181         /* Sleep a minimum of 15 us */
182         udelay(MIN_DELAY);
183
184         /* This dongles speed defaults to 115200 bps */
185         dev->speed = 115200;
186
187         return 0;
188 }
189
190 MODULE_AUTHOR("Dag Brattli <dagb@cs.uit.no>");
191 MODULE_DESCRIPTION("Parallax Litelink dongle driver");  
192 MODULE_LICENSE("GPL");
193 MODULE_ALIAS("irda-dongle-5"); /* IRDA_LITELINK_DONGLE */
194
195 /*
196  * Function init_module (void)
197  *
198  *    Initialize Litelink module
199  *
200  */
201 module_init(litelink_sir_init);
202
203 /*
204  * Function cleanup_module (void)
205  *
206  *    Cleanup Litelink module
207  *
208  */
209 module_exit(litelink_sir_cleanup);