/*---------------------------------------------------------------------------*/
static int mt_gpio_remove(struct platform_device *dev)
{
struct mt_gpio_obj_t *obj = platform_get_drvdata(dev);
int err;
if ((err = mt_gpio_delete_attr(obj->misc->this_device)))
GPIOERR("delete attr\n");
if ((err = misc_deregister(obj->misc)))
GPIOERR("deregister gpio\n");
return err;
}
/*----------------------------------------------------------------------------
void mt_gpio_load_ext(GPIOEXT_REGS *regs)
{
GPIOEXT_REGS *pReg = (GPIOEXT_REGS*)(GPIOEXT_BASE);
int idx;
if (!regs)
GPIOERR("%s: null pointer\n", __func__);
memset(regs, 0x00, sizeof(*regs));
for (idx = 0; idx < sizeof(pReg->dir)/sizeof(pReg->dir[0]); idx++)
regs->dir[idx].val = GPIOEXT_RD(&pReg->dir[idx]);
for (idx = 0; idx < sizeof(pReg->pullen)/sizeof(pReg->pullen[0]); idx++)
regs->pullen[idx].val = GPIOEXT_RD(&pReg->pullen[idx]);
for (idx = 0; idx < sizeof(pReg->pullsel)/sizeof(pReg->pullsel[0]); idx++)
regs->pullsel[idx].val =GPIOEXT_RD(&pReg->pullsel[idx]);
for (idx = 0; idx < sizeof(pReg->dinv)/sizeof(pReg->dinv[0]); idx++)
regs->dinv[idx].val =GPIOEXT_RD(&pReg->dinv[idx]);
for (idx = 0; idx < sizeof(pReg->dout)/sizeof(pReg->dout[0]); idx++)
regs->dout[idx].val = GPIOEXT_RD(&pReg->dout[idx]);
for (idx = 0; idx < sizeof(pReg->mode)/sizeof(pReg->mode[0]); idx++)
regs->mode[idx].val = GPIOEXT_RD(&pReg->mode[idx]);
for (idx = 0; idx < sizeof(pReg->din)/sizeof(pReg->din[0]); idx++)
regs->din[idx].val = GPIOEXT_RD(&pReg->din[idx]);
}
EXPORT_SYMBOL(mt_gpio_load_ext);
----------------------------------------------------------------------------*/
void mt_gpio_load_base(GPIO_REGS *regs)
{
GPIO_REGS *pReg = (GPIO_REGS*)(GPIO_BASE_1);
int idx;
if (!regs)
GPIOERR("%s: null pointer\n", __func__);
memset(regs, 0x00, sizeof(*regs));
for (idx = 0; idx < sizeof(pReg->dir)/sizeof(pReg->dir[0]); idx++)
regs->dir[idx].val = __raw_readl(&pReg->dir[idx]);
//for (idx = 0; idx < sizeof(pReg->ies)/sizeof(pReg->ies[0]); idx++)
// regs->ies[idx].val = __raw_readl(&pReg->ies[idx]);
//for (idx = 0; idx < sizeof(pReg->pullen)/sizeof(pReg->pullen[0]); idx++)
// regs->pullen[idx].val = __raw_readl(&pReg->pullen[idx]);
//for (idx = 0; idx < sizeof(pReg->pullsel)/sizeof(pReg->pullsel[0]); idx++)
// regs->pullsel[idx].val =__raw_readl(&pReg->pullsel[idx]);
//for (idx = 0; idx < sizeof(pReg->dinv)/sizeof(pReg->dinv[0]); idx++)
// regs->dinv[idx].val =__raw_readl(&pReg->dinv[idx]);
for (idx = 0; idx < sizeof(pReg->dout)/sizeof(pReg->dout[0]); idx++)
regs->dout[idx].val = __raw_readl(&pReg->dout[idx]);
for (idx = 0; idx < sizeof(pReg->mode)/sizeof(pReg->mode[0]); idx++)
regs->mode[idx].val = __raw_readl(&pReg->mode[idx]);
for (idx = 0; idx < sizeof(pReg->din)/sizeof(pReg->din[0]); idx++)
regs->din[idx].val = __raw_readl(&pReg->din[idx]);
}
/*---------------------------------------------------------------------------*/
int mt_set_gpio_out(unsigned long pin, unsigned long output)
{
if (output >= GPIO_OUT_MAX){
GPIOERR("Parameter output error: %d\n",output);
return -ERINVAL;
}
return MT_GPIO_OPS_SET(pin,set_out,output);
}
/*---------------------------------------------------------------------------*/
int mt_set_gpio_mode(unsigned long pin, unsigned long mode)
{
if (mode >= GPIO_MODE_MAX){
GPIOERR("Parameter mode error: %d\n",mode);
return -ERINVAL;
}
return MT_GPIO_OPS_SET(pin,set_mode,mode);
}
/*---------------------------------------------------------------------------*/
int mt_set_gpio_pull_select(unsigned long pin, unsigned long select)
{
if (select >= GPIO_PULL_MAX){
GPIOERR("Parameter select error: %d\n",select);
return -ERINVAL;
}
return MT_GPIO_OPS_SET(pin,set_pull_select,select);
}
/*---------------------------------------------------------------------------*/
int mt_set_gpio_inversion(unsigned long pin, unsigned long enable)
{
if (enable >= GPIO_DATA_INV_MAX){
GPIOERR("Parameter enable error: %d\n",enable);
return -ERINVAL;
}
return MT_GPIO_OPS_SET(pin,set_inversion,enable);
}
/*---------------------------------------------------------------------------*/
int mt_set_gpio_ies(unsigned long pin, unsigned long enable)
{
if (enable >= GPIO_IES_MAX){
GPIOERR("Parameter enable error: %d\n",enable);
return -ERINVAL;
}
return MT_GPIO_OPS_SET(pin,set_ies,enable);
}
int mt_set_gpio_dir(unsigned long pin, unsigned long dir)
{
//int ret=0;
if (dir >= GPIO_DIR_MAX){
GPIOERR("Parameter dir error: %d\n",dir);
return -ERINVAL;
}
return MT_GPIO_OPS_SET(pin,set_dir,dir);
}
/*---------------------------------------------------------------------------*/
int mt_set_gpio_pull_enable(unsigned long pin, unsigned long enable)
{
if (enable >= GPIO_PULL_EN_MAX){
GPIOERR("Parameter enable error: %d\n",enable);
return -ERINVAL;
}
return MT_GPIO_OPS_SET(pin,set_pull_enable,enable);
}
/*---------------------------------------------------------------------------*/
static int mt_gpio_probe(struct platform_device *dev)
{
int err;
struct miscdevice *misc = &mt_gpio_device;
//printk(KERN_ALERT"[GPIO]%5d,<%s> gpio devices probe\n", __LINE__, __func__);
GPIOLOG("Registering GPIO device\n");
if (!mt_gpio)
GPIO_RETERR(-EACCES, "");
mt_gpio->misc = misc;
if ((err = misc_register(misc)))
GPIOERR("register gpio\n");
if ((err = mt_gpio_create_attr(misc->this_device)))
GPIOERR("create attribute\n");
dev_set_drvdata(misc->this_device, mt_gpio);
return err;
}
/*---------------------------------------------------------------------------*/
static int mt_gpio_release(struct inode *inode, struct file *file)
{
struct mt_gpio_obj_t *obj = mt_gpio;
GPIOFUC();
if (obj == NULL) {
GPIOERR("NULL pointer");
return -EFAULT;
}
atomic_dec(&obj->ref);
return RSUCCESS;
}
static int mt_gpio_open(struct inode *inode, struct file *file)
{
struct mt_gpio_obj_t *obj = mt_gpio;
GPIOFUC();
if (obj == NULL) {
GPIOERR("NULL pointer");
return -EFAULT;
}
atomic_inc(&obj->ref);
file->private_data = obj;
return nonseekable_open(inode, file);
}
int mt_get_clock_output(unsigned long num, unsigned long *src, unsigned long *div)
{
GPIOERR("GPIO CLKM module not be implement any more!\n");
return RSUCCESS;
}
/*---------------------------------------------------------------------------*/
static long mt_gpio_ioctl(struct file *file,
unsigned int cmd, unsigned long arg)
{
struct mt_gpio_obj_t *obj = mt_gpio;
long res;
unsigned long pin;
GPIOFUC();
if (obj == NULL) {
GPIOERR("NULL pointer");
return -EFAULT;
}
switch(cmd)
{
case GPIO_IOCQMODE:
{
pin = (unsigned long)arg;
res = GIO_INVALID_OBJ(obj) ? (-EACCES) : mt_get_gpio_mode(pin);
break;
}
case GPIO_IOCTMODE0:
{
pin = (unsigned long)arg;
res = GIO_INVALID_OBJ(obj) ? (-EACCES) : mt_set_gpio_mode(pin, GPIO_MODE_00);
break;
}
case GPIO_IOCTMODE1:
{
pin = (unsigned long)arg;
res = GIO_INVALID_OBJ(obj) ? (-EACCES) : mt_set_gpio_mode(pin, GPIO_MODE_01);
break;
}
case GPIO_IOCTMODE2:
{
pin = (unsigned long)arg;
res = GIO_INVALID_OBJ(obj) ? (-EACCES) : mt_set_gpio_mode(pin, GPIO_MODE_02);
break;
}
case GPIO_IOCTMODE3:
{
pin = (unsigned long)arg;
res = GIO_INVALID_OBJ(obj) ? (-EACCES) : mt_set_gpio_mode(pin, GPIO_MODE_03);
break;
}
case GPIO_IOCQDIR:
{
pin = (unsigned long)arg;
res = GIO_INVALID_OBJ(obj) ? (-EACCES) : mt_get_gpio_dir(pin);
break;
}
case GPIO_IOCSDIRIN:
{
pin = (unsigned long)arg;
res = GIO_INVALID_OBJ(obj) ? (-EACCES) : mt_set_gpio_dir(pin, GPIO_DIR_IN);
break;
}
case GPIO_IOCSDIROUT:
{
pin = (unsigned long)arg;
res = GIO_INVALID_OBJ(obj) ? (-EACCES) : mt_set_gpio_dir(pin, GPIO_DIR_OUT);
break;
}
case GPIO_IOCQPULLEN:
{
pin = (unsigned long)arg;
res = GIO_INVALID_OBJ(obj) ? (-EACCES) : mt_get_gpio_pull_enable(pin);
break;
}
case GPIO_IOCSPULLENABLE:
{
pin = (unsigned long)arg;
res = GIO_INVALID_OBJ(obj) ? (-EACCES) : mt_set_gpio_pull_enable(pin, TRUE);
break;
}
case GPIO_IOCSPULLDISABLE:
{
pin = (unsigned long)arg;
res = GIO_INVALID_OBJ(obj) ? (-EACCES) : mt_set_gpio_pull_enable(pin, FALSE);
break;
}
case GPIO_IOCQPULL:
{
pin = (unsigned long)arg;
res = GIO_INVALID_OBJ(obj) ? (-EACCES) : mt_get_gpio_pull_select(pin);
break;
}
case GPIO_IOCSPULLDOWN:
{
pin = (unsigned long)arg;
res = GIO_INVALID_OBJ(obj) ? (-EACCES) : mt_set_gpio_pull_select(pin, GPIO_PULL_DOWN);
break;
}
case GPIO_IOCSPULLUP:
{
pin = (unsigned long)arg;
res = GIO_INVALID_OBJ(obj) ? (-EACCES) : mt_set_gpio_pull_select(pin, GPIO_PULL_UP);
break;
}
case GPIO_IOCQINV:
{
pin = (unsigned long)arg;
res = GIO_INVALID_OBJ(obj) ? (-EACCES) : mt_get_gpio_inversion(pin);
break;
}
case GPIO_IOCSINVENABLE:
{
pin = (unsigned long)arg;
res = GIO_INVALID_OBJ(obj) ? (-EACCES) : mt_set_gpio_inversion(pin, TRUE);
break;
}
case GPIO_IOCSINVDISABLE:
{
pin = (unsigned long)arg;
res = GIO_INVALID_OBJ(obj) ? (-EACCES) : mt_set_gpio_inversion(pin, FALSE);
break;
}
case GPIO_IOCQDATAIN:
{
pin = (unsigned long)arg;
res = GIO_INVALID_OBJ(obj) ? (-EFAULT) : mt_get_gpio_in(pin);
break;
}
case GPIO_IOCQDATAOUT:
{
pin = (unsigned long)arg;
res = GIO_INVALID_OBJ(obj) ? (-EACCES) : mt_get_gpio_out(pin);
break;
}
case GPIO_IOCSDATALOW:
{
pin = (unsigned long)arg;
res = GIO_INVALID_OBJ(obj) ? (-EACCES) : mt_set_gpio_out(pin, GPIO_OUT_ZERO);
break;
}
case GPIO_IOCSDATAHIGH:
{
pin = (unsigned long)arg;
res = GIO_INVALID_OBJ(obj) ? (-EACCES) : mt_set_gpio_out(pin, GPIO_OUT_ONE);
break;
}
default:
{
res = -EPERM;
break;
}
}
if (res == -EACCES)
GPIOERR(" cmd = 0x%8X, invalid pointer\n", cmd);
else if (res < 0)
GPIOERR(" cmd = 0x%8X, err = %ld\n", cmd, res);
return res;
}
int mt6306_set_gpio_dir(unsigned long pin, unsigned long dir)
{
GPIOERR("denali not support\n");
return 0;
}
//EXPORT_SYMBOL(mt_gpio_load_base);
void mt_gpio_dump_base(GPIO_REGS *regs)
{
GPIO_REGS *cur = NULL ;
int idx;
GPIOMSG("%s\n", __func__);
if (regs == NULL) { /*if arg is null, load & dump; otherwise, dump only*/
cur = kzalloc(sizeof(*cur), GFP_KERNEL);
if (cur == NULL) {
GPIOERR("null pointer\n");
return;
}
regs = cur;
mt_gpio_load_base(regs);
GPIOMSG("dump current: %p\n", regs);
} else {
GPIOMSG("dump %p ...\n", regs);
}
GPIOMSG("---# dir #-----------------------------------------------------------------\n");
GPIOMSG("Offset 0x%04X\n",(void *)(®s->dir[0])-(void *)regs);
for (idx = 0; idx < sizeof(regs->dir)/sizeof(regs->dir[0]); idx++) {
GPIOMSG("0x%04X ", regs->dir[idx].val);
if (7 == (idx % 8)) GPIOMSG("\n");
}
GPIOMSG("\n---# ies #-----------------------------------------------------------------\n");
GPIOMSG("Offset 0x%04X\n",(void *)(®s->ies[0])-(void *)regs);
for (idx = 0; idx < sizeof(regs->ies)/sizeof(regs->ies[0]); idx++) {
GPIOMSG("0x%04X ", regs->ies[idx].val);
if (7 == (idx % 8)) GPIOMSG("\n");
}
GPIOMSG("\n---# pullen #--------------------------------------------------------------\n");
GPIOMSG("Offset 0x%04X\n",(void *)(®s->pullen[0])-(void *)regs);
for (idx = 0; idx < sizeof(regs->pullen)/sizeof(regs->pullen[0]); idx++) {
GPIOMSG("0x%04X ", regs->pullen[idx].val);
if (7 == (idx % 8)) GPIOMSG("\n");
}
GPIOMSG("\n---# pullsel #-------------------------------------------------------------\n");
GPIOMSG("Offset 0x%04X\n",(void *)(®s->pullsel[0])-(void *)regs);
for (idx = 0; idx < sizeof(regs->pullsel)/sizeof(regs->pullsel[0]); idx++) {
GPIOMSG("0x%04X ", regs->pullsel[idx].val);
if (7 == (idx % 8)) GPIOMSG("\n");
}
GPIOMSG("\n---# dout #----------------------------------------------------------------\n");
GPIOMSG("Offset 0x%04X\n",(void *)(®s->dout[0])-(void *)regs);
for (idx = 0; idx < sizeof(regs->dout)/sizeof(regs->dout[0]); idx++) {
GPIOMSG("0x%04X ", regs->dout[idx].val);
if (7 == (idx % 8)) GPIOMSG("\n");
}
GPIOMSG("\n---# din #----------------------------------------------------------------\n");
GPIOMSG("Offset 0x%04X\n",(void *)(®s->din[0])-(void *)regs);
for (idx = 0; idx < sizeof(regs->din)/sizeof(regs->din[0]); idx++) {
GPIOMSG("0x%04X ", regs->din[idx].val);
if (7 == (idx % 8)) GPIOMSG("\n");
}
GPIOMSG("\n---# mode #----------------------------------------------------------------\n");
GPIOMSG("Offset 0x%04X\n",(void *)(®s->mode[0])-(void *)regs);
for (idx = 0; idx < sizeof(regs->mode)/sizeof(regs->mode[0]); idx++) {
GPIOMSG("0x%04X ", regs->mode[idx].val);
if (7 == (idx % 8)) GPIOMSG("\n");
}
GPIOMSG("\n---------------------------------------------------------------------------\n");
if (cur != NULL) {
kfree(cur);
}
}
void mt_gpio_self_test(void)
{
int i, val;
for (i = 0; i < MT_GPIO_EXT_MAX; i++)
{
s32 res,old;
GPIOMSG("GPIO-%3d test\n", i);
/*direction test*/
old = mt_get_gpio_dir(i);
if (old == 0 || old == 1) {
GPIOLOG(" dir old = %d\n", old);
} else {
GPIOERR(" test dir fail: %d\n", old);
break;
}
if ((res = mt_set_gpio_dir(i, GPIO_DIR_OUT)) != RSUCCESS) {
GPIOERR(" set dir out fail: %d\n", res);
break;
} else if ((res = mt_get_gpio_dir(i)) != GPIO_DIR_OUT) {
GPIOERR(" get dir out fail: %d\n", res);
break;
} else {
/*output test*/
s32 out = mt_get_gpio_out(i);
if (out != 0 && out != 1) {
GPIOERR(" get out fail = %d\n", old);
break;
}
for (val = 0; val < GPIO_OUT_MAX; val++) {
if ((res = mt_set_gpio_out(i,0)) != RSUCCESS) {
GPIOERR(" set out[%d] fail: %d\n", val, res);
break;
} else if ((res = mt_get_gpio_out(i)) != 0) {
GPIOERR(" get out[%d] fail: %d\n", val, res);
break;
}
}
if ((res = mt_set_gpio_out(i,out)) != RSUCCESS)
{
GPIOERR(" restore out fail: %d\n", res);
break;
}
}
if ((res = mt_set_gpio_dir(i, GPIO_DIR_IN)) != RSUCCESS) {
GPIOERR(" set dir in fail: %d\n", res);
break;
} else if ((res = mt_get_gpio_dir(i)) != GPIO_DIR_IN) {
GPIOERR(" get dir in fail: %d\n", res);
break;
} else {
GPIOLOG(" input data = %d\n", res);
}
if ((res = mt_set_gpio_dir(i, old)) != RSUCCESS) {
GPIOERR(" restore dir fail: %d\n", res);
break;
}
for (val = 0; val < GPIO_PULL_EN_MAX; val++) {
if ((res = mt_set_gpio_pull_enable(i,val)) != RSUCCESS) {
GPIOERR(" set pullen[%d] fail: %d\n", val, res);
break;
} else if ((res = mt_get_gpio_pull_enable(i)) != val) {
GPIOERR(" get pullen[%d] fail: %d\n", val, res);
break;
}
}
if ((res = mt_set_gpio_pull_enable(i, old)) != RSUCCESS) {
GPIOERR(" restore pullen fail: %d\n", res);
break;
}
/*pull select test*/
old = mt_get_gpio_pull_select(i);
if (old == 0 || old == 1)
GPIOLOG(" pullsel old = %d\n", old);
else {
GPIOERR(" pullsel fail: %d\n", old);
break;
}
for (val = 0; val < GPIO_PULL_MAX; val++) {
if ((res = mt_set_gpio_pull_select(i,val)) != RSUCCESS) {
GPIOERR(" set pullsel[%d] fail: %d\n", val, res);
break;
} else if ((res = mt_get_gpio_pull_select(i)) != val) {
GPIOERR(" get pullsel[%d] fail: %d\n", val, res);
break;
}
}
if ((res = mt_set_gpio_pull_select(i, old)) != RSUCCESS)
{
GPIOERR(" restore pullsel fail: %d\n", res);
break;
}
/*data inversion*/
old = mt_get_gpio_inversion(i);
if (old == 0 || old == 1)
GPIOLOG(" inv old = %d\n", old);
else {
GPIOERR(" inv fail: %d\n", old);
break;
}
for (val = 0; val < GPIO_DATA_INV_MAX; val++) {
if ((res = mt_set_gpio_inversion(i,val)) != RSUCCESS) {
GPIOERR(" set inv[%d] fail: %d\n", val, res);
break;
} else if ((res = mt_get_gpio_inversion(i)) != val) {
GPIOERR(" get inv[%d] fail: %d\n", val, res);
break;
}
}
if ((res = mt_set_gpio_inversion(i, old)) != RSUCCESS) {
GPIOERR(" restore inv fail: %d\n", res);
break;
}
/*mode control*/
// if((i<=GPIOEXT6) || (i >= GPIOEXT9)){
old = mt_get_gpio_mode(i);
if ((old >= GPIO_MODE_00) && (val < GPIO_MODE_MAX))
{
GPIOLOG(" mode old = %d\n", old);
}
else
{
GPIOERR(" get mode fail: %d\n", old);
break;
}
for (val = 0; val < GPIO_MODE_MAX; val++) {
if ((res = mt_set_gpio_mode(i, val)) != RSUCCESS) {
GPIOERR("set mode[%d] fail: %d\n", val, res);
break;
} else if ((res = mt_get_gpio_mode(i)) != val) {
GPIOERR("get mode[%d] fail: %d\n", val, res);
break;
}
}
if ((res = mt_set_gpio_mode(i,old)) != RSUCCESS) {
GPIOERR(" restore mode fail: %d\n", res);
break;
}
// }
}
GPIOLOG("GPIO test done\n");
}
int mt6306_set_gpio_out(unsigned long pin, unsigned long output)
{
GPIOERR("denali not support\n");
return 0;
}
