diff options
Diffstat (limited to 'src/roms/SLOF/lib/libvirtio')
| -rw-r--r-- | src/roms/SLOF/lib/libvirtio/Makefile | 55 | ||||
| -rw-r--r-- | src/roms/SLOF/lib/libvirtio/p9.c | 575 | ||||
| -rw-r--r-- | src/roms/SLOF/lib/libvirtio/p9.h | 68 | ||||
| -rw-r--r-- | src/roms/SLOF/lib/libvirtio/virtio-9p.c | 336 | ||||
| -rw-r--r-- | src/roms/SLOF/lib/libvirtio/virtio-9p.h | 32 | ||||
| -rw-r--r-- | src/roms/SLOF/lib/libvirtio/virtio-blk.c | 185 | ||||
| -rw-r--r-- | src/roms/SLOF/lib/libvirtio/virtio-blk.h | 60 | ||||
| -rw-r--r-- | src/roms/SLOF/lib/libvirtio/virtio-net.c | 369 | ||||
| -rw-r--r-- | src/roms/SLOF/lib/libvirtio/virtio-net.h | 43 | ||||
| -rw-r--r-- | src/roms/SLOF/lib/libvirtio/virtio-scsi.c | 145 | ||||
| -rw-r--r-- | src/roms/SLOF/lib/libvirtio/virtio-scsi.h | 69 | ||||
| -rw-r--r-- | src/roms/SLOF/lib/libvirtio/virtio.c | 241 | ||||
| -rw-r--r-- | src/roms/SLOF/lib/libvirtio/virtio.code | 164 | ||||
| -rw-r--r-- | src/roms/SLOF/lib/libvirtio/virtio.h | 90 | ||||
| -rw-r--r-- | src/roms/SLOF/lib/libvirtio/virtio.in | 33 |
15 files changed, 2465 insertions, 0 deletions
diff --git a/src/roms/SLOF/lib/libvirtio/Makefile b/src/roms/SLOF/lib/libvirtio/Makefile new file mode 100644 index 0000000..bd6a1fa --- /dev/null +++ b/src/roms/SLOF/lib/libvirtio/Makefile @@ -0,0 +1,55 @@ +# ***************************************************************************** +# * Copyright (c) 2004, 2008 IBM Corporation +# * All rights reserved. +# * This program and the accompanying materials +# * are made available under the terms of the BSD License +# * which accompanies this distribution, and is available at +# * http://www.opensource.org/licenses/bsd-license.php +# * +# * Contributors: +# * IBM Corporation - initial implementation +# ****************************************************************************/ + +TOPCMNDIR ?= ../.. + +include $(TOPCMNDIR)/make.rules + +ASFLAGS = $(FLAG) $(RELEASE) $(CPUARCHDEF) -Wa,-mregnames +CPPFLAGS = -I../libc/include $(CPUARCHDEF) -I$(INCLBRDDIR) \ + -I$(INCLCMNDIR) -I$(INCLCMNDIR)/$(CPUARCH) +LDFLAGS = -nostdlib + +TARGET = ../libvirtio.a + + +all: $(TARGET) + +SRCS = virtio.c virtio-blk.c p9.c virtio-9p.c virtio-scsi.c virtio-net.c + +OBJS = $(SRCS:%.c=%.o) + +$(TARGET): $(OBJS) + $(AR) -rc $@ $(OBJS) + $(RANLIB) $@ + +%.o: %.S + $(CC) $(CPPFLAGS) $(ASFLAGS) -c $< -o $@ + +clean: + $(RM) $(TARGET) $(OBJS) + +distclean: clean + $(RM) Makefile.dep + + +# Rules for creating the dependency file: +depend: + $(RM) Makefile.dep + $(MAKE) Makefile.dep + +Makefile.dep: Makefile + $(CC) -M $(CPPFLAGS) $(CFLAGS) $(SRCS) $(SRCSS) > Makefile.dep + +# Include dependency file if available: +-include Makefile.dep + diff --git a/src/roms/SLOF/lib/libvirtio/p9.c b/src/roms/SLOF/lib/libvirtio/p9.c new file mode 100644 index 0000000..a556629 --- /dev/null +++ b/src/roms/SLOF/lib/libvirtio/p9.c @@ -0,0 +1,575 @@ +/****************************************************************************** + * Copyright (c) 2011 IBM Corporation + * All rights reserved. + * This program and the accompanying materials + * are made available under the terms of the BSD License + * which accompanies this distribution, and is available at + * http://www.opensource.org/licenses/bsd-license.php + * + * Contributors: + * IBM Corporation - initial implementation + *****************************************************************************/ + +#include <stdio.h> +#include <stdint.h> +#include <string.h> +#include <byteorder.h> +#include "p9.h" + + +/* Protocol stack marshaling. */ +uint8_t *sp; + +#define GET_08(s,i) (s)[(i)] +#define GET_16(s,i) le16_to_cpu(*(uint16_t*)(&(s)[(i)])) +#define GET_32(s,i) le32_to_cpu(*(uint32_t*)(&(s)[(i)])) +#define GET_64(s,i) le64_to_cpu(*(uint64_t*)(&(s)[(i)])) + +#define SET_08(s,i,v) (s)[(i)] = (v) +#define SET_16(s,i,v) *(uint16_t*)(&(s)[(i)]) = cpu_to_le16(v) +#define SET_32(s,i,v) *(uint32_t*)(&(s)[(i)]) = cpu_to_le32(v) +#define SET_64(s,i,v) *(uint64_t*)(&(s)[(i)]) = cpu_to_le64(v) + +#define PUT_08(v) sp[0] = (v);sp+=1 +#define PUT_16(v) *(uint16_t*)(&sp[0]) = cpu_to_le16(v);sp+=2 +#define PUT_32(v) *(uint32_t*)(&sp[0]) = cpu_to_le32(v);sp+=4 +#define PUT_64(v) *(uint64_t*)(&sp[0]) = cpu_to_le64(v);sp+=8 + +#define PUT_HD(m,t) PUT_32(0);PUT_08(m);PUT_16(t) +#define PUT_SN(v,n) PUT_16(n);memcpy(sp,(v),(n));sp+=n +#define PUT_ST(v) PUT_16(strlen(v));memcpy(sp,(v),strlen(v));\ + sp+=strlen(v) + +#define GET_SIZE (sp - tx) + + +/* General defines. */ +#define MIN(a,b) ((a)>(b)?(b):(a)) + +#define NOTAG ((uint16_t)~0) +#define NOFID ((uint32_t)~0) +#define TAG 1 +#define BUF_SIZE (8*1024) + +#define VERSION "9P2000.u" +#define UNKNOWN_VER "unknown" + +#define MSG_SIZE 0 +#define MSG_ID 4 +#define MSG_ERR 0x6b +#define MSG_ERR_STR 9 +#define MSG_ERR_STR_LEN 7 +#define MSG_TAG 5 +#define MSG_VER_MSIZE 7 +#define MSG_VER_STR_LEN 11 +#define MSG_VER_STR 13 +#define MSG_WALK_TX_ELMT 15 +#define MSG_WALK_RX_ELMT 7 +#define MSG_SIZE 0 +#define MSG_WALK_MAX_ELMT 16 +#define MSG_QID_SIZE 13 +#define MSG_WALK_RX_HDR_SIZE 9 +#define MSG_OPEN_IOUNIT 20 +#define MSG_OPEN_MODE_MASK 0x5f +#define MSG_READ_COUNT 7 +#define MSG_READ_DATA 11 +#define MSG_STAT_LEN 42 +#define MSG_STAT_TYPE 17 + +#define T_VERSION 100 +#define R_VERSION (T_VERSION + 1) +#define T_ATTACH 104 +#define R_ATTACH (T_ATTACH + 1) +#define T_ERROR 106 +#define R_ERROR (T_ERROR + 1) +#define T_WALK 110 +#define R_WALK (T_WALK + 1) +#define T_OPEN 112 +#define R_OPEN (T_OPEN + 1) +#define T_READ 116 +#define R_READ (T_READ + 1) +#define T_CLUNK 120 +#define R_CLUNK (T_CLUNK + 1) +#define T_STAT 124 +#define R_STAT (T_STAT + 1) + +static p9_transact_t transact; +static void *transact_opaque; +static uint8_t *tx; +static uint8_t *rx; + + +/** + * p9_reg_transport + * + * Registers a transport function for use by the P9 protocol. The transport + * connects the P9 Client (this library) to a server instance. + * + * @param transact_func[in] Function pointer to type p9_transact_t. + * @param tx_buffer[in] TX buffer, must be 8k in size. + * @param rx_buffer[in] RX buffer, must be 8k in size. + */ +void p9_reg_transport(p9_transact_t transact_func, void *opaque, + uint8_t *tx_buffer, uint8_t *rx_buffer) +{ + transact = transact_func; + transact_opaque = opaque; + tx = tx_buffer; + rx = rx_buffer; +} + +/** + * reset_buffers + * + * Reset the RX and TX buffers to BUF_SIZE (8k) and reset the Stack Pointer + * for the TX buffer, which is referenced by the PUT_* macro's. + */ +void reset_buffers(void) +{ + memset(tx, 0, BUF_SIZE); + memset(rx, 0, BUF_SIZE); + sp = tx; +} + +/** + * p9_transaction + * + * Perform a transaction (send/recv) over the registered transport. + * + * @param connection[in|out] Connection object. + * @return 0 = success, -ve = error. + */ +int p9_transaction(p9_connection_t *connection) +{ + int rc; + int tx_size = GET_SIZE; + int rx_size = connection->message_size; + + if (transact == NULL) { + return P9_NO_TRANSPORT; + } + if (tx == NULL || rx == NULL) { + return P9_NO_BUFFER; + } + if (connection->message_size > BUF_SIZE) { + return P9_MSG_SIZE_TOO_BIG; + } + if (tx_size > connection->message_size) { + return P9_MSG_TOO_LONG; + } + + SET_32(tx, MSG_SIZE, tx_size); + rc = transact(transact_opaque, tx, tx_size, rx, &rx_size); + + if (rc != 0) { + return P9_TRANSPORT_ERROR; + } + if (GET_16(tx, MSG_TAG) != GET_16(rx, MSG_TAG)) { + return P9_UNEXPECTED_TAG; + } + if (GET_08(rx, MSG_ID) == MSG_ERR) { + char error_string[200]; + + memset(error_string, 0, 200); + strncpy(error_string, (char *)&rx[MSG_ERR_STR], + MIN(200 - 1, GET_16(rx, MSG_ERR_STR_LEN))); +#ifndef TEST + printf("\nError: %s\n", error_string); +#endif + return P9_R_ERROR; + } + if ((GET_08(tx, MSG_ID) + 1) != GET_08(rx, MSG_ID)) { + return P9_UNEXPECTED_MSG; + } + + return 0; +} + +/** + * p9_version + * + * Called to start a session. Negotiates the maximum message size for the + * P9 protocol. + * + * @param connection[in|out] Connection object, contains message_size. + * @return 0 = success, -ve = error. + * + * @remark + * size[4] Tversion tag[2] msize[4] version[s] + * size[4] Rversion tag[2] msize[4] version[s] + */ +int p9_version(p9_connection_t *connection) +{ + int rc; + char *ver_str; + int ver_len; + + reset_buffers(); + + /* Build message. */ + PUT_HD(T_VERSION, NOTAG); + PUT_32(connection->message_size); + PUT_ST(VERSION); + + /* Send message. */ + rc = p9_transaction(connection); + if (rc != 0) { + return rc; + } + + /* Handle response. */ + connection->message_size = MIN(connection->message_size, + GET_32(rx, MSG_VER_MSIZE)); + + ver_str = (char *)&rx[MSG_VER_STR]; + ver_len = GET_16(rx, MSG_VER_STR_LEN); + if (strncmp(UNKNOWN_VER, ver_str, ver_len) == 0) { + return P9_UNKNOWN_VERSION; + } + + + return 0; +} + +/** + * p9_attach + * + * Called to open a connection for a user to a file tree on the server. There + * is no authorisation undertaken (NOFID). + * + * @param connection[in|out] Connection object, contains uname and aname as + * well as the connection fid and returned qid. + * @return 0 = success, -ve = error. + * + * @remark + * size[4] Tattach tag[2] fid[4] afid[4] uname[s] aname[s] n_uname[4] + * size[4] Rattach tag[2] qid[13] + */ +int p9_attach(p9_connection_t *connection) +{ + int rc; + int length = 19 + strlen(connection->uname) + strlen(connection->aname); + + if (length > connection->message_size) { + return P9_MSG_TOO_LONG; + } + + reset_buffers(); + + /* Build message. */ + PUT_HD(T_ATTACH, TAG); + PUT_32(connection->fid); + PUT_32(NOFID); + PUT_ST(connection->uname); + PUT_ST(connection->aname); + PUT_32(~0); /* ??? */ + + /* Send message. */ + rc = p9_transaction(connection); + if (rc != 0) { + return rc; + } + + + return 0; +} + +/** + * p9_clunk + * + * Called when closing a file or connection (or after failed opens). Tells the + * server that the supplied fid is no longer needed by this client. + * + * @param connection[in|out] Connection object. + * @param fid[in] Fid to be clunked (released) on the server. + * @return 0 = success, -ve = error. + * + * @remark + * size[4] Tclunk tag[2] fid[4] + * size[4] Rclunk tag[2] + */ +int p9_clunk(p9_connection_t *connection, uint32_t fid) +{ + int rc; + + reset_buffers(); + + /* Build message. */ + PUT_HD(T_CLUNK, TAG); + PUT_32(fid); + + /* Send message. */ + rc = p9_transaction(connection); + if (rc != 0) { + return rc; + } + + + return 0; +} + +/** + * p9_walk + * + * Walk the provided path to a file (or directory) starting at the directory + * indicated by fid and assigning new_fid to the last successfully walked + * element. If not all elements of the path can be walked then the pos + * pointer is set to the part of the path following the last successful + * walked element. The function can be called again to walk the remainder + * of the path (or produce an error). + * + * @param connection[in] Connection object. + * @param fid[in] Fid to start walk from, must be directory or root (from + * call to p9_attach). + * @param new_fid[in] Fid to be used for the last walked element. + * @param pos[in|out] Position in path that remains to be walked. If the + * path was completely walked without error this will point to the NULL + * at the end of path. + * @return 1 = partial walk, 0 = success, -ve = error. + * + * @remark + * size[4] Twalk tag[2] fid[4] newfid[4] nwname[2] nwname*(wname[s]) + * size[4] Rwalk tag[2] nwqid[2] nwqid*(qid[13]) + */ +int p9_walk(p9_connection_t *connection, uint32_t fid, uint32_t new_fid, + uint8_t **pos) +{ + int rc; + const char *path = (const char *)*pos; + uint8_t *s_tok; + uint8_t *e_tok; + int element_count = 0; + + if (path == NULL) { + *pos = NULL; + return P9_NULL_PATH; + } + + reset_buffers(); + + /* Build message. */ + PUT_HD(T_WALK, TAG); /* Length to 0, set later. */ + PUT_32(fid); + PUT_32(new_fid); + PUT_16(0); /* Element count to 0, set later. */ + + /* Get elements from path, and append to message. */ + s_tok = (uint8_t *)path; + e_tok = s_tok; + + while (*s_tok != 0) { + while (*s_tok == '/') { + s_tok++; + } + e_tok = s_tok; + while ((*e_tok != '/') && (*e_tok != 0)) { + e_tok++; + } + + /* Check the element is OK. */ + if (strncmp(".", (const char *)s_tok, (e_tok - s_tok)) == 0) { + /* Don't send ".", continue to next. */ + s_tok = e_tok; + continue; + } + int tx_size = (e_tok - s_tok + 2 + GET_SIZE); + int rx_size = ((element_count + 1) * MSG_QID_SIZE + + MSG_WALK_RX_HDR_SIZE); + if ((tx_size > connection->message_size) + || (rx_size > connection->message_size)) { + /* + * Element makes TX msg too long OR expected RX msg + * too long. Move pos to previous element and do + * partial walk. + */ + e_tok = s_tok; + if (*(e_tok - 1) == '/') { + e_tok--; + } + break; + } + + /* Add the element to the message. */ + PUT_SN(s_tok, e_tok - s_tok); + element_count++; + + /* Server supports no more than 16 elements, partial walk. */ + if (element_count == MSG_WALK_MAX_ELMT) { + break; + } + + /* Ready to find the next element. */ + s_tok = e_tok; + } + + if ((element_count == 0) && (strlen(path) > 0)) { + return P9_PATH_ELEMENT_TOO_LONG; + } + + *pos = e_tok; + + /* Update counts and then send message. */ + SET_16(tx, MSG_WALK_TX_ELMT, element_count); + rc = p9_transaction(connection); + if (rc != 0) { + return rc; + } + + /* Check for special return conditions. */ + if (element_count != GET_16(rx, MSG_WALK_RX_ELMT)) { + /* Find the last element successfully walked */ + s_tok = (uint8_t *)path; + e_tok = s_tok; + element_count = GET_16(rx, MSG_WALK_RX_ELMT); + + while (element_count--) { + while (*s_tok == '/') { + s_tok++; + } + + e_tok = s_tok; + + while ((*e_tok != '/') && (*e_tok != 0)) { + e_tok++; + } + + s_tok = e_tok; + } + + *pos = e_tok; + } + if (**pos != 0) { + rc = P9_PARTIAL_WALK; + } + + + return rc; +} + +/** + * p9_open + * + * Opens the file represented by fid with associated mode bit mask. The iounit + * size returned from the server is written to the connection object. + * + * @param file[in|out] File object, contains fid for file. + * @param mode[in] Mode to open with. Bit's 0=R, 1=W, 2=RW, 3=EX, 4=Trunc + * and 6=Delete on Close. + * @return 0 = success, -ve = error. + * + * @remark + * size[4] Topen tag[2] fid[4] mode[1] + * size[4] Ropen tag[2] qid[13] iounit[4] + */ +int p9_open(p9_file_t *file, uint8_t mode) +{ + int rc; + p9_connection_t *connection = file->connection; + + reset_buffers(); + file->iounit = 0; + + /* Build message. */ + PUT_HD(T_OPEN, TAG); + PUT_32(file->fid); + PUT_08(mode & MSG_OPEN_MODE_MASK); + + /* Send message. */ + rc = p9_transaction(connection); + if (rc != 0) { + return rc; + } + + /* Handle response. */ + file->iounit = GET_32(rx, MSG_OPEN_IOUNIT); + + + return 0; +} + +/** + * p9_read + * + * Reads the file in to buffer. + * + * @param file[in] File object, contains fid for file. + * @param buffer[out] Buffer for data. + * @param count[in] Number of bytes to read (less bytes than requested + * may be read). + * @param offset[in] Offset in file to read from. + * @return Bytes read, -ve = error. + * + * @remark + * size[4] Tread tag[2] fid[4] offset[8] count[4] + * size[4] Rread tag[2] count[4] data[count] + */ +int p9_read(p9_file_t *file, uint8_t *buffer, + uint32_t count, uint64_t offset) +{ + int rc; + p9_connection_t *connection = file->connection; + uint32_t got; + + reset_buffers(); + count = MIN((connection->message_size - MSG_READ_DATA), count); + + /* Build message. */ + PUT_HD(T_READ, TAG); + PUT_32(file->fid); + PUT_64(offset); + PUT_32(count); + + /* Send message. */ + rc = p9_transaction(connection); + if (rc != 0) { + return rc; + } + got = GET_32(rx, MSG_READ_COUNT); + if (got > count) { + return P9_READ_UNEXPECTED_DATA; + } + + /* Handle response. */ + memcpy(buffer, &rx[MSG_READ_DATA], got); + + return got; +} + +/** + * p9_stat + * + * Stat's the fid and writes the type and length to the file object. + * + * @param file[in|out] File object, contains fid for file. + * @return 0 = success, -ve = error. + * + * @remark + * size[4] Tstat tag[2] fid[4] + * size[4] Rstat tag[2] size[2] stat[n] + */ +int p9_stat(p9_file_t *file) +{ + int rc; + p9_connection_t *connection = file->connection; + + reset_buffers(); + file->length = 0; + file->type = 0; + + /* Build message. */ + PUT_HD(T_STAT, TAG); + PUT_32(file->fid); + + /* Send message. */ + rc = p9_transaction(connection); + if (rc != 0) { + return rc; + } + + /* Handle response. */ + file->length = GET_64(rx, MSG_STAT_LEN); + file->type = GET_08(rx, MSG_STAT_TYPE); + + + return 0; +} diff --git a/src/roms/SLOF/lib/libvirtio/p9.h b/src/roms/SLOF/lib/libvirtio/p9.h new file mode 100644 index 0000000..7df9ef4 --- /dev/null +++ b/src/roms/SLOF/lib/libvirtio/p9.h @@ -0,0 +1,68 @@ +/****************************************************************************** + * Copyright (c) 2011 IBM Corporation + * All rights reserved. + * This program and the accompanying materials + * are made available under the terms of the BSD License + * which accompanies this distribution, and is available at + * http://www.opensource.org/licenses/bsd-license.php + * + * Contributors: + * IBM Corporation - initial implementation + *****************************************************************************/ + +#ifndef P9_H +#define P9_H + +#include <stdint.h> + + +#define P9_ERROR -1 +#define P9_UNKNOWN_VERSION -2 +#define P9_R_ERROR -3 +#define P9_MSG_TOO_LONG -4 +#define P9_UNEXPECTED_MSG -5 +#define P9_UNEXPECTED_TAG -6 +#define P9_TRANSPORT_ERROR -7 +#define P9_NO_TRANSPORT -8 +#define P9_NULL_PATH -9 +#define P9_PATH_ELEMENT_TOO_LONG -10 +#define P9_READ_UNEXPECTED_DATA -11 +#define P9_NO_BUFFER -12 +#define P9_MSG_SIZE_TOO_BIG -13 + +#define P9_PARTIAL_WALK 1 + +typedef int (*p9_transact_t)(void *opaque, uint8_t *tx, int tx_size, + uint8_t *rx, int *rx_size); + +typedef struct { + uint32_t message_size; + char *uname; /* User name. */ + char *aname; /* Tree/mount name/path. */ + uint32_t fid; /* Represents mount point. */ +} p9_connection_t; + +typedef struct { + uint32_t fid; /* Identifies the file to P9 server. */ + uint32_t iounit; /* Maximum read size in bytes. */ + uint8_t type; /* Type of file. */ + uint64_t length; /* Length of file. */ + p9_connection_t *connection; +} p9_file_t; + + +void reset_buffers(void); +void p9_reg_transport(p9_transact_t transact_func, void *opaque, + uint8_t *tx_buffer, uint8_t *rx_buffer); +int p9_transaction(p9_connection_t *connection); +int p9_version(p9_connection_t *connection); +int p9_attach(p9_connection_t *connection); +int p9_clunk(p9_connection_t *connection, uint32_t fid); +int p9_walk(p9_connection_t *connection, uint32_t fid, uint32_t new_fid, + uint8_t **pos); +int p9_open(p9_file_t *file, uint8_t mode); +int p9_read(p9_file_t *file, uint8_t *buffer, + uint32_t count, uint64_t offset); +int p9_stat(p9_file_t *file); + +#endif diff --git a/src/roms/SLOF/lib/libvirtio/virtio-9p.c b/src/roms/SLOF/lib/libvirtio/virtio-9p.c new file mode 100644 index 0000000..5a5fd01 --- /dev/null +++ b/src/roms/SLOF/lib/libvirtio/virtio-9p.c @@ -0,0 +1,336 @@ +/****************************************************************************** + * Copyright (c) 2011 IBM Corporation + * All rights reserved. + * This program and the accompanying materials + * are made available under the terms of the BSD License + * which accompanies this distribution, and is available at + * http://www.opensource.org/licenses/bsd-license.php + * + * Contributors: + * IBM Corporation - initial implementation + *****************************************************************************/ + +#include <stdio.h> +#include <string.h> +#include <stdint.h> +#include <byteorder.h> +#include <cpu.h> + +#include "virtio-9p.h" +#include "p9.h" + + +/** + * Notes for 9P Server config: + * + * make distclean; cm make qemu + * sudo cp boot_rom.bin /opt/qemu/share/qemu/slof.bin + * /opt/qemu/bin/qemu-system-ppc64 -M pseries -m 512 -boot d -nographic -fsdev + * local,id=trule,path=/home/trule/virtfs,security_model=none -device + * virtio-9p-spapr,fsdev=trule,mount_tag=trule + * load virtfs:\some\file + */ + +/* We support only one instance due to the (ab)use of globals. We + * use the buffer size as an open marker as well. + */ +static int __buf_size; + + +#define ROOT_FID 1 +#define FILE_FID 2 +#define TAG_SIZE 128 +#define MIN(a,b) ((a)>(b)?(b):(a)) + + +#undef DEBUG +//#define DEBUG +#ifdef DEBUG +#define dprintf(_x ...) do { printf(_x); } while(0) +#else +#define dprintf(_x ...) +#endif + +#ifdef DEBUG +static void dprint_buffer(const char *name, uint8_t *buffer, int length) +{ + int i; + + printf("*** %s ***", name); + + for (i = 0; i < length; i++) { + if (i % 16 == 0) { + printf("\n %04x:", i); + } + + printf(" %02x", buffer[i]); + } + + printf("\n"); +} +#else +#define dprint_buffer(n, b, l) +#endif + +/** + * virtio_9p_transact + * + * Perform a 9P transaction over the VIRTIO queue interface. This function is + * registered with the p9.c library via p9_reg_transport() to provide + * connectivity to the 9P server. + * + * @param tx[in] Data to send, mapped to first queue item. + * @param tx_size[in] Size of data to send. + * @param rx[out] Data to receive, mappend to second queue item. + * @param rx_size[out] Size of data received. + * @return 0 = success, -ve = error. + */ +static int virtio_9p_transact(void *opaque, uint8_t *tx, int tx_size, uint8_t *rx, + int *rx_size) +{ + struct virtio_device *dev = opaque; + struct vring_desc *desc; + int id, i; + uint32_t vq_size; + struct vring_desc *vq_desc; + struct vring_avail *vq_avail; + struct vring_used *vq_used; + volatile uint16_t *current_used_idx; + uint16_t last_used_idx; + + + /* Virt IO queues. */ + vq_size = virtio_get_qsize(dev, 0); + vq_desc = virtio_get_vring_desc(dev, 0); + vq_avail = virtio_get_vring_avail(dev, 0); + vq_used = virtio_get_vring_used(dev, 0); + + last_used_idx = vq_used->idx; + current_used_idx = &vq_used->idx; + + /* Determine descriptor index */ + id = (vq_avail->idx * 3) % vq_size; + + /* TX in first queue item. */ + dprint_buffer("TX", tx, tx_size); + + desc = &vq_desc[id]; + desc->addr = (uint64_t)tx; + desc->len = tx_size; + desc->flags = VRING_DESC_F_NEXT; + desc->next = (id + 1) % vq_size; + + /* RX in the second queue item. */ + desc = &vq_desc[(id + 1) % vq_size]; + desc->addr = (uint64_t)rx; + desc->len = *rx_size; + desc->flags = VRING_DESC_F_WRITE; + desc->next = 0; + + /* Tell HV that the queue is ready */ + vq_avail->ring[vq_avail->idx % vq_size] = id; + mb(); + vq_avail->idx += 1; + virtio_queue_notify(dev, 0); + + /* Receive the response. */ + i = 10000000; + while (*current_used_idx == last_used_idx && i-- > 0) { + // do something better + mb(); + } + if (i == 0) { + return -1; + } + + *rx_size = MIN(*rx_size, le32_to_cpu(*(uint32_t*)(&rx[0]))); + dprint_buffer("RX", rx, *rx_size); + + return 0; +} + +/** + * virtio_9p_init + * + * Establish the VIRTIO connection for use with the 9P server. Setup queues + * and negotiate capabilities. Setup the 9P (Client) library. + * + * @param reg[in] Pointer to device tree node for VIRTIO/9P interface. + * @param tx_buf[in] TX buffer for use by 9P Client lib - 8K in size. + * @param rx_buf[in] TX buffer for use by 9P Client lib - 8K in size. + * @param buf_size Somewhat redundant, buffer size expected to be 8k. + * @return 0 = success, -ve = error. + */ +int virtio_9p_init(struct virtio_device *dev, void *tx_buf, void *rx_buf, + int buf_size) +{ + struct vring_avail *vq_avail; + + /* Check for double open */ + if (__buf_size) + return -1; + __buf_size = buf_size; + + dprintf("%s : device at %p\n", __func__, dev->base); + dprintf("%s : type is %04x\n", __func__, dev->type); + + /* Reset device */ + // XXX That will clear the virtq base. We need to move + // initializing it to here anyway + // + // virtio_reset_device(dev); + + /* Acknowledge device. */ + virtio_set_status(dev, VIRTIO_STAT_ACKNOWLEDGE); + + /* Tell HV that we know how to drive the device. */ + virtio_set_status(dev, VIRTIO_STAT_ACKNOWLEDGE | VIRTIO_STAT_DRIVER); + + /* Device specific setup - we do not support special features */ + virtio_set_guest_features(dev, 0); + + vq_avail = virtio_get_vring_avail(dev, 0); + vq_avail->flags = VRING_AVAIL_F_NO_INTERRUPT; + vq_avail->idx = 0; + + /* Tell HV that setup succeeded */ + virtio_set_status(dev, VIRTIO_STAT_ACKNOWLEDGE | VIRTIO_STAT_DRIVER + |VIRTIO_STAT_DRIVER_OK); + + /* Setup 9P library. */ + p9_reg_transport(virtio_9p_transact, dev,(uint8_t *)tx_buf, + (uint8_t *)rx_buf); + + dprintf("%s : complete\n", __func__); + return 0; +} + +/** + * virtio_9p_shutdown + */ +void virtio_9p_shutdown(struct virtio_device *dev) +{ + /* Quiesce device */ + virtio_set_status(dev, VIRTIO_STAT_FAILED); + + /* Reset device */ + virtio_reset_device(dev); + + __buf_size = 0; +} + +/** + * virtio_9p_load + * + * Read a file from the 9P Server on the VIRTIO interface. + * + * @param file_name[in] File to read, use Linux style paths. + * @param buffer[out] Where to read the file to. + * @return +ve = amount of data read, -ve = error. + */ +int virtio_9p_load(struct virtio_device *dev, const char *file_name, uint8_t *buffer) +{ + int rc; + uint16_t tag_len; + char tag_name[TAG_SIZE]; + uint64_t offset = 0; + uint8_t *pos = (uint8_t *)file_name; + int start_fid = ROOT_FID; + p9_connection_t connection = { + .message_size = __buf_size, + .fid = ROOT_FID, + .uname = "slof" + }; + p9_file_t file = { + .connection = &connection, + .fid = FILE_FID, + }; + + + /* Get the share name from 9P config space. */ + tag_len = virtio_get_config(dev, 0, sizeof(tag_len)); + if (tag_len >= TAG_SIZE) + tag_len = TAG_SIZE - 1; + __virtio_read_config(dev, tag_name, 2, tag_len); + connection.aname = tag_name; + + /* Connect to the 9P server. */ + dprintf("%s : connecting, tag = %s, user = %s, msgsize = %d\n", + __func__, connection.aname, connection.uname, + connection.message_size); + rc = p9_version(&connection); + if (rc != 0) { + printf("Version check failed, rc = %d\n", rc); + goto cleanup_connection; + } + rc = p9_attach(&connection); + if (rc != 0) { + printf("Attach failed, rc = %d\n", rc); + goto cleanup_connection; + } + dprintf("%s : connected, msgsize = %d\n", __func__, + connection.message_size); + + /* Walk to the file. */ + do { + dprintf("%s : walk path %s\n", __func__, pos); + rc = p9_walk(&connection, start_fid, FILE_FID, &pos); + + if (rc < 0) { /* Some error. */ + printf("Walk failed, rc = %d\n", rc); + goto cleanup_connection; + } + + /* + * If partial walk (*pos != 0) then continue the walk from + * mid point with start_fid updated to current position + * FILE_FID. FILE_FID will then be reused for the result of + * the next call to walk. + */ + start_fid = FILE_FID; + } while (*pos != 0); + + /* Open the file. */ + dprintf("%s : stat and open\n", __func__); + rc = p9_stat(&file); + if (rc != 0) { + printf("Stat failed, rc = %d\n", rc); + goto cleanup_file; + } + rc = p9_open(&file, 0x00); /* TODO find include for "read mode" */ + if (rc != 0) { + printf("Open failed, rc = %d\n", rc); + goto cleanup_file; + } + dprintf("%s : file opened, size %lld\n", __func__, file.length); + + /* Read the file contents to buffer. */ + while (offset < file.length) { + dprintf("%s : read from offset %llu\n", __func__, offset); + rc = p9_read(&file, buffer + offset, + file.length - offset, offset); + dprintf("%s : read done, length was %d\n", __func__, rc); + if (rc < 0) { + printf("Read failed, rc = %d\n", rc); + goto cleanup_file; + } + if (rc == 0) { + break; + } + offset += rc; + rc = 0; + } + + /* Cleanup and disconnect. */ +cleanup_file: + dprintf("%s : clunking file\n", __func__); + p9_clunk(&connection, file.fid); + +cleanup_connection: + dprintf("%s : clunking connection\n", __func__); + p9_clunk(&connection, connection.fid); + + + dprintf("%s : complete, read %llu bytes\n", __func__, offset); + return rc == 0 ? offset : rc; +} diff --git a/src/roms/SLOF/lib/libvirtio/virtio-9p.h b/src/roms/SLOF/lib/libvirtio/virtio-9p.h new file mode 100644 index 0000000..4bf47d0 --- /dev/null +++ b/src/roms/SLOF/lib/libvirtio/virtio-9p.h @@ -0,0 +1,32 @@ +/****************************************************************************** + * Copyright (c) 2011 IBM Corporation + * All rights reserved. + * This program and the accompanying materials + * are made available under the terms of the BSD License + * which accompanies this distribution, and is available at + * http://www.opensource.org/licenses/bsd-license.php + * + * Contributors: + * IBM Corporation - initial implementation + *****************************************************************************/ + +#ifndef VIRTIO_9P_H_ +#define VIRTIO_9P_H_ + +#include <stdint.h> + +#include "virtio.h" + +#if 0 +typedef struct { + uint16_t tag_lenth; + char tag[0]; +} virtio_9p_config_t; +#endif +int virtio_9p_init(struct virtio_device *dev, void *tx_buf, void *rx_buf, + int buf_size); +void virtio_9p_shutdown(struct virtio_device *dev); +int virtio_9p_load(struct virtio_device *dev, const char *file_name, uint8_t *buffer); + + +#endif /* VIRTIO_9P_H_ */ diff --git a/src/roms/SLOF/lib/libvirtio/virtio-blk.c b/src/roms/SLOF/lib/libvirtio/virtio-blk.c new file mode 100644 index 0000000..826f2ea --- /dev/null +++ b/src/roms/SLOF/lib/libvirtio/virtio-blk.c @@ -0,0 +1,185 @@ +/****************************************************************************** + * Copyright (c) 2011 IBM Corporation + * All rights reserved. + * This program and the accompanying materials + * are made available under the terms of the BSD License + * which accompanies this distribution, and is available at + * http://www.opensource.org/licenses/bsd-license.php + * + * Contributors: + * IBM Corporation - initial implementation + *****************************************************************************/ + +#include <stdio.h> +#include <cpu.h> +#include <helpers.h> +#include "virtio.h" +#include "virtio-blk.h" + +#define DEFAULT_SECTOR_SIZE 512 + +/** + * Initialize virtio-block device. + * @param dev pointer to virtio device information + */ +int +virtioblk_init(struct virtio_device *dev) +{ + struct vring_avail *vq_avail; + int blk_size = DEFAULT_SECTOR_SIZE; + int features; + + /* Reset device */ + // XXX That will clear the virtq base. We need to move + // initializing it to here anyway + // + // virtio_reset_device(dev); + + /* Acknowledge device. */ + virtio_set_status(dev, VIRTIO_STAT_ACKNOWLEDGE); + + /* Tell HV that we know how to drive the device. */ + virtio_set_status(dev, VIRTIO_STAT_ACKNOWLEDGE|VIRTIO_STAT_DRIVER); + + /* Device specific setup - we support F_BLK_SIZE */ + virtio_set_guest_features(dev, VIRTIO_BLK_F_BLK_SIZE); + + vq_avail = virtio_get_vring_avail(dev, 0); + vq_avail->flags = VRING_AVAIL_F_NO_INTERRUPT; + vq_avail->idx = 0; + + /* Tell HV that setup succeeded */ + virtio_set_status(dev, VIRTIO_STAT_ACKNOWLEDGE|VIRTIO_STAT_DRIVER + |VIRTIO_STAT_DRIVER_OK); + + virtio_get_host_features(dev, &features); + if (features & VIRTIO_BLK_F_BLK_SIZE) { + blk_size = virtio_get_config(dev, + offset_of(struct virtio_blk_cfg, blk_size), + sizeof(blk_size)); + } + + return blk_size; +} + + +/** + * Shutdown the virtio-block device. + * @param dev pointer to virtio device information + */ +void +virtioblk_shutdown(struct virtio_device *dev) +{ + /* Quiesce device */ + virtio_set_status(dev, VIRTIO_STAT_FAILED); + + /* Reset device */ + virtio_reset_device(dev); +} + + +/** + * Read blocks + * @param reg pointer to "reg" property + * @param buf pointer to destination buffer + * @param blocknum block number of the first block that should be read + * @param cnt amount of blocks that should be read + * @return number of blocks that have been read successfully + */ +int +virtioblk_read(struct virtio_device *dev, char *buf, long blocknum, long cnt) +{ + struct vring_desc *desc; + int id; + static struct virtio_blk_req blkhdr; + //struct virtio_blk_config *blkconf; + uint64_t capacity; + uint32_t vq_size, time; + struct vring_desc *vq_desc; /* Descriptor vring */ + struct vring_avail *vq_avail; /* "Available" vring */ + struct vring_used *vq_used; /* "Used" vring */ + volatile uint8_t status = -1; + volatile uint16_t *current_used_idx; + uint16_t last_used_idx; + int blk_size = DEFAULT_SECTOR_SIZE; + + //printf("virtioblk_read: dev=%p buf=%p blocknum=%li count=%li\n", + // dev, buf, blocknum, cnt); + + /* Check whether request is within disk capacity */ + capacity = virtio_get_config(dev, + offset_of(struct virtio_blk_cfg, capacity), + sizeof(capacity)); + if (blocknum + cnt - 1 > capacity) { + puts("virtioblk_read: Access beyond end of device!"); + return 0; + } + + blk_size = virtio_get_config(dev, + offset_of(struct virtio_blk_cfg, blk_size), + sizeof(blk_size)); + if (blk_size % DEFAULT_SECTOR_SIZE) { + fprintf(stderr, "virtio-blk: Unaligned sector read %d\n", blk_size); + return 0; + } + + vq_size = virtio_get_qsize(dev, 0); + vq_desc = virtio_get_vring_desc(dev, 0); + vq_avail = virtio_get_vring_avail(dev, 0); + vq_used = virtio_get_vring_used(dev, 0); + + last_used_idx = vq_used->idx; + current_used_idx = &vq_used->idx; + + /* Set up header */ + blkhdr.type = VIRTIO_BLK_T_IN | VIRTIO_BLK_T_BARRIER; + blkhdr.ioprio = 1; + blkhdr.sector = blocknum * blk_size / DEFAULT_SECTOR_SIZE; + + /* Determine descriptor index */ + id = (vq_avail->idx * 3) % vq_size; + + /* Set up virtqueue descriptor for header */ + desc = &vq_desc[id]; + desc->addr = (uint64_t)&blkhdr; + desc->len = sizeof(struct virtio_blk_req); + desc->flags = VRING_DESC_F_NEXT; + desc->next = (id + 1) % vq_size; + + /* Set up virtqueue descriptor for data */ + desc = &vq_desc[(id + 1) % vq_size]; + desc->addr = (uint64_t)buf; + desc->len = cnt * blk_size; + desc->flags = VRING_DESC_F_NEXT | VRING_DESC_F_WRITE; + desc->next = (id + 2) % vq_size; + + /* Set up virtqueue descriptor for status */ + desc = &vq_desc[(id + 2) % vq_size]; + desc->addr = (uint64_t)&status; + desc->len = 1; + desc->flags = VRING_DESC_F_WRITE; + desc->next = 0; + + vq_avail->ring[vq_avail->idx % vq_size] = id; + mb(); + vq_avail->idx += 1; + + /* Tell HV that the queue is ready */ + virtio_queue_notify(dev, 0); + + /* Wait for host to consume the descriptor */ + time = SLOF_GetTimer() + VIRTIO_TIMEOUT; + while (*current_used_idx == last_used_idx) { + // do something better + mb(); + if (time < SLOF_GetTimer()) + break; + } + + if (status == 0) + return cnt; + + printf("virtioblk_read failed! status = %i\n", status); + + return 0; +} diff --git a/src/roms/SLOF/lib/libvirtio/virtio-blk.h b/src/roms/SLOF/lib/libvirtio/virtio-blk.h new file mode 100644 index 0000000..ac8bf28 --- /dev/null +++ b/src/roms/SLOF/lib/libvirtio/virtio-blk.h @@ -0,0 +1,60 @@ +/****************************************************************************** + * Copyright (c) 2011 IBM Corporation + * All rights reserved. + * This program and the accompanying materials + * are made available under the terms of the BSD License + * which accompanies this distribution, and is available at + * http://www.opensource.org/licenses/bsd-license.php + * + * Contributors: + * IBM Corporation - initial implementation + *****************************************************************************/ + +/* + * Virtio block device definitions. + * See Virtio Spec, Appendix D, for details + */ + +#ifndef _VIRTIO_BLK_H +#define _VIRTIO_BLK_H + +#include <stdint.h> + + +struct virtio_blk_cfg { + uint64_t capacity; + uint32_t size_max; + uint32_t seg_max; + struct virtio_blk_geometry { + uint16_t cylinders; + uint8_t heads; + uint8_t sectors; + } geometry; + uint32_t blk_size; + uint32_t sectors_max; +} __attribute__ ((packed)) ; + +/* Block request */ +struct virtio_blk_req { + uint32_t type ; + uint32_t ioprio ; + uint64_t sector ; +}; + +/* Block request types */ +#define VIRTIO_BLK_T_IN 0 +#define VIRTIO_BLK_T_OUT 1 +#define VIRTIO_BLK_T_SCSI_CMD 2 +#define VIRTIO_BLK_T_SCSI_CMD_OUT 3 +#define VIRTIO_BLK_T_FLUSH 4 +#define VIRTIO_BLK_T_FLUSH_OUT 5 +#define VIRTIO_BLK_T_BARRIER 0x80000000 + +/* VIRTIO_BLK Feature bits */ +#define VIRTIO_BLK_F_BLK_SIZE (1 << 6) + +extern int virtioblk_init(struct virtio_device *dev); +extern void virtioblk_shutdown(struct virtio_device *dev); +extern int virtioblk_read(struct virtio_device *dev, char *buf, long blocknum, long cnt); + +#endif /* _VIRTIO_BLK_H */ diff --git a/src/roms/SLOF/lib/libvirtio/virtio-net.c b/src/roms/SLOF/lib/libvirtio/virtio-net.c new file mode 100644 index 0000000..99c19d9 --- /dev/null +++ b/src/roms/SLOF/lib/libvirtio/virtio-net.c @@ -0,0 +1,369 @@ +/****************************************************************************** + * Copyright (c) 2011 IBM Corporation + * All rights reserved. + * This program and the accompanying materials + * are made available under the terms of the BSD License + * which accompanies this distribution, and is available at + * http://www.opensource.org/licenses/bsd-license.php + * + * Contributors: + * IBM Corporation - initial implementation + *****************************************************************************/ + +/* + * This is the implementation for the Virtio network device driver. Details + * about the virtio-net interface can be found in Rusty Russel's "Virtio PCI + * Card Specification v0.8.10", appendix C, which can be found here: + * + * http://ozlabs.org/~rusty/virtio-spec/virtio-spec.pdf + */ + +#include <stdint.h> +#include <stdio.h> +#include <string.h> +#include <helpers.h> +#include <cache.h> +#include <byteorder.h> +#include "virtio.h" +#include "virtio-net.h" + +#undef DEBUG +//#define DEBUG +#ifdef DEBUG +# define dprintf(fmt...) do { printf(fmt); } while(0) +#else +# define dprintf(fmt...) +#endif + +#define sync() asm volatile (" sync \n" ::: "memory") + +/* PCI virtio header offsets */ +#define VIRTIOHDR_DEVICE_FEATURES 0 +#define VIRTIOHDR_GUEST_FEATURES 4 +#define VIRTIOHDR_QUEUE_ADDRESS 8 +#define VIRTIOHDR_QUEUE_SIZE 12 +#define VIRTIOHDR_QUEUE_SELECT 14 +#define VIRTIOHDR_QUEUE_NOTIFY 16 +#define VIRTIOHDR_DEVICE_STATUS 18 +#define VIRTIOHDR_ISR_STATUS 19 +#define VIRTIOHDR_DEVICE_CONFIG 20 +#define VIRTIOHDR_MAC_ADDRESS 20 + +struct virtio_device virtiodev; +struct vqs vq[2]; /* Information about virtqueues */ + +/* See Virtio Spec, appendix C, "Device Operation" */ +struct virtio_net_hdr { + uint8_t flags; + uint8_t gso_type; + uint16_t hdr_len; + uint16_t gso_size; + uint16_t csum_start; + uint16_t csum_offset; + // uint16_t num_buffers; /* Only if VIRTIO_NET_F_MRG_RXBUF */ +}; + +static uint16_t last_rx_idx; /* Last index in RX "used" ring */ + +/** + * Module init for virtio via PCI. + * Checks whether we're reponsible for the given device and set up + * the virtqueue configuration. + */ +static int virtionet_init_pci(struct virtio_device *dev) +{ + int i; + + dprintf("virtionet: doing virtionet_init_pci!\n"); + + if (!dev) + return -1; + + virtiodev.base = dev->base; + virtiodev.type = dev->type; + + /* Reset device */ + virtio_reset_device(&virtiodev); + + /* The queue information can be retrieved via the virtio header that + * can be found in the I/O BAR. First queue is the receive queue, + * second the transmit queue, and the forth is the control queue for + * networking options. + * We are only interested in the receive and transmit queue here. */ + + for (i=VQ_RX; i<=VQ_TX; i++) { + /* Select ring (0=RX, 1=TX): */ + vq[i].id = i-VQ_RX; + ci_write_16(virtiodev.base+VIRTIOHDR_QUEUE_SELECT, + cpu_to_le16(vq[i].id)); + + vq[i].size = le16_to_cpu(ci_read_16(virtiodev.base+VIRTIOHDR_QUEUE_SIZE)); + vq[i].desc = SLOF_alloc_mem_aligned(virtio_vring_size(vq[i].size), 4096); + if (!vq[i].desc) { + printf("memory allocation failed!\n"); + return -1; + } + memset(vq[i].desc, 0, virtio_vring_size(vq[i].size)); + ci_write_32(virtiodev.base+VIRTIOHDR_QUEUE_ADDRESS, + cpu_to_le32((long)vq[i].desc / 4096)); + vq[i].avail = (void*)vq[i].desc + + vq[i].size * sizeof(struct vring_desc); + vq[i].used = (void*)VQ_ALIGN((long)vq[i].avail + + vq[i].size * sizeof(struct vring_avail)); + + dprintf("%i: vq.id = %llx\nvq.size =%x\n vq.avail =%p\nvq.used=%p\n", + i, vq[i].id, vq[i].size, vq[i].avail, vq[i].used); + } + + /* Acknowledge device. */ + virtio_set_status(&virtiodev, VIRTIO_STAT_ACKNOWLEDGE); + + return 0; +} + +/** + * Initialize the virtio-net device. + * See the Virtio Spec, chapter 2.2.1 and Appendix C "Device Initialization" + * for details. + */ +static int virtionet_init(net_driver_t *driver) +{ + int i; + + dprintf("virtionet_init(%02x:%02x:%02x:%02x:%02x:%02x)\n", + driver->mac_addr[0], driver->mac_addr[1], + driver->mac_addr[2], driver->mac_addr[3], + driver->mac_addr[4], driver->mac_addr[5]); + + if (driver->running != 0) + return 0; + + /* Tell HV that we know how to drive the device. */ + virtio_set_status(&virtiodev, VIRTIO_STAT_ACKNOWLEDGE|VIRTIO_STAT_DRIVER); + + /* Device specific setup - we do not support special features right now */ + virtio_set_guest_features(&virtiodev, 0); + + /* Allocate memory for one transmit an multiple receive buffers */ + vq[VQ_RX].buf_mem = SLOF_alloc_mem((BUFFER_ENTRY_SIZE+sizeof(struct virtio_net_hdr)) + * RX_QUEUE_SIZE); + if (!vq[VQ_RX].buf_mem) { + printf("virtionet: Failed to allocate buffers!\n"); + virtio_set_status(&virtiodev, VIRTIO_STAT_FAILED); + return -1; + } + + /* Prepare receive buffer queue */ + for (i = 0; i < RX_QUEUE_SIZE; i++) { + struct vring_desc *desc; + /* Descriptor for net_hdr: */ + desc = &vq[VQ_RX].desc[i*2]; + desc->addr = (uint64_t)vq[VQ_RX].buf_mem + + i * (BUFFER_ENTRY_SIZE+sizeof(struct virtio_net_hdr)); + desc->len = sizeof(struct virtio_net_hdr); + desc->flags = VRING_DESC_F_NEXT | VRING_DESC_F_WRITE; + desc->next = i*2+1; + + /* Descriptor for data: */ + desc = &vq[VQ_RX].desc[i*2+1]; + desc->addr = vq[VQ_RX].desc[i*2].addr + sizeof(struct virtio_net_hdr); + desc->len = BUFFER_ENTRY_SIZE; + desc->flags = VRING_DESC_F_WRITE; + desc->next = 0; + + vq[VQ_RX].avail->ring[i] = i*2; + } + sync(); + vq[VQ_RX].avail->flags = VRING_AVAIL_F_NO_INTERRUPT; + vq[VQ_RX].avail->idx = RX_QUEUE_SIZE; + + last_rx_idx = vq[VQ_RX].used->idx; + + vq[VQ_TX].avail->flags = VRING_AVAIL_F_NO_INTERRUPT; + vq[VQ_TX].avail->idx = 0; + + /* Tell HV that setup succeeded */ + virtio_set_status(&virtiodev, VIRTIO_STAT_ACKNOWLEDGE + |VIRTIO_STAT_DRIVER + |VIRTIO_STAT_DRIVER_OK); + + /* Tell HV that RX queues are ready */ + virtio_queue_notify(&virtiodev, VQ_RX); + + driver->running = 1; + + return 0; +} + + +/** + * Shutdown driver. + * We've got to make sure that the hosts stops all transfers since the buffers + * in our main memory will become invalid after this module has been terminated. + */ +static int virtionet_term(net_driver_t *driver) +{ + dprintf("virtionet_term()\n"); + + if (driver->running == 0) + return 0; + + /* Quiesce device */ + virtio_set_status(&virtiodev, VIRTIO_STAT_FAILED); + + /* Reset device */ + virtio_reset_device(&virtiodev); + + driver->running = 0; + + return 0; +} + + +/** + * Transmit a packet + */ +static int virtionet_xmit(char *buf, int len) +{ + struct vring_desc *desc; + int id; + static struct virtio_net_hdr nethdr; + + if (len > BUFFER_ENTRY_SIZE) { + printf("virtionet: Packet too big!\n"); + return 0; + } + + dprintf("\nvirtionet_xmit(packet at %p, %d bytes)\n", buf, len); + + memset(&nethdr, 0, sizeof(nethdr)); + + /* Determine descriptor index */ + id = (vq[VQ_TX].avail->idx * 2) % vq[VQ_TX].size; + + /* Set up virtqueue descriptor for header */ + desc = &vq[VQ_TX].desc[id]; + desc->addr = (uint64_t)&nethdr; + desc->len = sizeof(struct virtio_net_hdr); + desc->flags = VRING_DESC_F_NEXT; + desc->next = id + 1; + + /* Set up virtqueue descriptor for data */ + desc = &vq[VQ_TX].desc[id+1]; + desc->addr = (uint64_t)buf; + desc->len = len; + desc->flags = 0; + desc->next = 0; + + vq[VQ_TX].avail->ring[vq[VQ_TX].avail->idx % vq[VQ_TX].size] = id; + sync(); + vq[VQ_TX].avail->idx += 1; + sync(); + + /* Tell HV that TX queue is ready */ + virtio_queue_notify(&virtiodev, VQ_TX); + + return len; +} + + +/** + * Receive a packet + */ +static int virtionet_receive(char *buf, int maxlen) +{ + int len = 0; + int id; + + if (last_rx_idx == vq[VQ_RX].used->idx) { + /* Nothing received yet */ + return 0; + } + + id = (vq[VQ_RX].used->ring[last_rx_idx % vq[VQ_RX].size].id + 1) + % vq[VQ_RX].size; + len = vq[VQ_RX].used->ring[last_rx_idx % vq[VQ_RX].size].len + - sizeof(struct virtio_net_hdr); + + dprintf("virtionet_receive() last_rx_idx=%i, vq[VQ_RX].used->idx=%i," + " id=%i len=%i\n", last_rx_idx, vq[VQ_RX].used->idx, id, len); + + if (len > maxlen) { + printf("virtio-net: Receive buffer not big enough!\n"); + len = maxlen; + } + +#if 0 + /* Dump packet */ + printf("\n"); + int i; + for (i=0; i<64; i++) { + printf(" %02x", *(uint8_t*)(vq[VQ_RX].desc[id].addr+i)); + if ((i%16)==15) + printf("\n"); + } + prinfk("\n"); +#endif + + /* Copy data to destination buffer */ + memcpy(buf, (void*)vq[VQ_RX].desc[id].addr, len); + + /* Move indices to next entries */ + last_rx_idx = last_rx_idx + 1; + + vq[VQ_RX].avail->ring[vq[VQ_RX].avail->idx % vq[VQ_RX].size] = id - 1; + sync(); + vq[VQ_RX].avail->idx += 1; + + /* Tell HV that RX queue entry is ready */ + virtio_queue_notify(&virtiodev, VQ_RX); + + return len; +} + +net_driver_t *virtionet_open(char *mac_addr, int len, struct virtio_device *dev) +{ + net_driver_t *driver; + + driver = SLOF_alloc_mem(sizeof(*driver)); + if (!driver) { + printf("Unable to allocate virtio-net driver\n"); + return NULL; + } + + memcpy(driver->mac_addr, mac_addr, 6); + driver->running = 0; + + if (virtionet_init_pci(dev)) + goto FAIL; + + if (virtionet_init(driver)) + goto FAIL; + + return driver; + +FAIL: SLOF_free_mem(driver, sizeof(*driver)); + return NULL; +} + +void virtionet_close(net_driver_t *driver) +{ + if (driver) { + virtionet_term(driver); + SLOF_free_mem(driver, sizeof(*driver)); + } +} + +int virtionet_read(char *buf, int len) +{ + if (buf) + return virtionet_receive(buf, len); + return -1; +} + +int virtionet_write(char *buf, int len) +{ + if (buf) + return virtionet_xmit(buf, len); + return -1; +} diff --git a/src/roms/SLOF/lib/libvirtio/virtio-net.h b/src/roms/SLOF/lib/libvirtio/virtio-net.h new file mode 100644 index 0000000..bc7a189 --- /dev/null +++ b/src/roms/SLOF/lib/libvirtio/virtio-net.h @@ -0,0 +1,43 @@ +/****************************************************************************** + * Copyright (c) 2011 IBM Corporation + * All rights reserved. + * This program and the accompanying materials + * are made available under the terms of the BSD License + * which accompanies this distribution, and is available at + * http://www.opensource.org/licenses/bsd-license.php + * + * Contributors: + * IBM Corporation - initial implementation + *****************************************************************************/ + +#ifndef VIRTIO_NET_H +#define VIRTIO_NET_H + +#include <netdriver.h> + +#define RX_QUEUE_SIZE 128 +#define BUFFER_ENTRY_SIZE 1514 + +enum { + VQ_RX = 0, /* Receive Queue */ + VQ_TX = 1, /* Transmit Queue */ +}; + +struct vqs { + uint64_t id; /* Queue ID */ + uint32_t size; + void *buf_mem; + struct vring_desc *desc; + struct vring_avail *avail; + struct vring_used *used; +}; + +/* Device is identified by RX queue ID: */ +#define DEVICE_ID vq[0].id + +extern net_driver_t *virtionet_open(char *mac_addr, int len, struct virtio_device *dev); +extern void virtionet_close(net_driver_t *driver); +extern int virtionet_read(char *buf, int len); +extern int virtionet_write(char *buf, int len); + +#endif diff --git a/src/roms/SLOF/lib/libvirtio/virtio-scsi.c b/src/roms/SLOF/lib/libvirtio/virtio-scsi.c new file mode 100644 index 0000000..4828928 --- /dev/null +++ b/src/roms/SLOF/lib/libvirtio/virtio-scsi.c @@ -0,0 +1,145 @@ +/****************************************************************************** + * Copyright (c) 2012 IBM Corporation + * All rights reserved. + * This program and the accompanying materials + * are made available under the terms of the BSD License + * which accompanies this distribution, and is available at + * http://www.opensource.org/licenses/bsd-license.php + * + * Contributors: + * IBM Corporation - initial implementation + *****************************************************************************/ + +#include <stdio.h> +#include <string.h> +#include <cpu.h> +#include <helpers.h> +#include "virtio.h" +#include "virtio-scsi.h" + +int virtioscsi_send(struct virtio_device *dev, + struct virtio_scsi_req_cmd *req, + struct virtio_scsi_resp_cmd *resp, + int is_read, void *buf, uint64_t buf_len) +{ + struct vring_desc *desc; + struct vring_desc *vq_desc; /* Descriptor vring */ + struct vring_avail *vq_avail; /* "Available" vring */ + struct vring_used *vq_used; /* "Used" vring */ + + volatile uint16_t *current_used_idx; + uint16_t last_used_idx; + int id; + uint32_t vq_size, time; + + int vq = VIRTIO_SCSI_REQUEST_VQ; + + vq_size = virtio_get_qsize(dev, vq); + vq_desc = virtio_get_vring_desc(dev, vq); + vq_avail = virtio_get_vring_avail(dev, vq); + vq_used = virtio_get_vring_used(dev, vq); + + last_used_idx = vq_used->idx; + current_used_idx = &vq_used->idx; + + /* Determine descriptor index */ + id = (vq_avail->idx * 3) % vq_size; + + desc = &vq_desc[id]; + desc->addr = (uint64_t)req; + desc->len = sizeof(*req); + desc->flags = VRING_DESC_F_NEXT; + desc->next = (id + 1) % vq_size; + + /* Set up virtqueue descriptor for data */ + desc = &vq_desc[(id + 1) % vq_size]; + desc->addr = (uint64_t)resp; + desc->len = sizeof(*resp); + desc->flags = VRING_DESC_F_NEXT | VRING_DESC_F_WRITE; + desc->next = (id + 2) % vq_size; + + if (buf && buf_len) { + /* Set up virtqueue descriptor for status */ + desc = &vq_desc[(id + 2) % vq_size]; + desc->addr = (uint64_t)buf; + desc->len = buf_len; + desc->flags = is_read ? VRING_DESC_F_WRITE : 0; + desc->next = 0; + } else + desc->flags &= ~VRING_DESC_F_NEXT; + + vq_avail->ring[vq_avail->idx % vq_size] = id; + mb(); + vq_avail->idx += 1; + + /* Tell HV that the vq is ready */ + virtio_queue_notify(dev, vq); + + /* Wait for host to consume the descriptor */ + time = SLOF_GetTimer() + VIRTIO_TIMEOUT; + while (*current_used_idx == last_used_idx) { + // do something better + mb(); + if (time < SLOF_GetTimer()) + break; + } + + return 0; +} + +/** + * Initialize virtio-block device. + * @param dev pointer to virtio device information + */ +int virtioscsi_init(struct virtio_device *dev) +{ + struct vring_avail *vq_avail; + unsigned int idx = 0; + int qsize = 0; + + /* Reset device */ + // XXX That will clear the virtq base. We need to move + // initializing it to here anyway + // + // virtio_reset_device(dev); + + /* Acknowledge device. */ + virtio_set_status(dev, VIRTIO_STAT_ACKNOWLEDGE); + + /* Tell HV that we know how to drive the device. */ + virtio_set_status(dev, VIRTIO_STAT_ACKNOWLEDGE|VIRTIO_STAT_DRIVER); + + /* Device specific setup - we do not support special features right now */ + virtio_set_guest_features(dev, 0); + + while(1) { + qsize = virtio_get_qsize(dev, idx); + if (!qsize) + break; + virtio_vring_size(qsize); + + vq_avail = virtio_get_vring_avail(dev, 0); + vq_avail->flags = VRING_AVAIL_F_NO_INTERRUPT; + vq_avail->idx = 0; + idx++; + } + + /* Tell HV that setup succeeded */ + virtio_set_status(dev, VIRTIO_STAT_ACKNOWLEDGE|VIRTIO_STAT_DRIVER + |VIRTIO_STAT_DRIVER_OK); + + return 0; +} + +/** + * Shutdown the virtio-block device. + * @param dev pointer to virtio device information + */ +void virtioscsi_shutdown(struct virtio_device *dev) +{ + /* Quiesce device */ + virtio_set_status(dev, VIRTIO_STAT_FAILED); + + /* Reset device */ + virtio_reset_device(dev); +} diff --git a/src/roms/SLOF/lib/libvirtio/virtio-scsi.h b/src/roms/SLOF/lib/libvirtio/virtio-scsi.h new file mode 100644 index 0000000..451ba4d --- /dev/null +++ b/src/roms/SLOF/lib/libvirtio/virtio-scsi.h @@ -0,0 +1,69 @@ +/****************************************************************************** + * Copyright (c) 2012 IBM Corporation + * All rights reserved. + * This program and the accompanying materials + * are made available under the terms of the BSD License + * which accompanies this distribution, and is available at + * http://www.opensource.org/licenses/bsd-license.php + * + * Contributors: + * IBM Corporation - initial implementation + *****************************************************************************/ + +/* + * Virtio SCSI Host device definitions. + * See Virtio Spec, Appendix I, for details + */ + +#ifndef _VIRTIO_SCSI_H +#define _VIRTIO_SCSI_H + +#define VIRTIO_SCSI_CDB_SIZE 32 +#define VIRTIO_SCSI_SENSE_SIZE 96 + +#define VIRTIO_SCSI_CONTROL_VQ 0 +#define VIRTIO_SCSI_EVENT_VQ 1 +#define VIRTIO_SCSI_REQUEST_VQ 2 + +struct virtio_scsi_config +{ + uint32_t num_queues; + uint32_t seg_max; + uint32_t max_sectors; + uint32_t cmd_per_lun; + uint32_t event_info_size; + uint32_t sense_size; + uint32_t cdb_size; + uint16_t max_channel; + uint16_t max_target; + uint32_t max_lun; +} __attribute__((packed)); + +/* This is the first element of the "out" scatter-gather list. */ +struct virtio_scsi_req_cmd { + uint8_t lun[8]; + uint64_t tag; + uint8_t task_attr; + uint8_t prio; + uint8_t crn; + char cdb[VIRTIO_SCSI_CDB_SIZE]; +}; + +/* This is the first element of the "in" scatter-gather list. */ +struct virtio_scsi_resp_cmd { + uint32_t sense_len; + uint32_t residual; + uint16_t status_qualifier; + uint8_t status; + uint8_t response; + uint8_t sense[VIRTIO_SCSI_SENSE_SIZE]; +}; + +extern int virtioscsi_init(struct virtio_device *dev); +extern void virtioscsi_shutdown(struct virtio_device *dev); +extern int virtioscsi_send(struct virtio_device *dev, + struct virtio_scsi_req_cmd *req, + struct virtio_scsi_resp_cmd *resp, + int is_read, void *buf, uint64_t buf_len); + +#endif /* _VIRTIO_SCSI_H */ diff --git a/src/roms/SLOF/lib/libvirtio/virtio.c b/src/roms/SLOF/lib/libvirtio/virtio.c new file mode 100644 index 0000000..f9c00a6 --- /dev/null +++ b/src/roms/SLOF/lib/libvirtio/virtio.c @@ -0,0 +1,241 @@ +/****************************************************************************** + * Copyright (c) 2011 IBM Corporation + * All rights reserved. + * This program and the accompanying materials + * are made available under the terms of the BSD License + * which accompanies this distribution, and is available at + * http://www.opensource.org/licenses/bsd-license.php + * + * Contributors: + * IBM Corporation - initial implementation + *****************************************************************************/ + +#include <cpu.h> +#include <cache.h> +#include <byteorder.h> +#include "virtio.h" + +/* PCI virtio header offsets */ +#define VIRTIOHDR_DEVICE_FEATURES 0 +#define VIRTIOHDR_GUEST_FEATURES 4 +#define VIRTIOHDR_QUEUE_ADDRESS 8 +#define VIRTIOHDR_QUEUE_SIZE 12 +#define VIRTIOHDR_QUEUE_SELECT 14 +#define VIRTIOHDR_QUEUE_NOTIFY 16 +#define VIRTIOHDR_DEVICE_STATUS 18 +#define VIRTIOHDR_ISR_STATUS 19 +#define VIRTIOHDR_DEVICE_CONFIG 20 + + +/** + * Calculate ring size according to queue size number + */ +unsigned long virtio_vring_size(unsigned int qsize) +{ + return VQ_ALIGN(sizeof(struct vring_desc) * qsize + + sizeof(struct vring_avail) + sizeof(uint16_t) * qsize) + + VQ_ALIGN(sizeof(struct vring_used) + + sizeof(struct vring_used_elem) * qsize); +} + + +/** + * Get number of elements in a vring + * @param dev pointer to virtio device information + * @param queue virtio queue number + * @return number of elements + */ +int virtio_get_qsize(struct virtio_device *dev, int queue) +{ + int size = 0; + + if (dev->type == VIRTIO_TYPE_PCI) { + ci_write_16(dev->base+VIRTIOHDR_QUEUE_SELECT, + cpu_to_le16(queue)); + eieio(); + size = le16_to_cpu(ci_read_16(dev->base+VIRTIOHDR_QUEUE_SIZE)); + } + + return size; +} + + +/** + * Get address of descriptor vring + * @param dev pointer to virtio device information + * @param queue virtio queue number + * @return pointer to the descriptor ring + */ +struct vring_desc *virtio_get_vring_desc(struct virtio_device *dev, int queue) +{ + struct vring_desc *desc = 0; + + if (dev->type == VIRTIO_TYPE_PCI) { + ci_write_16(dev->base+VIRTIOHDR_QUEUE_SELECT, + cpu_to_le16(queue)); + eieio(); + desc = (void*)(4096L * + le32_to_cpu(ci_read_32(dev->base+VIRTIOHDR_QUEUE_ADDRESS))); + } + + return desc; +} + + +/** + * Get address of "available" vring + * @param dev pointer to virtio device information + * @param queue virtio queue number + * @return pointer to the "available" ring + */ +struct vring_avail *virtio_get_vring_avail(struct virtio_device *dev, int queue) +{ + return (void*)((uint64_t)virtio_get_vring_desc(dev, queue) + + virtio_get_qsize(dev, queue) * sizeof(struct vring_desc)); +} + + +/** + * Get address of "used" vring + * @param dev pointer to virtio device information + * @param queue virtio queue number + * @return pointer to the "used" ring + */ +struct vring_used *virtio_get_vring_used(struct virtio_device *dev, int queue) +{ + return (void*)VQ_ALIGN((uint64_t)virtio_get_vring_avail(dev, queue) + + virtio_get_qsize(dev, queue) + * sizeof(struct vring_avail)); +} + + +/** + * Reset virtio device + */ +void virtio_reset_device(struct virtio_device *dev) +{ + if (dev->type == VIRTIO_TYPE_PCI) { + ci_write_8(dev->base+VIRTIOHDR_DEVICE_STATUS, 0); + } +} + + +/** + * Notify hypervisor about queue update + */ +void virtio_queue_notify(struct virtio_device *dev, int queue) +{ + if (dev->type == VIRTIO_TYPE_PCI) { + ci_write_16(dev->base+VIRTIOHDR_QUEUE_NOTIFY, cpu_to_le16(queue)); + } +} + +/** + * Set queue address + */ +void virtio_set_qaddr(struct virtio_device *dev, int queue, unsigned int qaddr) +{ + if (dev->type == VIRTIO_TYPE_PCI) { + uint32_t val = qaddr; + val = val >> 12; + ci_write_16(dev->base+VIRTIOHDR_QUEUE_SELECT, + cpu_to_le16(queue)); + eieio(); + ci_write_32(dev->base+VIRTIOHDR_QUEUE_ADDRESS, + cpu_to_le32(val)); + } +} + +/** + * Set device status bits + */ +void virtio_set_status(struct virtio_device *dev, int status) +{ + if (dev->type == VIRTIO_TYPE_PCI) { + ci_write_8(dev->base+VIRTIOHDR_DEVICE_STATUS, status); + } +} + + +/** + * Set guest feature bits + */ +void virtio_set_guest_features(struct virtio_device *dev, int features) + +{ + if (dev->type == VIRTIO_TYPE_PCI) { + ci_write_32(dev->base+VIRTIOHDR_GUEST_FEATURES, bswap_32(features)); + } +} + +/** + * Get host feature bits + */ +void virtio_get_host_features(struct virtio_device *dev, int *features) + +{ + if (dev->type == VIRTIO_TYPE_PCI && features) { + *features = bswap_32(ci_read_32(dev->base+VIRTIOHDR_DEVICE_FEATURES)); + } +} + + +/** + * Get additional config values + */ +uint64_t virtio_get_config(struct virtio_device *dev, int offset, int size) +{ + uint64_t val = ~0ULL; + void *confbase; + + switch (dev->type) { + case VIRTIO_TYPE_PCI: + confbase = dev->base+VIRTIOHDR_DEVICE_CONFIG; + break; + default: + return ~0ULL; + } + switch (size) { + case 1: + val = ci_read_8(confbase+offset); + break; + case 2: + val = ci_read_16(confbase+offset); + break; + case 4: + val = ci_read_32(confbase+offset); + break; + case 8: + /* We don't support 8 bytes PIO accesses + * in qemu and this is all PIO + */ + val = ci_read_32(confbase+offset); + val <<= 32; + val |= ci_read_32(confbase+offset+4); + break; + } + + return val; +} + +/** + * Get config blob + */ +int __virtio_read_config(struct virtio_device *dev, void *dst, + int offset, int len) +{ + void *confbase; + unsigned char *buf = dst; + int i; + + switch (dev->type) { + case VIRTIO_TYPE_PCI: + confbase = dev->base+VIRTIOHDR_DEVICE_CONFIG; + break; + default: + return 0; + } + for (i = 0; i < len; i++) + buf[i] = ci_read_8(confbase + offset + i); + return len; +} diff --git a/src/roms/SLOF/lib/libvirtio/virtio.code b/src/roms/SLOF/lib/libvirtio/virtio.code new file mode 100644 index 0000000..258b9bb --- /dev/null +++ b/src/roms/SLOF/lib/libvirtio/virtio.code @@ -0,0 +1,164 @@ +/****************************************************************************** + * Copyright (c) 2004, 2011 IBM Corporation + * All rights reserved. + * This program and the accompanying materials + * are made available under the terms of the BSD License + * which accompanies this distribution, and is available at + * http://www.opensource.org/licenses/bsd-license.php + * + * Contributors: + * IBM Corporation - initial implementation + *****************************************************************************/ + +#include <virtio.h> +#include <virtio-blk.h> +#include <virtio-9p.h> +#include <virtio-scsi.h> +#include <virtio-net.h> + +/******** core virtio ********/ + +// : virtio-vring-size ( queuesize -- ringsize ) +PRIM(virtio_X2d_vring_X2d_size) + TOS.u = virtio_vring_size(TOS.u); +MIRP + +// : virtio-get-qsize ( dev queue -- queuesize ) +PRIM(virtio_X2d_get_X2d_qsize) + int queue = TOS.u; POP; + TOS.u = virtio_get_qsize(TOS.a, queue); +MIRP + +// : virtio-get-config ( dev offset size -- val ) +PRIM(virtio_X2d_get_X2d_config) + int size = TOS.u; POP; + int offset = TOS.u; POP; + TOS.u = virtio_get_config(TOS.a, offset, size); +MIRP + +// : virtio-set-qaddr ( dev queue qaddr -- ) +PRIM(virtio_X2d_set_X2d_qaddr) + unsigned int qaddr = TOS.u; POP; + int queue = TOS.u; POP; + void *dev = TOS.a; POP; + virtio_set_qaddr(dev, queue, qaddr); +MIRP + +/******** virtio-blk ********/ + +// : virtio-blk-init ( dev -- blk-size) +PRIM(virtio_X2d_blk_X2d_init) + void *dev = TOS.a; + TOS.u = virtioblk_init(dev); +MIRP + +// : virtio-blk-shutdown ( dev -- ) +PRIM(virtio_X2d_blk_X2d_shutdown) + void *dev = TOS.a; POP; + virtioblk_shutdown(dev); +MIRP + +// : virtio-blk-read ( dev blkno cnt reg -- #read ) +PRIM(virtio_X2d_blk_X2d_read) + void *dev = TOS.a; POP; + long cnt = TOS.n; POP; + long blkno = TOS.n; POP; + void *buf = TOS.a; + TOS.n = virtioblk_read(dev, buf, blkno, cnt); +MIRP + +/******** virtio-fs ********/ + +// : virtio-fs-init ( dev tx rx size -- success ) +PRIM(virtio_X2d_fs_X2d_init) + int size = TOS.n; POP; + void *rx = TOS.a; POP; + void *tx = TOS.a; POP; + void *dev = TOS.a; + + TOS.n = virtio_9p_init(dev, tx, rx, size) == 0 ? -1 : 0; +MIRP + +// : virtio-fs-shutdown ( dev -- ) +PRIM(virtio_X2d_fs_X2d_shutdown) + void *dev = TOS.a; POP; + + virtio_9p_shutdown(dev); +MIRP + +// : virtio-fs-load ( dev buf str -- #read ) +PRIM(virtio_X2d_fs_X2d_load) + char *str = TOS.a; POP; + void *buf = TOS.a; POP; + void *dev = TOS.a; + + TOS.n = virtio_9p_load(dev, str, buf); +MIRP + +/******** virtio-scsi ********/ + +// : virtio-scsi-init ( dev -- success ) +PRIM(virtio_X2d_scsi_X2d_init) + void *dev = TOS.a; + TOS.u = virtioscsi_init(dev); +MIRP + +// : virtio-scsi-shutdown ( dev -- ) +PRIM(virtio_X2d_scsi_X2d_shutdown) + void *dev = TOS.a; POP; + virtioscsi_shutdown(dev); +MIRP + +// : virtio-scsi-send ( buf_addr buf_len is_read req_ptr rsp_ptr dev -- success) +PRIM(virtio_X2d_scsi_X2d_send) + void *dev = TOS.a; POP; + void *resp = TOS.a; POP; + void *req = TOS.a; POP; + int is_read = !!TOS.n; POP; + uint64_t blen = TOS.n; POP; + void *buf = TOS.a; + TOS.n = virtioscsi_send(dev, req, resp, is_read, buf, blen); +MIRP + +/******** virtio-net ********/ + +// : virtio-net-open ( mac-addr-str len dev -- false | [ driver true ] ) +PRIM(virtio_X2d_net_X2d_open) +{ + void *dev = TOS.a; POP; + int len = TOS.u; POP; + char *mac_addr = TOS.a; + + net_driver_t *net_driver = virtionet_open(mac_addr, len, dev); + + if (net_driver) { + TOS.u = (unsigned long)net_driver; PUSH; + TOS.n = -1; + } else + TOS.n = 0; +} +MIRP + +// : virtio-net-close ( driver -- ) +PRIM(virtio_X2d_net_X2d_close) +{ + net_driver_t *driver = TOS.a; POP; + virtionet_close(driver); +} +MIRP + +// : virtio-net-read ( addr len -- actual ) +PRIM(virtio_X2d_net_X2d_read) +{ + int len = TOS.u; POP; + TOS.n = virtionet_read(TOS.a, len); +} +MIRP + +// : virtio-net-write ( addr len -- actual ) +PRIM(virtio_X2d_net_X2d_write) +{ + int len = TOS.u; POP; + TOS.n = virtionet_write(TOS.a, len); +} +MIRP diff --git a/src/roms/SLOF/lib/libvirtio/virtio.h b/src/roms/SLOF/lib/libvirtio/virtio.h new file mode 100644 index 0000000..d5759b4 --- /dev/null +++ b/src/roms/SLOF/lib/libvirtio/virtio.h @@ -0,0 +1,90 @@ +/****************************************************************************** + * Copyright (c) 2011 IBM Corporation + * All rights reserved. + * This program and the accompanying materials + * are made available under the terms of the BSD License + * which accompanies this distribution, and is available at + * http://www.opensource.org/licenses/bsd-license.php + * + * Contributors: + * IBM Corporation - initial implementation + *****************************************************************************/ + +#ifndef _LIBVIRTIO_H +#define _LIBVIRTIO_H + +#include <stdint.h> + +/* Device status bits */ +#define VIRTIO_STAT_ACKNOWLEDGE 1 +#define VIRTIO_STAT_DRIVER 2 +#define VIRTIO_STAT_DRIVER_OK 4 +#define VIRTIO_STAT_FAILED 128 + +#define VIRTIO_TIMEOUT 5000 /* 5 sec timeout */ + +/* Definitions for vring_desc.flags */ +#define VRING_DESC_F_NEXT 1 /* buffer continues via the next field */ +#define VRING_DESC_F_WRITE 2 /* buffer is write-only (otherwise read-only) */ +#define VRING_DESC_F_INDIRECT 4 /* buffer contains a list of buffer descriptors */ + +/* Descriptor table entry - see Virtio Spec chapter 2.3.2 */ +struct vring_desc { + uint64_t addr; /* Address (guest-physical) */ + uint32_t len; /* Length */ + uint16_t flags; /* The flags as indicated above */ + uint16_t next; /* Next field if flags & NEXT */ +}; + +/* Definitions for vring_avail.flags */ +#define VRING_AVAIL_F_NO_INTERRUPT 1 + +/* Available ring - see Virtio Spec chapter 2.3.4 */ +struct vring_avail { + uint16_t flags; + uint16_t idx; + uint16_t ring[]; +}; + + +/* Definitions for vring_used.flags */ +#define VRING_USED_F_NO_NOTIFY 1 + +struct vring_used_elem { + uint32_t id; /* Index of start of used descriptor chain */ + uint32_t len; /* Total length of the descriptor chain which was used */ +}; + +struct vring_used { + uint16_t flags; + uint16_t idx; + struct vring_used_elem ring[]; +}; + +#define VIRTIO_TYPE_PCI 0 /* For virtio-pci interface */ +struct virtio_device { + void *base; /* base address */ + int type; /* VIRTIO_TYPE_PCI or VIRTIO_TYPE_VIO */ +}; + +/* Parts of the virtqueue are aligned on a 4096 byte page boundary */ +#define VQ_ALIGN(addr) (((addr) + 0xfff) & ~0xfff) + +extern unsigned long virtio_vring_size(unsigned int qsize); +extern int virtio_get_qsize(struct virtio_device *dev, int queue); +extern struct vring_desc *virtio_get_vring_desc(struct virtio_device *dev, int queue); +extern struct vring_avail *virtio_get_vring_avail(struct virtio_device *dev, int queue); +extern struct vring_used *virtio_get_vring_used(struct virtio_device *dev, int queue); + +extern void virtio_reset_device(struct virtio_device *dev); +extern void virtio_queue_notify(struct virtio_device *dev, int queue); +extern void virtio_set_status(struct virtio_device *dev, int status); +extern void virtio_set_qaddr(struct virtio_device *dev, int queue, unsigned int qaddr); +extern void virtio_set_guest_features(struct virtio_device *dev, int features); +extern void virtio_get_host_features(struct virtio_device *dev, int *features); +extern uint64_t virtio_get_config(struct virtio_device *dev, int offset, int size); +extern int __virtio_read_config(struct virtio_device *dev, void *dst, + int offset, int len); + + +#endif /* _LIBVIRTIO_H */ diff --git a/src/roms/SLOF/lib/libvirtio/virtio.in b/src/roms/SLOF/lib/libvirtio/virtio.in new file mode 100644 index 0000000..c36d127 --- /dev/null +++ b/src/roms/SLOF/lib/libvirtio/virtio.in @@ -0,0 +1,33 @@ +/****************************************************************************** + * Copyright (c) 2004, 2011 IBM Corporation + * All rights reserved. + * This program and the accompanying materials + * are made available under the terms of the BSD License + * which accompanies this distribution, and is available at + * http://www.opensource.org/licenses/bsd-license.php + * + * Contributors: + * IBM Corporation - initial implementation + *****************************************************************************/ + +cod(virtio-vring-size) +cod(virtio-get-qsize) +cod(virtio-get-config) +cod(virtio-set-qaddr) + +cod(virtio-blk-init) +cod(virtio-blk-shutdown) +cod(virtio-blk-read) + +cod(virtio-scsi-init) +cod(virtio-scsi-shutdown) +cod(virtio-scsi-send) + +cod(virtio-fs-init) +cod(virtio-fs-shutdown) +cod(virtio-fs-load) + +cod(virtio-net-open) +cod(virtio-net-close) +cod(virtio-net-read) +cod(virtio-net-write) |
