os/linux/hif/sdio/sdio_test_driver_core.c - mt7668-wifi-mod - Git at Google

 #include "gl_os.h"

 #if (CFG_SDIO_1BIT_DATA_MODE == 1)
 /*
  *  linux/drivers/mmc/core/core.c
  *
  *  Copyright (C) 2003-2004 Russell King, All Rights Reserved.
  *  SD support Copyright (C) 2004 Ian Molton, All Rights Reserved.
  *  Copyright (C) 2005-2008 Pierre Ossman, All Rights Reserved.
  *  MMCv4 support Copyright (C) 2006 Philip Langdale, All Rights Reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  */
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <linux/completion.h>
 #include <linux/device.h>
 #include <linux/delay.h>
 #include <linux/pagemap.h>
 #include <linux/err.h>
 #include <linux/leds.h>
 #include <linux/scatterlist.h>
 #include <linux/log2.h>
 #include <linux/regulator/consumer.h>

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


 #include "test_driver_sdio_ops.h"


 /*
  * Internal function that does the actual ios call to the host driver,
  * optionally printing some debug output.
  */
 static inline void mmc_set_ios(struct mmc_host *host)
 {
 	struct mmc_ios *ios = &host->ios;

 	pr_debug("%s: clock %uHz busmode %u powermode %u cs %u Vdd %u width %u timing %u\n",
 		 mmc_hostname(host), ios->clock, ios->bus_mode,
 		 ios->power_mode, ios->chip_select, ios->vdd,
 		 ios->bus_width, ios->timing);

 	host->ops->set_ios(host, ios);
 }

 /*
  * Control chip select pin on a host.
  */
 void mmc_set_chip_select(struct mmc_host *host, int mode)
 {
 	host->ios.chip_select = mode;
 	mmc_set_ios(host);
 }

 /*
  * Sets the host clock to the highest possible frequency that
  * is below "hz".
  */
 void mmc_set_clock(struct mmc_host *host, unsigned int hz)
 {
 	WARN_ON(hz < host->f_min);

 	if (hz > host->f_max)
 		hz = host->f_max;

 	#if 1
 	pr_debug("%s(): %dHz\n", __func__, hz);
 	#endif

 	host->ios.clock = hz;
 	mmc_set_ios(host);
 }

 /*
  * Change the bus mode (open drain/push-pull) of a host.
  */
 void mmc_set_bus_mode(struct mmc_host *host, unsigned int mode)
 {
 	host->ios.bus_mode = mode;
 	mmc_set_ios(host);
 }

 /*
  * Change data bus width of a host.
  */
 void mmc_set_bus_width(struct mmc_host *host, unsigned int width)
 {
 	host->ios.bus_width = width;
 	mmc_set_ios(host);
 }

 /*
  * Mask off any voltages we don't support and select
  * the lowest voltage
  */
 u32 mmc_select_voltage(struct mmc_host *host, u32 ocr)
 {
 	int bit;

 	ocr &= host->ocr_avail;

 	bit = ffs(ocr);
 	if (bit) {
 		bit -= 1;

 		ocr &= 3 << bit;

 		host->ios.vdd = bit;
 		mmc_set_ios(host);
 	} else {
 		pr_warn("%s: host doesn't support card's voltages\n",
 				mmc_hostname(host));
 		ocr = 0;
 	}

 	return ocr;
 }

 /*
  * Select timing parameters for host.
  */
 void mmc_set_timing(struct mmc_host *host, unsigned int timing)
 {
 	host->ios.timing = timing;
 	mmc_set_ios(host);
 }


 static void mmc_power_off(struct mmc_host *host)
 {
 	host->ios.clock = 0;
 	host->ios.vdd = 0;
 	if (!mmc_host_is_spi(host)) {
 		host->ios.bus_mode = MMC_BUSMODE_OPENDRAIN;
 		host->ios.chip_select = MMC_CS_DONTCARE;
 	}
 	host->ios.power_mode = MMC_POWER_OFF;
 	host->ios.bus_width = MMC_BUS_WIDTH_1;
 	host->ios.timing = MMC_TIMING_LEGACY;
 	mmc_set_ios(host);
 }

 /*
  * Cleanup when the last reference to the bus operator is dropped.
  */
 static void __mmc_release_bus(struct mmc_host *host)
 {
 	BUG_ON(!host);
 	BUG_ON(host->bus_refs);
 	BUG_ON(!host->bus_dead);

 	host->bus_ops = NULL;
 }

 /*
  * Increase reference count of bus operator
  */
 static inline void mmc_bus_get(struct mmc_host *host)
 {
 	unsigned long flags;

 	spin_lock_irqsave(&host->lock, flags);
 	host->bus_refs++;
 	spin_unlock_irqrestore(&host->lock, flags);
 }

 /*
  * Decrease reference count of bus operator and free it if
  * it is the last reference.
  */
 static inline void mmc_bus_put(struct mmc_host *host)
 {
 	unsigned long flags;

 	spin_lock_irqsave(&host->lock, flags);
 	host->bus_refs--;
 	if ((host->bus_refs == 0) && host->bus_ops)
 		__mmc_release_bus(host);
 	spin_unlock_irqrestore(&host->lock, flags);
 }

 /*
  * Assign a mmc bus handler to a host. Only one bus handler may control a
  * host at any given time.
  */
 void mmc_attach_bus(struct mmc_host *host, const struct mmc_bus_ops *ops)
 {
 	unsigned long flags;

 	BUG_ON(!host);
 	BUG_ON(!ops);

 	WARN_ON(!host->claimed);

 	spin_lock_irqsave(&host->lock, flags);

 	BUG_ON(host->bus_ops);
 	BUG_ON(host->bus_refs);

 	host->bus_ops = ops;
 	host->bus_refs = 1;
 	host->bus_dead = 0;

 	spin_unlock_irqrestore(&host->lock, flags);
 }

 /*
  * Remove the current bus handler from a host. Assumes that there are
  * no interesting cards left, so the bus is powered down.
  */
 void mmc_detach_bus(struct mmc_host *host)
 {
 	unsigned long flags;

 	BUG_ON(!host);

 	WARN_ON(!host->claimed);
 	WARN_ON(!host->bus_ops);

 	spin_lock_irqsave(&host->lock, flags);

 	host->bus_dead = 1;

 	spin_unlock_irqrestore(&host->lock, flags);

 	mmc_power_off(host);

 	mmc_bus_put(host);
 }

 int mmc_app_set_bus_width(struct mmc_card *card, int width)
 {
 	int err;
 	struct mmc_command cmd;

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

 	memset(&cmd, 0, sizeof(struct mmc_command));

 	cmd.opcode = SD_APP_SET_BUS_WIDTH;
 	cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;

 	switch (width) {
 	case MMC_BUS_WIDTH_1:
 		cmd.arg = SD_BUS_WIDTH_1;
 		break;
 	case MMC_BUS_WIDTH_4:
 		cmd.arg = SD_BUS_WIDTH_4;
 		break;
 	default:
 		return -EINVAL;
 	}

 	err = mmc_wait_for_app_cmd(card->host, card, &cmd, MMC_CMD_RETRIES);
 	if (err)
 		return err;

 	return 0;
 }

 int mmc_send_app_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr)
 {
 	struct mmc_command cmd;
 	int i, err = 0;

 	BUG_ON(!host);

 	memset(&cmd, 0, sizeof(struct mmc_command));

 	cmd.opcode = SD_APP_OP_COND;
 	if (mmc_host_is_spi(host))
 		cmd.arg = ocr & (1 << 30); /* SPI only defines one bit */
 	else
 		cmd.arg = ocr;
 	cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R3 | MMC_CMD_BCR;

 	for (i = 100; i; i--) {
 		err = mmc_wait_for_app_cmd(host, NULL, &cmd, MMC_CMD_RETRIES);
 		if (err)
 			break;

 		/* if we're just probing, do a single pass */
 		if (ocr == 0)
 			break;

 		/* otherwise wait until reset completes */
 		if (mmc_host_is_spi(host)) {
 			if (!(cmd.resp[0] & R1_SPI_IDLE))
 				break;
 		} else {
 			if (cmd.resp[0] & MMC_CARD_BUSY)
 				break;
 		}

 		err = -ETIMEDOUT;

 		mmc_delay(10);
 	}

 	if (rocr && !mmc_host_is_spi(host))
 		*rocr = cmd.resp[0];

 	return err;
 }

 int mmc_send_if_cond(struct mmc_host *host, u32 ocr)
 {
 	struct mmc_command cmd;
 	int err;
 	static const u8 test_pattern = 0xAA;
 	u8 result_pattern;

 	/*
 	 * To support SD 2.0 cards, we must always invoke SD_SEND_IF_COND
 	 * before SD_APP_OP_COND. This command will harmlessly fail for
 	 * SD 1.0 cards.
 	 */
 	cmd.opcode = SD_SEND_IF_COND;
 	cmd.arg = ((ocr & 0xFF8000) != 0) << 8 | test_pattern;
 	cmd.flags = MMC_RSP_SPI_R7 | MMC_RSP_R7 | MMC_CMD_BCR;

 	err = mmc_wait_for_cmd(host, &cmd, 0);
 	if (err)
 		return err;

 	if (mmc_host_is_spi(host))
 		result_pattern = cmd.resp[1] & 0xFF;
 	else
 		result_pattern = cmd.resp[0] & 0xFF;

 	if (result_pattern != test_pattern)
 		return -EIO;

 	return 0;
 }


 static int sdio_enable_wide(struct mmc_card *card)
 {
 	int ret;
 	u8 ctrl;

 	if (!(card->host->caps & MMC_CAP_4_BIT_DATA))
 		return 0;


 	if (card->cccr.low_speed && !card->cccr.wide_bus)
 		return 0;


 	ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_IF, 0, &ctrl);
 	if (ret)
 		return ret;


 	if ((ctrl & SDIO_BUS_WIDTH_MASK) == SDIO_BUS_WIDTH_RESERVED)
 		pr_warn("%s: SDIO_CCCR_IF is invalid: 0x%02x\n",
 			mmc_hostname(card->host), ctrl);

 	/* set as 4-bit bus width */
 	ctrl &= ~SDIO_BUS_WIDTH_MASK;
 	ctrl |= SDIO_BUS_WIDTH_4BIT;

 	ret = mmc_io_rw_direct(card, 1, 0, SDIO_CCCR_IF, ctrl, NULL);
 	if (ret)
 		return ret;

 	return 1;
 }


 /*
  * Devices that remain active during a system suspend are
  * put back into 1-bit mode.
  */
 int sdio_disable_wide(struct mmc_card *card)
 {
 	int ret;
 	u8 ctrl;

 	if (!(card->host->caps & MMC_CAP_4_BIT_DATA))
 		return 0;


 	if (card->cccr.low_speed && !card->cccr.wide_bus)
 		return 0;


 	ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_IF, 0, &ctrl);
 	if (ret)
 		return ret;


 	if (!(ctrl & SDIO_BUS_WIDTH_4BIT))
 		return 0;


 	ctrl &= ~SDIO_BUS_WIDTH_4BIT;
 	ctrl |= SDIO_BUS_ASYNC_INT;

 	ret = mmc_io_rw_direct(card, 1, 0, SDIO_CCCR_IF, ctrl, NULL);
 	if (ret)
 		return ret;


 	mmc_set_bus_width(card->host, MMC_BUS_WIDTH_1);

 	return 0;
 }


 int sdio_enable_4bit_bus(struct mmc_card *card)
 {
 	int err;

 	if (card->type == MMC_TYPE_SDIO)
 		return sdio_enable_wide(card);


 	if ((card->host->caps & MMC_CAP_4_BIT_DATA) &&
 		(card->scr.bus_widths & SD_SCR_BUS_WIDTH_4)) {

 		err = mmc_app_set_bus_width(card, MMC_BUS_WIDTH_4);
 		if (err)
 			return err;
 	} else
 		return 0;


 	err = sdio_enable_wide(card);
 	if (err <= 0)
 		mmc_app_set_bus_width(card, MMC_BUS_WIDTH_1);

 	return err;
 }
 #endif
	#include "gl_os.h"

	#if (CFG_SDIO_1BIT_DATA_MODE == 1)
	/*
	* linux/drivers/mmc/core/core.c
	*
	* Copyright (C) 2003-2004 Russell King, All Rights Reserved.
	* SD support Copyright (C) 2004 Ian Molton, All Rights Reserved.
	* Copyright (C) 2005-2008 Pierre Ossman, All Rights Reserved.
	* MMCv4 support Copyright (C) 2006 Philip Langdale, All Rights Reserved.
	*
	* This program is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License version 2 as
	* published by the Free Software Foundation.
	*/
	#include <linux/module.h>
	#include <linux/init.h>
	#include <linux/interrupt.h>
	#include <linux/completion.h>
	#include <linux/device.h>
	#include <linux/delay.h>
	#include <linux/pagemap.h>
	#include <linux/err.h>
	#include <linux/leds.h>
	#include <linux/scatterlist.h>
	#include <linux/log2.h>
	#include <linux/regulator/consumer.h>

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


	#include "test_driver_sdio_ops.h"


	/*
	* Internal function that does the actual ios call to the host driver,
	* optionally printing some debug output.
	*/
	static inline void mmc_set_ios(struct mmc_host *host)
	{
	struct mmc_ios *ios = &host->ios;

	pr_debug("%s: clock %uHz busmode %u powermode %u cs %u Vdd %u width %u timing %u\n",
	mmc_hostname(host), ios->clock, ios->bus_mode,
	ios->power_mode, ios->chip_select, ios->vdd,
	ios->bus_width, ios->timing);

	host->ops->set_ios(host, ios);
	}

	/*
	* Control chip select pin on a host.
	*/
	void mmc_set_chip_select(struct mmc_host *host, int mode)
	{
	host->ios.chip_select = mode;
	mmc_set_ios(host);
	}

	/*
	* Sets the host clock to the highest possible frequency that
	* is below "hz".
	*/
	void mmc_set_clock(struct mmc_host *host, unsigned int hz)
	{
	WARN_ON(hz < host->f_min);

	if (hz > host->f_max)
	hz = host->f_max;

	#if 1
	pr_debug("%s(): %dHz\n", __func__, hz);
	#endif

	host->ios.clock = hz;
	mmc_set_ios(host);
	}

	/*
	* Change the bus mode (open drain/push-pull) of a host.
	*/
	void mmc_set_bus_mode(struct mmc_host *host, unsigned int mode)
	{
	host->ios.bus_mode = mode;
	mmc_set_ios(host);
	}

	/*
	* Change data bus width of a host.
	*/
	void mmc_set_bus_width(struct mmc_host *host, unsigned int width)
	{
	host->ios.bus_width = width;
	mmc_set_ios(host);
	}

	/*
	* Mask off any voltages we don't support and select
	* the lowest voltage
	*/
	u32 mmc_select_voltage(struct mmc_host *host, u32 ocr)
	{
	int bit;

	ocr &= host->ocr_avail;

	bit = ffs(ocr);
	if (bit) {
	bit -= 1;

	ocr &= 3 << bit;

	host->ios.vdd = bit;
	mmc_set_ios(host);
	} else {
	pr_warn("%s: host doesn't support card's voltages\n",
	mmc_hostname(host));
	ocr = 0;
	}

	return ocr;
	}

	/*
	* Select timing parameters for host.
	*/
	void mmc_set_timing(struct mmc_host *host, unsigned int timing)
	{
	host->ios.timing = timing;
	mmc_set_ios(host);
	}


	static void mmc_power_off(struct mmc_host *host)
	{
	host->ios.clock = 0;
	host->ios.vdd = 0;
	if (!mmc_host_is_spi(host)) {
	host->ios.bus_mode = MMC_BUSMODE_OPENDRAIN;
	host->ios.chip_select = MMC_CS_DONTCARE;
	}
	host->ios.power_mode = MMC_POWER_OFF;
	host->ios.bus_width = MMC_BUS_WIDTH_1;
	host->ios.timing = MMC_TIMING_LEGACY;
	mmc_set_ios(host);
	}

	/*
	* Cleanup when the last reference to the bus operator is dropped.
	*/
	static void __mmc_release_bus(struct mmc_host *host)
	{
	BUG_ON(!host);
	BUG_ON(host->bus_refs);
	BUG_ON(!host->bus_dead);

	host->bus_ops = NULL;
	}

	/*
	* Increase reference count of bus operator
	*/
	static inline void mmc_bus_get(struct mmc_host *host)
	{
	unsigned long flags;

	spin_lock_irqsave(&host->lock, flags);
	host->bus_refs++;
	spin_unlock_irqrestore(&host->lock, flags);
	}

	/*
	* Decrease reference count of bus operator and free it if
	* it is the last reference.
	*/
	static inline void mmc_bus_put(struct mmc_host *host)
	{
	unsigned long flags;

	spin_lock_irqsave(&host->lock, flags);
	host->bus_refs--;
	if ((host->bus_refs == 0) && host->bus_ops)
	__mmc_release_bus(host);
	spin_unlock_irqrestore(&host->lock, flags);
	}

	/*
	* Assign a mmc bus handler to a host. Only one bus handler may control a
	* host at any given time.
	*/
	void mmc_attach_bus(struct mmc_host host, const struct mmc_bus_ops ops)
	{
	unsigned long flags;

	BUG_ON(!host);
	BUG_ON(!ops);

	WARN_ON(!host->claimed);

	spin_lock_irqsave(&host->lock, flags);

	BUG_ON(host->bus_ops);
	BUG_ON(host->bus_refs);

	host->bus_ops = ops;
	host->bus_refs = 1;
	host->bus_dead = 0;

	spin_unlock_irqrestore(&host->lock, flags);
	}

	/*
	* Remove the current bus handler from a host. Assumes that there are
	* no interesting cards left, so the bus is powered down.
	*/
	void mmc_detach_bus(struct mmc_host *host)
	{
	unsigned long flags;

	BUG_ON(!host);

	WARN_ON(!host->claimed);
	WARN_ON(!host->bus_ops);

	spin_lock_irqsave(&host->lock, flags);

	host->bus_dead = 1;

	spin_unlock_irqrestore(&host->lock, flags);

	mmc_power_off(host);

	mmc_bus_put(host);
	}

	int mmc_app_set_bus_width(struct mmc_card *card, int width)
	{
	int err;
	struct mmc_command cmd;

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

	memset(&cmd, 0, sizeof(struct mmc_command));

	cmd.opcode = SD_APP_SET_BUS_WIDTH;
	cmd.flags = MMC_RSP_R1 \| MMC_CMD_AC;

	switch (width) {
	case MMC_BUS_WIDTH_1:
	cmd.arg = SD_BUS_WIDTH_1;
	break;
	case MMC_BUS_WIDTH_4:
	cmd.arg = SD_BUS_WIDTH_4;
	break;
	default:
	return -EINVAL;
	}

	err = mmc_wait_for_app_cmd(card->host, card, &cmd, MMC_CMD_RETRIES);
	if (err)
	return err;

	return 0;
	}

	int mmc_send_app_op_cond(struct mmc_host host, u32 ocr, u32 rocr)
	{
	struct mmc_command cmd;
	int i, err = 0;

	BUG_ON(!host);

	memset(&cmd, 0, sizeof(struct mmc_command));

	cmd.opcode = SD_APP_OP_COND;
	if (mmc_host_is_spi(host))
	cmd.arg = ocr & (1 << 30); /* SPI only defines one bit */
	else
	cmd.arg = ocr;
	cmd.flags = MMC_RSP_SPI_R1 \| MMC_RSP_R3 \| MMC_CMD_BCR;

	for (i = 100; i; i--) {
	err = mmc_wait_for_app_cmd(host, NULL, &cmd, MMC_CMD_RETRIES);
	if (err)
	break;

	/* if we're just probing, do a single pass */
	if (ocr == 0)
	break;

	/* otherwise wait until reset completes */
	if (mmc_host_is_spi(host)) {
	if (!(cmd.resp[0] & R1_SPI_IDLE))
	break;
	} else {
	if (cmd.resp[0] & MMC_CARD_BUSY)
	break;
	}

	err = -ETIMEDOUT;

	mmc_delay(10);
	}

	if (rocr && !mmc_host_is_spi(host))
	*rocr = cmd.resp[0];

	return err;
	}

	int mmc_send_if_cond(struct mmc_host *host, u32 ocr)
	{
	struct mmc_command cmd;
	int err;
	static const u8 test_pattern = 0xAA;
	u8 result_pattern;

	/*
	* To support SD 2.0 cards, we must always invoke SD_SEND_IF_COND
	* before SD_APP_OP_COND. This command will harmlessly fail for
	* SD 1.0 cards.
	*/
	cmd.opcode = SD_SEND_IF_COND;
	cmd.arg = ((ocr & 0xFF8000) != 0) << 8 \| test_pattern;
	cmd.flags = MMC_RSP_SPI_R7 \| MMC_RSP_R7 \| MMC_CMD_BCR;

	err = mmc_wait_for_cmd(host, &cmd, 0);
	if (err)
	return err;

	if (mmc_host_is_spi(host))
	result_pattern = cmd.resp[1] & 0xFF;
	else
	result_pattern = cmd.resp[0] & 0xFF;

	if (result_pattern != test_pattern)
	return -EIO;

	return 0;
	}



	static int sdio_enable_wide(struct mmc_card *card)
	{
	int ret;
	u8 ctrl;

	if (!(card->host->caps & MMC_CAP_4_BIT_DATA))
	return 0;


	if (card->cccr.low_speed && !card->cccr.wide_bus)
	return 0;


	ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_IF, 0, &ctrl);
	if (ret)
	return ret;


	if ((ctrl & SDIO_BUS_WIDTH_MASK) == SDIO_BUS_WIDTH_RESERVED)
	pr_warn("%s: SDIO_CCCR_IF is invalid: 0x%02x\n",
	mmc_hostname(card->host), ctrl);

	/* set as 4-bit bus width */
	ctrl &= ~SDIO_BUS_WIDTH_MASK;
	ctrl \|= SDIO_BUS_WIDTH_4BIT;

	ret = mmc_io_rw_direct(card, 1, 0, SDIO_CCCR_IF, ctrl, NULL);
	if (ret)
	return ret;

	return 1;
	}



	/*
	* Devices that remain active during a system suspend are
	* put back into 1-bit mode.
	*/
	int sdio_disable_wide(struct mmc_card *card)
	{
	int ret;
	u8 ctrl;

	if (!(card->host->caps & MMC_CAP_4_BIT_DATA))
	return 0;


	if (card->cccr.low_speed && !card->cccr.wide_bus)
	return 0;


	ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_IF, 0, &ctrl);
	if (ret)
	return ret;


	if (!(ctrl & SDIO_BUS_WIDTH_4BIT))
	return 0;


	ctrl &= ~SDIO_BUS_WIDTH_4BIT;
	ctrl \|= SDIO_BUS_ASYNC_INT;

	ret = mmc_io_rw_direct(card, 1, 0, SDIO_CCCR_IF, ctrl, NULL);
	if (ret)
	return ret;


	mmc_set_bus_width(card->host, MMC_BUS_WIDTH_1);

	return 0;
	}


	int sdio_enable_4bit_bus(struct mmc_card *card)
	{
	int err;

	if (card->type == MMC_TYPE_SDIO)
	return sdio_enable_wide(card);


	if ((card->host->caps & MMC_CAP_4_BIT_DATA) &&
	(card->scr.bus_widths & SD_SCR_BUS_WIDTH_4)) {

	err = mmc_app_set_bus_width(card, MMC_BUS_WIDTH_4);
	if (err)
	return err;
	} else
	return 0;


	err = sdio_enable_wide(card);
	if (err <= 0)
	mmc_app_set_bus_width(card, MMC_BUS_WIDTH_1);

	return err;
	}
	#endif