Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 3eac885d authored by Greg Kroah-Hartman's avatar Greg Kroah-Hartman
Browse files

greybus: svc: revert svc changes to keep things working for a while. 



The firmware for the svc changes isn't quite ready, so revert the whole
set of patches in one hunk to get things back to a working state for the
other firmware developers.  The svc patches will be added back in a
separate branch.

Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@google.com>
parent cb60f496

drivers/staging/greybus/Makefile

+1 −0
Original line number Diff line number Diff line 
greybus-y :=	core.o		\

		debugfs.o	\

		ap.o		\

		manifest.o	\

		endo.o		\

		module.o	\

drivers/staging/greybus/ap.c

0 → 100644
+351 −0
Original line number Diff line number Diff line 
/*

 * Greybus "AP" message loop handling

 *

 * Copyright 2014 Google Inc.

 * Copyright 2014 Linaro Ltd.

 *

 * Released under the GPLv2 only.

 */



#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt



#include <linux/types.h>

#include <linux/module.h>

#include <linux/moduleparam.h>

#include <linux/kernel.h>

#include <linux/slab.h>

#include <linux/uaccess.h>

#include <linux/workqueue.h>

#include <linux/device.h>

#include "svc_msg.h"

#include "greybus_manifest.h"

#include "greybus.h"



struct ap_msg {

	u8 *data;

	size_t size;

	struct greybus_host_device *hd;

	struct work_struct event;

};



static struct workqueue_struct *ap_workqueue;



static struct svc_msg *svc_msg_alloc(enum svc_function_id id)

{

	struct svc_msg *svc_msg;



	svc_msg = kzalloc((sizeof *svc_msg), GFP_KERNEL);

	if (!svc_msg)

		return NULL;



	// FIXME - verify we are only sending function IDs we should be

	svc_msg->header.function_id = id;

	return svc_msg;

}



static void svc_msg_free(struct svc_msg *svc_msg)

{

	kfree(svc_msg);

}



static int svc_msg_send(struct svc_msg *svc_msg, struct greybus_host_device *hd)

{

	int retval;



	// FIXME - Do we need to do more than just pass it to the hd and then

	// free it?

	retval = hd->driver->submit_svc(svc_msg, hd);



	svc_msg_free(svc_msg);

	return retval;

}



static void svc_handshake(struct svc_function_handshake *handshake,

			  int payload_length, struct greybus_host_device *hd)

{

	struct svc_msg *svc_msg;



	if (payload_length != sizeof(*handshake)) {

		dev_err(hd->parent,

			"Illegal size of svc handshake message %d\n",

			payload_length);

		return;

	}



	/* A new SVC communication channel, let's verify a supported version */

	if ((handshake->version_major != GREYBUS_VERSION_MAJOR) ||

	    (handshake->version_minor != GREYBUS_VERSION_MINOR)) {

		dev_warn(hd->parent,

			"received invalid greybus version %u.%u\n",

			handshake->version_major, handshake->version_minor);

		return;

	}



	/* Validate that the handshake came from the SVC */

	if (handshake->handshake_type != SVC_HANDSHAKE_SVC_HELLO) {

		/* we don't know what to do with this, log it and return */

		dev_dbg(hd->parent, "received invalid handshake type %d\n",

			handshake->handshake_type);

		return;

	}



	/* Send back a AP_HELLO message */

	svc_msg = svc_msg_alloc(SVC_FUNCTION_HANDSHAKE);

	if (!svc_msg)

		return;



	svc_msg->header.message_type = SVC_MSG_DATA;

	svc_msg->header.payload_length =

		cpu_to_le16(sizeof(*handshake));

	svc_msg->handshake.version_major = GREYBUS_VERSION_MAJOR;

	svc_msg->handshake.version_minor = GREYBUS_VERSION_MINOR;

	svc_msg->handshake.handshake_type = SVC_HANDSHAKE_AP_HELLO;



	(void)svc_msg_send(svc_msg, hd);

}



static void svc_management(struct svc_function_unipro_management *management,

			   int payload_length, struct greybus_host_device *hd)

{

	struct gb_interface *intf;

	int ret;



	if (payload_length != sizeof(*management)) {

		dev_err(hd->parent,

			"Illegal size of svc management message %d\n",

			payload_length);

		return;

	}



	switch (management->management_packet_type) {

	case SVC_MANAGEMENT_AP_ID:

		hd->device_id = management->ap_id.device_id;

		break;

	case SVC_MANAGEMENT_LINK_UP:

		intf = gb_interface_find(hd, management->link_up.interface_id);

		if (!intf) {

			dev_err(hd->parent, "Interface ID %d not found\n",

				management->link_up.interface_id);

			return;

		}

		ret = gb_interface_init(intf, management->link_up.device_id);

		if (ret) {

			dev_err(hd->parent,

				"error %d initializing interface %hhu\n",

				ret, management->link_up.interface_id);

			return;

		}

		break;

	default:

		dev_err(hd->parent, "Unhandled UniPro management message\n");

	}

}



