Merge branch 'mellanox' into k.o/for-next (a1139697) · Commits · e / devices / android_kernel_fairphone_FP5

drivers/infiniband/core/cache.c

+8 −15

Original line number	Original line	Diff line number	Diff line
	@@ -1199,30 +1199,23 @@ int ib_cache_setup_one(struct ib_device *device)
	device->cache.ports =		device->cache.ports =
	kzalloc(sizeof(device->cache.ports)		kzalloc(sizeof(device->cache.ports)
	(rdma_end_port(device) - rdma_start_port(device) + 1), GFP_KERNEL);		(rdma_end_port(device) - rdma_start_port(device) + 1), GFP_KERNEL);
	if (!device->cache.ports) {		if (!device->cache.ports)
	err = -ENOMEM;		return -ENOMEM;
	goto out;
	}

	err = gid_table_setup_one(device);		err = gid_table_setup_one(device);
	if (err)		if (err) {
	goto out;		kfree(device->cache.ports);
			device->cache.ports = NULL;
			return err;
			}

	for (p = 0; p <= rdma_end_port(device) - rdma_start_port(device); ++p)		for (p = 0; p <= rdma_end_port(device) - rdma_start_port(device); ++p)
	ib_cache_update(device, p + rdma_start_port(device), true);		ib_cache_update(device, p + rdma_start_port(device), true);

	INIT_IB_EVENT_HANDLER(&device->cache.event_handler,		INIT_IB_EVENT_HANDLER(&device->cache.event_handler,
	device, ib_cache_event);		device, ib_cache_event);
	err = ib_register_event_handler(&device->cache.event_handler);		ib_register_event_handler(&device->cache.event_handler);
	if (err)
	goto err;

	return 0;		return 0;

	err:
	gid_table_cleanup_one(device);
	out:
	return err;
	}		}

	void ib_cache_release_one(struct ib_device *device)		void ib_cache_release_one(struct ib_device *device)

drivers/infiniband/core/cma.c

+2 −2

