]>
Commit | Line | Data |
---|---|---|
c1dca562 DB |
1 | /* |
2 | * u_serial.c - utilities for USB gadget "serial port"/TTY support | |
3 | * | |
4 | * Copyright (C) 2003 Al Borchers (alborchers@steinerpoint.com) | |
5 | * Copyright (C) 2008 David Brownell | |
6 | * Copyright (C) 2008 by Nokia Corporation | |
7 | * | |
8 | * This code also borrows from usbserial.c, which is | |
9 | * Copyright (C) 1999 - 2002 Greg Kroah-Hartman (greg@kroah.com) | |
10 | * Copyright (C) 2000 Peter Berger (pberger@brimson.com) | |
11 | * Copyright (C) 2000 Al Borchers (alborchers@steinerpoint.com) | |
12 | * | |
13 | * This software is distributed under the terms of the GNU General | |
14 | * Public License ("GPL") as published by the Free Software Foundation, | |
15 | * either version 2 of that License or (at your option) any later version. | |
16 | */ | |
17 | ||
18 | /* #define VERBOSE_DEBUG */ | |
19 | ||
20 | #include <linux/kernel.h> | |
1e413943 | 21 | #include <linux/sched.h> |
c1dca562 DB |
22 | #include <linux/interrupt.h> |
23 | #include <linux/device.h> | |
24 | #include <linux/delay.h> | |
25 | #include <linux/tty.h> | |
26 | #include <linux/tty_flip.h> | |
5a0e3ad6 | 27 | #include <linux/slab.h> |
f940fcd8 | 28 | #include <linux/export.h> |
3249ca22 | 29 | #include <linux/module.h> |
a5beaaf3 BW |
30 | #include <linux/console.h> |
31 | #include <linux/kthread.h> | |
c1dca562 DB |
32 | |
33 | #include "u_serial.h" | |
34 | ||
35 | ||
36 | /* | |
37 | * This component encapsulates the TTY layer glue needed to provide basic | |
38 | * "serial port" functionality through the USB gadget stack. Each such | |
39 | * port is exposed through a /dev/ttyGS* node. | |
40 | * | |
19b10a88 SAS |
41 | * After this module has been loaded, the individual TTY port can be requested |
42 | * (gserial_alloc_line()) and it will stay available until they are removed | |
43 | * (gserial_free_line()). Each one may be connected to a USB function | |
44 | * (gserial_connect), or disconnected (with gserial_disconnect) when the USB | |
45 | * host issues a config change event. Data can only flow when the port is | |
46 | * connected to the host. | |
c1dca562 DB |
47 | * |
48 | * A given TTY port can be made available in multiple configurations. | |
49 | * For example, each one might expose a ttyGS0 node which provides a | |
50 | * login application. In one case that might use CDC ACM interface 0, | |
51 | * while another configuration might use interface 3 for that. The | |
52 | * work to handle that (including descriptor management) is not part | |
53 | * of this component. | |
54 | * | |
55 | * Configurations may expose more than one TTY port. For example, if | |
56 | * ttyGS0 provides login service, then ttyGS1 might provide dialer access | |
57 | * for a telephone or fax link. And ttyGS2 might be something that just | |
58 | * needs a simple byte stream interface for some messaging protocol that | |
59 | * is managed in userspace ... OBEX, PTP, and MTP have been mentioned. | |
c572a217 RL |
60 | * |
61 | * | |
c1dca562 DB |
62 | * gserial is the lifecycle interface, used by USB functions |
63 | * gs_port is the I/O nexus, used by the tty driver | |
64 | * tty_struct links to the tty/filesystem framework | |
65 | * | |
66 | * gserial <---> gs_port ... links will be null when the USB link is | |
1f1ba11b DB |
67 | * inactive; managed by gserial_{connect,disconnect}(). each gserial |
68 | * instance can wrap its own USB control protocol. | |
c1dca562 DB |
69 | * gserial->ioport == usb_ep->driver_data ... gs_port |
70 | * gs_port->port_usb ... gserial | |
71 | * | |
72 | * gs_port <---> tty_struct ... links will be null when the TTY file | |
73 | * isn't opened; managed by gs_open()/gs_close() | |
74 | * gserial->port_tty ... tty_struct | |
75 | * tty_struct->driver_data ... gserial | |
76 | */ | |
77 | ||
78 | /* RX and TX queues can buffer QUEUE_SIZE packets before they hit the | |
79 | * next layer of buffering. For TX that's a circular buffer; for RX | |
80 | * consider it a NOP. A third layer is provided by the TTY code. | |
81 | */ | |
82 | #define QUEUE_SIZE 16 | |
83 | #define WRITE_BUF_SIZE 8192 /* TX only */ | |
a5beaaf3 | 84 | #define GS_CONSOLE_BUF_SIZE 8192 |
c1dca562 DB |
85 | |
86 | /* circular buffer */ | |
87 | struct gs_buf { | |
88 | unsigned buf_size; | |
89 | char *buf_buf; | |
90 | char *buf_get; | |
91 | char *buf_put; | |
92 | }; | |
93 | ||
a5beaaf3 BW |
94 | /* console info */ |
95 | struct gscons_info { | |
96 | struct gs_port *port; | |
97 | struct task_struct *console_thread; | |
98 | struct gs_buf con_buf; | |
99 | /* protect the buf and busy flag */ | |
100 | spinlock_t con_lock; | |
101 | int req_busy; | |
102 | struct usb_request *console_req; | |
103 | }; | |
104 | ||
c1dca562 DB |
105 | /* |
106 | * The port structure holds info for each port, one for each minor number | |
107 | * (and thus for each /dev/ node). | |
108 | */ | |
109 | struct gs_port { | |
266e37ef | 110 | struct tty_port port; |
c1dca562 DB |
111 | spinlock_t port_lock; /* guard port_* access */ |
112 | ||
113 | struct gserial *port_usb; | |
c1dca562 | 114 | |
c1dca562 DB |
115 | bool openclose; /* open/close in progress */ |
116 | u8 port_num; | |
117 | ||
c1dca562 | 118 | struct list_head read_pool; |
28609d40 JS |
119 | int read_started; |
120 | int read_allocated; | |
937ef73d DB |
121 | struct list_head read_queue; |
122 | unsigned n_read; | |
c1dca562 DB |
123 | struct tasklet_struct push; |
124 | ||
125 | struct list_head write_pool; | |
28609d40 JS |
126 | int write_started; |
127 | int write_allocated; | |
c1dca562 DB |
128 | struct gs_buf port_write_buf; |
129 | wait_queue_head_t drain_wait; /* wait while writes drain */ | |
3e9d3d2e | 130 | bool write_busy; |
b140dfe6 | 131 | wait_queue_head_t close_wait; |
c1dca562 DB |
132 | |
133 | /* REVISIT this state ... */ | |
134 | struct usb_cdc_line_coding port_line_coding; /* 8-N-1 etc */ | |
135 | }; | |
136 | ||
c1dca562 DB |
137 | static struct portmaster { |
138 | struct mutex lock; /* protect open/close */ | |
139 | struct gs_port *port; | |
19b10a88 | 140 | } ports[MAX_U_SERIAL_PORTS]; |
c1dca562 DB |
141 | |
142 | #define GS_CLOSE_TIMEOUT 15 /* seconds */ | |
143 | ||
144 | ||
145 | ||
146 | #ifdef VERBOSE_DEBUG | |
ea0e6276 | 147 | #ifndef pr_vdebug |
c1dca562 DB |
148 | #define pr_vdebug(fmt, arg...) \ |
149 | pr_debug(fmt, ##arg) | |
ea0e6276 | 150 | #endif /* pr_vdebug */ |
c1dca562 | 151 | #else |
273daf2f | 152 | #ifndef pr_vdebug |
c1dca562 DB |
153 | #define pr_vdebug(fmt, arg...) \ |
154 | ({ if (0) pr_debug(fmt, ##arg); }) | |
ea0e6276 | 155 | #endif /* pr_vdebug */ |
c1dca562 DB |
156 | #endif |
157 | ||
158 | /*-------------------------------------------------------------------------*/ | |
159 | ||
160 | /* Circular Buffer */ | |
161 | ||
162 | /* | |
163 | * gs_buf_alloc | |
164 | * | |
165 | * Allocate a circular buffer and all associated memory. | |
166 | */ | |
167 | static int gs_buf_alloc(struct gs_buf *gb, unsigned size) | |
168 | { | |
169 | gb->buf_buf = kmalloc(size, GFP_KERNEL); | |
170 | if (gb->buf_buf == NULL) | |
171 | return -ENOMEM; | |
172 | ||
173 | gb->buf_size = size; | |
174 | gb->buf_put = gb->buf_buf; | |
175 | gb->buf_get = gb->buf_buf; | |
176 | ||
177 | return 0; | |
178 | } | |
179 | ||
180 | /* | |
181 | * gs_buf_free | |
182 | * | |
183 | * Free the buffer and all associated memory. | |
184 | */ | |
185 | static void gs_buf_free(struct gs_buf *gb) | |
186 | { | |
187 | kfree(gb->buf_buf); | |
188 | gb->buf_buf = NULL; | |
189 | } | |
190 | ||
191 | /* | |
192 | * gs_buf_clear | |
193 | * | |
194 | * Clear out all data in the circular buffer. | |
195 | */ | |
196 | static void gs_buf_clear(struct gs_buf *gb) | |
197 | { | |
198 | gb->buf_get = gb->buf_put; | |
199 | /* equivalent to a get of all data available */ | |
200 | } | |
201 | ||
202 | /* | |
203 | * gs_buf_data_avail | |
204 | * | |
1f1ba11b | 205 | * Return the number of bytes of data written into the circular |
c1dca562 DB |
206 | * buffer. |
207 | */ | |
208 | static unsigned gs_buf_data_avail(struct gs_buf *gb) | |
209 | { | |
210 | return (gb->buf_size + gb->buf_put - gb->buf_get) % gb->buf_size; | |
211 | } | |
212 | ||
213 | /* | |
214 | * gs_buf_space_avail | |
215 | * | |
216 | * Return the number of bytes of space available in the circular | |
217 | * buffer. | |
218 | */ | |
219 | static unsigned gs_buf_space_avail(struct gs_buf *gb) | |
220 | { | |
221 | return (gb->buf_size + gb->buf_get - gb->buf_put - 1) % gb->buf_size; | |
222 | } | |
223 | ||
224 | /* | |
225 | * gs_buf_put | |
226 | * | |
227 | * Copy data data from a user buffer and put it into the circular buffer. | |
228 | * Restrict to the amount of space available. | |
229 | * | |
230 | * Return the number of bytes copied. | |
231 | */ | |
232 | static unsigned | |
233 | gs_buf_put(struct gs_buf *gb, const char *buf, unsigned count) | |
234 | { | |
235 | unsigned len; | |
236 | ||
237 | len = gs_buf_space_avail(gb); | |
238 | if (count > len) | |
239 | count = len; | |
240 | ||
241 | if (count == 0) | |
242 | return 0; | |
243 | ||
244 | len = gb->buf_buf + gb->buf_size - gb->buf_put; | |
245 | if (count > len) { | |
246 | memcpy(gb->buf_put, buf, len); | |
247 | memcpy(gb->buf_buf, buf+len, count - len); | |
248 | gb->buf_put = gb->buf_buf + count - len; | |
249 | } else { | |
250 | memcpy(gb->buf_put, buf, count); | |
251 | if (count < len) | |
252 | gb->buf_put += count; | |
253 | else /* count == len */ | |
254 | gb->buf_put = gb->buf_buf; | |
255 | } | |
256 | ||
257 | return count; | |
258 | } | |
259 | ||
260 | /* | |
261 | * gs_buf_get | |
262 | * | |
263 | * Get data from the circular buffer and copy to the given buffer. | |
264 | * Restrict to the amount of data available. | |
265 | * | |
266 | * Return the number of bytes copied. | |
267 | */ | |
268 | static unsigned | |
269 | gs_buf_get(struct gs_buf *gb, char *buf, unsigned count) | |
270 | { | |
271 | unsigned len; | |
272 | ||
273 | len = gs_buf_data_avail(gb); | |
274 | if (count > len) | |
275 | count = len; | |
276 | ||
277 | if (count == 0) | |
278 | return 0; | |
279 | ||
280 | len = gb->buf_buf + gb->buf_size - gb->buf_get; | |
281 | if (count > len) { | |
282 | memcpy(buf, gb->buf_get, len); | |
283 | memcpy(buf+len, gb->buf_buf, count - len); | |
284 | gb->buf_get = gb->buf_buf + count - len; | |
285 | } else { | |
286 | memcpy(buf, gb->buf_get, count); | |
287 | if (count < len) | |
288 | gb->buf_get += count; | |
289 | else /* count == len */ | |
290 | gb->buf_get = gb->buf_buf; | |
291 | } | |
292 | ||
293 | return count; | |
294 | } | |
295 | ||
296 | /*-------------------------------------------------------------------------*/ | |
297 | ||
298 | /* I/O glue between TTY (upper) and USB function (lower) driver layers */ | |
299 | ||
300 | /* | |
301 | * gs_alloc_req | |
302 | * | |
303 | * Allocate a usb_request and its buffer. Returns a pointer to the | |
304 | * usb_request or NULL if there is an error. | |
305 | */ | |
1f1ba11b | 306 | struct usb_request * |
c1dca562 DB |
307 | gs_alloc_req(struct usb_ep *ep, unsigned len, gfp_t kmalloc_flags) |
308 | { | |
309 | struct usb_request *req; | |
310 | ||
311 | req = usb_ep_alloc_request(ep, kmalloc_flags); | |
312 | ||
313 | if (req != NULL) { | |
314 | req->length = len; | |
315 | req->buf = kmalloc(len, kmalloc_flags); | |
316 | if (req->buf == NULL) { | |
317 | usb_ep_free_request(ep, req); | |
318 | return NULL; | |
319 | } | |
320 | } | |
321 | ||
322 | return req; | |
323 | } | |
3249ca22 | 324 | EXPORT_SYMBOL_GPL(gs_alloc_req); |
c1dca562 DB |
325 | |
326 | /* | |
327 | * gs_free_req | |
328 | * | |
329 | * Free a usb_request and its buffer. | |
330 | */ | |
1f1ba11b | 331 | void gs_free_req(struct usb_ep *ep, struct usb_request *req) |
c1dca562 DB |
332 | { |
333 | kfree(req->buf); | |
334 | usb_ep_free_request(ep, req); | |
335 | } | |
3249ca22 | 336 | EXPORT_SYMBOL_GPL(gs_free_req); |
c1dca562 DB |
337 | |
338 | /* | |
339 | * gs_send_packet | |
340 | * | |
341 | * If there is data to send, a packet is built in the given | |
342 | * buffer and the size is returned. If there is no data to | |
343 | * send, 0 is returned. | |
344 | * | |
345 | * Called with port_lock held. | |
346 | */ | |
347 | static unsigned | |
348 | gs_send_packet(struct gs_port *port, char *packet, unsigned size) | |
349 | { | |
350 | unsigned len; | |
351 | ||
352 | len = gs_buf_data_avail(&port->port_write_buf); | |
353 | if (len < size) | |
354 | size = len; | |
355 | if (size != 0) | |
356 | size = gs_buf_get(&port->port_write_buf, packet, size); | |
357 | return size; | |
358 | } | |
359 | ||
360 | /* | |
361 | * gs_start_tx | |
362 | * | |
363 | * This function finds available write requests, calls | |
364 | * gs_send_packet to fill these packets with data, and | |
365 | * continues until either there are no more write requests | |
366 | * available or no more data to send. This function is | |
367 | * run whenever data arrives or write requests are available. | |
368 | * | |
369 | * Context: caller owns port_lock; port_usb is non-null. | |
370 | */ | |
371 | static int gs_start_tx(struct gs_port *port) | |
372 | /* | |
373 | __releases(&port->port_lock) | |
374 | __acquires(&port->port_lock) | |
375 | */ | |
376 | { | |
377 | struct list_head *pool = &port->write_pool; | |
511a36d2 | 378 | struct usb_ep *in; |
c1dca562 DB |
379 | int status = 0; |
380 | bool do_tty_wake = false; | |
381 | ||
511a36d2 BW |
382 | if (!port->port_usb) |
383 | return status; | |
384 | ||
385 | in = port->port_usb->in; | |
386 | ||
3e9d3d2e | 387 | while (!port->write_busy && !list_empty(pool)) { |
c1dca562 DB |
388 | struct usb_request *req; |
389 | int len; | |
390 | ||
28609d40 JS |
391 | if (port->write_started >= QUEUE_SIZE) |
392 | break; | |
393 | ||
c1dca562 DB |
394 | req = list_entry(pool->next, struct usb_request, list); |
395 | len = gs_send_packet(port, req->buf, in->maxpacket); | |
396 | if (len == 0) { | |
397 | wake_up_interruptible(&port->drain_wait); | |
398 | break; | |
399 | } | |
400 | do_tty_wake = true; | |
401 | ||
402 | req->length = len; | |
403 | list_del(&req->list); | |
2e251341 | 404 | req->zero = (gs_buf_data_avail(&port->port_write_buf) == 0); |
c1dca562 | 405 | |
c572a217 RL |
406 | pr_vdebug("ttyGS%d: tx len=%d, 0x%02x 0x%02x 0x%02x ...\n", |
407 | port->port_num, len, *((u8 *)req->buf), | |
408 | *((u8 *)req->buf+1), *((u8 *)req->buf+2)); | |
c1dca562 DB |
409 | |
410 | /* Drop lock while we call out of driver; completions | |
411 | * could be issued while we do so. Disconnection may | |
412 | * happen too; maybe immediately before we queue this! | |
413 | * | |
414 | * NOTE that we may keep sending data for a while after | |
415 | * the TTY closed (dev->ioport->port_tty is NULL). | |
416 | */ | |
3e9d3d2e | 417 | port->write_busy = true; |
c1dca562 DB |
418 | spin_unlock(&port->port_lock); |
419 | status = usb_ep_queue(in, req, GFP_ATOMIC); | |
420 | spin_lock(&port->port_lock); | |
3e9d3d2e | 421 | port->write_busy = false; |
c1dca562 DB |
422 | |
423 | if (status) { | |
424 | pr_debug("%s: %s %s err %d\n", | |
425 | __func__, "queue", in->name, status); | |
426 | list_add(&req->list, pool); | |
427 | break; | |
428 | } | |
429 | ||
28609d40 JS |
430 | port->write_started++; |
431 | ||
c1dca562 DB |
432 | /* abort immediately after disconnect */ |
433 | if (!port->port_usb) | |
434 | break; | |
435 | } | |
436 | ||
35f95fd7 JS |
437 | if (do_tty_wake && port->port.tty) |
438 | tty_wakeup(port->port.tty); | |
c1dca562 DB |
439 | return status; |
440 | } | |
441 | ||
c1dca562 DB |
442 | /* |
443 | * Context: caller owns port_lock, and port_usb is set | |
444 | */ | |
445 | static unsigned gs_start_rx(struct gs_port *port) | |
446 | /* | |
447 | __releases(&port->port_lock) | |
448 | __acquires(&port->port_lock) | |
449 | */ | |
450 | { | |
451 | struct list_head *pool = &port->read_pool; | |
452 | struct usb_ep *out = port->port_usb->out; | |
c1dca562 DB |
453 | |
454 | while (!list_empty(pool)) { | |
455 | struct usb_request *req; | |
456 | int status; | |
457 | struct tty_struct *tty; | |
458 | ||
937ef73d | 459 | /* no more rx if closed */ |
35f95fd7 | 460 | tty = port->port.tty; |
937ef73d | 461 | if (!tty) |
c1dca562 DB |
462 | break; |
463 | ||
28609d40 JS |
464 | if (port->read_started >= QUEUE_SIZE) |
465 | break; | |
466 | ||
c1dca562 DB |
467 | req = list_entry(pool->next, struct usb_request, list); |
468 | list_del(&req->list); | |
469 | req->length = out->maxpacket; | |
470 | ||
471 | /* drop lock while we call out; the controller driver | |
472 | * may need to call us back (e.g. for disconnect) | |
473 | */ | |
474 | spin_unlock(&port->port_lock); | |
475 | status = usb_ep_queue(out, req, GFP_ATOMIC); | |
476 | spin_lock(&port->port_lock); | |
477 | ||
478 | if (status) { | |
479 | pr_debug("%s: %s %s err %d\n", | |
480 | __func__, "queue", out->name, status); | |
481 | list_add(&req->list, pool); | |
482 | break; | |
483 | } | |
28609d40 | 484 | port->read_started++; |
c1dca562 DB |
485 | |
486 | /* abort immediately after disconnect */ | |
487 | if (!port->port_usb) | |
488 | break; | |
489 | } | |
28609d40 | 490 | return port->read_started; |
c1dca562 DB |
491 | } |
492 | ||
937ef73d DB |
493 | /* |
494 | * RX tasklet takes data out of the RX queue and hands it up to the TTY | |
495 | * layer until it refuses to take any more data (or is throttled back). | |
496 | * Then it issues reads for any further data. | |
497 | * | |
498 | * If the RX queue becomes full enough that no usb_request is queued, | |
499 | * the OUT endpoint may begin NAKing as soon as its FIFO fills up. | |
500 | * So QUEUE_SIZE packets plus however many the FIFO holds (usually two) | |
501 | * can be buffered before the TTY layer's buffers (currently 64 KB). | |
502 | */ | |
503 | static void gs_rx_push(unsigned long _port) | |
c1dca562 | 504 | { |
937ef73d DB |
505 | struct gs_port *port = (void *)_port; |
506 | struct tty_struct *tty; | |
507 | struct list_head *queue = &port->read_queue; | |
508 | bool disconnect = false; | |
509 | bool do_push = false; | |
c1dca562 | 510 | |
937ef73d DB |
511 | /* hand any queued data to the tty */ |
512 | spin_lock_irq(&port->port_lock); | |
35f95fd7 | 513 | tty = port->port.tty; |
937ef73d DB |
514 | while (!list_empty(queue)) { |
515 | struct usb_request *req; | |
c1dca562 | 516 | |
937ef73d | 517 | req = list_first_entry(queue, struct usb_request, list); |
c1dca562 | 518 | |
937ef73d | 519 | /* leave data queued if tty was rx throttled */ |
97ef38b8 | 520 | if (tty && tty_throttled(tty)) |
937ef73d DB |
521 | break; |
522 | ||
523 | switch (req->status) { | |
524 | case -ESHUTDOWN: | |
525 | disconnect = true; | |
c572a217 | 526 | pr_vdebug("ttyGS%d: shutdown\n", port->port_num); |
937ef73d DB |
527 | break; |
528 | ||
529 | default: | |
530 | /* presumably a transient fault */ | |
c572a217 RL |
531 | pr_warn("ttyGS%d: unexpected RX status %d\n", |
532 | port->port_num, req->status); | |
937ef73d DB |
533 | /* FALLTHROUGH */ |
534 | case 0: | |
535 | /* normal completion */ | |
536 | break; | |
537 | } | |
538 | ||
539 | /* push data to (open) tty */ | |
daa35bd9 | 540 | if (req->actual && tty) { |
937ef73d DB |
541 | char *packet = req->buf; |
542 | unsigned size = req->actual; | |
543 | unsigned n; | |
544 | int count; | |
545 | ||
546 | /* we may have pushed part of this packet already... */ | |
547 | n = port->n_read; | |
548 | if (n) { | |
549 | packet += n; | |
550 | size -= n; | |
551 | } | |
552 | ||
05c7cd39 JS |
553 | count = tty_insert_flip_string(&port->port, packet, |
554 | size); | |
937ef73d DB |
555 | if (count) |
556 | do_push = true; | |
557 | if (count != size) { | |
558 | /* stop pushing; TTY layer can't handle more */ | |
559 | port->n_read += count; | |
c572a217 RL |
560 | pr_vdebug("ttyGS%d: rx block %d/%d\n", |
561 | port->port_num, count, req->actual); | |
937ef73d DB |
562 | break; |
563 | } | |
564 | port->n_read = 0; | |
565 | } | |
05c7cd39 | 566 | |
937ef73d | 567 | list_move(&req->list, &port->read_pool); |
28609d40 | 568 | port->read_started--; |
937ef73d DB |
569 | } |
570 | ||
a9c3f68f PH |
571 | /* Push from tty to ldisc; this is handled by a workqueue, |
572 | * so we won't get callbacks and can hold port_lock | |
937ef73d | 573 | */ |
2e124b4a JS |
574 | if (do_push) |
575 | tty_flip_buffer_push(&port->port); | |
937ef73d DB |
576 | |
577 | ||
578 | /* We want our data queue to become empty ASAP, keeping data | |
579 | * in the tty and ldisc (not here). If we couldn't push any | |
580 | * this time around, there may be trouble unless there's an | |
581 | * implicit tty_unthrottle() call on its way... | |
582 | * | |
583 | * REVISIT we should probably add a timer to keep the tasklet | |
584 | * from starving ... but it's not clear that case ever happens. | |
585 | */ | |
586 | if (!list_empty(queue) && tty) { | |
97ef38b8 | 587 | if (!tty_throttled(tty)) { |
937ef73d DB |
588 | if (do_push) |
589 | tasklet_schedule(&port->push); | |
590 | else | |
c572a217 | 591 | pr_warn("ttyGS%d: RX not scheduled?\n", |
937ef73d DB |
592 | port->port_num); |
593 | } | |
594 | } | |
595 | ||
596 | /* If we're still connected, refill the USB RX queue. */ | |
597 | if (!disconnect && port->port_usb) | |
598 | gs_start_rx(port); | |
599 | ||
600 | spin_unlock_irq(&port->port_lock); | |
601 | } | |
602 | ||
603 | static void gs_read_complete(struct usb_ep *ep, struct usb_request *req) | |
604 | { | |
605 | struct gs_port *port = ep->driver_data; | |
606 | ||
607 | /* Queue all received data until the tty layer is ready for it. */ | |
608 | spin_lock(&port->port_lock); | |
609 | list_add_tail(&req->list, &port->read_queue); | |
610 | tasklet_schedule(&port->push); | |
c1dca562 DB |
611 | spin_unlock(&port->port_lock); |
612 | } | |
613 | ||
614 | static void gs_write_complete(struct usb_ep *ep, struct usb_request *req) | |
615 | { | |
616 | struct gs_port *port = ep->driver_data; | |
617 | ||
618 | spin_lock(&port->port_lock); | |
619 | list_add(&req->list, &port->write_pool); | |
28609d40 | 620 | port->write_started--; |
c1dca562 DB |
621 | |
622 | switch (req->status) { | |
623 | default: | |
624 | /* presumably a transient fault */ | |
3f5ad864 JP |
625 | pr_warn("%s: unexpected %s status %d\n", |
626 | __func__, ep->name, req->status); | |
c1dca562 DB |
627 | /* FALL THROUGH */ |
628 | case 0: | |
629 | /* normal completion */ | |
630 | gs_start_tx(port); | |
631 | break; | |
632 | ||
633 | case -ESHUTDOWN: | |
634 | /* disconnect */ | |
635 | pr_vdebug("%s: %s shutdown\n", __func__, ep->name); | |
636 | break; | |
637 | } | |
638 | ||
639 | spin_unlock(&port->port_lock); | |
640 | } | |
641 | ||
28609d40 JS |
642 | static void gs_free_requests(struct usb_ep *ep, struct list_head *head, |
643 | int *allocated) | |
c1dca562 DB |
644 | { |
645 | struct usb_request *req; | |
646 | ||
647 | while (!list_empty(head)) { | |
648 | req = list_entry(head->next, struct usb_request, list); | |
649 | list_del(&req->list); | |
650 | gs_free_req(ep, req); | |
28609d40 JS |
651 | if (allocated) |
652 | (*allocated)--; | |
c1dca562 DB |
653 | } |
654 | } | |
655 | ||
656 | static int gs_alloc_requests(struct usb_ep *ep, struct list_head *head, | |
28609d40 JS |
657 | void (*fn)(struct usb_ep *, struct usb_request *), |
658 | int *allocated) | |
c1dca562 DB |
659 | { |
660 | int i; | |
661 | struct usb_request *req; | |
28609d40 | 662 | int n = allocated ? QUEUE_SIZE - *allocated : QUEUE_SIZE; |
c1dca562 DB |
663 | |
664 | /* Pre-allocate up to QUEUE_SIZE transfers, but if we can't | |
665 | * do quite that many this time, don't fail ... we just won't | |
666 | * be as speedy as we might otherwise be. | |
667 | */ | |
28609d40 | 668 | for (i = 0; i < n; i++) { |
c1dca562 DB |
669 | req = gs_alloc_req(ep, ep->maxpacket, GFP_ATOMIC); |
670 | if (!req) | |
671 | return list_empty(head) ? -ENOMEM : 0; | |
672 | req->complete = fn; | |
673 | list_add_tail(&req->list, head); | |
28609d40 JS |
674 | if (allocated) |
675 | (*allocated)++; | |
c1dca562 DB |
676 | } |
677 | return 0; | |
678 | } | |
679 | ||
680 | /** | |
681 | * gs_start_io - start USB I/O streams | |
682 | * @dev: encapsulates endpoints to use | |
683 | * Context: holding port_lock; port_tty and port_usb are non-null | |
684 | * | |
685 | * We only start I/O when something is connected to both sides of | |
686 | * this port. If nothing is listening on the host side, we may | |
687 | * be pointlessly filling up our TX buffers and FIFO. | |
688 | */ | |
689 | static int gs_start_io(struct gs_port *port) | |
690 | { | |
691 | struct list_head *head = &port->read_pool; | |
692 | struct usb_ep *ep = port->port_usb->out; | |
693 | int status; | |
694 | unsigned started; | |
695 | ||
696 | /* Allocate RX and TX I/O buffers. We can't easily do this much | |
697 | * earlier (with GFP_KERNEL) because the requests are coupled to | |
698 | * endpoints, as are the packet sizes we'll be using. Different | |
699 | * configurations may use different endpoints with a given port; | |
700 | * and high speed vs full speed changes packet sizes too. | |
701 | */ | |
28609d40 JS |
702 | status = gs_alloc_requests(ep, head, gs_read_complete, |
703 | &port->read_allocated); | |
c1dca562 DB |
704 | if (status) |
705 | return status; | |
706 | ||
707 | status = gs_alloc_requests(port->port_usb->in, &port->write_pool, | |
28609d40 | 708 | gs_write_complete, &port->write_allocated); |
c1dca562 | 709 | if (status) { |
28609d40 | 710 | gs_free_requests(ep, head, &port->read_allocated); |
c1dca562 DB |
711 | return status; |
712 | } | |
713 | ||
714 | /* queue read requests */ | |
937ef73d | 715 | port->n_read = 0; |
c1dca562 DB |
716 | started = gs_start_rx(port); |
717 | ||
718 | /* unblock any pending writes into our circular buffer */ | |
719 | if (started) { | |
35f95fd7 | 720 | tty_wakeup(port->port.tty); |
c1dca562 | 721 | } else { |
28609d40 JS |
722 | gs_free_requests(ep, head, &port->read_allocated); |
723 | gs_free_requests(port->port_usb->in, &port->write_pool, | |
724 | &port->write_allocated); | |
937ef73d | 725 | status = -EIO; |
c1dca562 DB |
726 | } |
727 | ||
937ef73d | 728 | return status; |
c1dca562 DB |
729 | } |
730 | ||
731 | /*-------------------------------------------------------------------------*/ | |
732 | ||
733 | /* TTY Driver */ | |
734 | ||
735 | /* | |
736 | * gs_open sets up the link between a gs_port and its associated TTY. | |
737 | * That link is broken *only* by TTY close(), and all driver methods | |
738 | * know that. | |
739 | */ | |
740 | static int gs_open(struct tty_struct *tty, struct file *file) | |
741 | { | |
742 | int port_num = tty->index; | |
743 | struct gs_port *port; | |
744 | int status; | |
745 | ||
c1dca562 DB |
746 | do { |
747 | mutex_lock(&ports[port_num].lock); | |
748 | port = ports[port_num].port; | |
749 | if (!port) | |
750 | status = -ENODEV; | |
751 | else { | |
752 | spin_lock_irq(&port->port_lock); | |
753 | ||
754 | /* already open? Great. */ | |
266e37ef | 755 | if (port->port.count) { |
c1dca562 | 756 | status = 0; |
266e37ef | 757 | port->port.count++; |
c1dca562 DB |
758 | |
759 | /* currently opening/closing? wait ... */ | |
760 | } else if (port->openclose) { | |
761 | status = -EBUSY; | |
762 | ||
763 | /* ... else we do the work */ | |
764 | } else { | |
765 | status = -EAGAIN; | |
766 | port->openclose = true; | |
767 | } | |
768 | spin_unlock_irq(&port->port_lock); | |
769 | } | |
770 | mutex_unlock(&ports[port_num].lock); | |
771 | ||
772 | switch (status) { | |
773 | default: | |
774 | /* fully handled */ | |
775 | return status; | |
776 | case -EAGAIN: | |
777 | /* must do the work */ | |
778 | break; | |
779 | case -EBUSY: | |
780 | /* wait for EAGAIN task to finish */ | |
781 | msleep(1); | |
782 | /* REVISIT could have a waitchannel here, if | |
783 | * concurrent open performance is important | |
784 | */ | |
785 | break; | |
786 | } | |
787 | } while (status != -EAGAIN); | |
788 | ||
789 | /* Do the "real open" */ | |
790 | spin_lock_irq(&port->port_lock); | |
791 | ||
792 | /* allocate circular buffer on first open */ | |
793 | if (port->port_write_buf.buf_buf == NULL) { | |
794 | ||
795 | spin_unlock_irq(&port->port_lock); | |
796 | status = gs_buf_alloc(&port->port_write_buf, WRITE_BUF_SIZE); | |
797 | spin_lock_irq(&port->port_lock); | |
798 | ||
799 | if (status) { | |
800 | pr_debug("gs_open: ttyGS%d (%p,%p) no buffer\n", | |
801 | port->port_num, tty, file); | |
802 | port->openclose = false; | |
803 | goto exit_unlock_port; | |
804 | } | |
805 | } | |
806 | ||
807 | /* REVISIT if REMOVED (ports[].port NULL), abort the open | |
808 | * to let rmmod work faster (but this way isn't wrong). | |
809 | */ | |
810 | ||
811 | /* REVISIT maybe wait for "carrier detect" */ | |
812 | ||
813 | tty->driver_data = port; | |
35f95fd7 | 814 | port->port.tty = tty; |
c1dca562 | 815 | |
266e37ef | 816 | port->port.count = 1; |
c1dca562 DB |
817 | port->openclose = false; |
818 | ||
c1dca562 DB |
819 | /* if connected, start the I/O stream */ |
820 | if (port->port_usb) { | |
1f1ba11b DB |
821 | struct gserial *gser = port->port_usb; |
822 | ||
c1dca562 DB |
823 | pr_debug("gs_open: start ttyGS%d\n", port->port_num); |
824 | gs_start_io(port); | |
825 | ||
1f1ba11b DB |
826 | if (gser->connect) |
827 | gser->connect(gser); | |
c1dca562 DB |
828 | } |
829 | ||
830 | pr_debug("gs_open: ttyGS%d (%p,%p)\n", port->port_num, tty, file); | |
831 | ||
832 | status = 0; | |
833 | ||
834 | exit_unlock_port: | |
835 | spin_unlock_irq(&port->port_lock); | |
836 | return status; | |
837 | } | |
838 | ||
839 | static int gs_writes_finished(struct gs_port *p) | |
840 | { | |
841 | int cond; | |
842 | ||
843 | /* return true on disconnect or empty buffer */ | |
844 | spin_lock_irq(&p->port_lock); | |
845 | cond = (p->port_usb == NULL) || !gs_buf_data_avail(&p->port_write_buf); | |
846 | spin_unlock_irq(&p->port_lock); | |
847 | ||
848 | return cond; | |
849 | } | |
850 | ||
851 | static void gs_close(struct tty_struct *tty, struct file *file) | |
852 | { | |
853 | struct gs_port *port = tty->driver_data; | |
1f1ba11b | 854 | struct gserial *gser; |
c1dca562 DB |
855 | |
856 | spin_lock_irq(&port->port_lock); | |
857 | ||
266e37ef JS |
858 | if (port->port.count != 1) { |
859 | if (port->port.count == 0) | |
c1dca562 DB |
860 | WARN_ON(1); |
861 | else | |
266e37ef | 862 | --port->port.count; |
c1dca562 DB |
863 | goto exit; |
864 | } | |
865 | ||
866 | pr_debug("gs_close: ttyGS%d (%p,%p) ...\n", port->port_num, tty, file); | |
867 | ||
868 | /* mark port as closing but in use; we can drop port lock | |
869 | * and sleep if necessary | |
870 | */ | |
871 | port->openclose = true; | |
266e37ef | 872 | port->port.count = 0; |
c1dca562 | 873 | |
1f1ba11b DB |
874 | gser = port->port_usb; |
875 | if (gser && gser->disconnect) | |
876 | gser->disconnect(gser); | |
c1dca562 DB |
877 | |
878 | /* wait for circular write buffer to drain, disconnect, or at | |
879 | * most GS_CLOSE_TIMEOUT seconds; then discard the rest | |
880 | */ | |
1f1ba11b | 881 | if (gs_buf_data_avail(&port->port_write_buf) > 0 && gser) { |
c1dca562 DB |
882 | spin_unlock_irq(&port->port_lock); |
883 | wait_event_interruptible_timeout(port->drain_wait, | |
884 | gs_writes_finished(port), | |
885 | GS_CLOSE_TIMEOUT * HZ); | |
886 | spin_lock_irq(&port->port_lock); | |
1f1ba11b | 887 | gser = port->port_usb; |
c1dca562 DB |
888 | } |
889 | ||
890 | /* Iff we're disconnected, there can be no I/O in flight so it's | |
891 | * ok to free the circular buffer; else just scrub it. And don't | |
892 | * let the push tasklet fire again until we're re-opened. | |
893 | */ | |
1f1ba11b | 894 | if (gser == NULL) |
c1dca562 DB |
895 | gs_buf_free(&port->port_write_buf); |
896 | else | |
897 | gs_buf_clear(&port->port_write_buf); | |
898 | ||
35f95fd7 | 899 | port->port.tty = NULL; |
c1dca562 DB |
900 | |
901 | port->openclose = false; | |
902 | ||
903 | pr_debug("gs_close: ttyGS%d (%p,%p) done!\n", | |
904 | port->port_num, tty, file); | |
905 | ||
b140dfe6 | 906 | wake_up(&port->close_wait); |
c1dca562 DB |
907 | exit: |
908 | spin_unlock_irq(&port->port_lock); | |
909 | } | |
910 | ||
911 | static int gs_write(struct tty_struct *tty, const unsigned char *buf, int count) | |
912 | { | |
913 | struct gs_port *port = tty->driver_data; | |
914 | unsigned long flags; | |
c1dca562 DB |
915 | |
916 | pr_vdebug("gs_write: ttyGS%d (%p) writing %d bytes\n", | |
917 | port->port_num, tty, count); | |
918 | ||
919 | spin_lock_irqsave(&port->port_lock, flags); | |
920 | if (count) | |
921 | count = gs_buf_put(&port->port_write_buf, buf, count); | |
922 | /* treat count == 0 as flush_chars() */ | |
923 | if (port->port_usb) | |
872ce511 | 924 | gs_start_tx(port); |
c1dca562 DB |
925 | spin_unlock_irqrestore(&port->port_lock, flags); |
926 | ||
927 | return count; | |
928 | } | |
929 | ||
930 | static int gs_put_char(struct tty_struct *tty, unsigned char ch) | |
931 | { | |
932 | struct gs_port *port = tty->driver_data; | |
933 | unsigned long flags; | |
934 | int status; | |
935 | ||
16d9efa4 | 936 | pr_vdebug("gs_put_char: (%d,%p) char=0x%x, called from %ps\n", |
c1dca562 DB |
937 | port->port_num, tty, ch, __builtin_return_address(0)); |
938 | ||
939 | spin_lock_irqsave(&port->port_lock, flags); | |
940 | status = gs_buf_put(&port->port_write_buf, &ch, 1); | |
941 | spin_unlock_irqrestore(&port->port_lock, flags); | |
942 | ||
943 | return status; | |
944 | } | |
945 | ||
946 | static void gs_flush_chars(struct tty_struct *tty) | |
947 | { | |
948 | struct gs_port *port = tty->driver_data; | |
949 | unsigned long flags; | |
950 | ||
951 | pr_vdebug("gs_flush_chars: (%d,%p)\n", port->port_num, tty); | |
952 | ||
953 | spin_lock_irqsave(&port->port_lock, flags); | |
954 | if (port->port_usb) | |
955 | gs_start_tx(port); | |
956 | spin_unlock_irqrestore(&port->port_lock, flags); | |
957 | } | |
958 | ||
959 | static int gs_write_room(struct tty_struct *tty) | |
960 | { | |
961 | struct gs_port *port = tty->driver_data; | |
962 | unsigned long flags; | |
963 | int room = 0; | |
964 | ||
965 | spin_lock_irqsave(&port->port_lock, flags); | |
966 | if (port->port_usb) | |
967 | room = gs_buf_space_avail(&port->port_write_buf); | |
968 | spin_unlock_irqrestore(&port->port_lock, flags); | |
969 | ||
970 | pr_vdebug("gs_write_room: (%d,%p) room=%d\n", | |
971 | port->port_num, tty, room); | |
972 | ||
973 | return room; | |
974 | } | |
975 | ||
976 | static int gs_chars_in_buffer(struct tty_struct *tty) | |
977 | { | |
978 | struct gs_port *port = tty->driver_data; | |
979 | unsigned long flags; | |
980 | int chars = 0; | |
981 | ||
982 | spin_lock_irqsave(&port->port_lock, flags); | |
983 | chars = gs_buf_data_avail(&port->port_write_buf); | |
984 | spin_unlock_irqrestore(&port->port_lock, flags); | |
985 | ||
986 | pr_vdebug("gs_chars_in_buffer: (%d,%p) chars=%d\n", | |
987 | port->port_num, tty, chars); | |
988 | ||
989 | return chars; | |
990 | } | |
991 | ||
992 | /* undo side effects of setting TTY_THROTTLED */ | |
993 | static void gs_unthrottle(struct tty_struct *tty) | |
994 | { | |
995 | struct gs_port *port = tty->driver_data; | |
996 | unsigned long flags; | |
c1dca562 DB |
997 | |
998 | spin_lock_irqsave(&port->port_lock, flags); | |
937ef73d DB |
999 | if (port->port_usb) { |
1000 | /* Kickstart read queue processing. We don't do xon/xoff, | |
1001 | * rts/cts, or other handshaking with the host, but if the | |
1002 | * read queue backs up enough we'll be NAKing OUT packets. | |
1003 | */ | |
1004 | tasklet_schedule(&port->push); | |
c572a217 | 1005 | pr_vdebug("ttyGS%d: unthrottle\n", port->port_num); |
937ef73d | 1006 | } |
c1dca562 | 1007 | spin_unlock_irqrestore(&port->port_lock, flags); |
c1dca562 DB |
1008 | } |
1009 | ||
1f1ba11b DB |
1010 | static int gs_break_ctl(struct tty_struct *tty, int duration) |
1011 | { | |
1012 | struct gs_port *port = tty->driver_data; | |
1013 | int status = 0; | |
1014 | struct gserial *gser; | |
1015 | ||
1016 | pr_vdebug("gs_break_ctl: ttyGS%d, send break (%d) \n", | |
1017 | port->port_num, duration); | |
1018 | ||
1019 | spin_lock_irq(&port->port_lock); | |
1020 | gser = port->port_usb; | |
1021 | if (gser && gser->send_break) | |
1022 | status = gser->send_break(gser, duration); | |
1023 | spin_unlock_irq(&port->port_lock); | |
1024 | ||
1025 | return status; | |
1026 | } | |
1027 | ||
c1dca562 DB |
1028 | static const struct tty_operations gs_tty_ops = { |
1029 | .open = gs_open, | |
1030 | .close = gs_close, | |
1031 | .write = gs_write, | |
1032 | .put_char = gs_put_char, | |
1033 | .flush_chars = gs_flush_chars, | |
1034 | .write_room = gs_write_room, | |
1035 | .chars_in_buffer = gs_chars_in_buffer, | |
1036 | .unthrottle = gs_unthrottle, | |
1f1ba11b | 1037 | .break_ctl = gs_break_ctl, |
c1dca562 DB |
1038 | }; |
1039 | ||
1040 | /*-------------------------------------------------------------------------*/ | |
1041 | ||
1042 | static struct tty_driver *gs_tty_driver; | |
1043 | ||
a5beaaf3 BW |
1044 | #ifdef CONFIG_U_SERIAL_CONSOLE |
1045 | ||
1046 | static struct gscons_info gscons_info; | |
1047 | static struct console gserial_cons; | |
1048 | ||
1049 | static struct usb_request *gs_request_new(struct usb_ep *ep) | |
1050 | { | |
1051 | struct usb_request *req = usb_ep_alloc_request(ep, GFP_ATOMIC); | |
1052 | if (!req) | |
1053 | return NULL; | |
1054 | ||
1055 | req->buf = kmalloc(ep->maxpacket, GFP_ATOMIC); | |
1056 | if (!req->buf) { | |
1057 | usb_ep_free_request(ep, req); | |
1058 | return NULL; | |
1059 | } | |
1060 | ||
1061 | return req; | |
1062 | } | |
1063 | ||
1064 | static void gs_request_free(struct usb_request *req, struct usb_ep *ep) | |
1065 | { | |
1066 | if (!req) | |
1067 | return; | |
1068 | ||
1069 | kfree(req->buf); | |
1070 | usb_ep_free_request(ep, req); | |
1071 | } | |
1072 | ||
1073 | static void gs_complete_out(struct usb_ep *ep, struct usb_request *req) | |
1074 | { | |
1075 | struct gscons_info *info = &gscons_info; | |
1076 | ||
1077 | switch (req->status) { | |
1078 | default: | |
1079 | pr_warn("%s: unexpected %s status %d\n", | |
1080 | __func__, ep->name, req->status); | |
1081 | case 0: | |
1082 | /* normal completion */ | |
1083 | spin_lock(&info->con_lock); | |
1084 | info->req_busy = 0; | |
1085 | spin_unlock(&info->con_lock); | |
1086 | ||
1087 | wake_up_process(info->console_thread); | |
1088 | break; | |
1089 | case -ESHUTDOWN: | |
1090 | /* disconnect */ | |
1091 | pr_vdebug("%s: %s shutdown\n", __func__, ep->name); | |
1092 | break; | |
1093 | } | |
1094 | } | |
1095 | ||
1096 | static int gs_console_connect(int port_num) | |
1097 | { | |
1098 | struct gscons_info *info = &gscons_info; | |
1099 | struct gs_port *port; | |
1100 | struct usb_ep *ep; | |
1101 | ||
1102 | if (port_num != gserial_cons.index) { | |
1103 | pr_err("%s: port num [%d] is not support console\n", | |
1104 | __func__, port_num); | |
1105 | return -ENXIO; | |
1106 | } | |
1107 | ||
1108 | port = ports[port_num].port; | |
1109 | ep = port->port_usb->in; | |
1110 | if (!info->console_req) { | |
1111 | info->console_req = gs_request_new(ep); | |
1112 | if (!info->console_req) | |
1113 | return -ENOMEM; | |
1114 | info->console_req->complete = gs_complete_out; | |
1115 | } | |
1116 | ||
1117 | info->port = port; | |
1118 | spin_lock(&info->con_lock); | |
1119 | info->req_busy = 0; | |
1120 | spin_unlock(&info->con_lock); | |
1121 | pr_vdebug("port[%d] console connect!\n", port_num); | |
1122 | return 0; | |
1123 | } | |
1124 | ||
1125 | static void gs_console_disconnect(struct usb_ep *ep) | |
1126 | { | |
1127 | struct gscons_info *info = &gscons_info; | |
1128 | struct usb_request *req = info->console_req; | |
1129 | ||
1130 | gs_request_free(req, ep); | |
1131 | info->console_req = NULL; | |
1132 | } | |
1133 | ||
1134 | static int gs_console_thread(void *data) | |
1135 | { | |
1136 | struct gscons_info *info = &gscons_info; | |
1137 | struct gs_port *port; | |
1138 | struct usb_request *req; | |
1139 | struct usb_ep *ep; | |
1140 | int xfer, ret, count, size; | |
1141 | ||
1142 | do { | |
1143 | port = info->port; | |
1144 | set_current_state(TASK_INTERRUPTIBLE); | |
1145 | if (!port || !port->port_usb | |
1146 | || !port->port_usb->in || !info->console_req) | |
1147 | goto sched; | |
1148 | ||
1149 | req = info->console_req; | |
1150 | ep = port->port_usb->in; | |
1151 | ||
1152 | spin_lock_irq(&info->con_lock); | |
1153 | count = gs_buf_data_avail(&info->con_buf); | |
1154 | size = ep->maxpacket; | |
1155 | ||
1156 | if (count > 0 && !info->req_busy) { | |
1157 | set_current_state(TASK_RUNNING); | |
1158 | if (count < size) | |
1159 | size = count; | |
1160 | ||
1161 | xfer = gs_buf_get(&info->con_buf, req->buf, size); | |
1162 | req->length = xfer; | |
1163 | ||
1164 | spin_unlock(&info->con_lock); | |
1165 | ret = usb_ep_queue(ep, req, GFP_ATOMIC); | |
1166 | spin_lock(&info->con_lock); | |
1167 | if (ret < 0) | |
1168 | info->req_busy = 0; | |
1169 | else | |
1170 | info->req_busy = 1; | |
1171 | ||
1172 | spin_unlock_irq(&info->con_lock); | |
1173 | } else { | |
1174 | spin_unlock_irq(&info->con_lock); | |
1175 | sched: | |
1176 | if (kthread_should_stop()) { | |
1177 | set_current_state(TASK_RUNNING); | |
1178 | break; | |
1179 | } | |
1180 | schedule(); | |
1181 | } | |
1182 | } while (1); | |
1183 | ||
1184 | return 0; | |
1185 | } | |
1186 | ||
1187 | static int gs_console_setup(struct console *co, char *options) | |
1188 | { | |
1189 | struct gscons_info *info = &gscons_info; | |
1190 | int status; | |
1191 | ||
1192 | info->port = NULL; | |
1193 | info->console_req = NULL; | |
1194 | info->req_busy = 0; | |
1195 | spin_lock_init(&info->con_lock); | |
1196 | ||
1197 | status = gs_buf_alloc(&info->con_buf, GS_CONSOLE_BUF_SIZE); | |
1198 | if (status) { | |
1199 | pr_err("%s: allocate console buffer failed\n", __func__); | |
1200 | return status; | |
1201 | } | |
1202 | ||
1203 | info->console_thread = kthread_create(gs_console_thread, | |
1204 | co, "gs_console"); | |
1205 | if (IS_ERR(info->console_thread)) { | |
1206 | pr_err("%s: cannot create console thread\n", __func__); | |
1207 | gs_buf_free(&info->con_buf); | |
1208 | return PTR_ERR(info->console_thread); | |
1209 | } | |
1210 | wake_up_process(info->console_thread); | |
1211 | ||
1212 | return 0; | |
1213 | } | |
1214 | ||
1215 | static void gs_console_write(struct console *co, | |
1216 | const char *buf, unsigned count) | |
1217 | { | |
1218 | struct gscons_info *info = &gscons_info; | |
1219 | unsigned long flags; | |
1220 | ||
1221 | spin_lock_irqsave(&info->con_lock, flags); | |
1222 | gs_buf_put(&info->con_buf, buf, count); | |
1223 | spin_unlock_irqrestore(&info->con_lock, flags); | |
1224 | ||
1225 | wake_up_process(info->console_thread); | |
1226 | } | |
1227 | ||
1228 | static struct tty_driver *gs_console_device(struct console *co, int *index) | |
1229 | { | |
1230 | struct tty_driver **p = (struct tty_driver **)co->data; | |
1231 | ||
1232 | if (!*p) | |
1233 | return NULL; | |
1234 | ||
1235 | *index = co->index; | |
1236 | return *p; | |
1237 | } | |
1238 | ||
1239 | static struct console gserial_cons = { | |
1240 | .name = "ttyGS", | |
1241 | .write = gs_console_write, | |
1242 | .device = gs_console_device, | |
1243 | .setup = gs_console_setup, | |
1244 | .flags = CON_PRINTBUFFER, | |
1245 | .index = -1, | |
1246 | .data = &gs_tty_driver, | |
1247 | }; | |
1248 | ||
1249 | static void gserial_console_init(void) | |
1250 | { | |
1251 | register_console(&gserial_cons); | |
1252 | } | |
1253 | ||
1254 | static void gserial_console_exit(void) | |
1255 | { | |
1256 | struct gscons_info *info = &gscons_info; | |
1257 | ||
1258 | unregister_console(&gserial_cons); | |
844cf8a9 | 1259 | if (!IS_ERR_OR_NULL(info->console_thread)) |
d5c024f3 | 1260 | kthread_stop(info->console_thread); |
a5beaaf3 BW |
1261 | gs_buf_free(&info->con_buf); |
1262 | } | |
1263 | ||
1264 | #else | |
1265 | ||
1266 | static int gs_console_connect(int port_num) | |
1267 | { | |
1268 | return 0; | |
1269 | } | |
1270 | ||
1271 | static void gs_console_disconnect(struct usb_ep *ep) | |
1272 | { | |
1273 | } | |
1274 | ||
1275 | static void gserial_console_init(void) | |
1276 | { | |
1277 | } | |
1278 | ||
1279 | static void gserial_console_exit(void) | |
1280 | { | |
1281 | } | |
1282 | ||
1283 | #endif | |
1284 | ||
c3c04b29 | 1285 | static int |
c1dca562 DB |
1286 | gs_port_alloc(unsigned port_num, struct usb_cdc_line_coding *coding) |
1287 | { | |
1288 | struct gs_port *port; | |
19b10a88 SAS |
1289 | int ret = 0; |
1290 | ||
1291 | mutex_lock(&ports[port_num].lock); | |
1292 | if (ports[port_num].port) { | |
1293 | ret = -EBUSY; | |
1294 | goto out; | |
1295 | } | |
c1dca562 DB |
1296 | |
1297 | port = kzalloc(sizeof(struct gs_port), GFP_KERNEL); | |
19b10a88 SAS |
1298 | if (port == NULL) { |
1299 | ret = -ENOMEM; | |
1300 | goto out; | |
1301 | } | |
c1dca562 | 1302 | |
266e37ef | 1303 | tty_port_init(&port->port); |
c1dca562 | 1304 | spin_lock_init(&port->port_lock); |
c1dca562 | 1305 | init_waitqueue_head(&port->drain_wait); |
b140dfe6 | 1306 | init_waitqueue_head(&port->close_wait); |
c1dca562 DB |
1307 | |
1308 | tasklet_init(&port->push, gs_rx_push, (unsigned long) port); | |
1309 | ||
1310 | INIT_LIST_HEAD(&port->read_pool); | |
937ef73d | 1311 | INIT_LIST_HEAD(&port->read_queue); |
c1dca562 DB |
1312 | INIT_LIST_HEAD(&port->write_pool); |
1313 | ||
1314 | port->port_num = port_num; | |
1315 | port->port_line_coding = *coding; | |
1316 | ||
1317 | ports[port_num].port = port; | |
19b10a88 SAS |
1318 | out: |
1319 | mutex_unlock(&ports[port_num].lock); | |
1320 | return ret; | |
c1dca562 DB |
1321 | } |
1322 | ||
1323 | static int gs_closed(struct gs_port *port) | |
1324 | { | |
1325 | int cond; | |
1326 | ||
1327 | spin_lock_irq(&port->port_lock); | |
266e37ef | 1328 | cond = (port->port.count == 0) && !port->openclose; |
c1dca562 DB |
1329 | spin_unlock_irq(&port->port_lock); |
1330 | return cond; | |
1331 | } | |
1332 | ||
19b10a88 SAS |
1333 | static void gserial_free_port(struct gs_port *port) |
1334 | { | |
1335 | tasklet_kill(&port->push); | |
1336 | /* wait for old opens to finish */ | |
b140dfe6 | 1337 | wait_event(port->close_wait, gs_closed(port)); |
19b10a88 SAS |
1338 | WARN_ON(port->port_usb != NULL); |
1339 | tty_port_destroy(&port->port); | |
1340 | kfree(port); | |
1341 | } | |
1342 | ||
1343 | void gserial_free_line(unsigned char port_num) | |
c1dca562 | 1344 | { |
c1dca562 DB |
1345 | struct gs_port *port; |
1346 | ||
19b10a88 SAS |
1347 | mutex_lock(&ports[port_num].lock); |
1348 | if (WARN_ON(!ports[port_num].port)) { | |
1349 | mutex_unlock(&ports[port_num].lock); | |
ac90e365 | 1350 | return; |
19b10a88 SAS |
1351 | } |
1352 | port = ports[port_num].port; | |
1353 | ports[port_num].port = NULL; | |
1354 | mutex_unlock(&ports[port_num].lock); | |
ac90e365 | 1355 | |
19b10a88 SAS |
1356 | gserial_free_port(port); |
1357 | tty_unregister_device(gs_tty_driver, port_num); | |
a5beaaf3 | 1358 | gserial_console_exit(); |
19b10a88 SAS |
1359 | } |
1360 | EXPORT_SYMBOL_GPL(gserial_free_line); | |
937ef73d | 1361 | |
19b10a88 SAS |
1362 | int gserial_alloc_line(unsigned char *line_num) |
1363 | { | |
1364 | struct usb_cdc_line_coding coding; | |
1365 | struct device *tty_dev; | |
1366 | int ret; | |
1367 | int port_num; | |
c1dca562 | 1368 | |
19b10a88 SAS |
1369 | coding.dwDTERate = cpu_to_le32(9600); |
1370 | coding.bCharFormat = 8; | |
1371 | coding.bParityType = USB_CDC_NO_PARITY; | |
1372 | coding.bDataBits = USB_CDC_1_STOP_BITS; | |
c1dca562 | 1373 | |
19b10a88 SAS |
1374 | for (port_num = 0; port_num < MAX_U_SERIAL_PORTS; port_num++) { |
1375 | ret = gs_port_alloc(port_num, &coding); | |
1376 | if (ret == -EBUSY) | |
1377 | continue; | |
1378 | if (ret) | |
1379 | return ret; | |
1380 | break; | |
c1dca562 | 1381 | } |
19b10a88 SAS |
1382 | if (ret) |
1383 | return ret; | |
c1dca562 | 1384 | |
19b10a88 | 1385 | /* ... and sysfs class devices, so mdev/udev make /dev/ttyGS* */ |
c1dca562 | 1386 | |
19b10a88 SAS |
1387 | tty_dev = tty_port_register_device(&ports[port_num].port->port, |
1388 | gs_tty_driver, port_num, NULL); | |
1389 | if (IS_ERR(tty_dev)) { | |
1390 | struct gs_port *port; | |
1391 | pr_err("%s: failed to register tty for port %d, err %ld\n", | |
1392 | __func__, port_num, PTR_ERR(tty_dev)); | |
c1dca562 | 1393 | |
19b10a88 SAS |
1394 | ret = PTR_ERR(tty_dev); |
1395 | port = ports[port_num].port; | |
1396 | ports[port_num].port = NULL; | |
1397 | gserial_free_port(port); | |
1398 | goto err; | |
1399 | } | |
1400 | *line_num = port_num; | |
a5beaaf3 | 1401 | gserial_console_init(); |
19b10a88 SAS |
1402 | err: |
1403 | return ret; | |
c1dca562 | 1404 | } |
19b10a88 | 1405 | EXPORT_SYMBOL_GPL(gserial_alloc_line); |
c1dca562 DB |
1406 | |
1407 | /** | |
1408 | * gserial_connect - notify TTY I/O glue that USB link is active | |
1409 | * @gser: the function, set up with endpoints and descriptors | |
1410 | * @port_num: which port is active | |
1411 | * Context: any (usually from irq) | |
1412 | * | |
1413 | * This is called activate endpoints and let the TTY layer know that | |
1414 | * the connection is active ... not unlike "carrier detect". It won't | |
1415 | * necessarily start I/O queues; unless the TTY is held open by any | |
1416 | * task, there would be no point. However, the endpoints will be | |
1417 | * activated so the USB host can perform I/O, subject to basic USB | |
1418 | * hardware flow control. | |
1419 | * | |
1420 | * Caller needs to have set up the endpoints and USB function in @dev | |
1421 | * before calling this, as well as the appropriate (speed-specific) | |
19b10a88 SAS |
1422 | * endpoint descriptors, and also have allocate @port_num by calling |
1423 | * @gserial_alloc_line(). | |
c1dca562 DB |
1424 | * |
1425 | * Returns negative errno or zero. | |
1426 | * On success, ep->driver_data will be overwritten. | |
1427 | */ | |
1428 | int gserial_connect(struct gserial *gser, u8 port_num) | |
1429 | { | |
1430 | struct gs_port *port; | |
1431 | unsigned long flags; | |
1432 | int status; | |
1433 | ||
19b10a88 | 1434 | if (port_num >= MAX_U_SERIAL_PORTS) |
c1dca562 DB |
1435 | return -ENXIO; |
1436 | ||
c1dca562 | 1437 | port = ports[port_num].port; |
19b10a88 SAS |
1438 | if (!port) { |
1439 | pr_err("serial line %d not allocated.\n", port_num); | |
1440 | return -EINVAL; | |
1441 | } | |
1442 | if (port->port_usb) { | |
1443 | pr_err("serial line %d is in use.\n", port_num); | |
1444 | return -EBUSY; | |
1445 | } | |
c1dca562 DB |
1446 | |
1447 | /* activate the endpoints */ | |
72c973dd | 1448 | status = usb_ep_enable(gser->in); |
c1dca562 DB |
1449 | if (status < 0) |
1450 | return status; | |
1451 | gser->in->driver_data = port; | |
1452 | ||
72c973dd | 1453 | status = usb_ep_enable(gser->out); |
c1dca562 DB |
1454 | if (status < 0) |
1455 | goto fail_out; | |
1456 | gser->out->driver_data = port; | |
1457 | ||
1458 | /* then tell the tty glue that I/O can work */ | |
1459 | spin_lock_irqsave(&port->port_lock, flags); | |
1460 | gser->ioport = port; | |
1461 | port->port_usb = gser; | |
1462 | ||
1463 | /* REVISIT unclear how best to handle this state... | |
1464 | * we don't really couple it with the Linux TTY. | |
1465 | */ | |
1466 | gser->port_line_coding = port->port_line_coding; | |
1467 | ||
1468 | /* REVISIT if waiting on "carrier detect", signal. */ | |
1469 | ||
1f1ba11b DB |
1470 | /* if it's already open, start I/O ... and notify the serial |
1471 | * protocol about open/close status (connect/disconnect). | |
c1dca562 | 1472 | */ |
266e37ef | 1473 | if (port->port.count) { |
c1dca562 DB |
1474 | pr_debug("gserial_connect: start ttyGS%d\n", port->port_num); |
1475 | gs_start_io(port); | |
1f1ba11b DB |
1476 | if (gser->connect) |
1477 | gser->connect(gser); | |
1478 | } else { | |
1479 | if (gser->disconnect) | |
1480 | gser->disconnect(gser); | |
c1dca562 DB |
1481 | } |
1482 | ||
a5beaaf3 | 1483 | status = gs_console_connect(port_num); |
c1dca562 DB |
1484 | spin_unlock_irqrestore(&port->port_lock, flags); |
1485 | ||
1486 | return status; | |
1487 | ||
1488 | fail_out: | |
1489 | usb_ep_disable(gser->in); | |
c1dca562 DB |
1490 | return status; |
1491 | } | |
3249ca22 | 1492 | EXPORT_SYMBOL_GPL(gserial_connect); |
c1dca562 DB |
1493 | /** |
1494 | * gserial_disconnect - notify TTY I/O glue that USB link is inactive | |
1495 | * @gser: the function, on which gserial_connect() was called | |
1496 | * Context: any (usually from irq) | |
1497 | * | |
1498 | * This is called to deactivate endpoints and let the TTY layer know | |
1499 | * that the connection went inactive ... not unlike "hangup". | |
1500 | * | |
1501 | * On return, the state is as if gserial_connect() had never been called; | |
1502 | * there is no active USB I/O on these endpoints. | |
1503 | */ | |
1504 | void gserial_disconnect(struct gserial *gser) | |
1505 | { | |
1506 | struct gs_port *port = gser->ioport; | |
1507 | unsigned long flags; | |
1508 | ||
1509 | if (!port) | |
1510 | return; | |
1511 | ||
1512 | /* tell the TTY glue not to do I/O here any more */ | |
1513 | spin_lock_irqsave(&port->port_lock, flags); | |
1514 | ||
1515 | /* REVISIT as above: how best to track this? */ | |
1516 | port->port_line_coding = gser->port_line_coding; | |
1517 | ||
1518 | port->port_usb = NULL; | |
1519 | gser->ioport = NULL; | |
266e37ef | 1520 | if (port->port.count > 0 || port->openclose) { |
c1dca562 | 1521 | wake_up_interruptible(&port->drain_wait); |
35f95fd7 JS |
1522 | if (port->port.tty) |
1523 | tty_hangup(port->port.tty); | |
c1dca562 DB |
1524 | } |
1525 | spin_unlock_irqrestore(&port->port_lock, flags); | |
1526 | ||
1527 | /* disable endpoints, aborting down any active I/O */ | |
1528 | usb_ep_disable(gser->out); | |
c1dca562 | 1529 | usb_ep_disable(gser->in); |
c1dca562 DB |
1530 | |
1531 | /* finally, free any unused/unusable I/O buffers */ | |
1532 | spin_lock_irqsave(&port->port_lock, flags); | |
266e37ef | 1533 | if (port->port.count == 0 && !port->openclose) |
c1dca562 | 1534 | gs_buf_free(&port->port_write_buf); |
28609d40 JS |
1535 | gs_free_requests(gser->out, &port->read_pool, NULL); |
1536 | gs_free_requests(gser->out, &port->read_queue, NULL); | |
1537 | gs_free_requests(gser->in, &port->write_pool, NULL); | |
1538 | ||
1539 | port->read_allocated = port->read_started = | |
1540 | port->write_allocated = port->write_started = 0; | |
1541 | ||
a5beaaf3 | 1542 | gs_console_disconnect(gser->in); |
c1dca562 DB |
1543 | spin_unlock_irqrestore(&port->port_lock, flags); |
1544 | } | |
3249ca22 SAS |
1545 | EXPORT_SYMBOL_GPL(gserial_disconnect); |
1546 | ||
38b3ad56 | 1547 | static int userial_init(void) |
19b10a88 SAS |
1548 | { |
1549 | unsigned i; | |
1550 | int status; | |
1551 | ||
1552 | gs_tty_driver = alloc_tty_driver(MAX_U_SERIAL_PORTS); | |
1553 | if (!gs_tty_driver) | |
1554 | return -ENOMEM; | |
1555 | ||
1556 | gs_tty_driver->driver_name = "g_serial"; | |
c572a217 | 1557 | gs_tty_driver->name = "ttyGS"; |
19b10a88 SAS |
1558 | /* uses dynamically assigned dev_t values */ |
1559 | ||
1560 | gs_tty_driver->type = TTY_DRIVER_TYPE_SERIAL; | |
1561 | gs_tty_driver->subtype = SERIAL_TYPE_NORMAL; | |
1562 | gs_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV; | |
1563 | gs_tty_driver->init_termios = tty_std_termios; | |
1564 | ||
1565 | /* 9600-8-N-1 ... matches defaults expected by "usbser.sys" on | |
1566 | * MS-Windows. Otherwise, most of these flags shouldn't affect | |
1567 | * anything unless we were to actually hook up to a serial line. | |
1568 | */ | |
1569 | gs_tty_driver->init_termios.c_cflag = | |
1570 | B9600 | CS8 | CREAD | HUPCL | CLOCAL; | |
1571 | gs_tty_driver->init_termios.c_ispeed = 9600; | |
1572 | gs_tty_driver->init_termios.c_ospeed = 9600; | |
1573 | ||
1574 | tty_set_operations(gs_tty_driver, &gs_tty_ops); | |
1575 | for (i = 0; i < MAX_U_SERIAL_PORTS; i++) | |
1576 | mutex_init(&ports[i].lock); | |
1577 | ||
1578 | /* export the driver ... */ | |
1579 | status = tty_register_driver(gs_tty_driver); | |
1580 | if (status) { | |
1581 | pr_err("%s: cannot register, err %d\n", | |
1582 | __func__, status); | |
1583 | goto fail; | |
1584 | } | |
1585 | ||
1586 | pr_debug("%s: registered %d ttyGS* device%s\n", __func__, | |
1587 | MAX_U_SERIAL_PORTS, | |
1588 | (MAX_U_SERIAL_PORTS == 1) ? "" : "s"); | |
1589 | ||
1590 | return status; | |
1591 | fail: | |
1592 | put_tty_driver(gs_tty_driver); | |
1593 | gs_tty_driver = NULL; | |
1594 | return status; | |
1595 | } | |
1596 | module_init(userial_init); | |
1597 | ||
1598 | static void userial_cleanup(void) | |
1599 | { | |
1600 | tty_unregister_driver(gs_tty_driver); | |
1601 | put_tty_driver(gs_tty_driver); | |
1602 | gs_tty_driver = NULL; | |
1603 | } | |
1604 | module_exit(userial_cleanup); | |
1605 | ||
3249ca22 | 1606 | MODULE_LICENSE("GPL"); |