/* * harness_dcn10.c — unit-level proof of the hw_translate_dcn10 defects * (DragonFlyBSD pass-2 audit, file: * sys/dev/drm/amd/display/dc/gpio/dcn10/hw_translate_dcn10.c) * * offset_to_id() and id_to_offset() below are VERBATIM copies from * hw_translate_dcn10.c lines 61-201 and 203-388 with exactly one substitution: * ASSERT_CRITICAL(false) maps to a printf marker. * Register constants are the real DCN10/Raven values: * REG(x) = DCE_BASE__INST0_SEG2 (0x34C0) + mm x (vega10_ip_offset.h:277, * dcn_1_0_offset.h: BASE_IDX 2 for all DC_GPIO regs). * Enums are the real gpio_types.h values. * * Tests: * T1 (DF-4946): all eight DDC-family offsets return true WITHOUT writing *id; * en=6 (DDC_VGA) / en=7 (I2C_PAD) index hpd_regs[6] OOB when the * garbage id decodes to GPIO_ID_HPD in dal_gpio_create_irq. * T2 (negative): no GPIOPAD cross-domain case (DF-4942 producer absent); * "Not implemented" offsets return false. * T3 (DF-4947): id_to_offset(DDC_DATA, I2C_PAD) hands out the DDC6DATA mask * 0x100 for DC_GPIO_I2CPAD_A whose SDA field is bit 1 (0x2) — * per ddc_regs.h the factory table uses SDA_A_MASK for that pin. * T4 (negative): the HPD branch is well-formed (id written, en 0..5). */ #include #include #include #include #define ASSERT_CRITICAL(x) printf(" [ASSERT_CRITICAL hit]\n") enum gpio_id { GPIO_ID_UNKNOWN = (-1), GPIO_ID_DDC_DATA, GPIO_ID_DDC_CLOCK, GPIO_ID_GENERIC, GPIO_ID_HPD, GPIO_ID_GPIO_PAD, GPIO_ID_VIP_PAD, GPIO_ID_SYNC, GPIO_ID_GSL, GPIO_ID_COUNT, }; #define GPIO_ENUM_UNKNOWN 32 struct gpio_pin_info { uint32_t offset, offset_y, offset_en, offset_mask; uint32_t mask, mask_y, mask_en, mask_mask; }; enum gpio_generic { GPIO_GENERIC_UNKNOWN=(-1), GPIO_GENERIC_A, GPIO_GENERIC_B, GPIO_GENERIC_C, GPIO_GENERIC_D, GPIO_GENERIC_E, GPIO_GENERIC_F, GPIO_GENERIC_G, GPIO_GENERIC_COUNT }; enum gpio_hpd { GPIO_HPD_UNKNOWN=(-1), GPIO_HPD_1, GPIO_HPD_2, GPIO_HPD_3, GPIO_HPD_4, GPIO_HPD_5, GPIO_HPD_6, GPIO_HPD_COUNT }; enum gpio_sync { GPIO_SYNC_UNKNOWN=(-1), GPIO_SYNC_HSYNC_A, GPIO_SYNC_VSYNC_A, GPIO_SYNC_HSYNC_B, GPIO_SYNC_VSYNC_B, GPIO_SYNC_COUNT }; enum gpio_gsl { GPIO_GSL_UNKNOWN=(-1), GPIO_GSL_GENLOCK_CLOCK, GPIO_GSL_GENLOCK_VSYNC, GPIO_GSL_SWAPLOCK_A, GPIO_GSL_SWAPLOCK_B, GPIO_GSL_COUNT }; enum gpio_ddc_line { GPIO_DDC_LINE_UNKNOWN=(-1), GPIO_DDC_LINE_DDC1, GPIO_DDC_LINE_DDC2, GPIO_DDC_LINE_DDC3, GPIO_DDC_LINE_DDC4, GPIO_DDC_LINE_DDC5, GPIO_DDC_LINE_DDC6, GPIO_DDC_LINE_DDC_VGA, GPIO_DDC_LINE_VIP_PAD, GPIO_DDC_LINE_I2C_PAD = GPIO_DDC_LINE_VIP_PAD, GPIO_DDC_LINE_COUNT }; /* REG() arithmetic per hw_translate_dcn10.c:44-56 */ #define BASE_INNER(seg) DCE_BASE__INST0_SEG ## seg #define BASE(seg) BASE_INNER(seg) #define REG(reg_name) BASE(mm ## reg_name ## _BASE_IDX) + mm ## reg_name #define DCE_BASE__INST0_SEG2 0x34C0 /* dcn_1_0_offset.h (all BASE_IDX 2) */ #define mmDC_GPIO_GENERIC_A 0x28c9 #define mmDC_GPIO_GENERIC_A_BASE_IDX 2 #define mmDC_GPIO_DDC1_A 0x28d1 #define mmDC_GPIO_DDC1_A_BASE_IDX 2 #define mmDC_GPIO_DDC2_A 0x28d5 #define mmDC_GPIO_DDC2_A_BASE_IDX 2 #define mmDC_GPIO_DDC3_A 0x28d9 #define mmDC_GPIO_DDC3_A_BASE_IDX 2 #define mmDC_GPIO_DDC4_A 0x28dd #define mmDC_GPIO_DDC4_A_BASE_IDX 2 #define mmDC_GPIO_DDC5_A 0x28e1 #define mmDC_GPIO_DDC5_A_BASE_IDX 2 #define mmDC_GPIO_DDC6_A 0x28e5 #define mmDC_GPIO_DDC6_A_BASE_IDX 2 #define mmDC_GPIO_DDCVGA_A 0x28e9 #define mmDC_GPIO_DDCVGA_A_BASE_IDX 2 #define mmDC_GPIO_SYNCA_A 0x28ed #define mmDC_GPIO_SYNCA_A_BASE_IDX 2 #define mmDC_GPIO_GENLK_A 0x28f1 #define mmDC_GPIO_GENLK_A_BASE_IDX 2 #define mmDC_GPIO_HPD_A 0x28f5 #define mmDC_GPIO_HPD_A_BASE_IDX 2 #define mmDC_GPIO_PWRSEQ_A 0x28f9 #define mmDC_GPIO_PWRSEQ_A_BASE_IDX 2 #define mmDC_GPIO_PAD_STRENGTH_1 0x28fc #define mmDC_GPIO_PAD_STRENGTH_1_BASE_IDX 2 #define mmDC_GPIO_PAD_STRENGTH_2 0x28fd #define mmDC_GPIO_PAD_STRENGTH_2_BASE_IDX 2 #define mmDC_GPIO_I2CPAD_A 0x2901 #define mmDC_GPIO_I2CPAD_A_BASE_IDX 2 #define mmDC_GPIO_DEBUG 0x286c #define mmDC_GPIO_DEBUG_BASE_IDX 2 /* dcn_1_0_sh_mask.h */ #define DC_GPIO_GENERIC_A__DC_GPIO_GENERICA_A_MASK 0x00000001L #define DC_GPIO_GENERIC_A__DC_GPIO_GENERICB_A_MASK 0x00000100L #define DC_GPIO_GENERIC_A__DC_GPIO_GENERICC_A_MASK 0x00010000L #define DC_GPIO_GENERIC_A__DC_GPIO_GENERICD_A_MASK 0x00100000L #define DC_GPIO_GENERIC_A__DC_GPIO_GENERICE_A_MASK 0x00200000L #define DC_GPIO_GENERIC_A__DC_GPIO_GENERICF_A_MASK 0x00400000L #define DC_GPIO_GENERIC_A__DC_GPIO_GENERICG_A_MASK 0x00800000L #define DC_GPIO_HPD_A__DC_GPIO_HPD1_A_MASK 0x00000001L #define DC_GPIO_HPD_A__DC_GPIO_HPD2_A_MASK 0x00000100L #define DC_GPIO_HPD_A__DC_GPIO_HPD3_A_MASK 0x00010000L #define DC_GPIO_HPD_A__DC_GPIO_HPD4_A_MASK 0x01000000L #define DC_GPIO_HPD_A__DC_GPIO_HPD5_A_MASK 0x04000000L #define DC_GPIO_HPD_A__DC_GPIO_HPD6_A_MASK 0x10000000L #define DC_GPIO_SYNCA_A__DC_GPIO_HSYNCA_A_MASK 0x00000001L #define DC_GPIO_SYNCA_A__DC_GPIO_VSYNCA_A_MASK 0x00000100L #define DC_GPIO_GENLK_A__DC_GPIO_GENLK_CLK_A_MASK 0x00000001L #define DC_GPIO_GENLK_A__DC_GPIO_GENLK_VSYNC_A_MASK 0x00000100L #define DC_GPIO_GENLK_A__DC_GPIO_SWAPLOCK_A_A_MASK 0x00010000L #define DC_GPIO_GENLK_A__DC_GPIO_SWAPLOCK_B_A_MASK 0x01000000L #define DC_GPIO_DDC6_A__DC_GPIO_DDC6DATA_A_MASK 0x00000100L #define DC_GPIO_DDC6_A__DC_GPIO_DDC6CLK_A_MASK 0x00000001L /* truth for T3: DC_GPIO_I2CPAD_A's SDA/SCL field positions (dcn_1_0_sh_mask.h * 41216-41219) and the factory table's own use of them (ddc_regs.h:69-71) */ #define DC_GPIO_I2CPAD_A__DC_GPIO_SCL_A_MASK 0x00000001L #define DC_GPIO_I2CPAD_A__DC_GPIO_SDA_A_MASK 0x00000002L #define HPD_REGS_SIZE 6 /* hw_factory_dcn10.c:71-78 hpd_regs[] */ #define DDC_REGS_SIZE 8 /* hw_factory_dcn10.c:94-114 ddc_data_regs/ddc_clk_regs[] */ /* ============ VERBATIM from hw_translate_dcn10.c:61-201 ============ */ static bool offset_to_id( uint32_t offset, uint32_t mask, enum gpio_id *id, uint32_t *en) { switch (offset) { /* GENERIC */ case REG(DC_GPIO_GENERIC_A): *id = GPIO_ID_GENERIC; switch (mask) { case DC_GPIO_GENERIC_A__DC_GPIO_GENERICA_A_MASK: *en = GPIO_GENERIC_A; return true; case DC_GPIO_GENERIC_A__DC_GPIO_GENERICB_A_MASK: *en = GPIO_GENERIC_B; return true; case DC_GPIO_GENERIC_A__DC_GPIO_GENERICC_A_MASK: *en = GPIO_GENERIC_C; return true; case DC_GPIO_GENERIC_A__DC_GPIO_GENERICD_A_MASK: *en = GPIO_GENERIC_D; return true; case DC_GPIO_GENERIC_A__DC_GPIO_GENERICE_A_MASK: *en = GPIO_GENERIC_E; return true; case DC_GPIO_GENERIC_A__DC_GPIO_GENERICF_A_MASK: *en = GPIO_GENERIC_F; return true; case DC_GPIO_GENERIC_A__DC_GPIO_GENERICG_A_MASK: *en = GPIO_GENERIC_G; return true; default: ASSERT_CRITICAL(false); return false; } break; /* HPD */ case REG(DC_GPIO_HPD_A): *id = GPIO_ID_HPD; switch (mask) { case DC_GPIO_HPD_A__DC_GPIO_HPD1_A_MASK: *en = GPIO_HPD_1; return true; case DC_GPIO_HPD_A__DC_GPIO_HPD2_A_MASK: *en = GPIO_HPD_2; return true; case DC_GPIO_HPD_A__DC_GPIO_HPD3_A_MASK: *en = GPIO_HPD_3; return true; case DC_GPIO_HPD_A__DC_GPIO_HPD4_A_MASK: *en = GPIO_HPD_4; return true; case DC_GPIO_HPD_A__DC_GPIO_HPD5_A_MASK: *en = GPIO_HPD_5; return true; case DC_GPIO_HPD_A__DC_GPIO_HPD6_A_MASK: *en = GPIO_HPD_6; return true; default: ASSERT_CRITICAL(false); return false; } break; /* SYNCA */ case REG(DC_GPIO_SYNCA_A): *id = GPIO_ID_SYNC; switch (mask) { case DC_GPIO_SYNCA_A__DC_GPIO_HSYNCA_A_MASK: *en = GPIO_SYNC_HSYNC_A; return true; case DC_GPIO_SYNCA_A__DC_GPIO_VSYNCA_A_MASK: *en = GPIO_SYNC_VSYNC_A; return true; default: ASSERT_CRITICAL(false); return false; } break; /* REG(DC_GPIO_GENLK_MASK */ case REG(DC_GPIO_GENLK_A): *id = GPIO_ID_GSL; switch (mask) { case DC_GPIO_GENLK_A__DC_GPIO_GENLK_CLK_A_MASK: *en = GPIO_GSL_GENLOCK_CLOCK; return true; case DC_GPIO_GENLK_A__DC_GPIO_GENLK_VSYNC_A_MASK: *en = GPIO_GSL_GENLOCK_VSYNC; return true; case DC_GPIO_GENLK_A__DC_GPIO_SWAPLOCK_A_A_MASK: *en = GPIO_GSL_SWAPLOCK_A; return true; case DC_GPIO_GENLK_A__DC_GPIO_SWAPLOCK_B_A_MASK: *en = GPIO_GSL_SWAPLOCK_B; return true; default: ASSERT_CRITICAL(false); return false; } break; /* DDC */ /* we don't care about the GPIO_ID for DDC * in DdcHandle it will use GPIO_ID_DDC_DATA/GPIO_ID_DDC_CLOCK * directly in the create method */ case REG(DC_GPIO_DDC1_A): *en = GPIO_DDC_LINE_DDC1; return true; case REG(DC_GPIO_DDC2_A): *en = GPIO_DDC_LINE_DDC2; return true; case REG(DC_GPIO_DDC3_A): *en = GPIO_DDC_LINE_DDC3; return true; case REG(DC_GPIO_DDC4_A): *en = GPIO_DDC_LINE_DDC4; return true; case REG(DC_GPIO_DDC5_A): *en = GPIO_DDC_LINE_DDC5; return true; case REG(DC_GPIO_DDC6_A): *en = GPIO_DDC_LINE_DDC6; return true; case REG(DC_GPIO_DDCVGA_A): *en = GPIO_DDC_LINE_DDC_VGA; return true; /* GPIO_I2CPAD */ case REG(DC_GPIO_I2CPAD_A): *en = GPIO_DDC_LINE_I2C_PAD; return true; /* Not implemented */ case REG(DC_GPIO_PWRSEQ_A): case REG(DC_GPIO_PAD_STRENGTH_1): case REG(DC_GPIO_PAD_STRENGTH_2): case REG(DC_GPIO_DEBUG): return false; /* UNEXPECTED */ default: ASSERT_CRITICAL(false); return false; } } /* ============ VERBATIM from hw_translate_dcn10.c:203-388 ============ */ static bool id_to_offset( enum gpio_id id, uint32_t en, struct gpio_pin_info *info) { bool result = true; switch (id) { case GPIO_ID_DDC_DATA: info->mask = DC_GPIO_DDC6_A__DC_GPIO_DDC6DATA_A_MASK; switch (en) { case GPIO_DDC_LINE_DDC1: info->offset = REG(DC_GPIO_DDC1_A); break; case GPIO_DDC_LINE_DDC2: info->offset = REG(DC_GPIO_DDC2_A); break; case GPIO_DDC_LINE_DDC3: info->offset = REG(DC_GPIO_DDC3_A); break; case GPIO_DDC_LINE_DDC4: info->offset = REG(DC_GPIO_DDC4_A); break; case GPIO_DDC_LINE_DDC5: info->offset = REG(DC_GPIO_DDC5_A); break; case GPIO_DDC_LINE_DDC6: info->offset = REG(DC_GPIO_DDC6_A); break; case GPIO_DDC_LINE_DDC_VGA: info->offset = REG(DC_GPIO_DDCVGA_A); break; case GPIO_DDC_LINE_I2C_PAD: info->offset = REG(DC_GPIO_I2CPAD_A); break; default: ASSERT_CRITICAL(false); result = false; } break; case GPIO_ID_DDC_CLOCK: info->mask = DC_GPIO_DDC6_A__DC_GPIO_DDC6CLK_A_MASK; switch (en) { case GPIO_DDC_LINE_DDC1: info->offset = REG(DC_GPIO_DDC1_A); break; case GPIO_DDC_LINE_DDC2: info->offset = REG(DC_GPIO_DDC2_A); break; case GPIO_DDC_LINE_DDC3: info->offset = REG(DC_GPIO_DDC3_A); break; case GPIO_DDC_LINE_DDC4: info->offset = REG(DC_GPIO_DDC4_A); break; case GPIO_DDC_LINE_DDC5: info->offset = REG(DC_GPIO_DDC5_A); break; case GPIO_DDC_LINE_DDC6: info->offset = REG(DC_GPIO_DDC6_A); break; case GPIO_DDC_LINE_DDC_VGA: info->offset = REG(DC_GPIO_DDCVGA_A); break; case GPIO_DDC_LINE_I2C_PAD: info->offset = REG(DC_GPIO_I2CPAD_A); break; default: ASSERT_CRITICAL(false); result = false; } break; case GPIO_ID_GENERIC: info->offset = REG(DC_GPIO_GENERIC_A); switch (en) { case GPIO_GENERIC_A: info->mask = DC_GPIO_GENERIC_A__DC_GPIO_GENERICA_A_MASK; break; case GPIO_GENERIC_B: info->mask = DC_GPIO_GENERIC_A__DC_GPIO_GENERICB_A_MASK; break; case GPIO_GENERIC_C: info->mask = DC_GPIO_GENERIC_A__DC_GPIO_GENERICC_A_MASK; break; case GPIO_GENERIC_D: info->mask = DC_GPIO_GENERIC_A__DC_GPIO_GENERICD_A_MASK; break; case GPIO_GENERIC_E: info->mask = DC_GPIO_GENERIC_A__DC_GPIO_GENERICE_A_MASK; break; case GPIO_GENERIC_F: info->mask = DC_GPIO_GENERIC_A__DC_GPIO_GENERICF_A_MASK; break; case GPIO_GENERIC_G: info->mask = DC_GPIO_GENERIC_A__DC_GPIO_GENERICG_A_MASK; break; default: ASSERT_CRITICAL(false); result = false; } break; case GPIO_ID_HPD: info->offset = REG(DC_GPIO_HPD_A); switch (en) { case GPIO_HPD_1: info->mask = DC_GPIO_HPD_A__DC_GPIO_HPD1_A_MASK; break; case GPIO_HPD_2: info->mask = DC_GPIO_HPD_A__DC_GPIO_HPD2_A_MASK; break; case GPIO_HPD_3: info->mask = DC_GPIO_HPD_A__DC_GPIO_HPD3_A_MASK; break; case GPIO_HPD_4: info->mask = DC_GPIO_HPD_A__DC_GPIO_HPD4_A_MASK; break; case GPIO_HPD_5: info->mask = DC_GPIO_HPD_A__DC_GPIO_HPD5_A_MASK; break; case GPIO_HPD_6: info->mask = DC_GPIO_HPD_A__DC_GPIO_HPD6_A_MASK; break; default: ASSERT_CRITICAL(false); result = false; } break; case GPIO_ID_SYNC: switch (en) { case GPIO_SYNC_HSYNC_A: info->offset = REG(DC_GPIO_SYNCA_A); info->mask = DC_GPIO_SYNCA_A__DC_GPIO_HSYNCA_A_MASK; break; case GPIO_SYNC_VSYNC_A: info->offset = REG(DC_GPIO_SYNCA_A); info->mask = DC_GPIO_SYNCA_A__DC_GPIO_VSYNCA_A_MASK; break; case GPIO_SYNC_HSYNC_B: case GPIO_SYNC_VSYNC_B: default: ASSERT_CRITICAL(false); result = false; } break; case GPIO_ID_GSL: switch (en) { case GPIO_GSL_GENLOCK_CLOCK: info->offset = REG(DC_GPIO_GENLK_A); info->mask = DC_GPIO_GENLK_A__DC_GPIO_GENLK_CLK_A_MASK; break; case GPIO_GSL_GENLOCK_VSYNC: info->offset = REG(DC_GPIO_GENLK_A); info->mask = DC_GPIO_GENLK_A__DC_GPIO_GENLK_VSYNC_A_MASK; break; case GPIO_GSL_SWAPLOCK_A: info->offset = REG(DC_GPIO_GENLK_A); info->mask = DC_GPIO_GENLK_A__DC_GPIO_SWAPLOCK_A_A_MASK; break; case GPIO_GSL_SWAPLOCK_B: info->offset = REG(DC_GPIO_GENLK_A); info->mask = DC_GPIO_GENLK_A__DC_GPIO_SWAPLOCK_B_A_MASK; break; default: ASSERT_CRITICAL(false); result = false; } break; case GPIO_ID_VIP_PAD: default: ASSERT_CRITICAL(false); result = false; } if (result) { info->offset_y = info->offset + 2; info->offset_en = info->offset + 1; info->offset_mask = info->offset - 1; info->mask_y = info->mask; info->mask_en = info->mask; info->mask_mask = info->mask; } return result; } int main(void) { int fails = 0; enum gpio_id id; uint32_t en; bool r; struct gpio_pin_info info; int i; printf("== DCN10 REG() domain: REG(DC_GPIO_DDC1_A)=0x%x REG(DC_GPIO_DDCVGA_A)=0x%x REG(DC_GPIO_I2CPAD_A)=0x%x ==\n", REG(DC_GPIO_DDC1_A), REG(DC_GPIO_DDCVGA_A), REG(DC_GPIO_I2CPAD_A)); printf("(VBIOS gpio_pin_lut data_a_reg_index stores these full offsets — bios_parser2.c:537-539)\n\n"); printf("== T1: DDC/VGA/I2CPAD offsets return success WITHOUT writing *id (DF-4946) ==\n"); printf("(dal_gpio_service_create_irq gpio_service.c:148-149 declares 'enum gpio_id id;' uninitialized)\n"); { static const struct { uint32_t off; const char *nm; } ddc8[] = { { REG(DC_GPIO_DDC1_A), "DDC1" }, { REG(DC_GPIO_DDC2_A), "DDC2" }, { REG(DC_GPIO_DDC3_A), "DDC3" }, { REG(DC_GPIO_DDC4_A), "DDC4" }, { REG(DC_GPIO_DDC5_A), "DDC5" }, { REG(DC_GPIO_DDC6_A), "DDC6" }, { REG(DC_GPIO_DDCVGA_A), "DDCVGA" }, { REG(DC_GPIO_I2CPAD_A), "I2CPAD" }, }; for (i = 0; i < 8; i++) { id = (enum gpio_id)0x7B7B7B7B; r = offset_to_id(ddc8[i].off, 0x100 /* mask ignored in these branches */, &id, &en); printf("offset_to_id(REG(%-6s),0x100) = %-5s en=%d (id==0x%x %s)\n", ddc8[i].nm, r ? "true" : "false", en, (unsigned)id, id == (enum gpio_id)0x7B7B7B7B ? "UNTOUCHED" : "written"); if (r && id == (enum gpio_id)0x7B7B7B7B) { fails++; printf(" -> BUG(DF-4946): success, *id never written"); if (en >= HPD_REGS_SIZE) printf("; garbage id==GPIO_ID_HPD(3) => dal_gpio_create(HPD, en=%d) indexes hpd_regs[%d] OOB (hpd_regs has %d entries)", en, en, HPD_REGS_SIZE); else if (en >= DDC_REGS_SIZE) printf("; en=%d also exceeds ddc_regs[%d]", en, DDC_REGS_SIZE); printf("\n"); } } } printf("\n== T2 (negative): no GPIOPAD cross-domain case; Not-implemented rejects ==\n"); id = (enum gpio_id)0x7B7B7B7B; r = offset_to_id(0x183 /* mmGPIOPAD_A raw, the DF-4942 dce80 producer */, 1u << 20, &id, &en); printf("offset_to_id(0x183,1<<20) = %s (no GPIOPAD mapping -> rejected: OK;" " the dce80-style deterministic producer does not exist on DCN10)\n", r ? "true" : "false"); if (r) fails++; id = (enum gpio_id)0x7B7B7B7B; r = offset_to_id(REG(DC_GPIO_DEBUG), 1, &id, &en); printf("offset_to_id(REG(DC_GPIO_DEBUG)) = %s (Not-implemented path: OK)\n", r ? "true" : "false"); if (r) fails++; printf("\n== T3: id_to_offset DDC mask-vs-index — I2C_PAD data mask is WRONG (DF-4947) ==\n"); memset(&info, 0, sizeof(info)); r = id_to_offset(GPIO_ID_DDC_DATA, GPIO_DDC_LINE_I2C_PAD, &info); printf("id_to_offset(DDC_DATA, I2C_PAD) = %s offset=0x%x mask=0x%x" " — DC_GPIO_I2CPAD_A SDA field is bit1 (0x%x): WRONG BIT\n", r ? "true" : "false", info.offset, info.mask, (unsigned)DC_GPIO_I2CPAD_A__DC_GPIO_SDA_A_MASK); if (r && info.mask != DC_GPIO_I2CPAD_A__DC_GPIO_SDA_A_MASK) fails++; memset(&info, 0, sizeof(info)); r = id_to_offset(GPIO_ID_DDC_CLOCK, GPIO_DDC_LINE_I2C_PAD, &info); printf("id_to_offset(DDC_CLOCK, I2C_PAD) = %s offset=0x%x mask=0x%x" " — SCL field is bit0: coincidentally correct\n", r ? "true" : "false", info.offset, info.mask); memset(&info, 0, sizeof(info)); r = id_to_offset(GPIO_ID_DDC_DATA, GPIO_DDC_LINE_DDC_VGA, &info); printf("id_to_offset(DDC_DATA, DDC_VGA) = %s offset=0x%x mask=0x%x" " — DDCVGADATA_A_MASK is also 0x100: correct by layout\n", r ? "true" : "false", info.offset, info.mask); printf("\n== T4 (negative): HPD branch well-formed ==\n"); for (i = 0; i < 6; i++) { static const uint32_t hmask[6] = { DC_GPIO_HPD_A__DC_GPIO_HPD1_A_MASK, DC_GPIO_HPD_A__DC_GPIO_HPD2_A_MASK, DC_GPIO_HPD_A__DC_GPIO_HPD3_A_MASK, DC_GPIO_HPD_A__DC_GPIO_HPD4_A_MASK, DC_GPIO_HPD_A__DC_GPIO_HPD5_A_MASK, DC_GPIO_HPD_A__DC_GPIO_HPD6_A_MASK }; id = (enum gpio_id)0x7B7B7B7B; r = offset_to_id(REG(DC_GPIO_HPD_A), hmask[i], &id, &en); printf("offset_to_id(REG(HPD),HPD%d mask) = %-5s id=%d en=%d\n", i + 1, r ? "true" : "false", (int)id, en); if (!r || id != GPIO_ID_HPD || en != (uint32_t)i) fails++; } printf("\n%d contract-violation reproductions\n", fails); return (fails > 0) ? 0 : 1; }