drivers/mtd/hyperbus/hyperbus-core.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 //
   3 // Copyright (C) 2019 Texas Instruments Incorporated - https://www.ti.com/
   4 // Author: Vignesh Raghavendra <vigneshr@ti.com>
   5
   6 #include <linux/err.h>
   7 #include <linux/kernel.h>
   8 #include <linux/module.h>
   9 #include <linux/mtd/hyperbus.h>
  10 #include <linux/mtd/map.h>
  11 #include <linux/mtd/mtd.h>
  12 #include <linux/of.h>
  13 #include <linux/types.h>
  14
  15 static struct hyperbus_device *map_to_hbdev(struct map_info *map)
  16 {
  17         return container_of(map, struct hyperbus_device, map);
  18 }
  19
  20 static map_word hyperbus_read16(struct map_info *map, unsigned long addr)
  21 {
  22         struct hyperbus_device *hbdev = map_to_hbdev(map);
  23         struct hyperbus_ctlr *ctlr = hbdev->ctlr;
  24         map_word read_data;
  25
  26         read_data.x[0] = ctlr->ops->read16(hbdev, addr);
  27
  28         return read_data;
  29 }
  30
  31 static void hyperbus_write16(struct map_info *map, map_word d,
  32                              unsigned long addr)
  33 {
  34         struct hyperbus_device *hbdev = map_to_hbdev(map);
  35         struct hyperbus_ctlr *ctlr = hbdev->ctlr;
  36
  37         ctlr->ops->write16(hbdev, addr, d.x[0]);
  38 }
  39
  40 static void hyperbus_copy_from(struct map_info *map, void *to,
  41                                unsigned long from, ssize_t len)
  42 {
  43         struct hyperbus_device *hbdev = map_to_hbdev(map);
  44         struct hyperbus_ctlr *ctlr = hbdev->ctlr;
  45
  46         ctlr->ops->copy_from(hbdev, to, from, len);
  47 }
  48
  49 static void hyperbus_copy_to(struct map_info *map, unsigned long to,
  50                              const void *from, ssize_t len)
  51 {
  52         struct hyperbus_device *hbdev = map_to_hbdev(map);
  53         struct hyperbus_ctlr *ctlr = hbdev->ctlr;
  54
  55         ctlr->ops->copy_to(hbdev, to, from, len);
  56 }
  57
  58 int hyperbus_register_device(struct hyperbus_device *hbdev)
  59 {
  60         const struct hyperbus_ops *ops;
  61         struct hyperbus_ctlr *ctlr;
  62         struct device_node *np;
  63         struct map_info *map;
  64         struct device *dev;
  65         int ret;
  66
  67         if (!hbdev || !hbdev->np || !hbdev->ctlr || !hbdev->ctlr->dev) {
  68                 pr_err("hyperbus: please fill all the necessary fields!\n");
  69                 return -EINVAL;
  70         }
  71
  72         np = hbdev->np;
  73         ctlr = hbdev->ctlr;
  74         if (!of_device_is_compatible(np, "cypress,hyperflash")) {
  75                 dev_err(ctlr->dev, "\"cypress,hyperflash\" compatible missing\n");
  76                 return -ENODEV;
  77         }
  78
  79         hbdev->memtype = HYPERFLASH;
  80
  81         dev = ctlr->dev;
  82         map = &hbdev->map;
  83         map->name = dev_name(dev);
  84         map->bankwidth = 2;
  85         map->device_node = np;
  86
  87         simple_map_init(map);
  88         ops = ctlr->ops;
  89         if (ops) {
  90                 if (ops->read16)
  91                         map->read = hyperbus_read16;
  92                 if (ops->write16)
  93                         map->write = hyperbus_write16;
  94                 if (ops->copy_to)
  95                         map->copy_to = hyperbus_copy_to;
  96                 if (ops->copy_from)
  97                         map->copy_from = hyperbus_copy_from;
  98
  99                 if (ops->calibrate && !ctlr->calibrated) {
 100                         ret = ops->calibrate(hbdev);
 101                         if (!ret) {
 102                                 dev_err(dev, "Calibration failed\n");
 103                                 return -ENODEV;
 104                         }
 105                         ctlr->calibrated = true;
 106                 }
 107         }
 108
 109         hbdev->mtd = do_map_probe("cfi_probe", map);
 110         if (!hbdev->mtd) {
 111                 dev_err(dev, "probing of hyperbus device failed\n");
 112                 return -ENODEV;
 113         }
 114
 115         hbdev->mtd->dev.parent = dev;
 116         mtd_set_of_node(hbdev->mtd, np);
 117
 118         ret = mtd_device_register(hbdev->mtd, NULL, 0);
 119         if (ret) {
 120                 dev_err(dev, "failed to register mtd device\n");
 121                 map_destroy(hbdev->mtd);
 122                 return ret;
 123         }
 124
 125         return 0;
 126 }
 127 EXPORT_SYMBOL_GPL(hyperbus_register_device);
 128
 129 int hyperbus_unregister_device(struct hyperbus_device *hbdev)
 130 {
 131         int ret = 0;
 132
 133         if (hbdev && hbdev->mtd) {
 134                 ret = mtd_device_unregister(hbdev->mtd);
 135                 map_destroy(hbdev->mtd);
 136         }
 137
 138         return ret;
 139 }
 140 EXPORT_SYMBOL_GPL(hyperbus_unregister_device);
 141
 142 MODULE_DESCRIPTION("HyperBus Framework");
 143 MODULE_LICENSE("GPL v2");
 144 MODULE_AUTHOR("Vignesh Raghavendra <vigneshr@ti.com>");