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

Merge branch 's390-qeth-updates' 



Julian Wiedmann says:

====================
more s390/net updates

here's a second batch of s390/net patches for net-next.
A mixed bunch of qeth cleanups, and a few patches to add support for
ETHTOOL_GLINKSETTINGS.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 40077e0c 6ffa4d1b

drivers/s390/net/qeth_core.h

+8 −13
Original line number Diff line number Diff line
@@ -240,7 +240,6 @@ static inline int qeth_is_ipa_enabled(struct qeth_ipa_info *ipa, 
#define QETH_TX_TIMEOUT		100 * HZ

#define QETH_RCD_TIMEOUT	60 * HZ

#define QETH_RECLAIM_WORK_TIME	HZ

#define QETH_HEADER_SIZE	32

#define QETH_MAX_PORTNO		15



/*IPv6 address autoconfiguration stuff*/
@@ -447,7 +446,7 @@ struct qeth_qdio_out_buffer { 
	atomic_t state;

	int next_element_to_fill;

	struct sk_buff_head skb_list;

	int is_header[16];

	int is_header[QDIO_MAX_ELEMENTS_PER_BUFFER];



	struct qaob *aob;

	struct qeth_qdio_out_q *q;
@@ -705,17 +704,16 @@ struct qeth_discipline { 
	void (*start_poll)(struct ccw_device *, int, unsigned long);

	qdio_handler_t *input_handler;

	qdio_handler_t *output_handler;

	int (*process_rx_buffer)(struct qeth_card *card, int budget, int *done);

	int (*recover)(void *ptr);

	int (*setup) (struct ccwgroup_device *);

	void (*remove) (struct ccwgroup_device *);

	int (*set_online) (struct ccwgroup_device *);

	int (*set_offline) (struct ccwgroup_device *);

	void (*shutdown)(struct ccwgroup_device *);

	int (*prepare) (struct ccwgroup_device *);

	void (*complete) (struct ccwgroup_device *);

	int (*freeze)(struct ccwgroup_device *);

	int (*thaw) (struct ccwgroup_device *);

	int (*restore)(struct ccwgroup_device *);

	int (*do_ioctl)(struct net_device *dev, struct ifreq *rq, int cmd);

	int (*control_event_handler)(struct qeth_card *card,

					struct qeth_ipa_cmd *cmd);

};
@@ -908,14 +906,12 @@ int qeth_send_ipa_cmd(struct qeth_card *, struct qeth_cmd_buffer *, 
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 *);

int qeth_check_qdio_errors(struct qeth_card *, struct qdio_buffer *,

		unsigned int, const char *);

void qeth_queue_input_buffer(struct qeth_card *, int);

struct sk_buff *qeth_core_get_next_skb(struct qeth_card *,

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

		struct qeth_hdr **);

void qeth_schedule_recovery(struct qeth_card *);

void qeth_qdio_start_poll(struct ccw_device *, int, unsigned long);

int qeth_poll(struct napi_struct *napi, int budget);

void qeth_qdio_input_handler(struct ccw_device *,

		unsigned int, unsigned int, int,

		int, unsigned long);
@@ -936,9 +932,6 @@ void qeth_prepare_control_data(struct qeth_card *, int, 
void qeth_release_buffer(struct qeth_channel *, struct qeth_cmd_buffer *);

void qeth_prepare_ipa_cmd(struct qeth_card *, struct qeth_cmd_buffer *, char);

struct qeth_cmd_buffer *qeth_wait_for_buffer(struct qeth_channel *);

int qeth_mdio_read(struct net_device *, int, int);

int qeth_snmp_command(struct qeth_card *, char __user *);

int qeth_query_oat_command(struct qeth_card *, char __user *);

int qeth_query_switch_attributes(struct qeth_card *card,

				  struct qeth_switch_info *sw_info);

int qeth_send_control_data(struct qeth_card *, int, struct qeth_cmd_buffer *,
@@ -953,16 +946,18 @@ 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 *);

int qeth_do_send_packet_fast(struct qeth_card *, struct qeth_qdio_out_q *,

			struct sk_buff *, struct qeth_hdr *, int, int, int);

			struct sk_buff *, struct qeth_hdr *, int, int);

int qeth_do_send_packet(struct qeth_card *, struct qeth_qdio_out_q *,

		    struct sk_buff *, struct qeth_hdr *, int);

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

int qeth_core_get_sset_count(struct net_device *, int);

void qeth_core_get_ethtool_stats(struct net_device *,

				struct ethtool_stats *, u64 *);

void qeth_core_get_strings(struct net_device *, u32, u8 *);

void qeth_core_get_drvinfo(struct net_device *, struct ethtool_drvinfo *);

void qeth_dbf_longtext(debug_info_t *id, int level, char *text, ...);

int qeth_core_ethtool_get_settings(struct net_device *, struct ethtool_cmd *);

int qeth_core_ethtool_get_link_ksettings(struct net_device *netdev,

					 struct ethtool_link_ksettings *cmd);

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

drivers/s390/net/qeth_core_main.c

+242 −107
Original line number Diff line number Diff line
@@ -3216,8 +3216,10 @@ int qeth_hw_trap(struct qeth_card *card, enum qeth_diags_trap_action action) 
}

EXPORT_SYMBOL_GPL(qeth_hw_trap);



int qeth_check_qdio_errors(struct qeth_card *card, struct qdio_buffer *buf,

		unsigned int qdio_error, const char *dbftext)

static int qeth_check_qdio_errors(struct qeth_card *card,

				  struct qdio_buffer *buf,

				  unsigned int qdio_error,

				  const char *dbftext)

{

	if (qdio_error) {

		QETH_CARD_TEXT(card, 2, dbftext);
@@ -3234,18 +3236,8 @@ int qeth_check_qdio_errors(struct qeth_card *card, struct qdio_buffer *buf, 
	}

	return 0;

}

EXPORT_SYMBOL_GPL(qeth_check_qdio_errors);



static void qeth_buffer_reclaim_work(struct work_struct *work)

{

	struct qeth_card *card = container_of(work, struct qeth_card,

		buffer_reclaim_work.work);



	QETH_CARD_TEXT_(card, 2, "brw:%x", card->reclaim_index);

	qeth_queue_input_buffer(card, card->reclaim_index);

}



void qeth_queue_input_buffer(struct qeth_card *card, int index)

static void qeth_queue_input_buffer(struct qeth_card *card, int index)

{

	struct qeth_qdio_q *queue = card->qdio.in_q;

	struct list_head *lh;
@@ -3319,7 +3311,15 @@ void qeth_queue_input_buffer(struct qeth_card *card, int index) 
					  QDIO_MAX_BUFFERS_PER_Q;

	}

}

EXPORT_SYMBOL_GPL(qeth_queue_input_buffer);



static void qeth_buffer_reclaim_work(struct work_struct *work)

{

	struct qeth_card *card = container_of(work, struct qeth_card,

		buffer_reclaim_work.work);



	QETH_CARD_TEXT_(card, 2, "brw:%x", card->reclaim_index);

	qeth_queue_input_buffer(card, card->reclaim_index);

}



static void qeth_handle_send_error(struct qeth_card *card,

		struct qeth_qdio_out_buffer *buffer, unsigned int qdio_err)
@@ -4024,8 +4024,7 @@ static inline int qeth_fill_buffer(struct qeth_qdio_out_q *queue, 


int qeth_do_send_packet_fast(struct qeth_card *card,

		struct qeth_qdio_out_q *queue, struct sk_buff *skb,

		struct qeth_hdr *hdr, int elements_needed,

		int offset, int hd_len)

		struct qeth_hdr *hdr, int offset, int hd_len)

{

	struct qeth_qdio_out_buffer *buffer;

	int index;
@@ -4417,7 +4416,7 @@ void qeth_tx_timeout(struct net_device *dev) 
}

EXPORT_SYMBOL_GPL(qeth_tx_timeout);



int qeth_mdio_read(struct net_device *dev, int phy_id, int regnum)

static int qeth_mdio_read(struct net_device *dev, int phy_id, int regnum)

{

	struct qeth_card *card = dev->ml_priv;

	int rc = 0;
@@ -4480,7 +4479,6 @@ int qeth_mdio_read(struct net_device *dev, int phy_id, int regnum) 
	}

	return rc;

}

