xref: /openbmc/linux/drivers/soc/qcom/wcnss_ctrl.c (revision 6484be9d)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Copyright (c) 2016, Linaro Ltd.
4  * Copyright (c) 2015, Sony Mobile Communications Inc.
5  */
6 #include <linux/firmware.h>
7 #include <linux/module.h>
8 #include <linux/slab.h>
9 #include <linux/io.h>
10 #include <linux/of.h>
11 #include <linux/of_platform.h>
12 #include <linux/platform_device.h>
13 #include <linux/rpmsg.h>
14 #include <linux/soc/qcom/wcnss_ctrl.h>
15 
16 #define WCNSS_REQUEST_TIMEOUT	(5 * HZ)
17 #define WCNSS_CBC_TIMEOUT	(10 * HZ)
18 
19 #define WCNSS_ACK_DONE_BOOTING	1
20 #define WCNSS_ACK_COLD_BOOTING	2
21 
22 #define NV_FRAGMENT_SIZE	3072
23 #define NVBIN_FILE		"wlan/prima/WCNSS_qcom_wlan_nv.bin"
24 
25 /**
26  * struct wcnss_ctrl - driver context
27  * @dev:	device handle
28  * @channel:	SMD channel handle
29  * @ack:	completion for outstanding requests
30  * @cbc:	completion for cbc complete indication
31  * @ack_status:	status of the outstanding request
32  * @probe_work: worker for uploading nv binary
33  */
34 struct wcnss_ctrl {
35 	struct device *dev;
36 	struct rpmsg_endpoint *channel;
37 
38 	struct completion ack;
39 	struct completion cbc;
40 	int ack_status;
41 
42 	struct work_struct probe_work;
43 };
44 
45 /* message types */
46 enum {
47 	WCNSS_VERSION_REQ = 0x01000000,
48 	WCNSS_VERSION_RESP,
49 	WCNSS_DOWNLOAD_NV_REQ,
50 	WCNSS_DOWNLOAD_NV_RESP,
51 	WCNSS_UPLOAD_CAL_REQ,
52 	WCNSS_UPLOAD_CAL_RESP,
53 	WCNSS_DOWNLOAD_CAL_REQ,
54 	WCNSS_DOWNLOAD_CAL_RESP,
55 	WCNSS_VBAT_LEVEL_IND,
56 	WCNSS_BUILD_VERSION_REQ,
57 	WCNSS_BUILD_VERSION_RESP,
58 	WCNSS_PM_CONFIG_REQ,
59 	WCNSS_CBC_COMPLETE_IND,
60 };
61 
62 /**
63  * struct wcnss_msg_hdr - common packet header for requests and responses
64  * @type:	packet message type
65  * @len:	total length of the packet, including this header
66  */
67 struct wcnss_msg_hdr {
68 	u32 type;
69 	u32 len;
70 } __packed;
71 
72 /*
73  * struct wcnss_version_resp - version request response
74  */
75 struct wcnss_version_resp {
76 	struct wcnss_msg_hdr hdr;
77 	u8 major;
78 	u8 minor;
79 	u8 version;
80 	u8 revision;
81 } __packed;
82 
83 /**
84  * struct wcnss_download_nv_req - firmware fragment request
85  * @hdr:	common packet wcnss_msg_hdr header
86  * @seq:	sequence number of this fragment
87  * @last:	boolean indicator of this being the last fragment of the binary
88  * @frag_size:	length of this fragment
89  * @fragment:	fragment data
90  */
91 struct wcnss_download_nv_req {
92 	struct wcnss_msg_hdr hdr;
93 	u16 seq;
94 	u16 last;
95 	u32 frag_size;
96 	u8 fragment[];
97 } __packed;
98 
99 /**
100  * struct wcnss_download_nv_resp - firmware download response
101  * @hdr:	common packet wcnss_msg_hdr header
102  * @status:	boolean to indicate success of the download
103  */
104 struct wcnss_download_nv_resp {
105 	struct wcnss_msg_hdr hdr;
106 	u8 status;
107 } __packed;
108 
109 /**
110  * wcnss_ctrl_smd_callback() - handler from SMD responses
111  * @rpdev:	remote processor message device pointer
112  * @data:	pointer to the incoming data packet
113  * @count:	size of the incoming data packet
114  * @priv:	unused
115  * @addr:	unused
116  *
117  * Handles any incoming packets from the remote WCNSS_CTRL service.
118  */
wcnss_ctrl_smd_callback(struct rpmsg_device * rpdev,void * data,int count,void * priv,u32 addr)119 static int wcnss_ctrl_smd_callback(struct rpmsg_device *rpdev,
120 				   void *data,
121 				   int count,
122 				   void *priv,
123 				   u32 addr)
124 {
125 	struct wcnss_ctrl *wcnss = dev_get_drvdata(&rpdev->dev);
126 	const struct wcnss_download_nv_resp *nvresp;
127 	const struct wcnss_version_resp *version;
128 	const struct wcnss_msg_hdr *hdr = data;
129 
130 	switch (hdr->type) {
131 	case WCNSS_VERSION_RESP:
132 		if (count != sizeof(*version)) {
133 			dev_err(wcnss->dev,
134 				"invalid size of version response\n");
135 			break;
136 		}
137 
138 		version = data;
139 		dev_info(wcnss->dev, "WCNSS Version %d.%d %d.%d\n",
140 			 version->major, version->minor,
141 			 version->version, version->revision);
142 
143 		complete(&wcnss->ack);
144 		break;
145 	case WCNSS_DOWNLOAD_NV_RESP:
146 		if (count != sizeof(*nvresp)) {
147 			dev_err(wcnss->dev,
148 				"invalid size of download response\n");
149 			break;
150 		}
151 
152 		nvresp = data;
153 		wcnss->ack_status = nvresp->status;
154 		complete(&wcnss->ack);
155 		break;
156 	case WCNSS_CBC_COMPLETE_IND:
157 		dev_dbg(wcnss->dev, "cold boot complete\n");
158 		complete(&wcnss->cbc);
159 		break;
160 	default:
161 		dev_info(wcnss->dev, "unknown message type %d\n", hdr->type);
162 		break;
163 	}
164 
165 	return 0;
166 }
167 
168 /**
169  * wcnss_request_version() - send a version request to WCNSS
170  * @wcnss:	wcnss ctrl driver context
171  */
wcnss_request_version(struct wcnss_ctrl * wcnss)172 static int wcnss_request_version(struct wcnss_ctrl *wcnss)
173 {
174 	struct wcnss_msg_hdr msg;
175 	int ret;
176 
177 	msg.type = WCNSS_VERSION_REQ;
178 	msg.len = sizeof(msg);
179 	ret = rpmsg_send(wcnss->channel, &msg, sizeof(msg));
180 	if (ret < 0)
181 		return ret;
182 
183 	ret = wait_for_completion_timeout(&wcnss->ack, WCNSS_CBC_TIMEOUT);
184 	if (!ret) {
185 		dev_err(wcnss->dev, "timeout waiting for version response\n");
186 		return -ETIMEDOUT;
187 	}
188 
189 	return 0;
190 }
191 
192 /**
193  * wcnss_download_nv() - send nv binary to WCNSS
194  * @wcnss:	wcnss_ctrl state handle
195  * @expect_cbc:	indicator to caller that an cbc event is expected
196  *
197  * Returns 0 on success. Negative errno on failure.
198  */
wcnss_download_nv(struct wcnss_ctrl * wcnss,bool * expect_cbc)199 static int wcnss_download_nv(struct wcnss_ctrl *wcnss, bool *expect_cbc)
200 {
201 	struct wcnss_download_nv_req *req;
202 	const struct firmware *fw;
203 	struct device *dev = wcnss->dev;
204 	const char *nvbin = NVBIN_FILE;
205 	const void *data;
206 	ssize_t left;
207 	int ret;
208 
209 	req = kzalloc(sizeof(*req) + NV_FRAGMENT_SIZE, GFP_KERNEL);
210 	if (!req)
211 		return -ENOMEM;
212 
213 	ret = of_property_read_string(dev->of_node, "firmware-name", &nvbin);
214 	if (ret < 0 && ret != -EINVAL)
215 		goto free_req;
216 
217 	ret = request_firmware(&fw, nvbin, dev);
218 	if (ret < 0) {
219 		dev_err(dev, "Failed to load nv file %s: %d\n", nvbin, ret);
220 		goto free_req;
221 	}
222 
223 	data = fw->data;
224 	left = fw->size;
225 
226 	req->hdr.type = WCNSS_DOWNLOAD_NV_REQ;
227 	req->hdr.len = sizeof(*req) + NV_FRAGMENT_SIZE;
228 
229 	req->last = 0;
230 	req->frag_size = NV_FRAGMENT_SIZE;
231 
232 	req->seq = 0;
233 	do {
234 		if (left <= NV_FRAGMENT_SIZE) {
235 			req->last = 1;
236 			req->frag_size = left;
237 			req->hdr.len = sizeof(*req) + left;
238 		}
239 
240 		memcpy(req->fragment, data, req->frag_size);
241 
242 		ret = rpmsg_send(wcnss->channel, req, req->hdr.len);
243 		if (ret < 0) {
244 			dev_err(dev, "failed to send smd packet\n");
245 			goto release_fw;
246 		}
247 
248 		/* Increment for next fragment */
249 		req->seq++;
250 
251 		data += NV_FRAGMENT_SIZE;
252 		left -= NV_FRAGMENT_SIZE;
253 	} while (left > 0);
254 
255 	ret = wait_for_completion_timeout(&wcnss->ack, WCNSS_REQUEST_TIMEOUT);
256 	if (!ret) {
257 		dev_err(dev, "timeout waiting for nv upload ack\n");
258 		ret = -ETIMEDOUT;
259 	} else {
260 		*expect_cbc = wcnss->ack_status == WCNSS_ACK_COLD_BOOTING;
261 		ret = 0;
262 	}
263 
264 release_fw:
265 	release_firmware(fw);
266 free_req:
267 	kfree(req);
268 
269 	return ret;
270 }
271 
272 /**
273  * qcom_wcnss_open_channel() - open additional SMD channel to WCNSS
274  * @wcnss:	wcnss handle, retrieved from drvdata
275  * @name:	SMD channel name
276  * @cb:		callback to handle incoming data on the channel
277  * @priv:	private data for use in the call-back
278  */
qcom_wcnss_open_channel(void * wcnss,const char * name,rpmsg_rx_cb_t cb,void * priv)279 struct rpmsg_endpoint *qcom_wcnss_open_channel(void *wcnss, const char *name, rpmsg_rx_cb_t cb, void *priv)
280 {
281 	struct rpmsg_channel_info chinfo;
282 	struct wcnss_ctrl *_wcnss = wcnss;
283 
284 	strscpy(chinfo.name, name, sizeof(chinfo.name));
285 	chinfo.src = RPMSG_ADDR_ANY;
286 	chinfo.dst = RPMSG_ADDR_ANY;
287 
288 	return rpmsg_create_ept(_wcnss->channel->rpdev, cb, priv, chinfo);
289 }
290 EXPORT_SYMBOL(qcom_wcnss_open_channel);
291 
wcnss_async_probe(struct work_struct * work)292 static void wcnss_async_probe(struct work_struct *work)
293 {
294 	struct wcnss_ctrl *wcnss = container_of(work, struct wcnss_ctrl, probe_work);
295 	bool expect_cbc;
296 	int ret;
297 
298 	ret = wcnss_request_version(wcnss);
299 	if (ret < 0)
300 		return;
301 
302 	ret = wcnss_download_nv(wcnss, &expect_cbc);
303 	if (ret < 0)
304 		return;
305 
306 	/* Wait for pending cold boot completion if indicated by the nv downloader */
307 	if (expect_cbc) {
308 		ret = wait_for_completion_timeout(&wcnss->cbc, WCNSS_REQUEST_TIMEOUT);
309 		if (!ret)
310 			dev_err(wcnss->dev, "expected cold boot completion\n");
311 	}
312 
313 	of_platform_populate(wcnss->dev->of_node, NULL, NULL, wcnss->dev);
314 }
315 
wcnss_ctrl_probe(struct rpmsg_device * rpdev)316 static int wcnss_ctrl_probe(struct rpmsg_device *rpdev)
317 {
318 	struct wcnss_ctrl *wcnss;
319 
320 	wcnss = devm_kzalloc(&rpdev->dev, sizeof(*wcnss), GFP_KERNEL);
321 	if (!wcnss)
322 		return -ENOMEM;
323 
324 	wcnss->dev = &rpdev->dev;
325 	wcnss->channel = rpdev->ept;
326 
327 	init_completion(&wcnss->ack);
328 	init_completion(&wcnss->cbc);
329 	INIT_WORK(&wcnss->probe_work, wcnss_async_probe);
330 
331 	dev_set_drvdata(&rpdev->dev, wcnss);
332 
333 	schedule_work(&wcnss->probe_work);
334 
335 	return 0;
336 }
337 
wcnss_ctrl_remove(struct rpmsg_device * rpdev)338 static void wcnss_ctrl_remove(struct rpmsg_device *rpdev)
339 {
340 	struct wcnss_ctrl *wcnss = dev_get_drvdata(&rpdev->dev);
341 
342 	cancel_work_sync(&wcnss->probe_work);
343 	of_platform_depopulate(&rpdev->dev);
344 }
345 
346 static const struct of_device_id wcnss_ctrl_of_match[] = {
347 	{ .compatible = "qcom,wcnss", },
348 	{}
349 };
350 MODULE_DEVICE_TABLE(of, wcnss_ctrl_of_match);
351 
352 static struct rpmsg_driver wcnss_ctrl_driver = {
353 	.probe = wcnss_ctrl_probe,
354 	.remove = wcnss_ctrl_remove,
355 	.callback = wcnss_ctrl_smd_callback,
356 	.drv  = {
357 		.name  = "qcom_wcnss_ctrl",
358 		.owner = THIS_MODULE,
359 		.of_match_table = wcnss_ctrl_of_match,
360 	},
361 };
362 
363 module_rpmsg_driver(wcnss_ctrl_driver);
364 
365 MODULE_DESCRIPTION("Qualcomm WCNSS control driver");
366 MODULE_LICENSE("GPL v2");
367