mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-11-01 17:08:10 +00:00
1a59d1b8e0
Based on 1 normalized pattern(s): 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 extracted by the scancode license scanner the SPDX license identifier GPL-2.0-or-later has been chosen to replace the boilerplate/reference in 1334 file(s). Signed-off-by: Thomas Gleixner <tglx@linutronix.de> Reviewed-by: Allison Randal <allison@lohutok.net> Reviewed-by: Richard Fontana <rfontana@redhat.com> Cc: linux-spdx@vger.kernel.org Link: https://lkml.kernel.org/r/20190527070033.113240726@linutronix.de Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
201 lines
5.5 KiB
C
201 lines
5.5 KiB
C
/* 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_ */
|