drivers/pcmcia/pxa2xx_sharpsl.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Sharp SL-C7xx Series PCMCIA routines
0004  *
0005  * Copyright (c) 2004-2005 Richard Purdie
0006  *
0007  * Based on Sharp's 2.4 kernel patches and pxa2xx_mainstone.c
0008  */
0009
0010 #include <linux/module.h>
0011 #include <linux/init.h>
0012 #include <linux/kernel.h>
0013 #include <linux/errno.h>
0014 #include <linux/interrupt.h>
0015 #include <linux/platform_device.h>
0016
0017 #include <asm/mach-types.h>
0018 #include <asm/irq.h>
0019 #include <asm/hardware/scoop.h>
0020
0021 #include <pcmcia/soc_common.h>
0022
0023 #define NO_KEEP_VS 0x0001
0024 #define SCOOP_DEV platform_scoop_config->devs
0025
0026 static void sharpsl_pcmcia_init_reset(struct soc_pcmcia_socket *skt)
0027 {
0028     struct scoop_pcmcia_dev *scoopdev = &SCOOP_DEV[skt->nr];
0029
0030     reset_scoop(scoopdev->dev);
0031
0032     /* Shared power controls need to be handled carefully */
0033     if (platform_scoop_config->power_ctrl)
0034         platform_scoop_config->power_ctrl(scoopdev->dev, 0x0000, skt->nr);
0035     else
0036         write_scoop_reg(scoopdev->dev, SCOOP_CPR, 0x0000);
0037
0038     scoopdev->keep_vs = NO_KEEP_VS;
0039     scoopdev->keep_rd = 0;
0040 }
0041
0042 static int sharpsl_pcmcia_hw_init(struct soc_pcmcia_socket *skt)
0043 {
0044     if (SCOOP_DEV[skt->nr].cd_irq >= 0) {
0045         skt->stat[SOC_STAT_CD].irq = SCOOP_DEV[skt->nr].cd_irq;
0046         skt->stat[SOC_STAT_CD].name = SCOOP_DEV[skt->nr].cd_irq_str;
0047     }
0048
0049     skt->socket.pci_irq = SCOOP_DEV[skt->nr].irq;
0050
0051     return 0;
0052 }
0053
0054 static void sharpsl_pcmcia_socket_state(struct soc_pcmcia_socket *skt,
0055                     struct pcmcia_state *state)
0056 {
0057     unsigned short cpr, csr;
0058     struct device *scoop = SCOOP_DEV[skt->nr].dev;
0059
0060     cpr = read_scoop_reg(SCOOP_DEV[skt->nr].dev, SCOOP_CPR);
0061
0062     write_scoop_reg(scoop, SCOOP_IRM, 0x00FF);
0063     write_scoop_reg(scoop, SCOOP_ISR, 0x0000);
0064     write_scoop_reg(scoop, SCOOP_IRM, 0x0000);
0065     csr = read_scoop_reg(scoop, SCOOP_CSR);
0066     if (csr & 0x0004) {
0067         /* card eject */
0068         write_scoop_reg(scoop, SCOOP_CDR, 0x0000);
0069         SCOOP_DEV[skt->nr].keep_vs = NO_KEEP_VS;
0070     }
0071     else if (!(SCOOP_DEV[skt->nr].keep_vs & NO_KEEP_VS)) {
0072         /* keep vs1,vs2 */
0073         write_scoop_reg(scoop, SCOOP_CDR, 0x0000);
0074         csr |= SCOOP_DEV[skt->nr].keep_vs;
0075     }
0076     else if (cpr & 0x0003) {
0077         /* power on */
0078         write_scoop_reg(scoop, SCOOP_CDR, 0x0000);
0079         SCOOP_DEV[skt->nr].keep_vs = (csr & 0x00C0);
0080     }
0081     else {
0082         /* card detect */
0083             if ((machine_is_spitz() || machine_is_borzoi()) && skt->nr == 1) {
0084                     write_scoop_reg(scoop, SCOOP_CDR, 0x0000);
0085             } else {
0086                 write_scoop_reg(scoop, SCOOP_CDR, 0x0002);
0087             }
0088     }
0089
0090     state->detect = (csr & 0x0004) ? 0 : 1;
0091     state->ready  = (csr & 0x0002) ? 1 : 0;
0092     state->bvd1   = (csr & 0x0010) ? 1 : 0;
0093     state->bvd2   = (csr & 0x0020) ? 1 : 0;
0094     state->wrprot = (csr & 0x0008) ? 1 : 0;
0095     state->vs_3v  = (csr & 0x0040) ? 0 : 1;
0096     state->vs_Xv  = (csr & 0x0080) ? 0 : 1;
0097
0098     if ((cpr & 0x0080) && ((cpr & 0x8040) != 0x8040)) {
0099         printk(KERN_ERR "sharpsl_pcmcia_socket_state(): CPR=%04X, Low voltage!\n", cpr);
0100     }
0101 }
0102
0103
0104 static int sharpsl_pcmcia_configure_socket(struct soc_pcmcia_socket *skt,
0105                        const socket_state_t *state)
0106 {
0107     unsigned long flags;
0108     struct device *scoop = SCOOP_DEV[skt->nr].dev;
0109
0110     unsigned short cpr, ncpr, ccr, nccr, mcr, nmcr, imr, nimr;
0111
0112     switch (state->Vcc) {
0113     case    0:      break;
0114     case    33:     break;
0115     case    50:     break;
0116     default:
0117          printk(KERN_ERR "sharpsl_pcmcia_configure_socket(): bad Vcc %u\n", state->Vcc);
0118          return -1;
0119     }
0120
0121     if ((state->Vpp!=state->Vcc) && (state->Vpp!=0)) {
0122         printk(KERN_ERR "CF slot cannot support Vpp %u\n", state->Vpp);
0123         return -1;
0124     }
0125
0126     local_irq_save(flags);
0127
0128     nmcr = (mcr = read_scoop_reg(scoop, SCOOP_MCR)) & ~0x0010;
0129     ncpr = (cpr = read_scoop_reg(scoop, SCOOP_CPR)) & ~0x0083;
0130     nccr = (ccr = read_scoop_reg(scoop, SCOOP_CCR)) & ~0x0080;
0131     nimr = (imr = read_scoop_reg(scoop, SCOOP_IMR)) & ~0x003E;
0132
0133     if ((machine_is_spitz() || machine_is_borzoi() || machine_is_akita()) && skt->nr == 0) {
0134             ncpr |= (state->Vcc == 33) ? 0x0002 :
0135                 (state->Vcc == 50) ? 0x0002 : 0;
0136     } else {
0137             ncpr |= (state->Vcc == 33) ? 0x0001 :
0138                 (state->Vcc == 50) ? 0x0002 : 0;
0139     }
0140     nmcr |= (state->flags&SS_IOCARD) ? 0x0010 : 0;
0141     ncpr |= (state->flags&SS_OUTPUT_ENA) ? 0x0080 : 0;
0142     nccr |= (state->flags&SS_RESET)? 0x0080: 0;
0143     nimr |= ((skt->status&SS_DETECT) ? 0x0004 : 0)|
0144             ((skt->status&SS_READY)  ? 0x0002 : 0)|
0145             ((skt->status&SS_BATDEAD)? 0x0010 : 0)|
0146             ((skt->status&SS_BATWARN)? 0x0020 : 0)|
0147             ((skt->status&SS_STSCHG) ? 0x0010 : 0)|
0148             ((skt->status&SS_WRPROT) ? 0x0008 : 0);
0149
0150     if (!(ncpr & 0x0003)) {
0151         SCOOP_DEV[skt->nr].keep_rd = 0;
0152     } else if (!SCOOP_DEV[skt->nr].keep_rd) {
0153         if (nccr & 0x0080)
0154             SCOOP_DEV[skt->nr].keep_rd = 1;
0155         else
0156             nccr |= 0x0080;
0157     }
0158
0159     if (mcr != nmcr)
0160         write_scoop_reg(scoop, SCOOP_MCR, nmcr);
0161     if (cpr != ncpr) {
0162         if (platform_scoop_config->power_ctrl)
0163             platform_scoop_config->power_ctrl(scoop, ncpr , skt->nr);
0164         else
0165                 write_scoop_reg(scoop, SCOOP_CPR, ncpr);
0166     }
0167     if (ccr != nccr)
0168         write_scoop_reg(scoop, SCOOP_CCR, nccr);
0169     if (imr != nimr)
0170         write_scoop_reg(scoop, SCOOP_IMR, nimr);
0171
0172     local_irq_restore(flags);
0173
0174     return 0;
0175 }
0176
0177 static void sharpsl_pcmcia_socket_init(struct soc_pcmcia_socket *skt)
0178 {
0179     sharpsl_pcmcia_init_reset(skt);
0180
0181     /* Enable interrupt */
0182     write_scoop_reg(SCOOP_DEV[skt->nr].dev, SCOOP_IMR, 0x00C0);
0183     write_scoop_reg(SCOOP_DEV[skt->nr].dev, SCOOP_MCR, 0x0101);
0184     SCOOP_DEV[skt->nr].keep_vs = NO_KEEP_VS;
0185 }
0186
0187 static void sharpsl_pcmcia_socket_suspend(struct soc_pcmcia_socket *skt)
0188 {
0189     sharpsl_pcmcia_init_reset(skt);
0190 }
0191
0192 static struct pcmcia_low_level sharpsl_pcmcia_ops = {
0193     .owner                  = THIS_MODULE,
0194     .hw_init                = sharpsl_pcmcia_hw_init,
0195     .socket_state           = sharpsl_pcmcia_socket_state,
0196     .configure_socket       = sharpsl_pcmcia_configure_socket,
0197     .socket_init            = sharpsl_pcmcia_socket_init,
0198     .socket_suspend         = sharpsl_pcmcia_socket_suspend,
0199     .first                  = 0,
0200     .nr                     = 0,
0201 };
0202
0203 #ifdef CONFIG_SA1100_COLLIE
0204 #include "sa11xx_base.h"
0205
0206 int pcmcia_collie_init(struct device *dev)
0207 {
0208        int ret = -ENODEV;
0209
0210        if (machine_is_collie())
0211                ret = sa11xx_drv_pcmcia_probe(dev, &sharpsl_pcmcia_ops, 0, 1);
0212
0213        return ret;
0214 }
0215
0216 #else
0217
0218 static struct platform_device *sharpsl_pcmcia_device;
0219
0220 static int __init sharpsl_pcmcia_init(void)
0221 {
0222     int ret;
0223
0224     if (!platform_scoop_config)
0225         return -ENODEV;
0226
0227     sharpsl_pcmcia_ops.nr = platform_scoop_config->num_devs;
0228     sharpsl_pcmcia_device = platform_device_alloc("pxa2xx-pcmcia", -1);
0229
0230     if (!sharpsl_pcmcia_device)
0231         return -ENOMEM;
0232
0233     ret = platform_device_add_data(sharpsl_pcmcia_device,
0234             &sharpsl_pcmcia_ops, sizeof(sharpsl_pcmcia_ops));
0235     if (ret == 0) {
0236         sharpsl_pcmcia_device->dev.parent = platform_scoop_config->devs[0].dev;
0237         ret = platform_device_add(sharpsl_pcmcia_device);
0238     }
0239
0240     if (ret)
0241         platform_device_put(sharpsl_pcmcia_device);
0242
0243     return ret;
0244 }
0245
0246 static void __exit sharpsl_pcmcia_exit(void)
0247 {
0248     platform_device_unregister(sharpsl_pcmcia_device);
0249 }
0250
0251 fs_initcall(sharpsl_pcmcia_init);
0252 module_exit(sharpsl_pcmcia_exit);
0253 #endif
0254
0255 MODULE_DESCRIPTION("Sharp SL Series PCMCIA Support");
0256 MODULE_LICENSE("GPL");
0257 MODULE_ALIAS("platform:pxa2xx-pcmcia");