static int ak4671_set_idle_mode(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol); P(" idle_mode_value : %d", (int)ucontrol->value.integer.value[0]); if(ak4671_power == 0 && ak4671_idle_mode == IDLE_POWER_DOWN_MODE_ON) { P("audio power up"); set_registers(codec, ak4671_path); return 1; } if ( (ak4671_path & 0xf0) == MM_AUDIO_PLAYBACK) { if (ucontrol->value.integer.value[0] == 0 && ak4671_idle_mode == IDLE_POWER_DOWN_MODE_ON) { // Off idle_mode_enable(codec, ak4671_path); } else if (ucontrol->value.integer.value[0] == 1 && ak4671_idle_mode == IDLE_POWER_DOWN_MODE_OFF) { // On idle_mode_disable(codec, ak4671_path); } else { P("invalid idle mode value"); return -1; } ak4671_idle_mode = ucontrol->value.integer.value[0]; } else P("only Playback mode!"); return 1; }
static int rtl8150_open(struct net_device *netdev) { rtl8150_t *dev; int res; dev = netdev->priv; if (dev == NULL) { return -ENODEV; } down(&dev->sem); set_registers(dev, IDR, 6, netdev->dev_addr); FILL_BULK_URB(dev->rx_urb, dev->udev, usb_rcvbulkpipe(dev->udev, 1), dev->rx_buff, RTL8150_MAX_MTU, read_bulk_callback, dev); if ((res = usb_submit_urb(dev->rx_urb))) warn("%s: rx_urb submit failed: %d", __FUNCTION__, res); FILL_INT_URB(dev->intr_urb, dev->udev, usb_rcvintpipe(dev->udev, 3), dev->intr_buff, sizeof(dev->intr_buff), intr_callback, dev, dev->intr_interval); if ((res = usb_submit_urb(dev->intr_urb))) warn("%s: intr_urb submit failed: %d", __FUNCTION__, res); netif_start_queue(netdev); enable_net_traffic(dev); up(&dev->sem); return res; }
static int ak4671_set_path(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol); int i = 0, new_path; unsigned long flags; local_irq_save(flags); while(audio_path[i] != NULL) { new_path = (i << 4) | ucontrol->value.integer.value[0]; if(!strcmp(audio_path[i], kcontrol->id.name)) { P("path_state : 0x%02x, input path = 0x%02x", ak4671_path , (unsigned int)((i << 4) | ucontrol->value.integer.value[0]) ); if (ak4671_path != new_path) set_registers(codec, new_path); if (ak4671_idle_mode == IDLE_POWER_DOWN_MODE_ON) // Idle mode disable idle_mode_enable(codec, new_path); break; } i++; } local_irq_restore(flags); return 1; }
static int enable_net_traffic(struct net_device *dev, struct usb_device *usb) { __u16 linkpart; __u8 data[4]; pegasus_t *pegasus = dev->priv; read_mii_word(pegasus, pegasus->phy, MII_LPA, &linkpart); data[0] = 0xc9; data[1] = 0; if (linkpart & (ADVERTISE_100FULL | ADVERTISE_10FULL)) data[1] |= 0x20; /* set full duplex */ if (linkpart & (ADVERTISE_100FULL | ADVERTISE_100HALF)) data[1] |= 0x10; /* set 100 Mbps */ if (mii_mode) data[1] = 0; data[2] = (loopback & 1) ? 0x09 : 0x01; memcpy(pegasus->eth_regs, data, sizeof (data)); set_registers(pegasus, EthCtrl0, 3, data); if (usb_dev_id[pegasus->dev_index].vendor == VENDOR_LINKSYS || usb_dev_id[pegasus->dev_index].vendor == VENDOR_DLINK) { u16 auxmode; read_mii_word(pegasus, 0, 0x1b, &auxmode); write_mii_word(pegasus, 0, 0x1b, auxmode | 4); } return 0; }
void Value::assign_register() { if (in_register()) { return; } #if ENABLE_ARM_VFP if (stack_type() == T_FLOAT) { set_register(RegisterAllocator::allocate_float_register()); } else if (stack_type() == T_DOUBLE) { set_vfp_double_register(RegisterAllocator::allocate_double_register()); } else #endif { if (!is_two_word()) { set_register(RegisterAllocator::allocate()); } else { // NOTE: avoid doing this: set_registers(allocate(), allocate()); // The order of parameter list evaluation is undefined in C, and // on linux/i386 and solaris/sparc the orders are opposite. The following // code forces the same order, so AOT generator will generate exact // same code on both Linux and Solaris hosts. Assembler::Register hi = RegisterAllocator::allocate(); Assembler::Register low = RegisterAllocator::allocate(); set_registers(low, hi); } } }
static void disable_net_traffic(rtl8150_t * dev) { u8 cr; get_registers(dev, CR, 1, &cr); cr &= 0xf3; set_registers(dev, CR, 1, &cr); }
static void set_ethernet_addr(pegasus_t * pegasus) { __u8 node_id[6]; get_node_id(pegasus, node_id); set_registers(pegasus, EthID, sizeof (node_id), node_id); memcpy(pegasus->net->dev_addr, node_id, sizeof (node_id)); }
void Value::set_vfp_double_register(Assembler::Register reg) { GUARANTEE(reg >= Assembler::d0, "Not a valid vfp double register"); // Get the real registers reg uses Assembler::Register low = reg; Assembler::Register high = (Assembler::Register)((int)low + 1); set_registers(low, high); }
static int enable_net_traffic(rtl8150_t * dev) { u8 cr, tcr, rcr, msr; if (rtl8150_reset(dev)) { warn("%s - device reset failed", __FUNCTION__); } rcr = 0x9e; /* bit7=1 attach Rx info at the end */ dev->rx_creg = cpu_to_le16(rcr); tcr = 0xd8; cr = 0x0c; set_registers(dev, RCR, 1, &rcr); set_registers(dev, TCR, 1, &tcr); set_registers(dev, CR, 1, &cr); get_registers(dev, MSR, 1, &msr); return 0; }
static int rtl8150_set_mac_address(struct net_device *netdev, void *p) { struct sockaddr *addr = p; rtl8150_t *dev; int i; if (netif_running(netdev)) return -EBUSY; dev = netdev->priv; if (dev == NULL) { return -ENODEV; } // addr->sa_data[0]=0; memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len); dbg("%s: Setting MAC address to ", netdev->name); for (i = 0; i < 6; i++) printk("%02X:", netdev->dev_addr[i]); dbg("%02X\n", netdev->dev_addr[i]); /* Set the IDR registers. */ set_registers(dev, IDR, sizeof(netdev->dev_addr), netdev->dev_addr); #ifdef EEPROM_WRITE { u8 cr; /* Get the CR contents. */ get_registers(dev, CR, 1, &cr); /* Set the WEPROM bit (eeprom write enable). */ cr |= 0x20; set_registers(dev, CR, 1, &cr); /* Write the MAC address into eeprom. Eeprom writes must be word-sized, so we need to split them up. */ for (i = 0; i * 2 < netdev->addr_len; i++) { set_registers(dev, IDR_EEPROM + (i * 2), 2, netdev->dev_addr + (i * 2)); } /* Clear the WEPROM bit (preventing accidental eeprom writes). */ cr &= 0xdf; set_registers(dev, CR, 1, &cr); } #endif return 0; }
/* If the i2c layer weren't so broken, we could pass this kind of data around */ static int ak4671_codec_probe(struct i2c_adapter *adap, int addr, int kind) { struct snd_soc_device *socdev = ak4671_socdev; struct ak4671_setup_data *setup = socdev->codec_data; struct snd_soc_codec *codec = socdev->codec; struct i2c_client *i2c; int ret; if (addr != setup->i2c_address) return -ENODEV; ak4671_client.adapter = adap; ak4671_client.addr = addr; i2c = kmemdup(&ak4671_client, sizeof(ak4671_client), GFP_KERNEL); if (i2c == NULL) return -ENOMEM; i2c_set_clientdata(i2c, codec); codec->control_data = i2c; ret = i2c_attach_client(i2c); if (ret < 0) { printk(KERN_ERR "failed to attach codec at addr %x\n", addr); goto err; } ret = ak4671_init(socdev); if (ret < 0) { printk(KERN_ERR "failed to initialise AK4671\n"); goto err; } set_registers(codec, MM_AUDIO_PLAYBACK_SPK); #if 0 // i2c test p("---> 0x01 = 0x%02x\n", ak4671_read(codec, 0x01)); ak4671_write(codec, 0x01, 0x78); P("---> 0x01 = 0x%02x\n", ak4671_read(codec, 0x01)); P("---> 0x02 = 0x%02x\n", ak4671_read(codec, 0x02)); ak4671_write(codec, 0x02, 0x01); P("---> 0x02 = 0x%02x\n", ak4671_read(codec, 0x02)); P("---> 0x03 = 0x%02x\n", ak4671_read(codec, 0x03)); ak4671_write(codec, 0x03, 0x03); P("---> 0x03 = 0x%02x\n", ak4671_read(codec, 0x03)); #endif return ret; err: kfree(i2c); return ret; }
void do_raise() { /* unmap old stack */ munmap((void*) 0x8000000, 0xc0000000 - 0x8000000); /* open file */ fd = open(filename, O_RDONLY); if (fd < 0) error("Failed to open the file."); /* read and verify header */ if (read_at(0, &hdr, sizeof(Elf32_Ehdr)) != sizeof(Elf32_Ehdr) || hdr.e_ident[EI_MAG0] != ELFMAG0 || hdr.e_ident[EI_MAG1] != ELFMAG1 || hdr.e_ident[EI_MAG2] != ELFMAG2 || hdr.e_ident[EI_MAG3] != ELFMAG3) error("Not an ELF."); if (hdr.e_type != ET_CORE) error("Not a core ELF."); if (hdr.e_machine != EM_386) error("Bad machine."); if (hdr.e_version != EV_CURRENT) error("Bad version."); /* extract relevant info from notes */ for_each_program_header(PT_NOTE, process_program_header_note); if ((notes_found & NOTE_FOUND_ALL_RELEVANT) != NOTE_FOUND_ALL_RELEVANT) error("Relevant notes missing."); /* set up memory */ for_each_program_header(PT_LOAD, process_program_header_load); /* close file */ close(fd); /* prepare registers */ eax = prstatus.pr_reg[6]; ebx = prstatus.pr_reg[0]; ecx = prstatus.pr_reg[1]; edx = prstatus.pr_reg[2]; esi = prstatus.pr_reg[3]; edi = prstatus.pr_reg[4]; ebp = prstatus.pr_reg[5]; esp = prstatus.pr_reg[15]; eip = prstatus.pr_reg[12]; eflags = prstatus.pr_reg[14]; /* tls */ if (syscall(SYS_set_thread_area, &user_desc) < 0) error("tls"); /* set registers */ set_registers(); error("unreachable"); }
static int write_mii_word(rtl8150_t * dev, u8 phy, __u8 indx, u16 reg) { int i; u8 data[3], tmp; data[0] = phy; *(data + 1) = cpu_to_le16p(®); tmp = indx | PHY_WRITE | PHY_GO; i = 0; set_registers(dev, PHYADD, sizeof(data), data); set_registers(dev, PHYCNT, 1, &tmp); do { get_registers(dev, PHYCNT, 1, data); } while ((data[0] & PHY_GO) && (i++ < HZ)); if (i < HZ) return 0; else return 1; }
static int rtl8150_reset(rtl8150_t * dev) { u8 data = 0x10; int i = HZ; set_registers(dev, CR, 1, &data); do { get_registers(dev, CR, 1, &data); } while ((data & 0x10) && --i); return (i > 0) ? 0 : -1; }
static int write_eprom_word(pegasus_t * pegasus, __u8 index, __u16 data) { int i, tmp; __u8 d[4] = { 0x3f, 0, 0, EPROM_WRITE }; set_registers(pegasus, EpromOffset, 4, d); enable_eprom_write(pegasus); set_register(pegasus, EpromOffset, index); set_registers(pegasus, EpromData, 2, &data); set_register(pegasus, EpromCtrl, EPROM_WRITE); for (i = 0; i < REG_TIMEOUT; i++) { get_registers(pegasus, EpromCtrl, 1, &tmp); if (tmp & EPROM_DONE) break; } disable_eprom_write(pegasus); if (i < REG_TIMEOUT) return 0; warn("%s: failed", __FUNCTION__); return -1; }
void getnvrtime() { if (enable_sync) { /* Get time from host. */ time_get(nvrram); } else { /* Get time from internal clock. */ set_registers(); } }
static int read_mii_word(rtl8150_t * dev, u8 phy, __u8 indx, u16 * reg) { int i; u8 data[3], tmp; data[0] = phy; data[1] = data[2] = 0; tmp = indx | PHY_READ | PHY_GO; i = 0; set_registers(dev, PHYADD, sizeof(data), data); set_registers(dev, PHYCNT, 1, &tmp); do { get_registers(dev, PHYCNT, 1, data); } while ((data[0] & PHY_GO) && (i++ < HZ)); if (i < HZ) { get_registers(dev, PHYDAT, 2, data); *reg = le16_to_cpup((u16 *)data); return 0; } else return 1; }
void savenvr() { FILE *f; switch (oldromset) { case ROM_PC1512: f = romfopen("pc1512.nvr", "wb"); break; case ROM_PC1640: f = romfopen("pc1640.nvr", "wb"); break; case ROM_PC200: f = romfopen("pc200.nvr", "wb"); break; case ROM_PC2086: f = romfopen("pc2086.nvr", "wb"); break; case ROM_PC3086: f = romfopen("pc3086.nvr", "wb"); break; case ROM_IBMAT: f = romfopen("at.nvr", "wb"); break; case ROM_IBMPS1_2011: f = romfopen("ibmps1_2011.nvr", "wb"); break; case ROM_CMDPC30: f = romfopen("cmdpc30.nvr", "wb"); break; case ROM_AMI286: f = romfopen("ami286.nvr", "wb"); break; case ROM_DELL200: f = romfopen("dell200.nvr", "wb"); break; case ROM_IBMAT386: f = romfopen("at386.nvr", "wb"); break; case ROM_DESKPRO_386: f = romfopen("deskpro386.nvr", "wb"); break; case ROM_ACER386: f = romfopen("acer386.nvr", "wb"); break; case ROM_MEGAPC: f = romfopen("megapc.nvr", "wb"); break; case ROM_AMI386: f = romfopen("ami386.nvr", "wb"); break; case ROM_AMI486: f = romfopen("ami486.nvr", "wb"); break; case ROM_WIN486: f = romfopen("win486.nvr", "wb"); break; case ROM_PCI486: f = romfopen("hot-433.nvr", "wb"); break; case ROM_SIS496: f = romfopen("sis496.nvr", "wb"); break; case ROM_430VX: f = romfopen("430vx.nvr", "wb"); break; case ROM_REVENGE: f = romfopen("revenge.nvr", "wb"); break; case ROM_ENDEAVOR: f = romfopen("endeavor.nvr", "wb"); break; case ROM_PX386: f = romfopen("px386.nvr", "wb"); break; case ROM_DTK386: f = romfopen("dtk386.nvr", "wb"); break; case ROM_DTK486: f = romfopen("dtk486.nvr", "wb"); break; case ROM_R418: f = romfopen("r418.nvr", "wb"); break; case ROM_PLATO: f = romfopen("plato.nvr", "wb"); break; case ROM_MB500N: f = romfopen("mb500n.nvr", "wb"); break; case ROM_ACERM3A: f = romfopen("acerm3a.nvr", "wb"); break; case ROM_ACERV35N: f = romfopen("acerv35n.nvr", "wb"); break; case ROM_P55T2P4: f = romfopen("p55t2p4.nvr", "wb"); break; case ROM_P55VA: f = romfopen("p55va.nvr", "wb"); break; default: return; } /* If sync is disabled, save internal clock to registers. */ if (!enable_sync) set_registers(); fwrite(nvrram,128,1,f); fclose(f); }
static int pegasus_open(struct net_device *net) { pegasus_t *pegasus = (pegasus_t *) net->priv; int res; if (pegasus->rx_skb == NULL) pegasus->rx_skb = pull_skb(pegasus); /* ** Note: no point to free the pool. it is empty :-) */ if (!pegasus->rx_skb) return -ENOMEM; set_registers(pegasus, EthID, 6, net->dev_addr); usb_fill_bulk_urb(pegasus->rx_urb, pegasus->usb, usb_rcvbulkpipe(pegasus->usb, 1), pegasus->rx_skb->data, PEGASUS_MTU + 8, read_bulk_callback, pegasus); if ((res = usb_submit_urb(pegasus->rx_urb, GFP_KERNEL))) warn("%s: failed rx_urb %d", __FUNCTION__, res); usb_fill_int_urb(pegasus->intr_urb, pegasus->usb, usb_rcvintpipe(pegasus->usb, 3), pegasus->intr_buff, sizeof (pegasus->intr_buff), intr_callback, pegasus, pegasus->intr_interval); if ((res = usb_submit_urb(pegasus->intr_urb, GFP_KERNEL))) warn("%s: failed intr_urb %d", __FUNCTION__, res); netif_start_queue(net); pegasus->flags |= PEGASUS_RUNNING; if ((res = enable_net_traffic(net, pegasus->usb))) { err("can't enable_net_traffic() - %d", res); res = -EIO; usb_unlink_urb(pegasus->rx_urb); usb_unlink_urb(pegasus->intr_urb); free_skb_pool(pegasus); goto exit; } set_carrier(net); res = 0; exit: return res; }
static int rtl8150_open(struct net_device *netdev) { rtl8150_t *dev; int res; dev = netdev->priv; if (dev == NULL) { return -ENODEV; } down(&dev->sem); set_registers(dev, IDR, 6, netdev->dev_addr); FILL_BULK_URB(dev->rx_urb, dev->udev, usb_rcvbulkpipe(dev->udev, 1), dev->rx_buff, RTL8150_MAX_MTU, read_bulk_callback, dev); if ((res = usb_submit_urb(dev->rx_urb))) warn("%s: rx_urb submit failed: %d", __FUNCTION__, res); FILL_INT_URB(dev->intr_urb, dev->udev, usb_rcvintpipe(dev->udev, 3), dev->intr_buff, sizeof(dev->intr_buff), intr_callback, dev, dev->intr_interval); if ((res = usb_submit_urb(dev->intr_urb))) warn("%s: intr_urb submit failed: %d", __FUNCTION__, res); netif_start_queue(netdev); enable_net_traffic(dev); up(&dev->sem); #ifdef CONFIG_RTL865XB_3G { if (0!=reCore_registerWANDevice(netdev)) printk("XXX Can't register wan device\n"); if(0!=devglue_regExtDevice(netdev->name, 8, CONFIG_RTL865XB_3G_PORT, &myLinkID2)) printk("XXX Can't register a link ID for device %s on extPort 0x%x!!!\n", netdev->name,CONFIG_RTL865XB_3G_PORT ); else printk("Device %s on vlan ID %d using Link ID %d. Loopback/Ext port is %d\n", netdev->name, 8, myLinkID2, CONFIG_RTL865XB_3G_PORT); } #endif return res; }
static int write_mii_word(pegasus_t * pegasus, __u8 phy, __u8 indx, __u16 regd) { int i; __u8 data[4] = { phy, 0, 0, indx }; *(data + 1) = cpu_to_le16p(®d); set_register(pegasus, PhyCtrl, 0); set_registers(pegasus, PhyAddr, 4, data); set_register(pegasus, PhyCtrl, (indx | PHY_WRITE)); for (i = 0; i < REG_TIMEOUT; i++) { get_registers(pegasus, PhyCtrl, 1, data); if (data[0] & PHY_DONE) break; } if (i < REG_TIMEOUT) return 0; warn("%s: failed", __FUNCTION__); return 1; }
static int read_mii_word(pegasus_t * pegasus, __u8 phy, __u8 indx, __u16 * regd) { int i; __u8 data[4] = { phy, 0, 0, indx }; __u16 regdi; set_register(pegasus, PhyCtrl, 0); set_registers(pegasus, PhyAddr, sizeof (data), data); set_register(pegasus, PhyCtrl, (indx | PHY_READ)); for (i = 0; i < REG_TIMEOUT; i++) { get_registers(pegasus, PhyCtrl, 1, data); if (data[0] & PHY_DONE) break; } if (i < REG_TIMEOUT) { get_registers(pegasus, PhyData, 2, ®di); *regd = le16_to_cpu(regdi); return 0; } warn("%s: failed", __FUNCTION__); return 1; }
void Value::assign_register() { if (in_register()) return; switch(stack_type()) { case T_OBJECT : // fall through case T_ARRAY : // fall through case T_INT : set_register(RegisterAllocator::allocate()); break; case T_LONG : set_registers(RegisterAllocator::allocate(), RegisterAllocator::allocate()); break; #if ENABLE_ARM_VFP case T_FLOAT : set_register(RegisterAllocator::allocate_float_register()); break; case T_DOUBLE : set_vfp_double_register(RegisterAllocator::allocate_double_register()); break; #else // !ENABLE_ARM_VFP case T_FLOAT : // fall through case T_DOUBLE : set_register(RegisterAllocator::allocate_float_register()); break; #endif // ENABLE_ARM_VFP default : SHOULD_NOT_REACH_HERE(); break; } }
static inline void disable_net_traffic(pegasus_t * pegasus) { int tmp = 0; set_registers(pegasus, EthCtrl0, 2, &tmp); }
static ssize_t ak4671_control_store( struct device *dev, struct device_attribute *attr, const char *buf, size_t size) { u8 reg, value = 0; int ret = 0; struct snd_soc_device *socdev = dev_get_drvdata(dev); struct snd_soc_codec *codec = socdev->codec; printk("echo [REGISTER NUMBER(HEX)][VALUE(HEX)] > ak4671_control\n"); printk("ex) echo 030f > ak4671_control\n"); P("buf = %s", buf); P("buf size = %d", sizeof(buf)); P("buf size = %d", strlen(buf)); if(sizeof(buf) != 4) { printk("input error\n"); printk("store ex) echo 030f\n"); return -1; } ret = hex2dec(buf[0]); if (ret == -1) { printk("store error.\n"); return -1; } reg = ret << 4; ret = hex2dec(buf[1]); if (ret == -1) { printk("store error.\n"); return -1; } reg |= (ret & 0xf); ret = hex2dec(buf[2]); if (ret == -1) { printk("store error.\n"); return -1; } value = ret << 4; ret = hex2dec(buf[3]); if (ret == -1) { printk("store error.\n"); return -1; } value |= (ret & 0xf); if (reg == 0xf1) { // path control set_registers(codec, value); } else if (reg >= 0xe0 && reg <= 0xe5) amp_set_register(reg - 0xe0, value); else ak4671_write(codec, reg, value); printk("Set : reg = 0x%02x, value = 0x%02x\n", reg, value); printk("Read : reg = 0x%02x, value = 0x%02x\n", reg, ak4671_read(codec, reg)); return size; }
void gdbstub_loop(void) { int addr; int length; char *ptr, *ptr1; void *ramaddr; unsigned long regbuf[NUMREGS]; bool reply, set; while (1) { remcomOutBuffer[0] = 0; ptr = getpacket(); if (!ptr) { gdbstub_disconnect(); return; } reply = true; switch (*ptr++) { case '?': send_stop_reply(SIGNAL_TRAP, NULL, 0); reply = false; // already done break; case 'g': /* return the value of the CPU registers */ get_registers(regbuf); ptr = remcomOutBuffer; ptr = mem2hex(regbuf, ptr, NUMREGS * sizeof(unsigned long)); break; case 'G': /* set the value of the CPU registers - return OK */ hex2mem(ptr, regbuf, NUMREGS * sizeof(unsigned long)); set_registers(regbuf); strcpy(remcomOutBuffer,"OK"); break; case 'p': /* pn Read the value of register n */ if (hexToInt(&ptr, &addr) && (size_t)addr < sizeof(regbuf)) { mem2hex(get_registers(regbuf) + addr, remcomOutBuffer, sizeof(unsigned long)); } else { strcpy(remcomOutBuffer,"E01"); } break; case 'P': /* Pn=r Write register n with value r */ ptr = strtok(ptr, "="); if (hexToInt(&ptr, &addr) && (ptr=strtok(NULL, "")) && (size_t)addr < sizeof(regbuf) // TODO hex2mem doesn't check the format && hex2mem((char*)ptr, &get_registers(regbuf)[addr], sizeof(u32)) ) { set_registers(regbuf); strcpy(remcomOutBuffer, "OK"); } else { strcpy(remcomOutBuffer,"E01"); } break; case 'm': /* mAA..AA,LLLL Read LLLL bytes at address AA..AA */ /* Try to read %x,%x */ if (hexToInt(&ptr, &addr) && *ptr++ == ',' && hexToInt(&ptr, &length)) { ramaddr = virt_mem_ptr(addr, length); if (!ramaddr || mem2hex(ramaddr, remcomOutBuffer, length)) break; strcpy(remcomOutBuffer, "E03"); } else strcpy(remcomOutBuffer,"E01"); break; case 'M': /* MAA..AA,LLLL: Write LLLL bytes at address AA..AA */ /* Try to read '%x,%x:' */ if (hexToInt(&ptr, &addr) && *ptr++ == ',' && hexToInt(&ptr, &length) && *ptr++ == ':') { ramaddr = virt_mem_ptr(addr, length); if (!ramaddr) { strcpy(remcomOutBuffer, "E03"); break; } if (range_translated((u32)ramaddr, (u32)((char *)ramaddr + length))) flush_translations(); if (hex2mem(ptr, ramaddr, length)) strcpy(remcomOutBuffer, "OK"); else strcpy(remcomOutBuffer, "E03"); } else strcpy(remcomOutBuffer, "E02"); break; case 'S': /* Ssig[;AA..AA] Step with signal at address AA..AA(optional). Same as 's' for us. */ ptr = strchr(ptr, ';'); /* skip the signal */ if (ptr) ptr++; case 's': /* s[AA..AA] Step at address AA..AA(optional) */ cpu_events |= EVENT_DEBUG_STEP; goto parse_new_pc; case 'C': /* Csig[;AA..AA] Continue with signal at address AA..AA(optional). Same as 'c' for us. */ ptr = strchr(ptr, ';'); /* skip the signal */ if (ptr) ptr++; case 'c': /* c[AA..AA] Continue at address AA..AA(optional) */ parse_new_pc: if (ptr && hexToInt(&ptr, &addr)) { arm.reg[15] = addr; } return; case 'q': if (!strcmp("Offsets", ptr)) { sprintf(remcomOutBuffer, "Text=%x;Data=%x;Bss=%x", ndls_debug_alloc_block, ndls_debug_alloc_block, ndls_debug_alloc_block); } break; case 'Z': /* 0|1|2|3|4,addr,kind */ set = true; goto z; case 'z': /* 0|1|2|3|4,addr,kind */ set = false; // kinds other than 4 aren't supported z: ptr1 = ptr++; ptr = strtok(ptr, ","); if (ptr && hexToInt(&ptr, &addr) && (ramaddr = virt_mem_ptr(addr & ~3, 4))) { u32 *flags = &RAM_FLAGS(ramaddr); switch (*ptr1) { case '0': // mem breakpoint case '1': // hw breakpoint if (set) { if (*flags & RF_CODE_TRANSLATED) flush_translations(); *flags |= RF_EXEC_BREAKPOINT; } else *flags &= ~RF_EXEC_BREAKPOINT; break; case '2': // write watchpoint case '4': // access watchpoint if (set) *flags |= RF_WRITE_BREAKPOINT; else *flags &= ~RF_WRITE_BREAKPOINT; if (*ptr1 != 4) break; case '3': // read watchpoint, access watchpoint if (set) *flags |= RF_READ_BREAKPOINT; else *flags &= ~RF_READ_BREAKPOINT; break; default: goto reply; } strcpy(remcomOutBuffer, "OK"); } else strcpy(remcomOutBuffer, "E01"); break; } /* switch */ reply: /* reply to the request */ if (reply) putpacket(remcomOutBuffer); } }
_Unwind_Reason_Code #if __arm__ __gxx_personality_sj0 #else __gxx_personality_v0 #endif (int version, _Unwind_Action actions, uint64_t exceptionClass, _Unwind_Exception* unwind_exception, _Unwind_Context* context) { if (version != 1 || unwind_exception == 0 || context == 0) return _URC_FATAL_PHASE1_ERROR; bool native_exception = (exceptionClass & get_vendor_and_language) == (kOurExceptionClass & get_vendor_and_language); scan_results results; if (actions & _UA_SEARCH_PHASE) { // Phase 1 search: All we're looking for in phase 1 is a handler that // halts unwinding scan_eh_tab(results, actions, native_exception, unwind_exception, context); if (results.reason == _URC_HANDLER_FOUND) { // Found one. Can we cache the results somewhere to optimize phase 2? if (native_exception) { #ifndef __ARM_EABI_UNWINDER__ __cxa_exception* exception_header = (__cxa_exception*)(unwind_exception+1) - 1; exception_header->handlerSwitchValue = static_cast<int>(results.ttypeIndex); exception_header->actionRecord = results.actionRecord; exception_header->languageSpecificData = results.languageSpecificData; exception_header->catchTemp = reinterpret_cast<void*>(results.landingPad); exception_header->adjustedPtr = results.adjustedPtr; #endif } return _URC_HANDLER_FOUND; } // Did not find a catching-handler. Return the results of the scan // (normally _URC_CONTINUE_UNWIND, but could have been _URC_FATAL_PHASE1_ERROR // if we were called improperly). return results.reason; } if (actions & _UA_CLEANUP_PHASE) { // Phase 2 search: // Did we find a catching handler in phase 1? if (actions & _UA_HANDLER_FRAME) { // Yes, phase 1 said we have a catching handler here. // Did we cache the results of the scan? if (native_exception) { #ifndef __ARM_EABI_UNWINDER__ // Yes, reload the results from the cache. __cxa_exception* exception_header = (__cxa_exception*)(unwind_exception+1) - 1; results.ttypeIndex = exception_header->handlerSwitchValue; results.actionRecord = exception_header->actionRecord; results.languageSpecificData = exception_header->languageSpecificData; results.landingPad = reinterpret_cast<uintptr_t>(exception_header->catchTemp); results.adjustedPtr = exception_header->adjustedPtr; #endif } else { // No, do the scan again to reload the results. scan_eh_tab(results, actions, native_exception, unwind_exception, context); // Phase 1 told us we would find a handler. Now in Phase 2 we // didn't find a handler. The eh table should not be changing! if (results.reason != _URC_HANDLER_FOUND) call_terminate(native_exception, unwind_exception); } // Jump to the handler set_registers(unwind_exception, context, results); return _URC_INSTALL_CONTEXT; } // Either we didn't do a phase 1 search (due to forced unwinding), or // phase 1 reported no catching-handlers. // Search for a (non-catching) cleanup scan_eh_tab(results, actions, native_exception, unwind_exception, context); if (results.reason == _URC_HANDLER_FOUND) { // Found a non-catching handler. Jump to it: set_registers(unwind_exception, context, results); return _URC_INSTALL_CONTEXT; } // Did not find a cleanup. Return the results of the scan // (normally _URC_CONTINUE_UNWIND, but could have been _URC_FATAL_PHASE2_ERROR // if we were called improperly). return results.reason; } // We were called improperly: neither a phase 1 or phase 2 search return _URC_FATAL_PHASE1_ERROR; }