static struct net_device *vnet_add_dev(void *priv)
{
int ret;
struct net_device *dev;
DPRINTK(2, "BEGIN\n");
dev = alloc_netdev(0, "pdp%d", vnet_setup);
if (dev == NULL) {
EPRINTK("out of memory\n");
return NULL;
}
dev->ml_priv = priv;
ret = register_netdev(dev);
if (ret != 0) {
EPRINTK("register_netdevice failed: %d\n", ret);
kfree(dev);
return NULL;
}
DPRINTK(2, "END\n");
return dev;
}
static int publish_frontend_name(struct xenbus_device *dev)
{
struct xenbus_transaction tr;
int err;
/* Publish the name of the frontend driver */
do {
err = xenbus_transaction_start(&tr);
if (err != 0) {
EPRINTK("%s: transaction start failed\n", __FUNCTION__);
return err;
}
err = xenbus_printf(tr, dev->nodename, "accel-frontend",
"%s", frontend_name);
if (err != 0) {
EPRINTK("%s: xenbus_printf failed\n", __FUNCTION__);
xenbus_transaction_end(tr, 1);
return err;
}
err = xenbus_transaction_end(tr, 0);
} while (err == -EAGAIN);
if (err != 0) {
EPRINTK("failed to end frontend name transaction\n");
return err;
}
return 0;
}
static int mddi_auo_lcd_on(struct platform_device *pdev)
{
EPRINTK("%s: started.\n", __func__);
#if defined(CONFIG_MACH_MSM7X27_GELATO)
if (system_state == SYSTEM_BOOTING && mddi_auo_pdata->initialized) {
is_lcd_on = TRUE;
#if defined(CONFIG_FB_MSM_MDDI_24BIT)
EPRINTK("%s: mddi_auo_initialize_24bit.\n", __func__);
auo_display_table(mddi_auo_initialize_24bit, sizeof(mddi_auo_initialize_24bit)/sizeof(struct display_table));
#endif
return 0;
}
#endif
// LCD HW Reset
mddi_auo_lcd_panel_poweron();
#if defined(CONFIG_MACH_MSM7X27_THUNDERC) || defined(CONFIG_MACH_MSM7X27_GELATO)
#if defined(CONFIG_FB_MSM_MDDI_24BIT)
auo_display_table(mddi_auo_initialize_24bit_full, sizeof(mddi_auo_initialize_24bit_full)/sizeof(struct display_table));
#else
auo_display_table(mddi_auo_initialize_20110330, sizeof(mddi_auo_initialize_20110330)/sizeof(struct display_table));
#endif
auo_display_table(mddi_auo_display_on, sizeof(mddi_auo_display_on) / sizeof(struct display_table));
#endif
is_lcd_on = TRUE;
return 0;
}
static
int vnic_process_rx_msg(netfront_accel_vnic *vnic,
struct net_accel_msg *msg)
{
int err;
switch (msg->id) {
case NET_ACCEL_MSG_HELLO:
/* Hello, reply with Reply */
DPRINTK("got Hello, with version %.8x\n",
msg->u.hello.version);
BUG_ON(vnic->msg_state != NETFRONT_ACCEL_MSG_NONE);
err = vnic_process_hello_msg(vnic, msg);
if (err == 0)
vnic->msg_state = NETFRONT_ACCEL_MSG_HELLO;
break;
case NET_ACCEL_MSG_SETHW:
/* Hardware info message */
DPRINTK("got H/W info\n");
BUG_ON(vnic->msg_state != NETFRONT_ACCEL_MSG_HELLO);
err = netfront_accel_vi_init(vnic, &msg->u.hw);
if (err == 0)
vnic->msg_state = NETFRONT_ACCEL_MSG_HW;
break;
case NET_ACCEL_MSG_MAPBUF | NET_ACCEL_MSG_REPLY:
VPRINTK("Got mapped buffers back\n");
BUG_ON(vnic->msg_state != NETFRONT_ACCEL_MSG_HW);
err = vnic_add_bufs(vnic, msg);
break;
case NET_ACCEL_MSG_MAPBUF | NET_ACCEL_MSG_REPLY | NET_ACCEL_MSG_ERROR:
/* No buffers. Can't use the fast path. */
EPRINTK("Got mapped buffers error. Cannot accelerate.\n");
BUG_ON(vnic->msg_state != NETFRONT_ACCEL_MSG_HW);
err = -EIO;
break;
case NET_ACCEL_MSG_LOCALMAC:
/* Should be add, remove not currently used */
EPRINTK_ON(!(msg->u.localmac.flags & NET_ACCEL_MSG_ADD));
BUG_ON(vnic->msg_state != NETFRONT_ACCEL_MSG_HW);
err = vnic_process_localmac_msg(vnic, msg);
break;
default:
EPRINTK("Huh? Message code is 0x%x\n", msg->id);
err = -EPROTO;
break;
}
return err;
}
static int pdp_deactivate(pdp_arg_t *pdp_arg, int force)
{
struct pdp_info *dev = NULL;
DPRINTK(2, "BEGIN\n");
DPRINTK(1, "id: %d\n", pdp_arg->id);
if (pdp_arg->id == 1) {
DPRINTK(1, "Channel ID is 1, we will remove the network device (pdp) of channel ID: %d.\n",
pdp_arg->id + g_adjust);
}
else {
DPRINTK(1, "Channel ID: %d\n", pdp_arg->id);
}
pdp_arg->id = pdp_arg->id + g_adjust;
DPRINTK(1, "ID is adjusted, new ID: %d\n", pdp_arg->id);
dev = pdp_get_dev(pdp_arg->id);
if (dev == NULL) {
EPRINTK(1, "not found id: %u\n", pdp_arg->id);
return -EINVAL;
}
if (!force && dev->flags & DEV_FLAG_STICKY) {
EPRINTK(1, "sticky id: %u\n", pdp_arg->id);
return -EACCES;
}
pdp_remove_dev(pdp_arg->id);
if (dev->type == DEV_TYPE_NET) {
DPRINTK(1, "%s(id: %u) network device removed\n",
dev->vn_dev.net->name, dev->id);
vnet_del_dev(dev->vn_dev.net);
} else if (dev->type == DEV_TYPE_SERIAL) {
struct tty_driver * tty_driver = get_tty_driver_by_id(dev);
DPRINTK(1, "%s(id: %u) serial device removed\n",
tty_driver->name, dev->id);
vs_del_dev(dev);
}
kfree(dev);
DPRINTK(2, "END\n");
return 0;
}
void display_table(struct display_table *table, unsigned int count)
{
unsigned int i;
for(i = 0; i < count; i++) {
unsigned reg;
reg = table[i].reg;
switch (reg) {
case REGFLAG_DELAY :
msleep(table[i].count);
EPRINTK("%s() : delay %d msec\n", __func__, table[i].count);
break;
case REGFLAG_END_OF_TABLE :
break;
default:
mddi_host_register_cmds_write32(reg, table[i].count, table[i].val_list, 1, 0, 0);
//EPRINTK("%s: reg : 0x%04X, val : 0x%04X\n", __func__, reg, table[i].val_list[0]);
}
}
}
static inline int dpram_flush_rx(struct file *filp, size_t count)
{
int ret, n = 0;
char *buf;
mm_segment_t oldfs;
DPRINTK(2, "BEGIN\n");
buf = kmalloc(count, GFP_KERNEL);
if (buf == NULL) return -ENOMEM;
while (count) {
dpram_filp->f_flags |= O_NONBLOCK;
oldfs = get_fs(); set_fs(get_ds());
ret = filp->f_op->read(filp, buf + n, count, &filp->f_pos);
set_fs(oldfs);
dpram_filp->f_flags &= ~O_NONBLOCK;
if (ret < 0) {
if (ret == -EAGAIN) continue;
EPRINTK("f_op->read() failed: %d\n", ret);
kfree(buf);
return ret;
}
n += ret;
count -= ret;
}
kfree(buf);
DPRINTK(2, "END\n");
return n;
}
static inline int dpram_read(struct file *filp, void *buf, size_t count)
{
int ret, n = 0;
mm_segment_t oldfs;
DPRINTK(2, "BEGIN\n");
while (count) {
dpram_filp->f_flags |= O_NONBLOCK;
oldfs = get_fs(); set_fs(get_ds());
ret = filp->f_op->read(filp, buf + n, count, &filp->f_pos);
set_fs(oldfs);
dpram_filp->f_flags &= ~O_NONBLOCK;
if (ret < 0) {
if (ret == -EAGAIN) {
continue;
}
EPRINTK("f_op->read() failed: %d\n", ret);
return ret;
}
n += ret;
count -= ret;
DPRINTK(3, "ret : %d, count : %d", ret, count);
}
DPRINTK(2, "END\n");
return n;
}
static void compare_table(struct display_table *table, unsigned int count)
{
unsigned int i;
for(i = 0; i < count; i++) {
unsigned reg;
reg = table[i].reg;
switch (reg) {
case REGFLAG_DELAY :
break;
case REGFLAG_END_OF_TABLE :
break;
default:
mddi_host_register_cmds_write8(reg, table[i].count, table[i].val_list, 0, 0, 0);
// if(table[i].val_list != temp)
EPRINTK("%s: reg : %x, val : %x.\n", __func__, reg, table[i].val_list[0]);
}
}
}
static inline int dpram_write(struct file *filp, const void *buf, size_t count,
int nonblock)
{
int ret, n = 0;
mm_segment_t oldfs;
DPRINTK(2, "BEGIN\n");
while (count) {
if (!dpram_filp) {
DPRINTK(1, "DPRAM not available\n");
return -ENODEV;
}
dpram_filp->f_flags |= O_NONBLOCK;
oldfs = get_fs(); set_fs(get_ds());
ret = filp->f_op->write(filp, buf + n, count, &filp->f_pos);
set_fs(oldfs);
dpram_filp->f_flags &= ~O_NONBLOCK;
if (ret < 0) {
if (ret == -EAGAIN){
continue;
}
EPRINTK("f_op->write() failed: %d\n", ret);
return ret;
}
n += ret;
count -= ret;
}
DPRINTK(2, "END\n");
return n;
}
static int vnet_recv(struct pdp_info *dev, size_t len,int net_id)
{
struct sk_buff *skb;
int ret;
DPRINTK(2, "BEGIN\n");
/* @LDK@ for multiple pdp.. , ex) email & streaming.. by hobac. */
if (!dev) {
return 0;
}
if (!netif_running(dev->vn_dev.net)) {
EPRINTK("%s(id: %u) is not running\n",
dev->vn_dev.net->name, dev->id);
return -ENODEV;
}
skb = alloc_skb(len, GFP_KERNEL);
if (skb == NULL) {
EPRINTK("alloc_skb() failed\n");
return -ENOMEM;
}
ret = dpram_read(dpram_filp, skb->data, len);
if (ret < 0) {
EPRINTK("dpram_read() failed: %d\n", ret);
dev_kfree_skb_any(skb);
return ret;
}
skb_put(skb, ret);
skb->dev = dev->vn_dev.net;
skb->protocol = __constant_htons(ETH_P_IP);
netif_rx(skb);
dev->vn_dev.stats.rx_packets++;
dev->vn_dev.stats.rx_bytes += skb->len;
DPRINTK(2, "END\n");
return 0;
}
static int mddi_hitachi_lcd_on(struct platform_device *pdev)
{
EPRINTK("%s: started.\n", __func__);
#if defined(CONFIG_MACH_MSM7X27_THUNDERG) || defined(CONFIG_MACH_MSM7X27_THUNDERC) || defined(CONFIG_MACH_MSM7X27_THUNDERA)
if (system_state == SYSTEM_BOOTING && mddi_hitachi_pdata->initialized) {
hitachi_workaround();
is_lcd_on = TRUE;
return 0;
}
#endif
// LCD HW Reset
mddi_hitachi_lcd_panel_poweron();
#if defined(CONFIG_MACH_MSM7X27_THUNDERG)
if (lge_bd_rev <= LGE_REV_E) {
EPRINTK("ThunderG ==> lge_bd_rev = %d : 1st LCD initial\n", lge_bd_rev);
display_table(mddi_hitachi_initialize_1st, sizeof(mddi_hitachi_initialize_1st)/sizeof(struct display_table));
display_table(mddi_hitachi_display_on_1st, sizeof(mddi_hitachi_display_on_1st) / sizeof(struct display_table));
} else {
EPRINTK("ThunderG ==> lge_bd_rev = %d : 3rd LCD initial\n", lge_bd_rev);
display_table(mddi_hitachi_initialize_3rd_p500, sizeof(mddi_hitachi_initialize_3rd_p500)/sizeof(struct display_table));
display_table(mddi_hitachi_display_on_3rd, sizeof(mddi_hitachi_display_on_3rd) / sizeof(struct display_table));
}
#elif defined(CONFIG_MACH_MSM7X27_THUNDERA)
display_table(mddi_hitachi_initialize_1st,
sizeof(mddi_hitachi_initialize_1st)/sizeof(struct display_table));
display_table(mddi_hitachi_display_on_1st,
sizeof(mddi_hitachi_display_on_1st) / sizeof(struct display_table));
#else
if (lge_bd_rev <= LGE_REV_D) {
EPRINTK("ThunderC ==> lge_bd_rev = %d : 1st LCD initial\n", lge_bd_rev);
display_table(mddi_hitachi_initialize_1st, sizeof(mddi_hitachi_initialize_1st)/sizeof(struct display_table));
display_table(mddi_hitachi_display_on_1st, sizeof(mddi_hitachi_display_on_1st) / sizeof(struct display_table));
} else {
EPRINTK("ThunderC ==> lge_bd_rev = %d : 3rd LCD initial\n", lge_bd_rev);
display_table(mddi_hitachi_initialize_3rd_vs660, sizeof(mddi_hitachi_initialize_3rd_vs660)/sizeof(struct display_table));
display_table(mddi_hitachi_display_on_3rd, sizeof(mddi_hitachi_display_on_3rd) / sizeof(struct display_table));
}
#endif
is_lcd_on = TRUE;
return 0;
}
/* Shutdown remote domain that is misbehaving */
int net_accel_shutdown_remote(int domain)
{
struct sched_remote_shutdown sched_shutdown = {
.domain_id = domain,
.reason = SHUTDOWN_crash
};
EPRINTK("Crashing domain %d\n", domain);
return HYPERVISOR_sched_op(SCHEDOP_remote_shutdown, &sched_shutdown);
}
int net_accel_ungrant_page(grant_ref_t gntref)
{
if (unlikely(gnttab_query_foreign_access(gntref) != 0)) {
EPRINTK("%s: remote domain still using grant %d\n", __FUNCTION__,
gntref);
return -EBUSY;
}
gnttab_end_foreign_access(gntref, 0);
return 0;
}
/* Name : icp_ocfDrvFreeLACSession
*
* Description : This attempts to deregister a LAC session. If it fails, the
* deregistation retry function is called.
*/
int icp_ocfDrvFreeLACSession(icp_device_t dev, uint64_t sid)
{
CpaCySymSessionCtx sessionToDeregister = NULL;
struct icp_drvSessionData *sessionData = NULL;
CpaStatus lacStatus = CPA_STATUS_SUCCESS;
int retval = 0;
sessionData = (struct icp_drvSessionData *)CRYPTO_SESID2LID(sid);
if (NULL == sessionData) {
EPRINTK("%s(): OCF Free session called with Null Session ID.\n",
__FUNCTION__);
return EINVAL;
}
sessionToDeregister = sessionData->sessHandle;
if ((ICP_SESSION_INITIALISED != sessionData->inUse) &&
(ICP_SESSION_RUNNING != sessionData->inUse) &&
(ICP_SESSION_DEREGISTERED != sessionData->inUse)) {
DPRINTK("%s() Session not initialised.\n", __FUNCTION__);
return EINVAL;
}
if (ICP_SESSION_RUNNING == sessionData->inUse) {
lacStatus = cpaCySymRemoveSession(CPA_INSTANCE_HANDLE_SINGLE,
sessionToDeregister);
if (CPA_STATUS_RETRY == lacStatus) {
if (ICP_OCF_DRV_STATUS_SUCCESS !=
icp_ocfDrvDeregRetry(&sessionToDeregister)) {
/* the retry function increments the
dereg failed count */
DPRINTK("%s(): LAC failed to deregister the "
"session. (localSessionId= %p)\n",
__FUNCTION__, sessionToDeregister);
retval = EPERM;
}
} else if (CPA_STATUS_SUCCESS != lacStatus) {
DPRINTK("%s(): LAC failed to deregister the session. "
"localSessionId= %p, lacStatus = %d\n",
__FUNCTION__, sessionToDeregister, lacStatus);
icp_atomic_inc(&lac_session_failed_dereg_count);
retval = EPERM;
}
} else {
DPRINTK("%s() Session not registered with LAC.\n",
__FUNCTION__);
}
icp_ocfDrvFreeOCFSession(sessionData);
return retval;
}
static inline int pdp_add_dev(struct pdp_info *dev)
{
int slot;
DPRINTK(2, "BEGIN\n");
if (pdp_get_dev(dev->id)) {
EPRINTK("pdp_add_dev() Error ..%d already exist \n", dev->id);
return -EBUSY;
}
for (slot = 0; slot < MAX_PDP_CONTEXT; slot++) {
if (pdp_table[slot] == NULL) {
pdp_table[slot] = dev;
DPRINTK(2, "END\n");
return slot;
}
}
EPRINTK("pdp_add_dev() Error ..%d There is no space to make %d \n", dev->id);
return -ENOSPC;
}
static void mddi_novatek_lcd_panel_poweroff(void)
{
struct msm_panel_novatek_pdata *pdata = mddi_novatek_pdata;
EPRINTK("%s: started.\n", __func__);
fb_width = 320;
fb_height = 480;
if(pdata && pdata->gpio) {
gpio_set_value(pdata->gpio, 0);
mdelay(10);
}
}
static int __init mddi_novatek_lcd_probe(struct platform_device *pdev)
{
int ret;
EPRINTK("%s: started.\n", __func__);
if (pdev->id == 0) {
mddi_novatek_pdata = pdev->dev.platform_data;
return 0;
}
msm_fb_add_device(pdev);
ret = device_create_file(&pdev->dev, &dev_attr_lcd_onoff);
return 0;
}
static int mddi_auo_lcd_probe(struct platform_device *pdev)
{
int ret;
EPRINTK("%s: started.\n", __func__);
if (pdev->id == 0) {
mddi_auo_pdata = pdev->dev.platform_data;
return 0;
}
msm_fb_add_device(pdev);
/* LGE_CHANGE [[email protected]] 2010-08-28, probe LCD */
ret = device_create_file(&pdev->dev, &dev_attr_lcd_onoff);
return 0;
}
static void mddi_novatek_lcd_panel_poweron(void)
{
struct msm_panel_novatek_pdata *pdata = mddi_novatek_pdata;
EPRINTK("%s: started.\n", __func__);
fb_width = 320;
fb_height = 480;
if(pdata && pdata->gpio) {
gpio_set_value(pdata->gpio, 1);
mdelay(10);
gpio_set_value(pdata->gpio, 0);
mdelay(15); /* wait for more than 10ms */
gpio_set_value(pdata->gpio, 1);
mdelay(30); /* wait for more than 20ms */
}
}
ssize_t mddi_auo_lcd_store_onoff(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
{
struct platform_device *pdev = to_platform_device(dev);
int onoff;
sscanf(buf, "%d", &onoff);
EPRINTK("%s: onoff : %d\n", __func__, onoff);
if(onoff) {
mddi_auo_lcd_on(pdev);
}
else {
mddi_auo_lcd_off(pdev);
}
return count;
}
static int
cfg_frontend_info(struct xenbus_device *dev, struct netback_accel *bend,
int *grants)
{
/* Get some info from xenbus on the event channel and shmem grant */
int err = xenbus_gather(XBT_NIL, dev->otherend,
"accel-msg-channel", "%u", &bend->msg_channel,
"accel-ctrl-page", "%d", &(grants[0]),
"accel-msg-page", "%d", &(grants[1]),
"accel-net-channel", "%u", &bend->net_channel,
NULL);
if (err)
EPRINTK("failed to read event channels or shmem grant: %d\n",
err);
else
DPRINTK("got event chan %d and net chan %d from frontend\n",
bend->msg_channel, bend->net_channel);
return err;
}
/*
* Setup watch on "limits" in the backend vif info to know when
* configuration has been set
*/
static int setup_config_accel_watch(struct xenbus_device *dev,
struct netback_accel *bend)
{
int err;
VPRINTK("Setting watch on %s/%s\n", dev->nodename, "limits");
err = xenbus_watch_path2(dev, dev->nodename, "limits",
&bend->config_accel_watch,
bend_config_accel_change);
if (err) {
EPRINTK("%s: Failed to register xenbus watch: %d\n",
__FUNCTION__, err);
bend->config_accel_watch.node = NULL;
return err;
}
return 0;
}
static void mddi_auo_lcd_panel_store_poweron(void)
{
// struct msm_panel_common_pdata *pdata = mddi_auo_pdata;
struct msm_panel_auo_pdata *pdata = mddi_auo_pdata;
EPRINTK("%s: started.\n", __func__);
fb_width = 320;
fb_height = 480;
if(pdata && pdata->gpio) {
gpio_set_value(pdata->gpio, 1);
mdelay(10);
gpio_set_value(pdata->gpio, 0);
mdelay(20);
gpio_set_value(pdata->gpio, 1);
mdelay(50);
}
}
static int mddi_hitachi_lcd_store_on(void)
{
EPRINTK("%s: started.\n", __func__);
#if defined(CONFIG_MACH_MSM7X27_THUNDERG) || defined(CONFIG_MACH_MSM7X27_THUNDERC) || defined(CONFIG_MACH_MSM7X27_THUNDERA)
if (system_state == SYSTEM_BOOTING && mddi_hitachi_pdata->initialized) {
is_lcd_on = TRUE;
return 0;
}
#endif
// LCD HW Reset
mddi_hitachi_lcd_panel_store_poweron();
#if defined(CONFIG_MACH_MSM7X27_THUNDERG)
if (lge_bd_rev <= LGE_REV_E) {
display_table(mddi_hitachi_initialize_1st, sizeof(mddi_hitachi_initialize_1st)/sizeof(struct display_table));
mdelay(10);
display_table(mddi_hitachi_display_on_1st, sizeof(mddi_hitachi_display_on_1st) / sizeof(struct display_table));
} else {
display_table(mddi_hitachi_initialize_3rd_p500, sizeof(mddi_hitachi_initialize_3rd_p500)/sizeof(struct display_table));
mdelay(10);
display_table(mddi_hitachi_display_on_3rd, sizeof(mddi_hitachi_display_on_3rd) / sizeof(struct display_table));
}
#elif defined(CONFIG_MACH_MSM7X27_THUNDERA)
display_table(mddi_hitachi_initialize_1st,
sizeof(mddi_hitachi_initialize_1st)/sizeof(struct display_table));
mdelay(10);
display_table(mddi_hitachi_display_on_1st,
sizeof(mddi_hitachi_display_on_1st) / sizeof(struct display_table));
#else
if (lge_bd_rev <= LGE_REV_D) {
display_table(mddi_hitachi_initialize_1st, sizeof(mddi_hitachi_initialize_1st)/sizeof(struct display_table));
mdelay(10);
display_table(mddi_hitachi_display_on_1st, sizeof(mddi_hitachi_display_on_1st) / sizeof(struct display_table));
} else {
display_table(mddi_hitachi_initialize_3rd_vs660, sizeof(mddi_hitachi_initialize_3rd_vs660)/sizeof(struct display_table));
mdelay(10);
display_table(mddi_hitachi_display_on_3rd, sizeof(mddi_hitachi_display_on_3rd) / sizeof(struct display_table));
}
#endif
is_lcd_on = TRUE;
return 0;
}
static int vnic_send_buffer_requests(netfront_accel_vnic *vnic,
struct netfront_accel_bufpages *bufpages)
{
int pages, offset, rc = 0, sent = 0;
struct net_accel_msg msg;
while (bufpages->page_reqs < bufpages->max_pages) {
offset = bufpages->page_reqs;
pages = pow2(log2_le(bufpages->max_pages -
bufpages->page_reqs));
pages = pages < NET_ACCEL_MSG_MAX_PAGE_REQ ?
pages : NET_ACCEL_MSG_MAX_PAGE_REQ;
BUG_ON(offset < 0);
BUG_ON(pages <= 0);
rc = netfront_accel_buf_map_request(vnic->dev, bufpages,
&msg, pages, offset);
if (rc == 0) {
rc = net_accel_msg_send(vnic->shared_page,
&vnic->to_dom0, &msg);
if (rc < 0) {
VPRINTK("%s: queue full, stopping for now\n",
__FUNCTION__);
break;
}
sent++;
} else {
EPRINTK("%s: problem with grant, stopping for now\n",
__FUNCTION__);
break;
}
bufpages->page_reqs += pages;
}
if (sent)
net_accel_msg_notify(vnic->msg_channel_irq);
return rc;
}
/* Setup watch on frontend's accelstate */
static int setup_domu_accel_watch(struct xenbus_device *dev,
struct netback_accel *bend)
{
int err;
VPRINTK("Setting watch on %s/%s\n", dev->otherend, "accelstate");
err = xenbus_watch_path2(dev, dev->otherend, "accelstate",
&bend->domu_accel_watch,
bend_domu_accel_change);
if (err) {
EPRINTK("%s: Failed to register xenbus watch: %d\n",
__FUNCTION__, err);
goto fail;
}
return 0;
fail:
bend->domu_accel_watch.node = NULL;
return err;
}
ssize_t mddi_hitachi_lcd_store_onoff(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
{
struct platform_device dummy_pdev;
int onoff; // = simple_strtol(buf, NULL, count);
sscanf(buf, "%d", &onoff);
EPRINTK("%s: onoff : %d\n", __func__, onoff);
if(onoff) {
// display_table(mddi_hitachi_display_on, sizeof(mddi_hitachi_display_on) / sizeof(struct display_table));
mddi_hitachi_lcd_store_on();
is_lcd_on = TRUE;
}
else {
// display_table(mddi_hitachi_display_off, sizeof(mddi_hitachi_display_off) / sizeof(struct display_table));
mddi_hitachi_lcd_off(&dummy_pdev);
is_lcd_on = FALSE;
}
return 0;
}
static void mddi_hitachi_lcd_panel_store_poweron(void)
{
#if defined(CONFIG_MACH_MSM7X27_THUNDERG) || defined(CONFIG_MACH_MSM7X27_THUNDERC) || defined(CONFIG_MACH_MSM7X27_THUNDERA)
struct msm_panel_hitachi_pdata *pdata = mddi_hitachi_pdata;
#else
struct msm_panel_common_pdata *pdata = mddi_hitachi_pdata;
#endif
EPRINTK("%s: started.\n", __func__);
fb_width = 320;
fb_height = 480;
if(pdata && pdata->gpio) {
// gpio_set_value(pdata->gpio, 1);
// mdelay(10);
gpio_set_value(pdata->gpio, 0);
//mdelay(50);
gpio_set_value(pdata->gpio, 1);
//mdelay(50);
}
}
static int mddi_novatek_lcd_on(struct platform_device *pdev)
{
EPRINTK("%s: started.\n", __func__);
if(is_lcd_on == -1) {
is_lcd_on = TRUE;
return 0;
}
if (system_state == SYSTEM_BOOTING && mddi_novatek_pdata->initialized) {
is_lcd_on = TRUE;
}
#ifdef CONFIG_MACH_MSM7X27_THUNDERC_SPRINT
ts_set_vreg(1);
#endif
// LCD HW Reset
mddi_novatek_lcd_panel_poweron();
display_table(mddi_novatek_initialize, sizeof(mddi_novatek_initialize)/sizeof(struct display_table));
// display_table(mddi_novatek_display_on, sizeof(mddi_novatek_display_on) / sizeof(struct display_table));
is_lcd_on = TRUE;
return 0;
}
