1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33#include <linux/module.h>
34#include <linux/moduleparam.h>
35#include <linux/init.h>
36#include <linux/cpufreq.h>
37#include <linux/ioport.h>
38#include <linux/kernel.h>
39#include <linux/timer.h>
40#include <linux/mm.h>
41#include <linux/notifier.h>
42#include <linux/interrupt.h>
43#include <linux/spinlock.h>
44#include <linux/mutex.h>
45#include <linux/platform_device.h>
46
47#include <asm/io.h>
48#include <asm/irq.h>
49#include <asm/system.h>
50
51#include <asm/mach-au1x00/au1000.h>
52#include "au1000_generic.h"
53
54MODULE_LICENSE("GPL");
55MODULE_AUTHOR("Pete Popov <ppopov@embeddedalley.com>");
56MODULE_DESCRIPTION("Linux PCMCIA Card Services: Au1x00 Socket Controller");
57
58#if 0
59#define debug(x,args...) printk(KERN_DEBUG "%s: " x, __func__ , ##args)
60#else
61#define debug(x,args...)
62#endif
63
64#define MAP_SIZE 0x100000
65extern struct au1000_pcmcia_socket au1000_pcmcia_socket[];
66#define PCMCIA_SOCKET(x) (au1000_pcmcia_socket + (x))
67#define to_au1000_socket(x) container_of(x, struct au1000_pcmcia_socket, socket)
68
69
70
71
72u32 *pcmcia_base_vaddrs[2];
73extern const unsigned long mips_io_port_base;
74
75static DEFINE_MUTEX(pcmcia_sockets_lock);
76
77static int (*au1x00_pcmcia_hw_init[])(struct device *dev) = {
78 au1x_board_init,
79};
80
81static int
82au1x00_pcmcia_skt_state(struct au1000_pcmcia_socket *skt)
83{
84 struct pcmcia_state state;
85 unsigned int stat;
86
87 memset(&state, 0, sizeof(struct pcmcia_state));
88
89 skt->ops->socket_state(skt, &state);
90
91 stat = state.detect ? SS_DETECT : 0;
92 stat |= state.ready ? SS_READY : 0;
93 stat |= state.wrprot ? SS_WRPROT : 0;
94 stat |= state.vs_3v ? SS_3VCARD : 0;
95 stat |= state.vs_Xv ? SS_XVCARD : 0;
96 stat |= skt->cs_state.Vcc ? SS_POWERON : 0;
97
98 if (skt->cs_state.flags & SS_IOCARD)
99 stat |= state.bvd1 ? SS_STSCHG : 0;
100 else {
101 if (state.bvd1 == 0)
102 stat |= SS_BATDEAD;
103 else if (state.bvd2 == 0)
104 stat |= SS_BATWARN;
105 }
106 return stat;
107}
108
109
110
111
112
113
114static int
115au1x00_pcmcia_config_skt(struct au1000_pcmcia_socket *skt, socket_state_t *state)
116{
117 int ret;
118
119 ret = skt->ops->configure_socket(skt, state);
120 if (ret == 0) {
121 skt->cs_state = *state;
122 }
123
124 if (ret < 0)
125 debug("unable to configure socket %d\n", skt->nr);
126
127 return ret;
128}
129
130
131
132
133
134
135
136
137
138static int au1x00_pcmcia_sock_init(struct pcmcia_socket *sock)
139{
140 struct au1000_pcmcia_socket *skt = to_au1000_socket(sock);
141
142 debug("initializing socket %u\n", skt->nr);
143
144 skt->ops->socket_init(skt);
145 return 0;
146}
147
148
149
150
151
152
153
154
155
156static int au1x00_pcmcia_suspend(struct pcmcia_socket *sock)
157{
158 struct au1000_pcmcia_socket *skt = to_au1000_socket(sock);
159
160 debug("suspending socket %u\n", skt->nr);
161
162 skt->ops->socket_suspend(skt);
163
164 return 0;
165}
166
167static DEFINE_SPINLOCK(status_lock);
168
169
170
171
172static void au1x00_check_status(struct au1000_pcmcia_socket *skt)
173{
174 unsigned int events;
175
176 debug("entering PCMCIA monitoring thread\n");
177
178 do {
179 unsigned int status;
180 unsigned long flags;
181
182 status = au1x00_pcmcia_skt_state(skt);
183
184 spin_lock_irqsave(&status_lock, flags);
185 events = (status ^ skt->status) & skt->cs_state.csc_mask;
186 skt->status = status;
187 spin_unlock_irqrestore(&status_lock, flags);
188
189 debug("events: %s%s%s%s%s%s\n",
190 events == 0 ? "<NONE>" : "",
191 events & SS_DETECT ? "DETECT " : "",
192 events & SS_READY ? "READY " : "",
193 events & SS_BATDEAD ? "BATDEAD " : "",
194 events & SS_BATWARN ? "BATWARN " : "",
195 events & SS_STSCHG ? "STSCHG " : "");
196
197 if (events)
198 pcmcia_parse_events(&skt->socket, events);
199 } while (events);
200}
201
202
203
204
205
206static void au1x00_pcmcia_poll_event(unsigned long dummy)
207{
208 struct au1000_pcmcia_socket *skt = (struct au1000_pcmcia_socket *)dummy;
209 debug("polling for events\n");
210
211 mod_timer(&skt->poll_timer, jiffies + AU1000_PCMCIA_POLL_PERIOD);
212
213 au1x00_check_status(skt);
214}
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233static int
234au1x00_pcmcia_get_status(struct pcmcia_socket *sock, unsigned int *status)
235{
236 struct au1000_pcmcia_socket *skt = to_au1000_socket(sock);
237
238 skt->status = au1x00_pcmcia_skt_state(skt);
239 *status = skt->status;
240
241 return 0;
242}
243
244
245
246
247
248
249
250
251
252
253static int
254au1x00_pcmcia_set_socket(struct pcmcia_socket *sock, socket_state_t *state)
255{
256 struct au1000_pcmcia_socket *skt = to_au1000_socket(sock);
257
258 debug("for sock %u\n", skt->nr);
259
260 debug("\tmask: %s%s%s%s%s%s\n\tflags: %s%s%s%s%s%s\n",
261 (state->csc_mask==0)?"<NONE>":"",
262 (state->csc_mask&SS_DETECT)?"DETECT ":"",
263 (state->csc_mask&SS_READY)?"READY ":"",
264 (state->csc_mask&SS_BATDEAD)?"BATDEAD ":"",
265 (state->csc_mask&SS_BATWARN)?"BATWARN ":"",
266 (state->csc_mask&SS_STSCHG)?"STSCHG ":"",
267 (state->flags==0)?"<NONE>":"",
268 (state->flags&SS_PWR_AUTO)?"PWR_AUTO ":"",
269 (state->flags&SS_IOCARD)?"IOCARD ":"",
270 (state->flags&SS_RESET)?"RESET ":"",
271 (state->flags&SS_SPKR_ENA)?"SPKR_ENA ":"",
272 (state->flags&SS_OUTPUT_ENA)?"OUTPUT_ENA ":"");
273 debug("\tVcc %d Vpp %d irq %d\n",
274 state->Vcc, state->Vpp, state->io_irq);
275
276 return au1x00_pcmcia_config_skt(skt, state);
277}
278
279int
280au1x00_pcmcia_set_io_map(struct pcmcia_socket *sock, struct pccard_io_map *map)
281{
282 struct au1000_pcmcia_socket *skt = to_au1000_socket(sock);
283 unsigned int speed;
284
285 if(map->map>=MAX_IO_WIN){
286 debug("map (%d) out of range\n", map->map);
287 return -1;
288 }
289
290 if(map->flags&MAP_ACTIVE){
291 speed=(map->speed>0)?map->speed:AU1000_PCMCIA_IO_SPEED;
292 skt->spd_io[map->map] = speed;
293 }
294
295 map->start=(unsigned int)(u32)skt->virt_io;
296 map->stop=map->start+MAP_SIZE;
297 return 0;
298
299}
300
301
302static int
303au1x00_pcmcia_set_mem_map(struct pcmcia_socket *sock, struct pccard_mem_map *map)
304{
305 struct au1000_pcmcia_socket *skt = to_au1000_socket(sock);
306 unsigned short speed = map->speed;
307
308 if(map->map>=MAX_WIN){
309 debug("map (%d) out of range\n", map->map);
310 return -1;
311 }
312
313 if (map->flags & MAP_ATTRIB) {
314 skt->spd_attr[map->map] = speed;
315 skt->spd_mem[map->map] = 0;
316 } else {
317 skt->spd_attr[map->map] = 0;
318 skt->spd_mem[map->map] = speed;
319 }
320
321 if (map->flags & MAP_ATTRIB) {
322 map->static_start = skt->phys_attr + map->card_start;
323 }
324 else {
325 map->static_start = skt->phys_mem + map->card_start;
326 }
327
328 debug("set_mem_map %d start %08lx card_start %08x\n",
329 map->map, map->static_start, map->card_start);
330 return 0;
331
332}
333
334static struct pccard_operations au1x00_pcmcia_operations = {
335 .init = au1x00_pcmcia_sock_init,
336 .suspend = au1x00_pcmcia_suspend,
337 .get_status = au1x00_pcmcia_get_status,
338 .set_socket = au1x00_pcmcia_set_socket,
339 .set_io_map = au1x00_pcmcia_set_io_map,
340 .set_mem_map = au1x00_pcmcia_set_mem_map,
341};
342
343static const char *skt_names[] = {
344 "PCMCIA socket 0",
345 "PCMCIA socket 1",
346};
347
348struct skt_dev_info {
349 int nskt;
350};
351
352int au1x00_pcmcia_socket_probe(struct device *dev, struct pcmcia_low_level *ops, int first, int nr)
353{
354 struct skt_dev_info *sinfo;
355 struct au1000_pcmcia_socket *skt;
356 int ret, i;
357
358 sinfo = kzalloc(sizeof(struct skt_dev_info), GFP_KERNEL);
359 if (!sinfo) {
360 ret = -ENOMEM;
361 goto out;
362 }
363
364 sinfo->nskt = nr;
365
366
367
368
369 for (i = 0; i < nr; i++) {
370 skt = PCMCIA_SOCKET(i);
371 memset(skt, 0, sizeof(*skt));
372
373 skt->socket.resource_ops = &pccard_static_ops;
374 skt->socket.ops = &au1x00_pcmcia_operations;
375 skt->socket.owner = ops->owner;
376 skt->socket.dev.parent = dev;
377
378 init_timer(&skt->poll_timer);
379 skt->poll_timer.function = au1x00_pcmcia_poll_event;
380 skt->poll_timer.data = (unsigned long)skt;
381 skt->poll_timer.expires = jiffies + AU1000_PCMCIA_POLL_PERIOD;
382
383 skt->nr = first + i;
384 skt->irq = 255;
385 skt->dev = dev;
386 skt->ops = ops;
387
388 skt->res_skt.name = skt_names[skt->nr];
389 skt->res_io.name = "io";
390 skt->res_io.flags = IORESOURCE_MEM | IORESOURCE_BUSY;
391 skt->res_mem.name = "memory";
392 skt->res_mem.flags = IORESOURCE_MEM;
393 skt->res_attr.name = "attribute";
394 skt->res_attr.flags = IORESOURCE_MEM;
395
396
397
398
399
400
401
402
403
404 if (i == 0) {
405 skt->virt_io = (void *)
406 (ioremap((phys_t)AU1X_SOCK0_IO, 0x1000) -
407 (u32)mips_io_port_base);
408 skt->phys_attr = AU1X_SOCK0_PSEUDO_PHYS_ATTR;
409 skt->phys_mem = AU1X_SOCK0_PSEUDO_PHYS_MEM;
410 }
411#ifndef CONFIG_MIPS_XXS1500
412 else {
413 skt->virt_io = (void *)
414 (ioremap((phys_t)AU1X_SOCK1_IO, 0x1000) -
415 (u32)mips_io_port_base);
416 skt->phys_attr = AU1X_SOCK1_PSEUDO_PHYS_ATTR;
417 skt->phys_mem = AU1X_SOCK1_PSEUDO_PHYS_MEM;
418 }
419#endif
420 pcmcia_base_vaddrs[i] = (u32 *)skt->virt_io;
421 ret = ops->hw_init(skt);
422
423 skt->socket.features = SS_CAP_STATIC_MAP|SS_CAP_PCCARD;
424 skt->socket.irq_mask = 0;
425 skt->socket.map_size = MAP_SIZE;
426 skt->socket.pci_irq = skt->irq;
427 skt->socket.io_offset = (unsigned long)skt->virt_io;
428
429 skt->status = au1x00_pcmcia_skt_state(skt);
430
431 ret = pcmcia_register_socket(&skt->socket);
432 if (ret)
433 goto out_err;
434
435 WARN_ON(skt->socket.sock != i);
436
437 add_timer(&skt->poll_timer);
438 }
439
440 dev_set_drvdata(dev, sinfo);
441 return 0;
442
443
444out_err:
445 flush_scheduled_work();
446 ops->hw_shutdown(skt);
447 while (i-- > 0) {
448 skt = PCMCIA_SOCKET(i);
449
450 del_timer_sync(&skt->poll_timer);
451 pcmcia_unregister_socket(&skt->socket);
452 flush_scheduled_work();
453 if (i == 0) {
454 iounmap(skt->virt_io + (u32)mips_io_port_base);
455 skt->virt_io = NULL;
456 }
457#ifndef CONFIG_MIPS_XXS1500
458 else {
459 iounmap(skt->virt_io + (u32)mips_io_port_base);
460 skt->virt_io = NULL;
461 }
462#endif
463 ops->hw_shutdown(skt);
464
465 }
466 kfree(sinfo);
467out:
468 return ret;
469}
470
471int au1x00_drv_pcmcia_remove(struct platform_device *dev)
472{
473 struct skt_dev_info *sinfo = platform_get_drvdata(dev);
474 int i;
475
476 mutex_lock(&pcmcia_sockets_lock);
477 platform_set_drvdata(dev, NULL);
478
479 for (i = 0; i < sinfo->nskt; i++) {
480 struct au1000_pcmcia_socket *skt = PCMCIA_SOCKET(i);
481
482 del_timer_sync(&skt->poll_timer);
483 pcmcia_unregister_socket(&skt->socket);
484 flush_scheduled_work();
485 skt->ops->hw_shutdown(skt);
486 au1x00_pcmcia_config_skt(skt, &dead_socket);
487 iounmap(skt->virt_io + (u32)mips_io_port_base);
488 skt->virt_io = NULL;
489 }
490
491 kfree(sinfo);
492 mutex_unlock(&pcmcia_sockets_lock);
493 return 0;
494}
495
496
497
498
499
500
501static int au1x00_drv_pcmcia_probe(struct platform_device *dev)
502{
503 int i, ret = -ENODEV;
504
505 mutex_lock(&pcmcia_sockets_lock);
506 for (i=0; i < ARRAY_SIZE(au1x00_pcmcia_hw_init); i++) {
507 ret = au1x00_pcmcia_hw_init[i](&dev->dev);
508 if (ret == 0)
509 break;
510 }
511 mutex_unlock(&pcmcia_sockets_lock);
512 return ret;
513}
514
515static int au1x00_drv_pcmcia_suspend(struct platform_device *dev,
516 pm_message_t state)
517{
518 return pcmcia_socket_dev_suspend(&dev->dev);
519}
520
521static int au1x00_drv_pcmcia_resume(struct platform_device *dev)
522{
523 return pcmcia_socket_dev_resume(&dev->dev);
524}
525
526static struct platform_driver au1x00_pcmcia_driver = {
527 .driver = {
528 .name = "au1x00-pcmcia",
529 .owner = THIS_MODULE,
530 },
531 .probe = au1x00_drv_pcmcia_probe,
532 .remove = au1x00_drv_pcmcia_remove,
533 .suspend = au1x00_drv_pcmcia_suspend,
534 .resume = au1x00_drv_pcmcia_resume,
535};
536
537
538
539
540
541
542
543
544
545static int __init au1x00_pcmcia_init(void)
546{
547 int error = 0;
548 error = platform_driver_register(&au1x00_pcmcia_driver);
549 return error;
550}
551
552
553
554
555
556static void __exit au1x00_pcmcia_exit(void)
557{
558 platform_driver_unregister(&au1x00_pcmcia_driver);
559}
560
561module_init(au1x00_pcmcia_init);
562module_exit(au1x00_pcmcia_exit);
563