broadsheetfb.c 28 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226
  1. /*
  2. * broadsheetfb.c -- FB driver for E-Ink Broadsheet controller
  3. *
  4. * Copyright (C) 2008, Jaya Kumar
  5. *
  6. * This file is subject to the terms and conditions of the GNU General Public
  7. * License. See the file COPYING in the main directory of this archive for
  8. * more details.
  9. *
  10. * Layout is based on skeletonfb.c by James Simmons and Geert Uytterhoeven.
  11. *
  12. * This driver is written to be used with the Broadsheet display controller.
  13. *
  14. * It is intended to be architecture independent. A board specific driver
  15. * must be used to perform all the physical IO interactions.
  16. *
  17. */
  18. #include <linux/module.h>
  19. #include <linux/kernel.h>
  20. #include <linux/errno.h>
  21. #include <linux/string.h>
  22. #include <linux/mm.h>
  23. #include <linux/slab.h>
  24. #include <linux/vmalloc.h>
  25. #include <linux/delay.h>
  26. #include <linux/interrupt.h>
  27. #include <linux/fb.h>
  28. #include <linux/init.h>
  29. #include <linux/platform_device.h>
  30. #include <linux/list.h>
  31. #include <linux/firmware.h>
  32. #include <linux/uaccess.h>
  33. #include <video/broadsheetfb.h>
  34. /* track panel specific parameters */
  35. struct panel_info {
  36. int w;
  37. int h;
  38. u16 sdcfg;
  39. u16 gdcfg;
  40. u16 lutfmt;
  41. u16 fsynclen;
  42. u16 fendfbegin;
  43. u16 lsynclen;
  44. u16 lendlbegin;
  45. u16 pixclk;
  46. };
  47. /* table of panel specific parameters to be indexed into by the board drivers */
  48. static struct panel_info panel_table[] = {
  49. { /* standard 6" on TFT backplane */
  50. .w = 800,
  51. .h = 600,
  52. .sdcfg = (100 | (1 << 8) | (1 << 9)),
  53. .gdcfg = 2,
  54. .lutfmt = (4 | (1 << 7)),
  55. .fsynclen = 4,
  56. .fendfbegin = (10 << 8) | 4,
  57. .lsynclen = 10,
  58. .lendlbegin = (100 << 8) | 4,
  59. .pixclk = 6,
  60. },
  61. { /* custom 3.7" flexible on PET or steel */
  62. .w = 320,
  63. .h = 240,
  64. .sdcfg = (67 | (0 << 8) | (0 << 9) | (0 << 10) | (0 << 12)),
  65. .gdcfg = 3,
  66. .lutfmt = (4 | (1 << 7)),
  67. .fsynclen = 0,
  68. .fendfbegin = (80 << 8) | 4,
  69. .lsynclen = 10,
  70. .lendlbegin = (80 << 8) | 20,
  71. .pixclk = 14,
  72. },
  73. { /* standard 9.7" on TFT backplane */
  74. .w = 1200,
  75. .h = 825,
  76. .sdcfg = (100 | (1 << 8) | (1 << 9) | (0 << 10) | (0 << 12)),
  77. .gdcfg = 2,
  78. .lutfmt = (4 | (1 << 7)),
  79. .fsynclen = 0,
  80. .fendfbegin = (4 << 8) | 4,
  81. .lsynclen = 4,
  82. .lendlbegin = (60 << 8) | 10,
  83. .pixclk = 3,
  84. },
  85. };
  86. #define DPY_W 800
  87. #define DPY_H 600
  88. static struct fb_fix_screeninfo broadsheetfb_fix = {
  89. .id = "broadsheetfb",
  90. .type = FB_TYPE_PACKED_PIXELS,
  91. .visual = FB_VISUAL_STATIC_PSEUDOCOLOR,
  92. .xpanstep = 0,
  93. .ypanstep = 0,
  94. .ywrapstep = 0,
  95. .line_length = DPY_W,
  96. .accel = FB_ACCEL_NONE,
  97. };
  98. static struct fb_var_screeninfo broadsheetfb_var = {
  99. .xres = DPY_W,
  100. .yres = DPY_H,
  101. .xres_virtual = DPY_W,
  102. .yres_virtual = DPY_H,
  103. .bits_per_pixel = 8,
  104. .grayscale = 1,
  105. .red = { 0, 4, 0 },
  106. .green = { 0, 4, 0 },
  107. .blue = { 0, 4, 0 },
  108. .transp = { 0, 0, 0 },
  109. };
  110. /* main broadsheetfb functions */
  111. static void broadsheet_gpio_issue_data(struct broadsheetfb_par *par, u16 data)
  112. {
  113. par->board->set_ctl(par, BS_WR, 0);
  114. par->board->set_hdb(par, data);
  115. par->board->set_ctl(par, BS_WR, 1);
  116. }
  117. static void broadsheet_gpio_issue_cmd(struct broadsheetfb_par *par, u16 data)
  118. {
  119. par->board->set_ctl(par, BS_DC, 0);
  120. broadsheet_gpio_issue_data(par, data);
  121. }
  122. static void broadsheet_gpio_send_command(struct broadsheetfb_par *par, u16 data)
  123. {
  124. par->board->wait_for_rdy(par);
  125. par->board->set_ctl(par, BS_CS, 0);
  126. broadsheet_gpio_issue_cmd(par, data);
  127. par->board->set_ctl(par, BS_DC, 1);
  128. par->board->set_ctl(par, BS_CS, 1);
  129. }
  130. static void broadsheet_gpio_send_cmdargs(struct broadsheetfb_par *par, u16 cmd,
  131. int argc, u16 *argv)
  132. {
  133. int i;
  134. par->board->wait_for_rdy(par);
  135. par->board->set_ctl(par, BS_CS, 0);
  136. broadsheet_gpio_issue_cmd(par, cmd);
  137. par->board->set_ctl(par, BS_DC, 1);
  138. for (i = 0; i < argc; i++)
  139. broadsheet_gpio_issue_data(par, argv[i]);
  140. par->board->set_ctl(par, BS_CS, 1);
  141. }
  142. static void broadsheet_mmio_send_cmdargs(struct broadsheetfb_par *par, u16 cmd,
  143. int argc, u16 *argv)
  144. {
  145. int i;
  146. par->board->mmio_write(par, BS_MMIO_CMD, cmd);
  147. for (i = 0; i < argc; i++)
  148. par->board->mmio_write(par, BS_MMIO_DATA, argv[i]);
  149. }
  150. static void broadsheet_send_command(struct broadsheetfb_par *par, u16 data)
  151. {
  152. if (par->board->mmio_write)
  153. par->board->mmio_write(par, BS_MMIO_CMD, data);
  154. else
  155. broadsheet_gpio_send_command(par, data);
  156. }
  157. static void broadsheet_send_cmdargs(struct broadsheetfb_par *par, u16 cmd,
  158. int argc, u16 *argv)
  159. {
  160. if (par->board->mmio_write)
  161. broadsheet_mmio_send_cmdargs(par, cmd, argc, argv);
  162. else
  163. broadsheet_gpio_send_cmdargs(par, cmd, argc, argv);
  164. }
  165. static void broadsheet_gpio_burst_write(struct broadsheetfb_par *par, int size,
  166. u16 *data)
  167. {
  168. int i;
  169. u16 tmp;
  170. par->board->set_ctl(par, BS_CS, 0);
  171. par->board->set_ctl(par, BS_DC, 1);
  172. for (i = 0; i < size; i++) {
  173. par->board->set_ctl(par, BS_WR, 0);
  174. tmp = (data[i] & 0x0F) << 4;
  175. tmp |= (data[i] & 0x0F00) << 4;
  176. par->board->set_hdb(par, tmp);
  177. par->board->set_ctl(par, BS_WR, 1);
  178. }
  179. par->board->set_ctl(par, BS_CS, 1);
  180. }
  181. static void broadsheet_mmio_burst_write(struct broadsheetfb_par *par, int size,
  182. u16 *data)
  183. {
  184. int i;
  185. u16 tmp;
  186. for (i = 0; i < size; i++) {
  187. tmp = (data[i] & 0x0F) << 4;
  188. tmp |= (data[i] & 0x0F00) << 4;
  189. par->board->mmio_write(par, BS_MMIO_DATA, tmp);
  190. }
  191. }
  192. static void broadsheet_burst_write(struct broadsheetfb_par *par, int size,
  193. u16 *data)
  194. {
  195. if (par->board->mmio_write)
  196. broadsheet_mmio_burst_write(par, size, data);
  197. else
  198. broadsheet_gpio_burst_write(par, size, data);
  199. }
  200. static u16 broadsheet_gpio_get_data(struct broadsheetfb_par *par)
  201. {
  202. u16 res;
  203. /* wait for ready to go hi. (lo is busy) */
  204. par->board->wait_for_rdy(par);
  205. /* cs lo, dc lo for cmd, we lo for each data, db as usual */
  206. par->board->set_ctl(par, BS_DC, 1);
  207. par->board->set_ctl(par, BS_CS, 0);
  208. par->board->set_ctl(par, BS_WR, 0);
  209. res = par->board->get_hdb(par);
  210. /* strobe wr */
  211. par->board->set_ctl(par, BS_WR, 1);
  212. par->board->set_ctl(par, BS_CS, 1);
  213. return res;
  214. }
  215. static u16 broadsheet_get_data(struct broadsheetfb_par *par)
  216. {
  217. if (par->board->mmio_read)
  218. return par->board->mmio_read(par);
  219. else
  220. return broadsheet_gpio_get_data(par);
  221. }
  222. static void broadsheet_gpio_write_reg(struct broadsheetfb_par *par, u16 reg,
  223. u16 data)
  224. {
  225. /* wait for ready to go hi. (lo is busy) */
  226. par->board->wait_for_rdy(par);
  227. /* cs lo, dc lo for cmd, we lo for each data, db as usual */
  228. par->board->set_ctl(par, BS_CS, 0);
  229. broadsheet_gpio_issue_cmd(par, BS_CMD_WR_REG);
  230. par->board->set_ctl(par, BS_DC, 1);
  231. broadsheet_gpio_issue_data(par, reg);
  232. broadsheet_gpio_issue_data(par, data);
  233. par->board->set_ctl(par, BS_CS, 1);
  234. }
  235. static void broadsheet_mmio_write_reg(struct broadsheetfb_par *par, u16 reg,
  236. u16 data)
  237. {
  238. par->board->mmio_write(par, BS_MMIO_CMD, BS_CMD_WR_REG);
  239. par->board->mmio_write(par, BS_MMIO_DATA, reg);
  240. par->board->mmio_write(par, BS_MMIO_DATA, data);
  241. }
  242. static void broadsheet_write_reg(struct broadsheetfb_par *par, u16 reg,
  243. u16 data)
  244. {
  245. if (par->board->mmio_write)
  246. broadsheet_mmio_write_reg(par, reg, data);
  247. else
  248. broadsheet_gpio_write_reg(par, reg, data);
  249. }
  250. static void broadsheet_write_reg32(struct broadsheetfb_par *par, u16 reg,
  251. u32 data)
  252. {
  253. broadsheet_write_reg(par, reg, cpu_to_le32(data) & 0xFFFF);
  254. broadsheet_write_reg(par, reg + 2, (cpu_to_le32(data) >> 16) & 0xFFFF);
  255. }
  256. static u16 broadsheet_read_reg(struct broadsheetfb_par *par, u16 reg)
  257. {
  258. broadsheet_send_cmdargs(par, BS_CMD_RD_REG, 1, &reg);
  259. par->board->wait_for_rdy(par);
  260. return broadsheet_get_data(par);
  261. }
  262. /* functions for waveform manipulation */
  263. static int is_broadsheet_pll_locked(struct broadsheetfb_par *par)
  264. {
  265. return broadsheet_read_reg(par, 0x000A) & 0x0001;
  266. }
  267. static int broadsheet_setup_plls(struct broadsheetfb_par *par)
  268. {
  269. int retry_count = 0;
  270. u16 tmp;
  271. /* disable arral saemipu mode */
  272. broadsheet_write_reg(par, 0x0006, 0x0000);
  273. broadsheet_write_reg(par, 0x0010, 0x0004);
  274. broadsheet_write_reg(par, 0x0012, 0x5949);
  275. broadsheet_write_reg(par, 0x0014, 0x0040);
  276. broadsheet_write_reg(par, 0x0016, 0x0000);
  277. do {
  278. if (retry_count++ > 100)
  279. return -ETIMEDOUT;
  280. mdelay(1);
  281. } while (!is_broadsheet_pll_locked(par));
  282. tmp = broadsheet_read_reg(par, 0x0006);
  283. tmp &= ~0x1;
  284. broadsheet_write_reg(par, 0x0006, tmp);
  285. return 0;
  286. }
  287. static int broadsheet_setup_spi(struct broadsheetfb_par *par)
  288. {
  289. broadsheet_write_reg(par, 0x0204, ((3 << 3) | 1));
  290. broadsheet_write_reg(par, 0x0208, 0x0001);
  291. return 0;
  292. }
  293. static int broadsheet_setup_spiflash(struct broadsheetfb_par *par,
  294. u16 *orig_sfmcd)
  295. {
  296. *orig_sfmcd = broadsheet_read_reg(par, 0x0204);
  297. broadsheet_write_reg(par, 0x0208, 0);
  298. broadsheet_write_reg(par, 0x0204, 0);
  299. broadsheet_write_reg(par, 0x0204, ((3 << 3) | 1));
  300. return 0;
  301. }
  302. static int broadsheet_spiflash_wait_for_bit(struct broadsheetfb_par *par,
  303. u16 reg, int bitnum, int val,
  304. int timeout)
  305. {
  306. u16 tmp;
  307. do {
  308. tmp = broadsheet_read_reg(par, reg);
  309. if (((tmp >> bitnum) & 1) == val)
  310. return 0;
  311. mdelay(1);
  312. } while (timeout--);
  313. return -ETIMEDOUT;
  314. }
  315. static int broadsheet_spiflash_write_byte(struct broadsheetfb_par *par, u8 data)
  316. {
  317. broadsheet_write_reg(par, 0x0202, (data | 0x100));
  318. return broadsheet_spiflash_wait_for_bit(par, 0x0206, 3, 0, 100);
  319. }
  320. static int broadsheet_spiflash_read_byte(struct broadsheetfb_par *par, u8 *data)
  321. {
  322. int err;
  323. u16 tmp;
  324. broadsheet_write_reg(par, 0x0202, 0);
  325. err = broadsheet_spiflash_wait_for_bit(par, 0x0206, 3, 0, 100);
  326. if (err)
  327. return err;
  328. tmp = broadsheet_read_reg(par, 0x200);
  329. *data = tmp & 0xFF;
  330. return 0;
  331. }
  332. static int broadsheet_spiflash_wait_for_status(struct broadsheetfb_par *par,
  333. int timeout)
  334. {
  335. u8 tmp;
  336. int err;
  337. do {
  338. broadsheet_write_reg(par, 0x0208, 1);
  339. err = broadsheet_spiflash_write_byte(par, 0x05);
  340. if (err)
  341. goto failout;
  342. err = broadsheet_spiflash_read_byte(par, &tmp);
  343. if (err)
  344. goto failout;
  345. broadsheet_write_reg(par, 0x0208, 0);
  346. if (!(tmp & 0x1))
  347. return 0;
  348. mdelay(5);
  349. } while (timeout--);
  350. dev_err(par->info->device, "Timed out waiting for spiflash status\n");
  351. return -ETIMEDOUT;
  352. failout:
  353. broadsheet_write_reg(par, 0x0208, 0);
  354. return err;
  355. }
  356. static int broadsheet_spiflash_op_on_address(struct broadsheetfb_par *par,
  357. u8 op, u32 addr)
  358. {
  359. int i;
  360. u8 tmp;
  361. int err;
  362. broadsheet_write_reg(par, 0x0208, 1);
  363. err = broadsheet_spiflash_write_byte(par, op);
  364. if (err)
  365. return err;
  366. for (i = 2; i >= 0; i--) {
  367. tmp = ((addr >> (i * 8)) & 0xFF);
  368. err = broadsheet_spiflash_write_byte(par, tmp);
  369. if (err)
  370. return err;
  371. }
  372. return err;
  373. }
  374. static int broadsheet_verify_spiflash(struct broadsheetfb_par *par,
  375. int *flash_type)
  376. {
  377. int err = 0;
  378. u8 sig;
  379. err = broadsheet_spiflash_op_on_address(par, 0xAB, 0x00000000);
  380. if (err)
  381. goto failout;
  382. err = broadsheet_spiflash_read_byte(par, &sig);
  383. if (err)
  384. goto failout;
  385. if ((sig != 0x10) && (sig != 0x11)) {
  386. dev_err(par->info->device, "Unexpected flash type\n");
  387. err = -EINVAL;
  388. goto failout;
  389. }
  390. *flash_type = sig;
  391. failout:
  392. broadsheet_write_reg(par, 0x0208, 0);
  393. return err;
  394. }
  395. static int broadsheet_setup_for_wfm_write(struct broadsheetfb_par *par,
  396. u16 *initial_sfmcd, int *flash_type)
  397. {
  398. int err;
  399. err = broadsheet_setup_plls(par);
  400. if (err)
  401. return err;
  402. broadsheet_write_reg(par, 0x0106, 0x0203);
  403. err = broadsheet_setup_spi(par);
  404. if (err)
  405. return err;
  406. err = broadsheet_setup_spiflash(par, initial_sfmcd);
  407. if (err)
  408. return err;
  409. return broadsheet_verify_spiflash(par, flash_type);
  410. }
  411. static int broadsheet_spiflash_write_control(struct broadsheetfb_par *par,
  412. int mode)
  413. {
  414. int err;
  415. broadsheet_write_reg(par, 0x0208, 1);
  416. if (mode)
  417. err = broadsheet_spiflash_write_byte(par, 0x06);
  418. else
  419. err = broadsheet_spiflash_write_byte(par, 0x04);
  420. broadsheet_write_reg(par, 0x0208, 0);
  421. return err;
  422. }
  423. static int broadsheet_spiflash_erase_sector(struct broadsheetfb_par *par,
  424. int addr)
  425. {
  426. int err;
  427. broadsheet_spiflash_write_control(par, 1);
  428. err = broadsheet_spiflash_op_on_address(par, 0xD8, addr);
  429. broadsheet_write_reg(par, 0x0208, 0);
  430. if (err)
  431. return err;
  432. err = broadsheet_spiflash_wait_for_status(par, 1000);
  433. return err;
  434. }
  435. static int broadsheet_spiflash_read_range(struct broadsheetfb_par *par,
  436. int addr, int size, char *data)
  437. {
  438. int err;
  439. int i;
  440. err = broadsheet_spiflash_op_on_address(par, 0x03, addr);
  441. if (err)
  442. goto failout;
  443. for (i = 0; i < size; i++) {
  444. err = broadsheet_spiflash_read_byte(par, &data[i]);
  445. if (err)
  446. goto failout;
  447. }
  448. failout:
  449. broadsheet_write_reg(par, 0x0208, 0);
  450. return err;
  451. }
  452. #define BS_SPIFLASH_PAGE_SIZE 256
  453. static int broadsheet_spiflash_write_page(struct broadsheetfb_par *par,
  454. int addr, const char *data)
  455. {
  456. int err;
  457. int i;
  458. broadsheet_spiflash_write_control(par, 1);
  459. err = broadsheet_spiflash_op_on_address(par, 0x02, addr);
  460. if (err)
  461. goto failout;
  462. for (i = 0; i < BS_SPIFLASH_PAGE_SIZE; i++) {
  463. err = broadsheet_spiflash_write_byte(par, data[i]);
  464. if (err)
  465. goto failout;
  466. }
  467. broadsheet_write_reg(par, 0x0208, 0);
  468. err = broadsheet_spiflash_wait_for_status(par, 100);
  469. failout:
  470. return err;
  471. }
  472. static int broadsheet_spiflash_write_sector(struct broadsheetfb_par *par,
  473. int addr, const char *data, int sector_size)
  474. {
  475. int i;
  476. int err;
  477. for (i = 0; i < sector_size; i += BS_SPIFLASH_PAGE_SIZE) {
  478. err = broadsheet_spiflash_write_page(par, addr + i, &data[i]);
  479. if (err)
  480. return err;
  481. }
  482. return 0;
  483. }
  484. /*
  485. * The caller must guarantee that the data to be rewritten is entirely
  486. * contained within this sector. That is, data_start_addr + data_len
  487. * must be less than sector_start_addr + sector_size.
  488. */
  489. static int broadsheet_spiflash_rewrite_sector(struct broadsheetfb_par *par,
  490. int sector_size, int data_start_addr,
  491. int data_len, const char *data)
  492. {
  493. int err;
  494. char *sector_buffer;
  495. int tail_start_addr;
  496. int start_sector_addr;
  497. sector_buffer = kzalloc(sector_size, GFP_KERNEL);
  498. if (!sector_buffer)
  499. return -ENOMEM;
  500. /* the start address of the sector is the 0th byte of that sector */
  501. start_sector_addr = (data_start_addr / sector_size) * sector_size;
  502. /*
  503. * check if there is head data that we need to readback into our sector
  504. * buffer first
  505. */
  506. if (data_start_addr != start_sector_addr) {
  507. /*
  508. * we need to read every byte up till the start address of our
  509. * data and we put it into our sector buffer.
  510. */
  511. err = broadsheet_spiflash_read_range(par, start_sector_addr,
  512. data_start_addr, sector_buffer);
  513. if (err)
  514. goto out;
  515. }
  516. /* now we copy our data into the right place in the sector buffer */
  517. memcpy(sector_buffer + data_start_addr, data, data_len);
  518. /*
  519. * now we check if there is a tail section of the sector that we need to
  520. * readback.
  521. */
  522. tail_start_addr = (data_start_addr + data_len) % sector_size;
  523. if (tail_start_addr) {
  524. int tail_len;
  525. tail_len = sector_size - tail_start_addr;
  526. /* now we read this tail into our sector buffer */
  527. err = broadsheet_spiflash_read_range(par, tail_start_addr,
  528. tail_len, sector_buffer + tail_start_addr);
  529. if (err)
  530. goto out;
  531. }
  532. /* if we got here we have the full sector that we want to rewrite. */
  533. /* first erase the sector */
  534. err = broadsheet_spiflash_erase_sector(par, start_sector_addr);
  535. if (err)
  536. goto out;
  537. /* now write it */
  538. err = broadsheet_spiflash_write_sector(par, start_sector_addr,
  539. sector_buffer, sector_size);
  540. out:
  541. kfree(sector_buffer);
  542. return err;
  543. }
  544. static int broadsheet_write_spiflash(struct broadsheetfb_par *par, u32 wfm_addr,
  545. const u8 *wfm, int bytecount, int flash_type)
  546. {
  547. int sector_size;
  548. int err;
  549. int cur_addr;
  550. int writecount;
  551. int maxlen;
  552. int offset = 0;
  553. switch (flash_type) {
  554. case 0x10:
  555. sector_size = 32*1024;
  556. break;
  557. case 0x11:
  558. default:
  559. sector_size = 64*1024;
  560. break;
  561. }
  562. while (bytecount) {
  563. cur_addr = wfm_addr + offset;
  564. maxlen = roundup(cur_addr, sector_size) - cur_addr;
  565. writecount = min(bytecount, maxlen);
  566. err = broadsheet_spiflash_rewrite_sector(par, sector_size,
  567. cur_addr, writecount, wfm + offset);
  568. if (err)
  569. return err;
  570. offset += writecount;
  571. bytecount -= writecount;
  572. }
  573. return 0;
  574. }
  575. static int broadsheet_store_waveform_to_spiflash(struct broadsheetfb_par *par,
  576. const u8 *wfm, size_t wfm_size)
  577. {
  578. int err = 0;
  579. u16 initial_sfmcd = 0;
  580. int flash_type = 0;
  581. err = broadsheet_setup_for_wfm_write(par, &initial_sfmcd, &flash_type);
  582. if (err)
  583. goto failout;
  584. err = broadsheet_write_spiflash(par, 0x886, wfm, wfm_size, flash_type);
  585. failout:
  586. broadsheet_write_reg(par, 0x0204, initial_sfmcd);
  587. return err;
  588. }
  589. static ssize_t broadsheet_loadstore_waveform(struct device *dev,
  590. struct device_attribute *attr,
  591. const char *buf, size_t len)
  592. {
  593. int err;
  594. struct fb_info *info = dev_get_drvdata(dev);
  595. struct broadsheetfb_par *par = info->par;
  596. const struct firmware *fw_entry;
  597. if (len < 1)
  598. return -EINVAL;
  599. err = request_firmware(&fw_entry, "broadsheet.wbf", dev);
  600. if (err < 0) {
  601. dev_err(dev, "Failed to get broadsheet waveform\n");
  602. goto err_failed;
  603. }
  604. /* try to enforce reasonable min max on waveform */
  605. if ((fw_entry->size < 8*1024) || (fw_entry->size > 64*1024)) {
  606. dev_err(dev, "Invalid waveform\n");
  607. err = -EINVAL;
  608. goto err_fw;
  609. }
  610. mutex_lock(&(par->io_lock));
  611. err = broadsheet_store_waveform_to_spiflash(par, fw_entry->data,
  612. fw_entry->size);
  613. mutex_unlock(&(par->io_lock));
  614. if (err < 0) {
  615. dev_err(dev, "Failed to store broadsheet waveform\n");
  616. goto err_fw;
  617. }
  618. dev_info(dev, "Stored broadsheet waveform, size %zd\n", fw_entry->size);
  619. err = len;
  620. err_fw:
  621. release_firmware(fw_entry);
  622. err_failed:
  623. return err;
  624. }
  625. static DEVICE_ATTR(loadstore_waveform, S_IWUSR, NULL,
  626. broadsheet_loadstore_waveform);
  627. /* upper level functions that manipulate the display and other stuff */
  628. static void broadsheet_init_display(struct broadsheetfb_par *par)
  629. {
  630. u16 args[5];
  631. int xres = par->info->var.xres;
  632. int yres = par->info->var.yres;
  633. args[0] = panel_table[par->panel_index].w;
  634. args[1] = panel_table[par->panel_index].h;
  635. args[2] = panel_table[par->panel_index].sdcfg;
  636. args[3] = panel_table[par->panel_index].gdcfg;
  637. args[4] = panel_table[par->panel_index].lutfmt;
  638. broadsheet_send_cmdargs(par, BS_CMD_INIT_DSPE_CFG, 5, args);
  639. /* did the controller really set it? */
  640. broadsheet_send_cmdargs(par, BS_CMD_INIT_DSPE_CFG, 5, args);
  641. args[0] = panel_table[par->panel_index].fsynclen;
  642. args[1] = panel_table[par->panel_index].fendfbegin;
  643. args[2] = panel_table[par->panel_index].lsynclen;
  644. args[3] = panel_table[par->panel_index].lendlbegin;
  645. args[4] = panel_table[par->panel_index].pixclk;
  646. broadsheet_send_cmdargs(par, BS_CMD_INIT_DSPE_TMG, 5, args);
  647. broadsheet_write_reg32(par, 0x310, xres*yres*2);
  648. /* setup waveform */
  649. args[0] = 0x886;
  650. args[1] = 0;
  651. broadsheet_send_cmdargs(par, BS_CMD_RD_WFM_INFO, 2, args);
  652. broadsheet_send_command(par, BS_CMD_UPD_GDRV_CLR);
  653. broadsheet_send_command(par, BS_CMD_WAIT_DSPE_TRG);
  654. broadsheet_write_reg(par, 0x330, 0x84);
  655. broadsheet_send_command(par, BS_CMD_WAIT_DSPE_TRG);
  656. args[0] = (0x3 << 4);
  657. broadsheet_send_cmdargs(par, BS_CMD_LD_IMG, 1, args);
  658. args[0] = 0x154;
  659. broadsheet_send_cmdargs(par, BS_CMD_WR_REG, 1, args);
  660. broadsheet_burst_write(par, (panel_table[par->panel_index].w *
  661. panel_table[par->panel_index].h)/2,
  662. (u16 *) par->info->screen_base);
  663. broadsheet_send_command(par, BS_CMD_LD_IMG_END);
  664. args[0] = 0x4300;
  665. broadsheet_send_cmdargs(par, BS_CMD_UPD_FULL, 1, args);
  666. broadsheet_send_command(par, BS_CMD_WAIT_DSPE_TRG);
  667. broadsheet_send_command(par, BS_CMD_WAIT_DSPE_FREND);
  668. par->board->wait_for_rdy(par);
  669. }
  670. static void broadsheet_identify(struct broadsheetfb_par *par)
  671. {
  672. u16 rev, prc;
  673. struct device *dev = par->info->device;
  674. rev = broadsheet_read_reg(par, BS_REG_REV);
  675. prc = broadsheet_read_reg(par, BS_REG_PRC);
  676. dev_info(dev, "Broadsheet Rev 0x%x, Product Code 0x%x\n", rev, prc);
  677. if (prc != 0x0047)
  678. dev_warn(dev, "Unrecognized Broadsheet Product Code\n");
  679. if (rev != 0x0100)
  680. dev_warn(dev, "Unrecognized Broadsheet Revision\n");
  681. }
  682. static void broadsheet_init(struct broadsheetfb_par *par)
  683. {
  684. broadsheet_send_command(par, BS_CMD_INIT_SYS_RUN);
  685. /* the controller needs a second */
  686. msleep(1000);
  687. broadsheet_init_display(par);
  688. }
  689. static void broadsheetfb_dpy_update_pages(struct broadsheetfb_par *par,
  690. u16 y1, u16 y2)
  691. {
  692. u16 args[5];
  693. unsigned char *buf = (unsigned char *)par->info->screen_base;
  694. mutex_lock(&(par->io_lock));
  695. /* y1 must be a multiple of 4 so drop the lower bits */
  696. y1 &= 0xFFFC;
  697. /* y2 must be a multiple of 4 , but - 1 so up the lower bits */
  698. y2 |= 0x0003;
  699. args[0] = 0x3 << 4;
  700. args[1] = 0;
  701. args[2] = y1;
  702. args[3] = cpu_to_le16(par->info->var.xres);
  703. args[4] = y2;
  704. broadsheet_send_cmdargs(par, BS_CMD_LD_IMG_AREA, 5, args);
  705. args[0] = 0x154;
  706. broadsheet_send_cmdargs(par, BS_CMD_WR_REG, 1, args);
  707. buf += y1 * par->info->var.xres;
  708. broadsheet_burst_write(par, ((1 + y2 - y1) * par->info->var.xres)/2,
  709. (u16 *) buf);
  710. broadsheet_send_command(par, BS_CMD_LD_IMG_END);
  711. args[0] = 0x4300;
  712. broadsheet_send_cmdargs(par, BS_CMD_UPD_FULL, 1, args);
  713. broadsheet_send_command(par, BS_CMD_WAIT_DSPE_TRG);
  714. broadsheet_send_command(par, BS_CMD_WAIT_DSPE_FREND);
  715. par->board->wait_for_rdy(par);
  716. mutex_unlock(&(par->io_lock));
  717. }
  718. static void broadsheetfb_dpy_update(struct broadsheetfb_par *par)
  719. {
  720. u16 args[5];
  721. mutex_lock(&(par->io_lock));
  722. args[0] = 0x3 << 4;
  723. broadsheet_send_cmdargs(par, BS_CMD_LD_IMG, 1, args);
  724. args[0] = 0x154;
  725. broadsheet_send_cmdargs(par, BS_CMD_WR_REG, 1, args);
  726. broadsheet_burst_write(par, (panel_table[par->panel_index].w *
  727. panel_table[par->panel_index].h)/2,
  728. (u16 *) par->info->screen_base);
  729. broadsheet_send_command(par, BS_CMD_LD_IMG_END);
  730. args[0] = 0x4300;
  731. broadsheet_send_cmdargs(par, BS_CMD_UPD_FULL, 1, args);
  732. broadsheet_send_command(par, BS_CMD_WAIT_DSPE_TRG);
  733. broadsheet_send_command(par, BS_CMD_WAIT_DSPE_FREND);
  734. par->board->wait_for_rdy(par);
  735. mutex_unlock(&(par->io_lock));
  736. }
  737. /* this is called back from the deferred io workqueue */
  738. static void broadsheetfb_dpy_deferred_io(struct fb_info *info,
  739. struct list_head *pagelist)
  740. {
  741. u16 y1 = 0, h = 0;
  742. int prev_index = -1;
  743. struct page *cur;
  744. struct fb_deferred_io *fbdefio = info->fbdefio;
  745. int h_inc;
  746. u16 yres = info->var.yres;
  747. u16 xres = info->var.xres;
  748. /* height increment is fixed per page */
  749. h_inc = DIV_ROUND_UP(PAGE_SIZE , xres);
  750. /* walk the written page list and swizzle the data */
  751. list_for_each_entry(cur, &fbdefio->pagelist, lru) {
  752. if (prev_index < 0) {
  753. /* just starting so assign first page */
  754. y1 = (cur->index << PAGE_SHIFT) / xres;
  755. h = h_inc;
  756. } else if ((prev_index + 1) == cur->index) {
  757. /* this page is consecutive so increase our height */
  758. h += h_inc;
  759. } else {
  760. /* page not consecutive, issue previous update first */
  761. broadsheetfb_dpy_update_pages(info->par, y1, y1 + h);
  762. /* start over with our non consecutive page */
  763. y1 = (cur->index << PAGE_SHIFT) / xres;
  764. h = h_inc;
  765. }
  766. prev_index = cur->index;
  767. }
  768. /* if we still have any pages to update we do so now */
  769. if (h >= yres) {
  770. /* its a full screen update, just do it */
  771. broadsheetfb_dpy_update(info->par);
  772. } else {
  773. broadsheetfb_dpy_update_pages(info->par, y1,
  774. min((u16) (y1 + h), yres));
  775. }
  776. }
  777. static void broadsheetfb_fillrect(struct fb_info *info,
  778. const struct fb_fillrect *rect)
  779. {
  780. struct broadsheetfb_par *par = info->par;
  781. sys_fillrect(info, rect);
  782. broadsheetfb_dpy_update(par);
  783. }
  784. static void broadsheetfb_copyarea(struct fb_info *info,
  785. const struct fb_copyarea *area)
  786. {
  787. struct broadsheetfb_par *par = info->par;
  788. sys_copyarea(info, area);
  789. broadsheetfb_dpy_update(par);
  790. }
  791. static void broadsheetfb_imageblit(struct fb_info *info,
  792. const struct fb_image *image)
  793. {
  794. struct broadsheetfb_par *par = info->par;
  795. sys_imageblit(info, image);
  796. broadsheetfb_dpy_update(par);
  797. }
  798. /*
  799. * this is the slow path from userspace. they can seek and write to
  800. * the fb. it's inefficient to do anything less than a full screen draw
  801. */
  802. static ssize_t broadsheetfb_write(struct fb_info *info, const char __user *buf,
  803. size_t count, loff_t *ppos)
  804. {
  805. struct broadsheetfb_par *par = info->par;
  806. unsigned long p = *ppos;
  807. void *dst;
  808. int err = 0;
  809. unsigned long total_size;
  810. if (info->state != FBINFO_STATE_RUNNING)
  811. return -EPERM;
  812. total_size = info->fix.smem_len;
  813. if (p > total_size)
  814. return -EFBIG;
  815. if (count > total_size) {
  816. err = -EFBIG;
  817. count = total_size;
  818. }
  819. if (count + p > total_size) {
  820. if (!err)
  821. err = -ENOSPC;
  822. count = total_size - p;
  823. }
  824. dst = (void *)(info->screen_base + p);
  825. if (copy_from_user(dst, buf, count))
  826. err = -EFAULT;
  827. if (!err)
  828. *ppos += count;
  829. broadsheetfb_dpy_update(par);
  830. return (err) ? err : count;
  831. }
  832. static const struct fb_ops broadsheetfb_ops = {
  833. .owner = THIS_MODULE,
  834. .fb_read = fb_sys_read,
  835. .fb_write = broadsheetfb_write,
  836. .fb_fillrect = broadsheetfb_fillrect,
  837. .fb_copyarea = broadsheetfb_copyarea,
  838. .fb_imageblit = broadsheetfb_imageblit,
  839. };
  840. static struct fb_deferred_io broadsheetfb_defio = {
  841. .delay = HZ/4,
  842. .deferred_io = broadsheetfb_dpy_deferred_io,
  843. };
  844. static int broadsheetfb_probe(struct platform_device *dev)
  845. {
  846. struct fb_info *info;
  847. struct broadsheet_board *board;
  848. int retval = -ENOMEM;
  849. int videomemorysize;
  850. unsigned char *videomemory;
  851. struct broadsheetfb_par *par;
  852. int i;
  853. int dpyw, dpyh;
  854. int panel_index;
  855. /* pick up board specific routines */
  856. board = dev->dev.platform_data;
  857. if (!board)
  858. return -EINVAL;
  859. /* try to count device specific driver, if can't, platform recalls */
  860. if (!try_module_get(board->owner))
  861. return -ENODEV;
  862. info = framebuffer_alloc(sizeof(struct broadsheetfb_par), &dev->dev);
  863. if (!info)
  864. goto err;
  865. switch (board->get_panel_type()) {
  866. case 37:
  867. panel_index = 1;
  868. break;
  869. case 97:
  870. panel_index = 2;
  871. break;
  872. case 6:
  873. default:
  874. panel_index = 0;
  875. break;
  876. }
  877. dpyw = panel_table[panel_index].w;
  878. dpyh = panel_table[panel_index].h;
  879. videomemorysize = roundup((dpyw*dpyh), PAGE_SIZE);
  880. videomemory = vzalloc(videomemorysize);
  881. if (!videomemory)
  882. goto err_fb_rel;
  883. info->screen_base = (char *)videomemory;
  884. info->fbops = &broadsheetfb_ops;
  885. broadsheetfb_var.xres = dpyw;
  886. broadsheetfb_var.yres = dpyh;
  887. broadsheetfb_var.xres_virtual = dpyw;
  888. broadsheetfb_var.yres_virtual = dpyh;
  889. info->var = broadsheetfb_var;
  890. broadsheetfb_fix.line_length = dpyw;
  891. info->fix = broadsheetfb_fix;
  892. info->fix.smem_len = videomemorysize;
  893. par = info->par;
  894. par->panel_index = panel_index;
  895. par->info = info;
  896. par->board = board;
  897. par->write_reg = broadsheet_write_reg;
  898. par->read_reg = broadsheet_read_reg;
  899. init_waitqueue_head(&par->waitq);
  900. mutex_init(&par->io_lock);
  901. info->flags = FBINFO_FLAG_DEFAULT | FBINFO_VIRTFB;
  902. info->fbdefio = &broadsheetfb_defio;
  903. fb_deferred_io_init(info);
  904. retval = fb_alloc_cmap(&info->cmap, 16, 0);
  905. if (retval < 0) {
  906. dev_err(&dev->dev, "Failed to allocate colormap\n");
  907. goto err_vfree;
  908. }
  909. /* set cmap */
  910. for (i = 0; i < 16; i++)
  911. info->cmap.red[i] = (((2*i)+1)*(0xFFFF))/32;
  912. memcpy(info->cmap.green, info->cmap.red, sizeof(u16)*16);
  913. memcpy(info->cmap.blue, info->cmap.red, sizeof(u16)*16);
  914. retval = par->board->setup_irq(info);
  915. if (retval < 0)
  916. goto err_cmap;
  917. /* this inits the dpy */
  918. retval = board->init(par);
  919. if (retval < 0)
  920. goto err_free_irq;
  921. broadsheet_identify(par);
  922. broadsheet_init(par);
  923. retval = register_framebuffer(info);
  924. if (retval < 0)
  925. goto err_free_irq;
  926. platform_set_drvdata(dev, info);
  927. retval = device_create_file(&dev->dev, &dev_attr_loadstore_waveform);
  928. if (retval < 0)
  929. goto err_unreg_fb;
  930. fb_info(info, "Broadsheet frame buffer, using %dK of video memory\n",
  931. videomemorysize >> 10);
  932. return 0;
  933. err_unreg_fb:
  934. unregister_framebuffer(info);
  935. err_free_irq:
  936. board->cleanup(par);
  937. err_cmap:
  938. fb_dealloc_cmap(&info->cmap);
  939. err_vfree:
  940. vfree(videomemory);
  941. err_fb_rel:
  942. framebuffer_release(info);
  943. err:
  944. module_put(board->owner);
  945. return retval;
  946. }
  947. static int broadsheetfb_remove(struct platform_device *dev)
  948. {
  949. struct fb_info *info = platform_get_drvdata(dev);
  950. if (info) {
  951. struct broadsheetfb_par *par = info->par;
  952. device_remove_file(info->dev, &dev_attr_loadstore_waveform);
  953. unregister_framebuffer(info);
  954. fb_deferred_io_cleanup(info);
  955. par->board->cleanup(par);
  956. fb_dealloc_cmap(&info->cmap);
  957. vfree((void *)info->screen_base);
  958. module_put(par->board->owner);
  959. framebuffer_release(info);
  960. }
  961. return 0;
  962. }
  963. static struct platform_driver broadsheetfb_driver = {
  964. .probe = broadsheetfb_probe,
  965. .remove = broadsheetfb_remove,
  966. .driver = {
  967. .name = "broadsheetfb",
  968. },
  969. };
  970. module_platform_driver(broadsheetfb_driver);
  971. MODULE_DESCRIPTION("fbdev driver for Broadsheet controller");
  972. MODULE_AUTHOR("Jaya Kumar");
  973. MODULE_LICENSE("GPL");