mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
201 lines
5.5 KiB
201 lines
5.5 KiB
/* 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_ */
|
|
|