locomo.c 32 KB

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