int set_usb1_vbus(unsigned int on)
{
if(on) {
/* turn on the vbus */
GPIO_PortWrite(MV88DE3100_USB_VBUS_DRV_GPIO, 1);
} else {
/* turn off the vbus */
GPIO_PortWrite(MV88DE3100_USB_VBUS_DRV_GPIO, 0);
}
return 0;
}
static void mv_start_ehc(struct usb_hcd *hcd)
{
u32 temp;
struct berlin_ehci_hcd *berlin = dev_get_drvdata(hcd->self.controller);
GPIO_PortWrite(berlin->pwr_gpio, 0);
writel(PHY_PLL, berlin->phy_base + MV_USB_PHY_PLL_REG);
writel(0x2235, berlin->phy_base + MV_USB_PHY_PLL_CONTROL_REG);
writel(0x5680, berlin->phy_base + MV_USB_PHY_ANALOG_REG);
writel(0xAA79, berlin->phy_base + MV_USB_PHY_RX_CTRL_REG);
/* set USBMODE to host mode */
/* temp = ehci_readl(ehci, hcd->regs + MV_USBMODE);
temp |= USBMODE_CM_HOST;
ehci_writel(ehci, temp, hcd->regs + MV_USBMODE);*/
usleep_range(2000, 2500);
temp = 1 << berlin->reset;
writel(temp, IOMEM(MEMMAP_CHIP_CTRL_REG_BASE + MV_USB_RESET_TRIGGER));
GPIO_PortWrite(berlin->pwr_gpio, 1);
}
void galois_gpio_resume(void)
{
int i;
/* init io mapper */
#ifndef BERLIN
unsigned int reg;
spi_master_init_iomapper(IOMAPPER_SPI_MASTER);
spi_master_rw_iomapper(IOMAPPER_SPI_MASTER, IOMAPPER_SPI_DEVID,
1, IOMAPPER_REG_MAP_10, ®);
if (reg & 0x1800) { /* [12:11]=b00, GPIOmatrix0 */
printk("GPIO matrix isn't configured correctly.\n");
spi_master_exit_iomapper(IOMAPPER_SPI_MASTER);
return -ENODEV;
}
#endif
/* restore irq */
for (i = 0; i < SM_GPIO_PORT_NUM; i++) {
if (gpio_irq_mode & (1 << i)) {
GPIO_PortEnableIRQ(i);
mv88de3010_open_irq(IRQ_APB_GPIOINST_NUM(i));
galois_printk("Resume GPIO setting: enable IRQ for port %d\n", i);
}
}
for (i = 0; i < SM_GPIO_PORT_NUM; i++) {
if (sm_gpio_irq_mode & (1 << i)) {
SM_GPIO_PortEnableIRQ(i);
mv88de3010_open_irq(IRQ_APB_SMGPIOINST_NUM(i));
galois_printk("Resume GPIO setting: enable IRQ for SM port %d\n", i);
}
}
/* restore mode */
for (i = 0; i < GPIO_PORT_NUM; i++) {
int mode = gpio_mode[i];
int data = g_gpio_reg[0].port_dr & (1<<i);
/* if mode is not changed */
if (!(gpio_mode_status & (1<<i)))
continue;
/* restore mode of the port */
gpio_set_mode(i, mode);
galois_printk("Resume GPIO setting: port %d, mode %d", i, mode);
/* restore data if port is out */
if (mode == GPIO_MODE_DATA_OUT) {
GPIO_PortWrite(i, data);
galois_printk(", data %d", data);
}
galois_printk("\n");
}
/* restore mode */
for (i = 0; i < GPIO_PORT_NUM; i++) {
int mode = sm_gpio_mode[i];
int data = g_gpio_reg[1].port_dr & (1<<i);
/* if mode is not changed */
if (!(sm_gpio_mode_status & (1<<i)))
continue;
/* restore mode of the port */
sm_gpio_set_mode(i, mode);
galois_printk("Resume GPIO setting: SM port %d, mode %d", i, mode);
/* restore data if port is out */
if (mode == GPIO_MODE_DATA_OUT) {
SM_GPIO_PortWrite(i, data);
galois_printk(", data %d", data);
}
galois_printk("\n");
}
}
static int galois_gpio_ioctl(struct inode *inode, struct file *file,
unsigned int cmd, unsigned long arg)
{
galois_gpio_data_t *arg_data = (galois_gpio_data_t *)arg;
galois_gpio_reg_t *kreg;
galois_gpio_data_t gpio_data;
unsigned int __gpio_irq_status, __sm_gpio_irq_status;
int ret = 0;
switch(cmd) {
case GPIO_IOCTL_SET:
case SM_GPIO_IOCTL_SET:
if (copy_from_user(&gpio_data, (void __user *)arg, sizeof(galois_gpio_data_t)))
return -EFAULT;
if (cmd == GPIO_IOCTL_SET)
gpio_set_mode(gpio_data.port, gpio_data.mode);
else
sm_gpio_set_mode(gpio_data.port, gpio_data.mode);
break;
case GPIO_IOCTL_GET:
case SM_GPIO_IOCTL_GET:
kreg = kmalloc(sizeof(galois_gpio_reg_t), GFP_KERNEL);
if (kreg == NULL) {
printk("error: failed to kmalloc memory.\n");
return -ENOMEM;
}
if (cmd == GPIO_IOCTL_GET)
gpio_get_info(kreg);
else
sm_gpio_get_info(kreg);
if (copy_to_user((void __user *)arg, kreg, sizeof(galois_gpio_reg_t))) {
kfree(kreg);
return -EFAULT;
}
kfree(kreg);
break;
case GPIO_IOCTL_READ:
case SM_GPIO_IOCTL_READ:
if (copy_from_user(&gpio_data, (void __user *)arg, sizeof(galois_gpio_data_t)))
return -EFAULT;
if (cmd == GPIO_IOCTL_READ) {
if (gpio_mode[gpio_data.port] != GPIO_MODE_DATA_IN) {
printk("GPIO port %d isn't set to data in.\n", gpio_data.port);
return -ENODEV;
}
if (GPIO_PortRead(gpio_data.port, &gpio_data.data)) {
printk("GPIO_PortRead error (port=%d)\n", gpio_data.port);
return -ENODEV;
}
} else {
if (sm_gpio_mode[gpio_data.port] != GPIO_MODE_DATA_IN) {
printk("SM GPIO port %d isn't set to data in.\n", gpio_data.port);
return -ENODEV;
}
if (SM_GPIO_PortRead(gpio_data.port, &gpio_data.data)) {
printk("SM_GPIO_PortRead error (port=%d)\n", gpio_data.port);
return -ENODEV;
}
}
if (put_user(gpio_data.data, &arg_data->data))
return -EFAULT;
break;
case GPIO_IOCTL_WRITE:
case SM_GPIO_IOCTL_WRITE:
if (copy_from_user(&gpio_data, (void __user *)arg, sizeof(galois_gpio_data_t)))
return -EFAULT;
if (cmd == GPIO_IOCTL_WRITE) {
if (gpio_mode[gpio_data.port] != GPIO_MODE_DATA_OUT) {
printk("GPIO port %d isn't set to data out.\n", gpio_data.port);
return -ENODEV;
}
if (GPIO_PortWrite(gpio_data.port, gpio_data.data)) {
printk("GPIO_PortRead error (port=%d)\n", gpio_data.port);
return -ENODEV;
}
} else {
if (sm_gpio_mode[gpio_data.port] != GPIO_MODE_DATA_OUT) {
printk("SM GPIO port %d isn't set to data out.\n", gpio_data.port);
return -ENODEV;
}
if (SM_GPIO_PortWrite(gpio_data.port, gpio_data.data)) {
printk("SM_GPIO_PortRead error (port=%d)\n", gpio_data.port);
return -ENODEV;
}
}
break;
case GPIO_IOCTL_ENABLE_IRQ:
case SM_GPIO_IOCTL_ENABLE_IRQ:
if (copy_from_user(&gpio_data, (void __user *)arg, sizeof(galois_gpio_data_t)))
return -EFAULT;
if (cmd == GPIO_IOCTL_ENABLE_IRQ) {
if (GPIO_PortEnableIRQ(gpio_data.port)) {
printk("GPIO_PortEnableIRQ error (port=%d)\n", gpio_data.port);
return -ENODEV;
}
spin_lock(&gpio_irq_lock);
gpio_irq_mode |= (1 << gpio_data.port);
spin_unlock(&gpio_irq_lock);
/* enable ictl */
mv88de3010_open_irq(IRQ_APB_GPIOINST_NUM(gpio_data.port));
} else {
if (SM_GPIO_PortEnableIRQ(gpio_data.port)) {
printk("SM_GPIO_PortEnableIRQ error (port=%d)\n", gpio_data.port);
return -ENODEV;
}
spin_lock(&gpio_irq_lock);
sm_gpio_irq_mode |= (1 << gpio_data.port);
spin_unlock(&gpio_irq_lock);
/* enable ictl */
mv88de3010_open_irq(IRQ_APB_SMGPIOINST_NUM(gpio_data.port));
}
break;
case GPIO_IOCTL_DISABLE_IRQ:
case SM_GPIO_IOCTL_DISABLE_IRQ:
if (copy_from_user(&gpio_data, (void __user *)arg, sizeof(galois_gpio_data_t)))
return -EFAULT;
if (cmd == GPIO_IOCTL_DISABLE_IRQ) {
if (GPIO_PortDisableIRQ(gpio_data.port)) {
printk("GPIO_PortDisableIRQ error (port=%d)\n", gpio_data.port);
return -ENODEV;
}
spin_lock(&gpio_irq_lock);
gpio_irq_mode &= ~(1 << gpio_data.port);
spin_unlock(&gpio_irq_lock);
/* disable ictl */
//mv88de3010_close_irq(IRQ_APB_GPIOINST_NUM(gpio_data.port));
} else {
if (SM_GPIO_PortDisableIRQ(gpio_data.port)) {
printk("SM_GPIO_PortDisableIRQ error (port=%d)\n", gpio_data.port);
return -ENODEV;
}
spin_lock(&gpio_irq_lock);
sm_gpio_irq_mode &= ~(1 << gpio_data.port);
spin_unlock(&gpio_irq_lock);
/* */
}
break;
case GPIO_IOCTL_CLEAR_IRQ:
case SM_GPIO_IOCTL_CLEAR_IRQ:
if (copy_from_user(&gpio_data, (void __user *)arg, sizeof(galois_gpio_data_t)))
return -EFAULT;
if (cmd == GPIO_IOCTL_CLEAR_IRQ) {
/* GPIO_PortClearInterrupt isn't necessary */
if (GPIO_PortClearInterrupt(gpio_data.port)) {
printk("GPIO_PortClearIRQ error (port=%d)\n", gpio_data.port);
return -ENODEV;
}
spin_lock(&gpio_irq_lock);
gpio_irq_status &= ~(1 << gpio_data.port);
spin_unlock(&gpio_irq_lock);
} else {
/* GPIO_PortClearInterrupt isn't necessary */
if (SM_GPIO_PortClearInterrupt(gpio_data.port)) {
printk("SM_GPIO_PortClearIRQ error (port=%d)\n", gpio_data.port);
return -ENODEV;
}
spin_lock(&gpio_irq_lock);
sm_gpio_irq_status &= ~(1 << gpio_data.port);
spin_unlock(&gpio_irq_lock);
}
break;
case GPIO_IOCTL_READ_IRQ:
case SM_GPIO_IOCTL_READ_IRQ:
spin_lock(&gpio_irq_lock);
__gpio_irq_status = gpio_irq_status;
__sm_gpio_irq_status = sm_gpio_irq_status;
spin_unlock(&gpio_irq_lock);
if (cmd == GPIO_IOCTL_READ_IRQ) {
if (put_user(__gpio_irq_status, (unsigned int *)arg))
return -EFAULT;
} else {
if (put_user(__sm_gpio_irq_status, (unsigned int *)arg))
return -EFAULT;
}
break;
case GPIO_IOCTL_INIT_IRQ:
mutex_lock(&irq_init_mutex);
if (irq_init > 0) {
irq_init++;
printk("GPIO irq init++ %d\n", irq_init);
mutex_unlock(&irq_init_mutex);
return 0;
}
/* reigster GPIO inst0 interrupt */
ret = request_irq(IRQ_APB_GPIOINST0, gpio_interrupt_handle, IRQF_SHARED,
GALOIS_GPIO_NAME, &gpio_dev_id);
if (ret) {
printk("error: failed to request_irq %d.\n", IRQ_APB_GPIOINST0);
goto init_irq_exit;
}
/* reigster GPIO inst1 interrupt */
ret = request_irq(IRQ_APB_GPIOINST1, gpio_interrupt_handle, IRQF_SHARED,
GALOIS_GPIO_NAME, &gpio_dev_id);
if (ret) {
free_irq(IRQ_APB_GPIOINST0, &gpio_dev_id);
printk("error: failed to request_irq %d.\n", IRQ_APB_GPIOINST1);
goto init_irq_exit;
}
/* reigster GPIO inst2 interrupt */
ret = request_irq(IRQ_APB_GPIOINST2, gpio_interrupt_handle, IRQF_SHARED,
GALOIS_GPIO_NAME, &gpio_dev_id);
if (ret) {
free_irq(IRQ_APB_GPIOINST0, &gpio_dev_id);
free_irq(IRQ_APB_GPIOINST1, &gpio_dev_id);
printk("error: failed to request_irq %d.\n", IRQ_APB_GPIOINST2);
goto init_irq_exit;
}
/* reigster GPIO inst3 interrupt */
ret = request_irq(IRQ_APB_GPIOINST3, gpio_interrupt_handle, IRQF_SHARED,
GALOIS_GPIO_NAME, &gpio_dev_id);
if (ret) {
free_irq(IRQ_APB_GPIOINST0, &gpio_dev_id);
free_irq(IRQ_APB_GPIOINST1, &gpio_dev_id);
free_irq(IRQ_APB_GPIOINST2, &gpio_dev_id);
printk("error: failed to request_irq %d.\n", IRQ_APB_GPIOINST3);
goto init_irq_exit;
}
/* reigster SM GPIO inst1 interrupt */
ret = request_irq(G_IRQ_SM_GPIO1, gpio_interrupt_handle, IRQF_SHARED,
GALOIS_GPIO_NAME, &gpio_dev_id);
if (ret) {
free_irq(IRQ_APB_GPIOINST0, &gpio_dev_id);
free_irq(IRQ_APB_GPIOINST1, &gpio_dev_id);
free_irq(IRQ_APB_GPIOINST2, &gpio_dev_id);
free_irq(IRQ_APB_GPIOINST3, &gpio_dev_id);
printk("error: failed to request_irq %d.\n", G_IRQ_SM_GPIO1);
goto init_irq_exit;
}
/* reigster SM GPIO inst0 interrupt */
ret = request_irq(G_IRQ_SM_GPIO0, gpio_interrupt_handle, IRQF_SHARED,
GALOIS_GPIO_NAME, &gpio_dev_id);
if (ret) {
free_irq(IRQ_APB_GPIOINST0, &gpio_dev_id);
free_irq(IRQ_APB_GPIOINST1, &gpio_dev_id);
free_irq(IRQ_APB_GPIOINST2, &gpio_dev_id);
free_irq(IRQ_APB_GPIOINST3, &gpio_dev_id);
free_irq(G_IRQ_SM_GPIO1, &gpio_dev_id);
printk("error: failed to request_irq %d.\n", G_IRQ_SM_GPIO0);
goto init_irq_exit;
}
irq_init++;
printk("GPIO irq init++ %d\n", irq_init);
init_irq_exit:
mutex_unlock(&irq_init_mutex);
return ret;
//break;
case GPIO_IOCTL_EXIT_IRQ:
mutex_lock(&irq_init_mutex);
if (irq_init > 0) {
irq_init--;
printk("GPIO irq init-- %d", irq_init);
}
if (irq_init > 0) {
mutex_unlock(&irq_init_mutex);
return 0;
}
/* can it disable the irq when last handle is freed? */
free_irq(IRQ_APB_GPIOINST0, &gpio_dev_id);
free_irq(IRQ_APB_GPIOINST1, &gpio_dev_id);
free_irq(IRQ_APB_GPIOINST2, &gpio_dev_id);
free_irq(IRQ_APB_GPIOINST3, &gpio_dev_id);
free_irq(G_IRQ_SM_GPIO1, &gpio_dev_id);
free_irq(G_IRQ_SM_GPIO0, &gpio_dev_id);
mutex_unlock(&irq_init_mutex);
break;
default:
return -EPERM;
}
return 0;
}
static void mv_stop_ehc(struct usb_hcd *hcd)
{
struct berlin_ehci_hcd *berlin = dev_get_drvdata(hcd->self.controller);
GPIO_PortWrite(berlin->pwr_gpio, 0);
}
