1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License, Version 1.0 only 6 * (the "License"). You may not use this file except in compliance 7 * with the License. 8 * 9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 10 * or http://www.opensolaris.org/os/licensing. 11 * See the License for the specific language governing permissions 12 * and limitations under the License. 13 * 14 * When distributing Covered Code, include this CDDL HEADER in each 15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 16 * If applicable, add the following below this CDDL HEADER, with the 17 * fields enclosed by brackets "[]" replaced with your own identifying 18 * information: Portions Copyright [yyyy] [name of copyright owner] 19 * 20 * CDDL HEADER END 21 */ 22 /* 23 * Copyright 2005 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 #ifndef _SYS_SBDPRIV_H 28 #define _SYS_SBDPRIV_H 29 30 #pragma ident "%Z%%M% %I% %E% SMI" 31 32 #ifdef __cplusplus 33 extern "C" { 34 #endif 35 36 #include <sys/processor.h> 37 #include <sys/obpdefs.h> 38 #include <sys/memlist.h> 39 #include <sys/sbd_ioctl.h> 40 #include <sys/mem_config.h> 41 #include <sys/sbd.h> 42 #ifdef DEBUG 43 #include <sys/promif.h> 44 #endif 45 46 47 /* 48 * This structure passes the information when the caller requests to 49 * reserve a portion of unconfigured memory. It is also used to release 50 * previously reserved memory 51 */ 52 struct sbd_mres { 53 uint64_t new_base_pa; /* new base addr for physintalled */ 54 uint64_t reserved_pa; /* addr of the reserved mem */ 55 uint64_t size; /* size of the reserved chunk. */ 56 }; 57 58 int sbd_memory_reserve(dev_info_t *, uint64_t, struct sbd_mres *); 59 int sbd_memory_release(dev_info_t *, uint64_t, struct sbd_mres *); 60 61 /* This error type is used inside sbd only */ 62 typedef struct { 63 int e_errno; 64 int e_code; 65 char e_rsc[MAXPATHLEN]; 66 } sbderror_t; 67 68 #include <sys/sbd.h> 69 #include <sys/sbd_error.h> 70 71 typedef enum { 72 SBD_STATE_EMPTY = 0, 73 SBD_STATE_OCCUPIED, 74 SBD_STATE_CONNECTED, 75 SBD_STATE_UNCONFIGURED, 76 SBD_STATE_PARTIAL, 77 SBD_STATE_CONFIGURED, 78 SBD_STATE_RELEASE, 79 SBD_STATE_UNREFERENCED, 80 SBD_STATE_FATAL, 81 SBD_STATE_MAX 82 } sbd_istate_t; 83 84 typedef struct { 85 sbderror_t *errp; 86 sbd_flags_t flags; 87 } sbd_treeinfo_t; 88 89 /* 90 * generic flags (sbd_handle.h_flags) 91 */ 92 #define SBD_FLAG_DEVI_FORCE 0x00000001 93 94 /* mirror of SBD_FLAG_FORCE from sbd_ioctl.h */ 95 #define SBD_IOCTL_FLAG_FORCE 0x00000004 96 97 #define SBD_USER_FLAG_MASK 0x0000ffff 98 99 #define SBD_KERN_FLAG_MASK 0xffff0000 /* no flags in use */ 100 101 /* 102 * Translation macros for sbd->sbdp flags 103 */ 104 #define SBD_2_SBDP_FLAGS(f) (((f) & SBD_IOCTL_FLAG_FORCE) ? \ 105 SBDP_IOCTL_FLAG_FORCE : 0) 106 107 typedef struct sbd_handle { 108 void *h_sbd; 109 sbderror_t *h_err; 110 dev_t h_dev; /* dev_t of opened device */ 111 int h_cmd; /* ioctl argument */ 112 int h_mode; /* device open mode */ 113 sbd_flags_t h_flags; 114 sbd_ioctl_arg_t *h_iap; /* points to kernel copy of ioargs */ 115 sbdp_opts_t h_opts; /* points to the platform options */ 116 } sbd_handle_t; 117 118 #define SBD_HD2ERR(hd) ((hd)->h_err) 119 #define SBD_GET_ERR(ep) ((ep)->e_code) 120 #define SBD_SET_ERR(ep, ec) ((ep)->e_code = (ec)) 121 #define SBD_GET_ERRNO(ep) ((ep)->e_errno) 122 #define SBD_SET_ERRNO(ep, en) ((ep)->e_errno = (en)) 123 #define SBD_GET_ERRSTR(ep) ((ep)->e_rsc) 124 125 #define SBD_SET_ERRSTR(ep, es) \ 126 { \ 127 if ((es) && (*(es) != '\0')) \ 128 (void) strncpy((ep)->e_rsc, (es), MAXPATHLEN); \ 129 } 130 131 #define SBD_SET_IOCTL_ERR(ierr, code, rsc) \ 132 { \ 133 (ierr)->e_code = (int)(code); \ 134 if ((rsc) && (*(rsc) != '\0')) \ 135 bcopy((caddr_t)(rsc), \ 136 (caddr_t)(ierr)->e_rsc, \ 137 sizeof ((ierr)->e_rsc)); \ 138 } 139 140 #define SBD_FREE_ERR(ep) \ 141 ((ep)->e_rsc[0] = '\0') 142 143 #define SBD_GET_PERR(spe, ep) \ 144 (ep)->e_errno = EIO; \ 145 (ep)->e_code = (spe)->e_code; \ 146 if (*((spe)->e_rsc) != '\0') \ 147 bcopy((caddr_t)((spe)->e_rsc), \ 148 (caddr_t)((ep))->e_rsc, \ 149 sizeof (((ep))->e_rsc)); 150 151 /* 152 * dev_t is shared by PIM and PSM layers. 153 * 154 * Format = 31......16,15.......0 155 * | PIM | PSM | 156 */ 157 #define _SBD_DEVPIM_SHIFT 16 158 #define _SBD_DEVPIM_MASK 0xffff 159 #define _SBD_DEVPSM_MASK 0xffff 160 161 #define SBD_GET_MINOR2INST(d) (((d) >> _SBD_DEVPIM_SHIFT) & _SBD_DEVPIM_MASK) 162 #define SBD_MAKE_MINOR(i, m) \ 163 ((((i) & _SBD_DEVPIM_MASK) << _SBD_DEVPIM_SHIFT) | \ 164 ((m) & _SBD_DEVPSM_MASK)) 165 166 #define GETSTRUCT(t, n) \ 167 ((t *)kmem_zalloc((size_t)(n) * sizeof (t), KM_SLEEP)) 168 #define FREESTRUCT(p, t, n) \ 169 (kmem_free((caddr_t)(p), sizeof (t) * (size_t)(n))) 170 171 #define GET_SOFTC(i) ddi_get_soft_state(sbd_g.softsp, (i)) 172 #define ALLOC_SOFTC(i) ddi_soft_state_zalloc(sbd_g.softsp, (i)) 173 #define FREE_SOFTC(i) ddi_soft_state_free(sbd_g.softsp, (i)) 174 175 /* 176 * Per instance soft-state structure. 177 */ 178 typedef struct sbd_softstate { 179 void *sbd_boardlist; 180 int max_boards; 181 int wnode; 182 } sbd_softstate_t; 183 184 /* 185 * dr Global data elements 186 */ 187 typedef struct { 188 sbd_softstate_t *softsp; /* pointer to initialize soft state */ 189 } sbd_global; 190 191 typedef struct { 192 sbderror_t dv_error; 193 dev_info_t *dv_dip; 194 } sbd_devlist_t; 195 196 extern int plat_max_io_units_per_board(); 197 extern int plat_max_cmp_units_per_board(); 198 extern int plat_max_cpu_units_per_board(); 199 extern int plat_max_mem_units_per_board(); 200 #define MAX_IO_UNITS_PER_BOARD plat_max_io_units_per_board() 201 #define MAX_CMP_UNITS_PER_BOARD plat_max_cmp_units_per_board() 202 #define MAX_CPU_UNITS_PER_BOARD plat_max_cpu_units_per_board() 203 #define MAX_MEM_UNITS_PER_BOARD plat_max_mem_units_per_board() 204 #define SBD_MAX_UNITS_PER_BOARD 8 205 /* If any of the max units exceeds 5, this must be adjusted */ 206 207 #define SBD_MAX_INSTANCES 16 208 209 #define SBD_NUM_STATES ((int)SBD_STATE_MAX) 210 211 #ifdef DEBUG 212 #define SBD_DEVICE_TRANSITION(sb, nt, un, st) \ 213 { \ 214 int _ostate, _nstate; \ 215 _ostate = (int)((sb)->sb_dev[NIX(nt)][un].u_common.sbdev_state); \ 216 _nstate = (int)(st); \ 217 PR_STATE("BOARD %d (%s.%d) STATE: %s(%d) -> %s(%d)\n", \ 218 (sb)->sb_num, \ 219 sbd_ct_str[nt], (un), \ 220 sbd_state_str[_ostate], _ostate, \ 221 sbd_state_str[_nstate], _nstate); \ 222 (void) drv_getparm(TIME, \ 223 (void *)&(sb)->sb_dev[NIX(nt)][un].u_common.sbdev_time); \ 224 (sb)->sb_dev[NIX(nt)][un].u_common.sbdev_state = (st); \ 225 (sb)->sb_dev[NIX(nt)][un].u_common.sbdev_ostate = ostate_cvt(st); \ 226 send_event = 1; \ 227 } 228 #define SBD_BOARD_TRANSITION(sb, st) \ 229 { \ 230 PR_STATE("BOARD %d STATE: %s(%d) -> %s(%d)\n", \ 231 (sb)->sb_num, \ 232 sbd_state_str[(int)(sb)->sb_state], (int)(sb)->sb_state, \ 233 sbd_state_str[(int)(st)], (int)(st)); \ 234 (sb)->sb_pstate = (sb)->sb_state; \ 235 (sb)->sb_state = (st); \ 236 send_event = 1; \ 237 } 238 #else /* DEBUG */ 239 #define SBD_DEVICE_TRANSITION(sb, nt, un, st) \ 240 { \ 241 (sb)->sb_dev[NIX(nt)][un].u_common.sbdev_state = (st); \ 242 (sb)->sb_dev[NIX(nt)][un].u_common.sbdev_ostate = ostate_cvt(st); \ 243 (void) drv_getparm(TIME, \ 244 (void *)&(sb)->sb_dev[NIX(nt)][un].u_common.sbdev_time); \ 245 send_event = 1; \ 246 } 247 #define SBD_BOARD_TRANSITION(sb, st) \ 248 ((sb)->sb_pstate = (sb)->sb_state, (sb)->sb_state = (st), \ 249 send_event = 1) 250 #endif /* DEBUG */ 251 252 #define SBD_DEVICE_STATE(sb, nt, un) \ 253 ((sb)->sb_dev[NIX(nt)][un].u_common.sbdev_state) 254 #define SBD_BOARD_STATE(sb) \ 255 ((sb)->sb_state) 256 #define SBD_BOARD_PSTATE(sb) \ 257 ((sb)->sb_pstate) 258 259 typedef uint32_t sbd_devset_t; 260 261 /* 262 * sbd_priv_handle_t MUST appear first. 263 */ 264 typedef struct sbd_priv_handle { 265 sbd_handle_t sh_handle; 266 void *sh_arg; /* raw ioctl arg */ 267 sbd_devset_t sh_devset; /* based on h_dev */ 268 sbd_devset_t sh_orig_devset; /* what client requested */ 269 sbderror_t sh_err; 270 struct sbd_priv_handle *sh_next; 271 } sbd_priv_handle_t; 272 273 #define SBD_MAXNUM_NT 3 274 #define NIX(t) (((t) == SBD_COMP_CPU) ? 0 : \ 275 ((t) == SBD_COMP_MEM) ? 1 : \ 276 ((t) == SBD_COMP_IO) ? 2 : \ 277 ((t) == SBD_COMP_CMP) ? 0 : SBD_MAXNUM_NT) 278 279 #define SBD_NUM_MC_PER_BOARD 4 280 281 282 typedef struct sbd_common_unit { 283 sbd_istate_t sbdev_state; 284 sbd_cond_t sbdev_cond; 285 sbd_state_t sbdev_ostate; 286 time_t sbdev_time; 287 int sbdev_busy; 288 void *sbdev_sbp; 289 int sbdev_unum; 290 sbd_comp_type_t sbdev_type; 291 dev_info_t *sbdev_dip; 292 } sbd_common_unit_t; 293 294 typedef struct sbd_mem_unit { 295 sbd_common_unit_t sbm_cm; 296 sbd_istate_t sbm_state; /* mem-unit state */ 297 uint_t sbm_flags; 298 pfn_t sbm_basepfn; 299 pgcnt_t sbm_npages; 300 pgcnt_t sbm_pageslost; 301 /* 302 * The following fields are used during 303 * the memory detach process only. sbm_mlist 304 * will be used to store the board memlist 305 * following a detach. The memlist will be 306 * used to re-attach the board when configuring 307 * the unit directly after an unconfigure. 308 */ 309 struct sbd_mem_unit *sbm_peer; 310 struct memlist *sbm_mlist; 311 struct memlist *sbm_del_mlist; 312 memhandle_t sbm_memhandle; 313 pfn_t sbm_alignment_mask; 314 pfn_t sbm_slice_offset; 315 /* 316 * The following field is used to support the 317 * representation of all memory controllers on 318 * a board with one sbd_mem_unit_t. 319 */ 320 dev_info_t *sbm_dip[SBD_NUM_MC_PER_BOARD]; 321 /* 322 * The following field determines if the memory on this board 323 * is part of an interleave across boards 324 */ 325 int sbm_interleave; 326 } sbd_mem_unit_t; 327 328 /* 329 * Currently only maintain state information for individual 330 * components. 331 */ 332 typedef struct sbd_cpu_unit { 333 sbd_common_unit_t sbc_cm; /* cpu-unit state */ 334 processorid_t sbc_cpu_id; 335 cpu_flag_t sbc_cpu_flags; 336 ushort_t sbc_pad1; 337 int sbc_cpu_impl; 338 int sbc_speed; 339 int sbc_ecache; 340 } sbd_cpu_unit_t; 341 342 typedef struct sbd_io_unit { 343 sbd_common_unit_t sbi_cm; /* io-unit state */ 344 } sbd_io_unit_t; 345 346 typedef union { 347 sbd_common_unit_t u_common; 348 sbd_mem_unit_t _mu; 349 sbd_cpu_unit_t _cu; 350 sbd_io_unit_t _iu; 351 } sbd_dev_unit_t; 352 353 typedef struct { 354 sbd_priv_handle_t *sb_handle; 355 int sb_ref; /* # of handle references */ 356 int sb_num; /* board number */ 357 void *sb_softsp; /* pointer to soft state */ 358 dev_info_t *sb_topdip; /* top devinfo of instance */ 359 sbd_istate_t sb_state; /* (current) board state */ 360 sbd_istate_t sb_pstate; /* previous board state */ 361 sbd_cond_t sb_cond; /* condition */ 362 sbd_state_t sb_rstate; /* receptacle state */ 363 sbd_state_t sb_ostate; /* occupant state */ 364 /* 365 * 0=CPU, 1=MEM, 2=IO, 3=NULL 366 */ 367 dev_info_t **sb_devlist[SBD_MAXNUM_NT + 1]; 368 369 sbd_devset_t sb_dev_present; /* present mask */ 370 sbd_devset_t sb_dev_attached; /* attached mask */ 371 sbd_devset_t sb_dev_released; /* released mask */ 372 sbd_devset_t sb_dev_unreferenced; /* unreferenced mask */ 373 sbd_dev_unit_t *sb_dev[SBD_MAXNUM_NT]; 374 375 char *sb_cpupath[SBD_MAX_UNITS_PER_BOARD]; 376 char *sb_mempath[SBD_MAX_UNITS_PER_BOARD]; 377 char *sb_iopath[SBD_MAX_UNITS_PER_BOARD]; 378 379 int sb_ndev; /* number of devs */ 380 int sb_errno; /* store errno */ 381 int sb_busy; /* drain in progress */ 382 int sb_assigned; 383 int sb_flags; 384 kmutex_t sb_flags_mutex; /* mutex to protect flags */ 385 int sb_wnode; 386 int sb_memaccess_ok; 387 sbd_stat_t sb_stat; /* cached board status */ 388 processorid_t sb_cpuid; /* for starfire connect */ 389 time_t sb_time; /* time of last board op */ 390 kmutex_t sb_mutex; 391 kmutex_t sb_slock; /* status - unconfig, discon */ 392 } sbd_board_t; 393 394 /* definitions for sb_flags */ 395 #define SBD_BOARD_STATUS_CACHED 1 396 397 #define SBD_GET_BOARD_MEMUNIT(sb, un) \ 398 (&((sb)->sb_dev[NIX(SBD_COMP_MEM)][un]._mu)) 399 #define SBD_GET_BOARD_CPUUNIT(sb, un) \ 400 (&((sb)->sb_dev[NIX(SBD_COMP_CPU)][un]._cu)) 401 #define SBD_GET_BOARD_IOUNIT(sb, un) \ 402 (&((sb)->sb_dev[NIX(SBD_COMP_IO)][un]._iu)) 403 404 typedef ushort_t boardset_t; /* assumes 16 boards max */ 405 406 #define BOARDSET(b) ((boardset_t)(1 << (b))) 407 #define BOARD_IN_SET(bs, b) (((bs) & BOARDSET(b)) != 0) 408 #define BOARD_ADD(bs, b) ((bs) |= BOARDSET(b)) 409 #define BOARD_DEL(bs, b) ((bs) &= ~BOARDSET(b)) 410 411 /* 412 * Format of sbd_devset_t bit masks: 413 * 414 * 32 16 8 4 0 415 * |....|....|...I|IIII|....|...M|CCCC|CCCC| 416 * 1 = indicates respective component present/attached. 417 * I = I/O, M = Memory, C = CPU. 418 */ 419 #define DEVSET_ANYUNIT (-1) 420 #define _NT2DEVPOS(t, u) ((NIX(t) << 3) + (u)) 421 #define _DEVSET_MASK 0x001f01ff 422 #define _CMP_DEVSET_MASK 0x11 423 #define DEVSET(t, u) \ 424 (((u) == DEVSET_ANYUNIT) ? \ 425 (sbd_devset_t)((0xff << _NT2DEVPOS((t), 0)) & _DEVSET_MASK) : \ 426 (((t) == SBD_COMP_CMP) ? \ 427 (sbd_devset_t)(_CMP_DEVSET_MASK << _NT2DEVPOS((t), (u))) : \ 428 (sbd_devset_t)(1 << _NT2DEVPOS((t), (u))))) 429 430 #define DEVSET_IN_SET(ds, t, u) (((ds) & DEVSET((t), (u))) != 0) 431 #define DEVSET_ADD(ds, t, u) ((ds) |= DEVSET((t), (u))) 432 #define DEVSET_DEL(ds, t, u) ((ds) &= ~DEVSET((t), (u))) 433 #define DEVSET_GET_UNITSET(ds, t) \ 434 (((ds) & DEVSET((t), DEVSET_ANYUNIT)) >> _NT2DEVPOS((t), 0)) 435 /* 436 * Ops for sbd_board_t.sb_dev_present 437 */ 438 #define SBD_DEV_IS_PRESENT(bp, nt, un) \ 439 DEVSET_IN_SET((bp)->sb_dev_present, (nt), (un)) 440 #define SBD_DEV_SET_PRESENT(bp, nt, un) \ 441 DEVSET_ADD((bp)->sb_dev_present, (nt), (un)) 442 #define SBD_DEV_CLR_PRESENT(bp, nt, un) \ 443 DEVSET_DEL((bp)->sb_dev_present, (nt), (un)) 444 /* 445 * Ops for sbd_board_t.sb_dev_attached 446 */ 447 #define SBD_DEV_IS_ATTACHED(bp, nt, un) \ 448 DEVSET_IN_SET((bp)->sb_dev_attached, (nt), (un)) 449 #define SBD_DEV_SET_ATTACHED(bp, nt, un) \ 450 DEVSET_ADD((bp)->sb_dev_attached, (nt), (un)) 451 #define SBD_DEV_CLR_ATTACHED(bp, nt, un) \ 452 DEVSET_DEL((bp)->sb_dev_attached, (nt), (un)) 453 /* 454 * Ops for sbd_board_t.sb_dev_released 455 */ 456 #define SBD_DEV_IS_RELEASED(bp, nt, un) \ 457 DEVSET_IN_SET((bp)->sb_dev_released, (nt), (un)) 458 #define SBD_DEV_SET_RELEASED(bp, nt, un) \ 459 DEVSET_ADD((bp)->sb_dev_released, (nt), (un)) 460 #define SBD_DEV_CLR_RELEASED(bp, nt, un) \ 461 DEVSET_DEL((bp)->sb_dev_released, (nt), (un)) 462 /* 463 * Ops for sbd_board_t.sb_dev_unreferenced 464 */ 465 #define SBD_DEV_IS_UNREFERENCED(bp, nt, un) \ 466 DEVSET_IN_SET((bp)->sb_dev_unreferenced, (nt), (un)) 467 #define SBD_DEV_SET_UNREFERENCED(bp, nt, un) \ 468 DEVSET_ADD((bp)->sb_dev_unreferenced, (nt), (un)) 469 #define SBD_DEV_CLR_UNREFERENCED(bp, nt, un) \ 470 DEVSET_DEL((bp)->sb_dev_unreferenced, (nt), (un)) 471 472 #define SBD_DEVS_PRESENT(bp) \ 473 ((bp)->sb_dev_present) 474 #define SBD_DEVS_ATTACHED(bp) \ 475 ((bp)->sb_dev_attached) 476 #define SBD_DEVS_RELEASED(bp) \ 477 ((bp)->sb_dev_released) 478 #define SBD_DEVS_UNREFERENCED(bp) \ 479 ((bp)->sb_dev_unreferenced) 480 #define SBD_DEVS_UNATTACHED(bp) \ 481 ((bp)->sb_dev_present & ~(bp)->sb_dev_attached) 482 #define SBD_DEVS_CONFIGURE(bp, devs) \ 483 ((bp)->sb_dev_attached = (devs)) 484 #define SBD_DEVS_DISCONNECT(bp, devs) \ 485 ((bp)->sb_dev_present &= ~(devs)) 486 #define SBD_DEVS_CANCEL(bp, devs) \ 487 ((bp)->sb_dev_released &= ~(devs), \ 488 (bp)->sb_dev_unreferenced &= ~(devs)) 489 490 /* 491 * return values from sbd_cancel_cpu 492 */ 493 #define SBD_CPUERR_NONE 0 494 #define SBD_CPUERR_RECOVERABLE -1 495 #define SBD_CPUERR_FATAL -2 496 497 /* 498 * sbd_board_t.sbmem[].sbm_flags 499 */ 500 #define SBD_MFLAG_RESERVED 0x01 /* mem unit reserved for delete */ 501 #define SBD_MFLAG_SOURCE 0x02 /* source brd of copy/rename op */ 502 #define SBD_MFLAG_TARGET 0x04 /* board selected as target */ 503 #define SBD_MFLAG_MEMUPSIZE 0x08 /* move from big to small board */ 504 #define SBD_MFLAG_MEMDOWNSIZE 0x10 /* move from small to big board */ 505 #define SBD_MFLAG_MEMRESIZE 0x18 /* move to different size board */ 506 #define SBD_MFLAG_RELOWNER 0x20 /* memory release (delete) owner */ 507 #define SBD_MFLAG_RELDONE 0x40 508 509 typedef struct { 510 int sfio_cmd; 511 void *sfio_arg; 512 } sbd_ioctl_t; 513 514 /* 515 * 32bit support for sbd_ioctl_t. 516 */ 517 typedef struct { 518 int32_t sfio_cmd; 519 uint32_t sfio_arg; 520 } sbd_ioctl32_t; 521 522 /* 523 * PSM-DR layers are only allowed to use lower 16 bits of dev_t. 524 * B - bottom 4 bits are for the slot number. 525 * D - device type chosen (0 = indicates all devices in slot). 526 * U - unit number if specific device type chosen. 527 * X - not used. 528 * 529 * Upper Lower 530 * XXXXUUUUDDDDBBBB 531 * 532 * Note that this format only allows attachment points to 533 * either represent all the units on a board or one particular 534 * unit. A more general specification would permit any combination 535 * of specific units and types to be represented by individual 536 * attachment points. 537 */ 538 #define SBD_DEV_SLOTMASK 0x000f 539 /* 540 * These device level definitions are primarily for unit testing. 541 */ 542 #define SBD_DEV_UNITMASK 0x0f00 543 #define SBD_DEV_UNITSHIFT 8 544 #define SBD_DEV_CPU 0x0010 545 #define SBD_DEV_MEM 0x0020 546 #define SBD_DEV_IO 0x0040 547 #define SBD_DEV_TYPEMASK (SBD_DEV_CPU | SBD_DEV_MEM | SBD_DEV_IO) 548 #define SBD_DEV_TYPESHIFT 4 549 550 /* 551 * Slot, Instance, and Minor number Macro definitions 552 */ 553 #define SLOT2DEV(s) ((s) & SBD_DEV_SLOTMASK) 554 #define SBDGETSLOT(unit) ((unit) & SBD_DEV_SLOTMASK) 555 /* 556 * The following is primarily for unit testing. 557 */ 558 #define ALLCPU2DEV(s) (SBD_DEV_CPU | SLOT2DEV(s)) 559 #define ALLMEM2DEV(s) (SBD_DEV_MEM | SLOT2DEV(s)) 560 #define ALLIO2DEV(s) (SBD_DEV_IO | SLOT2DEV(s)) 561 #define _UNIT2DEV(u) (((u) << SBD_DEV_UNITSHIFT) & \ 562 SBD_DEV_UNITMASK) 563 #define CPUUNIT2DEV(s, c) (_UNIT2DEV(c) | ALLCPU2DEV(s)) 564 #define MEMUNIT2DEV(s, m) (_UNIT2DEV(m) | ALLMEM2DEV(s)) 565 #define IOUNIT2DEV(s, i) (_UNIT2DEV(i) | ALLIO2DEV(s)) 566 567 #define DEV_IS_ALLUNIT(d) (((d) & SBD_DEV_UNITMASK) == 0) 568 #define _DEV_IS_ALLTYPE(d) (((d) & SBD_DEV_TYPEMASK) == 0) 569 #define DEV_IS_ALLBOARD(d) (DEV_IS_ALLUNIT(d) && _DEV_IS_ALLTYPE(d)) 570 #define DEV_IS_CPU(d) ((d) & SBD_DEV_CPU) 571 #define DEV_IS_MEM(d) ((d) & SBD_DEV_MEM) 572 #define DEV_IS_IO(d) ((d) & SBD_DEV_IO) 573 #define DEV_IS_ALLCPU(d) (DEV_IS_ALLUNIT(d) && DEV_IS_CPU(d)) 574 #define DEV_IS_ALLMEM(d) (DEV_IS_ALLUNIT(d) && DEV_IS_MEM(d)) 575 #define DEV_IS_ALLIO(d) (DEV_IS_ALLUNIT(d) && DEV_IS_IO(d)) 576 #define DEV2UNIT(d) \ 577 ((((d) & SBD_DEV_UNITMASK) >> SBD_DEV_UNITSHIFT) - 1) 578 #define DEV2NT(d) \ 579 (DEV_IS_MEM(d) ? SBD_COMP_MEM : \ 580 DEV_IS_CPU(d) ? SBD_COMP_CPU : \ 581 DEV_IS_IO(d) ? SBD_COMP_IO : SBD_COMP_UNKNOWN) 582 583 /* 584 * Macros to cast between PIM and PSM layers of the following 585 * structures: 586 * board_t <-> sbd_board_t 587 * sbd_handle_t <-> sbd_priv_handle_t 588 * sbderror_t <-> sbderror_t 589 * slot -> board_t 590 * slot -> sbd_board_t 591 * sbd_board_t -> sbd_handle_t 592 * sbd_handle -> sbderror_t 593 */ 594 #define SBDH2BD(bd) ((sbd_board_t *)(bd)) 595 596 #define HD2MACHHD(hd) ((sbd_priv_handle_t *)(hd)) 597 #define MACHHD2HD(mhd) ((sbd_handle_t *)&((mhd)->sh_handle)) 598 599 #define ERR2MACHERR(err) ((sbderror_t *)(err)) 600 #define MACHERR2ERR(merr) ((sbderror_t *)(merr)) 601 602 #define BSLOT2MACHBD(b) (&(sbd_boardlist[b])) 603 #define BSLOT2BD(slot) MACHBD2BD(BSLOT2MACHBD(slot)) 604 605 #define MACHBD2HD(sbp) MACHHD2HD((sbp)->sb_handle) 606 607 #define HD2MACHERR(hd) ERR2MACHERR(SBD_HD2ERR(hd)) 608 609 #define MACHSRHD2HD(srh) ((srh)->sr_dr_handlep) 610 611 /* 612 * CMP Specific Helpers 613 */ 614 #define MAX_CORES_PER_CMP 2 615 #define SBD_CMP_CORE_UNUM(cmp, core) ((cmp + (core * 512)) 616 #define SBD_CMP_NUM(unum) (unum & 0x3) 617 618 /* 619 * Some stuff to assist in debug. 620 */ 621 #ifdef DEBUG 622 #define SBD_DBG_STATE 0x00000001 623 #define SBD_DBG_QR 0x00000002 624 #define SBD_DBG_CPU 0x00000004 625 #define SBD_DBG_MEM 0x00000008 626 #define SBD_DBG_IO 0x00000010 627 #define SBD_DBG_HW 0x00000020 628 #define SBD_DBG_BYP 0x00000040 629 630 #define PR_ALL if (sbd_debug) printf 631 #define PR_STATE if (sbd_debug & SBD_DBG_STATE) printf 632 #define PR_QR if (sbd_debug & SBD_DBG_QR) prom_printf 633 #define PR_CPU if (sbd_debug & SBD_DBG_CPU) printf 634 #define PR_MEM if (sbd_debug & SBD_DBG_MEM) printf 635 #define PR_IO if (sbd_debug & SBD_DBG_IO) printf 636 #define PR_HW if (sbd_debug & SBD_DBG_HW) printf 637 #define PR_BYP if (sbd_debug & SBD_DBG_BYP) prom_printf 638 639 #define SBD_MEMLIST_DUMP(ml) memlist_dump(ml) 640 641 extern uint_t sbd_debug; 642 #else /* DEBUG */ 643 #define PR_ALL if (0) printf 644 #define PR_STATE PR_ALL 645 #define PR_QR PR_ALL 646 #define PR_CPU PR_ALL 647 #define PR_MEM PR_ALL 648 #define PR_IO PR_ALL 649 #define PR_HW PR_ALL 650 #define PR_BYP PR_ALL 651 652 #define SBD_MEMLIST_DUMP(ml) 653 #endif /* DEBUG */ 654 extern char *sbd_state_str[]; 655 extern char *sbd_ct_str[]; 656 657 /* 658 * event flag 659 */ 660 extern char send_event; 661 662 /* 663 * IMPORTANT: 664 * The following two defines are also coded into OBP, so if they 665 * need to change here, don't forget to change OBP also. 666 */ 667 #define SBD_OBP_PROBE_GOOD 0 668 #define SBD_OBP_PROBE_BAD 1 669 670 extern int sbd_setup_instance(int, dev_info_t *, int, int, 671 caddr_t); 672 extern int sbd_teardown_instance(int, caddr_t); 673 extern int sbd_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, 674 char *event); 675 676 extern sbd_comp_type_t sbd_cm_type(char *name); 677 extern sbd_state_t ostate_cvt(sbd_istate_t state); 678 extern void sbd_cpu_set_prop(sbd_cpu_unit_t *cp, dev_info_t *dip); 679 extern int sbd_cpu_flags(sbd_handle_t *hp, sbd_devset_t devset, 680 sbd_dev_stat_t *dsp); 681 extern int sbd_disconnect_cpu(sbd_handle_t *hp, int unit); 682 extern int sbd_connect_cpu(sbd_board_t *sbp, int unit); 683 extern int sbd_disconnect_mem(sbd_handle_t *hp, int unit); 684 685 extern int sbd_pre_detach_mem(sbd_handle_t *hp, 686 sbd_devlist_t *devlist, int devnum); 687 extern int sbd_post_attach_mem(sbd_handle_t *, 688 sbd_devlist_t *, int); 689 extern int sbd_post_detach_mem(sbd_handle_t *, 690 sbd_devlist_t *, int); 691 extern int sbd_post_attach_cpu(sbd_handle_t *hp, 692 sbd_devlist_t *devlist, int devnum); 693 extern int sbd_pre_release_cpu(sbd_handle_t *hp, 694 sbd_devlist_t *devlist, int devnum); 695 extern int sbd_pre_detach_cpu(sbd_handle_t *hp, 696 sbd_devlist_t *devlist, int devnum); 697 extern int sbd_post_detach_cpu(sbd_handle_t *hp, 698 sbd_devlist_t *devlist, int devnum); 699 extern int sbd_pre_attach_mem(sbd_handle_t *hp, 700 sbd_devlist_t *devlist, int devnum); 701 extern int sbd_pre_release_mem(sbd_handle_t *hp, 702 sbd_devlist_t *devlist, int devnum); 703 extern int sbd_disconnect_io(sbd_handle_t *hp, int unit); 704 extern void sbd_check_devices(dev_info_t *dip, int *refcount, 705 sbd_handle_t *handle); 706 extern struct memlist *sbd_get_memlist(sbd_mem_unit_t *mp, sbderror_t *ep); 707 extern void sbd_init_mem_unit(sbd_board_t *sbp, int unit, 708 sbderror_t *ep); 709 extern void sbd_release_mem_done(sbd_handle_t *hp, int unit); 710 extern void sbd_release_cleanup(sbd_handle_t *hp); 711 extern int sbd_cancel_cpu(sbd_handle_t *hp, int unit); 712 extern void sbd_init_err(sbderror_t *ep); 713 extern int sbd_cancel_mem(sbd_handle_t *hp, int unit); 714 extern sbd_comp_type_t sbd_get_devtype(sbd_handle_t *hp, dev_info_t *dip); 715 extern int sbd_get_board(dev_info_t *dip); 716 extern int sfhw_get_base_physaddr(dev_info_t *dip, 717 uint64_t *basepa); 718 extern int sbd_pre_attach_cpu(sbd_handle_t *hp, 719 sbd_devlist_t *devlist, int devnum); 720 extern int sbd_move_memory(sbd_handle_t *hp, sbd_board_t 721 *s_bp, sbd_board_t *t_bp); 722 extern void memlist_delete(struct memlist *mlist); 723 extern struct memlist *memlist_dup(struct memlist *mlist); 724 extern void memlist_dump(struct memlist *mlist); 725 extern int memlist_intersect(struct memlist *alist, 726 struct memlist *blist); 727 extern int sbd_juggle_bootproc(sbd_handle_t *hp, 728 processorid_t cpuid); 729 730 extern sbd_cond_t sbd_get_comp_cond(dev_info_t *); 731 void sbd_attach_mem(sbd_handle_t *hp, sbderror_t *ep); 732 int sbd_release_mem(sbd_handle_t *hp, dev_info_t *dip, 733 int unit); 734 735 int sbd_get_memhandle(sbd_handle_t *hp, dev_info_t *dip, 736 memhandle_t *mhp); 737 int sbd_detach_memory(sbd_handle_t *hp, sbderror_t *ep, 738 sbd_mem_unit_t *s_mp, int unit); 739 void sbd_release_memory_done(void *arg, int error); 740 int sbd_set_err_in_hdl(sbd_handle_t *hp, sbderror_t *ep); 741 sbdp_handle_t *sbd_get_sbdp_handle(sbd_board_t *sbp, 742 sbd_handle_t *hp); 743 void sbd_release_sbdp_handle(sbdp_handle_t *hp); 744 void sbd_reset_error_sbdph(sbdp_handle_t *hp); 745 extern int sbd_is_cmp_child(dev_info_t *dip); 746 747 typedef const char *const fn_t; 748 749 #ifdef __cplusplus 750 } 751 #endif 752 753 #endif /* _SYS_SBDPRIV_H */ 754