1/* 2 * This file is subject to the terms and conditions of the GNU General Public 3 * License. See the file "COPYING" in the main directory of this archive 4 * for more details. 5 * 6 * Copyright (C) 2004-2005 Silicon Graphics, Inc. All rights reserved. 7 */ 8 9 10/* 11 * External Cross Partition (XP) structures and defines. 12 */ 13 14 15#ifndef _ASM_IA64_SN_XP_H 16#define _ASM_IA64_SN_XP_H 17 18 19#include <linux/cache.h> 20#include <linux/hardirq.h> 21#include <linux/mutex.h> 22#include <asm/sn/types.h> 23#include <asm/sn/bte.h> 24 25 26#ifdef USE_DBUG_ON 27#define DBUG_ON(condition) BUG_ON(condition) 28#else 29#define DBUG_ON(condition) 30#endif 31 32 33/* 34 * Define the maximum number of logically defined partitions the system 35 * can support. It is constrained by the maximum number of hardware 36 * partitionable regions. The term 'region' in this context refers to the 37 * minimum number of nodes that can comprise an access protection grouping. 38 * The access protection is in regards to memory, IPI and IOI. 39 * 40 * The maximum number of hardware partitionable regions is equal to the 41 * maximum number of nodes in the entire system divided by the minimum number 42 * of nodes that comprise an access protection grouping. 43 */ 44#define XP_MAX_PARTITIONS 64 45 46 47/* 48 * Define the number of u64s required to represent all the C-brick nasids 49 * as a bitmap. The cross-partition kernel modules deal only with 50 * C-brick nasids, thus the need for bitmaps which don't account for 51 * odd-numbered (non C-brick) nasids. 52 */ 53#define XP_MAX_PHYSNODE_ID (MAX_NUMALINK_NODES / 2) 54#define XP_NASID_MASK_BYTES ((XP_MAX_PHYSNODE_ID + 7) / 8) 55#define XP_NASID_MASK_WORDS ((XP_MAX_PHYSNODE_ID + 63) / 64) 56 57 58/* 59 * Wrapper for bte_copy() that should it return a failure status will retry 60 * the bte_copy() once in the hope that the failure was due to a temporary 61 * aberration (i.e., the link going down temporarily). 62 * 63 * src - physical address of the source of the transfer. 64 * vdst - virtual address of the destination of the transfer. 65 * len - number of bytes to transfer from source to destination. 66 * mode - see bte_copy() for definition. 67 * notification - see bte_copy() for definition. 68 * 69 * Note: xp_bte_copy() should never be called while holding a spinlock. 70 */ 71static inline bte_result_t 72xp_bte_copy(u64 src, u64 vdst, u64 len, u64 mode, void *notification) 73{ 74 bte_result_t ret; 75 u64 pdst = ia64_tpa(vdst); 76 77 78 /* 79 * Ensure that the physically mapped memory is contiguous. 80 * 81 * We do this by ensuring that the memory is from region 7 only. 82 * If the need should arise to use memory from one of the other 83 * regions, then modify the BUG_ON() statement to ensure that the 84 * memory from that region is always physically contiguous. 85 */ 86 BUG_ON(REGION_NUMBER(vdst) != RGN_KERNEL); 87 88 ret = bte_copy(src, pdst, len, mode, notification); 89 if (ret != BTE_SUCCESS) { 90 if (!in_interrupt()) { 91 cond_resched(); 92 } 93 ret = bte_copy(src, pdst, len, mode, notification); 94 } 95 96 return ret; 97} 98 99 100/* 101 * XPC establishes channel connections between the local partition and any 102 * other partition that is currently up. Over these channels, kernel-level 103 * `users' can communicate with their counterparts on the other partitions. 104 * 105 * The maxinum number of channels is limited to eight. For performance reasons, 106 * the internal cross partition structures require sixteen bytes per channel, 107 * and eight allows all of this interface-shared info to fit in one cache line. 108 * 109 * XPC_NCHANNELS reflects the total number of channels currently defined. 110 * If the need for additional channels arises, one can simply increase 111 * XPC_NCHANNELS accordingly. If the day should come where that number 112 * exceeds the MAXIMUM number of channels allowed (eight), then one will need 113 * to make changes to the XPC code to allow for this. 114 */ 115#define XPC_MEM_CHANNEL 0 /* memory channel number */ 116#define XPC_NET_CHANNEL 1 /* network channel number */ 117 118#define XPC_NCHANNELS 2 /* #of defined channels */ 119#define XPC_MAX_NCHANNELS 8 /* max #of channels allowed */ 120 121#if XPC_NCHANNELS > XPC_MAX_NCHANNELS 122#error XPC_NCHANNELS exceeds MAXIMUM allowed. 123#endif 124 125 126/* 127 * The format of an XPC message is as follows: 128 * 129 * +-------+--------------------------------+ 130 * | flags |////////////////////////////////| 131 * +-------+--------------------------------+ 132 * | message # | 133 * +----------------------------------------+ 134 * | payload (user-defined message) | 135 * | | 136 * : 137 * | | 138 * +----------------------------------------+ 139 * 140 * The size of the payload is defined by the user via xpc_connect(). A user- 141 * defined message resides in the payload area. 142 * 143 * The user should have no dealings with the message header, but only the 144 * message's payload. When a message entry is allocated (via xpc_allocate()) 145 * a pointer to the payload area is returned and not the actual beginning of 146 * the XPC message. The user then constructs a message in the payload area 147 * and passes that pointer as an argument on xpc_send() or xpc_send_notify(). 148 * 149 * The size of a message entry (within a message queue) must be a cacheline 150 * sized multiple in order to facilitate the BTE transfer of messages from one 151 * message queue to another. A macro, XPC_MSG_SIZE(), is provided for the user 152 * that wants to fit as many msg entries as possible in a given memory size 153 * (e.g. a memory page). 154 */ 155struct xpc_msg { 156 u8 flags; /* FOR XPC INTERNAL USE ONLY */ 157 u8 reserved[7]; /* FOR XPC INTERNAL USE ONLY */ 158 s64 number; /* FOR XPC INTERNAL USE ONLY */ 159 160 u64 payload; /* user defined portion of message */ 161}; 162 163 164#define XPC_MSG_PAYLOAD_OFFSET (u64) (&((struct xpc_msg *)0)->payload) 165#define XPC_MSG_SIZE(_payload_size) \ 166 L1_CACHE_ALIGN(XPC_MSG_PAYLOAD_OFFSET + (_payload_size)) 167 168 169/* 170 * Define the return values and values passed to user's callout functions. 171 * (It is important to add new value codes at the end just preceding 172 * xpcUnknownReason, which must have the highest numerical value.) 173 */ 174enum xpc_retval { 175 xpcSuccess = 0, 176 177 xpcNotConnected, /* 1: channel is not connected */ 178 xpcConnected, /* 2: channel connected (opened) */ 179 xpcRETIRED1, /* 3: (formerly xpcDisconnected) */ 180 181 xpcMsgReceived, /* 4: message received */ 182 xpcMsgDelivered, /* 5: message delivered and acknowledged */ 183 184 xpcRETIRED2, /* 6: (formerly xpcTransferFailed) */ 185 186 xpcNoWait, /* 7: operation would require wait */ 187 xpcRetry, /* 8: retry operation */ 188 xpcTimeout, /* 9: timeout in xpc_allocate_msg_wait() */ 189 xpcInterrupted, /* 10: interrupted wait */ 190 191 xpcUnequalMsgSizes, /* 11: message size disparity between sides */ 192 xpcInvalidAddress, /* 12: invalid address */ 193 194 xpcNoMemory, /* 13: no memory available for XPC structures */ 195 xpcLackOfResources, /* 14: insufficient resources for operation */ 196 xpcUnregistered, /* 15: channel is not registered */ 197 xpcAlreadyRegistered, /* 16: channel is already registered */ 198 199 xpcPartitionDown, /* 17: remote partition is down */ 200 xpcNotLoaded, /* 18: XPC module is not loaded */ 201 xpcUnloading, /* 19: this side is unloading XPC module */ 202 203 xpcBadMagic, /* 20: XPC MAGIC string not found */ 204 205 xpcReactivating, /* 21: remote partition was reactivated */ 206 207 xpcUnregistering, /* 22: this side is unregistering channel */ 208 xpcOtherUnregistering, /* 23: other side is unregistering channel */ 209 210 xpcCloneKThread, /* 24: cloning kernel thread */ 211 xpcCloneKThreadFailed, /* 25: cloning kernel thread failed */ 212 213 xpcNoHeartbeat, /* 26: remote partition has no heartbeat */ 214 215 xpcPioReadError, /* 27: PIO read error */ 216 xpcPhysAddrRegFailed, /* 28: registration of phys addr range failed */ 217 218 xpcBteDirectoryError, /* 29: maps to BTEFAIL_DIR */ 219 xpcBtePoisonError, /* 30: maps to BTEFAIL_POISON */ 220 xpcBteWriteError, /* 31: maps to BTEFAIL_WERR */ 221 xpcBteAccessError, /* 32: maps to BTEFAIL_ACCESS */ 222 xpcBtePWriteError, /* 33: maps to BTEFAIL_PWERR */ 223 xpcBtePReadError, /* 34: maps to BTEFAIL_PRERR */ 224 xpcBteTimeOutError, /* 35: maps to BTEFAIL_TOUT */ 225 xpcBteXtalkError, /* 36: maps to BTEFAIL_XTERR */ 226 xpcBteNotAvailable, /* 37: maps to BTEFAIL_NOTAVAIL */ 227 xpcBteUnmappedError, /* 38: unmapped BTEFAIL_ error */ 228 229 xpcBadVersion, /* 39: bad version number */ 230 xpcVarsNotSet, /* 40: the XPC variables are not set up */ 231 xpcNoRsvdPageAddr, /* 41: unable to get rsvd page's phys addr */ 232 xpcInvalidPartid, /* 42: invalid partition ID */ 233 xpcLocalPartid, /* 43: local partition ID */ 234 235 xpcOtherGoingDown, /* 44: other side going down, reason unknown */ 236 xpcSystemGoingDown, /* 45: system is going down, reason unknown */ 237 xpcSystemHalt, /* 46: system is being halted */ 238 xpcSystemReboot, /* 47: system is being rebooted */ 239 xpcSystemPoweroff, /* 48: system is being powered off */ 240 241 xpcDisconnecting, /* 49: channel disconnecting (closing) */ 242 243 xpcOpenCloseError, /* 50: channel open/close protocol error */ 244 245 xpcDisconnected, /* 51: channel disconnected (closed) */ 246 247 xpcUnknownReason /* 52: unknown reason -- must be last in list */ 248}; 249 250 251/* 252 * Define the callout function types used by XPC to update the user on 253 * connection activity and state changes (via the user function registered by 254 * xpc_connect()) and to notify them of messages received and delivered (via 255 * the user function registered by xpc_send_notify()). 256 * 257 * The two function types are xpc_channel_func and xpc_notify_func and 258 * both share the following arguments, with the exception of "data", which 259 * only xpc_channel_func has. 260 * 261 * Arguments: 262 * 263 * reason - reason code. (See following table.) 264 * partid - partition ID associated with condition. 265 * ch_number - channel # associated with condition. 266 * data - pointer to optional data. (See following table.) 267 * key - pointer to optional user-defined value provided as the "key" 268 * argument to xpc_connect() or xpc_send_notify(). 269 * 270 * In the following table the "Optional Data" column applies to callouts made 271 * to functions registered by xpc_connect(). A "NA" in that column indicates 272 * that this reason code can be passed to functions registered by 273 * xpc_send_notify() (i.e. they don't have data arguments). 274 * 275 * Also, the first three reason codes in the following table indicate 276 * success, whereas the others indicate failure. When a failure reason code 277 * is received, one can assume that the channel is not connected. 278 * 279 * 280 * Reason Code | Cause | Optional Data 281 * =====================+================================+===================== 282 * xpcConnected | connection has been established| max #of entries 283 * | to the specified partition on | allowed in message 284 * | the specified channel | queue 285 * ---------------------+--------------------------------+--------------------- 286 * xpcMsgReceived | an XPC message arrived from | address of payload 287 * | the specified partition on the | 288 * | specified channel | [the user must call 289 * | | xpc_received() when 290 * | | finished with the 291 * | | payload] 292 * ---------------------+--------------------------------+--------------------- 293 * xpcMsgDelivered | notification that the message | NA 294 * | was delivered to the intended | 295 * | recipient and that they have | 296 * | acknowledged its receipt by | 297 * | calling xpc_received() | 298 * =====================+================================+===================== 299 * xpcUnequalMsgSizes | can't connect to the specified | NULL 300 * | partition on the specified | 301 * | channel because of mismatched | 302 * | message sizes | 303 * ---------------------+--------------------------------+--------------------- 304 * xpcNoMemory | insufficient memory avaiable | NULL 305 * | to allocate message queue | 306 * ---------------------+--------------------------------+--------------------- 307 * xpcLackOfResources | lack of resources to create | NULL 308 * | the necessary kthreads to | 309 * | support the channel | 310 * ---------------------+--------------------------------+--------------------- 311 * xpcUnregistering | this side's user has | NULL or NA 312 * | unregistered by calling | 313 * | xpc_disconnect() | 314 * ---------------------+--------------------------------+--------------------- 315 * xpcOtherUnregistering| the other side's user has | NULL or NA 316 * | unregistered by calling | 317 * | xpc_disconnect() | 318 * ---------------------+--------------------------------+--------------------- 319 * xpcNoHeartbeat | the other side's XPC is no | NULL or NA 320 * | longer heartbeating | 321 * | | 322 * ---------------------+--------------------------------+--------------------- 323 * xpcUnloading | this side's XPC module is | NULL or NA 324 * | being unloaded | 325 * | | 326 * ---------------------+--------------------------------+--------------------- 327 * xpcOtherUnloading | the other side's XPC module is | NULL or NA 328 * | is being unloaded | 329 * | | 330 * ---------------------+--------------------------------+--------------------- 331 * xpcPioReadError | xp_nofault_PIOR() returned an | NULL or NA 332 * | error while sending an IPI | 333 * | | 334 * ---------------------+--------------------------------+--------------------- 335 * xpcInvalidAddress | the address either received or | NULL or NA 336 * | sent by the specified partition| 337 * | is invalid | 338 * ---------------------+--------------------------------+--------------------- 339 * xpcBteNotAvailable | attempt to pull data from the | NULL or NA 340 * xpcBtePoisonError | specified partition over the | 341 * xpcBteWriteError | specified channel via a | 342 * xpcBteAccessError | bte_copy() failed | 343 * xpcBteTimeOutError | | 344 * xpcBteXtalkError | | 345 * xpcBteDirectoryError | | 346 * xpcBteGenericError | | 347 * xpcBteUnmappedError | | 348 * ---------------------+--------------------------------+--------------------- 349 * xpcUnknownReason | the specified channel to the | NULL or NA 350 * | specified partition was | 351 * | unavailable for unknown reasons| 352 * =====================+================================+===================== 353 */ 354 355typedef void (*xpc_channel_func)(enum xpc_retval reason, partid_t partid, 356 int ch_number, void *data, void *key); 357 358typedef void (*xpc_notify_func)(enum xpc_retval reason, partid_t partid, 359 int ch_number, void *key); 360 361 362/* 363 * The following is a registration entry. There is a global array of these, 364 * one per channel. It is used to record the connection registration made 365 * by the users of XPC. As long as a registration entry exists, for any 366 * partition that comes up, XPC will attempt to establish a connection on 367 * that channel. Notification that a connection has been made will occur via 368 * the xpc_channel_func function. 369 * 370 * The 'func' field points to the function to call when aynchronous 371 * notification is required for such events as: a connection established/lost, 372 * or an incoming message received, or an error condition encountered. A 373 * non-NULL 'func' field indicates that there is an active registration for 374 * the channel. 375 */ 376struct xpc_registration { 377 struct mutex mutex; 378 xpc_channel_func func; /* function to call */ 379 void *key; /* pointer to user's key */ 380 u16 nentries; /* #of msg entries in local msg queue */ 381 u16 msg_size; /* message queue's message size */ 382 u32 assigned_limit; /* limit on #of assigned kthreads */ 383 u32 idle_limit; /* limit on #of idle kthreads */ 384} ____cacheline_aligned; 385 386 387#define XPC_CHANNEL_REGISTERED(_c) (xpc_registrations[_c].func != NULL) 388 389 390/* the following are valid xpc_allocate() flags */ 391#define XPC_WAIT 0 /* wait flag */ 392#define XPC_NOWAIT 1 /* no wait flag */ 393 394 395struct xpc_interface { 396 void (*connect)(int); 397 void (*disconnect)(int); 398 enum xpc_retval (*allocate)(partid_t, int, u32, void **); 399 enum xpc_retval (*send)(partid_t, int, void *); 400 enum xpc_retval (*send_notify)(partid_t, int, void *, 401 xpc_notify_func, void *); 402 void (*received)(partid_t, int, void *); 403 enum xpc_retval (*partid_to_nasids)(partid_t, void *); 404}; 405 406 407extern struct xpc_interface xpc_interface; 408 409extern void xpc_set_interface(void (*)(int), 410 void (*)(int), 411 enum xpc_retval (*)(partid_t, int, u32, void **), 412 enum xpc_retval (*)(partid_t, int, void *), 413 enum xpc_retval (*)(partid_t, int, void *, xpc_notify_func, 414 void *), 415 void (*)(partid_t, int, void *), 416 enum xpc_retval (*)(partid_t, void *)); 417extern void xpc_clear_interface(void); 418 419 420extern enum xpc_retval xpc_connect(int, xpc_channel_func, void *, u16, 421 u16, u32, u32); 422extern void xpc_disconnect(int); 423 424static inline enum xpc_retval 425xpc_allocate(partid_t partid, int ch_number, u32 flags, void **payload) 426{ 427 return xpc_interface.allocate(partid, ch_number, flags, payload); 428} 429 430static inline enum xpc_retval 431xpc_send(partid_t partid, int ch_number, void *payload) 432{ 433 return xpc_interface.send(partid, ch_number, payload); 434} 435 436static inline enum xpc_retval 437xpc_send_notify(partid_t partid, int ch_number, void *payload, 438 xpc_notify_func func, void *key) 439{ 440 return xpc_interface.send_notify(partid, ch_number, payload, func, key); 441} 442 443static inline void 444xpc_received(partid_t partid, int ch_number, void *payload) 445{ 446 return xpc_interface.received(partid, ch_number, payload); 447} 448 449static inline enum xpc_retval 450xpc_partid_to_nasids(partid_t partid, void *nasids) 451{ 452 return xpc_interface.partid_to_nasids(partid, nasids); 453} 454 455 456extern u64 xp_nofault_PIOR_target; 457extern int xp_nofault_PIOR(void *); 458extern int xp_error_PIOR(void); 459 460 461#endif /* _ASM_IA64_SN_XP_H */ 462