EXPORT_SYMBOL_GPL(qeth_mdio_read);



static int qeth_send_ipa_snmp_cmd(struct qeth_card *card,

		struct qeth_cmd_buffer *iob, int len,
@@ -4570,7 +4568,7 @@ static int qeth_snmp_command_cb(struct qeth_card *card, 
	return 0;

}



int qeth_snmp_command(struct qeth_card *card, char __user *udata)

static int qeth_snmp_command(struct qeth_card *card, char __user *udata)

{

	struct qeth_cmd_buffer *iob;

	struct qeth_ipa_cmd *cmd;
@@ -4630,7 +4628,6 @@ int qeth_snmp_command(struct qeth_card *card, char __user *udata) 
	kfree(qinfo.udata);

	return rc;

}

EXPORT_SYMBOL_GPL(qeth_snmp_command);



static int qeth_setadpparms_query_oat_cb(struct qeth_card *card,

		struct qeth_reply *reply, unsigned long data)
@@ -4662,7 +4659,7 @@ static int qeth_setadpparms_query_oat_cb(struct qeth_card *card, 
	return 0;

}



int qeth_query_oat_command(struct qeth_card *card, char __user *udata)

static int qeth_query_oat_command(struct qeth_card *card, char __user *udata)

{

	int rc = 0;

	struct qeth_cmd_buffer *iob;
@@ -4732,7 +4729,6 @@ int qeth_query_oat_command(struct qeth_card *card, char __user *udata) 
out:

	return rc;

}

EXPORT_SYMBOL_GPL(qeth_query_oat_command);



static int qeth_query_card_info_cb(struct qeth_card *card,

				   struct qeth_reply *reply, unsigned long data)
@@ -5285,6 +5281,83 @@ struct sk_buff *qeth_core_get_next_skb(struct qeth_card *card, 
}

EXPORT_SYMBOL_GPL(qeth_core_get_next_skb);



int qeth_poll(struct napi_struct *napi, int budget)

{

	struct qeth_card *card = container_of(napi, struct qeth_card, napi);

	int work_done = 0;

	struct qeth_qdio_buffer *buffer;

	int done;

	int new_budget = budget;



	if (card->options.performance_stats) {

		card->perf_stats.inbound_cnt++;

		card->perf_stats.inbound_start_time = qeth_get_micros();

	}



	while (1) {

		if (!card->rx.b_count) {

			card->rx.qdio_err = 0;

			card->rx.b_count = qdio_get_next_buffers(

				card->data.ccwdev, 0, &card->rx.b_index,

				&card->rx.qdio_err);

			if (card->rx.b_count <= 0) {

				card->rx.b_count = 0;

				break;

			}

			card->rx.b_element =

				&card->qdio.in_q->bufs[card->rx.b_index]

				.buffer->element[0];

			card->rx.e_offset = 0;

		}



		while (card->rx.b_count) {

			buffer = &card->qdio.in_q->bufs[card->rx.b_index];

			if (!(card->rx.qdio_err &&

			    qeth_check_qdio_errors(card, buffer->buffer,

			    card->rx.qdio_err, "qinerr")))

				work_done +=

					card->discipline->process_rx_buffer(

						card, new_budget, &done);

			else

				done = 1;



			if (done) {

				if (card->options.performance_stats)

					card->perf_stats.bufs_rec++;

				qeth_put_buffer_pool_entry(card,

					buffer->pool_entry);

				qeth_queue_input_buffer(card, card->rx.b_index);

				card->rx.b_count--;

				if (card->rx.b_count) {

					card->rx.b_index =

						(card->rx.b_index + 1) %

						QDIO_MAX_BUFFERS_PER_Q;

					card->rx.b_element =

						&card->qdio.in_q

						->bufs[card->rx.b_index]

						.buffer->element[0];

					card->rx.e_offset = 0;

				}

			}



			if (work_done >= budget)

				goto out;

			else

				new_budget = budget - work_done;

		}

	}



	napi_complete(napi);

	if (qdio_start_irq(card->data.ccwdev, 0))

		napi_schedule(&card->napi);

out:

	if (card->options.performance_stats)

		card->perf_stats.inbound_time += qeth_get_micros() -

			card->perf_stats.inbound_start_time;

	return work_done;

}

EXPORT_SYMBOL_GPL(qeth_poll);



int qeth_setassparms_cb(struct qeth_card *card,

			struct qeth_reply *reply, unsigned long data)

{
@@ -5675,23 +5748,12 @@ static int qeth_core_set_offline(struct ccwgroup_device *gdev) 
static void qeth_core_shutdown(struct ccwgroup_device *gdev)

{

	struct qeth_card *card = dev_get_drvdata(&gdev->dev);

	if (card->discipline && card->discipline->shutdown)

		card->discipline->shutdown(gdev);

}



static int qeth_core_prepare(struct ccwgroup_device *gdev)

{

	struct qeth_card *card = dev_get_drvdata(&gdev->dev);

	if (card->discipline && card->discipline->prepare)

		return card->discipline->prepare(gdev);

	return 0;

}



static void qeth_core_complete(struct ccwgroup_device *gdev)

{

	struct qeth_card *card = dev_get_drvdata(&gdev->dev);

	if (card->discipline && card->discipline->complete)

		card->discipline->complete(gdev);

	qeth_set_allowed_threads(card, 0, 1);

	if ((gdev->state == CCWGROUP_ONLINE) && card->info.hwtrap)

		qeth_hw_trap(card, QETH_DIAGS_TRAP_DISARM);

	qeth_qdio_clear_card(card, 0);

	qeth_clear_qdio_buffers(card);

	qdio_free(CARD_DDEV(card));

}



static int qeth_core_freeze(struct ccwgroup_device *gdev)
@@ -5728,8 +5790,8 @@ static struct ccwgroup_driver qeth_core_ccwgroup_driver = { 
	.set_online = qeth_core_set_online,

	.set_offline = qeth_core_set_offline,

	.shutdown = qeth_core_shutdown,

	.prepare = qeth_core_prepare,

	.complete = qeth_core_complete,

	.prepare = NULL,

	.complete = NULL,

	.freeze = qeth_core_freeze,

	.thaw = qeth_core_thaw,

	.restore = qeth_core_restore,
@@ -5759,6 +5821,60 @@ static const struct attribute_group *qeth_drv_attr_groups[] = { 
	NULL,

};



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

{

	struct qeth_card *card = dev->ml_priv;

	struct mii_ioctl_data *mii_data;

	int rc = 0;



	if (!card)

		return -ENODEV;



	if (!qeth_card_hw_is_reachable(card))

		return -ENODEV;



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

		return -EPERM;



	switch (cmd) {

	case SIOC_QETH_ADP_SET_SNMP_CONTROL:

		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)

			return 1;

		else

			return 0;

	case SIOCGMIIPHY:

		mii_data = if_mii(rq);

		mii_data->phy_id = 0;

		break;

	case SIOCGMIIREG:

		mii_data = if_mii(rq);

		if (mii_data->phy_id != 0)

			rc = -EINVAL;

		else

			mii_data->val_out = qeth_mdio_read(dev,

				mii_data->phy_id, mii_data->reg_num);

		break;

	case SIOC_QETH_QUERY_OAT:

		rc = qeth_query_oat_command(card, rq->ifr_ifru.ifru_data);

		break;

	default:

		if (card->discipline->do_ioctl)

			rc = card->discipline->do_ioctl(dev, rq, cmd);

		else

			rc = -EOPNOTSUPP;

	}

	if (rc)

		QETH_CARD_TEXT_(card, 2, "ioce%x", rc);

	return rc;

}

EXPORT_SYMBOL_GPL(qeth_do_ioctl);



static struct {

	const char str[ETH_GSTRING_LEN];

} qeth_ethtool_stats_keys[] = {
@@ -5893,104 +6009,124 @@ void qeth_core_get_drvinfo(struct net_device *dev, 
}

EXPORT_SYMBOL_GPL(qeth_core_get_drvinfo);



/* Helper function to fill 'advertizing' and 'supported' which are the same. */

/* Autoneg and full-duplex are supported and advertized uncondionally.	     */

/* Always advertize and support all speeds up to specified, and only one     */

/* Helper function to fill 'advertising' and 'supported' which are the same. */

/* Autoneg and full-duplex are supported and advertised unconditionally.     */

/* Always advertise and support all speeds up to specified, and only one     */

/* specified port type.							     */

static void qeth_set_ecmd_adv_sup(struct ethtool_cmd *ecmd,

static void qeth_set_cmd_adv_sup(struct ethtool_link_ksettings *cmd,

				int maxspeed, int porttype)

{

	int port_sup, port_adv, spd_sup, spd_adv;

	ethtool_link_ksettings_zero_link_mode(cmd, supported);

	ethtool_link_ksettings_zero_link_mode(cmd, advertising);

	ethtool_link_ksettings_zero_link_mode(cmd, lp_advertising);



	ethtool_link_ksettings_add_link_mode(cmd, supported, Autoneg);

	ethtool_link_ksettings_add_link_mode(cmd, advertising, Autoneg);



	switch (porttype) {

	case PORT_TP:

		port_sup = SUPPORTED_TP;

		port_adv = ADVERTISED_TP;

		ethtool_link_ksettings_add_link_mode(cmd, supported, TP);

		ethtool_link_ksettings_add_link_mode(cmd, advertising, TP);

		break;

	case PORT_FIBRE:

		port_sup = SUPPORTED_FIBRE;

		port_adv = ADVERTISED_FIBRE;

		ethtool_link_ksettings_add_link_mode(cmd, supported, FIBRE);

		ethtool_link_ksettings_add_link_mode(cmd, advertising, FIBRE);

		break;

	default:

		port_sup = SUPPORTED_TP;

		port_adv = ADVERTISED_TP;

		ethtool_link_ksettings_add_link_mode(cmd, supported, TP);

		ethtool_link_ksettings_add_link_mode(cmd, advertising, TP);

		WARN_ON_ONCE(1);

	}



	/* "Fallthrough" case'es ordered from high to low result in setting  */

	/* flags cumulatively, starting from the specified speed and down to */

	/* the lowest possible.						     */

	spd_sup = 0;

	spd_adv = 0;

	/* fallthrough from high to low, to select all legal speeds: */

	switch (maxspeed) {

	case SPEED_10000:

		spd_sup |= SUPPORTED_10000baseT_Full;

		spd_adv |= ADVERTISED_10000baseT_Full;

		ethtool_link_ksettings_add_link_mode(cmd, supported,

						     10000baseT_Full);

		ethtool_link_ksettings_add_link_mode(cmd, advertising,

						     10000baseT_Full);

	case SPEED_1000:

		spd_sup |= SUPPORTED_1000baseT_Half | SUPPORTED_1000baseT_Full;

		spd_adv |= ADVERTISED_1000baseT_Half |

						ADVERTISED_1000baseT_Full;

		ethtool_link_ksettings_add_link_mode(cmd, supported,

						     1000baseT_Full);

		ethtool_link_ksettings_add_link_mode(cmd, advertising,

						     1000baseT_Full);

		ethtool_link_ksettings_add_link_mode(cmd, supported,

						     1000baseT_Half);

		ethtool_link_ksettings_add_link_mode(cmd, advertising,

						     1000baseT_Half);

	case SPEED_100:

		spd_sup |= SUPPORTED_100baseT_Half | SUPPORTED_100baseT_Full;

		spd_adv |= ADVERTISED_100baseT_Half | ADVERTISED_100baseT_Full;

		ethtool_link_ksettings_add_link_mode(cmd, supported,

						     100baseT_Full);

		ethtool_link_ksettings_add_link_mode(cmd, advertising,

						     100baseT_Full);

		ethtool_link_ksettings_add_link_mode(cmd, supported,

						     100baseT_Half);

		ethtool_link_ksettings_add_link_mode(cmd, advertising,

						     100baseT_Half);

	case SPEED_10:

		spd_sup |= SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full;

		spd_adv |= ADVERTISED_10baseT_Half | ADVERTISED_10baseT_Full;

		ethtool_link_ksettings_add_link_mode(cmd, supported,

						     10baseT_Full);

		ethtool_link_ksettings_add_link_mode(cmd, advertising,

						     10baseT_Full);

		ethtool_link_ksettings_add_link_mode(cmd, supported,

						     10baseT_Half);

		ethtool_link_ksettings_add_link_mode(cmd, advertising,

						     10baseT_Half);

		/* end fallthrough */

		break;

	default:

		spd_sup = SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full;

		spd_adv = ADVERTISED_10baseT_Half | ADVERTISED_10baseT_Full;

		ethtool_link_ksettings_add_link_mode(cmd, supported,

						     10baseT_Full);

		ethtool_link_ksettings_add_link_mode(cmd, advertising,

						     10baseT_Full);

		ethtool_link_ksettings_add_link_mode(cmd, supported,

						     10baseT_Half);

		ethtool_link_ksettings_add_link_mode(cmd, advertising,

						     10baseT_Half);

		WARN_ON_ONCE(1);

	}

	ecmd->advertising = ADVERTISED_Autoneg | port_adv | spd_adv;

	ecmd->supported = SUPPORTED_Autoneg | port_sup | spd_sup;

}



int qeth_core_ethtool_get_settings(struct net_device *netdev,

					struct ethtool_cmd *ecmd)

int qeth_core_ethtool_get_link_ksettings(struct net_device *netdev,

		struct ethtool_link_ksettings *cmd)

{

	struct qeth_card *card = netdev->ml_priv;

	enum qeth_link_types link_type;

	struct carrier_info carrier_info;

	int rc;

	u32 speed;



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

		link_type = QETH_LINK_TYPE_10GBIT_ETH;

	else

		link_type = card->info.link_type;



	ecmd->transceiver = XCVR_INTERNAL;

	ecmd->duplex = DUPLEX_FULL;

	ecmd->autoneg = AUTONEG_ENABLE;

	cmd->base.duplex = DUPLEX_FULL;

	cmd->base.autoneg = AUTONEG_ENABLE;

	cmd->base.phy_address = 0;

	cmd->base.mdio_support = 0;

	cmd->base.eth_tp_mdix = ETH_TP_MDI_INVALID;

	cmd->base.eth_tp_mdix_ctrl = ETH_TP_MDI_INVALID;



	switch (link_type) {

	case QETH_LINK_TYPE_FAST_ETH:

	case QETH_LINK_TYPE_LANE_ETH100:

		qeth_set_ecmd_adv_sup(ecmd, SPEED_100, PORT_TP);

		speed = SPEED_100;

		ecmd->port = PORT_TP;

		cmd->base.speed = SPEED_100;

		cmd->base.port = PORT_TP;

		break;



	case QETH_LINK_TYPE_GBIT_ETH:

	case QETH_LINK_TYPE_LANE_ETH1000:

		qeth_set_ecmd_adv_sup(ecmd, SPEED_1000, PORT_FIBRE);

		speed = SPEED_1000;

		ecmd->port = PORT_FIBRE;

		cmd->base.speed = SPEED_1000;

		cmd->base.port = PORT_FIBRE;

		break;



	case QETH_LINK_TYPE_10GBIT_ETH:

		qeth_set_ecmd_adv_sup(ecmd, SPEED_10000, PORT_FIBRE);

		speed = SPEED_10000;

		ecmd->port = PORT_FIBRE;

		cmd->base.speed = SPEED_10000;

		cmd->base.port = PORT_FIBRE;

		break;



	default:

		qeth_set_ecmd_adv_sup(ecmd, SPEED_10, PORT_TP);

		speed = SPEED_10;

		ecmd->port = PORT_TP;

		cmd->base.speed = SPEED_10;

		cmd->base.port = PORT_TP;

	}

	ethtool_cmd_speed_set(ecmd, speed);

	qeth_set_cmd_adv_sup(cmd, cmd->base.speed, cmd->base.port);



	/* Check if we can obtain more accurate information.	 */

	/* If QUERY_CARD_INFO command is not supported or fails, */
@@ -6015,49 +6151,48 @@ int qeth_core_ethtool_get_settings(struct net_device *netdev, 
	switch (carrier_info.card_type) {

	case CARD_INFO_TYPE_1G_COPPER_A:

	case CARD_INFO_TYPE_1G_COPPER_B:

		qeth_set_ecmd_adv_sup(ecmd, SPEED_1000, PORT_TP);

		ecmd->port = PORT_TP;

		cmd->base.port = PORT_TP;

		qeth_set_cmd_adv_sup(cmd, SPEED_1000, cmd->base.port);

		break;

	case CARD_INFO_TYPE_1G_FIBRE_A:

	case CARD_INFO_TYPE_1G_FIBRE_B:

		qeth_set_ecmd_adv_sup(ecmd, SPEED_1000, PORT_FIBRE);

		ecmd->port = PORT_FIBRE;

		cmd->base.port = PORT_FIBRE;

		qeth_set_cmd_adv_sup(cmd, SPEED_1000, cmd->base.port);

		break;

	case CARD_INFO_TYPE_10G_FIBRE_A:

	case CARD_INFO_TYPE_10G_FIBRE_B:

		qeth_set_ecmd_adv_sup(ecmd, SPEED_10000, PORT_FIBRE);

		ecmd->port = PORT_FIBRE;

		cmd->base.port = PORT_FIBRE;

		qeth_set_cmd_adv_sup(cmd, SPEED_10000, cmd->base.port);

		break;

	}



	switch (carrier_info.port_mode) {

	case CARD_INFO_PORTM_FULLDUPLEX:

		ecmd->duplex = DUPLEX_FULL;

		cmd->base.duplex = DUPLEX_FULL;

		break;

	case CARD_INFO_PORTM_HALFDUPLEX:

		ecmd->duplex = DUPLEX_HALF;

		cmd->base.duplex = DUPLEX_HALF;

		break;

	}



	switch (carrier_info.port_speed) {

	case CARD_INFO_PORTS_10M:

		speed = SPEED_10;

		cmd->base.speed = SPEED_10;

		break;

	case CARD_INFO_PORTS_100M:

		speed = SPEED_100;

		cmd->base.speed = SPEED_100;

		break;

	case CARD_INFO_PORTS_1G:

		speed = SPEED_1000;

		cmd->base.speed = SPEED_1000;

		break;

	case CARD_INFO_PORTS_10G:

		speed = SPEED_10000;

		cmd->base.speed = SPEED_10000;

		break;

	}

	ethtool_cmd_speed_set(ecmd, speed);



	return 0;

}

EXPORT_SYMBOL_GPL(qeth_core_ethtool_get_settings);

EXPORT_SYMBOL_GPL(qeth_core_ethtool_get_link_ksettings);



/* Callback to handle checksum offload command reply from OSA card.

 * Verify that required features have been enabled on the card.

drivers/s390/net/qeth_l2_main.c

+9 −144

File changed.

Preview size limit exceeded, changes collapsed.

drivers/s390/net/qeth_l3_main.c

+9 −129
Original line number Diff line number Diff line
@@ -16,7 +16,6 @@ 
#include <linux/errno.h>

#include <linux/kernel.h>

#include <linux/etherdevice.h>

#include <linux/mii.h>

#include <linux/ip.h>

#include <linux/ipv6.h>

#include <linux/inetdevice.h>
@@ -1830,81 +1829,6 @@ static int qeth_l3_process_inbound_buffer(struct qeth_card *card, 
	return work_done;

}



static int qeth_l3_poll(struct napi_struct *napi, int budget)

{

	struct qeth_card *card = container_of(napi, struct qeth_card, napi);

	int work_done = 0;

	struct qeth_qdio_buffer *buffer;

	int done;

	int new_budget = budget;



	if (card->options.performance_stats) {

		card->perf_stats.inbound_cnt++;

		card->perf_stats.inbound_start_time = qeth_get_micros();

	}



	while (1) {

		if (!card->rx.b_count) {

			card->rx.qdio_err = 0;

			card->rx.b_count = qdio_get_next_buffers(

				card->data.ccwdev, 0, &card->rx.b_index,

				&card->rx.qdio_err);

			if (card->rx.b_count <= 0) {

				card->rx.b_count = 0;

				break;

			}

			card->rx.b_element =

				&card->qdio.in_q->bufs[card->rx.b_index]

				.buffer->element[0];

			card->rx.e_offset = 0;

		}



		while (card->rx.b_count) {

			buffer = &card->qdio.in_q->bufs[card->rx.b_index];

			if (!(card->rx.qdio_err &&

			    qeth_check_qdio_errors(card, buffer->buffer,

			    card->rx.qdio_err, "qinerr")))

				work_done += qeth_l3_process_inbound_buffer(

					card, new_budget, &done);

			else

				done = 1;



			if (done) {

				if (card->options.performance_stats)

					card->perf_stats.bufs_rec++;

				qeth_put_buffer_pool_entry(card,

					buffer->pool_entry);

				qeth_queue_input_buffer(card, card->rx.b_index);

				card->rx.b_count--;

				if (card->rx.b_count) {

					card->rx.b_index =

						(card->rx.b_index + 1) %

						QDIO_MAX_BUFFERS_PER_Q;

					card->rx.b_element =

						&card->qdio.in_q

						->bufs[card->rx.b_index]

						.buffer->element[0];

					card->rx.e_offset = 0;

				}

			}



			if (work_done >= budget)

				goto out;

			else

				new_budget = budget - work_done;

		}

	}



	napi_complete(napi);

	if (qdio_start_irq(card->data.ccwdev, 0))

		napi_schedule(&card->napi);

out:

	if (card->options.performance_stats)

		card->perf_stats.inbound_time += qeth_get_micros() -

			card->perf_stats.inbound_start_time;

	return work_done;

}



static int qeth_l3_verify_vlan_dev(struct net_device *dev,

			struct qeth_card *card)

{
@@ -2457,15 +2381,8 @@ static int qeth_l3_do_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) 
{

	struct qeth_card *card = dev->ml_priv;

	struct qeth_arp_cache_entry arp_entry;

	struct mii_ioctl_data *mii_data;

	int rc = 0;



	if (!card)

		return -ENODEV;



	if (!qeth_card_hw_is_reachable(card))

		return -ENODEV;



	switch (cmd) {

	case SIOC_QETH_ARP_SET_NO_ENTRIES:

		if (!capable(CAP_NET_ADMIN)) {
@@ -2510,37 +2427,9 @@ static int qeth_l3_do_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) 
		}

		rc = qeth_l3_arp_flush_cache(card);

		break;

	case SIOC_QETH_ADP_SET_SNMP_CONTROL:

		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_OSX) &&

		    !card->info.guestlan)

			return 1;

		return 0;

		break;

	case SIOCGMIIPHY:

		mii_data = if_mii(rq);

		mii_data->phy_id = 0;

		break;

	case SIOCGMIIREG:

		mii_data = if_mii(rq);

		if (mii_data->phy_id != 0)

			rc = -EINVAL;

		else

			mii_data->val_out = qeth_mdio_read(dev,

							mii_data->phy_id,

							mii_data->reg_num);

		break;

	case SIOC_QETH_QUERY_OAT:

		rc = qeth_query_oat_command(card, rq->ifr_ifru.ifru_data);

		break;

	default:

		rc = -EOPNOTSUPP;

	}

	if (rc)

		QETH_CARD_TEXT_(card, 2, "ioce%d", rc);

	return rc;

}
@@ -2766,7 +2655,8 @@ static int qeth_l3_get_elements_no_tso(struct qeth_card *card, 
	return elements;

}



static int qeth_l3_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)

static netdev_tx_t qeth_l3_hard_start_xmit(struct sk_buff *skb,

					   struct net_device *dev)

{

	int rc;

	__be16 *tag;
@@ -2921,7 +2811,7 @@ static int qeth_l3_hard_start_xmit(struct sk_buff *skb, struct net_device *dev) 
		rc = qeth_do_send_packet(card, queue, new_skb, hdr, elements);

	} else

		rc = qeth_do_send_packet_fast(card, queue, new_skb, hdr,

					elements, data_offset, 0);

					      data_offset, 0);



	if (!rc) {

		card->stats.tx_packets++;
@@ -3022,7 +2912,7 @@ static const struct ethtool_ops qeth_l3_ethtool_ops = { 
	.get_ethtool_stats = qeth_core_get_ethtool_stats,

	.get_sset_count = qeth_core_get_sset_count,

	.get_drvinfo = qeth_core_get_drvinfo,

	.get_settings = qeth_core_ethtool_get_settings,

	.get_link_ksettings = qeth_core_ethtool_get_link_ksettings,

};



/*
@@ -3056,7 +2946,7 @@ static const struct net_device_ops qeth_l3_netdev_ops = { 
	.ndo_start_xmit		= qeth_l3_hard_start_xmit,

	.ndo_validate_addr	= eth_validate_addr,

	.ndo_set_rx_mode	= qeth_l3_set_multicast_list,

	.ndo_do_ioctl		= qeth_l3_do_ioctl,

	.ndo_do_ioctl		= qeth_do_ioctl,

	.ndo_change_mtu		= qeth_change_mtu,

	.ndo_fix_features	= qeth_fix_features,

	.ndo_set_features	= qeth_set_features,
@@ -3072,7 +2962,7 @@ static const struct net_device_ops qeth_l3_osa_netdev_ops = { 
	.ndo_start_xmit		= qeth_l3_hard_start_xmit,

	.ndo_validate_addr	= eth_validate_addr,

	.ndo_set_rx_mode	= qeth_l3_set_multicast_list,

	.ndo_do_ioctl		= qeth_l3_do_ioctl,

	.ndo_do_ioctl		= qeth_do_ioctl,

	.ndo_change_mtu		= qeth_change_mtu,

	.ndo_fix_features	= qeth_fix_features,

	.ndo_set_features	= qeth_set_features,
@@ -3141,7 +3031,7 @@ static int qeth_l3_setup_netdev(struct qeth_card *card) 
				  PAGE_SIZE;



	SET_NETDEV_DEV(card->dev, &card->gdev->dev);

	netif_napi_add(card->dev, &card->napi, qeth_l3_poll, QETH_NAPI_WEIGHT);

	netif_napi_add(card->dev, &card->napi, qeth_poll, QETH_NAPI_WEIGHT);

	netif_carrier_off(card->dev);

	return register_netdev(card->dev);

}
@@ -3362,17 +3252,6 @@ static int qeth_l3_recover(void *ptr) 
	return 0;

}



static void qeth_l3_shutdown(struct ccwgroup_device *gdev)

{

	struct qeth_card *card = dev_get_drvdata(&gdev->dev);

	qeth_set_allowed_threads(card, 0, 1);

	if ((gdev->state == CCWGROUP_ONLINE) && card->info.hwtrap)

		qeth_hw_trap(card, QETH_DIAGS_TRAP_DISARM);

	qeth_qdio_clear_card(card, 0);

	qeth_clear_qdio_buffers(card);

	qdio_free(CARD_DDEV(card));

}



static int qeth_l3_pm_suspend(struct ccwgroup_device *gdev)

{

	struct qeth_card *card = dev_get_drvdata(&gdev->dev);
@@ -3430,15 +3309,16 @@ struct qeth_discipline qeth_l3_discipline = { 
	.start_poll = qeth_qdio_start_poll,

	.input_handler = (qdio_handler_t *) qeth_qdio_input_handler,

	.output_handler = (qdio_handler_t *) qeth_qdio_output_handler,

	.process_rx_buffer = qeth_l3_process_inbound_buffer,

	.recover = qeth_l3_recover,

	.setup = qeth_l3_probe_device,

	.remove = qeth_l3_remove_device,

	.set_online = qeth_l3_set_online,

	.set_offline = qeth_l3_set_offline,

	.shutdown = qeth_l3_shutdown,

	.freeze = qeth_l3_pm_suspend,

	.thaw = qeth_l3_pm_resume,

	.restore = qeth_l3_pm_resume,

	.do_ioctl = qeth_l3_do_ioctl,

	.control_event_handler = qeth_l3_control_event,

};

EXPORT_SYMBOL_GPL(qeth_l3_discipline);