linux/drivers/misc/mic/bus/scif_bus.c
<<
>>
Prefs
   1/*
   2 * Intel MIC Platform Software Stack (MPSS)
   3 *
   4 * Copyright(c) 2014 Intel Corporation.
   5 *
   6 * This program is free software; you can redistribute it and/or modify
   7 * it under the terms of the GNU General Public License, version 2, as
   8 * published by the Free Software Foundation.
   9 *
  10 * This program is distributed in the hope that it will be useful, but
  11 * WITHOUT ANY WARRANTY; without even the implied warranty of
  12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  13 * General Public License for more details.
  14 *
  15 * Intel Symmetric Communications Interface Bus driver.
  16 */
  17#include <linux/slab.h>
  18#include <linux/module.h>
  19#include <linux/idr.h>
  20#include <linux/dma-mapping.h>
  21
  22#include "scif_bus.h"
  23
  24static ssize_t device_show(struct device *d,
  25                           struct device_attribute *attr, char *buf)
  26{
  27        struct scif_hw_dev *dev = dev_to_scif(d);
  28
  29        return sprintf(buf, "0x%04x\n", dev->id.device);
  30}
  31static DEVICE_ATTR_RO(device);
  32
  33static ssize_t vendor_show(struct device *d,
  34                           struct device_attribute *attr, char *buf)
  35{
  36        struct scif_hw_dev *dev = dev_to_scif(d);
  37
  38        return sprintf(buf, "0x%04x\n", dev->id.vendor);
  39}
  40static DEVICE_ATTR_RO(vendor);
  41
  42static ssize_t modalias_show(struct device *d,
  43                             struct device_attribute *attr, char *buf)
  44{
  45        struct scif_hw_dev *dev = dev_to_scif(d);
  46
  47        return sprintf(buf, "scif:d%08Xv%08X\n",
  48                       dev->id.device, dev->id.vendor);
  49}
  50static DEVICE_ATTR_RO(modalias);
  51
  52static struct attribute *scif_dev_attrs[] = {
  53        &dev_attr_device.attr,
  54        &dev_attr_vendor.attr,
  55        &dev_attr_modalias.attr,
  56        NULL,
  57};
  58ATTRIBUTE_GROUPS(scif_dev);
  59
  60static inline int scif_id_match(const struct scif_hw_dev *dev,
  61                                const struct scif_hw_dev_id *id)
  62{
  63        if (id->device != dev->id.device && id->device != SCIF_DEV_ANY_ID)
  64                return 0;
  65
  66        return id->vendor == SCIF_DEV_ANY_ID || id->vendor == dev->id.vendor;
  67}
  68
  69/*
  70 * This looks through all the IDs a driver claims to support.  If any of them
  71 * match, we return 1 and the kernel will call scif_dev_probe().
  72 */
  73static int scif_dev_match(struct device *dv, struct device_driver *dr)
  74{
  75        unsigned int i;
  76        struct scif_hw_dev *dev = dev_to_scif(dv);
  77        const struct scif_hw_dev_id *ids;
  78
  79        ids = drv_to_scif(dr)->id_table;
  80        for (i = 0; ids[i].device; i++)
  81                if (scif_id_match(dev, &ids[i]))
  82                        return 1;
  83        return 0;
  84}
  85
  86static int scif_uevent(struct device *dv, struct kobj_uevent_env *env)
  87{
  88        struct scif_hw_dev *dev = dev_to_scif(dv);
  89
  90        return add_uevent_var(env, "MODALIAS=scif:d%08Xv%08X",
  91                              dev->id.device, dev->id.vendor);
  92}
  93
  94static int scif_dev_probe(struct device *d)
  95{
  96        struct scif_hw_dev *dev = dev_to_scif(d);
  97        struct scif_driver *drv = drv_to_scif(dev->dev.driver);
  98
  99        return drv->probe(dev);
 100}
 101
 102static int scif_dev_remove(struct device *d)
 103{
 104        struct scif_hw_dev *dev = dev_to_scif(d);
 105        struct scif_driver *drv = drv_to_scif(dev->dev.driver);
 106
 107        drv->remove(dev);
 108        return 0;
 109}
 110
 111static struct bus_type scif_bus = {
 112        .name  = "scif_bus",
 113        .match = scif_dev_match,
 114        .dev_groups = scif_dev_groups,
 115        .uevent = scif_uevent,
 116        .probe = scif_dev_probe,
 117        .remove = scif_dev_remove,
 118};
 119
 120int scif_register_driver(struct scif_driver *driver)
 121{
 122        driver->driver.bus = &scif_bus;
 123        return driver_register(&driver->driver);
 124}
 125EXPORT_SYMBOL_GPL(scif_register_driver);
 126
 127void scif_unregister_driver(struct scif_driver *driver)
 128{
 129        driver_unregister(&driver->driver);
 130}
 131EXPORT_SYMBOL_GPL(scif_unregister_driver);
 132
 133static void scif_release_dev(struct device *d)
 134{
 135        struct scif_hw_dev *sdev = dev_to_scif(d);
 136
 137        kfree(sdev);
 138}
 139
 140struct scif_hw_dev *
 141scif_register_device(struct device *pdev, int id, struct dma_map_ops *dma_ops,
 142                     struct scif_hw_ops *hw_ops, u8 dnode, u8 snode,
 143                     struct mic_mw *mmio, struct mic_mw *aper, void *dp,
 144                     void __iomem *rdp, struct dma_chan **chan, int num_chan,
 145                     bool card_rel_da)
 146{
 147        int ret;
 148        struct scif_hw_dev *sdev;
 149
 150        sdev = kzalloc(sizeof(*sdev), GFP_KERNEL);
 151        if (!sdev)
 152                return ERR_PTR(-ENOMEM);
 153
 154        sdev->dev.parent = pdev;
 155        sdev->id.device = id;
 156        sdev->id.vendor = SCIF_DEV_ANY_ID;
 157        sdev->dev.archdata.dma_ops = dma_ops;
 158        sdev->dev.release = scif_release_dev;
 159        sdev->hw_ops = hw_ops;
 160        sdev->dnode = dnode;
 161        sdev->snode = snode;
 162        dev_set_drvdata(&sdev->dev, sdev);
 163        sdev->dev.bus = &scif_bus;
 164        sdev->mmio = mmio;
 165        sdev->aper = aper;
 166        sdev->dp = dp;
 167        sdev->rdp = rdp;
 168        sdev->dev.dma_mask = &sdev->dev.coherent_dma_mask;
 169        dma_set_mask(&sdev->dev, DMA_BIT_MASK(64));
 170        sdev->dma_ch = chan;
 171        sdev->num_dma_ch = num_chan;
 172        sdev->card_rel_da = card_rel_da;
 173        dev_set_name(&sdev->dev, "scif-dev%u", sdev->dnode);
 174        /*
 175         * device_register() causes the bus infrastructure to look for a
 176         * matching driver.
 177         */
 178        ret = device_register(&sdev->dev);
 179        if (ret)
 180                goto free_sdev;
 181        return sdev;
 182free_sdev:
 183        put_device(&sdev->dev);
 184        return ERR_PTR(ret);
 185}
 186EXPORT_SYMBOL_GPL(scif_register_device);
 187
 188void scif_unregister_device(struct scif_hw_dev *sdev)
 189{
 190        device_unregister(&sdev->dev);
 191}
 192EXPORT_SYMBOL_GPL(scif_unregister_device);
 193
 194static int __init scif_init(void)
 195{
 196        return bus_register(&scif_bus);
 197}
 198
 199static void __exit scif_exit(void)
 200{
 201        bus_unregister(&scif_bus);
 202}
 203
 204core_initcall(scif_init);
 205module_exit(scif_exit);
 206
 207MODULE_AUTHOR("Intel Corporation");
 208MODULE_DESCRIPTION("Intel(R) SCIF Bus driver");
 209MODULE_LICENSE("GPL v2");
 210