Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Industry-pack bus support functions.
0004  *
0005  * Copyright (C) 2011-2012 CERN (www.cern.ch)
0006  * Author: Samuel Iglesias Gonsalvez <siglesias@igalia.com>
0007  */
0008 
0009 #include <linux/module.h>
0010 #include <linux/slab.h>
0011 #include <linux/idr.h>
0012 #include <linux/io.h>
0013 #include <linux/ipack.h>
0014 
0015 #define to_ipack_dev(device) container_of(device, struct ipack_device, dev)
0016 #define to_ipack_driver(drv) container_of(drv, struct ipack_driver, driver)
0017 
0018 static DEFINE_IDA(ipack_ida);
0019 
0020 static void ipack_device_release(struct device *dev)
0021 {
0022     struct ipack_device *device = to_ipack_dev(dev);
0023     kfree(device->id);
0024     device->release(device);
0025 }
0026 
0027 static inline const struct ipack_device_id *
0028 ipack_match_one_device(const struct ipack_device_id *id,
0029                const struct ipack_device *device)
0030 {
0031     if ((id->format == IPACK_ANY_FORMAT ||
0032                 id->format == device->id_format) &&
0033         (id->vendor == IPACK_ANY_ID || id->vendor == device->id_vendor) &&
0034         (id->device == IPACK_ANY_ID || id->device == device->id_device))
0035         return id;
0036     return NULL;
0037 }
0038 
0039 static const struct ipack_device_id *
0040 ipack_match_id(const struct ipack_device_id *ids, struct ipack_device *idev)
0041 {
0042     if (ids) {
0043         while (ids->vendor || ids->device) {
0044             if (ipack_match_one_device(ids, idev))
0045                 return ids;
0046             ids++;
0047         }
0048     }
0049     return NULL;
0050 }
0051 
0052 static int ipack_bus_match(struct device *dev, struct device_driver *drv)
0053 {
0054     struct ipack_device *idev = to_ipack_dev(dev);
0055     struct ipack_driver *idrv = to_ipack_driver(drv);
0056     const struct ipack_device_id *found_id;
0057 
0058     found_id = ipack_match_id(idrv->id_table, idev);
0059     return found_id ? 1 : 0;
0060 }
0061 
0062 static int ipack_bus_probe(struct device *device)
0063 {
0064     struct ipack_device *dev = to_ipack_dev(device);
0065     struct ipack_driver *drv = to_ipack_driver(device->driver);
0066 
0067     return drv->ops->probe(dev);
0068 }
0069 
0070 static void ipack_bus_remove(struct device *device)
0071 {
0072     struct ipack_device *dev = to_ipack_dev(device);
0073     struct ipack_driver *drv = to_ipack_driver(device->driver);
0074 
0075     if (drv->ops->remove)
0076         drv->ops->remove(dev);
0077 }
0078 
0079 static int ipack_uevent(struct device *dev, struct kobj_uevent_env *env)
0080 {
0081     struct ipack_device *idev;
0082 
0083     if (!dev)
0084         return -ENODEV;
0085 
0086     idev = to_ipack_dev(dev);
0087 
0088     if (add_uevent_var(env,
0089                "MODALIAS=ipack:f%02Xv%08Xd%08X", idev->id_format,
0090                idev->id_vendor, idev->id_device))
0091         return -ENOMEM;
0092 
0093     return 0;
0094 }
0095 
0096 #define ipack_device_attr(field, format_string)             \
0097 static ssize_t                              \
0098 field##_show(struct device *dev, struct device_attribute *attr,     \
0099         char *buf)                      \
0100 {                                   \
0101     struct ipack_device *idev = to_ipack_dev(dev);          \
0102     return sprintf(buf, format_string, idev->field);        \
0103 }
0104 
0105 static ssize_t id_show(struct device *dev,
0106                struct device_attribute *attr, char *buf)
0107 {
0108     unsigned int i, c, l, s;
0109     struct ipack_device *idev = to_ipack_dev(dev);
0110 
0111 
0112     switch (idev->id_format) {
0113     case IPACK_ID_VERSION_1:
0114         l = 0x7; s = 1; break;
0115     case IPACK_ID_VERSION_2:
0116         l = 0xf; s = 2; break;
0117     default:
0118         return -EIO;
0119     }
0120     c = 0;
0121     for (i = 0; i < idev->id_avail; i++) {
0122         if (i > 0) {
0123             if ((i & l) == 0)
0124                 buf[c++] = '\n';
0125             else if ((i & s) == 0)
0126                 buf[c++] = ' ';
0127         }
0128         sprintf(&buf[c], "%02x", idev->id[i]);
0129         c += 2;
0130     }
0131     buf[c++] = '\n';
0132     return c;
0133 }
0134 
0135 static ssize_t
0136 id_vendor_show(struct device *dev, struct device_attribute *attr, char *buf)
0137 {
0138     struct ipack_device *idev = to_ipack_dev(dev);
0139     switch (idev->id_format) {
0140     case IPACK_ID_VERSION_1:
0141         return sprintf(buf, "0x%02x\n", idev->id_vendor);
0142     case IPACK_ID_VERSION_2:
0143         return sprintf(buf, "0x%06x\n", idev->id_vendor);
0144     default:
0145         return -EIO;
0146     }
0147 }
0148 
0149 static ssize_t
0150 id_device_show(struct device *dev, struct device_attribute *attr, char *buf)
0151 {
0152     struct ipack_device *idev = to_ipack_dev(dev);
0153     switch (idev->id_format) {
0154     case IPACK_ID_VERSION_1:
0155         return sprintf(buf, "0x%02x\n", idev->id_device);
0156     case IPACK_ID_VERSION_2:
0157         return sprintf(buf, "0x%04x\n", idev->id_device);
0158     default:
0159         return -EIO;
0160     }
0161 }
0162 
0163 static ssize_t modalias_show(struct device *dev, struct device_attribute *attr,
0164                  char *buf)
0165 {
0166     struct ipack_device *idev = to_ipack_dev(dev);
0167 
0168     return sprintf(buf, "ipac:f%02Xv%08Xd%08X", idev->id_format,
0169                idev->id_vendor, idev->id_device);
0170 }
0171 
0172 ipack_device_attr(id_format, "0x%hhx\n");
0173 
0174 static DEVICE_ATTR_RO(id);
0175 static DEVICE_ATTR_RO(id_device);
0176 static DEVICE_ATTR_RO(id_format);
0177 static DEVICE_ATTR_RO(id_vendor);
0178 static DEVICE_ATTR_RO(modalias);
0179 
0180 static struct attribute *ipack_attrs[] = {
0181     &dev_attr_id.attr,
0182     &dev_attr_id_device.attr,
0183     &dev_attr_id_format.attr,
0184     &dev_attr_id_vendor.attr,
0185     &dev_attr_modalias.attr,
0186     NULL,
0187 };
0188 ATTRIBUTE_GROUPS(ipack);
0189 
0190 static struct bus_type ipack_bus_type = {
0191     .name      = "ipack",
0192     .probe     = ipack_bus_probe,
0193     .match     = ipack_bus_match,
0194     .remove    = ipack_bus_remove,
0195     .dev_groups = ipack_groups,
0196     .uevent    = ipack_uevent,
0197 };
0198 
0199 struct ipack_bus_device *ipack_bus_register(struct device *parent, int slots,
0200                         const struct ipack_bus_ops *ops,
0201                         struct module *owner)
0202 {
0203     int bus_nr;
0204     struct ipack_bus_device *bus;
0205 
0206     bus = kzalloc(sizeof(*bus), GFP_KERNEL);
0207     if (!bus)
0208         return NULL;
0209 
0210     bus_nr = ida_simple_get(&ipack_ida, 0, 0, GFP_KERNEL);
0211     if (bus_nr < 0) {
0212         kfree(bus);
0213         return NULL;
0214     }
0215 
0216     bus->bus_nr = bus_nr;
0217     bus->parent = parent;
0218     bus->slots = slots;
0219     bus->ops = ops;
0220     bus->owner = owner;
0221     return bus;
0222 }
0223 EXPORT_SYMBOL_GPL(ipack_bus_register);
0224 
0225 static int ipack_unregister_bus_member(struct device *dev, void *data)
0226 {
0227     struct ipack_device *idev = to_ipack_dev(dev);
0228     struct ipack_bus_device *bus = data;
0229 
0230     if (idev->bus == bus)
0231         ipack_device_del(idev);
0232 
0233     return 1;
0234 }
0235 
0236 int ipack_bus_unregister(struct ipack_bus_device *bus)
0237 {
0238     bus_for_each_dev(&ipack_bus_type, NULL, bus,
0239         ipack_unregister_bus_member);
0240     ida_simple_remove(&ipack_ida, bus->bus_nr);
0241     kfree(bus);
0242     return 0;
0243 }
0244 EXPORT_SYMBOL_GPL(ipack_bus_unregister);
0245 
0246 int ipack_driver_register(struct ipack_driver *edrv, struct module *owner,
0247               const char *name)
0248 {
0249     if (!edrv->ops->probe)
0250         return -EINVAL;
0251 
0252     edrv->driver.owner = owner;
0253     edrv->driver.name = name;
0254     edrv->driver.bus = &ipack_bus_type;
0255     return driver_register(&edrv->driver);
0256 }
0257 EXPORT_SYMBOL_GPL(ipack_driver_register);
0258 
0259 void ipack_driver_unregister(struct ipack_driver *edrv)
0260 {
0261     driver_unregister(&edrv->driver);
0262 }
0263 EXPORT_SYMBOL_GPL(ipack_driver_unregister);
0264 
0265 static u16 ipack_crc_byte(u16 crc, u8 c)
0266 {
0267     int i;
0268 
0269     crc ^= c << 8;
0270     for (i = 0; i < 8; i++)
0271         crc = (crc << 1) ^ ((crc & 0x8000) ? 0x1021 : 0);
0272     return crc;
0273 }
0274 
0275 /*
0276  * The algorithm in lib/crc-ccitt.c does not seem to apply since it uses the
0277  * opposite bit ordering.
0278  */
0279 static u8 ipack_calc_crc1(struct ipack_device *dev)
0280 {
0281     u8 c;
0282     u16 crc;
0283     unsigned int i;
0284 
0285     crc = 0xffff;
0286     for (i = 0; i < dev->id_avail; i++) {
0287         c = (i != 11) ? dev->id[i] : 0;
0288         crc = ipack_crc_byte(crc, c);
0289     }
0290     crc = ~crc;
0291     return crc & 0xff;
0292 }
0293 
0294 static u16 ipack_calc_crc2(struct ipack_device *dev)
0295 {
0296     u8 c;
0297     u16 crc;
0298     unsigned int i;
0299 
0300     crc = 0xffff;
0301     for (i = 0; i < dev->id_avail; i++) {
0302         c = ((i != 0x18) && (i != 0x19)) ? dev->id[i] : 0;
0303         crc = ipack_crc_byte(crc, c);
0304     }
0305     crc = ~crc;
0306     return crc;
0307 }
0308 
0309 static void ipack_parse_id1(struct ipack_device *dev)
0310 {
0311     u8 *id = dev->id;
0312     u8 crc;
0313 
0314     dev->id_vendor = id[4];
0315     dev->id_device = id[5];
0316     dev->speed_8mhz = 1;
0317     dev->speed_32mhz = (id[7] == 'H');
0318     crc = ipack_calc_crc1(dev);
0319     dev->id_crc_correct = (crc == id[11]);
0320     if (!dev->id_crc_correct) {
0321         dev_warn(&dev->dev, "ID CRC invalid found 0x%x, expected 0x%x.\n",
0322                 id[11], crc);
0323     }
0324 }
0325 
0326 static void ipack_parse_id2(struct ipack_device *dev)
0327 {
0328     __be16 *id = (__be16 *) dev->id;
0329     u16 flags, crc;
0330 
0331     dev->id_vendor = ((be16_to_cpu(id[3]) & 0xff) << 16)
0332              + be16_to_cpu(id[4]);
0333     dev->id_device = be16_to_cpu(id[5]);
0334     flags = be16_to_cpu(id[10]);
0335     dev->speed_8mhz = !!(flags & 2);
0336     dev->speed_32mhz = !!(flags & 4);
0337     crc = ipack_calc_crc2(dev);
0338     dev->id_crc_correct = (crc == be16_to_cpu(id[12]));
0339     if (!dev->id_crc_correct) {
0340         dev_warn(&dev->dev, "ID CRC invalid found 0x%x, expected 0x%x.\n",
0341                 id[11], crc);
0342     }
0343 }
0344 
0345 static int ipack_device_read_id(struct ipack_device *dev)
0346 {
0347     u8 __iomem *idmem;
0348     int i;
0349     int ret = 0;
0350 
0351     idmem = ioremap(dev->region[IPACK_ID_SPACE].start,
0352             dev->region[IPACK_ID_SPACE].size);
0353     if (!idmem) {
0354         dev_err(&dev->dev, "error mapping memory\n");
0355         return -ENOMEM;
0356     }
0357 
0358     /* Determine ID PROM Data Format.  If we find the ids "IPAC" or "IPAH"
0359      * we are dealing with a IndustryPack  format 1 device.  If we detect
0360      * "VITA4 " (16 bit big endian formatted) we are dealing with a
0361      * IndustryPack format 2 device */
0362     if ((ioread8(idmem + 1) == 'I') &&
0363             (ioread8(idmem + 3) == 'P') &&
0364             (ioread8(idmem + 5) == 'A') &&
0365             ((ioread8(idmem + 7) == 'C') ||
0366              (ioread8(idmem + 7) == 'H'))) {
0367         dev->id_format = IPACK_ID_VERSION_1;
0368         dev->id_avail = ioread8(idmem + 0x15);
0369         if ((dev->id_avail < 0x0c) || (dev->id_avail > 0x40)) {
0370             dev_warn(&dev->dev, "invalid id size");
0371             dev->id_avail = 0x0c;
0372         }
0373     } else if ((ioread8(idmem + 0) == 'I') &&
0374             (ioread8(idmem + 1) == 'V') &&
0375             (ioread8(idmem + 2) == 'A') &&
0376             (ioread8(idmem + 3) == 'T') &&
0377             (ioread8(idmem + 4) == ' ') &&
0378             (ioread8(idmem + 5) == '4')) {
0379         dev->id_format = IPACK_ID_VERSION_2;
0380         dev->id_avail = ioread16be(idmem + 0x16);
0381         if ((dev->id_avail < 0x1a) || (dev->id_avail > 0x40)) {
0382             dev_warn(&dev->dev, "invalid id size");
0383             dev->id_avail = 0x1a;
0384         }
0385     } else {
0386         dev->id_format = IPACK_ID_VERSION_INVALID;
0387         dev->id_avail = 0;
0388     }
0389 
0390     if (!dev->id_avail) {
0391         ret = -ENODEV;
0392         goto out;
0393     }
0394 
0395     /* Obtain the amount of memory required to store a copy of the complete
0396      * ID ROM contents */
0397     dev->id = kmalloc(dev->id_avail, GFP_KERNEL);
0398     if (!dev->id) {
0399         ret = -ENOMEM;
0400         goto out;
0401     }
0402     for (i = 0; i < dev->id_avail; i++) {
0403         if (dev->id_format == IPACK_ID_VERSION_1)
0404             dev->id[i] = ioread8(idmem + (i << 1) + 1);
0405         else
0406             dev->id[i] = ioread8(idmem + i);
0407     }
0408 
0409     /* now we can finally work with the copy */
0410     switch (dev->id_format) {
0411     case IPACK_ID_VERSION_1:
0412         ipack_parse_id1(dev);
0413         break;
0414     case IPACK_ID_VERSION_2:
0415         ipack_parse_id2(dev);
0416         break;
0417     }
0418 
0419 out:
0420     iounmap(idmem);
0421 
0422     return ret;
0423 }
0424 
0425 int ipack_device_init(struct ipack_device *dev)
0426 {
0427     int ret;
0428 
0429     dev->dev.bus = &ipack_bus_type;
0430     dev->dev.release = ipack_device_release;
0431     dev->dev.parent = dev->bus->parent;
0432     dev_set_name(&dev->dev,
0433              "ipack-dev.%u.%u", dev->bus->bus_nr, dev->slot);
0434     device_initialize(&dev->dev);
0435 
0436     if (dev->bus->ops->set_clockrate(dev, 8))
0437         dev_warn(&dev->dev, "failed to switch to 8 MHz operation for reading of device ID.\n");
0438     if (dev->bus->ops->reset_timeout(dev))
0439         dev_warn(&dev->dev, "failed to reset potential timeout.");
0440 
0441     ret = ipack_device_read_id(dev);
0442     if (ret < 0) {
0443         dev_err(&dev->dev, "error reading device id section.\n");
0444         return ret;
0445     }
0446 
0447     /* if the device supports 32 MHz operation, use it. */
0448     if (dev->speed_32mhz) {
0449         ret = dev->bus->ops->set_clockrate(dev, 32);
0450         if (ret < 0)
0451             dev_err(&dev->dev, "failed to switch to 32 MHz operation.\n");
0452     }
0453 
0454     return 0;
0455 }
0456 EXPORT_SYMBOL_GPL(ipack_device_init);
0457 
0458 int ipack_device_add(struct ipack_device *dev)
0459 {
0460     return device_add(&dev->dev);
0461 }
0462 EXPORT_SYMBOL_GPL(ipack_device_add);
0463 
0464 void ipack_device_del(struct ipack_device *dev)
0465 {
0466     device_del(&dev->dev);
0467     ipack_put_device(dev);
0468 }
0469 EXPORT_SYMBOL_GPL(ipack_device_del);
0470 
0471 void ipack_get_device(struct ipack_device *dev)
0472 {
0473     get_device(&dev->dev);
0474 }
0475 EXPORT_SYMBOL_GPL(ipack_get_device);
0476 
0477 void ipack_put_device(struct ipack_device *dev)
0478 {
0479     put_device(&dev->dev);
0480 }
0481 EXPORT_SYMBOL_GPL(ipack_put_device);
0482 
0483 static int __init ipack_init(void)
0484 {
0485     ida_init(&ipack_ida);
0486     return bus_register(&ipack_bus_type);
0487 }
0488 
0489 static void __exit ipack_exit(void)
0490 {
0491     bus_unregister(&ipack_bus_type);
0492     ida_destroy(&ipack_ida);
0493 }
0494 
0495 module_init(ipack_init);
0496 module_exit(ipack_exit);
0497 
0498 MODULE_AUTHOR("Samuel Iglesias Gonsalvez <siglesias@igalia.com>");
0499 MODULE_LICENSE("GPL");
0500 MODULE_DESCRIPTION("Industry-pack bus core");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!