static int __init mstar_gpio_drv_init_module(void)
{
int retval=0;
GPIO_PRINT("%s is invoked\n", __FUNCTION__);
retval = platform_driver_register(&Mstar_gpio_driver);
return retval;
}
static void mod_gpio_exit(void)
{
GPIO_PRINT("%s is invoked\n", __FUNCTION__);
cdev_del(&GPIODev.cDevice);
unregister_chrdev_region(MKDEV(GPIODev.s32MajorGPIO, GPIODev.s32MinorGPIO), MOD_GPIO_DEVICE_COUNT);
}
// Close SPI Channel
void Beagle_GPIO::closeSPI()
{
if ( m_spi_fd >= 0)
{
GPIO_PRINT( "Closing SPI Device" );
close( m_spi_fd );
delete [] m_spi_buffer_rx;
}
}
static int _MDrv_GPIO_Open (struct inode *inode, struct file *filp)
{
GPIO_ModHandle_t *dev;
GPIO_PRINT("%s is invoked\n", __FUNCTION__);
dev = container_of(inode->i_cdev, GPIO_ModHandle_t, cDevice);
filp->private_data = dev;
return 0;
}
Beagle_GPIO::Beagle_GPIO()
{
GPIO_PRINT( "Beagle_GPIO::Beagle_GPIO()" );
// Not initialized by default
m_active = false;
// Opening /dev/mem first
GPIO_PRINT( "Opening /dev/mem" );
m_gpio_fd = open( "/dev/mem", O_RDWR | O_SYNC );
if ( m_gpio_fd < 0 )
{
GPIO_ERROR( "Cannot open /dev/mem" );
return;
}
// Map Control Module
m_controlModule = (unsigned long *)mmap( NULL, 0x1FFF, PROT_READ | PROT_WRITE, MAP_SHARED, m_gpio_fd, GPIO_Control_Module_Registers );
if ( m_controlModule == MAP_FAILED )
{
GPIO_ERROR( "Control Module Mapping failed" );
return;
}
// Now mapping the GPIO registers
for ( int i=0; i<4; ++i)
{
// Map a GPIO bank
m_gpio[i] = (unsigned long *)mmap( NULL, 0xFFF, PROT_READ | PROT_WRITE, MAP_SHARED, m_gpio_fd, GPIO_Base[i] );
if ( m_gpio[i] == MAP_FAILED )
{
GPIO_ERROR( "GPIO Mapping failed for GPIO Module " << i );
return;
}
}
// Init complete and successfull
m_active = true;
GPIO_PRINT( "Beagle GPIO Initialized" );
}
static int mod_gpio_init(void)
{
S32 s32Ret;
dev_t dev;
GPIO_PRINT("%s is invoked\n", __FUNCTION__);
if (GPIODev.s32MajorGPIO)
{
dev = MKDEV(GPIODev.s32MajorGPIO, GPIODev.s32MinorGPIO);
s32Ret = register_chrdev_region(dev, MOD_GPIO_DEVICE_COUNT, MOD_GPIO_NAME);
}
else
{
s32Ret = alloc_chrdev_region(&dev, GPIODev.s32MinorGPIO, MOD_GPIO_DEVICE_COUNT, MOD_GPIO_NAME);
GPIODev.s32MajorGPIO = MAJOR(dev);
}
if ( 0 > s32Ret)
{
GPIO_PRINT("Unable to get major %d\n", GPIODev.s32MajorGPIO);
return s32Ret;
}
cdev_init(&GPIODev.cDevice, &GPIODev.GPIOFop);
if (0!= (s32Ret= cdev_add(&GPIODev.cDevice, dev, MOD_GPIO_DEVICE_COUNT)))
{
GPIO_PRINT("Unable add a character device\n");
unregister_chrdev_region(dev, MOD_GPIO_DEVICE_COUNT);
return s32Ret;
}
__mod_gpio_init();
return 0;
}
static int mstar_gpio_drv_resume(struct platform_device *dev)
{
GPIO_PRINT("%s is invoked\n", __FUNCTION__);
__mod_gpio_init();
return 0;
}
static int mstar_gpio_drv_suspend(struct platform_device *dev, pm_message_t state)
{
GPIO_PRINT("%s is invoked\n", __FUNCTION__);
return 0;
}
static int _MDrv_GPIO_Ioctl(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg)
#endif
{
S32 s32Err= 0;
U8 u8Temp;
GPIO_Reg_t GPIO_reg;
GPIO_PRINT("%s is invoked\n", __FUNCTION__);
/*
* extract the type and number bitfields, and don't decode
* wrong cmds: return ENOTTY (inappropriate ioctl) before access_ok()
*/
if ((GPIO_IOC_MAGIC!= _IOC_TYPE(cmd)) || (_IOC_NR(cmd)> GPIO_IOC_MAXNR))
{
return -ENOTTY;
}
/*
* the direction is a bitmask, and VERIFY_WRITE catches R/W
* transfers. `Type' is user-oriented, while
* access_ok is kernel-oriented, so the concept of "read" and
* "write" is reversed
*/
if ((cmd != KERN_GPIO_OEN) && (cmd != KERN_GPIO_PULL_HIGH) && (cmd != KERN_GPIO_PULL_LOW))
{
if (_IOC_DIR(cmd) & _IOC_READ)
{
s32Err = !access_ok(VERIFY_WRITE, (void __user *)arg, _IOC_SIZE(cmd));
}
else if (_IOC_DIR(cmd) & _IOC_WRITE)
{
s32Err = !access_ok(VERIFY_READ, (void __user *)arg, _IOC_SIZE(cmd));
}
if (s32Err)
{
return -EFAULT;
}
}
//PROBE_IO_ENTRY(MDRV_MAJOR_GPIO, _IOC_NR(cmd));
switch(cmd)
{
//the cases of this section set to initialize
case MDRV_GPIO_INIT:
GPIO_PRINT("ioctl: MDRV_GPIO_INIT\n");
MDrv_GPIO_Init();
break;
case MDRV_GPIO_SET:
GPIO_PRINT("ioctl: MDRV_GPIO_SET\n");
if (copy_from_user(&u8Temp, (U8 *) arg, sizeof(U8)))
{
//PROBE_IO_EXIT(MDRV_MAJOR_GPIO, _IOC_NR(cmd));
return -EFAULT;
}
MDrv_GPIO_Pad_Set(u8Temp);
break;
case MDRV_GPIO_OEN:
GPIO_PRINT("ioctl: MDRV_GPIO_OEN\n");
if (copy_from_user(&u8Temp, (U8 *) arg, sizeof(U8)))
{
//PROBE_IO_EXIT(MDRV_MAJOR_GPIO, _IOC_NR(cmd));
return -EFAULT;
}
MDrv_GPIO_Pad_Oen(u8Temp);
break;
case KERN_GPIO_OEN:
GPIO_PRINT("ioctl: KERN_GPIO_OEN\n");
u8Temp = *((U8 *) arg);
MDrv_GPIO_Pad_Oen(u8Temp);
break;
case MDRV_GPIO_ODN:
GPIO_PRINT("ioctl: MDRV_GPIO_ODN\n");
if (copy_from_user(&u8Temp, (U8 *) arg, sizeof(U8)))
{
//PROBE_IO_EXIT(MDRV_MAJOR_GPIO, _IOC_NR(cmd));
return -EFAULT;
}
MDrv_GPIO_Pad_Odn(u8Temp);
break;
case MDRV_GPIO_READ:
GPIO_PRINT("ioctl: MDRV_GPIO_READ\n");
if (copy_from_user(&u8Temp, (U8 *) arg, sizeof(U8)))
{
//PROBE_IO_EXIT(MDRV_MAJOR_GPIO, _IOC_NR(cmd));
return -EFAULT;
}
u8Temp=MDrv_GPIO_Pad_Read(u8Temp);
if (copy_to_user((U8 *) arg, &u8Temp, sizeof(U8)))
{
//PROBE_IO_EXIT(MDRV_MAJOR_GPIO, _IOC_NR(cmd));
return -EFAULT;
}
break;
case MDRV_GPIO_PULL_HIGH:
GPIO_PRINT("ioctl: MDRV_GPIO_PULL_HIGH\n");
if (copy_from_user(&u8Temp, (U8 *) arg, sizeof(U8)))
{
//PROBE_IO_EXIT(MDRV_MAJOR_GPIO, _IOC_NR(cmd));
return -EFAULT;
}
MDrv_GPIO_Pull_High(u8Temp);
break;
case KERN_GPIO_PULL_HIGH:
GPIO_PRINT("ioctl: KERN_GPIO_PULL_HIGH\n");
u8Temp = *((U8 *) arg);
MDrv_GPIO_Pull_High(u8Temp);
break;
case MDRV_GPIO_PULL_LOW:
GPIO_PRINT("ioctl: MDRV_GPIO_PULL_LOW\n");
if (copy_from_user(&u8Temp, (U8 *) arg, sizeof(U8)))
{
//PROBE_IO_EXIT(MDRV_MAJOR_GPIO, _IOC_NR(cmd));
return -EFAULT;
}
MDrv_GPIO_Pull_Low(u8Temp);
break;
case KERN_GPIO_PULL_LOW:
GPIO_PRINT("ioctl: KERN_GPIO_PULL_LOW\n");
u8Temp = *((U8 *) arg);
MDrv_GPIO_Pull_Low(u8Temp);
break;
case MDRV_GPIO_INOUT:
GPIO_PRINT("ioctl: MDRV_GPIO_INOUT\n");
if (copy_from_user(&u8Temp, (U8 *) arg, sizeof(U8)))
{
//PROBE_IO_EXIT(MDRV_MAJOR_GPIO, _IOC_NR(cmd));
return -EFAULT;
}
u8Temp=MDrv_GPIO_Pad_InOut(u8Temp);
if (copy_to_user((U8 *) arg, &u8Temp, sizeof(U8)))
{
//PROBE_IO_EXIT(MDRV_MAJOR_GPIO, _IOC_NR(cmd));
return -EFAULT;
}
break;
case MDRV_GPIO_WREGB:
GPIO_PRINT("ioctl: MDRV_GPIO_WREGB\n");
if (copy_from_user(&GPIO_reg, (GPIO_Reg_t __user *) arg, sizeof(GPIO_Reg_t)))
{
//PROBE_IO_EXIT(MDRV_MAJOR_GPIO, _IOC_NR(cmd));
return -EFAULT;
}
MDrv_GPIO_WriteRegBit(GPIO_reg.u32Reg, GPIO_reg.u8Enable, GPIO_reg.u8BitMsk);
break;
default:
GPIO_PRINT("ioctl: unknown command\n");
//PROBE_IO_EXIT(MDRV_MAJOR_GPIO, _IOC_NR(cmd));
return -ENOTTY;
}
//PROBE_IO_EXIT(MDRV_MAJOR_GPIO, _IOC_NR(cmd));
return 0;
}
static int _MDrv_GPIO_Fasync(int fd, struct file *filp, int mode)
{
GPIO_PRINT("%s is invoked\n", __FUNCTION__);
return 0;//fasync_helper(fd, filp, mode, &IICDev.async_queue);
}
static unsigned int _MDrv_GPIO_Poll(struct file *filp, poll_table *wait)
{
GPIO_PRINT("%s is invoked\n", __FUNCTION__);
return 0;
}
static ssize_t _MDrv_GPIO_Write(struct file *filp, const char __user *buf, size_t count, loff_t *f_pos)
{
GPIO_PRINT("%s is invoked\n", __FUNCTION__);
return 0;
}
static int _MDrv_GPIO_Release(struct inode *inode, struct file *filp)
{
GPIO_PRINT("%s is invoked\n", __FUNCTION__);
return 0;
}
// Open SPI Channel
void Beagle_GPIO::openSPI( unsigned char _mode,
unsigned char _bits,
unsigned long _speed,
unsigned short _delay )
{
GPIO_PRINT( "Opening SPI Device" );
m_spi_fd = open( spi_device, O_RDWR );
if ( m_spi_fd < 0 )
{
GPIO_ERROR( "Error opening SPI Device" );
return;
}
int ret = 0;
// Save settings
m_spi_mode = _mode;
m_spi_bits = _bits;
m_spi_speed = _speed;
m_spi_delay = _delay;
m_spi_buffer_rx = new unsigned char[65536];
// SPI Mode
ret = ioctl(m_spi_fd, SPI_IOC_WR_MODE, &m_spi_mode);
if (ret == -1)
{
GPIO_ERROR( "Error setting SPI Mode");
return;
}
ret = ioctl(m_spi_fd, SPI_IOC_RD_MODE, &m_spi_mode);
if (ret == -1)
{
GPIO_ERROR( "Error getting SPI Mode");
return;
}
// SPI Bits Per Word
ret = ioctl(m_spi_fd, SPI_IOC_WR_BITS_PER_WORD, &m_spi_bits);
if (ret == -1)
{
GPIO_ERROR( "Error setting SPI Bits Per Word");
return;
}
ret = ioctl(m_spi_fd, SPI_IOC_RD_BITS_PER_WORD, &m_spi_bits);
if (ret == -1)
{
GPIO_ERROR( "Error getting SPI Bits Per Word");
return;
}
// SPI Max Speed
ret = ioctl(m_spi_fd, SPI_IOC_WR_MAX_SPEED_HZ, &m_spi_speed);
if (ret == -1)
{
GPIO_ERROR( "Error setting SPI Max Speed");
return;
}
ret = ioctl(m_spi_fd, SPI_IOC_RD_MAX_SPEED_HZ, &m_spi_speed);
if (ret == -1)
{
GPIO_ERROR( "Error getting SPI Max Speed");
return;
}
GPIO_PRINT( "SPI Mode : " << std::hex << (int)(m_spi_mode) );
GPIO_PRINT( "SPI Bits Per Word : " << std::dec << (int)(m_spi_bits) );
GPIO_PRINT( "SPI Max Speed : " << std::dec << m_spi_speed );
GPIO_PRINT( "SPI Delay : " << std::dec << m_spi_delay );
GPIO_PRINT( "SPI Opened" );
}
