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;
}
