/*      $NetBSD: empb_bsm.c,v 1.5 2012/06/27 18:53:03 rkujawa Exp $ */

/*-
* Copyright (c) 2012 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Radoslaw Kujawa.
*
* 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.
*/

/*
* Special bus space methods handling PCI memory window. Used only by empb.
*
* XXX: Handle ops on window boundary! Currently these are broken!
*/

#include <sys/bus.h>
#include <sys/null.h>
#include <sys/param.h>
#include <sys/device.h>
#include <sys/systm.h>
#include <sys/types.h>

#include <amiga/pci/empbreg.h>
#include <amiga/pci/empbvar.h>
#include <amiga/pci/emmemvar.h>

static bool empb_bsm_init(void);

/*
* The bus_space functions are prototyped below. Due to macro-ridden
* maddness of amiga port bus_space implementation, these prototypes look
* somewhat different than what you can read in bus_space(9) man page.
*/

static int      empb_bsm(bus_space_tag_t space, bus_addr_t address,
                   bus_size_t size, int flags, bus_space_handle_t *handlep);
static int      empb_bsms(bus_space_handle_t handle, bus_size_t offset,
                   bus_size_t size, bus_space_handle_t *nhandlep);
static void     empb_bsu(bus_space_handle_t handle,
                   bus_size_t size);

static bsr(empb_bsr1, u_int8_t);
static bsw(empb_bsw1, u_int8_t);
static bsrm(empb_bsrm1, u_int8_t);
static bswm(empb_bswm1, u_int8_t);
static bsrm(empb_bsrr1, u_int8_t);
static bswm(empb_bswr1, u_int8_t);
static bssr(empb_bssr1, u_int8_t);
static bscr(empb_bscr1, u_int8_t);

static bsr(empb_bsr2_swap, u_int16_t);
static bsw(empb_bsw2_swap, u_int16_t);
static bsr(empb_bsr2, u_int16_t);
static bsw(empb_bsw2, u_int16_t);
static bsrm(empb_bsrm2_swap, u_int16_t);
static bswm(empb_bswm2_swap, u_int16_t);
static bsrm(empb_bsrm2, u_int16_t);
static bswm(empb_bswm2, u_int16_t);
static bsrm(empb_bsrr2_swap, u_int16_t);
static bswm(empb_bswr2_swap, u_int16_t);
static bsrm(empb_bsrr2, u_int16_t);
static bswm(empb_bswr2, u_int16_t);
static bssr(empb_bssr2_swap, u_int16_t);
static bscr(empb_bscr2, u_int16_t);

static bsr(empb_bsr4_swap, u_int32_t);
static bsw(empb_bsw4_swap, u_int32_t);
static bsr(empb_bsr4, u_int32_t);
static bsw(empb_bsw4, u_int32_t);
static bsrm(empb_bsrm4_swap, u_int32_t);
static bswm(empb_bswm4_swap, u_int32_t);
static bsrm(empb_bsrm4, u_int32_t);
static bswm(empb_bswm4, u_int32_t);
static bsrm(empb_bsrr4_swap, u_int32_t);
static bswm(empb_bswr4_swap, u_int32_t);
static bsrm(empb_bsrr4, u_int32_t);
static bswm(empb_bswr4, u_int32_t);
static bssr(empb_bssr4_swap, u_int32_t);
static bscr(empb_bscr4, u_int32_t);
/*
* Hold pointer to bridge driver here. We need to access it to switch
* window position. Perhaps it should be stored in bus_space_tag instead...
*/
static struct empb_softc *empb_sc = NULL;

static bool
empb_bsm_init(void)
{
       device_t dev;

       /* We can't have more than one Mediator anyway. */
       if (!(dev = device_find_by_xname("empb0"))) {
               aprint_error("empb: can't find bridge device\n");
               return false;
       }

       if (!(empb_sc = device_private(dev))) {
               aprint_error_dev(dev, "can't obtain bridge softc\n");
               return false;
       }

       if (empb_sc->pci_mem_win_size == 0) {
               aprint_error_dev(dev, "no PCI memory window found\n");
               return false;
       }

       return true;
}

/* === common bus space methods === */

