mirror of
https://github.com/AetherDroid/android_kernel_samsung_on5xelte.git
synced 2025-11-01 08:38:52 +01:00
Fixed MTP to work with TWRP
This commit is contained in:
awab228
commit
f6dfaef42e
50820 changed files with 20846062 additions and 0 deletions
214
drivers/misc/sgi-gru/grukservices.h
Normal file
214
drivers/misc/sgi-gru/grukservices.h
Normal file
|
|
@ -0,0 +1,214 @@
|
|||
|
||||
/*
|
||||
* 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_ */
|
||||
Loading…
Add table
Add a link
Reference in a new issue