drivers/staging/unisys/uislib/uislib.c

   1 /* uislib.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 /* @ALL_INSPECTED */
  19 #define EXPORT_SYMTAB
  20 #include <linux/kernel.h>
  21 #include <linux/highmem.h>
  22 #ifdef CONFIG_MODVERSIONS
  23 #include <config/modversions.h>
  24 #endif
  25 #include <linux/module.h>
  26 #include <linux/debugfs.h>
  27
  28 #include <linux/types.h>
  29 #include <linux/uuid.h>
  30
  31 #include <linux/version.h>
  32 #include "uniklog.h"
  33 #include "diagnostics/appos_subsystems.h"
  34 #include "uisutils.h"
  35 #include "vbuschannel.h"
  36
  37 #include <linux/proc_fs.h>
  38 #include <linux/uaccess.h>      /* for copy_from_user */
  39 #include <linux/ctype.h>        /* for toupper */
  40 #include <linux/list.h>
  41
  42 #include "sparstop.h"
  43 #include "visorchipset.h"
  44 #include "chanstub.h"
  45 #include "version.h"
  46 #include "guestlinuxdebug.h"
  47
  48 #define SET_PROC_OWNER(x, y)
  49
  50 #define POLLJIFFIES_NORMAL 1
  51 /* Choose whether or not you want to wakeup the request-polling thread
  52  * after an IO termination:
  53  * this is shorter than using __FILE__ (full path name) in
  54  * debug/info/error messages
  55  */
  56 #define CURRENT_FILE_PC UISLIB_PC_uislib_c
  57 #define __MYFILE__ "uislib.c"
  58
  59 /* global function pointers that act as callback functions into virtpcimod */
  60 int (*virt_control_chan_func)(struct guest_msgs *);
  61
  62 static int ProcReadBufferValid;
  63 static char *ProcReadBuffer;    /* Note this MUST be global,
  64                                          * because the contents must */
  65 static unsigned int chipset_inited;
  66
  67 #define WAIT_ON_CALLBACK(handle)        \
  68         do {                    \
  69                 if (handle)             \
  70                         break;          \
  71                 UIS_THREAD_WAIT;        \
  72         } while (1)
  73
  74 static struct bus_info *BusListHead;
  75 static rwlock_t BusListLock;
  76 static int BusListCount;        /* number of buses in the list */
  77 static int MaxBusCount;         /* maximum number of buses expected */
  78 static u64 PhysicalDataChan;
  79 static int PlatformNumber;
  80
  81 static struct uisthread_info Incoming_ThreadInfo;
  82 static BOOL Incoming_Thread_Started = FALSE;
  83 static LIST_HEAD(List_Polling_Device_Channels);
  84 static unsigned long long tot_moved_to_tail_cnt;
  85 static unsigned long long tot_wait_cnt;
  86 static unsigned long long tot_wakeup_cnt;
  87 static unsigned long long tot_schedule_cnt;
  88 static int en_smart_wakeup = 1;
  89 static DEFINE_SEMAPHORE(Lock_Polling_Device_Channels);  /* unlocked */
  90 static DECLARE_WAIT_QUEUE_HEAD(Wakeup_Polling_Device_Channels);
  91 static int Go_Polling_Device_Channels;
  92
  93 #define CALLHOME_PROC_ENTRY_FN "callhome"
  94 #define CALLHOME_THROTTLED_PROC_ENTRY_FN "callhome_throttled"
  95
  96 #define DIR_DEBUGFS_ENTRY "uislib"
  97 static struct dentry *dir_debugfs;
  98
  99 #define PLATFORMNUMBER_DEBUGFS_ENTRY_FN "platform"
 100 static struct dentry *platformnumber_debugfs_read;
 101
 102 #define CYCLES_BEFORE_WAIT_DEBUGFS_ENTRY_FN "cycles_before_wait"
 103 static struct dentry *cycles_before_wait_debugfs_read;
 104
 105 #define SMART_WAKEUP_DEBUGFS_ENTRY_FN "smart_wakeup"
 106 static struct dentry *smart_wakeup_debugfs_entry;
 107
 108 #define INFO_DEBUGFS_ENTRY_FN "info"
 109 static struct dentry *info_debugfs_entry;
 110
 111 static unsigned long long cycles_before_wait, wait_cycles;
 112
 113 /*****************************************************/
 114 /* local functions                                   */
 115 /*****************************************************/
 116
 117 static ssize_t info_debugfs_read(struct file *file, char __user *buf,
 118                               size_t len, loff_t *offset);
 119 static const struct file_operations debugfs_info_fops = {
 120         .read = info_debugfs_read,
 121 };
 122
 123 static void
 124 init_msg_header(struct controlvm_message *msg, u32 id, uint rsp, uint svr)
 125 {
 126         memset(msg, 0, sizeof(struct controlvm_message));
 127         msg->hdr.id = id;
 128         msg->hdr.flags.response_expected = rsp;
 129         msg->hdr.flags.server = svr;
 130 }
 131
 132 static __iomem void *
 133 init_vbus_channel(u64 channelAddr, u32 channelBytes)
 134 {
 135         void __iomem *rc = NULL;
 136         void __iomem *pChan = uislib_ioremap_cache(channelAddr, channelBytes);
 137
 138         if (!pChan) {
 139                 LOGERR("CONTROLVM_BUS_CREATE error: ioremap_cache of channelAddr:%Lx for channelBytes:%llu failed",
 140                      (unsigned long long) channelAddr,
 141                      (unsigned long long) channelBytes);
 142                 rc = NULL;
 143                 goto Away;
 144         }
 145         if (!SPAR_VBUS_CHANNEL_OK_CLIENT(pChan, NULL)) {
 146                 ERRDRV("%s channel cannot be used", __func__);
 147                 uislib_iounmap(pChan);
 148                 rc = NULL;
 149                 goto Away;
 150         }
 151         rc = pChan;
 152 Away:
 153         return rc;
 154 }
 155
 156 static int
 157 create_bus(struct controlvm_message *msg, char *buf)
 158 {
 159         u32 busNo, deviceCount;
 160         struct bus_info *tmp, *bus;
 161         size_t size;
 162
 163         if (MaxBusCount == BusListCount) {
 164                 LOGERR("CONTROLVM_BUS_CREATE Failed: max buses:%d already created\n",
 165                      MaxBusCount);
 166                 POSTCODE_LINUX_3(BUS_CREATE_FAILURE_PC, MaxBusCount,
 167                                  POSTCODE_SEVERITY_ERR);
 168                 return CONTROLVM_RESP_ERROR_MAX_BUSES;
 169         }
 170
 171         busNo = msg->cmd.create_bus.bus_no;
 172         deviceCount = msg->cmd.create_bus.dev_count;
 173
 174         POSTCODE_LINUX_4(BUS_CREATE_ENTRY_PC, busNo, deviceCount,
 175                          POSTCODE_SEVERITY_INFO);
 176
 177         size =
 178             sizeof(struct bus_info) +
 179             (deviceCount * sizeof(struct device_info *));
 180         bus = kzalloc(size, GFP_ATOMIC);
 181         if (!bus) {
 182                 LOGERR("CONTROLVM_BUS_CREATE Failed: kmalloc for bus failed.\n");
 183                 POSTCODE_LINUX_3(BUS_CREATE_FAILURE_PC, busNo,
 184                                  POSTCODE_SEVERITY_ERR);
 185                 return CONTROLVM_RESP_ERROR_KMALLOC_FAILED;
 186         }
 187
 188         /* Currently by default, the bus Number is the GuestHandle.
 189          * Configure Bus message can override this.
 190          */
 191         if (msg->hdr.flags.test_message) {
 192                 /* This implies we're the IOVM so set guest handle to 0... */
 193                 bus->guest_handle = 0;
 194                 bus->bus_no = busNo;
 195                 bus->local_vnic = 1;
 196         } else
 197                 bus->bus_no = bus->guest_handle = busNo;
 198         sprintf(bus->name, "%d", (int) bus->bus_no);
 199         bus->device_count = deviceCount;
 200         bus->device =
 201             (struct device_info **) ((char *) bus + sizeof(struct bus_info));
 202         bus->bus_inst_uuid = msg->cmd.create_bus.bus_inst_uuid;
 203         bus->bus_channel_bytes = 0;
 204         bus->bus_channel = NULL;
 205
 206         /* add bus to our bus list - but check for duplicates first */
 207         read_lock(&BusListLock);
 208         for (tmp = BusListHead; tmp; tmp = tmp->next) {
 209                 if (tmp->bus_no == bus->bus_no)
 210                         break;
 211         }
 212         read_unlock(&BusListLock);
 213         if (tmp) {
 214                 /* found a bus already in the list with same busNo -
 215                  * reject add
 216                  */
 217                 LOGERR("CONTROLVM_BUS_CREATE Failed: bus %d already exists.\n",
 218                        bus->bus_no);
 219                 POSTCODE_LINUX_3(BUS_CREATE_FAILURE_PC, bus->bus_no,
 220                                  POSTCODE_SEVERITY_ERR);
 221                 kfree(bus);
 222                 return CONTROLVM_RESP_ERROR_ALREADY_DONE;
 223         }
 224         if ((msg->cmd.create_bus.channel_addr != 0)
 225             && (msg->cmd.create_bus.channel_bytes != 0)) {
 226                 bus->bus_channel_bytes = msg->cmd.create_bus.channel_bytes;
 227                 bus->bus_channel =
 228                     init_vbus_channel(msg->cmd.create_bus.channel_addr,
 229                                       msg->cmd.create_bus.channel_bytes);
 230         }
 231         /* the msg is bound for virtpci; send guest_msgs struct to callback */
 232         if (!msg->hdr.flags.server) {
 233                 struct guest_msgs cmd;
 234
 235                 cmd.msgtype = GUEST_ADD_VBUS;
 236                 cmd.add_vbus.bus_no = busNo;
 237                 cmd.add_vbus.chanptr = bus->bus_channel;
 238                 cmd.add_vbus.dev_count = deviceCount;
 239                 cmd.add_vbus.bus_uuid = msg->cmd.create_bus.bus_data_type_uuid;
 240                 cmd.add_vbus.instance_uuid = msg->cmd.create_bus.bus_inst_uuid;
 241                 if (!virt_control_chan_func) {
 242                         LOGERR("CONTROLVM_BUS_CREATE Failed: virtpci callback not registered.");
 243                         POSTCODE_LINUX_3(BUS_CREATE_FAILURE_PC, bus->bus_no,
 244                                          POSTCODE_SEVERITY_ERR);
 245                         kfree(bus);
 246                         return CONTROLVM_RESP_ERROR_VIRTPCI_DRIVER_FAILURE;
 247                 }
 248                 if (!virt_control_chan_func(&cmd)) {
 249                         LOGERR("CONTROLVM_BUS_CREATE Failed: virtpci GUEST_ADD_VBUS returned error.");
 250                         POSTCODE_LINUX_3(BUS_CREATE_FAILURE_PC, bus->bus_no,
 251                                          POSTCODE_SEVERITY_ERR);
 252                         kfree(bus);
 253                         return
 254                             CONTROLVM_RESP_ERROR_VIRTPCI_DRIVER_CALLBACK_ERROR;
 255                 }
 256         }
 257
 258         /* add bus at the head of our list */
 259         write_lock(&BusListLock);
 260         if (!BusListHead)
 261                 BusListHead = bus;
 262         else {
 263                 bus->next = BusListHead;
 264                 BusListHead = bus;
 265         }
 266         BusListCount++;
 267         write_unlock(&BusListLock);
 268
 269         POSTCODE_LINUX_3(BUS_CREATE_EXIT_PC, bus->bus_no,
 270                          POSTCODE_SEVERITY_INFO);
 271         return CONTROLVM_RESP_SUCCESS;
 272 }
 273
 274 static int
 275 destroy_bus(struct controlvm_message *msg, char *buf)
 276 {
 277         int i;
 278         struct bus_info *bus, *prev = NULL;
 279         struct guest_msgs cmd;
 280         u32 busNo;
 281
 282         busNo = msg->cmd.destroy_bus.bus_no;
 283
 284         read_lock(&BusListLock);
 285
 286         bus = BusListHead;
 287         while (bus) {
 288                 if (bus->bus_no == busNo)
 289                         break;
 290                 prev = bus;
 291                 bus = bus->next;
 292         }
 293
 294         if (!bus) {
 295                 LOGERR("CONTROLVM_BUS_DESTROY Failed: failed to find bus %d.\n",
 296                        busNo);
 297                 read_unlock(&BusListLock);
 298                 return CONTROLVM_RESP_ERROR_ALREADY_DONE;
 299         }
 300
 301         /* verify that this bus has no devices. */
 302         for (i = 0; i < bus->device_count; i++) {
 303                 if (bus->device[i] != NULL) {
 304                         LOGERR("CONTROLVM_BUS_DESTROY Failed: device %i attached to bus %d.",
 305                              i, busNo);
 306                         read_unlock(&BusListLock);
 307                         return CONTROLVM_RESP_ERROR_BUS_DEVICE_ATTACHED;
 308                 }
 309         }
 310         read_unlock(&BusListLock);
 311
 312         if (msg->hdr.flags.server)
 313                 goto remove;
 314
 315         /* client messages require us to call the virtpci callback associated
 316            with this bus. */
 317         cmd.msgtype = GUEST_DEL_VBUS;
 318         cmd.del_vbus.bus_no = busNo;
 319         if (!virt_control_chan_func) {
 320                 LOGERR("CONTROLVM_BUS_DESTROY Failed: virtpci callback not registered.");
 321                 return CONTROLVM_RESP_ERROR_VIRTPCI_DRIVER_FAILURE;
 322         }
 323         if (!virt_control_chan_func(&cmd)) {
 324                 LOGERR("CONTROLVM_BUS_DESTROY Failed: virtpci GUEST_DEL_VBUS returned error.");
 325                 return CONTROLVM_RESP_ERROR_VIRTPCI_DRIVER_CALLBACK_ERROR;
 326         }
 327
 328         /* finally, remove the bus from the list */
 329 remove:
 330         write_lock(&BusListLock);
 331         if (prev)       /* not at head */
 332                 prev->next = bus->next;
 333         else
 334                 BusListHead = bus->next;
 335         BusListCount--;
 336         write_unlock(&BusListLock);
 337
 338         if (bus->bus_channel) {
 339                 uislib_iounmap(bus->bus_channel);
 340                 bus->bus_channel = NULL;
 341         }
 342
 343         kfree(bus);
 344         return CONTROLVM_RESP_SUCCESS;
 345 }
 346
 347 static int
 348 create_device(struct controlvm_message *msg, char *buf)
 349 {
 350         struct device_info *dev;
 351         struct bus_info *bus;
 352         u32 busNo, devNo;
 353         int result = CONTROLVM_RESP_SUCCESS;
 354         u64 minSize = MIN_IO_CHANNEL_SIZE;
 355         struct req_handler_info *pReqHandler;
 356
 357         busNo = msg->cmd.create_device.bus_no;
 358         devNo = msg->cmd.create_device.dev_no;
 359
 360         POSTCODE_LINUX_4(DEVICE_CREATE_ENTRY_PC, devNo, busNo,
 361                          POSTCODE_SEVERITY_INFO);
 362
 363         dev = kzalloc(sizeof(struct device_info), GFP_ATOMIC);
 364         if (!dev) {
 365                 LOGERR("CONTROLVM_DEVICE_CREATE Failed: kmalloc for dev failed.\n");
 366                 POSTCODE_LINUX_4(DEVICE_CREATE_FAILURE_PC, devNo, busNo,
 367                                  POSTCODE_SEVERITY_ERR);
 368                 return CONTROLVM_RESP_ERROR_KMALLOC_FAILED;
 369         }
 370
 371         dev->channel_uuid = msg->cmd.create_device.data_type_uuid;
 372         dev->intr = msg->cmd.create_device.intr;
 373         dev->channel_addr = msg->cmd.create_device.channel_addr;
 374         dev->bus_no = busNo;
 375         dev->dev_no = devNo;
 376         sema_init(&dev->interrupt_callback_lock, 1);    /* unlocked */
 377         sprintf(dev->devid, "vbus%u:dev%u", (unsigned) busNo, (unsigned) devNo);
 378         /* map the channel memory for the device. */
 379         if (msg->hdr.flags.test_message)
 380                 dev->chanptr = (void __iomem *)__va(dev->channel_addr);
 381         else {
 382                 pReqHandler = req_handler_find(dev->channel_uuid);
 383                 if (pReqHandler)
 384                         /* generic service handler registered for this
 385                          * channel
 386                          */
 387                         minSize = pReqHandler->min_channel_bytes;
 388                 if (minSize > msg->cmd.create_device.channel_bytes) {
 389                         LOGERR("CONTROLVM_DEVICE_CREATE Failed: channel size is too small, channel size:0x%lx, required size:0x%lx",
 390                              (ulong) msg->cmd.create_device.channel_bytes,
 391                              (ulong) minSize);
 392                         POSTCODE_LINUX_4(DEVICE_CREATE_FAILURE_PC, devNo, busNo,
 393                                          POSTCODE_SEVERITY_ERR);
 394                         result = CONTROLVM_RESP_ERROR_CHANNEL_SIZE_TOO_SMALL;
 395                         goto Away;
 396                 }
 397                 dev->chanptr =
 398                     uislib_ioremap_cache(dev->channel_addr,
 399                                          msg->cmd.create_device.channel_bytes);
 400                 if (!dev->chanptr) {
 401                         LOGERR("CONTROLVM_DEVICE_CREATE Failed: ioremap_cache of channelAddr:%Lx for channelBytes:%llu failed",
 402                              dev->channel_addr,
 403                              msg->cmd.create_device.channel_bytes);
 404                         result = CONTROLVM_RESP_ERROR_IOREMAP_FAILED;
 405                         POSTCODE_LINUX_4(DEVICE_CREATE_FAILURE_PC, devNo, busNo,
 406                                          POSTCODE_SEVERITY_ERR);
 407                         goto Away;
 408                 }
 409         }
 410         dev->instance_uuid = msg->cmd.create_device.dev_inst_uuid;
 411         dev->channel_bytes = msg->cmd.create_device.channel_bytes;
 412
 413         read_lock(&BusListLock);
 414         for (bus = BusListHead; bus; bus = bus->next) {
 415                 if (bus->bus_no == busNo) {
 416                         /* make sure the device number is valid */
 417                         if (devNo >= bus->device_count) {
 418                                 LOGERR("CONTROLVM_DEVICE_CREATE Failed: device (%d) >= deviceCount (%d).",
 419                                      devNo, bus->device_count);
 420                                 result = CONTROLVM_RESP_ERROR_MAX_DEVICES;
 421                                 POSTCODE_LINUX_4(DEVICE_CREATE_FAILURE_PC,
 422                                                  devNo, busNo,
 423                                                  POSTCODE_SEVERITY_ERR);
 424                                 read_unlock(&BusListLock);
 425                                 goto Away;
 426                         }
 427                         /* make sure this device is not already set */
 428                         if (bus->device[devNo]) {
 429                                 LOGERR("CONTROLVM_DEVICE_CREATE Failed: device %d is already exists.",
 430                                      devNo);
 431                                 POSTCODE_LINUX_4(DEVICE_CREATE_FAILURE_PC,
 432                                                  devNo, busNo,
 433                                                  POSTCODE_SEVERITY_ERR);
 434                                 result = CONTROLVM_RESP_ERROR_ALREADY_DONE;
 435                                 read_unlock(&BusListLock);
 436                                 goto Away;
 437                         }
 438                         read_unlock(&BusListLock);
 439                         /* the msg is bound for virtpci; send
 440                          * guest_msgs struct to callback
 441                          */
 442                         if (!msg->hdr.flags.server) {
 443                                 struct guest_msgs cmd;
 444
 445                                 if (!uuid_le_cmp(dev->channel_uuid,
 446                                      spar_vhba_channel_protocol_uuid)) {
 447                                         wait_for_valid_guid(&((
 448                                                 struct channel_header
 449                                                         __iomem *) (dev->
 450                                                                   chanptr))->
 451                                                             chtype);
 452                                         if (!SPAR_VHBA_CHANNEL_OK_CLIENT
 453                                             (dev->chanptr)) {
 454                                                 LOGERR("CONTROLVM_DEVICE_CREATE Failed:[CLIENT]VHBA dev %d chan invalid.",
 455                                                      devNo);
 456                                                 POSTCODE_LINUX_4
 457                                                     (DEVICE_CREATE_FAILURE_PC,
 458                                                      devNo, busNo,
 459                                                      POSTCODE_SEVERITY_ERR);
 460                                                 result = CONTROLVM_RESP_ERROR_CHANNEL_INVALID;
 461                                                 goto Away;
 462                                         }
 463                                         cmd.msgtype = GUEST_ADD_VHBA;
 464                                         cmd.add_vhba.chanptr = dev->chanptr;
 465                                         cmd.add_vhba.bus_no = busNo;
 466                                         cmd.add_vhba.device_no = devNo;
 467                                         cmd.add_vhba.instance_uuid =
 468                                             dev->instance_uuid;
 469                                         cmd.add_vhba.intr = dev->intr;
 470                                 } else
 471                                     if (!uuid_le_cmp(dev->channel_uuid,
 472                                          spar_vnic_channel_protocol_uuid)) {
 473                                         wait_for_valid_guid(&((
 474                                                 struct channel_header
 475                                                         __iomem *) (dev->
 476                                                                   chanptr))->
 477                                                             chtype);
 478                                         if (!SPAR_VNIC_CHANNEL_OK_CLIENT
 479                                             (dev->chanptr, NULL)) {
 480                                                 LOGERR("CONTROLVM_DEVICE_CREATE Failed: VNIC[CLIENT] dev %d chan invalid.",
 481                                                      devNo);
 482                                                 POSTCODE_LINUX_4
 483                                                     (DEVICE_CREATE_FAILURE_PC,
 484                                                      devNo, busNo,
 485                                                      POSTCODE_SEVERITY_ERR);
 486                                                 result = CONTROLVM_RESP_ERROR_CHANNEL_INVALID;
 487                                                 goto Away;
 488                                         }
 489                                         cmd.msgtype = GUEST_ADD_VNIC;
 490                                         cmd.add_vnic.chanptr = dev->chanptr;
 491                                         cmd.add_vnic.bus_no = busNo;
 492                                         cmd.add_vnic.device_no = devNo;
 493                                         cmd.add_vnic.instance_uuid =
 494                                             dev->instance_uuid;
 495                                         cmd.add_vhba.intr = dev->intr;
 496                                 } else {
 497                                         LOGERR("CONTROLVM_DEVICE_CREATE Failed: unknown channelTypeGuid.\n");
 498                                         POSTCODE_LINUX_4
 499                                             (DEVICE_CREATE_FAILURE_PC, devNo,
 500                                              busNo, POSTCODE_SEVERITY_ERR);
 501                                         result = CONTROLVM_RESP_ERROR_CHANNEL_TYPE_UNKNOWN;
 502                                         goto Away;
 503                                 }
 504
 505                                 if (!virt_control_chan_func) {
 506                                         LOGERR("CONTROLVM_DEVICE_CREATE Failed: virtpci callback not registered.");
 507                                         POSTCODE_LINUX_4
 508                                             (DEVICE_CREATE_FAILURE_PC, devNo,
 509                                              busNo, POSTCODE_SEVERITY_ERR);
 510                                         result = CONTROLVM_RESP_ERROR_VIRTPCI_DRIVER_FAILURE;
 511                                         goto Away;
 512                                 }
 513
 514                                 if (!virt_control_chan_func(&cmd)) {
 515                                         LOGERR("CONTROLVM_DEVICE_CREATE Failed: virtpci GUEST_ADD_[VHBA||VNIC] returned error.");
 516                                         POSTCODE_LINUX_4
 517                                             (DEVICE_CREATE_FAILURE_PC, devNo,
 518                                              busNo, POSTCODE_SEVERITY_ERR);
 519                                         result = CONTROLVM_RESP_ERROR_VIRTPCI_DRIVER_CALLBACK_ERROR;
 520                                         goto Away;
 521                                 }
 522                         }
 523                         bus->device[devNo] = dev;
 524                         POSTCODE_LINUX_4(DEVICE_CREATE_SUCCESS_PC, devNo, busNo,
 525                                          POSTCODE_SEVERITY_INFO);
 526                         return CONTROLVM_RESP_SUCCESS;
 527                 }
 528         }
 529         read_unlock(&BusListLock);
 530
 531         LOGERR("CONTROLVM_DEVICE_CREATE Failed: failed to find bus %d.", busNo);
 532         POSTCODE_LINUX_4(DEVICE_CREATE_FAILURE_PC, devNo, busNo,
 533                          POSTCODE_SEVERITY_ERR);
 534         result = CONTROLVM_RESP_ERROR_BUS_INVALID;
 535
 536 Away:
 537         if (!msg->hdr.flags.test_message) {
 538                 uislib_iounmap(dev->chanptr);
 539                 dev->chanptr = NULL;
 540         }
 541
 542         kfree(dev);
 543         return result;
 544 }
 545
 546 static int
 547 pause_device(struct controlvm_message *msg)
 548 {
 549         u32 busNo, devNo;
 550         struct bus_info *bus;
 551         struct device_info *dev;
 552         struct guest_msgs cmd;
 553         int retval = CONTROLVM_RESP_SUCCESS;
 554
 555         busNo = msg->cmd.device_change_state.bus_no;
 556         devNo = msg->cmd.device_change_state.dev_no;
 557
 558         read_lock(&BusListLock);
 559         for (bus = BusListHead; bus; bus = bus->next) {
 560                 if (bus->bus_no == busNo) {
 561                         /* make sure the device number is valid */
 562                         if (devNo >= bus->device_count) {
 563                                 LOGERR("CONTROLVM_DEVICE_CHANGESTATE:pause Failed: device(%d) >= deviceCount(%d).",
 564                                      devNo, bus->device_count);
 565                                 retval = CONTROLVM_RESP_ERROR_DEVICE_INVALID;
 566                         } else {
 567                                 /* make sure this device exists */
 568                                 dev = bus->device[devNo];
 569                                 if (!dev) {
 570                                         LOGERR("CONTROLVM_DEVICE_CHANGESTATE:pause Failed: device %d does not exist.",
 571                                              devNo);
 572                                         retval =
 573                                           CONTROLVM_RESP_ERROR_ALREADY_DONE;
 574                                 }
 575                         }
 576                         break;
 577                 }
 578         }
 579         if (!bus) {
 580                 LOGERR("CONTROLVM_DEVICE_CHANGESTATE:pause Failed: bus %d does not exist",
 581                      busNo);
 582                 retval = CONTROLVM_RESP_ERROR_BUS_INVALID;
 583         }
 584         read_unlock(&BusListLock);
 585         if (retval == CONTROLVM_RESP_SUCCESS) {
 586                 /* the msg is bound for virtpci; send
 587                  * guest_msgs struct to callback
 588                  */
 589                 if (!uuid_le_cmp(dev->channel_uuid,
 590                                 spar_vhba_channel_protocol_uuid)) {
 591                         cmd.msgtype = GUEST_PAUSE_VHBA;
 592                         cmd.pause_vhba.chanptr = dev->chanptr;
 593                 } else if (!uuid_le_cmp(dev->channel_uuid,
 594                                         spar_vnic_channel_protocol_uuid)) {
 595                         cmd.msgtype = GUEST_PAUSE_VNIC;
 596                         cmd.pause_vnic.chanptr = dev->chanptr;
 597                 } else {
 598                         LOGERR("CONTROLVM_DEVICE_CHANGESTATE:pause Failed: unknown channelTypeGuid.\n");
 599                         return CONTROLVM_RESP_ERROR_CHANNEL_TYPE_UNKNOWN;
 600                 }
 601                 if (!virt_control_chan_func) {
 602                         LOGERR("CONTROLVM_DEVICE_CHANGESTATE Failed: virtpci callback not registered.");
 603                         return CONTROLVM_RESP_ERROR_VIRTPCI_DRIVER_FAILURE;
 604                 }
 605                 if (!virt_control_chan_func(&cmd)) {
 606                         LOGERR("CONTROLVM_DEVICE_CHANGESTATE:pause Failed: virtpci GUEST_PAUSE_[VHBA||VNIC] returned error.");
 607                         return
 608                           CONTROLVM_RESP_ERROR_VIRTPCI_DRIVER_CALLBACK_ERROR;
 609                 }
 610         }
 611         return retval;
 612 }
 613
 614 static int
 615 resume_device(struct controlvm_message *msg)
 616 {
 617         u32 busNo, devNo;
 618         struct bus_info *bus;
 619         struct device_info *dev;
 620         struct guest_msgs cmd;
 621         int retval = CONTROLVM_RESP_SUCCESS;
 622
 623         busNo = msg->cmd.device_change_state.bus_no;
 624         devNo = msg->cmd.device_change_state.dev_no;
 625
 626         read_lock(&BusListLock);
 627         for (bus = BusListHead; bus; bus = bus->next) {
 628                 if (bus->bus_no == busNo) {
 629                         /* make sure the device number is valid */
 630                         if (devNo >= bus->device_count) {
 631                                 LOGERR("CONTROLVM_DEVICE_CHANGESTATE:resume Failed: device(%d) >= deviceCount(%d).",
 632                                      devNo, bus->device_count);
 633                                 retval = CONTROLVM_RESP_ERROR_DEVICE_INVALID;
 634                         } else {
 635                                 /* make sure this device exists */
 636                                 dev = bus->device[devNo];
 637                                 if (!dev) {
 638                                         LOGERR("CONTROLVM_DEVICE_CHANGESTATE:resume Failed: device %d does not exist.",
 639                                              devNo);
 640                                         retval =
 641                                           CONTROLVM_RESP_ERROR_ALREADY_DONE;
 642                                 }
 643                         }
 644                         break;
 645                 }
 646         }
 647
 648         if (!bus) {
 649                 LOGERR("CONTROLVM_DEVICE_CHANGESTATE:resume Failed: bus %d does not exist",
 650                      busNo);
 651                 retval = CONTROLVM_RESP_ERROR_BUS_INVALID;
 652         }
 653         read_unlock(&BusListLock);
 654         /* the msg is bound for virtpci; send
 655          * guest_msgs struct to callback
 656          */
 657         if (retval == CONTROLVM_RESP_SUCCESS) {
 658                 if (!uuid_le_cmp(dev->channel_uuid,
 659                                  spar_vhba_channel_protocol_uuid)) {
 660                         cmd.msgtype = GUEST_RESUME_VHBA;
 661                         cmd.resume_vhba.chanptr = dev->chanptr;
 662                 } else if (!uuid_le_cmp(dev->channel_uuid,
 663                                         spar_vnic_channel_protocol_uuid)) {
 664                         cmd.msgtype = GUEST_RESUME_VNIC;
 665                         cmd.resume_vnic.chanptr = dev->chanptr;
 666                 } else {
 667                         LOGERR("CONTROLVM_DEVICE_CHANGESTATE:resume Failed: unknown channelTypeGuid.\n");
 668                         return CONTROLVM_RESP_ERROR_CHANNEL_TYPE_UNKNOWN;
 669                 }
 670                 if (!virt_control_chan_func) {
 671                         LOGERR("CONTROLVM_DEVICE_CHANGESTATE Failed: virtpci callback not registered.");
 672                         return CONTROLVM_RESP_ERROR_VIRTPCI_DRIVER_FAILURE;
 673                 }
 674                 if (!virt_control_chan_func(&cmd)) {
 675                         LOGERR("CONTROLVM_DEVICE_CHANGESTATE:resume Failed: virtpci GUEST_RESUME_[VHBA||VNIC] returned error.");
 676                         return
 677                           CONTROLVM_RESP_ERROR_VIRTPCI_DRIVER_CALLBACK_ERROR;
 678                 }
 679         }
 680         return retval;
 681 }
 682
 683 static int
 684 destroy_device(struct controlvm_message *msg, char *buf)
 685 {
 686         u32 busNo, devNo;
 687         struct bus_info *bus;
 688         struct device_info *dev;
 689         struct guest_msgs cmd;
 690         int retval = CONTROLVM_RESP_SUCCESS;
 691
 692         busNo = msg->cmd.destroy_device.bus_no;
 693         devNo = msg->cmd.destroy_device.bus_no;
 694
 695         read_lock(&BusListLock);
 696         LOGINF("destroy_device called for busNo=%u, devNo=%u", busNo, devNo);
 697         for (bus = BusListHead; bus; bus = bus->next) {
 698                 if (bus->bus_no == busNo) {
 699                         /* make sure the device number is valid */
 700                         if (devNo >= bus->device_count) {
 701                                 LOGERR("CONTROLVM_DEVICE_DESTORY Failed: device(%d) >= deviceCount(%d).",
 702                                        devNo, bus->device_count);
 703                                 retval = CONTROLVM_RESP_ERROR_DEVICE_INVALID;
 704                         } else {
 705                                 /* make sure this device exists */
 706                                 dev = bus->device[devNo];
 707                                 if (!dev) {
 708                                         LOGERR("CONTROLVM_DEVICE_DESTROY Failed: device %d does not exist.",
 709                                                devNo);
 710                                         retval =
 711                                              CONTROLVM_RESP_ERROR_ALREADY_DONE;
 712                                 }
 713                         }
 714                         break;
 715                 }
 716         }
 717
 718         if (!bus) {
 719                 LOGERR("CONTROLVM_DEVICE_DESTROY Failed: bus %d does not exist",
 720                        busNo);
 721                 retval = CONTROLVM_RESP_ERROR_BUS_INVALID;
 722         }
 723         read_unlock(&BusListLock);
 724         if (retval == CONTROLVM_RESP_SUCCESS) {
 725                 /* the msg is bound for virtpci; send
 726                  * guest_msgs struct to callback
 727                  */
 728                 if (!uuid_le_cmp(dev->channel_uuid,
 729                                  spar_vhba_channel_protocol_uuid)) {
 730                         cmd.msgtype = GUEST_DEL_VHBA;
 731                         cmd.del_vhba.chanptr = dev->chanptr;
 732                 } else if (!uuid_le_cmp(dev->channel_uuid,
 733                                         spar_vnic_channel_protocol_uuid)) {
 734                         cmd.msgtype = GUEST_DEL_VNIC;
 735                         cmd.del_vnic.chanptr = dev->chanptr;
 736                 } else {
 737                         LOGERR("CONTROLVM_DEVICE_DESTROY Failed: unknown channelTypeGuid.\n");
 738                         return
 739                             CONTROLVM_RESP_ERROR_CHANNEL_TYPE_UNKNOWN;
 740                 }
 741                 if (!virt_control_chan_func) {
 742                         LOGERR("CONTROLVM_DEVICE_DESTORY Failed: virtpci callback not registered.");
 743                         return
 744                             CONTROLVM_RESP_ERROR_VIRTPCI_DRIVER_FAILURE;
 745                 }
 746                 if (!virt_control_chan_func(&cmd)) {
 747                         LOGERR("CONTROLVM_DEVICE_DESTROY Failed: virtpci GUEST_DEL_[VHBA||VNIC] returned error.");
 748                         return
 749                             CONTROLVM_RESP_ERROR_VIRTPCI_DRIVER_CALLBACK_ERROR;
 750                 }
 751 /* you must disable channel interrupts BEFORE you unmap the channel,
 752  * because if you unmap first, there may still be some activity going
 753  * on which accesses the channel and you will get a "unable to handle
 754  * kernel paging request"
 755  */
 756                 if (dev->polling) {
 757                         LOGINF("calling uislib_disable_channel_interrupts");
 758                         uislib_disable_channel_interrupts(busNo, devNo);
 759                 }
 760                 /* unmap the channel memory for the device. */
 761                 if (!msg->hdr.flags.test_message) {
 762                         LOGINF("destroy_device, doing iounmap");
 763                         uislib_iounmap(dev->chanptr);
 764                 }
 765                 kfree(dev);
 766                 bus->device[devNo] = NULL;
 767         }
 768         return retval;
 769 }
 770
 771 static int
 772 init_chipset(struct controlvm_message *msg, char *buf)
 773 {
 774         POSTCODE_LINUX_2(CHIPSET_INIT_ENTRY_PC, POSTCODE_SEVERITY_INFO);
 775
 776         MaxBusCount = msg->cmd.init_chipset.bus_count;
 777         PlatformNumber = msg->cmd.init_chipset.platform_number;
 778         PhysicalDataChan = 0;
 779
 780         /* We need to make sure we have our functions registered
 781         * before processing messages.  If we are a test vehicle the
 782         * test_message for init_chipset will be set.  We can ignore the
 783         * waits for the callbacks, since this will be manually entered
 784         * from a user.  If no test_message is set, we will wait for the
 785         * functions.
 786         */
 787         if (!msg->hdr.flags.test_message)
 788                 WAIT_ON_CALLBACK(virt_control_chan_func);
 789
 790         chipset_inited = 1;
 791         POSTCODE_LINUX_2(CHIPSET_INIT_EXIT_PC, POSTCODE_SEVERITY_INFO);
 792
 793         return CONTROLVM_RESP_SUCCESS;
 794 }
 795
 796 static int
 797 delete_bus_glue(u32 busNo)
 798 {
 799         struct controlvm_message msg;
 800
 801         init_msg_header(&msg, CONTROLVM_BUS_DESTROY, 0, 0);
 802         msg.cmd.destroy_bus.bus_no = busNo;
 803         if (destroy_bus(&msg, NULL) != CONTROLVM_RESP_SUCCESS) {
 804                 LOGERR("destroy_bus failed. busNo=0x%x\n", busNo);
 805                 return 0;
 806         }
 807         return 1;
 808 }
 809
 810 static int
 811 delete_device_glue(u32 busNo, u32 devNo)
 812 {
 813         struct controlvm_message msg;
 814
 815         init_msg_header(&msg, CONTROLVM_DEVICE_DESTROY, 0, 0);
 816         msg.cmd.destroy_device.bus_no = busNo;
 817         msg.cmd.destroy_device.dev_no = devNo;
 818         if (destroy_device(&msg, NULL) != CONTROLVM_RESP_SUCCESS) {
 819                 LOGERR("destroy_device failed. busNo=0x%x devNo=0x%x\n", busNo,
 820                        devNo);
 821                 return 0;
 822         }
 823         return 1;
 824 }
 825
 826 int
 827 uislib_client_inject_add_bus(u32 bus_no, uuid_le inst_uuid,
 828                              u64 channel_addr, ulong n_channel_bytes)
 829 {
 830         struct controlvm_message msg;
 831
 832         LOGINF("enter busNo=0x%x\n", bus_no);
 833         /* step 0: init the chipset */
 834         POSTCODE_LINUX_3(CHIPSET_INIT_ENTRY_PC, bus_no, POSTCODE_SEVERITY_INFO);
 835
 836         if (!chipset_inited) {
 837                 /* step: initialize the chipset */
 838                 init_msg_header(&msg, CONTROLVM_CHIPSET_INIT, 0, 0);
 839                 /* this change is needed so that console will come up
 840                 * OK even when the bus 0 create comes in late.  If the
 841                 * bus 0 create is the first create, then the add_vnic
 842                 * will work fine, but if the bus 0 create arrives
 843                 * after number 4, then the add_vnic will fail, and the
 844                 * ultraboot will fail.
 845                 */
 846                 msg.cmd.init_chipset.bus_count = 23;
 847                 msg.cmd.init_chipset.switch_count = 0;
 848                 if (init_chipset(&msg, NULL) != CONTROLVM_RESP_SUCCESS) {
 849                         LOGERR("init_chipset failed.\n");
 850                         return 0;
 851                 }
 852                 LOGINF("chipset initialized\n");
 853                 POSTCODE_LINUX_3(CHIPSET_INIT_EXIT_PC, bus_no,
 854                                  POSTCODE_SEVERITY_INFO);
 855         }
 856
 857         /* step 1: create a bus */
 858         POSTCODE_LINUX_3(BUS_CREATE_ENTRY_PC, bus_no,
 859                          POSTCODE_SEVERITY_WARNING);
 860         init_msg_header(&msg, CONTROLVM_BUS_CREATE, 0, 0);
 861         msg.cmd.create_bus.bus_no = bus_no;
 862         msg.cmd.create_bus.dev_count = 23;      /* devNo+1; */
 863         msg.cmd.create_bus.channel_addr = channel_addr;
 864         msg.cmd.create_bus.channel_bytes = n_channel_bytes;
 865         if (create_bus(&msg, NULL) != CONTROLVM_RESP_SUCCESS) {
 866                 LOGERR("create_bus failed.\n");
 867                 POSTCODE_LINUX_3(BUS_CREATE_FAILURE_PC, bus_no,
 868                                  POSTCODE_SEVERITY_ERR);
 869                 return 0;
 870         }
 871         POSTCODE_LINUX_3(BUS_CREATE_EXIT_PC, bus_no, POSTCODE_SEVERITY_INFO);
 872
 873         return 1;
 874 }
 875 EXPORT_SYMBOL_GPL(uislib_client_inject_add_bus);
 876
 877
 878 int
 879 uislib_client_inject_del_bus(u32 bus_no)
 880 {
 881         return delete_bus_glue(bus_no);
 882 }
 883 EXPORT_SYMBOL_GPL(uislib_client_inject_del_bus);
 884
 885 int
 886 uislib_client_inject_pause_vhba(u32 bus_no, u32 dev_no)
 887 {
 888         struct controlvm_message msg;
 889         int rc;
 890
 891         init_msg_header(&msg, CONTROLVM_DEVICE_CHANGESTATE, 0, 0);
 892         msg.cmd.device_change_state.bus_no = bus_no;
 893         msg.cmd.device_change_state.dev_no = dev_no;
 894         msg.cmd.device_change_state.state = segment_state_standby;
 895         rc = pause_device(&msg);
 896         if (rc != CONTROLVM_RESP_SUCCESS) {
 897                 LOGERR("VHBA pause_device failed. busNo=0x%x devNo=0x%x\n",
 898                        bus_no, dev_no);
 899                 return rc;
 900         }
 901         return 0;
 902 }
 903 EXPORT_SYMBOL_GPL(uislib_client_inject_pause_vhba);
 904
 905 int
 906 uislib_client_inject_resume_vhba(u32 bus_no, u32 dev_no)
 907 {
 908         struct controlvm_message msg;
 909         int rc;
 910
 911         init_msg_header(&msg, CONTROLVM_DEVICE_CHANGESTATE, 0, 0);
 912         msg.cmd.device_change_state.bus_no = bus_no;
 913         msg.cmd.device_change_state.dev_no = dev_no;
 914         msg.cmd.device_change_state.state = segment_state_running;
 915         rc = resume_device(&msg);
 916         if (rc != CONTROLVM_RESP_SUCCESS) {
 917                 LOGERR("VHBA resume_device failed. busNo=0x%x devNo=0x%x\n",
 918                        bus_no, dev_no);
 919                 return rc;
 920         }
 921         return 0;
 922
 923 }
 924 EXPORT_SYMBOL_GPL(uislib_client_inject_resume_vhba);
 925
 926 int
 927 uislib_client_inject_add_vhba(u32 bus_no, u32 dev_no,
 928                               u64 phys_chan_addr, u32 chan_bytes,
 929                               int is_test_addr, uuid_le inst_uuid,
 930                               struct irq_info *intr)
 931 {
 932         struct controlvm_message msg;
 933
 934         LOGINF(" enter busNo=0x%x devNo=0x%x\n", bus_no, dev_no);
 935         /* chipset init'ed with bus bus has been previously created -
 936         * Verify it still exists step 2: create the VHBA device on the
 937         * bus
 938         */
 939         POSTCODE_LINUX_4(VHBA_CREATE_ENTRY_PC, dev_no, bus_no,
 940                          POSTCODE_SEVERITY_INFO);
 941
 942         init_msg_header(&msg, CONTROLVM_DEVICE_CREATE, 0, 0);
 943         if (is_test_addr)
 944                 /* signify that the physical channel address does NOT
 945                  * need to be ioremap()ed
 946                  */
 947                 msg.hdr.flags.test_message = 1;
 948         msg.cmd.create_device.bus_no = bus_no;
 949         msg.cmd.create_device.dev_no = dev_no;
 950         msg.cmd.create_device.dev_inst_uuid = inst_uuid;
 951         if (intr)
 952                 msg.cmd.create_device.intr = *intr;
 953         else
 954                 memset(&msg.cmd.create_device.intr, 0,
 955                        sizeof(struct irq_info));
 956         msg.cmd.create_device.channel_addr = phys_chan_addr;
 957         if (chan_bytes < MIN_IO_CHANNEL_SIZE) {
 958                 LOGERR("wrong channel size.chan_bytes = 0x%x IO_CHANNEL_SIZE= 0x%x\n",
 959                      chan_bytes, (unsigned int) MIN_IO_CHANNEL_SIZE);
 960                 POSTCODE_LINUX_4(VHBA_CREATE_FAILURE_PC, chan_bytes,
 961                                  MIN_IO_CHANNEL_SIZE, POSTCODE_SEVERITY_ERR);
 962                 return 0;
 963         }
 964         msg.cmd.create_device.channel_bytes = chan_bytes;
 965         msg.cmd.create_device.data_type_uuid = spar_vhba_channel_protocol_uuid;
 966         if (create_device(&msg, NULL) != CONTROLVM_RESP_SUCCESS) {
 967                 LOGERR("VHBA create_device failed.\n");
 968                 POSTCODE_LINUX_4(VHBA_CREATE_FAILURE_PC, dev_no, bus_no,
 969                                  POSTCODE_SEVERITY_ERR);
 970                 return 0;
 971         }
 972         POSTCODE_LINUX_4(VHBA_CREATE_SUCCESS_PC, dev_no, bus_no,
 973                          POSTCODE_SEVERITY_INFO);
 974         return 1;
 975 }
 976 EXPORT_SYMBOL_GPL(uislib_client_inject_add_vhba);
 977
 978 int
 979 uislib_client_inject_del_vhba(u32 bus_no, u32 dev_no)
 980 {
 981         return delete_device_glue(bus_no, dev_no);
 982 }
 983 EXPORT_SYMBOL_GPL(uislib_client_inject_del_vhba);
 984
 985 int
 986 uislib_client_inject_add_vnic(u32 bus_no, u32 dev_no,
 987                               u64 phys_chan_addr, u32 chan_bytes,
 988                               int is_test_addr, uuid_le inst_uuid,
 989                               struct irq_info *intr)
 990 {
 991         struct controlvm_message msg;
 992
 993         LOGINF(" enter busNo=0x%x devNo=0x%x\n", bus_no, dev_no);
 994         /* chipset init'ed with bus bus has been previously created -
 995         * Verify it still exists step 2: create the VNIC device on the
 996         * bus
 997         */
 998         POSTCODE_LINUX_4(VNIC_CREATE_ENTRY_PC, dev_no, bus_no,
 999                          POSTCODE_SEVERITY_INFO);
1000
1001         init_msg_header(&msg, CONTROLVM_DEVICE_CREATE, 0, 0);
1002         if (is_test_addr)
1003                 /* signify that the physical channel address does NOT
1004                  * need to be ioremap()ed
1005                  */
1006                 msg.hdr.flags.test_message = 1;
1007         msg.cmd.create_device.bus_no = bus_no;
1008         msg.cmd.create_device.dev_no = dev_no;
1009         msg.cmd.create_device.dev_inst_uuid = inst_uuid;
1010         if (intr)
1011                 msg.cmd.create_device.intr = *intr;
1012         else
1013                 memset(&msg.cmd.create_device.intr, 0,
1014                        sizeof(struct irq_info));
1015         msg.cmd.create_device.channel_addr = phys_chan_addr;
1016         if (chan_bytes < MIN_IO_CHANNEL_SIZE) {
1017                 LOGERR("wrong channel size.chan_bytes = 0x%x IO_CHANNEL_SIZE= 0x%x\n",
1018                      chan_bytes, (unsigned int) MIN_IO_CHANNEL_SIZE);
1019                 POSTCODE_LINUX_4(VNIC_CREATE_FAILURE_PC, chan_bytes,
1020                                  MIN_IO_CHANNEL_SIZE, POSTCODE_SEVERITY_ERR);
1021                 return 0;
1022         }
1023         msg.cmd.create_device.channel_bytes = chan_bytes;
1024         msg.cmd.create_device.data_type_uuid = spar_vnic_channel_protocol_uuid;
1025         if (create_device(&msg, NULL) != CONTROLVM_RESP_SUCCESS) {
1026                 LOGERR("VNIC create_device failed.\n");
1027                 POSTCODE_LINUX_4(VNIC_CREATE_FAILURE_PC, dev_no, bus_no,
1028                                  POSTCODE_SEVERITY_ERR);
1029                 return 0;
1030         }
1031
1032         POSTCODE_LINUX_4(VNIC_CREATE_SUCCESS_PC, dev_no, bus_no,
1033                          POSTCODE_SEVERITY_INFO);
1034         return 1;
1035 }
1036 EXPORT_SYMBOL_GPL(uislib_client_inject_add_vnic);
1037
1038 int
1039 uislib_client_inject_pause_vnic(u32 bus_no, u32 dev_no)
1040 {
1041         struct controlvm_message msg;
1042         int rc;
1043
1044         init_msg_header(&msg, CONTROLVM_DEVICE_CHANGESTATE, 0, 0);
1045         msg.cmd.device_change_state.bus_no = bus_no;
1046         msg.cmd.device_change_state.dev_no = dev_no;
1047         msg.cmd.device_change_state.state = segment_state_standby;
1048         rc = pause_device(&msg);
1049         if (rc != CONTROLVM_RESP_SUCCESS) {
1050                 LOGERR("VNIC pause_device failed. busNo=0x%x devNo=0x%x\n",
1051                        bus_no, dev_no);
1052                 return -1;
1053         }
1054         return 0;
1055 }
1056 EXPORT_SYMBOL_GPL(uislib_client_inject_pause_vnic);
1057
1058 int
1059 uislib_client_inject_resume_vnic(u32 bus_no, u32 dev_no)
1060 {
1061         struct controlvm_message msg;
1062         int rc;
1063
1064         init_msg_header(&msg, CONTROLVM_DEVICE_CHANGESTATE, 0, 0);
1065         msg.cmd.device_change_state.bus_no = bus_no;
1066         msg.cmd.device_change_state.dev_no = dev_no;
1067         msg.cmd.device_change_state.state = segment_state_running;
1068         rc = resume_device(&msg);
1069         if (rc != CONTROLVM_RESP_SUCCESS) {
1070                 LOGERR("VNIC resume_device failed. busNo=0x%x devNo=0x%x\n",
1071                        bus_no, dev_no);
1072                 return -1;
1073         }
1074         return 0;
1075
1076 }
1077 EXPORT_SYMBOL_GPL(uislib_client_inject_resume_vnic);
1078
1079 int
1080 uislib_client_inject_del_vnic(u32 bus_no, u32 dev_no)
1081 {
1082         return delete_device_glue(bus_no, dev_no);
1083 }
1084 EXPORT_SYMBOL_GPL(uislib_client_inject_del_vnic);
1085
1086 static int
1087 uislib_client_add_vnic(u32 busNo)
1088 {
1089         BOOL busCreated = FALSE;
1090         int devNo = 0;          /* Default to 0, since only one device
1091                                  * will be created for this bus... */
1092         struct controlvm_message msg;
1093
1094         init_msg_header(&msg, CONTROLVM_BUS_CREATE, 0, 0);
1095         msg.hdr.flags.test_message = 1;
1096         msg.cmd.create_bus.bus_no = busNo;
1097         msg.cmd.create_bus.dev_count = 4;
1098         msg.cmd.create_bus.channel_addr = 0;
1099         msg.cmd.create_bus.channel_bytes = 0;
1100         if (create_bus(&msg, NULL) != CONTROLVM_RESP_SUCCESS) {
1101                 LOGERR("client create_bus failed");
1102                 return 0;
1103         }
1104         busCreated = TRUE;
1105
1106         init_msg_header(&msg, CONTROLVM_DEVICE_CREATE, 0, 0);
1107         msg.hdr.flags.test_message = 1;
1108         msg.cmd.create_device.bus_no = busNo;
1109         msg.cmd.create_device.dev_no = devNo;
1110         msg.cmd.create_device.dev_inst_uuid = NULL_UUID_LE;
1111         memset(&msg.cmd.create_device.intr, 0, sizeof(struct irq_info));
1112         msg.cmd.create_device.channel_addr = PhysicalDataChan;
1113         msg.cmd.create_device.channel_bytes = MIN_IO_CHANNEL_SIZE;
1114         msg.cmd.create_device.data_type_uuid = spar_vnic_channel_protocol_uuid;
1115         if (create_device(&msg, NULL) != CONTROLVM_RESP_SUCCESS) {
1116                 LOGERR("client create_device failed");
1117                 goto AwayCleanup;
1118         }
1119
1120         return 1;
1121
1122 AwayCleanup:
1123         if (busCreated) {
1124                 init_msg_header(&msg, CONTROLVM_BUS_DESTROY, 0, 0);
1125                 msg.hdr.flags.test_message = 1;
1126                 msg.cmd.destroy_bus.bus_no = busNo;
1127                 if (destroy_bus(&msg, NULL) != CONTROLVM_RESP_SUCCESS)
1128                         LOGERR("client destroy_bus failed.\n");
1129         }
1130
1131         return 0;
1132 }                               /* end uislib_client_add_vnic */
1133 EXPORT_SYMBOL_GPL(uislib_client_add_vnic);
1134
1135 static int
1136 uislib_client_delete_vnic(u32 busNo)
1137 {
1138         int devNo = 0;          /* Default to 0, since only one device
1139                                  * will be created for this bus... */
1140         struct controlvm_message msg;
1141
1142         init_msg_header(&msg, CONTROLVM_DEVICE_DESTROY, 0, 0);
1143         msg.hdr.flags.test_message = 1;
1144         msg.cmd.destroy_device.bus_no = busNo;
1145         msg.cmd.destroy_device.dev_no = devNo;
1146         if (destroy_device(&msg, NULL) != CONTROLVM_RESP_SUCCESS) {
1147                 /* Don't error exit - try to see if bus can be destroyed... */
1148                 LOGERR("client destroy_device failed.\n");
1149         }
1150
1151         init_msg_header(&msg, CONTROLVM_BUS_DESTROY, 0, 0);
1152         msg.hdr.flags.test_message = 1;
1153         msg.cmd.destroy_bus.bus_no = busNo;
1154         if (destroy_bus(&msg, NULL) != CONTROLVM_RESP_SUCCESS)
1155                 LOGERR("client destroy_bus failed.\n");
1156
1157         return 1;
1158 }
1159 EXPORT_SYMBOL_GPL(uislib_client_delete_vnic);
1160 /* end client_delete_vnic */
1161
1162 void *
1163 uislib_cache_alloc(struct kmem_cache *cur_pool, char *fn, int ln)
1164 {
1165         /* __GFP_NORETRY means "ok to fail", meaning kmalloc() can
1166         * return NULL.  If you do NOT specify __GFP_NORETRY, Linux
1167         * will go to extreme measures to get memory for you (like,
1168         * invoke oom killer), which will probably cripple the system.
1169         */
1170         void *p = kmem_cache_alloc(cur_pool, GFP_ATOMIC | __GFP_NORETRY);
1171
1172         if (p == NULL) {
1173                 LOGERR("uislib_malloc failed to alloc uiscmdrsp @%s:%d",
1174                        fn, ln);
1175                 return NULL;
1176         }
1177         return p;
1178 }
1179 EXPORT_SYMBOL_GPL(uislib_cache_alloc);
1180
1181 void
1182 uislib_cache_free(struct kmem_cache *cur_pool, void *p, char *fn, int ln)
1183 {
1184         if (p == NULL) {
1185                 LOGERR("uislib_free NULL pointer @%s:%d", fn, ln);
1186                 return;
1187         }
1188         kmem_cache_free(cur_pool, p);
1189 }
1190 EXPORT_SYMBOL_GPL(uislib_cache_free);
1191
1192 /*****************************************************/
1193 /* proc filesystem callback functions                */
1194 /*****************************************************/
1195
1196 #define PLINE(...) uisutil_add_proc_line_ex(&tot, buff, \
1197                                                buff_len, __VA_ARGS__)
1198
1199 static int
1200 info_debugfs_read_helper(char **buff, int *buff_len)
1201 {
1202         int i, tot = 0;
1203         struct bus_info *bus;
1204
1205         if (PLINE("\nBuses:\n") < 0)
1206                 goto err_done;
1207
1208         read_lock(&BusListLock);
1209         for (bus = BusListHead; bus; bus = bus->next) {
1210
1211                 if (PLINE("    bus=0x%p, busNo=%d, deviceCount=%d\n",
1212                           bus, bus->bus_no, bus->device_count) < 0)
1213                         goto err_done_unlock;
1214
1215
1216                 if (PLINE("        Devices:\n") < 0)
1217                         goto err_done_unlock;
1218
1219                 for (i = 0; i < bus->device_count; i++) {
1220                         if (bus->device[i]) {
1221                                 if (PLINE("            busNo %d, device[%i]: 0x%p, chanptr=0x%p, swtch=0x%p\n",
1222                                           bus->bus_no, i, bus->device[i],
1223                                           bus->device[i]->chanptr,
1224                                           bus->device[i]->swtch) < 0)
1225                                         goto err_done_unlock;
1226
1227                                 if (PLINE("            first_busy_cnt=%llu, moved_to_tail_cnt=%llu, last_on_list_cnt=%llu\n",
1228                                           bus->device[i]->first_busy_cnt,
1229                                           bus->device[i]->moved_to_tail_cnt,
1230                                           bus->device[i]->last_on_list_cnt) < 0)
1231                                         goto err_done_unlock;
1232                         }
1233                 }
1234         }
1235         read_unlock(&BusListLock);
1236
1237         if (PLINE("UisUtils_Registered_Services: %d\n",
1238                   atomic_read(&uisutils_registered_services)) < 0)
1239                 goto err_done;
1240         if (PLINE("cycles_before_wait %llu wait_cycles:%llu\n",
1241                   cycles_before_wait, wait_cycles) < 0)
1242                         goto err_done;
1243         if (PLINE("tot_wakeup_cnt %llu:tot_wait_cnt %llu:tot_schedule_cnt %llu\n",
1244                   tot_wakeup_cnt, tot_wait_cnt, tot_schedule_cnt) < 0)
1245                         goto err_done;
1246         if (PLINE("en_smart_wakeup %d\n", en_smart_wakeup) < 0)
1247                         goto err_done;
1248         if (PLINE("tot_moved_to_tail_cnt %llu\n", tot_moved_to_tail_cnt) < 0)
1249                         goto err_done;
1250
1251         return tot;
1252
1253 err_done_unlock:
1254         read_unlock(&BusListLock);
1255 err_done:
1256         return -1;
1257 }
1258
1259 static ssize_t
1260 info_debugfs_read(struct file *file, char __user *buf,
1261                 size_t len, loff_t *offset)
1262 {
1263         char *temp;
1264         int totalBytes = 0;
1265         int remaining_bytes = PROC_READ_BUFFER_SIZE;
1266
1267 /* *start = buf; */
1268         if (ProcReadBuffer == NULL) {
1269                 DBGINF("ProcReadBuffer == NULL; allocating buffer.\n.");
1270                 ProcReadBuffer = vmalloc(PROC_READ_BUFFER_SIZE);
1271
1272                 if (ProcReadBuffer == NULL) {
1273                         LOGERR("failed to allocate buffer to provide proc data.\n");
1274                         return -ENOMEM;
1275                 }
1276         }
1277
1278         temp = ProcReadBuffer;
1279
1280         if ((*offset == 0) || (!ProcReadBufferValid)) {
1281                 DBGINF("calling info_debugfs_read_helper.\n");
1282                 /* if the read fails, then -1 will be returned */
1283                 totalBytes = info_debugfs_read_helper(&temp, &remaining_bytes);
1284                 ProcReadBufferValid = 1;
1285         } else
1286                 totalBytes = strlen(ProcReadBuffer);
1287
1288         return simple_read_from_buffer(buf, len, offset,
1289                                        ProcReadBuffer, totalBytes);
1290 }
1291
1292 static struct device_info *
1293 find_dev(u32 busNo, u32 devNo)
1294 {
1295         struct bus_info *bus;
1296         struct device_info *dev = NULL;
1297
1298         read_lock(&BusListLock);
1299         for (bus = BusListHead; bus; bus = bus->next) {
1300                 if (bus->bus_no == busNo) {
1301                         /* make sure the device number is valid */
1302                         if (devNo >= bus->device_count) {
1303                                 LOGERR("%s bad busNo, devNo=%d,%d",
1304                                        __func__,
1305                                        (int) (busNo), (int) (devNo));
1306                                 goto Away;
1307                         }
1308                         dev = bus->device[devNo];
1309                         if (!dev)
1310                                 LOGERR("%s bad busNo, devNo=%d,%d",
1311                                        __func__,
1312                                        (int) (busNo), (int) (devNo));
1313                         goto Away;
1314                 }
1315         }
1316 Away:
1317         read_unlock(&BusListLock);
1318         return dev;
1319 }
1320
1321 /*  This thread calls the "interrupt" function for each device that has
1322  *  enabled such using uislib_enable_channel_interrupts().  The "interrupt"
1323  *  function typically reads and processes the devices's channel input
1324  *  queue.  This thread repeatedly does this, until the thread is told to stop
1325  *  (via uisthread_stop()).  Sleeping rules:
1326  *  - If we have called the "interrupt" function for all devices, and all of
1327  *    them have reported "nothing processed" (returned 0), then we will go to
1328  *    sleep for a maximum of POLLJIFFIES_NORMAL jiffies.
1329  *  - If anyone calls uislib_force_channel_interrupt(), the above jiffy
1330  *    sleep will be interrupted, and we will resume calling the "interrupt"
1331  *    function for all devices.
1332  *  - The list of devices is dynamically re-ordered in order to
1333  *    attempt to preserve fairness.  Whenever we spin thru the list of
1334  *    devices and call the dev->interrupt() function, if we find
1335  *    devices which report that there is still more work to do, the
1336  *    the first such device we find is moved to the end of the device
1337  *    list.  This ensures that extremely busy devices don't starve out
1338  *    less-busy ones.
1339  *
1340  */
1341 static int
1342 Process_Incoming(void *v)
1343 {
1344         unsigned long long cur_cycles, old_cycles, idle_cycles, delta_cycles;
1345         struct list_head *new_tail = NULL;
1346         int i;
1347
1348         UIS_DAEMONIZE("dev_incoming");
1349         for (i = 0; i < 16; i++) {
1350                 old_cycles = get_cycles();
1351                 wait_event_timeout(Wakeup_Polling_Device_Channels,
1352                                    0, POLLJIFFIES_NORMAL);
1353                 cur_cycles = get_cycles();
1354                 if (wait_cycles == 0) {
1355                         wait_cycles = (cur_cycles - old_cycles);
1356                 } else {
1357                         if (wait_cycles < (cur_cycles - old_cycles))
1358                                 wait_cycles = (cur_cycles - old_cycles);
1359                 }
1360         }
1361         LOGINF("wait_cycles=%llu", wait_cycles);
1362         cycles_before_wait = wait_cycles;
1363         idle_cycles = 0;
1364         Go_Polling_Device_Channels = 0;
1365         while (1) {
1366                 struct list_head *lelt, *tmp;
1367                 struct device_info *dev = NULL;
1368
1369                 /* poll each channel for input */
1370                 down(&Lock_Polling_Device_Channels);
1371                 new_tail = NULL;
1372                 list_for_each_safe(lelt, tmp, &List_Polling_Device_Channels) {
1373                         int rc = 0;
1374
1375                         dev = list_entry(lelt, struct device_info,
1376                                          list_polling_device_channels);
1377                         down(&dev->interrupt_callback_lock);
1378                         if (dev->interrupt)
1379                                 rc = dev->interrupt(dev->interrupt_context);
1380                         else
1381                                 continue;
1382                         up(&dev->interrupt_callback_lock);
1383                         if (rc) {
1384                                 /* dev->interrupt returned, but there
1385                                 * is still more work to do.
1386                                 * Reschedule work to occur as soon as
1387                                 * possible. */
1388                                 idle_cycles = 0;
1389                                 if (new_tail == NULL) {
1390                                         dev->first_busy_cnt++;
1391                                         if (!
1392                                             (list_is_last
1393                                              (lelt,
1394                                               &List_Polling_Device_Channels))) {
1395                                                 new_tail = lelt;
1396                                                 dev->moved_to_tail_cnt++;
1397                                         } else
1398                                                 dev->last_on_list_cnt++;
1399                                 }
1400
1401                         }
1402                         if (Incoming_ThreadInfo.should_stop)
1403                                 break;
1404                 }
1405                 if (new_tail != NULL) {
1406                         tot_moved_to_tail_cnt++;
1407                         list_move_tail(new_tail, &List_Polling_Device_Channels);
1408                 }
1409                 up(&Lock_Polling_Device_Channels);
1410                 cur_cycles = get_cycles();
1411                 delta_cycles = cur_cycles - old_cycles;
1412                 old_cycles = cur_cycles;
1413
1414                 /* At this point, we have scanned thru all of the
1415                 * channels, and at least one of the following is true:
1416                 * - there is no input waiting on any of the channels
1417                 * - we have received a signal to stop this thread
1418                 */
1419                 if (Incoming_ThreadInfo.should_stop)
1420                         break;
1421                 if (en_smart_wakeup == 0xFF) {
1422                         LOGINF("en_smart_wakeup set to 0xff, to force exiting process_incoming");
1423                         break;
1424                 }
1425                 /* wait for POLLJIFFIES_NORMAL jiffies, or until
1426                 * someone wakes up Wakeup_Polling_Device_Channels,
1427                 * whichever comes first only do a wait when we have
1428                 * been idle for cycles_before_wait cycles.
1429                 */
1430                 if (idle_cycles > cycles_before_wait) {
1431                         Go_Polling_Device_Channels = 0;
1432                         tot_wait_cnt++;
1433                         wait_event_timeout(Wakeup_Polling_Device_Channels,
1434                                            Go_Polling_Device_Channels,
1435                                            POLLJIFFIES_NORMAL);
1436                         Go_Polling_Device_Channels = 1;
1437                 } else {
1438                         tot_schedule_cnt++;
1439                         schedule();
1440                         idle_cycles = idle_cycles + delta_cycles;
1441                 }
1442         }
1443         DBGINF("exiting.\n");
1444         complete_and_exit(&Incoming_ThreadInfo.has_stopped, 0);
1445 }
1446
1447 static BOOL
1448 Initialize_incoming_thread(void)
1449 {
1450         if (Incoming_Thread_Started)
1451                 return TRUE;
1452         if (!uisthread_start(&Incoming_ThreadInfo,
1453                              &Process_Incoming, NULL, "dev_incoming")) {
1454                 LOGERR("uisthread_start Initialize_incoming_thread ****FAILED");
1455                 return FALSE;
1456         }
1457         Incoming_Thread_Started = TRUE;
1458         return TRUE;
1459 }
1460
1461 /*  Add a new device/channel to the list being processed by
1462  *  Process_Incoming().
1463  *  <interrupt> - indicates the function to call periodically.
1464  *  <interrupt_context> - indicates the data to pass to the <interrupt>
1465  *                        function.
1466  */
1467 void
1468 uislib_enable_channel_interrupts(u32 bus_no, u32 dev_no,
1469                                  int (*interrupt)(void *),
1470                                  void *interrupt_context)
1471 {
1472         struct device_info *dev;
1473
1474         dev = find_dev(bus_no, dev_no);
1475         if (!dev) {
1476                 LOGERR("%s busNo=%d, devNo=%d", __func__, (int) (bus_no),
1477                        (int) (dev_no));
1478                 return;
1479         }
1480         down(&Lock_Polling_Device_Channels);
1481         Initialize_incoming_thread();
1482         dev->interrupt = interrupt;
1483         dev->interrupt_context = interrupt_context;
1484         dev->polling = TRUE;
1485         list_add_tail(&(dev->list_polling_device_channels),
1486                       &List_Polling_Device_Channels);
1487         up(&Lock_Polling_Device_Channels);
1488 }
1489 EXPORT_SYMBOL_GPL(uislib_enable_channel_interrupts);
1490
1491 /*  Remove a device/channel from the list being processed by
1492  *  Process_Incoming().
1493  */
1494 void
1495 uislib_disable_channel_interrupts(u32 bus_no, u32 dev_no)
1496 {
1497         struct device_info *dev;
1498
1499         dev = find_dev(bus_no, dev_no);
1500         if (!dev) {
1501                 LOGERR("%s busNo=%d, devNo=%d", __func__, (int) (bus_no),
1502                        (int) (dev_no));
1503                 return;
1504         }
1505         down(&Lock_Polling_Device_Channels);
1506         list_del(&dev->list_polling_device_channels);
1507         dev->polling = FALSE;
1508         dev->interrupt = NULL;
1509         up(&Lock_Polling_Device_Channels);
1510 }
1511 EXPORT_SYMBOL_GPL(uislib_disable_channel_interrupts);
1512
1513 static void
1514 do_wakeup_polling_device_channels(struct work_struct *dummy)
1515 {
1516         if (!Go_Polling_Device_Channels) {
1517                 Go_Polling_Device_Channels = 1;
1518                 wake_up(&Wakeup_Polling_Device_Channels);
1519         }
1520 }
1521
1522 static DECLARE_WORK(Work_wakeup_polling_device_channels,
1523                     do_wakeup_polling_device_channels);
1524
1525 /*  Call this function when you want to send a hint to Process_Incoming() that
1526  *  your device might have more requests.
1527  */
1528 void
1529 uislib_force_channel_interrupt(u32 bus_no, u32 dev_no)
1530 {
1531         if (en_smart_wakeup == 0)
1532                 return;
1533         if (Go_Polling_Device_Channels)
1534                 return;
1535         /* The point of using schedule_work() instead of just doing
1536          * the work inline is to force a slight delay before waking up
1537          * the Process_Incoming() thread.
1538          */
1539         tot_wakeup_cnt++;
1540         schedule_work(&Work_wakeup_polling_device_channels);
1541 }
1542 EXPORT_SYMBOL_GPL(uislib_force_channel_interrupt);
1543
1544 /*****************************************************/
1545 /* Module Init & Exit functions                      */
1546 /*****************************************************/
1547
1548 static int __init
1549 uislib_mod_init(void)
1550 {
1551
1552         if (!unisys_spar_platform)
1553                 return -ENODEV;
1554
1555         LOGINF("MONITORAPIS");
1556
1557         LOGINF("sizeof(struct uiscmdrsp):%lu bytes\n",
1558                (ulong) sizeof(struct uiscmdrsp));
1559         LOGINF("sizeof(struct phys_info):%lu\n",
1560                (ulong) sizeof(struct phys_info));
1561         LOGINF("sizeof(uiscmdrsp_scsi):%lu\n",
1562                (ulong) sizeof(struct uiscmdrsp_scsi));
1563         LOGINF("sizeof(uiscmdrsp_net):%lu\n",
1564                (ulong) sizeof(struct uiscmdrsp_net));
1565         LOGINF("sizeof(CONTROLVM_MESSAGE):%lu bytes\n",
1566                (ulong) sizeof(struct controlvm_message));
1567         LOGINF("sizeof(struct spar_controlvm_channel_protocol):%lu bytes\n",
1568                (ulong) sizeof(struct spar_controlvm_channel_protocol));
1569         LOGINF("sizeof(CHANNEL_HEADER):%lu bytes\n",
1570                (ulong) sizeof(struct channel_header));
1571         LOGINF("sizeof(ULTRA_IO_CHANNEL_PROTOCOL):%lu bytes\n",
1572                (ulong) sizeof(ULTRA_IO_CHANNEL_PROTOCOL));
1573         LOGINF("SIZEOF_CMDRSP:%lu bytes\n", SIZEOF_CMDRSP);
1574         LOGINF("SIZEOF_PROTOCOL:%lu bytes\n", SIZEOF_PROTOCOL);
1575
1576         /* initialize global pointers to NULL */
1577         BusListHead = NULL;
1578         BusListCount = MaxBusCount = 0;
1579         rwlock_init(&BusListLock);
1580         virt_control_chan_func = NULL;
1581
1582         /* Issue VMCALL_GET_CONTROLVM_ADDR to get CtrlChanPhysAddr and
1583          * then map this physical address to a virtual address. */
1584         POSTCODE_LINUX_2(DRIVER_ENTRY_PC, POSTCODE_SEVERITY_INFO);
1585
1586         dir_debugfs = debugfs_create_dir(DIR_DEBUGFS_ENTRY, NULL);
1587         if (dir_debugfs) {
1588                 info_debugfs_entry = debugfs_create_file(
1589                         INFO_DEBUGFS_ENTRY_FN, 0444, dir_debugfs, NULL,
1590                         &debugfs_info_fops);
1591
1592                 platformnumber_debugfs_read = debugfs_create_u32(
1593                         PLATFORMNUMBER_DEBUGFS_ENTRY_FN, 0444, dir_debugfs,
1594                         &PlatformNumber);
1595
1596                 cycles_before_wait_debugfs_read = debugfs_create_u64(
1597                         CYCLES_BEFORE_WAIT_DEBUGFS_ENTRY_FN, 0666, dir_debugfs,
1598                         &cycles_before_wait);
1599
1600                 smart_wakeup_debugfs_entry = debugfs_create_bool(
1601                         SMART_WAKEUP_DEBUGFS_ENTRY_FN, 0666, dir_debugfs,
1602                         &en_smart_wakeup);
1603         }
1604
1605         POSTCODE_LINUX_3(DRIVER_EXIT_PC, 0, POSTCODE_SEVERITY_INFO);
1606         return 0;
1607 }
1608
1609 static void __exit
1610 uislib_mod_exit(void)
1611 {
1612         if (ProcReadBuffer) {
1613                 vfree(ProcReadBuffer);
1614                 ProcReadBuffer = NULL;
1615         }
1616
1617         debugfs_remove(info_debugfs_entry);
1618         debugfs_remove(smart_wakeup_debugfs_entry);
1619         debugfs_remove(cycles_before_wait_debugfs_read);
1620         debugfs_remove(platformnumber_debugfs_read);
1621         debugfs_remove(dir_debugfs);
1622
1623         DBGINF("goodbye.\n");
1624 }
1625
1626 module_init(uislib_mod_init);
1627 module_exit(uislib_mod_exit);
1628
1629 MODULE_LICENSE("GPL");
1630 MODULE_AUTHOR("Usha Srinivasan");
1631 MODULE_ALIAS("uislib");
1632   /* this is extracted during depmod and kept in modules.dep */