sys/arch/arm/sa11x0/sa11xx_pcic.c

   1 /*      $NetBSD: sa11xx_pcic.c,v 1.12 2008/06/03 13:45:22 rafal Exp $   */
   2
   3 /*
   4  * Copyright (c) 2001 IWAMOTO Toshihiro.  All rights reserved.
   5  * Copyright (c) 1997 Marc Horowitz.  All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. All advertising materials mentioning features or use of this software
  16  *    must display the following acknowledgement:
  17  *      This product includes software developed by Marc Horowitz.
  18  * 4. The name of the author may not be used to endorse or promote products
  19  *    derived from this software without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  22  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  23  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  24  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  25  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  26  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  27  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  28  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  29  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  30  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31  */
  32
  33 /*
  34  * Common code for SA-11x0 based PCMCIA modules.
  35  */
  36
  37 #include <sys/cdefs.h>
  38 __KERNEL_RCSID(0, "$NetBSD: sa11xx_pcic.c,v 1.12 2008/06/03 13:45:22 rafal Exp $");
  39
  40 #include <sys/types.h>
  41 #include <sys/param.h>
  42 #include <sys/systm.h>
  43 #include <sys/device.h>
  44 #include <sys/callout.h>
  45 #include <sys/kernel.h>
  46 #include <sys/kthread.h>
  47 #include <sys/malloc.h>
  48 #include <sys/bus.h>
  49 #include <sys/intr.h>
  50
  51 #include <uvm/uvm.h>
  52
  53 #include <dev/pcmcia/pcmciareg.h>
  54 #include <dev/pcmcia/pcmciavar.h>
  55 #include <dev/pcmcia/pcmciachip.h>
  56
  57 #include <arm/sa11x0/sa11x0_reg.h>
  58 #include <arm/sa11x0/sa11x0_var.h>
  59 #include <arm/sa11x0/sa11xx_pcicreg.h>
  60 #include <arm/sa11x0/sa11xx_pcicvar.h>
  61
  62 static  int     sapcic_mem_alloc(pcmcia_chipset_handle_t, bus_size_t,
  63                                         struct pcmcia_mem_handle *);
  64 static  void    sapcic_mem_free(pcmcia_chipset_handle_t,
  65                                        struct pcmcia_mem_handle *);
  66 static  int     sapcic_mem_map(pcmcia_chipset_handle_t, int, bus_addr_t,
  67                                       bus_size_t, struct pcmcia_mem_handle *,
  68                                       bus_addr_t *, int *);
  69 static  void    sapcic_mem_unmap(pcmcia_chipset_handle_t, int);
  70 static  int     sapcic_io_alloc(pcmcia_chipset_handle_t, bus_addr_t,
  71                                        bus_size_t, bus_size_t,
  72                                        struct pcmcia_io_handle *);
  73 static  void    sapcic_io_free(pcmcia_chipset_handle_t,
  74                                       struct pcmcia_io_handle *);
  75 static  int     sapcic_io_map(pcmcia_chipset_handle_t, int,
  76                                      bus_addr_t, bus_size_t,
  77                                      struct pcmcia_io_handle *, int *);
  78 static  void    sapcic_io_unmap(pcmcia_chipset_handle_t, int);
  79 static  void    *sapcic_intr_establish(pcmcia_chipset_handle_t,
  80                                               struct pcmcia_function *, int,
  81                                               int (*)(void *), void *);
  82 static  void    sapcic_intr_disestablish(pcmcia_chipset_handle_t,
  83                                                 void *);
  84 static  void    sapcic_socket_enable(pcmcia_chipset_handle_t);
  85 static  void    sapcic_socket_disable(pcmcia_chipset_handle_t);
  86 static  void    sapcic_socket_settype(pcmcia_chipset_handle_t, int);
  87
  88 static  void    sapcic_event_thread(void *);
  89
  90 static  void    sapcic_delay(int, const char *);
  91
  92 #ifdef DEBUG
  93 #define DPRINTF(arg)    aprint_normal arg
  94 #else
  95 #define DPRINTF(arg)
  96 #endif
  97
  98 struct pcmcia_chip_functions sa11x0_pcmcia_functions = {
  99         sapcic_mem_alloc,
 100         sapcic_mem_free,
 101         sapcic_mem_map,
 102         sapcic_mem_unmap,
 103
 104         sapcic_io_alloc,
 105         sapcic_io_free,
 106         sapcic_io_map,
 107         sapcic_io_unmap,
 108
 109         sapcic_intr_establish,
 110         sapcic_intr_disestablish,
 111
 112         sapcic_socket_enable,
 113         sapcic_socket_disable,
 114         sapcic_socket_settype,
 115 };
 116
 117
 118 void
 119 sapcic_kthread_create(void *arg)
 120 {
 121         struct sapcic_socket *so = arg;
 122
 123         /* XXX attach card if already present */
 124
 125         so->laststatus = (so->pcictag->read)(so, SAPCIC_STATUS_CARD);
 126         if (so->laststatus == SAPCIC_CARD_VALID) {
 127                 aprint_normal_dev(so->sc->sc_dev, "card present\n");
 128                 pcmcia_card_attach(so->pcmcia);
 129         }
 130
 131         if (kthread_create(PRI_NONE, 0, NULL, sapcic_event_thread, so,
 132             &so->event_thread, "%s,%d", device_xname(so->sc->sc_dev), so->socket)) {
 133                 aprint_normal_dev(so->sc->sc_dev, "unable to create event thread for socket %d\n",
 134                        so->socket);
 135                 panic("sapcic_kthread_create");
 136         }
 137 }
 138
 139 static void
 140 sapcic_event_thread(void *arg)
 141 {
 142         struct sapcic_socket *so = arg;
 143         int newstatus, s;
 144
 145         while (so->shutdown == 0) {
 146                 /*
 147                  * Serialize event processing on the PCIC.  We may
 148                  * sleep while we hold this lock.
 149                  */
 150                 mutex_enter(&so->sc->sc_lock);
 151
 152                 /* sleep .25s to be enqueued chatterling interrupts */
 153                 (void) tsleep(sapcic_event_thread, PWAIT, "pcicss", hz / 4);
 154
 155                 s = splhigh();
 156                 so->event = 0;
 157
 158                 /* we don't rely on interrupt type */
 159                 newstatus = (so->pcictag->read)(so, SAPCIC_STATUS_CARD);
 160                 splx(s);
 161
 162                 if (so->laststatus == newstatus) {
 163                         /*
 164                          * No events to process; release the PCIC lock.
 165                          */
 166                         mutex_exit(&so->sc->sc_lock);
 167                         (void) tsleep(&so->event, PWAIT, "pcicev", hz);
 168                         continue;
 169                 }
 170
 171                 so->laststatus = newstatus;
 172                 switch (newstatus) {
 173                 case SAPCIC_CARD_VALID:
 174                         aprint_normal_dev(so->sc->sc_dev, "insertion event\n");
 175
 176                         pcmcia_card_attach(so->pcmcia);
 177                         break;
 178
 179                 case SAPCIC_CARD_INVALID:
 180                         aprint_normal_dev(so->sc->sc_dev, "removal event\n");
 181
 182                         pcmcia_card_detach(so->pcmcia, DETACH_FORCE);
 183                         break;
 184
 185                 default:
 186                         panic("sapcic_event_thread: unknown status %d",
 187                             newstatus);
 188                 }
 189
 190                 mutex_exit(&so->sc->sc_lock);
 191         }
 192
 193         so->event_thread = NULL;
 194
 195         /* In case parent is waiting for us to exit. */
 196         wakeup(so->sc);
 197
 198         kthread_exit(0);
 199 }
 200
 201 static void
 202 sapcic_delay(int timo, const char *wmesg)
 203 {
 204 #ifdef DIAGNOSTIC
 205         if (curlwp == NULL)
 206                 panic("sapcic_delay: called in interrupt context");
 207 #endif
 208
 209         tsleep(sapcic_delay, PWAIT, wmesg, roundup(timo * hz, 1000) / 1000);
 210 }
 211
 212 int
 213 sapcic_intr(void *arg)
 214 {
 215         struct sapcic_socket *so = arg;
 216
 217         so->event++;
 218         (so->pcictag->clear_intr)(so->socket);
 219         wakeup(&so->event);
 220         return 1;
 221 }
 222
 223 static int
 224 sapcic_mem_alloc(pcmcia_chipset_handle_t pch, bus_size_t size,
 225     struct pcmcia_mem_handle *pmh)
 226 {
 227         struct sapcic_socket *so = pch;
 228
 229         /* All we need is bus space tag */
 230         memset(pmh, 0, sizeof(*pmh));
 231         pmh->memt = so->sc->sc_iot;
 232         return 0;
 233 }
 234
 235
 236 static void
 237 sapcic_mem_free(pcmcia_chipset_handle_t pch, struct pcmcia_mem_handle *pmh)
 238 {
 239 }
 240
 241 static int
 242 sapcic_mem_map(pcmcia_chipset_handle_t pch, int kind, bus_addr_t card_addr,
 243     bus_size_t size, struct pcmcia_mem_handle *pmh, bus_addr_t *offsetp,
 244     int *windowp)
 245 {
 246         struct sapcic_socket *so = pch;
 247         int error;
 248         bus_addr_t pa;
 249
 250         pa = trunc_page(card_addr);
 251         *offsetp = card_addr - pa;
 252         size = round_page(card_addr + size) - pa;
 253         pmh->realsize = size;
 254
 255         pa += SAPCIC_BASE_OFFSET;
 256         pa += SAPCIC_SOCKET_OFFSET * so->socket;
 257
 258         switch (kind & ~PCMCIA_WIDTH_MEM_MASK) {
 259         case PCMCIA_MEM_ATTR:
 260                 pa += SAPCIC_ATTR_OFFSET;
 261                 break;
 262         case PCMCIA_MEM_COMMON:
 263                 pa += SAPCIC_COMMON_OFFSET;
 264                 break;
 265         default:
 266                 panic("sapcic_mem_map: bogus kind");
 267         }
 268
 269         error = bus_space_map(so->sc->sc_iot, pa, size, 0, &pmh->memh);
 270         if (!error)
 271                 *windowp = (int)pmh->memh;
 272         return error;
 273 }
 274
 275 static void
 276 sapcic_mem_unmap(pcmcia_chipset_handle_t pch, int window)
 277 {
 278         struct sapcic_socket *so = pch;
 279
 280         bus_space_unmap(so->sc->sc_iot, (bus_addr_t)window, 4096); /* XXX */
 281 }
 282
 283 static int
 284 sapcic_io_alloc(pcmcia_chipset_handle_t pch, bus_addr_t start,
 285     bus_size_t size, bus_size_t align, struct pcmcia_io_handle *pih)
 286 {
 287         struct sapcic_socket *so = pch;
 288         int error;
 289         bus_addr_t pa;
 290
 291         memset(pih, 0, sizeof(*pih));
 292         pih->iot = so->sc->sc_iot;
 293         pih->addr = start;
 294         pih->size = size;
 295
 296         pa = pih->addr;
 297         pa += SAPCIC_BASE_OFFSET;
 298         pa += SAPCIC_SOCKET_OFFSET * so->socket;
 299
 300         DPRINTF(("sapcic_io_alloc: %x %x\n", (unsigned int)pa,
 301                  (unsigned int)size));
 302         /* XXX Are we ignoring alignment constraints? */
 303         error = bus_space_map(so->sc->sc_iot, pa, size, 0, &pih->ioh);
 304
 305         return error;
 306 }
 307
 308 static void
 309 sapcic_io_free(pcmcia_chipset_handle_t pch, struct pcmcia_io_handle *pih)
 310 {
 311         struct sapcic_socket *so = pch;
 312
 313         bus_space_unmap(so->sc->sc_iot, pih->ioh, pih->size);
 314 }
 315
 316 static int
 317 sapcic_io_map(pcmcia_chipset_handle_t pch, int width, bus_addr_t offset,
 318     bus_size_t size, struct pcmcia_io_handle *pih, int *windowp)
 319 {
 320
 321         return 0;
 322 }
 323
 324 static void sapcic_io_unmap(pcmcia_chipset_handle_t pch, int window)
 325 {
 326 }
 327
 328 static void *
 329 sapcic_intr_establish(pcmcia_chipset_handle_t pch, struct pcmcia_function *pf,
 330     int ipl, int (*fct)(void *), void *arg)
 331 {
 332         struct sapcic_socket *so = pch;
 333
 334         /* XXX need to check if something should be done here */
 335
 336         return (so->pcictag->intr_establish)(so, ipl, fct, arg);
 337 }
 338
 339 static void
 340 sapcic_intr_disestablish(pcmcia_chipset_handle_t pch, void *ih)
 341 {
 342         struct sapcic_socket *so = pch;
 343
 344         (so->pcictag->intr_disestablish)(so, ih);
 345 }
 346
 347 static void
 348 sapcic_socket_enable(pcmcia_chipset_handle_t pch)
 349 {
 350         struct sapcic_socket *so = pch;
 351         int i;
 352
 353 #if defined(DIAGNOSTIC) && defined(notyet)
 354         if (so->flags & PCIC_FLAG_ENABLED)
 355                 aprint_normal("sapcic_socket_enable: enabling twice\n");
 356 #endif
 357
 358         /* disable interrupts */
 359
 360         /* power down the socket to reset it, clear the card reset pin */
 361         (so->pcictag->set_power)(so, SAPCIC_POWER_OFF);
 362
 363         /*
 364          * wait 300ms until power fails (Tpf).  Then, wait 100ms since
 365          * we are changing Vcc (Toff).
 366          */
 367         sapcic_delay(300 + 100, "pccen0");
 368
 369         /* power up the socket */
 370         /* XXX voltage selection should be done in PCMCIA code */
 371         if (so->power_capability & SAPCIC_POWER_5V) {
 372                 (so->pcictag->set_power)(so, SAPCIC_POWER_5V);
 373                 (so->pcictag->write)(so, SAPCIC_CONTROL_POWERSELECT,
 374                                      SAPCIC_POWER_5V);
 375         } else {
 376                 (so->pcictag->set_power)(so, SAPCIC_POWER_3V);
 377                 (so->pcictag->write)(so, SAPCIC_CONTROL_POWERSELECT,
 378                                      SAPCIC_POWER_3V);
 379         }
 380
 381         /* enable PCMCIA control lines */
 382         (so->pcictag->write)(so, SAPCIC_CONTROL_LINEENABLE, 1);
 383
 384         /*
 385          * wait 100ms until power raise (Tpr) and 20ms to become
 386          * stable (Tsu(Vcc)).
 387          *
 388          * some machines require some more time to be settled
 389          * (300ms is added here).
 390          */
 391         sapcic_delay(100 + 20 + 300, "pccen1");
 392
 393         /* honor nWAIT signal */
 394         (so->pcictag->write)(so, SAPCIC_CONTROL_WAITENABLE, 1);
 395         /* now make sure we have reset# active */
 396         (so->pcictag->write)(so, SAPCIC_CONTROL_RESET, 1);
 397
 398         /*
 399          * hold RESET at least 10us, this is a min allow for slop in
 400          * delay routine.
 401          */
 402         delay(20);
 403
 404         /* clear the reset flag */
 405         (so->pcictag->write)(so, SAPCIC_CONTROL_RESET, 0);
 406
 407         /* wait 20ms as per pc card standard (r2.01) section 4.3.6 */
 408         sapcic_delay(20, "pccen2");
 409
 410         /* wait for the chip to finish initializing */
 411         sapcic_delay(10, "pccen3");
 412         for (i = 100; i; i--) {
 413                 if ((so->pcictag->read)(so, SAPCIC_STATUS_READY))
 414                         break;
 415                 sapcic_delay(100, "pccen4");
 416         }
 417         DPRINTF(("sapcic_socket_enable: wait ready %d\n", 100 - i));
 418
 419         /* finally enable the interrupt */
 420
 421 }
 422
 423 static void
 424 sapcic_socket_disable(pcmcia_chipset_handle_t pch)
 425 {
 426         struct sapcic_socket *so = pch;
 427
 428         /* XXX mask card interrupts */
 429
 430         /* power down the card */
 431         (so->pcictag->set_power)(so, SAPCIC_POWER_OFF);
 432
 433         /* float controller lines */
 434         (so->pcictag->write)(so, SAPCIC_CONTROL_LINEENABLE, 0);
 435 }
 436
 437 static void
 438 sapcic_socket_settype(pcmcia_chipset_handle_t pch, int type)
 439 {
 440
 441         /* XXX nothing to do */
 442 }