[gentoo-commits] linux-patches r1452 - genpatches-2.6/trunk/2.6.27

[Daniel Drake (dsd)]

Author: dsd
Date: 2008-12-30 20:30:00 +0000 (Tue, 30 Dec 2008)
New Revision: 1452

Added:
   genpatches-2.6/trunk/2.6.27/1705_s390-00.patch
   genpatches-2.6/trunk/2.6.27/1710_s390-01.patch
Modified:
   genpatches-2.6/trunk/2.6.27/0000_README
Log:
Fixes for s390 architecture

Modified: genpatches-2.6/trunk/2.6.27/0000_README
===================================================================
--- genpatches-2.6/trunk/2.6.27/0000_README	2008-12-25 01:56:17 UTC (rev 1451)
+++ genpatches-2.6/trunk/2.6.27/0000_README	2008-12-30 20:30:00 UTC (rev 1452)
@@ -83,6 +83,14 @@
 From:	http://bugs.gentoo.org/229441
 Desc:	Fix shutdown hang on Sun Blade 100
 
+Patch:	1705_s390-00.patch
+From:	http://bugs.gentoo.org/252421
+Desc:	IBM's s390-00 fixes for s390 architecture
+
+Patch:	1710_s390-01.patch
+From:	http://bugs.gentoo.org/252421
+Desc:	IBM's s390-01 fixes for s390 architecture
+
 Patch:	2500_pentax-k10d-wrong-capacity.patch
 From:	http://bugs.gentoo.org/250406
 Desc:	Fix capacity reported by Pentax K10D camera

Added: genpatches-2.6/trunk/2.6.27/1705_s390-00.patch
===================================================================
--- genpatches-2.6/trunk/2.6.27/1705_s390-00.patch	                        (rev 0)
+++ genpatches-2.6/trunk/2.6.27/1705_s390-00.patch	2008-12-30 20:30:00 UTC (rev 1452)
@@ -0,0 +1,5873 @@
+Index: linux-2.6.27-gentoo-r7/arch/s390/include/asm/qdio.h
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/arch/s390/include/asm/qdio.h
++++ linux-2.6.27-gentoo-r7/arch/s390/include/asm/qdio.h
+@@ -367,16 +367,16 @@ struct qdio_initialize {
+ #define QDIO_FLAG_SYNC_OUTPUT		0x02
+ #define QDIO_FLAG_PCI_OUT		0x10
+ 
+-extern int qdio_initialize(struct qdio_initialize *init_data);
+-extern int qdio_allocate(struct qdio_initialize *init_data);
+-extern int qdio_establish(struct qdio_initialize *init_data);
++extern int qdio_initialize(struct qdio_initialize *);
++extern int qdio_allocate(struct qdio_initialize *);
++extern int qdio_establish(struct qdio_initialize *);
+ extern int qdio_activate(struct ccw_device *);
+ 
+-extern int do_QDIO(struct ccw_device*, unsigned int flags,
+-		   int q_nr, int qidx, int count);
+-extern int qdio_cleanup(struct ccw_device*, int how);
+-extern int qdio_shutdown(struct ccw_device*, int how);
++extern int do_QDIO(struct ccw_device *cdev, unsigned int callflags,
++		   int q_nr, int bufnr, int count);
++extern int qdio_cleanup(struct ccw_device*, int);
++extern int qdio_shutdown(struct ccw_device*, int);
+ extern int qdio_free(struct ccw_device *);
+-extern struct qdio_ssqd_desc *qdio_get_ssqd_desc(struct ccw_device *cdev);
++extern int qdio_get_ssqd_desc(struct ccw_device *dev, struct qdio_ssqd_desc*);
+ 
+ #endif /* __QDIO_H__ */
+Index: linux-2.6.27-gentoo-r7/arch/s390/kernel/entry.S
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/arch/s390/kernel/entry.S
++++ linux-2.6.27-gentoo-r7/arch/s390/kernel/entry.S
+@@ -61,22 +61,25 @@ STACK_SIZE  = 1 << STACK_SHIFT
+ 
+ #ifdef CONFIG_TRACE_IRQFLAGS
+ 	.macro	TRACE_IRQS_ON
+-	l	%r1,BASED(.Ltrace_irq_on)
++	basr	%r2,%r0
++	l	%r1,BASED(.Ltrace_irq_on_caller)
+ 	basr	%r14,%r1
+ 	.endm
+ 
+ 	.macro	TRACE_IRQS_OFF
+-	l	%r1,BASED(.Ltrace_irq_off)
++	basr	%r2,%r0
++	l	%r1,BASED(.Ltrace_irq_off_caller)
+ 	basr	%r14,%r1
+ 	.endm
+ 
+ 	.macro	TRACE_IRQS_CHECK
++	basr	%r2,%r0
+ 	tm	SP_PSW(%r15),0x03	# irqs enabled?
+ 	jz	0f
+-	l	%r1,BASED(.Ltrace_irq_on)
++	l	%r1,BASED(.Ltrace_irq_on_caller)
+ 	basr	%r14,%r1
+ 	j	1f
+-0:	l	%r1,BASED(.Ltrace_irq_off)
++0:	l	%r1,BASED(.Ltrace_irq_off_caller)
+ 	basr	%r14,%r1
+ 1:
+ 	.endm
+@@ -1083,9 +1086,12 @@ cleanup_io_leave_insn:
+ .Lschedtail:	.long	schedule_tail
+ .Lsysc_table:	.long	sys_call_table
+ #ifdef CONFIG_TRACE_IRQFLAGS
+-.Ltrace_irq_on: .long	trace_hardirqs_on
+-.Ltrace_irq_off:
+-		.long	trace_hardirqs_off
++.Ltrace_irq_on_caller:
++		.long	trace_hardirqs_on_caller
++.Ltrace_irq_off_caller:
++		.long	trace_hardirqs_off_caller
++#endif
++#ifdef CONFIG_LOCKDEP
+ .Llockdep_sys_exit:
+ 		.long	lockdep_sys_exit
+ #endif
+Index: linux-2.6.27-gentoo-r7/arch/s390/kernel/entry64.S
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/arch/s390/kernel/entry64.S
++++ linux-2.6.27-gentoo-r7/arch/s390/kernel/entry64.S
+@@ -61,19 +61,22 @@ _TIF_WORK_INT = (_TIF_SIGPENDING | _TIF_
+ 
+ #ifdef CONFIG_TRACE_IRQFLAGS
+ 	.macro	TRACE_IRQS_ON
+-	 brasl	%r14,trace_hardirqs_on
++	 basr	%r2,%r0
++	 brasl	%r14,trace_hardirqs_on_caller
+ 	.endm
+ 
+ 	.macro	TRACE_IRQS_OFF
+-	 brasl	%r14,trace_hardirqs_off
++	 basr	%r2,%r0
++	 brasl	%r14,trace_hardirqs_off_caller
+ 	.endm
+ 
+ 	.macro TRACE_IRQS_CHECK
++	basr	%r2,%r0
+ 	tm	SP_PSW(%r15),0x03	# irqs enabled?
+ 	jz	0f
+-	brasl	%r14,trace_hardirqs_on
++	brasl	%r14,trace_hardirqs_on_caller
+ 	j	1f
+-0:	brasl	%r14,trace_hardirqs_off
++0:	brasl	%r14,trace_hardirqs_off_caller
+ 1:
+ 	.endm
+ #else
+Index: linux-2.6.27-gentoo-r7/arch/s390/kernel/process.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/arch/s390/kernel/process.c
++++ linux-2.6.27-gentoo-r7/arch/s390/kernel/process.c
+@@ -136,9 +136,12 @@ static void default_idle(void)
+ 		return;
+ 	}
+ 	trace_hardirqs_on();
++	/* Don't trace preempt off for idle. */
++	stop_critical_timings();
+ 	/* Wait for external, I/O or machine check interrupt. */
+ 	__load_psw_mask(psw_kernel_bits | PSW_MASK_WAIT |
+ 			PSW_MASK_IO | PSW_MASK_EXT);
++	start_critical_timings();
+ }
+ 
+ void cpu_idle(void)
+Index: linux-2.6.27-gentoo-r7/arch/s390/kernel/setup.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/arch/s390/kernel/setup.c
++++ linux-2.6.27-gentoo-r7/arch/s390/kernel/setup.c
+@@ -604,13 +604,13 @@ setup_memory(void)
+ 		if (memory_chunk[i].type != CHUNK_READ_WRITE)
+ 			continue;
+ 		start_chunk = PFN_DOWN(memory_chunk[i].addr);
+-		end_chunk = start_chunk + PFN_DOWN(memory_chunk[i].size) - 1;
++		end_chunk = start_chunk + PFN_DOWN(memory_chunk[i].size);
+ 		end_chunk = min(end_chunk, end_pfn);
+ 		if (start_chunk >= end_chunk)
+ 			continue;
+ 		add_active_range(0, start_chunk, end_chunk);
+ 		pfn = max(start_chunk, start_pfn);
+-		for (; pfn <= end_chunk; pfn++)
++		for (; pfn < end_chunk; pfn++)
+ 			page_set_storage_key(PFN_PHYS(pfn), PAGE_DEFAULT_KEY);
+ 	}
+ 
+Index: linux-2.6.27-gentoo-r7/arch/s390/kernel/sys_s390.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/arch/s390/kernel/sys_s390.c
++++ linux-2.6.27-gentoo-r7/arch/s390/kernel/sys_s390.c
+@@ -198,7 +198,7 @@ asmlinkage long s390x_newuname(struct ne
+ {
+ 	int ret = sys_newuname(name);
+ 
+-	if (current->personality == PER_LINUX32 && !ret) {
++	if (personality(current->personality) == PER_LINUX32 && !ret) {
+ 		ret = copy_to_user(name->machine, "s390\0\0\0\0", 8);
+ 		if (ret) ret = -EFAULT;
+ 	}
+Index: linux-2.6.27-gentoo-r7/arch/s390/kernel/time.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/arch/s390/kernel/time.c
++++ linux-2.6.27-gentoo-r7/arch/s390/kernel/time.c
+@@ -1356,7 +1356,7 @@ static void __init stp_reset(void)
+ 
+ 	stp_page = alloc_bootmem_pages(PAGE_SIZE);
+ 	rc = chsc_sstpc(stp_page, STP_OP_CTRL, 0x0000);
+-	if (rc == 1)
++	if (rc == 0)
+ 		set_bit(CLOCK_SYNC_HAS_STP, &clock_sync_flags);
+ 	else if (stp_online) {
+ 		printk(KERN_WARNING "Running on non STP capable machine.\n");
+Index: linux-2.6.27-gentoo-r7/drivers/s390/block/dasd.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/block/dasd.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/block/dasd.c
+@@ -1746,6 +1746,11 @@ restart:
+ 			goto restart;
+ 		}
+ 
++		/* log sense for fatal error */
++		if (cqr->status == DASD_CQR_FAILED) {
++			dasd_log_sense(cqr, &cqr->irb);
++		}
++
+ 		/* First of all call extended error reporting. */
+ 		if (dasd_eer_enabled(base) &&
+ 		    cqr->status == DASD_CQR_FAILED) {
+Index: linux-2.6.27-gentoo-r7/drivers/s390/block/dasd_eckd.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/block/dasd_eckd.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/block/dasd_eckd.c
+@@ -1501,12 +1501,27 @@ static void dasd_eckd_handle_unsolicited
+ 		return;
+ 	}
+ 
+-	/* just report other unsolicited interrupts */
+-	DEV_MESSAGE(KERN_DEBUG, device, "%s",
+-		    "unsolicited interrupt received");
+-	device->discipline->dump_sense(device, NULL, irb);
+-	dasd_schedule_device_bh(device);
++	if ((irb->scsw.cmd.cc == 1) &&
++	    (irb->scsw.cmd.fctl & SCSW_FCTL_START_FUNC) &&
++	    (irb->scsw.cmd.actl & SCSW_ACTL_START_PEND) &&
++	    (irb->scsw.cmd.stctl & SCSW_STCTL_STATUS_PEND)) {
++		/* fake irb do nothing, they are handled elsewhere */
++		dasd_schedule_device_bh(device);
++		return;
++	}
+ 
++	if (!(irb->esw.esw0.erw.cons)) {
++		/* just report other unsolicited interrupts */
++		DEV_MESSAGE(KERN_ERR, device, "%s",
++			    "unsolicited interrupt received");
++	} else {
++		DEV_MESSAGE(KERN_ERR, device, "%s",
++			    "unsolicited interrupt received "
++			    "(sense available)");
++		device->discipline->dump_sense(device, NULL, irb);
++	}
++
++	dasd_schedule_device_bh(device);
+ 	return;
+ };
+ 
+Index: linux-2.6.27-gentoo-r7/drivers/s390/block/xpram.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/block/xpram.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/block/xpram.c
+@@ -56,6 +56,7 @@ typedef struct {
+ static xpram_device_t xpram_devices[XPRAM_MAX_DEVS];
+ static unsigned int xpram_sizes[XPRAM_MAX_DEVS];
+ static struct gendisk *xpram_disks[XPRAM_MAX_DEVS];
++static struct request_queue *xpram_queues[XPRAM_MAX_DEVS];
+ static unsigned int xpram_pages;
+ static int xpram_devs;
+ 
+@@ -330,18 +331,22 @@ static int __init xpram_setup_sizes(unsi
+ 	return 0;
+ }
+ 
+-static struct request_queue *xpram_queue;
+-
+ static int __init xpram_setup_blkdev(void)
+ {
+ 	unsigned long offset;
+ 	int i, rc = -ENOMEM;
+ 
+ 	for (i = 0; i < xpram_devs; i++) {
+-		struct gendisk *disk = alloc_disk(1);
+-		if (!disk)
++		xpram_disks[i] = alloc_disk(1);
++		if (!xpram_disks[i])
++			goto out;
++		xpram_queues[i] = blk_alloc_queue(GFP_KERNEL);
++		if (!xpram_queues[i]) {
++			put_disk(xpram_disks[i]);
+ 			goto out;
+-		xpram_disks[i] = disk;
++		}
++		blk_queue_make_request(xpram_queues[i], xpram_make_request);
++		blk_queue_hardsect_size(xpram_queues[i], 4096);
+ 	}
+ 
+ 	/*
+@@ -352,18 +357,6 @@ static int __init xpram_setup_blkdev(voi
+ 		goto out;
+ 
+ 	/*
+-	 * Assign the other needed values: make request function, sizes and
+-	 * hardsect size. All the minor devices feature the same value.
+-	 */
+-	xpram_queue = blk_alloc_queue(GFP_KERNEL);
+-	if (!xpram_queue) {
+-		rc = -ENOMEM;
+-		goto out_unreg;
+-	}
+-	blk_queue_make_request(xpram_queue, xpram_make_request);
+-	blk_queue_hardsect_size(xpram_queue, 4096);
+-
+-	/*
+ 	 * Setup device structures.
+ 	 */
+ 	offset = 0;
+@@ -377,18 +370,18 @@ static int __init xpram_setup_blkdev(voi
+ 		disk->first_minor = i;
+ 		disk->fops = &xpram_devops;
+ 		disk->private_data = &xpram_devices[i];
+-		disk->queue = xpram_queue;
++		disk->queue = xpram_queues[i];
+ 		sprintf(disk->disk_name, "slram%d", i);
+ 		set_capacity(disk, xpram_sizes[i] << 1);
+ 		add_disk(disk);
+ 	}
+ 
+ 	return 0;
+-out_unreg:
+-	unregister_blkdev(XPRAM_MAJOR, XPRAM_NAME);
+ out:
+-	while (i--)
++	while (i--) {
++		blk_cleanup_queue(xpram_queues[i]);
+ 		put_disk(xpram_disks[i]);
++	}
+ 	return rc;
+ }
+ 
+@@ -400,10 +393,10 @@ static void __exit xpram_exit(void)
+ 	int i;
+ 	for (i = 0; i < xpram_devs; i++) {
+ 		del_gendisk(xpram_disks[i]);
++		blk_cleanup_queue(xpram_queues[i]);
+ 		put_disk(xpram_disks[i]);
+ 	}
+ 	unregister_blkdev(XPRAM_MAJOR, XPRAM_NAME);
+-	blk_cleanup_queue(xpram_queue);
+ }
+ 
+ static int __init xpram_init(void)
+Index: linux-2.6.27-gentoo-r7/drivers/s390/char/con3215.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/char/con3215.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/char/con3215.c
+@@ -21,6 +21,7 @@
+ #include <linux/console.h>
+ #include <linux/interrupt.h>
+ #include <linux/err.h>
++#include <linux/reboot.h>
+ 
+ #include <linux/slab.h>
+ #include <linux/bootmem.h>
+@@ -88,7 +89,6 @@ struct raw3215_info {
+ 	int count;		      /* number of bytes in output buffer */
+ 	int written;		      /* number of bytes in write requests */
+ 	struct tty_struct *tty;	      /* pointer to tty structure if present */
+-	struct tasklet_struct tasklet;
+ 	struct raw3215_req *queued_read; /* pointer to queued read requests */
+ 	struct raw3215_req *queued_write;/* pointer to queued write requests */
+ 	wait_queue_head_t empty_wait; /* wait queue for flushing */
+@@ -341,21 +341,14 @@ raw3215_try_io(struct raw3215_info *raw)
+ }
+ 
+ /*
+- * The bottom half handler routine for 3215 devices. It tries to start
+- * the next IO and wakes up processes waiting on the tty.
++ * Try to start the next IO and wake up processes waiting on the tty.
+  */
+-static void
+-raw3215_tasklet(void *data)
++static void raw3215_next_io(struct raw3215_info *raw)
+ {
+-	struct raw3215_info *raw;
+ 	struct tty_struct *tty;
+-	unsigned long flags;
+ 
+-	raw = (struct raw3215_info *) data;
+-	spin_lock_irqsave(get_ccwdev_lock(raw->cdev), flags);
+ 	raw3215_mk_write_req(raw);
+ 	raw3215_try_io(raw);
+-	spin_unlock_irqrestore(get_ccwdev_lock(raw->cdev), flags);
+ 	tty = raw->tty;
+ 	if (tty != NULL &&
+ 	    RAW3215_BUFFER_SIZE - raw->count >= RAW3215_MIN_SPACE) {
+@@ -380,7 +373,7 @@ raw3215_irq(struct ccw_device *cdev, uns
+ 	cstat = irb->scsw.cmd.cstat;
+ 	dstat = irb->scsw.cmd.dstat;
+ 	if (cstat != 0)
+-		tasklet_schedule(&raw->tasklet);
++		raw3215_next_io(raw);
+ 	if (dstat & 0x01) { /* we got a unit exception */
+ 		dstat &= ~0x01;	 /* we can ignore it */
+ 	}
+@@ -390,7 +383,7 @@ raw3215_irq(struct ccw_device *cdev, uns
+ 			break;
+ 		/* Attention interrupt, someone hit the enter key */
+ 		raw3215_mk_read_req(raw);
+-		tasklet_schedule(&raw->tasklet);
++		raw3215_next_io(raw);
+ 		break;
+ 	case 0x08:
+ 	case 0x0C:
+@@ -448,7 +441,7 @@ raw3215_irq(struct ccw_device *cdev, uns
+ 		    raw->queued_read == NULL) {
+ 			wake_up_interruptible(&raw->empty_wait);
+ 		}
+-		tasklet_schedule(&raw->tasklet);
++		raw3215_next_io(raw);
+ 		break;
+ 	default:
+ 		/* Strange interrupt, I'll do my best to clean up */
+@@ -460,7 +453,7 @@ raw3215_irq(struct ccw_device *cdev, uns
+ 			raw->flags &= ~RAW3215_WORKING;
+ 			raw3215_free_req(req);
+ 		}
+-		tasklet_schedule(&raw->tasklet);
++		raw3215_next_io(raw);
+ 	}
+ 	return;
+ }
+@@ -674,9 +667,6 @@ raw3215_probe (struct ccw_device *cdev)
+ 		kfree(raw);
+ 		return -ENOMEM;
+ 	}
+-	tasklet_init(&raw->tasklet,
+-		     (void (*)(unsigned long)) raw3215_tasklet,
+-		     (unsigned long) raw);
+ 	init_waitqueue_head(&raw->empty_wait);
+ 
+ 	cdev->dev.driver_data = raw;
+@@ -775,11 +765,11 @@ static struct tty_driver *con3215_device
+ }
+ 
+ /*
+- * panic() calls console_unblank before the system enters a
+- * disabled, endless loop.
++ * panic() calls con3215_flush through a panic_notifier
++ * before the system enters a disabled, endless loop.
+  */
+ static void
+-con3215_unblank(void)
++con3215_flush(void)
+ {
+ 	struct raw3215_info *raw;
+ 	unsigned long flags;
+@@ -790,6 +780,23 @@ con3215_unblank(void)
+ 	spin_unlock_irqrestore(get_ccwdev_lock(raw->cdev), flags);
+ }
+ 
++static int con3215_notify(struct notifier_block *self,
++			  unsigned long event, void *data)
++{
++	con3215_flush();
++	return NOTIFY_OK;
++}
++
++static struct notifier_block on_panic_nb = {
++	.notifier_call = con3215_notify,
++	.priority = 0,
++};
++
++static struct notifier_block on_reboot_nb = {
++	.notifier_call = con3215_notify,
++	.priority = 0,
++};
++
+ /*
+  *  The console structure for the 3215 console
+  */
+@@ -797,7 +804,6 @@ static struct console con3215 = {
+ 	.name	 = "ttyS",
+ 	.write	 = con3215_write,
+ 	.device	 = con3215_device,
+-	.unblank = con3215_unblank,
+ 	.flags	 = CON_PRINTBUFFER,
+ };
+ 
+@@ -846,9 +852,6 @@ con3215_init(void)
+ 	cdev->handler = raw3215_irq;
+ 
+ 	raw->flags |= RAW3215_FIXED;
+-	tasklet_init(&raw->tasklet,
+-		     (void (*)(unsigned long)) raw3215_tasklet,
+-		     (unsigned long) raw);
+ 	init_waitqueue_head(&raw->empty_wait);
+ 
+ 	/* Request the console irq */
+@@ -859,6 +862,8 @@ con3215_init(void)
+ 		raw3215[0] = NULL;
+ 		return -ENODEV;
+ 	}
++	atomic_notifier_chain_register(&panic_notifier_list, &on_panic_nb);
++	register_reboot_notifier(&on_reboot_nb);
+ 	register_console(&con3215);
+ 	return 0;
+ }
+Index: linux-2.6.27-gentoo-r7/drivers/s390/char/con3270.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/char/con3270.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/char/con3270.c
+@@ -15,6 +15,7 @@
+ #include <linux/list.h>
+ #include <linux/types.h>
+ #include <linux/err.h>
++#include <linux/reboot.h>
+ 
+ #include <asm/ccwdev.h>
+ #include <asm/cio.h>
+@@ -528,11 +529,11 @@ con3270_wait_write(struct con3270 *cp)
+ }
+ 
+ /*
+- * panic() calls console_unblank before the system enters a
+- * disabled, endless loop.
++ * panic() calls con3270_flush through a panic_notifier
++ * before the system enters a disabled, endless loop.
+  */
+ static void
+-con3270_unblank(void)
++con3270_flush(void)
+ {
+ 	struct con3270 *cp;
+ 	unsigned long flags;
+@@ -554,6 +555,23 @@ con3270_unblank(void)
+ 	spin_unlock_irqrestore(&cp->view.lock, flags);
+ }
+ 
++static int con3270_notify(struct notifier_block *self,
++			  unsigned long event, void *data)
++{
++	con3270_flush();
++	return NOTIFY_OK;
++}
++
++static struct notifier_block on_panic_nb = {
++	.notifier_call = con3270_notify,
++	.priority = 0,
++};
++
++static struct notifier_block on_reboot_nb = {
++	.notifier_call = con3270_notify,
++	.priority = 0,
++};
++
+ /*
+  *  The console structure for the 3270 console
+  */
+@@ -561,7 +579,6 @@ static struct console con3270 = {
+ 	.name	 = "tty3270",
+ 	.write	 = con3270_write,
+ 	.device	 = con3270_device,
+-	.unblank = con3270_unblank,
+ 	.flags	 = CON_PRINTBUFFER,
+ };
+ 
+@@ -623,6 +640,8 @@ con3270_init(void)
+ 	condev->cline->len = 0;
+ 	con3270_create_status(condev);
+ 	condev->input = alloc_string(&condev->freemem, 80);
++	atomic_notifier_chain_register(&panic_notifier_list, &on_panic_nb);
++	register_reboot_notifier(&on_reboot_nb);
+ 	register_console(&con3270);
+ 	return 0;
+ }
+Index: linux-2.6.27-gentoo-r7/drivers/s390/char/sclp_cmd.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/char/sclp_cmd.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/char/sclp_cmd.c
+@@ -324,6 +324,9 @@ static int do_assign_storage(sclp_cmdw_t
+ 	case 0x0120:
+ 		break;
+ 	default:
++		pr_warning("assign storage failed (cmd=0x%08x, "
++			   "response=0x%04x, rn=0x%04x)\n", cmd,
++			   sccb->header.response_code, rn);
+ 		rc = -EIO;
+ 		break;
+ 	}
+Index: linux-2.6.27-gentoo-r7/drivers/s390/char/sclp_con.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/char/sclp_con.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/char/sclp_con.c
+@@ -16,6 +16,7 @@
+ #include <linux/bootmem.h>
+ #include <linux/termios.h>
+ #include <linux/err.h>
++#include <linux/reboot.h>
+ 
+ #include "sclp.h"
+ #include "sclp_rw.h"
+@@ -172,7 +173,7 @@ sclp_console_device(struct console *c, i
+  * will be flushed to the SCLP.
+  */
+ static void
+-sclp_console_unblank(void)
++sclp_console_flush(void)
+ {
+ 	unsigned long flags;
+ 
+@@ -188,6 +189,24 @@ sclp_console_unblank(void)
+ 	spin_unlock_irqrestore(&sclp_con_lock, flags);
+ }
+ 
++static int
++sclp_console_notify(struct notifier_block *self,
++			  unsigned long event, void *data)
++{
++	sclp_console_flush();
++	return NOTIFY_OK;
++}
++
++static struct notifier_block on_panic_nb = {
++	.notifier_call = sclp_console_notify,
++	.priority = 1,
++};
++
++static struct notifier_block on_reboot_nb = {
++	.notifier_call = sclp_console_notify,
++	.priority = 1,
++};
++
+ /*
+  * used to register the SCLP console to the kernel and to
+  * give printk necessary information
+@@ -197,7 +216,6 @@ static struct console sclp_console =
+ 	.name = sclp_console_name,
+ 	.write = sclp_console_write,
+ 	.device = sclp_console_device,
+-	.unblank = sclp_console_unblank,
+ 	.flags = CON_PRINTBUFFER,
+ 	.index = 0 /* ttyS0 */
+ };
+@@ -241,6 +259,8 @@ sclp_console_init(void)
+ 	sclp_con_width_htab = 8;
+ 
+ 	/* enable printk-access to this driver */
++	atomic_notifier_chain_register(&panic_notifier_list, &on_panic_nb);
++	register_reboot_notifier(&on_reboot_nb);
+ 	register_console(&sclp_console);
+ 	return 0;
+ }
+Index: linux-2.6.27-gentoo-r7/drivers/s390/char/sclp_vt220.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/char/sclp_vt220.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/char/sclp_vt220.c
+@@ -24,6 +24,8 @@
+ #include <linux/bootmem.h>
+ #include <linux/interrupt.h>
+ #include <linux/init.h>
++#include <linux/reboot.h>
++
+ #include <asm/uaccess.h>
+ #include "sclp.h"
+ 
+@@ -743,24 +745,30 @@ sclp_vt220_con_device(struct console *c,
+ 	return sclp_vt220_driver;
+ }
+ 
+-/*
+- * This routine is called from panic when the kernel is going to give up.
+- * We have to make sure that all buffers will be flushed to the SCLP.
+- * Note that this function may be called from within an interrupt context.
+- */
+-static void
+-sclp_vt220_con_unblank(void)
++static int
++sclp_vt220_notify(struct notifier_block *self,
++			  unsigned long event, void *data)
+ {
+ 	__sclp_vt220_flush_buffer();
++	return NOTIFY_OK;
+ }
+ 
++static struct notifier_block on_panic_nb = {
++	.notifier_call = sclp_vt220_notify,
++	.priority = 1,
++};
++
++static struct notifier_block on_reboot_nb = {
++	.notifier_call = sclp_vt220_notify,
++	.priority = 1,
++};
++
+ /* Structure needed to register with printk */
+ static struct console sclp_vt220_console =
+ {
+ 	.name = SCLP_VT220_CONSOLE_NAME,
+ 	.write = sclp_vt220_con_write,
+ 	.device = sclp_vt220_con_device,
+-	.unblank = sclp_vt220_con_unblank,
+ 	.flags = CON_PRINTBUFFER,
+ 	.index = SCLP_VT220_CONSOLE_INDEX
+ };
+@@ -776,6 +784,8 @@ sclp_vt220_con_init(void)
+ 	if (rc)
+ 		return rc;
+ 	/* Attach linux console */
++	atomic_notifier_chain_register(&panic_notifier_list, &on_panic_nb);
++	register_reboot_notifier(&on_reboot_nb);
+ 	register_console(&sclp_vt220_console);
+ 	return 0;
+ }
+Index: linux-2.6.27-gentoo-r7/drivers/s390/char/tape_block.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/char/tape_block.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/char/tape_block.c
+@@ -76,7 +76,7 @@ tapeblock_trigger_requeue(struct tape_de
+ static void
+ tapeblock_end_request(struct request *req, int error)
+ {
+-	if (__blk_end_request(req, error, blk_rq_bytes(req)))
++	if (blk_end_request(req, error, blk_rq_bytes(req)))
+ 		BUG();
+ }
+ 
+@@ -166,7 +166,7 @@ tapeblock_requeue(struct work_struct *wo
+ 		nr_queued++;
+ 	spin_unlock(get_ccwdev_lock(device->cdev));
+ 
+-	spin_lock(&device->blk_data.request_queue_lock);
++	spin_lock_irq(&device->blk_data.request_queue_lock);
+ 	while (
+ 		!blk_queue_plugged(queue) &&
+ 		elv_next_request(queue)   &&
+@@ -176,7 +176,9 @@ tapeblock_requeue(struct work_struct *wo
+ 		if (rq_data_dir(req) == WRITE) {
+ 			DBF_EVENT(1, "TBLOCK: Rejecting write request\n");
+ 			blkdev_dequeue_request(req);
++			spin_unlock_irq(&device->blk_data.request_queue_lock);
+ 			tapeblock_end_request(req, -EIO);
++			spin_lock_irq(&device->blk_data.request_queue_lock);
+ 			continue;
+ 		}
+ 		blkdev_dequeue_request(req);
+Index: linux-2.6.27-gentoo-r7/drivers/s390/char/tape_core.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/char/tape_core.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/char/tape_core.c
+@@ -1199,7 +1199,7 @@ tape_open(struct tape_device *device)
+ {
+ 	int rc;
+ 
+-	spin_lock(get_ccwdev_lock(device->cdev));
++	spin_lock_irq(get_ccwdev_lock(device->cdev));
+ 	if (device->tape_state == TS_NOT_OPER) {
+ 		DBF_EVENT(6, "TAPE:nodev\n");
+ 		rc = -ENODEV;
+@@ -1217,7 +1217,7 @@ tape_open(struct tape_device *device)
+ 		tape_state_set(device, TS_IN_USE);
+ 		rc = 0;
+ 	}
+-	spin_unlock(get_ccwdev_lock(device->cdev));
++	spin_unlock_irq(get_ccwdev_lock(device->cdev));
+ 	return rc;
+ }
+ 
+@@ -1227,11 +1227,11 @@ tape_open(struct tape_device *device)
+ int
+ tape_release(struct tape_device *device)
+ {
+-	spin_lock(get_ccwdev_lock(device->cdev));
++	spin_lock_irq(get_ccwdev_lock(device->cdev));
+ 	if (device->tape_state == TS_IN_USE)
+ 		tape_state_set(device, TS_UNUSED);
+ 	module_put(device->discipline->owner);
+-	spin_unlock(get_ccwdev_lock(device->cdev));
++	spin_unlock_irq(get_ccwdev_lock(device->cdev));
+ 	return 0;
+ }
+ 
+Index: linux-2.6.27-gentoo-r7/drivers/s390/cio/blacklist.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/cio/blacklist.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/cio/blacklist.c
+@@ -24,6 +24,7 @@
+ #include "cio.h"
+ #include "cio_debug.h"
+ #include "css.h"
++#include "device.h"
+ 
+ /*
+  * "Blacklisting" of certain devices:
+@@ -191,9 +192,9 @@ static int blacklist_parse_parameters(ch
+ 			rc = blacklist_range(ra, from_ssid, to_ssid, from, to,
+ 					     msgtrigger);
+ 			if (rc)
+-				totalrc = 1;
++				totalrc = -EINVAL;
+ 		} else
+-			totalrc = 1;
++			totalrc = -EINVAL;
+ 	}
+ 
+ 	return totalrc;
+@@ -240,8 +241,10 @@ static int blacklist_parse_proc_paramete
+ 		rc = blacklist_parse_parameters(buf, free, 0);
+ 	else if (strcmp("add", parm) == 0)
+ 		rc = blacklist_parse_parameters(buf, add, 0);
++	else if (strcmp("purge", parm) == 0)
++		return ccw_purge_blacklisted();
+ 	else
+-		return 1;
++		return -EINVAL;
+ 
+ 	css_schedule_reprobe();
+ 
+@@ -353,7 +356,7 @@ cio_ignore_write(struct file *file, cons
+ 	}
+ 	ret = blacklist_parse_proc_parameters(buf);
+ 	if (ret)
+-		rc = -EINVAL;
++		rc = ret;
+ 	else
+ 		rc = user_len;
+ 
+Index: linux-2.6.27-gentoo-r7/drivers/s390/cio/cio.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/cio/cio.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/cio/cio.c
+@@ -114,6 +114,7 @@ cio_tpi(void)
+ 	struct tpi_info *tpi_info;
+ 	struct subchannel *sch;
+ 	struct irb *irb;
++	int irq_context;
+ 
+ 	tpi_info = (struct tpi_info *) __LC_SUBCHANNEL_ID;
+ 	if (tpi (NULL) != 1)
+@@ -126,7 +127,9 @@ cio_tpi(void)
+ 	sch = (struct subchannel *)(unsigned long)tpi_info->intparm;
+ 	if (!sch)
+ 		return 1;
+-	local_bh_disable();
++	irq_context = in_interrupt();
++	if (!irq_context)
++		local_bh_disable();
+ 	irq_enter ();
+ 	spin_lock(sch->lock);
+ 	memcpy(&sch->schib.scsw, &irb->scsw, sizeof(union scsw));
+@@ -134,7 +137,8 @@ cio_tpi(void)
+ 		sch->driver->irq(sch);
+ 	spin_unlock(sch->lock);
+ 	irq_exit ();
+-	_local_bh_enable();
++	if (!irq_context)
++		_local_bh_enable();
+ 	return 1;
+ }
+ 
+@@ -892,7 +896,7 @@ static void cio_reset_pgm_check_handler(
+ 	pgm_check_occured = 1;
+ }
+ 
+-static int stsch_reset(struct subchannel_id schid, volatile struct schib *addr)
++static int stsch_reset(struct subchannel_id schid, struct schib *addr)
+ {
+ 	int rc;
+ 
+Index: linux-2.6.27-gentoo-r7/drivers/s390/cio/device.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/cio/device.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/cio/device.c
+@@ -31,6 +31,7 @@
+ #include "device.h"
+ #include "ioasm.h"
+ #include "io_sch.h"
++#include "blacklist.h"
+ 
+ static struct timer_list recovery_timer;
+ static DEFINE_SPINLOCK(recovery_lock);
+@@ -296,36 +297,33 @@ static void ccw_device_unregister(struct
+ 		device_del(&cdev->dev);
+ }
+ 
+-static void ccw_device_remove_orphan_cb(struct device *dev)
++static void ccw_device_remove_orphan_cb(struct work_struct *work)
+ {
+-	struct ccw_device *cdev = to_ccwdev(dev);
++	struct ccw_device_private *priv;
++	struct ccw_device *cdev;
+ 
++	priv = container_of(work, struct ccw_device_private, kick_work);
++	cdev = priv->cdev;
+ 	ccw_device_unregister(cdev);
+ 	put_device(&cdev->dev);
++	/* Release cdev reference for workqueue processing. */
++	put_device(&cdev->dev);
+ }
+ 
+-static void ccw_device_remove_sch_cb(struct device *dev)
+-{
+-	struct subchannel *sch;
+-
+-	sch = to_subchannel(dev);
+-	css_sch_device_unregister(sch);
+-	/* Reset intparm to zeroes. */
+-	sch->schib.pmcw.intparm = 0;
+-	cio_modify(sch);
+-	put_device(&sch->dev);
+-}
++static void ccw_device_call_sch_unregister(struct work_struct *work);
+ 
+ static void
+ ccw_device_remove_disconnected(struct ccw_device *cdev)
+ {
+ 	unsigned long flags;
+-	int rc;
+ 
+ 	/*
+ 	 * Forced offline in disconnected state means
+ 	 * 'throw away device'.
+ 	 */
++	/* Get cdev reference for workqueue processing. */
++	if (!get_device(&cdev->dev))
++		return;
+ 	if (ccw_device_is_orphan(cdev)) {
+ 		/*
+ 		 * Deregister ccw device.
+@@ -335,23 +333,13 @@ ccw_device_remove_disconnected(struct cc
+ 		spin_lock_irqsave(cdev->ccwlock, flags);
+ 		cdev->private->state = DEV_STATE_NOT_OPER;
+ 		spin_unlock_irqrestore(cdev->ccwlock, flags);
+-		rc = device_schedule_callback(&cdev->dev,
+-					      ccw_device_remove_orphan_cb);
+-		if (rc)
+-			CIO_MSG_EVENT(0, "Couldn't unregister orphan "
+-				      "0.%x.%04x\n",
+-				      cdev->private->dev_id.ssid,
+-				      cdev->private->dev_id.devno);
+-		return;
+-	}
+-	/* Deregister subchannel, which will kill the ccw device. */
+-	rc = device_schedule_callback(cdev->dev.parent,
+-				      ccw_device_remove_sch_cb);
+-	if (rc)
+-		CIO_MSG_EVENT(0, "Couldn't unregister disconnected device "
+-			      "0.%x.%04x\n",
+-			      cdev->private->dev_id.ssid,
+-			      cdev->private->dev_id.devno);
++		PREPARE_WORK(&cdev->private->kick_work,
++				ccw_device_remove_orphan_cb);
++	} else
++		/* Deregister subchannel, which will kill the ccw device. */
++		PREPARE_WORK(&cdev->private->kick_work,
++				ccw_device_call_sch_unregister);
++	queue_work(slow_path_wq, &cdev->private->kick_work);
+ }
+ 
+ /**
+@@ -886,11 +874,15 @@ void ccw_device_move_to_orphanage(struct
+ 	replacing_cdev = get_disc_ccwdev_by_dev_id(&dev_id, cdev);
+ 	if (replacing_cdev) {
+ 		sch_attach_disconnected_device(sch, replacing_cdev);
++		/* Release reference from get_disc_ccwdev_by_dev_id() */
++		put_device(&cdev->dev);
+ 		return;
+ 	}
+ 	replacing_cdev = get_orphaned_ccwdev_by_dev_id(css, &dev_id);
+ 	if (replacing_cdev) {
+ 		sch_attach_orphaned_device(sch, replacing_cdev);
++		/* Release reference from get_orphaned_ccwdev_by_dev_id() */
++		put_device(&cdev->dev);
+ 		return;
+ 	}
+ 	sch_create_and_recog_new_device(sch);
+@@ -970,12 +962,17 @@ static void ccw_device_call_sch_unregist
+ 
+ 	priv = container_of(work, struct ccw_device_private, kick_work);
+ 	cdev = priv->cdev;
++	/* Get subchannel reference for local processing. */
++	if (!get_device(cdev->dev.parent))
++		return;
+ 	sch = to_subchannel(cdev->dev.parent);
+ 	css_sch_device_unregister(sch);
+ 	/* Reset intparm to zeroes. */
+ 	sch->schib.pmcw.intparm = 0;
+ 	cio_modify(sch);
++	/* Release cdev reference for workqueue processing.*/
+ 	put_device(&cdev->dev);
++	/* Release subchannel reference for local processing. */
+ 	put_device(&sch->dev);
+ }
+ 
+@@ -1001,6 +998,8 @@ io_subchannel_recog_done(struct ccw_devi
+ 		PREPARE_WORK(&cdev->private->kick_work,
+ 			     ccw_device_call_sch_unregister);
+ 		queue_work(slow_path_wq, &cdev->private->kick_work);
++		/* Release subchannel reference for asynchronous recognition. */
++		put_device(&sch->dev);
+ 		if (atomic_dec_and_test(&ccw_device_init_count))
+ 			wake_up(&ccw_device_init_wq);
+ 		break;
+@@ -1476,6 +1475,45 @@ static void ccw_device_schedule_recovery
+ 	spin_unlock_irqrestore(&recovery_lock, flags);
+ }
+ 
++static int purge_fn(struct device *dev, void *data)
++{
++	struct ccw_device *cdev = to_ccwdev(dev);
++	struct ccw_device_private *priv = cdev->private;
++	int unreg;
++
++	spin_lock_irq(cdev->ccwlock);
++	unreg = is_blacklisted(priv->dev_id.ssid, priv->dev_id.devno) &&
++		(priv->state == DEV_STATE_OFFLINE);
++	spin_unlock_irq(cdev->ccwlock);
++	if (!unreg)
++		goto out;
++	if (!get_device(&cdev->dev))
++		goto out;
++	CIO_MSG_EVENT(3, "ccw: purging 0.%x.%04x\n", priv->dev_id.ssid,
++		      priv->dev_id.devno);
++	PREPARE_WORK(&cdev->private->kick_work, ccw_device_call_sch_unregister);
++	queue_work(slow_path_wq, &cdev->private->kick_work);
++
++out:
++	/* Abort loop in case of pending signal. */
++	if (signal_pending(current))
++		return -EINTR;
++
++	return 0;
++}
++
++/**
++ * ccw_purge_blacklisted - purge unused, blacklisted devices
++ *
++ * Unregister all ccw devices that are offline and on the blacklist.
++ */
++int ccw_purge_blacklisted(void)
++{
++	CIO_MSG_EVENT(2, "ccw: purging blacklisted devices\n");
++	bus_for_each_dev(&ccw_bus_type, NULL, NULL, purge_fn);
++	return 0;
++}
++
+ static void device_set_disconnected(struct ccw_device *cdev)
+ {
+ 	if (!cdev)
+Index: linux-2.6.27-gentoo-r7/drivers/s390/cio/device.h
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/cio/device.h
++++ linux-2.6.27-gentoo-r7/drivers/s390/cio/device.h
+@@ -86,6 +86,7 @@ int ccw_device_is_orphan(struct ccw_devi
+ int ccw_device_recognition(struct ccw_device *);
+ int ccw_device_online(struct ccw_device *);
+ int ccw_device_offline(struct ccw_device *);
++int ccw_purge_blacklisted(void);
+ 
+ /* Function prototypes for device status and basic sense stuff. */
+ void ccw_device_accumulate_irb(struct ccw_device *, struct irb *);
+Index: linux-2.6.27-gentoo-r7/drivers/s390/cio/io_sch.h
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/cio/io_sch.h
++++ linux-2.6.27-gentoo-r7/drivers/s390/cio/io_sch.h
+@@ -123,7 +123,7 @@ struct ccw_device_private {
+ 	void *cmb_wait;			/* deferred cmb enable/disable */
+ };
+ 
+-static inline int ssch(struct subchannel_id schid, volatile union orb *addr)
++static inline int ssch(struct subchannel_id schid, union orb *addr)
+ {
+ 	register struct subchannel_id reg1 asm("1") = schid;
+ 	int ccode = -EIO;
+@@ -134,7 +134,9 @@ static inline int ssch(struct subchannel
+ 		"	srl	%0,28\n"
+ 		"1:\n"
+ 		EX_TABLE(0b, 1b)
+-		: "+d" (ccode) : "d" (reg1), "a" (addr), "m" (*addr) : "cc");
++		: "+d" (ccode)
++		: "d" (reg1), "a" (addr), "m" (*addr)
++		: "cc", "memory");
+ 	return ccode;
+ }
+ 
+@@ -147,7 +149,9 @@ static inline int rsch(struct subchannel
+ 		"	rsch\n"
+ 		"	ipm	%0\n"
+ 		"	srl	%0,28"
+-		: "=d" (ccode) : "d" (reg1) : "cc");
++		: "=d" (ccode)
++		: "d" (reg1)
++		: "cc", "memory");
+ 	return ccode;
+ }
+ 
+@@ -160,7 +164,9 @@ static inline int csch(struct subchannel
+ 		"	csch\n"
+ 		"	ipm	%0\n"
+ 		"	srl	%0,28"
+-		: "=d" (ccode) : "d" (reg1) : "cc");
++		: "=d" (ccode)
++		: "d" (reg1)
++		: "cc");
+ 	return ccode;
+ }
+ 
+@@ -173,7 +179,9 @@ static inline int hsch(struct subchannel
+ 		"	hsch\n"
+ 		"	ipm	%0\n"
+ 		"	srl	%0,28"
+-		: "=d" (ccode) : "d" (reg1) : "cc");
++		: "=d" (ccode)
++		: "d" (reg1)
++		: "cc");
+ 	return ccode;
+ }
+ 
+@@ -186,7 +194,9 @@ static inline int xsch(struct subchannel
+ 		"	.insn	rre,0xb2760000,%1,0\n"
+ 		"	ipm	%0\n"
+ 		"	srl	%0,28"
+-		: "=d" (ccode) : "d" (reg1) : "cc");
++		: "=d" (ccode)
++		: "d" (reg1)
++		: "cc");
+ 	return ccode;
+ }
+ 
+Index: linux-2.6.27-gentoo-r7/drivers/s390/cio/ioasm.h
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/cio/ioasm.h
++++ linux-2.6.27-gentoo-r7/drivers/s390/cio/ioasm.h
+@@ -23,38 +23,39 @@ struct tpi_info {
+  * Some S390 specific IO instructions as inline
+  */
+ 
+-static inline int stsch(struct subchannel_id schid,
+-			    volatile struct schib *addr)
++static inline int stsch(struct subchannel_id schid, struct schib *addr)
+ {
+ 	register struct subchannel_id reg1 asm ("1") = schid;
+ 	int ccode;
+ 
+ 	asm volatile(
+-		"	stsch	0(%2)\n"
++		"	stsch	0(%3)\n"
+ 		"	ipm	%0\n"
+ 		"	srl	%0,28"
+-		: "=d" (ccode) : "d" (reg1), "a" (addr), "m" (*addr) : "cc");
++		: "=d" (ccode), "=m" (*addr)
++		: "d" (reg1), "a" (addr)
++		: "cc");
+ 	return ccode;
+ }
+ 
+-static inline int stsch_err(struct subchannel_id schid,
+-				volatile struct schib *addr)
++static inline int stsch_err(struct subchannel_id schid, struct schib *addr)
+ {
+ 	register struct subchannel_id reg1 asm ("1") = schid;
+ 	int ccode = -EIO;
+ 
+ 	asm volatile(
+-		"	stsch	0(%2)\n"
++		"	stsch	0(%3)\n"
+ 		"0:	ipm	%0\n"
+ 		"	srl	%0,28\n"
+ 		"1:\n"
+ 		EX_TABLE(0b,1b)
+-		: "+d" (ccode) : "d" (reg1), "a" (addr), "m" (*addr) : "cc");
++		: "+d" (ccode), "=m" (*addr)
++		: "d" (reg1), "a" (addr)
++		: "cc");
+ 	return ccode;
+ }
+ 
+-static inline int msch(struct subchannel_id schid,
+-			   volatile struct schib *addr)
++static inline int msch(struct subchannel_id schid, struct schib *addr)
+ {
+ 	register struct subchannel_id reg1 asm ("1") = schid;
+ 	int ccode;
+@@ -63,12 +64,13 @@ static inline int msch(struct subchannel
+ 		"	msch	0(%2)\n"
+ 		"	ipm	%0\n"
+ 		"	srl	%0,28"
+-		: "=d" (ccode) : "d" (reg1), "a" (addr), "m" (*addr) : "cc");
++		: "=d" (ccode)
++		: "d" (reg1), "a" (addr), "m" (*addr)
++		: "cc");
+ 	return ccode;
+ }
+ 
+-static inline int msch_err(struct subchannel_id schid,
+-			       volatile struct schib *addr)
++static inline int msch_err(struct subchannel_id schid, struct schib *addr)
+ {
+ 	register struct subchannel_id reg1 asm ("1") = schid;
+ 	int ccode = -EIO;
+@@ -79,33 +81,38 @@ static inline int msch_err(struct subcha
+ 		"	srl	%0,28\n"
+ 		"1:\n"
+ 		EX_TABLE(0b,1b)
+-		: "+d" (ccode) : "d" (reg1), "a" (addr), "m" (*addr) : "cc");
++		: "+d" (ccode)
++		: "d" (reg1), "a" (addr), "m" (*addr)
++		: "cc");
+ 	return ccode;
+ }
+ 
+-static inline int tsch(struct subchannel_id schid,
+-			   volatile struct irb *addr)
++static inline int tsch(struct subchannel_id schid, struct irb *addr)
+ {
+ 	register struct subchannel_id reg1 asm ("1") = schid;
+ 	int ccode;
+ 
+ 	asm volatile(
+-		"	tsch	0(%2)\n"
++		"	tsch	0(%3)\n"
+ 		"	ipm	%0\n"
+ 		"	srl	%0,28"
+-		: "=d" (ccode) : "d" (reg1), "a" (addr), "m" (*addr) : "cc");
++		: "=d" (ccode), "=m" (*addr)
++		: "d" (reg1), "a" (addr)
++		: "cc");
+ 	return ccode;
+ }
+ 
+-static inline int tpi( volatile struct tpi_info *addr)
++static inline int tpi(struct tpi_info *addr)
+ {
+ 	int ccode;
+ 
+ 	asm volatile(
+-		"	tpi	0(%1)\n"
++		"	tpi	0(%2)\n"
+ 		"	ipm	%0\n"
+ 		"	srl	%0,28"
+-		: "=d" (ccode) : "a" (addr), "m" (*addr) : "cc");
++		: "=d" (ccode), "=m" (*addr)
++		: "a" (addr)
++		: "cc");
+ 	return ccode;
+ }
+ 
+Index: linux-2.6.27-gentoo-r7/drivers/s390/cio/qdio.h
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/cio/qdio.h
++++ linux-2.6.27-gentoo-r7/drivers/s390/cio/qdio.h
+@@ -16,6 +16,14 @@
+ #define QDIO_BUSY_BIT_GIVE_UP		2000000	/* 2 seconds = eternity */
+ #define QDIO_INPUT_THRESHOLD		500	/* 500 microseconds */
+ 
++/*
++ * if an asynchronous HiperSockets queue runs full, the 10 seconds timer wait
++ * till next initiative to give transmitted skbs back to the stack is too long.
++ * Therefore polling is started in case of multicast queue is filled more
++ * than 50 percent.
++ */
++#define QDIO_IQDIO_POLL_LVL		65	/* HS multicast queue */
++
+ enum qdio_irq_states {
+ 	QDIO_IRQ_STATE_INACTIVE,
+ 	QDIO_IRQ_STATE_ESTABLISHED,
+@@ -367,6 +375,9 @@ void qdio_int_handler(struct ccw_device 
+ int qdio_allocate_qs(struct qdio_irq *irq_ptr, int nr_input_qs,
+ 		     int nr_output_qs);
+ void qdio_setup_ssqd_info(struct qdio_irq *irq_ptr);
++int qdio_setup_get_ssqd(struct qdio_irq *irq_ptr,
++			struct subchannel_id *schid,
++			struct qdio_ssqd_desc *data);
+ int qdio_setup_irq(struct qdio_initialize *init_data);
+ void qdio_print_subchannel_info(struct qdio_irq *irq_ptr,
+ 				struct ccw_device *cdev);
+Index: linux-2.6.27-gentoo-r7/drivers/s390/cio/qdio_debug.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/cio/qdio_debug.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/cio/qdio_debug.c
+@@ -20,6 +20,7 @@ static struct dentry *debugfs_root;
+ #define MAX_DEBUGFS_QUEUES	32
+ static struct dentry *debugfs_queues[MAX_DEBUGFS_QUEUES] = { NULL };
+ static DEFINE_MUTEX(debugfs_mutex);
++#define QDIO_DEBUGFS_NAME_LEN	40
+ 
+ void qdio_allocate_do_dbf(struct qdio_initialize *init_data)
+ {
+@@ -152,17 +153,6 @@ static int qstat_seq_open(struct inode *
+ 			   filp->f_path.dentry->d_inode->i_private);
+ }
+ 
+-static void get_queue_name(struct qdio_q *q, struct ccw_device *cdev, char *name)
+-{
+-	memset(name, 0, sizeof(name));
+-	sprintf(name, "%s", cdev->dev.bus_id);
+-	if (q->is_input_q)
+-		sprintf(name + strlen(name), "_input");
+-	else
+-		sprintf(name + strlen(name), "_output");
+-	sprintf(name + strlen(name), "_%d", q->nr);
+-}
+-
+ static void remove_debugfs_entry(struct qdio_q *q)
+ {
+ 	int i;
+@@ -189,14 +179,17 @@ static struct file_operations debugfs_fo
+ static void setup_debugfs_entry(struct qdio_q *q, struct ccw_device *cdev)
+ {
+ 	int i = 0;
+-	char name[40];
++	char name[QDIO_DEBUGFS_NAME_LEN];
+ 
+ 	while (debugfs_queues[i] != NULL) {
+ 		i++;
+ 		if (i >= MAX_DEBUGFS_QUEUES)
+ 			return;
+ 	}
+-	get_queue_name(q, cdev, name);
++	snprintf(name, QDIO_DEBUGFS_NAME_LEN, "%s_%s_%d",
++		 dev_name(&cdev->dev),
++		 q->is_input_q ? "input" : "output",
++		 q->nr);
+ 	debugfs_queues[i] = debugfs_create_file(name, S_IFREG | S_IRUGO | S_IWUSR,
+ 						debugfs_root, q, &debugfs_fops);
+ }
+Index: linux-2.6.27-gentoo-r7/drivers/s390/cio/qdio_main.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/cio/qdio_main.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/cio/qdio_main.c
+@@ -851,6 +851,12 @@ static void __qdio_outbound_processing(s
+ 	if (queue_type(q) == QDIO_IQDIO_QFMT && !multicast_outbound(q))
+ 		return;
+ 
++	if ((queue_type(q) == QDIO_IQDIO_QFMT) &&
++	    (atomic_read(&q->nr_buf_used)) > QDIO_IQDIO_POLL_LVL) {
++		tasklet_schedule(&q->tasklet);
++		return;
++	}
++
+ 	if (q->u.out.pci_out_enabled)
+ 		return;
+ 
+@@ -1074,7 +1080,6 @@ void qdio_int_handler(struct ccw_device 
+ 		case -EIO:
+ 			sprintf(dbf_text, "ierr%4x", irq_ptr->schid.sch_no);
+ 			QDIO_DBF_TEXT2(1, setup, dbf_text);
+-			qdio_int_error(cdev);
+ 			return;
+ 		case -ETIMEDOUT:
+ 			sprintf(dbf_text, "qtoh%4x", irq_ptr->schid.sch_no);
+@@ -1121,23 +1126,23 @@ void qdio_int_handler(struct ccw_device 
+ /**
+  * qdio_get_ssqd_desc - get qdio subchannel description
+  * @cdev: ccw device to get description for
++ * @data: where to store the ssqd
+  *
+- * Returns a pointer to the saved qdio subchannel description,
+- * or NULL for not setup qdio devices.
++ * Returns 0 or an error code. The results of the chsc are stored in the
++ * specified structure.
+  */
+-struct qdio_ssqd_desc *qdio_get_ssqd_desc(struct ccw_device *cdev)
++int qdio_get_ssqd_desc(struct ccw_device *cdev,
++		       struct qdio_ssqd_desc *data)
+ {
+-	struct qdio_irq *irq_ptr;
+ 	char dbf_text[15];
+ 
++	if (!cdev || !cdev->private)
++		return -EINVAL;
++
+ 	sprintf(dbf_text, "qssq%4x", cdev->private->schid.sch_no);
+ 	QDIO_DBF_TEXT0(0, setup, dbf_text);
+ 
+-	irq_ptr = cdev->private->qdio_data;
+-	if (!irq_ptr)
+-		return NULL;
+-
+-	return &irq_ptr->ssqd_desc;
++	return qdio_setup_get_ssqd(NULL, &cdev->private->schid, data);
+ }
+ EXPORT_SYMBOL_GPL(qdio_get_ssqd_desc);
+ 
+Index: linux-2.6.27-gentoo-r7/drivers/s390/cio/qdio_setup.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/cio/qdio_setup.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/cio/qdio_setup.c
+@@ -243,22 +243,31 @@ no_qebsm:
+ 	QDIO_DBF_TEXT0(0, setup, "noV=V");
+ }
+ 
+-static int __get_ssqd_info(struct qdio_irq *irq_ptr)
++/*
++ * If there is a qdio_irq we use the chsc_page and store the information
++ * in the qdio_irq, otherwise we copy it to the specified structure.
++ */
++int qdio_setup_get_ssqd(struct qdio_irq *irq_ptr,
++			struct subchannel_id *schid,
++			struct qdio_ssqd_desc *data)
+ {
+ 	struct chsc_ssqd_area *ssqd;
+ 	int rc;
+ 
+ 	QDIO_DBF_TEXT0(0, setup, "getssqd");
+-	ssqd = (struct chsc_ssqd_area *)irq_ptr->chsc_page;
++	if (irq_ptr != NULL)
++		ssqd = (struct chsc_ssqd_area *)irq_ptr->chsc_page;
++	else
++		ssqd = (struct chsc_ssqd_area *)__get_free_page(GFP_KERNEL);
+ 	memset(ssqd, 0, PAGE_SIZE);
+ 
+ 	ssqd->request = (struct chsc_header) {
+ 		.length = 0x0010,
+ 		.code	= 0x0024,
+ 	};
+-	ssqd->first_sch = irq_ptr->schid.sch_no;
+-	ssqd->last_sch = irq_ptr->schid.sch_no;
+-	ssqd->ssid = irq_ptr->schid.ssid;
++	ssqd->first_sch = schid->sch_no;
++	ssqd->last_sch = schid->sch_no;
++	ssqd->ssid = schid->ssid;
+ 
+ 	if (chsc(ssqd))
+ 		return -EIO;
+@@ -268,11 +277,17 @@ static int __get_ssqd_info(struct qdio_i
+ 
+ 	if (!(ssqd->qdio_ssqd.flags & CHSC_FLAG_QDIO_CAPABILITY) ||
+ 	    !(ssqd->qdio_ssqd.flags & CHSC_FLAG_VALIDITY) ||
+-	    (ssqd->qdio_ssqd.sch != irq_ptr->schid.sch_no))
++	    (ssqd->qdio_ssqd.sch != schid->sch_no))
+ 		return -EINVAL;
+ 
+-	memcpy(&irq_ptr->ssqd_desc, &ssqd->qdio_ssqd,
+-	       sizeof(struct qdio_ssqd_desc));
++	if (irq_ptr != NULL)
++		memcpy(&irq_ptr->ssqd_desc, &ssqd->qdio_ssqd,
++		       sizeof(struct qdio_ssqd_desc));
++	else {
++		memcpy(data, &ssqd->qdio_ssqd,
++		       sizeof(struct qdio_ssqd_desc));
++		free_page((unsigned long)ssqd);
++	}
+ 	return 0;
+ }
+ 
+@@ -282,7 +297,7 @@ void qdio_setup_ssqd_info(struct qdio_ir
+ 	char dbf_text[15];
+ 	int rc;
+ 
+-	rc = __get_ssqd_info(irq_ptr);
++	rc = qdio_setup_get_ssqd(irq_ptr, &irq_ptr->schid, NULL);
+ 	if (rc) {
+ 		QDIO_DBF_TEXT2(0, setup, "ssqdasig");
+ 		sprintf(dbf_text, "schn%4x", irq_ptr->schid.sch_no);
+Index: linux-2.6.27-gentoo-r7/drivers/s390/net/qeth_core_main.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/net/qeth_core_main.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/net/qeth_core_main.c
+@@ -760,7 +760,7 @@ static int qeth_get_problem(struct ccw_d
+ 		if (sense[SENSE_COMMAND_REJECT_BYTE] &
+ 		    SENSE_COMMAND_REJECT_FLAG) {
+ 			QETH_DBF_TEXT(TRACE, 2, "CMDREJi");
+-			return 0;
++			return 1;
+ 		}
+ 		if ((sense[2] == 0xaf) && (sense[3] == 0xfe)) {
+ 			QETH_DBF_TEXT(TRACE, 2, "AFFE");
+@@ -884,6 +884,7 @@ static void qeth_irq(struct ccw_device *
+ 		}
+ 		rc = qeth_get_problem(cdev, irb);
+ 		if (rc) {
++			qeth_clear_ipacmd_list(card);
+ 			qeth_schedule_recovery(card);
+ 			goto out;
+ 		}
+@@ -3024,7 +3025,7 @@ static inline void __qeth_fill_buffer(st
+ 	struct qdio_buffer *buffer, int is_tso, int *next_element_to_fill,
+ 	int offset)
+ {
+-	int length = skb->len - offset;
++	int length = skb->len;
+ 	int length_here;
+ 	int element;
+ 	char *data;
+@@ -3036,6 +3037,7 @@ static inline void __qeth_fill_buffer(st
+ 
+ 	if (offset >= 0) {
+ 		data = skb->data + offset;
++		length -= offset;
+ 		first_lap = 0;
+ 	}
+ 
+@@ -3755,7 +3757,7 @@ static int qeth_core_driver_group(const 
+ 
+ int qeth_core_hardsetup_card(struct qeth_card *card)
+ {
+-	struct qdio_ssqd_desc *qdio_ssqd;
++	struct qdio_ssqd_desc *ssqd;
+ 	int retries = 3;
+ 	int mpno = 0;
+ 	int rc;
+@@ -3790,9 +3792,16 @@ retry:
+ 		return rc;
+ 	}
+ 
+-	qdio_ssqd = qdio_get_ssqd_desc(CARD_DDEV(card));
+-	if (qdio_ssqd)
+-		mpno = qdio_ssqd->pcnt;
++	ssqd = kmalloc(sizeof(struct qdio_ssqd_desc), GFP_KERNEL);
++	if (!ssqd) {
++		rc = -ENOMEM;
++		goto out;
++	}
++	rc = qdio_get_ssqd_desc(CARD_DDEV(card), ssqd);
++	if (rc == 0)
++		mpno = ssqd->pcnt;
++	kfree(ssqd);
++
+ 	if (mpno)
+ 		mpno = min(mpno - 1, QETH_MAX_PORTNO);
+ 	if (card->info.portno > mpno) {
+@@ -4147,6 +4156,7 @@ static void qeth_core_remove_device(stru
+ 	unsigned long flags;
+ 	struct qeth_card *card = dev_get_drvdata(&gdev->dev);
+ 
++	QETH_DBF_TEXT(SETUP, 2, "removedv");
+ 	if (card->discipline.ccwgdriver) {
+ 		card->discipline.ccwgdriver->remove(gdev);
+ 		qeth_core_free_discipline(card);
+Index: linux-2.6.27-gentoo-r7/drivers/s390/net/qeth_l2_main.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/net/qeth_l2_main.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/net/qeth_l2_main.c
+@@ -373,8 +373,6 @@ static int qeth_l2_stop_card(struct qeth
+ 	QETH_DBF_HEX(SETUP, 2, &card, sizeof(void *));
+ 
+ 	qeth_set_allowed_threads(card, 0, 1);
+-	if (qeth_wait_for_threads(card, ~QETH_RECOVER_THREAD))
+-		return -ERESTARTSYS;
+ 	if (card->read.state == CH_STATE_UP &&
+ 	    card->write.state == CH_STATE_UP &&
+ 	    (card->state == CARD_STATE_UP)) {
+@@ -395,7 +393,8 @@ static int qeth_l2_stop_card(struct qeth
+ 	}
+ 	if (card->state == CARD_STATE_SOFTSETUP) {
+ 		qeth_l2_process_vlans(card, 1);
+-		qeth_l2_del_all_mc(card);
++		if (!card->use_hard_stop)
++			qeth_l2_del_all_mc(card);
+ 		qeth_clear_ipacmd_list(card);
+ 		card->state = CARD_STATE_HARDSETUP;
+ 	}
+@@ -450,12 +449,15 @@ static void qeth_l2_process_inbound_buff
+ 			netif_rx(skb);
+ 			break;
+ 		case QETH_HEADER_TYPE_OSN:
+-			skb_push(skb, sizeof(struct qeth_hdr));
+-			skb_copy_to_linear_data(skb, hdr,
++			if (card->info.type == QETH_CARD_TYPE_OSN) {
++				skb_push(skb, sizeof(struct qeth_hdr));
++				skb_copy_to_linear_data(skb, hdr,
+ 						sizeof(struct qeth_hdr));
+-			len = skb->len;
+-			card->osn_info.data_cb(skb);
+-			break;
++				len = skb->len;
++				card->osn_info.data_cb(skb);
++				break;
++			}
++			/* else unknown */
+ 		default:
+ 			dev_kfree_skb_any(skb);
+ 			QETH_DBF_TEXT(TRACE, 3, "inbunkno");
+@@ -559,7 +561,8 @@ static int qeth_l2_request_initial_mac(s
+ 			"device %s: x%x\n", CARD_BUS_ID(card), rc);
+ 	}
+ 
+-	if (card->info.guestlan) {
++	if ((card->info.type == QETH_CARD_TYPE_IQD) ||
++	    (card->info.guestlan)) {
+ 		rc = qeth_setadpparms_change_macaddr(card);
+ 		if (rc) {
+ 			QETH_DBF_MESSAGE(2, "couldn't get MAC address on "
+@@ -825,7 +828,6 @@ static int qeth_l2_open(struct net_devic
+ 	}
+ 	card->data.state = CH_STATE_UP;
+ 	card->state = CARD_STATE_UP;
+-	card->dev->flags |= IFF_UP;
+ 	netif_start_queue(dev);
+ 
+ 	if (!card->lan_online && netif_carrier_ok(dev))
+@@ -840,7 +842,6 @@ static int qeth_l2_stop(struct net_devic
+ 
+ 	QETH_DBF_TEXT(TRACE, 4, "qethstop");
+ 	netif_tx_disable(dev);
+-	card->dev->flags &= ~IFF_UP;
+ 	if (card->state == CARD_STATE_UP)
+ 		card->state = CARD_STATE_SOFTSETUP;
+ 	return 0;
+@@ -975,12 +976,6 @@ static int __qeth_l2_set_online(struct c
+ 	QETH_DBF_HEX(SETUP, 2, &card, sizeof(void *));
+ 
+ 	qeth_set_allowed_threads(card, QETH_RECOVER_THREAD, 1);
+-	if (qeth_wait_for_threads(card, ~QETH_RECOVER_THREAD)) {
+-		PRINT_WARN("set_online of card %s interrupted by user!\n",
+-			   CARD_BUS_ID(card));
+-		return -ERESTARTSYS;
+-	}
+-
+ 	recover_flag = card->state;
+ 	rc = ccw_device_set_online(CARD_RDEV(card));
+ 	if (rc) {
+@@ -1091,11 +1086,7 @@ static int __qeth_l2_set_offline(struct 
+ 	if (card->dev && netif_carrier_ok(card->dev))
+ 		netif_carrier_off(card->dev);
+ 	recover_flag = card->state;
+-	if (qeth_l2_stop_card(card, recovery_mode) == -ERESTARTSYS) {
+-		PRINT_WARN("Stopping card %s interrupted by user!\n",
+-			   CARD_BUS_ID(card));
+-		return -ERESTARTSYS;
+-	}
++	qeth_l2_stop_card(card, recovery_mode);
+ 	rc  = ccw_device_set_offline(CARD_DDEV(card));
+ 	rc2 = ccw_device_set_offline(CARD_WDEV(card));
+ 	rc3 = ccw_device_set_offline(CARD_RDEV(card));
+@@ -1137,9 +1128,13 @@ static int qeth_l2_recover(void *ptr)
+ 	if (!rc)
+ 		PRINT_INFO("Device %s successfully recovered!\n",
+ 			   CARD_BUS_ID(card));
+-	else
++	else {
++		rtnl_lock();
++		dev_close(card->dev);
++		rtnl_unlock();
+ 		PRINT_INFO("Device %s could not be recovered!\n",
+ 			   CARD_BUS_ID(card));
++	}
+ 	return 0;
+ }
+ 
+Index: linux-2.6.27-gentoo-r7/drivers/s390/net/qeth_l3_main.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/net/qeth_l3_main.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/net/qeth_l3_main.c
+@@ -2064,8 +2064,6 @@ static int qeth_l3_stop_card(struct qeth
+ 	QETH_DBF_HEX(SETUP, 2, &card, sizeof(void *));
+ 
+ 	qeth_set_allowed_threads(card, 0, 1);
+-	if (qeth_wait_for_threads(card, ~QETH_RECOVER_THREAD))
+-		return -ERESTARTSYS;
+ 	if (card->read.state == CH_STATE_UP &&
+ 	    card->write.state == CH_STATE_UP &&
+ 	    (card->state == CARD_STATE_UP)) {
+@@ -2795,7 +2793,6 @@ static int qeth_l3_open(struct net_devic
+ 		return -ENODEV;
+ 	card->data.state = CH_STATE_UP;
+ 	card->state = CARD_STATE_UP;
+-	card->dev->flags |= IFF_UP;
+ 	netif_start_queue(dev);
+ 
+ 	if (!card->lan_online && netif_carrier_ok(dev))
+@@ -2809,7 +2806,6 @@ static int qeth_l3_stop(struct net_devic
+ 
+ 	QETH_DBF_TEXT(TRACE, 4, "qethstop");
+ 	netif_tx_disable(dev);
+-	card->dev->flags &= ~IFF_UP;
+ 	if (card->state == CARD_STATE_UP)
+ 		card->state = CARD_STATE_SOFTSETUP;
+ 	return 0;
+@@ -3051,11 +3047,6 @@ static int __qeth_l3_set_online(struct c
+ 	QETH_DBF_HEX(SETUP, 2, &card, sizeof(void *));
+ 
+ 	qeth_set_allowed_threads(card, QETH_RECOVER_THREAD, 1);
+-	if (qeth_wait_for_threads(card, ~QETH_RECOVER_THREAD)) {
+-		PRINT_WARN("set_online of card %s interrupted by user!\n",
+-			   CARD_BUS_ID(card));
+-		return -ERESTARTSYS;
+-	}
+ 
+ 	recover_flag = card->state;
+ 	rc = ccw_device_set_online(CARD_RDEV(card));
+@@ -3172,11 +3163,7 @@ static int __qeth_l3_set_offline(struct 
+ 	if (card->dev && netif_carrier_ok(card->dev))
+ 		netif_carrier_off(card->dev);
+ 	recover_flag = card->state;
+-	if (qeth_l3_stop_card(card, recovery_mode) == -ERESTARTSYS) {
+-		PRINT_WARN("Stopping card %s interrupted by user!\n",
+-			   CARD_BUS_ID(card));
+-		return -ERESTARTSYS;
+-	}
++	qeth_l3_stop_card(card, recovery_mode);
+ 	rc  = ccw_device_set_offline(CARD_DDEV(card));
+ 	rc2 = ccw_device_set_offline(CARD_WDEV(card));
+ 	rc3 = ccw_device_set_offline(CARD_RDEV(card));
+@@ -3218,9 +3205,13 @@ static int qeth_l3_recover(void *ptr)
+ 	if (!rc)
+ 		PRINT_INFO("Device %s successfully recovered!\n",
+ 			   CARD_BUS_ID(card));
+-	else
++	else {
++		rtnl_lock();
++		dev_close(card->dev);
++		rtnl_unlock();
+ 		PRINT_INFO("Device %s could not be recovered!\n",
+ 			   CARD_BUS_ID(card));
++	}
+ 	return 0;
+ }
+ 
+Index: linux-2.6.27-gentoo-r7/drivers/s390/net/qeth_l3_sys.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/net/qeth_l3_sys.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/net/qeth_l3_sys.c
+@@ -121,9 +121,6 @@ static ssize_t qeth_l3_dev_route6_show(s
+ 	if (!card)
+ 		return -EINVAL;
+ 
+-	if (!qeth_is_supported(card, IPA_IPV6))
+-		return sprintf(buf, "%s\n", "n/a");
+-
+ 	return qeth_l3_dev_route_show(card, &card->options.route6, buf);
+ }
+ 
+@@ -135,10 +132,6 @@ static ssize_t qeth_l3_dev_route6_store(
+ 	if (!card)
+ 		return -EINVAL;
+ 
+-	if (!qeth_is_supported(card, IPA_IPV6)) {
+-		return -EOPNOTSUPP;
+-	}
+-
+ 	return qeth_l3_dev_route_store(card, &card->options.route6,
+ 				QETH_PROT_IPV6, buf, count);
+ }
+Index: linux-2.6.27-gentoo-r7/drivers/s390/scsi/zfcp_aux.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/scsi/zfcp_aux.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/scsi/zfcp_aux.c
+@@ -100,24 +100,10 @@ static int __init zfcp_device_setup(char
+ 
+  err_out:
+ 	kfree(str);
+-	pr_err("zfcp: Parse error for device parameter string %s, "
+-	       "device not attached.\n", devstr);
++	pr_err("zfcp: %s is not a valid SCSI device\n", devstr);
+ 	return 0;
+ }
+ 
+-static struct zfcp_adapter *zfcp_get_adapter_by_busid(char *bus_id)
+-{
+-	struct zfcp_adapter *adapter;
+-
+-	list_for_each_entry(adapter, &zfcp_data.adapter_list_head, list)
+-		if ((strncmp(bus_id, adapter->ccw_device->dev.bus_id,
+-			     BUS_ID_SIZE) == 0) &&
+-		    !(atomic_read(&adapter->status) &
+-		      ZFCP_STATUS_COMMON_REMOVE))
+-		    return adapter;
+-	return NULL;
+-}
+-
+ static void __init zfcp_init_device_configure(void)
+ {
+ 	struct zfcp_adapter *adapter;
+@@ -141,7 +127,12 @@ static void __init zfcp_init_device_conf
+ 		goto out_unit;
+ 	up(&zfcp_data.config_sema);
+ 	ccw_device_set_online(adapter->ccw_device);
++
+ 	zfcp_erp_wait(adapter);
++	wait_event(adapter->erp_done_wqh,
++		   !(atomic_read(&unit->status) &
++				ZFCP_STATUS_UNIT_SCSI_WORK_PENDING));
++
+ 	down(&zfcp_data.config_sema);
+ 	zfcp_unit_put(unit);
+ out_unit:
+@@ -180,9 +171,9 @@ static int __init zfcp_module_init(void)
+ 	if (!zfcp_data.gid_pn_cache)
+ 		goto out_gid_cache;
+ 
+-	INIT_LIST_HEAD(&zfcp_data.adapter_list_head);
+-	INIT_LIST_HEAD(&zfcp_data.adapter_remove_lh);
++	zfcp_data.work_queue = create_singlethread_workqueue("zfcp_wq");
+ 
++	INIT_LIST_HEAD(&zfcp_data.adapter_list_head);
+ 	sema_init(&zfcp_data.config_sema, 1);
+ 	rwlock_init(&zfcp_data.config_lock);
+ 
+@@ -193,13 +184,14 @@ static int __init zfcp_module_init(void)
+ 
+ 	retval = misc_register(&zfcp_cfdc_misc);
+ 	if (retval) {
+-		pr_err("zfcp: registration of misc device zfcp_cfdc failed\n");
++		pr_err("zfcp: Registering the misc device zfcp_cfdc failed\n");
+ 		goto out_misc;
+ 	}
+ 
+ 	retval = zfcp_ccw_register();
+ 	if (retval) {
+-		pr_err("zfcp: Registration with common I/O layer failed.\n");
++		pr_err("zfcp: The zfcp device driver could not register with "
++		       "the common I/O layer\n");
+ 		goto out_ccw_register;
+ 	}
+ 
+@@ -232,7 +224,7 @@ module_init(zfcp_module_init);
+  * Returns: pointer to zfcp_unit or NULL
+  */
+ struct zfcp_unit *zfcp_get_unit_by_lun(struct zfcp_port *port,
+-				       fcp_lun_t fcp_lun)
++				       u64 fcp_lun)
+ {
+ 	struct zfcp_unit *unit;
+ 
+@@ -251,7 +243,7 @@ struct zfcp_unit *zfcp_get_unit_by_lun(s
+  * Returns: pointer to zfcp_port or NULL
+  */
+ struct zfcp_port *zfcp_get_port_by_wwpn(struct zfcp_adapter *adapter,
+-					wwn_t wwpn)
++					u64 wwpn)
+ {
+ 	struct zfcp_port *port;
+ 
+@@ -276,7 +268,7 @@ static void zfcp_sysfs_unit_release(stru
+  *
+  * Sets up some unit internal structures and creates sysfs entry.
+  */
+-struct zfcp_unit *zfcp_unit_enqueue(struct zfcp_port *port, fcp_lun_t fcp_lun)
++struct zfcp_unit *zfcp_unit_enqueue(struct zfcp_port *port, u64 fcp_lun)
+ {
+ 	struct zfcp_unit *unit;
+ 
+@@ -323,7 +315,6 @@ struct zfcp_unit *zfcp_unit_enqueue(stru
+ 	}
+ 
+ 	zfcp_unit_get(unit);
+-	unit->scsi_lun = scsilun_to_int((struct scsi_lun *)&unit->fcp_lun);
+ 
+ 	write_lock_irq(&zfcp_data.config_lock);
+ 	list_add_tail(&unit->list, &port->unit_list_head);
+@@ -332,7 +323,6 @@ struct zfcp_unit *zfcp_unit_enqueue(stru
+ 
+ 	write_unlock_irq(&zfcp_data.config_lock);
+ 
+-	port->units++;
+ 	zfcp_port_get(port);
+ 
+ 	return unit;
+@@ -351,11 +341,10 @@ err_out_free:
+  */
+ void zfcp_unit_dequeue(struct zfcp_unit *unit)
+ {
+-	zfcp_unit_wait(unit);
++	wait_event(unit->remove_wq, atomic_read(&unit->refcount) == 0);
+ 	write_lock_irq(&zfcp_data.config_lock);
+ 	list_del(&unit->list);
+ 	write_unlock_irq(&zfcp_data.config_lock);
+-	unit->port->units--;
+ 	zfcp_port_put(unit->port);
+ 	sysfs_remove_group(&unit->sysfs_device.kobj, &zfcp_sysfs_unit_attrs);
+ 	device_unregister(&unit->sysfs_device);
+@@ -416,11 +405,6 @@ static void zfcp_free_low_mem_buffers(st
+ 		mempool_destroy(adapter->pool.data_gid_pn);
+ }
+ 
+-static void zfcp_dummy_release(struct device *dev)
+-{
+-	return;
+-}
+-
+ /**
+  * zfcp_status_read_refill - refill the long running status_read_requests
+  * @adapter: ptr to struct zfcp_adapter for which the buffers should be refilled
+@@ -450,19 +434,6 @@ static void _zfcp_status_read_scheduler(
+ 					     stat_work));
+ }
+ 
+-static int zfcp_nameserver_enqueue(struct zfcp_adapter *adapter)
+-{
+-	struct zfcp_port *port;
+-
+-	port = zfcp_port_enqueue(adapter, 0, ZFCP_STATUS_PORT_WKA,
+-				 ZFCP_DID_DIRECTORY_SERVICE);
+-	if (IS_ERR(port))
+-		return PTR_ERR(port);
+-	zfcp_port_put(port);
+-
+-	return 0;
+-}
+-
+ /**
+  * zfcp_adapter_enqueue - enqueue a new adapter to the list
+  * @ccw_device: pointer to the struct cc_device
+@@ -508,7 +479,6 @@ int zfcp_adapter_enqueue(struct ccw_devi
+ 	init_waitqueue_head(&adapter->erp_done_wqh);
+ 
+ 	INIT_LIST_HEAD(&adapter->port_list_head);
+-	INIT_LIST_HEAD(&adapter->port_remove_lh);
+ 	INIT_LIST_HEAD(&adapter->erp_ready_head);
+ 	INIT_LIST_HEAD(&adapter->erp_running_head);
+ 
+@@ -518,7 +488,7 @@ int zfcp_adapter_enqueue(struct ccw_devi
+ 	spin_lock_init(&adapter->san_dbf_lock);
+ 	spin_lock_init(&adapter->scsi_dbf_lock);
+ 	spin_lock_init(&adapter->rec_dbf_lock);
+-	spin_lock_init(&adapter->req_q.lock);
++	spin_lock_init(&adapter->req_q_lock);
+ 
+ 	rwlock_init(&adapter->erp_lock);
+ 	rwlock_init(&adapter->abort_lock);
+@@ -537,28 +507,15 @@ int zfcp_adapter_enqueue(struct ccw_devi
+ 			       &zfcp_sysfs_adapter_attrs))
+ 		goto sysfs_failed;
+ 
+-	adapter->generic_services.parent = &adapter->ccw_device->dev;
+-	adapter->generic_services.release = zfcp_dummy_release;
+-	snprintf(adapter->generic_services.bus_id, BUS_ID_SIZE,
+-		 "generic_services");
+-
+-	if (device_register(&adapter->generic_services))
+-		goto generic_services_failed;
+-
+ 	write_lock_irq(&zfcp_data.config_lock);
+ 	atomic_clear_mask(ZFCP_STATUS_COMMON_REMOVE, &adapter->status);
+ 	list_add_tail(&adapter->list, &zfcp_data.adapter_list_head);
+ 	write_unlock_irq(&zfcp_data.config_lock);
+ 
+-	zfcp_data.adapters++;
+-
+-	zfcp_nameserver_enqueue(adapter);
++	zfcp_fc_nameserver_init(adapter);
+ 
+ 	return 0;
+ 
+-generic_services_failed:
+-	sysfs_remove_group(&ccw_device->dev.kobj,
+-			   &zfcp_sysfs_adapter_attrs);
+ sysfs_failed:
+ 	zfcp_adapter_debug_unregister(adapter);
+ debug_register_failed:
+@@ -585,7 +542,6 @@ void zfcp_adapter_dequeue(struct zfcp_ad
+ 	cancel_work_sync(&adapter->scan_work);
+ 	cancel_work_sync(&adapter->stat_work);
+ 	zfcp_adapter_scsi_unregister(adapter);
+-	device_unregister(&adapter->generic_services);
+ 	sysfs_remove_group(&adapter->ccw_device->dev.kobj,
+ 			   &zfcp_sysfs_adapter_attrs);
+ 	dev_set_drvdata(&adapter->ccw_device->dev, NULL);
+@@ -603,9 +559,6 @@ void zfcp_adapter_dequeue(struct zfcp_ad
+ 	list_del(&adapter->list);
+ 	write_unlock_irq(&zfcp_data.config_lock);
+ 
+-	/* decrease number of adapters in list */
+-	zfcp_data.adapters--;
+-
+ 	zfcp_qdio_free(adapter);
+ 
+ 	zfcp_free_low_mem_buffers(adapter);
+@@ -633,21 +586,19 @@ static void zfcp_sysfs_port_release(stru
+  * d_id is used to enqueue ports with a well known address like the Directory
+  * Service for nameserver lookup.
+  */
+-struct zfcp_port *zfcp_port_enqueue(struct zfcp_adapter *adapter, wwn_t wwpn,
++struct zfcp_port *zfcp_port_enqueue(struct zfcp_adapter *adapter, u64 wwpn,
+ 				     u32 status, u32 d_id)
+ {
+ 	struct zfcp_port *port;
+ 	int retval;
+-	char *bus_id;
+ 
+ 	port = kzalloc(sizeof(struct zfcp_port), GFP_KERNEL);
+ 	if (!port)
+ 		return ERR_PTR(-ENOMEM);
+ 
+ 	init_waitqueue_head(&port->remove_wq);
+-
+ 	INIT_LIST_HEAD(&port->unit_list_head);
+-	INIT_LIST_HEAD(&port->unit_remove_lh);
++	INIT_WORK(&port->gid_pn_work, zfcp_erp_port_strategy_open_lookup);
+ 
+ 	port->adapter = adapter;
+ 	port->d_id = d_id;
+@@ -657,34 +608,8 @@ struct zfcp_port *zfcp_port_enqueue(stru
+ 	atomic_set_mask(status | ZFCP_STATUS_COMMON_REMOVE, &port->status);
+ 	atomic_set(&port->refcount, 0);
+ 
+-	if (status & ZFCP_STATUS_PORT_WKA) {
+-		switch (d_id) {
+-		case ZFCP_DID_DIRECTORY_SERVICE:
+-			bus_id = "directory";
+-			break;
+-		case ZFCP_DID_MANAGEMENT_SERVICE:
+-			bus_id = "management";
+-			break;
+-		case ZFCP_DID_KEY_DISTRIBUTION_SERVICE:
+-			bus_id = "key_distribution";
+-			break;
+-		case ZFCP_DID_ALIAS_SERVICE:
+-			bus_id = "alias";
+-			break;
+-		case ZFCP_DID_TIME_SERVICE:
+-			bus_id = "time";
+-			break;
+-		default:
+-			kfree(port);
+-			return ERR_PTR(-EINVAL);
+-		}
+-		snprintf(port->sysfs_device.bus_id, BUS_ID_SIZE, "%s", bus_id);
+-		port->sysfs_device.parent = &adapter->generic_services;
+-	} else {
+-		snprintf(port->sysfs_device.bus_id,
+-			 BUS_ID_SIZE, "0x%016llx", wwpn);
+-		port->sysfs_device.parent = &adapter->ccw_device->dev;
+-	}
++	snprintf(port->sysfs_device.bus_id, BUS_ID_SIZE, "0x%016llx", wwpn);
++	port->sysfs_device.parent = &adapter->ccw_device->dev;
+ 
+ 	port->sysfs_device.release = zfcp_sysfs_port_release;
+ 	dev_set_drvdata(&port->sysfs_device, port);
+@@ -700,12 +625,8 @@ struct zfcp_port *zfcp_port_enqueue(stru
+ 	if (device_register(&port->sysfs_device))
+ 		goto err_out_free;
+ 
+-	if (status & ZFCP_STATUS_PORT_WKA)
+-		retval = sysfs_create_group(&port->sysfs_device.kobj,
+-					    &zfcp_sysfs_ns_port_attrs);
+-	else
+-		retval = sysfs_create_group(&port->sysfs_device.kobj,
+-					    &zfcp_sysfs_port_attrs);
++	retval = sysfs_create_group(&port->sysfs_device.kobj,
++				    &zfcp_sysfs_port_attrs);
+ 
+ 	if (retval) {
+ 		device_unregister(&port->sysfs_device);
+@@ -718,10 +639,6 @@ struct zfcp_port *zfcp_port_enqueue(stru
+ 	list_add_tail(&port->list, &adapter->port_list_head);
+ 	atomic_clear_mask(ZFCP_STATUS_COMMON_REMOVE, &port->status);
+ 	atomic_set_mask(ZFCP_STATUS_COMMON_RUNNING, &port->status);
+-	if (d_id == ZFCP_DID_DIRECTORY_SERVICE)
+-		if (!adapter->nameserver_port)
+-			adapter->nameserver_port = port;
+-	adapter->ports++;
+ 
+ 	write_unlock_irq(&zfcp_data.config_lock);
+ 
+@@ -740,21 +657,15 @@ err_out:
+  */
+ void zfcp_port_dequeue(struct zfcp_port *port)
+ {
+-	zfcp_port_wait(port);
++	wait_event(port->remove_wq, atomic_read(&port->refcount) == 0);
+ 	write_lock_irq(&zfcp_data.config_lock);
+ 	list_del(&port->list);
+-	port->adapter->ports--;
+ 	write_unlock_irq(&zfcp_data.config_lock);
+ 	if (port->rport)
+ 		fc_remote_port_delete(port->rport);
+ 	port->rport = NULL;
+ 	zfcp_adapter_put(port->adapter);
+-	if (atomic_read(&port->status) & ZFCP_STATUS_PORT_WKA)
+-		sysfs_remove_group(&port->sysfs_device.kobj,
+-				   &zfcp_sysfs_ns_port_attrs);
+-	else
+-		sysfs_remove_group(&port->sysfs_device.kobj,
+-				   &zfcp_sysfs_port_attrs);
++	sysfs_remove_group(&port->sysfs_device.kobj, &zfcp_sysfs_port_attrs);
+ 	device_unregister(&port->sysfs_device);
+ }
+ 
+Index: linux-2.6.27-gentoo-r7/drivers/s390/scsi/zfcp_ccw.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/scsi/zfcp_ccw.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/scsi/zfcp_ccw.c
+@@ -25,7 +25,8 @@ static int zfcp_ccw_probe(struct ccw_dev
+ 	down(&zfcp_data.config_sema);
+ 	if (zfcp_adapter_enqueue(ccw_device)) {
+ 		dev_err(&ccw_device->dev,
+-			"Setup of data structures failed.\n");
++			"Setting up data structures for the "
++			"FCP adapter failed\n");
+ 		retval = -EINVAL;
+ 	}
+ 	up(&zfcp_data.config_sema);
+@@ -46,6 +47,8 @@ static void zfcp_ccw_remove(struct ccw_d
+ 	struct zfcp_adapter *adapter;
+ 	struct zfcp_port *port, *p;
+ 	struct zfcp_unit *unit, *u;
++	LIST_HEAD(unit_remove_lh);
++	LIST_HEAD(port_remove_lh);
+ 
+ 	ccw_device_set_offline(ccw_device);
+ 	down(&zfcp_data.config_sema);
+@@ -54,26 +57,26 @@ static void zfcp_ccw_remove(struct ccw_d
+ 	write_lock_irq(&zfcp_data.config_lock);
+ 	list_for_each_entry_safe(port, p, &adapter->port_list_head, list) {
+ 		list_for_each_entry_safe(unit, u, &port->unit_list_head, list) {
+-			list_move(&unit->list, &port->unit_remove_lh);
++			list_move(&unit->list, &unit_remove_lh);
+ 			atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE,
+ 					&unit->status);
+ 		}
+-		list_move(&port->list, &adapter->port_remove_lh);
++		list_move(&port->list, &port_remove_lh);
+ 		atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &port->status);
+ 	}
+ 	atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &adapter->status);
+ 	write_unlock_irq(&zfcp_data.config_lock);
+ 
+-	list_for_each_entry_safe(port, p, &adapter->port_remove_lh, list) {
+-		list_for_each_entry_safe(unit, u, &port->unit_remove_lh, list) {
+-			if (atomic_test_mask(ZFCP_STATUS_UNIT_REGISTERED,
+-				&unit->status))
++	list_for_each_entry_safe(port, p, &port_remove_lh, list) {
++		list_for_each_entry_safe(unit, u, &unit_remove_lh, list) {
++			if (atomic_read(&unit->status) &
++			    ZFCP_STATUS_UNIT_REGISTERED)
+ 				scsi_remove_device(unit->device);
+ 			zfcp_unit_dequeue(unit);
+ 		}
+ 		zfcp_port_dequeue(port);
+ 	}
+-	zfcp_adapter_wait(adapter);
++	wait_event(adapter->remove_wq, atomic_read(&adapter->refcount) == 0);
+ 	zfcp_adapter_dequeue(adapter);
+ 
+ 	up(&zfcp_data.config_sema);
+@@ -113,7 +116,9 @@ static int zfcp_ccw_set_online(struct cc
+ 	zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED, 85,
+ 				NULL);
+ 	zfcp_erp_wait(adapter);
+-	goto out;
++	up(&zfcp_data.config_sema);
++	flush_work(&adapter->scan_work);
++	return 0;
+ 
+  out_scsi_register:
+ 	zfcp_erp_thread_kill(adapter);
+@@ -156,15 +161,18 @@ static int zfcp_ccw_notify(struct ccw_de
+ 
+ 	switch (event) {
+ 	case CIO_GONE:
+-		dev_warn(&adapter->ccw_device->dev, "device gone\n");
++		dev_warn(&adapter->ccw_device->dev,
++			 "The FCP device has been detached\n");
+ 		zfcp_erp_adapter_shutdown(adapter, 0, 87, NULL);
+ 		break;
+ 	case CIO_NO_PATH:
+-		dev_warn(&adapter->ccw_device->dev, "no path\n");
++		dev_warn(&adapter->ccw_device->dev,
++			 "The CHPID for the FCP device is offline\n");
+ 		zfcp_erp_adapter_shutdown(adapter, 0, 88, NULL);
+ 		break;
+ 	case CIO_OPER:
+-		dev_info(&adapter->ccw_device->dev, "operational again\n");
++		dev_info(&adapter->ccw_device->dev,
++			 "The FCP device is operational again\n");
+ 		zfcp_erp_modify_adapter_status(adapter, 11, NULL,
+ 					       ZFCP_STATUS_COMMON_RUNNING,
+ 					       ZFCP_SET);
+@@ -220,3 +228,20 @@ int __init zfcp_ccw_register(void)
+ {
+ 	return ccw_driver_register(&zfcp_ccw_driver);
+ }
++
++/**
++ * zfcp_get_adapter_by_busid - find zfcp_adapter struct
++ * @busid: bus id string of zfcp adapter to find
++ */
++struct zfcp_adapter *zfcp_get_adapter_by_busid(char *busid)
++{
++	struct ccw_device *ccw_device;
++	struct zfcp_adapter *adapter = NULL;
++
++	ccw_device = get_ccwdev_by_busid(&zfcp_ccw_driver, busid);
++	if (ccw_device) {
++		adapter = dev_get_drvdata(&ccw_device->dev);
++		put_device(&ccw_device->dev);
++	}
++	return adapter;
++}
+Index: linux-2.6.27-gentoo-r7/drivers/s390/scsi/zfcp_dbf.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/scsi/zfcp_dbf.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/scsi/zfcp_dbf.c
+@@ -30,7 +30,7 @@ static void zfcp_dbf_hexdump(debug_info_
+ 		dump->offset = offset;
+ 		dump->size = min(from_len - offset, room);
+ 		memcpy(dump->data, from + offset, dump->size);
+-		debug_event(dbf, level, dump, dump->size);
++		debug_event(dbf, level, dump, dump->size + sizeof(*dump));
+ 	}
+ }
+ 
+@@ -108,7 +108,7 @@ static int zfcp_dbf_view_header(debug_in
+ 			     t.tv_sec, t.tv_nsec);
+ 		zfcp_dbf_out(&p, "cpu", "%02i", entry->id.fields.cpuid);
+ 	} else	{
+-		zfcp_dbf_outd(&p, NULL, dump->data, dump->size, dump->offset,
++		zfcp_dbf_outd(&p, "", dump->data, dump->size, dump->offset,
+ 			      dump->total_size);
+ 		if ((dump->offset + dump->size) == dump->total_size)
+ 			p += sprintf(p, "\n");
+@@ -318,6 +318,26 @@ void zfcp_hba_dbf_event_qdio(struct zfcp
+ 	spin_unlock_irqrestore(&adapter->hba_dbf_lock, flags);
+ }
+ 
++/**
++ * zfcp_hba_dbf_event_berr - trace event for bit error threshold
++ * @adapter: adapter affected by this QDIO related event
++ * @req: fsf request
++ */
++void zfcp_hba_dbf_event_berr(struct zfcp_adapter *adapter,
++			     struct zfcp_fsf_req *req)
++{
++	struct zfcp_hba_dbf_record *r = &adapter->hba_dbf_buf;
++	struct fsf_status_read_buffer *sr_buf = req->data;
++	struct fsf_bit_error_payload *err = &sr_buf->payload.bit_error;
++	unsigned long flags;
++
++	spin_lock_irqsave(&adapter->hba_dbf_lock, flags);
++	memset(r, 0, sizeof(*r));
++	strncpy(r->tag, "berr", ZFCP_DBF_TAG_SIZE);
++	memcpy(&r->u.berr, err, sizeof(struct fsf_bit_error_payload));
++	debug_event(adapter->hba_dbf, 0, r, sizeof(*r));
++	spin_unlock_irqrestore(&adapter->hba_dbf_lock, flags);
++}
+ static void zfcp_hba_dbf_view_response(char **p,
+ 				       struct zfcp_hba_dbf_record_response *r)
+ {
+@@ -346,6 +366,7 @@ static void zfcp_hba_dbf_view_response(c
+ 			break;
+ 		zfcp_dbf_out(p, "scsi_cmnd", "0x%0Lx", r->u.fcp.cmnd);
+ 		zfcp_dbf_out(p, "scsi_serial", "0x%016Lx", r->u.fcp.serial);
++		p += sprintf(*p, "\n");
+ 		break;
+ 
+ 	case FSF_QTCB_OPEN_PORT_WITH_DID:
+@@ -399,6 +420,30 @@ static void zfcp_hba_dbf_view_qdio(char 
+ 	zfcp_dbf_out(p, "sbal_count", "0x%02x", r->sbal_count);
+ }
+ 
++static void zfcp_hba_dbf_view_berr(char **p, struct fsf_bit_error_payload *r)
++{
++	zfcp_dbf_out(p, "link_failures", "%d", r->link_failure_error_count);
++	zfcp_dbf_out(p, "loss_of_sync_err", "%d", r->loss_of_sync_error_count);
++	zfcp_dbf_out(p, "loss_of_sig_err", "%d", r->loss_of_signal_error_count);
++	zfcp_dbf_out(p, "prim_seq_err", "%d",
++		     r->primitive_sequence_error_count);
++	zfcp_dbf_out(p, "inval_trans_word_err", "%d",
++		     r->invalid_transmission_word_error_count);
++	zfcp_dbf_out(p, "CRC_errors", "%d", r->crc_error_count);
++	zfcp_dbf_out(p, "prim_seq_event_to", "%d",
++		     r->primitive_sequence_event_timeout_count);
++	zfcp_dbf_out(p, "elast_buf_overrun_err", "%d",
++		     r->elastic_buffer_overrun_error_count);
++	zfcp_dbf_out(p, "adv_rec_buf2buf_cred", "%d",
++		     r->advertised_receive_b2b_credit);
++	zfcp_dbf_out(p, "curr_rec_buf2buf_cred", "%d",
++		     r->current_receive_b2b_credit);
++	zfcp_dbf_out(p, "adv_trans_buf2buf_cred", "%d",
++		     r->advertised_transmit_b2b_credit);
++	zfcp_dbf_out(p, "curr_trans_buf2buf_cred", "%d",
++		     r->current_transmit_b2b_credit);
++}
++
+ static int zfcp_hba_dbf_view_format(debug_info_t *id, struct debug_view *view,
+ 				    char *out_buf, const char *in_buf)
+ {
+@@ -418,8 +463,11 @@ static int zfcp_hba_dbf_view_format(debu
+ 		zfcp_hba_dbf_view_status(&p, &r->u.status);
+ 	else if (strncmp(r->tag, "qdio", ZFCP_DBF_TAG_SIZE) == 0)
+ 		zfcp_hba_dbf_view_qdio(&p, &r->u.qdio);
++	else if (strncmp(r->tag, "berr", ZFCP_DBF_TAG_SIZE) == 0)
++		zfcp_hba_dbf_view_berr(&p, &r->u.berr);
+ 
+-	p += sprintf(p, "\n");
++	if (strncmp(r->tag, "resp", ZFCP_DBF_TAG_SIZE) != 0)
++		p += sprintf(p, "\n");
+ 	return p - out_buf;
+ }
+ 
+@@ -519,14 +567,14 @@ static const char *zfcp_rec_dbf_ids[] = 
+ 	[75]	= "physical port recovery escalation after failed port "
+ 		  "recovery",
+ 	[76]	= "port recovery escalation after failed unit recovery",
+-	[77]	= "recovery opening nameserver port",
++	[77]	= "",
+ 	[78]	= "duplicate request id",
+ 	[79]	= "link down",
+ 	[80]	= "exclusive read-only unit access unsupported",
+ 	[81]	= "shared read-write unit access unsupported",
+ 	[82]	= "incoming rscn",
+ 	[83]	= "incoming wwpn",
+-	[84]	= "",
++	[84]	= "wka port handle not valid close port",
+ 	[85]	= "online",
+ 	[86]	= "offline",
+ 	[87]	= "ccw device gone",
+@@ -570,7 +618,7 @@ static const char *zfcp_rec_dbf_ids[] = 
+ 	[125]	= "need newer zfcp",
+ 	[126]	= "need newer microcode",
+ 	[127]	= "arbitrated loop not supported",
+-	[128]	= "unknown topology",
++	[128]	= "",
+ 	[129]	= "qtcb size mismatch",
+ 	[130]	= "unknown fsf status ecd",
+ 	[131]	= "fcp request too big",
+@@ -829,11 +877,12 @@ void zfcp_rec_dbf_event_action(u8 id2, s
+ void zfcp_san_dbf_event_ct_request(struct zfcp_fsf_req *fsf_req)
+ {
+ 	struct zfcp_send_ct *ct = (struct zfcp_send_ct *)fsf_req->data;
+-	struct zfcp_port *port = ct->port;
+-	struct zfcp_adapter *adapter = port->adapter;
+-	struct ct_hdr *hdr = zfcp_sg_to_address(ct->req);
++	struct zfcp_wka_port *wka_port = ct->wka_port;
++	struct zfcp_adapter *adapter = wka_port->adapter;
++	struct ct_hdr *hdr = sg_virt(ct->req);
+ 	struct zfcp_san_dbf_record *r = &adapter->san_dbf_buf;
+ 	struct zfcp_san_dbf_record_ct_request *oct = &r->u.ct_req;
++	int level = 3;
+ 	unsigned long flags;
+ 
+ 	spin_lock_irqsave(&adapter->san_dbf_lock, flags);
+@@ -842,7 +891,7 @@ void zfcp_san_dbf_event_ct_request(struc
+ 	r->fsf_reqid = (unsigned long)fsf_req;
+ 	r->fsf_seqno = fsf_req->seq_no;
+ 	r->s_id = fc_host_port_id(adapter->scsi_host);
+-	r->d_id = port->d_id;
++	r->d_id = wka_port->d_id;
+ 	oct->cmd_req_code = hdr->cmd_rsp_code;
+ 	oct->revision = hdr->revision;
+ 	oct->gs_type = hdr->gs_type;
+@@ -850,9 +899,10 @@ void zfcp_san_dbf_event_ct_request(struc
+ 	oct->options = hdr->options;
+ 	oct->max_res_size = hdr->max_res_size;
+ 	oct->len = min((int)ct->req->length - (int)sizeof(struct ct_hdr),
+-		       ZFCP_DBF_CT_PAYLOAD);
+-	memcpy(oct->payload, (void *)hdr + sizeof(struct ct_hdr), oct->len);
+-	debug_event(adapter->san_dbf, 3, r, sizeof(*r));
++		       ZFCP_DBF_SAN_MAX_PAYLOAD);
++	debug_event(adapter->san_dbf, level, r, sizeof(*r));
++	zfcp_dbf_hexdump(adapter->san_dbf, r, sizeof(*r), level,
++			 (void *)hdr + sizeof(struct ct_hdr), oct->len);
+ 	spin_unlock_irqrestore(&adapter->san_dbf_lock, flags);
+ }
+ 
+@@ -863,11 +913,12 @@ void zfcp_san_dbf_event_ct_request(struc
+ void zfcp_san_dbf_event_ct_response(struct zfcp_fsf_req *fsf_req)
+ {
+ 	struct zfcp_send_ct *ct = (struct zfcp_send_ct *)fsf_req->data;
+-	struct zfcp_port *port = ct->port;
+-	struct zfcp_adapter *adapter = port->adapter;
+-	struct ct_hdr *hdr = zfcp_sg_to_address(ct->resp);
++	struct zfcp_wka_port *wka_port = ct->wka_port;
++	struct zfcp_adapter *adapter = wka_port->adapter;
++	struct ct_hdr *hdr = sg_virt(ct->resp);
+ 	struct zfcp_san_dbf_record *r = &adapter->san_dbf_buf;
+ 	struct zfcp_san_dbf_record_ct_response *rct = &r->u.ct_resp;
++	int level = 3;
+ 	unsigned long flags;
+ 
+ 	spin_lock_irqsave(&adapter->san_dbf_lock, flags);
+@@ -875,7 +926,7 @@ void zfcp_san_dbf_event_ct_response(stru
+ 	strncpy(r->tag, "rctc", ZFCP_DBF_TAG_SIZE);
+ 	r->fsf_reqid = (unsigned long)fsf_req;
+ 	r->fsf_seqno = fsf_req->seq_no;
+-	r->s_id = port->d_id;
++	r->s_id = wka_port->d_id;
+ 	r->d_id = fc_host_port_id(adapter->scsi_host);
+ 	rct->cmd_rsp_code = hdr->cmd_rsp_code;
+ 	rct->revision = hdr->revision;
+@@ -883,9 +934,10 @@ void zfcp_san_dbf_event_ct_response(stru
+ 	rct->expl = hdr->reason_code_expl;
+ 	rct->vendor_unique = hdr->vendor_unique;
+ 	rct->len = min((int)ct->resp->length - (int)sizeof(struct ct_hdr),
+-		       ZFCP_DBF_CT_PAYLOAD);
+-	memcpy(rct->payload, (void *)hdr + sizeof(struct ct_hdr), rct->len);
+-	debug_event(adapter->san_dbf, 3, r, sizeof(*r));
++		       ZFCP_DBF_SAN_MAX_PAYLOAD);
++	debug_event(adapter->san_dbf, level, r, sizeof(*r));
++	zfcp_dbf_hexdump(adapter->san_dbf, r, sizeof(*r), level,
++			 (void *)hdr + sizeof(struct ct_hdr), rct->len);
+ 	spin_unlock_irqrestore(&adapter->san_dbf_lock, flags);
+ }
+ 
+@@ -908,7 +960,7 @@ static void zfcp_san_dbf_event_els(const
+ 	rec->u.els.ls_code = ls_code;
+ 	debug_event(adapter->san_dbf, level, rec, sizeof(*rec));
+ 	zfcp_dbf_hexdump(adapter->san_dbf, rec, sizeof(*rec), level,
+-			 buffer, min(buflen, ZFCP_DBF_ELS_MAX_PAYLOAD));
++			 buffer, min(buflen, ZFCP_DBF_SAN_MAX_PAYLOAD));
+ 	spin_unlock_irqrestore(&adapter->san_dbf_lock, flags);
+ }
+ 
+@@ -922,8 +974,8 @@ void zfcp_san_dbf_event_els_request(stru
+ 
+ 	zfcp_san_dbf_event_els("oels", 2, fsf_req,
+ 			       fc_host_port_id(els->adapter->scsi_host),
+-			       els->d_id, *(u8 *) zfcp_sg_to_address(els->req),
+-			       zfcp_sg_to_address(els->req), els->req->length);
++			       els->d_id, *(u8 *) sg_virt(els->req),
++			       sg_virt(els->req), els->req->length);
+ }
+ 
+ /**
+@@ -936,8 +988,7 @@ void zfcp_san_dbf_event_els_response(str
+ 
+ 	zfcp_san_dbf_event_els("rels", 2, fsf_req, els->d_id,
+ 			       fc_host_port_id(els->adapter->scsi_host),
+-			       *(u8 *)zfcp_sg_to_address(els->req),
+-			       zfcp_sg_to_address(els->resp),
++			       *(u8 *)sg_virt(els->req), sg_virt(els->resp),
+ 			       els->resp->length);
+ }
+ 
+@@ -963,8 +1014,6 @@ static int zfcp_san_dbf_view_format(debu
+ 				    char *out_buf, const char *in_buf)
+ {
+ 	struct zfcp_san_dbf_record *r = (struct zfcp_san_dbf_record *)in_buf;
+-	char *buffer = NULL;
+-	int buflen = 0, total = 0;
+ 	char *p = out_buf;
+ 
+ 	if (strncmp(r->tag, "dump", ZFCP_DBF_TAG_SIZE) == 0)
+@@ -984,9 +1033,6 @@ static int zfcp_san_dbf_view_format(debu
+ 		zfcp_dbf_out(&p, "gs_subtype", "0x%02x", ct->gs_subtype);
+ 		zfcp_dbf_out(&p, "options", "0x%02x", ct->options);
+ 		zfcp_dbf_out(&p, "max_res_size", "0x%04x", ct->max_res_size);
+-		total = ct->len;
+-		buffer = ct->payload;
+-		buflen = min(total, ZFCP_DBF_CT_PAYLOAD);
+ 	} else if (strncmp(r->tag, "rctc", ZFCP_DBF_TAG_SIZE) == 0) {
+ 		struct zfcp_san_dbf_record_ct_response *ct = &r->u.ct_resp;
+ 		zfcp_dbf_out(&p, "cmd_rsp_code", "0x%04x", ct->cmd_rsp_code);
+@@ -994,23 +1040,12 @@ static int zfcp_san_dbf_view_format(debu
+ 		zfcp_dbf_out(&p, "reason_code", "0x%02x", ct->reason_code);
+ 		zfcp_dbf_out(&p, "reason_code_expl", "0x%02x", ct->expl);
+ 		zfcp_dbf_out(&p, "vendor_unique", "0x%02x", ct->vendor_unique);
+-		total = ct->len;
+-		buffer = ct->payload;
+-		buflen = min(total, ZFCP_DBF_CT_PAYLOAD);
+ 	} else if (strncmp(r->tag, "oels", ZFCP_DBF_TAG_SIZE) == 0 ||
+ 		   strncmp(r->tag, "rels", ZFCP_DBF_TAG_SIZE) == 0 ||
+ 		   strncmp(r->tag, "iels", ZFCP_DBF_TAG_SIZE) == 0) {
+ 		struct zfcp_san_dbf_record_els *els = &r->u.els;
+ 		zfcp_dbf_out(&p, "ls_code", "0x%02x", els->ls_code);
+-		total = els->len;
+-		buffer = els->payload;
+-		buflen = min(total, ZFCP_DBF_ELS_PAYLOAD);
+ 	}
+-
+-	zfcp_dbf_outd(&p, "payload", buffer, buflen, 0, total);
+-	if (buflen == total)
+-		p += sprintf(p, "\n");
+-
+ 	return p - out_buf;
+ }
+ 
+Index: linux-2.6.27-gentoo-r7/drivers/s390/scsi/zfcp_dbf.h
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/scsi/zfcp_dbf.h
++++ linux-2.6.27-gentoo-r7/drivers/s390/scsi/zfcp_dbf.h
+@@ -151,6 +151,7 @@ struct zfcp_hba_dbf_record {
+ 		struct zfcp_hba_dbf_record_response response;
+ 		struct zfcp_hba_dbf_record_status status;
+ 		struct zfcp_hba_dbf_record_qdio qdio;
++		struct fsf_bit_error_payload berr;
+ 	} u;
+ } __attribute__ ((packed));
+ 
+@@ -162,8 +163,6 @@ struct zfcp_san_dbf_record_ct_request {
+ 	u8 options;
+ 	u16 max_res_size;
+ 	u32 len;
+-#define ZFCP_DBF_CT_PAYLOAD	24
+-	u8 payload[ZFCP_DBF_CT_PAYLOAD];
+ } __attribute__ ((packed));
+ 
+ struct zfcp_san_dbf_record_ct_response {
+@@ -173,15 +172,11 @@ struct zfcp_san_dbf_record_ct_response {
+ 	u8 expl;
+ 	u8 vendor_unique;
+ 	u32 len;
+-	u8 payload[ZFCP_DBF_CT_PAYLOAD];
+ } __attribute__ ((packed));
+ 
+ struct zfcp_san_dbf_record_els {
+ 	u8 ls_code;
+ 	u32 len;
+-#define ZFCP_DBF_ELS_PAYLOAD	32
+-#define ZFCP_DBF_ELS_MAX_PAYLOAD 1024
+-	u8 payload[ZFCP_DBF_ELS_PAYLOAD];
+ } __attribute__ ((packed));
+ 
+ struct zfcp_san_dbf_record {
+@@ -195,6 +190,8 @@ struct zfcp_san_dbf_record {
+ 		struct zfcp_san_dbf_record_ct_response ct_resp;
+ 		struct zfcp_san_dbf_record_els els;
+ 	} u;
++#define ZFCP_DBF_SAN_MAX_PAYLOAD 1024
++	u8 payload[32];
+ } __attribute__ ((packed));
+ 
+ struct zfcp_scsi_dbf_record {
+Index: linux-2.6.27-gentoo-r7/drivers/s390/scsi/zfcp_def.h
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/scsi/zfcp_def.h
++++ linux-2.6.27-gentoo-r7/drivers/s390/scsi/zfcp_def.h
+@@ -39,29 +39,6 @@
+ 
+ /********************* GENERAL DEFINES *********************************/
+ 
+-/**
+- * zfcp_sg_to_address - determine kernel address from struct scatterlist
+- * @list: struct scatterlist
+- * Return: kernel address
+- */
+-static inline void *
+-zfcp_sg_to_address(struct scatterlist *list)
+-{
+-	return sg_virt(list);
+-}
+-
+-/**
+- * zfcp_address_to_sg - set up struct scatterlist from kernel address
+- * @address: kernel address
+- * @list: struct scatterlist
+- * @size: buffer size
+- */
+-static inline void
+-zfcp_address_to_sg(void *address, struct scatterlist *list, unsigned int size)
+-{
+-	sg_set_buf(list, address, size);
+-}
+-
+ #define REQUEST_LIST_SIZE 128
+ 
+ /********************* SCSI SPECIFIC DEFINES *********************************/
+@@ -101,11 +78,6 @@ zfcp_address_to_sg(void *address, struct
+ 
+ /*************** FIBRE CHANNEL PROTOCOL SPECIFIC DEFINES ********************/
+ 
+-typedef unsigned long long wwn_t;
+-typedef unsigned long long fcp_lun_t;
+-/* data length field may be at variable position in FCP-2 FCP_CMND IU */
+-typedef unsigned int       fcp_dl_t;
+-
+ /* timeout for name-server lookup (in seconds) */
+ #define ZFCP_NS_GID_PN_TIMEOUT		10
+ 
+@@ -129,7 +101,7 @@ typedef unsigned int       fcp_dl_t;
+ 
+ /* FCP(-2) FCP_CMND IU */
+ struct fcp_cmnd_iu {
+-	fcp_lun_t fcp_lun;	   /* FCP logical unit number */
++	u64 fcp_lun;	   /* FCP logical unit number */
+ 	u8  crn;	           /* command reference number */
+ 	u8  reserved0:5;	   /* reserved */
+ 	u8  task_attribute:3;	   /* task attribute */
+@@ -204,7 +176,7 @@ struct fcp_rscn_element {
+ struct fcp_logo {
+         u32 command;
+         u32 nport_did;
+-        wwn_t nport_wwpn;
++	u64 nport_wwpn;
+ } __attribute__((packed));
+ 
+ /*
+@@ -218,13 +190,6 @@ struct fcp_logo {
+ #define ZFCP_LS_RSCN			0x61
+ #define ZFCP_LS_RNID			0x78
+ 
+-struct zfcp_ls_rjt_par {
+-	u8 action;
+- 	u8 reason_code;
+- 	u8 reason_expl;
+- 	u8 vendor_unique;
+-} __attribute__ ((packed));
+-
+ struct zfcp_ls_adisc {
+ 	u8		code;
+ 	u8		field[3];
+@@ -234,20 +199,6 @@ struct zfcp_ls_adisc {
+ 	u32		nport_id;
+ } __attribute__ ((packed));
+ 
+-struct zfcp_ls_adisc_acc {
+-	u8		code;
+-	u8		field[3];
+-	u32		hard_nport_id;
+-	u64		wwpn;
+-	u64		wwnn;
+-	u32		nport_id;
+-} __attribute__ ((packed));
+-
+-struct zfcp_rc_entry {
+-	u8 code;
+-	const char *description;
+-};
+-
+ /*
+  * FC-GS-2 stuff
+  */
+@@ -281,9 +232,7 @@ struct zfcp_rc_entry {
+ #define ZFCP_STATUS_COMMON_RUNNING		0x40000000
+ #define ZFCP_STATUS_COMMON_ERP_FAILED		0x20000000
+ #define ZFCP_STATUS_COMMON_UNBLOCKED		0x10000000
+-#define ZFCP_STATUS_COMMON_OPENING              0x08000000
+ #define ZFCP_STATUS_COMMON_OPEN                 0x04000000
+-#define ZFCP_STATUS_COMMON_CLOSING              0x02000000
+ #define ZFCP_STATUS_COMMON_ERP_INUSE		0x01000000
+ #define ZFCP_STATUS_COMMON_ACCESS_DENIED	0x00800000
+ #define ZFCP_STATUS_COMMON_ACCESS_BOXED		0x00400000
+@@ -291,16 +240,15 @@ struct zfcp_rc_entry {
+ 
+ /* adapter status */
+ #define ZFCP_STATUS_ADAPTER_QDIOUP		0x00000002
+-#define ZFCP_STATUS_ADAPTER_REGISTERED		0x00000004
+ #define ZFCP_STATUS_ADAPTER_XCONFIG_OK		0x00000008
+ #define ZFCP_STATUS_ADAPTER_HOST_CON_INIT	0x00000010
+ #define ZFCP_STATUS_ADAPTER_ERP_THREAD_UP	0x00000020
+ #define ZFCP_STATUS_ADAPTER_ERP_THREAD_KILL	0x00000080
+ #define ZFCP_STATUS_ADAPTER_ERP_PENDING		0x00000100
+ #define ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED	0x00000200
+-#define ZFCP_STATUS_ADAPTER_XPORT_OK		0x00000800
+ 
+ /* FC-PH/FC-GS well-known address identifiers for generic services */
++#define ZFCP_DID_WKA				0xFFFFF0
+ #define ZFCP_DID_MANAGEMENT_SERVICE		0xFFFFFA
+ #define ZFCP_DID_TIME_SERVICE			0xFFFFFB
+ #define ZFCP_DID_DIRECTORY_SERVICE		0xFFFFFC
+@@ -312,29 +260,27 @@ struct zfcp_rc_entry {
+ #define ZFCP_STATUS_PORT_DID_DID		0x00000002
+ #define ZFCP_STATUS_PORT_PHYS_CLOSING		0x00000004
+ #define ZFCP_STATUS_PORT_NO_WWPN		0x00000008
+-#define ZFCP_STATUS_PORT_NO_SCSI_ID		0x00000010
+ #define ZFCP_STATUS_PORT_INVALID_WWPN		0x00000020
+ 
+-/* for ports with well known addresses */
+-#define ZFCP_STATUS_PORT_WKA \
+-		(ZFCP_STATUS_PORT_NO_WWPN | \
+-		 ZFCP_STATUS_PORT_NO_SCSI_ID)
++/* well known address (WKA) port status*/
++enum zfcp_wka_status {
++	ZFCP_WKA_PORT_OFFLINE,
++	ZFCP_WKA_PORT_CLOSING,
++	ZFCP_WKA_PORT_OPENING,
++	ZFCP_WKA_PORT_ONLINE,
++};
+ 
+ /* logical unit status */
+-#define ZFCP_STATUS_UNIT_TEMPORARY		0x00000002
+ #define ZFCP_STATUS_UNIT_SHARED			0x00000004
+ #define ZFCP_STATUS_UNIT_READONLY		0x00000008
+ #define ZFCP_STATUS_UNIT_REGISTERED		0x00000010
+ #define ZFCP_STATUS_UNIT_SCSI_WORK_PENDING	0x00000020
+ 
+ /* FSF request status (this does not have a common part) */
+-#define ZFCP_STATUS_FSFREQ_NOT_INIT		0x00000000
+-#define ZFCP_STATUS_FSFREQ_POOL  		0x00000001
+ #define ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT	0x00000002
+ #define ZFCP_STATUS_FSFREQ_COMPLETED		0x00000004
+ #define ZFCP_STATUS_FSFREQ_ERROR		0x00000008
+ #define ZFCP_STATUS_FSFREQ_CLEANUP		0x00000010
+-#define ZFCP_STATUS_FSFREQ_ABORTING		0x00000020
+ #define ZFCP_STATUS_FSFREQ_ABORTSUCCEEDED	0x00000040
+ #define ZFCP_STATUS_FSFREQ_ABORTNOTNEEDED       0x00000080
+ #define ZFCP_STATUS_FSFREQ_ABORTED              0x00000100
+@@ -379,7 +325,7 @@ struct ct_hdr {
+  * a port name is required */
+ struct ct_iu_gid_pn_req {
+ 	struct ct_hdr header;
+-	wwn_t wwpn;
++	u64 wwpn;
+ } __attribute__ ((packed));
+ 
+ /* FS_ACC IU and data unit for GID_PN nameserver request */
+@@ -388,11 +334,9 @@ struct ct_iu_gid_pn_resp {
+ 	u32 d_id;
+ } __attribute__ ((packed));
+ 
+-typedef void (*zfcp_send_ct_handler_t)(unsigned long);
+-
+ /**
+  * struct zfcp_send_ct - used to pass parameters to function zfcp_fsf_send_ct
+- * @port: port where the request is sent to
++ * @wka_port: port where the request is sent to
+  * @req: scatter-gather list for request
+  * @resp: scatter-gather list for response
+  * @req_count: number of elements in request scatter-gather list
+@@ -404,12 +348,12 @@ typedef void (*zfcp_send_ct_handler_t)(u
+  * @status: used to pass error status to calling function
+  */
+ struct zfcp_send_ct {
+-	struct zfcp_port *port;
++	struct zfcp_wka_port *wka_port;
+ 	struct scatterlist *req;
+ 	struct scatterlist *resp;
+ 	unsigned int req_count;
+ 	unsigned int resp_count;
+-	zfcp_send_ct_handler_t handler;
++	void (*handler)(unsigned long);
+ 	unsigned long handler_data;
+ 	int timeout;
+ 	struct completion *completion;
+@@ -426,8 +370,6 @@ struct zfcp_gid_pn_data {
+         struct zfcp_port *port;
+ };
+ 
+-typedef void (*zfcp_send_els_handler_t)(unsigned long);
+-
+ /**
+  * struct zfcp_send_els - used to pass parameters to function zfcp_fsf_send_els
+  * @adapter: adapter where request is sent from
+@@ -451,22 +393,28 @@ struct zfcp_send_els {
+ 	struct scatterlist *resp;
+ 	unsigned int req_count;
+ 	unsigned int resp_count;
+-	zfcp_send_els_handler_t handler;
++	void (*handler)(unsigned long);
+ 	unsigned long handler_data;
+ 	struct completion *completion;
+ 	int ls_code;
+ 	int status;
+ };
+ 
++struct zfcp_wka_port {
++	struct zfcp_adapter	*adapter;
++	wait_queue_head_t	completion_wq;
++	enum zfcp_wka_status	status;
++	atomic_t		refcount;
++	u32			d_id;
++	u32			handle;
++	struct mutex		mutex;
++	struct delayed_work	work;
++};
++
+ struct zfcp_qdio_queue {
+-	struct qdio_buffer *sbal[QDIO_MAX_BUFFERS_PER_Q]; /* SBALs */
+-	u8		   first;	      /* index of next free bfr
+-						 in queue (free_count>0) */
+-	atomic_t           count;	      /* number of free buffers
+-						 in queue */
+-	spinlock_t	   lock;	      /* lock for operations on queue */
+-	int                pci_batch;	      /* SBALs since PCI indication
+-						 was last set */
++	struct qdio_buffer *sbal[QDIO_MAX_BUFFERS_PER_Q];
++	u8		   first;	/* index of next free bfr in queue */
++	atomic_t           count;	/* number of free buffers in queue */
+ };
+ 
+ struct zfcp_erp_action {
+@@ -475,7 +423,7 @@ struct zfcp_erp_action {
+ 	struct zfcp_adapter *adapter; /* device which should be recovered */
+ 	struct zfcp_port *port;
+ 	struct zfcp_unit *unit;
+-	volatile u32 status;	      /* recovery status */
++	u32		status;	      /* recovery status */
+ 	u32 step;	              /* active step of this erp action */
+ 	struct zfcp_fsf_req *fsf_req; /* fsf request currently pending
+ 					 for this action */
+@@ -506,8 +454,8 @@ struct zfcp_adapter {
+ 	atomic_t                refcount;          /* reference count */
+ 	wait_queue_head_t	remove_wq;         /* can be used to wait for
+ 						      refcount drop to zero */
+-	wwn_t			peer_wwnn;	   /* P2P peer WWNN */
+-	wwn_t			peer_wwpn;	   /* P2P peer WWPN */
++	u64			peer_wwnn;	   /* P2P peer WWNN */
++	u64			peer_wwpn;	   /* P2P peer WWPN */
+ 	u32			peer_d_id;	   /* P2P peer D_ID */
+ 	struct ccw_device       *ccw_device;	   /* S/390 ccw device */
+ 	u32			hydra_version;	   /* Hydra version */
+@@ -518,13 +466,13 @@ struct zfcp_adapter {
+ 	u16			timer_ticks;       /* time int for a tick */
+ 	struct Scsi_Host	*scsi_host;	   /* Pointer to mid-layer */
+ 	struct list_head	port_list_head;	   /* remote port list */
+-	struct list_head        port_remove_lh;    /* head of ports to be
+-						      removed */
+-	u32			ports;	           /* number of remote ports */
+ 	unsigned long		req_no;		   /* unique FSF req number */
+ 	struct list_head	*req_list;	   /* list of pending reqs */
+ 	spinlock_t		req_list_lock;	   /* request list lock */
+ 	struct zfcp_qdio_queue	req_q;		   /* request queue */
++	spinlock_t		req_q_lock;	   /* for operations on queue */
++	int			req_q_pci_batch;   /* SBALs since PCI indication
++						      was last set */
+ 	u32			fsf_req_seq_no;	   /* FSF cmnd seq number */
+ 	wait_queue_head_t	request_wq;	   /* can be used to wait for
+ 						      more avaliable SBALs */
+@@ -548,7 +496,7 @@ struct zfcp_adapter {
+ 						      actions */
+ 	u32			erp_low_mem_count; /* nr of erp actions waiting
+ 						      for memory */
+-	struct zfcp_port	*nameserver_port;  /* adapter's nameserver */
++	struct zfcp_wka_port	nsp;		   /* adapter's nameserver */
+ 	debug_info_t		*rec_dbf;
+ 	debug_info_t		*hba_dbf;
+ 	debug_info_t		*san_dbf;          /* debug feature areas */
+@@ -563,11 +511,11 @@ struct zfcp_adapter {
+ 	struct zfcp_scsi_dbf_record	scsi_dbf_buf;
+ 	struct zfcp_adapter_mempool	pool;      /* Adapter memory pools */
+ 	struct qdio_initialize  qdio_init_data;    /* for qdio_establish */
+-	struct device           generic_services;  /* directory for WKA ports */
+ 	struct fc_host_statistics *fc_stats;
+ 	struct fsf_qtcb_bottom_port *stats_reset_data;
+ 	unsigned long		stats_reset;
+ 	struct work_struct	scan_work;
++	atomic_t		qdio_outb_full;	   /* queue full incidents */
+ };
+ 
+ struct zfcp_port {
+@@ -579,18 +527,16 @@ struct zfcp_port {
+ 						  refcount drop to zero */
+ 	struct zfcp_adapter    *adapter;       /* adapter used to access port */
+ 	struct list_head       unit_list_head; /* head of logical unit list */
+-	struct list_head       unit_remove_lh; /* head of luns to be removed
+-						  list */
+-	u32		       units;	       /* # of logical units in list */
+ 	atomic_t	       status;	       /* status of this remote port */
+-	wwn_t		       wwnn;	       /* WWNN if known */
+-	wwn_t		       wwpn;	       /* WWPN */
++	u64		       wwnn;	       /* WWNN if known */
++	u64		       wwpn;	       /* WWPN */
+ 	u32		       d_id;	       /* D_ID */
+ 	u32		       handle;	       /* handle assigned by FSF */
+ 	struct zfcp_erp_action erp_action;     /* pending error recovery */
+         atomic_t               erp_counter;
+ 	u32                    maxframe_size;
+ 	u32                    supported_classes;
++	struct work_struct     gid_pn_work;
+ };
+ 
+ struct zfcp_unit {
+@@ -601,8 +547,7 @@ struct zfcp_unit {
+ 						  refcount drop to zero */
+ 	struct zfcp_port       *port;	       /* remote port of unit */
+ 	atomic_t	       status;	       /* status of this logical unit */
+-	unsigned int	       scsi_lun;       /* own SCSI LUN */
+-	fcp_lun_t	       fcp_lun;	       /* own FCP_LUN */
++	u64		       fcp_lun;	       /* own FCP_LUN */
+ 	u32		       handle;	       /* handle assigned by FSF */
+         struct scsi_device     *device;        /* scsi device struct pointer */
+ 	struct zfcp_erp_action erp_action;     /* pending error recovery */
+@@ -625,7 +570,7 @@ struct zfcp_fsf_req {
+ 	u8			sbal_response;	/* SBAL used in interrupt */
+ 	wait_queue_head_t      completion_wq;  /* can be used by a routine
+ 						  to wait for completion */
+-	volatile u32	       status;	       /* status of this request */
++	u32			status;	       /* status of this request */
+ 	u32		       fsf_command;    /* FSF Command copy */
+ 	struct fsf_qtcb	       *qtcb;	       /* address of associated QTCB */
+ 	u32		       seq_no;         /* Sequence number of request */
+@@ -644,11 +589,7 @@ struct zfcp_fsf_req {
+ struct zfcp_data {
+ 	struct scsi_host_template scsi_host_template;
+ 	struct scsi_transport_template *scsi_transport_template;
+-        atomic_t                status;             /* Module status flags */
+ 	struct list_head	adapter_list_head;  /* head of adapter list */
+-	struct list_head	adapter_remove_lh;  /* head of adapters to be
+-						       removed */
+-	u32			adapters;	    /* # of adapters in list */
+ 	rwlock_t                config_lock;        /* serialises changes
+ 						       to adapter/port/unit
+ 						       lists */
+@@ -656,11 +597,12 @@ struct zfcp_data {
+ 						       changes */
+ 	atomic_t		loglevel;            /* current loglevel */
+ 	char                    init_busid[BUS_ID_SIZE];
+-	wwn_t                   init_wwpn;
+-	fcp_lun_t               init_fcp_lun;
+-	struct kmem_cache		*fsf_req_qtcb_cache;
+-	struct kmem_cache		*sr_buffer_cache;
+-	struct kmem_cache		*gid_pn_cache;
++	u64			init_wwpn;
++	u64			init_fcp_lun;
++	struct kmem_cache	*fsf_req_qtcb_cache;
++	struct kmem_cache	*sr_buffer_cache;
++	struct kmem_cache	*gid_pn_cache;
++	struct workqueue_struct	*work_queue;
+ };
+ 
+ /* struct used by memory pools for fsf_requests */
+@@ -677,14 +619,7 @@ struct zfcp_fsf_req_qtcb {
+ #define ZFCP_SET                0x00000100
+ #define ZFCP_CLEAR              0x00000200
+ 
+-#ifndef atomic_test_mask
+-#define atomic_test_mask(mask, target) \
+-           ((atomic_read(target) & mask) == mask)
+-#endif
+-
+ #define zfcp_get_busid_by_adapter(adapter) (adapter->ccw_device->dev.bus_id)
+-#define zfcp_get_busid_by_port(port) (zfcp_get_busid_by_adapter(port->adapter))
+-#define zfcp_get_busid_by_unit(unit) (zfcp_get_busid_by_port(unit->port))
+ 
+ /*
+  * Helper functions for request ID management.
+@@ -745,12 +680,6 @@ zfcp_unit_put(struct zfcp_unit *unit)
+ }
+ 
+ static inline void
+-zfcp_unit_wait(struct zfcp_unit *unit)
+-{
+-	wait_event(unit->remove_wq, atomic_read(&unit->refcount) == 0);
+-}
+-
+-static inline void
+ zfcp_port_get(struct zfcp_port *port)
+ {
+ 	atomic_inc(&port->refcount);
+@@ -764,12 +693,6 @@ zfcp_port_put(struct zfcp_port *port)
+ }
+ 
+ static inline void
+-zfcp_port_wait(struct zfcp_port *port)
+-{
+-	wait_event(port->remove_wq, atomic_read(&port->refcount) == 0);
+-}
+-
+-static inline void
+ zfcp_adapter_get(struct zfcp_adapter *adapter)
+ {
+ 	atomic_inc(&adapter->refcount);
+@@ -782,10 +705,4 @@ zfcp_adapter_put(struct zfcp_adapter *ad
+ 		wake_up(&adapter->remove_wq);
+ }
+ 
+-static inline void
+-zfcp_adapter_wait(struct zfcp_adapter *adapter)
+-{
+-	wait_event(adapter->remove_wq, atomic_read(&adapter->refcount) == 0);
+-}
+-
+ #endif /* ZFCP_DEF_H */
+Index: linux-2.6.27-gentoo-r7/drivers/s390/scsi/zfcp_erp.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/scsi/zfcp_erp.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/scsi/zfcp_erp.c
+@@ -23,7 +23,6 @@ enum zfcp_erp_steps {
+ 	ZFCP_ERP_STEP_FSF_XCONFIG	= 0x0001,
+ 	ZFCP_ERP_STEP_PHYS_PORT_CLOSING	= 0x0010,
+ 	ZFCP_ERP_STEP_PORT_CLOSING	= 0x0100,
+-	ZFCP_ERP_STEP_NAMESERVER_OPEN	= 0x0200,
+ 	ZFCP_ERP_STEP_NAMESERVER_LOOKUP	= 0x0400,
+ 	ZFCP_ERP_STEP_PORT_OPENING	= 0x0800,
+ 	ZFCP_ERP_STEP_UNIT_CLOSING	= 0x1000,
+@@ -473,6 +472,7 @@ static void zfcp_erp_strategy_check_fsfr
+ 				   ZFCP_STATUS_ERP_TIMEDOUT)) {
+ 			act->fsf_req->status |= ZFCP_STATUS_FSFREQ_DISMISSED;
+ 			zfcp_rec_dbf_event_action(142, act);
++			act->fsf_req->erp_action = NULL;
+ 		}
+ 		if (act->status & ZFCP_STATUS_ERP_TIMEDOUT)
+ 			zfcp_rec_dbf_event_action(143, act);
+@@ -532,8 +532,7 @@ static void _zfcp_erp_port_reopen_all(st
+ 	struct zfcp_port *port;
+ 
+ 	list_for_each_entry(port, &adapter->port_list_head, list)
+-		if (!(atomic_read(&port->status) & ZFCP_STATUS_PORT_WKA))
+-			_zfcp_erp_port_reopen(port, clear, id, ref);
++		_zfcp_erp_port_reopen(port, clear, id, ref);
+ }
+ 
+ static void _zfcp_erp_unit_reopen_all(struct zfcp_port *port, int clear, u8 id,
+@@ -669,8 +668,6 @@ static int zfcp_erp_adapter_strategy_ope
+ 	int ret;
+ 	struct zfcp_adapter *adapter = act->adapter;
+ 
+-	atomic_clear_mask(ZFCP_STATUS_ADAPTER_XPORT_OK, &adapter->status);
+-
+ 	write_lock_irq(&adapter->erp_lock);
+ 	zfcp_erp_action_to_running(act);
+ 	write_unlock_irq(&adapter->erp_lock);
+@@ -741,8 +738,7 @@ static int zfcp_erp_adapter_strategy_gen
+ 				       ZFCP_STATUS_COMMON_OPEN, ZFCP_CLEAR);
+  failed_qdio:
+ 	atomic_clear_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK |
+-			  ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED |
+-			  ZFCP_STATUS_ADAPTER_XPORT_OK,
++			  ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED,
+ 			  &act->adapter->status);
+ 	return retval;
+ }
+@@ -751,15 +747,11 @@ static int zfcp_erp_adapter_strategy(str
+ {
+ 	int retval;
+ 
+-	atomic_set_mask(ZFCP_STATUS_COMMON_CLOSING, &act->adapter->status);
+ 	zfcp_erp_adapter_strategy_generic(act, 1); /* close */
+-	atomic_clear_mask(ZFCP_STATUS_COMMON_CLOSING, &act->adapter->status);
+ 	if (act->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
+ 		return ZFCP_ERP_EXIT;
+ 
+-	atomic_set_mask(ZFCP_STATUS_COMMON_OPENING, &act->adapter->status);
+ 	retval = zfcp_erp_adapter_strategy_generic(act, 0); /* open */
+-	atomic_clear_mask(ZFCP_STATUS_COMMON_OPENING, &act->adapter->status);
+ 
+ 	if (retval == ZFCP_ERP_FAILED)
+ 		ssleep(8);
+@@ -783,10 +775,7 @@ static int zfcp_erp_port_forced_strategy
+ 
+ static void zfcp_erp_port_strategy_clearstati(struct zfcp_port *port)
+ {
+-	atomic_clear_mask(ZFCP_STATUS_COMMON_OPENING |
+-			  ZFCP_STATUS_COMMON_CLOSING |
+-			  ZFCP_STATUS_COMMON_ACCESS_DENIED |
+-			  ZFCP_STATUS_PORT_DID_DID |
++	atomic_clear_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED |
+ 			  ZFCP_STATUS_PORT_PHYS_CLOSING |
+ 			  ZFCP_STATUS_PORT_INVALID_WWPN,
+ 			  &port->status);
+@@ -839,73 +828,12 @@ static int zfcp_erp_port_strategy_open_p
+ 	return ZFCP_ERP_CONTINUES;
+ }
+ 
+-static void zfcp_erp_port_strategy_open_ns_wake(struct zfcp_erp_action *ns_act)
+-{
+-	unsigned long flags;
+-	struct zfcp_adapter *adapter = ns_act->adapter;
+-	struct zfcp_erp_action *act, *tmp;
+-	int status;
+-
+-	read_lock_irqsave(&adapter->erp_lock, flags);
+-	list_for_each_entry_safe(act, tmp, &adapter->erp_running_head, list) {
+-		if (act->step == ZFCP_ERP_STEP_NAMESERVER_OPEN) {
+-			status = atomic_read(&adapter->nameserver_port->status);
+-			if (status & ZFCP_STATUS_COMMON_ERP_FAILED)
+-				zfcp_erp_port_failed(act->port, 27, NULL);
+-			zfcp_erp_action_ready(act);
+-		}
+-	}
+-	read_unlock_irqrestore(&adapter->erp_lock, flags);
+-}
+-
+-static int zfcp_erp_port_strategy_open_nameserver(struct zfcp_erp_action *act)
+-{
+-	int retval;
+-
+-	switch (act->step) {
+-	case ZFCP_ERP_STEP_UNINITIALIZED:
+-	case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:
+-	case ZFCP_ERP_STEP_PORT_CLOSING:
+-		return zfcp_erp_port_strategy_open_port(act);
+-
+-	case ZFCP_ERP_STEP_PORT_OPENING:
+-		if (atomic_read(&act->port->status) & ZFCP_STATUS_COMMON_OPEN)
+-			retval = ZFCP_ERP_SUCCEEDED;
+-		else
+-			retval = ZFCP_ERP_FAILED;
+-		/* this is needed anyway  */
+-		zfcp_erp_port_strategy_open_ns_wake(act);
+-		return retval;
+-
+-	default:
+-		return ZFCP_ERP_FAILED;
+-	}
+-}
+-
+-static int zfcp_erp_port_strategy_open_lookup(struct zfcp_erp_action *act)
+-{
+-	int retval;
+-
+-	retval = zfcp_fc_ns_gid_pn_request(act);
+-	if (retval == -ENOMEM)
+-		return ZFCP_ERP_NOMEM;
+-	act->step = ZFCP_ERP_STEP_NAMESERVER_LOOKUP;
+-	if (retval)
+-		return ZFCP_ERP_FAILED;
+-	return ZFCP_ERP_CONTINUES;
+-}
+-
+ static int zfcp_erp_open_ptp_port(struct zfcp_erp_action *act)
+ {
+ 	struct zfcp_adapter *adapter = act->adapter;
+ 	struct zfcp_port *port = act->port;
+ 
+ 	if (port->wwpn != adapter->peer_wwpn) {
+-		dev_err(&adapter->ccw_device->dev,
+-			"Failed to open port 0x%016Lx, "
+-			"Peer WWPN 0x%016Lx does not "
+-			"match.\n", port->wwpn,
+-			adapter->peer_wwpn);
+ 		zfcp_erp_port_failed(port, 25, NULL);
+ 		return ZFCP_ERP_FAILED;
+ 	}
+@@ -914,11 +842,25 @@ static int zfcp_erp_open_ptp_port(struct
+ 	return zfcp_erp_port_strategy_open_port(act);
+ }
+ 
++void zfcp_erp_port_strategy_open_lookup(struct work_struct *work)
++{
++	int retval;
++	struct zfcp_port *port = container_of(work, struct zfcp_port,
++					      gid_pn_work);
++
++	retval = zfcp_fc_ns_gid_pn(&port->erp_action);
++	if (retval == -ENOMEM)
++		zfcp_erp_notify(&port->erp_action, ZFCP_ERP_NOMEM);
++	port->erp_action.step = ZFCP_ERP_STEP_NAMESERVER_LOOKUP;
++	if (retval)
++		zfcp_erp_notify(&port->erp_action, ZFCP_ERP_FAILED);
++
++}
++
+ static int zfcp_erp_port_strategy_open_common(struct zfcp_erp_action *act)
+ {
+ 	struct zfcp_adapter *adapter = act->adapter;
+ 	struct zfcp_port *port = act->port;
+-	struct zfcp_port *ns_port = adapter->nameserver_port;
+ 	int p_status = atomic_read(&port->status);
+ 
+ 	switch (act->step) {
+@@ -927,28 +869,10 @@ static int zfcp_erp_port_strategy_open_c
+ 	case ZFCP_ERP_STEP_PORT_CLOSING:
+ 		if (fc_host_port_type(adapter->scsi_host) == FC_PORTTYPE_PTP)
+ 			return zfcp_erp_open_ptp_port(act);
+-		if (!ns_port) {
+-			dev_err(&adapter->ccw_device->dev,
+-				"Nameserver port unavailable.\n");
+-			return ZFCP_ERP_FAILED;
+-		}
+-		if (!(atomic_read(&ns_port->status) &
+-		      ZFCP_STATUS_COMMON_UNBLOCKED)) {
+-			/* nameserver port may live again */
+-			atomic_set_mask(ZFCP_STATUS_COMMON_RUNNING,
+-					&ns_port->status);
+-			if (zfcp_erp_port_reopen(ns_port, 0, 77, act) >= 0) {
+-				act->step = ZFCP_ERP_STEP_NAMESERVER_OPEN;
+-				return ZFCP_ERP_CONTINUES;
+-			}
+-			return ZFCP_ERP_FAILED;
++		if (!(p_status & ZFCP_STATUS_PORT_DID_DID)) {
++			queue_work(zfcp_data.work_queue, &port->gid_pn_work);
++			return ZFCP_ERP_CONTINUES;
+ 		}
+-		/* else nameserver port is already open, fall through */
+-	case ZFCP_ERP_STEP_NAMESERVER_OPEN:
+-		if (!(atomic_read(&ns_port->status) & ZFCP_STATUS_COMMON_OPEN))
+-			return ZFCP_ERP_FAILED;
+-		return zfcp_erp_port_strategy_open_lookup(act);
+-
+ 	case ZFCP_ERP_STEP_NAMESERVER_LOOKUP:
+ 		if (!(p_status & ZFCP_STATUS_PORT_DID_DID)) {
+ 			if (p_status & (ZFCP_STATUS_PORT_INVALID_WWPN)) {
+@@ -961,25 +885,26 @@ static int zfcp_erp_port_strategy_open_c
+ 
+ 	case ZFCP_ERP_STEP_PORT_OPENING:
+ 		/* D_ID might have changed during open */
+-		if ((p_status & ZFCP_STATUS_COMMON_OPEN) &&
+-		    (p_status & ZFCP_STATUS_PORT_DID_DID))
+-			return ZFCP_ERP_SUCCEEDED;
++		if (p_status & ZFCP_STATUS_COMMON_OPEN) {
++			if (p_status & ZFCP_STATUS_PORT_DID_DID)
++				return ZFCP_ERP_SUCCEEDED;
++			else {
++				act->step = ZFCP_ERP_STEP_PORT_CLOSING;
++				return ZFCP_ERP_CONTINUES;
++			}
+ 		/* fall through otherwise */
++		}
+ 	}
+ 	return ZFCP_ERP_FAILED;
+ }
+ 
+-static int zfcp_erp_port_strategy_open(struct zfcp_erp_action *act)
+-{
+-	if (atomic_read(&act->port->status) & (ZFCP_STATUS_PORT_WKA))
+-		return zfcp_erp_port_strategy_open_nameserver(act);
+-	return zfcp_erp_port_strategy_open_common(act);
+-}
+-
+ static int zfcp_erp_port_strategy(struct zfcp_erp_action *erp_action)
+ {
+ 	struct zfcp_port *port = erp_action->port;
+ 
++	if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_NOESC)
++		goto close_init_done;
++
+ 	switch (erp_action->step) {
+ 	case ZFCP_ERP_STEP_UNINITIALIZED:
+ 		zfcp_erp_port_strategy_clearstati(port);
+@@ -992,19 +917,17 @@ static int zfcp_erp_port_strategy(struct
+ 			return ZFCP_ERP_FAILED;
+ 		break;
+ 	}
++
++close_init_done:
+ 	if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
+ 		return ZFCP_ERP_EXIT;
+-	else
+-		return zfcp_erp_port_strategy_open(erp_action);
+ 
+-	return ZFCP_ERP_FAILED;
++	return zfcp_erp_port_strategy_open_common(erp_action);
+ }
+ 
+ static void zfcp_erp_unit_strategy_clearstati(struct zfcp_unit *unit)
+ {
+-	atomic_clear_mask(ZFCP_STATUS_COMMON_OPENING |
+-			  ZFCP_STATUS_COMMON_CLOSING |
+-			  ZFCP_STATUS_COMMON_ACCESS_DENIED |
++	atomic_clear_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED |
+ 			  ZFCP_STATUS_UNIT_SHARED |
+ 			  ZFCP_STATUS_UNIT_READONLY,
+ 			  &unit->status);
+@@ -1065,8 +988,14 @@ static int zfcp_erp_strategy_check_unit(
+ 		break;
+ 	case ZFCP_ERP_FAILED :
+ 		atomic_inc(&unit->erp_counter);
+-		if (atomic_read(&unit->erp_counter) > ZFCP_MAX_ERPS)
++		if (atomic_read(&unit->erp_counter) > ZFCP_MAX_ERPS) {
++			dev_err(&unit->port->adapter->ccw_device->dev,
++				"ERP failed for unit 0x%016Lx on "
++				"port 0x%016Lx\n",
++				(unsigned long long)unit->fcp_lun,
++				(unsigned long long)unit->port->wwpn);
+ 			zfcp_erp_unit_failed(unit, 21, NULL);
++		}
+ 		break;
+ 	}
+ 
+@@ -1091,8 +1020,12 @@ static int zfcp_erp_strategy_check_port(
+ 			result = ZFCP_ERP_EXIT;
+ 		}
+ 		atomic_inc(&port->erp_counter);
+-		if (atomic_read(&port->erp_counter) > ZFCP_MAX_ERPS)
++		if (atomic_read(&port->erp_counter) > ZFCP_MAX_ERPS) {
++			dev_err(&port->adapter->ccw_device->dev,
++				"ERP failed for remote port 0x%016Lx\n",
++				(unsigned long long)port->wwpn);
+ 			zfcp_erp_port_failed(port, 22, NULL);
++		}
+ 		break;
+ 	}
+ 
+@@ -1114,8 +1047,12 @@ static int zfcp_erp_strategy_check_adapt
+ 
+ 	case ZFCP_ERP_FAILED :
+ 		atomic_inc(&adapter->erp_counter);
+-		if (atomic_read(&adapter->erp_counter) > ZFCP_MAX_ERPS)
++		if (atomic_read(&adapter->erp_counter) > ZFCP_MAX_ERPS) {
++			dev_err(&adapter->ccw_device->dev,
++				"ERP cannot recover an error "
++				"on the FCP device\n");
+ 			zfcp_erp_adapter_failed(adapter, 23, NULL);
++		}
+ 		break;
+ 	}
+ 
+@@ -1249,10 +1186,13 @@ static void zfcp_erp_scsi_scan(struct wo
+ 		container_of(work, struct zfcp_erp_add_work, work);
+ 	struct zfcp_unit *unit = p->unit;
+ 	struct fc_rport *rport = unit->port->rport;
+-	scsi_scan_target(&rport->dev, 0, rport->scsi_target_id,
+-			 unit->scsi_lun, 0);
++
++	if (rport && rport->port_state == FC_PORTSTATE_ONLINE)
++		scsi_scan_target(&rport->dev, 0, rport->scsi_target_id,
++			 scsilun_to_int((struct scsi_lun *)&unit->fcp_lun), 0);
+ 	atomic_clear_mask(ZFCP_STATUS_UNIT_SCSI_WORK_PENDING, &unit->status);
+ 	zfcp_unit_put(unit);
++	wake_up(&unit->port->adapter->erp_done_wqh);
+ 	kfree(p);
+ }
+ 
+@@ -1263,9 +1203,9 @@ static void zfcp_erp_schedule_work(struc
+ 	p = kzalloc(sizeof(*p), GFP_KERNEL);
+ 	if (!p) {
+ 		dev_err(&unit->port->adapter->ccw_device->dev,
+-			"Out of resources. Could not register unit "
+-			"0x%016Lx on port 0x%016Lx with SCSI stack.\n",
+-			unit->fcp_lun, unit->port->wwpn);
++			"Registering unit 0x%016Lx on port 0x%016Lx failed\n",
++			(unsigned long long)unit->fcp_lun,
++			(unsigned long long)unit->port->wwpn);
+ 		return;
+ 	}
+ 
+@@ -1273,7 +1213,7 @@ static void zfcp_erp_schedule_work(struc
+ 	atomic_set_mask(ZFCP_STATUS_UNIT_SCSI_WORK_PENDING, &unit->status);
+ 	INIT_WORK(&p->work, zfcp_erp_scsi_scan);
+ 	p->unit = unit;
+-	schedule_work(&p->work);
++	queue_work(zfcp_data.work_queue, &p->work);
+ }
+ 
+ static void zfcp_erp_rport_register(struct zfcp_port *port)
+@@ -1286,8 +1226,8 @@ static void zfcp_erp_rport_register(stru
+ 	port->rport = fc_remote_port_add(port->adapter->scsi_host, 0, &ids);
+ 	if (!port->rport) {
+ 		dev_err(&port->adapter->ccw_device->dev,
+-			"Failed registration of rport "
+-			"0x%016Lx.\n", port->wwpn);
++			"Registering port 0x%016Lx failed\n",
++			(unsigned long long)port->wwpn);
+ 		return;
+ 	}
+ 
+@@ -1299,12 +1239,12 @@ static void zfcp_erp_rport_register(stru
+ static void zfcp_erp_rports_del(struct zfcp_adapter *adapter)
+ {
+ 	struct zfcp_port *port;
+-	list_for_each_entry(port, &adapter->port_list_head, list)
+-		if (port->rport && !(atomic_read(&port->status) &
+-					ZFCP_STATUS_PORT_WKA)) {
+-			fc_remote_port_delete(port->rport);
+-			port->rport = NULL;
+-		}
++	list_for_each_entry(port, &adapter->port_list_head, list) {
++		if (!port->rport)
++			continue;
++		fc_remote_port_delete(port->rport);
++		port->rport = NULL;
++	}
+ }
+ 
+ static void zfcp_erp_action_cleanup(struct zfcp_erp_action *act, int result)
+@@ -1459,9 +1399,9 @@ static int zfcp_erp_thread(void *data)
+ 				zfcp_erp_wakeup(adapter);
+ 		}
+ 
+-		zfcp_rec_dbf_event_thread(4, adapter);
++		zfcp_rec_dbf_event_thread_lock(4, adapter);
+ 		down_interruptible(&adapter->erp_ready_sem);
+-		zfcp_rec_dbf_event_thread(5, adapter);
++		zfcp_rec_dbf_event_thread_lock(5, adapter);
+ 	}
+ 
+ 	atomic_clear_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP, &adapter->status);
+@@ -1484,7 +1424,7 @@ int zfcp_erp_thread_setup(struct zfcp_ad
+ 	retval = kernel_thread(zfcp_erp_thread, adapter, SIGCHLD);
+ 	if (retval < 0) {
+ 		dev_err(&adapter->ccw_device->dev,
+-			"Creation of ERP thread failed.\n");
++			"Creating an ERP thread for the FCP device failed.\n");
+ 		return retval;
+ 	}
+ 	wait_event(adapter->erp_thread_wqh,
+@@ -1506,7 +1446,7 @@ void zfcp_erp_thread_kill(struct zfcp_ad
+ {
+ 	atomic_set_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_KILL, &adapter->status);
+ 	up(&adapter->erp_ready_sem);
+-	zfcp_rec_dbf_event_thread_lock(2, adapter);
++	zfcp_rec_dbf_event_thread_lock(3, adapter);
+ 
+ 	wait_event(adapter->erp_thread_wqh,
+ 		   !(atomic_read(&adapter->status) &
+@@ -1526,7 +1466,6 @@ void zfcp_erp_adapter_failed(struct zfcp
+ {
+ 	zfcp_erp_modify_adapter_status(adapter, id, ref,
+ 				       ZFCP_STATUS_COMMON_ERP_FAILED, ZFCP_SET);
+-	dev_err(&adapter->ccw_device->dev, "Adapter ERP failed.\n");
+ }
+ 
+ /**
+@@ -1539,15 +1478,6 @@ void zfcp_erp_port_failed(struct zfcp_po
+ {
+ 	zfcp_erp_modify_port_status(port, id, ref,
+ 				    ZFCP_STATUS_COMMON_ERP_FAILED, ZFCP_SET);
+-
+-	if (atomic_read(&port->status) & ZFCP_STATUS_PORT_WKA)
+-		dev_err(&port->adapter->ccw_device->dev,
+-			"Port ERP failed for WKA port d_id=0x%06x.\n",
+-			port->d_id);
+-	else
+-		dev_err(&port->adapter->ccw_device->dev,
+-			"Port ERP failed for port wwpn=0x%016Lx.\n",
+-			port->wwpn);
+ }
+ 
+ /**
+@@ -1560,10 +1490,6 @@ void zfcp_erp_unit_failed(struct zfcp_un
+ {
+ 	zfcp_erp_modify_unit_status(unit, id, ref,
+ 				    ZFCP_STATUS_COMMON_ERP_FAILED, ZFCP_SET);
+-
+-	dev_err(&unit->port->adapter->ccw_device->dev,
+-		"Unit ERP failed for unit 0x%016Lx on port 0x%016Lx.\n",
+-		unit->fcp_lun, unit->port->wwpn);
+ }
+ 
+ /**
+@@ -1754,9 +1680,8 @@ static void zfcp_erp_port_access_changed
+ 
+ 	if (!(status & (ZFCP_STATUS_COMMON_ACCESS_DENIED |
+ 			ZFCP_STATUS_COMMON_ACCESS_BOXED))) {
+-		if (!(status & ZFCP_STATUS_PORT_WKA))
+-			list_for_each_entry(unit, &port->unit_list_head, list)
+-				zfcp_erp_unit_access_changed(unit, id, ref);
++		list_for_each_entry(unit, &port->unit_list_head, list)
++				    zfcp_erp_unit_access_changed(unit, id, ref);
+ 		return;
+ 	}
+ 
+@@ -1779,10 +1704,7 @@ void zfcp_erp_adapter_access_changed(str
+ 		return;
+ 
+ 	read_lock_irqsave(&zfcp_data.config_lock, flags);
+-	if (adapter->nameserver_port)
+-		zfcp_erp_port_access_changed(adapter->nameserver_port, id, ref);
+ 	list_for_each_entry(port, &adapter->port_list_head, list)
+-		if (port != adapter->nameserver_port)
+-			zfcp_erp_port_access_changed(port, id, ref);
++		zfcp_erp_port_access_changed(port, id, ref);
+ 	read_unlock_irqrestore(&zfcp_data.config_lock, flags);
+ }
+Index: linux-2.6.27-gentoo-r7/drivers/s390/scsi/zfcp_ext.h
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/scsi/zfcp_ext.h
++++ linux-2.6.27-gentoo-r7/drivers/s390/scsi/zfcp_ext.h
+@@ -12,16 +12,14 @@
+ #include "zfcp_def.h"
+ 
+ /* zfcp_aux.c */
+-extern struct zfcp_unit *zfcp_get_unit_by_lun(struct zfcp_port *,
+-					      fcp_lun_t);
+-extern struct zfcp_port *zfcp_get_port_by_wwpn(struct zfcp_adapter *,
+-					       wwn_t);
++extern struct zfcp_unit *zfcp_get_unit_by_lun(struct zfcp_port *, u64);
++extern struct zfcp_port *zfcp_get_port_by_wwpn(struct zfcp_adapter *, u64);
+ extern int zfcp_adapter_enqueue(struct ccw_device *);
+ extern void zfcp_adapter_dequeue(struct zfcp_adapter *);
+-extern struct zfcp_port *zfcp_port_enqueue(struct zfcp_adapter *, wwn_t, u32,
++extern struct zfcp_port *zfcp_port_enqueue(struct zfcp_adapter *, u64, u32,
+ 					   u32);
+ extern void zfcp_port_dequeue(struct zfcp_port *);
+-extern struct zfcp_unit *zfcp_unit_enqueue(struct zfcp_port *, fcp_lun_t);
++extern struct zfcp_unit *zfcp_unit_enqueue(struct zfcp_port *, u64);
+ extern void zfcp_unit_dequeue(struct zfcp_unit *);
+ extern int zfcp_reqlist_isempty(struct zfcp_adapter *);
+ extern void zfcp_sg_free_table(struct scatterlist *, int);
+@@ -29,6 +27,7 @@ extern int zfcp_sg_setup_table(struct sc
+ 
+ /* zfcp_ccw.c */
+ extern int zfcp_ccw_register(void);
++extern struct zfcp_adapter *zfcp_get_adapter_by_busid(char *);
+ 
+ /* zfcp_cfdc.c */
+ extern struct miscdevice zfcp_cfdc_misc;
+@@ -50,6 +49,8 @@ extern void zfcp_hba_dbf_event_fsf_unsol
+ 					 struct fsf_status_read_buffer *);
+ extern void zfcp_hba_dbf_event_qdio(struct zfcp_adapter *, unsigned int, int,
+ 				    int);
++extern void zfcp_hba_dbf_event_berr(struct zfcp_adapter *,
++				    struct zfcp_fsf_req *);
+ extern void zfcp_san_dbf_event_ct_request(struct zfcp_fsf_req *);
+ extern void zfcp_san_dbf_event_ct_response(struct zfcp_fsf_req *);
+ extern void zfcp_san_dbf_event_els_request(struct zfcp_fsf_req *);
+@@ -91,17 +92,21 @@ extern void zfcp_erp_port_access_denied(
+ extern void zfcp_erp_unit_access_denied(struct zfcp_unit *, u8, void *);
+ extern void zfcp_erp_adapter_access_changed(struct zfcp_adapter *, u8, void *);
+ extern void zfcp_erp_timeout_handler(unsigned long);
++extern void zfcp_erp_port_strategy_open_lookup(struct work_struct *);
+ 
+ /* zfcp_fc.c */
+ extern int zfcp_scan_ports(struct zfcp_adapter *);
+ extern void _zfcp_scan_ports_later(struct work_struct *);
+ extern void zfcp_fc_incoming_els(struct zfcp_fsf_req *);
+-extern int zfcp_fc_ns_gid_pn_request(struct zfcp_erp_action *);
++extern int zfcp_fc_ns_gid_pn(struct zfcp_erp_action *);
+ extern void zfcp_fc_plogi_evaluate(struct zfcp_port *, struct fsf_plogi *);
+ extern void zfcp_test_link(struct zfcp_port *);
++extern void zfcp_fc_nameserver_init(struct zfcp_adapter *);
+ 
+ /* zfcp_fsf.c */
+ extern int zfcp_fsf_open_port(struct zfcp_erp_action *);
++extern int zfcp_fsf_open_wka_port(struct zfcp_wka_port *);
++extern int zfcp_fsf_close_wka_port(struct zfcp_wka_port *);
+ extern int zfcp_fsf_close_port(struct zfcp_erp_action *);
+ extern int zfcp_fsf_close_physical_port(struct zfcp_erp_action *);
+ extern int zfcp_fsf_open_unit(struct zfcp_erp_action *);
+@@ -135,10 +140,8 @@ extern struct zfcp_fsf_req *zfcp_fsf_abo
+ extern int zfcp_qdio_allocate(struct zfcp_adapter *);
+ extern void zfcp_qdio_free(struct zfcp_adapter *);
+ extern int zfcp_qdio_send(struct zfcp_fsf_req *);
+-extern volatile struct qdio_buffer_element *zfcp_qdio_sbale_req(
+-						struct zfcp_fsf_req *);
+-extern volatile struct qdio_buffer_element *zfcp_qdio_sbale_curr(
+-						struct zfcp_fsf_req *);
++extern struct qdio_buffer_element *zfcp_qdio_sbale_req(struct zfcp_fsf_req *);
++extern struct qdio_buffer_element *zfcp_qdio_sbale_curr(struct zfcp_fsf_req *);
+ extern int zfcp_qdio_sbals_from_sg(struct zfcp_fsf_req *, unsigned long,
+ 				   struct scatterlist *, int);
+ extern int zfcp_qdio_open(struct zfcp_adapter *);
+@@ -148,14 +151,12 @@ extern void zfcp_qdio_close(struct zfcp_
+ extern struct zfcp_data zfcp_data;
+ extern int zfcp_adapter_scsi_register(struct zfcp_adapter *);
+ extern void zfcp_adapter_scsi_unregister(struct zfcp_adapter *);
+-extern void zfcp_set_fcp_dl(struct fcp_cmnd_iu *, fcp_dl_t);
+ extern char *zfcp_get_fcp_sns_info_ptr(struct fcp_rsp_iu *);
+ extern struct fc_function_template zfcp_transport_functions;
+ 
+ /* zfcp_sysfs.c */
+ extern struct attribute_group zfcp_sysfs_unit_attrs;
+ extern struct attribute_group zfcp_sysfs_adapter_attrs;
+-extern struct attribute_group zfcp_sysfs_ns_port_attrs;
+ extern struct attribute_group zfcp_sysfs_port_attrs;
+ extern struct device_attribute *zfcp_sysfs_sdev_attrs[];
+ extern struct device_attribute *zfcp_sysfs_shost_attrs[];
+Index: linux-2.6.27-gentoo-r7/drivers/s390/scsi/zfcp_fc.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/scsi/zfcp_fc.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/scsi/zfcp_fc.c
+@@ -39,6 +39,84 @@ struct zfcp_gpn_ft {
+ 	struct scatterlist sg_resp[ZFCP_GPN_FT_BUFFERS];
+ };
+ 
++struct zfcp_fc_ns_handler_data {
++	struct completion done;
++	void (*handler)(unsigned long);
++	unsigned long handler_data;
++};
++
++static int zfcp_wka_port_get(struct zfcp_wka_port *wka_port)
++{
++	if (mutex_lock_interruptible(&wka_port->mutex))
++		return -ERESTARTSYS;
++
++	if (wka_port->status != ZFCP_WKA_PORT_ONLINE) {
++		wka_port->status = ZFCP_WKA_PORT_OPENING;
++		if (zfcp_fsf_open_wka_port(wka_port))
++			wka_port->status = ZFCP_WKA_PORT_OFFLINE;
++	}
++
++	mutex_unlock(&wka_port->mutex);
++
++	wait_event_timeout(
++		wka_port->completion_wq,
++		wka_port->status == ZFCP_WKA_PORT_ONLINE ||
++		wka_port->status == ZFCP_WKA_PORT_OFFLINE,
++		HZ >> 1);
++
++	if (wka_port->status == ZFCP_WKA_PORT_ONLINE) {
++		atomic_inc(&wka_port->refcount);
++		return 0;
++	}
++	return -EIO;
++}
++
++static void zfcp_wka_port_offline(struct work_struct *work)
++{
++	struct delayed_work *dw = container_of(work, struct delayed_work, work);
++	struct zfcp_wka_port *wka_port =
++			container_of(dw, struct zfcp_wka_port, work);
++
++	wait_event(wka_port->completion_wq,
++			atomic_read(&wka_port->refcount) == 0);
++
++	mutex_lock(&wka_port->mutex);
++	if ((atomic_read(&wka_port->refcount) != 0) ||
++	    (wka_port->status != ZFCP_WKA_PORT_ONLINE))
++		goto out;
++
++	wka_port->status = ZFCP_WKA_PORT_CLOSING;
++	if (zfcp_fsf_close_wka_port(wka_port)) {
++		wka_port->status = ZFCP_WKA_PORT_OFFLINE;
++		wake_up(&wka_port->completion_wq);
++	}
++out:
++	mutex_unlock(&wka_port->mutex);
++}
++
++static void zfcp_wka_port_put(struct zfcp_wka_port *wka_port)
++{
++	if (atomic_dec_return(&wka_port->refcount) != 0)
++		return;
++	/* wait 10 miliseconds, other reqs might pop in */
++	schedule_delayed_work(&wka_port->work, HZ / 100);
++}
++
++void zfcp_fc_nameserver_init(struct zfcp_adapter *adapter)
++{
++	struct zfcp_wka_port *wka_port = &adapter->nsp;
++
++	init_waitqueue_head(&wka_port->completion_wq);
++
++	wka_port->adapter = adapter;
++	wka_port->d_id = ZFCP_DID_DIRECTORY_SERVICE;
++
++	wka_port->status = ZFCP_WKA_PORT_OFFLINE;
++	atomic_set(&wka_port->refcount, 0);
++	mutex_init(&wka_port->mutex);
++	INIT_DELAYED_WORK(&wka_port->work, zfcp_wka_port_offline);
++}
++
+ static void _zfcp_fc_incoming_rscn(struct zfcp_fsf_req *fsf_req, u32 range,
+ 				   struct fcp_rscn_element *elem)
+ {
+@@ -47,10 +125,7 @@ static void _zfcp_fc_incoming_rscn(struc
+ 
+ 	read_lock_irqsave(&zfcp_data.config_lock, flags);
+ 	list_for_each_entry(port, &fsf_req->adapter->port_list_head, list) {
+-		if (atomic_test_mask(ZFCP_STATUS_PORT_WKA, &port->status))
+-			continue;
+-		/* FIXME: ZFCP_STATUS_PORT_DID_DID check is racy */
+-		if (!atomic_test_mask(ZFCP_STATUS_PORT_DID_DID, &port->status))
++		if (!(atomic_read(&port->status) & ZFCP_STATUS_PORT_PHYS_OPEN))
+ 			/* Try to connect to unused ports anyway. */
+ 			zfcp_erp_port_reopen(port,
+ 					     ZFCP_STATUS_COMMON_ERP_FAILED,
+@@ -102,7 +177,7 @@ static void zfcp_fc_incoming_rscn(struct
+ 	schedule_work(&fsf_req->adapter->scan_work);
+ }
+ 
+-static void zfcp_fc_incoming_wwpn(struct zfcp_fsf_req *req, wwn_t wwpn)
++static void zfcp_fc_incoming_wwpn(struct zfcp_fsf_req *req, u64 wwpn)
+ {
+ 	struct zfcp_adapter *adapter = req->adapter;
+ 	struct zfcp_port *port;
+@@ -157,7 +232,18 @@ void zfcp_fc_incoming_els(struct zfcp_fs
+ 		zfcp_fc_incoming_rscn(fsf_req);
+ }
+ 
+-static void zfcp_ns_gid_pn_handler(unsigned long data)
++static void zfcp_fc_ns_handler(unsigned long data)
++{
++	struct zfcp_fc_ns_handler_data *compl_rec =
++			(struct zfcp_fc_ns_handler_data *) data;
++
++	if (compl_rec->handler)
++		compl_rec->handler(compl_rec->handler_data);
++
++	complete(&compl_rec->done);
++}
++
++static void zfcp_fc_ns_gid_pn_eval(unsigned long data)
+ {
+ 	struct zfcp_gid_pn_data *gid_pn = (struct zfcp_gid_pn_data *) data;
+ 	struct zfcp_send_ct *ct = &gid_pn->ct;
+@@ -166,43 +252,31 @@ static void zfcp_ns_gid_pn_handler(unsig
+ 	struct zfcp_port *port = gid_pn->port;
+ 
+ 	if (ct->status)
+-		goto out;
++		return;
+ 	if (ct_iu_resp->header.cmd_rsp_code != ZFCP_CT_ACCEPT) {
+ 		atomic_set_mask(ZFCP_STATUS_PORT_INVALID_WWPN, &port->status);
+-		goto out;
++		return;
+ 	}
+ 	/* paranoia */
+ 	if (ct_iu_req->wwpn != port->wwpn)
+-		goto out;
++		return;
+ 	/* looks like a valid d_id */
+ 	port->d_id = ct_iu_resp->d_id & ZFCP_DID_MASK;
+ 	atomic_set_mask(ZFCP_STATUS_PORT_DID_DID, &port->status);
+-out:
+-	mempool_free(gid_pn, port->adapter->pool.data_gid_pn);
+ }
+ 
+-/**
+- * zfcp_fc_ns_gid_pn_request - initiate GID_PN nameserver request
+- * @erp_action: pointer to zfcp_erp_action where GID_PN request is needed
+- * return: -ENOMEM on error, 0 otherwise
+- */
+-int zfcp_fc_ns_gid_pn_request(struct zfcp_erp_action *erp_action)
++int static zfcp_fc_ns_gid_pn_request(struct zfcp_erp_action *erp_action,
++				     struct zfcp_gid_pn_data *gid_pn)
+ {
+-	int ret;
+-	struct zfcp_gid_pn_data *gid_pn;
+ 	struct zfcp_adapter *adapter = erp_action->adapter;
+-
+-	gid_pn = mempool_alloc(adapter->pool.data_gid_pn, GFP_ATOMIC);
+-	if (!gid_pn)
+-		return -ENOMEM;
+-
+-	memset(gid_pn, 0, sizeof(*gid_pn));
++	struct zfcp_fc_ns_handler_data compl_rec;
++	int ret;
+ 
+ 	/* setup parameters for send generic command */
+ 	gid_pn->port = erp_action->port;
+-	gid_pn->ct.port = adapter->nameserver_port;
+-	gid_pn->ct.handler = zfcp_ns_gid_pn_handler;
+-	gid_pn->ct.handler_data = (unsigned long) gid_pn;
++	gid_pn->ct.wka_port = &adapter->nsp;
++	gid_pn->ct.handler = zfcp_fc_ns_handler;
++	gid_pn->ct.handler_data = (unsigned long) &compl_rec;
+ 	gid_pn->ct.timeout = ZFCP_NS_GID_PN_TIMEOUT;
+ 	gid_pn->ct.req = &gid_pn->req;
+ 	gid_pn->ct.resp = &gid_pn->resp;
+@@ -222,10 +296,42 @@ int zfcp_fc_ns_gid_pn_request(struct zfc
+ 	gid_pn->ct_iu_req.header.max_res_size = ZFCP_CT_MAX_SIZE;
+ 	gid_pn->ct_iu_req.wwpn = erp_action->port->wwpn;
+ 
++	init_completion(&compl_rec.done);
++	compl_rec.handler = zfcp_fc_ns_gid_pn_eval;
++	compl_rec.handler_data = (unsigned long) gid_pn;
+ 	ret = zfcp_fsf_send_ct(&gid_pn->ct, adapter->pool.fsf_req_erp,
+ 			       erp_action);
++	if (!ret)
++		wait_for_completion(&compl_rec.done);
++	return ret;
++}
++
++/**
++ * zfcp_fc_ns_gid_pn_request - initiate GID_PN nameserver request
++ * @erp_action: pointer to zfcp_erp_action where GID_PN request is needed
++ * return: -ENOMEM on error, 0 otherwise
++ */
++int zfcp_fc_ns_gid_pn(struct zfcp_erp_action *erp_action)
++{
++	int ret;
++	struct zfcp_gid_pn_data *gid_pn;
++	struct zfcp_adapter *adapter = erp_action->adapter;
++
++	gid_pn = mempool_alloc(adapter->pool.data_gid_pn, GFP_ATOMIC);
++	if (!gid_pn)
++		return -ENOMEM;
++
++	memset(gid_pn, 0, sizeof(*gid_pn));
++
++	ret = zfcp_wka_port_get(&adapter->nsp);
+ 	if (ret)
+-		mempool_free(gid_pn, adapter->pool.data_gid_pn);
++		goto out;
++
++	ret = zfcp_fc_ns_gid_pn_request(erp_action, gid_pn);
++
++	zfcp_wka_port_put(&adapter->nsp);
++out:
++	mempool_free(gid_pn, adapter->pool.data_gid_pn);
+ 	return ret;
+ }
+ 
+@@ -255,14 +361,14 @@ struct zfcp_els_adisc {
+ 	struct scatterlist req;
+ 	struct scatterlist resp;
+ 	struct zfcp_ls_adisc ls_adisc;
+-	struct zfcp_ls_adisc_acc ls_adisc_acc;
++	struct zfcp_ls_adisc ls_adisc_acc;
+ };
+ 
+ static void zfcp_fc_adisc_handler(unsigned long data)
+ {
+ 	struct zfcp_els_adisc *adisc = (struct zfcp_els_adisc *) data;
+ 	struct zfcp_port *port = adisc->els.port;
+-	struct zfcp_ls_adisc_acc *ls_adisc = &adisc->ls_adisc_acc;
++	struct zfcp_ls_adisc *ls_adisc = &adisc->ls_adisc_acc;
+ 
+ 	if (adisc->els.status) {
+ 		/* request rejected or timed out */
+@@ -295,7 +401,7 @@ static int zfcp_fc_adisc(struct zfcp_por
+ 	sg_init_one(adisc->els.req, &adisc->ls_adisc,
+ 		    sizeof(struct zfcp_ls_adisc));
+ 	sg_init_one(adisc->els.resp, &adisc->ls_adisc_acc,
+-		    sizeof(struct zfcp_ls_adisc_acc));
++		    sizeof(struct zfcp_ls_adisc));
+ 
+ 	adisc->els.req_count = 1;
+ 	adisc->els.resp_count = 1;
+@@ -338,30 +444,6 @@ void zfcp_test_link(struct zfcp_port *po
+ 		zfcp_erp_port_forced_reopen(port, 0, 65, NULL);
+ }
+ 
+-static int zfcp_scan_get_nameserver(struct zfcp_adapter *adapter)
+-{
+-	int ret;
+-
+-	if (!adapter->nameserver_port)
+-		return -EINTR;
+-
+-	if (!atomic_test_mask(ZFCP_STATUS_COMMON_UNBLOCKED,
+-			       &adapter->nameserver_port->status)) {
+-		ret = zfcp_erp_port_reopen(adapter->nameserver_port, 0, 148,
+-					   NULL);
+-		if (ret)
+-			return ret;
+-		zfcp_erp_wait(adapter);
+-	}
+-	return !atomic_test_mask(ZFCP_STATUS_COMMON_UNBLOCKED,
+-				  &adapter->nameserver_port->status);
+-}
+-
+-static void zfcp_gpn_ft_handler(unsigned long _done)
+-{
+-	complete((struct completion *)_done);
+-}
+-
+ static void zfcp_free_sg_env(struct zfcp_gpn_ft *gpn_ft)
+ {
+ 	struct scatterlist *sg = &gpn_ft->sg_req;
+@@ -403,7 +485,7 @@ static int zfcp_scan_issue_gpn_ft(struct
+ {
+ 	struct zfcp_send_ct *ct = &gpn_ft->ct;
+ 	struct ct_iu_gpn_ft_req *req = sg_virt(&gpn_ft->sg_req);
+-	struct completion done;
++	struct zfcp_fc_ns_handler_data compl_rec;
+ 	int ret;
+ 
+ 	/* prepare CT IU for GPN_FT */
+@@ -420,19 +502,20 @@ static int zfcp_scan_issue_gpn_ft(struct
+ 	req->fc4_type = ZFCP_CT_SCSI_FCP;
+ 
+ 	/* prepare zfcp_send_ct */
+-	ct->port = adapter->nameserver_port;
+-	ct->handler = zfcp_gpn_ft_handler;
+-	ct->handler_data = (unsigned long)&done;
++	ct->wka_port = &adapter->nsp;
++	ct->handler = zfcp_fc_ns_handler;
++	ct->handler_data = (unsigned long)&compl_rec;
+ 	ct->timeout = 10;
+ 	ct->req = &gpn_ft->sg_req;
+ 	ct->resp = gpn_ft->sg_resp;
+ 	ct->req_count = 1;
+ 	ct->resp_count = ZFCP_GPN_FT_BUFFERS;
+ 
+-	init_completion(&done);
++	init_completion(&compl_rec.done);
++	compl_rec.handler = NULL;
+ 	ret = zfcp_fsf_send_ct(ct, NULL, NULL);
+ 	if (!ret)
+-		wait_for_completion(&done);
++		wait_for_completion(&compl_rec.done);
+ 	return ret;
+ }
+ 
+@@ -442,9 +525,8 @@ static void zfcp_validate_port(struct zf
+ 
+ 	atomic_clear_mask(ZFCP_STATUS_COMMON_NOESC, &port->status);
+ 
+-	if (port == adapter->nameserver_port)
+-		return;
+-	if ((port->supported_classes != 0) || (port->units != 0)) {
++	if ((port->supported_classes != 0) ||
++	    !list_empty(&port->unit_list_head)) {
+ 		zfcp_port_put(port);
+ 		return;
+ 	}
+@@ -460,7 +542,7 @@ static int zfcp_scan_eval_gpn_ft(struct 
+ 	struct scatterlist *sg = gpn_ft->sg_resp;
+ 	struct ct_hdr *hdr = sg_virt(sg);
+ 	struct gpn_ft_resp_acc *acc = sg_virt(sg);
+-	struct zfcp_adapter *adapter = ct->port->adapter;
++	struct zfcp_adapter *adapter = ct->wka_port->adapter;
+ 	struct zfcp_port *port, *tmp;
+ 	u32 d_id;
+ 	int ret = 0, x, last = 0;
+@@ -490,6 +572,9 @@ static int zfcp_scan_eval_gpn_ft(struct 
+ 		d_id = acc->port_id[0] << 16 | acc->port_id[1] << 8 |
+ 		       acc->port_id[2];
+ 
++		/* don't attach ports with a well known address */
++		if ((d_id & ZFCP_DID_WKA) == ZFCP_DID_WKA)
++			continue;
+ 		/* skip the adapter's port and known remote ports */
+ 		if (acc->wwpn == fc_host_port_name(adapter->scsi_host))
+ 			continue;
+@@ -528,13 +613,15 @@ int zfcp_scan_ports(struct zfcp_adapter 
+ 	if (fc_host_port_type(adapter->scsi_host) != FC_PORTTYPE_NPORT)
+ 		return 0;
+ 
+-	ret = zfcp_scan_get_nameserver(adapter);
++	ret = zfcp_wka_port_get(&adapter->nsp);
+ 	if (ret)
+ 		return ret;
+ 
+ 	gpn_ft = zfcp_alloc_sg_env();
+-	if (!gpn_ft)
+-		return -ENOMEM;
++	if (!gpn_ft) {
++		ret = -ENOMEM;
++		goto out;
++	}
+ 
+ 	for (i = 0; i < 3; i++) {
+ 		ret = zfcp_scan_issue_gpn_ft(gpn_ft, adapter);
+@@ -547,7 +634,8 @@ int zfcp_scan_ports(struct zfcp_adapter 
+ 		}
+ 	}
+ 	zfcp_free_sg_env(gpn_ft);
+-
++out:
++	zfcp_wka_port_put(&adapter->nsp);
+ 	return ret;
+ }
+ 
+Index: linux-2.6.27-gentoo-r7/drivers/s390/scsi/zfcp_fsf.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/scsi/zfcp_fsf.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/scsi/zfcp_fsf.c
+@@ -50,19 +50,16 @@ static u32 fsf_qtcb_type[] = {
+ 	[FSF_QTCB_UPLOAD_CONTROL_FILE] =  FSF_SUPPORT_COMMAND
+ };
+ 
+-static const char *zfcp_act_subtable_type[] = {
+-	"unknown", "OS", "WWPN", "DID", "LUN"
+-};
+-
+ static void zfcp_act_eval_err(struct zfcp_adapter *adapter, u32 table)
+ {
+ 	u16 subtable = table >> 16;
+ 	u16 rule = table & 0xffff;
++	const char *act_type[] = { "unknown", "OS", "WWPN", "DID", "LUN" };
+ 
+-	if (subtable && subtable < ARRAY_SIZE(zfcp_act_subtable_type))
++	if (subtable && subtable < ARRAY_SIZE(act_type))
+ 		dev_warn(&adapter->ccw_device->dev,
+-			 "Access denied in subtable %s, rule %d.\n",
+-			 zfcp_act_subtable_type[subtable], rule);
++			 "Access denied according to ACT rule type %s, "
++			 "rule %d\n", act_type[subtable], rule);
+ }
+ 
+ static void zfcp_fsf_access_denied_port(struct zfcp_fsf_req *req,
+@@ -70,8 +67,8 @@ static void zfcp_fsf_access_denied_port(
+ {
+ 	struct fsf_qtcb_header *header = &req->qtcb->header;
+ 	dev_warn(&req->adapter->ccw_device->dev,
+-		 "Access denied, cannot send command to port 0x%016Lx.\n",
+-		 port->wwpn);
++		 "Access denied to port 0x%016Lx\n",
++		 (unsigned long long)port->wwpn);
+ 	zfcp_act_eval_err(req->adapter, header->fsf_status_qual.halfword[0]);
+ 	zfcp_act_eval_err(req->adapter, header->fsf_status_qual.halfword[1]);
+ 	zfcp_erp_port_access_denied(port, 55, req);
+@@ -83,8 +80,9 @@ static void zfcp_fsf_access_denied_unit(
+ {
+ 	struct fsf_qtcb_header *header = &req->qtcb->header;
+ 	dev_warn(&req->adapter->ccw_device->dev,
+-		 "Access denied for unit 0x%016Lx on port 0x%016Lx.\n",
+-		 unit->fcp_lun, unit->port->wwpn);
++		 "Access denied to unit 0x%016Lx on port 0x%016Lx\n",
++		 (unsigned long long)unit->fcp_lun,
++		 (unsigned long long)unit->port->wwpn);
+ 	zfcp_act_eval_err(req->adapter, header->fsf_status_qual.halfword[0]);
+ 	zfcp_act_eval_err(req->adapter, header->fsf_status_qual.halfword[1]);
+ 	zfcp_erp_unit_access_denied(unit, 59, req);
+@@ -93,9 +91,8 @@ static void zfcp_fsf_access_denied_unit(
+ 
+ static void zfcp_fsf_class_not_supp(struct zfcp_fsf_req *req)
+ {
+-	dev_err(&req->adapter->ccw_device->dev,
+-		"Required FC class not supported by adapter, "
+-		"shutting down adapter.\n");
++	dev_err(&req->adapter->ccw_device->dev, "FCP device not "
++		"operational because of an unsupported FC class\n");
+ 	zfcp_erp_adapter_shutdown(req->adapter, 0, 123, req);
+ 	req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ }
+@@ -171,42 +168,6 @@ static void zfcp_fsf_status_read_port_cl
+ 	read_unlock_irqrestore(&zfcp_data.config_lock, flags);
+ }
+ 
+-static void zfcp_fsf_bit_error_threshold(struct zfcp_fsf_req *req)
+-{
+-	struct zfcp_adapter *adapter = req->adapter;
+-	struct fsf_status_read_buffer *sr_buf = req->data;
+-	struct fsf_bit_error_payload *err = &sr_buf->payload.bit_error;
+-
+-	dev_warn(&adapter->ccw_device->dev,
+-		 "Warning: bit error threshold data "
+-		 "received for the adapter: "
+-		 "link failures = %i, loss of sync errors = %i, "
+-		 "loss of signal errors = %i, "
+-		 "primitive sequence errors = %i, "
+-		 "invalid transmission word errors = %i, "
+-		 "CRC errors = %i).\n",
+-		 err->link_failure_error_count,
+-		 err->loss_of_sync_error_count,
+-		 err->loss_of_signal_error_count,
+-		 err->primitive_sequence_error_count,
+-		 err->invalid_transmission_word_error_count,
+-		 err->crc_error_count);
+-	dev_warn(&adapter->ccw_device->dev,
+-		 "Additional bit error threshold data of the adapter: "
+-		 "primitive sequence event time-outs = %i, "
+-		 "elastic buffer overrun errors = %i, "
+-		 "advertised receive buffer-to-buffer credit = %i, "
+-		 "current receice buffer-to-buffer credit = %i, "
+-		 "advertised transmit buffer-to-buffer credit = %i, "
+-		 "current transmit buffer-to-buffer credit = %i).\n",
+-		 err->primitive_sequence_event_timeout_count,
+-		 err->elastic_buffer_overrun_error_count,
+-		 err->advertised_receive_b2b_credit,
+-		 err->current_receive_b2b_credit,
+-		 err->advertised_transmit_b2b_credit,
+-		 err->current_transmit_b2b_credit);
+-}
+-
+ static void zfcp_fsf_link_down_info_eval(struct zfcp_fsf_req *req, u8 id,
+ 					 struct fsf_link_down_info *link_down)
+ {
+@@ -223,62 +184,66 @@ static void zfcp_fsf_link_down_info_eval
+ 	switch (link_down->error_code) {
+ 	case FSF_PSQ_LINK_NO_LIGHT:
+ 		dev_warn(&req->adapter->ccw_device->dev,
+-			 "The local link is down: no light detected.\n");
++			 "There is no light signal from the local "
++			 "fibre channel cable\n");
+ 		break;
+ 	case FSF_PSQ_LINK_WRAP_PLUG:
+ 		dev_warn(&req->adapter->ccw_device->dev,
+-			 "The local link is down: wrap plug detected.\n");
++			 "There is a wrap plug instead of a fibre "
++			 "channel cable\n");
+ 		break;
+ 	case FSF_PSQ_LINK_NO_FCP:
+ 		dev_warn(&req->adapter->ccw_device->dev,
+-			 "The local link is down: "
+-			 "adjacent node on link does not support FCP.\n");
++			 "The adjacent fibre channel node does not "
++			 "support FCP\n");
+ 		break;
+ 	case FSF_PSQ_LINK_FIRMWARE_UPDATE:
+ 		dev_warn(&req->adapter->ccw_device->dev,
+-			 "The local link is down: "
+-			 "firmware update in progress.\n");
++			 "The FCP device is suspended because of a "
++			 "firmware update\n");
+ 		break;
+ 	case FSF_PSQ_LINK_INVALID_WWPN:
+ 		dev_warn(&req->adapter->ccw_device->dev,
+-			 "The local link is down: "
+-			 "duplicate or invalid WWPN detected.\n");
++			 "The FCP device detected a WWPN that is "
++			 "duplicate or not valid\n");
+ 		break;
+ 	case FSF_PSQ_LINK_NO_NPIV_SUPPORT:
+ 		dev_warn(&req->adapter->ccw_device->dev,
+-			 "The local link is down: "
+-			 "no support for NPIV by Fabric.\n");
++			 "The fibre channel fabric does not support NPIV\n");
+ 		break;
+ 	case FSF_PSQ_LINK_NO_FCP_RESOURCES:
+ 		dev_warn(&req->adapter->ccw_device->dev,
+-			 "The local link is down: "
+-			 "out of resource in FCP daughtercard.\n");
++			 "The FCP adapter cannot support more NPIV ports\n");
+ 		break;
+ 	case FSF_PSQ_LINK_NO_FABRIC_RESOURCES:
+ 		dev_warn(&req->adapter->ccw_device->dev,
+-			 "The local link is down: "
+-			 "out of resource in Fabric.\n");
++			 "The adjacent switch cannot support "
++			 "more NPIV ports\n");
+ 		break;
+ 	case FSF_PSQ_LINK_FABRIC_LOGIN_UNABLE:
+ 		dev_warn(&req->adapter->ccw_device->dev,
+-			 "The local link is down: "
+-			 "unable to login to Fabric.\n");
++			 "The FCP adapter could not log in to the "
++			 "fibre channel fabric\n");
+ 		break;
+ 	case FSF_PSQ_LINK_WWPN_ASSIGNMENT_CORRUPTED:
+ 		dev_warn(&req->adapter->ccw_device->dev,
+-			 "WWPN assignment file corrupted on adapter.\n");
++			 "The WWPN assignment file on the FCP adapter "
++			 "has been damaged\n");
+ 		break;
+ 	case FSF_PSQ_LINK_MODE_TABLE_CURRUPTED:
+ 		dev_warn(&req->adapter->ccw_device->dev,
+-			 "Mode table corrupted on adapter.\n");
++			 "The mode table on the FCP adapter "
++			 "has been damaged\n");
+ 		break;
+ 	case FSF_PSQ_LINK_NO_WWPN_ASSIGNMENT:
+ 		dev_warn(&req->adapter->ccw_device->dev,
+-			 "No WWPN for assignment table on adapter.\n");
++			 "All NPIV ports on the FCP adapter have "
++			 "been assigned\n");
+ 		break;
+ 	default:
+ 		dev_warn(&req->adapter->ccw_device->dev,
+-			 "The local link to adapter is down.\n");
++			 "The link between the FCP adapter and "
++			 "the FC fabric is down\n");
+ 	}
+ out:
+ 	zfcp_erp_adapter_failed(adapter, id, req);
+@@ -286,27 +251,18 @@ out:
+ 
+ static void zfcp_fsf_status_read_link_down(struct zfcp_fsf_req *req)
+ {
+-	struct zfcp_adapter *adapter = req->adapter;
+ 	struct fsf_status_read_buffer *sr_buf = req->data;
+ 	struct fsf_link_down_info *ldi =
+ 		(struct fsf_link_down_info *) &sr_buf->payload;
+ 
+ 	switch (sr_buf->status_subtype) {
+ 	case FSF_STATUS_READ_SUB_NO_PHYSICAL_LINK:
+-		dev_warn(&adapter->ccw_device->dev,
+-			 "Physical link is down.\n");
+ 		zfcp_fsf_link_down_info_eval(req, 38, ldi);
+ 		break;
+ 	case FSF_STATUS_READ_SUB_FDISC_FAILED:
+-		dev_warn(&adapter->ccw_device->dev,
+-			 "Local link is down "
+-			 "due to failed FDISC login.\n");
+ 		zfcp_fsf_link_down_info_eval(req, 39, ldi);
+ 		break;
+ 	case FSF_STATUS_READ_SUB_FIRMWARE_UPDATE:
+-		dev_warn(&adapter->ccw_device->dev,
+-			 "Local link is down "
+-			 "due to firmware update on adapter.\n");
+ 		zfcp_fsf_link_down_info_eval(req, 40, NULL);
+ 	};
+ }
+@@ -335,14 +291,17 @@ static void zfcp_fsf_status_read_handler
+ 	case FSF_STATUS_READ_SENSE_DATA_AVAIL:
+ 		break;
+ 	case FSF_STATUS_READ_BIT_ERROR_THRESHOLD:
+-		zfcp_fsf_bit_error_threshold(req);
++		dev_warn(&adapter->ccw_device->dev,
++			 "The error threshold for checksum statistics "
++			 "has been exceeded\n");
++		zfcp_hba_dbf_event_berr(adapter, req);
+ 		break;
+ 	case FSF_STATUS_READ_LINK_DOWN:
+ 		zfcp_fsf_status_read_link_down(req);
+ 		break;
+ 	case FSF_STATUS_READ_LINK_UP:
+ 		dev_info(&adapter->ccw_device->dev,
+-			 "Local link was replugged.\n");
++			 "The local link has been restored\n");
+ 		/* All ports should be marked as ready to run again */
+ 		zfcp_erp_modify_adapter_status(adapter, 30, NULL,
+ 					       ZFCP_STATUS_COMMON_RUNNING,
+@@ -370,7 +329,7 @@ static void zfcp_fsf_status_read_handler
+ 	zfcp_fsf_req_free(req);
+ 
+ 	atomic_inc(&adapter->stat_miss);
+-	schedule_work(&adapter->stat_work);
++	queue_work(zfcp_data.work_queue, &adapter->stat_work);
+ }
+ 
+ static void zfcp_fsf_fsfstatus_qual_eval(struct zfcp_fsf_req *req)
+@@ -386,8 +345,8 @@ static void zfcp_fsf_fsfstatus_qual_eval
+ 		break;
+ 	case FSF_SQ_NO_RECOM:
+ 		dev_err(&req->adapter->ccw_device->dev,
+-			"No recommendation could be given for a "
+-			"problem on the adapter.\n");
++			"The FCP adapter reported a problem "
++			"that cannot be recovered\n");
+ 		zfcp_erp_adapter_shutdown(req->adapter, 0, 121, req);
+ 		break;
+ 	}
+@@ -403,8 +362,7 @@ static void zfcp_fsf_fsfstatus_eval(stru
+ 	switch (req->qtcb->header.fsf_status) {
+ 	case FSF_UNKNOWN_COMMAND:
+ 		dev_err(&req->adapter->ccw_device->dev,
+-			"Command issued by the device driver (0x%x) is "
+-			"not known by the adapter.\n",
++			"The FCP adapter does not recognize the command 0x%x\n",
+ 			req->qtcb->header.fsf_command);
+ 		zfcp_erp_adapter_shutdown(req->adapter, 0, 120, req);
+ 		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+@@ -435,11 +393,9 @@ static void zfcp_fsf_protstatus_eval(str
+ 		return;
+ 	case FSF_PROT_QTCB_VERSION_ERROR:
+ 		dev_err(&adapter->ccw_device->dev,
+-			"The QTCB version requested by zfcp (0x%x) is not "
+-			"supported by the FCP adapter (lowest supported "
+-			"0x%x, highest supported 0x%x).\n",
+-			FSF_QTCB_CURRENT_VERSION, psq->word[0],
+-			psq->word[1]);
++			"QTCB version 0x%x not supported by FCP adapter "
++			"(0x%x to 0x%x)\n", FSF_QTCB_CURRENT_VERSION,
++			psq->word[0], psq->word[1]);
+ 		zfcp_erp_adapter_shutdown(adapter, 0, 117, req);
+ 		break;
+ 	case FSF_PROT_ERROR_STATE:
+@@ -449,8 +405,7 @@ static void zfcp_fsf_protstatus_eval(str
+ 		break;
+ 	case FSF_PROT_UNSUPP_QTCB_TYPE:
+ 		dev_err(&adapter->ccw_device->dev,
+-			"Packet header type used by the device driver is "
+-			"incompatible with that used on the adapter.\n");
++			"The QTCB type is not supported by the FCP adapter\n");
+ 		zfcp_erp_adapter_shutdown(adapter, 0, 118, req);
+ 		break;
+ 	case FSF_PROT_HOST_CONNECTION_INITIALIZING:
+@@ -459,7 +414,7 @@ static void zfcp_fsf_protstatus_eval(str
+ 		break;
+ 	case FSF_PROT_DUPLICATE_REQUEST_ID:
+ 		dev_err(&adapter->ccw_device->dev,
+-			"The request identifier 0x%Lx is ambiguous.\n",
++			"0x%Lx is an ambiguous request identifier\n",
+ 			(unsigned long long)qtcb->bottom.support.req_handle);
+ 		zfcp_erp_adapter_shutdown(adapter, 0, 78, req);
+ 		break;
+@@ -479,9 +434,7 @@ static void zfcp_fsf_protstatus_eval(str
+ 		break;
+ 	default:
+ 		dev_err(&adapter->ccw_device->dev,
+-			"Transfer protocol status information"
+-			"provided by the adapter (0x%x) "
+-			"is not compatible with the device driver.\n",
++			"0x%x is not a valid transfer protocol status\n",
+ 			qtcb->prefix.prot_status);
+ 		zfcp_erp_adapter_shutdown(adapter, 0, 119, req);
+ 	}
+@@ -559,33 +512,17 @@ static int zfcp_fsf_exchange_config_eval
+ 		adapter->peer_wwpn = bottom->plogi_payload.wwpn;
+ 		adapter->peer_wwnn = bottom->plogi_payload.wwnn;
+ 		fc_host_port_type(shost) = FC_PORTTYPE_PTP;
+-		if (req->erp_action)
+-			dev_info(&adapter->ccw_device->dev,
+-				 "Point-to-Point fibrechannel "
+-				 "configuration detected.\n");
+ 		break;
+ 	case FSF_TOPO_FABRIC:
+ 		fc_host_port_type(shost) = FC_PORTTYPE_NPORT;
+-		if (req->erp_action)
+-			dev_info(&adapter->ccw_device->dev,
+-				 "Switched fabric fibrechannel "
+-				 "network detected.\n");
+ 		break;
+ 	case FSF_TOPO_AL:
+ 		fc_host_port_type(shost) = FC_PORTTYPE_NLPORT;
+-		dev_err(&adapter->ccw_device->dev,
+-			"Unsupported arbitrated loop fibrechannel "
+-			"topology detected, shutting down "
+-			"adapter.\n");
+-		zfcp_erp_adapter_shutdown(adapter, 0, 127, req);
+-		return -EIO;
+ 	default:
+-		fc_host_port_type(shost) = FC_PORTTYPE_UNKNOWN;
+ 		dev_err(&adapter->ccw_device->dev,
+-			"The fibrechannel topology reported by the"
+-			" adapter is not known by the zfcp driver,"
+-			" shutting down adapter.\n");
+-		zfcp_erp_adapter_shutdown(adapter, 0, 128, req);
++			"Unknown or unsupported arbitrated loop "
++			"fibre channel topology detected\n");
++		zfcp_erp_adapter_shutdown(adapter, 0, 127, req);
+ 		return -EIO;
+ 	}
+ 
+@@ -616,11 +553,9 @@ static void zfcp_fsf_exchange_config_dat
+ 
+ 		if (bottom->max_qtcb_size < sizeof(struct fsf_qtcb)) {
+ 			dev_err(&adapter->ccw_device->dev,
+-				"Maximum QTCB size (%d bytes) allowed by "
+-				"the adapter is lower than the minimum "
+-				"required by the driver (%ld bytes).\n",
+-				bottom->max_qtcb_size,
+-				sizeof(struct fsf_qtcb));
++				"FCP adapter maximum QTCB size (%d bytes) "
++				"is too small\n",
++				bottom->max_qtcb_size);
+ 			zfcp_erp_adapter_shutdown(adapter, 0, 129, req);
+ 			return;
+ 		}
+@@ -656,15 +591,15 @@ static void zfcp_fsf_exchange_config_dat
+ 
+ 	if (FSF_QTCB_CURRENT_VERSION < bottom->low_qtcb_version) {
+ 		dev_err(&adapter->ccw_device->dev,
+-			"The adapter only supports newer control block "
+-			"versions, try updated device driver.\n");
++			"The FCP adapter only supports newer "
++			"control block versions\n");
+ 		zfcp_erp_adapter_shutdown(adapter, 0, 125, req);
+ 		return;
+ 	}
+ 	if (FSF_QTCB_CURRENT_VERSION > bottom->high_qtcb_version) {
+ 		dev_err(&adapter->ccw_device->dev,
+-			"The adapter only supports older control block "
+-			"versions, consider a microcode upgrade.\n");
++			"The FCP adapter only supports older "
++			"control block versions\n");
+ 		zfcp_erp_adapter_shutdown(adapter, 0, 126, req);
+ 	}
+ }
+@@ -688,7 +623,6 @@ static void zfcp_fsf_exchange_port_evalu
+ 
+ static void zfcp_fsf_exchange_port_data_handler(struct zfcp_fsf_req *req)
+ {
+-	struct zfcp_adapter *adapter = req->adapter;
+ 	struct fsf_qtcb *qtcb = req->qtcb;
+ 
+ 	if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
+@@ -697,38 +631,47 @@ static void zfcp_fsf_exchange_port_data_
+ 	switch (qtcb->header.fsf_status) {
+ 	case FSF_GOOD:
+ 		zfcp_fsf_exchange_port_evaluate(req);
+-		atomic_set_mask(ZFCP_STATUS_ADAPTER_XPORT_OK, &adapter->status);
+ 		break;
+ 	case FSF_EXCHANGE_CONFIG_DATA_INCOMPLETE:
+ 		zfcp_fsf_exchange_port_evaluate(req);
+-		atomic_set_mask(ZFCP_STATUS_ADAPTER_XPORT_OK, &adapter->status);
+ 		zfcp_fsf_link_down_info_eval(req, 43,
+ 			&qtcb->header.fsf_status_qual.link_down_info);
+ 		break;
+ 	}
+ }
+ 
+-static int zfcp_fsf_sbal_check(struct zfcp_qdio_queue *queue)
++static int zfcp_fsf_sbal_check(struct zfcp_adapter *adapter)
+ {
+-	spin_lock_bh(&queue->lock);
+-	if (atomic_read(&queue->count))
++	struct zfcp_qdio_queue *req_q = &adapter->req_q;
++
++	spin_lock_bh(&adapter->req_q_lock);
++	if (atomic_read(&req_q->count))
+ 		return 1;
+-	spin_unlock_bh(&queue->lock);
++	spin_unlock_bh(&adapter->req_q_lock);
+ 	return 0;
+ }
+ 
++static int zfcp_fsf_sbal_available(struct zfcp_adapter *adapter)
++{
++	unsigned int count = atomic_read(&adapter->req_q.count);
++	if (!count)
++		atomic_inc(&adapter->qdio_outb_full);
++	return count > 0;
++}
++
+ static int zfcp_fsf_req_sbal_get(struct zfcp_adapter *adapter)
+ {
+ 	long ret;
+-	struct zfcp_qdio_queue *req_q = &adapter->req_q;
+ 
+-	spin_unlock_bh(&req_q->lock);
++	spin_unlock_bh(&adapter->req_q_lock);
+ 	ret = wait_event_interruptible_timeout(adapter->request_wq,
+-					zfcp_fsf_sbal_check(req_q), 5 * HZ);
++					zfcp_fsf_sbal_check(adapter), 5 * HZ);
+ 	if (ret > 0)
+ 		return 0;
++	if (!ret)
++		atomic_inc(&adapter->qdio_outb_full);
+ 
+-	spin_lock_bh(&req_q->lock);
++	spin_lock_bh(&adapter->req_q_lock);
+ 	return -EIO;
+ }
+ 
+@@ -739,6 +682,7 @@ static struct zfcp_fsf_req *zfcp_fsf_all
+ 	if (!req)
+ 		return NULL;
+ 	memset(req, 0, sizeof(*req));
++	req->pool = pool;
+ 	return req;
+ }
+ 
+@@ -765,7 +709,7 @@ static struct zfcp_fsf_req *zfcp_fsf_req
+ 						u32 fsf_cmd, int req_flags,
+ 						mempool_t *pool)
+ {
+-	volatile struct qdio_buffer_element *sbale;
++	struct qdio_buffer_element *sbale;
+ 
+ 	struct zfcp_fsf_req *req;
+ 	struct zfcp_qdio_queue *req_q = &adapter->req_q;
+@@ -825,27 +769,23 @@ static struct zfcp_fsf_req *zfcp_fsf_req
+ static int zfcp_fsf_req_send(struct zfcp_fsf_req *req)
+ {
+ 	struct zfcp_adapter *adapter = req->adapter;
+-	struct zfcp_qdio_queue *req_q = &adapter->req_q;
++	unsigned long flags;
+ 	int idx;
+ 
+ 	/* put allocated FSF request into hash table */
+-	spin_lock(&adapter->req_list_lock);
++	spin_lock_irqsave(&adapter->req_list_lock, flags);
+ 	idx = zfcp_reqlist_hash(req->req_id);
+ 	list_add_tail(&req->list, &adapter->req_list[idx]);
+-	spin_unlock(&adapter->req_list_lock);
++	spin_unlock_irqrestore(&adapter->req_list_lock, flags);
+ 
+ 	req->issued = get_clock();
+ 	if (zfcp_qdio_send(req)) {
+-		/* Queues are down..... */
+ 		del_timer(&req->timer);
+-		spin_lock(&adapter->req_list_lock);
+-		zfcp_reqlist_remove(adapter, req);
+-		spin_unlock(&adapter->req_list_lock);
+-		/* undo changes in request queue made for this request */
+-		atomic_add(req->sbal_number, &req_q->count);
+-		req_q->first -= req->sbal_number;
+-		req_q->first += QDIO_MAX_BUFFERS_PER_Q;
+-		req_q->first %= QDIO_MAX_BUFFERS_PER_Q; /* wrap */
++		spin_lock_irqsave(&adapter->req_list_lock, flags);
++		/* lookup request again, list might have changed */
++		if (zfcp_reqlist_find_safe(adapter, req))
++			zfcp_reqlist_remove(adapter, req);
++		spin_unlock_irqrestore(&adapter->req_list_lock, flags);
+ 		zfcp_erp_adapter_reopen(adapter, 0, 116, req);
+ 		return -EIO;
+ 	}
+@@ -867,10 +807,10 @@ int zfcp_fsf_status_read(struct zfcp_ada
+ {
+ 	struct zfcp_fsf_req *req;
+ 	struct fsf_status_read_buffer *sr_buf;
+-	volatile struct qdio_buffer_element *sbale;
++	struct qdio_buffer_element *sbale;
+ 	int retval = -EIO;
+ 
+-	spin_lock_bh(&adapter->req_q.lock);
++	spin_lock_bh(&adapter->req_q_lock);
+ 	if (zfcp_fsf_req_sbal_get(adapter))
+ 		goto out;
+ 
+@@ -910,7 +850,7 @@ failed_buf:
+ 	zfcp_fsf_req_free(req);
+ 	zfcp_hba_dbf_event_fsf_unsol("fail", adapter, NULL);
+ out:
+-	spin_unlock_bh(&adapter->req_q.lock);
++	spin_unlock_bh(&adapter->req_q_lock);
+ 	return retval;
+ }
+ 
+@@ -980,11 +920,11 @@ struct zfcp_fsf_req *zfcp_fsf_abort_fcp_
+ 						struct zfcp_unit *unit,
+ 						int req_flags)
+ {
+-	volatile struct qdio_buffer_element *sbale;
++	struct qdio_buffer_element *sbale;
+ 	struct zfcp_fsf_req *req = NULL;
+ 
+-	spin_lock(&adapter->req_q.lock);
+-	if (!atomic_read(&adapter->req_q.count))
++	spin_lock(&adapter->req_q_lock);
++	if (!zfcp_fsf_sbal_available(adapter))
+ 		goto out;
+ 	req = zfcp_fsf_req_create(adapter, FSF_QTCB_ABORT_FCP_CMND,
+ 				  req_flags, adapter->pool.fsf_req_abort);
+@@ -1013,7 +953,7 @@ out_error_free:
+ 	zfcp_fsf_req_free(req);
+ 	req = NULL;
+ out:
+-	spin_unlock(&adapter->req_q.lock);
++	spin_unlock(&adapter->req_q_lock);
+ 	return req;
+ }
+ 
+@@ -1021,7 +961,6 @@ static void zfcp_fsf_send_ct_handler(str
+ {
+ 	struct zfcp_adapter *adapter = req->adapter;
+ 	struct zfcp_send_ct *send_ct = req->data;
+-	struct zfcp_port *port = send_ct->port;
+ 	struct fsf_qtcb_header *header = &req->qtcb->header;
+ 
+ 	send_ct->status = -EINVAL;
+@@ -1040,17 +979,14 @@ static void zfcp_fsf_send_ct_handler(str
+         case FSF_ADAPTER_STATUS_AVAILABLE:
+                 switch (header->fsf_status_qual.word[0]){
+                 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
+-			zfcp_test_link(port);
+                 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
+ 			req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ 			break;
+                 }
+                 break;
+ 	case FSF_ACCESS_DENIED:
+-		zfcp_fsf_access_denied_port(req, port);
+ 		break;
+         case FSF_PORT_BOXED:
+-		zfcp_erp_port_boxed(port, 49, req);
+ 		req->status |= ZFCP_STATUS_FSFREQ_ERROR |
+ 			       ZFCP_STATUS_FSFREQ_RETRY;
+ 		break;
+@@ -1101,12 +1037,12 @@ static int zfcp_fsf_setup_sbals(struct z
+ int zfcp_fsf_send_ct(struct zfcp_send_ct *ct, mempool_t *pool,
+ 		     struct zfcp_erp_action *erp_action)
+ {
+-	struct zfcp_port *port = ct->port;
+-	struct zfcp_adapter *adapter = port->adapter;
++	struct zfcp_wka_port *wka_port = ct->wka_port;
++	struct zfcp_adapter *adapter = wka_port->adapter;
+ 	struct zfcp_fsf_req *req;
+ 	int ret = -EIO;
+ 
+-	spin_lock_bh(&adapter->req_q.lock);
++	spin_lock_bh(&adapter->req_q_lock);
+ 	if (zfcp_fsf_req_sbal_get(adapter))
+ 		goto out;
+ 
+@@ -1123,7 +1059,7 @@ int zfcp_fsf_send_ct(struct zfcp_send_ct
+ 		goto failed_send;
+ 
+ 	req->handler = zfcp_fsf_send_ct_handler;
+-	req->qtcb->header.port_handle = port->handle;
++	req->qtcb->header.port_handle = wka_port->handle;
+ 	req->qtcb->bottom.support.service_class = FSF_CLASS_3;
+ 	req->qtcb->bottom.support.timeout = ct->timeout;
+ 	req->data = ct;
+@@ -1148,7 +1084,7 @@ failed_send:
+ 	if (erp_action)
+ 		erp_action->fsf_req = NULL;
+ out:
+-	spin_unlock_bh(&adapter->req_q.lock);
++	spin_unlock_bh(&adapter->req_q_lock);
+ 	return ret;
+ }
+ 
+@@ -1218,8 +1154,8 @@ int zfcp_fsf_send_els(struct zfcp_send_e
+ 		       ZFCP_STATUS_COMMON_UNBLOCKED)))
+ 		return -EBUSY;
+ 
+-	spin_lock(&adapter->req_q.lock);
+-	if (!atomic_read(&adapter->req_q.count))
++	spin_lock(&adapter->req_q_lock);
++	if (!zfcp_fsf_sbal_available(adapter))
+ 		goto out;
+ 	req = zfcp_fsf_req_create(adapter, FSF_QTCB_SEND_ELS,
+ 				  ZFCP_REQ_AUTO_CLEANUP, NULL);
+@@ -1228,8 +1164,8 @@ int zfcp_fsf_send_els(struct zfcp_send_e
+ 		goto out;
+ 	}
+ 
+-	ret = zfcp_fsf_setup_sbals(req, els->req, els->resp,
+-				   FSF_MAX_SBALS_PER_ELS_REQ);
++	ret = zfcp_fsf_setup_sbals(req, els->req, els->resp, 2);
++
+ 	if (ret)
+ 		goto failed_send;
+ 
+@@ -1252,19 +1188,19 @@ int zfcp_fsf_send_els(struct zfcp_send_e
+ failed_send:
+ 	zfcp_fsf_req_free(req);
+ out:
+-	spin_unlock(&adapter->req_q.lock);
++	spin_unlock(&adapter->req_q_lock);
+ 	return ret;
+ }
+ 
+ int zfcp_fsf_exchange_config_data(struct zfcp_erp_action *erp_action)
+ {
+-	volatile struct qdio_buffer_element *sbale;
++	struct qdio_buffer_element *sbale;
+ 	struct zfcp_fsf_req *req;
+ 	struct zfcp_adapter *adapter = erp_action->adapter;
+ 	int retval = -EIO;
+ 
+-	spin_lock_bh(&adapter->req_q.lock);
+-	if (!atomic_read(&adapter->req_q.count))
++	spin_lock_bh(&adapter->req_q_lock);
++	if (!zfcp_fsf_sbal_available(adapter))
+ 		goto out;
+ 	req = zfcp_fsf_req_create(adapter,
+ 				  FSF_QTCB_EXCHANGE_CONFIG_DATA,
+@@ -1295,18 +1231,18 @@ int zfcp_fsf_exchange_config_data(struct
+ 		erp_action->fsf_req = NULL;
+ 	}
+ out:
+-	spin_unlock_bh(&adapter->req_q.lock);
++	spin_unlock_bh(&adapter->req_q_lock);
+ 	return retval;
+ }
+ 
+ int zfcp_fsf_exchange_config_data_sync(struct zfcp_adapter *adapter,
+ 				       struct fsf_qtcb_bottom_config *data)
+ {
+-	volatile struct qdio_buffer_element *sbale;
++	struct qdio_buffer_element *sbale;
+ 	struct zfcp_fsf_req *req = NULL;
+ 	int retval = -EIO;
+ 
+-	spin_lock_bh(&adapter->req_q.lock);
++	spin_lock_bh(&adapter->req_q_lock);
+ 	if (zfcp_fsf_req_sbal_get(adapter))
+ 		goto out;
+ 
+@@ -1334,7 +1270,7 @@ int zfcp_fsf_exchange_config_data_sync(s
+ 	zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
+ 	retval = zfcp_fsf_req_send(req);
+ out:
+-	spin_unlock_bh(&adapter->req_q.lock);
++	spin_unlock_bh(&adapter->req_q_lock);
+ 	if (!retval)
+ 		wait_event(req->completion_wq,
+ 			   req->status & ZFCP_STATUS_FSFREQ_COMPLETED);
+@@ -1351,7 +1287,7 @@ out:
+  */
+ int zfcp_fsf_exchange_port_data(struct zfcp_erp_action *erp_action)
+ {
+-	volatile struct qdio_buffer_element *sbale;
++	struct qdio_buffer_element *sbale;
+ 	struct zfcp_fsf_req *req;
+ 	struct zfcp_adapter *adapter = erp_action->adapter;
+ 	int retval = -EIO;
+@@ -1359,8 +1295,8 @@ int zfcp_fsf_exchange_port_data(struct z
+ 	if (!(adapter->adapter_features & FSF_FEATURE_HBAAPI_MANAGEMENT))
+ 		return -EOPNOTSUPP;
+ 
+-	spin_lock_bh(&adapter->req_q.lock);
+-	if (!atomic_read(&adapter->req_q.count))
++	spin_lock_bh(&adapter->req_q_lock);
++	if (!zfcp_fsf_sbal_available(adapter))
+ 		goto out;
+ 	req = zfcp_fsf_req_create(adapter, FSF_QTCB_EXCHANGE_PORT_DATA,
+ 				  ZFCP_REQ_AUTO_CLEANUP,
+@@ -1385,7 +1321,7 @@ int zfcp_fsf_exchange_port_data(struct z
+ 		erp_action->fsf_req = NULL;
+ 	}
+ out:
+-	spin_unlock_bh(&adapter->req_q.lock);
++	spin_unlock_bh(&adapter->req_q_lock);
+ 	return retval;
+ }
+ 
+@@ -1398,15 +1334,15 @@ out:
+ int zfcp_fsf_exchange_port_data_sync(struct zfcp_adapter *adapter,
+ 				     struct fsf_qtcb_bottom_port *data)
+ {
+-	volatile struct qdio_buffer_element *sbale;
++	struct qdio_buffer_element *sbale;
+ 	struct zfcp_fsf_req *req = NULL;
+ 	int retval = -EIO;
+ 
+ 	if (!(adapter->adapter_features & FSF_FEATURE_HBAAPI_MANAGEMENT))
+ 		return -EOPNOTSUPP;
+ 
+-	spin_lock_bh(&adapter->req_q.lock);
+-	if (!atomic_read(&adapter->req_q.count))
++	spin_lock_bh(&adapter->req_q_lock);
++	if (!zfcp_fsf_sbal_available(adapter))
+ 		goto out;
+ 
+ 	req = zfcp_fsf_req_create(adapter, FSF_QTCB_EXCHANGE_PORT_DATA, 0,
+@@ -1427,7 +1363,7 @@ int zfcp_fsf_exchange_port_data_sync(str
+ 	zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
+ 	retval = zfcp_fsf_req_send(req);
+ out:
+-	spin_unlock_bh(&adapter->req_q.lock);
++	spin_unlock_bh(&adapter->req_q_lock);
+ 	if (!retval)
+ 		wait_event(req->completion_wq,
+ 			   req->status & ZFCP_STATUS_FSFREQ_COMPLETED);
+@@ -1443,7 +1379,7 @@ static void zfcp_fsf_open_port_handler(s
+ 	struct fsf_plogi *plogi;
+ 
+ 	if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
+-		goto skip_fsfstatus;
++		return;
+ 
+ 	switch (header->fsf_status) {
+ 	case FSF_PORT_ALREADY_OPEN:
+@@ -1453,9 +1389,9 @@ static void zfcp_fsf_open_port_handler(s
+ 		break;
+ 	case FSF_MAXIMUM_NUMBER_OF_PORTS_EXCEEDED:
+ 		dev_warn(&req->adapter->ccw_device->dev,
+-			 "The adapter is out of resources. The remote port "
+-			 "0x%016Lx could not be opened, disabling it.\n",
+-			 port->wwpn);
++			 "Not enough FCP adapter resources to open "
++			 "remote port 0x%016Lx\n",
++			 (unsigned long long)port->wwpn);
+ 		zfcp_erp_port_failed(port, 31, req);
+ 		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ 		break;
+@@ -1467,8 +1403,8 @@ static void zfcp_fsf_open_port_handler(s
+ 			break;
+ 		case FSF_SQ_NO_RETRY_POSSIBLE:
+ 			dev_warn(&req->adapter->ccw_device->dev,
+-				 "The remote port 0x%016Lx could not be "
+-				 "opened. Disabling it.\n", port->wwpn);
++				 "Remote port 0x%016Lx could not be opened\n",
++				 (unsigned long long)port->wwpn);
+ 			zfcp_erp_port_failed(port, 32, req);
+ 			req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ 			break;
+@@ -1496,9 +1432,6 @@ static void zfcp_fsf_open_port_handler(s
+ 		 * another GID_PN straight after a port has been opened.
+ 		 * Alternately, an ADISC/PDISC ELS should suffice, as well.
+ 		 */
+-		if (atomic_read(&port->status) & ZFCP_STATUS_PORT_NO_WWPN)
+-			break;
+-
+ 		plogi = (struct fsf_plogi *) req->qtcb->bottom.support.els;
+ 		if (req->qtcb->bottom.support.els1_length >= sizeof(*plogi)) {
+ 			if (plogi->serv_param.wwpn != port->wwpn)
+@@ -1514,9 +1447,6 @@ static void zfcp_fsf_open_port_handler(s
+ 		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ 		break;
+ 	}
+-
+-skip_fsfstatus:
+-	atomic_clear_mask(ZFCP_STATUS_COMMON_OPENING, &port->status);
+ }
+ 
+ /**
+@@ -1526,12 +1456,12 @@ skip_fsfstatus:
+  */
+ int zfcp_fsf_open_port(struct zfcp_erp_action *erp_action)
+ {
+-	volatile struct qdio_buffer_element *sbale;
++	struct qdio_buffer_element *sbale;
+ 	struct zfcp_adapter *adapter = erp_action->adapter;
+ 	struct zfcp_fsf_req *req;
+ 	int retval = -EIO;
+ 
+-	spin_lock_bh(&adapter->req_q.lock);
++	spin_lock_bh(&adapter->req_q_lock);
+ 	if (zfcp_fsf_req_sbal_get(adapter))
+ 		goto out;
+ 
+@@ -1553,7 +1483,6 @@ int zfcp_fsf_open_port(struct zfcp_erp_a
+ 	req->data = erp_action->port;
+ 	req->erp_action = erp_action;
+ 	erp_action->fsf_req = req;
+-	atomic_set_mask(ZFCP_STATUS_COMMON_OPENING, &erp_action->port->status);
+ 
+ 	zfcp_fsf_start_erp_timer(req);
+ 	retval = zfcp_fsf_req_send(req);
+@@ -1562,7 +1491,7 @@ int zfcp_fsf_open_port(struct zfcp_erp_a
+ 		erp_action->fsf_req = NULL;
+ 	}
+ out:
+-	spin_unlock_bh(&adapter->req_q.lock);
++	spin_unlock_bh(&adapter->req_q_lock);
+ 	return retval;
+ }
+ 
+@@ -1571,7 +1500,7 @@ static void zfcp_fsf_close_port_handler(
+ 	struct zfcp_port *port = req->data;
+ 
+ 	if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
+-		goto skip_fsfstatus;
++		return;
+ 
+ 	switch (req->qtcb->header.fsf_status) {
+ 	case FSF_PORT_HANDLE_NOT_VALID:
+@@ -1586,9 +1515,6 @@ static void zfcp_fsf_close_port_handler(
+ 					    ZFCP_CLEAR);
+ 		break;
+ 	}
+-
+-skip_fsfstatus:
+-	atomic_clear_mask(ZFCP_STATUS_COMMON_CLOSING, &port->status);
+ }
+ 
+ /**
+@@ -1598,12 +1524,12 @@ skip_fsfstatus:
+  */
+ int zfcp_fsf_close_port(struct zfcp_erp_action *erp_action)
+ {
+-	volatile struct qdio_buffer_element *sbale;
++	struct qdio_buffer_element *sbale;
+ 	struct zfcp_adapter *adapter = erp_action->adapter;
+ 	struct zfcp_fsf_req *req;
+ 	int retval = -EIO;
+ 
+-	spin_lock_bh(&adapter->req_q.lock);
++	spin_lock_bh(&adapter->req_q_lock);
+ 	if (zfcp_fsf_req_sbal_get(adapter))
+ 		goto out;
+ 
+@@ -1624,7 +1550,6 @@ int zfcp_fsf_close_port(struct zfcp_erp_
+ 	req->erp_action = erp_action;
+ 	req->qtcb->header.port_handle = erp_action->port->handle;
+ 	erp_action->fsf_req = req;
+-	atomic_set_mask(ZFCP_STATUS_COMMON_CLOSING, &erp_action->port->status);
+ 
+ 	zfcp_fsf_start_erp_timer(req);
+ 	retval = zfcp_fsf_req_send(req);
+@@ -1633,7 +1558,131 @@ int zfcp_fsf_close_port(struct zfcp_erp_
+ 		erp_action->fsf_req = NULL;
+ 	}
+ out:
+-	spin_unlock_bh(&adapter->req_q.lock);
++	spin_unlock_bh(&adapter->req_q_lock);
++	return retval;
++}
++
++static void zfcp_fsf_open_wka_port_handler(struct zfcp_fsf_req *req)
++{
++	struct zfcp_wka_port *wka_port = req->data;
++	struct fsf_qtcb_header *header = &req->qtcb->header;
++
++	if (req->status & ZFCP_STATUS_FSFREQ_ERROR) {
++		wka_port->status = ZFCP_WKA_PORT_OFFLINE;
++		goto out;
++	}
++
++	switch (header->fsf_status) {
++	case FSF_MAXIMUM_NUMBER_OF_PORTS_EXCEEDED:
++		dev_warn(&req->adapter->ccw_device->dev,
++			 "Opening WKA port 0x%x failed\n", wka_port->d_id);
++	case FSF_ADAPTER_STATUS_AVAILABLE:
++		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
++	case FSF_ACCESS_DENIED:
++		wka_port->status = ZFCP_WKA_PORT_OFFLINE;
++		break;
++	case FSF_PORT_ALREADY_OPEN:
++	case FSF_GOOD:
++		wka_port->handle = header->port_handle;
++		wka_port->status = ZFCP_WKA_PORT_ONLINE;
++	}
++out:
++	wake_up(&wka_port->completion_wq);
++}
++
++/**
++ * zfcp_fsf_open_wka_port - create and send open wka-port request
++ * @wka_port: pointer to struct zfcp_wka_port
++ * Returns: 0 on success, error otherwise
++ */
++int zfcp_fsf_open_wka_port(struct zfcp_wka_port *wka_port)
++{
++	struct qdio_buffer_element *sbale;
++	struct zfcp_adapter *adapter = wka_port->adapter;
++	struct zfcp_fsf_req *req;
++	int retval = -EIO;
++
++	spin_lock_bh(&adapter->req_q_lock);
++	if (zfcp_fsf_req_sbal_get(adapter))
++		goto out;
++
++	req = zfcp_fsf_req_create(adapter,
++				  FSF_QTCB_OPEN_PORT_WITH_DID,
++				  ZFCP_REQ_AUTO_CLEANUP,
++				  adapter->pool.fsf_req_erp);
++	if (unlikely(IS_ERR(req))) {
++		retval = PTR_ERR(req);
++		goto out;
++	}
++
++	sbale = zfcp_qdio_sbale_req(req);
++	sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
++	sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
++
++	req->handler = zfcp_fsf_open_wka_port_handler;
++	req->qtcb->bottom.support.d_id = wka_port->d_id;
++	req->data = wka_port;
++
++	zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
++	retval = zfcp_fsf_req_send(req);
++	if (retval)
++		zfcp_fsf_req_free(req);
++out:
++	spin_unlock_bh(&adapter->req_q_lock);
++	return retval;
++}
++
++static void zfcp_fsf_close_wka_port_handler(struct zfcp_fsf_req *req)
++{
++	struct zfcp_wka_port *wka_port = req->data;
++
++	if (req->qtcb->header.fsf_status == FSF_PORT_HANDLE_NOT_VALID) {
++		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
++		zfcp_erp_adapter_reopen(wka_port->adapter, 0, 84, req);
++	}
++
++	wka_port->status = ZFCP_WKA_PORT_OFFLINE;
++	wake_up(&wka_port->completion_wq);
++}
++
++/**
++ * zfcp_fsf_close_wka_port - create and send close wka port request
++ * @erp_action: pointer to struct zfcp_erp_action
++ * Returns: 0 on success, error otherwise
++ */
++int zfcp_fsf_close_wka_port(struct zfcp_wka_port *wka_port)
++{
++	struct qdio_buffer_element *sbale;
++	struct zfcp_adapter *adapter = wka_port->adapter;
++	struct zfcp_fsf_req *req;
++	int retval = -EIO;
++
++	spin_lock_bh(&adapter->req_q_lock);
++	if (zfcp_fsf_req_sbal_get(adapter))
++		goto out;
++
++	req = zfcp_fsf_req_create(adapter, FSF_QTCB_CLOSE_PORT,
++				  ZFCP_REQ_AUTO_CLEANUP,
++				  adapter->pool.fsf_req_erp);
++	if (unlikely(IS_ERR(req))) {
++		retval = PTR_ERR(req);
++		goto out;
++	}
++
++	sbale = zfcp_qdio_sbale_req(req);
++	sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
++	sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
++
++	req->handler = zfcp_fsf_close_wka_port_handler;
++	req->data = wka_port;
++	req->qtcb->header.port_handle = wka_port->handle;
++
++	zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
++	retval = zfcp_fsf_req_send(req);
++	if (retval)
++		zfcp_fsf_req_free(req);
++out:
++	spin_unlock_bh(&adapter->req_q_lock);
+ 	return retval;
+ }
+ 
+@@ -1695,12 +1744,12 @@ skip_fsfstatus:
+  */
+ int zfcp_fsf_close_physical_port(struct zfcp_erp_action *erp_action)
+ {
+-	volatile struct qdio_buffer_element *sbale;
++	struct qdio_buffer_element *sbale;
+ 	struct zfcp_adapter *adapter = erp_action->adapter;
+ 	struct zfcp_fsf_req *req;
+ 	int retval = -EIO;
+ 
+-	spin_lock_bh(&adapter->req_q.lock);
++	spin_lock_bh(&adapter->req_q_lock);
+ 	if (zfcp_fsf_req_sbal_get(adapter))
+ 		goto out;
+ 
+@@ -1731,7 +1780,7 @@ int zfcp_fsf_close_physical_port(struct 
+ 		erp_action->fsf_req = NULL;
+ 	}
+ out:
+-	spin_unlock_bh(&adapter->req_q.lock);
++	spin_unlock_bh(&adapter->req_q_lock);
+ 	return retval;
+ }
+ 
+@@ -1746,7 +1795,7 @@ static void zfcp_fsf_open_unit_handler(s
+ 	int exclusive, readwrite;
+ 
+ 	if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
+-		goto skip_fsfstatus;
++		return;
+ 
+ 	atomic_clear_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED |
+ 			  ZFCP_STATUS_COMMON_ACCESS_BOXED |
+@@ -1774,14 +1823,12 @@ static void zfcp_fsf_open_unit_handler(s
+ 	case FSF_LUN_SHARING_VIOLATION:
+ 		if (header->fsf_status_qual.word[0])
+ 			dev_warn(&adapter->ccw_device->dev,
+-				 "FCP-LUN 0x%Lx at the remote port "
+-				 "with WWPN 0x%Lx "
+-				 "connected to the adapter "
+-				 "is already in use in LPAR%d, CSS%d.\n",
+-				 unit->fcp_lun,
+-				 unit->port->wwpn,
+-				 queue_designator->hla,
+-				 queue_designator->cssid);
++				 "LUN 0x%Lx on port 0x%Lx is already in "
++				 "use by CSS%d, MIF Image ID %x\n",
++				 (unsigned long long)unit->fcp_lun,
++				 (unsigned long long)unit->port->wwpn,
++				 queue_designator->cssid,
++				 queue_designator->hla);
+ 		else
+ 			zfcp_act_eval_err(adapter,
+ 					  header->fsf_status_qual.word[2]);
+@@ -1792,9 +1839,10 @@ static void zfcp_fsf_open_unit_handler(s
+ 		break;
+ 	case FSF_MAXIMUM_NUMBER_OF_LUNS_EXCEEDED:
+ 		dev_warn(&adapter->ccw_device->dev,
+-			 "The adapter ran out of resources. There is no "
+-			 "handle available for unit 0x%016Lx on port 0x%016Lx.",
+-			 unit->fcp_lun, unit->port->wwpn);
++			 "No handle is available for LUN "
++			 "0x%016Lx on port 0x%016Lx\n",
++			 (unsigned long long)unit->fcp_lun,
++			 (unsigned long long)unit->port->wwpn);
+ 		zfcp_erp_unit_failed(unit, 34, req);
+ 		/* fall through */
+ 	case FSF_INVALID_COMMAND_OPTION:
+@@ -1831,26 +1879,29 @@ static void zfcp_fsf_open_unit_handler(s
+                 		atomic_set_mask(ZFCP_STATUS_UNIT_READONLY,
+ 						&unit->status);
+ 				dev_info(&adapter->ccw_device->dev,
+-					 "Read-only access for unit 0x%016Lx "
+-					 "on port 0x%016Lx.\n",
+-					 unit->fcp_lun, unit->port->wwpn);
++					 "SCSI device at LUN 0x%016Lx on port "
++					 "0x%016Lx opened read-only\n",
++					 (unsigned long long)unit->fcp_lun,
++					 (unsigned long long)unit->port->wwpn);
+         		}
+ 
+         		if (exclusive && !readwrite) {
+ 				dev_err(&adapter->ccw_device->dev,
+-					"Exclusive access of read-only unit "
+-					"0x%016Lx on port 0x%016Lx not "
+-					"supported, disabling unit.\n",
+-					unit->fcp_lun, unit->port->wwpn);
++					"Exclusive read-only access not "
++					"supported (unit 0x%016Lx, "
++					"port 0x%016Lx)\n",
++					(unsigned long long)unit->fcp_lun,
++					(unsigned long long)unit->port->wwpn);
+ 				zfcp_erp_unit_failed(unit, 35, req);
+ 				req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ 				zfcp_erp_unit_shutdown(unit, 0, 80, req);
+         		} else if (!exclusive && readwrite) {
+ 				dev_err(&adapter->ccw_device->dev,
+-					"Shared access of read-write unit "
+-					"0x%016Lx on port 0x%016Lx not "
+-					"supported, disabling unit.\n",
+-					unit->fcp_lun, unit->port->wwpn);
++					"Shared read-write access not "
++					"supported (unit 0x%016Lx, port "
++					"0x%016Lx\n)",
++					(unsigned long long)unit->fcp_lun,
++					(unsigned long long)unit->port->wwpn);
+ 				zfcp_erp_unit_failed(unit, 36, req);
+ 				req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ 				zfcp_erp_unit_shutdown(unit, 0, 81, req);
+@@ -1858,9 +1909,6 @@ static void zfcp_fsf_open_unit_handler(s
+ 		}
+ 		break;
+ 	}
+-
+-skip_fsfstatus:
+-	atomic_clear_mask(ZFCP_STATUS_COMMON_OPENING, &unit->status);
+ }
+ 
+ /**
+@@ -1870,12 +1918,12 @@ skip_fsfstatus:
+  */
+ int zfcp_fsf_open_unit(struct zfcp_erp_action *erp_action)
+ {
+-	volatile struct qdio_buffer_element *sbale;
++	struct qdio_buffer_element *sbale;
+ 	struct zfcp_adapter *adapter = erp_action->adapter;
+ 	struct zfcp_fsf_req *req;
+ 	int retval = -EIO;
+ 
+-	spin_lock_bh(&adapter->req_q.lock);
++	spin_lock_bh(&adapter->req_q_lock);
+ 	if (zfcp_fsf_req_sbal_get(adapter))
+ 		goto out;
+ 
+@@ -1901,8 +1949,6 @@ int zfcp_fsf_open_unit(struct zfcp_erp_a
+ 	if (!(adapter->connection_features & FSF_FEATURE_NPIV_MODE))
+ 		req->qtcb->bottom.support.option = FSF_OPEN_LUN_SUPPRESS_BOXING;
+ 
+-	atomic_set_mask(ZFCP_STATUS_COMMON_OPENING, &erp_action->unit->status);
+-
+ 	zfcp_fsf_start_erp_timer(req);
+ 	retval = zfcp_fsf_req_send(req);
+ 	if (retval) {
+@@ -1910,7 +1956,7 @@ int zfcp_fsf_open_unit(struct zfcp_erp_a
+ 		erp_action->fsf_req = NULL;
+ 	}
+ out:
+-	spin_unlock_bh(&adapter->req_q.lock);
++	spin_unlock_bh(&adapter->req_q_lock);
+ 	return retval;
+ }
+ 
+@@ -1919,7 +1965,7 @@ static void zfcp_fsf_close_unit_handler(
+ 	struct zfcp_unit *unit = req->data;
+ 
+ 	if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
+-		goto skip_fsfstatus;
++		return;
+ 
+ 	switch (req->qtcb->header.fsf_status) {
+ 	case FSF_PORT_HANDLE_NOT_VALID:
+@@ -1949,8 +1995,6 @@ static void zfcp_fsf_close_unit_handler(
+ 		atomic_clear_mask(ZFCP_STATUS_COMMON_OPEN, &unit->status);
+ 		break;
+ 	}
+-skip_fsfstatus:
+-	atomic_clear_mask(ZFCP_STATUS_COMMON_CLOSING, &unit->status);
+ }
+ 
+ /**
+@@ -1960,12 +2004,12 @@ skip_fsfstatus:
+  */
+ int zfcp_fsf_close_unit(struct zfcp_erp_action *erp_action)
+ {
+-	volatile struct qdio_buffer_element *sbale;
++	struct qdio_buffer_element *sbale;
+ 	struct zfcp_adapter *adapter = erp_action->adapter;
+ 	struct zfcp_fsf_req *req;
+ 	int retval = -EIO;
+ 
+-	spin_lock_bh(&adapter->req_q.lock);
++	spin_lock_bh(&adapter->req_q_lock);
+ 	if (zfcp_fsf_req_sbal_get(adapter))
+ 		goto out;
+ 	req = zfcp_fsf_req_create(adapter, FSF_QTCB_CLOSE_LUN,
+@@ -1986,7 +2030,6 @@ int zfcp_fsf_close_unit(struct zfcp_erp_
+ 	req->data = erp_action->unit;
+ 	req->erp_action = erp_action;
+ 	erp_action->fsf_req = req;
+-	atomic_set_mask(ZFCP_STATUS_COMMON_CLOSING, &erp_action->unit->status);
+ 
+ 	zfcp_fsf_start_erp_timer(req);
+ 	retval = zfcp_fsf_req_send(req);
+@@ -1995,7 +2038,7 @@ int zfcp_fsf_close_unit(struct zfcp_erp_
+ 		erp_action->fsf_req = NULL;
+ 	}
+ out:
+-	spin_unlock_bh(&adapter->req_q.lock);
++	spin_unlock_bh(&adapter->req_q_lock);
+ 	return retval;
+ }
+ 
+@@ -2038,18 +2081,21 @@ static void zfcp_fsf_req_latency(struct 
+ 
+ static void zfcp_fsf_send_fcp_command_task_handler(struct zfcp_fsf_req *req)
+ {
+-	struct scsi_cmnd *scpnt = req->data;
++	struct scsi_cmnd *scpnt;
+ 	struct fcp_rsp_iu *fcp_rsp_iu = (struct fcp_rsp_iu *)
+ 	    &(req->qtcb->bottom.io.fcp_rsp);
+ 	u32 sns_len;
+ 	char *fcp_rsp_info = (unsigned char *) &fcp_rsp_iu[1];
+ 	unsigned long flags;
+ 
+-	if (unlikely(!scpnt))
+-		return;
+-
+ 	read_lock_irqsave(&req->adapter->abort_lock, flags);
+ 
++	scpnt = req->data;
++	if (unlikely(!scpnt)) {
++		read_unlock_irqrestore(&req->adapter->abort_lock, flags);
++		return;
++	}
++
+ 	if (unlikely(req->status & ZFCP_STATUS_FSFREQ_ABORTED)) {
+ 		set_host_byte(scpnt, DID_SOFT_ERROR);
+ 		set_driver_byte(scpnt, SUGGEST_RETRY);
+@@ -2156,21 +2202,21 @@ static void zfcp_fsf_send_fcp_command_ha
+ 		break;
+ 	case FSF_DIRECTION_INDICATOR_NOT_VALID:
+ 		dev_err(&req->adapter->ccw_device->dev,
+-			"Invalid data direction (%d) given for unit "
+-			"0x%016Lx on port 0x%016Lx, shutting down "
+-			"adapter.\n",
++			"Incorrect direction %d, unit 0x%016Lx on port "
++			"0x%016Lx closed\n",
+ 			req->qtcb->bottom.io.data_direction,
+-			unit->fcp_lun, unit->port->wwpn);
++			(unsigned long long)unit->fcp_lun,
++			(unsigned long long)unit->port->wwpn);
+ 		zfcp_erp_adapter_shutdown(unit->port->adapter, 0, 133, req);
+ 		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ 		break;
+ 	case FSF_CMND_LENGTH_NOT_VALID:
+ 		dev_err(&req->adapter->ccw_device->dev,
+-			"An invalid control-data-block length field (%d) "
+-			"was found in a command for unit 0x%016Lx on port "
+-			"0x%016Lx. Shutting down adapter.\n",
++			"Incorrect CDB length %d, unit 0x%016Lx on "
++			"port 0x%016Lx closed\n",
+ 			req->qtcb->bottom.io.fcp_cmnd_length,
+-			unit->fcp_lun, unit->port->wwpn);
++			(unsigned long long)unit->fcp_lun,
++			(unsigned long long)unit->port->wwpn);
+ 		zfcp_erp_adapter_shutdown(unit->port->adapter, 0, 134, req);
+ 		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ 		break;
+@@ -2201,6 +2247,20 @@ skip_fsfstatus:
+ 	}
+ }
+ 
++static void zfcp_set_fcp_dl(struct fcp_cmnd_iu *fcp_cmd, u32 fcp_dl)
++{
++	u32 *fcp_dl_ptr;
++
++	/*
++	 * fcp_dl_addr = start address of fcp_cmnd structure +
++	 * size of fixed part + size of dynamically sized add_dcp_cdb field
++	 * SEE FCP-2 documentation
++	 */
++	fcp_dl_ptr = (u32 *) ((unsigned char *) &fcp_cmd[1] +
++			(fcp_cmd->add_fcp_cdb_length << 2));
++	*fcp_dl_ptr = fcp_dl;
++}
++
+ /**
+  * zfcp_fsf_send_fcp_command_task - initiate an FCP command (for a SCSI command)
+  * @adapter: adapter where scsi command is issued
+@@ -2223,8 +2283,8 @@ int zfcp_fsf_send_fcp_command_task(struc
+ 		       ZFCP_STATUS_COMMON_UNBLOCKED)))
+ 		return -EBUSY;
+ 
+-	spin_lock(&adapter->req_q.lock);
+-	if (!atomic_read(&adapter->req_q.count))
++	spin_lock(&adapter->req_q_lock);
++	if (!zfcp_fsf_sbal_available(adapter))
+ 		goto out;
+ 	req = zfcp_fsf_req_create(adapter, FSF_QTCB_FCP_CMND, req_flags,
+ 				  adapter->pool.fsf_req_scsi);
+@@ -2286,7 +2346,7 @@ int zfcp_fsf_send_fcp_command_task(struc
+ 	memcpy(fcp_cmnd_iu->fcp_cdb, scsi_cmnd->cmnd, scsi_cmnd->cmd_len);
+ 
+ 	req->qtcb->bottom.io.fcp_cmnd_length = sizeof(struct fcp_cmnd_iu) +
+-		fcp_cmnd_iu->add_fcp_cdb_length + sizeof(fcp_dl_t);
++		fcp_cmnd_iu->add_fcp_cdb_length + sizeof(u32);
+ 
+ 	real_bytes = zfcp_qdio_sbals_from_sg(req, sbtype,
+ 					     scsi_sglist(scsi_cmnd),
+@@ -2296,10 +2356,10 @@ int zfcp_fsf_send_fcp_command_task(struc
+ 			retval = -EIO;
+ 		else {
+ 			dev_err(&adapter->ccw_device->dev,
+-				"SCSI request too large. "
+-				"Shutting down unit 0x%016Lx on port "
+-				"0x%016Lx.\n", unit->fcp_lun,
+-				unit->port->wwpn);
++				"Oversize data package, unit 0x%016Lx "
++				"on port 0x%016Lx closed\n",
++				(unsigned long long)unit->fcp_lun,
++				(unsigned long long)unit->port->wwpn);
+ 			zfcp_erp_unit_shutdown(unit, 0, 131, req);
+ 			retval = -EINVAL;
+ 		}
+@@ -2322,7 +2382,7 @@ failed_scsi_cmnd:
+ 	zfcp_fsf_req_free(req);
+ 	scsi_cmnd->host_scribble = NULL;
+ out:
+-	spin_unlock(&adapter->req_q.lock);
++	spin_unlock(&adapter->req_q_lock);
+ 	return retval;
+ }
+ 
+@@ -2338,7 +2398,7 @@ struct zfcp_fsf_req *zfcp_fsf_send_fcp_c
+ 					   struct zfcp_unit *unit,
+ 					   u8 tm_flags, int req_flags)
+ {
+-	volatile struct qdio_buffer_element *sbale;
++	struct qdio_buffer_element *sbale;
+ 	struct zfcp_fsf_req *req = NULL;
+ 	struct fcp_cmnd_iu *fcp_cmnd_iu;
+ 
+@@ -2346,8 +2406,8 @@ struct zfcp_fsf_req *zfcp_fsf_send_fcp_c
+ 		       ZFCP_STATUS_COMMON_UNBLOCKED)))
+ 		return NULL;
+ 
+-	spin_lock(&adapter->req_q.lock);
+-	if (!atomic_read(&adapter->req_q.count))
++	spin_lock(&adapter->req_q_lock);
++	if (!zfcp_fsf_sbal_available(adapter))
+ 		goto out;
+ 	req = zfcp_fsf_req_create(adapter, FSF_QTCB_FCP_CMND, req_flags,
+ 				  adapter->pool.fsf_req_scsi);
+@@ -2362,7 +2422,7 @@ struct zfcp_fsf_req *zfcp_fsf_send_fcp_c
+ 	req->qtcb->bottom.io.data_direction = FSF_DATADIR_CMND;
+ 	req->qtcb->bottom.io.service_class = FSF_CLASS_3;
+ 	req->qtcb->bottom.io.fcp_cmnd_length = 	sizeof(struct fcp_cmnd_iu) +
+-						sizeof(fcp_dl_t);
++						sizeof(u32);
+ 
+ 	sbale = zfcp_qdio_sbale_req(req);
+ 	sbale[0].flags |= SBAL_FLAGS0_TYPE_WRITE;
+@@ -2379,7 +2439,7 @@ struct zfcp_fsf_req *zfcp_fsf_send_fcp_c
+ 	zfcp_fsf_req_free(req);
+ 	req = NULL;
+ out:
+-	spin_unlock(&adapter->req_q.lock);
++	spin_unlock(&adapter->req_q_lock);
+ 	return req;
+ }
+ 
+@@ -2398,7 +2458,7 @@ static void zfcp_fsf_control_file_handle
+ struct zfcp_fsf_req *zfcp_fsf_control_file(struct zfcp_adapter *adapter,
+ 					   struct zfcp_fsf_cfdc *fsf_cfdc)
+ {
+-	volatile struct qdio_buffer_element *sbale;
++	struct qdio_buffer_element *sbale;
+ 	struct zfcp_fsf_req *req = NULL;
+ 	struct fsf_qtcb_bottom_support *bottom;
+ 	int direction, retval = -EIO, bytes;
+@@ -2417,7 +2477,7 @@ struct zfcp_fsf_req *zfcp_fsf_control_fi
+ 		return ERR_PTR(-EINVAL);
+ 	}
+ 
+-	spin_lock_bh(&adapter->req_q.lock);
++	spin_lock_bh(&adapter->req_q_lock);
+ 	if (zfcp_fsf_req_sbal_get(adapter))
+ 		goto out;
+ 
+@@ -2447,7 +2507,7 @@ struct zfcp_fsf_req *zfcp_fsf_control_fi
+ 	zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
+ 	retval = zfcp_fsf_req_send(req);
+ out:
+-	spin_unlock_bh(&adapter->req_q.lock);
++	spin_unlock_bh(&adapter->req_q_lock);
+ 
+ 	if (!retval) {
+ 		wait_event(req->completion_wq,
+Index: linux-2.6.27-gentoo-r7/drivers/s390/scsi/zfcp_fsf.h
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/scsi/zfcp_fsf.h
++++ linux-2.6.27-gentoo-r7/drivers/s390/scsi/zfcp_fsf.h
+@@ -71,13 +71,6 @@
+ #define FSF_MAXIMUM_NUMBER_OF_LUNS_EXCEEDED	0x00000041
+ #define FSF_ELS_COMMAND_REJECTED		0x00000050
+ #define FSF_GENERIC_COMMAND_REJECTED		0x00000051
+-#define FSF_OPERATION_PARTIALLY_SUCCESSFUL	0x00000052
+-#define FSF_AUTHORIZATION_FAILURE		0x00000053
+-#define FSF_CFDC_ERROR_DETECTED			0x00000054
+-#define FSF_CONTROL_FILE_UPDATE_ERROR		0x00000055
+-#define FSF_CONTROL_FILE_TOO_LARGE		0x00000056
+-#define FSF_ACCESS_CONFLICT_DETECTED		0x00000057
+-#define FSF_CONFLICTS_OVERRULED			0x00000058
+ #define FSF_PORT_BOXED				0x00000059
+ #define FSF_LUN_BOXED				0x0000005A
+ #define FSF_EXCHANGE_CONFIG_DATA_INCOMPLETE	0x0000005B
+@@ -85,9 +78,7 @@
+ #define FSF_REQUEST_SIZE_TOO_LARGE		0x00000061
+ #define FSF_RESPONSE_SIZE_TOO_LARGE		0x00000062
+ #define FSF_SBAL_MISMATCH			0x00000063
+-#define FSF_OPEN_PORT_WITHOUT_PRLI		0x00000064
+ #define FSF_ADAPTER_STATUS_AVAILABLE		0x000000AD
+-#define FSF_FCP_RSP_AVAILABLE			0x000000AF
+ #define FSF_UNKNOWN_COMMAND			0x000000E2
+ #define FSF_UNKNOWN_OP_SUBTYPE                  0x000000E3
+ #define FSF_INVALID_COMMAND_OPTION              0x000000E5
+@@ -102,20 +93,9 @@
+ #define FSF_SQ_RETRY_IF_POSSIBLE		0x02
+ #define FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED	0x03
+ #define FSF_SQ_INVOKE_LINK_TEST_PROCEDURE	0x04
+-#define FSF_SQ_ULP_PROGRAMMING_ERROR		0x05
+ #define FSF_SQ_COMMAND_ABORTED			0x06
+ #define FSF_SQ_NO_RETRY_POSSIBLE		0x07
+ 
+-/* FSF status qualifier for CFDC commands */
+-#define FSF_SQ_CFDC_HARDENED_ON_SE		0x00000000
+-#define FSF_SQ_CFDC_COULD_NOT_HARDEN_ON_SE	0x00000001
+-#define FSF_SQ_CFDC_COULD_NOT_HARDEN_ON_SE2	0x00000002
+-/* CFDC subtable codes */
+-#define FSF_SQ_CFDC_SUBTABLE_OS			0x0001
+-#define FSF_SQ_CFDC_SUBTABLE_PORT_WWPN		0x0002
+-#define FSF_SQ_CFDC_SUBTABLE_PORT_DID		0x0003
+-#define FSF_SQ_CFDC_SUBTABLE_LUN		0x0004
+-
+ /* FSF status qualifier (most significant 4 bytes), local link down */
+ #define FSF_PSQ_LINK_NO_LIGHT			0x00000004
+ #define FSF_PSQ_LINK_WRAP_PLUG			0x00000008
+@@ -145,7 +125,6 @@
+ #define FSF_STATUS_READ_LINK_UP          	0x00000006
+ #define FSF_STATUS_READ_NOTIFICATION_LOST	0x00000009
+ #define FSF_STATUS_READ_CFDC_UPDATED		0x0000000A
+-#define FSF_STATUS_READ_CFDC_HARDENED		0x0000000B
+ #define FSF_STATUS_READ_FEATURE_UPDATE_ALERT	0x0000000C
+ 
+ /* status subtypes in status read buffer */
+@@ -159,20 +138,9 @@
+ 
+ /* status subtypes for unsolicited status notification lost */
+ #define FSF_STATUS_READ_SUB_INCOMING_ELS	0x00000001
+-#define FSF_STATUS_READ_SUB_SENSE_DATA		0x00000002
+-#define FSF_STATUS_READ_SUB_LINK_STATUS		0x00000004
+-#define FSF_STATUS_READ_SUB_PORT_CLOSED		0x00000008
+-#define FSF_STATUS_READ_SUB_BIT_ERROR_THRESHOLD	0x00000010
+ #define FSF_STATUS_READ_SUB_ACT_UPDATED		0x00000020
+-#define FSF_STATUS_READ_SUB_ACT_HARDENED	0x00000040
+-#define FSF_STATUS_READ_SUB_FEATURE_UPDATE_ALERT 0x00000080
+-
+-/* status subtypes for CFDC */
+-#define FSF_STATUS_READ_SUB_CFDC_HARDENED_ON_SE	0x00000002
+-#define FSF_STATUS_READ_SUB_CFDC_HARDENED_ON_SE2 0x0000000F
+ 
+ /* topologie that is detected by the adapter */
+-#define FSF_TOPO_ERROR				0x00000000
+ #define FSF_TOPO_P2P				0x00000001
+ #define FSF_TOPO_FABRIC				0x00000002
+ #define FSF_TOPO_AL				0x00000003
+@@ -180,17 +148,13 @@
+ /* data direction for FCP commands */
+ #define FSF_DATADIR_WRITE			0x00000001
+ #define FSF_DATADIR_READ			0x00000002
+-#define FSF_DATADIR_READ_WRITE			0x00000003
+ #define FSF_DATADIR_CMND			0x00000004
+ 
+ /* fc service class */
+-#define FSF_CLASS_1				0x00000001
+-#define FSF_CLASS_2				0x00000002
+ #define FSF_CLASS_3				0x00000003
+ 
+ /* SBAL chaining */
+ #define FSF_MAX_SBALS_PER_REQ			36
+-#define FSF_MAX_SBALS_PER_ELS_REQ		2
+ 
+ /* logging space behind QTCB */
+ #define FSF_QTCB_LOG_SIZE			1024
+@@ -200,50 +164,16 @@
+ #define FSF_FEATURE_LUN_SHARING			0x00000004
+ #define FSF_FEATURE_NOTIFICATION_LOST		0x00000008
+ #define FSF_FEATURE_HBAAPI_MANAGEMENT           0x00000010
+-#define FSF_FEATURE_ELS_CT_CHAINED_SBALS        0x00000020
+ #define FSF_FEATURE_UPDATE_ALERT		0x00000100
+ #define FSF_FEATURE_MEASUREMENT_DATA		0x00000200
+ 
+ /* host connection features */
+ #define FSF_FEATURE_NPIV_MODE			0x00000001
+-#define FSF_FEATURE_VM_ASSIGNED_WWPN		0x00000002
+ 
+ /* option */
+ #define FSF_OPEN_LUN_SUPPRESS_BOXING		0x00000001
+-#define FSF_OPEN_LUN_REPLICATE_SENSE		0x00000002
+-
+-/* adapter types */
+-#define FSF_ADAPTER_TYPE_FICON                  0x00000001
+-#define FSF_ADAPTER_TYPE_FICON_EXPRESS          0x00000002
+-
+-/* port types */
+-#define FSF_HBA_PORTTYPE_UNKNOWN		0x00000001
+-#define FSF_HBA_PORTTYPE_NOTPRESENT		0x00000003
+-#define FSF_HBA_PORTTYPE_NPORT			0x00000005
+-#define FSF_HBA_PORTTYPE_PTP			0x00000021
+-/* following are not defined and used by FSF Spec
+-   but are additionally defined by FC-HBA */
+-#define FSF_HBA_PORTTYPE_OTHER			0x00000002
+-#define FSF_HBA_PORTTYPE_NOTPRESENT		0x00000003
+-#define FSF_HBA_PORTTYPE_NLPORT			0x00000006
+-#define FSF_HBA_PORTTYPE_FLPORT			0x00000007
+-#define FSF_HBA_PORTTYPE_FPORT			0x00000008
+-#define FSF_HBA_PORTTYPE_LPORT			0x00000020
+-
+-/* port states */
+-#define FSF_HBA_PORTSTATE_UNKNOWN		0x00000001
+-#define FSF_HBA_PORTSTATE_ONLINE		0x00000002
+-#define FSF_HBA_PORTSTATE_OFFLINE		0x00000003
+-#define FSF_HBA_PORTSTATE_LINKDOWN		0x00000006
+-#define FSF_HBA_PORTSTATE_ERROR			0x00000007
+-
+-/* IO states of adapter */
+-#define FSF_IOSTAT_NPORT_RJT			0x00000004
+-#define FSF_IOSTAT_FABRIC_RJT			0x00000005
+-#define FSF_IOSTAT_LS_RJT			0x00000009
+ 
+ /* open LUN access flags*/
+-#define FSF_UNIT_ACCESS_OPEN_LUN_ALLOWED	0x01000000
+ #define FSF_UNIT_ACCESS_EXCLUSIVE		0x02000000
+ #define FSF_UNIT_ACCESS_OUTBOUND_TRANSFER	0x10000000
+ 
+@@ -265,11 +195,6 @@ struct fsf_queue_designator {
+ 	u32 res1;
+ } __attribute__ ((packed));
+ 
+-struct fsf_port_closed_payload {
+-	struct fsf_queue_designator queue_designator;
+-	u32                         port_handle;
+-} __attribute__ ((packed));
+-
+ struct fsf_bit_error_payload {
+ 	u32 res1;
+ 	u32 link_failure_error_count;
+Index: linux-2.6.27-gentoo-r7/drivers/s390/scsi/zfcp_qdio.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/scsi/zfcp_qdio.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/scsi/zfcp_qdio.c
+@@ -28,7 +28,7 @@ static int zfcp_qdio_buffers_enqueue(str
+ 	return 0;
+ }
+ 
+-static volatile struct qdio_buffer_element *
++static struct qdio_buffer_element *
+ zfcp_qdio_sbale(struct zfcp_qdio_queue *q, int sbal_idx, int sbale_idx)
+ {
+ 	return &q->sbal[sbal_idx]->element[sbale_idx];
+@@ -57,7 +57,7 @@ void zfcp_qdio_free(struct zfcp_adapter 
+ 
+ static void zfcp_qdio_handler_error(struct zfcp_adapter *adapter, u8 id)
+ {
+-	dev_warn(&adapter->ccw_device->dev, "QDIO problem occurred.\n");
++	dev_warn(&adapter->ccw_device->dev, "A QDIO problem occurred\n");
+ 
+ 	zfcp_erp_adapter_reopen(adapter,
+ 				ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED |
+@@ -145,7 +145,7 @@ static void zfcp_qdio_int_resp(struct cc
+ {
+ 	struct zfcp_adapter *adapter = (struct zfcp_adapter *) parm;
+ 	struct zfcp_qdio_queue *queue = &adapter->resp_q;
+-	volatile struct qdio_buffer_element *sbale;
++	struct qdio_buffer_element *sbale;
+ 	int sbal_idx, sbale_idx, sbal_no;
+ 
+ 	if (unlikely(qdio_err)) {
+@@ -174,8 +174,8 @@ static void zfcp_qdio_int_resp(struct cc
+ 
+ 		if (unlikely(!(sbale->flags & SBAL_FLAGS_LAST_ENTRY)))
+ 			dev_warn(&adapter->ccw_device->dev,
+-				 "Protocol violation by adapter. "
+-				 "Continuing operations.\n");
++				 "A QDIO protocol error occurred, "
++				 "operations continue\n");
+ 	}
+ 
+ 	/*
+@@ -190,8 +190,7 @@ static void zfcp_qdio_int_resp(struct cc
+  * @fsf_req: pointer to struct fsf_req
+  * Returns: pointer to qdio_buffer_element (SBALE) structure
+  */
+-volatile struct qdio_buffer_element *
+-zfcp_qdio_sbale_req(struct zfcp_fsf_req *req)
++struct qdio_buffer_element *zfcp_qdio_sbale_req(struct zfcp_fsf_req *req)
+ {
+ 	return zfcp_qdio_sbale(&req->adapter->req_q, req->sbal_last, 0);
+ }
+@@ -201,8 +200,7 @@ zfcp_qdio_sbale_req(struct zfcp_fsf_req 
+  * @fsf_req: pointer to struct fsf_req
+  * Returns: pointer to qdio_buffer_element (SBALE) structure
+  */
+-volatile struct qdio_buffer_element *
+-zfcp_qdio_sbale_curr(struct zfcp_fsf_req *req)
++struct qdio_buffer_element *zfcp_qdio_sbale_curr(struct zfcp_fsf_req *req)
+ {
+ 	return zfcp_qdio_sbale(&req->adapter->req_q, req->sbal_last,
+ 			       req->sbale_curr);
+@@ -216,10 +214,10 @@ static void zfcp_qdio_sbal_limit(struct 
+ 					% QDIO_MAX_BUFFERS_PER_Q;
+ }
+ 
+-static volatile struct qdio_buffer_element *
++static struct qdio_buffer_element *
+ zfcp_qdio_sbal_chain(struct zfcp_fsf_req *fsf_req, unsigned long sbtype)
+ {
+-	volatile struct qdio_buffer_element *sbale;
++	struct qdio_buffer_element *sbale;
+ 
+ 	/* set last entry flag in current SBALE of current SBAL */
+ 	sbale = zfcp_qdio_sbale_curr(fsf_req);
+@@ -250,7 +248,7 @@ zfcp_qdio_sbal_chain(struct zfcp_fsf_req
+ 	return sbale;
+ }
+ 
+-static volatile struct qdio_buffer_element *
++static struct qdio_buffer_element *
+ zfcp_qdio_sbale_next(struct zfcp_fsf_req *fsf_req, unsigned long sbtype)
+ {
+ 	if (fsf_req->sbale_curr == ZFCP_LAST_SBALE_PER_SBAL)
+@@ -273,7 +271,7 @@ static int zfcp_qdio_fill_sbals(struct z
+ 				unsigned int sbtype, void *start_addr,
+ 				unsigned int total_length)
+ {
+-	volatile struct qdio_buffer_element *sbale;
++	struct qdio_buffer_element *sbale;
+ 	unsigned long remaining, length;
+ 	void *addr;
+ 
+@@ -282,6 +280,7 @@ static int zfcp_qdio_fill_sbals(struct z
+ 	     addr += length, remaining -= length) {
+ 		sbale = zfcp_qdio_sbale_next(fsf_req, sbtype);
+ 		if (!sbale) {
++			atomic_inc(&fsf_req->adapter->qdio_outb_full);
+ 			zfcp_qdio_undo_sbals(fsf_req);
+ 			return -EINVAL;
+ 		}
+@@ -307,7 +306,7 @@ static int zfcp_qdio_fill_sbals(struct z
+ int zfcp_qdio_sbals_from_sg(struct zfcp_fsf_req *fsf_req, unsigned long sbtype,
+ 			    struct scatterlist *sg, int max_sbals)
+ {
+-	volatile struct qdio_buffer_element *sbale;
++	struct qdio_buffer_element *sbale;
+ 	int retval, bytes = 0;
+ 
+ 	/* figure out last allowed SBAL */
+@@ -344,10 +343,10 @@ int zfcp_qdio_send(struct zfcp_fsf_req *
+ 	int first = fsf_req->sbal_first;
+ 	int count = fsf_req->sbal_number;
+ 	int retval, pci, pci_batch;
+-	volatile struct qdio_buffer_element *sbale;
++	struct qdio_buffer_element *sbale;
+ 
+ 	/* acknowledgements for transferred buffers */
+-	pci_batch = req_q->pci_batch + count;
++	pci_batch = adapter->req_q_pci_batch + count;
+ 	if (unlikely(pci_batch >= ZFCP_QDIO_PCI_INTERVAL)) {
+ 		pci_batch %= ZFCP_QDIO_PCI_INTERVAL;
+ 		pci = first + count - (pci_batch + 1);
+@@ -367,7 +366,7 @@ int zfcp_qdio_send(struct zfcp_fsf_req *
+ 	atomic_sub(count, &req_q->count);
+ 	req_q->first += count;
+ 	req_q->first %= QDIO_MAX_BUFFERS_PER_Q;
+-	req_q->pci_batch = pci_batch;
++	adapter->req_q_pci_batch = pci_batch;
+ 	return 0;
+ }
+ 
+@@ -418,14 +417,14 @@ void zfcp_qdio_close(struct zfcp_adapter
+ 	struct zfcp_qdio_queue *req_q;
+ 	int first, count;
+ 
+-	if (!atomic_test_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &adapter->status))
++	if (!(atomic_read(&adapter->status) & ZFCP_STATUS_ADAPTER_QDIOUP))
+ 		return;
+ 
+ 	/* clear QDIOUP flag, thus do_QDIO is not called during qdio_shutdown */
+ 	req_q = &adapter->req_q;
+-	spin_lock_bh(&req_q->lock);
++	spin_lock_bh(&adapter->req_q_lock);
+ 	atomic_clear_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &adapter->status);
+-	spin_unlock_bh(&req_q->lock);
++	spin_unlock_bh(&adapter->req_q_lock);
+ 
+ 	qdio_shutdown(adapter->ccw_device, QDIO_FLAG_CLEANUP_USING_CLEAR);
+ 
+@@ -438,7 +437,7 @@ void zfcp_qdio_close(struct zfcp_adapter
+ 	}
+ 	req_q->first = 0;
+ 	atomic_set(&req_q->count, 0);
+-	req_q->pci_batch = 0;
++	adapter->req_q_pci_batch = 0;
+ 	adapter->resp_q.first = 0;
+ 	atomic_set(&adapter->resp_q.count, 0);
+ }
+@@ -450,23 +449,17 @@ void zfcp_qdio_close(struct zfcp_adapter
+  */
+ int zfcp_qdio_open(struct zfcp_adapter *adapter)
+ {
+-	volatile struct qdio_buffer_element *sbale;
++	struct qdio_buffer_element *sbale;
+ 	int cc;
+ 
+-	if (atomic_test_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &adapter->status))
++	if (atomic_read(&adapter->status) & ZFCP_STATUS_ADAPTER_QDIOUP)
+ 		return -EIO;
+ 
+-	if (qdio_establish(&adapter->qdio_init_data)) {
+-		dev_err(&adapter->ccw_device->dev,
+-			 "Establish of QDIO queues failed.\n");
+-		return -EIO;
+-	}
++	if (qdio_establish(&adapter->qdio_init_data))
++		goto failed_establish;
+ 
+-	if (qdio_activate(adapter->ccw_device)) {
+-		dev_err(&adapter->ccw_device->dev,
+-			 "Activate of QDIO queues failed.\n");
++	if (qdio_activate(adapter->ccw_device))
+ 		goto failed_qdio;
+-	}
+ 
+ 	for (cc = 0; cc < QDIO_MAX_BUFFERS_PER_Q; cc++) {
+ 		sbale = &(adapter->resp_q.sbal[cc]->element[0]);
+@@ -476,20 +469,20 @@ int zfcp_qdio_open(struct zfcp_adapter *
+ 	}
+ 
+ 	if (do_QDIO(adapter->ccw_device, QDIO_FLAG_SYNC_INPUT, 0, 0,
+-		     QDIO_MAX_BUFFERS_PER_Q)) {
+-		dev_err(&adapter->ccw_device->dev,
+-			 "Init of QDIO response queue failed.\n");
++		     QDIO_MAX_BUFFERS_PER_Q))
+ 		goto failed_qdio;
+-	}
+ 
+ 	/* set index of first avalable SBALS / number of available SBALS */
+ 	adapter->req_q.first = 0;
+ 	atomic_set(&adapter->req_q.count, QDIO_MAX_BUFFERS_PER_Q);
+-	adapter->req_q.pci_batch = 0;
++	adapter->req_q_pci_batch = 0;
+ 
+ 	return 0;
+ 
+ failed_qdio:
+ 	qdio_shutdown(adapter->ccw_device, QDIO_FLAG_CLEANUP_USING_CLEAR);
++failed_establish:
++	dev_err(&adapter->ccw_device->dev,
++		"Setting up the QDIO connection to the FCP adapter failed\n");
+ 	return -EIO;
+ }
+Index: linux-2.6.27-gentoo-r7/drivers/s390/scsi/zfcp_scsi.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/scsi/zfcp_scsi.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/scsi/zfcp_scsi.c
+@@ -21,31 +21,13 @@ char *zfcp_get_fcp_sns_info_ptr(struct f
+ 	return fcp_sns_info_ptr;
+ }
+ 
+-void zfcp_set_fcp_dl(struct fcp_cmnd_iu *fcp_cmd, fcp_dl_t fcp_dl)
+-{
+-	fcp_dl_t *fcp_dl_ptr;
+-
+-	/*
+-	 * fcp_dl_addr = start address of fcp_cmnd structure +
+-	 * size of fixed part + size of dynamically sized add_dcp_cdb field
+-	 * SEE FCP-2 documentation
+-	 */
+-	fcp_dl_ptr = (fcp_dl_t *) ((unsigned char *) &fcp_cmd[1] +
+-				   (fcp_cmd->add_fcp_cdb_length << 2));
+-	*fcp_dl_ptr = fcp_dl;
+-}
+-
+ static void zfcp_scsi_slave_destroy(struct scsi_device *sdpnt)
+ {
+ 	struct zfcp_unit *unit = (struct zfcp_unit *) sdpnt->hostdata;
+-	WARN_ON(!unit);
+-	if (unit) {
+-		atomic_clear_mask(ZFCP_STATUS_UNIT_REGISTERED, &unit->status);
+-		sdpnt->hostdata = NULL;
+-		unit->device = NULL;
+-		zfcp_erp_unit_failed(unit, 12, NULL);
+-		zfcp_unit_put(unit);
+-	}
++	atomic_clear_mask(ZFCP_STATUS_UNIT_REGISTERED, &unit->status);
++	unit->device = NULL;
++	zfcp_erp_unit_failed(unit, 12, NULL);
++	zfcp_unit_put(unit);
+ }
+ 
+ static int zfcp_scsi_slave_configure(struct scsi_device *sdp)
+@@ -119,13 +101,17 @@ static struct zfcp_unit *zfcp_unit_looku
+ {
+ 	struct zfcp_port *port;
+ 	struct zfcp_unit *unit;
++	int scsi_lun;
+ 
+ 	list_for_each_entry(port, &adapter->port_list_head, list) {
+ 		if (!port->rport || (id != port->rport->scsi_target_id))
+ 			continue;
+-		list_for_each_entry(unit, &port->unit_list_head, list)
+-			if (lun == unit->scsi_lun)
++		list_for_each_entry(unit, &port->unit_list_head, list) {
++			scsi_lun = scsilun_to_int(
++				(struct scsi_lun *)&unit->fcp_lun);
++			if (lun == scsi_lun)
+ 				return unit;
++		}
+ 	}
+ 
+ 	return NULL;
+@@ -183,7 +169,6 @@ static int zfcp_scsi_eh_abort_handler(st
+ 		return retval;
+ 	}
+ 	fsf_req->data = NULL;
+-	fsf_req->status |= ZFCP_STATUS_FSFREQ_ABORTING;
+ 
+ 	/* don't access old fsf_req after releasing the abort_lock */
+ 	write_unlock_irqrestore(&adapter->abort_lock, flags);
+@@ -294,7 +279,8 @@ int zfcp_adapter_scsi_register(struct zf
+ 					     sizeof (struct zfcp_adapter *));
+ 	if (!adapter->scsi_host) {
+ 		dev_err(&adapter->ccw_device->dev,
+-			"registration with SCSI stack failed.");
++			"Registering the FCP device with the "
++			"SCSI stack failed\n");
+ 		return -EIO;
+ 	}
+ 
+@@ -312,7 +298,6 @@ int zfcp_adapter_scsi_register(struct zf
+ 		scsi_host_put(adapter->scsi_host);
+ 		return -EIO;
+ 	}
+-	atomic_set_mask(ZFCP_STATUS_ADAPTER_REGISTERED, &adapter->status);
+ 
+ 	return 0;
+ }
+@@ -336,7 +321,6 @@ void zfcp_adapter_scsi_unregister(struct
+ 	scsi_remove_host(shost);
+ 	scsi_host_put(shost);
+ 	adapter->scsi_host = NULL;
+-	atomic_clear_mask(ZFCP_STATUS_ADAPTER_REGISTERED, &adapter->status);
+ 
+ 	return;
+ }
+Index: linux-2.6.27-gentoo-r7/drivers/s390/scsi/zfcp_sysfs.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/scsi/zfcp_sysfs.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/scsi/zfcp_sysfs.c
+@@ -26,9 +26,9 @@ static ZFCP_DEV_ATTR(_feat, _name, S_IRU
+ ZFCP_DEFINE_ATTR(zfcp_adapter, adapter, status, "0x%08x\n",
+ 		 atomic_read(&adapter->status));
+ ZFCP_DEFINE_ATTR(zfcp_adapter, adapter, peer_wwnn, "0x%016llx\n",
+-		 adapter->peer_wwnn);
++		 (unsigned long long) adapter->peer_wwnn);
+ ZFCP_DEFINE_ATTR(zfcp_adapter, adapter, peer_wwpn, "0x%016llx\n",
+-		 adapter->peer_wwpn);
++		 (unsigned long long) adapter->peer_wwpn);
+ ZFCP_DEFINE_ATTR(zfcp_adapter, adapter, peer_d_id, "0x%06x\n",
+ 		 adapter->peer_d_id);
+ ZFCP_DEFINE_ATTR(zfcp_adapter, adapter, card_version, "0x%04x\n",
+@@ -135,8 +135,9 @@ static ssize_t zfcp_sysfs_port_remove_st
+ {
+ 	struct zfcp_adapter *adapter = dev_get_drvdata(dev);
+ 	struct zfcp_port *port;
+-	wwn_t wwpn;
++	u64 wwpn;
+ 	int retval = 0;
++	LIST_HEAD(port_remove_lh);
+ 
+ 	down(&zfcp_data.config_sema);
+ 	if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_REMOVE) {
+@@ -144,7 +145,7 @@ static ssize_t zfcp_sysfs_port_remove_st
+ 		goto out;
+ 	}
+ 
+-	if (strict_strtoull(buf, 0, &wwpn)) {
++	if (strict_strtoull(buf, 0, (unsigned long long *) &wwpn)) {
+ 		retval = -EINVAL;
+ 		goto out;
+ 	}
+@@ -154,7 +155,7 @@ static ssize_t zfcp_sysfs_port_remove_st
+ 	if (port && (atomic_read(&port->refcount) == 0)) {
+ 		zfcp_port_get(port);
+ 		atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &port->status);
+-		list_move(&port->list, &adapter->port_remove_lh);
++		list_move(&port->list, &port_remove_lh);
+ 	} else
+ 		port = NULL;
+ 	write_unlock_irq(&zfcp_data.config_lock);
+@@ -200,7 +201,7 @@ static ssize_t zfcp_sysfs_unit_add_store
+ {
+ 	struct zfcp_port *port = dev_get_drvdata(dev);
+ 	struct zfcp_unit *unit;
+-	fcp_lun_t fcp_lun;
++	u64 fcp_lun;
+ 	int retval = -EINVAL;
+ 
+ 	down(&zfcp_data.config_sema);
+@@ -209,7 +210,7 @@ static ssize_t zfcp_sysfs_unit_add_store
+ 		goto out;
+ 	}
+ 
+-	if (strict_strtoull(buf, 0, &fcp_lun))
++	if (strict_strtoull(buf, 0, (unsigned long long *) &fcp_lun))
+ 		goto out;
+ 
+ 	unit = zfcp_unit_enqueue(port, fcp_lun);
+@@ -233,8 +234,9 @@ static ssize_t zfcp_sysfs_unit_remove_st
+ {
+ 	struct zfcp_port *port = dev_get_drvdata(dev);
+ 	struct zfcp_unit *unit;
+-	fcp_lun_t fcp_lun;
++	u64 fcp_lun;
+ 	int retval = 0;
++	LIST_HEAD(unit_remove_lh);
+ 
+ 	down(&zfcp_data.config_sema);
+ 	if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_REMOVE) {
+@@ -242,7 +244,7 @@ static ssize_t zfcp_sysfs_unit_remove_st
+ 		goto out;
+ 	}
+ 
+-	if (strict_strtoull(buf, 0, &fcp_lun)) {
++	if (strict_strtoull(buf, 0, (unsigned long long *) &fcp_lun)) {
+ 		retval = -EINVAL;
+ 		goto out;
+ 	}
+@@ -252,7 +254,7 @@ static ssize_t zfcp_sysfs_unit_remove_st
+ 	if (unit && (atomic_read(&unit->refcount) == 0)) {
+ 		zfcp_unit_get(unit);
+ 		atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &unit->status);
+-		list_move(&unit->list, &port->unit_remove_lh);
++		list_move(&unit->list, &unit_remove_lh);
+ 	} else
+ 		unit = NULL;
+ 
+@@ -273,22 +275,7 @@ out:
+ }
+ static DEVICE_ATTR(unit_remove, S_IWUSR, NULL, zfcp_sysfs_unit_remove_store);
+ 
+-static struct attribute *zfcp_port_ns_attrs[] = {
+-	&dev_attr_port_failed.attr,
+-	&dev_attr_port_in_recovery.attr,
+-	&dev_attr_port_status.attr,
+-	&dev_attr_port_access_denied.attr,
+-	NULL
+-};
+-
+-/**
+- * zfcp_sysfs_ns_port_attrs - sysfs attributes for nameserver
+- */
+-struct attribute_group zfcp_sysfs_ns_port_attrs = {
+-	.attrs = zfcp_port_ns_attrs,
+-};
+-
+-static struct attribute *zfcp_port_no_ns_attrs[] = {
++static struct attribute *zfcp_port_attrs[] = {
+ 	&dev_attr_unit_add.attr,
+ 	&dev_attr_unit_remove.attr,
+ 	&dev_attr_port_failed.attr,
+@@ -302,7 +289,7 @@ static struct attribute *zfcp_port_no_ns
+  * zfcp_sysfs_port_attrs - sysfs attributes for all other ports
+  */
+ struct attribute_group zfcp_sysfs_port_attrs = {
+-	.attrs = zfcp_port_no_ns_attrs,
++	.attrs = zfcp_port_attrs,
+ };
+ 
+ static struct attribute *zfcp_unit_attrs[] = {
+@@ -395,8 +382,10 @@ static DEVICE_ATTR(_name, S_IRUGO, zfcp_
+ 
+ ZFCP_DEFINE_SCSI_ATTR(hba_id, "%s\n",
+ 	unit->port->adapter->ccw_device->dev.bus_id);
+-ZFCP_DEFINE_SCSI_ATTR(wwpn, "0x%016llx\n", unit->port->wwpn);
+-ZFCP_DEFINE_SCSI_ATTR(fcp_lun, "0x%016llx\n", unit->fcp_lun);
++ZFCP_DEFINE_SCSI_ATTR(wwpn, "0x%016llx\n",
++		      (unsigned long long) unit->port->wwpn);
++ZFCP_DEFINE_SCSI_ATTR(fcp_lun, "0x%016llx\n",
++		      (unsigned long long) unit->fcp_lun);
+ 
+ struct device_attribute *zfcp_sysfs_sdev_attrs[] = {
+ 	&dev_attr_fcp_lun,
+@@ -487,10 +476,23 @@ ZFCP_SHOST_ATTR(megabytes, "%llu %llu\n"
+ ZFCP_SHOST_ATTR(seconds_active, "%llu\n",
+ 		(unsigned long long) stat_info.seconds_act);
+ 
++static ssize_t zfcp_sysfs_adapter_q_full_show(struct device *dev,
++					      struct device_attribute *attr,
++					      char *buf)
++{
++	struct Scsi_Host *scsi_host = class_to_shost(dev);
++	struct zfcp_adapter *adapter =
++		(struct zfcp_adapter *) scsi_host->hostdata[0];
++
++	return sprintf(buf, "%d\n", atomic_read(&adapter->qdio_outb_full));
++}
++static DEVICE_ATTR(queue_full, S_IRUGO, zfcp_sysfs_adapter_q_full_show, NULL);
++
+ struct device_attribute *zfcp_sysfs_shost_attrs[] = {
+ 	&dev_attr_utilization,
+ 	&dev_attr_requests,
+ 	&dev_attr_megabytes,
+ 	&dev_attr_seconds_active,
++	&dev_attr_queue_full,
+ 	NULL
+ };

Added: genpatches-2.6/trunk/2.6.27/1710_s390-01.patch
===================================================================
--- genpatches-2.6/trunk/2.6.27/1710_s390-01.patch	                        (rev 0)
+++ genpatches-2.6/trunk/2.6.27/1710_s390-01.patch	2008-12-30 20:30:00 UTC (rev 1452)
@@ -0,0 +1,6971 @@
+Index: linux-2.6.27-gentoo-r7/arch/s390/Kconfig
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/arch/s390/Kconfig
++++ linux-2.6.27-gentoo-r7/arch/s390/Kconfig
+@@ -222,6 +222,14 @@ config MARCH_Z9_109
+ 	  Class (z9 BC). The kernel will be slightly faster but will not
+ 	  work on older machines such as the z990, z890, z900, and z800.
+ 
++config MARCH_Z10
++	bool "IBM System z10"
++	help
++	  Select this to enable optimizations for IBM System z10. The
++	  kernel will be slightly faster but will not work on older
++	  machines such as the z990, z890, z900, z800, z9-109, z9-ec
++	  and z9-bc.
++
+ endchoice
+ 
+ config PACK_STACK
+Index: linux-2.6.27-gentoo-r7/arch/s390/Makefile
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/arch/s390/Makefile
++++ linux-2.6.27-gentoo-r7/arch/s390/Makefile
+@@ -34,6 +34,7 @@ cflags-$(CONFIG_MARCH_G5)   += $(call cc
+ cflags-$(CONFIG_MARCH_Z900) += $(call cc-option,-march=z900)
+ cflags-$(CONFIG_MARCH_Z990) += $(call cc-option,-march=z990)
+ cflags-$(CONFIG_MARCH_Z9_109) += $(call cc-option,-march=z9-109)
++cflags-$(CONFIG_MARCH_Z10) += $(call cc-option,-march=z10)
+ 
+ #KBUILD_IMAGE is necessary for make rpm
+ KBUILD_IMAGE	:=arch/s390/boot/image
+Index: linux-2.6.27-gentoo-r7/arch/s390/appldata/appldata.h
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/arch/s390/appldata/appldata.h
++++ linux-2.6.27-gentoo-r7/arch/s390/appldata/appldata.h
+@@ -26,10 +26,6 @@
+ #define CTL_APPLDATA_NET_SUM	2125
+ #define CTL_APPLDATA_PROC	2126
+ 
+-#define P_INFO(x...)	printk(KERN_INFO MY_PRINT_NAME " info: " x)
+-#define P_ERROR(x...)	printk(KERN_ERR MY_PRINT_NAME " error: " x)
+-#define P_WARNING(x...)	printk(KERN_WARNING MY_PRINT_NAME " status: " x)
+-
+ struct appldata_ops {
+ 	struct list_head list;
+ 	struct ctl_table_header *sysctl_header;
+Index: linux-2.6.27-gentoo-r7/arch/s390/appldata/appldata_base.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/arch/s390/appldata/appldata_base.c
++++ linux-2.6.27-gentoo-r7/arch/s390/appldata/appldata_base.c
+@@ -10,6 +10,9 @@
+  * Author: Gerald Schaefer <gerald.schaefer@××××××.com>
+  */
+ 
++#define KMSG_COMPONENT	"appldata"
++#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
++
+ #include <linux/module.h>
+ #include <linux/init.h>
+ #include <linux/slab.h>
+@@ -32,7 +35,6 @@
+ #include "appldata.h"
+ 
+ 
+-#define MY_PRINT_NAME	"appldata"		/* for debug messages, etc. */
+ #define APPLDATA_CPU_INTERVAL	10000		/* default (CPU) time for
+ 						   sampling interval in
+ 						   milliseconds */
+@@ -390,8 +392,8 @@ appldata_generic_handler(ctl_table *ctl,
+ 					(unsigned long) ops->data, ops->size,
+ 					ops->mod_lvl);
+ 		if (rc != 0) {
+-			P_ERROR("START DIAG 0xDC for %s failed, "
+-				"return code: %d\n", ops->name, rc);
++			pr_err("Starting the data collection for %s "
++			       "failed with rc=%d\n", ops->name, rc);
+ 			module_put(ops->owner);
+ 		} else
+ 			ops->active = 1;
+@@ -401,8 +403,8 @@ appldata_generic_handler(ctl_table *ctl,
+ 				(unsigned long) ops->data, ops->size,
+ 				ops->mod_lvl);
+ 		if (rc != 0)
+-			P_ERROR("STOP DIAG 0xDC for %s failed, "
+-				"return code: %d\n", ops->name, rc);
++			pr_err("Stopping the data collection for %s "
++			       "failed with rc=%d\n", ops->name, rc);
+ 		module_put(ops->owner);
+ 	}
+ 	spin_unlock(&appldata_ops_lock);
+Index: linux-2.6.27-gentoo-r7/arch/s390/appldata/appldata_os.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/arch/s390/appldata/appldata_os.c
++++ linux-2.6.27-gentoo-r7/arch/s390/appldata/appldata_os.c
+@@ -9,6 +9,9 @@
+  * Author: Gerald Schaefer <gerald.schaefer@××××××.com>
+  */
+ 
++#define KMSG_COMPONENT	"appldata"
++#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
++
+ #include <linux/module.h>
+ #include <linux/init.h>
+ #include <linux/slab.h>
+@@ -22,7 +25,6 @@
+ #include "appldata.h"
+ 
+ 
+-#define MY_PRINT_NAME	"appldata_os"		/* for debug messages, etc. */
+ #define LOAD_INT(x) ((x) >> FSHIFT)
+ #define LOAD_FRAC(x) LOAD_INT(((x) & (FIXED_1-1)) * 100)
+ 
+@@ -143,21 +145,16 @@ static void appldata_get_os_data(void *d
+ 					   (unsigned long) ops.data, new_size,
+ 					   ops.mod_lvl);
+ 			if (rc != 0)
+-				P_ERROR("os: START NEW DIAG 0xDC failed, "
+-					"return code: %d, new size = %i\n", rc,
+-					new_size);
++				pr_err("Starting a new OS data collection "
++				       "failed with rc=%d\n", rc);
+ 
+ 			rc = appldata_diag(APPLDATA_RECORD_OS_ID,
+ 					   APPLDATA_STOP_REC,
+ 					   (unsigned long) ops.data, ops.size,
+ 					   ops.mod_lvl);
+ 			if (rc != 0)
+-				P_ERROR("os: STOP OLD DIAG 0xDC failed, "
+-					"return code: %d, old size = %i\n", rc,
+-					ops.size);
+-			else
+-				P_INFO("os: old record size = %i stopped\n",
+-					ops.size);
++				pr_err("Stopping a faulty OS data "
++				       "collection failed with rc=%d\n", rc);
+ 		}
+ 		ops.size = new_size;
+ 	}
+@@ -178,8 +175,8 @@ static int __init appldata_os_init(void)
+ 	max_size = sizeof(struct appldata_os_data) +
+ 		   (NR_CPUS * sizeof(struct appldata_os_per_cpu));
+ 	if (max_size > APPLDATA_MAX_REC_SIZE) {
+-		P_ERROR("Max. size of OS record = %i, bigger than maximum "
+-			"record size (%i)\n", max_size, APPLDATA_MAX_REC_SIZE);
++		pr_err("Maximum OS record size %i exceeds the maximum "
++		       "record size %i\n", max_size, APPLDATA_MAX_REC_SIZE);
+ 		rc = -ENOMEM;
+ 		goto out;
+ 	}
+Index: linux-2.6.27-gentoo-r7/arch/s390/crypto/aes_s390.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/arch/s390/crypto/aes_s390.c
++++ linux-2.6.27-gentoo-r7/arch/s390/crypto/aes_s390.c
+@@ -17,6 +17,9 @@
+  *
+  */
+ 
++#define KMSG_COMPONENT "aes_s390"
++#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
++
+ #include <crypto/aes.h>
+ #include <crypto/algapi.h>
+ #include <linux/err.h>
+@@ -169,7 +172,8 @@ static int fallback_init_cip(struct cryp
+ 			CRYPTO_ALG_ASYNC | CRYPTO_ALG_NEED_FALLBACK);
+ 
+ 	if (IS_ERR(sctx->fallback.cip)) {
+-		printk(KERN_ERR "Error allocating fallback algo %s\n", name);
++		pr_err("Allocating AES fallback algorithm %s failed\n",
++		       name);
+ 		return PTR_ERR(sctx->fallback.blk);
+ 	}
+ 
+@@ -349,7 +353,8 @@ static int fallback_init_blk(struct cryp
+ 			CRYPTO_ALG_ASYNC | CRYPTO_ALG_NEED_FALLBACK);
+ 
+ 	if (IS_ERR(sctx->fallback.blk)) {
+-		printk(KERN_ERR "Error allocating fallback algo %s\n", name);
++		pr_err("Allocating AES fallback algorithm %s failed\n",
++		       name);
+ 		return PTR_ERR(sctx->fallback.blk);
+ 	}
+ 
+@@ -515,9 +520,8 @@ static int __init aes_s390_init(void)
+ 
+ 	/* z9 109 and z9 BC/EC only support 128 bit key length */
+ 	if (keylen_flag == AES_KEYLEN_128)
+-		printk(KERN_INFO
+-		       "aes_s390: hardware acceleration only available for "
+-		       "128 bit keys\n");
++		pr_info("AES hardware acceleration is only available for"
++			" 128-bit keys\n");
+ 
+ 	ret = crypto_register_alg(&aes_alg);
+ 	if (ret)
+Index: linux-2.6.27-gentoo-r7/arch/s390/hypfs/hypfs_diag.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/arch/s390/hypfs/hypfs_diag.c
++++ linux-2.6.27-gentoo-r7/arch/s390/hypfs/hypfs_diag.c
+@@ -3,10 +3,13 @@
+  *    Hypervisor filesystem for Linux on s390. Diag 204 and 224
+  *    implementation.
+  *
+- *    Copyright (C) IBM Corp. 2006
++ *    Copyright IBM Corp. 2006, 2008
+  *    Author(s): Michael Holzheu <holzheu@××××××.com>
+  */
+ 
++#define KMSG_COMPONENT "hypfs"
++#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
++
+ #include <linux/types.h>
+ #include <linux/errno.h>
+ #include <linux/string.h>
+@@ -527,13 +530,14 @@ __init int hypfs_diag_init(void)
+ 	int rc;
+ 
+ 	if (diag204_probe()) {
+-		printk(KERN_ERR "hypfs: diag 204 not working.");
++		pr_err("The hardware system does not support hypfs\n");
+ 		return -ENODATA;
+ 	}
+ 	rc = diag224_get_name_table();
+ 	if (rc) {
+ 		diag204_free_buffer();
+-		printk(KERN_ERR "hypfs: could not get name table.\n");
++		pr_err("The hardware system does not provide all "
++		       "functions required by hypfs\n");
+ 	}
+ 	return rc;
+ }
+Index: linux-2.6.27-gentoo-r7/arch/s390/hypfs/inode.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/arch/s390/hypfs/inode.c
++++ linux-2.6.27-gentoo-r7/arch/s390/hypfs/inode.c
+@@ -2,10 +2,13 @@
+  *  arch/s390/hypfs/inode.c
+  *    Hypervisor filesystem for Linux on s390.
+  *
+- *    Copyright (C) IBM Corp. 2006
++ *    Copyright IBM Corp. 2006, 2008
+  *    Author(s): Michael Holzheu <holzheu@××××××.com>
+  */
+ 
++#define KMSG_COMPONENT "hypfs"
++#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
++
+ #include <linux/types.h>
+ #include <linux/errno.h>
+ #include <linux/fs.h>
+@@ -200,7 +203,7 @@ static ssize_t hypfs_aio_write(struct ki
+ 	else
+ 		rc = hypfs_diag_create_files(sb, sb->s_root);
+ 	if (rc) {
+-		printk(KERN_ERR "hypfs: Update failed\n");
++		pr_err("Updating the hypfs tree failed\n");
+ 		hypfs_delete_tree(sb->s_root);
+ 		goto out;
+ 	}
+@@ -252,8 +255,7 @@ static int hypfs_parse_options(char *opt
+ 			break;
+ 		case opt_err:
+ 		default:
+-			printk(KERN_ERR "hypfs: Unrecognized mount option "
+-			       "\"%s\" or missing value\n", str);
++			pr_err("%s is not a valid mount option\n", str);
+ 			return -EINVAL;
+ 		}
+ 	}
+@@ -317,7 +319,7 @@ static int hypfs_fill_super(struct super
+ 	}
+ 	hypfs_update_update(sb);
+ 	sb->s_root = root_dentry;
+-	printk(KERN_INFO "hypfs: Hypervisor filesystem mounted\n");
++	pr_info("Hypervisor filesystem mounted\n");
+ 	return 0;
+ 
+ err_tree:
+@@ -513,7 +515,7 @@ fail_sysfs:
+ 	if (!MACHINE_IS_VM)
+ 		hypfs_diag_exit();
+ fail_diag:
+-	printk(KERN_ERR "hypfs: Initialization failed with rc = %i.\n", rc);
++	pr_err("Initialization of hypfs failed with rc=%i\n", rc);
+ 	return rc;
+ }
+ 
+Index: linux-2.6.27-gentoo-r7/arch/s390/include/asm/isc.h
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/arch/s390/include/asm/isc.h
++++ linux-2.6.27-gentoo-r7/arch/s390/include/asm/isc.h
+@@ -17,6 +17,7 @@
+ #define CHSC_SCH_ISC 7			/* CHSC subchannels */
+ /* Adapter interrupts. */
+ #define QDIO_AIRQ_ISC IO_SCH_ISC	/* I/O subchannel in qdio mode */
++#define AP_ISC 6			/* adjunct processor (crypto) devices */
+ 
+ /* Functions for registration of I/O interruption subclasses */
+ void isc_register(unsigned int isc);
+Index: linux-2.6.27-gentoo-r7/arch/s390/include/asm/qdio.h
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/arch/s390/include/asm/qdio.h
++++ linux-2.6.27-gentoo-r7/arch/s390/include/asm/qdio.h
+@@ -299,7 +299,13 @@ struct qdio_ssqd_desc {
+ 	u8 mbccnt;
+ 	u16 qdioac2;
+ 	u64 sch_token;
+-	u64:64;
++	u8 mro;
++	u8 mri;
++	u8:8;
++	u8 sbalic;
++	u16:16;
++	u8:8;
++	u8 mmwc;
+ } __attribute__ ((packed));
+ 
+ /* params are: ccw_device, qdio_error, queue_number,
+Index: linux-2.6.27-gentoo-r7/arch/s390/include/asm/sysinfo.h
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/arch/s390/include/asm/sysinfo.h
++++ linux-2.6.27-gentoo-r7/arch/s390/include/asm/sysinfo.h
+@@ -118,4 +118,15 @@ static inline int stsi(void *sysinfo, in
+ 	return r0;
+ }
+ 
++/*
++ * Service level reporting interface.
++ */
++struct service_level {
++	struct list_head list;
++	void (*seq_print)(struct seq_file *, struct service_level *);
++};
++
++int register_service_level(struct service_level *);
++int unregister_service_level(struct service_level *);
++
+ #endif /* __ASM_S390_SYSINFO_H */
+Index: linux-2.6.27-gentoo-r7/arch/s390/include/asm/system.h
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/arch/s390/include/asm/system.h
++++ linux-2.6.27-gentoo-r7/arch/s390/include/asm/system.h
+@@ -12,6 +12,7 @@
+ #define __ASM_SYSTEM_H
+ 
+ #include <linux/kernel.h>
++#include <linux/errno.h>
+ #include <asm/types.h>
+ #include <asm/ptrace.h>
+ #include <asm/setup.h>
+@@ -413,8 +414,6 @@ __set_psw_mask(unsigned long mask)
+ #define local_mcck_enable()  __set_psw_mask(psw_kernel_bits)
+ #define local_mcck_disable() __set_psw_mask(psw_kernel_bits & ~PSW_MASK_MCHECK)
+ 
+-int stfle(unsigned long long *list, int doublewords);
+-
+ #ifdef CONFIG_SMP
+ 
+ extern void smp_ctl_set_bit(int cr, int bit);
+@@ -438,6 +437,23 @@ static inline unsigned int stfl(void)
+ 	return S390_lowcore.stfl_fac_list;
+ }
+ 
++static inline int __stfle(unsigned long long *list, int doublewords)
++{
++	typedef struct { unsigned long long _[doublewords]; } addrtype;
++	register unsigned long __nr asm("0") = doublewords - 1;
++
++	asm volatile(".insn s,0xb2b00000,%0" /* stfle */
++		     : "=m" (*(addrtype *) list), "+d" (__nr) : : "cc");
++	return __nr + 1;
++}
++
++static inline int stfle(unsigned long long *list, int doublewords)
++{
++	if (!(stfl() & (1UL << 24)))
++		return -EOPNOTSUPP;
++	return __stfle(list, doublewords);
++}
++
+ static inline unsigned short stap(void)
+ {
+ 	unsigned short cpu_address;
+Index: linux-2.6.27-gentoo-r7/arch/s390/kernel/Makefile
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/arch/s390/kernel/Makefile
++++ linux-2.6.27-gentoo-r7/arch/s390/kernel/Makefile
+@@ -12,8 +12,8 @@ CFLAGS_smp.o	:= -Wno-nonnull
+ #
+ CFLAGS_ptrace.o		+= -DUTS_MACHINE='"$(UTS_MACHINE)"'
+ 
+-obj-y	:=  bitmap.o traps.o time.o process.o base.o early.o \
+-            setup.o sys_s390.o ptrace.o signal.o cpcmd.o ebcdic.o \
++obj-y	:=  bitmap.o traps.o time.o process.o base.o early.o setup.o \
++	    processor.o sys_s390.o ptrace.o signal.o cpcmd.o ebcdic.o \
+ 	    s390_ext.o debug.o irq.o ipl.o dis.o diag.o mem_detect.o
+ 
+ obj-y	+= $(if $(CONFIG_64BIT),entry64.o,entry.o)
+Index: linux-2.6.27-gentoo-r7/arch/s390/kernel/cpcmd.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/arch/s390/kernel/cpcmd.c
++++ linux-2.6.27-gentoo-r7/arch/s390/kernel/cpcmd.c
+@@ -7,6 +7,9 @@
+  *               Christian Borntraeger (cborntra@××××××.com),
+  */
+ 
++#define KMSG_COMPONENT "cpcmd"
++#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
++
+ #include <linux/kernel.h>
+ #include <linux/module.h>
+ #include <linux/slab.h>
+@@ -104,8 +107,8 @@ int cpcmd(const char *cmd, char *respons
+ 			(((unsigned long)response + rlen) >> 31)) {
+ 		lowbuf = kmalloc(rlen, GFP_KERNEL | GFP_DMA);
+ 		if (!lowbuf) {
+-			printk(KERN_WARNING
+-				"cpcmd: could not allocate response buffer\n");
++			pr_warning("The cpcmd kernel function failed to "
++				   "allocate a response buffer\n");
+ 			return -ENOMEM;
+ 		}
+ 		spin_lock_irqsave(&cpcmd_lock, flags);
+Index: linux-2.6.27-gentoo-r7/arch/s390/kernel/debug.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/arch/s390/kernel/debug.c
++++ linux-2.6.27-gentoo-r7/arch/s390/kernel/debug.c
+@@ -10,6 +10,9 @@
+  *    Bugreports to: <Linux390@××××××.com>
+  */
+ 
++#define KMSG_COMPONENT "s390dbf"
++#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
++
+ #include <linux/stddef.h>
+ #include <linux/kernel.h>
+ #include <linux/errno.h>
+@@ -693,8 +696,8 @@ debug_info_t *debug_register_mode(const 
+ 	/* Since debugfs currently does not support uid/gid other than root, */
+ 	/* we do not allow gid/uid != 0 until we get support for that. */
+ 	if ((uid != 0) || (gid != 0))
+-		printk(KERN_WARNING "debug: Warning - Currently only uid/gid "
+-		       "= 0 are supported. Using root as owner now!");
++		pr_warning("Root becomes the owner of all s390dbf files "
++			   "in sysfs\n");
+ 	if (!initialized)
+ 		BUG();
+ 	mutex_lock(&debug_mutex);
+@@ -709,7 +712,7 @@ debug_info_t *debug_register_mode(const 
+ 	debug_register_view(rc, &debug_pages_view);
+ out:
+         if (!rc){
+-		printk(KERN_ERR "debug: debug_register failed for %s\n",name);
++		pr_err("Registering debug feature %s failed\n", name);
+         }
+ 	mutex_unlock(&debug_mutex);
+ 	return rc;
+@@ -763,8 +766,8 @@ debug_set_size(debug_info_t* id, int nr_
+ 	if(pages_per_area > 0){
+ 		new_areas = debug_areas_alloc(pages_per_area, nr_areas);
+ 		if(!new_areas) {
+-			printk(KERN_WARNING "debug: could not allocate memory "\
+-					 "for pagenumber: %i\n",pages_per_area);
++			pr_info("Allocating memory for %i pages failed\n",
++				pages_per_area);
+ 			rc = -ENOMEM;
+ 			goto out;
+ 		}
+@@ -780,8 +783,7 @@ debug_set_size(debug_info_t* id, int nr_
+ 	memset(id->active_entries,0,sizeof(int)*id->nr_areas);
+ 	memset(id->active_pages, 0, sizeof(int)*id->nr_areas);
+ 	spin_unlock_irqrestore(&id->lock,flags);
+-	printk(KERN_INFO "debug: %s: set new size (%i pages)\n"\
+-			 ,id->name, pages_per_area);
++	pr_info("%s: set new size (%i pages)\n" ,id->name, pages_per_area);
+ out:
+ 	return rc;
+ }
+@@ -800,10 +802,9 @@ debug_set_level(debug_info_t* id, int ne
+ 	spin_lock_irqsave(&id->lock,flags);
+         if(new_level == DEBUG_OFF_LEVEL){
+                 id->level = DEBUG_OFF_LEVEL;
+-                printk(KERN_INFO "debug: %s: switched off\n",id->name);
++		pr_info("%s: switched off\n",id->name);
+         } else if ((new_level > DEBUG_MAX_LEVEL) || (new_level < 0)) {
+-                printk(KERN_INFO
+-                        "debug: %s: level %i is out of range (%i - %i)\n",
++		pr_info("%s: level %i is out of range (%i - %i)\n",
+                         id->name, new_level, 0, DEBUG_MAX_LEVEL);
+         } else {
+                 id->level = new_level;
+@@ -1108,8 +1109,8 @@ debug_register_view(debug_info_t * id, s
+ 	pde = debugfs_create_file(view->name, mode, id->debugfs_root_entry,
+ 				id , &debug_file_ops);
+ 	if (!pde){
+-		printk(KERN_WARNING "debug: debugfs_create_file() failed!"\
+-			" Cannot register view %s/%s\n", id->name,view->name);
++		pr_err("Registering view %s/%s failed due to out of "
++		       "memory\n", id->name,view->name);
+ 		rc = -1;
+ 		goto out;
+ 	}
+@@ -1119,10 +1120,8 @@ debug_register_view(debug_info_t * id, s
+ 			break;
+ 	}
+ 	if (i == DEBUG_MAX_VIEWS) {
+-		printk(KERN_WARNING "debug: cannot register view %s/%s\n",
+-			id->name,view->name);
+-		printk(KERN_WARNING 
+-			"debug: maximum number of views reached (%i)!\n", i);
++		pr_err("Registering view %s/%s would exceed the maximum "
++		       "number of views %i\n", id->name, view->name, i);
+ 		debugfs_remove(pde);
+ 		rc = -1;
+ 	} else {
+@@ -1303,7 +1302,8 @@ debug_input_level_fn(debug_info_t * id, 
+ 		new_level = debug_get_uint(str);
+ 	}
+ 	if(new_level < 0) {
+-		printk(KERN_INFO "debug: level `%s` is not valid\n", str);
++		pr_warning("%s is not a valid level for a debug "
++			   "feature\n", str);
+ 		rc = -EINVAL;
+ 	} else {
+ 		debug_set_level(id, new_level);
+@@ -1380,7 +1380,8 @@ debug_input_flush_fn(debug_info_t * id, 
+                 goto out;
+         }
+ 
+-        printk(KERN_INFO "debug: area `%c` is not valid\n", input_buf[0]);
++	pr_info("Flushing debug data failed because %c is not a valid "
++		 "area\n", input_buf[0]);
+ 
+ out:
+         *offset += user_len;
+Index: linux-2.6.27-gentoo-r7/arch/s390/kernel/head.S
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/arch/s390/kernel/head.S
++++ linux-2.6.27-gentoo-r7/arch/s390/kernel/head.S
+@@ -461,6 +461,55 @@ start:
+ 	.byte 0xf0,0xf1,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7
+ 	.byte 0xf8,0xf9,0xfa,0xfb,0xfc,0xfd,0xfe,0xff
+ 
++#
++# startup-code at 0x10000, running in absolute addressing mode
++# this is called either by the ipl loader or directly by PSW restart
++# or linload or SALIPL
++#
++	.org	0x10000
++startup:basr	%r13,0			# get base
++.LPG0:
++
++#ifndef CONFIG_MARCH_G5
++	# check processor version against MARCH_{G5,Z900,Z990,Z9_109,Z10}
++	stidp	__LC_CPUID		# store cpuid
++	lhi	%r0,(3f-2f) / 2
++	la	%r1,2f-.LPG0(%r13)
++0:	clc	__LC_CPUID+4(2),0(%r1)
++	jne	3f
++	lpsw	1f-.LPG0(13)		# machine type not good enough, crash
++	.align 16
++1:	.long	0x000a0000,0x00000000
++2:
++#if defined(CONFIG_MARCH_Z10)
++	.short 0x9672, 0x2064, 0x2066, 0x2084, 0x2086, 0x2094, 0x2096
++#elif defined(CONFIG_MARCH_Z9_109)
++	.short 0x9672, 0x2064, 0x2066, 0x2084, 0x2086
++#elif defined(CONFIG_MARCH_Z990)
++	.short 0x9672, 0x2064, 0x2066
++#elif defined(CONFIG_MARCH_Z900)
++	.short 0x9672
++#endif
++3:	la	%r1,2(%r1)
++	brct	%r0,0b
++#endif
++
++	l	%r13,0f-.LPG0(%r13)
++	b	0(%r13)
++0:	.long	startup_continue
++
++#
++# params at 10400 (setup.h)
++#
++	.org	PARMAREA
++	.long	0,0			# IPL_DEVICE
++	.long	0,0			# INITRD_START
++	.long	0,0			# INITRD_SIZE
++
++	.org	COMMAND_LINE
++	.byte	"root=/dev/ram0 ro"
++	.byte	0
++
+ #ifdef CONFIG_64BIT
+ #include "head64.S"
+ #else
+Index: linux-2.6.27-gentoo-r7/arch/s390/kernel/head31.S
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/arch/s390/kernel/head31.S
++++ linux-2.6.27-gentoo-r7/arch/s390/kernel/head31.S
+@@ -10,34 +10,13 @@
+  *
+  */
+ 
+-#
+-# startup-code at 0x10000, running in absolute addressing mode
+-# this is called either by the ipl loader or directly by PSW restart
+-# or linload or SALIPL
+-#
+-	.org	0x10000
+-startup:basr	%r13,0			# get base
+-.LPG0:	l	%r13,0f-.LPG0(%r13)
+-	b	0(%r13)
+-0:	.long	startup_continue
+-
+-#
+-# params at 10400 (setup.h)
+-#
+-	.org	PARMAREA
+-	.long	0,0			# IPL_DEVICE
+-	.long	0,0			# INITRD_START
+-	.long	0,0			# INITRD_SIZE
+-
+-	.org	COMMAND_LINE
+-	.byte	"root=/dev/ram0 ro"
+-	.byte	0
+-
+ 	.org	0x11000
+ 
+ startup_continue:
+ 	basr	%r13,0			# get base
+-.LPG1:	mvi	__LC_AR_MODE_ID,0	# set ESA flag (mode 0)
++.LPG1:
++
++	mvi	__LC_AR_MODE_ID,0	# set ESA flag (mode 0)
+ 	lctl	%c0,%c15,.Lctl-.LPG1(%r13) # load control registers
+ 	l	%r12,.Lparmaddr-.LPG1(%r13) # pointer to parameter area
+ 					# move IPL device to lowcore
+Index: linux-2.6.27-gentoo-r7/arch/s390/kernel/head64.S
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/arch/s390/kernel/head64.S
++++ linux-2.6.27-gentoo-r7/arch/s390/kernel/head64.S
+@@ -10,29 +10,6 @@
+  *
+  */
+ 
+-#
+-# startup-code at 0x10000, running in absolute addressing mode
+-# this is called either by the ipl loader or directly by PSW restart
+-# or linload or SALIPL
+-#
+-	.org	0x10000
+-startup:basr	%r13,0			# get base
+-.LPG0:	l	%r13,0f-.LPG0(%r13)
+-	b	0(%r13)
+-0:	.long	startup_continue
+-
+-#
+-# params at 10400 (setup.h)
+-#
+-	.org	PARMAREA
+-	.quad	0			# IPL_DEVICE
+-	.quad	0			# INITRD_START
+-	.quad	0			# INITRD_SIZE
+-
+-	.org	COMMAND_LINE
+-	.byte	"root=/dev/ram0 ro"
+-	.byte	0
+-
+ 	.org	0x11000
+ 
+ startup_continue:
+Index: linux-2.6.27-gentoo-r7/arch/s390/kernel/processor.c
+===================================================================
+--- /dev/null
++++ linux-2.6.27-gentoo-r7/arch/s390/kernel/processor.c
+@@ -0,0 +1,98 @@
++/*
++ *  arch/s390/kernel/processor.c
++ *
++ *  Copyright IBM Corp. 2008
++ *  Author(s): Martin Schwidefsky (schwidefsky@××××××.com)
++ */
++
++#define KMSG_COMPONENT "cpu"
++#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
++
++#include <linux/kernel.h>
++#include <linux/init.h>
++#include <linux/smp.h>
++#include <linux/seq_file.h>
++#include <linux/delay.h>
++
++#include <asm/elf.h>
++#include <asm/lowcore.h>
++#include <asm/param.h>
++
++void __cpuinit print_cpu_info(struct cpuinfo_S390 *cpuinfo)
++{
++	pr_info("Processor %d started, address %d, identification %06X\n",
++		cpuinfo->cpu_nr, cpuinfo->cpu_addr, cpuinfo->cpu_id.ident);
++}
++
++/*
++ * show_cpuinfo - Get information on one CPU for use by procfs.
++ */
++
++static int show_cpuinfo(struct seq_file *m, void *v)
++{
++	static const char *hwcap_str[8] = {
++		"esan3", "zarch", "stfle", "msa", "ldisp", "eimm", "dfp",
++		"edat"
++	};
++       struct cpuinfo_S390 *cpuinfo;
++       unsigned long n = (unsigned long) v - 1;
++       int i;
++
++       s390_adjust_jiffies();
++       preempt_disable();
++       if (!n) {
++	       seq_printf(m, "vendor_id       : IBM/S390\n"
++			  "# processors    : %i\n"
++			  "bogomips per cpu: %lu.%02lu\n",
++			  num_online_cpus(), loops_per_jiffy/(500000/HZ),
++			  (loops_per_jiffy/(5000/HZ))%100);
++	       seq_puts(m, "features\t: ");
++	       for (i = 0; i < 8; i++)
++		       if (hwcap_str[i] && (elf_hwcap & (1UL << i)))
++			       seq_printf(m, "%s ", hwcap_str[i]);
++	       seq_puts(m, "\n");
++       }
++
++       if (cpu_online(n)) {
++#ifdef CONFIG_SMP
++	       if (smp_processor_id() == n)
++		       cpuinfo = &S390_lowcore.cpu_data;
++	       else
++		       cpuinfo = &lowcore_ptr[n]->cpu_data;
++#else
++	       cpuinfo = &S390_lowcore.cpu_data;
++#endif
++	       seq_printf(m, "processor %li: "
++			  "version = %02X,  "
++			  "identification = %06X,  "
++			  "machine = %04X\n",
++			  n, cpuinfo->cpu_id.version,
++			  cpuinfo->cpu_id.ident,
++			  cpuinfo->cpu_id.machine);
++       }
++       preempt_enable();
++       return 0;
++}
++
++static void *c_start(struct seq_file *m, loff_t *pos)
++{
++	return *pos < NR_CPUS ? (void *)((unsigned long) *pos + 1) : NULL;
++}
++
++static void *c_next(struct seq_file *m, void *v, loff_t *pos)
++{
++	++*pos;
++	return c_start(m, pos);
++}
++
++static void c_stop(struct seq_file *m, void *v)
++{
++}
++
++const struct seq_operations cpuinfo_op = {
++	.start	= c_start,
++	.next	= c_next,
++	.stop	= c_stop,
++	.show	= show_cpuinfo,
++};
++
+Index: linux-2.6.27-gentoo-r7/arch/s390/kernel/setup.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/arch/s390/kernel/setup.c
++++ linux-2.6.27-gentoo-r7/arch/s390/kernel/setup.c
+@@ -14,6 +14,9 @@
+  * This file handles the architecture-dependent parts of initialization
+  */
+ 
++#define KMSG_COMPONENT "setup"
++#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
++
+ #include <linux/errno.h>
+ #include <linux/module.h>
+ #include <linux/sched.h>
+@@ -32,7 +35,6 @@
+ #include <linux/bootmem.h>
+ #include <linux/root_dev.h>
+ #include <linux/console.h>
+-#include <linux/seq_file.h>
+ #include <linux/kernel_stat.h>
+ #include <linux/device.h>
+ #include <linux/notifier.h>
+@@ -291,8 +293,8 @@ unsigned int switch_amode = 0;
+ #endif
+ EXPORT_SYMBOL_GPL(switch_amode);
+ 
+-static void set_amode_and_uaccess(unsigned long user_amode,
+-				  unsigned long user32_amode)
++static int set_amode_and_uaccess(unsigned long user_amode,
++				 unsigned long user32_amode)
+ {
+ 	psw_user_bits = PSW_BASE_BITS | PSW_MASK_DAT | user_amode |
+ 			PSW_MASK_IO | PSW_MASK_EXT | PSW_MASK_MCHECK |
+@@ -309,11 +311,11 @@ static void set_amode_and_uaccess(unsign
+ 			  PSW_MASK_MCHECK | PSW_DEFAULT_KEY;
+ 
+ 	if (MACHINE_HAS_MVCOS) {
+-		printk("mvcos available.\n");
+ 		memcpy(&uaccess, &uaccess_mvcos_switch, sizeof(uaccess));
++		return 1;
+ 	} else {
+-		printk("mvcos not available.\n");
+ 		memcpy(&uaccess, &uaccess_pt, sizeof(uaccess));
++		return 0;
+ 	}
+ }
+ 
+@@ -328,9 +330,10 @@ static int __init early_parse_switch_amo
+ early_param("switch_amode", early_parse_switch_amode);
+ 
+ #else /* CONFIG_S390_SWITCH_AMODE */
+-static inline void set_amode_and_uaccess(unsigned long user_amode,
+-					 unsigned long user32_amode)
++static inline int set_amode_and_uaccess(unsigned long user_amode,
++					unsigned long user32_amode)
+ {
++	return 0;
+ }
+ #endif /* CONFIG_S390_SWITCH_AMODE */
+ 
+@@ -355,11 +358,20 @@ early_param("noexec", early_parse_noexec
+ static void setup_addressing_mode(void)
+ {
+ 	if (s390_noexec) {
+-		printk("S390 execute protection active, ");
+-		set_amode_and_uaccess(PSW_ASC_SECONDARY, PSW32_ASC_SECONDARY);
++		if (set_amode_and_uaccess(PSW_ASC_SECONDARY,
++					  PSW32_ASC_SECONDARY))
++			pr_info("Execute protection active, "
++				"mvcos available\n");
++		else
++			pr_info("Execute protection active, "
++				"mvcos not available\n");
+ 	} else if (switch_amode) {
+-		printk("S390 address spaces switched, ");
+-		set_amode_and_uaccess(PSW_ASC_PRIMARY, PSW32_ASC_PRIMARY);
++		if (set_amode_and_uaccess(PSW_ASC_PRIMARY, PSW32_ASC_PRIMARY))
++			pr_info("Address spaces switched, "
++				"mvcos available\n");
++		else
++			pr_info("Address spaces switched, "
++				"mvcos not available\n");
+ 	}
+ #ifdef CONFIG_TRACE_IRQFLAGS
+ 	sysc_restore_trace_psw.mask = psw_kernel_bits & ~PSW_MASK_MCHECK;
+@@ -572,15 +584,15 @@ setup_memory(void)
+ 			start = PFN_PHYS(start_pfn) + bmap_size + PAGE_SIZE;
+ 
+ 			if (start + INITRD_SIZE > memory_end) {
+-				printk("initrd extends beyond end of memory "
+-				       "(0x%08lx > 0x%08lx)\n"
++				pr_err("initrd extends beyond end of "
++				       "memory (0x%08lx > 0x%08lx) "
+ 				       "disabling initrd\n",
+ 				       start + INITRD_SIZE, memory_end);
+ 				INITRD_START = INITRD_SIZE = 0;
+ 			} else {
+-				printk("Moving initrd (0x%08lx -> 0x%08lx, "
+-				       "size: %ld)\n",
+-				       INITRD_START, start, INITRD_SIZE);
++				pr_info("Moving initrd (0x%08lx -> "
++					"0x%08lx, size: %ld)\n",
++					INITRD_START, start, INITRD_SIZE);
+ 				memmove((void *) start, (void *) INITRD_START,
+ 					INITRD_SIZE);
+ 				INITRD_START = start;
+@@ -642,8 +654,9 @@ setup_memory(void)
+ 			initrd_start = INITRD_START;
+ 			initrd_end = initrd_start + INITRD_SIZE;
+ 		} else {
+-			printk("initrd extends beyond end of memory "
+-			       "(0x%08lx > 0x%08lx)\ndisabling initrd\n",
++			pr_err("initrd extends beyond end of "
++			       "memory (0x%08lx > 0x%08lx) "
++			       "disabling initrd\n",
+ 			       initrd_start + INITRD_SIZE, memory_end);
+ 			initrd_start = initrd_end = 0;
+ 		}
+@@ -651,23 +664,6 @@ setup_memory(void)
+ #endif
+ }
+ 
+-static int __init __stfle(unsigned long long *list, int doublewords)
+-{
+-	typedef struct { unsigned long long _[doublewords]; } addrtype;
+-	register unsigned long __nr asm("0") = doublewords - 1;
+-
+-	asm volatile(".insn s,0xb2b00000,%0" /* stfle */
+-		     : "=m" (*(addrtype *) list), "+d" (__nr) : : "cc");
+-	return __nr + 1;
+-}
+-
+-int __init stfle(unsigned long long *list, int doublewords)
+-{
+-	if (!(stfl() & (1UL << 24)))
+-		return -EOPNOTSUPP;
+-	return __stfle(list, doublewords);
+-}
+-
+ /*
+  * Setup hardware capabilities.
+  */
+@@ -756,21 +752,27 @@ setup_arch(char **cmdline_p)
+          * print what head.S has found out about the machine
+          */
+ #ifndef CONFIG_64BIT
+-	printk((MACHINE_IS_VM) ?
+-	       "We are running under VM (31 bit mode)\n" :
+-	       "We are running native (31 bit mode)\n");
+-	printk((MACHINE_HAS_IEEE) ?
+-	       "This machine has an IEEE fpu\n" :
+-	       "This machine has no IEEE fpu\n");
++	if (MACHINE_IS_VM)
++		pr_info("Linux is running as a z/VM "
++			"guest operating system in 31-bit mode\n");
++	else
++		pr_info("Linux is running natively in 31-bit mode\n");
++	if (MACHINE_HAS_IEEE)
++		pr_info("The hardware system has IEEE compatible "
++			"floating point units\n");
++	else
++		pr_info("The hardware system has no IEEE compatible "
++			"floating point units\n");
+ #else /* CONFIG_64BIT */
+ 	if (MACHINE_IS_VM)
+-		printk("We are running under VM (64 bit mode)\n");
++		pr_info("Linux is running as a z/VM "
++			"guest operating system in 64-bit mode\n");
+ 	else if (MACHINE_IS_KVM) {
+-		printk("We are running under KVM (64 bit mode)\n");
++		pr_info("Linux is running under KVM in 64-bit mode\n");
+ 		add_preferred_console("hvc", 0, NULL);
+ 		s390_virtio_console_init();
+ 	} else
+-		printk("We are running native (64 bit mode)\n");
++		pr_info("Linux is running natively in 64-bit mode\n");
+ #endif /* CONFIG_64BIT */
+ 
+ 	/* Have one command line that is parsed and saved in /proc/cmdline */
+@@ -818,90 +820,3 @@ setup_arch(char **cmdline_p)
+ 	/* Setup zfcpdump support */
+ 	setup_zfcpdump(console_devno);
+ }
+-
+-void __cpuinit print_cpu_info(struct cpuinfo_S390 *cpuinfo)
+-{
+-   printk(KERN_INFO "cpu %d "
+-#ifdef CONFIG_SMP
+-           "phys_idx=%d "
+-#endif
+-           "vers=%02X ident=%06X machine=%04X unused=%04X\n",
+-           cpuinfo->cpu_nr,
+-#ifdef CONFIG_SMP
+-           cpuinfo->cpu_addr,
+-#endif
+-           cpuinfo->cpu_id.version,
+-           cpuinfo->cpu_id.ident,
+-           cpuinfo->cpu_id.machine,
+-           cpuinfo->cpu_id.unused);
+-}
+-
+-/*
+- * show_cpuinfo - Get information on one CPU for use by procfs.
+- */
+-
+-static int show_cpuinfo(struct seq_file *m, void *v)
+-{
+-	static const char *hwcap_str[8] = {
+-		"esan3", "zarch", "stfle", "msa", "ldisp", "eimm", "dfp",
+-		"edat"
+-	};
+-        struct cpuinfo_S390 *cpuinfo;
+-	unsigned long n = (unsigned long) v - 1;
+-	int i;
+-
+-	s390_adjust_jiffies();
+-	preempt_disable();
+-	if (!n) {
+-		seq_printf(m, "vendor_id       : IBM/S390\n"
+-			       "# processors    : %i\n"
+-			       "bogomips per cpu: %lu.%02lu\n",
+-			       num_online_cpus(), loops_per_jiffy/(500000/HZ),
+-			       (loops_per_jiffy/(5000/HZ))%100);
+-		seq_puts(m, "features\t: ");
+-		for (i = 0; i < 8; i++)
+-			if (hwcap_str[i] && (elf_hwcap & (1UL << i)))
+-				seq_printf(m, "%s ", hwcap_str[i]);
+-		seq_puts(m, "\n");
+-	}
+-
+-	if (cpu_online(n)) {
+-#ifdef CONFIG_SMP
+-		if (smp_processor_id() == n)
+-			cpuinfo = &S390_lowcore.cpu_data;
+-		else
+-			cpuinfo = &lowcore_ptr[n]->cpu_data;
+-#else
+-		cpuinfo = &S390_lowcore.cpu_data;
+-#endif
+-		seq_printf(m, "processor %li: "
+-			       "version = %02X,  "
+-			       "identification = %06X,  "
+-			       "machine = %04X\n",
+-			       n, cpuinfo->cpu_id.version,
+-			       cpuinfo->cpu_id.ident,
+-			       cpuinfo->cpu_id.machine);
+-	}
+-	preempt_enable();
+-        return 0;
+-}
+-
+-static void *c_start(struct seq_file *m, loff_t *pos)
+-{
+-	return *pos < NR_CPUS ? (void *)((unsigned long) *pos + 1) : NULL;
+-}
+-static void *c_next(struct seq_file *m, void *v, loff_t *pos)
+-{
+-	++*pos;
+-	return c_start(m, pos);
+-}
+-static void c_stop(struct seq_file *m, void *v)
+-{
+-}
+-const struct seq_operations cpuinfo_op = {
+-	.start	= c_start,
+-	.next	= c_next,
+-	.stop	= c_stop,
+-	.show	= show_cpuinfo,
+-};
+-
+Index: linux-2.6.27-gentoo-r7/arch/s390/kernel/smp.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/arch/s390/kernel/smp.c
++++ linux-2.6.27-gentoo-r7/arch/s390/kernel/smp.c
+@@ -20,6 +20,9 @@
+  * cpu_number_map in other architectures.
+  */
+ 
++#define KMSG_COMPONENT "cpu"
++#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
++
+ #include <linux/module.h>
+ #include <linux/init.h>
+ #include <linux/mm.h>
+@@ -388,8 +391,8 @@ static void __init smp_get_save_area(uns
+ 	if (ipl_info.type != IPL_TYPE_FCP_DUMP)
+ 		return;
+ 	if (cpu >= NR_CPUS) {
+-		printk(KERN_WARNING "Registers for cpu %i not saved since dump "
+-		       "kernel was compiled with NR_CPUS=%i\n", cpu, NR_CPUS);
++		pr_warning("CPU %i exceeds the maximum %i and is excluded from "
++			   "the dump\n", cpu, NR_CPUS - 1);
+ 		return;
+ 	}
+ 	zfcpdump_save_areas[cpu] = kmalloc(sizeof(union save_area), GFP_KERNEL);
+@@ -562,7 +565,7 @@ static void __init smp_detect_cpus(void)
+ 	}
+ out:
+ 	kfree(info);
+-	printk(KERN_INFO "CPUs: %d configured, %d standby\n", c_cpus, s_cpus);
++	pr_info("%d configured CPUs, %d standby CPUs\n", c_cpus, s_cpus);
+ 	get_online_cpus();
+ 	__smp_rescan_cpus();
+ 	put_online_cpus();
+@@ -688,12 +691,8 @@ int __cpuinit __cpu_up(unsigned int cpu)
+ 
+ 	ccode = signal_processor_p((__u32)(unsigned long)(lowcore_ptr[cpu]),
+ 				   cpu, sigp_set_prefix);
+-	if (ccode) {
+-		printk("sigp_set_prefix failed for cpu %d "
+-		       "with condition code %d\n",
+-		       (int) cpu, (int) ccode);
++	if (ccode)
+ 		return -EIO;
+-	}
+ 
+ 	idle = current_set[cpu];
+ 	cpu_lowcore = lowcore_ptr[cpu];
+@@ -776,7 +775,7 @@ void __cpu_die(unsigned int cpu)
+ 	while (!smp_cpu_not_running(cpu))
+ 		cpu_relax();
+ 	smp_free_lowcore(cpu);
+-	printk(KERN_INFO "Processor %d spun down\n", cpu);
++	pr_info("Processor %d stopped\n", cpu);
+ }
+ 
+ void cpu_die(void)
+Index: linux-2.6.27-gentoo-r7/arch/s390/kernel/time.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/arch/s390/kernel/time.c
++++ linux-2.6.27-gentoo-r7/arch/s390/kernel/time.c
+@@ -12,6 +12,9 @@
+  *    Copyright (C) 1991, 1992, 1995  Linus Torvalds
+  */
+ 
++#define KMSG_COMPONENT "time"
++#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
++
+ #include <linux/errno.h>
+ #include <linux/module.h>
+ #include <linux/sched.h>
+@@ -291,8 +294,8 @@ static unsigned long long adjust_time(un
+ 	}
+ 	jiffies_timer_cc += delta;
+ 	if (adjust.offset != 0) {
+-		printk(KERN_NOTICE "etr: time adjusted by %li micro-seconds\n",
+-		       adjust.offset);
++		pr_notice("The ETR interface has adjusted the clock "
++			  "by %li microseconds\n", adjust.offset);
+ 		adjust.modes = ADJ_OFFSET_SINGLESHOT;
+ 		do_adjtimex(&adjust);
+ 	}
+@@ -443,8 +446,8 @@ static void etr_reset(void)
+ 		etr_tolec = get_clock();
+ 		set_bit(CLOCK_SYNC_HAS_ETR, &clock_sync_flags);
+ 	} else if (etr_port0_online || etr_port1_online) {
+-		printk(KERN_WARNING "Running on non ETR capable "
+-		       "machine, only local mode available.\n");
++		pr_warning("The real or virtual hardware system does "
++			   "not provide an ETR interface\n");
+ 		etr_port0_online = etr_port1_online = 0;
+ 	}
+ }
+@@ -1359,7 +1362,8 @@ static void __init stp_reset(void)
+ 	if (rc == 0)
+ 		set_bit(CLOCK_SYNC_HAS_STP, &clock_sync_flags);
+ 	else if (stp_online) {
+-		printk(KERN_WARNING "Running on non STP capable machine.\n");
++		pr_warning("The real or virtual hardware system does "
++			   "not provide an STP interface\n");
+ 		free_bootmem((unsigned long) stp_page, PAGE_SIZE);
+ 		stp_page = NULL;
+ 		stp_online = 0;
+Index: linux-2.6.27-gentoo-r7/arch/s390/kernel/topology.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/arch/s390/kernel/topology.c
++++ linux-2.6.27-gentoo-r7/arch/s390/kernel/topology.c
+@@ -3,6 +3,9 @@
+  *    Author(s): Heiko Carstens <heiko.carstens@××××××.com>
+  */
+ 
++#define KMSG_COMPONENT "cpu"
++#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
++
+ #include <linux/kernel.h>
+ #include <linux/mm.h>
+ #include <linux/init.h>
+@@ -311,7 +314,7 @@ void __init s390_init_cpu_topology(void)
+ 	for (i = 0; i < info->mnest - 2; i++)
+ 		nr_cores *= info->mag[NR_MAG - 3 - i];
+ 
+-	printk(KERN_INFO "CPU topology:");
++	pr_info("The CPU configuration topology of the machine is:");
+ 	for (i = 0; i < NR_MAG; i++)
+ 		printk(" %d", info->mag[i]);
+ 	printk(" / %d\n", info->mnest);
+Index: linux-2.6.27-gentoo-r7/arch/s390/mm/extmem.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/arch/s390/mm/extmem.c
++++ linux-2.6.27-gentoo-r7/arch/s390/mm/extmem.c
+@@ -7,6 +7,9 @@
+  * (C) IBM Corporation 2002-2004
+  */
+ 
++#define KMSG_COMPONENT "extmem"
++#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
++
+ #include <linux/kernel.h>
+ #include <linux/string.h>
+ #include <linux/spinlock.h>
+@@ -24,39 +27,46 @@
+ #include <asm/cpcmd.h>
+ #include <asm/setup.h>
+ 
+-#define DCSS_DEBUG	/* Debug messages on/off */
+-
+-#define DCSS_NAME "extmem"
+-#ifdef DCSS_DEBUG
+-#define PRINT_DEBUG(x...)	printk(KERN_DEBUG DCSS_NAME " debug:" x)
+-#else
+-#define PRINT_DEBUG(x...)   do {} while (0)
+-#endif
+-#define PRINT_INFO(x...)	printk(KERN_INFO DCSS_NAME " info:" x)
+-#define PRINT_WARN(x...)	printk(KERN_WARNING DCSS_NAME " warning:" x)
+-#define PRINT_ERR(x...)		printk(KERN_ERR DCSS_NAME " error:" x)
+-
+-
+ #define DCSS_LOADSHR    0x00
+ #define DCSS_LOADNSR    0x04
+ #define DCSS_PURGESEG   0x08
+ #define DCSS_FINDSEG    0x0c
+ #define DCSS_LOADNOLY   0x10
+ #define DCSS_SEGEXT     0x18
++#define DCSS_LOADSHRX	0x20
++#define DCSS_LOADNSRX	0x24
++#define DCSS_FINDSEGX	0x2c
++#define DCSS_SEGEXTX	0x38
+ #define DCSS_FINDSEGA   0x0c
+ 
+ struct qrange {
+-	unsigned int  start; // 3byte start address, 1 byte type
+-	unsigned int  end;   // 3byte end address, 1 byte reserved
++	unsigned long  start; /* last byte type */
++	unsigned long  end;   /* last byte reserved */
+ };
+ 
+ struct qout64 {
++	unsigned long segstart;
++	unsigned long segend;
++	int segcnt;
++	int segrcnt;
++	struct qrange range[6];
++};
++
++#ifdef CONFIG_64BIT
++struct qrange_old {
++	unsigned int start; /* last byte type */
++	unsigned int end;   /* last byte reserved */
++};
++
++/* output area format for the Diag x'64' old subcode x'18' */
++struct qout64_old {
+ 	int segstart;
+ 	int segend;
+ 	int segcnt;
+ 	int segrcnt;
+-	struct qrange range[6];
++	struct qrange_old range[6];
+ };
++#endif
+ 
+ struct qin64 {
+ 	char qopcode;
+@@ -86,6 +96,55 @@ static DEFINE_MUTEX(dcss_lock);
+ static LIST_HEAD(dcss_list);
+ static char *segtype_string[] = { "SW", "EW", "SR", "ER", "SN", "EN", "SC",
+ 					"EW/EN-MIXED" };
++static int loadshr_scode, loadnsr_scode, findseg_scode;
++static int segext_scode, purgeseg_scode;
++static int scode_set;
++
++/* set correct Diag x'64' subcodes. */
++static int
++dcss_set_subcodes(void)
++{
++#ifdef CONFIG_64BIT
++	char *name = kmalloc(8 * sizeof(char), GFP_DMA);
++	unsigned long rx, ry;
++	int rc;
++
++	if (name == NULL)
++		return -ENOMEM;
++
++	rx = (unsigned long) name;
++	ry = DCSS_FINDSEGX;
++
++	strcpy(name, "dummy");
++	asm volatile(
++		"	diag	%0,%1,0x64\n"
++		"0:	ipm	%2\n"
++		"	srl	%2,28\n"
++		"	j	2f\n"
++		"1:	la	%2,3\n"
++		"2:\n"
++		EX_TABLE(0b, 1b)
++		: "+d" (rx), "+d" (ry), "=d" (rc) : : "cc");
++
++	kfree(name);
++	/* Diag x'64' new subcodes are supported, set to new subcodes */
++	if (rc != 3) {
++		loadshr_scode = DCSS_LOADSHRX;
++		loadnsr_scode = DCSS_LOADNSRX;
++		purgeseg_scode = DCSS_PURGESEG;
++		findseg_scode = DCSS_FINDSEGX;
++		segext_scode = DCSS_SEGEXTX;
++		return 0;
++	}
++#endif
++	/* Diag x'64' new subcodes are not supported, set to old subcodes */
++	loadshr_scode = DCSS_LOADNOLY;
++	loadnsr_scode = DCSS_LOADNSR;
++	purgeseg_scode = DCSS_PURGESEG;
++	findseg_scode = DCSS_FINDSEG;
++	segext_scode = DCSS_SEGEXT;
++	return 0;
++}
+ 
+ /*
+  * Create the 8 bytes, ebcdic VM segment name from
+@@ -135,25 +194,45 @@ segment_by_name (char *name)
+  * Perform a function on a dcss segment.
+  */
+ static inline int
+-dcss_diag (__u8 func, void *parameter,
++dcss_diag(int *func, void *parameter,
+            unsigned long *ret1, unsigned long *ret2)
+ {
+ 	unsigned long rx, ry;
+ 	int rc;
+ 
++	if (scode_set == 0) {
++		rc = dcss_set_subcodes();
++		if (rc < 0)
++			return rc;
++		scode_set = 1;
++	}
+ 	rx = (unsigned long) parameter;
+-	ry = (unsigned long) func;
+-	asm volatile(
++	ry = (unsigned long) *func;
++
+ #ifdef CONFIG_64BIT
+-		"	sam31\n"
+-		"	diag	%0,%1,0x64\n"
+-		"	sam64\n"
++	/* 64-bit Diag x'64' new subcode, keep in 64-bit addressing mode */
++	if (*func > DCSS_SEGEXT)
++		asm volatile(
++			"	diag	%0,%1,0x64\n"
++			"	ipm	%2\n"
++			"	srl	%2,28\n"
++			: "+d" (rx), "+d" (ry), "=d" (rc) : : "cc");
++	/* 31-bit Diag x'64' old subcode, switch to 31-bit addressing mode */
++	else
++		asm volatile(
++			"	sam31\n"
++			"	diag	%0,%1,0x64\n"
++			"	sam64\n"
++			"	ipm	%2\n"
++			"	srl	%2,28\n"
++			: "+d" (rx), "+d" (ry), "=d" (rc) : : "cc");
+ #else
++	asm volatile(
+ 		"	diag	%0,%1,0x64\n"
+-#endif
+ 		"	ipm	%2\n"
+ 		"	srl	%2,28\n"
+ 		: "+d" (rx), "+d" (ry), "=d" (rc) : : "cc");
++#endif
+ 	*ret1 = rx;
+ 	*ret2 = ry;
+ 	return rc;
+@@ -190,14 +269,45 @@ query_segment_type (struct dcss_segment 
+ 	qin->qoutlen = sizeof(struct qout64);
+ 	memcpy (qin->qname, seg->dcss_name, 8);
+ 
+-	diag_cc = dcss_diag (DCSS_SEGEXT, qin, &dummy, &vmrc);
++	diag_cc = dcss_diag(&segext_scode, qin, &dummy, &vmrc);
+ 
++	if (diag_cc < 0) {
++		rc = diag_cc;
++		goto out_free;
++	}
+ 	if (diag_cc > 1) {
+-		PRINT_WARN ("segment_type: diag returned error %ld\n", vmrc);
++		pr_warning("Querying a DCSS type failed with rc=%ld\n", vmrc);
+ 		rc = dcss_diag_translate_rc (vmrc);
+ 		goto out_free;
+ 	}
+ 
++#ifdef CONFIG_64BIT
++	/* Only old format of output area of Diagnose x'64' is supported,
++	   copy data for the new format. */
++	if (segext_scode == DCSS_SEGEXT) {
++		struct qout64_old *qout_old;
++		qout_old = kzalloc(sizeof(struct qout64_old), GFP_DMA);
++		if (qout_old == NULL) {
++			rc = -ENOMEM;
++			goto out_free;
++		}
++		memcpy(qout_old, qout, sizeof(struct qout64_old));
++		qout->segstart = (unsigned long) qout_old->segstart;
++		qout->segend = (unsigned long) qout_old->segend;
++		qout->segcnt = qout_old->segcnt;
++		qout->segrcnt = qout_old->segrcnt;
++
++		if (qout->segcnt > 6)
++			qout->segrcnt = 6;
++		for (i = 0; i < qout->segrcnt; i++) {
++			qout->range[i].start =
++				(unsigned long) qout_old->range[i].start;
++			qout->range[i].end =
++				(unsigned long) qout_old->range[i].end;
++		}
++		kfree(qout_old);
++	}
++#endif
+ 	if (qout->segcnt > 6) {
+ 		rc = -ENOTSUPP;
+ 		goto out_free;
+@@ -248,7 +358,6 @@ query_segment_type (struct dcss_segment 
+  * -EIO     : could not perform query diagnose
+  * -ENOENT  : no such segment
+  * -ENOTSUPP: multi-part segment cannot be used with linux
+- * -ENOSPC  : segment cannot be used (overlaps with storage)
+  * -ENOMEM  : out of memory
+  * 0 .. 6   : type of segment as defined in include/asm-s390/extmem.h
+  */
+@@ -269,6 +378,30 @@ segment_type (char* name)
+ }
+ 
+ /*
++ * check if segment collides with other segments that are currently loaded
++ * returns 1 if this is the case, 0 if no collision was found
++ */
++static int
++segment_overlaps_others (struct dcss_segment *seg)
++{
++	struct list_head *l;
++	struct dcss_segment *tmp;
++
++	BUG_ON(!mutex_is_locked(&dcss_lock));
++	list_for_each(l, &dcss_list) {
++		tmp = list_entry(l, struct dcss_segment, list);
++		if ((tmp->start_addr >> 20) > (seg->end >> 20))
++			continue;
++		if ((tmp->end >> 20) < (seg->start_addr >> 20))
++			continue;
++		if (seg == tmp)
++			continue;
++		return 1;
++	}
++	return 0;
++}
++
++/*
+  * real segment loading function, called from segment_load
+  */
+ static int
+@@ -276,7 +409,8 @@ __segment_load (char *name, int do_nonsh
+ {
+ 	struct dcss_segment *seg = kmalloc(sizeof(struct dcss_segment),
+ 			GFP_DMA);
+-	int dcss_command, rc, diag_cc;
++	int rc, diag_cc;
++	unsigned long start_addr, end_addr, dummy;
+ 
+ 	if (seg == NULL) {
+ 		rc = -ENOMEM;
+@@ -287,6 +421,13 @@ __segment_load (char *name, int do_nonsh
+ 	if (rc < 0)
+ 		goto out_free;
+ 
++	if (loadshr_scode == DCSS_LOADSHRX) {
++		if (segment_overlaps_others(seg)) {
++			rc = -EBUSY;
++			goto out_free;
++		}
++	}
++
+ 	rc = vmem_add_mapping(seg->start_addr, seg->end - seg->start_addr + 1);
+ 
+ 	if (rc)
+@@ -316,35 +457,40 @@ __segment_load (char *name, int do_nonsh
+ 	}
+ 
+ 	if (do_nonshared)
+-		dcss_command = DCSS_LOADNSR;
++		diag_cc = dcss_diag(&loadnsr_scode, seg->dcss_name,
++				&start_addr, &end_addr);
+ 	else
+-		dcss_command = DCSS_LOADNOLY;
+-
+-	diag_cc = dcss_diag(dcss_command, seg->dcss_name,
+-			&seg->start_addr, &seg->end);
++		diag_cc = dcss_diag(&loadshr_scode, seg->dcss_name,
++				&start_addr, &end_addr);
++	if (diag_cc < 0) {
++		dcss_diag(&purgeseg_scode, seg->dcss_name,
++				&dummy, &dummy);
++		rc = diag_cc;
++		goto out_resource;
++	}
+ 	if (diag_cc > 1) {
+-		PRINT_WARN ("segment_load: could not load segment %s - "
+-				"diag returned error (%ld)\n",name,seg->end);
+-		rc = dcss_diag_translate_rc (seg->end);
+-		dcss_diag(DCSS_PURGESEG, seg->dcss_name,
+-				&seg->start_addr, &seg->end);
++		pr_warning("Loading DCSS %s failed with rc=%ld\n", name,
++			   end_addr);
++		rc = dcss_diag_translate_rc(end_addr);
++		dcss_diag(&purgeseg_scode, seg->dcss_name,
++				&dummy, &dummy);
+ 		goto out_resource;
+ 	}
++	seg->start_addr = start_addr;
++	seg->end = end_addr;
+ 	seg->do_nonshared = do_nonshared;
+ 	atomic_set(&seg->ref_count, 1);
+ 	list_add(&seg->list, &dcss_list);
+ 	*addr = seg->start_addr;
+ 	*end  = seg->end;
+ 	if (do_nonshared)
+-		PRINT_INFO ("segment_load: loaded segment %s range %p .. %p "
+-				"type %s in non-shared mode\n", name,
+-				(void*)seg->start_addr, (void*)seg->end,
+-				segtype_string[seg->vm_segtype]);
++		pr_info("DCSS %s of range %p to %p and type %s loaded as "
++			"exclusive-writable\n", name, (void*) seg->start_addr,
++			(void*) seg->end, segtype_string[seg->vm_segtype]);
+ 	else {
+-		PRINT_INFO ("segment_load: loaded segment %s range %p .. %p "
+-				"type %s in shared mode\n", name,
+-				(void*)seg->start_addr, (void*)seg->end,
+-				segtype_string[seg->vm_segtype]);
++		pr_info("DCSS %s of range %p to %p and type %s loaded in "
++			"shared access mode\n", name, (void*) seg->start_addr,
++			(void*) seg->end, segtype_string[seg->vm_segtype]);
+ 	}
+ 	goto out;
+  out_resource:
+@@ -423,8 +569,8 @@ int
+ segment_modify_shared (char *name, int do_nonshared)
+ {
+ 	struct dcss_segment *seg;
+-	unsigned long dummy;
+-	int dcss_command, rc, diag_cc;
++	unsigned long start_addr, end_addr, dummy;
++	int rc, diag_cc;
+ 
+ 	mutex_lock(&dcss_lock);
+ 	seg = segment_by_name (name);
+@@ -433,50 +579,62 @@ segment_modify_shared (char *name, int d
+ 		goto out_unlock;
+ 	}
+ 	if (do_nonshared == seg->do_nonshared) {
+-		PRINT_INFO ("segment_modify_shared: not reloading segment %s"
+-				" - already in requested mode\n",name);
++		pr_info("DCSS %s is already in the requested access "
++			"mode\n", name);
+ 		rc = 0;
+ 		goto out_unlock;
+ 	}
+ 	if (atomic_read (&seg->ref_count) != 1) {
+-		PRINT_WARN ("segment_modify_shared: not reloading segment %s - "
+-				"segment is in use by other driver(s)\n",name);
++		pr_warning("DCSS %s is in use and cannot be reloaded\n",
++			   name);
+ 		rc = -EAGAIN;
+ 		goto out_unlock;
+ 	}
+ 	release_resource(seg->res);
+-	if (do_nonshared) {
+-		dcss_command = DCSS_LOADNSR;
++	if (do_nonshared)
+ 		seg->res->flags &= ~IORESOURCE_READONLY;
+-	} else {
+-		dcss_command = DCSS_LOADNOLY;
++	else
+ 		if (seg->vm_segtype == SEG_TYPE_SR ||
+ 		    seg->vm_segtype == SEG_TYPE_ER)
+ 			seg->res->flags |= IORESOURCE_READONLY;
+-	}
++
+ 	if (request_resource(&iomem_resource, seg->res)) {
+-		PRINT_WARN("segment_modify_shared: could not reload segment %s"
+-			   " - overlapping resources\n", name);
++		pr_warning("DCSS %s overlaps with used memory resources "
++			   "and cannot be reloaded\n", name);
+ 		rc = -EBUSY;
+ 		kfree(seg->res);
+-		goto out_del;
++		goto out_del_mem;
++	}
++
++	dcss_diag(&purgeseg_scode, seg->dcss_name, &dummy, &dummy);
++	if (do_nonshared)
++		diag_cc = dcss_diag(&loadnsr_scode, seg->dcss_name,
++				&start_addr, &end_addr);
++	else
++		diag_cc = dcss_diag(&loadshr_scode, seg->dcss_name,
++				&start_addr, &end_addr);
++	if (diag_cc < 0) {
++		rc = diag_cc;
++		goto out_del_res;
+ 	}
+-	dcss_diag(DCSS_PURGESEG, seg->dcss_name, &dummy, &dummy);
+-	diag_cc = dcss_diag(dcss_command, seg->dcss_name,
+-			&seg->start_addr, &seg->end);
+ 	if (diag_cc > 1) {
+-		PRINT_WARN ("segment_modify_shared: could not reload segment %s"
+-				" - diag returned error (%ld)\n",name,seg->end);
+-		rc = dcss_diag_translate_rc (seg->end);
+-		goto out_del;
++		pr_warning("Reloading DCSS %s failed with rc=%ld\n", name,
++			   end_addr);
++		rc = dcss_diag_translate_rc(end_addr);
++		goto out_del_res;
+ 	}
++	seg->start_addr = start_addr;
++	seg->end = end_addr;
+ 	seg->do_nonshared = do_nonshared;
+ 	rc = 0;
+ 	goto out_unlock;
+- out_del:
++ out_del_res:
++	release_resource(seg->res);
++	kfree(seg->res);
++ out_del_mem:
+ 	vmem_remove_mapping(seg->start_addr, seg->end - seg->start_addr + 1);
+ 	list_del(&seg->list);
+-	dcss_diag(DCSS_PURGESEG, seg->dcss_name, &dummy, &dummy);
++	dcss_diag(&purgeseg_scode, seg->dcss_name, &dummy, &dummy);
+ 	kfree(seg);
+  out_unlock:
+ 	mutex_unlock(&dcss_lock);
+@@ -500,8 +658,7 @@ segment_unload(char *name)
+ 	mutex_lock(&dcss_lock);
+ 	seg = segment_by_name (name);
+ 	if (seg == NULL) {
+-		PRINT_ERR ("could not find segment %s in segment_unload, "
+-				"please report to linux390@××××××.com\n",name);
++		pr_err("Unloading unknown DCSS %s failed\n", name);
+ 		goto out_unlock;
+ 	}
+ 	if (atomic_dec_return(&seg->ref_count) != 0)
+@@ -510,7 +667,7 @@ segment_unload(char *name)
+ 	kfree(seg->res);
+ 	vmem_remove_mapping(seg->start_addr, seg->end - seg->start_addr + 1);
+ 	list_del(&seg->list);
+-	dcss_diag(DCSS_PURGESEG, seg->dcss_name, &dummy, &dummy);
++	dcss_diag(&purgeseg_scode, seg->dcss_name, &dummy, &dummy);
+ 	kfree(seg);
+ out_unlock:
+ 	mutex_unlock(&dcss_lock);
+@@ -536,8 +693,7 @@ segment_save(char *name)
+ 	seg = segment_by_name (name);
+ 
+ 	if (seg == NULL) {
+-		PRINT_ERR("could not find segment %s in segment_save, please "
+-			  "report to linux390@××××××.com\n", name);
++		pr_err("Saving unknown DCSS %s failed\n", name);
+ 		goto out;
+ 	}
+ 
+@@ -545,7 +701,7 @@ segment_save(char *name)
+ 	endpfn = (seg->end) >> PAGE_SHIFT;
+ 	sprintf(cmd1, "DEFSEG %s", name);
+ 	for (i=0; i<seg->segcnt; i++) {
+-		sprintf(cmd1+strlen(cmd1), " %X-%X %s",
++		sprintf(cmd1+strlen(cmd1), " %lX-%lX %s",
+ 			seg->range[i].start >> PAGE_SHIFT,
+ 			seg->range[i].end >> PAGE_SHIFT,
+ 			segtype_string[seg->range[i].start & 0xff]);
+@@ -554,14 +710,14 @@ segment_save(char *name)
+ 	response = 0;
+ 	cpcmd(cmd1, NULL, 0, &response);
+ 	if (response) {
+-		PRINT_ERR("segment_save: DEFSEG failed with response code %i\n",
+-			  response);
++		pr_err("Saving a DCSS failed with DEFSEG response code "
++		       "%i\n", response);
+ 		goto out;
+ 	}
+ 	cpcmd(cmd2, NULL, 0, &response);
+ 	if (response) {
+-		PRINT_ERR("segment_save: SAVESEG failed with response code %i\n",
+-			  response);
++		pr_err("Saving a DCSS failed with SAVESEG response code "
++		       "%i\n", response);
+ 		goto out;
+ 	}
+ out:
+@@ -576,44 +732,41 @@ void segment_warning(int rc, char *seg_n
+ {
+ 	switch (rc) {
+ 	case -ENOENT:
+-		PRINT_WARN("cannot load/query segment %s, "
+-			   "does not exist\n", seg_name);
++		pr_err("DCSS %s cannot be loaded or queried\n", seg_name);
+ 		break;
+ 	case -ENOSYS:
+-		PRINT_WARN("cannot load/query segment %s, "
+-			   "not running on VM\n", seg_name);
++		pr_err("DCSS %s cannot be loaded or queried without "
++		       "z/VM\n", seg_name);
+ 		break;
+ 	case -EIO:
+-		PRINT_WARN("cannot load/query segment %s, "
+-			   "hardware error\n", seg_name);
++		pr_err("Loading or querying DCSS %s resulted in a "
++		       "hardware error\n", seg_name);
+ 		break;
+ 	case -ENOTSUPP:
+-		PRINT_WARN("cannot load/query segment %s, "
+-			   "is a multi-part segment\n", seg_name);
++		pr_err("DCSS %s has multiple page ranges and cannot be "
++		       "loaded or queried\n", seg_name);
+ 		break;
+ 	case -ENOSPC:
+-		PRINT_WARN("cannot load/query segment %s, "
+-			   "overlaps with storage\n", seg_name);
++		pr_err("DCSS %s overlaps with used storage and cannot "
++		       "be loaded\n", seg_name);
+ 		break;
+ 	case -EBUSY:
+-		PRINT_WARN("cannot load/query segment %s, "
+-			   "overlaps with already loaded dcss\n", seg_name);
++		pr_err("%s needs used memory resources and cannot be "
++		       "loaded or queried\n", seg_name);
+ 		break;
+ 	case -EPERM:
+-		PRINT_WARN("cannot load/query segment %s, "
+-			   "already loaded in incompatible mode\n", seg_name);
++		pr_err("DCSS %s is already loaded in a different access "
++		       "mode\n", seg_name);
+ 		break;
+ 	case -ENOMEM:
+-		PRINT_WARN("cannot load/query segment %s, "
+-			   "out of memory\n", seg_name);
++		pr_err("There is not enough memory to load or query "
++		       "DCSS %s\n", seg_name);
+ 		break;
+ 	case -ERANGE:
+-		PRINT_WARN("cannot load/query segment %s, "
+-			   "exceeds kernel mapping range\n", seg_name);
++		pr_err("DCSS %s exceeds the kernel mapping range (%lu) "
++		       "and cannot be loaded\n", seg_name, VMEM_MAX_PHYS);
+ 		break;
+ 	default:
+-		PRINT_WARN("cannot load/query segment %s, "
+-			   "return value %i\n", seg_name, rc);
+ 		break;
+ 	}
+ }
+Index: linux-2.6.27-gentoo-r7/drivers/s390/block/dcssblk.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/block/dcssblk.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/block/dcssblk.c
+@@ -4,6 +4,9 @@
+  * Authors: Carsten Otte, Stefan Weinhuber, Gerald Schaefer
+  */
+ 
++#define KMSG_COMPONENT "dcssblk"
++#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
++
+ #include <linux/module.h>
+ #include <linux/moduleparam.h>
+ #include <linux/ctype.h>
+@@ -17,21 +20,10 @@
+ #include <linux/interrupt.h>
+ #include <asm/s390_rdev.h>
+ 
+-//#define DCSSBLK_DEBUG		/* Debug messages on/off */
+ #define DCSSBLK_NAME "dcssblk"
+ #define DCSSBLK_MINORS_PER_DISK 1
+ #define DCSSBLK_PARM_LEN 400
+ 
+-#ifdef DCSSBLK_DEBUG
+-#define PRINT_DEBUG(x...) printk(KERN_DEBUG DCSSBLK_NAME " debug: " x)
+-#else
+-#define PRINT_DEBUG(x...) do {} while (0)
+-#endif
+-#define PRINT_INFO(x...)  printk(KERN_INFO DCSSBLK_NAME " info: " x)
+-#define PRINT_WARN(x...)  printk(KERN_WARNING DCSSBLK_NAME " warning: " x)
+-#define PRINT_ERR(x...)	  printk(KERN_ERR DCSSBLK_NAME " error: " x)
+-
+-
+ static int dcssblk_open(struct inode *inode, struct file *filp);
+ static int dcssblk_release(struct inode *inode, struct file *filp);
+ static int dcssblk_make_request(struct request_queue *q, struct bio *bio);
+@@ -48,6 +40,30 @@ static struct block_device_operations dc
+ 	.direct_access 	= dcssblk_direct_access,
+ };
+ 
++struct dcssblk_dev_info {
++	struct list_head lh;
++	struct device dev;
++	char segment_name[BUS_ID_SIZE];
++	atomic_t use_count;
++	struct gendisk *gd;
++	unsigned long start;
++	unsigned long end;
++	int segment_type;
++	unsigned char save_pending;
++	unsigned char is_shared;
++	struct request_queue *dcssblk_queue;
++	int num_of_segments;
++	struct list_head seg_list;
++};
++
++struct segment_info {
++	struct list_head lh;
++	char segment_name[BUS_ID_SIZE];
++	unsigned long start;
++	unsigned long end;
++	int segment_type;
++};
++
+ static ssize_t dcssblk_add_store(struct device * dev, struct device_attribute *attr, const char * buf,
+ 				  size_t count);
+ static ssize_t dcssblk_remove_store(struct device * dev, struct device_attribute *attr, const char * buf,
+@@ -58,30 +74,20 @@ static ssize_t dcssblk_save_show(struct 
+ static ssize_t dcssblk_shared_store(struct device * dev, struct device_attribute *attr, const char * buf,
+ 				  size_t count);
+ static ssize_t dcssblk_shared_show(struct device *dev, struct device_attribute *attr, char *buf);
++static ssize_t dcssblk_seglist_show(struct device *dev,
++				struct device_attribute *attr,
++				char *buf);
+ 
+ static DEVICE_ATTR(add, S_IWUSR, NULL, dcssblk_add_store);
+ static DEVICE_ATTR(remove, S_IWUSR, NULL, dcssblk_remove_store);
+-static DEVICE_ATTR(save, S_IWUSR | S_IRUGO, dcssblk_save_show,
++static DEVICE_ATTR(save, S_IWUSR | S_IRUSR, dcssblk_save_show,
+ 		   dcssblk_save_store);
+-static DEVICE_ATTR(shared, S_IWUSR | S_IRUGO, dcssblk_shared_show,
++static DEVICE_ATTR(shared, S_IWUSR | S_IRUSR, dcssblk_shared_show,
+ 		   dcssblk_shared_store);
++static DEVICE_ATTR(seglist, S_IRUSR, dcssblk_seglist_show, NULL);
+ 
+ static struct device *dcssblk_root_dev;
+ 
+-struct dcssblk_dev_info {
+-	struct list_head lh;
+-	struct device dev;
+-	char segment_name[BUS_ID_SIZE];
+-	atomic_t use_count;
+-	struct gendisk *gd;
+-	unsigned long start;
+-	unsigned long end;
+-	int segment_type;
+-	unsigned char save_pending;
+-	unsigned char is_shared;
+-	struct request_queue *dcssblk_queue;
+-};
+-
+ static LIST_HEAD(dcssblk_devices);
+ static struct rw_semaphore dcssblk_devices_sem;
+ 
+@@ -91,8 +97,15 @@ static struct rw_semaphore dcssblk_devic
+ static void
+ dcssblk_release_segment(struct device *dev)
+ {
+-	PRINT_DEBUG("segment release fn called for %s\n", dev->bus_id);
+-	kfree(container_of(dev, struct dcssblk_dev_info, dev));
++	struct dcssblk_dev_info *dev_info;
++	struct segment_info *entry, *temp;
++
++	dev_info = container_of(dev, struct dcssblk_dev_info, dev);
++	list_for_each_entry_safe(entry, temp, &dev_info->seg_list, lh) {
++		list_del(&entry->lh);
++		kfree(entry);
++	}
++	kfree(dev_info);
+ 	module_put(THIS_MODULE);
+ }
+ 
+@@ -142,6 +155,168 @@ dcssblk_get_device_by_name(char *name)
+ 	return NULL;
+ }
+ 
++/*
++ * get the struct segment_info from seg_list
++ * for the given name.
++ * down_read(&dcssblk_devices_sem) must be held.
++ */
++static struct segment_info *
++dcssblk_get_segment_by_name(char *name)
++{
++	struct dcssblk_dev_info *dev_info;
++	struct segment_info *entry;
++
++	list_for_each_entry(dev_info, &dcssblk_devices, lh) {
++		list_for_each_entry(entry, &dev_info->seg_list, lh) {
++			if (!strcmp(name, entry->segment_name))
++				return entry;
++		}
++	}
++	return NULL;
++}
++
++/*
++ * get the highest address of the multi-segment block.
++ */
++static unsigned long
++dcssblk_find_highest_addr(struct dcssblk_dev_info *dev_info)
++{
++	unsigned long highest_addr;
++	struct segment_info *entry;
++
++	highest_addr = 0;
++	list_for_each_entry(entry, &dev_info->seg_list, lh) {
++		if (highest_addr < entry->end)
++			highest_addr = entry->end;
++	}
++	return highest_addr;
++}
++
++/*
++ * get the lowest address of the multi-segment block.
++ */
++static unsigned long
++dcssblk_find_lowest_addr(struct dcssblk_dev_info *dev_info)
++{
++	int set_first;
++	unsigned long lowest_addr;
++	struct segment_info *entry;
++
++	set_first = 0;
++	lowest_addr = 0;
++	list_for_each_entry(entry, &dev_info->seg_list, lh) {
++		if (set_first == 0) {
++			lowest_addr = entry->start;
++			set_first = 1;
++		} else {
++			if (lowest_addr > entry->start)
++				lowest_addr = entry->start;
++		}
++	}
++	return lowest_addr;
++}
++
++/*
++ * Check continuity of segments.
++ */
++static int
++dcssblk_is_continuous(struct dcssblk_dev_info *dev_info)
++{
++	int i, j, rc;
++	struct segment_info *sort_list, *entry, temp;
++
++	if (dev_info->num_of_segments <= 1)
++		return 0;
++
++	sort_list = kzalloc(
++			sizeof(struct segment_info) * dev_info->num_of_segments,
++			GFP_KERNEL);
++	if (sort_list == NULL)
++		return -ENOMEM;
++	i = 0;
++	list_for_each_entry(entry, &dev_info->seg_list, lh) {
++		memcpy(&sort_list[i], entry, sizeof(struct segment_info));
++		i++;
++	}
++
++	/* sort segments */
++	for (i = 0; i < dev_info->num_of_segments; i++)
++		for (j = 0; j < dev_info->num_of_segments; j++)
++			if (sort_list[j].start > sort_list[i].start) {
++				memcpy(&temp, &sort_list[i],
++					sizeof(struct segment_info));
++				memcpy(&sort_list[i], &sort_list[j],
++					sizeof(struct segment_info));
++				memcpy(&sort_list[j], &temp,
++					sizeof(struct segment_info));
++			}
++
++	/* check continuity */
++	for (i = 0; i < dev_info->num_of_segments - 1; i++) {
++		if ((sort_list[i].end + 1) != sort_list[i+1].start) {
++			pr_err("Adjacent DCSSs %s and %s are not "
++			       "contiguous\n", sort_list[i].segment_name,
++			       sort_list[i+1].segment_name);
++			rc = -EINVAL;
++			goto out;
++		}
++		/* EN and EW are allowed in a block device */
++		if (sort_list[i].segment_type != sort_list[i+1].segment_type) {
++			if (!(sort_list[i].segment_type & SEGMENT_EXCLUSIVE) ||
++				(sort_list[i].segment_type == SEG_TYPE_ER) ||
++				!(sort_list[i+1].segment_type &
++				SEGMENT_EXCLUSIVE) ||
++				(sort_list[i+1].segment_type == SEG_TYPE_ER)) {
++				pr_err("DCSS %s and DCSS %s have "
++				       "incompatible types\n",
++				       sort_list[i].segment_name,
++				       sort_list[i+1].segment_name);
++				rc = -EINVAL;
++				goto out;
++			}
++		}
++	}
++	rc = 0;
++out:
++	kfree(sort_list);
++	return rc;
++}
++
++/*
++ * Load a segment
++ */
++static int
++dcssblk_load_segment(char *name, struct segment_info **seg_info)
++{
++	int rc;
++
++	/* already loaded? */
++	down_read(&dcssblk_devices_sem);
++	*seg_info = dcssblk_get_segment_by_name(name);
++	up_read(&dcssblk_devices_sem);
++	if (*seg_info != NULL)
++		return -EEXIST;
++
++	/* get a struct segment_info */
++	*seg_info = kzalloc(sizeof(struct segment_info), GFP_KERNEL);
++	if (*seg_info == NULL)
++		return -ENOMEM;
++
++	strcpy((*seg_info)->segment_name, name);
++
++	/* load the segment */
++	rc = segment_load(name, SEGMENT_SHARED,
++			&(*seg_info)->start, &(*seg_info)->end);
++	if (rc < 0) {
++		segment_warning(rc, (*seg_info)->segment_name);
++		kfree(*seg_info);
++	} else {
++		INIT_LIST_HEAD(&(*seg_info)->lh);
++		(*seg_info)->segment_type = rc;
++	}
++	return rc;
++}
++
+ static void dcssblk_unregister_callback(struct device *dev)
+ {
+ 	device_unregister(dev);
+@@ -165,6 +340,7 @@ static ssize_t
+ dcssblk_shared_store(struct device *dev, struct device_attribute *attr, const char *inbuf, size_t count)
+ {
+ 	struct dcssblk_dev_info *dev_info;
++	struct segment_info *entry, *temp;
+ 	int rc;
+ 
+ 	if ((count > 1) && (inbuf[1] != '\n') && (inbuf[1] != '\0'))
+@@ -172,46 +348,47 @@ dcssblk_shared_store(struct device *dev,
+ 	down_write(&dcssblk_devices_sem);
+ 	dev_info = container_of(dev, struct dcssblk_dev_info, dev);
+ 	if (atomic_read(&dev_info->use_count)) {
+-		PRINT_ERR("share: segment %s is busy!\n",
+-			  dev_info->segment_name);
+ 		rc = -EBUSY;
+ 		goto out;
+ 	}
+ 	if (inbuf[0] == '1') {
+-		// reload segment in shared mode
+-		rc = segment_modify_shared(dev_info->segment_name,
+-					   SEGMENT_SHARED);
+-		if (rc < 0) {
+-			BUG_ON(rc == -EINVAL);
+-			if (rc != -EAGAIN)
+-				goto removeseg;
+-		} else {
+-			dev_info->is_shared = 1;
+-			switch (dev_info->segment_type) {
+-				case SEG_TYPE_SR:
+-				case SEG_TYPE_ER:
+-				case SEG_TYPE_SC:
+-					set_disk_ro(dev_info->gd,1);
++		/* reload segments in shared mode */
++		list_for_each_entry(entry, &dev_info->seg_list, lh) {
++			rc = segment_modify_shared(entry->segment_name,
++						SEGMENT_SHARED);
++			if (rc < 0) {
++				BUG_ON(rc == -EINVAL);
++				if (rc != -EAGAIN)
++					goto removeseg;
+ 			}
+ 		}
++		dev_info->is_shared = 1;
++		switch (dev_info->segment_type) {
++		case SEG_TYPE_SR:
++		case SEG_TYPE_ER:
++		case SEG_TYPE_SC:
++			set_disk_ro(dev_info->gd, 1);
++		}
+ 	} else if (inbuf[0] == '0') {
+-		// reload segment in exclusive mode
++		/* reload segments in exclusive mode */
+ 		if (dev_info->segment_type == SEG_TYPE_SC) {
+-			PRINT_ERR("Segment type SC (%s) cannot be loaded in "
+-				  "non-shared mode\n", dev_info->segment_name);
++			pr_err("DCSS %s is of type SC and cannot be "
++			       "loaded as exclusive-writable\n",
++			       dev_info->segment_name);
+ 			rc = -EINVAL;
+ 			goto out;
+ 		}
+-		rc = segment_modify_shared(dev_info->segment_name,
+-					   SEGMENT_EXCLUSIVE);
+-		if (rc < 0) {
+-			BUG_ON(rc == -EINVAL);
+-			if (rc != -EAGAIN)
+-				goto removeseg;
+-		} else {
+-			dev_info->is_shared = 0;
+-			set_disk_ro(dev_info->gd, 0);
++		list_for_each_entry(entry, &dev_info->seg_list, lh) {
++			rc = segment_modify_shared(entry->segment_name,
++						   SEGMENT_EXCLUSIVE);
++			if (rc < 0) {
++				BUG_ON(rc == -EINVAL);
++				if (rc != -EAGAIN)
++					goto removeseg;
++			}
+ 		}
++		dev_info->is_shared = 0;
++		set_disk_ro(dev_info->gd, 0);
+ 	} else {
+ 		rc = -EINVAL;
+ 		goto out;
+@@ -220,8 +397,13 @@ dcssblk_shared_store(struct device *dev,
+ 	goto out;
+ 
+ removeseg:
+-	PRINT_ERR("Could not reload segment %s, removing it now!\n",
+-			dev_info->segment_name);
++	pr_err("DCSS device %s is removed after a failed access mode "
++	       "change\n", dev_info->segment_name);
++	temp = entry;
++	list_for_each_entry(entry, &dev_info->seg_list, lh) {
++		if (entry != temp)
++			segment_unload(entry->segment_name);
++	}
+ 	list_del(&dev_info->lh);
+ 
+ 	del_gendisk(dev_info->gd);
+@@ -254,6 +436,7 @@ static ssize_t
+ dcssblk_save_store(struct device *dev, struct device_attribute *attr, const char *inbuf, size_t count)
+ {
+ 	struct dcssblk_dev_info *dev_info;
++	struct segment_info *entry;
+ 
+ 	if ((count > 1) && (inbuf[1] != '\n') && (inbuf[1] != '\0'))
+ 		return -EINVAL;
+@@ -263,15 +446,17 @@ dcssblk_save_store(struct device *dev, s
+ 	if (inbuf[0] == '1') {
+ 		if (atomic_read(&dev_info->use_count) == 0) {
+ 			// device is idle => we save immediately
+-			PRINT_INFO("Saving segment %s\n",
+-				   dev_info->segment_name);
+-			segment_save(dev_info->segment_name);
++			pr_info("All DCSSs that map to device %s are "
++				"saved\n", dev_info->segment_name);
++			list_for_each_entry(entry, &dev_info->seg_list, lh) {
++				segment_save(entry->segment_name);
++			}
+ 		}  else {
+ 			// device is busy => we save it when it becomes
+ 			// idle in dcssblk_release
+-			PRINT_INFO("Segment %s is currently busy, it will "
+-				   "be saved when it becomes idle...\n",
+-				   dev_info->segment_name);
++			pr_info("Device %s is in use, its DCSSs will be "
++				"saved when it becomes idle\n",
++				dev_info->segment_name);
+ 			dev_info->save_pending = 1;
+ 		}
+ 	} else if (inbuf[0] == '0') {
+@@ -279,8 +464,9 @@ dcssblk_save_store(struct device *dev, s
+ 			// device is busy & the user wants to undo his save
+ 			// request
+ 			dev_info->save_pending = 0;
+-			PRINT_INFO("Pending save for segment %s deactivated\n",
+-					dev_info->segment_name);
++			pr_info("A pending save request for device %s "
++				"has been canceled\n",
++				dev_info->segment_name);
+ 		}
+ 	} else {
+ 		up_write(&dcssblk_devices_sem);
+@@ -291,66 +477,123 @@ dcssblk_save_store(struct device *dev, s
+ }
+ 
+ /*
++ * device attribute for showing all segments in a device
++ */
++static ssize_t
++dcssblk_seglist_show(struct device *dev, struct device_attribute *attr,
++		char *buf)
++{
++	int i;
++
++	struct dcssblk_dev_info *dev_info;
++	struct segment_info *entry;
++
++	down_read(&dcssblk_devices_sem);
++	dev_info = container_of(dev, struct dcssblk_dev_info, dev);
++	i = 0;
++	buf[0] = '\0';
++	list_for_each_entry(entry, &dev_info->seg_list, lh) {
++		strcpy(&buf[i], entry->segment_name);
++		i += strlen(entry->segment_name);
++		buf[i] = '\n';
++		i++;
++	}
++	up_read(&dcssblk_devices_sem);
++	return i;
++}
++
++/*
+  * device attribute for adding devices
+  */
+ static ssize_t
+ dcssblk_add_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+ {
+-	int rc, i;
++	int rc, i, j, num_of_segments;
+ 	struct dcssblk_dev_info *dev_info;
++	struct segment_info *seg_info, *temp;
+ 	char *local_buf;
+ 	unsigned long seg_byte_size;
+ 
+ 	dev_info = NULL;
++	seg_info = NULL;
+ 	if (dev != dcssblk_root_dev) {
+ 		rc = -EINVAL;
+ 		goto out_nobuf;
+ 	}
++	if ((count < 1) || (buf[0] == '\0') || (buf[0] == '\n')) {
++		rc = -ENAMETOOLONG;
++		goto out_nobuf;
++	}
++
+ 	local_buf = kmalloc(count + 1, GFP_KERNEL);
+ 	if (local_buf == NULL) {
+ 		rc = -ENOMEM;
+ 		goto out_nobuf;
+ 	}
++
+ 	/*
+ 	 * parse input
+ 	 */
++	num_of_segments = 0;
+ 	for (i = 0; ((buf[i] != '\0') && (buf[i] != '\n') && i < count); i++) {
+-		local_buf[i] = toupper(buf[i]);
++		for (j = i; (buf[j] != ':') &&
++			(buf[j] != '\0') &&
++			(buf[j] != '\n') &&
++			j < count; j++) {
++			local_buf[j-i] = toupper(buf[j]);
++		}
++		local_buf[j-i] = '\0';
++		if (((j - i) == 0) || ((j - i) > 8)) {
++			rc = -ENAMETOOLONG;
++			goto seg_list_del;
++		}
++
++		rc = dcssblk_load_segment(local_buf, &seg_info);
++		if (rc < 0)
++			goto seg_list_del;
++		/*
++		 * get a struct dcssblk_dev_info
++		 */
++		if (num_of_segments == 0) {
++			dev_info = kzalloc(sizeof(struct dcssblk_dev_info),
++					GFP_KERNEL);
++			if (dev_info == NULL) {
++				rc = -ENOMEM;
++				goto out;
++			}
++			strcpy(dev_info->segment_name, local_buf);
++			dev_info->segment_type = seg_info->segment_type;
++			INIT_LIST_HEAD(&dev_info->seg_list);
++		}
++		list_add_tail(&seg_info->lh, &dev_info->seg_list);
++		num_of_segments++;
++		i = j;
++
++		if ((buf[j] == '\0') || (buf[j] == '\n'))
++			break;
+ 	}
+-	local_buf[i] = '\0';
+-	if ((i == 0) || (i > 8)) {
++
++	/* no trailing colon at the end of the input */
++	if ((i > 0) && (buf[i-1] == ':')) {
+ 		rc = -ENAMETOOLONG;
+-		goto out;
+-	}
+-	/*
+-	 * already loaded?
+-	 */
+-	down_read(&dcssblk_devices_sem);
+-	dev_info = dcssblk_get_device_by_name(local_buf);
+-	up_read(&dcssblk_devices_sem);
+-	if (dev_info != NULL) {
+-		PRINT_WARN("Segment %s already loaded!\n", local_buf);
+-		rc = -EEXIST;
+-		goto out;
+-	}
+-	/*
+-	 * get a struct dcssblk_dev_info
+-	 */
+-	dev_info = kzalloc(sizeof(struct dcssblk_dev_info), GFP_KERNEL);
+-	if (dev_info == NULL) {
+-		rc = -ENOMEM;
+-		goto out;
++		goto seg_list_del;
+ 	}
++	strlcpy(local_buf, buf, i + 1);
++	dev_info->num_of_segments = num_of_segments;
++	rc = dcssblk_is_continuous(dev_info);
++	if (rc < 0)
++		goto seg_list_del;
+ 
+-	strcpy(dev_info->segment_name, local_buf);
+-	strlcpy(dev_info->dev.bus_id, local_buf, BUS_ID_SIZE);
++	dev_info->start = dcssblk_find_lowest_addr(dev_info);
++	dev_info->end = dcssblk_find_highest_addr(dev_info);
++
++	dev_set_name(&dev_info->dev, dev_info->segment_name);
+ 	dev_info->dev.release = dcssblk_release_segment;
+ 	INIT_LIST_HEAD(&dev_info->lh);
+-
+ 	dev_info->gd = alloc_disk(DCSSBLK_MINORS_PER_DISK);
+ 	if (dev_info->gd == NULL) {
+ 		rc = -ENOMEM;
+-		goto free_dev_info;
++		goto seg_list_del;
+ 	}
+ 	dev_info->gd->major = dcssblk_major;
+ 	dev_info->gd->fops = &dcssblk_devops;
+@@ -360,59 +603,42 @@ dcssblk_add_store(struct device *dev, st
+ 	dev_info->gd->driverfs_dev = &dev_info->dev;
+ 	blk_queue_make_request(dev_info->dcssblk_queue, dcssblk_make_request);
+ 	blk_queue_hardsect_size(dev_info->dcssblk_queue, 4096);
+-	/*
+-	 * load the segment
+-	 */
+-	rc = segment_load(local_buf, SEGMENT_SHARED,
+-				&dev_info->start, &dev_info->end);
+-	if (rc < 0) {
+-		segment_warning(rc, dev_info->segment_name);
+-		goto dealloc_gendisk;
+-	}
++
+ 	seg_byte_size = (dev_info->end - dev_info->start + 1);
+ 	set_capacity(dev_info->gd, seg_byte_size >> 9); // size in sectors
+-	PRINT_INFO("Loaded segment %s, size = %lu Byte, "
+-		   "capacity = %lu (512 Byte) sectors\n", local_buf,
+-		   seg_byte_size, seg_byte_size >> 9);
++	pr_info("Loaded %s with total size %lu bytes and capacity %lu "
++		"sectors\n", local_buf, seg_byte_size, seg_byte_size >> 9);
+ 
+-	dev_info->segment_type = rc;
+ 	dev_info->save_pending = 0;
+ 	dev_info->is_shared = 1;
+ 	dev_info->dev.parent = dcssblk_root_dev;
+ 
+ 	/*
+-	 * get minor, add to list
++	 *get minor, add to list
+ 	 */
+ 	down_write(&dcssblk_devices_sem);
+-	if (dcssblk_get_device_by_name(local_buf)) {
+-		up_write(&dcssblk_devices_sem);
++	if (dcssblk_get_segment_by_name(local_buf)) {
+ 		rc = -EEXIST;
+-		goto unload_seg;
++		goto release_gd;
+ 	}
+ 	rc = dcssblk_assign_free_minor(dev_info);
+-	if (rc) {
+-		up_write(&dcssblk_devices_sem);
+-		PRINT_ERR("No free minor number available! "
+-			  "Unloading segment...\n");
+-		goto unload_seg;
+-	}
++	if (rc)
++		goto release_gd;
+ 	sprintf(dev_info->gd->disk_name, "dcssblk%d",
+ 		dev_info->gd->first_minor);
+ 	list_add_tail(&dev_info->lh, &dcssblk_devices);
+ 
+ 	if (!try_module_get(THIS_MODULE)) {
+ 		rc = -ENODEV;
+-		goto list_del;
++		goto dev_list_del;
+ 	}
+ 	/*
+ 	 * register the device
+ 	 */
+ 	rc = device_register(&dev_info->dev);
+ 	if (rc) {
+-		PRINT_ERR("Segment %s could not be registered RC=%d\n",
+-				local_buf, rc);
+ 		module_put(THIS_MODULE);
+-		goto list_del;
++		goto dev_list_del;
+ 	}
+ 	get_device(&dev_info->dev);
+ 	rc = device_create_file(&dev_info->dev, &dev_attr_shared);
+@@ -421,6 +647,9 @@ dcssblk_add_store(struct device *dev, st
+ 	rc = device_create_file(&dev_info->dev, &dev_attr_save);
+ 	if (rc)
+ 		goto unregister_dev;
++	rc = device_create_file(&dev_info->dev, &dev_attr_seglist);
++	if (rc)
++		goto unregister_dev;
+ 
+ 	add_disk(dev_info->gd);
+ 
+@@ -434,7 +663,6 @@ dcssblk_add_store(struct device *dev, st
+ 			set_disk_ro(dev_info->gd,0);
+ 			break;
+ 	}
+-	PRINT_DEBUG("Segment %s loaded successfully\n", local_buf);
+ 	up_write(&dcssblk_devices_sem);
+ 	rc = count;
+ 	goto out;
+@@ -445,20 +673,27 @@ unregister_dev:
+ 	dev_info->gd->queue = NULL;
+ 	put_disk(dev_info->gd);
+ 	device_unregister(&dev_info->dev);
+-	segment_unload(dev_info->segment_name);
++	list_for_each_entry(seg_info, &dev_info->seg_list, lh) {
++		segment_unload(seg_info->segment_name);
++	}
+ 	put_device(&dev_info->dev);
+ 	up_write(&dcssblk_devices_sem);
+ 	goto out;
+-list_del:
++dev_list_del:
+ 	list_del(&dev_info->lh);
+-	up_write(&dcssblk_devices_sem);
+-unload_seg:
+-	segment_unload(local_buf);
+-dealloc_gendisk:
++release_gd:
+ 	blk_cleanup_queue(dev_info->dcssblk_queue);
+ 	dev_info->gd->queue = NULL;
+ 	put_disk(dev_info->gd);
+-free_dev_info:
++	up_write(&dcssblk_devices_sem);
++seg_list_del:
++	if (dev_info == NULL)
++		goto out;
++	list_for_each_entry_safe(seg_info, temp, &dev_info->seg_list, lh) {
++		list_del(&seg_info->lh);
++		segment_unload(seg_info->segment_name);
++		kfree(seg_info);
++	}
+ 	kfree(dev_info);
+ out:
+ 	kfree(local_buf);
+@@ -473,6 +708,7 @@ static ssize_t
+ dcssblk_remove_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+ {
+ 	struct dcssblk_dev_info *dev_info;
++	struct segment_info *entry;
+ 	int rc, i;
+ 	char *local_buf;
+ 
+@@ -499,26 +735,30 @@ dcssblk_remove_store(struct device *dev,
+ 	dev_info = dcssblk_get_device_by_name(local_buf);
+ 	if (dev_info == NULL) {
+ 		up_write(&dcssblk_devices_sem);
+-		PRINT_WARN("Segment %s is not loaded!\n", local_buf);
++		pr_warning("Device %s cannot be removed because it is not a "
++			   "known device\n", local_buf);
+ 		rc = -ENODEV;
+ 		goto out_buf;
+ 	}
+ 	if (atomic_read(&dev_info->use_count) != 0) {
+ 		up_write(&dcssblk_devices_sem);
+-		PRINT_WARN("Segment %s is in use!\n", local_buf);
++		pr_warning("Device %s cannot be removed while it is in "
++			   "use\n", local_buf);
+ 		rc = -EBUSY;
+ 		goto out_buf;
+ 	}
+-	list_del(&dev_info->lh);
+ 
++	list_del(&dev_info->lh);
+ 	del_gendisk(dev_info->gd);
+ 	blk_cleanup_queue(dev_info->dcssblk_queue);
+ 	dev_info->gd->queue = NULL;
+ 	put_disk(dev_info->gd);
+ 	device_unregister(&dev_info->dev);
+-	segment_unload(dev_info->segment_name);
+-	PRINT_DEBUG("Segment %s unloaded successfully\n",
+-			dev_info->segment_name);
++
++	/* unload all related segments */
++	list_for_each_entry(entry, &dev_info->seg_list, lh)
++		segment_unload(entry->segment_name);
++
+ 	put_device(&dev_info->dev);
+ 	up_write(&dcssblk_devices_sem);
+ 
+@@ -550,6 +790,7 @@ static int
+ dcssblk_release(struct inode *inode, struct file *filp)
+ {
+ 	struct dcssblk_dev_info *dev_info;
++	struct segment_info *entry;
+ 	int rc;
+ 
+ 	dev_info = inode->i_bdev->bd_disk->private_data;
+@@ -560,9 +801,11 @@ dcssblk_release(struct inode *inode, str
+ 	down_write(&dcssblk_devices_sem);
+ 	if (atomic_dec_and_test(&dev_info->use_count)
+ 	    && (dev_info->save_pending)) {
+-		PRINT_INFO("Segment %s became idle and is being saved now\n",
+-			    dev_info->segment_name);
+-		segment_save(dev_info->segment_name);
++		pr_info("Device %s has become idle and is being saved "
++			"now\n", dev_info->segment_name);
++		list_for_each_entry(entry, &dev_info->seg_list, lh) {
++			segment_save(entry->segment_name);
++		}
+ 		dev_info->save_pending = 0;
+ 	}
+ 	up_write(&dcssblk_devices_sem);
+@@ -602,7 +845,9 @@ dcssblk_make_request(struct request_queu
+ 		case SEG_TYPE_SC:
+ 			/* cannot write to these segments */
+ 			if (bio_data_dir(bio) == WRITE) {
+-				PRINT_WARN("rejecting write to ro segment %s\n", dev_info->dev.bus_id);
++				pr_warning("Writing to %s failed because it "
++					   "is a read-only device\n",
++					   dev_name(&dev_info->dev));
+ 				goto fail;
+ 			}
+ 		}
+@@ -657,7 +902,7 @@ static void
+ dcssblk_check_params(void)
+ {
+ 	int rc, i, j, k;
+-	char buf[9];
++	char buf[DCSSBLK_PARM_LEN + 1];
+ 	struct dcssblk_dev_info *dev_info;
+ 
+ 	for (i = 0; (i < DCSSBLK_PARM_LEN) && (dcssblk_segments[i] != '\0');
+@@ -665,15 +910,16 @@ dcssblk_check_params(void)
+ 		for (j = i; (dcssblk_segments[j] != ',')  &&
+ 			    (dcssblk_segments[j] != '\0') &&
+ 			    (dcssblk_segments[j] != '(')  &&
+-			    (j - i) < 8; j++)
++			    (j < DCSSBLK_PARM_LEN); j++)
+ 		{
+ 			buf[j-i] = dcssblk_segments[j];
+ 		}
+ 		buf[j-i] = '\0';
+ 		rc = dcssblk_add_store(dcssblk_root_dev, NULL, buf, j-i);
+ 		if ((rc >= 0) && (dcssblk_segments[j] == '(')) {
+-			for (k = 0; buf[k] != '\0'; k++)
++			for (k = 0; (buf[k] != ':') && (buf[k] != '\0'); k++)
+ 				buf[k] = toupper(buf[k]);
++			buf[k] = '\0';
+ 			if (!strncmp(&dcssblk_segments[j], "(local)", 7)) {
+ 				down_read(&dcssblk_devices_sem);
+ 				dev_info = dcssblk_get_device_by_name(buf);
+@@ -740,10 +986,12 @@ module_exit(dcssblk_exit);
+ 
+ module_param_string(segments, dcssblk_segments, DCSSBLK_PARM_LEN, 0444);
+ MODULE_PARM_DESC(segments, "Name of DCSS segment(s) to be loaded, "
+-		 "comma-separated list, each name max. 8 chars.\n"
+-		 "Adding \"(local)\" to segment name equals echoing 0 to "
+-		 "/sys/devices/dcssblk/<segment name>/shared after loading "
+-		 "the segment - \n"
+-		 "e.g. segments=\"mydcss1,mydcss2,mydcss3(local)\"");
++		 "comma-separated list, names in each set separated "
++		 "by commas are separated by colons, each set contains "
++		 "names of contiguous segments and each name max. 8 chars.\n"
++		 "Adding \"(local)\" to the end of each set equals echoing 0 "
++		 "to /sys/devices/dcssblk/<device name>/shared after loading "
++		 "the contiguous segments - \n"
++		 "e.g. segments=\"mydcss1,mydcss2:mydcss3,mydcss4(local)\"");
+ 
+ MODULE_LICENSE("GPL");
+Index: linux-2.6.27-gentoo-r7/drivers/s390/block/xpram.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/block/xpram.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/block/xpram.c
+@@ -25,6 +25,9 @@
+  *   generic hard disk support to replace ad-hoc partitioning
+  */
+ 
++#define KMSG_COMPONENT "xpram"
++#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
++
+ #include <linux/module.h>
+ #include <linux/moduleparam.h>
+ #include <linux/ctype.h>  /* isdigit, isxdigit */
+@@ -42,12 +45,6 @@
+ #define XPRAM_DEVS	1	/* one partition */
+ #define XPRAM_MAX_DEVS	32	/* maximal number of devices (partitions) */
+ 
+-#define PRINT_DEBUG(x...)	printk(KERN_DEBUG XPRAM_NAME " debug:" x)
+-#define PRINT_INFO(x...)	printk(KERN_INFO XPRAM_NAME " info:" x)
+-#define PRINT_WARN(x...)	printk(KERN_WARNING XPRAM_NAME " warning:" x)
+-#define PRINT_ERR(x...)		printk(KERN_ERR XPRAM_NAME " error:" x)
+-
+-
+ typedef struct {
+ 	unsigned int	size;		/* size of xpram segment in pages */
+ 	unsigned int	offset;		/* start page of xpram segment */
+@@ -264,7 +261,7 @@ static int __init xpram_setup_sizes(unsi
+ 
+ 	/* Check number of devices. */
+ 	if (devs <= 0 || devs > XPRAM_MAX_DEVS) {
+-		PRINT_ERR("invalid number %d of devices\n",devs);
++		pr_err("%d is not a valid number of XPRAM devices\n",devs);
+ 		return -EINVAL;
+ 	}
+ 	xpram_devs = devs;
+@@ -295,22 +292,22 @@ static int __init xpram_setup_sizes(unsi
+ 			mem_auto_no++;
+ 	}
+ 	
+-	PRINT_INFO("  number of devices (partitions): %d \n", xpram_devs);
++	pr_info("  number of devices (partitions): %d \n", xpram_devs);
+ 	for (i = 0; i < xpram_devs; i++) {
+ 		if (xpram_sizes[i])
+-			PRINT_INFO("  size of partition %d: %u kB\n",
+-				   i, xpram_sizes[i]);
++			pr_info("  size of partition %d: %u kB\n",
++				i, xpram_sizes[i]);
+ 		else
+-			PRINT_INFO("  size of partition %d to be set "
+-				   "automatically\n",i);
++			pr_info("  size of partition %d to be set "
++				"automatically\n",i);
+ 	}
+-	PRINT_DEBUG("  memory needed (for sized partitions): %lu kB\n",
+-		    mem_needed);
+-	PRINT_DEBUG("  partitions to be sized automatically: %d\n",
+-		    mem_auto_no);
++	pr_info("  memory needed (for sized partitions): %lu kB\n",
++		mem_needed);
++	pr_info("  partitions to be sized automatically: %d\n",
++		mem_auto_no);
+ 
+ 	if (mem_needed > pages * 4) {
+-		PRINT_ERR("Not enough expanded memory available\n");
++		pr_err("Not enough expanded memory available\n");
+ 		return -EINVAL;
+ 	}
+ 
+@@ -322,8 +319,8 @@ static int __init xpram_setup_sizes(unsi
+ 	 */
+ 	if (mem_auto_no) {
+ 		mem_auto = ((pages - mem_needed / 4) / mem_auto_no) * 4;
+-		PRINT_INFO("  automatically determined "
+-			   "partition size: %lu kB\n", mem_auto);
++		pr_info("  automatically determined "
++			"partition size: %lu kB\n", mem_auto);
+ 		for (i = 0; i < xpram_devs; i++)
+ 			if (xpram_sizes[i] == 0)
+ 				xpram_sizes[i] = mem_auto;
+@@ -405,12 +402,12 @@ static int __init xpram_init(void)
+ 
+ 	/* Find out size of expanded memory. */
+ 	if (xpram_present() != 0) {
+-		PRINT_WARN("No expanded memory available\n");
++		pr_err("No expanded memory available\n");
+ 		return -ENODEV;
+ 	}
+ 	xpram_pages = xpram_highest_page_index() + 1;
+-	PRINT_INFO("  %u pages expanded memory found (%lu KB).\n",
+-		   xpram_pages, (unsigned long) xpram_pages*4);
++	pr_info("  %u pages expanded memory found (%lu KB).\n",
++		xpram_pages, (unsigned long) xpram_pages*4);
+ 	rc = xpram_setup_sizes(xpram_pages);
+ 	if (rc)
+ 		return rc;
+Index: linux-2.6.27-gentoo-r7/drivers/s390/char/monreader.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/char/monreader.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/char/monreader.c
+@@ -7,6 +7,9 @@
+  *   Author: Gerald Schaefer <gerald.schaefer@××××××.com>
+  */
+ 
++#define KMSG_COMPONENT "monreader"
++#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
++
+ #include <linux/module.h>
+ #include <linux/moduleparam.h>
+ #include <linux/init.h>
+@@ -24,19 +27,6 @@
+ #include <asm/ebcdic.h>
+ #include <asm/extmem.h>
+ 
+-//#define MON_DEBUG			/* Debug messages on/off */
+-
+-#define MON_NAME "monreader"
+-
+-#define P_INFO(x...)	printk(KERN_INFO MON_NAME " info: " x)
+-#define P_ERROR(x...)	printk(KERN_ERR MON_NAME " error: " x)
+-#define P_WARNING(x...)	printk(KERN_WARNING MON_NAME " warning: " x)
+-
+-#ifdef MON_DEBUG
+-#define P_DEBUG(x...)   printk(KERN_DEBUG MON_NAME " debug: " x)
+-#else
+-#define P_DEBUG(x...)   do {} while (0)
+-#endif
+ 
+ #define MON_COLLECT_SAMPLE 0x80
+ #define MON_COLLECT_EVENT  0x40
+@@ -172,7 +162,7 @@ static int mon_send_reply(struct mon_msg
+ 	} else
+ 		monmsg->replied_msglim = 1;
+ 	if (rc) {
+-		P_ERROR("read, IUCV reply failed with rc = %i\n\n", rc);
++		pr_err("Reading monitor data failed with rc=%i\n", rc);
+ 		return -EIO;
+ 	}
+ 	return 0;
+@@ -251,7 +241,8 @@ static void mon_iucv_path_severed(struct
+ {
+ 	struct mon_private *monpriv = path->private;
+ 
+-	P_ERROR("IUCV connection severed with rc = 0x%X\n", ipuser[0]);
++	pr_err("z/VM *MONITOR system service disconnected with rc=%i\n",
++	       ipuser[0]);
+ 	iucv_path_sever(path, NULL);
+ 	atomic_set(&monpriv->iucv_severed, 1);
+ 	wake_up(&mon_conn_wait_queue);
+@@ -266,8 +257,7 @@ static void mon_iucv_message_pending(str
+ 	memcpy(&monpriv->msg_array[monpriv->write_index]->msg,
+ 	       msg, sizeof(*msg));
+ 	if (atomic_inc_return(&monpriv->msglim_count) == MON_MSGLIM) {
+-		P_WARNING("IUCV message pending, message limit (%i) reached\n",
+-			  MON_MSGLIM);
++		pr_warning("The read queue for monitor data is full\n");
+ 		monpriv->msg_array[monpriv->write_index]->msglim_reached = 1;
+ 	}
+ 	monpriv->write_index = (monpriv->write_index + 1) % MON_MSGLIM;
+@@ -311,8 +301,8 @@ static int mon_open(struct inode *inode,
+ 	rc = iucv_path_connect(monpriv->path, &monreader_iucv_handler,
+ 			       MON_SERVICE, NULL, user_data_connect, monpriv);
+ 	if (rc) {
+-		P_ERROR("iucv connection to *MONITOR failed with "
+-			"IPUSER SEVER code = %i\n", rc);
++		pr_err("Connecting to the z/VM *MONITOR system service "
++		       "failed with rc=%i\n", rc);
+ 		rc = -EIO;
+ 		goto out_path;
+ 	}
+@@ -353,7 +343,8 @@ static int mon_close(struct inode *inode
+ 	 */
+ 	rc = iucv_path_sever(monpriv->path, user_data_sever);
+ 	if (rc)
+-		P_ERROR("close, iucv_sever failed with rc = %i\n", rc);
++		pr_warning("Disconnecting the z/VM *MONITOR system service "
++			   "failed with rc=%i\n", rc);
+ 
+ 	atomic_set(&monpriv->iucv_severed, 0);
+ 	atomic_set(&monpriv->iucv_connected, 0);
+@@ -469,7 +460,8 @@ static int __init mon_init(void)
+ 	int rc;
+ 
+ 	if (!MACHINE_IS_VM) {
+-		P_ERROR("not running under z/VM, driver not loaded\n");
++		pr_err("The z/VM *MONITOR record device driver cannot be "
++		       "loaded without z/VM\n");
+ 		return -ENODEV;
+ 	}
+ 
+@@ -478,7 +470,8 @@ static int __init mon_init(void)
+ 	 */
+ 	rc = iucv_register(&monreader_iucv_handler, 1);
+ 	if (rc) {
+-		P_ERROR("failed to register with iucv driver\n");
++		pr_err("The z/VM *MONITOR record device driver failed to "
++		       "register with IUCV\n");
+ 		return rc;
+ 	}
+ 
+@@ -488,8 +481,8 @@ static int __init mon_init(void)
+ 		goto out_iucv;
+ 	}
+ 	if (rc != SEG_TYPE_SC) {
+-		P_ERROR("segment %s has unsupported type, should be SC\n",
+-			mon_dcss_name);
++		pr_err("The specified *MONITOR DCSS %s does not have the "
++		       "required type SC\n", mon_dcss_name);
+ 		rc = -EINVAL;
+ 		goto out_iucv;
+ 	}
+Index: linux-2.6.27-gentoo-r7/drivers/s390/char/monwriter.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/char/monwriter.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/char/monwriter.c
+@@ -8,6 +8,9 @@
+  * Author(s): Melissa Howland <Melissa.Howland@××××××.com>
+  */
+ 
++#define KMSG_COMPONENT "monwriter"
++#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
++
+ #include <linux/module.h>
+ #include <linux/moduleparam.h>
+ #include <linux/init.h>
+@@ -64,9 +67,9 @@ static int monwrite_diag(struct monwrite
+ 	rc = appldata_asm(&id, fcn, (void *) buffer, myhdr->datalen);
+ 	if (rc <= 0)
+ 		return rc;
++	pr_err("Writing monitor data failed with rc=%i\n", rc);
+ 	if (rc == 5)
+ 		return -EPERM;
+-	printk("DIAG X'DC' error with return code: %i\n", rc);
+ 	return -EINVAL;
+ }
+ 
+Index: linux-2.6.27-gentoo-r7/drivers/s390/char/sclp_cmd.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/char/sclp_cmd.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/char/sclp_cmd.c
+@@ -6,6 +6,9 @@
+  *		 Peter Oberparleiter <peter.oberparleiter@××××××.com>
+  */
+ 
++#define KMSG_COMPONENT "sclp_cmd"
++#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
++
+ #include <linux/completion.h>
+ #include <linux/init.h>
+ #include <linux/errno.h>
+@@ -16,9 +19,8 @@
+ #include <linux/memory.h>
+ #include <asm/chpid.h>
+ #include <asm/sclp.h>
+-#include "sclp.h"
+ 
+-#define TAG	"sclp_cmd: "
++#include "sclp.h"
+ 
+ #define SCLP_CMDW_READ_SCP_INFO		0x00020001
+ #define SCLP_CMDW_READ_SCP_INFO_FORCED	0x00120001
+@@ -169,8 +171,8 @@ static int do_sync_request(sclp_cmdw_t c
+ 
+ 	/* Check response. */
+ 	if (request->status != SCLP_REQ_DONE) {
+-		printk(KERN_WARNING TAG "sync request failed "
+-		       "(cmd=0x%08x, status=0x%02x)\n", cmd, request->status);
++		pr_warning("sync request failed (cmd=0x%08x, "
++			   "status=0x%02x)\n", cmd, request->status);
+ 		rc = -EIO;
+ 	}
+ out:
+@@ -224,8 +226,8 @@ int sclp_get_cpu_info(struct sclp_cpu_in
+ 	if (rc)
+ 		goto out;
+ 	if (sccb->header.response_code != 0x0010) {
+-		printk(KERN_WARNING TAG "readcpuinfo failed "
+-		       "(response=0x%04x)\n", sccb->header.response_code);
++		pr_warning("readcpuinfo failed (response=0x%04x)\n",
++			   sccb->header.response_code);
+ 		rc = -EIO;
+ 		goto out;
+ 	}
+@@ -262,8 +264,9 @@ static int do_cpu_configure(sclp_cmdw_t 
+ 	case 0x0120:
+ 		break;
+ 	default:
+-		printk(KERN_WARNING TAG "configure cpu failed (cmd=0x%08x, "
+-		       "response=0x%04x)\n", cmd, sccb->header.response_code);
++		pr_warning("configure cpu failed (cmd=0x%08x, "
++			   "response=0x%04x)\n", cmd,
++			   sccb->header.response_code);
+ 		rc = -EIO;
+ 		break;
+ 	}
+@@ -626,9 +629,9 @@ static int do_chp_configure(sclp_cmdw_t 
+ 	case 0x0450:
+ 		break;
+ 	default:
+-		printk(KERN_WARNING TAG "configure channel-path failed "
+-		       "(cmd=0x%08x, response=0x%04x)\n", cmd,
+-		       sccb->header.response_code);
++		pr_warning("configure channel-path failed "
++			   "(cmd=0x%08x, response=0x%04x)\n", cmd,
++			   sccb->header.response_code);
+ 		rc = -EIO;
+ 		break;
+ 	}
+@@ -695,8 +698,8 @@ int sclp_chp_read_info(struct sclp_chp_i
+ 	if (rc)
+ 		goto out;
+ 	if (sccb->header.response_code != 0x0010) {
+-		printk(KERN_WARNING TAG "read channel-path info failed "
+-		       "(response=0x%04x)\n", sccb->header.response_code);
++		pr_warning("read channel-path info failed "
++			   "(response=0x%04x)\n", sccb->header.response_code);
+ 		rc = -EIO;
+ 		goto out;
+ 	}
+Index: linux-2.6.27-gentoo-r7/drivers/s390/char/sclp_config.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/char/sclp_config.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/char/sclp_config.c
+@@ -5,15 +5,17 @@
+  *    Author(s): Heiko Carstens <heiko.carstens@××××××.com>
+  */
+ 
++#define KMSG_COMPONENT "sclp_config"
++#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
++
+ #include <linux/init.h>
+ #include <linux/errno.h>
+ #include <linux/cpu.h>
+ #include <linux/sysdev.h>
+ #include <linux/workqueue.h>
+ #include <asm/smp.h>
+-#include "sclp.h"
+ 
+-#define TAG	"sclp_config: "
++#include "sclp.h"
+ 
+ struct conf_mgm_data {
+ 	u8 reserved;
+@@ -31,7 +33,7 @@ static void sclp_cpu_capability_notify(s
+ 	int cpu;
+ 	struct sys_device *sysdev;
+ 
+-	printk(KERN_WARNING TAG "cpu capability changed.\n");
++	pr_warning("cpu capability changed.\n");
+ 	get_online_cpus();
+ 	for_each_online_cpu(cpu) {
+ 		sysdev = get_cpu_sysdev(cpu);
+@@ -78,7 +80,7 @@ static int __init sclp_conf_init(void)
+ 		return rc;
+ 
+ 	if (!(sclp_conf_register.sclp_send_mask & EVTYP_CONFMGMDATA_MASK)) {
+-		printk(KERN_WARNING TAG "no configuration management.\n");
++		pr_warning("no configuration management.\n");
+ 		sclp_unregister(&sclp_conf_register);
+ 		rc = -ENOSYS;
+ 	}
+Index: linux-2.6.27-gentoo-r7/drivers/s390/char/sclp_cpi_sys.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/char/sclp_cpi_sys.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/char/sclp_cpi_sys.c
+@@ -7,6 +7,9 @@
+  *		 Michael Ernst <mernst@××××××.com>
+  */
+ 
++#define KMSG_COMPONENT "sclp_cpi"
++#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
++
+ #include <linux/kernel.h>
+ #include <linux/init.h>
+ #include <linux/stat.h>
+@@ -20,6 +23,7 @@
+ #include <linux/completion.h>
+ #include <asm/ebcdic.h>
+ #include <asm/sclp.h>
++
+ #include "sclp.h"
+ #include "sclp_rw.h"
+ #include "sclp_cpi_sys.h"
+@@ -150,16 +154,16 @@ static int cpi_req(void)
+ 	wait_for_completion(&completion);
+ 
+ 	if (req->status != SCLP_REQ_DONE) {
+-		printk(KERN_WARNING "cpi: request failed (status=0x%02x)\n",
+-			req->status);
++		pr_warning("request failed (status=0x%02x)\n",
++			   req->status);
+ 		rc = -EIO;
+ 		goto out_free_req;
+ 	}
+ 
+ 	response = ((struct cpi_sccb *) req->sccb)->header.response_code;
+ 	if (response != 0x0020) {
+-		printk(KERN_WARNING "cpi: failed with "
+-			"response code 0x%x\n", response);
++		pr_warning("request failed with response code 0x%x\n",
++			   response);
+ 		rc = -EIO;
+ 	}
+ 
+Index: linux-2.6.27-gentoo-r7/drivers/s390/char/sclp_sdias.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/char/sclp_sdias.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/char/sclp_sdias.c
+@@ -5,15 +5,18 @@
+  * Author(s): Michael Holzheu
+  */
+ 
++#define KMSG_COMPONENT "sclp_sdias"
++#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
++
+ #include <linux/sched.h>
+ #include <asm/sclp.h>
+ #include <asm/debug.h>
+ #include <asm/ipl.h>
++
+ #include "sclp.h"
+ #include "sclp_rw.h"
+ 
+ #define TRACE(x...) debug_sprintf_event(sdias_dbf, 1, x)
+-#define ERROR_MSG(x...) printk ( KERN_ALERT "SDIAS: " x )
+ 
+ #define SDIAS_RETRIES 300
+ #define SDIAS_SLEEP_TICKS 50
+@@ -131,7 +134,7 @@ int sclp_sdias_blk_count(void)
+ 
+ 	rc = sdias_sclp_send(&request);
+ 	if (rc) {
+-		ERROR_MSG("sclp_send failed for get_nr_blocks\n");
++		pr_err("sclp_send failed for get_nr_blocks\n");
+ 		goto out;
+ 	}
+ 	if (sccb.hdr.response_code != 0x0020) {
+@@ -145,7 +148,8 @@ int sclp_sdias_blk_count(void)
+ 			rc = sccb.evbuf.blk_cnt;
+ 			break;
+ 		default:
+-			ERROR_MSG("SCLP error: %x\n", sccb.evbuf.event_status);
++			pr_err("SCLP error: %x\n",
++			       sccb.evbuf.event_status);
+ 			rc = -EIO;
+ 			goto out;
+ 	}
+@@ -201,7 +205,7 @@ int sclp_sdias_copy(void *dest, int star
+ 
+ 	rc = sdias_sclp_send(&request);
+ 	if (rc) {
+-		ERROR_MSG("sclp_send failed: %x\n", rc);
++		pr_err("sclp_send failed: %x\n", rc);
+ 		goto out;
+ 	}
+ 	if (sccb.hdr.response_code != 0x0020) {
+@@ -219,9 +223,9 @@ int sclp_sdias_copy(void *dest, int star
+ 		case EVSTATE_NO_DATA:
+ 			TRACE("no data\n");
+ 		default:
+-			ERROR_MSG("Error from SCLP while copying hsa. "
+-				  "Event status = %x\n",
+-				sccb.evbuf.event_status);
++			pr_err("Error from SCLP while copying hsa. "
++			       "Event status = %x\n",
++			       sccb.evbuf.event_status);
+ 			rc = -EIO;
+ 	}
+ out:
+Index: linux-2.6.27-gentoo-r7/drivers/s390/char/vmcp.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/char/vmcp.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/char/vmcp.c
+@@ -11,6 +11,9 @@
+  * The idea of this driver is based on cpint from Neale Ferguson and #CP in CMS
+  */
+ 
++#define KMSG_COMPONENT "vmcp"
++#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
++
+ #include <linux/fs.h>
+ #include <linux/init.h>
+ #include <linux/kernel.h>
+@@ -26,8 +29,6 @@ MODULE_LICENSE("GPL");
+ MODULE_AUTHOR("Christian Borntraeger <borntraeger@××××××.com>");
+ MODULE_DESCRIPTION("z/VM CP interface");
+ 
+-#define PRINTK_HEADER "vmcp: "
+-
+ static debug_info_t *vmcp_debug;
+ 
+ static int vmcp_open(struct inode *inode, struct file *file)
+@@ -193,7 +194,8 @@ static int __init vmcp_init(void)
+ 	int ret;
+ 
+ 	if (!MACHINE_IS_VM) {
+-		PRINT_WARN("z/VM CP interface is only available under z/VM\n");
++		pr_warning("The z/VM CP interface device driver cannot be "
++			   "loaded without z/VM\n");
+ 		return -ENODEV;
+ 	}
+ 
+Index: linux-2.6.27-gentoo-r7/drivers/s390/char/vmlogrdr.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/char/vmlogrdr.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/char/vmlogrdr.c
+@@ -10,6 +10,10 @@
+  *		   Stefan Weinhuber <wein@××××××.com>
+  *
+  */
++
++#define KMSG_COMPONENT "vmlogrdr"
++#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
++
+ #include <linux/module.h>
+ #include <linux/init.h>
+ #include <linux/errno.h>
+@@ -28,8 +32,6 @@
+ #include <linux/smp_lock.h>
+ #include <linux/string.h>
+ 
+-
+-
+ MODULE_AUTHOR
+ 	("(C) 2004 IBM Corporation by Xenia Tkatschow (xenia@××××××.com)\n"
+ 	 "                            Stefan Weinhuber (wein@××××××.com)");
+@@ -174,8 +176,7 @@ static void vmlogrdr_iucv_path_severed(s
+ 	struct vmlogrdr_priv_t * logptr = path->private;
+ 	u8 reason = (u8) ipuser[8];
+ 
+-	printk (KERN_ERR "vmlogrdr: connection severed with"
+-		" reason %i\n", reason);
++	pr_err("vmlogrdr: connection severed with reason %i\n", reason);
+ 
+ 	iucv_path_sever(path, NULL);
+ 	kfree(path);
+@@ -333,8 +334,8 @@ static int vmlogrdr_open (struct inode *
+ 	if (logptr->autorecording) {
+ 		ret = vmlogrdr_recording(logptr,1,logptr->autopurge);
+ 		if (ret)
+-			printk (KERN_WARNING "vmlogrdr: failed to start "
+-				"recording automatically\n");
++			pr_warning("vmlogrdr: failed to start "
++				   "recording automatically\n");
+ 	}
+ 
+ 	/* create connection to the system service */
+@@ -345,9 +346,9 @@ static int vmlogrdr_open (struct inode *
+ 				       logptr->system_service, NULL, NULL,
+ 				       logptr);
+ 	if (connect_rc) {
+-		printk (KERN_ERR "vmlogrdr: iucv connection to %s "
+-			"failed with rc %i \n", logptr->system_service,
+-			connect_rc);
++		pr_err("vmlogrdr: iucv connection to %s "
++		       "failed with rc %i \n",
++		       logptr->system_service, connect_rc);
+ 		goto out_path;
+ 	}
+ 
+@@ -388,8 +389,8 @@ static int vmlogrdr_release (struct inod
+ 	if (logptr->autorecording) {
+ 		ret = vmlogrdr_recording(logptr,0,logptr->autopurge);
+ 		if (ret)
+-			printk (KERN_WARNING "vmlogrdr: failed to stop "
+-				"recording automatically\n");
++			pr_warning("vmlogrdr: failed to stop "
++				   "recording automatically\n");
+ 	}
+ 	logptr->dev_in_use = 0;
+ 
+@@ -824,8 +825,7 @@ static int __init vmlogrdr_init(void)
+ 	dev_t dev;
+ 
+ 	if (! MACHINE_IS_VM) {
+-		printk (KERN_ERR "vmlogrdr: not running under VM, "
+-				"driver not loaded.\n");
++		pr_err("not running under VM, driver not loaded.\n");
+ 		return -ENODEV;
+ 	}
+ 
+Index: linux-2.6.27-gentoo-r7/drivers/s390/char/vmur.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/char/vmur.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/char/vmur.c
+@@ -8,6 +8,9 @@
+  *	    Frank Munzert <munzert@××××××.com>
+  */
+ 
++#define KMSG_COMPONENT "vmur"
++#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
++
+ #include <linux/cdev.h>
+ #include <linux/smp_lock.h>
+ 
+@@ -40,8 +43,6 @@ MODULE_AUTHOR("IBM Corporation");
+ MODULE_DESCRIPTION("s390 z/VM virtual unit record device driver");
+ MODULE_LICENSE("GPL");
+ 
+-#define PRINTK_HEADER "vmur: "
+-
+ static dev_t ur_first_dev_maj_min;
+ static struct class *vmur_class;
+ static struct debug_info *vmur_dbf;
+@@ -988,7 +989,8 @@ static int __init ur_init(void)
+ 	dev_t dev;
+ 
+ 	if (!MACHINE_IS_VM) {
+-		PRINT_ERR("%s is only available under z/VM.\n", ur_banner);
++		pr_err("The %s cannot be loaded without z/VM\n",
++		       ur_banner);
+ 		return -ENODEV;
+ 	}
+ 
+@@ -1007,7 +1009,8 @@ static int __init ur_init(void)
+ 
+ 	rc = alloc_chrdev_region(&dev, 0, NUM_MINORS, "vmur");
+ 	if (rc) {
+-		PRINT_ERR("alloc_chrdev_region failed: err = %d\n", rc);
++		pr_err("Kernel function alloc_chrdev_region failed with "
++		       "error code %d\n", rc);
+ 		goto fail_unregister_driver;
+ 	}
+ 	ur_first_dev_maj_min = MKDEV(MAJOR(dev), 0);
+@@ -1017,7 +1020,7 @@ static int __init ur_init(void)
+ 		rc = PTR_ERR(vmur_class);
+ 		goto fail_unregister_region;
+ 	}
+-	PRINT_INFO("%s loaded.\n", ur_banner);
++	pr_info("%s loaded.\n", ur_banner);
+ 	return 0;
+ 
+ fail_unregister_region:
+@@ -1035,7 +1038,7 @@ static void __exit ur_exit(void)
+ 	unregister_chrdev_region(ur_first_dev_maj_min, NUM_MINORS);
+ 	ccw_driver_unregister(&ur_driver);
+ 	debug_unregister(vmur_dbf);
+-	PRINT_INFO("%s unloaded.\n", ur_banner);
++	pr_info("%s unloaded.\n", ur_banner);
+ }
+ 
+ module_init(ur_init);
+Index: linux-2.6.27-gentoo-r7/drivers/s390/char/zcore.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/char/zcore.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/char/zcore.c
+@@ -9,6 +9,9 @@
+  * Author(s): Michael Holzheu
+  */
+ 
++#define KMSG_COMPONENT "zdump"
++#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
++
+ #include <linux/init.h>
+ #include <linux/miscdevice.h>
+ #include <linux/utsname.h>
+@@ -24,8 +27,6 @@
+ #include "sclp.h"
+ 
+ #define TRACE(x...) debug_sprintf_event(zcore_dbf, 1, x)
+-#define MSG(x...) printk( KERN_ALERT x )
+-#define ERROR_MSG(x...) printk ( KERN_ALERT "DUMP: " x )
+ 
+ #define TO_USER		0
+ #define TO_KERNEL	1
+@@ -563,19 +564,19 @@ static int __init sys_info_init(enum arc
+ 
+ 	switch (arch) {
+ 	case ARCH_S390X:
+-		MSG("DETECTED 'S390X (64 bit) OS'\n");
++		pr_alert("DETECTED 'S390X (64 bit) OS'\n");
+ 		sys_info.sa_base = SAVE_AREA_BASE_S390X;
+ 		sys_info.sa_size = sizeof(struct save_area_s390x);
+ 		set_s390x_lc_mask(&sys_info.lc_mask);
+ 		break;
+ 	case ARCH_S390:
+-		MSG("DETECTED 'S390 (32 bit) OS'\n");
++		pr_alert("DETECTED 'S390 (32 bit) OS'\n");
+ 		sys_info.sa_base = SAVE_AREA_BASE_S390;
+ 		sys_info.sa_size = sizeof(struct save_area_s390);
+ 		set_s390_lc_mask(&sys_info.lc_mask);
+ 		break;
+ 	default:
+-		ERROR_MSG("unknown architecture 0x%x.\n",arch);
++		pr_alert("0x%x is an unknown architecture.\n",arch);
+ 		return -EINVAL;
+ 	}
+ 	sys_info.arch = arch;
+@@ -674,7 +675,8 @@ static int __init zcore_init(void)
+ 
+ #ifndef __s390x__
+ 	if (arch == ARCH_S390X) {
+-		ERROR_MSG("32 bit dumper can't dump 64 bit system!\n");
++		pr_alert("The 32-bit dump tool cannot be used for a "
++			 "64-bit system\n");
+ 		rc = -EINVAL;
+ 		goto fail;
+ 	}
+Index: linux-2.6.27-gentoo-r7/drivers/s390/cio/blacklist.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/cio/blacklist.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/cio/blacklist.c
+@@ -9,6 +9,9 @@
+  *		 Arnd Bergmann (arndb@××××××.com)
+  */
+ 
++#define KMSG_COMPONENT "cio"
++#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
++
+ #include <linux/init.h>
+ #include <linux/vmalloc.h>
+ #include <linux/slab.h>
+@@ -50,9 +53,10 @@ static int blacklist_range(range_action 
+ {
+ 	if ((from_ssid > to_ssid) || ((from_ssid == to_ssid) && (from > to))) {
+ 		if (msgtrigger)
+-			printk(KERN_WARNING "cio: Invalid cio_ignore range "
+-			       "0.%x.%04x-0.%x.%04x\n", from_ssid, from,
+-			       to_ssid, to);
++			pr_warning("0.%x.%04x to 0.%x.%04x is not a valid "
++				   "range for cio_ignore\n", from_ssid, from,
++				   to_ssid, to);
++
+ 		return 1;
+ 	}
+ 
+@@ -140,8 +144,8 @@ static int parse_busid(char *str, unsign
+ 	rc = 0;
+ out:
+ 	if (rc && msgtrigger)
+-		printk(KERN_WARNING "cio: Invalid cio_ignore device '%s'\n",
+-		       str);
++		pr_warning("%s is not a valid device for the cio_ignore "
++			   "kernel parameter\n", str);
+ 
+ 	return rc;
+ }
+Index: linux-2.6.27-gentoo-r7/drivers/s390/cio/chsc.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/cio/chsc.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/cio/chsc.c
+@@ -8,6 +8,9 @@
+  *		 Arnd Bergmann (arndb@××××××.com)
+  */
+ 
++#define KMSG_COMPONENT "cio"
++#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
++
+ #include <linux/module.h>
+ #include <linux/slab.h>
+ #include <linux/init.h>
+@@ -333,6 +336,7 @@ static void chsc_process_sei_chp_config(
+ 	struct chp_config_data *data;
+ 	struct chp_id chpid;
+ 	int num;
++	char *events[3] = {"configure", "deconfigure", "cancel deconfigure"};
+ 
+ 	CIO_CRW_EVENT(4, "chsc: channel-path-configuration notification\n");
+ 	if (sei_area->rs != 0)
+@@ -343,8 +347,8 @@ static void chsc_process_sei_chp_config(
+ 		if (!chp_test_bit(data->map, num))
+ 			continue;
+ 		chpid.id = num;
+-		printk(KERN_WARNING "cio: processing configure event %d for "
+-		       "chpid %x.%02x\n", data->op, chpid.cssid, chpid.id);
++		pr_notice("Processing %s for channel path %x.%02x\n",
++			  events[data->op], chpid.cssid, chpid.id);
+ 		switch (data->op) {
+ 		case 0:
+ 			chp_cfg_schedule(chpid, 1);
+Index: linux-2.6.27-gentoo-r7/drivers/s390/cio/cio.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/cio/cio.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/cio/cio.c
+@@ -9,6 +9,9 @@
+  *		 Martin Schwidefsky (schwidefsky@××××××.com)
+  */
+ 
++#define KMSG_COMPONENT "cio"
++#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
++
+ #include <linux/module.h>
+ #include <linux/init.h>
+ #include <linux/slab.h>
+@@ -777,7 +780,7 @@ cio_probe_console(void)
+ 	sch_no = cio_get_console_sch_no();
+ 	if (sch_no == -1) {
+ 		console_subchannel_in_use = 0;
+-		printk(KERN_WARNING "cio: No ccw console found!\n");
++		pr_warning("No CCW console was found\n");
+ 		return ERR_PTR(-ENODEV);
+ 	}
+ 	memset(&console_subchannel, 0, sizeof(struct subchannel));
+Index: linux-2.6.27-gentoo-r7/drivers/s390/cio/cmf.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/cio/cmf.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/cio/cmf.c
+@@ -25,6 +25,9 @@
+  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+  */
+ 
++#define KMSG_COMPONENT "cio"
++#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
++
+ #include <linux/bootmem.h>
+ #include <linux/device.h>
+ #include <linux/init.h>
+@@ -1359,9 +1362,8 @@ static int __init init_cmf(void)
+ 	default:
+ 		return 1;
+ 	}
+-
+-	printk(KERN_INFO "cio: Channel measurement facility using %s "
+-	       "format (%s)\n", format_string, detect_string);
++	pr_info("Channel measurement facility initialized using format "
++		"%s (mode %s)\n", format_string, detect_string);
+ 	return 0;
+ }
+ 
+Index: linux-2.6.27-gentoo-r7/drivers/s390/cio/css.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/cio/css.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/cio/css.c
+@@ -6,6 +6,10 @@
+  *    Author(s): Arnd Bergmann (arndb@××××××.com)
+  *		 Cornelia Huck (cornelia.huck@××××××.com)
+  */
++
++#define KMSG_COMPONENT "cio"
++#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
++
+ #include <linux/module.h>
+ #include <linux/init.h>
+ #include <linux/device.h>
+@@ -844,8 +848,8 @@ out:
+ 	s390_unregister_crw_handler(CRW_RSC_CSS);
+ 	chsc_free_sei_area();
+ 	kfree(slow_subchannel_set);
+-	printk(KERN_WARNING"cio: failed to initialize css driver (%d)!\n",
+-	       ret);
++	pr_alert("The CSS device driver initialization failed with "
++		 "errno=%d\n", ret);
+ 	return ret;
+ }
+ 
+Index: linux-2.6.27-gentoo-r7/drivers/s390/cio/qdio.h
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/cio/qdio.h
++++ linux-2.6.27-gentoo-r7/drivers/s390/cio/qdio.h
+@@ -203,6 +203,9 @@ struct qdio_output_q {
+ 	/* PCIs are enabled for the queue */
+ 	int pci_out_enabled;
+ 
++	/* IQDIO: output multiple buffers (enhanced SIGA) */
++	int use_enh_siga;
++
+ 	/* timer to check for more outbound work */
+ 	struct timer_list timer;
+ };
+Index: linux-2.6.27-gentoo-r7/drivers/s390/cio/qdio_main.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/cio/qdio_main.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/cio/qdio_main.c
+@@ -316,6 +316,9 @@ static inline int qdio_do_siga_output(st
+ 	unsigned int fc = 0;
+ 	unsigned long schid;
+ 
++	if (q->u.out.use_enh_siga) {
++		fc = 3;
++	}
+ 	if (!is_qebsm(q))
+ 		schid = *((u32 *)&q->irq_ptr->schid);
+ 	else {
+@@ -1448,6 +1451,8 @@ int qdio_establish(struct qdio_initializ
+ 	}
+ 
+ 	qdio_setup_ssqd_info(irq_ptr);
++	sprintf(dbf_text, "qDmmwc%2x", irq_ptr->ssqd_desc.mmwc);
++	QDIO_DBF_TEXT2(0, setup, dbf_text);
+ 	sprintf(dbf_text, "qib ac%2x", irq_ptr->qib.ac);
+ 	QDIO_DBF_TEXT2(0, setup, dbf_text);
+ 
+@@ -1620,12 +1625,21 @@ static void handle_outbound(struct qdio_
+ 		if (multicast_outbound(q))
+ 			qdio_kick_outbound_q(q);
+ 		else
+-			/*
+-			 * One siga-w per buffer required for unicast
+-			 * HiperSockets.
+-			 */
+-			while (count--)
++			if ((q->irq_ptr->ssqd_desc.mmwc > 1) &&
++			    (count > 1) &&
++			    (count <= q->irq_ptr->ssqd_desc.mmwc)) {
++				/* exploit enhanced SIGA */
++				q->u.out.use_enh_siga = 1;
+ 				qdio_kick_outbound_q(q);
++			} else {
++				/*
++				* One siga-w per buffer required for unicast
++				* HiperSockets.
++				*/
++				q->u.out.use_enh_siga = 0;
++				while (count--)
++					qdio_kick_outbound_q(q);
++			}
+ 		goto out;
+ 	}
+ 
+Index: linux-2.6.27-gentoo-r7/drivers/s390/crypto/ap_bus.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/crypto/ap_bus.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/crypto/ap_bus.c
+@@ -5,6 +5,7 @@
+  * Author(s): Cornelia Huck <cornelia.huck@××××××.com>
+  *	      Martin Schwidefsky <schwidefsky@××××××.com>
+  *	      Ralph Wuerthner <rwuerthn@××××××.com>
++ *	      Felix Beck <felix.beck@××××××.com>
+  *
+  * Adjunct processor bus.
+  *
+@@ -23,6 +24,9 @@
+  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+  */
+ 
++#define KMSG_COMPONENT "ap"
++#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
++
+ #include <linux/module.h>
+ #include <linux/init.h>
+ #include <linux/delay.h>
+@@ -34,6 +38,10 @@
+ #include <linux/mutex.h>
+ #include <asm/s390_rdev.h>
+ #include <asm/reset.h>
++#include <asm/airq.h>
++#include <asm/atomic.h>
++#include <asm/system.h>
++#include <asm/isc.h>
+ #include <linux/hrtimer.h>
+ #include <linux/ktime.h>
+ 
+@@ -46,6 +54,7 @@ static enum hrtimer_restart ap_poll_time
+ static int ap_poll_thread_start(void);
+ static void ap_poll_thread_stop(void);
+ static void ap_request_timeout(unsigned long);
++static inline void ap_schedule_poll_timer(void);
+ 
+ /*
+  * Module description.
+@@ -80,19 +89,29 @@ static int ap_config_time = AP_CONFIG_TI
+ static DECLARE_WORK(ap_config_work, ap_scan_bus);
+ 
+ /*
+- * Tasklet & timer for AP request polling.
++ * Tasklet & timer for AP request polling and interrupts
+  */
+ static DECLARE_TASKLET(ap_tasklet, ap_poll_all, 0);
+ static atomic_t ap_poll_requests = ATOMIC_INIT(0);
+ static DECLARE_WAIT_QUEUE_HEAD(ap_poll_wait);
+ static struct task_struct *ap_poll_kthread = NULL;
+ static DEFINE_MUTEX(ap_poll_thread_mutex);
++static void *ap_interrupt_indicator;
+ static struct hrtimer ap_poll_timer;
+ /* In LPAR poll with 4kHz frequency. Poll every 250000 nanoseconds.
+  * If z/VM change to 1500000 nanoseconds to adjust to z/VM polling.*/
+ static unsigned long long poll_timeout = 250000;
+ 
+ /**
++ * ap_using_interrupts() - Returns non-zero if interrupt support is
++ * available.
++ */
++static inline int ap_using_interrupts(void)
++{
++	return ap_interrupt_indicator != NULL;
++}
++
++/**
+  * ap_intructions_available() - Test if AP instructions are available.
+  *
+  * Returns 0 if the AP instructions are installed.
+@@ -113,6 +132,23 @@ static inline int ap_instructions_availa
+ }
+ 
+ /**
++ * ap_interrupts_available(): Test if AP interrupts are available.
++ *
++ * Returns 1 if AP interrupts are available.
++ */
++static int ap_interrupts_available(void)
++{
++	unsigned long long facility_bits[2];
++
++	if (stfle(facility_bits, 2) <= 1)
++		return 0;
++	if (!(facility_bits[0] & (1ULL << 61)) ||
++	    !(facility_bits[1] & (1ULL << 62)))
++		return 0;
++	return 1;
++}
++
++/**
+  * ap_test_queue(): Test adjunct processor queue.
+  * @qid: The AP queue number
+  * @queue_depth: Pointer to queue depth value
+@@ -152,6 +188,80 @@ static inline struct ap_queue_status ap_
+ 	return reg1;
+ }
+ 
++#ifdef CONFIG_64BIT
++/**
++ * ap_queue_interruption_control(): Enable interruption for a specific AP.
++ * @qid: The AP queue number
++ * @ind: The notification indicator byte
++ *
++ * Returns AP queue status.
++ */
++static inline struct ap_queue_status
++ap_queue_interruption_control(ap_qid_t qid, void *ind)
++{
++	register unsigned long reg0 asm ("0") = qid | 0x03000000UL;
++	register unsigned long reg1_in asm ("1") = 0x0000800000000000UL | AP_ISC;
++	register struct ap_queue_status reg1_out asm ("1");
++	register void *reg2 asm ("2") = ind;
++	asm volatile(
++		".long 0xb2af0000"		/* PQAP(RAPQ) */
++		: "+d" (reg0), "+d" (reg1_in), "=d" (reg1_out), "+d" (reg2)
++		:
++		: "cc" );
++	return reg1_out;
++}
++#endif
++
++/**
++ * ap_queue_enable_interruption(): Enable interruption on an AP.
++ * @qid: The AP queue number
++ * @ind: the notification indicator byte
++ *
++ * Enables interruption on AP queue via ap_queue_interruption_control(). Based
++ * on the return value it waits a while and tests the AP queue if interrupts
++ * have been switched on using ap_test_queue().
++ */
++static int ap_queue_enable_interruption(ap_qid_t qid, void *ind)
++{
++#ifdef CONFIG_64BIT
++	struct ap_queue_status status;
++	int t_depth, t_device_type, rc, i;
++
++	rc = -EBUSY;
++	status = ap_queue_interruption_control(qid, ind);
++
++	for (i = 0; i < AP_MAX_RESET; i++) {
++		switch (status.response_code) {
++		case AP_RESPONSE_NORMAL:
++			if (status.int_enabled)
++				return 0;
++			break;
++		case AP_RESPONSE_RESET_IN_PROGRESS:
++		case AP_RESPONSE_BUSY:
++			break;
++		case AP_RESPONSE_Q_NOT_AVAIL:
++		case AP_RESPONSE_DECONFIGURED:
++		case AP_RESPONSE_CHECKSTOPPED:
++		case AP_RESPONSE_INVALID_ADDRESS:
++			return -ENODEV;
++		case AP_RESPONSE_OTHERWISE_CHANGED:
++			if (status.int_enabled)
++				return 0;
++			break;
++		default:
++			break;
++		}
++		if (i < AP_MAX_RESET - 1) {
++			udelay(5);
++			status = ap_test_queue(qid, &t_depth, &t_device_type);
++		}
++	}
++	return rc;
++#else
++	return -EINVAL;
++#endif
++}
++
+ /**
+  * __ap_send(): Send message to adjunct processor queue.
+  * @qid: The AP queue number
+@@ -295,6 +405,11 @@ static int ap_query_queue(ap_qid_t qid, 
+ 		case AP_RESPONSE_CHECKSTOPPED:
+ 			rc = -ENODEV;
+ 			break;
++		case AP_RESPONSE_INVALID_ADDRESS:
++			rc = -ENODEV;
++			break;
++		case AP_RESPONSE_OTHERWISE_CHANGED:
++			break;
+ 		case AP_RESPONSE_BUSY:
+ 			break;
+ 		default:
+@@ -345,6 +460,15 @@ static int ap_init_queue(ap_qid_t qid)
+ 			status = ap_test_queue(qid, &dummy, &dummy);
+ 		}
+ 	}
++	if (rc == 0 && ap_using_interrupts()) {
++		rc = ap_queue_enable_interruption(qid, ap_interrupt_indicator);
++		/* If interruption mode is supported by the machine,
++		* but an AP can not be enabled for interruption then
++		* the AP will be discarded.    */
++		if (rc)
++			pr_err("Registering adapter interrupts for "
++			       "AP %d failed\n", AP_QID_DEVICE(qid));
++	}
+ 	return rc;
+ }
+ 
+@@ -599,6 +723,14 @@ static ssize_t ap_config_time_show(struc
+ 	return snprintf(buf, PAGE_SIZE, "%d\n", ap_config_time);
+ }
+ 
++static ssize_t ap_interrupts_show(struct bus_type *bus, char *buf)
++{
++	return snprintf(buf, PAGE_SIZE, "%d\n",
++			ap_using_interrupts() ? 1 : 0);
++}
++
++static BUS_ATTR(ap_interrupts, 0444, ap_interrupts_show, NULL);
++
+ static ssize_t ap_config_time_store(struct bus_type *bus,
+ 				    const char *buf, size_t count)
+ {
+@@ -653,7 +785,8 @@ static ssize_t poll_timeout_store(struct
+ 	ktime_t hr_time;
+ 
+ 	/* 120 seconds = maximum poll interval */
+-	if (sscanf(buf, "%llu\n", &time) != 1 || time < 1 || time > 120000000000)
++	if (sscanf(buf, "%llu\n", &time) != 1 || time < 1 ||
++	    time > 120000000000ULL)
+ 		return -EINVAL;
+ 	poll_timeout = time;
+ 	hr_time = ktime_set(0, poll_timeout);
+@@ -672,6 +805,7 @@ static struct bus_attribute *const ap_bu
+ 	&bus_attr_ap_domain,
+ 	&bus_attr_config_time,
+ 	&bus_attr_poll_thread,
++	&bus_attr_ap_interrupts,
+ 	&bus_attr_poll_timeout,
+ 	NULL,
+ };
+@@ -814,6 +948,11 @@ out:
+ 	return rc;
+ }
+ 
++static void ap_interrupt_handler(void *unused1, void *unused2)
++{
++	tasklet_schedule(&ap_tasklet);
++}
++
+ /**
+  * __ap_scan_bus(): Scan the AP bus.
+  * @dev: Pointer to device
+@@ -928,6 +1067,8 @@ ap_config_timeout(unsigned long ptr)
+  */
+ static inline void ap_schedule_poll_timer(void)
+ {
++	if (ap_using_interrupts())
++		return;
+ 	if (hrtimer_is_queued(&ap_poll_timer))
+ 		return;
+ 	hrtimer_start(&ap_poll_timer, ktime_set(0, poll_timeout),
+@@ -1207,6 +1348,12 @@ static void ap_poll_all(unsigned long du
+ 	unsigned long flags;
+ 	struct ap_device *ap_dev;
+ 
++	/* Reset the indicator if interrupts are used. Thus new interrupts can
++	 * be received. Doing it in the beginning of the tasklet is therefor
++	 * important that no requests on any AP get lost.
++	 */
++	if (ap_using_interrupts())
++		xchg((u8 *)ap_interrupt_indicator, 0);
+ 	do {
+ 		flags = 0;
+ 		spin_lock(&ap_device_lock);
+@@ -1268,6 +1415,8 @@ static int ap_poll_thread_start(void)
+ {
+ 	int rc;
+ 
++	if (ap_using_interrupts())
++		return 0;
+ 	mutex_lock(&ap_poll_thread_mutex);
+ 	if (!ap_poll_kthread) {
+ 		ap_poll_kthread = kthread_run(ap_poll_thread, NULL, "appoll");
+@@ -1301,8 +1450,12 @@ static void ap_request_timeout(unsigned 
+ {
+ 	struct ap_device *ap_dev = (struct ap_device *) data;
+ 
+-	if (ap_dev->reset == AP_RESET_ARMED)
++	if (ap_dev->reset == AP_RESET_ARMED) {
+ 		ap_dev->reset = AP_RESET_DO;
++
++		if (ap_using_interrupts())
++			tasklet_schedule(&ap_tasklet);
++	}
+ }
+ 
+ static void ap_reset_domain(void)
+@@ -1337,14 +1490,25 @@ int __init ap_module_init(void)
+ 	int rc, i;
+ 
+ 	if (ap_domain_index < -1 || ap_domain_index >= AP_DOMAINS) {
+-		printk(KERN_WARNING "Invalid param: domain = %d. "
+-		       " Not loading.\n", ap_domain_index);
++		pr_warning("%d is not a valid cryptographic domain\n",
++			   ap_domain_index);
+ 		return -EINVAL;
+ 	}
+ 	if (ap_instructions_available() != 0) {
+-		printk(KERN_WARNING "AP instructions not installed.\n");
++		pr_warning("The hardware system does not support "
++			   "AP instructions\n");
+ 		return -ENODEV;
+ 	}
++	if (ap_interrupts_available()) {
++		isc_register(AP_ISC);
++		ap_interrupt_indicator = s390_register_adapter_interrupt(
++			&ap_interrupt_handler, NULL, AP_ISC);
++		if (IS_ERR(ap_interrupt_indicator)) {
++			ap_interrupt_indicator = NULL;
++			isc_unregister(AP_ISC);
++		}
++	}
++
+ 	register_reset_call(&ap_reset_call);
+ 
+ 	/* Create /sys/bus/ap. */
+@@ -1408,6 +1572,10 @@ out_bus:
+ 	bus_unregister(&ap_bus_type);
+ out:
+ 	unregister_reset_call(&ap_reset_call);
++	if (ap_using_interrupts()) {
++		s390_unregister_adapter_interrupt(ap_interrupt_indicator, AP_ISC);
++		isc_unregister(AP_ISC);
++	}
+ 	return rc;
+ }
+ 
+@@ -1443,6 +1611,10 @@ void ap_module_exit(void)
+ 		bus_remove_file(&ap_bus_type, ap_bus_attrs[i]);
+ 	bus_unregister(&ap_bus_type);
+ 	unregister_reset_call(&ap_reset_call);
++	if (ap_using_interrupts()) {
++		s390_unregister_adapter_interrupt(ap_interrupt_indicator, AP_ISC);
++		isc_unregister(AP_ISC);
++	}
+ }
+ 
+ #ifndef CONFIG_ZCRYPT_MONOLITHIC
+Index: linux-2.6.27-gentoo-r7/drivers/s390/crypto/ap_bus.h
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/crypto/ap_bus.h
++++ linux-2.6.27-gentoo-r7/drivers/s390/crypto/ap_bus.h
+@@ -5,6 +5,7 @@
+  * Author(s): Cornelia Huck <cornelia.huck@××××××.com>
+  *	      Martin Schwidefsky <schwidefsky@××××××.com>
+  *	      Ralph Wuerthner <rwuerthn@××××××.com>
++ *	      Felix Beck <felix.beck@××××××.com>
+  *
+  * Adjunct processor bus header file.
+  *
+@@ -67,7 +68,8 @@ struct ap_queue_status {
+ 	unsigned int queue_empty	: 1;
+ 	unsigned int replies_waiting	: 1;
+ 	unsigned int queue_full		: 1;
+-	unsigned int pad1		: 5;
++	unsigned int pad1		: 4;
++	unsigned int int_enabled	: 1;
+ 	unsigned int response_code	: 8;
+ 	unsigned int pad2		: 16;
+ };
+@@ -78,6 +80,8 @@ struct ap_queue_status {
+ #define AP_RESPONSE_DECONFIGURED	0x03
+ #define AP_RESPONSE_CHECKSTOPPED	0x04
+ #define AP_RESPONSE_BUSY		0x05
++#define AP_RESPONSE_INVALID_ADDRESS	0x06
++#define AP_RESPONSE_OTHERWISE_CHANGED	0x07
+ #define AP_RESPONSE_Q_FULL		0x10
+ #define AP_RESPONSE_NO_PENDING_REPLY	0x10
+ #define AP_RESPONSE_INDEX_TOO_BIG	0x11
+Index: linux-2.6.27-gentoo-r7/drivers/s390/net/claw.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/net/claw.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/net/claw.c
+@@ -60,6 +60,9 @@
+  *    1.25  Added Packing support
+  *    1.5
+  */
++
++#define KMSG_COMPONENT "claw"
++
+ #include <asm/ccwdev.h>
+ #include <asm/ccwgroup.h>
+ #include <asm/debug.h>
+@@ -94,7 +97,7 @@
+    CLAW uses the s390dbf file system  see claw_trace and claw_setup
+ */
+ 
+-
++static char version[] __initdata = "CLAW driver";
+ static char debug_buffer[255];
+ /**
+  * Debug Facility Stuff
+@@ -298,8 +301,7 @@ claw_probe(struct ccwgroup_device *cgdev
+ 	if (rc) {
+ 		probe_error(cgdev);
+ 		put_device(&cgdev->dev);
+-		printk(KERN_WARNING "add_files failed %s %s Exit Line %d \n",
+-			cgdev->cdev[0]->dev.bus_id,__func__,__LINE__);
++		dev_warn(&cgdev->dev, "add_files failed\n");
+ 		CLAW_DBF_TEXT_(2, setup, "probex%d", rc);
+ 		return rc;
+ 	}
+@@ -496,7 +498,8 @@ claw_open(struct net_device *dev)
+            ~(DEV_STAT_CHN_END | DEV_STAT_DEV_END)) != 0x00) ||
+            (((privptr->channel[READ].flag |
+ 	   	privptr->channel[WRITE].flag) & CLAW_TIMER) != 0x00)) {
+-                printk(KERN_INFO "%s: remote side is not ready\n", dev->name);
++		dev_info(&privptr->channel[READ].cdev->dev,
++			"%s: remote side is not ready\n", dev->name);
+ 		CLAW_DBF_TEXT(2, trace, "notrdy");
+ 
+                 for ( i = 0; i < 2;  i++) {
+@@ -582,10 +585,9 @@ claw_irq_handler(struct ccw_device *cdev
+ 	CLAW_DBF_TEXT(4, trace, "clawirq");
+         /* Bypass all 'unsolicited interrupts' */
+ 	if (!cdev->dev.driver_data) {
+-                printk(KERN_WARNING "claw: unsolicited interrupt for device:"
+-		 	"%s received c-%02x d-%02x\n",
+-		       cdev->dev.bus_id, irb->scsw.cmd.cstat,
+-		       irb->scsw.cmd.dstat);
++		dev_warn(&cdev->dev, "unsolicited interrupt for device "
++			"received c-%02x d-%02x\n",
++			irb->scsw.cmd.cstat, irb->scsw.cmd.dstat);
+ 		CLAW_DBF_TEXT(2, trace, "badirq");
+                 return;
+         }
+@@ -597,8 +599,8 @@ claw_irq_handler(struct ccw_device *cdev
+ 	else if (privptr->channel[WRITE].cdev == cdev)
+ 		p_ch = &privptr->channel[WRITE];
+ 	else {
+-		printk(KERN_WARNING "claw: Can't determine channel for "
+-			"interrupt, device %s\n", cdev->dev.bus_id);
++		dev_warn(&cdev->dev, "Can't determine channel for "
++			"interrupt\n");
+ 		CLAW_DBF_TEXT(2, trace, "badchan");
+ 		return;
+ 	}
+@@ -612,7 +614,8 @@ claw_irq_handler(struct ccw_device *cdev
+ 
+ 	/* Check for good subchannel return code, otherwise info message */
+ 	if (irb->scsw.cmd.cstat && !(irb->scsw.cmd.cstat & SCHN_STAT_PCI)) {
+-                printk(KERN_INFO "%s: subchannel check for device: %04x -"
++		dev_info(&cdev->dev,
++			"%s: subchannel check for device: %04x -"
+ 			" Sch Stat %02x  Dev Stat %02x CPA - %04x\n",
+                         dev->name, p_ch->devno,
+ 			irb->scsw.cmd.cstat, irb->scsw.cmd.dstat,
+@@ -651,7 +654,7 @@ claw_irq_handler(struct ccw_device *cdev
+ 			wake_up(&p_ch->wait); /* wake claw_open (READ)*/
+ 		} else if (p_ch->flag == CLAW_WRITE) {
+ 			p_ch->claw_state = CLAW_START_WRITE;
+-			/*	send SYSTEM_VALIDATE			*/
++			/*      send SYSTEM_VALIDATE                    */
+ 			claw_strt_read(dev, LOCK_NO);
+ 			claw_send_control(dev,
+ 				SYSTEM_VALIDATE_REQUEST,
+@@ -659,10 +662,9 @@ claw_irq_handler(struct ccw_device *cdev
+ 				p_env->host_name,
+ 				p_env->adapter_name);
+ 		} else {
+-			printk(KERN_WARNING "claw: unsolicited "
+-				"interrupt for device:"
+-				"%s received c-%02x d-%02x\n",
+-				cdev->dev.bus_id,
++			dev_warn(&cdev->dev, "unsolicited "
++				"interrupt for device "
++				"received c-%02x d-%02x\n",
+ 				irb->scsw.cmd.cstat,
+ 				irb->scsw.cmd.dstat);
+ 			return;
+@@ -677,8 +679,8 @@ claw_irq_handler(struct ccw_device *cdev
+ 			    (p_ch->irb->ecw[0] & 0x40) == 0x40 ||
+ 			    (p_ch->irb->ecw[0])        == 0) {
+ 				privptr->stats.rx_errors++;
+-				printk(KERN_INFO "%s: Restart is "
+-					"required after remote "
++				dev_info(&cdev->dev,
++					"%s: Restart is required after remote "
+ 					"side recovers \n",
+ 					dev->name);
+ 			}
+@@ -713,11 +715,13 @@ claw_irq_handler(struct ccw_device *cdev
+ 		return;
+ 	case CLAW_START_WRITE:
+ 		if (p_ch->irb->scsw.cmd.dstat & DEV_STAT_UNIT_CHECK) {
+-			printk(KERN_INFO "%s: Unit Check Occured in "
++			dev_info(&cdev->dev,
++				"%s: Unit Check Occured in "
+ 				"write channel\n", dev->name);
+ 			clear_bit(0, (void *)&p_ch->IO_active);
+ 			if (p_ch->irb->ecw[0] & 0x80) {
+-				printk(KERN_INFO "%s: Resetting Event "
++				dev_info(&cdev->dev,
++					"%s: Resetting Event "
+ 					"occurred:\n", dev->name);
+ 				init_timer(&p_ch->timer);
+ 				p_ch->timer.function =
+@@ -725,7 +729,8 @@ claw_irq_handler(struct ccw_device *cdev
+ 				p_ch->timer.data = (unsigned long)p_ch;
+ 				p_ch->timer.expires = jiffies + 10*HZ;
+ 				add_timer(&p_ch->timer);
+-				printk(KERN_INFO "%s: write connection "
++				dev_info(&cdev->dev,
++					"%s: write connection "
+ 					"restarting\n", dev->name);
+ 			}
+ 			CLAW_DBF_TEXT(4, trace, "rstrtwrt");
+@@ -733,9 +738,10 @@ claw_irq_handler(struct ccw_device *cdev
+ 		}
+ 		if (p_ch->irb->scsw.cmd.dstat & DEV_STAT_UNIT_EXCEP) {
+ 			clear_bit(0, (void *)&p_ch->IO_active);
+-			printk(KERN_INFO "%s: Unit Exception "
+-			       "Occured in write channel\n",
+-			       dev->name);
++			dev_info(&cdev->dev,
++				"%s: Unit Exception "
++				"occurred in write channel\n",
++				dev->name);
+ 		}
+ 		if (!((p_ch->irb->scsw.cmd.stctl & SCSW_STCTL_SEC_STATUS) ||
+ 		(p_ch->irb->scsw.cmd.stctl == SCSW_STCTL_STATUS_PEND) ||
+@@ -757,7 +763,8 @@ claw_irq_handler(struct ccw_device *cdev
+ 		CLAW_DBF_TEXT(4, trace, "StWtExit");
+ 		return;
+ 	default:
+-		printk(KERN_WARNING "%s: wrong selection code - irq "
++		dev_warn(&cdev->dev,
++			"%s: wrong selection code - irq "
+ 			"state=%d\n", dev->name, p_ch->claw_state);
+ 		CLAW_DBF_TEXT(2, trace, "badIRQ");
+ 		return;
+@@ -910,7 +917,8 @@ claw_release(struct net_device *dev)
+         if (((privptr->channel[READ].last_dstat |
+ 		privptr->channel[WRITE].last_dstat) &
+ 		~(DEV_STAT_CHN_END | DEV_STAT_DEV_END)) != 0x00) {
+-                printk(KERN_WARNING "%s: channel problems during close - "
++		dev_warn(&privptr->channel[READ].cdev->dev,
++			"%s: channel problems during close - "
+ 			"read: %02x -  write: %02x\n",
+                 dev->name,
+ 		privptr->channel[READ].last_dstat,
+@@ -1135,20 +1143,19 @@ ccw_check_return_code(struct ccw_device 
+ 		case -EBUSY: /* BUSY is a transient state no action needed */
+ 			break;
+ 		case -ENODEV:
+-			printk(KERN_EMERG "%s: Missing device called "
+-				"for IO ENODEV\n", cdev->dev.bus_id);
++			dev_err(&cdev->dev, "Device not found "
++				"for IO ENODEV\n");
+ 			break;
+ 		case -EIO:
+-			printk(KERN_EMERG "%s: Status pending... EIO \n",
+-				cdev->dev.bus_id);
++			dev_err(&cdev->dev, "Status pending... EIO \n");
+ 			break;
+ 		case -EINVAL:
+-			printk(KERN_EMERG "%s: Invalid Dev State EINVAL \n",
+-				cdev->dev.bus_id);
++			dev_err(&cdev->dev,
++				"Invalid Dev State EINVAL \n");
+ 			break;
+ 		default:
+-			printk(KERN_EMERG "%s: Unknown error in "
+-				 "Do_IO %d\n",cdev->dev.bus_id, return_code);
++			dev_err(&cdev->dev, "Unknown error in "
++				 "Do_IO %d\n", return_code);
+ 		}
+ 	}
+ 	CLAW_DBF_TEXT(4, trace, "ccwret");
+@@ -1162,39 +1169,40 @@ static void
+ ccw_check_unit_check(struct chbk * p_ch, unsigned char sense )
+ {
+ 	struct net_device *ndev = p_ch->ndev;
++	struct device *dev = &p_ch->cdev->dev;
+ 
+ 	CLAW_DBF_TEXT(4, trace, "unitchek");
+-        printk(KERN_INFO "%s: Unit Check with sense byte:0x%04x\n",
+-	       ndev->name, sense);
++	dev_info(dev, "%s: Unit Check with sense byte:0x%04x\n",
++		ndev->name, sense);
+ 
+         if (sense & 0x40) {
+                 if (sense & 0x01) {
+-                        printk(KERN_WARNING "%s: Interface disconnect or "
++			dev_warn(dev, "%s: Interface disconnect or "
+ 				"Selective reset "
+ 				"occurred (remote side)\n", ndev->name);
+                 }
+                 else {
+-                        printk(KERN_WARNING "%s: System reset occured"
++			dev_warn(dev, "%s: System reset occurred"
+ 				" (remote side)\n", ndev->name);
+                 }
+         }
+         else if (sense & 0x20) {
+                 if (sense & 0x04) {
+-                        printk(KERN_WARNING "%s: Data-streaming "
++			dev_warn(dev, "%s: Data-streaming "
+ 				"timeout)\n", ndev->name);
+                 }
+                 else  {
+-                        printk(KERN_WARNING "%s: Data-transfer parity"
++			dev_warn(dev, "%s: Data-transfer parity"
+ 				" error\n", ndev->name);
+                 }
+         }
+         else if (sense & 0x10) {
+                 if (sense & 0x20) {
+-                        printk(KERN_WARNING "%s: Hardware malfunction "
++			dev_warn(dev, "%s: Hardware malfunction "
+ 				"(remote side)\n", ndev->name);
+                 }
+                 else {
+-                        printk(KERN_WARNING "%s: read-data parity error "
++			dev_warn(dev, "%s: read-data parity error "
+ 				"(remote side)\n", ndev->name);
+                 }
+         }
+@@ -2002,7 +2010,7 @@ claw_process_control( struct net_device 
+ 	tdev = &privptr->channel[READ].cdev->dev;
+ 	memcpy( &temp_host_name, p_env->host_name, 8);
+         memcpy( &temp_ws_name, p_env->adapter_name , 8);
+-        printk(KERN_INFO "%s: CLAW device %.8s: "
++	dev_info(tdev, "%s: CLAW device %.8s: "
+ 		"Received Control Packet\n",
+ 		dev->name, temp_ws_name);
+         if (privptr->release_pend==1) {
+@@ -2021,30 +2029,28 @@ claw_process_control( struct net_device 
+ 		if (p_ctlbk->version != CLAW_VERSION_ID) {
+ 			claw_snd_sys_validate_rsp(dev, p_ctlbk,
+ 				CLAW_RC_WRONG_VERSION);
+-			printk("%s: %d is wrong version id. "
+-			       "Expected %d\n",
+-			       dev->name, p_ctlbk->version,
+-			       CLAW_VERSION_ID);
++			dev_info(tdev, "%s: %d is wrong version id. "
++				"Expected %d\n", dev->name, p_ctlbk->version,
++				CLAW_VERSION_ID);
+ 		}
+ 		p_sysval = (struct sysval *)&(p_ctlbk->data);
+-		printk("%s: Recv Sys Validate Request: "
+-		       "Vers=%d,link_id=%d,Corr=%d,WS name=%."
+-		       "8s,Host name=%.8s\n",
+-		       dev->name, p_ctlbk->version,
+-		       p_ctlbk->linkid,
+-		       p_ctlbk->correlator,
+-		       p_sysval->WS_name,
+-		       p_sysval->host_name);
++		dev_info(tdev, "%s: Recv Sys Validate Request: "
++			"Vers=%d,link_id=%d,Corr=%d,WS name=%.8s,"
++			"Host name=%.8s\n",
++			dev->name, p_ctlbk->version,
++			p_ctlbk->linkid,
++			p_ctlbk->correlator,
++			p_sysval->WS_name,
++			p_sysval->host_name);
+ 		if (memcmp(temp_host_name, p_sysval->host_name, 8)) {
+ 			claw_snd_sys_validate_rsp(dev, p_ctlbk,
+ 				CLAW_RC_NAME_MISMATCH);
+ 			CLAW_DBF_TEXT(2, setup, "HSTBAD");
+ 			CLAW_DBF_TEXT_(2, setup, "%s", p_sysval->host_name);
+ 			CLAW_DBF_TEXT_(2, setup, "%s", temp_host_name);
+-			printk(KERN_INFO "%s:  Host name mismatch\n",
+-				dev->name);
+-			printk(KERN_INFO "%s: Received :%s: "
+-				"expected :%s: \n",
++			dev_info(tdev,
++				"%s: Host name mismatch. Received: %s "
++					"expected: %s\n",
+ 				dev->name,
+ 				p_sysval->host_name,
+ 				temp_host_name);
+@@ -2055,35 +2061,36 @@ claw_process_control( struct net_device 
+ 			CLAW_DBF_TEXT(2, setup, "WSNBAD");
+ 			CLAW_DBF_TEXT_(2, setup, "%s", p_sysval->WS_name);
+ 			CLAW_DBF_TEXT_(2, setup, "%s", temp_ws_name);
+-			printk(KERN_INFO "%s: WS name mismatch\n",
+-				dev->name);
+-			printk(KERN_INFO "%s: Received :%s: "
+-			       "expected :%s: \n",
+-			       dev->name,
+-			       p_sysval->WS_name,
+-			       temp_ws_name);
++			dev_info(tdev, "%s: WS name mismatch."
++				" Received: %s expected: %s\n",
++				dev->name,
++				p_sysval->WS_name,
++				temp_ws_name);
+ 		}
+ 		if ((p_sysval->write_frame_size < p_env->write_size) &&
+ 		    (p_env->packing == 0)) {
+ 			claw_snd_sys_validate_rsp(dev, p_ctlbk,
+ 				CLAW_RC_HOST_RCV_TOO_SMALL);
+-			printk(KERN_INFO "%s: host write size is too "
+-				"small\n", dev->name);
++			dev_info(tdev,
++				"host write size is too small\n");
+ 			CLAW_DBF_TEXT(2, setup, "wrtszbad");
+ 		}
+ 		if ((p_sysval->read_frame_size < p_env->read_size) &&
+ 		    (p_env->packing == 0)) {
+ 			claw_snd_sys_validate_rsp(dev, p_ctlbk,
+ 				CLAW_RC_HOST_RCV_TOO_SMALL);
+-			printk(KERN_INFO "%s: host read size is too "
+-				"small\n", dev->name);
++			dev_info(tdev,
++				"host read size is too small\n");
+ 			CLAW_DBF_TEXT(2, setup, "rdsizbad");
+ 		}
+ 		claw_snd_sys_validate_rsp(dev, p_ctlbk, 0);
+-		printk(KERN_INFO "%s: CLAW device %.8s: System validate "
+-			"completed.\n", dev->name, temp_ws_name);
+-		printk("%s: sys Validate Rsize:%d Wsize:%d\n", dev->name,
+-			p_sysval->read_frame_size, p_sysval->write_frame_size);
++		dev_info(tdev,
++			"CLAW device %.8s: System validate"
++			" completed.\n", temp_ws_name);
++		dev_info(tdev,
++			"%s: sys Validate Rsize:%d Wsize:%d\n",
++			dev->name, p_sysval->read_frame_size,
++			p_sysval->write_frame_size);
+ 		privptr->system_validate_comp = 1;
+ 		if (strncmp(p_env->api_type, WS_APPL_NAME_PACKED, 6) == 0)
+ 			p_env->packing = PACKING_ASK;
+@@ -2091,8 +2098,9 @@ claw_process_control( struct net_device 
+ 		break;
+ 	case SYSTEM_VALIDATE_RESPONSE:
+ 		p_sysval = (struct sysval *)&(p_ctlbk->data);
+-		printk("%s: Recv Sys Validate Resp: Vers=%d,Corr=%d,RC=%d,"
+-			"WS name=%.8s,Host name=%.8s\n",
++		dev_info(tdev,
++			"%s: Recv Sys Validate Resp: Vers=%d,Corr=%d,"
++			"RC=%d,WS name=%.8s,Host name=%.8s\n",
+ 			dev->name,
+ 			p_ctlbk->version,
+ 			p_ctlbk->correlator,
+@@ -2101,32 +2109,31 @@ claw_process_control( struct net_device 
+ 			p_sysval->host_name);
+ 		switch (p_ctlbk->rc) {
+ 		case 0:
+-			printk(KERN_INFO "%s: CLAW device "
+-				"%.8s: System validate "
+-				"completed.\n",
+-			       dev->name, temp_ws_name);
++			dev_info(tdev, "%s: CLAW device "
++				"%.8s: System validate completed.\n",
++				dev->name, temp_ws_name);
+ 			if (privptr->system_validate_comp == 0)
+ 				claw_strt_conn_req(dev);
+ 			privptr->system_validate_comp = 1;
+ 			break;
+ 		case CLAW_RC_NAME_MISMATCH:
+-			printk(KERN_INFO "%s: Sys Validate "
++			dev_info(tdev, "%s: Sys Validate "
+ 				"Resp : Host, WS name is "
+ 				"mismatch\n",
+-			       dev->name);
++				dev->name);
+ 			break;
+ 		case CLAW_RC_WRONG_VERSION:
+-			printk(KERN_INFO "%s: Sys Validate "
++			dev_info(tdev, "%s: Sys Validate "
+ 				"Resp : Wrong version\n",
+ 				dev->name);
+ 			break;
+ 		case CLAW_RC_HOST_RCV_TOO_SMALL:
+-			printk(KERN_INFO "%s: Sys Validate "
++			dev_info(tdev, "%s: Sys Validate "
+ 				"Resp : bad frame size\n",
+ 				dev->name);
+ 			break;
+ 		default:
+-			printk(KERN_INFO "%s: Sys Validate "
++			dev_info(tdev, "%s: Sys Validate "
+ 				"error code=%d \n",
+ 				 dev->name, p_ctlbk->rc);
+ 			break;
+@@ -2135,7 +2142,7 @@ claw_process_control( struct net_device 
+ 
+ 	case CONNECTION_REQUEST:
+ 		p_connect = (struct conncmd *)&(p_ctlbk->data);
+-		printk(KERN_INFO "%s: Recv Conn Req: Vers=%d,link_id=%d,"
++		dev_info(tdev, "%s: Recv Conn Req: Vers=%d,link_id=%d,"
+ 			"Corr=%d,HOST appl=%.8s,WS appl=%.8s\n",
+ 			dev->name,
+ 			p_ctlbk->version,
+@@ -2145,20 +2152,20 @@ claw_process_control( struct net_device 
+ 			p_connect->WS_name);
+ 		if (privptr->active_link_ID != 0) {
+ 			claw_snd_disc(dev, p_ctlbk);
+-			printk(KERN_INFO "%s: Conn Req error : "
++			dev_info(tdev, "%s: Conn Req error : "
+ 				"already logical link is active \n",
+ 				dev->name);
+ 		}
+ 		if (p_ctlbk->linkid != 1) {
+ 			claw_snd_disc(dev, p_ctlbk);
+-			printk(KERN_INFO "%s: Conn Req error : "
++			dev_info(tdev, "%s: Conn Req error : "
+ 				"req logical link id is not 1\n",
+ 				dev->name);
+ 		}
+ 		rc = find_link(dev, p_connect->host_name, p_connect->WS_name);
+ 		if (rc != 0) {
+ 			claw_snd_disc(dev, p_ctlbk);
+-			printk(KERN_INFO "%s: Conn Resp error: "
++			dev_info(tdev, "%s: Conn Req error : "
+ 				"req appl name does not match\n",
+ 				dev->name);
+ 		}
+@@ -2171,7 +2178,7 @@ claw_process_control( struct net_device 
+ 			p_env->packing = PACK_SEND;
+ 			claw_snd_conn_req(dev, 0);
+ 		}
+-		printk(KERN_INFO "%s: CLAW device %.8s: Connection "
++		dev_info(tdev, "%s: CLAW device %.8s: Connection "
+ 			"completed link_id=%d.\n",
+ 			dev->name, temp_ws_name,
+ 			p_ctlbk->linkid);
+@@ -2181,7 +2188,7 @@ claw_process_control( struct net_device 
+ 		break;
+ 	case CONNECTION_RESPONSE:
+ 		p_connect = (struct conncmd *)&(p_ctlbk->data);
+-		printk(KERN_INFO "%s: Revc Conn Resp: Vers=%d,link_id=%d,"
++		dev_info(tdev, "%s: Revc Conn Resp: Vers=%d,link_id=%d,"
+ 			"Corr=%d,RC=%d,Host appl=%.8s, WS appl=%.8s\n",
+ 			dev->name,
+ 			p_ctlbk->version,
+@@ -2192,7 +2199,7 @@ claw_process_control( struct net_device 
+ 			p_connect->WS_name);
+ 
+ 		if (p_ctlbk->rc != 0) {
+-			printk(KERN_INFO "%s: Conn Resp error: rc=%d \n",
++			dev_info(tdev, "%s: Conn Resp error: rc=%d \n",
+ 				dev->name, p_ctlbk->rc);
+ 			return 1;
+ 		}
+@@ -2200,7 +2207,7 @@ claw_process_control( struct net_device 
+ 			p_connect->host_name, p_connect->WS_name);
+ 		if (rc != 0) {
+ 			claw_snd_disc(dev, p_ctlbk);
+-			printk(KERN_INFO "%s: Conn Resp error: "
++			dev_info(tdev, "%s: Conn Resp error: "
+ 				"req appl name does not match\n",
+ 				 dev->name);
+ 		}
+@@ -2209,7 +2216,8 @@ claw_process_control( struct net_device 
+ 		break;
+ 	case CONNECTION_CONFIRM:
+ 		p_connect = (struct conncmd *)&(p_ctlbk->data);
+-		printk(KERN_INFO "%s: Recv Conn Confirm:Vers=%d,link_id=%d,"
++		dev_info(tdev,
++			"%s: Recv Conn Confirm:Vers=%d,link_id=%d,"
+ 			"Corr=%d,Host appl=%.8s,WS appl=%.8s\n",
+ 			dev->name,
+ 			p_ctlbk->version,
+@@ -2220,21 +2228,21 @@ claw_process_control( struct net_device 
+ 		if (p_ctlbk->linkid == -(privptr->active_link_ID)) {
+ 			privptr->active_link_ID = p_ctlbk->linkid;
+ 			if (p_env->packing > PACKING_ASK) {
+-				printk(KERN_INFO "%s: Confirmed Now packing\n",
+-					dev->name);
++				dev_info(tdev,
++				"%s: Confirmed Now packing\n", dev->name);
+ 				p_env->packing = DO_PACKED;
+ 			}
+ 			p_ch = &privptr->channel[WRITE];
+ 			wake_up(&p_ch->wait);
+ 		} else {
+-		       printk(KERN_INFO "%s: Conn confirm: "
++			dev_info(tdev, "%s: Conn confirm: "
+ 				"unexpected linkid=%d \n",
+ 				dev->name, p_ctlbk->linkid);
+ 			claw_snd_disc(dev, p_ctlbk);
+ 		}
+ 		break;
+ 	case DISCONNECT:
+-		printk(KERN_INFO "%s: Disconnect: "
++		dev_info(tdev, "%s: Disconnect: "
+ 			"Vers=%d,link_id=%d,Corr=%d\n",
+ 			dev->name, p_ctlbk->version,
+ 			p_ctlbk->linkid, p_ctlbk->correlator);
+@@ -2246,11 +2254,11 @@ claw_process_control( struct net_device 
+ 			privptr->active_link_ID = 0;
+ 		break;
+ 	case CLAW_ERROR:
+-		printk(KERN_INFO "%s: CLAW ERROR detected\n",
++		dev_info(tdev, "%s: CLAW ERROR detected\n",
+ 			dev->name);
+ 		break;
+ 	default:
+-		printk(KERN_INFO "%s:  Unexpected command code=%d \n",
++		dev_info(tdev, "%s: Unexpected command code=%d \n",
+ 			dev->name,  p_ctlbk->command);
+ 		break;
+         }
+@@ -2510,7 +2518,8 @@ unpack_read(struct net_device *dev )
+                         mtc_this_frm=1;
+                         if (p_this_ccw->header.length!=
+ 				privptr->p_env->read_size ) {
+-                                printk(KERN_INFO " %s: Invalid frame detected "
++				dev_info(p_dev,
++					"%s: Invalid frame detected "
+ 					"length is %02x\n" ,
+                                         dev->name, p_this_ccw->header.length);
+                         }
+@@ -2594,8 +2603,8 @@ unpack_next:
+                         }
+                         else {
+                                 privptr->stats.rx_dropped++;
+-                                printk(KERN_WARNING "%s: %s() low on memory\n",
+-				dev->name,__func__);
++				dev_warn(p_dev,
++					"buffer allocate failed on receive\n");
+                         }
+                         privptr->mtc_offset=0;
+                         privptr->mtc_logical_link=-1;
+@@ -2879,7 +2888,8 @@ claw_new_device(struct ccwgroup_device *
+ 	int ret;
+ 	struct ccw_dev_id dev_id;
+ 
+-	printk(KERN_INFO "claw: add for %s\n",cgdev->cdev[READ]->dev.bus_id);
++	dev_info(&cgdev->dev, "add for %s\n",
++		 dev_name(&cgdev->cdev[READ]->dev));
+ 	CLAW_DBF_TEXT(2, setup, "new_dev");
+ 	privptr = cgdev->dev.driver_data;
+ 	cgdev->cdev[READ]->dev.driver_data = privptr;
+@@ -2895,27 +2905,28 @@ claw_new_device(struct ccwgroup_device *
+ 	if (ret == 0)
+ 		ret = add_channel(cgdev->cdev[1],1,privptr);
+ 	if (ret != 0) {
+-		printk(KERN_WARNING
+-			"add channel failed with ret = %d\n", ret);
++		dev_warn(&cgdev->dev, "add channel failed "
++			"with ret = %d\n", ret);
+ 		goto out;
+ 	}
+ 	ret = ccw_device_set_online(cgdev->cdev[READ]);
+ 	if (ret != 0) {
+-		printk(KERN_WARNING
+-			"claw: ccw_device_set_online %s READ failed "
+-			"with ret = %d\n",cgdev->cdev[READ]->dev.bus_id,ret);
++		dev_warn(&cgdev->dev,
++			"device set online READ failed "
++			"with ret = %d\n", ret);
+ 		goto out;
+ 	}
+ 	ret = ccw_device_set_online(cgdev->cdev[WRITE]);
+ 	if (ret != 0) {
+-		printk(KERN_WARNING
+-			"claw: ccw_device_set_online %s WRITE failed "
+-			"with ret = %d\n",cgdev->cdev[WRITE]->dev.bus_id, ret);
++		dev_warn(&cgdev->dev,
++			"device set online WRITE failed "
++			"with ret = %d\n", ret);
+ 		goto out;
+ 	}
+ 	dev = alloc_netdev(0,"claw%d",claw_init_netdevice);
+ 	if (!dev) {
+-		printk(KERN_WARNING "%s:alloc_netdev failed\n",__func__);
++		dev_warn(&cgdev->dev,
++			"failed creating network device\n");
+ 		goto out;
+ 	}
+ 	dev->ml_priv = privptr;
+@@ -2943,13 +2954,13 @@ claw_new_device(struct ccwgroup_device *
+ 	privptr->channel[WRITE].ndev = dev;
+ 	privptr->p_env->ndev = dev;
+ 
+-	printk(KERN_INFO "%s:readsize=%d  writesize=%d "
++	dev_info(&cgdev->dev, "%s:readsize=%d  writesize=%d "
+ 		"readbuffer=%d writebuffer=%d read=0x%04x write=0x%04x\n",
+                 dev->name, p_env->read_size,
+ 		p_env->write_size, p_env->read_buffers,
+                 p_env->write_buffers, p_env->devno[READ],
+ 		p_env->devno[WRITE]);
+-        printk(KERN_INFO "%s:host_name:%.8s, adapter_name "
++	dev_info(&cgdev->dev, "%s:host_name:%.8s, adapter_name "
+ 		":%.8s api_type: %.8s\n",
+                 dev->name, p_env->host_name,
+ 		p_env->adapter_name , p_env->api_type);
+@@ -2993,8 +3004,8 @@ claw_shutdown_device(struct ccwgroup_dev
+ 	ndev = priv->channel[READ].ndev;
+ 	if (ndev) {
+ 		/* Close the device */
+-		printk(KERN_INFO
+-			"%s: shuting down \n",ndev->name);
++		dev_info(&cgdev->dev, "%s: shutting down \n",
++			ndev->name);
+ 		if (ndev->flags & IFF_RUNNING)
+ 			ret = claw_release(ndev);
+ 		ndev->flags &=~IFF_RUNNING;
+@@ -3019,8 +3030,7 @@ claw_remove_device(struct ccwgroup_devic
+ 	CLAW_DBF_TEXT_(2, setup, "%s", cgdev->dev.bus_id);
+ 	priv = cgdev->dev.driver_data;
+ 	BUG_ON(!priv);
+-	printk(KERN_INFO "claw: %s() called %s will be removed.\n",
+-			__func__,cgdev->cdev[0]->dev.bus_id);
++	dev_info(&cgdev->dev, " will be removed.\n");
+ 	if (cgdev->state == CCWGROUP_ONLINE)
+ 		claw_shutdown_device(cgdev);
+ 	claw_remove_files(&cgdev->dev);
+@@ -3285,7 +3295,7 @@ claw_cleanup(void)
+ {
+ 	unregister_cu3088_discipline(&claw_group_driver);
+ 	claw_unregister_debug_facility();
+-	printk(KERN_INFO "claw: Driver unloaded\n");
++	pr_info("Driver unloaded\n");
+ 
+ }
+ 
+@@ -3299,12 +3309,11 @@ static int __init
+ claw_init(void)
+ {
+ 	int ret = 0;
+-	printk(KERN_INFO "claw: starting driver\n");
+ 
++	pr_info("Loading %s\n", version);
+ 	ret = claw_register_debug_facility();
+ 	if (ret) {
+-		printk(KERN_WARNING "claw: %s() debug_register failed %d\n",
+-			__func__,ret);
++		pr_warning("debug_register failed %d\n", ret);
+ 		return ret;
+ 	}
+ 	CLAW_DBF_TEXT(2, setup, "init_mod");
+@@ -3312,8 +3321,7 @@ claw_init(void)
+ 	if (ret) {
+ 		CLAW_DBF_TEXT(2, setup, "init_bad");
+ 		claw_unregister_debug_facility();
+-		printk(KERN_WARNING "claw; %s() cu3088 register failed %d\n",
+-			__func__,ret);
++		pr_warning("register_cu3088_discipline() failed rc=%d\n", ret);
+ 	}
+ 	return ret;
+ }
+Index: linux-2.6.27-gentoo-r7/drivers/s390/net/ctcm_fsms.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/net/ctcm_fsms.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/net/ctcm_fsms.c
+@@ -13,6 +13,9 @@
+ #undef DEBUGDATA
+ #undef DEBUGCCW
+ 
++#define KMSG_COMPONENT "ctcm"
++#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
++
+ #include <linux/module.h>
+ #include <linux/init.h>
+ #include <linux/kernel.h>
+@@ -190,21 +193,22 @@ static void ctcmpc_chx_send_sweep(fsm_in
+ void ctcm_ccw_check_rc(struct channel *ch, int rc, char *msg)
+ {
+ 	CTCM_DBF_TEXT_(ERROR, CTC_DBF_ERROR,
+-			"%s(%s): %s: %04x\n",
+-				CTCM_FUNTAIL, ch->id, msg, rc);
++		"%s(%s): %s: %04x\n",
++		CTCM_FUNTAIL, ch->id, msg, rc);
+ 	switch (rc) {
+ 	case -EBUSY:
+-		ctcm_pr_warn("%s (%s): Busy !\n", ch->id, msg);
++		pr_info("%s: The communication peer is busy\n",
++			ch->id);
+ 		fsm_event(ch->fsm, CTC_EVENT_IO_EBUSY, ch);
+ 		break;
+ 	case -ENODEV:
+-		ctcm_pr_emerg("%s (%s): Invalid device called for IO\n",
+-			     ch->id, msg);
++		pr_err("%s: The specified target device is not valid\n",
++		       ch->id);
+ 		fsm_event(ch->fsm, CTC_EVENT_IO_ENODEV, ch);
+ 		break;
+ 	default:
+-		ctcm_pr_emerg("%s (%s): Unknown error in do_IO %04x\n",
+-			     ch->id, msg, rc);
++		pr_err("An I/O operation resulted in error %04x\n",
++		       rc);
+ 		fsm_event(ch->fsm, CTC_EVENT_IO_UNKNOWN, ch);
+ 	}
+ }
+@@ -886,8 +890,15 @@ static void ctcm_chx_rxiniterr(fsm_insta
+ 			fsm_newstate(fi, CTC_STATE_RXERR);
+ 			fsm_event(priv->fsm, DEV_EVENT_RXDOWN, dev);
+ 		}
+-	} else
+-		ctcm_pr_warn("%s: Error during RX init handshake\n", dev->name);
++	} else {
++		CTCM_DBF_TEXT_(ERROR, CTC_DBF_ERROR,
++			"%s(%s): %s in %s", CTCM_FUNTAIL, ch->id,
++			ctc_ch_event_names[event], fsm_getstate_str(fi));
++
++		dev_warn(&dev->dev,
++			"Initialization failed with RX/TX init handshake "
++			"error %s\n", ctc_ch_event_names[event]);
++	}
+ }
+ 
+ /**
+@@ -969,7 +980,9 @@ static void ctcm_chx_txiniterr(fsm_insta
+ 			"%s(%s): %s in %s", CTCM_FUNTAIL, ch->id,
+ 			ctc_ch_event_names[event], fsm_getstate_str(fi));
+ 
+-		ctcm_pr_warn("%s: Error during TX init handshake\n", dev->name);
++		dev_warn(&dev->dev,
++			"Initialization failed with RX/TX init handshake "
++			"error %s\n", ctc_ch_event_names[event]);
+ 	}
+ }
+ 
+@@ -2101,14 +2114,11 @@ static void dev_action_restart(fsm_insta
+ 	CTCMY_DBF_DEV_NAME(TRACE, dev, "");
+ 
+ 	if (IS_MPC(priv)) {
+-		ctcm_pr_info("ctcm: %s Restarting Device and "
+-		       "MPC Group in 5 seconds\n",
+-		       dev->name);
+ 		restart_timer = CTCM_TIME_1_SEC;
+ 	} else {
+-		ctcm_pr_info("%s: Restarting\n", dev->name);
+ 		restart_timer = CTCM_TIME_5_SEC;
+ 	}
++	dev_info(&dev->dev, "Restarting device\n");
+ 
+ 	dev_action_stop(fi, event, arg);
+ 	fsm_event(priv->fsm, DEV_EVENT_STOP, dev);
+@@ -2150,16 +2160,16 @@ static void dev_action_chup(fsm_instance
+ 	case DEV_STATE_STARTWAIT_RX:
+ 		if (event == DEV_EVENT_RXUP) {
+ 			fsm_newstate(fi, DEV_STATE_RUNNING);
+-			ctcm_pr_info("%s: connected with remote side\n",
+-				    dev->name);
++			dev_info(&dev->dev,
++				"Connected with remote side\n");
+ 			ctcm_clear_busy(dev);
+ 		}
+ 		break;
+ 	case DEV_STATE_STARTWAIT_TX:
+ 		if (event == DEV_EVENT_TXUP) {
+ 			fsm_newstate(fi, DEV_STATE_RUNNING);
+-			ctcm_pr_info("%s: connected with remote side\n",
+-				    dev->name);
++			dev_info(&dev->dev,
++				"Connected with remote side\n");
+ 			ctcm_clear_busy(dev);
+ 		}
+ 		break;
+Index: linux-2.6.27-gentoo-r7/drivers/s390/net/ctcm_main.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/net/ctcm_main.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/net/ctcm_main.c
+@@ -21,6 +21,9 @@
+ #undef DEBUGDATA
+ #undef DEBUGCCW
+ 
++#define KMSG_COMPONENT "ctcm"
++#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
++
+ #include <linux/module.h>
+ #include <linux/init.h>
+ #include <linux/kernel.h>
+@@ -281,14 +284,16 @@ static long ctcm_check_irb_error(struct 
+ 
+ 	switch (PTR_ERR(irb)) {
+ 	case -EIO:
+-		ctcm_pr_warn("i/o-error on device %s\n", cdev->dev.bus_id);
++		dev_err(&cdev->dev,
++			"An I/O-error occurred on the CTCM device\n");
+ 		break;
+ 	case -ETIMEDOUT:
+-		ctcm_pr_warn("timeout on device %s\n", cdev->dev.bus_id);
++		dev_err(&cdev->dev,
++			"An adapter hardware operation timed out\n");
+ 		break;
+ 	default:
+-		ctcm_pr_warn("unknown error %ld on device %s\n",
+-				PTR_ERR(irb), cdev->dev.bus_id);
++		dev_err(&cdev->dev,
++			"An error occurred on the adapter hardware\n");
+ 	}
+ 	return PTR_ERR(irb);
+ }
+@@ -309,15 +314,17 @@ static inline void ccw_unit_check(struct
+ 	if (sense & SNS0_INTERVENTION_REQ) {
+ 		if (sense & 0x01) {
+ 			if (ch->sense_rc != 0x01) {
+-				ctcm_pr_debug("%s: Interface disc. or Sel. "
+-					      "reset (remote)\n", ch->id);
++				pr_notice(
++					"%s: The communication peer has "
++					"disconnected\n", ch->id);
+ 				ch->sense_rc = 0x01;
+ 			}
+ 			fsm_event(ch->fsm, CTC_EVENT_UC_RCRESET, ch);
+ 		} else {
+ 			if (ch->sense_rc != SNS0_INTERVENTION_REQ) {
+-				ctcm_pr_debug("%s: System reset (remote)\n",
+-					      ch->id);
++				pr_notice(
++					"%s: The remote operating system is "
++					"not available\n", ch->id);
+ 				ch->sense_rc = SNS0_INTERVENTION_REQ;
+ 			}
+ 			fsm_event(ch->fsm, CTC_EVENT_UC_RSRESET, ch);
+@@ -1194,8 +1201,11 @@ static void ctcm_irq_handler(struct ccw_
+ 
+ 	/* Check for unsolicited interrupts. */
+ 	if (cgdev == NULL) {
+-		ctcm_pr_warn("ctcm: Got unsolicited irq: c-%02x d-%02x\n",
+-			     cstat, dstat);
++		CTCM_DBF_TEXT_(TRACE, CTC_DBF_ERROR,
++			"%s(%s) unsolicited irq: c-%02x d-%02x\n",
++			CTCM_FUNTAIL, dev_name(&cdev->dev), cstat, dstat);
++		dev_warn(&cdev->dev,
++			"The adapter received a non-specific IRQ\n");
+ 		return;
+ 	}
+ 
+@@ -1207,31 +1217,34 @@ static void ctcm_irq_handler(struct ccw_
+ 	else if (priv->channel[WRITE]->cdev == cdev)
+ 		ch = priv->channel[WRITE];
+ 	else {
+-		ctcm_pr_err("ctcm: Can't determine channel for interrupt, "
+-			   "device %s\n", cdev->dev.bus_id);
++		dev_err(&cdev->dev,
++			"%s: Internal error: Can't determine channel for "
++			"interrupt device %s\n",
++			__func__, dev_name(&cdev->dev));
++			/* Explain: inconsistent internal structures */
+ 		return;
+ 	}
+ 
+ 	dev = ch->netdev;
+ 	if (dev == NULL) {
+-		ctcm_pr_crit("ctcm: %s dev=NULL bus_id=%s, ch=0x%p\n",
+-				__func__, cdev->dev.bus_id, ch);
++		dev_err(&cdev->dev,
++			"%s Internal error: net_device is NULL, ch = 0x%p\n",
++			__func__, ch);
++			/* Explain: inconsistent internal structures */
+ 		return;
+ 	}
+ 
+-	CTCM_DBF_TEXT_(TRACE, CTC_DBF_DEBUG,
+-		"%s(%s): int. for %s: cstat=%02x dstat=%02x",
+-			CTCM_FUNTAIL, dev->name, ch->id, cstat, dstat);
+-
+ 	/* Copy interruption response block. */
+ 	memcpy(ch->irb, irb, sizeof(struct irb));
+ 
++	/* Issue error message and return on subchannel error code */
+ 	if (irb->scsw.cmd.cstat) {
+-	/* Check for good subchannel return code, otherwise error message */
+ 		fsm_event(ch->fsm, CTC_EVENT_SC_UNKNOWN, ch);
+-		ctcm_pr_warn("%s: subchannel check for dev: %s - %02x %02x\n",
+-			    dev->name, ch->id, irb->scsw.cmd.cstat,
+-			    irb->scsw.cmd.dstat);
++		CTCM_DBF_TEXT_(TRACE, CTC_DBF_WARN,
++			"%s(%s): sub-ch check %s: cs=%02x ds=%02x",
++				CTCM_FUNTAIL, dev->name, ch->id, cstat, dstat);
++		dev_warn(&cdev->dev,
++				"A check occurred on the subchannel\n");
+ 		return;
+ 	}
+ 
+@@ -1239,7 +1252,7 @@ static void ctcm_irq_handler(struct ccw_
+ 	if (irb->scsw.cmd.dstat & DEV_STAT_UNIT_CHECK) {
+ 		if ((irb->ecw[0] & ch->sense_rc) == 0)
+ 			/* print it only once */
+-			CTCM_DBF_TEXT_(TRACE, CTC_DBF_INFO,
++			CTCM_DBF_TEXT_(TRACE, CTC_DBF_WARN,
+ 				"%s(%s): sense=%02x, ds=%02x",
+ 				CTCM_FUNTAIL, ch->id, irb->ecw[0], dstat);
+ 		ccw_unit_check(ch, irb->ecw[0]);
+@@ -1574,6 +1587,11 @@ static int ctcm_new_device(struct ccwgro
+ 
+ 	strlcpy(priv->fsm->name, dev->name, sizeof(priv->fsm->name));
+ 
++	dev_info(&dev->dev,
++		"setup OK : r/w = %s/%s, protocol : %d\n",
++			priv->channel[READ]->id,
++			priv->channel[WRITE]->id, priv->protocol);
++
+ 	CTCM_DBF_TEXT_(SETUP, CTC_DBF_INFO,
+ 		"setup(%s) OK : r/w = %s/%s, protocol : %d", dev->name,
+ 			priv->channel[READ]->id,
+@@ -1687,7 +1705,7 @@ static void __exit ctcm_exit(void)
+ {
+ 	unregister_cu3088_discipline(&ctcm_group_driver);
+ 	ctcm_unregister_dbf_views();
+-	ctcm_pr_info("CTCM driver unloaded\n");
++	pr_info("CTCM driver unloaded\n");
+ }
+ 
+ /*
+@@ -1695,7 +1713,7 @@ static void __exit ctcm_exit(void)
+  */
+ static void print_banner(void)
+ {
+-	printk(KERN_INFO "CTCM driver initialized\n");
++	pr_info("CTCM driver initialized\n");
+ }
+ 
+ /**
+@@ -1717,8 +1735,8 @@ static int __init ctcm_init(void)
+ 	ret = register_cu3088_discipline(&ctcm_group_driver);
+ 	if (ret) {
+ 		ctcm_unregister_dbf_views();
+-		ctcm_pr_crit("ctcm_init failed with register_cu3088_discipline "
+-				"(rc = %d)\n", ret);
++		pr_err("%s / register_cu3088_discipline failed, ret = %d\n",
++			__func__, ret);
+ 		return ret;
+ 	}
+ 	print_banner();
+Index: linux-2.6.27-gentoo-r7/drivers/s390/net/ctcm_main.h
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/net/ctcm_main.h
++++ linux-2.6.27-gentoo-r7/drivers/s390/net/ctcm_main.h
+@@ -41,12 +41,6 @@
+ #define LOG_FLAG_NOMEM		8
+ 
+ #define ctcm_pr_debug(fmt, arg...) printk(KERN_DEBUG fmt, ##arg)
+-#define ctcm_pr_info(fmt, arg...) printk(KERN_INFO fmt, ##arg)
+-#define ctcm_pr_notice(fmt, arg...) printk(KERN_NOTICE fmt, ##arg)
+-#define ctcm_pr_warn(fmt, arg...) printk(KERN_WARNING fmt, ##arg)
+-#define ctcm_pr_emerg(fmt, arg...) printk(KERN_EMERG fmt, ##arg)
+-#define ctcm_pr_err(fmt, arg...) printk(KERN_ERR fmt, ##arg)
+-#define ctcm_pr_crit(fmt, arg...) printk(KERN_CRIT fmt, ##arg)
+ 
+ #define CTCM_PR_DEBUG(fmt, arg...) \
+ 	do { \
+Index: linux-2.6.27-gentoo-r7/drivers/s390/net/ctcm_mpc.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/net/ctcm_mpc.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/net/ctcm_mpc.c
+@@ -19,6 +19,9 @@
+ #undef DEBUGDATA
+ #undef DEBUGCCW
+ 
++#define KMSG_COMPONENT "ctcm"
++#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
++
+ #include <linux/module.h>
+ #include <linux/init.h>
+ #include <linux/kernel.h>
+@@ -386,7 +389,7 @@ int ctc_mpc_alloc_channel(int port_num, 
+ 		if (grp->allocchan_callback_retries < 4) {
+ 			if (grp->allochanfunc)
+ 				grp->allochanfunc(grp->port_num,
+-					      grp->group_max_buflen);
++						  grp->group_max_buflen);
+ 		} else {
+ 			/* there are problems...bail out	    */
+ 			/* there may be a state mismatch so restart */
+@@ -1232,8 +1235,9 @@ done:
+ 
+ 	dev_kfree_skb_any(pskb);
+ 	if (sendrc == NET_RX_DROP) {
+-		printk(KERN_WARNING "%s %s() NETWORK BACKLOG EXCEEDED"
+-		       " - PACKET DROPPED\n", dev->name, __func__);
++		dev_warn(&dev->dev,
++			"The network backlog for %s is exceeded, "
++			"package dropped\n", __func__);
+ 		fsm_event(grp->fsm, MPCG_EVENT_INOP, dev);
+ 	}
+ 
+@@ -1673,7 +1677,9 @@ static int mpc_validate_xid(struct mpcg_
+ 
+ done:
+ 	if (rc) {
+-		ctcm_pr_info("ctcmpc	   :  %s() failed\n", __FUNCTION__);
++		dev_warn(&dev->dev,
++			"The XID used in the MPC protocol is not valid, "
++			"rc = %d\n", rc);
+ 		priv->xid->xid2_flag2 = 0x40;
+ 		grp->saved_xid2->xid2_flag2 = 0x40;
+ 	}
+Index: linux-2.6.27-gentoo-r7/drivers/s390/net/ctcm_sysfs.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/net/ctcm_sysfs.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/net/ctcm_sysfs.c
+@@ -10,6 +10,9 @@
+ #undef DEBUGDATA
+ #undef DEBUGCCW
+ 
++#define KMSG_COMPONENT "ctcm"
++#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
++
+ #include <linux/sysfs.h>
+ #include "ctcm_main.h"
+ 
+Index: linux-2.6.27-gentoo-r7/drivers/s390/net/lcs.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/net/lcs.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/net/lcs.c
+@@ -26,6 +26,9 @@
+  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+  */
+ 
++#define KMSG_COMPONENT		"lcs"
++#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
++
+ #include <linux/module.h>
+ #include <linux/if.h>
+ #include <linux/netdevice.h>
+@@ -54,8 +57,6 @@
+ #error Cannot compile lcs.c without some net devices switched on.
+ #endif
+ 
+-#define PRINTK_HEADER		" lcs: "
+-
+ /**
+  * initialization string for output
+  */
+@@ -96,7 +97,7 @@ lcs_register_debug_facility(void)
+ 	lcs_dbf_setup = debug_register("lcs_setup", 2, 1, 8);
+ 	lcs_dbf_trace = debug_register("lcs_trace", 4, 1, 8);
+ 	if (lcs_dbf_setup == NULL || lcs_dbf_trace == NULL) {
+-		PRINT_ERR("Not enough memory for debug facility.\n");
++		pr_err("Not enough memory for debug facility.\n");
+ 		lcs_unregister_debug_facility();
+ 		return -ENOMEM;
+ 	}
+@@ -502,7 +503,9 @@ lcs_start_channel(struct lcs_channel *ch
+ 	spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
+ 	if (rc) {
+ 		LCS_DBF_TEXT_(4,trace,"essh%s", channel->ccwdev->dev.bus_id);
+-		PRINT_ERR("Error in starting channel, rc=%d!\n", rc);
++		dev_err(&channel->ccwdev->dev,
++			"Starting an LCS device resulted in an error,"
++			" rc=%d!\n", rc);
+ 	}
+ 	return rc;
+ }
+@@ -636,7 +639,9 @@ __lcs_resume_channel(struct lcs_channel 
+ 	rc = ccw_device_resume(channel->ccwdev);
+ 	if (rc) {
+ 		LCS_DBF_TEXT_(4, trace, "ersc%s", channel->ccwdev->dev.bus_id);
+-		PRINT_ERR("Error in lcs_resume_channel: rc=%d\n",rc);
++		dev_warn(&channel->ccwdev->dev,
++			"Sending data from the LCS device to the LAN failed"
++			" with rc=%d\n",rc);
+ 	} else
+ 		channel->state = LCS_CH_STATE_RUNNING;
+ 	return rc;
+@@ -1082,7 +1087,7 @@ lcs_check_multicast_support(struct lcs_c
+ 	cmd->cmd.lcs_qipassist.num_ip_pairs = 1;
+ 	rc = lcs_send_lancmd(card, buffer, __lcs_check_multicast_cb);
+ 	if (rc != 0) {
+-		PRINT_ERR("Query IPAssist failed. Assuming unsupported!\n");
++		pr_err("Query IPAssist failed. Assuming unsupported!\n");
+ 		return -EOPNOTSUPP;
+ 	}
+ 	if (card->ip_assists_supported & LCS_IPASS_MULTICAST_SUPPORT)
+@@ -1115,8 +1120,8 @@ list_modified:
+ 			rc = lcs_send_setipm(card, ipm);
+ 			spin_lock_irqsave(&card->ipm_lock, flags);
+ 			if (rc) {
+-				PRINT_INFO("Adding multicast address failed. "
+-					   "Table possibly full!\n");
++				pr_info("Adding multicast address failed."
++					" Table possibly full!\n");
+ 				/* store ipm in failed list -> will be added
+ 				 * to ipm_list again, so a retry will be done
+ 				 * during the next call of this function */
+@@ -1227,8 +1232,8 @@ lcs_set_mc_addresses(struct lcs_card *ca
+ 		ipm = (struct lcs_ipm_list *)
+ 			kzalloc(sizeof(struct lcs_ipm_list), GFP_ATOMIC);
+ 		if (ipm == NULL) {
+-			PRINT_INFO("Not enough memory to add "
+-				   "new multicast entry!\n");
++			pr_info("Not enough memory to add"
++				" new multicast entry!\n");
+ 			break;
+ 		}
+ 		memcpy(&ipm->ipm.mac_addr, buf, LCS_MAC_LENGTH);
+@@ -1302,18 +1307,21 @@ lcs_check_irb_error(struct ccw_device *c
+ 
+ 	switch (PTR_ERR(irb)) {
+ 	case -EIO:
+-		PRINT_WARN("i/o-error on device %s\n", cdev->dev.bus_id);
++		dev_warn(&cdev->dev,
++			"An I/O-error occurred on the LCS device\n");
+ 		LCS_DBF_TEXT(2, trace, "ckirberr");
+ 		LCS_DBF_TEXT_(2, trace, "  rc%d", -EIO);
+ 		break;
+ 	case -ETIMEDOUT:
+-		PRINT_WARN("timeout on device %s\n", cdev->dev.bus_id);
++		dev_warn(&cdev->dev,
++			"A command timed out on the LCS device\n");
+ 		LCS_DBF_TEXT(2, trace, "ckirberr");
+ 		LCS_DBF_TEXT_(2, trace, "  rc%d", -ETIMEDOUT);
+ 		break;
+ 	default:
+-		PRINT_WARN("unknown error %ld on device %s\n", PTR_ERR(irb),
+-			   cdev->dev.bus_id);
++		dev_warn(&cdev->dev,
++			"An error occurred on the LCS device, rc=%ld\n",
++			PTR_ERR(irb));
+ 		LCS_DBF_TEXT(2, trace, "ckirberr");
+ 		LCS_DBF_TEXT(2, trace, "  rc???");
+ 	}
+@@ -1399,8 +1407,10 @@ lcs_irq(struct ccw_device *cdev, unsigne
+ 	/* Check for channel and device errors presented */
+ 	rc = lcs_get_problem(cdev, irb);
+ 	if (rc || (dstat & DEV_STAT_UNIT_EXCEP)) {
+-		PRINT_WARN("check on device %s, dstat=0x%X, cstat=0x%X \n",
+-			    cdev->dev.bus_id, dstat, cstat);
++		dev_warn(&cdev->dev,
++			"The LCS device stopped because of an error,"
++			" dstat=0x%X, cstat=0x%X \n",
++			    dstat, cstat);
+ 		if (rc) {
+ 			channel->state = LCS_CH_STATE_ERROR;
+ 		}
+@@ -1757,8 +1767,8 @@ lcs_get_control(struct lcs_card *card, s
+ 			lcs_schedule_recovery(card);
+ 			break;
+ 		case LCS_CMD_STOPLAN:
+-			PRINT_WARN("Stoplan for %s initiated by LGW.\n",
+-					card->dev->name);
++			pr_warning("Stoplan for %s initiated by LGW.\n",
++				   card->dev->name);
+ 			if (card->dev)
+ 				netif_carrier_off(card->dev);
+ 			break;
+@@ -1786,7 +1796,8 @@ lcs_get_skb(struct lcs_card *card, char 
+ 
+ 	skb = dev_alloc_skb(skb_len);
+ 	if (skb == NULL) {
+-		PRINT_ERR("LCS: alloc_skb failed for device=%s\n",
++		dev_err(&card->dev->dev,
++			" Allocating a socket buffer to interface %s failed\n",
+ 			  card->dev->name);
+ 		card->stats.rx_dropped++;
+ 		return;
+@@ -1882,7 +1893,8 @@ lcs_stop_device(struct net_device *dev)
+ 		(card->write.state != LCS_CH_STATE_RUNNING));
+ 	rc = lcs_stopcard(card);
+ 	if (rc)
+-		PRINT_ERR("Try it again!\n ");
++		dev_err(&card->dev->dev,
++			" Shutting down the LCS device failed\n ");
+ 	return rc;
+ }
+ 
+@@ -1901,7 +1913,7 @@ lcs_open_device(struct net_device *dev)
+ 	/* initialize statistics */
+ 	rc = lcs_detect(card);
+ 	if (rc) {
+-		PRINT_ERR("LCS:Error in opening device!\n");
++		pr_err("Error in opening device!\n");
+ 
+ 	} else {
+ 		dev->flags |= IFF_UP;
+@@ -2109,8 +2121,9 @@ lcs_new_device(struct ccwgroup_device *c
+ 	rc = lcs_detect(card);
+ 	if (rc) {
+ 		LCS_DBF_TEXT(2, setup, "dtctfail");
+-		PRINT_WARN("Detection of LCS card failed with return code "
+-			   "%d (0x%x)\n", rc, rc);
++		dev_warn(&card->dev->dev,
++			"Detecting a network adapter for LCS devices"
++			" failed with rc=%d (0x%x)\n", rc, rc);
+ 		lcs_stopcard(card);
+ 		goto out;
+ 	}
+@@ -2140,7 +2153,7 @@ lcs_new_device(struct ccwgroup_device *c
+ #endif
+ 	default:
+ 		LCS_DBF_TEXT(3, setup, "errinit");
+-		PRINT_ERR("LCS: Initialization failed\n");
++		pr_err(" Initialization failed\n");
+ 		goto out;
+ 	}
+ 	if (!dev)
+@@ -2172,13 +2185,13 @@ netdev_out:
+ 		goto out;
+ 
+ 	/* Print out supported assists: IPv6 */
+-	PRINT_INFO("LCS device %s %s IPv6 support\n", card->dev->name,
+-		   (card->ip_assists_supported & LCS_IPASS_IPV6_SUPPORT) ?
+-		   "with" : "without");
++	pr_info("LCS device %s %s IPv6 support\n", card->dev->name,
++		(card->ip_assists_supported & LCS_IPASS_IPV6_SUPPORT) ?
++		"with" : "without");
+ 	/* Print out supported assist: Multicast */
+-	PRINT_INFO("LCS device %s %s Multicast support\n", card->dev->name,
+-		   (card->ip_assists_supported & LCS_IPASS_MULTICAST_SUPPORT) ?
+-		   "with" : "without");
++	pr_info("LCS device %s %s Multicast support\n", card->dev->name,
++		(card->ip_assists_supported & LCS_IPASS_MULTICAST_SUPPORT) ?
++		"with" : "without");
+ 	return 0;
+ out:
+ 
+@@ -2244,15 +2257,16 @@ lcs_recovery(void *ptr)
+ 		return 0;
+ 	LCS_DBF_TEXT(4, trace, "recover2");
+ 	gdev = card->gdev;
+-	PRINT_WARN("Recovery of device %s started...\n", gdev->dev.bus_id);
++	dev_warn(&gdev->dev,
++		"A recovery process has been started for the LCS device\n");
+ 	rc = __lcs_shutdown_device(gdev, 1);
+ 	rc = lcs_new_device(gdev);
+ 	if (!rc)
+-		PRINT_INFO("Device %s successfully recovered!\n",
+-				card->dev->name);
++		pr_info("Device %s successfully recovered!\n",
++			card->dev->name);
+ 	else
+-		PRINT_INFO("Device %s could not be recovered!\n",
+-				card->dev->name);
++		pr_info("Device %s could not be recovered!\n",
++			card->dev->name);
+ 	lcs_clear_thread_running_bit(card, LCS_RECOVERY_THREAD);
+ 	return 0;
+ }
+@@ -2304,17 +2318,17 @@ __init lcs_init_module(void)
+ {
+ 	int rc;
+ 
+-	PRINT_INFO("Loading %s\n",version);
++	pr_info("Loading %s\n", version);
+ 	rc = lcs_register_debug_facility();
+ 	LCS_DBF_TEXT(0, setup, "lcsinit");
+ 	if (rc) {
+-		PRINT_ERR("Initialization failed\n");
++		pr_err("Initialization failed\n");
+ 		return rc;
+ 	}
+ 
+ 	rc = register_cu3088_discipline(&lcs_group_driver);
+ 	if (rc) {
+-		PRINT_ERR("Initialization failed\n");
++		pr_err("Initialization failed\n");
+ 		return rc;
+ 	}
+ 	return 0;
+@@ -2327,7 +2341,7 @@ __init lcs_init_module(void)
+ static void
+ __exit lcs_cleanup_module(void)
+ {
+-	PRINT_INFO("Terminating lcs module.\n");
++	pr_info("Terminating lcs module.\n");
+ 	LCS_DBF_TEXT(0, trace, "cleanup");
+ 	unregister_cu3088_discipline(&lcs_group_driver);
+ 	lcs_unregister_debug_facility();
+Index: linux-2.6.27-gentoo-r7/drivers/s390/net/netiucv.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/net/netiucv.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/net/netiucv.c
+@@ -31,6 +31,9 @@
+  *
+  */
+ 
++#define KMSG_COMPONENT "netiucv"
++#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
++
+ #undef DEBUG
+ 
+ #include <linux/module.h>
+@@ -846,7 +849,8 @@ static void conn_action_connsever(fsm_in
+ 
+ 	fsm_deltimer(&conn->timer);
+ 	iucv_path_sever(conn->path, NULL);
+-	PRINT_INFO("%s: Remote dropped connection\n", netdev->name);
++	dev_info(privptr->dev, "The peer interface of the IUCV device"
++		" has closed the connection\n");
+ 	IUCV_DBF_TEXT(data, 2,
+ 		      "conn_action_connsever: Remote dropped connection\n");
+ 	fsm_newstate(fi, CONN_STATE_STARTWAIT);
+@@ -856,13 +860,15 @@ static void conn_action_connsever(fsm_in
+ static void conn_action_start(fsm_instance *fi, int event, void *arg)
+ {
+ 	struct iucv_connection *conn = arg;
++	struct net_device *netdev = conn->netdev;
++	struct netiucv_priv *privptr = netdev_priv(netdev);
+ 	int rc;
+ 
+ 	IUCV_DBF_TEXT(trace, 3, __func__);
+ 
+ 	fsm_newstate(fi, CONN_STATE_STARTWAIT);
+ 	IUCV_DBF_TEXT_(setup, 2, "%s('%s'): connecting ...\n",
+-		    conn->netdev->name, conn->userid);
++		netdev->name, conn->userid);
+ 
+ 	/*
+ 	 * We must set the state before calling iucv_connect because the
+@@ -876,41 +882,45 @@ static void conn_action_start(fsm_instan
+ 			       NULL, iucvMagic, conn);
+ 	switch (rc) {
+ 	case 0:
+-		conn->netdev->tx_queue_len = conn->path->msglim;
++		netdev->tx_queue_len = conn->path->msglim;
+ 		fsm_addtimer(&conn->timer, NETIUCV_TIMEOUT_5SEC,
+ 			     CONN_EVENT_TIMER, conn);
+ 		return;
+ 	case 11:
+-		PRINT_INFO("%s: User %s is currently not available.\n",
+-			   conn->netdev->name,
+-			   netiucv_printname(conn->userid));
++		dev_warn(privptr->dev,
++			"The IUCV device failed to connect to z/VM guest %s\n",
++			netiucv_printname(conn->userid));
+ 		fsm_newstate(fi, CONN_STATE_STARTWAIT);
+ 		break;
+ 	case 12:
+-		PRINT_INFO("%s: User %s is currently not ready.\n",
+-			   conn->netdev->name,
+-			   netiucv_printname(conn->userid));
++		dev_warn(privptr->dev,
++			"The IUCV device failed to connect to the peer on z/VM"
++			" guest %s\n", netiucv_printname(conn->userid));
+ 		fsm_newstate(fi, CONN_STATE_STARTWAIT);
+ 		break;
+ 	case 13:
+-		PRINT_WARN("%s: Too many IUCV connections.\n",
+-			   conn->netdev->name);
++		dev_err(privptr->dev,
++			"Connecting the IUCV device would exceed the maximum"
++			" number of IUCV connections\n");
+ 		fsm_newstate(fi, CONN_STATE_CONNERR);
+ 		break;
+ 	case 14:
+-		PRINT_WARN("%s: User %s has too many IUCV connections.\n",
+-			   conn->netdev->name,
+-			   netiucv_printname(conn->userid));
++		dev_err(privptr->dev,
++			"z/VM guest %s has too many IUCV connections"
++			" to connect with the IUCV device\n",
++			netiucv_printname(conn->userid));
+ 		fsm_newstate(fi, CONN_STATE_CONNERR);
+ 		break;
+ 	case 15:
+-		PRINT_WARN("%s: No IUCV authorization in CP directory.\n",
+-			   conn->netdev->name);
++		dev_err(privptr->dev,
++			"The IUCV device cannot connect to a z/VM guest with no"
++			" IUCV authorization\n");
+ 		fsm_newstate(fi, CONN_STATE_CONNERR);
+ 		break;
+ 	default:
+-		PRINT_WARN("%s: iucv_connect returned error %d\n",
+-			   conn->netdev->name, rc);
++		dev_err(privptr->dev,
++			"Connecting the IUCV device failed with error %d\n",
++			rc);
+ 		fsm_newstate(fi, CONN_STATE_CONNERR);
+ 		break;
+ 	}
+@@ -1059,8 +1069,9 @@ dev_action_connup(fsm_instance *fi, int 
+ 	switch (fsm_getstate(fi)) {
+ 		case DEV_STATE_STARTWAIT:
+ 			fsm_newstate(fi, DEV_STATE_RUNNING);
+-			PRINT_INFO("%s: connected with remote side %s\n",
+-			       dev->name, privptr->conn->userid);
++			dev_info(privptr->dev,
++				"The IUCV device has been connected"
++				" successfully to %s\n", privptr->conn->userid);
+ 			IUCV_DBF_TEXT(setup, 3,
+ 				"connection is up and running\n");
+ 			break;
+@@ -1982,6 +1993,8 @@ static ssize_t conn_write(struct device_
+ 	if (rc)
+ 		goto out_unreg;
+ 
++	dev_info(priv->dev, "The IUCV interface to %s has been"
++		" established successfully\n", netiucv_printname(username));
+ 
+ 	return count;
+ 
+@@ -2027,10 +2040,9 @@ static ssize_t remove_write (struct devi
+ 			continue;
+ 		read_unlock_bh(&iucv_connection_rwlock);
+                 if (ndev->flags & (IFF_UP | IFF_RUNNING)) {
+-			PRINT_WARN("netiucv: net device %s active with peer "
+-				   "%s\n", ndev->name, priv->conn->userid);
+-                        PRINT_WARN("netiucv: %s cannot be removed\n",
+-				   ndev->name);
++			dev_warn(dev, "The IUCV device is connected"
++				" to %s and cannot be removed\n",
++				priv->conn->userid);
+ 			IUCV_DBF_TEXT(data, 2, "remove_write: still active\n");
+ 			return -EPERM;
+                 }
+@@ -2062,7 +2074,7 @@ static struct attribute_group *netiucv_d
+ 
+ static void netiucv_banner(void)
+ {
+-	PRINT_INFO("NETIUCV driver initialized\n");
++	pr_info("driver initialized\n");
+ }
+ 
+ static void __exit netiucv_exit(void)
+@@ -2088,7 +2100,7 @@ static void __exit netiucv_exit(void)
+ 	iucv_unregister(&netiucv_handler, 1);
+ 	iucv_unregister_dbf_views();
+ 
+-	PRINT_INFO("NETIUCV driver unloaded\n");
++	pr_info("driver unloaded\n");
+ 	return;
+ }
+ 
+Index: linux-2.6.27-gentoo-r7/drivers/s390/net/qeth_core.h
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/net/qeth_core.h
++++ linux-2.6.27-gentoo-r7/drivers/s390/net/qeth_core.h
+@@ -31,11 +31,10 @@
+ #include <asm/qdio.h>
+ #include <asm/ccwdev.h>
+ #include <asm/ccwgroup.h>
++#include <asm/sysinfo.h>
+ 
+ #include "qeth_core_mpc.h"
+ 
+-#define KMSG_COMPONENT "qeth"
+-
+ /**
+  * Debug Facility stuff
+  */
+@@ -74,11 +73,6 @@ struct qeth_dbf_info {
+ #define QETH_DBF_TEXT_(name, level, text...) \
+ 	qeth_dbf_longtext(QETH_DBF_##name, level, text)
+ 
+-/**
+- * some more debug stuff
+- */
+-#define PRINTK_HEADER	"qeth: "
+-
+ #define SENSE_COMMAND_REJECT_BYTE 0
+ #define SENSE_COMMAND_REJECT_FLAG 0x80
+ #define SENSE_RESETTING_EVENT_BYTE 1
+@@ -733,6 +727,7 @@ struct qeth_card {
+ 	struct qeth_osn_info osn_info;
+ 	struct qeth_discipline discipline;
+ 	atomic_t force_alloc_skb;
++	struct service_level qeth_service_level;
+ };
+ 
+ struct qeth_card_list_struct {
+Index: linux-2.6.27-gentoo-r7/drivers/s390/net/qeth_core_main.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/net/qeth_core_main.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/net/qeth_core_main.c
+@@ -8,6 +8,9 @@
+  *		 Frank Blaschka <frank.blaschka@××××××.com>
+  */
+ 
++#define KMSG_COMPONENT "qeth"
++#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
++
+ #include <linux/module.h>
+ #include <linux/moduleparam.h>
+ #include <linux/string.h>
+@@ -319,7 +322,10 @@ static int qeth_issue_next_read(struct q
+ 		return -EIO;
+ 	iob = qeth_get_buffer(&card->read);
+ 	if (!iob) {
+-		PRINT_WARN("issue_next_read failed: no iob available!\n");
++		dev_warn(&card->gdev->dev, "The qeth device driver "
++			"failed to recover an error on the device\n");
++		QETH_DBF_MESSAGE(2, "%s issue_next_read failed: no iob "
++			"available\n", dev_name(&card->gdev->dev));
+ 		return -ENOMEM;
+ 	}
+ 	qeth_setup_ccw(&card->read, iob->data, QETH_BUFSIZE);
+@@ -327,7 +333,8 @@ static int qeth_issue_next_read(struct q
+ 	rc = ccw_device_start(card->read.ccwdev, &card->read.ccw,
+ 			      (addr_t) iob, 0, 0);
+ 	if (rc) {
+-		PRINT_ERR("Error in starting next read ccw! rc=%i\n", rc);
++		QETH_DBF_MESSAGE(2, "%s error in starting next read ccw! "
++			"rc=%i\n", dev_name(&card->gdev->dev), rc);
+ 		atomic_set(&card->read.irq_pending, 0);
+ 		qeth_schedule_recovery(card);
+ 		wake_up(&card->wait_q);
+@@ -393,10 +400,9 @@ static struct qeth_ipa_cmd *qeth_check_i
+ 		} else {
+ 			switch (cmd->hdr.command) {
+ 			case IPA_CMD_STOPLAN:
+-				PRINT_WARN("Link failure on %s (CHPID 0x%X) - "
+-					   "there is a network problem or "
+-					   "someone pulled the cable or "
+-					   "disabled the port.\n",
++				dev_warn(&card->gdev->dev,
++					   "The link for interface %s on CHPID"
++					   " 0x%X failed\n",
+ 					   QETH_CARD_IFNAME(card),
+ 					   card->info.chpid);
+ 				card->lan_online = 0;
+@@ -404,9 +410,9 @@ static struct qeth_ipa_cmd *qeth_check_i
+ 					netif_carrier_off(card->dev);
+ 				return NULL;
+ 			case IPA_CMD_STARTLAN:
+-				PRINT_INFO("Link reestablished on %s "
+-					   "(CHPID 0x%X). Scheduling "
+-					   "IP address reset.\n",
++				dev_info(&card->gdev->dev,
++					   "The link for %s on CHPID 0x%X has"
++					   " been restored\n",
+ 					   QETH_CARD_IFNAME(card),
+ 					   card->info.chpid);
+ 				netif_carrier_on(card->dev);
+@@ -458,7 +464,7 @@ static int qeth_check_idx_response(unsig
+ 
+ 	QETH_DBF_HEX(CTRL, 2, buffer, QETH_DBF_CTRL_LEN);
+ 	if ((buffer[2] & 0xc0) == 0xc0) {
+-		PRINT_WARN("received an IDX TERMINATE "
++		QETH_DBF_MESSAGE(2, "received an IDX TERMINATE "
+ 			   "with cause code 0x%02x%s\n",
+ 			   buffer[4],
+ 			   ((buffer[4] == 0x22) ?
+@@ -744,8 +750,10 @@ static int qeth_get_problem(struct ccw_d
+ 		     SCHN_STAT_CHN_DATA_CHK | SCHN_STAT_CHAIN_CHECK |
+ 		     SCHN_STAT_PROT_CHECK | SCHN_STAT_PROG_CHECK)) {
+ 		QETH_DBF_TEXT(TRACE, 2, "CGENCHK");
+-		PRINT_WARN("check on device %s, dstat=x%x, cstat=x%x ",
+-			   cdev->dev.bus_id, dstat, cstat);
++		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 ",
++			dev_name(&cdev->dev), dstat, cstat);
+ 		print_hex_dump(KERN_WARNING, "qeth: irb ", DUMP_PREFIX_OFFSET,
+ 				16, 1, irb, 64, 1);
+ 		return 1;
+@@ -784,12 +792,14 @@ static long __qeth_check_irb_error(struc
+ 
+ 	switch (PTR_ERR(irb)) {
+ 	case -EIO:
+-		PRINT_WARN("i/o-error on device %s\n", cdev->dev.bus_id);
++		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);
+ 		break;
+ 	case -ETIMEDOUT:
+-		PRINT_WARN("timeout on device %s\n", cdev->dev.bus_id);
++		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);
+ 		if (intparm == QETH_RCD_PARM) {
+@@ -802,8 +812,8 @@ static long __qeth_check_irb_error(struc
+ 		}
+ 		break;
+ 	default:
+-		PRINT_WARN("unknown error %ld on device %s\n", PTR_ERR(irb),
+-			   cdev->dev.bus_id);
++		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???");
+ 	}
+@@ -869,10 +879,12 @@ static void qeth_irq(struct ccw_device *
+ 	    (dstat & DEV_STAT_UNIT_CHECK) ||
+ 	    (cstat)) {
+ 		if (irb->esw.esw0.erw.cons) {
+-			/* TODO: we should make this s390dbf */
+-			PRINT_WARN("sense data available on channel %s.\n",
+-				   CHANNEL_ID(channel));
+-			PRINT_WARN(" cstat 0x%X\n dstat 0x%X\n", cstat, dstat);
++			dev_warn(&channel->ccwdev->dev,
++				"The qeth device driver failed to recover "
++				"an error on the device\n");
++			QETH_DBF_MESSAGE(2, "%s sense data available. cstat "
++				"0x%X dstat 0x%X\n",
++				dev_name(&channel->ccwdev->dev), cstat, dstat);
+ 			print_hex_dump(KERN_WARNING, "qeth: irb ",
+ 				DUMP_PREFIX_OFFSET, 16, 1, irb, 32, 1);
+ 			print_hex_dump(KERN_WARNING, "qeth: sense data ",
+@@ -1138,6 +1150,14 @@ static int qeth_setup_card(struct qeth_c
+ 	return 0;
+ }
+ 
++static void qeth_core_sl_print(struct seq_file *m, struct service_level *slr)
++{
++	struct qeth_card *card = container_of(slr, struct qeth_card,
++					qeth_service_level);
++	seq_printf(m, "qeth: %s firmware level %s\n", CARD_BUS_ID(card),
++			card->info.mcl_level);
++}
++
+ static struct qeth_card *qeth_alloc_card(void)
+ {
+ 	struct qeth_card *card;
+@@ -1157,6 +1177,8 @@ static struct qeth_card *qeth_alloc_card
+ 		return NULL;
+ 	}
+ 	card->options.layer2 = -1;
++	card->qeth_service_level.seq_print = qeth_core_sl_print;
++	register_service_level(&card->qeth_service_level);
+ 	return card;
+ }
+ 
+@@ -1175,8 +1197,8 @@ static int qeth_determine_card_type(stru
+ 			card->qdio.no_out_queues = known_devices[i][8];
+ 			card->info.is_multicast_different = known_devices[i][9];
+ 			if (qeth_is_1920_device(card)) {
+-				PRINT_INFO("Priority Queueing not able "
+-					   "due to hardware limitations!\n");
++				dev_info(&card->gdev->dev,
++					"Priority Queueing not supported\n");
+ 				card->qdio.no_out_queues = 1;
+ 				card->qdio.default_out_queue = 0;
+ 			}
+@@ -1185,7 +1207,8 @@ static int qeth_determine_card_type(stru
+ 		i++;
+ 	}
+ 	card->info.type = QETH_CARD_TYPE_UNKNOWN;
+-	PRINT_ERR("unknown card type on device %s\n", CARD_BUS_ID(card));
++	dev_err(&card->gdev->dev, "The adapter hardware is of an "
++		"unknown type\n");
+ 	return -ENOENT;
+ }
+ 
+@@ -1368,8 +1391,8 @@ static int qeth_get_unitaddr(struct qeth
+ 	QETH_DBF_TEXT(SETUP, 2, "getunit");
+ 	rc = qeth_read_conf_data(card, (void **) &prcd, &length);
+ 	if (rc) {
+-		PRINT_ERR("qeth_read_conf_data for device %s returned %i\n",
+-			CARD_DDEV_ID(card), rc);
++		QETH_DBF_MESSAGE(2, "%s qeth_read_conf_data returned %i\n",
++			dev_name(&card->gdev->dev), rc);
+ 		return rc;
+ 	}
+ 	card->info.chpid = prcd[30];
+@@ -1519,7 +1542,10 @@ static int qeth_idx_activate_channel(str
+ 	if (rc == -ERESTARTSYS)
+ 		return rc;
+ 	if (channel->state != CH_STATE_ACTIVATING) {
+-		PRINT_WARN("IDX activate timed out!\n");
++		dev_warn(&channel->ccwdev->dev, "The qeth device driver"
++			" failed to recover an error on the device\n");
++		QETH_DBF_MESSAGE(2, "%s IDX activate timed out\n",
++			dev_name(&channel->ccwdev->dev));
+ 		QETH_DBF_TEXT_(SETUP, 2, "2err%d", -ETIME);
+ 		qeth_clear_cmd_buffers(channel);
+ 		return -ETIME;
+@@ -1552,20 +1578,21 @@ static void qeth_idx_write_cb(struct qet
+ 
+ 	if (!(QETH_IS_IDX_ACT_POS_REPLY(iob->data))) {
+ 		if (QETH_IDX_ACT_CAUSE_CODE(iob->data) == 0x19)
+-			PRINT_ERR("IDX_ACTIVATE on write channel device %s: "
+-				"adapter exclusively used by another host\n",
+-			CARD_WDEV_ID(card));
++			dev_err(&card->write.ccwdev->dev,
++				"The adapter is used exclusively by another "
++				"host\n");
+ 		else
+-			PRINT_ERR("IDX_ACTIVATE on write channel device %s: "
+-				"negative reply\n", CARD_WDEV_ID(card));
++			QETH_DBF_MESSAGE(2, "%s IDX_ACTIVATE on write channel:"
++				" negative reply\n",
++				dev_name(&card->write.ccwdev->dev));
+ 		goto out;
+ 	}
+ 	memcpy(&temp, QETH_IDX_ACT_FUNC_LEVEL(iob->data), 2);
+ 	if ((temp & ~0x0100) != qeth_peer_func_level(card->info.func_level)) {
+-		PRINT_WARN("IDX_ACTIVATE on write channel device %s: "
+-			   "function level mismatch "
+-			   "(sent: 0x%x, received: 0x%x)\n",
+-			   CARD_WDEV_ID(card), card->info.func_level, temp);
++		QETH_DBF_MESSAGE(2, "%s IDX_ACTIVATE on write channel: "
++			"function level mismatch (sent: 0x%x, received: "
++			"0x%x)\n", dev_name(&card->write.ccwdev->dev),
++			card->info.func_level, temp);
+ 		goto out;
+ 	}
+ 	channel->state = CH_STATE_UP;
+@@ -1591,12 +1618,13 @@ static void qeth_idx_read_cb(struct qeth
+ 
+ 	if (!(QETH_IS_IDX_ACT_POS_REPLY(iob->data))) {
+ 		if (QETH_IDX_ACT_CAUSE_CODE(iob->data) == 0x19)
+-			PRINT_ERR("IDX_ACTIVATE on read channel device %s: "
+-				"adapter exclusively used by another host\n",
+-				CARD_RDEV_ID(card));
++			dev_err(&card->write.ccwdev->dev,
++				"The adapter is used exclusively by another "
++				"host\n");
+ 		else
+-			PRINT_ERR("IDX_ACTIVATE on read channel device %s: "
+-				"negative reply\n", CARD_RDEV_ID(card));
++			QETH_DBF_MESSAGE(2, "%s IDX_ACTIVATE on read channel:"
++				" negative reply\n",
++				dev_name(&card->read.ccwdev->dev));
+ 		goto out;
+ 	}
+ 
+@@ -1610,9 +1638,10 @@ static void qeth_idx_read_cb(struct qeth
+ 
+ 	memcpy(&temp, QETH_IDX_ACT_FUNC_LEVEL(iob->data), 2);
+ 	if (temp != qeth_peer_func_level(card->info.func_level)) {
+-		PRINT_WARN("IDX_ACTIVATE on read channel device %s: function "
+-			   "level mismatch (sent: 0x%x, received: 0x%x)\n",
+-			   CARD_RDEV_ID(card), card->info.func_level, temp);
++		QETH_DBF_MESSAGE(2, "%s IDX_ACTIVATE on read channel: function "
++			"level mismatch (sent: 0x%x, received: 0x%x)\n",
++			dev_name(&card->read.ccwdev->dev),
++			card->info.func_level, temp);
+ 		goto out;
+ 	}
+ 	memcpy(&card->token.issuer_rm_r,
+@@ -1686,8 +1715,9 @@ int qeth_send_control_data(struct qeth_c
+ 			      (addr_t) iob, 0, 0);
+ 	spin_unlock_irqrestore(get_ccwdev_lock(card->write.ccwdev), flags);
+ 	if (rc) {
+-		PRINT_WARN("qeth_send_control_data: "
+-			   "ccw_device_start rc = %i\n", rc);
++		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);
+ 		spin_lock_irqsave(&card->lock, flags);
+ 		list_del_init(&reply->list);
+@@ -2170,11 +2200,8 @@ static void qeth_print_status_with_portn
+ 		dbf_text[i] =
+ 			(char) _ebcasc[(__u8) dbf_text[i]];
+ 	dbf_text[8] = 0;
+-	PRINT_INFO("Device %s/%s/%s is a%s card%s%s%s\n"
++	dev_info(&card->gdev->dev, "Device is a%s card%s%s%s\n"
+ 	       "with link type %s (portname: %s)\n",
+-	       CARD_RDEV_ID(card),
+-	       CARD_WDEV_ID(card),
+-	       CARD_DDEV_ID(card),
+ 	       qeth_get_cardname(card),
+ 	       (card->info.mcl_level[0]) ? " (level: " : "",
+ 	       (card->info.mcl_level[0]) ? card->info.mcl_level : "",
+@@ -2187,23 +2214,17 @@ static void qeth_print_status_with_portn
+ static void qeth_print_status_no_portname(struct qeth_card *card)
+ {
+ 	if (card->info.portname[0])
+-		PRINT_INFO("Device %s/%s/%s is a%s "
++		dev_info(&card->gdev->dev, "Device is a%s "
+ 		       "card%s%s%s\nwith link type %s "
+ 		       "(no portname needed by interface).\n",
+-		       CARD_RDEV_ID(card),
+-		       CARD_WDEV_ID(card),
+-		       CARD_DDEV_ID(card),
+ 		       qeth_get_cardname(card),
+ 		       (card->info.mcl_level[0]) ? " (level: " : "",
+ 		       (card->info.mcl_level[0]) ? card->info.mcl_level : "",
+ 		       (card->info.mcl_level[0]) ? ")" : "",
+ 		       qeth_get_cardname_short(card));
+ 	else
+-		PRINT_INFO("Device %s/%s/%s is a%s "
++		dev_info(&card->gdev->dev, "Device is a%s "
+ 		       "card%s%s%s\nwith link type %s.\n",
+-		       CARD_RDEV_ID(card),
+-		       CARD_WDEV_ID(card),
+-		       CARD_DDEV_ID(card),
+ 		       qeth_get_cardname(card),
+ 		       (card->info.mcl_level[0]) ? " (level: " : "",
+ 		       (card->info.mcl_level[0]) ? card->info.mcl_level : "",
+@@ -2630,9 +2651,8 @@ void qeth_queue_input_buffer(struct qeth
+ 				qeth_get_micros() -
+ 				card->perf_stats.inbound_do_qdio_start_time;
+ 		if (rc) {
+-			PRINT_WARN("qeth_queue_input_buffer's do_QDIO "
+-				   "return %i (device %s).\n",
+-				   rc, CARD_DDEV_ID(card));
++			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));
+ 		}
+@@ -3730,6 +3750,7 @@ static void qeth_core_free_card(struct q
+ 		free_netdev(card->dev);
+ 	kfree(card->ip_tbd_list);
+ 	qeth_free_qdio_buffers(card);
++	unregister_service_level(&card->qeth_service_level);
+ 	kfree(card);
+ }
+ 
+@@ -3766,7 +3787,8 @@ int qeth_core_hardsetup_card(struct qeth
+ 	atomic_set(&card->force_alloc_skb, 0);
+ retry:
+ 	if (retries < 3) {
+-		PRINT_WARN("Retrying to do IDX activates.\n");
++		QETH_DBF_MESSAGE(2, "%s Retrying to do IDX activates.\n",
++			dev_name(&card->gdev->dev));
+ 		ccw_device_set_offline(CARD_DDEV(card));
+ 		ccw_device_set_offline(CARD_WDEV(card));
+ 		ccw_device_set_offline(CARD_RDEV(card));
+@@ -3841,7 +3863,10 @@ retry:
+ 	}
+ 	return 0;
+ out:
+-	PRINT_ERR("Initialization in hardsetup failed! rc=%d\n", rc);
++	dev_warn(&card->gdev->dev, "The qeth device driver failed to recover "
++		"an error on the device\n");
++	QETH_DBF_MESSAGE(2, "%s Initialization in hardsetup failed! rc=%d\n",
++		dev_name(&card->gdev->dev), rc);
+ 	return rc;
+ }
+ EXPORT_SYMBOL_GPL(qeth_core_hardsetup_card);
+@@ -4061,8 +4086,8 @@ int qeth_core_load_discipline(struct qet
+ 		break;
+ 	}
+ 	if (!card->discipline.ccwgdriver) {
+-		PRINT_ERR("Support for discipline %d not present\n",
+-				discipline);
++		dev_err(&card->gdev->dev, "There is no kernel module to "
++			"support discipline %d\n", discipline);
+ 		rc = -EINVAL;
+ 	}
+ 	return rc;
+@@ -4455,7 +4480,7 @@ static int __init qeth_core_init(void)
+ {
+ 	int rc;
+ 
+-	PRINT_INFO("loading core functions\n");
++	pr_info("loading core functions\n");
+ 	INIT_LIST_HEAD(&qeth_core_card_list.list);
+ 	rwlock_init(&qeth_core_card_list.rwlock);
+ 
+@@ -4495,9 +4520,10 @@ driver_err:
+ ccwgroup_err:
+ 	ccw_driver_unregister(&qeth_ccw_driver);
+ ccw_err:
++	QETH_DBF_MESSAGE(2, "Initialization failed with code %d\n", rc);
+ 	qeth_unregister_dbf_views();
+ out_err:
+-	PRINT_ERR("Initialization failed with code %d\n", rc);
++	pr_err("Initializing the qeth device driver failed\n");
+ 	return rc;
+ }
+ 
+@@ -4510,7 +4536,7 @@ static void __exit qeth_core_exit(void)
+ 	ccw_driver_unregister(&qeth_ccw_driver);
+ 	kmem_cache_destroy(qeth_core_header_cache);
+ 	qeth_unregister_dbf_views();
+-	PRINT_INFO("core functions removed\n");
++	pr_info("core functions removed\n");
+ }
+ 
+ module_init(qeth_core_init);
+Index: linux-2.6.27-gentoo-r7/drivers/s390/net/qeth_l2_main.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/net/qeth_l2_main.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/net/qeth_l2_main.c
+@@ -8,6 +8,9 @@
+  *		 Frank Blaschka <frank.blaschka@××××××.com>
+  */
+ 
++#define KMSG_COMPONENT "qeth"
++#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
++
+ #include <linux/module.h>
+ #include <linux/moduleparam.h>
+ #include <linux/string.h>
+@@ -503,12 +506,13 @@ static int qeth_l2_send_setmac_cb(struct
+ 		card->info.mac_bits |= QETH_LAYER2_MAC_REGISTERED;
+ 		memcpy(card->dev->dev_addr, cmd->data.setdelmac.mac,
+ 		       OSA_ADDR_LEN);
+-		PRINT_INFO("MAC address %2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x "
+-			   "successfully registered on device %s\n",
+-			   card->dev->dev_addr[0], card->dev->dev_addr[1],
+-			   card->dev->dev_addr[2], card->dev->dev_addr[3],
+-			   card->dev->dev_addr[4], card->dev->dev_addr[5],
+-			   card->dev->name);
++		dev_info(&card->gdev->dev,
++			"MAC address %2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x "
++			"successfully registered on device %s\n",
++			card->dev->dev_addr[0], card->dev->dev_addr[1],
++			card->dev->dev_addr[2], card->dev->dev_addr[3],
++			card->dev->dev_addr[4], card->dev->dev_addr[5],
++			card->dev->name);
+ 	}
+ 	return 0;
+ }
+@@ -1015,9 +1019,8 @@ static int __qeth_l2_set_online(struct c
+ 	if (rc) {
+ 		QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc);
+ 		if (rc == 0xe080) {
+-			PRINT_WARN("LAN on card %s if offline! "
+-				   "Waiting for STARTLAN from card.\n",
+-				   CARD_BUS_ID(card));
++			dev_warn(&card->gdev->dev,
++				"The LAN is offline\n");
+ 			card->lan_online = 0;
+ 		}
+ 		return rc;
+@@ -1117,8 +1120,8 @@ static int qeth_l2_recover(void *ptr)
+ 	if (!qeth_do_run_thread(card, QETH_RECOVER_THREAD))
+ 		return 0;
+ 	QETH_DBF_TEXT(TRACE, 2, "recover2");
+-	PRINT_WARN("Recovery of device %s started ...\n",
+-		   CARD_BUS_ID(card));
++	dev_warn(&card->gdev->dev,
++		"A recovery process has been started for the device\n");
+ 	card->use_hard_stop = 1;
+ 	__qeth_l2_set_offline(card->gdev, 1);
+ 	rc = __qeth_l2_set_online(card->gdev, 1);
+@@ -1126,27 +1129,27 @@ static int qeth_l2_recover(void *ptr)
+ 	qeth_clear_thread_start_bit(card, QETH_RECOVER_THREAD);
+ 	qeth_clear_thread_running_bit(card, QETH_RECOVER_THREAD);
+ 	if (!rc)
+-		PRINT_INFO("Device %s successfully recovered!\n",
+-			   CARD_BUS_ID(card));
++		dev_info(&card->gdev->dev,
++			"Device successfully recovered!\n");
+ 	else {
+ 		rtnl_lock();
+ 		dev_close(card->dev);
+ 		rtnl_unlock();
+-		PRINT_INFO("Device %s could not be recovered!\n",
+-			   CARD_BUS_ID(card));
++		dev_warn(&card->gdev->dev, "The qeth device driver "
++			"failed to recover an error on the device\n");
+ 	}
+ 	return 0;
+ }
+ 
+ static int __init qeth_l2_init(void)
+ {
+-	PRINT_INFO("register layer 2 discipline\n");
++	pr_info("register layer 2 discipline\n");
+ 	return 0;
+ }
+ 
+ static void __exit qeth_l2_exit(void)
+ {
+-	PRINT_INFO("unregister layer 2 discipline\n");
++	pr_info("unregister layer 2 discipline\n");
+ }
+ 
+ static void qeth_l2_shutdown(struct ccwgroup_device *gdev)
+Index: linux-2.6.27-gentoo-r7/drivers/s390/net/qeth_l3_main.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/net/qeth_l3_main.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/net/qeth_l3_main.c
+@@ -8,6 +8,9 @@
+  *		 Frank Blaschka <frank.blaschka@××××××.com>
+  */
+ 
++#define KMSG_COMPONENT "qeth"
++#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
++
+ #include <linux/module.h>
+ #include <linux/moduleparam.h>
+ #include <linux/string.h>
+@@ -917,8 +920,8 @@ static int qeth_l3_register_addr_entry(s
+ 	if (rc) {
+ 		QETH_DBF_TEXT(TRACE, 2, "FAILED");
+ 		qeth_l3_ipaddr_to_string(addr->proto, (u8 *)&addr->u, buf);
+-		PRINT_WARN("Could not register IP address %s (rc=0x%x/%d)\n",
+-			   buf, rc, rc);
++		dev_warn(&card->gdev->dev,
++			"Registering IP address %s failed\n", buf);
+ 	}
+ 	return rc;
+ }
+@@ -1029,24 +1032,22 @@ static int qeth_l3_setadapter_parms(stru
+ 	QETH_DBF_TEXT(SETUP, 2, "setadprm");
+ 
+ 	if (!qeth_is_supported(card, IPA_SETADAPTERPARMS)) {
+-		PRINT_WARN("set adapter parameters not supported "
+-			   "on device %s.\n",
+-			   CARD_BUS_ID(card));
++		dev_info(&card->gdev->dev,
++			"set adapter parameters not supported.\n");
+ 		QETH_DBF_TEXT(SETUP, 2, " notsupp");
+ 		return 0;
+ 	}
+ 	rc = qeth_query_setadapterparms(card);
+ 	if (rc) {
+-		PRINT_WARN("couldn't set adapter parameters on device %s: "
+-			   "x%x\n", CARD_BUS_ID(card), rc);
++		QETH_DBF_MESSAGE(2, "%s couldn't set adapter parameters: "
++			"0x%x\n", card->gdev->dev.bus_id, rc);
+ 		return rc;
+ 	}
+ 	if (qeth_adp_supported(card, IPA_SETADP_ALTER_MAC_ADDRESS)) {
+ 		rc = qeth_setadpparms_change_macaddr(card);
+ 		if (rc)
+-			PRINT_WARN("couldn't get MAC address on "
+-				   "device %s: x%x\n",
+-				   CARD_BUS_ID(card), rc);
++			dev_warn(&card->gdev->dev, "Reading the adapter MAC"
++				" address failed\n", rc);
+ 	}
+ 
+ 	if ((card->info.link_type == QETH_LINK_TYPE_HSTR) ||
+@@ -1160,16 +1161,17 @@ static int qeth_l3_start_ipa_arp_process
+ 	QETH_DBF_TEXT(TRACE, 3, "ipaarp");
+ 
+ 	if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) {
+-		PRINT_WARN("ARP processing not supported "
+-			   "on %s!\n", QETH_CARD_IFNAME(card));
++		dev_info(&card->gdev->dev,
++			"ARP processing not supported on %s!\n",
++			QETH_CARD_IFNAME(card));
+ 		return 0;
+ 	}
+ 	rc = qeth_l3_send_simple_setassparms(card, IPA_ARP_PROCESSING,
+ 					IPA_CMD_ASS_START, 0);
+ 	if (rc) {
+-		PRINT_WARN("Could not start ARP processing "
+-			   "assist on %s: 0x%x\n",
+-			   QETH_CARD_IFNAME(card), rc);
++		dev_warn(&card->gdev->dev,
++			"Starting ARP processing support for %s failed\n",
++			QETH_CARD_IFNAME(card));
+ 	}
+ 	return rc;
+ }
+@@ -1181,19 +1183,21 @@ static int qeth_l3_start_ipa_ip_fragment
+ 	QETH_DBF_TEXT(TRACE, 3, "ipaipfrg");
+ 
+ 	if (!qeth_is_supported(card, IPA_IP_FRAGMENTATION)) {
+-		PRINT_INFO("Hardware IP fragmentation not supported on %s\n",
+-			   QETH_CARD_IFNAME(card));
++		dev_info(&card->gdev->dev,
++			"Hardware IP fragmentation not supported on %s\n",
++			QETH_CARD_IFNAME(card));
+ 		return  -EOPNOTSUPP;
+ 	}
+ 
+ 	rc = qeth_l3_send_simple_setassparms(card, IPA_IP_FRAGMENTATION,
+ 					  IPA_CMD_ASS_START, 0);
+ 	if (rc) {
+-		PRINT_WARN("Could not start Hardware IP fragmentation "
+-			   "assist on %s: 0x%x\n",
+-			   QETH_CARD_IFNAME(card), rc);
++		dev_warn(&card->gdev->dev,
++			"Starting IP fragmentation support for %s failed\n",
++			QETH_CARD_IFNAME(card));
+ 	} else
+-		PRINT_INFO("Hardware IP fragmentation enabled \n");
++		dev_info(&card->gdev->dev,
++			"Hardware IP fragmentation enabled \n");
+ 	return rc;
+ }
+ 
+@@ -1207,17 +1211,18 @@ static int qeth_l3_start_ipa_source_mac(
+ 		return -EOPNOTSUPP;
+ 
+ 	if (!qeth_is_supported(card, IPA_SOURCE_MAC)) {
+-		PRINT_INFO("Inbound source address not "
+-			   "supported on %s\n", QETH_CARD_IFNAME(card));
++		dev_info(&card->gdev->dev,
++			"Inbound source address not supported on %s\n",
++			QETH_CARD_IFNAME(card));
+ 		return -EOPNOTSUPP;
+ 	}
+ 
+ 	rc = qeth_l3_send_simple_setassparms(card, IPA_SOURCE_MAC,
+ 					  IPA_CMD_ASS_START, 0);
+ 	if (rc)
+-		PRINT_WARN("Could not start inbound source "
+-			   "assist on %s: 0x%x\n",
+-			   QETH_CARD_IFNAME(card), rc);
++		dev_warn(&card->gdev->dev,
++			"Starting proxy ARP support for %s failed\n",
++			QETH_CARD_IFNAME(card));
+ 	return rc;
+ }
+ 
+@@ -1228,19 +1233,19 @@ static int qeth_l3_start_ipa_vlan(struct
+ 	QETH_DBF_TEXT(TRACE, 3, "strtvlan");
+ 
+ 	if (!qeth_is_supported(card, IPA_FULL_VLAN)) {
+-		PRINT_WARN("VLAN not supported on %s\n",
+-				QETH_CARD_IFNAME(card));
++		dev_info(&card->gdev->dev,
++			"VLAN not supported on %s\n", QETH_CARD_IFNAME(card));
+ 		return -EOPNOTSUPP;
+ 	}
+ 
+ 	rc = qeth_l3_send_simple_setassparms(card, IPA_VLAN_PRIO,
+ 					  IPA_CMD_ASS_START, 0);
+ 	if (rc) {
+-		PRINT_WARN("Could not start vlan "
+-			   "assist on %s: 0x%x\n",
+-			   QETH_CARD_IFNAME(card), rc);
++		dev_warn(&card->gdev->dev,
++			"Starting VLAN support for %s failed\n",
++			QETH_CARD_IFNAME(card));
+ 	} else {
+-		PRINT_INFO("VLAN enabled \n");
++		dev_info(&card->gdev->dev, "VLAN enabled\n");
+ 	}
+ 	return rc;
+ }
+@@ -1252,19 +1257,20 @@ static int qeth_l3_start_ipa_multicast(s
+ 	QETH_DBF_TEXT(TRACE, 3, "stmcast");
+ 
+ 	if (!qeth_is_supported(card, IPA_MULTICASTING)) {
+-		PRINT_WARN("Multicast not supported on %s\n",
+-			   QETH_CARD_IFNAME(card));
++		dev_info(&card->gdev->dev,
++			"Multicast not supported on %s\n",
++			QETH_CARD_IFNAME(card));
+ 		return -EOPNOTSUPP;
+ 	}
+ 
+ 	rc = qeth_l3_send_simple_setassparms(card, IPA_MULTICASTING,
+ 					  IPA_CMD_ASS_START, 0);
+ 	if (rc) {
+-		PRINT_WARN("Could not start multicast "
+-			   "assist on %s: rc=%i\n",
+-			   QETH_CARD_IFNAME(card), rc);
++		dev_warn(&card->gdev->dev,
++			"Starting multicast support for %s failed\n",
++			QETH_CARD_IFNAME(card));
+ 	} else {
+-		PRINT_INFO("Multicast enabled\n");
++		dev_info(&card->gdev->dev, "Multicast enabled\n");
+ 		card->dev->flags |= IFF_MULTICAST;
+ 	}
+ 	return rc;
+@@ -1315,36 +1321,37 @@ static int qeth_l3_softsetup_ipv6(struct
+ 
+ 	rc = qeth_l3_query_ipassists(card, QETH_PROT_IPV6);
+ 	if (rc) {
+-		PRINT_ERR("IPv6 query ipassist failed on %s\n",
+-			  QETH_CARD_IFNAME(card));
++		dev_err(&card->gdev->dev,
++			"Activating IPv6 support for %s failed\n",
++			QETH_CARD_IFNAME(card));
+ 		return rc;
+ 	}
+ 	rc = qeth_l3_send_simple_setassparms(card, IPA_IPV6,
+ 					  IPA_CMD_ASS_START, 3);
+ 	if (rc) {
+-		PRINT_WARN("IPv6 start assist (version 4) failed "
+-			   "on %s: 0x%x\n",
+-			   QETH_CARD_IFNAME(card), rc);
++		dev_warn(&card->gdev->dev,
++			"Activating IPv6 support for %s failed\n",
++			QETH_CARD_IFNAME(card));
+ 		return rc;
+ 	}
+ 	rc = qeth_l3_send_simple_setassparms_ipv6(card, IPA_IPV6,
+ 					       IPA_CMD_ASS_START);
+ 	if (rc) {
+-		PRINT_WARN("IPV6 start assist (version 6) failed  "
+-			   "on %s: 0x%x\n",
+-			   QETH_CARD_IFNAME(card), rc);
++		dev_warn(&card->gdev->dev,
++			"Activating IPv6 support for %s failed\n",
++			 QETH_CARD_IFNAME(card));
+ 		return rc;
+ 	}
+ 	rc = qeth_l3_send_simple_setassparms_ipv6(card, IPA_PASSTHRU,
+ 					       IPA_CMD_ASS_START);
+ 	if (rc) {
+-		PRINT_WARN("Could not enable passthrough "
+-			   "on %s: 0x%x\n",
+-			   QETH_CARD_IFNAME(card), rc);
++		dev_warn(&card->gdev->dev,
++			"Enabling the passthrough mode for %s failed\n",
++			QETH_CARD_IFNAME(card));
+ 		return rc;
+ 	}
+ out:
+-	PRINT_INFO("IPV6 enabled \n");
++	dev_info(&card->gdev->dev, "IPV6 enabled\n");
+ 	return 0;
+ }
+ #endif
+@@ -1356,8 +1363,8 @@ static int qeth_l3_start_ipa_ipv6(struct
+ 	QETH_DBF_TEXT(TRACE, 3, "strtipv6");
+ 
+ 	if (!qeth_is_supported(card, IPA_IPV6)) {
+-		PRINT_WARN("IPv6 not supported on %s\n",
+-			   QETH_CARD_IFNAME(card));
++		dev_info(&card->gdev->dev,
++			"IPv6 not supported on %s\n", QETH_CARD_IFNAME(card));
+ 		return 0;
+ 	}
+ #ifdef CONFIG_QETH_IPV6
+@@ -1373,34 +1380,35 @@ static int qeth_l3_start_ipa_broadcast(s
+ 	QETH_DBF_TEXT(TRACE, 3, "stbrdcst");
+ 	card->info.broadcast_capable = 0;
+ 	if (!qeth_is_supported(card, IPA_FILTERING)) {
+-		PRINT_WARN("Broadcast not supported on %s\n",
+-			   QETH_CARD_IFNAME(card));
++		dev_info(&card->gdev->dev,
++			"Broadcast not supported on %s\n",
++			QETH_CARD_IFNAME(card));
+ 		rc = -EOPNOTSUPP;
+ 		goto out;
+ 	}
+ 	rc = qeth_l3_send_simple_setassparms(card, IPA_FILTERING,
+ 					  IPA_CMD_ASS_START, 0);
+ 	if (rc) {
+-		PRINT_WARN("Could not enable broadcasting filtering "
+-			   "on %s: 0x%x\n",
+-			   QETH_CARD_IFNAME(card), rc);
++		dev_warn(&card->gdev->dev, "Enabling broadcast filtering for "
++			"%s failed\n", QETH_CARD_IFNAME(card));
+ 		goto out;
+ 	}
+ 
+ 	rc = qeth_l3_send_simple_setassparms(card, IPA_FILTERING,
+ 					  IPA_CMD_ASS_CONFIGURE, 1);
+ 	if (rc) {
+-		PRINT_WARN("Could not set up broadcast filtering on %s: 0x%x\n",
+-			   QETH_CARD_IFNAME(card), rc);
++		dev_warn(&card->gdev->dev,
++			"Setting up broadcast filtering for %s failed\n",
++			QETH_CARD_IFNAME(card));
+ 		goto out;
+ 	}
+ 	card->info.broadcast_capable = QETH_BROADCAST_WITH_ECHO;
+-	PRINT_INFO("Broadcast enabled \n");
++	dev_info(&card->gdev->dev, "Broadcast enabled\n");
+ 	rc = qeth_l3_send_simple_setassparms(card, IPA_FILTERING,
+ 					  IPA_CMD_ASS_ENABLE, 1);
+ 	if (rc) {
+-		PRINT_WARN("Could not set up broadcast echo filtering on "
+-			   "%s: 0x%x\n", QETH_CARD_IFNAME(card), rc);
++		dev_warn(&card->gdev->dev, "Setting up broadcast echo "
++			"filtering for %s failed\n", QETH_CARD_IFNAME(card));
+ 		goto out;
+ 	}
+ 	card->info.broadcast_capable = QETH_BROADCAST_WITHOUT_ECHO;
+@@ -1419,18 +1427,18 @@ static int qeth_l3_send_checksum_command
+ 	rc = qeth_l3_send_simple_setassparms(card, IPA_INBOUND_CHECKSUM,
+ 					  IPA_CMD_ASS_START, 0);
+ 	if (rc) {
+-		PRINT_WARN("Starting Inbound HW Checksumming failed on %s: "
+-			   "0x%x,\ncontinuing using Inbound SW Checksumming\n",
+-			   QETH_CARD_IFNAME(card), rc);
++		dev_warn(&card->gdev->dev, "Starting HW checksumming for %s "
++			"failed, using SW checksumming\n",
++			QETH_CARD_IFNAME(card));
+ 		return rc;
+ 	}
+ 	rc = qeth_l3_send_simple_setassparms(card, IPA_INBOUND_CHECKSUM,
+ 					  IPA_CMD_ASS_ENABLE,
+ 					  card->info.csum_mask);
+ 	if (rc) {
+-		PRINT_WARN("Enabling Inbound HW Checksumming failed on %s: "
+-			   "0x%x,\ncontinuing using Inbound SW Checksumming\n",
+-			   QETH_CARD_IFNAME(card), rc);
++		dev_warn(&card->gdev->dev, "Enabling HW checksumming for %s "
++			"failed, using SW checksumming\n",
++			QETH_CARD_IFNAME(card));
+ 		return rc;
+ 	}
+ 	return 0;
+@@ -1443,26 +1451,30 @@ static int qeth_l3_start_ipa_checksum(st
+ 	QETH_DBF_TEXT(TRACE, 3, "strtcsum");
+ 
+ 	if (card->options.checksum_type == NO_CHECKSUMMING) {
+-		PRINT_WARN("Using no checksumming on %s.\n",
+-			   QETH_CARD_IFNAME(card));
++		dev_info(&card->gdev->dev,
++			"Using no checksumming on %s.\n",
++			QETH_CARD_IFNAME(card));
+ 		return 0;
+ 	}
+ 	if (card->options.checksum_type == SW_CHECKSUMMING) {
+-		PRINT_WARN("Using SW checksumming on %s.\n",
+-			   QETH_CARD_IFNAME(card));
++		dev_info(&card->gdev->dev,
++			"Using SW checksumming on %s.\n",
++			QETH_CARD_IFNAME(card));
+ 		return 0;
+ 	}
+ 	if (!qeth_is_supported(card, IPA_INBOUND_CHECKSUM)) {
+-		PRINT_WARN("Inbound HW Checksumming not "
+-			   "supported on %s,\ncontinuing "
+-			   "using Inbound SW Checksumming\n",
+-			   QETH_CARD_IFNAME(card));
++		dev_info(&card->gdev->dev,
++			"Inbound HW Checksumming not "
++			"supported on %s,\ncontinuing "
++			"using Inbound SW Checksumming\n",
++			QETH_CARD_IFNAME(card));
+ 		card->options.checksum_type = SW_CHECKSUMMING;
+ 		return 0;
+ 	}
+ 	rc = qeth_l3_send_checksum_command(card);
+ 	if (!rc)
+-		PRINT_INFO("HW Checksumming (inbound) enabled \n");
++		dev_info(&card->gdev->dev,
++			"HW Checksumming (inbound) enabled\n");
+ 
+ 	return rc;
+ }
+@@ -1474,18 +1486,20 @@ static int qeth_l3_start_ipa_tso(struct 
+ 	QETH_DBF_TEXT(TRACE, 3, "sttso");
+ 
+ 	if (!qeth_is_supported(card, IPA_OUTBOUND_TSO)) {
+-		PRINT_WARN("Outbound TSO not supported on %s\n",
+-			   QETH_CARD_IFNAME(card));
++		dev_info(&card->gdev->dev,
++			"Outbound TSO not supported on %s\n",
++			QETH_CARD_IFNAME(card));
+ 		rc = -EOPNOTSUPP;
+ 	} else {
+ 		rc = qeth_l3_send_simple_setassparms(card, IPA_OUTBOUND_TSO,
+ 						IPA_CMD_ASS_START, 0);
+ 		if (rc)
+-			PRINT_WARN("Could not start outbound TSO "
+-				   "assist on %s: rc=%i\n",
+-				   QETH_CARD_IFNAME(card), rc);
++			dev_warn(&card->gdev->dev, "Starting outbound TCP "
++				"segmentation offload for %s failed\n",
++				QETH_CARD_IFNAME(card));
+ 		else
+-			PRINT_INFO("Outbound TSO enabled\n");
++			dev_info(&card->gdev->dev,
++				"Outbound TSO enabled\n");
+ 	}
+ 	if (rc && (card->options.large_send == QETH_LARGE_SEND_TSO)) {
+ 		card->options.large_send = QETH_LARGE_SEND_NO;
+@@ -1578,12 +1592,8 @@ static int qeth_l3_get_unique_id_cb(stru
+ 	else {
+ 		card->info.unique_id =  UNIQUE_ID_IF_CREATE_ADDR_FAILED |
+ 					UNIQUE_ID_NOT_BY_CARD;
+-		PRINT_WARN("couldn't get a unique id from the card on device "
+-			   "%s (result=x%x), using default id. ipv6 "
+-			   "autoconfig on other lpars may lead to duplicate "
+-			   "ip addresses. please use manually "
+-			   "configured ones.\n",
+-			   CARD_BUS_ID(card), cmd->hdr.return_code);
++		dev_warn(&card->gdev->dev, "The network adapter failed to "
++			"generate a unique ID\n");
+ 	}
+ 	return 0;
+ }
+@@ -3086,9 +3096,8 @@ static int __qeth_l3_set_online(struct c
+ 	if (rc) {
+ 		QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc);
+ 		if (rc == 0xe080) {
+-			PRINT_WARN("LAN on card %s if offline! "
+-				   "Waiting for STARTLAN from card.\n",
+-				   CARD_BUS_ID(card));
++			dev_warn(&card->gdev->dev,
++				"The LAN is offline\n");
+ 			card->lan_online = 0;
+ 		}
+ 		return rc;
+@@ -3194,8 +3203,8 @@ static int qeth_l3_recover(void *ptr)
+ 	if (!qeth_do_run_thread(card, QETH_RECOVER_THREAD))
+ 		return 0;
+ 	QETH_DBF_TEXT(TRACE, 2, "recover2");
+-	PRINT_WARN("Recovery of device %s started ...\n",
+-		   CARD_BUS_ID(card));
++	dev_warn(&card->gdev->dev,
++		"A recovery process has been started for the device\n");
+ 	card->use_hard_stop = 1;
+ 	__qeth_l3_set_offline(card->gdev, 1);
+ 	rc = __qeth_l3_set_online(card->gdev, 1);
+@@ -3203,14 +3212,14 @@ static int qeth_l3_recover(void *ptr)
+ 	qeth_clear_thread_start_bit(card, QETH_RECOVER_THREAD);
+ 	qeth_clear_thread_running_bit(card, QETH_RECOVER_THREAD);
+ 	if (!rc)
+-		PRINT_INFO("Device %s successfully recovered!\n",
+-			   CARD_BUS_ID(card));
++		dev_info(&card->gdev->dev,
++			"Device successfully recovered!\n");
+ 	else {
+ 		rtnl_lock();
+ 		dev_close(card->dev);
+ 		rtnl_unlock();
+-		PRINT_INFO("Device %s could not be recovered!\n",
+-			   CARD_BUS_ID(card));
++		dev_warn(&card->gdev->dev, "The qeth device driver "
++			"failed to recover an error on the device\n");
+ 	}
+ 	return 0;
+ }
+@@ -3344,7 +3353,7 @@ static int qeth_l3_register_notifiers(vo
+ 		return rc;
+ 	}
+ #else
+-	PRINT_WARN("layer 3 discipline no IPv6 support\n");
++	pr_warning("There is no IPv6 support for the layer 3 discipline\n");
+ #endif
+ 	return 0;
+ }
+@@ -3363,7 +3372,7 @@ static int __init qeth_l3_init(void)
+ {
+ 	int rc = 0;
+ 
+-	PRINT_INFO("register layer 3 discipline\n");
++	pr_info("register layer 3 discipline\n");
+ 	rc = qeth_l3_register_notifiers();
+ 	return rc;
+ }
+@@ -3371,7 +3380,7 @@ static int __init qeth_l3_init(void)
+ static void __exit qeth_l3_exit(void)
+ {
+ 	qeth_l3_unregister_notifiers();
+-	PRINT_INFO("unregister layer 3 discipline\n");
++	pr_info("unregister layer 3 discipline\n");
+ }
+ 
+ module_init(qeth_l3_init);
+Index: linux-2.6.27-gentoo-r7/drivers/s390/scsi/zfcp_aux.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/scsi/zfcp_aux.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/scsi/zfcp_aux.c
+@@ -25,7 +25,11 @@
+  *            Sven Schuetz
+  */
+ 
++#define KMSG_COMPONENT "zfcp"
++#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
++
+ #include <linux/miscdevice.h>
++#include <linux/seq_file.h>
+ #include "zfcp_ext.h"
+ 
+ static char *device;
+@@ -100,7 +104,7 @@ static int __init zfcp_device_setup(char
+ 
+  err_out:
+ 	kfree(str);
+-	pr_err("zfcp: %s is not a valid SCSI device\n", devstr);
++	pr_err("%s is not a valid SCSI device\n", devstr);
+ 	return 0;
+ }
+ 
+@@ -184,13 +188,13 @@ static int __init zfcp_module_init(void)
+ 
+ 	retval = misc_register(&zfcp_cfdc_misc);
+ 	if (retval) {
+-		pr_err("zfcp: Registering the misc device zfcp_cfdc failed\n");
++		pr_err("Registering the misc device zfcp_cfdc failed\n");
+ 		goto out_misc;
+ 	}
+ 
+ 	retval = zfcp_ccw_register();
+ 	if (retval) {
+-		pr_err("zfcp: The zfcp device driver could not register with "
++		pr_err("The zfcp device driver could not register with "
+ 		       "the common I/O layer\n");
+ 		goto out_ccw_register;
+ 	}
+@@ -434,6 +438,16 @@ static void _zfcp_status_read_scheduler(
+ 					     stat_work));
+ }
+ 
++static void zfcp_print_sl(struct seq_file *m, struct service_level *sl)
++{
++	struct zfcp_adapter *adapter =
++		container_of(sl, struct zfcp_adapter, service_level);
++
++	seq_printf(m, "zfcp: %s microcode level %x\n",
++		   dev_name(&adapter->ccw_device->dev),
++		   adapter->fsf_lic_version);
++}
++
+ /**
+  * zfcp_adapter_enqueue - enqueue a new adapter to the list
+  * @ccw_device: pointer to the struct cc_device
+@@ -498,6 +512,8 @@ int zfcp_adapter_enqueue(struct ccw_devi
+ 	INIT_WORK(&adapter->stat_work, _zfcp_status_read_scheduler);
+ 	INIT_WORK(&adapter->scan_work, _zfcp_scan_ports_later);
+ 
++	adapter->service_level.seq_print = zfcp_print_sl;
++
+ 	/* mark adapter unusable as long as sysfs registration is not complete */
+ 	atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &adapter->status);
+ 
+Index: linux-2.6.27-gentoo-r7/drivers/s390/scsi/zfcp_ccw.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/scsi/zfcp_ccw.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/scsi/zfcp_ccw.c
+@@ -6,6 +6,9 @@
+  * Copyright IBM Corporation 2002, 2008
+  */
+ 
++#define KMSG_COMPONENT "zfcp"
++#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
++
+ #include "zfcp_ext.h"
+ 
+ /**
+Index: linux-2.6.27-gentoo-r7/drivers/s390/scsi/zfcp_cfdc.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/scsi/zfcp_cfdc.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/scsi/zfcp_cfdc.c
+@@ -7,6 +7,9 @@
+  * Copyright IBM Corporation 2008
+  */
+ 
++#define KMSG_COMPONENT "zfcp"
++#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
++
+ #include <linux/types.h>
+ #include <linux/miscdevice.h>
+ #include <asm/ccwdev.h>
+Index: linux-2.6.27-gentoo-r7/drivers/s390/scsi/zfcp_dbf.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/scsi/zfcp_dbf.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/scsi/zfcp_dbf.c
+@@ -6,6 +6,9 @@
+  * Copyright IBM Corporation 2002, 2008
+  */
+ 
++#define KMSG_COMPONENT "zfcp"
++#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
++
+ #include <linux/ctype.h>
+ #include <asm/debug.h>
+ #include "zfcp_ext.h"
+Index: linux-2.6.27-gentoo-r7/drivers/s390/scsi/zfcp_def.h
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/scsi/zfcp_def.h
++++ linux-2.6.27-gentoo-r7/drivers/s390/scsi/zfcp_def.h
+@@ -33,6 +33,7 @@
+ #include <asm/qdio.h>
+ #include <asm/debug.h>
+ #include <asm/ebcdic.h>
++#include <asm/sysinfo.h>
+ #include "zfcp_dbf.h"
+ #include "zfcp_fsf.h"
+ 
+@@ -515,6 +516,7 @@ struct zfcp_adapter {
+ 	struct fsf_qtcb_bottom_port *stats_reset_data;
+ 	unsigned long		stats_reset;
+ 	struct work_struct	scan_work;
++	struct service_level	service_level;
+ 	atomic_t		qdio_outb_full;	   /* queue full incidents */
+ };
+ 
+@@ -583,6 +585,8 @@ struct zfcp_fsf_req {
+ 	unsigned long long     issued;         /* request sent time (STCK) */
+ 	struct zfcp_unit       *unit;
+ 	void			(*handler)(struct zfcp_fsf_req *);
++	u16			qdio_outb_usage;/* usage of outbound queue */
++	u16			qdio_inb_usage;	/* usage of inbound queue */
+ };
+ 
+ /* driver data */
+Index: linux-2.6.27-gentoo-r7/drivers/s390/scsi/zfcp_erp.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/scsi/zfcp_erp.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/scsi/zfcp_erp.c
+@@ -6,6 +6,9 @@
+  * Copyright IBM Corporation 2002, 2008
+  */
+ 
++#define KMSG_COMPONENT "zfcp"
++#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
++
+ #include "zfcp_ext.h"
+ 
+ #define ZFCP_MAX_ERPS                   3
+@@ -1282,8 +1285,11 @@ static void zfcp_erp_action_cleanup(stru
+ 		break;
+ 
+ 	case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
+-		if (result != ZFCP_ERP_SUCCEEDED)
++		if (result != ZFCP_ERP_SUCCEEDED) {
++			unregister_service_level(&adapter->service_level);
+ 			zfcp_erp_rports_del(adapter);
++		} else
++			register_service_level(&adapter->service_level);
+ 		zfcp_adapter_put(adapter);
+ 		break;
+ 	}
+Index: linux-2.6.27-gentoo-r7/drivers/s390/scsi/zfcp_fc.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/scsi/zfcp_fc.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/scsi/zfcp_fc.c
+@@ -6,6 +6,9 @@
+  * Copyright IBM Corporation 2008
+  */
+ 
++#define KMSG_COMPONENT "zfcp"
++#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
++
+ #include "zfcp_ext.h"
+ 
+ struct ct_iu_gpn_ft_req {
+Index: linux-2.6.27-gentoo-r7/drivers/s390/scsi/zfcp_fsf.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/scsi/zfcp_fsf.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/scsi/zfcp_fsf.c
+@@ -6,6 +6,10 @@
+  * Copyright IBM Corporation 2002, 2008
+  */
+ 
++#define KMSG_COMPONENT "zfcp"
++#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
++
++#include <linux/blktrace_api.h>
+ #include "zfcp_ext.h"
+ 
+ static void zfcp_fsf_request_timeout_handler(unsigned long data)
+@@ -778,6 +782,7 @@ static int zfcp_fsf_req_send(struct zfcp
+ 	list_add_tail(&req->list, &adapter->req_list[idx]);
+ 	spin_unlock_irqrestore(&adapter->req_list_lock, flags);
+ 
++	req->qdio_outb_usage = atomic_read(&req_q->count);
+ 	req->issued = get_clock();
+ 	if (zfcp_qdio_send(req)) {
+ 		del_timer(&req->timer);
+@@ -2079,6 +2084,36 @@ static void zfcp_fsf_req_latency(struct 
+ 	spin_unlock_irqrestore(&unit->latencies.lock, flags);
+ }
+ 
++#ifdef CONFIG_BLK_DEV_IO_TRACE
++static void zfcp_fsf_trace_latency(struct zfcp_fsf_req *fsf_req)
++{
++	struct fsf_qual_latency_info *lat_inf;
++	struct scsi_cmnd *scsi_cmnd = (struct scsi_cmnd *)fsf_req->data;
++	struct request *req = scsi_cmnd->request;
++	struct zfcp_blk_drv_data trace;
++	int ticks = fsf_req->adapter->timer_ticks;
++
++	trace.flags = 0;
++	trace.magic = ZFCP_BLK_DRV_DATA_MAGIC;
++	if (fsf_req->adapter->adapter_features & FSF_FEATURE_MEASUREMENT_DATA) {
++		trace.flags |= ZFCP_BLK_LAT_VALID;
++		lat_inf = &fsf_req->qtcb->prefix.prot_status_qual.latency_info;
++		trace.channel_lat = lat_inf->channel_lat * ticks;
++		trace.fabric_lat = lat_inf->fabric_lat * ticks;
++	}
++	if (fsf_req->status & ZFCP_STATUS_FSFREQ_ERROR)
++		trace.flags |= ZFCP_BLK_REQ_ERROR;
++	trace.inb_usage = fsf_req->qdio_inb_usage;
++	trace.outb_usage = fsf_req->qdio_outb_usage;
++
++	blk_add_driver_data(req->q, req, &trace, sizeof(trace));
++}
++#else
++static inline void zfcp_fsf_trace_latency(struct zfcp_fsf_req *fsf_req)
++{
++}
++#endif
++
+ static void zfcp_fsf_send_fcp_command_task_handler(struct zfcp_fsf_req *req)
+ {
+ 	struct scsi_cmnd *scpnt;
+@@ -2114,6 +2149,8 @@ static void zfcp_fsf_send_fcp_command_ta
+ 	if (req->adapter->adapter_features & FSF_FEATURE_MEASUREMENT_DATA)
+ 		zfcp_fsf_req_latency(req);
+ 
++	zfcp_fsf_trace_latency(req);
++
+ 	if (unlikely(fcp_rsp_iu->validity.bits.fcp_rsp_len_valid)) {
+ 		if (fcp_rsp_info[3] == RSP_CODE_GOOD)
+ 			set_host_byte(scpnt, DID_OK);
+Index: linux-2.6.27-gentoo-r7/drivers/s390/scsi/zfcp_fsf.h
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/scsi/zfcp_fsf.h
++++ linux-2.6.27-gentoo-r7/drivers/s390/scsi/zfcp_fsf.h
+@@ -439,4 +439,16 @@ struct fsf_qtcb {
+ 	u8 log[FSF_QTCB_LOG_SIZE];
+ } __attribute__ ((packed));
+ 
++struct zfcp_blk_drv_data {
++#define ZFCP_BLK_DRV_DATA_MAGIC			0x1
++	u32 magic;
++#define ZFCP_BLK_LAT_VALID			0x1
++#define ZFCP_BLK_REQ_ERROR			0x2
++	u16 flags;
++	u8 inb_usage;
++	u8 outb_usage;
++	u64 channel_lat;
++	u64 fabric_lat;
++} __attribute__ ((packed));
++
+ #endif				/* FSF_H */
+Index: linux-2.6.27-gentoo-r7/drivers/s390/scsi/zfcp_qdio.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/scsi/zfcp_qdio.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/scsi/zfcp_qdio.c
+@@ -6,6 +6,9 @@
+  * Copyright IBM Corporation 2002, 2008
+  */
+ 
++#define KMSG_COMPONENT "zfcp"
++#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
++
+ #include "zfcp_ext.h"
+ 
+ /* FIXME(tune): free space should be one max. SBAL chain plus what? */
+@@ -115,6 +118,7 @@ static void zfcp_qdio_reqid_check(struct
+ 	spin_unlock_irqrestore(&adapter->req_list_lock, flags);
+ 
+ 	fsf_req->sbal_response = sbal_idx;
++	fsf_req->qdio_inb_usage = atomic_read(&adapter->resp_q.count);
+ 	zfcp_fsf_req_complete(fsf_req);
+ }
+ 
+Index: linux-2.6.27-gentoo-r7/drivers/s390/scsi/zfcp_scsi.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/scsi/zfcp_scsi.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/scsi/zfcp_scsi.c
+@@ -6,6 +6,9 @@
+  * Copyright IBM Corporation 2002, 2008
+  */
+ 
++#define KMSG_COMPONENT "zfcp"
++#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
++
+ #include "zfcp_ext.h"
+ #include <asm/atomic.h>
+ 
+Index: linux-2.6.27-gentoo-r7/drivers/s390/scsi/zfcp_sysfs.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/scsi/zfcp_sysfs.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/scsi/zfcp_sysfs.c
+@@ -6,6 +6,9 @@
+  * Copyright IBM Corporation 2008
+  */
+ 
++#define KMSG_COMPONENT "zfcp"
++#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
++
+ #include "zfcp_ext.h"
+ 
+ #define ZFCP_DEV_ATTR(_feat, _name, _mode, _show, _store) \
+Index: linux-2.6.27-gentoo-r7/drivers/s390/sysinfo.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/drivers/s390/sysinfo.c
++++ linux-2.6.27-gentoo-r7/drivers/s390/sysinfo.c
+@@ -1,17 +1,21 @@
+ /*
+  *  drivers/s390/sysinfo.c
+  *
+- *    Copyright (C) 2001 IBM Deutschland Entwicklung GmbH, IBM Corporation
+- *    Author(s): Ulrich Weigand (Ulrich.Weigand@××××××.com)
++ *  Copyright IBM Corp. 2001, 2008
++ *  Author(s): Ulrich Weigand (Ulrich.Weigand@××××××.com)
++ *	       Martin Schwidefsky <schwidefsky@××××××.com>
+  */
+ 
+ #include <linux/kernel.h>
+ #include <linux/mm.h>
+ #include <linux/proc_fs.h>
++#include <linux/seq_file.h>
+ #include <linux/init.h>
+ #include <linux/delay.h>
++#include <linux/module.h>
+ #include <asm/ebcdic.h>
+ #include <asm/sysinfo.h>
++#include <asm/cpcmd.h>
+ 
+ /* Sigh, math-emu. Don't ask. */
+ #include <asm/sfp-util.h>
+@@ -271,6 +275,125 @@ static __init int create_proc_sysinfo(vo
+ 
+ __initcall(create_proc_sysinfo);
+ 
++/*
++ * Service levels interface.
++ */
++
++static DECLARE_RWSEM(service_level_sem);
++static LIST_HEAD(service_level_list);
++
++int register_service_level(struct service_level *slr)
++{
++	struct service_level *ptr;
++
++	down_write(&service_level_sem);
++	list_for_each_entry(ptr, &service_level_list, list)
++		if (ptr == slr) {
++			up_write(&service_level_sem);
++			return -EEXIST;
++		}
++	list_add_tail(&slr->list, &service_level_list);
++	up_write(&service_level_sem);
++	return 0;
++}
++EXPORT_SYMBOL(register_service_level);
++
++int unregister_service_level(struct service_level *slr)
++{
++	struct service_level *ptr, *next;
++	int rc = -ENOENT;
++
++	down_write(&service_level_sem);
++	list_for_each_entry_safe(ptr, next, &service_level_list, list) {
++		if (ptr != slr)
++			continue;
++		list_del(&ptr->list);
++		rc = 0;
++		break;
++	}
++	up_write(&service_level_sem);
++	return rc;
++}
++EXPORT_SYMBOL(unregister_service_level);
++
++static void *service_level_start(struct seq_file *m, loff_t *pos)
++{
++	down_read(&service_level_sem);
++	return seq_list_start(&service_level_list, *pos);
++}
++
++static void *service_level_next(struct seq_file *m, void *p, loff_t *pos)
++{
++	return seq_list_next(p, &service_level_list, pos);
++}
++
++static void service_level_stop(struct seq_file *m, void *p)
++{
++	up_read(&service_level_sem);
++}
++
++static int service_level_show(struct seq_file *m, void *p)
++{
++	struct service_level *slr;
++
++	slr = list_entry(p, struct service_level, list);
++	slr->seq_print(m, slr);
++	return 0;
++}
++
++static const struct seq_operations service_level_seq_ops = {
++	.start		= service_level_start,
++	.next		= service_level_next,
++	.stop		= service_level_stop,
++	.show		= service_level_show
++};
++
++static int service_level_open(struct inode *inode, struct file *file)
++{
++	return seq_open(file, &service_level_seq_ops);
++}
++
++static const struct file_operations service_level_ops = {
++	.open		= service_level_open,
++	.read		= seq_read,
++	.llseek 	= seq_lseek,
++	.release	= seq_release
++};
++
++static void service_level_vm_print(struct seq_file *m,
++				   struct service_level *slr)
++{
++	char *query_buffer, *str;
++
++	query_buffer = kmalloc(1024, GFP_KERNEL | GFP_DMA);
++	if (!query_buffer)
++		return;
++	cpcmd("QUERY CPLEVEL", query_buffer, 1024, NULL);
++	str = strchr(query_buffer, '\n');
++	if (str)
++		*str = 0;
++	seq_printf(m, "VM: %s\n", query_buffer);
++	kfree(query_buffer);
++}
++
++static struct service_level service_level_vm = {
++	.seq_print = service_level_vm_print
++};
++
++static __init int create_proc_service_level(void)
++{
++	proc_create("service_levels", 0, NULL, &service_level_ops);
++	if (MACHINE_IS_VM)
++		register_service_level(&service_level_vm);
++	return 0;
++}
++
++subsys_initcall(create_proc_service_level);
++
++/*
++ * Bogomips calculation based on cpu capability.
++ */
++
+ int get_cpu_capability(unsigned int *capability)
+ {
+ 	struct sysinfo_1_2_2 *info;
+Index: linux-2.6.27-gentoo-r7/include/linux/blktrace_api.h
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/include/linux/blktrace_api.h
++++ linux-2.6.27-gentoo-r7/include/linux/blktrace_api.h
+@@ -21,6 +21,7 @@ enum blktrace_cat {
+ 	BLK_TC_NOTIFY	= 1 << 10,	/* special message */
+ 	BLK_TC_AHEAD	= 1 << 11,	/* readahead */
+ 	BLK_TC_META	= 1 << 12,	/* metadata */
++	BLK_TC_DRV_DATA = 1 << 14,      /* binary per-driver data */
+ 
+ 	BLK_TC_END	= 1 << 15,	/* only 16-bits, reminder */
+ };
+@@ -47,6 +48,7 @@ enum blktrace_act {
+ 	__BLK_TA_SPLIT,			/* bio was split */
+ 	__BLK_TA_BOUNCE,		/* bio was bounced */
+ 	__BLK_TA_REMAP,			/* bio was remapped */
++	__BLK_TA_DRV_DATA,              /* driver-specific binary data */
+ };
+ 
+ /*
+@@ -77,6 +79,7 @@ enum blktrace_notify {
+ #define BLK_TA_SPLIT		(__BLK_TA_SPLIT)
+ #define BLK_TA_BOUNCE		(__BLK_TA_BOUNCE)
+ #define BLK_TA_REMAP		(__BLK_TA_REMAP | BLK_TC_ACT(BLK_TC_QUEUE))
++#define BLK_TA_DRV_DATA        (__BLK_TA_DRV_DATA | BLK_TC_ACT(BLK_TC_DRV_DATA))
+ 
+ #define BLK_TN_PROCESS		(__BLK_TN_PROCESS | BLK_TC_ACT(BLK_TC_NOTIFY))
+ #define BLK_TN_TIMESTAMP	(__BLK_TN_TIMESTAMP | BLK_TC_ACT(BLK_TC_NOTIFY))
+@@ -307,6 +310,34 @@ static inline void blk_add_trace_remap(s
+ 	__blk_add_trace(bt, from, bio->bi_size, bio->bi_rw, BLK_TA_REMAP, !bio_flagged(bio, BIO_UPTODATE), sizeof(r), &r);
+ }
+ 
++/**
++ * blk_add_driver_data - Add binary message with driver-specific data
++ * @q:		queue the io is for
++ * @rq:		io request
++ * @data:	driver-specific data
++ * @len:	length of driver-specific data
++ *
++ * Description:
++ *     Some drivers might want to write driver-specific data per request.
++ *
++ **/
++static inline void blk_add_driver_data(struct request_queue *q,
++				       struct request *rq,
++				       void *data, size_t len)
++{
++	struct blk_trace *bt = q->blk_trace;
++
++	if (likely(!bt))
++		return;
++
++	if (blk_pc_request(rq))
++		__blk_add_trace(bt, 0, rq->data_len, 0, BLK_TA_DRV_DATA,
++				rq->errors, len, data);
++	else
++		__blk_add_trace(bt, rq->hard_sector, rq->hard_nr_sectors << 9,
++				0, BLK_TA_DRV_DATA, rq->errors, len, data);
++}
++
+ extern int blk_trace_setup(struct request_queue *q, char *name, dev_t dev,
+ 			   char __user *arg);
+ extern int blk_trace_startstop(struct request_queue *q, int start);
+@@ -320,6 +351,7 @@ extern int blk_trace_remove(struct reque
+ #define blk_add_trace_generic(q, rq, rw, what)	do { } while (0)
+ #define blk_add_trace_pdu_int(q, what, bio, pdu)	do { } while (0)
+ #define blk_add_trace_remap(q, bio, dev, f, t)	do {} while (0)
++#define blk_add_driver_data(q, rq, data, len)	do {} while (0)
+ #define do_blk_trace_setup(q, name, dev, buts)	(-ENOTTY)
+ #define blk_trace_setup(q, name, dev, arg)	(-ENOTTY)
+ #define blk_trace_startstop(q, start)		(-ENOTTY)
+Index: linux-2.6.27-gentoo-r7/include/linux/kernel.h
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/include/linux/kernel.h
++++ linux-2.6.27-gentoo-r7/include/linux/kernel.h
+@@ -288,28 +288,32 @@ static inline char *pack_hex_byte(char *
+ 	return buf;
+ }
+ 
+-#define pr_emerg(fmt, arg...) \
+-	printk(KERN_EMERG fmt, ##arg)
+-#define pr_alert(fmt, arg...) \
+-	printk(KERN_ALERT fmt, ##arg)
+-#define pr_crit(fmt, arg...) \
+-	printk(KERN_CRIT fmt, ##arg)
+-#define pr_err(fmt, arg...) \
+-	printk(KERN_ERR fmt, ##arg)
+-#define pr_warning(fmt, arg...) \
+-	printk(KERN_WARNING fmt, ##arg)
+-#define pr_notice(fmt, arg...) \
+-	printk(KERN_NOTICE fmt, ##arg)
+-#define pr_info(fmt, arg...) \
+-	printk(KERN_INFO fmt, ##arg)
++#ifndef pr_fmt
++#define pr_fmt(fmt) fmt
++#endif
++
++#define pr_emerg(fmt, ...) \
++        printk(KERN_EMERG pr_fmt(fmt), ##__VA_ARGS__)
++#define pr_alert(fmt, ...) \
++        printk(KERN_ALERT pr_fmt(fmt), ##__VA_ARGS__)
++#define pr_crit(fmt, ...) \
++        printk(KERN_CRIT pr_fmt(fmt), ##__VA_ARGS__)
++#define pr_err(fmt, ...) \
++        printk(KERN_ERR pr_fmt(fmt), ##__VA_ARGS__)
++#define pr_warning(fmt, ...) \
++        printk(KERN_WARNING pr_fmt(fmt), ##__VA_ARGS__)
++#define pr_notice(fmt, ...) \
++        printk(KERN_NOTICE pr_fmt(fmt), ##__VA_ARGS__)
++#define pr_info(fmt, ...) \
++        printk(KERN_INFO pr_fmt(fmt), ##__VA_ARGS__)
+ 
+ #ifdef DEBUG
+ /* If you are writing a driver, please use dev_dbg instead */
+-#define pr_debug(fmt, arg...) \
+-	printk(KERN_DEBUG fmt, ##arg)
++#define pr_debug(fmt, ...) \
++	printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__)
+ #else
+-#define pr_debug(fmt, arg...) \
+-	({ if (0) printk(KERN_DEBUG fmt, ##arg); 0; })
++#define pr_debug(fmt, ...) \
++	({ if (0) printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__); 0; })
+ #endif
+ 
+ /*
+Index: linux-2.6.27-gentoo-r7/net/iucv/af_iucv.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/net/iucv/af_iucv.c
++++ linux-2.6.27-gentoo-r7/net/iucv/af_iucv.c
+@@ -8,6 +8,9 @@
+  *  Author(s):	Jennifer Hunt <jenhunt@××××××.com>
+  */
+ 
++#define KMSG_COMPONENT "af_iucv"
++#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
++
+ #include <linux/module.h>
+ #include <linux/types.h>
+ #include <linux/list.h>
+@@ -616,6 +619,8 @@ static int iucv_sock_sendmsg(struct kioc
+ 	struct iucv_sock *iucv = iucv_sk(sk);
+ 	struct sk_buff *skb;
+ 	struct iucv_message txmsg;
++	char user_id[9];
++	char appl_id[9];
+ 	int err;
+ 
+ 	err = sock_error(sk);
+@@ -651,8 +656,15 @@ static int iucv_sock_sendmsg(struct kioc
+ 		err = iucv_message_send(iucv->path, &txmsg, 0, 0,
+ 					(void *) skb->data, skb->len);
+ 		if (err) {
+-			if (err == 3)
+-				printk(KERN_ERR "AF_IUCV msg limit exceeded\n");
++			if (err == 3) {
++				user_id[8] = 0;
++				memcpy(user_id, iucv->dst_user_id, 8);
++				appl_id[8] = 0;
++				memcpy(appl_id, iucv->dst_name, 8);
++				pr_err("Application %s on z/VM guest %s"
++				       " exceeds message limit\n",
++				       user_id, appl_id);
++			}
+ 			skb_unlink(skb, &iucv->send_skb_q);
+ 			err = -EPIPE;
+ 			goto fail;
+@@ -1190,7 +1202,8 @@ static int __init afiucv_init(void)
+ 	int err;
+ 
+ 	if (!MACHINE_IS_VM) {
+-		printk(KERN_ERR "AF_IUCV connection needs VM as base\n");
++		pr_err("The af_iucv module cannot be loaded"
++		       " without z/VM\n");
+ 		err = -EPROTONOSUPPORT;
+ 		goto out;
+ 	}
+Index: linux-2.6.27-gentoo-r7/net/iucv/iucv.c
+===================================================================
+--- linux-2.6.27-gentoo-r7.orig/net/iucv/iucv.c
++++ linux-2.6.27-gentoo-r7/net/iucv/iucv.c
+@@ -30,6 +30,9 @@
+  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+  */
+ 
++#define KMSG_COMPONENT "iucv"
++#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
++
+ #include <linux/module.h>
+ #include <linux/moduleparam.h>
+ #include <linux/spinlock.h>
+@@ -424,8 +427,8 @@ static void iucv_declare_cpu(void *data)
+ 			err = "Paging or storage error";
+ 			break;
+ 		}
+-		printk(KERN_WARNING "iucv_register: iucv_declare_buffer "
+-		       "on cpu %i returned error 0x%02x (%s)\n", cpu, rc, err);
++		pr_warning("Defining an interrupt buffer on CPU %i"
++			   " failed with 0x%02x (%s)\n", cpu, rc, err);
+ 		return;
+ 	}
+ 
+@@ -1572,7 +1575,7 @@ static void iucv_external_interrupt(u16 
+ 	BUG_ON(p->iptype  < 0x01 || p->iptype > 0x09);
+ 	work = kmalloc(sizeof(struct iucv_irq_list), GFP_ATOMIC);
+ 	if (!work) {
+-		printk(KERN_WARNING "iucv_external_interrupt: out of memory\n");
++		pr_warning("iucv_external_interrupt: out of memory\n");
+ 		return;
+ 	}
+ 	memcpy(&work->data, p, sizeof(work->data));