Loading...
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 | /* SPDX-License-Identifier: GPL-2.0-or-later */ /* * Copyright (c) 2008 Silicon Graphics, Inc. All Rights Reserved. */ #ifndef __GRU_KSERVICES_H_ #define __GRU_KSERVICES_H_ /* * Message queues using the GRU to send/receive messages. * * These function allow the user to create a message queue for * sending/receiving 1 or 2 cacheline messages using the GRU. * * Processes SENDING messages will use a kernel CBR/DSR to send * the message. This is transparent to the caller. * * The receiver does not use any GRU resources. * * The functions support: * - single receiver * - multiple senders * - cross partition message * * Missing features ZZZ: * - user options for dealing with timeouts, queue full, etc. * - gru_create_message_queue() needs interrupt vector info */ struct gru_message_queue_desc { void *mq; /* message queue vaddress */ unsigned long mq_gpa; /* global address of mq */ int qlines; /* queue size in CL */ int interrupt_vector; /* interrupt vector */ int interrupt_pnode; /* pnode for interrupt */ int interrupt_apicid; /* lapicid for interrupt */ }; /* * Initialize a user allocated chunk of memory to be used as * a message queue. The caller must ensure that the queue is * in contiguous physical memory and is cacheline aligned. * * Message queue size is the total number of bytes allocated * to the queue including a 2 cacheline header that is used * to manage the queue. * * Input: * mqd pointer to message queue descriptor * p pointer to user allocated mesq memory. * bytes size of message queue in bytes * vector interrupt vector (zero if no interrupts) * nasid nasid of blade where interrupt is delivered * apicid apicid of cpu for interrupt * * Errors: * 0 OK * >0 error */ extern int gru_create_message_queue(struct gru_message_queue_desc *mqd, void *p, unsigned int bytes, int nasid, int vector, int apicid); /* * Send a message to a message queue. * * Note: The message queue transport mechanism uses the first 32 * bits of the message. Users should avoid using these bits. * * * Input: * mqd pointer to message queue descriptor * mesg pointer to message. Must be 64-bit aligned * bytes size of message in bytes * * Output: * 0 message sent * >0 Send failure - see error codes below * */ extern int gru_send_message_gpa(struct gru_message_queue_desc *mqd, void *mesg, unsigned int bytes); /* Status values for gru_send_message() */ #define MQE_OK 0 /* message sent successfully */ #define MQE_CONGESTION 1 /* temporary congestion, try again */ #define MQE_QUEUE_FULL 2 /* queue is full */ #define MQE_UNEXPECTED_CB_ERR 3 /* unexpected CB error */ #define MQE_PAGE_OVERFLOW 10 /* BUG - queue overflowed a page */ #define MQE_BUG_NO_RESOURCES 11 /* BUG - could not alloc GRU cb/dsr */ /* * Advance the receive pointer for the message queue to the next message. * Note: current API requires messages to be gotten & freed in order. Future * API extensions may allow for out-of-order freeing. * * Input * mqd pointer to message queue descriptor * mesq message being freed */ extern void gru_free_message(struct gru_message_queue_desc *mqd, void *mesq); /* * Get next message from message queue. Returns pointer to * message OR NULL if no message present. * User must call gru_free_message() after message is processed * in order to move the queue pointers to next message. * * Input * mqd pointer to message queue descriptor * * Output: * p pointer to message * NULL no message available */ extern void *gru_get_next_message(struct gru_message_queue_desc *mqd); /* * Read a GRU global GPA. Source can be located in a remote partition. * * Input: * value memory address where MMR value is returned * gpa source numalink physical address of GPA * * Output: * 0 OK * >0 error */ int gru_read_gpa(unsigned long *value, unsigned long gpa); /* * Copy data using the GRU. Source or destination can be located in a remote * partition. * * Input: * dest_gpa destination global physical address * src_gpa source global physical address * bytes number of bytes to copy * * Output: * 0 OK * >0 error */ extern int gru_copy_gpa(unsigned long dest_gpa, unsigned long src_gpa, unsigned int bytes); /* * Reserve GRU resources to be used asynchronously. * * input: * blade_id - blade on which resources should be reserved * cbrs - number of CBRs * dsr_bytes - number of DSR bytes needed * cmp - completion structure for waiting for * async completions * output: * handle to identify resource * (0 = no resources) */ extern unsigned long gru_reserve_async_resources(int blade_id, int cbrs, int dsr_bytes, struct completion *cmp); /* * Release async resources previously reserved. * * input: * han - handle to identify resources */ extern void gru_release_async_resources(unsigned long han); /* * Wait for async GRU instructions to complete. * * input: * han - handle to identify resources */ extern void gru_wait_async_cbr(unsigned long han); /* * Lock previous reserved async GRU resources * * input: * han - handle to identify resources * output: * cb - pointer to first CBR * dsr - pointer to first DSR */ extern void gru_lock_async_resource(unsigned long han, void **cb, void **dsr); /* * Unlock previous reserved async GRU resources * * input: * han - handle to identify resources */ extern void gru_unlock_async_resource(unsigned long han); #endif /* __GRU_KSERVICES_H_ */ |