forked from luck/tmp_suning_uos_patched
289750d1f1
The BIOS has decided to store a pointer to the partition reserved page in a scratch MMR. The GRU is only able to read an MMR using a vload instruction. The gru_read_gpa() function will implemented. Signed-off-by: Robin Holt <holt@sgi.com> Signed-off-by: Jack Steiner <steiner@sgi.com> Cc: Ingo Molnar <mingo@elte.hu> Signed-off-by: Andrew Morton <akpm@linux-foundation.org> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
215 lines
6.1 KiB
C
215 lines
6.1 KiB
C
|
|
/*
|
|
* 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_ */
|