drivers/mfd/ipaq-micro.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Compaq iPAQ h3xxx Atmel microcontroller companion support
0004  *
0005  * This is an Atmel AT90LS8535 with a special flashed-in firmware that
0006  * implements the special protocol used by this driver.
0007  *
0008  * based on previous kernel 2.4 version by Andrew Christian
0009  * Author : Alessandro Gardich <gremlin@gremlin.it>
0010  * Author : Dmitry Artamonow <mad_soft@inbox.ru>
0011  * Author : Linus Walleij <linus.walleij@linaro.org>
0012  */
0013
0014 #include <linux/module.h>
0015 #include <linux/init.h>
0016 #include <linux/interrupt.h>
0017 #include <linux/pm.h>
0018 #include <linux/delay.h>
0019 #include <linux/device.h>
0020 #include <linux/platform_device.h>
0021 #include <linux/io.h>
0022 #include <linux/mfd/core.h>
0023 #include <linux/mfd/ipaq-micro.h>
0024 #include <linux/string.h>
0025 #include <linux/random.h>
0026 #include <linux/slab.h>
0027 #include <linux/list.h>
0028
0029 #include <mach/hardware.h>
0030
0031 static void ipaq_micro_trigger_tx(struct ipaq_micro *micro)
0032 {
0033     struct ipaq_micro_txdev *tx = &micro->tx;
0034     struct ipaq_micro_msg *msg = micro->msg;
0035     int i, bp;
0036     u8 checksum;
0037     u32 val;
0038
0039     bp = 0;
0040     tx->buf[bp++] = CHAR_SOF;
0041
0042     checksum = ((msg->id & 0x0f) << 4) | (msg->tx_len & 0x0f);
0043     tx->buf[bp++] = checksum;
0044
0045     for (i = 0; i < msg->tx_len; i++) {
0046         tx->buf[bp++] = msg->tx_data[i];
0047         checksum += msg->tx_data[i];
0048     }
0049
0050     tx->buf[bp++] = checksum;
0051     tx->len = bp;
0052     tx->index = 0;
0053
0054     /* Enable interrupt */
0055     val = readl(micro->base + UTCR3);
0056     val |= UTCR3_TIE;
0057     writel(val, micro->base + UTCR3);
0058 }
0059
0060 int ipaq_micro_tx_msg(struct ipaq_micro *micro, struct ipaq_micro_msg *msg)
0061 {
0062     unsigned long flags;
0063
0064     dev_dbg(micro->dev, "TX msg: %02x, %d bytes\n", msg->id, msg->tx_len);
0065
0066     spin_lock_irqsave(&micro->lock, flags);
0067     if (micro->msg) {
0068         list_add_tail(&msg->node, &micro->queue);
0069         spin_unlock_irqrestore(&micro->lock, flags);
0070         return 0;
0071     }
0072     micro->msg = msg;
0073     ipaq_micro_trigger_tx(micro);
0074     spin_unlock_irqrestore(&micro->lock, flags);
0075     return 0;
0076 }
0077 EXPORT_SYMBOL(ipaq_micro_tx_msg);
0078
0079 static void micro_rx_msg(struct ipaq_micro *micro, u8 id, int len, u8 *data)
0080 {
0081     int i;
0082
0083     dev_dbg(micro->dev, "RX msg: %02x, %d bytes\n", id, len);
0084
0085     spin_lock(&micro->lock);
0086     switch (id) {
0087     case MSG_VERSION:
0088     case MSG_EEPROM_READ:
0089     case MSG_EEPROM_WRITE:
0090     case MSG_BACKLIGHT:
0091     case MSG_NOTIFY_LED:
0092     case MSG_THERMAL_SENSOR:
0093     case MSG_BATTERY:
0094         /* Handle synchronous messages */
0095         if (micro->msg && micro->msg->id == id) {
0096             struct ipaq_micro_msg *msg = micro->msg;
0097
0098             memcpy(msg->rx_data, data, len);
0099             msg->rx_len = len;
0100             complete(&micro->msg->ack);
0101             if (!list_empty(&micro->queue)) {
0102                 micro->msg = list_entry(micro->queue.next,
0103                             struct ipaq_micro_msg,
0104                             node);
0105                 list_del_init(&micro->msg->node);
0106                 ipaq_micro_trigger_tx(micro);
0107             } else
0108                 micro->msg = NULL;
0109             dev_dbg(micro->dev, "OK RX message 0x%02x\n", id);
0110         } else {
0111             dev_err(micro->dev,
0112                 "out of band RX message 0x%02x\n", id);
0113             if (!micro->msg)
0114                 dev_info(micro->dev, "no message queued\n");
0115             else
0116                 dev_info(micro->dev, "expected message %02x\n",
0117                      micro->msg->id);
0118         }
0119         break;
0120     case MSG_KEYBOARD:
0121         if (micro->key)
0122             micro->key(micro->key_data, len, data);
0123         else
0124             dev_dbg(micro->dev, "key message ignored, no handle\n");
0125         break;
0126     case MSG_TOUCHSCREEN:
0127         if (micro->ts)
0128             micro->ts(micro->ts_data, len, data);
0129         else
0130             dev_dbg(micro->dev, "touchscreen message ignored, no handle\n");
0131         break;
0132     default:
0133         dev_err(micro->dev,
0134             "unknown msg %d [%d] ", id, len);
0135         for (i = 0; i < len; ++i)
0136             pr_cont("0x%02x ", data[i]);
0137         pr_cont("\n");
0138     }
0139     spin_unlock(&micro->lock);
0140 }
0141
0142 static void micro_process_char(struct ipaq_micro *micro, u8 ch)
0143 {
0144     struct ipaq_micro_rxdev *rx = &micro->rx;
0145
0146     switch (rx->state) {
0147     case STATE_SOF: /* Looking for SOF */
0148         if (ch == CHAR_SOF)
0149             rx->state = STATE_ID; /* Next byte is the id and len */
0150         break;
0151     case STATE_ID: /* Looking for id and len byte */
0152         rx->id = (ch & 0xf0) >> 4;
0153         rx->len = (ch & 0x0f);
0154         rx->index = 0;
0155         rx->chksum = ch;
0156         rx->state = (rx->len > 0) ? STATE_DATA : STATE_CHKSUM;
0157         break;
0158     case STATE_DATA: /* Looking for 'len' data bytes */
0159         rx->chksum += ch;
0160         rx->buf[rx->index] = ch;
0161         if (++rx->index == rx->len)
0162             rx->state = STATE_CHKSUM;
0163         break;
0164     case STATE_CHKSUM: /* Looking for the checksum */
0165         if (ch == rx->chksum)
0166             micro_rx_msg(micro, rx->id, rx->len, rx->buf);
0167         rx->state = STATE_SOF;
0168         break;
0169     }
0170 }
0171
0172 static void micro_rx_chars(struct ipaq_micro *micro)
0173 {
0174     u32 status, ch;
0175
0176     while ((status = readl(micro->base + UTSR1)) & UTSR1_RNE) {
0177         ch = readl(micro->base + UTDR);
0178         if (status & UTSR1_PRE)
0179             dev_err(micro->dev, "rx: parity error\n");
0180         else if (status & UTSR1_FRE)
0181             dev_err(micro->dev, "rx: framing error\n");
0182         else if (status & UTSR1_ROR)
0183             dev_err(micro->dev, "rx: overrun error\n");
0184         micro_process_char(micro, ch);
0185     }
0186 }
0187
0188 static void ipaq_micro_get_version(struct ipaq_micro *micro)
0189 {
0190     struct ipaq_micro_msg msg = {
0191         .id = MSG_VERSION,
0192     };
0193
0194     ipaq_micro_tx_msg_sync(micro, &msg);
0195     if (msg.rx_len == 4) {
0196         memcpy(micro->version, msg.rx_data, 4);
0197         micro->version[4] = '\0';
0198     } else if (msg.rx_len == 9) {
0199         memcpy(micro->version, msg.rx_data, 4);
0200         micro->version[4] = '\0';
0201         /* Bytes 4-7 are "pack", byte 8 is "boot type" */
0202     } else {
0203         dev_err(micro->dev,
0204             "illegal version message %d bytes\n", msg.rx_len);
0205     }
0206 }
0207
0208 static void ipaq_micro_eeprom_read(struct ipaq_micro *micro,
0209                    u8 address, u8 len, u8 *data)
0210 {
0211     struct ipaq_micro_msg msg = {
0212         .id = MSG_EEPROM_READ,
0213     };
0214     u8 i;
0215
0216     for (i = 0; i < len; i++) {
0217         msg.tx_data[0] = address + i;
0218         msg.tx_data[1] = 1;
0219         msg.tx_len = 2;
0220         ipaq_micro_tx_msg_sync(micro, &msg);
0221         memcpy(data + (i * 2), msg.rx_data, 2);
0222     }
0223 }
0224
0225 static char *ipaq_micro_str(u8 *wchar, u8 len)
0226 {
0227     char retstr[256];
0228     u8 i;
0229
0230     for (i = 0; i < len / 2; i++)
0231         retstr[i] = wchar[i * 2];
0232     return kstrdup(retstr, GFP_KERNEL);
0233 }
0234
0235 static u16 ipaq_micro_to_u16(u8 *data)
0236 {
0237     return data[1] << 8 | data[0];
0238 }
0239
0240 static void __init ipaq_micro_eeprom_dump(struct ipaq_micro *micro)
0241 {
0242     u8 dump[256];
0243     char *str;
0244
0245     ipaq_micro_eeprom_read(micro, 0, 128, dump);
0246     str = ipaq_micro_str(dump, 10);
0247     if (str) {
0248         dev_info(micro->dev, "HW version %s\n", str);
0249         kfree(str);
0250     }
0251     str = ipaq_micro_str(dump+10, 40);
0252     if (str) {
0253         dev_info(micro->dev, "serial number: %s\n", str);
0254         /* Feed the random pool with this */
0255         add_device_randomness(str, strlen(str));
0256         kfree(str);
0257     }
0258     str = ipaq_micro_str(dump+50, 20);
0259     if (str) {
0260         dev_info(micro->dev, "module ID: %s\n", str);
0261         kfree(str);
0262     }
0263     str = ipaq_micro_str(dump+70, 10);
0264     if (str) {
0265         dev_info(micro->dev, "product revision: %s\n", str);
0266         kfree(str);
0267     }
0268     dev_info(micro->dev, "product ID: %u\n", ipaq_micro_to_u16(dump+80));
0269     dev_info(micro->dev, "frame rate: %u fps\n",
0270          ipaq_micro_to_u16(dump+82));
0271     dev_info(micro->dev, "page mode: %u\n", ipaq_micro_to_u16(dump+84));
0272     dev_info(micro->dev, "country ID: %u\n", ipaq_micro_to_u16(dump+86));
0273     dev_info(micro->dev, "color display: %s\n",
0274          ipaq_micro_to_u16(dump+88) ? "yes" : "no");
0275     dev_info(micro->dev, "ROM size: %u MiB\n", ipaq_micro_to_u16(dump+90));
0276     dev_info(micro->dev, "RAM size: %u KiB\n", ipaq_micro_to_u16(dump+92));
0277     dev_info(micro->dev, "screen: %u x %u\n",
0278          ipaq_micro_to_u16(dump+94), ipaq_micro_to_u16(dump+96));
0279 }
0280
0281 static void micro_tx_chars(struct ipaq_micro *micro)
0282 {
0283     struct ipaq_micro_txdev *tx = &micro->tx;
0284     u32 val;
0285
0286     while ((tx->index < tx->len) &&
0287            (readl(micro->base + UTSR1) & UTSR1_TNF)) {
0288         writel(tx->buf[tx->index], micro->base + UTDR);
0289         tx->index++;
0290     }
0291
0292     /* Stop interrupts */
0293     val = readl(micro->base + UTCR3);
0294     val &= ~UTCR3_TIE;
0295     writel(val, micro->base + UTCR3);
0296 }
0297
0298 static void micro_reset_comm(struct ipaq_micro *micro)
0299 {
0300     struct ipaq_micro_rxdev *rx = &micro->rx;
0301     u32 val;
0302
0303     if (micro->msg)
0304         complete(&micro->msg->ack);
0305
0306     /* Initialize Serial channel protocol frame */
0307     rx->state = STATE_SOF;  /* Reset the state machine */
0308
0309     /* Set up interrupts */
0310     writel(0x01, micro->sdlc + 0x0); /* Select UART mode */
0311
0312     /* Clean up CR3 */
0313     writel(0x0, micro->base + UTCR3);
0314
0315     /* Format: 8N1 */
0316     writel(UTCR0_8BitData | UTCR0_1StpBit, micro->base + UTCR0);
0317
0318     /* Baud rate: 115200 */
0319     writel(0x0, micro->base + UTCR1);
0320     writel(0x1, micro->base + UTCR2);
0321
0322     /* Clear SR0 */
0323     writel(0xff, micro->base + UTSR0);
0324
0325     /* Enable RX int, disable TX int */
0326     writel(UTCR3_TXE | UTCR3_RXE | UTCR3_RIE, micro->base + UTCR3);
0327     val = readl(micro->base + UTCR3);
0328     val &= ~UTCR3_TIE;
0329     writel(val, micro->base + UTCR3);
0330 }
0331
0332 static irqreturn_t micro_serial_isr(int irq, void *dev_id)
0333 {
0334     struct ipaq_micro *micro = dev_id;
0335     struct ipaq_micro_txdev *tx = &micro->tx;
0336     u32 status;
0337
0338     status = readl(micro->base + UTSR0);
0339     do {
0340         if (status & (UTSR0_RID | UTSR0_RFS)) {
0341             if (status & UTSR0_RID)
0342                 /* Clear the Receiver IDLE bit */
0343                 writel(UTSR0_RID, micro->base + UTSR0);
0344             micro_rx_chars(micro);
0345         }
0346
0347         /* Clear break bits */
0348         if (status & (UTSR0_RBB | UTSR0_REB))
0349             writel(status & (UTSR0_RBB | UTSR0_REB),
0350                    micro->base + UTSR0);
0351
0352         if (status & UTSR0_TFS)
0353             micro_tx_chars(micro);
0354
0355         status = readl(micro->base + UTSR0);
0356
0357     } while (((tx->index < tx->len) && (status & UTSR0_TFS)) ||
0358          (status & (UTSR0_RFS | UTSR0_RID)));
0359
0360     return IRQ_HANDLED;
0361 }
0362
0363 static const struct mfd_cell micro_cells[] = {
0364     { .name = "ipaq-micro-backlight", },
0365     { .name = "ipaq-micro-battery", },
0366     { .name = "ipaq-micro-keys", },
0367     { .name = "ipaq-micro-ts", },
0368     { .name = "ipaq-micro-leds", },
0369 };
0370
0371 static int __maybe_unused micro_resume(struct device *dev)
0372 {
0373     struct ipaq_micro *micro = dev_get_drvdata(dev);
0374
0375     micro_reset_comm(micro);
0376     mdelay(10);
0377
0378     return 0;
0379 }
0380
0381 static int __init micro_probe(struct platform_device *pdev)
0382 {
0383     struct ipaq_micro *micro;
0384     struct resource *res;
0385     int ret;
0386     int irq;
0387
0388     micro = devm_kzalloc(&pdev->dev, sizeof(*micro), GFP_KERNEL);
0389     if (!micro)
0390         return -ENOMEM;
0391
0392     micro->dev = &pdev->dev;
0393
0394     res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
0395     micro->base = devm_ioremap_resource(&pdev->dev, res);
0396     if (IS_ERR(micro->base))
0397         return PTR_ERR(micro->base);
0398
0399     micro->sdlc = devm_platform_ioremap_resource(pdev, 1);
0400     if (IS_ERR(micro->sdlc))
0401         return PTR_ERR(micro->sdlc);
0402
0403     micro_reset_comm(micro);
0404
0405     irq = platform_get_irq(pdev, 0);
0406     if (irq < 0)
0407         return -EINVAL;
0408     ret = devm_request_irq(&pdev->dev, irq, micro_serial_isr,
0409                    IRQF_SHARED, "ipaq-micro",
0410                    micro);
0411     if (ret) {
0412         dev_err(&pdev->dev, "unable to grab serial port IRQ\n");
0413         return ret;
0414     } else
0415         dev_info(&pdev->dev, "grabbed serial port IRQ\n");
0416
0417     spin_lock_init(&micro->lock);
0418     INIT_LIST_HEAD(&micro->queue);
0419     platform_set_drvdata(pdev, micro);
0420
0421     ret = mfd_add_devices(&pdev->dev, pdev->id, micro_cells,
0422                   ARRAY_SIZE(micro_cells), NULL, 0, NULL);
0423     if (ret) {
0424         dev_err(&pdev->dev, "error adding MFD cells");
0425         return ret;
0426     }
0427
0428     /* Check version */
0429     ipaq_micro_get_version(micro);
0430     dev_info(&pdev->dev, "Atmel micro ASIC version %s\n", micro->version);
0431     ipaq_micro_eeprom_dump(micro);
0432
0433     return 0;
0434 }
0435
0436 static const struct dev_pm_ops micro_dev_pm_ops = {
0437     SET_SYSTEM_SLEEP_PM_OPS(NULL, micro_resume)
0438 };
0439
0440 static struct platform_driver micro_device_driver = {
0441     .driver   = {
0442         .name   = "ipaq-h3xxx-micro",
0443         .pm = &micro_dev_pm_ops,
0444         .suppress_bind_attrs = true,
0445     },
0446 };
0447 builtin_platform_driver_probe(micro_device_driver, micro_probe);