tree d460c1e074f9001ae1fbbe811eb5dc3de79d7440
parent 0a100fa8206ffa6039caf9ce02754060b6faf2ea
author Lee Jones <joneslee@google.com> 1674056964 +0000
committer Karsten Tausche <karsten@fairphone.com> 1679558780 +0100

ANDROID: usb: f_accessory: Check buffer size when initialised via composite

When communicating with accessory devices via USBFS, the initialisation
call-stack looks like:

  ConfigFS > Gadget ConfigFS > UDC > Gadget ConfigFS > Composite

Eventually ending up in composite_dev_prepare() where memory for the
data buffer is allocated and initialised.  The default size used for the
allocation is USB_COMP_EP0_BUFSIZ (4k).  When handling bulk transfers,
acc_ctrlrequest() needs to be able to handle buffers up to
BULK_BUFFER_SIZE (16k).  Instead of adding new generic attributes to
'struct usb_request' to track the size of the allocated buffer, we can
simply split off the affected thread of execution to travel via a
knowledgeable abstracted function acc_ctrlrequest_composite() where we
can complete the necessary specific checks.

Bug: 264029575
Signed-off-by: Lee Jones <joneslee@google.com>
Change-Id: Ia1280f85499621d3fa57f7262b4a2c80f4be7773
Signed-off-by: Lee Jones <joneslee@google.com>
(cherry picked from commit 2021317cc8a9d505844f4fb12e28bbcd9a554e0d)
