1 /* 2 * Copyright 2021 Google LLC 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 /* 18 * Library of NC-SI commands compliant with version 1.0.0. 19 * 20 * This implements a subset of the commands provided in the specification. 21 * 22 * Checksums are optional and not implemented here. All NC-SI checksums are set 23 * to 0 to indicate that per 8.2.2.3. 24 */ 25 26 #include <stdint.h> 27 #include <string.h> 28 29 #include <netinet/in.h> 30 31 #include "platforms/nemora/portable/ncsi_client.h" 32 33 #ifndef ARRAY_SIZE 34 #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) 35 #endif 36 37 // todo - To save space these tables use the notion that no response is 38 // larger than 255 bytes. Need a BUILD_ASSERT. 39 // todo - Replace 0's with actual sizes once the commands are supported 40 static const uint8_t ncsi_response_size_table[] = { 41 sizeof(ncsi_simple_response_t), // NCSI_CLEAR_INITIAL_STATE 42 sizeof(ncsi_simple_response_t), // NCSI_SELECT_PACKAGE 43 sizeof(ncsi_simple_response_t), // NCSI_DESELECT_PACKAGE 44 sizeof(ncsi_simple_response_t), // NCSI_ENABLE_CHANNEL 45 sizeof(ncsi_simple_response_t), // NCSI_DISABLE_CHANNEL 46 sizeof(ncsi_simple_response_t), // NCSI_RESET_CHANNEL 47 sizeof(ncsi_simple_response_t), // NCSI_ENABLE_CHANNEL_NETWORK_TX 48 sizeof(ncsi_simple_response_t), // NCSI_DISABLE_CHANNEL_NETWORK_TX 49 sizeof(ncsi_simple_response_t), // NCSI_AEN_ENABLE 50 sizeof(ncsi_simple_response_t), // NCSI_SET_LINK 51 sizeof(ncsi_link_status_response_t), // NCSI_GET_LINK_STATUS 52 sizeof(ncsi_simple_response_t), // NCSI_SET_VLAN_FILTER 53 sizeof(ncsi_simple_response_t), // NCSI_ENABLE_VLAN 54 sizeof(ncsi_simple_response_t), // NCSI_DISABLE_VLAN 55 sizeof(ncsi_simple_response_t), // NCSI_SET_MAC_ADDRESS 56 0, // 0x0F is not a valid command 57 sizeof(ncsi_simple_response_t), // NCSI_ENABLE_BROADCAST_FILTER 58 sizeof(ncsi_simple_response_t), // NCSI_DISABLE_BROADCAST_FILTER 59 sizeof(ncsi_simple_response_t), // NCSI_ENABLE_GLOBAL_MULTICAST_FILTER 60 sizeof(ncsi_simple_response_t), // NCSI_DISABLE_GLOBAL_MULTICAST_FILTER 61 sizeof(ncsi_simple_response_t), // NCSI_SET_NCSI_FLOW_CONTROL 62 sizeof(ncsi_version_id_response_t), // NCSI_GET_VERSION_ID 63 sizeof(ncsi_capabilities_response_t), // NCSI_GET_CAPABILITIES 64 sizeof(ncsi_parameters_response_t), // NCSI_GET_PARAMETERS 65 0, // NCSI_GET_CONTROLLER_PACKET_STATISTICS 66 0, // NCSI_GET_NCSI_STATISTICS 67 sizeof(ncsi_passthrough_stats_response_t), // NCSI_GET_PASSTHROUGH_STATISTICS 68 }; 69 70 static const uint8_t ncsi_oem_response_size_table[] = { 71 sizeof(ncsi_host_mac_response_t), // NCSI_OEM_COMMAND_GET_HOST_MAC 72 sizeof(ncsi_oem_simple_response_t), // NCSI_OEM_COMMAND_SET_FILTER 73 sizeof(ncsi_oem_get_filter_response_t), // NCSI_OEM_COMMAND_GET_FILTER 74 sizeof(ncsi_oem_echo_response_t), // NCSI_OEM_COMMAND_ECHO 75 }; 76 77 // TODO Should increment when we send a packet that is not a retry. 78 static uint8_t current_instance_id; 79 80 /* 81 * Sets _most_ of the NC-SI header fields. Caller is expected to set 82 * payload_length field if it is > 0. For many NC-SI commands it is 0. 83 */ set_header_fields(ncsi_header_t * header,uint8_t ch_id,uint8_t cmd_type)84 static void set_header_fields(ncsi_header_t* header, uint8_t ch_id, 85 uint8_t cmd_type) 86 { 87 // Destination MAC must be all 0xFF. 88 memset(header->ethhdr.dest.octet, 0xFF, sizeof(header->ethhdr.dest.octet)); 89 // Source MAC can be any value. 90 memset(header->ethhdr.src.octet, 0xAB, sizeof(header->ethhdr.src.octet)); 91 header->ethhdr.ethertype = htons(NCSI_ETHERTYPE); 92 93 // NC-SI Header 94 header->mc_id = NCSI_MC_ID; 95 header->header_revision = NCSI_HEADER_REV; 96 header->reserved_00 = 0; 97 header->instance_id = current_instance_id; 98 header->control_packet_type = cmd_type; 99 header->channel_id = ch_id; 100 header->payload_length = 0; // Caller is expected to set this if != 0. 101 memset(header->reserved_01, 0, sizeof(header->reserved_01)); 102 } 103 ncsi_get_response_size(uint8_t cmd_type)104 uint32_t ncsi_get_response_size(uint8_t cmd_type) 105 { 106 return (cmd_type < ARRAY_SIZE(ncsi_response_size_table)) 107 ? ncsi_response_size_table[cmd_type] 108 : 0; 109 } 110 ncsi_oem_get_response_size(uint8_t oem_cmd_type)111 uint32_t ncsi_oem_get_response_size(uint8_t oem_cmd_type) 112 { 113 return (oem_cmd_type < ARRAY_SIZE(ncsi_oem_response_size_table)) 114 ? ncsi_oem_response_size_table[oem_cmd_type] 115 : 0; 116 } 117 118 /* 119 * Clear initial state. 120 */ ncsi_cmd_clear_initial_state(uint8_t * buf,uint8_t channel)121 uint32_t ncsi_cmd_clear_initial_state(uint8_t* buf, uint8_t channel) 122 { 123 set_header_fields((ncsi_header_t*)buf, channel, NCSI_CLEAR_INITIAL_STATE); 124 return sizeof(ncsi_simple_command_t); 125 } 126 127 /* 128 * Set MAC address filters. 129 */ ncsi_cmd_set_mac(uint8_t * buf,uint8_t channel_id,mac_addr_t * mac)130 uint32_t ncsi_cmd_set_mac(uint8_t* buf, uint8_t channel_id, mac_addr_t* mac) 131 { 132 ncsi_set_mac_command_t* cmd = (ncsi_set_mac_command_t*)buf; 133 134 set_header_fields((ncsi_header_t*)buf, channel_id, NCSI_SET_MAC_ADDRESS); 135 cmd->hdr.payload_length = 136 htons(sizeof(ncsi_set_mac_command_t) - sizeof(ncsi_header_t)); 137 memcpy(cmd->mac_addr.octet, mac->octet, sizeof(cmd->mac_addr.octet)); 138 cmd->mac_addr_num = 1; 139 // Unicast MAC address (AT=0), enabled (E=1). 140 cmd->misc = 0x01; 141 return sizeof(ncsi_set_mac_command_t); 142 } 143 ncsi_cmd_enable_broadcast_filter(uint8_t * buf,uint8_t channel,uint32_t filter_settings)144 uint32_t ncsi_cmd_enable_broadcast_filter(uint8_t* buf, uint8_t channel, 145 uint32_t filter_settings) 146 { 147 ncsi_enable_broadcast_filter_command_t* cmd = 148 (ncsi_enable_broadcast_filter_command_t*)buf; 149 set_header_fields((ncsi_header_t*)buf, channel, 150 NCSI_ENABLE_BROADCAST_FILTER); 151 cmd->hdr.payload_length = htons( 152 sizeof(ncsi_enable_broadcast_filter_command_t) - sizeof(ncsi_header_t)); 153 cmd->filter_settings = htonl(filter_settings); 154 return sizeof(ncsi_enable_broadcast_filter_command_t); 155 } 156 157 ncsi_cmd_disable_broadcast_filter(uint8_t * buf,uint8_t channel)158 uint32_t ncsi_cmd_disable_broadcast_filter(uint8_t* buf, uint8_t channel) 159 { 160 set_header_fields((ncsi_header_t*)buf, channel, 161 NCSI_DISABLE_BROADCAST_FILTER); 162 return sizeof(ncsi_simple_command_t); 163 } 164 ncsi_cmd_enable_channel(uint8_t * buf,uint8_t channel)165 uint32_t ncsi_cmd_enable_channel(uint8_t* buf, uint8_t channel) 166 { 167 set_header_fields((ncsi_header_t*)buf, channel, NCSI_ENABLE_CHANNEL); 168 return sizeof(ncsi_simple_command_t); 169 } 170 ncsi_cmd_get_link_status(uint8_t * buf,uint8_t channel)171 uint32_t ncsi_cmd_get_link_status(uint8_t* buf, uint8_t channel) 172 { 173 set_header_fields((ncsi_header_t*)buf, channel, NCSI_GET_LINK_STATUS); 174 return sizeof(ncsi_simple_command_t); 175 } 176 ncsi_cmd_reset_channel(uint8_t * buf,uint8_t channel)177 uint32_t ncsi_cmd_reset_channel(uint8_t* buf, uint8_t channel) 178 { 179 set_header_fields((ncsi_header_t*)buf, channel, NCSI_RESET_CHANNEL); 180 return sizeof(ncsi_simple_command_t); 181 } 182 ncsi_cmd_enable_tx(uint8_t * buf,uint8_t channel)183 uint32_t ncsi_cmd_enable_tx(uint8_t* buf, uint8_t channel) 184 { 185 set_header_fields((ncsi_header_t*)buf, channel, 186 NCSI_ENABLE_CHANNEL_NETWORK_TX); 187 return sizeof(ncsi_simple_command_t); 188 } 189 ncsi_cmd_get_version(uint8_t * buf,uint8_t channel)190 uint32_t ncsi_cmd_get_version(uint8_t* buf, uint8_t channel) 191 { 192 set_header_fields((ncsi_header_t*)buf, channel, NCSI_GET_VERSION_ID); 193 return sizeof(ncsi_simple_command_t); 194 } 195 ncsi_cmd_get_capabilities(uint8_t * buf,uint8_t channel)196 uint32_t ncsi_cmd_get_capabilities(uint8_t* buf, uint8_t channel) 197 { 198 set_header_fields((ncsi_header_t*)buf, channel, NCSI_GET_CAPABILITIES); 199 return sizeof(ncsi_simple_command_t); 200 } 201 ncsi_cmd_get_parameters(uint8_t * buf,uint8_t channel)202 uint32_t ncsi_cmd_get_parameters(uint8_t* buf, uint8_t channel) 203 { 204 set_header_fields((ncsi_header_t*)buf, channel, NCSI_GET_PARAMETERS); 205 return sizeof(ncsi_simple_command_t); 206 } 207 ncsi_cmd_get_passthrough_stats(uint8_t * buf,uint8_t channel)208 uint32_t ncsi_cmd_get_passthrough_stats(uint8_t* buf, uint8_t channel) 209 { 210 set_header_fields((ncsi_header_t*)buf, channel, 211 NCSI_GET_PASSTHROUGH_STATISTICS); 212 return sizeof(ncsi_simple_command_t); 213 } 214 215 /* OEM commands */ 216 ncsi_oem_cmd_get_host_mac(uint8_t * buf,uint8_t channel)217 uint32_t ncsi_oem_cmd_get_host_mac(uint8_t* buf, uint8_t channel) 218 { 219 ncsi_oem_simple_cmd_t* cmd = (ncsi_oem_simple_cmd_t*)buf; 220 set_header_fields((ncsi_header_t*)buf, channel, NCSI_OEM_COMMAND); 221 cmd->hdr.payload_length = 222 htons(sizeof(ncsi_oem_simple_cmd_t) - sizeof(ncsi_header_t)); 223 cmd->oem_header.manufacturer_id = htonl(NCSI_OEM_MANUFACTURER_ID); 224 memset(cmd->oem_header.reserved, 0, sizeof(cmd->oem_header.reserved)); 225 cmd->oem_header.oem_cmd = NCSI_OEM_COMMAND_GET_HOST_MAC; 226 return sizeof(ncsi_oem_simple_cmd_t); 227 } 228 ncsi_oem_cmd_get_filter(uint8_t * buf,uint8_t channel)229 uint32_t ncsi_oem_cmd_get_filter(uint8_t* buf, uint8_t channel) 230 { 231 ncsi_oem_simple_cmd_t* cmd = (ncsi_oem_simple_cmd_t*)buf; 232 set_header_fields((ncsi_header_t*)buf, channel, NCSI_OEM_COMMAND); 233 cmd->hdr.payload_length = 234 htons(sizeof(ncsi_oem_simple_cmd_t) - sizeof(ncsi_header_t)); 235 cmd->oem_header.manufacturer_id = htonl(NCSI_OEM_MANUFACTURER_ID); 236 memset(cmd->oem_header.reserved, 0, sizeof(cmd->oem_header.reserved)); 237 cmd->oem_header.oem_cmd = NCSI_OEM_COMMAND_GET_FILTER; 238 return sizeof(ncsi_oem_simple_cmd_t); 239 } 240 ncsi_oem_cmd_set_filter(uint8_t * buf,uint8_t channel,mac_addr_t * mac,uint32_t ip,uint16_t port,uint8_t flags)241 uint32_t ncsi_oem_cmd_set_filter(uint8_t* buf, uint8_t channel, mac_addr_t* mac, 242 uint32_t ip, uint16_t port, uint8_t flags) 243 { 244 ncsi_oem_set_filter_cmd_t* cmd = (ncsi_oem_set_filter_cmd_t*)buf; 245 set_header_fields((ncsi_header_t*)buf, channel, NCSI_OEM_COMMAND); 246 cmd->hdr.payload_length = 247 htons(sizeof(ncsi_oem_set_filter_cmd_t) - sizeof(ncsi_header_t)); 248 cmd->oem_header.manufacturer_id = htonl(NCSI_OEM_MANUFACTURER_ID); 249 memset(cmd->oem_header.reserved, 0, sizeof(cmd->oem_header.reserved)); 250 cmd->oem_header.oem_cmd = NCSI_OEM_COMMAND_SET_FILTER; 251 252 cmd->filter.reserved0 = 0; 253 memcpy(cmd->filter.mac, mac->octet, sizeof(cmd->filter.mac)); 254 cmd->filter.ip = htonl(ip); 255 cmd->filter.port = htons(port); 256 cmd->filter.reserved1 = 0; 257 cmd->filter.flags = flags; 258 memset(cmd->filter.regid, 0, sizeof(cmd->filter.regid)); // reserved for set 259 return sizeof(ncsi_oem_set_filter_cmd_t); 260 } 261 ncsi_oem_cmd_echo(uint8_t * buf,uint8_t channel,uint8_t pattern[64])262 uint32_t ncsi_oem_cmd_echo(uint8_t* buf, uint8_t channel, uint8_t pattern[64]) 263 { 264 ncsi_oem_echo_cmd_t* cmd = (ncsi_oem_echo_cmd_t*)buf; 265 set_header_fields((ncsi_header_t*)buf, channel, NCSI_OEM_COMMAND); 266 cmd->hdr.payload_length = 267 htons(sizeof(ncsi_oem_echo_cmd_t) - sizeof(ncsi_header_t)); 268 cmd->oem_header.manufacturer_id = htonl(NCSI_OEM_MANUFACTURER_ID); 269 memset(cmd->oem_header.reserved, 0, sizeof(cmd->oem_header.reserved)); 270 cmd->oem_header.oem_cmd = NCSI_OEM_COMMAND_ECHO; 271 memcpy(cmd->pattern, pattern, sizeof(cmd->pattern)); 272 return sizeof(ncsi_oem_echo_cmd_t); 273 } 274 ncsi_validate_response(uint8_t * buf,uint32_t len,uint8_t cmd_type,bool is_oem,uint32_t expected_size)275 ncsi_response_type_t ncsi_validate_response(uint8_t* buf, uint32_t len, 276 uint8_t cmd_type, bool is_oem, 277 uint32_t expected_size) { 278 if (len < sizeof(ncsi_simple_response_t)) { 279 return NCSI_RESPONSE_UNDERSIZED; 280 } 281 282 const ncsi_simple_response_t* response = (ncsi_simple_response_t*)buf; 283 if (response->response_code || response->reason_code) { 284 return NCSI_RESPONSE_NACK; 285 } 286 287 const uint8_t std_cmd_type = is_oem ? NCSI_OEM_COMMAND : cmd_type; 288 if (response->hdr.control_packet_type != (std_cmd_type | NCSI_RESPONSE)) { 289 return NCSI_RESPONSE_UNEXPECTED_TYPE; 290 } 291 292 if (len < expected_size || 293 ntohs(response->hdr.payload_length) != 294 expected_size - sizeof(ncsi_header_t)) { 295 return NCSI_RESPONSE_UNEXPECTED_SIZE; 296 } 297 298 if (is_oem) { 299 /* Since the expected_size was checked above, we know that if this is an oem 300 * command, it is the right size. */ 301 const ncsi_oem_simple_response_t* oem_response = 302 (ncsi_oem_simple_response_t*)buf; 303 if (oem_response->oem_header.manufacturer_id != 304 htonl(NCSI_OEM_MANUFACTURER_ID) || 305 oem_response->oem_header.oem_cmd != cmd_type) { 306 return NCSI_RESPONSE_OEM_FORMAT_ERROR; 307 } 308 } 309 310 return NCSI_RESPONSE_ACK; 311 } 312 ncsi_validate_std_response(uint8_t * buf,uint32_t len,uint8_t cmd_type)313 ncsi_response_type_t ncsi_validate_std_response(uint8_t* buf, uint32_t len, 314 uint8_t cmd_type) { 315 const uint32_t expected_size = ncsi_get_response_size(cmd_type); 316 return ncsi_validate_response(buf, len, cmd_type, false, expected_size); 317 } 318 ncsi_validate_oem_response(uint8_t * buf,uint32_t len,uint8_t cmd_type)319 ncsi_response_type_t ncsi_validate_oem_response(uint8_t* buf, uint32_t len, 320 uint8_t cmd_type) { 321 const uint32_t expected_size = ncsi_oem_get_response_size(cmd_type); 322 return ncsi_validate_response(buf, len, cmd_type, true, expected_size); 323 } 324