mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
285 lines
10 KiB
285 lines
10 KiB
/********************************************************************* |
|
* |
|
* Filename: irda_device.h |
|
* Version: 0.9 |
|
* Description: Contains various declarations used by the drivers |
|
* Status: Experimental. |
|
* Author: Dag Brattli <[email protected]> |
|
* Created at: Tue Apr 14 12:41:42 1998 |
|
* Modified at: Mon Mar 20 09:08:57 2000 |
|
* Modified by: Dag Brattli <[email protected]> |
|
* |
|
* Copyright (c) 1999-2000 Dag Brattli, All Rights Reserved. |
|
* Copyright (c) 1998 Thomas Davis, <[email protected]>, |
|
* Copyright (c) 2000-2002 Jean Tourrilhes <[email protected]> |
|
* |
|
* This program is free software; you can redistribute it and/or |
|
* modify it under the terms of the GNU General Public License as |
|
* published by the Free Software Foundation; either version 2 of |
|
* the License, or (at your option) any later version. |
|
* |
|
* This program is distributed in the hope that it will be useful, |
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
* GNU General Public License for more details. |
|
* |
|
* You should have received a copy of the GNU General Public License |
|
* along with this program; if not, see <http://www.gnu.org/licenses/>. |
|
* |
|
********************************************************************/ |
|
|
|
/* |
|
* This header contains all the IrDA definitions a driver really |
|
* needs, and therefore the driver should not need to include |
|
* any other IrDA headers - Jean II |
|
*/ |
|
|
|
#ifndef IRDA_DEVICE_H |
|
#define IRDA_DEVICE_H |
|
|
|
#include <linux/tty.h> |
|
#include <linux/netdevice.h> |
|
#include <linux/spinlock.h> |
|
#include <linux/skbuff.h> /* struct sk_buff */ |
|
#include <linux/irda.h> |
|
#include <linux/types.h> |
|
|
|
#include <net/pkt_sched.h> |
|
#include <net/irda/irda.h> |
|
#include <net/irda/qos.h> /* struct qos_info */ |
|
#include <net/irda/irqueue.h> /* irda_queue_t */ |
|
|
|
/* A few forward declarations (to make compiler happy) */ |
|
struct irlap_cb; |
|
|
|
/* Some non-standard interface flags (should not conflict with any in if.h) */ |
|
#define IFF_SIR 0x0001 /* Supports SIR speeds */ |
|
#define IFF_MIR 0x0002 /* Supports MIR speeds */ |
|
#define IFF_FIR 0x0004 /* Supports FIR speeds */ |
|
#define IFF_VFIR 0x0008 /* Supports VFIR speeds */ |
|
#define IFF_PIO 0x0010 /* Supports PIO transfer of data */ |
|
#define IFF_DMA 0x0020 /* Supports DMA transfer of data */ |
|
#define IFF_SHM 0x0040 /* Supports shared memory data transfers */ |
|
#define IFF_DONGLE 0x0080 /* Interface has a dongle attached */ |
|
#define IFF_AIR 0x0100 /* Supports Advanced IR (AIR) standards */ |
|
|
|
#define IO_XMIT 0x01 |
|
#define IO_RECV 0x02 |
|
|
|
typedef enum { |
|
IRDA_IRLAP, /* IrDA mode, and deliver to IrLAP */ |
|
IRDA_RAW, /* IrDA mode */ |
|
SHARP_ASK, |
|
TV_REMOTE, /* Also known as Consumer Electronics IR */ |
|
} INFRARED_MODE; |
|
|
|
typedef enum { |
|
IRDA_TASK_INIT, /* All tasks are initialized with this state */ |
|
IRDA_TASK_DONE, /* Signals that the task is finished */ |
|
IRDA_TASK_WAIT, |
|
IRDA_TASK_WAIT1, |
|
IRDA_TASK_WAIT2, |
|
IRDA_TASK_WAIT3, |
|
IRDA_TASK_CHILD_INIT, /* Initializing child task */ |
|
IRDA_TASK_CHILD_WAIT, /* Waiting for child task to finish */ |
|
IRDA_TASK_CHILD_DONE /* Child task is finished */ |
|
} IRDA_TASK_STATE; |
|
|
|
struct irda_task; |
|
typedef int (*IRDA_TASK_CALLBACK) (struct irda_task *task); |
|
|
|
struct irda_task { |
|
irda_queue_t q; |
|
magic_t magic; |
|
|
|
IRDA_TASK_STATE state; |
|
IRDA_TASK_CALLBACK function; |
|
IRDA_TASK_CALLBACK finished; |
|
|
|
struct irda_task *parent; |
|
struct timer_list timer; |
|
|
|
void *instance; /* Instance being called */ |
|
void *param; /* Parameter to be used by instance */ |
|
}; |
|
|
|
/* Dongle info */ |
|
struct dongle_reg; |
|
typedef struct { |
|
struct dongle_reg *issue; /* Registration info */ |
|
struct net_device *dev; /* Device we are attached to */ |
|
struct irda_task *speed_task; /* Task handling speed change */ |
|
struct irda_task *reset_task; /* Task handling reset */ |
|
__u32 speed; /* Current speed */ |
|
|
|
/* Callbacks to the IrDA device driver */ |
|
int (*set_mode)(struct net_device *, int mode); |
|
int (*read)(struct net_device *dev, __u8 *buf, int len); |
|
int (*write)(struct net_device *dev, __u8 *buf, int len); |
|
int (*set_dtr_rts)(struct net_device *dev, int dtr, int rts); |
|
} dongle_t; |
|
|
|
/* Dongle registration info */ |
|
struct dongle_reg { |
|
irda_queue_t q; /* Must be first */ |
|
IRDA_DONGLE type; |
|
|
|
void (*open)(dongle_t *dongle, struct qos_info *qos); |
|
void (*close)(dongle_t *dongle); |
|
int (*reset)(struct irda_task *task); |
|
int (*change_speed)(struct irda_task *task); |
|
struct module *owner; |
|
}; |
|
|
|
/* |
|
* Per-packet information we need to hide inside sk_buff |
|
* (must not exceed 48 bytes, check with struct sk_buff) |
|
* The default_qdisc_pad field is a temporary hack. |
|
*/ |
|
struct irda_skb_cb { |
|
unsigned int default_qdisc_pad; |
|
magic_t magic; /* Be sure that we can trust the information */ |
|
__u32 next_speed; /* The Speed to be set *after* this frame */ |
|
__u16 mtt; /* Minimum turn around time */ |
|
__u16 xbofs; /* Number of xbofs required, used by SIR mode */ |
|
__u16 next_xbofs; /* Number of xbofs required *after* this frame */ |
|
void *context; /* May be used by drivers */ |
|
void (*destructor)(struct sk_buff *skb); /* Used for flow control */ |
|
__u16 xbofs_delay; /* Number of xbofs used for generating the mtt */ |
|
__u8 line; /* Used by IrCOMM in IrLPT mode */ |
|
}; |
|
|
|
/* Chip specific info */ |
|
typedef struct { |
|
int cfg_base; /* Config register IO base */ |
|
int sir_base; /* SIR IO base */ |
|
int fir_base; /* FIR IO base */ |
|
int mem_base; /* Shared memory base */ |
|
int sir_ext; /* Length of SIR iobase */ |
|
int fir_ext; /* Length of FIR iobase */ |
|
int irq, irq2; /* Interrupts used */ |
|
int dma, dma2; /* DMA channel(s) used */ |
|
int fifo_size; /* FIFO size */ |
|
int irqflags; /* interrupt flags (ie, IRQF_SHARED) */ |
|
int direction; /* Link direction, used by some FIR drivers */ |
|
int enabled; /* Powered on? */ |
|
int suspended; /* Suspended by APM */ |
|
__u32 speed; /* Currently used speed */ |
|
__u32 new_speed; /* Speed we must change to when Tx is finished */ |
|
int dongle_id; /* Dongle or transceiver currently used */ |
|
} chipio_t; |
|
|
|
/* IO buffer specific info (inspired by struct sk_buff) */ |
|
typedef struct { |
|
int state; /* Receiving state (transmit state not used) */ |
|
int in_frame; /* True if receiving frame */ |
|
|
|
__u8 *head; /* start of buffer */ |
|
__u8 *data; /* start of data in buffer */ |
|
|
|
int len; /* current length of data */ |
|
int truesize; /* total allocated size of buffer */ |
|
__u16 fcs; |
|
|
|
struct sk_buff *skb; /* ZeroCopy Rx in async_unwrap_char() */ |
|
} iobuff_t; |
|
|
|
/* Maximum SIR frame (skb) that we expect to receive *unwrapped*. |
|
* Max LAP MTU (I field) is 2048 bytes max (IrLAP 1.1, chapt 6.6.5, p40). |
|
* Max LAP header is 2 bytes (for now). |
|
* Max CRC is 2 bytes at SIR, 4 bytes at FIR. |
|
* Need 1 byte for skb_reserve() to align IP header for IrLAN. |
|
* Add a few extra bytes just to be safe (buffer is power of two anyway) |
|
* Jean II */ |
|
#define IRDA_SKB_MAX_MTU 2064 |
|
/* Maximum SIR frame that we expect to send, wrapped (i.e. with XBOFS |
|
* and escaped characters on top of above). */ |
|
#define IRDA_SIR_MAX_FRAME 4269 |
|
|
|
/* The SIR unwrapper async_unwrap_char() will use a Rx-copy-break mechanism |
|
* when using the optional ZeroCopy Rx, where only small frames are memcpy |
|
* to a smaller skb to save memory. This is the threshold under which copy |
|
* will happen (and over which it won't happen). |
|
* Some FIR drivers may use this #define as well... |
|
* This is the same value as various Ethernet drivers. - Jean II */ |
|
#define IRDA_RX_COPY_THRESHOLD 256 |
|
|
|
/* Function prototypes */ |
|
int irda_device_init(void); |
|
void irda_device_cleanup(void); |
|
|
|
/* IrLAP entry points used by the drivers. |
|
* We declare them here to avoid the driver pulling a whole bunch stack |
|
* headers they don't really need - Jean II */ |
|
struct irlap_cb *irlap_open(struct net_device *dev, struct qos_info *qos, |
|
const char *hw_name); |
|
void irlap_close(struct irlap_cb *self); |
|
|
|
/* Interface to be uses by IrLAP */ |
|
void irda_device_set_media_busy(struct net_device *dev, int status); |
|
int irda_device_is_media_busy(struct net_device *dev); |
|
int irda_device_is_receiving(struct net_device *dev); |
|
|
|
/* Interface for internal use */ |
|
static inline int irda_device_txqueue_empty(const struct net_device *dev) |
|
{ |
|
return qdisc_all_tx_empty(dev); |
|
} |
|
int irda_device_set_raw_mode(struct net_device* self, int status); |
|
struct net_device *alloc_irdadev(int sizeof_priv); |
|
|
|
void irda_setup_dma(int channel, dma_addr_t buffer, int count, int mode); |
|
|
|
/* |
|
* Function irda_get_mtt (skb) |
|
* |
|
* Utility function for getting the minimum turnaround time out of |
|
* the skb, where it has been hidden in the cb field. |
|
*/ |
|
static inline __u16 irda_get_mtt(const struct sk_buff *skb) |
|
{ |
|
const struct irda_skb_cb *cb = (const struct irda_skb_cb *) skb->cb; |
|
return (cb->magic == LAP_MAGIC) ? cb->mtt : 10000; |
|
} |
|
|
|
/* |
|
* Function irda_get_next_speed (skb) |
|
* |
|
* Extract the speed that should be set *after* this frame from the skb |
|
* |
|
* Note : return -1 for user space frames |
|
*/ |
|
static inline __u32 irda_get_next_speed(const struct sk_buff *skb) |
|
{ |
|
const struct irda_skb_cb *cb = (const struct irda_skb_cb *) skb->cb; |
|
return (cb->magic == LAP_MAGIC) ? cb->next_speed : -1; |
|
} |
|
|
|
/* |
|
* Function irda_get_next_xbofs (skb) |
|
* |
|
* Extract the xbofs that should be set for this frame from the skb |
|
* |
|
* Note : default to 10 for user space frames |
|
*/ |
|
static inline __u16 irda_get_xbofs(const struct sk_buff *skb) |
|
{ |
|
const struct irda_skb_cb *cb = (const struct irda_skb_cb *) skb->cb; |
|
return (cb->magic == LAP_MAGIC) ? cb->xbofs : 10; |
|
} |
|
|
|
/* |
|
* Function irda_get_next_xbofs (skb) |
|
* |
|
* Extract the xbofs that should be set *after* this frame from the skb |
|
* |
|
* Note : return -1 for user space frames |
|
*/ |
|
static inline __u16 irda_get_next_xbofs(const struct sk_buff *skb) |
|
{ |
|
const struct irda_skb_cb *cb = (const struct irda_skb_cb *) skb->cb; |
|
return (cb->magic == LAP_MAGIC) ? cb->next_xbofs : -1; |
|
} |
|
#endif /* IRDA_DEVICE_H */ |
|
|
|
|
|
|