1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
|
/*********************************************************************
*
* 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: Tue Nov 16 12:54:01 1999
* Modified by: Dag Brattli <dagb@cs.uit.no>
*
* Copyright (c) 1999 Dag Brattli, All Rights Reserved.
* Copyright (c) 1998 Thomas Davis, <ratbert@radiks.net>,
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
********************************************************************/
#ifndef IRDA_DEVICE_H
#define IRDA_DEVICE_H
#include <linux/tty.h>
#include <linux/netdevice.h>
#include <linux/spinlock.h>
#include <linux/irda.h>
#include <net/irda/irda.h>
#include <net/irda/qos.h>
#include <net/irda/irqueue.h>
#include <net/irda/irlap_frame.h>
/* 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 */
} TASK_STATE;
struct irda_task;
typedef int (*TASK_CALLBACK) (struct irda_task *task);
struct irda_task {
queue_t q;
magic_t magic;
TASK_STATE state;
TASK_CALLBACK function;
TASK_CALLBACK finished;
/* struct net_device *dev; */
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 */
__u32 speed; /* Current speed */
int busy;
/* 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 {
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);
};
/* Chip specific info */
struct chipio_t {
int iobase, iobase2; /* IO base */
int io_ext, io_ext2; /* Length of iobase */
int membase; /* Shared memory base */
int irq, irq2; /* Interrupts used */
int fifo_size; /* FIFO size */
int dma, dma2; /* DMA channel used */
int irqflags; /* interrupt flags (ie, SA_SHIRQ|SA_INTERRUPT) */
int direction; /* Link direction, used by some FIR drivers */
__u32 speed; /* Currently used speed */
int dongle_id; /* Dongle or transceiver currently used */
};
/* IO buffer specific info (inspired by struct sk_buff) */
struct iobuff_t {
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 */
__u8 *tail; /* end of data in buffer */
int len; /* length of data */
int truesize; /* total size of buffer */
__u16 fcs;
};
/* Function prototypes */
int irda_device_init(void);
void irda_device_cleanup(void);
/* 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 */
int irda_device_txqueue_empty(struct net_device *dev);
int irda_device_set_raw_mode(struct net_device* self, int status);
int irda_device_set_dtr_rts(struct net_device *dev, int dtr, int rts);
int irda_device_change_speed(struct net_device *dev, __u32 speed);
int irda_device_setup(struct net_device *dev);
/* Dongle interface */
void irda_device_unregister_dongle(struct dongle_reg *dongle);
int irda_device_register_dongle(struct dongle_reg *dongle);
dongle_t *irda_device_dongle_init(struct net_device *dev, int type);
int irda_device_dongle_cleanup(dongle_t *dongle);
void setup_dma(int channel, char *buffer, int count, int mode);
int irda_task_kick(struct irda_task *task);
int irda_task_execute(void *instance, TASK_CALLBACK function,
TASK_CALLBACK finished, struct irda_task *parent,
void *param);
void irda_task_next_state(struct irda_task *task, TASK_STATE state);
extern const char *infrared_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.
*/
extern inline __u16 irda_get_mtt(struct sk_buff *skb)
{
__u16 mtt;
if (((struct irda_skb_cb *)(skb->cb))->magic != LAP_MAGIC)
mtt = 10000;
else
mtt = ((struct irda_skb_cb *)(skb->cb))->mtt;
ASSERT(mtt <= 10000, return 10000;);
return mtt;
}
/*
* Function irda_get_speed (skb)
*
* Extact the speed this frame should be sent out with from the skb
*
*/
extern inline __u32 irda_get_speed(struct sk_buff *skb)
{
__u32 speed;
if (((struct irda_skb_cb *)(skb->cb))->magic != LAP_MAGIC)
speed = 9600;
else
speed = ((struct irda_skb_cb *)(skb->cb))->speed;
return speed;
}
#endif
|