static void svc_hotplug(struct svc_function_hotplug *hotplug,

			int payload_length, struct greybus_host_device *hd)

{

	u8 interface_id = hotplug->interface_id;



	switch (hotplug->hotplug_event) {

	case SVC_HOTPLUG_EVENT:

		/* Add a new interface to the system */

		if (payload_length != sizeof(*hotplug)) {

			dev_err(hd->parent,

				"Illegal size of svc hotplug message %d\n",

				payload_length);

			return;

		}

		dev_dbg(hd->parent, "interface id %d added\n", interface_id);

		gb_interface_create(hd, interface_id);

		break;



	case SVC_HOTUNPLUG_EVENT:

		/* Remove a interface from the system */

		if (payload_length != sizeof(*hotplug)) {

			dev_err(hd->parent,

				"Illegal size of svc hotunplug message %d\n",

				payload_length);

			return;

		}

		dev_dbg(hd->parent, "interface id %d removed\n", interface_id);

		gb_interface_remove(hd, interface_id);

		break;



	default:

		dev_err(hd->parent,

			"Received invalid hotplug message type %d\n",

			hotplug->hotplug_event);

		break;

	}

}



static void svc_power(struct svc_function_power *power,

		      int payload_length, struct greybus_host_device *hd)

{

	u8 interface_id = power->interface_id;



	/*

	 * The AP is only allowed to get a Battery Status message, not a Battery

	 * Status Request

	 */

	if (power->power_type != SVC_POWER_BATTERY_STATUS) {

		dev_err(hd->parent, "Received invalid power type %d\n",

			power->power_type);

		return;

	}



	/*

	 * As struct struct svc_function_power_battery_status_request is 0 bytes

	 * big, we can just check the union of the whole structure to validate

	 * the size of this message.

	 */

	if (payload_length != sizeof(*power)) {

		dev_err(hd->parent,

			"Illegal size of svc power message %d\n",

			payload_length);

		return;

	}



	dev_dbg(hd->parent, "power status for interface id %d is %d\n",

		interface_id, power->status.status);



	// FIXME - do something with the power information, like update our

	// battery information...

}



static void svc_epm(struct svc_function_epm *epm,

		    int payload_length, struct greybus_host_device *hd)

{

	/* What?  An AP should not get this message */

	dev_err(hd->parent, "Got an EPM message???\n");

}



static void svc_suspend(struct svc_function_suspend *suspend,

			int payload_length, struct greybus_host_device *hd)

{

	/* What?  An AP should not get this message */

	dev_err(hd->parent, "Got an suspend message???\n");

}



static struct svc_msg *convert_ap_message(struct ap_msg *ap_msg)

{

	struct svc_msg *svc_msg;

	struct svc_msg_header *header;

	struct greybus_host_device *hd = ap_msg->hd;



	svc_msg = (struct svc_msg *)ap_msg->data;

	header = &svc_msg->header;



	/* Validate the message type */

	if (header->message_type != SVC_MSG_DATA) {

		dev_err(hd->parent, "message type %d received?\n",

			header->message_type);

		return NULL;

	}



	/*

	 * The validation of the size of the message buffer happens in each

	 * svc_* function, due to the different types of messages, keeping the

	 * logic for each message only in one place.

	 */



	return svc_msg;

}



static void ap_process_event(struct work_struct *work)

{

	struct svc_msg *svc_msg;

	struct greybus_host_device *hd;

	struct ap_msg *ap_msg;

	int payload_length;



	ap_msg = container_of(work, struct ap_msg, event);

	hd = ap_msg->hd;



	/* Turn the "raw" data into a real message */

	svc_msg = convert_ap_message(ap_msg);

	if (!svc_msg)

		return;



	payload_length = le16_to_cpu(svc_msg->header.payload_length);



	/* Look at the message to figure out what to do with it */

	switch (svc_msg->header.function_id) {

	case SVC_FUNCTION_HANDSHAKE:

		svc_handshake(&svc_msg->handshake, payload_length, hd);

		break;

	case SVC_FUNCTION_UNIPRO_NETWORK_MANAGEMENT:

		svc_management(&svc_msg->management, payload_length, hd);

		break;

	case SVC_FUNCTION_HOTPLUG:

		svc_hotplug(&svc_msg->hotplug, payload_length, hd);

		break;

	case SVC_FUNCTION_POWER:

		svc_power(&svc_msg->power, payload_length, hd);

		break;

	case SVC_FUNCTION_EPM:

		svc_epm(&svc_msg->epm, payload_length, hd);

		break;

	case SVC_FUNCTION_SUSPEND:

		svc_suspend(&svc_msg->suspend, payload_length, hd);

		break;

	default:

		dev_err(hd->parent, "received invalid SVC function ID %d\n",

			svc_msg->header.function_id);

	}



	/* clean the message up */

	kfree(ap_msg->data);

	kfree(ap_msg);

}



