diff --git a/demos/host/src/msc_host_app.c b/demos/host/src/msc_host_app.c
index 62d3b0a35..d4fe001d1 100644
--- a/demos/host/src/msc_host_app.c
+++ b/demos/host/src/msc_host_app.c
@@ -62,14 +62,14 @@ TUSB_CFG_ATTR_USBRAM static FATFS fatfs[TUSB_CFG_HOST_DEVICE_MAX];
 //--------------------------------------------------------------------+
 // tinyusb callbacks
 //--------------------------------------------------------------------+
-void tusbh_msc_mounted_cb(uint8_t dev_addr)
+void tuh_msc_mounted_cb(uint8_t dev_addr)
 {
   puts("\na MassStorage device is mounted");
 
   //------------- Disk Information -------------//
   // SCSI VendorID[8] & ProductID[16] from Inquiry Command
-  uint8_t const* p_vendor  = tusbh_msc_get_vendor_name(dev_addr);
-  uint8_t const* p_product = tusbh_msc_get_product_name(dev_addr);
+  uint8_t const* p_vendor  = tuh_msc_get_vendor_name(dev_addr);
+  uint8_t const* p_product = tuh_msc_get_product_name(dev_addr);
 
   for(uint8_t i=0; i<8; i++) putchar(p_vendor[i]);
 
@@ -78,7 +78,7 @@ void tusbh_msc_mounted_cb(uint8_t dev_addr)
   putchar('\n');
 
   uint32_t last_lba, block_size;
-  tusbh_msc_get_capacity(dev_addr, &last_lba, &block_size);
+  tuh_msc_get_capacity(dev_addr, &last_lba, &block_size);
   printf("Disk Size: %d MB\n", (last_lba+1)/ ((1024*1024)/block_size) );
   printf("LBA 0-0x%X  Block Size: %d\n", last_lba, block_size);
 
@@ -108,7 +108,7 @@ void tusbh_msc_mounted_cb(uint8_t dev_addr)
   }
 }
 
-void tusbh_msc_unmounted_cb(uint8_t dev_addr)
+void tuh_msc_unmounted_cb(uint8_t dev_addr)
 {
   puts("\na MassStorage device is unmounted");
 
@@ -131,7 +131,7 @@ void tusbh_msc_unmounted_cb(uint8_t dev_addr)
 }
 
 // invoked ISR context
