sdio: core support for SDIO function interrupt (d1496c39) · Commits · github.com / kvm-riscv / linux

drivers/mmc/core/Makefile

+1 −1

Original line number	Diff line number	Diff line
		@@ -10,5 +10,5 @@ obj-$(CONFIG_MMC) += mmc_core.o
		mmc_core-y := core.o sysfs.o bus.o host.o \
		mmc.o mmc_ops.o sd.o sd_ops.o \
		sdio.o sdio_ops.o sdio_bus.o \
		sdio_cis.o sdio_io.o
		sdio_cis.o sdio_io.o sdio_irq.o

drivers/mmc/core/sdio_bus.c

+8 −0

Original line number	Diff line number	Diff line
		@@ -143,6 +143,14 @@ static int sdio_bus_remove(struct device *dev)

		drv->remove(func);

		if (func->irq_handler) {
		printk(KERN_WARNING "WARNING: driver %s did not remove "
		"its interrupt handler!\n", drv->name);
		sdio_claim_host(func);
		sdio_release_irq(func);
		sdio_release_host(func);
		}

		return 0;
		}

drivers/mmc/core/sdio_irq.c

0 → 100644

+237 −0

Original line number	Diff line number	Diff line
		/*
		* linux/drivers/mmc/core/sdio_irq.c
		*
		* Author: Nicolas Pitre
		* Created: June 18, 2007
		* Copyright: MontaVista Software Inc.
		*
		* This program is free software; you can redistribute it and/or modify
		* it under the terms of the GNU General Public License as published by
		* the Free Software Foundation; either version 2 of the License, or (at
		* your option) any later version.
		*/

		#include <linux/kernel.h>
		#include <linux/sched.h>
		#include <linux/kthread.h>
		#include <linux/wait.h>
		#include <linux/delay.h>

		#include <linux/mmc/core.h>
		#include <linux/mmc/host.h>
		#include <linux/mmc/card.h>
		#include <linux/mmc/sdio.h>
		#include <linux/mmc/sdio_func.h>

		#include "sdio_ops.h"

		static int process_sdio_pending_irqs(struct mmc_card *card)
		{
		int i, ret;
		unsigned char pending;

		ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_INTx, 0, &pending);
		if (ret) {
		printk(KERN_DEBUG "%s: error %d reading SDIO_CCCR_INTx\n",
		mmc_card_id(card), ret);
		return ret;
		}

		for (i = 1; i <= 7; i++) {
		if (pending & (1 << i)) {
		struct sdio_func *func = card->sdio_func[i - 1];
		if (!func) {
		printk(KERN_WARNING "%s: pending IRQ for "
		"non-existant function\n",
		sdio_func_id(func));
		} else if (func->irq_handler) {
		func->irq_handler(func);
		} else
		printk(KERN_WARNING "%s: pending IRQ with no handler\n",
		sdio_func_id(func));
		}
		}

		return 0;
		}

		static int sdio_irq_thread(void *_host)
		{
		struct mmc_host *host = _host;
		struct sched_param param = { .sched_priority = 1 };
		unsigned long period;
		int ret;

		sched_setscheduler(current, SCHED_FIFO, &param);

		/*
		* We want to allow for SDIO cards to work even on non SDIO
		* aware hosts. One thing that non SDIO host cannot do is
		* asynchronous notification of pending SDIO card interrupts
		* hence we poll for them in that case.
		*/
		period = msecs_to_jiffies(10);

		pr_debug("%s: IRQ thread started (poll period = %lu jiffies)\n",
		mmc_hostname(host), period);

		do {
		/*
		* We claim the host here on drivers behalf for a couple
		* reasons:
		*
		* 1) it is already needed to retrieve the CCCR_INTx;
		* 2) we want the driver(s) to clear the IRQ condition ASAP;
		* 3) we need to control the abort condition locally.
		*
		* Just like traditional hard IRQ handlers, we expect SDIO
		* IRQ handlers to be quick and to the point, so that the
		* holding of the host lock does not cover too much work
		* that doesn't require that lock to be held.
		*/
		ret = __mmc_claim_host(host, &host->sdio_irq_thread_abort);
		if (ret)
		break;
		ret = process_sdio_pending_irqs(host->card);
		mmc_release_host(host);

		/*
		* Give other threads a chance to run in the presence of
		* errors. FIXME: determine if due to card removal and
		* possibly exit this thread if so.
		*/
		if (ret)
		ssleep(1);

		set_task_state(current, TASK_INTERRUPTIBLE);
		if (!kthread_should_stop())
		schedule_timeout(period);
		set_task_state(current, TASK_RUNNING);
		} while (!kthread_should_stop());

		pr_debug("%s: IRQ thread exiting with code %d\n",
		mmc_hostname(host), ret);

		return ret;
		}

		static int sdio_card_irq_get(struct mmc_card *card)
		{
		struct mmc_host *host = card->host;

		BUG_ON(!host->claimed);

		if (!host->sdio_irqs++) {
		atomic_set(&host->sdio_irq_thread_abort, 0);
		host->sdio_irq_thread =
		kthread_run(sdio_irq_thread, host, "ksdiorqd");
		if (IS_ERR(host->sdio_irq_thread)) {
		int err = PTR_ERR(host->sdio_irq_thread);
		host->sdio_irqs--;
		return err;
		}
		}

		return 0;
		}

		static int sdio_card_irq_put(struct mmc_card *card)
		{
		struct mmc_host *host = card->host;

		BUG_ON(!host->claimed);
		BUG_ON(host->sdio_irqs < 1);

		if (!--host->sdio_irqs) {
		atomic_set(&host->sdio_irq_thread_abort, 1);
		kthread_stop(host->sdio_irq_thread);
		}

		return 0;
		}

		/**
		* sdio_claim_irq - claim the IRQ for a SDIO function
		* @func: SDIO function
		* @handler: IRQ handler callback
		*
		* Claim and activate the IRQ for the given SDIO function. The provided
		* handler will be called when that IRQ is asserted. The host is always
		* claimed already when the handler is called so the handler must not
		* call sdio_claim_host() nor sdio_release_host().
		*/
		int sdio_claim_irq(struct sdio_func func, sdio_irq_handler_t handler)
		{
		int ret;
		unsigned char reg;

		BUG_ON(!func);
		BUG_ON(!func->card);

		pr_debug("SDIO: Enabling IRQ for %s...\n", sdio_func_id(func));

		if (func->irq_handler) {
		pr_debug("SDIO: IRQ for %s already in use.\n", sdio_func_id(func));
		return -EBUSY;
		}

		ret = mmc_io_rw_direct(func->card, 0, 0, SDIO_CCCR_IENx, 0, &reg);
		if (ret)
		return ret;

		reg \|= 1 << func->num;

		reg \|= 1; /* Master interrupt enable */

		ret = mmc_io_rw_direct(func->card, 1, 0, SDIO_CCCR_IENx, reg, NULL);
		if (ret)
		return ret;

		func->irq_handler = handler;
		ret = sdio_card_irq_get(func->card);
		if (ret)
		func->irq_handler = NULL;

		return ret;
		}
		EXPORT_SYMBOL_GPL(sdio_claim_irq);

		/**
		* sdio_release_irq - release the IRQ for a SDIO function
		* @func: SDIO function
		*
		* Disable and release the IRQ for the given SDIO function.
		*/
		int sdio_release_irq(struct sdio_func *func)
		{
		int ret;
		unsigned char reg;

		BUG_ON(!func);
		BUG_ON(!func->card);

		pr_debug("SDIO: Disabling IRQ for %s...\n", sdio_func_id(func));

		if (func->irq_handler) {
		func->irq_handler = NULL;
		sdio_card_irq_put(func->card);
		}

		ret = mmc_io_rw_direct(func->card, 0, 0, SDIO_CCCR_IENx, 0, &reg);
		if (ret)
		return ret;

		reg &= ~(1 << func->num);

		/* Disable master interrupt with the last function interrupt */
		if (!(reg & 0xFE))
		reg = 0;

		ret = mmc_io_rw_direct(func->card, 1, 0, SDIO_CCCR_IENx, reg, NULL);
		if (ret)
		return ret;

		return 0;
		}
		EXPORT_SYMBOL_GPL(sdio_release_irq);

