static void alloc586(struct net_device *dev) { struct priv *p = netdev_priv(dev); ni_reset586(); mdelay(32); memset_io(p->iscp, 0, sizeof(struct iscp_struct)); memset_io(p->scp , 0, sizeof(struct scp_struct)); writel(make24(p->iscp), &p->scp->iscp); writeb(SYSBUSVAL, &p->scp->sysbus); writew(make16(p->scb), &p->iscp->scb_offset); writeb(1, &p->iscp->busy); ni_reset586(); ni_attn586(); mdelay(32); if (readb(&p->iscp->busy)) printk(KERN_ERR "%s: Init-Problems (alloc).\n", dev->name); p->reset = 0; memset_io(p->scb, 0, sizeof(struct scb_struct)); }
static void ilo_ccb_close(struct pci_dev *pdev, struct ccb_data *data) { struct ccb *driver_ccb = &data->driver_ccb; struct ccb __iomem *device_ccb = data->mapped_ccb; int retries; /* */ doorbell_clr(driver_ccb); iowrite32(ioread32(&device_ccb->send_ctrl) & ~(1 << CTRL_BITPOS_G), &device_ccb->send_ctrl); iowrite32(ioread32(&device_ccb->recv_ctrl) & ~(1 << CTRL_BITPOS_G), &device_ccb->recv_ctrl); /* */ for (retries = MAX_WAIT; retries > 0; retries--) { doorbell_set(driver_ccb); udelay(WAIT_TIME); if (!(ioread32(&device_ccb->send_ctrl) & (1 << CTRL_BITPOS_A)) && !(ioread32(&device_ccb->recv_ctrl) & (1 << CTRL_BITPOS_A))) break; } if (retries == 0) dev_err(&pdev->dev, "Closing, but controller still active\n"); /* */ memset_io(device_ccb, 0, sizeof(struct ccb)); /* */ pci_free_consistent(pdev, data->dma_size, data->dma_va, data->dma_pa); }
static int vop_finalize_features(struct virtio_device *vdev) { unsigned int i, bits; struct mic_device_desc __iomem *desc = to_vopvdev(vdev)->desc; u8 feature_len = ioread8(&desc->feature_len); /* Second half of bitmap is features we accept. */ u8 __iomem *out_features = _vop_vq_features(desc) + feature_len; /* Give virtio_ring a chance to accept features. */ vring_transport_features(vdev); /* Give virtio_vop a chance to accept features. */ vop_transport_features(vdev); memset_io(out_features, 0, feature_len); bits = min_t(unsigned, feature_len, sizeof(vdev->features)) * 8; for (i = 0; i < bits; i++) { if (__virtio_test_bit(vdev, i)) iowrite8(ioread8(&out_features[i / 8]) | (1 << (i % 8)), &out_features[i / 8]); } return 0; }
static int last_amsslog_extract(void) { struct last_amsslog *buffer = (struct last_amsslog *)amsslog_base; char *smem_errlog = NULL; unsigned size; if (!buffer) return -EINVAL; smem_errlog = smem_get_entry(SMEM_ERR_CRASH_LOG, &size, 0, SMEM_ANY_HOST_FLAG); memset_io(amsslog_base, 0x0, amsslog_size); if (smem_errlog && !memcmp(smem_errlog, "ERR", 3)) { if (size > (amsslog_size - (buffer->data - (u8 *)buffer))) size = (amsslog_size - (buffer->data - (u8 *)buffer)); memcpy_toio(buffer->data, smem_errlog, size); writel_relaxed(size, &buffer->size); writel_relaxed(AMSSLOG_SIG, &buffer->sig); } else return -EINVAL; return 0; }
/* * Do a hardware reset on the card, and set up necessary registers. * * This should be called as little as possible, because it disrupts the * token on the network (causes a RECON) and requires a significant delay. * * However, it does make sure the card is in a defined state. */ static int com90xx_reset(struct net_device *dev, int really_reset) { struct arcnet_local *lp = netdev_priv(dev); short ioaddr = dev->base_addr; BUGMSG(D_INIT, "Resetting (status=%02Xh)\n", ASTATUS()); if (really_reset) { /* reset the card */ inb(_RESET); mdelay(RESETtime); } ACOMMAND(CFLAGScmd | RESETclear); /* clear flags & end reset */ ACOMMAND(CFLAGScmd | CONFIGclear); /* don't do this until we verify that it doesn't hurt older cards! */ /* outb(inb(_CONFIG) | ENABLE16flag, _CONFIG); */ /* verify that the ARCnet signature byte is present */ if (readb(lp->mem_start) != TESTvalue) { if (really_reset) BUGMSG(D_NORMAL, "reset failed: TESTvalue not present.\n"); return 1; } /* enable extended (512-byte) packets */ ACOMMAND(CONFIGcmd | EXTconf); /* clean out all the memory to make debugging make more sense :) */ BUGLVL(D_DURING) memset_io(lp->mem_start, 0x42, 2048); /* done! return success. */ return 0; }
static int check586(struct net_device *dev, unsigned size) { struct priv *p = netdev_priv(dev); int i; p->mapped = ioremap(dev->mem_start, size); if (!p->mapped) return 0; p->base = p->mapped + size - 0x01000000; p->memtop = p->mapped + size; p->scp = (struct scp_struct __iomem *)(p->base + SCP_DEFAULT_ADDRESS); p->scb = (struct scb_struct __iomem *) p->mapped; p->iscp = (struct iscp_struct __iomem *)p->scp - 1; memset_io(p->scp, 0, sizeof(struct scp_struct)); for (i = 0; i < sizeof(struct scp_struct); i++) /* */ if (readb((char __iomem *)p->scp + i)) goto Enodev; writeb(SYSBUSVAL, &p->scp->sysbus); /* */ if (readb(&p->scp->sysbus) != SYSBUSVAL) goto Enodev; if (!check_iscp(dev, p->mapped)) goto Enodev; if (!check_iscp(dev, p->iscp)) goto Enodev; return 1; Enodev: iounmap(p->mapped); return 0; }
static int com90xx_reset(struct net_device *dev, int really_reset) { struct arcnet_local *lp = netdev_priv(dev); short ioaddr = dev->base_addr; BUGMSG(D_INIT, "Resetting (status=%02Xh)\n", ASTATUS()); if (really_reset) { inb(_RESET); mdelay(RESETtime); } ACOMMAND(CFLAGScmd | RESETclear); ACOMMAND(CFLAGScmd | CONFIGclear); if (readb(lp->mem_start) != TESTvalue) { if (really_reset) BUGMSG(D_NORMAL, "reset failed: TESTvalue not present.\n"); return 1; } ACOMMAND(CONFIGcmd | EXTconf); BUGLVL(D_DURING) memset_io(lp->mem_start, 0x42, 2048); return 0; }
/* * We're called here very early in the boot. We determine the machine * type and call the appropriate low-level setup functions. * -- Cort <*****@*****.**> * * Note that the kernel may be running at an address which is different * from the address that it was linked at, so we must use RELOC/PTRRELOC * to access static data (including strings). -- paulus */ notrace unsigned long __init early_init(unsigned long dt_ptr) { unsigned long offset = reloc_offset(); struct cpu_spec *spec; /* First zero the BSS -- use memset_io, some platforms don't have * caches on yet */ memset_io((void __iomem *)PTRRELOC(&__bss_start), 0, __bss_stop - __bss_start); /* * Identify the CPU type and fix up code sections * that depend on which cpu we have. */ spec = identify_cpu(offset, mfspr(SPRN_PVR)); do_feature_fixups(spec->cpu_features, PTRRELOC(&__start___ftr_fixup), PTRRELOC(&__stop___ftr_fixup)); do_feature_fixups(spec->mmu_features, PTRRELOC(&__start___mmu_ftr_fixup), PTRRELOC(&__stop___mmu_ftr_fixup)); do_lwsync_fixups(spec->cpu_features, PTRRELOC(&__start___lwsync_fixup), PTRRELOC(&__stop___lwsync_fixup)); return KERNELBASE + offset; }
static int netx_eth_hard_start_xmit(struct sk_buff *skb, struct net_device *ndev) { struct netx_eth_priv *priv = netdev_priv(ndev); unsigned char *buf = skb->data; unsigned int len = skb->len; spin_lock_irq(&priv->lock); memcpy_toio(priv->sram_base + 1560, (void *)buf, len); if (len < 60) { memset_io(priv->sram_base + 1560 + len, 0, 60 - len); len = 60; } pfifo_push(REQ_FIFO_PORT_LO(priv->id), FIFO_PTR_SEGMENT(priv->id) | FIFO_PTR_FRAMENO(1) | FIFO_PTR_FRAMELEN(len)); ndev->stats.tx_packets++; ndev->stats.tx_bytes += skb->len; netif_stop_queue(ndev); spin_unlock_irq(&priv->lock); dev_kfree_skb(skb); return NETDEV_TX_OK; }
static void ilo_ccb_close(struct pci_dev *pdev, struct ccb_data *data) { struct ccb *driver_ccb = &data->driver_ccb; struct ccb __iomem *device_ccb = data->mapped_ccb; int retries; /* complicated dance to tell the hw we are stopping */ doorbell_clr(driver_ccb); iowrite32(ioread32(&device_ccb->send_ctrl) & ~(1 << CTRL_BITPOS_G), &device_ccb->send_ctrl); iowrite32(ioread32(&device_ccb->recv_ctrl) & ~(1 << CTRL_BITPOS_G), &device_ccb->recv_ctrl); /* give iLO some time to process stop request */ for (retries = MAX_WAIT; retries > 0; retries--) { doorbell_set(driver_ccb); udelay(WAIT_TIME); if (!(ioread32(&device_ccb->send_ctrl) & (1 << CTRL_BITPOS_A)) && !(ioread32(&device_ccb->recv_ctrl) & (1 << CTRL_BITPOS_A))) break; } if (retries == 0) dev_err(&pdev->dev, "Closing, but controller still active\n"); /* clear the hw ccb */ memset_io(device_ccb, 0, sizeof(struct ccb)); /* free resources used to back send/recv queues */ pci_free_consistent(pdev, data->dma_size, data->dma_va, data->dma_pa); }
notrace unsigned long __init early_init(unsigned long dt_ptr) { unsigned long offset = reloc_offset(); struct cpu_spec *spec; memset_io((void __iomem *)PTRRELOC(&__bss_start), 0, __bss_stop - __bss_start); spec = identify_cpu(offset, mfspr(SPRN_PVR)); do_feature_fixups(spec->cpu_features, PTRRELOC(&__start___ftr_fixup), PTRRELOC(&__stop___ftr_fixup)); do_feature_fixups(spec->mmu_features, PTRRELOC(&__start___mmu_ftr_fixup), PTRRELOC(&__stop___mmu_ftr_fixup)); do_lwsync_fixups(spec->cpu_features, PTRRELOC(&__start___lwsync_fixup), PTRRELOC(&__stop___lwsync_fixup)); do_final_fixups(); return KERNELBASE + offset; }
static int last_amsslog_release(struct inode *inode, struct file *file) { memset(amsslog_buf, 0x0, amsslog_size); memset_io(amsslog_base, 0x0, amsslog_size); amsslog_buf_len = 0; return 0; }
void memset_shmem(int card, void *dest, int c, size_t n) { unsigned long flags; unsigned char ch; if(!IS_VALID_CARD(card)) { pr_debug("Invalid param: %d is not a valid card id\n", card); return; } if(n > SRAM_PAGESIZE) { return; } /* * determine the page to load from the address */ ch = (unsigned long) dest / SRAM_PAGESIZE; pr_debug("%s: loaded page %d\n",sc_adapter[card]->devicename,ch); /* * Block interrupts and load the page */ spin_lock_irqsave(&sc_adapter[card]->lock, flags); outb(((sc_adapter[card]->shmem_magic + ch * SRAM_PAGESIZE) >> 14) | 0x80, sc_adapter[card]->ioport[sc_adapter[card]->shmem_pgport]); memset_io(sc_adapter[card]->rambase + ((unsigned long) dest % 0x4000), c, n); pr_debug("%s: set page to %#x\n",sc_adapter[card]->devicename, ((sc_adapter[card]->shmem_magic + ch * SRAM_PAGESIZE)>>14)|0x80); spin_unlock_irqrestore(&sc_adapter[card]->lock, flags); }
static int snd_sh_dac_pcm_silence(struct snd_pcm_substream *substream, int channel, snd_pcm_uframes_t pos, snd_pcm_uframes_t count) { struct snd_sh_dac *chip = snd_pcm_substream_chip(substream); struct snd_pcm_runtime *runtime = substream->runtime; ssize_t b_count = frames_to_bytes(runtime , count); ssize_t b_pos = frames_to_bytes(runtime , pos); if (count < 0) return -EINVAL; if (!count) return 0; memset_io(chip->data_buffer + b_pos, 0, b_count); chip->buffer_end = chip->data_buffer + b_pos + b_count; if (chip->empty) { chip->empty = 0; dac_audio_start_timer(chip); } return 0; }
static int __init Fb_map_video_memory(struct fb_info *info) { #ifndef CONFIG_FB_SUNXI_RESERVED_MEM unsigned map_size = PAGE_ALIGN(info->fix.smem_len); struct page *page; page = alloc_pages(GFP_KERNEL, get_order(map_size)); if (page != NULL) { info->screen_base = page_address(page); info->fix.smem_start = virt_to_phys(info->screen_base); memset(info->screen_base, 0, info->fix.smem_len); __inf("Fb_map_video_memory, pa=0x%08lx size:0x%x\n", info->fix.smem_start, info->fix.smem_len); return 0; } else { __wrn("alloc_pages fail!\n"); return -ENOMEM; } #else info->screen_base = (char __iomem *)disp_malloc(info->fix.smem_len); info->fix.smem_start = (unsigned long)__pa(info->screen_base); memset_io(info->screen_base, 0, info->fix.smem_len); __inf("Fb_map_video_memory, pa=0x%08lx size:0x%x\n", info->fix.smem_start, info->fix.smem_len); return 0; #endif }
static void rk_ahash_reg_init(struct rk_crypto_info *dev) { int reg_status = 0; reg_status = CRYPTO_READ(dev, RK_CRYPTO_CTRL) | RK_CRYPTO_HASH_FLUSH | _SBF(0xffff, 16); CRYPTO_WRITE(dev, RK_CRYPTO_CTRL, reg_status); reg_status = CRYPTO_READ(dev, RK_CRYPTO_CTRL); reg_status &= (~RK_CRYPTO_HASH_FLUSH); reg_status |= _SBF(0xffff, 16); CRYPTO_WRITE(dev, RK_CRYPTO_CTRL, reg_status); memset_io(dev->reg + RK_CRYPTO_HASH_DOUT_0, 0, 32); CRYPTO_WRITE(dev, RK_CRYPTO_INTENA, RK_CRYPTO_HRDMA_ERR_ENA | RK_CRYPTO_HRDMA_DONE_ENA); CRYPTO_WRITE(dev, RK_CRYPTO_INTSTS, RK_CRYPTO_HRDMA_ERR_INT | RK_CRYPTO_HRDMA_DONE_INT); CRYPTO_WRITE(dev, RK_CRYPTO_HASH_CTRL, dev->mode | RK_CRYPTO_HASH_SWAP_DO); CRYPTO_WRITE(dev, RK_CRYPTO_CONF, RK_CRYPTO_BYTESWAP_HRFIFO | RK_CRYPTO_BYTESWAP_BRFIFO | RK_CRYPTO_BYTESWAP_BTFIFO); CRYPTO_WRITE(dev, RK_CRYPTO_HASH_MSG_LEN, dev->total); }
INT32 mtk_wcn_consys_hw_restore(struct device *device) { UINT32 addrPhy = 0; if (gConEmiPhyBase) { #if CONSYS_EMI_MPU_SETTING /*set MPU for EMI share Memory */ WMT_PLAT_INFO_FUNC("setting MPU for EMI share memory\n"); #if defined(CONFIG_ARCH_MT6735) emi_mpu_set_region_protection(gConEmiPhyBase + SZ_1M / 2, gConEmiPhyBase + SZ_1M - 1, 13, SET_ACCESS_PERMISSON(FORBIDDEN, FORBIDDEN, FORBIDDEN, FORBIDDEN, FORBIDDEN, NO_PROTECTION, FORBIDDEN, NO_PROTECTION)); #elif defined(CONFIG_ARCH_MT6735M) emi_mpu_set_region_protection(gConEmiPhyBase, gConEmiPhyBase + SZ_1M - 1, 6, SET_ACCESS_PERMISSON(FORBIDDEN, NO_PROTECTION, FORBIDDEN, NO_PROTECTION)); #elif defined(CONFIG_ARCH_MT6753) emi_mpu_set_region_protection(gConEmiPhyBase + SZ_1M / 2, gConEmiPhyBase + SZ_1M - 1, 13, SET_ACCESS_PERMISSON(FORBIDDEN, FORBIDDEN, FORBIDDEN, FORBIDDEN, FORBIDDEN, NO_PROTECTION, FORBIDDEN, NO_PROTECTION)); #else WMT_PLAT_WARN_FUNC("not define platform config\n"); #endif #endif /*consys to ap emi remapping register:10000320, cal remapping address */ addrPhy = (gConEmiPhyBase & 0xFFF00000) >> 20; /*enable consys to ap emi remapping bit12 */ addrPhy = addrPhy | 0x1000; CONSYS_REG_WRITE(conn_reg.topckgen_base + CONSYS_EMI_MAPPING_OFFSET, CONSYS_REG_READ(conn_reg.topckgen_base + CONSYS_EMI_MAPPING_OFFSET) | addrPhy); WMT_PLAT_INFO_FUNC("CONSYS_EMI_MAPPING dump in restore cb(0x%08x)\n", CONSYS_REG_READ(conn_reg.topckgen_base + CONSYS_EMI_MAPPING_OFFSET)); #if 1 pEmibaseaddr = ioremap_nocache(gConEmiPhyBase + SZ_1M / 2, CONSYS_EMI_MEM_SIZE); #else pEmibaseaddr = ioremap_nocache(CONSYS_EMI_AP_PHY_BASE, CONSYS_EMI_MEM_SIZE); #endif if (pEmibaseaddr) { WMT_PLAT_WARN_FUNC("EMI mapping OK(0x%p)\n", pEmibaseaddr); memset_io(pEmibaseaddr, 0, CONSYS_EMI_MEM_SIZE); } else { WMT_PLAT_ERR_FUNC("EMI mapping fail\n"); } } else {
static int iomap_ioctl(struct inode* inode, struct file* file, unsigned int cmd, unsigned long arg) { Iomap* idev = iomap_dev[MINOR(inode->i_rdev)]; switch (cmd) { /* create the wanted device */ case IOMAP_SET: { /* if base is set, device is in use */ if (idev->base) { return -EBUSY; } if (copy_from_user(idev, (Iomap*)arg, sizeof(Iomap))) { return -EFAULT; } /* base and size must be page aligned */ if (idev->base % PAGE_SIZE || idev->size % PAGE_SIZE) { idev->base = 0; return -EINVAL; } MSG("setting up minor %d\n", MINOR(inode->i_rdev)); iomap_setup(idev); return 0; } case IOMAP_GET: { /* maybe device is not set up */ if (!idev->base) { return -ENXIO; } if (copy_to_user((Iomap*)arg, idev, sizeof(Iomap))) { return -EFAULT; } return 0; } case IOMAP_CLEAR: { long tmp; /* if base is set, device is in use */ if (!idev->base) { return -EBUSY; } if (get_user(tmp, (long*)arg)) { return -EFAULT; } memset_io(idev->ptr, tmp, idev->size); return 0; } } return -ENOTTY; }
/* silence callback for halfduplex mode */ static int snd_rme32_playback_silence(struct snd_pcm_substream *substream, int channel, /* not used (interleaved data) */ snd_pcm_uframes_t pos, snd_pcm_uframes_t count) { struct rme32 *rme32 = snd_pcm_substream_chip(substream); count <<= rme32->playback_frlog; pos <<= rme32->playback_frlog; memset_io(rme32->iobase + RME32_IO_DATA_BUFFER + pos, 0, count); return 0; }
static void __iomem *alloc_rfa(struct net_device *dev, void __iomem *ptr) { struct rfd_struct __iomem *rfd = ptr; struct rbd_struct __iomem *rbd; int i; struct priv *p = netdev_priv(dev); memset_io(rfd, 0, sizeof(struct rfd_struct) * (p->num_recv_buffs + rfdadd)); p->rfd_first = rfd; for (i = 0; i < (p->num_recv_buffs + rfdadd); i++) { writew(make16(rfd + (i+1) % (p->num_recv_buffs+rfdadd)), &rfd[i].next); writew(0xffff, &rfd[i].rbd_offset); } /* */ writeb(RFD_SUSP, &rfd[p->num_recv_buffs-1+rfdadd].last); ptr = rfd + (p->num_recv_buffs + rfdadd); rbd = ptr; ptr = rbd + p->num_recv_buffs; /* */ memset_io(rbd, 0, sizeof(struct rbd_struct) * (p->num_recv_buffs)); for (i = 0; i < p->num_recv_buffs; i++) { writew(make16(rbd + (i+1) % p->num_recv_buffs), &rbd[i].next); writew(RECV_BUFF_SIZE, &rbd[i].size); writel(make24(ptr), &rbd[i].buffer); ptr = ptr + RECV_BUFF_SIZE; } p->rfd_top = p->rfd_first; p->rfd_last = p->rfd_first + (p->num_recv_buffs - 1 + rfdadd); writew(make16(p->rfd_first), &p->scb->rfa_offset); writew(make16(rbd), &p->rfd_first->rbd_offset); return ptr; }
static void StartAudioFMI2SAWBHardware(struct snd_pcm_substream *substream) { AudioDigtalI2S m2ndI2SInAttribute; pr_warn("StartAudioFMI2SAWBHardware\n"); /* here to set interrupt */ SetIrqMcuCounter(Soc_Aud_IRQ_MCU_MODE_IRQ2_MCU_MODE, substream->runtime->period_size >> 1); SetIrqMcuSampleRate(Soc_Aud_IRQ_MCU_MODE_IRQ2_MCU_MODE, substream->runtime->rate); SetIrqEnable(Soc_Aud_IRQ_MCU_MODE_IRQ2_MCU_MODE, true); SetSampleRate(Soc_Aud_Digital_Block_MEM_AWB, substream->runtime->rate); SetMemoryPathEnable(Soc_Aud_Digital_Block_MEM_AWB, true); /* here to turn off digital part */ SetConnection(Soc_Aud_InterCon_Connection, Soc_Aud_InterConnectionInput_I00, Soc_Aud_InterConnectionOutput_O05); SetConnection(Soc_Aud_InterCon_Connection, Soc_Aud_InterConnectionInput_I01, Soc_Aud_InterConnectionOutput_O06); if (GetMemoryPathEnable(Soc_Aud_Digital_Block_I2S_IN_2) == false) { /* set merge interface */ SetMemoryPathEnable(Soc_Aud_Digital_Block_I2S_IN_2, true); /* Config 2nd I2S IN */ memset_io((void *)&m2ndI2SInAttribute, 0, sizeof(m2ndI2SInAttribute)); m2ndI2SInAttribute.mLR_SWAP = Soc_Aud_LR_SWAP_NO_SWAP; m2ndI2SInAttribute.mI2S_IN_PAD_SEL = false; /* I2S_IN_FROM_CONNSYS */ m2ndI2SInAttribute.mI2S_SLAVE = Soc_Aud_I2S_SRC_SLAVE_MODE; m2ndI2SInAttribute.mI2S_SAMPLERATE = 32000; m2ndI2SInAttribute.mINV_LRCK = Soc_Aud_INV_LRCK_NO_INVERSE; m2ndI2SInAttribute.mI2S_FMT = Soc_Aud_I2S_FORMAT_I2S; m2ndI2SInAttribute.mI2S_WLEN = Soc_Aud_I2S_WLEN_WLEN_16BITS; Set2ndI2SIn(&m2ndI2SInAttribute); if (substream->runtime->rate == 48000) SetI2SASRCConfig(true, 48000); /* Covert from 32000 Hz to 48000 Hz */ else SetI2SASRCConfig(true, 44100); /* Covert from 32000 Hz to 44100 Hz */ SetI2SASRCEnable(true); Set2ndI2SInEnable(true); } else SetMemoryPathEnable(Soc_Aud_Digital_Block_I2S_IN_2, true); EnableAfe(true); }
/* * silence / copy for playback */ static int snd_nm256_playback_silence(struct snd_pcm_substream *substream, int channel, /* not used (interleaved data) */ snd_pcm_uframes_t pos, snd_pcm_uframes_t count) { struct snd_pcm_runtime *runtime = substream->runtime; struct nm256_stream *s = runtime->private_data; count = frames_to_bytes(runtime, count); pos = frames_to_bytes(runtime, pos); memset_io(s->bufptr + pos, 0, count); return 0; }
/* Do a hardware reset on the card, and set up necessary registers. * * This should be called as little as possible, because it disrupts the * token on the network (causes a RECON) and requires a significant delay. * * However, it does make sure the card is in a defined state. */ int arcrimi_reset(struct device *dev,int reset_delay) { struct arcnet_local *lp=(struct arcnet_local *)dev->priv; short ioaddr=dev->mem_start + 0x800; int recbuf=lp->recbuf; if (reset_delay==3) { ARCRESET; return 0; } /* no IRQ's, please! */ lp->intmask=0; SETMASK; BUGMSG(D_INIT,"Resetting %s (status=%Xh)\n", dev->name,ARCSTATUS); ACOMMAND(CFLAGScmd|RESETclear); /* clear flags & end reset */ ACOMMAND(CFLAGScmd|CONFIGclear); /* clear out status variables */ recbuf=lp->recbuf=0; lp->txbuf=2; /* enable extended (512-byte) packets */ ACOMMAND(CONFIGcmd|EXTconf); #ifndef SLOW_XMIT_COPY /* clean out all the memory to make debugging make more sense :) */ BUGLVL(D_DURING) memset_io(dev->mem_start,0x42,2048); #endif /* and enable receive of our first packet to the first buffer */ EnableReceiver(); /* re-enable interrupts */ lp->intmask|=NORXflag; #ifdef DETECT_RECONFIGS lp->intmask|=RECONflag; #endif SETMASK; /* done! return success. */ return 0; }
static int init_mixer_values(struct lola *chip) { int i; /* all sample rate converters on */ lola_set_src_config(chip, (1 << chip->pin[CAPT].num_pins) - 1, false); /* clear all mixer matrix settings */ memset_io(chip->mixer.array, 0, sizeof(*chip->mixer.array)); /* inform firmware about all updated matrix columns - capture part */ for (i = 0; i < chip->mixer.dest_stream_ins; i++) lola_codec_write(chip, chip->mixer.nid, LOLA_VERB_SET_DESTINATION_GAIN, i, 0); /* inform firmware about all updated matrix columns - output part */ for (i = 0; i < chip->mixer.dest_phys_outs; i++) lola_codec_write(chip, chip->mixer.nid, LOLA_VERB_SET_DESTINATION_GAIN, chip->mixer.dest_phys_out_ofs + i, 0); /* set all digital input source (master) gains to 0dB */ for (i = 0; i < chip->mixer.src_phys_ins; i++) lola_mixer_set_src_gain(chip, i, 336, true); /* 0dB */ /* set all digital playback source (master) gains to 0dB */ for (i = 0; i < chip->mixer.src_stream_outs; i++) lola_mixer_set_src_gain(chip, i + chip->mixer.src_stream_out_ofs, 336, true); /* 0dB */ /* set gain value 0dB diagonally in matrix - part INPUT -> CAPTURE */ for (i = 0; i < chip->mixer.dest_stream_ins; i++) { int src = i % chip->mixer.src_phys_ins; lola_mixer_set_mapping_gain(chip, src, i, 336, true); } /* set gain value 0dB diagonally in matrix , part PLAYBACK -> OUTPUT * (LoLa280 : playback channel 0,2,4,6 linked to output channel 0) * (LoLa280 : playback channel 1,3,5,7 linked to output channel 1) */ for (i = 0; i < chip->mixer.src_stream_outs; i++) { int src = chip->mixer.src_stream_out_ofs + i; int dst = chip->mixer.dest_phys_out_ofs + i % chip->mixer.dest_phys_outs; lola_mixer_set_mapping_gain(chip, src, dst, 336, true); } return 0; }
/* * We're called here very early in the boot. We determine the machine * type and call the appropriate low-level setup functions. * -- Cort <*****@*****.**> * * Note that the kernel may be running at an address which is different * from the address that it was linked at, so we must use RELOC/PTRRELOC * to access static data (including strings). -- paulus */ unsigned long __init early_init(unsigned long dt_ptr) { unsigned long offset = reloc_offset(); /* First zero the BSS -- use memset_io, some platforms don't have * caches on yet */ memset_io(PTRRELOC(&__bss_start), 0, _end - __bss_start); /* * Identify the CPU type and fix up code sections * that depend on which cpu we have. */ identify_cpu(offset, 0); do_cpu_ftr_fixups(offset); return KERNELBASE + offset; }
static int check_iscp(struct net_device *dev, void __iomem *addr) { struct iscp_struct __iomem *iscp = addr; struct priv *p = netdev_priv(dev); memset_io(iscp, 0, sizeof(struct iscp_struct)); writel(make24(iscp), &p->scp->iscp); writeb(1, &iscp->busy); ni_reset586(); ni_attn586(); mdelay(32); /* */ /* */ if (readb(&iscp->busy)) return 0; return 1; }
static int check_iscp(struct net_device *dev, void __iomem *addr) { struct iscp_struct __iomem *iscp = addr; struct priv *p = dev->priv; memset_io(iscp, 0, sizeof(struct iscp_struct)); writel(make24(iscp), &p->scp->iscp); writeb(1, &iscp->busy); ni_reset586(); ni_attn586(); mdelay(32); /* wait a while... */ /* i82586 clears 'busy' after successful init */ if (readb(&iscp->busy)) return 0; return 1; }
/* * We're called here very early in the boot. * * Note that the kernel may be running at an address which is different * from the address that it was linked at, so we must use RELOC/PTRRELOC * to access static data (including strings). -- paulus */ notrace unsigned long __init early_init(unsigned long dt_ptr) { unsigned long offset = reloc_offset(); /* First zero the BSS -- use memset_io, some platforms don't have * caches on yet */ memset_io((void __iomem *)PTRRELOC(&__bss_start), 0, __bss_stop - __bss_start); /* * Identify the CPU type and fix up code sections * that depend on which cpu we have. */ identify_cpu(offset, mfspr(SPRN_PVR)); apply_feature_fixups(); return KERNELBASE + offset; }
static void snd_msnd_capture_reset_queue(struct snd_msnd *chip, unsigned int pcm_periods, unsigned int pcm_count) { int n; void *pDAQ; /* unsigned long flags; */ /* snd_msnd_init_queue(chip->DARQ, DARQ_DATA_BUFF, DARQ_BUFF_SIZE); */ chip->last_recbank = 2; chip->captureLimit = pcm_count * (pcm_periods - 1); chip->capturePeriods = pcm_periods; writew(PCTODSP_OFFSET(0 * DAQDS__size), chip->DARQ + JQS_wHead); writew(PCTODSP_OFFSET(chip->last_recbank * DAQDS__size), chip->DARQ + JQS_wTail); #if 0 /* Critical section: bank 1 access. this is how the OSS driver does it:*/ spin_lock_irqsave(&chip->lock, flags); outb(HPBLKSEL_1, chip->io + HP_BLKS); memset_io(chip->mappedbase, 0, DAR_BUFF_SIZE * 3); outb(HPBLKSEL_0, chip->io + HP_BLKS); spin_unlock_irqrestore(&chip->lock, flags); #endif chip->capturePeriodBytes = pcm_count; snd_printdd("snd_msnd_capture_reset_queue() %i\n", pcm_count); pDAQ = chip->mappedbase + DARQ_DATA_BUFF; for (n = 0; n < pcm_periods; ++n, pDAQ += DAQDS__size) { u32 tmp = pcm_count * n; writew(PCTODSP_BASED(tmp + 0x3000), pDAQ + DAQDS_wStart); writew(pcm_count, pDAQ + DAQDS_wSize); writew(1, pDAQ + DAQDS_wFormat); writew(chip->capture_sample_size, pDAQ + DAQDS_wSampleSize); writew(chip->capture_channels, pDAQ + DAQDS_wChannels); writew(chip->capture_sample_rate, pDAQ + DAQDS_wSampleRate); writew(HIMT_RECORD_DONE * 0x100 + n, pDAQ + DAQDS_wIntMsg); writew(n, pDAQ + DAQDS_wFlags); } }
void intel_fbdev_set_suspend(struct drm_device *dev, int state) { struct drm_i915_private *dev_priv = dev->dev_private; struct intel_fbdev *ifbdev = dev_priv->fbdev; struct fb_info *info; if (!ifbdev) return; info = ifbdev->helper.fbdev; /* On resume from hibernation: If the object is shmemfs backed, it has * been restored from swap. If the object is stolen however, it will be * full of whatever garbage was left in there. */ if (state == FBINFO_STATE_RUNNING && ifbdev->ifb.obj->stolen) memset_io(info->screen_base, 0, info->screen_size); fb_set_suspend(info, state); }