static inline void MemWriteDOC(unsigned long docptr, unsigned char *buf, int len)
{
#ifndef USE_MEMCPY
int i;
for (i = 0; i < len; i++)
WriteDOC(buf[i], docptr, Mil_CDSN_IO + i);
#else
memcpy_toio(docptr + DoC_Mil_CDSN_IO, buf, len);
#endif
}
static void pcmcia_copy_to(struct map_info *map, unsigned long to, const void *from, ssize_t len)
{
caddr_t win_base = (caddr_t)map->map_priv_2;
if(DEV_REMOVED(map))
return;
DEBUG(3, "to = %lu from = %p len = %u", to, from, len);
memcpy_toio(win_base + to, from, len);
}
int Can_dostring(ctl_table *table, int write, struct file *filp,
void *buffer, size_t *lenp)
{
int len;
char *p, c;
if (!table->data || !table->maxlen || !*lenp ||
(filp->f_pos && !write)) {
*lenp = 0;
return 0;
}
if (write) {
len = 0;
p = buffer;
while (len < *lenp && (c = get_user(p++)) != 0 && c != '\n') {
len++;
}
if (len >= table->maxlen) {
len = table->maxlen-1;
}
#if LINUX_VERSION_CODE > 0x20100
memcpy_fromio(table->data, buffer, len);
#else
memcpy_fromfs(table->data, buffer, len);
#endif
((char *) table->data)[len] = 0;
filp->f_pos += *lenp;
} else {
len = strlen(table->data);
if (len > table->maxlen) {
len = table->maxlen;
}
if (len > *lenp) {
len = *lenp;
}
if (len) {
#if LINUX_VERSION_CODE > 0x20100
memcpy_toio(buffer, table->data, len);
#else
memcpy_tofs(buffer, table->data, len);
#endif
}
if (len < *lenp) {
put_user('\n', ((char *) buffer) + len);
len++;
}
*lenp = len;
filp->f_pos += len;
}
return 0;
}
/***************************************************************************
* Name: XPCIe_Write
*
* Description: This routine is invoked from user space to write data to
* the 3GIO device.
*
* Arguments: filp : file pointer to opened device.
* buf : pointer to location in users space, where data is to
* be acquired.
* count : Amount of data in bytes user wishes to send.
*
* Returns: SUCCESS = Success
* CRIT_ERR = Critical failure
* TIME_ERR = Timeout
* LINK_ERR = Link Failure
*
* Modification log:
* Date Who Description
* -------- --- ----------------------------------------------------------
*
****************************************************************************/
ssize_t XPCIe_Write(struct file *filp, const char *buf, size_t count,
loff_t *f_pos)
{
int ret = SUCCESS;
//memcpy((char *)gBaseVirt, buf, count);
//iowrite32_rep(gBaseVirt, (const void *) buf, (unsigned long) count);
memcpy_toio(gBaseVirt + *f_pos, (void *) buf, (unsigned int) count);
printk("%s: XPCIe_Write: %d bytes have been written...\n", gDrvrName, count);
printk("data in buf is %d %d\n", *((int *)gBaseVirt), *((int *)(gBaseVirt+4)));
return (ret);
}
static void hydra_block_output(struct net_device *dev, int count,
const unsigned char *buf, int start_page)
{
unsigned long nic_base = dev->base_addr;
unsigned long mem_base = nic_base - HYDRA_NIC_BASE;
if (count&1)
count++;
memcpy_toio(mem_base+((start_page - NESM_START_PG)<<8), buf, count);
}
static void
hpp_mem_block_output(struct net_device *dev, int count,
const unsigned char *buf, int start_page)
{
int ioaddr = dev->base_addr - NIC_OFFSET;
int option_reg = inw(ioaddr + HPP_OPTION);
outw(start_page << 8, ioaddr + HPP_OUT_ADDR);
outw(option_reg & ~(MemDisable + BootROMEnb), ioaddr + HPP_OPTION);
memcpy_toio(ei_status.mem, buf, (count + 3) & ~3);
outw(option_reg, ioaddr + HPP_OPTION);
}
static inline void new_memcpy_toio(char __iomem *dest, char *src, int length)
{
int len;
do {
len = length > 256 ? 256 : length;
memcpy_toio(dest, src, len);
dest += len;
src += len;
length -= len;
readb(dest);
} while (len);
}
inline static void
snd_nm256_write_buffer(nm256_t *chip, void *src, int offset, int size)
{
offset -= chip->buffer_start;
#ifdef SNDRV_CONFIG_DEBUG
if (offset < 0 || offset >= chip->buffer_size) {
snd_printk("write_buffer invalid offset = %d size = %d\n", offset, size);
return;
}
#endif
memcpy_toio(chip->buffer + offset, src, size);
}
void
OUT_RINGp(struct nouveau_channel *chan, const void *data, unsigned nr_dwords)
{
bool is_iomem;
u32 *mem = ttm_kmap_obj_virtual(&chan->push.buffer->kmap, &is_iomem);
mem = &mem[chan->dma.cur];
if (is_iomem)
memcpy_toio((void __force __iomem *)mem, data, nr_dwords * 4);
else
memcpy(mem, data, nr_dwords * 4);
chan->dma.cur += nr_dwords;
}
static void gf_copy_to(struct map_info *map, unsigned long to, const void *from, ssize_t len)
{
struct async_state *state = gf_map_info_to_state(map);
gf_set_gpios(state, to);
BUG_ON(!((to + len) % state->win_size <= (to + len)));
memcpy_toio(map->virt + (to % state->win_size), from, len);
}
static void mv_inbound_write(u64 p, struct hptiop_hba *hba)
{
u32 inbound_head = readl(&hba->u.mv.mu->inbound_head);
u32 head = inbound_head + 1;
if (head == MVIOP_QUEUE_LEN)
head = 0;
memcpy_toio(&hba->u.mv.mu->inbound_q[inbound_head], &p, 8);
writel(head, &hba->u.mv.mu->inbound_head);
writel(MVIOP_MU_INBOUND_INT_POSTQUEUE,
&hba->u.mv.regs->inbound_doorbell);
}
static inline void
snd_nm256_write_buffer(struct nm256 *chip, void *src, int offset, int size)
{
offset -= chip->buffer_start;
#ifdef CONFIG_SND_DEBUG
if (offset < 0 || offset >= chip->buffer_size) {
snd_printk(KERN_ERR "write_buffer invalid offset = %d size = %d\n",
offset, size);
return;
}
#endif
memcpy_toio(chip->buffer + offset, src, size);
}
/**
* gf_copy_to() - copy a chunk of data to the flash
* @map: MTD map state
* @to: flash offset to copy to
* @from: memory to copy from
* @len: how much to copy
*
* See gf_copy_from() caveat.
*/
static void gf_copy_to(struct map_info *map, unsigned long to,
const void *from, ssize_t len)
{
struct async_state *state = gf_map_info_to_state(map);
gf_set_gpios(state, to);
/* BUG if operation crosses the win_size */
BUG_ON(!((to + len) % state->win_size <= (to + len)));
/* operation does not cross the win_size, so one shot it */
memcpy_toio(map->virt + (to % state->win_size), from, len);
}
int ibmasm_send_i2o_message(struct service_processor *sp)
{
u32 mfa;
unsigned int command_size;
struct i2o_message *message;
struct command *command = sp->current_command;
mfa = get_mfa_inbound(sp->base_address);
if (!mfa)
return 1;
command_size = get_dot_command_size(command->buffer);
header.message_size = outgoing_message_size(command_size);
message = get_i2o_message(sp->base_address, mfa);
memcpy_toio(&message->header, &header, sizeof(struct i2o_header));
memcpy_toio(&message->data, command->buffer, command_size);
set_mfa_inbound(sp->base_address, mfa);
return 0;
}
/*
* Description:
* Restore MAC registers from context buffer
*
* Parameters:
* In:
* io_base - Base Address for MAC
* cxt_buf - Context buffer
* Out:
* none
*
* Return Value: none
*
*/
void MACvRestoreContext(struct vnt_private *priv, unsigned char *cxt_buf)
{
void __iomem *io_base = priv->PortOffset;
MACvSelectPage1(io_base);
/* restore page1 */
memcpy_toio(io_base, cxt_buf + MAC_MAX_CONTEXT_SIZE_PAGE0,
MAC_MAX_CONTEXT_SIZE_PAGE1);
MACvSelectPage0(io_base);
/* restore RCR,TCR,IMR... */
memcpy_toio(io_base + MAC_REG_RCR, cxt_buf + MAC_REG_RCR,
MAC_REG_ISR - MAC_REG_RCR);
/* restore MAC Config. */
memcpy_toio(io_base + MAC_REG_LRT, cxt_buf + MAC_REG_LRT,
MAC_REG_PAGE1SEL - MAC_REG_LRT);
iowrite8(*(cxt_buf + MAC_REG_CFG), io_base + MAC_REG_CFG);
/* restore PS Config. */
memcpy_toio(io_base + MAC_REG_PSCFG, cxt_buf + MAC_REG_PSCFG,
MAC_REG_BBREGCTL - MAC_REG_PSCFG);
/* restore CURR_RX_DESC_ADDR, CURR_TX_DESC_ADDR */
iowrite32(*(u32 *)(cxt_buf + MAC_REG_TXDMAPTR0),
io_base + MAC_REG_TXDMAPTR0);
iowrite32(*(u32 *)(cxt_buf + MAC_REG_AC0DMAPTR),
io_base + MAC_REG_AC0DMAPTR);
iowrite32(*(u32 *)(cxt_buf + MAC_REG_BCNDMAPTR),
io_base + MAC_REG_BCNDMAPTR);
iowrite32(*(u32 *)(cxt_buf + MAC_REG_RXDMAPTR0),
io_base + MAC_REG_RXDMAPTR0);
iowrite32(*(u32 *)(cxt_buf + MAC_REG_RXDMAPTR1),
io_base + MAC_REG_RXDMAPTR1);
}
/**
* mic_x100_load_firmware - Load firmware to MIC.
* @mdev: pointer to mic_device instance
* @buf: buffer containing boot string including firmware/ramdisk path.
*
* RETURNS: An appropriate -ERRNO error value on error, or zero for success.
*/
static int
mic_x100_load_firmware(struct mic_device *mdev, const char *buf)
{
int rc;
const struct firmware *fw;
rc = mic_x100_get_boot_addr(mdev);
if (rc)
return rc;
/* load OS */
rc = request_firmware(&fw, mdev->cosm_dev->firmware, &mdev->pdev->dev);
if (rc < 0) {
dev_err(&mdev->pdev->dev,
"ramdisk request_firmware failed: %d %s\n",
rc, mdev->cosm_dev->firmware);
return rc;
}
if (mdev->bootaddr > mdev->aper.len - fw->size) {
rc = -EINVAL;
dev_err(&mdev->pdev->dev, "%s %d rc %d bootaddr 0x%x\n",
__func__, __LINE__, rc, mdev->bootaddr);
goto error;
}
memcpy_toio(mdev->aper.va + mdev->bootaddr, fw->data, fw->size);
mdev->ops->write_spad(mdev, MIC_X100_FW_SIZE, fw->size);
if (!strcmp(mdev->cosm_dev->bootmode, "flash")) {
rc = -EINVAL;
dev_err(&mdev->pdev->dev, "%s %d rc %d\n",
__func__, __LINE__, rc);
goto error;
}
/* load command line */
rc = mic_x100_load_command_line(mdev, fw);
if (rc) {
dev_err(&mdev->pdev->dev, "%s %d rc %d\n",
__func__, __LINE__, rc);
goto error;
}
release_firmware(fw);
/* load ramdisk */
if (mdev->cosm_dev->ramdisk)
rc = mic_x100_load_ramdisk(mdev);
return rc;
error:
release_firmware(fw);
return rc;
}
static void
e21_block_output(struct net_device *dev, int count, const unsigned char *buf,
int start_page)
{
short ioaddr = dev->base_addr;
volatile char __iomem *shared_mem = ei_status.mem;
/* Set the shared memory window start by doing a read, with the low address
bits specifying the starting page. */
readb(shared_mem + start_page);
mem_on(ioaddr, shared_mem, start_page);
memcpy_toio(shared_mem, buf, count);
mem_off(ioaddr);
}
static ssize_t iomap_write(struct file* file, const char* buf, size_t count,
loff_t* offset) {
Iomap* idev = iomap_dev[MINOR(file->f_dentry->d_inode->i_rdev)];
char* tmp;
/* device not set up */
if (!idev->base) {
return -ENXIO;
}
/* end of mapping? */
if (file->f_pos >= idev->size) {
return 0;
}
tmp = (char*) kmalloc(count, GFP_KERNEL);
if (!tmp) {
return -ENOMEM;
}
/* adjust access beyond end */
if (file->f_pos + count > idev->size) {
count = idev->size - file->f_pos;
}
/* get user data */
if (copy_from_user(tmp, buf, count)) {
kfree(tmp);
return -EFAULT;
}
/* write data to i/o region */
#ifdef IOMAP_BYTE_WISE
{
int i;
for (i = 0; i < count; i++) {
writeb(tmp[i], idev->ptr + file->f_pos + i);
}
}
#else
memcpy_toio(idev->ptr + file->f_pos, tmp, count);
#endif
file->f_pos += count;
kfree(tmp);
return count;
}
static void sane_block_input(struct net_device *dev, int count,
struct sk_buff *skb, int ring_offset)
{
unsigned long xfer_base = ring_offset - (WD_START_PG<<8);
unsigned long xfer_start = xfer_base + dev->mem_start;
if (xfer_start + count > ei_status.rmem_end) {
/* We must wrap the input move. */
int semi_count = ei_status.rmem_end - xfer_start;
memcpy_fromio(skb->data, (char *)dev->mem_start + xfer_base, semi_count);
count -= semi_count;
memcpy_toio(skb->data + semi_count, (char *)ei_status.rmem_start, count);
} else {
memcpy_fromio(skb->data, (char *)dev->mem_start + xfer_base, count);
}
}
static void vmax301_copy_to(struct map_info *map, unsigned long to, const void *from, ssize_t len)
{
while(len) {
unsigned long thislen = len;
if (len > (WINDOW_LENGTH - (to & WINDOW_MASK)))
thislen = WINDOW_LENGTH-(to & WINDOW_MASK);
spin_lock(&vmax301_spin);
vmax301_page(map, to);
memcpy_toio(map->map_priv_2 + to, from, thislen);
spin_unlock(&vmax301_spin);
to += thislen;
from += thislen;
len -= thislen;
}
}
static void elan_104nc_copy_to(struct map_info *map, unsigned long to, const void *from, ssize_t len)
{
while(len) {
unsigned long thislen = len;
if (len > (WINDOW_LENGTH - (to & WINDOW_MASK)))
thislen = WINDOW_LENGTH-(to & WINDOW_MASK);
spin_lock(&elan_104nc_spin);
elan_104nc_page(map, to);
memcpy_toio(iomapadr + (to & WINDOW_MASK), from, thislen);
spin_unlock(&elan_104nc_spin);
to += thislen;
from += thislen;
len -= thislen;
}
}
static void scpi_tx_prepare(struct mbox_client *c, void *msg)
{
unsigned long flags;
struct scpi_xfer *t = msg;
struct scpi_chan *ch = container_of(c, struct scpi_chan, cl);
struct scpi_shared_mem *mem = (struct scpi_shared_mem *)ch->tx_payload;
mem->command = cpu_to_le32(t->cmd);
if (t->tx_buf)
memcpy_toio(mem->payload, t->tx_buf, t->tx_len);
if (t->rx_buf) {
spin_lock_irqsave(&ch->rx_lock, flags);
list_add_tail(&t->node, &ch->rx_pending);
spin_unlock_irqrestore(&ch->rx_lock, flags);
}
}
static int
memregion_readwrite(BOOL is_write,
MEMREGION *memregion, ulong offset,
void *local, ulong nbytes)
{
if (offset + nbytes > memregion->nbytes) {
ERRDRV("memregion_readwrite offset out of range!!");
return -EFAULT;
}
if (is_write)
memcpy_toio(memregion->mapped + offset, local, nbytes);
else
memcpy_fromio(local, memregion->mapped + offset, nbytes);
return 0;
}
static int qsc6085_dump_update(struct dpram_link_device *dpld,
unsigned long arg)
{
int ret;
struct link_device *ld = &dpld->ld;
struct io_device *iod = link_get_iod_with_format(ld, IPC_RAMDUMP);
struct memif_uload_map *ul_map = &dpld->ul_map;
struct cp_ramdump_status *dump_stat = &ld->msd->dump_stat;
char *buff = dpld->buff;
struct qsc6085_dump_command dump_cmd;
while (iod->sk_rx_q.qlen > 0)
usleep_range(1000, 1100);
memset(&dump_cmd, 0, sizeof(dump_cmd));
dump_cmd.addr = dump_stat->addr;
dump_cmd.size = min(dump_stat->rest, ul_map->space);
dump_cmd.copyto_offset = 0x38000010;
memcpy_toio(ul_map->cmd, &dump_cmd, ul_map->cmd_size);
dpld->send_intr(dpld, CMD_CP_RAMDUMP_SEND_REQ);
ret = wait_for_completion_interruptible_timeout(&dpld->crash_cmpl,
RAMDUMP_CMD_TIMEOUT);
if (!ret) {
dump_stat->dump_size = 0;
mif_err("ERR! no response to CP_RAMDUMP_SEND_REQ\n");
ret = -EIO;
goto exit;
}
memcpy_fromio(buff, ul_map->buff, dump_cmd.size);
ret = iod->recv(iod, ld, buff, dump_cmd.size);
if (ret < 0)
goto exit;
dump_stat->addr += dump_cmd.size;
dump_stat->rcvd += dump_cmd.size;
dump_stat->rest -= dump_cmd.size;
mif_info("rest = %u bytes\n", dump_stat->rest);
ret = dump_cmd.size;
exit:
return ret;
}
static void nand_write_buf_cached_block(struct mtd_info *mtd,
const uint8_t *buf, int len)
{
struct nand_chip *chip = mtd->priv;
struct stm_nand_emi *data = chip->priv;
unsigned long irq_flags;
while (len > 0) {
local_irq_save(irq_flags);
memcpy_toio(data->io_data, buf, min(len, CACHEDIO_BLOCK_SIZE));
__flush_purge_region(data->io_data, CACHEDIO_BLOCK_SIZE);
local_irq_restore(irq_flags);
buf += CACHEDIO_BLOCK_SIZE;
len -= CACHEDIO_BLOCK_SIZE;
}
}
/* Copy to PIO, respecting that writes to PIO buffers must be dword aligned.
* Advances piobuf pointer. Leaves additional data in the copy buffer.
*/
static void efx_memcpy_toio_aligned(struct efx_nic *efx, u8 __iomem **piobuf,
u8 *data, int len,
struct efx_short_copy_buffer *copy_buf)
{
int block_len = len & ~(sizeof(copy_buf->buf) - 1);
memcpy_toio(*piobuf, data, block_len);
*piobuf += block_len;
len -= block_len;
if (len) {
data += block_len;
BUG_ON(copy_buf->used);
BUG_ON(len > sizeof(copy_buf->buf));
memcpy(copy_buf->buf, data, len);
copy_buf->used = len;
}
}
static ssize_t mmio_nvram_write(char *buf, size_t count, loff_t *index)
{
unsigned long flags;
if (*index >= mmio_nvram_len)
return 0;
if (*index + count > mmio_nvram_len)
count = mmio_nvram_len - *index;
spin_lock_irqsave(&mmio_nvram_lock, flags);
memcpy_toio(mmio_nvram_start + *index, buf, count);
spin_unlock_irqrestore(&mmio_nvram_lock, flags);
*index += count;
return count;
}
int Can_sysctl_string(ctl_table *table, int *name, int nlen,
void *oldval, size_t *oldlenp,
void *newval, size_t newlen, void **context)
{
int l, len;
if (!table->data || !table->maxlen)
return -ENOTDIR;
if (oldval && oldlenp && get_user(oldlenp)) {
len = get_user(oldlenp);
l = strlen(table->data);
if (len > l) len = l;
if (len >= table->maxlen)
len = table->maxlen;
#if LINUX_VERSION_CODE > 0x20100
memcpy_toio(oldval, table->data, len);
#else
memcpy_tofs(oldval, table->data, len);
#endif
put_user(0, ((char *) oldval) + len);
put_user(len, oldlenp);
}
if (newval && newlen) {
len = newlen;
if (len > table->maxlen)
len = table->maxlen;
#if LINUX_VERSION_CODE > 0x20100
memcpy_fromio(table->data, newval, len);
#else
memcpy_fromfs(table->data, newval, len);
#endif
if (len == table->maxlen)
len--;
((char *) table->data)[len] = 0;
}
return 0;
}
void omap3_scratchpad_dpll4autoidle(int enable)
{
void * __iomem scratchpad_address;
struct omap3_scratchpad_prcm_block prcm_block_contents;
scratchpad_address = OMAP2_IO_ADDRESS(OMAP343X_SCRATCHPAD);
memcpy_fromio(&prcm_block_contents, scratchpad_address + 0x2C,
sizeof(prcm_block_contents));
if (enable)
prcm_block_contents.cm_autoidle_pll |=
(1 << OMAP3430_AUTO_PERIPH_DPLL_SHIFT);
else
prcm_block_contents.cm_autoidle_pll &=
~OMAP3430_AUTO_PERIPH_DPLL_MASK;
memcpy_toio(scratchpad_address + 0x2C, &prcm_block_contents,
sizeof(prcm_block_contents));
}
/**
* copy_from_user_toio - copy data from user-space to mmio-space
* @dst: the destination pointer on mmio-space
* @src: the source pointer on user-space
* @count: the data size to copy in bytes
*
* Copies the data from user-space to mmio-space.
*
* Returns zero if successful, or non-zero on failure.
*/
int copy_from_user_toio(volatile void __iomem *dst, const void __user *src, size_t count)
{
#if defined(__i386__) || defined(CONFIG_SPARC32)
return copy_from_user((void __force *)dst, src, count) ? -EFAULT : 0;
#else
char buf[256];
while (count) {
size_t c = count;
if (c > sizeof(buf))
c = sizeof(buf);
if (copy_from_user(buf, src, c))
return -EFAULT;
memcpy_toio(dst, buf, c);
count -= c;
dst += c;
src += c;
}
return 0;
#endif
}
