| /* |
| * *************************************************************************** |
| * FILE: putest.c |
| * |
| * PURPOSE: putest related functions. |
| * |
| * Copyright (C) 2008-2009 by Cambridge Silicon Radio Ltd. |
| * |
| * Refer to LICENSE.txt included with this source code for details on |
| * the license terms. |
| * |
| * *************************************************************************** |
| */ |
| |
| #include <linux/vmalloc.h> |
| #include <linux/firmware.h> |
| |
| #include "unifi_priv.h" |
| #include "csr_wifi_hip_chiphelper.h" |
| |
| #define UNIFI_PROC_BOTH 3 |
| |
| |
| int unifi_putest_cmd52_read(unifi_priv_t *priv, unsigned char *arg) |
| { |
| struct unifi_putest_cmd52 cmd52_params; |
| u8 *arg_pos; |
| unsigned int cmd_param_size; |
| int r; |
| CsrResult csrResult; |
| unsigned char ret_buffer[32]; |
| u8 *ret_buffer_pos; |
| u8 retries; |
| |
| arg_pos = (u8*)(((unifi_putest_command_t*)arg) + 1); |
| if (get_user(cmd_param_size, (int*)arg_pos)) { |
| unifi_error(priv, |
| "unifi_putest_cmd52_read: Failed to get the argument\n"); |
| return -EFAULT; |
| } |
| |
| if (cmd_param_size != sizeof(struct unifi_putest_cmd52)) { |
| unifi_error(priv, |
| "unifi_putest_cmd52_read: cmd52 struct mismatch\n"); |
| return -EINVAL; |
| } |
| |
| arg_pos += sizeof(unsigned int); |
| if (copy_from_user(&cmd52_params, |
| (void*)arg_pos, |
| sizeof(struct unifi_putest_cmd52))) { |
| unifi_error(priv, |
| "unifi_putest_cmd52_read: Failed to get the cmd52 params\n"); |
| return -EFAULT; |
| } |
| |
| unifi_trace(priv, UDBG2, "cmd52r: func=%d addr=0x%x ", |
| cmd52_params.funcnum, cmd52_params.addr); |
| |
| retries = 3; |
| CsrSdioClaim(priv->sdio); |
| do { |
| if (cmd52_params.funcnum == 0) { |
| csrResult = CsrSdioF0Read8(priv->sdio, cmd52_params.addr, &cmd52_params.data); |
| } else { |
| csrResult = CsrSdioRead8(priv->sdio, cmd52_params.addr, &cmd52_params.data); |
| } |
| } while (--retries && ((csrResult == CSR_SDIO_RESULT_CRC_ERROR) || (csrResult == CSR_SDIO_RESULT_TIMEOUT))); |
| CsrSdioRelease(priv->sdio); |
| |
| if (csrResult != CSR_RESULT_SUCCESS) { |
| unifi_error(priv, |
| "\nunifi_putest_cmd52_read: Read8() failed (csrResult=0x%x)\n", csrResult); |
| return -EFAULT; |
| } |
| unifi_trace(priv, UDBG2, "data=%d\n", cmd52_params.data); |
| |
| /* Copy the info to the out buffer */ |
| *(unifi_putest_command_t*)ret_buffer = UNIFI_PUTEST_CMD52_READ; |
| ret_buffer_pos = (u8*)(((unifi_putest_command_t*)ret_buffer) + 1); |
| *(unsigned int*)ret_buffer_pos = sizeof(struct unifi_putest_cmd52); |
| ret_buffer_pos += sizeof(unsigned int); |
| memcpy(ret_buffer_pos, &cmd52_params, sizeof(struct unifi_putest_cmd52)); |
| ret_buffer_pos += sizeof(struct unifi_putest_cmd52); |
| |
| r = copy_to_user((void*)arg, |
| ret_buffer, |
| ret_buffer_pos - ret_buffer); |
| if (r) { |
| unifi_error(priv, |
| "unifi_putest_cmd52_read: Failed to return the data\n"); |
| return -EFAULT; |
| } |
| |
| return 0; |
| } |
| |
| |
| int unifi_putest_cmd52_write(unifi_priv_t *priv, unsigned char *arg) |
| { |
| struct unifi_putest_cmd52 cmd52_params; |
| u8 *arg_pos; |
| unsigned int cmd_param_size; |
| CsrResult csrResult; |
| u8 retries; |
| |
| arg_pos = (u8*)(((unifi_putest_command_t*)arg) + 1); |
| if (get_user(cmd_param_size, (int*)arg_pos)) { |
| unifi_error(priv, |
| "unifi_putest_cmd52_write: Failed to get the argument\n"); |
| return -EFAULT; |
| } |
| |
| if (cmd_param_size != sizeof(struct unifi_putest_cmd52)) { |
| unifi_error(priv, |
| "unifi_putest_cmd52_write: cmd52 struct mismatch\n"); |
| return -EINVAL; |
| } |
| |
| arg_pos += sizeof(unsigned int); |
| if (copy_from_user(&cmd52_params, |
| (void*)(arg_pos), |
| sizeof(struct unifi_putest_cmd52))) { |
| unifi_error(priv, |
| "unifi_putest_cmd52_write: Failed to get the cmd52 params\n"); |
| return -EFAULT; |
| } |
| |
| unifi_trace(priv, UDBG2, "cmd52w: func=%d addr=0x%x data=%d\n", |
| cmd52_params.funcnum, cmd52_params.addr, cmd52_params.data); |
| |
| retries = 3; |
| CsrSdioClaim(priv->sdio); |
| do { |
| if (cmd52_params.funcnum == 0) { |
| csrResult = CsrSdioF0Write8(priv->sdio, cmd52_params.addr, cmd52_params.data); |
| } else { |
| csrResult = CsrSdioWrite8(priv->sdio, cmd52_params.addr, cmd52_params.data); |
| } |
| } while (--retries && ((csrResult == CSR_SDIO_RESULT_CRC_ERROR) || (csrResult == CSR_SDIO_RESULT_TIMEOUT))); |
| CsrSdioRelease(priv->sdio); |
| |
| if (csrResult != CSR_RESULT_SUCCESS) { |
| unifi_error(priv, |
| "unifi_putest_cmd52_write: Write8() failed (csrResult=0x%x)\n", csrResult); |
| return -EFAULT; |
| } |
| |
| return 0; |
| } |
| |
| int unifi_putest_gp_read16(unifi_priv_t *priv, unsigned char *arg) |
| { |
| struct unifi_putest_gp_rw16 gp_r16_params; |
| u8 *arg_pos; |
| unsigned int cmd_param_size; |
| int r; |
| CsrResult csrResult; |
| unsigned char ret_buffer[32]; |
| u8 *ret_buffer_pos; |
| |
| arg_pos = (u8*)(((unifi_putest_command_t*)arg) + 1); |
| if (get_user(cmd_param_size, (int*)arg_pos)) { |
| unifi_error(priv, |
| "unifi_putest_gp_read16: Failed to get the argument\n"); |
| return -EFAULT; |
| } |
| |
| if (cmd_param_size != sizeof(struct unifi_putest_gp_rw16)) { |
| unifi_error(priv, |
| "unifi_putest_gp_read16: struct mismatch\n"); |
| return -EINVAL; |
| } |
| |
| arg_pos += sizeof(unsigned int); |
| if (copy_from_user(&gp_r16_params, |
| (void*)arg_pos, |
| sizeof(struct unifi_putest_gp_rw16))) { |
| unifi_error(priv, |
| "unifi_putest_gp_read16: Failed to get the params\n"); |
| return -EFAULT; |
| } |
| CsrSdioClaim(priv->sdio); |
| csrResult = unifi_card_read16(priv->card, gp_r16_params.addr, &gp_r16_params.data); |
| CsrSdioRelease(priv->sdio); |
| if (csrResult != CSR_RESULT_SUCCESS) { |
| unifi_error(priv, |
| "unifi_putest_gp_read16: unifi_card_read16() GP=0x%x failed (csrResult=0x%x)\n", gp_r16_params.addr, csrResult); |
| return -EFAULT; |
| } |
| |
| unifi_trace(priv, UDBG2, "gp_r16: GP=0x%08x, data=0x%04x\n", gp_r16_params.addr, gp_r16_params.data); |
| |
| /* Copy the info to the out buffer */ |
| *(unifi_putest_command_t*)ret_buffer = UNIFI_PUTEST_GP_READ16; |
| ret_buffer_pos = (u8*)(((unifi_putest_command_t*)ret_buffer) + 1); |
| *(unsigned int*)ret_buffer_pos = sizeof(struct unifi_putest_gp_rw16); |
| ret_buffer_pos += sizeof(unsigned int); |
| memcpy(ret_buffer_pos, &gp_r16_params, sizeof(struct unifi_putest_gp_rw16)); |
| ret_buffer_pos += sizeof(struct unifi_putest_gp_rw16); |
| |
| r = copy_to_user((void*)arg, |
| ret_buffer, |
| ret_buffer_pos - ret_buffer); |
| if (r) { |
| unifi_error(priv, |
| "unifi_putest_gp_read16: Failed to return the data\n"); |
| return -EFAULT; |
| } |
| |
| return 0; |
| } |
| |
| int unifi_putest_gp_write16(unifi_priv_t *priv, unsigned char *arg) |
| { |
| struct unifi_putest_gp_rw16 gp_w16_params; |
| u8 *arg_pos; |
| unsigned int cmd_param_size; |
| CsrResult csrResult; |
| |
| arg_pos = (u8*)(((unifi_putest_command_t*)arg) + 1); |
| if (get_user(cmd_param_size, (int*)arg_pos)) { |
| unifi_error(priv, |
| "unifi_putest_gp_write16: Failed to get the argument\n"); |
| return -EFAULT; |
| } |
| |
| if (cmd_param_size != sizeof(struct unifi_putest_gp_rw16)) { |
| unifi_error(priv, |
| "unifi_putest_gp_write16: struct mismatch\n"); |
| return -EINVAL; |
| } |
| |
| arg_pos += sizeof(unsigned int); |
| if (copy_from_user(&gp_w16_params, |
| (void*)(arg_pos), |
| sizeof(struct unifi_putest_gp_rw16))) { |
| unifi_error(priv, |
| "unifi_putest_gp_write16: Failed to get the params\n"); |
| return -EFAULT; |
| } |
| |
| unifi_trace(priv, UDBG2, "gp_w16: GP=0x%08x, data=0x%04x\n", gp_w16_params.addr, gp_w16_params.data); |
| CsrSdioClaim(priv->sdio); |
| csrResult = unifi_card_write16(priv->card, gp_w16_params.addr, gp_w16_params.data); |
| CsrSdioRelease(priv->sdio); |
| if (csrResult != CSR_RESULT_SUCCESS) { |
| unifi_error(priv, |
| "unifi_putest_gp_write16: unifi_card_write16() GP=%x failed (csrResult=0x%x)\n", gp_w16_params.addr, csrResult); |
| return -EFAULT; |
| } |
| |
| return 0; |
| } |
| |
| int unifi_putest_set_sdio_clock(unifi_priv_t *priv, unsigned char *arg) |
| { |
| int sdio_clock_speed; |
| CsrResult csrResult; |
| |
| if (get_user(sdio_clock_speed, (int*)(((unifi_putest_command_t*)arg) + 1))) { |
| unifi_error(priv, |
| "unifi_putest_set_sdio_clock: Failed to get the argument\n"); |
| return -EFAULT; |
| } |
| |
| unifi_trace(priv, UDBG2, "set sdio clock: %d KHz\n", sdio_clock_speed); |
| |
| CsrSdioClaim(priv->sdio); |
| csrResult = CsrSdioMaxBusClockFrequencySet(priv->sdio, sdio_clock_speed * 1000); |
| CsrSdioRelease(priv->sdio); |
| if (csrResult != CSR_RESULT_SUCCESS) { |
| unifi_error(priv, |
| "unifi_putest_set_sdio_clock: Set clock failed (csrResult=0x%x)\n", csrResult); |
| return -EFAULT; |
| } |
| |
| return 0; |
| } |
| |
| |
| int unifi_putest_start(unifi_priv_t *priv, unsigned char *arg) |
| { |
| int r; |
| CsrResult csrResult; |
| int already_in_test = priv->ptest_mode; |
| |
| /* Ensure that sme_sys_suspend() doesn't power down the chip because: |
| * 1) Power is needed anyway for ptest. |
| * 2) The app code uses the START ioctl as a reset, so it gets called |
| * multiple times. If the app stops the XAPs, but the power_down/up |
| * sequence doesn't actually power down the chip, there can be problems |
| * resetting, because part of the power_up sequence disables function 1 |
| */ |
| priv->ptest_mode = 1; |
| |
| /* Suspend the SME and UniFi */ |
| if (priv->sme_cli) { |
| r = sme_sys_suspend(priv); |
| if (r) { |
| unifi_error(priv, |
| "unifi_putest_start: failed to suspend UniFi\n"); |
| return r; |
| } |
| } |
| |
| /* Application may have stopped the XAPs, but they are needed for reset */ |
| if (already_in_test) { |
| CsrSdioClaim(priv->sdio); |
| csrResult = unifi_start_processors(priv->card); |
| CsrSdioRelease(priv->sdio); |
| if (csrResult != CSR_RESULT_SUCCESS) { |
| unifi_error(priv, "Failed to start XAPs. Hard reset required.\n"); |
| } |
| } else { |
| /* Ensure chip is powered for the case where there's no unifi_helper */ |
| CsrSdioClaim(priv->sdio); |
| csrResult = CsrSdioPowerOn(priv->sdio); |
| CsrSdioRelease(priv->sdio); |
| if (csrResult != CSR_RESULT_SUCCESS) { |
| unifi_error(priv, "CsrSdioPowerOn csrResult = %d\n", csrResult); |
| } |
| } |
| CsrSdioClaim(priv->sdio); |
| csrResult = unifi_init(priv->card); |
| CsrSdioRelease(priv->sdio); |
| if (csrResult != CSR_RESULT_SUCCESS) { |
| unifi_error(priv, |
| "unifi_putest_start: failed to init UniFi\n"); |
| return CsrHipResultToStatus(csrResult); |
| } |
| |
| return 0; |
| } |
| |
| |
| int unifi_putest_stop(unifi_priv_t *priv, unsigned char *arg) |
| { |
| int r = 0; |
| CsrResult csrResult; |
| |
| /* Application may have stopped the XAPs, but they are needed for reset */ |
| CsrSdioClaim(priv->sdio); |
| csrResult = unifi_start_processors(priv->card); |
| CsrSdioRelease(priv->sdio); |
| if (csrResult != CSR_RESULT_SUCCESS) { |
| unifi_error(priv, "Failed to start XAPs. Hard reset required.\n"); |
| } |
| |
| /* PUTEST_STOP is also used to resume the XAPs after SME coredump. |
| * Don't power off the chip, leave that to the normal wifi-off which is |
| * about to carry on. No need to resume the SME either, as it wasn't suspended. |
| */ |
| if (priv->coredump_mode) { |
| priv->coredump_mode = 0; |
| return 0; |
| } |
| |
| /* At this point function 1 is enabled and the XAPs are running, so it is |
| * safe to let the card power down. Power is restored later, asynchronously, |
| * during the wifi_on requested by the SME. |
| */ |
| CsrSdioClaim(priv->sdio); |
| CsrSdioPowerOff(priv->sdio); |
| CsrSdioRelease(priv->sdio); |
| |
| /* Resume the SME and UniFi */ |
| if (priv->sme_cli) { |
| r = sme_sys_resume(priv); |
| if (r) { |
| unifi_error(priv, |
| "unifi_putest_stop: failed to resume SME\n"); |
| } |
| } |
| priv->ptest_mode = 0; |
| |
| return r; |
| } |
| |
| |
| int unifi_putest_dl_fw(unifi_priv_t *priv, unsigned char *arg) |
| { |
| #define UF_PUTEST_MAX_FW_FILE_NAME 16 |
| #define UNIFI_MAX_FW_PATH_LEN 32 |
| unsigned int fw_name_length; |
| unsigned char fw_name[UF_PUTEST_MAX_FW_FILE_NAME+1]; |
| unsigned char *name_buffer; |
| int postfix; |
| char fw_path[UNIFI_MAX_FW_PATH_LEN]; |
| const struct firmware *fw_entry; |
| struct dlpriv temp_fw_sta; |
| int r; |
| CsrResult csrResult; |
| |
| /* Get the f/w file name length */ |
| if (get_user(fw_name_length, (unsigned int*)(((unifi_putest_command_t*)arg) + 1))) { |
| unifi_error(priv, |
| "unifi_putest_dl_fw: Failed to get the length argument\n"); |
| return -EFAULT; |
| } |
| |
| unifi_trace(priv, UDBG2, "unifi_putest_dl_fw: file name size = %d\n", fw_name_length); |
| |
| /* Sanity check for the f/w file name length */ |
| if (fw_name_length > UF_PUTEST_MAX_FW_FILE_NAME) { |
| unifi_error(priv, |
| "unifi_putest_dl_fw: F/W file name is too long\n"); |
| return -EINVAL; |
| } |
| |
| /* Get the f/w file name */ |
| name_buffer = ((unsigned char*)arg) + sizeof(unifi_putest_command_t) + sizeof(unsigned int); |
| if (copy_from_user(fw_name, (void*)name_buffer, fw_name_length)) { |
| unifi_error(priv, "unifi_putest_dl_fw: Failed to get the file name\n"); |
| return -EFAULT; |
| } |
| fw_name[fw_name_length] = '\0'; |
| unifi_trace(priv, UDBG2, "unifi_putest_dl_fw: file = %s\n", fw_name); |
| |
| /* Keep the existing f/w to a temp, we need to restore it later */ |
| temp_fw_sta = priv->fw_sta; |
| |
| /* Get the putest f/w */ |
| postfix = priv->instance; |
| scnprintf(fw_path, UNIFI_MAX_FW_PATH_LEN, "unifi-sdio-%d/%s", |
| postfix, fw_name); |
| r = request_firmware(&fw_entry, fw_path, priv->unifi_device); |
| if (r == 0) { |
| priv->fw_sta.fw_desc = (void *)fw_entry; |
| priv->fw_sta.dl_data = fw_entry->data; |
| priv->fw_sta.dl_len = fw_entry->size; |
| } else { |
| unifi_error(priv, "Firmware file not available\n"); |
| return -EINVAL; |
| } |
| |
| /* Application may have stopped the XAPs, but they are needed for reset */ |
| CsrSdioClaim(priv->sdio); |
| csrResult = unifi_start_processors(priv->card); |
| CsrSdioRelease(priv->sdio); |
| if (csrResult != CSR_RESULT_SUCCESS) { |
| unifi_error(priv, "Failed to start XAPs. Hard reset required.\n"); |
| } |
| |
| /* Download the f/w. On UF6xxx this will cause the f/w file to convert |
| * into patch format and download via the ROM boot loader |
| */ |
| CsrSdioClaim(priv->sdio); |
| csrResult = unifi_download(priv->card, 0x0c00); |
| CsrSdioRelease(priv->sdio); |
| if (csrResult != CSR_RESULT_SUCCESS) { |
| unifi_error(priv, |
| "unifi_putest_dl_fw: failed to download the f/w\n"); |
| goto free_fw; |
| } |
| |
| /* Free the putest f/w... */ |
| free_fw: |
| uf_release_firmware(priv, &priv->fw_sta); |
| /* ... and restore the original f/w */ |
| priv->fw_sta = temp_fw_sta; |
| |
| return CsrHipResultToStatus(csrResult); |
| } |
| |
| |
| int unifi_putest_dl_fw_buff(unifi_priv_t *priv, unsigned char *arg) |
| { |
| unsigned int fw_length; |
| unsigned char *fw_buf = NULL; |
| unsigned char *fw_user_ptr; |
| struct dlpriv temp_fw_sta; |
| CsrResult csrResult; |
| |
| /* Get the f/w buffer length */ |
| if (get_user(fw_length, (unsigned int*)(((unifi_putest_command_t*)arg) + 1))) { |
| unifi_error(priv, |
| "unifi_putest_dl_fw_buff: Failed to get the length arg\n"); |
| return -EFAULT; |
| } |
| |
| unifi_trace(priv, UDBG2, "unifi_putest_dl_fw_buff: size = %d\n", fw_length); |
| |
| /* Sanity check for the buffer length */ |
| if (fw_length == 0 || fw_length > 0xfffffff) { |
| unifi_error(priv, |
| "unifi_putest_dl_fw_buff: buffer length bad %u\n", fw_length); |
| return -EINVAL; |
| } |
| |
| /* Buffer for kernel copy of the f/w image */ |
| fw_buf = kmalloc(fw_length, GFP_KERNEL); |
| if (!fw_buf) { |
| unifi_error(priv, "unifi_putest_dl_fw_buff: malloc fail\n"); |
| return -ENOMEM; |
| } |
| |
| /* Get the f/w image */ |
| fw_user_ptr = ((unsigned char*)arg) + sizeof(unifi_putest_command_t) + sizeof(unsigned int); |
| if (copy_from_user(fw_buf, (void*)fw_user_ptr, fw_length)) { |
| unifi_error(priv, "unifi_putest_dl_fw_buff: Failed to get the buffer\n"); |
| kfree(fw_buf); |
| return -EFAULT; |
| } |
| |
| /* Save the existing f/w to a temp, we need to restore it later */ |
| temp_fw_sta = priv->fw_sta; |
| |
| /* Setting fw_desc NULL indicates to the core that no f/w file was loaded |
| * via the kernel request_firmware() mechanism. This indicates to the core |
| * that it shouldn't call release_firmware() after the download is done. |
| */ |
| priv->fw_sta.fw_desc = NULL; /* No OS f/w resource */ |
| priv->fw_sta.dl_data = fw_buf; |
| priv->fw_sta.dl_len = fw_length; |
| |
| /* Application may have stopped the XAPs, but they are needed for reset */ |
| CsrSdioClaim(priv->sdio); |
| csrResult = unifi_start_processors(priv->card); |
| CsrSdioRelease(priv->sdio); |
| if (csrResult != CSR_RESULT_SUCCESS) { |
| unifi_error(priv, "Failed to start XAPs. Hard reset required.\n"); |
| } |
| |
| /* Download the f/w. On UF6xxx this will cause the f/w file to convert |
| * into patch format and download via the ROM boot loader |
| */ |
| CsrSdioClaim(priv->sdio); |
| csrResult = unifi_download(priv->card, 0x0c00); |
| CsrSdioRelease(priv->sdio); |
| if (csrResult != CSR_RESULT_SUCCESS) { |
| unifi_error(priv, |
| "unifi_putest_dl_fw_buff: failed to download the f/w\n"); |
| goto free_fw; |
| } |
| |
| free_fw: |
| /* Finished with the putest f/w, so restore the station f/w */ |
| priv->fw_sta = temp_fw_sta; |
| kfree(fw_buf); |
| |
| return CsrHipResultToStatus(csrResult); |
| } |
| |
| |
| int unifi_putest_coredump_prepare(unifi_priv_t *priv, unsigned char *arg) |
| { |
| u16 data_u16; |
| s32 i; |
| CsrResult r; |
| |
| unifi_info(priv, "Preparing for SDIO coredump\n"); |
| #if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) |
| unifi_debug_buf_dump(); |
| #endif |
| |
| /* Sanity check that userspace hasn't called a PUTEST_START, because that |
| * would have reset UniFi, potentially power cycling it and losing context |
| */ |
| if (priv->ptest_mode) { |
| unifi_error(priv, "PUTEST_START shouldn't be used before a coredump\n"); |
| } |
| |
| /* Flag that the userspace has requested coredump. Even if this preparation |
| * fails, the SME will call PUTEST_STOP to tidy up. |
| */ |
| priv->coredump_mode = 1; |
| |
| for (i = 0; i < 3; i++) { |
| CsrSdioClaim(priv->sdio); |
| r = CsrSdioRead16(priv->sdio, CHIP_HELPER_UNIFI_GBL_CHIP_VERSION*2, &data_u16); |
| CsrSdioRelease(priv->sdio); |
| if (r != CSR_RESULT_SUCCESS) { |
| unifi_info(priv, "Failed to read chip version! Try %d\n", i); |
| |
| /* First try, re-enable function which may have been disabled by f/w panic */ |
| if (i == 0) { |
| unifi_info(priv, "Try function enable\n"); |
| CsrSdioClaim(priv->sdio); |
| r = CsrSdioFunctionEnable(priv->sdio); |
| CsrSdioRelease(priv->sdio); |
| if (r != CSR_RESULT_SUCCESS) { |
| unifi_error(priv, "CsrSdioFunctionEnable failed %d\n", r); |
| } |
| continue; |
| } |
| |
| /* Subsequent tries, reset */ |
| |
| /* Set clock speed low */ |
| CsrSdioClaim(priv->sdio); |
| r = CsrSdioMaxBusClockFrequencySet(priv->sdio, UNIFI_SDIO_CLOCK_SAFE_HZ); |
| CsrSdioRelease(priv->sdio); |
| if (r != CSR_RESULT_SUCCESS) { |
| unifi_error(priv, "CsrSdioMaxBusClockFrequencySet() failed %d\n", r); |
| } |
| |
| /* Card software reset */ |
| CsrSdioClaim(priv->sdio); |
| r = unifi_card_hard_reset(priv->card); |
| CsrSdioRelease(priv->sdio); |
| if (r != CSR_RESULT_SUCCESS) { |
| unifi_error(priv, "unifi_card_hard_reset() failed %d\n", r); |
| } |
| } else { |
| unifi_info(priv, "Read chip version of 0x%04x\n", data_u16); |
| break; |
| } |
| } |
| |
| if (r != CSR_RESULT_SUCCESS) { |
| unifi_error(priv, "Failed to prepare chip\n"); |
| return -EIO; |
| } |
| |
| /* Stop the XAPs for coredump. The PUTEST_STOP must be called, e.g. at |
| * Raw SDIO deinit, to resume them. |
| */ |
| CsrSdioClaim(priv->sdio); |
| r = unifi_card_stop_processor(priv->card, UNIFI_PROC_BOTH); |
| CsrSdioRelease(priv->sdio); |
| if (r != CSR_RESULT_SUCCESS) { |
| unifi_error(priv, "Failed to stop processors\n"); |
| } |
| |
| return 0; |
| } |
| |
| int unifi_putest_cmd52_block_read(unifi_priv_t *priv, unsigned char *arg) |
| { |
| struct unifi_putest_block_cmd52_r block_cmd52; |
| u8 *arg_pos; |
| unsigned int cmd_param_size; |
| CsrResult r; |
| u8 *block_local_buffer; |
| |
| arg_pos = (u8*)(((unifi_putest_command_t*)arg) + 1); |
| if (get_user(cmd_param_size, (int*)arg_pos)) { |
| unifi_error(priv, |
| "cmd52r_block: Failed to get the argument\n"); |
| return -EFAULT; |
| } |
| |
| if (cmd_param_size != sizeof(struct unifi_putest_block_cmd52_r)) { |
| unifi_error(priv, |
| "cmd52r_block: cmd52 struct mismatch\n"); |
| return -EINVAL; |
| } |
| |
| arg_pos += sizeof(unsigned int); |
| if (copy_from_user(&block_cmd52, |
| (void*)arg_pos, |
| sizeof(struct unifi_putest_block_cmd52_r))) { |
| unifi_error(priv, |
| "cmd52r_block: Failed to get the cmd52 params\n"); |
| return -EFAULT; |
| } |
| |
| unifi_trace(priv, UDBG2, "cmd52r_block: func=%d addr=0x%x len=0x%x ", |
| block_cmd52.funcnum, block_cmd52.addr, block_cmd52.length); |
| |
| block_local_buffer = vmalloc(block_cmd52.length); |
| if (block_local_buffer == NULL) { |
| unifi_error(priv, "cmd52r_block: Failed to allocate buffer\n"); |
| return -ENOMEM; |
| } |
| |
| CsrSdioClaim(priv->sdio); |
| r = unifi_card_readn(priv->card, block_cmd52.addr, block_local_buffer, block_cmd52.length); |
| CsrSdioRelease(priv->sdio); |
| if (r != CSR_RESULT_SUCCESS) { |
| unifi_error(priv, "cmd52r_block: unifi_readn failed\n"); |
| return -EIO; |
| } |
| |
| if (copy_to_user((void*)block_cmd52.data, |
| block_local_buffer, |
| block_cmd52.length)) { |
| unifi_error(priv, |
| "cmd52r_block: Failed to return the data\n"); |
| return -EFAULT; |
| } |
| |
| return 0; |
| } |
