/******************************************************************************* NAME $RCSfile: usbTest.c,v $ SUMMARY USB device Test VERSION $Revision: 1.3 $ UPDATE DATE $Date: 2009/08/25 11:56:01 $ PROGRAMMER $Author: lecter $ Copyright 2009 LSI Corporation. All Rights Reserved. DESCRIPTION: The functions used to diagnose USB device REFERENCE: *******************************************************************************/ #define __SRCusbTest /*** INCLUDES ***/ #include #include #include #include #include #include #include "commSCSI.h" #include "commPattern.h" #include "commRpt.h" #include "commMEC.h" #include "usbStruct.h" #include "usbLib.h" /*** MACRO DEFINITIONS ***/ #define M_USB_REPORT_PROGRESS(str, cur, rpt, incr) do { \ cur+=incr; \ if ((cur > 0) && (cur > rpt)) { \ commPostProgress(str, cur, USB_TEST_TOTAL_PROGRESS_UINT); \ rpt = cur; \ } else if ((incr == 0) && (cur != USB_TEST_TOTAL_PROGRESS_UINT)){ \ commPostProgress(str, USB_TEST_TOTAL_PROGRESS_UINT, USB_TEST_TOTAL_PROGRESS_UINT); \ } \ } while (0) /*** EXTERNAL REFERENCES ***/ extern unsigned long gDiagAvailAddr; extern VOID usbGetFlashDeviceList(struct list_head *pFlashDevList, UINT8 testItemCode); extern BOOLEAN usbTransferVerify(VOID *pSrcBuf, VOID *pDstBuf, UINT32 length); /*** FORWARE REFERENCES ***/ LOCAL int usbDiagUSBDesc(USBCB* pUCB); LOCAL VOID usbDiagUSBCapacity(USBCB* pUCB); LOCAL VOID usbDiagUSBTransfer(USBCB* pUCB); LOCAL VOID usbDiagUSBPerformance(USBCB* pUCB); LOCAL UINT32 usbGetTotalSector(struct scsi_device *pSDev, INT8 itemCode); /*** GLOBAL DATA ***/ UINT8 gExpUSBFlashDeviceNum = USB_TEST_DEFAULT_FLASH_DEVICE; /*** PROCEDURES ***/ /******************************************************************************* * PROCEDURE * * NAME: usbIntfaceTest * SUMMARY: USB Infterface Test * SCOPE: public * * DESCRIPTION: This function perform the diagnostics on the USB inferface * * RETURNS: * * NOTES: * */ PUBLIC VOID usbIntfaceTest(VOID) { struct list_head USBFlashDevList; USBCB* pUCB; USBCB* _pUCB; INIT_LIST_HEAD(&USBFlashDevList); /*get flash device list*/ usbGetFlashDeviceList(&USBFlashDevList, USB_DIAG_ITEM_CODE_INTERFACE); /*Perform test on eache flash device*/ list_for_each_entry_safe(pUCB, _pUCB, &USBFlashDevList, nodeUCB) { if( usbDiagUSBDesc(pUCB)== 0){ usbDiagUSBCapacity(pUCB); } list_del(&pUCB->nodeUCB); kfree(pUCB); } } /******************************************************************************* * PROCEDURE * * NAME: usbTransferTest * SUMMARY: USB Data Transfer Test * SCOPE: public * * DESCRIPTION: This function peform USB data transfer test * * RETURNS: * * NOTES: * */ PUBLIC VOID usbTransferTest(VOID) { struct list_head USBFlashDevList; USBCB* pUCB; USBCB* _pUCB; INIT_LIST_HEAD(&USBFlashDevList); /*get flash device list*/ usbGetFlashDeviceList(&USBFlashDevList, USB_DIAG_ITEM_CODE_TRANSFER); /*Perform test on eache flash device*/ list_for_each_entry_safe(pUCB, _pUCB, &USBFlashDevList, nodeUCB) { usbDiagUSBTransfer(pUCB); list_del(&pUCB->nodeUCB); kfree(pUCB); } } /******************************************************************************* * PROCEDURE * * NAME: usbPerfromanceTest * SUMMARY: USB Performance Test * SCOPE: public * * DESCRIPTION: This function peform USB performance test * * RETURNS: * * NOTES: * */ PUBLIC VOID usbPerfromanceTest(VOID) { struct list_head USBFlashDevList; USBCB* pUCB; USBCB* _pUCB; INIT_LIST_HEAD(&USBFlashDevList); /*get flash device list*/ usbGetFlashDeviceList(&USBFlashDevList, USB_DIAG_ITEM_CODE_PERFORMANCE); /*Perform test on eache flash device*/ list_for_each_entry_safe(pUCB, _pUCB, &USBFlashDevList, nodeUCB) { usbDiagUSBPerformance(pUCB); list_del(&pUCB->nodeUCB); kfree(pUCB); } } /******************************************************************************* * PROCEDURE * * NAME: usbDiagUSBDescriptor * SUMMARY: USB Diagnostic Information * SCOPE: public * * DESCRIPTION: This function peform to get the USB Diagnostic information * * RETURNS: * * NOTES: * */ LOCAL int usbDiagUSBDesc(USBCB* pUCB) { struct usb_device* pUSBDev; struct usb_interface* pUSBInterface; struct usb_host_interface* pUSBHostInterface; struct usb_host_endpoint* pUSBHostEndpoint; struct usb_device_descriptor* pUSBDeviceDesc; struct usb_config_descriptor* pUSBConfigDesc; struct usb_interface_descriptor* pUSBInterfaceDesc; struct usb_endpoint_descriptor* pUSBEndpointDesc = NULL; UINT8 idxInf; UINT8 idxEndpoint; UINT8 numEndpoint; UINT8 errorStatus; errorStatus = 0; pUSBDev = pUCB->pUSBDev; if(pUSBDev) { pUSBDeviceDesc = &pUSBDev->descriptor; if((pUSBDeviceDesc->bDescriptorType != USB_DT_DEVICE) || (pUSBDeviceDesc->bDeviceClass != USB_STORAGE_DEVICE_DEVICE_CLASS) || (pUSBDeviceDesc->bDeviceSubClass != USB_STORAGE_DEVICE_DEVICE_SUB_CLASS) || (pUSBDeviceDesc->bDeviceProtocol != USB_STORAGE_DEVICE_DEVICE_PROTOCOL) || (pUSBDeviceDesc->bNumConfigurations != USB_STORAGE_DEVICE_NUM_CONFIGURATIONS)) { //the usb device descriptor doesn't confirm to USB Mass Storage Spec errorStatus |= USB_STORAGE_DEVICE_ERROR; printk("Device:%x %x %x %x\n", pUSBDeviceDesc->bDeviceClass, pUSBDeviceDesc->bDeviceSubClass, pUSBDeviceDesc->bDeviceProtocol, pUSBDeviceDesc->bNumConfigurations); } if(pUSBDev->actconfig) { pUSBConfigDesc = &pUSBDev->actconfig->desc; if((pUSBConfigDesc->bDescriptorType != USB_DT_CONFIG) || (pUSBConfigDesc->bmAttributes != USB_STORAGE_CONFIG_M_ATTRIBUTE)) { //the usb configuration descriptor doesn't confirm to USB Mass Storage Spec errorStatus |= USB_STORAGE_CONFIG_ERROR; printk("Config:%x\n", pUSBConfigDesc->bmAttributes); } for(idxInf = 0; idxInf < pUSBConfigDesc->bNumInterfaces; idxInf++) { pUSBInterface = pUSBDev->actconfig->interface[idxInf]; if(pUSBInterface->cur_altsetting) { pUSBHostInterface = &pUSBInterface->cur_altsetting[0]; pUSBInterfaceDesc = &pUSBHostInterface->desc; if( (pUSBInterfaceDesc->bDescriptorType != USB_DT_INTERFACE) || (pUSBInterfaceDesc->bInterfaceClass != USB_STORAGE_INTERFACE_CLASS) || (pUSBInterfaceDesc->bInterfaceSubClass != USB_STORAGE_INTERFACE_SUB_CLASS) || (pUSBInterfaceDesc->bInterfaceProtocol != USB_STORAGE_INTERFACE_PROTOCOL)) { //the usb interface descriptor doesn't confirm to USB Mass Storage Spec errorStatus |= USB_STORAGE_INTERFACE_ERROR; printk("Inf: %x %x %x\n", pUSBInterfaceDesc->bInterfaceClass, pUSBInterfaceDesc->bInterfaceSubClass, pUSBInterfaceDesc->bInterfaceProtocol); } numEndpoint = 0; for(idxEndpoint = 0; idxEndpoint < pUSBInterfaceDesc->bNumEndpoints; idxEndpoint++) { pUSBHostEndpoint = &pUSBHostInterface->endpoint[idxEndpoint]; if(pUSBHostEndpoint) { pUSBEndpointDesc = &pUSBHostEndpoint->desc; if( (pUSBEndpointDesc->bDescriptorType == USB_DT_ENDPOINT) && (pUSBEndpointDesc->bmAttributes == USB_STORAGE_ENDPOINT_M_ATTRIBUTES) ) { numEndpoint++; } else { //Special case, if transfer type is "interrupt" still can prceed. if(pUSBEndpointDesc->bmAttributes != USB_STORAGE_ENDPOINT_TRANTYPE_INTERRUPT){ printk("End: %x\n", pUSBEndpointDesc->bmAttributes); errorStatus |= USB_STORAGE_ENDPOINT_ERROR; } } } else { //the usb host endpoint has not been detected errorStatus |= USB_STORAGE_ENDPOINT_ERROR; printk("No USB endpoint detected!\n"); } } if(numEndpoint < 2) { //the usb endpoint lass then two errorStatus |= USB_STORAGE_ENDPOINT_ERROR; printk("Too few endpoints detected: expected 2 or more, received %x\n", numEndpoint); } } else { //the usb interface has not been detected errorStatus |= USB_STORAGE_INTERFACE_ERROR; } } } else { //the usb configuration has not been detected errorStatus |= USB_STORAGE_CONFIG_ERROR; } } else { //the usb configuration has not been detected errorStatus |= USB_STORAGE_DEVICE_ERROR; } if(errorStatus != 0) { commReportError(MEC_COMP_CODE_TEMP, USB_DIAG_ITEM_CODE_INTERFACE, USB_DIAG_ERROR_CODE_USB_CONFIG_ERR, USB_DIAG_ERROR_MSG_USB_CONFIG_ERR, 0, (INT64)errorStatus, 0, DG_PCH_MSG_FORMAT); } return errorStatus; } /******************************************************************************* * PROCEDURE * * NAME: usbDiagUSBCapacity * SUMMARY: USB Diagnostic Capacity information * SCOPE: public * * DESCRIPTION: This function peform to get the USB Capacity information * * RETURNS: * * NOTES: * */ LOCAL VOID usbDiagUSBCapacity(USBCB* pUCB) { struct Scsi_Host* pSHost; struct scsi_device* pSDev; INT32 rcUSBOp; UINT32 sectorTotal = 0; VOID* pBuffer; pSHost = us_to_host(pUCB->pUSData); shost_for_each_device(pSDev, pSHost) { /*alloc data buffer for read*/ pBuffer = kmalloc(pSDev->sector_size, GFP_KERNEL); /*read total sector number from usb device*/ sectorTotal = usbGetTotalSector(pSDev, USB_DIAG_ITEM_CODE_INTERFACE); /*read last sector from usb device*/ rcUSBOp = scsiRead(pSDev, sectorTotal - 1, 1, pBuffer); if(rcUSBOp) { commReportError(MEC_COMP_CODE_TEMP, USB_DIAG_ITEM_CODE_INTERFACE, USB_DIAG_ERROR_CODE_CAPACITY_ERROR, USB_DIAG_ERROR_MSG_CAPACITY_ERROR, (INT64)sectorTotal - 1, 0, (INT64)rcUSBOp, DG_PCH_IO_FORMAT); return; } kfree(pBuffer); } } /******************************************************************************* * PROCEDURE * * NAME: usbDiagUSBTransfer * SUMMARY: USB Transfer data operation * SCOPE: public * * DESCRIPTION: This function peform USB transfer data test * * RETURNS: * * NOTES: * */ LOCAL VOID usbDiagUSBTransfer(USBCB* pUCB) { struct Scsi_Host* pSHost; struct scsi_device* pSDev; UINT32 offset; UINT32 sectorTest; UINT32 sectorLast; UINT32 sizeTestBuffer; VOID* pOrigBuffer = NULL; VOID* pWriteBuffer = NULL; VOID* pReadBuffer = NULL; INT32 rcUSBOp; BOOLEAN hitError = FALSE; pSHost = us_to_host(pUCB->pUSData); shost_for_each_device(pSDev, pSHost) { sizeTestBuffer = USB_TRANSFER_TEST_SIZE * pSDev->sector_size; rcUSBOp = 0; /*alloc data buffer to backup up disk data*/ pOrigBuffer = kmalloc(sizeTestBuffer, GFP_KERNEL); if(pOrigBuffer == NULL) { commReportError(MEC_COMP_CODE_TEMP, USB_DIAG_ITEM_CODE_TRANSFER, USB_DIAG_ERROR_CODE_KMALLOC_FAILED, USB_DIAG_ERROR_MSG_KMALLOC_FAILED, 0, 0, 0, DG_FORMAT_NONE); return; } /*alloc data buffer for write*/ pWriteBuffer = kmalloc(sizeTestBuffer, GFP_KERNEL); if(pWriteBuffer == NULL) { commReportError(MEC_COMP_CODE_TEMP, USB_DIAG_ITEM_CODE_TRANSFER, USB_DIAG_ERROR_CODE_KMALLOC_FAILED, USB_DIAG_ERROR_MSG_KMALLOC_FAILED, 0, 0, 0, DG_FORMAT_NONE); kfree(pOrigBuffer); return; } /*alloc data buffer for read*/ pReadBuffer = kmalloc(sizeTestBuffer, GFP_KERNEL); if(pReadBuffer == NULL) { commReportError(MEC_COMP_CODE_TEMP, USB_DIAG_ITEM_CODE_TRANSFER, USB_DIAG_ERROR_CODE_KMALLOC_FAILED, USB_DIAG_ERROR_MSG_KMALLOC_FAILED, 0, 0, 0, DG_FORMAT_NONE); kfree(pOrigBuffer); kfree(pWriteBuffer); return; } memset(pWriteBuffer, 0xF0, sizeTestBuffer); memset(pReadBuffer, 0x0F, sizeTestBuffer); /*Set up first sector and last sector to perform test*/ sectorLast = usbGetTotalSector(pSDev, USB_DIAG_ITEM_CODE_TRANSFER); sectorTest = USB_TEST_OFFSET_IN_SECTOR; offset = 1; while(sectorTest <= sectorLast) { /*read original data from USB device to memory*/ rcUSBOp = scsiRead(pSDev, sectorTest, USB_TRANSFER_TEST_SIZE, pOrigBuffer); if(rcUSBOp) { commReportError(MEC_COMP_CODE_TEMP, USB_DIAG_ITEM_CODE_TRANSFER, USB_DIAG_ERROR_CODE_RD_CMD_EXEC_FAILED, USB_DIAG_ERROR_MSG_RD_CMD_EXEC_FAILED, (INT64)sectorTest, 0, (INT64)rcUSBOp, DG_PCH_IO_FORMAT); break; } /*write test data to USB device*/ rcUSBOp = scsiWrite(pSDev, sectorTest, USB_TRANSFER_TEST_SIZE, pWriteBuffer); if(rcUSBOp) { commReportError(MEC_COMP_CODE_TEMP, USB_DIAG_ITEM_CODE_TRANSFER, USB_DIAG_ERROR_CODE_WR_CMD_EXEC_FAILED, USB_DIAG_ERROR_MSG_WR_CMD_EXEC_FAILED, (INT64)sectorTest, 0, (INT64)rcUSBOp, DG_PCH_IO_FORMAT); hitError = TRUE; } /*read test data from USB device*/ rcUSBOp = scsiRead(pSDev, sectorTest, USB_TRANSFER_TEST_SIZE, pReadBuffer); if(rcUSBOp) { commReportError(MEC_COMP_CODE_TEMP, USB_DIAG_ITEM_CODE_TRANSFER, USB_DIAG_ERROR_CODE_RD_CMD_EXEC_FAILED, USB_DIAG_ERROR_MSG_RD_CMD_EXEC_FAILED, (INT64)sectorTest, 0, (INT64)rcUSBOp, DG_PCH_IO_FORMAT); hitError = TRUE; } /*verify data read from USB device*/ if (!usbTransferVerify(pWriteBuffer, pReadBuffer, sizeTestBuffer)){ commReportError(MEC_COMP_CODE_TEMP, USB_DIAG_ITEM_CODE_TRANSFER, USB_DIAG_ERROR_CODE_DATA_TRANSFER_ERR, USB_DIAG_ERROR_MSG_DATA_TRANSFER_ERR, (INT64)sectorTest, (INT64)*((UINT32 *)pWriteBuffer), (INT64)*((UINT32 *)pReadBuffer), DG_PCH_IO_FORMAT); hitError = TRUE; } /*recover original data on USB device*/ rcUSBOp = scsiWrite(pSDev, sectorTest, USB_TRANSFER_TEST_SIZE, pOrigBuffer); if(rcUSBOp) { commReportError(MEC_COMP_CODE_TEMP, USB_DIAG_ITEM_CODE_TRANSFER, USB_DIAG_ERROR_CODE_WR_CMD_EXEC_FAILED, USB_DIAG_ERROR_MSG_WR_CMD_EXEC_FAILED, (INT64)sectorTest, 0, (INT64)rcUSBOp, DG_PCH_IO_FORMAT); hitError = TRUE; } memset(pReadBuffer, 0x0F, sizeTestBuffer); /*reach last sector*/ if(hitError || (sectorTest == sectorLast - 1)) break; /*move to next testing sector*/ sectorTest += offset; offset *= 2; if(sectorTest > sectorLast) sectorTest = sectorLast - 1; } } /*Free testing buffer*/ kfree(pOrigBuffer); kfree(pWriteBuffer); kfree(pReadBuffer); } /******************************************************************************* * PROCEDURE * * NAME: usbDiagUSBPerformance * SUMMARY: USB Performance Test * SCOPE: public * * DESCRIPTION: This function peform USB performance test * * RETURNS: * * NOTES: * */ LOCAL VOID usbDiagUSBPerformance(USBCB* pUCB) { struct Scsi_Host* pSHost; struct scsi_device* pSDev; UINT32 sectorTest; UINT32 sectorLast; UINT8 idx; VOID* pTestBuf; VOID* pDataBuf; UINT64 addrData; UINT8 repeatOP = 0; unsigned long startTestTime; unsigned long totalTestTime; INT32 rcUSBOp; UINT32 rptProcess = 0; // The reported progress counter UINT32 curProcess = 0; // The current progress counter UINT32 rptPoint = 0; totalTestTime = 0; pTestBuf = kmalloc(USB_FLASH_MAX_TRANSFER_SIZE, GFP_KERNEL); if(pTestBuf == NULL) { commReportError(MEC_COMP_CODE_TEMP, USB_DIAG_ITEM_CODE_PERFORMANCE, USB_DIAG_ERROR_CODE_KMALLOC_FAILED, USB_DIAG_ERROR_MSG_KMALLOC_FAILED, 0, 0, 0, DG_FORMAT_NONE); return; } pSHost = us_to_host(pUCB->pUSData); shost_for_each_device(pSDev, pSHost) { /*alloc buffer for transfer*/ sectorTest = USB_TEST_OFFSET_IN_SECTOR; sectorLast = sectorTest + USB_FLASH_PERFORMANCE_TEST_SIZE / pSDev->sector_size; addrData = gDiagAvailAddr; rptPoint = USB_FLASH_PERFORMANCE_RPT_VALUE; while(sectorTest < sectorLast) { rcUSBOp = scsiRead(pSDev, sectorTest, USB_FLASH_MAX_TRANSFER_SIZE / pSDev->sector_size, pTestBuf); if(rcUSBOp) { commReportError(MEC_COMP_CODE_TEMP, USB_DIAG_ITEM_CODE_PERFORMANCE, USB_DIAG_ERROR_CODE_RD_CMD_EXEC_FAILED, USB_DIAG_ERROR_MSG_RD_CMD_EXEC_FAILED, (INT64)sectorTest, 0, (INT64)rcUSBOp, DG_PCH_IO_FORMAT); kfree(pTestBuf); return; } //pDataBuf = ioremap(addrData, USB_FLASH_MAX_TRANSFER_SIZE); pDataBuf = kmalloc(USB_FLASH_MAX_TRANSFER_SIZE, GFP_KERNEL); if(pDataBuf != NULL) { memcpy(pDataBuf, pTestBuf, USB_FLASH_MAX_TRANSFER_SIZE); //iounmap(pDataBuf); kfree( pDataBuf ); } else { commReportError(MEC_COMP_CODE_TEMP, USB_DIAG_ITEM_CODE_PERFORMANCE, USB_DIAG_ERROR_CODE_KMALLOC_FAILED, USB_DIAG_ERROR_MSG_KMALLOC_FAILED, 0, 0, 0, DG_FORMAT_NONE); kfree(pTestBuf); return; } sectorTest += USB_FLASH_MAX_TRANSFER_SIZE / pSDev->sector_size; addrData += USB_FLASH_MAX_TRANSFER_SIZE; if(--rptPoint == 0) { M_USB_REPORT_PROGRESS("USB Performance Test", curProcess, rptProcess, 1); rptPoint = USB_FLASH_PERFORMANCE_RPT_VALUE; } } /*Write 20MB data to flash device*/ for(idx = 0; idx < (USB_FLASH_PERFORMANCE_TEST_ROUND + USB_FLASH_PERFORMANCE_TEST_RAMP_UP); idx++) { sectorTest = USB_TEST_OFFSET_IN_SECTOR; while(sectorTest < sectorLast) { startTestTime = jiffies; rcUSBOp = scsiWrite(pSDev, sectorTest, USB_FLASH_MAX_TRANSFER_SIZE / pSDev->sector_size, pTestBuf); if(rcUSBOp) { commReportError(MEC_COMP_CODE_TEMP, USB_DIAG_ITEM_CODE_PERFORMANCE, USB_DIAG_ERROR_CODE_WR_CMD_EXEC_FAILED, USB_DIAG_ERROR_MSG_WR_CMD_EXEC_FAILED, (INT64)sectorTest, 0, (INT64)rcUSBOp, DG_PCH_IO_FORMAT); } totalTestTime += (jiffies - startTestTime); sectorTest += USB_FLASH_MAX_TRANSFER_SIZE / pSDev->sector_size; } if(idx == 0) totalTestTime = 0; //skip first round data M_USB_REPORT_PROGRESS("USB Performance Test", curProcess, rptProcess, USB_TEST_PERFORMANCE_PRORCESS); } totalTestTime /= USB_FLASH_PERFORMANCE_TEST_ROUND; /*Calculate write performance*/ printk("USB Flash Performance:%lu.%lu MB/s\n", USB_FLASH_PERFORMANCE_TEST_SIZE / MB * HZ / totalTestTime, USB_FLASH_PERFORMANCE_TEST_SIZE / MB * HZ % totalTestTime); if((USB_FLASH_PERFORMANCE_TEST_SIZE / MB * HZ / totalTestTime) < USB_FLASH_PERFORMANCE_TEST_TARGET) { commReportError(MEC_COMP_CODE_TEMP, USB_DIAG_ITEM_CODE_PERFORMANCE, USB_DIAG_ERROR_CODE_PERFORMANCE_FAILED, USB_DIAG_ERROR_MSG_PERFORMANCE_FAILED, USB_FLASH_PERFORMANCE_TEST_TARGET, (INT64)((20 * HZ) / totalTestTime ), 0, DG_PCH_MSG_FORMAT); } sectorTest = USB_TEST_OFFSET_IN_SECTOR; addrData = gDiagAvailAddr; rptPoint = USB_FLASH_PERFORMANCE_RPT_VALUE; while(sectorTest != sectorLast) { //pDataBuf = ioremap(addrData, USB_FLASH_MAX_TRANSFER_SIZE); pDataBuf = kmalloc(USB_FLASH_MAX_TRANSFER_SIZE, GFP_KERNEL); if(pDataBuf != NULL) { memcpy(pTestBuf, pDataBuf, USB_FLASH_MAX_TRANSFER_SIZE); // iounmap(pDataBuf); kfree(pDataBuf); } else { commReportError(MEC_COMP_CODE_TEMP, USB_DIAG_ITEM_CODE_PERFORMANCE, USB_DIAG_ERROR_CODE_KMALLOC_FAILED, USB_DIAG_ERROR_MSG_KMALLOC_FAILED, 0, 0, 0, DG_FORMAT_NONE); if(repeatOP++ < USB_TEST_MAX_REPEAT_TIME) continue; else break; } rcUSBOp = scsiWrite(pSDev, sectorTest, USB_FLASH_MAX_TRANSFER_SIZE / pSDev->sector_size, pTestBuf); if(rcUSBOp) { commReportError(MEC_COMP_CODE_TEMP, USB_DIAG_ITEM_CODE_PERFORMANCE, USB_DIAG_ERROR_CODE_WR_CMD_EXEC_FAILED, USB_DIAG_ERROR_MSG_WR_CMD_EXEC_FAILED, (INT64)sectorTest, 0, (INT64)rcUSBOp, DG_PCH_IO_FORMAT); if(repeatOP++ < USB_TEST_MAX_REPEAT_TIME) continue; else break; } sectorTest += USB_FLASH_MAX_TRANSFER_SIZE / pSDev->sector_size; addrData += USB_FLASH_MAX_TRANSFER_SIZE; if(--rptPoint == 0) { M_USB_REPORT_PROGRESS("USB Performance Test", curProcess, rptProcess, 1); rptPoint = USB_FLASH_PERFORMANCE_RPT_VALUE; } } } kfree(pTestBuf); } /******************************************************************************* * PROCEDURE * * NAME: usbGetTotalSector * SUMMARY: Show the capacity of a USB devices * SCOPE: public * * DESCRIPTION: Show the capacity of a USB devices * * RETURNS: * * NOTES: * */ LOCAL UINT32 usbGetTotalSector(struct scsi_device *pSDev, INT8 itemCode) { UINT8 buffer[16]; INT32 rcUSB; sector_t numSector = 0; rcUSB = scsiReadCapacity(pSDev, buffer); if(rcUSB) { commReportError(MEC_COMP_CODE_TEMP, itemCode, SATA_DIAG_ERROR_CODE_RD_CMD_EXEC_FAILED, SATA_DIAG_ERROR_MSG_RD_CMD_EXEC_FAILED, 0, rcUSB, 0, DG_PCH_MSG_FORMAT); return 0; } numSector = (((sector_t)buffer[0] << 24) | (buffer[1] << 16) | (buffer[2] << 8) | buffer[3]) + 1; return (UINT32)numSector; } MODULE_AUTHOR( "will.lee@netapp.com" ); MODULE_DESCRIPTION( "NetApp USB Diag Code" ); MODULE_LICENSE( "GPL" ); MODULE_VERSION( "0.1" );