Merge tag 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dledford/rdma

+2 -2

drivers/staging/rdma/hfi1/chip.c

··· 2710 2710 if (sleep_ok) { 2711 2711 mutex_lock(&ppd->hls_lock); 2712 2712 } else { 2713 - while (mutex_trylock(&ppd->hls_lock) == EBUSY) 2713 + while (!mutex_trylock(&ppd->hls_lock)) 2714 2714 udelay(1); 2715 2715 } 2716 2716 ··· 2758 2758 if (sleep_ok) { 2759 2759 mutex_lock(&dd->pport->hls_lock); 2760 2760 } else { 2761 - while (mutex_trylock(&dd->pport->hls_lock) == EBUSY) 2761 + while (!mutex_trylock(&dd->pport->hls_lock)) 2762 2762 udelay(1); 2763 2763 } 2764 2764

+48 -6

drivers/staging/rdma/hfi1/device.c

··· 57 57 #include "device.h" 58 58 59 59 static struct class *class; 60 + static struct class *user_class; 60 61 static dev_t hfi1_dev; 61 62 62 63 int hfi1_cdev_init(int minor, const char *name, 63 64 const struct file_operations *fops, 64 - struct cdev *cdev, struct device **devp) 65 + struct cdev *cdev, struct device **devp, 66 + bool user_accessible) 65 67 { 66 68 const dev_t dev = MKDEV(MAJOR(hfi1_dev), minor); 67 69 struct device *device = NULL; ··· 80 78 goto done; 81 79 } 82 80 83 - device = device_create(class, NULL, dev, NULL, "%s", name); 81 + if (user_accessible) 82 + device = device_create(user_class, NULL, dev, NULL, "%s", name); 83 + else 84 + device = device_create(class, NULL, dev, NULL, "%s", name); 85 + 84 86 if (!IS_ERR(device)) 85 87 goto done; 86 88 ret = PTR_ERR(device); ··· 116 110 return hfi1_class_name; 117 111 } 118 112 113 + static char *hfi1_devnode(struct device *dev, umode_t *mode) 114 + { 115 + if (mode) 116 + *mode = 0600; 117 + return kasprintf(GFP_KERNEL, "%s", dev_name(dev)); 118 + } 119 + 120 + static const char *hfi1_class_name_user = "hfi1_user"; 121 + const char *class_name_user(void) 122 + { 123 + return hfi1_class_name_user; 124 + } 125 + 126 + static char *hfi1_user_devnode(struct device *dev, umode_t *mode) 127 + { 128 + if (mode) 129 + *mode = 0666; 130 + return kasprintf(GFP_KERNEL, "%s", dev_name(dev)); 131 + } 132 + 119 133 int __init dev_init(void) 120 134 { 121 135 int ret; ··· 151 125 ret = PTR_ERR(class); 152 126 pr_err("Could not create device class (err %d)\n", -ret); 153 127 unregister_chrdev_region(hfi1_dev, HFI1_NMINORS); 128 + goto done; 154 129 } 130 + class->devnode = hfi1_devnode; 131 + 132 + user_class = class_create(THIS_MODULE, class_name_user()); 133 + if (IS_ERR(user_class)) { 134 + ret = PTR_ERR(user_class); 135 + pr_err("Could not create device class for user accessible files (err %d)\n", 136 + -ret); 137 + class_destroy(class); 138 + class = NULL; 139 + user_class = NULL; 140 + unregister_chrdev_region(hfi1_dev, HFI1_NMINORS); 141 + goto done; 142 + } 143 + user_class->devnode = hfi1_user_devnode; 155 144 156 145 done: 157 146 return ret; ··· 174 133 175 134 void dev_cleanup(void) 176 135 { 177 - if (class) { 178 - class_destroy(class); 179 - class = NULL; 180 - } 136 + class_destroy(class); 137 + class = NULL; 138 + 139 + class_destroy(user_class); 140 + user_class = NULL; 181 141 182 142 unregister_chrdev_region(hfi1_dev, HFI1_NMINORS); 183 143 }

+2 -1

drivers/staging/rdma/hfi1/device.h

