linux-kernel.vger.kernel.org archive mirror
 help / color / mirror / Atom feed
* [PATCH 0/9] revive the XD driver a bit
@ 2013-02-12 22:40 Linus Walleij
  2013-02-12 22:40 ` [PATCH 1/9] block: introduce a delay before every outb operation Linus Walleij
  0 siblings, 1 reply; 11+ messages in thread
From: Linus Walleij @ 2013-02-12 22:40 UTC (permalink / raw)
  To: Jens Axboe; +Cc: linux-kernel, Linus Walleij

Yes, I use this driver. I have an old PC XT 8088, and the fact
that it was in the kernel tree SAVED MY DATA.

Of course I couldn't boot Linux on that old machine. But I
removed the disk and the controller card and put it into
a Pentium MMX. The ROM on the card has to be removed or it
will kill the boot by trying to patchextends the BIOS. Then
you have to configure out the IRQ and DMA manually in the
BIOS menu.

But then you pass the controller type to the driver with
xd=3 and it *WORKS*, well after the first two patches in
this series. I proceeded to do some rough cleanups to get
it more maintainable.

Linus Walleij (9):
  block: xd: introduce a delay before every outb operation
  block: xd: fix up request handler loop
  block: xd: raise timeouts
  block: xd: some whitespace and #if 0 removal
  block: xd: avoid using typedefs
  block: xd: avoid some forward declarations
  block: xd: merge header file into driver
  block: xd: remove custom DEBUG print system
  block: xd: replace all printks with pr_*

 drivers/block/xd.c | 1202 ++++++++++++++++++++++++++++++----------------------
 drivers/block/xd.h |  134 ------
 2 files changed, 686 insertions(+), 650 deletions(-)
 delete mode 100644 drivers/block/xd.h

-- 
1.8.1.2


^ permalink raw reply	[flat|nested] 11+ messages in thread
* [PATCH 1/9] block: introduce a delay before every outb operation
  2013-02-12 22:40 [PATCH 0/9] revive the XD driver a bit Linus Walleij
@ 2013-02-12 22:40 ` Linus Walleij
  2013-02-12 22:40   ` [PATCH 1/9] block: xd: " Linus Walleij
  0 siblings, 1 reply; 11+ messages in thread
From: Linus Walleij @ 2013-02-12 22:40 UTC (permalink / raw)
  To: Jens Axboe; +Cc: linux-kernel, Linus Walleij

When I plug an ISA XT 8bit card into a 16bit compatible EISA
slot, the outb() operations seemingly stumble over each other
so we need to introduce a small delay after each outb()
operation. After this my MFM MiniScribe harddrive is properly
detected like this:

Detected 1 hard drive (using IRQ5 & DMA3)
 xda: CHS=615/4/17

Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
---
 drivers/block/xd.c | 17 +++++++++++++++--
 1 file changed, 15 insertions(+), 2 deletions(-)

diff --git a/drivers/block/xd.c b/drivers/block/xd.c
index ff54052..303e9f2 100644
--- a/drivers/block/xd.c
+++ b/drivers/block/xd.c
@@ -57,6 +57,8 @@
 
 #include "xd.h"
 
+#define OUTB_DELAY 100
+
 static DEFINE_MUTEX(xd_mutex);
 static void __init do_xd_setup (int *integers);
 #ifdef MODULE
@@ -485,7 +487,8 @@ static irqreturn_t xd_interrupt_handler(int irq, void *dev_id)
 #ifdef DEBUG_OTHER
 		printk("xd_interrupt_handler: interrupt detected\n");
 #endif /* DEBUG_OTHER */
-		outb(0,XD_CONTROL);								/* acknowledge interrupt */
+		outb(0,XD_CONTROL); /* acknowledge interrupt */
+		udelay(OUTB_DELAY);
 		wake_up(&xd_wait_int);	/* and wake up sleeping processes */
 		return IRQ_HANDLED;
 	}
@@ -588,7 +591,9 @@ static u_int xd_command (u_char *command,u_char mode,u_char *indata,u_char *outd
 #endif /* DEBUG_COMMAND */
 
 	outb(0,XD_SELECT);
+	udelay(OUTB_DELAY);
 	outb(mode,XD_CONTROL);
+	udelay(OUTB_DELAY);
 
 	if (xd_waitport(XD_STATUS,STAT_SELECT,STAT_SELECT,timeout))
 		return (1);
@@ -602,8 +607,10 @@ static u_int xd_command (u_char *command,u_char mode,u_char *indata,u_char *outd
 				if (mode == DMA_MODE) {
 					if (xd_wait_for_IRQ())
 						return (1);
-				} else
+				} else {
 					outb(outdata ? *outdata++ : 0,XD_DATA);
+					udelay(OUTB_DELAY);
+				}
 				break;
 			case STAT_INPUT:
 				if (mode == DMA_MODE) {
@@ -617,6 +624,7 @@ static u_int xd_command (u_char *command,u_char mode,u_char *indata,u_char *outd
 				break;
 			case STAT_COMMAND:
 				outb(command ? *command++ : 0,XD_DATA);
+				udelay(OUTB_DELAY);
 				break;
 			case STAT_COMMAND | STAT_INPUT:
 				complete = 1;
@@ -680,6 +688,7 @@ static void __init xd_dtc_init_controller (unsigned int address)
 	xd_maxsectors = 0x01;		/* my card seems to have trouble doing multi-block transfers? */
 
 	outb(0,XD_RESET);		/* reset the controller */
+	udelay(OUTB_DELAY);
 }
 
 
@@ -773,6 +782,7 @@ static void __init xd_wd_init_controller (unsigned int address)
 	xd_maxsectors = 0x01;		/* this one doesn't wrap properly either... */
 
 	outb(0,XD_RESET);		/* reset the controller */
+	udelay(OUTB_DELAY);
 
 	msleep(XD_INIT_DISK_DELAY);
 }
@@ -875,6 +885,7 @@ static void __init xd_seagate_init_controller (unsigned int address)
 	xd_maxsectors = 0x40;
 
 	outb(0,XD_RESET);		/* reset the controller */
+	udelay(OUTB_DELAY);
 }
 
 static void __init xd_seagate_init_drive (u_char drive)
@@ -908,6 +919,7 @@ static void __init xd_omti_init_controller (unsigned int address)
 	xd_maxsectors = 0x40;
 
 	outb(0,XD_RESET);		/* reset the controller */
+	udelay(OUTB_DELAY);
 }
 
 static void __init xd_omti_init_drive (u_char drive)
@@ -947,6 +959,7 @@ If you need non-standard settings use the xd=... command */
 
 	xd_maxsectors = 0x01;
 	outb(0,XD_RESET);		/* reset the controller */
+	udelay(OUTB_DELAY);
 
 	msleep(XD_INIT_DISK_DELAY);
 }
-- 
1.8.1.2


^ permalink raw reply related	[flat|nested] 11+ messages in thread
* [PATCH 1/9] block: xd: introduce a delay before every outb operation
  2013-02-12 22:40 ` [PATCH 1/9] block: introduce a delay before every outb operation Linus Walleij
@ 2013-02-12 22:40   ` Linus Walleij
  2013-02-12 22:40     ` [PATCH 2/9] block: xd: fix up request handler loop Linus Walleij
  0 siblings, 1 reply; 11+ messages in thread
From: Linus Walleij @ 2013-02-12 22:40 UTC (permalink / raw)
  To: Jens Axboe; +Cc: linux-kernel, Linus Walleij

When I plug an ISA XT 8bit card into a 16bit compatible EISA
slot, the outb() operations seemingly stumble over each other
so we need to introduce a small delay after each outb()
operation. After this my MFM MiniScribe harddrive is properly
detected like this:

Detected 1 hard drive (using IRQ5 & DMA3)
 xda: CHS=615/4/17

Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
---
 drivers/block/xd.c | 17 +++++++++++++++--
 1 file changed, 15 insertions(+), 2 deletions(-)

diff --git a/drivers/block/xd.c b/drivers/block/xd.c
index ff54052..303e9f2 100644
--- a/drivers/block/xd.c
+++ b/drivers/block/xd.c
@@ -57,6 +57,8 @@
 
 #include "xd.h"
 
+#define OUTB_DELAY 100
+
 static DEFINE_MUTEX(xd_mutex);
 static void __init do_xd_setup (int *integers);
 #ifdef MODULE
@@ -485,7 +487,8 @@ static irqreturn_t xd_interrupt_handler(int irq, void *dev_id)
 #ifdef DEBUG_OTHER
 		printk("xd_interrupt_handler: interrupt detected\n");
 #endif /* DEBUG_OTHER */
-		outb(0,XD_CONTROL);								/* acknowledge interrupt */
+		outb(0,XD_CONTROL); /* acknowledge interrupt */
+		udelay(OUTB_DELAY);
 		wake_up(&xd_wait_int);	/* and wake up sleeping processes */
 		return IRQ_HANDLED;
 	}
@@ -588,7 +591,9 @@ static u_int xd_command (u_char *command,u_char mode,u_char *indata,u_char *outd
 #endif /* DEBUG_COMMAND */
 
 	outb(0,XD_SELECT);
+	udelay(OUTB_DELAY);
 	outb(mode,XD_CONTROL);
+	udelay(OUTB_DELAY);
 
 	if (xd_waitport(XD_STATUS,STAT_SELECT,STAT_SELECT,timeout))
 		return (1);
@@ -602,8 +607,10 @@ static u_int xd_command (u_char *command,u_char mode,u_char *indata,u_char *outd
 				if (mode == DMA_MODE) {
 					if (xd_wait_for_IRQ())
 						return (1);
-				} else
+				} else {
 					outb(outdata ? *outdata++ : 0,XD_DATA);
+					udelay(OUTB_DELAY);
+				}
 				break;
 			case STAT_INPUT:
 				if (mode == DMA_MODE) {
@@ -617,6 +624,7 @@ static u_int xd_command (u_char *command,u_char mode,u_char *indata,u_char *outd
 				break;
 			case STAT_COMMAND:
 				outb(command ? *command++ : 0,XD_DATA);
+				udelay(OUTB_DELAY);
 				break;
 			case STAT_COMMAND | STAT_INPUT:
 				complete = 1;
@@ -680,6 +688,7 @@ static void __init xd_dtc_init_controller (unsigned int address)
 	xd_maxsectors = 0x01;		/* my card seems to have trouble doing multi-block transfers? */
 
 	outb(0,XD_RESET);		/* reset the controller */
+	udelay(OUTB_DELAY);
 }
 
 
@@ -773,6 +782,7 @@ static void __init xd_wd_init_controller (unsigned int address)
 	xd_maxsectors = 0x01;		/* this one doesn't wrap properly either... */
 
 	outb(0,XD_RESET);		/* reset the controller */
+	udelay(OUTB_DELAY);
 
 	msleep(XD_INIT_DISK_DELAY);
 }
@@ -875,6 +885,7 @@ static void __init xd_seagate_init_controller (unsigned int address)
 	xd_maxsectors = 0x40;
 
 	outb(0,XD_RESET);		/* reset the controller */
+	udelay(OUTB_DELAY);
 }
 
 static void __init xd_seagate_init_drive (u_char drive)
@@ -908,6 +919,7 @@ static void __init xd_omti_init_controller (unsigned int address)
 	xd_maxsectors = 0x40;
 
 	outb(0,XD_RESET);		/* reset the controller */
+	udelay(OUTB_DELAY);
 }
 
 static void __init xd_omti_init_drive (u_char drive)
@@ -947,6 +959,7 @@ If you need non-standard settings use the xd=... command */
 
 	xd_maxsectors = 0x01;
 	outb(0,XD_RESET);		/* reset the controller */
+	udelay(OUTB_DELAY);
 
 	msleep(XD_INIT_DISK_DELAY);
 }
-- 
1.8.1.2


^ permalink raw reply related	[flat|nested] 11+ messages in thread
* [PATCH 2/9] block: xd: fix up request handler loop
  2013-02-12 22:40   ` [PATCH 1/9] block: xd: " Linus Walleij
@ 2013-02-12 22:40     ` Linus Walleij
  2013-02-12 22:40       ` [PATCH 3/9] block: xd: raise timeouts Linus Walleij
  0 siblings, 1 reply; 11+ messages in thread
From: Linus Walleij @ 2013-02-12 22:40 UTC (permalink / raw)
  To: Jens Axboe; +Cc: linux-kernel, Linus Walleij

The result (res) variable was set to -EIO in this loop, however
since the iteratively retried request execution loop would
exit on !res this means that loop is never taken.

Instead, assign zero to the res variable, and explicitly set
it to -EIO on error.

Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
---
 drivers/block/xd.c | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/drivers/block/xd.c b/drivers/block/xd.c
index 303e9f2..ce088f8 100644
--- a/drivers/block/xd.c
+++ b/drivers/block/xd.c
@@ -322,13 +322,19 @@ static void do_xd_request (struct request_queue * q)
 		unsigned block = blk_rq_pos(req);
 		unsigned count = blk_rq_cur_sectors(req);
 		XD_INFO *disk = req->rq_disk->private_data;
-		int res = -EIO;
+		int res = 0;
 		int retry;
 
-		if (req->cmd_type != REQ_TYPE_FS)
+		if (req->cmd_type != REQ_TYPE_FS) {
+			pr_err("unsupported request: %d\n", req->cmd_type);
+			res = -EIO;
 			goto done;
-		if (block + count > get_capacity(req->rq_disk))
+		}
+		if (block + count > get_capacity(req->rq_disk)) {
+			pr_err("request beyond device capacity\n");
+			res = -EIO;
 			goto done;
+		}
 		for (retry = 0; (retry < XD_RETRIES) && !res; retry++)
 			res = xd_readwrite(rq_data_dir(req), disk, req->buffer,
 					   block, count);
-- 
1.8.1.2


^ permalink raw reply related	[flat|nested] 11+ messages in thread
* [PATCH 3/9] block: xd: raise timeouts
  2013-02-12 22:40     ` [PATCH 2/9] block: xd: fix up request handler loop Linus Walleij
@ 2013-02-12 22:40       ` Linus Walleij
  2013-02-12 22:40         ` [PATCH 4/9] block: xd: some whitespace and #if 0 removal Linus Walleij
  0 siblings, 1 reply; 11+ messages in thread
From: Linus Walleij @ 2013-02-12 22:40 UTC (permalink / raw)
  To: Jens Axboe; +Cc: linux-kernel, Linus Walleij

The timeouts for the XD driver were set pretty low, probably
tested out on an error-free disk. When there are bad sectors
on the disk, the controller card will autonomously perform a
bump of the drive head, a quite slow mechanical operation
which takes way more than one second, or even the 8 seconds
allowed for the IRQ to arrive. Raise both timeouts to 30
seconds.

Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
---
 drivers/block/xd.c | 2 +-
 drivers/block/xd.h | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/drivers/block/xd.c b/drivers/block/xd.c
