mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-09-19 17:11:03 +00:00
89fa037b82
Fix "Missing blank line after declaration" warnings reported by checkpatch.pl. Signed-off-by: Pawel Lebioda <pawel.lebioda89@gmail.com> Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
317 lines
7.3 KiB
C
317 lines
7.3 KiB
C
#include "headers.h"
|
|
|
|
int InterfaceFileDownload(PVOID arg, struct file *flp, unsigned int on_chip_loc)
|
|
{
|
|
/* unsigned int reg = 0; */
|
|
mm_segment_t oldfs = {0};
|
|
int errno = 0, len = 0; /* ,is_config_file = 0 */
|
|
loff_t pos = 0;
|
|
struct bcm_interface_adapter *psIntfAdapter = arg;
|
|
/* struct bcm_mini_adapter *Adapter = psIntfAdapter->psAdapter; */
|
|
char *buff = kmalloc(MAX_TRANSFER_CTRL_BYTE_USB, GFP_KERNEL);
|
|
|
|
if (!buff)
|
|
return -ENOMEM;
|
|
|
|
while (1) {
|
|
oldfs = get_fs();
|
|
set_fs(get_ds());
|
|
len = vfs_read(flp, (void __force __user *)buff,
|
|
MAX_TRANSFER_CTRL_BYTE_USB, &pos);
|
|
set_fs(oldfs);
|
|
if (len <= 0) {
|
|
if (len < 0)
|
|
errno = len;
|
|
else
|
|
errno = 0;
|
|
break;
|
|
}
|
|
/* BCM_DEBUG_PRINT_BUFFER(Adapter,DBG_TYPE_INITEXIT, MP_INIT,
|
|
* DBG_LVL_ALL, buff,
|
|
* MAX_TRANSFER_CTRL_BYTE_USB);
|
|
*/
|
|
errno = InterfaceWRM(psIntfAdapter, on_chip_loc, buff, len);
|
|
if (errno)
|
|
break;
|
|
on_chip_loc += MAX_TRANSFER_CTRL_BYTE_USB;
|
|
}
|
|
|
|
kfree(buff);
|
|
return errno;
|
|
}
|
|
|
|
int InterfaceFileReadbackFromChip(PVOID arg, struct file *flp,
|
|
unsigned int on_chip_loc)
|
|
{
|
|
char *buff, *buff_readback;
|
|
unsigned int reg = 0;
|
|
mm_segment_t oldfs = {0};
|
|
int errno = 0, len = 0, is_config_file = 0;
|
|
loff_t pos = 0;
|
|
static int fw_down;
|
|
INT Status = STATUS_SUCCESS;
|
|
struct bcm_interface_adapter *psIntfAdapter = arg;
|
|
int bytes;
|
|
|
|
buff = kzalloc(MAX_TRANSFER_CTRL_BYTE_USB, GFP_DMA);
|
|
buff_readback = kzalloc(MAX_TRANSFER_CTRL_BYTE_USB , GFP_DMA);
|
|
if (!buff || !buff_readback) {
|
|
kfree(buff);
|
|
kfree(buff_readback);
|
|
|
|
return -ENOMEM;
|
|
}
|
|
|
|
is_config_file = (on_chip_loc == CONFIG_BEGIN_ADDR) ? 1 : 0;
|
|
|
|
while (1) {
|
|
oldfs = get_fs();
|
|
set_fs(get_ds());
|
|
len = vfs_read(flp, (void __force __user *)buff,
|
|
MAX_TRANSFER_CTRL_BYTE_USB, &pos);
|
|
set_fs(oldfs);
|
|
fw_down++;
|
|
|
|
if (len <= 0) {
|
|
if (len < 0)
|
|
errno = len;
|
|
else
|
|
errno = 0;
|
|
break;
|
|
}
|
|
|
|
bytes = InterfaceRDM(psIntfAdapter, on_chip_loc,
|
|
buff_readback, len);
|
|
if (bytes < 0) {
|
|
Status = bytes;
|
|
goto exit;
|
|
}
|
|
reg++;
|
|
if ((len-sizeof(unsigned int)) < 4) {
|
|
if (memcmp(buff_readback, buff, len)) {
|
|
Status = -EIO;
|
|
goto exit;
|
|
}
|
|
} else {
|
|
len -= 4;
|
|
|
|
while (len) {
|
|
if (*(unsigned int *)&buff_readback[len] !=
|
|
*(unsigned int *)&buff[len]) {
|
|
Status = -EIO;
|
|
goto exit;
|
|
}
|
|
len -= 4;
|
|
}
|
|
}
|
|
on_chip_loc += MAX_TRANSFER_CTRL_BYTE_USB;
|
|
} /* End of while(1) */
|
|
|
|
exit:
|
|
kfree(buff);
|
|
kfree(buff_readback);
|
|
return Status;
|
|
}
|
|
|
|
static int bcm_download_config_file(struct bcm_mini_adapter *Adapter,
|
|
struct bcm_firmware_info *psFwInfo)
|
|
{
|
|
int retval = STATUS_SUCCESS;
|
|
B_UINT32 value = 0;
|
|
|
|
if (Adapter->pstargetparams == NULL) {
|
|
Adapter->pstargetparams =
|
|
kmalloc(sizeof(struct bcm_target_params), GFP_KERNEL);
|
|
if (Adapter->pstargetparams == NULL)
|
|
return -ENOMEM;
|
|
}
|
|
|
|
if (psFwInfo->u32FirmwareLength != sizeof(struct bcm_target_params))
|
|
return -EIO;
|
|
|
|
retval = copy_from_user(Adapter->pstargetparams,
|
|
psFwInfo->pvMappedFirmwareAddress,
|
|
psFwInfo->u32FirmwareLength);
|
|
if (retval) {
|
|
kfree(Adapter->pstargetparams);
|
|
Adapter->pstargetparams = NULL;
|
|
return -EFAULT;
|
|
}
|
|
|
|
/* Parse the structure and then Download the Firmware */
|
|
beceem_parse_target_struct(Adapter);
|
|
|
|
/* Initializing the NVM. */
|
|
BcmInitNVM(Adapter);
|
|
retval = InitLedSettings(Adapter);
|
|
|
|
if (retval)
|
|
return retval;
|
|
|
|
if (Adapter->LEDInfo.led_thread_running &
|
|
BCM_LED_THREAD_RUNNING_ACTIVELY) {
|
|
Adapter->LEDInfo.bLedInitDone = false;
|
|
Adapter->DriverState = DRIVER_INIT;
|
|
wake_up(&Adapter->LEDInfo.notify_led_event);
|
|
}
|
|
|
|
if (Adapter->LEDInfo.led_thread_running &
|
|
BCM_LED_THREAD_RUNNING_ACTIVELY) {
|
|
Adapter->DriverState = FW_DOWNLOAD;
|
|
wake_up(&Adapter->LEDInfo.notify_led_event);
|
|
}
|
|
|
|
/* Initialize the DDR Controller */
|
|
retval = ddr_init(Adapter);
|
|
if (retval)
|
|
return retval;
|
|
|
|
value = 0;
|
|
wrmalt(Adapter, EEPROM_CAL_DATA_INTERNAL_LOC - 4,
|
|
&value, sizeof(value));
|
|
wrmalt(Adapter, EEPROM_CAL_DATA_INTERNAL_LOC - 8,
|
|
&value, sizeof(value));
|
|
|
|
if (Adapter->eNVMType == NVM_FLASH) {
|
|
retval = PropagateCalParamsFromFlashToMemory(Adapter);
|
|
if (retval)
|
|
return retval;
|
|
}
|
|
|
|
retval = buffDnldVerify(Adapter, (PUCHAR)Adapter->pstargetparams,
|
|
sizeof(struct bcm_target_params), CONFIG_BEGIN_ADDR);
|
|
|
|
if (retval)
|
|
BCM_DEBUG_PRINT(Adapter, DBG_TYPE_INITEXIT,
|
|
MP_INIT, DBG_LVL_ALL,
|
|
"configuration file not downloaded properly");
|
|
else
|
|
Adapter->bCfgDownloaded = TRUE;
|
|
|
|
return retval;
|
|
}
|
|
|
|
int bcm_ioctl_fw_download(struct bcm_mini_adapter *Adapter,
|
|
struct bcm_firmware_info *psFwInfo)
|
|
{
|
|
int retval = STATUS_SUCCESS;
|
|
PUCHAR buff = NULL;
|
|
|
|
/* Config File is needed for the Driver to download the Config file and
|
|
* Firmware. Check for the Config file to be first to be sent from the
|
|
* Application
|
|
*/
|
|
atomic_set(&Adapter->uiMBupdate, false);
|
|
if (!Adapter->bCfgDownloaded &&
|
|
psFwInfo->u32StartingAddress != CONFIG_BEGIN_ADDR) {
|
|
/* Can't Download Firmware. */
|
|
return -EINVAL;
|
|
}
|
|
|
|
/* If Config File, Finish the DDR Settings and then Download CFG File */
|
|
if (psFwInfo->u32StartingAddress == CONFIG_BEGIN_ADDR) {
|
|
retval = bcm_download_config_file(Adapter, psFwInfo);
|
|
} else {
|
|
buff = kzalloc(psFwInfo->u32FirmwareLength, GFP_KERNEL);
|
|
if (buff == NULL)
|
|
return -ENOMEM;
|
|
|
|
retval = copy_from_user(buff,
|
|
psFwInfo->pvMappedFirmwareAddress,
|
|
psFwInfo->u32FirmwareLength);
|
|
if (retval != STATUS_SUCCESS) {
|
|
retval = -EFAULT;
|
|
goto error;
|
|
}
|
|
|
|
retval = buffDnldVerify(Adapter,
|
|
buff,
|
|
psFwInfo->u32FirmwareLength,
|
|
psFwInfo->u32StartingAddress);
|
|
|
|
if (retval != STATUS_SUCCESS)
|
|
goto error;
|
|
}
|
|
|
|
error:
|
|
kfree(buff);
|
|
return retval;
|
|
}
|
|
|
|
static INT buffDnld(struct bcm_mini_adapter *Adapter,
|
|
PUCHAR mappedbuffer, UINT u32FirmwareLength,
|
|
ULONG u32StartingAddress)
|
|
{
|
|
unsigned int len = 0;
|
|
int retval = STATUS_SUCCESS;
|
|
|
|
len = u32FirmwareLength;
|
|
|
|
while (u32FirmwareLength) {
|
|
len = MIN_VAL(u32FirmwareLength, MAX_TRANSFER_CTRL_BYTE_USB);
|
|
retval = wrm(Adapter, u32StartingAddress, mappedbuffer, len);
|
|
|
|
if (retval)
|
|
break;
|
|
u32StartingAddress += len;
|
|
u32FirmwareLength -= len;
|
|
mappedbuffer += len;
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
static INT buffRdbkVerify(struct bcm_mini_adapter *Adapter,
|
|
PUCHAR mappedbuffer, UINT u32FirmwareLength,
|
|
ULONG u32StartingAddress)
|
|
{
|
|
UINT len = u32FirmwareLength;
|
|
INT retval = STATUS_SUCCESS;
|
|
PUCHAR readbackbuff = kzalloc(MAX_TRANSFER_CTRL_BYTE_USB, GFP_KERNEL);
|
|
int bytes;
|
|
|
|
if (NULL == readbackbuff)
|
|
return -ENOMEM;
|
|
|
|
while (u32FirmwareLength && !retval) {
|
|
len = MIN_VAL(u32FirmwareLength, MAX_TRANSFER_CTRL_BYTE_USB);
|
|
bytes = rdm(Adapter, u32StartingAddress, readbackbuff, len);
|
|
|
|
if (bytes < 0) {
|
|
retval = bytes;
|
|
break;
|
|
}
|
|
|
|
if (memcmp(readbackbuff, mappedbuffer, len) != 0) {
|
|
pr_err("%s() failed. The firmware doesn't match what was written",
|
|
__func__);
|
|
retval = -EIO;
|
|
}
|
|
|
|
u32StartingAddress += len;
|
|
u32FirmwareLength -= len;
|
|
mappedbuffer += len;
|
|
|
|
} /* end of while (u32FirmwareLength && !retval) */
|
|
kfree(readbackbuff);
|
|
return retval;
|
|
}
|
|
|
|
INT buffDnldVerify(struct bcm_mini_adapter *Adapter,
|
|
unsigned char *mappedbuffer,
|
|
unsigned int u32FirmwareLength,
|
|
unsigned long u32StartingAddress)
|
|
{
|
|
INT status = STATUS_SUCCESS;
|
|
|
|
status = buffDnld(Adapter, mappedbuffer,
|
|
u32FirmwareLength, u32StartingAddress);
|
|
if (status != STATUS_SUCCESS)
|
|
goto error;
|
|
|
|
status = buffRdbkVerify(Adapter, mappedbuffer,
|
|
u32FirmwareLength, u32StartingAddress);
|
|
if (status != STATUS_SUCCESS)
|
|
goto error;
|
|
error:
|
|
return status;
|
|
}
|