Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit c8c81de9 authored by David S. Miller's avatar David S. Miller
Browse files

Merge branch 's390-qeth-updates' 



Julian Wiedmann says:

====================
s390/qeth: updates 2018-07-11

please apply this first batch of qeth patches for net-next. It brings the
usual cleanups, and some performance improvements to the transmit paths.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 0761680d fb321f25

drivers/s390/net/qeth_core.h

+13 −9
Original line number Diff line number Diff line
@@ -465,7 +465,6 @@ struct qeth_qdio_out_buffer { 
	struct sk_buff_head skb_list;

	int is_header[QDIO_MAX_ELEMENTS_PER_BUFFER];



	struct qaob *aob;

	struct qeth_qdio_out_q *q;

	struct qeth_qdio_out_buffer *next_pending;

};
@@ -662,7 +661,6 @@ struct qeth_card_info { 
	int portno;

	enum qeth_card_types type;

	enum qeth_link_types link_type;

	int is_multicast_different;

	int initial_mtu;

	int max_mtu;

	int broadcast_capable;
@@ -935,6 +933,19 @@ static inline int qeth_send_simple_setassparms_v6(struct qeth_card *card, 
						 data, QETH_PROT_IPV6);

}



int qeth_get_priority_queue(struct qeth_card *card, struct sk_buff *skb,

			    int ipv);

static inline struct qeth_qdio_out_q *qeth_get_tx_queue(struct qeth_card *card,

							struct sk_buff *skb,

							int ipv, int cast_type)

{

	if (IS_IQD(card) && cast_type != RTN_UNICAST)

		return card->qdio.out_qs[card->qdio.no_out_queues - 1];

	if (!card->qdio.do_prio_queueing)

		return card->qdio.out_qs[card->qdio.default_out_queue];

	return card->qdio.out_qs[qeth_get_priority_queue(card, skb, ipv)];

}



extern struct qeth_discipline qeth_l2_discipline;

extern struct qeth_discipline qeth_l3_discipline;

extern const struct attribute_group *qeth_generic_attr_groups[];
@@ -972,7 +983,6 @@ int qeth_send_ipa_cmd(struct qeth_card *, struct qeth_cmd_buffer *, 
		  void *);

struct qeth_cmd_buffer *qeth_get_ipacmd_buffer(struct qeth_card *,

			enum qeth_ipa_cmds, enum qeth_prot_versions);

int qeth_query_setadapterparms(struct qeth_card *);

struct sk_buff *qeth_core_get_next_skb(struct qeth_card *,

		struct qeth_qdio_buffer *, struct qdio_buffer_element **, int *,

		struct qeth_hdr **);
