thunderbolt: Add support for XDomain properties (cdae7c07) · Commits · 戴 / test

drivers/thunderbolt/Makefile

+1 −1

Original line number	Diff line number	Diff line
		obj-${CONFIG_THUNDERBOLT} := thunderbolt.o
		thunderbolt-objs := nhi.o ctl.o tb.o switch.o cap.o path.o tunnel_pci.o eeprom.o
		thunderbolt-objs += domain.o dma_port.o icm.o
		thunderbolt-objs += domain.o dma_port.o icm.o property.o

drivers/thunderbolt/property.c

0 → 100644

+670 −0

Original line number	Diff line number	Diff line
		/*
		* Thunderbolt XDomain property support
		*
		* Copyright (C) 2017, Intel Corporation
		* Authors: Michael Jamet <michael.jamet@intel.com>
		* Mika Westerberg <mika.westerberg@linux.intel.com>
		*
		* This program is free software; you can redistribute it and/or modify
		* it under the terms of the GNU General Public License version 2 as
		* published by the Free Software Foundation.
		*/

		#include <linux/err.h>
		#include <linux/slab.h>
		#include <linux/string.h>
		#include <linux/uuid.h>
		#include <linux/thunderbolt.h>

		struct tb_property_entry {
		u32 key_hi;
		u32 key_lo;
		u16 length;
		u8 reserved;
		u8 type;
		u32 value;
		};

		struct tb_property_rootdir_entry {
		u32 magic;
		u32 length;
		struct tb_property_entry entries[];
		};

		struct tb_property_dir_entry {
		u32 uuid[4];
		struct tb_property_entry entries[];
		};

		#define TB_PROPERTY_ROOTDIR_MAGIC 0x55584401

		static struct tb_property_dir __tb_property_parse_dir(const u32 block,
		size_t block_len, unsigned int dir_offset, size_t dir_len,
		bool is_root);

		static inline void parse_dwdata(void dst, const void src, size_t dwords)
		{
		be32_to_cpu_array(dst, src, dwords);
		}

		static inline void format_dwdata(void dst, const void src, size_t dwords)
		{
		cpu_to_be32_array(dst, src, dwords);
		}

		static bool tb_property_entry_valid(const struct tb_property_entry *entry,
		size_t block_len)
		{
		switch (entry->type) {
		case TB_PROPERTY_TYPE_DIRECTORY:
		case TB_PROPERTY_TYPE_DATA:
		case TB_PROPERTY_TYPE_TEXT:
		if (entry->length > block_len)
		return false;
		if (entry->value + entry->length > block_len)
		return false;
		break;

		case TB_PROPERTY_TYPE_VALUE:
		if (entry->length != 1)
		return false;
		break;
		}

		return true;
		}

		static bool tb_property_key_valid(const char *key)
		{
		return key && strlen(key) <= TB_PROPERTY_KEY_SIZE;
		}

		static struct tb_property *
		tb_property_alloc(const char *key, enum tb_property_type type)
		{
		struct tb_property *property;

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

		strcpy(property->key, key);
		property->type = type;
		INIT_LIST_HEAD(&property->list);

		return property;
		}

		static struct tb_property tb_property_parse(const u32 block, size_t block_len,
		const struct tb_property_entry *entry)
		{
		char key[TB_PROPERTY_KEY_SIZE + 1];
		struct tb_property *property;
		struct tb_property_dir *dir;

		if (!tb_property_entry_valid(entry, block_len))
		return NULL;

		parse_dwdata(key, entry, 2);
		key[TB_PROPERTY_KEY_SIZE] = '\0';

		property = tb_property_alloc(key, entry->type);
		if (!property)
		return NULL;

		property->length = entry->length;

		switch (property->type) {
		case TB_PROPERTY_TYPE_DIRECTORY:
		dir = __tb_property_parse_dir(block, block_len, entry->value,
		entry->length, false);
		if (!dir) {
		kfree(property);
		return NULL;
		}
		property->value.dir = dir;
		break;

		case TB_PROPERTY_TYPE_DATA:
		property->value.data = kcalloc(property->length, sizeof(u32),
		GFP_KERNEL);
		if (!property->value.data) {
		kfree(property);
		return NULL;
		}
		parse_dwdata(property->value.data, block + entry->value,
		entry->length);
		break;

		case TB_PROPERTY_TYPE_TEXT:
		property->value.text = kcalloc(property->length, sizeof(u32),
		GFP_KERNEL);
		if (!property->value.text) {
		kfree(property);
		return NULL;
		}
		parse_dwdata(property->value.text, block + entry->value,
		entry->length);
		/* Force null termination */
		property->value.text[property->length * 4 - 1] = '\0';
		break;

		case TB_PROPERTY_TYPE_VALUE:
		property->value.immediate = entry->value;
		break;

		default:
		property->type = TB_PROPERTY_TYPE_UNKNOWN;
		break;
		}

		return property;
		}

		static struct tb_property_dir __tb_property_parse_dir(const u32 block,
		size_t block_len, unsigned int dir_offset, size_t dir_len, bool is_root)
		{
		const struct tb_property_entry *entries;
		size_t i, content_len, nentries;
		unsigned int content_offset;
		struct tb_property_dir *dir;

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

		if (is_root) {
		content_offset = dir_offset + 2;
		content_len = dir_len;
		} else {
		dir->uuid = kmemdup(&block[dir_offset], sizeof(*dir->uuid),
		GFP_KERNEL);
		content_offset = dir_offset + 4;
		content_len = dir_len - 4; /* Length includes UUID */
		}

		entries = (const struct tb_property_entry *)&block[content_offset];
		nentries = content_len / (sizeof(*entries) / 4);

		INIT_LIST_HEAD(&dir->properties);

		for (i = 0; i < nentries; i++) {
		struct tb_property *property;

		property = tb_property_parse(block, block_len, &entries[i]);
		if (!property) {
		tb_property_free_dir(dir);
		return NULL;
		}

		list_add_tail(&property->list, &dir->properties);
		}

		return dir;
		}

		/**
		* tb_property_parse_dir() - Parses properties from given property block
		* @block: Property block to parse
		* @block_len: Number of dword elements in the property block
		*
		* This function parses the XDomain properties data block into format that
		* can be traversed using the helper functions provided by this module.
		* Upon success returns the parsed directory. In case of error returns
		* %NULL. The resulting &struct tb_property_dir needs to be released by
		* calling tb_property_free_dir() when not needed anymore.
		*
		* The @block is expected to be root directory.
		*/
		struct tb_property_dir tb_property_parse_dir(const u32 block,
		size_t block_len)
		{
		const struct tb_property_rootdir_entry *rootdir =
		(const struct tb_property_rootdir_entry *)block;

		if (rootdir->magic != TB_PROPERTY_ROOTDIR_MAGIC)
		return NULL;
		if (rootdir->length > block_len)
		return NULL;

		return __tb_property_parse_dir(block, block_len, 0, rootdir->length,
		true);
		}

		/**
		* tb_property_create_dir() - Creates new property directory
		* @uuid: UUID used to identify the particular directory
		*
		* Creates new, empty property directory. If @uuid is %NULL then the
		* directory is assumed to be root directory.
		*/
		struct tb_property_dir tb_property_create_dir(const uuid_t uuid)
		{
		struct tb_property_dir *dir;

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

		INIT_LIST_HEAD(&dir->properties);
		if (uuid) {
		dir->uuid = kmemdup(uuid, sizeof(*dir->uuid), GFP_KERNEL);
		if (!dir->uuid) {
		kfree(dir);
		return NULL;
		}
		}

		return dir;
		}
		EXPORT_SYMBOL_GPL(tb_property_create_dir);

		static void tb_property_free(struct tb_property *property)
		{
		switch (property->type) {
		case TB_PROPERTY_TYPE_DIRECTORY:
		tb_property_free_dir(property->value.dir);
		break;

		case TB_PROPERTY_TYPE_DATA:
		kfree(property->value.data);
		break;

		case TB_PROPERTY_TYPE_TEXT:
		kfree(property->value.text);
		break;

		default:
		break;
		}

		kfree(property);
		}

		/**
		* tb_property_free_dir() - Release memory allocated for property directory
		* @dir: Directory to release
		*
		* This will release all the memory the directory occupies including all
		* descendants. It is OK to pass %NULL @dir, then the function does
		* nothing.
		*/
		void tb_property_free_dir(struct tb_property_dir *dir)
		{
		struct tb_property property, tmp;

		if (!dir)
		return;

		list_for_each_entry_safe(property, tmp, &dir->properties, list) {
		list_del(&property->list);
		tb_property_free(property);
		}
		kfree(dir->uuid);
		kfree(dir);
		}
		EXPORT_SYMBOL_GPL(tb_property_free_dir);

		static size_t tb_property_dir_length(const struct tb_property_dir *dir,
		bool recurse, size_t *data_len)
		{
		const struct tb_property *property;
		size_t len = 0;

		if (dir->uuid)
		len += sizeof(*dir->uuid) / 4;
		else
		len += sizeof(struct tb_property_rootdir_entry) / 4;

		list_for_each_entry(property, &dir->properties, list) {
		len += sizeof(struct tb_property_entry) / 4;

		switch (property->type) {
		case TB_PROPERTY_TYPE_DIRECTORY:
		if (recurse) {
		len += tb_property_dir_length(
		property->value.dir, recurse, data_len);
		}
		/* Reserve dword padding after each directory */
		if (data_len)
		*data_len += 1;
		break;

		case TB_PROPERTY_TYPE_DATA:
		case TB_PROPERTY_TYPE_TEXT:
		if (data_len)
		*data_len += property->length;
		break;

		default:
		break;
		}
		}

		return len;
		}

		static ssize_t __tb_property_format_dir(const struct tb_property_dir *dir,
		u32 *block, unsigned int start_offset, size_t block_len)
		{
		unsigned int data_offset, dir_end;
		const struct tb_property *property;
		struct tb_property_entry *entry;
		size_t dir_len, data_len = 0;
		int ret;

		/*
		* The structure of property block looks like following. Leaf
		* data/text is included right after the directory and each
		* directory follows each other (even nested ones).
		*
		* +----------+ <-- start_offset
		* \| header \| <-- root directory header
		* +----------+ ---
		* \| entry 0 \| -^--------------------.
		* +----------+ \| \|
		* \| entry 1 \| -\|--------------------\|--.
		* +----------+ \| \| \|
		* \| entry 2 \| -\|-----------------. \| \|
		* +----------+ \| \| \| \|
		* : : \| dir_len \| \| \|
		* . . \| \| \| \|
		* : : \| \| \| \|
		* +----------+ \| \| \| \|
		* \| entry n \| v \| \| \|
		* +----------+ <-- data_offset \| \| \|
		* \| data 0 \| <------------------\|--' \|
		* +----------+ \| \|
		* \| data 1 \| <------------------\|-----'
		* +----------+ \|
		* \| 00000000 \| padding \|
		* +----------+ <-- dir_end <------'
		* \| UUID \| <-- directory UUID (child directory)
		* +----------+
		* \| entry 0 \|
		* +----------+
		* \| entry 1 \|
		* +----------+
		* : :
		* . .
		* : :
		* +----------+
		* \| entry n \|
		* +----------+
		* \| data 0 \|
		* +----------+
		*
		* We use dir_end to hold pointer to the end of the directory. It
		* will increase as we add directories and each directory should be
		* added starting from previous dir_end.
		*/
		dir_len = tb_property_dir_length(dir, false, &data_len);
		data_offset = start_offset + dir_len;
		dir_end = start_offset + data_len + dir_len;

		if (data_offset > dir_end)
		return -EINVAL;
		if (dir_end > block_len)
		return -EINVAL;

		/* Write headers first */
		if (dir->uuid) {
		struct tb_property_dir_entry *pe;

		pe = (struct tb_property_dir_entry *)&block[start_offset];
		memcpy(pe->uuid, dir->uuid, sizeof(pe->uuid));
		entry = pe->entries;
		} else {
		struct tb_property_rootdir_entry *re;

		re = (struct tb_property_rootdir_entry *)&block[start_offset];
		re->magic = TB_PROPERTY_ROOTDIR_MAGIC;
		re->length = dir_len - sizeof(*re) / 4;
		entry = re->entries;
		}

		list_for_each_entry(property, &dir->properties, list) {
		const struct tb_property_dir *child;

		format_dwdata(entry, property->key, 2);
		entry->type = property->type;

		switch (property->type) {
		case TB_PROPERTY_TYPE_DIRECTORY:
		child = property->value.dir;
		ret = __tb_property_format_dir(child, block, dir_end,
		block_len);
		if (ret < 0)
		return ret;
		entry->length = tb_property_dir_length(child, false,
		NULL);
		entry->value = dir_end;
		dir_end = ret;
		break;

		case TB_PROPERTY_TYPE_DATA:
		format_dwdata(&block[data_offset], property->value.data,
		property->length);
		entry->length = property->length;
		entry->value = data_offset;
		data_offset += entry->length;
		break;

		case TB_PROPERTY_TYPE_TEXT:
		format_dwdata(&block[data_offset], property->value.text,
		property->length);
		entry->length = property->length;
		entry->value = data_offset;
		data_offset += entry->length;
		break;

		case TB_PROPERTY_TYPE_VALUE:
		entry->length = property->length;
		entry->value = property->value.immediate;
		break;

		default:
		break;
		}

		entry++;
		}

		return dir_end;
		}

		/**
		* tb_property_format_dir() - Formats directory to the packed XDomain format
		* @dir: Directory to format
		* @block: Property block where the packed data is placed
		* @block_len: Length of the property block
		*
		* This function formats the directory to the packed format that can be
		* then send over the thunderbolt fabric to receiving host. Returns %0 in
		* case of success and negative errno on faulure. Passing %NULL in @block
		* returns number of entries the block takes.
		*/
		ssize_t tb_property_format_dir(const struct tb_property_dir dir, u32 block,
		size_t block_len)
		{
		ssize_t ret;

		if (!block) {
		size_t dir_len, data_len = 0;

		dir_len = tb_property_dir_length(dir, true, &data_len);
		return dir_len + data_len;
		}

		ret = __tb_property_format_dir(dir, block, 0, block_len);
		return ret < 0 ? ret : 0;
		}

		/**
		* tb_property_add_immediate() - Add immediate property to directory
		* @parent: Directory to add the property
		* @key: Key for the property
		* @value: Immediate value to store with the property
		*/
		int tb_property_add_immediate(struct tb_property_dir parent, const char key,
		u32 value)
		{
		struct tb_property *property;

		if (!tb_property_key_valid(key))
		return -EINVAL;

		property = tb_property_alloc(key, TB_PROPERTY_TYPE_VALUE);
		if (!property)
		return -ENOMEM;

		property->length = 1;
		property->value.immediate = value;

		list_add_tail(&property->list, &parent->properties);
		return 0;
		}
		EXPORT_SYMBOL_GPL(tb_property_add_immediate);

		/**
		* tb_property_add_data() - Adds arbitrary data property to directory
		* @parent: Directory to add the property
		* @key: Key for the property
		* @buf: Data buffer to add
		* @buflen: Number of bytes in the data buffer
		*
		* Function takes a copy of @buf and adds it to the directory.
		*/
		int tb_property_add_data(struct tb_property_dir parent, const char key,
		const void *buf, size_t buflen)
		{
		/* Need to pad to dword boundary */
		size_t size = round_up(buflen, 4);
		struct tb_property *property;

		if (!tb_property_key_valid(key))
		return -EINVAL;

		property = tb_property_alloc(key, TB_PROPERTY_TYPE_DATA);
		if (!property)
		return -ENOMEM;

		property->length = size / 4;
		property->value.data = kzalloc(size, GFP_KERNEL);
		memcpy(property->value.data, buf, buflen);

		list_add_tail(&property->list, &parent->properties);
		return 0;
		}
		EXPORT_SYMBOL_GPL(tb_property_add_data);

		/**
		* tb_property_add_text() - Adds string property to directory
		* @parent: Directory to add the property
		* @key: Key for the property
		* @text: String to add
		*
		* Function takes a copy of @text and adds it to the directory.
		*/
		int tb_property_add_text(struct tb_property_dir parent, const char key,
		const char *text)
		{
		/* Need to pad to dword boundary */
		size_t size = round_up(strlen(text) + 1, 4);
		struct tb_property *property;

		if (!tb_property_key_valid(key))
		return -EINVAL;

		property = tb_property_alloc(key, TB_PROPERTY_TYPE_TEXT);
		if (!property)
		return -ENOMEM;

		property->length = size / 4;
		property->value.data = kzalloc(size, GFP_KERNEL);
		strcpy(property->value.text, text);

		list_add_tail(&property->list, &parent->properties);
		return 0;
		}
		EXPORT_SYMBOL_GPL(tb_property_add_text);

		/**
		* tb_property_add_dir() - Adds a directory to the parent directory
		* @parent: Directory to add the property
		* @key: Key for the property
		* @dir: Directory to add
		*/
		int tb_property_add_dir(struct tb_property_dir parent, const char key,
		struct tb_property_dir *dir)
		{
		struct tb_property *property;

		if (!tb_property_key_valid(key))
		return -EINVAL;

		property = tb_property_alloc(key, TB_PROPERTY_TYPE_DIRECTORY);
		if (!property)
		return -ENOMEM;

		property->value.dir = dir;

		list_add_tail(&property->list, &parent->properties);
		return 0;
		}
		EXPORT_SYMBOL_GPL(tb_property_add_dir);

		/**
		* tb_property_remove() - Removes property from a parent directory
		* @property: Property to remove
		*
		* Note memory for @property is released as well so it is not allowed to
		* touch the object after call to this function.
		*/
		void tb_property_remove(struct tb_property *property)
		{
		list_del(&property->list);
		kfree(property);
		}
		EXPORT_SYMBOL_GPL(tb_property_remove);

		/**
		* tb_property_find() - Find a property from a directory
		* @dir: Directory where the property is searched
		* @key: Key to look for
		* @type: Type of the property
		*
		* Finds and returns property from the given directory. Does not recurse
		* into sub-directories. Returns %NULL if the property was not found.
		*/
		struct tb_property tb_property_find(struct tb_property_dir dir,
		const char *key, enum tb_property_type type)
		{
		struct tb_property *property;

		list_for_each_entry(property, &dir->properties, list) {
		if (property->type == type && !strcmp(property->key, key))
		return property;
		}

		return NULL;
		}
		EXPORT_SYMBOL_GPL(tb_property_find);

		/**
		* tb_property_get_next() - Get next property from directory
		* @dir: Directory holding properties
		* @prev: Previous property in the directory (%NULL returns the first)
		*/
		struct tb_property tb_property_get_next(struct tb_property_dir dir,
		struct tb_property *prev)
		{
		if (prev) {
		if (list_is_last(&prev->list, &dir->properties))
		return NULL;
		return list_next_entry(prev, list);
		}
		return list_first_entry_or_null(&dir->properties, struct tb_property,
		list);
		}
		EXPORT_SYMBOL_GPL(tb_property_get_next);

