drivers/staging/unisys/virtpci/virtpci.c

   1 /* virtpci.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 #define EXPORT_SYMTAB
  19
  20 #include <linux/kernel.h>
  21 #ifdef CONFIG_MODVERSIONS
  22 #include <config/modversions.h>
  23 #endif
  24 #include "uniklog.h"
  25 #include "diagnostics/appos_subsystems.h"
  26 #include "uisutils.h"
  27 #include "vbuschannel.h"
  28 #include "vbushelper.h"
  29 #include <linux/types.h>
  30 #include <linux/io.h>
  31 #include <linux/uuid.h>
  32 #include <linux/module.h>
  33 #include <linux/init.h>
  34 #include <linux/pci.h>
  35 #include <linux/device.h>
  36 #include <linux/list.h>
  37 #include <linux/slab.h>
  38 #include <linux/mod_devicetable.h>
  39 #include <linux/if_ether.h>
  40 #include <linux/version.h>
  41 #include <linux/debugfs.h>
  42 #include "version.h"
  43 #include "guestlinuxdebug.h"
  44 #include "timskmod.h"
  45
  46 struct driver_private {
  47         struct kobject kobj;
  48         struct klist klist_devices;
  49         struct klist_node knode_bus;
  50         struct module_kobject *mkobj;
  51         struct device_driver *driver;
  52 };
  53 #define to_driver(obj) container_of(obj, struct driver_private, kobj)
  54
  55 /* bus_id went away in 2.6.30 - the size was 20 bytes, so we'll define
  56  * it ourselves, and a macro to make getting the field a bit simpler.
  57  */
  58 #ifndef BUS_ID_SIZE
  59 #define BUS_ID_SIZE 20
  60 #endif
  61
  62 #define BUS_ID(x) dev_name(x)
  63
  64 /* MAX_BUF = 4 busses x ( 32 devices/bus + 1 busline) x 80 characters
  65  *         = 10,560 bytes ~ 2^14 = 16,384 bytes
  66  */
  67 #define MAX_BUF 16384
  68
  69 #include "virtpci.h"
  70
  71 /* this is shorter than using __FILE__ (full path name) in
  72  * debug/info/error messages
  73  */
  74 #define CURRENT_FILE_PC VIRT_PCI_PC_virtpci_c
  75 #define __MYFILE__ "virtpci.c"
  76
  77 #define VIRTPCI_VERSION "01.00"
  78
  79 /*****************************************************/
  80 /* Forward declarations                              */
  81 /*****************************************************/
  82
  83 static int delete_vbus_device(struct device *vbus, void *data);
  84 static int match_busid(struct device *dev, void *data);
  85 static void virtpci_bus_release(struct device *dev);
  86 static void virtpci_device_release(struct device *dev);
  87 static int virtpci_device_add(struct device *parentbus, int devtype,
  88                               struct add_virt_guestpart *addparams,
  89                               struct scsi_adap_info *scsi,
  90                               struct net_adap_info *net);
  91 static int virtpci_device_del(struct device *parentbus, int devtype,
  92                               struct vhba_wwnn *wwnn, unsigned char macaddr[]);
  93 static int virtpci_device_serverdown(struct device *parentbus, int devtype,
  94                                      struct vhba_wwnn *wwnn,
  95                                      unsigned char macaddr[]);
  96 static int virtpci_device_serverup(struct device *parentbus, int devtype,
  97                                    struct vhba_wwnn *wwnn,
  98                                    unsigned char macaddr[]);
  99 static ssize_t virtpci_driver_attr_show(struct kobject *kobj,
 100                                         struct attribute *attr, char *buf);
 101 static ssize_t virtpci_driver_attr_store(struct kobject *kobj,
 102                                          struct attribute *attr,
 103                                          const char *buf, size_t count);
 104 static int virtpci_bus_match(struct device *dev, struct device_driver *drv);
 105 static int virtpci_uevent(struct device *dev, struct kobj_uevent_env *env);
 106 static int virtpci_device_suspend(struct device *dev, pm_message_t state);
 107 static int virtpci_device_resume(struct device *dev);
 108 static int virtpci_device_probe(struct device *dev);
 109 static int virtpci_device_remove(struct device *dev);
 110
 111 static ssize_t info_debugfs_read(struct file *file, char __user *buf,
 112                               size_t len, loff_t *offset);
 113
 114 static const struct file_operations debugfs_info_fops = {
 115         .read = info_debugfs_read,
 116 };
 117
 118 /*****************************************************/
 119 /* Globals                                           */
 120 /*****************************************************/
 121
 122 /* methods in bus_type struct allow the bus code to serve as an
 123  * intermediary between the device core and individual device core and
 124  * individual drivers
 125  */
 126 static struct bus_type virtpci_bus_type = {
 127         .name = "uisvirtpci",
 128         .match = virtpci_bus_match,
 129         .uevent = virtpci_uevent,
 130         .suspend = virtpci_device_suspend,
 131         .resume = virtpci_device_resume,
 132 };
 133
 134 static struct device virtpci_rootbus_device = {
 135         .init_name = "vbusroot",        /* root bus */
 136         .release = virtpci_bus_release
 137 };
 138
 139 /* filled in with info about parent chipset driver when we register with it */
 140 static ULTRA_VBUS_DEVICEINFO Chipset_DriverInfo;
 141
 142 static const struct sysfs_ops virtpci_driver_sysfs_ops = {
 143         .show = virtpci_driver_attr_show,
 144         .store = virtpci_driver_attr_store,
 145 };
 146
 147 static struct kobj_type virtpci_driver_kobj_type = {
 148         .sysfs_ops = &virtpci_driver_sysfs_ops,
 149 };
 150
 151 static struct virtpci_dev *VpcidevListHead;
 152 static DEFINE_RWLOCK(VpcidevListLock);
 153
 154 /* filled in with info about this driver, wrt it servicing client busses */
 155 static ULTRA_VBUS_DEVICEINFO Bus_DriverInfo;
 156
 157 /*****************************************************/
 158 /* debugfs entries                                   */
 159 /*****************************************************/
 160 /* dentry is used to create the debugfs entry directory
 161  * for virtpci
 162  */
 163 static struct dentry *virtpci_debugfs_dir;
 164
 165 struct virtpci_busdev {
 166         struct device virtpci_bus_device;
 167 };
 168
 169 /*****************************************************/
 170 /* Local functions                                   */
 171 /*****************************************************/
 172
 173 static inline
 174 int WAIT_FOR_IO_CHANNEL(ULTRA_IO_CHANNEL_PROTOCOL __iomem  *chanptr)
 175 {
 176         int count = 120;
 177
 178         while (count > 0) {
 179
 180                 if (ULTRA_CHANNEL_SERVER_READY(&chanptr->ChannelHeader))
 181                         return 1;
 182                 UIS_THREAD_WAIT_SEC(1);
 183                 count--;
 184         }
 185         return 0;
 186 }
 187
 188 /* Write the contents of <info> to the ULTRA_VBUS_CHANNEL_PROTOCOL.ChpInfo. */
 189 static int write_vbus_chpInfo(ULTRA_VBUS_CHANNEL_PROTOCOL *chan,
 190                               ULTRA_VBUS_DEVICEINFO *info)
 191 {
 192         int off;
 193
 194         if (!chan) {
 195                 LOGERR("vbus channel not present");
 196                 return -1;
 197         }
 198         off = sizeof(ULTRA_CHANNEL_PROTOCOL) + chan->HdrInfo.chpInfoByteOffset;
 199         if (chan->HdrInfo.chpInfoByteOffset == 0) {
 200                 LOGERR("vbus channel not used, because chpInfoByteOffset == 0");
 201                 return -1;
 202         }
 203         memcpy(((u8 *) (chan)) + off, info, sizeof(*info));
 204         return 0;
 205 }
 206
 207 /* Write the contents of <info> to the ULTRA_VBUS_CHANNEL_PROTOCOL.BusInfo. */
 208 static int write_vbus_busInfo(ULTRA_VBUS_CHANNEL_PROTOCOL *chan,
 209                               ULTRA_VBUS_DEVICEINFO *info)
 210 {
 211         int off;
 212
 213         if (!chan) {
 214                 LOGERR("vbus channel not present");
 215                 return -1;
 216         }
 217         off = sizeof(ULTRA_CHANNEL_PROTOCOL) + chan->HdrInfo.busInfoByteOffset;
 218         if (chan->HdrInfo.busInfoByteOffset == 0) {
 219                 LOGERR("vbus channel not used, because busInfoByteOffset == 0");
 220                 return -1;
 221         }
 222         memcpy(((u8 *) (chan)) + off, info, sizeof(*info));
 223         return 0;
 224 }
 225
 226 /* Write the contents of <info> to the
 227  * ULTRA_VBUS_CHANNEL_PROTOCOL.DevInfo[<devix>].
 228  */
 229 static int
 230 write_vbus_devInfo(ULTRA_VBUS_CHANNEL_PROTOCOL *chan,
 231                    ULTRA_VBUS_DEVICEINFO *info, int devix)
 232 {
 233         int off;
 234
 235         if (!chan) {
 236                 LOGERR("vbus channel not present");
 237                 return -1;
 238         }
 239         off =
 240             (sizeof(ULTRA_CHANNEL_PROTOCOL) +
 241              chan->HdrInfo.devInfoByteOffset) +
 242             (chan->HdrInfo.deviceInfoStructBytes * devix);
 243         if (chan->HdrInfo.devInfoByteOffset == 0) {
 244                 LOGERR("vbus channel not used, because devInfoByteOffset == 0");
 245                 return -1;
 246         }
 247         memcpy(((u8 *) (chan)) + off, info, sizeof(*info));
 248         return 0;
 249 }
 250
 251 /* adds a vbus
 252  * returns 0 failure, 1 success,
 253  */
 254 static int add_vbus(struct add_vbus_guestpart *addparams)
 255 {
 256         int ret;
 257         struct device *vbus;
 258
 259         vbus = kzalloc(sizeof(struct device), GFP_ATOMIC);
 260
 261         POSTCODE_LINUX_2(VPCI_CREATE_ENTRY_PC, POSTCODE_SEVERITY_INFO);
 262         if (!vbus)
 263                 return 0;
 264
 265         dev_set_name(vbus, "vbus%d", addparams->busNo);
 266         vbus->release = virtpci_bus_release;
 267         vbus->parent = &virtpci_rootbus_device; /* root bus is parent */
 268         vbus->bus = &virtpci_bus_type;  /* bus type */
 269         vbus->platform_data = (__force void *)addparams->chanptr;
 270
 271         /* register a virt bus device -
 272          * this bus shows up under /sys/devices with .name value
 273          * "virtpci%d" any devices added to this bus then show up under
 274          * /sys/devices/virtpci0
 275          */
 276         ret = device_register(vbus);
 277         if (ret) {
 278                 LOGERR("device_register FAILED:%d\n", ret);
 279                 POSTCODE_LINUX_2(VPCI_CREATE_FAILURE_PC, POSTCODE_SEVERITY_ERR);
 280                 return 0;
 281         }
 282         write_vbus_chpInfo(vbus->platform_data /* chanptr */ ,
 283                            &Chipset_DriverInfo);
 284         write_vbus_busInfo(vbus->platform_data /* chanptr */ , &Bus_DriverInfo);
 285         LOGINF("Added vbus %d; device %s created successfully\n",
 286                addparams->busNo, BUS_ID(vbus));
 287         POSTCODE_LINUX_2(VPCI_CREATE_EXIT_PC, POSTCODE_SEVERITY_INFO);
 288         return 1;
 289 }
 290
 291 /* for CHANSOCK wwwnn/max are AUTO-GENERATED; for normal channels,
 292  * wwnn/max are in the channel header.
 293  */
 294 #define GET_SCSIADAPINFO_FROM_CHANPTR(chanptr) {                        \
 295         memcpy_fromio(&scsi.wwnn,                                       \
 296                       &((ULTRA_IO_CHANNEL_PROTOCOL __iomem *)           \
 297                         chanptr)->vhba.wwnn,                            \
 298                       sizeof(struct vhba_wwnn));                        \
 299         memcpy_fromio(&scsi.max,                                        \
 300                       &((ULTRA_IO_CHANNEL_PROTOCOL __iomem *)           \
 301                         chanptr)->vhba.max,                             \
 302                       sizeof(struct vhba_config_max));                  \
 303         }
 304
 305 /* find bus device with the busid that matches - match_busid matches bus_id */
 306 #define GET_BUS_DEV(busno) { \
 307         sprintf(busid, "vbus%d", busno); \
 308         vbus = bus_find_device(&virtpci_bus_type, NULL, \
 309                                (void *)busid, match_busid);     \
 310         if (!vbus) { \
 311                 LOGERR("**** FAILED to find vbus %s\n", busid); \
 312                 return 0; \
 313         } \
 314 }
 315
 316 /* adds a vhba
 317  * returns 0 failure, 1 success,
 318  */
 319 static int add_vhba(struct add_virt_guestpart *addparams)
 320 {
 321         int i;
 322         struct scsi_adap_info scsi;
 323         struct device *vbus;
 324         unsigned char busid[BUS_ID_SIZE];
 325
 326         POSTCODE_LINUX_2(VPCI_CREATE_ENTRY_PC, POSTCODE_SEVERITY_INFO);
 327         if (!WAIT_FOR_IO_CHANNEL
 328             ((ULTRA_IO_CHANNEL_PROTOCOL __iomem *) addparams->chanptr)) {
 329                 LOGERR("Timed out.  Channel not ready\n");
 330                 POSTCODE_LINUX_2(VPCI_CREATE_FAILURE_PC, POSTCODE_SEVERITY_ERR);
 331                 return 0;
 332         }
 333
 334         GET_SCSIADAPINFO_FROM_CHANPTR(addparams->chanptr);
 335
 336         GET_BUS_DEV(addparams->bus_no);
 337
 338         LOGINF("Adding vhba wwnn:%x:%x config:%d-%d-%d-%d chanptr:%p\n",
 339                scsi.wwnn.wwnn1, scsi.wwnn.wwnn2,
 340                scsi.max.max_channel, scsi.max.max_id, scsi.max.max_lun,
 341                scsi.max.cmd_per_lun, addparams->chanptr);
 342         i = virtpci_device_add(vbus, VIRTHBA_TYPE, addparams, &scsi, NULL);
 343         if (i) {
 344                 LOGINF("Added vhba wwnn:%x:%x chanptr:%p\n", scsi.wwnn.wwnn1,
 345                        scsi.wwnn.wwnn2, addparams->chanptr);
 346                 POSTCODE_LINUX_3(VPCI_CREATE_EXIT_PC, i,
 347                                  POSTCODE_SEVERITY_INFO);
 348         }
 349         return i;
 350
 351 }
 352
 353 /* for CHANSOCK macaddr is AUTO-GENERATED; for normal channels,
 354  * macaddr is in the channel header.
 355  */
 356 #define GET_NETADAPINFO_FROM_CHANPTR(chanptr) {                         \
 357                 memcpy_fromio(net.mac_addr,                             \
 358                        ((ULTRA_IO_CHANNEL_PROTOCOL __iomem *)           \
 359                         chanptr)->vnic.macaddr,                         \
 360                        MAX_MACADDR_LEN);                                \
 361                 net.num_rcv_bufs =                                      \
 362                         readl(&((ULTRA_IO_CHANNEL_PROTOCOL __iomem *)   \
 363                                 chanptr)->vnic.num_rcv_bufs);           \
 364                 net.mtu = readl(&((ULTRA_IO_CHANNEL_PROTOCOL __iomem *) \
 365                                   chanptr)->vnic.mtu);                  \
 366                 memcpy_fromio(&net.zoneGuid, \
 367                               &((ULTRA_IO_CHANNEL_PROTOCOL __iomem *)   \
 368                                 chanptr)->vnic.zoneGuid,                \
 369                               sizeof(uuid_le));                         \
 370 }
 371
 372 /* adds a vnic
 373  * returns 0 failure, 1 success,
 374  */
 375 static int
 376 add_vnic(struct add_virt_guestpart *addparams)
 377 {
 378         int i;
 379         struct net_adap_info net;
 380         struct device *vbus;
 381         unsigned char busid[BUS_ID_SIZE];
 382
 383         POSTCODE_LINUX_2(VPCI_CREATE_ENTRY_PC, POSTCODE_SEVERITY_INFO);
 384         if (!WAIT_FOR_IO_CHANNEL
 385             ((ULTRA_IO_CHANNEL_PROTOCOL __iomem *) addparams->chanptr)) {
 386                 LOGERR("Timed out, channel not ready\n");
 387                 POSTCODE_LINUX_2(VPCI_CREATE_FAILURE_PC, POSTCODE_SEVERITY_ERR);
 388                 return 0;
 389         }
 390
 391         GET_NETADAPINFO_FROM_CHANPTR(addparams->chanptr);
 392
 393         GET_BUS_DEV(addparams->bus_no);
 394
 395         LOGINF("Adding vnic macaddr:%02x:%02x:%02x:%02x:%02x:%02x rcvbufs:%d mtu:%d chanptr:%p%pUL\n",
 396              net.mac_addr[0], net.mac_addr[1], net.mac_addr[2], net.mac_addr[3],
 397              net.mac_addr[4], net.mac_addr[5], net.num_rcv_bufs, net.mtu,
 398              addparams->chanptr, &net.zoneGuid);
 399         i = virtpci_device_add(vbus, VIRTNIC_TYPE, addparams, NULL, &net);
 400         if (i) {
 401                 LOGINF("Added vnic macaddr:%02x:%02x:%02x:%02x:%02x:%02x\n",
 402                        net.mac_addr[0], net.mac_addr[1], net.mac_addr[2],
 403                        net.mac_addr[3], net.mac_addr[4], net.mac_addr[5]);
 404                 POSTCODE_LINUX_3(VPCI_CREATE_EXIT_PC, i,
 405                                  POSTCODE_SEVERITY_INFO);
 406                 return 1;
 407         }
 408         return 0;
 409 }
 410
 411 /* delete vbus
 412  * returns 0 failure, 1 success,
 413  */
 414 static int
 415 delete_vbus(struct del_vbus_guestpart *delparams)
 416 {
 417         struct device *vbus;
 418         unsigned char busid[BUS_ID_SIZE];
 419
 420         GET_BUS_DEV(delparams->bus_no);
 421         /* ensure that bus has no devices? -- TBD */
 422         LOGINF("Deleting %s\n", BUS_ID(vbus));
 423         if (delete_vbus_device(vbus, NULL))
 424                 return 0;       /* failure */
 425         LOGINF("Deleted vbus %d\n", delparams->bus_no);
 426         return 1;
 427 }
 428
 429 static int
 430 delete_vbus_device(struct device *vbus, void *data)
 431 {
 432         int checkforroot = (data != NULL);
 433         struct device *pDev = &virtpci_rootbus_device;
 434
 435         if ((checkforroot) && match_busid(vbus, (void *) BUS_ID(pDev))) {
 436                 /* skip it - don't delete root bus */
 437                 LOGINF("skipping root bus\n");
 438                 return 0;       /* pretend no error */
 439         }
 440         LOGINF("Calling unregister for %s\n", BUS_ID(vbus));
 441         device_unregister(vbus);
 442         kfree(vbus);
 443         LOGINF("VBus unregister and freed\n");
 444         return 0;               /* no error */
 445 }
 446
 447 /* pause vhba
 448 * returns 0 failure, 1 success,
 449 */
 450 static int pause_vhba(struct pause_virt_guestpart *pauseparams)
 451 {
 452         int i;
 453         struct scsi_adap_info scsi;
 454
 455         GET_SCSIADAPINFO_FROM_CHANPTR(pauseparams->chanptr);
 456
 457         LOGINF("Pausing vhba wwnn:%x:%x\n", scsi.wwnn.wwnn1, scsi.wwnn.wwnn2);
 458         i = virtpci_device_serverdown(NULL /*no parent bus */ , VIRTHBA_TYPE,
 459                                       &scsi.wwnn, NULL);
 460         if (i)
 461                 LOGINF("Paused vhba wwnn:%x:%x\n", scsi.wwnn.wwnn1,
 462                        scsi.wwnn.wwnn2);
 463         return i;
 464 }
 465
 466 /* pause vnic
 467  * returns 0 failure, 1 success,
 468  */
 469 static int pause_vnic(struct pause_virt_guestpart *pauseparams)
 470 {
 471         int i;
 472         struct net_adap_info net;
 473
 474         GET_NETADAPINFO_FROM_CHANPTR(pauseparams->chanptr);
 475
 476         LOGINF("Pausing vnic macaddr:%02x:%02x:%02x:%02x:%02x:%02x\n",
 477                net.mac_addr[0], net.mac_addr[1], net.mac_addr[2],
 478                net.mac_addr[3], net.mac_addr[4], net.mac_addr[5]);
 479         i = virtpci_device_serverdown(NULL /*no parent bus */ , VIRTNIC_TYPE,
 480                                       NULL, net.mac_addr);
 481         if (i) {
 482                 LOGINF(" Paused vnic macaddr:%02x:%02x:%02x:%02x:%02x:%02x\n",
 483                        net.mac_addr[0], net.mac_addr[1], net.mac_addr[2],
 484                        net.mac_addr[3], net.mac_addr[4], net.mac_addr[5]);
 485         }
 486         return i;
 487 }
 488
 489 /* resume vhba
 490  * returns 0 failure, 1 success,
 491  */
 492 static int resume_vhba(struct resume_virt_guestpart *resumeparams)
 493 {
 494         int i;
 495         struct scsi_adap_info scsi;
 496
 497         GET_SCSIADAPINFO_FROM_CHANPTR(resumeparams->chanptr);
 498
 499         LOGINF("Resuming vhba wwnn:%x:%x\n", scsi.wwnn.wwnn1, scsi.wwnn.wwnn2);
 500         i = virtpci_device_serverup(NULL /*no parent bus */ , VIRTHBA_TYPE,
 501                                     &scsi.wwnn, NULL);
 502         if (i)
 503                 LOGINF("Resumed vhba wwnn:%x:%x\n", scsi.wwnn.wwnn1,
 504                        scsi.wwnn.wwnn2);
 505         return i;
 506 }
 507
 508 /* resume vnic
 509 * returns 0 failure, 1 success,
 510 */
 511 static int
 512 resume_vnic(struct resume_virt_guestpart *resumeparams)
 513 {
 514         int i;
 515         struct net_adap_info net;
 516
 517         GET_NETADAPINFO_FROM_CHANPTR(resumeparams->chanptr);
 518
 519         LOGINF("Resuming vnic macaddr:%02x:%02x:%02x:%02x:%02x:%02x\n",
 520                net.mac_addr[0], net.mac_addr[1], net.mac_addr[2],
 521                net.mac_addr[3], net.mac_addr[4], net.mac_addr[5]);
 522         i = virtpci_device_serverup(NULL /*no parent bus */ , VIRTNIC_TYPE,
 523                                     NULL, net.mac_addr);
 524         if (i) {
 525                 LOGINF(" Resumed vnic macaddr:%02x:%02x:%02x:%02x:%02x:%02x\n",
 526                        net.mac_addr[0], net.mac_addr[1], net.mac_addr[2],
 527                        net.mac_addr[3], net.mac_addr[4], net.mac_addr[5]);
 528         }
 529         return i;
 530 }
 531
 532 /* delete vhba
 533 * returns 0 failure, 1 success,
 534 */
 535 static int delete_vhba(struct del_virt_guestpart *delparams)
 536 {
 537         int i;
 538         struct scsi_adap_info scsi;
 539
 540         GET_SCSIADAPINFO_FROM_CHANPTR(delparams->chanptr);
 541
 542         LOGINF("Deleting vhba wwnn:%x:%x\n", scsi.wwnn.wwnn1, scsi.wwnn.wwnn2);
 543         i = virtpci_device_del(NULL /*no parent bus */ , VIRTHBA_TYPE,
 544                                &scsi.wwnn, NULL);
 545         if (i) {
 546                 LOGINF("Deleted vhba wwnn:%x:%x\n", scsi.wwnn.wwnn1,
 547                        scsi.wwnn.wwnn2);
 548                 return 1;
 549         }
 550         return 0;
 551 }
 552
 553 /* deletes a vnic
 554  * returns 0 failure, 1 success,
 555  */
 556 static int delete_vnic(struct del_virt_guestpart *delparams)
 557 {
 558         int i;
 559         struct net_adap_info net;
 560
 561         GET_NETADAPINFO_FROM_CHANPTR(delparams->chanptr);
 562
 563         LOGINF("Deleting vnic macaddr:%02x:%02x:%02x:%02x:%02x:%02x\n",
 564                net.mac_addr[0], net.mac_addr[1], net.mac_addr[2],
 565                net.mac_addr[3], net.mac_addr[4], net.mac_addr[5]);
 566         i = virtpci_device_del(NULL /*no parent bus */ , VIRTNIC_TYPE, NULL,
 567                                net.mac_addr);
 568         if (i) {
 569                 LOGINF("Deleted vnic macaddr:%02x:%02x:%02x:%02x:%02x:%02x\n",
 570                        net.mac_addr[0], net.mac_addr[1], net.mac_addr[2],
 571                        net.mac_addr[3], net.mac_addr[4], net.mac_addr[5]);
 572         }
 573         return i;
 574 }
 575
 576 #define DELETE_ONE_VPCIDEV(vpcidev) { \
 577         LOGINF("calling device_unregister:%p\n", &vpcidev->generic_dev); \
 578         device_unregister(&vpcidev->generic_dev); \
 579         LOGINF("Deleted %p\n", vpcidev); \
 580         kfree(vpcidev); \
 581 }
 582
 583 /* deletes all vhbas and vnics
 584  * returns 0 failure, 1 success,
 585  */
 586 static void delete_all(void)
 587 {
 588         int count = 0;
 589         unsigned long flags;
 590         struct virtpci_dev *tmpvpcidev, *nextvpcidev;
 591
 592         /* delete the entire vhba/vnic list in one shot */
 593         write_lock_irqsave(&VpcidevListLock, flags);
 594         tmpvpcidev = VpcidevListHead;
 595         VpcidevListHead = NULL;
 596         write_unlock_irqrestore(&VpcidevListLock, flags);
 597
 598         /* delete one vhba/vnic at a time */
 599         while (tmpvpcidev) {
 600                 nextvpcidev = tmpvpcidev->next;
 601                 /* delete the vhba/vnic at tmpvpcidev */
 602                 DELETE_ONE_VPCIDEV(tmpvpcidev);
 603                 tmpvpcidev = nextvpcidev;
 604                 count++;
 605         }
 606         LOGINF("Deleted %d vhbas/vnics.\n", count);
 607
 608         /* now delete each vbus */
 609         if (bus_for_each_dev
 610             (&virtpci_bus_type, NULL, (void *) 1, delete_vbus_device))
 611                 LOGERR("delete of all vbus failed\n");
 612 }
 613
 614 /* deletes all vnics or vhbas
 615  * returns 0 failure, 1 success,
 616  */
 617 static int delete_all_virt(VIRTPCI_DEV_TYPE devtype, struct del_vbus_guestpart *delparams)
 618 {
 619         int i;
 620         unsigned char busid[BUS_ID_SIZE];
 621         struct device *vbus;
 622
 623         GET_BUS_DEV(delparams->bus_no);
 624
 625         if ((devtype != VIRTHBA_TYPE) && (devtype != VIRTNIC_TYPE)) {
 626                 LOGERR("**** FAILED to delete all devices; devtype:%d not vhba:%d or vnic:%d\n",
 627                      devtype, VIRTHBA_TYPE, VIRTNIC_TYPE);
 628                 return 0;
 629         }
 630
 631         LOGINF("Deleting all %s in vbus %s\n",
 632                devtype == VIRTHBA_TYPE ? "vhbas" : "vnics", busid);
 633         /* delete all vhbas/vnics */
 634         i = virtpci_device_del(vbus, devtype, NULL, NULL);
 635         if (i > 0)
 636                 LOGINF("Deleted %d %s\n", i,
 637                        devtype == VIRTHBA_TYPE ? "vhbas" : "vnics");
 638         return 1;
 639 }
 640
 641 static int virtpci_ctrlchan_func(struct guest_msgs *msg)
 642 {
 643         switch (msg->msgtype) {
 644         case GUEST_ADD_VBUS:
 645                 return add_vbus(&msg->add_vbus);
 646         case GUEST_ADD_VHBA:
 647                 return add_vhba(&msg->add_vhba);
 648         case GUEST_ADD_VNIC:
 649                 return add_vnic(&msg->add_vnic);
 650         case GUEST_DEL_VBUS:
 651                 return delete_vbus(&msg->del_vbus);
 652         case GUEST_DEL_VHBA:
 653                 return delete_vhba(&msg->del_vhba);
 654         case GUEST_DEL_VNIC:
 655                 return delete_vnic(&msg->del_vhba);
 656         case GUEST_DEL_ALL_VHBAS:
 657                 return delete_all_virt(VIRTHBA_TYPE, &msg->del_all_vhbas);
 658         case GUEST_DEL_ALL_VNICS:
 659                 return delete_all_virt(VIRTNIC_TYPE, &msg->del_all_vnics);
 660         case GUEST_DEL_ALL_VBUSES:
 661                 delete_all();
 662                 return 1;
 663         case GUEST_PAUSE_VHBA:
 664                 return pause_vhba(&msg->pause_vhba);
 665         case GUEST_PAUSE_VNIC:
 666                 return pause_vnic(&msg->pause_vnic);
 667         case GUEST_RESUME_VHBA:
 668                 return resume_vhba(&msg->resume_vhba);
 669         case GUEST_RESUME_VNIC:
 670                 return resume_vnic(&msg->resume_vnic);
 671         default:
 672                 LOGERR("invalid message type %d.\n", msg->msgtype);
 673                 return 0;
 674         }
 675 }
 676
 677 /* same as driver_helper in bus.c linux */
 678 static int match_busid(struct device *dev, void *data)
 679 {
 680         const char *name = data;
 681
 682         if (strcmp(name, BUS_ID(dev)) == 0)
 683                 return 1;
 684         return 0;
 685 }
 686
 687 /*****************************************************/
 688 /*  Bus functions                                    */
 689 /*****************************************************/
 690
 691 static const struct pci_device_id *
 692 virtpci_match_device(const struct pci_device_id *ids,
 693                      const struct virtpci_dev *dev)
 694 {
 695         while (ids->vendor || ids->subvendor || ids->class_mask) {
 696                 DBGINF("ids->vendor:%x dev->vendor:%x ids->device:%x dev->device:%x\n",
 697                      ids->vendor, dev->vendor, ids->device, dev->device);
 698
 699                 if ((ids->vendor == dev->vendor)
 700                     && (ids->device == dev->device))
 701                         return ids;
 702
 703                 ids++;
 704         }
 705         return NULL;
 706 }
 707
 708 /* NOTE: !!!!!!  This function is called when a new device is added
 709 * for this bus.  Or, it is called for existing devices when a new
 710 * driver is added for this bus.  It returns nonzero if a given device
 711 * can be handled by the given driver.
 712 */
 713 static int virtpci_bus_match(struct device *dev, struct device_driver *drv)
 714 {
 715         struct virtpci_dev *virtpcidev = device_to_virtpci_dev(dev);
 716         struct virtpci_driver *virtpcidrv = driver_to_virtpci_driver(drv);
 717         int match = 0;
 718
 719         DBGINF("In virtpci_bus_match dev->bus_id:%s drv->name:%s\n",
 720                dev->bus_id, drv->name);
 721
 722         /* check ids list for a match */
 723         if (virtpci_match_device(virtpcidrv->id_table, virtpcidev))
 724                 match = 1;
 725
 726         DBGINF("returning match:%d\n", match);
 727         return match;           /* 0 - no match; 1 - yes it matches */
 728 }
 729
 730 static int virtpci_uevent(struct device *dev, struct kobj_uevent_env *env)
 731 {
 732         DBGINF("In virtpci_hotplug\n");
 733         /* add variables to the environment prior to the generation of
 734          * hotplug events to user space
 735          */
 736         if (add_uevent_var(env, "VIRTPCI_VERSION=%s", VIRTPCI_VERSION))
 737                 return -ENOMEM;
 738         return 0;
 739 }
 740
 741 static int virtpci_device_suspend(struct device *dev, pm_message_t state)
 742 {
 743         DBGINF("In virtpci_device_suspend -NYI ****\n");
 744         return 0;
 745 }
 746
 747 static int virtpci_device_resume(struct device *dev)
 748 {
 749         DBGINF("In virtpci_device_resume -NYI ****\n");
 750         return 0;
 751 }
 752
 753 /* For a child device just created on a client bus, fill in
 754  * information about the driver that is controlling this device into
 755  * the the appropriate slot within the vbus channel of the bus
 756  * instance.
 757  */
 758 static void fix_vbus_devInfo(struct device *dev, int devNo, int devType,
 759                              struct virtpci_driver *virtpcidrv)
 760 {
 761         struct device *vbus;
 762         void *pChan;
 763         ULTRA_VBUS_DEVICEINFO devInfo;
 764         const char *stype;
 765
 766         if (!dev) {
 767                 LOGERR("%s dev is NULL", __func__);
 768                 return;
 769         }
 770         if (!virtpcidrv) {
 771                 LOGERR("%s driver is NULL", __func__);
 772                 return;
 773         }
 774         vbus = dev->parent;
 775         if (!vbus) {
 776                 LOGERR("%s dev has no parent bus", __func__);
 777                 return;
 778         }
 779         pChan = vbus->platform_data;
 780         if (!pChan) {
 781                 LOGERR("%s dev bus has no channel", __func__);
 782                 return;
 783         }
 784         switch (devType) {
 785         case PCI_DEVICE_ID_VIRTHBA:
 786                 stype = "vHBA";
 787                 break;
 788         case PCI_DEVICE_ID_VIRTNIC:
 789                 stype = "vNIC";
 790                 break;
 791         default:
 792                 stype = "unknown";
 793                 break;
 794         }
 795         BusDeviceInfo_Init(&devInfo, stype,
 796                            virtpcidrv->name,
 797                            virtpcidrv->version,
 798                            virtpcidrv->vertag);
 799         write_vbus_devInfo(pChan, &devInfo, devNo);
 800
 801         /* Re-write bus+chipset info, because it is possible that this
 802         * was previously written by our good counterpart, visorbus.
 803         */
 804         write_vbus_chpInfo(pChan, &Chipset_DriverInfo);
 805         write_vbus_busInfo(pChan, &Bus_DriverInfo);
 806 }
 807
 808 /* This function is called to query the existence of a specific device
 809 * and whether this driver can work with it.  It should return -ENODEV
 810 * in case of failure.
 811 */
 812 static int virtpci_device_probe(struct device *dev)
 813 {
 814         struct virtpci_dev *virtpcidev = device_to_virtpci_dev(dev);
 815         struct virtpci_driver *virtpcidrv =
 816             driver_to_virtpci_driver(dev->driver);
 817         const struct pci_device_id *id;
 818         int error = 0;
 819
 820         LOGINF("In virtpci_device_probe dev:%p virtpcidev:%p virtpcidrv:%p\n",
 821                dev, virtpcidev, virtpcidrv);    /* VERBOSE/DEBUG ? */
 822         POSTCODE_LINUX_2(VPCI_PROBE_ENTRY_PC, POSTCODE_SEVERITY_INFO);
 823         /* static match and static probe vs dynamic match & dynamic
 824          * probe - do we care?.
 825          */
 826         if (!virtpcidrv->id_table)
 827                 return -ENODEV;
 828
 829         id = virtpci_match_device(virtpcidrv->id_table, virtpcidev);
 830         if (!id)
 831                 return -ENODEV;
 832
 833         /* increment reference count */
 834         get_device(dev);
 835
 836         /* if virtpcidev is not already claimed & probe function is
 837          * valid, probe it
 838          */
 839         if (!virtpcidev->mydriver && virtpcidrv->probe) {
 840                 /* call the probe function - virthba or virtnic probe
 841                  * is what it should be
 842                  */
 843                 error = virtpcidrv->probe(virtpcidev, id);
 844                 if (!error) {
 845                         fix_vbus_devInfo(dev, virtpcidev->deviceNo,
 846                                          virtpcidev->device, virtpcidrv);
 847                         virtpcidev->mydriver = virtpcidrv;
 848                         POSTCODE_LINUX_2(VPCI_PROBE_EXIT_PC,
 849                                          POSTCODE_SEVERITY_INFO);
 850                 } else
 851                         put_device(dev);
 852         }
 853         POSTCODE_LINUX_2(VPCI_PROBE_FAILURE_PC, POSTCODE_SEVERITY_ERR);
 854         return error;           /* -ENODEV for probe failure */
 855 }
 856
 857 static int virtpci_device_remove(struct device *dev_)
 858 {
 859         /* dev_ passed in is the HBA device which we called
 860         * generic_dev in our virtpcidev struct
 861         */
 862         struct virtpci_dev *virtpcidev = device_to_virtpci_dev(dev_);
 863         struct virtpci_driver *virtpcidrv = virtpcidev->mydriver;
 864
 865         LOGINF("In virtpci_device_remove bus_id:%s dev_:%p virtpcidev:%p dev->driver:%p drivername:%s\n",
 866                BUS_ID(dev_), dev_, virtpcidev, dev_->driver,
 867                dev_->driver->name);     /* VERBOSE/DEBUG */
 868         if (virtpcidrv) {
 869                 /* TEMP: assuming we have only one such driver for now */
 870                 if (virtpcidrv->remove)
 871                         virtpcidrv->remove(virtpcidev);
 872                 virtpcidev->mydriver = NULL;
 873         }
 874
 875         DBGINF("calling putdevice\n");
 876         put_device(dev_);
 877
 878         DBGINF("Leaving\n");
 879         return 0;
 880 }
 881
 882 /*****************************************************/
 883 /* Bus functions                                     */
 884 /*****************************************************/
 885
 886 static void virtpci_bus_release(struct device *dev)
 887 {
 888         /* this function is called when the last reference to the
 889          * device is removed
 890          */
 891         DBGINF("In virtpci_bus_release\n");
 892         /* what else is supposed to happen here? */
 893 }
 894
 895 /*****************************************************/
 896 /* Adapter functions                                 */
 897 /*****************************************************/
 898
 899 static int virtpci_device_add(struct device *parentbus, int devtype,
 900                               struct add_virt_guestpart *addparams,
 901                               struct scsi_adap_info *scsi, /* NULL for VNIC add */
 902                               struct net_adap_info *net /* NULL for VHBA add */)
 903 {
 904         struct virtpci_dev *virtpcidev = NULL;
 905         struct virtpci_dev *tmpvpcidev = NULL, *prev;
 906         unsigned long flags;
 907         int ret;
 908         ULTRA_IO_CHANNEL_PROTOCOL __iomem *pIoChan = NULL;
 909         struct device *pDev;
 910
 911         LOGINF("virtpci_device_add parentbus:%p chanptr:%p\n", parentbus,
 912                addparams->chanptr);
 913
 914         POSTCODE_LINUX_2(VPCI_CREATE_ENTRY_PC, POSTCODE_SEVERITY_INFO);
 915
 916         if ((devtype != VIRTHBA_TYPE) && (devtype != VIRTNIC_TYPE)) {
 917                 LOGERR("**** FAILED to add device; devtype:%d not vhba:%d or vnic:%d\n",
 918                      devtype, VIRTHBA_TYPE, VIRTNIC_TYPE);
 919                 POSTCODE_LINUX_3(VPCI_CREATE_FAILURE_PC, devtype,
 920                                  POSTCODE_SEVERITY_ERR);
 921                 return 0;
 922         }
 923
 924         /* add a Virtual Device */
 925         virtpcidev = kzalloc(sizeof(struct virtpci_dev), GFP_ATOMIC);
 926         if (virtpcidev == NULL) {
 927                 LOGERR("can't add device - malloc FALLED\n");
 928                 POSTCODE_LINUX_2(MALLOC_FAILURE_PC, POSTCODE_SEVERITY_ERR);
 929                 return 0;
 930         }
 931
 932         /* initialize stuff unique to virtpci_dev struct */
 933         virtpcidev->devtype = devtype;
 934         if (devtype == VIRTHBA_TYPE) {
 935                 virtpcidev->device = PCI_DEVICE_ID_VIRTHBA;
 936                 virtpcidev->scsi = *scsi;
 937         } else {
 938                 virtpcidev->device = PCI_DEVICE_ID_VIRTNIC;
 939                 virtpcidev->net = *net;
 940         }
 941         virtpcidev->vendor = PCI_VENDOR_ID_UNISYS;
 942         virtpcidev->busNo = addparams->bus_no;
 943         virtpcidev->deviceNo = addparams->device_no;
 944
 945         virtpcidev->queueinfo.chan = addparams->chanptr;
 946         virtpcidev->queueinfo.send_int_if_needed = NULL;
 947
 948         /* Set up safe queue... */
 949         pIoChan = (ULTRA_IO_CHANNEL_PROTOCOL __iomem *)
 950                 virtpcidev->queueinfo.chan;
 951
 952         virtpcidev->intr = addparams->intr;
 953
 954         /* initialize stuff in the device portion of the struct */
 955         virtpcidev->generic_dev.bus = &virtpci_bus_type;
 956         virtpcidev->generic_dev.parent = parentbus;
 957         virtpcidev->generic_dev.release = virtpci_device_release;
 958
 959         dev_set_name(&virtpcidev->generic_dev, "%x:%x",
 960                      addparams->bus_no, addparams->device_no);
 961
 962         /* add the vhba/vnic to virtpci device list - but check for
 963          * duplicate wwnn/macaddr first
 964          */
 965         write_lock_irqsave(&VpcidevListLock, flags);
 966         for (tmpvpcidev = VpcidevListHead; tmpvpcidev;
 967              tmpvpcidev = tmpvpcidev->next) {
 968                 if (devtype == VIRTHBA_TYPE) {
 969                         if ((tmpvpcidev->scsi.wwnn.wwnn1 == scsi->wwnn.wwnn1) &&
 970                             (tmpvpcidev->scsi.wwnn.wwnn2 == scsi->wwnn.wwnn2)) {
 971                                 /* duplicate - already have vpcidev
 972                                    with this wwnn */
 973                                 break;
 974                         }
 975                 } else
 976                     if (memcmp
 977                         (tmpvpcidev->net.mac_addr, net->mac_addr,
 978                          MAX_MACADDR_LEN) == 0) {
 979                         /* duplicate - already have vnic with this wwnn */
 980                         break;
 981                 }
 982         }
 983         if (tmpvpcidev) {
 984                 /* found a vhba/vnic already in the list with same
 985                  * wwnn or macaddr - reject add
 986                  */
 987                 write_unlock_irqrestore(&VpcidevListLock, flags);
 988                 kfree(virtpcidev);
 989                 LOGERR("**** FAILED vhba/vnic already exists in the list\n");
 990                 POSTCODE_LINUX_2(VPCI_CREATE_FAILURE_PC, POSTCODE_SEVERITY_ERR);
 991                 return 0;
 992         }
 993
 994         /* add it at the head */
 995         if (!VpcidevListHead)
 996                 VpcidevListHead = virtpcidev;
 997         else {
 998                 /* insert virtpcidev at the head of our linked list of
 999                  * vpcidevs
1000                  */
1001                 virtpcidev->next = VpcidevListHead;
1002                 VpcidevListHead = virtpcidev;
1003         }
1004
1005         write_unlock_irqrestore(&VpcidevListLock, flags);
1006
1007         /* Must transition channel to ATTACHED state BEFORE
1008          * registering the device, because polling of the channel
1009          * queues can begin at any time after device_register().
1010          */
1011         pDev = &virtpcidev->generic_dev;
1012         ULTRA_CHANNEL_CLIENT_TRANSITION(addparams->chanptr,
1013                                         BUS_ID(pDev),
1014                                         CHANNELCLI_ATTACHED, NULL);
1015
1016         /* don't register until device has been added to
1017         * list. Otherwise, a device_unregister from this function can
1018         * cause a "scheduling while atomic".
1019         */
1020         DBGINF("registering device:%p with bus_id:%s\n",
1021                &virtpcidev->generic_dev, virtpcidev->generic_dev.bus_id);
1022         ret = device_register(&virtpcidev->generic_dev);
1023         /* NOTE: THIS IS CALLING HOTPLUG virtpci_hotplug!!!
1024          * This call to device_register results in virtpci_bus_match
1025          * being called !!!!!  And, if match returns success, then
1026          * virtpcidev->generic_dev.driver is setup to core_driver,
1027          * i.e., virtpci and the probe function
1028          * virtpcidev->generic_dev.driver->probe is called which
1029          * results in virtpci_device_probe being called. And if
1030          * virtpci_device_probe is successful
1031          */
1032         if (ret) {
1033                 LOGERR("device_register returned %d\n", ret);
1034                 pDev = &virtpcidev->generic_dev;
1035                 ULTRA_CHANNEL_CLIENT_TRANSITION(addparams->chanptr,
1036                                                 BUS_ID(pDev),
1037                                                 CHANNELCLI_DETACHED, NULL);
1038                 /* remove virtpcidev, the one we just added, from the list */
1039                 write_lock_irqsave(&VpcidevListLock, flags);
1040                 for (tmpvpcidev = VpcidevListHead, prev = NULL;
1041                      tmpvpcidev;
1042                      prev = tmpvpcidev, tmpvpcidev = tmpvpcidev->next) {
1043                         if (tmpvpcidev == virtpcidev) {
1044                                 if (prev)
1045                                         prev->next = tmpvpcidev->next;
1046                                 else
1047                                         VpcidevListHead = tmpvpcidev->next;
1048                                 break;
1049                         }
1050                 }
1051                 write_unlock_irqrestore(&VpcidevListLock, flags);
1052                 kfree(virtpcidev);
1053                 return 0;
1054         }
1055
1056         LOGINF("Added %s:%d:%d &virtpcidev->generic_dev:%p\n",
1057                (devtype == VIRTHBA_TYPE) ? "virthba" : "virtnic",
1058                addparams->bus_no, addparams->device_no,
1059                &virtpcidev->generic_dev);
1060         POSTCODE_LINUX_2(VPCI_CREATE_EXIT_PC, POSTCODE_SEVERITY_INFO);
1061         return 1;
1062 }
1063
1064 static int virtpci_device_serverdown(struct device *parentbus,
1065                                      int devtype,
1066                                      struct vhba_wwnn *wwnn,
1067                                      unsigned char macaddr[])
1068 {
1069         int pausethisone = 0;
1070         bool found = false;
1071         struct virtpci_dev *tmpvpcidev, *prevvpcidev;
1072         struct virtpci_driver *vpcidriver;
1073         unsigned long flags;
1074         int rc = 0;
1075
1076         if ((devtype != VIRTHBA_TYPE) && (devtype != VIRTNIC_TYPE)) {
1077                 LOGERR("**** FAILED to pause device; devtype:%d not vhba:%d or vnic:%d\n",
1078                        devtype, VIRTHBA_TYPE, VIRTNIC_TYPE);
1079                 return 0;
1080         }
1081
1082         /* find the vhba or vnic in virtpci device list */
1083         write_lock_irqsave(&VpcidevListLock, flags);
1084
1085         for (tmpvpcidev = VpcidevListHead, prevvpcidev = NULL;
1086              (tmpvpcidev && !found);
1087              prevvpcidev = tmpvpcidev, tmpvpcidev = tmpvpcidev->next) {
1088                 if (tmpvpcidev->devtype != devtype)
1089                         continue;
1090
1091                 if (devtype == VIRTHBA_TYPE) {
1092                         pausethisone =
1093                             ((tmpvpcidev->scsi.wwnn.wwnn1 == wwnn->wwnn1) &&
1094                              (tmpvpcidev->scsi.wwnn.wwnn2 == wwnn->wwnn2));
1095                         /* devtype is vhba, we're pausing vhba whose
1096                         * wwnn matches the current device's wwnn
1097                         */
1098                 } else {        /* VIRTNIC_TYPE */
1099                         pausethisone =
1100                             memcmp(tmpvpcidev->net.mac_addr, macaddr,
1101                                    MAX_MACADDR_LEN) == 0;
1102                         /* devtype is vnic, we're pausing vnic whose
1103                         * macaddr matches the current device's macaddr */
1104                 }
1105
1106                 if (!pausethisone)
1107                         continue;
1108
1109                 found = true;
1110                 vpcidriver = tmpvpcidev->mydriver;
1111                 rc = vpcidriver->suspend(tmpvpcidev, 0);
1112         }
1113         write_unlock_irqrestore(&VpcidevListLock, flags);
1114
1115         if (!found) {
1116                 LOGERR("**** FAILED to find vhba/vnic in the list\n");
1117                 return 0;
1118         }
1119
1120         return rc;
1121 }
1122
1123 static int virtpci_device_serverup(struct device *parentbus,
1124                                    int devtype,
1125                                    struct vhba_wwnn *wwnn,
1126                                    unsigned char macaddr[])
1127 {
1128         int resumethisone = 0;
1129         bool found = false;
1130         struct virtpci_dev *tmpvpcidev, *prevvpcidev;
1131         struct virtpci_driver *vpcidriver;
1132         unsigned long flags;
1133         int rc = 0;
1134
1135         if ((devtype != VIRTHBA_TYPE) && (devtype != VIRTNIC_TYPE)) {
1136                 LOGERR("**** FAILED to resume device; devtype:%d not vhba:%d or vnic:%d\n",
1137                        devtype, VIRTHBA_TYPE, VIRTNIC_TYPE);
1138                 return 0;
1139         }
1140
1141         /* find the vhba or vnic in virtpci device list */
1142         write_lock_irqsave(&VpcidevListLock, flags);
1143
1144         for (tmpvpcidev = VpcidevListHead, prevvpcidev = NULL;
1145              (tmpvpcidev && !found);
1146              prevvpcidev = tmpvpcidev, tmpvpcidev = tmpvpcidev->next) {
1147                 if (tmpvpcidev->devtype != devtype)
1148                         continue;
1149
1150                 if (devtype == VIRTHBA_TYPE) {
1151                         resumethisone =
1152                             ((tmpvpcidev->scsi.wwnn.wwnn1 == wwnn->wwnn1) &&
1153                              (tmpvpcidev->scsi.wwnn.wwnn2 == wwnn->wwnn2));
1154                         /* devtype is vhba, we're resuming vhba whose
1155                         * wwnn matches the current device's wwnn */
1156                 } else {        /* VIRTNIC_TYPE */
1157                         resumethisone =
1158                             memcmp(tmpvpcidev->net.mac_addr, macaddr,
1159                                    MAX_MACADDR_LEN) == 0;
1160                         /* devtype is vnic, we're resuming vnic whose
1161                         * macaddr matches the current device's macaddr */
1162                 }
1163
1164                 if (!resumethisone)
1165                         continue;
1166
1167                 found = true;
1168                 vpcidriver = tmpvpcidev->mydriver;
1169                 /* This should be done at BUS resume time, but an
1170                 * existing problem prevents us from ever getting a bus
1171                 * resume...  This hack would fail to work should we
1172                 * ever have a bus that contains NO devices, since we
1173                 * would never even get here in that case.
1174                 */
1175                 fix_vbus_devInfo(&tmpvpcidev->generic_dev, tmpvpcidev->deviceNo,
1176                                  tmpvpcidev->device, vpcidriver);
1177                 rc = vpcidriver->resume(tmpvpcidev);
1178         }
1179
1180         write_unlock_irqrestore(&VpcidevListLock, flags);
1181
1182         if (!found) {
1183                 LOGERR("**** FAILED to find vhba/vnic in the list\n");
1184                 return 0;
1185         }
1186
1187         return rc;
1188 }
1189
1190 static int virtpci_device_del(struct device *parentbus,
1191                               int devtype, struct vhba_wwnn *wwnn,
1192                               unsigned char macaddr[])
1193 {
1194         int count = 0, all = 0, delthisone;
1195         struct virtpci_dev *tmpvpcidev, *prevvpcidev, *dellist = NULL;
1196         unsigned long flags;
1197
1198 #define DEL_CONTINUE { \
1199         prevvpcidev = tmpvpcidev;\
1200         tmpvpcidev = tmpvpcidev->next;\
1201         continue; \
1202 }
1203
1204         if ((devtype != VIRTHBA_TYPE) && (devtype != VIRTNIC_TYPE)) {
1205                 LOGERR("**** FAILED to delete device; devtype:%d not vhba:%d or vnic:%d\n",
1206                        devtype, VIRTHBA_TYPE, VIRTNIC_TYPE);
1207                 return 0;
1208         }
1209
1210         /* see if we are to delete all - NOTE: all implies we have a
1211          * valid parentbus
1212          */
1213         all = ((devtype == VIRTHBA_TYPE) && (wwnn == NULL)) ||
1214             ((devtype == VIRTNIC_TYPE) && (macaddr == NULL));
1215
1216         /* find all the vhba or vnic or both in virtpci device list
1217         * keep list of ones we are deleting so we can call
1218         * device_unregister after we release the lock; otherwise we
1219         * encounter "schedule while atomic"
1220         */
1221         write_lock_irqsave(&VpcidevListLock, flags);
1222         for (tmpvpcidev = VpcidevListHead, prevvpcidev = NULL; tmpvpcidev;) {
1223                 if (tmpvpcidev->devtype != devtype)
1224                         DEL_CONTINUE;
1225
1226                 if (all) {
1227                         delthisone =
1228                             (tmpvpcidev->generic_dev.parent == parentbus);
1229                         /* we're deleting all vhbas or vnics on the
1230                          * specified parent bus
1231                          */
1232                 } else if (devtype == VIRTHBA_TYPE) {
1233                         delthisone =
1234                             ((tmpvpcidev->scsi.wwnn.wwnn1 == wwnn->wwnn1) &&
1235                              (tmpvpcidev->scsi.wwnn.wwnn2 == wwnn->wwnn2));
1236                         /* devtype is vhba, we're deleting vhba whose
1237                          * wwnn matches the current device's wwnn
1238                          */
1239                 } else {        /* VIRTNIC_TYPE */
1240                         delthisone =
1241                             memcmp(tmpvpcidev->net.mac_addr, macaddr,
1242                                    MAX_MACADDR_LEN) == 0;
1243                         /* devtype is vnic, we're deleting vnic whose
1244                         * macaddr matches the current device's macaddr
1245                         */
1246                 }
1247
1248                 if (!delthisone)
1249                         DEL_CONTINUE;
1250
1251                 /* take vhba/vnic out of the list */
1252                 if (prevvpcidev)
1253                         /* not at head */
1254                         prevvpcidev->next = tmpvpcidev->next;
1255                 else
1256                         VpcidevListHead = tmpvpcidev->next;
1257
1258                 /* add it to our deletelist */
1259                 tmpvpcidev->next = dellist;
1260                 dellist = tmpvpcidev;
1261
1262                 count++;
1263                 if (!all)
1264                         break;  /* done */
1265                 /* going to top of loop again - set tmpvpcidev to next
1266                  * one we're to process
1267                  */
1268                 if (prevvpcidev)
1269                         tmpvpcidev = prevvpcidev->next;
1270                 else
1271                         tmpvpcidev = VpcidevListHead;
1272         }
1273         write_unlock_irqrestore(&VpcidevListLock, flags);
1274
1275         if (!all && (count == 0)) {
1276                 LOGERR("**** FAILED to find vhba/vnic in the list\n");
1277                 return 0;
1278         }
1279
1280         /* now delete each one from delete list */
1281         while (dellist) {
1282                 /* save next */
1283                 tmpvpcidev = dellist->next;
1284                 /* delete the vhba/vnic at dellist */
1285                 DELETE_ONE_VPCIDEV(dellist);
1286                 /* do next */
1287                 dellist = tmpvpcidev;
1288         }
1289
1290         return count;
1291 }
1292
1293 static void virtpci_device_release(struct device *dev_)
1294 {
1295         /* this function is called when the last reference to the
1296          * device is removed
1297          */
1298         LOGINF("In virtpci_device_release:%p - NOT YET IMPLEMENTED\n", dev_);
1299 }
1300
1301 /*****************************************************/
1302 /* Driver functions                                  */
1303 /*****************************************************/
1304
1305 #define kobj_to_device_driver(obj) container_of(obj, struct device_driver, kobj)
1306 #define attribute_to_driver_attribute(obj) \
1307         container_of(obj, struct driver_attribute, attr)
1308
1309 static ssize_t virtpci_driver_attr_show(struct kobject *kobj,
1310                                         struct attribute *attr,
1311                                         char *buf)
1312 {
1313         struct driver_attribute *dattr = attribute_to_driver_attribute(attr);
1314         ssize_t ret = 0;
1315
1316         struct driver_private *dprivate = to_driver(kobj);
1317         struct device_driver *driver;
1318
1319         if (dprivate != NULL)
1320                 driver = dprivate->driver;
1321         else
1322                 driver = NULL;
1323
1324         DBGINF("In virtpci_driver_attr_show driver->name:%s\n", driver->name);
1325         if (driver) {
1326                 if (dattr->show)
1327                         ret = dattr->show(driver, buf);
1328         }
1329         return ret;
1330 }
1331
1332 static ssize_t virtpci_driver_attr_store(struct kobject *kobj,
1333                                          struct attribute *attr,
1334                                          const char *buf, size_t count)
1335 {
1336         struct driver_attribute *dattr = attribute_to_driver_attribute(attr);
1337         ssize_t ret = 0;
1338
1339         struct driver_private *dprivate = to_driver(kobj);
1340         struct device_driver *driver;
1341
1342         if (dprivate != NULL)
1343                 driver = dprivate->driver;
1344         else
1345                 driver = NULL;
1346
1347         DBGINF("In virtpci_driver_attr_store driver->name:%s\n", driver->name);
1348
1349         if (driver) {
1350                 if (dattr->store)
1351                         ret = dattr->store(driver, buf, count);
1352         }
1353         return ret;
1354 }
1355
1356 /* register a new virtpci driver */
1357 int virtpci_register_driver(struct virtpci_driver *drv)
1358 {
1359         int result = 0;
1360
1361         DBGINF("In virtpci_register_driver\n");
1362
1363         if (drv->id_table == NULL) {
1364                 LOGERR("id_table missing\n");
1365                 return 1;
1366         }
1367         /* initialize core driver fields needed to call driver_register */
1368         drv->core_driver.name = drv->name;      /* name of driver in sysfs */
1369         drv->core_driver.bus = &virtpci_bus_type;       /* type of bus this
1370                                                          * driver works with */
1371         drv->core_driver.probe = virtpci_device_probe;  /* called to query the
1372                                                          * existence of a
1373                                                          * specific device and
1374                                                          * whether this driver
1375                                                          *can work with it */
1376         drv->core_driver.remove = virtpci_device_remove; /* called when the
1377                                                           * device is removed
1378                                                           * from the system */
1379         /* register with core */
1380         result = driver_register(&drv->core_driver);
1381         /* calls bus_add_driver which calls driver_attach and
1382          * module_add_driver
1383          */
1384         if (result)
1385                 return result;  /* failed */
1386
1387         drv->core_driver.p->kobj.ktype = &virtpci_driver_kobj_type;
1388
1389         return 0;
1390 }
1391 EXPORT_SYMBOL_GPL(virtpci_register_driver);
1392
1393 void virtpci_unregister_driver(struct virtpci_driver *drv)
1394 {
1395         DBGINF("In virtpci_unregister_driver drv:%p\n", drv);
1396         driver_unregister(&drv->core_driver);
1397         /* driver_unregister calls bus_remove_driver
1398          * bus_remove_driver calls device_detach
1399          * device_detach calls device_release_driver for each of the
1400          * driver's devices
1401          * device_release driver calls drv->remove which is
1402          * virtpci_device_remove
1403          * virtpci_device_remove calls virthba_remove
1404          */
1405         DBGINF("Leaving\n");
1406 }
1407 EXPORT_SYMBOL_GPL(virtpci_unregister_driver);
1408
1409 /*****************************************************/
1410 /* debugfs filesystem functions                      */
1411 /*****************************************************/
1412 struct print_vbus_info {
1413         int *str_pos;
1414         char *buf;
1415         size_t *len;
1416 };
1417
1418 static int print_vbus(struct device *vbus, void *data)
1419 {
1420         struct print_vbus_info *p = (struct print_vbus_info *)data;
1421
1422         *p->str_pos += scnprintf(p->buf + *p->str_pos, *p->len - *p->str_pos,
1423                                 "bus_id:%s\n", dev_name(vbus));
1424         return 0;
1425 }
1426
1427 static ssize_t info_debugfs_read(struct file *file, char __user *buf,
1428                               size_t len, loff_t *offset)
1429 {
1430         ssize_t bytes_read = 0;
1431         int str_pos = 0;
1432         struct virtpci_dev *tmpvpcidev;
1433         unsigned long flags;
1434         struct print_vbus_info printparam;
1435         char *vbuf;
1436
1437         if (len > MAX_BUF)
1438                 len = MAX_BUF;
1439         vbuf = kzalloc(len, GFP_KERNEL);
1440         if (!vbuf)
1441                 return -ENOMEM;
1442
1443         str_pos += scnprintf(vbuf + str_pos, len - str_pos,
1444                         " Virtual PCI Bus devices\n");
1445         printparam.str_pos = &str_pos;
1446         printparam.buf = vbuf;
1447         printparam.len = &len;
1448         if (bus_for_each_dev(&virtpci_bus_type, NULL,
1449                              (void *) &printparam, print_vbus))
1450                 LOGERR("Failed to find bus\n");
1451
1452         str_pos += scnprintf(vbuf + str_pos, len - str_pos,
1453                         "\n Virtual PCI devices\n");
1454         read_lock_irqsave(&VpcidevListLock, flags);
1455         tmpvpcidev = VpcidevListHead;
1456         while (tmpvpcidev) {
1457                 if (tmpvpcidev->devtype == VIRTHBA_TYPE) {
1458                         str_pos += scnprintf(vbuf + str_pos, len - str_pos,
1459                                         "[%d:%d] VHba:%08x:%08x max-config:%d-%d-%d-%d",
1460                                         tmpvpcidev->busNo, tmpvpcidev->deviceNo,
1461                                         tmpvpcidev->scsi.wwnn.wwnn1,
1462                                         tmpvpcidev->scsi.wwnn.wwnn2,
1463                                         tmpvpcidev->scsi.max.max_channel,
1464                                         tmpvpcidev->scsi.max.max_id,
1465                                         tmpvpcidev->scsi.max.max_lun,
1466                                         tmpvpcidev->scsi.max.cmd_per_lun);
1467                 } else {
1468                         str_pos += scnprintf(vbuf + str_pos, len - str_pos,
1469                                         "[%d:%d] VNic:%02x:%02x:%02x:%02x:%02x:%02x num_rcv_bufs:%d mtu:%d",
1470                                         tmpvpcidev->busNo, tmpvpcidev->deviceNo,
1471                                         tmpvpcidev->net.mac_addr[0],
1472                                         tmpvpcidev->net.mac_addr[1],
1473                                         tmpvpcidev->net.mac_addr[2],
1474                                         tmpvpcidev->net.mac_addr[3],
1475                                         tmpvpcidev->net.mac_addr[4],
1476                                         tmpvpcidev->net.mac_addr[5],
1477                                         tmpvpcidev->net.num_rcv_bufs,
1478                                         tmpvpcidev->net.mtu);
1479                 }
1480                 str_pos += scnprintf(vbuf + str_pos,
1481                                 len - str_pos, " chanptr:%p\n",
1482                                 tmpvpcidev->queueinfo.chan);
1483                                 tmpvpcidev = tmpvpcidev->next;
1484         }
1485         read_unlock_irqrestore(&VpcidevListLock, flags);
1486
1487         str_pos += scnprintf(vbuf + str_pos, len - str_pos, "\n");
1488         bytes_read = simple_read_from_buffer(buf, len, offset, vbuf, str_pos);
1489         kfree(vbuf);
1490         return bytes_read;
1491 }
1492
1493 /*****************************************************/
1494 /* Module Init & Exit functions                      */
1495 /*****************************************************/
1496
1497 static int __init virtpci_mod_init(void)
1498 {
1499         int ret;
1500
1501
1502         if (!unisys_spar_platform)
1503                 return -ENODEV;
1504
1505         POSTCODE_LINUX_2(VPCI_CREATE_ENTRY_PC, POSTCODE_SEVERITY_INFO);
1506
1507         ret = bus_register(&virtpci_bus_type);
1508         /* creates /sys/bus/uisvirtpci which contains devices &
1509          * drivers directory
1510          */
1511         if (ret) {
1512                 LOGERR("bus_register ****FAILED:%d\n", ret);
1513                 POSTCODE_LINUX_3(VPCI_CREATE_FAILURE_PC, ret,
1514                                  POSTCODE_SEVERITY_ERR);
1515                 return ret;
1516         }
1517         DBGINF("bus_register successful\n");
1518         BusDeviceInfo_Init(&Bus_DriverInfo, "clientbus", "virtpci",
1519                            VERSION, NULL);
1520
1521         /* create a root bus used to parent all the virtpci buses. */
1522         ret = device_register(&virtpci_rootbus_device);
1523         if (ret) {
1524                 LOGERR("device_register FAILED:%d\n", ret);
1525                 bus_unregister(&virtpci_bus_type);
1526                 POSTCODE_LINUX_3(VPCI_CREATE_FAILURE_PC, ret,
1527                                  POSTCODE_SEVERITY_ERR);
1528                 return ret;
1529         }
1530         DBGINF("device_register successful ret:%x\n", ret);
1531
1532         if (!uisctrl_register_req_handler(2, (void *) &virtpci_ctrlchan_func,
1533                                           &Chipset_DriverInfo)) {
1534                 LOGERR("uisctrl_register_req_handler ****FAILED.\n");
1535                 POSTCODE_LINUX_2(VPCI_CREATE_FAILURE_PC, POSTCODE_SEVERITY_ERR);
1536                 device_unregister(&virtpci_rootbus_device);
1537                 bus_unregister(&virtpci_bus_type);
1538                 return -1;
1539         }
1540
1541         LOGINF("successfully registered virtpci_ctrlchan_func (0x%p) as callback.\n",
1542              (void *) &virtpci_ctrlchan_func);
1543         /* create debugfs directory and info file inside. */
1544         virtpci_debugfs_dir = debugfs_create_dir("virtpci", NULL);
1545         debugfs_create_file("info", S_IRUSR, virtpci_debugfs_dir,
1546                         NULL, &debugfs_info_fops);
1547         LOGINF("Leaving\n");
1548         POSTCODE_LINUX_2(VPCI_CREATE_EXIT_PC, POSTCODE_SEVERITY_INFO);
1549         return 0;
1550 }
1551
1552 static void __exit virtpci_mod_exit(void)
1553 {
1554         LOGINF("virtpci_mod_exit...\n");
1555
1556         /* unregister the callback function */
1557         if (!uisctrl_register_req_handler(2, NULL, NULL))
1558                 LOGERR("uisctrl_register_req_handler ****FAILED.\n");
1559
1560         device_unregister(&virtpci_rootbus_device);
1561         bus_unregister(&virtpci_bus_type);
1562         debugfs_remove_recursive(virtpci_debugfs_dir);
1563         LOGINF("Leaving\n");
1564
1565 }
1566
1567 module_init(virtpci_mod_init);
1568 module_exit(virtpci_mod_exit);
1569 MODULE_LICENSE("GPL");
1570 MODULE_AUTHOR("Usha Srinivasan");
1571 MODULE_ALIAS("uisvirtpci");
1572