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", __func__);
  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", __func__);
  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", __func__);
 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", __func__);
 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);