int greybus_svc_in(struct greybus_host_device *hd, u8 *data, int size)

{

	struct ap_msg *ap_msg;



	/*

	 * Totally naive copy the message into a new structure that we slowly

	 * create and add it to the list.  Let's get this working, the odds of

	 * this being any "slow path" for AP messages is really low at this

	 * point in time, but you never know, so this comment is here to point

	 * out that maybe we should use a slab allocator, or even just not copy

	 * the data, but use it directly and force the urbs to be "new" each

	 * time.

	 */



	/* Note - this can, and will, be called in interrupt context. */

	ap_msg = kmalloc(sizeof(*ap_msg), GFP_ATOMIC);

	if (!ap_msg)

		return -ENOMEM;

	ap_msg->data = kmalloc(size, GFP_ATOMIC);

	if (!ap_msg->data) {

		kfree(ap_msg);

		return -ENOMEM;

	}

	memcpy(ap_msg->data, data, size);

	ap_msg->size = size;

	ap_msg->hd = hd;



	INIT_WORK(&ap_msg->event, ap_process_event);

	queue_work(ap_workqueue, &ap_msg->event);



	return 0;

}

EXPORT_SYMBOL_GPL(greybus_svc_in);



int __init gb_ap_init(void)

{

	ap_workqueue = alloc_ordered_workqueue("greybus_ap", 0);

	if (!ap_workqueue)

		return -ENOMEM;



	return 0;

}



void gb_ap_exit(void)

{

	destroy_workqueue(ap_workqueue);

	ap_workqueue = NULL;

}

drivers/staging/greybus/connection.c

