| |
| /* |
| * Copyright (c) 2008 Silicon Graphics, Inc. All Rights Reserved. |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License as published by |
| * the Free Software Foundation; either version 2 of the License, or |
| * (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| */ |
| #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_ */ |