@@ -998,11 +1008,6 @@ int qeth_query_switch_attributes(struct qeth_card *card, 
int qeth_send_control_data(struct qeth_card *, int, struct qeth_cmd_buffer *,

	int (*reply_cb)(struct qeth_card *, struct qeth_reply*, unsigned long),

	void *reply_param);

int qeth_bridgeport_query_ports(struct qeth_card *card,

	enum qeth_sbp_roles *role, enum qeth_sbp_states *state);

int qeth_bridgeport_setrole(struct qeth_card *card, enum qeth_sbp_roles role);

int qeth_bridgeport_an_set(struct qeth_card *card, int enable);

int qeth_get_priority_queue(struct qeth_card *, struct sk_buff *, int, int);

int qeth_get_elements_no(struct qeth_card *card, struct sk_buff *skb,

			 int extra_elems, int data_offset);

int qeth_get_elements_for_frags(struct sk_buff *);
@@ -1026,7 +1031,6 @@ int qeth_set_access_ctrl_online(struct qeth_card *card, int fallback); 
int qeth_hdr_chk_and_bounce(struct sk_buff *, struct qeth_hdr **, int);

int qeth_configure_cq(struct qeth_card *, enum qeth_cq);

int qeth_hw_trap(struct qeth_card *, enum qeth_diags_trap_action);

int qeth_query_ipassists(struct qeth_card *, enum qeth_prot_versions prot);

void qeth_trace_features(struct qeth_card *);

void qeth_close_dev(struct qeth_card *);

int qeth_send_setassparms(struct qeth_card *, struct qeth_cmd_buffer *, __u16,

drivers/s390/net/qeth_core_main.c

+45 −86
Original line number Diff line number Diff line
@@ -473,7 +473,6 @@ static void qeth_cleanup_handled_pending(struct qeth_qdio_out_q *q, int bidx, 
	if (forced_cleanup && (atomic_read(&(q->bufs[bidx]->state)) ==

					QETH_QDIO_BUF_HANDLED_DELAYED)) {

		/* for recovery situations */

		q->bufs[bidx]->aob = q->bufstates[bidx].aob;

		qeth_init_qdio_out_buf(q, bidx);

		QETH_CARD_TEXT(q->card, 2, "clprecov");

	}
@@ -510,7 +509,6 @@ static void qeth_qdio_handle_aob(struct qeth_card *card, 
	}

	qeth_notify_skbs(buffer->q, buffer, notification);



	buffer->aob = NULL;

	/* Free dangling allocations. The attached skbs are handled by

	 * qeth_cleanup_handled_pending().

	 */
@@ -1267,8 +1265,7 @@ static void qeth_release_skbs(struct qeth_qdio_out_buffer *buf) 
}



static void qeth_clear_output_buffer(struct qeth_qdio_out_q *queue,

		struct qeth_qdio_out_buffer *buf,

		enum qeth_qdio_buffer_states newbufstate)

				     struct qeth_qdio_out_buffer *buf)

{

	int i;
@@ -1276,23 +1273,19 @@ static void qeth_clear_output_buffer(struct qeth_qdio_out_q *queue, 
	if (buf->buffer->element[0].sflags & SBAL_SFLAGS0_PCI_REQ)

		atomic_dec(&queue->set_pci_flags_count);



	if (newbufstate == QETH_QDIO_BUF_EMPTY) {

	qeth_release_skbs(buf);

	}



	for (i = 0; i < QETH_MAX_BUFFER_ELEMENTS(queue->card); ++i) {

		if (buf->buffer->element[i].addr && buf->is_header[i])

			kmem_cache_free(qeth_core_header_cache,

				buf->buffer->element[i].addr);

		buf->is_header[i] = 0;

		buf->buffer->element[i].length = 0;

		buf->buffer->element[i].addr = NULL;

		buf->buffer->element[i].eflags = 0;

		buf->buffer->element[i].sflags = 0;

	}

	buf->buffer->element[15].eflags = 0;

	buf->buffer->element[15].sflags = 0;



	qeth_scrub_qdio_buffer(buf->buffer,

			       QETH_MAX_BUFFER_ELEMENTS(queue->card));

	buf->next_element_to_fill = 0;

	atomic_set(&buf->state, newbufstate);

	atomic_set(&buf->state, QETH_QDIO_BUF_EMPTY);

}



static void qeth_clear_outq_buffers(struct qeth_qdio_out_q *q, int free)
@@ -1303,7 +1296,7 @@ static void qeth_clear_outq_buffers(struct qeth_qdio_out_q *q, int free) 
		if (!q->bufs[j])

			continue;

		qeth_cleanup_handled_pending(q, j, 1);

		qeth_clear_output_buffer(q, q->bufs[j], QETH_QDIO_BUF_EMPTY);

		qeth_clear_output_buffer(q, q->bufs[j]);

		if (free) {

			kmem_cache_free(qeth_qdio_outbuf_cache, q->bufs[j]);

			q->bufs[j] = NULL;
@@ -1544,8 +1537,6 @@ static void qeth_determine_card_type(struct qeth_card *card) 
	card->qdio.default_out_queue = QETH_DEFAULT_QUEUE;

	card->info.type = CARD_RDEV(card)->id.driver_info;

	card->qdio.no_out_queues = QETH_MAX_QUEUES;

	if (card->info.type == QETH_CARD_TYPE_IQD)

		card->info.is_multicast_different = 0x0103;

	qeth_update_from_chp_desc(card);

}
@@ -2473,32 +2464,20 @@ static int qeth_ulp_setup(struct qeth_card *card) 


static int qeth_init_qdio_out_buf(struct qeth_qdio_out_q *q, int bidx)

{

	int rc;

	struct qeth_qdio_out_buffer *newbuf;



	rc = 0;

	newbuf = kmem_cache_zalloc(qeth_qdio_outbuf_cache, GFP_ATOMIC);

	if (!newbuf) {

		rc = -ENOMEM;

		goto out;

	}

	if (!newbuf)

		return -ENOMEM;



	newbuf->buffer = q->qdio_bufs[bidx];

	skb_queue_head_init(&newbuf->skb_list);

	lockdep_set_class(&newbuf->skb_list.lock, &qdio_out_skb_queue_key);

	newbuf->q = q;

	newbuf->aob = NULL;

	newbuf->next_pending = q->bufs[bidx];

	atomic_set(&newbuf->state, QETH_QDIO_BUF_EMPTY);

	q->bufs[bidx] = newbuf;

	if (q->bufstates) {

		q->bufstates[bidx].user = newbuf;

		QETH_CARD_TEXT_(q->card, 2, "nbs%d", bidx);

		QETH_CARD_TEXT_(q->card, 2, "%lx", (long) newbuf);

		QETH_CARD_TEXT_(q->card, 2, "%lx",

				(long) newbuf->next_pending);

	}

out:

	return rc;

	return 0;

}



static void qeth_free_qdio_out_buf(struct qeth_qdio_out_q *q)
@@ -2908,8 +2887,7 @@ int qeth_init_qdio_queues(struct qeth_card *card) 
				   QDIO_MAX_BUFFERS_PER_Q);

		for (j = 0; j < QDIO_MAX_BUFFERS_PER_Q; ++j) {

			qeth_clear_output_buffer(card->qdio.out_qs[i],

					card->qdio.out_qs[i]->bufs[j],

					QETH_QDIO_BUF_EMPTY);

						 card->qdio.out_qs[i]->bufs[j]);

		}

		card->qdio.out_qs[i]->card = card;

		card->qdio.out_qs[i]->next_buf_to_fill = 0;
