ATMEL: storage_task.c File Reference

- Main Page
- Modules
- Data Structures
- Files
- Related Pages

# storage_task.c File Reference

`#include "config.h"`
`#include "conf_usb.h"`
`#include "storage_task.h"`
`#include "lib_mcu/usb/usb_drv.h"`
`#include "usb_descriptors.h"`
`#include "modules/usb/device_chap9/usb_standard_request.h"`
`#include "usb_specific_request.h"`
`#include "modules/scsi_decoder/scsi_decoder.h"`
`#include "modules/control_access/ctrl_access.h"`

Include dependency graph for storage_task.c:

Go to the source code of this file.

## Functions

void | usb_mass_storage_cbw (void)
void | usb_mass_storage_csw (void)
void | storage_task_init (void)
void | storage_task (void)

## Variables

bit | ms_data_direction
static _MEM_TYPE_SLOW_ U8 | dCBWTag [4]
_MEM_TYPE_SLOW_ U8 | g_scsi_status
_MEM_TYPE_FAST_ U32 | g_scsi_data_remaining
bit | ms_multiple_drive
_MEM_TYPE_SLOW_ U8 | g_scsi_command [16]
U8 | endpoint_status [MAX_EP_NB]
_MEM_TYPE_SLOW_ U8 | usb_LUN

## Detailed Description

This file manages the mass storage task.

- Compiler: IAR EWAVR and GNU GCC for AVR
- Supported devices: AT90USB1287, AT90USB1286, AT90USB647, AT90USB646

Author:
  Atmel Corporation: http://www.atmel.com
  Support and FAQ: http://support.atmel.no/

Definition in file storage_task.c.

## Function Documentation

void usb_mass_storage_cbw | ( | void |  | ) |

USB Command Block Wrapper (CBW) management This function decodes the CBW command and stores the SCSI command

Warning:
  Code:?? bytes (function code length)

Parameters:

  | none |

Returns:
  none

check if dCBWSignature is correct

'U'

'S'

'B'

'C'

Store CBW Tag to be repeated in CSW

if (bmCBWFlags.bit7 == 1) {direction = IN}

Definition at line 129 of file storage_task.c.

References c, dCBWTag, endpoint_status, EP_MS_IN, EP_MS_OUT, FALSE, g_scsi_command, g_scsi_data_remaining, get_cur_lun(), Is_usb_ms_data_direction_in, LSB0, LSB1, LSB2, LSB3, ms_multiple_drive, MSK_EP_DIR, scsi_decode_command(), TRUE, Usb_ack_receive_out, Usb_enable_stall_handshake, usb_LUN, Usb_read_byte, Usb_select_endpoint, Usb_set_ms_data_direction_in, and Usb_set_ms_data_direction_out.

Referenced by storage_task().

    00130 {
    00131 bit cbw_error;
    00132 U8  c;
    00133 U8  dummy;
    00134
    00135    cbw_error = FALSE;
    00136    Usb_select_endpoint(EP_MS_OUT);
    00137    if (0x55 != Usb_read_byte())
    00138       { cbw_error = TRUE; }
    00139    if (0x53 != Usb_read_byte())
    00140       { cbw_error = TRUE; }
    00141    if (0x42 != Usb_read_byte())
    00142       { cbw_error = TRUE; }
    00143    if (0x43 != Usb_read_byte())
    00144       { cbw_error = TRUE; }
    00145    if (cbw_error)
    00146    {
    00147       Usb_ack_receive_out();
    00148       Usb_select_endpoint(EP_MS_IN);
    00149       Usb_enable_stall_handshake();
    00150       endpoint_status[(EP_MS_IN & MSK_EP_DIR)] = 0x01;
    00151       return;
    00152    }
    00153
    00154    dCBWTag[0] = Usb_read_byte();
    00155    dCBWTag[1] = Usb_read_byte();
    00156    dCBWTag[2] = Usb_read_byte();
    00157    dCBWTag[3] = Usb_read_byte();
    00158
    00159    LSB0(g_scsi_data_remaining) = Usb_read_byte();
    00160    LSB1(g_scsi_data_remaining) = Usb_read_byte();
    00161    LSB2(g_scsi_data_remaining) = Usb_read_byte();
    00162    LSB3(g_scsi_data_remaining) = Usb_read_byte();
    00163
    00164    if (Usb_read_byte() != 0x00)
    00165    {
    00166       Usb_set_ms_data_direction_in();
    00167    }
    00168    else
    00169    {
    00170       Usb_set_ms_data_direction_out();
    00171    }
    00172
    00173    usb_LUN = Usb_read_byte();
    00174
    00175    if (!ms_multiple_drive)
    00176    {
    00177       usb_LUN = get_cur_lun();
    00178    }
    00179
    00180    dummy      = Usb_read_byte();                // dummy CBWCBLength read
    00181
    00182
    00183    for (c=0; c<16; c++)                         // store scsi_command
    00184    {
    00185       g_scsi_command[c] = Usb_read_byte();
    00186    }
    00187    Usb_ack_receive_out();
    00188
    00189    if (Is_usb_ms_data_direction_in())
    00190    {
    00191       Usb_select_endpoint(EP_MS_IN);
    00192    }
    00193
    00194    if (TRUE != scsi_decode_command())
    00195    {
    00196       U8 ep;
    00197       Usb_enable_stall_handshake();
    00198       if (Is_usb_ms_data_direction_in())
    00199       {
    00200          ep = (EP_MS_IN & MSK_EP_DIR);
    00201       }else{
    00202          ep = (EP_MS_OUT & MSK_EP_DIR);
    00203       }
    00204       endpoint_status[ep] = 0x01;
    00205    }
    00206 }

Here is the call graph for this function:

Here is the caller graph for this function:

