开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
pxa.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：38k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

pxa.c：源码内容
  1. /*
  2.  * linux/drivers/pcmcia/pxa/pxa.c
  3.  *
  4.  * Author: George Davis
  5.  * Created: Jan 10, 2002
  6.  * Copyright: MontaVista Software Inc.
  7.  * 
  8.  * This program is free software; you can redistribute it and/or modify
  9.  * it under the terms of the GNU General Public License version 2 as
  10.  * published by the Free Software Foundation.
  11.  *
  12.  * Originally based upon linux/drivers/pcmcia/sa1100_generic.c
  13.  *
  14.  */
  16. /*======================================================================
  18.     Device driver for the PCMCIA control functionality of Intel
  19.     PXA250/210 microprocessors.
  21.     The contents of this file are subject to the Mozilla Public
  22.     License Version 1.1 (the "License"); you may not use this file
  23.     except in compliance with the License. You may obtain a copy of
  24.     the License at http://www.mozilla.org/MPL/
  26.     Software distributed under the License is distributed on an "AS
  27.     IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  28.     implied. See the License for the specific language governing
  29.     rights and limitations under the License.
  31.     The initial developer of the original code is John G. Dorsey
  32.     <john+@cs.cmu.edu>.  Portions created by John G. Dorsey are
  33.     Copyright (C) 1999 John G. Dorsey.  All Rights Reserved.
  35.     Alternatively, the contents of this file may be used under the
  36.     terms of the GNU Public License version 2 (the "GPL"), in which
  37.     case the provisions of the GPL are applicable instead of the
  38.     above.  If you wish to allow the use of your version of this file
  39.     only under the terms of the GPL and not to allow others to use
  40.     your version of this file under the MPL, indicate your decision
  41.     by deleting the provisions above and replace them with the notice
  42.     and other provisions required by the GPL.  If you do not delete
  43.     the provisions above, a recipient may use your version of this
  44.     file under either the MPL or the GPL.
  45.     
  46. ======================================================================*/
  48. #include <linux/module.h>
  49. #include <linux/init.h>
  50. #include <linux/config.h>
  51. #include <linux/cpufreq.h>
  52. #include <linux/delay.h>
  53. #include <linux/ioport.h>
  54. #include <linux/kernel.h>
  55. #include <linux/tqueue.h>
  56. #include <linux/timer.h>
  57. #include <linux/mm.h>
  58. #include <linux/notifier.h>
  59. #include <linux/proc_fs.h>
  60. #include <linux/version.h>
  61. #include <linux/cpufreq.h>
  63. #include <pcmcia/version.h>
  64. #include <pcmcia/cs_types.h>
  65. #include <pcmcia/cs.h>
  66. #include <pcmcia/ss.h>
  67. #include <pcmcia/bus_ops.h>
  69. #include <asm/hardware.h>
  70. #include <asm/io.h>
  71. #include <asm/irq.h>
  72. #include <asm/system.h>
  73. #include <asm/arch/lubbock.h>
  75. #include "pxa.h"
  77. #ifdef PCMCIA_DEBUG
  78. static int pc_debug;
  79. #endif
  81. MODULE_AUTHOR("George Davis <davis_g@mvista.com>");
  82. MODULE_DESCRIPTION("Linux PCMCIA Card Services: PXA250/210 Socket Controller");
  84. /* This structure maintains housekeeping state for each socket, such
  85.  * as the last known values of the card detect pins, or the Card Services
  86.  * callback value associated with the socket:
  87.  */
  88. static struct pxa_pcmcia_socket 
  89. pxa_pcmcia_socket[PXA_PCMCIA_MAX_SOCK];
  91. static int pxa_pcmcia_socket_count;
  94. /* Returned by the low-level PCMCIA interface: */
  95. static struct pcmcia_low_level *pcmcia_low_level;
  97. /* Event poll timer structure */
  98. static struct timer_list poll_timer;
  101. /* Prototypes for routines which are used internally: */
  103. static int  pxa_pcmcia_driver_init(void);
  104. static void pxa_pcmcia_driver_shutdown(void);
  105. static void pxa_pcmcia_task_handler(void *data);
  106. static void pxa_pcmcia_poll_event(unsigned long data);
  107. static void pxa_pcmcia_interrupt(int irq, void *dev,
  108.     struct pt_regs *regs);
  109. static struct tq_struct pxa_pcmcia_task;
  111. #ifdef CONFIG_PROC_FS
  112. static int  pxa_pcmcia_proc_status(char *buf, char **start, off_t pos,
  113.       int count, int *eof, void *data);
  114. #endif
  117. /* Prototypes for operations which are exported to the
  118.  * new-and-impr^H^H^H^H^H^H^H^H^H^H in-kernel PCMCIA core:
  119.  */
  121. static int pxa_pcmcia_init(unsigned int sock);
  122. static int pxa_pcmcia_suspend(unsigned int sock);
  123. static int pxa_pcmcia_register_callback(unsigned int sock,
  124.    void (*handler)(void *, 
  125.    unsigned int),
  126.    void *info);
  127. static int pxa_pcmcia_inquire_socket(unsigned int sock, 
  128. socket_cap_t *cap);
  129. static int pxa_pcmcia_get_status(unsigned int sock, u_int *value);
  130. static int pxa_pcmcia_get_socket(unsigned int sock, 
  131.     socket_state_t *state);
  132. static int pxa_pcmcia_set_socket(unsigned int sock,
  133.     socket_state_t *state);
  134. static int pxa_pcmcia_get_io_map(unsigned int sock,
  135.     struct pccard_io_map *io);
  136. static int pxa_pcmcia_set_io_map(unsigned int sock,
  137.     struct pccard_io_map *io);
  138. static int pxa_pcmcia_get_mem_map(unsigned int sock,
  139.      struct pccard_mem_map *mem);
  140. static int pxa_pcmcia_set_mem_map(unsigned int sock,
  141.      struct pccard_mem_map *mem);
  142. #ifdef CONFIG_PROC_FS
  143. static void pxa_pcmcia_proc_setup(unsigned int sock,
  144.      struct proc_dir_entry *base);
  145. #endif
  147. static struct pccard_operations pxa_pcmcia_operations = {
  148.   pxa_pcmcia_init,
  149.   pxa_pcmcia_suspend,
  150.   pxa_pcmcia_register_callback,
  151.   pxa_pcmcia_inquire_socket,
  152.   pxa_pcmcia_get_status,
  153.   pxa_pcmcia_get_socket,
  154.   pxa_pcmcia_set_socket,
  155.   pxa_pcmcia_get_io_map,
  156.   pxa_pcmcia_set_io_map,
  157.   pxa_pcmcia_get_mem_map,
  158.   pxa_pcmcia_set_mem_map,
  159. #ifdef CONFIG_PROC_FS
  160.   pxa_pcmcia_proc_setup
  161. #endif
  162. };
  164. #ifdef CONFIG_CPU_FREQ
  165. /* forward declaration */
  166. static struct notifier_block pxa_pcmcia_notifier_block;
  167. #endif
  170. /* pxa_pcmcia_driver_init()
  171.  * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
  172.  *
  173.  * This routine performs a basic sanity check to ensure that this
  174.  * kernel has been built with the appropriate board-specific low-level
  175.  * PCMCIA support, performs low-level PCMCIA initialization, registers
  176.  * this socket driver with Card Services, and then spawns the daemon
  177.  * thread which is the real workhorse of the socket driver.
  178.  *
  179.  * Please see linux/Documentation/arm/SA1100/PCMCIA for more information
  180.  * on the low-level kernel interface.
  181.  *
  182.  * Returns: 0 on success, -1 on error
  183.  */
  184. static int __init pxa_pcmcia_driver_init(void){
  185.   servinfo_t info;
  186.   struct pcmcia_init pcmcia_init;
  187.   struct pcmcia_state state[PXA_PCMCIA_MAX_SOCK];
  188.   struct pcmcia_state_array state_array;
  189.   unsigned int i, clock;
  190.   unsigned long mecr;
  192.   printk(KERN_INFO "Intel PXA250/210 PCMCIA (CS release %s)n", CS_RELEASE);
  194.   CardServices(GetCardServicesInfo, &info);
  196.   if(info.Revision!=CS_RELEASE_CODE){
  197.     printk(KERN_ERR "Card Services release codes do not matchn");
  198.     return -1;
  199.   }
  201.   /* Setup GPIOs for PCMCIA/CF alternate function mode.
  202.    *
  203.    * It would be nice if set_GPIO_mode included support
  204.    * for driving GPIO outputs to default high/low state
  205.    * before programming GPIOs as outputs. Setting GPIO
  206.    * outputs to default high/low state via GPSR/GPCR
  207.    * before defining them as outputs should reduce
  208.    * the possibility of glitching outputs during GPIO
  209.    * setup. This of course assumes external terminators
  210.    * are present to hold GPIOs in a defined state.
  211.    *
  212.    * In the meantime, setup default state of GPIO
  213.    * outputs before we enable them as outputs.
  214.    */
  216.   GPSR(GPIO48_nPOE) = GPIO_bit(GPIO48_nPOE) |
  217.                       GPIO_bit(GPIO49_nPWE) |
  218.                       GPIO_bit(GPIO50_nPIOR) |
  219.                       GPIO_bit(GPIO51_nPIOW) |
  220.                       GPIO_bit(GPIO52_nPCE_1) |
  221.                       GPIO_bit(GPIO53_nPCE_2);
  223.   set_GPIO_mode(GPIO48_nPOE_MD);
  224.   set_GPIO_mode(GPIO49_nPWE_MD);
  225.   set_GPIO_mode(GPIO50_nPIOR_MD);
  226.   set_GPIO_mode(GPIO51_nPIOW_MD);
  227.   set_GPIO_mode(GPIO52_nPCE_1_MD);
  228.   set_GPIO_mode(GPIO53_nPCE_2_MD);
  229.   set_GPIO_mode(GPIO54_pSKTSEL_MD); /* REVISIT: s/b dependent on num sockets */
  230.   set_GPIO_mode(GPIO55_nPREG_MD);
  231.   set_GPIO_mode(GPIO56_nPWAIT_MD);
  232.   set_GPIO_mode(GPIO57_nIOIS16_MD);
  235.   if(machine_is_lubbock()){
  236. #ifdef CONFIG_ARCH_LUBBOCK
  237.     pcmcia_low_level=&lubbock_pcmcia_ops;
  238. #endif
  239.   } else if (machine_is_pxa_idp()) {
  240.     pcmcia_low_level=&pxa_idp_pcmcia_ops;
  241.   } else if( machine_is_pxa_cerf()){
  242.     pcmcia_low_level=&cerf_pcmcia_ops;
  243.   }
  245.   if (!pcmcia_low_level) {
  246.     printk(KERN_ERR "This hardware is not supported by the PXA250/210 Card Service drivern");
  247.     return -ENODEV;
  248.   }
  250.   pcmcia_init.handler=pxa_pcmcia_interrupt;
  252.   if((pxa_pcmcia_socket_count=pcmcia_low_level->init(&pcmcia_init))<0){
  253.     printk(KERN_ERR "Unable to initialize kernel PCMCIA service.n");
  254.     return -EIO;
  255.   }
  257.   state_array.size=pxa_pcmcia_socket_count;
  258.   state_array.state=state;
  260.   /* Configure MECR based on the number of sockets present. */
  261.   if (pxa_pcmcia_socket_count == 2) {
  262.     MECR |= GPIO_bit(0);
  263.   } else {
  264.     MECR &= ~GPIO_bit(0);
  265.   }
  267.   if(pcmcia_low_level->socket_state(&state_array)<0){
  268.     printk(KERN_ERR "Unable to get PCMCIA status from kernel.n");
  269.     return -EIO;
  270.   }
  272.   /* Well, it looks good to go. So we can now enable the PCMCIA
  273.    * controller.
  274.    */
  275.   MECR |= GPIO_bit(1);
  277.   /* We need to initialize the MCXX registers to default values
  278.    * here because we're not guaranteed to see a SetIOMap operation
  279.    * at runtime.
  280.    */
  282.   clock = get_lclk_frequency_10khz();
  284.   for(i=0; i<pxa_pcmcia_socket_count; ++i){
  285.     pxa_pcmcia_socket[i].k_state=state[i];
  287.     /* This is an interim fix. Apparently, SetSocket is no longer
  288.      * called to initialize each socket (prior to the first detect
  289.      * event). For now, we'll just manually set up the mask.
  290.      */
  291.     pxa_pcmcia_socket[i].cs_state.csc_mask=SS_DETECT;
  293.     pxa_pcmcia_socket[i].virt_io=(i==0)?PCMCIA_IO_0_BASE:PCMCIA_IO_1_BASE;
  294.     pxa_pcmcia_socket[i].phys_attr=_PCMCIAAttr(i);
  295.     pxa_pcmcia_socket[i].phys_mem=_PCMCIAMem(i);
  297.     /* REVISIT: cleanup these macros */
  298.     //MCIO_SET(i, PXA_PCMCIA_IO_ACCESS, clock);
  299.     //MCATTR_SET(i, PXA_PCMCIA_5V_MEM_ACCESS, clock);
  300.     //MCMEM_SET(i, PXA_PCMCIA_5V_MEM_ACCESS, clock);
  302.     pxa_pcmcia_socket[i].speed_io=PXA_PCMCIA_IO_ACCESS;
  303.     pxa_pcmcia_socket[i].speed_attr=PXA_PCMCIA_5V_MEM_ACCESS;
  304.     pxa_pcmcia_socket[i].speed_mem=PXA_PCMCIA_5V_MEM_ACCESS;
  305.   }
  307. /* REVISIT: cleanup these macros */
  308. MCMEM0 = ((pxa_mcxx_setup(PXA_PCMCIA_5V_MEM_ACCESS, clock)
  309. & MCXX_SETUP_MASK) << MCXX_SETUP_SHIFT)
  310.        | ((pxa_mcxx_asst(PXA_PCMCIA_5V_MEM_ACCESS, clock)
  311. & MCXX_ASST_MASK) << MCXX_ASST_SHIFT)
  312.        | ((pxa_mcxx_hold(PXA_PCMCIA_5V_MEM_ACCESS, clock)
  313. & MCXX_HOLD_MASK) << MCXX_HOLD_SHIFT);
  314. MCMEM1 = ((pxa_mcxx_setup(PXA_PCMCIA_5V_MEM_ACCESS, clock)
  315. & MCXX_SETUP_MASK) << MCXX_SETUP_SHIFT)
  316.        | ((pxa_mcxx_asst(PXA_PCMCIA_5V_MEM_ACCESS, clock)
  317. & MCXX_ASST_MASK) << MCXX_ASST_SHIFT)
  318.        | ((pxa_mcxx_hold(PXA_PCMCIA_5V_MEM_ACCESS, clock)
  319. & MCXX_HOLD_MASK) << MCXX_HOLD_SHIFT);
  320. MCATT0 = ((pxa_mcxx_setup(PXA_PCMCIA_5V_MEM_ACCESS, clock)
  321. & MCXX_SETUP_MASK) << MCXX_SETUP_SHIFT)
  322.        | ((pxa_mcxx_asst(PXA_PCMCIA_5V_MEM_ACCESS, clock)
  323. & MCXX_ASST_MASK) << MCXX_ASST_SHIFT)
  324.        | ((pxa_mcxx_hold(PXA_PCMCIA_5V_MEM_ACCESS, clock)
  325. & MCXX_HOLD_MASK) << MCXX_HOLD_SHIFT);
  326. MCATT1 = ((pxa_mcxx_setup(PXA_PCMCIA_5V_MEM_ACCESS, clock)
  327. & MCXX_SETUP_MASK) << MCXX_SETUP_SHIFT)
  328.        | ((pxa_mcxx_asst(PXA_PCMCIA_5V_MEM_ACCESS, clock)
  329. & MCXX_ASST_MASK) << MCXX_ASST_SHIFT)
  330.        | ((pxa_mcxx_hold(PXA_PCMCIA_5V_MEM_ACCESS, clock)
  331. & MCXX_HOLD_MASK) << MCXX_HOLD_SHIFT);
  332. MCIO0 = ((pxa_mcxx_setup(PXA_PCMCIA_IO_ACCESS, clock)
  333. & MCXX_SETUP_MASK) << MCXX_SETUP_SHIFT)
  334.        | ((pxa_mcxx_asst(PXA_PCMCIA_IO_ACCESS, clock)
  335. & MCXX_ASST_MASK) << MCXX_ASST_SHIFT)
  336.        | ((pxa_mcxx_hold(PXA_PCMCIA_IO_ACCESS, clock)
  337. & MCXX_HOLD_MASK) << MCXX_HOLD_SHIFT);
  338. MCIO1 = ((pxa_mcxx_setup(PXA_PCMCIA_IO_ACCESS, clock)
  339. & MCXX_SETUP_MASK) << MCXX_SETUP_SHIFT)
  340.        | ((pxa_mcxx_asst(PXA_PCMCIA_IO_ACCESS, clock)
  341. & MCXX_ASST_MASK) << MCXX_ASST_SHIFT)
  342.        | ((pxa_mcxx_hold(PXA_PCMCIA_IO_ACCESS, clock)
  343. & MCXX_HOLD_MASK) << MCXX_HOLD_SHIFT);
  345. #ifdef CONFIG_CPU_FREQ
  346.   if(cpufreq_register_notifier(&pxa_pcmcia_notifier_block) < 0){
  347.     printk(KERN_ERR "Unable to register CPU frequency change notifiern");
  348.     return -ENXIO;
  349.   }
  350. #endif
  352.   /* Only advertise as many sockets as we can detect: */
  353.   if(register_ss_entry(pxa_pcmcia_socket_count, 
  354.        &pxa_pcmcia_operations)<0){
  355.     printk(KERN_ERR "Unable to register socket service routinen");
  356.     return -ENXIO;
  357.   }
  359.   /* Start the event poll timer.  It will reschedule by itself afterwards. */
  360.   pxa_pcmcia_poll_event(0);
  362.   DEBUG(1, "pxa_cs: initialization completen");
  364.   return 0;
  366. }  /* pxa_pcmcia_driver_init() */
  368. module_init(pxa_pcmcia_driver_init);
  371. /* pxa_pcmcia_driver_shutdown()
  372.  * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  373.  * Invokes the low-level kernel service to free IRQs associated with this
  374.  * socket controller and reset GPIO edge detection.
  375.  */
  376. static void __exit pxa_pcmcia_driver_shutdown(void){
  378.   del_timer_sync(&poll_timer);
  379.   unregister_ss_entry(&pxa_pcmcia_operations);
  380. #ifdef CONFIG_CPU_FREQ
  381.   cpufreq_unregister_notifier(&pxa_pcmcia_notifier_block);
  382. #endif
  383.   pcmcia_low_level->shutdown();
  384.   flush_scheduled_tasks();
  386.   DEBUG(1, "pxa_cs: shutdown completen");
  387. }
  389. module_exit(pxa_pcmcia_driver_shutdown);
  392. /* pxa_pcmcia_init()
  393.  * ^^^^^^^^^^^^^^^^^^^^
  394.  * We perform all of the interesting initialization tasks in 
  395.  * pxa_pcmcia_driver_init().
  396.  *
  397.  * Returns: 0
  398.  */
  399. static int pxa_pcmcia_init(unsigned int sock){
  400.   
  401.   DEBUG(2, "%s(): initializing socket %un", __FUNCTION__, sock);
  403.   return 0;
  404. }
  407. /* pxa_pcmcia_suspend()
  408.  * ^^^^^^^^^^^^^^^^^^^^^^^
  409.  * We don't currently perform any actions on a suspend.
  410.  *
  411.  * Returns: 0
  412.  */
  413. static int pxa_pcmcia_suspend(unsigned int sock)
  414. {
  415.   struct pcmcia_configure conf;
  416.   int ret;
  418.   DEBUG(2, "%s(): suspending socket %un", __FUNCTION__, sock);
  420.   conf.sock = sock;
  421.   conf.vcc = 0;
  422.   conf.vpp = 0;
  423.   conf.output = 0;
  424.   conf.speaker = 0;
  425.   conf.reset = 1;
  427.   ret = pcmcia_low_level->configure_socket(&conf);
  429.   if (ret == 0)
  430.     pxa_pcmcia_socket[sock].cs_state = dead_socket;
  432.   return ret;
  433. }
  436. /* pxa_pcmcia_events()
  437.  * ^^^^^^^^^^^^^^^^^^^^^^
  438.  * Helper routine to generate a Card Services event mask based on
  439.  * state information obtained from the kernel low-level PCMCIA layer
  440.  * in a recent (and previous) sampling. Updates `prev_state'.
  441.  *
  442.  * Returns: an event mask for the given socket state.
  443.  */
  444. static inline unsigned pxa_pcmcia_events(struct pcmcia_state *state,
  445.     struct pcmcia_state *prev_state,
  446.     unsigned int mask,
  447.     unsigned int flags){
  448.   unsigned int events=0;
  450.   if(state->detect!=prev_state->detect){
  452.     DEBUG(2, "%s(): card detect value %un", __FUNCTION__, state->detect);
  454.     events|=mask&SS_DETECT;
  455.   }
  457.   if(state->ready!=prev_state->ready){
  459.     DEBUG(2, "%s(): card ready value %un", __FUNCTION__, state->ready);
  461.     events|=mask&((flags&SS_IOCARD)?0:SS_READY);
  462.   }
  464.   if(state->bvd1!=prev_state->bvd1){
  466.     DEBUG(2, "%s(): card BVD1 value %un", __FUNCTION__, state->bvd1);
  468.     events|=mask&(flags&SS_IOCARD)?SS_STSCHG:SS_BATDEAD;
  469.   }
  471.   if(state->bvd2!=prev_state->bvd2){
  473.     DEBUG(2, "%s(): card BVD2 value %un", __FUNCTION__, state->bvd2);
  475.     events|=mask&(flags&SS_IOCARD)?0:SS_BATWARN;
  476.   }
  478.   DEBUG(2, "events: %s%s%s%s%s%sn",
  479. (events==0)?"<NONE>":"",
  480. (events&SS_DETECT)?"DETECT ":"",
  481. (events&SS_READY)?"READY ":"",
  482. (events&SS_BATDEAD)?"BATDEAD ":"",
  483. (events&SS_BATWARN)?"BATWARN ":"",
  484. (events&SS_STSCHG)?"STSCHG ":"");
  486.   *prev_state=*state;
  488.   return events;
  490. }  /* pxa_pcmcia_events() */
  493. /* pxa_pcmcia_task_handler()
  494.  * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  495.  * Processes serviceable socket events using the "eventd" thread context.
  496.  *
  497.  * Event processing (specifically, the invocation of the Card Services event
  498.  * callback) occurs in this thread rather than in the actual interrupt
  499.  * handler due to the use of scheduling operations in the PCMCIA core.
  500.  */
  501. static void pxa_pcmcia_task_handler(void *data) {
  502.   struct pcmcia_state state[PXA_PCMCIA_MAX_SOCK];
  503.   struct pcmcia_state_array state_array;
  504.   int i, events, all_events, irq_status;
  506.   DEBUG(2, "%s(): entering PCMCIA monitoring threadn", __FUNCTION__);
  508.   state_array.size=pxa_pcmcia_socket_count;
  509.   state_array.state=state;
  511.   do {
  513.     DEBUG(3, "%s(): interrogating low-level PCMCIA servicen", __FUNCTION__);
  515.     if((irq_status=pcmcia_low_level->socket_state(&state_array))<0)
  516.       printk(KERN_ERR "Error in kernel low-level PCMCIA service.n");
  518.     all_events=0;
  520.     if(irq_status>0){
  522.       for(i=0; i<state_array.size; ++i, all_events|=events)
  523. if((events=
  524.     pxa_pcmcia_events(&state[i],
  525.  &pxa_pcmcia_socket[i].k_state,
  526.  pxa_pcmcia_socket[i].cs_state.csc_mask,
  527.  pxa_pcmcia_socket[i].cs_state.flags)))
  528.   if(pxa_pcmcia_socket[i].handler!=NULL)
  529.     pxa_pcmcia_socket[i].handler(pxa_pcmcia_socket[i].handler_info,
  530.     events);
  531.     }
  533.   } while(all_events);
  534. }  /* pxa_pcmcia_task_handler() */
  536. static struct tq_struct pxa_pcmcia_task = {
  537. routine: pxa_pcmcia_task_handler
  538. };
  541. /* pxa_pcmcia_poll_event()
  542.  * ^^^^^^^^^^^^^^^^^^^^^^^^^^
  543.  * Let's poll for events in addition to IRQs since IRQ only is unreliable...
  544.  */
  545. static void pxa_pcmcia_poll_event(unsigned long dummy)
  546. {
  547.   DEBUG(3, "%s(): polling for eventsn", __FUNCTION__);
  548.   poll_timer.function = pxa_pcmcia_poll_event;
  549.   poll_timer.expires = jiffies + PXA_PCMCIA_POLL_PERIOD;
  550.   add_timer(&poll_timer);
  551.   schedule_task(&pxa_pcmcia_task);
  552. }
  555. /* pxa_pcmcia_interrupt()
  556.  * ^^^^^^^^^^^^^^^^^^^^^^^^^
  557.  * Service routine for socket driver interrupts (requested by the
  558.  * low-level PCMCIA init() operation via pxa_pcmcia_thread()).
  559.  * The actual interrupt-servicing work is performed by
  560.  * pxa_pcmcia_thread(), largely because the Card Services event-
  561.  * handling code performs scheduling operations which cannot be
  562.  * executed from within an interrupt context.
  563.  */
  564. static void pxa_pcmcia_interrupt(int irq, void *dev, struct pt_regs *regs){
  565.   DEBUG(3, "%s(): servicing IRQ %dn", __FUNCTION__, irq);
  566.   schedule_task(&pxa_pcmcia_task);
  567. }
  570. /* pxa_pcmcia_register_callback()
  571.  * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  572.  * Implements the register_callback() operation for the in-kernel
  573.  * PCMCIA service (formerly SS_RegisterCallback in Card Services). If 
  574.  * the function pointer `handler' is not NULL, remember the callback 
  575.  * location in the state for `sock', and increment the usage counter 
  576.  * for the driver module. (The callback is invoked from the interrupt
  577.  * service routine, pxa_pcmcia_interrupt(), to notify Card Services
  578.  * of interesting events.) Otherwise, clear the callback pointer in the
  579.  * socket state and decrement the module usage count.
  580.  *
  581.  * Returns: 0
  582.  */
  583. static int pxa_pcmcia_register_callback(unsigned int sock,
  584.    void (*handler)(void *,
  585.    unsigned int),
  586.    void *info){
  587.   if(handler==NULL){
  588.     pxa_pcmcia_socket[sock].handler=NULL;
  589.     MOD_DEC_USE_COUNT;
  590.   } else {
  591.     MOD_INC_USE_COUNT;
  592.     pxa_pcmcia_socket[sock].handler=handler;
  593.     pxa_pcmcia_socket[sock].handler_info=info;
  594.   }
  596.   return 0;
  597. }
  600. /* pxa_pcmcia_inquire_socket()
  601.  * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  602.  * Implements the inquire_socket() operation for the in-kernel PCMCIA
  603.  * service (formerly SS_InquireSocket in Card Services). Of note is
  604.  * the setting of the SS_CAP_PAGE_REGS bit in the `features' field of
  605.  * `cap' to "trick" Card Services into tolerating large "I/O memory" 
  606.  * addresses. Also set is SS_CAP_STATIC_MAP, which disables the memory
  607.  * resource database check. (Mapped memory is set up within the socket
  608.  * driver itself.)
  609.  *
  610.  * In conjunction with the STATIC_MAP capability is a new field,
  611.  * `io_offset', recommended by David Hinds. Rather than go through
  612.  * the SetIOMap interface (which is not quite suited for communicating
  613.  * window locations up from the socket driver), we just pass up
  614.  * an offset which is applied to client-requested base I/O addresses
  615.  * in alloc_io_space().
  616.  *
  617.  * Returns: 0 on success, -1 if no pin has been configured for `sock'
  618.  */
  619. static int pxa_pcmcia_inquire_socket(unsigned int sock,
  620. socket_cap_t *cap){
  621.   struct pcmcia_irq_info irq_info;
  623.   DEBUG(3, "%s() for sock %un", __FUNCTION__, sock);
  625.   if(sock>=pxa_pcmcia_socket_count){
  626.     printk(KERN_ERR "pxa_cs: socket %u not configuredn", sock);
  627.     return -1;
  628.   }
  630.   /* SS_CAP_PAGE_REGS: used by setup_cis_mem() in cistpl.c to set the
  631.    *   force_low argument to validate_mem() in rsrc_mgr.c -- since in
  632.    *   general, the mapped * addresses of the PCMCIA memory regions
  633.    *   will not be within 0xffff, setting force_low would be
  634.    *   undesirable.
  635.    *
  636.    * SS_CAP_STATIC_MAP: don't bother with the (user-configured) memory
  637.    *   resource database; we instead pass up physical address ranges
  638.    *   and allow other parts of Card Services to deal with remapping.
  639.    *
  640.    * SS_CAP_PCCARD: we can deal with 16-bit PCMCIA & CF cards, but
  641.    *   not 32-bit CardBus devices.
  642.    */
  643.   cap->features=(SS_CAP_PAGE_REGS  | SS_CAP_STATIC_MAP | SS_CAP_PCCARD);
  645.   irq_info.sock=sock;
  646.   irq_info.irq=-1;
  648.   if(pcmcia_low_level->get_irq_info(&irq_info)<0){
  649.     printk(KERN_ERR "Error obtaining IRQ info from kernel for socket %un",
  650.    sock);
  651.     return -1;
  652.   }
  654.   cap->irq_mask=0;
  655.   cap->map_size=PAGE_SIZE;
  656.   cap->pci_irq=irq_info.irq;
  657.   cap->io_offset=pxa_pcmcia_socket[sock].virt_io;
  659.   return 0;
  661. }  /* pxa_pcmcia_inquire_socket() */
  664. /* pxa_pcmcia_get_status()
  665.  * ^^^^^^^^^^^^^^^^^^^^^^^^^^
  666.  * Implements the get_status() operation for the in-kernel PCMCIA
  667.  * service (formerly SS_GetStatus in Card Services). Essentially just
  668.  * fills in bits in `status' according to internal driver state or
  669.  * the value of the voltage detect chipselect register.
  670.  *
  671.  * As a debugging note, during card startup, the PCMCIA core issues
  672.  * three set_socket() commands in a row the first with RESET deasserted,
  673.  * the second with RESET asserted, and the last with RESET deasserted
  674.  * again. Following the third set_socket(), a get_status() command will
  675.  * be issued. The kernel is looking for the SS_READY flag (see
  676.  * setup_socket(), reset_socket(), and unreset_socket() in cs.c).
  677.  *
  678.  * Returns: 0
  679.  */
  680. static int pxa_pcmcia_get_status(unsigned int sock,
  681.     unsigned int *status){
  682.   struct pcmcia_state state[PXA_PCMCIA_MAX_SOCK];
  683.   struct pcmcia_state_array state_array;
  685.   DEBUG(3, "%s() for sock %un", __FUNCTION__, sock);
  687.   state_array.size=pxa_pcmcia_socket_count;
  688.   state_array.state=state;
  690.   if((pcmcia_low_level->socket_state(&state_array))<0){
  691.     printk(KERN_ERR "Unable to get PCMCIA status from kernel.n");
  692.     return -1;
  693.   }
  695.   pxa_pcmcia_socket[sock].k_state=state[sock];
  697.   *status=state[sock].detect?SS_DETECT:0;
  699.   *status|=state[sock].ready?SS_READY:0;
  701.   /* The power status of individual sockets is not available
  702.    * explicitly from the hardware, so we just remember the state
  703.    * and regurgitate it upon request:
  704.    */
  705.   *status|=pxa_pcmcia_socket[sock].cs_state.Vcc?SS_POWERON:0;
  707.   if(pxa_pcmcia_socket[sock].cs_state.flags&SS_IOCARD)
  708.     *status|=state[sock].bvd1?SS_STSCHG:0;
  709.   else {
  710.     if(state[sock].bvd1==0)
  711.       *status|=SS_BATDEAD;
  712.     else if(state[sock].bvd2==0)
  713.       *status|=SS_BATWARN;
  714.   }
  716.   *status|=state[sock].vs_3v?SS_3VCARD:0;
  718.   *status|=state[sock].vs_Xv?SS_XVCARD:0;
  720.   DEBUG(3, "tstatus: %s%s%s%s%s%s%s%sn",
  721. (*status&SS_DETECT)?"DETECT ":"",
  722. (*status&SS_READY)?"READY ":"", 
  723. (*status&SS_BATDEAD)?"BATDEAD ":"",
  724. (*status&SS_BATWARN)?"BATWARN ":"",
  725. (*status&SS_POWERON)?"POWERON ":"",
  726. (*status&SS_STSCHG)?"STSCHG ":"",
  727. (*status&SS_3VCARD)?"3VCARD ":"",
  728. (*status&SS_XVCARD)?"XVCARD ":"");
  730.   return 0;
  732. }  /* pxa_pcmcia_get_status() */
  735. /* pxa_pcmcia_get_socket()
  736.  * ^^^^^^^^^^^^^^^^^^^^^^^^^^
  737.  * Implements the get_socket() operation for the in-kernel PCMCIA
  738.  * service (formerly SS_GetSocket in Card Services). Not a very 
  739.  * exciting routine.
  740.  *
  741.  * Returns: 0
  742.  */
  743. static int pxa_pcmcia_get_socket(unsigned int sock,
  744.     socket_state_t *state){
  746.   DEBUG(3, "%s() for sock %un", __FUNCTION__, sock);
  748.   /* This information was given to us in an earlier call to set_socket(),
  749.    * so we're just regurgitating it here:
  750.    */
  751.   *state=pxa_pcmcia_socket[sock].cs_state;
  753.   return 0;
  754. }
  757. /* pxa_pcmcia_set_socket()
  758.  * ^^^^^^^^^^^^^^^^^^^^^^^^^^
  759.  * Implements the set_socket() operation for the in-kernel PCMCIA
  760.  * service (formerly SS_SetSocket in Card Services). We more or
  761.  * less punt all of this work and let the kernel handle the details
  762.  * of power configuration, reset, &c. We also record the value of
  763.  * `state' in order to regurgitate it to the PCMCIA core later.
  764.  *
  765.  * Returns: 0
  766.  */
  767. static int pxa_pcmcia_set_socket(unsigned int sock,
  768.     socket_state_t *state){
  769.   struct pcmcia_configure configure;
  771.   DEBUG(3, "%s() for sock %un", __FUNCTION__, sock);
  773.   DEBUG(3, "tmask:  %s%s%s%s%s%sntflags: %s%s%s%s%s%sn"
  774. "tVcc %d  Vpp %d  irq %dn",
  775. (state->csc_mask==0)?"<NONE>":"",
  776. (state->csc_mask&SS_DETECT)?"DETECT ":"",
  777. (state->csc_mask&SS_READY)?"READY ":"",
  778. (state->csc_mask&SS_BATDEAD)?"BATDEAD ":"",
  779. (state->csc_mask&SS_BATWARN)?"BATWARN ":"",
  780. (state->csc_mask&SS_STSCHG)?"STSCHG ":"",
  781. (state->flags==0)?"<NONE>":"",
  782. (state->flags&SS_PWR_AUTO)?"PWR_AUTO ":"",
  783. (state->flags&SS_IOCARD)?"IOCARD ":"",
  784. (state->flags&SS_RESET)?"RESET ":"",
  785. (state->flags&SS_SPKR_ENA)?"SPKR_ENA ":"",
  786. (state->flags&SS_OUTPUT_ENA)?"OUTPUT_ENA ":"",
  787. state->Vcc, state->Vpp, state->io_irq);
  789.   configure.sock=sock;
  790.   configure.vcc=state->Vcc;
  791.   configure.vpp=state->Vpp;
  792.   configure.output=(state->flags&SS_OUTPUT_ENA)?1:0;
  793.   configure.speaker=(state->flags&SS_SPKR_ENA)?1:0;
  794.   configure.reset=(state->flags&SS_RESET)?1:0;
  796.   if(pcmcia_low_level->configure_socket(&configure)<0){
  797.     printk(KERN_ERR "Unable to configure socket %un", sock);
  798.     return -1;
  799.   }
  801.   pxa_pcmcia_socket[sock].cs_state=*state;
  802.   
  803.   return 0;
  805. }  /* pxa_pcmcia_set_socket() */
  808. /* pxa_pcmcia_get_io_map()
  809.  * ^^^^^^^^^^^^^^^^^^^^^^^^^^
  810.  * Implements the get_io_map() operation for the in-kernel PCMCIA
  811.  * service (formerly SS_GetIOMap in Card Services). Just returns an
  812.  * I/O map descriptor which was assigned earlier by a set_io_map().
  813.  *
  814.  * Returns: 0 on success, -1 if the map index was out of range
  815.  */
  816. static int pxa_pcmcia_get_io_map(unsigned int sock,
  817.     struct pccard_io_map *map){
  819.   DEBUG(4, "%s() for sock %un", __FUNCTION__, sock);
  821.   if(map->map>=MAX_IO_WIN){
  822.     printk(KERN_ERR "%s(): map (%d) out of rangen", __FUNCTION__,
  823.    map->map);
  824.     return -1;
  825.   }
  827.   *map=pxa_pcmcia_socket[sock].io_map[map->map];
  829.   return 0;
  830. }
  833. /* pxa_pcmcia_set_io_map()
  834.  * ^^^^^^^^^^^^^^^^^^^^^^^^^^
  835.  * Implements the set_io_map() operation for the in-kernel PCMCIA
  836.  * service (formerly SS_SetIOMap in Card Services). We configure
  837.  * the map speed as requested, but override the address ranges
  838.  * supplied by Card Services.
  839.  *
  840.  * Returns: 0 on success, -1 on error
  841.  */
  842. static int pxa_pcmcia_set_io_map(unsigned int sock,
  843.     struct pccard_io_map *map){
  844.   unsigned int clock, speed;
  845.   unsigned long mecr, start;
  847.   DEBUG(4, "%s() for sock %un", __FUNCTION__, sock);
  849.   DEBUG(4, "tmap %u  speed %untstart 0x%08lx  stop 0x%08lxn"
  850. "tflags: %s%s%s%s%s%s%s%sn",
  851. map->map, map->speed, map->start, map->stop,
  852. (map->flags==0)?"<NONE>":"",
  853. (map->flags&MAP_ACTIVE)?"ACTIVE ":"",
  854. (map->flags&MAP_16BIT)?"16BIT ":"",
  855. (map->flags&MAP_AUTOSZ)?"AUTOSZ ":"",
  856. (map->flags&MAP_0WS)?"0WS ":"",
  857. (map->flags&MAP_WRPROT)?"WRPROT ":"",
  858. (map->flags&MAP_USE_WAIT)?"USE_WAIT ":"",
  859. (map->flags&MAP_PREFETCH)?"PREFETCH ":"");
  861.   if(map->map>=MAX_IO_WIN){
  862.     printk(KERN_ERR "%s(): map (%d) out of rangen", __FUNCTION__,
  863.    map->map);
  864.     return -1;
  865.   }
  867.   if(map->flags&MAP_ACTIVE){
  869.     speed=(map->speed>0)?map->speed:PXA_PCMCIA_IO_ACCESS;
  871.     clock = get_lclk_frequency_10khz();
  873.     pxa_pcmcia_socket[sock].speed_io=speed;
  875.     if (sock == 0) {
  876.       MCIO0 = ((pxa_mcxx_setup(speed, clock)
  877. & MCXX_SETUP_MASK) << MCXX_SETUP_SHIFT)
  878.             | ((pxa_mcxx_asst(speed, clock)
  879. & MCXX_ASST_MASK) << MCXX_ASST_SHIFT)
  880.             | ((pxa_mcxx_hold(speed, clock)
  881. & MCXX_HOLD_MASK) << MCXX_HOLD_SHIFT);
  882.     } else {
  883.       MCIO1 = ((pxa_mcxx_setup(speed, clock)
  884. & MCXX_SETUP_MASK) << MCXX_SETUP_SHIFT)
  885.             | ((pxa_mcxx_asst(speed, clock)
  886. & MCXX_ASST_MASK) << MCXX_ASST_SHIFT)
  887.             | ((pxa_mcxx_hold(speed, clock)
  888. & MCXX_HOLD_MASK) << MCXX_HOLD_SHIFT);
  889.     }
  891.     DEBUG(4, "%s(): FAST%u %lx  BSM%u %lx  BSA%u %lx  BSIO%u %lxn",
  892.   __FUNCTION__, sock, MECR_FAST_GET(mecr, sock), sock,
  893.   MECR_BSM_GET(mecr, sock), sock, MECR_BSA_GET(mecr, sock), 
  894.   sock, MECR_BSIO_GET(mecr, sock));
  896.   }
  898.   start=map->start;
  900.   if(map->stop==1)
  901.     map->stop=PAGE_SIZE-1;
  903.   map->start=pxa_pcmcia_socket[sock].virt_io;
  904.   map->stop=map->start+(map->stop-start);
  906.   pxa_pcmcia_socket[sock].io_map[map->map]=*map;
  908.   return 0;
  910. }  /* pxa_pcmcia_set_io_map() */
  913. /* pxa_pcmcia_get_mem_map()
  914.  * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
  915.  * Implements the get_mem_map() operation for the in-kernel PCMCIA
  916.  * service (formerly SS_GetMemMap in Card Services). Just returns a
  917.  *  memory map descriptor which was assigned earlier by a
  918.  *  set_mem_map() request.
  919.  *
  920.  * Returns: 0 on success, -1 if the map index was out of range
  921.  */
  922. static int pxa_pcmcia_get_mem_map(unsigned int sock,
  923.      struct pccard_mem_map *map){
  925.   DEBUG(4, "%s() for sock %un", __FUNCTION__, sock);
  927.   if(map->map>=MAX_WIN){
  928.     printk(KERN_ERR "%s(): map (%d) out of rangen", __FUNCTION__,
  929.    map->map);
  930.     return -1;
  931.   }
  933.   *map=pxa_pcmcia_socket[sock].mem_map[map->map];
  935.   return 0;
  936. }
  939. /* pxa_pcmcia_set_mem_map()
  940.  * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
  941.  * Implements the set_mem_map() operation for the in-kernel PCMCIA
  942.  * service (formerly SS_SetMemMap in Card Services). We configure
  943.  * the map speed as requested, but override the address ranges
  944.  * supplied by Card Services.
  945.  *
  946.  * Returns: 0 on success, -1 on error
  947.  */
  948. static int pxa_pcmcia_set_mem_map(unsigned int sock,
  949.      struct pccard_mem_map *map){
  950.   unsigned int clock, speed;
  951.   unsigned long mecr, start;
  953.   DEBUG(4, "%s() for sock %un", __FUNCTION__, sock);
  955.   DEBUG(4, "tmap %u  speed %untsys_start  %#lxn"
  956. "tsys_stop   %#lxntcard_start %#xn"
  957. "tflags: %s%s%s%s%s%s%s%sn",
  958. map->map, map->speed, map->sys_start, map->sys_stop,
  959. map->card_start, (map->flags==0)?"<NONE>":"",
  960. (map->flags&MAP_ACTIVE)?"ACTIVE ":"",
  961. (map->flags&MAP_16BIT)?"16BIT ":"",
  962. (map->flags&MAP_AUTOSZ)?"AUTOSZ ":"",
  963. (map->flags&MAP_0WS)?"0WS ":"",
  964. (map->flags&MAP_WRPROT)?"WRPROT ":"",
  965. (map->flags&MAP_ATTRIB)?"ATTRIB ":"",
  966. (map->flags&MAP_USE_WAIT)?"USE_WAIT ":"");
  968.   if(map->map>=MAX_WIN){
  969.     printk(KERN_ERR "%s(): map (%d) out of rangen", __FUNCTION__,
  970.    map->map);
  971.     return -1;
  972.   }
  974.   if(map->flags&MAP_ACTIVE){
  975.     /* When clients issue RequestMap, the access speed is not always
  976.      * properly configured:
  977.      */
  978.     if(map->speed > 0)
  979.       speed = map->speed;
  980.     else
  981.       switch(pxa_pcmcia_socket[sock].cs_state.Vcc){
  982.       case 33:
  983. speed = PXA_PCMCIA_3V_MEM_ACCESS;
  984. break;
  985.       default:
  986. speed = PXA_PCMCIA_5V_MEM_ACCESS;
  987.       }
  989.     clock = get_lclk_frequency_10khz();
  991.     if(map->flags&MAP_ATTRIB){
  992.       if (sock == 0) {
  993.         MCATT0 = ((pxa_mcxx_setup(speed, clock)
  994. & MCXX_SETUP_MASK) << MCXX_SETUP_SHIFT)
  995.                | ((pxa_mcxx_asst(speed, clock)
  996. & MCXX_ASST_MASK) << MCXX_ASST_SHIFT)
  997.                | ((pxa_mcxx_hold(speed, clock)
  998. & MCXX_HOLD_MASK) << MCXX_HOLD_SHIFT);
  999.       } else {
  1000.         MCATT1 = ((pxa_mcxx_setup(speed, clock)
  1001. & MCXX_SETUP_MASK) << MCXX_SETUP_SHIFT)
  1002.                | ((pxa_mcxx_asst(speed, clock)
  1003. & MCXX_ASST_MASK) << MCXX_ASST_SHIFT)
  1004.                | ((pxa_mcxx_hold(speed, clock)
  1005. & MCXX_HOLD_MASK) << MCXX_HOLD_SHIFT);
  1006.       }
  1007.       pxa_pcmcia_socket[sock].speed_attr=speed;
  1008.     } else {
  1009.       if (sock == 0) {
  1010.         MCMEM0 = ((pxa_mcxx_setup(speed, clock)
  1011. & MCXX_SETUP_MASK) << MCXX_SETUP_SHIFT)
  1012.                | ((pxa_mcxx_asst(speed, clock)
  1013. & MCXX_ASST_MASK) << MCXX_ASST_SHIFT)
  1014.                | ((pxa_mcxx_hold(speed, clock)
  1015. & MCXX_HOLD_MASK) << MCXX_HOLD_SHIFT);
  1016.       } else {
  1017.         MCMEM1 = ((pxa_mcxx_setup(speed, clock)
  1018. & MCXX_SETUP_MASK) << MCXX_SETUP_SHIFT)
  1019.                | ((pxa_mcxx_asst(speed, clock)
  1020. & MCXX_ASST_MASK) << MCXX_ASST_SHIFT)
  1021.                | ((pxa_mcxx_hold(speed, clock)
  1022. & MCXX_HOLD_MASK) << MCXX_HOLD_SHIFT);
  1023.       }
  1024.       pxa_pcmcia_socket[sock].speed_mem=speed;
  1025.     }
  1026.     DEBUG(4, "%s(): FAST%u %lx  BSM%u %lx  BSA%u %lx  BSIO%u %lxn",
  1027.   __FUNCTION__, sock, MECR_FAST_GET(mecr, sock), sock,
  1028.   MECR_BSM_GET(mecr, sock), sock, MECR_BSA_GET(mecr, sock), 
  1029.   sock, MECR_BSIO_GET(mecr, sock));
  1030.   }
  1032.   start=map->sys_start;
  1034.   if(map->sys_stop==0)
  1035.     map->sys_stop=PAGE_SIZE-1;
  1037.   map->sys_start=(map->flags & MAP_ATTRIB)?
  1038.     pxa_pcmcia_socket[sock].phys_attr:
  1039.     pxa_pcmcia_socket[sock].phys_mem;
  1041.   map->sys_stop=map->sys_start+(map->sys_stop-start);
  1043.   pxa_pcmcia_socket[sock].mem_map[map->map]=*map;
  1045.   return 0;
  1047. }  /* pxa_pcmcia_set_mem_map() */
  1050. #if defined(CONFIG_PROC_FS)
  1052. /* pxa_pcmcia_proc_setup()
  1053.  * ^^^^^^^^^^^^^^^^^^^^^^^^^^
  1054.  * Implements the proc_setup() operation for the in-kernel PCMCIA
  1055.  * service (formerly SS_ProcSetup in Card Services).
  1056.  *
  1057.  * Returns: 0 on success, -1 on error
  1058.  */
  1059. static void pxa_pcmcia_proc_setup(unsigned int sock,
  1060.      struct proc_dir_entry *base){
  1061.   struct proc_dir_entry *entry;
  1063.   DEBUG(4, "%s() for sock %un", __FUNCTION__, sock);
  1065.   if((entry=create_proc_entry("status", 0, base))==NULL){
  1066.     printk(KERN_ERR "Unable to install "status" procfs entryn");
  1067.     return;
  1068.   }
  1070.   entry->read_proc=pxa_pcmcia_proc_status;
  1071.   entry->data=(void *)sock;
  1072. }
  1075. /* pxa_pcmcia_proc_status()
  1076.  * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
  1077.  * Implements the /proc/bus/pccard/??/status file.
  1078.  *
  1079.  * Returns: the number of characters added to the buffer
  1080.  */
  1081. static int pxa_pcmcia_proc_status(char *buf, char **start, off_t pos,
  1082.      int count, int *eof, void *data){
  1083.   char *p=buf;
  1084.   unsigned int sock=(unsigned int)data;
  1085.   unsigned int clock = get_lclk_frequency_10khz();
  1086.   unsigned long mecr = MECR;
  1088.   p+=sprintf(p, "k_flags  : %s%s%s%s%s%s%sn", 
  1089.      pxa_pcmcia_socket[sock].k_state.detect?"detect ":"",
  1090.      pxa_pcmcia_socket[sock].k_state.ready?"ready ":"",
  1091.      pxa_pcmcia_socket[sock].k_state.bvd1?"bvd1 ":"",
  1092.      pxa_pcmcia_socket[sock].k_state.bvd2?"bvd2 ":"",
  1093.      pxa_pcmcia_socket[sock].k_state.wrprot?"wrprot ":"",
  1094.      pxa_pcmcia_socket[sock].k_state.vs_3v?"vs_3v ":"",
  1095.      pxa_pcmcia_socket[sock].k_state.vs_Xv?"vs_Xv ":"");
  1097.   p+=sprintf(p, "status   : %s%s%s%s%s%s%s%s%sn",
  1098.      pxa_pcmcia_socket[sock].k_state.detect?"SS_DETECT ":"",
  1099.      pxa_pcmcia_socket[sock].k_state.ready?"SS_READY ":"",
  1100.      pxa_pcmcia_socket[sock].cs_state.Vcc?"SS_POWERON ":"",
  1101.      pxa_pcmcia_socket[sock].cs_state.flags&SS_IOCARD?
  1102.      "SS_IOCARD ":"",
  1103.      (pxa_pcmcia_socket[sock].cs_state.flags&SS_IOCARD &&
  1104.       pxa_pcmcia_socket[sock].k_state.bvd1)?"SS_STSCHG ":"",
  1105.      ((pxa_pcmcia_socket[sock].cs_state.flags&SS_IOCARD)==0 &&
  1106.       (pxa_pcmcia_socket[sock].k_state.bvd1==0))?"SS_BATDEAD ":"",
  1107.      ((pxa_pcmcia_socket[sock].cs_state.flags&SS_IOCARD)==0 &&
  1108.       (pxa_pcmcia_socket[sock].k_state.bvd2==0))?"SS_BATWARN ":"",
  1109.      pxa_pcmcia_socket[sock].k_state.vs_3v?"SS_3VCARD ":"",
  1110.      pxa_pcmcia_socket[sock].k_state.vs_Xv?"SS_XVCARD ":"");
  1112.   p+=sprintf(p, "mask     : %s%s%s%s%sn",
  1113.      pxa_pcmcia_socket[sock].cs_state.csc_mask&SS_DETECT?
  1114.      "SS_DETECT ":"",
  1115.      pxa_pcmcia_socket[sock].cs_state.csc_mask&SS_READY?
  1116.      "SS_READY ":"",
  1117.      pxa_pcmcia_socket[sock].cs_state.csc_mask&SS_BATDEAD?
  1118.      "SS_BATDEAD ":"",
  1119.      pxa_pcmcia_socket[sock].cs_state.csc_mask&SS_BATWARN?
  1120.      "SS_BATWARN ":"",
  1121.      pxa_pcmcia_socket[sock].cs_state.csc_mask&SS_STSCHG?
  1122.      "SS_STSCHG ":"");
  1124.   p+=sprintf(p, "cs_flags : %s%s%s%s%sn",
  1125.      pxa_pcmcia_socket[sock].cs_state.flags&SS_PWR_AUTO?
  1126.      "SS_PWR_AUTO ":"",
  1127.      pxa_pcmcia_socket[sock].cs_state.flags&SS_IOCARD?
  1128.      "SS_IOCARD ":"",
  1129.      pxa_pcmcia_socket[sock].cs_state.flags&SS_RESET?
  1130.      "SS_RESET ":"",
  1131.      pxa_pcmcia_socket[sock].cs_state.flags&SS_SPKR_ENA?
  1132.      "SS_SPKR_ENA ":"",
  1133.      pxa_pcmcia_socket[sock].cs_state.flags&SS_OUTPUT_ENA?
  1134.      "SS_OUTPUT_ENA ":"");
  1136.   p+=sprintf(p, "Vcc      : %dn", pxa_pcmcia_socket[sock].cs_state.Vcc);
  1138.   p+=sprintf(p, "Vpp      : %dn", pxa_pcmcia_socket[sock].cs_state.Vpp);
  1140.   p+=sprintf(p, "irq      : %dn", pxa_pcmcia_socket[sock].cs_state.io_irq);
  1142.   p+=sprintf(p, "I/O      : %u (%u)n", pxa_pcmcia_socket[sock].speed_io,
  1143.              sock ?
  1144.                pxa_pcmcia_cmd_time(clock,
  1145. ((MCIO1 >> MCXX_ASST_SHIFT) & MCXX_ASST_MASK)) :
  1146.                pxa_pcmcia_cmd_time(clock,
  1147. ((MCIO0 >> MCXX_ASST_SHIFT) & MCXX_ASST_MASK)));
  1149.   p+=sprintf(p, "attribute: %u (%u)n", pxa_pcmcia_socket[sock].speed_attr,
  1150.              sock ?
  1151.                pxa_pcmcia_cmd_time(clock,
  1152. ((MCATT1 >> MCXX_ASST_SHIFT) & MCXX_ASST_MASK)) :
  1153.                pxa_pcmcia_cmd_time(clock,
  1154. ((MCATT0 >> MCXX_ASST_SHIFT) & MCXX_ASST_MASK)));
  1156.   p+=sprintf(p, "common   : %u (%u)n", pxa_pcmcia_socket[sock].speed_mem,
  1157.              sock ?
  1158.                pxa_pcmcia_cmd_time(clock,
  1159. ((MCMEM1 >> MCXX_ASST_SHIFT) & MCXX_ASST_MASK)) :
  1160.                pxa_pcmcia_cmd_time(clock,
  1161. ((MCMEM0 >> MCXX_ASST_SHIFT) & MCXX_ASST_MASK)));
  1163.   return p-buf;
  1164. }
  1166. #endif  /* defined(CONFIG_PROC_FS) */
  1169. #ifdef CONFIG_CPU_FREQ
  1171. /* pxa_pcmcia_update_mecr()
  1172.  * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
  1173.  * When pxa_pcmcia_notifier() decides that a MECR adjustment (due
  1174.  * to a core clock frequency change) is needed, this routine establishes
  1175.  * new BS_xx values consistent with the clock speed `clock'.
  1176.  */
  1177. static void pxa_pcmcia_update_mecr(unsigned int clock){
  1178.   unsigned int sock;
  1180.   for(sock = 0; sock < PXA_PCMCIA_MAX_SOCK; ++sock){
  1182.     // REVISIT: MCXX macros needed here
  1183.     // MECR_BSIO_SET(mecr, sock,
  1184. //    pxa_pcmcia_mecr_bs(pxa_pcmcia_socket[sock].speed_io,
  1185. //  clock));
  1186.     // MECR_BSA_SET(mecr, sock,
  1187. //   pxa_pcmcia_mecr_bs(pxa_pcmcia_socket[sock].speed_attr,
  1188. //         clock));
  1189.     // MECR_BSM_SET(mecr, sock,
  1190. //   pxa_pcmcia_mecr_bs(pxa_pcmcia_socket[sock].speed_mem,
  1191. //         clock));
  1192.   }
  1193. }
  1195. /* pxa_pcmcia_notifier()
  1196.  * ^^^^^^^^^^^^^^^^^^^^^^^^
  1197.  * When changing the processor core clock frequency, it is necessary
  1198.  * to adjust the MECR timings accordingly. We've recorded the timings
  1199.  * requested by Card Services, so this is just a matter of finding
  1200.  * out what our current speed is, and then recomputing the new MECR
  1201.  * values.
  1202.  *
  1203.  * Returns: 0 on success, -1 on error
  1204.  */
  1205. static int pxa_pcmcia_notifier(struct notifier_block *nb,
  1206.   unsigned long val, void *data){
  1207.   struct cpufreq_info *ci = data;
  1209.   switch(val){
  1210.   case CPUFREQ_MINMAX:
  1212.     break;
  1214.   case CPUFREQ_PRECHANGE:
  1216.     if(ci->new_freq > ci->old_freq){
  1217.       DEBUG(2, "%s(): new frequency %u.%uMHz > %u.%uMHz, pre-updatingn",
  1218.     __FUNCTION__,
  1219.     ci->new_freq / 1000, (ci->new_freq / 100) % 10,
  1220.     ci->old_freq / 1000, (ci->old_freq / 100) % 10);
  1221.       pxa_pcmcia_update_mecr(ci->new_freq);
  1222.     }
  1224.     break;
  1226.   case CPUFREQ_POSTCHANGE:
  1228.     if(ci->new_freq < ci->old_freq){
  1229.       DEBUG(2, "%s(): new frequency %u.%uMHz < %u.%uMHz, post-updatingn",
  1230.     __FUNCTION__,
  1231.     ci->new_freq / 1000, (ci->new_freq / 100) % 10,
  1232.     ci->old_freq / 1000, (ci->old_freq / 100) % 10);
  1233.       pxa_pcmcia_update_mecr(ci->new_freq);
  1234.     }
  1236.     break;
  1238.   default:
  1239.     printk(KERN_ERR "%s(): unknown CPU frequency event %lxn", __FUNCTION__,
  1240.    val);
  1241.     return -1;
  1243.   }
  1245.   return 0;
  1247. }
  1249. static struct notifier_block pxa_pcmcia_notifier_block = {
  1250.   notifier_call: pxa_pcmcia_notifier
  1251. };
  1253. #endif