]> git.proxmox.com Git - mirror_ubuntu-zesty-kernel.git/blob - drivers/staging/westbridge/astoria/api/src/cyasusb.c
projects / mirror_ubuntu-zesty-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'fix/asoc' into for-linus
[mirror_ubuntu-zesty-kernel.git] / drivers / staging / westbridge / astoria / api / src / cyasusb.c
1 /* Cypress West Bridge API source file (cyasusb.c)
2 ## ===========================
3 ## Copyright (C) 2010 Cypress Semiconductor
4 ##
5 ## This program is free software; you can redistribute it and/or
6 ## modify it under the terms of the GNU General Public License
7 ## as published by the Free Software Foundation; either version 2
8 ## of the License, or (at your option) any later version.
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 ## You should have received a copy of the GNU General Public License
16 ## along with this program; if not, write to the Free Software
17 ## Foundation, Inc., 51 Franklin Street, Fifth Floor
18 ## Boston, MA 02110-1301, USA.
19 ## ===========================
20 */
21
22 #include "../../include/linux/westbridge/cyashal.h"
23 #include "../../include/linux/westbridge/cyasusb.h"
24 #include "../../include/linux/westbridge/cyaserr.h"
25 #include "../../include/linux/westbridge/cyasdma.h"
26 #include "../../include/linux/westbridge/cyaslowlevel.h"
27 #include "../../include/linux/westbridge/cyaslep2pep.h"
28 #include "../../include/linux/westbridge/cyasregs.h"
29 #include "../../include/linux/westbridge/cyasstorage.h"
30
31 static cy_as_return_status_t
32 cy_as_usb_ack_setup_packet(
33 /* Handle to the West Bridge device */
34 cy_as_device_handle handle,
35 /* The callback if async call */
36 cy_as_function_callback cb,
37 /* Client supplied data */
38 uint32_t client
39 );
40
41 static void
42 cy_as_usb_func_callback(
43 cy_as_device *dev_p,
44 uint8_t context,
45 cy_as_ll_request_response *rqt,
46 cy_as_ll_request_response *resp,
47 cy_as_return_status_t ret);
48 /*
49 * Reset the USB EP0 state
50 */
51 static void
52 cy_as_usb_reset_e_p0_state(cy_as_device *dev_p)
53 {
54 cy_as_log_debug_message(6, "cy_as_usb_reset_e_p0_state called");
55
56 cy_as_device_clear_ack_delayed(dev_p);
57 cy_as_device_clear_setup_packet(dev_p);
58 if (cy_as_device_is_usb_async_pending(dev_p, 0))
59 cy_as_usb_cancel_async((cy_as_device_handle)dev_p, 0);
60
61 dev_p->usb_pending_buffer = 0;
62 }
63
64 /*
65 * External function to map logical endpoints to physical endpoints
66 */
67 static cy_as_return_status_t
68 is_usb_active(cy_as_device *dev_p)
69 {
70 if (!cy_as_device_is_configured(dev_p))
71 return CY_AS_ERROR_NOT_CONFIGURED;
72
73 if (!cy_as_device_is_firmware_loaded(dev_p))
74 return CY_AS_ERROR_NO_FIRMWARE;
75
76 if (dev_p->usb_count == 0)
77 return CY_AS_ERROR_NOT_RUNNING;
78
79 if (cy_as_device_is_in_suspend_mode(dev_p))
80 return CY_AS_ERROR_IN_SUSPEND;
81
82 return CY_AS_ERROR_SUCCESS;
83 }
84
85 static void
86 usb_ack_callback(cy_as_device_handle h,
87 cy_as_return_status_t status,
88 uint32_t client,
89 cy_as_funct_c_b_type type,
90 void *data)
91 {
92 cy_as_device *dev_p = (cy_as_device *)h;
93
94 (void)client;
95 (void)status;
96 (void)data;
97
98 cy_as_hal_assert(type == CY_FUNCT_CB_NODATA);
99
100 if (dev_p->usb_pending_buffer) {
101 cy_as_usb_io_callback cb;
102
103 cb = dev_p->usb_cb[0];
104 dev_p->usb_cb[0] = 0;
105 cy_as_device_clear_usb_async_pending(dev_p, 0);
106 if (cb)
107 cb(h, 0, dev_p->usb_pending_size,
108 dev_p->usb_pending_buffer, dev_p->usb_error);
109
110 dev_p->usb_pending_buffer = 0;
111 }
112
113 cy_as_device_clear_setup_packet(dev_p);
114 }
115
116 static void
117 my_usb_request_callback_usb_event(cy_as_device *dev_p,
118 cy_as_ll_request_response *req_p)
119 {
120 uint16_t ev;
121 uint16_t val;
122 cy_as_device_handle h = (cy_as_device_handle)dev_p;
123
124 ev = cy_as_ll_request_response__get_word(req_p, 0);
125 switch (ev) {
126 case 0: /* Reserved */
127 cy_as_ll_send_status_response(dev_p, CY_RQT_USB_RQT_CONTEXT,
128 CY_AS_ERROR_INVALID_REQUEST, 0);
129 break;
130
131 case 1: /* Reserved */
132 cy_as_ll_send_status_response(dev_p, CY_RQT_USB_RQT_CONTEXT,
133 CY_AS_ERROR_INVALID_REQUEST, 0);
134 break;
135
136 case 2: /* USB Suspend */
137 dev_p->usb_last_event = cy_as_event_usb_suspend;
138 if (dev_p->usb_event_cb_ms)
139 dev_p->usb_event_cb_ms(h, cy_as_event_usb_suspend, 0);
140 else if (dev_p->usb_event_cb)
141 dev_p->usb_event_cb(h, cy_as_event_usb_suspend, 0);
142 cy_as_ll_send_status_response(dev_p,
143 CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0);
144 break;
145
146 case 3: /* USB Resume */
147 dev_p->usb_last_event = cy_as_event_usb_resume;
148 if (dev_p->usb_event_cb_ms)
149 dev_p->usb_event_cb_ms(h, cy_as_event_usb_resume, 0);
150 else if (dev_p->usb_event_cb)
151 dev_p->usb_event_cb(h, cy_as_event_usb_resume, 0);
152 cy_as_ll_send_status_response(dev_p,
153 CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0);
154 break;
155
156 case 4: /* USB Reset */
157 /*
158 * if we get a USB reset, the USB host did not understand
159 * our response or we timed out for some reason. reset
160 * our internal state to be ready for another set of
161 * enumeration based requests.
162 */
163 if (cy_as_device_is_ack_delayed(dev_p))
164 cy_as_usb_reset_e_p0_state(dev_p);
165
166 dev_p->usb_last_event = cy_as_event_usb_reset;
167 if (dev_p->usb_event_cb_ms)
168 dev_p->usb_event_cb_ms(h, cy_as_event_usb_reset, 0);
169 else if (dev_p->usb_event_cb)
170 dev_p->usb_event_cb(h, cy_as_event_usb_reset, 0);
171
172 cy_as_ll_send_status_response(dev_p,
173 CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0);
174 cy_as_device_clear_usb_high_speed(dev_p);
175 cy_as_usb_set_dma_sizes(dev_p);
176 dev_p->usb_max_tx_size = 0x40;
177 cy_as_dma_set_max_dma_size(dev_p, 0x06, 0x40);
178 break;
179
180 case 5: /* USB Set Configuration */
181 /* The configuration to set */
182 val = cy_as_ll_request_response__get_word(req_p, 1);
183 dev_p->usb_last_event = cy_as_event_usb_set_config;
184 if (dev_p->usb_event_cb_ms)
185 dev_p->usb_event_cb_ms(h,
186 cy_as_event_usb_set_config, &val);
187 else if (dev_p->usb_event_cb)
188 dev_p->usb_event_cb(h,
189 cy_as_event_usb_set_config, &val);
190
191 cy_as_ll_send_status_response(dev_p,
192 CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0);
193 break;
194
195 case 6: /* USB Speed change */
196 /* Connect speed */
197 val = cy_as_ll_request_response__get_word(req_p, 1);
198 dev_p->usb_last_event = cy_as_event_usb_speed_change;
199 if (dev_p->usb_event_cb_ms)
200 dev_p->usb_event_cb_ms(h,
201 cy_as_event_usb_speed_change, &val);
202 else if (dev_p->usb_event_cb)
203 dev_p->usb_event_cb(h,
204 cy_as_event_usb_speed_change, &val);
205
206 cy_as_ll_send_status_response(dev_p,
207 CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0);
208 cy_as_device_set_usb_high_speed(dev_p);
209 cy_as_usb_set_dma_sizes(dev_p);
210 dev_p->usb_max_tx_size = 0x200;
211 cy_as_dma_set_max_dma_size(dev_p, 0x06, 0x200);
212 break;
213
214 case 7: /* USB Clear Feature */
215 /* EP Number */
216 val = cy_as_ll_request_response__get_word(req_p, 1);
217 if (dev_p->usb_event_cb_ms)
218 dev_p->usb_event_cb_ms(h,
219 cy_as_event_usb_clear_feature, &val);
220 if (dev_p->usb_event_cb)
221 dev_p->usb_event_cb(h,
222 cy_as_event_usb_clear_feature, &val);
223
224 cy_as_ll_send_status_response(dev_p,
225 CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0);
226 break;
227
228 default:
229 cy_as_hal_print_message("invalid event type\n");
230 cy_as_ll_send_data_response(dev_p, CY_RQT_USB_RQT_CONTEXT,
231 CY_RESP_USB_INVALID_EVENT, sizeof(ev), &ev);
232 break;
233 }
234 }
235
236 static void
237 my_usb_request_callback_usb_data(cy_as_device *dev_p,
238 cy_as_ll_request_response *req_p)
239 {
240 cy_as_end_point_number_t ep;
241 uint8_t type;
242 uint16_t len;
243 uint16_t val;
244 cy_as_device_handle h = (cy_as_device_handle)dev_p;
245
246 val = cy_as_ll_request_response__get_word(req_p, 0);
247 ep = (cy_as_end_point_number_t)((val >> 13) & 0x01);
248 len = (val & 0x1ff);
249
250 cy_as_hal_assert(len <= 64);
251 cy_as_ll_request_response__unpack(req_p,
252 1, len, dev_p->usb_ep_data);
253
254 type = (uint8_t)((val >> 14) & 0x03);
255 if (type == 0) {
256 if (cy_as_device_is_ack_delayed(dev_p)) {
257 /*
258 * A setup packet has arrived while we are
259 * processing a previous setup packet. reset
260 * our state with respect to EP0 to be ready
261 * to process the new packet.
262 */
263 cy_as_usb_reset_e_p0_state(dev_p);
264 }
265
266 if (len != 8)
267 cy_as_ll_send_status_response(dev_p,
268 CY_RQT_USB_RQT_CONTEXT,
269 CY_AS_ERROR_INVALID_REQUEST, 0);
270 else {
271 cy_as_device_clear_ep0_stalled(dev_p);
272 cy_as_device_set_setup_packet(dev_p);
273 cy_as_ll_send_status_response(dev_p,
274 CY_RQT_USB_RQT_CONTEXT,
275 CY_AS_ERROR_SUCCESS, 0);
276
277 if (dev_p->usb_event_cb_ms)
278 dev_p->usb_event_cb_ms(h,
279 cy_as_event_usb_setup_packet,
280 dev_p->usb_ep_data);
281 else
282 dev_p->usb_event_cb(h,
283 cy_as_event_usb_setup_packet,
284 dev_p->usb_ep_data);
285
286 if ((!cy_as_device_is_ack_delayed(dev_p)) &&
287 (!cy_as_device_is_ep0_stalled(dev_p)))
288 cy_as_usb_ack_setup_packet(h,
289 usb_ack_callback, 0);
290 }
291 } else if (type == 2) {
292 if (len != 0)
293 cy_as_ll_send_status_response(dev_p,
294 CY_RQT_USB_RQT_CONTEXT,
295 CY_AS_ERROR_INVALID_REQUEST, 0);
296 else {
297 if (dev_p->usb_event_cb_ms)
298 dev_p->usb_event_cb_ms(h,
299 cy_as_event_usb_status_packet, 0);
300 else
301 dev_p->usb_event_cb(h,
302 cy_as_event_usb_status_packet, 0);
303
304 cy_as_ll_send_status_response(dev_p,
305 CY_RQT_USB_RQT_CONTEXT,
306 CY_AS_ERROR_SUCCESS, 0);
307 }
308 } else if (type == 1) {
309 /*
310 * we need to hand the data associated with these
311 * endpoints to the DMA module.
312 */
313 cy_as_dma_received_data(dev_p, ep, len, dev_p->usb_ep_data);
314 cy_as_ll_send_status_response(dev_p,
315 CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0);
316 }
317 }
318
319 static void
320 my_usb_request_callback_inquiry(cy_as_device *dev_p,
321 cy_as_ll_request_response *req_p)
322 {
323 cy_as_usb_inquiry_data_dep cbdata;
324 cy_as_usb_inquiry_data cbdata_ms;
325 void *data;
326 uint16_t val;
327 cy_as_device_handle h = (cy_as_device_handle)dev_p;
328 uint8_t def_inq_data[64];
329 uint8_t evpd;
330 uint8_t codepage;
331 cy_bool updated;
332 uint16_t length;
333
334 cy_as_bus_number_t bus;
335 uint32_t device;
336 cy_as_media_type media;
337
338 val = cy_as_ll_request_response__get_word(req_p, 0);
339 bus = cy_as_storage_get_bus_from_address(val);
340 device = cy_as_storage_get_device_from_address(val);
341 media = cy_as_storage_get_media_from_address(val);
342
343 val = cy_as_ll_request_response__get_word(req_p, 1);
344 evpd = (uint8_t)((val >> 8) & 0x01);
345 codepage = (uint8_t)(val & 0xff);
346
347 length = cy_as_ll_request_response__get_word(req_p, 2);
348 data = (void *)def_inq_data;
349
350 updated = cy_false;
351
352 if (dev_p->usb_event_cb_ms) {
353 cbdata_ms.bus = bus;
354 cbdata_ms.device = device;
355 cbdata_ms.updated = updated;
356 cbdata_ms.evpd = evpd;
357 cbdata_ms.codepage = codepage;
358 cbdata_ms.length = length;
359 cbdata_ms.data = data;
360
361 cy_as_hal_assert(cbdata_ms.length <= sizeof(def_inq_data));
362 cy_as_ll_request_response__unpack(req_p,
363 3, cbdata_ms.length, cbdata_ms.data);
364
365 dev_p->usb_event_cb_ms(h,
366 cy_as_event_usb_inquiry_before, &cbdata_ms);
367
368 updated = cbdata_ms.updated;
369 data = cbdata_ms.data;
370 length = cbdata_ms.length;
371 } else if (dev_p->usb_event_cb) {
372 cbdata.media = media;
373 cbdata.updated = updated;
374 cbdata.evpd = evpd;
375 cbdata.codepage = codepage;
376 cbdata.length = length;
377 cbdata.data = data;
378
379 cy_as_hal_assert(cbdata.length <=
380 sizeof(def_inq_data));
381 cy_as_ll_request_response__unpack(req_p, 3,
382 cbdata.length, cbdata.data);
383
384 dev_p->usb_event_cb(h,
385 cy_as_event_usb_inquiry_before, &cbdata);
386
387 updated = cbdata.updated;
388 data = cbdata.data;
389 length = cbdata.length;
390 }
391
392 if (updated && length > 192)
393 cy_as_hal_print_message("an inquiry result from a "
394 "cy_as_event_usb_inquiry_before event "
395 "was greater than 192 bytes.");
396
397 /* Now send the reply with the data back
398 * to the West Bridge device */
399 if (updated && length <= 192) {
400 /*
401 * the callback function modified the inquiry
402 * data, ship the data back to the west bridge firmware.
403 */
404 cy_as_ll_send_data_response(dev_p,
405 CY_RQT_USB_RQT_CONTEXT,
406 CY_RESP_INQUIRY_DATA, length, data);
407 } else {
408 /*
409 * the callback did not modify the data, just acknowledge
410 * that we processed the request
411 */
412 cy_as_ll_send_status_response(dev_p,
413 CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 1);
414 }
415
416 if (dev_p->usb_event_cb_ms)
417 dev_p->usb_event_cb_ms(h,
418 cy_as_event_usb_inquiry_after, &cbdata_ms);
419 else if (dev_p->usb_event_cb)
420 dev_p->usb_event_cb(h,
421 cy_as_event_usb_inquiry_after, &cbdata);
422 }
423
424 static void
425 my_usb_request_callback_start_stop(cy_as_device *dev_p,
426 cy_as_ll_request_response *req_p)
427 {
428 cy_as_bus_number_t bus;
429 cy_as_media_type media;
430 uint32_t device;
431 uint16_t val;
432
433 if (dev_p->usb_event_cb_ms || dev_p->usb_event_cb) {
434 cy_bool loej;
435 cy_bool start;
436 cy_as_device_handle h = (cy_as_device_handle)dev_p;
437
438 val = cy_as_ll_request_response__get_word(req_p, 0);
439 bus = cy_as_storage_get_bus_from_address(val);
440 device = cy_as_storage_get_device_from_address(val);
441 media = cy_as_storage_get_media_from_address(val);
442
443 val = cy_as_ll_request_response__get_word(req_p, 1);
444 loej = (val & 0x02) ? cy_true : cy_false;
445 start = (val & 0x01) ? cy_true : cy_false;
446
447 if (dev_p->usb_event_cb_ms) {
448 cy_as_usb_start_stop_data cbdata_ms;
449
450 cbdata_ms.bus = bus;
451 cbdata_ms.device = device;
452 cbdata_ms.loej = loej;
453 cbdata_ms.start = start;
454 dev_p->usb_event_cb_ms(h,
455 cy_as_event_usb_start_stop, &cbdata_ms);
456
457 } else if (dev_p->usb_event_cb) {
458 cy_as_usb_start_stop_data_dep cbdata;
459
460 cbdata.media = media;
461 cbdata.loej = loej;
462 cbdata.start = start;
463 dev_p->usb_event_cb(h,
464 cy_as_event_usb_start_stop, &cbdata);
465 }
466 }
467 cy_as_ll_send_status_response(dev_p,
468 CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 1);
469 }
470
471 static void
472 my_usb_request_callback_uknown_c_b_w(cy_as_device *dev_p,
473 cy_as_ll_request_response *req_p)
474 {
475 uint16_t val;
476 cy_as_device_handle h = (cy_as_device_handle)dev_p;
477 uint8_t buf[16];
478
479 uint8_t response[4];
480 uint16_t reqlen;
481 void *request;
482 uint8_t status;
483 uint8_t key;
484 uint8_t asc;
485 uint8_t ascq;
486
487 val = cy_as_ll_request_response__get_word(req_p, 0);
488 /* Failed by default */
489 status = 1;
490 /* Invalid command */
491 key = 0x05;
492 /* Invalid command */
493 asc = 0x20;
494 /* Invalid command */
495 ascq = 0x00;
496 reqlen = cy_as_ll_request_response__get_word(req_p, 1);
497 request = buf;
498
499 cy_as_hal_assert(reqlen <= sizeof(buf));
500 cy_as_ll_request_response__unpack(req_p, 2, reqlen, request);
501
502 if (dev_p->usb_event_cb_ms) {
503 cy_as_usb_unknown_command_data cbdata_ms;
504 cbdata_ms.bus = cy_as_storage_get_bus_from_address(val);
505 cbdata_ms.device =
506 cy_as_storage_get_device_from_address(val);
507 cbdata_ms.reqlen = reqlen;
508 cbdata_ms.request = request;
509 cbdata_ms.status = status;
510 cbdata_ms.key = key;
511 cbdata_ms.asc = asc;
512 cbdata_ms.ascq = ascq;
513
514 dev_p->usb_event_cb_ms(h,
515 cy_as_event_usb_unknown_storage, &cbdata_ms);
516 status = cbdata_ms.status;
517 key = cbdata_ms.key;
518 asc = cbdata_ms.asc;
519 ascq = cbdata_ms.ascq;
520 } else if (dev_p->usb_event_cb) {
521 cy_as_usb_unknown_command_data_dep cbdata;
522 cbdata.media =
523 cy_as_storage_get_media_from_address(val);
524 cbdata.reqlen = reqlen;
525 cbdata.request = request;
526 cbdata.status = status;
527 cbdata.key = key;
528 cbdata.asc = asc;
529 cbdata.ascq = ascq;
530
531 dev_p->usb_event_cb(h,
532 cy_as_event_usb_unknown_storage, &cbdata);
533 status = cbdata.status;
534 key = cbdata.key;
535 asc = cbdata.asc;
536 ascq = cbdata.ascq;
537 }
538
539 response[0] = status;
540 response[1] = key;
541 response[2] = asc;
542 response[3] = ascq;
543 cy_as_ll_send_data_response(dev_p, CY_RQT_USB_RQT_CONTEXT,
544 CY_RESP_UNKNOWN_SCSI_COMMAND, sizeof(response), response);
545 }
546
547 static void
548 my_usb_request_callback_m_s_c_progress(cy_as_device *dev_p,
549 cy_as_ll_request_response *req_p)
550 {
551 uint16_t val1, val2;
552 cy_as_device_handle h = (cy_as_device_handle)dev_p;
553
554 if ((dev_p->usb_event_cb) || (dev_p->usb_event_cb_ms)) {
555 cy_as_m_s_c_progress_data cbdata;
556
557 val1 = cy_as_ll_request_response__get_word(req_p, 0);
558 val2 = cy_as_ll_request_response__get_word(req_p, 1);
559 cbdata.wr_count = (uint32_t)((val1 << 16) | val2);
560
561 val1 = cy_as_ll_request_response__get_word(req_p, 2);
562 val2 = cy_as_ll_request_response__get_word(req_p, 3);
563 cbdata.rd_count = (uint32_t)((val1 << 16) | val2);
564
565 if (dev_p->usb_event_cb)
566 dev_p->usb_event_cb(h,
567 cy_as_event_usb_m_s_c_progress, &cbdata);
568 else
569 dev_p->usb_event_cb_ms(h,
570 cy_as_event_usb_m_s_c_progress, &cbdata);
571 }
572
573 cy_as_ll_send_status_response(dev_p,
574 CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0);
575 }
576
577 /*
578 * This function processes the requests delivered from the
579 * firmware within the West Bridge device that are delivered
580 * in the USB context. These requests generally are EP0 and
581 * EP1 related requests or USB events.
582 */
583 static void
584 my_usb_request_callback(cy_as_device *dev_p, uint8_t context,
585 cy_as_ll_request_response *req_p,
586 cy_as_ll_request_response *resp_p,
587 cy_as_return_status_t ret)
588 {
589 uint16_t val;
590 uint8_t code = cy_as_ll_request_response__get_code(req_p);
591
592 (void)resp_p;
593 (void)context;
594 (void)ret;
595
596 switch (code) {
597 case CY_RQT_USB_EVENT:
598 my_usb_request_callback_usb_event(dev_p, req_p);
599 break;
600
601 case CY_RQT_USB_EP_DATA:
602 dev_p->usb_last_event = cy_as_event_usb_setup_packet;
603 my_usb_request_callback_usb_data(dev_p, req_p);
604 break;
605
606 case CY_RQT_SCSI_INQUIRY_COMMAND:
607 dev_p->usb_last_event = cy_as_event_usb_inquiry_after;
608 my_usb_request_callback_inquiry(dev_p, req_p);
609 break;
610
611 case CY_RQT_SCSI_START_STOP_COMMAND:
612 dev_p->usb_last_event = cy_as_event_usb_start_stop;
613 my_usb_request_callback_start_stop(dev_p, req_p);
614 break;
615
616 case CY_RQT_SCSI_UNKNOWN_COMMAND:
617 dev_p->usb_last_event = cy_as_event_usb_unknown_storage;
618 my_usb_request_callback_uknown_c_b_w(dev_p, req_p);
619 break;
620
621 case CY_RQT_USB_ACTIVITY_UPDATE:
622 dev_p->usb_last_event = cy_as_event_usb_m_s_c_progress;
623 my_usb_request_callback_m_s_c_progress(dev_p, req_p);
624 break;
625
626 default:
627 cy_as_hal_print_message("invalid request "
628 "received on USB context\n");
629 val = req_p->box0;
630 cy_as_ll_send_data_response(dev_p, CY_RQT_USB_RQT_CONTEXT,
631 CY_RESP_INVALID_REQUEST, sizeof(val), &val);
632 break;
633 }
634 }
635
636 static cy_as_return_status_t
637 my_handle_response_usb_start(cy_as_device *dev_p,
638 cy_as_ll_request_response *req_p,
639 cy_as_ll_request_response *reply_p,
640 cy_as_return_status_t ret)
641 {
642 if (ret != CY_AS_ERROR_SUCCESS)
643 goto destroy;
644
645 if (cy_as_ll_request_response__get_code(reply_p) !=
646 CY_RESP_SUCCESS_FAILURE) {
647 ret = CY_AS_ERROR_INVALID_RESPONSE;
648 goto destroy;
649 }
650
651 ret = cy_as_ll_request_response__get_word(reply_p, 0);
652 if (ret != CY_AS_ERROR_SUCCESS)
653 goto destroy;
654
655 /*
656 * mark EP 0 and EP1 as 64 byte endpoints
657 */
658 cy_as_dma_set_max_dma_size(dev_p, 0, 64);
659 cy_as_dma_set_max_dma_size(dev_p, 1, 64);
660
661 dev_p->usb_count++;
662
663 destroy:
664 cy_as_ll_destroy_request(dev_p, req_p);
665 cy_as_ll_destroy_response(dev_p, reply_p);
666
667 if (ret != CY_AS_ERROR_SUCCESS) {
668 cy_as_destroy_c_b_queue(dev_p->usb_func_cbs);
669 cy_as_ll_register_request_callback(dev_p,
670 CY_RQT_USB_RQT_CONTEXT, 0);
671 }
672
673 cy_as_device_clear_u_s_s_pending(dev_p);
674
675 return ret;
676
677 }
678
679 /*
680 * This function starts the USB stack. The stack is reference
681 * counted so if the stack is already started, this function
682 * just increments the count. If the stack has not been started,
683 * a start request is sent to the West Bridge device.
684 *
685 * Note: Starting the USB stack does not cause the USB signals
686 * to be connected to the USB pins. To do this and therefore
687 * initiate enumeration, CyAsUsbConnect() must be called.
688 */
689 cy_as_return_status_t
690 cy_as_usb_start(cy_as_device_handle handle,
691 cy_as_function_callback cb,
692 uint32_t client)
693 {
694 cy_as_ll_request_response *req_p, *reply_p;
695 cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS;
696
697 cy_as_device *dev_p;
698
699 cy_as_log_debug_message(6, "cy_as_usb_start called");
700
701 dev_p = (cy_as_device *)handle;
702 if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
703 return CY_AS_ERROR_INVALID_HANDLE;
704
705 if (!cy_as_device_is_configured(dev_p))
706 return CY_AS_ERROR_NOT_CONFIGURED;
707
708 if (!cy_as_device_is_firmware_loaded(dev_p))
709 return CY_AS_ERROR_NO_FIRMWARE;
710
711 if (cy_as_device_is_in_suspend_mode(dev_p))
712 return CY_AS_ERROR_IN_SUSPEND;
713
714 if (cy_as_device_is_in_callback(dev_p))
715 return CY_AS_ERROR_INVALID_IN_CALLBACK;
716
717 if (cy_as_device_is_u_s_s_pending(dev_p))
718 return CY_AS_ERROR_STARTSTOP_PENDING;
719
720 cy_as_device_set_u_s_s_pending(dev_p);
721
722 if (dev_p->usb_count == 0) {
723 /*
724 * since we are just starting the stack,
725 * mark USB as not connected to the remote host
726 */
727 cy_as_device_clear_usb_connected(dev_p);
728 dev_p->usb_phy_config = 0;
729
730 /* Queue for 1.0 Async Requests, kept for
731 * backwards compatibility */
732 dev_p->usb_func_cbs = cy_as_create_c_b_queue(CYAS_USB_FUNC_CB);
733 if (dev_p->usb_func_cbs == 0) {
734 cy_as_device_clear_u_s_s_pending(dev_p);
735 return CY_AS_ERROR_OUT_OF_MEMORY;
736 }
737
738 /* Reset the EP0 state */
739 cy_as_usb_reset_e_p0_state(dev_p);
740
741 /*
742 * we register here becuase the start request may cause
743 * events to occur before the response to the start request.
744 */
745 cy_as_ll_register_request_callback(dev_p,
746 CY_RQT_USB_RQT_CONTEXT, my_usb_request_callback);
747
748 /* Create the request to send to the West Bridge device */
749 req_p = cy_as_ll_create_request(dev_p,
750 CY_RQT_START_USB, CY_RQT_USB_RQT_CONTEXT, 0);
751 if (req_p == 0) {
752 cy_as_destroy_c_b_queue(dev_p->usb_func_cbs);
753 dev_p->usb_func_cbs = 0;
754 cy_as_device_clear_u_s_s_pending(dev_p);
755 return CY_AS_ERROR_OUT_OF_MEMORY;
756 }
757
758 /* Reserve space for the reply, the reply data
759 * will not exceed one word */
760 reply_p = cy_as_ll_create_response(dev_p, 1);
761 if (reply_p == 0) {
762 cy_as_destroy_c_b_queue(dev_p->usb_func_cbs);
763 dev_p->usb_func_cbs = 0;
764 cy_as_ll_destroy_request(dev_p, req_p);
765 cy_as_device_clear_u_s_s_pending(dev_p);
766 return CY_AS_ERROR_OUT_OF_MEMORY;
767 }
768
769 if (cb == 0) {
770 ret = cy_as_ll_send_request_wait_reply(dev_p,
771 req_p, reply_p);
772 if (ret != CY_AS_ERROR_SUCCESS)
773 goto destroy;
774
775 return my_handle_response_usb_start(dev_p,
776 req_p, reply_p, ret);
777 } else {
778 ret = cy_as_misc_send_request(dev_p, cb,
779 client, CY_FUNCT_CB_USB_START, 0,
780 dev_p->func_cbs_usb,
781 CY_AS_REQUEST_RESPONSE_EX, req_p, reply_p,
782 cy_as_usb_func_callback);
783
784 if (ret != CY_AS_ERROR_SUCCESS)
785 goto destroy;
786
787 return ret;
788 }
789
790 destroy:
791 cy_as_ll_destroy_request(dev_p, req_p);
792 cy_as_ll_destroy_response(dev_p, reply_p);
793 } else {
794 dev_p->usb_count++;
795 if (cb)
796 cb(handle, ret, client, CY_FUNCT_CB_USB_START, 0);
797 }
798
799 cy_as_device_clear_u_s_s_pending(dev_p);
800
801 return ret;
802 }
803
804 void
805 cy_as_usb_reset(cy_as_device *dev_p)
806 {
807 int i;
808
809 cy_as_device_clear_usb_connected(dev_p);
810
811 for (i = 0; i < sizeof(dev_p->usb_config) /
812 sizeof(dev_p->usb_config[0]); i++) {
813 /*
814 * cancel all pending USB read/write operations, as it is
815 * possible that the USB stack comes up in a different
816 * configuration with a different set of endpoints.
817 */
818 if (cy_as_device_is_usb_async_pending(dev_p, i))
819 cy_as_usb_cancel_async(dev_p,
820 (cy_as_end_point_number_t)i);
821
822 dev_p->usb_cb[i] = 0;
823 dev_p->usb_config[i].enabled = cy_false;
824 }
825
826 dev_p->usb_phy_config = 0;
827 }
828
829 /*
830 * This function does all the API side clean-up associated
831 * with CyAsUsbStop, without any communication with firmware.
832 * This needs to be done when the device is being reset while
833 * the USB stack is active.
834 */
835 void
836 cy_as_usb_cleanup(cy_as_device *dev_p)
837 {
838 if (dev_p->usb_count) {
839 cy_as_usb_reset_e_p0_state(dev_p);
840 cy_as_usb_reset(dev_p);
841 cy_as_hal_mem_set(dev_p->usb_config, 0,
842 sizeof(dev_p->usb_config));
843 cy_as_destroy_c_b_queue(dev_p->usb_func_cbs);
844
845 dev_p->usb_count = 0;
846 }
847 }
848
849 static cy_as_return_status_t
850 my_handle_response_usb_stop(cy_as_device *dev_p,
851 cy_as_ll_request_response *req_p,
852 cy_as_ll_request_response *reply_p,
853 cy_as_return_status_t ret)
854 {
855 if (ret != CY_AS_ERROR_SUCCESS)
856 goto destroy;
857
858 if (cy_as_ll_request_response__get_code(reply_p) !=
859 CY_RESP_SUCCESS_FAILURE) {
860 ret = CY_AS_ERROR_INVALID_RESPONSE;
861 goto destroy;
862 }
863
864 ret = cy_as_ll_request_response__get_word(reply_p, 0);
865 if (ret != CY_AS_ERROR_SUCCESS)
866 goto destroy;
867
868 /*
869 * we sucessfully shutdown the stack, so
870 * decrement to make the count zero.
871 */
872 cy_as_usb_cleanup(dev_p);
873
874 destroy:
875 cy_as_ll_destroy_request(dev_p, req_p);
876 cy_as_ll_destroy_response(dev_p, reply_p);
877
878 if (ret != CY_AS_ERROR_SUCCESS)
879 cy_as_ll_register_request_callback(dev_p,
880 CY_RQT_USB_RQT_CONTEXT, 0);
881
882 cy_as_device_clear_u_s_s_pending(dev_p);
883
884 return ret;
885 }
886
887 /*
888 * This function stops the USB stack. The USB stack is reference
889 * counted so first is reference count is decremented. If the
890 * reference count is then zero, a request is sent to the West
891 * Bridge device to stop the USB stack on the West Bridge device.
892 */
893 cy_as_return_status_t
894 cy_as_usb_stop(cy_as_device_handle handle,
895 cy_as_function_callback cb,
896 uint32_t client)
897 {
898 cy_as_ll_request_response *req_p = 0, *reply_p = 0;
899 cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS;
900
901 cy_as_device *dev_p;
902
903 cy_as_log_debug_message(6, "cy_as_usb_stop called");
904
905 dev_p = (cy_as_device *)handle;
906 if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
907 return CY_AS_ERROR_INVALID_HANDLE;
908
909 ret = is_usb_active(dev_p);
910 if (ret != CY_AS_ERROR_SUCCESS)
911 return ret;
912
913 if (cy_as_device_is_usb_connected(dev_p))
914 return CY_AS_ERROR_USB_CONNECTED;
915
916 if (cy_as_device_is_in_callback(dev_p))
917 return CY_AS_ERROR_INVALID_IN_CALLBACK;
918
919 if (cy_as_device_is_u_s_s_pending(dev_p))
920 return CY_AS_ERROR_STARTSTOP_PENDING;
921
922 cy_as_device_set_u_s_s_pending(dev_p);
923
924 if (dev_p->usb_count == 1) {
925 /* Create the request to send to the West Bridge device */
926 req_p = cy_as_ll_create_request(dev_p, CY_RQT_STOP_USB,
927 CY_RQT_USB_RQT_CONTEXT, 0);
928 if (req_p == 0) {
929 ret = CY_AS_ERROR_OUT_OF_MEMORY;
930 goto destroy;
931 }
932
933 /* Reserve space for the reply, the reply data will not
934 * exceed one word */
935 reply_p = cy_as_ll_create_response(dev_p, 1);
936 if (reply_p == 0) {
937 ret = CY_AS_ERROR_OUT_OF_MEMORY;
938 goto destroy;
939 }
940
941 if (cb == 0) {
942 ret = cy_as_ll_send_request_wait_reply(dev_p,
943 req_p, reply_p);
944 if (ret != CY_AS_ERROR_SUCCESS)
945 goto destroy;
946
947 return my_handle_response_usb_stop(dev_p,
948 req_p, reply_p, ret);
949 } else {
950 ret = cy_as_misc_send_request(dev_p, cb, client,
951 CY_FUNCT_CB_USB_STOP, 0, dev_p->func_cbs_usb,
952 CY_AS_REQUEST_RESPONSE_EX, req_p, reply_p,
953 cy_as_usb_func_callback);
954
955 if (ret != CY_AS_ERROR_SUCCESS)
956 goto destroy;
957
958 return ret;
959 }
960
961 destroy:
962 cy_as_ll_destroy_request(dev_p, req_p);
963 cy_as_ll_destroy_response(dev_p, reply_p);
964 } else if (dev_p->usb_count > 1) {
965 /*
966 * reset all LE_ps to inactive state, after cleaning
967 * up any pending async read/write calls.
968 */
969 cy_as_usb_reset(dev_p);
970 dev_p->usb_count--;
971
972 if (cb)
973 cb(handle, ret, client, CY_FUNCT_CB_USB_STOP, 0);
974 }
975
976 cy_as_device_clear_u_s_s_pending(dev_p);
977
978 return ret;
979 }
980
981 /*
982 * This function registers a callback to be called when
983 * USB events are processed
984 */
985 cy_as_return_status_t
986 cy_as_usb_register_callback(cy_as_device_handle handle,
987 cy_as_usb_event_callback callback)
988 {
989 cy_as_device *dev_p;
990
991 cy_as_log_debug_message(6, "cy_as_usb_register_callback called");
992
993 dev_p = (cy_as_device *)handle;
994 if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
995 return CY_AS_ERROR_INVALID_HANDLE;
996
997 if (!cy_as_device_is_configured(dev_p))
998 return CY_AS_ERROR_NOT_CONFIGURED;
999
1000 if (!cy_as_device_is_firmware_loaded(dev_p))
1001 return CY_AS_ERROR_NO_FIRMWARE;
1002
1003 dev_p->usb_event_cb = NULL;
1004 dev_p->usb_event_cb_ms = callback;
1005 return CY_AS_ERROR_SUCCESS;
1006 }
1007
1008
1009 static cy_as_return_status_t
1010 my_handle_response_no_data(cy_as_device *dev_p,
1011 cy_as_ll_request_response *req_p,
1012 cy_as_ll_request_response *reply_p)
1013 {
1014 cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS;
1015
1016 if (cy_as_ll_request_response__get_code(reply_p) !=
1017 CY_RESP_SUCCESS_FAILURE)
1018 ret = CY_AS_ERROR_INVALID_RESPONSE;
1019 else
1020 ret = cy_as_ll_request_response__get_word(reply_p, 0);
1021
1022 cy_as_ll_destroy_request(dev_p, req_p);
1023 cy_as_ll_destroy_response(dev_p, reply_p);
1024
1025 return ret;
1026 }
1027
1028 static cy_as_return_status_t
1029 my_handle_response_connect(cy_as_device *dev_p,
1030 cy_as_ll_request_response *req_p,
1031 cy_as_ll_request_response *reply_p,
1032 cy_as_return_status_t ret)
1033 {
1034 if (ret != CY_AS_ERROR_SUCCESS)
1035 goto destroy;
1036
1037 if (cy_as_ll_request_response__get_code(reply_p) !=
1038 CY_RESP_SUCCESS_FAILURE) {
1039 ret = CY_AS_ERROR_INVALID_RESPONSE;
1040 goto destroy;
1041 }
1042
1043 ret = cy_as_ll_request_response__get_word(reply_p, 0);
1044 if (ret == CY_AS_ERROR_SUCCESS)
1045 cy_as_device_set_usb_connected(dev_p);
1046
1047 destroy:
1048 cy_as_ll_destroy_request(dev_p, req_p);
1049 cy_as_ll_destroy_response(dev_p, reply_p);
1050
1051 return ret;
1052 }
1053
1054
1055 /*
1056 * This method asks the West Bridge device to connect the
1057 * internal USB D+ and D- signals to the USB pins, thus
1058 * starting the enumeration processes if the external pins
1059 * are connnected to a USB host. If the external pins are
1060 * not connect to a USB host, enumeration will begin as soon
1061 * as the USB pins are connected to a host.
1062 */
1063 cy_as_return_status_t
1064 cy_as_usb_connect(cy_as_device_handle handle,
1065 cy_as_function_callback cb,
1066 uint32_t client)
1067 {
1068 cy_as_ll_request_response *req_p , *reply_p;
1069 cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS;
1070
1071 cy_as_device *dev_p;
1072
1073 cy_as_log_debug_message(6, "cy_as_usb_connect called");
1074
1075 dev_p = (cy_as_device *)handle;
1076 if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
1077 return CY_AS_ERROR_INVALID_HANDLE;
1078
1079 ret = is_usb_active(dev_p);
1080 if (ret != CY_AS_ERROR_SUCCESS)
1081 return ret;
1082
1083 if (cy_as_device_is_in_callback(dev_p))
1084 return CY_AS_ERROR_INVALID_IN_CALLBACK;
1085
1086 /* Create the request to send to the West Bridge device */
1087 req_p = cy_as_ll_create_request(dev_p,
1088 CY_RQT_SET_CONNECT_STATE, CY_RQT_USB_RQT_CONTEXT, 1);
1089 if (req_p == 0)
1090 return CY_AS_ERROR_OUT_OF_MEMORY;
1091
1092 /* 1 = Connect request */
1093 cy_as_ll_request_response__set_word(req_p, 0, 1);
1094
1095 /* Reserve space for the reply, the reply
1096 * data will not exceed one word */
1097 reply_p = cy_as_ll_create_response(dev_p, 1);
1098 if (reply_p == 0) {
1099 cy_as_ll_destroy_request(dev_p, req_p);
1100 return CY_AS_ERROR_OUT_OF_MEMORY;
1101 }
1102
1103 if (cb == 0) {
1104 ret = cy_as_ll_send_request_wait_reply(dev_p, req_p, reply_p);
1105 if (ret != CY_AS_ERROR_SUCCESS)
1106 goto destroy;
1107
1108 return my_handle_response_connect(dev_p, req_p, reply_p, ret);
1109 } else {
1110 ret = cy_as_misc_send_request(dev_p, cb, client,
1111 CY_FUNCT_CB_USB_CONNECT, 0, dev_p->func_cbs_usb,
1112 CY_AS_REQUEST_RESPONSE_EX, req_p, reply_p,
1113 cy_as_usb_func_callback);
1114
1115 if (ret != CY_AS_ERROR_SUCCESS)
1116 goto destroy;
1117
1118 return ret;
1119 }
1120
1121 destroy:
1122 cy_as_ll_destroy_request(dev_p, req_p);
1123 cy_as_ll_destroy_response(dev_p, reply_p);
1124
1125 return ret;
1126 }
1127
1128 static cy_as_return_status_t
1129 my_handle_response_disconnect(cy_as_device *dev_p,
1130 cy_as_ll_request_response *req_p,
1131 cy_as_ll_request_response *reply_p,
1132 cy_as_return_status_t ret)
1133 {
1134 if (ret != CY_AS_ERROR_SUCCESS)
1135 goto destroy;
1136
1137 if (cy_as_ll_request_response__get_code(reply_p) !=
1138 CY_RESP_SUCCESS_FAILURE) {
1139 ret = CY_AS_ERROR_INVALID_RESPONSE;
1140 goto destroy;
1141 }
1142
1143 ret = cy_as_ll_request_response__get_word(reply_p, 0);
1144 if (ret == CY_AS_ERROR_SUCCESS)
1145 cy_as_device_clear_usb_connected(dev_p);
1146
1147 destroy:
1148 cy_as_ll_destroy_request(dev_p, req_p);
1149 cy_as_ll_destroy_response(dev_p, reply_p);
1150
1151 return ret;
1152 }
1153 /*
1154 * This method forces a disconnect of the D+ and D- pins
1155 * external to the West Bridge device from the D+ and D-
1156 * signals internally, effectively disconnecting the West
1157 * Bridge device from any connected USB host.
1158 */
1159 cy_as_return_status_t
1160 cy_as_usb_disconnect(cy_as_device_handle handle,
1161 cy_as_function_callback cb,
1162 uint32_t client)
1163 {
1164 cy_as_ll_request_response *req_p , *reply_p;
1165 cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS;
1166
1167 cy_as_device *dev_p;
1168
1169 cy_as_log_debug_message(6, "cy_as_usb_disconnect called");
1170
1171 dev_p = (cy_as_device *)handle;
1172 if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
1173 return CY_AS_ERROR_INVALID_HANDLE;
1174
1175 ret = is_usb_active(dev_p);
1176 if (ret != CY_AS_ERROR_SUCCESS)
1177 return ret;
1178
1179 if (cy_as_device_is_in_callback(dev_p))
1180 return CY_AS_ERROR_INVALID_IN_CALLBACK;
1181
1182 if (!cy_as_device_is_usb_connected(dev_p))
1183 return CY_AS_ERROR_USB_NOT_CONNECTED;
1184
1185 /* Create the request to send to the West Bridge device */
1186 req_p = cy_as_ll_create_request(dev_p,
1187 CY_RQT_SET_CONNECT_STATE, CY_RQT_USB_RQT_CONTEXT, 1);
1188 if (req_p == 0)
1189 return CY_AS_ERROR_OUT_OF_MEMORY;
1190
1191 cy_as_ll_request_response__set_word(req_p, 0, 0);
1192
1193 /* Reserve space for the reply, the reply
1194 * data will not exceed two bytes */
1195 reply_p = cy_as_ll_create_response(dev_p, 1);
1196 if (reply_p == 0) {
1197 cy_as_ll_destroy_request(dev_p, req_p);
1198 return CY_AS_ERROR_OUT_OF_MEMORY;
1199 }
1200
1201 if (cb == 0) {
1202 ret = cy_as_ll_send_request_wait_reply(dev_p, req_p, reply_p);
1203 if (ret != CY_AS_ERROR_SUCCESS)
1204 goto destroy;
1205
1206 return my_handle_response_disconnect(dev_p,
1207 req_p, reply_p, ret);
1208 } else {
1209 ret = cy_as_misc_send_request(dev_p, cb, client,
1210 CY_FUNCT_CB_USB_DISCONNECT, 0, dev_p->func_cbs_usb,
1211 CY_AS_REQUEST_RESPONSE_EX, req_p, reply_p,
1212 cy_as_usb_func_callback);
1213
1214 if (ret != CY_AS_ERROR_SUCCESS)
1215 goto destroy;
1216
1217 return ret;
1218 }
1219 destroy:
1220 cy_as_ll_destroy_request(dev_p, req_p);
1221 cy_as_ll_destroy_response(dev_p, reply_p);
1222
1223 return ret;
1224 }
1225
1226 static cy_as_return_status_t
1227 my_handle_response_set_enum_config(cy_as_device *dev_p,
1228 cy_as_ll_request_response *req_p,
1229 cy_as_ll_request_response *reply_p)
1230 {
1231 cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS;
1232
1233 if (cy_as_ll_request_response__get_code(reply_p) !=
1234 CY_RESP_SUCCESS_FAILURE) {
1235 ret = CY_AS_ERROR_INVALID_RESPONSE;
1236 goto destroy;
1237 }
1238
1239 ret = cy_as_ll_request_response__get_word(reply_p, 0);
1240
1241 if (ret == CY_AS_ERROR_SUCCESS) {
1242 /*
1243 * we configured the west bridge device and
1244 * enumeration is going to happen on the P port
1245 * processor. now we must enable endpoint zero
1246 */
1247 cy_as_usb_end_point_config config;
1248
1249 config.dir = cy_as_usb_in_out;
1250 config.type = cy_as_usb_control;
1251 config.enabled = cy_true;
1252
1253 ret = cy_as_usb_set_end_point_config((cy_as_device_handle *)
1254 dev_p, 0, &config);
1255 }
1256
1257 destroy:
1258 cy_as_ll_destroy_request(dev_p, req_p);
1259 cy_as_ll_destroy_response(dev_p, reply_p);
1260
1261 return ret;
1262 }
1263
1264 /*
1265 * This method sets how the USB is enumerated and should
1266 * be called before the CyAsUsbConnect() is called.
1267 */
1268 static cy_as_return_status_t
1269 my_usb_set_enum_config(cy_as_device *dev_p,
1270 uint8_t bus_mask,
1271 uint8_t media_mask,
1272 cy_bool use_antioch_enumeration,
1273 uint8_t mass_storage_interface,
1274 uint8_t mtp_interface,
1275 cy_bool mass_storage_callbacks,
1276 cy_as_function_callback cb,
1277 uint32_t client)
1278 {
1279 cy_as_ll_request_response *req_p , *reply_p;
1280 cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS;
1281
1282 cy_as_log_debug_message(6, "cy_as_usb_set_enum_config called");
1283
1284 if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
1285 return CY_AS_ERROR_INVALID_HANDLE;
1286
1287 ret = is_usb_active(dev_p);
1288 if (ret != CY_AS_ERROR_SUCCESS)
1289 return ret;
1290
1291 if (cy_as_device_is_usb_connected(dev_p))
1292 return CY_AS_ERROR_USB_CONNECTED;
1293
1294 if (cy_as_device_is_in_callback(dev_p))
1295 return CY_AS_ERROR_INVALID_IN_CALLBACK;
1296
1297 /* if we are using MTP firmware: */
1298 if (dev_p->is_mtp_firmware == 1) {
1299 /* we cannot enumerate MSC */
1300 if (mass_storage_interface != 0)
1301 return CY_AS_ERROR_INVALID_CONFIGURATION;
1302
1303 if (bus_mask == 0) {
1304 if (mtp_interface != 0)
1305 return CY_AS_ERROR_INVALID_CONFIGURATION;
1306 } else if (bus_mask == 2) {
1307 /* enable EP 1 as it will be used */
1308 cy_as_dma_enable_end_point(dev_p, 1, cy_true,
1309 cy_as_direction_in);
1310 dev_p->usb_config[1].enabled = cy_true;
1311 dev_p->usb_config[1].dir = cy_as_usb_in;
1312 dev_p->usb_config[1].type = cy_as_usb_int;
1313 } else {
1314 return CY_AS_ERROR_INVALID_CONFIGURATION;
1315 }
1316 /* if we are not using MTP firmware, we cannot enumerate MTP */
1317 } else if (mtp_interface != 0)
1318 return CY_AS_ERROR_INVALID_CONFIGURATION;
1319
1320 /*
1321 * if we are not enumerating mass storage, we should
1322 * not be providing an interface number.
1323 */
1324 if (bus_mask == 0 && mass_storage_interface != 0)
1325 return CY_AS_ERROR_INVALID_CONFIGURATION;
1326
1327 /*
1328 * if we are going to use mtp_interface, bus mask must be 2.
1329 */
1330 if (mtp_interface != 0 && bus_mask != 2)
1331 return CY_AS_ERROR_INVALID_CONFIGURATION;
1332
1333
1334 /* Create the request to send to the West Bridge device */
1335 req_p = cy_as_ll_create_request(dev_p,
1336 CY_RQT_SET_USB_CONFIG, CY_RQT_USB_RQT_CONTEXT, 4);
1337 if (req_p == 0)
1338 return CY_AS_ERROR_OUT_OF_MEMORY;
1339
1340 /* Marshal the structure */
1341 cy_as_ll_request_response__set_word(req_p, 0,
1342 (uint16_t)((media_mask << 8) | bus_mask));
1343 cy_as_ll_request_response__set_word(req_p, 1,
1344 (uint16_t)use_antioch_enumeration);
1345 cy_as_ll_request_response__set_word(req_p, 2,
1346 dev_p->is_mtp_firmware ? mtp_interface :
1347 mass_storage_interface);
1348 cy_as_ll_request_response__set_word(req_p, 3,
1349 (uint16_t)mass_storage_callbacks);
1350
1351 /* Reserve space for the reply, the reply
1352 * data will not exceed one word */
1353 reply_p = cy_as_ll_create_response(dev_p, 1);
1354 if (reply_p == 0) {
1355 cy_as_ll_destroy_request(dev_p, req_p);
1356 return CY_AS_ERROR_OUT_OF_MEMORY;
1357 }
1358
1359 if (cb == 0) {
1360
1361 ret = cy_as_ll_send_request_wait_reply(dev_p, req_p, reply_p);
1362 if (ret != CY_AS_ERROR_SUCCESS)
1363 goto destroy;
1364
1365 return my_handle_response_set_enum_config(dev_p,
1366 req_p, reply_p);
1367 } else {
1368 ret = cy_as_misc_send_request(dev_p, cb, client,
1369 CY_FUNCT_CB_USB_SETENUMCONFIG, 0, dev_p->func_cbs_usb,
1370 CY_AS_REQUEST_RESPONSE_EX, req_p, reply_p,
1371 cy_as_usb_func_callback);
1372
1373 if (ret != CY_AS_ERROR_SUCCESS)
1374 goto destroy;
1375
1376 return ret;
1377 }
1378
1379 destroy:
1380 cy_as_ll_destroy_request(dev_p, req_p);
1381 cy_as_ll_destroy_response(dev_p, reply_p);
1382
1383 return ret;
1384 }
1385
1386 /*
1387 * This method sets how the USB is enumerated and should
1388 * be called before the CyAsUsbConnect() is called.
1389 */
1390 cy_as_return_status_t
1391 cy_as_usb_set_enum_config(cy_as_device_handle handle,
1392 cy_as_usb_enum_control *config_p,
1393 cy_as_function_callback cb,
1394 uint32_t client)
1395 {
1396 cy_as_device *dev_p = (cy_as_device *)handle;
1397 uint8_t bus_mask, media_mask;
1398 uint32_t bus, device;
1399 cy_as_return_status_t ret;
1400
1401 dev_p = (cy_as_device *)handle;
1402 if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
1403 return CY_AS_ERROR_INVALID_HANDLE;
1404
1405 ret = is_usb_active(dev_p);
1406 if (ret != CY_AS_ERROR_SUCCESS)
1407 return ret;
1408
1409 if ((cy_as_device_is_in_callback(dev_p)) && (cb != 0))
1410 return CY_AS_ERROR_INVALID_IN_CALLBACK;
1411
1412 /* Since we are mapping the media types to bus with NAND to 0
1413 * and the rest to 1, and we are only allowing for enumerating
1414 * all the devices on a bus we just scan the array for any
1415 * positions where there a device is enabled and mark the bus
1416 * to be enumerated.
1417 */
1418 bus_mask = 0;
1419 media_mask = 0;
1420 for (bus = 0; bus < CY_AS_MAX_BUSES; bus++) {
1421 for (device = 0; device < CY_AS_MAX_STORAGE_DEVICES; device++) {
1422 if (config_p->devices_to_enumerate[bus][device] ==
1423 cy_true) {
1424 bus_mask |= (0x01 << bus);
1425 media_mask |= dev_p->media_supported[bus];
1426 media_mask |= dev_p->media_supported[bus];
1427 }
1428 }
1429 }
1430
1431 return my_usb_set_enum_config(dev_p, bus_mask, media_mask,
1432 config_p->antioch_enumeration,
1433 config_p->mass_storage_interface,
1434 config_p->mtp_interface,
1435 config_p->mass_storage_callbacks,
1436 cb,
1437 client
1438 );
1439 }
1440
1441
1442 static cy_as_return_status_t
1443 my_handle_response_get_enum_config(cy_as_device *dev_p,
1444 cy_as_ll_request_response *req_p,
1445 cy_as_ll_request_response *reply_p,
1446 void *config_p)
1447 {
1448 cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS;
1449 uint16_t val;
1450 uint8_t bus_mask;
1451 uint32_t bus;
1452
1453 if (cy_as_ll_request_response__get_code(reply_p) !=
1454 CY_RESP_USB_CONFIG) {
1455 ret = CY_AS_ERROR_INVALID_RESPONSE;
1456 goto destroy;
1457 }
1458
1459 /* Marshal the reply */
1460 if (req_p->flags & CY_AS_REQUEST_RESPONSE_MS) {
1461 uint32_t device;
1462 cy_bool state;
1463 cy_as_usb_enum_control *ms_config_p =
1464 (cy_as_usb_enum_control *)config_p;
1465
1466 bus_mask = (uint8_t)
1467 (cy_as_ll_request_response__get_word
1468 (reply_p, 0) & 0xFF);
1469 for (bus = 0; bus < CY_AS_MAX_BUSES; bus++) {
1470 if (bus_mask & (1 << bus))
1471 state = cy_true;
1472 else
1473 state = cy_false;
1474
1475 for (device = 0; device < CY_AS_MAX_STORAGE_DEVICES;
1476 device++)
1477 ms_config_p->devices_to_enumerate[bus][device]
1478 = state;
1479 }
1480
1481 ms_config_p->antioch_enumeration =
1482 (cy_bool)cy_as_ll_request_response__get_word
1483 (reply_p, 1);
1484
1485 val = cy_as_ll_request_response__get_word(reply_p, 2);
1486 if (dev_p->is_mtp_firmware) {
1487 ms_config_p->mass_storage_interface = 0;
1488 ms_config_p->mtp_interface = (uint8_t)(val & 0xFF);
1489 } else {
1490 ms_config_p->mass_storage_interface =
1491 (uint8_t)(val & 0xFF);
1492 ms_config_p->mtp_interface = 0;
1493 }
1494 ms_config_p->mass_storage_callbacks = (cy_bool)(val >> 8);
1495
1496 /*
1497 * firmware returns an invalid interface number for mass storage,
1498 * if mass storage is not enabled. this needs to be converted to
1499 * zero to match the input configuration.
1500 */
1501 if (bus_mask == 0) {
1502 if (dev_p->is_mtp_firmware)
1503 ms_config_p->mtp_interface = 0;
1504 else
1505 ms_config_p->mass_storage_interface = 0;
1506 }
1507 } else {
1508 cy_as_usb_enum_control_dep *ex_config_p =
1509 (cy_as_usb_enum_control_dep *)config_p;
1510
1511 ex_config_p->enum_mass_storage = (uint8_t)
1512 ((cy_as_ll_request_response__get_word
1513 (reply_p, 0) >> 8) & 0xFF);
1514 ex_config_p->antioch_enumeration = (cy_bool)
1515 cy_as_ll_request_response__get_word(reply_p, 1);
1516
1517 val = cy_as_ll_request_response__get_word(reply_p, 2);
1518 ex_config_p->mass_storage_interface = (uint8_t)(val & 0xFF);
1519 ex_config_p->mass_storage_callbacks = (cy_bool)(val >> 8);
1520
1521 /*
1522 * firmware returns an invalid interface number for mass
1523 * storage, if mass storage is not enabled. this needs to
1524 * be converted to zero to match the input configuration.
1525 */
1526 if (ex_config_p->enum_mass_storage == 0)
1527 ex_config_p->mass_storage_interface = 0;
1528 }
1529
1530 destroy:
1531 cy_as_ll_destroy_request(dev_p, req_p);
1532 cy_as_ll_destroy_response(dev_p, reply_p);
1533
1534 return ret;
1535 }
1536
1537 /*
1538 * This sets up the request for the enumerateion configuration
1539 * information, based on if the request is from the old pre-1.2
1540 * functions.
1541 */
1542 static cy_as_return_status_t
1543 my_usb_get_enum_config(cy_as_device_handle handle,
1544 uint16_t req_flags,
1545 void *config_p,
1546 cy_as_function_callback cb,
1547 uint32_t client)
1548 {
1549 cy_as_ll_request_response *req_p , *reply_p;
1550 cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS;
1551
1552 cy_as_device *dev_p;
1553
1554 cy_as_log_debug_message(6, "cy_as_usb_get_enum_config called");
1555
1556 dev_p = (cy_as_device *)handle;
1557 if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
1558 return CY_AS_ERROR_INVALID_HANDLE;
1559
1560 ret = is_usb_active(dev_p);
1561 if (ret != CY_AS_ERROR_SUCCESS)
1562 return ret;
1563
1564 if (cy_as_device_is_in_callback(dev_p))
1565 return CY_AS_ERROR_INVALID_IN_CALLBACK;
1566
1567 /* Create the request to send to the West Bridge device */
1568 req_p = cy_as_ll_create_request(dev_p,
1569 CY_RQT_GET_USB_CONFIG, CY_RQT_USB_RQT_CONTEXT, 0);
1570 if (req_p == 0)
1571 return CY_AS_ERROR_OUT_OF_MEMORY;
1572
1573 /* Reserve space for the reply, the reply data
1574 * will not exceed two bytes */
1575 reply_p = cy_as_ll_create_response(dev_p, 3);
1576 if (reply_p == 0) {
1577 cy_as_ll_destroy_request(dev_p, req_p);
1578 return CY_AS_ERROR_OUT_OF_MEMORY;
1579 }
1580
1581 if (cb == 0) {
1582 ret = cy_as_ll_send_request_wait_reply(dev_p, req_p, reply_p);
1583 if (ret != CY_AS_ERROR_SUCCESS)
1584 goto destroy;
1585
1586 /* we need to know the type of request to
1587 * know how to manage the data */
1588 req_p->flags |= req_flags;
1589 return my_handle_response_get_enum_config(dev_p,
1590 req_p, reply_p, config_p);
1591 } else {
1592 ret = cy_as_misc_send_request(dev_p, cb, client,
1593 CY_FUNCT_CB_USB_GETENUMCONFIG, config_p,
1594 dev_p->func_cbs_usb, req_flags, req_p, reply_p,
1595 cy_as_usb_func_callback);
1596
1597 if (ret != CY_AS_ERROR_SUCCESS)
1598 goto destroy;
1599
1600 return ret;
1601 }
1602
1603 destroy:
1604 cy_as_ll_destroy_request(dev_p, req_p);
1605 cy_as_ll_destroy_response(dev_p, reply_p);
1606
1607 return ret;
1608 }
1609
1610 /*
1611 * This method returns the enumerateion configuration information
1612 * from the West Bridge device. Generally this is not used by
1613 * client software but is provided mostly for debug information.
1614 * We want a method to read all state information from the device.
1615 */
1616 cy_as_return_status_t
1617 cy_as_usb_get_enum_config(cy_as_device_handle handle,
1618 cy_as_usb_enum_control *config_p,
1619 cy_as_function_callback cb,
1620 uint32_t client)
1621 {
1622 return my_usb_get_enum_config(handle,
1623 CY_AS_REQUEST_RESPONSE_MS, config_p, cb, client);
1624 }
1625
1626
1627 /*
1628 * This method sets the USB descriptor for a given entity.
1629 */
1630 cy_as_return_status_t
1631 cy_as_usb_set_descriptor(cy_as_device_handle handle,
1632 cy_as_usb_desc_type type,
1633 uint8_t index,
1634 void *desc_p,
1635 uint16_t length,
1636 cy_as_function_callback cb,
1637 uint32_t client)
1638 {
1639 cy_as_ll_request_response *req_p , *reply_p;
1640 cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS;
1641 uint16_t pktlen;
1642
1643 cy_as_device *dev_p;
1644
1645 cy_as_log_debug_message(6, "cy_as_usb_set_descriptor called");
1646
1647 dev_p = (cy_as_device *)handle;
1648 if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
1649 return CY_AS_ERROR_INVALID_HANDLE;
1650
1651 ret = is_usb_active(dev_p);
1652 if (ret != CY_AS_ERROR_SUCCESS)
1653 return ret;
1654
1655 if (cy_as_device_is_in_callback(dev_p))
1656 return CY_AS_ERROR_INVALID_IN_CALLBACK;
1657
1658 if (length > CY_AS_MAX_USB_DESCRIPTOR_SIZE)
1659 return CY_AS_ERROR_INVALID_DESCRIPTOR;
1660
1661 pktlen = (uint16_t)length / 2;
1662 if (length % 2)
1663 pktlen++;
1664 pktlen += 2; /* 1 for type, 1 for length */
1665
1666 /* Create the request to send to the West Bridge device */
1667 req_p = cy_as_ll_create_request(dev_p, CY_RQT_SET_DESCRIPTOR,
1668 CY_RQT_USB_RQT_CONTEXT, (uint16_t)pktlen);
1669 if (req_p == 0)
1670 return CY_AS_ERROR_OUT_OF_MEMORY;
1671
1672 cy_as_ll_request_response__set_word(req_p, 0,
1673 (uint16_t)((uint8_t)type | (index << 8)));
1674 cy_as_ll_request_response__set_word(req_p, 1,
1675 (uint16_t)length);
1676 cy_as_ll_request_response__pack(req_p, 2, length, desc_p);
1677
1678 reply_p = cy_as_ll_create_response(dev_p, 1);
1679 if (reply_p == 0) {
1680 cy_as_ll_destroy_request(dev_p, req_p);
1681 return CY_AS_ERROR_OUT_OF_MEMORY;
1682 }
1683
1684 if (cb == 0) {
1685 ret = cy_as_ll_send_request_wait_reply(dev_p, req_p, reply_p);
1686 if (ret != CY_AS_ERROR_SUCCESS)
1687 goto destroy;
1688
1689 return my_handle_response_no_data(dev_p, req_p, reply_p);
1690 } else {
1691 ret = cy_as_misc_send_request(dev_p, cb, client,
1692 CY_FUNCT_CB_USB_SETDESCRIPTOR, 0, dev_p->func_cbs_usb,
1693 CY_AS_REQUEST_RESPONSE_EX, req_p, reply_p,
1694 cy_as_usb_func_callback);
1695
1696 if (ret != CY_AS_ERROR_SUCCESS)
1697 goto destroy;
1698
1699 return ret;
1700 }
1701
1702 destroy:
1703 cy_as_ll_destroy_request(dev_p, req_p);
1704 cy_as_ll_destroy_response(dev_p, reply_p);
1705
1706 return ret;
1707 }
1708
1709 /*
1710 * This method clears all descriptors that were previously
1711 * stored on the West Bridge through CyAsUsbSetDescriptor calls.
1712 */
1713 cy_as_return_status_t
1714 cy_as_usb_clear_descriptors(cy_as_device_handle handle,
1715 cy_as_function_callback cb,
1716 uint32_t client)
1717 {
1718 cy_as_ll_request_response *req_p , *reply_p;
1719 cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS;
1720
1721 cy_as_device *dev_p;
1722
1723 cy_as_log_debug_message(6, "cy_as_usb_clear_descriptors called");
1724
1725 dev_p = (cy_as_device *)handle;
1726 if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
1727 return CY_AS_ERROR_INVALID_HANDLE;
1728
1729 ret = is_usb_active(dev_p);
1730 if (ret != CY_AS_ERROR_SUCCESS)
1731 return ret;
1732
1733 if ((cy_as_device_is_in_callback(dev_p)) && (cb == 0))
1734 return CY_AS_ERROR_INVALID_IN_CALLBACK;
1735
1736 /* Create the request to send to the West Bridge device */
1737 req_p = cy_as_ll_create_request(dev_p,
1738 CY_RQT_CLEAR_DESCRIPTORS, CY_RQT_USB_RQT_CONTEXT, 1);
1739 if (req_p == 0)
1740 return CY_AS_ERROR_OUT_OF_MEMORY;
1741
1742 reply_p = cy_as_ll_create_response(dev_p, 1);
1743 if (reply_p == 0) {
1744 cy_as_ll_destroy_request(dev_p, req_p);
1745 return CY_AS_ERROR_OUT_OF_MEMORY;
1746 }
1747
1748 if (cb == 0) {
1749
1750 ret = cy_as_ll_send_request_wait_reply(dev_p, req_p, reply_p);
1751 if (ret != CY_AS_ERROR_SUCCESS)
1752 goto destroy;
1753
1754 return my_handle_response_no_data(dev_p, req_p, reply_p);
1755 } else {
1756 ret = cy_as_misc_send_request(dev_p, cb, client,
1757 CY_FUNCT_CB_USB_CLEARDESCRIPTORS, 0,
1758 dev_p->func_cbs_usb,
1759 CY_AS_REQUEST_RESPONSE_EX, req_p, reply_p,
1760 cy_as_usb_func_callback);
1761
1762 if (ret != CY_AS_ERROR_SUCCESS)
1763 goto destroy;
1764
1765 return ret;
1766 }
1767
1768 destroy:
1769 cy_as_ll_destroy_request(dev_p, req_p);
1770 cy_as_ll_destroy_response(dev_p, reply_p);
1771
1772 return ret;
1773 }
1774
1775 static cy_as_return_status_t
1776 my_handle_response_get_descriptor(cy_as_device *dev_p,
1777 cy_as_ll_request_response *req_p,
1778 cy_as_ll_request_response *reply_p,
1779 cy_as_get_descriptor_data *data)
1780 {
1781 cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS;
1782 uint32_t retlen;
1783
1784 if (cy_as_ll_request_response__get_code(reply_p) ==
1785 CY_RESP_SUCCESS_FAILURE) {
1786 ret = cy_as_ll_request_response__get_word(reply_p, 0);
1787 goto destroy;
1788 } else if (cy_as_ll_request_response__get_code(reply_p) !=
1789 CY_RESP_USB_DESCRIPTOR) {
1790 ret = CY_AS_ERROR_INVALID_RESPONSE;
1791 goto destroy;
1792 }
1793
1794 retlen = cy_as_ll_request_response__get_word(reply_p, 0);
1795 if (retlen > data->length) {
1796 ret = CY_AS_ERROR_INVALID_SIZE;
1797 goto destroy;
1798 }
1799
1800 ret = CY_AS_ERROR_SUCCESS;
1801 cy_as_ll_request_response__unpack(reply_p, 1,
1802 retlen, data->desc_p);
1803
1804 destroy:
1805 cy_as_ll_destroy_request(dev_p, req_p);
1806 cy_as_ll_destroy_response(dev_p, reply_p);
1807
1808 return ret;
1809 }
1810
1811 /*
1812 * This method retreives the USB descriptor for a given type.
1813 */
1814 cy_as_return_status_t
1815 cy_as_usb_get_descriptor(cy_as_device_handle handle,
1816 cy_as_usb_desc_type type,
1817 uint8_t index,
1818 cy_as_get_descriptor_data *data,
1819 cy_as_function_callback cb,
1820 uint32_t client)
1821 {
1822 cy_as_return_status_t ret;
1823 cy_as_ll_request_response *req_p , *reply_p;
1824
1825 cy_as_device *dev_p;
1826
1827 cy_as_log_debug_message(6, "cy_as_usb_get_descriptor called");
1828
1829 dev_p = (cy_as_device *)handle;
1830 if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
1831 return CY_AS_ERROR_INVALID_HANDLE;
1832
1833 ret = is_usb_active(dev_p);
1834 if (ret != CY_AS_ERROR_SUCCESS)
1835 return ret;
1836
1837 if (cy_as_device_is_in_callback(dev_p))
1838 return CY_AS_ERROR_INVALID_IN_CALLBACK;
1839
1840 /* Create the request to send to the West Bridge device */
1841 req_p = cy_as_ll_create_request(dev_p,
1842 CY_RQT_GET_DESCRIPTOR, CY_RQT_USB_RQT_CONTEXT, 1);
1843 if (req_p == 0)
1844 return CY_AS_ERROR_OUT_OF_MEMORY;
1845
1846 cy_as_ll_request_response__set_word(req_p, 0,
1847 (uint16_t)((uint8_t)type | (index << 8)));
1848
1849 /* Add one for the length field */
1850 reply_p = cy_as_ll_create_response(dev_p,
1851 CY_AS_MAX_USB_DESCRIPTOR_SIZE + 1);
1852 if (reply_p == 0) {
1853 cy_as_ll_destroy_request(dev_p, req_p);
1854 return CY_AS_ERROR_OUT_OF_MEMORY;
1855 }
1856
1857 if (cb == 0) {
1858 ret = cy_as_ll_send_request_wait_reply(
1859 dev_p, req_p, reply_p);
1860 if (ret != CY_AS_ERROR_SUCCESS)
1861 goto destroy;
1862
1863 return my_handle_response_get_descriptor(dev_p,
1864 req_p, reply_p, data);
1865 } else {
1866 ret = cy_as_misc_send_request(dev_p, cb, client,
1867 CY_FUNCT_CB_USB_GETDESCRIPTOR, data,
1868 dev_p->func_cbs_usb,
1869 CY_AS_REQUEST_RESPONSE_EX, req_p,
1870 reply_p, cy_as_usb_func_callback);
1871
1872 if (ret != CY_AS_ERROR_SUCCESS)
1873 goto destroy;
1874
1875 return ret;
1876 }
1877
1878 destroy:
1879 cy_as_ll_destroy_request(dev_p, req_p);
1880 cy_as_ll_destroy_response(dev_p, reply_p);
1881
1882 return ret;
1883 }
1884
1885 cy_as_return_status_t
1886 cy_as_usb_set_physical_configuration(cy_as_device_handle handle,
1887 uint8_t config)
1888 {
1889 cy_as_return_status_t ret;
1890 cy_as_device *dev_p;
1891
1892 cy_as_log_debug_message(6,
1893 "cy_as_usb_set_physical_configuration called");
1894
1895 dev_p = (cy_as_device *)handle;
1896 if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
1897 return CY_AS_ERROR_INVALID_HANDLE;
1898
1899 ret = is_usb_active(dev_p);
1900 if (ret != CY_AS_ERROR_SUCCESS)
1901 return ret;
1902
1903 if (cy_as_device_is_usb_connected(dev_p))
1904 return CY_AS_ERROR_USB_CONNECTED;
1905
1906 if (config < 1 || config > 12)
1907 return CY_AS_ERROR_INVALID_CONFIGURATION;
1908
1909 dev_p->usb_phy_config = config;
1910
1911 return CY_AS_ERROR_SUCCESS;
1912 }
1913
1914 static cy_bool
1915 is_physical_valid(uint8_t config, cy_as_end_point_number_t ep)
1916 {
1917 static uint8_t validmask[12] = {
1918 0x0f, /* Config 1 - 1, 2, 3, 4 */
1919 0x07, /* Config 2 - 1, 2, 3 */
1920 0x07, /* Config 3 - 1, 2, 3 */
1921 0x0d, /* Config 4 - 1, 3, 4 */
1922 0x05, /* Config 5 - 1, 3 */
1923 0x05, /* Config 6 - 1, 3 */
1924 0x0d, /* Config 7 - 1, 3, 4 */
1925 0x05, /* Config 8 - 1, 3 */
1926 0x05, /* Config 9 - 1, 3 */
1927 0x0d, /* Config 10 - 1, 3, 4 */
1928 0x09, /* Config 11 - 1, 4 */
1929 0x01 /* Config 12 - 1 */
1930 };
1931
1932 return (validmask[config - 1] & (1 << (ep - 1))) ? cy_true : cy_false;
1933 }
1934
1935 /*
1936 * This method sets the configuration for an endpoint
1937 */
1938 cy_as_return_status_t
1939 cy_as_usb_set_end_point_config(cy_as_device_handle handle,
1940 cy_as_end_point_number_t ep, cy_as_usb_end_point_config *config_p)
1941 {
1942 cy_as_return_status_t ret;
1943 cy_as_device *dev_p;
1944
1945 cy_as_log_debug_message(6, "cy_as_usb_set_end_point_config called");
1946
1947 dev_p = (cy_as_device *)handle;
1948 if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
1949 return CY_AS_ERROR_INVALID_HANDLE;
1950
1951 ret = is_usb_active(dev_p);
1952 if (ret != CY_AS_ERROR_SUCCESS)
1953 return ret;
1954
1955 if (cy_as_device_is_usb_connected(dev_p))
1956 return CY_AS_ERROR_USB_CONNECTED;
1957
1958 if (ep >= 16 || ep == 2 || ep == 4 || ep == 6 || ep == 8)
1959 return CY_AS_ERROR_INVALID_ENDPOINT;
1960
1961 if (ep == 0) {
1962 /* Endpoint 0 must be 64 byte, dir IN/OUT,
1963 * and control type */
1964 if (config_p->dir != cy_as_usb_in_out ||
1965 config_p->type != cy_as_usb_control)
1966 return CY_AS_ERROR_INVALID_CONFIGURATION;
1967 } else if (ep == 1) {
1968 if ((dev_p->is_mtp_firmware == 1) &&
1969 (dev_p->usb_config[1].enabled == cy_true)) {
1970 return CY_AS_ERROR_INVALID_ENDPOINT;
1971 }
1972
1973 /*
1974 * EP1 can only be used either as an OUT ep, or as an IN ep.
1975 */
1976 if ((config_p->type == cy_as_usb_control) ||
1977 (config_p->type == cy_as_usb_iso) ||
1978 (config_p->dir == cy_as_usb_in_out))
1979 return CY_AS_ERROR_INVALID_CONFIGURATION;
1980 } else {
1981 if (config_p->dir == cy_as_usb_in_out ||
1982 config_p->type == cy_as_usb_control)
1983 return CY_AS_ERROR_INVALID_CONFIGURATION;
1984
1985 if (!is_physical_valid(dev_p->usb_phy_config,
1986 config_p->physical))
1987 return CY_AS_ERROR_INVALID_PHYSICAL_ENDPOINT;
1988
1989 /*
1990 * ISO endpoints must be on E_ps 3, 5, 7 or 9 as
1991 * they need to align directly with the underlying
1992 * physical endpoint.
1993 */
1994 if (config_p->type == cy_as_usb_iso) {
1995 if (ep != 3 && ep != 5 && ep != 7 && ep != 9)
1996 return CY_AS_ERROR_INVALID_CONFIGURATION;
1997
1998 if (ep == 3 && config_p->physical != 1)
1999 return CY_AS_ERROR_INVALID_CONFIGURATION;
2000
2001 if (ep == 5 && config_p->physical != 2)
2002 return CY_AS_ERROR_INVALID_CONFIGURATION;
2003
2004 if (ep == 7 && config_p->physical != 3)
2005 return CY_AS_ERROR_INVALID_CONFIGURATION;
2006
2007 if (ep == 9 && config_p->physical != 4)
2008 return CY_AS_ERROR_INVALID_CONFIGURATION;
2009 }
2010 }
2011
2012 /* Store the configuration information until a
2013 * CyAsUsbCommitConfig is done */
2014 dev_p->usb_config[ep] = *config_p;
2015
2016 /* If the endpoint is enabled, enable DMA associated
2017 * with the endpoint */
2018 /*
2019 * we make some assumptions that we check here. we assume
2020 * that the direction fields for the DMA module are the same
2021 * values as the direction values for the USB module.
2022 */
2023 cy_as_hal_assert((int)cy_as_usb_in == (int)cy_as_direction_in);
2024 cy_as_hal_assert((int)cy_as_usb_out == (int)cy_as_direction_out);
2025 cy_as_hal_assert((int)cy_as_usb_in_out == (int)cy_as_direction_in_out);
2026
2027 return cy_as_dma_enable_end_point(dev_p, ep,
2028 config_p->enabled, (cy_as_dma_direction)config_p->dir);
2029 }
2030
2031 cy_as_return_status_t
2032 cy_as_usb_get_end_point_config(cy_as_device_handle handle,
2033 cy_as_end_point_number_t ep, cy_as_usb_end_point_config *config_p)
2034 {
2035 cy_as_return_status_t ret;
2036
2037 cy_as_device *dev_p;
2038
2039 cy_as_log_debug_message(6, "cy_as_usb_get_end_point_config called");
2040
2041 dev_p = (cy_as_device *)handle;
2042 if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
2043 return CY_AS_ERROR_INVALID_HANDLE;
2044
2045 ret = is_usb_active(dev_p);
2046 if (ret != CY_AS_ERROR_SUCCESS)
2047 return ret;
2048
2049 if (ep >= 16 || ep == 2 || ep == 4 || ep == 6 || ep == 8)
2050 return CY_AS_ERROR_INVALID_ENDPOINT;
2051
2052 *config_p = dev_p->usb_config[ep];
2053
2054 return CY_AS_ERROR_SUCCESS;
2055 }
2056
2057 /*
2058 * Commit the configuration of the various endpoints to the hardware.
2059 */
2060 cy_as_return_status_t
2061 cy_as_usb_commit_config(cy_as_device_handle handle,
2062 cy_as_function_callback cb,
2063 uint32_t client)
2064 {
2065 uint32_t i;
2066 cy_as_return_status_t ret;
2067 cy_as_ll_request_response *req_p , *reply_p;
2068 cy_as_device *dev_p;
2069 uint16_t data;
2070
2071 cy_as_log_debug_message(6, "cy_as_usb_commit_config called");
2072
2073 dev_p = (cy_as_device *)handle;
2074 if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
2075 return CY_AS_ERROR_INVALID_HANDLE;
2076
2077 ret = is_usb_active(dev_p);
2078 if (ret != CY_AS_ERROR_SUCCESS)
2079 return ret;
2080
2081 if (cy_as_device_is_usb_connected(dev_p))
2082 return CY_AS_ERROR_USB_CONNECTED;
2083
2084 if (cy_as_device_is_in_callback(dev_p))
2085 return CY_AS_ERROR_INVALID_IN_CALLBACK;
2086
2087 /*
2088 * this performs the mapping based on informatation that was
2089 * previously stored on the device about the various endpoints
2090 * and how they are configured. the output of this mapping is
2091 * setting the the 14 register values contained in usb_lepcfg
2092 * and usb_pepcfg
2093 */
2094 ret = cy_as_usb_map_logical2_physical(dev_p);
2095 if (ret != CY_AS_ERROR_SUCCESS)
2096 return ret;
2097
2098 /*
2099 * now, package the information about the various logical and
2100 * physical endpoint configuration registers and send it
2101 * across to the west bridge device.
2102 */
2103 req_p = cy_as_ll_create_request(dev_p,
2104 CY_RQT_SET_USB_CONFIG_REGISTERS, CY_RQT_USB_RQT_CONTEXT, 8);
2105 if (req_p == 0)
2106 return CY_AS_ERROR_OUT_OF_MEMORY;
2107
2108 cy_as_hal_print_message("USB configuration: %d\n",
2109 dev_p->usb_phy_config);
2110 cy_as_hal_print_message("EP1OUT: 0x%02x EP1IN: 0x%02x\n",
2111 dev_p->usb_ep1cfg[0], dev_p->usb_ep1cfg[1]);
2112 cy_as_hal_print_message("PEP registers: 0x%02x 0x%02x 0x%02x 0x%02x\n",
2113 dev_p->usb_pepcfg[0], dev_p->usb_pepcfg[1],
2114 dev_p->usb_pepcfg[2], dev_p->usb_pepcfg[3]);
2115
2116 cy_as_hal_print_message("LEP registers: 0x%02x 0x%02x 0x%02x "
2117 "0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
2118 dev_p->usb_lepcfg[0], dev_p->usb_lepcfg[1],
2119 dev_p->usb_lepcfg[2], dev_p->usb_lepcfg[3],
2120 dev_p->usb_lepcfg[4], dev_p->usb_lepcfg[5],
2121 dev_p->usb_lepcfg[6], dev_p->usb_lepcfg[7],
2122 dev_p->usb_lepcfg[8], dev_p->usb_lepcfg[9]);
2123
2124 /* Write the EP1OUTCFG and EP1INCFG data in the first word. */
2125 data = (uint16_t)((dev_p->usb_ep1cfg[0] << 8) |
2126 dev_p->usb_ep1cfg[1]);
2127 cy_as_ll_request_response__set_word(req_p, 0, data);
2128
2129 /* Write the PEP CFG data in the next 2 words */
2130 for (i = 0; i < 4; i += 2) {
2131 data = (uint16_t)((dev_p->usb_pepcfg[i] << 8) |
2132 dev_p->usb_pepcfg[i + 1]);
2133 cy_as_ll_request_response__set_word(req_p,
2134 1 + i / 2, data);
2135 }
2136
2137 /* Write the LEP CFG data in the next 5 words */
2138 for (i = 0; i < 10; i += 2) {
2139 data = (uint16_t)((dev_p->usb_lepcfg[i] << 8) |
2140 dev_p->usb_lepcfg[i + 1]);
2141 cy_as_ll_request_response__set_word(req_p,
2142 3 + i / 2, data);
2143 }
2144
2145 /* A single status word response type */
2146 reply_p = cy_as_ll_create_response(dev_p, 1);
2147 if (reply_p == 0) {
2148 cy_as_ll_destroy_request(dev_p, req_p);
2149 return CY_AS_ERROR_OUT_OF_MEMORY;
2150 }
2151
2152 if (cb == 0) {
2153 ret = cy_as_ll_send_request_wait_reply(dev_p,
2154 req_p, reply_p);
2155 if (ret != CY_AS_ERROR_SUCCESS)
2156 goto destroy;
2157
2158 ret = my_handle_response_no_data(dev_p,
2159 req_p, reply_p);
2160
2161 if (ret == CY_AS_ERROR_SUCCESS)
2162 ret = cy_as_usb_setup_dma(dev_p);
2163
2164 return ret;
2165 } else {
2166 ret = cy_as_misc_send_request(dev_p, cb, client,
2167 CY_FUNCT_CB_USB_COMMITCONFIG, 0, dev_p->func_cbs_usb,
2168 CY_AS_REQUEST_RESPONSE_EX, req_p, reply_p,
2169 cy_as_usb_func_callback);
2170
2171 if (ret != CY_AS_ERROR_SUCCESS)
2172 goto destroy;
2173
2174 return ret;
2175 }
2176
2177 destroy:
2178 cy_as_ll_destroy_request(dev_p, req_p);
2179 cy_as_ll_destroy_response(dev_p, reply_p);
2180
2181 return ret;
2182 }
2183
2184 static void
2185 sync_request_callback(cy_as_device *dev_p,
2186 cy_as_end_point_number_t ep, void *buf_p,
2187 uint32_t size, cy_as_return_status_t err)
2188 {
2189 (void)ep;
2190 (void)buf_p;
2191
2192 dev_p->usb_error = err;
2193 dev_p->usb_actual_cnt = size;
2194 }
2195
2196 static void
2197 async_read_request_callback(cy_as_device *dev_p,
2198 cy_as_end_point_number_t ep, void *buf_p,
2199 uint32_t size, cy_as_return_status_t err)
2200 {
2201 cy_as_device_handle h;
2202
2203 cy_as_log_debug_message(6,
2204 "async_read_request_callback called");
2205
2206 h = (cy_as_device_handle)dev_p;
2207
2208 if (ep == 0 && cy_as_device_is_ack_delayed(dev_p)) {
2209 dev_p->usb_pending_buffer = buf_p;
2210 dev_p->usb_pending_size = size;
2211 dev_p->usb_error = err;
2212 cy_as_usb_ack_setup_packet(h, usb_ack_callback, 0);
2213 } else {
2214 cy_as_usb_io_callback cb;
2215
2216 cb = dev_p->usb_cb[ep];
2217 dev_p->usb_cb[ep] = 0;
2218 cy_as_device_clear_usb_async_pending(dev_p, ep);
2219 if (cb)
2220 cb(h, ep, size, buf_p, err);
2221 }
2222 }
2223
2224 static void
2225 async_write_request_callback(cy_as_device *dev_p,
2226 cy_as_end_point_number_t ep, void *buf_p,
2227 uint32_t size, cy_as_return_status_t err)
2228 {
2229 cy_as_device_handle h;
2230
2231 cy_as_log_debug_message(6,
2232 "async_write_request_callback called");
2233
2234 h = (cy_as_device_handle)dev_p;
2235
2236 if (ep == 0 && cy_as_device_is_ack_delayed(dev_p)) {
2237 dev_p->usb_pending_buffer = buf_p;
2238 dev_p->usb_pending_size = size;
2239 dev_p->usb_error = err;
2240
2241 /* The west bridge protocol generates ZLPs as required. */
2242 cy_as_usb_ack_setup_packet(h, usb_ack_callback, 0);
2243 } else {
2244 cy_as_usb_io_callback cb;
2245
2246 cb = dev_p->usb_cb[ep];
2247 dev_p->usb_cb[ep] = 0;
2248
2249 cy_as_device_clear_usb_async_pending(dev_p, ep);
2250 if (cb)
2251 cb(h, ep, size, buf_p, err);
2252 }
2253 }
2254
2255 static void
2256 my_turbo_rqt_callback(cy_as_device *dev_p,
2257 uint8_t context,
2258 cy_as_ll_request_response *rqt,
2259 cy_as_ll_request_response *resp,
2260 cy_as_return_status_t stat)
2261 {
2262 uint8_t code;
2263
2264 (void)context;
2265 (void)stat;
2266
2267 /* The Handlers are responsible for Deleting the rqt and resp when
2268 * they are finished
2269 */
2270 code = cy_as_ll_request_response__get_code(rqt);
2271 switch (code) {
2272 case CY_RQT_TURBO_SWITCH_ENDPOINT:
2273 cy_as_hal_assert(stat == CY_AS_ERROR_SUCCESS);
2274 cy_as_ll_destroy_request(dev_p, rqt);
2275 cy_as_ll_destroy_response(dev_p, resp);
2276 break;
2277 default:
2278 cy_as_hal_assert(cy_false);
2279 break;
2280 }
2281 }
2282
2283 /* Send a mailbox request to prepare the endpoint for switching */
2284 static cy_as_return_status_t
2285 my_send_turbo_switch(cy_as_device *dev_p, uint32_t size, cy_bool pktread)
2286 {
2287 cy_as_return_status_t ret;
2288 cy_as_ll_request_response *req_p , *reply_p;
2289
2290 /* Create the request to send to the West Bridge device */
2291 req_p = cy_as_ll_create_request(dev_p,
2292 CY_RQT_TURBO_SWITCH_ENDPOINT, CY_RQT_TUR_RQT_CONTEXT, 3);
2293 if (req_p == 0)
2294 return CY_AS_ERROR_OUT_OF_MEMORY;
2295
2296 /* Reserve space for the reply, the reply data will
2297 * not exceed one word */
2298 reply_p = cy_as_ll_create_response(dev_p, 1);
2299 if (reply_p == 0) {
2300 cy_as_ll_destroy_request(dev_p, req_p);
2301 return CY_AS_ERROR_OUT_OF_MEMORY;
2302 }
2303
2304 cy_as_ll_request_response__set_word(req_p, 0,
2305 (uint16_t)pktread);
2306 cy_as_ll_request_response__set_word(req_p, 1,
2307 (uint16_t)((size >> 16) & 0xFFFF));
2308 cy_as_ll_request_response__set_word(req_p, 2,
2309 (uint16_t)(size & 0xFFFF));
2310
2311 ret = cy_as_ll_send_request(dev_p, req_p,
2312 reply_p, cy_false, my_turbo_rqt_callback);
2313 if (ret != CY_AS_ERROR_SUCCESS) {
2314 cy_as_ll_destroy_request(dev_p, req_p);
2315 cy_as_ll_destroy_request(dev_p, reply_p);
2316 return ret;
2317 }
2318
2319 return CY_AS_ERROR_SUCCESS;
2320 }
2321
2322 cy_as_return_status_t
2323 cy_as_usb_read_data(cy_as_device_handle handle,
2324 cy_as_end_point_number_t ep, cy_bool pktread,
2325 uint32_t dsize, uint32_t *dataread, void *data)
2326 {
2327 cy_as_return_status_t ret;
2328 cy_as_device *dev_p;
2329
2330 cy_as_log_debug_message(6, "cy_as_usb_read_data called");
2331
2332 dev_p = (cy_as_device *)handle;
2333 if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
2334 return CY_AS_ERROR_INVALID_HANDLE;
2335
2336 ret = is_usb_active(dev_p);
2337 if (ret != CY_AS_ERROR_SUCCESS)
2338 return ret;
2339
2340 if (cy_as_device_is_in_callback(dev_p))
2341 return CY_AS_ERROR_INVALID_IN_CALLBACK;
2342
2343 if (ep >= 16 || ep == 4 || ep == 6 || ep == 8)
2344 return CY_AS_ERROR_INVALID_ENDPOINT;
2345
2346 /* EP2 is available for reading when MTP is active */
2347 if (dev_p->mtp_count == 0 && ep == CY_AS_MTP_READ_ENDPOINT)
2348 return CY_AS_ERROR_INVALID_ENDPOINT;
2349
2350 /* If the endpoint is disabled, we cannot
2351 * write data to the endpoint */
2352 if (!dev_p->usb_config[ep].enabled)
2353 return CY_AS_ERROR_ENDPOINT_DISABLED;
2354
2355 if (dev_p->usb_config[ep].dir != cy_as_usb_out)
2356 return CY_AS_ERROR_USB_BAD_DIRECTION;
2357
2358 ret = cy_as_dma_queue_request(dev_p, ep, data, dsize,
2359 pktread, cy_true, sync_request_callback);
2360 if (ret != CY_AS_ERROR_SUCCESS)
2361 return ret;
2362
2363 if (ep == CY_AS_MTP_READ_ENDPOINT) {
2364 ret = my_send_turbo_switch(dev_p, dsize, pktread);
2365 if (ret != CY_AS_ERROR_SUCCESS) {
2366 cy_as_dma_cancel(dev_p, ep, ret);
2367 return ret;
2368 }
2369
2370 ret = cy_as_dma_drain_queue(dev_p, ep, cy_false);
2371 if (ret != CY_AS_ERROR_SUCCESS)
2372 return ret;
2373 } else {
2374 ret = cy_as_dma_drain_queue(dev_p, ep, cy_true);
2375 if (ret != CY_AS_ERROR_SUCCESS)
2376 return ret;
2377 }
2378
2379 ret = dev_p->usb_error;
2380 *dataread = dev_p->usb_actual_cnt;
2381
2382 return ret;
2383 }
2384
2385 cy_as_return_status_t
2386 cy_as_usb_read_data_async(cy_as_device_handle handle,
2387 cy_as_end_point_number_t ep, cy_bool pktread,
2388 uint32_t dsize, void *data, cy_as_usb_io_callback cb)
2389 {
2390 cy_as_return_status_t ret;
2391 uint32_t mask;
2392 cy_as_device *dev_p;
2393
2394 cy_as_log_debug_message(6, "cy_as_usb_read_data_async called");
2395
2396 dev_p = (cy_as_device *)handle;
2397 if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
2398 return CY_AS_ERROR_INVALID_HANDLE;
2399
2400 ret = is_usb_active(dev_p);
2401 if (ret != CY_AS_ERROR_SUCCESS)
2402 return ret;
2403
2404 if (ep >= 16 || ep == 4 || ep == 6 || ep == 8)
2405 return CY_AS_ERROR_INVALID_ENDPOINT;
2406
2407 /* EP2 is available for reading when MTP is active */
2408 if (dev_p->mtp_count == 0 && ep == CY_AS_MTP_READ_ENDPOINT)
2409 return CY_AS_ERROR_INVALID_ENDPOINT;
2410
2411 /* If the endpoint is disabled, we cannot
2412 * write data to the endpoint */
2413 if (!dev_p->usb_config[ep].enabled)
2414 return CY_AS_ERROR_ENDPOINT_DISABLED;
2415
2416 if (dev_p->usb_config[ep].dir != cy_as_usb_out &&
2417 dev_p->usb_config[ep].dir != cy_as_usb_in_out)
2418 return CY_AS_ERROR_USB_BAD_DIRECTION;
2419
2420 /*
2421 * since async operations can be triggered by interrupt
2422 * code, we must insure that we do not get multiple async
2423 * operations going at one time and protect this test and
2424 * set operation from interrupts.
2425 */
2426 mask = cy_as_hal_disable_interrupts();
2427 if (cy_as_device_is_usb_async_pending(dev_p, ep)) {
2428 cy_as_hal_enable_interrupts(mask);
2429 return CY_AS_ERROR_ASYNC_PENDING;
2430 }
2431 cy_as_device_set_usb_async_pending(dev_p, ep);
2432
2433 /*
2434 * if this is for EP0, we set this bit to delay the
2435 * ACK response until after this read has completed.
2436 */
2437 if (ep == 0)
2438 cy_as_device_set_ack_delayed(dev_p);
2439
2440 cy_as_hal_enable_interrupts(mask);
2441
2442 cy_as_hal_assert(dev_p->usb_cb[ep] == 0);
2443 dev_p->usb_cb[ep] = cb;
2444
2445 ret = cy_as_dma_queue_request(dev_p, ep, data, dsize,
2446 pktread, cy_true, async_read_request_callback);
2447 if (ret != CY_AS_ERROR_SUCCESS)
2448 return ret;
2449
2450 if (ep == CY_AS_MTP_READ_ENDPOINT) {
2451 ret = my_send_turbo_switch(dev_p, dsize, pktread);
2452 if (ret != CY_AS_ERROR_SUCCESS) {
2453 cy_as_dma_cancel(dev_p, ep, ret);
2454 return ret;
2455 }
2456 } else {
2457 /* Kick start the queue if it is not running */
2458 cy_as_dma_kick_start(dev_p, ep);
2459 }
2460 return ret;
2461 }
2462
2463 cy_as_return_status_t
2464 cy_as_usb_write_data(cy_as_device_handle handle,
2465 cy_as_end_point_number_t ep, uint32_t dsize, void *data)
2466 {
2467 cy_as_return_status_t ret;
2468 cy_as_device *dev_p;
2469
2470 cy_as_log_debug_message(6, "cy_as_usb_write_data called");
2471
2472 dev_p = (cy_as_device *)handle;
2473 if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
2474 return CY_AS_ERROR_INVALID_HANDLE;
2475
2476 ret = is_usb_active(dev_p);
2477 if (ret != CY_AS_ERROR_SUCCESS)
2478 return ret;
2479
2480 if (cy_as_device_is_in_callback(dev_p))
2481 return CY_AS_ERROR_INVALID_IN_CALLBACK;
2482
2483 if (ep >= 16 || ep == 2 || ep == 4 || ep == 8)
2484 return CY_AS_ERROR_INVALID_ENDPOINT;
2485
2486 /* EP6 is available for writing when MTP is active */
2487 if (dev_p->mtp_count == 0 && ep == CY_AS_MTP_WRITE_ENDPOINT)
2488 return CY_AS_ERROR_INVALID_ENDPOINT;
2489
2490 /* If the endpoint is disabled, we cannot
2491 * write data to the endpoint */
2492 if (!dev_p->usb_config[ep].enabled)
2493 return CY_AS_ERROR_ENDPOINT_DISABLED;
2494
2495 if (dev_p->usb_config[ep].dir != cy_as_usb_in &&
2496 dev_p->usb_config[ep].dir != cy_as_usb_in_out)
2497 return CY_AS_ERROR_USB_BAD_DIRECTION;
2498
2499 /* Write on Turbo endpoint */
2500 if (ep == CY_AS_MTP_WRITE_ENDPOINT) {
2501 cy_as_ll_request_response *req_p, *reply_p;
2502
2503 req_p = cy_as_ll_create_request(dev_p,
2504 CY_RQT_TURBO_SEND_RESP_DATA_TO_HOST,
2505 CY_RQT_TUR_RQT_CONTEXT, 3);
2506 if (req_p == 0)
2507 return CY_AS_ERROR_OUT_OF_MEMORY;
2508
2509 cy_as_ll_request_response__set_word(req_p,
2510 0, 0x0006); /* EP number to use. */
2511 cy_as_ll_request_response__set_word(req_p,
2512 1, (uint16_t)((dsize >> 16) & 0xFFFF));
2513 cy_as_ll_request_response__set_word(req_p,
2514 2, (uint16_t)(dsize & 0xFFFF));
2515
2516 /* Reserve space for the reply, the reply data
2517 * will not exceed one word */
2518 reply_p = cy_as_ll_create_response(dev_p, 1);
2519 if (reply_p == 0) {
2520 cy_as_ll_destroy_request(dev_p, req_p);
2521 return CY_AS_ERROR_OUT_OF_MEMORY;
2522 }
2523
2524 if (dsize) {
2525 ret = cy_as_dma_queue_request(dev_p,
2526 ep, data, dsize, cy_false,
2527 cy_false, sync_request_callback);
2528 if (ret != CY_AS_ERROR_SUCCESS)
2529 return ret;
2530 }
2531
2532 ret = cy_as_ll_send_request_wait_reply(dev_p, req_p, reply_p);
2533 if (ret == CY_AS_ERROR_SUCCESS) {
2534 if (cy_as_ll_request_response__get_code(reply_p) !=
2535 CY_RESP_SUCCESS_FAILURE)
2536 ret = CY_AS_ERROR_INVALID_RESPONSE;
2537 else
2538 ret = cy_as_ll_request_response__get_word
2539 (reply_p, 0);
2540 }
2541
2542 cy_as_ll_destroy_request(dev_p, req_p);
2543 cy_as_ll_destroy_response(dev_p, reply_p);
2544
2545 if (ret != CY_AS_ERROR_SUCCESS) {
2546 if (dsize)
2547 cy_as_dma_cancel(dev_p, ep, ret);
2548 return ret;
2549 }
2550
2551 /* If this is a zero-byte write, firmware will
2552 * handle it. there is no need to do any work here.
2553 */
2554 if (!dsize)
2555 return CY_AS_ERROR_SUCCESS;
2556 } else {
2557 ret = cy_as_dma_queue_request(dev_p, ep, data, dsize,
2558 cy_false, cy_false, sync_request_callback);
2559 if (ret != CY_AS_ERROR_SUCCESS)
2560 return ret;
2561 }
2562
2563 if (ep != CY_AS_MTP_WRITE_ENDPOINT)
2564 ret = cy_as_dma_drain_queue(dev_p, ep, cy_true);
2565 else
2566 ret = cy_as_dma_drain_queue(dev_p, ep, cy_false);
2567
2568 if (ret != CY_AS_ERROR_SUCCESS)
2569 return ret;
2570
2571 ret = dev_p->usb_error;
2572 return ret;
2573 }
2574
2575 static void
2576 mtp_write_callback(
2577 cy_as_device *dev_p,
2578 uint8_t context,
2579 cy_as_ll_request_response *rqt,
2580 cy_as_ll_request_response *resp,
2581 cy_as_return_status_t ret)
2582 {
2583 cy_as_usb_io_callback cb;
2584 cy_as_device_handle h = (cy_as_device_handle)dev_p;
2585
2586 cy_as_hal_assert(context == CY_RQT_TUR_RQT_CONTEXT);
2587
2588 if (ret == CY_AS_ERROR_SUCCESS) {
2589 if (cy_as_ll_request_response__get_code(resp) !=
2590 CY_RESP_SUCCESS_FAILURE)
2591 ret = CY_AS_ERROR_INVALID_RESPONSE;
2592 else
2593 ret = cy_as_ll_request_response__get_word(resp, 0);
2594 }
2595
2596 /* If this was a zero byte transfer request, we can
2597 * call the callback from here. */
2598 if ((cy_as_ll_request_response__get_word(rqt, 1) == 0) &&
2599 (cy_as_ll_request_response__get_word(rqt, 2) == 0)) {
2600 cb = dev_p->usb_cb[CY_AS_MTP_WRITE_ENDPOINT];
2601 dev_p->usb_cb[CY_AS_MTP_WRITE_ENDPOINT] = 0;
2602 cy_as_device_clear_usb_async_pending(dev_p,
2603 CY_AS_MTP_WRITE_ENDPOINT);
2604 if (cb)
2605 cb(h, CY_AS_MTP_WRITE_ENDPOINT, 0, 0, ret);
2606
2607 goto destroy;
2608 }
2609
2610 if (ret != CY_AS_ERROR_SUCCESS) {
2611 /* Firmware failed the request. Cancel the DMA transfer. */
2612 cy_as_dma_cancel(dev_p, 0x06, CY_AS_ERROR_CANCELED);
2613 dev_p->usb_cb[0x06] = 0;
2614 cy_as_device_clear_usb_async_pending(dev_p, 0x06);
2615 }
2616
2617 destroy:
2618 cy_as_ll_destroy_response(dev_p, resp);
2619 cy_as_ll_destroy_request(dev_p, rqt);
2620 }
2621
2622 cy_as_return_status_t
2623 cy_as_usb_write_data_async(cy_as_device_handle handle,
2624 cy_as_end_point_number_t ep, uint32_t dsize, void *data,
2625 cy_bool spacket, cy_as_usb_io_callback cb)
2626 {
2627 uint32_t mask;
2628 cy_as_return_status_t ret;
2629 cy_as_device *dev_p;
2630
2631 cy_as_log_debug_message(6, "cy_as_usb_write_data_async called");
2632
2633 dev_p = (cy_as_device *)handle;
2634 if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
2635 return CY_AS_ERROR_INVALID_HANDLE;
2636
2637 ret = is_usb_active(dev_p);
2638 if (ret != CY_AS_ERROR_SUCCESS)
2639 return ret;
2640
2641 if (ep >= 16 || ep == 2 || ep == 4 || ep == 8)
2642 return CY_AS_ERROR_INVALID_ENDPOINT;
2643
2644 /* EP6 is available for writing when MTP is active */
2645 if (dev_p->mtp_count == 0 && ep == CY_AS_MTP_WRITE_ENDPOINT)
2646 return CY_AS_ERROR_INVALID_ENDPOINT;
2647
2648 /* If the endpoint is disabled, we cannot
2649 * write data to the endpoint */
2650 if (!dev_p->usb_config[ep].enabled)
2651 return CY_AS_ERROR_ENDPOINT_DISABLED;
2652
2653 if (dev_p->usb_config[ep].dir != cy_as_usb_in &&
2654 dev_p->usb_config[ep].dir != cy_as_usb_in_out)
2655 return CY_AS_ERROR_USB_BAD_DIRECTION;
2656
2657 /*
2658 * since async operations can be triggered by interrupt
2659 * code, we must insure that we do not get multiple
2660 * async operations going at one time and
2661 * protect this test and set operation from interrupts.
2662 */
2663 mask = cy_as_hal_disable_interrupts();
2664 if (cy_as_device_is_usb_async_pending(dev_p, ep)) {
2665 cy_as_hal_enable_interrupts(mask);
2666 return CY_AS_ERROR_ASYNC_PENDING;
2667 }
2668
2669 cy_as_device_set_usb_async_pending(dev_p, ep);
2670
2671 if (ep == 0)
2672 cy_as_device_set_ack_delayed(dev_p);
2673
2674 cy_as_hal_enable_interrupts(mask);
2675
2676 cy_as_hal_assert(dev_p->usb_cb[ep] == 0);
2677 dev_p->usb_cb[ep] = cb;
2678 dev_p->usb_spacket[ep] = spacket;
2679
2680 /* Write on Turbo endpoint */
2681 if (ep == CY_AS_MTP_WRITE_ENDPOINT) {
2682 cy_as_ll_request_response *req_p, *reply_p;
2683
2684 req_p = cy_as_ll_create_request(dev_p,
2685 CY_RQT_TURBO_SEND_RESP_DATA_TO_HOST,
2686 CY_RQT_TUR_RQT_CONTEXT, 3);
2687
2688 if (req_p == 0)
2689 return CY_AS_ERROR_OUT_OF_MEMORY;
2690
2691 cy_as_ll_request_response__set_word(req_p, 0,
2692 0x0006); /* EP number to use. */
2693 cy_as_ll_request_response__set_word(req_p, 1,
2694 (uint16_t)((dsize >> 16) & 0xFFFF));
2695 cy_as_ll_request_response__set_word(req_p, 2,
2696 (uint16_t)(dsize & 0xFFFF));
2697
2698 /* Reserve space for the reply, the reply data
2699 * will not exceed one word */
2700 reply_p = cy_as_ll_create_response(dev_p, 1);
2701 if (reply_p == 0) {
2702 cy_as_ll_destroy_request(dev_p, req_p);
2703 return CY_AS_ERROR_OUT_OF_MEMORY;
2704 }
2705
2706 if (dsize) {
2707 ret = cy_as_dma_queue_request(dev_p, ep, data,
2708 dsize, cy_false, cy_false,
2709 async_write_request_callback);
2710 if (ret != CY_AS_ERROR_SUCCESS)
2711 return ret;
2712 }
2713
2714 ret = cy_as_ll_send_request(dev_p, req_p, reply_p,
2715 cy_false, mtp_write_callback);
2716 if (ret != CY_AS_ERROR_SUCCESS) {
2717 if (dsize)
2718 cy_as_dma_cancel(dev_p, ep, ret);
2719 return ret;
2720 }
2721
2722 /* Firmware will handle a zero byte transfer
2723 * without any DMA transfers. */
2724 if (!dsize)
2725 return CY_AS_ERROR_SUCCESS;
2726 } else {
2727 ret = cy_as_dma_queue_request(dev_p, ep, data, dsize,
2728 cy_false, cy_false, async_write_request_callback);
2729 if (ret != CY_AS_ERROR_SUCCESS)
2730 return ret;
2731 }
2732
2733 /* Kick start the queue if it is not running */
2734 if (ep != CY_AS_MTP_WRITE_ENDPOINT)
2735 cy_as_dma_kick_start(dev_p, ep);
2736
2737 return CY_AS_ERROR_SUCCESS;
2738 }
2739
2740 static void
2741 my_usb_cancel_async_callback(
2742 cy_as_device *dev_p,
2743 uint8_t context,
2744 cy_as_ll_request_response *rqt,
2745 cy_as_ll_request_response *resp,
2746 cy_as_return_status_t ret)
2747 {
2748 uint8_t ep;
2749 (void)context;
2750
2751 ep = (uint8_t)cy_as_ll_request_response__get_word(rqt, 0);
2752 if (ret == CY_AS_ERROR_SUCCESS) {
2753 if (cy_as_ll_request_response__get_code(resp) !=
2754 CY_RESP_SUCCESS_FAILURE)
2755 ret = CY_AS_ERROR_INVALID_RESPONSE;
2756 else
2757 ret = cy_as_ll_request_response__get_word(resp, 0);
2758 }
2759
2760 cy_as_ll_destroy_request(dev_p, rqt);
2761 cy_as_ll_destroy_response(dev_p, resp);
2762
2763 if (ret == CY_AS_ERROR_SUCCESS) {
2764 cy_as_dma_cancel(dev_p, ep, CY_AS_ERROR_CANCELED);
2765 dev_p->usb_cb[ep] = 0;
2766 cy_as_device_clear_usb_async_pending(dev_p, ep);
2767 }
2768 }
2769
2770 cy_as_return_status_t
2771 cy_as_usb_cancel_async(cy_as_device_handle handle,
2772 cy_as_end_point_number_t ep)
2773 {
2774 cy_as_return_status_t ret;
2775 cy_as_ll_request_response *req_p, *reply_p;
2776
2777 cy_as_device *dev_p = (cy_as_device *)handle;
2778 if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
2779 return CY_AS_ERROR_INVALID_HANDLE;
2780
2781 ep &= 0x7F; /* Remove the direction bit. */
2782 if (!cy_as_device_is_usb_async_pending(dev_p, ep))
2783 return CY_AS_ERROR_ASYNC_NOT_PENDING;
2784
2785 ret = is_usb_active(dev_p);
2786 if (ret != CY_AS_ERROR_SUCCESS)
2787 return ret;
2788
2789 if (cy_as_device_is_in_suspend_mode(dev_p))
2790 return CY_AS_ERROR_IN_SUSPEND;
2791
2792 if ((ep == CY_AS_MTP_WRITE_ENDPOINT) ||
2793 (ep == CY_AS_MTP_READ_ENDPOINT)) {
2794 /* Need firmware support for the cancel operation. */
2795 req_p = cy_as_ll_create_request(dev_p,
2796 CY_RQT_CANCEL_ASYNC_TRANSFER,
2797 CY_RQT_TUR_RQT_CONTEXT, 1);
2798
2799 if (req_p == 0)
2800 return CY_AS_ERROR_OUT_OF_MEMORY;
2801
2802 reply_p = cy_as_ll_create_response(dev_p, 1);
2803 if (reply_p == 0) {
2804 cy_as_ll_destroy_request(dev_p, req_p);
2805 return CY_AS_ERROR_OUT_OF_MEMORY;
2806 }
2807
2808 cy_as_ll_request_response__set_word(req_p, 0,
2809 (uint16_t)ep);
2810
2811 ret = cy_as_ll_send_request(dev_p, req_p, reply_p,
2812 cy_false, my_usb_cancel_async_callback);
2813
2814 if (ret != CY_AS_ERROR_SUCCESS) {
2815 cy_as_ll_destroy_request(dev_p, req_p);
2816 cy_as_ll_destroy_response(dev_p, reply_p);
2817 return ret;
2818 }
2819 } else {
2820 ret = cy_as_dma_cancel(dev_p, ep, CY_AS_ERROR_CANCELED);
2821 if (ret != CY_AS_ERROR_SUCCESS)
2822 return ret;
2823
2824 dev_p->usb_cb[ep] = 0;
2825 cy_as_device_clear_usb_async_pending(dev_p, ep);
2826 }
2827
2828 return CY_AS_ERROR_SUCCESS;
2829 }
2830
2831 static void
2832 cy_as_usb_ack_callback(
2833 cy_as_device *dev_p,
2834 uint8_t context,
2835 cy_as_ll_request_response *rqt,
2836 cy_as_ll_request_response *resp,
2837 cy_as_return_status_t ret)
2838 {
2839 cy_as_func_c_b_node *node = (cy_as_func_c_b_node *)
2840 dev_p->func_cbs_usb->head_p;
2841
2842 (void)context;
2843
2844 if (ret == CY_AS_ERROR_SUCCESS) {
2845 if (cy_as_ll_request_response__get_code(resp) !=
2846 CY_RESP_SUCCESS_FAILURE)
2847 ret = CY_AS_ERROR_INVALID_RESPONSE;
2848 else
2849 ret = cy_as_ll_request_response__get_word(resp, 0);
2850 }
2851
2852 node->cb_p((cy_as_device_handle)dev_p, ret,
2853 node->client_data, node->data_type, node->data);
2854 cy_as_remove_c_b_node(dev_p->func_cbs_usb);
2855
2856 cy_as_ll_destroy_request(dev_p, rqt);
2857 cy_as_ll_destroy_response(dev_p, resp);
2858 cy_as_device_clear_ack_delayed(dev_p);
2859 }
2860
2861 static cy_as_return_status_t
2862 cy_as_usb_ack_setup_packet(cy_as_device_handle handle,
2863 cy_as_function_callback cb,
2864 uint32_t client)
2865 {
2866 cy_as_return_status_t ret;
2867 cy_as_ll_request_response *req_p;
2868 cy_as_ll_request_response *reply_p;
2869 cy_as_func_c_b_node *cbnode;
2870
2871 cy_as_device *dev_p = (cy_as_device *)handle;
2872 if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
2873 return CY_AS_ERROR_INVALID_HANDLE;
2874
2875 ret = is_usb_active(dev_p);
2876 if (ret != CY_AS_ERROR_SUCCESS)
2877 return ret;
2878
2879 if (cy_as_device_is_in_callback(dev_p) && cb == 0)
2880 return CY_AS_ERROR_INVALID_IN_CALLBACK;
2881
2882 cy_as_hal_assert(cb != 0);
2883
2884 cbnode = cy_as_create_func_c_b_node(cb, client);
2885 if (cbnode == 0)
2886 return CY_AS_ERROR_OUT_OF_MEMORY;
2887
2888 req_p = cy_as_ll_create_request(dev_p, 0,
2889 CY_RQT_USB_RQT_CONTEXT, 2);
2890 if (req_p == 0)
2891 return CY_AS_ERROR_OUT_OF_MEMORY;
2892
2893 reply_p = cy_as_ll_create_response(dev_p, 1);
2894 if (reply_p == 0) {
2895 cy_as_ll_destroy_request(dev_p, req_p);
2896 return CY_AS_ERROR_OUT_OF_MEMORY;
2897 }
2898
2899 cy_as_ll_init_request(req_p, CY_RQT_ACK_SETUP_PACKET,
2900 CY_RQT_USB_RQT_CONTEXT, 1);
2901 cy_as_ll_init_response(reply_p, 1);
2902
2903 req_p->flags |= CY_AS_REQUEST_RESPONSE_EX;
2904
2905 cy_as_insert_c_b_node(dev_p->func_cbs_usb, cbnode);
2906
2907 ret = cy_as_ll_send_request(dev_p, req_p, reply_p,
2908 cy_false, cy_as_usb_ack_callback);
2909
2910 return ret;
2911 }
2912
2913 /*
2914 * Flush all data in logical EP that is being NAK-ed or
2915 * Stall-ed, so that this does not continue to block data
2916 * on other LEPs that use the same physical EP.
2917 */
2918 static void
2919 cy_as_usb_flush_logical_e_p(
2920 cy_as_device *dev_p,
2921 uint16_t ep)
2922 {
2923 uint16_t addr, val, count;
2924
2925 addr = CY_AS_MEM_P0_EP2_DMA_REG + ep - 2;
2926 val = cy_as_hal_read_register(dev_p->tag, addr);
2927
2928 while (val) {
2929 count = ((val & 0xFFF) + 1) / 2;
2930 while (count--)
2931 val = cy_as_hal_read_register(dev_p->tag, ep);
2932
2933 cy_as_hal_write_register(dev_p->tag, addr, 0);
2934 val = cy_as_hal_read_register(dev_p->tag, addr);
2935 }
2936 }
2937
2938 static cy_as_return_status_t
2939 cy_as_usb_nak_stall_request(cy_as_device_handle handle,
2940 cy_as_end_point_number_t ep,
2941 uint16_t request,
2942 cy_bool state,
2943 cy_as_usb_function_callback cb,
2944 cy_as_function_callback fcb,
2945 uint32_t client)
2946 {
2947 cy_as_return_status_t ret;
2948 cy_as_ll_request_response *req_p , *reply_p;
2949 uint16_t data;
2950
2951 cy_as_device *dev_p = (cy_as_device *)handle;
2952 if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
2953 return CY_AS_ERROR_INVALID_HANDLE;
2954
2955 if (cb)
2956 cy_as_hal_assert(fcb == 0);
2957 if (fcb)
2958 cy_as_hal_assert(cb == 0);
2959
2960 ret = is_usb_active(dev_p);
2961 if (ret != CY_AS_ERROR_SUCCESS)
2962 return ret;
2963
2964 if (cy_as_device_is_in_callback(dev_p) && cb == 0 && fcb == 0)
2965 return CY_AS_ERROR_INVALID_IN_CALLBACK;
2966
2967 req_p = cy_as_ll_create_request(dev_p,
2968 request, CY_RQT_USB_RQT_CONTEXT, 2);
2969 if (req_p == 0)
2970 return CY_AS_ERROR_OUT_OF_MEMORY;
2971
2972 /* A single status word response type */
2973 reply_p = cy_as_ll_create_response(dev_p, 1);
2974 if (reply_p == 0) {
2975 cy_as_ll_destroy_request(dev_p, req_p);
2976 return CY_AS_ERROR_OUT_OF_MEMORY;
2977 }
2978
2979 /* Set the endpoint */
2980 data = (uint8_t)ep;
2981 cy_as_ll_request_response__set_word(req_p, 0, data);
2982
2983 /* Set stall state to stalled */
2984 cy_as_ll_request_response__set_word(req_p, 1, (uint8_t)state);
2985
2986 if (cb || fcb) {
2987 void *cbnode;
2988 cy_as_c_b_queue *queue;
2989 if (cb) {
2990 cbnode = cy_as_create_usb_func_c_b_node(cb, client);
2991 queue = dev_p->usb_func_cbs;
2992 } else {
2993 cbnode = cy_as_create_func_c_b_node(fcb, client);
2994 queue = dev_p->func_cbs_usb;
2995 req_p->flags |= CY_AS_REQUEST_RESPONSE_EX;
2996 }
2997
2998 if (cbnode == 0) {
2999 ret = CY_AS_ERROR_OUT_OF_MEMORY;
3000 goto destroy;
3001 } else
3002 cy_as_insert_c_b_node(queue, cbnode);
3003
3004
3005 if (cy_as_device_is_setup_packet(dev_p)) {
3006 /* No Ack is needed on a stall request on EP0 */
3007 if ((state == cy_true) && (ep == 0)) {
3008 cy_as_device_set_ep0_stalled(dev_p);
3009 } else {
3010 cy_as_device_set_ack_delayed(dev_p);
3011 req_p->flags |=
3012 CY_AS_REQUEST_RESPONSE_DELAY_ACK;
3013 }
3014 }
3015
3016 ret = cy_as_ll_send_request(dev_p, req_p,
3017 reply_p, cy_false, cy_as_usb_func_callback);
3018 if (ret != CY_AS_ERROR_SUCCESS) {
3019 if (req_p->flags & CY_AS_REQUEST_RESPONSE_DELAY_ACK)
3020 cy_as_device_rem_ack_delayed(dev_p);
3021 cy_as_remove_c_b_tail_node(queue);
3022
3023 goto destroy;
3024 }
3025 } else {
3026 ret = cy_as_ll_send_request_wait_reply(dev_p,
3027 req_p, reply_p);
3028 if (ret != CY_AS_ERROR_SUCCESS)
3029 goto destroy;
3030
3031 if (cy_as_ll_request_response__get_code(reply_p) !=
3032 CY_RESP_SUCCESS_FAILURE) {
3033 ret = CY_AS_ERROR_INVALID_RESPONSE;
3034 goto destroy;
3035 }
3036
3037 ret = cy_as_ll_request_response__get_word(reply_p, 0);
3038
3039 if ((ret == CY_AS_ERROR_SUCCESS) &&
3040 (request == CY_RQT_STALL_ENDPOINT)) {
3041 if ((ep > 1) && (state != 0) &&
3042 (dev_p->usb_config[ep].dir == cy_as_usb_out))
3043 cy_as_usb_flush_logical_e_p(dev_p, ep);
3044 }
3045
3046 destroy:
3047 cy_as_ll_destroy_request(dev_p, req_p);
3048 cy_as_ll_destroy_response(dev_p, reply_p);
3049 }
3050
3051 return ret;
3052 }
3053
3054 static cy_as_return_status_t
3055 my_handle_response_get_stall(cy_as_device *dev_p,
3056 cy_as_ll_request_response *req_p,
3057 cy_as_ll_request_response *reply_p,
3058 cy_bool *state_p)
3059 {
3060 cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS;
3061 uint8_t code = cy_as_ll_request_response__get_code(reply_p);
3062
3063 if (code == CY_RESP_SUCCESS_FAILURE) {
3064 ret = cy_as_ll_request_response__get_word(reply_p, 0);
3065 goto destroy;
3066 } else if (code != CY_RESP_ENDPOINT_STALL) {
3067 ret = CY_AS_ERROR_INVALID_RESPONSE;
3068 goto destroy;
3069 }
3070
3071 *state_p = (cy_bool)cy_as_ll_request_response__get_word(reply_p, 0);
3072 ret = CY_AS_ERROR_SUCCESS;
3073
3074
3075 destroy:
3076 cy_as_ll_destroy_request(dev_p, req_p);
3077 cy_as_ll_destroy_response(dev_p, reply_p);
3078
3079 return ret;
3080 }
3081
3082 static cy_as_return_status_t
3083 my_handle_response_get_nak(cy_as_device *dev_p,
3084 cy_as_ll_request_response *req_p,
3085 cy_as_ll_request_response *reply_p,
3086 cy_bool *state_p)
3087 {
3088 cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS;
3089 uint8_t code = cy_as_ll_request_response__get_code(reply_p);
3090
3091 if (code == CY_RESP_SUCCESS_FAILURE) {
3092 ret = cy_as_ll_request_response__get_word(reply_p, 0);
3093 goto destroy;
3094 } else if (code != CY_RESP_ENDPOINT_NAK) {
3095 ret = CY_AS_ERROR_INVALID_RESPONSE;
3096 goto destroy;
3097 }
3098
3099 *state_p = (cy_bool)cy_as_ll_request_response__get_word(reply_p, 0);
3100 ret = CY_AS_ERROR_SUCCESS;
3101
3102
3103 destroy:
3104 cy_as_ll_destroy_request(dev_p, req_p);
3105 cy_as_ll_destroy_response(dev_p, reply_p);
3106
3107 return ret;
3108 }
3109
3110 static cy_as_return_status_t
3111 cy_as_usb_get_nak_stall(cy_as_device_handle handle,
3112 cy_as_end_point_number_t ep,
3113 uint16_t request,
3114 uint16_t response,
3115 cy_bool *state_p,
3116 cy_as_function_callback cb,
3117 uint32_t client)
3118 {
3119 cy_as_return_status_t ret;
3120 cy_as_ll_request_response *req_p , *reply_p;
3121 uint16_t data;
3122
3123 cy_as_device *dev_p = (cy_as_device *)handle;
3124
3125 (void)response;
3126
3127 if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
3128 return CY_AS_ERROR_INVALID_HANDLE;
3129
3130 ret = is_usb_active(dev_p);
3131 if (ret != CY_AS_ERROR_SUCCESS)
3132 return ret;
3133
3134 if (cy_as_device_is_in_callback(dev_p) && !cb)
3135 return CY_AS_ERROR_INVALID_IN_CALLBACK;
3136
3137 req_p = cy_as_ll_create_request(dev_p, request,
3138 CY_RQT_USB_RQT_CONTEXT, 1);
3139 if (req_p == 0)
3140 return CY_AS_ERROR_OUT_OF_MEMORY;
3141
3142 /* Set the endpoint */
3143 data = (uint8_t)ep;
3144 cy_as_ll_request_response__set_word(req_p, 0, (uint16_t)ep);
3145
3146 /* A single status word response type */
3147 reply_p = cy_as_ll_create_response(dev_p, 1);
3148 if (reply_p == 0) {
3149 cy_as_ll_destroy_request(dev_p, req_p);
3150 return CY_AS_ERROR_OUT_OF_MEMORY;
3151 }
3152
3153 if (cb == 0) {
3154 ret = cy_as_ll_send_request_wait_reply(dev_p,
3155 req_p, reply_p);
3156 if (ret != CY_AS_ERROR_SUCCESS)
3157 goto destroy;
3158
3159 if (request == CY_RQT_GET_STALL)
3160 return my_handle_response_get_stall(dev_p,
3161 req_p, reply_p, state_p);
3162 else
3163 return my_handle_response_get_nak(dev_p,
3164 req_p, reply_p, state_p);
3165
3166 } else {
3167 cy_as_funct_c_b_type type;
3168
3169 if (request == CY_RQT_GET_STALL)
3170 type = CY_FUNCT_CB_USB_GETSTALL;
3171 else
3172 type = CY_FUNCT_CB_USB_GETNAK;
3173
3174 ret = cy_as_misc_send_request(dev_p, cb, client, type,
3175 state_p, dev_p->func_cbs_usb, CY_AS_REQUEST_RESPONSE_EX,
3176 req_p, reply_p, cy_as_usb_func_callback);
3177
3178 if (ret != CY_AS_ERROR_SUCCESS)
3179 goto destroy;
3180
3181 return ret;
3182 }
3183
3184 destroy:
3185 cy_as_ll_destroy_request(dev_p, req_p);
3186 cy_as_ll_destroy_response(dev_p, reply_p);
3187
3188 return ret;
3189 }
3190
3191 cy_as_return_status_t
3192 cy_as_usb_set_nak(cy_as_device_handle handle,
3193 cy_as_end_point_number_t ep,
3194 cy_as_function_callback cb,
3195 uint32_t client)
3196 {
3197 cy_as_device *dev_p = (cy_as_device *)handle;
3198 if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
3199 return CY_AS_ERROR_INVALID_HANDLE;
3200
3201 /*
3202 * we send the firmware the EP# with the appropriate direction
3203 * bit, regardless of what the user gave us.
3204 */
3205 ep &= 0x0f;
3206 if (dev_p->usb_config[ep].dir == cy_as_usb_in)
3207 ep |= 0x80;
3208
3209 if (dev_p->mtp_count > 0)
3210 return CY_AS_ERROR_NOT_VALID_IN_MTP;
3211
3212 return cy_as_usb_nak_stall_request(handle, ep,
3213 CY_RQT_ENDPOINT_SET_NAK, cy_true, 0, cb, client);
3214 }
3215
3216
3217 cy_as_return_status_t
3218 cy_as_usb_clear_nak(cy_as_device_handle handle,
3219 cy_as_end_point_number_t ep,
3220 cy_as_function_callback cb,
3221 uint32_t client)
3222 {
3223 cy_as_device *dev_p = (cy_as_device *)handle;
3224 if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
3225 return CY_AS_ERROR_INVALID_HANDLE;
3226
3227 /*
3228 * we send the firmware the EP# with the appropriate
3229 * direction bit, regardless of what the user gave us.
3230 */
3231 ep &= 0x0f;
3232 if (dev_p->usb_config[ep].dir == cy_as_usb_in)
3233 ep |= 0x80;
3234
3235 if (dev_p->mtp_count > 0)
3236 return CY_AS_ERROR_NOT_VALID_IN_MTP;
3237
3238 return cy_as_usb_nak_stall_request(handle, ep,
3239 CY_RQT_ENDPOINT_SET_NAK, cy_false, 0, cb, client);
3240 }
3241
3242 cy_as_return_status_t
3243 cy_as_usb_get_nak(cy_as_device_handle handle,
3244 cy_as_end_point_number_t ep,
3245 cy_bool *nak_p,
3246 cy_as_function_callback cb,
3247 uint32_t client)
3248 {
3249 cy_as_device *dev_p = (cy_as_device *)handle;
3250 if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
3251 return CY_AS_ERROR_INVALID_HANDLE;
3252
3253 /*
3254 * we send the firmware the EP# with the appropriate
3255 * direction bit, regardless of what the user gave us.
3256 */
3257 ep &= 0x0f;
3258 if (dev_p->usb_config[ep].dir == cy_as_usb_in)
3259 ep |= 0x80;
3260
3261 if (dev_p->mtp_count > 0)
3262 return CY_AS_ERROR_NOT_VALID_IN_MTP;
3263
3264 return cy_as_usb_get_nak_stall(handle, ep,
3265 CY_RQT_GET_ENDPOINT_NAK, CY_RESP_ENDPOINT_NAK,
3266 nak_p, cb, client);
3267 }
3268
3269
3270 cy_as_return_status_t
3271 cy_as_usb_set_stall(cy_as_device_handle handle,
3272 cy_as_end_point_number_t ep,
3273 cy_as_function_callback cb,
3274 uint32_t client)
3275 {
3276 cy_as_device *dev_p = (cy_as_device *)handle;
3277 if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
3278 return CY_AS_ERROR_INVALID_HANDLE;
3279
3280 /*
3281 * we send the firmware the EP# with the appropriate
3282 * direction bit, regardless of what the user gave us.
3283 */
3284 ep &= 0x0f;
3285 if (dev_p->usb_config[ep].dir == cy_as_usb_in)
3286 ep |= 0x80;
3287
3288 if (dev_p->mtp_turbo_active)
3289 return CY_AS_ERROR_NOT_VALID_DURING_MTP;
3290
3291 return cy_as_usb_nak_stall_request(handle, ep,
3292 CY_RQT_STALL_ENDPOINT, cy_true, 0, cb, client);
3293 }
3294
3295 cy_as_return_status_t
3296 cy_as_usb_clear_stall(cy_as_device_handle handle,
3297 cy_as_end_point_number_t ep,
3298 cy_as_function_callback cb,
3299 uint32_t client)
3300 {
3301 cy_as_device *dev_p = (cy_as_device *)handle;
3302 if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
3303 return CY_AS_ERROR_INVALID_HANDLE;
3304
3305 /*
3306 * we send the firmware the EP# with the appropriate
3307 * direction bit, regardless of what the user gave us.
3308 */
3309 ep &= 0x0f;
3310 if (dev_p->usb_config[ep].dir == cy_as_usb_in)
3311 ep |= 0x80;
3312
3313 if (dev_p->mtp_turbo_active)
3314 return CY_AS_ERROR_NOT_VALID_DURING_MTP;
3315
3316 return cy_as_usb_nak_stall_request(handle, ep,
3317 CY_RQT_STALL_ENDPOINT, cy_false, 0, cb, client);
3318 }
3319
3320 cy_as_return_status_t
3321 cy_as_usb_get_stall(cy_as_device_handle handle,
3322 cy_as_end_point_number_t ep,
3323 cy_bool *stall_p,
3324 cy_as_function_callback cb,
3325 uint32_t client)
3326 {
3327 cy_as_device *dev_p = (cy_as_device *)handle;
3328 if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
3329 return CY_AS_ERROR_INVALID_HANDLE;
3330
3331 /*
3332 * we send the firmware the EP# with the appropriate
3333 * direction bit, regardless of what the user gave us.
3334 */
3335 ep &= 0x0f;
3336 if (dev_p->usb_config[ep].dir == cy_as_usb_in)
3337 ep |= 0x80;
3338
3339 if (dev_p->mtp_turbo_active)
3340 return CY_AS_ERROR_NOT_VALID_DURING_MTP;
3341
3342 return cy_as_usb_get_nak_stall(handle, ep,
3343 CY_RQT_GET_STALL, CY_RESP_ENDPOINT_STALL, stall_p, cb, client);
3344 }
3345
3346 cy_as_return_status_t
3347 cy_as_usb_signal_remote_wakeup(cy_as_device_handle handle,
3348 cy_as_function_callback cb,
3349 uint32_t client)
3350 {
3351 cy_as_return_status_t ret;
3352 cy_as_ll_request_response *req_p , *reply_p;
3353
3354 cy_as_device *dev_p = (cy_as_device *)handle;
3355 if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
3356 return CY_AS_ERROR_INVALID_HANDLE;
3357
3358 ret = is_usb_active(dev_p);
3359 if (ret != CY_AS_ERROR_SUCCESS)
3360 return ret;
3361
3362 if (cy_as_device_is_in_callback(dev_p))
3363 return CY_AS_ERROR_INVALID_IN_CALLBACK;
3364
3365 if (dev_p->usb_last_event != cy_as_event_usb_suspend)
3366 return CY_AS_ERROR_NOT_IN_SUSPEND;
3367
3368 req_p = cy_as_ll_create_request(dev_p,
3369 CY_RQT_USB_REMOTE_WAKEUP, CY_RQT_USB_RQT_CONTEXT, 0);
3370 if (req_p == 0)
3371 return CY_AS_ERROR_OUT_OF_MEMORY;
3372
3373 /* A single status word response type */
3374 reply_p = cy_as_ll_create_response(dev_p, 1);
3375 if (reply_p == 0) {
3376 cy_as_ll_destroy_request(dev_p, req_p);
3377 return CY_AS_ERROR_OUT_OF_MEMORY;
3378 }
3379
3380 if (cb == 0) {
3381 ret = cy_as_ll_send_request_wait_reply(dev_p, req_p, reply_p);
3382 if (ret != CY_AS_ERROR_SUCCESS)
3383 goto destroy;
3384
3385 if (cy_as_ll_request_response__get_code(reply_p) ==
3386 CY_RESP_SUCCESS_FAILURE)
3387 ret = cy_as_ll_request_response__get_word(reply_p, 0);
3388 else
3389 ret = CY_AS_ERROR_INVALID_RESPONSE;
3390 } else {
3391 ret = cy_as_misc_send_request(dev_p, cb, client,
3392 CY_FUNCT_CB_USB_SIGNALREMOTEWAKEUP, 0,
3393 dev_p->func_cbs_usb,
3394 CY_AS_REQUEST_RESPONSE_EX, req_p,
3395 reply_p, cy_as_usb_func_callback);
3396
3397 if (ret != CY_AS_ERROR_SUCCESS)
3398 goto destroy;
3399 return ret;
3400 }
3401
3402 destroy:
3403 cy_as_ll_destroy_request(dev_p, req_p);
3404 cy_as_ll_destroy_response(dev_p, reply_p);
3405
3406 return ret;
3407 }
3408
3409 cy_as_return_status_t
3410 cy_as_usb_set_m_s_report_threshold(cy_as_device_handle handle,
3411 uint32_t wr_sectors,
3412 uint32_t rd_sectors,
3413 cy_as_function_callback cb,
3414 uint32_t client)
3415 {
3416 cy_as_return_status_t ret;
3417 cy_as_ll_request_response *req_p , *reply_p;
3418
3419 cy_as_device *dev_p = (cy_as_device *)handle;
3420 if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
3421 return CY_AS_ERROR_INVALID_HANDLE;
3422
3423 ret = is_usb_active(dev_p);
3424 if (ret != CY_AS_ERROR_SUCCESS)
3425 return ret;
3426
3427 if ((cb == 0) && (cy_as_device_is_in_callback(dev_p)))
3428 return CY_AS_ERROR_INVALID_IN_CALLBACK;
3429
3430 /* Check if the firmware version supports this feature. */
3431 if ((dev_p->media_supported[0]) && (dev_p->media_supported[0] ==
3432 (1 << cy_as_media_nand)))
3433 return CY_AS_ERROR_NOT_SUPPORTED;
3434
3435 req_p = cy_as_ll_create_request(dev_p, CY_RQT_USB_STORAGE_MONITOR,
3436 CY_RQT_USB_RQT_CONTEXT, 4);
3437 if (req_p == 0)
3438 return CY_AS_ERROR_OUT_OF_MEMORY;
3439
3440 /* A single status word response type */
3441 reply_p = cy_as_ll_create_response(dev_p, 1);
3442 if (reply_p == 0) {
3443 cy_as_ll_destroy_request(dev_p, req_p);
3444 return CY_AS_ERROR_OUT_OF_MEMORY;
3445 }
3446
3447 /* Set the read and write count parameters into
3448 * the request structure. */
3449 cy_as_ll_request_response__set_word(req_p, 0,
3450 (uint16_t)((wr_sectors >> 16) & 0xFFFF));
3451 cy_as_ll_request_response__set_word(req_p, 1,
3452 (uint16_t)(wr_sectors & 0xFFFF));
3453 cy_as_ll_request_response__set_word(req_p, 2,
3454 (uint16_t)((rd_sectors >> 16) & 0xFFFF));
3455 cy_as_ll_request_response__set_word(req_p, 3,
3456 (uint16_t)(rd_sectors & 0xFFFF));
3457
3458 if (cb == 0) {
3459 ret = cy_as_ll_send_request_wait_reply(dev_p, req_p, reply_p);
3460 if (ret != CY_AS_ERROR_SUCCESS)
3461 goto destroy;
3462
3463 if (cy_as_ll_request_response__get_code(reply_p) ==
3464 CY_RESP_SUCCESS_FAILURE)
3465 ret = cy_as_ll_request_response__get_word(reply_p, 0);
3466 else
3467 ret = CY_AS_ERROR_INVALID_RESPONSE;
3468 } else {
3469 ret = cy_as_misc_send_request(dev_p, cb, client,
3470 CY_FUNCT_CB_USB_SET_MSREPORT_THRESHOLD, 0,
3471 dev_p->func_cbs_usb, CY_AS_REQUEST_RESPONSE_EX,
3472 req_p, reply_p, cy_as_usb_func_callback);
3473
3474 if (ret != CY_AS_ERROR_SUCCESS)
3475 goto destroy;
3476 return ret;
3477 }
3478
3479 destroy:
3480 cy_as_ll_destroy_request(dev_p, req_p);
3481 cy_as_ll_destroy_response(dev_p, reply_p);
3482
3483 return ret;
3484 }
3485
3486 cy_as_return_status_t
3487 cy_as_usb_select_m_s_partitions(
3488 cy_as_device_handle handle,
3489 cy_as_bus_number_t bus,
3490 uint32_t device,
3491 cy_as_usb_m_s_type_t type,
3492 cy_as_function_callback cb,
3493 uint32_t client)
3494 {
3495 cy_as_return_status_t ret;
3496 cy_as_ll_request_response *req_p , *reply_p;
3497 uint16_t val;
3498
3499 cy_as_device *dev_p = (cy_as_device *)handle;
3500 if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
3501 return CY_AS_ERROR_INVALID_HANDLE;
3502
3503 ret = is_usb_active(dev_p);
3504 if (ret != CY_AS_ERROR_SUCCESS)
3505 return ret;
3506
3507 /* This API has to be made before SetEnumConfig is called. */
3508 if (dev_p->usb_config[0].enabled)
3509 return CY_AS_ERROR_INVALID_CALL_SEQUENCE;
3510
3511 if ((cb == 0) && (cy_as_device_is_in_callback(dev_p)))
3512 return CY_AS_ERROR_INVALID_IN_CALLBACK;
3513
3514 req_p = cy_as_ll_create_request(dev_p, CY_RQT_MS_PARTITION_SELECT,
3515 CY_RQT_USB_RQT_CONTEXT, 2);
3516 if (req_p == 0)
3517 return CY_AS_ERROR_OUT_OF_MEMORY;
3518
3519 /* A single status word response type */
3520 reply_p = cy_as_ll_create_response(dev_p, 1);
3521 if (reply_p == 0) {
3522 cy_as_ll_destroy_request(dev_p, req_p);
3523 return CY_AS_ERROR_OUT_OF_MEMORY;
3524 }
3525
3526 /* Set the read and write count parameters into
3527 * the request structure. */
3528 cy_as_ll_request_response__set_word(req_p, 0,
3529 (uint16_t)((bus << 8) | device));
3530
3531 val = 0;
3532 if ((type == cy_as_usb_m_s_unit0) || (type == cy_as_usb_m_s_both))
3533 val |= 1;
3534 if ((type == cy_as_usb_m_s_unit1) || (type == cy_as_usb_m_s_both))
3535 val |= (1 << 8);
3536
3537 cy_as_ll_request_response__set_word(req_p, 1, val);
3538
3539 if (cb == 0) {
3540 ret = cy_as_ll_send_request_wait_reply(dev_p, req_p, reply_p);
3541 if (ret != CY_AS_ERROR_SUCCESS)
3542 goto destroy;
3543
3544 if (cy_as_ll_request_response__get_code(reply_p) ==
3545 CY_RESP_SUCCESS_FAILURE)
3546 ret = cy_as_ll_request_response__get_word(reply_p, 0);
3547 else
3548 ret = CY_AS_ERROR_INVALID_RESPONSE;
3549 } else {
3550 ret = cy_as_misc_send_request(dev_p, cb, client,
3551 CY_FUNCT_CB_NODATA, 0, dev_p->func_cbs_usb,
3552 CY_AS_REQUEST_RESPONSE_EX, req_p, reply_p,
3553 cy_as_usb_func_callback);
3554
3555 if (ret != CY_AS_ERROR_SUCCESS)
3556 goto destroy;
3557 return ret;
3558 }
3559
3560 destroy:
3561 cy_as_ll_destroy_request(dev_p, req_p);
3562 cy_as_ll_destroy_response(dev_p, reply_p);
3563
3564 return ret;
3565 }
3566
3567 static void
3568 cy_as_usb_func_callback(
3569 cy_as_device *dev_p,
3570 uint8_t context,
3571 cy_as_ll_request_response *rqt,
3572 cy_as_ll_request_response *resp,
3573 cy_as_return_status_t stat)
3574 {
3575 cy_as_usb_func_c_b_node* node = (cy_as_usb_func_c_b_node *)
3576 dev_p->usb_func_cbs->head_p;
3577 cy_as_func_c_b_node* fnode = (cy_as_func_c_b_node *)
3578 dev_p->func_cbs_usb->head_p;
3579 cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS;
3580
3581 cy_as_device_handle h = (cy_as_device_handle)dev_p;
3582 cy_bool delayed_ack = (rqt->flags & CY_AS_REQUEST_RESPONSE_DELAY_ACK)
3583 == CY_AS_REQUEST_RESPONSE_DELAY_ACK;
3584 cy_bool ex_request = (rqt->flags & CY_AS_REQUEST_RESPONSE_EX)
3585 == CY_AS_REQUEST_RESPONSE_EX;
3586 cy_bool ms_request = (rqt->flags & CY_AS_REQUEST_RESPONSE_MS)
3587 == CY_AS_REQUEST_RESPONSE_MS;
3588 uint8_t code;
3589 uint8_t ep, state;
3590
3591 if (!ex_request && !ms_request) {
3592 cy_as_hal_assert(dev_p->usb_func_cbs->count != 0);
3593 cy_as_hal_assert(dev_p->usb_func_cbs->type ==
3594 CYAS_USB_FUNC_CB);
3595 } else {
3596 cy_as_hal_assert(dev_p->func_cbs_usb->count != 0);
3597 cy_as_hal_assert(dev_p->func_cbs_usb->type == CYAS_FUNC_CB);
3598 }
3599
3600 (void)context;
3601
3602 /* The Handlers are responsible for Deleting the rqt and resp when
3603 * they are finished
3604 */
3605 code = cy_as_ll_request_response__get_code(rqt);
3606 switch (code) {
3607 case CY_RQT_START_USB:
3608 ret = my_handle_response_usb_start(dev_p, rqt, resp, stat);
3609 break;
3610 case CY_RQT_STOP_USB:
3611 ret = my_handle_response_usb_stop(dev_p, rqt, resp, stat);
3612 break;
3613 case CY_RQT_SET_CONNECT_STATE:
3614 if (!cy_as_ll_request_response__get_word(rqt, 0))
3615 ret = my_handle_response_disconnect(
3616 dev_p, rqt, resp, stat);
3617 else
3618 ret = my_handle_response_connect(
3619 dev_p, rqt, resp, stat);
3620 break;
3621 case CY_RQT_GET_CONNECT_STATE:
3622 break;
3623 case CY_RQT_SET_USB_CONFIG:
3624 ret = my_handle_response_set_enum_config(dev_p, rqt, resp);
3625 break;
3626 case CY_RQT_GET_USB_CONFIG:
3627 cy_as_hal_assert(fnode->data != 0);
3628 ret = my_handle_response_get_enum_config(dev_p,
3629 rqt, resp, fnode->data);
3630 break;
3631 case CY_RQT_STALL_ENDPOINT:
3632 ep = (uint8_t)cy_as_ll_request_response__get_word(rqt, 0);
3633 state = (uint8_t)cy_as_ll_request_response__get_word(rqt, 1);
3634 ret = my_handle_response_no_data(dev_p, rqt, resp);
3635 if ((ret == CY_AS_ERROR_SUCCESS) && (ep > 1) && (state != 0)
3636 && (dev_p->usb_config[ep].dir == cy_as_usb_out))
3637 cy_as_usb_flush_logical_e_p(dev_p, ep);
3638 break;
3639 case CY_RQT_GET_STALL:
3640 cy_as_hal_assert(fnode->data != 0);
3641 ret = my_handle_response_get_stall(dev_p,
3642 rqt, resp, (cy_bool *)fnode->data);
3643 break;
3644 case CY_RQT_SET_DESCRIPTOR:
3645 ret = my_handle_response_no_data(dev_p, rqt, resp);
3646 break;
3647 case CY_RQT_GET_DESCRIPTOR:
3648 cy_as_hal_assert(fnode->data != 0);
3649 ret = my_handle_response_get_descriptor(dev_p,
3650 rqt, resp, (cy_as_get_descriptor_data *)fnode->data);
3651 break;
3652 case CY_RQT_SET_USB_CONFIG_REGISTERS:
3653 ret = my_handle_response_no_data(dev_p, rqt, resp);
3654 if (ret == CY_AS_ERROR_SUCCESS)
3655 ret = cy_as_usb_setup_dma(dev_p);
3656 break;
3657 case CY_RQT_ENDPOINT_SET_NAK:
3658 ret = my_handle_response_no_data(dev_p, rqt, resp);
3659 break;
3660 case CY_RQT_GET_ENDPOINT_NAK:
3661 cy_as_hal_assert(fnode->data != 0);
3662 ret = my_handle_response_get_nak(dev_p,
3663 rqt, resp, (cy_bool *)fnode->data);
3664 break;
3665 case CY_RQT_ACK_SETUP_PACKET:
3666 break;
3667 case CY_RQT_USB_REMOTE_WAKEUP:
3668 ret = my_handle_response_no_data(dev_p, rqt, resp);
3669 break;
3670 case CY_RQT_CLEAR_DESCRIPTORS:
3671 ret = my_handle_response_no_data(dev_p, rqt, resp);
3672 break;
3673 case CY_RQT_USB_STORAGE_MONITOR:
3674 ret = my_handle_response_no_data(dev_p, rqt, resp);
3675 break;
3676 case CY_RQT_MS_PARTITION_SELECT:
3677 ret = my_handle_response_no_data(dev_p, rqt, resp);
3678 break;
3679 default:
3680 ret = CY_AS_ERROR_INVALID_RESPONSE;
3681 cy_as_hal_assert(cy_false);
3682 break;
3683 }
3684
3685 /*
3686 * if the low level layer returns a direct error, use
3687 * the corresponding error code. if not, use the error
3688 * code based on the response from firmware.
3689 */
3690 if (stat == CY_AS_ERROR_SUCCESS)
3691 stat = ret;
3692
3693 if (ex_request || ms_request) {
3694 fnode->cb_p((cy_as_device_handle)dev_p, stat,
3695 fnode->client_data, fnode->data_type, fnode->data);
3696 cy_as_remove_c_b_node(dev_p->func_cbs_usb);
3697 } else {
3698 node->cb_p((cy_as_device_handle)dev_p, stat,
3699 node->client_data);
3700 cy_as_remove_c_b_node(dev_p->usb_func_cbs);
3701 }
3702
3703 if (delayed_ack) {
3704 cy_as_hal_assert(cy_as_device_is_ack_delayed(dev_p));
3705 cy_as_device_rem_ack_delayed(dev_p);
3706
3707 /*
3708 * send the ACK if required.
3709 */
3710 if (!cy_as_device_is_ack_delayed(dev_p))
3711 cy_as_usb_ack_setup_packet(h,
3712 usb_ack_callback, 0);
3713 }
3714 }
3715
3716
3717 /*[]*/
ubuntu-zesty-kernel mirror