am 215b682b: MTP: changes to use new usb_request support in libusbhost (88845be6) · Commits · e / os / android_frameworks_base

media/mtp/MtpClient.cpp

+3 −14

Original line number	Diff line number	Diff line
		@@ -29,12 +29,8 @@
		#include <errno.h>

		#include <usbhost/usbhost.h>
		#include <linux/version.h>
		#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 20)
		#include <linux/usb/ch9.h>
		#else
		#include <linux/usb_ch9.h>
		#endif

		struct usb_device;

		namespace android {

		@@ -194,20 +190,13 @@ bool MtpClient::usbDeviceAdded(const char *devname) {
		return mDone;
		}

		struct usb_endpoint *ep_in = usb_endpoint_open(device, ep_in_desc);
		struct usb_endpoint *ep_out = usb_endpoint_open(device, ep_out_desc);
		struct usb_endpoint *ep_intr = usb_endpoint_open(device, ep_intr_desc);

		if (usb_device_claim_interface(device, interface->bInterfaceNumber)) {
		LOGE("usb_device_claim_interface failed errno: %d\n", errno);
		usb_endpoint_close(ep_in);
		usb_endpoint_close(ep_out);
		usb_endpoint_close(ep_intr);
		return mDone;
		}

		MtpDevice* mtpDevice = new MtpDevice(device, interface->bInterfaceNumber,
		ep_in, ep_out, ep_intr);
		ep_in_desc, ep_out_desc, ep_intr_desc);
		mDeviceList.add(mtpDevice);
		mtpDevice->initialize();
		deviceAdded(mtpDevice);

media/mtp/MtpDataPacket.cpp

+37 −21

