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  *     Copyright (c) 2000-2002 Jean Tourrilhes <jt@hpl.hp.com>
  15  *
  16  *     This program is free software; you can redistribute it and/or
  17  *     modify it under the terms of the GNU General Public License as
  18  *     published by the Free Software Foundation; either version 2 of
  19  *     the License, or (at your option) any later version.
  20  *
  21  *     This program is distributed in the hope that it will be useful,
  22  *     but WITHOUT ANY WARRANTY; without even the implied warranty of
  23  *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  24  *     GNU General Public License for more details.
  25  *
  26  *     You should have received a copy of the GNU General Public License
  27  *     along with this program; if not, write to the Free Software
  28  *     Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  29  *     MA 02111-1307 USA
  30  *
  31  ********************************************************************/
  32
  33 /*
  34  * This header contains all the IrDA definitions a driver really
  35  * needs, and therefore the driver should not need to include
  36  * any other IrDA headers - Jean II
  37  */
  38
  39 #ifndef IRDA_DEVICE_H
  40 #define IRDA_DEVICE_H
  41
  42 #include <linux/tty.h>
  43 #include <linux/netdevice.h>
  44 #include <linux/spinlock.h>
  45 #include <linux/skbuff.h>               /* struct sk_buff */
  46 #include <linux/irda.h>
  47
  48 #include <net/pkt_sched.h>
  49 #include <net/irda/irda.h>
  50 #include <net/irda/qos.h>               /* struct qos_info */
  51 #include <net/irda/irqueue.h>           /* irda_queue_t */
  52
  53 /* A few forward declarations (to make compiler happy) */
  54 struct irlap_cb;
  55
  56 /* Some non-standard interface flags (should not conflict with any in if.h) */
  57 #define IFF_SIR         0x0001 /* Supports SIR speeds */
  58 #define IFF_MIR         0x0002 /* Supports MIR speeds */
  59 #define IFF_FIR         0x0004 /* Supports FIR speeds */
  60 #define IFF_VFIR        0x0008 /* Supports VFIR speeds */
  61 #define IFF_PIO         0x0010 /* Supports PIO transfer of data */
  62 #define IFF_DMA         0x0020 /* Supports DMA transfer of data */
  63 #define IFF_SHM         0x0040 /* Supports shared memory data transfers */
  64 #define IFF_DONGLE      0x0080 /* Interface has a dongle attached */
  65 #define IFF_AIR         0x0100 /* Supports Advanced IR (AIR) standards */
  66
  67 #define IO_XMIT 0x01
  68 #define IO_RECV 0x02
  69
  70 typedef enum {
  71         IRDA_IRLAP, /* IrDA mode, and deliver to IrLAP */
  72         IRDA_RAW,   /* IrDA mode */
  73         SHARP_ASK,
  74         TV_REMOTE,  /* Also known as Consumer Electronics IR */
  75 } INFRARED_MODE;
  76
  77 typedef enum {
  78         IRDA_TASK_INIT,        /* All tasks are initialized with this state */
  79         IRDA_TASK_DONE,        /* Signals that the task is finished */
  80         IRDA_TASK_WAIT,
  81         IRDA_TASK_WAIT1,
  82         IRDA_TASK_WAIT2,
  83         IRDA_TASK_WAIT3,
  84         IRDA_TASK_CHILD_INIT,  /* Initializing child task */
  85         IRDA_TASK_CHILD_WAIT,  /* Waiting for child task to finish */
  86         IRDA_TASK_CHILD_DONE   /* Child task is finished */
  87 } IRDA_TASK_STATE;
  88
  89 struct irda_task;
  90 typedef int (*IRDA_TASK_CALLBACK) (struct irda_task *task);
  91
  92 struct irda_task {
  93         irda_queue_t q;
  94         magic_t magic;
  95
  96         IRDA_TASK_STATE state;
  97         IRDA_TASK_CALLBACK function;
  98         IRDA_TASK_CALLBACK finished;
  99
 100         struct irda_task *parent;
 101         struct timer_list timer;
 102
 103         void *instance; /* Instance being called */
 104         void *param;    /* Parameter to be used by instance */
 105 };
 106
 107 /* Dongle info */
 108 struct dongle_reg;
 109 typedef struct {
 110         struct dongle_reg *issue;     /* Registration info */
 111         struct net_device *dev;           /* Device we are attached to */
 112         struct irda_task *speed_task; /* Task handling speed change */
 113         struct irda_task *reset_task; /* Task handling reset */
 114         __u32 speed;                  /* Current speed */
 115
 116         /* Callbacks to the IrDA device driver */
 117         int (*set_mode)(struct net_device *, int mode);
 118         int (*read)(struct net_device *dev, __u8 *buf, int len);
 119         int (*write)(struct net_device *dev, __u8 *buf, int len);
 120         int (*set_dtr_rts)(struct net_device *dev, int dtr, int rts);
 121 } dongle_t;
 122
 123 /* Dongle registration info */
 124 struct dongle_reg {
 125         irda_queue_t q;         /* Must be first */
 126         IRDA_DONGLE type;
 127
 128         void (*open)(dongle_t *dongle, struct qos_info *qos);
 129         void (*close)(dongle_t *dongle);
 130         int  (*reset)(struct irda_task *task);
 131         int  (*change_speed)(struct irda_task *task);
 132         struct module *owner;
 133 };
 134
 135 /*
 136  * Per-packet information we need to hide inside sk_buff
 137  * (must not exceed 48 bytes, check with struct sk_buff)
 138  */
 139 struct irda_skb_cb {
 140         magic_t magic;       /* Be sure that we can trust the information */
 141         __u32   next_speed;  /* The Speed to be set *after* this frame */
 142         __u16   mtt;         /* Minimum turn around time */
 143         __u16   xbofs;       /* Number of xbofs required, used by SIR mode */
 144         __u16   next_xbofs;  /* Number of xbofs required *after* this frame */
 145         void    *context;    /* May be used by drivers */
 146         void    (*destructor)(struct sk_buff *skb); /* Used for flow control */
 147         __u16   xbofs_delay; /* Number of xbofs used for generating the mtt */
 148         __u8    line;        /* Used by IrCOMM in IrLPT mode */
 149 };
 150
 151 /* Chip specific info */
 152 typedef struct {
 153         int cfg_base;         /* Config register IO base */
 154         int sir_base;         /* SIR IO base */
 155         int fir_base;         /* FIR IO base */
 156         int mem_base;         /* Shared memory base */
 157         int sir_ext;          /* Length of SIR iobase */
 158         int fir_ext;          /* Length of FIR iobase */
 159         int irq, irq2;        /* Interrupts used */
 160         int dma, dma2;        /* DMA channel(s) used */
 161         int fifo_size;        /* FIFO size */
 162         int irqflags;         /* interrupt flags (ie, SA_SHIRQ|SA_INTERRUPT) */
 163         int direction;        /* Link direction, used by some FIR drivers */
 164         int enabled;          /* Powered on? */
 165         int suspended;        /* Suspended by APM */
 166         __u32 speed;          /* Currently used speed */
 167         __u32 new_speed;      /* Speed we must change to when Tx is finished */
 168         int dongle_id;        /* Dongle or transceiver currently used */
 169 } chipio_t;
 170
 171 /* IO buffer specific info (inspired by struct sk_buff) */
 172 typedef struct {
 173         int state;            /* Receiving state (transmit state not used) */
 174         int in_frame;         /* True if receiving frame */
 175
 176         __u8 *head;           /* start of buffer */
 177         __u8 *data;           /* start of data in buffer */
 178
 179         int len;              /* current length of data */
 180         int truesize;         /* total allocated size of buffer */
 181         __u16 fcs;
 182
 183         struct sk_buff *skb;    /* ZeroCopy Rx in async_unwrap_char() */
 184 } iobuff_t;
 185
 186 /* Maximum SIR frame (skb) that we expect to receive *unwrapped*.
 187  * Max LAP MTU (I field) is 2048 bytes max (IrLAP 1.1, chapt 6.6.5, p40).
 188  * Max LAP header is 2 bytes (for now).
 189  * Max CRC is 2 bytes at SIR, 4 bytes at FIR.
 190  * Need 1 byte for skb_reserve() to align IP header for IrLAN.
 191  * Add a few extra bytes just to be safe (buffer is power of two anyway)
 192  * Jean II */
 193 #define IRDA_SKB_MAX_MTU        2064
 194 /* Maximum SIR frame that we expect to send, wrapped (i.e. with XBOFS
 195  * and escaped characters on top of above). */
 196 #define IRDA_SIR_MAX_FRAME      4269
 197
 198 /* The SIR unwrapper async_unwrap_char() will use a Rx-copy-break mechanism
 199  * when using the optional ZeroCopy Rx, where only small frames are memcpy
 200  * to a smaller skb to save memory. This is the threshold under which copy
 201  * will happen (and over which it won't happen).
 202  * Some FIR drivers may use this #define as well...
 203  * This is the same value as various Ethernet drivers. - Jean II */
 204 #define IRDA_RX_COPY_THRESHOLD  256
 205
 206 /* Function prototypes */
 207 int  irda_device_init(void);
 208 void irda_device_cleanup(void);
 209
 210 /* IrLAP entry points used by the drivers.
 211  * We declare them here to avoid the driver pulling a whole bunch stack
 212  * headers they don't really need - Jean II */
 213 struct irlap_cb *irlap_open(struct net_device *dev, struct qos_info *qos,
 214                             const char *hw_name);
 215 void irlap_close(struct irlap_cb *self);
 216
 217 /* Interface to be uses by IrLAP */
 218 void irda_device_set_media_busy(struct net_device *dev, int status);
 219 int  irda_device_is_media_busy(struct net_device *dev);
 220 int  irda_device_is_receiving(struct net_device *dev);
 221
 222 /* Interface for internal use */
 223 static inline int irda_device_txqueue_empty(const struct net_device *dev)
 224 {
 225         return (skb_queue_len(&dev->qdisc->q) == 0);
 226 }
 227 int  irda_device_set_raw_mode(struct net_device* self, int status);
 228 int  irda_device_set_dtr_rts(struct net_device *dev, int dtr, int rts);
 229 int  irda_device_change_speed(struct net_device *dev, __u32 speed);
 230 struct net_device *alloc_irdadev(int sizeof_priv);
 231
 232 /* Dongle interface */
 233 void irda_device_unregister_dongle(struct dongle_reg *dongle);
 234 int  irda_device_register_dongle(struct dongle_reg *dongle);
 235 dongle_t *irda_device_dongle_init(struct net_device *dev, int type);
 236 int irda_device_dongle_cleanup(dongle_t *dongle);
 237
 238 #ifdef CONFIG_ISA
 239 void irda_setup_dma(int channel, char *buffer, int count, int mode);
 240 #endif
 241
 242 void irda_task_delete(struct irda_task *task);
 243 struct irda_task *irda_task_execute(void *instance,
 244                                     IRDA_TASK_CALLBACK function,
 245                                     IRDA_TASK_CALLBACK finished,
 246                                     struct irda_task *parent, void *param);
 247 void irda_task_next_state(struct irda_task *task, IRDA_TASK_STATE state);
 248
 249 /*
 250  * Function irda_get_mtt (skb)
 251  *
 252  *    Utility function for getting the minimum turnaround time out of
 253  *    the skb, where it has been hidden in the cb field.
 254  */
 255 static inline __u16 irda_get_mtt(const struct sk_buff *skb)
 256 {
 257         const struct irda_skb_cb *cb = (const struct irda_skb_cb *) skb->cb;
 258         return (cb->magic == LAP_MAGIC) ? cb->mtt : 10000;
 259 }
 260
 261 /*
 262  * Function irda_get_next_speed (skb)
 263  *
 264  *    Extract the speed that should be set *after* this frame from the skb
 265  *
 266  * Note : return -1 for user space frames
 267  */
 268 static inline __u32 irda_get_next_speed(const struct sk_buff *skb)
 269 {
 270         const struct irda_skb_cb *cb = (const struct irda_skb_cb *) skb->cb;
 271         return (cb->magic == LAP_MAGIC) ? cb->next_speed : -1;
 272 }
 273
 274 /*
 275  * Function irda_get_next_xbofs (skb)
 276  *
 277  *    Extract the xbofs that should be set for this frame from the skb
 278  *
 279  * Note : default to 10 for user space frames
 280  */
 281 static inline __u16 irda_get_xbofs(const struct sk_buff *skb)
 282 {
 283         const struct irda_skb_cb *cb = (const struct irda_skb_cb *) skb->cb;
 284         return (cb->magic == LAP_MAGIC) ? cb->xbofs : 10;
 285 }
 286
 287 /*
 288  * Function irda_get_next_xbofs (skb)
 289  *
 290  *    Extract the xbofs that should be set *after* this frame from the skb
 291  *
 292  * Note : return -1 for user space frames
 293  */
 294 static inline __u16 irda_get_next_xbofs(const struct sk_buff *skb)
 295 {
 296         const struct irda_skb_cb *cb = (const struct irda_skb_cb *) skb->cb;
 297         return (cb->magic == LAP_MAGIC) ? cb->next_xbofs : -1;
 298 }
 299 #endif /* IRDA_DEVICE_H */
 300
 301