include/asm-ppc64/iSeries/HvCallPci.h

   1 /*
   2  * Provides the Hypervisor PCI calls for iSeries Linux Parition.
   3  * Copyright (C) 2001  <Wayne G Holm> <IBM Corporation>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the:
  17  * Free Software Foundation, Inc.,
  18  * 59 Temple Place, Suite 330,
  19  * Boston, MA  02111-1307  USA
  20  *
  21  * Change Activity:
  22  *   Created, Jan 9, 2001
  23  */
  24
  25 #ifndef _HVCALLPCI_H
  26 #define _HVCALLPCI_H
  27
  28 #include <asm/iSeries/HvCallSc.h>
  29 #include <asm/iSeries/HvTypes.h>
  30
  31 /*
  32  * DSA == Direct Select Address
  33  * this struct must be 64 bits in total
  34  */
  35 struct HvCallPci_DsaAddr {
  36         u16             busNumber;              /* PHB index? */
  37         u8              subBusNumber;           /* PCI bus number? */
  38         u8              deviceId;               /* device and function? */
  39         u8              barNumber;
  40         u8              reserved[3];
  41 };
  42
  43 union HvDsaMap {
  44         u64     DsaAddr;
  45         struct HvCallPci_DsaAddr Dsa;
  46 };
  47
  48 struct HvCallPci_LoadReturn {
  49         u64             rc;
  50         u64             value;
  51 };
  52
  53 enum HvCallPci_DeviceType {
  54         HvCallPci_NodeDevice    = 1,
  55         HvCallPci_SpDevice      = 2,
  56         HvCallPci_IopDevice     = 3,
  57         HvCallPci_BridgeDevice  = 4,
  58         HvCallPci_MultiFunctionDevice = 5,
  59         HvCallPci_IoaDevice     = 6
  60 };
  61
  62
  63 struct HvCallPci_DeviceInfo {
  64         u32     deviceType;             /* See DeviceType enum for values */
  65 };
  66
  67 struct HvCallPci_BusUnitInfo {
  68         u32     sizeReturned;           /* length of data returned */
  69         u32     deviceType;             /* see DeviceType enum for values */
  70 };
  71
  72 struct HvCallPci_BridgeInfo {
  73         struct HvCallPci_BusUnitInfo busUnitInfo;  /* Generic bus unit info */
  74         u8              subBusNumber;   /* Bus number of secondary bus */
  75         u8              maxAgents;      /* Max idsels on secondary bus */
  76         u8              maxSubBusNumber; /* Max Sub Bus */
  77         u8              logicalSlotNumber; /* Logical Slot Number for IOA */
  78 };
  79
  80
  81 /*
  82  * Maximum BusUnitInfo buffer size.  Provided for clients so
  83  * they can allocate a buffer big enough for any type of bus
  84  * unit.  Increase as needed.
  85  */
  86 enum {HvCallPci_MaxBusUnitInfoSize = 128};
  87
  88 struct HvCallPci_BarParms {
  89         u64             vaddr;
  90         u64             raddr;
  91         u64             size;
  92         u64             protectStart;
  93         u64             protectEnd;
  94         u64             relocationOffset;
  95         u64             pciAddress;
  96         u64             reserved[3];
  97 };
  98
  99 enum HvCallPci_VpdType {
 100         HvCallPci_BusVpd        = 1,
 101         HvCallPci_BusAdapterVpd = 2
 102 };
 103
 104 #define HvCallPciConfigLoad8            HvCallPci + 0
 105 #define HvCallPciConfigLoad16           HvCallPci + 1
 106 #define HvCallPciConfigLoad32           HvCallPci + 2
 107 #define HvCallPciConfigStore8           HvCallPci + 3
 108 #define HvCallPciConfigStore16          HvCallPci + 4
 109 #define HvCallPciConfigStore32          HvCallPci + 5
 110 #define HvCallPciEoi                    HvCallPci + 16
 111 #define HvCallPciGetBarParms            HvCallPci + 18
 112 #define HvCallPciMaskFisr               HvCallPci + 20
 113 #define HvCallPciUnmaskFisr             HvCallPci + 21
 114 #define HvCallPciSetSlotReset           HvCallPci + 25
 115 #define HvCallPciGetDeviceInfo          HvCallPci + 27
 116 #define HvCallPciGetCardVpd             HvCallPci + 28
 117 #define HvCallPciBarLoad8               HvCallPci + 40
 118 #define HvCallPciBarLoad16              HvCallPci + 41
 119 #define HvCallPciBarLoad32              HvCallPci + 42
 120 #define HvCallPciBarLoad64              HvCallPci + 43
 121 #define HvCallPciBarStore8              HvCallPci + 44
 122 #define HvCallPciBarStore16             HvCallPci + 45
 123 #define HvCallPciBarStore32             HvCallPci + 46
 124 #define HvCallPciBarStore64             HvCallPci + 47
 125 #define HvCallPciMaskInterrupts         HvCallPci + 48
 126 #define HvCallPciUnmaskInterrupts       HvCallPci + 49
 127 #define HvCallPciGetBusUnitInfo         HvCallPci + 50
 128
 129 static inline u64 HvCallPci_configLoad8(u16 busNumber, u8 subBusNumber,
 130                 u8 deviceId, u32 offset, u8 *value)
 131 {
 132         struct HvCallPci_DsaAddr dsa;
 133         struct HvCallPci_LoadReturn retVal;
 134
 135         *((u64*)&dsa) = 0;
 136
 137         dsa.busNumber = busNumber;
 138         dsa.subBusNumber = subBusNumber;
 139         dsa.deviceId = deviceId;
 140
 141         HvCall3Ret16(HvCallPciConfigLoad8, &retVal, *(u64 *)&dsa, offset, 0);
 142
 143         *value = retVal.value;
 144
 145         return retVal.rc;
 146 }
 147
 148 static inline u64 HvCallPci_configLoad16(u16 busNumber, u8 subBusNumber,
 149                 u8 deviceId, u32 offset, u16 *value)
 150 {
 151         struct HvCallPci_DsaAddr dsa;
 152         struct HvCallPci_LoadReturn retVal;
 153
 154         *((u64*)&dsa) = 0;
 155
 156         dsa.busNumber = busNumber;
 157         dsa.subBusNumber = subBusNumber;
 158         dsa.deviceId = deviceId;
 159
 160         HvCall3Ret16(HvCallPciConfigLoad16, &retVal, *(u64 *)&dsa, offset, 0);
 161
 162         *value = retVal.value;
 163
 164         return retVal.rc;
 165 }
 166
 167 static inline u64 HvCallPci_configLoad32(u16 busNumber, u8 subBusNumber,
 168                 u8 deviceId, u32 offset, u32 *value)
 169 {
 170         struct HvCallPci_DsaAddr dsa;
 171         struct HvCallPci_LoadReturn retVal;
 172
 173         *((u64*)&dsa) = 0;
 174
 175         dsa.busNumber = busNumber;
 176         dsa.subBusNumber = subBusNumber;
 177         dsa.deviceId = deviceId;
 178
 179         HvCall3Ret16(HvCallPciConfigLoad32, &retVal, *(u64 *)&dsa, offset, 0);
 180
 181         *value = retVal.value;
 182
 183         return retVal.rc;
 184 }
 185
 186 static inline u64 HvCallPci_configStore8(u16 busNumber, u8 subBusNumber,
 187                 u8 deviceId, u32 offset, u8 value)
 188 {
 189         struct HvCallPci_DsaAddr dsa;
 190
 191         *((u64*)&dsa) = 0;
 192
 193         dsa.busNumber = busNumber;
 194         dsa.subBusNumber = subBusNumber;
 195         dsa.deviceId = deviceId;
 196
 197         return HvCall4(HvCallPciConfigStore8, *(u64 *)&dsa, offset, value, 0);
 198 }
 199
 200 static inline u64 HvCallPci_configStore16(u16 busNumber, u8 subBusNumber,
 201                 u8 deviceId, u32 offset, u16 value)
 202 {
 203         struct HvCallPci_DsaAddr dsa;
 204
 205         *((u64*)&dsa) = 0;
 206
 207         dsa.busNumber = busNumber;
 208         dsa.subBusNumber = subBusNumber;
 209         dsa.deviceId = deviceId;
 210
 211         return HvCall4(HvCallPciConfigStore16, *(u64 *)&dsa, offset, value, 0);
 212 }
 213
 214 static inline u64 HvCallPci_configStore32(u16 busNumber, u8 subBusNumber,
 215                 u8 deviceId, u32 offset, u32 value)
 216 {
 217         struct HvCallPci_DsaAddr dsa;
 218
 219         *((u64*)&dsa) = 0;
 220
 221         dsa.busNumber = busNumber;
 222         dsa.subBusNumber = subBusNumber;
 223         dsa.deviceId = deviceId;
 224
 225         return HvCall4(HvCallPciConfigStore32, *(u64 *)&dsa, offset, value, 0);
 226 }
 227
 228 static inline u64 HvCallPci_barLoad8(u16 busNumberParm, u8 subBusParm,
 229                 u8 deviceIdParm, u8 barNumberParm, u64 offsetParm,
 230                 u8 *valueParm)
 231 {
 232         struct HvCallPci_DsaAddr dsa;
 233         struct HvCallPci_LoadReturn retVal;
 234
 235         *((u64*)&dsa) = 0;
 236
 237         dsa.busNumber = busNumberParm;
 238         dsa.subBusNumber = subBusParm;
 239         dsa.deviceId = deviceIdParm;
 240         dsa.barNumber = barNumberParm;
 241
 242         HvCall3Ret16(HvCallPciBarLoad8, &retVal, *(u64 *)&dsa, offsetParm, 0);
 243
 244         *valueParm = retVal.value;
 245
 246         return retVal.rc;
 247 }
 248
 249 static inline u64 HvCallPci_barLoad16(u16 busNumberParm, u8 subBusParm,
 250                 u8 deviceIdParm, u8 barNumberParm, u64 offsetParm,
 251                 u16 *valueParm)
 252 {
 253         struct HvCallPci_DsaAddr dsa;
 254         struct HvCallPci_LoadReturn retVal;
 255
 256         *((u64*)&dsa) = 0;
 257
 258         dsa.busNumber = busNumberParm;
 259         dsa.subBusNumber = subBusParm;
 260         dsa.deviceId = deviceIdParm;
 261         dsa.barNumber = barNumberParm;
 262
 263         HvCall3Ret16(HvCallPciBarLoad16, &retVal, *(u64 *)&dsa, offsetParm, 0);
 264
 265         *valueParm = retVal.value;
 266
 267         return retVal.rc;
 268 }
 269
 270 static inline u64 HvCallPci_barLoad32(u16 busNumberParm, u8 subBusParm,
 271                 u8 deviceIdParm, u8 barNumberParm, u64 offsetParm,
 272                 u32 *valueParm)
 273 {
 274         struct HvCallPci_DsaAddr dsa;
 275         struct HvCallPci_LoadReturn retVal;
 276
 277         *((u64*)&dsa) = 0;
 278
 279         dsa.busNumber = busNumberParm;
 280         dsa.subBusNumber = subBusParm;
 281         dsa.deviceId = deviceIdParm;
 282         dsa.barNumber = barNumberParm;
 283
 284         HvCall3Ret16(HvCallPciBarLoad32, &retVal, *(u64 *)&dsa, offsetParm, 0);
 285
 286         *valueParm = retVal.value;
 287
 288         return retVal.rc;
 289 }
 290
 291 static inline u64 HvCallPci_barLoad64(u16 busNumberParm, u8 subBusParm,
 292                 u8 deviceIdParm, u8 barNumberParm, u64 offsetParm,
 293                 u64 *valueParm)
 294 {
 295         struct HvCallPci_DsaAddr dsa;
 296         struct HvCallPci_LoadReturn retVal;
 297
 298         *((u64*)&dsa) = 0;
 299
 300         dsa.busNumber = busNumberParm;
 301         dsa.subBusNumber = subBusParm;
 302         dsa.deviceId = deviceIdParm;
 303         dsa.barNumber = barNumberParm;
 304
 305         HvCall3Ret16(HvCallPciBarLoad64, &retVal, *(u64 *)&dsa, offsetParm, 0);
 306
 307         *valueParm = retVal.value;
 308
 309         return retVal.rc;
 310 }
 311
 312 static inline u64 HvCallPci_barStore8(u16 busNumberParm, u8 subBusParm,
 313                 u8 deviceIdParm, u8 barNumberParm, u64 offsetParm,
 314                 u8 valueParm)
 315 {
 316         struct HvCallPci_DsaAddr dsa;
 317
 318         *((u64*)&dsa) = 0;
 319
 320         dsa.busNumber = busNumberParm;
 321         dsa.subBusNumber = subBusParm;
 322         dsa.deviceId = deviceIdParm;
 323         dsa.barNumber = barNumberParm;
 324
 325         return HvCall4(HvCallPciBarStore8, *(u64 *)&dsa, offsetParm,
 326                         valueParm, 0);
 327 }
 328
 329 static inline u64 HvCallPci_barStore16(u16 busNumberParm, u8 subBusParm,
 330                 u8 deviceIdParm, u8 barNumberParm, u64 offsetParm,
 331                 u16 valueParm)
 332 {
 333         struct HvCallPci_DsaAddr dsa;
 334
 335         *((u64*)&dsa) = 0;
 336
 337         dsa.busNumber = busNumberParm;
 338         dsa.subBusNumber = subBusParm;
 339         dsa.deviceId = deviceIdParm;
 340         dsa.barNumber = barNumberParm;
 341
 342         return HvCall4(HvCallPciBarStore16, *(u64 *)&dsa, offsetParm,
 343                         valueParm, 0);
 344 }
 345
 346 static inline u64 HvCallPci_barStore32(u16 busNumberParm, u8 subBusParm,
 347                 u8 deviceIdParm, u8 barNumberParm, u64 offsetParm,
 348                 u32 valueParm)
 349 {
 350         struct HvCallPci_DsaAddr dsa;
 351
 352         *((u64*)&dsa) = 0;
 353
 354         dsa.busNumber = busNumberParm;
 355         dsa.subBusNumber = subBusParm;
 356         dsa.deviceId = deviceIdParm;
 357         dsa.barNumber = barNumberParm;
 358
 359         return HvCall4(HvCallPciBarStore32, *(u64 *)&dsa, offsetParm,
 360                         valueParm, 0);
 361 }
 362
 363 static inline u64 HvCallPci_barStore64(u16 busNumberParm, u8 subBusParm,
 364                 u8 deviceIdParm, u8 barNumberParm, u64 offsetParm,
 365                 u64 valueParm)
 366 {
 367         struct HvCallPci_DsaAddr dsa;
 368
 369         *((u64*)&dsa) = 0;
 370
 371         dsa.busNumber = busNumberParm;
 372         dsa.subBusNumber = subBusParm;
 373         dsa.deviceId = deviceIdParm;
 374         dsa.barNumber = barNumberParm;
 375
 376         return HvCall4(HvCallPciBarStore64, *(u64 *)&dsa, offsetParm,
 377                         valueParm, 0);
 378 }
 379
 380 static inline u64 HvCallPci_eoi(u16 busNumberParm, u8 subBusParm,
 381                 u8 deviceIdParm)
 382 {
 383         struct HvCallPci_DsaAddr dsa;
 384         struct HvCallPci_LoadReturn retVal;
 385
 386         *((u64*)&dsa) = 0;
 387
 388         dsa.busNumber = busNumberParm;
 389         dsa.subBusNumber = subBusParm;
 390         dsa.deviceId = deviceIdParm;
 391
 392         HvCall1Ret16(HvCallPciEoi, &retVal, *(u64*)&dsa);
 393
 394         return retVal.rc;
 395 }
 396
 397 static inline u64 HvCallPci_getBarParms(u16 busNumberParm, u8 subBusParm,
 398                 u8 deviceIdParm, u8 barNumberParm, u64 parms, u32 sizeofParms)
 399 {
 400         struct HvCallPci_DsaAddr dsa;
 401
 402         *((u64*)&dsa) = 0;
 403
 404         dsa.busNumber = busNumberParm;
 405         dsa.subBusNumber = subBusParm;
 406         dsa.deviceId = deviceIdParm;
 407         dsa.barNumber = barNumberParm;
 408
 409         return HvCall3(HvCallPciGetBarParms, *(u64*)&dsa, parms, sizeofParms);
 410 }
 411
 412 static inline u64 HvCallPci_maskFisr(u16 busNumberParm, u8 subBusParm,
 413                 u8 deviceIdParm, u64 fisrMask)
 414 {
 415         struct HvCallPci_DsaAddr dsa;
 416
 417         *((u64*)&dsa) = 0;
 418
 419         dsa.busNumber = busNumberParm;
 420         dsa.subBusNumber = subBusParm;
 421         dsa.deviceId = deviceIdParm;
 422
 423         return HvCall2(HvCallPciMaskFisr, *(u64*)&dsa, fisrMask);
 424 }
 425
 426 static inline u64 HvCallPci_unmaskFisr(u16 busNumberParm, u8 subBusParm,
 427                 u8 deviceIdParm, u64 fisrMask)
 428 {
 429         struct HvCallPci_DsaAddr dsa;
 430
 431         *((u64*)&dsa) = 0;
 432
 433         dsa.busNumber = busNumberParm;
 434         dsa.subBusNumber = subBusParm;
 435         dsa.deviceId = deviceIdParm;
 436
 437         return HvCall2(HvCallPciUnmaskFisr, *(u64*)&dsa, fisrMask);
 438 }
 439
 440 static inline u64 HvCallPci_setSlotReset(u16 busNumberParm, u8 subBusParm,
 441                 u8 deviceIdParm, u64 onNotOff)
 442 {
 443         struct HvCallPci_DsaAddr dsa;
 444
 445         *((u64*)&dsa) = 0;
 446
 447         dsa.busNumber = busNumberParm;
 448         dsa.subBusNumber = subBusParm;
 449         dsa.deviceId = deviceIdParm;
 450
 451         return HvCall2(HvCallPciSetSlotReset, *(u64*)&dsa, onNotOff);
 452 }
 453
 454 static inline u64 HvCallPci_getDeviceInfo(u16 busNumberParm, u8 subBusParm,
 455                 u8 deviceNumberParm, u64 parms, u32 sizeofParms)
 456 {
 457         struct HvCallPci_DsaAddr dsa;
 458
 459         *((u64*)&dsa) = 0;
 460
 461         dsa.busNumber = busNumberParm;
 462         dsa.subBusNumber = subBusParm;
 463         dsa.deviceId = deviceNumberParm << 4;
 464
 465         return HvCall3(HvCallPciGetDeviceInfo, *(u64*)&dsa, parms, sizeofParms);
 466 }
 467
 468 static inline u64 HvCallPci_maskInterrupts(u16 busNumberParm, u8 subBusParm,
 469                 u8 deviceIdParm, u64 interruptMask)
 470 {
 471         struct HvCallPci_DsaAddr dsa;
 472
 473         *((u64*)&dsa) = 0;
 474
 475         dsa.busNumber = busNumberParm;
 476         dsa.subBusNumber = subBusParm;
 477         dsa.deviceId = deviceIdParm;
 478
 479         return HvCall2(HvCallPciMaskInterrupts, *(u64*)&dsa, interruptMask);
 480 }
 481
 482 static inline u64 HvCallPci_unmaskInterrupts(u16 busNumberParm, u8 subBusParm,
 483                 u8 deviceIdParm, u64 interruptMask)
 484 {
 485         struct HvCallPci_DsaAddr dsa;
 486
 487         *((u64*)&dsa) = 0;
 488
 489         dsa.busNumber = busNumberParm;
 490         dsa.subBusNumber = subBusParm;
 491         dsa.deviceId = deviceIdParm;
 492
 493         return HvCall2(HvCallPciUnmaskInterrupts, *(u64*)&dsa, interruptMask);
 494 }
 495
 496 static inline u64 HvCallPci_getBusUnitInfo(u16 busNumberParm, u8 subBusParm,
 497                 u8 deviceIdParm, u64 parms, u32 sizeofParms)
 498 {
 499         struct HvCallPci_DsaAddr dsa;
 500
 501         *((u64*)&dsa) = 0;
 502
 503         dsa.busNumber = busNumberParm;
 504         dsa.subBusNumber = subBusParm;
 505         dsa.deviceId = deviceIdParm;
 506
 507         return HvCall3(HvCallPciGetBusUnitInfo, *(u64*)&dsa, parms,
 508                         sizeofParms);
 509 }
 510
 511 static inline int HvCallPci_getBusVpd(u16 busNumParm, u64 destParm,
 512                 u16 sizeParm)
 513 {
 514         u64 xRc = HvCall4(HvCallPciGetCardVpd, busNumParm, destParm,
 515                         sizeParm, HvCallPci_BusVpd);
 516         if (xRc == -1)
 517                 return -1;
 518         else
 519                 return xRc & 0xFFFF;
 520 }
 521
 522 static inline int HvCallPci_getBusAdapterVpd(u16 busNumParm, u64 destParm,
 523                 u16 sizeParm)
 524 {
 525         u64 xRc = HvCall4(HvCallPciGetCardVpd, busNumParm, destParm,
 526                         sizeParm, HvCallPci_BusAdapterVpd);
 527         if (xRc == -1)
 528                 return -1;
 529         else
 530                 return xRc & 0xFFFF;
 531 }
 532
 533 #endif /* _HVCALLPCI_H */