Original line number	Diff line number	Diff line
		@@ -391,15 +391,19 @@ int MtpDataPacket::writeDataHeader(int fd, uint32_t length) {
		#endif // MTP_DEVICE

		#ifdef MTP_HOST
		int MtpDataPacket::read(struct usb_endpoint *ep) {
		int MtpDataPacket::read(struct usb_request *request) {
		// first read the header
		int length = transfer(ep, mBuffer, mBufferSize);
		request->buffer = mBuffer;
		request->buffer_length = mBufferSize;
		int length = transfer(request);
		if (length >= MTP_CONTAINER_HEADER_SIZE) {
		// look at the length field to see if the data spans multiple packets
		uint32_t totalLength = MtpPacket::getUInt32(MTP_CONTAINER_LENGTH_OFFSET);
		while (totalLength > length) {
		allocate(length + mAllocationIncrement);
		int ret = transfer(ep, mBuffer + length, mAllocationIncrement);
		request->buffer = mBuffer + length;
		request->buffer_length = mAllocationIncrement;
		int ret = transfer(request);
		if (ret >= 0)
		length += ret;
		else {
		@@ -413,10 +417,12 @@ int MtpDataPacket::read(struct usb_endpoint *ep) {
		return length;
		}

		int MtpDataPacket::readData(struct usb_endpoint ep, void buffer, int length) {
		int MtpDataPacket::readData(struct usb_request request, void buffer, int length) {
		int read = 0;
		while (read < length) {
		int ret = transfer(ep, (char *)buffer + read, length - read);
		request->buffer = (char *)buffer + read;
		request->buffer_length = length - read;
		int ret = transfer(request);
		if (ret < 0) {
		return ret;
		}
		@@ -426,8 +432,8 @@ int MtpDataPacket::readData(struct usb_endpoint ep, void buffer, int length) {
		}

		// Queue a read request. Call readDataWait to wait for result
		int MtpDataPacket::readDataAsync(struct usb_endpoint ep, void buffer, int length) {
		if (usb_endpoint_queue(ep, buffer, length)) {
		int MtpDataPacket::readDataAsync(struct usb_request *req) {
		if (usb_request_queue(req)) {
		LOGE("usb_endpoint_queue failed, errno: %d", errno);
		return -1;
		}
		@@ -435,39 +441,49 @@ int MtpDataPacket::readDataAsync(struct usb_endpoint ep, void buffer, int leng
		}

		// Wait for result of readDataAsync
		int MtpDataPacket::readDataWait(struct usb_endpoint *ep) {
		int ep_num;
		return usb_endpoint_wait(usb_endpoint_get_device(ep), &ep_num);
		int MtpDataPacket::readDataWait(struct usb_device *device) {
		struct usb_request *req = usb_request_wait(device);
		return (req ? req->actual_length : -1);
		}

		int MtpDataPacket::readDataHeader(struct usb_endpoint *ep) {
		int length = transfer(ep, mBuffer, usb_endpoint_max_packet(ep));
		int MtpDataPacket::readDataHeader(struct usb_request *request) {
		request->buffer = mBuffer;
		request->buffer_length = request->max_packet_size;
		int length = transfer(request);
		if (length >= 0)
		mPacketSize = length;
		return length;
		}

		int MtpDataPacket::writeDataHeader(struct usb_endpoint *ep, uint32_t length) {
		int MtpDataPacket::writeDataHeader(struct usb_request *request, uint32_t length) {
		MtpPacket::putUInt32(MTP_CONTAINER_LENGTH_OFFSET, length);
		MtpPacket::putUInt16(MTP_CONTAINER_TYPE_OFFSET, MTP_CONTAINER_TYPE_DATA);
		int ret = transfer(ep, mBuffer, MTP_CONTAINER_HEADER_SIZE);
		request->buffer = mBuffer;
		request->buffer_length = MTP_CONTAINER_HEADER_SIZE;
		int ret = transfer(request);
		return (ret < 0 ? ret : 0);
		}

		int MtpDataPacket::write(struct usb_endpoint *ep) {
		int MtpDataPacket::write(struct usb_request *request) {
		MtpPacket::putUInt32(MTP_CONTAINER_LENGTH_OFFSET, mPacketSize);
		MtpPacket::putUInt16(MTP_CONTAINER_TYPE_OFFSET, MTP_CONTAINER_TYPE_DATA);

		// send header separately from data
		int ret = transfer(ep, mBuffer, MTP_CONTAINER_HEADER_SIZE);
		if (ret == MTP_CONTAINER_HEADER_SIZE)
		ret = transfer(ep, mBuffer + MTP_CONTAINER_HEADER_SIZE,
		mPacketSize - MTP_CONTAINER_HEADER_SIZE);
		request->buffer = mBuffer;
		request->buffer_length = MTP_CONTAINER_HEADER_SIZE;
		int ret = transfer(request);
		if (ret == MTP_CONTAINER_HEADER_SIZE) {
		request->buffer = mBuffer + MTP_CONTAINER_HEADER_SIZE;
		request->buffer_length = mPacketSize - MTP_CONTAINER_HEADER_SIZE;
		ret = transfer(request);
		}
		return (ret < 0 ? ret : 0);
		}

		int MtpDataPacket::write(struct usb_endpoint ep, void buffer, uint32_t length) {
		int ret = transfer(ep, buffer, length);
		int MtpDataPacket::write(struct usb_request request, void buffer, uint32_t length) {
		request->buffer = buffer;
		request->buffer_length = length;
		int ret = transfer(request);
		return (ret < 0 ? ret : 0);
		}

media/mtp/MtpDataPacket.h

+12 −9

Original line number	Diff line number	Diff line
		@@ -20,6 +20,9 @@
		#include "MtpPacket.h"
		#include "mtp.h"

		struct usb_device;
		struct usb_request;

		namespace android {

		class MtpStringBuffer;
		@@ -100,15 +103,15 @@ public:
		#endif

		#ifdef MTP_HOST
		int read(struct usb_endpoint *ep);
		int readData(struct usb_endpoint ep, void buffer, int length);
		int readDataAsync(struct usb_endpoint ep, void buffer, int length);
		int readDataWait(struct usb_endpoint *ep);
		int readDataHeader(struct usb_endpoint *ep);

		int writeDataHeader(struct usb_endpoint *ep, uint32_t length);
		int write(struct usb_endpoint *ep);
		int write(struct usb_endpoint ep, void buffer, uint32_t length);
		int read(struct usb_request *request);
		int readData(struct usb_request request, void buffer, int length);
		int readDataAsync(struct usb_request *req);
		int readDataWait(struct usb_device *device);
		int readDataHeader(struct usb_request *ep);

		int writeDataHeader(struct usb_request *ep, uint32_t length);
		int write(struct usb_request *ep);
		int write(struct usb_request ep, void buffer, uint32_t length);
		#endif

		inline bool hasData() const { return mPacketSize > MTP_CONTAINER_HEADER_SIZE; }

media/mtp/MtpDevice.cpp

+35 −23

Original line number	Diff line number	Diff line
		@@ -39,25 +39,35 @@
		namespace android {

		MtpDevice::MtpDevice(struct usb_device* device, int interface,
		struct usb_endpoint ep_in, struct usb_endpoint ep_out,
		struct usb_endpoint *ep_intr)
		const struct usb_endpoint_descriptor *ep_in,
		const struct usb_endpoint_descriptor *ep_out,
		const struct usb_endpoint_descriptor *ep_intr)
		: mDevice(device),
		mInterface(interface),
		mEndpointIn(ep_in),
		mEndpointOut(ep_out),
		mEndpointIntr(ep_intr),
		mRequestIn1(NULL),
		mRequestIn2(NULL),
		mRequestOut(NULL),
		mRequestIntr(NULL),
		mDeviceInfo(NULL),
		mID(usb_device_get_unique_id(device)),
		mSessionID(0),
		mTransactionID(0),
		mReceivedResponse(false)
		{
		mRequestIn1 = usb_request_new(device, ep_in);
		mRequestIn2 = usb_request_new(device, ep_in);
		mRequestOut = usb_request_new(device, ep_out);
		mRequestIntr = usb_request_new(device, ep_intr);
		}

		MtpDevice::~MtpDevice() {
		close();
		for (int i = 0; i < mDeviceProperties.size(); i++)
		delete mDeviceProperties[i];
		usb_request_free(mRequestIn1);
		usb_request_free(mRequestIn2);
		usb_request_free(mRequestOut);
		usb_request_free(mRequestIntr);
		}

		void MtpDevice::initialize() {
		@@ -325,7 +335,7 @@ bool MtpDevice::sendObject(MtpObjectInfo* info, int srcFD) {
		while (remaining > 0) {
		int count = read(srcFD, buffer, sizeof(buffer));
		if (count > 0) {
		int written = mData.write(mEndpointOut, buffer, count);
		int written = mData.write(mRequestOut, buffer, count);
		// FIXME check error
		remaining -= count;
		} else {
		@@ -441,7 +451,7 @@ bool MtpDevice::readObject(MtpObjectHandle handle, const char* destPath, int gro
		mRequest.reset();
		mRequest.setParameter(1, handle);
		if (sendRequest(MTP_OPERATION_GET_OBJECT)
		&& mData.readDataHeader(mEndpointIn)) {
		&& mData.readDataHeader(mRequestIn1)) {
		uint32_t length = mData.getContainerLength();
		if (length < MTP_CONTAINER_HEADER_SIZE)
		goto fail;
		@@ -461,20 +471,22 @@ bool MtpDevice::readObject(MtpObjectHandle handle, const char* destPath, int gro

		// USB reads greater than 16K don't work
		char buffer1[16384], buffer2[16384];
		char* readBuffer = buffer1;
		char* writeBuffer = NULL;
		mRequestIn1->buffer = buffer1;
		mRequestIn2->buffer = buffer2;
		struct usb_request* req = mRequestIn1;
		void* writeBuffer = NULL;
		int writeLength = 0;

		while (remaining > 0 \|\| writeBuffer) {
		if (remaining > 0) {
		// queue up a read request
		int readSize = (remaining > sizeof(buffer1) ? sizeof(buffer1) : remaining);
		if (mData.readDataAsync(mEndpointIn, readBuffer, readSize)) {
		req->buffer_length = (remaining > sizeof(buffer1) ? sizeof(buffer1) : remaining);
		if (mData.readDataAsync(req)) {
		LOGE("readDataAsync failed");
		goto fail;
		}
		} else {
		readBuffer = NULL;
		req = NULL;
		}

		if (writeBuffer) {
		@@ -482,23 +494,23 @@ bool MtpDevice::readObject(MtpObjectHandle handle, const char* destPath, int gro
		if (write(fd, writeBuffer, writeLength) != writeLength) {
		LOGE("write failed");
		// wait for pending read before failing
		if (readBuffer)
		mData.readDataWait(mEndpointIn);
		if (req)
		mData.readDataWait(mDevice);
		goto fail;
		}
		writeBuffer = NULL;
		}

		// wait for read to complete
		if (readBuffer) {
		int read = mData.readDataWait(mEndpointIn);
		if (req) {
		int read = mData.readDataWait(mDevice);
		if (read < 0)
		goto fail;

		writeBuffer = readBuffer;
		writeBuffer = req->buffer;
		writeLength = read;
		remaining -= read;
		readBuffer = (readBuffer == buffer1 ? buffer2 : buffer1);
		req = (req == mRequestIn1 ? mRequestIn2 : mRequestIn1);
		}
		}

		@@ -518,7 +530,7 @@ bool MtpDevice::sendRequest(MtpOperationCode operation) {
		mRequest.setOperationCode(operation);
		if (mTransactionID > 0)
		mRequest.setTransactionID(mTransactionID++);
		int ret = mRequest.write(mEndpointOut);
		int ret = mRequest.write(mRequestOut);
		mRequest.dump();
		return (ret > 0);
		}
		@@ -527,14 +539,14 @@ bool MtpDevice::sendData() {
		LOGV("sendData\n");
		mData.setOperationCode(mRequest.getOperationCode());
		mData.setTransactionID(mRequest.getTransactionID());
		int ret = mData.write(mEndpointOut);
		int ret = mData.write(mRequestOut);
		mData.dump();
		return (ret > 0);
		}

		bool MtpDevice::readData() {
		mData.reset();
		int ret = mData.read(mEndpointIn);
		int ret = mData.read(mRequestIn1);
		LOGV("readData returned %d\n", ret);
		if (ret >= MTP_CONTAINER_HEADER_SIZE) {
		if (mData.getContainerType() == MTP_CONTAINER_TYPE_RESPONSE) {
		@@ -557,7 +569,7 @@ bool MtpDevice::readData() {
		bool MtpDevice::writeDataHeader(MtpOperationCode operation, int dataLength) {
		mData.setOperationCode(operation);
		mData.setTransactionID(mRequest.getTransactionID());
		return (!mData.writeDataHeader(mEndpointOut, dataLength));
		return (!mData.writeDataHeader(mRequestOut, dataLength));
		}

		MtpResponseCode MtpDevice::readResponse() {
		@@ -566,7 +578,7 @@ MtpResponseCode MtpDevice::readResponse() {
		mReceivedResponse = false;
		return mResponse.getResponseCode();
		}
		int ret = mResponse.read(mEndpointIn);
		int ret = mResponse.read(mRequestIn1);
		if (ret >= MTP_CONTAINER_HEADER_SIZE) {
		mResponse.dump();
		return mResponse.getResponseCode();

media/mtp/MtpDevice.h

+9 −5

Original line number	Diff line number	Diff line
		@@ -25,6 +25,8 @@
		#include <utils/threads.h>

		struct usb_device;
		struct usb_request;
		struct usb_endpoint_descriptor;

		namespace android {

		@@ -36,9 +38,10 @@ class MtpDevice {
		private:
		struct usb_device* mDevice;
		int mInterface;
		struct usb_endpoint* mEndpointIn;
		struct usb_endpoint* mEndpointOut;
		struct usb_endpoint* mEndpointIntr;
		struct usb_request* mRequestIn1;
		struct usb_request* mRequestIn2;
		struct usb_request* mRequestOut;
		struct usb_request* mRequestIntr;
		MtpDeviceInfo* mDeviceInfo;
		MtpPropertyList mDeviceProperties;

		@@ -61,8 +64,9 @@ private:

		public:
		MtpDevice(struct usb_device* device, int interface,
		struct usb_endpoint ep_in, struct usb_endpoint ep_out,
		struct usb_endpoint *ep_intr);
		const struct usb_endpoint_descriptor *ep_in,
		const struct usb_endpoint_descriptor *ep_out,
		const struct usb_endpoint_descriptor *ep_intr);
		virtual ~MtpDevice();

		inline int getID() const { return mID; }