static int
empb_bsm(bus_space_tag_t space, bus_addr_t address, bus_size_t size,
   int flags, bus_space_handle_t *handlep)
{

       /* Check for bridge driver softc. */
       if (empb_sc==NULL)
               if(empb_bsm_init() == false)
                       return -1;

       /* Fail miserably if the driver wants linear space. */
       if ( (flags & BUS_SPACE_MAP_LINEAR) && (size > 8*1024*1024))
               aprint_error("empb: linear space mapping might not work\n");

       /*
        * Just store the desired PCI bus address as handlep. Don't make things
        * more complicated than they need to be.
        */
       *handlep = address;

       return 0;
}

static int
empb_bsms(bus_space_handle_t handle,
   bus_size_t offset, bus_size_t size, bus_space_handle_t *nhandlep)
{
       *nhandlep = handle + offset;
       return 0;
}

static void
empb_bsu(bus_space_handle_t handle, bus_size_t size)
{
       return;
}

/* === 8-bit methods === */

static uint8_t
empb_bsr1(bus_space_handle_t handle, bus_size_t offset)
{
       uint8_t *p;
       uint8_t x;
       bus_addr_t wp; /* window position */

       wp = empb_switch_window(empb_sc, handle);

       /* window address + (PCI mem address - window position) */
       p = (uint8_t*)((empb_sc->pci_mem_win_t->base) + (handle - wp) + offset);
       x = *p;

       return x;
}

static void
empb_bsw1(bus_space_handle_t handle, bus_size_t offset, unsigned value)
{
       uint8_t *p;
       bus_addr_t wp;

       wp = empb_switch_window(empb_sc, handle);
       p = (uint8_t*)((empb_sc->pci_mem_win_t->base) + (handle - wp) + offset);
       *p = value;
}

static void
empb_bsrm1(bus_space_handle_t handle, bus_size_t offset, u_int8_t *pointer,
   bus_size_t count)
{
       volatile uint8_t *p;
       bus_addr_t wp;

       wp = empb_switch_window(empb_sc, handle);
       p = (volatile u_int8_t *) ((empb_sc->pci_mem_win_t->base) +
           (handle - wp) + offset);

       while (count > 0) {
               *pointer++ = *p;
               amiga_bus_reorder_protect();
               --count;
       }
}

static void
empb_bswm1(bus_space_handle_t handle, bus_size_t offset,
   const u_int8_t *pointer, bus_size_t count)
{
       volatile uint8_t *p;
       bus_addr_t wp;

       wp = empb_switch_window(empb_sc, handle);
       p = (volatile u_int8_t *) ((empb_sc->pci_mem_win_t->base) +
           (handle - wp) + offset);

       while (count > 0) {
               *p = *pointer++;
               amiga_bus_reorder_protect();
               --count;
       }
}

static void
empb_bsrr1(bus_space_handle_t handle, bus_size_t offset, u_int8_t *pointer,
   bus_size_t count)
{
       volatile uint8_t *p;
       bus_addr_t wp;

       wp = empb_switch_window(empb_sc, handle);
       p = (volatile u_int8_t *) ((empb_sc->pci_mem_win_t->base) +
           (handle - wp) + offset);

       while (count > 0) {
               *pointer++ = *p;
               amiga_bus_reorder_protect();
               p++;
               --count;
       }
}

static void
empb_bswr1(bus_space_handle_t handle, bus_size_t offset,
   const u_int8_t *pointer, bus_size_t count)
{
       volatile uint8_t *p;
       bus_addr_t wp;

       wp = empb_switch_window(empb_sc, handle);
       p = (volatile u_int8_t *) ((empb_sc->pci_mem_win_t->base) +
           (handle - wp) + offset);

       while (count > 0) {
               *p = *pointer++;
               amiga_bus_reorder_protect();
               p++;
               --count;
       }
}

static void
empb_bssr1(bus_space_handle_t handle, bus_size_t offset, unsigned value,
   bus_size_t count)
{
       volatile uint8_t *p;
       bus_addr_t wp;

       wp = empb_switch_window(empb_sc, handle);
       p = (volatile u_int8_t *) ((empb_sc->pci_mem_win_t->base) +
           (handle - wp) + offset);

       while (count > 0) {
               *p = value;
               amiga_bus_reorder_protect();
               p++;
               --count;
       }
}

