/*      $NetBSD: sifbios.c,v 1.11 2014/03/31 11:25:49 martin Exp $      */

/*-
 * Copyright (c) 2001 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by UCHIYAMA Yasushi.
 *
 * 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.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. 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 FOUNDATION 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.
 */

/*
 * PlayStation 2 SIF BIOS Version 2.0 interface.
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: sifbios.c,v 1.11 2014/03/31 11:25:49 martin Exp $");

#include <sys/param.h>
#include <sys/systm.h>

#include <playstation2/playstation2/sifbios.h>
#include <playstation2/playstation2/interrupt.h>

#ifdef DEBUG
#define STATIC
#else
#define STATIC static
#endif

#define SIFBIOS_ENTRY_PTR       MIPS_PHYS_TO_KSEG0(0x00001000)
#define SIFBIOS_SIGNATURE_PTR   MIPS_PHYS_TO_KSEG1(0x00001004)
#define SIFBIOS_SIGNATURE       (('P' << 0)|('S' << 8)|('2' << 16)|('b' << 24))

STATIC int (*__sifbios_call)(int, void *);
#define CALL(t, n, a)   ((t)(*__sifbios_call)((n), (void *)(a)))

STATIC void sifbios_rpc_callback(void *, int);
STATIC int sifbios_rpc_call(int, void *, int *);

void
sifbios_init(void)
{
        /* check BIOS exits */
        if (*(u_int32_t *)SIFBIOS_SIGNATURE_PTR != SIFBIOS_SIGNATURE)
                panic("SIFBIOS not found");
        
        __sifbios_call = *((int (**)(int, void*))SIFBIOS_ENTRY_PTR);
}

int
sifbios_rpc_call(int callno, void *arg, int *result)
{
        volatile int done = 0;
        int retry;
        struct {
                int result;
                void *arg;
                void (*callback)(void *, int);
                volatile void *callback_arg;
        } __attribute__((__packed__, __aligned__(4))) sifbios_arg = {
                arg:            arg,
                callback:       sifbios_rpc_callback,
                callback_arg:   (volatile void *)&done,
        };
        
        /* call SIF BIOS */
        retry = 100;
        while (CALL(int, callno, &sifbios_arg) != 0 && --retry > 0)
                delay(20000);   /* .02 sec. for slow IOP */

        if (retry == 0) {
                printf("SIF BIOS call %d failed\n", callno);
                goto error;
        }

        /* wait IOP response (1 sec.) */
        _sif_call_start();
        retry = 10000;
        while (!done && --retry > 0)
                delay(100);
        _sif_call_end();

        if (retry == 0) {
                printf("IOP not respond (callno = %d)\n", callno);
                goto error;
        }
        
        *result = sifbios_arg.result;

        return (0);

 error:
        return (-1);
}

void
sifbios_rpc_callback(void *arg, int result)
{
        int *done = (int *)arg;
        
        *done = 1;
}

/*
 * System misc.
 */
int
sifbios_getver(void)
{

        return CALL(int, 0, 0);
}

void
sifbios_halt(int mode)
{
        int sifbios_arg = mode;

        CALL(void, 1, &sifbios_arg);
}

void
sifbios_setdve(int mode)
{
        int sifbios_arg = mode;

        CALL(void, 2, &sifbios_arg);
}

void
sifbios_putchar(int c)
{
        int sifbios_arg = c;

        CALL(void, 3, &sifbios_arg);
}

int
sifbios_getchar(void)
{

        return CALL(int, 4, 0);
}

/*
 * SIF DMA
 */
int
sifdma_init(void)
{

        return CALL(int, 16, 0);
}

void
sifdma_exit(void)
{

        CALL(void, 17, 0);
}

/* queue DMA request to SIFBIOS. returns queue identifier. */
sifdma_id_t
sifdma_queue(struct sifdma_transfer *arg, int n)
{
        struct {
                void *arg;      /* pointer to sifdma_transfer array */
                int n;          /* # of elements */
        } __attribute__((__packed__, __aligned__(4))) sifbios_arg = {
                arg:    arg,
                n:      n
        };

        return CALL(sifdma_id_t, 18, &sifbios_arg);
}

/* 
 * status of DMA 
 *      >0 ... queued. not kicked.
 *       0 ... DMA executing.
 *      <0 ... DMA done.
 */
