Release 4.11 drivers/misc/sgi-gru/grukservices.h
/*
* 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_ */
Overall Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Jack Steiner | 236 | 94.40% | 3 | 75.00% |
| Robin Holt | 14 | 5.60% | 1 | 25.00% |
| Total | 250 | 100.00% | 4 | 100.00% |
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.