mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-12-23 18:39:03 +07:00
b24413180f
Many source files in the tree are missing licensing information, which makes it harder for compliance tools to determine the correct license. By default all files without license information are under the default license of the kernel, which is GPL version 2. Update the files which contain no license information with the 'GPL-2.0' SPDX license identifier. The SPDX identifier is a legally binding shorthand, which can be used instead of the full boiler plate text. This patch is based on work done by Thomas Gleixner and Kate Stewart and Philippe Ombredanne. How this work was done: Patches were generated and checked against linux-4.14-rc6 for a subset of the use cases: - file had no licensing information it it. - file was a */uapi/* one with no licensing information in it, - file was a */uapi/* one with existing licensing information, Further patches will be generated in subsequent months to fix up cases where non-standard license headers were used, and references to license had to be inferred by heuristics based on keywords. The analysis to determine which SPDX License Identifier to be applied to a file was done in a spreadsheet of side by side results from of the output of two independent scanners (ScanCode & Windriver) producing SPDX tag:value files created by Philippe Ombredanne. Philippe prepared the base worksheet, and did an initial spot review of a few 1000 files. The 4.13 kernel was the starting point of the analysis with 60,537 files assessed. Kate Stewart did a file by file comparison of the scanner results in the spreadsheet to determine which SPDX license identifier(s) to be applied to the file. She confirmed any determination that was not immediately clear with lawyers working with the Linux Foundation. Criteria used to select files for SPDX license identifier tagging was: - Files considered eligible had to be source code files. - Make and config files were included as candidates if they contained >5 lines of source - File already had some variant of a license header in it (even if <5 lines). All documentation files were explicitly excluded. The following heuristics were used to determine which SPDX license identifiers to apply. - when both scanners couldn't find any license traces, file was considered to have no license information in it, and the top level COPYING file license applied. For non */uapi/* files that summary was: SPDX license identifier # files ---------------------------------------------------|------- GPL-2.0 11139 and resulted in the first patch in this series. If that file was a */uapi/* path one, it was "GPL-2.0 WITH Linux-syscall-note" otherwise it was "GPL-2.0". Results of that was: SPDX license identifier # files ---------------------------------------------------|------- GPL-2.0 WITH Linux-syscall-note 930 and resulted in the second patch in this series. - if a file had some form of licensing information in it, and was one of the */uapi/* ones, it was denoted with the Linux-syscall-note if any GPL family license was found in the file or had no licensing in it (per prior point). Results summary: SPDX license identifier # files ---------------------------------------------------|------ GPL-2.0 WITH Linux-syscall-note 270 GPL-2.0+ WITH Linux-syscall-note 169 ((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) 21 ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) 17 LGPL-2.1+ WITH Linux-syscall-note 15 GPL-1.0+ WITH Linux-syscall-note 14 ((GPL-2.0+ WITH Linux-syscall-note) OR BSD-3-Clause) 5 LGPL-2.0+ WITH Linux-syscall-note 4 LGPL-2.1 WITH Linux-syscall-note 3 ((GPL-2.0 WITH Linux-syscall-note) OR MIT) 3 ((GPL-2.0 WITH Linux-syscall-note) AND MIT) 1 and that resulted in the third patch in this series. - when the two scanners agreed on the detected license(s), that became the concluded license(s). - when there was disagreement between the two scanners (one detected a license but the other didn't, or they both detected different licenses) a manual inspection of the file occurred. - In most cases a manual inspection of the information in the file resulted in a clear resolution of the license that should apply (and which scanner probably needed to revisit its heuristics). - When it was not immediately clear, the license identifier was confirmed with lawyers working with the Linux Foundation. - If there was any question as to the appropriate license identifier, the file was flagged for further research and to be revisited later in time. In total, over 70 hours of logged manual review was done on the spreadsheet to determine the SPDX license identifiers to apply to the source files by Kate, Philippe, Thomas and, in some cases, confirmation by lawyers working with the Linux Foundation. Kate also obtained a third independent scan of the 4.13 code base from FOSSology, and compared selected files where the other two scanners disagreed against that SPDX file, to see if there was new insights. The Windriver scanner is based on an older version of FOSSology in part, so they are related. Thomas did random spot checks in about 500 files from the spreadsheets for the uapi headers and agreed with SPDX license identifier in the files he inspected. For the non-uapi files Thomas did random spot checks in about 15000 files. In initial set of patches against 4.14-rc6, 3 files were found to have copy/paste license identifier errors, and have been fixed to reflect the correct identifier. Additionally Philippe spent 10 hours this week doing a detailed manual inspection and review of the 12,461 patched files from the initial patch version early this week with: - a full scancode scan run, collecting the matched texts, detected license ids and scores - reviewing anything where there was a license detected (about 500+ files) to ensure that the applied SPDX license was correct - reviewing anything where there was no detection but the patch license was not GPL-2.0 WITH Linux-syscall-note to ensure that the applied SPDX license was correct This produced a worksheet with 20 files needing minor correction. This worksheet was then exported into 3 different .csv files for the different types of files to be modified. These .csv files were then reviewed by Greg. Thomas wrote a script to parse the csv files and add the proper SPDX tag to the file, in the format that the file expected. This script was further refined by Greg based on the output to detect more types of files automatically and to distinguish between header and source .c files (which need different comment types.) Finally Greg ran the script using the .csv files to generate the patches. 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>
516 lines
12 KiB
C
516 lines
12 KiB
C
/* SPDX-License-Identifier: GPL-2.0 */
|
|
#ifndef _SPARC64_VIO_H
|
|
#define _SPARC64_VIO_H
|
|
|
|
#include <linux/kernel.h>
|
|
#include <linux/device.h>
|
|
#include <linux/mod_devicetable.h>
|
|
#include <linux/timer.h>
|
|
#include <linux/spinlock.h>
|
|
#include <linux/completion.h>
|
|
#include <linux/list.h>
|
|
#include <linux/log2.h>
|
|
|
|
#include <asm/ldc.h>
|
|
#include <asm/mdesc.h>
|
|
|
|
struct vio_msg_tag {
|
|
u8 type;
|
|
#define VIO_TYPE_CTRL 0x01
|
|
#define VIO_TYPE_DATA 0x02
|
|
#define VIO_TYPE_ERR 0x04
|
|
|
|
u8 stype;
|
|
#define VIO_SUBTYPE_INFO 0x01
|
|
#define VIO_SUBTYPE_ACK 0x02
|
|
#define VIO_SUBTYPE_NACK 0x04
|
|
|
|
u16 stype_env;
|
|
#define VIO_VER_INFO 0x0001
|
|
#define VIO_ATTR_INFO 0x0002
|
|
#define VIO_DRING_REG 0x0003
|
|
#define VIO_DRING_UNREG 0x0004
|
|
#define VIO_RDX 0x0005
|
|
#define VIO_PKT_DATA 0x0040
|
|
#define VIO_DESC_DATA 0x0041
|
|
#define VIO_DRING_DATA 0x0042
|
|
#define VNET_MCAST_INFO 0x0101
|
|
|
|
u32 sid;
|
|
};
|
|
|
|
struct vio_rdx {
|
|
struct vio_msg_tag tag;
|
|
u64 resv[6];
|
|
};
|
|
|
|
struct vio_ver_info {
|
|
struct vio_msg_tag tag;
|
|
u16 major;
|
|
u16 minor;
|
|
u8 dev_class;
|
|
#define VDEV_NETWORK 0x01
|
|
#define VDEV_NETWORK_SWITCH 0x02
|
|
#define VDEV_DISK 0x03
|
|
#define VDEV_DISK_SERVER 0x04
|
|
#define VDEV_CONSOLE_CON 0x05
|
|
|
|
u8 resv1[3];
|
|
u64 resv2[5];
|
|
};
|
|
|
|
struct vio_dring_register {
|
|
struct vio_msg_tag tag;
|
|
u64 dring_ident;
|
|
u32 num_descr;
|
|
u32 descr_size;
|
|
u16 options;
|
|
#define VIO_TX_DRING 0x0001
|
|
#define VIO_RX_DRING 0x0002
|
|
#define VIO_RX_DRING_DATA 0x0004
|
|
u16 resv;
|
|
u32 num_cookies;
|
|
struct ldc_trans_cookie cookies[0];
|
|
};
|
|
|
|
struct vio_dring_unregister {
|
|
struct vio_msg_tag tag;
|
|
u64 dring_ident;
|
|
u64 resv[5];
|
|
};
|
|
|
|
/* Data transfer modes */
|
|
#define VIO_PKT_MODE 0x01 /* Packet based transfer */
|
|
#define VIO_DESC_MODE 0x02 /* In-band descriptors */
|
|
#define VIO_DRING_MODE 0x03 /* Descriptor rings */
|
|
/* in vers >= 1.2, VIO_DRING_MODE is 0x04 and transfer mode is a bitmask */
|
|
#define VIO_NEW_DRING_MODE 0x04
|
|
|
|
struct vio_dring_data {
|
|
struct vio_msg_tag tag;
|
|
u64 seq;
|
|
u64 dring_ident;
|
|
u32 start_idx;
|
|
u32 end_idx;
|
|
u8 state;
|
|
#define VIO_DRING_ACTIVE 0x01
|
|
#define VIO_DRING_STOPPED 0x02
|
|
|
|
u8 __pad1;
|
|
u16 __pad2;
|
|
u32 __pad3;
|
|
u64 __par4[2];
|
|
};
|
|
|
|
struct vio_dring_hdr {
|
|
u8 state;
|
|
#define VIO_DESC_FREE 0x01
|
|
#define VIO_DESC_READY 0x02
|
|
#define VIO_DESC_ACCEPTED 0x03
|
|
#define VIO_DESC_DONE 0x04
|
|
u8 ack;
|
|
#define VIO_ACK_ENABLE 0x01
|
|
#define VIO_ACK_DISABLE 0x00
|
|
|
|
u16 __pad1;
|
|
u32 __pad2;
|
|
};
|
|
|
|
/* VIO disk specific structures and defines */
|
|
struct vio_disk_attr_info {
|
|
struct vio_msg_tag tag;
|
|
u8 xfer_mode;
|
|
u8 vdisk_type;
|
|
#define VD_DISK_TYPE_SLICE 0x01 /* Slice in block device */
|
|
#define VD_DISK_TYPE_DISK 0x02 /* Entire block device */
|
|
u8 vdisk_mtype; /* v1.1 */
|
|
#define VD_MEDIA_TYPE_FIXED 0x01 /* Fixed device */
|
|
#define VD_MEDIA_TYPE_CD 0x02 /* CD Device */
|
|
#define VD_MEDIA_TYPE_DVD 0x03 /* DVD Device */
|
|
u8 resv1;
|
|
u32 vdisk_block_size;
|
|
u64 operations;
|
|
u64 vdisk_size; /* v1.1 */
|
|
u64 max_xfer_size;
|
|
u32 phys_block_size; /* v1.2 */
|
|
u32 resv2;
|
|
u64 resv3[1];
|
|
};
|
|
|
|
struct vio_disk_desc {
|
|
struct vio_dring_hdr hdr;
|
|
u64 req_id;
|
|
u8 operation;
|
|
#define VD_OP_BREAD 0x01 /* Block read */
|
|
#define VD_OP_BWRITE 0x02 /* Block write */
|
|
#define VD_OP_FLUSH 0x03 /* Flush disk contents */
|
|
#define VD_OP_GET_WCE 0x04 /* Get write-cache status */
|
|
#define VD_OP_SET_WCE 0x05 /* Enable/disable write-cache */
|
|
#define VD_OP_GET_VTOC 0x06 /* Get VTOC */
|
|
#define VD_OP_SET_VTOC 0x07 /* Set VTOC */
|
|
#define VD_OP_GET_DISKGEOM 0x08 /* Get disk geometry */
|
|
#define VD_OP_SET_DISKGEOM 0x09 /* Set disk geometry */
|
|
#define VD_OP_SCSICMD 0x0a /* SCSI control command */
|
|
#define VD_OP_GET_DEVID 0x0b /* Get device ID */
|
|
#define VD_OP_GET_EFI 0x0c /* Get EFI */
|
|
#define VD_OP_SET_EFI 0x0d /* Set EFI */
|
|
u8 slice;
|
|
u16 resv1;
|
|
u32 status;
|
|
u64 offset;
|
|
u64 size;
|
|
u32 ncookies;
|
|
u32 resv2;
|
|
struct ldc_trans_cookie cookies[0];
|
|
};
|
|
|
|
#define VIO_DISK_VNAME_LEN 8
|
|
#define VIO_DISK_ALABEL_LEN 128
|
|
#define VIO_DISK_NUM_PART 8
|
|
|
|
struct vio_disk_vtoc {
|
|
u8 volume_name[VIO_DISK_VNAME_LEN];
|
|
u16 sector_size;
|
|
u16 num_partitions;
|
|
u8 ascii_label[VIO_DISK_ALABEL_LEN];
|
|
struct {
|
|
u16 id;
|
|
u16 perm_flags;
|
|
u32 resv;
|
|
u64 start_block;
|
|
u64 num_blocks;
|
|
} partitions[VIO_DISK_NUM_PART];
|
|
};
|
|
|
|
struct vio_disk_geom {
|
|
u16 num_cyl; /* Num data cylinders */
|
|
u16 alt_cyl; /* Num alternate cylinders */
|
|
u16 beg_cyl; /* Cyl off of fixed head area */
|
|
u16 num_hd; /* Num heads */
|
|
u16 num_sec; /* Num sectors */
|
|
u16 ifact; /* Interleave factor */
|
|
u16 apc; /* Alts per cylinder (SCSI) */
|
|
u16 rpm; /* Revolutions per minute */
|
|
u16 phy_cyl; /* Num physical cylinders */
|
|
u16 wr_skip; /* Num sects to skip, writes */
|
|
u16 rd_skip; /* Num sects to skip, writes */
|
|
};
|
|
|
|
struct vio_disk_devid {
|
|
u16 resv;
|
|
u16 type;
|
|
u32 len;
|
|
char id[0];
|
|
};
|
|
|
|
struct vio_disk_efi {
|
|
u64 lba;
|
|
u64 len;
|
|
char data[0];
|
|
};
|
|
|
|
/* VIO net specific structures and defines */
|
|
struct vio_net_attr_info {
|
|
struct vio_msg_tag tag;
|
|
u8 xfer_mode;
|
|
u8 addr_type;
|
|
#define VNET_ADDR_ETHERMAC 0x01
|
|
u16 ack_freq;
|
|
u8 plnk_updt;
|
|
#define PHYSLINK_UPDATE_NONE 0x00
|
|
#define PHYSLINK_UPDATE_STATE 0x01
|
|
#define PHYSLINK_UPDATE_STATE_ACK 0x02
|
|
#define PHYSLINK_UPDATE_STATE_NACK 0x03
|
|
u8 options;
|
|
u16 resv1;
|
|
u64 addr;
|
|
u64 mtu;
|
|
u16 cflags;
|
|
#define VNET_LSO_IPV4_CAPAB 0x0001
|
|
u16 ipv4_lso_maxlen;
|
|
u32 resv2;
|
|
u64 resv3[2];
|
|
};
|
|
|
|
#define VNET_NUM_MCAST 7
|
|
|
|
struct vio_net_mcast_info {
|
|
struct vio_msg_tag tag;
|
|
u8 set;
|
|
u8 count;
|
|
u8 mcast_addr[VNET_NUM_MCAST * 6];
|
|
u32 resv;
|
|
};
|
|
|
|
struct vio_net_desc {
|
|
struct vio_dring_hdr hdr;
|
|
u32 size;
|
|
u32 ncookies;
|
|
struct ldc_trans_cookie cookies[0];
|
|
};
|
|
|
|
struct vio_net_dext {
|
|
u8 flags;
|
|
#define VNET_PKT_HASH 0x01
|
|
#define VNET_PKT_HCK_IPV4_HDRCKSUM 0x02
|
|
#define VNET_PKT_HCK_FULLCKSUM 0x04
|
|
#define VNET_PKT_IPV4_LSO 0x08
|
|
#define VNET_PKT_HCK_IPV4_HDRCKSUM_OK 0x10
|
|
#define VNET_PKT_HCK_FULLCKSUM_OK 0x20
|
|
|
|
u8 vnet_hashval;
|
|
u16 ipv4_lso_mss;
|
|
u32 resv3;
|
|
};
|
|
|
|
static inline struct vio_net_dext *vio_net_ext(struct vio_net_desc *desc)
|
|
{
|
|
return (struct vio_net_dext *)&desc->cookies[2];
|
|
}
|
|
|
|
#define VIO_MAX_RING_COOKIES 24
|
|
|
|
struct vio_dring_state {
|
|
u64 ident;
|
|
void *base;
|
|
u64 snd_nxt;
|
|
u64 rcv_nxt;
|
|
u32 entry_size;
|
|
u32 num_entries;
|
|
u32 prod;
|
|
u32 cons;
|
|
u32 pending;
|
|
int ncookies;
|
|
struct ldc_trans_cookie cookies[VIO_MAX_RING_COOKIES];
|
|
};
|
|
|
|
#define VIO_TAG_SIZE ((int)sizeof(struct vio_msg_tag))
|
|
#define VIO_VCC_MTU_SIZE (LDC_PACKET_SIZE - VIO_TAG_SIZE)
|
|
|
|
struct vio_vcc {
|
|
struct vio_msg_tag tag;
|
|
char data[VIO_VCC_MTU_SIZE];
|
|
};
|
|
|
|
static inline void *vio_dring_cur(struct vio_dring_state *dr)
|
|
{
|
|
return dr->base + (dr->entry_size * dr->prod);
|
|
}
|
|
|
|
static inline void *vio_dring_entry(struct vio_dring_state *dr,
|
|
unsigned int index)
|
|
{
|
|
return dr->base + (dr->entry_size * index);
|
|
}
|
|
|
|
static inline u32 vio_dring_avail(struct vio_dring_state *dr,
|
|
unsigned int ring_size)
|
|
{
|
|
return (dr->pending -
|
|
((dr->prod - dr->cons) & (ring_size - 1)) - 1);
|
|
}
|
|
|
|
static inline u32 vio_dring_next(struct vio_dring_state *dr, u32 index)
|
|
{
|
|
if (++index == dr->num_entries)
|
|
index = 0;
|
|
return index;
|
|
}
|
|
|
|
static inline u32 vio_dring_prev(struct vio_dring_state *dr, u32 index)
|
|
{
|
|
if (index == 0)
|
|
return dr->num_entries - 1;
|
|
else
|
|
return index - 1;
|
|
}
|
|
|
|
#define VIO_MAX_TYPE_LEN 32
|
|
#define VIO_MAX_NAME_LEN 32
|
|
#define VIO_MAX_COMPAT_LEN 64
|
|
|
|
struct vio_dev {
|
|
u64 mp;
|
|
struct device_node *dp;
|
|
|
|
char node_name[VIO_MAX_NAME_LEN];
|
|
char type[VIO_MAX_TYPE_LEN];
|
|
char compat[VIO_MAX_COMPAT_LEN];
|
|
int compat_len;
|
|
|
|
u64 dev_no;
|
|
|
|
unsigned long port_id;
|
|
unsigned long channel_id;
|
|
|
|
unsigned int tx_irq;
|
|
unsigned int rx_irq;
|
|
u64 rx_ino;
|
|
u64 tx_ino;
|
|
|
|
/* Handle to the root of "channel-devices" sub-tree in MDESC */
|
|
u64 cdev_handle;
|
|
|
|
/* MD specific data used to identify the vdev in MD */
|
|
union md_node_info md_node_info;
|
|
|
|
struct device dev;
|
|
};
|
|
|
|
struct vio_driver {
|
|
const char *name;
|
|
struct list_head node;
|
|
const struct vio_device_id *id_table;
|
|
int (*probe)(struct vio_dev *dev, const struct vio_device_id *id);
|
|
int (*remove)(struct vio_dev *dev);
|
|
void (*shutdown)(struct vio_dev *dev);
|
|
unsigned long driver_data;
|
|
struct device_driver driver;
|
|
bool no_irq;
|
|
};
|
|
|
|
struct vio_version {
|
|
u16 major;
|
|
u16 minor;
|
|
};
|
|
|
|
struct vio_driver_state;
|
|
struct vio_driver_ops {
|
|
int (*send_attr)(struct vio_driver_state *vio);
|
|
int (*handle_attr)(struct vio_driver_state *vio, void *pkt);
|
|
void (*handshake_complete)(struct vio_driver_state *vio);
|
|
};
|
|
|
|
struct vio_completion {
|
|
struct completion com;
|
|
int err;
|
|
int waiting_for;
|
|
};
|
|
|
|
struct vio_driver_state {
|
|
/* Protects VIO handshake and, optionally, driver private state. */
|
|
spinlock_t lock;
|
|
|
|
struct ldc_channel *lp;
|
|
|
|
u32 _peer_sid;
|
|
u32 _local_sid;
|
|
struct vio_dring_state drings[2];
|
|
#define VIO_DRIVER_TX_RING 0
|
|
#define VIO_DRIVER_RX_RING 1
|
|
|
|
u8 hs_state;
|
|
#define VIO_HS_INVALID 0x00
|
|
#define VIO_HS_GOTVERS 0x01
|
|
#define VIO_HS_GOT_ATTR 0x04
|
|
#define VIO_HS_SENT_DREG 0x08
|
|
#define VIO_HS_SENT_RDX 0x10
|
|
#define VIO_HS_GOT_RDX_ACK 0x20
|
|
#define VIO_HS_GOT_RDX 0x40
|
|
#define VIO_HS_SENT_RDX_ACK 0x80
|
|
#define VIO_HS_COMPLETE (VIO_HS_GOT_RDX_ACK | VIO_HS_SENT_RDX_ACK)
|
|
|
|
u8 dev_class;
|
|
|
|
u8 dr_state;
|
|
#define VIO_DR_STATE_TXREG 0x01
|
|
#define VIO_DR_STATE_RXREG 0x02
|
|
#define VIO_DR_STATE_TXREQ 0x10
|
|
#define VIO_DR_STATE_RXREQ 0x20
|
|
|
|
u8 debug;
|
|
#define VIO_DEBUG_HS 0x01
|
|
#define VIO_DEBUG_DATA 0x02
|
|
|
|
void *desc_buf;
|
|
unsigned int desc_buf_len;
|
|
|
|
struct vio_completion *cmp;
|
|
|
|
struct vio_dev *vdev;
|
|
|
|
struct timer_list timer;
|
|
|
|
struct vio_version ver;
|
|
|
|
struct vio_version *ver_table;
|
|
int ver_table_entries;
|
|
|
|
char *name;
|
|
|
|
struct vio_driver_ops *ops;
|
|
};
|
|
|
|
static inline bool vio_version_before(struct vio_driver_state *vio,
|
|
u16 major, u16 minor)
|
|
{
|
|
u32 have = (u32)vio->ver.major << 16 | vio->ver.minor;
|
|
u32 want = (u32)major << 16 | minor;
|
|
|
|
return have < want;
|
|
}
|
|
|
|
static inline bool vio_version_after(struct vio_driver_state *vio,
|
|
u16 major, u16 minor)
|
|
{
|
|
u32 have = (u32)vio->ver.major << 16 | vio->ver.minor;
|
|
u32 want = (u32)major << 16 | minor;
|
|
|
|
return have > want;
|
|
}
|
|
|
|
static inline bool vio_version_after_eq(struct vio_driver_state *vio,
|
|
u16 major, u16 minor)
|
|
{
|
|
u32 have = (u32)vio->ver.major << 16 | vio->ver.minor;
|
|
u32 want = (u32)major << 16 | minor;
|
|
|
|
return have >= want;
|
|
}
|
|
|
|
#define viodbg(TYPE, f, a...) \
|
|
do { if (vio->debug & VIO_DEBUG_##TYPE) \
|
|
printk(KERN_INFO "vio: ID[%lu] " f, \
|
|
vio->vdev->channel_id, ## a); \
|
|
} while (0)
|
|
|
|
int __vio_register_driver(struct vio_driver *drv, struct module *owner,
|
|
const char *mod_name);
|
|
/*
|
|
* vio_register_driver must be a macro so that KBUILD_MODNAME can be expanded
|
|
*/
|
|
#define vio_register_driver(driver) \
|
|
__vio_register_driver(driver, THIS_MODULE, KBUILD_MODNAME)
|
|
void vio_unregister_driver(struct vio_driver *drv);
|
|
|
|
static inline struct vio_driver *to_vio_driver(struct device_driver *drv)
|
|
{
|
|
return container_of(drv, struct vio_driver, driver);
|
|
}
|
|
|
|
static inline struct vio_dev *to_vio_dev(struct device *dev)
|
|
{
|
|
return container_of(dev, struct vio_dev, dev);
|
|
}
|
|
|
|
int vio_ldc_send(struct vio_driver_state *vio, void *data, int len);
|
|
void vio_link_state_change(struct vio_driver_state *vio, int event);
|
|
void vio_conn_reset(struct vio_driver_state *vio);
|
|
int vio_control_pkt_engine(struct vio_driver_state *vio, void *pkt);
|
|
int vio_validate_sid(struct vio_driver_state *vio,
|
|
struct vio_msg_tag *tp);
|
|
u32 vio_send_sid(struct vio_driver_state *vio);
|
|
int vio_ldc_alloc(struct vio_driver_state *vio,
|
|
struct ldc_channel_config *base_cfg, void *event_arg);
|
|
void vio_ldc_free(struct vio_driver_state *vio);
|
|
int vio_driver_init(struct vio_driver_state *vio, struct vio_dev *vdev,
|
|
u8 dev_class, struct vio_version *ver_table,
|
|
int ver_table_size, struct vio_driver_ops *ops,
|
|
char *name);
|
|
|
|
void vio_port_up(struct vio_driver_state *vio);
|
|
int vio_set_intr(unsigned long dev_ino, int state);
|
|
u64 vio_vdev_node(struct mdesc_handle *hp, struct vio_dev *vdev);
|
|
|
|
#endif /* _SPARC64_VIO_H */
|