sdio: split up common and function CIS parsing
Pierre Ossman [Mon, 30 Jul 2007 13:15:30 +0000 (15:15 +0200)]
Add a more clean separation between global, common CIS information
and the function specific one as we need the common information in
places where no specific function is specified.

Signed-off-by: Pierre Ossman <drzeus@drzeus.cx>

drivers/mmc/core/bus.c
drivers/mmc/core/sdio.c
drivers/mmc/core/sdio_bus.c
drivers/mmc/core/sdio_cis.c
drivers/mmc/core/sdio_cis.h
include/linux/mmc/card.h
include/linux/mmc/sdio_func.h

index 87a6070..9be11ec 100644 (file)
@@ -19,6 +19,7 @@
 
 #include "sysfs.h"
 #include "core.h"
+#include "sdio_cis.h"
 #include "bus.h"
 
 #define dev_to_mmc_card(d)     container_of(d, struct mmc_card, dev)
@@ -181,6 +182,8 @@ static void mmc_release_card(struct device *dev)
 {
        struct mmc_card *card = dev_to_mmc_card(dev);
 
+       sdio_free_common_cis(card);
+
        kfree(card);
 }
 
index c5baf76..1fb36a3 100644 (file)
@@ -66,7 +66,7 @@ static int sdio_init_func(struct mmc_card *card, unsigned int fn)
        if (ret)
                goto fail;
 
-       ret = sdio_read_cis(func);
+       ret = sdio_read_func_cis(func);
        if (ret)
                goto fail;
 
