linux/drivers/fmc/fmc-core.c
<<
>>
Prefs
   1/*
   2 * Copyright (C) 2012 CERN (www.cern.ch)
   3 * Author: Alessandro Rubini <rubini@gnudd.com>
   4 *
   5 * Released according to the GNU GPL, version 2 or any later version.
   6 *
   7 * This work is part of the White Rabbit project, a research effort led
   8 * by CERN, the European Institute for Nuclear Research.
   9 */
  10#include <linux/kernel.h>
  11#include <linux/module.h>
  12#include <linux/slab.h>
  13#include <linux/init.h>
  14#include <linux/device.h>
  15#include <linux/fmc.h>
  16
  17static int fmc_check_version(unsigned long version, const char *name)
  18{
  19        if (__FMC_MAJOR(version) != FMC_MAJOR) {
  20                pr_err("%s: \"%s\" has wrong major (has %li, expected %i)\n",
  21                       __func__, name, __FMC_MAJOR(version), FMC_MAJOR);
  22                return -EINVAL;
  23        }
  24
  25        if (__FMC_MINOR(version) != FMC_MINOR)
  26                pr_info("%s: \"%s\" has wrong minor (has %li, expected %i)\n",
  27                       __func__, name, __FMC_MINOR(version), FMC_MINOR);
  28        return 0;
  29}
  30
  31static int fmc_uevent(struct device *dev, struct kobj_uevent_env *env)
  32{
  33        /* struct fmc_device *fdev = to_fmc_device(dev); */
  34
  35        /* FIXME: The MODALIAS */
  36        add_uevent_var(env, "MODALIAS=%s", "fmc");
  37        return 0;
  38}
  39
  40static int fmc_probe(struct device *dev)
  41{
  42        struct fmc_driver *fdrv = to_fmc_driver(dev->driver);
  43        struct fmc_device *fdev = to_fmc_device(dev);
  44
  45        return fdrv->probe(fdev);
  46}
  47
  48static int fmc_remove(struct device *dev)
  49{
  50        struct fmc_driver *fdrv = to_fmc_driver(dev->driver);
  51        struct fmc_device *fdev = to_fmc_device(dev);
  52
  53        return fdrv->remove(fdev);
  54}
  55
  56static void fmc_shutdown(struct device *dev)
  57{
  58        /* not implemented but mandatory */
  59}
  60
  61static struct bus_type fmc_bus_type = {
  62        .name = "fmc",
  63        .match = fmc_match,
  64        .uevent = fmc_uevent,
  65        .probe = fmc_probe,
  66        .remove = fmc_remove,
  67        .shutdown = fmc_shutdown,
  68};
  69
  70static void fmc_release(struct device *dev)
  71{
  72        struct fmc_device *fmc = container_of(dev, struct fmc_device, dev);
  73
  74        kfree(fmc);
  75}
  76
  77/*
  78 * The eeprom is exported in sysfs, through a binary attribute
  79 */
  80
  81static ssize_t fmc_read_eeprom(struct file *file, struct kobject *kobj,
  82                           struct bin_attribute *bin_attr,
  83                           char *buf, loff_t off, size_t count)
  84{
  85        struct device *dev;
  86        struct fmc_device *fmc;
  87        int eelen;
  88
  89        dev = container_of(kobj, struct device, kobj);
  90        fmc = container_of(dev, struct fmc_device, dev);
  91        eelen = fmc->eeprom_len;
  92        if (off > eelen)
  93                return -ESPIPE;
  94        if (off == eelen)
  95                return 0; /* EOF */
  96        if (off + count > eelen)
  97                count = eelen - off;
  98        memcpy(buf, fmc->eeprom + off, count);
  99        return count;
 100}
 101
 102static struct bin_attribute fmc_eeprom_attr = {
 103        .attr = { .name = "eeprom", .mode = S_IRUGO, },
 104        .size = 8192, /* more or less standard */
 105        .read = fmc_read_eeprom,
 106};
 107
 108/*
 109 * Functions for client modules follow
 110 */
 111
 112int fmc_driver_register(struct fmc_driver *drv)
 113{
 114        if (fmc_check_version(drv->version, drv->driver.name))
 115                return -EINVAL;
 116        drv->driver.bus = &fmc_bus_type;
 117        return driver_register(&drv->driver);
 118}
 119EXPORT_SYMBOL(fmc_driver_register);
 120
 121void fmc_driver_unregister(struct fmc_driver *drv)
 122{
 123        driver_unregister(&drv->driver);
 124}
 125EXPORT_SYMBOL(fmc_driver_unregister);
 126
 127/*
 128 * When a device set is registered, all eeproms must be read
 129 * and all FRUs must be parsed
 130 */
 131int fmc_device_register_n(struct fmc_device **devs, int n)
 132{
 133        struct fmc_device *fmc, **devarray;
 134        uint32_t device_id;
 135        int i, ret = 0;
 136
 137        if (n < 1)
 138                return 0;
 139
 140        /* Check the version of the first data structure (function prints) */
 141        if (fmc_check_version(devs[0]->version, devs[0]->carrier_name))
 142                return -EINVAL;
 143
 144        devarray = kmemdup(devs, n * sizeof(*devs), GFP_KERNEL);
 145        if (!devarray)
 146                return -ENOMEM;
 147
 148        /* Make all other checks before continuing, for all devices */
 149        for (i = 0; i < n; i++) {
 150                fmc = devarray[i];
 151                if (!fmc->hwdev) {
 152                        pr_err("%s: device nr. %i has no hwdev pointer\n",
 153                               __func__, i);
 154                        ret = -EINVAL;
 155                        break;
 156                }
 157                if (fmc->flags == FMC_DEVICE_NO_MEZZANINE) {
 158                        dev_info(fmc->hwdev, "absent mezzanine in slot %d\n",
 159                                 fmc->slot_id);
 160                        continue;
 161                }
 162                if (!fmc->eeprom) {
 163                        dev_err(fmc->hwdev, "no eeprom provided for slot %i\n",
 164                                fmc->slot_id);
 165                        ret = -EINVAL;
 166                }
 167                if (!fmc->eeprom_addr) {
 168                        dev_err(fmc->hwdev, "no eeprom_addr for slot %i\n",
 169                                fmc->slot_id);
 170                        ret = -EINVAL;
 171                }
 172                if (!fmc->carrier_name || !fmc->carrier_data ||
 173                    !fmc->device_id) {
 174                        dev_err(fmc->hwdev,
 175                                "deivce nr %i: carrier name, "
 176                                "data or dev_id not set\n", i);
 177                        ret = -EINVAL;
 178                }
 179                if (ret)
 180                        break;
 181
 182        }
 183        if (ret) {
 184                kfree(devarray);
 185                return ret;
 186        }
 187
 188        /* Validation is ok. Now init and register the devices */
 189        for (i = 0; i < n; i++) {
 190                fmc = devarray[i];
 191
 192                if (fmc->flags == FMC_DEVICE_NO_MEZZANINE)
 193                        continue; /* dev_info already done above */
 194
 195                fmc->nr_slots = n; /* each slot must know how many are there */
 196                fmc->devarray = devarray;
 197
 198                device_initialize(&fmc->dev);
 199                fmc->dev.release = fmc_release;
 200                fmc->dev.parent = fmc->hwdev;
 201
 202                /* Fill the identification stuff (may fail) */
 203                fmc_fill_id_info(fmc);
 204
 205                fmc->dev.bus = &fmc_bus_type;
 206
 207                /* Name from mezzanine info or carrier info. Or 0,1,2.. */
 208                device_id = fmc->device_id;
 209                if (!fmc->mezzanine_name)
 210                        dev_set_name(&fmc->dev, "fmc-%04x", device_id);
 211                else
 212                        dev_set_name(&fmc->dev, "%s-%04x", fmc->mezzanine_name,
 213                                     device_id);
 214                ret = device_add(&fmc->dev);
 215                if (ret < 0) {
 216                        dev_err(fmc->hwdev, "Slot %i: Failed in registering "
 217                                "\"%s\"\n", fmc->slot_id, fmc->dev.kobj.name);
 218                        goto out;
 219                }
 220                ret = sysfs_create_bin_file(&fmc->dev.kobj, &fmc_eeprom_attr);
 221                if (ret < 0) {
 222                        dev_err(&fmc->dev, "Failed in registering eeprom\n");
 223                        goto out1;
 224                }
 225                /* This device went well, give information to the user */
 226                fmc_dump_eeprom(fmc);
 227                fmc_dump_sdb(fmc);
 228        }
 229        return 0;
 230
 231out1:
 232        device_del(&fmc->dev);
 233out:
 234        fmc_free_id_info(fmc);
 235        put_device(&fmc->dev);
 236
 237        kfree(devarray);
 238        for (i--; i >= 0; i--) {
 239                sysfs_remove_bin_file(&devs[i]->dev.kobj, &fmc_eeprom_attr);
 240                device_del(&devs[i]->dev);
 241                fmc_free_id_info(devs[i]);
 242                put_device(&devs[i]->dev);
 243        }
 244        return ret;
 245
 246}
 247EXPORT_SYMBOL(fmc_device_register_n);
 248
 249int fmc_device_register(struct fmc_device *fmc)
 250{
 251        return fmc_device_register_n(&fmc, 1);
 252}
 253EXPORT_SYMBOL(fmc_device_register);
 254
 255void fmc_device_unregister_n(struct fmc_device **devs, int n)
 256{
 257        int i;
 258
 259        if (n < 1)
 260                return;
 261
 262        /* Free devarray first, not used by the later loop */
 263        kfree(devs[0]->devarray);
 264
 265        for (i = 0; i < n; i++) {
 266                if (devs[i]->flags == FMC_DEVICE_NO_MEZZANINE)
 267                        continue;
 268                sysfs_remove_bin_file(&devs[i]->dev.kobj, &fmc_eeprom_attr);
 269                device_del(&devs[i]->dev);
 270                fmc_free_id_info(devs[i]);
 271                put_device(&devs[i]->dev);
 272        }
 273}
 274EXPORT_SYMBOL(fmc_device_unregister_n);
 275
 276void fmc_device_unregister(struct fmc_device *fmc)
 277{
 278        fmc_device_unregister_n(&fmc, 1);
 279}
 280EXPORT_SYMBOL(fmc_device_unregister);
 281
 282/* Init and exit are trivial */
 283static int fmc_init(void)
 284{
 285        return bus_register(&fmc_bus_type);
 286}
 287
 288static void fmc_exit(void)
 289{
 290        bus_unregister(&fmc_bus_type);
 291}
 292
 293module_init(fmc_init);
 294module_exit(fmc_exit);
 295
 296MODULE_LICENSE("GPL");
 297
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.