sifcmd.c

Go to the documentation of this file.

/*
# _____     ___ ____     ___ ____
#  ____|   |    ____|   |        | |____|
# |     ___|   |____ ___|    ____| |    \    PS2DEV Open Source Project.
#-----------------------------------------------------------------------
# (C)2001, Gustavo Scotti (gustavo@scotti.com)
# (c) 2003 Marcus R. Brown (mrbrown@0xd6.org)
# Licenced under Academic Free License version 2.0
# Review ps2sdk README & LICENSE files for further details.
*/
 
#include <tamtypes.h>
#include <kernel.h>
#include <sifcmd.h>
 
#define CMD_PACKET_MAX      128
#define CMD_PACKET_DATA_MAX 112
#define SYS_CMD_HANDLER_MAX 32
 
/* EE DMAC registers.  */
#define DMAC_COMM_STAT 0x1000e010
#define DMAC_SIF0_CHCR 0x1000c000
#define CHCR_STR       0x100
#define STAT_SIF0      0x20
 
struct cmd_data
{
    void *pktbuf;
    void *unused;
    void *iopbuf;
    SifCmdHandlerData_t *sys_cmd_handlers;
    u32 nr_sys_handlers;
    SifCmdHandlerData_t *usr_cmd_handlers;
    u32 nr_usr_handlers;
    int *sregs;
};
 
extern int _iop_reboot_count;
extern struct cmd_data _sif_cmd_data;
int _SifCmdIntHandler(int channel);
 
#ifdef F_sif_cmd_send
static unsigned int _SifSendCmd(int cid, int mode, void *pkt, int pktsize, void *src,
                                void *dest, int size)
{
    SifDmaTransfer_t dmat[2];
    SifCmdHeader_t *header;
    int count = 0;
 
    pktsize &= 0xff;
 
    if (pktsize > CMD_PACKET_DATA_MAX)
        return 0;
 
    header        = (SifCmdHeader_t *)pkt;
    header->cid   = cid;
    header->psize = pktsize;
    header->dest  = NULL;
 
    if (size > 0) {
        header->dsize = size;
        header->dest  = dest;
 
        if (mode & SIF_CMD_M_WBDC) /* if mode is & 4, flush reference cache */
            SifWriteBackDCache(src, size);
 
        dmat[count].src  = src;
        dmat[count].dest = dest;
        dmat[count].size = size;
        dmat[count].attr = 0;
        count++;
    }
 
    dmat[count].src  = pkt;
    dmat[count].dest = _sif_cmd_data.iopbuf;
    dmat[count].size = pktsize;
    dmat[count].attr = SIF_DMA_ERT | SIF_DMA_INT_O;
    count++;
 
    SifWriteBackDCache(pkt, pktsize);
 
    if (mode & SIF_CMD_M_INTR) /* INTERRUPT DMA TRANSFER */
        return iSifSetDma(dmat, count);
    else
        return SifSetDma(dmat, count);
}
 
unsigned int
SifSendCmd(int command, void *send_data, int send_len,
           void *extra_from, void *extra_dest, int extra_len)
{
    return _SifSendCmd(command, 0, send_data, send_len,
                       extra_from, extra_dest, extra_len);
}
 
unsigned int
iSifSendCmd(int command, void *send_data, int send_len,
            void *extra_from, void *extra_dest, int extra_len)
{
    return _SifSendCmd(command, SIF_CMD_M_INTR, send_data, send_len,
                       extra_from, extra_dest, extra_len);
}
#endif
 
