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 /* 23 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 28 /* 29 * SMP - Serial Management Protocol Device Driver 30 * 31 * The SMP driver provides user programs access to SAS Serial Management 32 * Protocol devices by providing ioctl interface. 33 */ 34 35 #include <sys/modctl.h> 36 #include <sys/file.h> 37 #include <sys/scsi/scsi.h> 38 #include <sys/scsi/targets/smp.h> 39 #include <sys/sdt.h> 40 41 /* 42 * Standard entrypoints 43 */ 44 static int smp_attach(dev_info_t *, ddi_attach_cmd_t); 45 static int smp_detach(dev_info_t *, ddi_detach_cmd_t); 46 static int smp_open(dev_t *, int, int, cred_t *); 47 static int smp_close(dev_t, int, int, cred_t *); 48 static int smp_ioctl(dev_t, int, intptr_t, int, cred_t *, int *); 49 50 /* 51 * Configuration routines 52 */ 53 static int smp_do_attach(dev_info_t *); 54 static int smp_do_detach(dev_info_t *); 55 56 /* 57 * Command handle routing 58 */ 59 static int smp_handle_func(dev_t, intptr_t, int, cred_t *, int *); 60 61 /* 62 * Logging/debugging routines 63 */ 64 static void smp_log(smp_state_t *, int, const char *, ...); 65 66 int smp_retry_times = SMP_DEFAULT_RETRY_TIMES; 67 int smp_retry_delay = 10000; /* 10msec */ 68 int smp_delay_cmd = 1; /* 1usec */ 69 int smp_single_command = 1; /* one command at a time */ 70 71 static int smp_retry_recovered = 0; /* retry recovery counter */ 72 static int smp_retry_failed = 0; /* retry failed counter */ 73 static int smp_failed = 0; 74 75 static struct cb_ops smp_cb_ops = { 76 smp_open, /* open */ 77 smp_close, /* close */ 78 nodev, /* strategy */ 79 nodev, /* print */ 80 nodev, /* dump */ 81 nodev, /* read */ 82 nodev, /* write */ 83 smp_ioctl, /* ioctl */ 84 nodev, /* devmap */ 85 nodev, /* mmap */ 86 nodev, /* segmap */ 87 nochpoll, /* poll */ 88 ddi_prop_op, /* cb_prop_op */ 89 0, /* streamtab */ 90 D_MP | D_NEW | D_HOTPLUG /* Driver compatibility flag */ 91 }; 92 93 static struct dev_ops smp_dev_ops = { 94 DEVO_REV, /* devo_rev, */ 95 0, /* refcnt */ 96 ddi_getinfo_1to1, /* info */ 97 nulldev, /* identify */ 98 NULL, /* probe */ 99 smp_attach, /* attach */ 100 smp_detach, /* detach */ 101 nodev, /* reset */ 102 &smp_cb_ops, /* driver operations */ 103 (struct bus_ops *)0, /* bus operations */ 104 NULL, /* power */ 105 ddi_quiesce_not_needed, /* quiesce */ 106 }; 107 108 static void *smp_soft_state = NULL; 109 110 static struct modldrv modldrv = { 111 &mod_driverops, "smp device driver", &smp_dev_ops 112 }; 113 114 static struct modlinkage modlinkage = { 115 MODREV_1, &modldrv, NULL 116 }; 117 118 int 119 _init(void) 120 { 121 int err; 122 123 if ((err = ddi_soft_state_init(&smp_soft_state, 124 sizeof (smp_state_t), SMP_ESTIMATED_NUM_DEVS)) != 0) { 125 return (err); 126 } 127 128 if ((err = mod_install(&modlinkage)) != 0) { 129 ddi_soft_state_fini(&smp_soft_state); 130 } 131 132 return (err); 133 } 134 135 int 136 _fini(void) 137 { 138 int err; 139 140 if ((err = mod_remove(&modlinkage)) == 0) { 141 ddi_soft_state_fini(&smp_soft_state); 142 } 143 144 return (err); 145 } 146 147 int 148 _info(struct modinfo *modinfop) 149 { 150 return (mod_info(&modlinkage, modinfop)); 151 } 152 153 /* 154 * smp_attach() 155 * attach(9e) entrypoint. 156 */ 157 static int 158 smp_attach(dev_info_t *dip, ddi_attach_cmd_t cmd) 159 { 160 int err; 161 162 switch (cmd) { 163 case DDI_ATTACH: 164 err = smp_do_attach(dip); 165 break; 166 case DDI_RESUME: 167 err = DDI_SUCCESS; 168 break; 169 default: 170 err = DDI_FAILURE; 171 break; 172 } 173 174 if (err != DDI_SUCCESS) { 175 smp_log(NULL, CE_NOTE, "!smp_attach(), " 176 "device unit-address @%s failed", 177 ddi_get_name_addr(dip)); 178 } 179 return (err); 180 } 181 182 /* 183 * smp_do_attach() 184 * handle the nitty details of attach. 185 */ 186 static int 187 smp_do_attach(dev_info_t *dip) 188 { 189 int instance; 190 struct smp_device *smp_sd; 191 uchar_t *srmir = NULL; 192 uint_t srmirlen = 0; 193 ddi_devid_t devid = NULL; 194 smp_state_t *smp_state; 195 196 instance = ddi_get_instance(dip); 197 smp_sd = ddi_get_driver_private(dip); 198 ASSERT(smp_sd != NULL); 199 200 DTRACE_PROBE2(smp__attach__detach, int, instance, char *, 201 ddi_get_name_addr(dip)); 202 203 /* make sure device is there, and establish srmir identity property */ 204 if (smp_probe(smp_sd) != DDI_PROBE_SUCCESS) { 205 smp_log(NULL, CE_NOTE, 206 "!smp_do_attach: failed smp_probe, " 207 "device unit-address @%s", ddi_get_name_addr(dip)); 208 return (DDI_FAILURE); 209 } 210 211 /* if we have not already registered a devid, then do so now */ 212 if (ddi_devid_get(dip, &devid) != DDI_SUCCESS) { 213 /* get the srmir identity information for use in devid */ 214 (void) ddi_prop_lookup_byte_array(DDI_DEV_T_ANY, dip, 215 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, 216 SMP_PROP_REPORT_MANUFACTURER, &srmir, &srmirlen); 217 218 /* Convert smp unit-address and srmir into devid */ 219 if (ddi_devid_smp_encode(DEVID_SMP_ENCODE_VERSION_LATEST, 220 (char *)ddi_driver_name(dip), ddi_get_name_addr(dip), 221 srmir, srmirlen, &devid) == DDI_SUCCESS) { 222 /* register the devid */ 223 (void) ddi_devid_register(dip, devid); 224 } 225 ddi_prop_free(srmir); 226 } 227 228 /* We don't need the devid for our own operation, so free now. */ 229 if (devid) 230 ddi_devid_free(devid); 231 232 /* we are now done with srmir identity property defined by smp_probe */ 233 (void) ndi_prop_remove(DDI_DEV_T_NONE, 234 dip, SMP_PROP_REPORT_MANUFACTURER); 235 236 if (ddi_soft_state_zalloc(smp_soft_state, instance) != DDI_SUCCESS) { 237 smp_log(NULL, CE_NOTE, 238 "!smp_do_attach: failed to allocate softstate, " 239 "device unit-address @%s", ddi_get_name_addr(dip)); 240 return (DDI_FAILURE); 241 } 242 243 smp_state = ddi_get_soft_state(smp_soft_state, instance); 244 smp_state->smp_sd = smp_sd; 245 246 /* 247 * For simplicity, the minor number == the instance number 248 */ 249 if (ddi_create_minor_node(dip, "smp", S_IFCHR, 250 instance, DDI_NT_SMP, 0) == DDI_FAILURE) { 251 smp_log(smp_state, CE_NOTE, 252 "!smp_do_attach: minor node creation failed, " 253 "device unit-address @%s", ddi_get_name_addr(dip)); 254 ddi_soft_state_free(smp_soft_state, instance); 255 return (DDI_FAILURE); 256 } 257 258 mutex_init(&smp_state->smp_mutex, NULL, MUTEX_DRIVER, NULL); 259 smp_state->smp_open_flag = SMP_CLOSED; 260 261 ddi_report_dev(dip); 262 return (DDI_SUCCESS); 263 } 264 265 /* 266 * smp_detach() 267 * detach(9E) entrypoint 268 */ 269 static int 270 smp_detach(dev_info_t *dip, ddi_detach_cmd_t cmd) 271 { 272 int instance; 273 smp_state_t *smp_state; 274 275 instance = ddi_get_instance(dip); 276 smp_state = ddi_get_soft_state(smp_soft_state, instance); 277 278 if (smp_state == NULL) { 279 smp_log(NULL, CE_NOTE, 280 "!smp_detach: failed, no softstate found (%d), " 281 "device unit-address @%s", 282 instance, ddi_get_name_addr(dip)); 283 return (DDI_FAILURE); 284 } 285 286 switch (cmd) { 287 case DDI_DETACH: 288 return (smp_do_detach(dip)); 289 case DDI_SUSPEND: 290 return (DDI_SUCCESS); 291 default: 292 return (DDI_FAILURE); 293 } 294 } 295 296 /* 297 * smp_do_detach() 298 * detach the driver, tearing down resources. 299 */ 300 static int 301 smp_do_detach(dev_info_t *dip) 302 { 303 int instance; 304 smp_state_t *smp_state; 305 306 instance = ddi_get_instance(dip); 307 smp_state = ddi_get_soft_state(smp_soft_state, instance); 308 309 DTRACE_PROBE2(smp__attach__detach, int, instance, char *, 310 ddi_get_name_addr(dip)); 311 312 mutex_destroy(&smp_state->smp_mutex); 313 ddi_soft_state_free(smp_soft_state, instance); 314 ddi_remove_minor_node(dip, NULL); 315 return (DDI_SUCCESS); 316 } 317 318 /*ARGSUSED*/ 319 static int 320 smp_open(dev_t *dev_p, int flag, int otyp, cred_t *cred_p) 321 { 322 smp_state_t *smp_state; 323 int instance; 324 int rv = 0; 325 326 instance = getminor(*dev_p); 327 if ((smp_state = ddi_get_soft_state(smp_soft_state, instance)) 328 == NULL) { 329 return (ENXIO); 330 } 331 332 mutex_enter(&smp_state->smp_mutex); 333 if (flag & FEXCL) { 334 if (smp_state->smp_open_flag != SMP_CLOSED) { 335 rv = EBUSY; 336 } else { 337 smp_state->smp_open_flag = SMP_EXOPENED; 338 } 339 } else { 340 if (smp_state->smp_open_flag == SMP_EXOPENED) { 341 rv = EBUSY; 342 } else { 343 smp_state->smp_open_flag = SMP_SOPENED; 344 } 345 } 346 mutex_exit(&smp_state->smp_mutex); 347 348 return (rv); 349 } 350 351 /*ARGSUSED*/ 352 static int 353 smp_close(dev_t dev, int flag, int otyp, cred_t *cred_p) 354 { 355 smp_state_t *smp_state; 356 int instance; 357 int rv = 0; 358 359 instance = getminor(dev); 360 if ((smp_state = ddi_get_soft_state(smp_soft_state, instance)) 361 == NULL) { 362 return (ENXIO); 363 } 364 365 mutex_enter(&smp_state->smp_mutex); 366 if (smp_state->smp_open_flag == SMP_CLOSED) { 367 smp_log(smp_state, CE_NOTE, "!smp device is already in close"); 368 } else { 369 smp_state->smp_open_flag = SMP_CLOSED; 370 } 371 mutex_exit(&smp_state->smp_mutex); 372 return (rv); 373 } 374 375 /*ARGSUSED*/ 376 static int 377 smp_handle_func(dev_t dev, 378 intptr_t arg, int flag, cred_t *cred_p, int *rval_p) 379 { 380 usmp_cmd_t usmp_cmd_data, *usmp_cmd = &usmp_cmd_data; 381 smp_pkt_t smp_pkt_data, *smp_pkt = &smp_pkt_data; 382 smp_state_t *smp_state; 383 int instance, retrycount; 384 cred_t *cr; 385 uint64_t cmd_flags = 0; 386 int rval = 0; 387 388 #ifdef _MULTI_DATAMODEL 389 usmp_cmd32_t usmp_cmd32_data, *usmp_cmd32 = &usmp_cmd32_data; 390 #endif 391 392 /* require PRIV_SYS_DEVICES privilege */ 393 cr = ddi_get_cred(); 394 if ((drv_priv(cred_p) != 0) && (drv_priv(cr) != 0)) { 395 return (EPERM); 396 } 397 398 bzero(smp_pkt, sizeof (smp_pkt_t)); 399 400 instance = getminor(dev); 401 if ((smp_state = ddi_get_soft_state(smp_soft_state, instance)) 402 == NULL) { 403 return (ENXIO); 404 } 405 406 #ifdef _MULTI_DATAMODEL 407 switch (ddi_model_convert_from(flag & FMODELS)) { 408 case DDI_MODEL_ILP32: 409 if (ddi_copyin((void *)arg, usmp_cmd32, sizeof (usmp_cmd32_t), 410 flag)) { 411 return (EFAULT); 412 } 413 414 usmp_cmd32tousmp_cmd(usmp_cmd32, usmp_cmd); 415 break; 416 case DDI_MODEL_NONE: 417 if (ddi_copyin((void *)arg, usmp_cmd, sizeof (usmp_cmd_t), 418 flag)) { 419 return (EFAULT); 420 } 421 break; 422 } 423 #else /* ! _MULTI_DATAMODEL */ 424 if (ddi_copyin((void *)arg, usmp_cmd, sizeof (usmp_cmd_t), flag)) { 425 return (EFAULT); 426 } 427 #endif /* _MULTI_DATAMODEL */ 428 429 if ((usmp_cmd->usmp_reqsize < SMP_MIN_REQUEST_SIZE) || 430 (usmp_cmd->usmp_reqsize > SMP_MAX_REQUEST_SIZE) || 431 (usmp_cmd->usmp_rspsize < SMP_MIN_RESPONSE_SIZE) || 432 (usmp_cmd->usmp_rspsize > SMP_MAX_RESPONSE_SIZE)) { 433 rval = EINVAL; 434 goto done; 435 } 436 437 smp_pkt->smp_pkt_reqsize = usmp_cmd->usmp_reqsize; 438 smp_pkt->smp_pkt_rspsize = usmp_cmd->usmp_rspsize; 439 440 /* allocate memory space for smp request and response frame in kernel */ 441 smp_pkt->smp_pkt_req = kmem_zalloc((size_t)usmp_cmd->usmp_reqsize, 442 KM_SLEEP); 443 cmd_flags |= SMP_FLAG_REQBUF; 444 445 smp_pkt->smp_pkt_rsp = kmem_zalloc((size_t)usmp_cmd->usmp_rspsize, 446 KM_SLEEP); 447 cmd_flags |= SMP_FLAG_RSPBUF; 448 449 /* copy smp request frame to kernel space */ 450 if (ddi_copyin(usmp_cmd->usmp_req, smp_pkt->smp_pkt_req, 451 (size_t)usmp_cmd->usmp_reqsize, flag) != 0) { 452 rval = EFAULT; 453 goto done; 454 } 455 456 DTRACE_PROBE1(smp__transport__start, caddr_t, smp_pkt->smp_pkt_req); 457 458 smp_pkt->smp_pkt_address = &smp_state->smp_sd->smp_sd_address; 459 if (usmp_cmd->usmp_timeout <= 0) { 460 smp_pkt->smp_pkt_timeout = SMP_DEFAULT_TIMEOUT; 461 } else { 462 smp_pkt->smp_pkt_timeout = usmp_cmd->usmp_timeout; 463 } 464 465 /* call smp_transport entry and send smp_pkt to HBA driver */ 466 cmd_flags |= SMP_FLAG_XFER; 467 for (retrycount = 0; retrycount <= smp_retry_times; retrycount++) { 468 469 /* 470 * To improve transport reliability, only allow one command 471 * outstanding at a time in smp_transport(). 472 * 473 * NOTE: Some expanders have issues with heavy smp load. 474 */ 475 if (smp_single_command) { 476 mutex_enter(&smp_state->smp_mutex); 477 while (smp_state->smp_busy) 478 cv_wait(&smp_state->smp_cv, 479 &smp_state->smp_mutex); 480 smp_state->smp_busy = 1; 481 mutex_exit(&smp_state->smp_mutex); 482 } 483 484 /* Let the transport know if more retries are possible. */ 485 smp_pkt->smp_pkt_will_retry = 486 (retrycount < smp_retry_times) ? 1 : 0; 487 488 smp_pkt->smp_pkt_reason = 0; 489 rval = smp_transport(smp_pkt); /* put on the wire */ 490 491 if (smp_delay_cmd) 492 delay(drv_usectohz(smp_delay_cmd)); 493 494 if (smp_single_command) { 495 mutex_enter(&smp_state->smp_mutex); 496 smp_state->smp_busy = 0; 497 cv_signal(&smp_state->smp_cv); 498 mutex_exit(&smp_state->smp_mutex); 499 } 500 501 if (rval == DDI_SUCCESS) { 502 if (retrycount) 503 smp_retry_recovered++; 504 rval = 0; 505 break; 506 } 507 508 switch (smp_pkt->smp_pkt_reason) { 509 case EAGAIN: 510 if (retrycount < smp_retry_times) { 511 bzero(smp_pkt->smp_pkt_rsp, 512 (size_t)usmp_cmd->usmp_rspsize); 513 if (smp_retry_delay) 514 delay(drv_usectohz(smp_retry_delay)); 515 continue; 516 } else { 517 smp_retry_failed++; 518 smp_log(smp_state, CE_NOTE, 519 "!smp_transport failed, smp_pkt_reason %d", 520 smp_pkt->smp_pkt_reason); 521 rval = smp_pkt->smp_pkt_reason; 522 goto copyout; 523 } 524 default: 525 smp_log(smp_state, CE_NOTE, 526 "!smp_transport failed, smp_pkt_reason %d", 527 smp_pkt->smp_pkt_reason); 528 rval = smp_pkt->smp_pkt_reason; 529 goto copyout; 530 } 531 } 532 533 copyout: 534 /* copy out smp response to user process */ 535 if (ddi_copyout(smp_pkt->smp_pkt_rsp, usmp_cmd->usmp_rsp, 536 (size_t)usmp_cmd->usmp_rspsize, flag) != 0) { 537 rval = EFAULT; 538 } 539 540 done: 541 if ((cmd_flags & SMP_FLAG_XFER) != 0) { 542 DTRACE_PROBE2(smp__transport__done, caddr_t, 543 smp_pkt->smp_pkt_rsp, uchar_t, smp_pkt->smp_pkt_reason); 544 } 545 if ((cmd_flags & SMP_FLAG_REQBUF) != 0) { 546 kmem_free(smp_pkt->smp_pkt_req, smp_pkt->smp_pkt_reqsize); 547 } 548 if ((cmd_flags & SMP_FLAG_RSPBUF) != 0) { 549 kmem_free(smp_pkt->smp_pkt_rsp, smp_pkt->smp_pkt_rspsize); 550 } 551 552 if (rval) 553 smp_failed++; 554 return (rval); 555 } 556 557 /*ARGSUSED*/ 558 static int 559 smp_ioctl(dev_t dev, 560 int cmd, intptr_t arg, int flag, cred_t *cred_p, int *rval_p) 561 { 562 int rval = 0; 563 564 switch (cmd) { 565 case USMPFUNC: 566 /* 567 * The response payload is valid only if return value is 0 568 * or EOVERFLOW. 569 */ 570 rval = smp_handle_func(dev, arg, flag, cred_p, rval_p); 571 break; 572 default: 573 rval = EINVAL; 574 } 575 return (rval); 576 } 577 578 static void 579 smp_log(smp_state_t *smp_state, int level, const char *fmt, ...) 580 { 581 va_list ap; 582 char buf[256]; 583 dev_info_t *dip; 584 585 if (smp_state == (smp_state_t *)NULL) { 586 dip = NULL; 587 } else { 588 dip = smp_state->smp_sd->smp_sd_dev; 589 } 590 591 va_start(ap, fmt); 592 (void) vsnprintf(buf, sizeof (buf), fmt, ap); 593 va_end(ap); 594 595 scsi_log(dip, "smp", level, "%s", buf); 596 } 597