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