1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Copyright (C) 2016 Imagination Technologies 4 * Author: Paul Burton <paul.burton@mips.com> 5 */ 6 7 #include <linux/kernel.h> 8 #include <linux/io.h> 9 #include <linux/mfd/syscon.h> 10 #include <linux/module.h> 11 #include <linux/of.h> 12 #include <linux/platform_device.h> 13 #include <linux/property.h> 14 #include <linux/regmap.h> 15 #include <linux/slab.h> 16 17 #include "line-display.h" 18 19 struct img_ascii_lcd_ctx; 20 21 /** 22 * struct img_ascii_lcd_config - Configuration information about an LCD model 23 * @num_chars: the number of characters the LCD can display 24 * @external_regmap: true if registers are in a system controller, else false 25 * @update: function called to update the LCD 26 */ 27 struct img_ascii_lcd_config { 28 unsigned int num_chars; 29 bool external_regmap; 30 void (*update)(struct linedisp *linedisp); 31 }; 32 33 /** 34 * struct img_ascii_lcd_ctx - Private data structure 35 * @base: the base address of the LCD registers 36 * @regmap: the regmap through which LCD registers are accessed 37 * @offset: the offset within regmap to the start of the LCD registers 38 * @cfg: pointer to the LCD model configuration 39 * @linedisp: line display structure 40 * @curr: the string currently displayed on the LCD 41 */ 42 struct img_ascii_lcd_ctx { 43 union { 44 void __iomem *base; 45 struct regmap *regmap; 46 }; 47 u32 offset; 48 const struct img_ascii_lcd_config *cfg; 49 struct linedisp linedisp; 50 char curr[] __aligned(8); 51 }; 52 53 /* 54 * MIPS Boston development board 55 */ 56 57 static void boston_update(struct linedisp *linedisp) 58 { 59 struct img_ascii_lcd_ctx *ctx = 60 container_of(linedisp, struct img_ascii_lcd_ctx, linedisp); 61 ulong val; 62 63 #if BITS_PER_LONG == 64 64 val = *((u64 *)&ctx->curr[0]); 65 __raw_writeq(val, ctx->base); 66 #elif BITS_PER_LONG == 32 67 val = *((u32 *)&ctx->curr[0]); 68 __raw_writel(val, ctx->base); 69 val = *((u32 *)&ctx->curr[4]); 70 __raw_writel(val, ctx->base + 4); 71 #else 72 # error Not 32 or 64 bit 73 #endif 74 } 75 76 static struct img_ascii_lcd_config boston_config = { 77 .num_chars = 8, 78 .update = boston_update, 79 }; 80 81 /* 82 * MIPS Malta development board 83 */ 84 85 static void malta_update(struct linedisp *linedisp) 86 { 87 struct img_ascii_lcd_ctx *ctx = 88 container_of(linedisp, struct img_ascii_lcd_ctx, linedisp); 89 unsigned int i; 90 int err = 0; 91 92 for (i = 0; i < linedisp->num_chars; i++) { 93 err = regmap_write(ctx->regmap, 94 ctx->offset + (i * 8), ctx->curr[i]); 95 if (err) 96 break; 97 } 98 99 if (unlikely(err)) 100 pr_err_ratelimited("Failed to update LCD display: %d\n", err); 101 } 102 103 static struct img_ascii_lcd_config malta_config = { 104 .num_chars = 8, 105 .external_regmap = true, 106 .update = malta_update, 107 }; 108 109 /* 110 * MIPS SEAD3 development board 111 */ 112 113 enum { 114 SEAD3_REG_LCD_CTRL = 0x00, 115 #define SEAD3_REG_LCD_CTRL_SETDRAM BIT(7) 116 SEAD3_REG_LCD_DATA = 0x08, 117 SEAD3_REG_CPLD_STATUS = 0x10, 118 #define SEAD3_REG_CPLD_STATUS_BUSY BIT(0) 119 SEAD3_REG_CPLD_DATA = 0x18, 120 #define SEAD3_REG_CPLD_DATA_BUSY BIT(7) 121 }; 122 123 static int sead3_wait_sm_idle(struct img_ascii_lcd_ctx *ctx) 124 { 125 unsigned int status; 126 int err; 127 128 do { 129 err = regmap_read(ctx->regmap, 130 ctx->offset + SEAD3_REG_CPLD_STATUS, 131 &status); 132 if (err) 133 return err; 134 } while (status & SEAD3_REG_CPLD_STATUS_BUSY); 135 136 return 0; 137 138 } 139 140 static int sead3_wait_lcd_idle(struct img_ascii_lcd_ctx *ctx) 141 { 142 unsigned int cpld_data; 143 int err; 144 145 err = sead3_wait_sm_idle(ctx); 146 if (err) 147 return err; 148 149 do { 150 err = regmap_read(ctx->regmap, 151 ctx->offset + SEAD3_REG_LCD_CTRL, 152 &cpld_data); 153 if (err) 154 return err; 155 156 err = sead3_wait_sm_idle(ctx); 157 if (err) 158 return err; 159 160 err = regmap_read(ctx->regmap, 161 ctx->offset + SEAD3_REG_CPLD_DATA, 162 &cpld_data); 163 if (err) 164 return err; 165 } while (cpld_data & SEAD3_REG_CPLD_DATA_BUSY); 166 167 return 0; 168 } 169 170 static void sead3_update(struct linedisp *linedisp) 171 { 172 struct img_ascii_lcd_ctx *ctx = 173 container_of(linedisp, struct img_ascii_lcd_ctx, linedisp); 174 unsigned int i; 175 int err = 0; 176 177 for (i = 0; i < linedisp->num_chars; i++) { 178 err = sead3_wait_lcd_idle(ctx); 179 if (err) 180 break; 181 182 err = regmap_write(ctx->regmap, 183 ctx->offset + SEAD3_REG_LCD_CTRL, 184 SEAD3_REG_LCD_CTRL_SETDRAM | i); 185 if (err) 186 break; 187 188 err = sead3_wait_lcd_idle(ctx); 189 if (err) 190 break; 191 192 err = regmap_write(ctx->regmap, 193 ctx->offset + SEAD3_REG_LCD_DATA, 194 ctx->curr[i]); 195 if (err) 196 break; 197 } 198 199 if (unlikely(err)) 200 pr_err_ratelimited("Failed to update LCD display: %d\n", err); 201 } 202 203 static struct img_ascii_lcd_config sead3_config = { 204 .num_chars = 16, 205 .external_regmap = true, 206 .update = sead3_update, 207 }; 208 209 static const struct of_device_id img_ascii_lcd_matches[] = { 210 { .compatible = "img,boston-lcd", .data = &boston_config }, 211 { .compatible = "mti,malta-lcd", .data = &malta_config }, 212 { .compatible = "mti,sead3-lcd", .data = &sead3_config }, 213 { /* sentinel */ } 214 }; 215 MODULE_DEVICE_TABLE(of, img_ascii_lcd_matches); 216 217 /** 218 * img_ascii_lcd_probe() - probe an LCD display device 219 * @pdev: the LCD platform device 220 * 221 * Probe an LCD display device, ensuring that we have the required resources in 222 * order to access the LCD & setting up private data as well as sysfs files. 223 * 224 * Return: 0 on success, else -ERRNO 225 */ 226 static int img_ascii_lcd_probe(struct platform_device *pdev) 227 { 228 struct device *dev = &pdev->dev; 229 const struct img_ascii_lcd_config *cfg = device_get_match_data(dev); 230 struct img_ascii_lcd_ctx *ctx; 231 int err; 232 233 ctx = devm_kzalloc(dev, sizeof(*ctx) + cfg->num_chars, GFP_KERNEL); 234 if (!ctx) 235 return -ENOMEM; 236 237 if (cfg->external_regmap) { 238 ctx->regmap = syscon_node_to_regmap(dev->parent->of_node); 239 if (IS_ERR(ctx->regmap)) 240 return PTR_ERR(ctx->regmap); 241 242 if (of_property_read_u32(dev->of_node, "offset", &ctx->offset)) 243 return -EINVAL; 244 } else { 245 ctx->base = devm_platform_ioremap_resource(pdev, 0); 246 if (IS_ERR(ctx->base)) 247 return PTR_ERR(ctx->base); 248 } 249 250 err = linedisp_register(&ctx->linedisp, dev, cfg->num_chars, ctx->curr, 251 cfg->update); 252 if (err) 253 return err; 254 255 /* for backwards compatibility */ 256 err = compat_only_sysfs_link_entry_to_kobj(&dev->kobj, 257 &ctx->linedisp.dev.kobj, 258 "message", NULL); 259 if (err) 260 goto err_unregister; 261 262 platform_set_drvdata(pdev, ctx); 263 return 0; 264 265 err_unregister: 266 linedisp_unregister(&ctx->linedisp); 267 return err; 268 } 269 270 /** 271 * img_ascii_lcd_remove() - remove an LCD display device 272 * @pdev: the LCD platform device 273 * 274 * Remove an LCD display device, freeing private resources & ensuring that the 275 * driver stops using the LCD display registers. 276 * 277 * Return: 0 278 */ 279 static int img_ascii_lcd_remove(struct platform_device *pdev) 280 { 281 struct img_ascii_lcd_ctx *ctx = platform_get_drvdata(pdev); 282 283 sysfs_remove_link(&pdev->dev.kobj, "message"); 284 linedisp_unregister(&ctx->linedisp); 285 return 0; 286 } 287 288 static struct platform_driver img_ascii_lcd_driver = { 289 .driver = { 290 .name = "img-ascii-lcd", 291 .of_match_table = img_ascii_lcd_matches, 292 }, 293 .probe = img_ascii_lcd_probe, 294 .remove = img_ascii_lcd_remove, 295 }; 296 module_platform_driver(img_ascii_lcd_driver); 297 298 MODULE_DESCRIPTION("Imagination Technologies ASCII LCD Display"); 299 MODULE_AUTHOR("Paul Burton <paul.burton@mips.com>"); 300 MODULE_LICENSE("GPL"); 301