serial.h 12 KB

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