include/net/irda/irda_device.h

   1 /*********************************************************************
   2  *
   3  * Filename:      irda_device.h
   4  * Version:       0.9
   5  * Description:   Contains various declarations used by the drivers
   6  * Status:        Experimental.
   7  * Author:        Dag Brattli <dagb@cs.uit.no>
   8  * Created at:    Tue Apr 14 12:41:42 1998
   9  * Modified at:   Mon Mar 20 09:08:57 2000
  10  * Modified by:   Dag Brattli <dagb@cs.uit.no>
  11  *
  12  *     Copyright (c) 1999-2000 Dag Brattli, All Rights Reserved.
  13  *     Copyright (c) 1998 Thomas Davis, <ratbert@radiks.net>,
  14  *
  15  *     This program is free software; you can redistribute it and/or
  16  *     modify it under the terms of the GNU General Public License as
  17  *     published by the Free Software Foundation; either version 2 of
  18  *     the License, or (at your option) any later version.
  19  *
  20  *     This program is distributed in the hope that it will be useful,
  21  *     but WITHOUT ANY WARRANTY; without even the implied warranty of
  22  *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  23  *     GNU General Public License for more details.
  24  *
  25  *     You should have received a copy of the GNU General Public License
  26  *     along with this program; if not, write to the Free Software
  27  *     Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  28  *     MA 02111-1307 USA
  29  *
  30  ********************************************************************/
  31
  32 #ifndef IRDA_DEVICE_H
  33 #define IRDA_DEVICE_H
  34
  35 #include <linux/tty.h>
  36 #include <linux/netdevice.h>
  37 #include <linux/spinlock.h>
  38 #include <linux/irda.h>
  39
  40 #include <net/irda/irda.h>
  41 #include <net/irda/qos.h>
  42 #include <net/irda/irqueue.h>
  43 #include <net/irda/irlap_frame.h>
  44
  45 /* Some non-standard interface flags (should not conflict with any in if.h) */
  46 #define IFF_SIR         0x0001 /* Supports SIR speeds */
  47 #define IFF_MIR         0x0002 /* Supports MIR speeds */
  48 #define IFF_FIR         0x0004 /* Supports FIR speeds */
  49 #define IFF_VFIR        0x0008 /* Supports VFIR speeds */
  50 #define IFF_PIO         0x0010 /* Supports PIO transfer of data */
  51 #define IFF_DMA         0x0020 /* Supports DMA transfer of data */
  52 #define IFF_SHM         0x0040 /* Supports shared memory data transfers */
  53 #define IFF_DONGLE      0x0080 /* Interface has a dongle attached */
  54 #define IFF_AIR         0x0100 /* Supports Advanced IR (AIR) standards */
  55
  56 #define IO_XMIT 0x01
  57 #define IO_RECV 0x02
  58
  59 typedef enum {
  60         IRDA_IRLAP, /* IrDA mode, and deliver to IrLAP */
  61         IRDA_RAW,   /* IrDA mode */
  62         SHARP_ASK,
  63         TV_REMOTE,  /* Also known as Consumer Electronics IR */
  64 } INFRARED_MODE;
  65
  66 typedef enum {
  67         IRDA_TASK_INIT,        /* All tasks are initialized with this state */
  68         IRDA_TASK_DONE,        /* Signals that the task is finished */
  69         IRDA_TASK_WAIT,
  70         IRDA_TASK_WAIT1,
  71         IRDA_TASK_WAIT2,
  72         IRDA_TASK_WAIT3,
  73         IRDA_TASK_CHILD_INIT,  /* Initializing child task */
  74         IRDA_TASK_CHILD_WAIT,  /* Waiting for child task to finish */
  75         IRDA_TASK_CHILD_DONE   /* Child task is finished */
  76 } IRDA_TASK_STATE;
  77
  78 struct irda_task;
  79 typedef int (*IRDA_TASK_CALLBACK) (struct irda_task *task);
  80
  81 struct irda_task {
  82         irda_queue_t q;
  83         magic_t magic;
  84
  85         IRDA_TASK_STATE state;
  86         IRDA_TASK_CALLBACK function;
  87         IRDA_TASK_CALLBACK finished;
  88
  89         struct irda_task *parent;
  90         struct timer_list timer;
  91
  92         void *instance; /* Instance being called */
  93         void *param;    /* Parameter to be used by instance */
  94 };
  95
  96 /* Dongle info */
  97 struct dongle_reg;
  98 typedef struct {
  99         struct dongle_reg *issue;     /* Registration info */
 100         struct net_device *dev;           /* Device we are attached to */
 101         struct irda_task *speed_task; /* Task handling speed change */
 102         struct irda_task *reset_task; /* Task handling reset */
 103         __u32 speed;                  /* Current speed */
 104
 105         /* Callbacks to the IrDA device driver */
 106         int (*set_mode)(struct net_device *, int mode);
 107         int (*read)(struct net_device *dev, __u8 *buf, int len);
 108         int (*write)(struct net_device *dev, __u8 *buf, int len);
 109         int (*set_dtr_rts)(struct net_device *dev, int dtr, int rts);
 110 } dongle_t;
 111
 112 /* Dongle registration info */
 113 struct dongle_reg {
 114         irda_queue_t q;         /* Must be first */
 115         IRDA_DONGLE type;
 116
 117         void (*open)(dongle_t *dongle, struct qos_info *qos);
 118         void (*close)(dongle_t *dongle);
 119         int  (*reset)(struct irda_task *task);
 120         int  (*change_speed)(struct irda_task *task);
 121 };
 122
 123 /* Chip specific info */
 124 typedef struct {
 125         int cfg_base;         /* Config register IO base */
 126         int sir_base;         /* SIR IO base */
 127         int fir_base;         /* FIR IO base */
 128         int mem_base;         /* Shared memory base */
 129         int sir_ext;          /* Length of SIR iobase */
 130         int fir_ext;          /* Length of FIR iobase */
 131         int irq, irq2;        /* Interrupts used */
 132         int dma, dma2;        /* DMA channel(s) used */
 133         int fifo_size;        /* FIFO size */
 134         int irqflags;         /* interrupt flags (ie, SA_SHIRQ|SA_INTERRUPT) */
 135         int direction;        /* Link direction, used by some FIR drivers */
 136         int enabled;          /* Powered on? */
 137         int suspended;        /* Suspended by APM */
 138         __u32 speed;          /* Currently used speed */
 139         __u32 new_speed;      /* Speed we must change to when Tx is finished */
 140         int dongle_id;        /* Dongle or transceiver currently used */
 141 } chipio_t;
 142
 143 /* IO buffer specific info (inspired by struct sk_buff) */
 144 typedef struct {
 145         int state;            /* Receiving state (transmit state not used) */
 146         int in_frame;         /* True if receiving frame */
 147
 148         __u8 *head;           /* start of buffer */
 149         __u8 *data;           /* start of data in buffer */
 150         __u8 *tail;           /* end of data in buffer */
 151
 152         int len;              /* length of data */
 153         int truesize;         /* total size of buffer */
 154         __u16 fcs;
 155 } iobuff_t;
 156
 157 /* Function prototypes */
 158 int  irda_device_init(void);
 159 void irda_device_cleanup(void);
 160
 161 /* Interface to be uses by IrLAP */
 162 void irda_device_set_media_busy(struct net_device *dev, int status);
 163 int  irda_device_is_media_busy(struct net_device *dev);
 164 int  irda_device_is_receiving(struct net_device *dev);
 165
 166 /* Interface for internal use */
 167 int  irda_device_txqueue_empty(struct net_device *dev);
 168 int  irda_device_set_raw_mode(struct net_device* self, int status);
 169 int  irda_device_set_dtr_rts(struct net_device *dev, int dtr, int rts);
 170 int  irda_device_change_speed(struct net_device *dev, __u32 speed);
 171 int  irda_device_setup(struct net_device *dev);
 172
 173 /* Dongle interface */
 174 void irda_device_unregister_dongle(struct dongle_reg *dongle);
 175 int  irda_device_register_dongle(struct dongle_reg *dongle);
 176 dongle_t *irda_device_dongle_init(struct net_device *dev, int type);
 177 int irda_device_dongle_cleanup(dongle_t *dongle);
 178
 179 void setup_dma(int channel, char *buffer, int count, int mode);
 180
 181 void irda_task_delete(struct irda_task *task);
 182 int  irda_task_kick(struct irda_task *task);
 183 struct irda_task *irda_task_execute(void *instance,
 184                                     IRDA_TASK_CALLBACK function,
 185                                     IRDA_TASK_CALLBACK finished,
 186                                     struct irda_task *parent, void *param);
 187 void irda_task_next_state(struct irda_task *task, IRDA_TASK_STATE state);
 188
 189 extern const char *infrared_mode[];
 190
 191 /*
 192  * Function irda_get_mtt (skb)
 193  *
 194  *    Utility function for getting the minimum turnaround time out of
 195  *    the skb, where it has been hidden in the cb field.
 196  */
 197 #define irda_get_mtt(skb) (                                                 \
 198         IRDA_MIN(10000,                                                     \
 199                   (((struct irda_skb_cb *) skb->cb)->magic == LAP_MAGIC) ?  \
 200                           ((struct irda_skb_cb *)(skb->cb))->mtt : 10000    \
 201                  )                                                          \
 202 )
 203
 204 #if 0
 205 extern inline __u16 irda_get_mtt(struct sk_buff *skb)
 206 {
 207         __u16 mtt;
 208
 209         if (((struct irda_skb_cb *)(skb->cb))->magic != LAP_MAGIC)
 210                 mtt = 10000;
 211         else
 212                 mtt = ((struct irda_skb_cb *)(skb->cb))->mtt;
 213
 214         ASSERT(mtt <= 10000, return 10000;);
 215
 216         return mtt;
 217 }
 218 #endif
 219
 220 /*
 221  * Function irda_get_next_speed (skb)
 222  *
 223  *    Extract the speed that should be set *after* this frame from the skb
 224  *
 225  * Note : return -1 for user space frames
 226  */
 227 #define irda_get_next_speed(skb) (                                              \
 228         (((struct irda_skb_cb*) skb->cb)->magic == LAP_MAGIC) ?         \
 229                   ((struct irda_skb_cb *)(skb->cb))->next_speed : -1    \
 230 )
 231
 232 #if 0
 233 extern inline __u32 irda_get_next_speed(struct sk_buff *skb)
 234 {
 235         __u32 speed;
 236
 237         if (((struct irda_skb_cb *)(skb->cb))->magic != LAP_MAGIC)
 238                 speed = -1;
 239         else
 240                 speed = ((struct irda_skb_cb *)(skb->cb))->next_speed;
 241
 242         return speed;
 243 }
 244 #endif
 245
 246 /*
 247  * Function irda_get_next_xbofs (skb)
 248  *
 249  *    Extract the xbofs that should be set for this frame from the skb
 250  *
 251  * Note : default to 10 for user space frames
 252  */
 253 #define irda_get_xbofs(skb) (                                           \
 254         (((struct irda_skb_cb*) skb->cb)->magic == LAP_MAGIC) ?         \
 255                   ((struct irda_skb_cb *)(skb->cb))->xbofs : 10         \
 256 )
 257
 258 /*
 259  * Function irda_get_next_xbofs (skb)
 260  *
 261  *    Extract the xbofs that should be set *after* this frame from the skb
 262  *
 263  * Note : return -1 for user space frames
 264  */
 265 #define irda_get_next_xbofs(skb) (                                              \
 266         (((struct irda_skb_cb*) skb->cb)->magic == LAP_MAGIC) ?         \
 267                   ((struct irda_skb_cb *)(skb->cb))->next_xbofs : -1    \
 268 )
 269
 270 #endif /* IRDA_DEVICE_H */
 271
 272