1// SPDX-License-Identifier: GPL-2.0+
  2/*
  3 * DRM driver for Ilitek ILI9486 panels
  4 *
  5 * Copyright 2020 Kamlesh Gurudasani <kamlesh.gurudasani@gmail.com>
  6 */
  7
  8#include <linux/backlight.h>
  9#include <linux/delay.h>
 10#include <linux/gpio/consumer.h>
 11#include <linux/module.h>
 12#include <linux/property.h>
 13#include <linux/spi/spi.h>
 14
 15#include <video/mipi_display.h>
 16
 17#include <drm/drm_atomic_helper.h>
 18#include <drm/drm_drv.h>
 19#include <drm/drm_fb_helper.h>
 20#include <drm/drm_gem_cma_helper.h>
 21#include <drm/drm_gem_framebuffer_helper.h>
 22#include <drm/drm_managed.h>
 23#include <drm/drm_mipi_dbi.h>
 24#include <drm/drm_modeset_helper.h>
 25
 26#define ILI9486_ITFCTR1         0xb0
 27#define ILI9486_PWCTRL1         0xc2
 28#define ILI9486_VMCTRL1         0xc5
 29#define ILI9486_PGAMCTRL        0xe0
 30#define ILI9486_NGAMCTRL        0xe1
 31#define ILI9486_DGAMCTRL        0xe2
 32#define ILI9486_MADCTL_BGR      BIT(3)
 33#define ILI9486_MADCTL_MV       BIT(5)
 34#define ILI9486_MADCTL_MX       BIT(6)
 35#define ILI9486_MADCTL_MY       BIT(7)
 36
 37/*
 38 * The PiScreen/waveshare rpi-lcd-35 has a SPI to 16-bit parallel bus converter
 39 * in front of the  display controller. This means that 8-bit values have to be
 40 * transferred as 16-bit.
 41 */
 42static int waveshare_command(struct mipi_dbi *mipi, u8 *cmd, u8 *par,
 43			     size_t num)
 44{
 45	struct spi_device *spi = mipi->spi;
 46	void *data = par;
 47	u32 speed_hz;
 48	int i, ret;
 49	__be16 *buf;
 50
 51	buf = kmalloc(32 * sizeof(u16), GFP_KERNEL);
 52	if (!buf)
 53		return -ENOMEM;
 54
 55	/*
 56	 * The displays are Raspberry Pi HATs and connected to the 8-bit only
 57	 * SPI controller, so 16-bit command and parameters need byte swapping
 58	 * before being transferred as 8-bit on the big endian SPI bus.
 59	 * Pixel data bytes have already been swapped before this function is
 60	 * called.
 61	 */
 62	buf[0] = cpu_to_be16(*cmd);
 63	gpiod_set_value_cansleep(mipi->dc, 0);
 64	speed_hz = mipi_dbi_spi_cmd_max_speed(spi, 2);
 65	ret = mipi_dbi_spi_transfer(spi, speed_hz, 8, buf, 2);
 66	if (ret || !num)
 67		goto free;
 68
 69	/* 8-bit configuration data, not 16-bit pixel data */
 70	if (num <= 32) {
 71		for (i = 0; i < num; i++)
 72			buf[i] = cpu_to_be16(par[i]);
 73		num *= 2;
 74		speed_hz = mipi_dbi_spi_cmd_max_speed(spi, num);
 75		data = buf;
 76	}
 77
 78	gpiod_set_value_cansleep(mipi->dc, 1);
 79	ret = mipi_dbi_spi_transfer(spi, speed_hz, 8, data, num);
 80 free:
 81	kfree(buf);
 82
 83	return ret;
 84}
 85
 86static void waveshare_enable(struct drm_simple_display_pipe *pipe,
 87			     struct drm_crtc_state *crtc_state,
 88			     struct drm_plane_state *plane_state)
 89{
 90	struct mipi_dbi_dev *dbidev = drm_to_mipi_dbi_dev(pipe->crtc.dev);
 91	struct mipi_dbi *dbi = &dbidev->dbi;
 92	u8 addr_mode;
 93	int ret, idx;
 94
 95	if (!drm_dev_enter(pipe->crtc.dev, &idx))
 96		return;
 97
 98	DRM_DEBUG_KMS("\n");
 99
100	ret = mipi_dbi_poweron_conditional_reset(dbidev);
101	if (ret < 0)
102		goto out_exit;
103	if (ret == 1)
104		goto out_enable;
105
106	mipi_dbi_command(dbi, ILI9486_ITFCTR1);
107	mipi_dbi_command(dbi, MIPI_DCS_EXIT_SLEEP_MODE);
108	msleep(250);
109
110	mipi_dbi_command(dbi, MIPI_DCS_SET_PIXEL_FORMAT, 0x55);
111
112	mipi_dbi_command(dbi, ILI9486_PWCTRL1, 0x44);
113
114	mipi_dbi_command(dbi, ILI9486_VMCTRL1, 0x00, 0x00, 0x00, 0x00);
115
116	mipi_dbi_command(dbi, ILI9486_PGAMCTRL,
117			 0x0F, 0x1F, 0x1C, 0x0C, 0x0F, 0x08, 0x48, 0x98,
118			 0x37, 0x0A, 0x13, 0x04, 0x11, 0x0D, 0x0);
119	mipi_dbi_command(dbi, ILI9486_NGAMCTRL,
120			 0x0F, 0x32, 0x2E, 0x0B, 0x0D, 0x05, 0x47, 0x75,
121			 0x37, 0x06, 0x10, 0x03, 0x24, 0x20, 0x00);
122	mipi_dbi_command(dbi, ILI9486_DGAMCTRL,
123			 0x0F, 0x32, 0x2E, 0x0B, 0x0D, 0x05, 0x47, 0x75,
124			 0x37, 0x06, 0x10, 0x03, 0x24, 0x20, 0x00);
125
126	mipi_dbi_command(dbi, MIPI_DCS_SET_DISPLAY_ON);
127	msleep(100);
128
129 out_enable:
130	switch (dbidev->rotation) {
131	case 90:
132		addr_mode = ILI9486_MADCTL_MY;
133		break;
134	case 180:
135		addr_mode = ILI9486_MADCTL_MV;
136		break;
137	case 270:
138		addr_mode = ILI9486_MADCTL_MX;
139		break;
140	default:
141		addr_mode = ILI9486_MADCTL_MV | ILI9486_MADCTL_MY |
142			ILI9486_MADCTL_MX;
143		break;
144	}
145	addr_mode |= ILI9486_MADCTL_BGR;
146	mipi_dbi_command(dbi, MIPI_DCS_SET_ADDRESS_MODE, addr_mode);
147	mipi_dbi_enable_flush(dbidev, crtc_state, plane_state);
148 out_exit:
149	drm_dev_exit(idx);
150}
151
152static const struct drm_simple_display_pipe_funcs waveshare_pipe_funcs = {
153	.enable = waveshare_enable,
154	.disable = mipi_dbi_pipe_disable,
155	.update = mipi_dbi_pipe_update,
156	.prepare_fb = drm_gem_fb_simple_display_pipe_prepare_fb,
157};
158
159static const struct drm_display_mode waveshare_mode = {
160	DRM_SIMPLE_MODE(480, 320, 73, 49),
161};
162
163DEFINE_DRM_GEM_CMA_FOPS(ili9486_fops);
164
165static struct drm_driver ili9486_driver = {
166	.driver_features	= DRIVER_GEM | DRIVER_MODESET | DRIVER_ATOMIC,
167	.fops			= &ili9486_fops,
168	DRM_GEM_CMA_DRIVER_OPS_VMAP,
169	.debugfs_init		= mipi_dbi_debugfs_init,
170	.name			= "ili9486",
171	.desc			= "Ilitek ILI9486",
172	.date			= "20200118",
173	.major			= 1,
174	.minor			= 0,
175};
176
177static const struct of_device_id ili9486_of_match[] = {
178	{ .compatible = "waveshare,rpi-lcd-35" },
179	{ .compatible = "ozzmaker,piscreen" },
180	{},
181};
182MODULE_DEVICE_TABLE(of, ili9486_of_match);
183
184static const struct spi_device_id ili9486_id[] = {
185	{ "ili9486", 0 },
186	{ }
187};
188MODULE_DEVICE_TABLE(spi, ili9486_id);
189
190static int ili9486_probe(struct spi_device *spi)
191{
192	struct device *dev = &spi->dev;
193	struct mipi_dbi_dev *dbidev;
194	struct drm_device *drm;
195	struct mipi_dbi *dbi;
196	struct gpio_desc *dc;
197	u32 rotation = 0;
198	int ret;
199
200	dbidev = devm_drm_dev_alloc(dev, &ili9486_driver,
201				    struct mipi_dbi_dev, drm);
202	if (IS_ERR(dbidev))
203		return PTR_ERR(dbidev);
204
205	dbi = &dbidev->dbi;
206	drm = &dbidev->drm;
207
208	dbi->reset = devm_gpiod_get(dev, "reset", GPIOD_OUT_HIGH);
209	if (IS_ERR(dbi->reset)) {
210		DRM_DEV_ERROR(dev, "Failed to get gpio 'reset'\n");
211		return PTR_ERR(dbi->reset);
212	}
213
214	dc = devm_gpiod_get(dev, "dc", GPIOD_OUT_LOW);
215	if (IS_ERR(dc)) {
216		DRM_DEV_ERROR(dev, "Failed to get gpio 'dc'\n");
217		return PTR_ERR(dc);
218	}
219
220	dbidev->backlight = devm_of_find_backlight(dev);
221	if (IS_ERR(dbidev->backlight))
222		return PTR_ERR(dbidev->backlight);
223
224	device_property_read_u32(dev, "rotation", &rotation);
225
226	ret = mipi_dbi_spi_init(spi, dbi, dc);
227	if (ret)
228		return ret;
229
230	dbi->command = waveshare_command;
231	dbi->read_commands = NULL;
232
233	ret = mipi_dbi_dev_init(dbidev, &waveshare_pipe_funcs,
234				&waveshare_mode, rotation);
235	if (ret)
236		return ret;
237
238	drm_mode_config_reset(drm);
239
240	ret = drm_dev_register(drm, 0);
241	if (ret)
242		return ret;
243
244	spi_set_drvdata(spi, drm);
245
246	drm_fbdev_generic_setup(drm, 0);
247
248	return 0;
249}
250
251static int ili9486_remove(struct spi_device *spi)
252{
253	struct drm_device *drm = spi_get_drvdata(spi);
254
255	drm_dev_unplug(drm);
256	drm_atomic_helper_shutdown(drm);
257
258	return 0;
259}
260
261static void ili9486_shutdown(struct spi_device *spi)
262{
263	drm_atomic_helper_shutdown(spi_get_drvdata(spi));
264}
265
266static struct spi_driver ili9486_spi_driver = {
267	.driver = {
268		.name = "ili9486",
269		.of_match_table = ili9486_of_match,
270	},
271	.id_table = ili9486_id,
272	.probe = ili9486_probe,
273	.remove = ili9486_remove,
274	.shutdown = ili9486_shutdown,
275};
276module_spi_driver(ili9486_spi_driver);
277
278MODULE_DESCRIPTION("Ilitek ILI9486 DRM driver");
279MODULE_AUTHOR("Kamlesh Gurudasani <kamlesh.gurudasani@gmail.com>");
280MODULE_LICENSE("GPL");