OpenCores
URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [include/] [linux/] [usb/] [serial.h] - Blame information for rev 81

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 62 marcus.erl
/*
2
 * USB Serial Converter stuff
3
 *
4
 *      Copyright (C) 1999 - 2005
5
 *          Greg Kroah-Hartman (greg@kroah.com)
6
 *
7
 *      This program is free software; you can redistribute it and/or modify
8
 *      it under the terms of the GNU General Public License as published by
9
 *      the Free Software Foundation; version 2 of the License.
10
 *
11
 */
12
 
13
 
14
#ifndef __LINUX_USB_SERIAL_H
15
#define __LINUX_USB_SERIAL_H
16
 
17
#include <linux/kref.h>
18
#include <linux/mutex.h>
19
 
20
#define SERIAL_TTY_MAJOR        188     /* Nice legal number now */
21
#define SERIAL_TTY_MINORS       255     /* loads of devices :) */
22
 
23
#define MAX_NUM_PORTS           8       /* The maximum number of ports one device can grab at once */
24
 
25
/* parity check flag */
26
#define RELEVANT_IFLAG(iflag)   (iflag & (IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK))
27
 
28
/**
29
 * usb_serial_port: structure for the specific ports of a device.
30
 * @serial: pointer back to the struct usb_serial owner of this port.
31
 * @tty: pointer to the corresponding tty for this port.
32
 * @lock: spinlock to grab when updating portions of this structure.
33
 * @mutex: mutex used to synchronize serial_open() and serial_close()
34
 *      access for this port.
35
 * @number: the number of the port (the minor number).
36
 * @interrupt_in_buffer: pointer to the interrupt in buffer for this port.
37
 * @interrupt_in_urb: pointer to the interrupt in struct urb for this port.
38
 * @interrupt_in_endpointAddress: endpoint address for the interrupt in pipe
39
 *      for this port.
40
 * @interrupt_out_buffer: pointer to the interrupt out buffer for this port.
41
 * @interrupt_out_size: the size of the interrupt_out_buffer, in bytes.
42
 * @interrupt_out_urb: pointer to the interrupt out struct urb for this port.
43
 * @interrupt_out_endpointAddress: endpoint address for the interrupt out pipe
44
 *      for this port.
45
 * @bulk_in_buffer: pointer to the bulk in buffer for this port.
46
 * @read_urb: pointer to the bulk in struct urb for this port.
47
 * @bulk_in_endpointAddress: endpoint address for the bulk in pipe for this
48
 *      port.
49
 * @bulk_out_buffer: pointer to the bulk out buffer for this port.
50
 * @bulk_out_size: the size of the bulk_out_buffer, in bytes.
51
 * @write_urb: pointer to the bulk out struct urb for this port.
52
 * @bulk_out_endpointAddress: endpoint address for the bulk out pipe for this
53
 *      port.
54
 * @write_wait: a wait_queue_head_t used by the port.
55
 * @work: work queue entry for the line discipline waking up.
56
 * @open_count: number of times this port has been opened.
57
 * @throttled: nonzero if the read urb is inactive to throttle the device
58
 * @throttle_req: nonzero if the tty wants to throttle us
59
 *
60
 * This structure is used by the usb-serial core and drivers for the specific
61
 * ports of a device.
62
 */
63
struct usb_serial_port {
64
        struct usb_serial *     serial;
65
        struct tty_struct *     tty;
66
        spinlock_t              lock;
67
        struct mutex            mutex;
68
        unsigned char           number;
69
 
70
        unsigned char *         interrupt_in_buffer;
71
        struct urb *            interrupt_in_urb;
72
        __u8                    interrupt_in_endpointAddress;
73
 
74
        unsigned char *         interrupt_out_buffer;
75
        int                     interrupt_out_size;
76
        struct urb *            interrupt_out_urb;
77
        __u8                    interrupt_out_endpointAddress;
78
 
79
        unsigned char *         bulk_in_buffer;
80
        int                     bulk_in_size;
81
        struct urb *            read_urb;
82
        __u8                    bulk_in_endpointAddress;
83
 
84
        unsigned char *         bulk_out_buffer;
85
        int                     bulk_out_size;
86
        struct urb *            write_urb;
87
        int                     write_urb_busy;
88
        __u8                    bulk_out_endpointAddress;
89
 
90
        wait_queue_head_t       write_wait;
91
        struct work_struct      work;
92
        int                     open_count;
93
        char                    throttled;
94
        char                    throttle_req;
95
        struct device           dev;
96
};
97
#define to_usb_serial_port(d) container_of(d, struct usb_serial_port, dev)
98
 
