text: /*
   * Copyright (C) 2011 MediaTek, Inc.
   *
   * Author: Holmes Chiou <holmes.chiou@mediatek.com>
   *
   * This software is licensed under the terms of the GNU General Public
   * License version 2, as published by the Free Software Foundation, and
   * may be copied, distributed, and modified under those terms.
   *
   * This program is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   * GNU General Public License for more details.
   *
   */
  #include <linux/module.h>
  #include <linux/kernel.h>
  #include <linux/sched.h>
  #include <linux/kthread.h>
  #include <linux/delay.h>
  #include <linux/uaccess.h>
  #include <linux/io.h>
  #include <linux/platform_device.h>
  #include <linux/miscdevice.h>
  #include <linux/vmalloc.h>
  #include <linux/dma-mapping.h>
  #include <linux/seq_file.h>
  #include "mach/mt_fhreg.h"
  #include "mt_freqhopping_drv.h"
  
  
  #define FREQ_HOPPING_DEVICE "mt-freqhopping"
  #define FH_PLL_COUNT		(g_p_fh_hal_drv->pll_cnt)
  static struct mt_fh_hal_driver *g_p_fh_hal_drv;
  
  static fh_pll_t *g_fh_drv_pll;
  static struct freqhopping_ssc *g_fh_drv_usr_def;
  static unsigned int g_drv_pll_count;
  static int mt_freqhopping_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
  
  #if !defined(DISABLE_FREQ_HOPPING)
  
  static struct miscdevice mt_fh_device = {
  	.minor = MISC_DYNAMIC_MINOR,
  	.name = "mtfreqhopping",
  	/* .fops = &mt_fh_fops, //TODO: Interface for UI maybe in the future... */
  };
  
  static int mt_fh_drv_probe(struct platform_device *dev)
  {
  	int err = 0;
  
  	FH_MSG("EN: mt_fh_probe()");
  
  	err = misc_register(&mt_fh_device);
  	if (err)
  		FH_MSG("register fh driver error!");
  
  	return err;
  }
  
  static int mt_fh_drv_remove(struct platform_device *dev)
  {
  	int err = 0;
  
  	err = misc_deregister(&mt_fh_device);
  	if (err)
  		FH_MSG("deregister fh driver error!");
  
  	return err;
  }
  
  static void mt_fh_drv_shutdown(struct platform_device *dev)
  {
  	FH_MSG("mt_fh_shutdown");
  }
  
  static int mt_fh_drv_suspend(struct platform_device *dev, pm_message_t state)
  {
  /* struct          freqhopping_ioctl fh_ctl; */
  
  	FH_MSG("-supd-");
  
  	return 0;
  }
  
  static int mt_fh_drv_resume(struct platform_device *dev)
  {
  /* struct          freqhopping_ioctl fh_ctl; */
  
  	FH_MSG("+resm+");
  
  	return 0;
  }
  
  
  static struct platform_driver freqhopping_driver = {
  	.probe = mt_fh_drv_probe,
  	.remove = mt_fh_drv_remove,
  	.shutdown = mt_fh_drv_shutdown,
  	.suspend = mt_fh_drv_suspend,
  	.resume = mt_fh_drv_resume,
  	.driver = {
  		   .name = FREQ_HOPPING_DEVICE,
  		   .owner = THIS_MODULE,
  		   },
  };
  #endif
  
  static int mt_fh_enable_usrdef(struct freqhopping_ioctl *fh_ctl)
  {
  	unsigned long flags = 0;
  	const unsigned int pll_id = fh_ctl->pll_id;
  
  	FH_MSG("EN: %s", __func__);
  	FH_MSG("pll_id: %d", fh_ctl->pll_id);
  
  	if (fh_ctl->pll_id < FH_PLL_COUNT) {
  		/* we don't care the PLL status , we just change the flag & update the table */
  		/* the setting will be applied during the following FH enable */
  
  		g_p_fh_hal_drv->mt_fh_lock(&flags);
  		memcpy(&g_fh_drv_usr_def[pll_id], &(fh_ctl->ssc_setting),
  		       sizeof(g_fh_drv_usr_def[pll_id]));
  		g_fh_drv_pll[pll_id].user_defined = true;
  		g_p_fh_hal_drv->mt_fh_unlock(&flags);
  	}
  	/* FH_MSG("Exit"); */
  
  	return 0;
  
  }
  
  static int mt_fh_disable_usrdef(struct freqhopping_ioctl *fh_ctl)
  {
  	unsigned long flags = 0;
  	const unsigned int pll_id = fh_ctl->pll_id;
  
  	FH_MSG("EN: %s", __func__);
  	FH_MSG("id: %d", fh_ctl->pll_id);
  
  	if (fh_ctl->pll_id < FH_PLL_COUNT) {
  		g_p_fh_hal_drv->mt_fh_lock(&flags);
  		memset(&g_fh_drv_usr_def[pll_id], 0, sizeof(g_fh_drv_usr_def[pll_id]));
  		g_fh_drv_pll[pll_id].user_defined = false;
  		g_p_fh_hal_drv->mt_fh_unlock(&flags);
  	}
  	/* FH_MSG("Exit"); */
  
  	return 0;
  }
  
  static int mt_fh_hal_ctrl_lock(struct freqhopping_ioctl *fh_ctl, bool enable)
  {
  	int retVal = 1;
  	unsigned long flags = 0;
  
  	FH_MSG("EN: _fctr_lck %d:%d", fh_ctl->pll_id, enable);
  
  	g_p_fh_hal_drv->mt_fh_lock(&flags);
  	retVal = g_p_fh_hal_drv->mt_fh_hal_ctrl(fh_ctl, enable);
  	g_p_fh_hal_drv->mt_fh_unlock(&flags);
  
  	return retVal;
  }
  
  
  static int mt_freqhopping_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
  {
  	/* Get the structure of ioctl */
  	int ret = 0;
  
  	struct freqhopping_ioctl *freqhopping_ctl = (struct freqhopping_ioctl *)arg;
  
  	FH_MSG("EN:CMD:%d pll id:%d", cmd, freqhopping_ctl->pll_id);
  
  	if (FH_CMD_ENABLE == cmd) {
  		ret = mt_fh_hal_ctrl_lock(freqhopping_ctl, true);
  	} else if (FH_CMD_DISABLE == cmd) {
  		ret = mt_fh_hal_ctrl_lock(freqhopping_ctl, false);
  	} else if (FH_CMD_ENABLE_USR_DEFINED == cmd) {
  		ret = mt_fh_enable_usrdef(freqhopping_ctl);
  	} else if (FH_CMD_DISABLE_USR_DEFINED == cmd) {
  		ret = mt_fh_disable_usrdef(freqhopping_ctl);
  	} else {
  		/* Invalid command is not acceptable!! */
  		WARN_ON(1);
  	}
  
  	/* FH_MSG("Exit"); */
  
  	return ret;
  }
  
  /* static int freqhopping_userdefine_proc_read(char *page, char **start, off_t off, int count, int *eof, void *data) */
  static int freqhopping_userdefine_proc_read(struct seq_file *m, void *v)
  {
  	int i = 0;
  
  	FH_MSG("EN: %s", __func__);
  
  	seq_puts(m, "user defined settings:\n");
  
  	seq_puts(m, "===============================================\r\n");
  	seq_printf(m,
  		   "     freq ==  delta t ==  delta f ==  up bond == low bond ==      dds ==\r\n");
  
  	for (i = 0; i < g_drv_pll_count; ++i) {
  		seq_printf(m, "%10d  0x%08x  0x%08x  0x%08x  0x%08x  0x%08x\r\n",
  			   0, g_fh_drv_usr_def[i].dt, g_fh_drv_usr_def[i].df,
  			   g_fh_drv_usr_def[i].upbnd, g_fh_drv_usr_def[i].lowbnd,
  			   g_fh_drv_usr_def[i].dds);
  	}
  
  	return 0;
  
  }
  
  static ssize_t freqhopping_userdefine_proc_write(struct file *file, const char *buffer,
  						 size_t count, loff_t *data)
  {
  	int ret, n;
  	char kbuf[256];
  	size_t len = 0;
  	unsigned int p1, p2, p3, p4, p5, p6, p7;
  	struct freqhopping_ioctl fh_ctl;
  
  	p1 = p2 = p3 = p4 = p5 = p6 = p7 = 0;
  
  	FH_MSG("EN: %s", __func__);
  
  	len = min(count, (sizeof(kbuf) - 1));
  
  	if (count == 0)
  		return -1;
  	if (count > 255)
  		count = 255;
  
  	ret = copy_from_user(kbuf, buffer, count);
  	if (ret < 0)
  		return -1;
  
  	kbuf[count] = '\0';
  
  	n = sscanf(kbuf, "%x %x %x %x %x %x %x", &p1, &p2, &p3, &p4, &p5, &p6, &p7);
  
  	fh_ctl.pll_id = p2;
  	fh_ctl.ssc_setting.df = p3;
  	fh_ctl.ssc_setting.dt = p4;
  	fh_ctl.ssc_setting.upbnd = p5;
  	fh_ctl.ssc_setting.lowbnd = p6;
  	fh_ctl.ssc_setting.dds = p7;
  	/* fh_ctl.ssc_setting.freq = 0; */
  
  
  	if (p1 == FH_CMD_ENABLE) {
  		ret = mt_fh_enable_usrdef(&fh_ctl);
  
  		if (ret)
  			FH_MSG("__EnableUsrSetting() fail!");
  
  	} else {
  		ret = mt_fh_disable_usrdef(&fh_ctl);
  
  		if (ret)
  			FH_MSG("__DisableUsrSetting() fail!");
  
  	}
  
  	FH_MSG("Exit: %s", __func__);
  	return count;
  }
  
  /* static int freqhopping_status_proc_read(char *page, char **start, off_t off, int count, int *eof, void *data) */
  static int freqhopping_status_proc_read(struct seq_file *m, void *v)
  {
  	int i = 0;
  
  	FH_MSG("EN: %s", __func__);
  
  	seq_puts(m, "FH status:\r\n");
  
  	seq_puts(m, "===============================================\r\n");
  	seq_printf(m,
  		   "id == fh_status == pll_status == setting_id == curr_freq == user_defined ==\r\n");
  
  
  	for (i = 0; i < g_drv_pll_count; ++i) {
  		seq_printf(m, "%2d    %8d      %8d",
  			   i, g_fh_drv_pll[i].fh_status, g_fh_drv_pll[i].pll_status);
  		seq_printf(m, "      %8d     %8d ",
  			   g_fh_drv_pll[i].setting_id, g_fh_drv_pll[i].curr_freq);
  
  		seq_printf(m, "        %d\r\n", g_fh_drv_pll[i].user_defined);
  	}
  	seq_puts(m, "\r\n");
  
  	return 0;
  }
  
  static ssize_t freqhopping_status_proc_write(struct file *file, const char *buffer, size_t count,
  					     loff_t *data)
  {
  	int ret, n;
  	char kbuf[256];
  	size_t len = 0;
  	unsigned int p1, p2, p3, p4, p5, p6;
  	struct freqhopping_ioctl fh_ctl;
  
  	p1 = p2 = p3 = p4 = p5 = p6 = 0;
  
  	FH_MSG("EN: %s", __func__);
  
  	len = min(count, (sizeof(kbuf) - 1));
  
  	if (count == 0)
  		return -1;
  	if (count > 255)
  		count = 255;
  
  	ret = copy_from_user(kbuf, buffer, count);
  	if (ret < 0)
  		return -1;
  
  	kbuf[count] = '\0';
  
  	n = sscanf(kbuf, "%x %x", &p1, &p2);
  
  	fh_ctl.pll_id = p2;
  	fh_ctl.ssc_setting.df = 0;
  	fh_ctl.ssc_setting.dt = 0;
  	fh_ctl.ssc_setting.upbnd = 0;
  	fh_ctl.ssc_setting.lowbnd = 0;
  
  	if (p1 == 0)
  		mt_freqhopping_ioctl(NULL, FH_CMD_DISABLE, (unsigned long)(&fh_ctl));
  	else
  		mt_freqhopping_ioctl(NULL, FH_CMD_ENABLE, (unsigned long)(&fh_ctl));
  
  
  	return count;
  }
  
  /* static int freqhopping_debug_proc_read(char *page, char **start, off_t off, int count, int *eof, void *data) */
  static int freqhopping_debug_proc_read(struct seq_file *m, void *v)
  {
  	FH_IO_PROC_READ_T arg;
  
  	arg.m = m;
  	arg.v = v;
  	arg.pll = g_fh_drv_pll;
  	g_p_fh_hal_drv->ioctl(FH_IO_PROC_READ, &arg);
  	return 0;
  }
  
  static ssize_t freqhopping_debug_proc_write(struct file *file, const char *buffer, size_t count,
  					    loff_t *data)
  {
  	int ret, n;
  	char kbuf[256];
  	size_t len = 0;
  	unsigned int cmd, p1, p2, p3, p4, p5, p6, p7;
  	struct freqhopping_ioctl fh_ctl;
  
  	p1 = p2 = p3 = p4 = p5 = p6 = p7 = 0;
  
  	FH_MSG("EN: %s", __func__);
  
  	len = min(count, (sizeof(kbuf) - 1));
  
  	if (count == 0)
  		return -1;
  	if (count > 255)
  		count = 255;
  
  	ret = copy_from_user(kbuf, buffer, count);
  	if (ret < 0)
  		return -1;
  
  	kbuf[count] = '\0';
  
  	n = sscanf(kbuf, "%x %x %x %x %x %x %x %x", &cmd, &p1, &p2, &p3, &p4, &p5, &p6, &p7);
  
  	fh_ctl.pll_id = p2;
  	fh_ctl.ssc_setting.dds = p3;
  	fh_ctl.ssc_setting.df = p4;
  	fh_ctl.ssc_setting.dt = p5;
  	fh_ctl.ssc_setting.upbnd = p6;
  	fh_ctl.ssc_setting.lowbnd = p7;
  	/* fh_ctl.ssc_setting.freq = 0; */
  
  	if (cmd < FH_CMD_INTERNAL_MAX_CMD)
  		mt_freqhopping_ioctl(NULL, cmd, (unsigned long)(&fh_ctl));
  	else if ((cmd > FH_DCTL_CMD_ID) && (cmd < FH_DCTL_CMD_MAX))
  		mt_freqhopping_devctl(cmd, &fh_ctl);
  	else
  		FH_MSG("CMD error!");
  
  
  	return count;
  }
  
  static int freqhopping_debug_proc_open(struct inode *inode, struct file *file)
  {
  	return single_open(file, freqhopping_debug_proc_read, NULL);
  }
  
  static int freqhopping_dramc_proc_open(struct inode *inode, struct file *file)
  {
  	return single_open(file, g_p_fh_hal_drv->proc.dramc_read, NULL);
  }
  
  static ssize_t freqhopping_dramc_proc_write(struct file *file, const char *buffer, size_t count,
  					    loff_t *data)
  {
  	return (ssize_t) (g_p_fh_hal_drv->proc.dramc_write(file, buffer, count, data));
  }
  
  static int freqhopping_dvfs_proc_open(struct inode *inode, struct file *file)
  {
  	return single_open(file, g_p_fh_hal_drv->proc.dvfs_read, NULL);
  }
  
  static ssize_t freqhopping_dvfs_proc_write(struct file *file, const char *buffer, size_t count,
  					   loff_t *data)
  {
  	return (ssize_t) (g_p_fh_hal_drv->proc.dvfs_write(file, buffer, count, data));
  }
  
  static int freqhopping_dumpregs_proc_open(struct inode *inode, struct file *file)
  {
  	return single_open(file, g_p_fh_hal_drv->proc.dumpregs_read, NULL);
  }
  
  static int freqhopping_status_proc_open(struct inode *inode, struct file *file)
  {
  	return single_open(file, freqhopping_status_proc_read, NULL);
  }
  
  static int freqhopping_userdefine_proc_open(struct inode *inode, struct file *file)
  {
  	return single_open(file, freqhopping_userdefine_proc_read, NULL);
  }
  
  static const struct file_operations freqhopping_debug_fops = {
  	.owner = THIS_MODULE,
  	.open = freqhopping_debug_proc_open,
  	.read = seq_read,
  	.write = freqhopping_debug_proc_write,
  	.release = single_release,
  };
  
  static const struct file_operations dramc_fops = {
  	.owner = THIS_MODULE,
  	.open = freqhopping_dramc_proc_open,
  	.read = seq_read,
  	.write = freqhopping_dramc_proc_write,
  	.release = single_release,
  };
  
  static const struct file_operations dvfs_fops = {
  	.owner = THIS_MODULE,
  	.open = freqhopping_dvfs_proc_open,
  	.read = seq_read,
  	.write = freqhopping_dvfs_proc_write,
  	.release = single_release,
  };
  
  static const struct file_operations dumpregs_fops = {
  	.owner = THIS_MODULE,
  	.open = freqhopping_dumpregs_proc_open,
  	.read = seq_read,
  	.release = single_release,
  };
  
  static const struct file_operations status_fops = {
  	.owner = THIS_MODULE,
  	.open = freqhopping_status_proc_open,
  	.read = seq_read,
  	.write = freqhopping_status_proc_write,
  	.release = single_release,
  };
  
  static const struct file_operations userdef_fops = {
  	.owner = THIS_MODULE,
  	.open = freqhopping_userdefine_proc_open,
  	.read = seq_read,
  	.write = freqhopping_userdefine_proc_write,
  	.release = single_release,
  };
  
  #if !defined(DISABLE_FREQ_HOPPING)
  
  static int freqhopping_debug_proc_init(void)
  {
  	struct proc_dir_entry *prDebugEntry;
  	struct proc_dir_entry *prDramcEntry;
  	struct proc_dir_entry *prDumpregEntry;
  	struct proc_dir_entry *prStatusEntry;
  	struct proc_dir_entry *prUserdefEntry;
  	struct proc_dir_entry *fh_proc_dir = NULL;
  
  	/* TODO: check the permission!! */
  
  	FH_MSG("EN: %s", __func__);
  
  	fh_proc_dir = proc_mkdir("freqhopping", NULL);
  	if (!fh_proc_dir) {
  		FH_MSG("proc_mkdir fail!");
  		return 1;
  	}
  
  	/* /proc/freqhopping/freqhopping_debug */
  	/* prDebugEntry = create_proc_entry("freqhopping_debug",  S_IRUGO | S_IWUSR | S_IWGRP, fh_proc_dir); */
  	prDebugEntry =
  	    proc_create("freqhopping_debug", S_IRUGO | S_IWUSR | S_IWGRP, fh_proc_dir,
  			&freqhopping_debug_fops);
  	if (prDebugEntry) {
  		/* prDebugEntry->read_proc  = freqhopping_debug_proc_read; */
  		/* prDebugEntry->write_proc = freqhopping_debug_proc_write; */
  		FH_MSG("[%s]: successfully create /proc/freqhopping_debug", __func__);
  	} else {
  		FH_MSG("[%s]: failed to create /proc/freqhopping/freqhopping_debug", __func__);
  		return 1;
  	}
  
  
  	/* /proc/freqhopping/dramc */
  	/* prDramcEntry = create_proc_entry("dramc",  S_IRUGO | S_IWUSR | S_IWGRP, fh_proc_dir); */
  	/* prDramcEntry = proc_create("dramc",  S_IRUGO | S_IWUSR | S_IWGRP, fh_proc_dir, &dramc_fops); */
  	/* if(prDramcEntry) */
  	/* { */
  	/* prDramcEntry->read_proc  = g_p_fh_hal_drv->proc.dramc_read; */
  	/* prDramcEntry->write_proc = g_p_fh_hal_drv->proc.dramc_write; */
  	/* FH_MSG("[%s]: successfully create /proc/freqhopping/prDramcEntry", __func__); */
  	/* }else{ */
  	/* FH_MSG("[%s]: failed to create /proc/freqhopping/prDramcEntry", __func__); */
  	/* return 1; */
  	/* } */
  	/* /proc/freqhopping/dvfs */
  	/* prDramcEntry = create_proc_entry("dvfs",  S_IRUGO | S_IWUSR | S_IWGRP, fh_proc_dir); */
  	prDramcEntry = proc_create("dvfs", S_IRUGO | S_IWUSR | S_IWGRP, fh_proc_dir, &dvfs_fops);
  	if (prDramcEntry) {
  		/* prDramcEntry->read_proc  = g_p_fh_hal_drv->proc.dvfs_read; */
  		/* prDramcEntry->write_proc = g_p_fh_hal_drv->proc.dvfs_write; */
  		FH_MSG("[%s]: successfully create /proc/freqhopping/dvfs", __func__);
  	} else {
  		FH_MSG("[%s]: failed to create /proc/freqhopping/dvfs", __func__);
  		return 1;
  	}
  
  
  	/* /proc/freqhopping/dumpregs */
  	/* prDumpregEntry = create_proc_entry("dumpregs",  S_IRUGO | S_IWUSR | S_IWGRP, fh_proc_dir); */
  	prDumpregEntry =
  	    proc_create("dumpregs", S_IRUGO | S_IWUSR | S_IWGRP, fh_proc_dir, &dumpregs_fops);
  	if (prDumpregEntry) {
  		/* prDumpregEntry->read_proc  =  g_p_fh_hal_drv->proc.dumpregs_read; */
  		/* prDumpregEntry->write_proc = NULL; */
  		FH_MSG("[%s]: successfully create /proc/freqhopping/dumpregs", __func__);
  	} else {
  		FH_MSG("[%s]: failed to create /proc/freqhopping/dumpregs", __func__);
  		return 1;
  	}
  
  
  	/* /proc/freqhopping/status */
  	/* prStatusEntry = create_proc_entry("status",  S_IRUGO | S_IWUSR | S_IWGRP, fh_proc_dir); */
  	prStatusEntry =
  	    proc_create("status", S_IRUGO | S_IWUSR | S_IWGRP, fh_proc_dir, &status_fops);
  	if (prStatusEntry) {
  		/* prStatusEntry->read_proc  = freqhopping_status_proc_read; */
  		/* prStatusEntry->write_proc = freqhopping_status_proc_write; */
  		FH_MSG("[%s]: successfully create /proc/freqhopping/status", __func__);
  	} else {
  		FH_MSG("[%s]: failed to create /proc/freqhopping/status", __func__);
  		return 1;
  	}
  
  
  	/* /proc/freqhopping/userdefine */
  	/* prUserdefEntry = create_proc_entry("userdef",  S_IRUGO | S_IWUSR | S_IWGRP, fh_proc_dir); */
  	prUserdefEntry =
  	    proc_create("userdef", S_IRUGO | S_IWUSR | S_IWGRP, fh_proc_dir, &userdef_fops);
  	if (prUserdefEntry) {
  		/* prUserdefEntry->read_proc  = freqhopping_userdefine_proc_read; */
  		/* prUserdefEntry->write_proc = freqhopping_userdefine_proc_write; */
  		FH_MSG("[%s]: successfully create /proc/freqhopping/userdef", __func__);
  	} else {
  		FH_MSG("[%s]: failed to create /proc/freqhopping/userdef", __func__);
  		return 1;
  	}
  
  
  	return 0;
  }
  #endif
  
  #if defined(DISABLE_FREQ_HOPPING)
  void mt_fh_popod_save(void)
  {
  }
  EXPORT_SYMBOL(mt_fh_popod_save);
  
  void mt_fh_popod_restore(void)
  {
  }
  EXPORT_SYMBOL(mt_fh_popod_restore);
  
  int freqhopping_config(unsigned int pll_id, unsigned long vco_freq, unsigned int enable)
  {
  	return 0;
  }
  EXPORT_SYMBOL(freqhopping_config);
  
  int mt_l2h_mempll(void)
  {
  	return 0;
  }
  EXPORT_SYMBOL(mt_l2h_mempll);
  
  int mt_h2l_mempll(void)
  {
  	return 0;
  }
  EXPORT_SYMBOL(mt_h2l_mempll);
  
  int mt_dfs_armpll(unsigned int current_freq, unsigned int target_dds)
  {
  	return 0;
  }
  EXPORT_SYMBOL(mt_dfs_armpll);
  
  int mt_dfs_mmpll(unsigned int target_dds)
  {
  	return 0;
  }
  EXPORT_SYMBOL(mt_dfs_mmpll);
  
  int mt_dfs_vencpll(unsigned int target_dds)
  {
  	return 0;
  }
  EXPORT_SYMBOL(mt_dfs_vencpll);
  
  int mt_dfs_mpll(unsigned int target_dds)
  {
  	return 0;
  }
  EXPORT_SYMBOL(mt_dfs_mpll);
  
  int mt_is_support_DFS_mode(void)
  {
  	return 0;
  }
  EXPORT_SYMBOL(mt_is_support_DFS_mode);
  
  int mt_l2h_dvfs_mempll(void)
  {
  	return 0;
  }
  EXPORT_SYMBOL(mt_l2h_dvfs_mempll);
  
  int mt_h2l_dvfs_mempll(void)
  {
  	return 0;
  }
  EXPORT_SYMBOL(mt_h2l_dvfs_mempll);
  
  int mt_fh_dram_overclock(int clk)
  {
  	return 0;
  }
  EXPORT_SYMBOL(mt_fh_dram_overclock);
  
  int mt_fh_get_dramc(void)
  {
  	return 0;
  }
  EXPORT_SYMBOL(mt_fh_get_dramc);
  
  void mt_freqhopping_init(void)
  {
  }
  EXPORT_SYMBOL(mt_freqhopping_init);
  
  void mt_freqhopping_pll_init(void)
  {
  }
  EXPORT_SYMBOL(mt_freqhopping_pll_init);
  
  int mt_freqhopping_devctl(unsigned int cmd, void *args)
  {
  	return 0;
  }
  EXPORT_SYMBOL(mt_freqhopping_devctl);
  
  #else
  
  void mt_fh_popod_save(void)
  {
  	if (!g_p_fh_hal_drv) {
  		FH_MSG("[%s]: g_p_fh_hal_drv is uninitialized.", __func__);
  		return;
  	}
  	FH_MSG("EN: %s", __func__);
  
  	g_p_fh_hal_drv->mt_fh_popod_save();
  }
  EXPORT_SYMBOL(mt_fh_popod_save);
  
  void mt_fh_popod_restore(void)
  {
  	if (!g_p_fh_hal_drv) {
  		FH_MSG("[%s]: g_p_fh_hal_drv is uninitialized.", __func__);
  		return;
  	}
  
  	FH_MSG("EN: %s", __func__);
  
  	g_p_fh_hal_drv->mt_fh_popod_restore();
  }
  EXPORT_SYMBOL(mt_fh_popod_restore);
  
  int freqhopping_config(unsigned int pll_id, unsigned long vco_freq, unsigned int enable)
  {
  	struct freqhopping_ioctl fh_ctl;
  	unsigned int fh_status;
  	unsigned long flags = 0;
  	unsigned int skip_flag = 0;
  
  	/* FH_MSG("conf() id: %d f: %d, e: %d",(int)pll_id, (int)vco_freq, (int)enable); */
  
  	if ((g_p_fh_hal_drv->mt_fh_get_init()) == 0) {
  		FH_MSG("Not init yet, init first.");
  		return 1;
  	}
  
  	g_p_fh_hal_drv->mt_fh_lock(&flags);
  
  	/* backup */
  	fh_status = g_fh_drv_pll[pll_id].fh_status;
  
  	g_fh_drv_pll[pll_id].curr_freq = vco_freq;
  	g_fh_drv_pll[pll_id].pll_status = (enable > 0) ? FH_PLL_ENABLE : FH_PLL_DISABLE;
  
  
  	/* prepare freqhopping_ioctl */
  	fh_ctl.pll_id = pll_id;
  
  	if (g_fh_drv_pll[pll_id].fh_status != FH_FH_DISABLE) {
  		/* FH_MSG("+fh"); */
  		g_p_fh_hal_drv->mt_fh_hal_ctrl(&fh_ctl, enable);
  
  	} else {
  		skip_flag = 1;
  		/* FH_MSG("-fh,skip"); */
  	}
  
  	/* restore */
  	g_fh_drv_pll[pll_id].fh_status = fh_status;
  
  	g_p_fh_hal_drv->mt_fh_unlock(&flags);
  
  	/* if(skip_flag) */
  	/* FH_MSG("-fh,skip"); */
  
  	return 0;
  }
  EXPORT_SYMBOL(freqhopping_config);
  
  
  int mt_l2h_mempll(void)
  {
  	return g_p_fh_hal_drv->mt_l2h_mempll();
  }
  EXPORT_SYMBOL(mt_l2h_mempll);
  
  int mt_h2l_mempll(void)
  {
  	return g_p_fh_hal_drv->mt_h2l_mempll();
  }
  EXPORT_SYMBOL(mt_h2l_mempll);
  
  int mt_dfs_armpll(unsigned int current_freq, unsigned int target_dds)
  {
  	if (!g_p_fh_hal_drv) {
  		FH_MSG("[%s]: g_p_fh_hal_drv is uninitialized.", __func__);
  		return 1;
  	}
  
  	return g_p_fh_hal_drv->mt_dfs_armpll(current_freq, target_dds);
  }
  EXPORT_SYMBOL(mt_dfs_armpll);
  int mt_dfs_mmpll(unsigned int target_dds)
  {
  	if (!g_p_fh_hal_drv) {
  		FH_MSG("[%s]: g_p_fh_hal_drv is uninitialized.", __func__);
  		return 1;
  	}
  	return g_p_fh_hal_drv->mt_dfs_mmpll(target_dds);
  }
  EXPORT_SYMBOL(mt_dfs_mmpll);
  int mt_dfs_vencpll(unsigned int target_dds)
  {
  	if (!g_p_fh_hal_drv) {
  		FH_MSG("[%s]: g_p_fh_hal_drv is uninitialized.", __func__);
  		return 1;
  	}
  
  	return g_p_fh_hal_drv->mt_dfs_vencpll(target_dds);
  }
  EXPORT_SYMBOL(mt_dfs_vencpll);
  
  int mt_dfs_mpll(unsigned int target_dds)
  {
  	if ((!g_p_fh_hal_drv) || (!g_p_fh_hal_drv->mt_dfs_mpll)) {
  		FH_MSG("[%s]: g_p_fh_hal_drv is uninitialized.", __func__);
  		return 1;
  	}
  
  	return g_p_fh_hal_drv->mt_dfs_mpll(target_dds);
  
  }
  EXPORT_SYMBOL(mt_dfs_mpll);
  
  int mt_dfs_mempll(unsigned int target_dds)
  {
  	if ((!g_p_fh_hal_drv) || (!g_p_fh_hal_drv->mt_dfs_mempll)) {
  		FH_MSG("[%s]: g_p_fh_hal_drv or g_p_fh_hal_drv->mt_dfs_mempll is uninitialized.",
  		       __func__);
  		return 1;
  	}
  
  	return g_p_fh_hal_drv->mt_dfs_mempll(target_dds);
  
  }
  EXPORT_SYMBOL(mt_dfs_mempll);
  
  
  int mt_is_support_DFS_mode(void)
  {
  	return g_p_fh_hal_drv->mt_is_support_DFS_mode();
  }
  EXPORT_SYMBOL(mt_is_support_DFS_mode);
  int mt_l2h_dvfs_mempll(void)
  {
  	if (!g_p_fh_hal_drv) {
  		FH_MSG("[%s]: g_p_fh_hal_drv is uninitialized.", __func__);
  		return 1;
  	}
  	return g_p_fh_hal_drv->mt_l2h_dvfs_mempll();
  }
  EXPORT_SYMBOL(mt_l2h_dvfs_mempll);
  
  int mt_h2l_dvfs_mempll(void)
  {
  	if (!g_p_fh_hal_drv) {
  		FH_MSG("[%s]: g_p_fh_hal_drv is uninitialized.", __func__);
  		return 1;
  	}
  
  	return g_p_fh_hal_drv->mt_h2l_dvfs_mempll();
  }
  EXPORT_SYMBOL(mt_h2l_dvfs_mempll);
  int mt_fh_dram_overclock(int clk)
  {
  	return g_p_fh_hal_drv->mt_dram_overclock(clk);
  }
  EXPORT_SYMBOL(mt_fh_dram_overclock);
  
  int mt_fh_get_dramc(void)
  {
  	return g_p_fh_hal_drv->mt_get_dramc();
  }
  EXPORT_SYMBOL(mt_fh_get_dramc);
  
  void mt_freqhopping_init(void)
  {
  	g_p_fh_hal_drv = mt_get_fh_hal_drv();
  
  	g_p_fh_hal_drv->mt_fh_hal_init();
  
  	g_fh_drv_pll = g_p_fh_hal_drv->fh_pll;
  	g_fh_drv_usr_def = g_p_fh_hal_drv->fh_usrdef;
  	g_drv_pll_count = g_p_fh_hal_drv->pll_cnt;
  
  	freqhopping_debug_proc_init();
  
  	platform_driver_register(&freqhopping_driver);
  
  	mt_freqhopping_pll_init();	/* TODO_HAL: wait for clkmgr to invoke this function */
  }
  EXPORT_SYMBOL(mt_freqhopping_init);
  
  void mt_freqhopping_pll_init(void)
  {
  	g_p_fh_hal_drv->mt_fh_default_conf();
  }
  EXPORT_SYMBOL(mt_freqhopping_pll_init);
  
  int mt_freqhopping_devctl(unsigned int cmd, void *args)
  {
  	if (!g_p_fh_hal_drv)
  		return 1;
  
  	g_p_fh_hal_drv->ioctl(cmd, args);
  	return 0;
  
  }
  EXPORT_SYMBOL(mt_freqhopping_devctl);
  
  #endif
  