#ifdef F__sif_cmd_int_handler
int _SifCmdIntHandler(int channel)
{
    u128 packet[8];
    u128 *pktbuf;
    struct cmd_data *cmd_data = &_sif_cmd_data;
    SifCmdHeader_t *header;
    SifCmdHandlerData_t *cmd_handlers;
    int size, pktquads, id, i = 0;
 
    (void)channel;
 
    EI();
 
    header = (SifCmdHeader_t *)cmd_data->pktbuf;
 
    if (!(size = header->psize))
        goto out;
 
    pktquads      = (size + 30) >> 4;
    header->psize = 0;
    if (pktquads) {
        pktbuf = (u128 *)cmd_data->pktbuf;
        while (pktquads--) {
            packet[i] = pktbuf[i];
            i++;
        }
    }
 
    iSifSetDChain();
 
    header = (SifCmdHeader_t *)packet;
    /* Get the command handler id and determine which handler list to
       dispatch from.  */
    id = header->cid & ~SIF_CMD_ID_SYSTEM;
 
    if (header->cid & SIF_CMD_ID_SYSTEM) {
        if ((u32)id < cmd_data->nr_sys_handlers)
            cmd_handlers = cmd_data->sys_cmd_handlers;
        else
            goto out;
    } else {
        if ((u32)id < cmd_data->nr_usr_handlers)
            cmd_handlers = cmd_data->usr_cmd_handlers;
        else
            goto out;
    }
 
    if (cmd_handlers[id].handler)
        cmd_handlers[id].handler(packet, cmd_handlers[id].harg);
 
out:
    ExitHandler();
    return 0;
}
#endif
 
#ifdef F_sif_cmd_main
static u8 pktbuf[CMD_PACKET_MAX] __attribute__((aligned(64)));
/* Define this so that in the unlikely case another SIF implementation decides
   to use it, it won't crash.  Otherwise unused.  */
static u8 sif_unused[64] __attribute__((aligned(64)));
 
static SifCmdHandlerData_t sys_cmd_handlers[SYS_CMD_HANDLER_MAX];
static int sregs[32];
 
struct cmd_data _sif_cmd_data;
static int init    = 0;
static int sif0_id = -1;
 
struct ca_pkt
{
    SifCmdHeader_t header;
    void *buf;
};
 
static void change_addr(void *packet, void *harg)
{
    struct cmd_data *cmd_data = (struct cmd_data *)harg;
    struct ca_pkt *pkt        = (struct ca_pkt *)packet;
 
    cmd_data->iopbuf = pkt->buf;
}
 
struct sr_pkt
{
    SifCmdHeader_t header;
    u32 sreg;
    int val;
};
 
static void set_sreg(void *packet, void *harg)
{
    struct cmd_data *cmd_data = (struct cmd_data *)harg;
    struct sr_pkt *pkt        = (struct sr_pkt *)packet;
 
    cmd_data->sregs[pkt->sreg] = pkt->val;
}
 
