1
0
uboot-1.1.4-kirkwood/board/mv_feroceon/USP/mv_usb_dev.c

380 lines
9.0 KiB
C
Raw Normal View History

2024-01-09 13:41:15 +01:00
/*******************************************************************************
Copyright (C) Marvell International Ltd. and its affiliates
********************************************************************************
Marvell GPL License Option
If you received this File from Marvell, you may opt to use, redistribute and/or
modify this File in accordance with the terms and conditions of the General
Public License Version 2, June 1991 (the "GPL License"), a copy of which is
available along with the File in the license.txt file or by writing to the Free
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 or
on the worldwide web at http://www.gnu.org/licenses/gpl.txt.
THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE IMPLIED
WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE ARE EXPRESSLY
DISCLAIMED. The GPL License provides additional details about this warranty
disclaimer.
*******************************************************************************/
#include <config.h>
#include <common.h>
#include <command.h>
#include "mvOs.h"
#include "mvCommon.h"
#include "mvDebug.h"
#include "mvBoardEnvSpec.h"
#include "mvUsb.h"
#include "mvUsbDevApi.h"
#include "disk.h"
#include "mouse.h"
#define USB_DISK_DEFAULT_SIZE 2048
extern MV_U32 mvUsbGetCapRegAddr(int devNo);
typedef struct
{
_usb_device_handle handle;
MV_BOOL isMouse;
int gppNo;
} MV_USB_DEVICE;
MV_BOOL mvUsbIsFirst = MV_TRUE;
MV_USB_DEVICE mvUsbDevice[MV_BOARD_MAX_USB_IF];
USB_IMPORT_FUNCS usbImportFuncs =
{
printf,
mvOsSPrintf,
mvOsIoUncachedMalloc,
mvOsIoUncachedFree,
mvOsMalloc,
mvOsFree,
memset,
memcpy,
mvOsCacheFlush,
mvOsCacheInvalidate,
mvOsIoVirtToPhy,
NULL,
NULL,
mvUsbGetCapRegAddr,
NULL
};
static void print_args(int argc, char** argv)
{
int i;
for(i=0; i<argc; i++)
{
mvOsPrintf("argv[%d]=%s, ", i, argv[i]);
}
mvOsPrintf("\n");
}
static void mvUsbDevsInit(void)
{
int dev;
for(dev=0; dev<mvCtrlUsbMaxGet(); dev++)
{
mvUsbDevice[dev].handle = NULL;
mvUsbDevice[dev].gppNo = -1;
mvUsbDevice[dev].isMouse = MV_FALSE;
mvUsbInit(dev, MV_FALSE);
#ifdef MV_USB_VOLTAGE_FIX
mvUsbDevice[dev].gppNo = mvUsbGppInit(dev);
#endif /* MV_USB_VOLTAGE_FIX */
}
/* First of all. */
_usb_device_set_bsp_funcs(&usbImportFuncs);
}
static void mvUsbPolling(void)
{
int dev, counter = 0;
mvOsPrintf("Start USB ISR polling:");
for(dev=0; dev<mvCtrlUsbMaxGet(); dev++)
{
mvOsPrintf(" dev-%d - handle=%p\n", dev, mvUsbDevice[dev].handle);
}
mvOsPrintf("\n");
while (TRUE)
{
counter++;
for(dev=0; dev<mvCtrlUsbMaxGet(); dev++)
{
if(mvUsbDevice[dev].handle == NULL)
continue;
#ifdef MV_USB_VOLTAGE_FIX
/* Polling VBUS */
if(mvUsbDevice[dev].gppNo != -1)
mvUsbBackVoltageUpdate(dev, mvUsbDevice[dev].gppNo);
#endif /* MV_USB_VOLTAGE_FIX */
/* Polling USB interrupts */
_usb_dci_vusb20_isr(mvUsbDevice[dev].handle);
if(mvUsbDevice[dev].isMouse)
{
if (counter >= 1000000)
{ /* Body */
usbMousePeriodicResume(mvUsbDevice[dev].handle);
}
} /* Endbody */
}
if( (counter & 0xFFFFF) == 0)
mvOsPrintf(".");
if (ctrlc())
{
puts ("\nAbort\n");
return;
}
} /* Endwhile */
}
static void mvUsbUnload(int dev)
{
if(mvUsbDevice[dev].handle == NULL)
{
mvOsPrintf("USB-%d Device is not loaded\n", dev);
return;
}
mvOsPrintf("Unload USB=%d Device: handle=%p\n",
dev, mvUsbDevice[dev].handle);
if(mvUsbDevice[dev].isMouse)
{
usbMouseUnload(mvUsbDevice[dev].handle);
}
else
{
usbDiskUnload(mvUsbDevice[dev].handle);
}
mvUsbDevice[dev].handle = NULL;
mvUsbDevice[dev].gppNo = -1;
mvUsbDevice[dev].isMouse = MV_FALSE;
}
static void mvUsbDisk(int dev, int diskSize)
{
if(mvUsbDevice[dev].handle != NULL)
{
mvOsPrintf("USB-%d device already in use\n", dev);
return;
}
if(diskSize == 0)
diskSize = USB_DISK_DEFAULT_SIZE;
mvOsPrintf("Load USB-%d Disk example: disk size is %d Kbytes\n",
dev, diskSize);
mvUsbDevice[dev].handle = usbDiskLoad(dev, diskSize);
if(mvUsbDevice[dev].handle == NULL)
{
mvOsPrintf("usbDiskLoad-%d FAILED\n", dev);
return;
}
mvUsbPolling();
}
static void mvUsbMouse(int dev)
{
if(mvUsbDevice[dev].handle != NULL)
{
mvOsPrintf("USB-%d device is already in use\n", dev);
return;
}
mvOsPrintf("Load USB-%d Mouse example\n", dev);
mvUsbDevice[dev].handle = usbMouseLoad(dev);
if(mvUsbDevice[dev].handle == NULL)
{
mvOsPrintf("usbMouseLoad-%d FAILED\n", dev);
return;
}
mvUsbDevice[dev].isMouse = MV_TRUE;
mvUsbPolling();
}
int mvUsbCmdMain(int argc, char *argv[])
{
_usb_device_handle handle = NULL;
int i, mode, dev;
if(mvUsbIsFirst == MV_TRUE)
{
mvUsbDevsInit();
mvUsbIsFirst = MV_FALSE;
}
if(argc <= 1)
{
mvOsPrintf("usbTest: not enough parameters\n");
return 2;
}
print_args(argc, argv);
if(memcmp(argv[1], "flags", strlen(argv[1])) == 0)
{
mvOsPrintf("USB old debug flags = 0x%x\n", _usb_debug_get_flags());
if(argc > 2)
{
mode = strtol(argv[2], NULL, 16);
_usb_debug_set_flags(mode);
mvOsPrintf("USB new debug flags = 0x%x\n", _usb_debug_get_flags());
}
return 0;
}
if(memcmp(argv[1], "poll", strlen(argv[1])) == 0)
{
mvUsbPolling();
return 0;
}
dev = 0;
if(argc > 2)
dev = strtol(argv[2], NULL, 10);
handle = mvUsbDevice[dev].handle;
if(handle == NULL)
{
mvOsPrintf("USB Device core is not initialized\n");
return 3;
}
if(memcmp(argv[1], "show", strlen(argv[1])) == 0)
{
mode = 0;
if(argc > 3)
mode = strtol(argv[3], NULL, 16);
if( MV_BIT_CHECK(mode, 0) )
_usb_regs(handle);
if( MV_BIT_CHECK(mode, 1) )
_usb_status(handle);
if( MV_BIT_CHECK(mode, 2) )
_usb_stats(handle);
if( MV_BIT_CHECK(mode, 3) )
_usb_debug_print_trace_log();
for(i=0; i<_usb_device_get_max_endpoint(handle); i++)
{
if( MV_BIT_CHECK(mode, (8+i)) )
{
_usb_ep_status(handle, i, ARC_USB_RECV);
_usb_ep_status(handle, i, ARC_USB_SEND);
}
}
return 0;
}
if(memcmp(argv[1], "test", strlen(argv[1])) == 0)
{
/* Set Test mode */
mode = 0;
if(argc > 3)
mode = strtol(argv[3], NULL, 10);
mvOsPrintf("USB test: set test mode %d\n", mode);
_usb_dci_vusb20_set_test_mode(handle, (mode & 0x7) << 8);
return 0;
}
mvOsPrintf("USB test: Unexpected command %s\n", argv[1]);
return 3;
}
int mvUsbDevMain(int argc, char *argv[])
{
int dev, diskSize = 0;
if(mvUsbIsFirst == MV_TRUE)
{
mvUsbDevsInit();
mvUsbIsFirst = MV_FALSE;
}
dev = strtol(argv[1], NULL, 10);
if(memcmp(argv[2], "disk", strlen(argv[2])) == 0)
{
if(argc > 3)
diskSize = strtol(argv[3], NULL, 10);
mvUsbDisk(dev, diskSize);
return 0;
}
if(memcmp(argv[2], "mouse", strlen(argv[2])) == 0)
{
mvUsbMouse(dev);
return 0;
}
if( memcmp(argv[2], "unload", strlen(argv[2])) == 0)
{
mvUsbUnload(dev);
return 0;
}
mvOsPrintf("usbDev unknown command\n");
return 1;
}
int mvUsbCmd(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
if( (argc == 0) || (argc == 1) )
{
mvOsPrintf ("Usage:\n%s\n", cmdtp->usage);
return 1;
}
return mvUsbCmdMain(argc, argv);
}
int mvUsbDev(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
if(argc < 2)
{
mvOsPrintf ("Usage:\n%s\n", cmdtp->usage);
return 1;
}
return mvUsbDevMain(argc, argv);
}
U_BOOT_CMD(
usbCmd, 4, 1, mvUsbCmd,
"usbCmd - USB Device sub-system\n",
"\n"
"\t usbCmd flags [mask] - Get/Set debug flags\n"
"\t usbCmd poll - Polling IRQs for all USB devices for never\n"
"\t usbCmd show <devId> [mask] - Print out USB device information\n"
"\t usbCmd test <devId> [mode] - Set USB device to test mode\n"
);
U_BOOT_CMD(
usbDev, 5, 0, mvUsbDev,
"usbDev - Load/Unload USB Devices\n",
"\t usbDev <devId> disk [kBytes] - Load USB Disk device\n"
"\t usbDev <devId> mouse - Load USB Mouse device\n"
"\t usbDev <devId> unload - Unload USB device\n"
);