1 // SPDX-License-Identifier: ISC 2 /* 3 * Copyright (c) 2005-2011 Atheros Communications Inc. 4 * Copyright (c) 2011-2014,2016-2017 Qualcomm Atheros, Inc. 5 */ 6 7 #include "bmi.h" 8 #include "hif.h" 9 #include "debug.h" 10 #include "htc.h" 11 #include "hw.h" 12 13 void ath10k_bmi_start(struct ath10k *ar) 14 { 15 ath10k_dbg(ar, ATH10K_DBG_BMI, "bmi start\n"); 16 17 ar->bmi.done_sent = false; 18 } 19 EXPORT_SYMBOL(ath10k_bmi_start); 20 21 int ath10k_bmi_done(struct ath10k *ar) 22 { 23 struct bmi_cmd cmd; 24 u32 cmdlen = sizeof(cmd.id) + sizeof(cmd.done); 25 int ret; 26 27 ath10k_dbg(ar, ATH10K_DBG_BMI, "bmi done\n"); 28 29 if (ar->bmi.done_sent) { 30 ath10k_dbg(ar, ATH10K_DBG_BMI, "bmi skipped\n"); 31 return 0; 32 } 33 34 ar->bmi.done_sent = true; 35 cmd.id = __cpu_to_le32(BMI_DONE); 36 37 ret = ath10k_hif_exchange_bmi_msg(ar, &cmd, cmdlen, NULL, NULL); 38 if (ret) { 39 ath10k_warn(ar, "unable to write to the device: %d\n", ret); 40 return ret; 41 } 42 43 return 0; 44 } 45 46 int ath10k_bmi_get_target_info(struct ath10k *ar, 47 struct bmi_target_info *target_info) 48 { 49 struct bmi_cmd cmd; 50 union bmi_resp resp; 51 u32 cmdlen = sizeof(cmd.id) + sizeof(cmd.get_target_info); 52 u32 resplen = sizeof(resp.get_target_info); 53 int ret; 54 55 ath10k_dbg(ar, ATH10K_DBG_BMI, "bmi get target info\n"); 56 57 if (ar->bmi.done_sent) { 58 ath10k_warn(ar, "BMI Get Target Info Command disallowed\n"); 59 return -EBUSY; 60 } 61 62 cmd.id = __cpu_to_le32(BMI_GET_TARGET_INFO); 63 64 ret = ath10k_hif_exchange_bmi_msg(ar, &cmd, cmdlen, &resp, &resplen); 65 if (ret) { 66 ath10k_warn(ar, "unable to get target info from device\n"); 67 return ret; 68 } 69 70 if (resplen < sizeof(resp.get_target_info)) { 71 ath10k_warn(ar, "invalid get_target_info response length (%d)\n", 72 resplen); 73 return -EIO; 74 } 75 76 target_info->version = __le32_to_cpu(resp.get_target_info.version); 77 target_info->type = __le32_to_cpu(resp.get_target_info.type); 78 79 return 0; 80 } 81 82 #define TARGET_VERSION_SENTINAL 0xffffffffu 83 84 int ath10k_bmi_get_target_info_sdio(struct ath10k *ar, 85 struct bmi_target_info *target_info) 86 { 87 struct bmi_cmd cmd; 88 union bmi_resp resp; 89 u32 cmdlen = sizeof(cmd.id) + sizeof(cmd.get_target_info); 90 u32 resplen, ver_len; 91 __le32 tmp; 92 int ret; 93 94 ath10k_dbg(ar, ATH10K_DBG_BMI, "bmi get target info SDIO\n"); 95 96 if (ar->bmi.done_sent) { 97 ath10k_warn(ar, "BMI Get Target Info Command disallowed\n"); 98 return -EBUSY; 99 } 100 101 cmd.id = __cpu_to_le32(BMI_GET_TARGET_INFO); 102 103 /* Step 1: Read 4 bytes of the target info and check if it is 104 * the special sentinal version word or the first word in the 105 * version response. 106 */ 107 resplen = sizeof(u32); 108 ret = ath10k_hif_exchange_bmi_msg(ar, &cmd, cmdlen, &tmp, &resplen); 109 if (ret) { 110 ath10k_warn(ar, "unable to read from device\n"); 111 return ret; 112 } 113 114 /* Some SDIO boards have a special sentinal byte before the real 115 * version response. 116 */ 117 if (__le32_to_cpu(tmp) == TARGET_VERSION_SENTINAL) { 118 /* Step 1b: Read the version length */ 119 resplen = sizeof(u32); 120 ret = ath10k_hif_exchange_bmi_msg(ar, NULL, 0, &tmp, 121 &resplen); 122 if (ret) { 123 ath10k_warn(ar, "unable to read from device\n"); 124 return ret; 125 } 126 } 127 128 ver_len = __le32_to_cpu(tmp); 129 130 /* Step 2: Check the target info length */ 131 if (ver_len != sizeof(resp.get_target_info)) { 132 ath10k_warn(ar, "Unexpected target info len: %u. Expected: %zu\n", 133 ver_len, sizeof(resp.get_target_info)); 134 return -EINVAL; 135 } 136 137 /* Step 3: Read the rest of the version response */ 138 resplen = sizeof(resp.get_target_info) - sizeof(u32); 139 ret = ath10k_hif_exchange_bmi_msg(ar, NULL, 0, 140 &resp.get_target_info.version, 141 &resplen); 142 if (ret) { 143 ath10k_warn(ar, "unable to read from device\n"); 144 return ret; 145 } 146 147 target_info->version = __le32_to_cpu(resp.get_target_info.version); 148 target_info->type = __le32_to_cpu(resp.get_target_info.type); 149 150 return 0; 151 } 152 153 int ath10k_bmi_read_memory(struct ath10k *ar, 154 u32 address, void *buffer, u32 length) 155 { 156 struct bmi_cmd cmd; 157 union bmi_resp resp; 158 u32 cmdlen = sizeof(cmd.id) + sizeof(cmd.read_mem); 159 u32 rxlen; 160 int ret; 161 162 ath10k_dbg(ar, ATH10K_DBG_BMI, "bmi read address 0x%x length %d\n", 163 address, length); 164 165 if (ar->bmi.done_sent) { 166 ath10k_warn(ar, "command disallowed\n"); 167 return -EBUSY; 168 } 169 170 while (length) { 171 rxlen = min_t(u32, length, BMI_MAX_DATA_SIZE); 172 173 cmd.id = __cpu_to_le32(BMI_READ_MEMORY); 174 cmd.read_mem.addr = __cpu_to_le32(address); 175 cmd.read_mem.len = __cpu_to_le32(rxlen); 176 177 ret = ath10k_hif_exchange_bmi_msg(ar, &cmd, cmdlen, 178 &resp, &rxlen); 179 if (ret) { 180 ath10k_warn(ar, "unable to read from the device (%d)\n", 181 ret); 182 return ret; 183 } 184 185 memcpy(buffer, resp.read_mem.payload, rxlen); 186 address += rxlen; 187 buffer += rxlen; 188 length -= rxlen; 189 } 190 191 return 0; 192 } 193 EXPORT_SYMBOL(ath10k_bmi_read_memory); 194 195 int ath10k_bmi_write_soc_reg(struct ath10k *ar, u32 address, u32 reg_val) 196 { 197 struct bmi_cmd cmd; 198 u32 cmdlen = sizeof(cmd.id) + sizeof(cmd.write_soc_reg); 199 int ret; 200 201 ath10k_dbg(ar, ATH10K_DBG_BMI, 202 "bmi write soc register 0x%08x val 0x%08x\n", 203 address, reg_val); 204 205 if (ar->bmi.done_sent) { 206 ath10k_warn(ar, "bmi write soc register command in progress\n"); 207 return -EBUSY; 208 } 209 210 cmd.id = __cpu_to_le32(BMI_WRITE_SOC_REGISTER); 211 cmd.write_soc_reg.addr = __cpu_to_le32(address); 212 cmd.write_soc_reg.value = __cpu_to_le32(reg_val); 213 214 ret = ath10k_hif_exchange_bmi_msg(ar, &cmd, cmdlen, NULL, NULL); 215 if (ret) { 216 ath10k_warn(ar, "Unable to write soc register to device: %d\n", 217 ret); 218 return ret; 219 } 220 221 return 0; 222 } 223 224 int ath10k_bmi_read_soc_reg(struct ath10k *ar, u32 address, u32 *reg_val) 225 { 226 struct bmi_cmd cmd; 227 union bmi_resp resp; 228 u32 cmdlen = sizeof(cmd.id) + sizeof(cmd.read_soc_reg); 229 u32 resplen = sizeof(resp.read_soc_reg); 230 int ret; 231 232 ath10k_dbg(ar, ATH10K_DBG_BMI, "bmi read soc register 0x%08x\n", 233 address); 234 235 if (ar->bmi.done_sent) { 236 ath10k_warn(ar, "bmi read soc register command in progress\n"); 237 return -EBUSY; 238 } 239 240 cmd.id = __cpu_to_le32(BMI_READ_SOC_REGISTER); 241 cmd.read_soc_reg.addr = __cpu_to_le32(address); 242 243 ret = ath10k_hif_exchange_bmi_msg(ar, &cmd, cmdlen, &resp, &resplen); 244 if (ret) { 245 ath10k_warn(ar, "Unable to read soc register from device: %d\n", 246 ret); 247 return ret; 248 } 249 250 *reg_val = __le32_to_cpu(resp.read_soc_reg.value); 251 252 ath10k_dbg(ar, ATH10K_DBG_BMI, "bmi read soc register value 0x%08x\n", 253 *reg_val); 254 255 return 0; 256 } 257 258 int ath10k_bmi_write_memory(struct ath10k *ar, 259 u32 address, const void *buffer, u32 length) 260 { 261 struct bmi_cmd cmd; 262 u32 hdrlen = sizeof(cmd.id) + sizeof(cmd.write_mem); 263 u32 txlen; 264 int ret; 265 266 ath10k_dbg(ar, ATH10K_DBG_BMI, "bmi write address 0x%x length %d\n", 267 address, length); 268 269 if (ar->bmi.done_sent) { 270 ath10k_warn(ar, "command disallowed\n"); 271 return -EBUSY; 272 } 273 274 while (length) { 275 txlen = min(length, BMI_MAX_DATA_SIZE - hdrlen); 276 277 /* copy before roundup to avoid reading beyond buffer*/ 278 memcpy(cmd.write_mem.payload, buffer, txlen); 279 txlen = roundup(txlen, 4); 280 281 cmd.id = __cpu_to_le32(BMI_WRITE_MEMORY); 282 cmd.write_mem.addr = __cpu_to_le32(address); 283 cmd.write_mem.len = __cpu_to_le32(txlen); 284 285 ret = ath10k_hif_exchange_bmi_msg(ar, &cmd, hdrlen + txlen, 286 NULL, NULL); 287 if (ret) { 288 ath10k_warn(ar, "unable to write to the device (%d)\n", 289 ret); 290 return ret; 291 } 292 293 /* fixup roundup() so `length` zeroes out for last chunk */ 294 txlen = min(txlen, length); 295 296 address += txlen; 297 buffer += txlen; 298 length -= txlen; 299 } 300 301 return 0; 302 } 303 304 int ath10k_bmi_execute(struct ath10k *ar, u32 address, u32 param, u32 *result) 305 { 306 struct bmi_cmd cmd; 307 union bmi_resp resp; 308 u32 cmdlen = sizeof(cmd.id) + sizeof(cmd.execute); 309 u32 resplen = sizeof(resp.execute); 310 int ret; 311 312 ath10k_dbg(ar, ATH10K_DBG_BMI, "bmi execute address 0x%x param 0x%x\n", 313 address, param); 314 315 if (ar->bmi.done_sent) { 316 ath10k_warn(ar, "command disallowed\n"); 317 return -EBUSY; 318 } 319 320 cmd.id = __cpu_to_le32(BMI_EXECUTE); 321 cmd.execute.addr = __cpu_to_le32(address); 322 cmd.execute.param = __cpu_to_le32(param); 323 324 ret = ath10k_hif_exchange_bmi_msg(ar, &cmd, cmdlen, &resp, &resplen); 325 if (ret) { 326 ath10k_warn(ar, "unable to read from the device\n"); 327 return ret; 328 } 329 330 if (resplen < sizeof(resp.execute)) { 331 ath10k_warn(ar, "invalid execute response length (%d)\n", 332 resplen); 333 return -EIO; 334 } 335 336 *result = __le32_to_cpu(resp.execute.result); 337 338 ath10k_dbg(ar, ATH10K_DBG_BMI, "bmi execute result 0x%x\n", *result); 339 340 return 0; 341 } 342 343 static int ath10k_bmi_lz_data_large(struct ath10k *ar, const void *buffer, u32 length) 344 { 345 struct bmi_cmd *cmd; 346 u32 hdrlen = sizeof(cmd->id) + sizeof(cmd->lz_data); 347 u32 txlen; 348 int ret; 349 size_t buf_len; 350 351 ath10k_dbg(ar, ATH10K_DBG_BMI, "large bmi lz data buffer 0x%pK length %d\n", 352 buffer, length); 353 354 if (ar->bmi.done_sent) { 355 ath10k_warn(ar, "command disallowed\n"); 356 return -EBUSY; 357 } 358 359 buf_len = sizeof(*cmd) + BMI_MAX_LARGE_DATA_SIZE - BMI_MAX_DATA_SIZE; 360 cmd = kzalloc(buf_len, GFP_KERNEL); 361 if (!cmd) 362 return -ENOMEM; 363 364 while (length) { 365 txlen = min(length, BMI_MAX_LARGE_DATA_SIZE - hdrlen); 366 367 WARN_ON_ONCE(txlen & 3); 368 369 cmd->id = __cpu_to_le32(BMI_LZ_DATA); 370 cmd->lz_data.len = __cpu_to_le32(txlen); 371 memcpy(cmd->lz_data.payload, buffer, txlen); 372 373 ret = ath10k_hif_exchange_bmi_msg(ar, cmd, hdrlen + txlen, 374 NULL, NULL); 375 if (ret) { 376 ath10k_warn(ar, "unable to write to the device\n"); 377 kfree(cmd); 378 return ret; 379 } 380 381 buffer += txlen; 382 length -= txlen; 383 } 384 385 kfree(cmd); 386 387 return 0; 388 } 389 390 int ath10k_bmi_lz_data(struct ath10k *ar, const void *buffer, u32 length) 391 { 392 struct bmi_cmd cmd; 393 u32 hdrlen = sizeof(cmd.id) + sizeof(cmd.lz_data); 394 u32 txlen; 395 int ret; 396 397 ath10k_dbg(ar, ATH10K_DBG_BMI, "bmi lz data buffer 0x%pK length %d\n", 398 buffer, length); 399 400 if (ar->bmi.done_sent) { 401 ath10k_warn(ar, "command disallowed\n"); 402 return -EBUSY; 403 } 404 405 while (length) { 406 txlen = min(length, BMI_MAX_DATA_SIZE - hdrlen); 407 408 WARN_ON_ONCE(txlen & 3); 409 410 cmd.id = __cpu_to_le32(BMI_LZ_DATA); 411 cmd.lz_data.len = __cpu_to_le32(txlen); 412 memcpy(cmd.lz_data.payload, buffer, txlen); 413 414 ret = ath10k_hif_exchange_bmi_msg(ar, &cmd, hdrlen + txlen, 415 NULL, NULL); 416 if (ret) { 417 ath10k_warn(ar, "unable to write to the device\n"); 418 return ret; 419 } 420 421 buffer += txlen; 422 length -= txlen; 423 } 424 425 return 0; 426 } 427 428 int ath10k_bmi_lz_stream_start(struct ath10k *ar, u32 address) 429 { 430 struct bmi_cmd cmd; 431 u32 cmdlen = sizeof(cmd.id) + sizeof(cmd.lz_start); 432 int ret; 433 434 ath10k_dbg(ar, ATH10K_DBG_BMI, "bmi lz stream start address 0x%x\n", 435 address); 436 437 if (ar->bmi.done_sent) { 438 ath10k_warn(ar, "command disallowed\n"); 439 return -EBUSY; 440 } 441 442 cmd.id = __cpu_to_le32(BMI_LZ_STREAM_START); 443 cmd.lz_start.addr = __cpu_to_le32(address); 444 445 ret = ath10k_hif_exchange_bmi_msg(ar, &cmd, cmdlen, NULL, NULL); 446 if (ret) { 447 ath10k_warn(ar, "unable to Start LZ Stream to the device\n"); 448 return ret; 449 } 450 451 return 0; 452 } 453 454 int ath10k_bmi_fast_download(struct ath10k *ar, 455 u32 address, const void *buffer, u32 length) 456 { 457 u8 trailer[4] = {}; 458 u32 head_len = rounddown(length, 4); 459 u32 trailer_len = length - head_len; 460 int ret; 461 462 ath10k_dbg(ar, ATH10K_DBG_BMI, 463 "bmi fast download address 0x%x buffer 0x%pK length %d\n", 464 address, buffer, length); 465 466 ret = ath10k_bmi_lz_stream_start(ar, address); 467 if (ret) 468 return ret; 469 470 /* copy the last word into a zero padded buffer */ 471 if (trailer_len > 0) 472 memcpy(trailer, buffer + head_len, trailer_len); 473 474 if (ar->hw_params.bmi_large_size_download) 475 ret = ath10k_bmi_lz_data_large(ar, buffer, head_len); 476 else 477 ret = ath10k_bmi_lz_data(ar, buffer, head_len); 478 479 if (ret) 480 return ret; 481 482 if (trailer_len > 0) 483 ret = ath10k_bmi_lz_data(ar, trailer, 4); 484 485 if (ret != 0) 486 return ret; 487 488 /* 489 * Close compressed stream and open a new (fake) one. 490 * This serves mainly to flush Target caches. 491 */ 492 ret = ath10k_bmi_lz_stream_start(ar, 0x00); 493 494 return ret; 495 } 496 497 int ath10k_bmi_set_start(struct ath10k *ar, u32 address) 498 { 499 struct bmi_cmd cmd; 500 u32 cmdlen = sizeof(cmd.id) + sizeof(cmd.set_app_start); 501 int ret; 502 503 if (ar->bmi.done_sent) { 504 ath10k_warn(ar, "bmi set start command disallowed\n"); 505 return -EBUSY; 506 } 507 508 cmd.id = __cpu_to_le32(BMI_SET_APP_START); 509 cmd.set_app_start.addr = __cpu_to_le32(address); 510 511 ret = ath10k_hif_exchange_bmi_msg(ar, &cmd, cmdlen, NULL, NULL); 512 if (ret) { 513 ath10k_warn(ar, "unable to set start to the device:%d\n", ret); 514 return ret; 515 } 516 517 return 0; 518 } 519