?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge commit '37e84ab74e939caf52150fc3352081786ecc0c29' into merges
[unleashed.git] / usr / src / uts / common / io / usb / clients / usbser / usbser.c
blob0fe258b713c6c2b548dc1b5ba1d6dfc2ae3d0657
1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26
27 /*
28 *
29 * USB generic serial driver (GSD)
30 *
31 */
32 #include <sys/types.h>
33 #include <sys/param.h>
34 #include <sys/stream.h>
35 #include <sys/stropts.h>
36 #include <sys/errno.h>
37 #include <sys/cred.h>
38 #include <sys/conf.h>
39 #include <sys/stat.h>
40 #include <sys/modctl.h>
41 #include <sys/ddi.h>
42 #include <sys/sunddi.h>
43 #include <sys/sunndi.h>
44 #include <sys/termio.h>
45 #include <sys/termiox.h>
46 #include <sys/stropts.h>
47 #include <sys/stream.h>
48 #include <sys/strsubr.h>
49 #include <sys/strsun.h>
50 #include <sys/strtty.h>
51 #include <sys/policy.h>
52 #include <sys/consdev.h>
53
54 #include <sys/usb/usba.h>
55 #include <sys/usb/clients/usbser/usbser_var.h>
56 #include <sys/usb/clients/usbser/usbser_dsdi.h>
57 #include <sys/usb/clients/usbser/usbser_rseq.h>
58 #include <sys/usb/usba/genconsole.h>
59
60 /* autoconfiguration subroutines */
61 static int usbser_rseq_do_cb(rseq_t *, int, uintptr_t);
62 static int usbser_free_soft_state(usbser_state_t *);
63 static int usbser_init_soft_state(usbser_state_t *);
64 static int usbser_fini_soft_state(usbser_state_t *);
65 static int usbser_attach_dev(usbser_state_t *);
66 static void usbser_detach_dev(usbser_state_t *);
67 static int usbser_attach_ports(usbser_state_t *);
68 static int usbser_create_port_minor_nodes(usbser_state_t *, int);
69 static void usbser_detach_ports(usbser_state_t *);
70 static int usbser_create_taskq(usbser_state_t *);
71 static void usbser_destroy_taskq(usbser_state_t *);
72 static void usbser_set_dev_state_init(usbser_state_t *);
73
74 /* hotplugging and power management */
75 static int usbser_disconnect_cb(dev_info_t *);
76 static int usbser_reconnect_cb(dev_info_t *);
77 static void usbser_disconnect_ports(usbser_state_t *);
78 static int usbser_cpr_suspend(dev_info_t *);
79 static int usbser_suspend_ports(usbser_state_t *);
80 static void usbser_cpr_resume(dev_info_t *);
81 static int usbser_restore_device_state(usbser_state_t *);
82 static void usbser_restore_ports_state(usbser_state_t *);
83
84 /* STREAMS subroutines */
85 static int usbser_open_setup(queue_t *, usbser_port_t *, int, int,
86 cred_t *);
87 static int usbser_open_init(usbser_port_t *, int);
88 static void usbser_check_port_props(usbser_port_t *);
89 static void usbser_open_fini(usbser_port_t *);
90 static int usbser_open_line_setup(usbser_port_t *, int, int);
91 static int usbser_open_carrier_check(usbser_port_t *, int, int);
92 static void usbser_open_queues_init(usbser_port_t *, queue_t *);
93 static void usbser_open_queues_fini(usbser_port_t *);
94 static void usbser_close_drain(usbser_port_t *);
95 static void usbser_close_cancel_break(usbser_port_t *);
96 static void usbser_close_hangup(usbser_port_t *);
97 static void usbser_close_cleanup(usbser_port_t *);
98
99 /* threads */
100 static void usbser_thr_dispatch(usbser_thread_t *);
101 static void usbser_thr_cancel(usbser_thread_t *);
102 static void usbser_thr_wake(usbser_thread_t *);
103 static void usbser_wq_thread(void *);
104 static void usbser_rq_thread(void *);
105
106 /* DSD callbacks */
107 static void usbser_tx_cb(caddr_t);
108 static void usbser_rx_cb(caddr_t);
109 static void usbser_rx_massage_data(usbser_port_t *, mblk_t *);
110 static void usbser_rx_massage_mbreak(usbser_port_t *, mblk_t *);
111 static void usbser_rx_cb_put(usbser_port_t *, queue_t *, queue_t *,
112 mblk_t *);
113 static void usbser_status_cb(caddr_t);
114 static void usbser_status_proc_cb(usbser_port_t *);
115
116 /* serial support */
117 static void usbser_wmsg(usbser_port_t *);
118 static int usbser_data(usbser_port_t *, mblk_t *);
119 static int usbser_ioctl(usbser_port_t *, mblk_t *);
120 static void usbser_iocdata(usbser_port_t *, mblk_t *);
121 static void usbser_stop(usbser_port_t *, mblk_t *);
122 static void usbser_start(usbser_port_t *, mblk_t *);
123 static void usbser_stopi(usbser_port_t *, mblk_t *);
124 static void usbser_starti(usbser_port_t *, mblk_t *);
125 static void usbser_flush(usbser_port_t *, mblk_t *);
126 static void usbser_break(usbser_port_t *, mblk_t *);
127 static void usbser_delay(usbser_port_t *, mblk_t *);
128 static void usbser_restart(void *);
129 static int usbser_port_program(usbser_port_t *);
130 static void usbser_inbound_flow_ctl(usbser_port_t *);
131
132 /* misc */
133 static int usbser_dev_is_online(usbser_state_t *);
134 static void usbser_serialize_port_act(usbser_port_t *, int);
135 static void usbser_release_port_act(usbser_port_t *, int);
136 #ifdef DEBUG
137 static char *usbser_msgtype2str(int);
138 static char *usbser_ioctl2str(int);
139 #endif
140
141 /* USBA events */
142 usb_event_t usbser_usb_events = {
143 usbser_disconnect_cb, /* disconnect */
144 usbser_reconnect_cb, /* reconnect */
145 NULL, /* pre-suspend */
146 NULL, /* pre-resume */
147 };
148
149 /* debug support */
150 uint_t usbser_errlevel = USB_LOG_L4;
151 uint_t usbser_errmask = DPRINT_MASK_ALL;
152 uint_t usbser_instance_debug = (uint_t)-1;
153
154 /* usb serial console */
155 static struct usbser_state *usbser_list;
156 static kmutex_t usbser_lock;
157 static int usbser_console_abort;
158 static usb_console_info_t console_input, console_output;
159 static uchar_t *console_input_buf;
160 static uchar_t *console_input_start, *console_input_end;
161
162 _NOTE(SCHEME_PROTECTS_DATA("unshared", usbser_console_abort))
163 _NOTE(SCHEME_PROTECTS_DATA("unshared", console_input))
164 _NOTE(SCHEME_PROTECTS_DATA("unshared", console_output))
165 _NOTE(SCHEME_PROTECTS_DATA("unshared", console_input_start))
166 _NOTE(SCHEME_PROTECTS_DATA("unshared", console_input_end))
167
168 static void usbser_putchar(cons_polledio_arg_t, uchar_t);
169 static int usbser_getchar(cons_polledio_arg_t);
170 static boolean_t usbser_ischar(cons_polledio_arg_t);
171 static void usbser_polledio_enter(cons_polledio_arg_t);
172 static void usbser_polledio_exit(cons_polledio_arg_t);
173 static int usbser_polledio_init(usbser_port_t *);
174 static void usbser_polledio_fini(usbser_port_t *);
175
176 static struct cons_polledio usbser_polledio = {
177 CONSPOLLEDIO_V1,
178 NULL, /* to be set later */
179 usbser_putchar,
180 usbser_getchar,
181 usbser_ischar,
182 usbser_polledio_enter,
183 usbser_polledio_exit
184 };
185
186 /* various statistics. TODO: replace with kstats */
187 static int usbser_st_tx_data_loss = 0;
188 static int usbser_st_rx_data_loss = 0;
189 static int usbser_st_put_stopi = 0;
190 static int usbser_st_mstop = 0;
191 static int usbser_st_mstart = 0;
192 static int usbser_st_mstopi = 0;
193 static int usbser_st_mstarti = 0;
194 static int usbser_st_rsrv = 0;
195 _NOTE(SCHEME_PROTECTS_DATA("monotonic stats", usbser_st_{
196 tx_data_loss rx_data_loss put_stopi mstop mstart mstopi mstarti rsrv}))
197 _NOTE(SCHEME_PROTECTS_DATA("unshared", usb_bulk_req_t))
198 _NOTE(SCHEME_PROTECTS_DATA("unshared", usb_intr_req_t))
199
200 /* taskq parameter */
201 extern pri_t minclsyspri;
202
203 /*
204 * modload support
205 */
206 extern struct mod_ops mod_miscops;
207
208 static struct modlmisc modlmisc = {
209 &mod_miscops, /* Type of module */
210 "USB generic serial module"
211 };
212
213 static struct modlinkage modlinkage = {
214 MODREV_1, (void *)&modlmisc, NULL
215 };
216
217
218 #define RSEQ(f1, f2) RSEQE(f1, usbser_rseq_do_cb, f2, NULL)
219
220
221 /*
222 * loadable module entry points
223 * ----------------------------
224 */
225
226 int
227 _init(void)
228 {
229 int err;
230
231 mutex_init(&usbser_lock, NULL, MUTEX_DRIVER, NULL);
232
233 if ((err = mod_install(&modlinkage)) != 0)
234 mutex_destroy(&usbser_lock);
235
236 return (err);
237 }
238
239
240 int
241 _fini(void)
242 {
243 int err;
244
245 if ((err = mod_remove(&modlinkage)) != 0)
246 return (err);
247
248 mutex_destroy(&usbser_lock);
249
250 return (0);
251 }
252
253
254 int
255 _info(struct modinfo *modinfop)
256 {
257 return (mod_info(&modlinkage, modinfop));
258 }
259
260
261 /*
262 * soft state size
263 */
264 int
265 usbser_soft_state_size()
266 {
267 return (sizeof (usbser_state_t));
268 }
269
270
271 /*
272 * autoconfiguration entry points
273 * ------------------------------
274 */
275
276 /*ARGSUSED*/
277 int
278 usbser_getinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg,
279 void **result, void *statep)
280 {
281 int instance;
282 int ret = DDI_FAILURE;
283 usbser_state_t *usbserp;
284
285 instance = USBSER_MINOR2INST(getminor((dev_t)arg));
286
287 switch (infocmd) {
288 case DDI_INFO_DEVT2DEVINFO:
289 *result = NULL;
290 usbserp = ddi_get_soft_state(statep, instance);
291 if (usbserp != NULL) {
292 *result = usbserp->us_dip;
293 if (*result != NULL) {
294 ret = DDI_SUCCESS;
295 }
296 }
297
298 break;
299 case DDI_INFO_DEVT2INSTANCE:
300 *result = (void *)(uintptr_t)instance;
301 ret = DDI_SUCCESS;
302
303 break;
304 default:
305 break;
306 }
307
308 return (ret);
309 }
310
311 /*
312 * device attach
313 */
314 static rseq_t rseq_att[] = {
315 RSEQ(NULL, usbser_free_soft_state),
316 RSEQ(usbser_init_soft_state, usbser_fini_soft_state),
317 RSEQ(usbser_attach_dev, usbser_detach_dev),
318 RSEQ(usbser_attach_ports, usbser_detach_ports),
319 RSEQ(usbser_create_taskq, usbser_destroy_taskq),
320 RSEQ(NULL, usbser_set_dev_state_init)
321 };
322
323 static void
324 usbser_insert(struct usbser_state *usp)
325 {
326 struct usbser_state *tmp;
327
328 mutex_enter(&usbser_lock);
329 tmp = usbser_list;
330 if (tmp == NULL)
331 usbser_list = usp;
332 else {
333 while (tmp->us_next)
334 tmp = tmp->us_next;
335 tmp->us_next = usp;
336 }
337 mutex_exit(&usbser_lock);
338 }
339
340 static void
341 usbser_remove(struct usbser_state *usp)
342 {
343 struct usbser_state *tmp, *prev = NULL;
344
345 mutex_enter(&usbser_lock);
346 tmp = usbser_list;
347 while (tmp != usp) {
348 prev = tmp;
349 tmp = tmp->us_next;
350 }
351 ASSERT(tmp == usp); /* must exist, else attach/detach wrong */
352 if (prev)
353 prev->us_next = usp->us_next;
354 else
355 usbser_list = usp->us_next;
356 usp->us_next = NULL;
357 mutex_exit(&usbser_lock);
358 }
359
360 /*
361 * Return the first serial device, with dip held. This is called
362 * from the console subsystem to place console on usb serial device.
363 */
364 dev_info_t *
365 usbser_first_device(void)
366 {
367 dev_info_t *dip = NULL;
368
369 mutex_enter(&usbser_lock);
370 if (usbser_list) {
371 dip = usbser_list->us_dip;
372 ndi_hold_devi(dip);
373 }
374 mutex_exit(&usbser_lock);
375
376 return (dip);
377 }
378
379 int
380 usbser_attach(dev_info_t *dip, ddi_attach_cmd_t cmd,
381 void *statep, ds_ops_t *ds_ops)
382 {
383 int instance;
384 usbser_state_t *usp;
385
386 instance = ddi_get_instance(dip);
387
388 switch (cmd) {
389 case DDI_ATTACH:
390
391 break;
392 case DDI_RESUME:
393 usbser_cpr_resume(dip);
394
395 return (DDI_SUCCESS);
396 default:
397
398 return (DDI_FAILURE);
399 }
400
401 /* allocate and get soft state */
402 if (ddi_soft_state_zalloc(statep, instance) != DDI_SUCCESS) {
403
404 return (DDI_FAILURE);
405 }
406 if ((usp = ddi_get_soft_state(statep, instance)) == NULL) {
407 ddi_soft_state_free(statep, instance);
408
409 return (DDI_FAILURE);
410 }
411
412 usp->us_statep = statep;
413 usp->us_dip = dip;
414 usp->us_instance = instance;
415 usp->us_ds_ops = ds_ops;
416
417 if (rseq_do(rseq_att, NELEM(rseq_att), (uintptr_t)usp, 0) == RSEQ_OK) {
418 ddi_report_dev(dip);
419 usbser_insert(usp);
420
421 return (DDI_SUCCESS);
422 } else {
423
424 return (DDI_FAILURE);
425 }
426 }
427
428 /*
429 * device detach
430 */
431 int
432 usbser_detach(dev_info_t *dip, ddi_detach_cmd_t cmd, void *statep)
433 {
434 int instance = ddi_get_instance(dip);
435 usbser_state_t *usp;
436 int rval;
437
438 usp = ddi_get_soft_state(statep, instance);
439
440 switch (cmd) {
441 case DDI_DETACH:
442 USB_DPRINTF_L4(DPRINT_DETACH, usp->us_lh, "usbser_detach");
443 usbser_remove(usp);
444 (void) rseq_undo(rseq_att, NELEM(rseq_att), (uintptr_t)usp, 0);
445 USB_DPRINTF_L4(DPRINT_DETACH, NULL,
446 "usbser_detach.%d: end", instance);
447
448 return (DDI_SUCCESS);
449 case DDI_SUSPEND:
450 rval = usbser_cpr_suspend(dip);
451
452 return ((rval == USB_SUCCESS)? DDI_SUCCESS : DDI_FAILURE);
453 default:
454
455 return (DDI_FAILURE);
456 }
457 }
458
459 /*
460 * STREAMS entry points
461 * --------------------
462 *
463 *
464 * port open
465 */
466 /*ARGSUSED*/
467 int
468 usbser_open(queue_t *rq, dev_t *dev, int flag, int sflag, cred_t *cr,
469 void *statep)
470 {
471 usbser_state_t *usp;
472 usbser_port_t *pp;
473 int minor = getminor(*dev);
474 int instance;
475 uint_t port_num;
476 int rval;
477
478 instance = USBSER_MINOR2INST(minor);
479 if (instance < 0) {
480
481 return (ENXIO);
482 }
483
484 usp = ddi_get_soft_state(statep, instance);
485 if (usp == NULL) {
486
487 return (ENXIO);
488 }
489
490 /* don't allow to open disconnected device */
491 mutex_enter(&usp->us_mutex);
492 if (usp->us_dev_state == USB_DEV_DISCONNECTED) {
493 mutex_exit(&usp->us_mutex);
494
495 return (ENXIO);
496 }
497 mutex_exit(&usp->us_mutex);
498
499 /* get port soft state */
500 port_num = USBSER_MINOR2PORT(minor);
501 if (port_num >= usp->us_port_cnt) {
502
503 return (ENXIO);
504 }
505 pp = &usp->us_ports[port_num];
506
507 /* set up everything for open */
508 rval = usbser_open_setup(rq, pp, minor, flag, cr);
509
510 USB_DPRINTF_L4(DPRINT_OPEN, pp->port_lh, "usbser_open: rval=%d", rval);
511
512 return (rval);
513 }
514
515
516 /*
517 * port close
518 *
519 * some things driver should do when the last app closes the line:
520 *
521 * drain data;
522 * cancel break/delay;
523 * hangup line (if necessary);
524 * DSD close;
525 * cleanup soft state;
526 */
527 /*ARGSUSED*/
528 int
529 usbser_close(queue_t *rq, int flag, cred_t *cr)
530 {
531 usbser_port_t *pp = (usbser_port_t *)rq->q_ptr;
532 int online;
533
534 if (pp == NULL) {
535
536 return (ENXIO);
537 }
538
539 online = usbser_dev_is_online(pp->port_usp);
540
541 /*
542 * in the closing state new activities will not be initiated
543 */
544 mutex_enter(&pp->port_mutex);
545 pp->port_state = USBSER_PORT_CLOSING;
546
547 if (online) {
548 /* drain the data */
549 usbser_close_drain(pp);
550 }
551
552 /* stop break/delay */
553 usbser_close_cancel_break(pp);
554
555 if (online) {
556 /* hangup line */
557 usbser_close_hangup(pp);
558 }
559
560 /*
561 * close DSD, cleanup state and transition to 'closed' state
562 */
563 usbser_close_cleanup(pp);
564 mutex_exit(&pp->port_mutex);
565
566 USB_DPRINTF_L4(DPRINT_CLOSE, pp->port_lh, "usbser_close: end");
567
568 return (0);
569 }
570
571
572 /*
573 * read side service routine: send as much as possible messages upstream
574 * and if there is still place on the queue, enable receive (if not already)
575 */
576 int
577 usbser_rsrv(queue_t *q)
578 {
579 usbser_port_t *pp = (usbser_port_t *)q->q_ptr;
580 mblk_t *mp;
581
582 usbser_st_rsrv++;
583 USB_DPRINTF_L4(DPRINT_RQ, pp->port_lh, "usbser_rsrv");
584
585 while (canputnext(q) && (mp = getq(q))) {
586 putnext(q, mp);
587 }
588
589 if (canputnext(q)) {
590 mutex_enter(&pp->port_mutex);
591 ASSERT(pp->port_state != USBSER_PORT_CLOSED);
592
593 if (USBSER_PORT_ACCESS_OK(pp)) {
594 usbser_thr_wake(&pp->port_rq_thread);
595 }
596 mutex_exit(&pp->port_mutex);
597 }
598
599 return (0);
600 }
601
602
603 /*
604 * wput: put message on the queue and wake wq thread
605 */
606 int
607 usbser_wput(queue_t *q, mblk_t *mp)
608 {
609 usbser_port_t *pp = (usbser_port_t *)q->q_ptr;
610
611 USB_DPRINTF_L4(DPRINT_WQ, pp->port_lh, "usbser_wput");
612
613 mutex_enter(&pp->port_mutex);
614 ASSERT(pp->port_state != USBSER_PORT_CLOSED);
615
616 /* ignore new messages if port is already closing */
617 if (pp->port_state == USBSER_PORT_CLOSING) {
618 freemsg(mp);
619 } else if (putq(q, mp)) {
620 /*
621 * this counter represents amount of tx data on the wq.
622 * each time the data is passed to DSD for transmission,
623 * the counter is decremented accordingly
624 */
625 pp->port_wq_data_cnt += msgdsize(mp);
626 } else {
627 usbser_st_tx_data_loss++;
628 }
629 mutex_exit(&pp->port_mutex);
630
631 return (0);
632 }
633
634
635 /*
636 * we need wsrv() routine to take advantage of STREAMS flow control:
637 * without it the framework will consider we are always able to process msgs
638 */
639 int
640 usbser_wsrv(queue_t *q)
641 {
642 usbser_port_t *pp = (usbser_port_t *)q->q_ptr;
643
644 USB_DPRINTF_L4(DPRINT_WQ, pp->port_lh, "usbser_wsrv");
645
646 mutex_enter(&pp->port_mutex);
647 ASSERT(pp->port_state != USBSER_PORT_CLOSED);
648
649 if (USBSER_PORT_ACCESS_OK(pp)) {
650 usbser_thr_wake(&pp->port_wq_thread);
651 }
652 mutex_exit(&pp->port_mutex);
653
654 return (0);
655 }
656
657
658 /*
659 * power entry point
660 */
661 int
662 usbser_power(dev_info_t *dip, int comp, int level)
663 {
664 void *statep;
665 usbser_state_t *usp;
666 int new_state;
667 int rval;
668
669 statep = ddi_get_driver_private(dip);
670 usp = ddi_get_soft_state(statep, ddi_get_instance(dip));
671
672 USB_DPRINTF_L3(DPRINT_EVENTS, usp->us_lh,
673 "usbser_power: dip=0x%p, comp=%d, level=%d",
674 (void *)dip, comp, level);
675
676 mutex_enter(&usp->us_mutex);
677 new_state = usp->us_dev_state;
678 mutex_exit(&usp->us_mutex);
679
680 /* let DSD do the job */
681 rval = USBSER_DS_USB_POWER(usp, comp, level, &new_state);
682
683 /* stay in sync with DSD */
684 mutex_enter(&usp->us_mutex);
685 usp->us_dev_state = new_state;
686 mutex_exit(&usp->us_mutex);
687
688 return ((rval == USB_SUCCESS) ? DDI_SUCCESS : DDI_FAILURE);
689 }
690
691
692 /*
693 *
694 * configuration entry point subroutines
695 * -------------------------------------
696 *
697 * rseq callback
698 */
699 static int
700 usbser_rseq_do_cb(rseq_t *rseq, int num, uintptr_t arg)
701 {
702 usbser_state_t *usp = (usbser_state_t *)arg;
703 int rval = rseq[num].r_do.s_rval;
704 char *name = rseq[num].r_do.s_name;
705
706 if (rval != DDI_SUCCESS) {
707 USB_DPRINTF_L2(DPRINT_ATTACH, usp->us_lh,
708 "do %s failed (%d)", name, rval);
709
710 return (RSEQ_UNDO);
711 } else {
712
713 return (RSEQ_OK);
714 }
715 }
716
717
718 /*
719 * free soft state
720 */
721 static int
722 usbser_free_soft_state(usbser_state_t *usp)
723 {
724 ddi_soft_state_free(usp->us_statep, usp->us_instance);
725
726 return (USB_SUCCESS);
727 }
728
729 /*
730 * init instance soft state
731 */
732 static int
733 usbser_init_soft_state(usbser_state_t *usp)
734 {
735 usp->us_lh = usb_alloc_log_hdl(usp->us_dip, "usbs[*].",
736 &usbser_errlevel, &usbser_errmask, &usbser_instance_debug,
737 0);
738 mutex_init(&usp->us_mutex, NULL, MUTEX_DRIVER, NULL);
739
740 /* save state pointer for use in event callbacks */
741 ddi_set_driver_private(usp->us_dip, usp->us_statep);
742
743 usp->us_dev_state = USBSER_DEV_INIT;
744
745 return (DDI_SUCCESS);
746 }
747
748 /*
749 * fini instance soft state
750 */
751 static int
752 usbser_fini_soft_state(usbser_state_t *usp)
753 {
754 usb_free_log_hdl(usp->us_lh);
755 mutex_destroy(&usp->us_mutex);
756 ddi_set_driver_private(usp->us_dip, NULL);
757
758 return (DDI_SUCCESS);
759 }
760
761 /*
762 * attach entire device
763 */
764 static int
765 usbser_attach_dev(usbser_state_t *usp)
766 {
767 ds_attach_info_t ai;
768 int rval;
769
770 usp->us_dev_state = USB_DEV_ONLINE;
771
772 ai.ai_dip = usp->us_dip;
773 ai.ai_usb_events = &usbser_usb_events;
774 ai.ai_hdl = &usp->us_ds_hdl;
775 ai.ai_port_cnt = &usp->us_port_cnt;
776
777 rval = USBSER_DS_ATTACH(usp, &ai);
778
779 if ((rval != USB_SUCCESS) || (usp->us_ds_hdl == NULL) ||
780 (usp->us_port_cnt == 0)) {
781 USB_DPRINTF_L4(DPRINT_ATTACH, usp->us_lh, "usbser_attach_dev: "
782 "failed %d %p %d", rval, usp->us_ds_hdl, usp->us_port_cnt);
783
784 return (DDI_FAILURE);
785 }
786
787 USB_DPRINTF_L4(DPRINT_ATTACH, usp->us_lh,
788 "usbser_attach_dev: port_cnt = %d", usp->us_port_cnt);
789
790 return (DDI_SUCCESS);
791 }
792
793
794 /*
795 * detach entire device
796 */
797 static void
798 usbser_detach_dev(usbser_state_t *usp)
799 {
800 USBSER_DS_DETACH(usp);
801 }
802
803
804 /*
805 * attach each individual port
806 */
807 static int
808 usbser_attach_ports(usbser_state_t *usp)
809 {
810 int i;
811 usbser_port_t *pp;
812 ds_cb_t ds_cb;
813
814 /*
815 * allocate port array
816 */
817 usp->us_ports = kmem_zalloc(usp->us_port_cnt *
818 sizeof (usbser_port_t), KM_SLEEP);
819
820 /* callback handlers */
821 ds_cb.cb_tx = usbser_tx_cb;
822 ds_cb.cb_rx = usbser_rx_cb;
823 ds_cb.cb_status = usbser_status_cb;
824
825 /*
826 * initialize each port
827 */
828 for (i = 0; i < usp->us_port_cnt; i++) {
829 pp = &usp->us_ports[i];
830
831 /*
832 * initialize data
833 */
834 pp->port_num = i;
835 pp->port_usp = usp;
836 pp->port_ds_ops = usp->us_ds_ops;
837 pp->port_ds_hdl = usp->us_ds_hdl;
838
839 /* allocate log handle */
840 (void) sprintf(pp->port_lh_name, "usbs[%d].", i);
841 pp->port_lh = usb_alloc_log_hdl(usp->us_dip,
842 pp->port_lh_name, &usbser_errlevel, &usbser_errmask,
843 &usbser_instance_debug, 0);
844
845 mutex_init(&pp->port_mutex, NULL, MUTEX_DRIVER, NULL);
846 cv_init(&pp->port_state_cv, NULL, CV_DEFAULT, NULL);
847 cv_init(&pp->port_act_cv, NULL, CV_DEFAULT, NULL);
848 cv_init(&pp->port_car_cv, NULL, CV_DEFAULT, NULL);
849
850 /*
851 * init threads
852 */
853 pp->port_wq_thread.thr_port = pp;
854 pp->port_wq_thread.thr_func = usbser_wq_thread;
855 pp->port_wq_thread.thr_arg = (void *)&pp->port_wq_thread;
856 cv_init(&pp->port_wq_thread.thr_cv, NULL, CV_DEFAULT, NULL);
857
858 pp->port_rq_thread.thr_port = pp;
859 pp->port_rq_thread.thr_func = usbser_rq_thread;
860 pp->port_rq_thread.thr_arg = (void *)&pp->port_rq_thread;
861 cv_init(&pp->port_rq_thread.thr_cv, NULL, CV_DEFAULT, NULL);
862
863 /*
864 * register callbacks
865 */
866 ds_cb.cb_arg = (caddr_t)pp;
867 USBSER_DS_REGISTER_CB(usp, i, &ds_cb);
868
869 pp->port_state = USBSER_PORT_CLOSED;
870
871 if (usbser_create_port_minor_nodes(usp, i) != USB_SUCCESS) {
872 usbser_detach_ports(usp);
873
874 return (DDI_FAILURE);
875 }
876 }
877
878 return (DDI_SUCCESS);
879 }
880
881
882 /*
883 * create a pair of minor nodes for the port
884 */
885 static int
886 usbser_create_port_minor_nodes(usbser_state_t *usp, int port_num)
887 {
888 int instance = usp->us_instance;
889 minor_t minor;
890 char name[16];
891
892 /*
893 * tty node
894 */
895 (void) sprintf(name, "%d", port_num);
896 minor = USBSER_MAKEMINOR(instance, port_num, 0);
897
898 if (ddi_create_minor_node(usp->us_dip, name,
899 S_IFCHR, minor, DDI_NT_SERIAL, 0) != DDI_SUCCESS) {
900
901 return (USB_FAILURE);
902 }
903
904 /*
905 * dial-out node
906 */
907 (void) sprintf(name, "%d,cu", port_num);
908 minor = USBSER_MAKEMINOR(instance, port_num, OUTLINE);
909
910 if (ddi_create_minor_node(usp->us_dip, name,
911 S_IFCHR, minor, DDI_NT_SERIAL_DO, 0) != DDI_SUCCESS) {
912
913 return (USB_FAILURE);
914 }
915
916 return (USB_SUCCESS);
917 }
918
919
920 /*
921 * detach each port individually
922 */
923 static void
924 usbser_detach_ports(usbser_state_t *usp)
925 {
926 int i;
927 int sz;
928 usbser_port_t *pp;
929
930 /*
931 * remove all minor nodes
932 */
933 ddi_remove_minor_node(usp->us_dip, NULL);
934
935 for (i = 0; i < usp->us_port_cnt; i++) {
936 pp = &usp->us_ports[i];
937
938 if (pp->port_state != USBSER_PORT_CLOSED) {
939 ASSERT(pp->port_state == USBSER_PORT_NOT_INIT);
940
941 continue;
942 }
943
944 USBSER_DS_UNREGISTER_CB(usp, i);
945
946 mutex_destroy(&pp->port_mutex);
947 cv_destroy(&pp->port_state_cv);
948 cv_destroy(&pp->port_act_cv);
949 cv_destroy(&pp->port_car_cv);
950
951 cv_destroy(&pp->port_wq_thread.thr_cv);
952 cv_destroy(&pp->port_rq_thread.thr_cv);
953
954 usb_free_log_hdl(pp->port_lh);
955 }
956
957 /*
958 * free memory
959 */
960 sz = usp->us_port_cnt * sizeof (usbser_port_t);
961 kmem_free(usp->us_ports, sz);
962 usp->us_ports = NULL;
963 }
964
965
966 /*
967 * create a taskq with two threads per port (read and write sides)
968 */
969 static int
970 usbser_create_taskq(usbser_state_t *usp)
971 {
972 int nthr = usp->us_port_cnt * 2;
973
974 usp->us_taskq = ddi_taskq_create(usp->us_dip, "usbser_taskq",
975 nthr, TASKQ_DEFAULTPRI, 0);
976
977 return ((usp->us_taskq == NULL) ? DDI_FAILURE : DDI_SUCCESS);
978 }
979
980
981 static void
982 usbser_destroy_taskq(usbser_state_t *usp)
983 {
984 ddi_taskq_destroy(usp->us_taskq);
985 }
986
987
988 static void
989 usbser_set_dev_state_init(usbser_state_t *usp)
990 {
991 mutex_enter(&usp->us_mutex);
992 usp->us_dev_state = USBSER_DEV_INIT;
993 mutex_exit(&usp->us_mutex);
994 }
995
996 /*
997 * hotplugging and power management
998 * ---------------------------------
999 *
1000 * disconnect event callback
1001 */
1002 /*ARGSUSED*/
1003 static int
1004 usbser_disconnect_cb(dev_info_t *dip)
1005 {
1006 void *statep;
1007 usbser_state_t *usp;
1008
1009 statep = ddi_get_driver_private(dip);
1010 usp = ddi_get_soft_state(statep, ddi_get_instance(dip));
1011
1012 USB_DPRINTF_L3(DPRINT_EVENTS, usp->us_lh,
1013 "usbser_disconnect_cb: dip=%p", (void *)dip);
1014
1015 mutex_enter(&usp->us_mutex);
1016 switch (usp->us_dev_state) {
1017 case USB_DEV_ONLINE:
1018 case USB_DEV_PWRED_DOWN:
1019 /* prevent further activity */
1020 usp->us_dev_state = USB_DEV_DISCONNECTED;
1021 mutex_exit(&usp->us_mutex);
1022
1023 /* see if any of the ports are open and do necessary handling */
1024 usbser_disconnect_ports(usp);
1025
1026 /* call DSD to do any necessary work */
1027 if (USBSER_DS_DISCONNECT(usp) != USB_DEV_DISCONNECTED) {
1028 USB_DPRINTF_L2(DPRINT_EVENTS, usp->us_lh,
1029 "usbser_disconnect_cb: ds_disconnect failed");
1030 }
1031
1032 break;
1033 case USB_DEV_SUSPENDED:
1034 /* we remain suspended */
1035 default:
1036 mutex_exit(&usp->us_mutex);
1037
1038 break;
1039 }
1040
1041 return (USB_SUCCESS);
1042 }
1043
1044
1045 /*
1046 * reconnect event callback
1047 */
1048 /*ARGSUSED*/
1049 static int
1050 usbser_reconnect_cb(dev_info_t *dip)
1051 {
1052 void *statep;
1053 usbser_state_t *usp;
1054
1055 statep = ddi_get_driver_private(dip);
1056 usp = ddi_get_soft_state(statep, ddi_get_instance(dip));
1057
1058 USB_DPRINTF_L3(DPRINT_EVENTS, usp->us_lh,
1059 "usbser_reconnect_cb: dip=%p", (void *)dip);
1060
1061 (void) usbser_restore_device_state(usp);
1062
1063 return (USB_SUCCESS);
1064 }
1065
1066
1067 /*
1068 * if any of the ports is open during disconnect,
1069 * send M_HANGUP message upstream and log a warning
1070 */
1071 static void
1072 usbser_disconnect_ports(usbser_state_t *usp)
1073 {
1074 usbser_port_t *pp;
1075 queue_t *rq;
1076 int complain = 0;
1077 int hangup = 0;
1078 timeout_id_t delay_id = 0;
1079 int i;
1080
1081 if (usp->us_ports == NULL) {
1082 return;
1083 }
1084
1085 for (i = 0; i < usp->us_port_cnt; i++) {
1086 pp = &usp->us_ports[i];
1087
1088 mutex_enter(&pp->port_mutex);
1089 if (pp->port_state == USBSER_PORT_OPEN ||
1090 USBSER_IS_OPENING(pp) ||
1091 pp->port_state == USBSER_PORT_CLOSING) {
1092 complain = 1;
1093 }
1094
1095 if (pp->port_state == USBSER_PORT_OPEN) {
1096 rq = pp->port_ttycommon.t_readq;
1097
1098 /*
1099 * hangup the stream; will send actual
1100 * M_HANGUP message after releasing mutex
1101 */
1102 pp->port_flags |= USBSER_FL_HUNGUP;
1103 hangup = 1;
1104
1105 /*
1106 * cancel all activities
1107 */
1108 usbser_release_port_act(pp, USBSER_ACT_ALL);
1109
1110 delay_id = pp->port_delay_id;
1111 pp->port_delay_id = 0;
1112
1113 /* mark disconnected */
1114 pp->port_state = USBSER_PORT_DISCONNECTED;
1115 cv_broadcast(&pp->port_state_cv);
1116 }
1117 mutex_exit(&pp->port_mutex);
1118
1119 if (hangup) {
1120 (void) putnextctl(rq, M_HANGUP);
1121 hangup = 0;
1122 }
1123
1124 /*
1125 * we couldn't untimeout while holding the mutex - do it now
1126 */
1127 if (delay_id) {
1128 (void) untimeout(delay_id);
1129 delay_id = 0;
1130 }
1131 }
1132
1133 /*
1134 * complain about disconnecting device while open
1135 */
1136 if (complain) {
1137 USB_DPRINTF_L0(DPRINT_EVENTS, usp->us_lh, "device was "
1138 "disconnected while open. Data may have been lost");
1139 }
1140 }
1141
1142
1143 /*
1144 * do CPR suspend
1145 *
1146 * We use a trivial CPR strategy - fail if any of the device's ports are open.
1147 * The problem with more sophisticated strategies is that each open port uses
1148 * two threads that sit in the loop until the port is closed, while CPR has to
1149 * stop all kernel threads to succeed. Stopping port threads is a rather
1150 * intrusive and delicate procedure; I leave it as an RFE for now.
1151 *
1152 */
1153 static int
1154 usbser_cpr_suspend(dev_info_t *dip)
1155 {
1156 void *statep;
1157 usbser_state_t *usp;
1158 int new_state;
1159 int rval;
1160
1161 statep = ddi_get_driver_private(dip);
1162 usp = ddi_get_soft_state(statep, ddi_get_instance(dip));
1163
1164 USB_DPRINTF_L4(DPRINT_EVENTS, usp->us_lh, "usbser_cpr_suspend");
1165
1166 /* suspend each port first */
1167 if (usbser_suspend_ports(usp) != USB_SUCCESS) {
1168 USB_DPRINTF_L3(DPRINT_EVENTS, usp->us_lh,
1169 "usbser_cpr_suspend: GSD failure");
1170
1171 return (USB_FAILURE);
1172 }
1173
1174 new_state = USBSER_DS_SUSPEND(usp); /* let DSD do its part */
1175
1176 mutex_enter(&usp->us_mutex);
1177 if (new_state == USB_DEV_SUSPENDED) {
1178 rval = USB_SUCCESS;
1179 } else {
1180 ASSERT(new_state == USB_DEV_ONLINE);
1181 rval = USB_FAILURE;
1182 }
1183 usp->us_dev_state = new_state;
1184 mutex_exit(&usp->us_mutex);
1185
1186 return (rval);
1187 }
1188
1189
1190 static int
1191 usbser_suspend_ports(usbser_state_t *usp)
1192 {
1193 usbser_port_t *pp;
1194 int i;
1195
1196 for (i = 0; i < usp->us_port_cnt; i++) {
1197 pp = &usp->us_ports[i];
1198
1199 mutex_enter(&pp->port_mutex);
1200 if (pp->port_state != USBSER_PORT_CLOSED) {
1201 mutex_exit(&pp->port_mutex);
1202
1203 return (USB_FAILURE);
1204 }
1205 mutex_exit(&pp->port_mutex);
1206 }
1207
1208 return (USB_SUCCESS);
1209 }
1210
1211
1212 /*
1213 * do CPR resume
1214 *
1215 * DSD will return USB_DEV_ONLINE in case of success
1216 */
1217 static void
1218 usbser_cpr_resume(dev_info_t *dip)
1219 {
1220 void *statep;
1221 usbser_state_t *usp;
1222
1223 statep = ddi_get_driver_private(dip);
1224 usp = ddi_get_soft_state(statep, ddi_get_instance(dip));
1225
1226 USB_DPRINTF_L3(DPRINT_EVENTS, usp->us_lh, "usbser_cpr_resume");
1227
1228 (void) usbser_restore_device_state(usp);
1229 }
1230
1231
1232 /*
1233 * restore device state after CPR resume or reconnect
1234 */
1235 static int
1236 usbser_restore_device_state(usbser_state_t *usp)
1237 {
1238 int new_state, current_state;
1239
1240 /* needed as power up state of dev is "unknown" to system */
1241 (void) pm_busy_component(usp->us_dip, 0);
1242 (void) pm_raise_power(usp->us_dip, 0, USB_DEV_OS_FULL_PWR);
1243
1244 mutex_enter(&usp->us_mutex);
1245 current_state = usp->us_dev_state;
1246 mutex_exit(&usp->us_mutex);
1247
1248 ASSERT((current_state == USB_DEV_DISCONNECTED) ||
1249 (current_state == USB_DEV_SUSPENDED));
1250
1251 /*
1252 * call DSD to perform device-specific work
1253 */
1254 if (current_state == USB_DEV_DISCONNECTED) {
1255 new_state = USBSER_DS_RECONNECT(usp);
1256 } else {
1257 new_state = USBSER_DS_RESUME(usp);
1258 }
1259
1260 mutex_enter(&usp->us_mutex);
1261 usp->us_dev_state = new_state;
1262 mutex_exit(&usp->us_mutex);
1263
1264 if (new_state == USB_DEV_ONLINE) {
1265 /*
1266 * restore ports state
1267 */
1268 usbser_restore_ports_state(usp);
1269 }
1270
1271 (void) pm_idle_component(usp->us_dip, 0);
1272
1273 return (USB_SUCCESS);
1274 }
1275
1276
1277 /*
1278 * restore ports state after device reconnect/resume
1279 */
1280 static void
1281 usbser_restore_ports_state(usbser_state_t *usp)
1282 {
1283 usbser_port_t *pp;
1284 queue_t *rq;
1285 int i;
1286
1287 for (i = 0; i < usp->us_port_cnt; i++) {
1288 pp = &usp->us_ports[i];
1289
1290 mutex_enter(&pp->port_mutex);
1291 /*
1292 * only care about ports that are open
1293 */
1294 if ((pp->port_state != USBSER_PORT_SUSPENDED) &&
1295 (pp->port_state != USBSER_PORT_DISCONNECTED)) {
1296 mutex_exit(&pp->port_mutex);
1297
1298 continue;
1299 }
1300
1301 pp->port_state = USBSER_PORT_OPEN;
1302
1303 /*
1304 * if the stream was hung up during disconnect, restore it
1305 */
1306 if (pp->port_flags & USBSER_FL_HUNGUP) {
1307 pp->port_flags &= ~USBSER_FL_HUNGUP;
1308 rq = pp->port_ttycommon.t_readq;
1309
1310 mutex_exit(&pp->port_mutex);
1311 (void) putnextctl(rq, M_UNHANGUP);
1312 mutex_enter(&pp->port_mutex);
1313 }
1314
1315 /*
1316 * restore serial parameters
1317 */
1318 (void) usbser_port_program(pp);
1319
1320 /*
1321 * wake anything that might be sleeping
1322 */
1323 cv_broadcast(&pp->port_state_cv);
1324 cv_broadcast(&pp->port_act_cv);
1325 usbser_thr_wake(&pp->port_wq_thread);
1326 usbser_thr_wake(&pp->port_rq_thread);
1327 mutex_exit(&pp->port_mutex);
1328 }
1329 }
1330
1331
1332 /*
1333 * STREAMS subroutines
1334 * -------------------
1335 *
1336 *
1337 * port open state machine
1338 *
1339 * here's a list of things that the driver has to do while open;
1340 * because device can be opened any number of times,
1341 * initial open has additional responsibilities:
1342 *
1343 * if (initial_open) {
1344 * initialize soft state; \
1345 * DSD open; - see usbser_open_init()
1346 * dispatch threads; /
1347 * }
1348 * raise DTR;
1349 * wait for carrier (if necessary);
1350 *
1351 * we should also take into consideration that two threads can try to open
1352 * the same physical port simultaneously (/dev/term/N and /dev/cua/N).
1353 *
1354 * return values:
1355 * 0 - success;
1356 * >0 - fail with this error code;
1357 */
1358 static int
1359 usbser_open_setup(queue_t *rq, usbser_port_t *pp, int minor, int flag,
1360 cred_t *cr)
1361 {
1362 int rval = USBSER_CONTINUE;
1363
1364 mutex_enter(&pp->port_mutex);
1365 /*
1366 * refer to port state diagram in the header file
1367 */
1368 loop:
1369 switch (pp->port_state) {
1370 case USBSER_PORT_CLOSED:
1371 /*
1372 * initial open
1373 */
1374 rval = usbser_open_init(pp, minor);
1375
1376 break;
1377 case USBSER_PORT_OPENING_TTY:
1378 /*
1379 * dial-out thread can overtake the port
1380 * if tty open thread is sleeping waiting for carrier
1381 */
1382 if ((minor & OUTLINE) && (pp->port_flags & USBSER_FL_WOPEN)) {
1383 pp->port_state = USBSER_PORT_OPENING_OUT;
1384
1385 USB_DPRINTF_L3(DPRINT_OPEN, pp->port_lh,
1386 "usbser_open_state: overtake");
1387 }
1388
1389 /* FALLTHRU */
1390 case USBSER_PORT_OPENING_OUT:
1391 /*
1392 * if no other open in progress, setup the line
1393 */
1394 if (USBSER_NO_OTHER_OPEN(pp, minor)) {
1395 rval = usbser_open_line_setup(pp, minor, flag);
1396
1397 break;
1398 }
1399
1400 /* FALLTHRU */
1401 case USBSER_PORT_CLOSING:
1402 /*
1403 * wait until close active phase ends
1404 */
1405 if (cv_wait_sig(&pp->port_state_cv, &pp->port_mutex) == 0) {
1406 rval = EINTR;
1407 }
1408
1409 break;
1410 case USBSER_PORT_OPEN:
1411 if ((pp->port_ttycommon.t_flags & TS_XCLUDE) &&
1412 secpolicy_excl_open(cr) != 0) {
1413 /*
1414 * exclusive use
1415 */
1416 rval = EBUSY;
1417 } else if (USBSER_OPEN_IN_OTHER_MODE(pp, minor)) {
1418 /*
1419 * tty and dial-out modes are mutually exclusive
1420 */
1421 rval = EBUSY;
1422 } else {
1423 /*
1424 * port is being re-open in the same mode
1425 */
1426 rval = usbser_open_line_setup(pp, minor, flag);
1427 }
1428
1429 break;
1430 default:
1431 rval = ENXIO;
1432
1433 break;
1434 }
1435
1436 if (rval == USBSER_CONTINUE) {
1437
1438 goto loop;
1439 }
1440
1441 /*
1442 * initial open requires additional handling
1443 */
1444 if (USBSER_IS_OPENING(pp)) {
1445 if (rval == USBSER_COMPLETE) {
1446 if (pp->port_state == USBSER_PORT_OPENING_OUT) {
1447 pp->port_flags |= USBSER_FL_OUT;
1448 }
1449 pp->port_state = USBSER_PORT_OPEN;
1450 cv_broadcast(&pp->port_state_cv);
1451
1452 usbser_open_queues_init(pp, rq);
1453 } else {
1454 usbser_open_fini(pp);
1455 }
1456 }
1457 mutex_exit(&pp->port_mutex);
1458
1459 return (rval);
1460 }
1461
1462
1463 /*
1464 * initialize the port when opened for the first time
1465 */
1466 static int
1467 usbser_open_init(usbser_port_t *pp, int minor)
1468 {
1469 usbser_state_t *usp = pp->port_usp;
1470 tty_common_t *tp = &pp->port_ttycommon;
1471 int rval = ENXIO;
1472
1473 ASSERT(pp->port_state == USBSER_PORT_CLOSED);
1474
1475 /*
1476 * init state
1477 */
1478 pp->port_act = 0;
1479 pp->port_flags &= USBSER_FL_PRESERVE;
1480 pp->port_flowc = '\0';
1481 pp->port_wq_data_cnt = 0;
1482
1483 if (minor & OUTLINE) {
1484 pp->port_state = USBSER_PORT_OPENING_OUT;
1485 } else {
1486 pp->port_state = USBSER_PORT_OPENING_TTY;
1487 }
1488
1489 /*
1490 * init termios settings
1491 */
1492 tp->t_iflag = 0;
1493 tp->t_iocpending = NULL;
1494 tp->t_size.ws_row = tp->t_size.ws_col = 0;
1495 tp->t_size.ws_xpixel = tp->t_size.ws_ypixel = 0;
1496 tp->t_startc = CSTART;
1497 tp->t_stopc = CSTOP;
1498
1499 usbser_check_port_props(pp);
1500
1501 /*
1502 * dispatch wq and rq threads:
1503 * although queues are not enabled at this point,
1504 * we will need wq to run status processing callback
1505 */
1506 usbser_thr_dispatch(&pp->port_wq_thread);
1507 usbser_thr_dispatch(&pp->port_rq_thread);
1508
1509 /*
1510 * open DSD port
1511 */
1512 mutex_exit(&pp->port_mutex);
1513 rval = USBSER_DS_OPEN_PORT(usp, pp->port_num);
1514 mutex_enter(&pp->port_mutex);
1515
1516 if (rval != USB_SUCCESS) {
1517
1518 return (ENXIO);
1519 }
1520 pp->port_flags |= USBSER_FL_DSD_OPEN;
1521
1522 /*
1523 * program port with default parameters
1524 */
1525 if ((rval = usbser_port_program(pp)) != 0) {
1526
1527 return (ENXIO);
1528 }
1529
1530 return (USBSER_CONTINUE);
1531 }
1532
1533
1534 /*
1535 * create a pair of minor nodes for the port
1536 */
1537 static void
1538 usbser_check_port_props(usbser_port_t *pp)
1539 {
1540 dev_info_t *dip = pp->port_usp->us_dip;
1541 tty_common_t *tp = &pp->port_ttycommon;
1542 struct termios *termiosp;
1543 uint_t len;
1544 char name[20];
1545
1546 /*
1547 * take default modes from "ttymodes" property if it exists
1548 */
1549 if (ddi_prop_lookup_byte_array(DDI_DEV_T_ANY, ddi_root_node(), 0,
1550 "ttymodes", (uchar_t **)&termiosp, &len) == DDI_PROP_SUCCESS) {
1551
1552 if (len == sizeof (struct termios)) {
1553 tp->t_cflag = termiosp->c_cflag;
1554
1555 if (termiosp->c_iflag & (IXON | IXANY)) {
1556 tp->t_iflag =
1557 termiosp->c_iflag & (IXON | IXANY);
1558 tp->t_startc = termiosp->c_cc[VSTART];
1559 tp->t_stopc = termiosp->c_cc[VSTOP];
1560 }
1561 }
1562 ddi_prop_free(termiosp);
1563 }
1564
1565 /*
1566 * look for "ignore-cd" or "port-N-ignore-cd" property
1567 */
1568 (void) sprintf(name, "port-%d-ignore-cd", pp->port_num);
1569 if (ddi_prop_get_int(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS,
1570 "ignore-cd", 0) ||
1571 ddi_prop_get_int(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS, name, 0)) {
1572 pp->port_flags |= USBSER_FL_IGNORE_CD;
1573 } else {
1574 pp->port_flags &= ~USBSER_FL_IGNORE_CD;
1575 }
1576 }
1577
1578
1579 /*
1580 * undo what was done in usbser_open_init()
1581 */
1582 static void
1583 usbser_open_fini(usbser_port_t *pp)
1584 {
1585 uint_t port_num = pp->port_num;
1586 usbser_state_t *usp = pp->port_usp;
1587
1588 /*
1589 * close DSD if it is open
1590 */
1591 if (pp->port_flags & USBSER_FL_DSD_OPEN) {
1592 mutex_exit(&pp->port_mutex);
1593 if (USBSER_DS_CLOSE_PORT(usp, port_num) != USB_SUCCESS) {
1594 USB_DPRINTF_L2(DPRINT_CLOSE, pp->port_lh,
1595 "usbser_open_fini: CLOSE_PORT fail");
1596 }
1597 mutex_enter(&pp->port_mutex);
1598 }
1599
1600 /*
1601 * cancel threads
1602 */
1603 usbser_thr_cancel(&pp->port_wq_thread);
1604 usbser_thr_cancel(&pp->port_rq_thread);
1605
1606 /*
1607 * unpdate soft state
1608 */
1609 pp->port_state = USBSER_PORT_CLOSED;
1610 cv_broadcast(&pp->port_state_cv);
1611 cv_broadcast(&pp->port_car_cv);
1612 }
1613
1614
1615 /*
1616 * setup serial line
1617 */
1618 static int
1619 usbser_open_line_setup(usbser_port_t *pp, int minor, int flag)
1620 {
1621 int rval;
1622
1623 mutex_exit(&pp->port_mutex);
1624 /*
1625 * prevent opening a disconnected device
1626 */
1627 if (!usbser_dev_is_online(pp->port_usp)) {
1628 mutex_enter(&pp->port_mutex);
1629
1630 return (ENXIO);
1631 }
1632
1633 /* raise DTR on every open */
1634 (void) USBSER_DS_SET_MODEM_CTL(pp, TIOCM_DTR, TIOCM_DTR);
1635
1636 mutex_enter(&pp->port_mutex);
1637 /*
1638 * check carrier
1639 */
1640 rval = usbser_open_carrier_check(pp, minor, flag);
1641
1642 return (rval);
1643 }
1644
1645
1646 /*
1647 * check carrier and wait if needed
1648 */
1649 static int
1650 usbser_open_carrier_check(usbser_port_t *pp, int minor, int flag)
1651 {
1652 tty_common_t *tp = &pp->port_ttycommon;
1653 int val = 0;
1654 int rval;
1655
1656 if (pp->port_flags & USBSER_FL_IGNORE_CD) {
1657 tp->t_flags |= TS_SOFTCAR;
1658 }
1659
1660 /*
1661 * check carrier
1662 */
1663 if (tp->t_flags & TS_SOFTCAR) {
1664 pp->port_flags |= USBSER_FL_CARR_ON;
1665 } else if (USBSER_DS_GET_MODEM_CTL(pp, TIOCM_CD, &val) != USB_SUCCESS) {
1666
1667 return (ENXIO);
1668 } else if (val & TIOCM_CD) {
1669 pp->port_flags |= USBSER_FL_CARR_ON;
1670 } else {
1671 pp->port_flags &= ~USBSER_FL_CARR_ON;
1672 }
1673
1674 /*
1675 * don't block if 1) not allowed to, 2) this is a local device,
1676 * 3) opening in dial-out mode, or 4) carrier is already on
1677 */
1678 if ((flag & (FNDELAY | FNONBLOCK)) || (tp->t_cflag & CLOCAL) ||
1679 (minor & OUTLINE) || (pp->port_flags & USBSER_FL_CARR_ON)) {
1680
1681 return (USBSER_COMPLETE);
1682 }
1683
1684 /*
1685 * block until carrier up (only in tty mode)
1686 */
1687 USB_DPRINTF_L4(DPRINT_OPEN, pp->port_lh,
1688 "usbser_open_carrier_check: waiting for carrier...");
1689
1690 pp->port_flags |= USBSER_FL_WOPEN;
1691
1692 rval = cv_wait_sig(&pp->port_car_cv, &pp->port_mutex);
1693
1694 pp->port_flags &= ~USBSER_FL_WOPEN;
1695
1696 if (rval == 0) {
1697 /*
1698 * interrupted with a signal
1699 */
1700 return (EINTR);
1701 } else {
1702 /*
1703 * try again
1704 */
1705 return (USBSER_CONTINUE);
1706 }
1707 }
1708
1709
1710 /*
1711 * during open, setup queues and message processing
1712 */
1713 static void
1714 usbser_open_queues_init(usbser_port_t *pp, queue_t *rq)
1715 {
1716 pp->port_ttycommon.t_readq = rq;
1717 pp->port_ttycommon.t_writeq = WR(rq);
1718 rq->q_ptr = WR(rq)->q_ptr = (caddr_t)pp;
1719
1720 qprocson(rq);
1721 }
1722
1723
1724 /*
1725 * clean up queues and message processing
1726 */
1727 static void
1728 usbser_open_queues_fini(usbser_port_t *pp)
1729 {
1730 queue_t *rq = pp->port_ttycommon.t_readq;
1731
1732 mutex_exit(&pp->port_mutex);
1733 /*
1734 * clean up queues
1735 */
1736 qprocsoff(rq);
1737
1738 /*
1739 * free unused messages
1740 */
1741 flushq(rq, FLUSHALL);
1742 flushq(WR(rq), FLUSHALL);
1743
1744 rq->q_ptr = WR(rq)->q_ptr = NULL;
1745 ttycommon_close(&pp->port_ttycommon);
1746 mutex_enter(&pp->port_mutex);
1747 }
1748
1749
1750 /*
1751 * during close, wait until pending data is gone or the signal is sent
1752 */
1753 static void
1754 usbser_close_drain(usbser_port_t *pp)
1755 {
1756 int need_drain;
1757 clock_t until;
1758 int rval = USB_SUCCESS;
1759
1760 /*
1761 * port_wq_data_cnt indicates amount of data on the write queue,
1762 * which becomes zero when all data is submitted to DSD. But usbser
1763 * stays busy until it gets tx callback from DSD, signalling that
1764 * data has been sent over USB. To be continued in the next comment...
1765 */
1766 until = ddi_get_lbolt() +
1767 drv_usectohz(USBSER_WQ_DRAIN_TIMEOUT * 1000000);
1768
1769 while ((pp->port_wq_data_cnt > 0) && USBSER_PORT_IS_BUSY(pp)) {
1770 if ((rval = cv_timedwait_sig(&pp->port_act_cv, &pp->port_mutex,
1771 until)) <= 0) {
1772
1773 break;
1774 }
1775 }
1776
1777 /* don't drain if timed out or received a signal */
1778 need_drain = (pp->port_wq_data_cnt == 0) || !USBSER_PORT_IS_BUSY(pp) ||
1779 (rval != USB_SUCCESS);
1780
1781 mutex_exit(&pp->port_mutex);
1782 /*
1783 * Once the data reaches USB serial box, it may still be stored in its
1784 * internal output buffer (FIFO). We call DSD drain to ensure that all
1785 * the data is transmitted transmitted over the serial line.
1786 */
1787 if (need_drain) {
1788 rval = USBSER_DS_FIFO_DRAIN(pp, USBSER_TX_FIFO_DRAIN_TIMEOUT);
1789 if (rval != USB_SUCCESS) {
1790 (void) USBSER_DS_FIFO_FLUSH(pp, DS_TX);
1791 }
1792 } else {
1793 (void) USBSER_DS_FIFO_FLUSH(pp, DS_TX);
1794 }
1795 mutex_enter(&pp->port_mutex);
1796 }
1797
1798
1799 /*
1800 * during close, cancel break/delay
1801 */
1802 static void
1803 usbser_close_cancel_break(usbser_port_t *pp)
1804 {
1805 timeout_id_t delay_id;
1806
1807 if (pp->port_act & USBSER_ACT_BREAK) {
1808 delay_id = pp->port_delay_id;
1809 pp->port_delay_id = 0;
1810
1811 mutex_exit(&pp->port_mutex);
1812 (void) untimeout(delay_id);
1813 (void) USBSER_DS_BREAK_CTL(pp, DS_OFF);
1814 mutex_enter(&pp->port_mutex);
1815
1816 pp->port_act &= ~USBSER_ACT_BREAK;
1817 }
1818 }
1819
1820
1821 /*
1822 * during close, drop RTS/DTR if necessary
1823 */
1824 static void
1825 usbser_close_hangup(usbser_port_t *pp)
1826 {
1827 /*
1828 * drop DTR and RTS if HUPCL is set
1829 */
1830 if (pp->port_ttycommon.t_cflag & HUPCL) {
1831 mutex_exit(&pp->port_mutex);
1832 (void) USBSER_DS_SET_MODEM_CTL(pp, TIOCM_RTS | TIOCM_DTR, 0);
1833 mutex_enter(&pp->port_mutex);
1834 }
1835 }
1836
1837
1838 /*
1839 * state cleanup during close
1840 */
1841 static void
1842 usbser_close_cleanup(usbser_port_t *pp)
1843 {
1844 usbser_open_queues_fini(pp);
1845
1846 usbser_open_fini(pp);
1847 }
1848
1849
1850 /*
1851 *
1852 * thread management
1853 * -----------------
1854 *
1855 *
1856 * dispatch a thread
1857 */
1858 static void
1859 usbser_thr_dispatch(usbser_thread_t *thr)
1860 {
1861 usbser_port_t *pp = thr->thr_port;
1862 usbser_state_t *usp = pp->port_usp;
1863 int rval;
1864
1865 ASSERT(mutex_owned(&pp->port_mutex));
1866 ASSERT((thr->thr_flags & USBSER_THR_RUNNING) == 0);
1867
1868 thr->thr_flags = USBSER_THR_RUNNING;
1869
1870 rval = ddi_taskq_dispatch(usp->us_taskq, thr->thr_func, thr->thr_arg,
1871 DDI_SLEEP);
1872 ASSERT(rval == DDI_SUCCESS);
1873 }
1874
1875
1876 /*
1877 * cancel a thread
1878 */
1879 static void
1880 usbser_thr_cancel(usbser_thread_t *thr)
1881 {
1882 usbser_port_t *pp = thr->thr_port;
1883
1884 ASSERT(mutex_owned(&pp->port_mutex));
1885
1886 thr->thr_flags &= ~USBSER_THR_RUNNING;
1887 cv_signal(&thr->thr_cv);
1888
1889 /* wait until the thread actually exits */
1890 do {
1891 cv_wait(&thr->thr_cv, &pp->port_mutex);
1892
1893 } while ((thr->thr_flags & USBSER_THR_EXITED) == 0);
1894 }
1895
1896
1897 /*
1898 * wake thread
1899 */
1900 static void
1901 usbser_thr_wake(usbser_thread_t *thr)
1902 {
1903 ASSERT(mutex_owned(&thr->thr_port->port_mutex));
1904
1905 thr->thr_flags |= USBSER_THR_WAKE;
1906 cv_signal(&thr->thr_cv);
1907 }
1908
1909
1910 /*
1911 * thread handling write queue requests
1912 */
1913 static void
1914 usbser_wq_thread(void *arg)
1915 {
1916 usbser_thread_t *thr = (usbser_thread_t *)arg;
1917 usbser_port_t *pp = thr->thr_port;
1918
1919 USB_DPRINTF_L4(DPRINT_WQ, pp->port_lh, "usbser_wq_thread: enter");
1920
1921 mutex_enter(&pp->port_mutex);
1922 while (thr->thr_flags & USBSER_THR_RUNNING) {
1923 /*
1924 * when woken, see what we should do
1925 */
1926 if (thr->thr_flags & USBSER_THR_WAKE) {
1927 thr->thr_flags &= ~USBSER_THR_WAKE;
1928
1929 /*
1930 * status callback pending?
1931 */
1932 if (pp->port_flags & USBSER_FL_STATUS_CB) {
1933 usbser_status_proc_cb(pp);
1934 }
1935
1936 usbser_wmsg(pp);
1937 } else {
1938 /*
1939 * sleep until woken up to do some work, e.g:
1940 * - new message arrives;
1941 * - data transmit completes;
1942 * - status callback pending;
1943 * - wq thread is cancelled;
1944 */
1945 cv_wait(&thr->thr_cv, &pp->port_mutex);
1946 USB_DPRINTF_L4(DPRINT_WQ, pp->port_lh,
1947 "usbser_wq_thread: wakeup");
1948 }
1949 }
1950 thr->thr_flags |= USBSER_THR_EXITED;
1951 cv_signal(&thr->thr_cv);
1952 USB_DPRINTF_L4(DPRINT_WQ, pp->port_lh, "usbser_wq_thread: exit");
1953 mutex_exit(&pp->port_mutex);
1954 }
1955
1956
1957 /*
1958 * thread handling read queue requests
1959 */
1960 static void
1961 usbser_rq_thread(void *arg)
1962 {
1963 usbser_thread_t *thr = (usbser_thread_t *)arg;
1964 usbser_port_t *pp = thr->thr_port;
1965
1966 USB_DPRINTF_L4(DPRINT_WQ, pp->port_lh, "usbser_rq_thread: enter");
1967
1968 mutex_enter(&pp->port_mutex);
1969 while (thr->thr_flags & USBSER_THR_RUNNING) {
1970 /*
1971 * read service routine will wake us when
1972 * more space is available on the read queue
1973 */
1974 if (thr->thr_flags & USBSER_THR_WAKE) {
1975 thr->thr_flags &= ~USBSER_THR_WAKE;
1976
1977 /*
1978 * don't process messages until queue is enabled
1979 */
1980 if (!pp->port_ttycommon.t_readq) {
1981
1982 continue;
1983 }
1984
1985 /*
1986 * check whether we need to resume receive
1987 */
1988 if (pp->port_flags & USBSER_FL_RX_STOPPED) {
1989 pp->port_flowc = pp->port_ttycommon.t_startc;
1990 usbser_inbound_flow_ctl(pp);
1991 }
1992
1993 /*
1994 * grab more data if available
1995 */
1996 mutex_exit(&pp->port_mutex);
1997 usbser_rx_cb((caddr_t)pp);
1998 mutex_enter(&pp->port_mutex);
1999 } else {
2000 cv_wait(&thr->thr_cv, &pp->port_mutex);
2001 USB_DPRINTF_L4(DPRINT_WQ, pp->port_lh,
2002 "usbser_rq_thread: wakeup");
2003 }
2004 }
2005 thr->thr_flags |= USBSER_THR_EXITED;
2006 cv_signal(&thr->thr_cv);
2007 USB_DPRINTF_L4(DPRINT_RQ, pp->port_lh, "usbser_rq_thread: exit");
2008 mutex_exit(&pp->port_mutex);
2009 }
2010
2011
2012 /*
2013 * DSD callbacks
2014 * -------------
2015 *
2016 * Note: to avoid deadlocks with DSD, these callbacks
2017 * should not call DSD functions that can block.
2018 *
2019 *
2020 * transmit callback
2021 *
2022 * invoked by DSD when the last byte of data is transmitted over USB
2023 */
2024 static void
2025 usbser_tx_cb(caddr_t arg)
2026 {
2027 usbser_port_t *pp = (usbser_port_t *)arg;
2028 int online;
2029
2030 online = usbser_dev_is_online(pp->port_usp);
2031
2032 mutex_enter(&pp->port_mutex);
2033 USB_DPRINTF_L4(DPRINT_TX_CB, pp->port_lh,
2034 "usbser_tx_cb: act=%x curthread=%p", pp->port_act,
2035 (void *)curthread);
2036
2037 usbser_release_port_act(pp, USBSER_ACT_TX);
2038
2039 /*
2040 * as long as port access is ok and the port is not busy on
2041 * TX, break, ctrl or delay, the wq_thread should be waken
2042 * to do further process for next message
2043 */
2044 if (online && USBSER_PORT_ACCESS_OK(pp) &&
2045 !USBSER_PORT_IS_BUSY_NON_RX(pp)) {
2046 /*
2047 * wake wq thread for further data/ioctl processing
2048 */
2049 usbser_thr_wake(&pp->port_wq_thread);
2050 }
2051 mutex_exit(&pp->port_mutex);
2052 }
2053
2054
2055 /*
2056 * receive callback
2057 *
2058 * invoked by DSD when there is more data for us to pick
2059 */
2060 static void
2061 usbser_rx_cb(caddr_t arg)
2062 {
2063 usbser_port_t *pp = (usbser_port_t *)arg;
2064 queue_t *rq, *wq;
2065 mblk_t *mp; /* current mblk */
2066 mblk_t *data, *data_tail; /* M_DATA mblk list and its tail */
2067 mblk_t *emp; /* error (M_BREAK) mblk */
2068
2069 USB_DPRINTF_L4(DPRINT_RX_CB, pp->port_lh, "usbser_rx_cb");
2070
2071 if (!usbser_dev_is_online(pp->port_usp)) {
2072
2073 return;
2074 }
2075
2076 /* get data from DSD */
2077 if ((mp = USBSER_DS_RX(pp)) == NULL) {
2078
2079 return;
2080 }
2081
2082 mutex_enter(&pp->port_mutex);
2083 if ((!USBSER_PORT_ACCESS_OK(pp)) ||
2084 ((pp->port_ttycommon.t_cflag & CREAD) == 0)) {
2085 freemsg(mp);
2086 mutex_exit(&pp->port_mutex);
2087 USB_DPRINTF_L3(DPRINT_RX_CB, pp->port_lh,
2088 "usbser_rx_cb: access not ok or receiver disabled");
2089
2090 return;
2091 }
2092
2093 usbser_serialize_port_act(pp, USBSER_ACT_RX);
2094
2095 rq = pp->port_ttycommon.t_readq;
2096 wq = pp->port_ttycommon.t_writeq;
2097 mutex_exit(&pp->port_mutex);
2098
2099 /*
2100 * DSD data is a b_cont-linked list of M_DATA and M_BREAK blocks.
2101 * M_DATA is correctly received data.
2102 * M_BREAK is a character with either framing or parity error.
2103 *
2104 * this loop runs through the list of mblks. when it meets an M_BREAK,
2105 * it sends all leading M_DATA's in one shot, then sends M_BREAK.
2106 * in the trivial case when list contains only M_DATA's, the loop
2107 * does nothing but set data variable.
2108 */
2109 data = data_tail = NULL;
2110 while (mp) {
2111 /*
2112 * skip data until we meet M_BREAK or end of list
2113 */
2114 if (DB_TYPE(mp) == M_DATA) {
2115 if (data == NULL) {
2116 data = mp;
2117 }
2118 data_tail = mp;
2119 mp = mp->b_cont;
2120
2121 continue;
2122 }
2123
2124 /* detach data list from mp */
2125 if (data_tail) {
2126 data_tail->b_cont = NULL;
2127 }
2128 /* detach emp from the list */
2129 emp = mp;
2130 mp = mp->b_cont;
2131 emp->b_cont = NULL;
2132
2133 /* DSD shouldn't send anything but M_DATA or M_BREAK */
2134 if ((DB_TYPE(emp) != M_BREAK) || (MBLKL(emp) != 2)) {
2135 freemsg(emp);
2136 USB_DPRINTF_L2(DPRINT_RX_CB, pp->port_lh,
2137 "usbser_rx_cb: bad message");
2138
2139 continue;
2140 }
2141
2142 /*
2143 * first tweak and send M_DATA's
2144 */
2145 if (data) {
2146 usbser_rx_massage_data(pp, data);
2147 usbser_rx_cb_put(pp, rq, wq, data);
2148 data = data_tail = NULL;
2149 }
2150
2151 /*
2152 * now tweak and send M_BREAK
2153 */
2154 mutex_enter(&pp->port_mutex);
2155 usbser_rx_massage_mbreak(pp, emp);
2156 mutex_exit(&pp->port_mutex);
2157 usbser_rx_cb_put(pp, rq, wq, emp);
2158 }
2159
2160 /* send the rest of the data, if any */
2161 if (data) {
2162 usbser_rx_massage_data(pp, data);
2163 usbser_rx_cb_put(pp, rq, wq, data);
2164 }
2165
2166 mutex_enter(&pp->port_mutex);
2167 usbser_release_port_act(pp, USBSER_ACT_RX);
2168 mutex_exit(&pp->port_mutex);
2169 }
2170
2171 /*
2172 * the joys of termio -- this is to accomodate Unix98 assertion:
2173 *
2174 * If PARENB is supported and is set, when PARMRK is set, and CSIZE is
2175 * set to CS8, and IGNPAR is clear, and ISTRIP is clear, a valid
2176 * character of '\377' is read as '\377', '\377'.
2177 *
2178 * Posix Ref: Assertion 7.1.2.2-16(C)
2179 *
2180 * this requires the driver to scan every incoming valid character
2181 */
2182 static void
2183 usbser_rx_massage_data(usbser_port_t *pp, mblk_t *mp)
2184 {
2185 tty_common_t *tp = &pp->port_ttycommon;
2186 uchar_t *p;
2187 mblk_t *newmp;
2188 int tailsz;
2189
2190 /* avoid scanning if possible */
2191 mutex_enter(&pp->port_mutex);
2192 if (!((tp->t_cflag & PARENB) && (tp->t_iflag & PARMRK) &&
2193 ((tp->t_cflag & CSIZE) == CS8) &&
2194 ((tp->t_iflag & (IGNPAR|ISTRIP)) == 0))) {
2195 mutex_exit(&pp->port_mutex);
2196
2197 return;
2198 }
2199 mutex_exit(&pp->port_mutex);
2200
2201 while (mp) {
2202 for (p = mp->b_rptr; p < mp->b_wptr; ) {
2203 if (*p++ != 0377) {
2204
2205 continue;
2206 }
2207 USB_DPRINTF_L4(DPRINT_RX_CB, pp->port_lh,
2208 "usbser_rx_massage_data: mp=%p off=%ld(%ld)",
2209 (void *)mp, _PTRDIFF(p, mp->b_rptr) - 1,
2210 (long)MBLKL(mp));
2211
2212 /*
2213 * insert another 0377 after this one. all data after
2214 * the original 0377 have to be copied to the new mblk
2215 */
2216 tailsz = _PTRDIFF(mp->b_wptr, p);
2217 if ((newmp = allocb(tailsz + 1, BPRI_HI)) == NULL) {
2218 USB_DPRINTF_L2(DPRINT_RX_CB, pp->port_lh,
2219 "usbser_rx_massage_data: allocb failed");
2220
2221 continue;
2222 }
2223
2224 /* fill in the new mblk */
2225 *newmp->b_wptr++ = 0377;
2226 if (tailsz > 0) {
2227 bcopy(p, newmp->b_wptr, tailsz);
2228 newmp->b_wptr += tailsz;
2229 }
2230 /* shrink the original mblk */
2231 mp->b_wptr = p;
2232
2233 newmp->b_cont = mp->b_cont;
2234 mp->b_cont = newmp;
2235 p = newmp->b_rptr + 1;
2236 mp = newmp;
2237 }
2238 mp = mp->b_cont;
2239 }
2240 }
2241
2242 /*
2243 * more joys of termio
2244 */
2245 static void
2246 usbser_rx_massage_mbreak(usbser_port_t *pp, mblk_t *mp)
2247 {
2248 tty_common_t *tp = &pp->port_ttycommon;
2249 uchar_t err, c;
2250
2251 err = *mp->b_rptr;
2252 c = *(mp->b_rptr + 1);
2253
2254 if ((err & (DS_FRAMING_ERR | DS_BREAK_ERR)) && (c == 0)) {
2255 /* break */
2256 mp->b_rptr += 2;
2257 } else if (!(tp->t_iflag & INPCK) && (err & (DS_PARITY_ERR))) {
2258 /* Posix Ref: Assertion 7.1.2.2-20(C) */
2259 mp->b_rptr++;
2260 DB_TYPE(mp) = M_DATA;
2261 } else {
2262 /* for ldterm to handle */
2263 mp->b_rptr++;
2264 }
2265
2266 USB_DPRINTF_L4(DPRINT_RX_CB, pp->port_lh,
2267 "usbser_rx_massage_mbreak: type=%x len=%ld [0]=0%o",
2268 DB_TYPE(mp), (long)MBLKL(mp), (MBLKL(mp) > 0) ? *mp->b_rptr : 45);
2269 }
2270
2271
2272 /*
2273 * in rx callback, try to send an mblk upstream
2274 */
2275 static void
2276 usbser_rx_cb_put(usbser_port_t *pp, queue_t *rq, queue_t *wq, mblk_t *mp)
2277 {
2278 if (canputnext(rq)) {
2279 putnext(rq, mp);
2280 } else if (canput(rq) && putq(rq, mp)) {
2281 /*
2282 * full queue indicates the need for inbound flow control
2283 */
2284 (void) putctl(wq, M_STOPI);
2285 usbser_st_put_stopi++;
2286
2287 USB_DPRINTF_L3(DPRINT_RX_CB, pp->port_lh,
2288 "usbser_rx_cb: cannot putnext, flow ctl");
2289 } else {
2290 freemsg(mp);
2291 usbser_st_rx_data_loss++;
2292 (void) putctl(wq, M_STOPI);
2293 usbser_st_put_stopi++;
2294
2295 USB_DPRINTF_L1(DPRINT_RX_CB, pp->port_lh,
2296 "input overrun");
2297 }
2298 }
2299
2300
2301 /*
2302 * modem status change callback
2303 *
2304 * each time external status lines are changed, DSD calls this routine
2305 */
2306 static void
2307 usbser_status_cb(caddr_t arg)
2308 {
2309 usbser_port_t *pp = (usbser_port_t *)arg;
2310
2311 USB_DPRINTF_L4(DPRINT_STATUS_CB, pp->port_lh, "usbser_status_cb");
2312
2313 if (!usbser_dev_is_online(pp->port_usp)) {
2314
2315 return;
2316 }
2317
2318 /*
2319 * actual processing will be done in usbser_status_proc_cb()
2320 * running in wq thread
2321 */
2322 mutex_enter(&pp->port_mutex);
2323 if (USBSER_PORT_ACCESS_OK(pp) || USBSER_IS_OPENING(pp)) {
2324 pp->port_flags |= USBSER_FL_STATUS_CB;
2325 usbser_thr_wake(&pp->port_wq_thread);
2326 }
2327 mutex_exit(&pp->port_mutex);
2328 }
2329
2330
2331 /*
2332 * modem status change
2333 */
2334 static void
2335 usbser_status_proc_cb(usbser_port_t *pp)
2336 {
2337 tty_common_t *tp = &pp->port_ttycommon;
2338 queue_t *rq, *wq;
2339 int status;
2340 int drop_dtr = 0;
2341 int rq_msg = 0, wq_msg = 0;
2342
2343 USB_DPRINTF_L4(DPRINT_STATUS_CB, pp->port_lh, "usbser_status_proc_cb");
2344
2345 pp->port_flags &= ~USBSER_FL_STATUS_CB;
2346
2347 mutex_exit(&pp->port_mutex);
2348 if (!usbser_dev_is_online(pp->port_usp)) {
2349 mutex_enter(&pp->port_mutex);
2350
2351 return;
2352 }
2353
2354 /* get modem status */
2355 if (USBSER_DS_GET_MODEM_CTL(pp, -1, &status) != USB_SUCCESS) {
2356 mutex_enter(&pp->port_mutex);
2357
2358 return;
2359 }
2360
2361 mutex_enter(&pp->port_mutex);
2362 usbser_serialize_port_act(pp, USBSER_ACT_CTL);
2363
2364 rq = pp->port_ttycommon.t_readq;
2365 wq = pp->port_ttycommon.t_writeq;
2366
2367 /*
2368 * outbound flow control
2369 */
2370 if (tp->t_cflag & CRTSCTS) {
2371 if (!(status & TIOCM_CTS)) {
2372 /*
2373 * CTS dropped, stop xmit
2374 */
2375 if (!(pp->port_flags & USBSER_FL_TX_STOPPED)) {
2376 wq_msg = M_STOP;
2377 }
2378 } else if (pp->port_flags & USBSER_FL_TX_STOPPED) {
2379 /*
2380 * CTS raised, resume xmit
2381 */
2382 wq_msg = M_START;
2383 }
2384 }
2385
2386 /*
2387 * check carrier
2388 */
2389 if ((status & TIOCM_CD) || (tp->t_flags & TS_SOFTCAR)) {
2390 /*
2391 * carrier present
2392 */
2393 if ((pp->port_flags & USBSER_FL_CARR_ON) == 0) {
2394 pp->port_flags |= USBSER_FL_CARR_ON;
2395
2396 rq_msg = M_UNHANGUP;
2397 /*
2398 * wake open
2399 */
2400 if (pp->port_flags & USBSER_FL_WOPEN) {
2401 cv_broadcast(&pp->port_car_cv);
2402 }
2403
2404 USB_DPRINTF_L4(DPRINT_STATUS_CB, pp->port_lh,
2405 "usbser_status_cb: carr on");
2406 }
2407 } else if (pp->port_flags & USBSER_FL_CARR_ON) {
2408 pp->port_flags &= ~USBSER_FL_CARR_ON;
2409 /*
2410 * carrier went away: if not local line, drop DTR
2411 */
2412 if (!(tp->t_cflag & CLOCAL)) {
2413 drop_dtr = 1;
2414 rq_msg = M_HANGUP;
2415 }
2416 if ((pp->port_flags & USBSER_FL_TX_STOPPED) && (wq_msg == 0)) {
2417 wq_msg = M_START;
2418 }
2419
2420 USB_DPRINTF_L4(DPRINT_STATUS_CB, pp->port_lh,
2421 "usbser_status_cb: carr off");
2422 }
2423 mutex_exit(&pp->port_mutex);
2424
2425 USB_DPRINTF_L4(DPRINT_STATUS_CB, pp->port_lh,
2426 "usbser_status_cb: rq_msg=%d wq_msg=%d", rq_msg, wq_msg);
2427
2428 /*
2429 * commit postponed actions now
2430 * do so only if port is fully open (queues are enabled)
2431 */
2432 if (rq) {
2433 if (rq_msg) {
2434 (void) putnextctl(rq, rq_msg);
2435 }
2436 if (drop_dtr) {
2437 (void) USBSER_DS_SET_MODEM_CTL(pp, TIOCM_DTR, 0);
2438 }
2439 if (wq_msg) {
2440 (void) putctl(wq, wq_msg);
2441 }
2442 }
2443
2444 mutex_enter(&pp->port_mutex);
2445 usbser_release_port_act(pp, USBSER_ACT_CTL);
2446 }
2447
2448
2449 /*
2450 * serial support
2451 * --------------
2452 *
2453 *
2454 * this routine is run by wq thread every time it's woken,
2455 * i.e. when the queue contains messages to process
2456 */
2457 static void
2458 usbser_wmsg(usbser_port_t *pp)
2459 {
2460 queue_t *q = pp->port_ttycommon.t_writeq;
2461 mblk_t *mp;
2462 int msgtype;
2463
2464 ASSERT(mutex_owned(&pp->port_mutex));
2465
2466 if (q == NULL) {
2467 USB_DPRINTF_L3(DPRINT_WQ, pp->port_lh, "usbser_wmsg: q=NULL");
2468
2469 return;
2470 }
2471 USB_DPRINTF_L4(DPRINT_WQ, pp->port_lh, "usbser_wmsg: q=%p act=%x 0x%x",
2472 (void *)q, pp->port_act, q->q_first ? DB_TYPE(q->q_first) : 0xff);
2473
2474 while ((mp = getq(q)) != NULL) {
2475 msgtype = DB_TYPE(mp);
2476 USB_DPRINTF_L4(DPRINT_WQ, pp->port_lh, "usbser_wmsg: "
2477 "type=%s (0x%x)", usbser_msgtype2str(msgtype), msgtype);
2478
2479 switch (msgtype) {
2480 /*
2481 * high-priority messages
2482 */
2483 case M_STOP:
2484 usbser_stop(pp, mp);
2485
2486 break;
2487 case M_START:
2488 usbser_start(pp, mp);
2489
2490 break;
2491 case M_STOPI:
2492 usbser_stopi(pp, mp);
2493
2494 break;
2495 case M_STARTI:
2496 usbser_starti(pp, mp);
2497
2498 break;
2499 case M_IOCDATA:
2500 usbser_iocdata(pp, mp);
2501
2502 break;
2503 case M_FLUSH:
2504 usbser_flush(pp, mp);
2505
2506 break;
2507 /*
2508 * normal-priority messages
2509 */
2510 case M_BREAK:
2511 usbser_break(pp, mp);
2512
2513 break;
2514 case M_DELAY:
2515 usbser_delay(pp, mp);
2516
2517 break;
2518 case M_DATA:
2519 if (usbser_data(pp, mp) != USB_SUCCESS) {
2520 (void) putbq(q, mp);
2521
2522 return;
2523 }
2524
2525 break;
2526 case M_IOCTL:
2527 if (usbser_ioctl(pp, mp) != USB_SUCCESS) {
2528 (void) putbq(q, mp);
2529
2530 return;
2531 }
2532
2533 break;
2534 default:
2535 freemsg(mp);
2536
2537 break;
2538 }
2539 }
2540 }
2541
2542
2543 /*
2544 * process M_DATA message
2545 */
2546 static int
2547 usbser_data(usbser_port_t *pp, mblk_t *mp)
2548 {
2549 /* put off until current transfer ends or delay is over */
2550 if ((pp->port_act & USBSER_ACT_TX) ||
2551 (pp->port_act & USBSER_ACT_DELAY)) {
2552
2553 return (USB_FAILURE);
2554 }
2555 if (MBLKL(mp) <= 0) {
2556 freemsg(mp);
2557
2558 return (USB_SUCCESS);
2559 }
2560
2561 pp->port_act |= USBSER_ACT_TX;
2562 pp->port_wq_data_cnt -= msgdsize(mp);
2563
2564 mutex_exit(&pp->port_mutex);
2565 /* DSD is required to accept data block in any case */
2566 (void) USBSER_DS_TX(pp, mp);
2567 mutex_enter(&pp->port_mutex);
2568
2569 return (USB_SUCCESS);
2570 }
2571
2572
2573 /*
2574 * process an M_IOCTL message
2575 */
2576 static int
2577 usbser_ioctl(usbser_port_t *pp, mblk_t *mp)
2578 {
2579 tty_common_t *tp = &pp->port_ttycommon;
2580 queue_t *q = tp->t_writeq;
2581 struct iocblk *iocp;
2582 int cmd;
2583 mblk_t *datamp;
2584 int error = 0, rval = USB_SUCCESS;
2585 int val;
2586
2587 ASSERT(mutex_owned(&pp->port_mutex));
2588 ASSERT(DB_TYPE(mp) == M_IOCTL);
2589
2590 iocp = (struct iocblk *)mp->b_rptr;
2591 cmd = iocp->ioc_cmd;
2592
2593 USB_DPRINTF_L4(DPRINT_IOCTL, pp->port_lh, "usbser_ioctl: "
2594 "mp=%p %s (0x%x)", (void *)mp, usbser_ioctl2str(cmd), cmd);
2595
2596 if (tp->t_iocpending != NULL) {
2597 /*
2598 * We were holding an ioctl response pending the
2599 * availability of an mblk to hold data to be passed up;
2600 * another ioctl came through, which means that ioctl
2601 * must have timed out or been aborted.
2602 */
2603 freemsg(tp->t_iocpending);
2604 tp->t_iocpending = NULL;
2605 }
2606
2607 switch (cmd) {
2608 case TIOCMGET:
2609 case TIOCMBIC:
2610 case TIOCMBIS:
2611 case TIOCMSET:
2612 case CONSOPENPOLLEDIO:
2613 case CONSCLOSEPOLLEDIO:
2614 case CONSSETABORTENABLE:
2615 case CONSGETABORTENABLE:
2616 /*
2617 * For the above ioctls do not call ttycommon_ioctl() because
2618 * this function frees up the message block (mp->b_cont) that
2619 * contains the address of the user variable where we need to
2620 * pass back the bit array.
2621 */
2622 error = -1;
2623 usbser_serialize_port_act(pp, USBSER_ACT_CTL);
2624 mutex_exit(&pp->port_mutex);
2625 break;
2626
2627 case TCSBRK:
2628 /* serialize breaks */
2629 if (pp->port_act & USBSER_ACT_BREAK)
2630 return (USB_FAILURE);
2631 /*FALLTHRU*/
2632 default:
2633 usbser_serialize_port_act(pp, USBSER_ACT_CTL);
2634 mutex_exit(&pp->port_mutex);
2635 (void) ttycommon_ioctl(tp, q, mp, &error);
2636 break;
2637 }
2638
2639 if (error == 0) {
2640 /*
2641 * ttycommon_ioctl() did most of the work
2642 * we just use the data it set up
2643 */
2644 switch (cmd) {
2645 case TCSETSF:
2646 case TCSETSW:
2647 case TCSETA:
2648 case TCSETAW:
2649 case TCSETAF:
2650 (void) USBSER_DS_FIFO_DRAIN(pp, DS_TX);
2651 /*FALLTHRU*/
2652
2653 case TCSETS:
2654 mutex_enter(&pp->port_mutex);
2655 error = usbser_port_program(pp);
2656 mutex_exit(&pp->port_mutex);
2657 break;
2658 }
2659 goto end;
2660
2661 } else if (error > 0) {
2662 USB_DPRINTF_L3(DPRINT_IOCTL, pp->port_lh, "usbser_ioctl: "
2663 "ttycommon_ioctl returned %d", error);
2664 goto end;
2665 }
2666
2667 /*
2668 * error < 0: ttycommon_ioctl() didn't do anything, we process it here
2669 */
2670 error = 0;
2671 switch (cmd) {
2672 case TCSBRK:
2673 if ((error = miocpullup(mp, sizeof (int))) != 0)
2674 break;
2675
2676 /* drain output */
2677 (void) USBSER_DS_FIFO_DRAIN(pp, USBSER_TX_FIFO_DRAIN_TIMEOUT);
2678
2679 /*
2680 * if required, set break
2681 */
2682 if (*(int *)mp->b_cont->b_rptr == 0) {
2683 if (USBSER_DS_BREAK_CTL(pp, DS_ON) != USB_SUCCESS) {
2684 error = EIO;
2685 break;
2686 }
2687
2688 mutex_enter(&pp->port_mutex);
2689 pp->port_act |= USBSER_ACT_BREAK;
2690 pp->port_delay_id = timeout(usbser_restart, pp,
2691 drv_usectohz(250000));
2692 mutex_exit(&pp->port_mutex);
2693 }
2694 mioc2ack(mp, NULL, 0, 0);
2695 break;
2696
2697 case TIOCSBRK: /* set break */
2698 if (USBSER_DS_BREAK_CTL(pp, DS_ON) != USB_SUCCESS)
2699 error = EIO;
2700 else
2701 mioc2ack(mp, NULL, 0, 0);
2702 break;
2703
2704 case TIOCCBRK: /* clear break */
2705 if (USBSER_DS_BREAK_CTL(pp, DS_OFF) != USB_SUCCESS)
2706 error = EIO;
2707 else
2708 mioc2ack(mp, NULL, 0, 0);
2709 break;
2710
2711 case TIOCMSET: /* set all modem bits */
2712 case TIOCMBIS: /* bis modem bits */
2713 case TIOCMBIC: /* bic modem bits */
2714 if (iocp->ioc_count == TRANSPARENT) {
2715 mcopyin(mp, NULL, sizeof (int), NULL);
2716 break;
2717 }
2718 if ((error = miocpullup(mp, sizeof (int))) != 0)
2719 break;
2720
2721 val = *(int *)mp->b_cont->b_rptr;
2722 if (cmd == TIOCMSET) {
2723 rval = USBSER_DS_SET_MODEM_CTL(pp, -1, val);
2724 } else if (cmd == TIOCMBIS) {
2725 rval = USBSER_DS_SET_MODEM_CTL(pp, val, -1);
2726 } else if (cmd == TIOCMBIC) {
2727 rval = USBSER_DS_SET_MODEM_CTL(pp, val, 0);
2728 }
2729 if (rval == USB_SUCCESS)
2730 mioc2ack(mp, NULL, 0, 0);
2731 else
2732 error = EIO;
2733 break;
2734
2735 case TIOCSILOOP:
2736 if (USBSER_DS_LOOPBACK_SUPPORTED(pp)) {
2737 if (USBSER_DS_LOOPBACK(pp, DS_ON) == USB_SUCCESS)
2738 mioc2ack(mp, NULL, 0, 0);
2739 else
2740 error = EIO;
2741 } else {
2742 error = EINVAL;
2743 }
2744 break;
2745
2746 case TIOCCILOOP:
2747 if (USBSER_DS_LOOPBACK_SUPPORTED(pp)) {
2748 if (USBSER_DS_LOOPBACK(pp, DS_OFF) == USB_SUCCESS)
2749 mioc2ack(mp, NULL, 0, 0);
2750 else
2751 error = EIO;
2752 } else {
2753 error = EINVAL;
2754 }
2755 break;
2756
2757 case TIOCMGET: /* get all modem bits */
2758 if ((datamp = allocb(sizeof (int), BPRI_MED)) == NULL) {
2759 error = EAGAIN;
2760 break;
2761 }
2762 rval = USBSER_DS_GET_MODEM_CTL(pp, -1, (int *)datamp->b_rptr);
2763 if (rval != USB_SUCCESS) {
2764 error = EIO;
2765 break;
2766 }
2767 if (iocp->ioc_count == TRANSPARENT)
2768 mcopyout(mp, NULL, sizeof (int), NULL, datamp);
2769 else
2770 mioc2ack(mp, datamp, sizeof (int), 0);
2771 break;
2772
2773 case CONSOPENPOLLEDIO:
2774 error = usbser_polledio_init(pp);
2775 if (error != 0)
2776 break;
2777
2778 error = miocpullup(mp, sizeof (struct cons_polledio *));
2779 if (error != 0)
2780 break;
2781
2782 *(struct cons_polledio **)mp->b_cont->b_rptr = &usbser_polledio;
2783
2784 mp->b_datap->db_type = M_IOCACK;
2785 break;
2786
2787 case CONSCLOSEPOLLEDIO:
2788 usbser_polledio_fini(pp);
2789 mp->b_datap->db_type = M_IOCACK;
2790 iocp->ioc_error = 0;
2791 iocp->ioc_rval = 0;
2792 break;
2793
2794 case CONSSETABORTENABLE:
2795 error = secpolicy_console(iocp->ioc_cr);
2796 if (error != 0)
2797 break;
2798
2799 if (iocp->ioc_count != TRANSPARENT) {
2800 error = EINVAL;
2801 break;
2802 }
2803
2804 /*
2805 * To do: implement console abort support
2806 * This involves adding a console flag to usbser
2807 * state structure. If flag is set, parse input stream
2808 * for abort sequence (see asy for example).
2809 *
2810 * For now, run mdb -K to get kmdb prompt.
2811 */
2812 if (*(intptr_t *)mp->b_cont->b_rptr)
2813 usbser_console_abort = 1;
2814 else
2815 usbser_console_abort = 0;
2816
2817 mp->b_datap->db_type = M_IOCACK;
2818 iocp->ioc_error = 0;
2819 iocp->ioc_rval = 0;
2820 break;
2821
2822 case CONSGETABORTENABLE:
2823 /*CONSTANTCONDITION*/
2824 ASSERT(sizeof (boolean_t) <= sizeof (boolean_t *));
2825 /*
2826 * Store the return value right in the payload
2827 * we were passed. Crude.
2828 */
2829 mcopyout(mp, NULL, sizeof (boolean_t), NULL, NULL);
2830 *(boolean_t *)mp->b_cont->b_rptr = (usbser_console_abort != 0);
2831 break;
2832
2833 default:
2834 error = EINVAL;
2835 break;
2836 }
2837 end:
2838 if (error != 0)
2839 miocnak(q, mp, 0, error);
2840 else
2841 qreply(q, mp);
2842
2843 mutex_enter(&pp->port_mutex);
2844 usbser_release_port_act(pp, USBSER_ACT_CTL);
2845
2846 return (USB_SUCCESS);
2847 }
2848
2849
2850 /*
2851 * process M_IOCDATA message
2852 */
2853 static void
2854 usbser_iocdata(usbser_port_t *pp, mblk_t *mp)
2855 {
2856 tty_common_t *tp = &pp->port_ttycommon;
2857 queue_t *q = tp->t_writeq;
2858 struct copyresp *csp;
2859 int cmd;
2860 int val;
2861 int rval = USB_FAILURE;
2862
2863 ASSERT(mutex_owned(&pp->port_mutex));
2864
2865 csp = (struct copyresp *)mp->b_rptr;
2866 cmd = csp->cp_cmd;
2867
2868 if (csp->cp_rval != 0) {
2869 freemsg(mp);
2870 return;
2871 }
2872
2873 switch (cmd) {
2874 case TIOCMSET: /* set all modem bits */
2875 case TIOCMBIS: /* bis modem bits */
2876 case TIOCMBIC: /* bic modem bits */
2877 if ((mp->b_cont == NULL) ||
2878 (MBLKL(mp->b_cont) < sizeof (int))) {
2879 miocnak(q, mp, 0, EINVAL);
2880 break;
2881 }
2882 val = *(int *)mp->b_cont->b_rptr;
2883
2884 usbser_serialize_port_act(pp, USBSER_ACT_CTL);
2885 mutex_exit(&pp->port_mutex);
2886
2887 if (cmd == TIOCMSET) {
2888 rval = USBSER_DS_SET_MODEM_CTL(pp, -1, val);
2889 } else if (cmd == TIOCMBIS) {
2890 rval = USBSER_DS_SET_MODEM_CTL(pp, val, -1);
2891 } else if (cmd == TIOCMBIC) {
2892 rval = USBSER_DS_SET_MODEM_CTL(pp, val, 0);
2893 }
2894
2895 if (mp->b_cont) {
2896 freemsg(mp->b_cont);
2897 mp->b_cont = NULL;
2898 }
2899
2900 if (rval == USB_SUCCESS)
2901 miocack(q, mp, 0, 0);
2902 else
2903 miocnak(q, mp, 0, EIO);
2904
2905 mutex_enter(&pp->port_mutex);
2906 usbser_release_port_act(pp, USBSER_ACT_CTL);
2907 break;
2908
2909 case TIOCMGET: /* get all modem bits */
2910 mutex_exit(&pp->port_mutex);
2911 miocack(q, mp, 0, 0);
2912 mutex_enter(&pp->port_mutex);
2913 break;
2914
2915 default:
2916 mutex_exit(&pp->port_mutex);
2917 miocnak(q, mp, 0, EINVAL);
2918 mutex_enter(&pp->port_mutex);
2919 break;
2920 }
2921 }
2922
2923
2924 /*
2925 * handle M_START[I]/M_STOP[I] messages
2926 */
2927 static void
2928 usbser_stop(usbser_port_t *pp, mblk_t *mp)
2929 {
2930 usbser_st_mstop++;
2931 if (!(pp->port_flags & USBSER_FL_TX_STOPPED)) {
2932 usbser_serialize_port_act(pp, USBSER_ACT_CTL);
2933 pp->port_flags |= USBSER_FL_TX_STOPPED;
2934
2935 mutex_exit(&pp->port_mutex);
2936 USBSER_DS_STOP(pp, DS_TX);
2937 mutex_enter(&pp->port_mutex);
2938
2939 usbser_release_port_act(pp, USBSER_ACT_TX);
2940 usbser_release_port_act(pp, USBSER_ACT_CTL);
2941 }
2942 freemsg(mp);
2943 }
2944
2945
2946 static void
2947 usbser_start(usbser_port_t *pp, mblk_t *mp)
2948 {
2949 usbser_st_mstart++;
2950 if (pp->port_flags & USBSER_FL_TX_STOPPED) {
2951 usbser_serialize_port_act(pp, USBSER_ACT_CTL);
2952 pp->port_flags &= ~USBSER_FL_TX_STOPPED;
2953
2954 mutex_exit(&pp->port_mutex);
2955 USBSER_DS_START(pp, DS_TX);
2956 mutex_enter(&pp->port_mutex);
2957 usbser_release_port_act(pp, USBSER_ACT_CTL);
2958 }
2959 freemsg(mp);
2960 }
2961
2962
2963 static void
2964 usbser_stopi(usbser_port_t *pp, mblk_t *mp)
2965 {
2966 usbser_st_mstopi++;
2967 usbser_serialize_port_act(pp, USBSER_ACT_CTL);
2968 pp->port_flowc = pp->port_ttycommon.t_stopc;
2969 usbser_inbound_flow_ctl(pp);
2970 usbser_release_port_act(pp, USBSER_ACT_CTL);
2971 freemsg(mp);
2972 }
2973
2974 static void
2975 usbser_starti(usbser_port_t *pp, mblk_t *mp)
2976 {
2977 usbser_st_mstarti++;
2978 usbser_serialize_port_act(pp, USBSER_ACT_CTL);
2979 pp->port_flowc = pp->port_ttycommon.t_startc;
2980 usbser_inbound_flow_ctl(pp);
2981 usbser_release_port_act(pp, USBSER_ACT_CTL);
2982 freemsg(mp);
2983 }
2984
2985 /*
2986 * process M_FLUSH message
2987 */
2988 static void
2989 usbser_flush(usbser_port_t *pp, mblk_t *mp)
2990 {
2991 queue_t *q = pp->port_ttycommon.t_writeq;
2992
2993 if (*mp->b_rptr & FLUSHW) {
2994 mutex_exit(&pp->port_mutex);
2995 (void) USBSER_DS_FIFO_FLUSH(pp, DS_TX); /* flush FIFO buffers */
2996 flushq(q, FLUSHDATA); /* flush write queue */
2997 mutex_enter(&pp->port_mutex);
2998
2999 usbser_release_port_act(pp, USBSER_ACT_TX);
3000
3001 *mp->b_rptr &= ~FLUSHW;
3002 }
3003 if (*mp->b_rptr & FLUSHR) {
3004 /*
3005 * flush FIFO buffers
3006 */
3007 mutex_exit(&pp->port_mutex);
3008 (void) USBSER_DS_FIFO_FLUSH(pp, DS_RX);
3009 flushq(RD(q), FLUSHDATA);
3010 qreply(q, mp);
3011 mutex_enter(&pp->port_mutex);
3012 } else {
3013 freemsg(mp);
3014 }
3015 }
3016
3017 /*
3018 * process M_BREAK message
3019 */
3020 static void
3021 usbser_break(usbser_port_t *pp, mblk_t *mp)
3022 {
3023 int rval;
3024
3025 /*
3026 * set the break and arrange for usbser_restart() to be called in 1/4 s
3027 */
3028 mutex_exit(&pp->port_mutex);
3029 rval = USBSER_DS_BREAK_CTL(pp, DS_ON);
3030 mutex_enter(&pp->port_mutex);
3031
3032 if (rval == USB_SUCCESS) {
3033 pp->port_act |= USBSER_ACT_BREAK;
3034 pp->port_delay_id = timeout(usbser_restart, pp,
3035 drv_usectohz(250000));
3036 }
3037 freemsg(mp);
3038 }
3039
3040
3041 /*
3042 * process M_DELAY message
3043 */
3044 static void
3045 usbser_delay(usbser_port_t *pp, mblk_t *mp)
3046 {
3047 /*
3048 * arrange for usbser_restart() to be called when the delay expires
3049 */
3050 pp->port_act |= USBSER_ACT_DELAY;
3051 pp->port_delay_id = timeout(usbser_restart, pp,
3052 (clock_t)(*(uchar_t *)mp->b_rptr + 6));
3053 freemsg(mp);
3054 }
3055
3056
3057 /*
3058 * restart output on a line after a delay or break timer expired
3059 */
3060 static void
3061 usbser_restart(void *arg)
3062 {
3063 usbser_port_t *pp = (usbser_port_t *)arg;
3064
3065 USB_DPRINTF_L4(DPRINT_WQ, pp->port_lh, "usbser_restart");
3066
3067 mutex_enter(&pp->port_mutex);
3068 /* if cancelled, return immediately */
3069 if (pp->port_delay_id == 0) {
3070 mutex_exit(&pp->port_mutex);
3071
3072 return;
3073 }
3074 pp->port_delay_id = 0;
3075
3076 /* clear break if necessary */
3077 if (pp->port_act & USBSER_ACT_BREAK) {
3078 mutex_exit(&pp->port_mutex);
3079 (void) USBSER_DS_BREAK_CTL(pp, DS_OFF);
3080 mutex_enter(&pp->port_mutex);
3081 }
3082
3083 usbser_release_port_act(pp, USBSER_ACT_BREAK | USBSER_ACT_DELAY);
3084
3085 /* wake wq thread to resume message processing */
3086 usbser_thr_wake(&pp->port_wq_thread);
3087 mutex_exit(&pp->port_mutex);
3088 }
3089
3090
3091 /*
3092 * program port hardware with the chosen parameters
3093 * most of the operation is based on the values of 'c_iflag' and 'c_cflag'
3094 */
3095 static int
3096 usbser_port_program(usbser_port_t *pp)
3097 {
3098 tty_common_t *tp = &pp->port_ttycommon;
3099 int baudrate;
3100 int c_flag;
3101 ds_port_param_entry_t pe[6];
3102 ds_port_params_t params;
3103 int flow_ctl, ctl_val;
3104 int err = 0;
3105
3106 baudrate = tp->t_cflag & CBAUD;
3107 if (tp->t_cflag & CBAUDEXT) {
3108 baudrate += 16;
3109 }
3110
3111 /*
3112 * set input speed same as output, as split speed not supported
3113 */
3114 if (tp->t_cflag & (CIBAUD|CIBAUDEXT)) {
3115 tp->t_cflag &= ~(CIBAUD);
3116 if (baudrate > CBAUD) {
3117 tp->t_cflag |= CIBAUDEXT;
3118 tp->t_cflag |=
3119 (((baudrate - CBAUD - 1) << IBSHIFT) & CIBAUD);
3120 } else {
3121 tp->t_cflag &= ~CIBAUDEXT;
3122 tp->t_cflag |= ((baudrate << IBSHIFT) & CIBAUD);
3123 }
3124 }
3125
3126 c_flag = tp->t_cflag;
3127
3128 /*
3129 * flow control
3130 */
3131 flow_ctl = tp->t_iflag & (IXON | IXANY | IXOFF);
3132 if (c_flag & CRTSCTS) {
3133 flow_ctl |= CTSXON;
3134 }
3135 if (c_flag & CRTSXOFF) {
3136 flow_ctl |= RTSXOFF;
3137 }
3138
3139 /*
3140 * fill in port parameters we need to set:
3141 *
3142 * baud rate
3143 */
3144 pe[0].param = DS_PARAM_BAUD;
3145 pe[0].val.ui = baudrate;
3146
3147 /* stop bits */
3148 pe[1].param = DS_PARAM_STOPB;
3149 pe[1].val.ui = c_flag & CSTOPB;
3150
3151 /* parity */
3152 pe[2].param = DS_PARAM_PARITY;
3153 pe[2].val.ui = c_flag & (PARENB | PARODD);
3154
3155 /* char size */
3156 pe[3].param = DS_PARAM_CHARSZ;
3157 pe[3].val.ui = c_flag & CSIZE;
3158
3159 /* start & stop chars */
3160 pe[4].param = DS_PARAM_XON_XOFF;
3161 pe[4].val.uc[0] = tp->t_startc;
3162 pe[4].val.uc[1] = tp->t_stopc;
3163
3164 /* flow control */
3165 pe[5].param = DS_PARAM_FLOW_CTL;
3166 pe[5].val.ui = flow_ctl;
3167
3168 params.tp_entries = &pe[0];
3169 params.tp_cnt = 6;
3170
3171 /* control signals */
3172 ctl_val = TIOCM_DTR | TIOCM_RTS;
3173 if (baudrate == 0) {
3174 ctl_val &= ~TIOCM_DTR; /* zero baudrate means drop DTR */
3175 }
3176 if (pp->port_flags & USBSER_FL_RX_STOPPED) {
3177 ctl_val &= ~TIOCM_RTS;
3178 }
3179
3180 /* submit */
3181 mutex_exit(&pp->port_mutex);
3182 err = USBSER_DS_SET_PORT_PARAMS(pp, &params);
3183 if (err != USB_SUCCESS) {
3184 mutex_enter(&pp->port_mutex);
3185
3186 return (EINVAL);
3187 }
3188
3189 err = USBSER_DS_SET_MODEM_CTL(pp, TIOCM_DTR | TIOCM_RTS, ctl_val);
3190 mutex_enter(&pp->port_mutex);
3191
3192 return ((err == USB_SUCCESS) ? 0 : EIO);
3193 }
3194
3195
3196 /*
3197 * check if any inbound flow control action needed
3198 */
3199 static void
3200 usbser_inbound_flow_ctl(usbser_port_t *pp)
3201 {
3202 tcflag_t need_hw;
3203 int rts;
3204 char c = pp->port_flowc;
3205 mblk_t *mp = NULL;
3206
3207 USB_DPRINTF_L4(DPRINT_WQ, pp->port_lh,
3208 "usbser_inbound_flow_ctl: c=%x cflag=%x port_flags=%x",
3209 c, pp->port_ttycommon.t_cflag, pp->port_flags);
3210
3211 if (c == '\0') {
3212
3213 return;
3214 }
3215 pp->port_flowc = '\0';
3216
3217 /*
3218 * if inbound hardware flow control enabled, we need to frob RTS
3219 */
3220 need_hw = (pp->port_ttycommon.t_cflag & CRTSXOFF);
3221 if (c == pp->port_ttycommon.t_startc) {
3222 rts = TIOCM_RTS;
3223 pp->port_flags &= ~USBSER_FL_RX_STOPPED;
3224 } else {
3225 rts = 0;
3226 pp->port_flags |= USBSER_FL_RX_STOPPED;
3227 }
3228
3229 /*
3230 * if character flow control active, transmit a start or stop char,
3231 */
3232 if (pp->port_ttycommon.t_iflag & IXOFF) {
3233 if ((mp = allocb(1, BPRI_LO)) == NULL) {
3234 USB_DPRINTF_L2(DPRINT_WQ, pp->port_lh,
3235 "usbser_inbound_flow_ctl: allocb failed");
3236 } else {
3237 *mp->b_wptr++ = c;
3238 pp->port_flags |= USBSER_ACT_TX;
3239 }
3240 }
3241
3242 mutex_exit(&pp->port_mutex);
3243 if (need_hw) {
3244 (void) USBSER_DS_SET_MODEM_CTL(pp, TIOCM_RTS, rts);
3245 }
3246 if (mp) {
3247 (void) USBSER_DS_TX(pp, mp);
3248 }
3249 mutex_enter(&pp->port_mutex);
3250 }
3251
3252
3253 /*
3254 * misc
3255 * ----
3256 *
3257 *
3258 * returns != 0 if device is online, 0 otherwise
3259 */
3260 static int
3261 usbser_dev_is_online(usbser_state_t *usp)
3262 {
3263 int rval;
3264
3265 mutex_enter(&usp->us_mutex);
3266 rval = (usp->us_dev_state == USB_DEV_ONLINE);
3267 mutex_exit(&usp->us_mutex);
3268
3269 return (rval);
3270 }
3271
3272 /*
3273 * serialize port activities defined by 'act' mask
3274 */
3275 static void
3276 usbser_serialize_port_act(usbser_port_t *pp, int act)
3277 {
3278 while (pp->port_act & act)
3279 cv_wait(&pp->port_act_cv, &pp->port_mutex);
3280 pp->port_act |= act;
3281 }
3282
3283
3284 /*
3285 * indicate that port activity is finished
3286 */
3287 static void
3288 usbser_release_port_act(usbser_port_t *pp, int act)
3289 {
3290 pp->port_act &= ~act;
3291 cv_broadcast(&pp->port_act_cv);
3292 }
3293
3294 #ifdef DEBUG
3295 /*
3296 * message type to string and back conversion.
3297 *
3298 * pardon breaks on the same line, but as long as cstyle doesn't
3299 * complain, I'd like to keep this form for trivial cases like this.
3300 * associative arrays in the kernel, anyone?
3301 */
3302 static char *
3303 usbser_msgtype2str(int type) __unused;
3304
3305 static char *
3306 usbser_msgtype2str(int type)
3307 {
3308 char *str;
3309
3310 switch (type) {
3311 case M_STOP: str = "M_STOP"; break;
3312 case M_START: str = "M_START"; break;
3313 case M_STOPI: str = "M_STOPI"; break;
3314 case M_STARTI: str = "M_STARTI"; break;
3315 case M_DATA: str = "M_DATA"; break;
3316 case M_DELAY: str = "M_DELAY"; break;
3317 case M_BREAK: str = "M_BREAK"; break;
3318 case M_IOCTL: str = "M_IOCTL"; break;
3319 case M_IOCDATA: str = "M_IOCDATA"; break;
3320 case M_FLUSH: str = "M_FLUSH"; break;
3321 case M_CTL: str = "M_CTL"; break;
3322 case M_READ: str = "M_READ"; break;
3323 default: str = "unknown"; break;
3324 }
3325
3326 return (str);
3327 }
3328
3329 static char *
3330 usbser_ioctl2str(int ioctl) __unused;
3331
3332 static char *
3333 usbser_ioctl2str(int ioctl)
3334 {
3335 char *str;
3336
3337 switch (ioctl) {
3338 case TCGETA: str = "TCGETA"; break;
3339 case TCSETA: str = "TCSETA"; break;
3340 case TCSETAF: str = "TCSETAF"; break;
3341 case TCSETAW: str = "TCSETAW"; break;
3342 case TCSBRK: str = "TCSBRK"; break;
3343 case TCXONC: str = "TCXONC"; break;
3344 case TCFLSH: str = "TCFLSH"; break;
3345 case TCGETS: str = "TCGETS"; break;
3346 case TCSETS: str = "TCSETS"; break;
3347 case TCSETSF: str = "TCSETSF"; break;
3348 case TCSETSW: str = "TCSETSW"; break;
3349 case TIOCSBRK: str = "TIOCSBRK"; break;
3350 case TIOCCBRK: str = "TIOCCBRK"; break;
3351 case TIOCMSET: str = "TIOCMSET"; break;
3352 case TIOCMBIS: str = "TIOCMBIS"; break;
3353 case TIOCMBIC: str = "TIOCMBIC"; break;
3354 case TIOCMGET: str = "TIOCMGET"; break;
3355 case TIOCSILOOP: str = "TIOCSILOOP"; break;
3356 case TIOCCILOOP: str = "TIOCCILOOP"; break;
3357 case TCGETX: str = "TCGETX"; break;
3358 case TCSETX: str = "TCGETX"; break;
3359 case TCSETXW: str = "TCGETX"; break;
3360 case TCSETXF: str = "TCGETX"; break;
3361 default: str = "unknown"; break;
3362 }
3363
3364 return (str);
3365 }
3366 #endif
3367 /*
3368 * Polled IO support
3369 */
3370
3371 /* called once by consconfig() when polledio is opened */
3372 static int
3373 usbser_polledio_init(usbser_port_t *pp)
3374 {
3375 int err;
3376 usb_pipe_handle_t hdl;
3377 ds_ops_t *ds_ops = pp->port_ds_ops;
3378
3379 /* only one serial line console supported */
3380 if (console_input != NULL)
3381 return (USB_FAILURE);
3382
3383 /* check if underlying driver supports polled io */
3384 if (ds_ops->ds_version < DS_OPS_VERSION_V1 ||
3385 ds_ops->ds_out_pipe == NULL || ds_ops->ds_in_pipe == NULL)
3386 return (USB_FAILURE);
3387
3388 /* init polled input pipe */
3389 hdl = ds_ops->ds_in_pipe(pp->port_ds_hdl, pp->port_num);
3390 err = usb_console_input_init(pp->port_usp->us_dip, hdl,
3391 &console_input_buf, &console_input);
3392 if (err)
3393 return (USB_FAILURE);
3394
3395 /* init polled output pipe */
3396 hdl = ds_ops->ds_out_pipe(pp->port_ds_hdl, pp->port_num);
3397 err = usb_console_output_init(pp->port_usp->us_dip, hdl,
3398 &console_output);
3399 if (err) {
3400 (void) usb_console_input_fini(console_input);
3401 console_input = NULL;
3402 return (USB_FAILURE);
3403 }
3404
3405 return (USB_SUCCESS);
3406 }
3407
3408 /* called once by consconfig() when polledio is closed */
3409 /*ARGSUSED*/
3410 static void usbser_polledio_fini(usbser_port_t *pp)
3411 {
3412 /* Since we can't move the console, there is nothing to do. */
3413 }
3414
3415 /*ARGSUSED*/
3416 static void
3417 usbser_polledio_enter(cons_polledio_arg_t arg)
3418 {
3419 (void) usb_console_input_enter(console_input);
3420 (void) usb_console_output_enter(console_output);
3421 }
3422
3423 /*ARGSUSED*/
3424 static void
3425 usbser_polledio_exit(cons_polledio_arg_t arg)
3426 {
3427 (void) usb_console_output_exit(console_output);
3428 (void) usb_console_input_exit(console_input);
3429 }
3430
3431 /*ARGSUSED*/
3432 static void
3433 usbser_putchar(cons_polledio_arg_t arg, uchar_t c)
3434 {
3435 static uchar_t cr[2] = {'\r', '\n'};
3436 uint_t nout;
3437
3438 if (c == '\n')
3439 (void) usb_console_write(console_output, cr, 2, &nout);
3440 else
3441 (void) usb_console_write(console_output, &c, 1, &nout);
3442 }
3443
3444 /*ARGSUSED*/
3445 static int
3446 usbser_getchar(cons_polledio_arg_t arg)
3447 {
3448 while (!usbser_ischar(arg))
3449 ;
3450
3451 return (*console_input_start++);
3452 }
3453
3454 /*ARGSUSED*/
3455 static boolean_t
3456 usbser_ischar(cons_polledio_arg_t arg)
3457 {
3458 uint_t num_bytes;
3459
3460 if (console_input_start < console_input_end)
3461 return (B_TRUE);
3462
3463 if (usb_console_read(console_input, &num_bytes) != USB_SUCCESS)
3464 return (B_FALSE);
3465
3466 console_input_start = console_input_buf;
3467 console_input_end = console_input_buf + num_bytes;
3468
3469 return (num_bytes != 0);
3470 }
Unleashed OS