drivers/visorbus/visorchipset.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (C) 2010 - 2015 UNISYS CORPORATION
   4  * All rights reserved.
   5  */
   6
   7 #include <linux/acpi.h>
   8 #include <linux/crash_dump.h>
   9 #include <linux/visorbus.h>
  10
  11 #include "visorbus_private.h"
  12
  13 /* {72120008-4AAB-11DC-8530-444553544200} */
  14 #define VISOR_SIOVM_GUID GUID_INIT(0x72120008, 0x4AAB, 0x11DC, 0x85, 0x30, \
  15                                    0x44, 0x45, 0x53, 0x54, 0x42, 0x00)
  16
  17 static const guid_t visor_vhba_channel_guid = VISOR_VHBA_CHANNEL_GUID;
  18 static const guid_t visor_siovm_guid = VISOR_SIOVM_GUID;
  19 static const guid_t visor_controlvm_channel_guid = VISOR_CONTROLVM_CHANNEL_GUID;
  20
  21 #define POLLJIFFIES_CONTROLVM_FAST 1
  22 #define POLLJIFFIES_CONTROLVM_SLOW 100
  23
  24 #define MAX_CONTROLVM_PAYLOAD_BYTES (1024 * 128)
  25
  26 #define UNISYS_VISOR_LEAF_ID 0x40000000
  27
  28 /* The s-Par leaf ID returns "UnisysSpar64" encoded across ebx, ecx, edx */
  29 #define UNISYS_VISOR_ID_EBX 0x73696e55
  30 #define UNISYS_VISOR_ID_ECX 0x70537379
  31 #define UNISYS_VISOR_ID_EDX 0x34367261
  32
  33 /*
  34  * When the controlvm channel is idle for at least MIN_IDLE_SECONDS, we switch
  35  * to slow polling mode. As soon as we get a controlvm message, we switch back
  36  * to fast polling mode.
  37  */
  38 #define MIN_IDLE_SECONDS 10
  39
  40 struct parser_context {
  41         unsigned long allocbytes;
  42         unsigned long param_bytes;
  43         u8 *curr;
  44         unsigned long bytes_remaining;
  45         bool byte_stream;
  46         struct visor_controlvm_parameters_header data;
  47 };
  48
  49 /* VMCALL_CONTROLVM_ADDR: Used by all guests, not just IO. */
  50 #define VMCALL_CONTROLVM_ADDR 0x0501
  51
  52 enum vmcall_result {
  53         VMCALL_RESULT_SUCCESS = 0,
  54         VMCALL_RESULT_INVALID_PARAM = 1,
  55         VMCALL_RESULT_DATA_UNAVAILABLE = 2,
  56         VMCALL_RESULT_FAILURE_UNAVAILABLE = 3,
  57         VMCALL_RESULT_DEVICE_ERROR = 4,
  58         VMCALL_RESULT_DEVICE_NOT_READY = 5
  59 };
  60
  61 /*
  62  * struct vmcall_io_controlvm_addr_params - Structure for IO VMCALLS. Has
  63  *                                          parameters to VMCALL_CONTROLVM_ADDR
  64  *                                          interface.
  65  * @address:       The Guest-relative physical address of the ControlVm channel.
  66  *                 This VMCall fills this in with the appropriate address.
  67  *                 Contents provided by this VMCALL (OUT).
  68  * @channel_bytes: The size of the ControlVm channel in bytes This VMCall fills
  69  *                 this in with the appropriate address. Contents provided by
  70  *                 this VMCALL (OUT).
  71  * @unused:        Unused Bytes in the 64-Bit Aligned Struct.
  72  */
  73 struct vmcall_io_controlvm_addr_params {
  74         u64 address;
  75         u32 channel_bytes;
  76         u8 unused[4];
  77 } __packed;
  78
  79 struct visorchipset_device {
  80         struct acpi_device *acpi_device;
  81         unsigned long poll_jiffies;
  82         /* when we got our last controlvm message */
  83         unsigned long most_recent_message_jiffies;
  84         struct delayed_work periodic_controlvm_work;
  85         struct visorchannel *controlvm_channel;
  86         unsigned long controlvm_payload_bytes_buffered;
  87         /*
  88          * The following variables are used to handle the scenario where we are
  89          * unable to offload the payload from a controlvm message due to memory
  90          * requirements. In this scenario, we simply stash the controlvm
  91          * message, then attempt to process it again the next time
  92          * controlvm_periodic_work() runs.
  93          */
  94         struct controlvm_message controlvm_pending_msg;
  95         bool controlvm_pending_msg_valid;
  96         struct vmcall_io_controlvm_addr_params controlvm_params;
  97 };
  98
  99 static struct visorchipset_device *chipset_dev;
 100
 101 struct parahotplug_request {
 102         struct list_head list;
 103         int id;
 104         unsigned long expiration;
 105         struct controlvm_message msg;
 106 };
 107
 108 /* prototypes for attributes */
 109 static ssize_t toolaction_show(struct device *dev,
 110                                struct device_attribute *attr,
 111                                char *buf)
 112 {
 113         u8 tool_action = 0;
 114         int err;
 115
 116         err = visorchannel_read(chipset_dev->controlvm_channel,
 117                                 offsetof(struct visor_controlvm_channel,
 118                                          tool_action),
 119                                 &tool_action, sizeof(u8));
 120         if (err)
 121                 return err;
 122         return sprintf(buf, "%u\n", tool_action);
 123 }
 124
 125 static ssize_t toolaction_store(struct device *dev,
 126                                 struct device_attribute *attr,
 127                                 const char *buf, size_t count)
 128 {
 129         u8 tool_action;
 130         int err;
 131
 132         if (kstrtou8(buf, 10, &tool_action))
 133                 return -EINVAL;
 134         err = visorchannel_write(chipset_dev->controlvm_channel,
 135                                  offsetof(struct visor_controlvm_channel,
 136                                           tool_action),
 137                                  &tool_action, sizeof(u8));
 138         if (err)
 139                 return err;
 140         return count;
 141 }
 142 static DEVICE_ATTR_RW(toolaction);
 143
 144 static ssize_t boottotool_show(struct device *dev,
 145                                struct device_attribute *attr,
 146                                char *buf)
 147 {
 148         struct efi_visor_indication efi_visor_indication;
 149         int err;
 150
 151         err = visorchannel_read(chipset_dev->controlvm_channel,
 152                                 offsetof(struct visor_controlvm_channel,
 153                                          efi_visor_ind),
 154                                 &efi_visor_indication,
 155                                 sizeof(struct efi_visor_indication));
 156         if (err)
 157                 return err;
 158         return sprintf(buf, "%u\n", efi_visor_indication.boot_to_tool);
 159 }
 160
 161 static ssize_t boottotool_store(struct device *dev,
 162                                 struct device_attribute *attr,
 163                                 const char *buf, size_t count)
 164 {
 165         int val, err;
 166         struct efi_visor_indication efi_visor_indication;
 167
 168         if (kstrtoint(buf, 10, &val))
 169                 return -EINVAL;
 170         efi_visor_indication.boot_to_tool = val;
 171         err = visorchannel_write(chipset_dev->controlvm_channel,
 172                                  offsetof(struct visor_controlvm_channel,
 173                                           efi_visor_ind),
 174                                  &(efi_visor_indication),
 175                                  sizeof(struct efi_visor_indication));
 176         if (err)
 177                 return err;
 178         return count;
 179 }
 180 static DEVICE_ATTR_RW(boottotool);
 181
 182 static ssize_t error_show(struct device *dev, struct device_attribute *attr,
 183                           char *buf)
 184 {
 185         u32 error = 0;
 186         int err;
 187
 188         err = visorchannel_read(chipset_dev->controlvm_channel,
 189                                 offsetof(struct visor_controlvm_channel,
 190                                          installation_error),
 191                                 &error, sizeof(u32));
 192         if (err)
 193                 return err;
 194         return sprintf(buf, "%u\n", error);
 195 }
 196
 197 static ssize_t error_store(struct device *dev, struct device_attribute *attr,
 198                            const char *buf, size_t count)
 199 {
 200         u32 error;
 201         int err;
 202
 203         if (kstrtou32(buf, 10, &error))
 204                 return -EINVAL;
 205         err = visorchannel_write(chipset_dev->controlvm_channel,
 206                                  offsetof(struct visor_controlvm_channel,
 207                                           installation_error),
 208                                  &error, sizeof(u32));
 209         if (err)
 210                 return err;
 211         return count;
 212 }
 213 static DEVICE_ATTR_RW(error);
 214
 215 static ssize_t textid_show(struct device *dev, struct device_attribute *attr,
 216                            char *buf)
 217 {
 218         u32 text_id = 0;
 219         int err;
 220
 221         err = visorchannel_read(chipset_dev->controlvm_channel,
 222                                 offsetof(struct visor_controlvm_channel,
 223                                          installation_text_id),
 224                                 &text_id, sizeof(u32));
 225         if (err)
 226                 return err;
 227         return sprintf(buf, "%u\n", text_id);
 228 }
 229
 230 static ssize_t textid_store(struct device *dev, struct device_attribute *attr,
 231                             const char *buf, size_t count)
 232 {
 233         u32 text_id;
 234         int err;
 235
 236         if (kstrtou32(buf, 10, &text_id))
 237                 return -EINVAL;
 238         err = visorchannel_write(chipset_dev->controlvm_channel,
 239                                  offsetof(struct visor_controlvm_channel,
 240                                           installation_text_id),
 241                                  &text_id, sizeof(u32));
 242         if (err)
 243                 return err;
 244         return count;
 245 }
 246 static DEVICE_ATTR_RW(textid);
 247
 248 static ssize_t remaining_steps_show(struct device *dev,
 249                                     struct device_attribute *attr, char *buf)
 250 {
 251         u16 remaining_steps = 0;
 252         int err;
 253
 254         err = visorchannel_read(chipset_dev->controlvm_channel,
 255                                 offsetof(struct visor_controlvm_channel,
 256                                          installation_remaining_steps),
 257                                 &remaining_steps, sizeof(u16));
 258         if (err)
 259                 return err;
 260         return sprintf(buf, "%hu\n", remaining_steps);
 261 }
 262
 263 static ssize_t remaining_steps_store(struct device *dev,
 264                                      struct device_attribute *attr,
 265                                      const char *buf, size_t count)
 266 {
 267         u16 remaining_steps;
 268         int err;
 269
 270         if (kstrtou16(buf, 10, &remaining_steps))
 271                 return -EINVAL;
 272         err = visorchannel_write(chipset_dev->controlvm_channel,
 273                                  offsetof(struct visor_controlvm_channel,
 274                                           installation_remaining_steps),
 275                                  &remaining_steps, sizeof(u16));
 276         if (err)
 277                 return err;
 278         return count;
 279 }
 280 static DEVICE_ATTR_RW(remaining_steps);
 281
 282 static void controlvm_init_response(struct controlvm_message *msg,
 283                                     struct controlvm_message_header *msg_hdr,
 284                                     int response)
 285 {
 286         memset(msg, 0, sizeof(struct controlvm_message));
 287         memcpy(&msg->hdr, msg_hdr, sizeof(struct controlvm_message_header));
 288         msg->hdr.payload_bytes = 0;
 289         msg->hdr.payload_vm_offset = 0;
 290         msg->hdr.payload_max_bytes = 0;
 291         if (response < 0) {
 292                 msg->hdr.flags.failed = 1;
 293                 msg->hdr.completion_status = (u32)(-response);
 294         }
 295 }
 296
 297 static int controlvm_respond_chipset_init(
 298                                 struct controlvm_message_header *msg_hdr,
 299                                 int response,
 300                                 enum visor_chipset_feature features)
 301 {
 302         struct controlvm_message outmsg;
 303
 304         controlvm_init_response(&outmsg, msg_hdr, response);
 305         outmsg.cmd.init_chipset.features = features;
 306         return visorchannel_signalinsert(chipset_dev->controlvm_channel,
 307                                          CONTROLVM_QUEUE_REQUEST, &outmsg);
 308 }
 309
 310 static int chipset_init(struct controlvm_message *inmsg)
 311 {
 312         static int chipset_inited;
 313         enum visor_chipset_feature features = 0;
 314         int rc = CONTROLVM_RESP_SUCCESS;
 315         int res = 0;
 316
 317         if (chipset_inited) {
 318                 rc = -CONTROLVM_RESP_ALREADY_DONE;
 319                 res = -EIO;
 320                 goto out_respond;
 321         }
 322         chipset_inited = 1;
 323         /*
 324          * Set features to indicate we support parahotplug (if Command also
 325          * supports it). Set the "reply" bit so Command knows this is a
 326          * features-aware driver.
 327          */
 328         features = inmsg->cmd.init_chipset.features &
 329                    VISOR_CHIPSET_FEATURE_PARA_HOTPLUG;
 330         features |= VISOR_CHIPSET_FEATURE_REPLY;
 331
 332 out_respond:
 333         if (inmsg->hdr.flags.response_expected)
 334                 res = controlvm_respond_chipset_init(&inmsg->hdr, rc, features);
 335
 336         return res;
 337 }
 338
 339 static int controlvm_respond(struct controlvm_message_header *msg_hdr,
 340                              int response, struct visor_segment_state *state)
 341 {
 342         struct controlvm_message outmsg;
 343
 344         controlvm_init_response(&outmsg, msg_hdr, response);
 345         if (outmsg.hdr.flags.test_message == 1)
 346                 return -EINVAL;
 347         if (state) {
 348                 outmsg.cmd.device_change_state.state = *state;
 349                 outmsg.cmd.device_change_state.flags.phys_device = 1;
 350         }
 351         return visorchannel_signalinsert(chipset_dev->controlvm_channel,
 352                                          CONTROLVM_QUEUE_REQUEST, &outmsg);
 353 }
 354
 355 enum crash_obj_type {
 356         CRASH_DEV,
 357         CRASH_BUS,
 358 };
 359
 360 static int save_crash_message(struct controlvm_message *msg,
 361                               enum crash_obj_type cr_type)
 362 {
 363         u32 local_crash_msg_offset;
 364         u16 local_crash_msg_count;
 365         int err;
 366
 367         err = visorchannel_read(chipset_dev->controlvm_channel,
 368                                 offsetof(struct visor_controlvm_channel,
 369                                          saved_crash_message_count),
 370                                 &local_crash_msg_count, sizeof(u16));
 371         if (err) {
 372                 dev_err(&chipset_dev->acpi_device->dev,
 373                         "failed to read message count\n");
 374                 return err;
 375         }
 376         if (local_crash_msg_count != CONTROLVM_CRASHMSG_MAX) {
 377                 dev_err(&chipset_dev->acpi_device->dev,
 378                         "invalid number of messages\n");
 379                 return -EIO;
 380         }
 381         err = visorchannel_read(chipset_dev->controlvm_channel,
 382                                 offsetof(struct visor_controlvm_channel,
 383                                          saved_crash_message_offset),
 384                                 &local_crash_msg_offset, sizeof(u32));
 385         if (err) {
 386                 dev_err(&chipset_dev->acpi_device->dev,
 387                         "failed to read offset\n");
 388                 return err;
 389         }
 390         switch (cr_type) {
 391         case CRASH_DEV:
 392                 local_crash_msg_offset += sizeof(struct controlvm_message);
 393                 err = visorchannel_write(chipset_dev->controlvm_channel,
 394                                          local_crash_msg_offset, msg,
 395                                          sizeof(struct controlvm_message));
 396                 if (err) {
 397                         dev_err(&chipset_dev->acpi_device->dev,
 398                                 "failed to write dev msg\n");
 399                         return err;
 400                 }
 401                 break;
 402         case CRASH_BUS:
 403                 err = visorchannel_write(chipset_dev->controlvm_channel,
 404                                          local_crash_msg_offset, msg,
 405                                          sizeof(struct controlvm_message));
 406                 if (err) {
 407                         dev_err(&chipset_dev->acpi_device->dev,
 408                                 "failed to write bus msg\n");
 409                         return err;
 410                 }
 411                 break;
 412         default:
 413                 dev_err(&chipset_dev->acpi_device->dev,
 414                         "Invalid crash_obj_type\n");
 415                 break;
 416         }
 417         return 0;
 418 }
 419
 420 static int controlvm_responder(enum controlvm_id cmd_id,
 421                                struct controlvm_message_header *pending_msg_hdr,
 422                                int response)
 423 {
 424         if (pending_msg_hdr->id != (u32)cmd_id)
 425                 return -EINVAL;
 426
 427         return controlvm_respond(pending_msg_hdr, response, NULL);
 428 }
 429
 430 static int device_changestate_responder(enum controlvm_id cmd_id,
 431                                         struct visor_device *p, int response,
 432                                         struct visor_segment_state state)
 433 {
 434         struct controlvm_message outmsg;
 435
 436         if (p->pending_msg_hdr->id != cmd_id)
 437                 return -EINVAL;
 438
 439         controlvm_init_response(&outmsg, p->pending_msg_hdr, response);
 440         outmsg.cmd.device_change_state.bus_no = p->chipset_bus_no;
 441         outmsg.cmd.device_change_state.dev_no = p->chipset_dev_no;
 442         outmsg.cmd.device_change_state.state = state;
 443         return visorchannel_signalinsert(chipset_dev->controlvm_channel,
 444                                          CONTROLVM_QUEUE_REQUEST, &outmsg);
 445 }
 446
 447 static int visorbus_create(struct controlvm_message *inmsg)
 448 {
 449         struct controlvm_message_packet *cmd = &inmsg->cmd;
 450         struct controlvm_message_header *pmsg_hdr;
 451         u32 bus_no = cmd->create_bus.bus_no;
 452         struct visor_device *bus_info;
 453         struct visorchannel *visorchannel;
 454         int err;
 455
 456         bus_info = visorbus_get_device_by_id(bus_no, BUS_ROOT_DEVICE, NULL);
 457         if (bus_info && bus_info->state.created == 1) {
 458                 dev_err(&chipset_dev->acpi_device->dev,
 459                         "failed %s: already exists\n", __func__);
 460                 err = -EEXIST;
 461                 goto err_respond;
 462         }
 463         bus_info = kzalloc(sizeof(*bus_info), GFP_KERNEL);
 464         if (!bus_info) {
 465                 err = -ENOMEM;
 466                 goto err_respond;
 467         }
 468         INIT_LIST_HEAD(&bus_info->list_all);
 469         bus_info->chipset_bus_no = bus_no;
 470         bus_info->chipset_dev_no = BUS_ROOT_DEVICE;
 471         if (guid_equal(&cmd->create_bus.bus_inst_guid, &visor_siovm_guid)) {
 472                 err = save_crash_message(inmsg, CRASH_BUS);
 473                 if (err)
 474                         goto err_free_bus_info;
 475         }
 476         if (inmsg->hdr.flags.response_expected == 1) {
 477                 pmsg_hdr = kzalloc(sizeof(*pmsg_hdr), GFP_KERNEL);
 478                 if (!pmsg_hdr) {
 479                         err = -ENOMEM;
 480                         goto err_free_bus_info;
 481                 }
 482                 memcpy(pmsg_hdr, &inmsg->hdr,
 483                        sizeof(struct controlvm_message_header));
 484                 bus_info->pending_msg_hdr = pmsg_hdr;
 485         }
 486         visorchannel = visorchannel_create(cmd->create_bus.channel_addr,
 487                                            GFP_KERNEL,
 488                                            &cmd->create_bus.bus_data_type_guid,
 489                                            false);
 490         if (!visorchannel) {
 491                 err = -ENOMEM;
 492                 goto err_free_pending_msg;
 493         }
 494         bus_info->visorchannel = visorchannel;
 495         /* Response will be handled by visorbus_create_instance on success */
 496         err = visorbus_create_instance(bus_info);
 497         if (err)
 498                 goto err_destroy_channel;
 499         return 0;
 500
 501 err_destroy_channel:
 502         visorchannel_destroy(visorchannel);
 503
 504 err_free_pending_msg:
 505         kfree(bus_info->pending_msg_hdr);
 506
 507 err_free_bus_info:
 508         kfree(bus_info);
 509
 510 err_respond:
 511         if (inmsg->hdr.flags.response_expected == 1)
 512                 controlvm_responder(inmsg->hdr.id, &inmsg->hdr, err);
 513         return err;
 514 }
 515
 516 static int visorbus_destroy(struct controlvm_message *inmsg)
 517 {
 518         struct controlvm_message_header *pmsg_hdr;
 519         u32 bus_no = inmsg->cmd.destroy_bus.bus_no;
 520         struct visor_device *bus_info;
 521         int err;
 522
 523         bus_info = visorbus_get_device_by_id(bus_no, BUS_ROOT_DEVICE, NULL);
 524         if (!bus_info) {
 525                 err = -ENODEV;
 526                 goto err_respond;
 527         }
 528         if (bus_info->state.created == 0) {
 529                 err = -ENOENT;
 530                 goto err_respond;
 531         }
 532         if (bus_info->pending_msg_hdr) {
 533                 /* only non-NULL if dev is still waiting on a response */
 534                 err = -EEXIST;
 535                 goto err_respond;
 536         }
 537         if (inmsg->hdr.flags.response_expected == 1) {
 538                 pmsg_hdr = kzalloc(sizeof(*pmsg_hdr), GFP_KERNEL);
 539                 if (!pmsg_hdr) {
 540                         err = -ENOMEM;
 541                         goto err_respond;
 542                 }
 543                 memcpy(pmsg_hdr, &inmsg->hdr,
 544                        sizeof(struct controlvm_message_header));
 545                 bus_info->pending_msg_hdr = pmsg_hdr;
 546         }
 547         /* Response will be handled by visorbus_remove_instance */
 548         visorbus_remove_instance(bus_info);
 549         return 0;
 550
 551 err_respond:
 552         if (inmsg->hdr.flags.response_expected == 1)
 553                 controlvm_responder(inmsg->hdr.id, &inmsg->hdr, err);
 554         return err;
 555 }
 556
 557 static const guid_t *parser_id_get(struct parser_context *ctx)
 558 {
 559         return &ctx->data.id;
 560 }
 561
 562 static void *parser_string_get(u8 *pscan, int nscan)
 563 {
 564         int value_length;
 565         void *value;
 566
 567         if (nscan == 0)
 568                 return NULL;
 569
 570         value_length = strnlen(pscan, nscan);
 571         value = kzalloc(value_length + 1, GFP_KERNEL);
 572         if (!value)
 573                 return NULL;
 574         if (value_length > 0)
 575                 memcpy(value, pscan, value_length);
 576         return value;
 577 }
 578
 579 static void *parser_name_get(struct parser_context *ctx)
 580 {
 581         struct visor_controlvm_parameters_header *phdr;
 582
 583         phdr = &ctx->data;
 584         if ((unsigned long)phdr->name_offset +
 585             (unsigned long)phdr->name_length > ctx->param_bytes)
 586                 return NULL;
 587         ctx->curr = (char *)&phdr + phdr->name_offset;
 588         ctx->bytes_remaining = phdr->name_length;
 589         return parser_string_get(ctx->curr, phdr->name_length);
 590 }
 591
 592 static int visorbus_configure(struct controlvm_message *inmsg,
 593                               struct parser_context *parser_ctx)
 594 {
 595         struct controlvm_message_packet *cmd = &inmsg->cmd;
 596         u32 bus_no;
 597         struct visor_device *bus_info;
 598         int err = 0;
 599
 600         bus_no = cmd->configure_bus.bus_no;
 601         bus_info = visorbus_get_device_by_id(bus_no, BUS_ROOT_DEVICE, NULL);
 602         if (!bus_info) {
 603                 err = -EINVAL;
 604                 goto err_respond;
 605         }
 606         if (bus_info->state.created == 0) {
 607                 err = -EINVAL;
 608                 goto err_respond;
 609         }
 610         if (bus_info->pending_msg_hdr) {
 611                 err = -EIO;
 612                 goto err_respond;
 613         }
 614         err = visorchannel_set_clientpartition(bus_info->visorchannel,
 615                                                cmd->configure_bus.guest_handle);
 616         if (err)
 617                 goto err_respond;
 618         if (parser_ctx) {
 619                 const guid_t *partition_guid = parser_id_get(parser_ctx);
 620
 621                 guid_copy(&bus_info->partition_guid, partition_guid);
 622                 bus_info->name = parser_name_get(parser_ctx);
 623         }
 624         if (inmsg->hdr.flags.response_expected == 1)
 625                 controlvm_responder(inmsg->hdr.id, &inmsg->hdr, err);
 626         return 0;
 627
 628 err_respond:
 629         dev_err(&chipset_dev->acpi_device->dev,
 630                 "%s exited with err: %d\n", __func__, err);
 631         if (inmsg->hdr.flags.response_expected == 1)
 632                 controlvm_responder(inmsg->hdr.id, &inmsg->hdr, err);
 633         return err;
 634 }
 635
 636 static int visorbus_device_create(struct controlvm_message *inmsg)
 637 {
 638         struct controlvm_message_packet *cmd = &inmsg->cmd;
 639         struct controlvm_message_header *pmsg_hdr;
 640         u32 bus_no = cmd->create_device.bus_no;
 641         u32 dev_no = cmd->create_device.dev_no;
 642         struct visor_device *dev_info;
 643         struct visor_device *bus_info;
 644         struct visorchannel *visorchannel;
 645         int err;
 646
 647         bus_info = visorbus_get_device_by_id(bus_no, BUS_ROOT_DEVICE, NULL);
 648         if (!bus_info) {
 649                 dev_err(&chipset_dev->acpi_device->dev,
 650                         "failed to get bus by id: %d\n", bus_no);
 651                 err = -ENODEV;
 652                 goto err_respond;
 653         }
 654         if (bus_info->state.created == 0) {
 655                 dev_err(&chipset_dev->acpi_device->dev,
 656                         "bus not created, id: %d\n", bus_no);
 657                 err = -EINVAL;
 658                 goto err_respond;
 659         }
 660         dev_info = visorbus_get_device_by_id(bus_no, dev_no, NULL);
 661         if (dev_info && dev_info->state.created == 1) {
 662                 dev_err(&chipset_dev->acpi_device->dev,
 663                         "failed to get bus by id: %d/%d\n", bus_no, dev_no);
 664                 err = -EEXIST;
 665                 goto err_respond;
 666         }
 667
 668         dev_info = kzalloc(sizeof(*dev_info), GFP_KERNEL);
 669         if (!dev_info) {
 670                 err = -ENOMEM;
 671                 goto err_respond;
 672         }
 673         dev_info->chipset_bus_no = bus_no;
 674         dev_info->chipset_dev_no = dev_no;
 675         guid_copy(&dev_info->inst, &cmd->create_device.dev_inst_guid);
 676         dev_info->device.parent = &bus_info->device;
 677         visorchannel = visorchannel_create(cmd->create_device.channel_addr,
 678                                            GFP_KERNEL,
 679                                            &cmd->create_device.data_type_guid,
 680                                            true);
 681         if (!visorchannel) {
 682                 dev_err(&chipset_dev->acpi_device->dev,
 683                         "failed to create visorchannel: %d/%d\n",
 684                         bus_no, dev_no);
 685                 err = -ENOMEM;
 686                 goto err_free_dev_info;
 687         }
 688         dev_info->visorchannel = visorchannel;
 689         guid_copy(&dev_info->channel_type_guid,
 690                   &cmd->create_device.data_type_guid);
 691         if (guid_equal(&cmd->create_device.data_type_guid,
 692                        &visor_vhba_channel_guid)) {
 693                 err = save_crash_message(inmsg, CRASH_DEV);
 694                 if (err)
 695                         goto err_destroy_visorchannel;
 696         }
 697         if (inmsg->hdr.flags.response_expected == 1) {
 698                 pmsg_hdr = kzalloc(sizeof(*pmsg_hdr), GFP_KERNEL);
 699                 if (!pmsg_hdr) {
 700                         err = -ENOMEM;
 701                         goto err_destroy_visorchannel;
 702                 }
 703                 memcpy(pmsg_hdr, &inmsg->hdr,
 704                        sizeof(struct controlvm_message_header));
 705                 dev_info->pending_msg_hdr = pmsg_hdr;
 706         }
 707         /* create_visor_device will send response */
 708         err = create_visor_device(dev_info);
 709         if (err)
 710                 goto err_destroy_visorchannel;
 711
 712         return 0;
 713
 714 err_destroy_visorchannel:
 715         visorchannel_destroy(visorchannel);
 716
 717 err_free_dev_info:
 718         kfree(dev_info);
 719
 720 err_respond:
 721         if (inmsg->hdr.flags.response_expected == 1)
 722                 controlvm_responder(inmsg->hdr.id, &inmsg->hdr, err);
 723         return err;
 724 }
 725
 726 static int visorbus_device_changestate(struct controlvm_message *inmsg)
 727 {
 728         struct controlvm_message_packet *cmd = &inmsg->cmd;
 729         struct controlvm_message_header *pmsg_hdr;
 730         u32 bus_no = cmd->device_change_state.bus_no;
 731         u32 dev_no = cmd->device_change_state.dev_no;
 732         struct visor_segment_state state = cmd->device_change_state.state;
 733         struct visor_device *dev_info;
 734         int err = 0;
 735
 736         dev_info = visorbus_get_device_by_id(bus_no, dev_no, NULL);
 737         if (!dev_info) {
 738                 err = -ENODEV;
 739                 goto err_respond;
 740         }
 741         if (dev_info->state.created == 0) {
 742                 err = -EINVAL;
 743                 goto err_respond;
 744         }
 745         if (dev_info->pending_msg_hdr) {
 746                 /* only non-NULL if dev is still waiting on a response */
 747                 err = -EIO;
 748                 goto err_respond;
 749         }
 750
 751         if (inmsg->hdr.flags.response_expected == 1) {
 752                 pmsg_hdr = kzalloc(sizeof(*pmsg_hdr), GFP_KERNEL);
 753                 if (!pmsg_hdr) {
 754                         err = -ENOMEM;
 755                         goto err_respond;
 756                 }
 757                 memcpy(pmsg_hdr, &inmsg->hdr,
 758                        sizeof(struct controlvm_message_header));
 759                 dev_info->pending_msg_hdr = pmsg_hdr;
 760         }
 761         if (state.alive == segment_state_running.alive &&
 762             state.operating == segment_state_running.operating)
 763                 /* Response will be sent from visorchipset_device_resume */
 764                 err = visorchipset_device_resume(dev_info);
 765         /* ServerNotReady / ServerLost / SegmentStateStandby */
 766         else if (state.alive == segment_state_standby.alive &&
 767                  state.operating == segment_state_standby.operating)
 768                 /*
 769                  * technically this is standby case where server is lost.
 770                  * Response will be sent from visorchipset_device_pause.
 771                  */
 772                 err = visorchipset_device_pause(dev_info);
 773         if (err)
 774                 goto err_respond;
 775         return 0;
 776
 777 err_respond:
 778         dev_err(&chipset_dev->acpi_device->dev, "failed: %d\n", err);
 779         if (inmsg->hdr.flags.response_expected == 1)
 780                 controlvm_responder(inmsg->hdr.id, &inmsg->hdr, err);
 781         return err;
 782 }
 783
 784 static int visorbus_device_destroy(struct controlvm_message *inmsg)
 785 {
 786         struct controlvm_message_packet *cmd = &inmsg->cmd;
 787         struct controlvm_message_header *pmsg_hdr;
 788         u32 bus_no = cmd->destroy_device.bus_no;
 789         u32 dev_no = cmd->destroy_device.dev_no;
 790         struct visor_device *dev_info;
 791         int err;
 792
 793         dev_info = visorbus_get_device_by_id(bus_no, dev_no, NULL);
 794         if (!dev_info) {
 795                 err = -ENODEV;
 796                 goto err_respond;
 797         }
 798         if (dev_info->state.created == 0) {
 799                 err = -EINVAL;
 800                 goto err_respond;
 801         }
 802         if (dev_info->pending_msg_hdr) {
 803                 /* only non-NULL if dev is still waiting on a response */
 804                 err = -EIO;
 805                 goto err_respond;
 806         }
 807         if (inmsg->hdr.flags.response_expected == 1) {
 808                 pmsg_hdr = kzalloc(sizeof(*pmsg_hdr), GFP_KERNEL);
 809                 if (!pmsg_hdr) {
 810                         err = -ENOMEM;
 811                         goto err_respond;
 812                 }
 813
 814                 memcpy(pmsg_hdr, &inmsg->hdr,
 815                        sizeof(struct controlvm_message_header));
 816                 dev_info->pending_msg_hdr = pmsg_hdr;
 817         }
 818         kfree(dev_info->name);
 819         remove_visor_device(dev_info);
 820         return 0;
 821
 822 err_respond:
 823         if (inmsg->hdr.flags.response_expected == 1)
 824                 controlvm_responder(inmsg->hdr.id, &inmsg->hdr, err);
 825         return err;
 826 }
 827
 828 /*
 829  * The general parahotplug flow works as follows. The visorchipset receives
 830  * a DEVICE_CHANGESTATE message from Command specifying a physical device
 831  * to enable or disable. The CONTROLVM message handler calls
 832  * parahotplug_process_message, which then adds the message to a global list
 833  * and kicks off a udev event which causes a user level script to enable or
 834  * disable the specified device. The udev script then writes to
 835  * /sys/devices/platform/visorchipset/parahotplug, which causes the
 836  * parahotplug store functions to get called, at which point the
 837  * appropriate CONTROLVM message is retrieved from the list and responded to.
 838  */
 839
 840 #define PARAHOTPLUG_TIMEOUT_MS 2000
 841
 842 /*
 843  * parahotplug_next_id() - generate unique int to match an outstanding
 844  *                         CONTROLVM message with a udev script /sys
 845  *                         response
 846  *
 847  * Return: a unique integer value
 848  */
 849 static int parahotplug_next_id(void)
 850 {
 851         static atomic_t id = ATOMIC_INIT(0);
 852
 853         return atomic_inc_return(&id);
 854 }
 855
 856 /*
 857  * parahotplug_next_expiration() - returns the time (in jiffies) when a
 858  *                                 CONTROLVM message on the list should expire
 859  *                                 -- PARAHOTPLUG_TIMEOUT_MS in the future
 860  *
 861  * Return: expected expiration time (in jiffies)
 862  */
 863 static unsigned long parahotplug_next_expiration(void)
 864 {
 865         return jiffies + msecs_to_jiffies(PARAHOTPLUG_TIMEOUT_MS);
 866 }
 867
 868 /*
 869  * parahotplug_request_create() - create a parahotplug_request, which is
 870  *                                basically a wrapper for a CONTROLVM_MESSAGE
 871  *                                that we can stick on a list
 872  * @msg: the message to insert in the request
 873  *
 874  * Return: the request containing the provided message
 875  */
 876 static struct parahotplug_request *parahotplug_request_create(
 877                                                 struct controlvm_message *msg)
 878 {
 879         struct parahotplug_request *req;
 880
 881         req = kmalloc(sizeof(*req), GFP_KERNEL);
 882         if (!req)
 883                 return NULL;
 884         req->id = parahotplug_next_id();
 885         req->expiration = parahotplug_next_expiration();
 886         req->msg = *msg;
 887         return req;
 888 }
 889
 890 /*
 891  * parahotplug_request_destroy() - free a parahotplug_request
 892  * @req: the request to deallocate
 893  */
 894 static void parahotplug_request_destroy(struct parahotplug_request *req)
 895 {
 896         kfree(req);
 897 }
 898
 899 static LIST_HEAD(parahotplug_request_list);
 900 /* lock for above */
 901 static DEFINE_SPINLOCK(parahotplug_request_list_lock);
 902
 903 /*
 904  * parahotplug_request_complete() - mark request as complete
 905  * @id:     the id of the request
 906  * @active: indicates whether the request is assigned to active partition
 907  *
 908  * Called from the /sys handler, which means the user script has
 909  * finished the enable/disable. Find the matching identifier, and
 910  * respond to the CONTROLVM message with success.
 911  *
 912  * Return: 0 on success or -EINVAL on failure
 913  */
 914 static int parahotplug_request_complete(int id, u16 active)
 915 {
 916         struct list_head *pos;
 917         struct list_head *tmp;
 918         struct parahotplug_request *req;
 919
 920         spin_lock(&parahotplug_request_list_lock);
 921         /* Look for a request matching "id". */
 922         list_for_each_safe(pos, tmp, &parahotplug_request_list) {
 923                 req = list_entry(pos, struct parahotplug_request, list);
 924                 if (req->id == id) {
 925                         /*
 926                          * Found a match. Remove it from the list and
 927                          * respond.
 928                          */
 929                         list_del(pos);
 930                         spin_unlock(&parahotplug_request_list_lock);
 931                         req->msg.cmd.device_change_state.state.active = active;
 932                         if (req->msg.hdr.flags.response_expected)
 933                                 controlvm_respond(
 934                                        &req->msg.hdr, CONTROLVM_RESP_SUCCESS,
 935                                        &req->msg.cmd.device_change_state.state);
 936                         parahotplug_request_destroy(req);
 937                         return 0;
 938                 }
 939         }
 940         spin_unlock(&parahotplug_request_list_lock);
 941         return -EINVAL;
 942 }
 943
 944 /*
 945  * devicedisabled_store() - disables the hotplug device
 946  * @dev:   sysfs interface variable not utilized in this function
 947  * @attr:  sysfs interface variable not utilized in this function
 948  * @buf:   buffer containing the device id
 949  * @count: the size of the buffer
 950  *
 951  * The parahotplug/devicedisabled interface gets called by our support script
 952  * when an SR-IOV device has been shut down. The ID is passed to the script
 953  * and then passed back when the device has been removed.
 954  *
 955  * Return: the size of the buffer for success or negative for error
 956  */
 957 static ssize_t devicedisabled_store(struct device *dev,
 958                                     struct device_attribute *attr,
 959                                     const char *buf, size_t count)
 960 {
 961         unsigned int id;
 962         int err;
 963
 964         if (kstrtouint(buf, 10, &id))
 965                 return -EINVAL;
 966         err = parahotplug_request_complete(id, 0);
 967         if (err < 0)
 968                 return err;
 969         return count;
 970 }
 971 static DEVICE_ATTR_WO(devicedisabled);
 972
 973 /*
 974  * deviceenabled_store() - enables the hotplug device
 975  * @dev:   sysfs interface variable not utilized in this function
 976  * @attr:  sysfs interface variable not utilized in this function
 977  * @buf:   buffer containing the device id
 978  * @count: the size of the buffer
 979  *
 980  * The parahotplug/deviceenabled interface gets called by our support script
 981  * when an SR-IOV device has been recovered. The ID is passed to the script
 982  * and then passed back when the device has been brought back up.
 983  *
 984  * Return: the size of the buffer for success or negative for error
 985  */
 986 static ssize_t deviceenabled_store(struct device *dev,
 987                                    struct device_attribute *attr,
 988                                    const char *buf, size_t count)
 989 {
 990         unsigned int id;
 991
 992         if (kstrtouint(buf, 10, &id))
 993                 return -EINVAL;
 994         parahotplug_request_complete(id, 1);
 995         return count;
 996 }
 997 static DEVICE_ATTR_WO(deviceenabled);
 998
 999 static struct attribute *visorchipset_install_attrs[] = {
1000         &dev_attr_toolaction.attr,
1001         &dev_attr_boottotool.attr,
1002         &dev_attr_error.attr,
1003         &dev_attr_textid.attr,
1004         &dev_attr_remaining_steps.attr,
1005         NULL
1006 };
1007
1008 static const struct attribute_group visorchipset_install_group = {
1009         .name = "install",
1010         .attrs = visorchipset_install_attrs
1011 };
1012
1013 static struct attribute *visorchipset_parahotplug_attrs[] = {
1014         &dev_attr_devicedisabled.attr,
1015         &dev_attr_deviceenabled.attr,
1016         NULL
1017 };
1018
1019 static const struct attribute_group visorchipset_parahotplug_group = {
1020         .name = "parahotplug",
1021         .attrs = visorchipset_parahotplug_attrs
1022 };
1023
1024 static const struct attribute_group *visorchipset_dev_groups[] = {
1025         &visorchipset_install_group,
1026         &visorchipset_parahotplug_group,
1027         NULL
1028 };
1029
1030 /*
1031  * parahotplug_request_kickoff() - initiate parahotplug request
1032  * @req: the request to initiate
1033  *
1034  * Cause uevent to run the user level script to do the disable/enable specified
1035  * in the parahotplug_request.
1036  */
1037 static int parahotplug_request_kickoff(struct parahotplug_request *req)
1038 {
1039         struct controlvm_message_packet *cmd = &req->msg.cmd;
1040         char env_cmd[40], env_id[40], env_state[40], env_bus[40], env_dev[40],
1041              env_func[40];
1042         char *envp[] = { env_cmd, env_id, env_state, env_bus, env_dev,
1043                          env_func, NULL
1044         };
1045
1046         sprintf(env_cmd, "VISOR_PARAHOTPLUG=1");
1047         sprintf(env_id, "VISOR_PARAHOTPLUG_ID=%d", req->id);
1048         sprintf(env_state, "VISOR_PARAHOTPLUG_STATE=%d",
1049                 cmd->device_change_state.state.active);
1050         sprintf(env_bus, "VISOR_PARAHOTPLUG_BUS=%d",
1051                 cmd->device_change_state.bus_no);
1052         sprintf(env_dev, "VISOR_PARAHOTPLUG_DEVICE=%d",
1053                 cmd->device_change_state.dev_no >> 3);
1054         sprintf(env_func, "VISOR_PARAHOTPLUG_FUNCTION=%d",
1055                 cmd->device_change_state.dev_no & 0x7);
1056         return kobject_uevent_env(&chipset_dev->acpi_device->dev.kobj,
1057                                   KOBJ_CHANGE, envp);
1058 }
1059
1060 /*
1061  * parahotplug_process_message() - enables or disables a PCI device by kicking
1062  *                                 off a udev script
1063  * @inmsg: the message indicating whether to enable or disable
1064  */
1065 static int parahotplug_process_message(struct controlvm_message *inmsg)
1066 {
1067         struct parahotplug_request *req;
1068         int err;
1069
1070         req = parahotplug_request_create(inmsg);
1071         if (!req)
1072                 return -ENOMEM;
1073         /*
1074          * For enable messages, just respond with success right away, we don't
1075          * need to wait to see if the enable was successful.
1076          */
1077         if (inmsg->cmd.device_change_state.state.active) {
1078                 err = parahotplug_request_kickoff(req);
1079                 if (err)
1080                         goto err_respond;
1081                 controlvm_respond(&inmsg->hdr, CONTROLVM_RESP_SUCCESS,
1082                                   &inmsg->cmd.device_change_state.state);
1083                 parahotplug_request_destroy(req);
1084                 return 0;
1085         }
1086         /*
1087          * For disable messages, add the request to the request list before
1088          * kicking off the udev script. It won't get responded to until the
1089          * script has indicated it's done.
1090          */
1091         spin_lock(&parahotplug_request_list_lock);
1092         list_add_tail(&req->list, &parahotplug_request_list);
1093         spin_unlock(&parahotplug_request_list_lock);
1094         err = parahotplug_request_kickoff(req);
1095         if (err)
1096                 goto err_respond;
1097         return 0;
1098
1099 err_respond:
1100         controlvm_respond(&inmsg->hdr, err,
1101                           &inmsg->cmd.device_change_state.state);
1102         return err;
1103 }
1104
1105 /*
1106  * chipset_ready_uevent() - sends chipset_ready action
1107  *
1108  * Send ACTION=online for DEVPATH=/sys/devices/platform/visorchipset.
1109  *
1110  * Return: 0 on success, negative on failure
1111  */
1112 static int chipset_ready_uevent(struct controlvm_message_header *msg_hdr)
1113 {
1114         int res;
1115
1116         res = kobject_uevent(&chipset_dev->acpi_device->dev.kobj, KOBJ_ONLINE);
1117         if (msg_hdr->flags.response_expected)
1118                 controlvm_respond(msg_hdr, res, NULL);
1119         return res;
1120 }
1121
1122 /*
1123  * chipset_selftest_uevent() - sends chipset_selftest action
1124  *
1125  * Send ACTION=online for DEVPATH=/sys/devices/platform/visorchipset.
1126  *
1127  * Return: 0 on success, negative on failure
1128  */
1129 static int chipset_selftest_uevent(struct controlvm_message_header *msg_hdr)
1130 {
1131         char env_selftest[20];
1132         char *envp[] = { env_selftest, NULL };
1133         int res;
1134
1135         sprintf(env_selftest, "SPARSP_SELFTEST=%d", 1);
1136         res = kobject_uevent_env(&chipset_dev->acpi_device->dev.kobj,
1137                                  KOBJ_CHANGE, envp);
1138         if (msg_hdr->flags.response_expected)
1139                 controlvm_respond(msg_hdr, res, NULL);
1140         return res;
1141 }
1142
1143 /*
1144  * chipset_notready_uevent() - sends chipset_notready action
1145  *
1146  * Send ACTION=offline for DEVPATH=/sys/devices/platform/visorchipset.
1147  *
1148  * Return: 0 on success, negative on failure
1149  */
1150 static int chipset_notready_uevent(struct controlvm_message_header *msg_hdr)
1151 {
1152         int res = kobject_uevent(&chipset_dev->acpi_device->dev.kobj,
1153                                  KOBJ_OFFLINE);
1154
1155         if (msg_hdr->flags.response_expected)
1156                 controlvm_respond(msg_hdr, res, NULL);
1157         return res;
1158 }
1159
1160 static int unisys_vmcall(unsigned long tuple, unsigned long param)
1161 {
1162         int result = 0;
1163         unsigned int cpuid_eax, cpuid_ebx, cpuid_ecx, cpuid_edx;
1164         unsigned long reg_ebx;
1165         unsigned long reg_ecx;
1166
1167         reg_ebx = param & 0xFFFFFFFF;
1168         reg_ecx = param >> 32;
1169         cpuid(0x00000001, &cpuid_eax, &cpuid_ebx, &cpuid_ecx, &cpuid_edx);
1170         if (!(cpuid_ecx & 0x80000000))
1171                 return -EPERM;
1172         __asm__ __volatile__(".byte 0x00f, 0x001, 0x0c1" : "=a"(result) :
1173                              "a"(tuple), "b"(reg_ebx), "c"(reg_ecx));
1174         if (result)
1175                 goto error;
1176         return 0;
1177
1178 /* Need to convert from VMCALL error codes to Linux */
1179 error:
1180         switch (result) {
1181         case VMCALL_RESULT_INVALID_PARAM:
1182                 return -EINVAL;
1183         case VMCALL_RESULT_DATA_UNAVAILABLE:
1184                 return -ENODEV;
1185         default:
1186                 return -EFAULT;
1187         }
1188 }
1189
1190 static int controlvm_channel_create(struct visorchipset_device *dev)
1191 {
1192         struct visorchannel *chan;
1193         u64 addr;
1194         int err;
1195
1196         err = unisys_vmcall(VMCALL_CONTROLVM_ADDR,
1197                             virt_to_phys(&dev->controlvm_params));
1198         if (err)
1199                 return err;
1200         addr = dev->controlvm_params.address;
1201         chan = visorchannel_create(addr, GFP_KERNEL,
1202                                    &visor_controlvm_channel_guid, true);
1203         if (!chan)
1204                 return -ENOMEM;
1205         dev->controlvm_channel = chan;
1206         return 0;
1207 }
1208
1209 static void setup_crash_devices_work_queue(struct work_struct *work)
1210 {
1211         struct controlvm_message local_crash_bus_msg;
1212         struct controlvm_message local_crash_dev_msg;
1213         struct controlvm_message msg = {
1214                 .hdr.id = CONTROLVM_CHIPSET_INIT,
1215                 .cmd.init_chipset = {
1216                         .bus_count = 23,
1217                         .switch_count = 0,
1218                 },
1219         };
1220         u32 local_crash_msg_offset;
1221         u16 local_crash_msg_count;
1222
1223         /* send init chipset msg */
1224         chipset_init(&msg);
1225         /* get saved message count */
1226         if (visorchannel_read(chipset_dev->controlvm_channel,
1227                               offsetof(struct visor_controlvm_channel,
1228                                        saved_crash_message_count),
1229                               &local_crash_msg_count, sizeof(u16)) < 0) {
1230                 dev_err(&chipset_dev->acpi_device->dev,
1231                         "failed to read channel\n");
1232                 return;
1233         }
1234         if (local_crash_msg_count != CONTROLVM_CRASHMSG_MAX) {
1235                 dev_err(&chipset_dev->acpi_device->dev, "invalid count\n");
1236                 return;
1237         }
1238         /* get saved crash message offset */
1239         if (visorchannel_read(chipset_dev->controlvm_channel,
1240                               offsetof(struct visor_controlvm_channel,
1241                                        saved_crash_message_offset),
1242                               &local_crash_msg_offset, sizeof(u32)) < 0) {
1243                 dev_err(&chipset_dev->acpi_device->dev,
1244                         "failed to read channel\n");
1245                 return;
1246         }
1247         /* read create device message for storage bus offset */
1248         if (visorchannel_read(chipset_dev->controlvm_channel,
1249                               local_crash_msg_offset,
1250                               &local_crash_bus_msg,
1251                               sizeof(struct controlvm_message)) < 0) {
1252                 dev_err(&chipset_dev->acpi_device->dev,
1253                         "failed to read channel\n");
1254                 return;
1255         }
1256         /* read create device message for storage device */
1257         if (visorchannel_read(chipset_dev->controlvm_channel,
1258                               local_crash_msg_offset +
1259                               sizeof(struct controlvm_message),
1260                               &local_crash_dev_msg,
1261                               sizeof(struct controlvm_message)) < 0) {
1262                 dev_err(&chipset_dev->acpi_device->dev,
1263                         "failed to read channel\n");
1264                 return;
1265         }
1266         /* reuse IOVM create bus message */
1267         if (!local_crash_bus_msg.cmd.create_bus.channel_addr) {
1268                 dev_err(&chipset_dev->acpi_device->dev,
1269                         "no valid create_bus message\n");
1270                 return;
1271         }
1272         visorbus_create(&local_crash_bus_msg);
1273         /* reuse create device message for storage device */
1274         if (!local_crash_dev_msg.cmd.create_device.channel_addr) {
1275                 dev_err(&chipset_dev->acpi_device->dev,
1276                         "no valid create_device message\n");
1277                 return;
1278         }
1279         visorbus_device_create(&local_crash_dev_msg);
1280 }
1281
1282 void visorbus_response(struct visor_device *bus_info, int response,
1283                        int controlvm_id)
1284 {
1285         if (!bus_info->pending_msg_hdr)
1286                 return;
1287
1288         controlvm_responder(controlvm_id, bus_info->pending_msg_hdr, response);
1289         kfree(bus_info->pending_msg_hdr);
1290         bus_info->pending_msg_hdr = NULL;
1291 }
1292
1293 void visorbus_device_changestate_response(struct visor_device *dev_info,
1294                                           int response,
1295                                           struct visor_segment_state state)
1296 {
1297         if (!dev_info->pending_msg_hdr)
1298                 return;
1299
1300         device_changestate_responder(CONTROLVM_DEVICE_CHANGESTATE, dev_info,
1301                                      response, state);
1302         kfree(dev_info->pending_msg_hdr);
1303         dev_info->pending_msg_hdr = NULL;
1304 }
1305
1306 static void parser_done(struct parser_context *ctx)
1307 {
1308         chipset_dev->controlvm_payload_bytes_buffered -= ctx->param_bytes;
1309         kfree(ctx);
1310 }
1311
1312 static struct parser_context *parser_init_stream(u64 addr, u32 bytes,
1313                                                  bool *retry)
1314 {
1315         unsigned long allocbytes;
1316         struct parser_context *ctx;
1317         void *mapping;
1318
1319         *retry = false;
1320         /* alloc an extra byte to ensure payload is \0 terminated */
1321         allocbytes = (unsigned long)bytes + 1 + (sizeof(struct parser_context) -
1322                      sizeof(struct visor_controlvm_parameters_header));
1323         if ((chipset_dev->controlvm_payload_bytes_buffered + bytes) >
1324              MAX_CONTROLVM_PAYLOAD_BYTES) {
1325                 *retry = true;
1326                 return NULL;
1327         }
1328         ctx = kzalloc(allocbytes, GFP_KERNEL);
1329         if (!ctx) {
1330                 *retry = true;
1331                 return NULL;
1332         }
1333         ctx->allocbytes = allocbytes;
1334         ctx->param_bytes = bytes;
1335         mapping = memremap(addr, bytes, MEMREMAP_WB);
1336         if (!mapping)
1337                 goto err_finish_ctx;
1338         memcpy(&ctx->data, mapping, bytes);
1339         memunmap(mapping);
1340         ctx->byte_stream = true;
1341         chipset_dev->controlvm_payload_bytes_buffered += ctx->param_bytes;
1342         return ctx;
1343
1344 err_finish_ctx:
1345         kfree(ctx);
1346         return NULL;
1347 }
1348
1349 /*
1350  * handle_command() - process a controlvm message
1351  * @inmsg:        the message to process
1352  * @channel_addr: address of the controlvm channel
1353  *
1354  * Return:
1355  *      0       - Successfully processed the message
1356  *      -EAGAIN - ControlVM message was not processed and should be retried
1357  *                reading the next controlvm message; a scenario where this can
1358  *                occur is when we need to throttle the allocation of memory in
1359  *                which to copy out controlvm payload data.
1360  *      < 0     - error: ControlVM message was processed but an error occurred.
1361  */
1362 static int handle_command(struct controlvm_message inmsg, u64 channel_addr)
1363 {
1364         struct controlvm_message_packet *cmd = &inmsg.cmd;
1365         u64 parm_addr;
1366         u32 parm_bytes;
1367         struct parser_context *parser_ctx = NULL;
1368         struct controlvm_message ackmsg;
1369         int err = 0;
1370
1371         /* create parsing context if necessary */
1372         parm_addr = channel_addr + inmsg.hdr.payload_vm_offset;
1373         parm_bytes = inmsg.hdr.payload_bytes;
1374         /*
1375          * Parameter and channel addresses within test messages actually lie
1376          * within our OS-controlled memory. We need to know that, because it
1377          * makes a difference in how we compute the virtual address.
1378          */
1379         if (parm_bytes) {
1380                 bool retry;
1381
1382                 parser_ctx = parser_init_stream(parm_addr, parm_bytes, &retry);
1383                 if (!parser_ctx && retry)
1384                         return -EAGAIN;
1385         }
1386         controlvm_init_response(&ackmsg, &inmsg.hdr, CONTROLVM_RESP_SUCCESS);
1387         err = visorchannel_signalinsert(chipset_dev->controlvm_channel,
1388                                         CONTROLVM_QUEUE_ACK, &ackmsg);
1389         if (err)
1390                 return err;
1391         switch (inmsg.hdr.id) {
1392         case CONTROLVM_CHIPSET_INIT:
1393                 err = chipset_init(&inmsg);
1394                 break;
1395         case CONTROLVM_BUS_CREATE:
1396                 err = visorbus_create(&inmsg);
1397                 break;
1398         case CONTROLVM_BUS_DESTROY:
1399                 err = visorbus_destroy(&inmsg);
1400                 break;
1401         case CONTROLVM_BUS_CONFIGURE:
1402                 err = visorbus_configure(&inmsg, parser_ctx);
1403                 break;
1404         case CONTROLVM_DEVICE_CREATE:
1405                 err = visorbus_device_create(&inmsg);
1406                 break;
1407         case CONTROLVM_DEVICE_CHANGESTATE:
1408                 if (cmd->device_change_state.flags.phys_device) {
1409                         err = parahotplug_process_message(&inmsg);
1410                 } else {
1411                         /*
1412                          * save the hdr and cmd structures for later use when
1413                          * sending back the response to Command
1414                          */
1415                         err = visorbus_device_changestate(&inmsg);
1416                         break;
1417                 }
1418                 break;
1419         case CONTROLVM_DEVICE_DESTROY:
1420                 err = visorbus_device_destroy(&inmsg);
1421                 break;
1422         case CONTROLVM_DEVICE_CONFIGURE:
1423                 /* no op just send a respond that we passed */
1424                 if (inmsg.hdr.flags.response_expected)
1425                         controlvm_respond(&inmsg.hdr, CONTROLVM_RESP_SUCCESS,
1426                                           NULL);
1427                 break;
1428         case CONTROLVM_CHIPSET_READY:
1429                 err = chipset_ready_uevent(&inmsg.hdr);
1430                 break;
1431         case CONTROLVM_CHIPSET_SELFTEST:
1432                 err = chipset_selftest_uevent(&inmsg.hdr);
1433                 break;
1434         case CONTROLVM_CHIPSET_STOP:
1435                 err = chipset_notready_uevent(&inmsg.hdr);
1436                 break;
1437         default:
1438                 err = -ENOMSG;
1439                 if (inmsg.hdr.flags.response_expected)
1440                         controlvm_respond(&inmsg.hdr,
1441                                           -CONTROLVM_RESP_ID_UNKNOWN, NULL);
1442                 break;
1443         }
1444         if (parser_ctx) {
1445                 parser_done(parser_ctx);
1446                 parser_ctx = NULL;
1447         }
1448         return err;
1449 }
1450
1451 /*
1452  * read_controlvm_event() - retreives the next message from the
1453  *                          CONTROLVM_QUEUE_EVENT queue in the controlvm
1454  *                          channel
1455  * @msg: pointer to the retrieved message
1456  *
1457  * Return: 0 if valid message was retrieved or -error
1458  */
1459 static int read_controlvm_event(struct controlvm_message *msg)
1460 {
1461         int err = visorchannel_signalremove(chipset_dev->controlvm_channel,
1462                                             CONTROLVM_QUEUE_EVENT, msg);
1463
1464         if (err)
1465                 return err;
1466         /* got a message */
1467         if (msg->hdr.flags.test_message == 1)
1468                 return -EINVAL;
1469         return 0;
1470 }
1471
1472 /*
1473  * parahotplug_process_list() - remove any request from the list that's been on
1474  *                              there too long and respond with an error
1475  */
1476 static void parahotplug_process_list(void)
1477 {
1478         struct list_head *pos;
1479         struct list_head *tmp;
1480
1481         spin_lock(&parahotplug_request_list_lock);
1482         list_for_each_safe(pos, tmp, &parahotplug_request_list) {
1483                 struct parahotplug_request *req =
1484                     list_entry(pos, struct parahotplug_request, list);
1485
1486                 if (!time_after_eq(jiffies, req->expiration))
1487                         continue;
1488                 list_del(pos);
1489                 if (req->msg.hdr.flags.response_expected)
1490                         controlvm_respond(
1491                                 &req->msg.hdr,
1492                                 CONTROLVM_RESP_DEVICE_UDEV_TIMEOUT,
1493                                 &req->msg.cmd.device_change_state.state);
1494                 parahotplug_request_destroy(req);
1495         }
1496         spin_unlock(&parahotplug_request_list_lock);
1497 }
1498
1499 static void controlvm_periodic_work(struct work_struct *work)
1500 {
1501         struct controlvm_message inmsg;
1502         int count = 0;
1503         int err;
1504
1505         /* Drain the RESPONSE queue make it empty */
1506         do {
1507                 err = visorchannel_signalremove(chipset_dev->controlvm_channel,
1508                                                 CONTROLVM_QUEUE_RESPONSE,
1509                                                 &inmsg);
1510         } while ((!err) && (++count < CONTROLVM_MESSAGE_MAX));
1511         if (err != -EAGAIN)
1512                 goto schedule_out;
1513         if (chipset_dev->controlvm_pending_msg_valid) {
1514                 /*
1515                  * we throttled processing of a prior msg, so try to process
1516                  * it again rather than reading a new one
1517                  */
1518                 inmsg = chipset_dev->controlvm_pending_msg;
1519                 chipset_dev->controlvm_pending_msg_valid = false;
1520                 err = 0;
1521         } else {
1522                 err = read_controlvm_event(&inmsg);
1523         }
1524         while (!err) {
1525                 chipset_dev->most_recent_message_jiffies = jiffies;
1526                 err = handle_command(inmsg,
1527                                      visorchannel_get_physaddr
1528                                      (chipset_dev->controlvm_channel));
1529                 if (err == -EAGAIN) {
1530                         chipset_dev->controlvm_pending_msg = inmsg;
1531                         chipset_dev->controlvm_pending_msg_valid = true;
1532                         break;
1533                 }
1534
1535                 err = read_controlvm_event(&inmsg);
1536         }
1537         /* parahotplug_worker */
1538         parahotplug_process_list();
1539
1540 /*
1541  * The controlvm messages are sent in a bulk. If we start receiving messages, we
1542  * want the polling to be fast. If we do not receive any message for
1543  * MIN_IDLE_SECONDS, we can slow down the polling.
1544  */
1545 schedule_out:
1546         if (time_after(jiffies, chipset_dev->most_recent_message_jiffies +
1547                                 (HZ * MIN_IDLE_SECONDS))) {
1548                 /*
1549                  * it's been longer than MIN_IDLE_SECONDS since we processed
1550                  * our last controlvm message; slow down the polling
1551                  */
1552                 if (chipset_dev->poll_jiffies != POLLJIFFIES_CONTROLVM_SLOW)
1553                         chipset_dev->poll_jiffies = POLLJIFFIES_CONTROLVM_SLOW;
1554         } else {
1555                 if (chipset_dev->poll_jiffies != POLLJIFFIES_CONTROLVM_FAST)
1556                         chipset_dev->poll_jiffies = POLLJIFFIES_CONTROLVM_FAST;
1557         }
1558         schedule_delayed_work(&chipset_dev->periodic_controlvm_work,
1559                               chipset_dev->poll_jiffies);
1560 }
1561
1562 static int visorchipset_init(struct acpi_device *acpi_device)
1563 {
1564         int err = -ENODEV;
1565         struct visorchannel *controlvm_channel;
1566
1567         chipset_dev = kzalloc(sizeof(*chipset_dev), GFP_KERNEL);
1568         if (!chipset_dev)
1569                 goto error;
1570         err = controlvm_channel_create(chipset_dev);
1571         if (err)
1572                 goto error_free_chipset_dev;
1573         acpi_device->driver_data = chipset_dev;
1574         chipset_dev->acpi_device = acpi_device;
1575         chipset_dev->poll_jiffies = POLLJIFFIES_CONTROLVM_FAST;
1576         err = sysfs_create_groups(&chipset_dev->acpi_device->dev.kobj,
1577                                   visorchipset_dev_groups);
1578         if (err < 0)
1579                 goto error_destroy_channel;
1580         controlvm_channel = chipset_dev->controlvm_channel;
1581         if (!visor_check_channel(visorchannel_get_header(controlvm_channel),
1582                                  &chipset_dev->acpi_device->dev,
1583                                  &visor_controlvm_channel_guid,
1584                                  "controlvm",
1585                                  sizeof(struct visor_controlvm_channel),
1586                                  VISOR_CONTROLVM_CHANNEL_VERSIONID,
1587                                  VISOR_CHANNEL_SIGNATURE))
1588                 goto error_delete_groups;
1589         /* if booting in a crash kernel */
1590         if (is_kdump_kernel())
1591                 INIT_DELAYED_WORK(&chipset_dev->periodic_controlvm_work,
1592                                   setup_crash_devices_work_queue);
1593         else
1594                 INIT_DELAYED_WORK(&chipset_dev->periodic_controlvm_work,
1595                                   controlvm_periodic_work);
1596         chipset_dev->most_recent_message_jiffies = jiffies;
1597         chipset_dev->poll_jiffies = POLLJIFFIES_CONTROLVM_FAST;
1598         schedule_delayed_work(&chipset_dev->periodic_controlvm_work,
1599                               chipset_dev->poll_jiffies);
1600         err = visorbus_init();
1601         if (err < 0)
1602                 goto error_cancel_work;
1603         return 0;
1604
1605 error_cancel_work:
1606         cancel_delayed_work_sync(&chipset_dev->periodic_controlvm_work);
1607
1608 error_delete_groups:
1609         sysfs_remove_groups(&chipset_dev->acpi_device->dev.kobj,
1610                             visorchipset_dev_groups);
1611
1612 error_destroy_channel:
1613         visorchannel_destroy(chipset_dev->controlvm_channel);
1614
1615 error_free_chipset_dev:
1616         kfree(chipset_dev);
1617
1618 error:
1619         dev_err(&acpi_device->dev, "failed with error %d\n", err);
1620         return err;
1621 }
1622
1623 static int visorchipset_exit(struct acpi_device *acpi_device)
1624 {
1625         visorbus_exit();
1626         cancel_delayed_work_sync(&chipset_dev->periodic_controlvm_work);
1627         sysfs_remove_groups(&chipset_dev->acpi_device->dev.kobj,
1628                             visorchipset_dev_groups);
1629         visorchannel_destroy(chipset_dev->controlvm_channel);
1630         kfree(chipset_dev);
1631         return 0;
1632 }
1633
1634 static const struct acpi_device_id unisys_device_ids[] = {
1635         {"PNP0A07", 0},
1636         {"", 0},
1637 };
1638
1639 static struct acpi_driver unisys_acpi_driver = {
1640         .name = "unisys_acpi",
1641         .class = "unisys_acpi_class",
1642         .owner = THIS_MODULE,
1643         .ids = unisys_device_ids,
1644         .ops = {
1645                 .add = visorchipset_init,
1646                 .remove = visorchipset_exit,
1647         },
1648 };
1649
1650 MODULE_DEVICE_TABLE(acpi, unisys_device_ids);
1651
1652 static __init int visorutil_spar_detect(void)
1653 {
1654         unsigned int eax, ebx, ecx, edx;
1655
1656         if (boot_cpu_has(X86_FEATURE_HYPERVISOR)) {
1657                 /* check the ID */
1658                 cpuid(UNISYS_VISOR_LEAF_ID, &eax, &ebx, &ecx, &edx);
1659                 return  (ebx == UNISYS_VISOR_ID_EBX) &&
1660                         (ecx == UNISYS_VISOR_ID_ECX) &&
1661                         (edx == UNISYS_VISOR_ID_EDX);
1662         }
1663         return 0;
1664 }
1665
1666 static int __init init_unisys(void)
1667 {
1668         int result;
1669
1670         if (!visorutil_spar_detect())
1671                 return -ENODEV;
1672         result = acpi_bus_register_driver(&unisys_acpi_driver);
1673         if (result)
1674                 return -ENODEV;
1675         pr_info("Unisys Visorchipset Driver Loaded.\n");
1676         return 0;
1677 };
1678
1679 static void __exit exit_unisys(void)
1680 {
1681         acpi_bus_unregister_driver(&unisys_acpi_driver);
1682 }
1683
1684 module_init(init_unisys);
1685 module_exit(exit_unisys);
1686
1687 MODULE_AUTHOR("Unisys");
1688 MODULE_LICENSE("GPL");
1689 MODULE_DESCRIPTION("s-Par visorbus driver for virtual device buses");