@@ -3076,7 +3054,7 @@ static struct qeth_cmd_buffer *qeth_get_adapter_cmd(struct qeth_card *card, 
	return iob;

}



int qeth_query_setadapterparms(struct qeth_card *card)

static int qeth_query_setadapterparms(struct qeth_card *card)

{

	int rc;

	struct qeth_cmd_buffer *iob;
@@ -3089,7 +3067,6 @@ int qeth_query_setadapterparms(struct qeth_card *card) 
	rc = qeth_send_ipa_cmd(card, iob, qeth_query_setadapterparms_cb, NULL);

	return rc;

}

EXPORT_SYMBOL_GPL(qeth_query_setadapterparms);



static int qeth_query_ipassists_cb(struct qeth_card *card,

		struct qeth_reply *reply, unsigned long data)
@@ -3129,7 +3106,8 @@ static int qeth_query_ipassists_cb(struct qeth_card *card, 
	return 0;

}



int qeth_query_ipassists(struct qeth_card *card, enum qeth_prot_versions prot)

static int qeth_query_ipassists(struct qeth_card *card,

				enum qeth_prot_versions prot)

{

	int rc;

	struct qeth_cmd_buffer *iob;
@@ -3141,7 +3119,6 @@ int qeth_query_ipassists(struct qeth_card *card, enum qeth_prot_versions prot) 
	rc = qeth_send_ipa_cmd(card, iob, qeth_query_ipassists_cb, NULL);

	return rc;

}

EXPORT_SYMBOL_GPL(qeth_query_ipassists);



static int qeth_query_switch_attributes_cb(struct qeth_card *card,

				struct qeth_reply *reply, unsigned long data)
