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 (C) 4Front Technologies 1996-2008. 23 * 24 * Copyright 2010 Sun Microsystems, Inc. All rights reserved. 25 * Use is subject to license terms. 26 */ 27 28 #include <sys/types.h> 29 #include <sys/sysmacros.h> 30 #include <sys/stropts.h> 31 #include <sys/strsun.h> 32 #include <sys/list.h> 33 #include <sys/mkdev.h> 34 #include <sys/conf.h> 35 #include <sys/note.h> 36 #include <sys/atomic.h> 37 #include <sys/ddi.h> 38 #include <sys/sunddi.h> 39 40 #include "audio_impl.h" 41 42 /* 43 * Audio DDI glue implementation. 44 */ 45 46 /* 47 * The audio module is itself a pseudo driver, as it contains the 48 * logic to support un-associated nodes. (Think generic /dev/mixer 49 * and /dev/sndstat used by OSS.) 50 */ 51 static int 52 audio_attach(dev_info_t *dip, ddi_attach_cmd_t cmd) 53 { 54 audio_dev_t *adev; 55 56 /* pseudo devices don't need S/R support */ 57 if ((cmd != DDI_ATTACH) || (dip == NULL)) { 58 return (DDI_FAILURE); 59 } 60 61 if (ddi_get_instance(dip) != 0) { 62 return (DDI_FAILURE); 63 } 64 65 /* this can't fail */ 66 adev = audio_dev_alloc(dip, 0); 67 adev->d_flags = DEV_SNDSTAT_CAP; 68 audio_dev_set_description(adev, "Audio Common Code"); 69 audio_dev_set_version(adev, "pseudo"); 70 ddi_set_driver_private(dip, adev); 71 72 /* look up our properties! */ 73 74 if (audio_dev_register(adev) != NULL) { 75 audio_dev_free(adev); 76 return (DDI_FAILURE); 77 } 78 79 ddi_report_dev(dip); 80 81 return (DDI_SUCCESS); 82 } 83 84 static int 85 audio_detach(dev_info_t *dip, ddi_detach_cmd_t cmd) 86 { 87 audio_dev_t *adev; 88 89 /* pseudo devices don't need S/R support */ 90 if (cmd != DDI_DETACH) { 91 return (DDI_FAILURE); 92 } 93 94 if (dip == NULL) { 95 return (DDI_FAILURE); 96 } 97 98 if ((adev = ddi_get_driver_private(dip)) == NULL) { 99 return (DDI_FAILURE); 100 } 101 102 if (audio_dev_unregister(adev) != DDI_SUCCESS) { 103 return (DDI_FAILURE); 104 } 105 106 audio_dev_free(adev); 107 108 return (DDI_SUCCESS); 109 } 110 111 static int 112 audio_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **resp) 113 { 114 dip = NULL; 115 116 if (getminor((dev_t)arg) & AUDIO_MN_CLONE_MASK) { 117 audio_client_t *c; 118 c = auclnt_hold_by_devt((dev_t)arg); 119 if (c != NULL) { 120 dip = c->c_dev->d_dip; 121 auclnt_release(c); 122 } 123 } else { 124 audio_dev_t *adev; 125 if ((adev = auimpl_dev_hold_by_devt((dev_t)arg)) != NULL) { 126 dip = adev->d_dip; 127 auimpl_dev_release(adev); 128 } 129 } 130 131 if (dip == NULL) { 132 return (DDI_FAILURE); 133 } 134 135 switch (cmd) { 136 case DDI_INFO_DEVT2DEVINFO: 137 *resp = dip; 138 break; 139 case DDI_INFO_DEVT2INSTANCE: 140 *resp = (void *)(uintptr_t)ddi_get_instance(dip); 141 break; 142 default: 143 *resp = NULL; 144 return (DDI_FAILURE); 145 } 146 return (DDI_SUCCESS); 147 } 148 149 static int 150 audio_open(dev_t *devp, int oflag, int otyp, cred_t *credp) 151 { 152 int rv; 153 audio_client_t *c; 154 155 if (otyp == OTYP_BLK) { 156 return (ENXIO); 157 } 158 159 if ((c = auimpl_client_create(*devp)) == NULL) { 160 audio_dev_warn(NULL, "client create failed"); 161 return (ENXIO); 162 } 163 164 c->c_omode = oflag; 165 c->c_pid = ddi_get_pid(); 166 c->c_cred = credp; 167 168 /* 169 * Call client/personality specific open handler. Note that 170 * we "insist" that there is an open. The personality layer 171 * will initialize/allocate any engines required. 172 * 173 * Hmm... do we need to pass in the cred? 174 */ 175 if ((rv = c->c_open(c, oflag)) != 0) { 176 audio_dev_warn(c->c_dev, "open failed (rv %d)", rv); 177 auimpl_client_destroy(c); 178 return (rv); 179 } 180 181 /* we do device cloning! */ 182 *devp = makedevice(c->c_major, c->c_minor); 183 184 /* now we can receive upcalls */ 185 auimpl_client_activate(c); 186 187 atomic_inc_uint(&c->c_dev->d_serial); 188 189 return (0); 190 } 191 192 static int 193 audio_stropen(queue_t *rq, dev_t *devp, int oflag, int sflag, cred_t *credp) 194 { 195 int rv; 196 audio_client_t *c; 197 198 if (sflag != 0) { 199 /* no direct clone or module opens */ 200 return (ENXIO); 201 } 202 203 /* 204 * Make sure its a STREAMS personality - only legacy Sun API uses 205 * STREAMS. 206 */ 207 switch (AUDIO_MN_TYPE_MASK & getminor(*devp)) { 208 case AUDIO_MINOR_DEVAUDIO: 209 case AUDIO_MINOR_DEVAUDIOCTL: 210 break; 211 default: 212 return (ENOSTR); 213 } 214 215 if ((c = auimpl_client_create(*devp)) == NULL) { 216 audio_dev_warn(NULL, "client create failed"); 217 return (ENXIO); 218 } 219 220 rq->q_ptr = WR(rq)->q_ptr = c; 221 c->c_omode = oflag; 222 c->c_pid = ddi_get_pid(); 223 c->c_cred = credp; 224 c->c_rq = rq; 225 c->c_wq = WR(rq); 226 227 /* 228 * Call client/personality specific open handler. Note that 229 * we "insist" that there is an open. The personality layer 230 * will initialize/allocate any engines required. 231 * 232 * Hmm... do we need to pass in the cred? 233 */ 234 if ((rv = c->c_open(c, oflag)) != 0) { 235 audio_dev_warn(c->c_dev, "open failed (rv %d)", rv); 236 auimpl_client_destroy(c); 237 return (rv); 238 } 239 240 /* we do device cloning! */ 241 *devp = makedevice(c->c_major, c->c_minor); 242 243 qprocson(rq); 244 245 /* now we can receive upcalls */ 246 auimpl_client_activate(c); 247 248 atomic_inc_uint(&c->c_dev->d_serial); 249 250 return (0); 251 } 252 253 static int 254 audio_strclose(queue_t *rq, int flag, cred_t *credp) 255 { 256 audio_client_t *c; 257 audio_dev_t *d; 258 int rv; 259 260 _NOTE(ARGUNUSED(flag)); 261 _NOTE(ARGUNUSED(credp)); 262 263 if ((c = rq->q_ptr) == NULL) { 264 return (ENXIO); 265 } 266 if (ddi_can_receive_sig() || (ddi_get_pid() == 0)) { 267 rv = auclnt_drain(c); 268 } 269 270 /* make sure we won't get any upcalls */ 271 auimpl_client_deactivate(c); 272 273 /* 274 * Pick up any data sitting around in input buffers. This 275 * avoids leaving record data stuck in queues. 276 */ 277 if (c->c_istream.s_engine != NULL) 278 auimpl_input_callback(c->c_istream.s_engine); 279 280 /* get a local hold on the device */ 281 d = c->c_dev; 282 auimpl_dev_hold(c->c_dev); 283 284 /* Turn off queue processing... */ 285 qprocsoff(rq); 286 287 /* Call personality specific close handler */ 288 c->c_close(c); 289 290 auimpl_client_destroy(c); 291 292 /* notify peers that a change has occurred */ 293 atomic_inc_uint(&d->d_serial); 294 295 /* now we can drop the release we had on the device */ 296 auimpl_dev_release(d); 297 298 return (rv); 299 } 300 301 static int 302 audio_close(dev_t dev, int flag, int otyp, cred_t *credp) 303 { 304 audio_client_t *c; 305 audio_dev_t *d; 306 307 _NOTE(ARGUNUSED(flag)); 308 _NOTE(ARGUNUSED(credp)); 309 _NOTE(ARGUNUSED(otyp)); 310 311 if ((c = auclnt_hold_by_devt(dev)) == NULL) { 312 audio_dev_warn(NULL, "close on bogus devt %x,%x", 313 getmajor(dev), getminor(dev)); 314 return (ENXIO); 315 } 316 317 /* we don't want any upcalls anymore */ 318 auimpl_client_deactivate(c); 319 320 /* 321 * Pick up any data sitting around in input buffers. This 322 * avoids leaving record data stuck in queues. 323 */ 324 if (c->c_istream.s_engine != NULL) 325 auimpl_input_callback(c->c_istream.s_engine); 326 327 /* get a local hold on the device */ 328 d = c->c_dev; 329 auimpl_dev_hold(c->c_dev); 330 331 /* 332 * NB: This must be done before c->c_close, since it calls 333 * auclnt_close which will block waiting for the refence count 334 * to drop to zero. 335 */ 336 auclnt_release(c); 337 338 /* Call personality specific close handler */ 339 c->c_close(c); 340 341 auimpl_client_destroy(c); 342 343 /* notify peers that a change has occurred */ 344 atomic_inc_uint(&d->d_serial); 345 346 /* now we can drop the release we had on the device */ 347 auimpl_dev_release(d); 348 349 return (0); 350 } 351 352 static int 353 audio_write(dev_t dev, struct uio *uio, cred_t *credp) 354 { 355 audio_client_t *c; 356 int rv; 357 358 if ((c = auclnt_hold_by_devt(dev)) == NULL) { 359 return (ENXIO); 360 } 361 if ((rv = auclnt_serialize(c)) == 0) { 362 rv = (c->c_write == NULL) ? ENXIO : c->c_write(c, uio, credp); 363 auclnt_unserialize(c); 364 } 365 auclnt_release(c); 366 367 return (rv); 368 } 369 370 static int 371 audio_read(dev_t dev, struct uio *uio, cred_t *credp) 372 { 373 audio_client_t *c; 374 int rv; 375 376 if ((c = auclnt_hold_by_devt(dev)) == NULL) { 377 return (ENXIO); 378 } 379 if ((rv = auclnt_serialize(c)) == 0) { 380 rv = (c->c_read == NULL) ? ENXIO : c->c_read(c, uio, credp); 381 auclnt_unserialize(c); 382 } 383 auclnt_release(c); 384 385 return (rv); 386 } 387 388 static int 389 audio_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp, 390 int *rvalp) 391 { 392 audio_client_t *c; 393 int rv; 394 395 if ((c = auclnt_hold_by_devt(dev)) == NULL) { 396 return (ENXIO); 397 } 398 rv = (c->c_ioctl == NULL) ? ENXIO : c->c_ioctl(c, cmd, arg, mode, 399 credp, rvalp); 400 auclnt_release(c); 401 402 return (rv); 403 } 404 405 static int 406 audio_chpoll(dev_t dev, short events, int anyyet, short *reventsp, 407 struct pollhead **phpp) 408 { 409 audio_client_t *c; 410 int rv; 411 412 if ((c = auclnt_hold_by_devt(dev)) == NULL) { 413 return (ENXIO); 414 } 415 rv = (c->c_chpoll == NULL) ? 416 ENXIO : 417 c->c_chpoll(c, events, anyyet, reventsp, phpp); 418 auclnt_release(c); 419 420 return (rv); 421 } 422 423 static int 424 audio_wput(queue_t *wq, mblk_t *mp) 425 { 426 audio_client_t *c; 427 428 c = wq->q_ptr; 429 if (c->c_wput) { 430 c->c_wput(c, mp); 431 } else { 432 freemsg(mp); 433 } 434 return (0); 435 } 436 437 static int 438 audio_wsrv(queue_t *wq) 439 { 440 audio_client_t *c; 441 442 c = wq->q_ptr; 443 if (c->c_wsrv) { 444 c->c_wsrv(c); 445 } else { 446 flushq(wq, FLUSHALL); 447 } 448 return (0); 449 } 450 451 static int 452 audio_rsrv(queue_t *rq) 453 { 454 audio_client_t *c; 455 456 c = rq->q_ptr; 457 if (c->c_rsrv) { 458 c->c_rsrv(c); 459 } else { 460 flushq(rq, FLUSHALL); 461 } 462 return (0); 463 } 464 465 466 static struct dev_ops audio_dev_ops = { 467 DEVO_REV, /* rev */ 468 0, /* refcnt */ 469 NULL, /* getinfo */ 470 nulldev, /* identify */ 471 nulldev, /* probe */ 472 audio_attach, /* attach */ 473 audio_detach, /* detach */ 474 nodev, /* reset */ 475 NULL, /* cb_ops */ 476 NULL, /* bus_ops */ 477 NULL, /* power */ 478 }; 479 480 static struct modldrv modldrv = { 481 &mod_driverops, 482 "Audio Framework", 483 &audio_dev_ops, 484 }; 485 486 static struct modlinkage modlinkage = { 487 MODREV_1, /* MODREV_1 indicated by manual */ 488 &modldrv, 489 NULL 490 }; 491 492 struct audio_ops_helper { 493 struct cb_ops cbops; /* NB: must be first */ 494 struct streamtab strtab; 495 struct qinit rqinit; 496 struct qinit wqinit; 497 struct module_info minfo; 498 char name[MODMAXNAMELEN+1]; 499 }; 500 501 void 502 audio_init_ops(struct dev_ops *devops, const char *name) 503 { 504 struct audio_ops_helper *helper; 505 506 helper = kmem_zalloc(sizeof (*helper), KM_SLEEP); 507 508 (void) strlcpy(helper->name, name, sizeof (helper->name)); 509 510 helper->minfo.mi_idnum = 0; /* only for strlog(1M) */ 511 helper->minfo.mi_idname = helper->name; 512 helper->minfo.mi_minpsz = 0; 513 helper->minfo.mi_maxpsz = 8192; 514 helper->minfo.mi_hiwat = 65536; 515 helper->minfo.mi_lowat = 32768; 516 517 helper->wqinit.qi_putp = audio_wput; 518 helper->wqinit.qi_srvp = audio_wsrv; 519 helper->wqinit.qi_qopen = NULL; 520 helper->wqinit.qi_qclose = NULL; 521 helper->wqinit.qi_qadmin = NULL; 522 helper->wqinit.qi_minfo = &helper->minfo; 523 helper->wqinit.qi_mstat = NULL; 524 525 helper->rqinit.qi_putp = putq; 526 helper->rqinit.qi_srvp = audio_rsrv; 527 helper->rqinit.qi_qopen = audio_stropen; 528 helper->rqinit.qi_qclose = audio_strclose; 529 helper->rqinit.qi_qadmin = NULL; 530 helper->rqinit.qi_minfo = &helper->minfo; 531 helper->rqinit.qi_mstat = NULL; 532 533 helper->strtab.st_rdinit = &helper->rqinit; 534 helper->strtab.st_wrinit = &helper->wqinit; 535 helper->strtab.st_muxrinit = NULL; 536 helper->strtab.st_muxwinit = NULL; 537 538 helper->cbops.cb_open = audio_open; 539 helper->cbops.cb_close = audio_close; 540 helper->cbops.cb_strategy = nodev; 541 helper->cbops.cb_print = nodev; 542 helper->cbops.cb_dump = nodev; 543 helper->cbops.cb_read = audio_read; 544 helper->cbops.cb_write = audio_write; 545 helper->cbops.cb_ioctl = audio_ioctl; 546 helper->cbops.cb_devmap = nodev; 547 helper->cbops.cb_mmap = nodev; 548 helper->cbops.cb_segmap = nodev; 549 helper->cbops.cb_chpoll = audio_chpoll; 550 helper->cbops.cb_prop_op = ddi_prop_op; 551 helper->cbops.cb_str = &helper->strtab; 552 helper->cbops.cb_flag = D_MP | D_64BIT; 553 helper->cbops.cb_rev = CB_REV; 554 helper->cbops.cb_aread = nodev; 555 helper->cbops.cb_awrite = nodev; 556 557 devops->devo_cb_ops = &helper->cbops; 558 devops->devo_getinfo = audio_getinfo; 559 } 560 561 void 562 audio_fini_ops(struct dev_ops *devops) 563 { 564 kmem_free(devops->devo_cb_ops, sizeof (struct audio_ops_helper)); 565 devops->devo_cb_ops = NULL; 566 devops->devo_getinfo = NULL; 567 } 568 569 void 570 auimpl_dev_vwarn(audio_dev_t *dev, const char *fmt, va_list va) 571 { 572 char buf[256]; 573 574 if (dev != NULL) { 575 (void) snprintf(buf, sizeof (buf), "%s#%d: %s", 576 ddi_driver_name(dev->d_dip), ddi_get_instance(dev->d_dip), 577 fmt); 578 } else { 579 (void) snprintf(buf, sizeof (buf), "audio: %s", fmt); 580 } 581 582 vcmn_err(CE_WARN, buf, va); 583 } 584 585 586 void 587 audio_dev_warn(audio_dev_t *dev, const char *fmt, ...) 588 { 589 va_list va; 590 591 va_start(va, fmt); 592 auimpl_dev_vwarn(dev, fmt, va); 593 va_end(va); 594 } 595 596 /* 597 * _init, _info, and _fini DDI glue. 598 */ 599 int 600 _init(void) 601 { 602 int rv; 603 604 auimpl_client_init(); 605 auimpl_dev_init(); 606 auimpl_sun_init(); 607 auimpl_oss_init(); 608 609 audio_init_ops(&audio_dev_ops, "audio"); 610 611 if ((rv = mod_install(&modlinkage)) != 0) { 612 audio_fini_ops(&audio_dev_ops); 613 auimpl_dev_fini(); 614 auimpl_client_fini(); 615 } 616 return (rv); 617 } 618 619 int 620 _info(struct modinfo *modinfop) 621 { 622 return (mod_info(&modlinkage, modinfop)); 623 } 624 625 int 626 _fini(void) 627 { 628 int rv; 629 630 if ((rv = mod_remove(&modlinkage)) != 0) 631 return (rv); 632 633 auimpl_dev_fini(); 634 auimpl_client_fini(); 635 636 return (rv); 637 } 638