2 * Copyright (C) 2016 Imagination Technologies
3 * Author: Paul Burton <paul.burton@mips.com>
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License as published by the
7 * Free Software Foundation; either version 2 of the License, or (at your
8 * option) any later version.
11 #include <generated/utsrelease.h>
12 #include <linux/kernel.h>
14 #include <linux/mfd/syscon.h>
15 #include <linux/module.h>
16 #include <linux/of_address.h>
17 #include <linux/of_platform.h>
18 #include <linux/platform_device.h>
19 #include <linux/regmap.h>
20 #include <linux/slab.h>
21 #include <linux/sysfs.h>
23 struct img_ascii_lcd_ctx
;
26 * struct img_ascii_lcd_config - Configuration information about an LCD model
27 * @num_chars: the number of characters the LCD can display
28 * @external_regmap: true if registers are in a system controller, else false
29 * @update: function called to update the LCD
31 struct img_ascii_lcd_config
{
32 unsigned int num_chars
;
34 void (*update
)(struct img_ascii_lcd_ctx
*ctx
);
38 * struct img_ascii_lcd_ctx - Private data structure
39 * @pdev: the ASCII LCD platform device
40 * @base: the base address of the LCD registers
41 * @regmap: the regmap through which LCD registers are accessed
42 * @offset: the offset within regmap to the start of the LCD registers
43 * @cfg: pointer to the LCD model configuration
44 * @message: the full message to display or scroll on the LCD
45 * @message_len: the length of the @message string
46 * @scroll_pos: index of the first character of @message currently displayed
47 * @scroll_rate: scroll interval in jiffies
48 * @timer: timer used to implement scrolling
49 * @curr: the string currently displayed on the LCD
51 struct img_ascii_lcd_ctx
{
52 struct platform_device
*pdev
;
55 struct regmap
*regmap
;
58 const struct img_ascii_lcd_config
*cfg
;
60 unsigned int message_len
;
61 unsigned int scroll_pos
;
62 unsigned int scroll_rate
;
63 struct timer_list timer
;
64 char curr
[] __aligned(8);
68 * MIPS Boston development board
71 static void boston_update(struct img_ascii_lcd_ctx
*ctx
)
75 #if BITS_PER_LONG == 64
76 val
= *((u64
*)&ctx
->curr
[0]);
77 __raw_writeq(val
, ctx
->base
);
78 #elif BITS_PER_LONG == 32
79 val
= *((u32
*)&ctx
->curr
[0]);
80 __raw_writel(val
, ctx
->base
);
81 val
= *((u32
*)&ctx
->curr
[4]);
82 __raw_writel(val
, ctx
->base
+ 4);
84 # error Not 32 or 64 bit
88 static struct img_ascii_lcd_config boston_config
= {
90 .update
= boston_update
,
94 * MIPS Malta development board
97 static void malta_update(struct img_ascii_lcd_ctx
*ctx
)
102 for (i
= 0; i
< ctx
->cfg
->num_chars
; i
++) {
103 err
= regmap_write(ctx
->regmap
,
104 ctx
->offset
+ (i
* 8), ctx
->curr
[i
]);
110 pr_err_ratelimited("Failed to update LCD display: %d\n", err
);
113 static struct img_ascii_lcd_config malta_config
= {
115 .external_regmap
= true,
116 .update
= malta_update
,
120 * MIPS SEAD3 development board
124 SEAD3_REG_LCD_CTRL
= 0x00,
125 #define SEAD3_REG_LCD_CTRL_SETDRAM BIT(7)
126 SEAD3_REG_LCD_DATA
= 0x08,
127 SEAD3_REG_CPLD_STATUS
= 0x10,
128 #define SEAD3_REG_CPLD_STATUS_BUSY BIT(0)
129 SEAD3_REG_CPLD_DATA
= 0x18,
130 #define SEAD3_REG_CPLD_DATA_BUSY BIT(7)
133 static int sead3_wait_sm_idle(struct img_ascii_lcd_ctx
*ctx
)
139 err
= regmap_read(ctx
->regmap
,
140 ctx
->offset
+ SEAD3_REG_CPLD_STATUS
,
144 } while (status
& SEAD3_REG_CPLD_STATUS_BUSY
);
150 static int sead3_wait_lcd_idle(struct img_ascii_lcd_ctx
*ctx
)
152 unsigned int cpld_data
;
155 err
= sead3_wait_sm_idle(ctx
);
160 err
= regmap_read(ctx
->regmap
,
161 ctx
->offset
+ SEAD3_REG_LCD_CTRL
,
166 err
= sead3_wait_sm_idle(ctx
);
170 err
= regmap_read(ctx
->regmap
,
171 ctx
->offset
+ SEAD3_REG_CPLD_DATA
,
175 } while (cpld_data
& SEAD3_REG_CPLD_DATA_BUSY
);
180 static void sead3_update(struct img_ascii_lcd_ctx
*ctx
)
185 for (i
= 0; i
< ctx
->cfg
->num_chars
; i
++) {
186 err
= sead3_wait_lcd_idle(ctx
);
190 err
= regmap_write(ctx
->regmap
,
191 ctx
->offset
+ SEAD3_REG_LCD_CTRL
,
192 SEAD3_REG_LCD_CTRL_SETDRAM
| i
);
196 err
= sead3_wait_lcd_idle(ctx
);
200 err
= regmap_write(ctx
->regmap
,
201 ctx
->offset
+ SEAD3_REG_LCD_DATA
,
208 pr_err_ratelimited("Failed to update LCD display: %d\n", err
);
211 static struct img_ascii_lcd_config sead3_config
= {
213 .external_regmap
= true,
214 .update
= sead3_update
,
217 static const struct of_device_id img_ascii_lcd_matches
[] = {
218 { .compatible
= "img,boston-lcd", .data
= &boston_config
},
219 { .compatible
= "mti,malta-lcd", .data
= &malta_config
},
220 { .compatible
= "mti,sead3-lcd", .data
= &sead3_config
},
223 MODULE_DEVICE_TABLE(of
, img_ascii_lcd_matches
);
226 * img_ascii_lcd_scroll() - scroll the display by a character
227 * @arg: really a pointer to the private data structure
229 * Scroll the current message along the LCD by one character, rearming the
232 static void img_ascii_lcd_scroll(unsigned long arg
)
234 struct img_ascii_lcd_ctx
*ctx
= (struct img_ascii_lcd_ctx
*)arg
;
235 unsigned int i
, ch
= ctx
->scroll_pos
;
236 unsigned int num_chars
= ctx
->cfg
->num_chars
;
238 /* update the current message string */
239 for (i
= 0; i
< num_chars
;) {
240 /* copy as many characters from the string as possible */
241 for (; i
< num_chars
&& ch
< ctx
->message_len
; i
++, ch
++)
242 ctx
->curr
[i
] = ctx
->message
[ch
];
244 /* wrap around to the start of the string */
249 ctx
->cfg
->update(ctx
);
251 /* move on to the next character */
253 ctx
->scroll_pos
%= ctx
->message_len
;
255 /* rearm the timer */
256 if (ctx
->message_len
> ctx
->cfg
->num_chars
)
257 mod_timer(&ctx
->timer
, jiffies
+ ctx
->scroll_rate
);
261 * img_ascii_lcd_display() - set the message to be displayed
262 * @ctx: pointer to the private data structure
263 * @msg: the message to display
264 * @count: length of msg, or -1
266 * Display a new message @msg on the LCD. @msg can be longer than the number of
267 * characters the LCD can display, in which case it will begin scrolling across
270 * Return: 0 on success, -ENOMEM on memory allocation failure
272 static int img_ascii_lcd_display(struct img_ascii_lcd_ctx
*ctx
,
273 const char *msg
, ssize_t count
)
277 /* stop the scroll timer */
278 del_timer_sync(&ctx
->timer
);
283 /* if the string ends with a newline, trim it */
284 if (msg
[count
- 1] == '\n')
287 new_msg
= devm_kmalloc(&ctx
->pdev
->dev
, count
+ 1, GFP_KERNEL
);
291 memcpy(new_msg
, msg
, count
);
295 devm_kfree(&ctx
->pdev
->dev
, ctx
->message
);
297 ctx
->message
= new_msg
;
298 ctx
->message_len
= count
;
302 img_ascii_lcd_scroll((unsigned long)ctx
);
308 * message_show() - read message via sysfs
309 * @dev: the LCD device
310 * @attr: the LCD message attribute
311 * @buf: the buffer to read the message into
313 * Read the current message being displayed or scrolled across the LCD display
314 * into @buf, for reads from sysfs.
316 * Return: the number of characters written to @buf
318 static ssize_t
message_show(struct device
*dev
, struct device_attribute
*attr
,
321 struct img_ascii_lcd_ctx
*ctx
= dev_get_drvdata(dev
);
323 return sprintf(buf
, "%s\n", ctx
->message
);
327 * message_store() - write a new message via sysfs
328 * @dev: the LCD device
329 * @attr: the LCD message attribute
330 * @buf: the buffer containing the new message
331 * @count: the size of the message in @buf
333 * Write a new message to display or scroll across the LCD display from sysfs.
335 * Return: the size of the message on success, else -ERRNO
337 static ssize_t
message_store(struct device
*dev
, struct device_attribute
*attr
,
338 const char *buf
, size_t count
)
340 struct img_ascii_lcd_ctx
*ctx
= dev_get_drvdata(dev
);
343 err
= img_ascii_lcd_display(ctx
, buf
, count
);
347 static DEVICE_ATTR_RW(message
);
350 * img_ascii_lcd_probe() - probe an LCD display device
351 * @pdev: the LCD platform device
353 * Probe an LCD display device, ensuring that we have the required resources in
354 * order to access the LCD & setting up private data as well as sysfs files.
356 * Return: 0 on success, else -ERRNO
358 static int img_ascii_lcd_probe(struct platform_device
*pdev
)
360 const struct of_device_id
*match
;
361 const struct img_ascii_lcd_config
*cfg
;
362 struct img_ascii_lcd_ctx
*ctx
;
363 struct resource
*res
;
366 match
= of_match_device(img_ascii_lcd_matches
, &pdev
->dev
);
371 ctx
= devm_kzalloc(&pdev
->dev
, sizeof(*ctx
) + cfg
->num_chars
,
376 if (cfg
->external_regmap
) {
377 ctx
->regmap
= syscon_node_to_regmap(pdev
->dev
.parent
->of_node
);
378 if (IS_ERR(ctx
->regmap
))
379 return PTR_ERR(ctx
->regmap
);
381 if (of_property_read_u32(pdev
->dev
.of_node
, "offset",
385 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
386 ctx
->base
= devm_ioremap_resource(&pdev
->dev
, res
);
387 if (IS_ERR(ctx
->base
))
388 return PTR_ERR(ctx
->base
);
395 ctx
->scroll_rate
= HZ
/ 2;
397 /* initialise a timer for scrolling the message */
398 init_timer(&ctx
->timer
);
399 ctx
->timer
.function
= img_ascii_lcd_scroll
;
400 ctx
->timer
.data
= (unsigned long)ctx
;
402 platform_set_drvdata(pdev
, ctx
);
404 /* display a default message */
405 err
= img_ascii_lcd_display(ctx
, "Linux " UTS_RELEASE
" ", -1);
409 err
= device_create_file(&pdev
->dev
, &dev_attr_message
);
415 del_timer_sync(&ctx
->timer
);
420 * img_ascii_lcd_remove() - remove an LCD display device
421 * @pdev: the LCD platform device
423 * Remove an LCD display device, freeing private resources & ensuring that the
424 * driver stops using the LCD display registers.
428 static int img_ascii_lcd_remove(struct platform_device
*pdev
)
430 struct img_ascii_lcd_ctx
*ctx
= platform_get_drvdata(pdev
);
432 device_remove_file(&pdev
->dev
, &dev_attr_message
);
433 del_timer_sync(&ctx
->timer
);
437 static struct platform_driver img_ascii_lcd_driver
= {
439 .name
= "img-ascii-lcd",
440 .of_match_table
= img_ascii_lcd_matches
,
442 .probe
= img_ascii_lcd_probe
,
443 .remove
= img_ascii_lcd_remove
,
445 module_platform_driver(img_ascii_lcd_driver
);