xref: /illumos-gate/usr/src/uts/common/io/consms.c (revision 6cd62caa5b5899503c648f5b5ce211b7eec6644d)
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 2008 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25 
26 
27 /*
28  * Console mouse driver for Sun.
29  * The console "zs" port is linked under us, with the "ms" module pushed
30  * on top of it.
31  *
32  * This device merely provides a way to have "/dev/mouse" automatically
33  * have the "ms" module present. Due to problems with the way the "specfs"
34  * file system works, you can't use an indirect device (a "stat" on
35  * "/dev/mouse" won't get the right snode, so you won't get the right time
36  * of last access), and due to problems with the kernel window system code,
37  * you can't use a "cons"-like driver ("/dev/mouse" won't be a streams device,
38  * even though operations on it get turned into operations on the real stream).
39  *
40  * This module supports multiple mice connected to the system at the same time.
41  * All the mice are linked under consms, and act as a mouse with replicated
42  * clicks. Only USB and PS/2 mouse are supported to be virtual mouse now.
43  */
44 
45 #include <sys/types.h>
46 #include <sys/param.h>
47 #include <sys/stropts.h>
48 #include <sys/stream.h>
49 #include <sys/strsun.h>
50 #include <sys/conf.h>
51 #include <sys/stat.h>
52 #include <sys/errno.h>
53 #include <sys/modctl.h>
54 #include <sys/consdev.h>
55 #include <sys/ddi.h>
56 #include <sys/sunddi.h>
57 #include <sys/kstat.h>
58 #include <sys/vuid_wheel.h>
59 #include <sys/msio.h>
60 #include <sys/consms.h>
61 
62 static void consms_plink(queue_t *, mblk_t *);
63 static int consms_punlink(queue_t *, mblk_t *);
64 static void
65 consms_lqs_ack_complete(consms_lq_t *, mblk_t *);
66 static void consms_add_lq(consms_lq_t *);
67 static void consms_check_caps(void);
68 static mblk_t *consms_new_firm_event(ushort_t, int);
69 
70 static void consms_mux_max_wheel_report(mblk_t *);
71 static void consms_mux_cache_states(mblk_t *);
72 static void consms_mux_link_msg(consms_msg_t *);
73 static consms_msg_t *consms_mux_unlink_msg(uint_t);
74 static consms_msg_t *consms_mux_find_msg(uint_t);
75 
76 static void consms_mux_iocdata(consms_msg_t *, mblk_t *);
77 static void consms_mux_disp_iocdata(consms_response_t *, mblk_t *);
78 static int consms_mux_disp_ioctl(queue_t *, mblk_t *);
79 static void consms_mux_copyreq(queue_t *, consms_msg_t *, mblk_t *);
80 static void consms_mux_ack(consms_msg_t *, mblk_t *);
81 static void consms_mux_disp_data(mblk_t *);
82 
83 
84 static int	consmsopen();
85 static int	consmsclose();
86 static void	consmsuwput();
87 static void	consmslrput();
88 static void	consmslwserv();
89 
90 static struct module_info consmsm_info = {
91 	0,
92 	"consms",
93 	0,
94 	1024,
95 	2048,
96 	128
97 };
98 
99 static struct qinit consmsurinit = {
100 	putq,
101 	(int (*)())NULL,
102 	consmsopen,
103 	consmsclose,
104 	(int (*)())NULL,
105 	&consmsm_info,
106 	NULL
107 };
108 
109 static struct qinit consmsuwinit = {
110 	(int (*)())consmsuwput,
111 	(int (*)())NULL,
112 	consmsopen,
113 	consmsclose,
114 	(int (*)())NULL,
115 	&consmsm_info,
116 	NULL
117 };
118 
119 static struct qinit consmslrinit = {
120 	(int (*)())consmslrput,
121 	(int (*)())NULL,
122 	(int (*)())NULL,
123 	(int (*)())NULL,
124 	(int (*)())NULL,
125 	&consmsm_info,
126 	NULL
127 };
128 
129 static struct qinit consmslwinit = {
130 	putq,
131 	(int (*)())consmslwserv,
132 	(int (*)())NULL,
133 	(int (*)())NULL,
134 	(int (*)())NULL,
135 	&consmsm_info,
136 	NULL
137 };
138 
139 static struct streamtab consms_str_info = {
140 	&consmsurinit,
141 	&consmsuwinit,
142 	&consmslrinit,
143 	&consmslwinit,
144 };
145 
146 static void consmsioctl(queue_t *q, mblk_t *mp);
147 static int consms_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg,
148 		void **result);
149 static int consms_attach(dev_info_t *devi, ddi_attach_cmd_t cmd);
150 static int consms_detach(dev_info_t *devi, ddi_detach_cmd_t cmd);
151 static int consms_kstat_update(kstat_t *, int);
152 
153 /*
154  * Module global data are protected by the per-module inner perimeter.
155  */
156 static queue_t		*upperqueue;	/* regular mouse queue above us */
157 static dev_info_t	*consms_dip;	/* private copy of devinfo pointer */
158 static long	consms_idle_stamp;	/* seconds tstamp of latest mouse op */
159 
160 static consms_msg_t	*consms_mux_msg; /* ioctl messages being processed */
161 static	kmutex_t	consms_msg_lock; /* protect ioctl messages list */
162 
163 static consms_state_t	consms_state;	/* the global virtual mouse state */
164 static	kmutex_t	consmslock;
165 
166 
167 /*
168  * Normally, kstats of type KSTAT_TYPE_NAMED have multiple elements.  In
169  * this case we use this type for a single element because the ioctl code
170  * for it knows how to handle mixed kernel/user data models.  Also, it
171  * will be easier to add new statistics later.
172  */
173 static struct {
174 	kstat_named_t idle_sec;		/* seconds since last user op */
175 } consms_kstat = {
176 	{ "idle_sec", KSTAT_DATA_LONG, }
177 };
178 
179 
180 static 	struct cb_ops cb_consms_ops = {
181 	nulldev,		/* cb_open */
182 	nulldev,		/* cb_close */
183 	nodev,			/* cb_strategy */
184 	nodev,			/* cb_print */
185 	nodev,			/* cb_dump */
186 	nodev,			/* cb_read */
187 	nodev,			/* cb_write */
188 	nodev,			/* cb_ioctl */
189 	nodev,			/* cb_devmap */
190 	nodev,			/* cb_mmap */
191 	nodev,			/* cb_segmap */
192 	nochpoll,		/* cb_chpoll */
193 	ddi_prop_op,		/* cb_prop_op */
194 	&consms_str_info,	/* cb_stream */
195 	D_MP | D_MTPERMOD	/* cb_flag */
196 };
197 
198 static struct dev_ops consms_ops = {
199 	DEVO_REV,		/* devo_rev */
200 	0,			/* devo_refcnt */
201 	consms_info,		/* devo_getinfo */
202 	nulldev,		/* devo_identify */
203 	nulldev,		/* devo_probe */
204 	consms_attach,		/* devo_attach */
205 	consms_detach,		/* devo_detach */
206 	nodev,			/* devo_reset */
207 	&(cb_consms_ops),	/* devo_cb_ops */
208 	(struct bus_ops *)NULL,	/* devo_bus_ops */
209 	NULL,			/* devo_power */
210 	ddi_quiesce_not_needed,		/* devo_quiesce */
211 };
212 
213 
214 /*
215  * Module linkage information for the kernel.
216  */
217 
218 static struct modldrv modldrv = {
219 	&mod_driverops, /* Type of module.  This one is a pseudo driver */
220 	"Mouse Driver for Sun 'consms' 5.57",
221 	&consms_ops,	/* driver ops */
222 };
223 
224 static struct modlinkage modlinkage = {
225 	MODREV_1,
226 	(void *)&modldrv,
227 	NULL
228 };
229 
230 int
231 _init(void)
232 {
233 	int	error;
234 
235 	mutex_init(&consmslock, NULL, MUTEX_DRIVER, NULL);
236 	mutex_init(&consms_msg_lock, NULL, MUTEX_DRIVER, NULL);
237 	error = mod_install(&modlinkage);
238 	if (error != 0) {
239 		mutex_destroy(&consmslock);
240 		mutex_destroy(&consms_msg_lock);
241 	}
242 	return (error);
243 }
244 
245 int
246 _fini(void)
247 {
248 	int	error;
249 
250 	error = mod_remove(&modlinkage);
251 	if (error != 0)
252 		return (error);
253 	mutex_destroy(&consmslock);
254 	mutex_destroy(&consms_msg_lock);
255 	return (0);
256 }
257 
258 int
259 _info(struct modinfo *modinfop)
260 {
261 	return (mod_info(&modlinkage, modinfop));
262 }
263 
264 static int
265 consms_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
266 {
267 	kstat_t	*ksp;
268 
269 	switch (cmd) {
270 	case DDI_ATTACH:
271 		break;
272 	default:
273 		return (DDI_FAILURE);
274 	}
275 
276 	if (ddi_create_minor_node(devi, "mouse", S_IFCHR,
277 	    0, DDI_PSEUDO, 0) == DDI_FAILURE) {
278 		ddi_remove_minor_node(devi, NULL);
279 		return (-1);
280 	}
281 	consms_dip = devi;
282 	(void) ddi_prop_update_int(DDI_DEV_T_NONE, devi, DDI_NO_AUTODETACH, 1);
283 
284 	ksp = kstat_create("consms", 0, "activity", "misc", KSTAT_TYPE_NAMED,
285 	    sizeof (consms_kstat) / sizeof (kstat_named_t), KSTAT_FLAG_VIRTUAL);
286 	if (ksp) {
287 		ksp->ks_data = (void *)&consms_kstat;
288 		ksp->ks_update = consms_kstat_update;
289 		kstat_install(ksp);
290 		consms_idle_stamp = gethrestime_sec();	/* initial value */
291 	}
292 
293 	consms_state.consms_lqs = NULL;
294 	consms_state.consms_num_lqs = 0;
295 
296 	/* default consms state values */
297 	consms_state.consms_vuid_format = VUID_FIRM_EVENT;
298 	consms_state.consms_num_buttons = 0;
299 	consms_state.consms_num_wheels = 0;
300 	consms_state.consms_wheel_state_bf |= VUID_WHEEL_STATE_ENABLED;
301 	consms_state.consms_ms_parms.jitter_thresh =
302 	    CONSMS_PARMS_DEFAULT_JITTER;
303 	consms_state.consms_ms_parms.speed_limit =
304 	    CONSMS_PARMS_DEFAULT_SPEED_LIMIT;
305 	consms_state.consms_ms_parms.speed_law =
306 	    CONSMS_PARMS_DEFAULT_SPEED_LAW;
307 	consms_state.consms_ms_sr.height = CONSMS_SR_DEFAULT_HEIGHT;
308 	consms_state.consms_ms_sr.width = CONSMS_SR_DEFAULT_WIDTH;
309 
310 	return (DDI_SUCCESS);
311 }
312 
313 /*ARGSUSED*/
314 static int
315 consms_detach(dev_info_t *devi, ddi_detach_cmd_t cmd)
316 {
317 	switch (cmd) {
318 	case DDI_DETACH:
319 	default:
320 		return (DDI_FAILURE);
321 	}
322 }
323 
324 /*ARGSUSED*/
325 static int
326 consms_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg,
327 	void **result)
328 {
329 	register int error;
330 
331 	switch (infocmd) {
332 	case DDI_INFO_DEVT2DEVINFO:
333 		if (consms_dip == NULL) {
334 			error = DDI_FAILURE;
335 		} else {
336 			*result = (void *) consms_dip;
337 			error = DDI_SUCCESS;
338 		}
339 		break;
340 	case DDI_INFO_DEVT2INSTANCE:
341 		*result = (void *)0;
342 		error = DDI_SUCCESS;
343 		break;
344 	default:
345 		error = DDI_FAILURE;
346 	}
347 	return (error);
348 }
349 
350 
351 /*ARGSUSED*/
352 static int
353 consmsopen(q, devp, flag, sflag, crp)
354 	queue_t *q;
355 	dev_t	*devp;
356 	int	flag, sflag;
357 	cred_t	*crp;
358 {
359 	upperqueue = q;
360 	qprocson(q);
361 	return (0);
362 }
363 
364 /*ARGSUSED*/
365 static int
366 consmsclose(q, flag, crp)
367 	queue_t *q;
368 	int	flag;
369 	cred_t	*crp;
370 {
371 	qprocsoff(q);
372 	upperqueue = NULL;
373 	return (0);
374 }
375 
376 /*
377  * Put procedure for upper write queue.
378  */
379 static void
380 consmsuwput(q, mp)
381 	register queue_t *q;
382 	register mblk_t *mp;
383 {
384 	struct iocblk		*iocbp = (struct iocblk *)mp->b_rptr;
385 	consms_msg_t		*msg;
386 	int			error = 0;
387 
388 	switch (mp->b_datap->db_type) {
389 
390 	case M_IOCTL:
391 		consmsioctl(q, mp);
392 		break;
393 
394 	case M_FLUSH:
395 		if (*mp->b_rptr & FLUSHW)
396 			flushq(q, FLUSHDATA);
397 		if (*mp->b_rptr & FLUSHR)
398 			flushq(RD(q), FLUSHDATA);
399 		if (consms_state.consms_num_lqs > 0) {
400 			consms_mux_disp_data(mp);
401 		} else {
402 			/*
403 			 * No lower queue; just reflect this back upstream.
404 			 */
405 			*mp->b_rptr &= ~FLUSHW;
406 			if (*mp->b_rptr & FLUSHR)
407 				qreply(q, mp);
408 			else
409 				freemsg(mp);
410 		}
411 		break;
412 
413 	case M_DATA:
414 		if (consms_state.consms_num_lqs > 0) {
415 			consms_mux_disp_data(mp);
416 		} else {
417 			freemsg(mp);
418 		}
419 		break;
420 
421 	case M_IOCDATA:
422 		if ((msg = consms_mux_find_msg(iocbp->ioc_id)) != NULL) {
423 			consms_mux_iocdata(msg, mp);
424 		} else {
425 			error = EINVAL;
426 		}
427 		break;
428 
429 	default:
430 		error = EINVAL;
431 		break;
432 	}
433 
434 	if (error) {
435 		/*
436 		 * Pass an error message up.
437 		 */
438 		mp->b_datap->db_type = M_ERROR;
439 		if (mp->b_cont) {
440 			freemsg(mp->b_cont);
441 			mp->b_cont = NULL;
442 		}
443 		mp->b_rptr = mp->b_datap->db_base;
444 		mp->b_wptr = mp->b_rptr + sizeof (char);
445 		*mp->b_rptr = (char)error;
446 		qreply(q, mp);
447 	}
448 }
449 
450 static void
451 consmsioctl(q, mp)
452 	register queue_t *q;
453 	register mblk_t *mp;
454 {
455 	register struct iocblk *iocp;
456 	int		error;
457 	mblk_t		*datap;
458 
459 	iocp = (struct iocblk *)mp->b_rptr;
460 
461 	switch (iocp->ioc_cmd) {
462 
463 	case I_LINK:
464 	case I_PLINK:
465 		mutex_enter(&consmslock);
466 		consms_plink(q, mp);
467 		mutex_exit(&consmslock);
468 		return;
469 
470 	case I_UNLINK:
471 	case I_PUNLINK:
472 		mutex_enter(&consmslock);
473 		if ((error = consms_punlink(q, mp)) != 0) {
474 			mutex_exit(&consmslock);
475 			miocnak(q, mp, 0, error);
476 			return;
477 		}
478 		mutex_exit(&consmslock);
479 		iocp->ioc_count = 0;
480 		break;
481 
482 	case MSIOBUTTONS:	/* query the number of buttons */
483 		if ((consms_state.consms_num_lqs <= 0) ||
484 		    ((datap = allocb(sizeof (int), BPRI_HI)) == NULL)) {
485 			miocnak(q, mp, 0, ENOMEM);
486 			return;
487 		}
488 		*(int *)datap->b_wptr = consms_state.consms_num_buttons;
489 		datap->b_wptr += sizeof (int);
490 		if (mp->b_cont) {
491 			freemsg(mp->b_cont);
492 		}
493 		mp->b_cont = datap;
494 		iocp->ioc_count = sizeof (int);
495 		break;
496 
497 	default:
498 		/*
499 		 * Pass this through, if there's something to pass it
500 		 * through to; otherwise, reject it.
501 		 */
502 		if (consms_state.consms_num_lqs <= 0) {
503 			miocnak(q, mp, 0, EINVAL);
504 			return;
505 		}
506 		if ((error = consms_mux_disp_ioctl(q, mp)) != 0)
507 			miocnak(q, mp, 0, error);
508 
509 		return;
510 	}
511 
512 	/*
513 	 * Common exit path for calls that return a positive
514 	 * acknowledgment with a return value of 0.
515 	 */
516 	miocack(q, mp, iocp->ioc_count, 0);
517 }
518 
519 /*
520  * Service procedure for lower write queue.
521  * Puts things on the queue below us, if it lets us.
522  */
523 static void
524 consmslwserv(q)
525 	register queue_t *q;
526 {
527 	register mblk_t *mp;
528 
529 	while (canput(q->q_next) && (mp = getq(q)) != NULL)
530 		putnext(q, mp);
531 }
532 
533 /*
534  * Put procedure for lower read queue.
535  */
536 static void
537 consmslrput(q, mp)
538 	register queue_t *q;
539 	register mblk_t *mp;
540 {
541 	struct iocblk		*iocbp = (struct iocblk *)mp->b_rptr;
542 	struct copyreq		*copyreq = (struct copyreq *)mp->b_rptr;
543 	consms_msg_t		*msg;
544 	consms_lq_t		*lq = (consms_lq_t *)q->q_ptr;
545 
546 	ASSERT(lq != NULL);
547 
548 	switch (mp->b_datap->db_type) {
549 	case M_FLUSH:
550 		if (*mp->b_rptr & FLUSHW)
551 			flushq(WR(q), FLUSHDATA);
552 		if (*mp->b_rptr & FLUSHR)
553 			flushq(q, FLUSHDATA);
554 		if (upperqueue != NULL)
555 			putnext(upperqueue, mp);	/* pass it through */
556 		else {
557 			/*
558 			 * No upper queue; just reflect this back downstream.
559 			 */
560 			*mp->b_rptr &= ~FLUSHR;
561 			if (*mp->b_rptr & FLUSHW)
562 				qreply(q, mp);
563 			else
564 				freemsg(mp);
565 		}
566 		break;
567 
568 	case M_DATA:
569 		if (upperqueue != NULL)
570 			putnext(upperqueue, mp);
571 		else
572 			freemsg(mp);
573 		consms_idle_stamp = gethrestime_sec();
574 		break;
575 
576 	case M_IOCACK:
577 	case M_IOCNAK:
578 		/*
579 		 * First, check to see if this device
580 		 * is still being initialized.
581 		 */
582 		if (lq->lq_ioc_reply_func != NULL) {
583 			mutex_enter(&consmslock);
584 			lq->lq_ioc_reply_func(lq, mp);
585 			mutex_exit(&consmslock);
586 			freemsg(mp);
587 			break;
588 		}
589 
590 		/*
591 		 * This is normal ioctl ack for upper layer.
592 		 */
593 		if ((msg = consms_mux_find_msg(iocbp->ioc_id)) != NULL) {
594 			consms_mux_ack(msg, mp);
595 		} else {
596 			freemsg(mp);
597 		}
598 		consms_idle_stamp = gethrestime_sec();
599 		break;
600 
601 	case M_COPYIN:
602 	case M_COPYOUT:
603 		if ((msg = consms_mux_find_msg(copyreq->cq_id)) != NULL) {
604 			consms_mux_copyreq(q, msg, mp);
605 		} else
606 			freemsg(mp);
607 		consms_idle_stamp = gethrestime_sec();
608 		break;
609 
610 	case M_ERROR:
611 	case M_HANGUP:
612 	default:
613 		freemsg(mp);	/* anything useful here? */
614 		break;
615 	}
616 }
617 
618 /* ARGSUSED */
619 static int
620 consms_kstat_update(kstat_t *ksp, int rw)
621 {
622 	if (rw == KSTAT_WRITE)
623 		return (EACCES);
624 
625 	consms_kstat.idle_sec.value.l = gethrestime_sec() - consms_idle_stamp;
626 	return (0);
627 }
628 
629 /*ARGSUSED*/
630 static int
631 consms_punlink(queue_t *q, mblk_t *mp)
632 {
633 	struct linkblk	*linkp;
634 	consms_lq_t	*lq;
635 	consms_lq_t	*prev_lq;
636 
637 	ASSERT(MUTEX_HELD(&consmslock));
638 
639 	linkp = (struct linkblk *)mp->b_cont->b_rptr;
640 
641 	prev_lq = NULL;
642 	for (lq = consms_state.consms_lqs; lq != NULL; lq = lq->lq_next) {
643 		if (lq->lq_queue == linkp->l_qbot) {
644 			if (prev_lq)
645 				prev_lq->lq_next = lq->lq_next;
646 			else
647 				consms_state.consms_lqs = lq->lq_next;
648 			kmem_free(lq, sizeof (*lq));
649 			consms_state.consms_num_lqs--;
650 
651 			/*
652 			 * Check to see if mouse capabilities
653 			 * have changed.
654 			 */
655 			consms_check_caps();
656 
657 			return (0);
658 		}
659 		prev_lq = lq;
660 	}
661 
662 	return (EINVAL);
663 }
664 
665 /*
666  * Link a specific mouse into our mouse list.
667  */
668 static void
669 consms_plink(queue_t *q, mblk_t *mp)
670 {
671 	struct	linkblk	*linkp;
672 	consms_lq_t	*lq;
673 	queue_t		*lowq;
674 
675 	ASSERT(MUTEX_HELD(&consmslock));
676 
677 	linkp = (struct linkblk *)mp->b_cont->b_rptr;
678 	lowq = linkp->l_qbot;
679 
680 	lq = kmem_zalloc(sizeof (*lq), KM_SLEEP);
681 
682 	lowq->q_ptr = (void *)lq;
683 	OTHERQ(lowq)->q_ptr = (void *)lq;
684 	lq->lq_queue = lowq;
685 	lq->lq_pending_plink = mp;
686 	lq->lq_pending_queue = q;
687 
688 	/*
689 	 * Set the number of buttons to 3 by default
690 	 * in case the following MSIOBUTTONS ioctl fails.
691 	 */
692 	lq->lq_num_buttons = 3;
693 
694 	/*
695 	 * Begin to initialize this mouse.
696 	 */
697 	lq->lq_state = LQS_START;
698 	consms_lqs_ack_complete(lq, NULL);
699 }
700 
701 /*
702  * Initialize the newly hotplugged-in mouse,
703  * e.g. get the number of buttons, set event
704  * format. Then we add it into our list.
705  */
706 static void
707 consms_lqs_ack_complete(consms_lq_t *lq, mblk_t *mp)
708 {
709 	mblk_t			*req = NULL;
710 	boolean_t		skipped = B_FALSE;
711 	wheel_state		*ws;
712 	Ms_screen_resolution	*sr;
713 	Ms_parms		*params;
714 
715 	ASSERT(MUTEX_HELD(&consmslock));
716 
717 	/*
718 	 * We try each ioctl even if the previous one fails
719 	 * until we reach LQS_DONE, and then add this lq
720 	 * into our lq list.
721 	 *
722 	 * If the message allocation fails, we skip this ioctl,
723 	 * set skipped flag to B_TRUE in order to skip the ioctl
724 	 * result, then we try next ioctl, go to next state.
725 	 */
726 	while ((lq->lq_state < LQS_DONE) && (req == NULL)) {
727 		switch (lq->lq_state) {
728 		case LQS_START:
729 			/*
730 			 * First, issue MSIOBUTTONS ioctl
731 			 * to get the number of buttons.
732 			 */
733 			req = mkiocb(MSIOBUTTONS);
734 			if (req && ((req->b_cont = allocb(sizeof (int),
735 			    BPRI_MED)) == NULL)) {
736 				freemsg(req);
737 				req = NULL;
738 			}
739 			if (req == NULL)
740 				skipped = B_TRUE;
741 			lq->lq_state++;
742 			break;
743 
744 		case LQS_BUTTON_COUNT_PENDING:
745 			if (!skipped && mp && mp->b_cont &&
746 			    (mp->b_datap->db_type == M_IOCACK))
747 				lq->lq_num_buttons =
748 				    *(int *)mp->b_cont->b_rptr;
749 
750 			/*
751 			 * Second, issue VUIDGWHEELCOUNT ioctl
752 			 * to get the count of wheels.
753 			 */
754 			req = mkiocb(VUIDGWHEELCOUNT);
755 			if (req && ((req->b_cont = allocb(sizeof (int),
756 			    BPRI_MED)) == NULL)) {
757 				freemsg(req);
758 				req = NULL;
759 			}
760 			if (req == NULL)
761 				skipped = B_TRUE;
762 			lq->lq_state++;
763 			break;
764 
765 		case LQS_WHEEL_COUNT_PENDING:
766 			if (!skipped && mp && mp->b_cont &&
767 			    (mp->b_datap->db_type == M_IOCACK))
768 				lq->lq_num_wheels =
769 				    *(int *)mp->b_cont->b_rptr;
770 
771 			/*
772 			 * Third, issue VUIDSFORMAT ioctl
773 			 * to set the event format.
774 			 */
775 			req = mkiocb(VUIDSFORMAT);
776 			if (req && ((req->b_cont = allocb(sizeof (int),
777 			    BPRI_MED)) == NULL)) {
778 				freemsg(req);
779 				req = NULL;
780 			}
781 			if (req) {
782 				*(int *)req->b_cont->b_wptr =
783 				    consms_state.consms_vuid_format;
784 				req->b_cont->b_wptr += sizeof (int);
785 			}
786 			lq->lq_state++;
787 			break;
788 
789 		case LQS_SET_VUID_FORMAT_PENDING:
790 			/*
791 			 * Fourth, issue VUIDSWHEELSTATE ioctl
792 			 * to set the wheel state (enable or disable).
793 			 */
794 			req = mkiocb(VUIDSWHEELSTATE);
795 			if (req && ((req->b_cont = allocb(sizeof (wheel_state),
796 			    BPRI_MED)) == NULL)) {
797 				freemsg(req);
798 				req = NULL;
799 			}
800 			if (req) {
801 				ws = (wheel_state *)req->b_cont->b_wptr;
802 				ws->vers = VUID_WHEEL_STATE_VERS;
803 				ws->id = 0;	/* the first wheel */
804 				ws->stateflags =
805 				    consms_state.consms_wheel_state_bf & 1;
806 				req->b_cont->b_wptr += sizeof (wheel_state);
807 			}
808 			lq->lq_state++;
809 			break;
810 
811 		case LQS_SET_WHEEL_STATE_PENDING:
812 			/*
813 			 * Fifth,  issue MSIOSETPARMS ioctl
814 			 * to set the parameters for USB mouse.
815 			 */
816 			req = mkiocb(MSIOSETPARMS);
817 			if (req && ((req->b_cont = allocb(sizeof (Ms_parms),
818 			    BPRI_MED)) == NULL)) {
819 				freemsg(req);
820 				req = NULL;
821 			}
822 			if (req) {
823 				params = (Ms_parms *)req->b_cont->b_wptr;
824 				*params = consms_state.consms_ms_parms;
825 				req->b_cont->b_wptr += sizeof (Ms_parms);
826 			}
827 			lq->lq_state++;
828 			break;
829 
830 		case LQS_SET_PARMS_PENDING:
831 			/*
832 			 * Sixth, issue MSIOSRESOLUTION ioctl
833 			 * to set the screen resolution for absolute mouse.
834 			 */
835 			req = mkiocb(MSIOSRESOLUTION);
836 			if (req && ((req->b_cont =
837 			    allocb(sizeof (Ms_screen_resolution),
838 			    BPRI_MED)) == NULL)) {
839 				freemsg(req);
840 				req = NULL;
841 			}
842 			if (req) {
843 				sr =
844 				    (Ms_screen_resolution *)req->b_cont->b_wptr;
845 				*sr = consms_state.consms_ms_sr;
846 				req->b_cont->b_wptr +=
847 				    sizeof (Ms_screen_resolution);
848 			}
849 			lq->lq_state++;
850 			break;
851 
852 		case LQS_SET_RESOLUTION_PENDING:
853 			/*
854 			 * All jobs are done, lq->lq_state is turned into
855 			 * LQS_DONE, and this lq is added into our list.
856 			 */
857 			lq->lq_state++;
858 			consms_add_lq(lq);
859 			break;
860 		}
861 	}
862 
863 	if (lq->lq_state < LQS_DONE) {
864 		lq->lq_ioc_reply_func = consms_lqs_ack_complete;
865 		(void) putq(lq->lq_queue, req);
866 	}
867 }
868 
869 /*
870  * Add this specific lq into our list, finally reply
871  * the previous pending I_PLINK ioctl. Also check to
872  * see if mouse capabilities have changed, and send
873  * a dynamical notification event to upper layer if
874  * necessary.
875  */
876 static void
877 consms_add_lq(consms_lq_t *lq)
878 {
879 	struct	iocblk		*iocp;
880 
881 	ASSERT(MUTEX_HELD(&consmslock));
882 
883 	lq->lq_ioc_reply_func = NULL;
884 	iocp = (struct iocblk *)lq->lq_pending_plink->b_rptr;
885 	iocp->ioc_error = 0;
886 	iocp->ioc_count = 0;
887 	iocp->ioc_rval = 0;
888 	lq->lq_pending_plink->b_datap->db_type = M_IOCACK;
889 
890 	/* Reply to the I_PLINK ioctl. */
891 	qreply(lq->lq_pending_queue, lq->lq_pending_plink);
892 
893 	lq->lq_pending_plink = NULL;
894 	lq->lq_pending_queue = NULL;
895 
896 	/*
897 	 * Add this lq into list.
898 	 */
899 	consms_state.consms_num_lqs++;
900 
901 	lq->lq_next = consms_state.consms_lqs;
902 	consms_state.consms_lqs = lq;
903 
904 	/*
905 	 * Check to see if mouse capabilities
906 	 * have changed.
907 	 */
908 	consms_check_caps();
909 
910 }
911 
912 
913 static void
914 consms_check_caps(void)
915 {
916 	consms_lq_t *lq;
917 	int	max_buttons = 0;
918 	int	max_wheels = 0;
919 	mblk_t	*mp;
920 
921 	/*
922 	 * Check to see if the number of buttons
923 	 * and the number of wheels have changed.
924 	 */
925 	for (lq = consms_state.consms_lqs; lq != NULL; lq = lq->lq_next) {
926 		max_buttons = CONSMS_MAX(max_buttons, lq->lq_num_buttons);
927 		max_wheels = CONSMS_MAX(max_wheels, lq->lq_num_wheels);
928 	}
929 
930 	if (max_buttons != consms_state.consms_num_buttons) {
931 		/*
932 		 * Since the number of buttons have changed,
933 		 * send a MOUSE_CAP_CHANGE_NUM_BUT dynamical
934 		 * notification event to upper layer.
935 		 */
936 		consms_state.consms_num_buttons = max_buttons;
937 		if (upperqueue != NULL) {
938 			if ((mp = consms_new_firm_event(
939 			    MOUSE_CAP_CHANGE_NUM_BUT,
940 			    consms_state.consms_num_buttons)) != NULL) {
941 				putnext(upperqueue, mp);
942 			}
943 		}
944 	}
945 
946 	if (max_wheels != consms_state.consms_num_wheels) {
947 		/*
948 		 * Since the number of wheels have changed,
949 		 * send a MOUSE_CAP_CHANGE_NUM_WHEEL dynamical
950 		 * notification event to upper layer.
951 		 */
952 		consms_state.consms_num_wheels = max_wheels;
953 		if (upperqueue != NULL) {
954 			if ((mp = consms_new_firm_event(
955 			    MOUSE_CAP_CHANGE_NUM_WHEEL,
956 			    consms_state.consms_num_wheels)) != NULL) {
957 				putnext(upperqueue, mp);
958 			}
959 		}
960 	}
961 }
962 
963 /*
964  * Allocate a dynamical notification event.
965  */
966 static mblk_t *
967 consms_new_firm_event(ushort_t id, int value)
968 {
969 	Firm_event *fep;
970 	mblk_t	*tmp;
971 
972 	if ((tmp = allocb(sizeof (Firm_event), BPRI_HI)) != NULL) {
973 		fep = (Firm_event *)tmp->b_wptr;
974 		fep->id = id;
975 		fep->pair_type = FE_PAIR_NONE;
976 		fep->pair = '\0';
977 		fep->value = value;
978 		tmp->b_wptr += sizeof (Firm_event);
979 	}
980 
981 	return (tmp);
982 }
983 
984 /*
985  * Start of dispatching interfaces as a multiplexor
986  */
987 
988 /*
989  * There is a global msg list (consms_mux_msg),
990  * which is used to link all ioctl messages from
991  * upper layer, which are currently being processed.
992  *
993  * consms_mux_link_msg links a msg into the list,
994  * consms_mux_unlink_msg unlinks a msg from the list,
995  * consms_mux_find_msg finds a msg from the list
996  * according to its unique id.
997  *
998  * The id of each msg is taken from stream's mp,
999  * so the id is supposed to be unique.
1000  */
1001 static void
1002 consms_mux_link_msg(consms_msg_t *msg)
1003 {
1004 	mutex_enter(&consms_msg_lock);
1005 	msg->msg_next = consms_mux_msg;
1006 	consms_mux_msg = msg;
1007 	mutex_exit(&consms_msg_lock);
1008 }
1009 
1010 static consms_msg_t *
1011 consms_mux_unlink_msg(uint_t msg_id)
1012 {
1013 	consms_msg_t	*msg;
1014 	consms_msg_t	*prev_msg;
1015 
1016 	mutex_enter(&consms_msg_lock);
1017 	prev_msg = NULL;
1018 	for (msg = consms_mux_msg; msg != NULL;
1019 	    prev_msg = msg, msg = msg->msg_next) {
1020 		if (msg->msg_id == msg_id)
1021 			break;
1022 	}
1023 
1024 	if (msg != NULL) {
1025 		if (prev_msg != NULL) {
1026 			prev_msg->msg_next = msg->msg_next;
1027 		} else {
1028 			consms_mux_msg = consms_mux_msg->msg_next;
1029 		}
1030 		msg->msg_next = NULL;
1031 	}
1032 	mutex_exit(&consms_msg_lock);
1033 
1034 	return (msg);
1035 }
1036 
1037 static consms_msg_t *
1038 consms_mux_find_msg(uint_t msg_id)
1039 {
1040 	consms_msg_t	*msg;
1041 
1042 	mutex_enter(&consms_msg_lock);
1043 	for (msg = consms_mux_msg; msg != NULL; msg = msg->msg_next) {
1044 		if (msg->msg_id == msg_id)
1045 			break;
1046 	}
1047 	mutex_exit(&consms_msg_lock);
1048 
1049 	return (msg);
1050 }
1051 
1052 /*
1053  * Received ACK or NAK from lower mice
1054  *
1055  * For non-transparent ioctl, the msg->msg_rsp_list
1056  * is always NULL; for transparent ioctl, it
1057  * remembers the M_COPYIN/M_COPYOUT request
1058  * messages from lower mice. So here if msg->msg_rsp_list
1059  * is NULL (after receiving all ACK/NAKs), we
1060  * are done with this specific ioctl.
1061  *
1062  * As long as one of lower mice responds success,
1063  * we treat it success for a ioctl.
1064  */
1065 static void
1066 consms_mux_ack(consms_msg_t *msg, mblk_t *mp)
1067 {
1068 	mblk_t	*ack_mp;
1069 
1070 	/* increment response_nums */
1071 	msg->msg_num_responses++;
1072 
1073 	if (mp->b_datap->db_type == M_IOCACK) {
1074 		/*
1075 		 * Received ACK from lower, then
1076 		 * this is the last step for both
1077 		 * non-transparent and transparent
1078 		 * ioctl. We only need to remember
1079 		 * one of the ACKs, finally reply
1080 		 * this ACK to upper layer for this
1081 		 * specific ioctl.
1082 		 */
1083 		ASSERT(msg->msg_rsp_list == NULL);
1084 		if (msg->msg_ack_mp == NULL) {
1085 			msg->msg_ack_mp = mp;
1086 			mp = NULL;
1087 		}
1088 	}
1089 
1090 	/*
1091 	 * Check to see if all lower mice have responded
1092 	 * to our dispatching ioctl.
1093 	 */
1094 	if (msg->msg_num_responses == msg->msg_num_requests) {
1095 		if ((msg->msg_ack_mp == NULL) &&
1096 		    (msg->msg_rsp_list == NULL)) {
1097 			/*
1098 			 * All are NAKed.
1099 			 */
1100 			ack_mp = mp;
1101 			mp = NULL;
1102 		} else if (msg->msg_rsp_list == NULL) {
1103 			/*
1104 			 * The last step and at least one ACKed.
1105 			 */
1106 			ack_mp = msg->msg_ack_mp;
1107 			consms_mux_cache_states(msg->msg_request);
1108 			consms_mux_max_wheel_report(ack_mp);
1109 		} else {
1110 			/*
1111 			 * This is a NAK, but we have
1112 			 * already received M_COPYIN
1113 			 * or M_COPYOUT request from
1114 			 * at least one of lower mice.
1115 			 * (msg->msg_rsp_list != NULL)
1116 			 *
1117 			 * Still copyin or copyout.
1118 			 */
1119 			ack_mp = msg->msg_rsp_list->rsp_mp;
1120 			consms_mux_max_wheel_report(ack_mp);
1121 		}
1122 
1123 		qreply(msg->msg_queue, ack_mp);
1124 
1125 		if (msg->msg_rsp_list == NULL) {
1126 			/*
1127 			 * We are done with this ioctl.
1128 			 */
1129 			if (msg->msg_request)
1130 				freemsg(msg->msg_request);
1131 			(void) consms_mux_unlink_msg(msg->msg_id);
1132 			kmem_free(msg, sizeof (*msg));
1133 		}
1134 	}
1135 
1136 	if (mp) {
1137 		freemsg(mp);
1138 	}
1139 }
1140 
1141 /*
1142  * Received M_COPYIN or M_COPYOUT request from
1143  * lower mice for transparent ioctl
1144  *
1145  * We remember each M_COPYIN/M_COPYOUT into the
1146  * msg->msg_rsp_list, reply upper layer using the first
1147  * M_COPYIN/M_COPYOUT in the list after receiving
1148  * all responses from lower mice, even if some of
1149  * them return NAKs.
1150  */
1151 static void
1152 consms_mux_copyreq(queue_t *q, consms_msg_t *msg, mblk_t *mp)
1153 {
1154 	consms_response_t	*rsp;
1155 
1156 	rsp = (consms_response_t *)kmem_zalloc(sizeof (*rsp), KM_SLEEP);
1157 	rsp->rsp_mp = mp;
1158 	rsp->rsp_queue = q;
1159 	if (msg->msg_rsp_list) {
1160 		rsp->rsp_next = msg->msg_rsp_list;
1161 	}
1162 	msg->msg_rsp_list = rsp;
1163 	msg->msg_num_responses++;
1164 
1165 	if (msg->msg_num_responses == msg->msg_num_requests) {
1166 		consms_mux_max_wheel_report(msg->msg_rsp_list->rsp_mp);
1167 		qreply(msg->msg_queue, msg->msg_rsp_list->rsp_mp);
1168 	}
1169 }
1170 
1171 /*
1172  * Do the real job for updating M_COPYIN/M_COPYOUT
1173  * request with the mp of M_IOCDATA, then put it
1174  * down to lower mice.
1175  */
1176 static void
1177 consms_mux_disp_iocdata(consms_response_t *rsp, mblk_t *mp)
1178 {
1179 	mblk_t	*down_mp = rsp->rsp_mp;
1180 	struct copyresp *copyresp = (struct copyresp *)mp->b_rptr;
1181 	struct copyresp *newresp = (struct copyresp *)down_mp->b_rptr;
1182 
1183 	/*
1184 	 * Update the rval.
1185 	 */
1186 	newresp->cp_rval = copyresp->cp_rval;
1187 
1188 	/*
1189 	 * Update the db_type to M_IOCDATA.
1190 	 */
1191 	down_mp->b_datap->db_type = mp->b_datap->db_type;
1192 
1193 	/*
1194 	 * Update the b_cont.
1195 	 */
1196 	if (down_mp->b_cont != NULL) {
1197 		freemsg(down_mp->b_cont);
1198 		down_mp->b_cont = NULL;
1199 	}
1200 	if (mp->b_cont != NULL) {
1201 		down_mp->b_cont = copymsg(mp->b_cont);
1202 	}
1203 
1204 	/*
1205 	 * Put it down.
1206 	 */
1207 	(void) putq(WR(rsp->rsp_queue), down_mp);
1208 }
1209 
1210 /*
1211  * Dispatch M_IOCDATA down to all lower mice
1212  * for transparent ioctl.
1213  *
1214  * We update each M_COPYIN/M_COPYOUT in the
1215  * msg->msg_rsp_list with the M_IOCDATA.
1216  */
1217 static void
1218 consms_mux_iocdata(consms_msg_t *msg, mblk_t *mp)
1219 {
1220 	consms_response_t	*rsp;
1221 	consms_response_t	*tmp;
1222 	consms_response_t	*first;
1223 	struct copyresp		*copyresp;
1224 	int			request_nums;
1225 
1226 	ASSERT(msg->msg_rsp_list != NULL);
1227 
1228 	/*
1229 	 * We should remember the ioc data for
1230 	 * VUIDSWHEELSTATE, and MSIOSRESOLUTION,
1231 	 * for we will cache the wheel state and
1232 	 * the screen resolution later if ACKed.
1233 	 */
1234 	copyresp = (struct copyresp *)mp->b_rptr;
1235 	if ((copyresp->cp_cmd == VUIDSWHEELSTATE) ||
1236 	    (copyresp->cp_cmd == MSIOSRESOLUTION)) {
1237 		freemsg(msg->msg_request);
1238 		msg->msg_request = copymsg(mp);
1239 	}
1240 
1241 	/*
1242 	 * Update request numbers and response numbers.
1243 	 */
1244 	msg->msg_num_requests = msg->msg_num_responses;
1245 	msg->msg_num_responses = 0;
1246 	request_nums = 1;
1247 
1248 	/*
1249 	 * Since we have use the first M_COPYIN/M_COPYOUT
1250 	 * in the msg_rsp_list to reply upper layer, the mp
1251 	 * of M_IOCDATA can be directly used for that.
1252 	 */
1253 	first = msg->msg_rsp_list;
1254 	rsp = first->rsp_next;
1255 	msg->msg_rsp_list = NULL;
1256 
1257 	for (rsp = first->rsp_next; rsp != NULL; ) {
1258 		tmp = rsp;
1259 		rsp = rsp->rsp_next;
1260 		consms_mux_disp_iocdata(tmp, mp);
1261 		kmem_free(tmp, sizeof (*tmp));
1262 		request_nums++;
1263 	}
1264 
1265 	/* Must set the request number before the last q. */
1266 	msg->msg_num_requests = request_nums;
1267 
1268 	/* the first one */
1269 	(void) putq(WR(first->rsp_queue), mp);
1270 	kmem_free(first, sizeof (*first));
1271 }
1272 
1273 
1274 /*
1275  * Here we update the number of wheels with
1276  * the virtual mouse for VUIDGWHEELCOUNT ioctl.
1277  */
1278 static void
1279 consms_mux_max_wheel_report(mblk_t *mp)
1280 {
1281 	struct iocblk		*iocp;
1282 	int			num_wheels;
1283 
1284 	if (mp == NULL || mp->b_cont == NULL)
1285 		return;
1286 
1287 	iocp = (struct iocblk *)mp->b_rptr;
1288 
1289 	if ((iocp->ioc_cmd == VUIDGWHEELCOUNT) &&
1290 	    (mp->b_datap->db_type == M_COPYOUT)) {
1291 		num_wheels = *(int *)mp->b_cont->b_rptr;
1292 		if (num_wheels < consms_state.consms_num_wheels) {
1293 			*(int *)mp->b_cont->b_rptr =
1294 			    consms_state.consms_num_wheels;
1295 		}
1296 	}
1297 }
1298 
1299 /*
1300  * Update the virtual mouse state variables with
1301  * the latest value from upper layer when these
1302  * set ioctls return success. Thus we can update
1303  * low mice with the latest state values during
1304  * hotplug.
1305  */
1306 static void
1307 consms_mux_cache_states(mblk_t *mp)
1308 {
1309 	struct iocblk 		*iocp;
1310 	Ms_parms		*parms;
1311 	Ms_screen_resolution	*sr;
1312 	wheel_state		*ws;
1313 
1314 	if (mp == NULL || mp->b_cont == NULL)
1315 		return;
1316 
1317 	iocp = (struct iocblk *)mp->b_rptr;
1318 	switch (iocp->ioc_cmd) {
1319 	case VUIDSFORMAT:
1320 		consms_state.consms_vuid_format = *(int *)mp->b_cont->b_rptr;
1321 		break;
1322 
1323 	case MSIOSETPARMS:
1324 		parms = (Ms_parms *)mp->b_cont->b_rptr;
1325 		consms_state.consms_ms_parms = *parms;
1326 		break;
1327 
1328 	case MSIOSRESOLUTION:
1329 		sr = (Ms_screen_resolution *)mp->b_cont->b_rptr;
1330 		consms_state.consms_ms_sr = *sr;
1331 		break;
1332 
1333 	case VUIDSWHEELSTATE:
1334 		ws = (wheel_state *)mp->b_cont->b_rptr;
1335 		consms_state.consms_wheel_state_bf =
1336 		    (ws->stateflags << ws->id) |
1337 		    (consms_state.consms_wheel_state_bf & ~(1 << ws->id));
1338 		break;
1339 	}
1340 }
1341 
1342 /*
1343  * Dispatch ioctl mp (non-transparent and transparent)
1344  * down to all lower mice.
1345  *
1346  * First, create a pending message for this mp, link it into
1347  * the global messages list. Then wait for ACK/NAK for
1348  * non-transparent ioctl, COPYIN/COPYOUT for transparent
1349  * ioctl.
1350  */
1351 static int
1352 consms_mux_disp_ioctl(queue_t *q, mblk_t *mp)
1353 {
1354 	struct iocblk	*iocp;
1355 	consms_msg_t	*msg;
1356 	consms_lq_t	*lq;
1357 	mblk_t		*copy_mp;
1358 	int		error = 0;
1359 
1360 	iocp = (struct iocblk *)mp->b_rptr;
1361 	msg = (consms_msg_t *)kmem_zalloc(sizeof (*msg), KM_SLEEP);
1362 	msg->msg_id = iocp->ioc_id;
1363 	msg->msg_request = mp;
1364 	msg->msg_queue = q;
1365 	msg->msg_num_requests = consms_state.consms_num_lqs;
1366 	consms_mux_link_msg(msg);
1367 
1368 	for (lq = consms_state.consms_lqs; lq != NULL; lq = lq->lq_next) {
1369 		if ((copy_mp = copymsg(mp)) != NULL) {
1370 			(void) putq(lq->lq_queue, copy_mp);
1371 		} else {
1372 			/*
1373 			 * If copymsg fails, we ignore this lq and
1374 			 * try next one. As long as one of them succeeds,
1375 			 * we dispatch this ioctl down. And later as long
1376 			 * as one of the lower drivers return success, we
1377 			 * reply to this ioctl with success.
1378 			 */
1379 			msg->msg_num_requests--;
1380 		}
1381 	}
1382 
1383 	if (msg->msg_num_requests <= 0) {
1384 		/*
1385 		 * Since copymsg fails for all lqs, we NAK this ioctl.
1386 		 */
1387 		(void) consms_mux_unlink_msg(msg->msg_id);
1388 		kmem_free(msg, sizeof (*msg));
1389 		error = ENOMEM;
1390 	}
1391 
1392 	return (error);
1393 }
1394 
1395 /*
1396  * Dispatch M_DATA and M_FLUSH message down to all
1397  * lower mice, and there are no acknowledgements
1398  * for them. Here we just copy the mp and then
1399  * put it into the lower queues.
1400  */
1401 static void
1402 consms_mux_disp_data(mblk_t *mp)
1403 {
1404 	consms_lq_t	*lq;
1405 	mblk_t		*copy_mp;
1406 
1407 	for (lq = consms_state.consms_lqs; lq != NULL; lq = lq->lq_next) {
1408 		if ((copy_mp = copymsg(mp)) != NULL) {
1409 			(void) putq(lq->lq_queue, copy_mp);
1410 		}
1411 	}
1412 
1413 	freemsg(mp);
1414 }
1415