corgi_lcd.c 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * LCD/Backlight Driver for Sharp Zaurus Handhelds (various models)
  4. *
  5. * Copyright (c) 2004-2006 Richard Purdie
  6. *
  7. * Based on Sharp's 2.4 Backlight Driver
  8. *
  9. * Copyright (c) 2008 Marvell International Ltd.
  10. * Converted to SPI device based LCD/Backlight device driver
  11. * by Eric Miao <eric.miao@marvell.com>
  12. */
  13. #include <linux/module.h>
  14. #include <linux/kernel.h>
  15. #include <linux/init.h>
  16. #include <linux/delay.h>
  17. #include <linux/gpio/consumer.h>
  18. #include <linux/fb.h>
  19. #include <linux/lcd.h>
  20. #include <linux/spi/spi.h>
  21. #include <linux/spi/corgi_lcd.h>
  22. #include <linux/slab.h>
  23. #include <asm/mach/sharpsl_param.h>
  24. #define POWER_IS_ON(pwr) ((pwr) <= FB_BLANK_NORMAL)
  25. /* Register Addresses */
  26. #define RESCTL_ADRS 0x00
  27. #define PHACTRL_ADRS 0x01
  28. #define DUTYCTRL_ADRS 0x02
  29. #define POWERREG0_ADRS 0x03
  30. #define POWERREG1_ADRS 0x04
  31. #define GPOR3_ADRS 0x05
  32. #define PICTRL_ADRS 0x06
  33. #define POLCTRL_ADRS 0x07
  34. /* Register Bit Definitions */
  35. #define RESCTL_QVGA 0x01
  36. #define RESCTL_VGA 0x00
  37. #define POWER1_VW_ON 0x01 /* VW Supply FET ON */
  38. #define POWER1_GVSS_ON 0x02 /* GVSS(-8V) Power Supply ON */
  39. #define POWER1_VDD_ON 0x04 /* VDD(8V),SVSS(-4V) Power Supply ON */
  40. #define POWER1_VW_OFF 0x00 /* VW Supply FET OFF */
  41. #define POWER1_GVSS_OFF 0x00 /* GVSS(-8V) Power Supply OFF */
  42. #define POWER1_VDD_OFF 0x00 /* VDD(8V),SVSS(-4V) Power Supply OFF */
  43. #define POWER0_COM_DCLK 0x01 /* COM Voltage DC Bias DAC Serial Data Clock */
  44. #define POWER0_COM_DOUT 0x02 /* COM Voltage DC Bias DAC Serial Data Out */
  45. #define POWER0_DAC_ON 0x04 /* DAC Power Supply ON */
  46. #define POWER0_COM_ON 0x08 /* COM Power Supply ON */
  47. #define POWER0_VCC5_ON 0x10 /* VCC5 Power Supply ON */
  48. #define POWER0_DAC_OFF 0x00 /* DAC Power Supply OFF */
  49. #define POWER0_COM_OFF 0x00 /* COM Power Supply OFF */
  50. #define POWER0_VCC5_OFF 0x00 /* VCC5 Power Supply OFF */
  51. #define PICTRL_INIT_STATE 0x01
  52. #define PICTRL_INIOFF 0x02
  53. #define PICTRL_POWER_DOWN 0x04
  54. #define PICTRL_COM_SIGNAL_OFF 0x08
  55. #define PICTRL_DAC_SIGNAL_OFF 0x10
  56. #define POLCTRL_SYNC_POL_FALL 0x01
  57. #define POLCTRL_EN_POL_FALL 0x02
  58. #define POLCTRL_DATA_POL_FALL 0x04
  59. #define POLCTRL_SYNC_ACT_H 0x08
  60. #define POLCTRL_EN_ACT_L 0x10
  61. #define POLCTRL_SYNC_POL_RISE 0x00
  62. #define POLCTRL_EN_POL_RISE 0x00
  63. #define POLCTRL_DATA_POL_RISE 0x00
  64. #define POLCTRL_SYNC_ACT_L 0x00
  65. #define POLCTRL_EN_ACT_H 0x00
  66. #define PHACTRL_PHASE_MANUAL 0x01
  67. #define DEFAULT_PHAD_QVGA (9)
  68. #define DEFAULT_COMADJ (125)
  69. struct corgi_lcd {
  70. struct spi_device *spi_dev;
  71. struct lcd_device *lcd_dev;
  72. struct backlight_device *bl_dev;
  73. int limit_mask;
  74. int intensity;
  75. int power;
  76. int mode;
  77. char buf[2];
  78. struct gpio_desc *backlight_on;
  79. struct gpio_desc *backlight_cont;
  80. void (*kick_battery)(void);
  81. };
  82. static int corgi_ssp_lcdtg_send(struct corgi_lcd *lcd, int reg, uint8_t val);
  83. static struct corgi_lcd *the_corgi_lcd;
  84. static unsigned long corgibl_flags;
  85. #define CORGIBL_SUSPENDED 0x01
  86. #define CORGIBL_BATTLOW 0x02
  87. /*
  88. * This is only a pseudo I2C interface. We can't use the standard kernel
  89. * routines as the interface is write only. We just assume the data is acked...
  90. */
  91. static void lcdtg_ssp_i2c_send(struct corgi_lcd *lcd, uint8_t data)
  92. {
  93. corgi_ssp_lcdtg_send(lcd, POWERREG0_ADRS, data);
  94. udelay(10);
  95. }
  96. static void lcdtg_i2c_send_bit(struct corgi_lcd *lcd, uint8_t data)
  97. {
  98. lcdtg_ssp_i2c_send(lcd, data);
  99. lcdtg_ssp_i2c_send(lcd, data | POWER0_COM_DCLK);
  100. lcdtg_ssp_i2c_send(lcd, data);
  101. }
  102. static void lcdtg_i2c_send_start(struct corgi_lcd *lcd, uint8_t base)
  103. {
  104. lcdtg_ssp_i2c_send(lcd, base | POWER0_COM_DCLK | POWER0_COM_DOUT);
  105. lcdtg_ssp_i2c_send(lcd, base | POWER0_COM_DCLK);
  106. lcdtg_ssp_i2c_send(lcd, base);
  107. }
  108. static void lcdtg_i2c_send_stop(struct corgi_lcd *lcd, uint8_t base)
  109. {
  110. lcdtg_ssp_i2c_send(lcd, base);
  111. lcdtg_ssp_i2c_send(lcd, base | POWER0_COM_DCLK);
  112. lcdtg_ssp_i2c_send(lcd, base | POWER0_COM_DCLK | POWER0_COM_DOUT);
  113. }
  114. static void lcdtg_i2c_send_byte(struct corgi_lcd *lcd,
  115. uint8_t base, uint8_t data)
  116. {
  117. int i;
  118. for (i = 0; i < 8; i++) {
  119. if (data & 0x80)
  120. lcdtg_i2c_send_bit(lcd, base | POWER0_COM_DOUT);
  121. else
  122. lcdtg_i2c_send_bit(lcd, base);
  123. data <<= 1;
  124. }
  125. }
  126. static void lcdtg_i2c_wait_ack(struct corgi_lcd *lcd, uint8_t base)
  127. {
  128. lcdtg_i2c_send_bit(lcd, base);
  129. }
  130. static void lcdtg_set_common_voltage(struct corgi_lcd *lcd,
  131. uint8_t base_data, uint8_t data)
  132. {
  133. /* Set Common Voltage to M62332FP via I2C */
  134. lcdtg_i2c_send_start(lcd, base_data);
  135. lcdtg_i2c_send_byte(lcd, base_data, 0x9c);
  136. lcdtg_i2c_wait_ack(lcd, base_data);
  137. lcdtg_i2c_send_byte(lcd, base_data, 0x00);
  138. lcdtg_i2c_wait_ack(lcd, base_data);
  139. lcdtg_i2c_send_byte(lcd, base_data, data);
  140. lcdtg_i2c_wait_ack(lcd, base_data);
  141. lcdtg_i2c_send_stop(lcd, base_data);
  142. }
  143. static int corgi_ssp_lcdtg_send(struct corgi_lcd *lcd, int adrs, uint8_t data)
  144. {
  145. struct spi_message msg;
  146. struct spi_transfer xfer = {
  147. .len = 1,
  148. .cs_change = 0,
  149. .tx_buf = lcd->buf,
  150. };
  151. lcd->buf[0] = ((adrs & 0x07) << 5) | (data & 0x1f);
  152. spi_message_init(&msg);
  153. spi_message_add_tail(&xfer, &msg);
  154. return spi_sync(lcd->spi_dev, &msg);
  155. }
  156. /* Set Phase Adjust */
  157. static void lcdtg_set_phadadj(struct corgi_lcd *lcd, int mode)
  158. {
  159. int adj;
  160. switch (mode) {
  161. case CORGI_LCD_MODE_VGA:
  162. /* Setting for VGA */
  163. adj = sharpsl_param.phadadj;
  164. adj = (adj < 0) ? PHACTRL_PHASE_MANUAL :
  165. PHACTRL_PHASE_MANUAL | ((adj & 0xf) << 1);
  166. break;
  167. case CORGI_LCD_MODE_QVGA:
  168. default:
  169. /* Setting for QVGA */
  170. adj = (DEFAULT_PHAD_QVGA << 1) | PHACTRL_PHASE_MANUAL;
  171. break;
  172. }
  173. corgi_ssp_lcdtg_send(lcd, PHACTRL_ADRS, adj);
  174. }
  175. static void corgi_lcd_power_on(struct corgi_lcd *lcd)
  176. {
  177. int comadj;
  178. /* Initialize Internal Logic & Port */
  179. corgi_ssp_lcdtg_send(lcd, PICTRL_ADRS,
  180. PICTRL_POWER_DOWN | PICTRL_INIOFF |
  181. PICTRL_INIT_STATE | PICTRL_COM_SIGNAL_OFF |
  182. PICTRL_DAC_SIGNAL_OFF);
  183. corgi_ssp_lcdtg_send(lcd, POWERREG0_ADRS,
  184. POWER0_COM_DCLK | POWER0_COM_DOUT | POWER0_DAC_OFF |
  185. POWER0_COM_OFF | POWER0_VCC5_OFF);
  186. corgi_ssp_lcdtg_send(lcd, POWERREG1_ADRS,
  187. POWER1_VW_OFF | POWER1_GVSS_OFF | POWER1_VDD_OFF);
  188. /* VDD(+8V), SVSS(-4V) ON */
  189. corgi_ssp_lcdtg_send(lcd, POWERREG1_ADRS,
  190. POWER1_VW_OFF | POWER1_GVSS_OFF | POWER1_VDD_ON);
  191. mdelay(3);
  192. /* DAC ON */
  193. corgi_ssp_lcdtg_send(lcd, POWERREG0_ADRS,
  194. POWER0_COM_DCLK | POWER0_COM_DOUT | POWER0_DAC_ON |
  195. POWER0_COM_OFF | POWER0_VCC5_OFF);
  196. /* INIB = H, INI = L */
  197. /* PICTL[0] = H , PICTL[1] = PICTL[2] = PICTL[4] = L */
  198. corgi_ssp_lcdtg_send(lcd, PICTRL_ADRS,
  199. PICTRL_INIT_STATE | PICTRL_COM_SIGNAL_OFF);
  200. /* Set Common Voltage */
  201. comadj = sharpsl_param.comadj;
  202. if (comadj < 0)
  203. comadj = DEFAULT_COMADJ;
  204. lcdtg_set_common_voltage(lcd, POWER0_DAC_ON | POWER0_COM_OFF |
  205. POWER0_VCC5_OFF, comadj);
  206. /* VCC5 ON, DAC ON */
  207. corgi_ssp_lcdtg_send(lcd, POWERREG0_ADRS,
  208. POWER0_COM_DCLK | POWER0_COM_DOUT | POWER0_DAC_ON |
  209. POWER0_COM_OFF | POWER0_VCC5_ON);
  210. /* GVSS(-8V) ON, VDD ON */
  211. corgi_ssp_lcdtg_send(lcd, POWERREG1_ADRS,
  212. POWER1_VW_OFF | POWER1_GVSS_ON | POWER1_VDD_ON);
  213. mdelay(2);
  214. /* COM SIGNAL ON (PICTL[3] = L) */
  215. corgi_ssp_lcdtg_send(lcd, PICTRL_ADRS, PICTRL_INIT_STATE);
  216. /* COM ON, DAC ON, VCC5_ON */
  217. corgi_ssp_lcdtg_send(lcd, POWERREG0_ADRS,
  218. POWER0_COM_DCLK | POWER0_COM_DOUT | POWER0_DAC_ON |
  219. POWER0_COM_ON | POWER0_VCC5_ON);
  220. /* VW ON, GVSS ON, VDD ON */
  221. corgi_ssp_lcdtg_send(lcd, POWERREG1_ADRS,
  222. POWER1_VW_ON | POWER1_GVSS_ON | POWER1_VDD_ON);
  223. /* Signals output enable */
  224. corgi_ssp_lcdtg_send(lcd, PICTRL_ADRS, 0);
  225. /* Set Phase Adjust */
  226. lcdtg_set_phadadj(lcd, lcd->mode);
  227. /* Initialize for Input Signals from ATI */
  228. corgi_ssp_lcdtg_send(lcd, POLCTRL_ADRS,
  229. POLCTRL_SYNC_POL_RISE | POLCTRL_EN_POL_RISE |
  230. POLCTRL_DATA_POL_RISE | POLCTRL_SYNC_ACT_L |
  231. POLCTRL_EN_ACT_H);
  232. udelay(1000);
  233. switch (lcd->mode) {
  234. case CORGI_LCD_MODE_VGA:
  235. corgi_ssp_lcdtg_send(lcd, RESCTL_ADRS, RESCTL_VGA);
  236. break;
  237. case CORGI_LCD_MODE_QVGA:
  238. default:
  239. corgi_ssp_lcdtg_send(lcd, RESCTL_ADRS, RESCTL_QVGA);
  240. break;
  241. }
  242. }
  243. static void corgi_lcd_power_off(struct corgi_lcd *lcd)
  244. {
  245. /* 60Hz x 2 frame = 16.7msec x 2 = 33.4 msec */
  246. msleep(34);
  247. /* (1)VW OFF */
  248. corgi_ssp_lcdtg_send(lcd, POWERREG1_ADRS,
  249. POWER1_VW_OFF | POWER1_GVSS_ON | POWER1_VDD_ON);
  250. /* (2)COM OFF */
  251. corgi_ssp_lcdtg_send(lcd, PICTRL_ADRS, PICTRL_COM_SIGNAL_OFF);
  252. corgi_ssp_lcdtg_send(lcd, POWERREG0_ADRS,
  253. POWER0_DAC_ON | POWER0_COM_OFF | POWER0_VCC5_ON);
  254. /* (3)Set Common Voltage Bias 0V */
  255. lcdtg_set_common_voltage(lcd, POWER0_DAC_ON | POWER0_COM_OFF |
  256. POWER0_VCC5_ON, 0);
  257. /* (4)GVSS OFF */
  258. corgi_ssp_lcdtg_send(lcd, POWERREG1_ADRS,
  259. POWER1_VW_OFF | POWER1_GVSS_OFF | POWER1_VDD_ON);
  260. /* (5)VCC5 OFF */
  261. corgi_ssp_lcdtg_send(lcd, POWERREG0_ADRS,
  262. POWER0_DAC_ON | POWER0_COM_OFF | POWER0_VCC5_OFF);
  263. /* (6)Set PDWN, INIOFF, DACOFF */
  264. corgi_ssp_lcdtg_send(lcd, PICTRL_ADRS,
  265. PICTRL_INIOFF | PICTRL_DAC_SIGNAL_OFF |
  266. PICTRL_POWER_DOWN | PICTRL_COM_SIGNAL_OFF);
  267. /* (7)DAC OFF */
  268. corgi_ssp_lcdtg_send(lcd, POWERREG0_ADRS,
  269. POWER0_DAC_OFF | POWER0_COM_OFF | POWER0_VCC5_OFF);
  270. /* (8)VDD OFF */
  271. corgi_ssp_lcdtg_send(lcd, POWERREG1_ADRS,
  272. POWER1_VW_OFF | POWER1_GVSS_OFF | POWER1_VDD_OFF);
  273. }
  274. static int corgi_lcd_set_mode(struct lcd_device *ld, struct fb_videomode *m)
  275. {
  276. struct corgi_lcd *lcd = lcd_get_data(ld);
  277. int mode = CORGI_LCD_MODE_QVGA;
  278. if (m->xres == 640 || m->xres == 480)
  279. mode = CORGI_LCD_MODE_VGA;
  280. if (lcd->mode == mode)
  281. return 0;
  282. lcdtg_set_phadadj(lcd, mode);
  283. switch (mode) {
  284. case CORGI_LCD_MODE_VGA:
  285. corgi_ssp_lcdtg_send(lcd, RESCTL_ADRS, RESCTL_VGA);
  286. break;
  287. case CORGI_LCD_MODE_QVGA:
  288. default:
  289. corgi_ssp_lcdtg_send(lcd, RESCTL_ADRS, RESCTL_QVGA);
  290. break;
  291. }
  292. lcd->mode = mode;
  293. return 0;
  294. }
  295. static int corgi_lcd_set_power(struct lcd_device *ld, int power)
  296. {
  297. struct corgi_lcd *lcd = lcd_get_data(ld);
  298. if (POWER_IS_ON(power) && !POWER_IS_ON(lcd->power))
  299. corgi_lcd_power_on(lcd);
  300. if (!POWER_IS_ON(power) && POWER_IS_ON(lcd->power))
  301. corgi_lcd_power_off(lcd);
  302. lcd->power = power;
  303. return 0;
  304. }
  305. static int corgi_lcd_get_power(struct lcd_device *ld)
  306. {
  307. struct corgi_lcd *lcd = lcd_get_data(ld);
  308. return lcd->power;
  309. }
  310. static struct lcd_ops corgi_lcd_ops = {
  311. .get_power = corgi_lcd_get_power,
  312. .set_power = corgi_lcd_set_power,
  313. .set_mode = corgi_lcd_set_mode,
  314. };
  315. static int corgi_bl_get_intensity(struct backlight_device *bd)
  316. {
  317. struct corgi_lcd *lcd = bl_get_data(bd);
  318. return lcd->intensity;
  319. }
  320. static int corgi_bl_set_intensity(struct corgi_lcd *lcd, int intensity)
  321. {
  322. int cont;
  323. if (intensity > 0x10)
  324. intensity += 0x10;
  325. corgi_ssp_lcdtg_send(lcd, DUTYCTRL_ADRS, intensity);
  326. /* Bit 5 via GPIO_BACKLIGHT_CONT */
  327. cont = !!(intensity & 0x20);
  328. if (lcd->backlight_cont)
  329. gpiod_set_value_cansleep(lcd->backlight_cont, cont);
  330. if (lcd->backlight_on)
  331. gpiod_set_value_cansleep(lcd->backlight_on, intensity);
  332. if (lcd->kick_battery)
  333. lcd->kick_battery();
  334. lcd->intensity = intensity;
  335. return 0;
  336. }
  337. static int corgi_bl_update_status(struct backlight_device *bd)
  338. {
  339. struct corgi_lcd *lcd = bl_get_data(bd);
  340. int intensity = backlight_get_brightness(bd);
  341. if (corgibl_flags & CORGIBL_SUSPENDED)
  342. intensity = 0;
  343. if ((corgibl_flags & CORGIBL_BATTLOW) && intensity > lcd->limit_mask)
  344. intensity = lcd->limit_mask;
  345. return corgi_bl_set_intensity(lcd, intensity);
  346. }
  347. void corgi_lcd_limit_intensity(int limit)
  348. {
  349. if (limit)
  350. corgibl_flags |= CORGIBL_BATTLOW;
  351. else
  352. corgibl_flags &= ~CORGIBL_BATTLOW;
  353. backlight_update_status(the_corgi_lcd->bl_dev);
  354. }
  355. EXPORT_SYMBOL(corgi_lcd_limit_intensity);
  356. static const struct backlight_ops corgi_bl_ops = {
  357. .get_brightness = corgi_bl_get_intensity,
  358. .update_status = corgi_bl_update_status,
  359. };
  360. #ifdef CONFIG_PM_SLEEP
  361. static int corgi_lcd_suspend(struct device *dev)
  362. {
  363. struct corgi_lcd *lcd = dev_get_drvdata(dev);
  364. corgibl_flags |= CORGIBL_SUSPENDED;
  365. corgi_bl_set_intensity(lcd, 0);
  366. corgi_lcd_set_power(lcd->lcd_dev, FB_BLANK_POWERDOWN);
  367. return 0;
  368. }
  369. static int corgi_lcd_resume(struct device *dev)
  370. {
  371. struct corgi_lcd *lcd = dev_get_drvdata(dev);
  372. corgibl_flags &= ~CORGIBL_SUSPENDED;
  373. corgi_lcd_set_power(lcd->lcd_dev, FB_BLANK_UNBLANK);
  374. backlight_update_status(lcd->bl_dev);
  375. return 0;
  376. }
  377. #endif
  378. static SIMPLE_DEV_PM_OPS(corgi_lcd_pm_ops, corgi_lcd_suspend, corgi_lcd_resume);
  379. static int setup_gpio_backlight(struct corgi_lcd *lcd,
  380. struct corgi_lcd_platform_data *pdata)
  381. {
  382. struct spi_device *spi = lcd->spi_dev;
  383. lcd->backlight_on = devm_gpiod_get_optional(&spi->dev,
  384. "BL_ON", GPIOD_OUT_LOW);
  385. if (IS_ERR(lcd->backlight_on))
  386. return PTR_ERR(lcd->backlight_on);
  387. lcd->backlight_cont = devm_gpiod_get_optional(&spi->dev, "BL_CONT",
  388. GPIOD_OUT_LOW);
  389. if (IS_ERR(lcd->backlight_cont))
  390. return PTR_ERR(lcd->backlight_cont);
  391. return 0;
  392. }
  393. static int corgi_lcd_probe(struct spi_device *spi)
  394. {
  395. struct backlight_properties props;
  396. struct corgi_lcd_platform_data *pdata = dev_get_platdata(&spi->dev);
  397. struct corgi_lcd *lcd;
  398. int ret = 0;
  399. if (pdata == NULL) {
  400. dev_err(&spi->dev, "platform data not available\n");
  401. return -EINVAL;
  402. }
  403. lcd = devm_kzalloc(&spi->dev, sizeof(struct corgi_lcd), GFP_KERNEL);
  404. if (!lcd)
  405. return -ENOMEM;
  406. lcd->spi_dev = spi;
  407. lcd->lcd_dev = devm_lcd_device_register(&spi->dev, "corgi_lcd",
  408. &spi->dev, lcd, &corgi_lcd_ops);
  409. if (IS_ERR(lcd->lcd_dev))
  410. return PTR_ERR(lcd->lcd_dev);
  411. lcd->power = FB_BLANK_POWERDOWN;
  412. lcd->mode = (pdata) ? pdata->init_mode : CORGI_LCD_MODE_VGA;
  413. memset(&props, 0, sizeof(struct backlight_properties));
  414. props.type = BACKLIGHT_RAW;
  415. props.max_brightness = pdata->max_intensity;
  416. lcd->bl_dev = devm_backlight_device_register(&spi->dev, "corgi_bl",
  417. &spi->dev, lcd, &corgi_bl_ops,
  418. &props);
  419. if (IS_ERR(lcd->bl_dev))
  420. return PTR_ERR(lcd->bl_dev);
  421. lcd->bl_dev->props.brightness = pdata->default_intensity;
  422. lcd->bl_dev->props.power = FB_BLANK_UNBLANK;
  423. ret = setup_gpio_backlight(lcd, pdata);
  424. if (ret)
  425. return ret;
  426. lcd->kick_battery = pdata->kick_battery;
  427. spi_set_drvdata(spi, lcd);
  428. corgi_lcd_set_power(lcd->lcd_dev, FB_BLANK_UNBLANK);
  429. backlight_update_status(lcd->bl_dev);
  430. lcd->limit_mask = pdata->limit_mask;
  431. the_corgi_lcd = lcd;
  432. return 0;
  433. }
  434. static int corgi_lcd_remove(struct spi_device *spi)
  435. {
  436. struct corgi_lcd *lcd = spi_get_drvdata(spi);
  437. lcd->bl_dev->props.power = FB_BLANK_UNBLANK;
  438. lcd->bl_dev->props.brightness = 0;
  439. backlight_update_status(lcd->bl_dev);
  440. corgi_lcd_set_power(lcd->lcd_dev, FB_BLANK_POWERDOWN);
  441. return 0;
  442. }
  443. static struct spi_driver corgi_lcd_driver = {
  444. .driver = {
  445. .name = "corgi-lcd",
  446. .pm = &corgi_lcd_pm_ops,
  447. },
  448. .probe = corgi_lcd_probe,
  449. .remove = corgi_lcd_remove,
  450. };
  451. module_spi_driver(corgi_lcd_driver);
  452. MODULE_DESCRIPTION("LCD and backlight driver for SHARP C7x0/Cxx00");
  453. MODULE_AUTHOR("Eric Miao <eric.miao@marvell.com>");
  454. MODULE_LICENSE("GPL");
  455. MODULE_ALIAS("spi:corgi-lcd");