/** * get_bd - get a null bd * @args - arg1: dir, arg2: ep number */ PBD get_bd(USB_DIR dir, DEV_UINT32 num) { PBD ptr; if (dir == USB_RX) { ptr = (PBD) Rx_bd_List[num].pNext; os_printk(K_DEBUG, "%s Rx_bd_List[%d].pNext=%p\n", __func__, num, (Rx_bd_List[num].pNext)); if ((Rx_bd_List[num].pNext + 1) < Rx_bd_List[num].pEnd) Rx_bd_List[num].pNext++; else Rx_bd_List[num].pNext = Rx_bd_List[num].pStart; } else { ptr = (PBD) Tx_bd_List[num].pNext; os_printk(K_DEBUG, "%s Tx_gpd_List[%d].pNext=%p\n", __func__, num, (Tx_bd_List[num].pNext)); Tx_bd_List[num].pNext++; Tx_bd_List[num].pNext = Tx_bd_List[num].pNext + AT_BD_EXT_LEN; if (Tx_bd_List[num].pNext >= Tx_bd_List[num].pEnd) { Tx_bd_List[num].pNext = Tx_bd_List[num].pStart; } } return ptr; }
/** * mu3d_hal_resume_qmu - resume qmu function * @args - arg1: ep number, arg2: dir */ void mu3d_hal_resume_qmu(DEV_INT32 q_num, USB_DIR dir) { #if defined(USB_RISC_CACHE_ENABLED) os_flushinvalidateDcache(); #endif if (dir == USB_TX) { os_writel(USB_QMU_TQCSR(q_num), QMU_Q_RESUME); if (!os_readl(USB_QMU_TQCSR(q_num))) { os_printk(K_DEBUG, "%s QMU_TQCSR[%d]=%x\n", __func__, q_num, os_readl(USB_QMU_TQCSR(q_num))); os_writel(USB_QMU_TQCSR(q_num), QMU_Q_RESUME); } } else if (dir == USB_RX) { os_writel(USB_QMU_RQCSR(q_num), QMU_Q_RESUME); if (!os_readl(USB_QMU_RQCSR(q_num))) { os_printk(K_DEBUG, "%s QMU_RQCSR[%d]=%x\n", __func__, q_num, os_readl(USB_QMU_RQCSR(q_num))); os_writel(USB_QMU_RQCSR(q_num), QMU_Q_RESUME); } } else { os_printk(K_INFO, "%s wrong direction!!!\n", __func__); BUG_ON(1); } }
void mt_usb_disconnect(void) { os_printk(K_DEBUG,"%s\n", __func__); musb_stop(mu3d_musb); os_printk(K_DEBUG,"%s-\n", __func__); }
void mt_usb_connect(void) { os_printk(K_DEBUG,"%s+\n", __func__); musb_start(mu3d_musb); os_printk(K_DEBUG,"%s-\n", __func__); }
/* * print out a key in hex */ static void print_key(const char *tag, uint8_t *key, int bits) { int bytes = (bits + 7) / 8; di_info("%s", tag); while (bytes--) os_printk("%02x", *key++); os_printk("\n"); }
static void dump(const char *name, const uint8_t * data, unsigned int len) { os_printk("%s: ", name); while (len > 0) { os_printk("%02x ", (unsigned)*data++); len--; } os_printk("\n"); }
static inline void mtu3d_u2_common_intr_handler(u32 dwIntrUsbValue) { if (dwIntrUsbValue & DISCONN_INTR) { mu3d_hal_pdn_ip_port(1, 0, 1, 1); os_printk(K_NOTICE, "[U2 DISCONN_INTR] Set SOFT_CONN=0\n"); os_clrmsk(U3D_POWER_MANAGEMENT, SOFT_CONN); /*TODO-J: ADD musb_g_disconnect(musb);??*/ } if (dwIntrUsbValue & LPM_INTR) { u32 rmwake ; rmwake = os_readl(U3D_POWER_MANAGEMENT); os_printk(K_NOTICE, "[U2 LPM interrupt] last rmwake is 0x%x\n", rmwake & LPM_RWP); if (!((os_readl(U3D_POWER_MANAGEMENT) & LPM_HRWE))) { mu3d_hal_pdn_ip_port(0, 0, 0, 1); } #ifdef CONFIG_USBIF_COMPLIANCE // SW word around for USBIF test with Fresco FL1100 with LPM L1C enabling #if 0 if (rmwake & LPM_RWP){ os_writel(U3D_USB20_MISC_CONTROL, os_readl(U3D_USB20_MISC_CONTROL) | LPM_U3_ACK_EN); os_writel(U3D_POWER_MANAGEMENT, os_readl(U3D_POWER_MANAGEMENT) | RESUME); } #endif #endif } if (dwIntrUsbValue & LPM_RESUME_INTR) { if (!(os_readl(U3D_POWER_MANAGEMENT) & LPM_HRWE)) { mu3d_hal_pdn_ip_port(1, 0, 0, 1); os_writel(U3D_USB20_MISC_CONTROL, os_readl(U3D_USB20_MISC_CONTROL) | LPM_U3_ACK_EN); } } if(dwIntrUsbValue & SUSPEND_INTR) { os_printk(K_NOTICE, "[U2 SUSPEND_INTR]\n"); mu3d_hal_pdn_ip_port(0, 0, 0, 1); } if (dwIntrUsbValue & RESUME_INTR) { os_printk(K_NOTICE,"[U2 RESUME_INTR]\n"); mu3d_hal_pdn_ip_port(1, 0, 0, 1); } if (dwIntrUsbValue & RESET_INTR) { os_printk(K_NOTICE,"[U2 RESET_INTR]\n"); } }
/** * init_gpd_list - initialize gpd management list * @args - arg1: dir, arg2: ep number, arg3: gpd virtual addr, arg4: gpd ioremap addr, arg5: gpd number */ void init_gpd_list(USB_DIR dir, int num, PGPD ptr, PGPD io_ptr, DEV_UINT32 size) { if (dir == USB_RX) { Rx_gpd_List[num].pStart = ptr; Rx_gpd_List[num].pEnd = (PGPD) (ptr + size); Rx_gpd_Offset[num] = (DEV_UINT32) ptr - (DEV_UINT32) io_ptr; /* (DEV_UINT32)os_virt_to_phys(ptr); */ ptr++; Rx_gpd_List[num].pNext = ptr; os_printk(K_DEBUG, "Rx_gpd_List[%d].pStart=%p, pNext=%p, pEnd=%p\n", num, Rx_gpd_List[num].pStart, Rx_gpd_List[num].pNext, Rx_gpd_List[num].pEnd); os_printk(K_DEBUG, "Rx_gpd_Offset[%d]=0x%08X\n", num, Rx_gpd_Offset[num]); os_printk(K_DEBUG, "virtual start=%p, end=%p\n", ptr, ptr + size); os_printk(K_DEBUG, "dma addr start=%p, end=%p\n", io_ptr, io_ptr + size); } else { Tx_gpd_List[num].pStart = ptr; Tx_gpd_List[num].pEnd = (PGPD) ((DEV_UINT8 *) (ptr + size) + AT_GPD_EXT_LEN * size); Tx_gpd_Offset[num] = (DEV_UINT32) ptr - (DEV_UINT32) io_ptr; /* (DEV_UINT32)os_virt_to_phys(ptr); */ ptr++; Tx_gpd_List[num].pNext = (PGPD) ((DEV_UINT8 *) ptr + AT_GPD_EXT_LEN); os_printk(K_DEBUG, "Tx_gpd_List[%d].pStart=%p, pNext=%p, pEnd=%p\n", num, Tx_gpd_List[num].pStart, Tx_gpd_List[num].pNext, Tx_gpd_List[num].pEnd); os_printk(K_DEBUG, "Tx_gpd_Offset[%d]=0x%08X\n", num, Tx_gpd_Offset[num]); os_printk(K_DEBUG, "virtual start=%p, end=%p\n", ptr, ptr + size); os_printk(K_DEBUG, "dma addr start=%p, end=%p\n", io_ptr, io_ptr + size); } }
/** * mu3d_hal_init_qmu - initialize qmu * */ void mu3d_hal_init_qmu(void) { DEV_UINT32 i; DEV_UINT32 QCR = 0; /* Initialize QMU Tx/Rx start address. */ for (i = 1; i <= MAX_QMU_EP; i++) { os_printk(K_DEBUG, "==EP[%d]==Start addr RXQ=0x%08x, TXQ=0x%08x\n", i, mu3d_hal_gpd_virt_to_phys(Rx_gpd_head[i], USB_RX, i), mu3d_hal_gpd_virt_to_phys(Tx_gpd_head[i], USB_TX, i)); QCR |= QMU_RX_EN(i); QCR |= QMU_TX_EN(i); os_writel(USB_QMU_RQSAR(i), mu3d_hal_gpd_virt_to_phys(Rx_gpd_head[i], USB_RX, i)); os_writel(USB_QMU_TQSAR(i), mu3d_hal_gpd_virt_to_phys(Tx_gpd_head[i], USB_TX, i)); Tx_gpd_end[i] = Tx_gpd_last[i] = Tx_gpd_head[i]; Rx_gpd_end[i] = Rx_gpd_last[i] = Rx_gpd_head[i]; gpd_ptr_align(USB_TX, i, Tx_gpd_end[i]); gpd_ptr_align(USB_RX, i, Rx_gpd_end[i]); } /* Enable QMU Tx/Rx. */ os_writel(U3D_QGCSR, QCR); os_writel(U3D_QIESR0, QCR); /* Enable QMU interrupt. */ os_writel(U3D_QIESR1, TXQ_EMPTY_IESR | TXQ_CSERR_IESR | TXQ_LENERR_IESR | RXQ_EMPTY_IESR | RXQ_CSERR_IESR | RXQ_LENERR_IESR | RXQ_ZLPERR_IESR); os_writel(U3D_EPIESR, EP0ISR); }
static int hpt_attach(device_t dev) { PHBA hba = (PHBA)device_get_softc(dev); HIM *him = hba->ldm_adapter.him; PCI_ID pci_id; HPT_UINT size; PVBUS vbus; PVBUS_EXT vbus_ext; KdPrint(("hpt_attach(%d/%d/%d)", pci_get_bus(dev), pci_get_slot(dev), pci_get_function(dev))); pci_enable_busmaster(dev); pci_id.vid = pci_get_vendor(dev); pci_id.did = pci_get_device(dev); pci_id.rev = pci_get_revid(dev); pci_id.subsys = (HPT_U32)(pci_get_subdevice(dev)) << 16 | pci_get_subvendor(dev); size = him->get_adapter_size(&pci_id); hba->ldm_adapter.him_handle = kmalloc(size, M_DEVBUF, M_WAITOK); if (!hba->ldm_adapter.him_handle) return ENXIO; hba->pcidev = dev; hba->pciaddr.tree = 0; hba->pciaddr.bus = pci_get_bus(dev); hba->pciaddr.device = pci_get_slot(dev); hba->pciaddr.function = pci_get_function(dev); if (!him->create_adapter(&pci_id, hba->pciaddr, hba->ldm_adapter.him_handle, hba)) { kfree(hba->ldm_adapter.him_handle, M_DEVBUF); return -1; } os_printk("adapter at PCI %d:%d:%d, IRQ %d", hba->pciaddr.bus, hba->pciaddr.device, hba->pciaddr.function, pci_get_irq(dev)); if (!ldm_register_adapter(&hba->ldm_adapter)) { size = ldm_get_vbus_size(); vbus_ext = kmalloc(sizeof(VBUS_EXT) + size, M_DEVBUF, M_WAITOK); if (!vbus_ext) { kfree(hba->ldm_adapter.him_handle, M_DEVBUF); return -1; } memset(vbus_ext, 0, sizeof(VBUS_EXT)); vbus_ext->ext_type = EXT_TYPE_VBUS; ldm_create_vbus((PVBUS)vbus_ext->vbus, vbus_ext); ldm_register_adapter(&hba->ldm_adapter); } ldm_for_each_vbus(vbus, vbus_ext) { if (hba->ldm_adapter.vbus==vbus) { hba->vbus_ext = vbus_ext; hba->next = vbus_ext->hba_list; vbus_ext->hba_list = hba; break; } } return 0; }
/** * Register the driver with the kernel. * * Call @c register_chrdev() to set this driver up as being * responsible for the SCC. Save the major number for the driver * in scc2_test_major_node. * * Called from #scc2_test_init() * * @return 0 on success, -errno on failure. */ static os_error_code setup_user_driver_interaction(void) { os_error_code code = OS_ERROR_OK_S; os_driver_init_registration(reg_handle); os_driver_add_registration(reg_handle, OS_FN_OPEN, OS_DEV_OPEN_REF(scc2_test_open)); os_driver_add_registration(reg_handle, OS_FN_IOCTL, OS_DEV_IOCTL_REF(scc2_test_ioctl)); os_driver_add_registration(reg_handle, OS_FN_CLOSE, OS_DEV_CLOSE_REF(scc2_test_release)); code = os_driver_complete_registration(reg_handle, scc2_test_major_node, SCC2_TEST_DRIVER_NAME); if (code != OS_ERROR_OK_S) { /* failure ! */ os_printk("SCC2 TEST Driver: register device driver failed: %d\n", code); return code; } /* Save the major node value */ if (scc2_test_major_node == 0) { /* We passed in a zero value, then one was assigned to us. */ scc2_test_major_node = code; } pr_debug("SCC2 TEST Driver: Major node is %d\n", scc2_test_major_node); return code; }
/*! * Function to handle "Security Alarm" indication from SCC. * * This function is registered with the Security Monitor ans the callback * function for the RNG driver. Upon alarm, it will shut down the driver so * that no more random data can be retrieved. * * @return void */ static void rng_sec_failure(void) { os_printk(KERN_ALERT "RNG Driver: Security Failure Alarm received.\n"); rng_cleanup(); return; }
/*--FOR INSTANT POWER ON USAGE--------------------------------------------------*/ static ssize_t mt_usb_show_cmode(struct device* dev, struct device_attribute *attr, char *buf) { if (!dev) { os_printk(K_DEBUG,"dev is null!!\n"); return 0; } return scnprintf(buf, PAGE_SIZE, "%d\n", cable_mode); }
bool usb_cable_connected(void) { #ifdef CONFIG_POWER_EXT CHARGER_TYPE chg_type = mt_charger_type_detection(); os_printk(K_INFO, "%s ext-chrdet=%d type=%d\n", __func__, upmu_get_rgs_chrdet(), chg_type); if (upmu_get_rgs_chrdet() && (chg_type == STANDARD_HOST)) #else os_printk(K_INFO, "%s chrdet=%d\n", __func__, upmu_is_chr_det()); if (upmu_is_chr_det()) #endif { return true; } else { return false; } return true; }
ssize_t musb_cmode_show(struct device* dev, struct device_attribute *attr, char *buf) { if (!dev) { os_printk(K_ERR, "dev is null!!\n"); return 0; } return sprintf(buf, "%s\n", usb_mode_str[cable_mode]); }
void mt_usb_connect(void) { struct delayed_work *work; os_printk(K_INFO, "%s+\n", __func__); if(_mu3d_musb) { work = &_mu3d_musb->connection_work; //if(!cancel_delayed_work(work)) // flush_workqueue(_mu3d_musb->wq); queue_delayed_work(_mu3d_musb->wq, work, 0); } else { os_printk(K_INFO, "%s musb_musb not ready\n", __func__); } os_printk(K_INFO, "%s-\n", __func__); }
void usb_check_connect(void) { os_printk(K_DEBUG,"[MUSB] usb_check_connect\n"); #ifdef NEVER #ifndef CONFIG_MTK_FPGA if (usb_cable_connected()) mt_usb_connect(); #endif #endif /* NEVER */ }
void musb_sync_with_bat(struct musb *musb, int usb_state) { os_printk(K_INFO, "musb_sync_with_bat\n"); #ifndef CONFIG_MTK_FPGA BATTERY_SetUSBState(usb_state); wake_up_bat(); #endif }
void usb_check_connect(void) { os_printk(K_INFO, "usb_check_connect\n"); #ifndef CONFIG_MTK_FPGA if (usb_cable_connected()) mt_usb_connect(); #endif }
void musb_sync_with_bat(struct musb *musb, int usb_state) { os_printk(K_DEBUG,"[MUSB] musb_sync_with_bat\n"); #ifdef NEVER #ifndef CONFIG_MTK_FPGA BATTERY_SetUSBState(usb_state); wake_up_bat(); #endif #endif /* NEVER */ }
static inline void mtu3d_u2_common_intr_handler(u32 dwIntrUsbValue) { if (dwIntrUsbValue & DISCONN_INTR) { mu3d_hal_pdn_ip_port(1, 0, 1, 1); os_printk(K_NOTICE, "[U2 DISCONN_INTR] Set SOFT_CONN=0\n"); os_clrmsk(U3D_POWER_MANAGEMENT, SOFT_CONN); /*TODO-J: ADD musb_g_disconnect(musb);??*/ } if (dwIntrUsbValue & LPM_INTR) { os_printk(K_NOTICE, "[U2 LPM interrupt]\n"); if (!((os_readl(U3D_POWER_MANAGEMENT) & LPM_HRWE))) { mu3d_hal_pdn_ip_port(0, 0, 0, 1); } } if (dwIntrUsbValue & LPM_RESUME_INTR) { if (!(os_readl(U3D_POWER_MANAGEMENT) & LPM_HRWE)) { mu3d_hal_pdn_ip_port(1, 0, 0, 1); os_writel(U3D_USB20_MISC_CONTROL, os_readl(U3D_USB20_MISC_CONTROL) | LPM_U3_ACK_EN); } } if(dwIntrUsbValue & SUSPEND_INTR) { os_printk(K_NOTICE, "[U2 SUSPEND_INTR]\n"); mu3d_hal_pdn_ip_port(0, 0, 0, 1); } if (dwIntrUsbValue & RESUME_INTR) { os_printk(K_NOTICE,"[U2 RESUME_INTR]\n"); mu3d_hal_pdn_ip_port(1, 0, 0, 1); } if (dwIntrUsbValue & RESET_INTR) { os_printk(K_NOTICE,"[U2 RESET_INTR]\n"); } }
bool mt_usb_is_ready(void) { os_printk(K_INFO, "USB is ready or not\n"); #ifdef NEVER if(!mtk_musb || !mtk_musb->is_ready) return false; else return true; #endif /* NEVER */ return true; }
/** * mu3d_hal_stop_qmu - stop qmu function (after qmu stop, fifo should be flushed) * @args - arg1: ep number, arg2: dir */ void mu3d_hal_stop_qmu(DEV_INT32 q_num, USB_DIR dir) { if (dir == USB_TX) { if (!(os_readl(USB_QMU_TQCSR(q_num)) & (QMU_Q_ACTIVE))) { os_printk(K_DEBUG, "Tx%d inActive Now!\n", q_num); return; } os_writel(USB_QMU_TQCSR(q_num), QMU_Q_STOP); while ((os_readl(USB_QMU_TQCSR(q_num)) & (QMU_Q_ACTIVE))); os_printk(K_CRIT, "Tx%d stop Now!\n", q_num); } else if (dir == USB_RX) { if (!(os_readl(USB_QMU_RQCSR(q_num)) & QMU_Q_ACTIVE)) { os_printk(K_DEBUG, "Rx%d inActive Now!\n", q_num); return; } os_writel(USB_QMU_RQCSR(q_num), QMU_Q_STOP); while ((os_readl(USB_QMU_RQCSR(q_num)) & (QMU_Q_ACTIVE))); os_printk(K_CRIT, "Rx%d stop now!\n", q_num); } }
/** * gpd_phys_to_virt - map gpd physical address to virtual address * @args - arg1: physical address, arg2: dir, arg3: ep number * @return - virtual address */ void *gpd_phys_to_virt(void *paddr, USB_DIR dir, DEV_UINT32 num) { DEV_UINT32 *ptr; os_printk(K_DEBUG, "%s paddr=%p, num=%d\n", __func__, paddr, num); if (dir == USB_RX) { os_printk(K_DEBUG, "%s Rx_gpd_Offset[%d]=0x%08X\n", __func__, num, Rx_gpd_Offset[num]); ptr = (DEV_UINT32 *) ((DEV_UINT32) paddr + Rx_gpd_Offset[num]); } else { os_printk(K_DEBUG, "%s Tx_gpd_Offset[%d]=0x%08X\n", __func__, num, Tx_gpd_Offset[num]); ptr = (DEV_UINT32 *) ((DEV_UINT32) paddr + Tx_gpd_Offset[num]); } /*os_printk(K_DEBUG,"%s %s[%d]phys=%p<->virt=%p\n", __func__, \ ((dir==USB_RX)?"RX":"TX"), num , paddr, ptr); */ return ptr; }
static inline void mtu3d_otg_intr_handler(u32 dwOtgIntValue) { if (dwOtgIntValue & VBUS_CHG_INTR) { os_printk(K_NOTICE, "OTG: VBUS_CHG_INTR\n"); os_setmsk(U3D_SSUSB_OTG_STS_CLR, SSUSB_VBUS_INTR_CLR); } //this interrupt is issued when B device becomes device if (dwOtgIntValue & SSUSB_CHG_B_ROLE_B) { os_printk(K_NOTICE, "OTG: CHG_B_ROLE_B\n"); os_setmsk(U3D_SSUSB_OTG_STS_CLR, SSUSB_CHG_B_ROLE_B_CLR); //switch DMA module to device os_printk(K_NOTICE, "Switch DMA to device\n"); os_clrmsk(U3D_SSUSB_U2_CTRL_0P, SSUSB_U2_PORT_HOST_SEL); } //this interrupt is issued when B device becomes host if (dwOtgIntValue & SSUSB_CHG_A_ROLE_B) { os_printk(K_NOTICE, "OTG: CHG_A_ROLE_B\n"); os_setmsk(U3D_SSUSB_OTG_STS_CLR, SSUSB_CHG_A_ROLE_B_CLR); } //this interrupt is issued when IDDIG reads B if (dwOtgIntValue & SSUSB_ATTACH_B_ROLE) { os_printk(K_NOTICE, "OTG: CHG_ATTACH_B_ROLE\n"); os_setmsk(U3D_SSUSB_OTG_STS_CLR, SSUSB_ATTACH_B_ROLE_CLR); //switch DMA module to device os_printk(K_NOTICE, "Switch DMA to device\n"); os_clrmsk(U3D_SSUSB_U2_CTRL_0P, SSUSB_U2_PORT_HOST_SEL); } }
/** * init_bd_list - initialize bd management list * @args - arg1: dir, arg2: ep number, arg3: bd virtual addr, arg4: bd ioremap addr, arg5: bd number */ void init_bd_list(USB_DIR dir, int num, PBD ptr, dma_addr_t io_ptr, DEV_UINT32 size) { if (dir == USB_RX) { Rx_bd_List[num].pStart = ptr; Rx_bd_List[num].pEnd = (PBD)(ptr + size); rx_bd_map[num].p_desc = (void *)ptr; rx_bd_map[num].p_desc_dma = io_ptr; ptr++; Rx_bd_List[num].pNext = ptr; os_printk(K_DEBUG,"Rx_bd_List[%d].pStart=%p, pNext=%p, pEnd=%p\n", \ num, Rx_bd_List[num].pStart, Rx_bd_List[num].pNext, Rx_bd_List[num].pEnd); os_printk(K_DEBUG,"rx_bd_map[%d] vir=%p dma=%08llx\n", num, rx_bd_map[num].p_desc, (unsigned long long) rx_bd_map[num].p_desc_dma); os_printk(K_DEBUG,"vir=%p dma=%08llx\n", ptr, (unsigned long long)io_ptr); } else { Tx_bd_List[num].pStart = ptr; Tx_bd_List[num].pEnd = (PBD)((DEV_UINT8*)(ptr + size) + AT_BD_EXT_LEN*size); tx_bd_map[num].p_desc = (void *)ptr; tx_bd_map[num].p_desc_dma = io_ptr; ptr++; Tx_bd_List[num].pNext = (PBD)((DEV_UINT8*)ptr + AT_BD_EXT_LEN); os_printk(K_DEBUG,"Tx_bd_List[%d].pStart=%p, pNext=%p, pEnd=%p\n", \ num,Tx_bd_List[num].pStart, Tx_bd_List[num].pNext, Tx_bd_List[num].pEnd); os_printk(K_DEBUG,"tx_bd_map[%d] vir=%p dma=%08llx\n", num, tx_bd_map[num].p_desc, (unsigned long long) tx_bd_map[num].p_desc_dma); os_printk(K_DEBUG,"vir=%p, dma=%08llx\n", ptr, (unsigned long long)io_ptr); } }
/* * @brief dump memory * @param addr -i- memory address * nb -i- number of bytes to dump * type -i- byte, half-word or word * @return none * @note TODO Only supports nb that can be divide by 8. * TODO Need to complete type implementation. */ void _mm_dump(void *addr, int32 nb, int32 type) { uint8 *m = (uint8 *) addr; int32 i, row; row = nb / 8; for (i = 0; i < row; i++) { m = (uint8 *) addr + i * 8; os_printk(LOG_INFO, "%08x: %02x %02x %02x %02x %02x %02x %02x %02x\n", m, *m, *(m + 1), *(m + 2), *(m + 3), *(m + 4), *(m + 5), *(m + 6), *(m + 7)); } }
/** * mu3d_hal_gpd_virt_to_phys - map gpd virtual address to physical address * @args - arg1: virtual address, arg2: dir, arg3: ep number * @return - physical address */ dma_addr_t mu3d_hal_gpd_virt_to_phys(void *vaddr, USB_DIR dir, DEV_UINT32 num) { uintptr_t ptr; if (dir == USB_RX) { ptr = rx_gpd_map[num].p_desc_dma + (dma_addr_t)(vaddr - rx_gpd_map[num].p_desc); } else { ptr = tx_gpd_map[num].p_desc_dma + (dma_addr_t)(vaddr - tx_gpd_map[num].p_desc); } os_printk( K_DEBUG, "%s %s[%d]phys=%lx<->virt=%p\n", __func__, \ ((dir == USB_RX) ? "RX" : "TX"), num, ptr, vaddr); return (dma_addr_t)ptr; }
bool mt_usb_is_device(void) { os_printk(K_INFO, "%s\n", __func__); #ifdef NEVER if(!mtk_musb){ DBG(0,"mtk_musb is NULL\n"); return false; // don't do charger detection when usb is not ready } else { DBG(4,"is_host=%d\n",mtk_musb->is_host); } return !mtk_musb->is_host; #endif /* NEVER */ return true; }
/* * This work is to fix IOT problem. * 1. PC(Lenovo MT-M5852-B88) + USB Host PCI-e TI(TUSB7340) or Fresco, * --> PC enter SLERP/HIBERNATION --> USER wake up PC --> PC can not detect device. * 2. PC(Lenovo MT-M5852-B88) + USB Host PCI-e Fresco, * --> PC COLD reboot --> PC can not detect device. * The root cause is that device try to link host too early. XHCI host does not ready to linkup. * So create a delayed work to re-tran when device is stuck at RxDetect. */ void check_ltssm_work(struct work_struct *data) { //struct musb *musb = container_of(to_delayed_work(data), struct musb, check_ltssm_work); #ifndef CONFIG_USBIF_COMPLIANCE os_printk(K_INFO, "%s %x\n", __func__, sts_ltssm); if(sts_ltssm == RXDET_SUCCESS_INTR) { sts_ltssm = 0; mu3d_hal_u3dev_dis(); mdelay(10); mu3d_hal_u3dev_en(); } #endif }