index ce088f8..549a7fa 100644
--- a/drivers/block/xd.c
+++ b/drivers/block/xd.c
@@ -564,7 +564,7 @@ static inline u_char xd_waitport (u_short port,u_char flags,u_char mask,u_long t
 static inline u_int xd_wait_for_IRQ (void)
 {
 	unsigned long flags;
-	xd_watchdog_int.expires = jiffies + 8 * HZ;
+	xd_watchdog_int.expires = jiffies + 30 * HZ;
 	add_timer(&xd_watchdog_int);
 	
 	flags=claim_dma_lock();
diff --git a/drivers/block/xd.h b/drivers/block/xd.h
index 37cacef..489e1ce 100644
--- a/drivers/block/xd.h
+++ b/drivers/block/xd.h
@@ -67,7 +67,7 @@
 #define DMA_MODE	0x03	/* control bits to set for DMA & interrupt */
 
 #define XD_MAXDRIVES	2	/* maximum 2 drives */
-#define XD_TIMEOUT	HZ	/* 1 second timeout */
+#define XD_TIMEOUT	(HZ * 30)	/* 30 second timeout */
 #define XD_RETRIES	4	/* maximum 4 retries */
 
 #undef DEBUG			/* define for debugging output */
-- 
1.8.1.2


^ permalink raw reply related	[flat|nested] 11+ messages in thread
* [PATCH 4/9] block: xd: some whitespace and #if 0 removal
  2013-02-12 22:40       ` [PATCH 3/9] block: xd: raise timeouts Linus Walleij
@ 2013-02-12 22:40         ` Linus Walleij
  2013-02-12 22:40           ` [PATCH 5/9] block: xd: avoid using typedefs Linus Walleij
  0 siblings, 1 reply; 11+ messages in thread
From: Linus Walleij @ 2013-02-12 22:40 UTC (permalink / raw)
  To: Jens Axboe; +Cc: linux-kernel, Linus Walleij

Structure some whitespace that I personally found very irritating
when reading the code, like sole tabs on lines and dangling
spaces. (We get very used to our code looking the same these
days.) Also delete a few instances of commenting the obvious
like heads = 12 /* assign number of heads */ and some to git
they will not be fixed down the road either. Made some attempts
to document functions into legal kerneldoc (far from all).

Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
---
 drivers/block/xd.c | 319 +++++++++++++++++++++++++++++------------------------
 1 file changed, 174 insertions(+), 145 deletions(-)

diff --git a/drivers/block/xd.c b/drivers/block/xd.c
index 549a7fa..18f51e9 100644
--- a/drivers/block/xd.c
+++ b/drivers/block/xd.c
@@ -4,7 +4,7 @@
  *
  * Author: Pat Mackinlay, pat@it.com.au
  * Date: 29/09/92
- * 
+ *
  * Revised: 01/01/93, ...
  *
  * Ref: DTC 5150X Controller Specification (thanks to Kevin Fowler,
@@ -31,6 +31,8 @@
  *
  * Bugfix: 15/02/01, Paul G. - inform queue layer of tiny xd_maxsect.
  *
+ * Revised 12/02/13, Linus Walleij - add delays after outb(), increase
+ *   timeouts, fix whitespace and checkpatch issues.
  */
 
 #include <linux/module.h>
@@ -65,38 +67,54 @@ static void __init do_xd_setup (int *integers);
 static int xd[5] = { -1,-1,-1,-1, };
 #endif
 
-#define XD_DONT_USE_DMA		0  /* Initial value. may be overriden using
-				      "nodma" module option */
-#define XD_INIT_DISK_DELAY	(30)  /* 30 ms delay during disk initialization */
+/* Initial value. may be overriden using "nodma" module option */
+#define XD_DONT_USE_DMA		0
+/* 30 ms delay during disk initialization */
+#define XD_INIT_DISK_DELAY	(30)
 
-/* Above may need to be increased if a problem with the 2nd drive detection
-   (ST11M controller) or resetting a controller (WD) appears */
+/*
+ * Above may need to be increased if a problem with the 2nd drive detection
+ * (ST11M controller) or resetting a controller (WD) appears
+ */
 
 static XD_INFO xd_info[XD_MAXDRIVES];
 
-/* If you try this driver and find that your card is not detected by the driver at bootup, you need to add your BIOS
-   signature and details to the following list of signatures. A BIOS signature is a string embedded into the first
-   few bytes of your controller's on-board ROM BIOS. To find out what yours is, use something like MS-DOS's DEBUG
-   command. Run DEBUG, and then you can examine your BIOS signature with:
-
-	d xxxx:0000
-
-   where xxxx is the segment of your controller (like C800 or D000 or something). On the ASCII dump at the right, you should
-   be able to see a string mentioning the manufacturer's copyright etc. Add this string into the table below. The parameters
-   in the table are, in order:
-
-	offset			; this is the offset (in bytes) from the start of your ROM where the signature starts
-	signature		; this is the actual text of the signature
-	xd_?_init_controller	; this is the controller init routine used by your controller
-	xd_?_init_drive		; this is the drive init routine used by your controller
-
-   The controllers directly supported at the moment are: DTC 5150x, WD 1004A27X, ST11M/R and override. If your controller is
-   made by the same manufacturer as one of these, try using the same init routines as they do. If that doesn't work, your
-   best bet is to use the "override" routines. These routines use a "portable" method of getting the disk's geometry, and
-   may work with your card. If none of these seem to work, try sending me some email and I'll see what I can do <grin>.
-
-   NOTE: You can now specify your XT controller's parameters from the command line in the form xd=TYPE,IRQ,IO,DMA. The driver
-   should be able to detect your drive's geometry from this info. (eg: xd=0,5,0x320,3 is the "standard"). */
+/*
+ * If you try this driver and find that your card is not detected by the
+ * driver at bootup, you need to add your BIOS signature and details to the
+ * following list of signatures. A BIOS signature is a string embedded into
+ * the first few bytes of your controller's on-board ROM BIOS. To find out
+ * what yours is, use something like MS-DOS's DEBUG command. Run DEBUG, and
+ * then you can examine your BIOS signature with:
+ *
+ *	d xxxx:0000
+ *
+ * where xxxx is the segment of your controller (like C800 or D000 or
+ * something). On the ASCII dump at the right, you should be able to see a
+ * string mentioning the manufacturer's copyright etc. Add this string into
+ * the table below. The parameters in the table are, in order:
+ *
+ *	offset			; this is the offset (in bytes) from the
+ *				; start of your ROM where the signature starts
+ *	signature		; this is the actual text of the signature
+ *	xd_?_init_controller	; this is the controller init routine used by
+ *				; your controller
+ *	xd_?_init_drive		; this is the drive init routine used by your
+ *				; controller
+ *
+ * The controllers directly supported at the moment are: DTC 5150x,
+ * WD 1004A27X, ST11M/R and override. If your controller is made by the same
+ * manufacturer as one of these, try using the same init routines as they do.
+ * If that doesn't work, your best bet is to use the "override" routines.
+ * These routines use a "portable" method of getting the disk's geometry, and
+ * may work with your card. If none of these seem to work, try sending me some
+ * email and I'll see what I can do <grin>.
+ *
+ * NOTE: You can now specify your XT controller's parameters from the command
+ * line in the form xd=TYPE,IRQ,IO,DMA. The driver should be able to detect
+ * your drive's geometry from this info. (eg: xd=0,5,0x320,3 is the
+ * "standard").
+ */
 
 #include <asm/page.h>
 #define xd_dma_mem_alloc(size) __get_dma_pages(GFP_KERNEL,get_order(size))
@@ -194,7 +212,7 @@ static int __init xd_init(void)
 		if (controller)
 			xd_sigs[controller].init_controller(address);
 		xd_drives = xd_initdrives(xd_sigs[controller].init_drive);
-		
+
 		printk("Detected %d hard drive%s (using IRQ%d & DMA%d)\n",
 			xd_drives,xd_drives == 1 ? "" : "s",xd_irq,xd_dma);
 	}
@@ -279,7 +297,7 @@ Enomem:
 }
 
 /* xd_detect: scan the possible BIOS ROM locations for the signature strings */
-static u_char __init xd_detect (u_char *controller, unsigned int *address)
+static u_char __init xd_detect(u_char *controller, unsigned int *address)
 {
 	int i, j;
 
@@ -310,7 +328,7 @@ static u_char __init xd_detect (u_char *controller, unsigned int *address)
 }
 
 /* do_xd_request: handle an incoming request */
-static void do_xd_request (struct request_queue * q)
+static void do_xd_request(struct request_queue * q)
 {
 	struct request *req;
 
@@ -356,7 +374,8 @@ static int xd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
 }
 
 /* xd_ioctl: handle device ioctl's */
-static int xd_locked_ioctl(struct block_device *bdev, fmode_t mode, u_int cmd, u_long arg)
+static int xd_locked_ioctl(struct block_device *bdev, fmode_t mode,
+			   u_int cmd, u_long arg)
 {
 	switch (cmd) {
 		case HDIO_SET_DMA:
@@ -385,7 +404,7 @@ static int xd_locked_ioctl(struct block_device *bdev, fmode_t mode, u_int cmd, u
 }
 
 static int xd_ioctl(struct block_device *bdev, fmode_t mode,
-			     unsigned int cmd, unsigned long param)
+		    unsigned int cmd, unsigned long param)
 {
 	int ret;
 
@@ -397,7 +416,8 @@ static int xd_ioctl(struct block_device *bdev, fmode_t mode,
 }
 
 /* xd_readwrite: handle a read/write request */
-static int xd_readwrite (u_char operation,XD_INFO *p,char *buffer,u_int block,u_int count)
+static int xd_readwrite(u_char operation, XD_INFO *p, char *buffer,
+			u_int block, u_int count)
 {
 	int drive = p->unit;
 	u_char cmdblk[6],sense[4];
@@ -405,7 +425,7 @@ static int xd_readwrite (u_char operation,XD_INFO *p,char *buffer,u_int block,u_
 	u_char head,sector,control,mode = PIO_MODE,temp;
 	char **real_buffer;
 	register int i;
-	
+
 #ifdef DEBUG_READWRITE
 	printk("xd_readwrite: operation = %s, drive = %d, buffer = 0x%X, block = %d, count = %d\n",operation == READ ? "read" : "write",drive,buffer,block,count);
 #endif /* DEBUG_READWRITE */
@@ -477,10 +497,10 @@ static int xd_readwrite (u_char operation,XD_INFO *p,char *buffer,u_int block,u_
 }
 
 /* xd_recalibrate: recalibrate a given drive and reset controller if necessary */
-static void xd_recalibrate (u_char drive)
+static void xd_recalibrate(u_char drive)
 {
 	u_char cmdblk[6];
-	
+
 	xd_build(cmdblk,CMD_RECALIBRATE,drive,0,0,0,0,0);
 	if (xd_command(cmdblk,PIO_MODE,NULL,NULL,NULL,XD_TIMEOUT * 8))
 		printk("xd%c: warning! error recalibrating, controller may be unstable\n", 'a'+drive);
@@ -504,10 +524,10 @@ static irqreturn_t xd_interrupt_handler(int irq, void *dev_id)
 }
 
 /* xd_setup_dma: set up the DMA controller for a data transfer */
-static u_char xd_setup_dma (u_char mode,u_char *buffer,u_int count)
+static u_char xd_setup_dma(u_char mode, u_char *buffer, u_int count)
 {
 	unsigned long f;
-	
+
 	if (nodma)
 		return (PIO_MODE);
 	if (((unsigned long) buffer & 0xFFFF0000) != (((unsigned long) buffer + count) & 0xFFFF0000)) {
@@ -516,21 +536,23 @@ static u_char xd_setup_dma (u_char mode,u_char *buffer,u_int count)
 #endif /* DEBUG_OTHER */
 		return (PIO_MODE);
 	}
-	
+
 	f=claim_dma_lock();
 	disable_dma(xd_dma);
 	clear_dma_ff(xd_dma);
 	set_dma_mode(xd_dma,mode);
 	set_dma_addr(xd_dma, (unsigned long) buffer);
 	set_dma_count(xd_dma,count);
-	
+
 	release_dma_lock(f);
 
-	return (DMA_MODE);			/* use DMA and INT */
+	return (DMA_MODE); /* use DMA and INT */
 }
 
 /* xd_build: put stuff into an array in a format suitable for the controller */
-static u_char *xd_build (u_char *cmdblk,u_char command,u_char drive,u_char head,u_short cylinder,u_char sector,u_char count,u_char control)
+static u_char *xd_build(u_char *cmdblk, u_char command, u_char drive,
+			u_char head, u_short cylinder, u_char sector,
+			u_char count, u_char control)
 {
 	cmdblk[0] = command;
 	cmdblk[1] = ((drive & 0x07) << 5) | (head & 0x1F);
@@ -538,18 +560,19 @@ static u_char *xd_build (u_char *cmdblk,u_char command,u_char drive,u_char head,
 	cmdblk[3] = cylinder & 0xFF;
 	cmdblk[4] = count;
 	cmdblk[5] = control;
-	
+
 	return (cmdblk);
 }
 
-static void xd_watchdog (unsigned long unused)
+static void xd_watchdog(unsigned long unused)
 {
 	xd_error = 1;
 	wake_up(&xd_wait_int);
 }
 
 /* xd_waitport: waits until port & mask == flags or a timeout occurs. return 1 for a timeout */
-static inline u_char xd_waitport (u_short port,u_char flags,u_char mask,u_long timeout)
+static inline u_char xd_waitport(u_short port, u_char flags,
+				 u_char mask, u_long timeout)
 {
 	u_long expiry = jiffies + timeout;
 	int success;
@@ -561,24 +584,24 @@ static inline u_char xd_waitport (u_short port,u_char flags,u_char mask,u_long t
 	return (success);
 }
 
-static inline u_int xd_wait_for_IRQ (void)
+static inline u_int xd_wait_for_IRQ(void)
 {
 	unsigned long flags;
 	xd_watchdog_int.expires = jiffies + 30 * HZ;
 	add_timer(&xd_watchdog_int);
-	
+
 	flags=claim_dma_lock();
 	enable_dma(xd_dma);
 	release_dma_lock(flags);
-	
+
 	sleep_on(&xd_wait_int);
 	del_timer(&xd_watchdog_int);
 	xdc_busy = 0;
-	
+
 	flags=claim_dma_lock();
 	disable_dma(xd_dma);
 	release_dma_lock(flags);
-	
+
 	if (xd_error) {
 		printk("xd: missed IRQ - command aborted\n");
 		xd_error = 0;
@@ -588,9 +611,10 @@ static inline u_int xd_wait_for_IRQ (void)
 }
 
 /* xd_command: handle all data transfers necessary for a single command */
-static u_int xd_command (u_char *command,u_char mode,u_char *indata,u_char *outdata,u_char *sense,u_long timeout)
+static u_int xd_command(u_char *command, u_char mode, u_char *indata,
+			u_char *outdata, u_char *sense, u_long timeout)
 {
-	u_char cmdblk[6],csb,complete = 0;
+	u_char cmdblk[6], csb, complete = 0;
 
 #ifdef DEBUG_COMMAND
 	printk("xd_command: command = 0x%X, mode = 0x%X, indata = 0x%X, outdata = 0x%X, sense = 0x%X\n",command,mode,indata,outdata,sense);
@@ -655,9 +679,9 @@ static u_int xd_command (u_char *command,u_char mode,u_char *indata,u_char *outd
 	return (csb & CSB_ERROR);
 }
 
-static u_char __init xd_initdrives (void (*init_drive)(u_char drive))
+static u_char __init xd_initdrives(void (*init_drive)(u_char drive))
 {
-	u_char cmdblk[6],i,count = 0;
+	u_char cmdblk[6], i, count = 0;
 
 	for (i = 0; i < XD_MAXDRIVES; i++) {
 		xd_build(cmdblk,CMD_TESTREADY,i,0,0,0,0,0);
@@ -673,19 +697,19 @@ static u_char __init xd_initdrives (void (*init_drive)(u_char drive))
 	return (count);
 }
 
-static void __init xd_manual_geo_set (u_char drive)
+static void __init xd_manual_geo_set(u_char drive)
 {
 	xd_info[drive].heads = (u_char)(xd_geo[3 * drive + 1]);
 	xd_info[drive].cylinders = (u_short)(xd_geo[3 * drive]);
 	xd_info[drive].sectors = (u_char)(xd_geo[3 * drive + 2]);
 }
 
-static void __init xd_dtc_init_controller (unsigned int address)
+static void __init xd_dtc_init_controller(unsigned int address)
 {
 	switch (address) {
 		case 0x00000:
 		case 0xC8000:	break;			/*initial: 0x320 */
-		case 0xCA000:	xd_iobase = 0x324; 
+		case 0xCA000:	xd_iobase = 0x324;
 		case 0xD0000:				/*5150CX*/
 		case 0xD8000:	break;			/*5150CX & 5150XL*/
 		default:        printk("xd_dtc_init_controller: unsupported BIOS address %06x\n",address);
@@ -698,7 +722,7 @@ static void __init xd_dtc_init_controller (unsigned int address)
 }
 
 
-static void __init xd_dtc5150cx_init_drive (u_char drive)
+static void __init xd_dtc5150cx_init_drive(u_char drive)
 {
 	/* values from controller's BIOS - BIOS chip may be removed */
 	static u_short geometry_table[][4] = {
@@ -726,7 +750,7 @@ static void __init xd_dtc5150cx_init_drive (u_char drive)
 	if (xd_geo[3*drive])
 		xd_manual_geo_set(drive);
 	else
-		if (n != 7) {	
+		if (n != 7) {
 			xd_info[drive].heads = (u_char)(geometry_table[n][1]);			/* heads */
 			xd_info[drive].cylinders = geometry_table[n][0];	/* cylinders */
 			xd_info[drive].sectors = 17;				/* sectors */
@@ -745,7 +769,7 @@ static void __init xd_dtc5150cx_init_drive (u_char drive)
 	xd_recalibrate(drive);
 }
 
-static void __init xd_dtc_init_drive (u_char drive)
+static void __init xd_dtc_init_drive(u_char drive)
 {
 	u_char cmdblk[6],buf[64];
 
@@ -772,11 +796,11 @@ static void __init xd_dtc_init_drive (u_char drive)
 		printk("xd_dtc_init_drive: error reading geometry for xd%c\n", 'a'+drive);
 }
 
-static void __init xd_wd_init_controller (unsigned int address)
+static void __init xd_wd_init_controller(unsigned int address)
 {
 	switch (address) {
 		case 0x00000:
-		case 0xC8000:	break;			/*initial: 0x320 */
+		case 0xC8000:	break; /*initial: 0x320 */
 		case 0xCA000:	xd_iobase = 0x324; break;
 		case 0xCC000:   xd_iobase = 0x328; break;
 		case 0xCE000:   xd_iobase = 0x32C; break;
@@ -785,15 +809,16 @@ static void __init xd_wd_init_controller (unsigned int address)
 		default:        printk("xd_wd_init_controller: unsupported BIOS address %06x\n",address);
 				break;
 	}
-	xd_maxsectors = 0x01;		/* this one doesn't wrap properly either... */
+	/* this one doesn't wrap properly either... */
+	xd_maxsectors = 0x01;
 
-	outb(0,XD_RESET);		/* reset the controller */
+	outb(0,XD_RESET);
 	udelay(OUTB_DELAY);
 
 	msleep(XD_INIT_DISK_DELAY);
 }
 
-static void __init xd_wd_init_drive (u_char drive)
+static void __init xd_wd_init_drive(u_char drive)
 {
 	/* values from controller's BIOS - BIOS may be disabled */
 	static u_short geometry_table[][4] = {
@@ -815,24 +840,20 @@ static void __init xd_wd_init_drive (u_char drive)
 	u_char cmdblk[6],buf[0x200];
 	u_char n = 0,rll,jumper_state,use_jumper_geo;
 	u_char wd_1002 = (xd_sigs[xd_type].string[7] == '6');
-	
+
 	jumper_state = ~(inb(0x322));
 	if (jumper_state & 0x40)
 		xd_irq = 9;
 	rll = (jumper_state & 0x30) ? (0x04 << wd_1002) : 0;
 	xd_build(cmdblk,CMD_READ,drive,0,0,0,1,0);
 	if (!xd_command(cmdblk,PIO_MODE,buf,NULL,NULL,XD_TIMEOUT * 2)) {
-		xd_info[drive].heads = buf[0x1AF];				/* heads */
-		xd_info[drive].cylinders = ((u_short *) (buf + 1))[0xD6];	/* cylinders */
-		xd_info[drive].sectors = 17;					/* sectors */
+		xd_info[drive].heads = buf[0x1AF];
+		xd_info[drive].cylinders = ((u_short *) (buf + 1))[0xD6];
+		xd_info[drive].sectors = 17;
 		if (xd_geo[3*drive])
 			xd_manual_geo_set(drive);
-#if 0
-		xd_info[drive].rwrite = ((u_short *) (buf))[0xD8];		/* reduced write */
-		xd_info[drive].wprecomp = ((u_short *) (buf))[0xDA];		/* write precomp */
-		xd_info[drive].ecc = buf[0x1B4];				/* ecc length */
-#endif /* 0 */
-		xd_info[drive].control = buf[0x1B5];				/* control byte */
+		/* control byte */
+		xd_info[drive].control = buf[0x1B5];
 		use_jumper_geo = !(xd_info[drive].heads) || !(xd_info[drive].cylinders);
 		if (xd_geo[3*drive]) {
 			xd_manual_geo_set(drive);
@@ -843,11 +864,6 @@ static void __init xd_wd_init_drive (u_char drive)
 			xd_info[drive].cylinders = geometry_table[n][0];
 			xd_info[drive].heads = (u_char)(geometry_table[n][1]);
 			xd_info[drive].control = rll ? 7 : 5;
-#if 0
-			xd_info[drive].rwrite = geometry_table[n][2];
-			xd_info[drive].wprecomp = geometry_table[n][3];
-			xd_info[drive].ecc = 0x0B;
-#endif /* 0 */
 		}
 		if (!wd_1002) {
 			if (use_jumper_geo)
@@ -857,24 +873,19 @@ static void __init xd_wd_init_drive (u_char drive)
 				xd_setparam(CMD_WDSETPARAM,drive,xd_info[drive].heads,xd_info[drive].cylinders,
 					((u_short *) (buf))[0xD8],((u_short *) (buf))[0xDA],buf[0x1B4]);
 		}
-	/* 1002 based RLL controller requests converted addressing, but reports physical 
-	   (physical 26 sec., logical 17 sec.) 
-	   1004 based ???? */
+		/*
+		 * 1002 based RLL controller requests converted addressing,
+		 * but reports physical (physical 26 sec., logical 17 sec.)
+		 * 1004 based ????
+		 */
 		if (rll & wd_1002) {
 			if ((xd_info[drive].cylinders *= 26,
 			     xd_info[drive].cylinders /= 17) > 1023)
 				xd_info[drive].cylinders = 1023;  /* 1024 ? */
-#if 0
-			xd_info[drive].rwrite *= 26; 
-			xd_info[drive].rwrite /= 17;
-			xd_info[drive].wprecomp *= 26
-			xd_info[drive].wprecomp /= 17;
-#endif /* 0 */
 		}
 	}
 	else
-		printk("xd_wd_init_drive: error reading geometry for xd%c\n",'a'+drive);	
-
+		printk("xd_wd_init_drive: error reading geometry for xd%c\n",'a'+drive);
 }
 
 static void __init xd_seagate_init_controller (unsigned int address)
@@ -890,41 +901,49 @@ static void __init xd_seagate_init_controller (unsigned int address)
 	}
 	xd_maxsectors = 0x40;
 
-	outb(0,XD_RESET);		/* reset the controller */
+	outb(0,XD_RESET);
 	udelay(OUTB_DELAY);
 }
 
-static void __init xd_seagate_init_drive (u_char drive)
+static void __init xd_seagate_init_drive(u_char drive)
 {
 	u_char cmdblk[6],buf[0x200];
 
 	xd_build(cmdblk,CMD_ST11GETGEOM,drive,0,0,0,1,0);
 	if (!xd_command(cmdblk,PIO_MODE,buf,NULL,NULL,XD_TIMEOUT * 2)) {
-		xd_info[drive].heads = buf[0x04];				/* heads */
-		xd_info[drive].cylinders = (buf[0x02] << 8) | buf[0x03];	/* cylinders */
-		xd_info[drive].sectors = buf[0x05];				/* sectors */
-		xd_info[drive].control = 0;					/* control byte */
+		xd_info[drive].heads = buf[0x04];
+		xd_info[drive].cylinders = (buf[0x02] << 8) | buf[0x03];
+		xd_info[drive].sectors = buf[0x05];
+		xd_info[drive].control = 0;
 	}
 	else
 		printk("xd_seagate_init_drive: error reading geometry from xd%c\n", 'a'+drive);
 }
 
 /* Omti support courtesy Dirk Melchers */
-static void __init xd_omti_init_controller (unsigned int address)
+static void __init xd_omti_init_controller(unsigned int address)
 {
 	switch (address) {
 		case 0x00000:
-		case 0xC8000:	break;			/*initial: 0x320 */
-		case 0xD0000:	xd_iobase = 0x324; break;
-		case 0xD8000:	xd_iobase = 0x328; break;
-		case 0xE0000:	xd_iobase = 0x32C; break;
-		default:	printk("xd_omti_init_controller: unsupported BIOS address %06x\n",address);
-				break;
+		case 0xC8000:
+			break; /*initial: 0x320 */
+		case 0xD0000:
+			xd_iobase = 0x324;
+			break;
+		case 0xD8000:
+			xd_iobase = 0x328;
+			break;
+		case 0xE0000:
+			xd_iobase = 0x32C;
+			break;
+		default:
+			printk("xd_omti_init_controller: unsupported BIOS address %06x\n",address);
+			break;
 	}
-	
+
 	xd_maxsectors = 0x40;
 
-	outb(0,XD_RESET);		/* reset the controller */
+	outb(0,XD_RESET);
 	udelay(OUTB_DELAY);
 }
 
@@ -938,15 +957,16 @@ static void __init xd_omti_init_drive (u_char drive)
 }
 
 /* Xebec support (AK) */
-static void __init xd_xebec_init_controller (unsigned int address)
+static void __init xd_xebec_init_controller(unsigned int address)
 {
-/* iobase may be set manually in range 0x300 - 0x33C
-      irq may be set manually to 2(9),3,4,5,6,7
-      dma may be set manually to 1,2,3
-	(How to detect them ???)
-BIOS address may be set manually in range 0x0 - 0xF8000
-If you need non-standard settings use the xd=... command */
-
+/*
+ * iobase may be set manually in range 0x300 - 0x33C
+ *    irq may be set manually to 2(9),3,4,5,6,7
+ *    dma may be set manually to 1,2,3
+ *	(How to detect them ???)
+ * BIOS address may be set manually in range 0x0 - 0xF8000
+ * If you need non-standard settings use the xd=... command
+ */
 	switch (address) {
 		case 0x00000:
 		case 0xC8000:	/* initially: xd_iobase==0x320 */
@@ -958,13 +978,15 @@ If you need non-standard settings use the xd=... command */
 		case 0xDA000:
 		case 0xDC000:
 		case 0xDE000:
-		case 0xE0000:	break;
-		default:	printk("xd_xebec_init_controller: unsupported BIOS address %06x\n",address);
-				break;
+		case 0xE0000:
+			break;
+		default:
+			printk("xd_xebec_init_controller: unsupported BIOS address %06x\n",address);
+			break;
 		}
 
 	xd_maxsectors = 0x01;
-	outb(0,XD_RESET);		/* reset the controller */
+	outb(0,XD_RESET);
 	udelay(OUTB_DELAY);
 
 	msleep(XD_INIT_DISK_DELAY);
@@ -992,31 +1014,30 @@ static void __init xd_xebec_init_drive (u_char drive)
 		{0x33E,7,0x33E,0x200,0x7}};
 	u_char n;
 
-	n = inb(XD_JUMPER) & 0x0F; /* BIOS's drive number: same geometry 
-					is assumed for BOTH drives */
+	/* BIOS's drive number: same geometry is assumed for BOTH drives */
+	n = inb(XD_JUMPER) & 0x0F;
 	if (xd_geo[3*drive])
 		xd_manual_geo_set(drive);
 	else {
-		xd_info[drive].heads = (u_char)(geometry_table[n][1]);			/* heads */
-		xd_info[drive].cylinders = geometry_table[n][0];	/* cylinders */
-		xd_info[drive].sectors = 17;				/* sectors */
-#if 0
-		xd_info[drive].rwrite = geometry_table[n][2];	/* reduced write */
-		xd_info[drive].precomp = geometry_table[n][3]		/* write precomp */
-		xd_info[drive].ecc = 0x0B;				/* ecc length */
-#endif /* 0 */
+		xd_info[drive].heads = (u_char)(geometry_table[n][1]);
+		xd_info[drive].cylinders = geometry_table[n][0];
+		xd_info[drive].sectors = 17;
 	}
-	xd_info[drive].control = geometry_table[n][4];			/* control byte */
+	xd_info[drive].control = geometry_table[n][4];
 	xd_setparam(CMD_XBSETPARAM,drive,xd_info[drive].heads,xd_info[drive].cylinders,geometry_table[n][2],geometry_table[n][3],0x0B);
 	xd_recalibrate(drive);
 }
 
-/* xd_override_init_drive: this finds disk geometry in a "binary search" style, narrowing in on the "correct" number of heads
-   etc. by trying values until it gets the highest successful value. Idea courtesy Salvador Abreu (spa@fct.unl.pt). */
-static void __init xd_override_init_drive (u_char drive)
+/**
+ * xd_override_init_drive() - this finds disk geometry in a "binary search"
+ * style, narrowing in on the "correct" number of heads etc. by trying values
+ * until it gets the highest successful value. Idea courtesy Salvador Abreu
+ * (spa@fct.unl.pt).
+ */
+static void __init xd_override_init_drive(u_char drive)
 {
-	u_short min[] = { 0,0,0 },max[] = { 16,1024,64 },test[] = { 0,0,0 };
-	u_char cmdblk[6],i;
+	u_short min[] = { 0,0,0 }, max[] = { 16,1024,64 }, test[] = { 0,0,0 };
+	u_char cmdblk[6], i;
 
 	if (xd_geo[3*drive])
 		xd_manual_geo_set(drive);
@@ -1039,8 +1060,10 @@ static void __init xd_override_init_drive (u_char drive)
 	xd_info[drive].control = 0;
 }
 
-/* xd_setup: initialise controller from command line parameters */
-static void __init do_xd_setup (int *integers)
+/**
+ * xd_setup() - initialise controller from command line parameters
+ */
+static void __init do_xd_setup(int *integers)
 {
 	switch (integers[0]) {
 		case 4: if (integers[4] < 0)
@@ -1060,8 +1083,12 @@ static void __init do_xd_setup (int *integers)
 	xd_maxsectors = 0x01;
 }
 
-/* xd_setparam: set the drive characteristics */
-static void __init xd_setparam (u_char command,u_char drive,u_char heads,u_short cylinders,u_short rwrite,u_short wprecomp,u_char ecc)
+/**
+ * xd_setparam() - set the drive characteristics
+ */
+static void __init xd_setparam (u_char command, u_char drive, u_char heads,
+				u_short cylinders, u_short rwrite,
+				u_short wprecomp, u_char ecc)
 {
 	u_char cmdblk[14];
 
@@ -1081,7 +1108,6 @@ static void __init xd_setparam (u_char command,u_char drive,u_char heads,u_short
 		printk("xd: error setting characteristics for xd%c\n", 'a'+drive);
 }
 
-
 #ifdef MODULE
 
 module_param_array(xd, int, NULL, 0);
@@ -1107,9 +1133,10 @@ void cleanup_module(void)
 			xd_dma_mem_free((unsigned long)xd_dma_buffer, xd_maxsectors * 0x200);
 	}
 }
+
 #else
 
-static int __init xd_setup (char *str)
+static int __init xd_setup(char *str)
 {
 	int ints[5];
 	get_options (str, ARRAY_SIZE (ints), ints);
@@ -1117,13 +1144,15 @@ static int __init xd_setup (char *str)
 	return 1;
 }
 
-/* xd_manual_geo_init: initialise drive geometry from command line parameters
-   (used only for WD drives) */
+/**
+ * xd_manual_geo_init() - initialise drive geometry from command line
+ * parameters (used only for WD drives)
+ */
 static int __init xd_manual_geo_init (char *str)
 {
 	int i, integers[1 + 3*XD_MAXDRIVES];
 
-	get_options (str, ARRAY_SIZE (integers), integers);
+	get_options (str, ARRAY_SIZE(integers), integers);
 	if (integers[0]%3 != 0) {
 		printk("xd: incorrect number of parameters for xd_geo\n");
 		return 1;
-- 
1.8.1.2


^ permalink raw reply related	[flat|nested] 11+ messages in thread
* [PATCH 5/9] block: xd: avoid using typedefs
  2013-02-12 22:40         ` [PATCH 4/9] block: xd: some whitespace and #if 0 removal Linus Walleij
@ 2013-02-12 22:40           ` Linus Walleij
  2013-02-12 22:40             ` [PATCH 6/9] block: xd: avoid some forward declarations Linus Walleij
  0 siblings, 1 reply; 11+ messages in thread
From: Linus Walleij @ 2013-02-12 22:40 UTC (permalink / raw)
  To: Jens Axboe; +Cc: linux-kernel, Linus Walleij

Two of the structs in the driver were using typedef, which we
avoid since ages in the kernel.

Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
---
 drivers/block/xd.c | 12 ++++++------
 drivers/block/xd.h | 10 +++++-----
 2 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/drivers/block/xd.c b/drivers/block/xd.c
index 18f51e9..9e00753 100644
--- a/drivers/block/xd.c
+++ b/drivers/block/xd.c
@@ -77,7 +77,7 @@ static int xd[5] = { -1,-1,-1,-1, };
  * (ST11M controller) or resetting a controller (WD) appears
  */
 
-static XD_INFO xd_info[XD_MAXDRIVES];
+static struct xd_info xd_info[XD_MAXDRIVES];
 
 /*
  * If you try this driver and find that your card is not detected by the
@@ -121,7 +121,7 @@ static XD_INFO xd_info[XD_MAXDRIVES];
 #define xd_dma_mem_free(addr, size) free_pages(addr, get_order(size))
 static char *xd_dma_buffer;
 
-static XD_SIGNATURE xd_sigs[] __initdata = {
+static struct xd_signature xd_sigs[] __initdata = {
 	{ 0x0000,"Override geometry handler",NULL,xd_override_init_drive,"n unknown" }, /* Pat Mackinlay, pat@it.com.au */
 	{ 0x0008,"[BXD06 (C) DTC 17-MAY-1985]",xd_dtc_init_controller,xd_dtc5150cx_init_drive," DTC 5150CX" }, /* Andrzej Krzysztofowicz, ankry@mif.pg.gda.pl */
 	{ 0x000B,"CRD18A   Not an IBM rom. (C) Copyright Data Technology Corp. 05/31/88",xd_dtc_init_controller,xd_dtc_init_drive," DTC 5150X" }, /* Todd Fries, tfries@umr.edu */
@@ -235,7 +235,7 @@ static int __init xd_init(void)
 		goto out3;
 
 	for (i = 0; i < xd_drives; i++) {
-		XD_INFO *p = &xd_info[i];
+		struct xd_info *p = &xd_info[i];
 		struct gendisk *disk = alloc_disk(64);
 		if (!disk)
 			goto Enomem;
@@ -339,7 +339,7 @@ static void do_xd_request(struct request_queue * q)
 	while (req) {
 		unsigned block = blk_rq_pos(req);
 		unsigned count = blk_rq_cur_sectors(req);
-		XD_INFO *disk = req->rq_disk->private_data;
+		struct xd_info *disk = req->rq_disk->private_data;
 		int res = 0;
 		int retry;
 
@@ -365,7 +365,7 @@ static void do_xd_request(struct request_queue * q)
 
 static int xd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
 {
-	XD_INFO *p = bdev->bd_disk->private_data;
+	struct xd_info *p = bdev->bd_disk->private_data;
 
 	geo->heads = p->heads;
 	geo->sectors = p->sectors;
@@ -416,7 +416,7 @@ static int xd_ioctl(struct block_device *bdev, fmode_t mode,
 }
 
 /* xd_readwrite: handle a read/write request */
-static int xd_readwrite(u_char operation, XD_INFO *p, char *buffer,
+static int xd_readwrite(u_char operation, struct xd_info *p, char *buffer,
 			u_int block, u_int count)
 {
 	int drive = p->unit;
diff --git a/drivers/block/xd.h b/drivers/block/xd.h
index 489e1ce..40630db 100644
--- a/drivers/block/xd.h
+++ b/drivers/block/xd.h
@@ -81,22 +81,22 @@
 #endif /* DEBUG */
 
 /* this structure defines the XT drives and their types */
-typedef struct {
+struct xd_info {
 	u_char heads;
 	u_short cylinders;
 	u_char sectors;
 	u_char control;
 	int unit;
-} XD_INFO;
+};
 
 /* this structure defines a ROM BIOS signature */
-typedef struct {
+struct xd_signature {
 	unsigned int offset;
 	const char *string;
 	void (*init_controller)(unsigned int address);
 	void (*init_drive)(u_char drive);
 	const char *name;
-} XD_SIGNATURE;
+};
 
 #ifndef MODULE
 static int xd_manual_geo_init (char *command);
@@ -106,7 +106,7 @@ static u_char xd_initdrives (void (*init_drive)(u_char drive));
 
 static void do_xd_request (struct request_queue * q);
 static int xd_ioctl (struct block_device *bdev,fmode_t mode,unsigned int cmd,unsigned long arg);
-static int xd_readwrite (u_char operation,XD_INFO *disk,char *buffer,u_int block,u_int count);
+static int xd_readwrite (u_char operation, struct xd_info *disk,char *buffer,u_int block,u_int count);
 static void xd_recalibrate (u_char drive);
 
 static irqreturn_t xd_interrupt_handler(int irq, void *dev_id);
-- 
1.8.1.2


^ permalink raw reply related	[flat|nested] 11+ messages in thread
* [PATCH 6/9] block: xd: avoid some forward declarations
  2013-02-12 22:40           ` [PATCH 5/9] block: xd: avoid using typedefs Linus Walleij
@ 2013-02-12 22:40             ` Linus Walleij
  2013-02-12 22:40               ` [PATCH 7/9] block: xd: merge header file into driver Linus Walleij
  0 siblings, 1 reply; 11+ messages in thread
From: Linus Walleij @ 2013-02-12 22:40 UTC (permalink / raw)
  To: Jens Axboe; +Cc: linux-kernel, Linus Walleij

This moves the code around so that we can avoid a dozen
forward-declarations, then move the few remaining ones above the
table that use them. No semantic changes.

Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
---
 drivers/block/xd.c | 801 +++++++++++++++++++++++++++--------------------------
 drivers/block/xd.h |  33 ---
 2 files changed, 415 insertions(+), 419 deletions(-)

diff --git a/drivers/block/xd.c b/drivers/block/xd.c
index 9e00753..ffa6e76 100644
--- a/drivers/block/xd.c
+++ b/drivers/block/xd.c
@@ -121,6 +121,20 @@ static struct xd_info xd_info[XD_MAXDRIVES];
 #define xd_dma_mem_free(addr, size) free_pages(addr, get_order(size))
 static char *xd_dma_buffer;
 
+/* card specific setup and geometry gathering code */
+static void xd_dtc_init_controller (unsigned int address);
+static void xd_dtc5150cx_init_drive (u_char drive);
+static void xd_dtc_init_drive (u_char drive);
+static void xd_wd_init_controller (unsigned int address);
+static void xd_wd_init_drive (u_char drive);
+static void xd_seagate_init_controller (unsigned int address);
+static void xd_seagate_init_drive (u_char drive);
+static void xd_omti_init_controller (unsigned int address);
+static void xd_omti_init_drive (u_char drive);
+static void xd_xebec_init_controller (unsigned int address);
+static void xd_xebec_init_drive (u_char drive);
+static void xd_override_init_drive (u_char drive);
+
 static struct xd_signature xd_sigs[] __initdata = {
 	{ 0x0000,"Override geometry handler",NULL,xd_override_init_drive,"n unknown" }, /* Pat Mackinlay, pat@it.com.au */
 	{ 0x0008,"[BXD06 (C) DTC 17-MAY-1985]",xd_dtc_init_controller,xd_dtc5150cx_init_drive," DTC 5150CX" }, /* Andrzej Krzysztofowicz, ankry@mif.pg.gda.pl */
@@ -150,13 +164,6 @@ static DEFINE_SPINLOCK(xd_lock);
 
 static struct gendisk *xd_gendisk[2];
 
-static int xd_getgeo(struct block_device *bdev, struct hd_geometry *geo);
-
-static const struct block_device_operations xd_fops = {
-	.owner	= THIS_MODULE,
-	.ioctl	= xd_ioctl,
-	.getgeo = xd_getgeo,
-};
 static DECLARE_WAIT_QUEUE_HEAD(xd_wait_int);
 static u_char xd_drives, xd_irq = 5, xd_dma = 3, xd_maxsectors;
 static u_char xd_override __initdata = 0, xd_type __initdata = 0;
@@ -171,251 +178,206 @@ static bool nodma = XD_DONT_USE_DMA;
 
 static struct request_queue *xd_queue;
 
-/* xd_init: register the block device number and set up pointer tables */
-static int __init xd_init(void)
+/**
+ * xd_setup_dma() - set up the DMA controller for a data transfer
+ */
+static u_char xd_setup_dma(u_char mode, u_char *buffer, u_int count)
 {
-	u_char i,controller;
-	unsigned int address;
-	int err;
+	unsigned long f;
 
-#ifdef MODULE
-	{
-		u_char count = 0;
-		for (i = 4; i > 0; i--)
-			if (((xd[i] = xd[i-1]) >= 0) && !count)
-				count = i;
-		if ((xd[0] = count))
-			do_xd_setup(xd);
+	if (nodma)
+		return (PIO_MODE);
+	if (((unsigned long) buffer & 0xFFFF0000) != (((unsigned long) buffer + count) & 0xFFFF0000)) {
+#ifdef DEBUG_OTHER
+		printk("xd_setup_dma: using PIO, transfer overlaps 64k boundary\n");
+#endif /* DEBUG_OTHER */
+		return (PIO_MODE);
 	}
-#endif
 
-	init_timer (&xd_watchdog_int); xd_watchdog_int.function = xd_watchdog;
-
-	err = -EBUSY;
-	if (register_blkdev(XT_DISK_MAJOR, "xd"))
-		goto out1;
+	f=claim_dma_lock();
+	disable_dma(xd_dma);
+	clear_dma_ff(xd_dma);
+	set_dma_mode(xd_dma,mode);
+	set_dma_addr(xd_dma, (unsigned long) buffer);
+	set_dma_count(xd_dma,count);
 
-	err = -ENOMEM;
-	xd_queue = blk_init_queue(do_xd_request, &xd_lock);
-	if (!xd_queue)
-		goto out1a;
+	release_dma_lock(f);
 
-	if (xd_detect(&controller,&address)) {
+	return (DMA_MODE); /* use DMA and INT */
+}
 
-		printk("Detected a%s controller (type %d) at address %06x\n",
-			xd_sigs[controller].name,controller,address);
-		if (!request_region(xd_iobase,4,"xd")) {
-			printk("xd: Ports at 0x%x are not available\n",
-				xd_iobase);
-			goto out2;
-		}
-		if (controller)
-			xd_sigs[controller].init_controller(address);
-		xd_drives = xd_initdrives(xd_sigs[controller].init_drive);
+/**
+ * xd_build() - put stuff into an array in a format suitable for
+ * the controller
+ */
+static u_char *xd_build(u_char *cmdblk, u_char command, u_char drive,
+			u_char head, u_short cylinder, u_char sector,
+			u_char count, u_char control)
+{
+	cmdblk[0] = command;
+	cmdblk[1] = ((drive & 0x07) << 5) | (head & 0x1F);
+	cmdblk[2] = ((cylinder & 0x300) >> 2) | (sector & 0x3F);
+	cmdblk[3] = cylinder & 0xFF;
+	cmdblk[4] = count;
+	cmdblk[5] = control;
 
-		printk("Detected %d hard drive%s (using IRQ%d & DMA%d)\n",
-			xd_drives,xd_drives == 1 ? "" : "s",xd_irq,xd_dma);
-	}
+	return (cmdblk);
+}
 
-	/*
-	 * With the drive detected, xd_maxsectors should now be known.
-	 * If xd_maxsectors is 0, nothing was detected and we fall through
-	 * to return -ENODEV
-	 */
-	if (!xd_dma_buffer && xd_maxsectors) {
-		xd_dma_buffer = (char *)xd_dma_mem_alloc(xd_maxsectors * 0x200);
-		if (!xd_dma_buffer) {
-			printk(KERN_ERR "xd: Out of memory.\n");
-			goto out3;
-		}
-	}
+/**
+ * xd_waitport() - waits until port & mask == flags or a timeout occurs.
+ * return 1 for a timeout
+ */
+static inline u_char xd_waitport(u_short port, u_char flags,
+				 u_char mask, u_long timeout)
+{
+	u_long expiry = jiffies + timeout;
+	int success;
 
-	err = -ENODEV;
-	if (!xd_drives)
-		goto out3;
+	xdc_busy = 1;
+	while ((success = ((inb(port) & mask) != flags)) && time_before(jiffies, expiry))
+		schedule_timeout_uninterruptible(1);
+	xdc_busy = 0;
+	return (success);
+}
 
-	for (i = 0; i < xd_drives; i++) {
-		struct xd_info *p = &xd_info[i];
-		struct gendisk *disk = alloc_disk(64);
-		if (!disk)
-			goto Enomem;
-		p->unit = i;
-		disk->major = XT_DISK_MAJOR;
-		disk->first_minor = i<<6;
-		sprintf(disk->disk_name, "xd%c", i+'a');
-		disk->fops = &xd_fops;
-		disk->private_data = p;
-		disk->queue = xd_queue;
-		set_capacity(disk, p->heads * p->cylinders * p->sectors);
-		printk(" %s: CHS=%d/%d/%d\n", disk->disk_name,
-			p->cylinders, p->heads, p->sectors);
-		xd_gendisk[i] = disk;
-	}
+static inline u_int xd_wait_for_IRQ(void)
+{
+	unsigned long flags;
+	xd_watchdog_int.expires = jiffies + 30 * HZ;
+	add_timer(&xd_watchdog_int);
 
-	err = -EBUSY;
-	if (request_irq(xd_irq,xd_interrupt_handler, 0, "XT hard disk", NULL)) {
-		printk("xd: unable to get IRQ%d\n",xd_irq);
-		goto out4;
-	}
+	flags = claim_dma_lock();
+	enable_dma(xd_dma);
+	release_dma_lock(flags);
 
-	if (request_dma(xd_dma,"xd")) {
-		printk("xd: unable to get DMA%d\n",xd_dma);
-		goto out5;
-	}
+	sleep_on(&xd_wait_int);
+	del_timer(&xd_watchdog_int);
+	xdc_busy = 0;
 
-	/* xd_maxsectors depends on controller - so set after detection */
-	blk_queue_max_hw_sectors(xd_queue, xd_maxsectors);
+	flags = claim_dma_lock();
+	disable_dma(xd_dma);
+	release_dma_lock(flags);
 
-	for (i = 0; i < xd_drives; i++)
-		add_disk(xd_gendisk[i]);
+	if (xd_error) {
+		printk("xd: missed IRQ - command aborted\n");
+		xd_error = 0;
+		return (1);
+	}
+	return (0);
+}
 
-	return 0;
+/**
+ * xd_command() - handle all data transfers necessary for a single command
+ */
+static u_int xd_command(u_char *command, u_char mode, u_char *indata,
+			u_char *outdata, u_char *sense, u_long timeout)
+{
+	u_char cmdblk[6], csb, complete = 0;
 
-out5:
-	free_irq(xd_irq, NULL);
-out4:
-	for (i = 0; i < xd_drives; i++)
-		put_disk(xd_gendisk[i]);
-out3:
-	if (xd_maxsectors)
-		release_region(xd_iobase,4);
+#ifdef DEBUG_COMMAND
+	printk("xd_command: command = 0x%X, mode = 0x%X, indata = 0x%X, outdata = 0x%X, sense = 0x%X\n",command,mode,indata,outdata,sense);
+#endif /* DEBUG_COMMAND */
 
-	if (xd_dma_buffer)
-		xd_dma_mem_free((unsigned long)xd_dma_buffer,
-				xd_maxsectors * 0x200);
-out2:
-	blk_cleanup_queue(xd_queue);
-out1a:
-	unregister_blkdev(XT_DISK_MAJOR, "xd");
-out1:
-	return err;
-Enomem:
-	err = -ENOMEM;
-	while (i--)
-		put_disk(xd_gendisk[i]);
-	goto out3;
-}
+	outb(0,XD_SELECT);
+	udelay(OUTB_DELAY);
+	outb(mode,XD_CONTROL);
+	udelay(OUTB_DELAY);
 
-/* xd_detect: scan the possible BIOS ROM locations for the signature strings */
-static u_char __init xd_detect(u_char *controller, unsigned int *address)
-{
-	int i, j;
+	if (xd_waitport(XD_STATUS,STAT_SELECT,STAT_SELECT,timeout))
+		return (1);
 
-	if (xd_override)
-	{
-		*controller = xd_type;
-		*address = 0;
-		return(1);
-	}
+	while (!complete) {
+		if (xd_waitport(XD_STATUS,STAT_READY,STAT_READY,timeout))
+			return (1);
 
-	for (i = 0; i < ARRAY_SIZE(xd_bases); i++) {
-		void __iomem *p = ioremap(xd_bases[i], 0x2000);
-		if (!p)
-			continue;
-		for (j = 1; j < ARRAY_SIZE(xd_sigs); j++) {
-			const char *s = xd_sigs[j].string;
-			if (check_signature(p + xd_sigs[j].offset, s, strlen(s))) {
-				*controller = j;
-				xd_type = j;
-				*address = xd_bases[i];
-				iounmap(p);
-				return 1;
-			}
+		switch (inb(XD_STATUS) & (STAT_COMMAND | STAT_INPUT)) {
+			case 0:
+				if (mode == DMA_MODE) {
+					if (xd_wait_for_IRQ())
+						return (1);
+				} else {
+					outb(outdata ? *outdata++ : 0,XD_DATA);
+					udelay(OUTB_DELAY);
+				}
+				break;
+			case STAT_INPUT:
+				if (mode == DMA_MODE) {
+					if (xd_wait_for_IRQ())
+						return (1);
+				} else
+					if (indata)
+						*indata++ = inb(XD_DATA);
+					else
+						inb(XD_DATA);
+				break;
+			case STAT_COMMAND:
+				outb(command ? *command++ : 0,XD_DATA);
+				udelay(OUTB_DELAY);
+				break;
+			case STAT_COMMAND | STAT_INPUT:
+				complete = 1;
+				break;
 		}
-		iounmap(p);
 	}
-	return 0;
-}
+	csb = inb(XD_DATA);
 
-/* do_xd_request: handle an incoming request */
-static void do_xd_request(struct request_queue * q)
-{
-	struct request *req;
+	if (xd_waitport(XD_STATUS,0,STAT_SELECT,timeout))					/* wait until deselected */
+		return (1);
 
-	if (xdc_busy)
-		return;
+	if (csb & CSB_ERROR) {									/* read sense data if error */
+		xd_build(cmdblk,CMD_SENSE,(csb & CSB_LUN) >> 5,0,0,0,0,0);
+		if (xd_command(cmdblk,0,sense,NULL,NULL,XD_TIMEOUT))
+			printk("xd: warning! sense command failed!\n");
+	}
 
-	req = blk_fetch_request(q);
-	while (req) {
-		unsigned block = blk_rq_pos(req);
-		unsigned count = blk_rq_cur_sectors(req);
-		struct xd_info *disk = req->rq_disk->private_data;
-		int res = 0;
-		int retry;
+#ifdef DEBUG_COMMAND
+	printk("xd_command: completed with csb = 0x%X\n",csb);
+#endif /* DEBUG_COMMAND */
 
-		if (req->cmd_type != REQ_TYPE_FS) {
-			pr_err("unsupported request: %d\n", req->cmd_type);
-			res = -EIO;
-			goto done;
-		}
-		if (block + count > get_capacity(req->rq_disk)) {
-			pr_err("request beyond device capacity\n");
-			res = -EIO;
-			goto done;
-		}
-		for (retry = 0; (retry < XD_RETRIES) && !res; retry++)
-			res = xd_readwrite(rq_data_dir(req), disk, req->buffer,
-					   block, count);
-	done:
-		/* wrap up, 0 = success, -errno = fail */
-		if (!__blk_end_request_cur(req, res))
-			req = blk_fetch_request(q);
-	}
+	return (csb & CSB_ERROR);
 }
 
-static int xd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
+/**
+ * xd_setparam() - set the drive characteristics
+ */
+static void __init xd_setparam (u_char command, u_char drive, u_char heads,
+				u_short cylinders, u_short rwrite,
+				u_short wprecomp, u_char ecc)
 {
-	struct xd_info *p = bdev->bd_disk->private_data;
+	u_char cmdblk[14];
 
-	geo->heads = p->heads;
-	geo->sectors = p->sectors;
-	geo->cylinders = p->cylinders;
-	return 0;
-}
+	xd_build(cmdblk,command,drive,0,0,0,0,0);
+	cmdblk[6] = (u_char) (cylinders >> 8) & 0x03;
+	cmdblk[7] = (u_char) (cylinders & 0xFF);
+	cmdblk[8] = heads & 0x1F;
+	cmdblk[9] = (u_char) (rwrite >> 8) & 0x03;
+	cmdblk[10] = (u_char) (rwrite & 0xFF);
+	cmdblk[11] = (u_char) (wprecomp >> 8) & 0x03;
+	cmdblk[12] = (u_char) (wprecomp & 0xFF);
+	cmdblk[13] = ecc;
 
-/* xd_ioctl: handle device ioctl's */
-static int xd_locked_ioctl(struct block_device *bdev, fmode_t mode,
-			   u_int cmd, u_long arg)
-{
-	switch (cmd) {
-		case HDIO_SET_DMA:
-			if (!capable(CAP_SYS_ADMIN)) return -EACCES;
-			if (xdc_busy) return -EBUSY;
-			nodma = !arg;
-			if (nodma && xd_dma_buffer) {
-				xd_dma_mem_free((unsigned long)xd_dma_buffer,
-						xd_maxsectors * 0x200);
-				xd_dma_buffer = NULL;
-			} else if (!nodma && !xd_dma_buffer) {
-				xd_dma_buffer = (char *)xd_dma_mem_alloc(xd_maxsectors * 0x200);
-				if (!xd_dma_buffer) {
-					nodma = XD_DONT_USE_DMA;
-					return -ENOMEM;
-				}
-			}
-			return 0;
-		case HDIO_GET_DMA:
-			return put_user(!nodma, (long __user *) arg);
-		case HDIO_GET_MULTCOUNT:
-			return put_user(xd_maxsectors, (long __user *) arg);
-		default:
-			return -EINVAL;
-	}
+	/* Some controllers require geometry info as data, not command */
+	if (xd_command(cmdblk,PIO_MODE,NULL,&cmdblk[6],NULL,XD_TIMEOUT * 2))
+		printk("xd: error setting characteristics for xd%c\n", 'a'+drive);
 }
 
-static int xd_ioctl(struct block_device *bdev, fmode_t mode,
-		    unsigned int cmd, unsigned long param)
+/**
+ * xd_recalibrate() - recalibrate a given drive and reset controller if
+ * necessary
+ */
+static void xd_recalibrate(u_char drive)
 {
-	int ret;
-
-	mutex_lock(&xd_mutex);
-	ret = xd_locked_ioctl(bdev, mode, cmd, param);
-	mutex_unlock(&xd_mutex);
+	u_char cmdblk[6];
 
-	return ret;
+	xd_build(cmdblk,CMD_RECALIBRATE,drive,0,0,0,0,0);
+	if (xd_command(cmdblk,PIO_MODE,NULL,NULL,NULL,XD_TIMEOUT * 8))
+		printk("xd%c: warning! error recalibrating, controller may be unstable\n", 'a'+drive);
 }
 
-/* xd_readwrite: handle a read/write request */
+/**
+ * xd_readwrite() - handle a read/write request
+ */
 static int xd_readwrite(u_char operation, struct xd_info *p, char *buffer,
 			u_int block, u_int count)
 {
@@ -496,187 +458,154 @@ static int xd_readwrite(u_char operation, struct xd_info *p, char *buffer,
 	return 0;
 }
 
-/* xd_recalibrate: recalibrate a given drive and reset controller if necessary */
-static void xd_recalibrate(u_char drive)
+/* xd_detect: scan the possible BIOS ROM locations for the signature strings */
+static u_char __init xd_detect(u_char *controller, unsigned int *address)
 {
-	u_char cmdblk[6];
+	int i, j;
 
-	xd_build(cmdblk,CMD_RECALIBRATE,drive,0,0,0,0,0);
-	if (xd_command(cmdblk,PIO_MODE,NULL,NULL,NULL,XD_TIMEOUT * 8))
-		printk("xd%c: warning! error recalibrating, controller may be unstable\n", 'a'+drive);
-}
+	if (xd_override)
+	{
+		*controller = xd_type;
+		*address = 0;
+		return(1);
+	}
 
-/* xd_interrupt_handler: interrupt service routine */
-static irqreturn_t xd_interrupt_handler(int irq, void *dev_id)
-{
-	if (inb(XD_STATUS) & STAT_INTERRUPT) {							/* check if it was our device */
-#ifdef DEBUG_OTHER
-		printk("xd_interrupt_handler: interrupt detected\n");
-#endif /* DEBUG_OTHER */
-		outb(0,XD_CONTROL); /* acknowledge interrupt */
-		udelay(OUTB_DELAY);
-		wake_up(&xd_wait_int);	/* and wake up sleeping processes */
-		return IRQ_HANDLED;
+	for (i = 0; i < ARRAY_SIZE(xd_bases); i++) {
+		void __iomem *p = ioremap(xd_bases[i], 0x2000);
+		if (!p)
+			continue;
+		for (j = 1; j < ARRAY_SIZE(xd_sigs); j++) {
+			const char *s = xd_sigs[j].string;
+			if (check_signature(p + xd_sigs[j].offset, s, strlen(s))) {
+				*controller = j;
+				xd_type = j;
+				*address = xd_bases[i];
+				iounmap(p);
+				return 1;
+			}
+		}
+		iounmap(p);
 	}
-	else
-		printk("xd: unexpected interrupt\n");
-	return IRQ_NONE;
+	return 0;
 }
 
-/* xd_setup_dma: set up the DMA controller for a data transfer */
-static u_char xd_setup_dma(u_char mode, u_char *buffer, u_int count)
+/* do_xd_request: handle an incoming request */
+static void do_xd_request(struct request_queue * q)
 {
-	unsigned long f;
-
-	if (nodma)
-		return (PIO_MODE);
-	if (((unsigned long) buffer & 0xFFFF0000) != (((unsigned long) buffer + count) & 0xFFFF0000)) {
-#ifdef DEBUG_OTHER
-		printk("xd_setup_dma: using PIO, transfer overlaps 64k boundary\n");
-#endif /* DEBUG_OTHER */
-		return (PIO_MODE);
-	}
+	struct request *req;
 
-	f=claim_dma_lock();
-	disable_dma(xd_dma);
-	clear_dma_ff(xd_dma);
-	set_dma_mode(xd_dma,mode);
-	set_dma_addr(xd_dma, (unsigned long) buffer);
-	set_dma_count(xd_dma,count);
+	if (xdc_busy)
+		return;
 
-	release_dma_lock(f);
+	req = blk_fetch_request(q);
+	while (req) {
+		unsigned block = blk_rq_pos(req);
+		unsigned count = blk_rq_cur_sectors(req);
+		struct xd_info *disk = req->rq_disk->private_data;
+		int res = 0;
+		int retry;
 
-	return (DMA_MODE); /* use DMA and INT */
+		if (req->cmd_type != REQ_TYPE_FS) {
+			pr_err("unsupported request: %d\n", req->cmd_type);
+			res = -EIO;
+			goto done;
+		}
+		if (block + count > get_capacity(req->rq_disk)) {
+			pr_err("request beyond device capacity\n");
+			res = -EIO;
+			goto done;
+		}
+		for (retry = 0; (retry < XD_RETRIES) && !res; retry++)
+			res = xd_readwrite(rq_data_dir(req), disk, req->buffer,
+					   block, count);
+	done:
+		/* wrap up, 0 = success, -errno = fail */
+		if (!__blk_end_request_cur(req, res))
+			req = blk_fetch_request(q);
+	}
 }
 
-/* xd_build: put stuff into an array in a format suitable for the controller */
-static u_char *xd_build(u_char *cmdblk, u_char command, u_char drive,
-			u_char head, u_short cylinder, u_char sector,
-			u_char count, u_char control)
+static int xd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
 {
-	cmdblk[0] = command;
-	cmdblk[1] = ((drive & 0x07) << 5) | (head & 0x1F);
-	cmdblk[2] = ((cylinder & 0x300) >> 2) | (sector & 0x3F);
-	cmdblk[3] = cylinder & 0xFF;
-	cmdblk[4] = count;
-	cmdblk[5] = control;
-
-	return (cmdblk);
-}
+	struct xd_info *p = bdev->bd_disk->private_data;
 
-static void xd_watchdog(unsigned long unused)
-{
-	xd_error = 1;
-	wake_up(&xd_wait_int);
+	geo->heads = p->heads;
+	geo->sectors = p->sectors;
+	geo->cylinders = p->cylinders;
+	return 0;
 }
 
-/* xd_waitport: waits until port & mask == flags or a timeout occurs. return 1 for a timeout */
-static inline u_char xd_waitport(u_short port, u_char flags,
-				 u_char mask, u_long timeout)
+static int xd_locked_ioctl(struct block_device *bdev, fmode_t mode,
+			   u_int cmd, u_long arg)
 {
-	u_long expiry = jiffies + timeout;
-	int success;
-
-	xdc_busy = 1;
-	while ((success = ((inb(port) & mask) != flags)) && time_before(jiffies, expiry))
-		schedule_timeout_uninterruptible(1);
-	xdc_busy = 0;
-	return (success);
+	switch (cmd) {
+		case HDIO_SET_DMA:
+			if (!capable(CAP_SYS_ADMIN)) return -EACCES;
+			if (xdc_busy) return -EBUSY;
+			nodma = !arg;
+			if (nodma && xd_dma_buffer) {
+				xd_dma_mem_free((unsigned long)xd_dma_buffer,
+						xd_maxsectors * 0x200);
+				xd_dma_buffer = NULL;
+			} else if (!nodma && !xd_dma_buffer) {
+				xd_dma_buffer = (char *)xd_dma_mem_alloc(xd_maxsectors * 0x200);
+				if (!xd_dma_buffer) {
+					nodma = XD_DONT_USE_DMA;
+					return -ENOMEM;
+				}
+			}
+			return 0;
+		case HDIO_GET_DMA:
+			return put_user(!nodma, (long __user *) arg);
+		case HDIO_GET_MULTCOUNT:
+			return put_user(xd_maxsectors, (long __user *) arg);
+		default:
+			return -EINVAL;
+	}
 }
 
-static inline u_int xd_wait_for_IRQ(void)
+/**
+ * xd_ioctl() - handle device ioctl's
+ */
+static int xd_ioctl(struct block_device *bdev, fmode_t mode,
+		    unsigned int cmd, unsigned long param)
 {
-	unsigned long flags;
-	xd_watchdog_int.expires = jiffies + 30 * HZ;
-	add_timer(&xd_watchdog_int);
+	int ret;
 
-	flags=claim_dma_lock();
-	enable_dma(xd_dma);
-	release_dma_lock(flags);
+	mutex_lock(&xd_mutex);
+	ret = xd_locked_ioctl(bdev, mode, cmd, param);
+	mutex_unlock(&xd_mutex);
 
-	sleep_on(&xd_wait_int);
-	del_timer(&xd_watchdog_int);
-	xdc_busy = 0;
+	return ret;
+}
 
-	flags=claim_dma_lock();
-	disable_dma(xd_dma);
-	release_dma_lock(flags);
+static const struct block_device_operations xd_fops = {
+	.owner	= THIS_MODULE,
+	.ioctl	= xd_ioctl,
+	.getgeo = xd_getgeo,
+};
 
-	if (xd_error) {
-		printk("xd: missed IRQ - command aborted\n");
-		xd_error = 0;
-		return (1);
+/* xd_interrupt_handler: interrupt service routine */
+static irqreturn_t xd_interrupt_handler(int irq, void *dev_id)
+{
+	if (inb(XD_STATUS) & STAT_INTERRUPT) {							/* check if it was our device */
+#ifdef DEBUG_OTHER
+		printk("xd_interrupt_handler: interrupt detected\n");
+#endif /* DEBUG_OTHER */
+		outb(0,XD_CONTROL); /* acknowledge interrupt */
+		udelay(OUTB_DELAY);
+		wake_up(&xd_wait_int);	/* and wake up sleeping processes */
+		return IRQ_HANDLED;
 	}
-	return (0);
+	else
+		printk("xd: unexpected interrupt\n");
+	return IRQ_NONE;
 }
 
-/* xd_command: handle all data transfers necessary for a single command */
-static u_int xd_command(u_char *command, u_char mode, u_char *indata,
-			u_char *outdata, u_char *sense, u_long timeout)
+static void xd_watchdog(unsigned long unused)
 {
-	u_char cmdblk[6], csb, complete = 0;
-
-#ifdef DEBUG_COMMAND
-	printk("xd_command: command = 0x%X, mode = 0x%X, indata = 0x%X, outdata = 0x%X, sense = 0x%X\n",command,mode,indata,outdata,sense);
-#endif /* DEBUG_COMMAND */
-
-	outb(0,XD_SELECT);
-	udelay(OUTB_DELAY);
-	outb(mode,XD_CONTROL);
-	udelay(OUTB_DELAY);
-
-	if (xd_waitport(XD_STATUS,STAT_SELECT,STAT_SELECT,timeout))
-		return (1);
-
-	while (!complete) {
-		if (xd_waitport(XD_STATUS,STAT_READY,STAT_READY,timeout))
-			return (1);
-
-		switch (inb(XD_STATUS) & (STAT_COMMAND | STAT_INPUT)) {
-			case 0:
-				if (mode == DMA_MODE) {
-					if (xd_wait_for_IRQ())
-						return (1);
-				} else {
-					outb(outdata ? *outdata++ : 0,XD_DATA);
-					udelay(OUTB_DELAY);
-				}
-				break;
-			case STAT_INPUT:
-				if (mode == DMA_MODE) {
-					if (xd_wait_for_IRQ())
-						return (1);
-				} else
-					if (indata)
-						*indata++ = inb(XD_DATA);
-					else
-						inb(XD_DATA);
-				break;
-			case STAT_COMMAND:
-				outb(command ? *command++ : 0,XD_DATA);
-				udelay(OUTB_DELAY);
-				break;
-			case STAT_COMMAND | STAT_INPUT:
-				complete = 1;
-				break;
-		}
-	}
-	csb = inb(XD_DATA);
-
-	if (xd_waitport(XD_STATUS,0,STAT_SELECT,timeout))					/* wait until deselected */
-		return (1);
-
-	if (csb & CSB_ERROR) {									/* read sense data if error */
-		xd_build(cmdblk,CMD_SENSE,(csb & CSB_LUN) >> 5,0,0,0,0,0);
-		if (xd_command(cmdblk,0,sense,NULL,NULL,XD_TIMEOUT))
-			printk("xd: warning! sense command failed!\n");
-	}
-
-#ifdef DEBUG_COMMAND
-	printk("xd_command: completed with csb = 0x%X\n",csb);
-#endif /* DEBUG_COMMAND */
-
-	return (csb & CSB_ERROR);
+	xd_error = 1;
+	wake_up(&xd_wait_int);
 }
 
 static u_char __init xd_initdrives(void (*init_drive)(u_char drive))
@@ -1083,29 +1012,129 @@ static void __init do_xd_setup(int *integers)
 	xd_maxsectors = 0x01;
 }
 
-/**
- * xd_setparam() - set the drive characteristics
- */
-static void __init xd_setparam (u_char command, u_char drive, u_char heads,
-				u_short cylinders, u_short rwrite,
-				u_short wprecomp, u_char ecc)
+/* xd_init: register the block device number and set up pointer tables */
+static int __init xd_init(void)
 {
-	u_char cmdblk[14];
+	u_char i,controller;
+	unsigned int address;
+	int err;
 
-	xd_build(cmdblk,command,drive,0,0,0,0,0);
-	cmdblk[6] = (u_char) (cylinders >> 8) & 0x03;
-	cmdblk[7] = (u_char) (cylinders & 0xFF);
-	cmdblk[8] = heads & 0x1F;
-	cmdblk[9] = (u_char) (rwrite >> 8) & 0x03;
-	cmdblk[10] = (u_char) (rwrite & 0xFF);
-	cmdblk[11] = (u_char) (wprecomp >> 8) & 0x03;
-	cmdblk[12] = (u_char) (wprecomp & 0xFF);
-	cmdblk[13] = ecc;
+#ifdef MODULE
+	{
+		u_char count = 0;
+		for (i = 4; i > 0; i--)
+			if (((xd[i] = xd[i-1]) >= 0) && !count)
+				count = i;
+		if ((xd[0] = count))
+			do_xd_setup(xd);
+	}
+#endif
 
-	/* Some controllers require geometry info as data, not command */
+	init_timer (&xd_watchdog_int); xd_watchdog_int.function = xd_watchdog;
 
-	if (xd_command(cmdblk,PIO_MODE,NULL,&cmdblk[6],NULL,XD_TIMEOUT * 2))
-		printk("xd: error setting characteristics for xd%c\n", 'a'+drive);
+	err = -EBUSY;
+	if (register_blkdev(XT_DISK_MAJOR, "xd"))
+		goto out1;
+
+	err = -ENOMEM;
+	xd_queue = blk_init_queue(do_xd_request, &xd_lock);
+	if (!xd_queue)
+		goto out1a;
+
+	if (xd_detect(&controller,&address)) {
+
+		printk("Detected a%s controller (type %d) at address %06x\n",
+			xd_sigs[controller].name,controller,address);
+		if (!request_region(xd_iobase,4,"xd")) {
+			printk("xd: Ports at 0x%x are not available\n",
+				xd_iobase);
+			goto out2;
+		}
+		if (controller)
+			xd_sigs[controller].init_controller(address);
+		xd_drives = xd_initdrives(xd_sigs[controller].init_drive);
+
+		printk("Detected %d hard drive%s (using IRQ%d & DMA%d)\n",
+			xd_drives,xd_drives == 1 ? "" : "s",xd_irq,xd_dma);
+	}
+
+	/*
+	 * With the drive detected, xd_maxsectors should now be known.
+	 * If xd_maxsectors is 0, nothing was detected and we fall through
+	 * to return -ENODEV
+	 */
+	if (!xd_dma_buffer && xd_maxsectors) {
+		xd_dma_buffer = (char *)xd_dma_mem_alloc(xd_maxsectors * 0x200);
+		if (!xd_dma_buffer) {
+			printk(KERN_ERR "xd: Out of memory.\n");
+			goto out3;
+		}
+	}
+
+	err = -ENODEV;
+	if (!xd_drives)
+		goto out3;
+
+	for (i = 0; i < xd_drives; i++) {
+		struct xd_info *p = &xd_info[i];
+		struct gendisk *disk = alloc_disk(64);
+		if (!disk)
+			goto Enomem;
+		p->unit = i;
+		disk->major = XT_DISK_MAJOR;
+		disk->first_minor = i<<6;
+		sprintf(disk->disk_name, "xd%c", i+'a');
+		disk->fops = &xd_fops;
+		disk->private_data = p;
+		disk->queue = xd_queue;
+		set_capacity(disk, p->heads * p->cylinders * p->sectors);
+		printk(" %s: CHS=%d/%d/%d\n", disk->disk_name,
+			p->cylinders, p->heads, p->sectors);
+		xd_gendisk[i] = disk;
+	}
+
+	err = -EBUSY;
+	if (request_irq(xd_irq,xd_interrupt_handler, 0, "XT hard disk", NULL)) {
+		printk("xd: unable to get IRQ%d\n",xd_irq);
+		goto out4;
+	}
+
+	if (request_dma(xd_dma,"xd")) {
+		printk("xd: unable to get DMA%d\n",xd_dma);
+		goto out5;
+	}
+
+	/* xd_maxsectors depends on controller - so set after detection */
+	blk_queue_max_hw_sectors(xd_queue, xd_maxsectors);
+
+	for (i = 0; i < xd_drives; i++)
+		add_disk(xd_gendisk[i]);
+
+	return 0;
+
+out5:
+	free_irq(xd_irq, NULL);
+out4:
+	for (i = 0; i < xd_drives; i++)
+		put_disk(xd_gendisk[i]);
+out3:
+	if (xd_maxsectors)
+		release_region(xd_iobase,4);
+
+	if (xd_dma_buffer)
+		xd_dma_mem_free((unsigned long)xd_dma_buffer,
+				xd_maxsectors * 0x200);
+out2:
+	blk_cleanup_queue(xd_queue);
+out1a:
+	unregister_blkdev(XT_DISK_MAJOR, "xd");
+out1:
+	return err;
+Enomem:
+	err = -ENOMEM;
+	while (i--)
+		put_disk(xd_gendisk[i]);
+	goto out3;
 }
 
 #ifdef MODULE
diff --git a/drivers/block/xd.h b/drivers/block/xd.h
index 40630db..f09a33d 100644
--- a/drivers/block/xd.h
+++ b/drivers/block/xd.h
@@ -98,37 +98,4 @@ struct xd_signature {
 	const char *name;
 };
 
-#ifndef MODULE
-static int xd_manual_geo_init (char *command);
-#endif /* MODULE */
-static u_char xd_detect (u_char *controller, unsigned int *address);
-static u_char xd_initdrives (void (*init_drive)(u_char drive));
-
-static void do_xd_request (struct request_queue * q);
-static int xd_ioctl (struct block_device *bdev,fmode_t mode,unsigned int cmd,unsigned long arg);
-static int xd_readwrite (u_char operation, struct xd_info *disk,char *buffer,u_int block,u_int count);
-static void xd_recalibrate (u_char drive);
-
-static irqreturn_t xd_interrupt_handler(int irq, void *dev_id);
-static u_char xd_setup_dma (u_char opcode,u_char *buffer,u_int count);
-static u_char *xd_build (u_char *cmdblk,u_char command,u_char drive,u_char head,u_short cylinder,u_char sector,u_char count,u_char control);
-static void xd_watchdog (unsigned long unused);
-static inline u_char xd_waitport (u_short port,u_char flags,u_char mask,u_long timeout);
-static u_int xd_command (u_char *command,u_char mode,u_char *indata,u_char *outdata,u_char *sense,u_long timeout);
-
-/* card specific setup and geometry gathering code */
-static void xd_dtc_init_controller (unsigned int address);
-static void xd_dtc5150cx_init_drive (u_char drive);
-static void xd_dtc_init_drive (u_char drive);
-static void xd_wd_init_controller (unsigned int address);
-static void xd_wd_init_drive (u_char drive);
-static void xd_seagate_init_controller (unsigned int address);
-static void xd_seagate_init_drive (u_char drive);
-static void xd_omti_init_controller (unsigned int address);
-static void xd_omti_init_drive (u_char drive);
-static void xd_xebec_init_controller (unsigned int address);
-static void xd_xebec_init_drive (u_char drive);
-static void xd_setparam (u_char command,u_char drive,u_char heads,u_short cylinders,u_short rwrite,u_short wprecomp,u_char ecc);
-static void xd_override_init_drive (u_char drive);
-
 #endif /* _LINUX_XD_H */
-- 
1.8.1.2


^ permalink raw reply related	[flat|nested] 11+ messages in thread
* [PATCH 7/9] block: xd: merge header file into driver
  2013-02-12 22:40             ` [PATCH 6/9] block: xd: avoid some forward declarations Linus Walleij
@ 2013-02-12 22:40               ` Linus Walleij
  2013-02-12 22:40                 ` [PATCH 8/9] block: xd: remove custom DEBUG print system Linus Walleij
  0 siblings, 1 reply; 11+ messages in thread
From: Linus Walleij @ 2013-02-12 22:40 UTC (permalink / raw)
  To: Jens Axboe; +Cc: linux-kernel, Linus Walleij

This consolidates the XD driver in one single file.
No semantic changes.

Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
---
 drivers/block/xd.c |  84 +++++++++++++++++++++++++++++++++++++++++++-
 drivers/block/xd.h | 101 -----------------------------------------------------
 2 files changed, 83 insertions(+), 102 deletions(-)
 delete mode 100644 drivers/block/xd.h

diff --git a/drivers/block/xd.c b/drivers/block/xd.c
index ffa6e76..1875590 100644
--- a/drivers/block/xd.c
+++ b/drivers/block/xd.c
@@ -53,11 +53,93 @@
 #include <linux/delay.h>
 #include <linux/io.h>
 #include <linux/gfp.h>
+#include <linux/interrupt.h>
 
 #include <asm/uaccess.h>
 #include <asm/dma.h>
 
-#include "xd.h"
+/* XT hard disk controller registers */
+#define XD_DATA		(xd_iobase + 0x00)	/* data RW register */
+#define XD_RESET	(xd_iobase + 0x01)	/* reset WO register */
+#define XD_STATUS	(xd_iobase + 0x01)	/* status RO register */
+#define XD_SELECT	(xd_iobase + 0x02)	/* select WO register */
+#define XD_JUMPER	(xd_iobase + 0x02)	/* jumper RO register */
+#define XD_CONTROL	(xd_iobase + 0x03)	/* DMAE/INTE WO register */
+#define XD_RESERVED	(xd_iobase + 0x03)	/* reserved */
+
+/* XT hard disk controller commands (incomplete list) */
+#define CMD_TESTREADY	0x00	/* test drive ready */
+#define CMD_RECALIBRATE	0x01	/* recalibrate drive */
+#define CMD_SENSE	0x03	/* request sense */
+#define CMD_FORMATDRV	0x04	/* format drive */
+#define CMD_VERIFY	0x05	/* read verify */
+#define CMD_FORMATTRK	0x06	/* format track */
+#define CMD_FORMATBAD	0x07	/* format bad track */
+#define CMD_READ	0x08	/* read */
+#define CMD_WRITE	0x0A	/* write */
+#define CMD_SEEK	0x0B	/* seek */
+
+/* Controller specific commands */
+#define CMD_DTCSETPARAM	0x0C	/* set drive parameters (DTC 5150X & CX only?) */
+#define CMD_DTCGETECC	0x0D	/* get ecc error length (DTC 5150X only?) */
+#define CMD_DTCREADBUF	0x0E	/* read sector buffer (DTC 5150X only?) */
+#define CMD_DTCWRITEBUF 0x0F	/* write sector buffer (DTC 5150X only?) */
+#define CMD_DTCREMAPTRK	0x11	/* assign alternate track (DTC 5150X only?) */
+#define CMD_DTCGETPARAM	0xFB	/* get drive parameters (DTC 5150X only?) */
+#define CMD_DTCSETSTEP	0xFC	/* set step rate (DTC 5150X only?) */
+#define CMD_DTCSETGEOM	0xFE	/* set geometry data (DTC 5150X only?) */
+#define CMD_DTCGETGEOM	0xFF	/* get geometry data (DTC 5150X only?) */
+#define CMD_ST11GETGEOM 0xF8	/* get geometry data (Seagate ST11R/M only?) */
+#define CMD_WDSETPARAM	0x0C	/* set drive parameters (WD 1004A27X only?) */
+#define CMD_XBSETPARAM	0x0C	/* set drive parameters (XEBEC only?) */
+
+/* Bits for command status byte */
+#define CSB_ERROR	0x02	/* error */
+#define CSB_LUN		0x20	/* logical Unit Number */
+
+/* XT hard disk controller status bits */
+#define STAT_READY	0x01	/* controller is ready */
+#define STAT_INPUT	0x02	/* data flowing from controller to host */
+#define STAT_COMMAND	0x04	/* controller in command phase */
+#define STAT_SELECT	0x08	/* controller is selected */
+#define STAT_REQUEST	0x10	/* controller requesting data */
+#define STAT_INTERRUPT	0x20	/* controller requesting interrupt */
+
+/* XT hard disk controller control bits */
+#define PIO_MODE	0x00	/* control bits to set for PIO */
+#define DMA_MODE	0x03	/* control bits to set for DMA & interrupt */
+
+#define XD_MAXDRIVES	2	/* maximum 2 drives */
+#define XD_TIMEOUT	(HZ * 30)	/* 30 second timeout */
+#define XD_RETRIES	4	/* maximum 4 retries */
+
+#undef DEBUG			/* define for debugging output */
+
+#ifdef DEBUG
+	#define DEBUG_STARTUP	/* debug driver initialisation */
+	#define DEBUG_OVERRIDE	/* debug override geometry detection */
+	#define DEBUG_READWRITE	/* debug each read/write command */
+	#define DEBUG_OTHER	/* debug misc. interrupt/DMA stuff */
+	#define DEBUG_COMMAND	/* debug each controller command */
+#endif /* DEBUG */
+
+/* this structure defines the XT drives and their types */
+struct xd_info {
+	u_char heads;
+	u_short cylinders;
+	u_char sectors;
+	u_char control;
+	int unit;
+};
+
+/* this structure defines a ROM BIOS signature */
+struct xd_signature {
+	unsigned int offset;
+	const char *string;
+	void (*init_controller)(unsigned int address);
+	void (*init_drive)(u_char drive);
+	const char *name;
+};
 
 #define OUTB_DELAY 100
 
diff --git a/drivers/block/xd.h b/drivers/block/xd.h
deleted file mode 100644
index f09a33d..0000000
--- a/drivers/block/xd.h
+++ /dev/null
@@ -1,101 +0,0 @@
-#ifndef _LINUX_XD_H
-#define _LINUX_XD_H
-
-/*
- * This file contains the definitions for the IO ports and errors etc. for XT hard disk controllers (at least the DTC 5150X).
- *
- * Author: Pat Mackinlay, pat@it.com.au
- * Date: 29/09/92
- *
- * Revised: 01/01/93, ...
- *
- * Ref: DTC 5150X Controller Specification (thanks to Kevin Fowler, kevinf@agora.rain.com)
- * Also thanks to: Salvador Abreu, Dave Thaler, Risto Kankkunen and Wim Van Dorst.
- */
-
-#include <linux/interrupt.h>
-
-/* XT hard disk controller registers */
-#define XD_DATA		(xd_iobase + 0x00)	/* data RW register */
-#define XD_RESET	(xd_iobase + 0x01)	/* reset WO register */
-#define XD_STATUS	(xd_iobase + 0x01)	/* status RO register */
-#define XD_SELECT	(xd_iobase + 0x02)	/* select WO register */
-#define XD_JUMPER	(xd_iobase + 0x02)	/* jumper RO register */
-#define XD_CONTROL	(xd_iobase + 0x03)	/* DMAE/INTE WO register */
-#define XD_RESERVED	(xd_iobase + 0x03)	/* reserved */
-
-/* XT hard disk controller commands (incomplete list) */
-#define CMD_TESTREADY	0x00	/* test drive ready */
-#define CMD_RECALIBRATE	0x01	/* recalibrate drive */
-#define CMD_SENSE	0x03	/* request sense */
-#define CMD_FORMATDRV	0x04	/* format drive */
-#define CMD_VERIFY	0x05	/* read verify */
-#define CMD_FORMATTRK	0x06	/* format track */
-#define CMD_FORMATBAD	0x07	/* format bad track */
-#define CMD_READ	0x08	/* read */
-#define CMD_WRITE	0x0A	/* write */
-#define CMD_SEEK	0x0B	/* seek */
-
-/* Controller specific commands */
-#define CMD_DTCSETPARAM	0x0C	/* set drive parameters (DTC 5150X & CX only?) */
-#define CMD_DTCGETECC	0x0D	/* get ecc error length (DTC 5150X only?) */
-#define CMD_DTCREADBUF	0x0E	/* read sector buffer (DTC 5150X only?) */
-#define CMD_DTCWRITEBUF 0x0F	/* write sector buffer (DTC 5150X only?) */
-#define CMD_DTCREMAPTRK	0x11	/* assign alternate track (DTC 5150X only?) */
-#define CMD_DTCGETPARAM	0xFB	/* get drive parameters (DTC 5150X only?) */
-#define CMD_DTCSETSTEP	0xFC	/* set step rate (DTC 5150X only?) */
-#define CMD_DTCSETGEOM	0xFE	/* set geometry data (DTC 5150X only?) */
-#define CMD_DTCGETGEOM	0xFF	/* get geometry data (DTC 5150X only?) */
-#define CMD_ST11GETGEOM 0xF8	/* get geometry data (Seagate ST11R/M only?) */
-#define CMD_WDSETPARAM	0x0C	/* set drive parameters (WD 1004A27X only?) */
-#define CMD_XBSETPARAM	0x0C	/* set drive parameters (XEBEC only?) */
-
-/* Bits for command status byte */
-#define CSB_ERROR	0x02	/* error */
-#define CSB_LUN		0x20	/* logical Unit Number */
-
-/* XT hard disk controller status bits */
-#define STAT_READY	0x01	/* controller is ready */
-#define STAT_INPUT	0x02	/* data flowing from controller to host */
-#define STAT_COMMAND	0x04	/* controller in command phase */
-#define STAT_SELECT	0x08	/* controller is selected */
-#define STAT_REQUEST	0x10	/* controller requesting data */
-#define STAT_INTERRUPT	0x20	/* controller requesting interrupt */
-
-/* XT hard disk controller control bits */
-#define PIO_MODE	0x00	/* control bits to set for PIO */
-#define DMA_MODE	0x03	/* control bits to set for DMA & interrupt */
-
-#define XD_MAXDRIVES	2	/* maximum 2 drives */
-#define XD_TIMEOUT	(HZ * 30)	/* 30 second timeout */
-#define XD_RETRIES	4	/* maximum 4 retries */
-
-#undef DEBUG			/* define for debugging output */
-
-#ifdef DEBUG
-	#define DEBUG_STARTUP	/* debug driver initialisation */
-	#define DEBUG_OVERRIDE	/* debug override geometry detection */
-	#define DEBUG_READWRITE	/* debug each read/write command */
-	#define DEBUG_OTHER	/* debug misc. interrupt/DMA stuff */
-	#define DEBUG_COMMAND	/* debug each controller command */
-#endif /* DEBUG */
-
-/* this structure defines the XT drives and their types */
-struct xd_info {
-	u_char heads;
-	u_short cylinders;
-	u_char sectors;
-	u_char control;
-	int unit;
-};
-
-/* this structure defines a ROM BIOS signature */
-struct xd_signature {
-	unsigned int offset;
-	const char *string;
-	void (*init_controller)(unsigned int address);
-	void (*init_drive)(u_char drive);
-	const char *name;
-};
-
-#endif /* _LINUX_XD_H */
-- 
1.8.1.2


^ permalink raw reply related	[flat|nested] 11+ messages in thread
* [PATCH 8/9] block: xd: remove custom DEBUG print system
  2013-02-12 22:40               ` [PATCH 7/9] block: xd: merge header file into driver Linus Walleij
@ 2013-02-12 22:40                 ` Linus Walleij
  2013-02-12 22:41                   ` [PATCH 9/9] block: xd: replace all printks with pr_* Linus Walleij
  0 siblings, 1 reply; 11+ messages in thread
From: Linus Walleij @ 2013-02-12 22:40 UTC (permalink / raw)
  To: Jens Axboe; +Cc: linux-kernel, Linus Walleij

The driver used a variant of debug levels, convert this over to
using the kernel pr_debug() macro for all instances. Instead
of hard-coding function names in debug messages, pass __func__.

Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
---
 drivers/block/xd.c | 46 +++++++++++++++-------------------------------
 1 file changed, 15 insertions(+), 31 deletions(-)

diff --git a/drivers/block/xd.c b/drivers/block/xd.c
index 1875590..7ecebd4 100644
--- a/drivers/block/xd.c
+++ b/drivers/block/xd.c
@@ -113,16 +113,6 @@
 #define XD_TIMEOUT	(HZ * 30)	/* 30 second timeout */
 #define XD_RETRIES	4	/* maximum 4 retries */
 
-#undef DEBUG			/* define for debugging output */
-
-#ifdef DEBUG
-	#define DEBUG_STARTUP	/* debug driver initialisation */
-	#define DEBUG_OVERRIDE	/* debug override geometry detection */
-	#define DEBUG_READWRITE	/* debug each read/write command */
-	#define DEBUG_OTHER	/* debug misc. interrupt/DMA stuff */
-	#define DEBUG_COMMAND	/* debug each controller command */
-#endif /* DEBUG */
-
 /* this structure defines the XT drives and their types */
 struct xd_info {
 	u_char heads;
@@ -270,9 +260,8 @@ static u_char xd_setup_dma(u_char mode, u_char *buffer, u_int count)
 	if (nodma)
 		return (PIO_MODE);
 	if (((unsigned long) buffer & 0xFFFF0000) != (((unsigned long) buffer + count) & 0xFFFF0000)) {
-#ifdef DEBUG_OTHER
-		printk("xd_setup_dma: using PIO, transfer overlaps 64k boundary\n");
-#endif /* DEBUG_OTHER */
+		pr_debug("%s: using PIO, transfer overlaps 64k boundary\n",
+			 __func__);
 		return (PIO_MODE);
 	}
 
@@ -357,10 +346,8 @@ static u_int xd_command(u_char *command, u_char mode, u_char *indata,
 {
 	u_char cmdblk[6], csb, complete = 0;
 
-#ifdef DEBUG_COMMAND
-	printk("xd_command: command = 0x%X, mode = 0x%X, indata = 0x%X, outdata = 0x%X, sense = 0x%X\n",command,mode,indata,outdata,sense);
-#endif /* DEBUG_COMMAND */
-
+	pr_debug("%s: command = 0x%p, mode = 0x%X, indata = 0x%p, outdata = 0x%p, sense = 0x%p\n",
+		 __func__, command, mode, indata, outdata, sense);
 	outb(0,XD_SELECT);
 	udelay(OUTB_DELAY);
 	outb(mode,XD_CONTROL);
@@ -413,9 +400,7 @@ static u_int xd_command(u_char *command, u_char mode, u_char *indata,
 			printk("xd: warning! sense command failed!\n");
 	}
 
-#ifdef DEBUG_COMMAND
-	printk("xd_command: completed with csb = 0x%X\n",csb);
-#endif /* DEBUG_COMMAND */
+	pr_debug("%s: completed with csb = 0x%X\n", __func__, csb);
 
 	return (csb & CSB_ERROR);
 }
@@ -470,9 +455,9 @@ static int xd_readwrite(u_char operation, struct xd_info *p, char *buffer,
 	char **real_buffer;
 	register int i;
 
-#ifdef DEBUG_READWRITE
-	printk("xd_readwrite: operation = %s, drive = %d, buffer = 0x%X, block = %d, count = %d\n",operation == READ ? "read" : "write",drive,buffer,block,count);
-#endif /* DEBUG_READWRITE */
+	pr_debug("%s: operation = %s, drive = %d, buffer = 0x%p, block = %d, count = %d\n",
+		 __func__, operation == READ ? "read" : "write",
+		 drive, buffer, block, count);
 
 	spin_unlock_irq(&xd_lock);
 
@@ -487,9 +472,8 @@ static int xd_readwrite(u_char operation, struct xd_info *p, char *buffer,
 		cylinder = track / p->heads;
 		sector = block % p->sectors;
 
-#ifdef DEBUG_READWRITE
-		printk("xd_readwrite: drive = %d, head = %d, cylinder = %d, sector = %d, count = %d\n",drive,head,cylinder,sector,temp);
-#endif /* DEBUG_READWRITE */
+		pr_debug("%s: drive = %d, head = %d, cylinder = %d, sector = %d, count = %d\n",
+			 __func__, drive, head, cylinder, sector, temp);
 
 		if (xd_dma_buffer) {
 			mode = xd_setup_dma(operation == READ ? DMA_MODE_READ : DMA_MODE_WRITE,(u_char *)(xd_dma_buffer),temp * 0x200);
@@ -588,12 +572,14 @@ static void do_xd_request(struct request_queue * q)
 		int retry;
 
 		if (req->cmd_type != REQ_TYPE_FS) {
-			pr_err("unsupported request: %d\n", req->cmd_type);
+			pr_err("%s: unsupported request: %d\n",
+			       __func__, req->cmd_type);
 			res = -EIO;
 			goto done;
 		}
 		if (block + count > get_capacity(req->rq_disk)) {
-			pr_err("request beyond device capacity\n");
+			pr_err("%s: request beyond device capacity\n",
+			       __func__);
 			res = -EIO;
 			goto done;
 		}
@@ -671,9 +657,7 @@ static const struct block_device_operations xd_fops = {
 static irqreturn_t xd_interrupt_handler(int irq, void *dev_id)
 {
 	if (inb(XD_STATUS) & STAT_INTERRUPT) {							/* check if it was our device */
-#ifdef DEBUG_OTHER
-		printk("xd_interrupt_handler: interrupt detected\n");
-#endif /* DEBUG_OTHER */
+		pr_debug("%s: interrupt detected\n", __func__);
 		outb(0,XD_CONTROL); /* acknowledge interrupt */
 		udelay(OUTB_DELAY);
 		wake_up(&xd_wait_int);	/* and wake up sleeping processes */
-- 
1.8.1.2


^ permalink raw reply related	[flat|nested] 11+ messages in thread
* [PATCH 9/9] block: xd: replace all printks with pr_*
  2013-02-12 22:40                 ` [PATCH 8/9] block: xd: remove custom DEBUG print system Linus Walleij
@ 2013-02-12 22:41                   ` Linus Walleij
  0 siblings, 0 replies; 11+ messages in thread
From: Linus Walleij @ 2013-02-12 22:41 UTC (permalink / raw)
  To: Jens Axboe; +Cc: linux-kernel, Linus Walleij

This replaces all the printk() statements with pr_* messages
tagged with the apropriate log level. Errors are printed as
pr_err() etc.

Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
---
 drivers/block/xd.c | 97 ++++++++++++++++++++++++++++++++++--------------------
 1 file changed, 62 insertions(+), 35 deletions(-)

diff --git a/drivers/block/xd.c b/drivers/block/xd.c
index 7ecebd4..8ee500f 100644
--- a/drivers/block/xd.c
+++ b/drivers/block/xd.c
@@ -331,7 +331,7 @@ static inline u_int xd_wait_for_IRQ(void)
 	release_dma_lock(flags);
 
 	if (xd_error) {
-		printk("xd: missed IRQ - command aborted\n");
+		pr_err("xd: missed IRQ - command aborted\n");
 		xd_error = 0;
 		return (1);
 	}
@@ -397,7 +397,7 @@ static u_int xd_command(u_char *command, u_char mode, u_char *indata,
 	if (csb & CSB_ERROR) {									/* read sense data if error */
 		xd_build(cmdblk,CMD_SENSE,(csb & CSB_LUN) >> 5,0,0,0,0,0);
 		if (xd_command(cmdblk,0,sense,NULL,NULL,XD_TIMEOUT))
-			printk("xd: warning! sense command failed!\n");
+			pr_warning("xd: warning! sense command failed!\n");
 	}
 
 	pr_debug("%s: completed with csb = 0x%X\n", __func__, csb);
@@ -426,7 +426,8 @@ static void __init xd_setparam (u_char command, u_char drive, u_char heads,
 
 	/* Some controllers require geometry info as data, not command */
 	if (xd_command(cmdblk,PIO_MODE,NULL,&cmdblk[6],NULL,XD_TIMEOUT * 2))
-		printk("xd: error setting characteristics for xd%c\n", 'a'+drive);
+		pr_err("xd: error setting characteristics for xd%c\n",
+		       'a' + drive);
 }
 
 /**
@@ -439,7 +440,8 @@ static void xd_recalibrate(u_char drive)
 
 	xd_build(cmdblk,CMD_RECALIBRATE,drive,0,0,0,0,0);
 	if (xd_command(cmdblk,PIO_MODE,NULL,NULL,NULL,XD_TIMEOUT * 8))
-		printk("xd%c: warning! error recalibrating, controller may be unstable\n", 'a'+drive);
+		pr_warning("xd%c: warning! error recalibrating, controller may be unstable\n",
+			   'a' + drive);
 }
 
 /**
@@ -488,29 +490,40 @@ static int xd_readwrite(u_char operation, struct xd_info *p, char *buffer,
 
 		switch (xd_command(cmdblk,mode,(u_char *)(*real_buffer),(u_char *)(*real_buffer),sense,XD_TIMEOUT)) {
 			case 1:
-				printk("xd%c: %s timeout, recalibrating drive\n",'a'+drive,(operation == READ ? "read" : "write"));
+				pr_err("xd%c: %s timeout, recalibrating drive\n",
+				       'a' + drive,
+				       (operation == READ ? "read" : "write"));
 				xd_recalibrate(drive);
 				spin_lock_irq(&xd_lock);
 				return -EIO;
 			case 2:
 				if (sense[0] & 0x30) {
-					printk("xd%c: %s - ",'a'+drive,(operation == READ ? "reading" : "writing"));
+					pr_err("xd%c: %s - ", 'a' + drive,
+					       (operation == READ ? "reading" : "writing"));
 					switch ((sense[0] & 0x30) >> 4) {
-					case 0: printk("drive error, code = 0x%X",sense[0] & 0x0F);
+					case 0:
+						pr_cont("drive error, code = 0x%X",
+						       sense[0] & 0x0F);
 						break;
-					case 1: printk("controller error, code = 0x%X",sense[0] & 0x0F);
+					case 1:
+						pr_cont("controller error, code = 0x%X",
+						       sense[0] & 0x0F);
 						break;
-					case 2: printk("command error, code = 0x%X",sense[0] & 0x0F);
+					case 2:
+						pr_cont("command error, code = 0x%X",
+						       sense[0] & 0x0F);
 						break;
-					case 3: printk("miscellaneous error, code = 0x%X",sense[0] & 0x0F);
+					case 3:
+						pr_cont("miscellaneous error, code = 0x%X",
+						       sense[0] & 0x0F);
 						break;
 					}
 				}
 				if (sense[0] & 0x80)
-					printk(" - CHS = %d/%d/%d\n",((sense[2] & 0xC0) << 2) | sense[3],sense[1] & 0x1F,sense[2] & 0x3F);
+					pr_cont(" - CHS = %d/%d/%d\n",((sense[2] & 0xC0) << 2) | sense[3],sense[1] & 0x1F,sense[2] & 0x3F);
 				/*	reported drive number = (sense[1] & 0xE0) >> 5 */
 				else
-					printk(" - no valid disk address\n");
+					pr_cont(" - no valid disk address\n");
 				spin_lock_irq(&xd_lock);
 				return -EIO;
 		}
@@ -664,7 +677,7 @@ static irqreturn_t xd_interrupt_handler(int irq, void *dev_id)
 		return IRQ_HANDLED;
 	}
 	else
-		printk("xd: unexpected interrupt\n");
+		pr_err("xd: unexpected interrupt\n");
 	return IRQ_NONE;
 }
 
@@ -707,8 +720,10 @@ static void __init xd_dtc_init_controller(unsigned int address)
 		case 0xCA000:	xd_iobase = 0x324;
 		case 0xD0000:				/*5150CX*/
 		case 0xD8000:	break;			/*5150CX & 5150XL*/
-		default:        printk("xd_dtc_init_controller: unsupported BIOS address %06x\n",address);
-				break;
+		default:
+			pr_err("%s: unsupported BIOS address %06x\n",
+			       __func__, address);
+			break;
 	}
 	xd_maxsectors = 0x01;		/* my card seems to have trouble doing multi-block transfers? */
 
@@ -756,7 +771,8 @@ static void __init xd_dtc5150cx_init_drive(u_char drive)
 #endif /* 0 */
 		}
 		else {
-			printk("xd%c: undetermined drive geometry\n",'a'+drive);
+			pr_err("xd%c: undetermined drive geometry\n",
+			       'a' + drive);
 			return;
 		}
 	xd_info[drive].control = 5;				/* control byte */
@@ -785,10 +801,12 @@ static void __init xd_dtc_init_drive(u_char drive)
 		xd_setparam(CMD_DTCSETPARAM,drive,xd_info[drive].heads,xd_info[drive].cylinders,((u_short *) (buf + 1))[0x05],((u_short *) (buf + 1))[0x06],buf[0x0F]);
 		xd_build(cmdblk,CMD_DTCSETSTEP,drive,0,0,0,0,7);
 		if (xd_command(cmdblk,PIO_MODE,NULL,NULL,NULL,XD_TIMEOUT * 2))
-			printk("xd_dtc_init_drive: error setting step rate for xd%c\n", 'a'+drive);
+			pr_err("%s: error setting step rate for xd%c\n",
+			       __func__, 'a'+drive);
 	}
 	else
-		printk("xd_dtc_init_drive: error reading geometry for xd%c\n", 'a'+drive);
+		pr_err("%s: error reading geometry for xd%c\n",
+		       __func__, 'a'+drive);
 }
 
 static void __init xd_wd_init_controller(unsigned int address)
@@ -801,7 +819,9 @@ static void __init xd_wd_init_controller(unsigned int address)
 		case 0xCE000:   xd_iobase = 0x32C; break;
 		case 0xD0000:	xd_iobase = 0x328; break; /* ? */
 		case 0xD8000:	xd_iobase = 0x32C; break; /* ? */
-		default:        printk("xd_wd_init_controller: unsupported BIOS address %06x\n",address);
+		default:
+			pr_err("%s: unsupported BIOS address %06x\n",
+			       __func__, address);
 				break;
 	}
 	/* this one doesn't wrap properly either... */
@@ -880,7 +900,8 @@ static void __init xd_wd_init_drive(u_char drive)
 		}
 	}
 	else
-		printk("xd_wd_init_drive: error reading geometry for xd%c\n",'a'+drive);
+		pr_err("%s: error reading geometry for xd%c\n",
+		       __func__, 'a' + drive);
 }
 
 static void __init xd_seagate_init_controller (unsigned int address)
@@ -891,8 +912,10 @@ static void __init xd_seagate_init_controller (unsigned int address)
 		case 0xD0000:	xd_iobase = 0x324; break;
 		case 0xD8000:	xd_iobase = 0x328; break;
 		case 0xE0000:	xd_iobase = 0x32C; break;
-		default:	printk("xd_seagate_init_controller: unsupported BIOS address %06x\n",address);
-				break;
+		default:
+			pr_err("%s: unsupported BIOS address %06x\n",
+			       __func__, address);
+			break;
 	}
 	xd_maxsectors = 0x40;
 
@@ -912,7 +935,8 @@ static void __init xd_seagate_init_drive(u_char drive)
 		xd_info[drive].control = 0;
 	}
 	else
-		printk("xd_seagate_init_drive: error reading geometry from xd%c\n", 'a'+drive);
+		pr_err("%s: error reading geometry from xd%c\n",
+		       __func__, 'a' + drive);
 }
 
 /* Omti support courtesy Dirk Melchers */
@@ -932,7 +956,8 @@ static void __init xd_omti_init_controller(unsigned int address)
 			xd_iobase = 0x32C;
 			break;
 		default:
-			printk("xd_omti_init_controller: unsupported BIOS address %06x\n",address);
+			pr_err("%s: unsupported BIOS address %06x\n",
+			       __func__, address);
 			break;
 	}
 
@@ -976,7 +1001,8 @@ static void __init xd_xebec_init_controller(unsigned int address)
 		case 0xE0000:
 			break;
 		default:
-			printk("xd_xebec_init_controller: unsupported BIOS address %06x\n",address);
+			pr_err("%s: unsupported BIOS address %06x\n",
+			       __func__, address);
 			break;
 		}
 
@@ -1073,7 +1099,8 @@ static void __init do_xd_setup(int *integers)
 			if ((integers[1] >= 0) && (integers[1] < ARRAY_SIZE(xd_sigs)))
 				xd_type = integers[1];
 		case 0: break;
-		default:printk("xd: too many parameters for xd\n");
+		default:
+			pr_err("xd: too many parameters for xd\n");
 	}
 	xd_maxsectors = 0x01;
 }
@@ -1109,18 +1136,18 @@ static int __init xd_init(void)
 
 	if (xd_detect(&controller,&address)) {
 
-		printk("Detected a%s controller (type %d) at address %06x\n",
+		pr_info("Detected a%s controller (type %d) at address %06x\n",
 			xd_sigs[controller].name,controller,address);
 		if (!request_region(xd_iobase,4,"xd")) {
-			printk("xd: Ports at 0x%x are not available\n",
-				xd_iobase);
+			pr_err("xd: Ports at 0x%x are not available\n",
+			       xd_iobase);
 			goto out2;
 		}
 		if (controller)
 			xd_sigs[controller].init_controller(address);
 		xd_drives = xd_initdrives(xd_sigs[controller].init_drive);
 
-		printk("Detected %d hard drive%s (using IRQ%d & DMA%d)\n",
+		pr_info("Detected %d hard drive%s (using IRQ%d & DMA%d)\n",
 			xd_drives,xd_drives == 1 ? "" : "s",xd_irq,xd_dma);
 	}
 
@@ -1132,7 +1159,7 @@ static int __init xd_init(void)
 	if (!xd_dma_buffer && xd_maxsectors) {
 		xd_dma_buffer = (char *)xd_dma_mem_alloc(xd_maxsectors * 0x200);
 		if (!xd_dma_buffer) {
-			printk(KERN_ERR "xd: Out of memory.\n");
+			pr_err("xd: Out of memory.\n");
 			goto out3;
 		}
 	}
@@ -1154,19 +1181,19 @@ static int __init xd_init(void)
 		disk->private_data = p;
 		disk->queue = xd_queue;
 		set_capacity(disk, p->heads * p->cylinders * p->sectors);
-		printk(" %s: CHS=%d/%d/%d\n", disk->disk_name,
+		pr_info(" %s: CHS=%d/%d/%d\n", disk->disk_name,
 			p->cylinders, p->heads, p->sectors);
 		xd_gendisk[i] = disk;
 	}
 
 	err = -EBUSY;
 	if (request_irq(xd_irq,xd_interrupt_handler, 0, "XT hard disk", NULL)) {
-		printk("xd: unable to get IRQ%d\n",xd_irq);
+		pr_err("xd: unable to get IRQ%d\n", xd_irq);
 		goto out4;
 	}
 
 	if (request_dma(xd_dma,"xd")) {
-		printk("xd: unable to get DMA%d\n",xd_dma);
+		pr_err("xd: unable to get DMA%d\n", xd_dma);
 		goto out5;
 	}
 
@@ -1249,7 +1276,7 @@ static int __init xd_manual_geo_init (char *str)
 
 	get_options (str, ARRAY_SIZE(integers), integers);
 	if (integers[0]%3 != 0) {
-		printk("xd: incorrect number of parameters for xd_geo\n");
+		pr_err("xd: incorrect number of parameters for xd_geo\n");
 		return 1;
 	}
 	for (i = 0; (i < integers[0]) && (i < 3*XD_MAXDRIVES); i++)
-- 
1.8.1.2


^ permalink raw reply related	[flat|nested] 11+ messages in thread
end of thread, other threads:[~2013-02-12 22:42 UTC | newest]

Thread overview: 11+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2013-02-12 22:40 [PATCH 0/9] revive the XD driver a bit Linus Walleij
2013-02-12 22:40 ` [PATCH 1/9] block: introduce a delay before every outb operation Linus Walleij
2013-02-12 22:40   ` [PATCH 1/9] block: xd: " Linus Walleij
2013-02-12 22:40     ` [PATCH 2/9] block: xd: fix up request handler loop Linus Walleij
2013-02-12 22:40       ` [PATCH 3/9] block: xd: raise timeouts Linus Walleij
2013-02-12 22:40         ` [PATCH 4/9] block: xd: some whitespace and #if 0 removal Linus Walleij
2013-02-12 22:40           ` [PATCH 5/9] block: xd: avoid using typedefs Linus Walleij
2013-02-12 22:40             ` [PATCH 6/9] block: xd: avoid some forward declarations Linus Walleij
2013-02-12 22:40               ` [PATCH 7/9] block: xd: merge header file into driver Linus Walleij
2013-02-12 22:40                 ` [PATCH 8/9] block: xd: remove custom DEBUG print system Linus Walleij
2013-02-12 22:41                   ` [PATCH 9/9] block: xd: replace all printks with pr_* Linus Walleij

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).