#include <linux/workqueue.h>
#include "greybus.h"
+#include "gbphy.h"
struct gb_sdio_host {
struct gb_connection *connection;
- u8 version_major;
- u8 version_minor;
+ struct gbphy_device *gbphy_dev;
struct mmc_host *mmc;
struct mmc_request *mrq;
struct mutex lock; /* lock for this host */
void *xfer_buffer;
spinlock_t xfer; /* lock to cancel ongoing transfer */
bool xfer_stop;
+ struct workqueue_struct *mrq_workqueue;
struct work_struct mrqwork;
+ u8 queued_events;
bool removed;
bool card_present;
bool read_only;
};
-static struct workqueue_struct *gb_sdio_mrq_workqueue;
-/* Define get_version() routine */
-define_get_version(gb_sdio_host, SDIO);
+#define GB_SDIO_RSP_R1_R5_R6_R7 (GB_SDIO_RSP_PRESENT | GB_SDIO_RSP_CRC | \
+ GB_SDIO_RSP_OPCODE)
+#define GB_SDIO_RSP_R3_R4 (GB_SDIO_RSP_PRESENT)
+#define GB_SDIO_RSP_R2 (GB_SDIO_RSP_PRESENT | GB_SDIO_RSP_CRC | \
+ GB_SDIO_RSP_136)
+#define GB_SDIO_RSP_R1B (GB_SDIO_RSP_PRESENT | GB_SDIO_RSP_CRC | \
+ GB_SDIO_RSP_OPCODE | GB_SDIO_RSP_BUSY)
+
+static inline bool single_op(struct mmc_command *cmd)
+{
+ uint32_t opcode = cmd->opcode;
+
+ return opcode == MMC_WRITE_BLOCK ||
+ opcode == MMC_READ_SINGLE_BLOCK;
+}
static void _gb_sdio_set_host_caps(struct gb_sdio_host *host, u32 r)
{
u32 caps = 0;
u32 caps2 = 0;
- caps = (r & GB_SDIO_CAP_NONREMOVABLE ? MMC_CAP_NONREMOVABLE : 0) |
- (r & GB_SDIO_CAP_4_BIT_DATA ? MMC_CAP_4_BIT_DATA : 0) |
- (r & GB_SDIO_CAP_8_BIT_DATA ? MMC_CAP_8_BIT_DATA : 0) |
- (r & GB_SDIO_CAP_MMC_HS ? MMC_CAP_MMC_HIGHSPEED : 0) |
- (r & GB_SDIO_CAP_SD_HS ? MMC_CAP_SD_HIGHSPEED : 0) |
- (r & GB_SDIO_CAP_ERASE ? MMC_CAP_ERASE : 0) |
- (r & GB_SDIO_CAP_1_2V_DDR ? MMC_CAP_1_2V_DDR : 0) |
- (r & GB_SDIO_CAP_1_8V_DDR ? MMC_CAP_1_8V_DDR : 0) |
- (r & GB_SDIO_CAP_POWER_OFF_CARD ? MMC_CAP_POWER_OFF_CARD : 0) |
- (r & GB_SDIO_CAP_UHS_SDR12 ? MMC_CAP_UHS_SDR12 : 0) |
- (r & GB_SDIO_CAP_UHS_SDR25 ? MMC_CAP_UHS_SDR25 : 0) |
- (r & GB_SDIO_CAP_UHS_SDR50 ? MMC_CAP_UHS_SDR50 : 0) |
- (r & GB_SDIO_CAP_UHS_SDR104 ? MMC_CAP_UHS_SDR104 : 0) |
- (r & GB_SDIO_CAP_UHS_DDR50 ? MMC_CAP_UHS_DDR50 : 0) |
- (r & GB_SDIO_CAP_DRIVER_TYPE_A ? MMC_CAP_DRIVER_TYPE_A : 0) |
- (r & GB_SDIO_CAP_DRIVER_TYPE_C ? MMC_CAP_DRIVER_TYPE_C : 0) |
- (r & GB_SDIO_CAP_DRIVER_TYPE_D ? MMC_CAP_DRIVER_TYPE_D : 0);
-
- caps2 = (r & GB_SDIO_CAP_HS200_1_2V ? MMC_CAP2_HS200_1_2V_SDR : 0) |
+ caps = ((r & GB_SDIO_CAP_NONREMOVABLE) ? MMC_CAP_NONREMOVABLE : 0) |
+ ((r & GB_SDIO_CAP_4_BIT_DATA) ? MMC_CAP_4_BIT_DATA : 0) |
+ ((r & GB_SDIO_CAP_8_BIT_DATA) ? MMC_CAP_8_BIT_DATA : 0) |
+ ((r & GB_SDIO_CAP_MMC_HS) ? MMC_CAP_MMC_HIGHSPEED : 0) |
+ ((r & GB_SDIO_CAP_SD_HS) ? MMC_CAP_SD_HIGHSPEED : 0) |
+ ((r & GB_SDIO_CAP_ERASE) ? MMC_CAP_ERASE : 0) |
+ ((r & GB_SDIO_CAP_1_2V_DDR) ? MMC_CAP_1_2V_DDR : 0) |
+ ((r & GB_SDIO_CAP_1_8V_DDR) ? MMC_CAP_1_8V_DDR : 0) |
+ ((r & GB_SDIO_CAP_POWER_OFF_CARD) ? MMC_CAP_POWER_OFF_CARD : 0) |
+ ((r & GB_SDIO_CAP_UHS_SDR12) ? MMC_CAP_UHS_SDR12 : 0) |
+ ((r & GB_SDIO_CAP_UHS_SDR25) ? MMC_CAP_UHS_SDR25 : 0) |
+ ((r & GB_SDIO_CAP_UHS_SDR50) ? MMC_CAP_UHS_SDR50 : 0) |
+ ((r & GB_SDIO_CAP_UHS_SDR104) ? MMC_CAP_UHS_SDR104 : 0) |
+ ((r & GB_SDIO_CAP_UHS_DDR50) ? MMC_CAP_UHS_DDR50 : 0) |
+ ((r & GB_SDIO_CAP_DRIVER_TYPE_A) ? MMC_CAP_DRIVER_TYPE_A : 0) |
+ ((r & GB_SDIO_CAP_DRIVER_TYPE_C) ? MMC_CAP_DRIVER_TYPE_C : 0) |
+ ((r & GB_SDIO_CAP_DRIVER_TYPE_D) ? MMC_CAP_DRIVER_TYPE_D : 0);
+
+ caps2 = ((r & GB_SDIO_CAP_HS200_1_2V) ? MMC_CAP2_HS200_1_2V_SDR : 0) |
#ifdef MMC_HS400_SUPPORTED
- (r & GB_SDIO_CAP_HS400_1_2V ? MMC_CAP2_HS400_1_2V : 0) |
- (r & GB_SDIO_CAP_HS400_1_8V ? MMC_CAP2_HS400_1_8V : 0) |
+ ((r & GB_SDIO_CAP_HS400_1_2V) ? MMC_CAP2_HS400_1_2V : 0) |
+ ((r & GB_SDIO_CAP_HS400_1_8V) ? MMC_CAP2_HS400_1_8V : 0) |
#endif
- (r & GB_SDIO_CAP_HS200_1_8V ? MMC_CAP2_HS200_1_8V_SDR : 0);
+ ((r & GB_SDIO_CAP_HS200_1_8V) ? MMC_CAP2_HS200_1_8V_SDR : 0);
- host->mmc->caps = caps;
+ host->mmc->caps = caps | MMC_CAP_NEEDS_POLL;
host->mmc->caps2 = caps2;
if (caps & MMC_CAP_NONREMOVABLE)
host->card_present = true;
}
+static u32 _gb_sdio_get_host_ocr(u32 ocr)
+{
+ return (((ocr & GB_SDIO_VDD_165_195) ? MMC_VDD_165_195 : 0) |
+ ((ocr & GB_SDIO_VDD_20_21) ? MMC_VDD_20_21 : 0) |
+ ((ocr & GB_SDIO_VDD_21_22) ? MMC_VDD_21_22 : 0) |
+ ((ocr & GB_SDIO_VDD_22_23) ? MMC_VDD_22_23 : 0) |
+ ((ocr & GB_SDIO_VDD_23_24) ? MMC_VDD_23_24 : 0) |
+ ((ocr & GB_SDIO_VDD_24_25) ? MMC_VDD_24_25 : 0) |
+ ((ocr & GB_SDIO_VDD_25_26) ? MMC_VDD_25_26 : 0) |
+ ((ocr & GB_SDIO_VDD_26_27) ? MMC_VDD_26_27 : 0) |
+ ((ocr & GB_SDIO_VDD_27_28) ? MMC_VDD_27_28 : 0) |
+ ((ocr & GB_SDIO_VDD_28_29) ? MMC_VDD_28_29 : 0) |
+ ((ocr & GB_SDIO_VDD_29_30) ? MMC_VDD_29_30 : 0) |
+ ((ocr & GB_SDIO_VDD_30_31) ? MMC_VDD_30_31 : 0) |
+ ((ocr & GB_SDIO_VDD_31_32) ? MMC_VDD_31_32 : 0) |
+ ((ocr & GB_SDIO_VDD_32_33) ? MMC_VDD_32_33 : 0) |
+ ((ocr & GB_SDIO_VDD_33_34) ? MMC_VDD_33_34 : 0) |
+ ((ocr & GB_SDIO_VDD_34_35) ? MMC_VDD_34_35 : 0) |
+ ((ocr & GB_SDIO_VDD_35_36) ? MMC_VDD_35_36 : 0)
+ );
+}
+
static int gb_sdio_get_caps(struct gb_sdio_host *host)
{
struct gb_sdio_get_caps_response response;
struct mmc_host *mmc = host->mmc;
u16 data_max;
u32 blksz;
+ u32 ocr;
u32 r;
int ret;
host->data_max = data_max;
/* get ocr supported values */
- mmc->ocr_avail = le32_to_cpu(response.ocr);
+ ocr = _gb_sdio_get_host_ocr(le32_to_cpu(response.ocr));
+ mmc->ocr_avail = ocr;
mmc->ocr_avail_sdio = mmc->ocr_avail;
mmc->ocr_avail_sd = mmc->ocr_avail;
mmc->ocr_avail_mmc = mmc->ocr_avail;
+ /* get frequency range values */
+ mmc->f_min = le32_to_cpu(response.f_min);
+ mmc->f_max = le32_to_cpu(response.f_max);
+
return 0;
}
-static int gb_sdio_event_recv(u8 type, struct gb_operation *op)
+static void _gb_queue_event(struct gb_sdio_host *host, u8 event)
{
- struct gb_connection *connection = op->connection;
- struct gb_sdio_host *host = connection->private;
- struct gb_message *request;
- struct gb_sdio_event_request *payload;
- u8 state_changed = 0;
- u8 event;
+ if (event & GB_SDIO_CARD_INSERTED)
+ host->queued_events &= ~GB_SDIO_CARD_REMOVED;
+ else if (event & GB_SDIO_CARD_REMOVED)
+ host->queued_events &= ~GB_SDIO_CARD_INSERTED;
- if (type != GB_SDIO_TYPE_EVENT) {
- dev_err(&connection->dev,
- "unsupported unsolicited event: %u\n", type);
- return -EINVAL;
- }
-
- request = op->request;
-
- if (request->payload_size != sizeof(*payload)) {
- dev_err(mmc_dev(host->mmc), "wrong event size received\n");
- return -EINVAL;
- }
+ host->queued_events |= event;
+}
- payload = request->payload;
- event = payload->event;
+static int _gb_sdio_process_events(struct gb_sdio_host *host, u8 event)
+{
+ u8 state_changed = 0;
- switch (event) {
- case GB_SDIO_CARD_INSERTED:
- if (!mmc_card_is_removable(host->mmc))
+ if (event & GB_SDIO_CARD_INSERTED) {
+ if (host->mmc->caps & MMC_CAP_NONREMOVABLE)
return 0;
if (host->card_present)
return 0;
host->card_present = true;
state_changed = 1;
- break;
- case GB_SDIO_CARD_REMOVED:
- if (!mmc_card_is_removable(host->mmc))
+ }
+
+ if (event & GB_SDIO_CARD_REMOVED) {
+ if (host->mmc->caps & MMC_CAP_NONREMOVABLE)
return 0;
if (!(host->card_present))
return 0;
host->card_present = false;
state_changed = 1;
- break;
- case GB_SDIO_WP:
+ }
+
+ if (event & GB_SDIO_WP) {
host->read_only = true;
- break;
- default:
- dev_err(mmc_dev(host->mmc), "wrong event received %d\n", event);
- return -EINVAL;
}
if (state_changed) {
return 0;
}
+static int gb_sdio_request_handler(struct gb_operation *op)
+{
+ struct gb_sdio_host *host = gb_connection_get_data(op->connection);
+ struct gb_message *request;
+ struct gb_sdio_event_request *payload;
+ u8 type = op->type;
+ int ret = 0;
+ u8 event;
+
+ if (type != GB_SDIO_TYPE_EVENT) {
+ dev_err(mmc_dev(host->mmc),
+ "unsupported unsolicited event: %u\n", type);
+ return -EINVAL;
+ }
+
+ request = op->request;
+
+ if (request->payload_size < sizeof(*payload)) {
+ dev_err(mmc_dev(host->mmc), "wrong event size received (%zu < %zu)\n",
+ request->payload_size, sizeof(*payload));
+ return -EINVAL;
+ }
+
+ payload = request->payload;
+ event = payload->event;
+
+ if (host->removed)
+ _gb_queue_event(host, event);
+ else
+ ret = _gb_sdio_process_events(host, event);
+
+ return ret;
+}
+
static int gb_sdio_set_ios(struct gb_sdio_host *host,
struct gb_sdio_set_ios_request *request)
{
request->data_blocks = cpu_to_le16(nblocks);
request->data_blksz = cpu_to_le16(data->blksz);
- copied = sg_pcopy_to_buffer(sg, sg_len, &request->data[0] + skip, len,
- skip);
+ copied = sg_pcopy_to_buffer(sg, sg_len, &request->data[0], len, skip);
if (copied != len)
return -EINVAL;
ret = gb_operation_sync(host->connection, GB_SDIO_TYPE_TRANSFER,
- request, len, &response, sizeof(response));
+ request, len + sizeof(*request),
+ &response, sizeof(response));
if (ret < 0)
return ret;
send_blocks = le16_to_cpu(response.data_blocks);
send_blksz = le16_to_cpu(response.data_blksz);
- if (len != send_blksz * send_blocks)
+ if (len != send_blksz * send_blocks) {
+ dev_err(mmc_dev(host->mmc), "send: size received: %zu != %d\n",
+ len, send_blksz * send_blocks);
return -EINVAL;
+ }
return ret;
}
response = host->xfer_buffer;
ret = gb_operation_sync(host->connection, GB_SDIO_TYPE_TRANSFER,
- &request, sizeof(request), response, len);
+ &request, sizeof(request), response, len +
+ sizeof(*response));
if (ret < 0)
return ret;
recv_blocks = le16_to_cpu(response->data_blocks);
recv_blksz = le16_to_cpu(response->data_blksz);
- if (len != recv_blksz * recv_blocks)
+ if (len != recv_blksz * recv_blocks) {
+ dev_err(mmc_dev(host->mmc), "recv: size received: %d != %zu\n",
+ recv_blksz * recv_blocks, len);
return -EINVAL;
+ }
- copied = sg_pcopy_from_buffer(sg, sg_len, &response->data[0] + skip,
- len, skip);
+ copied = sg_pcopy_from_buffer(sg, sg_len, &response->data[0], len,
+ skip);
if (copied != len)
return -EINVAL;
return 0;
}
-static int gb_sdio_transfer(struct gb_sdio_host *host, struct mmc_request *mrq)
+static int gb_sdio_transfer(struct gb_sdio_host *host, struct mmc_data *data)
{
- struct mmc_data *data = mrq->data;
size_t left, len;
off_t skip = 0;
int ret = 0;
u16 nblocks;
+ if (single_op(data->mrq->cmd) && data->blocks > 1) {
+ ret = -ETIMEDOUT;
+ goto out;
+ }
+
left = data->blksz * data->blocks;
while (left) {
}
spin_unlock(&host->xfer);
len = min(left, host->data_max);
- nblocks = do_div(len, data->blksz);
+ nblocks = len / data->blksz;
len = nblocks * data->blksz;
if (data->flags & MMC_DATA_READ) {
static int gb_sdio_command(struct gb_sdio_host *host, struct mmc_command *cmd)
{
- struct gb_sdio_command_request request;
+ struct gb_sdio_command_request request = {0};
struct gb_sdio_command_response response;
+ struct mmc_data *data = host->mrq->data;
u8 cmd_flags;
u8 cmd_type;
int i;
- int ret = 0;
+ int ret;
switch (mmc_resp_type(cmd)) {
case MMC_RSP_NONE:
break;
case MMC_RSP_R3:
cmd_flags = GB_SDIO_RSP_R3_R4;
+ break;
default:
- dev_err(mmc_dev(host->mmc), "cmd flag invalid %04x\n",
+ dev_err(mmc_dev(host->mmc), "cmd flag invalid 0x%04x\n",
mmc_resp_type(cmd));
ret = -EINVAL;
goto out;
cmd_type = GB_SDIO_CMD_ADTC;
break;
default:
- dev_err(mmc_dev(host->mmc), "cmd type invalid %04x\n",
+ dev_err(mmc_dev(host->mmc), "cmd type invalid 0x%04x\n",
mmc_cmd_type(cmd));
ret = -EINVAL;
goto out;
request.cmd_flags = cmd_flags;
request.cmd_type = cmd_type;
request.cmd_arg = cpu_to_le32(cmd->arg);
+ /* some controllers need to know at command time data details */
+ if (data) {
+ request.data_blocks = cpu_to_le16(data->blocks);
+ request.data_blksz = cpu_to_le16(data->blksz);
+ }
ret = gb_operation_sync(host->connection, GB_SDIO_TYPE_COMMAND,
&request, sizeof(request), &response,
goto done;
if (mrq->data) {
- ret = gb_sdio_transfer(host, host->mrq);
+ ret = gb_sdio_transfer(host, mrq->data);
if (ret < 0)
goto done;
}
- if (mrq->data->stop) {
- ret = gb_sdio_command(host, mrq->data->stop);
+ if (mrq->stop) {
+ ret = gb_sdio_command(host, mrq->stop);
if (ret < 0)
goto done;
}
goto out;
}
- queue_work(gb_sdio_mrq_workqueue, &host->mrqwork);
+ queue_work(host->mrq_workqueue, &host->mrqwork);
mutex_unlock(&host->lock);
return;
struct gb_sdio_host *host = mmc_priv(mmc);
mutex_lock(&host->lock);
- if (host->removed)
+ if (host->removed) {
+ mutex_unlock(&host->lock);
return -ESHUTDOWN;
+ }
mutex_unlock(&host->lock);
- return host->card_present;
+
+ return host->read_only;
}
static int gb_mmc_get_cd(struct mmc_host *mmc)
struct gb_sdio_host *host = mmc_priv(mmc);
mutex_lock(&host->lock);
- if (host->removed)
+ if (host->removed) {
+ mutex_unlock(&host->lock);
return -ESHUTDOWN;
+ }
mutex_unlock(&host->lock);
- return host->read_only;
+
+ return host->card_present;
}
static const struct mmc_host_ops gb_sdio_ops = {
.get_cd = gb_mmc_get_cd,
};
-static int gb_sdio_connection_init(struct gb_connection *connection)
+static int gb_sdio_probe(struct gbphy_device *gbphy_dev,
+ const struct gbphy_device_id *id)
{
+ struct gb_connection *connection;
struct mmc_host *mmc;
struct gb_sdio_host *host;
size_t max_buffer;
int ret = 0;
- mmc = mmc_alloc_host(sizeof(*host), &connection->dev);
+ mmc = mmc_alloc_host(sizeof(*host), &gbphy_dev->dev);
if (!mmc)
return -ENOMEM;
+ connection = gb_connection_create(gbphy_dev->bundle,
+ le16_to_cpu(gbphy_dev->cport_desc->id),
+ gb_sdio_request_handler);
+ if (IS_ERR(connection)) {
+ ret = PTR_ERR(connection);
+ goto exit_mmc_free;
+ }
+
host = mmc_priv(mmc);
host->mmc = mmc;
+ host->removed = true;
host->connection = connection;
- connection->private = host;
+ gb_connection_set_data(connection, host);
+ host->gbphy_dev = gbphy_dev;
+ gb_gbphy_set_data(gbphy_dev, host);
- ret = get_version(host);
- if (ret < 0)
- goto free_mmc;
+ ret = gb_connection_enable_tx(connection);
+ if (ret)
+ goto exit_connection_destroy;
ret = gb_sdio_get_caps(host);
if (ret < 0)
- goto free_mmc;
+ goto exit_connection_disable;
mmc->ops = &gb_sdio_ops;
host->xfer_buffer = kzalloc(max_buffer, GFP_KERNEL);
if (!host->xfer_buffer) {
ret = -ENOMEM;
- goto free_mmc;
+ goto exit_connection_disable;
}
mutex_init(&host->lock);
spin_lock_init(&host->xfer);
- gb_sdio_mrq_workqueue = alloc_workqueue("gb_sdio_mrq", 0, 1);
+ host->mrq_workqueue = alloc_workqueue("mmc-%s", 0, 1,
+ dev_name(&gbphy_dev->dev));
+ if (!host->mrq_workqueue) {
+ ret = -ENOMEM;
+ goto exit_buf_free;
+ }
INIT_WORK(&host->mrqwork, gb_sdio_mrq_work);
+ ret = gb_connection_enable(connection);
+ if (ret)
+ goto exit_wq_destroy;
+
ret = mmc_add_host(mmc);
if (ret < 0)
- goto free_work;
+ goto exit_wq_destroy;
+ host->removed = false;
+ ret = _gb_sdio_process_events(host, host->queued_events);
+ host->queued_events = 0;
return ret;
-free_work:
- destroy_workqueue(gb_sdio_mrq_workqueue);
+exit_wq_destroy:
+ destroy_workqueue(host->mrq_workqueue);
+exit_buf_free:
kfree(host->xfer_buffer);
-
-free_mmc:
- connection->private = NULL;
+exit_connection_disable:
+ gb_connection_disable(connection);
+exit_connection_destroy:
+ gb_connection_destroy(connection);
+exit_mmc_free:
mmc_free_host(mmc);
return ret;
}
-static void gb_sdio_connection_exit(struct gb_connection *connection)
+static void gb_sdio_remove(struct gbphy_device *gbphy_dev)
{
+ struct gb_sdio_host *host = gb_gbphy_get_data(gbphy_dev);
+ struct gb_connection *connection = host->connection;
struct mmc_host *mmc;
- struct gb_sdio_host *host = connection->private;
-
- if (!host)
- return;
mutex_lock(&host->lock);
host->removed = true;
mmc = host->mmc;
- connection->private = NULL;
+ gb_connection_set_data(connection, NULL);
mutex_unlock(&host->lock);
- flush_workqueue(gb_sdio_mrq_workqueue);
- destroy_workqueue(gb_sdio_mrq_workqueue);
+ flush_workqueue(host->mrq_workqueue);
+ destroy_workqueue(host->mrq_workqueue);
+ gb_connection_disable_rx(connection);
mmc_remove_host(mmc);
- mmc_free_host(mmc);
+ gb_connection_disable(connection);
+ gb_connection_destroy(connection);
kfree(host->xfer_buffer);
+ mmc_free_host(mmc);
}
-static struct gb_protocol sdio_protocol = {
- .name = "sdio",
- .id = GREYBUS_PROTOCOL_SDIO,
- .major = GB_SDIO_VERSION_MAJOR,
- .minor = GB_SDIO_VERSION_MINOR,
- .connection_init = gb_sdio_connection_init,
- .connection_exit = gb_sdio_connection_exit,
- .request_recv = gb_sdio_event_recv,
+static const struct gbphy_device_id gb_sdio_id_table[] = {
+ { GBPHY_PROTOCOL(GREYBUS_PROTOCOL_SDIO) },
+ { },
+};
+MODULE_DEVICE_TABLE(gbphy, gb_sdio_id_table);
+
+static struct gbphy_driver sdio_driver = {
+ .name = "sdio",
+ .probe = gb_sdio_probe,
+ .remove = gb_sdio_remove,
+ .id_table = gb_sdio_id_table,
};
-gb_gpbridge_protocol_driver(sdio_protocol);
+module_gbphy_driver(sdio_driver);
+MODULE_LICENSE("GPL v2");
projects / karo-tx-linux.git / blobdiff