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

bus: fsl-mc: change mc_command in fsl_mc_command

The "struct mc_command" is a very generic name for a global
kernel structure. Change its name in "struct fsl_mc_command".

Signed-off-by: Ioana Ciornei <ioana.ciornei@nxp.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

authored by

Ioana Ciornei and committed by
Greg Kroah-Hartman 5b04cede 12a01487

+126 -126
+6 -6
drivers/bus/fsl-mc/dpbp.c
··· 31 31 int dpbp_id, 32 32 u16 *token) 33 33 { 34 - struct mc_command cmd = { 0 }; 34 + struct fsl_mc_command cmd = { 0 }; 35 35 struct dpbp_cmd_open *cmd_params; 36 36 int err; 37 37 ··· 68 68 u32 cmd_flags, 69 69 u16 token) 70 70 { 71 - struct mc_command cmd = { 0 }; 71 + struct fsl_mc_command cmd = { 0 }; 72 72 73 73 /* prepare command */ 74 74 cmd.header = mc_encode_cmd_header(DPBP_CMDID_CLOSE, cmd_flags, ··· 91 91 u32 cmd_flags, 92 92 u16 token) 93 93 { 94 - struct mc_command cmd = { 0 }; 94 + struct fsl_mc_command cmd = { 0 }; 95 95 96 96 /* prepare command */ 97 97 cmd.header = mc_encode_cmd_header(DPBP_CMDID_ENABLE, cmd_flags, ··· 114 114 u32 cmd_flags, 115 115 u16 token) 116 116 { 117 - struct mc_command cmd = { 0 }; 117 + struct fsl_mc_command cmd = { 0 }; 118 118 119 119 /* prepare command */ 120 120 cmd.header = mc_encode_cmd_header(DPBP_CMDID_DISABLE, ··· 137 137 u32 cmd_flags, 138 138 u16 token) 139 139 { 140 - struct mc_command cmd = { 0 }; 140 + struct fsl_mc_command cmd = { 0 }; 141 141 142 142 /* prepare command */ 143 143 cmd.header = mc_encode_cmd_header(DPBP_CMDID_RESET, ··· 163 163 u16 token, 164 164 struct dpbp_attr *attr) 165 165 { 166 - struct mc_command cmd = { 0 }; 166 + struct fsl_mc_command cmd = { 0 }; 167 167 struct dpbp_rsp_get_attributes *rsp_params; 168 168 int err; 169 169
+7 -7
drivers/bus/fsl-mc/dpcon.c
··· 31 31 int dpcon_id, 32 32 u16 *token) 33 33 { 34 - struct mc_command cmd = { 0 }; 34 + struct fsl_mc_command cmd = { 0 }; 35 35 struct dpcon_cmd_open *dpcon_cmd; 36 36 int err; 37 37 ··· 69 69 u32 cmd_flags, 70 70 u16 token) 71 71 { 72 - struct mc_command cmd = { 0 }; 72 + struct fsl_mc_command cmd = { 0 }; 73 73 74 74 /* prepare command */ 75 75 cmd.header = mc_encode_cmd_header(DPCON_CMDID_CLOSE, ··· 93 93 u32 cmd_flags, 94 94 u16 token) 95 95 { 96 - struct mc_command cmd = { 0 }; 96 + struct fsl_mc_command cmd = { 0 }; 97 97 98 98 /* prepare command */ 99 99 cmd.header = mc_encode_cmd_header(DPCON_CMDID_ENABLE, ··· 117 117 u32 cmd_flags, 118 118 u16 token) 119 119 { 120 - struct mc_command cmd = { 0 }; 120 + struct fsl_mc_command cmd = { 0 }; 121 121 122 122 /* prepare command */ 123 123 cmd.header = mc_encode_cmd_header(DPCON_CMDID_DISABLE, ··· 141 141 u32 cmd_flags, 142 142 u16 token) 143 143 { 144 - struct mc_command cmd = { 0 }; 144 + struct fsl_mc_command cmd = { 0 }; 145 145 146 146 /* prepare command */ 147 147 cmd.header = mc_encode_cmd_header(DPCON_CMDID_RESET, ··· 166 166 u16 token, 167 167 struct dpcon_attr *attr) 168 168 { 169 - struct mc_command cmd = { 0 }; 169 + struct fsl_mc_command cmd = { 0 }; 170 170 struct dpcon_rsp_get_attr *dpcon_rsp; 171 171 int err; 172 172 ··· 204 204 u16 token, 205 205 struct dpcon_notification_cfg *cfg) 206 206 { 207 - struct mc_command cmd = { 0 }; 207 + struct fsl_mc_command cmd = { 0 }; 208 208 struct dpcon_cmd_set_notification *dpcon_cmd; 209 209 210 210 /* prepare command */
+3 -3
drivers/bus/fsl-mc/dpmcp.c
··· 30 30 int dpmcp_id, 31 31 u16 *token) 32 32 { 33 - struct mc_command cmd = { 0 }; 33 + struct fsl_mc_command cmd = { 0 }; 34 34 struct dpmcp_cmd_open *cmd_params; 35 35 int err; 36 36 ··· 66 66 u32 cmd_flags, 67 67 u16 token) 68 68 { 69 - struct mc_command cmd = { 0 }; 69 + struct fsl_mc_command cmd = { 0 }; 70 70 71 71 /* prepare command */ 72 72 cmd.header = mc_encode_cmd_header(DPMCP_CMDID_CLOSE, ··· 88 88 u32 cmd_flags, 89 89 u16 token) 90 90 { 91 - struct mc_command cmd = { 0 }; 91 + struct fsl_mc_command cmd = { 0 }; 92 92 93 93 /* prepare command */ 94 94 cmd.header = mc_encode_cmd_header(DPMCP_CMDID_RESET,
+14 -14
drivers/bus/fsl-mc/dprc.c
··· 24 24 int container_id, 25 25 u16 *token) 26 26 { 27 - struct mc_command cmd = { 0 }; 27 + struct fsl_mc_command cmd = { 0 }; 28 28 struct dprc_cmd_open *cmd_params; 29 29 int err; 30 30 ··· 61 61 u32 cmd_flags, 62 62 u16 token) 63 63 { 64 - struct mc_command cmd = { 0 }; 64 + struct fsl_mc_command cmd = { 0 }; 65 65 66 66 /* prepare command */ 67 67 cmd.header = mc_encode_cmd_header(DPRC_CMDID_CLOSE, cmd_flags, ··· 88 88 u8 irq_index, 89 89 struct dprc_irq_cfg *irq_cfg) 90 90 { 91 - struct mc_command cmd = { 0 }; 91 + struct fsl_mc_command cmd = { 0 }; 92 92 struct dprc_cmd_set_irq *cmd_params; 93 93 94 94 /* prepare command */ ··· 126 126 u8 irq_index, 127 127 u8 en) 128 128 { 129 - struct mc_command cmd = { 0 }; 129 + struct fsl_mc_command cmd = { 0 }; 130 130 struct dprc_cmd_set_irq_enable *cmd_params; 131 131 132 132 /* prepare command */ ··· 162 162 u8 irq_index, 163 163 u32 mask) 164 164 { 165 - struct mc_command cmd = { 0 }; 165 + struct fsl_mc_command cmd = { 0 }; 166 166 struct dprc_cmd_set_irq_mask *cmd_params; 167 167 168 168 /* prepare command */ ··· 194 194 u8 irq_index, 195 195 u32 *status) 196 196 { 197 - struct mc_command cmd = { 0 }; 197 + struct fsl_mc_command cmd = { 0 }; 198 198 struct dprc_cmd_get_irq_status *cmd_params; 199 199 struct dprc_rsp_get_irq_status *rsp_params; 200 200 int err; ··· 236 236 u8 irq_index, 237 237 u32 status) 238 238 { 239 - struct mc_command cmd = { 0 }; 239 + struct fsl_mc_command cmd = { 0 }; 240 240 struct dprc_cmd_clear_irq_status *cmd_params; 241 241 242 242 /* prepare command */ ··· 264 264 u16 token, 265 265 struct dprc_attributes *attr) 266 266 { 267 - struct mc_command cmd = { 0 }; 267 + struct fsl_mc_command cmd = { 0 }; 268 268 struct dprc_rsp_get_attributes *rsp_params; 269 269 int err; 270 270 ··· 302 302 u16 token, 303 303 int *obj_count) 304 304 { 305 - struct mc_command cmd = { 0 }; 305 + struct fsl_mc_command cmd = { 0 }; 306 306 struct dprc_rsp_get_obj_count *rsp_params; 307 307 int err; 308 308 ··· 344 344 int obj_index, 345 345 struct fsl_mc_obj_desc *obj_desc) 346 346 { 347 - struct mc_command cmd = { 0 }; 347 + struct fsl_mc_command cmd = { 0 }; 348 348 struct dprc_cmd_get_obj *cmd_params; 349 349 struct dprc_rsp_get_obj *rsp_params; 350 350 int err; ··· 399 399 u8 irq_index, 400 400 struct dprc_irq_cfg *irq_cfg) 401 401 { 402 - struct mc_command cmd = { 0 }; 402 + struct fsl_mc_command cmd = { 0 }; 403 403 struct dprc_cmd_set_obj_irq *cmd_params; 404 404 405 405 /* prepare command */ ··· 440 440 u8 region_index, 441 441 struct dprc_region_desc *region_desc) 442 442 { 443 - struct mc_command cmd = { 0 }; 443 + struct fsl_mc_command cmd = { 0 }; 444 444 struct dprc_cmd_get_obj_region *cmd_params; 445 445 struct dprc_rsp_get_obj_region *rsp_params; 446 446 int err; ··· 482 482 u16 *major_ver, 483 483 u16 *minor_ver) 484 484 { 485 - struct mc_command cmd = { 0 }; 485 + struct fsl_mc_command cmd = { 0 }; 486 486 int err; 487 487 488 488 /* prepare command */ ··· 512 512 u32 cmd_flags, 513 513 int *container_id) 514 514 { 515 - struct mc_command cmd = { 0 }; 515 + struct fsl_mc_command cmd = { 0 }; 516 516 int err; 517 517 518 518 /* prepare command */
+1 -1
drivers/bus/fsl-mc/fsl-mc-bus.c
··· 314 314 u32 cmd_flags, 315 315 struct mc_version *mc_ver_info) 316 316 { 317 - struct mc_command cmd = { 0 }; 317 + struct fsl_mc_command cmd = { 0 }; 318 318 struct dpmng_rsp_get_version *rsp_params; 319 319 int err; 320 320
+10 -10
drivers/bus/fsl-mc/mc-sys.c
··· 28 28 #define MC_CMD_COMPLETION_POLLING_MIN_SLEEP_USECS 10 29 29 #define MC_CMD_COMPLETION_POLLING_MAX_SLEEP_USECS 500 30 30 31 - static enum mc_cmd_status mc_cmd_hdr_read_status(struct mc_command *cmd) 31 + static enum mc_cmd_status mc_cmd_hdr_read_status(struct fsl_mc_command *cmd) 32 32 { 33 33 struct mc_cmd_header *hdr = (struct mc_cmd_header *)&cmd->header; 34 34 35 35 return (enum mc_cmd_status)hdr->status; 36 36 } 37 37 38 - static u16 mc_cmd_hdr_read_cmdid(struct mc_command *cmd) 38 + static u16 mc_cmd_hdr_read_cmdid(struct fsl_mc_command *cmd) 39 39 { 40 40 struct mc_cmd_header *hdr = (struct mc_cmd_header *)&cmd->header; 41 41 u16 cmd_id = le16_to_cpu(hdr->cmd_id); ··· 94 94 * @portal: pointer to an MC portal 95 95 * @cmd: pointer to a filled command 96 96 */ 97 - static inline void mc_write_command(struct mc_command __iomem *portal, 98 - struct mc_command *cmd) 97 + static inline void mc_write_command(struct fsl_mc_command __iomem *portal, 98 + struct fsl_mc_command *cmd) 99 99 { 100 100 int i; 101 101 ··· 121 121 * 122 122 * Returns MC_CMD_STATUS_OK on Success; Error code otherwise. 123 123 */ 124 - static inline enum mc_cmd_status mc_read_response(struct mc_command __iomem * 125 - portal, 126 - struct mc_command *resp) 124 + static inline enum mc_cmd_status mc_read_response(struct fsl_mc_command __iomem 125 + *portal, 126 + struct fsl_mc_command *resp) 127 127 { 128 128 int i; 129 129 enum mc_cmd_status status; ··· 156 156 * @mc_status: MC command completion status 157 157 */ 158 158 static int mc_polling_wait_preemptible(struct fsl_mc_io *mc_io, 159 - struct mc_command *cmd, 159 + struct fsl_mc_command *cmd, 160 160 enum mc_cmd_status *mc_status) 161 161 { 162 162 enum mc_cmd_status status; ··· 202 202 * @mc_status: MC command completion status 203 203 */ 204 204 static int mc_polling_wait_atomic(struct fsl_mc_io *mc_io, 205 - struct mc_command *cmd, 205 + struct fsl_mc_command *cmd, 206 206 enum mc_cmd_status *mc_status) 207 207 { 208 208 enum mc_cmd_status status; ··· 241 241 * 242 242 * Returns '0' on Success; Error code otherwise. 243 243 */ 244 - int mc_send_command(struct fsl_mc_io *mc_io, struct mc_command *cmd) 244 + int mc_send_command(struct fsl_mc_io *mc_io, struct fsl_mc_command *cmd) 245 245 { 246 246 int error; 247 247 enum mc_cmd_status status;
+42 -42
drivers/staging/fsl-dpaa2/ethernet/dpni.c
··· 122 122 int dpni_id, 123 123 u16 *token) 124 124 { 125 - struct mc_command cmd = { 0 }; 125 + struct fsl_mc_command cmd = { 0 }; 126 126 struct dpni_cmd_open *cmd_params; 127 127 128 128 int err; ··· 160 160 u32 cmd_flags, 161 161 u16 token) 162 162 { 163 - struct mc_command cmd = { 0 }; 163 + struct fsl_mc_command cmd = { 0 }; 164 164 165 165 /* prepare command */ 166 166 cmd.header = mc_encode_cmd_header(DPNI_CMDID_CLOSE, ··· 188 188 u16 token, 189 189 const struct dpni_pools_cfg *cfg) 190 190 { 191 - struct mc_command cmd = { 0 }; 191 + struct fsl_mc_command cmd = { 0 }; 192 192 struct dpni_cmd_set_pools *cmd_params; 193 193 int i; 194 194 ··· 222 222 u32 cmd_flags, 223 223 u16 token) 224 224 { 225 - struct mc_command cmd = { 0 }; 225 + struct fsl_mc_command cmd = { 0 }; 226 226 227 227 /* prepare command */ 228 228 cmd.header = mc_encode_cmd_header(DPNI_CMDID_ENABLE, ··· 245 245 u32 cmd_flags, 246 246 u16 token) 247 247 { 248 - struct mc_command cmd = { 0 }; 248 + struct fsl_mc_command cmd = { 0 }; 249 249 250 250 /* prepare command */ 251 251 cmd.header = mc_encode_cmd_header(DPNI_CMDID_DISABLE, ··· 270 270 u16 token, 271 271 int *en) 272 272 { 273 - struct mc_command cmd = { 0 }; 273 + struct fsl_mc_command cmd = { 0 }; 274 274 struct dpni_rsp_is_enabled *rsp_params; 275 275 int err; 276 276 ··· 303 303 u32 cmd_flags, 304 304 u16 token) 305 305 { 306 - struct mc_command cmd = { 0 }; 306 + struct fsl_mc_command cmd = { 0 }; 307 307 308 308 /* prepare command */ 309 309 cmd.header = mc_encode_cmd_header(DPNI_CMDID_RESET, ··· 335 335 u8 irq_index, 336 336 u8 en) 337 337 { 338 - struct mc_command cmd = { 0 }; 338 + struct fsl_mc_command cmd = { 0 }; 339 339 struct dpni_cmd_set_irq_enable *cmd_params; 340 340 341 341 /* prepare command */ ··· 366 366 u8 irq_index, 367 367 u8 *en) 368 368 { 369 - struct mc_command cmd = { 0 }; 369 + struct fsl_mc_command cmd = { 0 }; 370 370 struct dpni_cmd_get_irq_enable *cmd_params; 371 371 struct dpni_rsp_get_irq_enable *rsp_params; 372 372 ··· 413 413 u8 irq_index, 414 414 u32 mask) 415 415 { 416 - struct mc_command cmd = { 0 }; 416 + struct fsl_mc_command cmd = { 0 }; 417 417 struct dpni_cmd_set_irq_mask *cmd_params; 418 418 419 419 /* prepare command */ ··· 447 447 u8 irq_index, 448 448 u32 *mask) 449 449 { 450 - struct mc_command cmd = { 0 }; 450 + struct fsl_mc_command cmd = { 0 }; 451 451 struct dpni_cmd_get_irq_mask *cmd_params; 452 452 struct dpni_rsp_get_irq_mask *rsp_params; 453 453 int err; ··· 489 489 u8 irq_index, 490 490 u32 *status) 491 491 { 492 - struct mc_command cmd = { 0 }; 492 + struct fsl_mc_command cmd = { 0 }; 493 493 struct dpni_cmd_get_irq_status *cmd_params; 494 494 struct dpni_rsp_get_irq_status *rsp_params; 495 495 int err; ··· 532 532 u8 irq_index, 533 533 u32 status) 534 534 { 535 - struct mc_command cmd = { 0 }; 535 + struct fsl_mc_command cmd = { 0 }; 536 536 struct dpni_cmd_clear_irq_status *cmd_params; 537 537 538 538 /* prepare command */ ··· 561 561 u16 token, 562 562 struct dpni_attr *attr) 563 563 { 564 - struct mc_command cmd = { 0 }; 564 + struct fsl_mc_command cmd = { 0 }; 565 565 struct dpni_rsp_get_attr *rsp_params; 566 566 567 567 int err; ··· 609 609 u16 token, 610 610 struct dpni_error_cfg *cfg) 611 611 { 612 - struct mc_command cmd = { 0 }; 612 + struct fsl_mc_command cmd = { 0 }; 613 613 struct dpni_cmd_set_errors_behavior *cmd_params; 614 614 615 615 /* prepare command */ ··· 641 641 enum dpni_queue_type qtype, 642 642 struct dpni_buffer_layout *layout) 643 643 { 644 - struct mc_command cmd = { 0 }; 644 + struct fsl_mc_command cmd = { 0 }; 645 645 struct dpni_cmd_get_buffer_layout *cmd_params; 646 646 struct dpni_rsp_get_buffer_layout *rsp_params; 647 647 int err; ··· 689 689 enum dpni_queue_type qtype, 690 690 const struct dpni_buffer_layout *layout) 691 691 { 692 - struct mc_command cmd = { 0 }; 692 + struct fsl_mc_command cmd = { 0 }; 693 693 struct dpni_cmd_set_buffer_layout *cmd_params; 694 694 695 695 /* prepare command */ ··· 731 731 enum dpni_offload type, 732 732 u32 config) 733 733 { 734 - struct mc_command cmd = { 0 }; 734 + struct fsl_mc_command cmd = { 0 }; 735 735 struct dpni_cmd_set_offload *cmd_params; 736 736 737 737 cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_OFFLOAD, ··· 750 750 enum dpni_offload type, 751 751 u32 *config) 752 752 { 753 - struct mc_command cmd = { 0 }; 753 + struct fsl_mc_command cmd = { 0 }; 754 754 struct dpni_cmd_get_offload *cmd_params; 755 755 struct dpni_rsp_get_offload *rsp_params; 756 756 int err; ··· 792 792 enum dpni_queue_type qtype, 793 793 u16 *qdid) 794 794 { 795 - struct mc_command cmd = { 0 }; 795 + struct fsl_mc_command cmd = { 0 }; 796 796 struct dpni_cmd_get_qdid *cmd_params; 797 797 struct dpni_rsp_get_qdid *rsp_params; 798 798 int err; ··· 830 830 u16 token, 831 831 u16 *data_offset) 832 832 { 833 - struct mc_command cmd = { 0 }; 833 + struct fsl_mc_command cmd = { 0 }; 834 834 struct dpni_rsp_get_tx_data_offset *rsp_params; 835 835 int err; 836 836 ··· 865 865 u16 token, 866 866 const struct dpni_link_cfg *cfg) 867 867 { 868 - struct mc_command cmd = { 0 }; 868 + struct fsl_mc_command cmd = { 0 }; 869 869 struct dpni_cmd_set_link_cfg *cmd_params; 870 870 871 871 /* prepare command */ ··· 894 894 u16 token, 895 895 struct dpni_link_state *state) 896 896 { 897 - struct mc_command cmd = { 0 }; 897 + struct fsl_mc_command cmd = { 0 }; 898 898 struct dpni_rsp_get_link_state *rsp_params; 899 899 int err; 900 900 ··· 933 933 u16 token, 934 934 u16 max_frame_length) 935 935 { 936 - struct mc_command cmd = { 0 }; 936 + struct fsl_mc_command cmd = { 0 }; 937 937 struct dpni_cmd_set_max_frame_length *cmd_params; 938 938 939 939 /* prepare command */ ··· 963 963 u16 token, 964 964 u16 *max_frame_length) 965 965 { 966 - struct mc_command cmd = { 0 }; 966 + struct fsl_mc_command cmd = { 0 }; 967 967 struct dpni_rsp_get_max_frame_length *rsp_params; 968 968 int err; 969 969 ··· 998 998 u16 token, 999 999 int en) 1000 1000 { 1001 - struct mc_command cmd = { 0 }; 1001 + struct fsl_mc_command cmd = { 0 }; 1002 1002 struct dpni_cmd_set_multicast_promisc *cmd_params; 1003 1003 1004 1004 /* prepare command */ ··· 1026 1026 u16 token, 1027 1027 int *en) 1028 1028 { 1029 - struct mc_command cmd = { 0 }; 1029 + struct fsl_mc_command cmd = { 0 }; 1030 1030 struct dpni_rsp_get_multicast_promisc *rsp_params; 1031 1031 int err; 1032 1032 ··· 1061 1061 u16 token, 1062 1062 int en) 1063 1063 { 1064 - struct mc_command cmd = { 0 }; 1064 + struct fsl_mc_command cmd = { 0 }; 1065 1065 struct dpni_cmd_set_unicast_promisc *cmd_params; 1066 1066 1067 1067 /* prepare command */ ··· 1089 1089 u16 token, 1090 1090 int *en) 1091 1091 { 1092 - struct mc_command cmd = { 0 }; 1092 + struct fsl_mc_command cmd = { 0 }; 1093 1093 struct dpni_rsp_get_unicast_promisc *rsp_params; 1094 1094 int err; 1095 1095 ··· 1124 1124 u16 token, 1125 1125 const u8 mac_addr[6]) 1126 1126 { 1127 - struct mc_command cmd = { 0 }; 1127 + struct fsl_mc_command cmd = { 0 }; 1128 1128 struct dpni_cmd_set_primary_mac_addr *cmd_params; 1129 1129 int i; 1130 1130 ··· 1154 1154 u16 token, 1155 1155 u8 mac_addr[6]) 1156 1156 { 1157 - struct mc_command cmd = { 0 }; 1157 + struct fsl_mc_command cmd = { 0 }; 1158 1158 struct dpni_rsp_get_primary_mac_addr *rsp_params; 1159 1159 int i, err; 1160 1160 ··· 1193 1193 u16 token, 1194 1194 u8 mac_addr[6]) 1195 1195 { 1196 - struct mc_command cmd = { 0 }; 1196 + struct fsl_mc_command cmd = { 0 }; 1197 1197 struct dpni_rsp_get_port_mac_addr *rsp_params; 1198 1198 int i, err; 1199 1199 ··· 1229 1229 u16 token, 1230 1230 const u8 mac_addr[6]) 1231 1231 { 1232 - struct mc_command cmd = { 0 }; 1232 + struct fsl_mc_command cmd = { 0 }; 1233 1233 struct dpni_cmd_add_mac_addr *cmd_params; 1234 1234 int i; 1235 1235 ··· 1259 1259 u16 token, 1260 1260 const u8 mac_addr[6]) 1261 1261 { 1262 - struct mc_command cmd = { 0 }; 1262 + struct fsl_mc_command cmd = { 0 }; 1263 1263 struct dpni_cmd_remove_mac_addr *cmd_params; 1264 1264 int i; 1265 1265 ··· 1293 1293 int unicast, 1294 1294 int multicast) 1295 1295 { 1296 - struct mc_command cmd = { 0 }; 1296 + struct fsl_mc_command cmd = { 0 }; 1297 1297 struct dpni_cmd_clear_mac_filters *cmd_params; 1298 1298 1299 1299 /* prepare command */ ··· 1327 1327 u8 tc_id, 1328 1328 const struct dpni_rx_tc_dist_cfg *cfg) 1329 1329 { 1330 - struct mc_command cmd = { 0 }; 1330 + struct fsl_mc_command cmd = { 0 }; 1331 1331 struct dpni_cmd_set_rx_tc_dist *cmd_params; 1332 1332 1333 1333 /* prepare command */ ··· 1371 1371 u8 options, 1372 1372 const struct dpni_queue *queue) 1373 1373 { 1374 - struct mc_command cmd = { 0 }; 1374 + struct fsl_mc_command cmd = { 0 }; 1375 1375 struct dpni_cmd_set_queue *cmd_params; 1376 1376 1377 1377 /* prepare command */ ··· 1419 1419 struct dpni_queue *queue, 1420 1420 struct dpni_queue_id *qid) 1421 1421 { 1422 - struct mc_command cmd = { 0 }; 1422 + struct fsl_mc_command cmd = { 0 }; 1423 1423 struct dpni_cmd_get_queue *cmd_params; 1424 1424 struct dpni_rsp_get_queue *rsp_params; 1425 1425 int err; ··· 1473 1473 u8 page, 1474 1474 union dpni_statistics *stat) 1475 1475 { 1476 - struct mc_command cmd = { 0 }; 1476 + struct fsl_mc_command cmd = { 0 }; 1477 1477 struct dpni_cmd_get_statistics *cmd_params; 1478 1478 struct dpni_rsp_get_statistics *rsp_params; 1479 1479 int i, err; ··· 1522 1522 u8 index, 1523 1523 struct dpni_taildrop *taildrop) 1524 1524 { 1525 - struct mc_command cmd = { 0 }; 1525 + struct fsl_mc_command cmd = { 0 }; 1526 1526 struct dpni_cmd_set_taildrop *cmd_params; 1527 1527 1528 1528 /* prepare command */ ··· 1566 1566 u8 index, 1567 1567 struct dpni_taildrop *taildrop) 1568 1568 { 1569 - struct mc_command cmd = { 0 }; 1569 + struct fsl_mc_command cmd = { 0 }; 1570 1570 struct dpni_cmd_get_taildrop *cmd_params; 1571 1571 struct dpni_rsp_get_taildrop *rsp_params; 1572 1572 int err; ··· 1610 1610 u16 *minor_ver) 1611 1611 { 1612 1612 struct dpni_rsp_get_api_version *rsp_params; 1613 - struct mc_command cmd = { 0 }; 1613 + struct fsl_mc_command cmd = { 0 }; 1614 1614 int err; 1615 1615 1616 1616 cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_API_VERSION,
+32 -32
drivers/staging/fsl-dpaa2/ethsw/dpsw.c
··· 43 43 int dpsw_id, 44 44 u16 *token) 45 45 { 46 - struct mc_command cmd = { 0 }; 46 + struct fsl_mc_command cmd = { 0 }; 47 47 struct dpsw_cmd_open *cmd_params; 48 48 int err; 49 49 ··· 80 80 u32 cmd_flags, 81 81 u16 token) 82 82 { 83 - struct mc_command cmd = { 0 }; 83 + struct fsl_mc_command cmd = { 0 }; 84 84 85 85 /* prepare command */ 86 86 cmd.header = mc_encode_cmd_header(DPSW_CMDID_CLOSE, ··· 103 103 u32 cmd_flags, 104 104 u16 token) 105 105 { 106 - struct mc_command cmd = { 0 }; 106 + struct fsl_mc_command cmd = { 0 }; 107 107 108 108 /* prepare command */ 109 109 cmd.header = mc_encode_cmd_header(DPSW_CMDID_ENABLE, ··· 126 126 u32 cmd_flags, 127 127 u16 token) 128 128 { 129 - struct mc_command cmd = { 0 }; 129 + struct fsl_mc_command cmd = { 0 }; 130 130 131 131 /* prepare command */ 132 132 cmd.header = mc_encode_cmd_header(DPSW_CMDID_DISABLE, ··· 149 149 u32 cmd_flags, 150 150 u16 token) 151 151 { 152 - struct mc_command cmd = { 0 }; 152 + struct fsl_mc_command cmd = { 0 }; 153 153 154 154 /* prepare command */ 155 155 cmd.header = mc_encode_cmd_header(DPSW_CMDID_RESET, ··· 181 181 u8 irq_index, 182 182 u8 en) 183 183 { 184 - struct mc_command cmd = { 0 }; 184 + struct fsl_mc_command cmd = { 0 }; 185 185 struct dpsw_cmd_set_irq_enable *cmd_params; 186 186 187 187 /* prepare command */ ··· 218 218 u8 irq_index, 219 219 u32 mask) 220 220 { 221 - struct mc_command cmd = { 0 }; 221 + struct fsl_mc_command cmd = { 0 }; 222 222 struct dpsw_cmd_set_irq_mask *cmd_params; 223 223 224 224 /* prepare command */ ··· 251 251 u8 irq_index, 252 252 u32 *status) 253 253 { 254 - struct mc_command cmd = { 0 }; 254 + struct fsl_mc_command cmd = { 0 }; 255 255 struct dpsw_cmd_get_irq_status *cmd_params; 256 256 struct dpsw_rsp_get_irq_status *rsp_params; 257 257 int err; ··· 294 294 u8 irq_index, 295 295 u32 status) 296 296 { 297 - struct mc_command cmd = { 0 }; 297 + struct fsl_mc_command cmd = { 0 }; 298 298 struct dpsw_cmd_clear_irq_status *cmd_params; 299 299 300 300 /* prepare command */ ··· 323 323 u16 token, 324 324 struct dpsw_attr *attr) 325 325 { 326 - struct mc_command cmd = { 0 }; 326 + struct fsl_mc_command cmd = { 0 }; 327 327 struct dpsw_rsp_get_attr *rsp_params; 328 328 int err; 329 329 ··· 373 373 u16 if_id, 374 374 struct dpsw_link_cfg *cfg) 375 375 { 376 - struct mc_command cmd = { 0 }; 376 + struct fsl_mc_command cmd = { 0 }; 377 377 struct dpsw_cmd_if_set_link_cfg *cmd_params; 378 378 379 379 /* prepare command */ ··· 405 405 u16 if_id, 406 406 struct dpsw_link_state *state) 407 407 { 408 - struct mc_command cmd = { 0 }; 408 + struct fsl_mc_command cmd = { 0 }; 409 409 struct dpsw_cmd_if_get_link_state *cmd_params; 410 410 struct dpsw_rsp_if_get_link_state *rsp_params; 411 411 int err; ··· 447 447 u16 if_id, 448 448 u8 en) 449 449 { 450 - struct mc_command cmd = { 0 }; 450 + struct fsl_mc_command cmd = { 0 }; 451 451 struct dpsw_cmd_if_set_flooding *cmd_params; 452 452 453 453 /* prepare command */ ··· 478 478 u16 if_id, 479 479 u8 en) 480 480 { 481 - struct mc_command cmd = { 0 }; 481 + struct fsl_mc_command cmd = { 0 }; 482 482 struct dpsw_cmd_if_set_broadcast *cmd_params; 483 483 484 484 /* prepare command */ ··· 509 509 u16 if_id, 510 510 const struct dpsw_tci_cfg *cfg) 511 511 { 512 - struct mc_command cmd = { 0 }; 512 + struct fsl_mc_command cmd = { 0 }; 513 513 struct dpsw_cmd_if_set_tci *cmd_params; 514 514 u16 tmp_conf = 0; 515 515 ··· 547 547 u16 if_id, 548 548 const struct dpsw_stp_cfg *cfg) 549 549 { 550 - struct mc_command cmd = { 0 }; 550 + struct fsl_mc_command cmd = { 0 }; 551 551 struct dpsw_cmd_if_set_stp *cmd_params; 552 552 553 553 /* prepare command */ ··· 581 581 enum dpsw_counter type, 582 582 u64 *counter) 583 583 { 584 - struct mc_command cmd = { 0 }; 584 + struct fsl_mc_command cmd = { 0 }; 585 585 struct dpsw_cmd_if_get_counter *cmd_params; 586 586 struct dpsw_rsp_if_get_counter *rsp_params; 587 587 int err; ··· 620 620 u16 token, 621 621 u16 if_id) 622 622 { 623 - struct mc_command cmd = { 0 }; 623 + struct fsl_mc_command cmd = { 0 }; 624 624 struct dpsw_cmd_if *cmd_params; 625 625 626 626 /* prepare command */ ··· 648 648 u16 token, 649 649 u16 if_id) 650 650 { 651 - struct mc_command cmd = { 0 }; 651 + struct fsl_mc_command cmd = { 0 }; 652 652 struct dpsw_cmd_if *cmd_params; 653 653 654 654 /* prepare command */ ··· 678 678 u16 if_id, 679 679 u16 frame_length) 680 680 { 681 - struct mc_command cmd = { 0 }; 681 + struct fsl_mc_command cmd = { 0 }; 682 682 struct dpsw_cmd_if_set_max_frame_length *cmd_params; 683 683 684 684 /* prepare command */ ··· 716 716 u16 vlan_id, 717 717 const struct dpsw_vlan_cfg *cfg) 718 718 { 719 - struct mc_command cmd = { 0 }; 719 + struct fsl_mc_command cmd = { 0 }; 720 720 struct dpsw_vlan_add *cmd_params; 721 721 722 722 /* prepare command */ ··· 752 752 u16 vlan_id, 753 753 const struct dpsw_vlan_if_cfg *cfg) 754 754 { 755 - struct mc_command cmd = { 0 }; 755 + struct fsl_mc_command cmd = { 0 }; 756 756 struct dpsw_cmd_vlan_manage_if *cmd_params; 757 757 758 758 /* prepare command */ ··· 790 790 u16 vlan_id, 791 791 const struct dpsw_vlan_if_cfg *cfg) 792 792 { 793 - struct mc_command cmd = { 0 }; 793 + struct fsl_mc_command cmd = { 0 }; 794 794 struct dpsw_cmd_vlan_manage_if *cmd_params; 795 795 796 796 /* prepare command */ ··· 824 824 u16 vlan_id, 825 825 const struct dpsw_vlan_if_cfg *cfg) 826 826 { 827 - struct mc_command cmd = { 0 }; 827 + struct fsl_mc_command cmd = { 0 }; 828 828 struct dpsw_cmd_vlan_manage_if *cmd_params; 829 829 830 830 /* prepare command */ ··· 860 860 u16 vlan_id, 861 861 const struct dpsw_vlan_if_cfg *cfg) 862 862 { 863 - struct mc_command cmd = { 0 }; 863 + struct fsl_mc_command cmd = { 0 }; 864 864 struct dpsw_cmd_vlan_manage_if *cmd_params; 865 865 866 866 /* prepare command */ ··· 889 889 u16 token, 890 890 u16 vlan_id) 891 891 { 892 - struct mc_command cmd = { 0 }; 892 + struct fsl_mc_command cmd = { 0 }; 893 893 struct dpsw_cmd_vlan_remove *cmd_params; 894 894 895 895 /* prepare command */ ··· 919 919 u16 fdb_id, 920 920 const struct dpsw_fdb_unicast_cfg *cfg) 921 921 { 922 - struct mc_command cmd = { 0 }; 922 + struct fsl_mc_command cmd = { 0 }; 923 923 struct dpsw_cmd_fdb_unicast_op *cmd_params; 924 924 int i; 925 925 ··· 954 954 u16 fdb_id, 955 955 const struct dpsw_fdb_unicast_cfg *cfg) 956 956 { 957 - struct mc_command cmd = { 0 }; 957 + struct fsl_mc_command cmd = { 0 }; 958 958 struct dpsw_cmd_fdb_unicast_op *cmd_params; 959 959 int i; 960 960 ··· 996 996 u16 fdb_id, 997 997 const struct dpsw_fdb_multicast_cfg *cfg) 998 998 { 999 - struct mc_command cmd = { 0 }; 999 + struct fsl_mc_command cmd = { 0 }; 1000 1000 struct dpsw_cmd_fdb_multicast_op *cmd_params; 1001 1001 int i; 1002 1002 ··· 1038 1038 u16 fdb_id, 1039 1039 const struct dpsw_fdb_multicast_cfg *cfg) 1040 1040 { 1041 - struct mc_command cmd = { 0 }; 1041 + struct fsl_mc_command cmd = { 0 }; 1042 1042 struct dpsw_cmd_fdb_multicast_op *cmd_params; 1043 1043 int i; 1044 1044 ··· 1074 1074 u16 fdb_id, 1075 1075 enum dpsw_fdb_learning_mode mode) 1076 1076 { 1077 - struct mc_command cmd = { 0 }; 1077 + struct fsl_mc_command cmd = { 0 }; 1078 1078 struct dpsw_cmd_fdb_set_learning_mode *cmd_params; 1079 1079 1080 1080 /* prepare command */ ··· 1103 1103 u16 *major_ver, 1104 1104 u16 *minor_ver) 1105 1105 { 1106 - struct mc_command cmd = { 0 }; 1106 + struct fsl_mc_command cmd = { 0 }; 1107 1107 struct dpsw_rsp_get_api_version *rsp_params; 1108 1108 int err; 1109 1109
+6 -6
drivers/staging/fsl-mc/bus/dpio/dpio.c
··· 37 37 int dpio_id, 38 38 u16 *token) 39 39 { 40 - struct mc_command cmd = { 0 }; 40 + struct fsl_mc_command cmd = { 0 }; 41 41 struct dpio_cmd_open *dpio_cmd; 42 42 int err; 43 43 ··· 70 70 u32 cmd_flags, 71 71 u16 token) 72 72 { 73 - struct mc_command cmd = { 0 }; 73 + struct fsl_mc_command cmd = { 0 }; 74 74 75 75 /* prepare command */ 76 76 cmd.header = mc_encode_cmd_header(DPIO_CMDID_CLOSE, ··· 92 92 u32 cmd_flags, 93 93 u16 token) 94 94 { 95 - struct mc_command cmd = { 0 }; 95 + struct fsl_mc_command cmd = { 0 }; 96 96 97 97 /* prepare command */ 98 98 cmd.header = mc_encode_cmd_header(DPIO_CMDID_ENABLE, ··· 114 114 u32 cmd_flags, 115 115 u16 token) 116 116 { 117 - struct mc_command cmd = { 0 }; 117 + struct fsl_mc_command cmd = { 0 }; 118 118 119 119 /* prepare command */ 120 120 cmd.header = mc_encode_cmd_header(DPIO_CMDID_DISABLE, ··· 138 138 u16 token, 139 139 struct dpio_attr *attr) 140 140 { 141 - struct mc_command cmd = { 0 }; 141 + struct fsl_mc_command cmd = { 0 }; 142 142 struct dpio_rsp_get_attr *dpio_rsp; 143 143 int err; 144 144 ··· 180 180 u16 *major_ver, 181 181 u16 *minor_ver) 182 182 { 183 - struct mc_command cmd = { 0 }; 183 + struct fsl_mc_command cmd = { 0 }; 184 184 int err; 185 185 186 186 /* prepare command */
+5 -5
include/linux/fsl/mc.h
··· 209 209 __le16 cmd_id; 210 210 }; 211 211 212 - struct mc_command { 212 + struct fsl_mc_command { 213 213 u64 header; 214 214 u64 params[MC_CMD_NUM_OF_PARAMS]; 215 215 }; ··· 256 256 return header; 257 257 } 258 258 259 - static inline u16 mc_cmd_hdr_read_token(struct mc_command *cmd) 259 + static inline u16 mc_cmd_hdr_read_token(struct fsl_mc_command *cmd) 260 260 { 261 261 struct mc_cmd_header *hdr = (struct mc_cmd_header *)&cmd->header; 262 262 u16 token = le16_to_cpu(hdr->token); ··· 273 273 __le16 minor_ver; 274 274 }; 275 275 276 - static inline u32 mc_cmd_read_object_id(struct mc_command *cmd) 276 + static inline u32 mc_cmd_read_object_id(struct fsl_mc_command *cmd) 277 277 { 278 278 struct mc_rsp_create *rsp_params; 279 279 ··· 281 281 return le32_to_cpu(rsp_params->object_id); 282 282 } 283 283 284 - static inline void mc_cmd_read_api_version(struct mc_command *cmd, 284 + static inline void mc_cmd_read_api_version(struct fsl_mc_command *cmd, 285 285 u16 *major_ver, 286 286 u16 *minor_ver) 287 287 { ··· 342 342 }; 343 343 }; 344 344 345 - int mc_send_command(struct fsl_mc_io *mc_io, struct mc_command *cmd); 345 + int mc_send_command(struct fsl_mc_io *mc_io, struct fsl_mc_command *cmd); 346 346 347 347 #ifdef CONFIG_FSL_MC_BUS 348 348 #define dev_is_fsl_mc(_dev) ((_dev)->bus == &fsl_mc_bus_type)