/* XXX: this is broken, rewrite */
static void
empb_bscr1(bus_space_handle_t handlefrom, bus_size_t from,
   bus_space_handle_t handleto, bus_size_t to, bus_size_t count)
{
       volatile uint8_t *p, *q;
       bus_addr_t wp;

       wp = empb_switch_window(empb_sc, handlefrom);

       p = (volatile u_int8_t *)
           ( ((empb_sc->pci_mem_win_t->base)+(handlefrom - wp)) + from );
       q = (volatile u_int8_t *)
           ( ((empb_sc->pci_mem_win_t->base)+(handleto - wp)) + to );

       while (count > 0) {
               *q = *p;
               amiga_bus_reorder_protect();
               p ++; q++;
               --count;
       }
}

/* === 16-bit methods === */

static uint16_t
empb_bsr2(bus_space_handle_t handle, bus_size_t offset)
{
       uint16_t *p;
       uint16_t x;
       bus_addr_t wp;

       wp = empb_switch_window(empb_sc, handle);

       p = (uint16_t*) ((empb_sc->pci_mem_win_t->base) + (handle - wp)
           + offset);
       x = *p;

       return x;
}

static uint16_t
empb_bsr2_swap(bus_space_handle_t handle, bus_size_t offset)
{
       uint16_t *p;
       uint16_t x;
       bus_addr_t wp;

       wp = empb_switch_window(empb_sc, handle);

       p = (uint16_t*) ((empb_sc->pci_mem_win_t->base) + (handle - wp)
           + offset);
       x = *p;

       return bswap16(x);
}


static void
empb_bsw2(bus_space_handle_t handle, bus_size_t offset, unsigned value)
{
       uint16_t *p;
       bus_addr_t wp;

       wp = empb_switch_window(empb_sc, handle);
       p = (uint16_t*)((empb_sc->pci_mem_win_t->base) + (handle - wp)
            + offset);
       *p = value;
}

static void
empb_bsw2_swap(bus_space_handle_t handle, bus_size_t offset, unsigned value)
{
       uint16_t *p;
       bus_addr_t wp;

       wp = empb_switch_window(empb_sc, handle);
       p = (uint16_t*)((empb_sc->pci_mem_win_t->base) + (handle - wp)
           + offset);
       *p = bswap16(value);
}

static void
empb_bsrm2(bus_space_handle_t handle, bus_size_t offset, u_int16_t *pointer,
   bus_size_t count)
{
       volatile uint16_t *p;
       bus_addr_t wp;

       wp = empb_switch_window(empb_sc, handle);
       p = (volatile uint16_t *) ((empb_sc->pci_mem_win_t->base) +
           (handle - wp) + offset);

       while (count > 0) {
               *pointer++ = *p;
               amiga_bus_reorder_protect();
               --count;
       }
}

static void
empb_bsrm2_swap(bus_space_handle_t handle, bus_size_t offset,
   u_int16_t *pointer, bus_size_t count)
{
       volatile uint16_t *p;
       bus_addr_t wp;

       wp = empb_switch_window(empb_sc, handle);
       p = (volatile uint16_t *) ((empb_sc->pci_mem_win_t->base) +
           (handle - wp) + offset);

       while (count > 0) {
               *pointer++ = bswap16(*p);
               amiga_bus_reorder_protect();
               --count;
       }
}

static void
empb_bswm2(bus_space_handle_t handle, bus_size_t offset,
   const u_int16_t *pointer, bus_size_t count)
{
       volatile uint16_t *p;
       bus_addr_t wp;

       wp = empb_switch_window(empb_sc, handle);
       p = (volatile uint16_t *) ((empb_sc->pci_mem_win_t->base) +
           (handle - wp) + offset);

       while (count > 0) {
               *p = *pointer++;
               amiga_bus_reorder_protect();
               --count;
       }
}

static void
empb_bswm2_swap(bus_space_handle_t handle, bus_size_t offset,
   const u_int16_t *pointer, bus_size_t count)
{
       volatile uint16_t *p;
       bus_addr_t wp;

       wp = empb_switch_window(empb_sc, handle);
       p = (volatile uint16_t *) ((empb_sc->pci_mem_win_t->base) +
           (handle - wp) + offset);

       while (count > 0) {
               *p = bswap16(*pointer++);
               amiga_bus_reorder_protect();
               --count;
       }
}