··· 52 52 53 53 int hfi1_cdev_init(int minor, const char *name, 54 54 const struct file_operations *fops, 55 - struct cdev *cdev, struct device **devp); 55 + struct cdev *cdev, struct device **devp, 56 + bool user_accessible); 56 57 void hfi1_cdev_cleanup(struct cdev *cdev, struct device **devp); 57 58 const char *class_name(void); 58 59 int __init dev_init(void);

+18 -18

drivers/staging/rdma/hfi1/diag.c

··· 292 292 if (atomic_inc_return(&diagpkt_count) == 1) { 293 293 ret = hfi1_cdev_init(HFI1_DIAGPKT_MINOR, name, 294 294 &diagpkt_file_ops, &diagpkt_cdev, 295 - &diagpkt_device); 295 + &diagpkt_device, false); 296 296 } 297 297 298 298 return ret; ··· 592 592 593 593 ret = hfi1_cdev_init(HFI1_SNOOP_CAPTURE_BASE + dd->unit, name, 594 594 &snoop_file_ops, 595 - &dd->hfi1_snoop.cdev, &dd->hfi1_snoop.class_dev); 595 + &dd->hfi1_snoop.cdev, &dd->hfi1_snoop.class_dev, 596 + false); 596 597 597 598 if (ret) { 598 599 dd_dev_err(dd, "Couldn't create %s device: %d", name, ret); ··· 1013 1012 case HFI1_SNOOP_IOCSETLINKSTATE_EXTRA: 1014 1013 memset(&link_info, 0, sizeof(link_info)); 1015 1014 1016 - ret = copy_from_user(&link_info, 1015 + if (copy_from_user(&link_info, 1017 1016 (struct hfi1_link_info __user *)arg, 1018 - sizeof(link_info)); 1019 - if (ret) 1020 - break; 1017 + sizeof(link_info))) 1018 + ret = -EFAULT; 1021 1019 1022 1020 value = link_info.port_state; 1023 1021 index = link_info.port_number; ··· 1080 1080 case HFI1_SNOOP_IOCGETLINKSTATE_EXTRA: 1081 1081 if (cmd == HFI1_SNOOP_IOCGETLINKSTATE_EXTRA) { 1082 1082 memset(&link_info, 0, sizeof(link_info)); 1083 - ret = copy_from_user(&link_info, 1083 + if (copy_from_user(&link_info, 1084 1084 (struct hfi1_link_info __user *)arg, 1085 - sizeof(link_info)); 1085 + sizeof(link_info))) 1086 + ret = -EFAULT; 1086 1087 index = link_info.port_number; 1087 1088 } else { 1088 1089 ret = __get_user(index, (int __user *) arg); ··· 1115 1114 ppd->link_speed_active; 1116 1115 link_info.link_width_active = 1117 1116 ppd->link_width_active; 1118 - ret = copy_to_user( 1117 + if (copy_to_user( 1119 1118 (struct hfi1_link_info __user *)arg, 1120 - &link_info, sizeof(link_info)); 1119 + &link_info, sizeof(link_info))) 1120 + ret = -EFAULT; 1121 1121 } else { 1122 1122 ret = __put_user(value, (int __user *)arg); 1123 1123 } ··· 1144 1142 snoop_dbg("Setting filter"); 1145 1143 /* just copy command structure */ 1146 1144 argp = (unsigned long *)arg; 1147 - ret = copy_from_user(&filter_cmd, (void __user *)argp, 1148 - sizeof(filter_cmd)); 1149 - if (ret < 0) { 1150 - pr_alert("Error copying filter command\n"); 1145 + if (copy_from_user(&filter_cmd, (void __user *)argp, 1146 + sizeof(filter_cmd))) { 1147 + ret = -EFAULT; 1151 1148 break; 1152 1149 } 1153 1150 if (filter_cmd.opcode >= HFI1_MAX_FILTERS) { ··· 1168 1167 break; 1169 1168 } 1170 1169 /* copy remaining data from userspace */ 1171 - ret = copy_from_user((u8 *)filter_value, 1170 + if (copy_from_user((u8 *)filter_value, 1172 1171 (void __user *)filter_cmd.value_ptr, 1173 - filter_cmd.length); 1174 - if (ret < 0) { 1172 + filter_cmd.length)) { 1175 1173 kfree(filter_value); 1176 - pr_alert("Error copying filter data\n"); 1174 + ret = -EFAULT; 1177 1175 break; 1178 1176 } 1179 1177 /* Drain packets first */

+7 -3

drivers/staging/rdma/hfi1/file_ops.c

··· 1181 1181 struct hfi1_filedata *fd = fp->private_data; 1182 1182 int ret = 0; 1183 1183 1184 + memset(&cinfo, 0, sizeof(cinfo)); 1184 1185 ret = hfi1_get_base_kinfo(uctxt, &cinfo); 1185 1186 if (ret < 0) 1186 1187 goto done; ··· 2090 2089 2091 2090 if (atomic_inc_return(&user_count) == 1) { 2092 2091 ret = hfi1_cdev_init(0, class_name(), &hfi1_file_ops, 2093 - &wildcard_cdev, &wildcard_device); 2092 + &wildcard_cdev, &wildcard_device, 2093 + true); 2094 2094 if (ret) 2095 2095 goto done; 2096 2096 } 2097 2097 2098 2098 snprintf(name, sizeof(name), "%s_%d", class_name(), dd->unit); 2099 2099 ret = hfi1_cdev_init(dd->unit + 1, name, &hfi1_file_ops, 2100 - &dd->user_cdev, &dd->user_device); 2100 + &dd->user_cdev, &dd->user_device, 2101 + true); 2101 2102 if (ret) 2102 2103 goto done; 2103 2104 ··· 2107 2104 snprintf(name, sizeof(name), 2108 2105 "%s_ui%d", class_name(), dd->unit); 2109 2106 ret = hfi1_cdev_init(dd->unit + UI_OFFSET, name, &ui_file_ops, 2110 - &dd->ui_cdev, &dd->ui_device); 2107 + &dd->ui_cdev, &dd->ui_device, 2108 + false); 2111 2109 if (ret) 2112 2110 goto done; 2113 2111 }

