locomo.c 23 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * linux/arch/arm/common/locomo.c
  4. *
  5. * Sharp LoCoMo support
  6. *
  7. * This file contains all generic LoCoMo support.
  8. *
  9. * All initialization functions provided here are intended to be called
  10. * from machine specific code with proper arguments when required.
  11. *
  12. * Based on sa1111.c
  13. */
  14. #include <linux/module.h>
  15. #include <linux/init.h>
  16. #include <linux/kernel.h>
  17. #include <linux/delay.h>
  18. #include <linux/errno.h>
  19. #include <linux/ioport.h>
  20. #include <linux/platform_device.h>
  21. #include <linux/slab.h>
  22. #include <linux/spinlock.h>
  23. #include <linux/io.h>
  24. #include <asm/irq.h>
  25. #include <asm/mach/irq.h>
  26. #include <asm/hardware/locomo.h>
  27. /* LoCoMo Interrupts */
  28. #define IRQ_LOCOMO_KEY (0)
  29. #define IRQ_LOCOMO_GPIO (1)
  30. #define IRQ_LOCOMO_LT (2)
  31. #define IRQ_LOCOMO_SPI (3)
  32. /* M62332 output channel selection */
  33. #define M62332_EVR_CH 1 /* M62332 volume channel number */
  34. /* 0 : CH.1 , 1 : CH. 2 */
  35. /* DAC send data */
  36. #define M62332_SLAVE_ADDR 0x4e /* Slave address */
  37. #define M62332_W_BIT 0x00 /* W bit (0 only) */
  38. #define M62332_SUB_ADDR 0x00 /* Sub address */
  39. #define M62332_A_BIT 0x00 /* A bit (0 only) */
  40. /* DAC setup and hold times (expressed in us) */
  41. #define DAC_BUS_FREE_TIME 5 /* 4.7 us */
  42. #define DAC_START_SETUP_TIME 5 /* 4.7 us */
  43. #define DAC_STOP_SETUP_TIME 4 /* 4.0 us */
  44. #define DAC_START_HOLD_TIME 5 /* 4.7 us */
  45. #define DAC_SCL_LOW_HOLD_TIME 5 /* 4.7 us */
  46. #define DAC_SCL_HIGH_HOLD_TIME 4 /* 4.0 us */
  47. #define DAC_DATA_SETUP_TIME 1 /* 250 ns */
  48. #define DAC_DATA_HOLD_TIME 1 /* 300 ns */
  49. #define DAC_LOW_SETUP_TIME 1 /* 300 ns */
  50. #define DAC_HIGH_SETUP_TIME 1 /* 1000 ns */
  51. /* the following is the overall data for the locomo chip */
  52. struct locomo {
  53. struct device *dev;
  54. unsigned long phys;
  55. unsigned int irq;
  56. int irq_base;
  57. spinlock_t lock;
  58. void __iomem *base;
  59. #ifdef CONFIG_PM
  60. void *saved_state;
  61. #endif
  62. };
  63. struct locomo_dev_info {
  64. unsigned long offset;
  65. unsigned long length;
  66. unsigned int devid;
  67. unsigned int irq[1];
  68. const char * name;
  69. };
  70. /* All the locomo devices. If offset is non-zero, the mapbase for the
  71. * locomo_dev will be set to the chip base plus offset. If offset is
  72. * zero, then the mapbase for the locomo_dev will be set to zero. An
  73. * offset of zero means the device only uses GPIOs or other helper
  74. * functions inside this file */
  75. static struct locomo_dev_info locomo_devices[] = {
  76. {
  77. .devid = LOCOMO_DEVID_KEYBOARD,
  78. .irq = { IRQ_LOCOMO_KEY },
  79. .name = "locomo-keyboard",
  80. .offset = LOCOMO_KEYBOARD,
  81. .length = 16,
  82. },
  83. {
  84. .devid = LOCOMO_DEVID_FRONTLIGHT,
  85. .irq = {},
  86. .name = "locomo-frontlight",
  87. .offset = LOCOMO_FRONTLIGHT,
  88. .length = 8,
  89. },
  90. {
  91. .devid = LOCOMO_DEVID_BACKLIGHT,
  92. .irq = {},
  93. .name = "locomo-backlight",
  94. .offset = LOCOMO_BACKLIGHT,
  95. .length = 8,
  96. },
  97. {
  98. .devid = LOCOMO_DEVID_AUDIO,
  99. .irq = {},
  100. .name = "locomo-audio",
  101. .offset = LOCOMO_AUDIO,
  102. .length = 4,
  103. },
  104. {
  105. .devid = LOCOMO_DEVID_LED,
  106. .irq = {},
  107. .name = "locomo-led",
  108. .offset = LOCOMO_LED,
  109. .length = 8,
  110. },
  111. {
  112. .devid = LOCOMO_DEVID_UART,
  113. .irq = {},
  114. .name = "locomo-uart",
  115. .offset = 0,
  116. .length = 0,
  117. },
  118. {
  119. .devid = LOCOMO_DEVID_SPI,
  120. .irq = {},
  121. .name = "locomo-spi",
  122. .offset = LOCOMO_SPI,
  123. .length = 0x30,
  124. },
  125. };
  126. static void locomo_handler(struct irq_desc *desc)
  127. {
  128. struct locomo *lchip = irq_desc_get_handler_data(desc);
  129. int req, i;
  130. /* Acknowledge the parent IRQ */
  131. desc->irq_data.chip->irq_ack(&desc->irq_data);
  132. /* check why this interrupt was generated */
  133. req = locomo_readl(lchip->base + LOCOMO_ICR) & 0x0f00;
  134. if (req) {
  135. unsigned int irq;
  136. /* generate the next interrupt(s) */
  137. irq = lchip->irq_base;
  138. for (i = 0; i <= 3; i++, irq++) {
  139. if (req & (0x0100 << i)) {
  140. generic_handle_irq(irq);
  141. }
  142. }
  143. }
  144. }
  145. static void locomo_ack_irq(struct irq_data *d)
  146. {
  147. }
  148. static void locomo_mask_irq(struct irq_data *d)
  149. {
  150. struct locomo *lchip = irq_data_get_irq_chip_data(d);
  151. unsigned int r;
  152. r = locomo_readl(lchip->base + LOCOMO_ICR);
  153. r &= ~(0x0010 << (d->irq - lchip->irq_base));
  154. locomo_writel(r, lchip->base + LOCOMO_ICR);
  155. }
  156. static void locomo_unmask_irq(struct irq_data *d)
  157. {
  158. struct locomo *lchip = irq_data_get_irq_chip_data(d);
  159. unsigned int r;
  160. r = locomo_readl(lchip->base + LOCOMO_ICR);
  161. r |= (0x0010 << (d->irq - lchip->irq_base));
  162. locomo_writel(r, lchip->base + LOCOMO_ICR);
  163. }
  164. static struct irq_chip locomo_chip = {
  165. .name = "LOCOMO",
  166. .irq_ack = locomo_ack_irq,
  167. .irq_mask = locomo_mask_irq,
  168. .irq_unmask = locomo_unmask_irq,
  169. };
  170. static void locomo_setup_irq(struct locomo *lchip)
  171. {
  172. int irq = lchip->irq_base;
  173. /*
  174. * Install handler for IRQ_LOCOMO_HW.
  175. */
  176. irq_set_irq_type(lchip->irq, IRQ_TYPE_EDGE_FALLING);
  177. irq_set_chained_handler_and_data(lchip->irq, locomo_handler, lchip);
  178. /* Install handlers for IRQ_LOCOMO_* */
  179. for ( ; irq <= lchip->irq_base + 3; irq++) {
  180. irq_set_chip_and_handler(irq, &locomo_chip, handle_level_irq);
  181. irq_set_chip_data(irq, lchip);
  182. irq_clear_status_flags(irq, IRQ_NOREQUEST | IRQ_NOPROBE);
  183. }
  184. }
  185. static void locomo_dev_release(struct device *_dev)
  186. {
  187. struct locomo_dev *dev = LOCOMO_DEV(_dev);
  188. kfree(dev);
  189. }
  190. static int
  191. locomo_init_one_child(struct locomo *lchip, struct locomo_dev_info *info)
  192. {
  193. struct locomo_dev *dev;
  194. int ret;
  195. dev = kzalloc(sizeof(struct locomo_dev), GFP_KERNEL);
  196. if (!dev) {
  197. ret = -ENOMEM;
  198. goto out;
  199. }
  200. /*
  201. * If the parent device has a DMA mask associated with it,
  202. * propagate it down to the children.
  203. */
  204. if (lchip->dev->dma_mask) {
  205. dev->dma_mask = *lchip->dev->dma_mask;
  206. dev->dev.dma_mask = &dev->dma_mask;
  207. }
  208. dev_set_name(&dev->dev, "%s", info->name);
  209. dev->devid = info->devid;
  210. dev->dev.parent = lchip->dev;
  211. dev->dev.bus = &locomo_bus_type;
  212. dev->dev.release = locomo_dev_release;
  213. dev->dev.coherent_dma_mask = lchip->dev->coherent_dma_mask;
  214. if (info->offset)
  215. dev->mapbase = lchip->base + info->offset;
  216. else
  217. dev->mapbase = 0;
  218. dev->length = info->length;
  219. dev->irq[0] = (lchip->irq_base == NO_IRQ) ?
  220. NO_IRQ : lchip->irq_base + info->irq[0];
  221. ret = device_register(&dev->dev);
  222. if (ret) {
  223. out:
  224. kfree(dev);
  225. }
  226. return ret;
  227. }
  228. #ifdef CONFIG_PM
  229. struct locomo_save_data {
  230. u16 LCM_GPO;
  231. u16 LCM_SPICT;
  232. u16 LCM_GPE;
  233. u16 LCM_ASD;
  234. u16 LCM_SPIMD;
  235. };
  236. static int locomo_suspend(struct platform_device *dev, pm_message_t state)
  237. {
  238. struct locomo *lchip = platform_get_drvdata(dev);
  239. struct locomo_save_data *save;
  240. unsigned long flags;
  241. save = kmalloc(sizeof(struct locomo_save_data), GFP_KERNEL);
  242. if (!save)
  243. return -ENOMEM;
  244. lchip->saved_state = save;
  245. spin_lock_irqsave(&lchip->lock, flags);
  246. save->LCM_GPO = locomo_readl(lchip->base + LOCOMO_GPO); /* GPIO */
  247. locomo_writel(0x00, lchip->base + LOCOMO_GPO);
  248. save->LCM_SPICT = locomo_readl(lchip->base + LOCOMO_SPI + LOCOMO_SPICT); /* SPI */
  249. locomo_writel(0x40, lchip->base + LOCOMO_SPI + LOCOMO_SPICT);
  250. save->LCM_GPE = locomo_readl(lchip->base + LOCOMO_GPE); /* GPIO */
  251. locomo_writel(0x00, lchip->base + LOCOMO_GPE);
  252. save->LCM_ASD = locomo_readl(lchip->base + LOCOMO_ASD); /* ADSTART */
  253. locomo_writel(0x00, lchip->base + LOCOMO_ASD);
  254. save->LCM_SPIMD = locomo_readl(lchip->base + LOCOMO_SPI + LOCOMO_SPIMD); /* SPI */
  255. locomo_writel(0x3C14, lchip->base + LOCOMO_SPI + LOCOMO_SPIMD);
  256. locomo_writel(0x00, lchip->base + LOCOMO_PAIF);
  257. locomo_writel(0x00, lchip->base + LOCOMO_DAC);
  258. locomo_writel(0x00, lchip->base + LOCOMO_BACKLIGHT + LOCOMO_TC);
  259. if ((locomo_readl(lchip->base + LOCOMO_LED + LOCOMO_LPT0) & 0x88) && (locomo_readl(lchip->base + LOCOMO_LED + LOCOMO_LPT1) & 0x88))
  260. locomo_writel(0x00, lchip->base + LOCOMO_C32K); /* CLK32 off */
  261. else
  262. /* 18MHz already enabled, so no wait */
  263. locomo_writel(0xc1, lchip->base + LOCOMO_C32K); /* CLK32 on */
  264. locomo_writel(0x00, lchip->base + LOCOMO_TADC); /* 18MHz clock off*/
  265. locomo_writel(0x00, lchip->base + LOCOMO_AUDIO + LOCOMO_ACC); /* 22MHz/24MHz clock off */
  266. locomo_writel(0x00, lchip->base + LOCOMO_FRONTLIGHT + LOCOMO_ALS); /* FL */
  267. spin_unlock_irqrestore(&lchip->lock, flags);
  268. return 0;
  269. }
  270. static int locomo_resume(struct platform_device *dev)
  271. {
  272. struct locomo *lchip = platform_get_drvdata(dev);
  273. struct locomo_save_data *save;
  274. unsigned long r;
  275. unsigned long flags;
  276. save = lchip->saved_state;
  277. if (!save)
  278. return 0;
  279. spin_lock_irqsave(&lchip->lock, flags);
  280. locomo_writel(save->LCM_GPO, lchip->base + LOCOMO_GPO);
  281. locomo_writel(save->LCM_SPICT, lchip->base + LOCOMO_SPI + LOCOMO_SPICT);
  282. locomo_writel(save->LCM_GPE, lchip->base + LOCOMO_GPE);
  283. locomo_writel(save->LCM_ASD, lchip->base + LOCOMO_ASD);
  284. locomo_writel(save->LCM_SPIMD, lchip->base + LOCOMO_SPI + LOCOMO_SPIMD);
  285. locomo_writel(0x00, lchip->base + LOCOMO_C32K);
  286. locomo_writel(0x90, lchip->base + LOCOMO_TADC);
  287. locomo_writel(0, lchip->base + LOCOMO_KEYBOARD + LOCOMO_KSC);
  288. r = locomo_readl(lchip->base + LOCOMO_KEYBOARD + LOCOMO_KIC);
  289. r &= 0xFEFF;
  290. locomo_writel(r, lchip->base + LOCOMO_KEYBOARD + LOCOMO_KIC);
  291. locomo_writel(0x1, lchip->base + LOCOMO_KEYBOARD + LOCOMO_KCMD);
  292. spin_unlock_irqrestore(&lchip->lock, flags);
  293. lchip->saved_state = NULL;
  294. kfree(save);
  295. return 0;
  296. }
  297. #endif
  298. /**
  299. * locomo_probe - probe for a single LoCoMo chip.
  300. * @phys_addr: physical address of device.
  301. *
  302. * Probe for a LoCoMo chip. This must be called
  303. * before any other locomo-specific code.
  304. *
  305. * Returns:
  306. * %-ENODEV device not found.
  307. * %-EBUSY physical address already marked in-use.
  308. * %0 successful.
  309. */
  310. static int
  311. __locomo_probe(struct device *me, struct resource *mem, int irq)
  312. {
  313. struct locomo_platform_data *pdata = me->platform_data;
  314. struct locomo *lchip;
  315. unsigned long r;
  316. int i, ret = -ENODEV;
  317. lchip = kzalloc(sizeof(struct locomo), GFP_KERNEL);
  318. if (!lchip)
  319. return -ENOMEM;
  320. spin_lock_init(&lchip->lock);
  321. lchip->dev = me;
  322. dev_set_drvdata(lchip->dev, lchip);
  323. lchip->phys = mem->start;
  324. lchip->irq = irq;
  325. lchip->irq_base = (pdata) ? pdata->irq_base : NO_IRQ;
  326. /*
  327. * Map the whole region. This also maps the
  328. * registers for our children.
  329. */
  330. lchip->base = ioremap(mem->start, PAGE_SIZE);
  331. if (!lchip->base) {
  332. ret = -ENOMEM;
  333. goto out;
  334. }
  335. /* locomo initialize */
  336. locomo_writel(0, lchip->base + LOCOMO_ICR);
  337. /* KEYBOARD */
  338. locomo_writel(0, lchip->base + LOCOMO_KEYBOARD + LOCOMO_KIC);
  339. /* GPIO */
  340. locomo_writel(0, lchip->base + LOCOMO_GPO);
  341. locomo_writel((LOCOMO_GPIO(1) | LOCOMO_GPIO(2) | LOCOMO_GPIO(13) | LOCOMO_GPIO(14))
  342. , lchip->base + LOCOMO_GPE);
  343. locomo_writel((LOCOMO_GPIO(1) | LOCOMO_GPIO(2) | LOCOMO_GPIO(13) | LOCOMO_GPIO(14))
  344. , lchip->base + LOCOMO_GPD);
  345. locomo_writel(0, lchip->base + LOCOMO_GIE);
  346. /* Frontlight */
  347. locomo_writel(0, lchip->base + LOCOMO_FRONTLIGHT + LOCOMO_ALS);
  348. locomo_writel(0, lchip->base + LOCOMO_FRONTLIGHT + LOCOMO_ALD);
  349. /* Longtime timer */
  350. locomo_writel(0, lchip->base + LOCOMO_LTINT);
  351. /* SPI */
  352. locomo_writel(0, lchip->base + LOCOMO_SPI + LOCOMO_SPIIE);
  353. locomo_writel(6 + 8 + 320 + 30 - 10, lchip->base + LOCOMO_ASD);
  354. r = locomo_readl(lchip->base + LOCOMO_ASD);
  355. r |= 0x8000;
  356. locomo_writel(r, lchip->base + LOCOMO_ASD);
  357. locomo_writel(6 + 8 + 320 + 30 - 10 - 128 + 4, lchip->base + LOCOMO_HSD);
  358. r = locomo_readl(lchip->base + LOCOMO_HSD);
  359. r |= 0x8000;
  360. locomo_writel(r, lchip->base + LOCOMO_HSD);
  361. locomo_writel(128 / 8, lchip->base + LOCOMO_HSC);
  362. /* XON */
  363. locomo_writel(0x80, lchip->base + LOCOMO_TADC);
  364. udelay(1000);
  365. /* CLK9MEN */
  366. r = locomo_readl(lchip->base + LOCOMO_TADC);
  367. r |= 0x10;
  368. locomo_writel(r, lchip->base + LOCOMO_TADC);
  369. udelay(100);
  370. /* init DAC */
  371. r = locomo_readl(lchip->base + LOCOMO_DAC);
  372. r |= LOCOMO_DAC_SCLOEB | LOCOMO_DAC_SDAOEB;
  373. locomo_writel(r, lchip->base + LOCOMO_DAC);
  374. r = locomo_readl(lchip->base + LOCOMO_VER);
  375. printk(KERN_INFO "LoCoMo Chip: %lu%lu\n", (r >> 8), (r & 0xff));
  376. /*
  377. * The interrupt controller must be initialised before any
  378. * other device to ensure that the interrupts are available.
  379. */
  380. if (lchip->irq != NO_IRQ && lchip->irq_base != NO_IRQ)
  381. locomo_setup_irq(lchip);
  382. for (i = 0; i < ARRAY_SIZE(locomo_devices); i++)
  383. locomo_init_one_child(lchip, &locomo_devices[i]);
  384. return 0;
  385. out:
  386. kfree(lchip);
  387. return ret;
  388. }
  389. static int locomo_remove_child(struct device *dev, void *data)
  390. {
  391. device_unregister(dev);
  392. return 0;
  393. }
  394. static void __locomo_remove(struct locomo *lchip)
  395. {
  396. device_for_each_child(lchip->dev, NULL, locomo_remove_child);
  397. if (lchip->irq != NO_IRQ) {
  398. irq_set_chained_handler_and_data(lchip->irq, NULL, NULL);
  399. }
  400. iounmap(lchip->base);
  401. kfree(lchip);
  402. }
  403. static int locomo_probe(struct platform_device *dev)
  404. {
  405. struct resource *mem;
  406. int irq;
  407. mem = platform_get_resource(dev, IORESOURCE_MEM, 0);
  408. if (!mem)
  409. return -EINVAL;
  410. irq = platform_get_irq(dev, 0);
  411. if (irq < 0)
  412. return -ENXIO;
  413. return __locomo_probe(&dev->dev, mem, irq);
  414. }
  415. static int locomo_remove(struct platform_device *dev)
  416. {
  417. struct locomo *lchip = platform_get_drvdata(dev);
  418. if (lchip) {
  419. __locomo_remove(lchip);
  420. platform_set_drvdata(dev, NULL);
  421. }
  422. return 0;
  423. }
  424. /*
  425. * Not sure if this should be on the system bus or not yet.
  426. * We really want some way to register a system device at
  427. * the per-machine level, and then have this driver pick
  428. * up the registered devices.
  429. */
  430. static struct platform_driver locomo_device_driver = {
  431. .probe = locomo_probe,
  432. .remove = locomo_remove,
  433. #ifdef CONFIG_PM
  434. .suspend = locomo_suspend,
  435. .resume = locomo_resume,
  436. #endif
  437. .driver = {
  438. .name = "locomo",
  439. },
  440. };
  441. /*
  442. * Get the parent device driver (us) structure
  443. * from a child function device
  444. */
  445. static inline struct locomo *locomo_chip_driver(struct locomo_dev *ldev)
  446. {
  447. return (struct locomo *)dev_get_drvdata(ldev->dev.parent);
  448. }
  449. void locomo_gpio_set_dir(struct device *dev, unsigned int bits, unsigned int dir)
  450. {
  451. struct locomo *lchip = dev_get_drvdata(dev);
  452. unsigned long flags;
  453. unsigned int r;
  454. if (!lchip)
  455. return;
  456. spin_lock_irqsave(&lchip->lock, flags);
  457. r = locomo_readl(lchip->base + LOCOMO_GPD);
  458. if (dir)
  459. r |= bits;
  460. else
  461. r &= ~bits;
  462. locomo_writel(r, lchip->base + LOCOMO_GPD);
  463. r = locomo_readl(lchip->base + LOCOMO_GPE);
  464. if (dir)
  465. r |= bits;
  466. else
  467. r &= ~bits;
  468. locomo_writel(r, lchip->base + LOCOMO_GPE);
  469. spin_unlock_irqrestore(&lchip->lock, flags);
  470. }
  471. EXPORT_SYMBOL(locomo_gpio_set_dir);
  472. int locomo_gpio_read_level(struct device *dev, unsigned int bits)
  473. {
  474. struct locomo *lchip = dev_get_drvdata(dev);
  475. unsigned long flags;
  476. unsigned int ret;
  477. if (!lchip)
  478. return -ENODEV;
  479. spin_lock_irqsave(&lchip->lock, flags);
  480. ret = locomo_readl(lchip->base + LOCOMO_GPL);
  481. spin_unlock_irqrestore(&lchip->lock, flags);
  482. ret &= bits;
  483. return ret;
  484. }
  485. EXPORT_SYMBOL(locomo_gpio_read_level);
  486. int locomo_gpio_read_output(struct device *dev, unsigned int bits)
  487. {
  488. struct locomo *lchip = dev_get_drvdata(dev);
  489. unsigned long flags;
  490. unsigned int ret;
  491. if (!lchip)
  492. return -ENODEV;
  493. spin_lock_irqsave(&lchip->lock, flags);
  494. ret = locomo_readl(lchip->base + LOCOMO_GPO);
  495. spin_unlock_irqrestore(&lchip->lock, flags);
  496. ret &= bits;
  497. return ret;
  498. }
  499. EXPORT_SYMBOL(locomo_gpio_read_output);
  500. void locomo_gpio_write(struct device *dev, unsigned int bits, unsigned int set)
  501. {
  502. struct locomo *lchip = dev_get_drvdata(dev);
  503. unsigned long flags;
  504. unsigned int r;
  505. if (!lchip)
  506. return;
  507. spin_lock_irqsave(&lchip->lock, flags);
  508. r = locomo_readl(lchip->base + LOCOMO_GPO);
  509. if (set)
  510. r |= bits;
  511. else
  512. r &= ~bits;
  513. locomo_writel(r, lchip->base + LOCOMO_GPO);
  514. spin_unlock_irqrestore(&lchip->lock, flags);
  515. }
  516. EXPORT_SYMBOL(locomo_gpio_write);
  517. static void locomo_m62332_sendbit(void *mapbase, int bit)
  518. {
  519. unsigned int r;
  520. r = locomo_readl(mapbase + LOCOMO_DAC);
  521. r &= ~(LOCOMO_DAC_SCLOEB);
  522. locomo_writel(r, mapbase + LOCOMO_DAC);
  523. udelay(DAC_LOW_SETUP_TIME); /* 300 nsec */
  524. udelay(DAC_DATA_HOLD_TIME); /* 300 nsec */
  525. r = locomo_readl(mapbase + LOCOMO_DAC);
  526. r &= ~(LOCOMO_DAC_SCLOEB);
  527. locomo_writel(r, mapbase + LOCOMO_DAC);
  528. udelay(DAC_LOW_SETUP_TIME); /* 300 nsec */
  529. udelay(DAC_SCL_LOW_HOLD_TIME); /* 4.7 usec */
  530. if (bit & 1) {
  531. r = locomo_readl(mapbase + LOCOMO_DAC);
  532. r |= LOCOMO_DAC_SDAOEB;
  533. locomo_writel(r, mapbase + LOCOMO_DAC);
  534. udelay(DAC_HIGH_SETUP_TIME); /* 1000 nsec */
  535. } else {
  536. r = locomo_readl(mapbase + LOCOMO_DAC);
  537. r &= ~(LOCOMO_DAC_SDAOEB);
  538. locomo_writel(r, mapbase + LOCOMO_DAC);
  539. udelay(DAC_LOW_SETUP_TIME); /* 300 nsec */
  540. }
  541. udelay(DAC_DATA_SETUP_TIME); /* 250 nsec */
  542. r = locomo_readl(mapbase + LOCOMO_DAC);
  543. r |= LOCOMO_DAC_SCLOEB;
  544. locomo_writel(r, mapbase + LOCOMO_DAC);
  545. udelay(DAC_HIGH_SETUP_TIME); /* 1000 nsec */
  546. udelay(DAC_SCL_HIGH_HOLD_TIME); /* 4.0 usec */
  547. }
  548. void locomo_m62332_senddata(struct locomo_dev *ldev, unsigned int dac_data, int channel)
  549. {
  550. struct locomo *lchip = locomo_chip_driver(ldev);
  551. int i;
  552. unsigned char data;
  553. unsigned int r;
  554. void *mapbase = lchip->base;
  555. unsigned long flags;
  556. spin_lock_irqsave(&lchip->lock, flags);
  557. /* Start */
  558. udelay(DAC_BUS_FREE_TIME); /* 5.0 usec */
  559. r = locomo_readl(mapbase + LOCOMO_DAC);
  560. r |= LOCOMO_DAC_SCLOEB | LOCOMO_DAC_SDAOEB;
  561. locomo_writel(r, mapbase + LOCOMO_DAC);
  562. udelay(DAC_HIGH_SETUP_TIME); /* 1000 nsec */
  563. udelay(DAC_SCL_HIGH_HOLD_TIME); /* 4.0 usec */
  564. r = locomo_readl(mapbase + LOCOMO_DAC);
  565. r &= ~(LOCOMO_DAC_SDAOEB);
  566. locomo_writel(r, mapbase + LOCOMO_DAC);
  567. udelay(DAC_START_HOLD_TIME); /* 5.0 usec */
  568. udelay(DAC_DATA_HOLD_TIME); /* 300 nsec */
  569. /* Send slave address and W bit (LSB is W bit) */
  570. data = (M62332_SLAVE_ADDR << 1) | M62332_W_BIT;
  571. for (i = 1; i <= 8; i++) {
  572. locomo_m62332_sendbit(mapbase, data >> (8 - i));
  573. }
  574. /* Check A bit */
  575. r = locomo_readl(mapbase + LOCOMO_DAC);
  576. r &= ~(LOCOMO_DAC_SCLOEB);
  577. locomo_writel(r, mapbase + LOCOMO_DAC);
  578. udelay(DAC_LOW_SETUP_TIME); /* 300 nsec */
  579. udelay(DAC_SCL_LOW_HOLD_TIME); /* 4.7 usec */
  580. r = locomo_readl(mapbase + LOCOMO_DAC);
  581. r &= ~(LOCOMO_DAC_SDAOEB);
  582. locomo_writel(r, mapbase + LOCOMO_DAC);
  583. udelay(DAC_LOW_SETUP_TIME); /* 300 nsec */
  584. r = locomo_readl(mapbase + LOCOMO_DAC);
  585. r |= LOCOMO_DAC_SCLOEB;
  586. locomo_writel(r, mapbase + LOCOMO_DAC);
  587. udelay(DAC_HIGH_SETUP_TIME); /* 1000 nsec */
  588. udelay(DAC_SCL_HIGH_HOLD_TIME); /* 4.7 usec */
  589. if (locomo_readl(mapbase + LOCOMO_DAC) & LOCOMO_DAC_SDAOEB) { /* High is error */
  590. printk(KERN_WARNING "locomo: m62332_senddata Error 1\n");
  591. goto out;
  592. }
  593. /* Send Sub address (LSB is channel select) */
  594. /* channel = 0 : ch1 select */
  595. /* = 1 : ch2 select */
  596. data = M62332_SUB_ADDR + channel;
  597. for (i = 1; i <= 8; i++) {
  598. locomo_m62332_sendbit(mapbase, data >> (8 - i));
  599. }
  600. /* Check A bit */
  601. r = locomo_readl(mapbase + LOCOMO_DAC);
  602. r &= ~(LOCOMO_DAC_SCLOEB);
  603. locomo_writel(r, mapbase + LOCOMO_DAC);
  604. udelay(DAC_LOW_SETUP_TIME); /* 300 nsec */
  605. udelay(DAC_SCL_LOW_HOLD_TIME); /* 4.7 usec */
  606. r = locomo_readl(mapbase + LOCOMO_DAC);
  607. r &= ~(LOCOMO_DAC_SDAOEB);
  608. locomo_writel(r, mapbase + LOCOMO_DAC);
  609. udelay(DAC_LOW_SETUP_TIME); /* 300 nsec */
  610. r = locomo_readl(mapbase + LOCOMO_DAC);
  611. r |= LOCOMO_DAC_SCLOEB;
  612. locomo_writel(r, mapbase + LOCOMO_DAC);
  613. udelay(DAC_HIGH_SETUP_TIME); /* 1000 nsec */
  614. udelay(DAC_SCL_HIGH_HOLD_TIME); /* 4.7 usec */
  615. if (locomo_readl(mapbase + LOCOMO_DAC) & LOCOMO_DAC_SDAOEB) { /* High is error */
  616. printk(KERN_WARNING "locomo: m62332_senddata Error 2\n");
  617. goto out;
  618. }
  619. /* Send DAC data */
  620. for (i = 1; i <= 8; i++) {
  621. locomo_m62332_sendbit(mapbase, dac_data >> (8 - i));
  622. }
  623. /* Check A bit */
  624. r = locomo_readl(mapbase + LOCOMO_DAC);
  625. r &= ~(LOCOMO_DAC_SCLOEB);
  626. locomo_writel(r, mapbase + LOCOMO_DAC);
  627. udelay(DAC_LOW_SETUP_TIME); /* 300 nsec */
  628. udelay(DAC_SCL_LOW_HOLD_TIME); /* 4.7 usec */
  629. r = locomo_readl(mapbase + LOCOMO_DAC);
  630. r &= ~(LOCOMO_DAC_SDAOEB);
  631. locomo_writel(r, mapbase + LOCOMO_DAC);
  632. udelay(DAC_LOW_SETUP_TIME); /* 300 nsec */
  633. r = locomo_readl(mapbase + LOCOMO_DAC);
  634. r |= LOCOMO_DAC_SCLOEB;
  635. locomo_writel(r, mapbase + LOCOMO_DAC);
  636. udelay(DAC_HIGH_SETUP_TIME); /* 1000 nsec */
  637. udelay(DAC_SCL_HIGH_HOLD_TIME); /* 4.7 usec */
  638. if (locomo_readl(mapbase + LOCOMO_DAC) & LOCOMO_DAC_SDAOEB) { /* High is error */
  639. printk(KERN_WARNING "locomo: m62332_senddata Error 3\n");
  640. }
  641. out:
  642. /* stop */
  643. r = locomo_readl(mapbase + LOCOMO_DAC);
  644. r &= ~(LOCOMO_DAC_SCLOEB);
  645. locomo_writel(r, mapbase + LOCOMO_DAC);
  646. udelay(DAC_LOW_SETUP_TIME); /* 300 nsec */
  647. udelay(DAC_SCL_LOW_HOLD_TIME); /* 4.7 usec */
  648. r = locomo_readl(mapbase + LOCOMO_DAC);
  649. r |= LOCOMO_DAC_SCLOEB;
  650. locomo_writel(r, mapbase + LOCOMO_DAC);
  651. udelay(DAC_HIGH_SETUP_TIME); /* 1000 nsec */
  652. udelay(DAC_SCL_HIGH_HOLD_TIME); /* 4 usec */
  653. r = locomo_readl(mapbase + LOCOMO_DAC);
  654. r |= LOCOMO_DAC_SDAOEB;
  655. locomo_writel(r, mapbase + LOCOMO_DAC);
  656. udelay(DAC_HIGH_SETUP_TIME); /* 1000 nsec */
  657. udelay(DAC_SCL_HIGH_HOLD_TIME); /* 4 usec */
  658. r = locomo_readl(mapbase + LOCOMO_DAC);
  659. r |= LOCOMO_DAC_SCLOEB | LOCOMO_DAC_SDAOEB;
  660. locomo_writel(r, mapbase + LOCOMO_DAC);
  661. udelay(DAC_LOW_SETUP_TIME); /* 1000 nsec */
  662. udelay(DAC_SCL_LOW_HOLD_TIME); /* 4.7 usec */
  663. spin_unlock_irqrestore(&lchip->lock, flags);
  664. }
  665. EXPORT_SYMBOL(locomo_m62332_senddata);
  666. /*
  667. * Frontlight control
  668. */
  669. void locomo_frontlight_set(struct locomo_dev *dev, int duty, int vr, int bpwf)
  670. {
  671. unsigned long flags;
  672. struct locomo *lchip = locomo_chip_driver(dev);
  673. if (vr)
  674. locomo_gpio_write(dev->dev.parent, LOCOMO_GPIO_FL_VR, 1);
  675. else
  676. locomo_gpio_write(dev->dev.parent, LOCOMO_GPIO_FL_VR, 0);
  677. spin_lock_irqsave(&lchip->lock, flags);
  678. locomo_writel(bpwf, lchip->base + LOCOMO_FRONTLIGHT + LOCOMO_ALS);
  679. udelay(100);
  680. locomo_writel(duty, lchip->base + LOCOMO_FRONTLIGHT + LOCOMO_ALD);
  681. locomo_writel(bpwf | LOCOMO_ALC_EN, lchip->base + LOCOMO_FRONTLIGHT + LOCOMO_ALS);
  682. spin_unlock_irqrestore(&lchip->lock, flags);
  683. }
  684. EXPORT_SYMBOL(locomo_frontlight_set);
  685. /*
  686. * LoCoMo "Register Access Bus."
  687. *
  688. * We model this as a regular bus type, and hang devices directly
  689. * off this.
  690. */
  691. static int locomo_match(struct device *_dev, struct device_driver *_drv)
  692. {
  693. struct locomo_dev *dev = LOCOMO_DEV(_dev);
  694. struct locomo_driver *drv = LOCOMO_DRV(_drv);
  695. return dev->devid == drv->devid;
  696. }
  697. static int locomo_bus_probe(struct device *dev)
  698. {
  699. struct locomo_dev *ldev = LOCOMO_DEV(dev);
  700. struct locomo_driver *drv = LOCOMO_DRV(dev->driver);
  701. int ret = -ENODEV;
  702. if (drv->probe)
  703. ret = drv->probe(ldev);
  704. return ret;
  705. }
  706. static void locomo_bus_remove(struct device *dev)
  707. {
  708. struct locomo_dev *ldev = LOCOMO_DEV(dev);
  709. struct locomo_driver *drv = LOCOMO_DRV(dev->driver);
  710. if (drv->remove)
  711. drv->remove(ldev);
  712. }
  713. struct bus_type locomo_bus_type = {
  714. .name = "locomo-bus",
  715. .match = locomo_match,
  716. .probe = locomo_bus_probe,
  717. .remove = locomo_bus_remove,
  718. };
  719. int locomo_driver_register(struct locomo_driver *driver)
  720. {
  721. driver->drv.bus = &locomo_bus_type;
  722. return driver_register(&driver->drv);
  723. }
  724. EXPORT_SYMBOL(locomo_driver_register);
  725. void locomo_driver_unregister(struct locomo_driver *driver)
  726. {
  727. driver_unregister(&driver->drv);
  728. }
  729. EXPORT_SYMBOL(locomo_driver_unregister);
  730. static int __init locomo_init(void)
  731. {
  732. int ret = bus_register(&locomo_bus_type);
  733. if (ret == 0)
  734. platform_driver_register(&locomo_device_driver);
  735. return ret;
  736. }
  737. static void __exit locomo_exit(void)
  738. {
  739. platform_driver_unregister(&locomo_device_driver);
  740. bus_unregister(&locomo_bus_type);
  741. }
  742. module_init(locomo_init);
  743. module_exit(locomo_exit);
  744. MODULE_DESCRIPTION("Sharp LoCoMo core driver");
  745. MODULE_LICENSE("GPL");
  746. MODULE_AUTHOR("John Lenz <[email protected]>");