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

Commit 847a50fd authored by Carsten Otte's avatar Carsten Otte Committed by David S. Miller
Browse files

qeth: Fold qeth_trace debug area 



This patch removes the qeth_trace debug area. All relevant data is logged into
either qeth_setup or into each card's own debug area. Superfluous information
(such as the card number when logging into the card's own debug area) is
removed without replacement.

Signed-off-by: default avatarCarsten Otte <cotte@de.ibm.com>
Signed-off-by: default avatarFrank Blaschka <frank.blaschka@de.ibm.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent af039068

drivers/s390/net/qeth_core.h

+0 −1
Original line number Diff line number Diff line
@@ -41,7 +41,6 @@ 
enum qeth_dbf_names {

	QETH_DBF_SETUP,

	QETH_DBF_QERR,

	QETH_DBF_TRACE,

	QETH_DBF_MSG,

	QETH_DBF_SENSE,

	QETH_DBF_MISC,

drivers/s390/net/qeth_core_main.c

+101 −109
Original line number Diff line number Diff line
@@ -34,8 +34,6 @@ struct qeth_dbf_info qeth_dbf[QETH_DBF_INFOS] = { 
				8, 1,   8, 5, &debug_hex_ascii_view, NULL},

	[QETH_DBF_QERR]  = {"qeth_qerr",

				2, 1,   8, 2, &debug_hex_ascii_view, NULL},

	[QETH_DBF_TRACE] = {"qeth_trace",

				4, 1,   8, 3, &debug_hex_ascii_view, NULL},

	[QETH_DBF_MSG]   = {"qeth_msg",

				8, 1, 128, 3, &debug_sprintf_view,   NULL},

	[QETH_DBF_SENSE] = {"qeth_sense",
@@ -232,7 +230,7 @@ void qeth_clear_working_pool_list(struct qeth_card *card) 
{

	struct qeth_buffer_pool_entry *pool_entry, *tmp;



	QETH_DBF_TEXT(TRACE, 5, "clwrklst");

	QETH_CARD_TEXT(card, 5, "clwrklst");

	list_for_each_entry_safe(pool_entry, tmp,

			    &card->qdio.in_buf_pool.entry_list, list){

			list_del(&pool_entry->list);
@@ -246,7 +244,7 @@ static int qeth_alloc_buffer_pool(struct qeth_card *card) 
	void *ptr;

	int i, j;



	QETH_DBF_TEXT(TRACE, 5, "alocpool");

	QETH_CARD_TEXT(card, 5, "alocpool");

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

		pool_entry = kmalloc(sizeof(*pool_entry), GFP_KERNEL);

		if (!pool_entry) {
@@ -273,7 +271,7 @@ static int qeth_alloc_buffer_pool(struct qeth_card *card) 


int qeth_realloc_buffer_pool(struct qeth_card *card, int bufcnt)

{

	QETH_DBF_TEXT(TRACE, 2, "realcbp");

	QETH_CARD_TEXT(card, 2, "realcbp");



	if ((card->state != CARD_STATE_DOWN) &&

	    (card->state != CARD_STATE_RECOVER))
@@ -293,7 +291,7 @@ static int qeth_issue_next_read(struct qeth_card *card) 
	int rc;

	struct qeth_cmd_buffer *iob;



	QETH_DBF_TEXT(TRACE, 5, "issnxrd");

	QETH_CARD_TEXT(card, 5, "issnxrd");

	if (card->read.state != CH_STATE_UP)

		return -EIO;

	iob = qeth_get_buffer(&card->read);
@@ -305,7 +303,7 @@ static int qeth_issue_next_read(struct qeth_card *card) 
		return -ENOMEM;

	}

	qeth_setup_ccw(&card->read, iob->data, QETH_BUFSIZE);

	QETH_DBF_TEXT(TRACE, 6, "noirqpnd");

	QETH_CARD_TEXT(card, 6, "noirqpnd");

	rc = ccw_device_start(card->read.ccwdev, &card->read.ccw,

			      (addr_t) iob, 0, 0);

	if (rc) {
@@ -364,7 +362,7 @@ static struct qeth_ipa_cmd *qeth_check_ipa_data(struct qeth_card *card, 
{

	struct qeth_ipa_cmd *cmd = NULL;



	QETH_DBF_TEXT(TRACE, 5, "chkipad");

	QETH_CARD_TEXT(card, 5, "chkipad");

	if (IS_IPA(iob->data)) {

		cmd = (struct qeth_ipa_cmd *) PDU_ENCAPSULATION(iob->data);

		if (IS_IPA_REPLY(cmd)) {
@@ -400,10 +398,10 @@ static struct qeth_ipa_cmd *qeth_check_ipa_data(struct qeth_card *card, 
			case IPA_CMD_MODCCID:

				return cmd;

			case IPA_CMD_REGISTER_LOCAL_ADDR:

				QETH_DBF_TEXT(TRACE, 3, "irla");

				QETH_CARD_TEXT(card, 3, "irla");

				break;

			case IPA_CMD_UNREGISTER_LOCAL_ADDR:

				QETH_DBF_TEXT(TRACE, 3, "urla");

				QETH_CARD_TEXT(card, 3, "urla");

				break;

			default:

				QETH_DBF_MESSAGE(2, "Received data is IPA "
@@ -420,7 +418,7 @@ void qeth_clear_ipacmd_list(struct qeth_card *card) 
	struct qeth_reply *reply, *r;

	unsigned long flags;



	QETH_DBF_TEXT(TRACE, 4, "clipalst");

	QETH_CARD_TEXT(card, 4, "clipalst");



	spin_lock_irqsave(&card->lock, flags);

	list_for_each_entry_safe(reply, r, &card->cmd_waiter_list, list) {
@@ -448,9 +446,9 @@ static int qeth_check_idx_response(struct qeth_card *card, 
			   buffer[4],

			   ((buffer[4] == 0x22) ?

			    " -- try another portname" : ""));

		QETH_DBF_TEXT(TRACE, 2, "ckidxres");

		QETH_DBF_TEXT(TRACE, 2, " idxterm");

		QETH_DBF_TEXT_(TRACE, 2, "  rc%d", -EIO);

		QETH_CARD_TEXT(card, 2, "ckidxres");

		QETH_CARD_TEXT(card, 2, " idxterm");

		QETH_CARD_TEXT_(card, 2, "  rc%d", -EIO);

		if (buffer[4] == 0xf6) {

			dev_err(&card->gdev->dev,

			"The qeth device is not configured "
@@ -467,8 +465,8 @@ static void qeth_setup_ccw(struct qeth_channel *channel, unsigned char *iob, 
{

	struct qeth_card *card;



	QETH_DBF_TEXT(TRACE, 4, "setupccw");

	card = CARD_FROM_CDEV(channel->ccwdev);

	QETH_CARD_TEXT(card, 4, "setupccw");

	if (channel == &card->read)

		memcpy(&channel->ccw, READ_CCW, sizeof(struct ccw1));

	else
@@ -481,7 +479,7 @@ static struct qeth_cmd_buffer *__qeth_get_buffer(struct qeth_channel *channel) 
{

	__u8 index;



	QETH_DBF_TEXT(TRACE, 6, "getbuff");

	QETH_CARD_TEXT(CARD_FROM_CDEV(channel->ccwdev), 6, "getbuff");

	index = channel->io_buf_no;

	do {

		if (channel->iob[index].state == BUF_STATE_FREE) {
@@ -502,7 +500,7 @@ void qeth_release_buffer(struct qeth_channel *channel, 
{

	unsigned long flags;



	QETH_DBF_TEXT(TRACE, 6, "relbuff");

	QETH_CARD_TEXT(CARD_FROM_CDEV(channel->ccwdev), 6, "relbuff");

	spin_lock_irqsave(&channel->iob_lock, flags);

	memset(iob->data, 0, QETH_BUFSIZE);

	iob->state = BUF_STATE_FREE;
@@ -553,9 +551,8 @@ static void qeth_send_control_data_cb(struct qeth_channel *channel, 
	int keep_reply;

	int rc = 0;



	QETH_DBF_TEXT(TRACE, 4, "sndctlcb");



	card = CARD_FROM_CDEV(channel->ccwdev);

	QETH_CARD_TEXT(card, 4, "sndctlcb");

	rc = qeth_check_idx_response(card, iob->data);

	switch (rc) {

	case 0:
@@ -722,7 +719,7 @@ EXPORT_SYMBOL_GPL(qeth_do_run_thread); 


void qeth_schedule_recovery(struct qeth_card *card)

{

	QETH_DBF_TEXT(TRACE, 2, "startrec");

	QETH_CARD_TEXT(card, 2, "startrec");

	if (qeth_set_thread_start_bit(card, QETH_RECOVER_THREAD) == 0)

		schedule_work(&card->kernel_thread_starter);

}
@@ -732,15 +729,17 @@ static int qeth_get_problem(struct ccw_device *cdev, struct irb *irb) 
{

	int dstat, cstat;

	char *sense;

	struct qeth_card *card;



	sense = (char *) irb->ecw;

	cstat = irb->scsw.cmd.cstat;

	dstat = irb->scsw.cmd.dstat;

	card = CARD_FROM_CDEV(cdev);



	if (cstat & (SCHN_STAT_CHN_CTRL_CHK | SCHN_STAT_INTF_CTRL_CHK |

		     SCHN_STAT_CHN_DATA_CHK | SCHN_STAT_CHAIN_CHECK |

		     SCHN_STAT_PROT_CHECK | SCHN_STAT_PROG_CHECK)) {

		QETH_DBF_TEXT(TRACE, 2, "CGENCHK");

		QETH_CARD_TEXT(card, 2, "CGENCHK");

		dev_warn(&cdev->dev, "The qeth device driver "

			"failed to recover an error on the device\n");

		QETH_DBF_MESSAGE(2, "%s check on device dstat=x%x, cstat=x%x\n",
@@ -753,23 +752,23 @@ static int qeth_get_problem(struct ccw_device *cdev, struct irb *irb) 
	if (dstat & DEV_STAT_UNIT_CHECK) {

		if (sense[SENSE_RESETTING_EVENT_BYTE] &

		    SENSE_RESETTING_EVENT_FLAG) {

			QETH_DBF_TEXT(TRACE, 2, "REVIND");

			QETH_CARD_TEXT(card, 2, "REVIND");

			return 1;

		}

		if (sense[SENSE_COMMAND_REJECT_BYTE] &

		    SENSE_COMMAND_REJECT_FLAG) {

			QETH_DBF_TEXT(TRACE, 2, "CMDREJi");

			QETH_CARD_TEXT(card, 2, "CMDREJi");

			return 1;

		}

		if ((sense[2] == 0xaf) && (sense[3] == 0xfe)) {

			QETH_DBF_TEXT(TRACE, 2, "AFFE");

			QETH_CARD_TEXT(card, 2, "AFFE");

			return 1;

		}

		if ((!sense[0]) && (!sense[1]) && (!sense[2]) && (!sense[3])) {

			QETH_DBF_TEXT(TRACE, 2, "ZEROSEN");

			QETH_CARD_TEXT(card, 2, "ZEROSEN");

			return 0;

		}

		QETH_DBF_TEXT(TRACE, 2, "DGENCHK");

		QETH_CARD_TEXT(card, 2, "DGENCHK");

			return 1;

	}

	return 0;
@@ -778,6 +777,10 @@ static int qeth_get_problem(struct ccw_device *cdev, struct irb *irb) 
static long __qeth_check_irb_error(struct ccw_device *cdev,

		unsigned long intparm, struct irb *irb)

{

	struct qeth_card *card;



	card = CARD_FROM_CDEV(cdev);



	if (!IS_ERR(irb))

		return 0;
@@ -785,17 +788,15 @@ static long __qeth_check_irb_error(struct ccw_device *cdev, 
	case -EIO:

		QETH_DBF_MESSAGE(2, "%s i/o-error on device\n",

			dev_name(&cdev->dev));

		QETH_DBF_TEXT(TRACE, 2, "ckirberr");

		QETH_DBF_TEXT_(TRACE, 2, "  rc%d", -EIO);

		QETH_CARD_TEXT(card, 2, "ckirberr");

		QETH_CARD_TEXT_(card, 2, "  rc%d", -EIO);

		break;

	case -ETIMEDOUT:

		dev_warn(&cdev->dev, "A hardware operation timed out"

			" on the device\n");

		QETH_DBF_TEXT(TRACE, 2, "ckirberr");

		QETH_DBF_TEXT_(TRACE, 2, "  rc%d", -ETIMEDOUT);

		QETH_CARD_TEXT(card, 2, "ckirberr");

		QETH_CARD_TEXT_(card, 2, "  rc%d", -ETIMEDOUT);

		if (intparm == QETH_RCD_PARM) {

			struct qeth_card *card = CARD_FROM_CDEV(cdev);



			if (card && (card->data.ccwdev == cdev)) {

				card->data.state = CH_STATE_DOWN;

				wake_up(&card->wait_q);
@@ -805,8 +806,8 @@ static long __qeth_check_irb_error(struct ccw_device *cdev, 
	default:

		QETH_DBF_MESSAGE(2, "%s unknown error %ld on device\n",

			dev_name(&cdev->dev), PTR_ERR(irb));

		QETH_DBF_TEXT(TRACE, 2, "ckirberr");

		QETH_DBF_TEXT(TRACE, 2, "  rc???");

		QETH_CARD_TEXT(card, 2, "ckirberr");

		QETH_CARD_TEXT(card, 2, "  rc???");

	}

	return PTR_ERR(irb);

}
@@ -822,8 +823,6 @@ static void qeth_irq(struct ccw_device *cdev, unsigned long intparm, 
	struct qeth_cmd_buffer *iob;

	__u8 index;



	QETH_DBF_TEXT(TRACE, 5, "irq");



	if (__qeth_check_irb_error(cdev, intparm, irb))

		return;

	cstat = irb->scsw.cmd.cstat;
@@ -833,15 +832,17 @@ static void qeth_irq(struct ccw_device *cdev, unsigned long intparm, 
	if (!card)

		return;



	QETH_CARD_TEXT(card, 5, "irq");



	if (card->read.ccwdev == cdev) {

		channel = &card->read;

		QETH_DBF_TEXT(TRACE, 5, "read");

		QETH_CARD_TEXT(card, 5, "read");

	} else if (card->write.ccwdev == cdev) {

		channel = &card->write;

		QETH_DBF_TEXT(TRACE, 5, "write");

		QETH_CARD_TEXT(card, 5, "write");

	} else {

		channel = &card->data;

		QETH_DBF_TEXT(TRACE, 5, "data");

		QETH_CARD_TEXT(card, 5, "data");

	}

	atomic_set(&channel->irq_pending, 0);
@@ -857,12 +858,12 @@ static void qeth_irq(struct ccw_device *cdev, unsigned long intparm, 
		goto out;



	if (intparm == QETH_CLEAR_CHANNEL_PARM) {

		QETH_DBF_TEXT(TRACE, 6, "clrchpar");

		QETH_CARD_TEXT(card, 6, "clrchpar");

		/* we don't have to handle this further */

		intparm = 0;

	}

	if (intparm == QETH_HALT_CHANNEL_PARM) {

		QETH_DBF_TEXT(TRACE, 6, "hltchpar");

		QETH_CARD_TEXT(card, 6, "hltchpar");

		/* we don't have to handle this further */

		intparm = 0;

	}
@@ -963,7 +964,7 @@ void qeth_clear_qdio_buffers(struct qeth_card *card) 
{

	int i, j;



	QETH_DBF_TEXT(TRACE, 2, "clearqdbf");

	QETH_CARD_TEXT(card, 2, "clearqdbf");

	/* clear outbound buffers to free skbs */

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

		if (card->qdio.out_qs[i]) {
@@ -978,7 +979,7 @@ static void qeth_free_buffer_pool(struct qeth_card *card) 
{

	struct qeth_buffer_pool_entry *pool_entry, *tmp;

	int i = 0;

	QETH_DBF_TEXT(TRACE, 5, "freepool");

	QETH_CARD_TEXT(card, 5, "freepool");

	list_for_each_entry_safe(pool_entry, tmp,

				 &card->qdio.init_pool.entry_list, init_list){

		for (i = 0; i < QETH_MAX_BUFFER_ELEMENTS(card); ++i)
@@ -992,7 +993,6 @@ static void qeth_free_qdio_buffers(struct qeth_card *card) 
{

	int i, j;



	QETH_DBF_TEXT(TRACE, 2, "freeqdbf");

	if (atomic_xchg(&card->qdio.state, QETH_QDIO_UNINITIALIZED) ==

		QETH_QDIO_UNINITIALIZED)

		return;
@@ -1089,7 +1089,7 @@ static int qeth_do_start_thread(struct qeth_card *card, unsigned long thread) 
	int rc = 0;



	spin_lock_irqsave(&card->thread_mask_lock, flags);

	QETH_DBF_TEXT_(TRACE, 4, "  %02x%02x%02x",

	QETH_CARD_TEXT_(card, 4, "  %02x%02x%02x",

			(u8) card->thread_start_mask,

			(u8) card->thread_allowed_mask,

			(u8) card->thread_running_mask);
@@ -1102,7 +1102,7 @@ static void qeth_start_kernel_thread(struct work_struct *work) 
{

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

					kernel_thread_starter);

	QETH_DBF_TEXT(TRACE , 2, "strthrd");

	QETH_CARD_TEXT(card , 2, "strthrd");



	if (card->read.state != CH_STATE_UP &&

	    card->write.state != CH_STATE_UP)
@@ -1229,8 +1229,8 @@ static int qeth_clear_channel(struct qeth_channel *channel) 
	struct qeth_card *card;

	int rc;



	QETH_DBF_TEXT(TRACE, 3, "clearch");

	card = CARD_FROM_CDEV(channel->ccwdev);

	QETH_CARD_TEXT(card, 3, "clearch");

	spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);

	rc = ccw_device_clear(channel->ccwdev, QETH_CLEAR_CHANNEL_PARM);

	spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
@@ -1253,8 +1253,8 @@ static int qeth_halt_channel(struct qeth_channel *channel) 
	struct qeth_card *card;

	int rc;



	QETH_DBF_TEXT(TRACE, 3, "haltch");

	card = CARD_FROM_CDEV(channel->ccwdev);

	QETH_CARD_TEXT(card, 3, "haltch");

	spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);

	rc = ccw_device_halt(channel->ccwdev, QETH_HALT_CHANNEL_PARM);

	spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
@@ -1274,7 +1274,7 @@ static int qeth_halt_channels(struct qeth_card *card) 
{

	int rc1 = 0, rc2 = 0, rc3 = 0;



	QETH_DBF_TEXT(TRACE, 3, "haltchs");

	QETH_CARD_TEXT(card, 3, "haltchs");

	rc1 = qeth_halt_channel(&card->read);

	rc2 = qeth_halt_channel(&card->write);

	rc3 = qeth_halt_channel(&card->data);
@@ -1289,7 +1289,7 @@ static int qeth_clear_channels(struct qeth_card *card) 
{

	int rc1 = 0, rc2 = 0, rc3 = 0;



	QETH_DBF_TEXT(TRACE, 3, "clearchs");

	QETH_CARD_TEXT(card, 3, "clearchs");

	rc1 = qeth_clear_channel(&card->read);

	rc2 = qeth_clear_channel(&card->write);

	rc3 = qeth_clear_channel(&card->data);
@@ -1304,8 +1304,7 @@ static int qeth_clear_halt_card(struct qeth_card *card, int halt) 
{

	int rc = 0;



	QETH_DBF_TEXT(TRACE, 3, "clhacrd");

	QETH_DBF_HEX(TRACE, 3, &card, sizeof(void *));

	QETH_CARD_TEXT(card, 3, "clhacrd");



	if (halt)

		rc = qeth_halt_channels(card);
@@ -1318,7 +1317,7 @@ int qeth_qdio_clear_card(struct qeth_card *card, int use_halt) 
{

	int rc = 0;



	QETH_DBF_TEXT(TRACE, 3, "qdioclr");

	QETH_CARD_TEXT(card, 3, "qdioclr");

	switch (atomic_cmpxchg(&card->qdio.state, QETH_QDIO_ESTABLISHED,

		QETH_QDIO_CLEANING)) {

	case QETH_QDIO_ESTABLISHED:
@@ -1329,7 +1328,7 @@ int qeth_qdio_clear_card(struct qeth_card *card, int use_halt) 
			rc = qdio_shutdown(CARD_DDEV(card),

				QDIO_FLAG_CLEANUP_USING_CLEAR);

		if (rc)

			QETH_DBF_TEXT_(TRACE, 3, "1err%d", rc);

			QETH_CARD_TEXT_(card, 3, "1err%d", rc);

		qdio_free(CARD_DDEV(card));

		atomic_set(&card->qdio.state, QETH_QDIO_ALLOCATED);

		break;
@@ -1340,7 +1339,7 @@ int qeth_qdio_clear_card(struct qeth_card *card, int use_halt) 
	}

	rc = qeth_clear_halt_card(card, use_halt);

	if (rc)

		QETH_DBF_TEXT_(TRACE, 3, "2err%d", rc);

		QETH_CARD_TEXT_(card, 3, "2err%d", rc);

	card->state = CARD_STATE_DOWN;

	return rc;

}
@@ -1705,7 +1704,7 @@ int qeth_send_control_data(struct qeth_card *card, int len, 
	unsigned long timeout, event_timeout;

	struct qeth_ipa_cmd *cmd;



	QETH_DBF_TEXT(TRACE, 2, "sendctl");

	QETH_CARD_TEXT(card, 2, "sendctl");



	reply = qeth_alloc_reply(card);

	if (!reply) {
@@ -1732,7 +1731,7 @@ int qeth_send_control_data(struct qeth_card *card, int len, 
		event_timeout = QETH_TIMEOUT;

	timeout = jiffies + event_timeout;



	QETH_DBF_TEXT(TRACE, 6, "noirqpnd");

	QETH_CARD_TEXT(card, 6, "noirqpnd");

	spin_lock_irqsave(get_ccwdev_lock(card->write.ccwdev), flags);

	rc = ccw_device_start(card->write.ccwdev, &card->write.ccw,

			      (addr_t) iob, 0, 0);
@@ -1741,7 +1740,7 @@ int qeth_send_control_data(struct qeth_card *card, int len, 
		QETH_DBF_MESSAGE(2, "%s qeth_send_control_data: "

			"ccw_device_start rc = %i\n",

			dev_name(&card->write.ccwdev->dev), rc);

		QETH_DBF_TEXT_(TRACE, 2, " err%d", rc);

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

		spin_lock_irqsave(&card->lock, flags);

		list_del_init(&reply->list);

		qeth_put_reply(reply);
@@ -2335,7 +2334,7 @@ static void qeth_initialize_working_pool_list(struct qeth_card *card) 
{

	struct qeth_buffer_pool_entry *entry;



	QETH_DBF_TEXT(TRACE, 5, "inwrklst");

	QETH_CARD_TEXT(card, 5, "inwrklst");



	list_for_each_entry(entry,

			    &card->qdio.init_pool.entry_list, init_list) {
@@ -2522,7 +2521,7 @@ int qeth_send_ipa_cmd(struct qeth_card *card, struct qeth_cmd_buffer *iob, 
	int rc;

	char prot_type;



	QETH_DBF_TEXT(TRACE, 4, "sendipa");

	QETH_CARD_TEXT(card, 4, "sendipa");



	if (card->options.layer2)

		if (card->info.type == QETH_CARD_TYPE_OSN)
@@ -2582,7 +2581,7 @@ int qeth_default_setadapterparms_cb(struct qeth_card *card, 
{

	struct qeth_ipa_cmd *cmd;



	QETH_DBF_TEXT(TRACE, 4, "defadpcb");

	QETH_CARD_TEXT(card, 4, "defadpcb");



	cmd = (struct qeth_ipa_cmd *) data;

	if (cmd->hdr.return_code == 0)
@@ -2597,7 +2596,7 @@ static int qeth_query_setadapterparms_cb(struct qeth_card *card, 
{

	struct qeth_ipa_cmd *cmd;



	QETH_DBF_TEXT(TRACE, 3, "quyadpcb");

	QETH_CARD_TEXT(card, 3, "quyadpcb");



	cmd = (struct qeth_ipa_cmd *) data;

	if (cmd->data.setadapterparms.data.query_cmds_supp.lan_type & 0x7f) {
@@ -2633,7 +2632,7 @@ int qeth_query_setadapterparms(struct qeth_card *card) 
	int rc;

	struct qeth_cmd_buffer *iob;



	QETH_DBF_TEXT(TRACE, 3, "queryadp");

	QETH_CARD_TEXT(card, 3, "queryadp");

	iob = qeth_get_adapter_cmd(card, IPA_SETADP_QUERY_COMMANDS_SUPPORTED,

				   sizeof(struct qeth_ipacmd_setadpparms));

	rc = qeth_send_ipa_cmd(card, iob, qeth_query_setadapterparms_cb, NULL);
@@ -2645,7 +2644,7 @@ int qeth_check_qdio_errors(struct qeth_card *card, struct qdio_buffer *buf, 
		unsigned int qdio_error, const char *dbftext)

{

	if (qdio_error) {

		QETH_DBF_TEXT(TRACE, 2, dbftext);

		QETH_CARD_TEXT(card, 2, dbftext);

		QETH_DBF_TEXT(QERR, 2, dbftext);

		QETH_DBF_TEXT_(QERR, 2, " F15=%02X",

			       buf->element[15].flags & 0xff);
@@ -2717,8 +2716,7 @@ void qeth_queue_input_buffer(struct qeth_card *card, int index) 
		if (rc) {

			dev_warn(&card->gdev->dev,

				"QDIO reported an error, rc=%i\n", rc);

			QETH_DBF_TEXT(TRACE, 2, "qinberr");

			QETH_DBF_TEXT_(TRACE, 2, "%s", CARD_BUS_ID(card));

			QETH_CARD_TEXT(card, 2, "qinberr");

		}

		queue->next_buf_to_init = (queue->next_buf_to_init + count) %

					  QDIO_MAX_BUFFERS_PER_Q;
@@ -2731,7 +2729,7 @@ static int qeth_handle_send_error(struct qeth_card *card, 
{

	int sbalf15 = buffer->buffer->element[15].flags & 0xff;



	QETH_DBF_TEXT(TRACE, 6, "hdsnderr");

	QETH_CARD_TEXT(card, 6, "hdsnderr");

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

		if (sbalf15 == 0) {

			qdio_err = 0;
@@ -2747,9 +2745,8 @@ static int qeth_handle_send_error(struct qeth_card *card, 
	if ((sbalf15 >= 15) && (sbalf15 <= 31))

		return QETH_SEND_ERROR_RETRY;



	QETH_DBF_TEXT(TRACE, 1, "lnkfail");

	QETH_DBF_TEXT_(TRACE, 1, "%s", CARD_BUS_ID(card));

	QETH_DBF_TEXT_(TRACE, 1, "%04x %02x",

	QETH_CARD_TEXT(card, 1, "lnkfail");

	QETH_CARD_TEXT_(card, 1, "%04x %02x",

		       (u16)qdio_err, (u8)sbalf15);

	return QETH_SEND_ERROR_LINK_FAILURE;

}
@@ -2764,7 +2761,7 @@ static void qeth_switch_to_packing_if_needed(struct qeth_qdio_out_q *queue) 
		if (atomic_read(&queue->used_buffers)

		    >= QETH_HIGH_WATERMARK_PACK){

			/* switch non-PACKING -> PACKING */

			QETH_DBF_TEXT(TRACE, 6, "np->pack");

			QETH_CARD_TEXT(queue->card, 6, "np->pack");

			if (queue->card->options.performance_stats)

				queue->card->perf_stats.sc_dp_p++;

			queue->do_pack = 1;
@@ -2787,7 +2784,7 @@ static int qeth_switch_to_nonpacking_if_needed(struct qeth_qdio_out_q *queue) 
		if (atomic_read(&queue->used_buffers)

		    <= QETH_LOW_WATERMARK_PACK) {

			/* switch PACKING -> non-PACKING */

			QETH_DBF_TEXT(TRACE, 6, "pack->np");

			QETH_CARD_TEXT(queue->card, 6, "pack->np");

			if (queue->card->options.performance_stats)

				queue->card->perf_stats.sc_p_dp++;

			queue->do_pack = 0;
@@ -2896,9 +2893,8 @@ static void qeth_flush_buffers(struct qeth_qdio_out_q *queue, int index, 
		/* ignore temporary SIGA errors without busy condition */

		if (rc == QDIO_ERROR_SIGA_TARGET)

			return;

		QETH_DBF_TEXT(TRACE, 2, "flushbuf");

		QETH_DBF_TEXT_(TRACE, 2, " err%d", rc);

		QETH_DBF_TEXT_(TRACE, 2, "%s", CARD_DDEV_ID(queue->card));

		QETH_CARD_TEXT(queue->card, 2, "flushbuf");

		QETH_CARD_TEXT_(queue->card, 2, " err%d", rc);



		/* this must not happen under normal circumstances. if it

		 * happens something is really wrong -> recover */
@@ -2960,10 +2956,9 @@ void qeth_qdio_output_handler(struct ccw_device *ccwdev, 
	int i;

	unsigned qeth_send_err;



	QETH_DBF_TEXT(TRACE, 6, "qdouhdl");

	QETH_CARD_TEXT(card, 6, "qdouhdl");

	if (qdio_error & QDIO_ERROR_ACTIVATE_CHECK_CONDITION) {

		QETH_DBF_TEXT(TRACE, 2, "achkcond");

		QETH_DBF_TEXT_(TRACE, 2, "%s", CARD_BUS_ID(card));

		QETH_CARD_TEXT(card, 2, "achkcond");

		netif_stop_queue(card->dev);

		qeth_schedule_recovery(card);

		return;
@@ -3145,12 +3140,12 @@ static inline int qeth_fill_buffer(struct qeth_qdio_out_q *queue, 
					(int *)&buf->next_element_to_fill);



	if (!queue->do_pack) {

		QETH_DBF_TEXT(TRACE, 6, "fillbfnp");

		QETH_CARD_TEXT(queue->card, 6, "fillbfnp");

		/* set state to PRIMED -> will be flushed */

		atomic_set(&buf->state, QETH_QDIO_BUF_PRIMED);

		flush_cnt = 1;

	} else {

		QETH_DBF_TEXT(TRACE, 6, "fillbfpa");

		QETH_CARD_TEXT(queue->card, 6, "fillbfpa");

		if (queue->card->options.performance_stats)

			queue->card->perf_stats.skbs_sent_pack++;

		if (buf->next_element_to_fill >=
@@ -3312,14 +3307,14 @@ static int qeth_setadp_promisc_mode_cb(struct qeth_card *card, 
	struct qeth_ipa_cmd *cmd;

	struct qeth_ipacmd_setadpparms *setparms;



	QETH_DBF_TEXT(TRACE, 4, "prmadpcb");

	QETH_CARD_TEXT(card, 4, "prmadpcb");



	cmd = (struct qeth_ipa_cmd *) data;

	setparms = &(cmd->data.setadapterparms);



	qeth_default_setadapterparms_cb(card, reply, (unsigned long)cmd);

	if (cmd->hdr.return_code) {

		QETH_DBF_TEXT_(TRACE, 4, "prmrc%2.2x", cmd->hdr.return_code);

		QETH_CARD_TEXT_(card, 4, "prmrc%2.2x", cmd->hdr.return_code);

		setparms->data.mode = SET_PROMISC_MODE_OFF;

	}

	card->info.promisc_mode = setparms->data.mode;
@@ -3333,7 +3328,7 @@ void qeth_setadp_promisc_mode(struct qeth_card *card) 
	struct qeth_cmd_buffer *iob;

	struct qeth_ipa_cmd *cmd;



	QETH_DBF_TEXT(TRACE, 4, "setprom");

	QETH_CARD_TEXT(card, 4, "setprom");



	if (((dev->flags & IFF_PROMISC) &&

	     (card->info.promisc_mode == SET_PROMISC_MODE_ON)) ||
@@ -3343,7 +3338,7 @@ void qeth_setadp_promisc_mode(struct qeth_card *card) 
	mode = SET_PROMISC_MODE_OFF;

	if (dev->flags & IFF_PROMISC)

		mode = SET_PROMISC_MODE_ON;

	QETH_DBF_TEXT_(TRACE, 4, "mode:%x", mode);

	QETH_CARD_TEXT_(card, 4, "mode:%x", mode);



	iob = qeth_get_adapter_cmd(card, IPA_SETADP_SET_PROMISC_MODE,

			sizeof(struct qeth_ipacmd_setadpparms));
@@ -3360,9 +3355,9 @@ int qeth_change_mtu(struct net_device *dev, int new_mtu) 


	card = dev->ml_priv;



	QETH_DBF_TEXT(TRACE, 4, "chgmtu");

	QETH_CARD_TEXT(card, 4, "chgmtu");

	sprintf(dbf_text, "%8x", new_mtu);

	QETH_DBF_TEXT(TRACE, 4, dbf_text);

	QETH_CARD_TEXT(card, 4, dbf_text);



	if (new_mtu < 64)

		return -EINVAL;
@@ -3382,7 +3377,7 @@ struct net_device_stats *qeth_get_stats(struct net_device *dev) 


	card = dev->ml_priv;



	QETH_DBF_TEXT(TRACE, 5, "getstat");

	QETH_CARD_TEXT(card, 5, "getstat");



	return &card->stats;

}
@@ -3393,7 +3388,7 @@ static int qeth_setadpparms_change_macaddr_cb(struct qeth_card *card, 
{

	struct qeth_ipa_cmd *cmd;



	QETH_DBF_TEXT(TRACE, 4, "chgmaccb");

	QETH_CARD_TEXT(card, 4, "chgmaccb");



	cmd = (struct qeth_ipa_cmd *) data;

	if (!card->options.layer2 ||
@@ -3413,7 +3408,7 @@ int qeth_setadpparms_change_macaddr(struct qeth_card *card) 
	struct qeth_cmd_buffer *iob;

	struct qeth_ipa_cmd *cmd;



	QETH_DBF_TEXT(TRACE, 4, "chgmac");

	QETH_CARD_TEXT(card, 4, "chgmac");



	iob = qeth_get_adapter_cmd(card, IPA_SETADP_ALTER_MAC_ADDRESS,

				   sizeof(struct qeth_ipacmd_setadpparms));
@@ -3435,7 +3430,7 @@ static int qeth_setadpparms_set_access_ctrl_cb(struct qeth_card *card, 
	struct qeth_set_access_ctrl *access_ctrl_req;

	int rc;



	QETH_DBF_TEXT(TRACE, 4, "setaccb");

	QETH_CARD_TEXT(card, 4, "setaccb");



	cmd = (struct qeth_ipa_cmd *) data;

	access_ctrl_req = &cmd->data.setadapterparms.data.set_access_ctrl;
@@ -3533,7 +3528,7 @@ static int qeth_setadpparms_set_access_ctrl(struct qeth_card *card, 
	struct qeth_ipa_cmd *cmd;

	struct qeth_set_access_ctrl *access_ctrl_req;



	QETH_DBF_TEXT(TRACE, 4, "setacctl");

	QETH_CARD_TEXT(card, 4, "setacctl");



	QETH_DBF_TEXT_(SETUP, 2, "setacctl");

	QETH_DBF_TEXT_(SETUP, 2, "%s", card->gdev->dev.kobj.name);
@@ -3555,7 +3550,7 @@ int qeth_set_access_ctrl_online(struct qeth_card *card) 
{

	int rc = 0;



	QETH_DBF_TEXT(TRACE, 4, "setactlo");

	QETH_CARD_TEXT(card, 4, "setactlo");



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

	     card->info.type == QETH_CARD_TYPE_OSX) &&
@@ -3583,8 +3578,8 @@ void qeth_tx_timeout(struct net_device *dev) 
{

	struct qeth_card *card;



	QETH_DBF_TEXT(TRACE, 4, "txtimeo");

	card = dev->ml_priv;

	QETH_CARD_TEXT(card, 4, "txtimeo");

	card->stats.tx_errors++;

	qeth_schedule_recovery(card);

}
@@ -3663,7 +3658,7 @@ static int qeth_send_ipa_snmp_cmd(struct qeth_card *card, 
{

	u16 s1, s2;



	QETH_DBF_TEXT(TRACE, 4, "sendsnmp");

	QETH_CARD_TEXT(card, 4, "sendsnmp");



	memcpy(iob->data, IPA_PDU_HEADER, IPA_PDU_HEADER_SIZE);

	memcpy(QETH_IPA_CMD_DEST_ADDR(iob->data),
@@ -3688,7 +3683,7 @@ static int qeth_snmp_command_cb(struct qeth_card *card, 
	unsigned char *data;

	__u16 data_len;



	QETH_DBF_TEXT(TRACE, 3, "snpcmdcb");

	QETH_CARD_TEXT(card, 3, "snpcmdcb");



	cmd = (struct qeth_ipa_cmd *) sdata;

	data = (unsigned char *)((char *)cmd - reply->offset);
@@ -3696,13 +3691,13 @@ static int qeth_snmp_command_cb(struct qeth_card *card, 
	snmp = &cmd->data.setadapterparms.data.snmp;



	if (cmd->hdr.return_code) {

		QETH_DBF_TEXT_(TRACE, 4, "scer1%i", cmd->hdr.return_code);

		QETH_CARD_TEXT_(card, 4, "scer1%i", cmd->hdr.return_code);

		return 0;

	}

	if (cmd->data.setadapterparms.hdr.return_code) {

		cmd->hdr.return_code =

			cmd->data.setadapterparms.hdr.return_code;

		QETH_DBF_TEXT_(TRACE, 4, "scer2%i", cmd->hdr.return_code);

		QETH_CARD_TEXT_(card, 4, "scer2%i", cmd->hdr.return_code);

		return 0;

	}

	data_len = *((__u16 *)QETH_IPA_PDU_LEN_PDU1(data));
@@ -3713,13 +3708,13 @@ static int qeth_snmp_command_cb(struct qeth_card *card, 


	/* check if there is enough room in userspace */

	if ((qinfo->udata_len - qinfo->udata_offset) < data_len) {

		QETH_DBF_TEXT_(TRACE, 4, "scer3%i", -ENOMEM);

		QETH_CARD_TEXT_(card, 4, "scer3%i", -ENOMEM);

		cmd->hdr.return_code = -ENOMEM;

		return 0;

	}

	QETH_DBF_TEXT_(TRACE, 4, "snore%i",

	QETH_CARD_TEXT_(card, 4, "snore%i",

		       cmd->data.setadapterparms.hdr.used_total);

	QETH_DBF_TEXT_(TRACE, 4, "sseqn%i",

	QETH_CARD_TEXT_(card, 4, "sseqn%i",

		cmd->data.setadapterparms.hdr.seq_no);

	/*copy entries to user buffer*/

	if (cmd->data.setadapterparms.hdr.seq_no == 1) {
@@ -3733,9 +3728,9 @@ static int qeth_snmp_command_cb(struct qeth_card *card, 
	}

	qinfo->udata_offset += data_len;

	/* check if all replies received ... */

		QETH_DBF_TEXT_(TRACE, 4, "srtot%i",

		QETH_CARD_TEXT_(card, 4, "srtot%i",

			       cmd->data.setadapterparms.hdr.used_total);

		QETH_DBF_TEXT_(TRACE, 4, "srseq%i",

		QETH_CARD_TEXT_(card, 4, "srseq%i",

			       cmd->data.setadapterparms.hdr.seq_no);

	if (cmd->data.setadapterparms.hdr.seq_no <

	    cmd->data.setadapterparms.hdr.used_total)
@@ -3752,7 +3747,7 @@ int qeth_snmp_command(struct qeth_card *card, char __user *udata) 
	struct qeth_arp_query_info qinfo = {0, };

	int rc = 0;



	QETH_DBF_TEXT(TRACE, 3, "snmpcmd");

	QETH_CARD_TEXT(card, 3, "snmpcmd");



	if (card->info.guestlan)

		return -EOPNOTSUPP;
@@ -3766,7 +3761,7 @@ int qeth_snmp_command(struct qeth_card *card, char __user *udata) 
		return -EFAULT;

	ureq = kmalloc(req_len+sizeof(struct qeth_snmp_ureq_hdr), GFP_KERNEL);

	if (!ureq) {

		QETH_DBF_TEXT(TRACE, 2, "snmpnome");

		QETH_CARD_TEXT(card, 2, "snmpnome");

		return -ENOMEM;

	}

	if (copy_from_user(ureq, udata,
@@ -4120,9 +4115,7 @@ struct sk_buff *qeth_core_get_next_skb(struct qeth_card *card, 
		skb_len -= data_len;

		if (skb_len) {

			if (qeth_is_last_sbale(element)) {

				QETH_DBF_TEXT(TRACE, 4, "unexeob");

				QETH_DBF_TEXT_(TRACE, 4, "%s",

					CARD_BUS_ID(card));

				QETH_CARD_TEXT(card, 4, "unexeob");

				QETH_DBF_TEXT(QERR, 2, "unexeob");

				QETH_DBF_TEXT_(QERR, 2, "%s",

					CARD_BUS_ID(card));
@@ -4147,8 +4140,7 @@ struct sk_buff *qeth_core_get_next_skb(struct qeth_card *card, 
	return skb;

no_mem:

	if (net_ratelimit()) {

		QETH_DBF_TEXT(TRACE, 2, "noskbmem");

		QETH_DBF_TEXT_(TRACE, 2, "%s", CARD_BUS_ID(card));

		QETH_CARD_TEXT(card, 2, "noskbmem");

	}

	card->stats.rx_dropped++;

	return NULL;