static int mhl_chip_init(void)
{
/* Read the chip rev ID */
mhl_msm_state->chip_rev_id = mhl_i2c_reg_read(TX_PAGE_L0, 0x04);
pr_debug("MHL: chip rev ID read=[%x]\n", mhl_msm_state->chip_rev_id);
/* Reset the TX chip */
mhl_sii_reset_pin(1);
msleep(20);
mhl_sii_reset_pin(0);
msleep(20);
mhl_sii_reset_pin(1);
/* MHL spec requires a 100 ms wait here. */
msleep(100);
/*
* Need to disable MHL discovery
*/
mhl_init_reg_settings(true);
/*
* Power down the chip to the
* D3 - a low power standby mode
* cable impedance measurement logic is operational
*/
switch_mode(POWER_STATE_D3);
return 0;
}
static int mhl_tx_chip_init(struct mhl_tx_ctrl *mhl_ctrl)
{
uint8_t chip_rev_id = 0x00;
struct i2c_client *client = mhl_ctrl->i2c_handle;
/* Reset the TX chip */
mhl_sii_reset_pin(mhl_ctrl, 0);
msleep(20);
mhl_sii_reset_pin(mhl_ctrl, 1);
/* TX PR-guide requires a 100 ms wait here */
msleep(100);
/* Read the chip rev ID */
chip_rev_id = MHL_SII_PAGE0_RD(0x04);
pr_debug("MHL: chip rev ID read=[%x]\n", chip_rev_id);
mhl_ctrl->chip_rev_id = chip_rev_id;
/*
* Need to disable MHL discovery if
* MHL-USB handshake is implemented
*/
mhl_init_reg_settings(mhl_ctrl, true);
switch_mode(mhl_ctrl, POWER_STATE_D3);
return 0;
}
static int prepare_update(struct handler_priv *priv,
struct img_type *img)
{
int ret;
char msg[128];
int len;
ret = switch_mode(priv->reset.gpiodev, priv->reset.offset,
priv->prog.gpiodev, priv->prog.offset, MODE_PROG);
if (ret < 0) {
return -ENODEV;
}
DEBUG("Using %s", img->device);
priv->fduart = open(img->device, O_RDWR);
if (priv->fduart < 0) {
ERROR("Cannot open UART %s", img->device);
return -ENODEV;
}
set_uart(priv->fduart);
/* No FW data to be sent */
priv->nbytes = 0;
write_msg(priv->fduart, "$PROG;");
len = receive_msg(priv->fduart, msg, sizeof(msg), priv->timeout, priv->debug);
if (len < 0 || strcmp(msg, "$READY;"))
return -EBADMSG;
return 0;
}
/*
* If hardware detected a change in impedance and raised an INTR
* We check the range of this impedance to infer if the connected
* device is MHL or USB and take appropriate actions.
*/
static int mhl_msm_read_rgnd_int(void)
{
uint8_t rgnd_imp;
/*
* DISC STATUS REG 2
* 1:0 RGND
* 00 - open (USB)
* 01 - 2 kOHM (USB)
* 10 - 1 kOHM ***(MHL)**** It's range 800 - 1200 OHM from MHL spec
* 11 - short (USB)
*/
rgnd_imp = (mhl_i2c_reg_read(TX_PAGE_3, 0x001C) & (BIT1 | BIT0));
pr_debug("Imp Range read = %02X\n", (int)rgnd_imp);
if (0x02 == rgnd_imp) {
pr_debug("MHL: MHL DEVICE!!!\n");
mhl_i2c_reg_modify(TX_PAGE_3, 0x0018, BIT0, BIT0);
/*
* Handling the MHL event in driver
*/
mhl_msm_state->mhl_mode = TRUE;
if (notify_usb_online)
notify_usb_online(1);
} else {
pr_debug("MHL: NON-MHL DEVICE!!!\n");
mhl_msm_state->mhl_mode = FALSE;
mhl_i2c_reg_modify(TX_PAGE_3, 0x0018, BIT3, BIT3);
switch_mode(POWER_STATE_D3);
}
complete(&mhl_msm_state->rgnd_done);
return mhl_msm_state->mhl_mode ?
MHL_DISCOVERY_RESULT_MHL : MHL_DISCOVERY_RESULT_USB;
}
void cpu_exec(cpu_t *cpu, exec_reg_t *regs)
{
int i;
for(i = 0; i < regs->nreg; i++){
if (regs->id[i] < N_GPREG){
cpu->regs[regs->id[i]].data = regs->data[i];
} else if (regs->id[i] == REGID_CPSR){
switch_mode(cpu, regs->data[i] & 0x1f);
cpu->cpsr.data = regs->data[i];
} else if (regs->id[i] == REGID_SPSR ){
cpu->spsr.data = regs->data[i];
} else if(regs->id[i] & USER_REGS){
uint8_t reg_id;
reg_id = regs->id[i] & 0x0F;
if(reg_id == 13){
cpu->banked_r13[0].data = regs->data[i];
}else if (reg_id == 14){
cpu->banked_r14[0].data = regs->data[i];
} else if (reg_id >= 8 && (regs->id[i] & FIQ_MODE)){
cpu->usr_regs[reg_id - 8].data = regs->data[i];
} else {
cpu->regs[reg_id].data = regs->data[i];
}
// ERROR("USER_REGS");
}else{
ERROR("Not recognized register");
}
}
}
static int mhl_tx_chip_init(struct mhl_tx_ctrl *mhl_ctrl)
{
uint8_t chip_rev_id = 0x00;
struct i2c_client *client = mhl_ctrl->i2c_handle;
unsigned long flags;
spin_lock_irqsave(&mhl_ctrl->lock, flags);
mhl_ctrl->dwnstream_hpd = 0;
mhl_ctrl->tx_powered_off = false;
spin_unlock_irqrestore(&mhl_ctrl->lock, flags);
/* Reset the TX chip */
mhl_sii_reset_pin(mhl_ctrl, 0);
msleep(20);
mhl_sii_reset_pin(mhl_ctrl, 1);
/* TX PR-guide requires a 100 ms wait here */
msleep(100);
/* Read the chip rev ID */
chip_rev_id = MHL_SII_PAGE0_RD(0x04);
pr_debug("MHL: chip rev ID read=[%x]\n", chip_rev_id);
mhl_ctrl->chip_rev_id = chip_rev_id;
/*
* Need to disable MHL discovery if
* MHL-USB handshake is implemented
*/
mhl_init_reg_settings(mhl_ctrl, true);
switch_mode(mhl_ctrl, POWER_STATE_D3, true);
return 0;
}
static void
keycode_run()
{
for (;;) {
halt();
key_t key;
bool avail;
while ((avail = kb_getkey(&key)) != false) {
if (key.ch) {
tty_printf(
TTY_CONSOLE,
"Keycode: \033[%c]%02x\033[-] meta=%02x '%c'\n",
key.brk == KEYBRK_UP ? 'e' : '2',
key.code,
key.meta,
key.ch);
}
else {
tty_printf(
TTY_CONSOLE,
"Keycode: \033[%c]%02x\033[-] meta=%02x\n",
key.brk == KEYBRK_UP ? 'e' : '2',
key.code,
key.meta);
}
if ((key.brk == KEYBRK_UP) && (key.meta & META_ALT) &&
(key.code == KEY_TAB)) {
switch_mode(&mode_command);
return;
}
}
}
}
int adau17x1_probe(struct device *dev, struct regmap *regmap,
enum adau17x1_type type, void (*switch_mode)(struct device *dev),
const char *firmware_name)
{
struct adau *adau;
if (IS_ERR(regmap))
return PTR_ERR(regmap);
adau = devm_kzalloc(dev, sizeof(*adau), GFP_KERNEL);
if (!adau)
return -ENOMEM;
adau->regmap = regmap;
adau->switch_mode = switch_mode;
adau->type = type;
dev_set_drvdata(dev, adau);
if (firmware_name) {
adau->sigmadsp = devm_sigmadsp_init_regmap(dev, regmap, NULL,
firmware_name);
if (IS_ERR(adau->sigmadsp)) {
dev_warn(dev, "Could not find firmware file: %ld\n",
PTR_ERR(adau->sigmadsp));
adau->sigmadsp = NULL;
}
}
if (switch_mode)
switch_mode(dev);
return 0;
}
static void mhl_msm_connection(struct mhl_tx_ctrl *mhl_ctrl)
{
uint8_t val;
struct i2c_client *client = mhl_ctrl->i2c_handle;
pr_debug("%s: cur st [0x%x]\n", __func__,
mhl_ctrl->cur_state);
if (mhl_ctrl->cur_state == POWER_STATE_D0_MHL) {
/* Already in D0 - MHL power state */
pr_err("%s: cur st not D0\n", __func__);
return;
}
/* spin_lock_irqsave(&mhl_state_lock, flags); */
switch_mode(mhl_ctrl, POWER_STATE_D0_MHL);
/* spin_unlock_irqrestore(&mhl_state_lock, flags); */
MHL_SII_REG_NAME_WR(REG_MHLTX_CTL1, 0x10);
MHL_SII_CBUS_WR(0x07, 0xF2);
/*
* Keep the discovery enabled. Need RGND interrupt
* Possibly chip disables discovery after MHL_EST??
* Need to re-enable here
*/
val = MHL_SII_PAGE3_RD(0x10);
MHL_SII_PAGE3_WR(0x10, val | BIT0);
return;
}
int adau17x1_probe(struct device *dev, struct regmap *regmap,
enum adau17x1_type type, void (*switch_mode)(struct device *dev),
const char *firmware_name)
{
struct adau *adau;
int ret;
if (IS_ERR(regmap))
return PTR_ERR(regmap);
adau = devm_kzalloc(dev, sizeof(*adau), GFP_KERNEL);
if (!adau)
return -ENOMEM;
adau->mclk = devm_clk_get(dev, "mclk");
if (IS_ERR(adau->mclk)) {
if (PTR_ERR(adau->mclk) != -ENOENT)
return PTR_ERR(adau->mclk);
/* Clock is optional (for the driver) */
adau->mclk = NULL;
} else if (adau->mclk) {
adau->clk_src = ADAU17X1_CLK_SRC_PLL_AUTO;
/*
* Any valid PLL output rate will work at this point, use one
* that is likely to be chosen later as well. The register will
* be written when the PLL is powered up for the first time.
*/
ret = adau_calc_pll_cfg(clk_get_rate(adau->mclk), 48000 * 1024,
adau->pll_regs);
if (ret < 0)
return ret;
ret = clk_prepare_enable(adau->mclk);
if (ret)
return ret;
}
adau->regmap = regmap;
adau->switch_mode = switch_mode;
adau->type = type;
dev_set_drvdata(dev, adau);
if (firmware_name) {
adau->sigmadsp = devm_sigmadsp_init_regmap(dev, regmap, NULL,
firmware_name);
if (IS_ERR(adau->sigmadsp)) {
dev_warn(dev, "Could not find firmware file: %ld\n",
PTR_ERR(adau->sigmadsp));
adau->sigmadsp = NULL;
}
}
if (switch_mode)
switch_mode(dev);
return 0;
}
static bool
cmd_switch_to_keycodes()
{
tty_print(TTY_CONSOLE,
"Entering keycode mode. Hit Alt-Tab to exit.\n");
switch_mode(&mode_keycode);
return false;
}
static void mhl_msm_disconnection(void)
{
mhl_i2c_reg_write(TX_PAGE_3, 0x30, 0xD0);
mhl_drive_hpd(HPD_DOWN);
switch_mode(POWER_STATE_D3);
return;
}
void GPO::run()
{
gpo_config_t prev_config;
db_gpo->get((int32_t *)&prev_config.i);
bool state = !prev_config.s.period ?
switch_mode(&prev_config) : blink_mode(&prev_config);
hal->gpio->set(this->GPIOx, this->pin, state);
}
void
display(int signo)
{
int j;
sigset_t set;
struct mode *p;
sigemptyset(&set);
sigaddset(&set, SIGALRM);
sigprocmask(SIG_BLOCK, &set, NULL);
/* Get the load average over the last minute. */
(void)getloadavg(avenrun, sizeof(avenrun) / sizeof(avenrun[0]));
(*curmode->c_fetch)();
if (curmode->c_flags & CF_LOADAV) {
j = 5.0*avenrun[0] + 0.5;
dellave -= avenrun[0];
if (dellave >= 0.0)
c = '<';
else {
c = '>';
dellave = -dellave;
}
if (dellave < 0.1)
c = '|';
dellave = avenrun[0];
wmove(wload, 0, 0);
wclrtoeol(wload);
whline(wload, c, (j > 50) ? 50 : j);
if (j > 50)
wprintw(wload, " %4.1f", avenrun[0]);
}
(*curmode->c_refresh)();
if (curmode->c_flags & CF_LOADAV)
wrefresh(wload);
wrefresh(wnd);
move(CMDLINE, col);
refresh();
if (allflag && signo==SIGALRM) {
if (allcounter >= turns){
p = curmode;
p++;
if (p->c_name == NULL)
p = modes;
switch_mode(p);
allcounter=0;
} else
allcounter++;
}
sigprocmask(SIG_UNBLOCK, &set, NULL);
alarm(naptime);
}
static int finish_update(struct handler_priv *priv)
{
int ret;
close(priv->fduart);
ret = switch_mode(priv->reset.gpiodev, priv->reset.offset,
priv->prog.gpiodev, priv->prog.offset, MODE_NORMAL);
if (ret < 0) {
return -ENODEV;
}
return 0;
}
static void mhl_msm_disconnection(struct mhl_tx_ctrl *mhl_ctrl)
{
struct i2c_client *client = mhl_ctrl->i2c_handle;
/*
* MHL TX CTL1
* Disabling Tx termination
*/
MHL_SII_PAGE3_WR(0x30, 0xD0);
switch_mode(mhl_ctrl, POWER_STATE_D3);
return;
}
static void run_basic_tests(struct userdata *u) {
/* Subscribe to updates. Note that "alg_b" wants full updates. */
meego_parameter_request_updates("alg_a", (pa_hook_cb_t)parameters_changed_cb, PA_HOOK_NORMAL, FALSE, &u->alg_a);
meego_parameter_request_updates("alg_b", (pa_hook_cb_t)parameters_changed_cb, PA_HOOK_NORMAL, TRUE, &u->alg_b);
meego_parameter_request_updates("alg_c", (pa_hook_cb_t)parameters_changed_cb, PA_HOOK_NORMAL, FALSE, &u->alg_c);
disable_algs(u);
/* Shuffle the modes around a bit to verify correct parameters and status enums */
switch_mode(u, "mode_a");
verify(&u->alg_a, "mode_a", "set_a1_parameters", MEEGO_PARAM_UPDATE);
verify(&u->alg_b, "mode_a", "set_b1_parameters", MEEGO_PARAM_UPDATE);
switch_mode(u, "mode_b");
verify(&u->alg_a, "mode_b", "set_a2_parameters", MEEGO_PARAM_UPDATE);
verify(&u->alg_b, "mode_b", NULL, MEEGO_PARAM_MODE_CHANGE);
switch_mode(u, "mode_c");
verify(&u->alg_a, "mode_c", "set_a3_parameters", MEEGO_PARAM_UPDATE);
verify(&u->alg_b, "mode_c", "set_b2_parameters", MEEGO_PARAM_UPDATE);
switch_mode(u, "mode_d");
verify(&u->alg_a, "mode_d", NULL, MEEGO_PARAM_DISABLE);
verify(&u->alg_b, "mode_d", NULL, MEEGO_PARAM_DISABLE);
verify(&u->alg_c, "mode_d", "set_c1_parameters", MEEGO_PARAM_UPDATE);
switch_mode(u, "mode_c");
verify(&u->alg_a, "mode_c", NULL, MEEGO_PARAM_ENABLE);
verify(&u->alg_b, "mode_c", NULL, MEEGO_PARAM_ENABLE);
verify(&u->alg_c, "mode_c", NULL, MEEGO_PARAM_DISABLE);
disable_algs(u); /* -> mode_reset2 */
/* Stop updates to verify that it's really working */
meego_parameter_stop_updates("alg_a", (pa_hook_cb_t)parameters_changed_cb, &u->alg_a);
meego_parameter_stop_updates("alg_b", (pa_hook_cb_t)parameters_changed_cb, &u->alg_b);
meego_parameter_stop_updates("alg_c", (pa_hook_cb_t)parameters_changed_cb, &u->alg_c);
/* This mode switch should now have no effect */
switch_mode(u, "mode_a");
verify(&u->alg_a, "mode_reset2", NULL, MEEGO_PARAM_DISABLE);
verify(&u->alg_b, "mode_reset2", NULL, MEEGO_PARAM_DISABLE);
verify(&u->alg_c, "mode_reset2", NULL, MEEGO_PARAM_DISABLE);
/* This should cause updates to mode_a */
meego_parameter_request_updates("alg_a", (pa_hook_cb_t)parameters_changed_cb, PA_HOOK_NORMAL, FALSE, &u->alg_a);
meego_parameter_request_updates("alg_b", (pa_hook_cb_t)parameters_changed_cb, PA_HOOK_NORMAL, TRUE, &u->alg_b);
meego_parameter_request_updates("alg_c", (pa_hook_cb_t)parameters_changed_cb, PA_HOOK_NORMAL, FALSE, &u->alg_c);
verify(&u->alg_a, "mode_a", "set_a1_parameters", MEEGO_PARAM_UPDATE);
verify(&u->alg_b, "mode_a", "set_b1_parameters", MEEGO_PARAM_UPDATE);
verify(&u->alg_c, "mode_a", NULL, MEEGO_PARAM_DISABLE);
meego_parameter_stop_updates("alg_a", (pa_hook_cb_t)parameters_changed_cb, &u->alg_a);
meego_parameter_stop_updates("alg_b", (pa_hook_cb_t)parameters_changed_cb, &u->alg_b);
meego_parameter_stop_updates("alg_c", (pa_hook_cb_t)parameters_changed_cb, &u->alg_c);
disable_algs(u);
}
static void mhl_msm_disconnection(struct mhl_tx_ctrl *mhl_ctrl)
{
struct i2c_client *client = mhl_ctrl->i2c_handle;
unsigned long flags;
spin_lock_irqsave(&mhl_ctrl->lock, flags);
mhl_ctrl->dwnstream_hpd &= ~BIT6;
spin_unlock_irqrestore(&mhl_ctrl->lock, flags);
/* disabling Tx termination */
MHL_SII_REG_NAME_WR(REG_MHLTX_CTL1, 0xD0);
switch_mode(mhl_ctrl, POWER_STATE_D3, true);
}
bool osg_ghost_switch_t::handle( const osgGA::GUIEventAdapter& event, osgGA::GUIActionAdapter& action)
{
bool handled = false;
if (event.getEventType() == osgGA::GUIEventAdapter::KEYDOWN
&& event.getKey() == 'g' )
{
switch_mode((scene_mode_t)(mode+1));
handled = true;
}
return handled;
}
static void mhl_msm_disconnection(void)
{
/*
* MHL TX CTL1
* Disabling Tx termination
*/
mhl_i2c_reg_write(TX_PAGE_3, 0x30, 0xD0);
/* Change HPD line to drive it low */
mhl_drive_hpd(HPD_DOWN);
/* switch power state to D3 */
switch_mode(POWER_STATE_D3);
return;
}
void end_stats()
{
time_marker now;
while (now.diff_time(&stat_show_start)<2)
now.get_time();
view *f=player_list;
for (;f;f=f->next)
f->kills=0;
fade_out(8);
switch_mode(VMODE_320x200);
pal->load();
stat_man=old_stat;
}
void net_status_manager::push(char *name, visual_object *show)
{
level++;
first=new net_status_node(name,show,first);
if (level==1)
{
screen->clear();
update_dirty(screen); // make sure the screen is actually clear before we mess with the palette
// save a copy of the old palette
if (pal)
old_pal=pal->copy();
else old_pal=0;
bFILE *fp=open_file(g_file,"rb");
if (fp->open_failure())
{
dprintf("Unable to open art/status.spe\n");
exit(0);
}
old_xres=xres;
switch_mode(VMODE_640x480);
spec_directory sd(fp);
spec_entry *se=sd.find(SPEC_PALETTE); // find the palette used by this screen
fp->seek(se->offset,0);
palette new_pal(fp);
new_pal.load();
delete fp;
// now load the status image direct into our back buffer so that
// another image is not allocated
int x,y;
load_image_into_screen(g_file,"status",x,y);
xp=x; yp=y;
// cash.img(cash.reg("art/status.spe","status", SPEC_IMAGE,1))->put_image(screen,0,0);
// xp=0;
// yp=0;
update_dirty(screen);
}
}
void net_status_manager::pop()
{
// return;
level--;
if (level==0)
{
screen->clear();
update_dirty(screen);
if (old_xres<=320)
switch_mode(VMODE_320x200);
if (eh)
{
event e,*ev=new event;
ev->type=EV_REDRAW;
ev->redraw.x1=0;
ev->redraw.y1=0;
ev->redraw.x2=xres;
ev->redraw.y2=yres;
eh->push_event(ev);
eh->get_event(e); // cause the window manager to process this event
}
if (old_pal)
{
old_pal->load();
delete old_pal;
}
}
net_status_node *p=first;
first=first->next;
delete p;
if (level==0)
{
}
}
static int mhl_chip_init(void)
{
mhl_msm_state->chip_rev_id = mhl_i2c_reg_read(TX_PAGE_L0, 0x04);
pr_debug("MHL: chip rev ID read=[%x]\n", mhl_msm_state->chip_rev_id);
mhl_sii_reset_pin(1);
msleep(20);
mhl_sii_reset_pin(0);
msleep(20);
mhl_sii_reset_pin(1);
msleep(100);
mhl_init_reg_settings(true);
switch_mode(POWER_STATE_D3);
return 0;
}
static void mhl_msm_connection(struct mhl_tx_ctrl *mhl_ctrl)
{
uint8_t val;
struct i2c_client *client = mhl_ctrl->i2c_handle;
pr_debug("%s: cur st [0x%x]\n", __func__,
mhl_ctrl->cur_state);
if (mhl_ctrl->cur_state == POWER_STATE_D0_MHL) {
/* Already in D0 - MHL power state */
pr_err("%s: cur st not D0\n", __func__);
return;
}
switch_mode(mhl_ctrl, POWER_STATE_D0_MHL, true);
MHL_SII_REG_NAME_WR(REG_MHLTX_CTL1, 0x10);
MHL_SII_CBUS_WR(0x07, 0xF2);
/*
* Keep the discovery enabled. Need RGND interrupt
* Possibly chip disables discovery after MHL_EST??
* Need to re-enable here
*/
val = MHL_SII_PAGE3_RD(0x10);
MHL_SII_PAGE3_WR(0x10, val | BIT0);
/*
* indicate DCAP_RDY and DCAP_CHG
* to the peer only after
* msm conn has been established
*/
mhl_msc_send_write_stat(mhl_ctrl,
MHL_STATUS_REG_CONNECTED_RDY,
MHL_STATUS_DCAP_RDY);
mhl_msc_send_set_int(mhl_ctrl,
MHL_RCHANGE_INT,
MHL_INT_DCAP_CHG,
MSC_PRIORITY_SEND);
}
ARM_DynCom::ARM_DynCom(PrivilegeMode initial_mode) {
state = Common::make_unique<ARMul_State>();
ARMul_NewState(state.get());
ARMul_SelectProcessor(state.get(), ARM_v6_Prop | ARM_v5_Prop | ARM_v5e_Prop);
state->abort_model = ABORT_BASE_RESTORED;
state->bigendSig = LOW;
state->lateabtSig = LOW;
state->NirqSig = HIGH;
// Reset the core to initial state
ARMul_Reset(state.get());
state->Emulate = RUN;
// Switch to the desired privilege mode.
switch_mode(state.get(), initial_mode);
state->Reg[13] = 0x10000000; // Set stack pointer to the top of the stack
state->Reg[15] = 0x00000000;
}
static int mhl_msm_read_rgnd_int(struct mhl_tx_ctrl *mhl_ctrl)
{
uint8_t rgnd_imp;
struct i2c_client *client = mhl_ctrl->i2c_handle;
struct msm_hdmi_mhl_ops *hdmi_mhl_ops = mhl_ctrl->hdmi_mhl_ops;
unsigned long flags;
int rc;
spin_lock_irqsave(&mhl_ctrl->lock, flags);
mhl_ctrl->tx_powered_off = false;
spin_unlock_irqrestore(&mhl_ctrl->lock, flags);
/* DISC STATUS REG 2 */
rgnd_imp = (mhl_i2c_reg_read(client, TX_PAGE_3, 0x001C) &
(BIT1 | BIT0));
pr_debug("imp range read=%02X\n", (int)rgnd_imp);
if (0x02 == rgnd_imp) {
pr_debug("%s: mhl sink\n", __func__);
if (hdmi_mhl_ops) {
rc = hdmi_mhl_ops->set_upstream_hpd(
mhl_ctrl->pdata->hdmi_pdev, 1);
pr_debug("%s: hdmi set hpd %s\n", __func__,
rc ? "failed" : "passed");
}
mhl_ctrl->mhl_mode = 1;
power_supply_changed(&mhl_ctrl->mhl_psy);
if (mhl_ctrl->notify_usb_online)
mhl_ctrl->notify_usb_online(1);
} else {
pr_debug("%s: non-mhl sink\n", __func__);
mhl_ctrl->mhl_mode = 0;
switch_mode(mhl_ctrl, POWER_STATE_D3, true);
}
complete(&mhl_ctrl->rgnd_done);
return mhl_ctrl->mhl_mode ?
MHL_DISCOVERY_RESULT_MHL : MHL_DISCOVERY_RESULT_USB;
}
static int mhl_msm_read_rgnd_int(void)
{
uint8_t rgnd_imp;
rgnd_imp = (mhl_i2c_reg_read(TX_PAGE_3, 0x001C) & (BIT1 | BIT0));
pr_debug("Imp Range read = %02X\n", (int)rgnd_imp);
if (0x02 == rgnd_imp) {
pr_debug("MHL: MHL DEVICE!!!\n");
mhl_i2c_reg_modify(TX_PAGE_3, 0x0018, BIT0, BIT0);
mhl_msm_state->mhl_mode = TRUE;
if (notify_usb_online)
notify_usb_online(1);
} else {
pr_debug("MHL: NON-MHL DEVICE!!!\n");
mhl_msm_state->mhl_mode = FALSE;
mhl_i2c_reg_modify(TX_PAGE_3, 0x0018, BIT3, BIT3);
switch_mode(POWER_STATE_D3);
}
complete(&mhl_msm_state->rgnd_done);
return mhl_msm_state->mhl_mode ?
MHL_DISCOVERY_RESULT_MHL : MHL_DISCOVERY_RESULT_USB;
}
static int mhl_msm_read_rgnd_int(struct mhl_tx_ctrl *mhl_ctrl)
{
uint8_t rgnd_imp;
struct i2c_client *client = mhl_ctrl->i2c_handle;
/* DISC STATUS REG 2 */
rgnd_imp = (mhl_i2c_reg_read(client,
TX_PAGE_3, 0x001C) & (BIT1 | BIT0));
pr_debug("imp range read=%02X\n", (int)rgnd_imp);
if (0x02 == rgnd_imp) {
pr_debug("%s: mhl sink\n", __func__);
mhl_ctrl->mhl_mode = 1;
power_supply_changed(&mhl_ctrl->mhl_psy);
if (mhl_ctrl->notify_usb_online)
mhl_ctrl->notify_usb_online(1);
} else {
pr_debug("%s: non-mhl sink\n", __func__);
mhl_ctrl->mhl_mode = 0;
switch_mode(mhl_ctrl, POWER_STATE_D3);
}
complete(&mhl_ctrl->rgnd_done);
return mhl_ctrl->mhl_mode ?
MHL_DISCOVERY_RESULT_MHL : MHL_DISCOVERY_RESULT_USB;
}
static void int_4_isr(void)
{
uint8_t status, reg ;
/* INTR_STATUS4 */
status = mhl_i2c_reg_read(TX_PAGE_3, 0x0021);
/*
* When I2C is inoperational (D3) and
* a previous interrupt brought us here,
* do nothing.
*/
if ((0x00 == status) && (mhl_msm_state->cur_state == POWER_STATE_D3)) {
pr_debug("MHL: spurious interrupt\n");
return;
}
if (0xFF != status) {
if ((status & BIT0) && (mhl_msm_state->chip_rev_id < 1)) {
uint8_t tmds_cstat;
uint8_t mhl_fifo_status;
/* TMDS CSTAT */
tmds_cstat = mhl_i2c_reg_read(TX_PAGE_3, 0x0040);
pr_debug("TMDS CSTAT: 0x%02x\n", tmds_cstat);
if (tmds_cstat & 0x02) {
mhl_fifo_status = mhl_i2c_reg_read(TX_PAGE_3,
0x0023);
pr_debug("MHL FIFO status: 0x%02x\n",
mhl_fifo_status);
if (mhl_fifo_status & 0x0C) {
mhl_i2c_reg_write(TX_PAGE_3, 0x0023,
0x0C);
pr_debug("Apply MHL FIFO Reset\n");
mhl_i2c_reg_write(TX_PAGE_3, 0x0000,
0x94);
mhl_i2c_reg_write(TX_PAGE_3, 0x0000,
0x84);
}
}
}
if (status & BIT1)
pr_debug("MHL: INT4 BIT1 is set\n");
/* MHL_EST interrupt */
if (status & BIT2) {
pr_debug("mhl_msm_connection() from ISR\n");
mhl_connect_api(true);
mhl_msm_connection();
pr_debug("MHL Connect Drv: INT4 Status = %02X\n",
(int) status);
} else if (status & BIT3) {
pr_debug("MHL: uUSB-A type device detected.\n");
mhl_i2c_reg_write(TX_PAGE_3, 0x001C, 0x80);
switch_mode(POWER_STATE_D3);
}
if (status & BIT5) {
mhl_connect_api(false);
/* Clear interrupts - REG INTR4 */
reg = mhl_i2c_reg_read(TX_PAGE_3, 0x0021);
mhl_i2c_reg_write(TX_PAGE_3, 0x0021, reg);
mhl_msm_disconnection();
if (notify_usb_online)
notify_usb_online(0);
pr_debug("MHL Disconnect Drv: INT4 Status = %02X\n",
(int)status);
}
if ((mhl_msm_state->cur_state != POWER_STATE_D0_MHL) &&\
(status & BIT6)) {
/* RGND READY Intr */
switch_mode(POWER_STATE_D0_MHL);
mhl_msm_read_rgnd_int();
}
/* Can't succeed at these in D3 */
if (mhl_msm_state->cur_state != POWER_STATE_D3) {
/* CBUS Lockout interrupt? */
/*
* Hardware detection mechanism figures that
* CBUS line is latched and raises this intr
* where we force usb switch open and release
*/
if (status & BIT4) {
force_usb_switch_open();
release_usb_switch_open();
}
}
}
pr_debug("MHL END Drv: INT4 Status = %02X\n", (int) status);
mhl_i2c_reg_write(TX_PAGE_3, 0x0021, status);
return;
}