+2 -2

drivers/staging/rdma/hfi1/mad.c

··· 1717 1717 psi->port_states.portphysstate_portstate = 1718 1718 (hfi1_ibphys_portstate(ppd) << 4) | (lstate & 0xf); 1719 1719 psi->link_width_downgrade_tx_active = 1720 - ppd->link_width_downgrade_tx_active; 1720 + cpu_to_be16(ppd->link_width_downgrade_tx_active); 1721 1721 psi->link_width_downgrade_rx_active = 1722 - ppd->link_width_downgrade_rx_active; 1722 + cpu_to_be16(ppd->link_width_downgrade_rx_active); 1723 1723 if (resp_len) 1724 1724 *resp_len += sizeof(struct opa_port_state_info); 1725 1725

+3 -3

drivers/staging/rdma/hfi1/sdma.c

··· 737 737 */ 738 738 if (!is_power_of_2(count)) 739 739 return SDMA_DESCQ_CNT; 740 - if (count < 64 && count > 32768) 740 + if (count < 64 || count > 32768) 741 741 return SDMA_DESCQ_CNT; 742 742 return count; 743 743 } ··· 1848 1848 dd_dev_err(sde->dd, 1849 1849 "\taidx: %u amode: %u alen: %u\n", 1850 1850 (u8)((desc[1] & SDMA_DESC1_HEADER_INDEX_SMASK) 1851 - >> SDMA_DESC1_HEADER_INDEX_MASK), 1851 + >> SDMA_DESC1_HEADER_INDEX_SHIFT), 1852 1852 (u8)((desc[1] & SDMA_DESC1_HEADER_MODE_SMASK) 1853 1853 >> SDMA_DESC1_HEADER_MODE_SHIFT), 1854 1854 (u8)((desc[1] & SDMA_DESC1_HEADER_DWS_SMASK) ··· 1926 1926 if (desc[0] & SDMA_DESC0_FIRST_DESC_FLAG) 1927 1927 seq_printf(s, "\t\tahgidx: %u ahgmode: %u\n", 1928 1928 (u8)((desc[1] & SDMA_DESC1_HEADER_INDEX_SMASK) 1929 - >> SDMA_DESC1_HEADER_INDEX_MASK), 1929 + >> SDMA_DESC1_HEADER_INDEX_SHIFT), 1930 1930 (u8)((desc[1] & SDMA_DESC1_HEADER_MODE_SMASK) 1931 1931 >> SDMA_DESC1_HEADER_MODE_SHIFT)); 1932 1932 head = (head + 1) & sde->sdma_mask;

