locomo.c 32 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190
  1. /*
  2. * linux/arch/arm/common/locomo.c
  3. *
  4. * Sharp LoCoMo support
  5. *
  6. * This program is free software; you can redistribute it and/or modify
  7. * it under the terms of the GNU General Public License version 2 as
  8. * published by the Free Software Foundation.
  9. *
  10. * This file contains all generic LoCoMo support.
  11. *
  12. * All initialization functions provided here are intended to be called
  13. * from machine specific code with proper arguments when required.
  14. *
  15. * Based on sa1111.c
  16. */
  17. #include <linux/module.h>
  18. #include <linux/init.h>
  19. #include <linux/kernel.h>
  20. #include <linux/delay.h>
  21. #include <linux/errno.h>
  22. #include <linux/ioport.h>
  23. #include <linux/platform_device.h>
  24. #include <linux/slab.h>
  25. #include <linux/spinlock.h>
  26. #include <asm/hardware.h>
  27. #include <asm/io.h>
  28. #include <asm/irq.h>
  29. #include <asm/mach/irq.h>
  30. #include <asm/hardware/locomo.h>
  31. /* M62332 output channel selection */
  32. #define M62332_EVR_CH 1 /* M62332 volume channel number */
  33. /* 0 : CH.1 , 1 : CH. 2 */
  34. /* DAC send data */
  35. #define M62332_SLAVE_ADDR 0x4e /* Slave address */
  36. #define M62332_W_BIT 0x00 /* W bit (0 only) */
  37. #define M62332_SUB_ADDR 0x00 /* Sub address */
  38. #define M62332_A_BIT 0x00 /* A bit (0 only) */
  39. /* DAC setup and hold times (expressed in us) */
  40. #define DAC_BUS_FREE_TIME 5 /* 4.7 us */
  41. #define DAC_START_SETUP_TIME 5 /* 4.7 us */
  42. #define DAC_STOP_SETUP_TIME 4 /* 4.0 us */
  43. #define DAC_START_HOLD_TIME 5 /* 4.7 us */
  44. #define DAC_SCL_LOW_HOLD_TIME 5 /* 4.7 us */
  45. #define DAC_SCL_HIGH_HOLD_TIME 4 /* 4.0 us */
  46. #define DAC_DATA_SETUP_TIME 1 /* 250 ns */
  47. #define DAC_DATA_HOLD_TIME 1 /* 300 ns */
  48. #define DAC_LOW_SETUP_TIME 1 /* 300 ns */
  49. #define DAC_HIGH_SETUP_TIME 1 /* 1000 ns */
  50. /* the following is the overall data for the locomo chip */
  51. struct locomo {
  52. struct device *dev;
  53. unsigned long phys;
  54. unsigned int irq;
  55. spinlock_t lock;
  56. void __iomem *base;
  57. };
  58. struct locomo_dev_info {
  59. unsigned long offset;
  60. unsigned long length;
  61. unsigned int devid;
  62. unsigned int irq[1];
  63. const char * name;
  64. };
  65. /* All the locomo devices. If offset is non-zero, the mapbase for the
  66. * locomo_dev will be set to the chip base plus offset. If offset is
  67. * zero, then the mapbase for the locomo_dev will be set to zero. An
  68. * offset of zero means the device only uses GPIOs or other helper
  69. * functions inside this file */
  70. static struct locomo_dev_info locomo_devices[] = {
  71. {
  72. .devid = LOCOMO_DEVID_KEYBOARD,
  73. .irq = {
  74. IRQ_LOCOMO_KEY,
  75. },
  76. .name = "locomo-keyboard",
  77. .offset = LOCOMO_KEYBOARD,
  78. .length = 16,
  79. },
  80. {
  81. .devid = LOCOMO_DEVID_FRONTLIGHT,
  82. .irq = {},
  83. .name = "locomo-frontlight",
  84. .offset = LOCOMO_FRONTLIGHT,
  85. .length = 8,
  86. },
  87. {
  88. .devid = LOCOMO_DEVID_BACKLIGHT,
  89. .irq = {},
  90. .name = "locomo-backlight",
  91. .offset = LOCOMO_BACKLIGHT,
  92. .length = 8,
  93. },
  94. {
  95. .devid = LOCOMO_DEVID_AUDIO,
  96. .irq = {},
  97. .name = "locomo-audio",
  98. .offset = LOCOMO_AUDIO,
  99. .length = 4,
  100. },
  101. {
  102. .devid = LOCOMO_DEVID_LED,
  103. .irq = {},
  104. .name = "locomo-led",
  105. .offset = LOCOMO_LED,
  106. .length = 8,
  107. },
  108. {
  109. .devid = LOCOMO_DEVID_UART,
  110. .irq = {},
  111. .name = "locomo-uart",
  112. .offset = 0,
  113. .length = 0,
  114. },
  115. };
  116. /** LoCoMo interrupt handling stuff.
  117. * NOTE: LoCoMo has a 1 to many mapping on all of its IRQs.
  118. * that is, there is only one real hardware interrupt
  119. * we determine which interrupt it is by reading some IO memory.
  120. * We have two levels of expansion, first in the handler for the
  121. * hardware interrupt we generate an interrupt
  122. * IRQ_LOCOMO_*_BASE and those handlers generate more interrupts
  123. *
  124. * hardware irq reads LOCOMO_ICR & 0x0f00
  125. * IRQ_LOCOMO_KEY_BASE
  126. * IRQ_LOCOMO_GPIO_BASE
  127. * IRQ_LOCOMO_LT_BASE
  128. * IRQ_LOCOMO_SPI_BASE
  129. * IRQ_LOCOMO_KEY_BASE reads LOCOMO_KIC & 0x0001
  130. * IRQ_LOCOMO_KEY
  131. * IRQ_LOCOMO_GPIO_BASE reads LOCOMO_GIR & LOCOMO_GPD & 0xffff
  132. * IRQ_LOCOMO_GPIO[0-15]
  133. * IRQ_LOCOMO_LT_BASE reads LOCOMO_LTINT & 0x0001
  134. * IRQ_LOCOMO_LT
  135. * IRQ_LOCOMO_SPI_BASE reads LOCOMO_SPIIR & 0x000F
  136. * IRQ_LOCOMO_SPI_RFR
  137. * IRQ_LOCOMO_SPI_RFW
  138. * IRQ_LOCOMO_SPI_OVRN
  139. * IRQ_LOCOMO_SPI_TEND
  140. */
  141. #define LOCOMO_IRQ_START (IRQ_LOCOMO_KEY_BASE)
  142. #define LOCOMO_IRQ_KEY_START (IRQ_LOCOMO_KEY)
  143. #define LOCOMO_IRQ_GPIO_START (IRQ_LOCOMO_GPIO0)
  144. #define LOCOMO_IRQ_LT_START (IRQ_LOCOMO_LT)
  145. #define LOCOMO_IRQ_SPI_START (IRQ_LOCOMO_SPI_RFR)
  146. static void locomo_handler(unsigned int irq, struct irqdesc *desc,
  147. struct pt_regs *regs)
  148. {
  149. int req, i;
  150. struct irqdesc *d;
  151. void __iomem *mapbase = get_irq_chipdata(irq);
  152. /* Acknowledge the parent IRQ */
  153. desc->chip->ack(irq);
  154. /* check why this interrupt was generated */
  155. req = locomo_readl(mapbase + LOCOMO_ICR) & 0x0f00;
  156. if (req) {
  157. /* generate the next interrupt(s) */
  158. irq = LOCOMO_IRQ_START;
  159. d = irq_desc + irq;
  160. for (i = 0; i <= 3; i++, d++, irq++) {
  161. if (req & (0x0100 << i)) {
  162. desc_handle_irq(irq, d, regs);
  163. }
  164. }
  165. }
  166. }
  167. static void locomo_ack_irq(unsigned int irq)
  168. {
  169. }
  170. static void locomo_mask_irq(unsigned int irq)
  171. {
  172. void __iomem *mapbase = get_irq_chipdata(irq);
  173. unsigned int r;
  174. r = locomo_readl(mapbase + LOCOMO_ICR);
  175. r &= ~(0x0010 << (irq - LOCOMO_IRQ_START));
  176. locomo_writel(r, mapbase + LOCOMO_ICR);
  177. }
  178. static void locomo_unmask_irq(unsigned int irq)
  179. {
  180. void __iomem *mapbase = get_irq_chipdata(irq);
  181. unsigned int r;
  182. r = locomo_readl(mapbase + LOCOMO_ICR);
  183. r |= (0x0010 << (irq - LOCOMO_IRQ_START));
  184. locomo_writel(r, mapbase + LOCOMO_ICR);
  185. }
  186. static struct irq_chip locomo_chip = {
  187. .name = "LOCOMO",
  188. .ack = locomo_ack_irq,
  189. .mask = locomo_mask_irq,
  190. .unmask = locomo_unmask_irq,
  191. };
  192. static void locomo_key_handler(unsigned int irq, struct irqdesc *desc,
  193. struct pt_regs *regs)
  194. {
  195. struct irqdesc *d;
  196. void __iomem *mapbase = get_irq_chipdata(irq);
  197. if (locomo_readl(mapbase + LOCOMO_KEYBOARD + LOCOMO_KIC) & 0x0001) {
  198. d = irq_desc + LOCOMO_IRQ_KEY_START;
  199. desc_handle_irq(LOCOMO_IRQ_KEY_START, d, regs);
  200. }
  201. }
  202. static void locomo_key_ack_irq(unsigned int irq)
  203. {
  204. void __iomem *mapbase = get_irq_chipdata(irq);
  205. unsigned int r;
  206. r = locomo_readl(mapbase + LOCOMO_KEYBOARD + LOCOMO_KIC);
  207. r &= ~(0x0100 << (irq - LOCOMO_IRQ_KEY_START));
  208. locomo_writel(r, mapbase + LOCOMO_KEYBOARD + LOCOMO_KIC);
  209. }
  210. static void locomo_key_mask_irq(unsigned int irq)
  211. {
  212. void __iomem *mapbase = get_irq_chipdata(irq);
  213. unsigned int r;
  214. r = locomo_readl(mapbase + LOCOMO_KEYBOARD + LOCOMO_KIC);
  215. r &= ~(0x0010 << (irq - LOCOMO_IRQ_KEY_START));
  216. locomo_writel(r, mapbase + LOCOMO_KEYBOARD + LOCOMO_KIC);
  217. }
  218. static void locomo_key_unmask_irq(unsigned int irq)
  219. {
  220. void __iomem *mapbase = get_irq_chipdata(irq);
  221. unsigned int r;
  222. r = locomo_readl(mapbase + LOCOMO_KEYBOARD + LOCOMO_KIC);
  223. r |= (0x0010 << (irq - LOCOMO_IRQ_KEY_START));
  224. locomo_writel(r, mapbase + LOCOMO_KEYBOARD + LOCOMO_KIC);
  225. }
  226. static struct irq_chip locomo_key_chip = {
  227. .name = "LOCOMO-key",
  228. .ack = locomo_key_ack_irq,
  229. .mask = locomo_key_mask_irq,
  230. .unmask = locomo_key_unmask_irq,
  231. };
  232. static void locomo_gpio_handler(unsigned int irq, struct irqdesc *desc,
  233. struct pt_regs *regs)
  234. {
  235. int req, i;
  236. struct irqdesc *d;
  237. void __iomem *mapbase = get_irq_chipdata(irq);
  238. req = locomo_readl(mapbase + LOCOMO_GIR) &
  239. locomo_readl(mapbase + LOCOMO_GPD) &
  240. 0xffff;
  241. if (req) {
  242. irq = LOCOMO_IRQ_GPIO_START;
  243. d = irq_desc + LOCOMO_IRQ_GPIO_START;
  244. for (i = 0; i <= 15; i++, irq++, d++) {
  245. if (req & (0x0001 << i)) {
  246. desc_handle_irq(irq, d, regs);
  247. }
  248. }
  249. }
  250. }
  251. static void locomo_gpio_ack_irq(unsigned int irq)
  252. {
  253. void __iomem *mapbase = get_irq_chipdata(irq);
  254. unsigned int r;
  255. r = locomo_readl(mapbase + LOCOMO_GWE);
  256. r |= (0x0001 << (irq - LOCOMO_IRQ_GPIO_START));
  257. locomo_writel(r, mapbase + LOCOMO_GWE);
  258. r = locomo_readl(mapbase + LOCOMO_GIS);
  259. r &= ~(0x0001 << (irq - LOCOMO_IRQ_GPIO_START));
  260. locomo_writel(r, mapbase + LOCOMO_GIS);
  261. r = locomo_readl(mapbase + LOCOMO_GWE);
  262. r &= ~(0x0001 << (irq - LOCOMO_IRQ_GPIO_START));
  263. locomo_writel(r, mapbase + LOCOMO_GWE);
  264. }
  265. static void locomo_gpio_mask_irq(unsigned int irq)
  266. {
  267. void __iomem *mapbase = get_irq_chipdata(irq);
  268. unsigned int r;
  269. r = locomo_readl(mapbase + LOCOMO_GIE);
  270. r &= ~(0x0001 << (irq - LOCOMO_IRQ_GPIO_START));
  271. locomo_writel(r, mapbase + LOCOMO_GIE);
  272. }
  273. static void locomo_gpio_unmask_irq(unsigned int irq)
  274. {
  275. void __iomem *mapbase = get_irq_chipdata(irq);
  276. unsigned int r;
  277. r = locomo_readl(mapbase + LOCOMO_GIE);
  278. r |= (0x0001 << (irq - LOCOMO_IRQ_GPIO_START));
  279. locomo_writel(r, mapbase + LOCOMO_GIE);
  280. }
  281. static struct irq_chip locomo_gpio_chip = {
  282. .name = "LOCOMO-gpio",
  283. .ack = locomo_gpio_ack_irq,
  284. .mask = locomo_gpio_mask_irq,
  285. .unmask = locomo_gpio_unmask_irq,
  286. };
  287. static void locomo_lt_handler(unsigned int irq, struct irqdesc *desc,
  288. struct pt_regs *regs)
  289. {
  290. struct irqdesc *d;
  291. void __iomem *mapbase = get_irq_chipdata(irq);
  292. if (locomo_readl(mapbase + LOCOMO_LTINT) & 0x0001) {
  293. d = irq_desc + LOCOMO_IRQ_LT_START;
  294. desc_handle_irq(LOCOMO_IRQ_LT_START, d, regs);
  295. }
  296. }
  297. static void locomo_lt_ack_irq(unsigned int irq)
  298. {
  299. void __iomem *mapbase = get_irq_chipdata(irq);
  300. unsigned int r;
  301. r = locomo_readl(mapbase + LOCOMO_LTINT);
  302. r &= ~(0x0100 << (irq - LOCOMO_IRQ_LT_START));
  303. locomo_writel(r, mapbase + LOCOMO_LTINT);
  304. }
  305. static void locomo_lt_mask_irq(unsigned int irq)
  306. {
  307. void __iomem *mapbase = get_irq_chipdata(irq);
  308. unsigned int r;
  309. r = locomo_readl(mapbase + LOCOMO_LTINT);
  310. r &= ~(0x0010 << (irq - LOCOMO_IRQ_LT_START));
  311. locomo_writel(r, mapbase + LOCOMO_LTINT);
  312. }
  313. static void locomo_lt_unmask_irq(unsigned int irq)
  314. {
  315. void __iomem *mapbase = get_irq_chipdata(irq);
  316. unsigned int r;
  317. r = locomo_readl(mapbase + LOCOMO_LTINT);
  318. r |= (0x0010 << (irq - LOCOMO_IRQ_LT_START));
  319. locomo_writel(r, mapbase + LOCOMO_LTINT);
  320. }
  321. static struct irq_chip locomo_lt_chip = {
  322. .name = "LOCOMO-lt",
  323. .ack = locomo_lt_ack_irq,
  324. .mask = locomo_lt_mask_irq,
  325. .unmask = locomo_lt_unmask_irq,
  326. };
  327. static void locomo_spi_handler(unsigned int irq, struct irqdesc *desc,
  328. struct pt_regs *regs)
  329. {
  330. int req, i;
  331. struct irqdesc *d;
  332. void __iomem *mapbase = get_irq_chipdata(irq);
  333. req = locomo_readl(mapbase + LOCOMO_SPIIR) & 0x000F;
  334. if (req) {
  335. irq = LOCOMO_IRQ_SPI_START;
  336. d = irq_desc + irq;
  337. for (i = 0; i <= 3; i++, irq++, d++) {
  338. if (req & (0x0001 << i)) {
  339. desc_handle_irq(irq, d, regs);
  340. }
  341. }
  342. }
  343. }
  344. static void locomo_spi_ack_irq(unsigned int irq)
  345. {
  346. void __iomem *mapbase = get_irq_chipdata(irq);
  347. unsigned int r;
  348. r = locomo_readl(mapbase + LOCOMO_SPIWE);
  349. r |= (0x0001 << (irq - LOCOMO_IRQ_SPI_START));
  350. locomo_writel(r, mapbase + LOCOMO_SPIWE);
  351. r = locomo_readl(mapbase + LOCOMO_SPIIS);
  352. r &= ~(0x0001 << (irq - LOCOMO_IRQ_SPI_START));
  353. locomo_writel(r, mapbase + LOCOMO_SPIIS);
  354. r = locomo_readl(mapbase + LOCOMO_SPIWE);
  355. r &= ~(0x0001 << (irq - LOCOMO_IRQ_SPI_START));
  356. locomo_writel(r, mapbase + LOCOMO_SPIWE);
  357. }
  358. static void locomo_spi_mask_irq(unsigned int irq)
  359. {
  360. void __iomem *mapbase = get_irq_chipdata(irq);
  361. unsigned int r;
  362. r = locomo_readl(mapbase + LOCOMO_SPIIE);
  363. r &= ~(0x0001 << (irq - LOCOMO_IRQ_SPI_START));
  364. locomo_writel(r, mapbase + LOCOMO_SPIIE);
  365. }
  366. static void locomo_spi_unmask_irq(unsigned int irq)
  367. {
  368. void __iomem *mapbase = get_irq_chipdata(irq);
  369. unsigned int r;
  370. r = locomo_readl(mapbase + LOCOMO_SPIIE);
  371. r |= (0x0001 << (irq - LOCOMO_IRQ_SPI_START));
  372. locomo_writel(r, mapbase + LOCOMO_SPIIE);
  373. }
  374. static struct irq_chip locomo_spi_chip = {
  375. .name = "LOCOMO-spi",
  376. .ack = locomo_spi_ack_irq,
  377. .mask = locomo_spi_mask_irq,
  378. .unmask = locomo_spi_unmask_irq,
  379. };
  380. static void locomo_setup_irq(struct locomo *lchip)
  381. {
  382. int irq;
  383. void __iomem *irqbase = lchip->base;
  384. /*
  385. * Install handler for IRQ_LOCOMO_HW.
  386. */
  387. set_irq_type(lchip->irq, IRQT_FALLING);
  388. set_irq_chipdata(lchip->irq, irqbase);
  389. set_irq_chained_handler(lchip->irq, locomo_handler);
  390. /* Install handlers for IRQ_LOCOMO_*_BASE */
  391. set_irq_chip(IRQ_LOCOMO_KEY_BASE, &locomo_chip);
  392. set_irq_chipdata(IRQ_LOCOMO_KEY_BASE, irqbase);
  393. set_irq_chained_handler(IRQ_LOCOMO_KEY_BASE, locomo_key_handler);
  394. set_irq_flags(IRQ_LOCOMO_KEY_BASE, IRQF_VALID | IRQF_PROBE);
  395. set_irq_chip(IRQ_LOCOMO_GPIO_BASE, &locomo_chip);
  396. set_irq_chipdata(IRQ_LOCOMO_GPIO_BASE, irqbase);
  397. set_irq_chained_handler(IRQ_LOCOMO_GPIO_BASE, locomo_gpio_handler);
  398. set_irq_flags(IRQ_LOCOMO_GPIO_BASE, IRQF_VALID | IRQF_PROBE);
  399. set_irq_chip(IRQ_LOCOMO_LT_BASE, &locomo_chip);
  400. set_irq_chipdata(IRQ_LOCOMO_LT_BASE, irqbase);
  401. set_irq_chained_handler(IRQ_LOCOMO_LT_BASE, locomo_lt_handler);
  402. set_irq_flags(IRQ_LOCOMO_LT_BASE, IRQF_VALID | IRQF_PROBE);
  403. set_irq_chip(IRQ_LOCOMO_SPI_BASE, &locomo_chip);
  404. set_irq_chipdata(IRQ_LOCOMO_SPI_BASE, irqbase);
  405. set_irq_chained_handler(IRQ_LOCOMO_SPI_BASE, locomo_spi_handler);
  406. set_irq_flags(IRQ_LOCOMO_SPI_BASE, IRQF_VALID | IRQF_PROBE);
  407. /* install handlers for IRQ_LOCOMO_KEY_BASE generated interrupts */
  408. set_irq_chip(LOCOMO_IRQ_KEY_START, &locomo_key_chip);
  409. set_irq_chipdata(LOCOMO_IRQ_KEY_START, irqbase);
  410. set_irq_handler(LOCOMO_IRQ_KEY_START, do_edge_IRQ);
  411. set_irq_flags(LOCOMO_IRQ_KEY_START, IRQF_VALID | IRQF_PROBE);
  412. /* install handlers for IRQ_LOCOMO_GPIO_BASE generated interrupts */
  413. for (irq = LOCOMO_IRQ_GPIO_START; irq < LOCOMO_IRQ_GPIO_START + 16; irq++) {
  414. set_irq_chip(irq, &locomo_gpio_chip);
  415. set_irq_chipdata(irq, irqbase);
  416. set_irq_handler(irq, do_edge_IRQ);
  417. set_irq_flags(irq, IRQF_VALID | IRQF_PROBE);
  418. }
  419. /* install handlers for IRQ_LOCOMO_LT_BASE generated interrupts */
  420. set_irq_chip(LOCOMO_IRQ_LT_START, &locomo_lt_chip);
  421. set_irq_chipdata(LOCOMO_IRQ_LT_START, irqbase);
  422. set_irq_handler(LOCOMO_IRQ_LT_START, do_edge_IRQ);
  423. set_irq_flags(LOCOMO_IRQ_LT_START, IRQF_VALID | IRQF_PROBE);
  424. /* install handlers for IRQ_LOCOMO_SPI_BASE generated interrupts */
  425. for (irq = LOCOMO_IRQ_SPI_START; irq < LOCOMO_IRQ_SPI_START + 3; irq++) {
  426. set_irq_chip(irq, &locomo_spi_chip);
  427. set_irq_chipdata(irq, irqbase);
  428. set_irq_handler(irq, do_edge_IRQ);
  429. set_irq_flags(irq, IRQF_VALID | IRQF_PROBE);
  430. }
  431. }
  432. static void locomo_dev_release(struct device *_dev)
  433. {
  434. struct locomo_dev *dev = LOCOMO_DEV(_dev);
  435. kfree(dev);
  436. }
  437. static int
  438. locomo_init_one_child(struct locomo *lchip, struct locomo_dev_info *info)
  439. {
  440. struct locomo_dev *dev;
  441. int ret;
  442. dev = kzalloc(sizeof(struct locomo_dev), GFP_KERNEL);
  443. if (!dev) {
  444. ret = -ENOMEM;
  445. goto out;
  446. }
  447. strncpy(dev->dev.bus_id, info->name, sizeof(dev->dev.bus_id));
  448. /*
  449. * If the parent device has a DMA mask associated with it,
  450. * propagate it down to the children.
  451. */
  452. if (lchip->dev->dma_mask) {
  453. dev->dma_mask = *lchip->dev->dma_mask;
  454. dev->dev.dma_mask = &dev->dma_mask;
  455. }
  456. dev->devid = info->devid;
  457. dev->dev.parent = lchip->dev;
  458. dev->dev.bus = &locomo_bus_type;
  459. dev->dev.release = locomo_dev_release;
  460. dev->dev.coherent_dma_mask = lchip->dev->coherent_dma_mask;
  461. if (info->offset)
  462. dev->mapbase = lchip->base + info->offset;
  463. else
  464. dev->mapbase = 0;
  465. dev->length = info->length;
  466. memmove(dev->irq, info->irq, sizeof(dev->irq));
  467. ret = device_register(&dev->dev);
  468. if (ret) {
  469. out:
  470. kfree(dev);
  471. }
  472. return ret;
  473. }
  474. #ifdef CONFIG_PM
  475. struct locomo_save_data {
  476. u16 LCM_GPO;
  477. u16 LCM_SPICT;
  478. u16 LCM_GPE;
  479. u16 LCM_ASD;
  480. u16 LCM_SPIMD;
  481. };
  482. static int locomo_suspend(struct platform_device *dev, pm_message_t state)
  483. {
  484. struct locomo *lchip = platform_get_drvdata(dev);
  485. struct locomo_save_data *save;
  486. unsigned long flags;
  487. save = kmalloc(sizeof(struct locomo_save_data), GFP_KERNEL);
  488. if (!save)
  489. return -ENOMEM;
  490. dev->dev.power.saved_state = (void *) save;
  491. spin_lock_irqsave(&lchip->lock, flags);
  492. save->LCM_GPO = locomo_readl(lchip->base + LOCOMO_GPO); /* GPIO */
  493. locomo_writel(0x00, lchip->base + LOCOMO_GPO);
  494. save->LCM_SPICT = locomo_readl(lchip->base + LOCOMO_SPICT); /* SPI */
  495. locomo_writel(0x40, lchip->base + LOCOMO_SPICT);
  496. save->LCM_GPE = locomo_readl(lchip->base + LOCOMO_GPE); /* GPIO */
  497. locomo_writel(0x00, lchip->base + LOCOMO_GPE);
  498. save->LCM_ASD = locomo_readl(lchip->base + LOCOMO_ASD); /* ADSTART */
  499. locomo_writel(0x00, lchip->base + LOCOMO_ASD);
  500. save->LCM_SPIMD = locomo_readl(lchip->base + LOCOMO_SPIMD); /* SPI */
  501. locomo_writel(0x3C14, lchip->base + LOCOMO_SPIMD);
  502. locomo_writel(0x00, lchip->base + LOCOMO_PAIF);
  503. locomo_writel(0x00, lchip->base + LOCOMO_DAC);
  504. locomo_writel(0x00, lchip->base + LOCOMO_BACKLIGHT + LOCOMO_TC);
  505. if ( (locomo_readl(lchip->base + LOCOMO_LED + LOCOMO_LPT0) & 0x88) && (locomo_readl(lchip->base + LOCOMO_LED + LOCOMO_LPT1) & 0x88) )
  506. locomo_writel(0x00, lchip->base + LOCOMO_C32K); /* CLK32 off */
  507. else
  508. /* 18MHz already enabled, so no wait */
  509. locomo_writel(0xc1, lchip->base + LOCOMO_C32K); /* CLK32 on */
  510. locomo_writel(0x00, lchip->base + LOCOMO_TADC); /* 18MHz clock off*/
  511. locomo_writel(0x00, lchip->base + LOCOMO_AUDIO + LOCOMO_ACC); /* 22MHz/24MHz clock off */
  512. locomo_writel(0x00, lchip->base + LOCOMO_FRONTLIGHT + LOCOMO_ALS); /* FL */
  513. spin_unlock_irqrestore(&lchip->lock, flags);
  514. return 0;
  515. }
  516. static int locomo_resume(struct platform_device *dev)
  517. {
  518. struct locomo *lchip = platform_get_drvdata(dev);
  519. struct locomo_save_data *save;
  520. unsigned long r;
  521. unsigned long flags;
  522. save = (struct locomo_save_data *) dev->dev.power.saved_state;
  523. if (!save)
  524. return 0;
  525. spin_lock_irqsave(&lchip->lock, flags);
  526. locomo_writel(save->LCM_GPO, lchip->base + LOCOMO_GPO);
  527. locomo_writel(save->LCM_SPICT, lchip->base + LOCOMO_SPICT);
  528. locomo_writel(save->LCM_GPE, lchip->base + LOCOMO_GPE);
  529. locomo_writel(save->LCM_ASD, lchip->base + LOCOMO_ASD);
  530. locomo_writel(save->LCM_SPIMD, lchip->base + LOCOMO_SPIMD);
  531. locomo_writel(0x00, lchip->base + LOCOMO_C32K);
  532. locomo_writel(0x90, lchip->base + LOCOMO_TADC);
  533. locomo_writel(0, lchip->base + LOCOMO_KEYBOARD + LOCOMO_KSC);
  534. r = locomo_readl(lchip->base + LOCOMO_KEYBOARD + LOCOMO_KIC);
  535. r &= 0xFEFF;
  536. locomo_writel(r, lchip->base + LOCOMO_KEYBOARD + LOCOMO_KIC);
  537. locomo_writel(0x1, lchip->base + LOCOMO_KEYBOARD + LOCOMO_KCMD);
  538. spin_unlock_irqrestore(&lchip->lock, flags);
  539. kfree(save);
  540. return 0;
  541. }
  542. #endif
  543. /**
  544. * locomo_probe - probe for a single LoCoMo chip.
  545. * @phys_addr: physical address of device.
  546. *
  547. * Probe for a LoCoMo chip. This must be called
  548. * before any other locomo-specific code.
  549. *
  550. * Returns:
  551. * %-ENODEV device not found.
  552. * %-EBUSY physical address already marked in-use.
  553. * %0 successful.
  554. */
  555. static int
  556. __locomo_probe(struct device *me, struct resource *mem, int irq)
  557. {
  558. struct locomo *lchip;
  559. unsigned long r;
  560. int i, ret = -ENODEV;
  561. lchip = kzalloc(sizeof(struct locomo), GFP_KERNEL);
  562. if (!lchip)
  563. return -ENOMEM;
  564. spin_lock_init(&lchip->lock);
  565. lchip->dev = me;
  566. dev_set_drvdata(lchip->dev, lchip);
  567. lchip->phys = mem->start;
  568. lchip->irq = irq;
  569. /*
  570. * Map the whole region. This also maps the
  571. * registers for our children.
  572. */
  573. lchip->base = ioremap(mem->start, PAGE_SIZE);
  574. if (!lchip->base) {
  575. ret = -ENOMEM;
  576. goto out;
  577. }
  578. /* locomo initialize */
  579. locomo_writel(0, lchip->base + LOCOMO_ICR);
  580. /* KEYBOARD */
  581. locomo_writel(0, lchip->base + LOCOMO_KEYBOARD + LOCOMO_KIC);
  582. /* GPIO */
  583. locomo_writel(0, lchip->base + LOCOMO_GPO);
  584. locomo_writel( (LOCOMO_GPIO(2) | LOCOMO_GPIO(3) | LOCOMO_GPIO(13) | LOCOMO_GPIO(14))
  585. , lchip->base + LOCOMO_GPE);
  586. locomo_writel( (LOCOMO_GPIO(2) | LOCOMO_GPIO(3) | LOCOMO_GPIO(13) | LOCOMO_GPIO(14))
  587. , lchip->base + LOCOMO_GPD);
  588. locomo_writel(0, lchip->base + LOCOMO_GIE);
  589. /* Frontlight */
  590. locomo_writel(0, lchip->base + LOCOMO_FRONTLIGHT + LOCOMO_ALS);
  591. locomo_writel(0, lchip->base + LOCOMO_FRONTLIGHT + LOCOMO_ALD);
  592. /* Longtime timer */
  593. locomo_writel(0, lchip->base + LOCOMO_LTINT);
  594. /* SPI */
  595. locomo_writel(0, lchip->base + LOCOMO_SPIIE);
  596. locomo_writel(6 + 8 + 320 + 30 - 10, lchip->base + LOCOMO_ASD);
  597. r = locomo_readl(lchip->base + LOCOMO_ASD);
  598. r |= 0x8000;
  599. locomo_writel(r, lchip->base + LOCOMO_ASD);
  600. locomo_writel(6 + 8 + 320 + 30 - 10 - 128 + 4, lchip->base + LOCOMO_HSD);
  601. r = locomo_readl(lchip->base + LOCOMO_HSD);
  602. r |= 0x8000;
  603. locomo_writel(r, lchip->base + LOCOMO_HSD);
  604. locomo_writel(128 / 8, lchip->base + LOCOMO_HSC);
  605. /* XON */
  606. locomo_writel(0x80, lchip->base + LOCOMO_TADC);
  607. udelay(1000);
  608. /* CLK9MEN */
  609. r = locomo_readl(lchip->base + LOCOMO_TADC);
  610. r |= 0x10;
  611. locomo_writel(r, lchip->base + LOCOMO_TADC);
  612. udelay(100);
  613. /* init DAC */
  614. r = locomo_readl(lchip->base + LOCOMO_DAC);
  615. r |= LOCOMO_DAC_SCLOEB | LOCOMO_DAC_SDAOEB;
  616. locomo_writel(r, lchip->base + LOCOMO_DAC);
  617. r = locomo_readl(lchip->base + LOCOMO_VER);
  618. printk(KERN_INFO "LoCoMo Chip: %lu%lu\n", (r >> 8), (r & 0xff));
  619. /*
  620. * The interrupt controller must be initialised before any
  621. * other device to ensure that the interrupts are available.
  622. */
  623. if (lchip->irq != NO_IRQ)
  624. locomo_setup_irq(lchip);
  625. for (i = 0; i < ARRAY_SIZE(locomo_devices); i++)
  626. locomo_init_one_child(lchip, &locomo_devices[i]);
  627. return 0;
  628. out:
  629. kfree(lchip);
  630. return ret;
  631. }
  632. static int locomo_remove_child(struct device *dev, void *data)
  633. {
  634. device_unregister(dev);
  635. return 0;
  636. }
  637. static void __locomo_remove(struct locomo *lchip)
  638. {
  639. device_for_each_child(lchip->dev, NULL, locomo_remove_child);
  640. if (lchip->irq != NO_IRQ) {
  641. set_irq_chained_handler(lchip->irq, NULL);
  642. set_irq_data(lchip->irq, NULL);
  643. }
  644. iounmap(lchip->base);
  645. kfree(lchip);
  646. }
  647. static int locomo_probe(struct platform_device *dev)
  648. {
  649. struct resource *mem;
  650. int irq;
  651. mem = platform_get_resource(dev, IORESOURCE_MEM, 0);
  652. if (!mem)
  653. return -EINVAL;
  654. irq = platform_get_irq(dev, 0);
  655. if (irq < 0)
  656. return -ENXIO;
  657. return __locomo_probe(&dev->dev, mem, irq);
  658. }
  659. static int locomo_remove(struct platform_device *dev)
  660. {
  661. struct locomo *lchip = platform_get_drvdata(dev);
  662. if (lchip) {
  663. __locomo_remove(lchip);
  664. platform_set_drvdata(dev, NULL);
  665. }
  666. return 0;
  667. }
  668. /*
  669. * Not sure if this should be on the system bus or not yet.
  670. * We really want some way to register a system device at
  671. * the per-machine level, and then have this driver pick
  672. * up the registered devices.
  673. */
  674. static struct platform_driver locomo_device_driver = {
  675. .probe = locomo_probe,
  676. .remove = locomo_remove,
  677. #ifdef CONFIG_PM
  678. .suspend = locomo_suspend,
  679. .resume = locomo_resume,
  680. #endif
  681. .driver = {
  682. .name = "locomo",
  683. },
  684. };
  685. /*
  686. * Get the parent device driver (us) structure
  687. * from a child function device
  688. */
  689. static inline struct locomo *locomo_chip_driver(struct locomo_dev *ldev)
  690. {
  691. return (struct locomo *)dev_get_drvdata(ldev->dev.parent);
  692. }
  693. void locomo_gpio_set_dir(struct device *dev, unsigned int bits, unsigned int dir)
  694. {
  695. struct locomo *lchip = dev_get_drvdata(dev);
  696. unsigned long flags;
  697. unsigned int r;
  698. if (!lchip)
  699. return;
  700. spin_lock_irqsave(&lchip->lock, flags);
  701. r = locomo_readl(lchip->base + LOCOMO_GPD);
  702. r &= ~bits;
  703. locomo_writel(r, lchip->base + LOCOMO_GPD);
  704. r = locomo_readl(lchip->base + LOCOMO_GPE);
  705. if (dir)
  706. r |= bits;
  707. else
  708. r &= ~bits;
  709. locomo_writel(r, lchip->base + LOCOMO_GPE);
  710. spin_unlock_irqrestore(&lchip->lock, flags);
  711. }
  712. int locomo_gpio_read_level(struct device *dev, unsigned int bits)
  713. {
  714. struct locomo *lchip = dev_get_drvdata(dev);
  715. unsigned long flags;
  716. unsigned int ret;
  717. if (!lchip)
  718. return -ENODEV;
  719. spin_lock_irqsave(&lchip->lock, flags);
  720. ret = locomo_readl(lchip->base + LOCOMO_GPL);
  721. spin_unlock_irqrestore(&lchip->lock, flags);
  722. ret &= bits;
  723. return ret;
  724. }
  725. int locomo_gpio_read_output(struct device *dev, unsigned int bits)
  726. {
  727. struct locomo *lchip = dev_get_drvdata(dev);
  728. unsigned long flags;
  729. unsigned int ret;
  730. if (!lchip)
  731. return -ENODEV;
  732. spin_lock_irqsave(&lchip->lock, flags);
  733. ret = locomo_readl(lchip->base + LOCOMO_GPO);
  734. spin_unlock_irqrestore(&lchip->lock, flags);
  735. ret &= bits;
  736. return ret;
  737. }
  738. void locomo_gpio_write(struct device *dev, unsigned int bits, unsigned int set)
  739. {
  740. struct locomo *lchip = dev_get_drvdata(dev);
  741. unsigned long flags;
  742. unsigned int r;
  743. if (!lchip)
  744. return;
  745. spin_lock_irqsave(&lchip->lock, flags);
  746. r = locomo_readl(lchip->base + LOCOMO_GPO);
  747. if (set)
  748. r |= bits;
  749. else
  750. r &= ~bits;
  751. locomo_writel(r, lchip->base + LOCOMO_GPO);
  752. spin_unlock_irqrestore(&lchip->lock, flags);
  753. }
  754. static void locomo_m62332_sendbit(void *mapbase, int bit)
  755. {
  756. unsigned int r;
  757. r = locomo_readl(mapbase + LOCOMO_DAC);
  758. r &= ~(LOCOMO_DAC_SCLOEB);
  759. locomo_writel(r, mapbase + LOCOMO_DAC);
  760. udelay(DAC_LOW_SETUP_TIME); /* 300 nsec */
  761. udelay(DAC_DATA_HOLD_TIME); /* 300 nsec */
  762. r = locomo_readl(mapbase + LOCOMO_DAC);
  763. r &= ~(LOCOMO_DAC_SCLOEB);
  764. locomo_writel(r, mapbase + LOCOMO_DAC);
  765. udelay(DAC_LOW_SETUP_TIME); /* 300 nsec */
  766. udelay(DAC_SCL_LOW_HOLD_TIME); /* 4.7 usec */
  767. if (bit & 1) {
  768. r = locomo_readl(mapbase + LOCOMO_DAC);
  769. r |= LOCOMO_DAC_SDAOEB;
  770. locomo_writel(r, mapbase + LOCOMO_DAC);
  771. udelay(DAC_HIGH_SETUP_TIME); /* 1000 nsec */
  772. } else {
  773. r = locomo_readl(mapbase + LOCOMO_DAC);
  774. r &= ~(LOCOMO_DAC_SDAOEB);
  775. locomo_writel(r, mapbase + LOCOMO_DAC);
  776. udelay(DAC_LOW_SETUP_TIME); /* 300 nsec */
  777. }
  778. udelay(DAC_DATA_SETUP_TIME); /* 250 nsec */
  779. r = locomo_readl(mapbase + LOCOMO_DAC);
  780. r |= LOCOMO_DAC_SCLOEB;
  781. locomo_writel(r, mapbase + LOCOMO_DAC);
  782. udelay(DAC_HIGH_SETUP_TIME); /* 1000 nsec */
  783. udelay(DAC_SCL_HIGH_HOLD_TIME); /* 4.0 usec */
  784. }
  785. void locomo_m62332_senddata(struct locomo_dev *ldev, unsigned int dac_data, int channel)
  786. {
  787. struct locomo *lchip = locomo_chip_driver(ldev);
  788. int i;
  789. unsigned char data;
  790. unsigned int r;
  791. void *mapbase = lchip->base;
  792. unsigned long flags;
  793. spin_lock_irqsave(&lchip->lock, flags);
  794. /* Start */
  795. udelay(DAC_BUS_FREE_TIME); /* 5.0 usec */
  796. r = locomo_readl(mapbase + LOCOMO_DAC);
  797. r |= LOCOMO_DAC_SCLOEB | LOCOMO_DAC_SDAOEB;
  798. locomo_writel(r, mapbase + LOCOMO_DAC);
  799. udelay(DAC_HIGH_SETUP_TIME); /* 1000 nsec */
  800. udelay(DAC_SCL_HIGH_HOLD_TIME); /* 4.0 usec */
  801. r = locomo_readl(mapbase + LOCOMO_DAC);
  802. r &= ~(LOCOMO_DAC_SDAOEB);
  803. locomo_writel(r, mapbase + LOCOMO_DAC);
  804. udelay(DAC_START_HOLD_TIME); /* 5.0 usec */
  805. udelay(DAC_DATA_HOLD_TIME); /* 300 nsec */
  806. /* Send slave address and W bit (LSB is W bit) */
  807. data = (M62332_SLAVE_ADDR << 1) | M62332_W_BIT;
  808. for (i = 1; i <= 8; i++) {
  809. locomo_m62332_sendbit(mapbase, data >> (8 - i));
  810. }
  811. /* Check A bit */
  812. r = locomo_readl(mapbase + LOCOMO_DAC);
  813. r &= ~(LOCOMO_DAC_SCLOEB);
  814. locomo_writel(r, mapbase + LOCOMO_DAC);
  815. udelay(DAC_LOW_SETUP_TIME); /* 300 nsec */
  816. udelay(DAC_SCL_LOW_HOLD_TIME); /* 4.7 usec */
  817. r = locomo_readl(mapbase + LOCOMO_DAC);
  818. r &= ~(LOCOMO_DAC_SDAOEB);
  819. locomo_writel(r, mapbase + LOCOMO_DAC);
  820. udelay(DAC_LOW_SETUP_TIME); /* 300 nsec */
  821. r = locomo_readl(mapbase + LOCOMO_DAC);
  822. r |= LOCOMO_DAC_SCLOEB;
  823. locomo_writel(r, mapbase + LOCOMO_DAC);
  824. udelay(DAC_HIGH_SETUP_TIME); /* 1000 nsec */
  825. udelay(DAC_SCL_HIGH_HOLD_TIME); /* 4.7 usec */
  826. if (locomo_readl(mapbase + LOCOMO_DAC) & LOCOMO_DAC_SDAOEB) { /* High is error */
  827. printk(KERN_WARNING "locomo: m62332_senddata Error 1\n");
  828. return;
  829. }
  830. /* Send Sub address (LSB is channel select) */
  831. /* channel = 0 : ch1 select */
  832. /* = 1 : ch2 select */
  833. data = M62332_SUB_ADDR + channel;
  834. for (i = 1; i <= 8; i++) {
  835. locomo_m62332_sendbit(mapbase, data >> (8 - i));
  836. }
  837. /* Check A bit */
  838. r = locomo_readl(mapbase + LOCOMO_DAC);
  839. r &= ~(LOCOMO_DAC_SCLOEB);
  840. locomo_writel(r, mapbase + LOCOMO_DAC);
  841. udelay(DAC_LOW_SETUP_TIME); /* 300 nsec */
  842. udelay(DAC_SCL_LOW_HOLD_TIME); /* 4.7 usec */
  843. r = locomo_readl(mapbase + LOCOMO_DAC);
  844. r &= ~(LOCOMO_DAC_SDAOEB);
  845. locomo_writel(r, mapbase + LOCOMO_DAC);
  846. udelay(DAC_LOW_SETUP_TIME); /* 300 nsec */
  847. r = locomo_readl(mapbase + LOCOMO_DAC);
  848. r |= LOCOMO_DAC_SCLOEB;
  849. locomo_writel(r, mapbase + LOCOMO_DAC);
  850. udelay(DAC_HIGH_SETUP_TIME); /* 1000 nsec */
  851. udelay(DAC_SCL_HIGH_HOLD_TIME); /* 4.7 usec */
  852. if (locomo_readl(mapbase + LOCOMO_DAC) & LOCOMO_DAC_SDAOEB) { /* High is error */
  853. printk(KERN_WARNING "locomo: m62332_senddata Error 2\n");
  854. return;
  855. }
  856. /* Send DAC data */
  857. for (i = 1; i <= 8; i++) {
  858. locomo_m62332_sendbit(mapbase, dac_data >> (8 - i));
  859. }
  860. /* Check A bit */
  861. r = locomo_readl(mapbase + LOCOMO_DAC);
  862. r &= ~(LOCOMO_DAC_SCLOEB);
  863. locomo_writel(r, mapbase + LOCOMO_DAC);
  864. udelay(DAC_LOW_SETUP_TIME); /* 300 nsec */
  865. udelay(DAC_SCL_LOW_HOLD_TIME); /* 4.7 usec */
  866. r = locomo_readl(mapbase + LOCOMO_DAC);
  867. r &= ~(LOCOMO_DAC_SDAOEB);
  868. locomo_writel(r, mapbase + LOCOMO_DAC);
  869. udelay(DAC_LOW_SETUP_TIME); /* 300 nsec */
  870. r = locomo_readl(mapbase + LOCOMO_DAC);
  871. r |= LOCOMO_DAC_SCLOEB;
  872. locomo_writel(r, mapbase + LOCOMO_DAC);
  873. udelay(DAC_HIGH_SETUP_TIME); /* 1000 nsec */
  874. udelay(DAC_SCL_HIGH_HOLD_TIME); /* 4.7 usec */
  875. if (locomo_readl(mapbase + LOCOMO_DAC) & LOCOMO_DAC_SDAOEB) { /* High is error */
  876. printk(KERN_WARNING "locomo: m62332_senddata Error 3\n");
  877. return;
  878. }
  879. /* stop */
  880. r = locomo_readl(mapbase + LOCOMO_DAC);
  881. r &= ~(LOCOMO_DAC_SCLOEB);
  882. locomo_writel(r, mapbase + LOCOMO_DAC);
  883. udelay(DAC_LOW_SETUP_TIME); /* 300 nsec */
  884. udelay(DAC_SCL_LOW_HOLD_TIME); /* 4.7 usec */
  885. r = locomo_readl(mapbase + LOCOMO_DAC);
  886. r |= LOCOMO_DAC_SCLOEB;
  887. locomo_writel(r, mapbase + LOCOMO_DAC);
  888. udelay(DAC_HIGH_SETUP_TIME); /* 1000 nsec */
  889. udelay(DAC_SCL_HIGH_HOLD_TIME); /* 4 usec */
  890. r = locomo_readl(mapbase + LOCOMO_DAC);
  891. r |= LOCOMO_DAC_SDAOEB;
  892. locomo_writel(r, mapbase + LOCOMO_DAC);
  893. udelay(DAC_HIGH_SETUP_TIME); /* 1000 nsec */
  894. udelay(DAC_SCL_HIGH_HOLD_TIME); /* 4 usec */
  895. r = locomo_readl(mapbase + LOCOMO_DAC);
  896. r |= LOCOMO_DAC_SCLOEB | LOCOMO_DAC_SDAOEB;
  897. locomo_writel(r, mapbase + LOCOMO_DAC);
  898. udelay(DAC_LOW_SETUP_TIME); /* 1000 nsec */
  899. udelay(DAC_SCL_LOW_HOLD_TIME); /* 4.7 usec */
  900. spin_unlock_irqrestore(&lchip->lock, flags);
  901. }
  902. /*
  903. * Frontlight control
  904. */
  905. static struct locomo *locomo_chip_driver(struct locomo_dev *ldev);
  906. void locomo_frontlight_set(struct locomo_dev *dev, int duty, int vr, int bpwf)
  907. {
  908. unsigned long flags;
  909. struct locomo *lchip = locomo_chip_driver(dev);
  910. if (vr)
  911. locomo_gpio_write(dev->dev.parent, LOCOMO_GPIO_FL_VR, 1);
  912. else
  913. locomo_gpio_write(dev->dev.parent, LOCOMO_GPIO_FL_VR, 0);
  914. spin_lock_irqsave(&lchip->lock, flags);
  915. locomo_writel(bpwf, lchip->base + LOCOMO_FRONTLIGHT + LOCOMO_ALS);
  916. udelay(100);
  917. locomo_writel(duty, lchip->base + LOCOMO_FRONTLIGHT + LOCOMO_ALD);
  918. locomo_writel(bpwf | LOCOMO_ALC_EN, lchip->base + LOCOMO_FRONTLIGHT + LOCOMO_ALS);
  919. spin_unlock_irqrestore(&lchip->lock, flags);
  920. }
  921. /*
  922. * LoCoMo "Register Access Bus."
  923. *
  924. * We model this as a regular bus type, and hang devices directly
  925. * off this.
  926. */
  927. static int locomo_match(struct device *_dev, struct device_driver *_drv)
  928. {
  929. struct locomo_dev *dev = LOCOMO_DEV(_dev);
  930. struct locomo_driver *drv = LOCOMO_DRV(_drv);
  931. return dev->devid == drv->devid;
  932. }
  933. static int locomo_bus_suspend(struct device *dev, pm_message_t state)
  934. {
  935. struct locomo_dev *ldev = LOCOMO_DEV(dev);
  936. struct locomo_driver *drv = LOCOMO_DRV(dev->driver);
  937. int ret = 0;
  938. if (drv && drv->suspend)
  939. ret = drv->suspend(ldev, state);
  940. return ret;
  941. }
  942. static int locomo_bus_resume(struct device *dev)
  943. {
  944. struct locomo_dev *ldev = LOCOMO_DEV(dev);
  945. struct locomo_driver *drv = LOCOMO_DRV(dev->driver);
  946. int ret = 0;
  947. if (drv && drv->resume)
  948. ret = drv->resume(ldev);
  949. return ret;
  950. }
  951. static int locomo_bus_probe(struct device *dev)
  952. {
  953. struct locomo_dev *ldev = LOCOMO_DEV(dev);
  954. struct locomo_driver *drv = LOCOMO_DRV(dev->driver);
  955. int ret = -ENODEV;
  956. if (drv->probe)
  957. ret = drv->probe(ldev);
  958. return ret;
  959. }
  960. static int locomo_bus_remove(struct device *dev)
  961. {
  962. struct locomo_dev *ldev = LOCOMO_DEV(dev);
  963. struct locomo_driver *drv = LOCOMO_DRV(dev->driver);
  964. int ret = 0;
  965. if (drv->remove)
  966. ret = drv->remove(ldev);
  967. return ret;
  968. }
  969. struct bus_type locomo_bus_type = {
  970. .name = "locomo-bus",
  971. .match = locomo_match,
  972. .probe = locomo_bus_probe,
  973. .remove = locomo_bus_remove,
  974. .suspend = locomo_bus_suspend,
  975. .resume = locomo_bus_resume,
  976. };
  977. int locomo_driver_register(struct locomo_driver *driver)
  978. {
  979. driver->drv.bus = &locomo_bus_type;
  980. return driver_register(&driver->drv);
  981. }
  982. void locomo_driver_unregister(struct locomo_driver *driver)
  983. {
  984. driver_unregister(&driver->drv);
  985. }
  986. static int __init locomo_init(void)
  987. {
  988. int ret = bus_register(&locomo_bus_type);
  989. if (ret == 0)
  990. platform_driver_register(&locomo_device_driver);
  991. return ret;
  992. }
  993. static void __exit locomo_exit(void)
  994. {
  995. platform_driver_unregister(&locomo_device_driver);
  996. bus_unregister(&locomo_bus_type);
  997. }
  998. module_init(locomo_init);
  999. module_exit(locomo_exit);
  1000. MODULE_DESCRIPTION("Sharp LoCoMo core driver");
  1001. MODULE_LICENSE("GPL");
  1002. MODULE_AUTHOR("John Lenz <lenz@cs.wisc.edu>");
  1003. EXPORT_SYMBOL(locomo_driver_register);
  1004. EXPORT_SYMBOL(locomo_driver_unregister);
  1005. EXPORT_SYMBOL(locomo_gpio_set_dir);
  1006. EXPORT_SYMBOL(locomo_gpio_read_level);
  1007. EXPORT_SYMBOL(locomo_gpio_read_output);
  1008. EXPORT_SYMBOL(locomo_gpio_write);
  1009. EXPORT_SYMBOL(locomo_m62332_senddata);