Merge tag 'for-linus-4.17-rc2-tag' of git://git.kernel.org/pub/scm/linux/kernel/git/xen/tip (36e584de) · Commits · e / devices / android_kernel_oneplus_sm7250

drivers/xen/xen-pciback/conf_space_quirks.c

+1 −1

Original line number	Diff line number	Diff line
		@@ -95,7 +95,7 @@ int xen_pcibk_config_quirks_init(struct pci_dev *dev)
		struct xen_pcibk_config_quirk *quirk;
		int ret = 0;

		quirk = kzalloc(sizeof(*quirk), GFP_ATOMIC);
		quirk = kzalloc(sizeof(*quirk), GFP_KERNEL);
		if (!quirk) {
		ret = -ENOMEM;
		goto out;

drivers/xen/xen-pciback/pci_stub.c

+4 −4

Original line number	Diff line number	Diff line
		@@ -71,7 +71,7 @@ static struct pcistub_device pcistub_device_alloc(struct pci_dev dev)

		dev_dbg(&dev->dev, "pcistub_device_alloc\n");

		psdev = kzalloc(sizeof(*psdev), GFP_ATOMIC);
		psdev = kzalloc(sizeof(*psdev), GFP_KERNEL);
		if (!psdev)
		return NULL;

		@@ -364,7 +364,7 @@ static int pcistub_init_device(struct pci_dev *dev)
		* here and then to call kfree(pci_get_drvdata(psdev->dev)).
		*/
		dev_data = kzalloc(sizeof(*dev_data) + strlen(DRV_NAME "[]")
		+ strlen(pci_name(dev)) + 1, GFP_ATOMIC);
		+ strlen(pci_name(dev)) + 1, GFP_KERNEL);
		if (!dev_data) {
		err = -ENOMEM;
		goto out;
		@@ -577,7 +577,7 @@ static int pcistub_probe(struct pci_dev dev, const struct pci_device_id id)
		}

		if (!match) {
		pci_dev_id = kmalloc(sizeof(*pci_dev_id), GFP_ATOMIC);
		pci_dev_id = kmalloc(sizeof(*pci_dev_id), GFP_KERNEL);
		if (!pci_dev_id) {
		err = -ENOMEM;
		goto out;
		@@ -1149,7 +1149,7 @@ static int pcistub_reg_add(int domain, int bus, int slot, int func,
		}
		dev = psdev->dev;

		field = kzalloc(sizeof(*field), GFP_ATOMIC);
		field = kzalloc(sizeof(*field), GFP_KERNEL);
		if (!field) {
		err = -ENOMEM;
		goto out;

drivers/xen/xenbus/xenbus_dev_frontend.c

+2 −1

Original line number	Diff line number	Diff line
		@@ -403,7 +403,7 @@ static int xenbus_command_reply(struct xenbus_file_priv *u,
		{
		struct {
		struct xsd_sockmsg hdr;
		const char body[16];
		char body[16];
		} msg;
		int rc;

		@@ -412,6 +412,7 @@ static int xenbus_command_reply(struct xenbus_file_priv *u,
		msg.hdr.len = strlen(reply) + 1;
		if (msg.hdr.len > sizeof(msg.body))
		return -E2BIG;
		memcpy(&msg.body, reply, msg.hdr.len);

		mutex_lock(&u->reply_mutex);
		rc = queue_reply(&u->read_buffers, &msg, sizeof(msg.hdr) + msg.hdr.len);

include/xen/interface/io/sndif.h

+306 −16

Original line number	Diff line number	Diff line
		@@ -36,6 +36,13 @@
		#include "ring.h"
		#include "../grant_table.h"

		/*
		******************************************************************************
		* Protocol version
		******************************************************************************
		*/
		#define XENSND_PROTOCOL_VERSION 2

		/*
		******************************************************************************
		* Feature and Parameter Negotiation
		@@ -106,6 +113,8 @@
		*
		* /local/domain/1/device/vsnd/0/0/0/ring-ref = "386"
		* /local/domain/1/device/vsnd/0/0/0/event-channel = "15"
		* /local/domain/1/device/vsnd/0/0/0/evt-ring-ref = "1386"
		* /local/domain/1/device/vsnd/0/0/0/evt-event-channel = "215"
		*
		*------------------------------ Stream 1, capture ----------------------------
		*
		@@ -115,6 +124,8 @@
		*
		* /local/domain/1/device/vsnd/0/0/1/ring-ref = "384"
		* /local/domain/1/device/vsnd/0/0/1/event-channel = "13"
		* /local/domain/1/device/vsnd/0/0/1/evt-ring-ref = "1384"
		* /local/domain/1/device/vsnd/0/0/1/evt-event-channel = "213"
		*
		*------------------------------- PCM device 1 --------------------------------
		*
		@@ -128,6 +139,8 @@
		*
		* /local/domain/1/device/vsnd/0/1/0/ring-ref = "387"
		* /local/domain/1/device/vsnd/0/1/0/event-channel = "151"
		* /local/domain/1/device/vsnd/0/1/0/evt-ring-ref = "1387"
		* /local/domain/1/device/vsnd/0/1/0/evt-event-channel = "351"
		*
		*------------------------------- PCM device 2 --------------------------------
		*
		@@ -140,6 +153,8 @@
		*
		* /local/domain/1/device/vsnd/0/2/0/ring-ref = "389"
		* /local/domain/1/device/vsnd/0/2/0/event-channel = "152"
		* /local/domain/1/device/vsnd/0/2/0/evt-ring-ref = "1389"
		* /local/domain/1/device/vsnd/0/2/0/evt-event-channel = "452"
		*
		******************************************************************************
		* Backend XenBus Nodes
		@@ -285,6 +300,23 @@
		* The Xen grant reference granting permission for the backend to map
		* a sole page in a single page sized ring buffer.
		*
		*--------------------- Stream Event Transport Parameters ---------------------
		*
		* This communication path is used to deliver asynchronous events from backend
		* to frontend, set up per stream.
		*
		* evt-event-channel
		* Values: <uint32_t>
		*
		* The identifier of the Xen event channel used to signal activity
		* in the ring buffer.
		*
		* evt-ring-ref
		* Values: <uint32_t>
		*
		* The Xen grant reference granting permission for the backend to map
		* a sole page in a single page sized ring buffer.
		*
		******************************************************************************
		* STATE DIAGRAMS
		******************************************************************************
		@@ -432,6 +464,20 @@
		#define XENSND_OP_GET_VOLUME 5
		#define XENSND_OP_MUTE 6
		#define XENSND_OP_UNMUTE 7
		#define XENSND_OP_TRIGGER 8
		#define XENSND_OP_HW_PARAM_QUERY 9

		#define XENSND_OP_TRIGGER_START 0
		#define XENSND_OP_TRIGGER_PAUSE 1
		#define XENSND_OP_TRIGGER_STOP 2
		#define XENSND_OP_TRIGGER_RESUME 3

		/*
		******************************************************************************
		* EVENT CODES
		******************************************************************************
		*/
		#define XENSND_EVT_CUR_POS 0

		/*
		******************************************************************************
		@@ -448,6 +494,8 @@
		#define XENSND_FIELD_VCARD_LONG_NAME "long-name"
		#define XENSND_FIELD_RING_REF "ring-ref"
		#define XENSND_FIELD_EVT_CHNL "event-channel"
		#define XENSND_FIELD_EVT_RING_REF "evt-ring-ref"
		#define XENSND_FIELD_EVT_EVT_CHNL "evt-event-channel"
		#define XENSND_FIELD_DEVICE_NAME "name"
		#define XENSND_FIELD_TYPE "type"
		#define XENSND_FIELD_STREAM_UNIQUE_ID "unique-id"
		@@ -526,7 +574,7 @@
		*
		*---------------------------------- Requests ---------------------------------
		*
		* All request packets have the same length (32 octets)
		* All request packets have the same length (64 octets)
		* All request packets have common header:
		* 0 1 2 3 octet
		* +----------------+----------------+----------------+----------------+
		@@ -559,11 +607,13 @@
		* +----------------+----------------+----------------+----------------+
		* \| gref_directory \| 24
		* +----------------+----------------+----------------+----------------+
		* \| reserved \| 28
		* \| period_sz \| 28
		* +----------------+----------------+----------------+----------------+
		* \| reserved \| 32
		* +----------------+----------------+----------------+----------------+
		* \|/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\|
		* +----------------+----------------+----------------+----------------+
		* \| reserved \| 32
		* \| reserved \| 64
		* +----------------+----------------+----------------+----------------+
		*
		* pcm_rate - uint32_t, stream data rate, Hz
		@@ -571,6 +621,14 @@
		* pcm_channels - uint8_t, number of channels of this stream,
		* [channels-min; channels-max]
		* buffer_sz - uint32_t, buffer size to be allocated, octets
		* period_sz - uint32_t, event period size, octets
		* This is the requested value of the period at which frontend would
		* like to receive XENSND_EVT_CUR_POS notifications from the backend when
		* stream position advances during playback/capture.
		* It shows how many octets are expected to be played/captured before
		* sending such an event.
		* If set to 0 no XENSND_EVT_CUR_POS events are sent by the backend.
		*
		* gref_directory - grant_ref_t, a reference to the first shared page
		* describing shared buffer references. At least one page exists. If shared
		* buffer size (buffer_sz) exceeds what can be addressed by this single page,
		@@ -585,6 +643,7 @@ struct xensnd_open_req {
		uint16_t reserved;
		uint32_t buffer_sz;
		grant_ref_t gref_directory;
		uint32_t period_sz;
		};

		/*
		@@ -632,7 +691,7 @@ struct xensnd_page_directory {
		* +----------------+----------------+----------------+----------------+
		* \|/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\|
		* +----------------+----------------+----------------+----------------+
		* \| reserved \| 32
		* \| reserved \| 64
		* +----------------+----------------+----------------+----------------+
		*
		* Request read/write - used for read (for capture) or write (for playback):
		@@ -650,7 +709,7 @@ struct xensnd_page_directory {
		* +----------------+----------------+----------------+----------------+
		* \|/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\|
		* +----------------+----------------+----------------+----------------+
		* \| reserved \| 32
		* \| reserved \| 64
		* +----------------+----------------+----------------+----------------+
		*
		* operation - XENSND_OP_READ for read or XENSND_OP_WRITE for write
		@@ -673,9 +732,11 @@ struct xensnd_rw_req {
		* +----------------+----------------+----------------+----------------+
		* \| length \| 16
		* +----------------+----------------+----------------+----------------+
		* \| reserved \| 20
		* +----------------+----------------+----------------+----------------+
		* \|/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\|
		* +----------------+----------------+----------------+----------------+
		* \| reserved \| 32
		* \| reserved \| 64
		* +----------------+----------------+----------------+----------------+
		*
		* operation - XENSND_OP_SET_VOLUME for volume set
		@@ -713,9 +774,11 @@ struct xensnd_rw_req {
		* +----------------+----------------+----------------+----------------+
		* \| length \| 16
		* +----------------+----------------+----------------+----------------+
		* \| reserved \| 20
		* +----------------+----------------+----------------+----------------+
		* \|/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\|
		* +----------------+----------------+----------------+----------------+
		* \| reserved \| 32
		* \| reserved \| 64
		* +----------------+----------------+----------------+----------------+
		*
		* operation - XENSND_OP_MUTE for mute or XENSND_OP_UNMUTE for unmute
		@@ -743,32 +806,213 @@ struct xensnd_rw_req {
		*
		* The 'struct xensnd_rw_req' is also used for XENSND_OP_SET_VOLUME,
		* XENSND_OP_GET_VOLUME, XENSND_OP_MUTE, XENSND_OP_UNMUTE.
		*
		* Request stream running state change - trigger PCM stream running state
		* to start, stop, pause or resume:
		*
		* 0 1 2 3 octet
		* +----------------+----------------+----------------+----------------+
		* \| id \| _OP_TRIGGER \| reserved \| 4
		* +----------------+----------------+----------------+----------------+
		* \| reserved \| 8
		* +----------------+----------------+----------------+----------------+
		* \| type \| reserved \| 12
		* +----------------+----------------+----------------+----------------+
		* \| reserved \| 16
		* +----------------+----------------+----------------+----------------+
		* \|/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\|
		* +----------------+----------------+----------------+----------------+
		* \| reserved \| 64
		* +----------------+----------------+----------------+----------------+
		*
		* type - uint8_t, XENSND_OP_TRIGGER_XXX value
		*/

		struct xensnd_trigger_req {
		uint8_t type;
		};

		/*
		*---------------------------------- Responses --------------------------------
		* Request stream parameter ranges: request intervals and
		* masks of supported ranges for stream configuration values.
		*
		* All response packets have the same length (32 octets)
		* Sound device configuration for a particular stream is a limited subset
		* of the multidimensional configuration available on XenStore, e.g.
		* once the frame rate has been selected there is a limited supported range
		* for sample rates becomes available (which might be the same set configured
		* on XenStore or less). For example, selecting 96kHz sample rate may limit
		* number of channels available for such configuration from 4 to 2, etc.
		* Thus, each call to XENSND_OP_HW_PARAM_QUERY may reduce configuration
		* space making it possible to iteratively get the final stream configuration,
		* used in XENSND_OP_OPEN request.
		*
		* See response format for this request.
		*
		* Response for all requests:
		* 0 1 2 3 octet
		* +----------------+----------------+----------------+----------------+
		* \| id \| operation \| reserved \| 4
		* \| id \| _HW_PARAM_QUERY\| reserved \| 4
		* +----------------+----------------+----------------+----------------+
		* \| status \| 8
		* \| reserved \| 8
		* +----------------+----------------+----------------+----------------+
		* \| formats mask low 32-bit \| 12
		* +----------------+----------------+----------------+----------------+
		* \| formats mask high 32-bit \| 16
		* +----------------+----------------+----------------+----------------+
		* \| reserved \| 12
		* \| min rate \| 20
		* +----------------+----------------+----------------+----------------+
		* \| max rate \| 24
		* +----------------+----------------+----------------+----------------+
		* \| min channels \| 28
		* +----------------+----------------+----------------+----------------+
		* \| max channels \| 32
		* +----------------+----------------+----------------+----------------+
		* \| min buffer frames \| 36
		* +----------------+----------------+----------------+----------------+
		* \| max buffer frames \| 40
		* +----------------+----------------+----------------+----------------+
		* \| min period frames \| 44
		* +----------------+----------------+----------------+----------------+
		* \| max period frames \| 48
		* +----------------+----------------+----------------+----------------+
		* \| reserved \| 52
		* +----------------+----------------+----------------+----------------+
		* \|/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\|
		* +----------------+----------------+----------------+----------------+
		* \| reserved \| 32
		* \| reserved \| 64
		* +----------------+----------------+----------------+----------------+
		*
		* formats - uint64_t, bit mask representing values of the parameter
		* made as bitwise OR of (1 << XENSND_PCM_FORMAT_XXX) values
		*
		* For interval parameters:
		* min - uint32_t, minimum value of the parameter
		* max - uint32_t, maximum value of the parameter
		*
		* Frame is defined as a product of the number of channels by the
		* number of octets per one sample.
		*/

		struct xensnd_query_hw_param {
		uint64_t formats;
		struct {
		uint32_t min;
		uint32_t max;
		} rates;
		struct {
		uint32_t min;
		uint32_t max;
		} channels;
		struct {
		uint32_t min;
		uint32_t max;
		} buffer;
		struct {
		uint32_t min;
		uint32_t max;
		} period;
		};

		/*
		*---------------------------------- Responses --------------------------------
		*
		* All response packets have the same length (64 octets)
		*
		* All response packets have common header:
		* 0 1 2 3 octet
		* +----------------+----------------+----------------+----------------+
		* \| id \| operation \| reserved \| 4
		* +----------------+----------------+----------------+----------------+
		* \| status \| 8
		* +----------------+----------------+----------------+----------------+
		*
		* id - uint16_t, copied from the request
		* operation - uint8_t, XENSND_OP_* - copied from request
		* status - int32_t, response status, zero on success and -XEN_EXX on failure
		*
		*
		* HW parameter query response - response for XENSND_OP_HW_PARAM_QUERY:
		* 0 1 2 3 octet
		* +----------------+----------------+----------------+----------------+
		* \| id \| operation \| reserved \| 4
		* +----------------+----------------+----------------+----------------+
		* \| status \| 8
		* +----------------+----------------+----------------+----------------+
		* \| formats mask low 32-bit \| 12
		* +----------------+----------------+----------------+----------------+
		* \| formats mask high 32-bit \| 16
		* +----------------+----------------+----------------+----------------+
		* \| min rate \| 20
		* +----------------+----------------+----------------+----------------+
		* \| max rate \| 24
		* +----------------+----------------+----------------+----------------+
		* \| min channels \| 28
		* +----------------+----------------+----------------+----------------+
		* \| max channels \| 32
		* +----------------+----------------+----------------+----------------+
		* \| min buffer frames \| 36
		* +----------------+----------------+----------------+----------------+
		* \| max buffer frames \| 40
		* +----------------+----------------+----------------+----------------+
		* \| min period frames \| 44
		* +----------------+----------------+----------------+----------------+
		* \| max period frames \| 48
		* +----------------+----------------+----------------+----------------+
		* \| reserved \| 52
		* +----------------+----------------+----------------+----------------+
		* \|/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\|
		* +----------------+----------------+----------------+----------------+
		* \| reserved \| 64
		* +----------------+----------------+----------------+----------------+
		*
		* Meaning of the values in this response is the same as for
		* XENSND_OP_HW_PARAM_QUERY request.
		*/

		/*
		*----------------------------------- Events ----------------------------------
		*
		* Events are sent via shared page allocated by the front and propagated by
		* evt-event-channel/evt-ring-ref XenStore entries
		* All event packets have the same length (64 octets)
		* All event packets have common header:
		* 0 1 2 3 octet
		* +----------------+----------------+----------------+----------------+
		* \| id \| type \| reserved \| 4
		* +----------------+----------------+----------------+----------------+
		* \| reserved \| 8
		* +----------------+----------------+----------------+----------------+
		*
		* id - uint16_t, event id, may be used by front
		* type - uint8_t, type of the event
		*
		*
		* Current stream position - event from back to front when stream's
		* playback/capture position has advanced:
		* 0 1 2 3 octet
		* +----------------+----------------+----------------+----------------+
		* \| id \| _EVT_CUR_POS \| reserved \| 4
		* +----------------+----------------+----------------+----------------+
		* \| reserved \| 8
		* +----------------+----------------+----------------+----------------+
		* \| position low 32-bit \| 12
		* +----------------+----------------+----------------+----------------+
		* \| position high 32-bit \| 16
		* +----------------+----------------+----------------+----------------+
		* \| reserved \| 20
		* +----------------+----------------+----------------+----------------+
		* \|/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\|
		* +----------------+----------------+----------------+----------------+
		* \| reserved \| 64
		* +----------------+----------------+----------------+----------------+
		*
		* position - current value of stream's playback/capture position, octets
		*
		*/

		struct xensnd_cur_pos_evt {
		uint64_t position;
		};

		struct xensnd_req {
		uint16_t id;
		uint8_t operation;
		@@ -776,7 +1020,9 @@ struct xensnd_req {
		union {
		struct xensnd_open_req open;
		struct xensnd_rw_req rw;
		uint8_t reserved[24];
		struct xensnd_trigger_req trigger;
		struct xensnd_query_hw_param hw_param;
		uint8_t reserved[56];
		} op;
		};

		@@ -785,9 +1031,53 @@ struct xensnd_resp {
		uint8_t operation;
		uint8_t reserved;
		int32_t status;
		uint8_t reserved1[24];
		union {
		struct xensnd_query_hw_param hw_param;
		uint8_t reserved1[56];
		} resp;
		};

		struct xensnd_evt {
		uint16_t id;
		uint8_t type;
		uint8_t reserved[5];
		union {
		struct xensnd_cur_pos_evt cur_pos;
		uint8_t reserved[56];
		} op;
		};

		DEFINE_RING_TYPES(xen_sndif, struct xensnd_req, struct xensnd_resp);

		/*
		******************************************************************************
		* Back to front events delivery
		******************************************************************************
		* In order to deliver asynchronous events from back to front a shared page is
		* allocated by front and its granted reference propagated to back via
		* XenStore entries (evt-ring-ref/evt-event-channel).
		* This page has a common header used by both front and back to synchronize
		* access and control event's ring buffer, while back being a producer of the
		* events and front being a consumer. The rest of the page after the header
		* is used for event packets.
		*
		* Upon reception of an event(s) front may confirm its reception
		* for either each event, group of events or none.
		*/

		struct xensnd_event_page {
		uint32_t in_cons;
		uint32_t in_prod;
		uint8_t reserved[56];
		};

		#define XENSND_EVENT_PAGE_SIZE XEN_PAGE_SIZE
		#define XENSND_IN_RING_OFFS (sizeof(struct xensnd_event_page))
		#define XENSND_IN_RING_SIZE (XENSND_EVENT_PAGE_SIZE - XENSND_IN_RING_OFFS)
		#define XENSND_IN_RING_LEN (XENSND_IN_RING_SIZE / sizeof(struct xensnd_evt))
		#define XENSND_IN_RING(page) \
		((struct xensnd_evt )((char )(page) + XENSND_IN_RING_OFFS))
		#define XENSND_IN_RING_REF(page, idx) \
		(XENSND_IN_RING((page))[(idx) % XENSND_IN_RING_LEN])

		#endif /* __XEN_PUBLIC_IO_SNDIF_H__ */