include/linux/mmc/host.h

+4 −0

Original line number	Diff line number	Diff line
		@@ -123,6 +123,10 @@ struct mmc_host {
		unsigned int bus_refs; /* reference counter */
		unsigned int bus_dead:1; /* bus has been released */

		unsigned int sdio_irqs;
		struct task_struct *sdio_irq_thread;
		atomic_t sdio_irq_thread_abort;

		unsigned long private[0] ____cacheline_aligned;
		};

include/linux/mmc/sdio_func.h

+7 −0

Original line number	Diff line number	Diff line
		@@ -16,6 +16,9 @@
		#include <linux/mod_devicetable.h>

		struct mmc_card;
		struct sdio_func;

		typedef void (sdio_irq_handler_t)(struct sdio_func *);

		/*
		* SDIO function CIS tuple (unknown to the core)
		@@ -33,6 +36,7 @@ struct sdio_func_tuple {
		struct sdio_func {
		struct mmc_card card; / the card this device belongs to */
		struct device dev; /* the device */
		sdio_irq_handler_t irq_handler; / IRQ callback */
		unsigned int num; /* function number */

		unsigned char class; /* standard interface class */
		@@ -105,6 +109,9 @@ extern void sdio_release_host(struct sdio_func *func);
		extern int sdio_enable_func(struct sdio_func *func);
		extern int sdio_disable_func(struct sdio_func *func);

		extern int sdio_claim_irq(struct sdio_func func, sdio_irq_handler_t handler);
		extern int sdio_release_irq(struct sdio_func *func);

		extern unsigned char sdio_readb(struct sdio_func *func,
		unsigned int addr, int *err_ret);