@@ -3180,7 +3157,6 @@ int qeth_query_switch_attributes(struct qeth_card *card, 
	return qeth_send_ipa_cmd(card, iob,

				qeth_query_switch_attributes_cb, sw_info);

}

EXPORT_SYMBOL_GPL(qeth_query_switch_attributes);



static int qeth_query_setdiagass_cb(struct qeth_card *card,

		struct qeth_reply *reply, unsigned long data)
@@ -3634,10 +3610,10 @@ int qeth_configure_cq(struct qeth_card *card, enum qeth_cq cq) 
}

EXPORT_SYMBOL_GPL(qeth_configure_cq);





static void qeth_qdio_cq_handler(struct qeth_card *card,

		unsigned int qdio_err,

		unsigned int queue, int first_element, int count) {

static void qeth_qdio_cq_handler(struct qeth_card *card, unsigned int qdio_err,

				 unsigned int queue, int first_element,

				 int count)

{

	struct qeth_qdio_q *cq = card->qdio.c_q;

	int i;

	int rc;
@@ -3663,25 +3639,17 @@ static void qeth_qdio_cq_handler(struct qeth_card *card, 
	for (i = first_element; i < first_element + count; ++i) {

		int bidx = i % QDIO_MAX_BUFFERS_PER_Q;

		struct qdio_buffer *buffer = cq->qdio_bufs[bidx];

		int e;

		int e = 0;



		e = 0;

		while ((e < QDIO_MAX_ELEMENTS_PER_BUFFER) &&

		       buffer->element[e].addr) {

			unsigned long phys_aob_addr;



			phys_aob_addr = (unsigned long) buffer->element[e].addr;

			qeth_qdio_handle_aob(card, phys_aob_addr);

			buffer->element[e].addr = NULL;

			buffer->element[e].eflags = 0;

			buffer->element[e].sflags = 0;

			buffer->element[e].length = 0;



			++e;

		}



		buffer->element[15].eflags = 0;

		buffer->element[15].sflags = 0;

		qeth_scrub_qdio_buffer(buffer, QDIO_MAX_ELEMENTS_PER_BUFFER);

	}

	rc = do_QDIO(CARD_DDEV(card), QDIO_FLAG_SYNC_INPUT, queue,

		    card->qdio.c_q->next_buf_to_init,
@@ -3760,11 +3728,7 @@ static void qeth_qdio_output_handler(struct ccw_device *ccwdev, 
				qeth_notify_skbs(queue, buffer,

						 TX_NOTIFY_PENDING);

			}

			buffer->aob = queue->bufstates[bidx].aob;

			QETH_CARD_TEXT_(queue->card, 5, "pel%d", bidx);

			QETH_CARD_TEXT(queue->card, 5, "aob");

			QETH_CARD_TEXT_(queue->card, 5, "%lx",

					virt_to_phys(buffer->aob));



			/* prepare the queue slot for re-use: */

			qeth_scrub_qdio_buffer(buffer->buffer,
@@ -3782,8 +3746,7 @@ static void qeth_qdio_output_handler(struct ccw_device *ccwdev, 
				qeth_notify_skbs(queue, buffer, n);

			}



			qeth_clear_output_buffer(queue, buffer,

						QETH_QDIO_BUF_EMPTY);

			qeth_clear_output_buffer(queue, buffer);

		}

		qeth_cleanup_handled_pending(queue, bidx, 0);

	}
@@ -3810,15 +3773,11 @@ static inline int qeth_cut_iqd_prio(struct qeth_card *card, int queue_num) 
 * Note: Function assumes that we have 4 outbound queues.

 */

int qeth_get_priority_queue(struct qeth_card *card, struct sk_buff *skb,

			int ipv, int cast_type)

			    int ipv)

{

	__be16 *tci;

	u8 tos;



	if (cast_type && card->info.is_multicast_different)

		return card->info.is_multicast_different &

			(card->qdio.no_out_queues - 1);



	switch (card->qdio.do_prio_queueing) {

	case QETH_PRIO_Q_ING_TOS:

	case QETH_PRIO_Q_ING_PREC:
@@ -5887,31 +5846,13 @@ static int qeth_core_restore(struct ccwgroup_device *gdev) 
	return 0;

}



static struct ccwgroup_driver qeth_core_ccwgroup_driver = {

	.driver = {

		.owner = THIS_MODULE,

		.name = "qeth",

	},

	.ccw_driver = &qeth_ccw_driver,

	.setup = qeth_core_probe_device,

	.remove = qeth_core_remove_device,

	.set_online = qeth_core_set_online,

	.set_offline = qeth_core_set_offline,

	.shutdown = qeth_core_shutdown,

	.prepare = NULL,

	.complete = NULL,

	.freeze = qeth_core_freeze,

	.thaw = qeth_core_thaw,

	.restore = qeth_core_restore,

};



static ssize_t group_store(struct device_driver *ddrv, const char *buf,

			   size_t count)

{

	int err;



	err = ccwgroup_create_dev(qeth_core_root_dev,

				  &qeth_core_ccwgroup_driver, 3, buf);

	err = ccwgroup_create_dev(qeth_core_root_dev, to_ccwgroupdrv(ddrv), 3,

				  buf);



	return err ? err : count;

}
@@ -5929,6 +5870,25 @@ static const struct attribute_group *qeth_drv_attr_groups[] = { 
	NULL,

};



static struct ccwgroup_driver qeth_core_ccwgroup_driver = {

	.driver = {

		.groups = qeth_drv_attr_groups,

		.owner = THIS_MODULE,

		.name = "qeth",

	},

	.ccw_driver = &qeth_ccw_driver,

	.setup = qeth_core_probe_device,

	.remove = qeth_core_remove_device,

	.set_online = qeth_core_set_online,

	.set_offline = qeth_core_set_offline,

	.shutdown = qeth_core_shutdown,

	.prepare = NULL,

	.complete = NULL,

	.freeze = qeth_core_freeze,

	.thaw = qeth_core_thaw,

	.restore = qeth_core_restore,

};



int qeth_do_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)

{

	struct qeth_card *card = dev->ml_priv;
@@ -6620,7 +6580,6 @@ static int __init qeth_core_init(void) 
	rc = ccw_driver_register(&qeth_ccw_driver);

	if (rc)

		goto ccw_err;

	qeth_core_ccwgroup_driver.driver.groups = qeth_drv_attr_groups;

	rc = ccwgroup_driver_register(&qeth_core_ccwgroup_driver);

	if (rc)

		goto ccwgroup_err;

drivers/s390/net/qeth_core_mpc.h

+2 −0
Original line number Diff line number Diff line
@@ -64,6 +64,8 @@ enum qeth_card_types { 
	QETH_CARD_TYPE_OSX     = 2,

};



#define IS_IQD(card)	((card)->info.type == QETH_CARD_TYPE_IQD)



#define QETH_MPC_DIFINFO_LEN_INDICATES_LINK_TYPE 0x18

/* only the first two bytes are looked at in qeth_get_cardname_short */

enum qeth_link_types {

drivers/s390/net/qeth_l2.h

+5 −0
Original line number Diff line number Diff line
@@ -14,6 +14,11 @@ extern const struct attribute_group *qeth_l2_attr_groups[]; 
int qeth_l2_create_device_attributes(struct device *);

void qeth_l2_remove_device_attributes(struct device *);

void qeth_l2_setup_bridgeport_attrs(struct qeth_card *card);

int qeth_bridgeport_query_ports(struct qeth_card *card,

				enum qeth_sbp_roles *role,

				enum qeth_sbp_states *state);

int qeth_bridgeport_setrole(struct qeth_card *card, enum qeth_sbp_roles role);

int qeth_bridgeport_an_set(struct qeth_card *card, int enable);



int qeth_l2_vnicc_set_state(struct qeth_card *card, u32 vnicc, bool state);

int qeth_l2_vnicc_get_state(struct qeth_card *card, u32 vnicc, bool *state);

drivers/s390/net/qeth_l2_main.c

+5 −15
Original line number Diff line number Diff line
@@ -26,7 +26,6 @@ 


static int qeth_l2_set_offline(struct ccwgroup_device *);

static int qeth_l2_stop(struct net_device *);

static void qeth_l2_set_rx_mode(struct net_device *);

static void qeth_bridgeport_query_support(struct qeth_card *card);

static void qeth_bridge_state_change(struct qeth_card *card,

					struct qeth_ipa_cmd *cmd);
@@ -186,12 +185,12 @@ static void qeth_l2_del_all_macs(struct qeth_card *card) 
static int qeth_l2_get_cast_type(struct qeth_card *card, struct sk_buff *skb)

{

	if (card->info.type == QETH_CARD_TYPE_OSN)

		return RTN_UNSPEC;

		return RTN_UNICAST;

	if (is_broadcast_ether_addr(skb->data))

		return RTN_BROADCAST;

	if (is_multicast_ether_addr(skb->data))

		return RTN_MULTICAST;

	return RTN_UNSPEC;

	return RTN_UNICAST;

}



static void qeth_l2_fill_header(struct qeth_hdr *hdr, struct sk_buff *skb,
@@ -344,7 +343,6 @@ static int qeth_l2_vlan_rx_kill_vid(struct net_device *dev, 
		rc = qeth_l2_send_setdelvlan(card, vid, IPA_CMD_DELVLAN);

		kfree(tmpid);

	}

	qeth_l2_set_rx_mode(card->dev);

	return rc;

}
@@ -770,18 +768,13 @@ static netdev_tx_t qeth_l2_hard_start_xmit(struct sk_buff *skb, 
	int tx_bytes = skb->len;

	int rc;



	if (card->qdio.do_prio_queueing || (cast_type &&

					card->info.is_multicast_different))

		queue = card->qdio.out_qs[qeth_get_priority_queue(card, skb,

					ipv, cast_type)];

	else

		queue = card->qdio.out_qs[card->qdio.default_out_queue];



	if ((card->state != CARD_STATE_UP) || !card->lan_online) {

		card->stats.tx_carrier_errors++;

		goto tx_drop;

	}



	queue = qeth_get_tx_queue(card, skb, ipv, cast_type);



	if (card->options.performance_stats) {

		card->perf_stats.outbound_cnt++;

		card->perf_stats.outbound_start_time = qeth_get_micros();
@@ -1125,13 +1118,12 @@ static int __qeth_l2_set_online(struct ccwgroup_device *gdev, int recovery_mode) 
		if (recovery_mode &&

		    card->info.type != QETH_CARD_TYPE_OSN) {

			__qeth_l2_open(card->dev);

			qeth_l2_set_rx_mode(card->dev);

		} else {

			rtnl_lock();

			dev_open(card->dev);

			rtnl_unlock();

		}

		/* this also sets saved unicast addresses */

		qeth_l2_set_rx_mode(card->dev);

	}

	/* let user_space know that device is online */

	kobject_uevent(&gdev->dev.kobj, KOBJ_CHANGE);
@@ -1877,7 +1869,6 @@ int qeth_bridgeport_query_ports(struct qeth_card *card, 
		return rc;

	return qeth_bridgeport_makerc(card, &cbctl, IPA_SBP_QUERY_BRIDGE_PORTS);

}

EXPORT_SYMBOL_GPL(qeth_bridgeport_query_ports);



static int qeth_bridgeport_set_cb(struct qeth_card *card,

	struct qeth_reply *reply, unsigned long data)
@@ -2025,7 +2016,6 @@ int qeth_bridgeport_an_set(struct qeth_card *card, int enable) 
		rc = qdio_pnso_brinfo(schid, 0, &response, NULL, NULL);

	return qeth_anset_makerc(card, rc, response);

}

EXPORT_SYMBOL_GPL(qeth_bridgeport_an_set);



static bool qeth_bridgeport_is_in_use(struct qeth_card *card)

{