-void tusbh_msc_isr(uint8_t dev_addr, tusb_event_t event, uint32_t xferred_bytes)
+void tuh_msc_isr(uint8_t dev_addr, tusb_event_t event, uint32_t xferred_bytes)
 {
   (void) dev_addr;
   (void) event;
diff --git a/tinyusb/class/msc_host.c b/tinyusb/class/msc_host.c
index 9dc86e939..b961c1724 100644
--- a/tinyusb/class/msc_host.c
+++ b/tinyusb/class/msc_host.c
@@ -67,29 +67,29 @@ TUSB_CFG_ATTR_USBRAM ATTR_ALIGNED(4) STATIC_VAR uint8_t msch_buffer[sizeof(scsi_
 //--------------------------------------------------------------------+
 // PUBLIC API
 //--------------------------------------------------------------------+
-bool tusbh_msc_is_mounted(uint8_t dev_addr)
+bool tuh_msc_is_mounted(uint8_t dev_addr)
 {
   return  tusbh_device_is_configured(dev_addr) && // is configured can be omitted
           msch_data[dev_addr-1].is_initialized;
 }
 
-bool tusbh_msc_is_busy(uint8_t dev_addr)
+bool tuh_msc_is_busy(uint8_t dev_addr)
 {
   return  msch_data[dev_addr-1].is_initialized &&
           hcd_pipe_is_busy(msch_data[dev_addr-1].bulk_in);
 }
 
-uint8_t const* tusbh_msc_get_vendor_name(uint8_t dev_addr)
+uint8_t const* tuh_msc_get_vendor_name(uint8_t dev_addr)
 {
   return msch_data[dev_addr-1].is_initialized ? msch_data[dev_addr-1].vendor_id : NULL;
 }
 
-uint8_t const* tusbh_msc_get_product_name(uint8_t dev_addr)
+uint8_t const* tuh_msc_get_product_name(uint8_t dev_addr)
 {
   return msch_data[dev_addr-1].is_initialized ? msch_data[dev_addr-1].product_id : NULL;
 }
 
-tusb_error_t tusbh_msc_get_capacity(uint8_t dev_addr, uint32_t* p_last_lba, uint32_t* p_block_size)
+tusb_error_t tuh_msc_get_capacity(uint8_t dev_addr, uint32_t* p_last_lba, uint32_t* p_block_size)
 {
   if ( !msch_data[dev_addr-1].is_initialized )   return TUSB_ERROR_MSCH_DEVICE_NOT_MOUNTED;
   ASSERT(p_last_lba != NULL && p_block_size != NULL, TUSB_ERROR_INVALID_PARA);
@@ -181,7 +181,7 @@ tusb_error_t tusbh_msc_read_capacity10(uint8_t dev_addr, uint8_t lun, uint8_t *p
   return TUSB_ERROR_NONE;
 }
 
-tusb_error_t tusbh_msc_request_sense(uint8_t dev_addr, uint8_t lun, uint8_t *p_data)
+tusb_error_t tuh_msc_request_sense(uint8_t dev_addr, uint8_t lun, uint8_t *p_data)
 {
   (void) lun; // TODO [MSCH] multiple lun support
 
@@ -206,7 +206,7 @@ tusb_error_t tusbh_msc_request_sense(uint8_t dev_addr, uint8_t lun, uint8_t *p_d
   return TUSB_ERROR_NONE;
 }
 
-tusb_error_t tusbh_msc_test_unit_ready(uint8_t dev_addr, uint8_t lun,  msc_cmd_status_wrapper_t * p_csw)
+tusb_error_t tuh_msc_test_unit_ready(uint8_t dev_addr, uint8_t lun,  msc_cmd_status_wrapper_t * p_csw)
 {
   msch_interface_t* p_msch = &msch_data[dev_addr-1];
 
@@ -233,7 +233,7 @@ tusb_error_t tusbh_msc_test_unit_ready(uint8_t dev_addr, uint8_t lun,  msc_cmd_s
   return TUSB_ERROR_NONE;
 }
 
-tusb_error_t  tusbh_msc_read10(uint8_t dev_addr, uint8_t lun, void * p_buffer, uint32_t lba, uint16_t block_count)
+tusb_error_t  tuh_msc_read10(uint8_t dev_addr, uint8_t lun, void * p_buffer, uint32_t lba, uint16_t block_count)
 {
   msch_interface_t* p_msch = &msch_data[dev_addr-1];
 
@@ -259,7 +259,7 @@ tusb_error_t  tusbh_msc_read10(uint8_t dev_addr, uint8_t lun, void * p_buffer, u
   return TUSB_ERROR_NONE;
 }
 
-tusb_error_t tusbh_msc_write10(uint8_t dev_addr, uint8_t lun, void const * p_buffer, uint32_t lba, uint16_t block_count)
+tusb_error_t tuh_msc_write10(uint8_t dev_addr, uint8_t lun, void const * p_buffer, uint32_t lba, uint16_t block_count)
 {
   msch_interface_t* p_msch = &msch_data[dev_addr-1];
 
@@ -380,7 +380,7 @@ tusb_error_t msch_open_subtask(uint8_t dev_addr, tusb_descriptor_interface_t con
     SUBTASK_ASSERT_STATUS(error);
 
     //------------- SCSI Request Sense -------------//
-    (void) tusbh_msc_request_sense(dev_addr, 0, msch_buffer);
+    (void) tuh_msc_request_sense(dev_addr, 0, msch_buffer);
     osal_semaphore_wait(msch_sem_hdl, SCSI_XFER_TIMEOUT, &error);
     SUBTASK_ASSERT_STATUS(error);
 
@@ -394,7 +394,7 @@ tusb_error_t msch_open_subtask(uint8_t dev_addr, tusb_descriptor_interface_t con
   msch_data[dev_addr-1].block_size = (uint16_t) __be2n( ((scsi_read_capacity10_data_t*)msch_buffer)->block_size );
 
   msch_data[dev_addr-1].is_initialized = true;
-  tusbh_msc_mounted_cb(dev_addr);
+  tuh_msc_mounted_cb(dev_addr);
 
   OSAL_SUBTASK_END
 }
@@ -405,7 +405,7 @@ void msch_isr(pipe_handle_t pipe_hdl, tusb_event_t event, uint32_t xferred_bytes
   {
     if (msch_data[pipe_hdl.dev_addr-1].is_initialized)
     {
-      tusbh_msc_isr(pipe_hdl.dev_addr, event, xferred_bytes);
+      tuh_msc_isr(pipe_hdl.dev_addr, event, xferred_bytes);
     }else
     { // still initializing under open subtask
       ASSERT( TUSB_ERROR_NONE == osal_semaphore_post(msch_sem_hdl), VOID_RETURN );
@@ -421,7 +421,7 @@ void msch_close(uint8_t dev_addr)
   memclr_(&msch_data[dev_addr-1], sizeof(msch_interface_t));
   osal_semaphore_reset(msch_sem_hdl);
 
-  tusbh_msc_unmounted_cb(dev_addr); // invoke Application Callback
+  tuh_msc_unmounted_cb(dev_addr); // invoke Application Callback
 }
 
 //--------------------------------------------------------------------+
diff --git a/tinyusb/class/msc_host.h b/tinyusb/class/msc_host.h
index 46ee139dd..9eb79f3c0 100644
--- a/tinyusb/class/msc_host.h
+++ b/tinyusb/class/msc_host.h
@@ -60,17 +60,17 @@
  * \retval      true if device supports
  * \retval      false if device does not support or is not mounted
  */
-bool          tusbh_msc_is_mounted(uint8_t dev_addr) ATTR_PURE ATTR_WARN_UNUSED_RESULT;
+bool          tuh_msc_is_mounted(uint8_t dev_addr) ATTR_PURE ATTR_WARN_UNUSED_RESULT;
 
 /** \brief      Check if the interface is currently busy or not
  * \param[in]   dev_addr device address
  * \retval      true if the interface is busy meaning the stack is still transferring/waiting data from/to device
  * \retval      false if the interface is not busy meaning the stack successfully transferred data from/to device
  * \note        This function is used to check if previous transfer is complete (success or error), so that the next transfer
- *              can be scheduled. User needs to make sure the corresponding interface is mounted (by \ref tusbh_msc_is_mounted)
+ *              can be scheduled. User needs to make sure the corresponding interface is mounted (by \ref tuh_msc_is_mounted)
  *              before calling this function
  */
-bool          tusbh_msc_is_busy(uint8_t dev_addr) ATTR_PURE ATTR_WARN_UNUSED_RESULT;
+bool          tuh_msc_is_busy(uint8_t dev_addr) ATTR_PURE ATTR_WARN_UNUSED_RESULT;
 
 /** \brief      Get SCSI vendor's name of MassStorage device
  * \param[in]   dev_addr device address
@@ -79,7 +79,7 @@ bool          tusbh_msc_is_busy(uint8_t dev_addr) ATTR_PURE ATTR_WARN_UNUSED_RES
  *              retrieved (via SCSI INQUIRY) and store this information internally. There is no need for application to re-send SCSI INQUIRY
  *              command or allocate buffer for this.
  */
-uint8_t const* tusbh_msc_get_vendor_name(uint8_t dev_addr);
+uint8_t const* tuh_msc_get_vendor_name(uint8_t dev_addr);
 
 /** \brief      Get SCSI product's name of MassStorage device
  * \param[in]   dev_addr device address
@@ -88,7 +88,7 @@ uint8_t const* tusbh_msc_get_vendor_name(uint8_t dev_addr);
  *              retrieved (via SCSI INQUIRY) and store this information internally. There is no need for application to re-send SCSI INQUIRY
  *              command or allocate buffer for this.
  */
-uint8_t const* tusbh_msc_get_product_name(uint8_t dev_addr);
+uint8_t const* tuh_msc_get_product_name(uint8_t dev_addr);
 
 /** \brief      Get SCSI Capacity of MassStorage device
  * \param[in]   dev_addr device address
@@ -99,7 +99,7 @@ uint8_t const* tusbh_msc_get_product_name(uint8_t dev_addr);
  *              retrieved (via SCSI READ CAPACITY 10) and store this information internally. There is no need for application
  *              to re-send SCSI READ CAPACITY 10 command
  */
-tusb_error_t tusbh_msc_get_capacity(uint8_t dev_addr, uint32_t* p_last_lba, uint32_t* p_block_size);
+tusb_error_t tuh_msc_get_capacity(uint8_t dev_addr, uint32_t* p_last_lba, uint32_t* p_block_size);
 
 /** \brief 			Perform SCSI READ 10 command to read data from MassStorage device
  * \param[in]		dev_addr	device address
@@ -113,7 +113,7 @@ tusb_error_t tusbh_msc_get_capacity(uint8_t dev_addr, uint32_t* p_last_lba, uint
  * \retval      TUSB_ERROR_INVALID_PARA if input parameters are not correct
  * \note        This function is non-blocking and returns immediately. The result of USB transfer will be reported by the interface's callback function
  */
-tusb_error_t tusbh_msc_read10 (uint8_t dev_addr, uint8_t lun, void * p_buffer, uint32_t lba, uint16_t block_count) ATTR_WARN_UNUSED_RESULT;
+tusb_error_t tuh_msc_read10 (uint8_t dev_addr, uint8_t lun, void * p_buffer, uint32_t lba, uint16_t block_count) ATTR_WARN_UNUSED_RESULT;
 
 /** \brief 			Perform SCSI WRITE 10 command to write data to MassStorage device
  * \param[in]		dev_addr	device address
@@ -127,7 +127,7 @@ tusb_error_t tusbh_msc_read10 (uint8_t dev_addr, uint8_t lun, void * p_buffer, u
  * \retval      TUSB_ERROR_INVALID_PARA if input parameters are not correct
  * \note        This function is non-blocking and returns immediately. The result of USB transfer will be reported by the interface's callback function
  */
-tusb_error_t tusbh_msc_write10(uint8_t dev_addr, uint8_t lun, void const * p_buffer, uint32_t lba, uint16_t block_count) ATTR_WARN_UNUSED_RESULT;
+tusb_error_t tuh_msc_write10(uint8_t dev_addr, uint8_t lun, void const * p_buffer, uint32_t lba, uint16_t block_count) ATTR_WARN_UNUSED_RESULT;
 
 /** \brief 			Perform SCSI REQUEST SENSE command, used to retrieve sense data from MassStorage device
  * \param[in]		dev_addr	device address
@@ -139,7 +139,7 @@ tusb_error_t tusbh_msc_write10(uint8_t dev_addr, uint8_t lun, void const * p_buf
  * \retval      TUSB_ERROR_INVALID_PARA if input parameters are not correct
  * \note        This function is non-blocking and returns immediately. The result of USB transfer will be reported by the interface's callback function
  */
-tusb_error_t tusbh_msc_request_sense(uint8_t dev_addr, uint8_t lun, uint8_t *p_data);
+tusb_error_t tuh_msc_request_sense(uint8_t dev_addr, uint8_t lun, uint8_t *p_data);
 
 /** \brief 			Perform SCSI TEST UNIT READY command to test if MassStorage device is ready
  * \param[in]		dev_addr	device address
@@ -150,7 +150,7 @@ tusb_error_t tusbh_msc_request_sense(uint8_t dev_addr, uint8_t lun, uint8_t *p_d
  * \retval      TUSB_ERROR_INVALID_PARA if input parameters are not correct
  * \note        This function is non-blocking and returns immediately. The result of USB transfer will be reported by the interface's callback function
  */
-tusb_error_t tusbh_msc_test_unit_ready(uint8_t dev_addr, uint8_t lun, msc_cmd_status_wrapper_t * p_csw) ATTR_WARN_UNUSED_RESULT; // TODO to be refractor
+tusb_error_t tuh_msc_test_unit_ready(uint8_t dev_addr, uint8_t lun, msc_cmd_status_wrapper_t * p_csw) ATTR_WARN_UNUSED_RESULT; // TODO to be refractor
 
 //tusb_error_t  tusbh_msc_scsi_send(uint8_t dev_addr, uint8_t lun, bool is_direction_in,
 //                                  uint8_t const * p_command, uint8_t cmd_len,
@@ -161,13 +161,13 @@ tusb_error_t tusbh_msc_test_unit_ready(uint8_t dev_addr, uint8_t lun, msc_cmd_st
  * \param[in]	  dev_addr Address of newly mounted device
  * \note        This callback should be used by Application to set-up interface-related data
  */
-void tusbh_msc_mounted_cb(uint8_t dev_addr);
+void tuh_msc_mounted_cb(uint8_t dev_addr);
 
 /** \brief 			Callback function that will be invoked when a device with MassStorage interface is unmounted
  * \param[in] 	dev_addr Address of newly unmounted device
  * \note        This callback should be used by Application to tear-down interface-related data
  */
-void tusbh_msc_unmounted_cb(uint8_t dev_addr);
+void tuh_msc_unmounted_cb(uint8_t dev_addr);
 
 /** \brief      Callback function that is invoked when an transferring event occurred
  * \param[in]		dev_addr	Address of device
@@ -179,7 +179,7 @@ void tusbh_msc_unmounted_cb(uint8_t dev_addr);
  *              - TUSB_EVENT_XFER_STALLED : previously scheduled transfer is stalled by device.
  * \note
  */
-void tusbh_msc_isr(uint8_t dev_addr, tusb_event_t event, uint32_t xferred_bytes);
+void tuh_msc_isr(uint8_t dev_addr, tusb_event_t event, uint32_t xferred_bytes);
 
 
 //--------------------------------------------------------------------+
diff --git a/vendor/fatfs/diskio.c b/vendor/fatfs/diskio.c
index 83d20f1ba..130f6860d 100644
--- a/vendor/fatfs/diskio.c
+++ b/vendor/fatfs/diskio.c
@@ -60,7 +60,7 @@ static DSTATUS disk_state[TUSB_CFG_HOST_DEVICE_MAX];
 static DRESULT wait_for_io_complete(uint8_t usb_addr)
 {
   // TODO with RTOS, this should use semaphore instead of blocking
-  while ( tusbh_msc_is_busy(usb_addr) )
+  while ( tuh_msc_is_busy(usb_addr) )
   {
     // TODO should have timeout here
     #if TUSB_CFG_OS != TUSB_OS_NONE
@@ -106,7 +106,7 @@ DRESULT disk_read (BYTE pdrv, BYTE*buff, DWORD sector, BYTE count)
 {
   uint8_t usb_addr = pdrv+1;
 
-	if ( TUSB_ERROR_NONE != tusbh_msc_read10(usb_addr, 0, buff, sector, count) )		return RES_ERROR;
+	if ( TUSB_ERROR_NONE != tuh_msc_read10(usb_addr, 0, buff, sector, count) )		return RES_ERROR;
 
 	return wait_for_io_complete(usb_addr);
 }
@@ -116,7 +116,7 @@ DRESULT disk_write (BYTE pdrv, const BYTE* buff, DWORD sector, BYTE count)
 {
   uint8_t usb_addr = pdrv+1;
 
-	if ( TUSB_ERROR_NONE != tusbh_msc_write10(usb_addr, 0, buff, sector, count) )		return RES_ERROR;
+	if ( TUSB_ERROR_NONE != tuh_msc_write10(usb_addr, 0, buff, sector, count) )		return RES_ERROR;
 
 	return wait_for_io_complete(usb_addr);
 }