Original line number	Original line	Diff line number	Diff line
	@@ -72,7 +72,7 @@ MODULE_LICENSE("Dual BSD/GPL");
	#define CMA_MAX_CM_RETRIES 15		#define CMA_MAX_CM_RETRIES 15
	#define CMA_CM_MRA_SETTING (IB_CM_MRA_FLAG_DELAY \| 24)		#define CMA_CM_MRA_SETTING (IB_CM_MRA_FLAG_DELAY \| 24)
	#define CMA_IBOE_PACKET_LIFETIME 18		#define CMA_IBOE_PACKET_LIFETIME 18
	#define CMA_PREFERRED_ROCE_GID_TYPE (1 << IB_GID_TYPE_ROCE_UDP_ENCAP)		#define CMA_PREFERRED_ROCE_GID_TYPE IB_GID_TYPE_ROCE_UDP_ENCAP

	static const char * const cma_events[] = {		static const char * const cma_events[] = {
	[RDMA_CM_EVENT_ADDR_RESOLVED] = "address resolved",		[RDMA_CM_EVENT_ADDR_RESOLVED] = "address resolved",
	@@ -4282,7 +4282,7 @@ static void cma_add_one(struct ib_device *device)
	for (i = rdma_start_port(device); i <= rdma_end_port(device); i++) {		for (i = rdma_start_port(device); i <= rdma_end_port(device); i++) {
	supported_gids = roce_gid_type_mask_support(device, i);		supported_gids = roce_gid_type_mask_support(device, i);
	WARN_ON(!supported_gids);		WARN_ON(!supported_gids);
	if (supported_gids & CMA_PREFERRED_ROCE_GID_TYPE)		if (supported_gids & (1 << CMA_PREFERRED_ROCE_GID_TYPE))
	cma_dev->default_gid_type[i - rdma_start_port(device)] =		cma_dev->default_gid_type[i - rdma_start_port(device)] =
	CMA_PREFERRED_ROCE_GID_TYPE;		CMA_PREFERRED_ROCE_GID_TYPE;
	else		else

drivers/infiniband/core/device.c

+2 −6

drivers/infiniband/core/sa_query.c

+1 −2

Original line number	Original line	Diff line number	Diff line
	@@ -2417,8 +2417,7 @@ static void ib_sa_add_one(struct ib_device *device)
	*/		*/

	INIT_IB_EVENT_HANDLER(&sa_dev->event_handler, device, ib_sa_event);		INIT_IB_EVENT_HANDLER(&sa_dev->event_handler, device, ib_sa_event);
	if (ib_register_event_handler(&sa_dev->event_handler))		ib_register_event_handler(&sa_dev->event_handler);
	goto err;

	for (i = 0; i <= e - s; ++i) {		for (i = 0; i <= e - s; ++i) {
	if (rdma_cap_ib_sa(device, i + 1))		if (rdma_cap_ib_sa(device, i + 1))

drivers/infiniband/core/uverbs_cmd.c

+51 −76

Original line number	Original line	Diff line number	Diff line
	@@ -1820,6 +1820,28 @@ ssize_t ib_uverbs_open_qp(struct ib_uverbs_file *file,
	return ret;		return ret;
	}		}

			static void copy_ah_attr_to_uverbs(struct ib_uverbs_qp_dest *uverb_attr,
			struct rdma_ah_attr *rdma_attr)
			{
			const struct ib_global_route *grh;

			uverb_attr->dlid = rdma_ah_get_dlid(rdma_attr);
			uverb_attr->sl = rdma_ah_get_sl(rdma_attr);
			uverb_attr->src_path_bits = rdma_ah_get_path_bits(rdma_attr);
			uverb_attr->static_rate = rdma_ah_get_static_rate(rdma_attr);
			uverb_attr->is_global = !!(rdma_ah_get_ah_flags(rdma_attr) &
			IB_AH_GRH);
			if (uverb_attr->is_global) {
			grh = rdma_ah_read_grh(rdma_attr);
			memcpy(uverb_attr->dgid, grh->dgid.raw, 16);
			uverb_attr->flow_label = grh->flow_label;
			uverb_attr->sgid_index = grh->sgid_index;
			uverb_attr->hop_limit = grh->hop_limit;
			uverb_attr->traffic_class = grh->traffic_class;
			}
			uverb_attr->port_num = rdma_ah_get_port_num(rdma_attr);
			}

	ssize_t ib_uverbs_query_qp(struct ib_uverbs_file *file,		ssize_t ib_uverbs_query_qp(struct ib_uverbs_file *file,
	struct ib_device *ib_dev,		struct ib_device *ib_dev,
	const char __user *buf, int in_len,		const char __user *buf, int in_len,
	@@ -1830,7 +1852,6 @@ ssize_t ib_uverbs_query_qp(struct ib_uverbs_file *file,
	struct ib_qp *qp;		struct ib_qp *qp;
	struct ib_qp_attr *attr;		struct ib_qp_attr *attr;
	struct ib_qp_init_attr *init_attr;		struct ib_qp_init_attr *init_attr;
	const struct ib_global_route *grh;
	int ret;		int ret;

	if (copy_from_user(&cmd, buf, sizeof cmd))		if (copy_from_user(&cmd, buf, sizeof cmd))
	@@ -1880,39 +1901,8 @@ ssize_t ib_uverbs_query_qp(struct ib_uverbs_file *file,
	resp.alt_port_num = attr->alt_port_num;		resp.alt_port_num = attr->alt_port_num;
	resp.alt_timeout = attr->alt_timeout;		resp.alt_timeout = attr->alt_timeout;

	resp.dest.dlid = rdma_ah_get_dlid(&attr->ah_attr);		copy_ah_attr_to_uverbs(&resp.dest, &attr->ah_attr);
	resp.dest.sl = rdma_ah_get_sl(&attr->ah_attr);		copy_ah_attr_to_uverbs(&resp.alt_dest, &attr->alt_ah_attr);
	resp.dest.src_path_bits = rdma_ah_get_path_bits(&attr->ah_attr);
	resp.dest.static_rate = rdma_ah_get_static_rate(&attr->ah_attr);
	resp.dest.is_global = !!(rdma_ah_get_ah_flags(&attr->ah_attr) &
	IB_AH_GRH);
	if (resp.dest.is_global) {
	grh = rdma_ah_read_grh(&attr->ah_attr);
	memcpy(resp.dest.dgid, grh->dgid.raw, 16);
	resp.dest.flow_label = grh->flow_label;
	resp.dest.sgid_index = grh->sgid_index;
	resp.dest.hop_limit = grh->hop_limit;
	resp.dest.traffic_class = grh->traffic_class;
	}
	resp.dest.port_num = rdma_ah_get_port_num(&attr->ah_attr);

	resp.alt_dest.dlid = rdma_ah_get_dlid(&attr->alt_ah_attr);
	resp.alt_dest.sl = rdma_ah_get_sl(&attr->alt_ah_attr);
	resp.alt_dest.src_path_bits = rdma_ah_get_path_bits(&attr->alt_ah_attr);
	resp.alt_dest.static_rate
	= rdma_ah_get_static_rate(&attr->alt_ah_attr);
	resp.alt_dest.is_global
	= !!(rdma_ah_get_ah_flags(&attr->alt_ah_attr) &
	IB_AH_GRH);
	if (resp.alt_dest.is_global) {
	grh = rdma_ah_read_grh(&attr->alt_ah_attr);
	memcpy(resp.alt_dest.dgid, grh->dgid.raw, 16);
	resp.alt_dest.flow_label = grh->flow_label;
	resp.alt_dest.sgid_index = grh->sgid_index;
	resp.alt_dest.hop_limit = grh->hop_limit;
	resp.alt_dest.traffic_class = grh->traffic_class;
	}
	resp.alt_dest.port_num = rdma_ah_get_port_num(&attr->alt_ah_attr);

	resp.max_send_wr = init_attr->cap.max_send_wr;		resp.max_send_wr = init_attr->cap.max_send_wr;
	resp.max_recv_wr = init_attr->cap.max_recv_wr;		resp.max_recv_wr = init_attr->cap.max_recv_wr;
	@@ -1946,6 +1936,29 @@ static int modify_qp_mask(enum ib_qp_type qp_type, int mask)
	}		}
	}		}

			static void copy_ah_attr_from_uverbs(struct ib_device *dev,
			struct rdma_ah_attr *rdma_attr,
			struct ib_uverbs_qp_dest *uverb_attr)
			{
			rdma_attr->type = rdma_ah_find_type(dev, uverb_attr->port_num);
			if (uverb_attr->is_global) {
			rdma_ah_set_grh(rdma_attr, NULL,
			uverb_attr->flow_label,
			uverb_attr->sgid_index,
			uverb_attr->hop_limit,
			uverb_attr->traffic_class);
			rdma_ah_set_dgid_raw(rdma_attr, uverb_attr->dgid);
			} else {
			rdma_ah_set_ah_flags(rdma_attr, 0);
			}
			rdma_ah_set_dlid(rdma_attr, uverb_attr->dlid);
			rdma_ah_set_sl(rdma_attr, uverb_attr->sl);
			rdma_ah_set_path_bits(rdma_attr, uverb_attr->src_path_bits);
			rdma_ah_set_static_rate(rdma_attr, uverb_attr->static_rate);
			rdma_ah_set_port_num(rdma_attr, uverb_attr->port_num);
			rdma_ah_set_make_grd(rdma_attr, false);
			}

	static int modify_qp(struct ib_uverbs_file *file,		static int modify_qp(struct ib_uverbs_file *file,
	struct ib_uverbs_ex_modify_qp cmd, struct ib_udata udata)		struct ib_uverbs_ex_modify_qp cmd, struct ib_udata udata)
	{		{
	@@ -1993,50 +2006,12 @@ static int modify_qp(struct ib_uverbs_file *file,
	attr->rate_limit = cmd->rate_limit;		attr->rate_limit = cmd->rate_limit;

	if (cmd->base.attr_mask & IB_QP_AV)		if (cmd->base.attr_mask & IB_QP_AV)
	attr->ah_attr.type = rdma_ah_find_type(qp->device,		copy_ah_attr_from_uverbs(qp->device, &attr->ah_attr,
	cmd->base.dest.port_num);		&cmd->base.dest);
	if (cmd->base.dest.is_global) {
	rdma_ah_set_grh(&attr->ah_attr, NULL,
	cmd->base.dest.flow_label,
	cmd->base.dest.sgid_index,
	cmd->base.dest.hop_limit,
	cmd->base.dest.traffic_class);
	rdma_ah_set_dgid_raw(&attr->ah_attr, cmd->base.dest.dgid);
	} else {
	rdma_ah_set_ah_flags(&attr->ah_attr, 0);
	}
	rdma_ah_set_dlid(&attr->ah_attr, cmd->base.dest.dlid);
	rdma_ah_set_sl(&attr->ah_attr, cmd->base.dest.sl);
	rdma_ah_set_path_bits(&attr->ah_attr, cmd->base.dest.src_path_bits);
	rdma_ah_set_static_rate(&attr->ah_attr, cmd->base.dest.static_rate);
	rdma_ah_set_port_num(&attr->ah_attr,
	cmd->base.dest.port_num);
	rdma_ah_set_make_grd(&attr->ah_attr, false);

	if (cmd->base.attr_mask & IB_QP_ALT_PATH)		if (cmd->base.attr_mask & IB_QP_ALT_PATH)
	attr->alt_ah_attr.type =		copy_ah_attr_from_uverbs(qp->device, &attr->alt_ah_attr,
	rdma_ah_find_type(qp->device, cmd->base.dest.port_num);		&cmd->base.alt_dest);
	if (cmd->base.alt_dest.is_global) {
	rdma_ah_set_grh(&attr->alt_ah_attr, NULL,
	cmd->base.alt_dest.flow_label,
	cmd->base.alt_dest.sgid_index,
	cmd->base.alt_dest.hop_limit,
	cmd->base.alt_dest.traffic_class);
	rdma_ah_set_dgid_raw(&attr->alt_ah_attr,
	cmd->base.alt_dest.dgid);
	} else {
	rdma_ah_set_ah_flags(&attr->alt_ah_attr, 0);
	}

	rdma_ah_set_dlid(&attr->alt_ah_attr, cmd->base.alt_dest.dlid);
	rdma_ah_set_sl(&attr->alt_ah_attr, cmd->base.alt_dest.sl);
	rdma_ah_set_path_bits(&attr->alt_ah_attr,
	cmd->base.alt_dest.src_path_bits);
	rdma_ah_set_static_rate(&attr->alt_ah_attr,
	cmd->base.alt_dest.static_rate);
	rdma_ah_set_port_num(&attr->alt_ah_attr,
	cmd->base.alt_dest.port_num);
	rdma_ah_set_make_grd(&attr->alt_ah_attr, false);

	ret = ib_modify_qp_with_udata(qp, attr,		ret = ib_modify_qp_with_udata(qp, attr,
	modify_qp_mask(qp->qp_type,		modify_qp_mask(qp->qp_type,

Original line number	Original line	Diff line number	Diff line
	@@ -747,7 +747,7 @@ EXPORT_SYMBOL(ib_set_client_data);
	* chapter 11 of the InfiniBand Architecture Specification). This		* chapter 11 of the InfiniBand Architecture Specification). This
	* callback may occur in interrupt context.		* callback may occur in interrupt context.
	*/		*/
	int ib_register_event_handler (struct ib_event_handler *event_handler)		void ib_register_event_handler(struct ib_event_handler *event_handler)
	{		{
	unsigned long flags;		unsigned long flags;

	@@ -755,8 +755,6 @@ int ib_register_event_handler (struct ib_event_handler *event_handler)
	list_add_tail(&event_handler->list,		list_add_tail(&event_handler->list,
	&event_handler->device->event_handler_list);		&event_handler->device->event_handler_list);
	spin_unlock_irqrestore(&event_handler->device->event_handler_lock, flags);		spin_unlock_irqrestore(&event_handler->device->event_handler_lock, flags);

	return 0;
	}		}
	EXPORT_SYMBOL(ib_register_event_handler);		EXPORT_SYMBOL(ib_register_event_handler);

	@@ -767,15 +765,13 @@ EXPORT_SYMBOL(ib_register_event_handler);
	* Unregister an event handler registered with		* Unregister an event handler registered with
	* ib_register_event_handler().		* ib_register_event_handler().
	*/		*/
	int ib_unregister_event_handler(struct ib_event_handler *event_handler)		void ib_unregister_event_handler(struct ib_event_handler *event_handler)
	{		{
	unsigned long flags;		unsigned long flags;

	spin_lock_irqsave(&event_handler->device->event_handler_lock, flags);		spin_lock_irqsave(&event_handler->device->event_handler_lock, flags);
	list_del(&event_handler->list);		list_del(&event_handler->list);
	spin_unlock_irqrestore(&event_handler->device->event_handler_lock, flags);		spin_unlock_irqrestore(&event_handler->device->event_handler_lock, flags);

	return 0;
	}		}
	EXPORT_SYMBOL(ib_unregister_event_handler);		EXPORT_SYMBOL(ib_unregister_event_handler);