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

Merge branch 's390-qeth-cleanups' 



Julian Wiedmann says:

====================
s390/qeth: updates 2019-04-25

please apply one more patch series for qeth to net-next. Nothing special,
just a bunch of cleanups.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 9157bc2a 14a1b047

drivers/s390/net/qeth_core.h

+35 −39
Original line number Diff line number Diff line
@@ -165,6 +165,12 @@ struct qeth_vnicc_info { 
	bool rx_bcast_enabled;

};



static inline int qeth_is_adp_supported(struct qeth_ipa_info *ipa,

		enum qeth_ipa_setadp_cmd func)

{

	return (ipa->supported_funcs & func);

}



static inline int qeth_is_ipa_supported(struct qeth_ipa_info *ipa,

		enum qeth_ipa_funcs func)

{
@@ -178,9 +184,7 @@ static inline int qeth_is_ipa_enabled(struct qeth_ipa_info *ipa, 
}



#define qeth_adp_supported(c, f) \

	qeth_is_ipa_supported(&c->options.adp, f)

#define qeth_adp_enabled(c, f) \

	qeth_is_ipa_enabled(&c->options.adp, f)

	qeth_is_adp_supported(&c->options.adp, f)

#define qeth_is_supported(c, f) \

	qeth_is_ipa_supported(&c->options.ipa4, f)

#define qeth_is_enabled(c, f) \
@@ -370,34 +374,6 @@ enum qeth_header_ids { 
#define QETH_HDR_EXT_CSUM_TRANSP_REQ  0x20

#define QETH_HDR_EXT_UDP	      0x40 /*bit off for TCP*/



enum qeth_qdio_buffer_states {

	/*

	 * inbound: read out by driver; owned by hardware in order to be filled

	 * outbound: owned by driver in order to be filled

	 */

	QETH_QDIO_BUF_EMPTY,

	/*

	 * inbound: filled by hardware; owned by driver in order to be read out

	 * outbound: filled by driver; owned by hardware in order to be sent

	 */

	QETH_QDIO_BUF_PRIMED,

	/*

	 * inbound: not applicable

	 * outbound: identified to be pending in TPQ

	 */

	QETH_QDIO_BUF_PENDING,

	/*

	 * inbound: not applicable

	 * outbound: found in completion queue

	 */

	QETH_QDIO_BUF_IN_CQ,

	/*

	 * inbound: not applicable

	 * outbound: handled via transfer pending / completion queue

	 */

	QETH_QDIO_BUF_HANDLED_DELAYED,

};



enum qeth_qdio_info_states {

	QETH_QDIO_UNINITIALIZED,

	QETH_QDIO_ALLOCATED,
@@ -429,6 +405,19 @@ struct qeth_qdio_q { 
	int next_buf_to_init;

};



enum qeth_qdio_out_buffer_state {

	/* Owned by driver, in order to be filled. */

	QETH_QDIO_BUF_EMPTY,

	/* Filled by driver; owned by hardware in order to be sent. */

	QETH_QDIO_BUF_PRIMED,

	/* Identified to be pending in TPQ. */

	QETH_QDIO_BUF_PENDING,

	/* Found in completion queue. */

	QETH_QDIO_BUF_IN_CQ,

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

	QETH_QDIO_BUF_HANDLED_DELAYED,

};



struct qeth_qdio_out_buffer {

	struct qdio_buffer *buffer;

	atomic_t state;
@@ -495,14 +484,12 @@ struct qeth_qdio_out_q { 
	struct qeth_qdio_out_buffer *bufs[QDIO_MAX_BUFFERS_PER_Q];

	struct qdio_outbuf_state *bufstates; /* convenience pointer */

	struct qeth_out_q_stats stats;

	int queue_no;

	u8 next_buf_to_fill;

	u8 max_elements;

	u8 queue_no;

	u8 do_pack;

	struct qeth_card *card;

	atomic_t state;

	int do_pack;

	/*

	 * index of buffer to be filled by driver; state EMPTY or PACKING

	 */

	int next_buf_to_fill;

	/*

	 * number of buffers that are currently filled (PRIMED)

	 * -> these buffers are hardware-owned
@@ -648,7 +635,6 @@ struct qeth_seqno { 
	__u32 pdu_hdr;

	__u32 pdu_hdr_ack;

	__u16 ipa;

	__u32 pkt_seqno;

};



struct qeth_reply {
@@ -679,7 +665,7 @@ struct qeth_card_info { 
	__u16 func_level;

	char mcl_level[QETH_MCL_LENGTH + 1];

	u8 open_when_online:1;

	int guestlan;

	u8 is_vm_nic:1;

	int mac_bits;

	enum qeth_card_types type;

	enum qeth_link_types link_type;
@@ -895,6 +881,16 @@ static inline int qeth_get_ip_version(struct sk_buff *skb) 
	}

}



static inline int qeth_get_ether_cast_type(struct sk_buff *skb)

{

	u8 *addr = eth_hdr(skb)->h_dest;



	if (is_multicast_ether_addr(addr))

		return is_broadcast_ether_addr(addr) ? RTN_BROADCAST :

						       RTN_MULTICAST;

	return RTN_UNICAST;

}



static inline void qeth_rx_csum(struct qeth_card *card, struct sk_buff *skb,

				u8 flags)

{

drivers/s390/net/qeth_core_main.c

+50 −72
Original line number Diff line number Diff line
@@ -85,7 +85,7 @@ static void qeth_close_dev_handler(struct work_struct *work) 


static const char *qeth_get_cardname(struct qeth_card *card)

{

	if (card->info.guestlan) {

	if (IS_VM_NIC(card)) {

		switch (card->info.type) {

		case QETH_CARD_TYPE_OSD:

			return " Virtual NIC QDIO";
@@ -120,7 +120,7 @@ static const char *qeth_get_cardname(struct qeth_card *card) 
/* max length to be returned: 14 */

const char *qeth_get_cardname_short(struct qeth_card *card)

{

	if (card->info.guestlan) {

	if (IS_VM_NIC(card)) {

		switch (card->info.type) {

		case QETH_CARD_TYPE_OSD:

			return "Virt.NIC QDIO";
@@ -1165,15 +1165,14 @@ static void qeth_clear_output_buffer(struct qeth_qdio_out_q *queue, 


	qeth_release_skbs(buf);



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

	for (i = 0; i < queue->max_elements; ++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;

	}



	qeth_scrub_qdio_buffer(buf->buffer,

			       QETH_MAX_BUFFER_ELEMENTS(queue->card));

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

	buf->next_element_to_fill = 0;

	atomic_set(&buf->state, QETH_QDIO_BUF_EMPTY);

}
@@ -1330,7 +1329,7 @@ static void qeth_init_qdio_info(struct qeth_card *card) 
	/* inbound */

	card->qdio.no_in_queues = 1;

	card->qdio.in_buf_size = QETH_IN_BUF_SIZE_DEFAULT;

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

	if (IS_IQD(card))

		card->qdio.init_pool.buf_count = QETH_IN_BUF_COUNT_HSDEFAULT;

	else

		card->qdio.init_pool.buf_count = QETH_IN_BUF_COUNT_DEFAULT;
@@ -1554,7 +1553,7 @@ int qeth_qdio_clear_card(struct qeth_card *card, int use_halt) 
	switch (atomic_cmpxchg(&card->qdio.state, QETH_QDIO_ESTABLISHED,

		QETH_QDIO_CLEANING)) {

	case QETH_QDIO_ESTABLISHED:

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

		if (IS_IQD(card))

			rc = qdio_shutdown(CARD_DDEV(card),

				QDIO_FLAG_CLEANUP_USING_HALT);

		else
@@ -1627,7 +1626,7 @@ static void qeth_configure_unitaddr(struct qeth_card *card, char *prcd) 
	card->info.chpid = prcd[30];

	card->info.unit_addr2 = prcd[31];

	card->info.cula = prcd[63];

	card->info.guestlan = ((prcd[0x10] == _ascebc['V']) &&

	card->info.is_vm_nic = ((prcd[0x10] == _ascebc['V']) &&

				(prcd[0x11] == _ascebc['M']));

}
@@ -1692,12 +1691,10 @@ static enum qeth_discipline_id qeth_enforce_discipline(struct qeth_card *card) 
{

	enum qeth_discipline_id disc = QETH_DISCIPLINE_UNDETERMINED;



	if (card->info.type == QETH_CARD_TYPE_OSM ||

	    card->info.type == QETH_CARD_TYPE_OSN)

	if (IS_OSM(card) || IS_OSN(card))

		disc = QETH_DISCIPLINE_LAYER2;

	else if (card->info.guestlan)

		disc = (card->info.type == QETH_CARD_TYPE_IQD) ?

				QETH_DISCIPLINE_LAYER3 :

	else if (IS_VM_NIC(card))

		disc = IS_IQD(card) ? QETH_DISCIPLINE_LAYER3 :

				      qeth_vm_detect_layer(card);



	switch (disc) {
@@ -2217,7 +2214,7 @@ static int qeth_ulp_enable_cb(struct qeth_card *card, struct qeth_reply *reply, 
	memcpy(&card->token.ulp_filter_r,

	       QETH_ULP_ENABLE_RESP_FILTER_TOKEN(iob->data),

	       QETH_MPC_TOKEN_LENGTH);

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

	if (IS_IQD(card)) {

		memcpy(&framesize, QETH_ULP_ENABLE_RESP_MAX_MTU(iob->data), 2);

		mtu = qeth_get_mtu_outof_framesize(framesize);

	} else {
@@ -2388,6 +2385,7 @@ static int qeth_alloc_qdio_queues(struct qeth_card *card) 
			goto out_freeoutq;

		QETH_DBF_TEXT_(SETUP, 2, "outq %i", i);

		QETH_DBF_HEX(SETUP, 2, &card->qdio.out_qs[i], sizeof(void *));

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

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

		/* give outbound qeth_qdio_buffers their qdio_buffers */

		for (j = 0; j < QDIO_MAX_BUFFERS_PER_Q; ++j) {
@@ -2555,7 +2553,7 @@ static int qeth_mpc_initialize(struct qeth_card *card) 


	return 0;

out_qdio:

	qeth_qdio_clear_card(card, card->info.type != QETH_CARD_TYPE_IQD);

	qeth_qdio_clear_card(card, !IS_IQD(card));

	qdio_free(CARD_DDEV(card));

	return rc;

}
@@ -2578,8 +2576,7 @@ void qeth_print_status_message(struct qeth_card *card) 
		}

		/* fallthrough */

	case QETH_CARD_TYPE_IQD:

		if ((card->info.guestlan) ||

		    (card->info.mcl_level[0] & 0x80)) {

		if (IS_VM_NIC(card) || (card->info.mcl_level[0] & 0x80)) {

			card->info.mcl_level[0] = (char) _ebcasc[(__u8)

				card->info.mcl_level[0]];

			card->info.mcl_level[1] = (char) _ebcasc[(__u8)
@@ -2700,7 +2697,7 @@ static int qeth_init_input_buffer(struct qeth_card *card, 


int qeth_init_qdio_queues(struct qeth_card *card)

{

	int i, j;

	unsigned int i;

	int rc;



	QETH_DBF_TEXT(SETUP, 2, "initqdqs");
@@ -2729,19 +2726,15 @@ int qeth_init_qdio_queues(struct qeth_card *card) 


	/* outbound queue */

	for (i = 0; i < card->qdio.no_out_queues; ++i) {

		qdio_reset_buffers(card->qdio.out_qs[i]->qdio_bufs,

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

		}

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

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

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

		atomic_set(&card->qdio.out_qs[i]->used_buffers, 0);

		atomic_set(&card->qdio.out_qs[i]->set_pci_flags_count, 0);

		atomic_set(&card->qdio.out_qs[i]->state,

			   QETH_OUT_Q_UNLOCKED);

		struct qeth_qdio_out_q *queue = card->qdio.out_qs[i];



		qdio_reset_buffers(queue->qdio_bufs, QDIO_MAX_BUFFERS_PER_Q);

		queue->max_elements = QETH_MAX_BUFFER_ELEMENTS(card);

		queue->next_buf_to_fill = 0;

		queue->do_pack = 0;

		atomic_set(&queue->used_buffers, 0);

		atomic_set(&queue->set_pci_flags_count, 0);

		atomic_set(&queue->state, QETH_OUT_Q_UNLOCKED);

	}

	return 0;

}
@@ -3237,7 +3230,7 @@ static void qeth_handle_send_error(struct qeth_card *card, 
	int sbalf15 = buffer->buffer->element[15].sflags;



	QETH_CARD_TEXT(card, 6, "hdsnderr");

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

	if (IS_IQD(card)) {

		if (sbalf15 == 0) {

			qdio_err = 0;

		} else {
@@ -3334,7 +3327,7 @@ static void qeth_flush_buffers(struct qeth_qdio_out_q *queue, int index, 
		if (queue->bufstates)

			queue->bufstates[bidx].user = buf;



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

		if (IS_IQD(queue->card))

			continue;



		if (!queue->do_pack) {
@@ -3565,7 +3558,7 @@ static void qeth_qdio_output_handler(struct ccw_device *ccwdev, 


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

			qeth_scrub_qdio_buffer(buffer->buffer,

					       QETH_MAX_BUFFER_ELEMENTS(card));

					       queue->max_elements);

			if (qeth_init_qdio_out_buf(queue, bidx)) {

				QETH_CARD_TEXT(card, 2, "outofbuf");

				qeth_schedule_recovery(card);
@@ -3585,7 +3578,7 @@ static void qeth_qdio_output_handler(struct ccw_device *ccwdev, 
	}

	atomic_sub(count, &queue->used_buffers);

	/* check if we need to do something on this outbound queue */

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

	if (!IS_IQD(card))

		qeth_check_outbound_queue(queue);



	if (IS_IQD(card))
@@ -3712,8 +3705,8 @@ static int qeth_add_hw_header(struct qeth_qdio_out_q *queue, 
			      unsigned int hdr_len, unsigned int proto_len,

			      unsigned int *elements)

{

	const unsigned int max_elements = QETH_MAX_BUFFER_ELEMENTS(queue->card);

	const unsigned int contiguous = proto_len ? proto_len : 1;

	const unsigned int max_elements = queue->max_elements;

	unsigned int __elements;

	addr_t start, end;

	bool push_ok;
@@ -3885,8 +3878,8 @@ static int qeth_fill_buffer(struct qeth_qdio_out_q *queue, 


		QETH_TXQ_STAT_INC(queue, skbs_pack);

		/* If the buffer still has free elements, keep using it. */

		if (!flush && buf->next_element_to_fill <

			      QETH_MAX_BUFFER_ELEMENTS(queue->card))

		if (!flush &&

		    buf->next_element_to_fill < queue->max_elements)

			return 0;

	}
@@ -3966,8 +3959,8 @@ int qeth_do_send_packet(struct qeth_card *card, struct qeth_qdio_out_q *queue, 
	if (queue->do_pack) {

		do_pack = 1;

		/* does packet fit in current buffer? */

		if ((QETH_MAX_BUFFER_ELEMENTS(card) -

		    buffer->next_element_to_fill) < elements_needed) {

		if (buffer->next_element_to_fill + elements_needed >

		    queue->max_elements) {

			/* ... no -> set state PRIMED */

			atomic_set(&buffer->state, QETH_QDIO_BUF_PRIMED);

			flush_count++;
@@ -4336,8 +4329,7 @@ int qeth_set_access_ctrl_online(struct qeth_card *card, int fallback) 


	QETH_CARD_TEXT(card, 4, "setactlo");



	if ((card->info.type == QETH_CARD_TYPE_OSD ||

	     card->info.type == QETH_CARD_TYPE_OSX) &&

	if ((IS_OSD(card) || IS_OSX(card)) &&

	    qeth_adp_supported(card, IPA_SETADP_SET_ACCESS_CONTROL)) {

		rc = qeth_setadpparms_set_access_ctrl(card,

			card->options.isolation, fallback);
@@ -4503,7 +4495,7 @@ static int qeth_snmp_command(struct qeth_card *card, char __user *udata) 


	QETH_CARD_TEXT(card, 3, "snmpcmd");



	if (card->info.guestlan)

	if (IS_VM_NIC(card))

		return -EOPNOTSUPP;



	if ((!qeth_adp_supported(card, IPA_SETADP_SET_SNMP_CONTROL)) &&
@@ -4746,14 +4738,6 @@ int qeth_vm_request_mac(struct qeth_card *card) 
}

EXPORT_SYMBOL_GPL(qeth_vm_request_mac);



static int qeth_get_qdio_q_format(struct qeth_card *card)

{

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

		return QDIO_IQDIO_QFMT;

	else

		return QDIO_QETH_QFMT;

}



static void qeth_determine_capabilities(struct qeth_card *card)

{

	int rc;
@@ -4892,7 +4876,8 @@ static int qeth_qdio_establish(struct qeth_card *card) 


	memset(&init_data, 0, sizeof(struct qdio_initialize));

	init_data.cdev                   = CARD_DDEV(card);

	init_data.q_format               = qeth_get_qdio_q_format(card);

	init_data.q_format		 = IS_IQD(card) ? QDIO_IQDIO_QFMT :

							  QDIO_QETH_QFMT;

	init_data.qib_param_field_format = 0;

	init_data.qib_param_field        = qib_param_field;

	init_data.no_input_qs            = card->qdio.no_in_queues;
@@ -4904,8 +4889,7 @@ static int qeth_qdio_establish(struct qeth_card *card) 
	init_data.input_sbal_addr_array  = in_sbal_ptrs;

	init_data.output_sbal_addr_array = out_sbal_ptrs;

	init_data.output_sbal_state_array = card->qdio.out_bufstates;

	init_data.scan_threshold =

		(card->info.type == QETH_CARD_TYPE_IQD) ? 1 : 32;

	init_data.scan_threshold	 = IS_IQD(card) ? 1 : 32;



	if (atomic_cmpxchg(&card->qdio.state, QETH_QDIO_ALLOCATED,

		QETH_QDIO_ESTABLISHED) == QETH_QDIO_ALLOCATED) {
@@ -5007,7 +4991,7 @@ int qeth_core_hardsetup_card(struct qeth_card *card, bool *carrier_ok) 
	if (retries < 3)

		QETH_DBF_MESSAGE(2, "Retrying to do IDX activates on device %x.\n",

				 CARD_DEVID(card));

	rc = qeth_qdio_clear_card(card, card->info.type != QETH_CARD_TYPE_IQD);

	rc = qeth_qdio_clear_card(card, !IS_IQD(card));

	ccw_device_set_offline(CARD_DDEV(card));

	ccw_device_set_offline(CARD_WDEV(card));

	ccw_device_set_offline(CARD_RDEV(card));
@@ -5189,7 +5173,7 @@ struct sk_buff *qeth_core_get_next_skb(struct qeth_card *card, 
		return NULL;



	if (((skb_len >= card->options.rx_sg_cb) &&

	     (!(card->info.type == QETH_CARD_TYPE_OSN)) &&

	     !IS_OSN(card) &&

	     (!atomic_read(&card->force_alloc_skb))) ||

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

		use_rx_sg = 1;
@@ -5687,9 +5671,8 @@ static int qeth_core_probe_device(struct ccwgroup_device *gdev) 
		if (rc)

			goto err_load;



		gdev->dev.type = (card->info.type != QETH_CARD_TYPE_OSN)

					? card->discipline->devtype

					: &qeth_osn_devtype;

		gdev->dev.type = IS_OSN(card) ? &qeth_osn_devtype :

						card->discipline->devtype;

		rc = card->discipline->setup(card->gdev);

		if (rc)

			goto err_disc;
@@ -5733,10 +5716,8 @@ static int qeth_core_set_online(struct ccwgroup_device *gdev) 
	enum qeth_discipline_id def_discipline;



	if (!card->discipline) {

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

			def_discipline = QETH_DISCIPLINE_LAYER3;

		else

			def_discipline = QETH_DISCIPLINE_LAYER2;

		def_discipline = IS_IQD(card) ? QETH_DISCIPLINE_LAYER3 :

						QETH_DISCIPLINE_LAYER2;

		rc = qeth_core_load_discipline(card, def_discipline);

		if (rc)

			goto err;
@@ -5864,12 +5845,9 @@ int qeth_do_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) 
		rc = qeth_snmp_command(card, rq->ifr_ifru.ifru_data);

		break;

	case SIOC_QETH_GET_CARD_TYPE:

		if ((card->info.type == QETH_CARD_TYPE_OSD ||

		     card->info.type == QETH_CARD_TYPE_OSM ||

		     card->info.type == QETH_CARD_TYPE_OSX) &&

		    !card->info.guestlan)

		if ((IS_OSD(card) || IS_OSM(card) || IS_OSX(card)) &&

		    !IS_VM_NIC(card))

			return 1;

		else

		return 0;

	case SIOCGMIIPHY:

		mii_data = if_mii(rq);

drivers/s390/net/qeth_core_mpc.h

+1 −1
Original line number Diff line number Diff line
@@ -82,7 +82,7 @@ enum qeth_card_types { 
#define IS_OSM(card)	((card)->info.type == QETH_CARD_TYPE_OSM)

#define IS_OSN(card)	((card)->info.type == QETH_CARD_TYPE_OSN)

#define IS_OSX(card)	((card)->info.type == QETH_CARD_TYPE_OSX)

#define IS_VM_NIC(card)	((card)->info.guestlan)

#define IS_VM_NIC(card)	((card)->info.is_vm_nic)



#define QETH_MPC_DIFINFO_LEN_INDICATES_LINK_TYPE 0x18

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

drivers/s390/net/qeth_core_sys.c

+1 −2
Original line number Diff line number Diff line
@@ -479,8 +479,7 @@ static ssize_t qeth_dev_isolation_store(struct device *dev, 
		return -EINVAL;



	mutex_lock(&card->conf_mutex);

	if (card->info.type != QETH_CARD_TYPE_OSD &&

	    card->info.type != QETH_CARD_TYPE_OSX) {

	if (!IS_OSD(card) && !IS_OSX(card)) {

		rc = -EOPNOTSUPP;

		dev_err(&card->gdev->dev, "Adapter does not "

			"support QDIO data connection isolation\n");

drivers/s390/net/qeth_l2_main.c

+10 −23
Original line number Diff line number Diff line
@@ -161,15 +161,6 @@ static void qeth_l2_drain_rx_mode_cache(struct qeth_card *card) 
	}

}



static int qeth_l2_get_cast_type(struct sk_buff *skb)

{

	if (is_broadcast_ether_addr(skb->data))

		return RTN_BROADCAST;

	if (is_multicast_ether_addr(skb->data))

		return RTN_MULTICAST;

	return RTN_UNICAST;

}



static void qeth_l2_fill_header(struct qeth_qdio_out_q *queue,

				struct qeth_hdr *hdr, struct sk_buff *skb,

				int ipv, int cast_type, unsigned int data_len)
@@ -332,13 +323,11 @@ static int qeth_l2_process_inbound_buffer(struct qeth_card *card, 
		case QETH_HEADER_TYPE_LAYER2:

			skb->protocol = eth_type_trans(skb, skb->dev);

			qeth_rx_csum(card, skb, hdr->hdr.l2.flags[1]);

			if (skb->protocol == htons(ETH_P_802_2))

				*((__u32 *)skb->cb) = ++card->seqno.pkt_seqno;

			len = skb->len;

			napi_gro_receive(&card->napi, skb);

			break;

		case QETH_HEADER_TYPE_OSN:

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

			if (IS_OSN(card)) {

				skb_push(skb, sizeof(struct qeth_hdr));

				skb_copy_to_linear_data(skb, hdr,

						sizeof(struct qeth_hdr));
@@ -389,8 +378,7 @@ static int qeth_l2_request_initial_mac(struct qeth_card *card) 
	}



	/* some devices don't support a custom MAC address: */

	if (card->info.type == QETH_CARD_TYPE_OSM ||

	    card->info.type == QETH_CARD_TYPE_OSX)

	if (IS_OSM(card) || IS_OSX(card))

		return (rc) ? rc : -EADDRNOTAVAIL;

	eth_hw_addr_random(card->dev);
@@ -584,7 +572,7 @@ static int qeth_l2_xmit_osn(struct qeth_card *card, struct sk_buff *skb, 
	}



	elements += qeth_count_elements(skb, hd_len);

	if (elements > QETH_MAX_BUFFER_ELEMENTS(card)) {

	if (elements > queue->max_elements) {

		rc = -E2BIG;

		goto out;

	}
@@ -614,7 +602,8 @@ static netdev_tx_t qeth_l2_hard_start_xmit(struct sk_buff *skb, 
		rc = qeth_l2_xmit_osn(card, skb, queue);

	else

		rc = qeth_xmit(card, skb, queue, qeth_get_ip_version(skb),

			       qeth_l2_get_cast_type(skb), qeth_l2_fill_header);

			       qeth_get_ether_cast_type(skb),

			       qeth_l2_fill_header);



	if (!rc) {

		QETH_TXQ_STAT_INC(queue, tx_packets);
@@ -634,7 +623,7 @@ static u16 qeth_l2_select_queue(struct net_device *dev, struct sk_buff *skb, 


	if (IS_IQD(card))

		return qeth_iqd_select_queue(dev, skb,

					     qeth_l2_get_cast_type(skb),

					     qeth_get_ether_cast_type(skb),

					     sb_dev);

	return qeth_get_priority_queue(card, skb);

}
@@ -735,7 +724,7 @@ static int qeth_l2_setup_netdev(struct qeth_card *card, bool carrier_ok) 
		card->dev->features |= NETIF_F_HW_VLAN_CTAG_FILTER;

	}



	if (card->info.type == QETH_CARD_TYPE_OSD && !card->info.guestlan) {

	if (IS_OSD(card) && !IS_VM_NIC(card)) {

		card->dev->features |= NETIF_F_SG;

		/* OSA 3S and earlier has no RX/TX support */

		if (qeth_is_supported(card, IPA_OUTBOUND_CHECKSUM)) {
@@ -845,8 +834,7 @@ static int qeth_l2_set_online(struct ccwgroup_device *gdev) 
	/* softsetup */

	QETH_DBF_TEXT(SETUP, 2, "softsetp");



	if ((card->info.type == QETH_CARD_TYPE_OSD) ||

	    (card->info.type == QETH_CARD_TYPE_OSX)) {

	if (IS_OSD(card) || IS_OSX(card)) {

		rc = qeth_l2_start_ipassists(card);

		if (rc)

			goto out_remove;
@@ -1470,8 +1458,7 @@ static struct qeth_cmd_buffer *qeth_sbp_build_cmd(struct qeth_card *card, 
						  enum qeth_ipa_sbp_cmd sbp_cmd,

						  unsigned int cmd_length)

{

	enum qeth_ipa_cmds ipa_cmd = (card->info.type == QETH_CARD_TYPE_IQD) ?

					IPA_CMD_SETBRIDGEPORT_IQD :

	enum qeth_ipa_cmds ipa_cmd = IS_IQD(card) ? IPA_CMD_SETBRIDGEPORT_IQD :

						    IPA_CMD_SETBRIDGEPORT_OSA;

	struct qeth_cmd_buffer *iob;

	struct qeth_ipa_cmd *cmd;