+1 −6
Original line number Diff line number Diff line
@@ -251,12 +251,7 @@ gb_connection_create_range(struct greybus_host_device *hd, 


	spin_unlock_irq(&gb_connections_lock);



	if (hd_cport_id != GB_SVC_CPORT_ID) {

		gb_svc_connection_create(hd->svc,

					 hd->endo->ap_intf_id, hd_cport_id,

					 bundle->intf->interface_id, cport_id);

	}



	/* XXX Will have to establish connections to get version */

	gb_connection_bind_protocol(connection);

	if (!connection->protocol)

		dev_warn(&connection->dev,

drivers/staging/greybus/core.c

+11 −16
Original line number Diff line number Diff line
@@ -176,7 +176,8 @@ struct greybus_host_device *greybus_create_hd(struct greybus_host_driver *driver 
	 * Validate that the driver implements all of the callbacks

	 * so that we don't have to every time we make them.

	 */

	if ((!driver->message_send) || (!driver->message_cancel)) {

	if ((!driver->message_send) || (!driver->message_cancel) ||

	    (!driver->submit_svc)) {

		pr_err("Must implement all greybus_host_driver callbacks!\n");

		return ERR_PTR(-EINVAL);

	}
@@ -208,21 +209,6 @@ struct greybus_host_device *greybus_create_hd(struct greybus_host_driver *driver 
	ida_init(&hd->cport_id_map);

	hd->buffer_size_max = buffer_size_max;



	/*

	 * Initialize AP's SVC protocol connection:

	 *

	 * This is required as part of early initialization of the host device

	 * as we need this connection in order to start any kind of message

	 * exchange between the AP and the SVC. SVC will start with a

	 * 'get-version' request followed by a 'svc-hello' message and at that

	 * time we will create a fully initialized svc-connection, as we need

	 * endo-id and AP's interface id for that.

	 */

	if (!gb_ap_svc_connection_create(hd)) {

		kref_put_mutex(&hd->kref, free_hd, &hd_mutex);

		return ERR_PTR(-ENOMEM);

	}



	return hd;

}

EXPORT_SYMBOL_GPL(greybus_create_hd);
@@ -284,6 +270,12 @@ static int __init gb_init(void) 
		goto error_bus;

	}



	retval = gb_ap_init();

	if (retval) {

		pr_err("gb_ap_init failed (%d)\n", retval);

		goto error_ap;

	}



	retval = gb_operation_init();

	if (retval) {

		pr_err("gb_operation_init failed (%d)\n", retval);
@@ -317,6 +309,8 @@ static int __init gb_init(void) 
error_endo:

	gb_operation_exit();

error_operation:

	gb_ap_exit();

error_ap:

	bus_unregister(&greybus_bus_type);

error_bus:

	gb_debugfs_cleanup();
@@ -331,6 +325,7 @@ static void __exit gb_exit(void) 
	gb_control_protocol_exit();

	gb_endo_exit();

	gb_operation_exit();

	gb_ap_exit();

	bus_unregister(&greybus_bus_type);

	gb_debugfs_cleanup();

}

drivers/staging/greybus/es1.c

+104 −2
Original line number Diff line number Diff line
@@ -14,9 +14,11 @@ 
#include <asm/unaligned.h>



#include "greybus.h"

#include "svc_msg.h"

#include "kernel_ver.h"



/* Memory sizes for the buffers sent to/from the ES1 controller */

#define ES1_SVC_MSG_SIZE	(sizeof(struct svc_msg) + SZ_64K)

#define ES1_GBUF_MSG_SIZE_MAX	2048



static const struct usb_device_id id_table[] = {
@@ -56,8 +58,11 @@ static DEFINE_KFIFO(apb1_log_fifo, char, APB1_LOG_SIZE); 
 * @usb_intf: pointer to the USB interface we are bound to.

 * @hd: pointer to our greybus_host_device structure

 * @control_endpoint: endpoint to send data to SVC

 * @svc_endpoint: endpoint for SVC data in

 * @cport_in_endpoint: bulk in endpoint for CPort data

 * @cport-out_endpoint: bulk out endpoint for CPort data

 * @svc_buffer: buffer for SVC messages coming in on @svc_endpoint

 * @svc_urb: urb for SVC messages coming in on @svc_endpoint

 * @cport_in_urb: array of urbs for the CPort in messages

 * @cport_in_buffer: array of buffers for the @cport_in_urb urbs

 * @cport_out_urb: array of urbs for the CPort out messages
@@ -73,9 +78,13 @@ struct es1_ap_dev { 
	struct greybus_host_device *hd;



	__u8 control_endpoint;

	__u8 svc_endpoint;

	__u8 cport_in_endpoint;

	__u8 cport_out_endpoint;



	u8 *svc_buffer;

	struct urb *svc_urb;



	struct urb *cport_in_urb[NUM_CPORT_IN_URB];

	u8 *cport_in_buffer[NUM_CPORT_IN_URB];

	struct urb *cport_out_urb[NUM_CPORT_OUT_URB];
@@ -94,6 +103,26 @@ static void usb_log_enable(struct es1_ap_dev *es1); 
static void usb_log_disable(struct es1_ap_dev *es1);



#define ES1_TIMEOUT	500	/* 500 ms for the SVC to do something */

static int submit_svc(struct svc_msg *svc_msg, struct greybus_host_device *hd)

{

	struct es1_ap_dev *es1 = hd_to_es1(hd);

	int retval;



	/* SVC messages go down our control pipe */

	retval = usb_control_msg(es1->usb_dev,

				 usb_sndctrlpipe(es1->usb_dev,

						 es1->control_endpoint),

				 REQUEST_SVC,

				 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,

				 0x00, 0x00,

				 (char *)svc_msg,

				 sizeof(*svc_msg),

				 ES1_TIMEOUT);

	if (retval != sizeof(*svc_msg))

		return retval;



	return 0;

}



static struct urb *next_free_urb(struct es1_ap_dev *es1, gfp_t gfp_mask)

{
@@ -274,6 +303,7 @@ static struct greybus_host_driver es1_driver = { 
	.hd_priv_size		= sizeof(struct es1_ap_dev),

	.message_send		= message_send,

	.message_cancel		= message_cancel,

	.submit_svc		= submit_svc,

};



/* Common function to report consistent warnings based on URB status */
@@ -337,6 +367,12 @@ static void ap_disconnect(struct usb_interface *interface) 
		es1->cport_in_buffer[i] = NULL;

	}



	usb_kill_urb(es1->svc_urb);

	usb_free_urb(es1->svc_urb);

	es1->svc_urb = NULL;

	kfree(es1->svc_buffer);

	es1->svc_buffer = NULL;



	usb_set_intfdata(interface, NULL);

	udev = es1->usb_dev;

	greybus_remove_hd(es1->hd);
@@ -344,6 +380,33 @@ static void ap_disconnect(struct usb_interface *interface) 
	usb_put_dev(udev);

}



/* Callback for when we get a SVC message */

static void svc_in_callback(struct urb *urb)

{

	struct greybus_host_device *hd = urb->context;

	struct device *dev = &urb->dev->dev;

	int status = check_urb_status(urb);

	int retval;



	if (status) {

		if ((status == -EAGAIN) || (status == -EPROTO))

			goto exit;

		dev_err(dev, "urb svc in error %d (dropped)\n", status);

		return;

	}



	/* We have a message, create a new message structure, add it to the

	 * list, and wake up our thread that will process the messages.

	 */

	greybus_svc_in(hd, urb->transfer_buffer, urb->actual_length);



exit:

	/* resubmit the urb to get more messages */

	retval = usb_submit_urb(urb, GFP_ATOMIC);

	if (retval)

		dev_err(dev, "Can not submit urb for AP data: %d\n", retval);

}



static void cport_in_callback(struct urb *urb)

{

	struct greybus_host_device *hd = urb->context;
@@ -547,10 +610,14 @@ static int ap_probe(struct usb_interface *interface, 
	struct usb_device *udev;

	struct usb_host_interface *iface_desc;

	struct usb_endpoint_descriptor *endpoint;

	bool int_in_found = false;

	bool bulk_in_found = false;

	bool bulk_out_found = false;

	int retval = -ENOMEM;

	int i;

	u16 endo_id = 0x4755;	// FIXME - get endo "ID" from the SVC

	u8 ap_intf_id = 0x01;	// FIXME - get endo "ID" from the SVC

	u8 svc_interval = 0;



	/* We need to fit a CPort ID in one byte of a message header */

	BUILD_BUG_ON(CPORT_ID_MAX > U8_MAX);
@@ -579,7 +646,11 @@ static int ap_probe(struct usb_interface *interface, 
	for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {

		endpoint = &iface_desc->endpoint[i].desc;



		if (usb_endpoint_is_bulk_in(endpoint)) {

		if (usb_endpoint_is_int_in(endpoint)) {

			es1->svc_endpoint = endpoint->bEndpointAddress;

			svc_interval = endpoint->bInterval;

			int_in_found = true;

		} else if (usb_endpoint_is_bulk_in(endpoint)) {

			es1->cport_in_endpoint = endpoint->bEndpointAddress;

			bulk_in_found = true;

		} else if (usb_endpoint_is_bulk_out(endpoint)) {
@@ -591,12 +662,27 @@ static int ap_probe(struct usb_interface *interface, 
				endpoint->bEndpointAddress);

		}

	}

	if ((bulk_in_found == false) ||

	if ((int_in_found == false) ||

	    (bulk_in_found == false) ||

	    (bulk_out_found == false)) {

		dev_err(&udev->dev, "Not enough endpoints found in device, aborting!\n");

		goto error;

	}



	/* Create our buffer and URB to get SVC messages, and start it up */

	es1->svc_buffer = kmalloc(ES1_SVC_MSG_SIZE, GFP_KERNEL);

	if (!es1->svc_buffer)

		goto error;



	es1->svc_urb = usb_alloc_urb(0, GFP_KERNEL);

	if (!es1->svc_urb)

		goto error;



	usb_fill_int_urb(es1->svc_urb, udev,

			 usb_rcvintpipe(udev, es1->svc_endpoint),

			 es1->svc_buffer, ES1_SVC_MSG_SIZE, svc_in_callback,

			 hd, svc_interval);



	/* Allocate buffers for our cport in messages and start them up */

	for (i = 0; i < NUM_CPORT_IN_URB; ++i) {

		struct urb *urb;
@@ -632,6 +718,22 @@ static int ap_probe(struct usb_interface *interface, 
		es1->cport_out_urb_busy[i] = false;	/* just to be anal */

	}



	/*

	 * XXX Soon this will be initiated later, with a combination

	 * XXX of a Control protocol probe operation and a

	 * XXX subsequent Control protocol connected operation for

	 * XXX the SVC connection.  At that point we know we're

	 * XXX properly connected to an Endo.

	 */

	retval = greybus_endo_setup(hd, endo_id, ap_intf_id);

	if (retval)

		goto error;



	/* Start up our svc urb, which allows events to start flowing */

	retval = usb_submit_urb(es1->svc_urb, GFP_KERNEL);

	if (retval)

		goto error;



	apb1_log_enable_dentry = debugfs_create_file("apb1_log_enable",

							(S_IWUSR | S_IRUGO),

							gb_debugfs_get(), es1,