cregit-Linux how code gets into the kernel

Release 4.12 include/net/irda/irda_device.h

Directory: include/net/irda
/*********************************************************************
 *                
 * Filename:      irda_device.h
 * Version:       0.9
 * Description:   Contains various declarations used by the drivers
 * Status:        Experimental.
 * Author:        Dag Brattli <dagb@cs.uit.no>
 * Created at:    Tue Apr 14 12:41:42 1998
 * Modified at:   Mon Mar 20 09:08:57 2000
 * Modified by:   Dag Brattli <dagb@cs.uit.no>
 * 
 *     Copyright (c) 1999-2000 Dag Brattli, All Rights Reserved.
 *     Copyright (c) 1998 Thomas Davis, <ratbert@radiks.net>,
 *     Copyright (c) 2000-2002 Jean Tourrilhes <jt@hpl.hp.com>
 *
 *     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);
}

Contributors
PersonTokensPropCommitsCommitProp
Stephen Hemminger1052.63%120.00%


Linus Torvalds (pre-git)842.11%360.00%


David S. Miller15.26%120.00%


Total19100.00%5100.00%



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;
}


Contributors
PersonTokensPropCommitsCommitProp
Stephen Hemminger4090.91%150.00%


Linus Torvalds (pre-git)49.09%150.00%


Total44100.00%2100.00%



/*
 * 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;
}


Contributors
PersonTokensPropCommitsCommitProp
Stephen Hemminger4191.11%125.00%


Linus Torvalds (pre-git)36.67%250.00%


Linus Torvalds12.22%125.00%


Total45100.00%4100.00%



/*
 * 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;
}


Contributors
PersonTokensPropCommitsCommitProp
Stephen Hemminger4090.91%150.00%


Linus Torvalds49.09%150.00%


Total44100.00%2100.00%



/*
 * 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;
}

Contributors
PersonTokensPropCommitsCommitProp
Stephen Hemminger4191.11%150.00%


Linus Torvalds48.89%150.00%


Total45100.00%2100.00%



#endif /* IRDA_DEVICE_H */



Overall Contributors
PersonTokensPropCommitsCommitProp
Linus Torvalds (pre-git)55062.36%1448.28%


Stephen Hemminger19121.66%620.69%


Jean Tourrilhes11613.15%26.90%


Linus Torvalds121.36%13.45%


Samuel Ortiz50.57%13.45%


William Lee Irwin III40.45%13.45%


David S. Miller10.11%13.45%


Steven Cole10.11%13.45%


Jeff Kirsher10.11%13.45%


Michael Opdenacker10.11%13.45%


Total882100.00%29100.00%


Directory: include/net/irda



Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with cregit.