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