release/src-rt-6.x.4708/linux/linux-2.6.36/drivers/staging/hv/storvsc.c

   1 /*
   2  * Copyright (c) 2009, Microsoft Corporation.
   3  *
   4  * This program is free software; you can redistribute it and/or modify it
   5  * under the terms and conditions of the GNU General Public License,
   6  * version 2, as published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope it will be useful, but WITHOUT
   9  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  10  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  11  * more details.
  12  *
  13  * You should have received a copy of the GNU General Public License along with
  14  * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
  15  * Place - Suite 330, Boston, MA 02111-1307 USA.
  16  *
  17  * Authors:
  18  *   Haiyang Zhang <haiyangz@microsoft.com>
  19  *   Hank Janssen  <hjanssen@microsoft.com>
  20  */
  21 #include <linux/kernel.h>
  22 #include <linux/string.h>
  23 #include <linux/slab.h>
  24 #include <linux/mm.h>
  25 #include <linux/delay.h>
  26 #include "osd.h"
  27 #include "logging.h"
  28 #include "storvsc_api.h"
  29 #include "vmbus_packet_format.h"
  30 #include "vstorage.h"
  31
  32
  33 struct storvsc_request_extension {
  34         /* LIST_ENTRY ListEntry; */
  35
  36         struct hv_storvsc_request *Request;
  37         struct hv_device *Device;
  38
  39         /* Synchronize the request/response if needed */
  40         struct osd_waitevent *WaitEvent;
  41
  42         struct vstor_packet VStorPacket;
  43 };
  44
  45 /* A storvsc device is a device object that contains a vmbus channel */
  46 struct storvsc_device {
  47         struct hv_device *Device;
  48
  49         /* 0 indicates the device is being destroyed */
  50         atomic_t RefCount;
  51
  52         atomic_t NumOutstandingRequests;
  53
  54         /*
  55          * Each unique Port/Path/Target represents 1 channel ie scsi
  56          * controller. In reality, the pathid, targetid is always 0
  57          * and the port is set by us
  58          */
  59         unsigned int PortNumber;
  60         unsigned char PathId;
  61         unsigned char TargetId;
  62
  63         /* LIST_ENTRY OutstandingRequestList; */
  64         /* HANDLE OutstandingRequestLock; */
  65
  66         /* Used for vsc/vsp channel reset process */
  67         struct storvsc_request_extension InitRequest;
  68         struct storvsc_request_extension ResetRequest;
  69 };
  70
  71
  72 static const char *gDriverName = "storvsc";
  73
  74 /* {ba6163d9-04a1-4d29-b605-72e2ffb1dc7f} */
  75 static const struct hv_guid gStorVscDeviceType = {
  76         .data = {
  77                 0xd9, 0x63, 0x61, 0xba, 0xa1, 0x04, 0x29, 0x4d,
  78                 0xb6, 0x05, 0x72, 0xe2, 0xff, 0xb1, 0xdc, 0x7f
  79         }
  80 };
  81
  82
  83 static inline struct storvsc_device *AllocStorDevice(struct hv_device *Device)
  84 {
  85         struct storvsc_device *storDevice;
  86
  87         storDevice = kzalloc(sizeof(struct storvsc_device), GFP_KERNEL);
  88         if (!storDevice)
  89                 return NULL;
  90
  91         /* Set to 2 to allow both inbound and outbound traffics */
  92         /* (ie GetStorDevice() and MustGetStorDevice()) to proceed. */
  93         atomic_cmpxchg(&storDevice->RefCount, 0, 2);
  94
  95         storDevice->Device = Device;
  96         Device->Extension = storDevice;
  97
  98         return storDevice;
  99 }
 100
 101 static inline void FreeStorDevice(struct storvsc_device *Device)
 102 {
 103         /* ASSERT(atomic_read(&Device->RefCount) == 0); */
 104         kfree(Device);
 105 }
 106
 107 /* Get the stordevice object iff exists and its refcount > 1 */
 108 static inline struct storvsc_device *GetStorDevice(struct hv_device *Device)
 109 {
 110         struct storvsc_device *storDevice;
 111
 112         storDevice = (struct storvsc_device *)Device->Extension;
 113         if (storDevice && atomic_read(&storDevice->RefCount) > 1)
 114                 atomic_inc(&storDevice->RefCount);
 115         else
 116                 storDevice = NULL;
 117
 118         return storDevice;
 119 }
 120
 121 /* Get the stordevice object iff exists and its refcount > 0 */
 122 static inline struct storvsc_device *MustGetStorDevice(struct hv_device *Device)
 123 {
 124         struct storvsc_device *storDevice;
 125
 126         storDevice = (struct storvsc_device *)Device->Extension;
 127         if (storDevice && atomic_read(&storDevice->RefCount))
 128                 atomic_inc(&storDevice->RefCount);
 129         else
 130                 storDevice = NULL;
 131
 132         return storDevice;
 133 }
 134
 135 static inline void PutStorDevice(struct hv_device *Device)
 136 {
 137         struct storvsc_device *storDevice;
 138
 139         storDevice = (struct storvsc_device *)Device->Extension;
 140         /* ASSERT(storDevice); */
 141
 142         atomic_dec(&storDevice->RefCount);
 143         /* ASSERT(atomic_read(&storDevice->RefCount)); */
 144 }
 145
 146 /* Drop ref count to 1 to effectively disable GetStorDevice() */
 147 static inline struct storvsc_device *ReleaseStorDevice(struct hv_device *Device)
 148 {
 149         struct storvsc_device *storDevice;
 150
 151         storDevice = (struct storvsc_device *)Device->Extension;
 152         /* ASSERT(storDevice); */
 153
 154         /* Busy wait until the ref drop to 2, then set it to 1 */
 155         while (atomic_cmpxchg(&storDevice->RefCount, 2, 1) != 2)
 156                 udelay(100);
 157
 158         return storDevice;
 159 }
 160
 161 /* Drop ref count to 0. No one can use StorDevice object. */
 162 static inline struct storvsc_device *FinalReleaseStorDevice(
 163                         struct hv_device *Device)
 164 {
 165         struct storvsc_device *storDevice;
 166
 167         storDevice = (struct storvsc_device *)Device->Extension;
 168         /* ASSERT(storDevice); */
 169
 170         /* Busy wait until the ref drop to 1, then set it to 0 */
 171         while (atomic_cmpxchg(&storDevice->RefCount, 1, 0) != 1)
 172                 udelay(100);
 173
 174         Device->Extension = NULL;
 175         return storDevice;
 176 }
 177
 178 static int StorVscChannelInit(struct hv_device *Device)
 179 {
 180         struct storvsc_device *storDevice;
 181         struct storvsc_request_extension *request;
 182         struct vstor_packet *vstorPacket;
 183         int ret;
 184
 185         storDevice = GetStorDevice(Device);
 186         if (!storDevice) {
 187                 DPRINT_ERR(STORVSC, "unable to get stor device..."
 188                            "device being destroyed?");
 189                 return -1;
 190         }
 191
 192         request = &storDevice->InitRequest;
 193         vstorPacket = &request->VStorPacket;
 194
 195         /*
 196          * Now, initiate the vsc/vsp initialization protocol on the open
 197          * channel
 198          */
 199         memset(request, 0, sizeof(struct storvsc_request_extension));
 200         request->WaitEvent = osd_WaitEventCreate();
 201         if (!request->WaitEvent) {
 202                 ret = -ENOMEM;
 203                 goto nomem;
 204         }
 205
 206         vstorPacket->Operation = VStorOperationBeginInitialization;
 207         vstorPacket->Flags = REQUEST_COMPLETION_FLAG;
 208
 209         /*SpinlockAcquire(gDriverExt.packetListLock);
 210         INSERT_TAIL_LIST(&gDriverExt.packetList, &packet->listEntry.entry);
 211         SpinlockRelease(gDriverExt.packetListLock);*/
 212
 213         DPRINT_INFO(STORVSC, "BEGIN_INITIALIZATION_OPERATION...");
 214
 215         ret = Device->Driver->VmbusChannelInterface.SendPacket(Device,
 216                                 vstorPacket,
 217                                 sizeof(struct vstor_packet),
 218                                 (unsigned long)request,
 219                                 VmbusPacketTypeDataInBand,
 220                                 VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
 221         if (ret != 0) {
 222                 DPRINT_ERR(STORVSC,
 223                            "unable to send BEGIN_INITIALIZATION_OPERATION");
 224                 goto Cleanup;
 225         }
 226
 227         osd_WaitEventWait(request->WaitEvent);
 228
 229         if (vstorPacket->Operation != VStorOperationCompleteIo ||
 230             vstorPacket->Status != 0) {
 231                 DPRINT_ERR(STORVSC, "BEGIN_INITIALIZATION_OPERATION failed "
 232                            "(op %d status 0x%x)",
 233                            vstorPacket->Operation, vstorPacket->Status);
 234                 goto Cleanup;
 235         }
 236
 237         DPRINT_INFO(STORVSC, "QUERY_PROTOCOL_VERSION_OPERATION...");
 238
 239         /* reuse the packet for version range supported */
 240         memset(vstorPacket, 0, sizeof(struct vstor_packet));
 241         vstorPacket->Operation = VStorOperationQueryProtocolVersion;
 242         vstorPacket->Flags = REQUEST_COMPLETION_FLAG;
 243
 244         vstorPacket->Version.MajorMinor = VMSTOR_PROTOCOL_VERSION_CURRENT;
 245         FILL_VMSTOR_REVISION(vstorPacket->Version.Revision);
 246
 247         ret = Device->Driver->VmbusChannelInterface.SendPacket(Device,
 248                                 vstorPacket,
 249                                 sizeof(struct vstor_packet),
 250                                 (unsigned long)request,
 251                                 VmbusPacketTypeDataInBand,
 252                                 VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
 253         if (ret != 0) {
 254                 DPRINT_ERR(STORVSC,
 255                            "unable to send BEGIN_INITIALIZATION_OPERATION");
 256                 goto Cleanup;
 257         }
 258
 259         osd_WaitEventWait(request->WaitEvent);
 260
 261         /* TODO: Check returned version */
 262         if (vstorPacket->Operation != VStorOperationCompleteIo ||
 263             vstorPacket->Status != 0) {
 264                 DPRINT_ERR(STORVSC, "QUERY_PROTOCOL_VERSION_OPERATION failed "
 265                            "(op %d status 0x%x)",
 266                            vstorPacket->Operation, vstorPacket->Status);
 267                 goto Cleanup;
 268         }
 269
 270         /* Query channel properties */
 271         DPRINT_INFO(STORVSC, "QUERY_PROPERTIES_OPERATION...");
 272
 273         memset(vstorPacket, 0, sizeof(struct vstor_packet));
 274         vstorPacket->Operation = VStorOperationQueryProperties;
 275         vstorPacket->Flags = REQUEST_COMPLETION_FLAG;
 276         vstorPacket->StorageChannelProperties.PortNumber =
 277                                         storDevice->PortNumber;
 278
 279         ret = Device->Driver->VmbusChannelInterface.SendPacket(Device,
 280                                 vstorPacket,
 281                                 sizeof(struct vstor_packet),
 282                                 (unsigned long)request,
 283                                 VmbusPacketTypeDataInBand,
 284                                 VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
 285
 286         if (ret != 0) {
 287                 DPRINT_ERR(STORVSC,
 288                            "unable to send QUERY_PROPERTIES_OPERATION");
 289                 goto Cleanup;
 290         }
 291
 292         osd_WaitEventWait(request->WaitEvent);
 293
 294         /* TODO: Check returned version */
 295         if (vstorPacket->Operation != VStorOperationCompleteIo ||
 296             vstorPacket->Status != 0) {
 297                 DPRINT_ERR(STORVSC, "QUERY_PROPERTIES_OPERATION failed "
 298                            "(op %d status 0x%x)",
 299                            vstorPacket->Operation, vstorPacket->Status);
 300                 goto Cleanup;
 301         }
 302
 303         storDevice->PathId = vstorPacket->StorageChannelProperties.PathId;
 304         storDevice->TargetId = vstorPacket->StorageChannelProperties.TargetId;
 305
 306         DPRINT_DBG(STORVSC, "channel flag 0x%x, max xfer len 0x%x",
 307                    vstorPacket->StorageChannelProperties.Flags,
 308                    vstorPacket->StorageChannelProperties.MaxTransferBytes);
 309
 310         DPRINT_INFO(STORVSC, "END_INITIALIZATION_OPERATION...");
 311
 312         memset(vstorPacket, 0, sizeof(struct vstor_packet));
 313         vstorPacket->Operation = VStorOperationEndInitialization;
 314         vstorPacket->Flags = REQUEST_COMPLETION_FLAG;
 315
 316         ret = Device->Driver->VmbusChannelInterface.SendPacket(Device,
 317                                 vstorPacket,
 318                                 sizeof(struct vstor_packet),
 319                                 (unsigned long)request,
 320                                 VmbusPacketTypeDataInBand,
 321                                 VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
 322
 323         if (ret != 0) {
 324                 DPRINT_ERR(STORVSC,
 325                            "unable to send END_INITIALIZATION_OPERATION");
 326                 goto Cleanup;
 327         }
 328
 329         osd_WaitEventWait(request->WaitEvent);
 330
 331         if (vstorPacket->Operation != VStorOperationCompleteIo ||
 332             vstorPacket->Status != 0) {
 333                 DPRINT_ERR(STORVSC, "END_INITIALIZATION_OPERATION failed "
 334                            "(op %d status 0x%x)",
 335                            vstorPacket->Operation, vstorPacket->Status);
 336                 goto Cleanup;
 337         }
 338
 339         DPRINT_INFO(STORVSC, "**** storage channel up and running!! ****");
 340
 341 Cleanup:
 342         kfree(request->WaitEvent);
 343         request->WaitEvent = NULL;
 344 nomem:
 345         PutStorDevice(Device);
 346         return ret;
 347 }
 348
 349 static void StorVscOnIOCompletion(struct hv_device *Device,
 350                                   struct vstor_packet *VStorPacket,
 351                                   struct storvsc_request_extension *RequestExt)
 352 {
 353         struct hv_storvsc_request *request;
 354         struct storvsc_device *storDevice;
 355
 356         storDevice = MustGetStorDevice(Device);
 357         if (!storDevice) {
 358                 DPRINT_ERR(STORVSC, "unable to get stor device..."
 359                            "device being destroyed?");
 360                 return;
 361         }
 362
 363         DPRINT_DBG(STORVSC, "IO_COMPLETE_OPERATION - request extension %p "
 364                    "completed bytes xfer %u", RequestExt,
 365                    VStorPacket->VmSrb.DataTransferLength);
 366
 367         /* ASSERT(RequestExt != NULL); */
 368         /* ASSERT(RequestExt->Request != NULL); */
 369
 370         request = RequestExt->Request;
 371
 372         /* ASSERT(request->OnIOCompletion != NULL); */
 373
 374         /* Copy over the status...etc */
 375         request->Status = VStorPacket->VmSrb.ScsiStatus;
 376
 377         if (request->Status != 0 || VStorPacket->VmSrb.SrbStatus != 1) {
 378                 DPRINT_WARN(STORVSC,
 379                             "cmd 0x%x scsi status 0x%x srb status 0x%x\n",
 380                             request->Cdb[0], VStorPacket->VmSrb.ScsiStatus,
 381                             VStorPacket->VmSrb.SrbStatus);
 382         }
 383
 384         if ((request->Status & 0xFF) == 0x02) {
 385                 /* CHECK_CONDITION */
 386                 if (VStorPacket->VmSrb.SrbStatus & 0x80) {
 387                         /* autosense data available */
 388                         DPRINT_WARN(STORVSC, "storvsc pkt %p autosense data "
 389                                     "valid - len %d\n", RequestExt,
 390                                     VStorPacket->VmSrb.SenseInfoLength);
 391
 392                         /* ASSERT(VStorPacket->VmSrb.SenseInfoLength <= */
 393                         /*      request->SenseBufferSize); */
 394                         memcpy(request->SenseBuffer,
 395                                VStorPacket->VmSrb.SenseData,
 396                                VStorPacket->VmSrb.SenseInfoLength);
 397
 398                         request->SenseBufferSize =
 399                                         VStorPacket->VmSrb.SenseInfoLength;
 400                 }
 401         }
 402
 403         /* TODO: */
 404         request->BytesXfer = VStorPacket->VmSrb.DataTransferLength;
 405
 406         request->OnIOCompletion(request);
 407
 408         atomic_dec(&storDevice->NumOutstandingRequests);
 409
 410         PutStorDevice(Device);
 411 }
 412
 413 static void StorVscOnReceive(struct hv_device *Device,
 414                              struct vstor_packet *VStorPacket,
 415                              struct storvsc_request_extension *RequestExt)
 416 {
 417         switch (VStorPacket->Operation) {
 418         case VStorOperationCompleteIo:
 419                 DPRINT_DBG(STORVSC, "IO_COMPLETE_OPERATION");
 420                 StorVscOnIOCompletion(Device, VStorPacket, RequestExt);
 421                 break;
 422         case VStorOperationRemoveDevice:
 423                 DPRINT_INFO(STORVSC, "REMOVE_DEVICE_OPERATION");
 424                 /* TODO: */
 425                 break;
 426
 427         default:
 428                 DPRINT_INFO(STORVSC, "Unknown operation received - %d",
 429                             VStorPacket->Operation);
 430                 break;
 431         }
 432 }
 433
 434 static void StorVscOnChannelCallback(void *context)
 435 {
 436         struct hv_device *device = (struct hv_device *)context;
 437         struct storvsc_device *storDevice;
 438         u32 bytesRecvd;
 439         u64 requestId;
 440         unsigned char packet[ALIGN_UP(sizeof(struct vstor_packet), 8)];
 441         struct storvsc_request_extension *request;
 442         int ret;
 443
 444         /* ASSERT(device); */
 445
 446         storDevice = MustGetStorDevice(device);
 447         if (!storDevice) {
 448                 DPRINT_ERR(STORVSC, "unable to get stor device..."
 449                            "device being destroyed?");
 450                 return;
 451         }
 452
 453         do {
 454                 ret = device->Driver->VmbusChannelInterface.RecvPacket(device,
 455                                 packet,
 456                                 ALIGN_UP(sizeof(struct vstor_packet), 8),
 457                                 &bytesRecvd, &requestId);
 458                 if (ret == 0 && bytesRecvd > 0) {
 459                         DPRINT_DBG(STORVSC, "receive %d bytes - tid %llx",
 460                                    bytesRecvd, requestId);
 461
 462                         /* ASSERT(bytesRecvd == sizeof(struct vstor_packet)); */
 463
 464                         request = (struct storvsc_request_extension *)
 465                                         (unsigned long)requestId;
 466                         /* ASSERT(request);c */
 467
 468                         /* if (vstorPacket.Flags & SYNTHETIC_FLAG) */
 469                         if ((request == &storDevice->InitRequest) ||
 470                             (request == &storDevice->ResetRequest)) {
 471                                 /* DPRINT_INFO(STORVSC,
 472                                  *             "reset completion - operation "
 473                                  *             "%u status %u",
 474                                  *             vstorPacket.Operation,
 475                                  *             vstorPacket.Status); */
 476
 477                                 memcpy(&request->VStorPacket, packet,
 478                                        sizeof(struct vstor_packet));
 479
 480                                 osd_WaitEventSet(request->WaitEvent);
 481                         } else {
 482                                 StorVscOnReceive(device,
 483                                                 (struct vstor_packet *)packet,
 484                                                 request);
 485                         }
 486                 } else {
 487                         /* DPRINT_DBG(STORVSC, "nothing else to read..."); */
 488                         break;
 489                 }
 490         } while (1);
 491
 492         PutStorDevice(device);
 493         return;
 494 }
 495
 496 static int StorVscConnectToVsp(struct hv_device *Device)
 497 {
 498         struct vmstorage_channel_properties props;
 499         struct storvsc_driver_object *storDriver;
 500         int ret;
 501
 502         storDriver = (struct storvsc_driver_object *)Device->Driver;
 503         memset(&props, 0, sizeof(struct vmstorage_channel_properties));
 504
 505         /* Open the channel */
 506         ret = Device->Driver->VmbusChannelInterface.Open(Device,
 507                         storDriver->RingBufferSize,
 508                         storDriver->RingBufferSize,
 509                         (void *)&props,
 510                         sizeof(struct vmstorage_channel_properties),
 511                         StorVscOnChannelCallback,
 512                         Device);
 513
 514         DPRINT_DBG(STORVSC, "storage props: path id %d, tgt id %d, max xfer %d",
 515                    props.PathId, props.TargetId, props.MaxTransferBytes);
 516
 517         if (ret != 0) {
 518                 DPRINT_ERR(STORVSC, "unable to open channel: %d", ret);
 519                 return -1;
 520         }
 521
 522         ret = StorVscChannelInit(Device);
 523
 524         return ret;
 525 }
 526
 527 /*
 528  * StorVscOnDeviceAdd - Callback when the device belonging to this driver is added
 529  */
 530 static int StorVscOnDeviceAdd(struct hv_device *Device, void *AdditionalInfo)
 531 {
 532         struct storvsc_device *storDevice;
 533         /* struct vmstorage_channel_properties *props; */
 534         struct storvsc_device_info *deviceInfo;
 535         int ret = 0;
 536
 537         deviceInfo = (struct storvsc_device_info *)AdditionalInfo;
 538         storDevice = AllocStorDevice(Device);
 539         if (!storDevice) {
 540                 ret = -1;
 541                 goto Cleanup;
 542         }
 543
 544         /* Save the channel properties to our storvsc channel */
 545         /* props = (struct vmstorage_channel_properties *)
 546          *              channel->offerMsg.Offer.u.Standard.UserDefined; */
 547
 548         /*
 549          * If we support more than 1 scsi channel, we need to set the
 550          * port number here to the scsi channel but how do we get the
 551          * scsi channel prior to the bus scan
 552          */
 553
 554         /* storChannel->PortNumber = 0;
 555         storChannel->PathId = props->PathId;
 556         storChannel->TargetId = props->TargetId; */
 557
 558         storDevice->PortNumber = deviceInfo->PortNumber;
 559         /* Send it back up */
 560         ret = StorVscConnectToVsp(Device);
 561
 562         /* deviceInfo->PortNumber = storDevice->PortNumber; */
 563         deviceInfo->PathId = storDevice->PathId;
 564         deviceInfo->TargetId = storDevice->TargetId;
 565
 566         DPRINT_DBG(STORVSC, "assigned port %u, path %u target %u\n",
 567                    storDevice->PortNumber, storDevice->PathId,
 568                    storDevice->TargetId);
 569
 570 Cleanup:
 571         return ret;
 572 }
 573
 574 /*
 575  * StorVscOnDeviceRemove - Callback when the our device is being removed
 576  */
 577 static int StorVscOnDeviceRemove(struct hv_device *Device)
 578 {
 579         struct storvsc_device *storDevice;
 580
 581         DPRINT_INFO(STORVSC, "disabling storage device (%p)...",
 582                     Device->Extension);
 583
 584         storDevice = ReleaseStorDevice(Device);
 585
 586         /*
 587          * At this point, all outbound traffic should be disable. We
 588          * only allow inbound traffic (responses) to proceed so that
 589          * outstanding requests can be completed.
 590          */
 591         while (atomic_read(&storDevice->NumOutstandingRequests)) {
 592                 DPRINT_INFO(STORVSC, "waiting for %d requests to complete...",
 593                             atomic_read(&storDevice->NumOutstandingRequests));
 594                 udelay(100);
 595         }
 596
 597         DPRINT_INFO(STORVSC, "removing storage device (%p)...",
 598                     Device->Extension);
 599
 600         storDevice = FinalReleaseStorDevice(Device);
 601
 602         DPRINT_INFO(STORVSC, "storage device (%p) safe to remove", storDevice);
 603
 604         /* Close the channel */
 605         Device->Driver->VmbusChannelInterface.Close(Device);
 606
 607         FreeStorDevice(storDevice);
 608         return 0;
 609 }
 610
 611 int StorVscOnHostReset(struct hv_device *Device)
 612 {
 613         struct storvsc_device *storDevice;
 614         struct storvsc_request_extension *request;
 615         struct vstor_packet *vstorPacket;
 616         int ret;
 617
 618         DPRINT_INFO(STORVSC, "resetting host adapter...");
 619
 620         storDevice = GetStorDevice(Device);
 621         if (!storDevice) {
 622                 DPRINT_ERR(STORVSC, "unable to get stor device..."
 623                            "device being destroyed?");
 624                 return -1;
 625         }
 626
 627         request = &storDevice->ResetRequest;
 628         vstorPacket = &request->VStorPacket;
 629
 630         request->WaitEvent = osd_WaitEventCreate();
 631         if (!request->WaitEvent) {
 632                 ret = -ENOMEM;
 633                 goto Cleanup;
 634         }
 635
 636         vstorPacket->Operation = VStorOperationResetBus;
 637         vstorPacket->Flags = REQUEST_COMPLETION_FLAG;
 638         vstorPacket->VmSrb.PathId = storDevice->PathId;
 639
 640         ret = Device->Driver->VmbusChannelInterface.SendPacket(Device,
 641                                 vstorPacket,
 642                                 sizeof(struct vstor_packet),
 643                                 (unsigned long)&storDevice->ResetRequest,
 644                                 VmbusPacketTypeDataInBand,
 645                                 VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
 646         if (ret != 0) {
 647                 DPRINT_ERR(STORVSC, "Unable to send reset packet %p ret %d",
 648                            vstorPacket, ret);
 649                 goto Cleanup;
 650         }
 651
 652         osd_WaitEventWait(request->WaitEvent);
 653
 654         kfree(request->WaitEvent);
 655         DPRINT_INFO(STORVSC, "host adapter reset completed");
 656
 657         /*
 658          * At this point, all outstanding requests in the adapter
 659          * should have been flushed out and return to us
 660          */
 661
 662 Cleanup:
 663         PutStorDevice(Device);
 664         return ret;
 665 }
 666
 667 /*
 668  * StorVscOnIORequest - Callback to initiate an I/O request
 669  */
 670 static int StorVscOnIORequest(struct hv_device *Device,
 671                               struct hv_storvsc_request *Request)
 672 {
 673         struct storvsc_device *storDevice;
 674         struct storvsc_request_extension *requestExtension;
 675         struct vstor_packet *vstorPacket;
 676         int ret = 0;
 677
 678         requestExtension =
 679                 (struct storvsc_request_extension *)Request->Extension;
 680         vstorPacket = &requestExtension->VStorPacket;
 681         storDevice = GetStorDevice(Device);
 682
 683         DPRINT_DBG(STORVSC, "enter - Device %p, DeviceExt %p, Request %p, "
 684                    "Extension %p", Device, storDevice, Request,
 685                    requestExtension);
 686
 687         DPRINT_DBG(STORVSC, "req %p len %d bus %d, target %d, lun %d cdblen %d",
 688                    Request, Request->DataBuffer.Length, Request->Bus,
 689                    Request->TargetId, Request->LunId, Request->CdbLen);
 690
 691         if (!storDevice) {
 692                 DPRINT_ERR(STORVSC, "unable to get stor device..."
 693                            "device being destroyed?");
 694                 return -2;
 695         }
 696
 697         /* print_hex_dump_bytes("", DUMP_PREFIX_NONE, Request->Cdb,
 698          *                      Request->CdbLen); */
 699
 700         requestExtension->Request = Request;
 701         requestExtension->Device  = Device;
 702
 703         memset(vstorPacket, 0 , sizeof(struct vstor_packet));
 704
 705         vstorPacket->Flags |= REQUEST_COMPLETION_FLAG;
 706
 707         vstorPacket->VmSrb.Length = sizeof(struct vmscsi_request);
 708
 709         vstorPacket->VmSrb.PortNumber = Request->Host;
 710         vstorPacket->VmSrb.PathId = Request->Bus;
 711         vstorPacket->VmSrb.TargetId = Request->TargetId;
 712         vstorPacket->VmSrb.Lun = Request->LunId;
 713
 714         vstorPacket->VmSrb.SenseInfoLength = SENSE_BUFFER_SIZE;
 715
 716         /* Copy over the scsi command descriptor block */
 717         vstorPacket->VmSrb.CdbLength = Request->CdbLen;
 718         memcpy(&vstorPacket->VmSrb.Cdb, Request->Cdb, Request->CdbLen);
 719
 720         vstorPacket->VmSrb.DataIn = Request->Type;
 721         vstorPacket->VmSrb.DataTransferLength = Request->DataBuffer.Length;
 722
 723         vstorPacket->Operation = VStorOperationExecuteSRB;
 724
 725         DPRINT_DBG(STORVSC, "srb - len %d port %d, path %d, target %d, "
 726                    "lun %d senselen %d cdblen %d",
 727                    vstorPacket->VmSrb.Length,
 728                    vstorPacket->VmSrb.PortNumber,
 729                    vstorPacket->VmSrb.PathId,
 730                    vstorPacket->VmSrb.TargetId,
 731                    vstorPacket->VmSrb.Lun,
 732                    vstorPacket->VmSrb.SenseInfoLength,
 733                    vstorPacket->VmSrb.CdbLength);
 734
 735         if (requestExtension->Request->DataBuffer.Length) {
 736                 ret = Device->Driver->VmbusChannelInterface.
 737                         SendPacketMultiPageBuffer(Device,
 738                                 &requestExtension->Request->DataBuffer,
 739                                 vstorPacket,
 740                                 sizeof(struct vstor_packet),
 741                                 (unsigned long)requestExtension);
 742         } else {
 743                 ret = Device->Driver->VmbusChannelInterface.SendPacket(Device,
 744                                 vstorPacket,
 745                                 sizeof(struct vstor_packet),
 746                                 (unsigned long)requestExtension,
 747                                 VmbusPacketTypeDataInBand,
 748                                 VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
 749         }
 750
 751         if (ret != 0) {
 752                 DPRINT_DBG(STORVSC, "Unable to send packet %p ret %d",
 753                            vstorPacket, ret);
 754         }
 755
 756         atomic_inc(&storDevice->NumOutstandingRequests);
 757
 758         PutStorDevice(Device);
 759         return ret;
 760 }
 761
 762 /*
 763  * StorVscOnCleanup - Perform any cleanup when the driver is removed
 764  */
 765 static void StorVscOnCleanup(struct hv_driver *Driver)
 766 {
 767 }
 768
 769 /*
 770  * StorVscInitialize - Main entry point
 771  */
 772 int StorVscInitialize(struct hv_driver *Driver)
 773 {
 774         struct storvsc_driver_object *storDriver;
 775
 776         storDriver = (struct storvsc_driver_object *)Driver;
 777
 778         DPRINT_DBG(STORVSC, "sizeof(STORVSC_REQUEST)=%zd "
 779                    "sizeof(struct storvsc_request_extension)=%zd "
 780                    "sizeof(struct vstor_packet)=%zd, "
 781                    "sizeof(struct vmscsi_request)=%zd",
 782                    sizeof(struct hv_storvsc_request),
 783                    sizeof(struct storvsc_request_extension),
 784                    sizeof(struct vstor_packet),
 785                    sizeof(struct vmscsi_request));
 786
 787         /* Make sure we are at least 2 pages since 1 page is used for control */
 788         /* ASSERT(storDriver->RingBufferSize >= (PAGE_SIZE << 1)); */
 789
 790         Driver->name = gDriverName;
 791         memcpy(&Driver->deviceType, &gStorVscDeviceType,
 792                sizeof(struct hv_guid));
 793
 794         storDriver->RequestExtSize = sizeof(struct storvsc_request_extension);
 795
 796         /*
 797          * Divide the ring buffer data size (which is 1 page less
 798          * than the ring buffer size since that page is reserved for
 799          * the ring buffer indices) by the max request size (which is
 800          * VMBUS_CHANNEL_PACKET_MULITPAGE_BUFFER + struct vstor_packet + u64)
 801          */
 802         storDriver->MaxOutstandingRequestsPerChannel =
 803                 ((storDriver->RingBufferSize - PAGE_SIZE) /
 804                   ALIGN_UP(MAX_MULTIPAGE_BUFFER_PACKET +
 805                            sizeof(struct vstor_packet) + sizeof(u64),
 806                            sizeof(u64)));
 807
 808         DPRINT_INFO(STORVSC, "max io %u, currently %u\n",
 809                     storDriver->MaxOutstandingRequestsPerChannel,
 810                     STORVSC_MAX_IO_REQUESTS);
 811
 812         /* Setup the dispatch table */
 813         storDriver->Base.OnDeviceAdd    = StorVscOnDeviceAdd;
 814         storDriver->Base.OnDeviceRemove = StorVscOnDeviceRemove;
 815         storDriver->Base.OnCleanup      = StorVscOnCleanup;
 816
 817         storDriver->OnIORequest         = StorVscOnIORequest;
 818
 819         return 0;
 820 }