Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usbx_device_classes/src/ux_device_class_storage_initialize.c	Lines:	53	65	81.5 %
Date:	2024-12-12 17:16:36	Branches:	25	36	69.4 %


/***************************************************************************
 * Copyright (c) 2024 Microsoft Corporation
 *
 * This program and the accompanying materials are made available under the
 * terms of the MIT License which is available at
 * https://opensource.org/licenses/MIT.
 *
 * SPDX-License-Identifier: MIT
 **************************************************************************/


/**************************************************************************/
/**************************************************************************/
/**                                                                       */
/** USBX Component                                                        */
/**                                                                       */
/**   Device Storage Class                                                */
/**                                                                       */
/**************************************************************************/
/**************************************************************************/

#define UX_SOURCE_CODE


/* Include necessary system files.  */

#include "ux_api.h"
#include "ux_device_class_storage.h"
#include "ux_device_stack.h"

/* Define the Slave Storage Class Inquiry data : DO NOT CHANGE THE LENGTH OF THESE ITEMS */

UCHAR _ux_system_slave_class_storage_vendor_id[] =                          "AzureRTO";
UCHAR _ux_system_slave_class_storage_product_id[] =                         "USBX storage dev";
UCHAR _ux_system_slave_class_storage_product_rev[] =                        "2000";
UCHAR _ux_system_slave_class_storage_product_serial[] =                     "12345678901234567890";

