include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit...

[safe/jmp/linux-2.6] / drivers / block / paride / pd.c

diff --git a/drivers/block/paride/pd.c b/drivers/block/paride/pd.c
index 500d2eb..c1e5cd0 100644 (file)
--- a/drivers/block/paride/pd.c
+++ b/drivers/block/paride/pd.c
@@ -145,6 +145,7 @@ enum {D_PRT, D_PRO, D_UNI, D_MOD, D_GEO, D_SBY, D_DLY, D_SLV};
 
 #include <linux/init.h>
 #include <linux/module.h>
+#include <linux/gfp.h>
 #include <linux/fs.h>
 #include <linux/delay.h>
 #include <linux/hdreg.h>
@@ -153,7 +154,6 @@ enum {D_PRT, D_PRO, D_UNI, D_MOD, D_GEO, D_SBY, D_DLY, D_SLV};
 #include <linux/blkpg.h>
 #include <linux/kernel.h>
 #include <asm/uaccess.h>
-#include <linux/sched.h>
 #include <linux/workqueue.h>
 
 static DEFINE_SPINLOCK(pd_lock);
@@ -352,19 +352,19 @@ static enum action (*phase)(void);
 
 static void run_fsm(void);
 
-static void ps_tq_int( void *data);
+static void ps_tq_int(struct work_struct *work);
 
-static DECLARE_WORK(fsm_tq, ps_tq_int, NULL);
+static DECLARE_DELAYED_WORK(fsm_tq, ps_tq_int);
 
 static void schedule_fsm(void)
 {
        if (!nice)
-               schedule_work(&fsm_tq);
+               schedule_delayed_work(&fsm_tq, 0);
        else
                schedule_delayed_work(&fsm_tq, nice-1);
 }
 
-static void ps_tq_int(void *data)
+static void ps_tq_int(struct work_struct *work)
 {
        run_fsm();
 }
@@ -411,10 +411,12 @@ static void run_fsm(void)
                                pd_claimed = 0;
                                phase = NULL;
                                spin_lock_irqsave(&pd_lock, saved_flags);
-                               end_request(pd_req, res);
-                               pd_req = elv_next_request(pd_queue);
-                               if (!pd_req)
-                                       stop = 1;
+                               if (!__blk_end_request_cur(pd_req,
+                                               res == Ok ? 0 : -EIO)) {
+                                       pd_req = blk_fetch_request(pd_queue);
+                                       if (!pd_req)
+                                               stop = 1;
+                               }
                                spin_unlock_irqrestore(&pd_lock, saved_flags);
                                if (stop)
                                        return;
