text: /*
   * Copyright (C) 2012 CERN (www.cern.ch)
   * Author: Alessandro Rubini <rubini@gnudd.com>
   *
   * Released according to the GNU GPL, version 2 or any later version.
   *
   * This work is part of the White Rabbit project, a research effort led
   * by CERN, the European Institute for Nuclear Research.
   */
  #include <linux/kernel.h>
  #include <linux/module.h>
  #include <linux/slab.h>
  #include <linux/init.h>
  #include <linux/device.h>
  #include <linux/fmc.h>
  
  static int fmc_check_version(unsigned long version, const char *name)
  {
  	if (__FMC_MAJOR(version) != FMC_MAJOR) {
  		pr_err("%s: \"%s\" has wrong major (has %li, expected %i)\n",
  		       __func__, name, __FMC_MAJOR(version), FMC_MAJOR);
  		return -EINVAL;
  	}
  
  	if (__FMC_MINOR(version) != FMC_MINOR)
  		pr_info("%s: \"%s\" has wrong minor (has %li, expected %i)\n",
  		       __func__, name, __FMC_MINOR(version), FMC_MINOR);
  	return 0;
  }
  
  static int fmc_uevent(struct device *dev, struct kobj_uevent_env *env)
  {
  	/* struct fmc_device *fdev = to_fmc_device(dev); */
  
  	/* FIXME: The MODALIAS */
  	add_uevent_var(env, "MODALIAS=%s", "fmc");
  	return 0;
  }
  
  static int fmc_probe(struct device *dev)
  {
  	struct fmc_driver *fdrv = to_fmc_driver(dev->driver);
  	struct fmc_device *fdev = to_fmc_device(dev);
  
  	return fdrv->probe(fdev);
  }
  
  static int fmc_remove(struct device *dev)
  {
  	struct fmc_driver *fdrv = to_fmc_driver(dev->driver);
  	struct fmc_device *fdev = to_fmc_device(dev);
  
  	return fdrv->remove(fdev);
  }
  
  static void fmc_shutdown(struct device *dev)
  {
  	/* not implemented but mandatory */
  }
  
  static struct bus_type fmc_bus_type = {
  	.name = "fmc",
  	.match = fmc_match,
  	.uevent = fmc_uevent,
  	.probe = fmc_probe,
  	.remove = fmc_remove,
  	.shutdown = fmc_shutdown,
  };
  
  static void fmc_release(struct device *dev)
  {
  	struct fmc_device *fmc = container_of(dev, struct fmc_device, dev);
  
  	kfree(fmc);
  }
  
  /*
   * The eeprom is exported in sysfs, through a binary attribute
   */
  
  static ssize_t fmc_read_eeprom(struct file *file, struct kobject *kobj,
  			   struct bin_attribute *bin_attr,
  			   char *buf, loff_t off, size_t count)
  {
  	struct device *dev;
  	struct fmc_device *fmc;
  	int eelen;
  
  	dev = container_of(kobj, struct device, kobj);
  	fmc = container_of(dev, struct fmc_device, dev);
  	eelen = fmc->eeprom_len;
  	if (off > eelen)
  		return -ESPIPE;
  	if (off == eelen)
  		return 0; /* EOF */
  	if (off + count > eelen)
  		count = eelen - off;
  	memcpy(buf, fmc->eeprom + off, count);
  	return count;
  }
  
  static ssize_t fmc_write_eeprom(struct file *file, struct kobject *kobj,
  				struct bin_attribute *bin_attr,
  				char *buf, loff_t off, size_t count)
  {
  	struct device *dev;
  	struct fmc_device *fmc;
  
  	dev = container_of(kobj, struct device, kobj);
  	fmc = container_of(dev, struct fmc_device, dev);
  	return fmc->op->write_ee(fmc, off, buf, count);
  }
  
  static struct bin_attribute fmc_eeprom_attr = {
  	.attr = { .name = "eeprom", .mode = S_IRUGO | S_IWUSR, },
  	.size = 8192, /* more or less standard */
  	.read = fmc_read_eeprom,
  	.write = fmc_write_eeprom,
  };
  
  /*
   * Functions for client modules follow
   */
  
  int fmc_driver_register(struct fmc_driver *drv)
  {
  	if (fmc_check_version(drv->version, drv->driver.name))
  		return -EINVAL;
  	drv->driver.bus = &fmc_bus_type;
  	return driver_register(&drv->driver);
  }
  EXPORT_SYMBOL(fmc_driver_register);
  
  void fmc_driver_unregister(struct fmc_driver *drv)
  {
  	driver_unregister(&drv->driver);
  }
  EXPORT_SYMBOL(fmc_driver_unregister);
  
  /*
   * When a device set is registered, all eeproms must be read
   * and all FRUs must be parsed
   */
  int fmc_device_register_n(struct fmc_device **devs, int n)
  {
  	struct fmc_device *fmc, **devarray;
  	uint32_t device_id;
  	int i, ret = 0;
  
  	if (n < 1)
  		return 0;
  
  	/* Check the version of the first data structure (function prints) */
  	if (fmc_check_version(devs[0]->version, devs[0]->carrier_name))
  		return -EINVAL;
  
  	devarray = kmemdup(devs, n * sizeof(*devs), GFP_KERNEL);
  	if (!devarray)
  		return -ENOMEM;
  
  	/* Make all other checks before continuing, for all devices */
  	for (i = 0; i < n; i++) {
  		fmc = devarray[i];
  		if (!fmc->hwdev) {
  			pr_err("%s: device nr. %i has no hwdev pointer\n",
  			       __func__, i);
  			ret = -EINVAL;
  			break;
  		}
  		if (fmc->flags & FMC_DEVICE_NO_MEZZANINE) {
  			dev_info(fmc->hwdev, "absent mezzanine in slot %d\n",
  				 fmc->slot_id);
  			continue;
  		}
  		if (!fmc->eeprom) {
  			dev_err(fmc->hwdev, "no eeprom provided for slot %i\n",
  				fmc->slot_id);
  			ret = -EINVAL;
  		}
  		if (!fmc->eeprom_addr) {
  			dev_err(fmc->hwdev, "no eeprom_addr for slot %i\n",
  				fmc->slot_id);
  			ret = -EINVAL;
  		}
  		if (!fmc->carrier_name || !fmc->carrier_data ||
  		    !fmc->device_id) {
  			dev_err(fmc->hwdev,
  				"deivce nr %i: carrier name, "
  				"data or dev_id not set\n", i);
  			ret = -EINVAL;
  		}
  		if (ret)
  			break;
  
  	}
  	if (ret) {
  		kfree(devarray);
  		return ret;
  	}
  
  	/* Validation is ok. Now init and register the devices */
  	for (i = 0; i < n; i++) {
  		fmc = devarray[i];
  
  		fmc->nr_slots = n; /* each slot must know how many are there */
  		fmc->devarray = devarray;
  
  		device_initialize(&fmc->dev);
  		fmc->dev.release = fmc_release;
  		fmc->dev.parent = fmc->hwdev;
  
  		/* Fill the identification stuff (may fail) */
  		fmc_fill_id_info(fmc);
  
  		fmc->dev.bus = &fmc_bus_type;
  
  		/* Name from mezzanine info or carrier info. Or 0,1,2.. */
  		device_id = fmc->device_id;
  		if (!fmc->mezzanine_name)
  			dev_set_name(&fmc->dev, "fmc-%04x", device_id);
  		else
  			dev_set_name(&fmc->dev, "%s-%04x", fmc->mezzanine_name,
  				     device_id);
  		ret = device_add(&fmc->dev);
  		if (ret < 0) {
  			dev_err(fmc->hwdev, "Slot %i: Failed in registering "
  				"\"%s\"\n", fmc->slot_id, fmc->dev.kobj.name);
  			goto out;
  		}
  		ret = sysfs_create_bin_file(&fmc->dev.kobj, &fmc_eeprom_attr);
  		if (ret < 0) {
  			dev_err(&fmc->dev, "Failed in registering eeprom\n");
  			goto out1;
  		}
  		/* This device went well, give information to the user */
  		fmc_dump_eeprom(fmc);
  		fmc_dump_sdb(fmc);
  	}
  	return 0;
  
  out1:
  	device_del(&fmc->dev);
  out:
  	fmc_free_id_info(fmc);
  	put_device(&fmc->dev);
  
  	kfree(devarray);
  	for (i--; i >= 0; i--) {
  		sysfs_remove_bin_file(&devs[i]->dev.kobj, &fmc_eeprom_attr);
  		device_del(&devs[i]->dev);
  		fmc_free_id_info(devs[i]);
  		put_device(&devs[i]->dev);
  	}
  	return ret;
  
  }
  EXPORT_SYMBOL(fmc_device_register_n);
  
  int fmc_device_register(struct fmc_device *fmc)
  {
  	return fmc_device_register_n(&fmc, 1);
  }
  EXPORT_SYMBOL(fmc_device_register);
  
  void fmc_device_unregister_n(struct fmc_device **devs, int n)
  {
  	int i;
  
  	if (n < 1)
  		return;
  
  	/* Free devarray first, not used by the later loop */
  	kfree(devs[0]->devarray);
  
  	for (i = 0; i < n; i++) {
  		sysfs_remove_bin_file(&devs[i]->dev.kobj, &fmc_eeprom_attr);
  		device_del(&devs[i]->dev);
  		fmc_free_id_info(devs[i]);
  		put_device(&devs[i]->dev);
  	}
  }
  EXPORT_SYMBOL(fmc_device_unregister_n);
  
  void fmc_device_unregister(struct fmc_device *fmc)
  {
  	fmc_device_unregister_n(&fmc, 1);
  }
  EXPORT_SYMBOL(fmc_device_unregister);
  
  /* Init and exit are trivial */
  static int fmc_init(void)
  {
  	return bus_register(&fmc_bus_type);
  }
  
  static void fmc_exit(void)
  {
  	bus_unregister(&fmc_bus_type);
  }
  
  module_init(fmc_init);
  module_exit(fmc_exit);
  
  MODULE_LICENSE("GPL");
  