/**************************************************************************/
/*                                                                        */
/*  FUNCTION                                               RELEASE        */
/*                                                                        */
/*    _ux_device_class_storage_initialize                 PORTABLE C      */
/*                                                           6.3.0        */
/*  AUTHOR                                                                */
/*                                                                        */
/*    Chaoqiong Xiao, Microsoft Corporation                               */
/*                                                                        */
/*  DESCRIPTION                                                           */
/*                                                                        */
/*    This function initializes the USB storage device.                   */
/*                                                                        */
/*  INPUT                                                                 */
/*                                                                        */
/*    command                               Pointer to storage command    */
/*                                                                        */
/*  OUTPUT                                                                */
/*                                                                        */
/*    Completion Status                                                   */
/*                                                                        */
/*  CALLS                                                                 */
/*                                                                        */
/*    _ux_utility_memory_allocate           Allocate memory               */
/*    _ux_utility_memory_free               Free memory                   */
/*    _ux_device_thread_create              Create thread                 */
/*    _ux_device_thread_delete              Delete thread                 */
/*                                                                        */
/*  CALLED BY                                                             */
/*                                                                        */
/*    Device Storage Class                                                */
/*                                                                        */
/*  RELEASE HISTORY                                                       */
/*                                                                        */
/*    DATE              NAME                      DESCRIPTION             */
/*                                                                        */
/*  05-19-2020     Chaoqiong Xiao           Initial Version 6.0           */
/*  09-30-2020     Chaoqiong Xiao           Modified comment(s),          */
/*                                            used UX prefix to refer to  */
/*                                            TX symbols instead of using */
/*                                            them directly,              */
/*                                            resulting in version 6.1    */
/*  01-31-2022     Chaoqiong Xiao           Modified comment(s),          */
/*                                            added standalone support,   */
/*                                            resulting in version 6.1.10 */
/*  10-31-2023     Chaoqiong Xiao           Modified comment(s),          */
/*                                            added a new mode to manage  */
/*                                            endpoint buffer in classes, */
/*                                            resulting in version 6.3.0  */
/*                                                                        */
/**************************************************************************/
UINT  _ux_device_class_storage_initialize(UX_SLAVE_CLASS_COMMAND *command)
{

UINT                                    status = UX_SUCCESS;
UX_SLAVE_CLASS_STORAGE                  *storage;
UX_SLAVE_CLASS_STORAGE_PARAMETER        *storage_parameter;
UX_SLAVE_CLASS                          *class_inst;
ULONG                                   lun_index;


    /* Get the pointer to the application parameters for the storage class.  */
    storage_parameter =  command -> ux_slave_class_command_parameter;

    /* Ensure the number of LUN declared by the caller does not exceed the
       max number allowed for LUN storage.  */
    if (storage_parameter -> ux_slave_class_storage_parameter_number_lun > UX_MAX_SLAVE_LUN)
        return UX_ERROR;

    /* Get the class container.  */
    class_inst =  command -> ux_slave_class_command_class_ptr;

    /* Create an instance of the device storage class.  */
    storage =  _ux_utility_memory_allocate(UX_NO_ALIGN, UX_REGULAR_MEMORY, sizeof(UX_SLAVE_CLASS_STORAGE));

    /* Check for successful allocation.  */
    if (storage == UX_NULL)
        return(UX_MEMORY_INSUFFICIENT);

#if UX_DEVICE_ENDPOINT_BUFFER_OWNER == 1

    /* Allocate bulk endpoint buffer.  */
    UX_ASSERT(!UX_DEVICE_CLASS_STORAGE_ENDPOINT_BUFFER_SIZE_CALC_OVERFLOW);
    storage -> ux_device_class_storage_endpoint_buffer = _ux_utility_memory_allocate(UX_NO_ALIGN,
                UX_CACHE_SAFE_MEMORY, UX_DEVICE_CLASS_STORAGE_ENDPOINT_BUFFER_SIZE);
#else
    status = UX_SUCCESS;
#endif

#if !defined(UX_DEVICE_STANDALONE)

    /* Allocate some memory for the thread stack. */
    if (status == UX_SUCCESS)
    {
        class_inst -> ux_slave_class_thread_stack = _ux_utility_memory_allocate(UX_NO_ALIGN, UX_REGULAR_MEMORY, UX_THREAD_STACK_SIZE);

        /* If it's OK, create thread.  */
        if (class_inst -> ux_slave_class_thread_stack != UX_NULL)

            /* This instance needs to be running in a different thread. So start
            a new thread. We pass a pointer to the class to the new thread.  This thread
            does not start until we have a instance of the class. */
            status =  _ux_device_thread_create(&class_inst -> ux_slave_class_thread, "ux_slave_storage_thread",
                        _ux_device_class_storage_thread,
                        (ULONG) (ALIGN_TYPE) class_inst, (VOID *) class_inst -> ux_slave_class_thread_stack,
                        UX_THREAD_STACK_SIZE, UX_THREAD_PRIORITY_CLASS,
                        UX_THREAD_PRIORITY_CLASS, UX_NO_TIME_SLICE, UX_DONT_START);
        else
            status = UX_MEMORY_INSUFFICIENT;
    }
#else

    /* Save tasks run entry.  */
    class_inst -> ux_slave_class_task_function = _ux_device_class_storage_tasks_run;
#endif

    /* If thread resources allocated, go on.  */
    if (status == UX_SUCCESS)
    {

        UX_THREAD_EXTENSION_PTR_SET(&(class_inst -> ux_slave_class_thread), class_inst)

        /* Store the number of LUN declared.  */
        storage -> ux_slave_class_storage_number_lun = storage_parameter -> ux_slave_class_storage_parameter_number_lun;

        /* Copy each individual LUN parameters.  */
        for (lun_index = 0; lun_index < storage -> ux_slave_class_storage_number_lun; lun_index++)
        {

            /* Check block length size. */
            if (storage_parameter -> ux_slave_class_storage_parameter_lun[lun_index].ux_slave_class_storage_media_block_length > UX_SLAVE_CLASS_STORAGE_BUFFER_SIZE)
            {
                /* Cannot proceed.  */
                status = (UX_MEMORY_INSUFFICIENT);
                break;
            }

            /* Store all the application parameter information about the media.  */
            storage -> ux_slave_class_storage_lun[lun_index].ux_slave_class_storage_media_last_lba       = storage_parameter -> ux_slave_class_storage_parameter_lun[lun_index].ux_slave_class_storage_media_last_lba;
            storage -> ux_slave_class_storage_lun[lun_index].ux_slave_class_storage_media_block_length   = storage_parameter -> ux_slave_class_storage_parameter_lun[lun_index].ux_slave_class_storage_media_block_length;
            storage -> ux_slave_class_storage_lun[lun_index].ux_slave_class_storage_media_type           = storage_parameter -> ux_slave_class_storage_parameter_lun[lun_index].ux_slave_class_storage_media_type;
            storage -> ux_slave_class_storage_lun[lun_index].ux_slave_class_storage_media_removable_flag = storage_parameter -> ux_slave_class_storage_parameter_lun[lun_index].ux_slave_class_storage_media_removable_flag;
            storage -> ux_slave_class_storage_lun[lun_index].ux_slave_class_storage_media_read_only_flag = storage_parameter -> ux_slave_class_storage_parameter_lun[lun_index].ux_slave_class_storage_media_read_only_flag;
            storage -> ux_slave_class_storage_lun[lun_index].ux_slave_class_storage_media_read           = storage_parameter -> ux_slave_class_storage_parameter_lun[lun_index].ux_slave_class_storage_media_read;
            storage -> ux_slave_class_storage_lun[lun_index].ux_slave_class_storage_media_flush          = storage_parameter -> ux_slave_class_storage_parameter_lun[lun_index].ux_slave_class_storage_media_flush;
            storage -> ux_slave_class_storage_lun[lun_index].ux_slave_class_storage_media_write          = storage_parameter -> ux_slave_class_storage_parameter_lun[lun_index].ux_slave_class_storage_media_write;
            storage -> ux_slave_class_storage_lun[lun_index].ux_slave_class_storage_media_status         = storage_parameter -> ux_slave_class_storage_parameter_lun[lun_index].ux_slave_class_storage_media_status;
            storage -> ux_slave_class_storage_lun[lun_index].ux_slave_class_storage_media_notification   = storage_parameter -> ux_slave_class_storage_parameter_lun[lun_index].ux_slave_class_storage_media_notification;
        }

        /* If it's OK, complete it.  */
        if (status == UX_SUCCESS)
        {

            /* Store the start and stop signals if needed by the application.  */
            storage -> ux_slave_class_storage_instance_activate = storage_parameter -> ux_slave_class_storage_instance_activate;
            storage -> ux_slave_class_storage_instance_deactivate = storage_parameter -> ux_slave_class_storage_instance_deactivate;

            /* Store the vendor id, product id, product revision and product serial.  */
            if (storage_parameter -> ux_slave_class_storage_parameter_vendor_id)
                storage -> ux_slave_class_storage_vendor_id = storage_parameter -> ux_slave_class_storage_parameter_vendor_id;
            else
                storage -> ux_slave_class_storage_vendor_id = _ux_system_slave_class_storage_vendor_id;

            if (storage_parameter -> ux_slave_class_storage_parameter_product_id)
                storage -> ux_slave_class_storage_product_id = storage_parameter -> ux_slave_class_storage_parameter_product_id;
            else
                storage -> ux_slave_class_storage_product_id = _ux_system_slave_class_storage_product_id;

            if (storage_parameter -> ux_slave_class_storage_parameter_product_rev)
                storage -> ux_slave_class_storage_product_rev = storage_parameter -> ux_slave_class_storage_parameter_product_rev;
            else
                storage -> ux_slave_class_storage_product_rev = _ux_system_slave_class_storage_product_rev;

            if (storage_parameter -> ux_slave_class_storage_parameter_product_serial)
                storage -> ux_slave_class_storage_product_serial = storage_parameter -> ux_slave_class_storage_parameter_product_serial;
            else
                storage -> ux_slave_class_storage_product_serial = _ux_system_slave_class_storage_product_serial;

            /* Save the address of the STORAGE instance inside the STORAGE container.  */
            class_inst -> ux_slave_class_instance = (VOID *) storage;

            return(UX_SUCCESS);
        }

        /* Free thread resources.  */
        _ux_device_thread_delete(&class_inst -> ux_slave_class_thread);
    }

#if !defined(UX_DEVICE_STANDALONE)
    if (class_inst -> ux_slave_class_thread_stack != UX_NULL)
        _ux_utility_memory_free(&class_inst -> ux_slave_class_thread_stack);
#endif

#if UX_DEVICE_ENDPOINT_BUFFER_OWNER == 1
    if (storage -> ux_device_class_storage_endpoint_buffer != UX_NULL)
        _ux_utility_memory_free(storage -> ux_device_class_storage_endpoint_buffer);
#endif

    /* Free instance.  */
    _ux_utility_memory_free(storage);

    /* Return completion status.  */
    return(status);
}


