static void
gdb_cmd_read_mem(unsigned long addr, unsigned long length,
struct gdb_context *ctx)
{
int x, r;
unsigned char val;
dbg_printk("Memory read starting at %lx, length %lx.\n", addr,
length);
for ( x = 0; x < length; x++ )
{
r = gdb_arch_copy_from_user(&val, (void *)(addr + x), 1);
if ( r != 0 )
{
dbg_printk("Error reading from %lx.\n", addr + x);
break;
}
gdb_write_to_packet_hex(val, sizeof(val), ctx);
}
if ( x == 0 )
gdb_write_to_packet_str("E05", ctx);
dbg_printk("Read done.\n");
gdb_send_packet(ctx);
}
static void
gdb_cmd_write_mem(unsigned long addr, unsigned long length,
const char *buf, struct gdb_context *ctx)
{
int x, r;
unsigned char val;
dbg_printk("Memory write starting at %lx, length %lx.\n", addr, length);
for ( x = 0; x < length; x++, addr++, buf += 2 )
{
val = str2ulong(buf, sizeof(val));
r = gdb_arch_copy_to_user((void*)addr, (void*)&val, 1);
if ( r != 0 )
{
dbg_printk("Error writing to %lx.\n", addr);
break;
}
}
if (x == length)
gdb_write_to_packet_str("OK", ctx);
else
gdb_write_to_packet_str("E11", ctx);
dbg_printk("Write done.\n");
gdb_send_packet(ctx);
}
static void sec_report_flip_key(struct sec_flip *flip)
{
#if REPORT_KEY
if (flip_status) {
input_report_key(flip->input, KEY_FOLDER_OPEN, 1);
input_report_key(flip->input, KEY_FOLDER_OPEN, 0);
input_sync(flip->input);
dbg_printk("[FLIP] %s: input flip key : open\n", __FUNCTION__);
} else {
input_report_key(flip->input, KEY_FOLDER_CLOSE, 1);
input_report_key(flip->input, KEY_FOLDER_CLOSE, 0);
input_sync(flip->input);
dbg_printk ("[FLIP] %s: input flip key : close\n", __FUNCTION__);
}
#else
if (flip_status) {
input_report_switch(flip->input, SW_LID, 0);
input_sync(flip->input);
dbg_printk("[FLIP] %s: input flip key : open\n", __FUNCTION__);
} else {
input_report_switch(flip->input, SW_LID, 1);
input_sync(flip->input);
dbg_printk ("[FLIP] %s: input flip key : close\n", __FUNCTION__);
}
#endif
}
static int touch_event_handler(void *arg)
{
struct sched_param param = { .sched_priority = RTPM_PRIO_TPD };
struct tp_driver_data * data = (struct tp_driver_data*) arg ;
if(!data)
return -ENODEV ;
sched_setscheduler(current, SCHED_RR, ¶m);
do
{
set_current_state(TASK_INTERRUPTIBLE);
wait_event_interruptible(waiter, tpd_flag != 0);
tpd_flag = 0 ;
set_current_state(TASK_RUNNING);
if(data->out.report_func&& !exitThread){
dbg_printk("++++:%pf\n",data->out.report_func);
data->out.report_func(data->out.driver_data) ;
dbg_printk("----\n");
}
mt_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM);
}while (!exitThread);
dbg_printk("!!!!!!!!!!!!!!kthread exit!!!!!!!!!!!!\n");
return 0;
}
/*****************************************************************************
* MODULE : sizrot2_close
* FUNCTION : close SIZ/ROT device
* RETURN : 0 :
* NOTE : none
******************************************************************************/
int sizrot2_close(struct inode *inode, struct file *file)
{
dbg_printk((_DEBUG_SIZROT2 & 0x01),
" @sizrot2: sizrot2_close() <start>");
dbg_printk((_DEBUG_SIZROT2 & 0x01),
" MINOR(inode->i_rdev): %d\n", MINOR(inode->i_rdev));
return 0;
}
int s5p_dsim_phy_enable(struct mipi_dsim_device *dsim, bool on)
{
//u32 cfg = (u32)dsim->pd->lcd_panel_info;
dbg_printk("%s: %d\n", __func__, on);
return 0;
}
void
gdb_write_to_packet_hex(unsigned long x, int int_size, struct gdb_context *ctx)
{
char buf[sizeof(unsigned long) * 2 + 1];
int i = sizeof(unsigned long) * 2;
int width = int_size * 2;
buf[sizeof(unsigned long) * 2] = 0;
switch ( int_size )
{
case sizeof(u8):
case sizeof(u16):
case sizeof(u32):
case sizeof(u64):
break;
default:
dbg_printk("WARNING: %s x: 0x%lx int_size: %d\n",
__func__, x, int_size);
break;
}
do {
buf[--i] = hex2char(x & 15);
x >>= 4;
} while ( x );
while ( (i + width) > (sizeof(unsigned long) * 2) )
buf[--i] = '0';
gdb_write_to_packet(&buf[i], width, ctx);
}
static int __devinit usbhsic_probe(struct platform_device *pdev)
{
int ret;
struct resource *iomem, *ioarea;
if (pdev->dev.platform_data == NULL) {
dev_err(&pdev->dev, "platform_data missing\n");
ret = -EFAULT;
goto err_exit;
}
memset(&usbh_hsic_data, 0, sizeof(usbh_hsic_data));
memcpy(&usbh_hsic_data.hw_cfg, pdev->dev.platform_data,
sizeof(usbh_hsic_data.hw_cfg));
usbh_hsic_data.dev = &pdev->dev;
iomem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!iomem) {
dev_err(&pdev->dev, "no mem resource\n");
ret = -ENODEV;
goto err_exit;
}
dbg_printk("%s: HSIC %s %d 0x%08x\n",
__func__, pdev->name, pdev->id, iomem->start);
/* mark the memory region as used */
ioarea = request_mem_region(iomem->start, resource_size(iomem),
pdev->name);
if (!ioarea) {
dev_err(&pdev->dev, "memory region already claimed\n");
ret = -EBUSY;
goto err_exit;
}
/* now map the I/O memory */
usbh_hsic_data.ctrl_regs = (struct usbh_hsic_ctrl_regs __iomem *)
ioremap(iomem->start, sizeof(usbh_hsic_data.ctrl_regs));
if (!usbh_hsic_data.ctrl_regs) {
dev_err(&pdev->dev, "failed to remap registers\n");
ret = -ENOMEM;
goto err_free_mem_region;
}
platform_set_drvdata(pdev, &usbh_hsic_data);
bcm_usbhsic_init(0);
printk("Capri USB HSIC Low-Level Driver: Probe completed sucessfully.\n");
return 0;
err_free_mem_region:
release_mem_region(iomem->start, resource_size(iomem));
err_exit:
memset(&usbh_hsic_data, 0, sizeof(usbh_hsic_data));
return ret;
}
/* Does not acknowledge. */
static int
attempt_receive_packet(struct gdb_context *ctx)
{
u8 csum;
u8 received_csum;
u8 ch;
/* Skip over everything up to the first '$' */
while ( (ch = gdb_io_read(ctx)) != '$' )
continue;
csum = 0;
for ( ctx->in_bytes = 0;
ctx->in_bytes < sizeof(ctx->in_buf);
ctx->in_bytes++ )
{
ch = gdb_io_read(ctx);
if ( ch == '#' )
break;
ctx->in_buf[ctx->in_bytes] = ch;
csum += ch;
}
if ( ctx->in_bytes == sizeof(ctx->in_buf) )
{
dbg_printk("WARNING: GDB sent a stupidly big packet.\n");
return -1;
}
ctx->in_buf[ctx->in_bytes] = '\0';
received_csum = char2hex(gdb_io_read(ctx)) * 16 +
char2hex(gdb_io_read(ctx));
return (received_csum == csum) ? 0 : -1;
}
static int
kgdb_get_blocked_state(struct vcpu *p,
struct cpu_user_regs *regs,
struct unw_frame_info *unw)
#endif
{
unsigned long ip;
int count = 0;
#ifndef XEN
unw_init_from_blocked_task(unw, p);
#endif
ip = 0UL;
do {
if (unw_unwind(unw) < 0)
return -1;
unw_get_ip(unw, &ip);
#ifndef XEN
if (!in_sched_functions(ip))
break;
#else
dbg_printk("ip 0x%lx cr_iip 0x%lx\n", ip, regs->cr_iip);
if (ip == regs->cr_iip)
break;
#endif
} while (count++ < 16);
if (!ip)
return -1;
else
return 0;
}
void sec_flip_timer(unsigned long data)
{
struct sec_flip* flip = (struct sec_flip*)data;
dbg_printk("%s\n", __FUNCTION__);
queue_work(flip->wq, &flip->flip_id_det);
}
/*
* Function to initialize USB host related low level hardware including PHY,
* clocks, etc.
*
* TODO: expand support for more than one host in the future if needed
*/
static int bcm_usbhsic_init(unsigned int host_index)
{
int ret;
struct usbh_hsic_priv *drv_hsic_data = &usbh_hsic_data;
struct usbh_cfg *hw_cfg;
dbg_printk("%s: HSIC\n", __func__);
hw_cfg = &drv_hsic_data->hw_cfg;
/* enable clocks */
ret = usbh_hsic_clk_ctrl(drv_hsic_data, 1);
if (ret) {
dev_err(drv_hsic_data->dev,
"unable to enable one of the HSIC clocks\n");
goto err_exit;
}
ret = bcm_usbh_hsic_init(hw_cfg);
if (ret < 0)
goto err_free_gpio;
return 0;
err_free_gpio:
usbh_hsic_clk_ctrl(drv_hsic_data, 0);
err_exit:
return ret;
}
static irqreturn_t sec_flip_irq_handler(int irq, void *_flip)
{
struct sec_flip *flip = _flip;
dbg_printk("%s\n", __FUNCTION__);
/*
val = gpio_get_value_cansleep(flip->gpio);
if(val){ // OPEN
flip_status = 1;
} else{ // CLOSE
flip_status = 0;
samsung_switching_tsp_pre(0, flip_status);
}
printk("[FLIP] %s: val=%d (1:open, 0:close)\n", __func__, val);
wake_lock_timeout(&flip->wlock, 1 * HZ);
*/
samsung_disable_tspInput(); /* do not accept tsp irq before folder open/close complete */
if (flip->timer_debounce)
mod_timer(&flip->flip_timer,
jiffies + msecs_to_jiffies(flip->timer_debounce));
else
queue_work(flip->wq, &flip->flip_id_det );
return IRQ_HANDLED;
}
void
gdb_arch_read_reg(unsigned long regnum, struct cpu_user_regs *regs,
struct gdb_context *ctx)
{
struct gdb_callback_arg arg;
unsigned long reg;
struct pt_fpreg freg;
char buf[16 * 2 + 1];
if (regnum >= NUM_REGS) {
dbg_printk("%s: regnum %ld\n", __func__, regnum);
goto out_err;
}
arg.regs = regs;
arg.regnum = regnum;
arg.reg = ®
arg.freg = &freg;
arg.error = 0;
unw_init_running(&gdb_get_reg_callback, (void*)&arg);
if (arg.error < 0) {
dbg_printk("%s: gdb_get_reg_callback failed\n", __func__);
goto out_err;
}
if (arg.error > 0) {
// notify gdb that this register is not supported.
// see fetch_register_using_p() in gdb/remote.c.
safe_strcpy(buf, "x");
} else if (IA64_FR0_REGNUM <= regnum && regnum <= IA64_FR0_REGNUM + 127) {
snprintf(buf, sizeof(buf), "%.016lx", swab64(freg.u.bits[0]));
snprintf(buf + 16, sizeof(buf) - 16, "%.016lx", swab64(freg.u.bits[1]));
} else {
snprintf(buf, sizeof(buf), "%.016lx", swab64(reg));
}
out:
return gdb_send_reply(buf, ctx);
out_err:
dbg_printk("Register read unsupported regnum = 0x%lx\n", regnum);
safe_strcpy(buf, "E0");
goto out;
}
void mci_sleep(){
dbg_printk("[MCI] in %s...\n",__func__);
mci_dump_structure();
mci_snoop_en(MCI_DISABLE);
mci_write_skip_en(MCI_DISABLE);
mci_write_snoop_early_resp_en(MCI_DISABLE);
mci_write_snoop_outstanding_en(MCI_DISABLE);
//asm volatile("LOOP_2:");
//asm volatile ("mov r0,r0");
////asm volatile("b LOOP_2");
}
static void
gdb_get_reg_callback(struct unw_frame_info* info, void* __arg)
{
struct gdb_callback_arg* arg = (struct gdb_callback_arg*)__arg;
if (kgdb_get_blocked_state(current, arg->regs, info) < 0) {
dbg_printk("%s: kgdb_get_blocked_state failed\n", __func__);
arg->error = -1;
return;
}
//XXX struct ia64_fpreg and struct pt_fpreg are same.
if (kgdb_get_reg(arg->regnum, info, arg->regs, arg->reg,
(struct ia64_fpreg*)arg->freg) < 0) {
dbg_printk("%s: kgdb_get_reg failed\n", __func__);
arg->error = 1;
return;
}
arg->error = 0;
return;
}
static void set_flip_status(struct sec_flip *flip)
{
int val = 0;
val = gpio_get_value_cansleep(flip->gpio);
dbg_printk("%s, val:%d, flip_status:%d\n", __FUNCTION__, val, flip_status);
if (flip_status != val) {
flip_status_before = flip_status;
flip_status = val ? FLIP_OPEN : FLIP_CLOSE;
}
}
static void sec_report_flip_key(struct sec_flip *flip)
{
#if 0 //REPORT_KEY change by yuechun.yao
if (flip_status) {
input_report_key(flip->input, KEY_FOLDER_OPEN, 1);
input_report_key(flip->input, KEY_FOLDER_OPEN, 0);
input_sync(flip->input);
dbg_printk("[FLIP] %s: input flip key : open\n", __FUNCTION__);
} else {
input_report_key(flip->input, KEY_FOLDER_CLOSE, 1);
input_report_key(flip->input, KEY_FOLDER_CLOSE, 0);
input_sync(flip->input);
dbg_printk ("[FLIP] %s: input flip key : close\n", __FUNCTION__);
}
#else
if (flip_status) {
if(flip_status_before == flip_status) {
input_report_switch(flip->input, SW_LID, 1);
dbg_printk("[FLIP] %s: force 1 upload : open\n", __FUNCTION__);
}
input_report_switch(flip->input, SW_LID, 0);
input_sync(flip->input);
dbg_printk("[FLIP] %s: input flip key : open\n", __FUNCTION__);
} else {
if(flip_status_before == flip_status) {
input_report_switch(flip->input, SW_LID, 0);
dbg_printk("[FLIP] %s: force 0 upload : close\n", __FUNCTION__);
}
input_report_switch(flip->input, SW_LID, 1);
input_sync(flip->input);
dbg_printk ("[FLIP] %s: input flip key : close\n", __FUNCTION__);
}
#endif
}
static
int merge_point_add_check(struct mp_table *mp_table, unsigned long target_pc,
const struct vstack *stack)
{
struct mp_node *mp_node;
unsigned long hash = jhash_1word(target_pc, 0);
struct hlist_head *head;
struct mp_node *lookup_node;
int found = 0;
dbg_printk("Filter: adding merge point at offset %lu, hash %lu\n",
target_pc, hash);
mp_node = kzalloc(sizeof(struct mp_node), GFP_KERNEL);
if (!mp_node)
return -ENOMEM;
mp_node->target_pc = target_pc;
memcpy(&mp_node->stack, stack, sizeof(mp_node->stack));
head = &mp_table->mp_head[hash & (MERGE_POINT_TABLE_SIZE - 1)];
lttng_hlist_for_each_entry(lookup_node, head, node) {
if (lttng_hash_match(lookup_node, target_pc)) {
found = 1;
break;
}
}
if (found) {
/* Key already present */
dbg_printk("Filter: compare merge points for offset %lu, hash %lu\n",
target_pc, hash);
kfree(mp_node);
if (merge_points_compare(stack, &lookup_node->stack)) {
printk(KERN_WARNING "Merge points differ for offset %lu\n",
target_pc);
return -EINVAL;
}
} else {
hlist_add_head(&mp_node->node, head);
}
return 0;
}
static int sec_flip_resume(struct device *dev)
{
struct sec_flip *flip = dev_get_drvdata(dev);
dbg_printk("[FLIP]%s:\n", __func__);
if (device_may_wakeup(dev)) {
disable_irq_wake(flip->irq);
printk(KERN_INFO "[FLIP]%s: disable_irq_wake\n", __func__);
}
return 0;
}
/*****************************************************************************
* MODULE : sizrot2_ioctl
* FUNCTION : IOCTL main function
* RETURN : 0 : success
* : negative : fail
* NOTE : none
******************************************************************************/
int sizrot2_ioctl(struct inode *inode, struct file *file, unsigned int request,
unsigned long arg)
{
int ret = 0;
unsigned int minor = MINOR(inode->i_rdev);
dbg_printk((_DEBUG_SIZROT2 & 0x01),
" @sizrot2: sizrot2_ioctl() <requset = 0x%x>\n", request);
dbg_printk((_DEBUG_SIZROT2 & 0x01),
" MINOR(inode->i_rdev): %d\n", MINOR(inode->i_rdev));
if (minor == DEV_MINOR_SIZ)
ret = siz_ioctl(inode, file, request, arg);
else if (minor == DEV_MINOR_ROT0)
ret = rot2_ioctl(inode, file, request, arg);
else
ret = -EINVAL;
dbg_printk((_DEBUG_SIZROT2 & 0x02),
"sizrot2_ioctl() <end> return (%d)\n", ret);
return ret;
}
static void mci_setup(struct MCI_CONF conf){
dbg_printk("[MCI] in %s...\n",__func__);
smp_inner_dcache_flush_all();
mci_conf.mci_write_skip = conf.mci_write_skip;
mci_conf.mci_write_snoop_early_resp = conf.mci_write_snoop_early_resp;
mci_conf.mci_write_snoop_outstanding = conf.mci_write_snoop_outstanding;
mci_conf.mci_bar = conf.mci_bar;
mci_conf.mci_snoop = conf.mci_snoop;
mci_write_skip_en(conf.mci_write_skip);
mci_write_snoop_early_resp_en(conf.mci_write_snoop_early_resp);
mci_write_snoop_outstanding_en(conf.mci_write_snoop_outstanding);
mci_snoop_en(conf.mci_snoop);
}
void
gdb_write_to_packet_hex(unsigned long x, int int_size, struct gdb_context *ctx)
{
char buf[sizeof(unsigned long) * 2 + 1];
int i, width = int_size * 2;
buf[sizeof(unsigned long) * 2] = 0;
switch ( int_size )
{
case sizeof(u8):
case sizeof(u16):
case sizeof(u32):
case sizeof(u64):
break;
default:
dbg_printk("WARNING: %s x: 0x%lx int_size: %d\n",
__func__, x, int_size);
break;
}
#ifdef __BIG_ENDIAN
i = sizeof(unsigned long) * 2
do {
buf[--i] = hex2char(x & 15);
x >>= 4;
} while ( x );
while ( (i + width) > (sizeof(unsigned long) * 2) )
buf[--i] = '0';
gdb_write_to_packet(&buf[i], width, ctx);
#elif defined(__LITTLE_ENDIAN)
i = 0;
while ( i < width )
{
buf[i++] = hex2char(x>>4);
buf[i++] = hex2char(x);
x >>= 8;
}
gdb_write_to_packet(buf, width, ctx);
#else
# error unknown endian
#endif
}
/* Return 0 if the reply was successfully received, !0 otherwise. */
void
gdb_send_packet(struct gdb_context *ctx)
{
char buf[3];
int count;
snprintf(buf, sizeof(buf), "%.02x\n", ctx->out_csum);
gdb_write_to_packet_char('#', ctx);
gdb_write_to_packet(buf, 2, ctx);
count = 0;
do {
gdb_io_write(ctx->out_buf, ctx->out_offset, ctx);
} while ( !gdb_check_ack(ctx) && (count++ < GDB_RETRY_MAX) );
if ( count == GDB_RETRY_MAX )
dbg_printk("WARNING: %s reached max retry %d\n",
__func__, GDB_RETRY_MAX);
}
void dump_a(unsigned long start, unsigned long size)
{
unsigned long p, n, a, q, ch;
char tmp[64];
p = start;
n = size;
for (a = 0; a < n ; a++) {
q = a % 16;
if (a % 16 == 0) {
dbg_printk("%08X : ", p + a);
}
ch = *((unsigned char*)p + a);
if (q == 7) {
dbg_printk("%02X-", ch);
}
else {
dbg_printk("%02X ", ch);
}
if ((ch >= 0x20)&&(ch < 0x7F)) {
tmp[q] = ch;
tmp[q+1] = 0;
}
else {
tmp[q] = '.';
tmp[q+1] = 0;
}
if (a % 16 == 15) {
dbg_printk(": %s\n", tmp);
}
}
q = a % 16;
if (q != 0) {
q = 16 - q;
while (q-- > 0) {
dbg_printk(" ");
}
dbg_printk(": %s\n", tmp);
}
}
/*
* Function to initialize USB host related low level hardware including PHY,
* clocks, etc.
*
* TODO: expand support for more than one host in the future if needed
*/
int bcm_usbh_init(unsigned int host_index)
{
int i, ret;
u32 tmp;
struct usbh_priv *drv_data = &usbh_data;
struct usbh_cfg *hw_cfg = &drv_data->hw_cfg;
if (atomic_read(&drv_data->probe_done) == 0)
return -ENODEV;
BUG_ON(drv_data->init_cnt < 0);
mutex_lock(&drv_data->lock);
if (++drv_data->init_cnt > 1) {
mutex_unlock(&drv_data->lock);
return 0;
}
/* enable clocks */
ret = usbh_clk_ctrl(drv_data, 1);
if (ret) {
dev_err(drv_data->dev, "unable to enable one of the USBH clocks\n");
goto err_exit;
}
for (i = 0; i < hw_cfg->num_ports; i++) {
struct usbh_port_cfg *port = &hw_cfg->port[i];
if (port->pwr_gpio >= 0) {
ret = gpio_request(port->pwr_gpio, "usbh power");
if (ret < 0)
goto err_free_gpio;
gpio_direction_output(port->pwr_gpio, 0);
/* power enable */
gpio_set_value(port->pwr_gpio, 1);
}
if (port->pwr_flt_gpio >= 0) {
ret = gpio_request(port->pwr_flt_gpio, "usbh power fault");
if (ret < 0)
goto err_free_gpio;
gpio_direction_input(port->pwr_flt_gpio);
}
if (port->reset_gpio >= 0) {
ret = gpio_request(port->reset_gpio, "usbh ulpi reset");
if (ret < 0)
goto err_free_gpio;
gpio_direction_output(port->reset_gpio, 1);
/* now reset the ULPI interface */
mdelay(10);
gpio_set_value(port->reset_gpio, 0);
mdelay(10);
gpio_set_value(port->reset_gpio, 1);
mdelay(10);
}
}
/* configure each port to be in ULPI PHY mode */
tmp = 0;
for (i = 0; i < hw_cfg->num_ports; i++)
tmp |= MODE_PORT_CFG(i, MODE_ULPI_PHY);
writel(tmp, &drv_data->ctrl_regs->mode);
writel(MISC_RESUME_R23_ENABLE | MISC_RESUME_R23_UTMI_PLUS_DISABLE,
&drv_data->ctrl_regs->misc);
writel(STRAP_PWR_STATE_VALID, &drv_data->ctrl_regs->strap_q);
mutex_unlock(&drv_data->lock);
dbg_printk("reg info:\n");
dbg_printk(" Mode: 0x%08x", readl(&drv_data->ctrl_regs->mode));
dbg_printk(" Strap: 0x%08x", readl(&drv_data->ctrl_regs->strap_q));
dbg_printk(" Misc: 0x%08x", readl(&drv_data->ctrl_regs->misc));
return 0;
err_free_gpio:
for (i = 0; i < hw_cfg->num_ports; i++) {
struct usbh_port_cfg *port = &hw_cfg->port[i];
if (port->pwr_gpio >= 0) {
/* disable port power */
gpio_set_value(port->pwr_gpio, 0);
gpio_free(port->pwr_gpio);
}
if (port->pwr_flt_gpio >= 0)
gpio_free(port->pwr_flt_gpio);
if (port->reset_gpio >= 0)
gpio_free(port->reset_gpio);
}
//err_disable_clk:
usbh_clk_ctrl(drv_data, 0);
err_exit:
drv_data->init_cnt--;
mutex_unlock(&drv_data->lock);
return ret;
}
/* trap handler: main entry point */
int
__trap_to_gdb(struct cpu_user_regs *regs, unsigned long cookie)
{
int rc = 0;
unsigned long flags;
if ( gdb_ctx->serhnd < 0 )
{
printk("Debugging connection not set up.\n");
return -EBUSY;
}
/* We rely on our caller to ensure we're only on one processor
* at a time... We should probably panic here, but given that
* we're a debugger we should probably be a little tolerant of
* things going wrong. */
/* We don't want to use a spin lock here, because we're doing
two distinct things:
1 -- we don't want to run on more than one processor at a time,
and
2 -- we want to do something sensible if we re-enter ourselves.
Spin locks are good for 1, but useless for 2. */
if ( !atomic_dec_and_test(&gdb_ctx->running) )
{
printk("WARNING WARNING WARNING: Avoiding recursive gdb.\n");
atomic_inc(&gdb_ctx->running);
return -EBUSY;
}
if ( !gdb_ctx->connected )
{
printk("GDB connection activated.\n");
gdb_arch_print_state(regs);
gdb_ctx->connected = 1;
}
gdb_smp_pause();
local_irq_save(flags);
watchdog_disable();
console_start_sync();
/* Shouldn't really do this, but otherwise we stop for no
obvious reason, which is Bad */
printk("Waiting for GDB to attach...\n");
gdb_arch_enter(regs);
gdb_ctx->signum = gdb_arch_signal_num(regs, cookie);
/* If gdb is already attached, tell it we've stopped again. */
if ( gdb_ctx->currently_attached )
{
gdb_start_packet(gdb_ctx);
gdb_cmd_signum(gdb_ctx);
}
do {
if ( receive_command(gdb_ctx) < 0 )
{
dbg_printk("Error in GDB session...\n");
rc = -EIO;
break;
}
} while ( process_command(regs, gdb_ctx) == 0 );
gdb_smp_resume();
gdb_arch_exit(regs);
console_end_sync();
watchdog_enable();
atomic_inc(&gdb_ctx->running);
local_irq_restore(flags);
return rc;
}
void mci_dump_structure(){
dbg_printk("[MCI] mci_confi:%d,%d,%d,%d,%d\n",mci_conf.mci_write_skip,mci_conf.mci_write_snoop_early_resp,mci_conf.mci_write_snoop_outstanding,mci_conf.mci_bar,mci_conf.mci_snoop);
}
static void tpd_eint_handler(void)
{
tpd_flag = 1 ;
dbg_printk("+++\n");
wake_up_interruptible(&waiter);
}
void
gdb_arch_read_reg(unsigned long regnum, struct cpu_user_regs *regs,
struct gdb_context *ctx)
{
unsigned long reg = IA64_IP_REGNUM;
char buf[9];
int i;
dbg_printk("Register read regnum = 0x%lx\n", regnum);
if (IA64_GR0_REGNUM <= regnum && regnum <= IA64_GR0_REGNUM + 31) {
for (i = 0; i < gr_reg_to_cpu_user_regs_index_max; i++) {
if (gr_reg_to_cpu_user_regs_index[i].reg == regnum) {
reg = *(unsigned long*)(((char*)regs) + gr_reg_to_cpu_user_regs_index[i].ptregoff);
break;
}
}
if (i == gr_reg_to_cpu_user_regs_index_max) {
goto out_err;
}
} else if (IA64_BR0_REGNUM <= regnum && regnum <= IA64_BR0_REGNUM + 7) {
for (i = 0; i < br_reg_to_cpu_user_regs_index_max; i++) {
if (br_reg_to_cpu_user_regs_index[i].reg == regnum) {
reg = *(unsigned long*)(((char*)regs) + br_reg_to_cpu_user_regs_index[i].ptregoff);
break;
}
}
if (i == br_reg_to_cpu_user_regs_index_max) {
goto out_err;
}
} else if (IA64_FR0_REGNUM + 6 <= regnum && regnum <= IA64_FR0_REGNUM + 11) {
for (i = 0; i < fr_reg_to_cpu_user_regs_index_max; i++) {
if (fr_reg_to_cpu_user_regs_index[i].reg == regnum) {
reg = *(unsigned long*)(((char*)regs) + fr_reg_to_cpu_user_regs_index[i].ptregoff);
break;
}
}
if (i == fr_reg_to_cpu_user_regs_index_max) {
goto out_err;
}
} else if (regnum == IA64_CSD_REGNUM) {
reg = regs->ar_csd;
} else if (regnum == IA64_SSD_REGNUM) {
reg = regs->ar_ssd;
} else if (regnum == IA64_PSR_REGNUM) {
reg = regs->cr_ipsr;
} else if (regnum == IA64_IP_REGNUM) {
reg = regs->cr_iip;
} else if (regnum == IA64_CFM_REGNUM) {
reg = regs->cr_ifs;
} else if (regnum == IA64_UNAT_REGNUM) {
reg = regs->ar_unat;
} else if (regnum == IA64_PFS_REGNUM) {
reg = regs->ar_pfs;
} else if (regnum == IA64_RSC_REGNUM) {
reg = regs->ar_rsc;
} else if (regnum == IA64_RNAT_REGNUM) {
reg = regs->ar_rnat;
} else if (regnum == IA64_BSPSTORE_REGNUM) {
reg = regs->ar_bspstore;
} else if (regnum == IA64_PR_REGNUM) {
reg = regs->pr;
} else if (regnum == IA64_FPSR_REGNUM) {
reg = regs->ar_fpsr;
} else if (regnum == IA64_CCV_REGNUM) {
reg = regs->ar_ccv;
} else {
// emul_unat, rfi_pfs
goto out_err;
}
dbg_printk("Register read regnum = 0x%lx, val = 0x%lx\n", regnum, reg);
snprintf(buf, sizeof(buf), "%.08lx", swab64(reg));
out:
return gdb_send_reply(buf, ctx);
out_err:
dbg_printk("Register read unsupported regnum = 0x%lx\n", regnum);
safe_strcpy(buf, "x");
goto out;
}
