1 /*- 2 * SPDX-License-Identifier: (BSD-2-Clause OR GPL-2.0) 3 * 4 * Copyright (c) 2000 by Matthew Jacob 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, immediately at the beginning of the file. 13 * 2. The name of the author may not be used to endorse or promote products 14 * derived from this software without specific prior written permission. 15 * 16 * Alternatively, this software may be distributed under the terms of the 17 * the GNU Public License ("GPL"). 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR 23 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29 * SUCH DAMAGE. 30 * 31 */ 32 33 #ifndef _SCSI_SES_H_ 34 #define _SCSI_SES_H_ 35 36 #include <cam/scsi/scsi_all.h> 37 38 /*========================== Field Extraction Macros =========================*/ 39 #define MK_ENUM(S, F, SUFFIX) S ## _ ## F ## SUFFIX 40 41 #define GEN_GETTER(LS, US, LF, UF) \ 42 static inline int \ 43 LS ## _get_ ## LF(struct LS *elem) { \ 44 return ((elem->bytes[MK_ENUM(US,UF,_BYTE)] & MK_ENUM(US,UF,_MASK)) \ 45 >> MK_ENUM(US,UF,_SHIFT)); \ 46 } 47 48 #define GEN_SETTER(LS, US, LF, UF) \ 49 static inline void \ 50 LS ## _set_ ## LF(struct LS *elem, int val) { \ 51 elem->bytes[MK_ENUM(US,UF,_BYTE)] &= ~MK_ENUM(US,UF,_MASK); \ 52 elem->bytes[MK_ENUM(US,UF,_BYTE)] |= \ 53 (val << MK_ENUM(US,UF,_SHIFT)) & MK_ENUM(US,UF,_MASK); \ 54 } 55 56 #define GEN_HDR_GETTER(LS, US, LF, UF) \ 57 static inline int \ 58 LS ## _get_ ## LF(struct LS *page) { \ 59 return ((page->hdr.page_specific_flags & MK_ENUM(US,UF,_MASK)) \ 60 >> MK_ENUM(US,UF,_SHIFT)); \ 61 } 62 63 #define GEN_HDR_SETTER(LS, US, LF, UF) \ 64 static inline void \ 65 LS ## _set_ ## LF(struct LS *page, int val) { \ 66 page->hdr.page_specific_flags &= ~MK_ENUM(US,UF,_MASK); \ 67 page->hdr.page_specific_flags |= \ 68 (val << MK_ENUM(US,UF,_SHIFT)) & MK_ENUM(US,UF,_MASK); \ 69 } 70 71 #define GEN_ACCESSORS(LS, US, LF, UF) \ 72 GEN_GETTER(LS, US, LF, UF) \ 73 GEN_SETTER(LS, US, LF, UF) 74 75 #define GEN_HDR_ACCESSORS(LS, US, LF, UF) \ 76 GEN_HDR_GETTER(LS, US, LF, UF) \ 77 GEN_HDR_SETTER(LS, US, LF, UF) 78 79 /*=============== Common SCSI ENC Diagnostic Page Structures ===============*/ 80 struct ses_page_hdr { 81 uint8_t page_code; 82 uint8_t page_specific_flags; 83 uint8_t length[2]; 84 uint8_t gen_code[4]; 85 }; 86 87 static inline size_t 88 ses_page_length(const struct ses_page_hdr *hdr) 89 { 90 /* 91 * The page length as received only accounts for bytes that 92 * follow the length field, namely starting with the generation 93 * code field. 94 */ 95 return (scsi_2btoul(hdr->length) 96 + offsetof(struct ses_page_hdr, gen_code)); 97 } 98 99 /*============= SCSI ENC Configuration Diagnostic Page Structures ============*/ 100 struct ses_enc_desc { 101 uint8_t byte0; 102 /* 103 * reserved0 : 1, 104 * rel_id : 3, relative enclosure process id 105 * reserved1 : 1, 106 * num_procs : 3; number of enclosure procesenc 107 */ 108 uint8_t subenc_id; /* Sub-enclosure Identifier */ 109 uint8_t num_types; /* # of supported types */ 110 uint8_t length; /* Enclosure Descriptor Length */ 111 uint8_t logical_id[8]; /* formerly wwn */ 112 uint8_t vendor_id[8]; 113 uint8_t product_id[16]; 114 uint8_t product_rev[4]; 115 uint8_t vendor_bytes[]; 116 }; 117 118 static inline uint8_t * 119 ses_enc_desc_last_byte(struct ses_enc_desc *encdesc) 120 { 121 return (&encdesc->length + encdesc->length); 122 } 123 124 static inline struct ses_enc_desc * 125 ses_enc_desc_next(struct ses_enc_desc *encdesc) 126 { 127 return ((struct ses_enc_desc *)(ses_enc_desc_last_byte(encdesc) + 1)); 128 } 129 130 static inline int 131 ses_enc_desc_is_complete(struct ses_enc_desc *encdesc, uint8_t *last_buf_byte) 132 { 133 return (&encdesc->length <= last_buf_byte 134 && ses_enc_desc_last_byte(encdesc) <= last_buf_byte); 135 } 136 137 struct ses_elm_type_desc { 138 uint8_t etype_elm_type; /* type of element */ 139 uint8_t etype_maxelt; /* maximum supported */ 140 uint8_t etype_subenc; /* in sub-enclosure #n */ 141 uint8_t etype_txt_len; /* Type Descriptor Text Length */ 142 }; 143 144 struct ses_cfg_page { 145 struct ses_page_hdr hdr; 146 struct ses_enc_desc subencs[]; 147 /* type descriptors */ 148 /* type text */ 149 }; 150 151 static inline int 152 ses_cfg_page_get_num_subenc(struct ses_cfg_page *page) 153 { 154 return (page->hdr.page_specific_flags + 1); 155 } 156 157 /*================ SCSI SES Control Diagnostic Page Structures ==============*/ 158 struct ses_ctrl_common { 159 uint8_t bytes[1]; 160 }; 161 162 enum ses_ctrl_common_field_data { 163 SES_CTRL_COMMON_SELECT_BYTE = 0, 164 SES_CTRL_COMMON_SELECT_MASK = 0x80, 165 SES_CTRL_COMMON_SELECT_SHIFT = 7, 166 167 SES_CTRL_COMMON_PRDFAIL_BYTE = 0, 168 SES_CTRL_COMMON_PRDFAIL_MASK = 0x40, 169 SES_CTRL_COMMON_PRDFAIL_SHIFT = 6, 170 171 SES_CTRL_COMMON_DISABLE_BYTE = 0, 172 SES_CTRL_COMMON_DISABLE_MASK = 0x20, 173 SES_CTRL_COMMON_DISABLE_SHIFT = 5, 174 175 SES_CTRL_COMMON_RST_SWAP_BYTE = 0, 176 SES_CTRL_COMMON_RST_SWAP_MASK = 0x10, 177 SES_CTRL_COMMON_RST_SWAP_SHIFT = 4 178 }; 179 180 #define GEN_SES_CTRL_COMMON_ACCESSORS(LCASE, UCASE) \ 181 GEN_ACCESSORS(ses_ctrl_common, SES_CTRL_COMMON, LCASE, UCASE) 182 GEN_SES_CTRL_COMMON_ACCESSORS(select, SELECT) 183 GEN_SES_CTRL_COMMON_ACCESSORS(prdfail, PRDFAIL) 184 GEN_SES_CTRL_COMMON_ACCESSORS(disable, DISABLE) 185 GEN_SES_CTRL_COMMON_ACCESSORS(rst_swap, RST_SWAP) 186 #undef GEN_SES_CTRL_COMMON_ACCESSORS 187 188 /*------------------------ Device Slot Control Element ----------------------*/ 189 struct ses_ctrl_dev_slot { 190 struct ses_ctrl_common common; 191 uint8_t bytes[3]; 192 }; 193 194 enum ses_ctrl_dev_slot_field_data { 195 SES_CTRL_DEV_SLOT_RQST_ACTIVE_BYTE = 1, 196 SES_CTRL_DEV_SLOT_RQST_ACTIVE_MASK = 0x80, 197 SES_CTRL_DEV_SLOT_RQST_ACTIVE_SHIFT = 7, 198 199 SES_CTRL_DEV_SLOT_DO_NOT_REMOVE_BYTE = 1, 200 SES_CTRL_DEV_SLOT_DO_NOT_REMOVE_MASK = 0x40, 201 SES_CTRL_DEV_SLOT_DO_NOT_REMOVE_SHIFT = 6, 202 203 SES_CTRL_DEV_SLOT_RQST_MISSING_BYTE = 1, 204 SES_CTRL_DEV_SLOT_RQST_MISSING_MASK = 0x10, 205 SES_CTRL_DEV_SLOT_RQST_MISSING_SHIFT = 4, 206 207 SES_CTRL_DEV_SLOT_RQST_INSERT_BYTE = 1, 208 SES_CTRL_DEV_SLOT_RQST_INSERT_MASK = 0x08, 209 SES_CTRL_DEV_SLOT_RQST_INSERT_SHIFT = 3, 210 211 SES_CTRL_DEV_SLOT_RQST_REMOVE_BYTE = 1, 212 SES_CTRL_DEV_SLOT_RQST_REMOVE_MASK = 0x04, 213 SES_CTRL_DEV_SLOT_RQST_REMOVE_SHIFT = 2, 214 215 SES_CTRL_DEV_SLOT_RQST_IDENT_BYTE = 1, 216 SES_CTRL_DEV_SLOT_RQST_IDENT_MASK = 0x02, 217 SES_CTRL_DEV_SLOT_RQST_IDENT_SHIFT = 1, 218 219 SES_CTRL_DEV_SLOT_RQST_FAULT_BYTE = 2, 220 SES_CTRL_DEV_SLOT_RQST_FAULT_MASK = 0x20, 221 SES_CTRL_DEV_SLOT_RQST_FAULT_SHIFT = 5, 222 223 SES_CTRL_DEV_SLOT_DEVICE_OFF_BYTE = 2, 224 SES_CTRL_DEV_SLOT_DEVICE_OFF_MASK = 0x10, 225 SES_CTRL_DEV_SLOT_DEVICE_OFF_SHIFT = 4, 226 227 SES_CTRL_DEV_SLOT_ENABLE_BYP_A_BYTE = 2, 228 SES_CTRL_DEV_SLOT_ENABLE_BYP_A_MASK = 0x08, 229 SES_CTRL_DEV_SLOT_ENABLE_BYP_A_SHIFT = 3, 230 231 SES_CTRL_DEV_SLOT_ENABLE_BYP_B_BYTE = 2, 232 SES_CTRL_DEV_SLOT_ENABLE_BYP_B_MASK = 0x04, 233 SES_CTRL_DEV_SLOT_ENABLE_BYP_B_SHIFT = 2 234 }; 235 #define GEN_SES_CTRL_DEV_SLOT_ACCESSORS(LCASE, UCASE) \ 236 GEN_ACCESSORS(ses_ctrl_dev_slot, SES_CTRL_DEV_SLOT, LCASE, UCASE) 237 238 GEN_SES_CTRL_DEV_SLOT_ACCESSORS(rqst_active, RQST_ACTIVE) 239 GEN_SES_CTRL_DEV_SLOT_ACCESSORS(do_not_remove, DO_NOT_REMOVE) 240 GEN_SES_CTRL_DEV_SLOT_ACCESSORS(rqst_missing, RQST_MISSING) 241 GEN_SES_CTRL_DEV_SLOT_ACCESSORS(rqst_insert, RQST_INSERT) 242 GEN_SES_CTRL_DEV_SLOT_ACCESSORS(rqst_remove, RQST_REMOVE) 243 GEN_SES_CTRL_DEV_SLOT_ACCESSORS(rqst_ident, RQST_IDENT) 244 GEN_SES_CTRL_DEV_SLOT_ACCESSORS(rqst_fault, RQST_FAULT) 245 GEN_SES_CTRL_DEV_SLOT_ACCESSORS(device_off, DEVICE_OFF) 246 GEN_SES_CTRL_DEV_SLOT_ACCESSORS(enable_byp_a, ENABLE_BYP_A) 247 GEN_SES_CTRL_DEV_SLOT_ACCESSORS(enable_byp_b, ENABLE_BYP_B) 248 #undef GEN_SES_CTRL_DEV_SLOT_ACCESSORS 249 250 /*--------------------- Array Device Slot Control Element --------------------*/ 251 struct ses_ctrl_array_dev_slot { 252 struct ses_ctrl_common common; 253 uint8_t bytes[3]; 254 }; 255 256 enum ses_ctrl_array_dev_slot_field_data { 257 SES_CTRL_ARRAY_DEV_SLOT_RQST_OK_BYTE = 0, 258 SES_CTRL_ARRAY_DEV_SLOT_RQST_OK_MASK = 0x80, 259 SES_CTRL_ARRAY_DEV_SLOT_RQST_OK_SHIFT = 7, 260 261 SES_CTRL_ARRAY_DEV_SLOT_RQST_RSVD_DEVICE_BYTE = 0, 262 SES_CTRL_ARRAY_DEV_SLOT_RQST_RSVD_DEVICE_MASK = 0x40, 263 SES_CTRL_ARRAY_DEV_SLOT_RQST_RSVD_DEVICE_SHIFT = 6, 264 265 SES_CTRL_ARRAY_DEV_SLOT_RQST_HOT_SPARE_BYTE = 0, 266 SES_CTRL_ARRAY_DEV_SLOT_RQST_HOT_SPARE_MASK = 0x20, 267 SES_CTRL_ARRAY_DEV_SLOT_RQST_HOT_SPARE_SHIFT = 5, 268 269 SES_CTRL_ARRAY_DEV_SLOT_RQST_CONS_CHECK_BYTE = 0, 270 SES_CTRL_ARRAY_DEV_SLOT_RQST_CONS_CHECK_MASK = 0x10, 271 SES_CTRL_ARRAY_DEV_SLOT_RQST_CONS_CHECK_SHIFT = 4, 272 273 SES_CTRL_ARRAY_DEV_SLOT_RQST_IN_CRIT_ARRAY_BYTE = 0, 274 SES_CTRL_ARRAY_DEV_SLOT_RQST_IN_CRIT_ARRAY_MASK = 0x08, 275 SES_CTRL_ARRAY_DEV_SLOT_RQST_IN_CRIT_ARRAY_SHIFT = 3, 276 277 SES_CTRL_ARRAY_DEV_SLOT_RQST_IN_FAILED_ARRAY_BYTE = 0, 278 SES_CTRL_ARRAY_DEV_SLOT_RQST_IN_FAILED_ARRAY_MASK = 0x04, 279 SES_CTRL_ARRAY_DEV_SLOT_RQST_IN_FAILED_ARRAY_SHIFT = 2, 280 281 SES_CTRL_ARRAY_DEV_SLOT_RQST_REBUILD_REMAP_BYTE = 0, 282 SES_CTRL_ARRAY_DEV_SLOT_RQST_REBUILD_REMAP_MASK = 0x02, 283 SES_CTRL_ARRAY_DEV_SLOT_RQST_REBUILD_REMAP_SHIFT = 1, 284 285 SES_CTRL_ARRAY_DEV_SLOT_RQST_REBUILD_REMAP_ABORT_BYTE = 0, 286 SES_CTRL_ARRAY_DEV_SLOT_RQST_REBUILD_REMAP_ABORT_MASK = 0x01, 287 SES_CTRL_ARRAY_DEV_SLOT_RQST_REBUILD_REMAP_ABORT_SHIFT = 0 288 289 /* 290 * The remaining fields are identical to the device 291 * slot element type. Access them through the device slot 292 * element type and its accessors. 293 */ 294 }; 295 #define GEN_SES_CTRL_ARRAY_DEV_SLOT_ACCESSORS(LCASE, UCASE) \ 296 GEN_ACCESSORS(ses_ctrl_array_dev_slot, SES_CTRL_ARRAY_DEV_SLOT, \ 297 LCASE, UCASE) 298 GEN_SES_CTRL_ARRAY_DEV_SLOT_ACCESSORS(rqst_ok, RQST_OK) 299 GEN_SES_CTRL_ARRAY_DEV_SLOT_ACCESSORS(rqst_rsvd_device, RQST_RSVD_DEVICE) 300 GEN_SES_CTRL_ARRAY_DEV_SLOT_ACCESSORS(rqst_hot_spare, RQST_HOT_SPARE) 301 GEN_SES_CTRL_ARRAY_DEV_SLOT_ACCESSORS(rqst_cons_check, RQST_CONS_CHECK) 302 GEN_SES_CTRL_ARRAY_DEV_SLOT_ACCESSORS(rqst_in_crit_array, RQST_IN_CRIT_ARRAY) 303 GEN_SES_CTRL_ARRAY_DEV_SLOT_ACCESSORS(rqst_in_failed_array, 304 RQST_IN_FAILED_ARRAY) 305 GEN_SES_CTRL_ARRAY_DEV_SLOT_ACCESSORS(rqst_rebuild_remap, RQST_REBUILD_REMAP) 306 GEN_SES_CTRL_ARRAY_DEV_SLOT_ACCESSORS(rqst_rebuild_remap_abort, 307 RQST_REBUILD_REMAP_ABORT) 308 #undef GEN_SES_CTRL_ARRAY_DEV_SLOT_ACCESSORS 309 310 /*----------------------- Power Supply Control Element -----------------------*/ 311 struct ses_ctrl_power_supply { 312 struct ses_ctrl_common common; 313 uint8_t bytes[3]; 314 }; 315 316 enum ses_ctrl_power_supply_field_data { 317 SES_CTRL_POWER_SUPPLY_RQST_IDENT_BYTE = 0, 318 SES_CTRL_POWER_SUPPLY_RQST_IDENT_MASK = 0x80, 319 SES_CTRL_POWER_SUPPLY_RQST_IDENT_SHIFT = 7, 320 321 SES_CTRL_POWER_SUPPLY_RQST_FAIL_BYTE = 2, 322 SES_CTRL_POWER_SUPPLY_RQST_FAIL_MASK = 0x40, 323 SES_CTRL_POWER_SUPPLY_RQST_FAIL_SHIFT = 6, 324 325 SES_CTRL_POWER_SUPPLY_RQST_ON_BYTE = 2, 326 SES_CTRL_POWER_SUPPLY_RQST_ON_MASK = 0x20, 327 SES_CTRL_POWER_SUPPLY_RQST_ON_SHIFT = 5 328 }; 329 330 #define GEN_SES_CTRL_POWER_SUPPLY_ACCESSORS(LCASE, UCASE) \ 331 GEN_ACCESSORS(ses_ctrl_power_supply, SES_CTRL_POWER_SUPPLY, LCASE, UCASE) 332 GEN_SES_CTRL_POWER_SUPPLY_ACCESSORS(rqst_ident, RQST_IDENT) 333 GEN_SES_CTRL_POWER_SUPPLY_ACCESSORS(rqst_fail, RQST_FAIL) 334 GEN_SES_CTRL_POWER_SUPPLY_ACCESSORS(rqst_on, RQST_ON) 335 #undef GEN_SES_CTRL_POWER_SUPPLY_ACCESSORS 336 337 /*-------------------------- Cooling Control Element -------------------------*/ 338 struct ses_ctrl_cooling { 339 struct ses_ctrl_common common; 340 uint8_t bytes[3]; 341 }; 342 343 enum ses_ctrl_cooling_field_data { 344 SES_CTRL_COOLING_RQST_IDENT_BYTE = 0, 345 SES_CTRL_COOLING_RQST_IDENT_MASK = 0x80, 346 SES_CTRL_COOLING_RQST_IDENT_SHIFT = 7, 347 348 SES_CTRL_COOLING_RQST_FAIL_BYTE = 2, 349 SES_CTRL_COOLING_RQST_FAIL_MASK = 0x40, 350 SES_CTRL_COOLING_RQST_FAIL_SHIFT = 6, 351 352 SES_CTRL_COOLING_RQST_ON_BYTE = 2, 353 SES_CTRL_COOLING_RQST_ON_MASK = 0x20, 354 SES_CTRL_COOLING_RQST_ON_SHIFT = 5, 355 356 SES_CTRL_COOLING_RQSTED_SPEED_CODE_BYTE = 2, 357 SES_CTRL_COOLING_RQSTED_SPEED_CODE_MASK = 0x07, 358 SES_CTRL_COOLING_RQSTED_SPEED_CODE_SHIFT = 2, 359 SES_CTRL_COOLING_RQSTED_SPEED_CODE_UNCHANGED = 0x00, 360 SES_CTRL_COOLING_RQSTED_SPEED_CODE_LOWEST = 0x01, 361 SES_CTRL_COOLING_RQSTED_SPEED_CODE_HIGHEST = 0x07 362 }; 363 364 #define GEN_SES_CTRL_COOLING_ACCESSORS(LCASE, UCASE) \ 365 GEN_ACCESSORS(ses_ctrl_cooling, SES_CTRL_COOLING, LCASE, UCASE) 366 GEN_SES_CTRL_COOLING_ACCESSORS(rqst_ident, RQST_IDENT) 367 GEN_SES_CTRL_COOLING_ACCESSORS(rqst_fail, RQST_FAIL) 368 GEN_SES_CTRL_COOLING_ACCESSORS(rqst_on, RQST_ON) 369 GEN_SES_CTRL_COOLING_ACCESSORS(rqsted_speed_code, RQSTED_SPEED_CODE) 370 #undef GEN_SES_CTRL_COOLING_ACCESSORS 371 372 /*-------------------- Temperature Sensor Control Element --------------------*/ 373 struct ses_ctrl_temp_sensor { 374 struct ses_ctrl_common common; 375 uint8_t bytes[3]; 376 }; 377 378 enum ses_ctrl_temp_sensor_field_data { 379 SES_CTRL_TEMP_SENSOR_RQST_IDENT_BYTE = 0, 380 SES_CTRL_TEMP_SENSOR_RQST_IDENT_MASK = 0x80, 381 SES_CTRL_TEMP_SENSOR_RQST_IDENT_SHIFT = 7, 382 383 SES_CTRL_TEMP_SENSOR_RQST_FAIL_BYTE = 0, 384 SES_CTRL_TEMP_SENSOR_RQST_FAIL_MASK = 0x40, 385 SES_CTRL_TEMP_SENSOR_RQST_FAIL_SHIFT = 6 386 }; 387 388 #define GEN_SES_CTRL_TEMP_SENSOR_ACCESSORS(LCASE, UCASE) \ 389 GEN_ACCESSORS(ses_ctrl_temp_sensor, SES_CTRL_TEMP_SENSOR, LCASE, UCASE) 390 GEN_SES_CTRL_TEMP_SENSOR_ACCESSORS(rqst_ident, RQST_IDENT) 391 GEN_SES_CTRL_TEMP_SENSOR_ACCESSORS(rqst_fail, RQST_FAIL) 392 #undef GEN_SES_CTRL_TEMP_SENSOR_ACCESSORS 393 394 /*------------------------- Door Lock Control Element ------------------------*/ 395 struct ses_ctrl_door_lock { 396 struct ses_ctrl_common common; 397 uint8_t bytes[3]; 398 }; 399 400 enum ses_ctrl_door_lock_field_data { 401 SES_CTRL_DOOR_LOCK_RQST_IDENT_BYTE = 0, 402 SES_CTRL_DOOR_LOCK_RQST_IDENT_MASK = 0x80, 403 SES_CTRL_DOOR_LOCK_RQST_IDENT_SHIFT = 7, 404 405 SES_CTRL_DOOR_LOCK_RQST_FAIL_BYTE = 0, 406 SES_CTRL_DOOR_LOCK_RQST_FAIL_MASK = 0x40, 407 SES_CTRL_DOOR_LOCK_RQST_FAIL_SHIFT = 6, 408 409 SES_CTRL_DOOR_LOCK_UNLOCK_BYTE = 2, 410 SES_CTRL_DOOR_LOCK_UNLOCK_MASK = 0x01, 411 SES_CTRL_DOOR_LOCK_UNLOCK_SHIFT = 0 412 }; 413 414 #define GEN_SES_CTRL_DOOR_LOCK_ACCESSORS(LCASE, UCASE) \ 415 GEN_ACCESSORS(ses_ctrl_door_lock, SES_CTRL_DOOR_LOCK, LCASE, UCASE) 416 GEN_SES_CTRL_DOOR_LOCK_ACCESSORS(rqst_ident, RQST_IDENT) 417 GEN_SES_CTRL_DOOR_LOCK_ACCESSORS(rqst_fail, RQST_FAIL) 418 GEN_SES_CTRL_DOOR_LOCK_ACCESSORS(unlock, UNLOCK) 419 #undef GEN_SES_CTRL_DOOR_LOCK_ACCESSORS 420 421 /*----------------------- Audible Alarm Control Element ----------------------*/ 422 struct ses_ctrl_audible_alarm { 423 struct ses_ctrl_common common; 424 uint8_t bytes[3]; 425 }; 426 427 enum ses_ctrl_audible_alarm_field_data { 428 SES_CTRL_AUDIBLE_ALARM_RQST_IDENT_BYTE = 0, 429 SES_CTRL_AUDIBLE_ALARM_RQST_IDENT_MASK = 0x80, 430 SES_CTRL_AUDIBLE_ALARM_RQST_IDENT_SHIFT = 7, 431 432 SES_CTRL_AUDIBLE_ALARM_RQST_FAIL_BYTE = 0, 433 SES_CTRL_AUDIBLE_ALARM_RQST_FAIL_MASK = 0x40, 434 SES_CTRL_AUDIBLE_ALARM_RQST_FAIL_SHIFT = 6, 435 436 SES_CTRL_AUDIBLE_ALARM_SET_MUTE_BYTE = 2, 437 SES_CTRL_AUDIBLE_ALARM_SET_MUTE_MASK = 0x40, 438 SES_CTRL_AUDIBLE_ALARM_SET_MUTE_SHIFT = 6, 439 440 SES_CTRL_AUDIBLE_ALARM_SET_REMIND_BYTE = 2, 441 SES_CTRL_AUDIBLE_ALARM_SET_REMIND_MASK = 0x10, 442 SES_CTRL_AUDIBLE_ALARM_SET_REMIND_SHIFT = 4, 443 444 SES_CTRL_AUDIBLE_ALARM_TONE_CONTROL_BYTE = 2, 445 SES_CTRL_AUDIBLE_ALARM_TONE_CONTROL_MASK = 0x0F, 446 SES_CTRL_AUDIBLE_ALARM_TONE_CONTROL_SHIFT = 0, 447 SES_CTRL_AUDIBLE_ALARM_TONE_CONTROL_INFO = 0x08, 448 SES_CTRL_AUDIBLE_ALARM_TONE_CONTROL_NON_CRIT = 0x04, 449 SES_CTRL_AUDIBLE_ALARM_TONE_CONTROL_CRIT = 0x02, 450 SES_CTRL_AUDIBLE_ALARM_TONE_CONTROL_UNRECOV = 0x01 451 }; 452 453 #define GEN_SES_CTRL_AUDIBLE_ALARM_ACCESSORS(LCASE, UCASE) \ 454 GEN_ACCESSORS(ses_ctrl_audible_alarm, SES_CTRL_AUDIBLE_ALARM, LCASE, UCASE) 455 GEN_SES_CTRL_AUDIBLE_ALARM_ACCESSORS(rqst_ident, RQST_IDENT) 456 GEN_SES_CTRL_AUDIBLE_ALARM_ACCESSORS(rqst_fail, RQST_FAIL) 457 GEN_SES_CTRL_AUDIBLE_ALARM_ACCESSORS(set_mute, SET_MUTE) 458 GEN_SES_CTRL_AUDIBLE_ALARM_ACCESSORS(set_remind, SET_REMIND) 459 GEN_SES_CTRL_AUDIBLE_ALARM_ACCESSORS(tone_control, TONE_CONTROL) 460 #undef GEN_SES_CTRL_AUDIBLE_ALARM_ACCESSORS 461 462 /*--------- Enclosure Services Controller Electronics Control Element --------*/ 463 struct ses_ctrl_ecc_electronics { 464 struct ses_ctrl_common common; 465 uint8_t bytes[3]; 466 }; 467 468 enum ses_ctrl_ecc_electronics_field_data { 469 SES_CTRL_ECC_ELECTRONICS_RQST_IDENT_BYTE = 0, 470 SES_CTRL_ECC_ELECTRONICS_RQST_IDENT_MASK = 0x80, 471 SES_CTRL_ECC_ELECTRONICS_RQST_IDENT_SHIFT = 7, 472 473 SES_CTRL_ECC_ELECTRONICS_RQST_FAIL_BYTE = 0, 474 SES_CTRL_ECC_ELECTRONICS_RQST_FAIL_MASK = 0x40, 475 SES_CTRL_ECC_ELECTRONICS_RQST_FAIL_SHIFT = 6, 476 477 SES_CTRL_ECC_ELECTRONICS_SELECT_ELEMENT_BYTE = 1, 478 SES_CTRL_ECC_ELECTRONICS_SELECT_ELEMENT_MASK = 0x01, 479 SES_CTRL_ECC_ELECTRONICS_SELECT_ELEMENT_SHIFT = 0 480 }; 481 482 #define GEN_SES_CTRL_ECC_ELECTRONICS_ACCESSORS(LCASE, UCASE) \ 483 GEN_ACCESSORS(ses_ctrl_ecc_electronics, SES_CTRL_ECC_ELECTRONICS, \ 484 LCASE, UCASE) 485 GEN_SES_CTRL_ECC_ELECTRONICS_ACCESSORS(rqst_ident, RQST_IDENT) 486 GEN_SES_CTRL_ECC_ELECTRONICS_ACCESSORS(rqst_fail, RQST_FAIL) 487 GEN_SES_CTRL_ECC_ELECTRONICS_ACCESSORS(select_element, SELECT_ELEMENT) 488 #undef GEN_SES_CTRL_ECC_ELECTRONICS_ACCESSORS 489 490 /*----------- SCSI Services Controller Electronics Control Element -----------*/ 491 struct ses_ctrl_scc_electronics { 492 struct ses_ctrl_common common; 493 uint8_t bytes[3]; 494 }; 495 496 enum ses_ctrl_scc_electronics_field_data { 497 SES_CTRL_SCC_ELECTRONICS_RQST_IDENT_BYTE = 0, 498 SES_CTRL_SCC_ELECTRONICS_RQST_IDENT_MASK = 0x80, 499 SES_CTRL_SCC_ELECTRONICS_RQST_IDENT_SHIFT = 7, 500 501 SES_CTRL_SCC_ELECTRONICS_RQST_FAIL_BYTE = 0, 502 SES_CTRL_SCC_ELECTRONICS_RQST_FAIL_MASK = 0x40, 503 SES_CTRL_SCC_ELECTRONICS_RQST_FAIL_SHIFT = 6 504 }; 505 506 #define GEN_SES_CTRL_SCC_ELECTRONICS_ACCESSORS(LCASE, UCASE) \ 507 GEN_ACCESSORS(ses_ctrl_scc_electronics, SES_CTRL_SCC_ELECTRONICS, \ 508 LCASE, UCASE) 509 GEN_SES_CTRL_SCC_ELECTRONICS_ACCESSORS(rqst_ident, RQST_IDENT) 510 GEN_SES_CTRL_SCC_ELECTRONICS_ACCESSORS(rqst_fail, RQST_FAIL) 511 #undef GEN_SES_CTRL_SCC_ELECTRONICS_ACCESSORS 512 513 /*--------------------- Nonvolatile Cache Control Element --------------------*/ 514 struct ses_ctrl_nv_cache { 515 struct ses_ctrl_common common; 516 uint8_t bytes[3]; 517 }; 518 519 enum ses_ctrl_nv_cache_field_data { 520 SES_CTRL_NV_CACHE_RQST_IDENT_BYTE = 0, 521 SES_CTRL_NV_CACHE_RQST_IDENT_MASK = 0x80, 522 SES_CTRL_NV_CACHE_RQST_IDENT_SHIFT = 7, 523 524 SES_CTRL_NV_CACHE_RQST_FAIL_BYTE = 0, 525 SES_CTRL_NV_CACHE_RQST_FAIL_MASK = 0x40, 526 SES_CTRL_NV_CACHE_RQST_FAIL_SHIFT = 6 527 }; 528 529 #define GEN_SES_CTRL_NV_CACHE_ACCESSORS(LCASE, UCASE) \ 530 GEN_ACCESSORS(ses_ctrl_nv_cache, SES_CTRL_NV_CACHE, LCASE, UCASE) 531 GEN_SES_CTRL_NV_CACHE_ACCESSORS(rqst_ident, RQST_IDENT) 532 GEN_SES_CTRL_NV_CACHE_ACCESSORS(rqst_fail, RQST_FAIL) 533 #undef GEN_SES_CTRL_NV_CACHE_ACCESSORS 534 535 /*----------------- Invalid Operation Reason Control Element -----------------*/ 536 struct ses_ctrl_invalid_op_reason { 537 struct ses_ctrl_common common; 538 uint8_t bytes[3]; 539 }; 540 541 /* There are no element specific fields currently defined in the spec. */ 542 543 /*--------------- Uninterruptible Power Supply Control Element ---------------*/ 544 struct ses_ctrl_ups { 545 struct ses_ctrl_common common; 546 uint8_t bytes[3]; 547 }; 548 549 enum ses_ctrl_ups_field_data { 550 SES_CTRL_UPS_RQST_IDENT_BYTE = 2, 551 SES_CTRL_UPS_RQST_IDENT_MASK = 0x80, 552 SES_CTRL_UPS_RQST_IDENT_SHIFT = 7, 553 554 SES_CTRL_UPS_RQST_FAIL_BYTE = 2, 555 SES_CTRL_UPS_RQST_FAIL_MASK = 0x40, 556 SES_CTRL_UPS_RQST_FAIL_SHIFT = 6 557 }; 558 559 #define GEN_SES_CTRL_UPS_ACCESSORS(LCASE, UCASE) \ 560 GEN_ACCESSORS(ses_ctrl_ups, SES_CTRL_UPS, LCASE, UCASE) 561 GEN_SES_CTRL_UPS_ACCESSORS(rqst_ident, RQST_IDENT) 562 GEN_SES_CTRL_UPS_ACCESSORS(rqst_fail, RQST_FAIL) 563 #undef GEN_SES_CTRL_UPS_ACCESSORS 564 565 /*-------------------------- Display Control Element -------------------------*/ 566 struct ses_ctrl_display { 567 struct ses_ctrl_common common; 568 uint8_t bytes[1]; 569 uint8_t display_character[2]; 570 }; 571 572 enum ses_ctrl_display_field_data { 573 SES_CTRL_DISPLAY_RQST_IDENT_BYTE = 0, 574 SES_CTRL_DISPLAY_RQST_IDENT_MASK = 0x80, 575 SES_CTRL_DISPLAY_RQST_IDENT_SHIFT = 7, 576 577 SES_CTRL_DISPLAY_RQST_FAIL_BYTE = 0, 578 SES_CTRL_DISPLAY_RQST_FAIL_MASK = 0x40, 579 SES_CTRL_DISPLAY_RQST_FAIL_SHIFT = 6, 580 581 SES_CTRL_DISPLAY_DISPLAY_MODE_BYTE = 0, 582 SES_CTRL_DISPLAY_DISPLAY_MODE_MASK = 0x03, 583 SES_CTRL_DISPLAY_DISPLAY_MODE_SHIFT = 6, 584 SES_CTRL_DISPLAY_DISPLAY_MODE_UNCHANGED = 0x0, 585 SES_CTRL_DISPLAY_DISPLAY_MODE_ESP = 0x1, 586 SES_CTRL_DISPLAY_DISPLAY_MODE_DC_FIELD = 0x2 587 }; 588 589 #define GEN_SES_CTRL_DISPLAY_ACCESSORS(LCASE, UCASE) \ 590 GEN_ACCESSORS(ses_ctrl_display, SES_CTRL_DISPLAY, LCASE, UCASE) 591 GEN_SES_CTRL_DISPLAY_ACCESSORS(rqst_ident, RQST_IDENT) 592 GEN_SES_CTRL_DISPLAY_ACCESSORS(rqst_fail, RQST_FAIL) 593 GEN_SES_CTRL_DISPLAY_ACCESSORS(display_mode, DISPLAY_MODE) 594 #undef GEN_SES_CTRL_DISPLAY_ACCESSORS 595 596 /*----------------------- Key Pad Entry Control Element ----------------------*/ 597 struct ses_ctrl_key_pad_entry { 598 struct ses_ctrl_common common; 599 uint8_t bytes[3]; 600 }; 601 602 enum ses_ctrl_key_pad_entry_field_data { 603 SES_CTRL_KEY_PAD_ENTRY_RQST_IDENT_BYTE = 0, 604 SES_CTRL_KEY_PAD_ENTRY_RQST_IDENT_MASK = 0x80, 605 SES_CTRL_KEY_PAD_ENTRY_RQST_IDENT_SHIFT = 7, 606 607 SES_CTRL_KEY_PAD_ENTRY_RQST_FAIL_BYTE = 0, 608 SES_CTRL_KEY_PAD_ENTRY_RQST_FAIL_MASK = 0x40, 609 SES_CTRL_KEY_PAD_ENTRY_RQST_FAIL_SHIFT = 6 610 }; 611 612 #define GEN_SES_CTRL_KEY_PAD_ENTRY_ACCESSORS(LCASE, UCASE) \ 613 GEN_ACCESSORS(ses_ctrl_key_pad_entry, SES_CTRL_KEY_PAD_ENTRY, LCASE, UCASE) 614 GEN_SES_CTRL_KEY_PAD_ENTRY_ACCESSORS(rqst_ident, RQST_IDENT) 615 GEN_SES_CTRL_KEY_PAD_ENTRY_ACCESSORS(rqst_fail, RQST_FAIL) 616 #undef GEN_SES_CTRL_KEY_PAD_ENTRY_ACCESSORS 617 618 /*------------------------- Enclosure Control Element ------------------------*/ 619 struct ses_ctrl_enclosure { 620 struct ses_ctrl_common common; 621 uint8_t bytes[3]; 622 }; 623 624 enum ses_ctrl_enclosure_field_data { 625 SES_CTRL_ENCLOSURE_RQST_IDENT_BYTE = 0, 626 SES_CTRL_ENCLOSURE_RQST_IDENT_MASK = 0x80, 627 SES_CTRL_ENCLOSURE_RQST_IDENT_SHIFT = 7, 628 629 SES_CTRL_ENCLOSURE_POWER_CYCLE_RQST_BYTE = 1, 630 SES_CTRL_ENCLOSURE_POWER_CYCLE_RQST_MASK = 0xC0, 631 SES_CTRL_ENCLOSURE_POWER_CYCLE_RQST_SHIFT = 6, 632 SES_CTRL_ENCLOSURE_POWER_CYCLE_RQST_NONE = 0x0, 633 SES_CTRL_ENCLOSURE_POWER_CYCLE_RQST_AFTER_DELAY = 0x1, 634 SES_CTRL_ENCLOSURE_POWER_CYCLE_RQST_CANCEL = 0x2, 635 636 SES_CTRL_ENCLOSURE_POWER_CYCLE_DELAY_BYTE = 1, 637 SES_CTRL_ENCLOSURE_POWER_CYCLE_DELAY_MASK = 0x3F, 638 SES_CTRL_ENCLOSURE_POWER_CYCLE_DELAY_SHIFT = 0, 639 SES_CTRL_ENCLOSURE_POWER_CYCLE_DELAY_MAX = 60,/*minutes*/ 640 641 SES_CTRL_ENCLOSURE_POWER_OFF_DURATION_BYTE = 2, 642 SES_CTRL_ENCLOSURE_POWER_OFF_DURATION_MASK = 0xFC, 643 SES_CTRL_ENCLOSURE_POWER_OFF_DURATION_SHIFT = 2, 644 SES_CTRL_ENCLOSURE_POWER_OFF_DURATION_MAX_AUTO = 60, 645 SES_CTRL_ENCLOSURE_POWER_OFF_DURATION_MANUAL = 63, 646 647 SES_CTRL_ENCLOSURE_RQST_FAIL_BYTE = 2, 648 SES_CTRL_ENCLOSURE_RQST_FAIL_MASK = 0x02, 649 SES_CTRL_ENCLOSURE_RQST_FAIL_SHIFT = 1, 650 651 SES_CTRL_ENCLOSURE_RQST_WARN_BYTE = 2, 652 SES_CTRL_ENCLOSURE_RQST_WARN_MASK = 0x01, 653 SES_CTRL_ENCLOSURE_RQST_WARN_SHIFT = 0 654 }; 655 656 #define GEN_SES_CTRL_ENCLOSURE_ACCESSORS(LCASE, UCASE) \ 657 GEN_ACCESSORS(ses_ctrl_enclosure, SES_CTRL_ENCLOSURE, LCASE, UCASE) 658 GEN_SES_CTRL_ENCLOSURE_ACCESSORS(rqst_ident, RQST_IDENT) 659 GEN_SES_CTRL_ENCLOSURE_ACCESSORS(power_cycle_rqst, POWER_CYCLE_RQST) 660 GEN_SES_CTRL_ENCLOSURE_ACCESSORS(power_cycle_delay, POWER_CYCLE_DELAY) 661 GEN_SES_CTRL_ENCLOSURE_ACCESSORS(power_off_duration, POWER_OFF_DURATION) 662 GEN_SES_CTRL_ENCLOSURE_ACCESSORS(rqst_fail, RQST_FAIL) 663 GEN_SES_CTRL_ENCLOSURE_ACCESSORS(rqst_warn, RQST_WARN) 664 #undef GEN_SES_CTRL_ENCLOSURE_ACCESSORS 665 666 /*------------------- SCSI Port/Transceiver Control Element ------------------*/ 667 struct ses_ctrl_scsi_port_or_xcvr { 668 struct ses_ctrl_common common; 669 uint8_t bytes[3]; 670 }; 671 672 enum ses_ctrl_scsi_port_or_xcvr_field_data { 673 SES_CTRL_SCSI_PORT_OR_XCVR_RQST_IDENT_BYTE = 0, 674 SES_CTRL_SCSI_PORT_OR_XCVR_RQST_IDENT_MASK = 0x80, 675 SES_CTRL_SCSI_PORT_OR_XCVR_RQST_IDENT_SHIFT = 7, 676 677 SES_CTRL_SCSI_PORT_OR_XCVR_RQST_FAIL_BYTE = 0, 678 SES_CTRL_SCSI_PORT_OR_XCVR_RQST_FAIL_MASK = 0x40, 679 SES_CTRL_SCSI_PORT_OR_XCVR_RQST_FAIL_SHIFT = 6, 680 681 SES_CTRL_SCSI_PORT_OR_XCVR_DISABLE_BYTE = 2, 682 SES_CTRL_SCSI_PORT_OR_XCVR_DISABLE_MASK = 0x10, 683 SES_CTRL_SCSI_PORT_OR_XCVR_DISABLE_SHIFT = 4 684 }; 685 686 #define GEN_SES_CTRL_SCSI_PORT_OR_XCVR_ACCESSORS(LCASE, UCASE) \ 687 GEN_ACCESSORS(ses_ctrl_scsi_port_or_xcvr, SES_CTRL_SCSI_PORT_OR_XCVR,\ 688 LCASE, UCASE) 689 GEN_SES_CTRL_SCSI_PORT_OR_XCVR_ACCESSORS(rqst_ident, RQST_IDENT) 690 GEN_SES_CTRL_SCSI_PORT_OR_XCVR_ACCESSORS(disable, DISABLE) 691 GEN_SES_CTRL_SCSI_PORT_OR_XCVR_ACCESSORS(rqst_fail, RQST_FAIL) 692 #undef GEN_SES_CTRL_SCSI_PORT_OR_XCVR_ACCESSORS 693 694 /*------------------------- Language Control Element -------------------------*/ 695 struct ses_ctrl_language { 696 struct ses_ctrl_common common; 697 uint8_t bytes[1]; 698 uint8_t language_code[2]; 699 }; 700 701 enum ses_ctrl_language_field_data { 702 SES_CTRL_LANGUAGE_RQST_IDENT_BYTE = 0, 703 SES_CTRL_LANGUAGE_RQST_IDENT_MASK = 0x80, 704 SES_CTRL_LANGUAGE_RQST_IDENT_SHIFT = 7 705 }; 706 707 #define GEN_SES_CTRL_LANGUAGE_ACCESSORS(LCASE, UCASE) \ 708 GEN_ACCESSORS(ses_ctrl_language, SES_CTRL_LANGUAGE, LCASE, UCASE) 709 GEN_SES_CTRL_LANGUAGE_ACCESSORS(rqst_ident, RQST_IDENT) 710 #undef GEN_SES_CTRL_LANGUAGE_ACCESSORS 711 712 /*-------------------- Communication Port Control Element --------------------*/ 713 struct ses_ctrl_comm_port { 714 struct ses_ctrl_common common; 715 uint8_t bytes[3]; 716 }; 717 718 enum ses_ctrl_comm_port_field_data { 719 SES_CTRL_COMM_PORT_RQST_IDENT_BYTE = 0, 720 SES_CTRL_COMM_PORT_RQST_IDENT_MASK = 0x80, 721 SES_CTRL_COMM_PORT_RQST_IDENT_SHIFT = 7, 722 723 SES_CTRL_COMM_PORT_RQST_FAIL_BYTE = 0, 724 SES_CTRL_COMM_PORT_RQST_FAIL_MASK = 0x40, 725 SES_CTRL_COMM_PORT_RQST_FAIL_SHIFT = 6, 726 727 SES_CTRL_COMM_PORT_DISABLE_BYTE = 2, 728 SES_CTRL_COMM_PORT_DISABLE_MASK = 0x01, 729 SES_CTRL_COMM_PORT_DISABLE_SHIFT = 0 730 }; 731 732 #define GEN_SES_CTRL_COMM_PORT_ACCESSORS(LCASE, UCASE) \ 733 GEN_ACCESSORS(ses_ctrl_comm_port, SES_CTRL_COMM_PORT, LCASE, UCASE) 734 GEN_SES_CTRL_COMM_PORT_ACCESSORS(rqst_ident, RQST_IDENT) 735 GEN_SES_CTRL_COMM_PORT_ACCESSORS(rqst_fail, RQST_FAIL) 736 GEN_SES_CTRL_COMM_PORT_ACCESSORS(disable, DISABLE) 737 #undef GEN_SES_CTRL_COMM_PORT_ACCESSORS 738 739 /*---------------------- Voltage Sensor Control Element ----------------------*/ 740 struct ses_ctrl_voltage_sensor { 741 struct ses_ctrl_common common; 742 uint8_t bytes[3]; 743 }; 744 745 enum ses_ctrl_voltage_sensor_field_data { 746 SES_CTRL_VOLTAGE_SENSOR_RQST_IDENT_BYTE = 0, 747 SES_CTRL_VOLTAGE_SENSOR_RQST_IDENT_MASK = 0x80, 748 SES_CTRL_VOLTAGE_SENSOR_RQST_IDENT_SHIFT = 7, 749 750 SES_CTRL_VOLTAGE_SENSOR_RQST_FAIL_BYTE = 0, 751 SES_CTRL_VOLTAGE_SENSOR_RQST_FAIL_MASK = 0x40, 752 SES_CTRL_VOLTAGE_SENSOR_RQST_FAIL_SHIFT = 6 753 }; 754 755 #define GEN_SES_CTRL_VOLTAGE_SENSOR_ACCESSORS(LCASE, UCASE) \ 756 GEN_ACCESSORS(ses_ctrl_voltage_sensor, SES_CTRL_VOLTAGE_SENSOR, \ 757 LCASE, UCASE) 758 GEN_SES_CTRL_VOLTAGE_SENSOR_ACCESSORS(rqst_ident, RQST_IDENT) 759 GEN_SES_CTRL_VOLTAGE_SENSOR_ACCESSORS(rqst_fail, RQST_FAIL) 760 #undef GEN_SES_CTRL_VOLTAGE_SENSOR_ACCESSORS 761 762 /*---------------------- Current Sensor Control Element ----------------------*/ 763 struct ses_ctrl_current_sensor { 764 struct ses_ctrl_common common; 765 uint8_t bytes[3]; 766 }; 767 768 enum ses_ctrl_current_sensor_field_data { 769 SES_CTRL_CURRENT_SENSOR_RQST_IDENT_BYTE = 0, 770 SES_CTRL_CURRENT_SENSOR_RQST_IDENT_MASK = 0x80, 771 SES_CTRL_CURRENT_SENSOR_RQST_IDENT_SHIFT = 7, 772 773 SES_CTRL_CURRENT_SENSOR_RQST_FAIL_BYTE = 0, 774 SES_CTRL_CURRENT_SENSOR_RQST_FAIL_MASK = 0x40, 775 SES_CTRL_CURRENT_SENSOR_RQST_FAIL_SHIFT = 6 776 }; 777 778 #define GEN_SES_CTRL_CURRENT_SENSOR_ACCESSORS(LCASE, UCASE) \ 779 GEN_ACCESSORS(ses_ctrl_current_sensor, SES_CTRL_CURRENT_SENSOR, \ 780 LCASE, UCASE) 781 GEN_SES_CTRL_CURRENT_SENSOR_ACCESSORS(rqst_ident, RQST_IDENT) 782 GEN_SES_CTRL_CURRENT_SENSOR_ACCESSORS(rqst_fail, RQST_FAIL) 783 #undef GEN_SES_CTRL_CURRENT_SENSOR_ACCESSORS 784 785 /*--------------------- SCSI Target Port Control Element ---------------------*/ 786 struct ses_ctrl_target_port { 787 struct ses_ctrl_common common; 788 uint8_t bytes[3]; 789 }; 790 791 enum ses_ctrl_scsi_target_port_field_data { 792 SES_CTRL_TARGET_PORT_RQST_IDENT_BYTE = 0, 793 SES_CTRL_TARGET_PORT_RQST_IDENT_MASK = 0x80, 794 SES_CTRL_TARGET_PORT_RQST_IDENT_SHIFT = 7, 795 796 SES_CTRL_TARGET_PORT_RQST_FAIL_BYTE = 0, 797 SES_CTRL_TARGET_PORT_RQST_FAIL_MASK = 0x40, 798 SES_CTRL_TARGET_PORT_RQST_FAIL_SHIFT = 6, 799 800 SES_CTRL_TARGET_PORT_ENABLE_BYTE = 2, 801 SES_CTRL_TARGET_PORT_ENABLE_MASK = 0x01, 802 SES_CTRL_TARGET_PORT_ENABLE_SHIFT = 0 803 }; 804 805 #define GEN_SES_CTRL_TARGET_PORT_ACCESSORS(LCASE, UCASE) \ 806 GEN_ACCESSORS(ses_ctrl_target_port, SES_CTRL_TARGET_PORT, LCASE, UCASE) 807 GEN_SES_CTRL_TARGET_PORT_ACCESSORS(rqst_ident, RQST_IDENT) 808 GEN_SES_CTRL_TARGET_PORT_ACCESSORS(rqst_fail, RQST_FAIL) 809 GEN_SES_CTRL_TARGET_PORT_ACCESSORS(enable, ENABLE) 810 #undef GEN_SES_CTRL_TARGET_PORT_ACCESSORS 811 812 /*-------------------- SCSI Initiator Port Control Element -------------------*/ 813 struct ses_ctrl_initiator_port { 814 struct ses_ctrl_common common; 815 uint8_t bytes[3]; 816 }; 817 818 enum ses_ctrl_initiator_port_field_data { 819 SES_CTRL_INITIATOR_PORT_RQST_IDENT_BYTE = 0, 820 SES_CTRL_INITIATOR_PORT_RQST_IDENT_MASK = 0x80, 821 SES_CTRL_INITIATOR_PORT_RQST_IDENT_SHIFT = 7, 822 823 SES_CTRL_INITIATOR_PORT_RQST_FAIL_BYTE = 0, 824 SES_CTRL_INITIATOR_PORT_RQST_FAIL_MASK = 0x40, 825 SES_CTRL_INITIATOR_PORT_RQST_FAIL_SHIFT = 6, 826 827 SES_CTRL_INITIATOR_PORT_ENABLE_BYTE = 2, 828 SES_CTRL_INITIATOR_PORT_ENABLE_MASK = 0x01, 829 SES_CTRL_INITIATOR_PORT_ENABLE_SHIFT = 0 830 }; 831 832 #define GEN_SES_CTRL_INITIATOR_PORT_ACCESSORS(LCASE, UCASE) \ 833 GEN_ACCESSORS(ses_ctrl_initiator_port, SES_CTRL_INITIATOR_PORT, \ 834 LCASE, UCASE) 835 GEN_SES_CTRL_INITIATOR_PORT_ACCESSORS(rqst_ident, RQST_IDENT) 836 GEN_SES_CTRL_INITIATOR_PORT_ACCESSORS(rqst_fail, RQST_FAIL) 837 GEN_SES_CTRL_INITIATOR_PORT_ACCESSORS(enable, ENABLE) 838 #undef GEN_SES_CTRL_INITIATOR_PORT_ACCESSORS 839 840 /*-------------------- Simple Subenclosure Control Element -------------------*/ 841 struct ses_ctrl_simple_subenc { 842 struct ses_ctrl_common common; 843 uint8_t bytes[3]; 844 }; 845 846 enum ses_ctrl_simple_subenc_field_data { 847 SES_CTRL_SIMPlE_SUBSES_RQST_IDENT_BYTE = 0, 848 SES_CTRL_SIMPlE_SUBSES_RQST_IDENT_MASK = 0x80, 849 SES_CTRL_SIMPlE_SUBSES_RQST_IDENT_SHIFT = 7, 850 851 SES_CTRL_SIMPlE_SUBSES_RQST_FAIL_BYTE = 0, 852 SES_CTRL_SIMPlE_SUBSES_RQST_FAIL_MASK = 0x40, 853 SES_CTRL_SIMPlE_SUBSES_RQST_FAIL_SHIFT = 6 854 }; 855 856 #define GEN_SES_CTRL_SIMPlE_SUBSES_ACCESSORS(LCASE, UCASE) \ 857 GEN_ACCESSORS(ses_ctrl_simple_subenc, SES_CTRL_SIMPlE_SUBSES, \ 858 LCASE, UCASE) 859 GEN_SES_CTRL_SIMPlE_SUBSES_ACCESSORS(rqst_ident, RQST_IDENT) 860 GEN_SES_CTRL_SIMPlE_SUBSES_ACCESSORS(rqst_fail, RQST_FAIL) 861 #undef GEN_SES_CTRL_SIMPlE_SUBSES_ACCESSORS 862 863 /*----------------------- SAS Expander Control Element -----------------------*/ 864 struct ses_ctrl_sas_expander { 865 struct ses_ctrl_common common; 866 uint8_t bytes[3]; 867 }; 868 869 enum ses_ctrl_sas_expander_field_data { 870 SES_CTRL_SAS_EXPANDER_RQST_IDENT_BYTE = 0, 871 SES_CTRL_SAS_EXPANDER_RQST_IDENT_MASK = 0x80, 872 SES_CTRL_SAS_EXPANDER_RQST_IDENT_SHIFT = 7, 873 874 SES_CTRL_SAS_EXPANDER_RQST_FAIL_BYTE = 0, 875 SES_CTRL_SAS_EXPANDER_RQST_FAIL_MASK = 0x40, 876 SES_CTRL_SAS_EXPANDER_RQST_FAIL_SHIFT = 6 877 }; 878 879 #define GEN_SES_CTRL_SAS_EXPANDER_ACCESSORS(LCASE, UCASE) \ 880 GEN_ACCESSORS(ses_ctrl_sas_expander, SES_CTRL_SAS_EXPANDER, LCASE, UCASE) 881 GEN_SES_CTRL_SAS_EXPANDER_ACCESSORS(rqst_ident, RQST_IDENT) 882 GEN_SES_CTRL_SAS_EXPANDER_ACCESSORS(rqst_fail, RQST_FAIL) 883 #undef GEN_SES_CTRL_SAS_EXPANDER_ACCESSORS 884 885 /*----------------------- SAS Connector Control Element ----------------------*/ 886 struct ses_ctrl_sas_connector { 887 struct ses_ctrl_common common; 888 uint8_t bytes[3]; 889 }; 890 891 enum ses_ctrl_sas_connector_field_data { 892 SES_CTRL_SAS_CONNECTOR_RQST_IDENT_BYTE = 0, 893 SES_CTRL_SAS_CONNECTOR_RQST_IDENT_MASK = 0x80, 894 SES_CTRL_SAS_CONNECTOR_RQST_IDENT_SHIFT = 7, 895 896 SES_CTRL_SAS_CONNECTOR_RQST_FAIL_BYTE = 2, 897 SES_CTRL_SAS_CONNECTOR_RQST_FAIL_MASK = 0x40, 898 SES_CTRL_SAS_CONNECTOR_RQST_FAIL_SHIFT = 6 899 }; 900 901 #define GEN_SES_CTRL_SAS_CONNECTOR_ACCESSORS(LCASE, UCASE) \ 902 GEN_ACCESSORS(ses_ctrl_sas_connector, SES_CTRL_SAS_CONNECTOR, \ 903 LCASE, UCASE) 904 GEN_SES_CTRL_SAS_CONNECTOR_ACCESSORS(rqst_ident, RQST_IDENT) 905 GEN_SES_CTRL_SAS_CONNECTOR_ACCESSORS(rqst_fail, RQST_FAIL) 906 #undef GEN_SES_CTRL_SAS_CONNECTOR_ACCESSORS 907 908 /*------------------------- Universal Control Element ------------------------*/ 909 union ses_ctrl_element { 910 struct ses_ctrl_common common; 911 struct ses_ctrl_dev_slot dev_slot; 912 struct ses_ctrl_array_dev_slot array_dev_slot; 913 struct ses_ctrl_power_supply power_supply; 914 struct ses_ctrl_cooling cooling; 915 struct ses_ctrl_temp_sensor temp_sensor; 916 struct ses_ctrl_door_lock door_lock; 917 struct ses_ctrl_audible_alarm audible_alarm; 918 struct ses_ctrl_ecc_electronics ecc_electronics; 919 struct ses_ctrl_scc_electronics scc_electronics; 920 struct ses_ctrl_nv_cache nv_cache; 921 struct ses_ctrl_invalid_op_reason invalid_op_reason; 922 struct ses_ctrl_ups ups; 923 struct ses_ctrl_display display; 924 struct ses_ctrl_key_pad_entry key_pad_entry; 925 struct ses_ctrl_scsi_port_or_xcvr scsi_port_or_xcvr; 926 struct ses_ctrl_language language; 927 struct ses_ctrl_comm_port comm_port; 928 struct ses_ctrl_voltage_sensor voltage_sensor; 929 struct ses_ctrl_current_sensor current_sensor; 930 struct ses_ctrl_target_port target_port; 931 struct ses_ctrl_initiator_port initiator_port; 932 struct ses_ctrl_simple_subenc simple_subenc; 933 struct ses_ctrl_sas_expander sas_expander; 934 struct ses_ctrl_sas_connector sas_connector; 935 }; 936 937 /*--------------------- SCSI SES Control Diagnostic Page ---------------------*/ 938 struct ses_ctrl_page { 939 struct ses_page_hdr hdr; 940 union ses_ctrl_element elements[]; 941 }; 942 943 enum ses_ctrl_page_field_data { 944 SES_CTRL_PAGE_INFO_MASK = 0x08, 945 SES_CTRL_PAGE_INFO_SHIFT = 3, 946 947 SES_CTRL_PAGE_NON_CRIT_MASK = 0x04, 948 SES_CTRL_PAGE_NON_CRIT_SHIFT = 2, 949 950 SES_CTRL_PAGE_CRIT_MASK = 0x02, 951 SES_CTRL_PAGE_CRIT_SHIFT = 1, 952 953 SES_CTRL_PAGE_UNRECOV_MASK = 0x01, 954 SES_CTRL_PAGE_UNRECOV_SHIFT = 0 955 }; 956 957 #define GEN_SES_CTRL_PAGE_ACCESSORS(LCASE, UCASE) \ 958 GEN_HDR_ACCESSORS(ses_ctrl_page, SES_CTRL_PAGE, LCASE, UCASE) 959 960 GEN_SES_CTRL_PAGE_ACCESSORS(info, INFO) 961 GEN_SES_CTRL_PAGE_ACCESSORS(non_crit, NON_CRIT) 962 GEN_SES_CTRL_PAGE_ACCESSORS(crit, CRIT) 963 GEN_SES_CTRL_PAGE_ACCESSORS(unrecov, UNRECOV) 964 #undef GEN_SES_CTRL_PAGE_ACCESSORS 965 966 /*================= SCSI SES Status Diagnostic Page Structures ===============*/ 967 struct ses_status_common { 968 uint8_t bytes[1]; 969 }; 970 971 enum ses_status_common_field_data { 972 SES_STATUS_COMMON_PRDFAIL_BYTE = 0, 973 SES_STATUS_COMMON_PRDFAIL_MASK = 0x40, 974 SES_STATUS_COMMON_PRDFAIL_SHIFT = 6, 975 976 SES_STATUS_COMMON_DISABLED_BYTE = 0, 977 SES_STATUS_COMMON_DISABLED_MASK = 0x20, 978 SES_STATUS_COMMON_DISABLED_SHIFT = 5, 979 980 SES_STATUS_COMMON_SWAP_BYTE = 0, 981 SES_STATUS_COMMON_SWAP_MASK = 0x10, 982 SES_STATUS_COMMON_SWAP_SHIFT = 4, 983 984 SES_STATUS_COMMON_ELEMENT_STATUS_CODE_BYTE = 0, 985 SES_STATUS_COMMON_ELEMENT_STATUS_CODE_MASK = 0x0F, 986 SES_STATUS_COMMON_ELEMENT_STATUS_CODE_SHIFT = 0 987 }; 988 989 #define GEN_SES_STATUS_COMMON_ACCESSORS(LCASE, UCASE) \ 990 GEN_GETTER(ses_status_common, SES_STATUS_COMMON, LCASE, UCASE) 991 992 GEN_SES_STATUS_COMMON_ACCESSORS(prdfail, PRDFAIL) 993 GEN_SES_STATUS_COMMON_ACCESSORS(disabled, DISABLED) 994 GEN_SES_STATUS_COMMON_ACCESSORS(swap, SWAP) 995 GEN_SES_STATUS_COMMON_ACCESSORS(element_status_code, ELEMENT_STATUS_CODE) 996 #undef GEN_SES_STATUS_COMMON_ACCESSORS 997 998 /*------------------------- Device Slot Status Element -----------------------*/ 999 struct ses_status_dev_slot { 1000 struct ses_status_common common; 1001 uint8_t slot_address; 1002 uint8_t bytes[2]; 1003 }; 1004 1005 enum ses_status_dev_slot_field_data { 1006 SES_STATUS_DEV_SLOT_APP_CLIENT_BYPED_A_BYTE = 0, 1007 SES_STATUS_DEV_SLOT_APP_CLIENT_BYPED_A_MASK = 0x80, 1008 SES_STATUS_DEV_SLOT_APP_CLIENT_BYPED_A_SHIFT = 7, 1009 1010 SES_STATUS_DEV_SLOT_DO_NOT_REMOVE_BYTE = 0, 1011 SES_STATUS_DEV_SLOT_DO_NOT_REMOVE_MASK = 0x40, 1012 SES_STATUS_DEV_SLOT_DO_NOT_REMOVE_SHIFT = 6, 1013 1014 SES_STATUS_DEV_SLOT_ENCLOSURE_BYPED_A_BYTE = 0, 1015 SES_STATUS_DEV_SLOT_ENCLOSURE_BYPED_A_MASK = 0x20, 1016 SES_STATUS_DEV_SLOT_ENCLOSURE_BYPED_A_SHIFT = 5, 1017 1018 SES_STATUS_DEV_SLOT_ENCLOSURE_BYPED_B_BYTE = 0, 1019 SES_STATUS_DEV_SLOT_ENCLOSURE_BYPED_B_MASK = 0x10, 1020 SES_STATUS_DEV_SLOT_ENCLOSURE_BYPED_B_SHIFT = 4, 1021 1022 SES_STATUS_DEV_SLOT_INSERT_READY_BYTE = 0, 1023 SES_STATUS_DEV_SLOT_INSERT_READY_MASK = 0x08, 1024 SES_STATUS_DEV_SLOT_INSERT_READY_SHIFT = 3, 1025 1026 SES_STATUS_DEV_SLOT_REMOVE_BYTE = 0, 1027 SES_STATUS_DEV_SLOT_REMOVE_MASK = 0x04, 1028 SES_STATUS_DEV_SLOT_REMOVE_SHIFT = 2, 1029 1030 SES_STATUS_DEV_SLOT_IDENT_BYTE = 0, 1031 SES_STATUS_DEV_SLOT_IDENT_MASK = 0x02, 1032 SES_STATUS_DEV_SLOT_IDENT_SHIFT = 1, 1033 1034 SES_STATUS_DEV_SLOT_REPORT_BYTE = 0, 1035 SES_STATUS_DEV_SLOT_REPORT_MASK = 0x01, 1036 SES_STATUS_DEV_SLOT_REPORT_SHIFT = 0, 1037 1038 SES_STATUS_DEV_SLOT_APP_CLIENT_BYPED_B_BYTE = 1, 1039 SES_STATUS_DEV_SLOT_APP_CLIENT_BYPED_B_MASK = 0x80, 1040 SES_STATUS_DEV_SLOT_APP_CLIENT_BYPED_B_SHIFT = 7, 1041 1042 SES_STATUS_DEV_SLOT_FAULT_SENSED_BYTE = 1, 1043 SES_STATUS_DEV_SLOT_FAULT_SENSED_MASK = 0x40, 1044 SES_STATUS_DEV_SLOT_FAULT_SENSED_SHIFT = 6, 1045 1046 SES_STATUS_DEV_SLOT_FAULT_REQUESTED_BYTE = 1, 1047 SES_STATUS_DEV_SLOT_FAULT_REQUESTED_MASK = 0x20, 1048 SES_STATUS_DEV_SLOT_FAULT_REQUESTED_SHIFT = 5, 1049 1050 SES_STATUS_DEV_SLOT_DEVICE_OFF_BYTE = 1, 1051 SES_STATUS_DEV_SLOT_DEVICE_OFF_MASK = 0x10, 1052 SES_STATUS_DEV_SLOT_DEVICE_OFF_SHIFT = 4, 1053 1054 SES_STATUS_DEV_SLOT_BYPED_A_BYTE = 1, 1055 SES_STATUS_DEV_SLOT_BYPED_A_MASK = 0x08, 1056 SES_STATUS_DEV_SLOT_BYPED_A_SHIFT = 3, 1057 1058 SES_STATUS_DEV_SLOT_BYPED_B_BYTE = 1, 1059 SES_STATUS_DEV_SLOT_BYPED_B_MASK = 0x04, 1060 SES_STATUS_DEV_SLOT_BYPED_B_SHIFT = 2, 1061 1062 SES_STATUS_DEV_SLOT_DEVICE_BYPED_A_BYTE = 1, 1063 SES_STATUS_DEV_SLOT_DEVICE_BYPED_A_MASK = 0x02, 1064 SES_STATUS_DEV_SLOT_DEVICE_BYPED_A_SHIFT = 1, 1065 1066 SES_STATUS_DEV_SLOT_DEVICE_BYPED_B_BYTE = 1, 1067 SES_STATUS_DEV_SLOT_DEVICE_BYPED_B_MASK = 0x01, 1068 SES_STATUS_DEV_SLOT_DEVICE_BYPED_B_SHIFT = 0 1069 }; 1070 #define GEN_SES_STATUS_DEV_SLOT_ACCESSORS(LCASE, UCASE) \ 1071 GEN_GETTER(ses_status_dev_slot, SES_STATUS_DEV_SLOT, LCASE, UCASE) 1072 1073 GEN_SES_STATUS_DEV_SLOT_ACCESSORS(app_client_byped_a, APP_CLIENT_BYPED_A) 1074 GEN_SES_STATUS_DEV_SLOT_ACCESSORS(do_not_remove, DO_NOT_REMOVE) 1075 GEN_SES_STATUS_DEV_SLOT_ACCESSORS(enclosure_byped_a, ENCLOSURE_BYPED_A) 1076 GEN_SES_STATUS_DEV_SLOT_ACCESSORS(enclosure_byped_b, ENCLOSURE_BYPED_B) 1077 GEN_SES_STATUS_DEV_SLOT_ACCESSORS(insert_ready, INSERT_READY) 1078 GEN_SES_STATUS_DEV_SLOT_ACCESSORS(remove, REMOVE) 1079 GEN_SES_STATUS_DEV_SLOT_ACCESSORS(ident, IDENT) 1080 GEN_SES_STATUS_DEV_SLOT_ACCESSORS(report, REPORT) 1081 GEN_SES_STATUS_DEV_SLOT_ACCESSORS(app_client_byped_b, APP_CLIENT_BYPED_B) 1082 GEN_SES_STATUS_DEV_SLOT_ACCESSORS(fault_sensed, FAULT_SENSED) 1083 GEN_SES_STATUS_DEV_SLOT_ACCESSORS(fault_requested, FAULT_REQUESTED) 1084 GEN_SES_STATUS_DEV_SLOT_ACCESSORS(device_off, DEVICE_OFF) 1085 GEN_SES_STATUS_DEV_SLOT_ACCESSORS(byped_a, BYPED_A) 1086 GEN_SES_STATUS_DEV_SLOT_ACCESSORS(byped_b, BYPED_B) 1087 GEN_SES_STATUS_DEV_SLOT_ACCESSORS(device_byped_a, DEVICE_BYPED_A) 1088 GEN_SES_STATUS_DEV_SLOT_ACCESSORS(device_byped_b, DEVICE_BYPED_B) 1089 #undef GEN_SES_STATUS_DEV_SLOT_ACCESSORS 1090 1091 /*---------------------- Array Device Slot Status Element --------------------*/ 1092 struct ses_status_array_dev_slot { 1093 struct ses_status_common common; 1094 uint8_t bytes[3]; 1095 }; 1096 1097 enum ses_status_array_dev_slot_field_data { 1098 SES_STATUS_ARRAY_DEV_SLOT_OK_BYTE = 0, 1099 SES_STATUS_ARRAY_DEV_SLOT_OK_MASK = 0x80, 1100 SES_STATUS_ARRAY_DEV_SLOT_OK_SHIFT = 7, 1101 1102 SES_STATUS_ARRAY_DEV_SLOT_RSVD_DEVICE_BYTE = 0, 1103 SES_STATUS_ARRAY_DEV_SLOT_RSVD_DEVICE_MASK = 0x40, 1104 SES_STATUS_ARRAY_DEV_SLOT_RSVD_DEVICE_SHIFT = 6, 1105 1106 SES_STATUS_ARRAY_DEV_SLOT_HOT_SPARE_BYTE = 0, 1107 SES_STATUS_ARRAY_DEV_SLOT_HOT_SPARE_MASK = 0x20, 1108 SES_STATUS_ARRAY_DEV_SLOT_HOT_SPARE_SHIFT = 5, 1109 1110 SES_STATUS_ARRAY_DEV_SLOT_CONS_CHECK_BYTE = 0, 1111 SES_STATUS_ARRAY_DEV_SLOT_CONS_CHECK_MASK = 0x10, 1112 SES_STATUS_ARRAY_DEV_SLOT_CONS_CHECK_SHIFT = 4, 1113 1114 SES_STATUS_ARRAY_DEV_SLOT_IN_CRIT_ARRAY_BYTE = 0, 1115 SES_STATUS_ARRAY_DEV_SLOT_IN_CRIT_ARRAY_MASK = 0x08, 1116 SES_STATUS_ARRAY_DEV_SLOT_IN_CRIT_ARRAY_SHIFT = 3, 1117 1118 SES_STATUS_ARRAY_DEV_SLOT_IN_FAILED_ARRAY_BYTE = 0, 1119 SES_STATUS_ARRAY_DEV_SLOT_IN_FAILED_ARRAY_MASK = 0x04, 1120 SES_STATUS_ARRAY_DEV_SLOT_IN_FAILED_ARRAY_SHIFT = 2, 1121 1122 SES_STATUS_ARRAY_DEV_SLOT_REBUILD_REMAP_BYTE = 0, 1123 SES_STATUS_ARRAY_DEV_SLOT_REBUILD_REMAP_MASK = 0x02, 1124 SES_STATUS_ARRAY_DEV_SLOT_REBUILD_REMAP_SHIFT = 1, 1125 1126 SES_STATUS_ARRAY_DEV_SLOT_REBUILD_REMAP_ABORT_BYTE = 0, 1127 SES_STATUS_ARRAY_DEV_SLOT_REBUILD_REMAP_ABORT_MASK = 0x01, 1128 SES_STATUS_ARRAY_DEV_SLOT_REBUILD_REMAP_ABORT_SHIFT = 0 1129 1130 /* 1131 * The remaining fields are identical to the device 1132 * slot element type. Access them through the device slot 1133 * element type and its accessors. 1134 */ 1135 }; 1136 #define GEN_SES_STATUS_ARRAY_DEV_SLOT_ACCESSORS(LCASE, UCASE) \ 1137 GEN_GETTER(ses_status_array_dev_slot, SES_STATUS_ARRAY_DEV_SLOT, \ 1138 LCASE, UCASE) 1139 GEN_SES_STATUS_ARRAY_DEV_SLOT_ACCESSORS(ok, OK) 1140 GEN_SES_STATUS_ARRAY_DEV_SLOT_ACCESSORS(rsvd_device, RSVD_DEVICE) 1141 GEN_SES_STATUS_ARRAY_DEV_SLOT_ACCESSORS(hot_spare, HOT_SPARE) 1142 GEN_SES_STATUS_ARRAY_DEV_SLOT_ACCESSORS(cons_check, CONS_CHECK) 1143 GEN_SES_STATUS_ARRAY_DEV_SLOT_ACCESSORS(in_crit_array, IN_CRIT_ARRAY) 1144 GEN_SES_STATUS_ARRAY_DEV_SLOT_ACCESSORS(in_failed_array, IN_FAILED_ARRAY) 1145 GEN_SES_STATUS_ARRAY_DEV_SLOT_ACCESSORS(rebuild_remap, REBUILD_REMAP) 1146 GEN_SES_STATUS_ARRAY_DEV_SLOT_ACCESSORS(rebuild_remap_abort, 1147 REBUILD_REMAP_ABORT) 1148 #undef GEN_SES_STATUS_ARRAY_DEV_SLOT_ACCESSORS 1149 1150 /*----------------------- Power Supply Status Element ------------------------*/ 1151 struct ses_status_power_supply { 1152 struct ses_status_common common; 1153 uint8_t bytes[3]; 1154 }; 1155 1156 enum ses_status_power_supply_field_data { 1157 SES_STATUS_POWER_SUPPLY_IDENT_BYTE = 0, 1158 SES_STATUS_POWER_SUPPLY_IDENT_MASK = 0x80, 1159 SES_STATUS_POWER_SUPPLY_IDENT_SHIFT = 7, 1160 1161 SES_STATUS_POWER_SUPPLY_DC_OVER_VOLTAGE_BYTE = 1, 1162 SES_STATUS_POWER_SUPPLY_DC_OVER_VOLTAGE_MASK = 0x08, 1163 SES_STATUS_POWER_SUPPLY_DC_OVER_VOLTAGE_SHIFT = 3, 1164 1165 SES_STATUS_POWER_SUPPLY_DC_UNDER_VOLTAGE_BYTE = 1, 1166 SES_STATUS_POWER_SUPPLY_DC_UNDER_VOLTAGE_MASK = 0x04, 1167 SES_STATUS_POWER_SUPPLY_DC_UNDER_VOLTAGE_SHIFT = 2, 1168 1169 SES_STATUS_POWER_SUPPLY_DC_OVER_CURRENT_BYTE = 1, 1170 SES_STATUS_POWER_SUPPLY_DC_OVER_CURRENT_MASK = 0x02, 1171 SES_STATUS_POWER_SUPPLY_DC_OVER_CURRENT_SHIFT = 1, 1172 1173 SES_STATUS_POWER_SUPPLY_HOT_SWAP_BYTE = 2, 1174 SES_STATUS_POWER_SUPPLY_HOT_SWAP_MASK = 0x80, 1175 SES_STATUS_POWER_SUPPLY_HOT_SWAP_SHIFT = 7, 1176 1177 SES_STATUS_POWER_SUPPLY_FAIL_BYTE = 2, 1178 SES_STATUS_POWER_SUPPLY_FAIL_MASK = 0x40, 1179 SES_STATUS_POWER_SUPPLY_FAIL_SHIFT = 6, 1180 1181 SES_STATUS_POWER_SUPPLY_REQUESTED_ON_BYTE = 2, 1182 SES_STATUS_POWER_SUPPLY_REQUESTED_ON_MASK = 0x20, 1183 SES_STATUS_POWER_SUPPLY_REQUESTED_ON_SHIFT = 5, 1184 1185 SES_STATUS_POWER_SUPPLY_OFF_BYTE = 2, 1186 SES_STATUS_POWER_SUPPLY_OFF_MASK = 0x10, 1187 SES_STATUS_POWER_SUPPLY_OFF_SHIFT = 4, 1188 1189 SES_STATUS_POWER_SUPPLY_OVERTMP_FAIL_BYTE = 2, 1190 SES_STATUS_POWER_SUPPLY_OVERTMP_FAIL_MASK = 0x08, 1191 SES_STATUS_POWER_SUPPLY_OVERTMP_FAIL_SHIFT = 3, 1192 1193 SES_STATUS_POWER_SUPPLY_TEMP_WARN_BYTE = 2, 1194 SES_STATUS_POWER_SUPPLY_TEMP_WARN_MASK = 0x04, 1195 SES_STATUS_POWER_SUPPLY_TEMP_WARN_SHIFT = 2, 1196 1197 SES_STATUS_POWER_SUPPLY_AC_FAIL_BYTE = 2, 1198 SES_STATUS_POWER_SUPPLY_AC_FAIL_MASK = 0x02, 1199 SES_STATUS_POWER_SUPPLY_AC_FAIL_SHIFT = 1, 1200 1201 SES_STATUS_POWER_SUPPLY_DC_FAIL_BYTE = 2, 1202 SES_STATUS_POWER_SUPPLY_DC_FAIL_MASK = 0x01, 1203 SES_STATUS_POWER_SUPPLY_DC_FAIL_SHIFT = 0 1204 }; 1205 1206 #define GEN_SES_STATUS_POWER_SUPPLY_ACCESSORS(LCASE, UCASE) \ 1207 GEN_GETTER(ses_status_power_supply, SES_STATUS_POWER_SUPPLY, LCASE, UCASE) 1208 GEN_SES_STATUS_POWER_SUPPLY_ACCESSORS(ident, IDENT) 1209 GEN_SES_STATUS_POWER_SUPPLY_ACCESSORS(dc_over_voltage, DC_OVER_VOLTAGE) 1210 GEN_SES_STATUS_POWER_SUPPLY_ACCESSORS(dc_under_voltage, DC_UNDER_VOLTAGE) 1211 GEN_SES_STATUS_POWER_SUPPLY_ACCESSORS(dc_over_current, DC_OVER_CURRENT) 1212 GEN_SES_STATUS_POWER_SUPPLY_ACCESSORS(hot_swap, HOT_SWAP) 1213 GEN_SES_STATUS_POWER_SUPPLY_ACCESSORS(fail, FAIL) 1214 GEN_SES_STATUS_POWER_SUPPLY_ACCESSORS(requested_on, REQUESTED_ON) 1215 GEN_SES_STATUS_POWER_SUPPLY_ACCESSORS(off, OFF) 1216 GEN_SES_STATUS_POWER_SUPPLY_ACCESSORS(overtmp_fail, OVERTMP_FAIL) 1217 GEN_SES_STATUS_POWER_SUPPLY_ACCESSORS(temp_warn, TEMP_WARN) 1218 GEN_SES_STATUS_POWER_SUPPLY_ACCESSORS(ac_fail, AC_FAIL) 1219 GEN_SES_STATUS_POWER_SUPPLY_ACCESSORS(dc_fail, DC_FAIL) 1220 #undef GEN_SES_STATUS_POWER_SUPPLY_ACCESSORS 1221 1222 /*-------------------------- Cooling Status Element --------------------------*/ 1223 struct ses_status_cooling { 1224 struct ses_status_common common; 1225 uint8_t bytes[3]; 1226 }; 1227 1228 enum ses_status_cooling_field_data { 1229 SES_STATUS_COOLING_IDENT_BYTE = 0, 1230 SES_STATUS_COOLING_IDENT_MASK = 0x80, 1231 SES_STATUS_COOLING_IDENT_SHIFT = 7, 1232 1233 SES_STATUS_COOLING_ACTUAL_FAN_SPEED_MSB_BYTE = 0, 1234 SES_STATUS_COOLING_ACTUAL_FAN_SPEED_MSB_MASK = 0x07, 1235 SES_STATUS_COOLING_ACTUAL_FAN_SPEED_MSB_SHIFT = 0, 1236 1237 SES_STATUS_COOLING_ACTUAL_FAN_SPEED_LSB_BYTE = 1, 1238 SES_STATUS_COOLING_ACTUAL_FAN_SPEED_LSB_MASK = 0xFF, 1239 SES_STATUS_COOLING_ACTUAL_FAN_SPEED_LSB_SHIFT = 0, 1240 1241 SES_STATUS_COOLING_HOT_SWAP_BYTE = 2, 1242 SES_STATUS_COOLING_HOT_SWAP_MASK = 0x40, 1243 SES_STATUS_COOLING_HOT_SWAP_SHIFT = 6, 1244 1245 SES_STATUS_COOLING_FAIL_BYTE = 2, 1246 SES_STATUS_COOLING_FAIL_MASK = 0x40, 1247 SES_STATUS_COOLING_FAIL_SHIFT = 6, 1248 1249 SES_STATUS_COOLING_REQUESTED_ON_BYTE = 2, 1250 SES_STATUS_COOLING_REQUESTED_ON_MASK = 0x20, 1251 SES_STATUS_COOLING_REQUESTED_ON_SHIFT = 5, 1252 1253 SES_STATUS_COOLING_OFF_BYTE = 2, 1254 SES_STATUS_COOLING_OFF_MASK = 0x20, 1255 SES_STATUS_COOLING_OFF_SHIFT = 5, 1256 1257 SES_STATUS_COOLING_ACTUAL_SPEED_CODE_BYTE = 2, 1258 SES_STATUS_COOLING_ACTUAL_SPEED_CODE_MASK = 0x07, 1259 SES_STATUS_COOLING_ACTUAL_SPEED_CODE_SHIFT = 2, 1260 SES_STATUS_COOLING_ACTUAL_SPEED_CODE_STOPPED = 0x00, 1261 SES_STATUS_COOLING_ACTUAL_SPEED_CODE_LOWEST = 0x01, 1262 SES_STATUS_COOLING_ACTUAL_SPEED_CODE_HIGHEST = 0x07 1263 }; 1264 1265 #define GEN_SES_STATUS_COOLING_ACCESSORS(LCASE, UCASE) \ 1266 GEN_GETTER(ses_status_cooling, SES_STATUS_COOLING, LCASE, UCASE) 1267 GEN_SES_STATUS_COOLING_ACCESSORS(ident, IDENT) 1268 GEN_SES_STATUS_COOLING_ACCESSORS(actual_fan_speed_msb, ACTUAL_FAN_SPEED_MSB) 1269 GEN_SES_STATUS_COOLING_ACCESSORS(actual_fan_speed_lsb, ACTUAL_FAN_SPEED_LSB) 1270 GEN_SES_STATUS_COOLING_ACCESSORS(hot_swap, HOT_SWAP) 1271 GEN_SES_STATUS_COOLING_ACCESSORS(fail, FAIL) 1272 GEN_SES_STATUS_COOLING_ACCESSORS(requested_on, REQUESTED_ON) 1273 GEN_SES_STATUS_COOLING_ACCESSORS(off, OFF) 1274 GEN_SES_STATUS_COOLING_ACCESSORS(actual_speed_code, ACTUAL_SPEED_CODE) 1275 #undef GEN_SES_STATUS_COOLING_ACCESSORS 1276 1277 static inline int 1278 ses_status_cooling_get_actual_fan_speed(struct ses_status_cooling *elem) 1279 { 1280 return (ses_status_cooling_get_actual_fan_speed_msb(elem) << 8 1281 | ses_status_cooling_get_actual_fan_speed_lsb(elem)); 1282 } 1283 1284 /*-------------------- Temperature Sensor Status Element ---------------------*/ 1285 struct ses_status_temp_sensor { 1286 struct ses_status_common common; 1287 uint8_t bytes[3]; 1288 }; 1289 1290 enum ses_status_temp_sensor_field_data { 1291 SES_STATUS_TEMP_SENSOR_IDENT_BYTE = 0, 1292 SES_STATUS_TEMP_SENSOR_IDENT_MASK = 0x80, 1293 SES_STATUS_TEMP_SENSOR_IDENT_SHIFT = 7, 1294 1295 SES_STATUS_TEMP_SENSOR_FAIL_BYTE = 0, 1296 SES_STATUS_TEMP_SENSOR_FAIL_MASK = 0x40, 1297 SES_STATUS_TEMP_SENSOR_FAIL_SHIFT = 6, 1298 1299 SES_STATUS_TEMP_SENSOR_TEMPERATURE_BYTE = 1, 1300 SES_STATUS_TEMP_SENSOR_TEMPERATURE_MASK = 0xFF, 1301 SES_STATUS_TEMP_SENSOR_TEMPERATURE_SHIFT = 0, 1302 1303 SES_STATUS_TEMP_SENSOR_OT_FAILURE_BYTE = 2, 1304 SES_STATUS_TEMP_SENSOR_OT_FAILURE_MASK = 0x08, 1305 SES_STATUS_TEMP_SENSOR_OT_FAILURE_SHIFT = 3, 1306 1307 SES_STATUS_TEMP_SENSOR_OT_WARNING_BYTE = 2, 1308 SES_STATUS_TEMP_SENSOR_OT_WARNING_MASK = 0x04, 1309 SES_STATUS_TEMP_SENSOR_OT_WARNING_SHIFT = 2, 1310 1311 SES_STATUS_TEMP_SENSOR_UT_FAILURE_BYTE = 2, 1312 SES_STATUS_TEMP_SENSOR_UT_FAILURE_MASK = 0x02, 1313 SES_STATUS_TEMP_SENSOR_UT_FAILURE_SHIFT = 1, 1314 1315 SES_STATUS_TEMP_SENSOR_UT_WARNING_BYTE = 2, 1316 SES_STATUS_TEMP_SENSOR_UT_WARNING_MASK = 0x01, 1317 SES_STATUS_TEMP_SENSOR_UT_WARNING_SHIFT = 0 1318 }; 1319 1320 #define GEN_SES_STATUS_TEMP_SENSOR_ACCESSORS(LCASE, UCASE) \ 1321 GEN_GETTER(ses_status_temp_sensor, SES_STATUS_TEMP_SENSOR, LCASE, UCASE) 1322 GEN_SES_STATUS_TEMP_SENSOR_ACCESSORS(ident, IDENT) 1323 GEN_SES_STATUS_TEMP_SENSOR_ACCESSORS(fail, FAIL) 1324 GEN_SES_STATUS_TEMP_SENSOR_ACCESSORS(temperature, TEMPERATURE) 1325 GEN_SES_STATUS_TEMP_SENSOR_ACCESSORS(ot_failure, OT_FAILURE) 1326 GEN_SES_STATUS_TEMP_SENSOR_ACCESSORS(ot_warning, OT_WARNING) 1327 GEN_SES_STATUS_TEMP_SENSOR_ACCESSORS(ut_failure, UT_FAILURE) 1328 GEN_SES_STATUS_TEMP_SENSOR_ACCESSORS(ut_warning, UT_WARNING) 1329 #undef GEN_SES_STATUS_TEMP_SENSOR_ACCESSORS 1330 1331 /*------------------------- Door Lock Status Element -------------------------*/ 1332 struct ses_status_door_lock { 1333 struct ses_status_common common; 1334 uint8_t bytes[3]; 1335 }; 1336 1337 enum ses_status_door_lock_field_data { 1338 SES_STATUS_DOOR_LOCK_IDENT_BYTE = 0, 1339 SES_STATUS_DOOR_LOCK_IDENT_MASK = 0x80, 1340 SES_STATUS_DOOR_LOCK_IDENT_SHIFT = 7, 1341 1342 SES_STATUS_DOOR_LOCK_FAIL_BYTE = 0, 1343 SES_STATUS_DOOR_LOCK_FAIL_MASK = 0x40, 1344 SES_STATUS_DOOR_LOCK_FAIL_SHIFT = 6, 1345 1346 SES_STATUS_DOOR_LOCK_UNLOCKED_BYTE = 2, 1347 SES_STATUS_DOOR_LOCK_UNLOCKED_MASK = 0x01, 1348 SES_STATUS_DOOR_LOCK_UNLOCKED_SHIFT = 0 1349 }; 1350 1351 #define GEN_SES_STATUS_DOOR_LOCK_ACCESSORS(LCASE, UCASE) \ 1352 GEN_GETTER(ses_status_door_lock, SES_STATUS_DOOR_LOCK, LCASE, UCASE) 1353 GEN_SES_STATUS_DOOR_LOCK_ACCESSORS(ident, IDENT) 1354 GEN_SES_STATUS_DOOR_LOCK_ACCESSORS(fail, FAIL) 1355 GEN_SES_STATUS_DOOR_LOCK_ACCESSORS(unlocked, UNLOCKED) 1356 #undef GEN_SES_STATUS_DOOR_LOCK_ACCESSORS 1357 1358 /*----------------------- Audible Alarm Status Element -----------------------*/ 1359 struct ses_status_audible_alarm { 1360 struct ses_status_common common; 1361 uint8_t bytes[3]; 1362 }; 1363 1364 enum ses_status_audible_alarm_field_data { 1365 SES_STATUS_AUDIBLE_ALARM_IDENT_BYTE = 0, 1366 SES_STATUS_AUDIBLE_ALARM_IDENT_MASK = 0x80, 1367 SES_STATUS_AUDIBLE_ALARM_IDENT_SHIFT = 7, 1368 1369 SES_STATUS_AUDIBLE_ALARM_FAIL_BYTE = 0, 1370 SES_STATUS_AUDIBLE_ALARM_FAIL_MASK = 0x40, 1371 SES_STATUS_AUDIBLE_ALARM_FAIL_SHIFT = 6, 1372 1373 SES_STATUS_AUDIBLE_ALARM_RQST_MUTE_BYTE = 2, 1374 SES_STATUS_AUDIBLE_ALARM_RQST_MUTE_MASK = 0x80, 1375 SES_STATUS_AUDIBLE_ALARM_RQST_MUTE_SHIFT = 7, 1376 1377 SES_STATUS_AUDIBLE_ALARM_MUTED_BYTE = 2, 1378 SES_STATUS_AUDIBLE_ALARM_MUTED_MASK = 0x40, 1379 SES_STATUS_AUDIBLE_ALARM_MUTED_SHIFT = 6, 1380 1381 SES_STATUS_AUDIBLE_ALARM_REMIND_BYTE = 2, 1382 SES_STATUS_AUDIBLE_ALARM_REMIND_MASK = 0x10, 1383 SES_STATUS_AUDIBLE_ALARM_REMIND_SHIFT = 4, 1384 1385 SES_STATUS_AUDIBLE_ALARM_TONE_INDICATOR_BYTE = 2, 1386 SES_STATUS_AUDIBLE_ALARM_TONE_INDICATOR_MASK = 0x0F, 1387 SES_STATUS_AUDIBLE_ALARM_TONE_INDICATOR_SHIFT = 0, 1388 SES_STATUS_AUDIBLE_ALARM_TONE_INDICATOR_INFO = 0x08, 1389 SES_STATUS_AUDIBLE_ALARM_TONE_INDICATOR_NON_CRIT = 0x04, 1390 SES_STATUS_AUDIBLE_ALARM_TONE_INDICATOR_CRIT = 0x02, 1391 SES_STATUS_AUDIBLE_ALARM_TONE_INDICATOR_UNRECOV = 0x01 1392 }; 1393 1394 #define GEN_SES_STATUS_AUDIBLE_ALARM_ACCESSORS(LCASE, UCASE) \ 1395 GEN_GETTER(ses_status_audible_alarm, SES_STATUS_AUDIBLE_ALARM, LCASE, UCASE) 1396 GEN_SES_STATUS_AUDIBLE_ALARM_ACCESSORS(ident, IDENT) 1397 GEN_SES_STATUS_AUDIBLE_ALARM_ACCESSORS(fail, FAIL) 1398 GEN_SES_STATUS_AUDIBLE_ALARM_ACCESSORS(rqst_mute, RQST_MUTE) 1399 GEN_SES_STATUS_AUDIBLE_ALARM_ACCESSORS(muted, MUTED) 1400 GEN_SES_STATUS_AUDIBLE_ALARM_ACCESSORS(remind, REMIND) 1401 GEN_SES_STATUS_AUDIBLE_ALARM_ACCESSORS(tone_indicator, TONE_INDICATOR) 1402 #undef GEN_SES_STATUS_AUDIBLE_ALARM_ACCESSORS 1403 1404 /*---------- Enclosure Services Statusler Electronics Status Element ---------*/ 1405 struct ses_status_ecc_electronics { 1406 struct ses_status_common common; 1407 uint8_t bytes[3]; 1408 }; 1409 1410 enum ses_status_ecc_electronics_field_data { 1411 SES_STATUS_ECC_ELECTRONICS_IDENT_BYTE = 0, 1412 SES_STATUS_ECC_ELECTRONICS_IDENT_MASK = 0x80, 1413 SES_STATUS_ECC_ELECTRONICS_IDENT_SHIFT = 7, 1414 1415 SES_STATUS_ECC_ELECTRONICS_FAIL_BYTE = 0, 1416 SES_STATUS_ECC_ELECTRONICS_FAIL_MASK = 0x40, 1417 SES_STATUS_ECC_ELECTRONICS_FAIL_SHIFT = 6, 1418 1419 SES_STATUS_ECC_ELECTRONICS_REPORT_BYTE = 1, 1420 SES_STATUS_ECC_ELECTRONICS_REPORT_MASK = 0x01, 1421 SES_STATUS_ECC_ELECTRONICS_REPORT_SHIFT = 0, 1422 1423 SES_STATUS_ECC_ELECTRONICS_HOT_SWAP_BYTE = 2, 1424 SES_STATUS_ECC_ELECTRONICS_HOT_SWAP_MASK = 0x80, 1425 SES_STATUS_ECC_ELECTRONICS_HOT_SWAP_SHIFT = 7 1426 }; 1427 1428 #define GEN_SES_STATUS_ECC_ELECTRONICS_ACCESSORS(LCASE, UCASE) \ 1429 GEN_GETTER(ses_status_ecc_electronics, SES_STATUS_ECC_ELECTRONICS, \ 1430 LCASE, UCASE) 1431 GEN_SES_STATUS_ECC_ELECTRONICS_ACCESSORS(ident, IDENT) 1432 GEN_SES_STATUS_ECC_ELECTRONICS_ACCESSORS(fail, FAIL) 1433 GEN_SES_STATUS_ECC_ELECTRONICS_ACCESSORS(report, REPORT) 1434 GEN_SES_STATUS_ECC_ELECTRONICS_ACCESSORS(hot_swap, HOT_SWAP) 1435 #undef GEN_SES_STATUS_ECC_ELECTRONICS_ACCESSORS 1436 1437 /*------------ SCSI Services Statusler Electronics Status Element ------------*/ 1438 struct ses_status_scc_electronics { 1439 struct ses_status_common common; 1440 uint8_t bytes[3]; 1441 }; 1442 1443 enum ses_status_scc_electronics_field_data { 1444 SES_STATUS_SCC_ELECTRONICS_IDENT_BYTE = 0, 1445 SES_STATUS_SCC_ELECTRONICS_IDENT_MASK = 0x80, 1446 SES_STATUS_SCC_ELECTRONICS_IDENT_SHIFT = 7, 1447 1448 SES_STATUS_SCC_ELECTRONICS_FAIL_BYTE = 0, 1449 SES_STATUS_SCC_ELECTRONICS_FAIL_MASK = 0x40, 1450 SES_STATUS_SCC_ELECTRONICS_FAIL_SHIFT = 6, 1451 1452 SES_STATUS_SCC_ELECTRONICS_REPORT_BYTE = 1, 1453 SES_STATUS_SCC_ELECTRONICS_REPORT_MASK = 0x01, 1454 SES_STATUS_SCC_ELECTRONICS_REPORT_SHIFT = 0 1455 }; 1456 1457 #define GEN_SES_STATUS_SCC_ELECTRONICS_ACCESSORS(LCASE, UCASE) \ 1458 GEN_GETTER(ses_status_scc_electronics, SES_STATUS_SCC_ELECTRONICS, \ 1459 LCASE, UCASE) 1460 GEN_SES_STATUS_SCC_ELECTRONICS_ACCESSORS(ident, IDENT) 1461 GEN_SES_STATUS_SCC_ELECTRONICS_ACCESSORS(fail, FAIL) 1462 GEN_SES_STATUS_SCC_ELECTRONICS_ACCESSORS(report, REPORT) 1463 #undef GEN_SES_STATUS_SCC_ELECTRONICS_ACCESSORS 1464 1465 /*--------------------- Nonvolatile Cache Status Element ---------------------*/ 1466 struct ses_status_nv_cache { 1467 struct ses_status_common common; 1468 uint8_t bytes[1]; 1469 uint8_t cache_size[2]; 1470 }; 1471 1472 enum ses_status_nv_cache_field_data { 1473 SES_STATUS_NV_CACHE_IDENT_BYTE = 0, 1474 SES_STATUS_NV_CACHE_IDENT_MASK = 0x80, 1475 SES_STATUS_NV_CACHE_IDENT_SHIFT = 7, 1476 1477 SES_STATUS_NV_CACHE_FAIL_BYTE = 0, 1478 SES_STATUS_NV_CACHE_FAIL_MASK = 0x40, 1479 SES_STATUS_NV_CACHE_FAIL_SHIFT = 6, 1480 1481 SES_STATUS_NV_CACHE_SIZE_MULTIPLIER_BYTE = 0, 1482 SES_STATUS_NV_CACHE_SIZE_MULTIPLIER_MASK = 0x03, 1483 SES_STATUS_NV_CACHE_SIZE_MULTIPLIER_SHIFT = 0, 1484 SES_STATUS_NV_CACHE_SIZE_MULTIPLIER_BYTES = 0x0, 1485 SES_STATUS_NV_CACHE_SIZE_MULTIPLIER_KBYTES = 0x1, 1486 SES_STATUS_NV_CACHE_SIZE_MULTIPLIER_MBYTES = 0x2, 1487 SES_STATUS_NV_CACHE_SIZE_MULTIPLIER_GBYTES = 0x3 1488 }; 1489 1490 #define GEN_SES_STATUS_NV_CACHE_ACCESSORS(LCASE, UCASE) \ 1491 GEN_GETTER(ses_status_nv_cache, SES_STATUS_NV_CACHE, LCASE, UCASE) 1492 GEN_SES_STATUS_NV_CACHE_ACCESSORS(ident, IDENT) 1493 GEN_SES_STATUS_NV_CACHE_ACCESSORS(fail, FAIL) 1494 GEN_SES_STATUS_NV_CACHE_ACCESSORS(size_multiplier, SIZE_MULTIPLIER) 1495 #undef GEN_SES_STATUS_NV_CACHE_ACCESSORS 1496 1497 static inline uintmax_t 1498 ses_status_nv_cache_get_cache_size(struct ses_status_nv_cache *elem) 1499 { 1500 uintmax_t cache_size; 1501 int multiplier; 1502 1503 /* Multiplier is in units of 2^10 */ 1504 cache_size = scsi_2btoul(elem->cache_size); 1505 multiplier = 10 * ses_status_nv_cache_get_size_multiplier(elem); 1506 return (cache_size << multiplier); 1507 } 1508 1509 /*----------------- Invalid Operation Reason Status Element ------------------*/ 1510 struct ses_status_invalid_op_reason { 1511 struct ses_status_common common; 1512 uint8_t bytes[3]; 1513 }; 1514 1515 enum ses_status_invalid_op_field_data { 1516 SES_STATUS_INVALID_OP_REASON_TYPE_BYTE = 0, 1517 SES_STATUS_INVALID_OP_REASON_TYPE_MASK = 0xC0, 1518 SES_STATUS_INVALID_OP_REASON_TYPE_SHIFT = 6, 1519 SES_STATUS_INVALID_OP_REASON_TYPE_PC_ERROR = 0x00, 1520 SES_STATUS_INVALID_OP_REASON_TYPE_PF_ERROR = 0x01, 1521 SES_STATUS_INVALID_OP_REASON_TYPE_VS_ERROR = 0x03, 1522 1523 SES_STATUS_INVALID_OP_REASON_PC_ERROR_PC_NOT_SUPPORTED_BYTE = 0, 1524 SES_STATUS_INVALID_OP_REASON_PC_ERROR_PC_NOT_SUPPORTED_MASK = 0x01, 1525 SES_STATUS_INVALID_OP_REASON_PC_ERROR_PC_NOT_SUPPORTED_SHIFT = 0, 1526 1527 SES_STATUS_INVALID_OP_REASON_PF_ERROR_BIT_NUMBER_BYTE = 0, 1528 SES_STATUS_INVALID_OP_REASON_PF_ERROR_BIT_NUMBER_MASK = 0x03, 1529 SES_STATUS_INVALID_OP_REASON_PF_ERROR_BIT_NUMBER_SHIFT = 0 1530 }; 1531 1532 #define GEN_SES_STATUS_INVALID_OP_REASON_ACCESSORS(LCASE, UCASE) \ 1533 GEN_GETTER(ses_status_invalid_op_reason, SES_STATUS_INVALID_OP_REASON, \ 1534 LCASE, UCASE) 1535 GEN_SES_STATUS_INVALID_OP_REASON_ACCESSORS(type, TYPE) 1536 GEN_SES_STATUS_INVALID_OP_REASON_ACCESSORS(pc_error_pc_not_supported, 1537 PC_ERROR_PC_NOT_SUPPORTED) 1538 GEN_SES_STATUS_INVALID_OP_REASON_ACCESSORS(pf_error_bit_number, 1539 PF_ERROR_BIT_NUMBER) 1540 #undef GEN_SES_STATUS_INVALID_OP_ACCESSORS 1541 1542 /*--------------- Uninterruptible Power Supply Status Element ----------------*/ 1543 struct ses_status_ups { 1544 struct ses_status_common common; 1545 /* Minutes of remaining capacity. */ 1546 uint8_t battery_status; 1547 uint8_t bytes[2]; 1548 }; 1549 1550 enum ses_status_ups_field_data { 1551 SES_STATUS_UPS_AC_LO_BYTE = 0, 1552 SES_STATUS_UPS_AC_LO_MASK = 0x80, 1553 SES_STATUS_UPS_AC_LO_SHIFT = 7, 1554 1555 SES_STATUS_UPS_AC_HI_BYTE = 0, 1556 SES_STATUS_UPS_AC_HI_MASK = 0x40, 1557 SES_STATUS_UPS_AC_HI_SHIFT = 6, 1558 1559 SES_STATUS_UPS_AC_QUAL_BYTE = 0, 1560 SES_STATUS_UPS_AC_QUAL_MASK = 0x20, 1561 SES_STATUS_UPS_AC_QUAL_SHIFT = 5, 1562 1563 SES_STATUS_UPS_AC_FAIL_BYTE = 0, 1564 SES_STATUS_UPS_AC_FAIL_MASK = 0x10, 1565 SES_STATUS_UPS_AC_FAIL_SHIFT = 4, 1566 1567 SES_STATUS_UPS_DC_FAIL_BYTE = 0, 1568 SES_STATUS_UPS_DC_FAIL_MASK = 0x08, 1569 SES_STATUS_UPS_DC_FAIL_SHIFT = 3, 1570 1571 SES_STATUS_UPS_UPS_FAIL_BYTE = 0, 1572 SES_STATUS_UPS_UPS_FAIL_MASK = 0x04, 1573 SES_STATUS_UPS_UPS_FAIL_SHIFT = 2, 1574 1575 SES_STATUS_UPS_WARN_BYTE = 0, 1576 SES_STATUS_UPS_WARN_MASK = 0x02, 1577 SES_STATUS_UPS_WARN_SHIFT = 1, 1578 1579 SES_STATUS_UPS_INTF_FAIL_BYTE = 0, 1580 SES_STATUS_UPS_INTF_FAIL_MASK = 0x01, 1581 SES_STATUS_UPS_INTF_FAIL_SHIFT = 0, 1582 1583 SES_STATUS_UPS_IDENT_BYTE = 0, 1584 SES_STATUS_UPS_IDENT_MASK = 0x80, 1585 SES_STATUS_UPS_IDENT_SHIFT = 7, 1586 1587 SES_STATUS_UPS_FAIL_BYTE = 1, 1588 SES_STATUS_UPS_FAIL_MASK = 0x40, 1589 SES_STATUS_UPS_FAIL_SHIFT = 6, 1590 1591 SES_STATUS_UPS_BATT_FAIL_BYTE = 1, 1592 SES_STATUS_UPS_BATT_FAIL_MASK = 0x02, 1593 SES_STATUS_UPS_BATT_FAIL_SHIFT = 1, 1594 1595 SES_STATUS_UPS_BPF_BYTE = 1, 1596 SES_STATUS_UPS_BPF_MASK = 0x01, 1597 SES_STATUS_UPS_BPF_SHIFT = 0 1598 }; 1599 1600 #define GEN_SES_STATUS_UPS_ACCESSORS(LCASE, UCASE) \ 1601 GEN_GETTER(ses_status_ups, SES_STATUS_UPS, LCASE, UCASE) 1602 GEN_SES_STATUS_UPS_ACCESSORS(ac_lo, AC_LO) 1603 GEN_SES_STATUS_UPS_ACCESSORS(ac_hi, AC_HI) 1604 GEN_SES_STATUS_UPS_ACCESSORS(ac_qual, AC_QUAL) 1605 GEN_SES_STATUS_UPS_ACCESSORS(ac_fail, AC_FAIL) 1606 GEN_SES_STATUS_UPS_ACCESSORS(dc_fail, DC_FAIL) 1607 GEN_SES_STATUS_UPS_ACCESSORS(ups_fail, UPS_FAIL) 1608 GEN_SES_STATUS_UPS_ACCESSORS(warn, WARN) 1609 GEN_SES_STATUS_UPS_ACCESSORS(intf_fail, INTF_FAIL) 1610 GEN_SES_STATUS_UPS_ACCESSORS(ident, IDENT) 1611 GEN_SES_STATUS_UPS_ACCESSORS(fail, FAIL) 1612 GEN_SES_STATUS_UPS_ACCESSORS(batt_fail, BATT_FAIL) 1613 GEN_SES_STATUS_UPS_ACCESSORS(bpf, BPF) 1614 #undef GEN_SES_STATUS_UPS_ACCESSORS 1615 1616 /*-------------------------- Display Status Element --------------------------*/ 1617 struct ses_status_display { 1618 struct ses_status_common common; 1619 uint8_t bytes[1]; 1620 uint8_t display_character[2]; 1621 }; 1622 1623 enum ses_status_display_field_data { 1624 SES_STATUS_DISPLAY_IDENT_BYTE = 0, 1625 SES_STATUS_DISPLAY_IDENT_MASK = 0x80, 1626 SES_STATUS_DISPLAY_IDENT_SHIFT = 7, 1627 1628 SES_STATUS_DISPLAY_FAIL_BYTE = 0, 1629 SES_STATUS_DISPLAY_FAIL_MASK = 0x40, 1630 SES_STATUS_DISPLAY_FAIL_SHIFT = 6, 1631 1632 SES_STATUS_DISPLAY_DISPLAY_MODE_BYTE = 0, 1633 SES_STATUS_DISPLAY_DISPLAY_MODE_MASK = 0x03, 1634 SES_STATUS_DISPLAY_DISPLAY_MODE_SHIFT = 6, 1635 SES_STATUS_DISPLAY_DISPLAY_MODE_DC_FIELD_UNSUPP = 0x0, 1636 SES_STATUS_DISPLAY_DISPLAY_MODE_DC_FIELD_SUPP = 0x1, 1637 SES_STATUS_DISPLAY_DISPLAY_MODE_DC_FIELD = 0x2 1638 }; 1639 1640 #define GEN_SES_STATUS_DISPLAY_ACCESSORS(LCASE, UCASE) \ 1641 GEN_GETTER(ses_status_display, SES_STATUS_DISPLAY, LCASE, UCASE) 1642 GEN_SES_STATUS_DISPLAY_ACCESSORS(ident, IDENT) 1643 GEN_SES_STATUS_DISPLAY_ACCESSORS(fail, FAIL) 1644 GEN_SES_STATUS_DISPLAY_ACCESSORS(display_mode, DISPLAY_MODE) 1645 #undef GEN_SES_STATUS_DISPLAY_ACCESSORS 1646 1647 /*----------------------- Key Pad Entry Status Element -----------------------*/ 1648 struct ses_status_key_pad_entry { 1649 struct ses_status_common common; 1650 uint8_t bytes[3]; 1651 }; 1652 1653 enum ses_status_key_pad_entry_field_data { 1654 SES_STATUS_KEY_PAD_ENTRY_IDENT_BYTE = 0, 1655 SES_STATUS_KEY_PAD_ENTRY_IDENT_MASK = 0x80, 1656 SES_STATUS_KEY_PAD_ENTRY_IDENT_SHIFT = 7, 1657 1658 SES_STATUS_KEY_PAD_ENTRY_FAIL_BYTE = 0, 1659 SES_STATUS_KEY_PAD_ENTRY_FAIL_MASK = 0x40, 1660 SES_STATUS_KEY_PAD_ENTRY_FAIL_SHIFT = 6 1661 }; 1662 1663 #define GEN_SES_STATUS_KEY_PAD_ENTRY_ACCESSORS(LCASE, UCASE) \ 1664 GEN_GETTER(ses_status_key_pad_entry, SES_STATUS_KEY_PAD_ENTRY, LCASE, UCASE) 1665 GEN_SES_STATUS_KEY_PAD_ENTRY_ACCESSORS(ident, IDENT) 1666 GEN_SES_STATUS_KEY_PAD_ENTRY_ACCESSORS(fail, FAIL) 1667 #undef GEN_SES_STATUS_KEY_PAD_ENTRY_ACCESSORS 1668 1669 /*------------------------- Enclosure Status Element -------------------------*/ 1670 struct ses_status_enclosure { 1671 struct ses_status_common common; 1672 uint8_t bytes[3]; 1673 }; 1674 1675 enum ses_status_enclosure_field_data { 1676 SES_STATUS_ENCLOSURE_IDENT_BYTE = 0, 1677 SES_STATUS_ENCLOSURE_IDENT_MASK = 0x80, 1678 SES_STATUS_ENCLOSURE_IDENT_SHIFT = 7, 1679 1680 SES_STATUS_ENCLOSURE_TIME_UNTIL_POWER_CYCLE_BYTE = 1, 1681 SES_STATUS_ENCLOSURE_TIME_UNTIL_POWER_CYCLE_MASK = 0xFC, 1682 SES_STATUS_ENCLOSURE_TIME_UNTIL_POWER_CYCLE_SHIFT = 2, 1683 1684 SES_STATUS_ENCLOSURE_FAIL_BYTE = 1, 1685 SES_STATUS_ENCLOSURE_FAIL_MASK = 0x02, 1686 SES_STATUS_ENCLOSURE_FAIL_SHIFT = 1, 1687 1688 SES_STATUS_ENCLOSURE_WARN_BYTE = 1, 1689 SES_STATUS_ENCLOSURE_WARN_MASK = 0x01, 1690 SES_STATUS_ENCLOSURE_WARN_SHIFT = 0, 1691 1692 SES_STATUS_ENCLOSURE_REQUESTED_POWER_OFF_DURATION_BYTE = 2, 1693 SES_STATUS_ENCLOSURE_REQUESTED_POWER_OFF_DURATION_MASK = 0xFC, 1694 SES_STATUS_ENCLOSURE_REQUESTED_POWER_OFF_DURATION_SHIFT = 2, 1695 SES_STATUS_ENCLOSURE_REQUESTED_POWER_OFF_DURATION_MAX_AUTO = 60, 1696 SES_STATUS_ENCLOSURE_REQUESTED_POWER_OFF_DURATION_MANUAL = 63, 1697 1698 SES_STATUS_ENCLOSURE_REQUESTED_FAIL_BYTE = 2, 1699 SES_STATUS_ENCLOSURE_REQUESTED_FAIL_MASK = 0x02, 1700 SES_STATUS_ENCLOSURE_REQUESTED_FAIL_SHIFT = 1, 1701 1702 SES_STATUS_ENCLOSURE_REQUESTED_WARN_BYTE = 2, 1703 SES_STATUS_ENCLOSURE_REQUESTED_WARN_MASK = 0x01, 1704 SES_STATUS_ENCLOSURE_REQUESTED_WARN_SHIFT = 0 1705 }; 1706 1707 #define GEN_SES_STATUS_ENCLOSURE_ACCESSORS(LCASE, UCASE) \ 1708 GEN_GETTER(ses_status_enclosure, SES_STATUS_ENCLOSURE, LCASE, UCASE) 1709 GEN_SES_STATUS_ENCLOSURE_ACCESSORS(ident, IDENT) 1710 GEN_SES_STATUS_ENCLOSURE_ACCESSORS(time_until_power_cycle, 1711 TIME_UNTIL_POWER_CYCLE) 1712 GEN_SES_STATUS_ENCLOSURE_ACCESSORS(fail, FAIL) 1713 GEN_SES_STATUS_ENCLOSURE_ACCESSORS(warn, WARN) 1714 GEN_SES_STATUS_ENCLOSURE_ACCESSORS(requested_power_off_duration, 1715 REQUESTED_POWER_OFF_DURATION) 1716 GEN_SES_STATUS_ENCLOSURE_ACCESSORS(requested_fail, REQUESTED_FAIL) 1717 GEN_SES_STATUS_ENCLOSURE_ACCESSORS(requested_warn, REQUESTED_WARN) 1718 #undef GEN_SES_STATUS_ENCLOSURE_ACCESSORS 1719 1720 /*------------------- SCSI Port/Transceiver Status Element -------------------*/ 1721 struct ses_status_scsi_port_or_xcvr { 1722 struct ses_status_common common; 1723 uint8_t bytes[3]; 1724 }; 1725 1726 enum ses_status_scsi_port_or_xcvr_field_data { 1727 SES_STATUS_SCSI_PORT_OR_XCVR_IDENT_BYTE = 0, 1728 SES_STATUS_SCSI_PORT_OR_XCVR_IDENT_MASK = 0x80, 1729 SES_STATUS_SCSI_PORT_OR_XCVR_IDENT_SHIFT = 7, 1730 1731 SES_STATUS_SCSI_PORT_OR_XCVR_FAIL_BYTE = 0, 1732 SES_STATUS_SCSI_PORT_OR_XCVR_FAIL_MASK = 0x40, 1733 SES_STATUS_SCSI_PORT_OR_XCVR_FAIL_SHIFT = 6, 1734 1735 SES_STATUS_SCSI_PORT_OR_XCVR_REPORT_BYTE = 1, 1736 SES_STATUS_SCSI_PORT_OR_XCVR_REPORT_MASK = 0x01, 1737 SES_STATUS_SCSI_PORT_OR_XCVR_REPORT_SHIFT = 0, 1738 1739 SES_STATUS_SCSI_PORT_OR_XCVR_DISABLED_BYTE = 2, 1740 SES_STATUS_SCSI_PORT_OR_XCVR_DISABLED_MASK = 0x10, 1741 SES_STATUS_SCSI_PORT_OR_XCVR_DISABLED_SHIFT = 4, 1742 1743 SES_STATUS_SCSI_PORT_OR_XCVR_LOL_BYTE = 2, 1744 SES_STATUS_SCSI_PORT_OR_XCVR_LOL_MASK = 0x02, 1745 SES_STATUS_SCSI_PORT_OR_XCVR_LOL_SHIFT = 1, 1746 1747 SES_STATUS_SCSI_PORT_OR_XCVR_XMIT_FAIL_BYTE = 2, 1748 SES_STATUS_SCSI_PORT_OR_XCVR_XMIT_FAIL_MASK = 0x01, 1749 SES_STATUS_SCSI_PORT_OR_XCVR_XMIT_FAIL_SHIFT = 0 1750 }; 1751 1752 #define GEN_SES_STATUS_SCSI_PORT_OR_XCVR_ACCESSORS(LCASE, UCASE) \ 1753 GEN_GETTER(ses_status_scsi_port_or_xcvr, SES_STATUS_SCSI_PORT_OR_XCVR,\ 1754 LCASE, UCASE) 1755 GEN_SES_STATUS_SCSI_PORT_OR_XCVR_ACCESSORS(ident, IDENT) 1756 GEN_SES_STATUS_SCSI_PORT_OR_XCVR_ACCESSORS(fail, FAIL) 1757 GEN_SES_STATUS_SCSI_PORT_OR_XCVR_ACCESSORS(report, REPORT) 1758 GEN_SES_STATUS_SCSI_PORT_OR_XCVR_ACCESSORS(disable, DISABLED) 1759 GEN_SES_STATUS_SCSI_PORT_OR_XCVR_ACCESSORS(lol, LOL) 1760 GEN_SES_STATUS_SCSI_PORT_OR_XCVR_ACCESSORS(xmit_fail, XMIT_FAIL) 1761 #undef GEN_SES_STATUS_SCSI_PORT_OR_XCVR_ACCESSORS 1762 1763 /*------------------------- Language Status Element --------------------------*/ 1764 struct ses_status_language { 1765 struct ses_status_common common; 1766 uint8_t bytes[1]; 1767 uint8_t language_code[2]; 1768 }; 1769 1770 enum ses_status_language_field_data { 1771 SES_STATUS_LANGUAGE_IDENT_BYTE = 0, 1772 SES_STATUS_LANGUAGE_IDENT_MASK = 0x80, 1773 SES_STATUS_LANGUAGE_IDENT_SHIFT = 7 1774 }; 1775 1776 #define GEN_SES_STATUS_LANGUAGE_ACCESSORS(LCASE, UCASE) \ 1777 GEN_GETTER(ses_status_language, SES_STATUS_LANGUAGE, LCASE, UCASE) 1778 GEN_SES_STATUS_LANGUAGE_ACCESSORS(ident, IDENT) 1779 #undef GEN_SES_STATUS_LANGUAGE_ACCESSORS 1780 1781 /*-------------------- Communication Port Status Element ---------------------*/ 1782 struct ses_status_comm_port { 1783 struct ses_status_common common; 1784 uint8_t bytes[3]; 1785 }; 1786 1787 enum ses_status_comm_port_field_data { 1788 SES_STATUS_COMM_PORT_IDENT_BYTE = 0, 1789 SES_STATUS_COMM_PORT_IDENT_MASK = 0x80, 1790 SES_STATUS_COMM_PORT_IDENT_SHIFT = 7, 1791 1792 SES_STATUS_COMM_PORT_FAIL_BYTE = 0, 1793 SES_STATUS_COMM_PORT_FAIL_MASK = 0x40, 1794 SES_STATUS_COMM_PORT_FAIL_SHIFT = 6, 1795 1796 SES_STATUS_COMM_PORT_DISABLED_BYTE = 2, 1797 SES_STATUS_COMM_PORT_DISABLED_MASK = 0x01, 1798 SES_STATUS_COMM_PORT_DISABLED_SHIFT = 0 1799 }; 1800 1801 #define GEN_SES_STATUS_COMM_PORT_ACCESSORS(LCASE, UCASE) \ 1802 GEN_GETTER(ses_status_comm_port, SES_STATUS_COMM_PORT, LCASE, UCASE) 1803 GEN_SES_STATUS_COMM_PORT_ACCESSORS(ident, IDENT) 1804 GEN_SES_STATUS_COMM_PORT_ACCESSORS(fail, FAIL) 1805 GEN_SES_STATUS_COMM_PORT_ACCESSORS(disabled, DISABLED) 1806 #undef GEN_SES_STATUS_COMM_PORT_ACCESSORS 1807 1808 /*---------------------- Voltage Sensor Status Element -----------------------*/ 1809 struct ses_status_voltage_sensor { 1810 struct ses_status_common common; 1811 uint8_t bytes[1]; 1812 uint8_t voltage[2]; 1813 }; 1814 1815 enum ses_status_voltage_sensor_field_data { 1816 SES_STATUS_VOLTAGE_SENSOR_IDENT_BYTE = 0, 1817 SES_STATUS_VOLTAGE_SENSOR_IDENT_MASK = 0x80, 1818 SES_STATUS_VOLTAGE_SENSOR_IDENT_SHIFT = 7, 1819 1820 SES_STATUS_VOLTAGE_SENSOR_FAIL_BYTE = 0, 1821 SES_STATUS_VOLTAGE_SENSOR_FAIL_MASK = 0x40, 1822 SES_STATUS_VOLTAGE_SENSOR_FAIL_SHIFT = 6, 1823 1824 SES_STATUS_VOLTAGE_SENSOR_WARN_OVER_BYTE = 0, 1825 SES_STATUS_VOLTAGE_SENSOR_WARN_OVER_MASK = 0x08, 1826 SES_STATUS_VOLTAGE_SENSOR_WARN_OVER_SHIFT = 3, 1827 1828 SES_STATUS_VOLTAGE_SENSOR_WARN_UNDER_BYTE = 0, 1829 SES_STATUS_VOLTAGE_SENSOR_WARN_UNDER_MASK = 0x04, 1830 SES_STATUS_VOLTAGE_SENSOR_WARN_UNDER_SHIFT = 2, 1831 1832 SES_STATUS_VOLTAGE_SENSOR_CRIT_OVER_BYTE = 0, 1833 SES_STATUS_VOLTAGE_SENSOR_CRIT_OVER_MASK = 0x02, 1834 SES_STATUS_VOLTAGE_SENSOR_CRIT_OVER_SHIFT = 1, 1835 1836 SES_STATUS_VOLTAGE_SENSOR_CRIT_UNDER_BYTE = 0, 1837 SES_STATUS_VOLTAGE_SENSOR_CRIT_UNDER_MASK = 0x01, 1838 SES_STATUS_VOLTAGE_SENSOR_CRIT_UNDER_SHIFT = 0 1839 }; 1840 1841 #define GEN_SES_STATUS_VOLTAGE_SENSOR_ACCESSORS(LCASE, UCASE) \ 1842 GEN_GETTER(ses_status_voltage_sensor, SES_STATUS_VOLTAGE_SENSOR, \ 1843 LCASE, UCASE) 1844 GEN_SES_STATUS_VOLTAGE_SENSOR_ACCESSORS(ident, IDENT) 1845 GEN_SES_STATUS_VOLTAGE_SENSOR_ACCESSORS(fail, FAIL) 1846 GEN_SES_STATUS_VOLTAGE_SENSOR_ACCESSORS(warn_over, WARN_OVER) 1847 GEN_SES_STATUS_VOLTAGE_SENSOR_ACCESSORS(warn_under, WARN_UNDER) 1848 GEN_SES_STATUS_VOLTAGE_SENSOR_ACCESSORS(crit_over, CRIT_OVER) 1849 GEN_SES_STATUS_VOLTAGE_SENSOR_ACCESSORS(crit_under, CRIT_UNDER) 1850 #undef GEN_SES_STATUS_VOLTAGE_SENSOR_ACCESSORS 1851 1852 /*---------------------- Current Sensor Status Element -----------------------*/ 1853 struct ses_status_current_sensor { 1854 struct ses_status_common common; 1855 uint8_t bytes[3]; 1856 }; 1857 1858 enum ses_status_current_sensor_field_data { 1859 SES_STATUS_CURRENT_SENSOR_IDENT_BYTE = 0, 1860 SES_STATUS_CURRENT_SENSOR_IDENT_MASK = 0x80, 1861 SES_STATUS_CURRENT_SENSOR_IDENT_SHIFT = 7, 1862 1863 SES_STATUS_CURRENT_SENSOR_FAIL_BYTE = 0, 1864 SES_STATUS_CURRENT_SENSOR_FAIL_MASK = 0x40, 1865 SES_STATUS_CURRENT_SENSOR_FAIL_SHIFT = 6, 1866 1867 SES_STATUS_CURRENT_SENSOR_WARN_OVER_BYTE = 0, 1868 SES_STATUS_CURRENT_SENSOR_WARN_OVER_MASK = 0x08, 1869 SES_STATUS_CURRENT_SENSOR_WARN_OVER_SHIFT = 3, 1870 1871 SES_STATUS_CURRENT_SENSOR_CRIT_OVER_BYTE = 0, 1872 SES_STATUS_CURRENT_SENSOR_CRIT_OVER_MASK = 0x02, 1873 SES_STATUS_CURRENT_SENSOR_CRIT_OVER_SHIFT = 1 1874 }; 1875 1876 #define GEN_SES_STATUS_CURRENT_SENSOR_ACCESSORS(LCASE, UCASE) \ 1877 GEN_GETTER(ses_status_current_sensor, SES_STATUS_CURRENT_SENSOR, \ 1878 LCASE, UCASE) 1879 GEN_SES_STATUS_CURRENT_SENSOR_ACCESSORS(ident, IDENT) 1880 GEN_SES_STATUS_CURRENT_SENSOR_ACCESSORS(fail, FAIL) 1881 GEN_SES_STATUS_CURRENT_SENSOR_ACCESSORS(warn_over, WARN_OVER) 1882 GEN_SES_STATUS_CURRENT_SENSOR_ACCESSORS(crit_over, CRIT_OVER) 1883 #undef GEN_SES_STATUS_CURRENT_SENSOR_ACCESSORS 1884 1885 /*--------------------- SCSI Target Port Status Element ----------------------*/ 1886 struct ses_status_target_port { 1887 struct ses_status_common common; 1888 uint8_t bytes[3]; 1889 }; 1890 1891 enum ses_status_scsi_target_port_field_data { 1892 SES_STATUS_TARGET_PORT_IDENT_BYTE = 0, 1893 SES_STATUS_TARGET_PORT_IDENT_MASK = 0x80, 1894 SES_STATUS_TARGET_PORT_IDENT_SHIFT = 7, 1895 1896 SES_STATUS_TARGET_PORT_FAIL_BYTE = 0, 1897 SES_STATUS_TARGET_PORT_FAIL_MASK = 0x40, 1898 SES_STATUS_TARGET_PORT_FAIL_SHIFT = 6, 1899 1900 SES_STATUS_TARGET_PORT_REPORT_BYTE = 1, 1901 SES_STATUS_TARGET_PORT_REPORT_MASK = 0x01, 1902 SES_STATUS_TARGET_PORT_REPORT_SHIFT = 0, 1903 1904 SES_STATUS_TARGET_PORT_ENABLED_BYTE = 2, 1905 SES_STATUS_TARGET_PORT_ENABLED_MASK = 0x01, 1906 SES_STATUS_TARGET_PORT_ENABLED_SHIFT = 0 1907 }; 1908 1909 #define GEN_SES_STATUS_TARGET_PORT_ACCESSORS(LCASE, UCASE) \ 1910 GEN_GETTER(ses_status_target_port, SES_STATUS_TARGET_PORT, LCASE, UCASE) 1911 GEN_SES_STATUS_TARGET_PORT_ACCESSORS(ident, IDENT) 1912 GEN_SES_STATUS_TARGET_PORT_ACCESSORS(fail, FAIL) 1913 GEN_SES_STATUS_TARGET_PORT_ACCESSORS(report, REPORT) 1914 GEN_SES_STATUS_TARGET_PORT_ACCESSORS(enabled, ENABLED) 1915 #undef GEN_SES_STATUS_TARGET_PORT_ACCESSORS 1916 1917 /*-------------------- SCSI Initiator Port Status Element --------------------*/ 1918 struct ses_status_initiator_port { 1919 struct ses_status_common common; 1920 uint8_t bytes[3]; 1921 }; 1922 1923 enum ses_status_scsi_initiator_port_field_data { 1924 SES_STATUS_INITIATOR_PORT_IDENT_BYTE = 0, 1925 SES_STATUS_INITIATOR_PORT_IDENT_MASK = 0x80, 1926 SES_STATUS_INITIATOR_PORT_IDENT_SHIFT = 7, 1927 1928 SES_STATUS_INITIATOR_PORT_FAIL_BYTE = 0, 1929 SES_STATUS_INITIATOR_PORT_FAIL_MASK = 0x40, 1930 SES_STATUS_INITIATOR_PORT_FAIL_SHIFT = 6, 1931 1932 SES_STATUS_INITIATOR_PORT_REPORT_BYTE = 1, 1933 SES_STATUS_INITIATOR_PORT_REPORT_MASK = 0x01, 1934 SES_STATUS_INITIATOR_PORT_REPORT_SHIFT = 0, 1935 1936 SES_STATUS_INITIATOR_PORT_ENABLED_BYTE = 2, 1937 SES_STATUS_INITIATOR_PORT_ENABLED_MASK = 0x01, 1938 SES_STATUS_INITIATOR_PORT_ENABLED_SHIFT = 0 1939 }; 1940 1941 #define GEN_SES_STATUS_INITIATOR_PORT_ACCESSORS(LCASE, UCASE) \ 1942 GEN_GETTER(ses_status_initiator_port, SES_STATUS_INITIATOR_PORT, \ 1943 LCASE, UCASE) 1944 GEN_SES_STATUS_INITIATOR_PORT_ACCESSORS(ident, IDENT) 1945 GEN_SES_STATUS_INITIATOR_PORT_ACCESSORS(fail, FAIL) 1946 GEN_SES_STATUS_INITIATOR_PORT_ACCESSORS(report, REPORT) 1947 GEN_SES_STATUS_INITIATOR_PORT_ACCESSORS(enabled, ENABLED) 1948 #undef GEN_SES_STATUS_INITIATOR_PORT_ACCESSORS 1949 1950 /*-------------------- Simple Subenclosure Status Element --------------------*/ 1951 struct ses_status_simple_subses { 1952 struct ses_status_common common; 1953 uint8_t bytes[2]; 1954 uint8_t short_enclosure_status; 1955 }; 1956 1957 enum ses_status_simple_subses_field_data { 1958 SES_STATUS_SIMPlE_SUBSES_IDENT_BYTE = 0, 1959 SES_STATUS_SIMPlE_SUBSES_IDENT_MASK = 0x80, 1960 SES_STATUS_SIMPlE_SUBSES_IDENT_SHIFT = 7, 1961 1962 SES_STATUS_SIMPlE_SUBSES_FAIL_BYTE = 0, 1963 SES_STATUS_SIMPlE_SUBSES_FAIL_MASK = 0x40, 1964 SES_STATUS_SIMPlE_SUBSES_FAIL_SHIFT = 6 1965 }; 1966 1967 #define GEN_SES_STATUS_SIMPlE_SUBSES_ACCESSORS(LCASE, UCASE) \ 1968 GEN_GETTER(ses_status_simple_subses, SES_STATUS_SIMPlE_SUBSES, \ 1969 LCASE, UCASE) 1970 GEN_SES_STATUS_SIMPlE_SUBSES_ACCESSORS(ident, IDENT) 1971 GEN_SES_STATUS_SIMPlE_SUBSES_ACCESSORS(fail, FAIL) 1972 #undef GEN_SES_STATUS_SIMPlE_SUBSES_ACCESSORS 1973 1974 /*----------------------- SAS Expander Status Element ------------------------*/ 1975 struct ses_status_sas_expander { 1976 struct ses_status_common common; 1977 uint8_t bytes[3]; 1978 }; 1979 1980 enum ses_status_sas_expander_field_data { 1981 SES_STATUS_SAS_EXPANDER_IDENT_BYTE = 0, 1982 SES_STATUS_SAS_EXPANDER_IDENT_MASK = 0x80, 1983 SES_STATUS_SAS_EXPANDER_IDENT_SHIFT = 7, 1984 1985 SES_STATUS_SAS_EXPANDER_FAIL_BYTE = 0, 1986 SES_STATUS_SAS_EXPANDER_FAIL_MASK = 0x40, 1987 SES_STATUS_SAS_EXPANDER_FAIL_SHIFT = 6 1988 }; 1989 1990 #define GEN_SES_STATUS_SAS_EXPANDER_ACCESSORS(LCASE, UCASE) \ 1991 GEN_GETTER(ses_status_sas_expander, SES_STATUS_SAS_EXPANDER, LCASE, UCASE) 1992 GEN_SES_STATUS_SAS_EXPANDER_ACCESSORS(ident, IDENT) 1993 GEN_SES_STATUS_SAS_EXPANDER_ACCESSORS(fail, FAIL) 1994 #undef GEN_SES_STATUS_SAS_EXPANDER_ACCESSORS 1995 1996 /*----------------------- SAS Connector Status Element -----------------------*/ 1997 struct ses_status_sas_connector { 1998 struct ses_status_common common; 1999 uint8_t bytes[3]; 2000 }; 2001 2002 enum ses_status_sas_connector_field_data { 2003 SES_STATUS_SAS_CONNECTOR_IDENT_BYTE = 0, 2004 SES_STATUS_SAS_CONNECTOR_IDENT_MASK = 0x80, 2005 SES_STATUS_SAS_CONNECTOR_IDENT_SHIFT = 7, 2006 2007 SES_STATUS_SAS_CONNECTOR_TYPE_BYTE = 0, 2008 SES_STATUS_SAS_CONNECTOR_TYPE_MASK = 0x7F, 2009 SES_STATUS_SAS_CONNECTOR_TYPE_SHIFT = 0, 2010 2011 SES_STATUS_SAS_CONNECTOR_PHYS_LINK_BYTE = 1, 2012 SES_STATUS_SAS_CONNECTOR_PHYS_LINK_MASK = 0xFF, 2013 SES_STATUS_SAS_CONNECTOR_PHYS_LINK_SHIFT = 0, 2014 SES_STATUS_SAS_CONNECTOR_PHYS_LINK_ALL = 0xFF, 2015 2016 SES_STATUS_SAS_CONNECTOR_FAIL_BYTE = 2, 2017 SES_STATUS_SAS_CONNECTOR_FAIL_MASK = 0x40, 2018 SES_STATUS_SAS_CONNECTOR_FAIL_SHIFT = 6, 2019 }; 2020 2021 #define GEN_SES_STATUS_SAS_CONNECTOR_ACCESSORS(LCASE, UCASE) \ 2022 GEN_GETTER(ses_status_sas_connector, SES_STATUS_SAS_CONNECTOR, \ 2023 LCASE, UCASE) 2024 GEN_SES_STATUS_SAS_CONNECTOR_ACCESSORS(ident, IDENT) 2025 GEN_SES_STATUS_SAS_CONNECTOR_ACCESSORS(type, TYPE) 2026 GEN_SES_STATUS_SAS_CONNECTOR_ACCESSORS(phys_link, PHYS_LINK) 2027 GEN_SES_STATUS_SAS_CONNECTOR_ACCESSORS(fail, FAIL) 2028 #undef GEN_SES_STATUS_SAS_CONNECTOR_ACCESSORS 2029 2030 /*------------------------- Universal Status Element -------------------------*/ 2031 union ses_status_element { 2032 struct ses_status_common common; 2033 struct ses_status_dev_slot dev_slot; 2034 struct ses_status_array_dev_slot array_dev_slot; 2035 struct ses_status_power_supply power_supply; 2036 struct ses_status_cooling cooling; 2037 struct ses_status_temp_sensor temp_sensor; 2038 struct ses_status_door_lock door_lock; 2039 struct ses_status_audible_alarm audible_alarm; 2040 struct ses_status_ecc_electronics ecc_electronics; 2041 struct ses_status_scc_electronics scc_electronics; 2042 struct ses_status_nv_cache nv_cache; 2043 struct ses_status_invalid_op_reason invalid_op_reason; 2044 struct ses_status_ups ups; 2045 struct ses_status_display display; 2046 struct ses_status_key_pad_entry key_pad_entry; 2047 struct ses_status_scsi_port_or_xcvr scsi_port_or_xcvr; 2048 struct ses_status_language language; 2049 struct ses_status_comm_port comm_port; 2050 struct ses_status_voltage_sensor voltage_sensor; 2051 struct ses_status_current_sensor current_sensor; 2052 struct ses_status_target_port target_port; 2053 struct ses_status_initiator_port initiator_port; 2054 struct ses_status_simple_subses simple_subses; 2055 struct ses_status_sas_expander sas_expander; 2056 struct ses_status_sas_connector sas_connector; 2057 uint8_t bytes[4]; 2058 }; 2059 2060 /* 2061 * Convert element status into control as much as possible. 2062 * Some bits have different meaning in status and control, 2063 * while others have the same and should be preserved. 2064 */ 2065 static inline void 2066 ses_status_to_ctrl(uint8_t type, uint8_t *bytes) 2067 { 2068 /* Updated to SES4r5. */ 2069 static const uint8_t mask[][4] = { 2070 { 0x60, 0x00, 0x00, 0x00 }, /* UNSPECIFIED */ 2071 { 0x60, 0x00, 0x4e, 0x3c }, /* DEVICE */ 2072 { 0x60, 0xc0, 0x00, 0x60 }, /* POWER */ 2073 { 0x60, 0xc0, 0x00, 0x60 }, /* COOLING/FAN */ 2074 { 0x60, 0xc0, 0x00, 0x80 }, /* THERM */ 2075 { 0x60, 0xc0, 0x00, 0x01 }, /* DOORLOCK */ 2076 { 0x60, 0xc0, 0x00, 0x5f }, /* ALARM */ 2077 { 0x60, 0xf0, 0x01, 0x00 }, /* ESSC */ 2078 { 0x60, 0xc0, 0x00, 0x00 }, /* SCC */ 2079 { 0x60, 0xc0, 0x00, 0x00 }, /* NVRAM */ 2080 { 0x60, 0x00, 0x00, 0x00 }, /* INV_OP_REASON */ 2081 { 0x60, 0x00, 0x00, 0xe0 }, /* UPS */ 2082 { 0x60, 0xc0, 0xff, 0xff }, /* DISPLAY */ 2083 { 0x60, 0xc0, 0x00, 0x00 }, /* KEYPAD */ 2084 { 0x60, 0x80, 0x00, 0xff }, /* ENCLOSURE */ 2085 { 0x60, 0xc0, 0x00, 0x10 }, /* SCSIXVR */ 2086 { 0x60, 0x80, 0xff, 0xff }, /* LANGUAGE */ 2087 { 0x60, 0xc0, 0x00, 0x01 }, /* COMPORT */ 2088 { 0x60, 0xc0, 0x00, 0x00 }, /* VOM */ 2089 { 0x60, 0xc0, 0x00, 0x00 }, /* AMMETER */ 2090 { 0x60, 0xc0, 0x00, 0x01 }, /* SCSI_TGT */ 2091 { 0x60, 0xc0, 0x00, 0x01 }, /* SCSI_INI*/ 2092 { 0x60, 0xc0, 0x00, 0x00 }, /* SUBENC */ 2093 { 0x60, 0xff, 0x4e, 0x3c }, /* ARRAY_DEV */ 2094 { 0x60, 0xc0, 0x00, 0x00 }, /* SAS_EXP */ 2095 { 0x60, 0x80, 0x00, 0x40 }, /* SAS_CONN */ 2096 }; 2097 2098 if (type >= sizeof(mask) / sizeof(mask[0])) 2099 type = 0; 2100 for (int i = 0; i < 4; i++) 2101 bytes[i] &= mask[type][i]; 2102 } 2103 2104 /*===================== SCSI SES Status Diagnostic Page =====================*/ 2105 struct ses_status_page { 2106 struct ses_page_hdr hdr; 2107 union ses_status_element elements[]; 2108 }; 2109 2110 enum ses_status_page_field_data { 2111 SES_STATUS_PAGE_INVOP_MASK = 0x10, 2112 SES_STATUS_PAGE_INVOP_SHIFT = 4, 2113 2114 SES_STATUS_PAGE_INFO_MASK = 0x08, 2115 SES_STATUS_PAGE_INFO_SHIFT = 3, 2116 2117 SES_STATUS_PAGE_NON_CRIT_MASK = 0x04, 2118 SES_STATUS_PAGE_NON_CRIT_SHIFT = 2, 2119 2120 SES_STATUS_PAGE_CRIT_MASK = 0x02, 2121 SES_STATUS_PAGE_CRIT_SHIFT = 1, 2122 2123 SES_STATUS_PAGE_UNRECOV_MASK = 0x01, 2124 SES_STATUS_PAGE_UNRECOV_SHIFT = 0, 2125 2126 SES_STATUS_PAGE_CHANGED_MASK = SES_STATUS_PAGE_INVOP_MASK 2127 | SES_STATUS_PAGE_INFO_MASK 2128 | SES_STATUS_PAGE_NON_CRIT_MASK 2129 | SES_STATUS_PAGE_CRIT_MASK 2130 | SES_STATUS_PAGE_UNRECOV_MASK, 2131 SES_STATUS_PAGE_CHANGED_SHIFT = 0, 2132 }; 2133 2134 #define GEN_SES_STATUS_PAGE_ACCESSORS(LCASE, UCASE) \ 2135 GEN_HDR_ACCESSORS(ses_status_page, SES_STATUS_PAGE, LCASE, UCASE) 2136 2137 GEN_SES_STATUS_PAGE_ACCESSORS(invop, INVOP) 2138 GEN_SES_STATUS_PAGE_ACCESSORS(info, INFO) 2139 GEN_SES_STATUS_PAGE_ACCESSORS(non_crit, NON_CRIT) 2140 GEN_SES_STATUS_PAGE_ACCESSORS(crit, CRIT) 2141 GEN_SES_STATUS_PAGE_ACCESSORS(unrecov, UNRECOV) 2142 GEN_SES_STATUS_PAGE_ACCESSORS(changed, CHANGED) 2143 #undef GEN_SES_STATUS_PAGE_ACCESSORS 2144 2145 /*================ SCSI SES Element Descriptor Diagnostic Page ===============*/ 2146 struct ses_elem_descr { 2147 uint8_t reserved[2]; 2148 uint8_t length[2]; 2149 char description[]; 2150 }; 2151 2152 struct ses_elem_descr_page { 2153 struct ses_page_hdr hdr; 2154 struct ses_elem_descr descrs[]; 2155 }; 2156 2157 /*============ SCSI SES Additional Element Status Diagnostic Page ============*/ 2158 struct ses_addl_elem_status_page { 2159 struct ses_page_hdr hdr; 2160 }; 2161 2162 /*====================== Legacy (Deprecated) Structures ======================*/ 2163 struct ses_control_page_hdr { 2164 uint8_t page_code; 2165 uint8_t control_flags; 2166 uint8_t length[2]; 2167 uint8_t gen_code[4]; 2168 /* Followed by variable length array of descriptors. */ 2169 }; 2170 2171 struct ses_status_page_hdr { 2172 uint8_t page_code; 2173 uint8_t status_flags; 2174 uint8_t length[2]; 2175 uint8_t gen_code[4]; 2176 /* Followed by variable length array of descriptors. */ 2177 }; 2178 2179 /* ses_page_hdr.reserved values */ 2180 /* 2181 * Enclosure Status Diagnostic Page: 2182 * uint8_t reserved : 3, 2183 * invop : 1, 2184 * info : 1, 2185 * noncritical : 1, 2186 * critical : 1, 2187 * unrecov : 1; 2188 */ 2189 #define SES_ENCSTAT_UNRECOV 0x01 2190 #define SES_ENCSTAT_CRITICAL 0x02 2191 #define SES_ENCSTAT_NONCRITICAL 0x04 2192 #define SES_ENCSTAT_INFO 0x08 2193 #define SES_ENCSTAT_INVOP 0x10 2194 /* Status mask: All of the above OR'd together */ 2195 #define SES_STATUS_MASK 0x1f 2196 #define SES_SET_STATUS_MASK 0xf 2197 /* Element Descriptor Diagnostic Page: unused */ 2198 /* Additional Element Status Diagnostic Page: unused */ 2199 2200 /* Summary SES Status Defines, Common Status Codes */ 2201 #define SES_OBJSTAT_UNSUPPORTED 0 2202 #define SES_OBJSTAT_OK 1 2203 #define SES_OBJSTAT_CRIT 2 2204 #define SES_OBJSTAT_NONCRIT 3 2205 #define SES_OBJSTAT_UNRECOV 4 2206 #define SES_OBJSTAT_NOTINSTALLED 5 2207 #define SES_OBJSTAT_UNKNOWN 6 2208 #define SES_OBJSTAT_NOTAVAIL 7 2209 #define SES_OBJSTAT_NOACCESS 8 2210 2211 /* 2212 * For control pages, cstat[0] is the same for the 2213 * enclosure and is common across all device types. 2214 * 2215 * If SESCTL_CSEL is set, then PRDFAIL, DISABLE and RSTSWAP 2216 * are checked, otherwise bits that are specific to the device 2217 * type in the other 3 bytes of cstat or checked. 2218 */ 2219 #define SESCTL_CSEL 0x80 2220 #define SESCTL_PRDFAIL 0x40 2221 #define SESCTL_DISABLE 0x20 2222 #define SESCTL_RSTSWAP 0x10 2223 2224 /* Control bits, Array Device Slot Elements, byte 1 */ 2225 #define SESCTL_RQSOK 0x80 /* RQST OK */ 2226 #define SESCTL_RQSRSV 0x40 /* RQST RSVD DEVICE */ 2227 #define SESCTL_RQSSPR 0x20 /* RQST HOT SPARE */ 2228 #define SESCTL_RQSCCH 0x10 /* RQST CONS CHECK */ 2229 #define SESCTL_RQSCRA 0x08 /* RQST IN CRIT ARRAY */ 2230 #define SESCTL_RQSFAA 0x04 /* RQST IN FAILED ARRAY */ 2231 #define SESCTL_RQSRR 0x02 /* RQST REBUI/REMAP */ 2232 #define SESCTL_RQSRRA 0x01 /* RQST R/R ABORT */ 2233 /* Control bits, [Array] Device Slot Elements, byte 2 */ 2234 #define SESCTL_RQSACT 0x80 /* RQST ACTIVE */ 2235 #define SESCTL_DRVLCK 0x40 /* DO NOT REMOVE */ 2236 #define SESCTL_RQSMSN 0x10 /* RQST MISSING */ 2237 #define SESCTL_RQSINS 0x08 /* RQST INSERT */ 2238 #define SESCTL_RQSRMV 0x04 /* RQST REMOVE */ 2239 #define SESCTL_RQSID 0x02 /* RQST IDENT */ 2240 /* Control bits, [Array] Device Slot Elements, byte 3 */ 2241 #define SESCTL_RQSFLT 0x20 /* RQST FAULT */ 2242 #define SESCTL_DEVOFF 0x10 /* DEVICE OFF */ 2243 #define SESCTL_ENBYPA 0x08 /* ENABLE BYP A */ 2244 #define SESCTL_ENBYPB 0x04 /* ENABLE BYP B */ 2245 2246 /* Control bits, Generic, byte 3 */ 2247 #define SESCTL_RQSTFAIL 0x40 2248 #define SESCTL_RQSTON 0x20 2249 2250 /* 2251 * Getting text for an object type is a little 2252 * trickier because it's string data that can 2253 * go up to 64 KBytes. Build this union and 2254 * fill the obj_id with the id of the object who's 2255 * help text you want, and if text is available, 2256 * obj_text will be filled in, null terminated. 2257 */ 2258 2259 typedef union { 2260 unsigned int obj_id; 2261 char obj_text[1]; 2262 } ses_hlptxt; 2263 2264 /*============================================================================*/ 2265 struct ses_elm_desc_hdr { 2266 uint8_t reserved[2]; 2267 uint8_t length[2]; 2268 }; 2269 2270 /* 2271 * SES v2 r20 6.1.13 - Element Additional Status diagnostic page 2272 * Tables 26-28 (general), 29-32 (FC), 33-41 (SAS) 2273 * 2274 * Protocol identifier uses definitions in scsi_all.h; 2275 * SPSP_PROTO_FC, SPSP_PROTO_SAS are the only ones used here. 2276 */ 2277 2278 struct ses_elm_fc_eip_hdr { 2279 uint8_t num_phys; 2280 uint8_t reserved[2]; 2281 uint8_t dev_slot_num; 2282 uint8_t node_name[8]; 2283 }; 2284 2285 struct ses_elm_fc_noneip_hdr { 2286 uint8_t num_phys; 2287 uint8_t reserved; 2288 uint8_t node_name[8]; 2289 }; 2290 2291 struct ses_elm_fc_base_hdr { 2292 uint8_t num_phys; 2293 }; 2294 2295 union ses_elm_fc_hdr { 2296 struct ses_elm_fc_base_hdr base_hdr; 2297 struct ses_elm_fc_eip_hdr eip_hdr; 2298 struct ses_elm_fc_noneip_hdr noneip_hdr; 2299 }; 2300 2301 struct ses_elm_fc_port { 2302 uint8_t port_loop_position; 2303 uint8_t bypass_reason; 2304 #define SES_FC_PORT_BYPASS_UNBYPASSED 0x00 2305 2306 #define SES_FC_PORT_BYPASS_LINKFAIL_RATE_TOO_HIGH 0x10 2307 #define SES_FC_PORT_BYPASS_SYNC_LOSS_RATE_TOO_HIGH 0x11 2308 #define SES_FC_PORT_BYPASS_SIGNAL_LOSS_RATE_TOO_HIGH 0x12 2309 #define SES_FC_PORT_BYPASS_SEQPROTO_ERR_RATE_TOO_HIGH 0x13 2310 #define SES_FC_PORT_BYPASS_INVAL_XMIT_RATE_TOO_HIGH 0x14 2311 #define SES_FC_PORT_BYPASS_CRC_ERR_RATE_TOO_HIGH 0x15 2312 2313 #define SES_FC_PORT_BYPASS_ERR_RATE_RESERVED_BEGIN 0x16 2314 #define SES_FC_PORT_BYPASS_ERR_RATE_RESERVED_END 0x1F 2315 2316 #define SES_FC_PORT_BYPASS_LINKFAIL_COUNT_TOO_HIGH 0x20 2317 #define SES_FC_PORT_BYPASS_SYNC_LOSS_COUNT_TOO_HIGH 0x21 2318 #define SES_FC_PORT_BYPASS_SIGNAL_LOSS_COUNT_TOO_HIGH 0x22 2319 #define SES_FC_PORT_BYPASS_SEQPROTO_ERR_COUNT_TOO_HIGH 0x23 2320 #define SES_FC_PORT_BYPASS_INVAL_XMIT_COUNT_TOO_HIGH 0x24 2321 #define SES_FC_PORT_BYPASS_CRC_ERR_COUNT_TOO_HIGH 0x25 2322 2323 #define SES_FC_PORT_BYPASS_ERR_COUNT_RESERVED_BEGIN 0x26 2324 #define SES_FC_PORT_BYPASS_ERR_COUNT_RESERVED_END 0x2F 2325 2326 #define SES_FC_PORT_BYPASS_RESERVED_BEGIN 0x30 2327 #define SES_FC_PORT_BYPASS_RESERVED_END 0xBF 2328 2329 #define SES_FC_PORT_BYPASS_VENDOR_SPECIFIC_BEGIN 0xC0 2330 #define SES_FC_PORT_BYPASS_VENDOR_SPECIFIC_END 0xFF 2331 uint8_t port_req_hard_addr; 2332 uint8_t n_port_id[3]; 2333 uint8_t n_port_name[8]; 2334 }; 2335 2336 struct ses_elm_sas_device_phy { 2337 uint8_t byte0; 2338 /* 2339 * uint8_t reserved0 : 1, 2340 * uint8_t device_type : 3, 2341 * uint8_t reserved1 : 4; 2342 */ 2343 2344 uint8_t reserved0; 2345 2346 /* Bit positions for initiator and target port protocols */ 2347 #define SES_SASOBJ_DEV_PHY_SMP 0x2 2348 #define SES_SASOBJ_DEV_PHY_STP 0x4 2349 #define SES_SASOBJ_DEV_PHY_SSP 0x8 2350 /* Select all of the above protocols */ 2351 #define SES_SASOBJ_DEV_PHY_PROTOMASK 0xe 2352 uint8_t initiator_ports; 2353 /* 2354 * uint8_t reserved0 : 4, 2355 * uint8_t ssp : 1, 2356 * uint8_t stp : 1, 2357 * uint8_t smp : 1, 2358 * uint8_t reserved1 : 3; 2359 */ 2360 uint8_t target_ports; 2361 /* 2362 * uint8_t sata_port_selector : 1, 2363 * uint8_t reserved : 3, 2364 * uint8_t ssp : 1, 2365 * uint8_t stp : 1, 2366 * uint8_t smp : 1, 2367 * uint8_t sata_device : 1; 2368 */ 2369 uint8_t parent_addr[8]; /* SAS address of parent */ 2370 uint8_t phy_addr[8]; /* SAS address of this phy */ 2371 uint8_t phy_id; 2372 uint8_t reserved1[7]; 2373 }; 2374 #ifdef _KERNEL 2375 int ses_elm_sas_dev_phy_sata_dev(struct ses_elm_sas_device_phy *); 2376 int ses_elm_sas_dev_phy_sata_port(struct ses_elm_sas_device_phy *); 2377 int ses_elm_sas_dev_phy_dev_type(struct ses_elm_sas_device_phy *); 2378 #endif /* _KERNEL */ 2379 2380 struct ses_elm_sas_expander_phy { 2381 uint8_t connector_index; 2382 uint8_t other_index; 2383 }; 2384 2385 struct ses_elm_sas_port_phy { 2386 uint8_t phy_id; 2387 uint8_t reserved; 2388 uint8_t connector_index; 2389 uint8_t other_index; 2390 uint8_t phy_addr[8]; 2391 }; 2392 2393 struct ses_elm_sas_type0_base_hdr { 2394 uint8_t num_phys; 2395 uint8_t byte1; 2396 /* 2397 * uint8_t descriptor_type : 2, 2398 * uint8_t reserved : 5, 2399 * uint8_t not_all_phys : 1; 2400 */ 2401 #define SES_SASOBJ_TYPE0_NOT_ALL_PHYS(obj) \ 2402 ((obj)->byte1 & 0x1) 2403 }; 2404 2405 struct ses_elm_sas_type0_eip_hdr { 2406 struct ses_elm_sas_type0_base_hdr base; 2407 uint8_t reserved; 2408 uint8_t dev_slot_num; 2409 }; 2410 2411 struct ses_elm_sas_type1_expander_hdr { 2412 uint8_t num_phys; 2413 uint8_t byte1; 2414 /* 2415 * uint8_t descriptor_type : 2, 2416 * uint8_t reserved : 6; 2417 */ 2418 uint8_t reserved[2]; 2419 uint8_t sas_addr[8]; 2420 }; 2421 2422 struct ses_elm_sas_type1_nonexpander_hdr { 2423 uint8_t num_phys; 2424 uint8_t byte1; 2425 /* 2426 * uint8_t descriptor_type : 2, 2427 * uint8_t reserved : 6; 2428 */ 2429 uint8_t reserved[2]; 2430 }; 2431 2432 /* NB: This is only usable for as long as the headers happen to match */ 2433 struct ses_elm_sas_base_hdr { 2434 uint8_t num_phys; 2435 uint8_t byte1; 2436 /* 2437 * uint8_t descriptor_type : 2, 2438 * uint8_t descr_specific : 6; 2439 */ 2440 #define SES_SASOBJ_TYPE_SLOT 0 2441 #define SES_SASOBJ_TYPE_OTHER 1 2442 }; 2443 2444 union ses_elm_sas_hdr { 2445 struct ses_elm_sas_base_hdr base_hdr; 2446 struct ses_elm_sas_type0_base_hdr type0_noneip; 2447 struct ses_elm_sas_type0_eip_hdr type0_eip; 2448 struct ses_elm_sas_type1_expander_hdr type1_exp; 2449 struct ses_elm_sas_type1_nonexpander_hdr type1_nonexp; 2450 }; 2451 int ses_elm_sas_type0_not_all_phys(union ses_elm_sas_hdr *); 2452 int ses_elm_sas_descr_type(union ses_elm_sas_hdr *); 2453 2454 /* 2455 * This structure for SPSP_PROTO_ATA is not defined by SES specs, 2456 * but purely my own design to make AHCI EM interoperate with SES. 2457 * Since no other software I know can talk to SEMB, and we do not 2458 * expose this outside, it should be safe to do what we want. 2459 */ 2460 struct ses_elm_ata_hdr { 2461 uint8_t bus[4]; 2462 uint8_t target[4]; 2463 }; 2464 2465 struct ses_elm_addlstatus_base_hdr { 2466 uint8_t byte0; 2467 /* 2468 * uint8_t invalid : 1, 2469 * uint8_t reserved : 2, 2470 * uint8_t eip : 1, 2471 * uint8_t proto_id : 4; 2472 */ 2473 uint8_t length; 2474 }; 2475 int ses_elm_addlstatus_proto(struct ses_elm_addlstatus_base_hdr *); 2476 int ses_elm_addlstatus_eip(struct ses_elm_addlstatus_base_hdr *); 2477 int ses_elm_addlstatus_invalid(struct ses_elm_addlstatus_base_hdr *); 2478 2479 struct ses_elm_addlstatus_eip_hdr { 2480 struct ses_elm_addlstatus_base_hdr base; 2481 uint8_t byte2; 2482 #define SES_ADDL_EIP_EIIOE_MASK 3 2483 #define SES_ADDL_EIP_EIIOE_SES2 0 2484 #define SES_ADDL_EIP_EIIOE_GLOB 1 2485 #define SES_ADDL_EIP_EIIOE_IND 2 2486 #define SES_ADDL_EIP_EIIOE_MIX 3 2487 #define SES_ADDL_EIP_EIIOE_EI_GLOB(x) \ 2488 (((x) & SES_ADDL_EIP_EIIOE_MASK) == SES_ADDL_EIP_EIIOE_GLOB) 2489 uint8_t element_index; 2490 /* NB: This define (currently) applies to all eip=1 headers */ 2491 #define SES_EIP_HDR_EXTRA_LEN 2 2492 }; 2493 2494 union ses_elm_addlstatus_descr_hdr { 2495 struct ses_elm_addlstatus_base_hdr base; 2496 struct ses_elm_addlstatus_eip_hdr eip; 2497 }; 2498 2499 union ses_elm_addlstatus_proto_hdr { 2500 union ses_elm_fc_hdr fc; 2501 union ses_elm_sas_hdr sas; 2502 }; 2503 2504 /*============================= Namespace Cleanup ============================*/ 2505 #undef GEN_HDR_ACCESSORS 2506 #undef GEN_ACCESSORS 2507 #undef GEN_HDR_SETTER 2508 #undef GEN_HDR_GETTER 2509 #undef GEN_SETTER 2510 #undef GEN_GETTER 2511 #undef MK_ENUM 2512 2513 #endif /* _SCSI_SES_H_ */ 2514