+18 -18

drivers/staging/rdma/hfi1/sdma.h

··· 109 109 /* 110 110 * Bits defined in the send DMA descriptor. 111 111 */ 112 - #define SDMA_DESC0_FIRST_DESC_FLAG (1ULL<<63) 113 - #define SDMA_DESC0_LAST_DESC_FLAG (1ULL<<62) 112 + #define SDMA_DESC0_FIRST_DESC_FLAG (1ULL << 63) 113 + #define SDMA_DESC0_LAST_DESC_FLAG (1ULL << 62) 114 114 #define SDMA_DESC0_BYTE_COUNT_SHIFT 48 115 115 #define SDMA_DESC0_BYTE_COUNT_WIDTH 14 116 116 #define SDMA_DESC0_BYTE_COUNT_MASK \ 117 - ((1ULL<<SDMA_DESC0_BYTE_COUNT_WIDTH)-1ULL) 117 + ((1ULL << SDMA_DESC0_BYTE_COUNT_WIDTH) - 1) 118 118 #define SDMA_DESC0_BYTE_COUNT_SMASK \ 119 - (SDMA_DESC0_BYTE_COUNT_MASK<<SDMA_DESC0_BYTE_COUNT_SHIFT) 119 + (SDMA_DESC0_BYTE_COUNT_MASK << SDMA_DESC0_BYTE_COUNT_SHIFT) 120 120 #define SDMA_DESC0_PHY_ADDR_SHIFT 0 121 121 #define SDMA_DESC0_PHY_ADDR_WIDTH 48 122 122 #define SDMA_DESC0_PHY_ADDR_MASK \ 123 - ((1ULL<<SDMA_DESC0_PHY_ADDR_WIDTH)-1ULL) 123 + ((1ULL << SDMA_DESC0_PHY_ADDR_WIDTH) - 1) 124 124 #define SDMA_DESC0_PHY_ADDR_SMASK \ 125 - (SDMA_DESC0_PHY_ADDR_MASK<<SDMA_DESC0_PHY_ADDR_SHIFT) 125 + (SDMA_DESC0_PHY_ADDR_MASK << SDMA_DESC0_PHY_ADDR_SHIFT) 126 126 127 127 #define SDMA_DESC1_HEADER_UPDATE1_SHIFT 32 128 128 #define SDMA_DESC1_HEADER_UPDATE1_WIDTH 32 129 129 #define SDMA_DESC1_HEADER_UPDATE1_MASK \ 130 - ((1ULL<<SDMA_DESC1_HEADER_UPDATE1_WIDTH)-1ULL) 130 + ((1ULL << SDMA_DESC1_HEADER_UPDATE1_WIDTH) - 1) 131 131 #define SDMA_DESC1_HEADER_UPDATE1_SMASK \ 132 - (SDMA_DESC1_HEADER_UPDATE1_MASK<<SDMA_DESC1_HEADER_UPDATE1_SHIFT) 132 + (SDMA_DESC1_HEADER_UPDATE1_MASK << SDMA_DESC1_HEADER_UPDATE1_SHIFT) 133 133 #define SDMA_DESC1_HEADER_MODE_SHIFT 13 134 134 #define SDMA_DESC1_HEADER_MODE_WIDTH 3 135 135 #define SDMA_DESC1_HEADER_MODE_MASK \ 136 - ((1ULL<<SDMA_DESC1_HEADER_MODE_WIDTH)-1ULL) 136 + ((1ULL << SDMA_DESC1_HEADER_MODE_WIDTH) - 1) 137 137 #define SDMA_DESC1_HEADER_MODE_SMASK \ 138 - (SDMA_DESC1_HEADER_MODE_MASK<<SDMA_DESC1_HEADER_MODE_SHIFT) 138 + (SDMA_DESC1_HEADER_MODE_MASK << SDMA_DESC1_HEADER_MODE_SHIFT) 139 139 #define SDMA_DESC1_HEADER_INDEX_SHIFT 8 140 140 #define SDMA_DESC1_HEADER_INDEX_WIDTH 5 141 141 #define SDMA_DESC1_HEADER_INDEX_MASK \ 142 - ((1ULL<<SDMA_DESC1_HEADER_INDEX_WIDTH)-1ULL) 142 + ((1ULL << SDMA_DESC1_HEADER_INDEX_WIDTH) - 1) 143 143 #define SDMA_DESC1_HEADER_INDEX_SMASK \ 144 - (SDMA_DESC1_HEADER_INDEX_MASK<<SDMA_DESC1_HEADER_INDEX_SHIFT) 144 + (SDMA_DESC1_HEADER_INDEX_MASK << SDMA_DESC1_HEADER_INDEX_SHIFT) 145 145 #define SDMA_DESC1_HEADER_DWS_SHIFT 4 146 146 #define SDMA_DESC1_HEADER_DWS_WIDTH 4 147 147 #define SDMA_DESC1_HEADER_DWS_MASK \ 148 - ((1ULL<<SDMA_DESC1_HEADER_DWS_WIDTH)-1ULL) 148 + ((1ULL << SDMA_DESC1_HEADER_DWS_WIDTH) - 1) 149 149 #define SDMA_DESC1_HEADER_DWS_SMASK \ 150 - (SDMA_DESC1_HEADER_DWS_MASK<<SDMA_DESC1_HEADER_DWS_SHIFT) 150 + (SDMA_DESC1_HEADER_DWS_MASK << SDMA_DESC1_HEADER_DWS_SHIFT) 151 151 #define SDMA_DESC1_GENERATION_SHIFT 2 152 152 #define SDMA_DESC1_GENERATION_WIDTH 2 153 153 #define SDMA_DESC1_GENERATION_MASK \ 154 - ((1ULL<<SDMA_DESC1_GENERATION_WIDTH)-1ULL) 154 + ((1ULL << SDMA_DESC1_GENERATION_WIDTH) - 1) 155 155 #define SDMA_DESC1_GENERATION_SMASK \ 156 - (SDMA_DESC1_GENERATION_MASK<<SDMA_DESC1_GENERATION_SHIFT) 157 - #define SDMA_DESC1_INT_REQ_FLAG (1ULL<<1) 158 - #define SDMA_DESC1_HEAD_TO_HOST_FLAG (1ULL<<0) 156 + (SDMA_DESC1_GENERATION_MASK << SDMA_DESC1_GENERATION_SHIFT) 157 + #define SDMA_DESC1_INT_REQ_FLAG (1ULL << 1) 158 + #define SDMA_DESC1_HEAD_TO_HOST_FLAG (1ULL << 0) 159 159 160 160 enum sdma_states { 161 161 sdma_state_s00_hw_down,

+5 -3

drivers/staging/rdma/hfi1/verbs.c

··· 749 749 struct verbs_txreq *tx; 750 750 751 751 tx = kmem_cache_alloc(dev->verbs_txreq_cache, GFP_ATOMIC); 752 - if (!tx) 752 + if (!tx) { 753 753 /* call slow path to get the lock */ 754 754 tx = __get_txreq(dev, qp); 755 - if (tx) 756 - tx->qp = qp; 755 + if (IS_ERR(tx)) 756 + return tx; 757 + } 758 + tx->qp = qp; 757 759 return tx; 758 760 } 759 761

+2 -2

include/rdma/opa_port_info.h

··· 294 294 295 295 struct opa_port_state_info { 296 296 struct opa_port_states port_states; 297 - u16 link_width_downgrade_tx_active; 298 - u16 link_width_downgrade_rx_active; 297 + __be16 link_width_downgrade_tx_active; 298 + __be16 link_width_downgrade_rx_active; 299 299 }; 300 300 301 301 struct opa_port_info {

Configure Feed

Configure Feed