mirror of
https://github.com/edk2-porting/linux-next.git
synced 2024-12-23 04:34:11 +08:00
e2be04c7f9
Many user space API headers have licensing information, which is either
incomplete, badly formatted or just a shorthand for referring to the
license under which the file is supposed to be. This makes it hard for
compliance tools to determine the correct license.
Update these files with an SPDX license identifier. The identifier was
chosen based on the license information in the file.
GPL/LGPL licensed headers get the matching GPL/LGPL SPDX license
identifier with the added 'WITH Linux-syscall-note' exception, which is
the officially assigned exception identifier for the kernel syscall
exception:
NOTE! This copyright does *not* cover user programs that use kernel
services by normal system calls - this is merely considered normal use
of the kernel, and does *not* fall under the heading of "derived work".
This exception makes it possible to include GPL headers into non GPL
code, without confusing license compliance tools.
Headers which have either explicit dual licensing or are just licensed
under a non GPL license are updated with the corresponding SPDX
identifier and the GPLv2 with syscall exception identifier. The format
is:
((GPL-2.0 WITH Linux-syscall-note) OR SPDX-ID-OF-OTHER-LICENSE)
SPDX license identifiers are a legally binding shorthand, which can be
used instead of the full boiler plate text. The update does not remove
existing license information as this has to be done on a case by case
basis and the copyright holders might have to be consulted. This will
happen in a separate step.
This patch is based on work done by Thomas Gleixner and Kate Stewart and
Philippe Ombredanne. See the previous patch in this series for the
methodology of how this patch was researched.
Reviewed-by: Kate Stewart <kstewart@linuxfoundation.org>
Reviewed-by: Philippe Ombredanne <pombredanne@nexb.com>
Reviewed-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
279 lines
9.1 KiB
C
279 lines
9.1 KiB
C
/* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) */
|
|
/*
|
|
* Copyright (c) 2015-2016, Integrated Device Technology Inc.
|
|
* Copyright (c) 2015, Prodrive Technologies
|
|
* Copyright (c) 2015, Texas Instruments Incorporated
|
|
* Copyright (c) 2015, RapidIO Trade Association
|
|
* All rights reserved.
|
|
*
|
|
* This software is available to you under a choice of one of two licenses.
|
|
* You may choose to be licensed under the terms of the GNU General Public
|
|
* License(GPL) Version 2, or the BSD-3 Clause license below:
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright notice,
|
|
* this list of conditions and the following disclaimer.
|
|
*
|
|
* 2. Redistributions in binary form must reproduce the above copyright notice,
|
|
* this list of conditions and the following disclaimer in the documentation
|
|
* and/or other materials provided with the distribution.
|
|
*
|
|
* 3. Neither the name of the copyright holder nor the names of its contributors
|
|
* may be used to endorse or promote products derived from this software without
|
|
* specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
|
|
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
|
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
|
|
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
|
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
|
|
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
|
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
|
|
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
|
|
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#ifndef _RIO_MPORT_CDEV_H_
|
|
#define _RIO_MPORT_CDEV_H_
|
|
|
|
#include <linux/ioctl.h>
|
|
#include <linux/types.h>
|
|
|
|
struct rio_mport_maint_io {
|
|
__u16 rioid; /* destID of remote device */
|
|
__u8 hopcount; /* hopcount to remote device */
|
|
__u8 pad0[5];
|
|
__u32 offset; /* offset in register space */
|
|
__u32 length; /* length in bytes */
|
|
__u64 buffer; /* pointer to data buffer */
|
|
};
|
|
|
|
/*
|
|
* Definitions for RapidIO data transfers:
|
|
* - memory mapped (MAPPED)
|
|
* - packet generation from memory (TRANSFER)
|
|
*/
|
|
#define RIO_TRANSFER_MODE_MAPPED (1 << 0)
|
|
#define RIO_TRANSFER_MODE_TRANSFER (1 << 1)
|
|
#define RIO_CAP_DBL_SEND (1 << 2)
|
|
#define RIO_CAP_DBL_RECV (1 << 3)
|
|
#define RIO_CAP_PW_SEND (1 << 4)
|
|
#define RIO_CAP_PW_RECV (1 << 5)
|
|
#define RIO_CAP_MAP_OUTB (1 << 6)
|
|
#define RIO_CAP_MAP_INB (1 << 7)
|
|
|
|
struct rio_mport_properties {
|
|
__u16 hdid;
|
|
__u8 id; /* Physical port ID */
|
|
__u8 index;
|
|
__u32 flags;
|
|
__u32 sys_size; /* Default addressing size */
|
|
__u8 port_ok;
|
|
__u8 link_speed;
|
|
__u8 link_width;
|
|
__u8 pad0;
|
|
__u32 dma_max_sge;
|
|
__u32 dma_max_size;
|
|
__u32 dma_align;
|
|
__u32 transfer_mode; /* Default transfer mode */
|
|
__u32 cap_sys_size; /* Capable system sizes */
|
|
__u32 cap_addr_size; /* Capable addressing sizes */
|
|
__u32 cap_transfer_mode; /* Capable transfer modes */
|
|
__u32 cap_mport; /* Mport capabilities */
|
|
};
|
|
|
|
/*
|
|
* Definitions for RapidIO events;
|
|
* - incoming port-writes
|
|
* - incoming doorbells
|
|
*/
|
|
#define RIO_DOORBELL (1 << 0)
|
|
#define RIO_PORTWRITE (1 << 1)
|
|
|
|
struct rio_doorbell {
|
|
__u16 rioid;
|
|
__u16 payload;
|
|
};
|
|
|
|
struct rio_doorbell_filter {
|
|
__u16 rioid; /* Use RIO_INVALID_DESTID to match all ids */
|
|
__u16 low;
|
|
__u16 high;
|
|
__u16 pad0;
|
|
};
|
|
|
|
|
|
struct rio_portwrite {
|
|
__u32 payload[16];
|
|
};
|
|
|
|
struct rio_pw_filter {
|
|
__u32 mask;
|
|
__u32 low;
|
|
__u32 high;
|
|
__u32 pad0;
|
|
};
|
|
|
|
/* RapidIO base address for inbound requests set to value defined below
|
|
* indicates that no specific RIO-to-local address translation is requested
|
|
* and driver should use direct (one-to-one) address mapping.
|
|
*/
|
|
#define RIO_MAP_ANY_ADDR (__u64)(~((__u64) 0))
|
|
|
|
struct rio_mmap {
|
|
__u16 rioid;
|
|
__u16 pad0[3];
|
|
__u64 rio_addr;
|
|
__u64 length;
|
|
__u64 handle;
|
|
__u64 address;
|
|
};
|
|
|
|
struct rio_dma_mem {
|
|
__u64 length; /* length of DMA memory */
|
|
__u64 dma_handle; /* handle associated with this memory */
|
|
__u64 address;
|
|
};
|
|
|
|
struct rio_event {
|
|
__u32 header; /* event type RIO_DOORBELL or RIO_PORTWRITE */
|
|
union {
|
|
struct rio_doorbell doorbell; /* header for RIO_DOORBELL */
|
|
struct rio_portwrite portwrite; /* header for RIO_PORTWRITE */
|
|
} u;
|
|
__u32 pad0;
|
|
};
|
|
|
|
enum rio_transfer_sync {
|
|
RIO_TRANSFER_SYNC, /* synchronous transfer */
|
|
RIO_TRANSFER_ASYNC, /* asynchronous transfer */
|
|
RIO_TRANSFER_FAF, /* fire-and-forget transfer */
|
|
};
|
|
|
|
enum rio_transfer_dir {
|
|
RIO_TRANSFER_DIR_READ, /* Read operation */
|
|
RIO_TRANSFER_DIR_WRITE, /* Write operation */
|
|
};
|
|
|
|
/*
|
|
* RapidIO data exchange transactions are lists of individual transfers. Each
|
|
* transfer exchanges data between two RapidIO devices by remote direct memory
|
|
* access and has its own completion code.
|
|
*
|
|
* The RapidIO specification defines four types of data exchange requests:
|
|
* NREAD, NWRITE, SWRITE and NWRITE_R. The RapidIO DMA channel interface allows
|
|
* to specify the required type of write operation or combination of them when
|
|
* only the last data packet requires response.
|
|
*
|
|
* NREAD: read up to 256 bytes from remote device memory into local memory
|
|
* NWRITE: write up to 256 bytes from local memory to remote device memory
|
|
* without confirmation
|
|
* SWRITE: as NWRITE, but all addresses and payloads must be 64-bit aligned
|
|
* NWRITE_R: as NWRITE, but expect acknowledgment from remote device.
|
|
*
|
|
* The default exchange is chosen from NREAD and any of the WRITE modes as the
|
|
* driver sees fit. For write requests the user can explicitly choose between
|
|
* any of the write modes for each transaction.
|
|
*/
|
|
enum rio_exchange {
|
|
RIO_EXCHANGE_DEFAULT, /* Default method */
|
|
RIO_EXCHANGE_NWRITE, /* All packets using NWRITE */
|
|
RIO_EXCHANGE_SWRITE, /* All packets using SWRITE */
|
|
RIO_EXCHANGE_NWRITE_R, /* Last packet NWRITE_R, others NWRITE */
|
|
RIO_EXCHANGE_SWRITE_R, /* Last packet NWRITE_R, others SWRITE */
|
|
RIO_EXCHANGE_NWRITE_R_ALL, /* All packets using NWRITE_R */
|
|
};
|
|
|
|
struct rio_transfer_io {
|
|
__u64 rio_addr; /* Address in target's RIO mem space */
|
|
__u64 loc_addr;
|
|
__u64 handle;
|
|
__u64 offset; /* Offset in buffer */
|
|
__u64 length; /* Length in bytes */
|
|
__u16 rioid; /* Target destID */
|
|
__u16 method; /* Data exchange method, one of rio_exchange enum */
|
|
__u32 completion_code; /* Completion code for this transfer */
|
|
};
|
|
|
|
struct rio_transaction {
|
|
__u64 block; /* Pointer to array of <count> transfers */
|
|
__u32 count; /* Number of transfers */
|
|
__u32 transfer_mode; /* Data transfer mode */
|
|
__u16 sync; /* Synch method, one of rio_transfer_sync enum */
|
|
__u16 dir; /* Transfer direction, one of rio_transfer_dir enum */
|
|
__u32 pad0;
|
|
};
|
|
|
|
struct rio_async_tx_wait {
|
|
__u32 token; /* DMA transaction ID token */
|
|
__u32 timeout; /* Wait timeout in msec, if 0 use default TO */
|
|
};
|
|
|
|
#define RIO_MAX_DEVNAME_SZ 20
|
|
|
|
struct rio_rdev_info {
|
|
__u16 destid;
|
|
__u8 hopcount;
|
|
__u8 pad0;
|
|
__u32 comptag;
|
|
char name[RIO_MAX_DEVNAME_SZ + 1];
|
|
};
|
|
|
|
/* Driver IOCTL codes */
|
|
#define RIO_MPORT_DRV_MAGIC 'm'
|
|
|
|
#define RIO_MPORT_MAINT_HDID_SET \
|
|
_IOW(RIO_MPORT_DRV_MAGIC, 1, __u16)
|
|
#define RIO_MPORT_MAINT_COMPTAG_SET \
|
|
_IOW(RIO_MPORT_DRV_MAGIC, 2, __u32)
|
|
#define RIO_MPORT_MAINT_PORT_IDX_GET \
|
|
_IOR(RIO_MPORT_DRV_MAGIC, 3, __u32)
|
|
#define RIO_MPORT_GET_PROPERTIES \
|
|
_IOR(RIO_MPORT_DRV_MAGIC, 4, struct rio_mport_properties)
|
|
#define RIO_MPORT_MAINT_READ_LOCAL \
|
|
_IOR(RIO_MPORT_DRV_MAGIC, 5, struct rio_mport_maint_io)
|
|
#define RIO_MPORT_MAINT_WRITE_LOCAL \
|
|
_IOW(RIO_MPORT_DRV_MAGIC, 6, struct rio_mport_maint_io)
|
|
#define RIO_MPORT_MAINT_READ_REMOTE \
|
|
_IOR(RIO_MPORT_DRV_MAGIC, 7, struct rio_mport_maint_io)
|
|
#define RIO_MPORT_MAINT_WRITE_REMOTE \
|
|
_IOW(RIO_MPORT_DRV_MAGIC, 8, struct rio_mport_maint_io)
|
|
#define RIO_ENABLE_DOORBELL_RANGE \
|
|
_IOW(RIO_MPORT_DRV_MAGIC, 9, struct rio_doorbell_filter)
|
|
#define RIO_DISABLE_DOORBELL_RANGE \
|
|
_IOW(RIO_MPORT_DRV_MAGIC, 10, struct rio_doorbell_filter)
|
|
#define RIO_ENABLE_PORTWRITE_RANGE \
|
|
_IOW(RIO_MPORT_DRV_MAGIC, 11, struct rio_pw_filter)
|
|
#define RIO_DISABLE_PORTWRITE_RANGE \
|
|
_IOW(RIO_MPORT_DRV_MAGIC, 12, struct rio_pw_filter)
|
|
#define RIO_SET_EVENT_MASK \
|
|
_IOW(RIO_MPORT_DRV_MAGIC, 13, __u32)
|
|
#define RIO_GET_EVENT_MASK \
|
|
_IOR(RIO_MPORT_DRV_MAGIC, 14, __u32)
|
|
#define RIO_MAP_OUTBOUND \
|
|
_IOWR(RIO_MPORT_DRV_MAGIC, 15, struct rio_mmap)
|
|
#define RIO_UNMAP_OUTBOUND \
|
|
_IOW(RIO_MPORT_DRV_MAGIC, 16, struct rio_mmap)
|
|
#define RIO_MAP_INBOUND \
|
|
_IOWR(RIO_MPORT_DRV_MAGIC, 17, struct rio_mmap)
|
|
#define RIO_UNMAP_INBOUND \
|
|
_IOW(RIO_MPORT_DRV_MAGIC, 18, __u64)
|
|
#define RIO_ALLOC_DMA \
|
|
_IOWR(RIO_MPORT_DRV_MAGIC, 19, struct rio_dma_mem)
|
|
#define RIO_FREE_DMA \
|
|
_IOW(RIO_MPORT_DRV_MAGIC, 20, __u64)
|
|
#define RIO_TRANSFER \
|
|
_IOWR(RIO_MPORT_DRV_MAGIC, 21, struct rio_transaction)
|
|
#define RIO_WAIT_FOR_ASYNC \
|
|
_IOW(RIO_MPORT_DRV_MAGIC, 22, struct rio_async_tx_wait)
|
|
#define RIO_DEV_ADD \
|
|
_IOW(RIO_MPORT_DRV_MAGIC, 23, struct rio_rdev_info)
|
|
#define RIO_DEV_DEL \
|
|
_IOW(RIO_MPORT_DRV_MAGIC, 24, struct rio_rdev_info)
|
|
|
|
#endif /* _RIO_MPORT_CDEV_H_ */
|