/* * --------------------------------------------------------------------------- * FILE: firmware.c * * PURPOSE: * Implements the f/w related HIP core lib API. * It is part of the porting exercise in Linux. * * Also, it contains example code for reading the loader and f/w files * from the userspace and starting the SME in Linux. * * Copyright (C) 2005-2009 by Cambridge Silicon Radio Ltd. * * Refer to LICENSE.txt included with this source code for details on * the license terms. * * --------------------------------------------------------------------------- */ #include #include #include #include #include "csr_wifi_hip_unifi.h" #include "csr_wifi_hip_unifi_udi.h" #include "unifiio.h" #include "unifi_priv.h" /* * --------------------------------------------------------------------------- * * F/W download. Part of the HIP core API * * --------------------------------------------------------------------------- */ /* * --------------------------------------------------------------------------- * unifi_fw_read_start * * Returns a structure to be passed in unifi_fw_read(). * This structure is an OS specific description of the f/w file. * In the linux implementation it is a buffer with the f/w and its' length. * The HIP driver calls this functions to request for the loader or * the firmware file. * The structure pointer can be freed when unifi_fw_read_stop() is called. * * Arguments: * ospriv Pointer to driver context. * is_fw Type of firmware to retrieve * info Versions information. Can be used to determine * the appropriate f/w file to load. * * Returns: * O on success, non-zero otherwise. * * --------------------------------------------------------------------------- */ void* unifi_fw_read_start(void *ospriv, s8 is_fw, const card_info_t *info) { unifi_priv_t *priv = (unifi_priv_t*)ospriv; CSR_UNUSED(info); if (is_fw == UNIFI_FW_STA) { /* F/w may have been released after a previous successful download. */ if (priv->fw_sta.dl_data == NULL) { unifi_trace(priv, UDBG2, "Attempt reload of sta f/w\n"); uf_request_firmware_files(priv, UNIFI_FW_STA); } /* Set up callback struct for readfunc() */ if (priv->fw_sta.dl_data != NULL) { return &priv->fw_sta; } } else { unifi_error(priv, "downloading firmware... unknown request: %d\n", is_fw); } return NULL; } /* unifi_fw_read_start() */ /* * --------------------------------------------------------------------------- * unifi_fw_read_stop * * Called when the HIP driver has finished using the loader or * the firmware file. * The firmware buffer may be released now. * * Arguments: * ospriv Pointer to driver context. * dlpriv The pointer returned by unifi_fw_read_start() * * --------------------------------------------------------------------------- */ void unifi_fw_read_stop(void *ospriv, void *dlpriv) { unifi_priv_t *priv = (unifi_priv_t*)ospriv; struct dlpriv *dl_struct = (struct dlpriv *)dlpriv; if (dl_struct != NULL) { if (dl_struct->dl_data != NULL) { unifi_trace(priv, UDBG2, "Release f/w buffer %p, %d bytes\n", dl_struct->dl_data, dl_struct->dl_len); } uf_release_firmware(priv, dl_struct); } } /* unifi_fw_read_stop() */ /* * --------------------------------------------------------------------------- * unifi_fw_open_buffer * * Returns a handle for a buffer dynamically allocated by the driver, * e.g. into which a firmware file may have been converted from another format * which is the case with some production test images. * * The handle may then be used by unifi_fw_read() to access the contents of * the buffer. * * Arguments: * ospriv Pointer to driver context. * fwbuf Buffer containing firmware image * len Length of buffer in bytes * * Returns * Handle for buffer, or NULL on error * --------------------------------------------------------------------------- */ void * unifi_fw_open_buffer(void *ospriv, void *fwbuf, u32 len) { unifi_priv_t *priv = (unifi_priv_t*)ospriv; if (fwbuf == NULL) { return NULL; } priv->fw_conv.dl_data = fwbuf; priv->fw_conv.dl_len = len; priv->fw_conv.fw_desc = NULL; /* No OS f/w resource is associated */ return &priv->fw_conv; } /* * --------------------------------------------------------------------------- * unifi_fw_close_buffer * * Releases any handle for a buffer dynamically allocated by the driver, * e.g. into which a firmware file may have been converted from another format * which is the case with some production test images. * * * Arguments: * ospriv Pointer to driver context. * fwbuf Buffer containing firmware image * * Returns * Handle for buffer, or NULL on error * --------------------------------------------------------------------------- */ void unifi_fw_close_buffer(void *ospriv, void *fwbuf) { } /* * --------------------------------------------------------------------------- * unifi_fw_read * * The HIP driver calls this function to ask for a part of the loader or * the firmware file. * * Arguments: * ospriv Pointer to driver context. * arg The pointer returned by unifi_fw_read_start(). * offset The offset in the file to return from. * buf A buffer to store the requested data. * len The size of the buf and the size of the requested data. * * Returns * The number of bytes read from the firmware image, or -ve on error * --------------------------------------------------------------------------- */ s32 unifi_fw_read(void *ospriv, void *arg, u32 offset, void *buf, u32 len) { const struct dlpriv *dlpriv = arg; if (offset >= dlpriv->dl_len) { /* at end of file */ return 0; } if ((offset + len) > dlpriv->dl_len) { /* attempt to read past end of file */ return -1; } memcpy(buf, dlpriv->dl_data+offset, len); return len; } /* unifi_fw_read() */ #define UNIFIHELPER_INIT_MODE_SMEUSER 2 #define UNIFIHELPER_INIT_MODE_NATIVE 1 /* * --------------------------------------------------------------------------- * uf_run_unifihelper * * Ask userspace to send us firmware for download by running * '/usr/sbin/unififw'. * The same script starts the SME userspace application. * Derived from net_run_sbin_hotplug(). * * Arguments: * priv Pointer to OS private struct. * * Returns: * None. * --------------------------------------------------------------------------- */ int uf_run_unifihelper(unifi_priv_t *priv) { #ifdef ANDROID_BUILD char *prog = "/system/bin/unififw"; #else char *prog = "/usr/sbin/unififw"; #endif /* ANDROID_BUILD */ char *argv[6], *envp[4]; char inst_str[8]; char init_mode[8]; int i, r; #if (defined CSR_SME_USERSPACE) && (!defined CSR_SUPPORT_WEXT) unifi_trace(priv, UDBG1, "SME userspace build: run unifi_helper manually\n"); return 0; #endif unifi_trace(priv, UDBG1, "starting %s\n", prog); snprintf(inst_str, 8, "%d", priv->instance); #if (defined CSR_SME_USERSPACE) snprintf(init_mode, 8, "%d", UNIFIHELPER_INIT_MODE_SMEUSER); #else snprintf(init_mode, 8, "%d", UNIFIHELPER_INIT_MODE_NATIVE); #endif /* CSR_SME_USERSPACE */ i = 0; argv[i++] = prog; argv[i++] = inst_str; argv[i++] = init_mode; argv[i++] = 0; argv[i] = 0; /* Don't add more args without making argv bigger */ /* minimal command environment */ i = 0; envp[i++] = "HOME=/"; envp[i++] = "PATH=/sbin:/bin:/usr/sbin:/usr/bin"; envp[i] = 0; /* Don't add more without making envp bigger */ unifi_trace(priv, UDBG2, "running %s %s %s\n", argv[0], argv[1], argv[2]); r = call_usermodehelper(argv[0], argv, envp, UMH_WAIT_EXEC); return r; } /* uf_run_unifihelper() */ #ifdef CSR_WIFI_SPLIT_PATCH static u8 is_ap_mode(unifi_priv_t *priv) { if (priv == NULL || priv->interfacePriv[0] == NULL) { return FALSE; } /* Test for mode requiring AP patch */ return(CSR_WIFI_HIP_IS_AP_FW(priv->interfacePriv[0]->interfaceMode)); } #endif /* * --------------------------------------------------------------------------- * uf_request_firmware_files * * Get the firmware files from userspace. * * Arguments: * priv Pointer to OS private struct. * is_fw type of firmware to load (UNIFI_FW_STA/LOADER) * * Returns: * None. * --------------------------------------------------------------------------- */ int uf_request_firmware_files(unifi_priv_t *priv, int is_fw) { /* uses the default method to get the firmware */ const struct firmware *fw_entry; int postfix; #define UNIFI_MAX_FW_PATH_LEN 32 char fw_name[UNIFI_MAX_FW_PATH_LEN]; int r; #if (defined CSR_SUPPORT_SME) && (defined CSR_SUPPORT_WEXT) if (priv->mib_data.length) { vfree(priv->mib_data.data); priv->mib_data.data = NULL; priv->mib_data.length = 0; } #endif /* CSR_SUPPORT_SME && CSR_SUPPORT_WEXT*/ postfix = priv->instance; if (is_fw == UNIFI_FW_STA) { /* Free kernel buffer and reload */ uf_release_firmware(priv, &priv->fw_sta); #ifdef CSR_WIFI_SPLIT_PATCH scnprintf(fw_name, UNIFI_MAX_FW_PATH_LEN, "unifi-sdio-%d/%s", postfix, (is_ap_mode(priv) ? "ap.xbv" : "staonly.xbv") ); #else scnprintf(fw_name, UNIFI_MAX_FW_PATH_LEN, "unifi-sdio-%d/%s", postfix, "sta.xbv" ); #endif r = request_firmware(&fw_entry, fw_name, priv->unifi_device); if (r == 0) { priv->fw_sta.dl_data = fw_entry->data; priv->fw_sta.dl_len = fw_entry->size; priv->fw_sta.fw_desc = (void *)fw_entry; } else { unifi_trace(priv, UDBG2, "Firmware file not available\n"); } } return 0; } /* uf_request_firmware_files() */ /* * --------------------------------------------------------------------------- * uf_release_firmware_files * * Release all buffers used to store firmware files * * Arguments: * priv Pointer to OS private struct. * * Returns: * None. * --------------------------------------------------------------------------- */ int uf_release_firmware_files(unifi_priv_t *priv) { uf_release_firmware(priv, &priv->fw_sta); return 0; } /* * --------------------------------------------------------------------------- * uf_release_firmware * * Release specific buffer used to store firmware * * Arguments: * priv Pointer to OS private struct. * to_free Pointer to specific buffer to release * * Returns: * None. * --------------------------------------------------------------------------- */ int uf_release_firmware(unifi_priv_t *priv, struct dlpriv *to_free) { if (to_free != NULL) { release_firmware((const struct firmware *)to_free->fw_desc); to_free->fw_desc = NULL; to_free->dl_data = NULL; to_free->dl_len = 0; } return 0; }