static void
empb_bsrr2(bus_space_handle_t handle, bus_size_t offset, u_int16_t *pointer,
   bus_size_t count)
{
       volatile uint16_t *p;
       bus_addr_t wp;

       wp = empb_switch_window(empb_sc, handle);
       p = (volatile uint16_t *) ((empb_sc->pci_mem_win_t->base) +
           (handle - wp) + offset);

       while (count > 0) {
               *pointer++ = *p;
               amiga_bus_reorder_protect();
               p++;
               --count;
       }
}

static void
empb_bsrr2_swap(bus_space_handle_t handle, bus_size_t offset,
   u_int16_t *pointer, bus_size_t count)
{
       volatile uint16_t *p;
       bus_addr_t wp;

       wp = empb_switch_window(empb_sc, handle);
       p = (volatile uint16_t *) ((empb_sc->pci_mem_win_t->base) +
           (handle - wp) + offset);

       while (count > 0) {
               *pointer++ = bswap16(*p);
               amiga_bus_reorder_protect();
               p++;
               --count;
       }
}

static void
empb_bssr2_swap(bus_space_handle_t handle, bus_size_t offset, unsigned value,
   bus_size_t count)
{
       volatile uint16_t *p;
       bus_addr_t wp;

       wp = empb_switch_window(empb_sc, handle);
       p = (volatile uint16_t *) ((empb_sc->pci_mem_win_t->base) +
           (handle - wp) + offset);

       while (count > 0) {
               *p = bswap16(value);
               amiga_bus_reorder_protect();
               p++;
               --count;
       }
}

static void
empb_bswr2(bus_space_handle_t handle, bus_size_t offset,
   const u_int16_t *pointer, bus_size_t count)
{
       volatile uint16_t *p;
       bus_addr_t wp;

       wp = empb_switch_window(empb_sc, handle);
       p = (volatile u_int16_t *) ((empb_sc->pci_mem_win_t->base) +
           (handle - wp) + offset);

       while (count > 0) {
               *p = *pointer++;
               amiga_bus_reorder_protect();
               p++;
               --count;
       }
}

static void
empb_bswr2_swap(bus_space_handle_t handle, bus_size_t offset,
   const u_int16_t *pointer, bus_size_t count)
{
       volatile uint16_t *p;
       bus_addr_t wp;

       wp = empb_switch_window(empb_sc, handle);
       p = (volatile u_int16_t *) ((empb_sc->pci_mem_win_t->base)
           + (handle - wp) + offset);

       while (count > 0) {
               *p = bswap16(*pointer++);
               amiga_bus_reorder_protect();
               p++;
               --count;
       }
}

/* XXX: this is broken, rewrite, XXX 2: should we swap here? */
static void
empb_bscr2(bus_space_handle_t handlefrom, bus_size_t from,
   bus_space_handle_t handleto, bus_size_t to, bus_size_t count)
{
       volatile uint16_t *p, *q;
       bus_addr_t wp;

       wp = empb_switch_window(empb_sc, handlefrom);

       p = (volatile uint16_t *)
           ( ((empb_sc->pci_mem_win_t->base)+(handlefrom - wp)) + from );
       q = (volatile uint16_t *)
           ( ((empb_sc->pci_mem_win_t->base)+(handleto - wp)) + to );

       while (count > 0) {
               *q = *p;
               amiga_bus_reorder_protect();
               p++; q++;
               --count;
       }
}

/* === 32-bit methods === */

static uint32_t
empb_bsr4(bus_space_handle_t handle, bus_size_t offset)
{
       uint32_t *p;
       uint32_t x;
       bus_addr_t wp;

       wp = empb_switch_window(empb_sc, handle);

       p = (uint32_t*) ((empb_sc->pci_mem_win_t->base)
           + (handle - wp) + offset);
       x = *p;

       return x;
}

static uint32_t
empb_bsr4_swap(bus_space_handle_t handle, bus_size_t offset)
{
       uint32_t *p;
       uint32_t x;
       bus_addr_t wp;

       wp = empb_switch_window(empb_sc, handle);

       p = (uint32_t*) ((empb_sc->pci_mem_win_t->base) + (handle - wp)
           + offset);
       x = *p;

       return bswap32(x);
}


