1 // SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause)
2 // Copyright(c) 2015-17 Intel Corporation.
3 
4 /*
5  * SDW Intel Init Routines
6  *
7  * Initializes and creates SDW devices based on ACPI and Hardware values
8  */
9 
10 #include <linux/acpi.h>
11 #include <linux/export.h>
12 #include <linux/io.h>
13 #include <linux/module.h>
14 #include <linux/platform_device.h>
15 #include <linux/soundwire/sdw_intel.h>
16 #include "intel.h"
17 
18 #define SDW_LINK_TYPE		4 /* from Intel ACPI documentation */
19 #define SDW_MAX_LINKS		4
20 #define SDW_SHIM_LCAP		0x0
21 #define SDW_SHIM_BASE		0x2C000
22 #define SDW_ALH_BASE		0x2C800
23 #define SDW_LINK_BASE		0x30000
24 #define SDW_LINK_SIZE		0x10000
25 
26 static int link_mask;
27 module_param_named(sdw_link_mask, link_mask, int, 0444);
28 MODULE_PARM_DESC(sdw_link_mask, "Intel link mask (one bit per link)");
29 
30 static int sdw_intel_cleanup_pdev(struct sdw_intel_ctx *ctx)
31 {
32 	struct sdw_intel_link_res *link = ctx->links;
33 	int i;
34 
35 	if (!link)
36 		return 0;
37 
38 	for (i = 0; i < ctx->count; i++) {
39 		if (link->pdev)
40 			platform_device_unregister(link->pdev);
41 		link++;
42 	}
43 
44 	kfree(ctx->links);
45 	ctx->links = NULL;
46 
47 	return 0;
48 }
49 
50 static struct sdw_intel_ctx
51 *sdw_intel_add_controller(struct sdw_intel_res *res)
52 {
53 	struct platform_device_info pdevinfo;
54 	struct platform_device *pdev;
55 	struct sdw_intel_link_res *link;
56 	struct sdw_intel_ctx *ctx;
57 	struct acpi_device *adev;
58 	int ret, i;
59 	u8 count;
60 	u32 caps;
61 
62 	if (acpi_bus_get_device(res->handle, &adev))
63 		return NULL;
64 
65 	/* Found controller, find links supported */
66 	count = 0;
67 	ret = fwnode_property_read_u8_array(acpi_fwnode_handle(adev),
68 					    "mipi-sdw-master-count", &count, 1);
69 
70 	/* Don't fail on error, continue and use hw value */
71 	if (ret) {
72 		dev_err(&adev->dev,
73 			"Failed to read mipi-sdw-master-count: %d\n", ret);
74 		count = SDW_MAX_LINKS;
75 	}
76 
77 	/* Check SNDWLCAP.LCOUNT */
78 	caps = ioread32(res->mmio_base + SDW_SHIM_BASE + SDW_SHIM_LCAP);
79 	caps &= GENMASK(2, 0);
80 
81 	/* Check HW supported vs property value and use min of two */
82 	count = min_t(u8, caps, count);
83 
84 	/* Check count is within bounds */
85 	if (count > SDW_MAX_LINKS) {
86 		dev_err(&adev->dev, "Link count %d exceeds max %d\n",
87 			count, SDW_MAX_LINKS);
88 		return NULL;
89 	}
90 
91 	if (!count) {
92 		dev_warn(&adev->dev, "No SoundWire links detected\n");
93 		return NULL;
94 	}
95 
96 	dev_dbg(&adev->dev, "Creating %d SDW Link devices\n", count);
97 
98 	ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
99 	if (!ctx)
100 		return NULL;
101 
102 	ctx->count = count;
103 	ctx->links = kcalloc(ctx->count, sizeof(*ctx->links), GFP_KERNEL);
104 	if (!ctx->links)
105 		goto link_err;
106 
107 	link = ctx->links;
108 
109 	/* Create SDW Master devices */
110 	for (i = 0; i < count; i++) {
111 		if (link_mask && !(link_mask & BIT(i))) {
112 			dev_dbg(&adev->dev,
113 				"Link %d masked, will not be enabled\n", i);
114 			link++;
115 			continue;
116 		}
117 
118 		link->registers = res->mmio_base + SDW_LINK_BASE
119 					+ (SDW_LINK_SIZE * i);
120 		link->shim = res->mmio_base + SDW_SHIM_BASE;
121 		link->alh = res->mmio_base + SDW_ALH_BASE;
122 
123 		link->ops = res->ops;
124 		link->dev = res->dev;
125 
126 		memset(&pdevinfo, 0, sizeof(pdevinfo));
127 
128 		pdevinfo.parent = res->parent;
129 		pdevinfo.name = "int-sdw";
130 		pdevinfo.id = i;
131 		pdevinfo.fwnode = acpi_fwnode_handle(adev);
132 
133 		pdev = platform_device_register_full(&pdevinfo);
134 		if (IS_ERR(pdev)) {
135 			dev_err(&adev->dev,
136 				"platform device creation failed: %ld\n",
137 				PTR_ERR(pdev));
138 			goto pdev_err;
139 		}
140 
141 		link->pdev = pdev;
142 		link++;
143 	}
144 
145 	return ctx;
146 
147 pdev_err:
148 	sdw_intel_cleanup_pdev(ctx);
149 link_err:
150 	kfree(ctx);
151 	return NULL;
152 }
153 
154 static acpi_status sdw_intel_acpi_cb(acpi_handle handle, u32 level,
155 				     void *cdata, void **return_value)
156 {
157 	struct sdw_intel_res *res = cdata;
158 	struct acpi_device *adev;
159 	acpi_status status;
160 	u64 adr;
161 
162 	status = acpi_evaluate_integer(handle, METHOD_NAME__ADR, NULL, &adr);
163 	if (ACPI_FAILURE(status))
164 		return AE_OK; /* keep going */
165 
166 	if (acpi_bus_get_device(handle, &adev)) {
167 		pr_err("%s: Couldn't find ACPI handle\n", __func__);
168 		return AE_NOT_FOUND;
169 	}
170 
171 	res->handle = handle;
172 
173 	/*
174 	 * On some Intel platforms, multiple children of the HDAS
175 	 * device can be found, but only one of them is the SoundWire
176 	 * controller. The SNDW device is always exposed with
177 	 * Name(_ADR, 0x40000000), with bits 31..28 representing the
178 	 * SoundWire link so filter accordingly
179 	 */
180 	if ((adr & GENMASK(31, 28)) >> 28 != SDW_LINK_TYPE)
181 		return AE_OK; /* keep going */
182 
183 	/* device found, stop namespace walk */
184 	return AE_CTRL_TERMINATE;
185 }
186 
187 /**
188  * sdw_intel_init() - SoundWire Intel init routine
189  * @parent_handle: ACPI parent handle
190  * @res: resource data
191  *
192  * This scans the namespace and creates SoundWire link controller devices
193  * based on the info queried.
194  */
195 void *sdw_intel_init(acpi_handle *parent_handle, struct sdw_intel_res *res)
196 {
197 	acpi_status status;
198 
199 	status = acpi_walk_namespace(ACPI_TYPE_DEVICE,
200 				     parent_handle, 1,
201 				     sdw_intel_acpi_cb,
202 				     NULL, res, NULL);
203 	if (ACPI_FAILURE(status))
204 		return NULL;
205 
206 	return sdw_intel_add_controller(res);
207 }
208 
209 /**
210  * sdw_intel_exit() - SoundWire Intel exit
211  * @arg: callback context
212  *
213  * Delete the controller instances created and cleanup
214  */
215 void sdw_intel_exit(struct sdw_intel_ctx *ctx)
216 {
217 	sdw_intel_cleanup_pdev(ctx);
218 	kfree(ctx);
219 }
220 EXPORT_SYMBOL(sdw_intel_exit);
221 
222 MODULE_LICENSE("Dual BSD/GPL");
223 MODULE_DESCRIPTION("Intel Soundwire Init Library");
224