/**************************************************************************/
/*                                                                        */
/*  FUNCTION                                               RELEASE        */
/*                                                                        */
/*    _uxe_device_class_storage_initialize                PORTABLE C      */
/*                                                           6.3.0        */
/*  AUTHOR                                                                */
/*                                                                        */
/*    Chaoqiong Xiao, Microsoft Corporation                               */
/*                                                                        */
/*  DESCRIPTION                                                           */
/*                                                                        */
/*    This function checks errors in storage initialization function call.*/
/*                                                                        */
/*  INPUT                                                                 */
/*                                                                        */
/*    command                               Pointer to storage command    */
/*                                                                        */
/*  OUTPUT                                                                */
/*                                                                        */
/*    Completion Status                                                   */
/*                                                                        */
/*  CALLS                                                                 */
/*                                                                        */
/*    _ux_device_class_storage_initialize     Initialize storage instance */
/*                                                                        */
/*  CALLED BY                                                             */
/*                                                                        */
/*    Application                                                         */
/*                                                                        */
/*  RELEASE HISTORY                                                       */
/*                                                                        */
/*    DATE              NAME                      DESCRIPTION             */
/*                                                                        */
/*  10-31-2023     Chaoqiong Xiao           Initial Version 6.3.0         */
/*                                                                        */
/**************************************************************************/
UINT  _uxe_device_class_storage_initialize(UX_SLAVE_CLASS_COMMAND *command)
{

UX_SLAVE_CLASS_STORAGE_PARAMETER        *storage_parameter;
UINT                                    i;

    /* Get the pointer to the application parameters for the storage class.  */
    storage_parameter =  command -> ux_slave_class_command_parameter;

    /* Sanity checks.  */
    if (storage_parameter -> ux_slave_class_storage_parameter_number_lun > UX_MAX_SLAVE_LUN)
        return(UX_INVALID_PARAMETER);
    for (i = 0; i < storage_parameter -> ux_slave_class_storage_parameter_number_lun; i ++)
    {
        if ((storage_parameter -> ux_slave_class_storage_parameter_lun[i].
                            ux_slave_class_storage_media_read == UX_NULL) ||
            (storage_parameter -> ux_slave_class_storage_parameter_lun[i].
                            ux_slave_class_storage_media_write == UX_NULL) ||
            (storage_parameter -> ux_slave_class_storage_parameter_lun[i].
                            ux_slave_class_storage_media_status == UX_NULL)
#if defined(UX_SLAVE_CLASS_STORAGE_INCLUDE_MMC)
            || (storage_parameter -> ux_slave_class_storage_parameter_lun[i].
                            ux_slave_class_storage_media_notification == UX_NULL)
#endif
           )
        {
            return(UX_INVALID_PARAMETER);
        }
    }

    /* Invoke storage initialize function.  */
    return(_ux_device_class_storage_initialize(command));
}


