storage_task.c

Go to the documentation of this file.

/*This file has been prepared for Doxygen automatic documentation generation.*/

/* Copyright (c) 2007, Atmel Corporation All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *
 * 3. The name of ATMEL may not be used to endorse or promote products derived
 * from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY ATMEL ``AS IS'' AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE EXPRESSLY AND
 * SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR ANY DIRECT,
 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

//_____  I N C L U D E S ___________________________________________________

#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"



//_____ D E C L A R A T I O N S ____________________________________________


volatile U8 cpt_sof;
extern  U8   usb_configuration_nb;
extern Bool g_b_df_protected;  // Global value to manage the write protection on DataFlash


bit ms_data_direction;
static _MEM_TYPE_SLOW_ U8  dCBWTag[4];

extern _MEM_TYPE_SLOW_ U8  g_scsi_status;
extern _MEM_TYPE_FAST_ U32 g_scsi_data_remaining;
extern bit ms_multiple_drive;
extern _MEM_TYPE_SLOW_ U8  g_scsi_command[16];

extern U8   endpoint_status[MAX_EP_NB];

_MEM_TYPE_SLOW_ U8 usb_LUN;


void usb_mass_storage_cbw (void);
void usb_mass_storage_csw (void);

void storage_task_init(void)
{
   Leds_init();
   Joy_init();
   Usb_enable_sof_interrupt();
   df_mem_init();    // Init the hw/sw ressources required to drive the DF.
}


void storage_task(void)
{
   if(Is_joy_up())
   {
      // Look Write Protection DataFlash
      g_b_df_protected = TRUE;
   }
   if(Is_joy_down())
   {
      // UnLook Write Protection DataFlash
      g_b_df_protected = FALSE;
   }
    
   if (Is_device_enumerated())
   {
      Usb_select_endpoint(EP_MS_OUT);
      if (Is_usb_receive_out())
      {
         usb_mass_storage_cbw();
         usb_mass_storage_csw();
      }
   }
}


void sof_action()
{
   cpt_sof++;
}


void usb_mass_storage_cbw (void)
{
bit cbw_error;
U8  c;
U8  dummy;

   cbw_error = FALSE;
   Usb_select_endpoint(EP_MS_OUT);           
   if (0x55 != Usb_read_byte())
      { cbw_error = TRUE; } 
   if (0x53 != Usb_read_byte())
      { cbw_error = TRUE; } 
   if (0x42 != Usb_read_byte())
      { cbw_error = TRUE; } 
   if (0x43 != Usb_read_byte())
      { cbw_error = TRUE; } 
   if (cbw_error)
   {
      Usb_ack_receive_out();
      Usb_select_endpoint(EP_MS_IN);
      Usb_enable_stall_handshake();
      endpoint_status[(EP_MS_IN & MSK_EP_DIR)] = 0x01;
      return;
   }

   dCBWTag[0] = Usb_read_byte();             
   dCBWTag[1] = Usb_read_byte();
   dCBWTag[2] = Usb_read_byte();
   dCBWTag[3] = Usb_read_byte();
   
   LSB0(g_scsi_data_remaining) = Usb_read_byte();
   LSB1(g_scsi_data_remaining) = Usb_read_byte();
   LSB2(g_scsi_data_remaining) = Usb_read_byte();
   LSB3(g_scsi_data_remaining) = Usb_read_byte();

   if (Usb_read_byte() != 0x00)              
   {
      Usb_set_ms_data_direction_in();
   }
   else
   {
      Usb_set_ms_data_direction_out();
   }

   usb_LUN = Usb_read_byte();

   if (!ms_multiple_drive)
   {
      usb_LUN = get_cur_lun();
   }

   dummy      = Usb_read_byte();                // dummy CBWCBLength read


   for (c=0; c<16; c++)                         // store scsi_command
   {
      g_scsi_command[c] = Usb_read_byte();
   }
   Usb_ack_receive_out();

   if (Is_usb_ms_data_direction_in())
   {
      Usb_select_endpoint(EP_MS_IN);
   }

   if (TRUE != scsi_decode_command())
   {
      U8 ep;
      Usb_enable_stall_handshake();
      if (Is_usb_ms_data_direction_in())
      {
         ep = (EP_MS_IN & MSK_EP_DIR);
      }else{
         ep = (EP_MS_OUT & MSK_EP_DIR);
      }
      endpoint_status[ep] = 0x01;
   }
}


void usb_mass_storage_csw (void)
{
   Usb_select_endpoint(EP_MS_IN);
   while (Is_usb_endpoint_stall_requested())
   {
      Usb_select_endpoint(EP_CONTROL);
      if (Is_usb_receive_setup())       { usb_process_request(); }
      Usb_select_endpoint(EP_MS_IN);
   }

   Usb_select_endpoint(EP_MS_OUT);
   while (Is_usb_endpoint_stall_requested())
   {
      Usb_select_endpoint(EP_CONTROL);
      if (Is_usb_receive_setup())       { usb_process_request(); }
      Usb_select_endpoint(EP_MS_OUT);
   }


   Usb_select_endpoint(EP_MS_IN);
   while(!Is_usb_write_enabled())
   {
      if(!Is_usb_endpoint_enabled())   return; // USB Reset
   }
   Usb_write_byte(0x55);                                 
   Usb_write_byte(0x53);                                 
   Usb_write_byte(0x42);                                 
   Usb_write_byte(0x53);                                 

   Usb_write_byte(dCBWTag[0]);
   Usb_write_byte(dCBWTag[1]);
   Usb_write_byte(dCBWTag[2]);
   Usb_write_byte(dCBWTag[3]);
   Usb_write_byte( LSB0(g_scsi_data_remaining) );
   Usb_write_byte( LSB1(g_scsi_data_remaining) );
   Usb_write_byte( LSB2(g_scsi_data_remaining) );
   Usb_write_byte( LSB3(g_scsi_data_remaining) );

   Usb_write_byte(g_scsi_status);                        

   Usb_send_in();
}

---