Merge branch 'for-2.6.39/core' of git://git.kernel.dk/linux-2.6-block

[pandora-kernel.git] / drivers / staging / hv / blkvsc_drv.c

diff --git a/drivers/staging/hv/blkvsc_drv.c b/drivers/staging/hv/blkvsc_drv.c
index 1ecd7e1..af78993 100644 (file)
--- a/drivers/staging/hv/blkvsc_drv.c
+++ b/drivers/staging/hv/blkvsc_drv.c
@@ -31,7 +31,7 @@
 #include <scsi/scsi_cmnd.h>
 #include <scsi/scsi_eh.h>
 #include <scsi/scsi_dbg.h>
-#include "osd.h"
+#include "hv_api.h"
 #include "logging.h"
 #include "version_info.h"
 #include "vmbus.h"
@@ -95,7 +95,7 @@ struct blkvsc_request {
 /* Per device structure */
 struct block_device_context {
        /* point back to our device context */
-       struct vm_device *device_ctx;
+       struct hv_device *device_ctx;
        struct kmem_cache *request_pool;
        spinlock_t lock;
        struct gendisk *gd;
@@ -115,13 +115,6 @@ struct block_device_context {
        int users;
 };
 
-/* Per driver */
-struct blkvsc_driver_context {
-       /* !! These must be the first 2 fields !! */
-       /* FIXME this is a bug! */
-       struct driver_context drv_ctx;
-       struct storvsc_driver_object drv_obj;
-};
 
 /* Static decl */
 static DEFINE_MUTEX(blkvsc_mutex);
@@ -157,7 +150,7 @@ module_param(blkvsc_ringbuffer_size, int, S_IRUGO);
 MODULE_PARM_DESC(ring_size, "Ring buffer size (in bytes)");
 
 /* The one and only one */
-static struct blkvsc_driver_context g_blkvsc_drv;
+static  struct storvsc_driver_object g_blkvsc_drv;
 
 static const struct block_device_operations block_ops = {
        .owner = THIS_MODULE,
@@ -174,25 +167,25 @@ static const struct block_device_operations block_ops = {
  */
 static int blkvsc_drv_init(int (*drv_init)(struct hv_driver *drv))
 {
-       struct storvsc_driver_object *storvsc_drv_obj = &g_blkvsc_drv.drv_obj;
-       struct driver_context *drv_ctx = &g_blkvsc_drv.drv_ctx;
+       struct storvsc_driver_object *storvsc_drv_obj = &g_blkvsc_drv;
+       struct hv_driver *drv = &g_blkvsc_drv.base;
        int ret;
 
        storvsc_drv_obj->ring_buffer_size = blkvsc_ringbuffer_size;
 
+       drv->priv = storvsc_drv_obj;
+
        /* Callback to client driver to complete the initialization */
        drv_init(&storvsc_drv_obj->base);
 
-       drv_ctx->driver.name = storvsc_drv_obj->base.name;
-       memcpy(&drv_ctx->class_id, &storvsc_drv_obj->base.deviceType,
-              sizeof(struct hv_guid));
+       drv->driver.name = storvsc_drv_obj->base.name;
 
-       drv_ctx->probe = blkvsc_probe;
-       drv_ctx->remove = blkvsc_remove;
-       drv_ctx->shutdown = blkvsc_shutdown;
+       drv->driver.probe = blkvsc_probe;
+       drv->driver.remove = blkvsc_remove;
+       drv->driver.shutdown = blkvsc_shutdown;
 
        /* The driver belongs to vmbus */
-       ret = vmbus_child_driver_register(drv_ctx);
+       ret = vmbus_child_driver_register(&drv->driver);
 
        return ret;
 }
@@ -206,8 +199,8 @@ static int blkvsc_drv_exit_cb(struct device *dev, void *data)
 
 static void blkvsc_drv_exit(void)
 {
-       struct storvsc_driver_object *storvsc_drv_obj = &g_blkvsc_drv.drv_obj;
-       struct driver_context *drv_ctx = &g_blkvsc_drv.drv_ctx;
+       struct storvsc_driver_object *storvsc_drv_obj = &g_blkvsc_drv;
+       struct hv_driver *drv = &g_blkvsc_drv.base;
        struct device *current_dev;
        int ret;
 
@@ -215,7 +208,7 @@ static void blkvsc_drv_exit(void)
                current_dev = NULL;
 
                /* Get the device */
-               ret = driver_for_each_device(&drv_ctx->driver, NULL,
+               ret = driver_for_each_device(&drv->driver, NULL,
                                             (void *) &current_dev,
                                             blkvsc_drv_exit_cb);
 
@@ -231,10 +224,10 @@ static void blkvsc_drv_exit(void)
                device_unregister(current_dev);
        }
 
-       if (storvsc_drv_obj->base.OnCleanup)
-               storvsc_drv_obj->base.OnCleanup(&storvsc_drv_obj->base);
+       if (storvsc_drv_obj->base.cleanup)
+               storvsc_drv_obj->base.cleanup(&storvsc_drv_obj->base);
 
-       vmbus_child_driver_unregister(drv_ctx);
+       vmbus_child_driver_unregister(&drv->driver);
 
        return;
 }
@@ -244,14 +237,11 @@ static void blkvsc_drv_exit(void)
  */
 static int blkvsc_probe(struct device *device)
 {
-       struct driver_context *driver_ctx =
-                               driver_to_driver_context(device->driver);
-       struct blkvsc_driver_context *blkvsc_drv_ctx =
-                               (struct blkvsc_driver_context *)driver_ctx;
+       struct hv_driver *drv =
+                               drv_to_hv_drv(device->driver);
        struct storvsc_driver_object *storvsc_drv_obj =
-                               &blkvsc_drv_ctx->drv_obj;
-       struct vm_device *device_ctx = device_to_vm_device(device);
-       struct hv_device *device_obj = &device_ctx->device_obj;
+                               drv->priv;
+       struct hv_device *device_obj = device_to_hv_device(device);
 
        struct block_device_context *blkdev = NULL;
        struct storvsc_device_info device_info;
@@ -263,7 +253,7 @@ static int blkvsc_probe(struct device *device)
 
        DPRINT_DBG(BLKVSC_DRV, "blkvsc_probe - enter");
 
-       if (!storvsc_drv_obj->base.OnDeviceAdd) {
+       if (!storvsc_drv_obj->base.dev_add) {
                DPRINT_ERR(BLKVSC_DRV, "OnDeviceAdd() not set");
                ret = -1;
                goto Cleanup;
@@ -283,7 +273,7 @@ static int blkvsc_probe(struct device *device)
        /* ASSERT(sizeof(struct blkvsc_request_group) <= */
        /*      sizeof(struct blkvsc_request)); */
 
-       blkdev->request_pool = kmem_cache_create(dev_name(&device_ctx->device),
+       blkdev->request_pool = kmem_cache_create(dev_name(&device_obj->device),
                                        sizeof(struct blkvsc_request) +
                                        storvsc_drv_obj->request_ext_size, 0,
                                        SLAB_HWCACHE_ALIGN, NULL);
@@ -294,13 +284,13 @@ static int blkvsc_probe(struct device *device)
 
 
        /* Call to the vsc driver to add the device */
-       ret = storvsc_drv_obj->base.OnDeviceAdd(device_obj, &device_info);
+       ret = storvsc_drv_obj->base.dev_add(device_obj, &device_info);
        if (ret != 0) {
                DPRINT_ERR(BLKVSC_DRV, "unable to add blkvsc device");
                goto Cleanup;
        }
 
-       blkdev->device_ctx = device_ctx;
+       blkdev->device_ctx = device_obj;
        /* this identified the device 0 or 1 */
        blkdev->target = device_info.target_id;
        /* this identified the ide ctrl 0 or 1 */
@@ -394,7 +384,7 @@ static int blkvsc_probe(struct device *device)
        return ret;
 
 Remove:
-       storvsc_drv_obj->base.OnDeviceRemove(device_obj);
+       storvsc_drv_obj->base.dev_rm(device_obj);
 
 Cleanup:
        if (blkdev) {
@@ -462,9 +452,9 @@ static int blkvsc_do_flush(struct block_device_context *blkdev)
        blkvsc_req->req = NULL;
        blkvsc_req->write = 0;
 
-       blkvsc_req->request.data_buffer.PfnArray[0] = 0;
-       blkvsc_req->request.data_buffer.Offset = 0;
-       blkvsc_req->request.data_buffer.Length = 0;
+       blkvsc_req->request.data_buffer.pfn_array[0] = 0;
+       blkvsc_req->request.data_buffer.offset = 0;
+       blkvsc_req->request.data_buffer.len = 0;
 
        blkvsc_req->cmnd[0] = SYNCHRONIZE_CACHE;
        blkvsc_req->cmd_len = 10;
@@ -509,9 +499,9 @@ static int blkvsc_do_inquiry(struct block_device_context *blkdev)
        blkvsc_req->req = NULL;
        blkvsc_req->write = 0;
 
-       blkvsc_req->request.data_buffer.PfnArray[0] = page_to_pfn(page_buf);
-       blkvsc_req->request.data_buffer.Offset = 0;
-       blkvsc_req->request.data_buffer.Length = 64;
+       blkvsc_req->request.data_buffer.pfn_array[0] = page_to_pfn(page_buf);
+       blkvsc_req->request.data_buffer.offset = 0;
+       blkvsc_req->request.data_buffer.len = 64;
 
        blkvsc_req->cmnd[0] = INQUIRY;
        blkvsc_req->cmnd[1] = 0x1;              /* Get product data */
@@ -596,9 +586,9 @@ static int blkvsc_do_read_capacity(struct block_device_context *blkdev)
        blkvsc_req->req = NULL;
        blkvsc_req->write = 0;
 
-       blkvsc_req->request.data_buffer.PfnArray[0] = page_to_pfn(page_buf);
-       blkvsc_req->request.data_buffer.Offset = 0;
-       blkvsc_req->request.data_buffer.Length = 8;
+       blkvsc_req->request.data_buffer.pfn_array[0] = page_to_pfn(page_buf);
+       blkvsc_req->request.data_buffer.offset = 0;
+       blkvsc_req->request.data_buffer.len = 8;
 
        blkvsc_req->cmnd[0] = READ_CAPACITY;
        blkvsc_req->cmd_len = 16;
@@ -673,9 +663,9 @@ static int blkvsc_do_read_capacity16(struct block_device_context *blkdev)
        blkvsc_req->req = NULL;
        blkvsc_req->write = 0;
 
-       blkvsc_req->request.data_buffer.PfnArray[0] = page_to_pfn(page_buf);
-       blkvsc_req->request.data_buffer.Offset = 0;
-       blkvsc_req->request.data_buffer.Length = 12;
+       blkvsc_req->request.data_buffer.pfn_array[0] = page_to_pfn(page_buf);
+       blkvsc_req->request.data_buffer.offset = 0;
+       blkvsc_req->request.data_buffer.len = 12;
 
        blkvsc_req->cmnd[0] = 0x9E; /* READ_CAPACITY16; */
        blkvsc_req->cmd_len = 16;
@@ -730,28 +720,25 @@ static int blkvsc_do_read_capacity16(struct block_device_context *blkdev)
  */
 static int blkvsc_remove(struct device *device)
 {
-       struct driver_context *driver_ctx =
-                               driver_to_driver_context(device->driver);
-       struct blkvsc_driver_context *blkvsc_drv_ctx =
-                               (struct blkvsc_driver_context *)driver_ctx;
+       struct hv_driver *drv =
+                               drv_to_hv_drv(device->driver);
        struct storvsc_driver_object *storvsc_drv_obj =
-                               &blkvsc_drv_ctx->drv_obj;
-       struct vm_device *device_ctx = device_to_vm_device(device);
-       struct hv_device *device_obj = &device_ctx->device_obj;
+                               drv->priv;
+       struct hv_device *device_obj = device_to_hv_device(device);
        struct block_device_context *blkdev = dev_get_drvdata(device);
        unsigned long flags;
        int ret;
 
        DPRINT_DBG(BLKVSC_DRV, "blkvsc_remove()\n");
 
-       if (!storvsc_drv_obj->base.OnDeviceRemove)
+       if (!storvsc_drv_obj->base.dev_rm)
                return -1;
 
        /*
         * Call to the vsc driver to let it know that the device is being
         * removed
         */
-       ret = storvsc_drv_obj->base.OnDeviceRemove(device_obj);
+       ret = storvsc_drv_obj->base.dev_rm(device_obj);
        if (ret != 0) {
                /* TODO: */
                DPRINT_ERR(BLKVSC_DRV,
@@ -852,13 +839,11 @@ static int blkvsc_submit_request(struct blkvsc_request *blkvsc_req,
                        void (*request_completion)(struct hv_storvsc_request *))
 {
        struct block_device_context *blkdev = blkvsc_req->dev;
-       struct vm_device *device_ctx = blkdev->device_ctx;
-       struct driver_context *driver_ctx =
-                       driver_to_driver_context(device_ctx->device.driver);
-       struct blkvsc_driver_context *blkvsc_drv_ctx =
-                       (struct blkvsc_driver_context *)driver_ctx;
+       struct hv_device *device_ctx = blkdev->device_ctx;
+       struct hv_driver *drv =
+                       drv_to_hv_drv(device_ctx->device.driver);
        struct storvsc_driver_object *storvsc_drv_obj =
-                       &blkvsc_drv_ctx->drv_obj;
+                       drv->priv;
        struct hv_storvsc_request *storvsc_req;
        int ret;
 
@@ -868,14 +853,14 @@ static int blkvsc_submit_request(struct blkvsc_request *blkvsc_req,
                   (blkvsc_req->write) ? "WRITE" : "READ",
                   (unsigned long) blkvsc_req->sector_start,
                   blkvsc_req->sector_count,
-                  blkvsc_req->request.data_buffer.Offset,
-                  blkvsc_req->request.data_buffer.Length);
+                  blkvsc_req->request.data_buffer.offset,
+                  blkvsc_req->request.data_buffer.len);
 #if 0
-       for (i = 0; i < (blkvsc_req->request.data_buffer.Length >> 12); i++) {
+       for (i = 0; i < (blkvsc_req->request.data_buffer.len >> 12); i++) {
                DPRINT_DBG(BLKVSC_DRV, "blkvsc_submit_request() - "
                           "req %p pfn[%d] %llx\n",
                           blkvsc_req, i,
-                          blkvsc_req->request.data_buffer.PfnArray[i]);
+                          blkvsc_req->request.data_buffer.pfn_array[i]);
        }
 #endif
 
@@ -899,7 +884,7 @@ static int blkvsc_submit_request(struct blkvsc_request *blkvsc_req,
        storvsc_req->sense_buffer = blkvsc_req->sense_buffer;
        storvsc_req->sense_buffer_size = SCSI_SENSE_BUFFERSIZE;
 
-       ret = storvsc_drv_obj->on_io_request(&blkdev->device_ctx->device_obj,
+       ret = storvsc_drv_obj->on_io_request(blkdev->device_ctx,
                                           &blkvsc_req->request);
        if (ret == 0)
                blkdev->num_outstanding_reqs++;
@@ -995,9 +980,9 @@ static int blkvsc_do_request(struct block_device_context *blkdev,
 
                                        blkvsc_req->dev = blkdev;
                                        blkvsc_req->req = req;
-                                       blkvsc_req->request.data_buffer.Offset
+                                       blkvsc_req->request.data_buffer.offset
                                                = bvec->bv_offset;
-                                       blkvsc_req->request.data_buffer.Length
+                                       blkvsc_req->request.data_buffer.len
                                                = 0;
 
                                        /* Add to the group */
@@ -1013,9 +998,9 @@ static int blkvsc_do_request(struct block_device_context *blkdev,
 
                                /* Add the curr bvec/segment to the curr blkvsc_req */
                                blkvsc_req->request.data_buffer.
-                                       PfnArray[databuf_idx]
+                                       pfn_array[databuf_idx]
                                                = page_to_pfn(bvec->bv_page);
-                               blkvsc_req->request.data_buffer.Length
+                               blkvsc_req->request.data_buffer.len
                                        += bvec->bv_len;
 
                                prev_bvec = bvec;
@@ -1118,7 +1103,7 @@ static void blkvsc_request_completion(struct hv_storvsc_request *request)
                   (blkvsc_req->write) ? "WRITE" : "READ",
                   (unsigned long)blkvsc_req->sector_start,
                   blkvsc_req->sector_count,
-                  blkvsc_req->request.data_buffer.Length,
+                  blkvsc_req->request.data_buffer.len,
                   blkvsc_req->group->outstanding,
                   blkdev->num_outstanding_reqs);