drivers/staging/unisys/visorchipset/visorchipset_main.c

   1 /* visorchipset_main.c
   2  *
   3  * Copyright (C) 2010 - 2013 UNISYS CORPORATION
   4  * All rights reserved.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or (at
   9  * your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
  14  * NON INFRINGEMENT.  See the GNU General Public License for more
  15  * details.
  16  */
  17
  18 #include "globals.h"
  19 #include "visorchipset.h"
  20 #include "procobjecttree.h"
  21 #include "visorchannel.h"
  22 #include "periodic_work.h"
  23 #include "file.h"
  24 #include "parser.h"
  25 #include "uisutils.h"
  26 #include "controlvmcompletionstatus.h"
  27 #include "guestlinuxdebug.h"
  28
  29 #include <linux/nls.h>
  30 #include <linux/netdevice.h>
  31 #include <linux/platform_device.h>
  32 #include <linux/uuid.h>
  33
  34 #define CURRENT_FILE_PC VISOR_CHIPSET_PC_visorchipset_main_c
  35 #define TEST_VNIC_PHYSITF "eth0"        /* physical network itf for
  36                                          * vnic loopback test */
  37 #define TEST_VNIC_SWITCHNO 1
  38 #define TEST_VNIC_BUSNO 9
  39
  40 #define MAX_NAME_SIZE 128
  41 #define MAX_IP_SIZE   50
  42 #define MAXOUTSTANDINGCHANNELCOMMAND 256
  43 #define POLLJIFFIES_CONTROLVMCHANNEL_FAST   1
  44 #define POLLJIFFIES_CONTROLVMCHANNEL_SLOW 100
  45
  46 /* When the controlvm channel is idle for at least MIN_IDLE_SECONDS,
  47 * we switch to slow polling mode.  As soon as we get a controlvm
  48 * message, we switch back to fast polling mode.
  49 */
  50 #define MIN_IDLE_SECONDS 10
  51 static ulong poll_jiffies = POLLJIFFIES_CONTROLVMCHANNEL_FAST;
  52 static ulong most_recent_message_jiffies;       /* when we got our last
  53                                                  * controlvm message */
  54 static inline char *
  55 NONULLSTR(char *s)
  56 {
  57         if (s)
  58                 return s;
  59         return "";
  60 }
  61
  62 static int serverregistered;
  63 static int clientregistered;
  64
  65 #define MAX_CHIPSET_EVENTS 2
  66 static u8 chipset_events[MAX_CHIPSET_EVENTS] = { 0, 0 };
  67
  68 static struct delayed_work periodic_controlvm_work;
  69 static struct workqueue_struct *periodic_controlvm_workqueue;
  70 static DEFINE_SEMAPHORE(notifier_lock);
  71
  72 static struct controlvm_message_header g_diag_msg_hdr;
  73 static struct controlvm_message_header g_chipset_msg_hdr;
  74 static struct controlvm_message_header g_del_dump_msg_hdr;
  75 static const uuid_le spar_diag_pool_channel_protocol_uuid =
  76         SPAR_DIAG_POOL_CHANNEL_PROTOCOL_UUID;
  77 /* 0xffffff is an invalid Bus/Device number */
  78 static ulong g_diagpool_bus_no = 0xffffff;
  79 static ulong g_diagpool_dev_no = 0xffffff;
  80 static struct controlvm_message_packet g_devicechangestate_packet;
  81
  82 /* Only VNIC and VHBA channels are sent to visorclientbus (aka
  83  * "visorhackbus")
  84  */
  85 #define FOR_VISORHACKBUS(channel_type_guid) \
  86         (((uuid_le_cmp(channel_type_guid,\
  87                        spar_vnic_channel_protocol_uuid) == 0) ||\
  88         (uuid_le_cmp(channel_type_guid,\
  89                         spar_vhba_channel_protocol_uuid) == 0)))
  90 #define FOR_VISORBUS(channel_type_guid) (!(FOR_VISORHACKBUS(channel_type_guid)))
  91
  92 #define is_diagpool_channel(channel_type_guid) \
  93         (uuid_le_cmp(channel_type_guid,\
  94                      spar_diag_pool_channel_protocol_uuid) == 0)
  95
  96 static LIST_HEAD(bus_info_list);
  97 static LIST_HEAD(dev_info_list);
  98
  99 static struct visorchannel *controlvm_channel;
 100
 101 /* Manages the request payload in the controlvm channel */
 102 static struct controlvm_payload_info {
 103         u8 __iomem *ptr;        /* pointer to base address of payload pool */
 104         u64 offset;             /* offset from beginning of controlvm
 105                                  * channel to beginning of payload * pool */
 106         u32 bytes;              /* number of bytes in payload pool */
 107 } controlvm_payload_info;
 108
 109 /* Manages the info for a CONTROLVM_DUMP_CAPTURESTATE /
 110  * CONTROLVM_DUMP_GETTEXTDUMP / CONTROLVM_DUMP_COMPLETE conversation.
 111  */
 112 static struct livedump_info {
 113         struct controlvm_message_header dumpcapture_header;
 114         struct controlvm_message_header gettextdump_header;
 115         struct controlvm_message_header dumpcomplete_header;
 116         BOOL gettextdump_outstanding;
 117         u32 crc32;
 118         ulong length;
 119         atomic_t buffers_in_use;
 120         ulong destination;
 121 } livedump_info;
 122
 123 /* The following globals are used to handle the scenario where we are unable to
 124  * offload the payload from a controlvm message due to memory requirements.  In
 125  * this scenario, we simply stash the controlvm message, then attempt to
 126  * process it again the next time controlvm_periodic_work() runs.
 127  */
 128 static struct controlvm_message ControlVm_Pending_Msg;
 129 static BOOL ControlVm_Pending_Msg_Valid = FALSE;
 130
 131 /* Pool of struct putfile_buffer_entry, for keeping track of pending (incoming)
 132  * TRANSMIT_FILE PutFile payloads.
 133  */
 134 static struct kmem_cache *Putfile_buffer_list_pool;
 135 static const char Putfile_buffer_list_pool_name[] =
 136         "controlvm_putfile_buffer_list_pool";
 137
 138 /* This identifies a data buffer that has been received via a controlvm messages
 139  * in a remote --> local CONTROLVM_TRANSMIT_FILE conversation.
 140  */
 141 struct putfile_buffer_entry {
 142         struct list_head next;  /* putfile_buffer_entry list */
 143         struct parser_context *parser_ctx; /* points to input data buffer */
 144 };
 145
 146 /* List of struct putfile_request *, via next_putfile_request member.
 147  * Each entry in this list identifies an outstanding TRANSMIT_FILE
 148  * conversation.
 149  */
 150 static LIST_HEAD(Putfile_request_list);
 151
 152 /* This describes a buffer and its current state of transfer (e.g., how many
 153  * bytes have already been supplied as putfile data, and how many bytes are
 154  * remaining) for a putfile_request.
 155  */
 156 struct putfile_active_buffer {
 157         /* a payload from a controlvm message, containing a file data buffer */
 158         struct parser_context *parser_ctx;
 159         /* points within data area of parser_ctx to next byte of data */
 160         u8 *pnext;
 161         /* # bytes left from <pnext> to the end of this data buffer */
 162         size_t bytes_remaining;
 163 };
 164
 165 #define PUTFILE_REQUEST_SIG 0x0906101302281211
 166 /* This identifies a single remote --> local CONTROLVM_TRANSMIT_FILE
 167  * conversation.  Structs of this type are dynamically linked into
 168  * <Putfile_request_list>.
 169  */
 170 struct putfile_request {
 171         u64 sig;                /* PUTFILE_REQUEST_SIG */
 172
 173         /* header from original TransmitFile request */
 174         struct controlvm_message_header controlvm_header;
 175         u64 file_request_number;        /* from original TransmitFile request */
 176
 177         /* link to next struct putfile_request */
 178         struct list_head next_putfile_request;
 179
 180         /* most-recent sequence number supplied via a controlvm message */
 181         u64 data_sequence_number;
 182
 183         /* head of putfile_buffer_entry list, which describes the data to be
 184          * supplied as putfile data;
 185          * - this list is added to when controlvm messages come in that supply
 186          * file data
 187          * - this list is removed from via the hotplug program that is actually
 188          * consuming these buffers to write as file data */
 189         struct list_head input_buffer_list;
 190         spinlock_t req_list_lock;       /* lock for input_buffer_list */
 191
 192         /* waiters for input_buffer_list to go non-empty */
 193         wait_queue_head_t input_buffer_wq;
 194
 195         /* data not yet read within current putfile_buffer_entry */
 196         struct putfile_active_buffer active_buf;
 197
 198         /* <0 = failed, 0 = in-progress, >0 = successful; */
 199         /* note that this must be set with req_list_lock, and if you set <0, */
 200         /* it is your responsibility to also free up all of the other objects */
 201         /* in this struct (like input_buffer_list, active_buf.parser_ctx) */
 202         /* before releasing the lock */
 203         int completion_status;
 204 };
 205
 206 static atomic_t Visorchipset_cache_buffers_in_use = ATOMIC_INIT(0);
 207
 208 struct parahotplug_request {
 209         struct list_head list;
 210         int id;
 211         unsigned long expiration;
 212         struct controlvm_message msg;
 213 };
 214
 215 static LIST_HEAD(Parahotplug_request_list);
 216 static DEFINE_SPINLOCK(Parahotplug_request_list_lock);  /* lock for above */
 217 static void parahotplug_process_list(void);
 218
 219 /* Manages the info for a CONTROLVM_DUMP_CAPTURESTATE /
 220  * CONTROLVM_REPORTEVENT.
 221  */
 222 static struct visorchipset_busdev_notifiers BusDev_Server_Notifiers;
 223 static struct visorchipset_busdev_notifiers BusDev_Client_Notifiers;
 224
 225 static void bus_create_response(ulong busNo, int response);
 226 static void bus_destroy_response(ulong busNo, int response);
 227 static void device_create_response(ulong busNo, ulong devNo, int response);
 228 static void device_destroy_response(ulong busNo, ulong devNo, int response);
 229 static void device_resume_response(ulong busNo, ulong devNo, int response);
 230
 231 static struct visorchipset_busdev_responders BusDev_Responders = {
 232         .bus_create = bus_create_response,
 233         .bus_destroy = bus_destroy_response,
 234         .device_create = device_create_response,
 235         .device_destroy = device_destroy_response,
 236         .device_pause = visorchipset_device_pause_response,
 237         .device_resume = device_resume_response,
 238 };
 239
 240 /* info for /dev/visorchipset */
 241 static dev_t MajorDev = -1; /**< indicates major num for device */
 242
 243 /* prototypes for attributes */
 244 static ssize_t toolaction_show(struct device *dev,
 245         struct device_attribute *attr, char *buf);
 246 static ssize_t toolaction_store(struct device *dev,
 247         struct device_attribute *attr, const char *buf, size_t count);
 248 static DEVICE_ATTR_RW(toolaction);
 249
 250 static ssize_t boottotool_show(struct device *dev,
 251         struct device_attribute *attr, char *buf);
 252 static ssize_t boottotool_store(struct device *dev,
 253         struct device_attribute *attr, const char *buf, size_t count);
 254 static DEVICE_ATTR_RW(boottotool);
 255
 256 static ssize_t error_show(struct device *dev, struct device_attribute *attr,
 257         char *buf);
 258 static ssize_t error_store(struct device *dev, struct device_attribute *attr,
 259         const char *buf, size_t count);
 260 static DEVICE_ATTR_RW(error);
 261
 262 static ssize_t textid_show(struct device *dev, struct device_attribute *attr,
 263         char *buf);
 264 static ssize_t textid_store(struct device *dev, struct device_attribute *attr,
 265         const char *buf, size_t count);
 266 static DEVICE_ATTR_RW(textid);
 267
 268 static ssize_t remaining_steps_show(struct device *dev,
 269         struct device_attribute *attr, char *buf);
 270 static ssize_t remaining_steps_store(struct device *dev,
 271         struct device_attribute *attr, const char *buf, size_t count);
 272 static DEVICE_ATTR_RW(remaining_steps);
 273
 274 static ssize_t chipsetready_store(struct device *dev,
 275                 struct device_attribute *attr, const char *buf, size_t count);
 276 static DEVICE_ATTR_WO(chipsetready);
 277
 278 static ssize_t devicedisabled_store(struct device *dev,
 279                 struct device_attribute *attr, const char *buf, size_t count);
 280 static DEVICE_ATTR_WO(devicedisabled);
 281
 282 static ssize_t deviceenabled_store(struct device *dev,
 283                 struct device_attribute *attr, const char *buf, size_t count);
 284 static DEVICE_ATTR_WO(deviceenabled);
 285
 286 static struct attribute *visorchipset_install_attrs[] = {
 287         &dev_attr_toolaction.attr,
 288         &dev_attr_boottotool.attr,
 289         &dev_attr_error.attr,
 290         &dev_attr_textid.attr,
 291         &dev_attr_remaining_steps.attr,
 292         NULL
 293 };
 294
 295 static struct attribute_group visorchipset_install_group = {
 296         .name = "install",
 297         .attrs = visorchipset_install_attrs
 298 };
 299
 300 static struct attribute *visorchipset_guest_attrs[] = {
 301         &dev_attr_chipsetready.attr,
 302         NULL
 303 };
 304
 305 static struct attribute_group visorchipset_guest_group = {
 306         .name = "guest",
 307         .attrs = visorchipset_guest_attrs
 308 };
 309
 310 static struct attribute *visorchipset_parahotplug_attrs[] = {
 311         &dev_attr_devicedisabled.attr,
 312         &dev_attr_deviceenabled.attr,
 313         NULL
 314 };
 315
 316 static struct attribute_group visorchipset_parahotplug_group = {
 317         .name = "parahotplug",
 318         .attrs = visorchipset_parahotplug_attrs
 319 };
 320
 321 static const struct attribute_group *visorchipset_dev_groups[] = {
 322         &visorchipset_install_group,
 323         &visorchipset_guest_group,
 324         &visorchipset_parahotplug_group,
 325         NULL
 326 };
 327
 328 /* /sys/devices/platform/visorchipset */
 329 static struct platform_device Visorchipset_platform_device = {
 330         .name = "visorchipset",
 331         .id = -1,
 332         .dev.groups = visorchipset_dev_groups,
 333 };
 334
 335 /* Function prototypes */
 336 static void controlvm_respond(struct controlvm_message_header *msgHdr,
 337                               int response);
 338 static void controlvm_respond_chipset_init(
 339                 struct controlvm_message_header *msgHdr, int response,
 340                 enum ultra_chipset_feature features);
 341 static void controlvm_respond_physdev_changestate(
 342                 struct controlvm_message_header *msgHdr, int response,
 343                 struct spar_segment_state state);
 344
 345 static ssize_t toolaction_show(struct device *dev,
 346                                struct device_attribute *attr,
 347                                char *buf)
 348 {
 349         u8 toolAction;
 350
 351         visorchannel_read(controlvm_channel,
 352                 offsetof(struct spar_controlvm_channel_protocol,
 353                            tool_action), &toolAction, sizeof(u8));
 354         return scnprintf(buf, PAGE_SIZE, "%u\n", toolAction);
 355 }
 356
 357 static ssize_t toolaction_store(struct device *dev,
 358                                 struct device_attribute *attr,
 359                                 const char *buf, size_t count)
 360 {
 361         u8 toolAction;
 362         int ret;
 363
 364         if (kstrtou8(buf, 10, &toolAction) != 0)
 365                 return -EINVAL;
 366
 367         ret = visorchannel_write(controlvm_channel,
 368                 offsetof(struct spar_controlvm_channel_protocol, tool_action),
 369                 &toolAction, sizeof(u8));
 370
 371         if (ret)
 372                 return ret;
 373         return count;
 374 }
 375
 376 static ssize_t boottotool_show(struct device *dev,
 377                                struct device_attribute *attr,
 378                                char *buf)
 379 {
 380         struct efi_spar_indication efiSparIndication;
 381
 382         visorchannel_read(controlvm_channel,
 383                 offsetof(struct spar_controlvm_channel_protocol,
 384                         efi_spar_ind), &efiSparIndication,
 385                 sizeof(struct efi_spar_indication));
 386         return scnprintf(buf, PAGE_SIZE, "%u\n",
 387                         efiSparIndication.boot_to_tool);
 388 }
 389
 390 static ssize_t boottotool_store(struct device *dev,
 391                                 struct device_attribute *attr,
 392                                 const char *buf, size_t count)
 393 {
 394         int val, ret;
 395         struct efi_spar_indication efiSparIndication;
 396
 397         if (kstrtoint(buf, 10, &val) != 0)
 398                 return -EINVAL;
 399
 400         efiSparIndication.boot_to_tool = val;
 401         ret = visorchannel_write(controlvm_channel,
 402                         offsetof(struct spar_controlvm_channel_protocol,
 403                                 efi_spar_ind),
 404                         &(efiSparIndication),
 405                 sizeof(struct efi_spar_indication));
 406
 407         if (ret)
 408                 return ret;
 409         return count;
 410 }
 411
 412 static ssize_t error_show(struct device *dev, struct device_attribute *attr,
 413                 char *buf)
 414 {
 415         u32 error;
 416
 417         visorchannel_read(controlvm_channel, offsetof(
 418                 struct spar_controlvm_channel_protocol, installation_error),
 419                 &error, sizeof(u32));
 420         return scnprintf(buf, PAGE_SIZE, "%i\n", error);
 421 }
 422
 423 static ssize_t error_store(struct device *dev, struct device_attribute *attr,
 424                 const char *buf, size_t count)
 425 {
 426         u32 error;
 427         int ret;
 428
 429         if (kstrtou32(buf, 10, &error) != 0)
 430                 return -EINVAL;
 431
 432         ret = visorchannel_write(controlvm_channel,
 433                         offsetof(struct spar_controlvm_channel_protocol,
 434                                 installation_error),
 435                         &error, sizeof(u32));
 436         if (ret)
 437                 return ret;
 438         return count;
 439 }
 440
 441 static ssize_t textid_show(struct device *dev, struct device_attribute *attr,
 442                 char *buf)
 443 {
 444         u32 textId;
 445
 446         visorchannel_read(controlvm_channel, offsetof(
 447                 struct spar_controlvm_channel_protocol, installation_text_id),
 448                 &textId, sizeof(u32));
 449         return scnprintf(buf, PAGE_SIZE, "%i\n", textId);
 450 }
 451
 452 static ssize_t textid_store(struct device *dev, struct device_attribute *attr,
 453                 const char *buf, size_t count)
 454 {
 455         u32 textId;
 456         int ret;
 457
 458         if (kstrtou32(buf, 10, &textId) != 0)
 459                 return -EINVAL;
 460
 461         ret = visorchannel_write(controlvm_channel,
 462                         offsetof(struct spar_controlvm_channel_protocol,
 463                                 installation_text_id),
 464                         &textId, sizeof(u32));
 465         if (ret)
 466                 return ret;
 467         return count;
 468 }
 469
 470 static ssize_t remaining_steps_show(struct device *dev,
 471         struct device_attribute *attr, char *buf)
 472 {
 473         u16 remainingSteps;
 474
 475         visorchannel_read(controlvm_channel,
 476                 offsetof(struct spar_controlvm_channel_protocol,
 477                         installation_remaining_steps),
 478                 &remainingSteps,
 479                 sizeof(u16));
 480         return scnprintf(buf, PAGE_SIZE, "%hu\n", remainingSteps);
 481 }
 482
 483 static ssize_t remaining_steps_store(struct device *dev,
 484         struct device_attribute *attr, const char *buf, size_t count)
 485 {
 486         u16 remainingSteps;
 487         int ret;
 488
 489         if (kstrtou16(buf, 10, &remainingSteps) != 0)
 490                 return -EINVAL;
 491
 492         ret = visorchannel_write(controlvm_channel,
 493                         offsetof(struct spar_controlvm_channel_protocol,
 494                                 installation_remaining_steps),
 495                         &remainingSteps, sizeof(u16));
 496         if (ret)
 497                 return ret;
 498         return count;
 499 }
 500
 501 static void
 502 bus_info_clear(void *v)
 503 {
 504         struct visorchipset_bus_info *p = (struct visorchipset_bus_info *) (v);
 505
 506         kfree(p->name);
 507         p->name = NULL;
 508
 509         kfree(p->description);
 510         p->description = NULL;
 511
 512         p->state.created = 0;
 513         memset(p, 0, sizeof(struct visorchipset_bus_info));
 514 }
 515
 516 static void
 517 dev_info_clear(void *v)
 518 {
 519         struct visorchipset_device_info *p =
 520                         (struct visorchipset_device_info *)(v);
 521
 522         p->state.created = 0;
 523         memset(p, 0, sizeof(struct visorchipset_device_info));
 524 }
 525
 526 static u8
 527 check_chipset_events(void)
 528 {
 529         int i;
 530         u8 send_msg = 1;
 531         /* Check events to determine if response should be sent */
 532         for (i = 0; i < MAX_CHIPSET_EVENTS; i++)
 533                 send_msg &= chipset_events[i];
 534         return send_msg;
 535 }
 536
 537 static void
 538 clear_chipset_events(void)
 539 {
 540         int i;
 541         /* Clear chipset_events */
 542         for (i = 0; i < MAX_CHIPSET_EVENTS; i++)
 543                 chipset_events[i] = 0;
 544 }
 545
 546 void
 547 visorchipset_register_busdev_server(
 548                         struct visorchipset_busdev_notifiers *notifiers,
 549                         struct visorchipset_busdev_responders *responders,
 550                         struct ultra_vbus_deviceinfo *driver_info)
 551 {
 552         down(&notifier_lock);
 553         if (!notifiers) {
 554                 memset(&BusDev_Server_Notifiers, 0,
 555                        sizeof(BusDev_Server_Notifiers));
 556                 serverregistered = 0;   /* clear flag */
 557         } else {
 558                 BusDev_Server_Notifiers = *notifiers;
 559                 serverregistered = 1;   /* set flag */
 560         }
 561         if (responders)
 562                 *responders = BusDev_Responders;
 563         if (driver_info)
 564                 bus_device_info_init(driver_info, "chipset", "visorchipset",
 565                                    VERSION, NULL);
 566
 567         up(&notifier_lock);
 568 }
 569 EXPORT_SYMBOL_GPL(visorchipset_register_busdev_server);
 570
 571 void
 572 visorchipset_register_busdev_client(
 573                         struct visorchipset_busdev_notifiers *notifiers,
 574                         struct visorchipset_busdev_responders *responders,
 575                         struct ultra_vbus_deviceinfo *driver_info)
 576 {
 577         down(&notifier_lock);
 578         if (!notifiers) {
 579                 memset(&BusDev_Client_Notifiers, 0,
 580                        sizeof(BusDev_Client_Notifiers));
 581                 clientregistered = 0;   /* clear flag */
 582         } else {
 583                 BusDev_Client_Notifiers = *notifiers;
 584                 clientregistered = 1;   /* set flag */
 585         }
 586         if (responders)
 587                 *responders = BusDev_Responders;
 588         if (driver_info)
 589                 bus_device_info_init(driver_info, "chipset(bolts)",
 590                                      "visorchipset", VERSION, NULL);
 591         up(&notifier_lock);
 592 }
 593 EXPORT_SYMBOL_GPL(visorchipset_register_busdev_client);
 594
 595 static void
 596 cleanup_controlvm_structures(void)
 597 {
 598         struct visorchipset_bus_info *bi, *tmp_bi;
 599         struct visorchipset_device_info *di, *tmp_di;
 600
 601         list_for_each_entry_safe(bi, tmp_bi, &bus_info_list, entry) {
 602                 bus_info_clear(bi);
 603                 list_del(&bi->entry);
 604                 kfree(bi);
 605         }
 606
 607         list_for_each_entry_safe(di, tmp_di, &dev_info_list, entry) {
 608                 dev_info_clear(di);
 609                 list_del(&di->entry);
 610                 kfree(di);
 611         }
 612 }
 613
 614 static void
 615 chipset_init(struct controlvm_message *inmsg)
 616 {
 617         static int chipset_inited;
 618         enum ultra_chipset_feature features = 0;
 619         int rc = CONTROLVM_RESP_SUCCESS;
 620
 621         POSTCODE_LINUX_2(CHIPSET_INIT_ENTRY_PC, POSTCODE_SEVERITY_INFO);
 622         if (chipset_inited) {
 623                 rc = -CONTROLVM_RESP_ERROR_ALREADY_DONE;
 624                 goto cleanup;
 625         }
 626         chipset_inited = 1;
 627         POSTCODE_LINUX_2(CHIPSET_INIT_EXIT_PC, POSTCODE_SEVERITY_INFO);
 628
 629         /* Set features to indicate we support parahotplug (if Command
 630          * also supports it). */
 631         features =
 632             inmsg->cmd.init_chipset.
 633             features & ULTRA_CHIPSET_FEATURE_PARA_HOTPLUG;
 634
 635         /* Set the "reply" bit so Command knows this is a
 636          * features-aware driver. */
 637         features |= ULTRA_CHIPSET_FEATURE_REPLY;
 638
 639 cleanup:
 640         if (rc < 0)
 641                 cleanup_controlvm_structures();
 642         if (inmsg->hdr.flags.response_expected)
 643                 controlvm_respond_chipset_init(&inmsg->hdr, rc, features);
 644 }
 645
 646 static void
 647 controlvm_init_response(struct controlvm_message *msg,
 648                         struct controlvm_message_header *msgHdr, int response)
 649 {
 650         memset(msg, 0, sizeof(struct controlvm_message));
 651         memcpy(&msg->hdr, msgHdr, sizeof(struct controlvm_message_header));
 652         msg->hdr.payload_bytes = 0;
 653         msg->hdr.payload_vm_offset = 0;
 654         msg->hdr.payload_max_bytes = 0;
 655         if (response < 0) {
 656                 msg->hdr.flags.failed = 1;
 657                 msg->hdr.completion_status = (u32) (-response);
 658         }
 659 }
 660
 661 static void
 662 controlvm_respond(struct controlvm_message_header *msgHdr, int response)
 663 {
 664         struct controlvm_message outmsg;
 665
 666         controlvm_init_response(&outmsg, msgHdr, response);
 667         /* For DiagPool channel DEVICE_CHANGESTATE, we need to send
 668         * back the deviceChangeState structure in the packet. */
 669         if (msgHdr->id == CONTROLVM_DEVICE_CHANGESTATE &&
 670             g_devicechangestate_packet.device_change_state.bus_no ==
 671             g_diagpool_bus_no &&
 672             g_devicechangestate_packet.device_change_state.dev_no ==
 673             g_diagpool_dev_no)
 674                 outmsg.cmd = g_devicechangestate_packet;
 675         if (outmsg.hdr.flags.test_message == 1)
 676                 return;
 677
 678         if (!visorchannel_signalinsert(controlvm_channel,
 679                                        CONTROLVM_QUEUE_REQUEST, &outmsg)) {
 680                 return;
 681         }
 682 }
 683
 684 static void
 685 controlvm_respond_chipset_init(struct controlvm_message_header *msgHdr,
 686                                int response,
 687                                enum ultra_chipset_feature features)
 688 {
 689         struct controlvm_message outmsg;
 690
 691         controlvm_init_response(&outmsg, msgHdr, response);
 692         outmsg.cmd.init_chipset.features = features;
 693         if (!visorchannel_signalinsert(controlvm_channel,
 694                                        CONTROLVM_QUEUE_REQUEST, &outmsg)) {
 695                 return;
 696         }
 697 }
 698
 699 static void controlvm_respond_physdev_changestate(
 700                 struct controlvm_message_header *msgHdr, int response,
 701                 struct spar_segment_state state)
 702 {
 703         struct controlvm_message outmsg;
 704
 705         controlvm_init_response(&outmsg, msgHdr, response);
 706         outmsg.cmd.device_change_state.state = state;
 707         outmsg.cmd.device_change_state.flags.phys_device = 1;
 708         if (!visorchannel_signalinsert(controlvm_channel,
 709                                        CONTROLVM_QUEUE_REQUEST, &outmsg)) {
 710                 return;
 711         }
 712 }
 713
 714 void
 715 visorchipset_save_message(struct controlvm_message *msg,
 716                           enum crash_obj_type type)
 717 {
 718         u32 crash_msg_offset;
 719         u16 crash_msg_count;
 720
 721         /* get saved message count */
 722         if (visorchannel_read(controlvm_channel,
 723                               offsetof(struct spar_controlvm_channel_protocol,
 724                                        saved_crash_message_count),
 725                               &crash_msg_count, sizeof(u16)) < 0) {
 726                 POSTCODE_LINUX_2(CRASH_DEV_CTRL_RD_FAILURE_PC,
 727                                  POSTCODE_SEVERITY_ERR);
 728                 return;
 729         }
 730
 731         if (crash_msg_count != CONTROLVM_CRASHMSG_MAX) {
 732                 POSTCODE_LINUX_3(CRASH_DEV_COUNT_FAILURE_PC,
 733                                  crash_msg_count,
 734                                  POSTCODE_SEVERITY_ERR);
 735                 return;
 736         }
 737
 738         /* get saved crash message offset */
 739         if (visorchannel_read(controlvm_channel,
 740                               offsetof(struct spar_controlvm_channel_protocol,
 741                                        saved_crash_message_offset),
 742                               &crash_msg_offset, sizeof(u32)) < 0) {
 743                 POSTCODE_LINUX_2(CRASH_DEV_CTRL_RD_FAILURE_PC,
 744                                  POSTCODE_SEVERITY_ERR);
 745                 return;
 746         }
 747
 748         if (type == CRASH_BUS) {
 749                 if (visorchannel_write(controlvm_channel,
 750                                        crash_msg_offset,
 751                                        msg,
 752                                        sizeof(struct controlvm_message)) < 0) {
 753                         POSTCODE_LINUX_2(SAVE_MSG_BUS_FAILURE_PC,
 754                                          POSTCODE_SEVERITY_ERR);
 755                         return;
 756                 }
 757         } else {
 758                 if (visorchannel_write(controlvm_channel,
 759                                        crash_msg_offset +
 760                                        sizeof(struct controlvm_message), msg,
 761                                        sizeof(struct controlvm_message)) < 0) {
 762                         POSTCODE_LINUX_2(SAVE_MSG_DEV_FAILURE_PC,
 763                                          POSTCODE_SEVERITY_ERR);
 764                         return;
 765                 }
 766         }
 767 }
 768 EXPORT_SYMBOL_GPL(visorchipset_save_message);
 769
 770 static void
 771 bus_responder(enum controlvm_id cmd_id, ulong bus_no, int response)
 772 {
 773         struct visorchipset_bus_info *p = NULL;
 774         BOOL need_clear = FALSE;
 775
 776         p = findbus(&bus_info_list, bus_no);
 777         if (!p)
 778                 return;
 779
 780         if (response < 0) {
 781                 if ((cmd_id == CONTROLVM_BUS_CREATE) &&
 782                     (response != (-CONTROLVM_RESP_ERROR_ALREADY_DONE)))
 783                         /* undo the row we just created... */
 784                         delbusdevices(&dev_info_list, bus_no);
 785         } else {
 786                 if (cmd_id == CONTROLVM_BUS_CREATE)
 787                         p->state.created = 1;
 788                 if (cmd_id == CONTROLVM_BUS_DESTROY)
 789                         need_clear = TRUE;
 790         }
 791
 792         if (p->pending_msg_hdr.id == CONTROLVM_INVALID)
 793                 return;         /* no controlvm response needed */
 794         if (p->pending_msg_hdr.id != (u32)cmd_id)
 795                 return;
 796         controlvm_respond(&p->pending_msg_hdr, response);
 797         p->pending_msg_hdr.id = CONTROLVM_INVALID;
 798         if (need_clear) {
 799                 bus_info_clear(p);
 800                 delbusdevices(&dev_info_list, bus_no);
 801         }
 802 }
 803
 804 static void
 805 device_changestate_responder(enum controlvm_id cmd_id,
 806                              ulong bus_no, ulong dev_no, int response,
 807                              struct spar_segment_state response_state)
 808 {
 809         struct visorchipset_device_info *p = NULL;
 810         struct controlvm_message outmsg;
 811
 812         p = finddevice(&dev_info_list, bus_no, dev_no);
 813         if (!p)
 814                 return;
 815         if (p->pending_msg_hdr.id == CONTROLVM_INVALID)
 816                 return;         /* no controlvm response needed */
 817         if (p->pending_msg_hdr.id != cmd_id)
 818                 return;
 819
 820         controlvm_init_response(&outmsg, &p->pending_msg_hdr, response);
 821
 822         outmsg.cmd.device_change_state.bus_no = bus_no;
 823         outmsg.cmd.device_change_state.dev_no = dev_no;
 824         outmsg.cmd.device_change_state.state = response_state;
 825
 826         if (!visorchannel_signalinsert(controlvm_channel,
 827                                        CONTROLVM_QUEUE_REQUEST, &outmsg))
 828                 return;
 829
 830         p->pending_msg_hdr.id = CONTROLVM_INVALID;
 831 }
 832
 833 static void
 834 device_responder(enum controlvm_id cmd_id, ulong bus_no, ulong dev_no,
 835                  int response)
 836 {
 837         struct visorchipset_device_info *p = NULL;
 838         BOOL need_clear = FALSE;
 839
 840         p = finddevice(&dev_info_list, bus_no, dev_no);
 841         if (!p)
 842                 return;
 843         if (response >= 0) {
 844                 if (cmd_id == CONTROLVM_DEVICE_CREATE)
 845                         p->state.created = 1;
 846                 if (cmd_id == CONTROLVM_DEVICE_DESTROY)
 847                         need_clear = TRUE;
 848         }
 849
 850         if (p->pending_msg_hdr.id == CONTROLVM_INVALID)
 851                 return;         /* no controlvm response needed */
 852
 853         if (p->pending_msg_hdr.id != (u32)cmd_id)
 854                 return;
 855
 856         controlvm_respond(&p->pending_msg_hdr, response);
 857         p->pending_msg_hdr.id = CONTROLVM_INVALID;
 858         if (need_clear)
 859                 dev_info_clear(p);
 860 }
 861
 862 static void
 863 bus_epilog(u32 bus_no,
 864            u32 cmd, struct controlvm_message_header *msg_hdr,
 865            int response, BOOL need_response)
 866 {
 867         BOOL notified = FALSE;
 868
 869         struct visorchipset_bus_info *bus_info = findbus(&bus_info_list,
 870                                                          bus_no);
 871
 872         if (!bus_info)
 873                 return;
 874
 875         if (need_response) {
 876                 memcpy(&bus_info->pending_msg_hdr, msg_hdr,
 877                        sizeof(struct controlvm_message_header));
 878         } else
 879                 bus_info->pending_msg_hdr.id = CONTROLVM_INVALID;
 880
 881         down(&notifier_lock);
 882         if (response == CONTROLVM_RESP_SUCCESS) {
 883                 switch (cmd) {
 884                 case CONTROLVM_BUS_CREATE:
 885                         /* We can't tell from the bus_create
 886                         * information which of our 2 bus flavors the
 887                         * devices on this bus will ultimately end up.
 888                         * FORTUNATELY, it turns out it is harmless to
 889                         * send the bus_create to both of them.  We can
 890                         * narrow things down a little bit, though,
 891                         * because we know: - BusDev_Server can handle
 892                         * either server or client devices
 893                         * - BusDev_Client can handle ONLY client
 894                         * devices */
 895                         if (BusDev_Server_Notifiers.bus_create) {
 896                                 (*BusDev_Server_Notifiers.bus_create) (bus_no);
 897                                 notified = TRUE;
 898                         }
 899                         if ((!bus_info->flags.server) /*client */ &&
 900                             BusDev_Client_Notifiers.bus_create) {
 901                                 (*BusDev_Client_Notifiers.bus_create) (bus_no);
 902                                 notified = TRUE;
 903                         }
 904                         break;
 905                 case CONTROLVM_BUS_DESTROY:
 906                         if (BusDev_Server_Notifiers.bus_destroy) {
 907                                 (*BusDev_Server_Notifiers.bus_destroy) (bus_no);
 908                                 notified = TRUE;
 909                         }
 910                         if ((!bus_info->flags.server) /*client */ &&
 911                             BusDev_Client_Notifiers.bus_destroy) {
 912                                 (*BusDev_Client_Notifiers.bus_destroy) (bus_no);
 913                                 notified = TRUE;
 914                         }
 915                         break;
 916                 }
 917         }
 918         if (notified)
 919                 /* The callback function just called above is responsible
 920                  * for calling the appropriate visorchipset_busdev_responders
 921                  * function, which will call bus_responder()
 922                  */
 923                 ;
 924         else
 925                 bus_responder(cmd, bus_no, response);
 926         up(&notifier_lock);
 927 }
 928
 929 static void
 930 device_epilog(u32 bus_no, u32 dev_no, struct spar_segment_state state, u32 cmd,
 931               struct controlvm_message_header *msg_hdr, int response,
 932               BOOL need_response, BOOL for_visorbus)
 933 {
 934         struct visorchipset_busdev_notifiers *notifiers = NULL;
 935         BOOL notified = FALSE;
 936
 937         struct visorchipset_device_info *dev_info =
 938                 finddevice(&dev_info_list, bus_no, dev_no);
 939         char *envp[] = {
 940                 "SPARSP_DIAGPOOL_PAUSED_STATE = 1",
 941                 NULL
 942         };
 943
 944         if (!dev_info)
 945                 return;
 946
 947         if (for_visorbus)
 948                 notifiers = &BusDev_Server_Notifiers;
 949         else
 950                 notifiers = &BusDev_Client_Notifiers;
 951         if (need_response) {
 952                 memcpy(&dev_info->pending_msg_hdr, msg_hdr,
 953                        sizeof(struct controlvm_message_header));
 954         } else
 955                 dev_info->pending_msg_hdr.id = CONTROLVM_INVALID;
 956
 957         down(&notifier_lock);
 958         if (response >= 0) {
 959                 switch (cmd) {
 960                 case CONTROLVM_DEVICE_CREATE:
 961                         if (notifiers->device_create) {
 962                                 (*notifiers->device_create) (bus_no, dev_no);
 963                                 notified = TRUE;
 964                         }
 965                         break;
 966                 case CONTROLVM_DEVICE_CHANGESTATE:
 967                         /* ServerReady / ServerRunning / SegmentStateRunning */
 968                         if (state.alive == segment_state_running.alive &&
 969                             state.operating ==
 970                                 segment_state_running.operating) {
 971                                 if (notifiers->device_resume) {
 972                                         (*notifiers->device_resume) (bus_no,
 973                                                                      dev_no);
 974                                         notified = TRUE;
 975                                 }
 976                         }
 977                         /* ServerNotReady / ServerLost / SegmentStateStandby */
 978                         else if (state.alive == segment_state_standby.alive &&
 979                                  state.operating ==
 980                                  segment_state_standby.operating) {
 981                                 /* technically this is standby case
 982                                  * where server is lost
 983                                  */
 984                                 if (notifiers->device_pause) {
 985                                         (*notifiers->device_pause) (bus_no,
 986                                                                     dev_no);
 987                                         notified = TRUE;
 988                                 }
 989                         } else if (state.alive == segment_state_paused.alive &&
 990                                    state.operating ==
 991                                    segment_state_paused.operating) {
 992                                 /* this is lite pause where channel is
 993                                  * still valid just 'pause' of it
 994                                  */
 995                                 if (bus_no == g_diagpool_bus_no &&
 996                                     dev_no == g_diagpool_dev_no) {
 997                                         /* this will trigger the
 998                                          * diag_shutdown.sh script in
 999                                          * the visorchipset hotplug */
1000                                         kobject_uevent_env
1001                                             (&Visorchipset_platform_device.dev.
1002                                              kobj, KOBJ_ONLINE, envp);
1003                                 }
1004                         }
1005                         break;
1006                 case CONTROLVM_DEVICE_DESTROY:
1007                         if (notifiers->device_destroy) {
1008                                 (*notifiers->device_destroy) (bus_no, dev_no);
1009                                 notified = TRUE;
1010                         }
1011                         break;
1012                 }
1013         }
1014         if (notified)
1015                 /* The callback function just called above is responsible
1016                  * for calling the appropriate visorchipset_busdev_responders
1017                  * function, which will call device_responder()
1018                  */
1019                 ;
1020         else
1021                 device_responder(cmd, bus_no, dev_no, response);
1022         up(&notifier_lock);
1023 }
1024
1025 static void
1026 bus_create(struct controlvm_message *inmsg)
1027 {
1028         struct controlvm_message_packet *cmd = &inmsg->cmd;
1029         ulong busNo = cmd->create_bus.bus_no;
1030         int rc = CONTROLVM_RESP_SUCCESS;
1031         struct visorchipset_bus_info *pBusInfo = NULL;
1032
1033
1034         pBusInfo = findbus(&bus_info_list, busNo);
1035         if (pBusInfo && (pBusInfo->state.created == 1)) {
1036                 POSTCODE_LINUX_3(BUS_CREATE_FAILURE_PC, busNo,
1037                                  POSTCODE_SEVERITY_ERR);
1038                 rc = -CONTROLVM_RESP_ERROR_ALREADY_DONE;
1039                 goto Away;
1040         }
1041         pBusInfo = kzalloc(sizeof(struct visorchipset_bus_info), GFP_KERNEL);
1042         if (!pBusInfo) {
1043                 POSTCODE_LINUX_3(BUS_CREATE_FAILURE_PC, busNo,
1044                                  POSTCODE_SEVERITY_ERR);
1045                 rc = -CONTROLVM_RESP_ERROR_KMALLOC_FAILED;
1046                 goto Away;
1047         }
1048
1049         INIT_LIST_HEAD(&pBusInfo->entry);
1050         pBusInfo->bus_no = busNo;
1051         pBusInfo->dev_no = cmd->create_bus.dev_count;
1052
1053         POSTCODE_LINUX_3(BUS_CREATE_ENTRY_PC, busNo, POSTCODE_SEVERITY_INFO);
1054
1055         if (inmsg->hdr.flags.test_message == 1)
1056                 pBusInfo->chan_info.addr_type = ADDRTYPE_LOCALTEST;
1057         else
1058                 pBusInfo->chan_info.addr_type = ADDRTYPE_LOCALPHYSICAL;
1059
1060         pBusInfo->flags.server = inmsg->hdr.flags.server;
1061         pBusInfo->chan_info.channel_addr = cmd->create_bus.channel_addr;
1062         pBusInfo->chan_info.n_channel_bytes = cmd->create_bus.channel_bytes;
1063         pBusInfo->chan_info.channel_type_uuid =
1064                         cmd->create_bus.bus_data_type_uuid;
1065         pBusInfo->chan_info.channel_inst_uuid = cmd->create_bus.bus_inst_uuid;
1066
1067         list_add(&pBusInfo->entry, &bus_info_list);
1068
1069         POSTCODE_LINUX_3(BUS_CREATE_EXIT_PC, busNo, POSTCODE_SEVERITY_INFO);
1070
1071 Away:
1072         bus_epilog(busNo, CONTROLVM_BUS_CREATE, &inmsg->hdr,
1073                    rc, inmsg->hdr.flags.response_expected == 1);
1074 }
1075
1076 static void
1077 bus_destroy(struct controlvm_message *inmsg)
1078 {
1079         struct controlvm_message_packet *cmd = &inmsg->cmd;
1080         ulong busNo = cmd->destroy_bus.bus_no;
1081         struct visorchipset_bus_info *pBusInfo;
1082         int rc = CONTROLVM_RESP_SUCCESS;
1083
1084         pBusInfo = findbus(&bus_info_list, busNo);
1085         if (!pBusInfo) {
1086                 rc = -CONTROLVM_RESP_ERROR_BUS_INVALID;
1087                 goto Away;
1088         }
1089         if (pBusInfo->state.created == 0) {
1090                 rc = -CONTROLVM_RESP_ERROR_ALREADY_DONE;
1091                 goto Away;
1092         }
1093
1094 Away:
1095         bus_epilog(busNo, CONTROLVM_BUS_DESTROY, &inmsg->hdr,
1096                    rc, inmsg->hdr.flags.response_expected == 1);
1097 }
1098
1099 static void
1100 bus_configure(struct controlvm_message *inmsg,
1101               struct parser_context *parser_ctx)
1102 {
1103         struct controlvm_message_packet *cmd = &inmsg->cmd;
1104         ulong busNo = cmd->configure_bus.bus_no;
1105         struct visorchipset_bus_info *pBusInfo = NULL;
1106         int rc = CONTROLVM_RESP_SUCCESS;
1107         char s[99];
1108
1109         busNo = cmd->configure_bus.bus_no;
1110         POSTCODE_LINUX_3(BUS_CONFIGURE_ENTRY_PC, busNo, POSTCODE_SEVERITY_INFO);
1111
1112         pBusInfo = findbus(&bus_info_list, busNo);
1113         if (!pBusInfo) {
1114                 POSTCODE_LINUX_3(BUS_CONFIGURE_FAILURE_PC, busNo,
1115                                  POSTCODE_SEVERITY_ERR);
1116                 rc = -CONTROLVM_RESP_ERROR_BUS_INVALID;
1117                 goto Away;
1118         }
1119         if (pBusInfo->state.created == 0) {
1120                 POSTCODE_LINUX_3(BUS_CONFIGURE_FAILURE_PC, busNo,
1121                                  POSTCODE_SEVERITY_ERR);
1122                 rc = -CONTROLVM_RESP_ERROR_BUS_INVALID;
1123                 goto Away;
1124         }
1125         /* TBD - add this check to other commands also... */
1126         if (pBusInfo->pending_msg_hdr.id != CONTROLVM_INVALID) {
1127                 POSTCODE_LINUX_3(BUS_CONFIGURE_FAILURE_PC, busNo,
1128                                  POSTCODE_SEVERITY_ERR);
1129                 rc = -CONTROLVM_RESP_ERROR_MESSAGE_ID_INVALID_FOR_CLIENT;
1130                 goto Away;
1131         }
1132
1133         pBusInfo->partition_handle = cmd->configure_bus.guest_handle;
1134         pBusInfo->partition_uuid = parser_id_get(parser_ctx);
1135         parser_param_start(parser_ctx, PARSERSTRING_NAME);
1136         pBusInfo->name = parser_string_get(parser_ctx);
1137
1138         visorchannel_uuid_id(&pBusInfo->partition_uuid, s);
1139         POSTCODE_LINUX_3(BUS_CONFIGURE_EXIT_PC, busNo, POSTCODE_SEVERITY_INFO);
1140 Away:
1141         bus_epilog(busNo, CONTROLVM_BUS_CONFIGURE, &inmsg->hdr,
1142                    rc, inmsg->hdr.flags.response_expected == 1);
1143 }
1144
1145 static void
1146 my_device_create(struct controlvm_message *inmsg)
1147 {
1148         struct controlvm_message_packet *cmd = &inmsg->cmd;
1149         ulong busNo = cmd->create_device.bus_no;
1150         ulong devNo = cmd->create_device.dev_no;
1151         struct visorchipset_device_info *pDevInfo = NULL;
1152         struct visorchipset_bus_info *pBusInfo = NULL;
1153         int rc = CONTROLVM_RESP_SUCCESS;
1154
1155         pDevInfo = finddevice(&dev_info_list, busNo, devNo);
1156         if (pDevInfo && (pDevInfo->state.created == 1)) {
1157                 POSTCODE_LINUX_4(DEVICE_CREATE_FAILURE_PC, devNo, busNo,
1158                                  POSTCODE_SEVERITY_ERR);
1159                 rc = -CONTROLVM_RESP_ERROR_ALREADY_DONE;
1160                 goto Away;
1161         }
1162         pBusInfo = findbus(&bus_info_list, busNo);
1163         if (!pBusInfo) {
1164                 POSTCODE_LINUX_4(DEVICE_CREATE_FAILURE_PC, devNo, busNo,
1165                                  POSTCODE_SEVERITY_ERR);
1166                 rc = -CONTROLVM_RESP_ERROR_BUS_INVALID;
1167                 goto Away;
1168         }
1169         if (pBusInfo->state.created == 0) {
1170                 POSTCODE_LINUX_4(DEVICE_CREATE_FAILURE_PC, devNo, busNo,
1171                                  POSTCODE_SEVERITY_ERR);
1172                 rc = -CONTROLVM_RESP_ERROR_BUS_INVALID;
1173                 goto Away;
1174         }
1175         pDevInfo = kzalloc(sizeof(struct visorchipset_device_info), GFP_KERNEL);
1176         if (!pDevInfo) {
1177                 POSTCODE_LINUX_4(DEVICE_CREATE_FAILURE_PC, devNo, busNo,
1178                                  POSTCODE_SEVERITY_ERR);
1179                 rc = -CONTROLVM_RESP_ERROR_KMALLOC_FAILED;
1180                 goto Away;
1181         }
1182
1183         INIT_LIST_HEAD(&pDevInfo->entry);
1184         pDevInfo->bus_no = busNo;
1185         pDevInfo->dev_no = devNo;
1186         pDevInfo->dev_inst_uuid = cmd->create_device.dev_inst_uuid;
1187         POSTCODE_LINUX_4(DEVICE_CREATE_ENTRY_PC, devNo, busNo,
1188                          POSTCODE_SEVERITY_INFO);
1189
1190         if (inmsg->hdr.flags.test_message == 1)
1191                 pDevInfo->chan_info.addr_type = ADDRTYPE_LOCALTEST;
1192         else
1193                 pDevInfo->chan_info.addr_type = ADDRTYPE_LOCALPHYSICAL;
1194         pDevInfo->chan_info.channel_addr = cmd->create_device.channel_addr;
1195         pDevInfo->chan_info.n_channel_bytes = cmd->create_device.channel_bytes;
1196         pDevInfo->chan_info.channel_type_uuid =
1197                         cmd->create_device.data_type_uuid;
1198         pDevInfo->chan_info.intr = cmd->create_device.intr;
1199         list_add(&pDevInfo->entry, &dev_info_list);
1200         POSTCODE_LINUX_4(DEVICE_CREATE_EXIT_PC, devNo, busNo,
1201                          POSTCODE_SEVERITY_INFO);
1202 Away:
1203         /* get the bus and devNo for DiagPool channel */
1204         if (pDevInfo &&
1205             is_diagpool_channel(pDevInfo->chan_info.channel_type_uuid)) {
1206                 g_diagpool_bus_no = busNo;
1207                 g_diagpool_dev_no = devNo;
1208         }
1209         device_epilog(busNo, devNo, segment_state_running,
1210                       CONTROLVM_DEVICE_CREATE, &inmsg->hdr, rc,
1211                       inmsg->hdr.flags.response_expected == 1,
1212                       FOR_VISORBUS(pDevInfo->chan_info.channel_type_uuid));
1213 }
1214
1215 static void
1216 my_device_changestate(struct controlvm_message *inmsg)
1217 {
1218         struct controlvm_message_packet *cmd = &inmsg->cmd;
1219         ulong busNo = cmd->device_change_state.bus_no;
1220         ulong devNo = cmd->device_change_state.dev_no;
1221         struct spar_segment_state state = cmd->device_change_state.state;
1222         struct visorchipset_device_info *pDevInfo = NULL;
1223         int rc = CONTROLVM_RESP_SUCCESS;
1224
1225         pDevInfo = finddevice(&dev_info_list, busNo, devNo);
1226         if (!pDevInfo) {
1227                 POSTCODE_LINUX_4(DEVICE_CHANGESTATE_FAILURE_PC, devNo, busNo,
1228                                  POSTCODE_SEVERITY_ERR);
1229                 rc = -CONTROLVM_RESP_ERROR_DEVICE_INVALID;
1230                 goto Away;
1231         }
1232         if (pDevInfo->state.created == 0) {
1233                 POSTCODE_LINUX_4(DEVICE_CHANGESTATE_FAILURE_PC, devNo, busNo,
1234                                  POSTCODE_SEVERITY_ERR);
1235                 rc = -CONTROLVM_RESP_ERROR_DEVICE_INVALID;
1236         }
1237 Away:
1238         if ((rc >= CONTROLVM_RESP_SUCCESS) && pDevInfo)
1239                 device_epilog(busNo, devNo, state, CONTROLVM_DEVICE_CHANGESTATE,
1240                               &inmsg->hdr, rc,
1241                               inmsg->hdr.flags.response_expected == 1,
1242                               FOR_VISORBUS(
1243                                         pDevInfo->chan_info.channel_type_uuid));
1244 }
1245
1246 static void
1247 my_device_destroy(struct controlvm_message *inmsg)
1248 {
1249         struct controlvm_message_packet *cmd = &inmsg->cmd;
1250         ulong busNo = cmd->destroy_device.bus_no;
1251         ulong devNo = cmd->destroy_device.dev_no;
1252         struct visorchipset_device_info *pDevInfo = NULL;
1253         int rc = CONTROLVM_RESP_SUCCESS;
1254
1255         pDevInfo = finddevice(&dev_info_list, busNo, devNo);
1256         if (!pDevInfo) {
1257                 rc = -CONTROLVM_RESP_ERROR_DEVICE_INVALID;
1258                 goto Away;
1259         }
1260         if (pDevInfo->state.created == 0) {
1261                 rc = -CONTROLVM_RESP_ERROR_ALREADY_DONE;
1262         }
1263
1264 Away:
1265         if ((rc >= CONTROLVM_RESP_SUCCESS) && pDevInfo)
1266                 device_epilog(busNo, devNo, segment_state_running,
1267                               CONTROLVM_DEVICE_DESTROY, &inmsg->hdr, rc,
1268                               inmsg->hdr.flags.response_expected == 1,
1269                               FOR_VISORBUS(
1270                                         pDevInfo->chan_info.channel_type_uuid));
1271 }
1272
1273 /* When provided with the physical address of the controlvm channel
1274  * (phys_addr), the offset to the payload area we need to manage
1275  * (offset), and the size of this payload area (bytes), fills in the
1276  * controlvm_payload_info struct.  Returns TRUE for success or FALSE
1277  * for failure.
1278  */
1279 static int
1280 initialize_controlvm_payload_info(HOSTADDRESS phys_addr, u64 offset, u32 bytes,
1281                                   struct controlvm_payload_info *info)
1282 {
1283         u8 __iomem *payload = NULL;
1284         int rc = CONTROLVM_RESP_SUCCESS;
1285
1286         if (!info) {
1287                 rc = -CONTROLVM_RESP_ERROR_PAYLOAD_INVALID;
1288                 goto Away;
1289         }
1290         memset(info, 0, sizeof(struct controlvm_payload_info));
1291         if ((offset == 0) || (bytes == 0)) {
1292                 rc = -CONTROLVM_RESP_ERROR_PAYLOAD_INVALID;
1293                 goto Away;
1294         }
1295         payload = ioremap_cache(phys_addr + offset, bytes);
1296         if (!payload) {
1297                 rc = -CONTROLVM_RESP_ERROR_IOREMAP_FAILED;
1298                 goto Away;
1299         }
1300
1301         info->offset = offset;
1302         info->bytes = bytes;
1303         info->ptr = payload;
1304
1305 Away:
1306         if (rc < 0) {
1307                 if (payload != NULL) {
1308                         iounmap(payload);
1309                         payload = NULL;
1310                 }
1311         }
1312         return rc;
1313 }
1314
1315 static void
1316 destroy_controlvm_payload_info(struct controlvm_payload_info *info)
1317 {
1318         if (info->ptr != NULL) {
1319                 iounmap(info->ptr);
1320                 info->ptr = NULL;
1321         }
1322         memset(info, 0, sizeof(struct controlvm_payload_info));
1323 }
1324
1325 static void
1326 initialize_controlvm_payload(void)
1327 {
1328         HOSTADDRESS phys_addr = visorchannel_get_physaddr(controlvm_channel);
1329         u64 payloadOffset = 0;
1330         u32 payloadBytes = 0;
1331
1332         if (visorchannel_read(controlvm_channel,
1333                               offsetof(struct spar_controlvm_channel_protocol,
1334                                        request_payload_offset),
1335                               &payloadOffset, sizeof(payloadOffset)) < 0) {
1336                 POSTCODE_LINUX_2(CONTROLVM_INIT_FAILURE_PC,
1337                                  POSTCODE_SEVERITY_ERR);
1338                 return;
1339         }
1340         if (visorchannel_read(controlvm_channel,
1341                               offsetof(struct spar_controlvm_channel_protocol,
1342                                        request_payload_bytes),
1343                               &payloadBytes, sizeof(payloadBytes)) < 0) {
1344                 POSTCODE_LINUX_2(CONTROLVM_INIT_FAILURE_PC,
1345                                  POSTCODE_SEVERITY_ERR);
1346                 return;
1347         }
1348         initialize_controlvm_payload_info(phys_addr,
1349                                           payloadOffset, payloadBytes,
1350                                           &controlvm_payload_info);
1351 }
1352
1353 /*  Send ACTION=online for DEVPATH=/sys/devices/platform/visorchipset.
1354  *  Returns CONTROLVM_RESP_xxx code.
1355  */
1356 int
1357 visorchipset_chipset_ready(void)
1358 {
1359         kobject_uevent(&Visorchipset_platform_device.dev.kobj, KOBJ_ONLINE);
1360         return CONTROLVM_RESP_SUCCESS;
1361 }
1362 EXPORT_SYMBOL_GPL(visorchipset_chipset_ready);
1363
1364 int
1365 visorchipset_chipset_selftest(void)
1366 {
1367         char env_selftest[20];
1368         char *envp[] = { env_selftest, NULL };
1369
1370         sprintf(env_selftest, "SPARSP_SELFTEST=%d", 1);
1371         kobject_uevent_env(&Visorchipset_platform_device.dev.kobj, KOBJ_CHANGE,
1372                            envp);
1373         return CONTROLVM_RESP_SUCCESS;
1374 }
1375 EXPORT_SYMBOL_GPL(visorchipset_chipset_selftest);
1376
1377 /*  Send ACTION=offline for DEVPATH=/sys/devices/platform/visorchipset.
1378  *  Returns CONTROLVM_RESP_xxx code.
1379  */
1380 int
1381 visorchipset_chipset_notready(void)
1382 {
1383         kobject_uevent(&Visorchipset_platform_device.dev.kobj, KOBJ_OFFLINE);
1384         return CONTROLVM_RESP_SUCCESS;
1385 }
1386 EXPORT_SYMBOL_GPL(visorchipset_chipset_notready);
1387
1388 static void
1389 chipset_ready(struct controlvm_message_header *msgHdr)
1390 {
1391         int rc = visorchipset_chipset_ready();
1392
1393         if (rc != CONTROLVM_RESP_SUCCESS)
1394                 rc = -rc;
1395         if (msgHdr->flags.response_expected && !visorchipset_holdchipsetready)
1396                 controlvm_respond(msgHdr, rc);
1397         if (msgHdr->flags.response_expected && visorchipset_holdchipsetready) {
1398                 /* Send CHIPSET_READY response when all modules have been loaded
1399                  * and disks mounted for the partition
1400                  */
1401                 g_chipset_msg_hdr = *msgHdr;
1402         }
1403 }
1404
1405 static void
1406 chipset_selftest(struct controlvm_message_header *msgHdr)
1407 {
1408         int rc = visorchipset_chipset_selftest();
1409
1410         if (rc != CONTROLVM_RESP_SUCCESS)
1411                 rc = -rc;
1412         if (msgHdr->flags.response_expected)
1413                 controlvm_respond(msgHdr, rc);
1414 }
1415
1416 static void
1417 chipset_notready(struct controlvm_message_header *msgHdr)
1418 {
1419         int rc = visorchipset_chipset_notready();
1420
1421         if (rc != CONTROLVM_RESP_SUCCESS)
1422                 rc = -rc;
1423         if (msgHdr->flags.response_expected)
1424                 controlvm_respond(msgHdr, rc);
1425 }
1426
1427 /* This is your "one-stop" shop for grabbing the next message from the
1428  * CONTROLVM_QUEUE_EVENT queue in the controlvm channel.
1429  */
1430 static BOOL
1431 read_controlvm_event(struct controlvm_message *msg)
1432 {
1433         if (visorchannel_signalremove(controlvm_channel,
1434                                       CONTROLVM_QUEUE_EVENT, msg)) {
1435                 /* got a message */
1436                 if (msg->hdr.flags.test_message == 1)
1437                         return FALSE;
1438                 return TRUE;
1439         }
1440         return FALSE;
1441 }
1442
1443 /*
1444  * The general parahotplug flow works as follows.  The visorchipset
1445  * driver receives a DEVICE_CHANGESTATE message from Command
1446  * specifying a physical device to enable or disable.  The CONTROLVM
1447  * message handler calls parahotplug_process_message, which then adds
1448  * the message to a global list and kicks off a udev event which
1449  * causes a user level script to enable or disable the specified
1450  * device.  The udev script then writes to
1451  * /proc/visorchipset/parahotplug, which causes parahotplug_proc_write
1452  * to get called, at which point the appropriate CONTROLVM message is
1453  * retrieved from the list and responded to.
1454  */
1455
1456 #define PARAHOTPLUG_TIMEOUT_MS 2000
1457
1458 /*
1459  * Generate unique int to match an outstanding CONTROLVM message with a
1460  * udev script /proc response
1461  */
1462 static int
1463 parahotplug_next_id(void)
1464 {
1465         static atomic_t id = ATOMIC_INIT(0);
1466
1467         return atomic_inc_return(&id);
1468 }
1469
1470 /*
1471  * Returns the time (in jiffies) when a CONTROLVM message on the list
1472  * should expire -- PARAHOTPLUG_TIMEOUT_MS in the future
1473  */
1474 static unsigned long
1475 parahotplug_next_expiration(void)
1476 {
1477         return jiffies + msecs_to_jiffies(PARAHOTPLUG_TIMEOUT_MS);
1478 }
1479
1480 /*
1481  * Create a parahotplug_request, which is basically a wrapper for a
1482  * CONTROLVM_MESSAGE that we can stick on a list
1483  */
1484 static struct parahotplug_request *
1485 parahotplug_request_create(struct controlvm_message *msg)
1486 {
1487         struct parahotplug_request *req;
1488
1489         req = kmalloc(sizeof(*req), GFP_KERNEL|__GFP_NORETRY);
1490         if (!req)
1491                 return NULL;
1492
1493         req->id = parahotplug_next_id();
1494         req->expiration = parahotplug_next_expiration();
1495         req->msg = *msg;
1496
1497         return req;
1498 }
1499
1500 /*
1501  * Free a parahotplug_request.
1502  */
1503 static void
1504 parahotplug_request_destroy(struct parahotplug_request *req)
1505 {
1506         kfree(req);
1507 }
1508
1509 /*
1510  * Cause uevent to run the user level script to do the disable/enable
1511  * specified in (the CONTROLVM message in) the specified
1512  * parahotplug_request
1513  */
1514 static void
1515 parahotplug_request_kickoff(struct parahotplug_request *req)
1516 {
1517         struct controlvm_message_packet *cmd = &req->msg.cmd;
1518         char env_cmd[40], env_id[40], env_state[40], env_bus[40], env_dev[40],
1519             env_func[40];
1520         char *envp[] = {
1521                 env_cmd, env_id, env_state, env_bus, env_dev, env_func, NULL
1522         };
1523
1524         sprintf(env_cmd, "SPAR_PARAHOTPLUG=1");
1525         sprintf(env_id, "SPAR_PARAHOTPLUG_ID=%d", req->id);
1526         sprintf(env_state, "SPAR_PARAHOTPLUG_STATE=%d",
1527                 cmd->device_change_state.state.active);
1528         sprintf(env_bus, "SPAR_PARAHOTPLUG_BUS=%d",
1529                 cmd->device_change_state.bus_no);
1530         sprintf(env_dev, "SPAR_PARAHOTPLUG_DEVICE=%d",
1531                 cmd->device_change_state.dev_no >> 3);
1532         sprintf(env_func, "SPAR_PARAHOTPLUG_FUNCTION=%d",
1533                 cmd->device_change_state.dev_no & 0x7);
1534
1535         kobject_uevent_env(&Visorchipset_platform_device.dev.kobj, KOBJ_CHANGE,
1536                            envp);
1537 }
1538
1539 /*
1540  * Remove any request from the list that's been on there too long and
1541  * respond with an error.
1542  */
1543 static void
1544 parahotplug_process_list(void)
1545 {
1546         struct list_head *pos = NULL;
1547         struct list_head *tmp = NULL;
1548
1549         spin_lock(&Parahotplug_request_list_lock);
1550
1551         list_for_each_safe(pos, tmp, &Parahotplug_request_list) {
1552                 struct parahotplug_request *req =
1553                     list_entry(pos, struct parahotplug_request, list);
1554                 if (time_after_eq(jiffies, req->expiration)) {
1555                         list_del(pos);
1556                         if (req->msg.hdr.flags.response_expected)
1557                                 controlvm_respond_physdev_changestate(
1558                                         &req->msg.hdr,
1559                                         CONTROLVM_RESP_ERROR_DEVICE_UDEV_TIMEOUT,
1560                                         req->msg.cmd.device_change_state.state);
1561                         parahotplug_request_destroy(req);
1562                 }
1563         }
1564
1565         spin_unlock(&Parahotplug_request_list_lock);
1566 }
1567
1568 /*
1569  * Called from the /proc handler, which means the user script has
1570  * finished the enable/disable.  Find the matching identifier, and
1571  * respond to the CONTROLVM message with success.
1572  */
1573 static int
1574 parahotplug_request_complete(int id, u16 active)
1575 {
1576         struct list_head *pos = NULL;
1577         struct list_head *tmp = NULL;
1578
1579         spin_lock(&Parahotplug_request_list_lock);
1580
1581         /* Look for a request matching "id". */
1582         list_for_each_safe(pos, tmp, &Parahotplug_request_list) {
1583                 struct parahotplug_request *req =
1584                     list_entry(pos, struct parahotplug_request, list);
1585                 if (req->id == id) {
1586                         /* Found a match.  Remove it from the list and
1587                          * respond.
1588                          */
1589                         list_del(pos);
1590                         spin_unlock(&Parahotplug_request_list_lock);
1591                         req->msg.cmd.device_change_state.state.active = active;
1592                         if (req->msg.hdr.flags.response_expected)
1593                                 controlvm_respond_physdev_changestate(
1594                                         &req->msg.hdr, CONTROLVM_RESP_SUCCESS,
1595                                         req->msg.cmd.device_change_state.state);
1596                         parahotplug_request_destroy(req);
1597                         return 0;
1598                 }
1599         }
1600
1601         spin_unlock(&Parahotplug_request_list_lock);
1602         return -1;
1603 }
1604
1605 /*
1606  * Enables or disables a PCI device by kicking off a udev script
1607  */
1608 static void
1609 parahotplug_process_message(struct controlvm_message *inmsg)
1610 {
1611         struct parahotplug_request *req;
1612
1613         req = parahotplug_request_create(inmsg);
1614
1615         if (!req)
1616                 return;
1617
1618         if (inmsg->cmd.device_change_state.state.active) {
1619                 /* For enable messages, just respond with success
1620                 * right away.  This is a bit of a hack, but there are
1621                 * issues with the early enable messages we get (with
1622                 * either the udev script not detecting that the device
1623                 * is up, or not getting called at all).  Fortunately
1624                 * the messages that get lost don't matter anyway, as
1625                 * devices are automatically enabled at
1626                 * initialization.
1627                 */
1628                 parahotplug_request_kickoff(req);
1629                 controlvm_respond_physdev_changestate(&inmsg->hdr,
1630                                 CONTROLVM_RESP_SUCCESS, inmsg->cmd.
1631                                 device_change_state.state);
1632                 parahotplug_request_destroy(req);
1633         } else {
1634                 /* For disable messages, add the request to the
1635                 * request list before kicking off the udev script.  It
1636                 * won't get responded to until the script has
1637                 * indicated it's done.
1638                 */
1639                 spin_lock(&Parahotplug_request_list_lock);
1640                 list_add_tail(&(req->list), &Parahotplug_request_list);
1641                 spin_unlock(&Parahotplug_request_list_lock);
1642
1643                 parahotplug_request_kickoff(req);
1644         }
1645 }
1646
1647 /* Process a controlvm message.
1648  * Return result:
1649  *    FALSE - this function will return FALSE only in the case where the
1650  *            controlvm message was NOT processed, but processing must be
1651  *            retried before reading the next controlvm message; a
1652  *            scenario where this can occur is when we need to throttle
1653  *            the allocation of memory in which to copy out controlvm
1654  *            payload data
1655  *    TRUE  - processing of the controlvm message completed,
1656  *            either successfully or with an error.
1657  */
1658 static BOOL
1659 handle_command(struct controlvm_message inmsg, HOSTADDRESS channel_addr)
1660 {
1661         struct controlvm_message_packet *cmd = &inmsg.cmd;
1662         u64 parametersAddr = 0;
1663         u32 parametersBytes = 0;
1664         struct parser_context *parser_ctx = NULL;
1665         BOOL isLocalAddr = FALSE;
1666         struct controlvm_message ackmsg;
1667
1668         /* create parsing context if necessary */
1669         isLocalAddr = (inmsg.hdr.flags.test_message == 1);
1670         if (channel_addr == 0)
1671                 return TRUE;
1672         parametersAddr = channel_addr + inmsg.hdr.payload_vm_offset;
1673         parametersBytes = inmsg.hdr.payload_bytes;
1674
1675         /* Parameter and channel addresses within test messages actually lie
1676          * within our OS-controlled memory.  We need to know that, because it
1677          * makes a difference in how we compute the virtual address.
1678          */
1679         if (parametersAddr != 0 && parametersBytes != 0) {
1680                 BOOL retry = FALSE;
1681
1682                 parser_ctx =
1683                     parser_init_byte_stream(parametersAddr, parametersBytes,
1684                                            isLocalAddr, &retry);
1685                 if (!parser_ctx && retry)
1686                         return FALSE;
1687         }
1688
1689         if (!isLocalAddr) {
1690                 controlvm_init_response(&ackmsg, &inmsg.hdr,
1691                                         CONTROLVM_RESP_SUCCESS);
1692                 if (controlvm_channel)
1693                         visorchannel_signalinsert(controlvm_channel,
1694                                                   CONTROLVM_QUEUE_ACK,
1695                                                   &ackmsg);
1696         }
1697         switch (inmsg.hdr.id) {
1698         case CONTROLVM_CHIPSET_INIT:
1699                 chipset_init(&inmsg);
1700                 break;
1701         case CONTROLVM_BUS_CREATE:
1702                 bus_create(&inmsg);
1703                 break;
1704         case CONTROLVM_BUS_DESTROY:
1705                 bus_destroy(&inmsg);
1706                 break;
1707         case CONTROLVM_BUS_CONFIGURE:
1708                 bus_configure(&inmsg, parser_ctx);
1709                 break;
1710         case CONTROLVM_DEVICE_CREATE:
1711                 my_device_create(&inmsg);
1712                 break;
1713         case CONTROLVM_DEVICE_CHANGESTATE:
1714                 if (cmd->device_change_state.flags.phys_device) {
1715                         parahotplug_process_message(&inmsg);
1716                 } else {
1717                         /* save the hdr and cmd structures for later use */
1718                         /* when sending back the response to Command */
1719                         my_device_changestate(&inmsg);
1720                         g_diag_msg_hdr = inmsg.hdr;
1721                         g_devicechangestate_packet = inmsg.cmd;
1722                         break;
1723                 }
1724                 break;
1725         case CONTROLVM_DEVICE_DESTROY:
1726                 my_device_destroy(&inmsg);
1727                 break;
1728         case CONTROLVM_DEVICE_CONFIGURE:
1729                 /* no op for now, just send a respond that we passed */
1730                 if (inmsg.hdr.flags.response_expected)
1731                         controlvm_respond(&inmsg.hdr, CONTROLVM_RESP_SUCCESS);
1732                 break;
1733         case CONTROLVM_CHIPSET_READY:
1734                 chipset_ready(&inmsg.hdr);
1735                 break;
1736         case CONTROLVM_CHIPSET_SELFTEST:
1737                 chipset_selftest(&inmsg.hdr);
1738                 break;
1739         case CONTROLVM_CHIPSET_STOP:
1740                 chipset_notready(&inmsg.hdr);
1741                 break;
1742         default:
1743                 if (inmsg.hdr.flags.response_expected)
1744                         controlvm_respond(&inmsg.hdr,
1745                                           -CONTROLVM_RESP_ERROR_MESSAGE_ID_UNKNOWN);
1746                 break;
1747         }
1748
1749         if (parser_ctx) {
1750                 parser_done(parser_ctx);
1751                 parser_ctx = NULL;
1752         }
1753         return TRUE;
1754 }
1755
1756 static HOSTADDRESS controlvm_get_channel_address(void)
1757 {
1758         u64 addr = 0;
1759         u32 size = 0;
1760
1761         if (!VMCALL_SUCCESSFUL(issue_vmcall_io_controlvm_addr(&addr, &size)))
1762                 return 0;
1763
1764         return addr;
1765 }
1766
1767 static void
1768 controlvm_periodic_work(struct work_struct *work)
1769 {
1770         struct controlvm_message inmsg;
1771         BOOL gotACommand = FALSE;
1772         BOOL handle_command_failed = FALSE;
1773         static u64 Poll_Count;
1774
1775         /* make sure visorbus server is registered for controlvm callbacks */
1776         if (visorchipset_serverregwait && !serverregistered)
1777                 goto Away;
1778         /* make sure visorclientbus server is regsitered for controlvm
1779          * callbacks
1780          */
1781         if (visorchipset_clientregwait && !clientregistered)
1782                 goto Away;
1783
1784         Poll_Count++;
1785         if (Poll_Count >= 250)
1786                 ;       /* keep going */
1787         else
1788                 goto Away;
1789
1790         /* Check events to determine if response to CHIPSET_READY
1791          * should be sent
1792          */
1793         if (visorchipset_holdchipsetready &&
1794             (g_chipset_msg_hdr.id != CONTROLVM_INVALID)) {
1795                 if (check_chipset_events() == 1) {
1796                         controlvm_respond(&g_chipset_msg_hdr, 0);
1797                         clear_chipset_events();
1798                         memset(&g_chipset_msg_hdr, 0,
1799                                sizeof(struct controlvm_message_header));
1800                 }
1801         }
1802
1803         while (visorchannel_signalremove(controlvm_channel,
1804                                          CONTROLVM_QUEUE_RESPONSE,
1805                                          &inmsg))
1806                 ;
1807         if (!gotACommand) {
1808                 if (ControlVm_Pending_Msg_Valid) {
1809                         /* we throttled processing of a prior
1810                         * msg, so try to process it again
1811                         * rather than reading a new one
1812                         */
1813                         inmsg = ControlVm_Pending_Msg;
1814                         ControlVm_Pending_Msg_Valid = FALSE;
1815                         gotACommand = TRUE;
1816                 } else
1817                         gotACommand = read_controlvm_event(&inmsg);
1818         }
1819
1820         handle_command_failed = FALSE;
1821         while (gotACommand && (!handle_command_failed)) {
1822                 most_recent_message_jiffies = jiffies;
1823                 if (handle_command(inmsg,
1824                                    visorchannel_get_physaddr
1825                                    (controlvm_channel)))
1826                         gotACommand = read_controlvm_event(&inmsg);
1827                 else {
1828                         /* this is a scenario where throttling
1829                         * is required, but probably NOT an
1830                         * error...; we stash the current
1831                         * controlvm msg so we will attempt to
1832                         * reprocess it on our next loop
1833                         */
1834                         handle_command_failed = TRUE;
1835                         ControlVm_Pending_Msg = inmsg;
1836                         ControlVm_Pending_Msg_Valid = TRUE;
1837                 }
1838         }
1839
1840         /* parahotplug_worker */
1841         parahotplug_process_list();
1842
1843 Away:
1844
1845         if (time_after(jiffies,
1846                        most_recent_message_jiffies + (HZ * MIN_IDLE_SECONDS))) {
1847                 /* it's been longer than MIN_IDLE_SECONDS since we
1848                 * processed our last controlvm message; slow down the
1849                 * polling
1850                 */
1851                 if (poll_jiffies != POLLJIFFIES_CONTROLVMCHANNEL_SLOW)
1852                         poll_jiffies = POLLJIFFIES_CONTROLVMCHANNEL_SLOW;
1853         } else {
1854                 if (poll_jiffies != POLLJIFFIES_CONTROLVMCHANNEL_FAST)
1855                         poll_jiffies = POLLJIFFIES_CONTROLVMCHANNEL_FAST;
1856         }
1857
1858         queue_delayed_work(periodic_controlvm_workqueue,
1859                            &periodic_controlvm_work, poll_jiffies);
1860 }
1861
1862 static void
1863 setup_crash_devices_work_queue(struct work_struct *work)
1864 {
1865         struct controlvm_message localCrashCreateBusMsg;
1866         struct controlvm_message localCrashCreateDevMsg;
1867         struct controlvm_message msg;
1868         u32 localSavedCrashMsgOffset;
1869         u16 localSavedCrashMsgCount;
1870
1871         /* make sure visorbus server is registered for controlvm callbacks */
1872         if (visorchipset_serverregwait && !serverregistered)
1873                 goto Away;
1874
1875         /* make sure visorclientbus server is regsitered for controlvm
1876          * callbacks
1877          */
1878         if (visorchipset_clientregwait && !clientregistered)
1879                 goto Away;
1880
1881         POSTCODE_LINUX_2(CRASH_DEV_ENTRY_PC, POSTCODE_SEVERITY_INFO);
1882
1883         /* send init chipset msg */
1884         msg.hdr.id = CONTROLVM_CHIPSET_INIT;
1885         msg.cmd.init_chipset.bus_count = 23;
1886         msg.cmd.init_chipset.switch_count = 0;
1887
1888         chipset_init(&msg);
1889
1890         /* get saved message count */
1891         if (visorchannel_read(controlvm_channel,
1892                               offsetof(struct spar_controlvm_channel_protocol,
1893                                        saved_crash_message_count),
1894                               &localSavedCrashMsgCount, sizeof(u16)) < 0) {
1895                 POSTCODE_LINUX_2(CRASH_DEV_CTRL_RD_FAILURE_PC,
1896                                  POSTCODE_SEVERITY_ERR);
1897                 return;
1898         }
1899
1900         if (localSavedCrashMsgCount != CONTROLVM_CRASHMSG_MAX) {
1901                 POSTCODE_LINUX_3(CRASH_DEV_COUNT_FAILURE_PC,
1902                                  localSavedCrashMsgCount,
1903                                  POSTCODE_SEVERITY_ERR);
1904                 return;
1905         }
1906
1907         /* get saved crash message offset */
1908         if (visorchannel_read(controlvm_channel,
1909                               offsetof(struct spar_controlvm_channel_protocol,
1910                                        saved_crash_message_offset),
1911                               &localSavedCrashMsgOffset, sizeof(u32)) < 0) {
1912                 POSTCODE_LINUX_2(CRASH_DEV_CTRL_RD_FAILURE_PC,
1913                                  POSTCODE_SEVERITY_ERR);
1914                 return;
1915         }
1916
1917         /* read create device message for storage bus offset */
1918         if (visorchannel_read(controlvm_channel,
1919                               localSavedCrashMsgOffset,
1920                               &localCrashCreateBusMsg,
1921                               sizeof(struct controlvm_message)) < 0) {
1922                 POSTCODE_LINUX_2(CRASH_DEV_RD_BUS_FAIULRE_PC,
1923                                  POSTCODE_SEVERITY_ERR);
1924                 return;
1925         }
1926
1927         /* read create device message for storage device */
1928         if (visorchannel_read(controlvm_channel,
1929                               localSavedCrashMsgOffset +
1930                               sizeof(struct controlvm_message),
1931                               &localCrashCreateDevMsg,
1932                               sizeof(struct controlvm_message)) < 0) {
1933                 POSTCODE_LINUX_2(CRASH_DEV_RD_DEV_FAIULRE_PC,
1934                                  POSTCODE_SEVERITY_ERR);
1935                 return;
1936         }
1937
1938         /* reuse IOVM create bus message */
1939         if (localCrashCreateBusMsg.cmd.create_bus.channel_addr != 0)
1940                 bus_create(&localCrashCreateBusMsg);
1941         else {
1942                 POSTCODE_LINUX_2(CRASH_DEV_BUS_NULL_FAILURE_PC,
1943                                  POSTCODE_SEVERITY_ERR);
1944                 return;
1945         }
1946
1947         /* reuse create device message for storage device */
1948         if (localCrashCreateDevMsg.cmd.create_device.channel_addr != 0)
1949                 my_device_create(&localCrashCreateDevMsg);
1950         else {
1951                 POSTCODE_LINUX_2(CRASH_DEV_DEV_NULL_FAILURE_PC,
1952                                  POSTCODE_SEVERITY_ERR);
1953                 return;
1954         }
1955         POSTCODE_LINUX_2(CRASH_DEV_EXIT_PC, POSTCODE_SEVERITY_INFO);
1956         return;
1957
1958 Away:
1959
1960         poll_jiffies = POLLJIFFIES_CONTROLVMCHANNEL_SLOW;
1961
1962         queue_delayed_work(periodic_controlvm_workqueue,
1963                            &periodic_controlvm_work, poll_jiffies);
1964 }
1965
1966 static void
1967 bus_create_response(ulong busNo, int response)
1968 {
1969         bus_responder(CONTROLVM_BUS_CREATE, busNo, response);
1970 }
1971
1972 static void
1973 bus_destroy_response(ulong busNo, int response)
1974 {
1975         bus_responder(CONTROLVM_BUS_DESTROY, busNo, response);
1976 }
1977
1978 static void
1979 device_create_response(ulong busNo, ulong devNo, int response)
1980 {
1981         device_responder(CONTROLVM_DEVICE_CREATE, busNo, devNo, response);
1982 }
1983
1984 static void
1985 device_destroy_response(ulong busNo, ulong devNo, int response)
1986 {
1987         device_responder(CONTROLVM_DEVICE_DESTROY, busNo, devNo, response);
1988 }
1989
1990 void
1991 visorchipset_device_pause_response(ulong bus_no, ulong dev_no, int response)
1992 {
1993         device_changestate_responder(CONTROLVM_DEVICE_CHANGESTATE,
1994                                      bus_no, dev_no, response,
1995                                      segment_state_standby);
1996 }
1997 EXPORT_SYMBOL_GPL(visorchipset_device_pause_response);
1998
1999 static void
2000 device_resume_response(ulong busNo, ulong devNo, int response)
2001 {
2002         device_changestate_responder(CONTROLVM_DEVICE_CHANGESTATE,
2003                                      busNo, devNo, response,
2004                                      segment_state_running);
2005 }
2006
2007 BOOL
2008 visorchipset_get_bus_info(ulong bus_no, struct visorchipset_bus_info *bus_info)
2009 {
2010         void *p = findbus(&bus_info_list, bus_no);
2011
2012         if (!p)
2013                 return FALSE;
2014         memcpy(bus_info, p, sizeof(struct visorchipset_bus_info));
2015         return TRUE;
2016 }
2017 EXPORT_SYMBOL_GPL(visorchipset_get_bus_info);
2018
2019 BOOL
2020 visorchipset_set_bus_context(ulong bus_no, void *context)
2021 {
2022         struct visorchipset_bus_info *p = findbus(&bus_info_list, bus_no);
2023
2024         if (!p)
2025                 return FALSE;
2026         p->bus_driver_context = context;
2027         return TRUE;
2028 }
2029 EXPORT_SYMBOL_GPL(visorchipset_set_bus_context);
2030
2031 BOOL
2032 visorchipset_get_device_info(ulong bus_no, ulong dev_no,
2033                              struct visorchipset_device_info *dev_info)
2034 {
2035         void *p = finddevice(&dev_info_list, bus_no, dev_no);
2036
2037         if (!p)
2038                 return FALSE;
2039         memcpy(dev_info, p, sizeof(struct visorchipset_device_info));
2040         return TRUE;
2041 }
2042 EXPORT_SYMBOL_GPL(visorchipset_get_device_info);
2043
2044 BOOL
2045 visorchipset_set_device_context(ulong bus_no, ulong dev_no, void *context)
2046 {
2047         struct visorchipset_device_info *p =
2048                         finddevice(&dev_info_list, bus_no, dev_no);
2049
2050         if (!p)
2051                 return FALSE;
2052         p->bus_driver_context = context;
2053         return TRUE;
2054 }
2055 EXPORT_SYMBOL_GPL(visorchipset_set_device_context);
2056
2057 /* Generic wrapper function for allocating memory from a kmem_cache pool.
2058  */
2059 void *
2060 visorchipset_cache_alloc(struct kmem_cache *pool, BOOL ok_to_block,
2061                          char *fn, int ln)
2062 {
2063         gfp_t gfp;
2064         void *p;
2065
2066         if (ok_to_block)
2067                 gfp = GFP_KERNEL;
2068         else
2069                 gfp = GFP_ATOMIC;
2070         /* __GFP_NORETRY means "ok to fail", meaning
2071          * kmem_cache_alloc() can return NULL, implying the caller CAN
2072          * cope with failure.  If you do NOT specify __GFP_NORETRY,
2073          * Linux will go to extreme measures to get memory for you
2074          * (like, invoke oom killer), which will probably cripple the
2075          * system.
2076          */
2077         gfp |= __GFP_NORETRY;
2078         p = kmem_cache_alloc(pool, gfp);
2079         if (!p)
2080                 return NULL;
2081
2082         atomic_inc(&Visorchipset_cache_buffers_in_use);
2083         return p;
2084 }
2085
2086 /* Generic wrapper function for freeing memory from a kmem_cache pool.
2087  */
2088 void
2089 visorchipset_cache_free(struct kmem_cache *pool, void *p, char *fn, int ln)
2090 {
2091         if (!p)
2092                 return;
2093
2094         atomic_dec(&Visorchipset_cache_buffers_in_use);
2095         kmem_cache_free(pool, p);
2096 }
2097
2098 static ssize_t chipsetready_store(struct device *dev,
2099         struct device_attribute *attr, const char *buf, size_t count)
2100 {
2101         char msgtype[64];
2102
2103         if (sscanf(buf, "%63s", msgtype) != 1)
2104                 return -EINVAL;
2105
2106         if (strcmp(msgtype, "CALLHOMEDISK_MOUNTED") == 0) {
2107                 chipset_events[0] = 1;
2108                 return count;
2109         } else if (strcmp(msgtype, "MODULES_LOADED") == 0) {
2110                 chipset_events[1] = 1;
2111                 return count;
2112         }
2113         return -EINVAL;
2114 }
2115
2116 /* The parahotplug/devicedisabled interface gets called by our support script
2117  * when an SR-IOV device has been shut down. The ID is passed to the script
2118  * and then passed back when the device has been removed.
2119  */
2120 static ssize_t devicedisabled_store(struct device *dev,
2121         struct device_attribute *attr, const char *buf, size_t count)
2122 {
2123         uint id;
2124
2125         if (kstrtouint(buf, 10, &id) != 0)
2126                 return -EINVAL;
2127
2128         parahotplug_request_complete(id, 0);
2129         return count;
2130 }
2131
2132 /* The parahotplug/deviceenabled interface gets called by our support script
2133  * when an SR-IOV device has been recovered. The ID is passed to the script
2134  * and then passed back when the device has been brought back up.
2135  */
2136 static ssize_t deviceenabled_store(struct device *dev,
2137         struct device_attribute *attr, const char *buf, size_t count)
2138 {
2139         uint id;
2140
2141         if (kstrtouint(buf, 10, &id) != 0)
2142                 return -EINVAL;
2143
2144         parahotplug_request_complete(id, 1);
2145         return count;
2146 }
2147
2148 static int __init
2149 visorchipset_init(void)
2150 {
2151         int rc = 0, x = 0;
2152         HOSTADDRESS addr;
2153
2154         if (!unisys_spar_platform)
2155                 return -ENODEV;
2156
2157         memset(&BusDev_Server_Notifiers, 0, sizeof(BusDev_Server_Notifiers));
2158         memset(&BusDev_Client_Notifiers, 0, sizeof(BusDev_Client_Notifiers));
2159         memset(&controlvm_payload_info, 0, sizeof(controlvm_payload_info));
2160         memset(&livedump_info, 0, sizeof(livedump_info));
2161         atomic_set(&livedump_info.buffers_in_use, 0);
2162
2163         if (visorchipset_testvnic) {
2164                 POSTCODE_LINUX_3(CHIPSET_INIT_FAILURE_PC, x, DIAG_SEVERITY_ERR);
2165                 rc = x;
2166                 goto Away;
2167         }
2168
2169         addr = controlvm_get_channel_address();
2170         if (addr != 0) {
2171                 controlvm_channel =
2172                     visorchannel_create_with_lock
2173                     (addr,
2174                      sizeof(struct spar_controlvm_channel_protocol),
2175                      spar_controlvm_channel_protocol_uuid);
2176                 if (SPAR_CONTROLVM_CHANNEL_OK_CLIENT(
2177                                 visorchannel_get_header(controlvm_channel))) {
2178                         initialize_controlvm_payload();
2179                 } else {
2180                         visorchannel_destroy(controlvm_channel);
2181                         controlvm_channel = NULL;
2182                         return -ENODEV;
2183                 }
2184         } else {
2185                 return -ENODEV;
2186         }
2187
2188         MajorDev = MKDEV(visorchipset_major, 0);
2189         rc = visorchipset_file_init(MajorDev, &controlvm_channel);
2190         if (rc < 0) {
2191                 POSTCODE_LINUX_2(CHIPSET_INIT_FAILURE_PC, DIAG_SEVERITY_ERR);
2192                 goto Away;
2193         }
2194
2195         memset(&g_diag_msg_hdr, 0, sizeof(struct controlvm_message_header));
2196
2197         memset(&g_chipset_msg_hdr, 0, sizeof(struct controlvm_message_header));
2198
2199         memset(&g_del_dump_msg_hdr, 0, sizeof(struct controlvm_message_header));
2200
2201         Putfile_buffer_list_pool =
2202             kmem_cache_create(Putfile_buffer_list_pool_name,
2203                               sizeof(struct putfile_buffer_entry),
2204                               0, SLAB_HWCACHE_ALIGN, NULL);
2205         if (!Putfile_buffer_list_pool) {
2206                 POSTCODE_LINUX_2(CHIPSET_INIT_FAILURE_PC, DIAG_SEVERITY_ERR);
2207                 rc = -1;
2208                 goto Away;
2209         }
2210         if (!visorchipset_disable_controlvm) {
2211                 /* if booting in a crash kernel */
2212                 if (visorchipset_crash_kernel)
2213                         INIT_DELAYED_WORK(&periodic_controlvm_work,
2214                                           setup_crash_devices_work_queue);
2215                 else
2216                         INIT_DELAYED_WORK(&periodic_controlvm_work,
2217                                           controlvm_periodic_work);
2218                 periodic_controlvm_workqueue =
2219                     create_singlethread_workqueue("visorchipset_controlvm");
2220
2221                 if (!periodic_controlvm_workqueue) {
2222                         POSTCODE_LINUX_2(CREATE_WORKQUEUE_FAILED_PC,
2223                                          DIAG_SEVERITY_ERR);
2224                         rc = -ENOMEM;
2225                         goto Away;
2226                 }
2227                 most_recent_message_jiffies = jiffies;
2228                 poll_jiffies = POLLJIFFIES_CONTROLVMCHANNEL_FAST;
2229                 rc = queue_delayed_work(periodic_controlvm_workqueue,
2230                                         &periodic_controlvm_work, poll_jiffies);
2231                 if (rc < 0) {
2232                         POSTCODE_LINUX_2(QUEUE_DELAYED_WORK_PC,
2233                                          DIAG_SEVERITY_ERR);
2234                         goto Away;
2235                 }
2236         }
2237
2238         Visorchipset_platform_device.dev.devt = MajorDev;
2239         if (platform_device_register(&Visorchipset_platform_device) < 0) {
2240                 POSTCODE_LINUX_2(DEVICE_REGISTER_FAILURE_PC, DIAG_SEVERITY_ERR);
2241                 rc = -1;
2242                 goto Away;
2243         }
2244         POSTCODE_LINUX_2(CHIPSET_INIT_SUCCESS_PC, POSTCODE_SEVERITY_INFO);
2245         rc = 0;
2246 Away:
2247         if (rc) {
2248                 POSTCODE_LINUX_3(CHIPSET_INIT_FAILURE_PC, rc,
2249                                  POSTCODE_SEVERITY_ERR);
2250         }
2251         return rc;
2252 }
2253
2254 static void
2255 visorchipset_exit(void)
2256 {
2257         POSTCODE_LINUX_2(DRIVER_EXIT_PC, POSTCODE_SEVERITY_INFO);
2258
2259         if (visorchipset_disable_controlvm) {
2260                 ;
2261         } else {
2262                 cancel_delayed_work(&periodic_controlvm_work);
2263                 flush_workqueue(periodic_controlvm_workqueue);
2264                 destroy_workqueue(periodic_controlvm_workqueue);
2265                 periodic_controlvm_workqueue = NULL;
2266                 destroy_controlvm_payload_info(&controlvm_payload_info);
2267         }
2268         if (Putfile_buffer_list_pool) {
2269                 kmem_cache_destroy(Putfile_buffer_list_pool);
2270                 Putfile_buffer_list_pool = NULL;
2271         }
2272
2273         cleanup_controlvm_structures();
2274
2275         memset(&g_diag_msg_hdr, 0, sizeof(struct controlvm_message_header));
2276
2277         memset(&g_chipset_msg_hdr, 0, sizeof(struct controlvm_message_header));
2278
2279         memset(&g_del_dump_msg_hdr, 0, sizeof(struct controlvm_message_header));
2280
2281         visorchannel_destroy(controlvm_channel);
2282
2283         visorchipset_file_cleanup();
2284         POSTCODE_LINUX_2(DRIVER_EXIT_PC, POSTCODE_SEVERITY_INFO);
2285 }
2286
2287 module_param_named(testvnic, visorchipset_testvnic, int, S_IRUGO);
2288 MODULE_PARM_DESC(visorchipset_testvnic, "1 to test vnic, using dummy VNIC connected via a loopback to a physical ethernet");
2289 int visorchipset_testvnic = 0;
2290
2291 module_param_named(testvnicclient, visorchipset_testvnicclient, int, S_IRUGO);
2292 MODULE_PARM_DESC(visorchipset_testvnicclient, "1 to test vnic, using real VNIC channel attached to a separate IOVM guest");
2293 int visorchipset_testvnicclient = 0;
2294
2295 module_param_named(testmsg, visorchipset_testmsg, int, S_IRUGO);
2296 MODULE_PARM_DESC(visorchipset_testmsg,
2297                  "1 to manufacture the chipset, bus, and switch messages");
2298 int visorchipset_testmsg = 0;
2299
2300 module_param_named(major, visorchipset_major, int, S_IRUGO);
2301 MODULE_PARM_DESC(visorchipset_major, "major device number to use for the device node");
2302 int visorchipset_major = 0;
2303
2304 module_param_named(serverregwait, visorchipset_serverregwait, int, S_IRUGO);
2305 MODULE_PARM_DESC(visorchipset_serverreqwait,
2306                  "1 to have the module wait for the visor bus to register");
2307 int visorchipset_serverregwait = 0;     /* default is off */
2308 module_param_named(clientregwait, visorchipset_clientregwait, int, S_IRUGO);
2309 MODULE_PARM_DESC(visorchipset_clientregwait, "1 to have the module wait for the visorclientbus to register");
2310 int visorchipset_clientregwait = 1;     /* default is on */
2311 module_param_named(testteardown, visorchipset_testteardown, int, S_IRUGO);
2312 MODULE_PARM_DESC(visorchipset_testteardown,
2313                  "1 to test teardown of the chipset, bus, and switch");
2314 int visorchipset_testteardown = 0;      /* default is off */
2315 module_param_named(disable_controlvm, visorchipset_disable_controlvm, int,
2316                    S_IRUGO);
2317 MODULE_PARM_DESC(visorchipset_disable_controlvm,
2318                  "1 to disable polling of controlVm channel");
2319 int visorchipset_disable_controlvm = 0; /* default is off */
2320 module_param_named(crash_kernel, visorchipset_crash_kernel, int, S_IRUGO);
2321 MODULE_PARM_DESC(visorchipset_crash_kernel,
2322                  "1 means we are running in crash kernel");
2323 int visorchipset_crash_kernel = 0; /* default is running in non-crash kernel */
2324 module_param_named(holdchipsetready, visorchipset_holdchipsetready,
2325                    int, S_IRUGO);
2326 MODULE_PARM_DESC(visorchipset_holdchipsetready,
2327                  "1 to hold response to CHIPSET_READY");
2328 int visorchipset_holdchipsetready = 0; /* default is to send CHIPSET_READY
2329                                       * response immediately */
2330 module_init(visorchipset_init);
2331 module_exit(visorchipset_exit);
2332
2333 MODULE_AUTHOR("Unisys");
2334 MODULE_LICENSE("GPL");
2335 MODULE_DESCRIPTION("Supervisor chipset driver for service partition: ver "
2336                    VERSION);
2337 MODULE_VERSION(VERSION);