i386/linux-2.3.21/drivers/net/irda/girbil.c

   1 /*********************************************************************
   2  *
   3  * Filename:      girbil.c
   4  * Version:       1.1
   5  * Description:   Implementation for the Greenwich GIrBIL dongle
   6  * Status:        Experimental.
   7  * Author:        Dag Brattli <dagb@cs.uit.no>
   8  * Created at:    Sat Feb  6 21:02:33 1999
   9  * Modified at:   Sun Jul 18 12:09:26 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  *     Neither Dag Brattli nor University of Tromsø admit liability nor
  20  *     provide warranty for any of this software. This material is
  21  *     provided "AS-IS" and at no charge.
  22  *
  23  ********************************************************************/
  24
  25 #include <linux/module.h>
  26 #include <linux/delay.h>
  27 #include <linux/tty.h>
  28 #include <linux/sched.h>
  29 #include <linux/init.h>
  30
  31 #include <net/irda/irda.h>
  32 #include <net/irda/irmod.h>
  33 #include <net/irda/irda_device.h>
  34 #include <net/irda/irtty.h>
  35 #include <net/irda/dongle.h>
  36
  37 static void girbil_reset(struct irda_device *dev);
  38 static void girbil_open(struct irda_device *dev, int type);
  39 static void girbil_close(struct irda_device *dev);
  40 static void girbil_change_speed(struct irda_device *dev, __u32 speed);
  41 static void girbil_init_qos(struct irda_device *idev, struct qos_info *qos);
  42
  43 /* Control register 1 */
  44 #define GIRBIL_TXEN    0x01 /* Enable transmitter */
  45 #define GIRBIL_RXEN    0x02 /* Enable receiver */
  46 #define GIRBIL_ECAN    0x04 /* Cancel self emmited data */
  47 #define GIRBIL_ECHO    0x08 /* Echo control characters */
  48
  49 /* LED Current Register (0x2) */
  50 #define GIRBIL_HIGH    0x20
  51 #define GIRBIL_MEDIUM  0x21
  52 #define GIRBIL_LOW     0x22
  53
  54 /* Baud register (0x3) */
  55 #define GIRBIL_2400    0x30
  56 #define GIRBIL_4800    0x31
  57 #define GIRBIL_9600    0x32
  58 #define GIRBIL_19200   0x33
  59 #define GIRBIL_38400   0x34
  60 #define GIRBIL_57600   0x35
  61 #define GIRBIL_115200  0x36
  62
  63 /* Mode register (0x4) */
  64 #define GIRBIL_IRDA    0x40
  65 #define GIRBIL_ASK     0x41
  66
  67 /* Control register 2 (0x5) */
  68 #define GIRBIL_LOAD    0x51 /* Load the new baud rate value */
  69
  70 static struct dongle dongle = {
  71         GIRBIL_DONGLE,
  72         girbil_open,
  73         girbil_close,
  74         girbil_reset,
  75         girbil_change_speed,
  76         girbil_init_qos,
  77 };
  78
  79 int __init girbil_init(void)
  80 {
  81         return irda_device_register_dongle(&dongle);
  82 }
  83
  84 void girbil_cleanup(void)
  85 {
  86         irda_device_unregister_dongle(&dongle);
  87 }
  88
  89 static void girbil_open(struct irda_device *idev, int type)
  90 {
  91         strcat(idev->description, " <-> girbil");
  92
  93         idev->io.dongle_id = type;
  94         idev->flags |= IFF_DONGLE;
  95
  96         MOD_INC_USE_COUNT;
  97 }
  98
  99 static void girbil_close(struct irda_device *idev)
 100 {
 101         /* Power off dongle */
 102         irda_device_set_dtr_rts(idev, FALSE, FALSE);
 103
 104         MOD_DEC_USE_COUNT;
 105 }
 106
 107 /*
 108  * Function girbil_change_speed (dev, speed)
 109  *
 110  *    Set the speed for the Girbil type dongle. Warning, this
 111  *    function must be called with a process context!
 112  *
 113  */
 114 static void girbil_change_speed(struct irda_device *idev, __u32 speed)
 115 {
 116         __u8 control[2];
 117
 118         ASSERT(idev != NULL, return;);
 119         ASSERT(idev->magic == IRDA_DEVICE_MAGIC, return;);
 120
 121         switch (speed) {
 122         case 9600:
 123         default:
 124                 control[0] = GIRBIL_9600;
 125                 break;
 126         case 19200:
 127                 control[0] = GIRBIL_19200;
 128                 break;
 129         case 34800:
 130                 control[0] = GIRBIL_38400;
 131                 break;
 132         case 57600:
 133                 control[0] = GIRBIL_57600;
 134                 break;
 135         case 115200:
 136                 control[0] = GIRBIL_115200;
 137                 break;
 138         }
 139         control[1] = GIRBIL_LOAD;
 140
 141         /* Need to reset the dongle and go to 9600 bps before programming */
 142         girbil_reset(idev);
 143
 144         /* Set DTR and Clear RTS to enter command mode */
 145         irda_device_set_dtr_rts(idev, FALSE, TRUE);
 146
 147         /* Write control bytes */
 148         irda_device_raw_write(idev, control, 2);
 149
 150         current->state = TASK_INTERRUPTIBLE;
 151         schedule_timeout(MSECS_TO_JIFFIES(100));
 152
 153         /* Go back to normal mode */
 154         irda_device_set_dtr_rts(idev, TRUE, TRUE);
 155 }
 156
 157 /*
 158  * Function girbil_reset (driver)
 159  *
 160  *      This function resets the girbil dongle. Warning, this function
 161  *      must be called with a process context!!
 162  *
 163  *      Algorithm:
 164  *        0. set RTS, and wait at least 5 ms
 165  *        1. clear RTS
 166  */
 167 void girbil_reset(struct irda_device *idev)
 168 {
 169         __u8 control = GIRBIL_TXEN | GIRBIL_RXEN;
 170
 171         ASSERT(idev != NULL, return;);
 172         ASSERT(idev->magic == IRDA_DEVICE_MAGIC, return;);
 173
 174         /* Make sure the IrDA chip also goes to defalt speed */
 175         if (idev->change_speed)
 176                 idev->change_speed(idev, 9600);
 177
 178         /* Reset dongle */
 179         irda_device_set_dtr_rts(idev, TRUE, FALSE);
 180
 181         /* Sleep at least 5 ms */
 182         current->state = TASK_INTERRUPTIBLE;
 183         schedule_timeout(MSECS_TO_JIFFIES(10));
 184
 185         /* Set DTR and clear RTS to enter command mode */
 186         irda_device_set_dtr_rts(idev, FALSE, TRUE);
 187
 188         current->state = TASK_INTERRUPTIBLE;
 189         schedule_timeout(MSECS_TO_JIFFIES(10));
 190
 191         /* Write control byte */
 192         irda_device_raw_write(idev, &control, 1);
 193
 194         current->state = TASK_INTERRUPTIBLE;
 195         schedule_timeout(MSECS_TO_JIFFIES(20));
 196
 197         /* Go back to normal mode */
 198         irda_device_set_dtr_rts(idev, TRUE, TRUE);
 199 }
 200
 201 /*
 202  * Function girbil_init_qos (qos)
 203  *
 204  *    Initialize QoS capabilities
 205  *
 206  */
 207 static void girbil_init_qos(struct irda_device *idev, struct qos_info *qos)
 208 {
 209         qos->baud_rate.bits &= IR_9600|IR_19200|IR_38400|IR_57600|IR_115200;
 210         qos->min_turn_time.bits &= 0x03;
 211 }
 212
 213 #ifdef MODULE
 214
 215 MODULE_AUTHOR("Dag Brattli <dagb@cs.uit.no>");
 216 MODULE_DESCRIPTION("Greenwich GIrBIL dongle driver");
 217
 218 /*
 219  * Function init_module (void)
 220  *
 221  *    Initialize Girbil module
 222  *
 223  */
 224 int init_module(void)
 225 {
 226         return girbil_init();
 227 }
 228
 229 /*
 230  * Function cleanup_module (void)
 231  *
 232  *    Cleanup Girbil module
 233  *
 234  */
 235 void cleanup_module(void)
 236 {
 237         girbil_cleanup();
 238 }
 239
 240 #endif /* MODULE */