1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright (c) 2010 Spectra Logic Corporation 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions, and the following disclaimer, 12 * without modification. 13 * 2. Redistributions in binary form must reproduce at minimum a disclaimer 14 * substantially similar to the "NO WARRANTY" disclaimer below 15 * ("Disclaimer") and any redistribution must be conditioned upon 16 * including a substantially similar Disclaimer requirement for further 17 * binary redistribution. 18 * 19 * NO WARRANTY 20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 21 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR 23 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 24 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 28 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 29 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 30 * POSSIBILITY OF SUCH DAMAGES. 31 * 32 * $Id: //depot/users/kenm/FreeBSD-test/sys/cam/scsi/smp_all.c#4 $ 33 */ 34 35 /* 36 * Serial Management Protocol helper functions. 37 */ 38 39 #include <sys/cdefs.h> 40 __FBSDID("$FreeBSD$"); 41 42 #include <sys/param.h> 43 #include <sys/types.h> 44 #ifdef _KERNEL 45 #include <sys/systm.h> 46 #include <sys/libkern.h> 47 #include <sys/kernel.h> 48 #else /* _KERNEL */ 49 #include <errno.h> 50 #include <stdio.h> 51 #include <stdlib.h> 52 #include <string.h> 53 #include <inttypes.h> 54 #endif /* _KERNEL */ 55 56 #include <cam/cam.h> 57 #include <cam/cam_ccb.h> 58 #include <cam/cam_xpt.h> 59 #include <cam/scsi/smp_all.h> 60 #include <sys/sbuf.h> 61 62 #ifndef _KERNEL 63 #include <camlib.h> 64 #endif 65 66 static char *smp_yesno(int val); 67 68 static char * 69 smp_yesno(int val) 70 { 71 char *str; 72 73 if (val) 74 str = "Yes"; 75 else 76 str = "No"; 77 78 return (str); 79 } 80 81 struct smp_error_table_entry { 82 uint8_t function_result; 83 const char *desc; 84 }; 85 86 /* List current as of SPL Revision 7 */ 87 static struct smp_error_table_entry smp_error_table[] = { 88 {SMP_FR_ACCEPTED, "SMP Function Accepted"}, 89 {SMP_FR_UNKNOWN_FUNC, "Unknown SMP Function"}, 90 {SMP_FR_FUNCTION_FAILED, "SMP Function Failed"}, 91 {SMP_FR_INVALID_REQ_FRAME_LEN, "Invalid Request Frame Length"}, 92 {SMP_FR_INVALID_EXP_CHG_CNT, "Invalid Expander Change Count"}, 93 {SMP_FR_BUSY, "Busy"}, 94 {SMP_FR_INCOMPLETE_DESC_LIST, "Incomplete Descriptor List"}, 95 {SMP_FR_PHY_DOES_NOT_EXIST, "Phy Does Not Exist"}, 96 {SMP_FR_INDEX_DOES_NOT_EXIST, "Index Does Not Exist"}, 97 {SMP_FR_PHY_DOES_NOT_SUP_SATA, "Phy Does Not Support SATA"}, 98 {SMP_FR_UNKNOWN_PHY_OP, "Unknown Phy Operation"}, 99 {SMP_FR_UNKNOWN_PHY_TEST_FUNC, "Unknown Phy Test Function"}, 100 {SMP_FR_PHY_TEST_FUNC_INPROG, "Phy Test Function In Progress"}, 101 {SMP_FR_PHY_VACANT, "Phy Vacant"}, 102 {SMP_FR_UNKNOWN_PHY_EVENT_SRC, "Unknown Phy Event Source"}, 103 {SMP_FR_UNKNOWN_DESC_TYPE, "Unknown Descriptor Type"}, 104 {SMP_FR_UNKNOWN_PHY_FILTER, "Unknown Phy Filter"}, 105 {SMP_FR_AFFILIATION_VIOLATION, "Affiliation Violation"}, 106 {SMP_FR_SMP_ZONE_VIOLATION, "SMP Zone Violation"}, 107 {SMP_FR_NO_MGMT_ACCESS_RIGHTS, "No Management Access Rights"}, 108 {SMP_FR_UNKNOWN_ED_ZONING_VAL, "Unknown Enable Disable Zoning Value"}, 109 {SMP_FR_ZONE_LOCK_VIOLATION, "Zone Lock Violation"}, 110 {SMP_FR_NOT_ACTIVATED, "Not Activated"}, 111 {SMP_FR_ZG_OUT_OF_RANGE, "Zone Group Out of Range"}, 112 {SMP_FR_NO_PHYS_PRESENCE, "No Physical Presence"}, 113 {SMP_FR_SAVING_NOT_SUP, "Saving Not Supported"}, 114 {SMP_FR_SRC_ZONE_DNE, "Source Zone Group Does Not Exist"}, 115 {SMP_FR_DISABLED_PWD_NOT_SUP, "Disabled Password Not Supported"} 116 }; 117 118 const char * 119 smp_error_desc(int function_result) 120 { 121 int i; 122 123 for (i = 0; i < nitems(smp_error_table); i++){ 124 if (function_result == smp_error_table[i].function_result) 125 return (smp_error_table[i].desc); 126 } 127 return ("Reserved Function Result"); 128 } 129 130 /* List current as of SPL Revision 7 */ 131 struct smp_cmd_table_entry { 132 uint8_t cmd_num; 133 const char *desc; 134 } smp_cmd_table[] = { 135 {SMP_FUNC_REPORT_GENERAL, "REPORT GENERAL"}, 136 {SMP_FUNC_REPORT_MANUF_INFO, "REPORT MANUFACTURER INFORMATION"}, 137 {SMP_FUNC_REPORT_SC_STATUS, "REPORT SELF-CONFIGURATION STATUS"}, 138 {SMP_FUNC_REPORT_ZONE_PERM_TBL, "REPORT ZONE PERMISSION TABLE"}, 139 {SMP_FUNC_REPORT_BROADCAST, "REPORT BROADCAST"}, 140 {SMP_FUNC_DISCOVER, "DISCOVER"}, 141 {SMP_FUNC_REPORT_PHY_ERR_LOG, "REPORT PHY ERROR LOG"}, 142 {SMP_FUNC_REPORT_PHY_SATA, "REPORT PHY SATA"}, 143 {SMP_FUNC_REPORT_ROUTE_INFO, "REPORT ROUTE INFORMATION"}, 144 {SMP_FUNC_REPORT_PHY_EVENT, "REPORT PHY EVENT"}, 145 {SMP_FUNC_DISCOVER_LIST, "DISCOVER LIST"}, 146 {SMP_FUNC_REPORT_PHY_EVENT_LIST, "REPORT PHY EVENT LIST"}, 147 {SMP_FUNC_REPORT_EXP_RTL, "REPORT EXPANDER ROUTE TABLE LIST"}, 148 {SMP_FUNC_CONFIG_GENERAL, "CONFIGURE GENERAL"}, 149 {SMP_FUNC_ENABLE_DISABLE_ZONING, "ENABLE DISABLE ZONING"}, 150 {SMP_FUNC_ZONED_BROADCAST, "ZONED BROADCAST"}, 151 {SMP_FUNC_ZONE_LOCK, "ZONE LOCK"}, 152 {SMP_FUNC_ZONE_ACTIVATE, "ZONE ACTIVATE"}, 153 {SMP_FUNC_ZONE_UNLOCK, "ZONE UNLOCK"}, 154 {SMP_FUNC_CONFIG_ZM_PWD, "CONFIGURE ZONE MANAGER PASSWORD"}, 155 {SMP_FUNC_CONFIG_ZONE_PHY_INFO, "CONFIGURE ZONE PHY INFORMATION"}, 156 {SMP_FUNC_CONFIG_ZONE_PERM_TBL, "CONFIGURE ZONE PERMISSION TABLE"}, 157 {SMP_FUNC_CONFIG_ROUTE_INFO, "CONFIGURE ROUTE INFORMATION"}, 158 {SMP_FUNC_PHY_CONTROL, "PHY CONTROL"}, 159 {SMP_FUNC_PHY_TEST_FUNC, "PHY TEST FUNCTION"}, 160 {SMP_FUNC_CONFIG_PHY_EVENT, "CONFIGURE PHY EVENT"} 161 }; 162 163 const char * 164 smp_command_desc(uint8_t cmd_num) 165 { 166 int i; 167 168 for (i = 0; i < nitems(smp_cmd_table) && 169 smp_cmd_table[i].cmd_num <= cmd_num; i++) { 170 if (cmd_num == smp_cmd_table[i].cmd_num) 171 return (smp_cmd_table[i].desc); 172 } 173 174 /* 175 * 0x40 to 0x7f and 0xc0 to 0xff are the vendor specific SMP 176 * command ranges. 177 */ 178 if (((cmd_num >= 0x40) && (cmd_num <= 0x7f)) 179 || (cmd_num >= 0xc0)) { 180 return ("Vendor Specific SMP Command"); 181 } else { 182 return ("Unknown SMP Command"); 183 } 184 } 185 186 /* 187 * Decode a SMP request buffer into a string of hexadecimal numbers. 188 * 189 * smp_request: SMP request 190 * request_len: length of the SMP request buffer, may be reduced if the 191 * caller only wants part of the buffer printed 192 * sb: sbuf(9) buffer 193 * line_prefix: prefix for new lines, or an empty string ("") 194 * first_line_len: length left on first line 195 * line_len: total length of subsequent lines, 0 for no additional lines 196 * if there are no additional lines, first line will get ... 197 * at the end if there is additional data 198 */ 199 void 200 smp_command_decode(uint8_t *smp_request, int request_len, struct sbuf *sb, 201 char *line_prefix, int first_line_len, int line_len) 202 { 203 int i, cur_len; 204 205 for (i = 0, cur_len = first_line_len; i < request_len; i++) { 206 /* 207 * Each byte takes 3 characters. As soon as we go less 208 * than 6 (meaning we have at least 3 and at most 5 209 * characters left), check to see whether the subsequent 210 * line length (line_len) is long enough to bother with. 211 * If the user set it to 0, or some other length that isn't 212 * enough to hold at least the prefix and one byte, put ... 213 * on the first line to indicate that there is more data 214 * and bail out. 215 */ 216 if ((cur_len < 6) 217 && (line_len < (strlen(line_prefix) + 3))) { 218 sbuf_printf(sb, "..."); 219 return; 220 } 221 if (cur_len < 3) { 222 sbuf_printf(sb, "\n%s", line_prefix); 223 cur_len = line_len - strlen(line_prefix); 224 } 225 sbuf_printf(sb, "%02x ", smp_request[i]); 226 cur_len = cur_len - 3; 227 } 228 } 229 230 void 231 smp_command_sbuf(struct ccb_smpio *smpio, struct sbuf *sb, 232 char *line_prefix, int first_line_len, int line_len) 233 { 234 sbuf_printf(sb, "%s. ", smp_command_desc(smpio->smp_request[1])); 235 236 /* 237 * Acccount for the command description and the period and space 238 * after the command description. 239 */ 240 first_line_len -= strlen(smp_command_desc(smpio->smp_request[1])) + 2; 241 242 smp_command_decode(smpio->smp_request, smpio->smp_request_len, sb, 243 line_prefix, first_line_len, line_len); 244 } 245 246 /* 247 * Print SMP error output. For userland commands, we need the cam_device 248 * structure so we can get the path information from the CCB. 249 */ 250 #ifdef _KERNEL 251 void 252 smp_error_sbuf(struct ccb_smpio *smpio, struct sbuf *sb) 253 #else /* !_KERNEL*/ 254 void 255 smp_error_sbuf(struct cam_device *device, struct ccb_smpio *smpio, 256 struct sbuf *sb) 257 #endif /* _KERNEL/!_KERNEL */ 258 { 259 char path_str[64]; 260 261 #ifdef _KERNEL 262 xpt_path_string(smpio->ccb_h.path, path_str, sizeof(path_str)); 263 #else 264 cam_path_string(device, path_str, sizeof(path_str)); 265 #endif 266 smp_command_sbuf(smpio, sb, path_str, 80 - strlen(path_str), 80); 267 sbuf_printf(sb, "\n"); 268 269 sbuf_cat(sb, path_str); 270 sbuf_printf(sb, "SMP Error: %s (0x%x)\n", 271 smp_error_desc(smpio->smp_response[2]), 272 smpio->smp_response[2]); 273 } 274 275 /* 276 * Decode the SMP REPORT GENERAL response. The format is current as of SPL 277 * Revision 7, but the parsing should be backward compatible for older 278 * versions of the spec. 279 */ 280 void 281 smp_report_general_sbuf(struct smp_report_general_response *response, 282 int response_len, struct sbuf *sb) 283 { 284 sbuf_printf(sb, "Report General\n"); 285 sbuf_printf(sb, "Response Length: %d words (%d bytes)\n", 286 response->response_len, 287 response->response_len * SMP_WORD_LEN); 288 sbuf_printf(sb, "Expander Change Count: %d\n", 289 scsi_2btoul(response->expander_change_count)); 290 sbuf_printf(sb, "Expander Route Indexes: %d\n", 291 scsi_2btoul(response->expander_route_indexes)); 292 sbuf_printf(sb, "Long Response: %s\n", 293 smp_yesno(response->long_response & 294 SMP_RG_LONG_RESPONSE)); 295 sbuf_printf(sb, "Number of Phys: %d\n", response->num_phys); 296 sbuf_printf(sb, "Table to Table Supported: %s\n", 297 smp_yesno(response->config_bits0 & 298 SMP_RG_TABLE_TO_TABLE_SUP)); 299 sbuf_printf(sb, "Zone Configuring: %s\n", 300 smp_yesno(response->config_bits0 & 301 SMP_RG_ZONE_CONFIGURING)); 302 sbuf_printf(sb, "Self Configuring: %s\n", 303 smp_yesno(response->config_bits0 & 304 SMP_RG_SELF_CONFIGURING)); 305 sbuf_printf(sb, "STP Continue AWT: %s\n", 306 smp_yesno(response->config_bits0 & 307 SMP_RG_STP_CONTINUE_AWT)); 308 sbuf_printf(sb, "Open Reject Retry Supported: %s\n", 309 smp_yesno(response->config_bits0 & 310 SMP_RG_OPEN_REJECT_RETRY_SUP)); 311 sbuf_printf(sb, "Configures Others: %s\n", 312 smp_yesno(response->config_bits0 & 313 SMP_RG_CONFIGURES_OTHERS)); 314 sbuf_printf(sb, "Configuring: %s\n", 315 smp_yesno(response->config_bits0 & 316 SMP_RG_CONFIGURING)); 317 sbuf_printf(sb, "Externally Configurable Route Table: %s\n", 318 smp_yesno(response->config_bits0 & 319 SMP_RG_CONFIGURING)); 320 sbuf_printf(sb, "Enclosure Logical Identifier: 0x%016jx\n", 321 (uintmax_t)scsi_8btou64(response->encl_logical_id)); 322 323 /* 324 * If the response->response_len is 0, then we don't have the 325 * extended information. Also, if the user didn't allocate enough 326 * space for the full request, don't try to parse it. 327 */ 328 if ((response->response_len == 0) 329 || (response_len < (sizeof(struct smp_report_general_response) - 330 sizeof(response->crc)))) 331 return; 332 333 sbuf_printf(sb, "STP Bus Inactivity Time Limit: %d\n", 334 scsi_2btoul(response->stp_bus_inact_time_limit)); 335 sbuf_printf(sb, "STP Maximum Connect Time Limit: %d\n", 336 scsi_2btoul(response->stp_max_conn_time_limit)); 337 sbuf_printf(sb, "STP SMP I_T Nexus Loss Time: %d\n", 338 scsi_2btoul(response->stp_smp_it_nexus_loss_time)); 339 340 sbuf_printf(sb, "Number of Zone Groups: %d\n", 341 (response->config_bits1 & SMP_RG_NUM_ZONE_GROUPS_MASK) >> 342 SMP_RG_NUM_ZONE_GROUPS_SHIFT); 343 sbuf_printf(sb, "Zone Locked: %s\n", 344 smp_yesno(response->config_bits1 & SMP_RG_ZONE_LOCKED)); 345 sbuf_printf(sb, "Physical Presence Supported: %s\n", 346 smp_yesno(response->config_bits1 & SMP_RG_PP_SUPPORTED)); 347 sbuf_printf(sb, "Physical Presence Asserted: %s\n", 348 smp_yesno(response->config_bits1 & SMP_RG_PP_ASSERTED)); 349 sbuf_printf(sb, "Zoning Supported: %s\n", 350 smp_yesno(response->config_bits1 & 351 SMP_RG_ZONING_SUPPORTED)); 352 sbuf_printf(sb, "Zoning Enabled: %s\n", 353 smp_yesno(response->config_bits1 & SMP_RG_ZONING_ENABLED)); 354 355 sbuf_printf(sb, "Saving: %s\n", 356 smp_yesno(response->config_bits2 & SMP_RG_SAVING)); 357 sbuf_printf(sb, "Saving Zone Manager Password Supported: %s\n", 358 smp_yesno(response->config_bits2 & 359 SMP_RG_SAVING_ZM_PWD_SUP)); 360 sbuf_printf(sb, "Saving Zone Phy Information Supported: %s\n", 361 smp_yesno(response->config_bits2 & 362 SMP_RG_SAVING_PHY_INFO_SUP)); 363 sbuf_printf(sb, "Saving Zone Permission Table Supported: %s\n", 364 smp_yesno(response->config_bits2 & 365 SMP_RG_SAVING_ZPERM_TAB_SUP)); 366 sbuf_printf(sb, "Saving Zoning Enabled Supported: %s\n", 367 smp_yesno(response->config_bits2 & 368 SMP_RG_SAVING_ZENABLED_SUP)); 369 370 sbuf_printf(sb, "Maximum Number of Routed SAS Addresses: %d\n", 371 scsi_2btoul(response->max_num_routed_addrs)); 372 373 sbuf_printf(sb, "Active Zone Manager SAS Address: 0x%016jx\n", 374 scsi_8btou64(response->active_zm_address)); 375 376 sbuf_printf(sb, "Zone Inactivity Time Limit: %d\n", 377 scsi_2btoul(response->zone_lock_inact_time_limit)); 378 379 sbuf_printf(sb, "First Enclosure Connector Element Index: %d\n", 380 response->first_encl_conn_el_index); 381 382 sbuf_printf(sb, "Number of Enclosure Connector Element Indexes: %d\n", 383 response->num_encl_conn_el_indexes); 384 385 sbuf_printf(sb, "Reduced Functionality: %s\n", 386 smp_yesno(response->reduced_functionality & 387 SMP_RG_REDUCED_FUNCTIONALITY)); 388 389 sbuf_printf(sb, "Time to Reduced Functionality: %d\n", 390 response->time_to_reduced_func); 391 sbuf_printf(sb, "Initial Time to Reduced Functionality: %d\n", 392 response->initial_time_to_reduced_func); 393 sbuf_printf(sb, "Maximum Reduced Functionality Time: %d\n", 394 response->max_reduced_func_time); 395 396 sbuf_printf(sb, "Last Self-Configuration Status Descriptor Index: %d\n", 397 scsi_2btoul(response->last_sc_stat_desc_index)); 398 399 sbuf_printf(sb, "Maximum Number of Storated Self-Configuration " 400 "Status Descriptors: %d\n", 401 scsi_2btoul(response->max_sc_stat_descs)); 402 403 sbuf_printf(sb, "Last Phy Event List Descriptor Index: %d\n", 404 scsi_2btoul(response->last_phy_evl_desc_index)); 405 406 sbuf_printf(sb, "Maximum Number of Stored Phy Event List " 407 "Descriptors: %d\n", 408 scsi_2btoul(response->max_stored_pel_descs)); 409 410 sbuf_printf(sb, "STP Reject to Open Limit: %d\n", 411 scsi_2btoul(response->stp_reject_to_open_limit)); 412 } 413 414 /* 415 * Decode the SMP REPORT MANUFACTURER INFORMATION response. The format is 416 * current as of SPL Revision 7, but the parsing should be backward 417 * compatible for older versions of the spec. 418 */ 419 void 420 smp_report_manuf_info_sbuf(struct smp_report_manuf_info_response *response, 421 int response_len, struct sbuf *sb) 422 { 423 char vendor[16], product[48], revision[16]; 424 char comp_vendor[16]; 425 426 sbuf_printf(sb, "Report Manufacturer Information\n"); 427 sbuf_printf(sb, "Expander Change count: %d\n", 428 scsi_2btoul(response->expander_change_count)); 429 sbuf_printf(sb, "SAS 1.1 Format: %s\n", 430 smp_yesno(response->sas_11_format & SMP_RMI_SAS11_FORMAT)); 431 cam_strvis(vendor, response->vendor, sizeof(response->vendor), 432 sizeof(vendor)); 433 cam_strvis(product, response->product, sizeof(response->product), 434 sizeof(product)); 435 cam_strvis(revision, response->revision, sizeof(response->revision), 436 sizeof(revision)); 437 sbuf_printf(sb, "<%s %s %s>\n", vendor, product, revision); 438 439 if ((response->sas_11_format & SMP_RMI_SAS11_FORMAT) == 0) { 440 uint8_t *curbyte; 441 int line_start, line_cursor; 442 443 sbuf_printf(sb, "Vendor Specific Data:\n"); 444 445 /* 446 * Print out the bytes roughly in the style of hd(1), but 447 * without the extra ASCII decoding. Hexadecimal line 448 * numbers on the left, and 16 bytes per line, with an 449 * extra space after the first 8 bytes. 450 * 451 * It would be nice if this sort of thing were available 452 * in a library routine. 453 */ 454 for (curbyte = (uint8_t *)&response->comp_vendor, line_start= 1, 455 line_cursor = 0; curbyte < (uint8_t *)&response->crc; 456 curbyte++, line_cursor++) { 457 if (line_start != 0) { 458 sbuf_printf(sb, "%08lx ", 459 (unsigned long)(curbyte - 460 (uint8_t *)response)); 461 line_start = 0; 462 line_cursor = 0; 463 } 464 sbuf_printf(sb, "%02x", *curbyte); 465 466 if (line_cursor == 15) { 467 sbuf_printf(sb, "\n"); 468 line_start = 1; 469 } else 470 sbuf_printf(sb, " %s", (line_cursor == 7) ? 471 " " : ""); 472 } 473 if (line_cursor != 16) 474 sbuf_printf(sb, "\n"); 475 return; 476 } 477 478 cam_strvis(comp_vendor, response->comp_vendor, 479 sizeof(response->comp_vendor), sizeof(comp_vendor)); 480 sbuf_printf(sb, "Component Vendor: %s\n", comp_vendor); 481 sbuf_printf(sb, "Component ID: %#x\n", scsi_2btoul(response->comp_id)); 482 sbuf_printf(sb, "Component Revision: %#x\n", response->comp_revision); 483 sbuf_printf(sb, "Vendor Specific: 0x%016jx\n", 484 (uintmax_t)scsi_8btou64(response->vendor_specific)); 485 } 486 487 /* 488 * Compose a SMP REPORT GENERAL request and put it into a CCB. This is 489 * current as of SPL Revision 7. 490 */ 491 void 492 smp_report_general(struct ccb_smpio *smpio, uint32_t retries, 493 void (*cbfcnp)(struct cam_periph *, union ccb *), 494 struct smp_report_general_request *request, int request_len, 495 uint8_t *response, int response_len, int long_response, 496 uint32_t timeout) 497 { 498 cam_fill_smpio(smpio, 499 retries, 500 cbfcnp, 501 /*flags*/CAM_DIR_BOTH, 502 (uint8_t *)request, 503 request_len - SMP_CRC_LEN, 504 response, 505 response_len, 506 timeout); 507 508 bzero(request, sizeof(*request)); 509 510 request->frame_type = SMP_FRAME_TYPE_REQUEST; 511 request->function = SMP_FUNC_REPORT_GENERAL; 512 request->response_len = long_response ? SMP_RG_RESPONSE_LEN : 0; 513 request->request_len = 0; 514 } 515 516 /* 517 * Compose a SMP DISCOVER request and put it into a CCB. This is current 518 * as of SPL Revision 7. 519 */ 520 void 521 smp_discover(struct ccb_smpio *smpio, uint32_t retries, 522 void (*cbfcnp)(struct cam_periph *, union ccb *), 523 struct smp_discover_request *request, int request_len, 524 uint8_t *response, int response_len, int long_response, 525 int ignore_zone_group, int phy, uint32_t timeout) 526 { 527 cam_fill_smpio(smpio, 528 retries, 529 cbfcnp, 530 /*flags*/CAM_DIR_BOTH, 531 (uint8_t *)request, 532 request_len - SMP_CRC_LEN, 533 response, 534 response_len, 535 timeout); 536 537 bzero(request, sizeof(*request)); 538 request->frame_type = SMP_FRAME_TYPE_REQUEST; 539 request->function = SMP_FUNC_DISCOVER; 540 request->response_len = long_response ? SMP_DIS_RESPONSE_LEN : 0; 541 request->request_len = long_response ? SMP_DIS_REQUEST_LEN : 0; 542 if (ignore_zone_group != 0) 543 request->ignore_zone_group |= SMP_DIS_IGNORE_ZONE_GROUP; 544 request->phy = phy; 545 } 546 547 /* 548 * Compose a SMP REPORT MANUFACTURER INFORMATION request and put it into a 549 * CCB. This is current as of SPL Revision 7. 550 */ 551 void 552 smp_report_manuf_info(struct ccb_smpio *smpio, uint32_t retries, 553 void (*cbfcnp)(struct cam_periph *, union ccb *), 554 struct smp_report_manuf_info_request *request, 555 int request_len, uint8_t *response, int response_len, 556 int long_response, uint32_t timeout) 557 { 558 cam_fill_smpio(smpio, 559 retries, 560 cbfcnp, 561 /*flags*/CAM_DIR_BOTH, 562 (uint8_t *)request, 563 request_len - SMP_CRC_LEN, 564 response, 565 response_len, 566 timeout); 567 568 bzero(request, sizeof(*request)); 569 570 request->frame_type = SMP_FRAME_TYPE_REQUEST; 571 request->function = SMP_FUNC_REPORT_MANUF_INFO; 572 request->response_len = long_response ? SMP_RMI_RESPONSE_LEN : 0; 573 request->request_len = long_response ? SMP_RMI_REQUEST_LEN : 0; 574 } 575 576 /* 577 * Compose a SMP PHY CONTROL request and put it into a CCB. This is 578 * current as of SPL Revision 7. 579 */ 580 void 581 smp_phy_control(struct ccb_smpio *smpio, uint32_t retries, 582 void (*cbfcnp)(struct cam_periph *, union ccb *), 583 struct smp_phy_control_request *request, int request_len, 584 uint8_t *response, int response_len, int long_response, 585 uint32_t expected_exp_change_count, int phy, int phy_op, 586 int update_pp_timeout_val, uint64_t attached_device_name, 587 int prog_min_prl, int prog_max_prl, int slumber_partial, 588 int pp_timeout_value, uint32_t timeout) 589 { 590 cam_fill_smpio(smpio, 591 retries, 592 cbfcnp, 593 /*flags*/CAM_DIR_BOTH, 594 (uint8_t *)request, 595 request_len - SMP_CRC_LEN, 596 response, 597 response_len, 598 timeout); 599 600 bzero(request, sizeof(*request)); 601 602 request->frame_type = SMP_FRAME_TYPE_REQUEST; 603 request->function = SMP_FUNC_PHY_CONTROL; 604 request->response_len = long_response ? SMP_PC_RESPONSE_LEN : 0; 605 request->request_len = long_response ? SMP_PC_REQUEST_LEN : 0; 606 scsi_ulto2b(expected_exp_change_count, request->expected_exp_chg_cnt); 607 request->phy = phy; 608 request->phy_operation = phy_op; 609 610 if (update_pp_timeout_val != 0) 611 request->update_pp_timeout |= SMP_PC_UPDATE_PP_TIMEOUT; 612 613 scsi_u64to8b(attached_device_name, request->attached_device_name); 614 request->prog_min_phys_link_rate = (prog_min_prl << 615 SMP_PC_PROG_MIN_PL_RATE_SHIFT) & SMP_PC_PROG_MIN_PL_RATE_MASK; 616 request->prog_max_phys_link_rate = (prog_max_prl << 617 SMP_PC_PROG_MAX_PL_RATE_SHIFT) & SMP_PC_PROG_MAX_PL_RATE_MASK; 618 request->config_bits0 = slumber_partial; 619 request->pp_timeout_value = pp_timeout_value; 620 } 621