Generated by: GCOVR (Version 4.1)

Line	Branch	Exec	Source
1			/***************************************************************************
2			* Copyright (c) 2024 Microsoft Corporation
3			*
4			* This program and the accompanying materials are made available under the
5			* terms of the MIT License which is available at
6			* https://opensource.org/licenses/MIT.
7			*
8			* SPDX-License-Identifier: MIT
9			**************************************************************************/
10
11
12			/**************************************************************************/
13			/**************************************************************************/
14			/** */
15			/** USBX Component */
16			/** */
17			/** Device Storage Class */
18			/** */
19			/**************************************************************************/
20			/**************************************************************************/
21
22			#define UX_SOURCE_CODE
23
24
25			/* Include necessary system files. */
26
27			#include "ux_api.h"
28			#include "ux_device_class_storage.h"
29			#include "ux_device_stack.h"
30
31			/* Define the Slave Storage Class Inquiry data : DO NOT CHANGE THE LENGTH OF THESE ITEMS */
32
33			UCHAR _ux_system_slave_class_storage_vendor_id[] = "AzureRTO";
34			UCHAR _ux_system_slave_class_storage_product_id[] = "USBX storage dev";
35			UCHAR _ux_system_slave_class_storage_product_rev[] = "2000";
36			UCHAR _ux_system_slave_class_storage_product_serial[] = "12345678901234567890";
37
38			/**************************************************************************/
39			/* */
40			/* FUNCTION RELEASE */
41			/* */
42			/* _ux_device_class_storage_initialize PORTABLE C */
43			/* 6.3.0 */
44			/* AUTHOR */
45			/* */
46			/* Chaoqiong Xiao, Microsoft Corporation */
47			/* */
48			/* DESCRIPTION */
49			/* */
50			/* This function initializes the USB storage device. */
51			/* */
52			/* INPUT */
53			/* */
54			/* command Pointer to storage command */
55			/* */
56			/* OUTPUT */
57			/* */
58			/* Completion Status */
59			/* */
60			/* CALLS */
61			/* */
62			/* _ux_utility_memory_allocate Allocate memory */
63			/* _ux_utility_memory_free Free memory */
64			/* _ux_device_thread_create Create thread */
65			/* _ux_device_thread_delete Delete thread */
66			/* */
67			/* CALLED BY */
68			/* */
69			/* Device Storage Class */
70			/* */
71			/* RELEASE HISTORY */
72			/* */
73			/* DATE NAME DESCRIPTION */
74			/* */
75			/* 05-19-2020 Chaoqiong Xiao Initial Version 6.0 */
76			/* 09-30-2020 Chaoqiong Xiao Modified comment(s), */
77			/* used UX prefix to refer to */
78			/* TX symbols instead of using */
79			/* them directly, */
80			/* resulting in version 6.1 */
81			/* 01-31-2022 Chaoqiong Xiao Modified comment(s), */
82			/* added standalone support, */
83			/* resulting in version 6.1.10 */
84			/* 10-31-2023 Chaoqiong Xiao Modified comment(s), */
85			/* added a new mode to manage */
86			/* endpoint buffer in classes, */
87			/* resulting in version 6.3.0 */
88			/* */
89			/**************************************************************************/
90		50	UINT _ux_device_class_storage_initialize(UX_SLAVE_CLASS_COMMAND *command)
91			{
92
93		50	UINT status = UX_SUCCESS;
94			UX_SLAVE_CLASS_STORAGE *storage;
95			UX_SLAVE_CLASS_STORAGE_PARAMETER *storage_parameter;
96			UX_SLAVE_CLASS *class_inst;
97			ULONG lun_index;
98
99
100			/* Get the pointer to the application parameters for the storage class. */
101		50	storage_parameter = command -> ux_slave_class_command_parameter;
102
103			/* Ensure the number of LUN declared by the caller does not exceed the
104			max number allowed for LUN storage. */
105	✓✓	50	if (storage_parameter -> ux_slave_class_storage_parameter_number_lun > UX_MAX_SLAVE_LUN)
106		1	return UX_ERROR;
107
108			/* Get the class container. */
109		49	class_inst = command -> ux_slave_class_command_class_ptr;
110
111			/* Create an instance of the device storage class. */
112		49	storage = _ux_utility_memory_allocate(UX_NO_ALIGN, UX_REGULAR_MEMORY, sizeof(UX_SLAVE_CLASS_STORAGE));
113
114			/* Check for successful allocation. */
115	✓✓	49	if (storage == UX_NULL)
116		2	return(UX_MEMORY_INSUFFICIENT);
117
118			#if UX_DEVICE_ENDPOINT_BUFFER_OWNER == 1
119
120			/* Allocate bulk endpoint buffer. */
121			UX_ASSERT(!UX_DEVICE_CLASS_STORAGE_ENDPOINT_BUFFER_SIZE_CALC_OVERFLOW);
122			storage -> ux_device_class_storage_endpoint_buffer = _ux_utility_memory_allocate(UX_NO_ALIGN,
123			UX_CACHE_SAFE_MEMORY, UX_DEVICE_CLASS_STORAGE_ENDPOINT_BUFFER_SIZE);
124			#else
125		47	status = UX_SUCCESS;
126			#endif
127
128			#if !defined(UX_DEVICE_STANDALONE)
129
130			/* Allocate some memory for the thread stack. */
131	✓✗	47	if (status == UX_SUCCESS)
132			{
133		47	class_inst -> ux_slave_class_thread_stack = _ux_utility_memory_allocate(UX_NO_ALIGN, UX_REGULAR_MEMORY, UX_THREAD_STACK_SIZE);
134
135			/* If it's OK, create thread. */
136	✓✓	47	if (class_inst -> ux_slave_class_thread_stack != UX_NULL)
137
138			/* This instance needs to be running in a different thread. So start
139			a new thread. We pass a pointer to the class to the new thread. This thread
140			does not start until we have a instance of the class. */
141		45	status = _ux_device_thread_create(&class_inst -> ux_slave_class_thread, "ux_slave_storage_thread",
142			_ux_device_class_storage_thread,
143			(ULONG) (ALIGN_TYPE) class_inst, (VOID *) class_inst -> ux_slave_class_thread_stack,
144			UX_THREAD_STACK_SIZE, UX_THREAD_PRIORITY_CLASS,
145			UX_THREAD_PRIORITY_CLASS, UX_NO_TIME_SLICE, UX_DONT_START);
146			else
147		2	status = UX_MEMORY_INSUFFICIENT;
148			}
149			#else
150
151			/* Save tasks run entry. */
152			class_inst -> ux_slave_class_task_function = _ux_device_class_storage_tasks_run;
153			#endif
154
155			/* If thread resources allocated, go on. */
156	✓✓	47	if (status == UX_SUCCESS)
157			{
158
159			UX_THREAD_EXTENSION_PTR_SET(&(class_inst -> ux_slave_class_thread), class_inst)
160
161			/* Store the number of LUN declared. */
162		44	storage -> ux_slave_class_storage_number_lun = storage_parameter -> ux_slave_class_storage_parameter_number_lun;
163
164			/* Copy each individual LUN parameters. */
165	✓✓	101	for (lun_index = 0; lun_index < storage -> ux_slave_class_storage_number_lun; lun_index++)
166			{
167
168			/* Check block length size. */
169	✓✓	58	if (storage_parameter -> ux_slave_class_storage_parameter_lun[lun_index].ux_slave_class_storage_media_block_length > UX_SLAVE_CLASS_STORAGE_BUFFER_SIZE)
170			{
171			/* Cannot proceed. */
172		1	status = (UX_MEMORY_INSUFFICIENT);
173		1	break;
174			}
175
176			/* Store all the application parameter information about the media. */
177		57	storage -> ux_slave_class_storage_lun[lun_index].ux_slave_class_storage_media_last_lba = storage_parameter -> ux_slave_class_storage_parameter_lun[lun_index].ux_slave_class_storage_media_last_lba;
178		57	storage -> ux_slave_class_storage_lun[lun_index].ux_slave_class_storage_media_block_length = storage_parameter -> ux_slave_class_storage_parameter_lun[lun_index].ux_slave_class_storage_media_block_length;
179		57	storage -> ux_slave_class_storage_lun[lun_index].ux_slave_class_storage_media_type = storage_parameter -> ux_slave_class_storage_parameter_lun[lun_index].ux_slave_class_storage_media_type;
180		57	storage -> ux_slave_class_storage_lun[lun_index].ux_slave_class_storage_media_removable_flag = storage_parameter -> ux_slave_class_storage_parameter_lun[lun_index].ux_slave_class_storage_media_removable_flag;
181		57	storage -> ux_slave_class_storage_lun[lun_index].ux_slave_class_storage_media_read_only_flag = storage_parameter -> ux_slave_class_storage_parameter_lun[lun_index].ux_slave_class_storage_media_read_only_flag;
182		57	storage -> ux_slave_class_storage_lun[lun_index].ux_slave_class_storage_media_read = storage_parameter -> ux_slave_class_storage_parameter_lun[lun_index].ux_slave_class_storage_media_read;
183		57	storage -> ux_slave_class_storage_lun[lun_index].ux_slave_class_storage_media_flush = storage_parameter -> ux_slave_class_storage_parameter_lun[lun_index].ux_slave_class_storage_media_flush;
184		57	storage -> ux_slave_class_storage_lun[lun_index].ux_slave_class_storage_media_write = storage_parameter -> ux_slave_class_storage_parameter_lun[lun_index].ux_slave_class_storage_media_write;
185		57	storage -> ux_slave_class_storage_lun[lun_index].ux_slave_class_storage_media_status = storage_parameter -> ux_slave_class_storage_parameter_lun[lun_index].ux_slave_class_storage_media_status;
186		57	storage -> ux_slave_class_storage_lun[lun_index].ux_slave_class_storage_media_notification = storage_parameter -> ux_slave_class_storage_parameter_lun[lun_index].ux_slave_class_storage_media_notification;
187			}
188
189			/* If it's OK, complete it. */
190	✓✓	44	if (status == UX_SUCCESS)
191			{
192
193			/* Store the start and stop signals if needed by the application. */
194		43	storage -> ux_slave_class_storage_instance_activate = storage_parameter -> ux_slave_class_storage_instance_activate;
195		43	storage -> ux_slave_class_storage_instance_deactivate = storage_parameter -> ux_slave_class_storage_instance_deactivate;
196
197			/* Store the vendor id, product id, product revision and product serial. */
198	✓✓	43	if (storage_parameter -> ux_slave_class_storage_parameter_vendor_id)
199		1	storage -> ux_slave_class_storage_vendor_id = storage_parameter -> ux_slave_class_storage_parameter_vendor_id;
200			else
201		42	storage -> ux_slave_class_storage_vendor_id = _ux_system_slave_class_storage_vendor_id;
202
203	✓✓	43	if (storage_parameter -> ux_slave_class_storage_parameter_product_id)
204		1	storage -> ux_slave_class_storage_product_id = storage_parameter -> ux_slave_class_storage_parameter_product_id;
205			else
206		42	storage -> ux_slave_class_storage_product_id = _ux_system_slave_class_storage_product_id;
207
208	✓✓	43	if (storage_parameter -> ux_slave_class_storage_parameter_product_rev)
209		1	storage -> ux_slave_class_storage_product_rev = storage_parameter -> ux_slave_class_storage_parameter_product_rev;
210			else
211		42	storage -> ux_slave_class_storage_product_rev = _ux_system_slave_class_storage_product_rev;
212
213	✓✓	43	if (storage_parameter -> ux_slave_class_storage_parameter_product_serial)
214		1	storage -> ux_slave_class_storage_product_serial = storage_parameter -> ux_slave_class_storage_parameter_product_serial;
215			else
216		42	storage -> ux_slave_class_storage_product_serial = _ux_system_slave_class_storage_product_serial;
217
218			/* Save the address of the STORAGE instance inside the STORAGE container. */
219		43	class_inst -> ux_slave_class_instance = (VOID *) storage;
220
221		43	return(UX_SUCCESS);
222			}
223
224			/* Free thread resources. */
225		1	_ux_device_thread_delete(&class_inst -> ux_slave_class_thread);
226			}
227
228			#if !defined(UX_DEVICE_STANDALONE)
229	✓✓	4	if (class_inst -> ux_slave_class_thread_stack != UX_NULL)
230		2	_ux_utility_memory_free(&class_inst -> ux_slave_class_thread_stack);
231			#endif
232
233			#if UX_DEVICE_ENDPOINT_BUFFER_OWNER == 1
234			if (storage -> ux_device_class_storage_endpoint_buffer != UX_NULL)
235			_ux_utility_memory_free(storage -> ux_device_class_storage_endpoint_buffer);
236			#endif
237
238			/* Free instance. */
239		4	_ux_utility_memory_free(storage);
240
241			/* Return completion status. */
242		4	return(status);
243			}
244
245
246			/**************************************************************************/
247			/* */
248			/* FUNCTION RELEASE */
249			/* */
250			/* _uxe_device_class_storage_initialize PORTABLE C */
251			/* 6.3.0 */
252			/* AUTHOR */
253			/* */
254			/* Chaoqiong Xiao, Microsoft Corporation */
255			/* */
256			/* DESCRIPTION */
257			/* */
258			/* This function checks errors in storage initialization function call.*/
259			/* */
260			/* INPUT */
261			/* */
262			/* command Pointer to storage command */
263			/* */
264			/* OUTPUT */
265			/* */
266			/* Completion Status */
267			/* */
268			/* CALLS */
269			/* */
270			/* _ux_device_class_storage_initialize Initialize storage instance */
271			/* */
272			/* CALLED BY */
273			/* */
274			/* Application */
275			/* */
276			/* RELEASE HISTORY */
277			/* */
278			/* DATE NAME DESCRIPTION */
279			/* */
280			/* 10-31-2023 Chaoqiong Xiao Initial Version 6.3.0 */
281			/* */
282			/**************************************************************************/
283			UINT _uxe_device_class_storage_initialize(UX_SLAVE_CLASS_COMMAND *command)
284			{
285
286			UX_SLAVE_CLASS_STORAGE_PARAMETER *storage_parameter;
287			UINT i;
288
289			/* Get the pointer to the application parameters for the storage class. */
290			storage_parameter = command -> ux_slave_class_command_parameter;
291
292			/* Sanity checks. */
293			if (storage_parameter -> ux_slave_class_storage_parameter_number_lun > UX_MAX_SLAVE_LUN)
294			return(UX_INVALID_PARAMETER);
295			for (i = 0; i < storage_parameter -> ux_slave_class_storage_parameter_number_lun; i ++)
296			{
297			if ((storage_parameter -> ux_slave_class_storage_parameter_lun[i].
298			ux_slave_class_storage_media_read == UX_NULL) \|\|
299			(storage_parameter -> ux_slave_class_storage_parameter_lun[i].
300			ux_slave_class_storage_media_write == UX_NULL) \|\|
301			(storage_parameter -> ux_slave_class_storage_parameter_lun[i].
302			ux_slave_class_storage_media_status == UX_NULL)
303			#if defined(UX_SLAVE_CLASS_STORAGE_INCLUDE_MMC)
304			\|\| (storage_parameter -> ux_slave_class_storage_parameter_lun[i].
305			ux_slave_class_storage_media_notification == UX_NULL)
306			#endif
307			)
308			{
309			return(UX_INVALID_PARAMETER);
310			}
311			}
312
313			/* Invoke storage initialize function. */
314			return(_ux_device_class_storage_initialize(command));
315			}