99
/* get and set the port private data pointer helper functions */
100
static inline void *usb_get_serial_port_data (struct usb_serial_port *port)
101
{
102
        return dev_get_drvdata(&port->dev);
103
}
104
 
105
static inline void usb_set_serial_port_data (struct usb_serial_port *port, void *data)
106
{
107
        dev_set_drvdata(&port->dev, data);
108
}
109
 
110
/**
111
 * usb_serial - structure used by the usb-serial core for a device
112
 * @dev: pointer to the struct usb_device for this device
113
 * @type: pointer to the struct usb_serial_driver for this device
114
 * @interface: pointer to the struct usb_interface for this device
115
 * @minor: the starting minor number for this device
116
 * @num_ports: the number of ports this device has
117
 * @num_interrupt_in: number of interrupt in endpoints we have
118
 * @num_interrupt_out: number of interrupt out endpoints we have
119
 * @num_bulk_in: number of bulk in endpoints we have
120
 * @num_bulk_out: number of bulk out endpoints we have
121
 * @port: array of struct usb_serial_port structures for the different ports.
122
 * @private: place to put any driver specific information that is needed.  The
123
 *      usb-serial driver is required to manage this data, the usb-serial core
124
 *      will not touch this.  Use usb_get_serial_data() and
125
 *      usb_set_serial_data() to access this.
126
 */
127
struct usb_serial {
128
        struct usb_device *             dev;
129
        struct usb_serial_driver *      type;
130
        struct usb_interface *          interface;
131
        unsigned char                   minor;
132
        unsigned char                   num_ports;
133
        unsigned char                   num_port_pointers;
134
        char                            num_interrupt_in;
135
        char                            num_interrupt_out;
136
        char                            num_bulk_in;
137
        char                            num_bulk_out;
138
        struct usb_serial_port *        port[MAX_NUM_PORTS];
139
        struct kref                     kref;
140
        void *                          private;
141
};
142
#define to_usb_serial(d) container_of(d, struct usb_serial, kref)
143
 
144
#define NUM_DONT_CARE   99
145
 
146
/* get and set the serial private data pointer helper functions */
147
static inline void *usb_get_serial_data (struct usb_serial *serial)
148
{
149
        return serial->private;
150
}
151
 
152
static inline void usb_set_serial_data (struct usb_serial *serial, void *data)
153
{
154
        serial->private = data;
155
}
156
 