@@ -287,6 +287,13 @@ int mmc_attach_sdio(struct mmc_host *host, u32 ocr)
                goto remove;
 
        /*
+        * Read the common CIS tuples.
+        */
+       err = sdio_read_common_cis(card);
+       if (err)
+               goto remove;
+
+       /*
         * Initialize (but don't add) all present functions.
         */
        for (i = 0;i < funcs;i++) {
index 78e0381..461fe48 100644 (file)
@@ -95,7 +95,7 @@ static void sdio_release_func(struct device *dev)
 {
        struct sdio_func *func = dev_to_sdio_func(dev);
 
-       sdio_free_cis(func);
+       sdio_free_func_cis(func);
 
        kfree(func);
 }
index b6c7342..ec806a1 100644 (file)
 #include <linux/kernel.h>
 
 #include <linux/mmc/host.h>
+#include <linux/mmc/card.h>
 #include <linux/mmc/sdio.h>
 #include <linux/mmc/sdio_func.h>
 
 #include "sdio_cis.h"
 #include "sdio_ops.h"
 
-static int cistpl_manfid(struct sdio_func *func,
-                        const unsigned char *buf,
-                        unsigned size)
+static int cistpl_manfid(struct mmc_card *card, struct sdio_func *func,
+                        const unsigned char *buf, unsigned size)
 {
+       unsigned int vendor, device;
+
        /* TPLMID_MANF */
-       func->vendor = buf[0] | (buf[1] << 8);
+       vendor = buf[0] | (buf[1] << 8);
 
        /* TPLMID_CARD */
-       func->device = buf[2] | (buf[3] << 8);
+       device = buf[2] | (buf[3] << 8);
+
+       if (func) {
+               func->vendor = vendor;
+               func->device = device;
+       } else {
+               card->cis.vendor = vendor;
+               card->cis.device = device;
+       }
+
+       return 0;
+}
+
+static const unsigned char speed_val[16] =
+       { 0, 10, 12, 13, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 70, 80 };
+static const unsigned int speed_unit[8] =
+       { 10000, 100000, 1000000, 10000000, 0, 0, 0, 0 };
+
+static int cistpl_funce_common(struct mmc_card *card,
+                              const unsigned char *buf, unsigned size)
+{
+       if (size < 0x04 || buf[0] != 0)
+               return -EINVAL;
+
+       /* TPLFE_FN0_BLK_SIZE */
+       card->cis.blksize = buf[1] | (buf[2] << 8);
+
+       /* TPLFE_MAX_TRAN_SPEED */
+       card->cis.max_dtr = speed_val[(buf[3] >> 3) & 15] *
+                           speed_unit[buf[3] & 7];
+
+       return 0;
+}
+
+static int cistpl_funce_func(struct sdio_func *func,
+                            const unsigned char *buf, unsigned size)
+{
+       unsigned vsn;
+       unsigned min_size;
+
+       vsn = func->card->cccr.sdio_vsn;
+       min_size = (vsn == SDIO_SDIO_REV_1_00) ? 28 : 42;
+
+       if (size < min_size || buf[0] != 1)
+               return -EINVAL;
+
+       /* TPLFE_MAX_BLK_SIZE */
+       func->blksize = buf[12] | (buf[13] << 8);
 
        return 0;
 }
 
+static int cistpl_funce(struct mmc_card *card, struct sdio_func *func,
+                       const unsigned char *buf, unsigned size)
+{
+       int ret;
+
+       /*
+        * There should be two versions of the CISTPL_FUNCE tuple,
+        * one for the common CIS (function 0) and a version used by
+        * the individual function's CIS (1-7). Yet, the later has a
+        * different length depending on the SDIO spec version.
+        */
+       if (func)
+               ret = cistpl_funce_func(func, buf, size);
+       else
+               ret = cistpl_funce_common(card, buf, size);
+
+       if (ret) {
+               printk(KERN_ERR "%s: bad CISTPL_FUNCE size %u "
+                      "type %u\n", mmc_hostname(card->host), size, buf[0]);
+               return ret;
+       }
+
+       return 0;
+}
+
+typedef int (tpl_parse_t)(struct mmc_card *, struct sdio_func *,
+                          const unsigned char *, unsigned);
+
 struct cis_tpl {
        unsigned char code;
        unsigned char min_size;
-       int (*parse)(struct sdio_func *, const unsigned char *buf, unsigned size);
+       tpl_parse_t *parse;
 };
 
 static const struct cis_tpl cis_tpl_list[] = {
        {       0x15,   3,      /* cistpl_vers_1 */     },
        {       0x20,   4,      cistpl_manfid           },
        {       0x21,   2,      /* cistpl_funcid */     },
-       {       0x22,   0,      /* cistpl_funce */      },
+       {       0x22,   0,      cistpl_funce            },
 };
 
-int sdio_read_cis(struct sdio_func *func)
+static int sdio_read_cis(struct mmc_card *card, struct sdio_func *func)
 {
        int ret;
        struct sdio_func_tuple *this, **prev;
        unsigned i, ptr = 0;
 
+       /*
+        * Note that this works for the common CIS (function number 0) as
+        * well as a function's CIS * since SDIO_CCCR_CIS and SDIO_FBR_CIS
+        * have the same offset.
+        */
        for (i = 0; i < 3; i++) {
-               unsigned char x;
-               ret = mmc_io_rw_direct(func->card, 0, 0,
-                               func->num * 0x100 + SDIO_FBR_CIS + i, 0, &x);
+               unsigned char x, fn;
+
+               if (func)
+                       fn = func->num;
+               else
+                       fn = 0;
+
+               ret = mmc_io_rw_direct(card, 0, 0,
+                                      fn * 0x100 + SDIO_FBR_CIS + i, 0, &x);
                if (ret)
                        return ret;
                ptr |= x << (i * 8);
        }
 
-       /* find the list tail */
-       for (prev = &func->tuples; *prev; prev = &(*prev)->next);
+       if (func)
+               prev = &func->tuples;
+       else
+               prev = &card->tuples;
+
+       BUG_ON(*prev);
 
        do {
                unsigned char tpl_code, tpl_link;
 
-               ret = mmc_io_rw_direct(func->card, 0, 0, ptr++, 0, &tpl_code);
+               ret = mmc_io_rw_direct(card, 0, 0, ptr++, 0, &tpl_code);
                if (ret)
                        break;
 
@@ -77,7 +169,7 @@ int sdio_read_cis(struct sdio_func *func)
                if (tpl_code == 0xff)
                        break;
 
-               ret = mmc_io_rw_direct(func->card, 0, 0, ptr++, 0, &tpl_link);
+               ret = mmc_io_rw_direct(card, 0, 0, ptr++, 0, &tpl_link);
                if (ret)
                        break;
 
@@ -86,7 +178,7 @@ int sdio_read_cis(struct sdio_func *func)
                        return -ENOMEM;
 
                for (i = 0; i < tpl_link; i++) {
-                       ret = mmc_io_rw_direct(func->card, 0, 0,
+                       ret = mmc_io_rw_direct(card, 0, 0,
                                               ptr + i, 0, &this->data[i]);
                        if (ret)
                                break;
@@ -108,30 +200,45 @@ int sdio_read_cis(struct sdio_func *func)
                        prev = &this->next;
                        printk(KERN_DEBUG
                               "%s: queuing CIS tuple 0x%02x length %u\n",
-                              sdio_func_id(func), tpl_code, tpl_link);
+                              mmc_hostname(card->host), tpl_code, tpl_link);
                } else {
                        const struct cis_tpl *tpl = cis_tpl_list + i;
                        if (tpl_link < tpl->min_size) {
                                printk(KERN_ERR
                                       "%s: bad CIS tuple 0x%02x (length = %u, expected >= %u)\n",
-                                      sdio_func_id(func), tpl_code, tpl_link, tpl->min_size);
+                                      mmc_hostname(card->host),
+                                      tpl_code, tpl_link, tpl->min_size);
                                ret = -EINVAL;
-                       } else if (tpl->parse)
-                               ret = tpl->parse(func, this->data, tpl_link);
+                       } else if (tpl->parse) {
+                               ret = tpl->parse(card, func,
+                                                this->data, tpl_link);
+                       }
                        kfree(this);
                }
 
                ptr += tpl_link;
        } while (!ret);
 
