1 /*
2 * This file is part of the flashrom project.
3 *
4 * Copyright 2021 Google LLC
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; version 2 of the License.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 */
15
16 #include "lifecycle.h"
17
18 #if CONFIG_RAIDEN_DEBUG_SPI == 1
raiden_debug_libusb_get_device_list(void * state,libusb_context * ctx,libusb_device *** list)19 static ssize_t raiden_debug_libusb_get_device_list(void *state, libusb_context *ctx, libusb_device ***list)
20 {
21 *list = calloc(1, sizeof(**list));
22 assert_non_null(*list);
23
24 /*
25 * libusb_device is opaque type, it is tossed around between libusb functions but always
26 * stays opaque to the caller.
27 * Given that all libusb functions are mocked in tests, and raiden_debug test is mocking
28 * only one device, we don't need to initialise libusb_device.
29 */
30 return 1;
31 }
32
raiden_debug_libusb_free_device_list(void * state,libusb_device ** list,int unref_devices)33 static void raiden_debug_libusb_free_device_list(void *state, libusb_device **list, int unref_devices)
34 {
35 free(list);
36 }
37
raiden_debug_libusb_get_device_descriptor(void * state,libusb_device * dev,struct libusb_device_descriptor * desc)38 static int raiden_debug_libusb_get_device_descriptor(
39 void *state, libusb_device *dev, struct libusb_device_descriptor *desc)
40 {
41 desc->idVendor = 0x18D1; /* GOOGLE_VID */
42 desc->idProduct = 0;
43 desc->bNumConfigurations = 1;
44
45 return 0;
46 }
47
raiden_debug_libusb_get_config_descriptor(void * state,libusb_device * dev,uint8_t config_index,struct libusb_config_descriptor ** config)48 static int raiden_debug_libusb_get_config_descriptor(
49 void *state, libusb_device *dev, uint8_t config_index, struct libusb_config_descriptor **config)
50 {
51 *config = calloc(1, sizeof(**config));
52 assert_non_null(*config);
53
54 struct libusb_endpoint_descriptor *tmp_endpoint = calloc(2, sizeof(*tmp_endpoint));
55 assert_non_null(tmp_endpoint);
56 struct libusb_interface_descriptor *tmp_interface_desc = calloc(1, sizeof(*tmp_interface_desc));
57 assert_non_null(tmp_interface_desc);
58 struct libusb_interface *tmp_interface = calloc(1, sizeof(*tmp_interface));
59 assert_non_null(tmp_interface);
60
61 /* in endpoint */
62 tmp_endpoint[0].bEndpointAddress = 0x80;
63 tmp_endpoint[0].bmAttributes = 0x2;
64 /* out endpoint */
65 tmp_endpoint[1].bEndpointAddress = 0x0;
66 tmp_endpoint[1].bmAttributes = 0x2;
67
68 tmp_interface_desc->bInterfaceClass = 0xff; /* LIBUSB_CLASS_VENDOR_SPEC */
69 tmp_interface_desc->bInterfaceSubClass = 0x51; /* GOOGLE_RAIDEN_SPI_SUBCLASS */
70 tmp_interface_desc->bInterfaceProtocol = 0x01; /* GOOGLE_RAIDEN_SPI_PROTOCOL_V1 */
71 tmp_interface_desc->bNumEndpoints = 2; /* in_endpoint and out_endpoint */
72 tmp_interface_desc->endpoint = tmp_endpoint;
73
74 tmp_interface->num_altsetting = 1;
75 tmp_interface->altsetting = tmp_interface_desc;
76
77 (*config)->bConfigurationValue = 0;
78 (*config)->bNumInterfaces = 1;
79 (*config)->interface = tmp_interface;
80
81 return 0;
82 }
83
raiden_debug_libusb_free_config_descriptor(void * state,struct libusb_config_descriptor * config)84 static void raiden_debug_libusb_free_config_descriptor(void *state, struct libusb_config_descriptor *config)
85 {
86 free((void *)config->interface->altsetting->endpoint);
87 free((void *)config->interface->altsetting);
88 free((void *)config->interface);
89 free(config);
90 }
91
raiden_debug_basic_lifecycle_test_success(void ** state)92 void raiden_debug_basic_lifecycle_test_success(void **state)
93 {
94 struct io_mock_fallback_open_state raiden_debug_fallback_open_state = {
95 .noc = 0,
96 .paths = { LOCK_FILE },
97 };
98 const struct io_mock raiden_debug_io = {
99 .libusb_get_device_list = raiden_debug_libusb_get_device_list,
100 .libusb_free_device_list = raiden_debug_libusb_free_device_list,
101 .libusb_get_device_descriptor = raiden_debug_libusb_get_device_descriptor,
102 .libusb_get_config_descriptor = raiden_debug_libusb_get_config_descriptor,
103 .libusb_free_config_descriptor = raiden_debug_libusb_free_config_descriptor,
104 .fallback_open_state = &raiden_debug_fallback_open_state,
105 };
106
107 char raiden_debug_param[32];
108
109 snprintf(raiden_debug_param, sizeof(raiden_debug_param),
110 "address=%d", USB_DEVICE_ADDRESS);
111 run_basic_lifecycle(state, &raiden_debug_io, &programmer_raiden_debug_spi, raiden_debug_param);
112 }
113
raiden_debug_targetAP_basic_lifecycle_test_success(void ** state)114 void raiden_debug_targetAP_basic_lifecycle_test_success(void **state)
115 {
116 struct io_mock_fallback_open_state raiden_debug_fallback_open_state = {
117 .noc = 0,
118 .paths = { LOCK_FILE },
119 };
120 const struct io_mock raiden_debug_io = {
121 .libusb_get_device_list = raiden_debug_libusb_get_device_list,
122 .libusb_free_device_list = raiden_debug_libusb_free_device_list,
123 .libusb_get_device_descriptor = raiden_debug_libusb_get_device_descriptor,
124 .libusb_get_config_descriptor = raiden_debug_libusb_get_config_descriptor,
125 .libusb_free_config_descriptor = raiden_debug_libusb_free_config_descriptor,
126 .fallback_open_state = &raiden_debug_fallback_open_state,
127 };
128
129 char raiden_debug_param[32];
130 snprintf(raiden_debug_param, sizeof(raiden_debug_param),
131 "address=%d,target=AP", USB_DEVICE_ADDRESS);
132 run_basic_lifecycle(state, &raiden_debug_io, &programmer_raiden_debug_spi, raiden_debug_param);
133 }
134
raiden_debug_targetEC_basic_lifecycle_test_success(void ** state)135 void raiden_debug_targetEC_basic_lifecycle_test_success(void **state)
136 {
137 struct io_mock_fallback_open_state raiden_debug_fallback_open_state = {
138 .noc = 0,
139 .paths = { LOCK_FILE },
140 };
141 const struct io_mock raiden_debug_io = {
142 .libusb_get_device_list = raiden_debug_libusb_get_device_list,
143 .libusb_free_device_list = raiden_debug_libusb_free_device_list,
144 .libusb_get_device_descriptor = raiden_debug_libusb_get_device_descriptor,
145 .libusb_get_config_descriptor = raiden_debug_libusb_get_config_descriptor,
146 .libusb_free_config_descriptor = raiden_debug_libusb_free_config_descriptor,
147 .fallback_open_state = &raiden_debug_fallback_open_state,
148 };
149
150 char raiden_debug_param[32];
151 snprintf(raiden_debug_param, sizeof(raiden_debug_param),
152 "address=%d,target=ec", USB_DEVICE_ADDRESS);
153 run_basic_lifecycle(state, &raiden_debug_io, &programmer_raiden_debug_spi, raiden_debug_param);
154 }
155
raiden_debug_target0_basic_lifecycle_test_success(void ** state)156 void raiden_debug_target0_basic_lifecycle_test_success(void **state)
157 {
158 struct io_mock_fallback_open_state raiden_debug_fallback_open_state = {
159 .noc = 0,
160 .paths = { LOCK_FILE },
161 };
162 const struct io_mock raiden_debug_io = {
163 .libusb_get_device_list = raiden_debug_libusb_get_device_list,
164 .libusb_free_device_list = raiden_debug_libusb_free_device_list,
165 .libusb_get_device_descriptor = raiden_debug_libusb_get_device_descriptor,
166 .libusb_get_config_descriptor = raiden_debug_libusb_get_config_descriptor,
167 .libusb_free_config_descriptor = raiden_debug_libusb_free_config_descriptor,
168 .fallback_open_state = &raiden_debug_fallback_open_state,
169 };
170
171 char raiden_debug_param[32];
172 snprintf(raiden_debug_param, sizeof(raiden_debug_param),
173 "address=%d,target=0", USB_DEVICE_ADDRESS);
174 run_basic_lifecycle(state, &raiden_debug_io, &programmer_raiden_debug_spi, raiden_debug_param);
175 }
176
raiden_debug_target1_basic_lifecycle_test_success(void ** state)177 void raiden_debug_target1_basic_lifecycle_test_success(void **state)
178 {
179 struct io_mock_fallback_open_state raiden_debug_fallback_open_state = {
180 .noc = 0,
181 .paths = { LOCK_FILE },
182 };
183 const struct io_mock raiden_debug_io = {
184 .libusb_get_device_list = raiden_debug_libusb_get_device_list,
185 .libusb_free_device_list = raiden_debug_libusb_free_device_list,
186 .libusb_get_device_descriptor = raiden_debug_libusb_get_device_descriptor,
187 .libusb_get_config_descriptor = raiden_debug_libusb_get_config_descriptor,
188 .libusb_free_config_descriptor = raiden_debug_libusb_free_config_descriptor,
189 .fallback_open_state = &raiden_debug_fallback_open_state,
190 };
191
192 char raiden_debug_param[32];
193 snprintf(raiden_debug_param, sizeof(raiden_debug_param),
194 "address=%d,target=1", USB_DEVICE_ADDRESS);
195 run_basic_lifecycle(state, &raiden_debug_io, &programmer_raiden_debug_spi, raiden_debug_param);
196 }
197 #else
198 SKIP_TEST(raiden_debug_basic_lifecycle_test_success)
199 SKIP_TEST(raiden_debug_targetAP_basic_lifecycle_test_success)
200 SKIP_TEST(raiden_debug_targetEC_basic_lifecycle_test_success)
201 SKIP_TEST(raiden_debug_target0_basic_lifecycle_test_success)
202 SKIP_TEST(raiden_debug_target1_basic_lifecycle_test_success)
203 #endif /* CONFIG_RAIDEN_DEBUG_SPI */
204