157
/**
158
 * usb_serial_driver - describes a usb serial driver
159
 * @description: pointer to a string that describes this driver.  This string used
160
 *      in the syslog messages when a device is inserted or removed.
161
 * @id_table: pointer to a list of usb_device_id structures that define all
162
 *      of the devices this structure can support.
163
 * @num_interrupt_in: If a device doesn't have this many interrupt-in
164
 *      endpoints, it won't be sent to the driver's attach() method.
165
 *      (But it might still be sent to the probe() method.)
166
 * @num_interrupt_out: If a device doesn't have this many interrupt-out
167
 *      endpoints, it won't be sent to the driver's attach() method.
168
 *      (But it might still be sent to the probe() method.)
169
 * @num_bulk_in: If a device doesn't have this many bulk-in
170
 *      endpoints, it won't be sent to the driver's attach() method.
171
 *      (But it might still be sent to the probe() method.)
172
 * @num_bulk_out: If a device doesn't have this many bulk-out
173
 *      endpoints, it won't be sent to the driver's attach() method.
174
 *      (But it might still be sent to the probe() method.)
175
 * @num_ports: the number of different ports this device will have.
176
 * @calc_num_ports: pointer to a function to determine how many ports this
177
 *      device has dynamically.  It will be called after the probe()
178
 *      callback is called, but before attach()
179
 * @probe: pointer to the driver's probe function.
180
 *      This will be called when the device is inserted into the system,
181
 *      but before the device has been fully initialized by the usb_serial
182
 *      subsystem.  Use this function to download any firmware to the device,
183
 *      or any other early initialization that might be needed.
184
 *      Return 0 to continue on with the initialization sequence.  Anything
185
 *      else will abort it.
186
 * @attach: pointer to the driver's attach function.
187
 *      This will be called when the struct usb_serial structure is fully set
188
 *      set up.  Do any local initialization of the device, or any private
189
 *      memory structure allocation at this point in time.
190
 * @shutdown: pointer to the driver's shutdown function.  This will be
191
 *      called when the device is removed from the system.
192
 * @usb_driver: pointer to the struct usb_driver that controls this
193
 *      device.  This is necessary to allow dynamic ids to be added to
194
 *      the driver from sysfs.
195
 *
196
 * This structure is defines a USB Serial driver.  It provides all of
197
 * the information that the USB serial core code needs.  If the function
198
 * pointers are defined, then the USB serial core code will call them when
199
 * the corresponding tty port functions are called.  If they are not
200
 * called, the generic serial function will be used instead.
201
 *
202
 * The driver.owner field should be set to the module owner of this driver.
203
 * The driver.name field should be set to the name of this driver (remember
204
 * it will show up in sysfs, so it needs to be short and to the point.
205
 * Useing the module name is a good idea.)
206
 */
207
struct usb_serial_driver {
208
        const char *description;
209
        const struct usb_device_id *id_table;
210
        char    num_interrupt_in;
211
        char    num_interrupt_out;
212
        char    num_bulk_in;
213
        char    num_bulk_out;
214
        char    num_ports;
215
 
216
        struct list_head        driver_list;
217
        struct device_driver    driver;
218
        struct usb_driver       *usb_driver;
219
        struct usb_dynids       dynids;
220
 
221
        int (*probe) (struct usb_serial *serial, const struct usb_device_id *id);
222
        int (*attach) (struct usb_serial *serial);
223
        int (*calc_num_ports) (struct usb_serial *serial);
224
 
225
        void (*shutdown) (struct usb_serial *serial);
226
 
227
        int (*port_probe) (struct usb_serial_port *port);
228
        int (*port_remove) (struct usb_serial_port *port);
229
 
230
        int (*suspend) (struct usb_serial *serial, pm_message_t message);
231
        int (*resume) (struct usb_serial *serial);
232
 
233
        /* serial function calls */
234
        int  (*open)            (struct usb_serial_port *port, struct file * filp);
235
        void (*close)           (struct usb_serial_port *port, struct file * filp);
236
        int  (*write)           (struct usb_serial_port *port, const unsigned char *buf, int count);
237
        int  (*write_room)      (struct usb_serial_port *port);
238
        int  (*ioctl)           (struct usb_serial_port *port, struct file * file, unsigned int cmd, unsigned long arg);
239
        void (*set_termios)     (struct usb_serial_port *port, struct ktermios * old);
240
        void (*break_ctl)       (struct usb_serial_port *port, int break_state);
241
        int  (*chars_in_buffer) (struct usb_serial_port *port);
242
        void (*throttle)        (struct usb_serial_port *port);
243
        void (*unthrottle)      (struct usb_serial_port *port);
244
        int  (*tiocmget)        (struct usb_serial_port *port, struct file *file);
245
        int  (*tiocmset)        (struct usb_serial_port *port, struct file *file, unsigned int set, unsigned int clear);
246
 
247
        void (*read_int_callback)(struct urb *urb);
248
        void (*write_int_callback)(struct urb *urb);
249
        void (*read_bulk_callback)(struct urb *urb);
250
        void (*write_bulk_callback)(struct urb *urb);
251
};
252
#define to_usb_serial_driver(d) container_of(d, struct usb_serial_driver, driver)
253
 
