drivers/staging/hv/Vmbus.c

   1 /*
   2  *
   3  * Copyright (c) 2009, Microsoft Corporation.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms and conditions of the GNU General Public License,
   7  * version 2, as published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  12  * more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along with
  15  * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
  16  * Place - Suite 330, Boston, MA 02111-1307 USA.
  17  *
  18  * Authors:
  19  *   Haiyang Zhang <haiyangz@microsoft.com>
  20  *   Hank Janssen  <hjanssen@microsoft.com>
  21  *
  22  */
  23
  24 #include <linux/kernel.h>
  25 #include <linux/mm.h>
  26 #include "osd.h"
  27 #include "logging.h"
  28 #include "VersionInfo.h"
  29 #include "VmbusPrivate.h"
  30
  31
  32 /* Globals */
  33
  34 static const char* gDriverName="vmbus";
  35
  36 /* Windows vmbus does not defined this.
  37  * We defined this to be consistent with other devices
  38  */
  39 /* {c5295816-f63a-4d5f-8d1a-4daf999ca185} */
  40 static const struct hv_guid gVmbusDeviceType = {
  41         .data = {
  42                 0x16, 0x58, 0x29, 0xc5, 0x3a, 0xf6, 0x5f, 0x4d,
  43                 0x8d, 0x1a, 0x4d, 0xaf, 0x99, 0x9c, 0xa1, 0x85
  44         }
  45 };
  46
  47 /* {ac3760fc-9adf-40aa-9427-a70ed6de95c5} */
  48 static const struct hv_guid gVmbusDeviceId = {
  49         .data = {
  50                 0xfc, 0x60, 0x37, 0xac, 0xdf, 0x9a, 0xaa, 0x40,
  51                 0x94, 0x27, 0xa7, 0x0e, 0xd6, 0xde, 0x95, 0xc5
  52         }
  53 };
  54
  55 static struct hv_driver *gDriver; /* vmbus driver object */
  56 static struct hv_device* gDevice; /* vmbus root device */
  57
  58
  59
  60 /* Internal routines */
  61
  62
  63 static void VmbusGetChannelInterface(struct vmbus_channel_interface *Interface);
  64
  65 static void
  66 VmbusGetChannelInfo(
  67         struct hv_device *DeviceObject,
  68         struct hv_device_info *DeviceInfo
  69         );
  70
  71 static void
  72 VmbusGetChannelOffers(
  73         void
  74         );
  75
  76 static int
  77 VmbusOnDeviceAdd(
  78         struct hv_device *Device,
  79         void                    *AdditionalInfo
  80         );
  81
  82 static int
  83 VmbusOnDeviceRemove(
  84         struct hv_device *dev
  85         );
  86
  87 static void
  88 VmbusOnCleanup(
  89         struct hv_driver *drv
  90         );
  91
  92 static int
  93 VmbusOnISR(
  94         struct hv_driver *drv
  95         );
  96
  97 static void
  98 VmbusOnMsgDPC(
  99         struct hv_driver *drv
 100         );
 101
 102 static void
 103 VmbusOnEventDPC(
 104         struct hv_driver *drv
 105         );
 106
 107 /*++;
 108
 109 Name:
 110         VmbusInitialize()
 111
 112 Description:
 113         Main entry point
 114
 115 --*/
 116 int
 117 VmbusInitialize(
 118         struct hv_driver *drv
 119         )
 120 {
 121         struct vmbus_driver *driver = (struct vmbus_driver *)drv;
 122         int ret=0;
 123
 124         DPRINT_ENTER(VMBUS);
 125
 126         DPRINT_INFO(VMBUS, "+++++++ Build Date=%s %s +++++++", VersionDate, VersionTime);
 127         DPRINT_INFO(VMBUS, "+++++++ Build Description=%s +++++++", VersionDesc);
 128
 129         DPRINT_INFO(VMBUS, "+++++++ Vmbus supported version = %d +++++++", VMBUS_REVISION_NUMBER);
 130         DPRINT_INFO(VMBUS, "+++++++ Vmbus using SINT %d +++++++", VMBUS_MESSAGE_SINT);
 131
 132         DPRINT_DBG(VMBUS, "sizeof(VMBUS_CHANNEL_PACKET_PAGE_BUFFER)=%zd, sizeof(VMBUS_CHANNEL_PACKET_MULITPAGE_BUFFER)=%zd",
 133                 sizeof(struct VMBUS_CHANNEL_PACKET_PAGE_BUFFER), sizeof(struct VMBUS_CHANNEL_PACKET_MULITPAGE_BUFFER));
 134
 135         drv->name = gDriverName;
 136         memcpy(&drv->deviceType, &gVmbusDeviceType, sizeof(struct hv_guid));
 137
 138         /* Setup dispatch table */
 139         driver->Base.OnDeviceAdd                = VmbusOnDeviceAdd;
 140         driver->Base.OnDeviceRemove             = VmbusOnDeviceRemove;
 141         driver->Base.OnCleanup                  = VmbusOnCleanup;
 142         driver->OnIsr                                   = VmbusOnISR;
 143         driver->OnMsgDpc                                = VmbusOnMsgDPC;
 144         driver->OnEventDpc                              = VmbusOnEventDPC;
 145         driver->GetChannelOffers                = VmbusGetChannelOffers;
 146         driver->GetChannelInterface             = VmbusGetChannelInterface;
 147         driver->GetChannelInfo                  = VmbusGetChannelInfo;
 148
 149         /* Hypervisor initialization...setup hypercall page..etc */
 150         ret = HvInit();
 151         if (ret != 0)
 152         {
 153                 DPRINT_ERR(VMBUS, "Unable to initialize the hypervisor - 0x%x", ret);
 154         }
 155
 156         gDriver = drv;
 157
 158         DPRINT_EXIT(VMBUS);
 159
 160         return ret;
 161 }
 162
 163
 164 /*++;
 165
 166 Name:
 167         VmbusGetChannelOffers()
 168
 169 Description:
 170         Retrieve the channel offers from the parent partition
 171
 172 --*/
 173
 174 static void
 175 VmbusGetChannelOffers(void)
 176 {
 177         DPRINT_ENTER(VMBUS);
 178         VmbusChannelRequestOffers();
 179         DPRINT_EXIT(VMBUS);
 180 }
 181
 182
 183 /*++;
 184
 185 Name:
 186         VmbusGetChannelInterface()
 187
 188 Description:
 189         Get the channel interface
 190
 191 --*/
 192 static void VmbusGetChannelInterface(struct vmbus_channel_interface *Interface)
 193 {
 194         GetChannelInterface(Interface);
 195 }
 196
 197
 198 /*++;
 199
 200 Name:
 201         VmbusGetChannelInfo()
 202
 203 Description:
 204         Get the device info for the specified device object
 205
 206 --*/
 207 static void
 208 VmbusGetChannelInfo(
 209         struct hv_device *DeviceObject,
 210         struct hv_device_info *DeviceInfo
 211         )
 212 {
 213         GetChannelInfo(DeviceObject, DeviceInfo);
 214 }
 215
 216
 217
 218 /*++
 219
 220 Name:
 221         VmbusCreateChildDevice()
 222
 223 Description:
 224         Creates the child device on the bus that represents the channel offer
 225
 226 --*/
 227
 228 struct hv_device *VmbusChildDeviceCreate(struct hv_guid *DeviceType,
 229                                          struct hv_guid *DeviceInstance,
 230                                          void *Context)
 231 {
 232         struct vmbus_driver *vmbusDriver = (struct vmbus_driver *)gDriver;
 233
 234         return vmbusDriver->OnChildDeviceCreate(
 235                 DeviceType,
 236                 DeviceInstance,
 237                 Context);
 238 }
 239
 240
 241 /*++
 242
 243 Name:
 244         VmbusChildDeviceAdd()
 245
 246 Description:
 247         Registers the child device with the vmbus
 248
 249 --*/
 250 int VmbusChildDeviceAdd(struct hv_device *ChildDevice)
 251 {
 252         struct vmbus_driver *vmbusDriver = (struct vmbus_driver *)gDriver;
 253
 254         return vmbusDriver->OnChildDeviceAdd(gDevice, ChildDevice);
 255 }
 256
 257
 258 /*++
 259
 260 Name:
 261         VmbusChildDeviceRemove()
 262
 263 Description:
 264         Unregisters the child device from the vmbus
 265
 266 --*/
 267 void VmbusChildDeviceRemove(struct hv_device *ChildDevice)
 268 {
 269         struct vmbus_driver *vmbusDriver = (struct vmbus_driver *)gDriver;
 270
 271         vmbusDriver->OnChildDeviceRemove(ChildDevice);
 272 }
 273
 274 /*++
 275
 276 Name:
 277         VmbusChildDeviceDestroy()
 278
 279 Description:
 280         Release the child device from the vmbus
 281
 282 --*/
 283
 284 /* **************
 285 void
 286 VmbusChildDeviceDestroy(
 287 struct hv_device  *ChildDevice
 288 )
 289 {
 290         struct vmbus_driver *vmbusDriver = (struct vmbus_driver *)gDriver;
 291
 292         vmbusDriver->OnChildDeviceDestroy(ChildDevice);
 293 }
 294 ************* */
 295
 296 /*++
 297
 298 Name:
 299         VmbusOnDeviceAdd()
 300
 301 Description:
 302         Callback when the root bus device is added
 303
 304 --*/
 305 static int
 306 VmbusOnDeviceAdd(
 307         struct hv_device *dev,
 308         void                    *AdditionalInfo
 309         )
 310 {
 311         u32 *irqvector = (u32*) AdditionalInfo;
 312         int ret=0;
 313
 314         DPRINT_ENTER(VMBUS);
 315
 316         gDevice = dev;
 317
 318         memcpy(&gDevice->deviceType, &gVmbusDeviceType, sizeof(struct hv_guid));
 319         memcpy(&gDevice->deviceInstance, &gVmbusDeviceId, sizeof(struct hv_guid));
 320
 321         /* strcpy(dev->name, "vmbus"); */
 322         /* SynIC setup... */
 323         ret = HvSynicInit(*irqvector);
 324
 325         /* Connect to VMBus in the root partition */
 326         ret = VmbusConnect();
 327
 328         /* VmbusSendEvent(device->localPortId+1); */
 329         DPRINT_EXIT(VMBUS);
 330
 331         return ret;
 332 }
 333
 334
 335 /*++
 336
 337 Name:
 338         VmbusOnDeviceRemove()
 339
 340 Description:
 341         Callback when the root bus device is removed
 342
 343 --*/
 344 static int VmbusOnDeviceRemove(
 345         struct hv_device *dev
 346         )
 347 {
 348         int ret=0;
 349
 350         DPRINT_ENTER(VMBUS);
 351
 352         VmbusChannelReleaseUnattachedChannels();
 353
 354         VmbusDisconnect();
 355
 356         HvSynicCleanup();
 357
 358         DPRINT_EXIT(VMBUS);
 359
 360         return ret;
 361 }
 362
 363
 364 /*++
 365
 366 Name:
 367         VmbusOnCleanup()
 368
 369 Description:
 370         Perform any cleanup when the driver is removed
 371
 372 --*/
 373 static void
 374 VmbusOnCleanup(
 375         struct hv_driver *drv
 376         )
 377 {
 378         /* struct vmbus_driver *driver = (struct vmbus_driver *)drv; */
 379
 380         DPRINT_ENTER(VMBUS);
 381
 382         HvCleanup();
 383
 384         DPRINT_EXIT(VMBUS);
 385 }
 386
 387
 388 /*++
 389
 390 Name:
 391         VmbusOnMsgDPC()
 392
 393 Description:
 394         DPC routine to handle messages from the hypervisior
 395
 396 --*/
 397 static void
 398 VmbusOnMsgDPC(
 399         struct hv_driver *drv
 400         )
 401 {
 402         void *page_addr = gHvContext.synICMessagePage[0];
 403
 404         struct hv_message *msg = (struct hv_message *)page_addr + VMBUS_MESSAGE_SINT;
 405         struct hv_message *copied;
 406         while (1)
 407         {
 408                 if (msg->Header.MessageType == HvMessageTypeNone) /* no msg */
 409                 {
 410                         break;
 411                 }
 412                 else
 413                 {
 414                         copied = kmalloc(sizeof(*copied), GFP_ATOMIC);
 415                         if (copied == NULL)
 416                         {
 417                                 continue;
 418                         }
 419
 420                         memcpy(copied, msg, sizeof(*copied));
 421                         osd_schedule_callback(gVmbusConnection.WorkQueue,
 422                                               VmbusOnChannelMessage,
 423                                               (void *)copied);
 424                 }
 425
 426                 msg->Header.MessageType = HvMessageTypeNone;
 427
 428                 /*
 429                  * Make sure the write to MessageType (ie set to
 430                  * HvMessageTypeNone) happens before we read the
 431                  * MessagePending and EOMing. Otherwise, the EOMing
 432                  * will not deliver any more messages since there is
 433                  * no empty slot
 434                  */
 435                 mb();
 436
 437                 if (msg->Header.MessageFlags.MessagePending)
 438                 {
 439                         /*
 440                          * This will cause message queue rescan to
 441                          * possibly deliver another msg from the
 442                          * hypervisor
 443                          */
 444                         wrmsrl(HV_X64_MSR_EOM, 0);
 445                 }
 446         }
 447 }
 448
 449 /*++
 450
 451 Name:
 452         VmbusOnEventDPC()
 453
 454 Description:
 455         DPC routine to handle events from the hypervisior
 456
 457 --*/
 458 static void
 459 VmbusOnEventDPC(
 460         struct hv_driver* drv
 461         )
 462 {
 463         /* TODO: Process any events */
 464         VmbusOnEvents();
 465 }
 466
 467
 468 /*++
 469
 470 Name:
 471         VmbusOnISR()
 472
 473 Description:
 474         ISR routine
 475
 476 --*/
 477 static int
 478 VmbusOnISR(
 479         struct hv_driver *drv
 480         )
 481 {
 482         /* struct vmbus_driver *driver = (struct vmbus_driver *)drv; */
 483
 484         int ret=0;
 485         /* struct page* page; */
 486         void *page_addr;
 487         struct hv_message *msg;
 488         union hv_synic_event_flags *event;
 489
 490         /* page = SynICMessagePage[0]; */
 491         /* page_addr = page_address(page); */
 492         page_addr = gHvContext.synICMessagePage[0];
 493         msg = (struct hv_message *)page_addr + VMBUS_MESSAGE_SINT;
 494
 495         DPRINT_ENTER(VMBUS);
 496
 497         /* Check if there are actual msgs to be process */
 498         if (msg->Header.MessageType != HvMessageTypeNone)
 499     {
 500                 DPRINT_DBG(VMBUS, "received msg type %d size %d", msg->Header.MessageType, msg->Header.PayloadSize);
 501                 ret |= 0x1;
 502     }
 503
 504         /* TODO: Check if there are events to be process */
 505         page_addr = gHvContext.synICEventPage[0];
 506         event = (union hv_synic_event_flags *)page_addr + VMBUS_MESSAGE_SINT;
 507
 508         /* Since we are a child, we only need to check bit 0 */
 509         if (test_and_clear_bit(0, (unsigned long *) &event->Flags32[0]))
 510         {
 511                 DPRINT_DBG(VMBUS, "received event %d", event->Flags32[0]);
 512                 ret |= 0x2;
 513         }
 514
 515         DPRINT_EXIT(VMBUS);
 516         return ret;
 517 }
 518
 519 /* eof */