diff --git a/backport-0001-Title-Fix-errors-found-with-checkpatch-script.patch b/backport-0001-Title-Fix-errors-found-with-checkpatch-script.patch new file mode 100644 index 0000000..3ee3d9a --- /dev/null +++ b/backport-0001-Title-Fix-errors-found-with-checkpatch-script.patch @@ -0,0 +1,1146 @@ +From 8154be122d0f841208b787b728085c565710e0f7 Mon Sep 17 00:00:00 2001 +From: Idan Mehalel +Date: Mon, 23 Jul 2018 15:24:12 +0300 +Subject: [PATCH] Title: Fix errors found with checkpatch script + +Description: +Issue: 1471556 +--- + kernel/mst.h | 32 +-- + kernel/mst_kernel.h | 4 +- + kernel/mst_main.c | 616 +++++++++++++++++++++++--------------------- + kernel/mst_vpd.c | 4 +- + 4 files changed, 338 insertions(+), 318 deletions(-) + +diff --git a/kernel/mst.h b/kernel/mst.h +index dc22513..c076c1d 100644 +--- a/kernel/mst.h ++++ b/kernel/mst.h +@@ -74,18 +74,18 @@ typedef uint32_t u32; + #define MST_READ4 _IOR(MST_BYTE_ACCESS_MAGIC, 1, struct mst_read4_st) + + struct mst_read4_st { +- unsigned int address_space; +- unsigned int offset; +- unsigned int data; /*OUT*/ ++ unsigned int address_space; ++ unsigned int offset; ++ unsigned int data; /*OUT*/ + }; + + + #define MST_WRITE4 _IOW(MST_BYTE_ACCESS_MAGIC, 2, struct mst_write4_st) + + struct mst_write4_st { +- unsigned int address_space; +- unsigned int offset; +- unsigned int data; ++ unsigned int address_space; ++ unsigned int offset; ++ unsigned int data; + }; + + +@@ -115,20 +115,20 @@ struct mst_write_block_st { + }; + + +-#define PCICONF_READ4_BUFFER _IOR (MST_BLOCK_ACCESS_MAGIC, 3, struct mst_read4_st) ++#define PCICONF_READ4_BUFFER _IOR(MST_BLOCK_ACCESS_MAGIC, 3, struct mst_read4_st) + struct mst_read4_buffer_st { +- unsigned int address_space; +- unsigned int offset; +- int size; +- unsigned int data[PCICONF_MAX_BUFFER_SIZE/4]; /*OUT*/ ++ unsigned int address_space; ++ unsigned int offset; ++ int size; ++ unsigned int data[PCICONF_MAX_BUFFER_SIZE/4]; /*OUT*/ + }; + +-#define PCICONF_WRITE4_BUFFER _IOW (MST_BLOCK_ACCESS_MAGIC, 4, struct mst_write4_buffer_st) ++#define PCICONF_WRITE4_BUFFER _IOW(MST_BLOCK_ACCESS_MAGIC, 4, struct mst_write4_buffer_st) + struct mst_write4_buffer_st { +- unsigned int address_space; +- unsigned int offset; +- int size; +- unsigned int data[PCICONF_MAX_BUFFER_SIZE/4]; /*IN*/ ++ unsigned int address_space; ++ unsigned int offset; ++ int size; ++ unsigned int data[PCICONF_MAX_BUFFER_SIZE/4]; /*IN*/ + }; + /****************************************************/ + /* +diff --git a/kernel/mst_kernel.h b/kernel/mst_kernel.h +index d7188e9..fb52abc 100644 +--- a/kernel/mst_kernel.h ++++ b/kernel/mst_kernel.h +@@ -113,10 +113,10 @@ struct mst_dev_data { + + /****************************************************/ + int pci_read4_vpd(struct mst_dev_data *dev, unsigned int timeout, +- unsigned offset, u32 *buf); ++ unsigned int offset, u32 *buf); + + int pci_write4_vpd(struct mst_dev_data *dev, unsigned int timeout, +- unsigned offset, u32 buf); ++ unsigned int offset, u32 buf); + + + #endif /* _MST_KERNEL_H_ */ +diff --git a/kernel/mst_main.c b/kernel/mst_main.c +index 047cc98..9da9df9 100644 +--- a/kernel/mst_main.c ++++ b/kernel/mst_main.c +@@ -33,7 +33,7 @@ + #include + #include + #include +-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,18) ++#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 18) + #include + #else + #include +@@ -59,7 +59,7 @@ static const char mst_driver_string[] = "Mellanox Technologies Software Tools Dr + LIST_HEAD(mst_devices); + + static struct pci_device_id mst_livefish_pci_table[] = { +- { PCI_DEVICE(MST_MELLANOX_PCI_VENDOR, 0x01f6) }, /* MT27500 [ConnectX-3 Flash Recovery] */ ++ { PCI_DEVICE(MST_MELLANOX_PCI_VENDOR, 0x01f6) }, /* MT27500 [ConnectX-3 Flash Recovery] */ + { PCI_DEVICE(MST_MELLANOX_PCI_VENDOR, 0x01f8) }, /* MT27520 [ConnectX-3 Pro Flash Recovery] */ + { PCI_DEVICE(MST_MELLANOX_PCI_VENDOR, 0x01ff) }, /* MT27520 [ConnectX-IB Flash Recovery] */ + { PCI_DEVICE(MST_MELLANOX_PCI_VENDOR, 0x0209) }, /* MT27520 [ConnectX-4 Flash Recovery] */ +@@ -70,14 +70,14 @@ static struct pci_device_id mst_livefish_pci_table[] = { + }; + + static struct pci_device_id mst_bar_pci_table[] = { +- { PCI_DEVICE(MST_MELLANOX_PCI_VENDOR, 4099) }, /* MT27600 [ConnectX-3] */ +- { PCI_DEVICE(MST_MELLANOX_PCI_VENDOR, 4103) }, /* MT27600 [ConnectX-3Pro] */ ++ { PCI_DEVICE(MST_MELLANOX_PCI_VENDOR, 4099) }, /* MT27600 [ConnectX-3] */ ++ { PCI_DEVICE(MST_MELLANOX_PCI_VENDOR, 4103) }, /* MT27600 [ConnectX-3Pro] */ + { 0, } + }; + + static struct pci_device_id supported_pci_devices[] = { +- { PCI_DEVICE(MST_MELLANOX_PCI_VENDOR, 4099) }, /* MT27600 [ConnectX-3] */ +- { PCI_DEVICE(MST_MELLANOX_PCI_VENDOR, 4103) }, /* MT27600 [ConnectX-3Pro] */ ++ { PCI_DEVICE(MST_MELLANOX_PCI_VENDOR, 4099) }, /* MT27600 [ConnectX-3] */ ++ { PCI_DEVICE(MST_MELLANOX_PCI_VENDOR, 4103) }, /* MT27600 [ConnectX-3Pro] */ + { PCI_DEVICE(MST_MELLANOX_PCI_VENDOR, 4113) }, /* MT27600 [ConnectX-IB] */ + { PCI_DEVICE(MST_MELLANOX_PCI_VENDOR, 4115) }, /* MT27600 [ConnectX-4] */ + { PCI_DEVICE(MST_MELLANOX_PCI_VENDOR, 4117) }, /* MT27600 [ConnectX-4Lx] */ +@@ -93,13 +93,13 @@ static struct pci_device_id supported_pci_devices[] = { + + // BIT Slicing macros + #define ONES32(size) ((size)?(0xffffffff>>(32-(size))):0) +-#define MASK32(offset,size) (ONES32(size)<<(offset)) ++#define MASK32(offset, size) (ONES32(size)<<(offset)) + +-#define EXTRACT_C(source,offset,size) ((((unsigned)(source))>>(offset)) & ONES32(size)) +-#define EXTRACT(src,start,len) (((len)==32)?(src):EXTRACT_C(src,start,len)) ++#define EXTRACT_C(source, offset, size) ((((unsigned int)(source))>>(offset)) & ONES32(size)) ++#define EXTRACT(src, start, len) (((len) == 32)?(src):EXTRACT_C(src, start, len)) + +-#define MERGE_C(rsrc1,rsrc2,start,len) ((((rsrc2)<<(start)) & (MASK32((start),(len)))) | ((rsrc1) & (~MASK32((start),(len))))) +-#define MERGE(rsrc1,rsrc2,start,len) (((len)==32)?(rsrc2):MERGE_C(rsrc1,rsrc2,start,len)) ++#define MERGE_C(rsrc1, rsrc2, start, len) ((((rsrc2)<<(start)) & (MASK32((start), (len)))) | ((rsrc1) & (~MASK32((start), (len))))) ++#define MERGE(rsrc1, rsrc2, start, len) (((len) == 32)?(rsrc2):MERGE_C(rsrc1, rsrc2, start, len)) + + + /* Allow minor numbers 0-255 */ +@@ -163,34 +163,40 @@ static int _vendor_specific_sem(struct mst_dev_data *dev, int state) + u32 counter = 0; + int retries = 0; + int ret; ++ + if (!state) {// unlock +- ret = pci_write_config_dword(dev->pci_dev, dev->vendor_specific_cap + PCI_SEMAPHORE_OFFSET, 0); +- if (ret) return ret; ++ ret = pci_write_config_dword(dev->pci_dev, dev->vendor_specific_cap + PCI_SEMAPHORE_OFFSET, 0); ++ if (ret) ++ return ret; + } else { // lock +- do { +- if (retries > SEM_MAX_RETRIES) { +- return -1; +- } +- // read semaphore untill 0x0 +- ret = pci_read_config_dword(dev->pci_dev, dev->vendor_specific_cap + PCI_SEMAPHORE_OFFSET, &lock_val); +- if (ret) return ret; +- +- if (lock_val) { //semaphore is taken +- retries++; +- msleep(1); // wait for current op to end +- continue; +- } +- //read ticket +- ret = pci_read_config_dword(dev->pci_dev, dev->vendor_specific_cap + PCI_COUNTER_OFFSET, &counter); +- if (ret) return ret; +- //write ticket to semaphore dword +- ret = pci_write_config_dword(dev->pci_dev, dev->vendor_specific_cap + PCI_SEMAPHORE_OFFSET, counter); +- if (ret) return ret; +- // read back semaphore make sure ticket == semaphore else repeat +- ret = pci_read_config_dword(dev->pci_dev, dev->vendor_specific_cap + PCI_SEMAPHORE_OFFSET, &lock_val); +- if (ret) return ret; +- retries++; +- } while (counter != lock_val); ++ do { ++ if (retries > SEM_MAX_RETRIES) { ++ return -1; ++ } ++ // read semaphore untill 0x0 ++ ret = pci_read_config_dword(dev->pci_dev, dev->vendor_specific_cap + PCI_SEMAPHORE_OFFSET, &lock_val); ++ if (ret) ++ return ret; ++ ++ if (lock_val) { //semaphore is taken ++ retries++; ++ msleep(1); // wait for current op to end ++ continue; ++ } ++ //read ticket ++ ret = pci_read_config_dword(dev->pci_dev, dev->vendor_specific_cap + PCI_COUNTER_OFFSET, &counter); ++ if (ret) ++ return ret; ++ //write ticket to semaphore dword ++ ret = pci_write_config_dword(dev->pci_dev, dev->vendor_specific_cap + PCI_SEMAPHORE_OFFSET, counter); ++ if (ret) ++ return ret; ++ // read back semaphore make sure ticket == semaphore else repeat ++ ret = pci_read_config_dword(dev->pci_dev, dev->vendor_specific_cap + PCI_SEMAPHORE_OFFSET, &lock_val); ++ if (ret) ++ return ret; ++ retries++; ++ } while (counter != lock_val); + } + return 0; + } +@@ -200,91 +206,101 @@ static int _wait_on_flag(struct mst_dev_data *dev, u8 expected_val) + int retries = 0; + int ret; + u32 flag; ++ + do { +- if (retries > IFC_MAX_RETRIES) { +- return -1; +- } +- +- ret = pci_read_config_dword(dev->pci_dev, dev->vendor_specific_cap + PCI_ADDR_OFFSET, &flag); +- if (ret) return ret; +- +- flag = EXTRACT(flag, PCI_FLAG_BIT_OFFS, 1); +- retries++; +- if ((retries & 0xf) == 0) {// dont sleep always +- //usleep_range(1,5); +- } ++ if (retries > IFC_MAX_RETRIES) { ++ return -1; ++ } ++ ++ ret = pci_read_config_dword(dev->pci_dev, dev->vendor_specific_cap + PCI_ADDR_OFFSET, &flag); ++ if (ret) ++ return ret; ++ ++ flag = EXTRACT(flag, PCI_FLAG_BIT_OFFS, 1); ++ retries++; ++ if ((retries & 0xf) == 0) {// dont sleep always ++ //usleep_range(1,5); ++ } + } while (flag != expected_val); + return 0; + } + +-static int _set_addr_space( struct mst_dev_data *dev, u16 space) ++static int _set_addr_space(struct mst_dev_data *dev, u16 space) + { + // read modify write + u32 val; + int ret; ++ + ret = pci_read_config_dword(dev->pci_dev, dev->vendor_specific_cap + PCI_CTRL_OFFSET, &val); +- if (ret) return ret; ++ if (ret) ++ return ret; + val = MERGE(val, space, PCI_SPACE_BIT_OFFS, PCI_SPACE_BIT_LEN); + ret = pci_write_config_dword(dev->pci_dev, dev->vendor_specific_cap + PCI_CTRL_OFFSET, val); +- if (ret) return ret; ++ if (ret) ++ return ret; + // read status and make sure space is supported + ret = pci_read_config_dword(dev->pci_dev, dev->vendor_specific_cap + PCI_CTRL_OFFSET, &val); +- if (ret) return ret; ++ if (ret) ++ return ret; + + if (EXTRACT(val, PCI_STATUS_BIT_OFFS, PCI_STATUS_BIT_LEN) == 0) { + // mst_err("CRSPACE %d is not supported !\n", space); +- return -1; ++ return -1; + } + // mst_err("CRSPACE %d is supported !\n", space); + return 0; + } + +-static int _pciconf_rw(struct mst_dev_data *dev, unsigned int offset, u32* data, int rw) ++static int _pciconf_rw(struct mst_dev_data *dev, unsigned int offset, u32 *data, int rw) + { + int ret = 0; + u32 address = offset; + + //last 2 bits must be zero as we only allow 30 bits addresses + if (EXTRACT(address, 30, 2)) { +- return -1; ++ return -1; + } + +- address = MERGE(address,(rw ? 1 : 0), PCI_FLAG_BIT_OFFS, 1); ++ address = MERGE(address, (rw ? 1 : 0), PCI_FLAG_BIT_OFFS, 1); + if (rw == WRITE_OP) { +- // write data +- ret = pci_write_config_dword(dev->pci_dev, dev->vendor_specific_cap + PCI_DATA_OFFSET, *data); +- if (ret) return ret; +- // write address +- ret = pci_write_config_dword(dev->pci_dev, dev->vendor_specific_cap + PCI_ADDR_OFFSET, address); +- if (ret) return ret; +- // wait on flag +- ret = _wait_on_flag(dev, 0); ++ // write data ++ ret = pci_write_config_dword(dev->pci_dev, dev->vendor_specific_cap + PCI_DATA_OFFSET, *data); ++ if (ret) ++ return ret; ++ // write address ++ ret = pci_write_config_dword(dev->pci_dev, dev->vendor_specific_cap + PCI_ADDR_OFFSET, address); ++ if (ret) ++ return ret; ++ // wait on flag ++ ret = _wait_on_flag(dev, 0); + } else { +- // write address +- ret = pci_write_config_dword(dev->pci_dev, dev->vendor_specific_cap + PCI_ADDR_OFFSET, address); +- if (ret) return ret; +- // wait on flag +- ret = _wait_on_flag(dev, 1); +- // read data +- ret = pci_read_config_dword(dev->pci_dev, dev->vendor_specific_cap + PCI_DATA_OFFSET, data); +- if (ret) return ret; ++ // write address ++ ret = pci_write_config_dword(dev->pci_dev, dev->vendor_specific_cap + PCI_ADDR_OFFSET, address); ++ if (ret) ++ return ret; ++ // wait on flag ++ ret = _wait_on_flag(dev, 1); ++ // read data ++ ret = pci_read_config_dword(dev->pci_dev, dev->vendor_specific_cap + PCI_DATA_OFFSET, data); ++ if (ret) ++ return ret; + } + return ret; + } + +-static int _send_pci_cmd_int( struct mst_dev_data *dev, int space, unsigned int offset, u32* data, int rw) ++static int _send_pci_cmd_int(struct mst_dev_data *dev, int space, unsigned int offset, u32 *data, int rw) + { + int ret = 0; + + // take semaphore + ret = _vendor_specific_sem(dev, 1); + if (ret) { +- return ret; ++ return ret; + } + // set address space + ret = _set_addr_space(dev, space); + if (ret) { +- goto cleanup; ++ goto cleanup; + } + // read/write the data + ret = _pciconf_rw(dev, offset, data, rw); +@@ -294,55 +310,56 @@ cleanup: + return ret; + } + +-static int _block_op( struct mst_dev_data *dev, int space, unsigned int offset, int size, u32* data, int rw) ++static int _block_op(struct mst_dev_data *dev, int space, unsigned int offset, int size, u32 *data, int rw) + { + int i; + int ret = 0; + int wrote_or_read = size; ++ + if (size % 4) { +- return -1; ++ return -1; + } + // lock semaphore and set address space + ret = _vendor_specific_sem(dev, 1); + if (ret) { +- return -1; ++ return -1; + } + // set address space + ret = _set_addr_space(dev, space); + if (ret) { +- wrote_or_read = -1; +- goto cleanup; ++ wrote_or_read = -1; ++ goto cleanup; + } + + for (i = 0; i < size ; i += 4) { +- if (_pciconf_rw(dev, offset + i, &(data[(i >> 2)]), rw)) { +- wrote_or_read = i; +- goto cleanup; +- } ++ if (_pciconf_rw(dev, offset + i, &(data[(i >> 2)]), rw)) { ++ wrote_or_read = i; ++ goto cleanup; ++ } + } + cleanup: + _vendor_specific_sem(dev, 0); + return wrote_or_read; + } + +-static int write4_vsec( struct mst_dev_data *dev, int addresss_domain, unsigned int offset, unsigned int data) ++static int write4_vsec(struct mst_dev_data *dev, int addresss_domain, unsigned int offset, unsigned int data) + { + int ret; + + ret = _send_pci_cmd_int(dev, addresss_domain, offset, &data, WRITE_OP); + if (ret) { +- return -1; ++ return -1; + } + return 0; + } + +-static int read4_vsec( struct mst_dev_data *dev, int address_space, unsigned int offset, unsigned int* data) ++static int read4_vsec(struct mst_dev_data *dev, int address_space, unsigned int offset, unsigned int *data) + { + int ret; + //mst_info("Read from VSEC: offset: %#x\n", offset); + ret = _send_pci_cmd_int(dev, address_space, offset, data, READ_OP); + if (ret) { +- return -1; ++ return -1; + } + return 0; + } +@@ -355,23 +372,23 @@ int pciconf_read4_legacy(struct mst_dev_data *dev, unsigned int offset, unsigned + unsigned int new_offset = offset; + //mst_info("pciconf_read4_legacy: offset: %#x\n", offset); + if (dev->type != PCICONF) { +- return -1; ++ return -1; + } + if (dev->wo_addr) { +- new_offset |= 0x1; ++ new_offset |= 0x1; + } + /* write the wanted address to addr register */ + res = pci_write_config_dword(dev->pci_dev, dev->addr_reg, new_offset); + if (res) { +- mst_err("pci_write_config_dword failed\n"); +- return res; ++ mst_err("pci_write_config_dword failed\n"); ++ return res; + } + + /* read the result from data register */ + res = pci_read_config_dword(dev->pci_dev, dev->data_reg, data); + if (res) { +- mst_err("pci_read_config_dword failed\n"); +- return res; ++ mst_err("pci_read_config_dword failed\n"); ++ return res; + } + return 0; + } +@@ -379,55 +396,56 @@ int pciconf_read4_legacy(struct mst_dev_data *dev, unsigned int offset, unsigned + int pciconf_write4_legacy(struct mst_dev_data *dev, unsigned int offset, unsigned int data) + { + int res = 0; ++ + if (dev->type != PCICONF) { +- return -1; ++ return -1; + } + if (dev->wo_addr) { +- /* +- * Write operation with new WO GW +- * 1. Write data +- * 2. Write address +- */ +- +- /* write the data to data register */ +- res = pci_write_config_dword(dev->pci_dev, dev->data_reg, data); +- if (res) { +- mst_err("pci_write_config_dword failed\n"); +- return res; +- } +- /* write the destination address to addr register */ +- res = pci_write_config_dword(dev->pci_dev, dev->addr_reg, offset); +- if (res) { +- mst_err("pci_write_config_dword failed\n"); +- return res; +- } ++ /* ++ * Write operation with new WO GW ++ * 1. Write data ++ * 2. Write address ++ */ ++ ++ /* write the data to data register */ ++ res = pci_write_config_dword(dev->pci_dev, dev->data_reg, data); ++ if (res) { ++ mst_err("pci_write_config_dword failed\n"); ++ return res; ++ } ++ /* write the destination address to addr register */ ++ res = pci_write_config_dword(dev->pci_dev, dev->addr_reg, offset); ++ if (res) { ++ mst_err("pci_write_config_dword failed\n"); ++ return res; ++ } + + } else { +- /* write the destination address to addr register */ +- res = pci_write_config_dword(dev->pci_dev, dev->addr_reg, offset); +- if (res) { +- mst_err("pci_write_conflig_dword failed\n"); +- return res; +- } +- +- /* write the data to data register */ +- res = pci_write_config_dword(dev->pci_dev, dev->data_reg, data); +- if (res) { +- mst_err("pci_write_config_dword failed\n"); +- return res; +- } ++ /* write the destination address to addr register */ ++ res = pci_write_config_dword(dev->pci_dev, dev->addr_reg, offset); ++ if (res) { ++ mst_err("pci_write_conflig_dword failed\n"); ++ return res; ++ } ++ ++ /* write the data to data register */ ++ res = pci_write_config_dword(dev->pci_dev, dev->data_reg, data); ++ if (res) { ++ mst_err("pci_write_config_dword failed\n"); ++ return res; ++ } + } + return 0; + } + + +-static int write4_block_vsec( struct mst_dev_data *dev, int address_space, unsigned int offset, int size, u32* data) ++static int write4_block_vsec(struct mst_dev_data *dev, int address_space, unsigned int offset, int size, u32 *data) + { + // mst_info("HERE %#x %#x %#x\n", address_space, offset, *data); + return _block_op(dev, address_space, offset, size, data, WRITE_OP); + } + +-static int read4_block_vsec( struct mst_dev_data *dev, int address_space, unsigned int offset, int size, u32* data) ++static int read4_block_vsec(struct mst_dev_data *dev, int address_space, unsigned int offset, int size, u32 *data) + { + // mst_info("HERE %#x %#x %#x\n", address_space, offset, *data); + return _block_op(dev, address_space, offset, size, data, READ_OP); +@@ -438,25 +456,25 @@ static int get_space_support_status(struct mst_dev_data *dev) + int ret; + // printk("[MST] Checking if the Vendor CAP %d supports the SPACES in devices\n", vend_cap); + if (!dev->vendor_specific_cap) { +- return 0; ++ return 0; + } +- if (dev->spaces_support_status != SS_UNINITIALIZED ) { +- return 0; ++ if (dev->spaces_support_status != SS_UNINITIALIZED) { ++ return 0; + } + // take semaphore + ret = _vendor_specific_sem(dev, 1); + if (ret) { +- mst_err("Failed to lock VSEC semaphore\n"); +- return 1; ++ mst_err("Failed to lock VSEC semaphore\n"); ++ return 1; + } + +- if( _set_addr_space(dev, AS_CR_SPACE) || ++ if (_set_addr_space(dev, AS_CR_SPACE) || + _set_addr_space(dev, AS_ICMD) || +- _set_addr_space(dev, AS_SEMAPHORE) ) { +- mst_err("At least one SPACE is not supported\n"); +- dev->spaces_support_status = SS_NOT_ALL_SPACES_SUPPORTED; ++ _set_addr_space(dev, AS_SEMAPHORE)) { ++ mst_err("At least one SPACE is not supported\n"); ++ dev->spaces_support_status = SS_NOT_ALL_SPACES_SUPPORTED; + } else { +- dev->spaces_support_status = SS_ALL_SPACES_SUPPORTED; ++ dev->spaces_support_status = SS_ALL_SPACES_SUPPORTED; + } + // clear semaphore + _vendor_specific_sem(dev, 0); +@@ -468,20 +486,21 @@ static int get_space_support_status(struct mst_dev_data *dev) + + #define WO_REG_ADDR_DATA 0xbadacce5 + #define DEVID_OFFSET 0xf0014 +-int is_wo_gw(struct pci_dev* pcidev, unsigned addr_reg) ++int is_wo_gw(struct pci_dev *pcidev, unsigned int addr_reg) + { + int ret; + unsigned int data = 0; ++ + ret = pci_write_config_dword(pcidev, addr_reg, DEVID_OFFSET); + if (ret) { +- return 0; ++ return 0; + } + ret = pci_read_config_dword(pcidev, addr_reg, &data); + if (ret) { +- return 0; ++ return 0; + } +- if ( data == WO_REG_ADDR_DATA ) { +- return 1; ++ if (data == WO_REG_ADDR_DATA) { ++ return 1; + } + return 0; + } +@@ -493,15 +512,15 @@ static int mst_open(struct inode *inode, struct file *file) + struct mst_file_data *md = NULL; + + md = kmalloc(sizeof(struct mst_connectx_wa), GFP_KERNEL); +- if (!md) { +- return -ERESTARTSYS; +- } ++ if (!md) { ++ return -ERESTARTSYS; ++ } + + memset(md, 0, sizeof(struct mst_connectx_wa)); + + file->private_data = md; + +- return 0; ++ return 0; + } + + +@@ -512,7 +531,7 @@ static int mst_release(struct inode *inode, struct file *file) + struct mst_dev_data *dev = NULL; + struct mst_dev_data *cur = NULL; + unsigned int slot_mask; +- struct mst_connectx_wa *md = file->private_data; ++ struct mst_connectx_wa *md = file->private_data; + + /* + * make sure the device is available since it +@@ -539,7 +558,7 @@ static int mst_release(struct inode *inode, struct file *file) + + /* + * mst_info("CONNECTX_WA: Released slot %u. Current slots: %02x\n", +- * md->connectx_wa_slot_p1 - 1, dev->connectx_wa_slots); ++ * md->connectx_wa_slot_p1 - 1, dev->connectx_wa_slots); + */ + md->connectx_wa_slot_p1 = 0; + mutex_unlock(&dev->lock); +@@ -680,24 +699,24 @@ static int mst_ioctl(struct inode *inode, struct file *file, + goto fin; + } + // best effort : try to get space spport status if we fail assume we got vsec support. +- get_space_support_status(dev); +- paramst.domain = pci_domain_nr(dev->pci_dev->bus); +- paramst.bus = dev->pci_dev->bus->number; +- paramst.slot = PCI_SLOT(dev->pci_dev->devfn); ++ get_space_support_status(dev); ++ paramst.domain = pci_domain_nr(dev->pci_dev->bus); ++ paramst.bus = dev->pci_dev->bus->number; ++ paramst.slot = PCI_SLOT(dev->pci_dev->devfn); + paramst.func = PCI_FUNC(dev->pci_dev->devfn); +- paramst.bar = dev->bar; +- paramst.device = dev->pci_dev->device; ++ paramst.bar = dev->bar; ++ paramst.device = dev->pci_dev->device; + paramst.vendor = dev->pci_dev->vendor; +- paramst.subsystem_device = dev->pci_dev->subsystem_device; ++ paramst.subsystem_device = dev->pci_dev->subsystem_device; + paramst.subsystem_vendor = dev->pci_dev->subsystem_vendor; +- if (dev->vendor_specific_cap && +- (dev->spaces_support_status == SS_ALL_SPACES_SUPPORTED || +- dev->spaces_support_status == SS_UNINITIALIZED) ) { +- // assume supported if SS_UNINITIALIZED (since semaphore is locked) +- paramst.vendor_specific_cap = dev->vendor_specific_cap; +- } else { +- paramst.vendor_specific_cap = 0; +- } ++ if (dev->vendor_specific_cap && ++ (dev->spaces_support_status == SS_ALL_SPACES_SUPPORTED || ++ dev->spaces_support_status == SS_UNINITIALIZED)) { ++ // assume supported if SS_UNINITIALIZED (since semaphore is locked) ++ paramst.vendor_specific_cap = dev->vendor_specific_cap; ++ } else { ++ paramst.vendor_specific_cap = 0; ++ } + if (copy_to_user(user_buf, ¶mst, sizeof(struct mst_params))) { + res = -EFAULT; + goto fin; +@@ -723,19 +742,19 @@ static int mst_ioctl(struct inode *inode, struct file *file, + + switch (dev->type) { + case PCICONF: +- if (get_space_support_status(dev)) { +- res = -EBUSY; +- goto fin; +- } +- +- if ( VSEC_FULLY_SUPPORTED(dev) ) { +- res = read4_vsec(dev, readst.address_space, readst.offset, &out); +- } else { +- res = pciconf_read4_legacy(dev, readst.offset, &out); +- } +- if (res) { +- goto fin; +- } ++ if (get_space_support_status(dev)) { ++ res = -EBUSY; ++ goto fin; ++ } ++ ++ if (VSEC_FULLY_SUPPORTED(dev)) { ++ res = read4_vsec(dev, readst.address_space, readst.offset, &out); ++ } else { ++ res = pciconf_read4_legacy(dev, readst.offset, &out); ++ } ++ if (res) { ++ goto fin; ++ } + break; + + case PCIMEM: +@@ -749,8 +768,8 @@ static int mst_ioctl(struct inode *inode, struct file *file, + out = ioread32(dev->hw_addr + readst.offset); + + /* endianness conversion - we noticed that we need to swap always */ +- be32_to_cpus(&out); +- out = cpu_to_le32(out); ++ be32_to_cpus(&out); ++ out = cpu_to_le32(out); + break; + } + +@@ -779,15 +798,15 @@ static int mst_ioctl(struct inode *inode, struct file *file, + + switch (dev->type) { + case PCICONF: +- if (get_space_support_status(dev)) { +- res = -EBUSY; +- goto fin; +- } +- if ( VSEC_FULLY_SUPPORTED(dev) ) { +- res = write4_vsec(dev, writest.address_space, writest.offset, writest.data); +- } else { +- res = pciconf_write4_legacy(dev, writest.offset, writest.data); +- } ++ if (get_space_support_status(dev)) { ++ res = -EBUSY; ++ goto fin; ++ } ++ if (VSEC_FULLY_SUPPORTED(dev)) { ++ res = write4_vsec(dev, writest.address_space, writest.offset, writest.data); ++ } else { ++ res = pciconf_write4_legacy(dev, writest.offset, writest.data); ++ } + break; + + case PCIMEM: +@@ -799,7 +818,7 @@ static int mst_ioctl(struct inode *inode, struct file *file, + + /* endianness conversion - we noticed that we need to swap always */ + cpu_to_be32s(&(writest.data)); +- writest.data = cpu_to_le32(writest.data); ++ writest.data = cpu_to_le32(writest.data); + + /* write to hardware */ + iowrite32(writest.data, dev->hw_addr + writest.offset); +@@ -912,86 +931,87 @@ static int mst_ioctl(struct inode *inode, struct file *file, + break; + } + +- case PCICONF_READ4_BUFFER: ++ case PCICONF_READ4_BUFFER: + { +- struct mst_read4_buffer_st read4_buf; +- struct mst_read4_buffer_st* rb_udata = (struct mst_read4_buffer_st *)user_buf; +- +- if (!dev->initialized) { +- mst_err("device is not initialized\n"); +- res = -ENODEV; +- goto fin; +- } +- +- if (dev->type != PCICONF) { +- mst_err("wrong type for device\n"); +- res = -EPERM; +- goto fin; +- } +- +- if (get_space_support_status(dev)) { +- res = -EBUSY; +- goto fin; +- } +- +- if (dev->spaces_support_status != SS_ALL_SPACES_SUPPORTED) { +- res = -ENOSYS; +- goto fin; +- } +- +- +- if (copy_from_user(&read4_buf, user_buf, sizeof(read4_buf))) { +- res = -EFAULT; +- goto fin; +- } +- +- res = read4_block_vsec(dev, read4_buf.address_space, read4_buf.offset, read4_buf.size, read4_buf.data); +- if (res != read4_buf.size) { +- goto fin; +- } +- +- res = copy_to_user(rb_udata, &read4_buf, sizeof(read4_buf)) ? -EFAULT : read4_buf.size; +- goto fin; ++ struct mst_read4_buffer_st read4_buf; ++ struct mst_read4_buffer_st *rb_udata = (struct mst_read4_buffer_st *)user_buf; ++ ++ if (!dev->initialized) { ++ mst_err("device is not initialized\n"); ++ res = -ENODEV; ++ goto fin; ++ } ++ ++ if (dev->type != PCICONF) { ++ mst_err("wrong type for device\n"); ++ res = -EPERM; ++ goto fin; ++ } ++ ++ if (get_space_support_status(dev)) { ++ res = -EBUSY; ++ goto fin; ++ } ++ ++ if (dev->spaces_support_status != SS_ALL_SPACES_SUPPORTED) { ++ res = -ENOSYS; ++ goto fin; ++ } ++ ++ ++ if (copy_from_user(&read4_buf, user_buf, sizeof(read4_buf))) { ++ res = -EFAULT; ++ goto fin; ++ } ++ ++ res = read4_block_vsec(dev, read4_buf.address_space, read4_buf.offset, read4_buf.size, read4_buf.data); ++ if (res != read4_buf.size) { ++ goto fin; ++ } ++ ++ res = copy_to_user(rb_udata, &read4_buf, sizeof(read4_buf)) ? -EFAULT : read4_buf.size; ++ goto fin; + } +- case PCICONF_WRITE4_BUFFER: ++ case PCICONF_WRITE4_BUFFER: + { +- struct mst_write4_buffer_st write4_buf; +- struct mst_write4_buffer_st* wb_udata = (struct mst_write4_buffer_st *)user_buf; ++ struct mst_write4_buffer_st write4_buf; ++ struct mst_write4_buffer_st *wb_udata = (struct mst_write4_buffer_st *)user_buf; + +- if (!dev->initialized) { +- mst_err("device is not initialized\n"); +- res = -ENODEV; +- goto fin; +- } ++ if (!dev->initialized) { ++ mst_err("device is not initialized\n"); ++ res = -ENODEV; ++ goto fin; ++ } + +- if (dev->type != PCICONF) { +- mst_err("wrong type for device\n"); +- res = -EPERM; +- goto fin; +- } ++ if (dev->type != PCICONF) { ++ mst_err("wrong type for device\n"); ++ res = -EPERM; ++ goto fin; ++ } + + +- if (get_space_support_status(dev)) { +- res = -EBUSY; +- goto fin; +- } ++ if (get_space_support_status(dev)) { ++ res = -EBUSY; ++ goto fin; ++ } + +- if (dev->spaces_support_status != SS_ALL_SPACES_SUPPORTED) { +- res = -ENOSYS; +- goto fin; +- } ++ if (dev->spaces_support_status != SS_ALL_SPACES_SUPPORTED) { ++ res = -ENOSYS; ++ goto fin; ++ } + + +- if (copy_from_user(&write4_buf, user_buf, sizeof(write4_buf))) { +- res = -EFAULT; +- goto fin; +- } ++ if (copy_from_user(&write4_buf, user_buf, sizeof(write4_buf))) { ++ res = -EFAULT; ++ goto fin; ++ } + +- res = write4_block_vsec(dev, write4_buf.address_space, write4_buf.offset, write4_buf.size, write4_buf.data); +- if (res != write4_buf.size) goto fin; ++ res = write4_block_vsec(dev, write4_buf.address_space, write4_buf.offset, write4_buf.size, write4_buf.data); ++ if (res != write4_buf.size) ++ goto fin; + +- res = copy_to_user(wb_udata, &write4_buf, sizeof(write4_buf)) ? -EFAULT : write4_buf.size; +- goto fin; ++ res = copy_to_user(wb_udata, &write4_buf, sizeof(write4_buf)) ? -EFAULT : write4_buf.size; ++ goto fin; + } + case PCICONF_INIT: { + struct mst_pciconf_init_st initst; +@@ -1020,7 +1040,7 @@ static int mst_ioctl(struct inode *inode, struct file *file, + dev->wo_addr = is_wo_gw(dev->pci_dev, initst.addr_reg); + dev->vendor_specific_cap = pci_find_capability(dev->pci_dev, MLNX_VENDOR_SPECIFIC_CAP_ID); + //mst_info("VSEC SUPP: %#x\n", dev->vendor_specific_cap); +- dev->spaces_support_status = SS_UNINITIALIZED; // init on first op ++ dev->spaces_support_status = SS_UNINITIALIZED; // init on first op + + + dev->initialized = 1; +@@ -1139,7 +1159,7 @@ static int mst_ioctl(struct inode *inode, struct file *file, + + /* + * mst_info("CONNECTX_WA: Took slot %u. Current slots: %02x\n", +- * md->connectx_wa_slot_p1 - 1, dev->connectx_wa_slots); ++ * md->connectx_wa_slot_p1 - 1, dev->connectx_wa_slots); + */ + if (copy_to_user(user_buf, md, sizeof(struct mst_connectx_wa))) { + res = -EFAULT; +@@ -1177,7 +1197,7 @@ static int mst_ioctl(struct inode *inode, struct file *file, + + /* retrieve to user - we noticed that we need to swap always */ + dataout = &((struct mst_vpd_read4_st *)user_buf)->data; +- out = le32_to_cpu(out); ++ out = le32_to_cpu(out); + if (copy_to_user(dataout, &out, sizeof(u32))) { + res = -EFAULT; + goto fin; +@@ -1204,7 +1224,7 @@ static int mst_ioctl(struct inode *inode, struct file *file, + res = -EFAULT; + goto fin; + } +- writest.data = le32_to_cpu(writest.data); ++ writest.data = le32_to_cpu(writest.data); + res = pci_write4_vpd(dev, writest.timeout, writest.offset, writest.data); + if (res) { + goto fin; +@@ -1228,9 +1248,9 @@ fin_err: + } + + #if HAVE_COMPAT_IOCTL +-static long compat_ioctl (struct file *f, unsigned int o, unsigned long d) ++static long compat_ioctl(struct file *f, unsigned int o, unsigned long d) + { +-#if LINUX_VERSION_CODE < KERNEL_VERSION(3,18,0) ++#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 18, 0) + struct inode *n = f->f_dentry->d_inode; + #else + struct inode *n = f->f_path.dentry->d_inode; +@@ -1240,9 +1260,9 @@ static long compat_ioctl (struct file *f, unsigned int o, unsigned long d) + #endif + + #ifdef HAVE_UNLOCKED_IOCTL +-static long unlocked_ioctl (struct file *f, unsigned int o, unsigned long d) ++static long unlocked_ioctl(struct file *f, unsigned int o, unsigned long d) + { +-#if LINUX_VERSION_CODE < KERNEL_VERSION(3,18,0) ++#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 18, 0) + struct inode *n = f->f_dentry->d_inode; + #else + struct inode *n = f->f_path.dentry->d_inode; +@@ -1275,7 +1295,7 @@ static const struct file_operations mst_fops = { + .unlocked_ioctl = unlocked_ioctl, + #endif + +-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,35) ++#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 35) + .ioctl = mst_ioctl, + #endif + +@@ -1292,7 +1312,7 @@ static struct mst_dev_data *mst_device_create(enum dev_type type, + struct pci_dev *pdev) + { + struct mst_dev_data *dev = NULL; +- char dbdf[20]; ++ char dbdf[20]; + + dev = kzalloc(sizeof(struct mst_dev_data), GFP_KERNEL); + if (!dev) { +@@ -1302,7 +1322,7 @@ static struct mst_dev_data *mst_device_create(enum dev_type type, + return NULL; + } + +- sprintf(dbdf, "%4.4x:%2.2x:%2.2x.%1.1x", pci_domain_nr(pdev->bus), pdev->bus->number, PCI_SLOT(pdev->devfn), PCI_FUNC(pdev->devfn)); ++ sprintf(dbdf, "%4.4x:%2.2x:%2.2x.%1.1x", pci_domain_nr(pdev->bus), pdev->bus->number, PCI_SLOT(pdev->devfn), PCI_FUNC(pdev->devfn)); + switch (type) { + case PCICONF: + dev->addr_reg = MST_CONF_ADDR_REG; +@@ -1312,15 +1332,15 @@ static struct mst_dev_data *mst_device_create(enum dev_type type, + snprintf(dev->name, + MST_NAME_SIZE, + "%s" MST_PCICONF_DEVICE_NAME, +- dbdf); ++ dbdf); + + + break; + case PCIMEM: + dev->addr_reg = 0; /* invalid */ + dev->data_reg = 0; /* invalid */ +- dev->bar = 0; +- dev->hw_addr = ioremap(pci_resource_start(pdev, dev->bar), ++ dev->bar = 0; ++ dev->hw_addr = ioremap(pci_resource_start(pdev, dev->bar), + MST_MEMORY_SIZE); + if (dev->hw_addr <= 0) { + mst_err("could not map device memory, BAR: %x\n", dev->bar); +@@ -1345,19 +1365,20 @@ static struct mst_dev_data *mst_device_create(enum dev_type type, + dev->vpd_cap_addr = pci_find_capability(pdev, PCI_CAP_ID_VPD); + + if (alloc_chrdev_region(&dev->my_dev, 0, 1, dev->name)) { +- mst_err("failed to allocate chrdev_region\n"); ++ mst_err("failed to allocate chrdev_region\n"); + } +- if ( (dev->cl = class_create( THIS_MODULE, dev->name ) ) == NULL ) { +- printk(KERN_ALERT "Class creation failed\n"); +- unregister_chrdev_region(dev->my_dev, 1); +- goto out; ++ dev->cl = class_create(THIS_MODULE, dev->name) ++ if (dev->cl == NULL) { ++ printk(KERN_ALERT "Class creation failed\n"); ++ unregister_chrdev_region(dev->my_dev, 1); ++ goto out; + } + +- if( device_create(dev->cl, NULL, dev->my_dev, NULL, dev->name) == NULL) { +- printk(KERN_ALERT "Device creation failed\n"); +- class_destroy(dev->cl); +- unregister_chrdev_region(dev->my_dev , 1); +- goto out; ++ if (device_create(dev->cl, NULL, dev->my_dev, NULL, dev->name) == NULL) { ++ printk(KERN_ALERT "Device creation failed\n"); ++ class_destroy(dev->cl); ++ unregister_chrdev_region(dev->my_dev, 1); ++ goto out; + } + + dev->major = MAJOR(dev->my_dev); +@@ -1365,13 +1386,13 @@ static struct mst_dev_data *mst_device_create(enum dev_type type, + cdev_add(&dev->mcdev, dev->my_dev, 1); //TODO check if cdev_add fails + + if (type == PCICONF) { +- /* +- * Initialize 5th Gen attributes +- */ +- dev->wo_addr = is_wo_gw(dev->pci_dev, MST_CONF_ADDR_REG); +- dev->vendor_specific_cap = pci_find_capability(dev->pci_dev, MLNX_VENDOR_SPECIFIC_CAP_ID); +- //mst_info("VSEC SUPP: %#x\n", dev->vendor_specific_cap); +- dev->spaces_support_status = SS_UNINITIALIZED; // init on first op ++ /* ++ * Initialize 5th Gen attributes ++ */ ++ dev->wo_addr = is_wo_gw(dev->pci_dev, MST_CONF_ADDR_REG); ++ dev->vendor_specific_cap = pci_find_capability(dev->pci_dev, MLNX_VENDOR_SPECIFIC_CAP_ID); ++ //mst_info("VSEC SUPP: %#x\n", dev->vendor_specific_cap); ++ dev->spaces_support_status = SS_UNINITIALIZED; // init on first op + } + dev->initialized = 1; + list_add_tail(&dev->list, &mst_devices); +@@ -1389,10 +1410,10 @@ static void mst_device_destroy(struct mst_dev_data *dev) + iounmap(dev->hw_addr); + } + +- cdev_del(&dev->mcdev); +- device_destroy(dev->cl, dev->my_dev); +- class_destroy(dev->cl); +- unregister_chrdev_region(dev->my_dev, 1); ++ cdev_del(&dev->mcdev); ++ device_destroy(dev->cl, dev->my_dev); ++ class_destroy(dev->cl); ++ unregister_chrdev_region(dev->my_dev, 1); + list_del(&dev->list); + kfree(dev); + } +@@ -1410,9 +1431,9 @@ static int __init mst_init(void) + mst_info("%s - version %s\n", mst_driver_string, mst_driver_version); + + while ((pdev = pci_get_device(MST_MELLANOX_PCI_VENDOR, PCI_ANY_ID, pdev)) != NULL) { +- if (!pci_match_id(supported_pci_devices, pdev) && !pci_match_id(mst_livefish_pci_table, pdev)) { +- continue; +- } ++ if (!pci_match_id(supported_pci_devices, pdev) && !pci_match_id(mst_livefish_pci_table, pdev)) { ++ continue; ++ } + device_exists = 0; + list_for_each_entry(cur, &mst_devices, list) { + if (cur->pci_dev->bus->number == pdev->bus->number) { +@@ -1430,8 +1451,7 @@ static int __init mst_init(void) + } + + /* found new device */ +- mst_info("found device - " +- "domain=0x%x, bus=0x%x, slot=0x%x, func=0x%x, vendor=0x%x, device=0x%x\n", ++ mst_info("found device - domain=0x%x, bus=0x%x, slot=0x%x, func=0x%x, vendor=0x%x, device=0x%x\n", + pci_domain_nr(pdev->bus), + pdev->bus->number, + PCI_SLOT(pdev->devfn), +diff --git a/kernel/mst_vpd.c b/kernel/mst_vpd.c +index 36ebae1..60efa11 100644 +--- a/kernel/mst_vpd.c ++++ b/kernel/mst_vpd.c +@@ -37,7 +37,7 @@ + + /****************************************************/ + int pci_read4_vpd(struct mst_dev_data *dev, unsigned int timeout, +- unsigned offset, u32 *buf) ++ unsigned int offset, u32 *buf) + { + struct pci_dev *pci_dev = dev->pci_dev; + int vpd_cap = dev->vpd_cap_addr; +@@ -99,7 +99,7 @@ int pci_read4_vpd(struct mst_dev_data *dev, unsigned int timeout, + EXPORT_SYMBOL(pci_read4_vpd); + + int pci_write4_vpd(struct mst_dev_data *dev, unsigned int timeout, +- unsigned offset, u32 buf) ++ unsigned int offset, u32 buf) + { + struct pci_dev *pci_dev = dev->pci_dev; + int vpd_cap = dev->vpd_cap_addr; +-- +2.21.0 + diff --git a/mstflint.spec b/mstflint.spec index 72586d6..2b7f46f 100644 --- a/mstflint.spec +++ b/mstflint.spec @@ -1,13 +1,14 @@ Name: mstflint Summary: Firmware Burning and Diagnostics Tools Version: 4.10.0 -Release: 9 +Release: 10 License: GPLv2+ or BSD Url: https://github.com/Mellanox/mstflint Source: https://github.com/Mellanox/%{name}/releases/download/v4.10.0-2/%{name}-%{version}.tar.gz Patch0000: 0001-Fix-compile-errors.patch Patch0001: fix-return-local-addr.patch Patch0002: backport-0001-Title-Fix-error-while-burning-mcc-enabled.patch +Patch0003: backport-0001-Title-Fix-errors-found-with-checkpatch-script.patch BuildRequires: libstdc++-devel zlib-devel rdma-core-devel gcc-c++ gcc BuildRequires: libcurl-devel boost-devel libxml2-devel openssl-devel Obsoletes: openib-mstflint <= 1.4 openib-tvflash <= 0.9.2 tvflash <= 0.9.0 @@ -44,6 +45,9 @@ strip %{buildroot}/%{_libdir}/mstflint/python_tools/*.so %{_mandir}/man1/* %changelog +* Thu Jan 05 2023 chenmaodong - 4.10.0-10 +- Fix errors found with checkpatch script + * Thu Dec 29 2022 chenmaodong - 4.10.0-9 - Fix error while burning mcc enabled Description