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#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) */ 55struct 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 71typedef enum { 72 IRDA_IRLAP, /* IrDA mode, and deliver to IrLAP */ 73 IRDA_RAW, /* IrDA mode */ 74 SHARP_ASK, 75 TV_REMOTE, /* Also known as Consumer Electronics IR */ 76} INFRARED_MODE; 77 78typedef enum { 79 IRDA_TASK_INIT, /* All tasks are initialized with this state */ 80 IRDA_TASK_DONE, /* Signals that the task is finished */ 81 IRDA_TASK_WAIT, 82 IRDA_TASK_WAIT1, 83 IRDA_TASK_WAIT2, 84 IRDA_TASK_WAIT3, 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 */ 88} IRDA_TASK_STATE; 89 90struct irda_task; 91typedef int (*IRDA_TASK_CALLBACK) (struct irda_task *task); 92 93struct irda_task { 94 irda_queue_t q; 95 magic_t magic; 96 97 IRDA_TASK_STATE state; 98 IRDA_TASK_CALLBACK function; 99 IRDA_TASK_CALLBACK finished; 100 101 struct irda_task *parent; 102 struct timer_list timer; 103 104 void *instance; /* Instance being called */ 105 void *param; /* Parameter to be used by instance */ 106}; 107 108/* Dongle info */ 109struct dongle_reg; 110typedef 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 */ 125struct dongle_reg { 126 irda_queue_t q; /* Must be first */ 127 IRDA_DONGLE type; 128 129 void (*open)(dongle_t *dongle, struct qos_info *qos); 130 void (*close)(dongle_t *dongle); 131 int (*reset)(struct irda_task *task); 132 int (*change_speed)(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 */ 140struct irda_skb_cb { 141 magic_t magic; /* Be sure that we can trust the information */ 142 __u32 next_speed; /* The Speed to be set *after* this frame */ 143 __u16 mtt; /* Minimum turn around time */ 144 __u16 xbofs; /* Number of xbofs required, used by SIR mode */ 145 __u16 next_xbofs; /* Number of xbofs required *after* this frame */ 146 void *context; /* May be used by drivers */ 147 void (*destructor)(struct sk_buff *skb); /* Used for flow control */ 148 __u16 xbofs_delay; /* Number of xbofs used for generating the mtt */ 149 __u8 line; /* Used by IrCOMM in IrLPT mode */ 150}; 151 152/* Chip specific info */ 153typedef struct { 154 int cfg_base; /* Config register IO base */ 155 int sir_base; /* SIR IO base */ 156 int fir_base; /* FIR IO base */ 157 int mem_base; /* Shared memory base */ 158 int sir_ext; /* Length of SIR iobase */ 159 int fir_ext; /* Length of FIR iobase */ 160 int irq, irq2; /* Interrupts used */ 161 int dma, dma2; /* DMA channel(s) used */ 162 int fifo_size; /* FIFO size */ 163 int irqflags; /* interrupt flags (ie, IRQF_SHARED|IRQF_DISABLED) */ 164 int direction; /* Link direction, used by some FIR drivers */ 165 int enabled; /* Powered on? */ 166 int suspended; /* Suspended by APM */ 167 __u32 speed; /* Currently used speed */ 168 __u32 new_speed; /* Speed we must change to when Tx is finished */ 169 int dongle_id; /* Dongle or transceiver currently used */ 170} chipio_t; 171 172/* IO buffer specific info (inspired by struct sk_buff) */ 173typedef struct { 174 int state; /* Receiving state (transmit state not used) */ 175 int in_frame; /* True if receiving frame */ 176 177 __u8 *head; /* start of buffer */ 178 __u8 *data; /* start of data in buffer */ 179 180 int len; /* current length of data */ 181 int truesize; /* total allocated size of buffer */ 182 __u16 fcs; 183 184 struct sk_buff *skb; /* ZeroCopy Rx in async_unwrap_char() */ 185} iobuff_t; 186 187/* Maximum SIR frame (skb) that we expect to receive *unwrapped*. 188 * Max LAP MTU (I field) is 2048 bytes max (IrLAP 1.1, chapt 6.6.5, p40). 189 * Max LAP header is 2 bytes (for now). 190 * Max CRC is 2 bytes at SIR, 4 bytes at FIR. 191 * Need 1 byte for skb_reserve() to align IP header for IrLAN. 192 * Add a few extra bytes just to be safe (buffer is power of two anyway) 193 * Jean II */ 194#define IRDA_SKB_MAX_MTU 2064 195/* Maximum SIR frame that we expect to send, wrapped (i.e. with XBOFS 196 * and escaped characters on top of above). */ 197#define IRDA_SIR_MAX_FRAME 4269 198 199/* The SIR unwrapper async_unwrap_char() will use a Rx-copy-break mechanism 200 * when using the optional ZeroCopy Rx, where only small frames are memcpy 201 * to a smaller skb to save memory. This is the threshold under which copy 202 * will happen (and over which it won't happen). 203 * Some FIR drivers may use this #define as well... 204 * This is the same value as various Ethernet drivers. - Jean II */ 205#define IRDA_RX_COPY_THRESHOLD 256 206 207/* Function prototypes */ 208int irda_device_init(void); 209void irda_device_cleanup(void); 210 211/* IrLAP entry points used by the drivers. 212 * We declare them here to avoid the driver pulling a whole bunch stack 213 * headers they don't really need - Jean II */ 214struct irlap_cb *irlap_open(struct net_device *dev, struct qos_info *qos, 215 const char *hw_name); 216void irlap_close(struct irlap_cb *self); 217 218/* Interface to be uses by IrLAP */ 219void irda_device_set_media_busy(struct net_device *dev, int status); 220int irda_device_is_media_busy(struct net_device *dev); 221int irda_device_is_receiving(struct net_device *dev); 222 223/* Interface for internal use */ 224static inline int irda_device_txqueue_empty(const struct net_device *dev) 225{ 226 return skb_queue_empty(&dev->qdisc->q); 227} 228int irda_device_set_raw_mode(struct net_device* self, int status); 229struct net_device *alloc_irdadev(int sizeof_priv); 230 231/* Dongle interface */ 232void irda_device_unregister_dongle(struct dongle_reg *dongle); 233int irda_device_register_dongle(struct dongle_reg *dongle); 234dongle_t *irda_device_dongle_init(struct net_device *dev, int type); 235int irda_device_dongle_cleanup(dongle_t *dongle); 236 237void irda_setup_dma(int channel, dma_addr_t buffer, int count, int mode); 238 239void irda_task_delete(struct irda_task *task); 240struct irda_task *irda_task_execute(void *instance, 241 IRDA_TASK_CALLBACK function, 242 IRDA_TASK_CALLBACK finished, 243 struct irda_task *parent, void *param); 244void irda_task_next_state(struct irda_task *task, IRDA_TASK_STATE state); 245 246/* 247 * Function irda_get_mtt (skb) 248 * 249 * Utility function for getting the minimum turnaround time out of 250 * the skb, where it has been hidden in the cb field. 251 */ 252static inline __u16 irda_get_mtt(const struct sk_buff *skb) 253{ 254 const struct irda_skb_cb *cb = (const struct irda_skb_cb *) skb->cb; 255 return (cb->magic == LAP_MAGIC) ? cb->mtt : 10000; 256} 257 258/* 259 * Function irda_get_next_speed (skb) 260 * 261 * Extract the speed that should be set *after* this frame from the skb 262 * 263 * Note : return -1 for user space frames 264 */ 265static inline __u32 irda_get_next_speed(const struct sk_buff *skb) 266{ 267 const struct irda_skb_cb *cb = (const struct irda_skb_cb *) skb->cb; 268 return (cb->magic == LAP_MAGIC) ? cb->next_speed : -1; 269} 270 271/* 272 * Function irda_get_next_xbofs (skb) 273 * 274 * Extract the xbofs that should be set for this frame from the skb 275 * 276 * Note : default to 10 for user space frames 277 */ 278static inline __u16 irda_get_xbofs(const struct sk_buff *skb) 279{ 280 const struct irda_skb_cb *cb = (const struct irda_skb_cb *) skb->cb; 281 return (cb->magic == LAP_MAGIC) ? cb->xbofs : 10; 282} 283 284/* 285 * Function irda_get_next_xbofs (skb) 286 * 287 * Extract the xbofs that should be set *after* this frame from the skb 288 * 289 * Note : return -1 for user space frames 290 */ 291static inline __u16 irda_get_next_xbofs(const struct sk_buff *skb) 292{ 293 const struct irda_skb_cb *cb = (const struct irda_skb_cb *) skb->cb; 294 return (cb->magic == LAP_MAGIC) ? cb->next_xbofs : -1; 295} 296#endif /* IRDA_DEVICE_H */ 297