void SifInitCmd(void)
{
    static struct ca_pkt packet __attribute((aligned(64)));
    int i;
    static int _rb_count = 0;
    if (_rb_count != _iop_reboot_count) {
        _rb_count = _iop_reboot_count;
        if (sif0_id >= 0) {
            DisableDmac(DMAC_SIF0);
            RemoveDmacHandler(DMAC_SIF0, sif0_id);
        }
        init = 0;
    }
 
    if (init)
        return;
 
    DI();
 
    _sif_cmd_data.pktbuf           = UNCACHED_SEG(pktbuf);
    _sif_cmd_data.unused           = UNCACHED_SEG(sif_unused);
    _sif_cmd_data.sys_cmd_handlers = sys_cmd_handlers;
    _sif_cmd_data.nr_sys_handlers  = SYS_CMD_HANDLER_MAX;
    _sif_cmd_data.usr_cmd_handlers = NULL;
    _sif_cmd_data.nr_usr_handlers  = 0;
    _sif_cmd_data.sregs            = sregs;
 
    for (i = 0; i < SYS_CMD_HANDLER_MAX; i++) {
        _sif_cmd_data.sys_cmd_handlers[i].handler = NULL;
        _sif_cmd_data.sys_cmd_handlers[i].harg    = NULL;
    }
 
    for (i = 0; i < 32; i++)
        _sif_cmd_data.sregs[i] = 0;
 
    _sif_cmd_data.sys_cmd_handlers[0].handler = change_addr;
    _sif_cmd_data.sys_cmd_handlers[0].harg    = &_sif_cmd_data;
    _sif_cmd_data.sys_cmd_handlers[1].handler = set_sreg;
    _sif_cmd_data.sys_cmd_handlers[1].harg    = &_sif_cmd_data;
 
    EI();
    FlushCache(0);
 
    if (_lw(DMAC_COMM_STAT) & STAT_SIF0)
        _sw(STAT_SIF0, DMAC_COMM_STAT);
 
    // If SIF0 (IOP -> EE) is not enabled, enable it.
    if (!(_lw(DMAC_SIF0_CHCR) & CHCR_STR))
        SifSetDChain();
 
    sif0_id = AddDmacHandler(DMAC_SIF0, &_SifCmdIntHandler, 0);
    EnableDmac(DMAC_SIF0);
 
    init = 1;
 
    _sif_cmd_data.iopbuf = (void *)SifGetReg(SIF_SYSREG_SUBADDR);
    if (_sif_cmd_data.iopbuf) {
        /* IOP SIF CMD is already initialized, so give it our new
           receive address.  */
        packet.buf = _sif_cmd_data.pktbuf;
        SifSendCmd(SIF_CMD_CHANGE_SADDR, &packet, sizeof packet, NULL, NULL, 0);
    } else {
        /* Sync with the IOP side's SIFCMD implementation. */
        while (!(SifGetReg(SIF_REG_SMFLAG) & SIF_STAT_CMDINIT))
            ;
 
        _sif_cmd_data.iopbuf = (void *)SifGetReg(SIF_REG_SUBADDR);
        SifSetReg(SIF_SYSREG_SUBADDR, (u32)_sif_cmd_data.iopbuf);
        /* See the note above about struct cmd_data, and the use of
           this register.  */
        SifSetReg(SIF_SYSREG_MAINADDR, (u32)&_sif_cmd_data);
        packet.header.opt = 0; // SIFCMD initialization on the IOP (opt = 0)
        packet.buf        = _sif_cmd_data.pktbuf;
        SifSendCmd(SIF_CMD_INIT_CMD, &packet, sizeof packet, NULL, NULL, 0);
    }
}
 
void SifExitCmd(void)
{
    DisableDmac(DMAC_SIF0);
    RemoveDmacHandler(DMAC_SIF0, sif0_id);
    init = 0;
}
#endif
 
#ifdef F_sif_cmd_client
SifCmdHandlerData_t *SifSetCmdBuffer(SifCmdHandlerData_t *db, int size)
{
    SifCmdHandlerData_t *old;
 
    old                            = _sif_cmd_data.usr_cmd_handlers;
    _sif_cmd_data.usr_cmd_handlers = db;
    _sif_cmd_data.nr_usr_handlers  = size;
 
    return old;
}
 
void SifAddCmdHandler(int pos, SifCmdHandler_t handler, void *harg)
{
    SifCmdHandlerData_t *cmd_handlers;
    u32 id = pos & ~SIF_CMD_ID_SYSTEM;
 
    cmd_handlers = (pos & SIF_CMD_ID_SYSTEM) ? _sif_cmd_data.sys_cmd_handlers : _sif_cmd_data.usr_cmd_handlers;
 
    cmd_handlers[id].handler = handler;
    cmd_handlers[id].harg    = harg;
}
#endif
 
#ifdef F_sif_cmd_remove_cmdhandler
void SifRemoveCmdHandler(int pos)
{
    u32 id = pos & ~SIF_CMD_ID_SYSTEM;
 
    if (pos & SIF_CMD_ID_SYSTEM)
        _sif_cmd_data.sys_cmd_handlers[id].handler = NULL;
    else
        _sif_cmd_data.usr_cmd_handlers[id].handler = NULL;
}
#endif
 
#ifdef F_sif_sreg_get
int SifGetSreg(int sreg)
{
    return _sif_cmd_data.sregs[sreg];
}
#endif