static void
empb_bsw4(bus_space_handle_t handle, bus_size_t offset, unsigned value)
{
       uint32_t *p;
       bus_addr_t wp;

       wp = empb_switch_window(empb_sc, handle);
       p = (uint32_t*)((empb_sc->pci_mem_win_t->base) + (handle - wp)
           + offset);
       *p = value;
}

static void
empb_bsw4_swap(bus_space_handle_t handle, bus_size_t offset, unsigned value)
{
       uint32_t *p;
       bus_addr_t wp;

       wp = empb_switch_window(empb_sc, handle);
       p = (uint32_t*)((empb_sc->pci_mem_win_t->base) + (handle - wp)
           + offset);
       *p = bswap32(value);
}

static void
empb_bsrm4(bus_space_handle_t handle, bus_size_t offset, u_int32_t *pointer,
   bus_size_t count)
{
       volatile uint32_t *p;
       bus_addr_t wp;

       wp = empb_switch_window(empb_sc, handle);
       p = (volatile uint32_t *) ((empb_sc->pci_mem_win_t->base) +
           (handle - wp) + offset);

       while (count > 0) {
               *pointer++ = *p;
               amiga_bus_reorder_protect();
               --count;
       }
}

static void
empb_bsrm4_swap(bus_space_handle_t handle, bus_size_t offset,
   u_int32_t *pointer, bus_size_t count)
{
       volatile uint32_t *p;
       bus_addr_t wp;

       wp = empb_switch_window(empb_sc, handle);
       p = (volatile uint32_t *) ((empb_sc->pci_mem_win_t->base) +
           (handle - wp) + offset);

       while (count > 0) {
               *pointer++ = bswap32(*p);
               amiga_bus_reorder_protect();
               --count;
       }
}

static void
empb_bswm4(bus_space_handle_t handle, bus_size_t offset,
   const u_int32_t *pointer, bus_size_t count)
{
       volatile uint32_t *p;
       bus_addr_t wp;

       wp = empb_switch_window(empb_sc, handle);
       p = (volatile uint32_t *) ((empb_sc->pci_mem_win_t->base) +
           (handle - wp) + offset);

       while (count > 0) {
               *p = *pointer++;
               amiga_bus_reorder_protect();
               --count;
       }
}

static void
empb_bswm4_swap(bus_space_handle_t handle, bus_size_t offset,
   const u_int32_t *pointer, bus_size_t count)
{
       volatile uint32_t *p;
       bus_addr_t wp;

       wp = empb_switch_window(empb_sc, handle);
       p = (volatile uint32_t *) ((empb_sc->pci_mem_win_t->base) +
           (handle - wp) + offset);

       while (count > 0) {
               *p = bswap32(*pointer++);
               amiga_bus_reorder_protect();
               --count;
       }
}

static void
empb_bsrr4(bus_space_handle_t handle, bus_size_t offset, u_int32_t *pointer,
   bus_size_t count)
{
       volatile uint32_t *p;
       bus_addr_t wp;

       wp = empb_switch_window(empb_sc, handle);
       p = (volatile uint32_t *) ((empb_sc->pci_mem_win_t->base) +
           (handle - wp) + offset);

       while (count > 0) {
               *pointer++ = *p;
               amiga_bus_reorder_protect();
               p++;
               --count;
       }
}

static void
empb_bsrr4_swap(bus_space_handle_t handle, bus_size_t offset,
   u_int32_t *pointer, bus_size_t count)
{
       volatile uint32_t *p;
       bus_addr_t wp;

       wp = empb_switch_window(empb_sc, handle);
       p = (volatile uint32_t *) ((empb_sc->pci_mem_win_t->base)
           + (handle - wp) + offset);

       while (count > 0) {
               *pointer++ = bswap32(*p);
               amiga_bus_reorder_protect();
               p++;
               --count;
       }
}

static void
empb_bssr4_swap(bus_space_handle_t handle, bus_size_t offset, unsigned value,
   bus_size_t count)
{
       volatile uint32_t *p;
       bus_addr_t wp;

       wp = empb_switch_window(empb_sc, handle);
       p = (volatile uint32_t *) ((empb_sc->pci_mem_win_t->base) +
           (handle - wp) + offset);

       while (count > 0) {
               *p = bswap32(value);
               amiga_bus_reorder_protect();
               p++;
               --count;
       }
}