include/linux/thunderbolt.h

0 → 100644

+89 −0

Original line number	Diff line number	Diff line
		/*
		* Thunderbolt service API
		*
		* Copyright (C) 2017, Intel Corporation
		* Authors: Michael Jamet <michael.jamet@intel.com>
		* Mika Westerberg <mika.westerberg@linux.intel.com>
		*
		* This program is free software; you can redistribute it and/or modify
		* it under the terms of the GNU General Public License version 2 as
		* published by the Free Software Foundation.
		*/

		#ifndef THUNDERBOLT_H_
		#define THUNDERBOLT_H_

		#include <linux/list.h>
		#include <linux/uuid.h>

		/**
		* struct tb_property_dir - XDomain property directory
		* @uuid: Directory UUID or %NULL if root directory
		* @properties: List of properties in this directory
		*
		* User needs to provide serialization if needed.
		*/
		struct tb_property_dir {
		const uuid_t *uuid;
		struct list_head properties;
		};

		enum tb_property_type {
		TB_PROPERTY_TYPE_UNKNOWN = 0x00,
		TB_PROPERTY_TYPE_DIRECTORY = 0x44,
		TB_PROPERTY_TYPE_DATA = 0x64,
		TB_PROPERTY_TYPE_TEXT = 0x74,
		TB_PROPERTY_TYPE_VALUE = 0x76,
		};

		#define TB_PROPERTY_KEY_SIZE 8

		/**
		* struct tb_property - XDomain property
		* @list: Used to link properties together in a directory
		* @key: Key for the property (always terminated).
		* @type: Type of the property
		* @length: Length of the property data in dwords
		* @value: Property value
		*
		* Users use @type to determine which field in @value is filled.
		*/
		struct tb_property {
		struct list_head list;
		char key[TB_PROPERTY_KEY_SIZE + 1];
		enum tb_property_type type;
		size_t length;
		union {
		struct tb_property_dir *dir;
		u8 *data;
		char *text;
		u32 immediate;
		} value;
		};

		struct tb_property_dir tb_property_parse_dir(const u32 block,
		size_t block_len);
		ssize_t tb_property_format_dir(const struct tb_property_dir dir, u32 block,
		size_t block_len);
		struct tb_property_dir tb_property_create_dir(const uuid_t uuid);
		void tb_property_free_dir(struct tb_property_dir *dir);
		int tb_property_add_immediate(struct tb_property_dir parent, const char key,
		u32 value);
		int tb_property_add_data(struct tb_property_dir parent, const char key,
		const void *buf, size_t buflen);
		int tb_property_add_text(struct tb_property_dir parent, const char key,
		const char *text);
		int tb_property_add_dir(struct tb_property_dir parent, const char key,
		struct tb_property_dir *dir);
		void tb_property_remove(struct tb_property *tb_property);
		struct tb_property tb_property_find(struct tb_property_dir dir,
		const char *key, enum tb_property_type type);
		struct tb_property tb_property_get_next(struct tb_property_dir dir,
		struct tb_property *prev);

		#define tb_property_for_each(dir, property) \
		for (property = tb_property_get_next(dir, NULL); \
		property; \
		property = tb_property_get_next(dir, property))

		#endif /* THUNDERBOLT_H_ */

Admin message