254
extern int  usb_serial_register(struct usb_serial_driver *driver);
255
extern void usb_serial_deregister(struct usb_serial_driver *driver);
256
extern void usb_serial_port_softint(struct usb_serial_port *port);
257
 
258
extern int usb_serial_probe(struct usb_interface *iface, const struct usb_device_id *id);
259
extern void usb_serial_disconnect(struct usb_interface *iface);
260
 
261
extern int usb_serial_suspend(struct usb_interface *intf, pm_message_t message);
262
extern int usb_serial_resume(struct usb_interface *intf);
263
 
264
extern int ezusb_writememory (struct usb_serial *serial, int address, unsigned char *data, int length, __u8 bRequest);
265
extern int ezusb_set_reset (struct usb_serial *serial, unsigned char reset_bit);
266
 
267
/* USB Serial console functions */
268
#ifdef CONFIG_USB_SERIAL_CONSOLE
269
extern void usb_serial_console_init (int debug, int minor);
270
extern void usb_serial_console_exit (void);
271
extern void usb_serial_console_disconnect(struct usb_serial *serial);
272
#else
273
static inline void usb_serial_console_init (int debug, int minor) { }
274
static inline void usb_serial_console_exit (void) { }
275
static inline void usb_serial_console_disconnect(struct usb_serial *serial) {}
276
#endif
277
 
278
/* Functions needed by other parts of the usbserial core */
279
extern struct usb_serial *usb_serial_get_by_index (unsigned int minor);
280
extern void usb_serial_put(struct usb_serial *serial);
281
extern int usb_serial_generic_open (struct usb_serial_port *port, struct file *filp);
282
extern int usb_serial_generic_write (struct usb_serial_port *port, const unsigned char *buf, int count);
283
extern void usb_serial_generic_close (struct usb_serial_port *port, struct file *filp);
284
extern int usb_serial_generic_resume (struct usb_serial *serial);
285
extern int usb_serial_generic_write_room (struct usb_serial_port *port);
286
extern int usb_serial_generic_chars_in_buffer (struct usb_serial_port *port);
287
extern void usb_serial_generic_read_bulk_callback (struct urb *urb);
288
extern void usb_serial_generic_write_bulk_callback (struct urb *urb);
289
extern void usb_serial_generic_throttle (struct usb_serial_port *port);
290
extern void usb_serial_generic_unthrottle (struct usb_serial_port *port);
291
extern void usb_serial_generic_shutdown (struct usb_serial *serial);
292
extern int usb_serial_generic_register (int debug);
293
extern void usb_serial_generic_deregister (void);
294
 
295
extern int usb_serial_bus_register (struct usb_serial_driver *device);
296
extern void usb_serial_bus_deregister (struct usb_serial_driver *device);
297
 
298
extern struct usb_serial_driver usb_serial_generic_device;
299
extern struct bus_type usb_serial_bus_type;
300
extern struct tty_driver *usb_serial_tty_driver;
301
 
302
static inline void usb_serial_debug_data(int debug,
303
                                         struct device *dev,
304
                                         const char *function, int size,
305
                                         const unsigned char *data)
306
{
307
        int i;
308
 
309
        if (debug) {
310
                dev_printk(KERN_DEBUG, dev, "%s - length = %d, data = ", function, size);
311
                for (i = 0; i < size; ++i)
312
                        printk ("%.2x ", data[i]);
313
                printk ("\n");
314
        }
315
}
316
 
317
/* Use our own dbg macro */
318
#undef dbg
319
#define dbg(format, arg...) do { if (debug) printk(KERN_DEBUG "%s: " format "\n" , __FILE__ , ## arg); } while (0)
320
 
321
 
322
 
323
#endif  /* ifdef __LINUX_USB_SERIAL_H */
324
 

powered by: WebSVN 2.1.0

© copyright 1999-2025 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.