static void
empb_bswr4(bus_space_handle_t handle, bus_size_t offset,
   const u_int32_t *pointer, bus_size_t count)
{
       volatile uint32_t *p;
       bus_addr_t wp;

       wp = empb_switch_window(empb_sc, handle);
       p = (volatile uint32_t *) ((empb_sc->pci_mem_win_t->base)
           + (handle - wp) + offset);

       while (count > 0) {
               *p = *pointer++;
               amiga_bus_reorder_protect();
               p++;
               --count;
       }
}

static void
empb_bswr4_swap(bus_space_handle_t handle, bus_size_t offset,
   const u_int32_t *pointer, bus_size_t count)
{
       volatile uint32_t *p;
       bus_addr_t wp;

       wp = empb_switch_window(empb_sc, handle);
       p = (volatile uint32_t *) ((empb_sc->pci_mem_win_t->base)
           + (handle - wp) + offset);

       while (count > 0) {
               *p = bswap32(*pointer++);
               amiga_bus_reorder_protect();
               p++;
               --count;
       }
}

/* XXX: this is broken, rewrite, XXX 2: should we swap here? */
void
empb_bscr4(bus_space_handle_t handlefrom, bus_size_t from,
   bus_space_handle_t handleto, bus_size_t to, bus_size_t count)
{
       volatile uint32_t *p, *q;
       bus_addr_t wp;

       wp = empb_switch_window(empb_sc, handlefrom);

       p = (volatile uint32_t *)
           ( ((empb_sc->pci_mem_win_t->base)+(handlefrom - wp)) + from );
       q = (volatile uint32_t *)
           ( ((empb_sc->pci_mem_win_t->base)+(handleto - wp)) + to );

       while (count > 0) {
               *q = *p;
               amiga_bus_reorder_protect();
               p++; q++;
               --count;
       }
}
/* === end of implementation === */

const struct amiga_bus_space_methods empb_bus_swap = {

       .bsm =          empb_bsm,
       .bsms =         empb_bsms,
       .bsu =          empb_bsu,
       .bsa =          NULL,
       .bsf =          NULL,

       /* 8-bit methods */
       .bsr1 =         empb_bsr1,
       .bsw1 =         empb_bsw1,
       .bsrm1 =        empb_bsrm1,
       .bswm1 =        empb_bswm1,
       .bsrr1 =        empb_bsrr1,
       .bswr1 =        empb_bswr1,
       .bssr1 =        empb_bssr1,
       .bscr1 =        empb_bscr1,

       /* 16-bit methods */
       .bsr2 =         empb_bsr2_swap,
       .bsw2 =         empb_bsw2_swap,
       .bsrs2 =        empb_bsr2,
       .bsws2 =        empb_bsw2,
       .bsrm2 =        empb_bsrm2_swap,
       .bswm2 =        empb_bswm2_swap,
       .bsrms2 =       empb_bsrm2,
       .bswms2 =       empb_bswm2,
       .bsrr2 =        empb_bsrr2_swap,
       .bswr2 =        empb_bswr2_swap,
       .bsrrs2 =       empb_bsrr2,
       .bswrs2 =       empb_bswr2,
       .bssr2 =        empb_bssr2_swap,
       .bscr2 =        empb_bscr2,     /* swap? */

       /* 32-bit methods */
       .bsr4 =         empb_bsr4_swap,
       .bsw4 =         empb_bsw4_swap,
       .bsrs4 =        empb_bsr4,
       .bsws4 =        empb_bsw4,
       .bsrm4 =        empb_bsrm4_swap,
       .bswm4 =        empb_bswm4_swap,
       .bsrms4 =       empb_bsrm4,
       .bswms4 =       empb_bswm4,
       .bsrr4 =        empb_bsrr4_swap,
       .bswr4 =        empb_bswr4_swap,
       .bsrrs4 =       empb_bsrr4,
       .bswrs4 =       empb_bswr4,
       .bssr4 =        empb_bssr4_swap,
       .bscr4 =        empb_bscr4              /* swap? */

};

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.