@@ -444,11 +446,11 @@ static enum action do_pd_io_start(void)
 
        pd_cmd = rq_data_dir(pd_req);
        if (pd_cmd == READ || pd_cmd == WRITE) {
-               pd_block = pd_req->sector;
-               pd_count = pd_req->current_nr_sectors;
+               pd_block = blk_rq_pos(pd_req);
+               pd_count = blk_rq_cur_sectors(pd_req);
                if (pd_block + pd_count > get_capacity(pd_req->rq_disk))
                        return Fail;
-               pd_run = pd_req->nr_sectors;
+               pd_run = blk_rq_sectors(pd_req);
                pd_buf = pd_req->buffer;
                pd_retries = 0;
                if (pd_cmd == READ)
@@ -478,8 +480,8 @@ static int pd_next_buf(void)
        if (pd_count)
                return 0;
        spin_lock_irqsave(&pd_lock, saved_flags);
-       end_request(pd_req, 1);
-       pd_count = pd_req->current_nr_sectors;
+       __blk_end_request_cur(pd_req, 0);
+       pd_count = blk_rq_cur_sectors(pd_req);
        pd_buf = pd_req->buffer;
        spin_unlock_irqrestore(&pd_lock, saved_flags);
        return 0;
@@ -664,11 +666,11 @@ static enum action pd_identify(struct pd_unit *disk)
                return Fail;
        pi_read_block(disk->pi, pd_scratch, 512);
        disk->can_lba = pd_scratch[99] & 2;
-       disk->sectors = le16_to_cpu(*(u16 *) (pd_scratch + 12));
-       disk->heads = le16_to_cpu(*(u16 *) (pd_scratch + 6));
-       disk->cylinders = le16_to_cpu(*(u16 *) (pd_scratch + 2));
+       disk->sectors = le16_to_cpu(*(__le16 *) (pd_scratch + 12));
+       disk->heads = le16_to_cpu(*(__le16 *) (pd_scratch + 6));
+       disk->cylinders = le16_to_cpu(*(__le16 *) (pd_scratch + 2));
        if (disk->can_lba)
-               disk->capacity = le32_to_cpu(*(u32 *) (pd_scratch + 120));
+               disk->capacity = le32_to_cpu(*(__le32 *) (pd_scratch + 120));
        else
                disk->capacity = disk->sectors * disk->heads * disk->cylinders;
 
@@ -699,11 +701,11 @@ static enum action pd_identify(struct pd_unit *disk)
 
 /* end of io request engine */
 
-static void do_pd_request(request_queue_t * q)
+static void do_pd_request(struct request_queue * q)
 {
        if (pd_req)
                return;
-       pd_req = elv_next_request(q);
+       pd_req = blk_fetch_request(q);
        if (!pd_req)
                return;
 
@@ -713,30 +715,25 @@ static void do_pd_request(request_queue_t * q)
 static int pd_special_command(struct pd_unit *disk,
                      enum action (*func)(struct pd_unit *disk))
 {
-       DECLARE_COMPLETION(wait);
-       struct request rq;
+       struct request *rq;
        int err = 0;
 
-       memset(&rq, 0, sizeof(rq));
-       rq.errors = 0;
-       rq.rq_status = RQ_ACTIVE;
-       rq.rq_disk = disk->gd;
-       rq.ref_count = 1;
-       rq.end_io_data = &wait;
-       rq.end_io = blk_end_sync_rq;
-       blk_insert_request(disk->gd->queue, &rq, 0, func);
-       wait_for_completion(&wait);
-       if (rq.errors)
-               err = -EIO;
-       blk_put_request(&rq);
+       rq = blk_get_request(disk->gd->queue, READ, __GFP_WAIT);
+
+       rq->cmd_type = REQ_TYPE_SPECIAL;
+       rq->special = func;
+
+       err = blk_execute_rq(disk->gd->queue, disk->gd, rq, 0);
+
+       blk_put_request(rq);
        return err;
 }
 
 /* kernel glue structures */
 
-static int pd_open(struct inode *inode, struct file *file)
+static int pd_open(struct block_device *bdev, fmode_t mode)
 {
-       struct pd_unit *disk = inode->i_bdev->bd_disk->private_data;
+       struct pd_unit *disk = bdev->bd_disk->private_data;
 
        disk->access++;
 
@@ -764,10 +761,10 @@ static int pd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
        return 0;
 }
 
-static int pd_ioctl(struct inode *inode, struct file *file,
+static int pd_ioctl(struct block_device *bdev, fmode_t mode,
         unsigned int cmd, unsigned long arg)
 {
-       struct pd_unit *disk = inode->i_bdev->bd_disk->private_data;
+       struct pd_unit *disk = bdev->bd_disk->private_data;
 
        switch (cmd) {
        case CDROMEJECT:
@@ -779,9 +776,9 @@ static int pd_ioctl(struct inode *inode, struct file *file,
        }
 }
 
-static int pd_release(struct inode *inode, struct file *file)
+static int pd_release(struct gendisk *p, fmode_t mode)
 {
-       struct pd_unit *disk = inode->i_bdev->bd_disk->private_data;
+       struct pd_unit *disk = p->private_data;
 
        if (!--disk->access && disk->removable)
                pd_special_command(disk, pd_door_unlock);
@@ -811,11 +808,11 @@ static int pd_revalidate(struct gendisk *p)
        return 0;
 }
 
-static struct block_device_operations pd_fops = {
+static const struct block_device_operations pd_fops = {
        .owner          = THIS_MODULE,
        .open           = pd_open,
        .release        = pd_release,
-       .ioctl          = pd_ioctl,
+       .locked_ioctl   = pd_ioctl,
        .getgeo         = pd_getgeo,
        .media_changed  = pd_check_media,
        .revalidate_disk= pd_revalidate
@@ -910,7 +907,7 @@ static int __init pd_init(void)
        if (!pd_queue)
                goto out1;
 
-       blk_queue_max_sectors(pd_queue, cluster);
+       blk_queue_max_hw_sectors(pd_queue, cluster);
 
        if (register_blkdev(major, name))
                goto out2;