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

Merge branch 's390-qeth-next' 



Julian Wiedmann says:

====================
s390/qeth: updates 2020-12-07

please apply the following patch series for qeth to netdev's net-next tree.

Some sysfs cleanups (with the prep work in ccwgroup acked by Heiko), and
a few improvements to the code that deals with async TX completion
notifications for IQD devices.

This also brings the missing patch from the previous net-next submission.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents af3f4a85 d2e46004

drivers/s390/cio/ccwgroup.c

+3 −9
Original line number Diff line number Diff line
@@ -210,18 +210,12 @@ static ssize_t ccwgroup_ungroup_store(struct device *dev, 
static DEVICE_ATTR(ungroup, 0200, NULL, ccwgroup_ungroup_store);

static DEVICE_ATTR(online, 0644, ccwgroup_online_show, ccwgroup_online_store);



static struct attribute *ccwgroup_attrs[] = {

static struct attribute *ccwgroup_dev_attrs[] = {

	&dev_attr_online.attr,

	&dev_attr_ungroup.attr,

	NULL,

};

static struct attribute_group ccwgroup_attr_group = {

	.attrs = ccwgroup_attrs,

};

static const struct attribute_group *ccwgroup_attr_groups[] = {

	&ccwgroup_attr_group,

	NULL,

};

ATTRIBUTE_GROUPS(ccwgroup_dev);



static void ccwgroup_ungroup_workfn(struct work_struct *work)

{
@@ -384,7 +378,6 @@ int ccwgroup_create_dev(struct device *parent, struct ccwgroup_driver *gdrv, 
	}



	dev_set_name(&gdev->dev, "%s", dev_name(&gdev->cdev[0]->dev));

	gdev->dev.groups = ccwgroup_attr_groups;



	if (gdrv) {

		gdev->dev.driver = &gdrv->driver;
@@ -487,6 +480,7 @@ static void ccwgroup_shutdown(struct device *dev) 


static struct bus_type ccwgroup_bus_type = {

	.name   = "ccwgroup",

	.dev_groups = ccwgroup_dev_groups,

	.remove = ccwgroup_remove,

	.shutdown = ccwgroup_shutdown,

};

drivers/s390/net/qeth_core.h

+3 −7
Original line number Diff line number Diff line
@@ -424,8 +424,6 @@ enum qeth_qdio_out_buffer_state { 
	/* Received QAOB notification on CQ: */

	QETH_QDIO_BUF_QAOB_OK,

	QETH_QDIO_BUF_QAOB_ERROR,

	/* Handled via transfer pending / completion queue. */

	QETH_QDIO_BUF_HANDLED_DELAYED,

};



struct qeth_qdio_out_buffer {
@@ -624,7 +622,7 @@ struct qeth_reply { 
};



struct qeth_cmd_buffer {

	struct list_head list;

	struct list_head list_entry;

	struct completion done;

	spinlock_t lock;

	unsigned int length;
@@ -1063,10 +1061,8 @@ extern const struct qeth_discipline qeth_l2_discipline; 
extern const struct qeth_discipline qeth_l3_discipline;

extern const struct ethtool_ops qeth_ethtool_ops;

extern const struct ethtool_ops qeth_osn_ethtool_ops;

extern const struct attribute_group *qeth_generic_attr_groups[];

extern const struct attribute_group *qeth_osn_attr_groups[];

extern const struct attribute_group qeth_device_attr_group;

extern const struct attribute_group qeth_device_blkt_group;

extern const struct attribute_group *qeth_dev_groups[];

extern const struct attribute_group *qeth_osn_dev_groups[];

extern const struct device_type qeth_generic_devtype;



const char *qeth_get_cardname_short(struct qeth_card *);

drivers/s390/net/qeth_core_main.c

+63 −48
Original line number Diff line number Diff line
@@ -75,7 +75,6 @@ static void qeth_notify_skbs(struct qeth_qdio_out_q *queue, 
		enum iucv_tx_notify notification);

static void qeth_tx_complete_buf(struct qeth_qdio_out_buffer *buf, bool error,

				 int budget);

static int qeth_init_qdio_out_buf(struct qeth_qdio_out_q *, int);



static void qeth_close_dev_handler(struct work_struct *work)

{
@@ -478,8 +477,7 @@ static void qeth_cleanup_handled_pending(struct qeth_qdio_out_q *q, int bidx, 


		while (c) {

			if (forced_cleanup ||

			    atomic_read(&c->state) ==

			      QETH_QDIO_BUF_HANDLED_DELAYED) {

			    atomic_read(&c->state) == QETH_QDIO_BUF_EMPTY) {

				struct qeth_qdio_out_buffer *f = c;



				QETH_CARD_TEXT(f->q->card, 5, "fp");
@@ -517,18 +515,6 @@ static void qeth_qdio_handle_aob(struct qeth_card *card, 
	buffer = (struct qeth_qdio_out_buffer *) aob->user1;

	QETH_CARD_TEXT_(card, 5, "%lx", aob->user1);



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

	 * qeth_cleanup_handled_pending().

	 */

	for (i = 0;

	     i < aob->sb_count && i < QETH_MAX_BUFFER_ELEMENTS(card);

	     i++) {

		void *data = phys_to_virt(aob->sba[i]);



		if (data && buffer->is_header[i])

			kmem_cache_free(qeth_core_header_cache, data);

	}



	if (aob->aorc) {

		QETH_CARD_TEXT_(card, 2, "aorc%02X", aob->aorc);

		new_state = QETH_QDIO_BUF_QAOB_ERROR;
@@ -536,10 +522,9 @@ static void qeth_qdio_handle_aob(struct qeth_card *card, 


	switch (atomic_xchg(&buffer->state, new_state)) {

	case QETH_QDIO_BUF_PRIMED:

		/* Faster than TX completion code. */

		notification = qeth_compute_cq_notification(aob->aorc, 0);

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

		atomic_set(&buffer->state, QETH_QDIO_BUF_HANDLED_DELAYED);

		/* Faster than TX completion code, let it handle the async

		 * completion for us.

		 */

		break;

	case QETH_QDIO_BUF_PENDING:

		/* TX completion code is active and will handle the async
@@ -550,7 +535,21 @@ static void qeth_qdio_handle_aob(struct qeth_card *card, 
		/* TX completion code is already finished. */

		notification = qeth_compute_cq_notification(aob->aorc, 1);

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

		atomic_set(&buffer->state, QETH_QDIO_BUF_HANDLED_DELAYED);



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

		 * qeth_cleanup_handled_pending().

		 */

		for (i = 0;

		     i < aob->sb_count && i < QETH_MAX_BUFFER_ELEMENTS(card);

		     i++) {

			void *data = phys_to_virt(aob->sba[i]);



			if (data && buffer->is_header[i])

				kmem_cache_free(qeth_core_header_cache, data);

			buffer->is_header[i] = 0;

		}



		atomic_set(&buffer->state, QETH_QDIO_BUF_EMPTY);

		break;

	default:

		WARN_ON_ONCE(1);
@@ -615,7 +614,7 @@ static void qeth_enqueue_cmd(struct qeth_card *card, 
			     struct qeth_cmd_buffer *iob)

{

	spin_lock_irq(&card->lock);

	list_add_tail(&iob->list, &card->cmd_waiter_list);

	list_add_tail(&iob->list_entry, &card->cmd_waiter_list);

	spin_unlock_irq(&card->lock);

}
@@ -623,7 +622,7 @@ static void qeth_dequeue_cmd(struct qeth_card *card, 
			     struct qeth_cmd_buffer *iob)

{

	spin_lock_irq(&card->lock);

	list_del(&iob->list);

	list_del(&iob->list_entry);

	spin_unlock_irq(&card->lock);

}
@@ -977,7 +976,7 @@ static void qeth_clear_ipacmd_list(struct qeth_card *card) 
	QETH_CARD_TEXT(card, 4, "clipalst");



	spin_lock_irqsave(&card->lock, flags);

	list_for_each_entry(iob, &card->cmd_waiter_list, list)

	list_for_each_entry(iob, &card->cmd_waiter_list, list_entry)

		qeth_notify_cmd(iob, -ECANCELED);

	spin_unlock_irqrestore(&card->lock, flags);

}
@@ -1047,7 +1046,6 @@ struct qeth_cmd_buffer *qeth_alloc_cmd(struct qeth_channel *channel, 


	init_completion(&iob->done);

	spin_lock_init(&iob->lock);

	INIT_LIST_HEAD(&iob->list);

	refcount_set(&iob->ref_count, 1);

	iob->channel = channel;

	iob->timeout = timeout;
@@ -1094,7 +1092,7 @@ static void qeth_issue_next_read_cb(struct qeth_card *card, 


	/* match against pending cmd requests */

	spin_lock_irqsave(&card->lock, flags);

	list_for_each_entry(tmp, &card->cmd_waiter_list, list) {

	list_for_each_entry(tmp, &card->cmd_waiter_list, list_entry) {

		if (tmp->match && tmp->match(tmp, iob)) {

			request = tmp;

			/* take the object outside the lock */
@@ -6079,9 +6077,13 @@ static void qeth_iqd_tx_complete(struct qeth_qdio_out_q *queue, 
				 QDIO_OUTBUF_STATE_FLAG_PENDING)) {

		WARN_ON_ONCE(card->options.cq != QETH_CQ_ENABLED);



		if (atomic_cmpxchg(&buffer->state, QETH_QDIO_BUF_PRIMED,

						   QETH_QDIO_BUF_PENDING) ==

		    QETH_QDIO_BUF_PRIMED) {

		QETH_CARD_TEXT_(card, 5, "pel%u", bidx);



		switch (atomic_cmpxchg(&buffer->state,

				       QETH_QDIO_BUF_PRIMED,

				       QETH_QDIO_BUF_PENDING)) {

		case QETH_QDIO_BUF_PRIMED:

			/* We have initial ownership, no QAOB (yet): */

			qeth_notify_skbs(queue, buffer, TX_NOTIFY_PENDING);



			/* Handle race with qeth_qdio_handle_aob(): */
@@ -6089,39 +6091,49 @@ static void qeth_iqd_tx_complete(struct qeth_qdio_out_q *queue, 
					    QETH_QDIO_BUF_NEED_QAOB)) {

			case QETH_QDIO_BUF_PENDING:

				/* No concurrent QAOB notification. */

				break;



				/* Prepare the queue slot for immediate re-use: */

				qeth_scrub_qdio_buffer(buffer->buffer, queue->max_elements);

				if (qeth_init_qdio_out_buf(queue, bidx)) {

					QETH_CARD_TEXT(card, 2, "outofbuf");

					qeth_schedule_recovery(card);

				}



				/* Skip clearing the buffer: */

				return;

			case QETH_QDIO_BUF_QAOB_OK:

				qeth_notify_skbs(queue, buffer,

						 TX_NOTIFY_DELAYED_OK);

				atomic_set(&buffer->state,

					   QETH_QDIO_BUF_HANDLED_DELAYED);

				error = false;

				break;

			case QETH_QDIO_BUF_QAOB_ERROR:

				qeth_notify_skbs(queue, buffer,

						 TX_NOTIFY_DELAYED_GENERALERROR);

				atomic_set(&buffer->state,

					   QETH_QDIO_BUF_HANDLED_DELAYED);

				error = true;

				break;

			default:

				WARN_ON_ONCE(1);

			}

		}



		QETH_CARD_TEXT_(card, 5, "pel%u", bidx);



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

		qeth_scrub_qdio_buffer(buffer->buffer, queue->max_elements);

		if (qeth_init_qdio_out_buf(queue, bidx)) {

			QETH_CARD_TEXT(card, 2, "outofbuf");

			qeth_schedule_recovery(card);

		}



		return;

			break;

		case QETH_QDIO_BUF_QAOB_OK:

			/* qeth_qdio_handle_aob() already received a QAOB: */

			qeth_notify_skbs(queue, buffer, TX_NOTIFY_OK);

			error = false;

			break;

		case QETH_QDIO_BUF_QAOB_ERROR:

			/* qeth_qdio_handle_aob() already received a QAOB: */

			qeth_notify_skbs(queue, buffer, TX_NOTIFY_GENERALERROR);

			error = true;

			break;

		default:

			WARN_ON_ONCE(1);

		}



	if (card->options.cq == QETH_CQ_ENABLED)

	} else if (card->options.cq == QETH_CQ_ENABLED) {

		qeth_notify_skbs(queue, buffer,

				 qeth_compute_cq_notification(sflags, 0));

	}



	qeth_clear_output_buffer(queue, buffer, error, budget);

}
@@ -6376,13 +6388,11 @@ void qeth_core_free_discipline(struct qeth_card *card) 


const struct device_type qeth_generic_devtype = {

	.name = "qeth_generic",

	.groups = qeth_generic_attr_groups,

};

EXPORT_SYMBOL_GPL(qeth_generic_devtype);



static const struct device_type qeth_osn_devtype = {

	.name = "qeth_osn",

	.groups = qeth_osn_attr_groups,

};



#define DBF_NAME_LEN	20
@@ -6562,6 +6572,11 @@ static int qeth_core_probe_device(struct ccwgroup_device *gdev) 
	if (rc)

		goto err_chp_desc;



	if (IS_OSN(card))

		gdev->dev.groups = qeth_osn_dev_groups;

	else

		gdev->dev.groups = qeth_dev_groups;



	enforced_disc = qeth_enforce_discipline(card);

	switch (enforced_disc) {

	case QETH_DISCIPLINE_UNDETERMINED:

drivers/s390/net/qeth_core_sys.c

+19 −22
Original line number Diff line number Diff line
@@ -640,23 +640,17 @@ static struct attribute *qeth_blkt_device_attrs[] = { 
	&dev_attr_inter_jumbo.attr,

	NULL,

};

const struct attribute_group qeth_device_blkt_group = {



static const struct attribute_group qeth_dev_blkt_group = {

	.name = "blkt",

	.attrs = qeth_blkt_device_attrs,

};

EXPORT_SYMBOL_GPL(qeth_device_blkt_group);



static struct attribute *qeth_device_attrs[] = {

	&dev_attr_state.attr,

	&dev_attr_chpid.attr,

	&dev_attr_if_name.attr,

	&dev_attr_card_type.attr,

static struct attribute *qeth_dev_extended_attrs[] = {

	&dev_attr_inbuf_size.attr,

	&dev_attr_portno.attr,

	&dev_attr_portname.attr,

	&dev_attr_priority_queueing.attr,

	&dev_attr_buffer_count.attr,

	&dev_attr_recover.attr,

	&dev_attr_performance_stats.attr,

	&dev_attr_layer2.attr,

	&dev_attr_isolation.attr,
@@ -664,18 +658,12 @@ static struct attribute *qeth_device_attrs[] = { 
	&dev_attr_switch_attrs.attr,

	NULL,

};

const struct attribute_group qeth_device_attr_group = {

	.attrs = qeth_device_attrs,

};

EXPORT_SYMBOL_GPL(qeth_device_attr_group);



const struct attribute_group *qeth_generic_attr_groups[] = {

	&qeth_device_attr_group,

	&qeth_device_blkt_group,

	NULL,

static const struct attribute_group qeth_dev_extended_group = {

	.attrs = qeth_dev_extended_attrs,

};



static struct attribute *qeth_osn_device_attrs[] = {

static struct attribute *qeth_dev_attrs[] = {

	&dev_attr_state.attr,

	&dev_attr_chpid.attr,

	&dev_attr_if_name.attr,
@@ -684,10 +672,19 @@ static struct attribute *qeth_osn_device_attrs[] = { 
	&dev_attr_recover.attr,

	NULL,

};

static struct attribute_group qeth_osn_device_attr_group = {

	.attrs = qeth_osn_device_attrs,



static const struct attribute_group qeth_dev_group = {

	.attrs = qeth_dev_attrs,

};

const struct attribute_group *qeth_osn_attr_groups[] = {

	&qeth_osn_device_attr_group,



const struct attribute_group *qeth_osn_dev_groups[] = {

	&qeth_dev_group,

	NULL,

};



const struct attribute_group *qeth_dev_groups[] = {

	&qeth_dev_group,

	&qeth_dev_extended_group,

	&qeth_dev_blkt_group,

	NULL,

};

drivers/s390/net/qeth_l2.h

+0 −2
Original line number Diff line number Diff line
@@ -11,8 +11,6 @@ 


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 *);

int qeth_bridgeport_query_ports(struct qeth_card *card,

				enum qeth_sbp_roles *role,

				enum qeth_sbp_states *state);