John Crispin | 3c54473 | 2011-04-12 18:10:01 +0200 | [diff] [blame] | 1 | /* |
| 2 | * This program is free software; you can redistribute it and/or modify it |
| 3 | * under the terms of the GNU General Public License version 2 as published |
| 4 | * by the Free Software Foundation. |
| 5 | * |
| 6 | * Copyright (C) 2004 Liu Peng Infineon IFAP DC COM CPE |
John Crispin | 40bc941 | 2016-12-20 20:03:26 +0100 | [diff] [blame] | 7 | * Copyright (C) 2010 John Crispin <john@phrozen.org> |
John Crispin | 3c54473 | 2011-04-12 18:10:01 +0200 | [diff] [blame] | 8 | */ |
| 9 | |
Thierry Reding | b0de774 | 2013-01-21 11:09:12 +0100 | [diff] [blame] | 10 | #include <linux/err.h> |
John Crispin | 3c54473 | 2011-04-12 18:10:01 +0200 | [diff] [blame] | 11 | #include <linux/module.h> |
| 12 | #include <linux/types.h> |
| 13 | #include <linux/kernel.h> |
| 14 | #include <linux/io.h> |
| 15 | #include <linux/slab.h> |
John Crispin | 3c54473 | 2011-04-12 18:10:01 +0200 | [diff] [blame] | 16 | #include <linux/mtd/mtd.h> |
| 17 | #include <linux/mtd/map.h> |
| 18 | #include <linux/mtd/partitions.h> |
| 19 | #include <linux/mtd/cfi.h> |
| 20 | #include <linux/platform_device.h> |
| 21 | #include <linux/mtd/physmap.h> |
John Crispin | fa09ede | 2012-05-05 15:41:42 +0200 | [diff] [blame] | 22 | #include <linux/of.h> |
John Crispin | 3c54473 | 2011-04-12 18:10:01 +0200 | [diff] [blame] | 23 | |
| 24 | #include <lantiq_soc.h> |
John Crispin | 3c54473 | 2011-04-12 18:10:01 +0200 | [diff] [blame] | 25 | |
| 26 | /* |
| 27 | * The NOR flash is connected to the same external bus unit (EBU) as PCI. |
| 28 | * To make PCI work we need to enable the endianness swapping for the address |
| 29 | * written to the EBU. This endianness swapping works for PCI correctly but |
| 30 | * fails for attached NOR devices. To workaround this we need to use a complex |
| 31 | * map. The workaround involves swapping all addresses whilst probing the chip. |
| 32 | * Once probing is complete we stop swapping the addresses but swizzle the |
| 33 | * unlock addresses to ensure that access to the NOR device works correctly. |
| 34 | */ |
| 35 | |
| 36 | enum { |
| 37 | LTQ_NOR_PROBING, |
| 38 | LTQ_NOR_NORMAL |
| 39 | }; |
| 40 | |
| 41 | struct ltq_mtd { |
| 42 | struct resource *res; |
| 43 | struct mtd_info *mtd; |
| 44 | struct map_info *map; |
| 45 | }; |
| 46 | |
John Crispin | 02fa961 | 2012-04-13 09:36:46 +0200 | [diff] [blame] | 47 | static const char ltq_map_name[] = "ltq_nor"; |
John Crispin | 3c54473 | 2011-04-12 18:10:01 +0200 | [diff] [blame] | 48 | |
| 49 | static map_word |
| 50 | ltq_read16(struct map_info *map, unsigned long adr) |
| 51 | { |
| 52 | unsigned long flags; |
| 53 | map_word temp; |
| 54 | |
| 55 | if (map->map_priv_1 == LTQ_NOR_PROBING) |
| 56 | adr ^= 2; |
| 57 | spin_lock_irqsave(&ebu_lock, flags); |
| 58 | temp.x[0] = *(u16 *)(map->virt + adr); |
| 59 | spin_unlock_irqrestore(&ebu_lock, flags); |
| 60 | return temp; |
| 61 | } |
| 62 | |
| 63 | static void |
| 64 | ltq_write16(struct map_info *map, map_word d, unsigned long adr) |
| 65 | { |
| 66 | unsigned long flags; |
| 67 | |
| 68 | if (map->map_priv_1 == LTQ_NOR_PROBING) |
| 69 | adr ^= 2; |
| 70 | spin_lock_irqsave(&ebu_lock, flags); |
| 71 | *(u16 *)(map->virt + adr) = d.x[0]; |
| 72 | spin_unlock_irqrestore(&ebu_lock, flags); |
| 73 | } |
| 74 | |
| 75 | /* |
| 76 | * The following 2 functions copy data between iomem and a cached memory |
| 77 | * section. As memcpy() makes use of pre-fetching we cannot use it here. |
| 78 | * The normal alternative of using memcpy_{to,from}io also makes use of |
| 79 | * memcpy() on MIPS so it is not applicable either. We are therefore stuck |
| 80 | * with having to use our own loop. |
| 81 | */ |
| 82 | static void |
| 83 | ltq_copy_from(struct map_info *map, void *to, |
| 84 | unsigned long from, ssize_t len) |
| 85 | { |
| 86 | unsigned char *f = (unsigned char *)map->virt + from; |
| 87 | unsigned char *t = (unsigned char *)to; |
| 88 | unsigned long flags; |
| 89 | |
| 90 | spin_lock_irqsave(&ebu_lock, flags); |
| 91 | while (len--) |
| 92 | *t++ = *f++; |
| 93 | spin_unlock_irqrestore(&ebu_lock, flags); |
| 94 | } |
| 95 | |
| 96 | static void |
| 97 | ltq_copy_to(struct map_info *map, unsigned long to, |
| 98 | const void *from, ssize_t len) |
| 99 | { |
| 100 | unsigned char *f = (unsigned char *)from; |
| 101 | unsigned char *t = (unsigned char *)map->virt + to; |
| 102 | unsigned long flags; |
| 103 | |
| 104 | spin_lock_irqsave(&ebu_lock, flags); |
| 105 | while (len--) |
| 106 | *t++ = *f++; |
| 107 | spin_unlock_irqrestore(&ebu_lock, flags); |
| 108 | } |
| 109 | |
Bill Pemberton | 06f2551 | 2012-11-19 13:23:07 -0500 | [diff] [blame] | 110 | static int |
John Crispin | 3c54473 | 2011-04-12 18:10:01 +0200 | [diff] [blame] | 111 | ltq_mtd_probe(struct platform_device *pdev) |
| 112 | { |
John Crispin | 3c54473 | 2011-04-12 18:10:01 +0200 | [diff] [blame] | 113 | struct ltq_mtd *ltq_mtd; |
John Crispin | 3c54473 | 2011-04-12 18:10:01 +0200 | [diff] [blame] | 114 | struct cfi_private *cfi; |
| 115 | int err; |
| 116 | |
Jingoo Han | 436bf63 | 2013-12-26 10:42:34 +0900 | [diff] [blame] | 117 | ltq_mtd = devm_kzalloc(&pdev->dev, sizeof(struct ltq_mtd), GFP_KERNEL); |
| 118 | if (!ltq_mtd) |
| 119 | return -ENOMEM; |
| 120 | |
John Crispin | 3c54473 | 2011-04-12 18:10:01 +0200 | [diff] [blame] | 121 | platform_set_drvdata(pdev, ltq_mtd); |
| 122 | |
| 123 | ltq_mtd->res = platform_get_resource(pdev, IORESOURCE_MEM, 0); |
| 124 | if (!ltq_mtd->res) { |
John Crispin | 02fa961 | 2012-04-13 09:36:46 +0200 | [diff] [blame] | 125 | dev_err(&pdev->dev, "failed to get memory resource\n"); |
Jingoo Han | 436bf63 | 2013-12-26 10:42:34 +0900 | [diff] [blame] | 126 | return -ENOENT; |
John Crispin | 3c54473 | 2011-04-12 18:10:01 +0200 | [diff] [blame] | 127 | } |
| 128 | |
Jingoo Han | 436bf63 | 2013-12-26 10:42:34 +0900 | [diff] [blame] | 129 | ltq_mtd->map = devm_kzalloc(&pdev->dev, sizeof(struct map_info), |
| 130 | GFP_KERNEL); |
| 131 | if (!ltq_mtd->map) |
| 132 | return -ENOMEM; |
| 133 | |
John Crispin | 02fa961 | 2012-04-13 09:36:46 +0200 | [diff] [blame] | 134 | ltq_mtd->map->phys = ltq_mtd->res->start; |
| 135 | ltq_mtd->map->size = resource_size(ltq_mtd->res); |
Thierry Reding | b0de774 | 2013-01-21 11:09:12 +0100 | [diff] [blame] | 136 | ltq_mtd->map->virt = devm_ioremap_resource(&pdev->dev, ltq_mtd->res); |
Jingoo Han | 436bf63 | 2013-12-26 10:42:34 +0900 | [diff] [blame] | 137 | if (IS_ERR(ltq_mtd->map->virt)) |
| 138 | return PTR_ERR(ltq_mtd->map->virt); |
John Crispin | 3c54473 | 2011-04-12 18:10:01 +0200 | [diff] [blame] | 139 | |
John Crispin | 3c54473 | 2011-04-12 18:10:01 +0200 | [diff] [blame] | 140 | ltq_mtd->map->name = ltq_map_name; |
| 141 | ltq_mtd->map->bankwidth = 2; |
| 142 | ltq_mtd->map->read = ltq_read16; |
| 143 | ltq_mtd->map->write = ltq_write16; |
| 144 | ltq_mtd->map->copy_from = ltq_copy_from; |
| 145 | ltq_mtd->map->copy_to = ltq_copy_to; |
| 146 | |
| 147 | ltq_mtd->map->map_priv_1 = LTQ_NOR_PROBING; |
| 148 | ltq_mtd->mtd = do_map_probe("cfi_probe", ltq_mtd->map); |
| 149 | ltq_mtd->map->map_priv_1 = LTQ_NOR_NORMAL; |
| 150 | |
| 151 | if (!ltq_mtd->mtd) { |
| 152 | dev_err(&pdev->dev, "probing failed\n"); |
Jingoo Han | 436bf63 | 2013-12-26 10:42:34 +0900 | [diff] [blame] | 153 | return -ENXIO; |
John Crispin | 3c54473 | 2011-04-12 18:10:01 +0200 | [diff] [blame] | 154 | } |
| 155 | |
Frans Klaver | c54c2fb | 2015-06-10 22:38:28 +0200 | [diff] [blame] | 156 | ltq_mtd->mtd->dev.parent = &pdev->dev; |
Brian Norris | 004b5e6 | 2015-10-30 20:33:28 -0700 | [diff] [blame] | 157 | mtd_set_of_node(ltq_mtd->mtd, pdev->dev.of_node); |
John Crispin | 3c54473 | 2011-04-12 18:10:01 +0200 | [diff] [blame] | 158 | |
| 159 | cfi = ltq_mtd->map->fldrv_priv; |
| 160 | cfi->addr_unlock1 ^= 1; |
| 161 | cfi->addr_unlock2 ^= 1; |
| 162 | |
Brian Norris | 004b5e6 | 2015-10-30 20:33:28 -0700 | [diff] [blame] | 163 | err = mtd_device_register(ltq_mtd->mtd, NULL, 0); |
John Crispin | 3c54473 | 2011-04-12 18:10:01 +0200 | [diff] [blame] | 164 | if (err) { |
| 165 | dev_err(&pdev->dev, "failed to add partitions\n"); |
| 166 | goto err_destroy; |
| 167 | } |
| 168 | |
| 169 | return 0; |
| 170 | |
| 171 | err_destroy: |
| 172 | map_destroy(ltq_mtd->mtd); |
John Crispin | 3c54473 | 2011-04-12 18:10:01 +0200 | [diff] [blame] | 173 | return err; |
| 174 | } |
| 175 | |
Bill Pemberton | 810b7e0 | 2012-11-19 13:26:04 -0500 | [diff] [blame] | 176 | static int |
John Crispin | 3c54473 | 2011-04-12 18:10:01 +0200 | [diff] [blame] | 177 | ltq_mtd_remove(struct platform_device *pdev) |
| 178 | { |
| 179 | struct ltq_mtd *ltq_mtd = platform_get_drvdata(pdev); |
| 180 | |
Jingoo Han | 436bf63 | 2013-12-26 10:42:34 +0900 | [diff] [blame] | 181 | if (ltq_mtd && ltq_mtd->mtd) { |
| 182 | mtd_device_unregister(ltq_mtd->mtd); |
| 183 | map_destroy(ltq_mtd->mtd); |
John Crispin | 3c54473 | 2011-04-12 18:10:01 +0200 | [diff] [blame] | 184 | } |
| 185 | return 0; |
| 186 | } |
| 187 | |
John Crispin | 02fa961 | 2012-04-13 09:36:46 +0200 | [diff] [blame] | 188 | static const struct of_device_id ltq_mtd_match[] = { |
| 189 | { .compatible = "lantiq,nor" }, |
| 190 | {}, |
| 191 | }; |
| 192 | MODULE_DEVICE_TABLE(of, ltq_mtd_match); |
| 193 | |
John Crispin | 3c54473 | 2011-04-12 18:10:01 +0200 | [diff] [blame] | 194 | static struct platform_driver ltq_mtd_driver = { |
John Crispin | 02fa961 | 2012-04-13 09:36:46 +0200 | [diff] [blame] | 195 | .probe = ltq_mtd_probe, |
Bill Pemberton | 5153b88 | 2012-11-19 13:21:24 -0500 | [diff] [blame] | 196 | .remove = ltq_mtd_remove, |
John Crispin | 3c54473 | 2011-04-12 18:10:01 +0200 | [diff] [blame] | 197 | .driver = { |
John Crispin | 02fa961 | 2012-04-13 09:36:46 +0200 | [diff] [blame] | 198 | .name = "ltq-nor", |
John Crispin | 02fa961 | 2012-04-13 09:36:46 +0200 | [diff] [blame] | 199 | .of_match_table = ltq_mtd_match, |
John Crispin | 3c54473 | 2011-04-12 18:10:01 +0200 | [diff] [blame] | 200 | }, |
| 201 | }; |
| 202 | |
John Crispin | 02fa961 | 2012-04-13 09:36:46 +0200 | [diff] [blame] | 203 | module_platform_driver(ltq_mtd_driver); |
John Crispin | 3c54473 | 2011-04-12 18:10:01 +0200 | [diff] [blame] | 204 | |
| 205 | MODULE_LICENSE("GPL"); |
John Crispin | 40bc941 | 2016-12-20 20:03:26 +0100 | [diff] [blame] | 206 | MODULE_AUTHOR("John Crispin <john@phrozen.org>"); |
John Crispin | 3c54473 | 2011-04-12 18:10:01 +0200 | [diff] [blame] | 207 | MODULE_DESCRIPTION("Lantiq SoC NOR"); |