void usb_mass_storage_csw | ( | void |  | ) |

USB Command Status Wrapper (CSW) management This function sends the status in relation with the last CBW

Parameters:

  | none |

Returns:
  none

write CSW Signature

'U'

'S'

'B'

'S' write stored CBW Tag

write data residue value

write command status

0 -> PASS, 1 -> FAIL

Definition at line 217 of file storage_task.c.

References dCBWTag, EP_CONTROL, EP_MS_IN, EP_MS_OUT, g_scsi_data_remaining, g_scsi_status, Is_usb_endpoint_enabled, Is_usb_endpoint_stall_requested, Is_usb_receive_setup, Is_usb_write_enabled, LSB0, LSB1, LSB2, LSB3, usb_process_request(), Usb_select_endpoint, Usb_send_in, and Usb_write_byte.

Referenced by storage_task().

    00218 {
    00219    Usb_select_endpoint(EP_MS_IN);
    00220    while (Is_usb_endpoint_stall_requested())
    00221    {
    00222       Usb_select_endpoint(EP_CONTROL);
    00223       if (Is_usb_receive_setup())       { usb_process_request(); }
    00224       Usb_select_endpoint(EP_MS_IN);
    00225    }
    00226
    00227    Usb_select_endpoint(EP_MS_OUT);
    00228    while (Is_usb_endpoint_stall_requested())
    00229    {
    00230       Usb_select_endpoint(EP_CONTROL);
    00231       if (Is_usb_receive_setup())       { usb_process_request(); }
    00232       Usb_select_endpoint(EP_MS_OUT);
    00233    }
    00234
    00235
    00236    Usb_select_endpoint(EP_MS_IN);
    00237    while(!Is_usb_write_enabled())
    00238    {
    00239       if(!Is_usb_endpoint_enabled())   return; // USB Reset
    00240    }
    00242    Usb_write_byte(0x55);
    00243    Usb_write_byte(0x53);
    00244    Usb_write_byte(0x42);
    00245    Usb_write_byte(0x53);
    00246
    00247    Usb_write_byte(dCBWTag[0]);
    00248    Usb_write_byte(dCBWTag[1]);
    00249    Usb_write_byte(dCBWTag[2]);
    00250    Usb_write_byte(dCBWTag[3]);
    00252    Usb_write_byte( LSB0(g_scsi_data_remaining) );
    00253    Usb_write_byte( LSB1(g_scsi_data_remaining) );
    00254    Usb_write_byte( LSB2(g_scsi_data_remaining) );
    00255    Usb_write_byte( LSB3(g_scsi_data_remaining) );
    00256
    00258    Usb_write_byte(g_scsi_status);
    00259
    00260    Usb_send_in();
    00261 }

Here is the call graph for this function:

Here is the caller graph for this function:

void storage_task_init | ( | void |  | ) |

This function initializes the hardware/software ressources required for storage task.

Parameters:

  | none |

Returns:
  none

/

Definition at line 86 of file storage_task.c.

References df_mem_init(), Leds_init, and Usb_enable_sof_interrupt.

    00087 {
    00088    Leds_init();
    00089    Usb_enable_sof_interrupt();
    00090    df_mem_init();    // Init the hw/sw ressources required to drive the DF.
    00091 }

Here is the call graph for this function:

void storage_task | ( | void |  | ) |

Entry point of the mass storage task management This function links the mass storage SCSI commands and the USB bus.

Parameters:

  | none |

Returns:
  none

Definition at line 102 of file storage_task.c.

References EP_MS_OUT, Is_device_enumerated, Is_usb_receive_out, usb_mass_storage_cbw(), usb_mass_storage_csw(), and Usb_select_endpoint.

    00103 {
    00104    if (Is_device_enumerated())
    00105    {
    00106       Usb_select_endpoint(EP_MS_OUT);
    00107       if (Is_usb_receive_out())
    00108       {
    00109          usb_mass_storage_cbw();
    00110          usb_mass_storage_csw();
    00111       }
    00112    }
    00113 }

Here is the call graph for this function:

## Variable Documentation

bit ms_data_direction

Definition at line 61 of file storage_task.c.

_MEM_TYPE_SLOW_ U8 dCBWTag[4]`[static]`

Definition at line 62 of file storage_task.c.

Referenced by usb_mass_storage_cbw(), and usb_mass_storage_csw().

_MEM_TYPE_SLOW_ U8 g_scsi_status

Definition at line 60 of file scsi_decoder.c.

Referenced by usb_mass_storage_csw().

_MEM_TYPE_FAST_ U32 g_scsi_data_remaining

Definition at line 61 of file scsi_decoder.c.

Referenced by sbc_read_10(), sbc_write_10(), usb_mass_storage_cbw(), and usb_mass_storage_csw().

bit ms_multiple_drive

Definition at line 63 of file usb_specific_request.c.

Referenced by usb_mass_storage_cbw(), and usb_user_read_request().

_MEM_TYPE_SLOW_ U8 g_scsi_command[16]

Definition at line 59 of file scsi_decoder.c.

Referenced by sbc_inquiry(), sbc_mode_sense(), sbc_read_10(), sbc_request_sense(), sbc_write_10(), scsi_decode_command(), and usb_mass_storage_cbw().

U8 endpoint_status[MAX_EP_NB]

Definition at line 98 of file usb_standard_request.c.

Referenced by usb_clear_feature(), usb_get_status(), usb_mass_storage_cbw(), usb_process_request(), and usb_set_feature().

_MEM_TYPE_SLOW_ U8 usb_LUN

Definition at line 71 of file storage_task.c.

Referenced by sbc_header_mode_sense(), sbc_read_10(), sbc_read_capacity(), sbc_test_unit_ready(), sbc_write_10(), and usb_mass_storage_cbw().