int
sifdma_stat(sifdma_id_t id)
{
        u_int32_t sifbios_arg = id;

        return CALL(int, 19, &sifbios_arg);
}

/* reset DMA channel */
void
sifdma_reset(void)
{

        CALL(void, 20, 0);
}

/*
 * SIF CMD
 */
int
sifcmd_init(void)
{
        
        return CALL(int, 32, 0);
}

void
sifcmd_exit(void)
{

        CALL(void, 33, 0);
}

sifdma_id_t
sifcmd_queue(sifcmd_sw_t sw, vaddr_t cmd_pkt_addr, size_t cmd_pkt_sz,
    vaddr_t src_addr, vaddr_t dst_addr, vsize_t buf_sz)
{
        struct {
                sifcmd_sw_t sw;
                vaddr_t cmd_pkt_addr;   /* command buffer */
                size_t cmd_pkt_sz;
                vaddr_t src_addr;       /* data buffer */
                vaddr_t dst_addr;
                vsize_t buf_sz;
        } __attribute__((__packed__, __aligned__(4))) sifbios_arg = {
                sw:             sw,
                cmd_pkt_addr:   cmd_pkt_addr,
                cmd_pkt_sz:     cmd_pkt_sz,
                src_addr:       src_addr,
                dst_addr:       dst_addr,
                buf_sz:         buf_sz,
        };

        return CALL(sifdma_id_t, 34, &sifbios_arg);
}

/* interrupt handler of DMAC channel 5 (SIF0) */
int
sifcmd_intr(void *arg)
{

        CALL(void, 35, 0);

        return (1);
}

void
sifcmd_establish(sifcmd_sw_t sw, struct sifcmd_callback_holder *holder)
{
        struct {
                sifcmd_sw_t sw;
                sifcmd_callback_t func;
                void *arg;
        } __attribute__((__packed__, __aligned__(4))) sifbios_arg = {
                sw:     sw,
                func:   holder->func,
                arg:    holder->arg,
        };
        
        CALL(void, 36, &sifbios_arg);
}

void
sifcmd_disestablish(sifcmd_sw_t sw)
{
        u_int32_t sifbios_arg = sw;

        CALL(void, 37, &sifbios_arg);
}

struct sifcmd_callback_holder *
sifcmd_handler_init(struct sifcmd_callback_holder *holder, int n)
{
        struct {
                void *holder;
                int n;          /* # of slot */
        } __attribute__((__packed__, __aligned__(4))) sifbios_arg = {
                holder: holder,
                n:      n,
        };

        /* returns old holder */
        return CALL(struct sifcmd_callback_holder *, 38, &sifbios_arg);
}

/*
 * SIF RPC
 */
int
sifrpc_init(void)
{

        return CALL(int, 48, 0);
}

void
sifrpc_exit(void)
{

        CALL(void, 49, 0);
}

int
sifrpc_receive_buffer(struct sifrpc_receive *_cookie, void *src_iop,
    void *dst_ee, size_t sz, u_int32_t rpc_mode, void (*end_func)(void *),
    void *end_arg)
{
        struct {
                void *_cookie;
                void *src_iop;
                void *dst_ee;
                size_t sz;
                u_int32_t rpc_mode;
                sifrpc_endfunc_t end_func;
                void *end_arg;
        } __attribute__((__packed__, __aligned__(4))) sifbios_arg = {
                _cookie:        _cookie,
                src_iop:        src_iop,
                dst_ee:         dst_ee,
                sz:             sz,
                rpc_mode:       rpc_mode,
                end_func:       end_func,
                end_arg:        end_arg,
        };

        return CALL(int, 50, &sifbios_arg);
}

int
sifrpc_bind(struct sifrpc_client *_cookie, sifrpc_id_t rpc_id,
    u_int32_t rpc_mode, void (*end_func)(void *), void *end_arg)
{
        struct {
                void *_cookie;          /* filled by this call */
                sifrpc_id_t rpc_id;     /* specify server RPC id */
                u_int32_t rpc_mode;
                sifrpc_endfunc_t end_func;
                void *end_arg;
        } __attribute__((__packed__, __aligned__(4))) sifbios_arg = {
                _cookie:        _cookie,
                rpc_id:         rpc_id,
                rpc_mode:       rpc_mode,
                end_func:       end_func,
                end_arg:        end_arg,
        };

        return CALL(int, 51, &sifbios_arg);
}

