tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

soc/tegra: cbb: Change master/slave to initiator/target

Change usage of 'Master/Slave' to 'Initiator/Target' as per the new
convention.

Signed-off-by: Sumit Gupta <sumitg@nvidia.com>
Signed-off-by: Thierry Reding <treding@nvidia.com>

authored by

Sumit Gupta and committed by
Thierry Reding 9c150799 a0647bca

+120 -119
+17 -17
drivers/soc/tegra/cbb/tegra194-cbb.c
··· 1 1 // SPDX-License-Identifier: GPL-2.0 2 2 /* 3 - * Copyright (c) 2021-2022, NVIDIA CORPORATION. All rights reserved 3 + * Copyright (c) 2021-2025, NVIDIA CORPORATION. All rights reserved 4 4 * 5 5 * The driver handles Error's from Control Backbone(CBB) generated due to 6 6 * illegal accesses. When an error is reported from a NOC within CBB, ··· 138 138 struct tegra194_cbb_noc_data { 139 139 const char *name; 140 140 bool erd_mask_inband_err; 141 - const char * const *master_id; 141 + const char * const *initiator_id; 142 142 unsigned int max_aperture; 143 143 const struct tegra194_cbb_aperture *noc_aperture; 144 144 const char * const *routeid_initflow; ··· 216 216 "CH2RFIFOF - Ch2 Request FIFO Full interrupt" 217 217 }; 218 218 219 - static const char * const tegra194_master_id[] = { 219 + static const char * const tegra194_initiator_id[] = { 220 220 [0x0] = "CCPLEX", 221 221 [0x1] = "CCPLEX_DPMU", 222 222 [0x2] = "BPMP", ··· 238 238 { 239 239 .code = "SLV", 240 240 .source = "Target", 241 - .desc = "Target error detected by CBB slave" 241 + .desc = "Target error detected by CBB target" 242 242 }, { 243 243 .code = "DEC", 244 244 .source = "Initiator NIU", ··· 1774 1774 tegra_cbb_print_err(file, "\t AXI ID\t\t: %#x\n", userbits.axi_id); 1775 1775 } 1776 1776 1777 - tegra_cbb_print_err(file, "\t Master ID\t\t: %s\n", 1778 - cbb->noc->master_id[userbits.mstr_id]); 1777 + tegra_cbb_print_err(file, "\t Initiator ID\t\t: %s\n", 1778 + cbb->noc->initiator_id[userbits.mstr_id]); 1779 1779 tegra_cbb_print_err(file, "\t Security Group(GRPSEC): %#x\n", userbits.grpsec); 1780 1780 tegra_cbb_print_cache(file, userbits.axcache); 1781 1781 tegra_cbb_print_prot(file, userbits.axprot); ··· 1837 1837 1838 1838 /* 1839 1839 * Print transcation type, error code and description from ErrLog0 for all 1840 - * errors. For NOC slave errors, all relevant error info is printed using 1840 + * errors. For NOC target errors, all relevant error info is printed using 1841 1841 * ErrLog0 only. But additional information is printed for errors from 1842 - * APB slaves because for them: 1843 - * - All errors are logged as SLV(slave) errors due to APB having only single 1842 + * APB targets because for them: 1843 + * - All errors are logged as SLV(target) errors due to APB having only single 1844 1844 * bit pslverr to report all errors. 1845 1845 * - Exact cause is printed by reading DMAAPB_X_RAW_INTERRUPT_STATUS register. 1846 1846 * - The driver prints information showing AXI2APB bridge and exact error 1847 - * only if there is error in any AXI2APB slave. 1847 + * only if there is error in any AXI2APB target. 1848 1848 * - There is still no way to disambiguate a DEC error from SLV error type. 1849 1849 */ 1850 1850 static bool print_errlog0(struct seq_file *file, struct tegra194_cbb *cbb) ··· 1884 1884 /* For all SLV errors, read DMAAPB_X_RAW_INTERRUPT_STATUS 1885 1885 * register to get error status for all AXI2APB bridges. 1886 1886 * Print bridge details if a bit is set in a bridge's 1887 - * status register due to error in a APB slave connected 1888 - * to that bridge. For other NOC slaves, none of the status 1887 + * status register due to error in a APB target connected 1888 + * to that bridge. For other NOC targets, none of the status 1889 1889 * register will be set. 1890 1890 */ 1891 1891 ··· 2118 2118 static struct tegra194_cbb_noc_data tegra194_cbb_central_noc_data = { 2119 2119 .name = "cbb-noc", 2120 2120 .erd_mask_inband_err = true, 2121 - .master_id = tegra194_master_id, 2121 + .initiator_id = tegra194_initiator_id, 2122 2122 .noc_aperture = tegra194_cbbcentralnoc_apert_lookup, 2123 2123 .max_aperture = ARRAY_SIZE(tegra194_cbbcentralnoc_apert_lookup), 2124 2124 .routeid_initflow = tegra194_cbbcentralnoc_routeid_initflow, ··· 2130 2130 static struct tegra194_cbb_noc_data tegra194_aon_noc_data = { 2131 2131 .name = "aon-noc", 2132 2132 .erd_mask_inband_err = false, 2133 - .master_id = tegra194_master_id, 2133 + .initiator_id = tegra194_initiator_id, 2134 2134 .noc_aperture = tegra194_aonnoc_aperture_lookup, 2135 2135 .max_aperture = ARRAY_SIZE(tegra194_aonnoc_aperture_lookup), 2136 2136 .routeid_initflow = tegra194_aonnoc_routeid_initflow, ··· 2142 2142 static struct tegra194_cbb_noc_data tegra194_bpmp_noc_data = { 2143 2143 .name = "bpmp-noc", 2144 2144 .erd_mask_inband_err = false, 2145 - .master_id = tegra194_master_id, 2145 + .initiator_id = tegra194_initiator_id, 2146 2146 .noc_aperture = tegra194_bpmpnoc_apert_lookup, 2147 2147 .max_aperture = ARRAY_SIZE(tegra194_bpmpnoc_apert_lookup), 2148 2148 .routeid_initflow = tegra194_bpmpnoc_routeid_initflow, ··· 2154 2154 static struct tegra194_cbb_noc_data tegra194_rce_noc_data = { 2155 2155 .name = "rce-noc", 2156 2156 .erd_mask_inband_err = false, 2157 - .master_id = tegra194_master_id, 2157 + .initiator_id = tegra194_initiator_id, 2158 2158 .noc_aperture = tegra194_scenoc_apert_lookup, 2159 2159 .max_aperture = ARRAY_SIZE(tegra194_scenoc_apert_lookup), 2160 2160 .routeid_initflow = tegra194_scenoc_routeid_initflow, ··· 2166 2166 static struct tegra194_cbb_noc_data tegra194_sce_noc_data = { 2167 2167 .name = "sce-noc", 2168 2168 .erd_mask_inband_err = false, 2169 - .master_id = tegra194_master_id, 2169 + .initiator_id = tegra194_initiator_id, 2170 2170 .noc_aperture = tegra194_scenoc_apert_lookup, 2171 2171 .max_aperture = ARRAY_SIZE(tegra194_scenoc_apert_lookup), 2172 2172 .routeid_initflow = tegra194_scenoc_routeid_initflow,
+103 -102
drivers/soc/tegra/cbb/tegra234-cbb.c
··· 1 1 // SPDX-License-Identifier: GPL-2.0 2 2 /* 3 - * Copyright (c) 2021-2022, NVIDIA CORPORATION. All rights reserved 3 + * Copyright (c) 2021-2025, NVIDIA CORPORATION. All rights reserved 4 4 * 5 5 * The driver handles Error's from Control Backbone(CBB) version 2.0. 6 6 * generated due to illegal accesses. The driver prints debug information 7 7 * about failed transaction on receiving interrupt from Error Notifier. 8 8 * Error types supported by CBB2.0 are: 9 9 * UNSUPPORTED_ERR, PWRDOWN_ERR, TIMEOUT_ERR, FIREWALL_ERR, DECODE_ERR, 10 - * SLAVE_ERR 10 + * TARGET_ERR 11 11 */ 12 12 13 13 #include <linux/acpi.h> ··· 30 30 #define FABRIC_EN_CFG_ADDR_LOW_0 0x80 31 31 #define FABRIC_EN_CFG_ADDR_HI_0 0x84 32 32 33 - #define FABRIC_MN_MASTER_ERR_EN_0 0x200 34 - #define FABRIC_MN_MASTER_ERR_FORCE_0 0x204 35 - #define FABRIC_MN_MASTER_ERR_STATUS_0 0x208 36 - #define FABRIC_MN_MASTER_ERR_OVERFLOW_STATUS_0 0x20c 33 + #define FABRIC_MN_INITIATOR_ERR_EN_0 0x200 34 + #define FABRIC_MN_INITIATOR_ERR_FORCE_0 0x204 35 + #define FABRIC_MN_INITIATOR_ERR_STATUS_0 0x208 36 + #define FABRIC_MN_INITIATOR_ERR_OVERFLOW_STATUS_0 0x20c 37 37 38 - #define FABRIC_MN_MASTER_LOG_ERR_STATUS_0 0x300 39 - #define FABRIC_MN_MASTER_LOG_ADDR_LOW_0 0x304 40 - #define FABRIC_MN_MASTER_LOG_ADDR_HIGH_0 0x308 41 - #define FABRIC_MN_MASTER_LOG_ATTRIBUTES0_0 0x30c 42 - #define FABRIC_MN_MASTER_LOG_ATTRIBUTES1_0 0x310 43 - #define FABRIC_MN_MASTER_LOG_ATTRIBUTES2_0 0x314 44 - #define FABRIC_MN_MASTER_LOG_USER_BITS0_0 0x318 38 + #define FABRIC_MN_INITIATOR_LOG_ERR_STATUS_0 0x300 39 + #define FABRIC_MN_INITIATOR_LOG_ADDR_LOW_0 0x304 40 + #define FABRIC_MN_INITIATOR_LOG_ADDR_HIGH_0 0x308 41 + #define FABRIC_MN_INITIATOR_LOG_ATTRIBUTES0_0 0x30c 42 + #define FABRIC_MN_INITIATOR_LOG_ATTRIBUTES1_0 0x310 43 + #define FABRIC_MN_INITIATOR_LOG_ATTRIBUTES2_0 0x314 44 + #define FABRIC_MN_INITIATOR_LOG_USER_BITS0_0 0x318 45 45 46 46 #define AXI_SLV_TIMEOUT_STATUS_0_0 0x8 47 47 #define APB_BLOCK_TMO_STATUS_0 0xc00 ··· 53 53 #define FAB_EM_EL_FALCONSEC GENMASK(1, 0) 54 54 55 55 #define FAB_EM_EL_FABID GENMASK(20, 16) 56 - #define FAB_EM_EL_SLAVEID GENMASK(7, 0) 56 + #define FAB_EM_EL_TARGETID GENMASK(7, 0) 57 57 58 58 #define FAB_EM_EL_ACCESSID GENMASK(7, 0) 59 59 ··· 85 85 MAX_FAB_ID, 86 86 }; 87 87 88 - struct tegra234_slave_lookup { 88 + struct tegra234_target_lookup { 89 89 const char *name; 90 90 unsigned int offset; 91 91 }; ··· 96 96 phys_addr_t firewall_base; 97 97 unsigned int firewall_ctl; 98 98 unsigned int firewall_wr_ctl; 99 - const char * const *master_id; 99 + const char * const *initiator_id; 100 100 unsigned int notifier_offset; 101 101 const struct tegra_cbb_error *errors; 102 102 const int max_errors; 103 - const struct tegra234_slave_lookup *slave_map; 104 - const int max_slaves; 103 + const struct tegra234_target_lookup *target_map; 104 + const int max_targets; 105 105 }; 106 106 107 107 struct tegra234_cbb { ··· 185 185 { 186 186 struct tegra234_cbb *priv = to_tegra234_cbb(cbb); 187 187 188 - writel(0, priv->mon + FABRIC_MN_MASTER_ERR_FORCE_0); 188 + writel(0, priv->mon + FABRIC_MN_INITIATOR_ERR_FORCE_0); 189 189 190 - writel(0x3f, priv->mon + FABRIC_MN_MASTER_ERR_STATUS_0); 190 + writel(0x3f, priv->mon + FABRIC_MN_INITIATOR_ERR_STATUS_0); 191 191 dsb(sy); 192 192 } 193 193 ··· 218 218 return timeout; 219 219 } 220 220 221 - static void tegra234_cbb_tmo_slv(struct seq_file *file, const char *slave, void __iomem *addr, 221 + static void tegra234_cbb_tmo_slv(struct seq_file *file, const char *target, void __iomem *addr, 222 222 u32 status) 223 223 { 224 - tegra_cbb_print_err(file, "\t %s : %#x\n", slave, status); 224 + tegra_cbb_print_err(file, "\t %s : %#x\n", target, status); 225 225 } 226 226 227 - static void tegra234_cbb_lookup_apbslv(struct seq_file *file, const char *slave, 227 + static void tegra234_cbb_lookup_apbslv(struct seq_file *file, const char *target, 228 228 void __iomem *base) 229 229 { 230 230 unsigned int block = 0; ··· 234 234 235 235 status = tegra234_cbb_get_tmo_slv(base); 236 236 if (status) 237 - tegra_cbb_print_err(file, "\t %s_BLOCK_TMO_STATUS : %#x\n", slave, status); 237 + tegra_cbb_print_err(file, "\t %s_BLOCK_TMO_STATUS : %#x\n", target, status); 238 238 239 239 while (status) { 240 240 if (status & BIT(0)) { ··· 249 249 if (clients != 0xffffffff) 250 250 clients &= BIT(client); 251 251 252 - sprintf(name, "%s_BLOCK%d_TMO", slave, block); 252 + sprintf(name, "%s_BLOCK%d_TMO", target, block); 253 253 254 254 tegra234_cbb_tmo_slv(file, name, addr, clients); 255 255 } ··· 264 264 } 265 265 } 266 266 267 - static void tegra234_lookup_slave_timeout(struct seq_file *file, struct tegra234_cbb *cbb, 268 - u8 slave_id, u8 fab_id) 267 + static void tegra234_lookup_target_timeout(struct seq_file *file, struct tegra234_cbb *cbb, 268 + u8 target_id, u8 fab_id) 269 269 { 270 - const struct tegra234_slave_lookup *map = cbb->fabric->slave_map; 270 + const struct tegra234_target_lookup *map = cbb->fabric->target_map; 271 271 void __iomem *addr; 272 272 273 273 /* 274 - * 1) Get slave node name and address mapping using slave_id. 275 - * 2) Check if the timed out slave node is APB or AXI. 276 - * 3) If AXI, then print timeout register and reset axi slave 274 + * 1) Get target node name and address mapping using target_id. 275 + * 2) Check if the timed out target node is APB or AXI. 276 + * 3) If AXI, then print timeout register and reset axi target 277 277 * using <FABRIC>_SN_<>_SLV_TIMEOUT_STATUS_0_0 register. 278 278 * 4) If APB, then perform an additional lookup to find the client 279 279 * which timed out. ··· 287 287 * e) Goto step-a till all bits are set. 288 288 */ 289 289 290 - addr = cbb->regs + map[slave_id].offset; 290 + addr = cbb->regs + map[target_id].offset; 291 291 292 - if (strstr(map[slave_id].name, "AXI2APB")) { 292 + if (strstr(map[target_id].name, "AXI2APB")) { 293 293 addr += APB_BLOCK_TMO_STATUS_0; 294 294 295 - tegra234_cbb_lookup_apbslv(file, map[slave_id].name, addr); 295 + tegra234_cbb_lookup_apbslv(file, map[target_id].name, addr); 296 296 } else { 297 297 char name[64]; 298 298 u32 status; ··· 301 301 302 302 status = tegra234_cbb_get_tmo_slv(addr); 303 303 if (status) { 304 - sprintf(name, "%s_SLV_TIMEOUT_STATUS", map[slave_id].name); 304 + sprintf(name, "%s_SLV_TIMEOUT_STATUS", map[target_id].name); 305 305 tegra234_cbb_tmo_slv(file, name, addr, status); 306 306 } 307 307 } ··· 351 351 static void print_errlog_err(struct seq_file *file, struct tegra234_cbb *cbb) 352 352 { 353 353 u8 cache_type, prot_type, burst_length, mstr_id, grpsec, vqc, falconsec, beat_size; 354 - u8 access_type, access_id, requester_socket_id, local_socket_id, slave_id, fab_id; 354 + u8 access_type, access_id, requester_socket_id, local_socket_id, target_id, fab_id; 355 355 char fabric_name[20]; 356 356 bool is_numa = false; 357 357 u8 burst_type; ··· 366 366 367 367 /* 368 368 * For SOC with multiple NUMA nodes, print cross socket access 369 - * errors only if initiator/master_id is CCPLEX, CPMU or GPU. 369 + * errors only if initiator_id is CCPLEX, CPMU or GPU. 370 370 */ 371 371 if (is_numa) { 372 372 local_socket_id = numa_node_id(); ··· 379 379 } 380 380 381 381 fab_id = FIELD_GET(FAB_EM_EL_FABID, cbb->mn_attr2); 382 - slave_id = FIELD_GET(FAB_EM_EL_SLAVEID, cbb->mn_attr2); 382 + target_id = FIELD_GET(FAB_EM_EL_TARGETID, cbb->mn_attr2); 383 383 384 384 access_id = FIELD_GET(FAB_EM_EL_ACCESSID, cbb->mn_attr1); 385 385 ··· 397 397 else 398 398 tegra_cbb_print_err(file, "\t Wrong type index:%u\n", cbb->type); 399 399 400 - tegra_cbb_print_err(file, "\t MASTER_ID\t\t: %s\n", cbb->fabric->master_id[mstr_id]); 400 + tegra_cbb_print_err(file, "\t Initiator_Id\t\t: %s\n", cbb->fabric->initiator_id[mstr_id]); 401 401 tegra_cbb_print_err(file, "\t Address\t\t: %#llx\n", cbb->access); 402 402 403 403 tegra_cbb_print_cache(file, cache_type); ··· 423 423 } 424 424 425 425 tegra_cbb_print_err(file, "\t Fabric\t\t: %s\n", fabric_name); 426 - tegra_cbb_print_err(file, "\t Slave_Id\t\t: %#x\n", slave_id); 426 + tegra_cbb_print_err(file, "\t Target_Id\t\t: %#x\n", target_id); 427 427 tegra_cbb_print_err(file, "\t Burst_length\t\t: %#x\n", burst_length); 428 428 tegra_cbb_print_err(file, "\t Burst_type\t\t: %#x\n", burst_type); 429 429 tegra_cbb_print_err(file, "\t Beat_size\t\t: %#x\n", beat_size); ··· 434 434 if ((fab_id == PSC_FAB_ID) || (fab_id == FSI_FAB_ID)) 435 435 return; 436 436 437 - if (slave_id >= cbb->fabric->max_slaves) { 438 - tegra_cbb_print_err(file, "\t Invalid slave_id:%d\n", slave_id); 437 + if (target_id >= cbb->fabric->max_targets) { 438 + tegra_cbb_print_err(file, "\t Invalid target_id:%d\n", target_id); 439 439 return; 440 440 } 441 441 442 442 if (!strcmp(cbb->fabric->errors[cbb->type].code, "TIMEOUT_ERR")) { 443 - tegra234_lookup_slave_timeout(file, cbb, slave_id, fab_id); 443 + tegra234_lookup_target_timeout(file, cbb, target_id, fab_id); 444 444 return; 445 445 } 446 446 447 - tegra_cbb_print_err(file, "\t Slave\t\t\t: %s\n", cbb->fabric->slave_map[slave_id].name); 447 + tegra_cbb_print_err(file, "\t Target\t\t\t: %s\n", 448 + cbb->fabric->target_map[target_id].name); 448 449 } 449 450 450 451 static int print_errmonX_info(struct seq_file *file, struct tegra234_cbb *cbb) 451 452 { 452 453 u32 overflow, status, error; 453 454 454 - status = readl(cbb->mon + FABRIC_MN_MASTER_ERR_STATUS_0); 455 + status = readl(cbb->mon + FABRIC_MN_INITIATOR_ERR_STATUS_0); 455 456 if (!status) { 456 457 pr_err("Error Notifier received a spurious notification\n"); 457 458 return -ENODATA; ··· 463 462 return -EINVAL; 464 463 } 465 464 466 - overflow = readl(cbb->mon + FABRIC_MN_MASTER_ERR_OVERFLOW_STATUS_0); 465 + overflow = readl(cbb->mon + FABRIC_MN_INITIATOR_ERR_OVERFLOW_STATUS_0); 467 466 468 467 tegra234_cbb_print_error(file, cbb, status, overflow); 469 468 470 - error = readl(cbb->mon + FABRIC_MN_MASTER_LOG_ERR_STATUS_0); 469 + error = readl(cbb->mon + FABRIC_MN_INITIATOR_LOG_ERR_STATUS_0); 471 470 if (!error) { 472 471 pr_info("Error Monitor doesn't have Error Logger\n"); 473 472 return -EINVAL; ··· 479 478 if (error & BIT(0)) { 480 479 u32 hi, lo; 481 480 482 - hi = readl(cbb->mon + FABRIC_MN_MASTER_LOG_ADDR_HIGH_0); 483 - lo = readl(cbb->mon + FABRIC_MN_MASTER_LOG_ADDR_LOW_0); 481 + hi = readl(cbb->mon + FABRIC_MN_INITIATOR_LOG_ADDR_HIGH_0); 482 + lo = readl(cbb->mon + FABRIC_MN_INITIATOR_LOG_ADDR_LOW_0); 484 483 485 484 cbb->access = (u64)hi << 32 | lo; 486 485 487 - cbb->mn_attr0 = readl(cbb->mon + FABRIC_MN_MASTER_LOG_ATTRIBUTES0_0); 488 - cbb->mn_attr1 = readl(cbb->mon + FABRIC_MN_MASTER_LOG_ATTRIBUTES1_0); 489 - cbb->mn_attr2 = readl(cbb->mon + FABRIC_MN_MASTER_LOG_ATTRIBUTES2_0); 490 - cbb->mn_user_bits = readl(cbb->mon + FABRIC_MN_MASTER_LOG_USER_BITS0_0); 486 + cbb->mn_attr0 = readl(cbb->mon + FABRIC_MN_INITIATOR_LOG_ATTRIBUTES0_0); 487 + cbb->mn_attr1 = readl(cbb->mon + FABRIC_MN_INITIATOR_LOG_ATTRIBUTES1_0); 488 + cbb->mn_attr2 = readl(cbb->mon + FABRIC_MN_INITIATOR_LOG_ATTRIBUTES2_0); 489 + cbb->mn_user_bits = readl(cbb->mon + FABRIC_MN_INITIATOR_LOG_USER_BITS0_0); 491 490 492 491 print_errlog_err(file, cbb); 493 492 } ··· 592 591 goto unlock; 593 592 594 593 /* 595 - * If illegal request is from CCPLEX(id:0x1) master then call WARN() 594 + * If illegal request is from CCPLEX(id:0x1) initiator then call WARN() 596 595 */ 597 596 if (priv->fabric->off_mask_erd) { 598 597 mstr_id = FIELD_GET(USRBITS_MSTR_ID, priv->mn_user_bits); ··· 644 643 #endif 645 644 }; 646 645 647 - static const char * const tegra234_master_id[] = { 646 + static const char * const tegra234_initiator_id[] = { 648 647 [0x00] = "TZ", 649 648 [0x01] = "CCPLEX", 650 649 [0x02] = "CCPMU", ··· 675 674 676 675 static const struct tegra_cbb_error tegra234_cbb_errors[] = { 677 676 { 678 - .code = "SLAVE_ERR", 679 - .desc = "Slave being accessed responded with an error" 677 + .code = "TARGET_ERR", 678 + .desc = "Target being accessed responded with an error" 680 679 }, { 681 680 .code = "DECODE_ERR", 682 681 .desc = "Attempt to access an address hole" ··· 685 684 .desc = "Attempt to access a region which is firewall protected" 686 685 }, { 687 686 .code = "TIMEOUT_ERR", 688 - .desc = "No response returned by slave" 687 + .desc = "No response returned by target" 689 688 }, { 690 689 .code = "PWRDOWN_ERR", 691 690 .desc = "Attempt to access a portion of fabric that is powered down" 692 691 }, { 693 692 .code = "UNSUPPORTED_ERR", 694 - .desc = "Attempt to access a slave through an unsupported access" 693 + .desc = "Attempt to access a target through an unsupported access" 695 694 } 696 695 }; 697 696 698 - static const struct tegra234_slave_lookup tegra234_aon_slave_map[] = { 697 + static const struct tegra234_target_lookup tegra234_aon_target_map[] = { 699 698 { "AXI2APB", 0x00000 }, 700 699 { "AST", 0x14000 }, 701 700 { "CBB", 0x15000 }, ··· 704 703 705 704 static const struct tegra234_cbb_fabric tegra234_aon_fabric = { 706 705 .name = "aon-fabric", 707 - .master_id = tegra234_master_id, 708 - .slave_map = tegra234_aon_slave_map, 709 - .max_slaves = ARRAY_SIZE(tegra234_aon_slave_map), 706 + .initiator_id = tegra234_initiator_id, 707 + .target_map = tegra234_aon_target_map, 708 + .max_targets = ARRAY_SIZE(tegra234_aon_target_map), 710 709 .errors = tegra234_cbb_errors, 711 710 .max_errors = ARRAY_SIZE(tegra234_cbb_errors), 712 711 .notifier_offset = 0x17000, ··· 715 714 .firewall_wr_ctl = 0x8c8, 716 715 }; 717 716 718 - static const struct tegra234_slave_lookup tegra234_bpmp_slave_map[] = { 717 + static const struct tegra234_target_lookup tegra234_bpmp_target_map[] = { 719 718 { "AXI2APB", 0x00000 }, 720 719 { "AST0", 0x15000 }, 721 720 { "AST1", 0x16000 }, ··· 725 724 726 725 static const struct tegra234_cbb_fabric tegra234_bpmp_fabric = { 727 726 .name = "bpmp-fabric", 728 - .master_id = tegra234_master_id, 729 - .slave_map = tegra234_bpmp_slave_map, 730 - .max_slaves = ARRAY_SIZE(tegra234_bpmp_slave_map), 727 + .initiator_id = tegra234_initiator_id, 728 + .target_map = tegra234_bpmp_target_map, 729 + .max_targets = ARRAY_SIZE(tegra234_bpmp_target_map), 731 730 .errors = tegra234_cbb_errors, 732 731 .max_errors = ARRAY_SIZE(tegra234_cbb_errors), 733 732 .notifier_offset = 0x19000, ··· 736 735 .firewall_wr_ctl = 0x8e8, 737 736 }; 738 737 739 - static const struct tegra234_slave_lookup tegra234_cbb_slave_map[] = { 738 + static const struct tegra234_target_lookup tegra234_cbb_target_map[] = { 740 739 { "AON", 0x40000 }, 741 740 { "BPMP", 0x41000 }, 742 741 { "CBB", 0x42000 }, ··· 802 801 803 802 static const struct tegra234_cbb_fabric tegra234_cbb_fabric = { 804 803 .name = "cbb-fabric", 805 - .master_id = tegra234_master_id, 806 - .slave_map = tegra234_cbb_slave_map, 807 - .max_slaves = ARRAY_SIZE(tegra234_cbb_slave_map), 804 + .initiator_id = tegra234_initiator_id, 805 + .target_map = tegra234_cbb_target_map, 806 + .max_targets = ARRAY_SIZE(tegra234_cbb_target_map), 808 807 .errors = tegra234_cbb_errors, 809 808 .max_errors = ARRAY_SIZE(tegra234_cbb_errors), 810 809 .notifier_offset = 0x60000, ··· 814 813 .firewall_wr_ctl = 0x23e8, 815 814 }; 816 815 817 - static const struct tegra234_slave_lookup tegra234_common_slave_map[] = { 816 + static const struct tegra234_target_lookup tegra234_common_target_map[] = { 818 817 { "AXI2APB", 0x00000 }, 819 818 { "AST0", 0x15000 }, 820 819 { "AST1", 0x16000 }, ··· 825 824 826 825 static const struct tegra234_cbb_fabric tegra234_dce_fabric = { 827 826 .name = "dce-fabric", 828 - .master_id = tegra234_master_id, 829 - .slave_map = tegra234_common_slave_map, 830 - .max_slaves = ARRAY_SIZE(tegra234_common_slave_map), 827 + .initiator_id = tegra234_initiator_id, 828 + .target_map = tegra234_common_target_map, 829 + .max_targets = ARRAY_SIZE(tegra234_common_target_map), 831 830 .errors = tegra234_cbb_errors, 832 831 .max_errors = ARRAY_SIZE(tegra234_cbb_errors), 833 832 .notifier_offset = 0x19000, ··· 838 837 839 838 static const struct tegra234_cbb_fabric tegra234_rce_fabric = { 840 839 .name = "rce-fabric", 841 - .master_id = tegra234_master_id, 842 - .slave_map = tegra234_common_slave_map, 843 - .max_slaves = ARRAY_SIZE(tegra234_common_slave_map), 840 + .initiator_id = tegra234_initiator_id, 841 + .target_map = tegra234_common_target_map, 842 + .max_targets = ARRAY_SIZE(tegra234_common_target_map), 844 843 .errors = tegra234_cbb_errors, 845 844 .max_errors = ARRAY_SIZE(tegra234_cbb_errors), 846 845 .notifier_offset = 0x19000, ··· 851 850 852 851 static const struct tegra234_cbb_fabric tegra234_sce_fabric = { 853 852 .name = "sce-fabric", 854 - .master_id = tegra234_master_id, 855 - .slave_map = tegra234_common_slave_map, 856 - .max_slaves = ARRAY_SIZE(tegra234_common_slave_map), 853 + .initiator_id = tegra234_initiator_id, 854 + .target_map = tegra234_common_target_map, 855 + .max_targets = ARRAY_SIZE(tegra234_common_target_map), 857 856 .errors = tegra234_cbb_errors, 858 857 .max_errors = ARRAY_SIZE(tegra234_cbb_errors), 859 858 .notifier_offset = 0x19000, ··· 862 861 .firewall_wr_ctl = 0x288, 863 862 }; 864 863 865 - static const char * const tegra241_master_id[] = { 864 + static const char * const tegra241_initiator_id[] = { 866 865 [0x0] = "TZ", 867 866 [0x1] = "CCPLEX", 868 867 [0x2] = "CCPMU", ··· 880 879 }; 881 880 882 881 /* 883 - * Possible causes for Slave and Timeout errors. 884 - * SLAVE_ERR: 885 - * Slave being accessed responded with an error. Slave could return 882 + * Possible causes for Target and Timeout errors. 883 + * TARGET_ERR: 884 + * Target being accessed responded with an error. Target could return 886 885 * an error for various cases : 887 886 * Unsupported access, clamp setting when power gated, register 888 - * level firewall(SCR), address hole within the slave, etc 887 + * level firewall(SCR), address hole within the target, etc 889 888 * 890 889 * TIMEOUT_ERR: 891 - * No response returned by slave. Can be due to slave being clock 892 - * gated, under reset, powered down or slave inability to respond 893 - * for an internal slave issue 890 + * No response returned by target. Can be due to target being clock 891 + * gated, under reset, powered down or target inability to respond 892 + * for an internal target issue 894 893 */ 895 894 static const struct tegra_cbb_error tegra241_cbb_errors[] = { 896 895 { 897 - .code = "SLAVE_ERR", 898 - .desc = "Slave being accessed responded with an error." 896 + .code = "TARGET_ERR", 897 + .desc = "Target being accessed responded with an error." 899 898 }, { 900 899 .code = "DECODE_ERR", 901 900 .desc = "Attempt to access an address hole or Reserved region of memory." ··· 904 903 .desc = "Attempt to access a region which is firewalled." 905 904 }, { 906 905 .code = "TIMEOUT_ERR", 907 - .desc = "No response returned by slave." 906 + .desc = "No response returned by target." 908 907 }, { 909 908 .code = "PWRDOWN_ERR", 910 909 .desc = "Attempt to access a portion of the fabric that is powered down." 911 910 }, { 912 911 .code = "UNSUPPORTED_ERR", 913 - .desc = "Attempt to access a slave through an unsupported access." 912 + .desc = "Attempt to access a target through an unsupported access." 914 913 }, { 915 914 .code = "POISON_ERR", 916 - .desc = "Slave responds with poison error to indicate error in data." 915 + .desc = "Target responds with poison error to indicate error in data." 917 916 }, { 918 917 .code = "RSVD" 919 918 }, { ··· 971 970 }, 972 971 }; 973 972 974 - static const struct tegra234_slave_lookup tegra241_cbb_slave_map[] = { 973 + static const struct tegra234_target_lookup tegra241_cbb_target_map[] = { 975 974 { "RSVD", 0x00000 }, 976 975 { "PCIE_C8", 0x51000 }, 977 976 { "PCIE_C9", 0x52000 }, ··· 1035 1034 1036 1035 static const struct tegra234_cbb_fabric tegra241_cbb_fabric = { 1037 1036 .name = "cbb-fabric", 1038 - .master_id = tegra241_master_id, 1039 - .slave_map = tegra241_cbb_slave_map, 1040 - .max_slaves = ARRAY_SIZE(tegra241_cbb_slave_map), 1037 + .initiator_id = tegra241_initiator_id, 1038 + .target_map = tegra241_cbb_target_map, 1039 + .max_targets = ARRAY_SIZE(tegra241_cbb_target_map), 1041 1040 .errors = tegra241_cbb_errors, 1042 1041 .max_errors = ARRAY_SIZE(tegra241_cbb_errors), 1043 1042 .notifier_offset = 0x60000, ··· 1047 1046 .firewall_wr_ctl = 0x2368, 1048 1047 }; 1049 1048 1050 - static const struct tegra234_slave_lookup tegra241_bpmp_slave_map[] = { 1049 + static const struct tegra234_target_lookup tegra241_bpmp_target_map[] = { 1051 1050 { "RSVD", 0x00000 }, 1052 1051 { "RSVD", 0x00000 }, 1053 1052 { "RSVD", 0x00000 }, ··· 1060 1059 1061 1060 static const struct tegra234_cbb_fabric tegra241_bpmp_fabric = { 1062 1061 .name = "bpmp-fabric", 1063 - .master_id = tegra241_master_id, 1064 - .slave_map = tegra241_bpmp_slave_map, 1065 - .max_slaves = ARRAY_SIZE(tegra241_bpmp_slave_map), 1062 + .initiator_id = tegra241_initiator_id, 1063 + .target_map = tegra241_bpmp_target_map, 1064 + .max_targets = ARRAY_SIZE(tegra241_bpmp_target_map), 1066 1065 .errors = tegra241_cbb_errors, 1067 1066 .max_errors = ARRAY_SIZE(tegra241_cbb_errors), 1068 1067 .notifier_offset = 0x19000,