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