1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * SD/MMC Greybus driver.
4  *
5  * Copyright 2014-2015 Google Inc.
6  * Copyright 2014-2015 Linaro Ltd.
7  */
8 
9 #include <linux/kernel.h>
10 #include <linux/mmc/core.h>
11 #include <linux/mmc/host.h>
12 #include <linux/mmc/mmc.h>
13 #include <linux/scatterlist.h>
14 #include <linux/workqueue.h>
15 #include <linux/greybus.h>
16 
17 #include "gbphy.h"
18 
19 struct gb_sdio_host {
20 	struct gb_connection	*connection;
21 	struct gbphy_device	*gbphy_dev;
22 	struct mmc_host		*mmc;
23 	struct mmc_request	*mrq;
24 	struct mutex		lock;	/* lock for this host */
25 	size_t			data_max;
26 	spinlock_t		xfer;	/* lock to cancel ongoing transfer */
27 	bool			xfer_stop;
28 	struct workqueue_struct	*mrq_workqueue;
29 	struct work_struct	mrqwork;
30 	u8			queued_events;
31 	bool			removed;
32 	bool			card_present;
33 	bool			read_only;
34 };
35 
36 #define GB_SDIO_RSP_R1_R5_R6_R7	(GB_SDIO_RSP_PRESENT | GB_SDIO_RSP_CRC | \
37 				 GB_SDIO_RSP_OPCODE)
38 #define GB_SDIO_RSP_R3_R4	(GB_SDIO_RSP_PRESENT)
39 #define GB_SDIO_RSP_R2		(GB_SDIO_RSP_PRESENT | GB_SDIO_RSP_CRC | \
40 				 GB_SDIO_RSP_136)
41 #define GB_SDIO_RSP_R1B		(GB_SDIO_RSP_PRESENT | GB_SDIO_RSP_CRC | \
42 				 GB_SDIO_RSP_OPCODE | GB_SDIO_RSP_BUSY)
43 
44 /* kernel vdd starts at 0x80 and we need to translate to greybus ones 0x01 */
45 #define GB_SDIO_VDD_SHIFT	8
46 
47 #ifndef MMC_CAP2_CORE_RUNTIME_PM
48 #define MMC_CAP2_CORE_RUNTIME_PM	0
49 #endif
50 
single_op(struct mmc_command * cmd)51 static inline bool single_op(struct mmc_command *cmd)
52 {
53 	u32 opcode = cmd->opcode;
54 
55 	return opcode == MMC_WRITE_BLOCK ||
56 	       opcode == MMC_READ_SINGLE_BLOCK;
57 }
58 
_gb_sdio_set_host_caps(struct gb_sdio_host * host,u32 r)59 static void _gb_sdio_set_host_caps(struct gb_sdio_host *host, u32 r)
60 {
61 	u32 caps = 0;
62 	u32 caps2 = 0;
63 
64 	caps = ((r & GB_SDIO_CAP_NONREMOVABLE) ? MMC_CAP_NONREMOVABLE : 0) |
65 		((r & GB_SDIO_CAP_4_BIT_DATA) ? MMC_CAP_4_BIT_DATA : 0) |
66 		((r & GB_SDIO_CAP_8_BIT_DATA) ? MMC_CAP_8_BIT_DATA : 0) |
67 		((r & GB_SDIO_CAP_MMC_HS) ? MMC_CAP_MMC_HIGHSPEED : 0) |
68 		((r & GB_SDIO_CAP_SD_HS) ? MMC_CAP_SD_HIGHSPEED : 0) |
69 		((r & GB_SDIO_CAP_1_2V_DDR) ? MMC_CAP_1_2V_DDR : 0) |
70 		((r & GB_SDIO_CAP_1_8V_DDR) ? MMC_CAP_1_8V_DDR : 0) |
71 		((r & GB_SDIO_CAP_POWER_OFF_CARD) ? MMC_CAP_POWER_OFF_CARD : 0) |
72 		((r & GB_SDIO_CAP_UHS_SDR12) ? MMC_CAP_UHS_SDR12 : 0) |
73 		((r & GB_SDIO_CAP_UHS_SDR25) ? MMC_CAP_UHS_SDR25 : 0) |
74 		((r & GB_SDIO_CAP_UHS_SDR50) ? MMC_CAP_UHS_SDR50 : 0) |
75 		((r & GB_SDIO_CAP_UHS_SDR104) ? MMC_CAP_UHS_SDR104 : 0) |
76 		((r & GB_SDIO_CAP_UHS_DDR50) ? MMC_CAP_UHS_DDR50 : 0) |
77 		((r & GB_SDIO_CAP_DRIVER_TYPE_A) ? MMC_CAP_DRIVER_TYPE_A : 0) |
78 		((r & GB_SDIO_CAP_DRIVER_TYPE_C) ? MMC_CAP_DRIVER_TYPE_C : 0) |
79 		((r & GB_SDIO_CAP_DRIVER_TYPE_D) ? MMC_CAP_DRIVER_TYPE_D : 0);
80 
81 	caps2 = ((r & GB_SDIO_CAP_HS200_1_2V) ? MMC_CAP2_HS200_1_2V_SDR : 0) |
82 		((r & GB_SDIO_CAP_HS400_1_2V) ? MMC_CAP2_HS400_1_2V : 0) |
83 		((r & GB_SDIO_CAP_HS400_1_8V) ? MMC_CAP2_HS400_1_8V : 0) |
84 		((r & GB_SDIO_CAP_HS200_1_8V) ? MMC_CAP2_HS200_1_8V_SDR : 0);
85 
86 	host->mmc->caps = caps;
87 	host->mmc->caps2 = caps2 | MMC_CAP2_CORE_RUNTIME_PM;
88 
89 	if (caps & MMC_CAP_NONREMOVABLE)
90 		host->card_present = true;
91 }
92 
_gb_sdio_get_host_ocr(u32 ocr)93 static u32 _gb_sdio_get_host_ocr(u32 ocr)
94 {
95 	return (((ocr & GB_SDIO_VDD_165_195) ? MMC_VDD_165_195 : 0) |
96 		((ocr & GB_SDIO_VDD_20_21) ? MMC_VDD_20_21 : 0) |
97 		((ocr & GB_SDIO_VDD_21_22) ? MMC_VDD_21_22 : 0) |
98 		((ocr & GB_SDIO_VDD_22_23) ? MMC_VDD_22_23 : 0) |
99 		((ocr & GB_SDIO_VDD_23_24) ? MMC_VDD_23_24 : 0) |
100 		((ocr & GB_SDIO_VDD_24_25) ? MMC_VDD_24_25 : 0) |
101 		((ocr & GB_SDIO_VDD_25_26) ? MMC_VDD_25_26 : 0) |
102 		((ocr & GB_SDIO_VDD_26_27) ? MMC_VDD_26_27 : 0) |
103 		((ocr & GB_SDIO_VDD_27_28) ? MMC_VDD_27_28 : 0) |
104 		((ocr & GB_SDIO_VDD_28_29) ? MMC_VDD_28_29 : 0) |
105 		((ocr & GB_SDIO_VDD_29_30) ? MMC_VDD_29_30 : 0) |
106 		((ocr & GB_SDIO_VDD_30_31) ? MMC_VDD_30_31 : 0) |
107 		((ocr & GB_SDIO_VDD_31_32) ? MMC_VDD_31_32 : 0) |
108 		((ocr & GB_SDIO_VDD_32_33) ? MMC_VDD_32_33 : 0) |
109 		((ocr & GB_SDIO_VDD_33_34) ? MMC_VDD_33_34 : 0) |
110 		((ocr & GB_SDIO_VDD_34_35) ? MMC_VDD_34_35 : 0) |
111 		((ocr & GB_SDIO_VDD_35_36) ? MMC_VDD_35_36 : 0)
112 		);
113 }
114 
gb_sdio_get_caps(struct gb_sdio_host * host)115 static int gb_sdio_get_caps(struct gb_sdio_host *host)
116 {
117 	struct gb_sdio_get_caps_response response;
118 	struct mmc_host *mmc = host->mmc;
119 	u16 data_max;
120 	u32 blksz;
121 	u32 ocr;
122 	u32 r;
123 	int ret;
124 
125 	ret = gb_operation_sync(host->connection, GB_SDIO_TYPE_GET_CAPABILITIES,
126 				NULL, 0, &response, sizeof(response));
127 	if (ret < 0)
128 		return ret;
129 	r = le32_to_cpu(response.caps);
130 
131 	_gb_sdio_set_host_caps(host, r);
132 
133 	/* get the max block size that could fit our payload */
134 	data_max = gb_operation_get_payload_size_max(host->connection);
135 	data_max = min(data_max - sizeof(struct gb_sdio_transfer_request),
136 		       data_max - sizeof(struct gb_sdio_transfer_response));
137 
138 	blksz = min_t(u16, le16_to_cpu(response.max_blk_size), data_max);
139 	blksz = max_t(u32, 512, blksz);
140 
141 	mmc->max_blk_size = rounddown_pow_of_two(blksz);
142 	mmc->max_blk_count = le16_to_cpu(response.max_blk_count);
143 	host->data_max = data_max;
144 
145 	/* get ocr supported values */
146 	ocr = _gb_sdio_get_host_ocr(le32_to_cpu(response.ocr));
147 	mmc->ocr_avail = ocr;
148 	mmc->ocr_avail_sdio = mmc->ocr_avail;
149 	mmc->ocr_avail_sd = mmc->ocr_avail;
150 	mmc->ocr_avail_mmc = mmc->ocr_avail;
151 
152 	/* get frequency range values */
153 	mmc->f_min = le32_to_cpu(response.f_min);
154 	mmc->f_max = le32_to_cpu(response.f_max);
155 
156 	return 0;
157 }
158 
_gb_queue_event(struct gb_sdio_host * host,u8 event)159 static void _gb_queue_event(struct gb_sdio_host *host, u8 event)
160 {
161 	if (event & GB_SDIO_CARD_INSERTED)
162 		host->queued_events &= ~GB_SDIO_CARD_REMOVED;
163 	else if (event & GB_SDIO_CARD_REMOVED)
164 		host->queued_events &= ~GB_SDIO_CARD_INSERTED;
165 
166 	host->queued_events |= event;
167 }
168 
_gb_sdio_process_events(struct gb_sdio_host * host,u8 event)169 static int _gb_sdio_process_events(struct gb_sdio_host *host, u8 event)
170 {
171 	u8 state_changed = 0;
172 
173 	if (event & GB_SDIO_CARD_INSERTED) {
174 		if (host->mmc->caps & MMC_CAP_NONREMOVABLE)
175 			return 0;
176 		if (host->card_present)
177 			return 0;
178 		host->card_present = true;
179 		state_changed = 1;
180 	}
181 
182 	if (event & GB_SDIO_CARD_REMOVED) {
183 		if (host->mmc->caps & MMC_CAP_NONREMOVABLE)
184 			return 0;
185 		if (!(host->card_present))
186 			return 0;
187 		host->card_present = false;
188 		state_changed = 1;
189 	}
190 
191 	if (event & GB_SDIO_WP)
192 		host->read_only = true;
193 
194 	if (state_changed) {
195 		dev_info(mmc_dev(host->mmc), "card %s now event\n",
196 			 (host->card_present ?  "inserted" : "removed"));
197 		mmc_detect_change(host->mmc, 0);
198 	}
199 
200 	return 0;
201 }
202 
gb_sdio_request_handler(struct gb_operation * op)203 static int gb_sdio_request_handler(struct gb_operation *op)
204 {
205 	struct gb_sdio_host *host = gb_connection_get_data(op->connection);
206 	struct gb_message *request;
207 	struct gb_sdio_event_request *payload;
208 	u8 type = op->type;
209 	int ret =  0;
210 	u8 event;
211 
212 	if (type != GB_SDIO_TYPE_EVENT) {
213 		dev_err(mmc_dev(host->mmc),
214 			"unsupported unsolicited event: %u\n", type);
215 		return -EINVAL;
216 	}
217 
218 	request = op->request;
219 
220 	if (request->payload_size < sizeof(*payload)) {
221 		dev_err(mmc_dev(host->mmc), "wrong event size received (%zu < %zu)\n",
222 			request->payload_size, sizeof(*payload));
223 		return -EINVAL;
224 	}
225 
226 	payload = request->payload;
227 	event = payload->event;
228 
229 	if (host->removed)
230 		_gb_queue_event(host, event);
231 	else
232 		ret = _gb_sdio_process_events(host, event);
233 
234 	return ret;
235 }
236 
gb_sdio_set_ios(struct gb_sdio_host * host,struct gb_sdio_set_ios_request * request)237 static int gb_sdio_set_ios(struct gb_sdio_host *host,
238 			   struct gb_sdio_set_ios_request *request)
239 {
240 	int ret;
241 
242 	ret = gbphy_runtime_get_sync(host->gbphy_dev);
243 	if (ret)
244 		return ret;
245 
246 	ret = gb_operation_sync(host->connection, GB_SDIO_TYPE_SET_IOS, request,
247 				sizeof(*request), NULL, 0);
248 
249 	gbphy_runtime_put_autosuspend(host->gbphy_dev);
250 
251 	return ret;
252 }
253 
_gb_sdio_send(struct gb_sdio_host * host,struct mmc_data * data,size_t len,u16 nblocks,off_t skip)254 static int _gb_sdio_send(struct gb_sdio_host *host, struct mmc_data *data,
255 			 size_t len, u16 nblocks, off_t skip)
256 {
257 	struct gb_sdio_transfer_request *request;
258 	struct gb_sdio_transfer_response *response;
259 	struct gb_operation *operation;
260 	struct scatterlist *sg = data->sg;
261 	unsigned int sg_len = data->sg_len;
262 	size_t copied;
263 	u16 send_blksz;
264 	u16 send_blocks;
265 	int ret;
266 
267 	WARN_ON(len > host->data_max);
268 
269 	operation = gb_operation_create(host->connection, GB_SDIO_TYPE_TRANSFER,
270 					len + sizeof(*request),
271 					sizeof(*response), GFP_KERNEL);
272 	if (!operation)
273 		return -ENOMEM;
274 
275 	request = operation->request->payload;
276 	request->data_flags = data->flags >> 8;
277 	request->data_blocks = cpu_to_le16(nblocks);
278 	request->data_blksz = cpu_to_le16(data->blksz);
279 
280 	copied = sg_pcopy_to_buffer(sg, sg_len, &request->data[0], len, skip);
281 
282 	if (copied != len) {
283 		ret = -EINVAL;
284 		goto err_put_operation;
285 	}
286 
287 	ret = gb_operation_request_send_sync(operation);
288 	if (ret < 0)
289 		goto err_put_operation;
290 
291 	response = operation->response->payload;
292 
293 	send_blocks = le16_to_cpu(response->data_blocks);
294 	send_blksz = le16_to_cpu(response->data_blksz);
295 
296 	if (len != send_blksz * send_blocks) {
297 		dev_err(mmc_dev(host->mmc), "send: size received: %zu != %d\n",
298 			len, send_blksz * send_blocks);
299 		ret = -EINVAL;
300 	}
301 
302 err_put_operation:
303 	gb_operation_put(operation);
304 
305 	return ret;
306 }
307 
_gb_sdio_recv(struct gb_sdio_host * host,struct mmc_data * data,size_t len,u16 nblocks,off_t skip)308 static int _gb_sdio_recv(struct gb_sdio_host *host, struct mmc_data *data,
309 			 size_t len, u16 nblocks, off_t skip)
310 {
311 	struct gb_sdio_transfer_request *request;
312 	struct gb_sdio_transfer_response *response;
313 	struct gb_operation *operation;
314 	struct scatterlist *sg = data->sg;
315 	unsigned int sg_len = data->sg_len;
316 	size_t copied;
317 	u16 recv_blksz;
318 	u16 recv_blocks;
319 	int ret;
320 
321 	WARN_ON(len > host->data_max);
322 
323 	operation = gb_operation_create(host->connection, GB_SDIO_TYPE_TRANSFER,
324 					sizeof(*request),
325 					len + sizeof(*response), GFP_KERNEL);
326 	if (!operation)
327 		return -ENOMEM;
328 
329 	request = operation->request->payload;
330 	request->data_flags = data->flags >> 8;
331 	request->data_blocks = cpu_to_le16(nblocks);
332 	request->data_blksz = cpu_to_le16(data->blksz);
333 
334 	ret = gb_operation_request_send_sync(operation);
335 	if (ret < 0)
336 		goto err_put_operation;
337 
338 	response = operation->response->payload;
339 	recv_blocks = le16_to_cpu(response->data_blocks);
340 	recv_blksz = le16_to_cpu(response->data_blksz);
341 
342 	if (len != recv_blksz * recv_blocks) {
343 		dev_err(mmc_dev(host->mmc), "recv: size received: %d != %zu\n",
344 			recv_blksz * recv_blocks, len);
345 		ret = -EINVAL;
346 		goto err_put_operation;
347 	}
348 
349 	copied = sg_pcopy_from_buffer(sg, sg_len, &response->data[0], len,
350 				      skip);
351 	if (copied != len)
352 		ret = -EINVAL;
353 
354 err_put_operation:
355 	gb_operation_put(operation);
356 
357 	return ret;
358 }
359 
gb_sdio_transfer(struct gb_sdio_host * host,struct mmc_data * data)360 static int gb_sdio_transfer(struct gb_sdio_host *host, struct mmc_data *data)
361 {
362 	size_t left, len;
363 	off_t skip = 0;
364 	int ret = 0;
365 	u16 nblocks;
366 
367 	if (single_op(data->mrq->cmd) && data->blocks > 1) {
368 		ret = -ETIMEDOUT;
369 		goto out;
370 	}
371 
372 	left = data->blksz * data->blocks;
373 
374 	while (left) {
375 		/* check is a stop transmission is pending */
376 		spin_lock(&host->xfer);
377 		if (host->xfer_stop) {
378 			host->xfer_stop = false;
379 			spin_unlock(&host->xfer);
380 			ret = -EINTR;
381 			goto out;
382 		}
383 		spin_unlock(&host->xfer);
384 		len = min(left, host->data_max);
385 		nblocks = len / data->blksz;
386 		len = nblocks * data->blksz;
387 
388 		if (data->flags & MMC_DATA_READ) {
389 			ret = _gb_sdio_recv(host, data, len, nblocks, skip);
390 			if (ret < 0)
391 				goto out;
392 		} else {
393 			ret = _gb_sdio_send(host, data, len, nblocks, skip);
394 			if (ret < 0)
395 				goto out;
396 		}
397 		data->bytes_xfered += len;
398 		left -= len;
399 		skip += len;
400 	}
401 
402 out:
403 	data->error = ret;
404 	return ret;
405 }
406 
gb_sdio_command(struct gb_sdio_host * host,struct mmc_command * cmd)407 static int gb_sdio_command(struct gb_sdio_host *host, struct mmc_command *cmd)
408 {
409 	struct gb_sdio_command_request request = {0};
410 	struct gb_sdio_command_response response;
411 	struct mmc_data *data = host->mrq->data;
412 	unsigned int timeout_ms;
413 	u8 cmd_flags;
414 	u8 cmd_type;
415 	int i;
416 	int ret;
417 
418 	switch (mmc_resp_type(cmd)) {
419 	case MMC_RSP_NONE:
420 		cmd_flags = GB_SDIO_RSP_NONE;
421 		break;
422 	case MMC_RSP_R1:
423 		cmd_flags = GB_SDIO_RSP_R1_R5_R6_R7;
424 		break;
425 	case MMC_RSP_R1B:
426 		cmd_flags = GB_SDIO_RSP_R1B;
427 		break;
428 	case MMC_RSP_R2:
429 		cmd_flags = GB_SDIO_RSP_R2;
430 		break;
431 	case MMC_RSP_R3:
432 		cmd_flags = GB_SDIO_RSP_R3_R4;
433 		break;
434 	default:
435 		dev_err(mmc_dev(host->mmc), "cmd flag invalid 0x%04x\n",
436 			mmc_resp_type(cmd));
437 		ret = -EINVAL;
438 		goto out;
439 	}
440 
441 	switch (mmc_cmd_type(cmd)) {
442 	case MMC_CMD_BC:
443 		cmd_type = GB_SDIO_CMD_BC;
444 		break;
445 	case MMC_CMD_BCR:
446 		cmd_type = GB_SDIO_CMD_BCR;
447 		break;
448 	case MMC_CMD_AC:
449 		cmd_type = GB_SDIO_CMD_AC;
450 		break;
451 	case MMC_CMD_ADTC:
452 		cmd_type = GB_SDIO_CMD_ADTC;
453 		break;
454 	default:
455 		dev_err(mmc_dev(host->mmc), "cmd type invalid 0x%04x\n",
456 			mmc_cmd_type(cmd));
457 		ret = -EINVAL;
458 		goto out;
459 	}
460 
461 	request.cmd = cmd->opcode;
462 	request.cmd_flags = cmd_flags;
463 	request.cmd_type = cmd_type;
464 	request.cmd_arg = cpu_to_le32(cmd->arg);
465 	/* some controllers need to know at command time data details */
466 	if (data) {
467 		request.data_blocks = cpu_to_le16(data->blocks);
468 		request.data_blksz = cpu_to_le16(data->blksz);
469 	}
470 
471 	timeout_ms = cmd->busy_timeout ? cmd->busy_timeout :
472 		GB_OPERATION_TIMEOUT_DEFAULT;
473 
474 	ret = gb_operation_sync_timeout(host->connection, GB_SDIO_TYPE_COMMAND,
475 					&request, sizeof(request), &response,
476 					sizeof(response), timeout_ms);
477 	if (ret < 0)
478 		goto out;
479 
480 	/* no response expected */
481 	if (cmd_flags == GB_SDIO_RSP_NONE)
482 		goto out;
483 
484 	/* long response expected */
485 	if (cmd_flags & GB_SDIO_RSP_R2)
486 		for (i = 0; i < 4; i++)
487 			cmd->resp[i] = le32_to_cpu(response.resp[i]);
488 	else
489 		cmd->resp[0] = le32_to_cpu(response.resp[0]);
490 
491 out:
492 	cmd->error = ret;
493 	return ret;
494 }
495 
gb_sdio_mrq_work(struct work_struct * work)496 static void gb_sdio_mrq_work(struct work_struct *work)
497 {
498 	struct gb_sdio_host *host;
499 	struct mmc_request *mrq;
500 	int ret;
501 
502 	host = container_of(work, struct gb_sdio_host, mrqwork);
503 
504 	ret = gbphy_runtime_get_sync(host->gbphy_dev);
505 	if (ret)
506 		return;
507 
508 	mutex_lock(&host->lock);
509 	mrq = host->mrq;
510 	if (!mrq) {
511 		mutex_unlock(&host->lock);
512 		gbphy_runtime_put_autosuspend(host->gbphy_dev);
513 		dev_err(mmc_dev(host->mmc), "mmc request is NULL");
514 		return;
515 	}
516 
517 	if (host->removed) {
518 		mrq->cmd->error = -ESHUTDOWN;
519 		goto done;
520 	}
521 
522 	if (mrq->sbc) {
523 		ret = gb_sdio_command(host, mrq->sbc);
524 		if (ret < 0)
525 			goto done;
526 	}
527 
528 	ret = gb_sdio_command(host, mrq->cmd);
529 	if (ret < 0)
530 		goto done;
531 
532 	if (mrq->data) {
533 		ret = gb_sdio_transfer(host, mrq->data);
534 		if (ret < 0)
535 			goto done;
536 	}
537 
538 	if (mrq->stop) {
539 		ret = gb_sdio_command(host, mrq->stop);
540 		if (ret < 0)
541 			goto done;
542 	}
543 
544 done:
545 	host->mrq = NULL;
546 	mutex_unlock(&host->lock);
547 	mmc_request_done(host->mmc, mrq);
548 	gbphy_runtime_put_autosuspend(host->gbphy_dev);
549 }
550 
gb_mmc_request(struct mmc_host * mmc,struct mmc_request * mrq)551 static void gb_mmc_request(struct mmc_host *mmc, struct mmc_request *mrq)
552 {
553 	struct gb_sdio_host *host = mmc_priv(mmc);
554 	struct mmc_command *cmd = mrq->cmd;
555 
556 	/* Check if it is a cancel to ongoing transfer */
557 	if (cmd->opcode == MMC_STOP_TRANSMISSION) {
558 		spin_lock(&host->xfer);
559 		host->xfer_stop = true;
560 		spin_unlock(&host->xfer);
561 	}
562 
563 	mutex_lock(&host->lock);
564 
565 	WARN_ON(host->mrq);
566 	host->mrq = mrq;
567 
568 	if (host->removed) {
569 		mrq->cmd->error = -ESHUTDOWN;
570 		goto out;
571 	}
572 	if (!host->card_present) {
573 		mrq->cmd->error = -ENOMEDIUM;
574 		goto out;
575 	}
576 
577 	queue_work(host->mrq_workqueue, &host->mrqwork);
578 
579 	mutex_unlock(&host->lock);
580 	return;
581 
582 out:
583 	host->mrq = NULL;
584 	mutex_unlock(&host->lock);
585 	mmc_request_done(mmc, mrq);
586 }
587 
gb_mmc_set_ios(struct mmc_host * mmc,struct mmc_ios * ios)588 static void gb_mmc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
589 {
590 	struct gb_sdio_host *host = mmc_priv(mmc);
591 	struct gb_sdio_set_ios_request request;
592 	int ret;
593 	u8 power_mode;
594 	u8 bus_width;
595 	u8 timing;
596 	u8 signal_voltage;
597 	u8 drv_type;
598 	u32 vdd = 0;
599 
600 	mutex_lock(&host->lock);
601 	request.clock = cpu_to_le32(ios->clock);
602 
603 	if (ios->vdd)
604 		vdd = 1 << (ios->vdd - GB_SDIO_VDD_SHIFT);
605 	request.vdd = cpu_to_le32(vdd);
606 
607 	request.bus_mode = ios->bus_mode == MMC_BUSMODE_OPENDRAIN ?
608 			    GB_SDIO_BUSMODE_OPENDRAIN :
609 			    GB_SDIO_BUSMODE_PUSHPULL;
610 
611 	switch (ios->power_mode) {
612 	case MMC_POWER_OFF:
613 	default:
614 		power_mode = GB_SDIO_POWER_OFF;
615 		break;
616 	case MMC_POWER_UP:
617 		power_mode = GB_SDIO_POWER_UP;
618 		break;
619 	case MMC_POWER_ON:
620 		power_mode = GB_SDIO_POWER_ON;
621 		break;
622 	case MMC_POWER_UNDEFINED:
623 		power_mode = GB_SDIO_POWER_UNDEFINED;
624 		break;
625 	}
626 	request.power_mode = power_mode;
627 
628 	switch (ios->bus_width) {
629 	case MMC_BUS_WIDTH_1:
630 		bus_width = GB_SDIO_BUS_WIDTH_1;
631 		break;
632 	case MMC_BUS_WIDTH_4:
633 	default:
634 		bus_width = GB_SDIO_BUS_WIDTH_4;
635 		break;
636 	case MMC_BUS_WIDTH_8:
637 		bus_width = GB_SDIO_BUS_WIDTH_8;
638 		break;
639 	}
640 	request.bus_width = bus_width;
641 
642 	switch (ios->timing) {
643 	case MMC_TIMING_LEGACY:
644 	default:
645 		timing = GB_SDIO_TIMING_LEGACY;
646 		break;
647 	case MMC_TIMING_MMC_HS:
648 		timing = GB_SDIO_TIMING_MMC_HS;
649 		break;
650 	case MMC_TIMING_SD_HS:
651 		timing = GB_SDIO_TIMING_SD_HS;
652 		break;
653 	case MMC_TIMING_UHS_SDR12:
654 		timing = GB_SDIO_TIMING_UHS_SDR12;
655 		break;
656 	case MMC_TIMING_UHS_SDR25:
657 		timing = GB_SDIO_TIMING_UHS_SDR25;
658 		break;
659 	case MMC_TIMING_UHS_SDR50:
660 		timing = GB_SDIO_TIMING_UHS_SDR50;
661 		break;
662 	case MMC_TIMING_UHS_SDR104:
663 		timing = GB_SDIO_TIMING_UHS_SDR104;
664 		break;
665 	case MMC_TIMING_UHS_DDR50:
666 		timing = GB_SDIO_TIMING_UHS_DDR50;
667 		break;
668 	case MMC_TIMING_MMC_DDR52:
669 		timing = GB_SDIO_TIMING_MMC_DDR52;
670 		break;
671 	case MMC_TIMING_MMC_HS200:
672 		timing = GB_SDIO_TIMING_MMC_HS200;
673 		break;
674 	case MMC_TIMING_MMC_HS400:
675 		timing = GB_SDIO_TIMING_MMC_HS400;
676 		break;
677 	}
678 	request.timing = timing;
679 
680 	switch (ios->signal_voltage) {
681 	case MMC_SIGNAL_VOLTAGE_330:
682 		signal_voltage = GB_SDIO_SIGNAL_VOLTAGE_330;
683 		break;
684 	case MMC_SIGNAL_VOLTAGE_180:
685 	default:
686 		signal_voltage = GB_SDIO_SIGNAL_VOLTAGE_180;
687 		break;
688 	case MMC_SIGNAL_VOLTAGE_120:
689 		signal_voltage = GB_SDIO_SIGNAL_VOLTAGE_120;
690 		break;
691 	}
692 	request.signal_voltage = signal_voltage;
693 
694 	switch (ios->drv_type) {
695 	case MMC_SET_DRIVER_TYPE_A:
696 		drv_type = GB_SDIO_SET_DRIVER_TYPE_A;
697 		break;
698 	case MMC_SET_DRIVER_TYPE_C:
699 		drv_type = GB_SDIO_SET_DRIVER_TYPE_C;
700 		break;
701 	case MMC_SET_DRIVER_TYPE_D:
702 		drv_type = GB_SDIO_SET_DRIVER_TYPE_D;
703 		break;
704 	case MMC_SET_DRIVER_TYPE_B:
705 	default:
706 		drv_type = GB_SDIO_SET_DRIVER_TYPE_B;
707 		break;
708 	}
709 	request.drv_type = drv_type;
710 
711 	ret = gb_sdio_set_ios(host, &request);
712 	if (ret < 0)
713 		goto out;
714 
715 	memcpy(&mmc->ios, ios, sizeof(mmc->ios));
716 
717 out:
718 	mutex_unlock(&host->lock);
719 }
720 
gb_mmc_get_ro(struct mmc_host * mmc)721 static int gb_mmc_get_ro(struct mmc_host *mmc)
722 {
723 	struct gb_sdio_host *host = mmc_priv(mmc);
724 
725 	mutex_lock(&host->lock);
726 	if (host->removed) {
727 		mutex_unlock(&host->lock);
728 		return -ESHUTDOWN;
729 	}
730 	mutex_unlock(&host->lock);
731 
732 	return host->read_only;
733 }
734 
gb_mmc_get_cd(struct mmc_host * mmc)735 static int gb_mmc_get_cd(struct mmc_host *mmc)
736 {
737 	struct gb_sdio_host *host = mmc_priv(mmc);
738 
739 	mutex_lock(&host->lock);
740 	if (host->removed) {
741 		mutex_unlock(&host->lock);
742 		return -ESHUTDOWN;
743 	}
744 	mutex_unlock(&host->lock);
745 
746 	return host->card_present;
747 }
748 
gb_mmc_switch_voltage(struct mmc_host * mmc,struct mmc_ios * ios)749 static int gb_mmc_switch_voltage(struct mmc_host *mmc, struct mmc_ios *ios)
750 {
751 	return 0;
752 }
753 
754 static const struct mmc_host_ops gb_sdio_ops = {
755 	.request	= gb_mmc_request,
756 	.set_ios	= gb_mmc_set_ios,
757 	.get_ro		= gb_mmc_get_ro,
758 	.get_cd		= gb_mmc_get_cd,
759 	.start_signal_voltage_switch	= gb_mmc_switch_voltage,
760 };
761 
gb_sdio_probe(struct gbphy_device * gbphy_dev,const struct gbphy_device_id * id)762 static int gb_sdio_probe(struct gbphy_device *gbphy_dev,
763 			 const struct gbphy_device_id *id)
764 {
765 	struct gb_connection *connection;
766 	struct mmc_host *mmc;
767 	struct gb_sdio_host *host;
768 	int ret = 0;
769 
770 	mmc = mmc_alloc_host(sizeof(*host), &gbphy_dev->dev);
771 	if (!mmc)
772 		return -ENOMEM;
773 
774 	connection = gb_connection_create(gbphy_dev->bundle,
775 					  le16_to_cpu(gbphy_dev->cport_desc->id),
776 					  gb_sdio_request_handler);
777 	if (IS_ERR(connection)) {
778 		ret = PTR_ERR(connection);
779 		goto exit_mmc_free;
780 	}
781 
782 	host = mmc_priv(mmc);
783 	host->mmc = mmc;
784 	host->removed = true;
785 
786 	host->connection = connection;
787 	gb_connection_set_data(connection, host);
788 	host->gbphy_dev = gbphy_dev;
789 	gb_gbphy_set_data(gbphy_dev, host);
790 
791 	ret = gb_connection_enable_tx(connection);
792 	if (ret)
793 		goto exit_connection_destroy;
794 
795 	ret = gb_sdio_get_caps(host);
796 	if (ret < 0)
797 		goto exit_connection_disable;
798 
799 	mmc->ops = &gb_sdio_ops;
800 
801 	mmc->max_segs = host->mmc->max_blk_count;
802 
803 	/* for now we make a map 1:1 between max request and segment size */
804 	mmc->max_req_size = mmc->max_blk_size * mmc->max_blk_count;
805 	mmc->max_seg_size = mmc->max_req_size;
806 
807 	mutex_init(&host->lock);
808 	spin_lock_init(&host->xfer);
809 	host->mrq_workqueue = alloc_workqueue("mmc-%s", 0, 1,
810 					      dev_name(&gbphy_dev->dev));
811 	if (!host->mrq_workqueue) {
812 		ret = -ENOMEM;
813 		goto exit_connection_disable;
814 	}
815 	INIT_WORK(&host->mrqwork, gb_sdio_mrq_work);
816 
817 	ret = gb_connection_enable(connection);
818 	if (ret)
819 		goto exit_wq_destroy;
820 
821 	ret = mmc_add_host(mmc);
822 	if (ret < 0)
823 		goto exit_wq_destroy;
824 	host->removed = false;
825 	ret = _gb_sdio_process_events(host, host->queued_events);
826 	host->queued_events = 0;
827 
828 	gbphy_runtime_put_autosuspend(gbphy_dev);
829 
830 	return ret;
831 
832 exit_wq_destroy:
833 	destroy_workqueue(host->mrq_workqueue);
834 exit_connection_disable:
835 	gb_connection_disable(connection);
836 exit_connection_destroy:
837 	gb_connection_destroy(connection);
838 exit_mmc_free:
839 	mmc_free_host(mmc);
840 
841 	return ret;
842 }
843 
gb_sdio_remove(struct gbphy_device * gbphy_dev)844 static void gb_sdio_remove(struct gbphy_device *gbphy_dev)
845 {
846 	struct gb_sdio_host *host = gb_gbphy_get_data(gbphy_dev);
847 	struct gb_connection *connection = host->connection;
848 	struct mmc_host *mmc;
849 	int ret;
850 
851 	ret = gbphy_runtime_get_sync(gbphy_dev);
852 	if (ret)
853 		gbphy_runtime_get_noresume(gbphy_dev);
854 
855 	mutex_lock(&host->lock);
856 	host->removed = true;
857 	mmc = host->mmc;
858 	gb_connection_set_data(connection, NULL);
859 	mutex_unlock(&host->lock);
860 
861 	destroy_workqueue(host->mrq_workqueue);
862 	gb_connection_disable_rx(connection);
863 	mmc_remove_host(mmc);
864 	gb_connection_disable(connection);
865 	gb_connection_destroy(connection);
866 	mmc_free_host(mmc);
867 }
868 
869 static const struct gbphy_device_id gb_sdio_id_table[] = {
870 	{ GBPHY_PROTOCOL(GREYBUS_PROTOCOL_SDIO) },
871 	{ },
872 };
873 MODULE_DEVICE_TABLE(gbphy, gb_sdio_id_table);
874 
875 static struct gbphy_driver sdio_driver = {
876 	.name		= "sdio",
877 	.probe		= gb_sdio_probe,
878 	.remove		= gb_sdio_remove,
879 	.id_table	= gb_sdio_id_table,
880 };
881 
882 module_gbphy_driver(sdio_driver);
883 MODULE_DESCRIPTION("SD/MMC Greybus driver");
884 MODULE_LICENSE("GPL v2");
885