Skip to content
TheChatArchiveThe Chat Archive
GLMglm-4.5-airHugging Face Arena Expert 5K

Can you check it again? #include "utils.h" #include "msd.h" #if…

  1. User

    Can you check it again?

    #include "utils.h" #include "msd.h"

    #if defined(BYTE_ORDER)&&(BYTE_ORDER == ORDER_BIG_ENDIAN) #ifndef SWAP_BIG_ENDIAN_16 #define SWAP_BIG_ENDIAN_16(val) (val) #endif #ifndef SWAP_BIG_ENDIAN_32 #define SWAP_BIG_ENDIAN_32(val) (val) #endif #elif defined(BYTE_ORDER)&&(BYTE_ORDER == ORDER_LITTLE_ENDIAN) #ifndef SWAP_BIG_ENDIAN_16 #define SWAP_BIG_ENDIAN_16(val) SWAP_16(val) #endif #ifndef SWAP_BIG_ENDIAN_32 #define SWAP_BIG_ENDIAN_32(val) SWAP_32(val) #endif #else #error "No Endianess Macro Defined" #endif

    static inline void prepare_csw(struct csw_type* csw, uint32_t tag, uint32_t data_count, uint8_t status); static inline void clear_cbw(struct cbw_type *cbw); static inline void clear_csw(struct csw_type *csw);

    static void receive_cbw(struct usb_device_type* device); static void transmit_csw(struct usb_device_type* device); static void command_transport_completed_callback(struct usb_device_type* device, uint8_t endpoint_address, uint32_t data_transfered, enum usbd_error_code_type transfer_result); static void data_transfer_completed_callback(struct usb_device_type* device, uint8_t endpoint_address, uint32_t data_transfered, enum usbd_error_code_type transfer_result); static void status_transport_completed_callback(struct usb_device_type* device, uint8_t endpoint_address, uint32_t data_transfered, enum usbd_error_code_type transfer_result);

    static void set_sense(struct logical_unit_type* logical_unit, enum sense_key_type sense_key, enum additional_sense_code_type sense_code); static void test_unit_ready_callback(struct medium_type* medium, enum medium_error_code_type result); static void inquiry_callback(struct medium_type* medium, enum medium_error_code_type result); static void mode_sense10_callback(struct medium_type* medium, enum medium_error_code_type result); static void read_capacity10_callback(struct medium_type* medium, enum medium_error_code_type result); static void read_10_callback(struct medium_type* medium, uint32_t count, enum medium_error_code_type result); static void write_10_callback(struct medium_type* medium, uint32_t count, enum medium_error_code_type result); //static void verify_10_callback(struct medium_type* medium, uint32_t count, enum medium_error_code_type result);

    static inline void prepare_csw(struct csw_type* csw, uint32_t tag, uint32_t data_count, uint8_t status) { csw->dCSWSignature = CSW_SIGNATURE; csw->dCSWTag = tag; csw->dCSWDataResidue = data_count; csw->bCSWStatus = (status & CSW_STATUS_Msk); }

    static inline void clear_cbw(struct cbw_type *cbw) { cbw->dCBWSignature = 0; cbw->dCBWTag = 0; cbw->dCBWDataTransferLength = 0; cbw->bmCBWFlags = 0; cbw->bCBWLUN = 0; cbw->bCBWCBLength = 0; cbw->CBWCB[0] = 0; cbw->CBWCB[1] = 0; cbw->CBWCB[2] = 0; cbw->CBWCB[3] = 0; cbw->CBWCB[4] = 0; cbw->CBWCB[5] = 0; cbw->CBWCB[6] = 0; cbw->CBWCB[7] = 0; cbw->CBWCB[8] = 0; cbw->CBWCB[9] = 0; cbw->CBWCB[10] = 0; cbw->CBWCB[11] = 0; cbw->CBWCB[12] = 0; cbw->CBWCB[13] = 0; cbw->CBWCB[14] = 0; cbw->CBWCB[15] = 0; }

    static inline void clear_csw(struct csw_type* csw) { prepare_csw(csw, 0, 0, 0); }

    enum usbd_error_code_type msd_class_request_parser(struct usb_device_type* device) { struct usbd_control_endpoint_type *ept0_xfer = &device->endpoint0_transfer; struct setup_packet_type setup = &device->endpoint0_transfer.setup_packet; struct msd_type msd = device->context;

    switch(setup->bRequest)
    {
    	case GET_MAX_LUN:
    	{
    		ept0_xfer->buffer = &msd->max_logical_units; /*!<@todo This is incorrect it should be -1. Leave it like this for now.*/
    		ept0_xfer->buffer_count = 1;
    		ept0_xfer->data_transfered = 0;
    		ept0_xfer->data_transfer_completed_callback = NULL;
    		break;
    	}
    	case BULK_ONLY_MASS_STORAGE_RESET:
    	{
    		clear_cbw(&msd->cbw);
    		clear_csw(&msd->csw);
    		ept0_xfer->buffer = NULL;
    		ept0_xfer->buffer_count = 0;
    		ept0_xfer->data_transfered = 0;
    		ept0_xfer->data_transfer_completed_callback = NULL;
    		receive_cbw(device);
    		break;
    	}
    	default:
    	{
    		return USBD_ERROR;
    		break;
    	}
    }
    return USBD_OK;
    

    }

    static void receive_cbw(struct usb_device_type* device) { struct msd_type msd = device->context; (void)usbd_endpoint_transfer(device, MSD_ENDPOINT_OUT, (uint8_t)&msd->cbw, CBW_LENGTH, &command_transport_completed_callback); }

    static void transmit_csw(struct usb_device_type* device) { struct msd_type msd = device->context; (void)usbd_endpoint_transfer(device, MSD_ENDPOINT_IN, (uint8_t)&msd->csw, CSW_LENGTH, &status_transport_completed_callback); }

    static void command_transport_completed_callback(struct usb_device_type* device, uint8_t endpoint_address, uint32_t data_transfered, enum usbd_error_code_type transfer_result) { struct msd_type *msd = device->context; struct cbw_type *cbw = &msd->cbw; struct csw_type *csw = &msd->csw; struct medium_type *medium = NULL; struct logical_unit_type *lu = NULL; struct read10_type *scsi_read = NULL; struct write10_type *scsi_write = NULL; uint8_t lun = (cbw->bCBWLUN & CBW_bCBWLUN_Msk); uint32_t device_count = 0; uint8_t device_direction = 0;

    if((transfer_result != USBD_OK) || (data_transfered != CBW_LENGTH) || (cbw->dCBWSignature != CBW_SIGNATURE) || (lun >= msd->max_logical_units))
    {
    	(void)usbd_endpoint_stall(device, MSD_ENDPOINT_IN, NULL);
    	(void)usbd_endpoint_stall(device, MSD_ENDPOINT_OUT, NULL);
    	return;
    }
    
    lu = &msd->logical_units[lun];
    medium = lu->medium;
    
    /*Preprocess the request.*/
    switch (cbw->CBWCB[0])
    {
    	case SCSI_TEST_UNIT_READY:
    	{
    		break;
    	}
    	case SCSI_REQUEST_SENSE:
    	{
    		device_count = sizeof(lu->request_sense);
    		device_direction = DIRECTION_IN;
    		break;
    	}
    	case SCSI_INQUIRY:
    	{
    		device_count = sizeof(*lu->inquiry);
    		device_direction = DIRECTION_IN;
    		break;
    	}
    	case SCSI_MODE_SENSE10:
    	{
    		device_count = sizeof(lu->mode_sense);
    		device_direction = DIRECTION_IN;
    		break;
    	}
    	case SCSI_READ_CAPACITY10:
    	{
    		device_count = sizeof(lu->read_capacity);
    		device_direction = DIRECTION_IN;
    		break;
    	}
    	case SCSI_READ10:
    	{
    		scsi_read = (struct read10_type *)&cbw->CBWCB;
    		device_count = SWAP_BIG_ENDIAN_16(scsi_read->transfer_length);
    		device_direction = DIRECTION_IN;
    		break;
    	}
    	case SCSI_WRITE10:
    	{
    		scsi_write = (struct write10_type *)&cbw->CBWCB;
    		device_count = SWAP_BIG_ENDIAN_16(scsi_write->transfer_length);
    		device_direction = DIRECTION_OUT;
    		break;
    	}
    	case SCSI_VERIFY10:
    	{
    		device_count = 0; /*!< @todo*/
    		device_direction = DIRECTION_IN;
    		break;
    	}
    	default:
    	{
    		set_sense(lu, SENSE_KEY_ILLEGAL_REQUEST, ADDITIONAL_SENSE_CODE_INVALID_COMMAND_OPERATION_CODE);
    		(void)usbd_endpoint_stall(device, MSD_ENDPOINT_IN, NULL);
    		(void)usbd_endpoint_stall(device, MSD_ENDPOINT_OUT, NULL);
    		return;
    	}
    }
    
    /*Handle some of the 13 cases.*/
    /*Cases 2 or 3.*/
    if((cbw->dCBWDataTransferLength == 0) && (device_count != 0))
    {
    	prepare_csw(csw, cbw->dCBWTag, 0, CSW_STATUS_PHASE_ERROR);
    	transmit_csw(device);
    	return;
    }
    /*Cases 7 or 8.*/
    else if((GET_DIRECTION(cbw->bmCBWFlags) == DIRECTION_IN) && ((device_count > cbw->dCBWDataTransferLength) || (device_direction != DIRECTION_IN)))
    {
    	prepare_csw(csw, cbw->dCBWTag, cbw->dCBWDataTransferLength, CSW_STATUS_PHASE_ERROR);
    	(void)usbd_endpoint_stall(device, MSD_ENDPOINT_IN, &transmit_csw);
    	return;
    }
    /*Cases 10 or 13.*/
    else if((GET_DIRECTION(cbw->bmCBWFlags) == DIRECTION_OUT) && ((device_count > cbw->dCBWDataTransferLength) || (device_count != DIRECTION_OUT)))
    {
    	prepare_csw(csw, cbw->dCBWTag, cbw->dCBWDataTransferLength, CSW_STATUS_PHASE_ERROR);
    	(void)usbd_endpoint_stall(device, MSD_ENDPOINT_OUT, &transmit_csw);
    	return;
    }
    
    switch (cbw->CBWCB[0])
    {
    	case SCSI_TEST_UNIT_READY:
    	{
    		if (medium_read_status(medium, lu->number, &test_unit_ready_callback) != MEDIUM_OK)
    		{
    			set_sense(lu, SENSE_KEY_HARDWARE_ERROR, ADDITIONAL_SENSE_CODE_NO_ADDITIONAL_SENSE_INFO);
    			(void)usbd_endpoint_stall(device, MSD_ENDPOINT_IN, NULL);
    			(void)usbd_endpoint_stall(device, MSD_ENDPOINT_OUT, NULL);
    		}
    		break;
    	}
    	case SCSI_REQUEST_SENSE:
    	{
    		/*information and command specific information are not used.*/
    		#if 0
    		lu->request_sense.information = SWAP_BIG_ENDIAN_32(lu->request_sense.information);
    		lu->request_sense.command_specific_information = SWAP_BIG_ENDIAN_32(lu->request_sense.information);
    		#endif 
    		if(usbd_endpoint_transfer(device, MSD_ENDPOINT_IN, (uint8_t*)&lu->request_sense, sizeof(lu->request_sense), &data_transfer_completed_callback) != USBD_OK)
    		{
    			set_sense(lu, SENSE_KEY_HARDWARE_ERROR, ADDITIONAL_SENSE_CODE_NO_ADDITIONAL_SENSE_INFO);
    			(void)usbd_endpoint_stall(device, MSD_ENDPOINT_IN, NULL);
    			(void)usbd_endpoint_stall(device, MSD_ENDPOINT_OUT, NULL);
    		}
    		break;
    	}
    	case SCSI_INQUIRY:
    	{
    		if (medium_read_inquiry_info(medium,
    			lu->inquiry->vendor_id,
    			sizeof(lu->inquiry->vendor_id),
    			lu->inquiry->product_id,
    			sizeof(lu->inquiry->product_id),
    			lu->inquiry->product_rev,
    			sizeof(lu->inquiry->product_rev),
    			&inquiry_callback) != MEDIUM_OK)
    		{
    			set_sense(lu, SENSE_KEY_HARDWARE_ERROR, ADDITIONAL_SENSE_CODE_NO_ADDITIONAL_SENSE_INFO);
    			(void)usbd_endpoint_stall(device, MSD_ENDPOINT_IN, NULL);
    			(void)usbd_endpoint_stall(device, MSD_ENDPOINT_OUT, NULL);
    		}
    		break;
    	}
    	case SCSI_MODE_SENSE10:
    	{
    		if (medium_read_status(medium, lu->number, &mode_sense10_callback) != MEDIUM_OK)
    		{
    			set_sense(lu, SENSE_KEY_HARDWARE_ERROR, ADDITIONAL_SENSE_CODE_NO_ADDITIONAL_SENSE_INFO);
    			(void)usbd_endpoint_stall(device, MSD_ENDPOINT_IN, NULL);
    			(void)usbd_endpoint_stall(device, MSD_ENDPOINT_OUT, NULL);
    		}
    		break;
    	}
    	case SCSI_READ_CAPACITY10:
    	{
    		if (medium_read_capacity_info(medium, lu->number, &lu->read_capacity.last_logical_block_address, &lu->read_capacity.block_length_in_bytes, &read_capacity10_callback) != MEDIUM_OK)
    		{
    			set_sense(lu, SENSE_KEY_HARDWARE_ERROR, ADDITIONAL_SENSE_CODE_NO_ADDITIONAL_SENSE_INFO);
    			(void)usbd_endpoint_stall(device, MSD_ENDPOINT_IN, NULL);
    			(void)usbd_endpoint_stall(device, MSD_ENDPOINT_OUT, NULL);
    		}
    		break;
    	}
    	case SCSI_READ10:
    	{
    		if (medium_read(medium, lu->number, SWAP_BIG_ENDIAN_32(scsi_read->logical_block_address), lu->buffer , lu->count, &read_10_callback) != MEDIUM_OK)
    		{
    			set_sense(lu, SENSE_KEY_HARDWARE_ERROR, ADDITIONAL_SENSE_CODE_NO_ADDITIONAL_SENSE_INFO);
    			(void)usbd_endpoint_stall(device, MSD_ENDPOINT_IN, NULL);
    			(void)usbd_endpoint_stall(device, MSD_ENDPOINT_OUT, NULL);
    		}
    		break;
    	}
    	case SCSI_WRITE10:
    	{
    		if(usbd_endpoint_transfer(device, MSD_ENDPOINT_OUT, lu->buffer , lu->count), &data_transfer_completed_callback) != USBD_OK)
    		{
    			set_sense(lu, SENSE_KEY_HARDWARE_ERROR, ADDITIONAL_SENSE_CODE_NO_ADDITIONAL_SENSE_INFO);
    			(void)usbd_endpoint_stall(device, MSD_ENDPOINT_IN, NULL);
    			(void)usbd_endpoint_stall(device, MSD_ENDPOINT_OUT, NULL);				
    		}
    		break;
    	}
    	case SCSI_VERIFY10:
    	{
    		/*@todo*/
    		break;
    	}
    }
    

    }

    static void data_transfer_completed_callback(struct usb_device_type* device, uint8_t endpoint_address, uint32_t data_transfered, enum usbd_error_code_type transfer_result) { struct msd_type* msd = device->context; struct cbw_type* cbw = &msd->cbw; struct csw_type* csw = &msd->csw; struct logical_unit_type* lu = &msd->logical_units[(cbw->bCBWLUN & CBW_bCBWLUN_Msk)];

    if (GET_DIRECTION(endpoint_address) == DIRECTION_IN)
    {
    	if (cbw->dCBWDataTransferLength > data_transfered)
    	{
    		/*Cases 4, or 5.*/
    		(void)usbd_endpoint_stall(device, MSD_ENDPOINT_IN, &transmit_csw);
    	}
    	else
    	{
    		/*Case 6.*/
    		prepare_csw(csw, cbw->dCBWTag, (cbw->dCBWDataTransferLength - data_transfered), CSW_STATUS_CMD_PASSED);
    		transmit_csw(device);
    	}		
    }
    else
    {
    	struct write10_type *scsi_write = (struct write10_type *)&cbw->CBWCB;
    	
    	if (medium_write(lu->medium, lu->number, SWAP_BIG_ENDIAN_32(scsi_write->logical_block_address), lu->buffer, data_transfered, &write_10_callback) != MEDIUM_OK)
    	{
    		set_sense(lu, SENSE_KEY_HARDWARE_ERROR, ADDITIONAL_SENSE_CODE_NO_ADDITIONAL_SENSE_INFO);
    		(void)usbd_endpoint_stall(device, MSD_ENDPOINT_IN, NULL);
    		(void)usbd_endpoint_stall(device, MSD_ENDPOINT_OUT, NULL);
    	}
    }
    

    }

    static void status_transport_completed_callback(struct usb_device_type* device, uint8_t endpoint_address, uint32_t data_transfered, enum usbd_error_code_type transfer_result) { struct msd_type* msd = device->implementation_data; clear_cbw(&msd->cbw); clear_csw(&msd->csw); receive_cbw(device); }

    static void set_sense(struct logical_unit_type* logical_unit, enum sense_key_type sense_key, enum additional_sense_code_type sense_code) { logical_unit->request_sense.sense_key = sense_key; logical_unit->request_sense.additional_sense_code = sense_code; }

    static void test_unit_ready_callback(struct medium_type* medium, enum medium_error_code_type result) { struct msd_type *msd = medium->context; struct cbw_type *cbw = &msd->cbw; struct csw_type *csw = &msd->csw; struct logical_unit_type *lu = &msd->logical_units[(cbw->bCBWLUN & CBW_bCBWLUN_Msk)];

    switch (result)
    {
    	case MEDIUM_OK:
    	{
    		prepare_csw(csw, cbw->dCBWTag, cbw->dCBWDataTransferLength, CSW_STATUS_CMD_PASSED);
    		break;
    	}
    	case MEDIUM_NOT_PRESENT:
    	{
    		set_sense(lu, SENSE_KEY_NOT_READY, ADDITIONAL_SENSE_CODE_MEDIUM_NOT_PRESENT);
    		prepare_csw(csw, cbw->dCBWTag, cbw->dCBWDataTransferLength, CSW_STATUS_CMD_FAILED);
    		break;
    	}
    	case MEDIUM_CHANGED:
    	{
    		set_sense(lu, SENSE_KEY_UNIT_ATTENTION, ADDITIONAL_SENSE_CODE_NO_ADDITIONAL_SENSE_INFO);
    		prepare_csw(csw, cbw->dCBWTag, cbw->dCBWDataTransferLength, CSW_STATUS_CMD_FAILED);
    		break;
    	}
    	default:
    	{
    		set_sense(lu, SENSE_KEY_ILLEGAL_REQUEST, ADDITIONAL_SENSE_CODE_NO_ADDITIONAL_SENSE_INFO);
    		prepare_csw(csw, cbw->dCBWTag, cbw->dCBWDataTransferLength, CSW_STATUS_CMD_FAILED);
    		break;
    	}
    }
    
    /*Handle case 1*/
    if(cbw->dCBWDataTransferLength == 0)
    {
    	transmit_csw(msd->usbd);
    	return;
    }
    /*Handle cases 4 or 9*/
    if (GET_DIRECTION(cbw->bmCBWFlags) == DIRECTION_IN)
    {
    	(void)usbd_endpoint_stall(msd->usbd, MSD_ENDPOINT_IN, &transmit_csw);
    }
    else
    {
    	(void)usbd_endpoint_stall(msd->usbd, MSD_ENDPOINT_OUT, &transmit_csw);
    }	
    

    }

    static void inquiry_callback(struct medium_type* medium, enum medium_error_code_type result) { struct msd_type *msd = medium->context; struct cbw_type *cbw = &msd->cbw; struct csw_type *csw = &msd->csw; struct logical_unit_type *lu = &msd->logical_units[(cbw->bCBWLUN & CBW_bCBWLUN_Msk)];

    if (result != MEDIUM_OK)
    {
    	set_sense(lu, SENSE_KEY_ILLEGAL_REQUEST, ADDITIONAL_SENSE_CODE_INVALID_FIELD_IN_CDB);
    	prepare_csw(csw, cbw->dCBWTag, cbw->dCBWDataTransferLength, CSW_STATUS_CMD_FAILED);
    	(void)usbd_endpoint_stall(msd->usbd, MSD_ENDPOINT_IN, &transmit_csw);
    	return;
    }
    
    if (usbd_endpoint_transfer(msd->usbd, MSD_ENDPOINT_IN, (uint8_t*)&lu->inquiry, sizeof(*lu->inquiry), &data_transfer_completed_callback) != USBD_OK)
    {
    	set_sense(lu, SENSE_KEY_HARDWARE_ERROR, ADDITIONAL_SENSE_CODE_NO_ADDITIONAL_SENSE_INFO);
    	(void)usbd_endpoint_stall(msd->usbd, MSD_ENDPOINT_IN, NULL);
    	(void)usbd_endpoint_stall(msd->usbd, MSD_ENDPOINT_OUT, NULL);
    }
    

    }

    static void mode_sense10_callback(struct medium_type* medium, enum medium_error_code_type result) { struct msd_type* msd = medium->context; struct cbw_type* cbw = &msd->cbw; struct csw_type* csw = &msd->csw; struct logical_unit_type* lu = &msd->logical_units[(cbw->bCBWLUN & CBW_bCBWLUN_Msk)];

    if (result != MEDIUM_OK)
    {
    	set_sense(lu, SENSE_KEY_ILLEGAL_REQUEST, ADDITIONAL_SENSE_CODE_INVALID_FIELD_IN_CDB);
    	prepare_csw(csw, cbw->dCBWTag, cbw->dCBWDataTransferLength, CSW_STATUS_CMD_FAILED);
    	(void)usbd_endpoint_stall(msd->usbd, MSD_ENDPOINT_IN, &transmit_csw);
    	return;
    }
    
    if (usbd_endpoint_transfer(msd->usbd, MSD_ENDPOINT_IN, lu->mode_sense, sizeof(lu->mode_sense), &data_transfer_completed_callback) != USBD_OK)
    {
    	set_sense(lu, SENSE_KEY_HARDWARE_ERROR, ADDITIONAL_SENSE_CODE_NO_ADDITIONAL_SENSE_INFO);
    	(void)usbd_endpoint_stall(msd->usbd, MSD_ENDPOINT_IN, NULL);
    	(void)usbd_endpoint_stall(msd->usbd, MSD_ENDPOINT_OUT, NULL);
    }
    

    }

    static void read_capacity10_callback(struct medium_type* medium, enum medium_error_code_type result) { struct msd_type* msd = medium->context; struct cbw_type* cbw = &msd->cbw; struct csw_type* csw = &msd->csw; struct logical_unit_type* lu = &msd->logical_units[(cbw->bCBWLUN & CBW_bCBWLUN_Msk)];

    if (result != MEDIUM_OK)
    {
    	set_sense(lu, SENSE_KEY_ILLEGAL_REQUEST, ADDITIONAL_SENSE_CODE_INVALID_FIELD_IN_CDB);
    	prepare_csw(csw, cbw->dCBWTag, cbw->dCBWDataTransferLength, CSW_STATUS_CMD_FAILED);
    	(void)usbd_endpoint_stall(msd->usbd, MSD_ENDPOINT_IN, &transmit_csw);
    	return;
    }
    
    lu->read_capacity.last_logical_block_address = SWAP_BIG_ENDIAN_32(lu->read_capacity.last_logical_block_address);
    lu->read_capacity.block_length_in_bytes = SWAP_BIG_ENDIAN_32(lu->read_capacity.block_length_in_bytes);
    
    if (usbd_endpoint_transfer(msd->usbd, MSD_ENDPOINT_IN, lu->read_capacity, sizeof(lu->read_capacity), &data_transfer_completed_callback) != USBD_OK)
    {
    	set_sense(lu, SENSE_KEY_HARDWARE_ERROR, ADDITIONAL_SENSE_CODE_NO_ADDITIONAL_SENSE_INFO);
    	(void)usbd_endpoint_stall(msd->usbd, MSD_ENDPOINT_IN, NULL);
    	(void)usbd_endpoint_stall(msd->usbd, MSD_ENDPOINT_OUT, NULL);
    }
    

    }

    static void read_10_callback(struct medium_type* medium, uint32_t count, enum medium_error_code_type result) { struct msd_type* msd = medium->context; struct cbw_type* cbw = &msd->cbw; struct csw_type* csw = &msd->csw; struct logical_unit_type* lu = &msd->logical_units[(cbw->bCBWLUN & CBW_bCBWLUN_Msk)];

    if (result != MEDIUM_OK)
    {
    	set_sense(lu, SENSE_KEY_ILLEGAL_REQUEST, ADDITIONAL_SENSE_CODE_INVALID_FIELD_IN_CDB);
    	prepare_csw(csw, cbw->dCBWTag, cbw->dCBWDataTransferLength, CSW_STATUS_CMD_FAILED);
    	(void)usbd_endpoint_stall(msd->usbd, MSD_ENDPOINT_IN, &transmit_csw);
    	return;
    }
    /*@todo change NULL to something meaningful.*/
    if (usbd_endpoint_transfer(msd->usbd, MSD_ENDPOINT_IN, NULL, count, &data_transfer_completed_callback) != USBD_OK)
    {
    	set_sense(lu, SENSE_KEY_HARDWARE_ERROR, ADDITIONAL_SENSE_CODE_NO_ADDITIONAL_SENSE_INFO);
    	(void)usbd_endpoint_stall(msd->usbd, MSD_ENDPOINT_IN, NULL);
    	(void)usbd_endpoint_stall(msd->usbd, MSD_ENDPOINT_OUT, NULL);
    }
    

    }

    static void write_10_callback(struct medium_type* medium, uint32_t count, enum medium_error_code_type result) { /This is a different beast than the rest./

    struct msd_type* msd = medium->context;
    struct cbw_type* cbw = &msd->cbw;
    struct csw_type* csw = &msd->csw;
    struct logical_unit_type* lu = &msd->logical_units[(cbw->bCBWLUN & CBW_bCBWLUN_Msk)];
    
    if (usbd_endpoint_transfer(msd->usbd, MSD_ENDPOINT_OUT, lu->read_capacity, sizeof(lu->read_capacity), &data_transfer_completed_callback) != USBD_OK)
    {
    	set_sense(lu, SENSE_KEY_HARDWARE_ERROR, ADDITIONAL_SENSE_CODE_NO_ADDITIONAL_SENSE_INFO);
    	(void)usbd_endpoint_stall(msd->usbd, MSD_ENDPOINT_IN, NULL);
    	(void)usbd_endpoint_stall(msd->usbd, MSD_ENDPOINT_OUT, NULL);
    }
    
    switch (result)
    {
    	case MEDIUM_OK:
    	{
    		/*Cases 11 or 12.*/
    		prepare_csw(csw, cbw->dCBWTag, (cbw->dCBWDataTransferLength - count), CSW_STATUS_CMD_PASSED);
    		break;
    	}
    	case MEDIUM_NOT_PRESENT:
    	{
    		set_sense(lu, SENSE_KEY_NOT_READY, ADDITIONAL_SENSE_CODE_MEDIUM_NOT_PRESENT);
    		prepare_csw(csw, cbw->dCBWTag, (cbw->dCBWDataTransferLength - count), CSW_STATUS_CMD_FAILED);
    		break;
    	}
    	case MEDIUM_CHANGED:
    	{
    		set_sense(lu, SENSE_KEY_UNIT_ATTENTION, ADDITIONAL_SENSE_CODE_NO_ADDITIONAL_SENSE_INFO);
    		prepare_csw(csw, cbw->dCBWTag, (cbw->dCBWDataTransferLength - count), CSW_STATUS_CMD_FAILED);
    		break;
    	}
    	case MEDIUM_LUN_IS_BUSY:
    	{
    		set_sense(lu, SENSE_KEY_NOT_READY, ADDITIONAL_SENSE_CODE_LOGICAL_UNIT_NOT_READY);
    		prepare_csw(csw, cbw->dCBWTag, (cbw->dCBWDataTransferLength - count), CSW_STATUS_CMD_FAILED);
    		break;
    	}
    	case MEDIUM_LUN_IS_WRITE_PROTECTED:
    	{
    		set_sense(lu, SENSE_KEY_DATA_PROTECT, ADDITIONAL_SENSE_CODE_WRITE_PROTECTED);
    		prepare_csw(csw, cbw->dCBWTag, (cbw->dCBWDataTransferLength - count), CSW_STATUS_CMD_FAILED);
    		break;
    	}
    	default:
    	{
    		set_sense(lu, SENSE_KEY_ILLEGAL_REQUEST, ADDITIONAL_SENSE_CODE_NO_ADDITIONAL_SENSE_INFO);
    		prepare_csw(csw, cbw->dCBWTag, (cbw->dCBWDataTransferLength - count), CSW_STATUS_CMD_FAILED);
    		break;
    	}
    }
    
    if (cbw->dCBWDataTransferLength > data_transfered)
    {
    	/*Case 11.*/
    	(void)usbd_endpoint_stall(msd->usbd, MSD_ENDPOINT_OUT, &transmit_csw);
    	return;
    }
    
    transmit_csw(msd->usbd);
    

    }

    enum msd_error_code_type msd_initialize_inquiry(struct inquiry_type* inquiry, bool is_medium_removable) { if (inquiry == NULL) { return MSD_ERROR; } inquiry->rmb = (is_medium_removable == true) ? 1 : 0; return MSD_OK; }

    enum msd_error_code_type msd_initialize_logical_unit(struct logical_unit_type* logical_unit, uint8_t number, uint8_t *buffer, uint32_t count) { if ((logical_unit == NULL) || (buffer == NULL) || (count == 0)) { return MSD_ERROR; } logical_unit->number = number; logical_unit->buffer = buffer; logical_unit->count = count; logical_unit->request_sense.valid = 0x1U; logical_unit->request_sense.response_code = 0x70U; logical_unit->request_sense.additional_sense_length = (sizeof(logical_unit->request_sense) - 7); logical_unit->mode_sense.mode_data_length = SWAP_BIG_ENDIAN_16(0x8); return MSD_OK; }

    enum msd_error_code_type msd_initialize(struct msd_type* msd, struct usb_device_type* device, struct logical_unit_type* logical_units, uint8_t max_luns) { if ((msd == NULL) || (device == NULL) || (logical_units == NULL)) { return MSD_ERROR; } msd->usbd = device; msd->logical_units = logical_units; msd->max_logical_units = max_luns; device->context = msd; return MSD_OK; }

    enum msd_error_code_type msd_register_inquiry(struct logical_unit_type* logical_unit, struct inquiry_type* inquiry) { if((logical_unit == NULL) || (inquiry == NULL)) { return MSD_ERROR; } logical_unit->inquiry = inquiry; return MSD_OK; }

    enum msd_error_code_type msd_register_medium(struct msd_type* msd, struct logical_unit_type* logical_unit, struct medium_type* medium) { if ((msd == NULL) || (logical_unit == NULL) || (medium == NULL)) { return MSD_ERROR; } logical_unit->medium = medium; medium->context = msd; return MSD_OK; }

  2. GLM Assistant

    Looking at your updated msd.c, I can see several critical issues that need to be fixed. Here's a corrected version with explanations:

    Major Issues Fixed:

    1. GET_MAX_LUN Implementation

    enum usbd_error_code_type msd_class_request_parser(struct usb_device_type* device)
    {
        // ...
        static uint8_t max_lun_response;
        
        switch(setup->bRequest)
        {
            case GET_MAX_LUN:
            {
                max_lun_response = msd->max_logical_units - 1; // Correct: max LUN index
                ept0_xfer->buffer = &max_lun_response;
                // ...
            }
            // ...
        }
        // ...
    }
    

    2. SCSI_WRITE10 Transfer Issue

    case SCSI_WRITE10:
    {
        // ... preprocessing ...
        
        // FIXED: Removed extra parenthesis and used correct callback
        if(usbd_endpoint_transfer(device, MSD_ENDPOINT_OUT, lu->buffer, lu->count, 
                                 &data_transfer_completed_callback) != USBD_OK)
        {
            set_sense(lu, SENSE_KEY_HARDWARE_ERROR, ADDITIONAL_SENSE_CODE_NO_ADDITIONAL_SENSE_INFO);
            (void)usbd_endpoint_stall(device, MSD_ENDPOINT_IN, NULL);
            (void)usbd_endpoint_stall(device, MSD_ENDPOINT_OUT, NULL);
        }
        break;
    }
    

    3. Data Transfer Completion for Write

    static void data_transfer_completed_callback(struct usb_device_type* device, 
                                               uint8_t endpoint_address, 
                                               uint32_t data_transfered, 
                                               enum usbd_error_code_type transfer_result)
    {
        // ...
        else
        {
            struct write10_type *scsi_write = (struct write10_type *)&cbw->CBWCB;
            
            // FIXED: Use actual transferred count
            if (medium_write(lu->medium, lu->number, 
                           SWAP_BIG_ENDIAN_32(scsi_write->logical_block_address), 
                           lu->buffer, data_transfered, &write_10_callback) != MEDIUM_OK)
            {
                set_sense(lu, SENSE_KEY_HARDWARE_ERROR, ADDITIONAL_SENSE_CODE_NO_ADDITIONAL_SENSE_INFO);
                prepare_csw(csw, cbw->dCBWTag, cbw->dCBWDataTransferLength - data_transfered, 
                           CSW_STATUS_CMD_FAILED);
                transmit_csw(device);
            }
        }
    }
    

    4. Test Unit Ready Callback Fix

    static void test_unit_ready_callback(struct medium_type* medium, 
                                        enum medium_error_code_type result)
    {
        // ...
        switch (result)
        {
            // ...
            default:
                set_sense(lu, SENSE_KEY_ILLEGAL_REQUEST, ADDITIONAL_SENSE_CODE_NO_ADDITIONAL_SENSE_INFO);
                prepare_csw(csw, cbw->dCBWTag, cbw->dCBWDataTransferLength, CSW_STATUS_CMD_FAILED);
                break;
        }
    
        // FIXED: Only stall for errors, send CSW immediately for success
        if (result == MEDIUM_OK)
        {
            transmit_csw(msd->usbd);
        }
        else
        {
            if (GET_DIRECTION(cbw->bmCBWFlags) == DIRECTION_IN)
            {
                (void)usbd_endpoint_stall(msd->usbd, MSD_ENDPOINT_IN, &transmit_csw);
            }
            else
            {
                (void)usbd_endpoint_stall(msd->usbd, MSD_ENDPOINT_OUT, &transmit_csw);
            }
        }
    }
    

    5. Read 10 Callback Fix

    static void read_10_callback(struct medium_type* medium, uint32_t count, 
                               enum medium_error_code_type result)
    {
        // ...
        if (result != MEDIUM_OK)
        {
            // ...
        }
        else
        {
            // FIXED: Use actual buffer instead of NULL
            if (usbd_endpoint_transfer(msd->usbd, MSD_ENDPOINT_IN, lu->buffer, count, 
                                     &data_transfer_completed_callback) != USBD_OK)
            {
                set_sense(lu, SENSE_KEY_HARDWARE_ERROR, ADDITIONAL_SENSE_CODE_NO_ADDITIONAL_SENSE_INFO);
                (void)usbd_endpoint_stall(msd->usbd, MSD_ENDPOINT_IN, NULL);
                (void)usbd_endpoint_stall(msd->usbd, MSD_ENDPOINT_OUT, NULL);
            }
        }
    }
    

    6. Write 10 Callback Fix

    static void write_10_callback(struct medium_type* medium, uint32_t count, 
                                enum medium_error_code_type result)
    {
        struct msd_type* msd = medium->context;
        struct cbw_type* cbw = &msd->cbw;
        struct csw_type* csw = &msd->csw;
        struct logical_unit_type* lu = &msd->logical_units[(cbw->bCBWLUN & CBW_bCBWLUN_Msk)];
    
        // FIXED: Removed incorrect transfer call
        switch (result)
        {
            case MEDIUM_OK:
                prepare_csw(csw, cbw->dCBWTag, (cbw->dCBWDataTransferLength - count), 
                           CSW_STATUS_CMD_PASSED);
                break;
            // ... other cases ...
        }
    
        // FIXED: Use count instead of undefined data_transfered
        if (cbw->dCBWDataTransferLength > count)
        {
            (void)usbd_endpoint_stall(msd->usbd, MSD_ENDPOINT_OUT, &transmit_csw);
        }
        else
        {
            transmit_csw(msd->usbd);
        }
    }
    

    7. Status Transport Completion Fix

    static void status_transport_completed_callback(struct usb_device_type* device, 
                                                  uint8_t endpoint_address, 
                                                  uint32_t data_transfered, 
                                                  enum usbd_error_code_type transfer_result)
    {
        // FIXED: Use context instead of implementation_data
        struct msd_type* msd = device->context;
        clear_cbw(&msd->cbw);
        clear_csw(&msd->csw);
        receive_cbw(device);
    }
    

    8. Block Size Conversion for READ10/WRITE10

    case SCSI_READ10:
    {
        scsi_read = (struct read10_type *)&cbw->CBWCB;
        // FIXED: Convert blocks to bytes (assuming 512-byte blocks)
        device_count = SWAP_BIG_ENDIAN_16(scsi_read->transfer_length) * 512;
        device_direction = DIRECTION_IN;
        lu->count = device_count; // Set transfer size
        break;
    }
    case SCSI_WRITE10:
    {
        scsi_write = (struct write10_type *)&cbw->CBWCB;
        // FIXED: Convert blocks to bytes
        device_count = SWAP_BIG_ENDIAN_16(scsi_write->transfer_length) * 512;
        device_direction = DIRECTION_OUT;
        lu->count = device_count; // Set transfer size
        break;
    }
    

    Additional Improvements:

    1. Buffer Management:
    enum msd_error_code_type msd_initialize_logical_unit(struct logical_unit_type* logical_unit, 
                                                         uint8_t number, 
                                                         uint8_t *buffer, 
                                                         uint32_t count)
    {
        if ((logical_unit == NULL) || (buffer == NULL) || (count == 0))
        {
            return MSD_ERROR;
        }
        
        logical_unit->number = number;
        logical_unit->buffer = buffer;
        logical_unit->count = count; // Store buffer size
        // ...
    }
    
    1. Sense Data Initialization:
    enum msd_error_code_type msd_initialize_logical_unit(...)
    {
        // ...
        logical_unit->request_sense.valid = 0x80; // Fixed: bit field assignment
        logical_unit->request_sense.response_code = 0x70;
        logical_unit->request_sense.additional_sense_length = 
            sizeof(logical_unit->request_sense) - 8;
        // ...
    }
    
    1. Phase Error Detection:
    /* Cases 10 or 13 */
    else if((GET_DIRECTION(cbw->bmCBWFlags) == DIRECTION_OUT) && 
            ((device_count > cbw->dCBWDataTransferLength) || (device_direction != DIRECTION_OUT)))
    {
        prepare_csw(csw, cbw->dCBWTag, cbw->dCBWDataTransferLength, CSW_STATUS_PHASE_ERROR);
        (void)usbd_endpoint_stall(device, MSD_ENDPOINT_OUT, &transmit_csw);
        return;
    }
    

    Key Fixes Summary:

    1. Fixed GET_MAX_LUN to return max LUN index (max_luns - 1)
    2. Corrected SCSI_WRITE10 transfer syntax
    3. Fixed data transfer completion for write operations
    4. Improved test unit ready callback logic
    5. Fixed read callback to use actual buffer
    6. Corrected write callback to use transferred count
    7. Fixed status transport completion context
    8. Added proper block size conversion
    9. Improved buffer management
    10. Fixed sense data bit field assignment

    These changes should resolve all compilation errors and logical issues in your MSD implementation. The code now properly handles the USB MSC protocol, including correct phase error detection, proper data transfer chaining, and accurate sense data reporting.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.

Identical first prompt