int
sifrpc_call(struct sifrpc_client *_cookie, sifrpc_callno_t call_no,
    u_int32_t rpc_mode, void *sendbuf, size_t sendbuf_sz, void *recvbuf,
    size_t recvbuf_sz, void (*end_func)(void *), void *end_arg)
{
        struct {
                struct sifrpc_client *_cookie;  /* binded client cookie */
                sifrpc_callno_t call_no; /* passed to service function arg. */
                u_int32_t rpc_mode;
                void *sendbuf;
                size_t sendbuf_sz;
                void *recvbuf;
                size_t recvbuf_sz;
                sifrpc_endfunc_t end_func;
                void *end_arg;
        } __attribute__((__packed__, __aligned__(4))) sifbios_arg = {
                _cookie:        _cookie,
                call_no:        call_no,
                rpc_mode:       rpc_mode,
                sendbuf:        sendbuf,
                sendbuf_sz:     sendbuf_sz,
                recvbuf:        recvbuf,
                recvbuf_sz:     recvbuf_sz,
                end_func:       end_func,
                end_arg:        end_arg,
        };

        return CALL(int, 52, &sifbios_arg);
}

int
sifrpc_stat(struct sifrpc_header *_cookie)
{
        void *sifbios_arg = _cookie;

        return CALL(int, 53, &sifbios_arg);
}

void
sifrpc_establish(struct sifrpc_server_system *queue, void (*end_func)(void *),
    void *end_arg)
{
        struct {
                struct sifrpc_server_system *queue;
                sifrpc_endfunc_t end_func;
                void *end_arg;
        } __attribute__((__packed__, __aligned__(4))) sifbios_arg = {
                queue:          queue,
                end_func:       end_func,
                end_arg:        end_arg,
        };

        CALL(void, 54, &sifbios_arg);
}

void
sifrpc_register_service(struct sifrpc_server_system *queue,
    struct sifrpc_server *server, sifrpc_id_t rpc_id,
    void *(*service_func)(sifrpc_callno_t, void *, size_t), void *service_arg,
    void *(*cancel_func)(sifrpc_callno_t, void *, size_t), void *cancel_arg)
{
        struct {
                void *server;
                sifrpc_id_t rpc_id;
                sifrpc_rpcfunc_t service_func;
                void *service_arg;
                sifrpc_rpcfunc_t cancel_func;
                void *cancel_arg;
                void *receive_queue;
        } __attribute__((__packed__, __aligned__(4))) sifbios_arg = {
                server:         server,
                rpc_id:         rpc_id,
                service_func:   service_func,
                service_arg:    service_arg,
                cancel_func:    cancel_func,
                cancel_arg:     cancel_arg,
                receive_queue:  queue,
        };
        
        CALL(void, 55, &sifbios_arg);
}

void
sifrpc_unregister_service(struct sifrpc_server_system *queue,
    struct sifrpc_server *server)
{
        struct {
                void *server;
                void *receive_queue;
        } __attribute__((__packed__, __aligned__(4))) sifbios_arg = {
                server:         server,
                receive_queue:  queue,
        };

        CALL(void, 56, &sifbios_arg);
}

void
sifrpc_disestablish(struct sifrpc_server_system *queue)
{
        void *sifbios_arg = queue;

        CALL(void, 57, &sifbios_arg);
}

struct sifrpc_server *
sifrpc_dequeue(struct sifrpc_server_system *queue)
{
        void *sifbios_arg = queue;

        return CALL(struct sifrpc_server *, 58, &sifbios_arg);
}

void
sifrpc_dispatch_service(struct sifrpc_server *server)
{
        void *sifbios_arg = server;

        CALL(void, 59, &sifbios_arg);
}

/*
 * IOP memory
 */
int
iopmem_init(void)
{
        int result;

        sifbios_rpc_call(64, 0, &result);

        return (0);
}

paddr_t
iopmem_alloc(psize_t sz)
{
        int result, sifbios_arg = sz;

        if (sifbios_rpc_call(65, (void *)&sifbios_arg, &result) < 0)
                return (paddr_t)0;
        /* returns allocated IOP physical addr */
        return (paddr_t)result;
}

int
iopmem_free(paddr_t addr)
{
        int result, sifbios_arg = addr;

        sifbios_rpc_call(66, (void *)&sifbios_arg, &result);

        return (result);
}