+       /*
+        * Link in all unknown tuples found in the common CIS so that
+        * drivers don't have to go digging in two places.
+        */
+       if (func)
+               *prev = card->tuples;
+
        return ret;
 }
 
-void sdio_free_cis(struct sdio_func *func)
+int sdio_read_common_cis(struct mmc_card *card)
+{
+       return sdio_read_cis(card, NULL);
+}
+
+void sdio_free_common_cis(struct mmc_card *card)
 {
        struct sdio_func_tuple *tuple, *victim;
 
-       tuple = func->tuples;
+       tuple = card->tuples;
 
        while (tuple) {
                victim = tuple;
@@ -139,6 +246,53 @@ void sdio_free_cis(struct sdio_func *func)
                kfree(victim);
        }
 
+       card->tuples = NULL;
+}
+
+int sdio_read_func_cis(struct sdio_func *func)
+{
+       int ret;
+
+       ret = sdio_read_cis(func->card, func);
+       if (ret)
+               return ret;
+
+       /*
+        * Since we've linked to tuples in the card structure,
+        * we must make sure we have a reference to it.
+        */
+       get_device(&func->card->dev);
+
+       /*
+        * Vendor/device id is optional for function CIS, so
+        * copy it from the card structure as needed.
+        */
+       if (func->vendor == 0) {
+               func->vendor = func->card->cis.vendor;
+               func->device = func->card->cis.device;
+       }
+
+       return 0;
+}
+
+void sdio_free_func_cis(struct sdio_func *func)
+{
+       struct sdio_func_tuple *tuple, *victim;
+
+       tuple = func->tuples;
+
+       while (tuple && tuple != func->card->tuples) {
+               victim = tuple;
+               tuple = tuple->next;
+               kfree(victim);
+       }
+
        func->tuples = NULL;
+
+       /*
+        * We have now removed the link to the tuples in the
+        * card structure, so remove the reference.
+        */
+       put_device(&func->card->dev);
 }
 
index 863d3d5..4d903c2 100644 (file)
 #ifndef _MMC_SDIO_CIS_H
 #define _MMC_SDIO_CIS_H
 
-int sdio_read_cis(struct sdio_func *func);
-void sdio_free_cis(struct sdio_func *func);
+int sdio_read_common_cis(struct mmc_card *card);
+void sdio_free_common_cis(struct mmc_card *card);
+
+int sdio_read_func_cis(struct sdio_func *func);
+void sdio_free_func_cis(struct sdio_func *func);
 
 #endif
index 520d9d2..a444431 100644 (file)
@@ -65,8 +65,16 @@ struct sdio_cccr {
                                high_speed:1;
 };
 
+struct sdio_cis {
+       unsigned short          vendor;
+       unsigned short          device;
+       unsigned short          blksize;
+       unsigned int            max_dtr;
+};
+
 struct mmc_host;
 struct sdio_func;
+struct sdio_func_tuple;
 
 #define SDIO_MAX_FUNCS         7
 
@@ -98,7 +106,9 @@ struct mmc_card {
 
        unsigned int            sdio_funcs;     /* number of SDIO functions */
        struct sdio_cccr        cccr;           /* common card info */
+       struct sdio_cis         cis;            /* common tuple info */
        struct sdio_func        *sdio_func[SDIO_MAX_FUNCS]; /* SDIO functions (devices) */
+       struct sdio_func_tuple  *tuples;        /* unknown common tuples */
 };
 
 #define mmc_card_mmc(c)                ((c)->type == MMC_TYPE_MMC)
index 2690676..2f2b3c8 100644 (file)
@@ -36,6 +36,8 @@ struct sdio_func {
        unsigned short          vendor;         /* vendor id */
        unsigned short          device;         /* device id */
 
+       unsigned short          blksize;        /* maximum block size */
+
        unsigned int            state;          /* function state */
 #define SDIO_STATE_PRESENT     (1<<0)          /* present in sysfs */