Root/drivers/pcmcia/rsrc_nonstatic.c

1/*
2 * rsrc_nonstatic.c -- Resource management routines for !SS_CAP_STATIC_MAP sockets
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License version 2 as
6 * published by the Free Software Foundation.
7 *
8 * The initial developer of the original code is David A. Hinds
9 * <dahinds@users.sourceforge.net>. Portions created by David A. Hinds
10 * are Copyright (C) 1999 David A. Hinds. All Rights Reserved.
11 *
12 * (C) 1999 David A. Hinds
13 */
14
15#include <linux/module.h>
16#include <linux/moduleparam.h>
17#include <linux/init.h>
18#include <linux/interrupt.h>
19#include <linux/kernel.h>
20#include <linux/errno.h>
21#include <linux/types.h>
22#include <linux/slab.h>
23#include <linux/ioport.h>
24#include <linux/timer.h>
25#include <linux/pci.h>
26#include <linux/device.h>
27#include <linux/io.h>
28
29#include <asm/irq.h>
30
31#include <pcmcia/ss.h>
32#include <pcmcia/cistpl.h>
33#include "cs_internal.h"
34
35/* moved to rsrc_mgr.c
36MODULE_AUTHOR("David A. Hinds, Dominik Brodowski");
37MODULE_LICENSE("GPL");
38*/
39
40/* Parameters that can be set with 'insmod' */
41
42#define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0444)
43
44INT_MODULE_PARM(probe_mem, 1); /* memory probe? */
45#ifdef CONFIG_PCMCIA_PROBE
46INT_MODULE_PARM(probe_io, 1); /* IO port probe? */
47INT_MODULE_PARM(mem_limit, 0x10000);
48#endif
49
50/* for io_db and mem_db */
51struct resource_map {
52    u_long base, num;
53    struct resource_map *next;
54};
55
56struct socket_data {
57    struct resource_map mem_db;
58    struct resource_map mem_db_valid;
59    struct resource_map io_db;
60};
61
62#define MEM_PROBE_LOW (1 << 0)
63#define MEM_PROBE_HIGH (1 << 1)
64
65/* Action field */
66#define REMOVE_MANAGED_RESOURCE 1
67#define ADD_MANAGED_RESOURCE 2
68
69/*======================================================================
70
71    Linux resource management extensions
72
73======================================================================*/
74
75static struct resource *
76claim_region(struct pcmcia_socket *s, resource_size_t base,
77        resource_size_t size, int type, char *name)
78{
79    struct resource *res, *parent;
80
81    parent = type & IORESOURCE_MEM ? &iomem_resource : &ioport_resource;
82    res = pcmcia_make_resource(base, size, type | IORESOURCE_BUSY, name);
83
84    if (res) {
85#ifdef CONFIG_PCI
86        if (s && s->cb_dev)
87            parent = pci_find_parent_resource(s->cb_dev, res);
88#endif
89        if (!parent || request_resource(parent, res)) {
90            kfree(res);
91            res = NULL;
92        }
93    }
94    return res;
95}
96
97static void free_region(struct resource *res)
98{
99    if (res) {
100        release_resource(res);
101        kfree(res);
102    }
103}
104
105/*======================================================================
106
107    These manage the internal databases of available resources.
108
109======================================================================*/
110
111static int add_interval(struct resource_map *map, u_long base, u_long num)
112{
113    struct resource_map *p, *q;
114
115    for (p = map; ; p = p->next) {
116        if ((p != map) && (p->base+p->num >= base)) {
117            p->num = max(num + base - p->base, p->num);
118            return 0;
119        }
120        if ((p->next == map) || (p->next->base > base+num-1))
121            break;
122    }
123    q = kmalloc(sizeof(struct resource_map), GFP_KERNEL);
124    if (!q) {
125        printk(KERN_WARNING "out of memory to update resources\n");
126        return -ENOMEM;
127    }
128    q->base = base; q->num = num;
129    q->next = p->next; p->next = q;
130    return 0;
131}
132
133/*====================================================================*/
134
135static int sub_interval(struct resource_map *map, u_long base, u_long num)
136{
137    struct resource_map *p, *q;
138
139    for (p = map; ; p = q) {
140        q = p->next;
141        if (q == map)
142            break;
143        if ((q->base+q->num > base) && (base+num > q->base)) {
144            if (q->base >= base) {
145                if (q->base+q->num <= base+num) {
146                    /* Delete whole block */
147                    p->next = q->next;
148                    kfree(q);
149                    /* don't advance the pointer yet */
150                    q = p;
151                } else {
152                    /* Cut off bit from the front */
153                    q->num = q->base + q->num - base - num;
154                    q->base = base + num;
155                }
156            } else if (q->base+q->num <= base+num) {
157                /* Cut off bit from the end */
158                q->num = base - q->base;
159            } else {
160                /* Split the block into two pieces */
161                p = kmalloc(sizeof(struct resource_map),
162                    GFP_KERNEL);
163                if (!p) {
164                    printk(KERN_WARNING "out of memory to update resources\n");
165                    return -ENOMEM;
166                }
167                p->base = base+num;
168                p->num = q->base+q->num - p->base;
169                q->num = base - q->base;
170                p->next = q->next ; q->next = p;
171            }
172        }
173    }
174    return 0;
175}
176
177/*======================================================================
178
179    These routines examine a region of IO or memory addresses to
180    determine what ranges might be genuinely available.
181
182======================================================================*/
183
184#ifdef CONFIG_PCMCIA_PROBE
185static void do_io_probe(struct pcmcia_socket *s, unsigned int base,
186            unsigned int num)
187{
188    struct resource *res;
189    struct socket_data *s_data = s->resource_data;
190    unsigned int i, j, bad;
191    int any;
192    u_char *b, hole, most;
193
194    dev_printk(KERN_INFO, &s->dev, "cs: IO port probe %#x-%#x:",
195        base, base+num-1);
196
197    /* First, what does a floating port look like? */
198    b = kzalloc(256, GFP_KERNEL);
199    if (!b) {
200        printk("\n");
201        dev_printk(KERN_ERR, &s->dev,
202            "do_io_probe: unable to kmalloc 256 bytes");
203        return;
204    }
205    for (i = base, most = 0; i < base+num; i += 8) {
206        res = claim_region(s, i, 8, IORESOURCE_IO, "PCMCIA ioprobe");
207        if (!res)
208            continue;
209        hole = inb(i);
210        for (j = 1; j < 8; j++)
211            if (inb(i+j) != hole)
212                break;
213        free_region(res);
214        if ((j == 8) && (++b[hole] > b[most]))
215            most = hole;
216        if (b[most] == 127)
217            break;
218    }
219    kfree(b);
220
221    bad = any = 0;
222    for (i = base; i < base+num; i += 8) {
223        res = claim_region(s, i, 8, IORESOURCE_IO, "PCMCIA ioprobe");
224        if (!res) {
225            if (!any)
226                printk(" excluding");
227            if (!bad)
228                bad = any = i;
229            continue;
230        }
231        for (j = 0; j < 8; j++)
232            if (inb(i+j) != most)
233                break;
234        free_region(res);
235        if (j < 8) {
236            if (!any)
237                printk(" excluding");
238            if (!bad)
239                bad = any = i;
240        } else {
241            if (bad) {
242                sub_interval(&s_data->io_db, bad, i-bad);
243                printk(" %#x-%#x", bad, i-1);
244                bad = 0;
245            }
246        }
247    }
248    if (bad) {
249        if ((num > 16) && (bad == base) && (i == base+num)) {
250            sub_interval(&s_data->io_db, bad, i-bad);
251            printk(" nothing: probe failed.\n");
252            return;
253        } else {
254            sub_interval(&s_data->io_db, bad, i-bad);
255            printk(" %#x-%#x", bad, i-1);
256        }
257    }
258
259    printk(any ? "\n" : " clean.\n");
260}
261#endif
262
263/*======================================================================*/
264
265/**
266 * readable() - iomem validation function for cards with a valid CIS
267 */
268static int readable(struct pcmcia_socket *s, struct resource *res,
269            unsigned int *count)
270{
271    int ret = -EINVAL;
272
273    if (s->fake_cis) {
274        dev_dbg(&s->dev, "fake CIS is being used: can't validate mem\n");
275        return 0;
276    }
277
278    s->cis_mem.res = res;
279    s->cis_virt = ioremap(res->start, s->map_size);
280    if (s->cis_virt) {
281        mutex_unlock(&s->ops_mutex);
282        /* as we're only called from pcmcia.c, we're safe */
283        if (s->callback->validate)
284            ret = s->callback->validate(s, count);
285        /* invalidate mapping */
286        mutex_lock(&s->ops_mutex);
287        iounmap(s->cis_virt);
288        s->cis_virt = NULL;
289    }
290    s->cis_mem.res = NULL;
291    if ((ret) || (*count == 0))
292        return -EINVAL;
293    return 0;
294}
295
296/**
297 * checksum() - iomem validation function for simple memory cards
298 */
299static int checksum(struct pcmcia_socket *s, struct resource *res,
300            unsigned int *value)
301{
302    pccard_mem_map map;
303    int i, a = 0, b = -1, d;
304    void __iomem *virt;
305
306    virt = ioremap(res->start, s->map_size);
307    if (virt) {
308        map.map = 0;
309        map.flags = MAP_ACTIVE;
310        map.speed = 0;
311        map.res = res;
312        map.card_start = 0;
313        s->ops->set_mem_map(s, &map);
314
315        /* Don't bother checking every word... */
316        for (i = 0; i < s->map_size; i += 44) {
317            d = readl(virt+i);
318            a += d;
319            b &= d;
320        }
321
322        map.flags = 0;
323        s->ops->set_mem_map(s, &map);
324
325        iounmap(virt);
326    }
327
328    if (b == -1)
329        return -EINVAL;
330
331    *value = a;
332
333    return 0;
334}
335
336/**
337 * do_validate_mem() - low level validate a memory region for PCMCIA use
338 * @s: PCMCIA socket to validate
339 * @base: start address of resource to check
340 * @size: size of resource to check
341 * @validate: validation function to use
342 *
343 * do_validate_mem() splits up the memory region which is to be checked
344 * into two parts. Both are passed to the @validate() function. If
345 * @validate() returns non-zero, or the value parameter to @validate()
346 * is zero, or the value parameter is different between both calls,
347 * the check fails, and -EINVAL is returned. Else, 0 is returned.
348 */
349static int do_validate_mem(struct pcmcia_socket *s,
350               unsigned long base, unsigned long size,
351               int validate (struct pcmcia_socket *s,
352                     struct resource *res,
353                     unsigned int *value))
354{
355    struct socket_data *s_data = s->resource_data;
356    struct resource *res1, *res2;
357    unsigned int info1 = 1, info2 = 1;
358    int ret = -EINVAL;
359
360    res1 = claim_region(s, base, size/2, IORESOURCE_MEM, "PCMCIA memprobe");
361    res2 = claim_region(s, base + size/2, size/2, IORESOURCE_MEM,
362            "PCMCIA memprobe");
363
364    if (res1 && res2) {
365        ret = 0;
366        if (validate) {
367            ret = validate(s, res1, &info1);
368            ret += validate(s, res2, &info2);
369        }
370    }
371
372    free_region(res2);
373    free_region(res1);
374
375    dev_dbg(&s->dev, "cs: memory probe 0x%06lx-0x%06lx: %p %p %u %u %u",
376        base, base+size-1, res1, res2, ret, info1, info2);
377
378    if ((ret) || (info1 != info2) || (info1 == 0))
379        return -EINVAL;
380
381    if (validate && !s->fake_cis) {
382        /* move it to the validated data set */
383        add_interval(&s_data->mem_db_valid, base, size);
384        sub_interval(&s_data->mem_db, base, size);
385    }
386
387    return 0;
388}
389
390
391/**
392 * do_mem_probe() - validate a memory region for PCMCIA use
393 * @s: PCMCIA socket to validate
394 * @base: start address of resource to check
395 * @num: size of resource to check
396 * @validate: validation function to use
397 * @fallback: validation function to use if validate fails
398 *
399 * do_mem_probe() checks a memory region for use by the PCMCIA subsystem.
400 * To do so, the area is split up into sensible parts, and then passed
401 * into the @validate() function. Only if @validate() and @fallback() fail,
402 * the area is marked as unavaibale for use by the PCMCIA subsystem. The
403 * function returns the size of the usable memory area.
404 */
405static int do_mem_probe(struct pcmcia_socket *s, u_long base, u_long num,
406            int validate (struct pcmcia_socket *s,
407                      struct resource *res,
408                      unsigned int *value),
409            int fallback (struct pcmcia_socket *s,
410                      struct resource *res,
411                      unsigned int *value))
412{
413    struct socket_data *s_data = s->resource_data;
414    u_long i, j, bad, fail, step;
415
416    dev_printk(KERN_INFO, &s->dev, "cs: memory probe 0x%06lx-0x%06lx:",
417        base, base+num-1);
418    bad = fail = 0;
419    step = (num < 0x20000) ? 0x2000 : ((num>>4) & ~0x1fff);
420    /* don't allow too large steps */
421    if (step > 0x800000)
422        step = 0x800000;
423    /* cis_readable wants to map 2x map_size */
424    if (step < 2 * s->map_size)
425        step = 2 * s->map_size;
426    for (i = j = base; i < base+num; i = j + step) {
427        if (!fail) {
428            for (j = i; j < base+num; j += step) {
429                if (!do_validate_mem(s, j, step, validate))
430                    break;
431            }
432            fail = ((i == base) && (j == base+num));
433        }
434        if ((fail) && (fallback)) {
435            for (j = i; j < base+num; j += step)
436                if (!do_validate_mem(s, j, step, fallback))
437                    break;
438        }
439        if (i != j) {
440            if (!bad)
441                printk(" excluding");
442            printk(" %#05lx-%#05lx", i, j-1);
443            sub_interval(&s_data->mem_db, i, j-i);
444            bad += j-i;
445        }
446    }
447    printk(bad ? "\n" : " clean.\n");
448    return num - bad;
449}
450
451
452#ifdef CONFIG_PCMCIA_PROBE
453
454/**
455 * inv_probe() - top-to-bottom search for one usuable high memory area
456 * @s: PCMCIA socket to validate
457 * @m: resource_map to check
458 */
459static u_long inv_probe(struct resource_map *m, struct pcmcia_socket *s)
460{
461    struct socket_data *s_data = s->resource_data;
462    u_long ok;
463    if (m == &s_data->mem_db)
464        return 0;
465    ok = inv_probe(m->next, s);
466    if (ok) {
467        if (m->base >= 0x100000)
468            sub_interval(&s_data->mem_db, m->base, m->num);
469        return ok;
470    }
471    if (m->base < 0x100000)
472        return 0;
473    return do_mem_probe(s, m->base, m->num, readable, checksum);
474}
475
476/**
477 * validate_mem() - memory probe function
478 * @s: PCMCIA socket to validate
479 * @probe_mask: MEM_PROBE_LOW | MEM_PROBE_HIGH
480 *
481 * The memory probe. If the memory list includes a 64K-aligned block
482 * below 1MB, we probe in 64K chunks, and as soon as we accumulate at
483 * least mem_limit free space, we quit. Returns 0 on usuable ports.
484 */
485static int validate_mem(struct pcmcia_socket *s, unsigned int probe_mask)
486{
487    struct resource_map *m, mm;
488    static unsigned char order[] = { 0xd0, 0xe0, 0xc0, 0xf0 };
489    unsigned long b, i, ok = 0;
490    struct socket_data *s_data = s->resource_data;
491
492    /* We do up to four passes through the list */
493    if (probe_mask & MEM_PROBE_HIGH) {
494        if (inv_probe(s_data->mem_db.next, s) > 0)
495            return 0;
496        if (s_data->mem_db_valid.next != &s_data->mem_db_valid)
497            return 0;
498        dev_printk(KERN_NOTICE, &s->dev,
499               "cs: warning: no high memory space available!\n");
500        return -ENODEV;
501    }
502
503    for (m = s_data->mem_db.next; m != &s_data->mem_db; m = mm.next) {
504        mm = *m;
505        /* Only probe < 1 MB */
506        if (mm.base >= 0x100000)
507            continue;
508        if ((mm.base | mm.num) & 0xffff) {
509            ok += do_mem_probe(s, mm.base, mm.num, readable,
510                       checksum);
511            continue;
512        }
513        /* Special probe for 64K-aligned block */
514        for (i = 0; i < 4; i++) {
515            b = order[i] << 12;
516            if ((b >= mm.base) && (b+0x10000 <= mm.base+mm.num)) {
517                if (ok >= mem_limit)
518                    sub_interval(&s_data->mem_db, b, 0x10000);
519                else
520                    ok += do_mem_probe(s, b, 0x10000,
521                               readable, checksum);
522            }
523        }
524    }
525
526    if (ok > 0)
527        return 0;
528
529    return -ENODEV;
530}
531
532#else /* CONFIG_PCMCIA_PROBE */
533
534/**
535 * validate_mem() - memory probe function
536 * @s: PCMCIA socket to validate
537 * @probe_mask: ignored
538 *
539 * Returns 0 on usuable ports.
540 */
541static int validate_mem(struct pcmcia_socket *s, unsigned int probe_mask)
542{
543    struct resource_map *m, mm;
544    struct socket_data *s_data = s->resource_data;
545    unsigned long ok = 0;
546
547    for (m = s_data->mem_db.next; m != &s_data->mem_db; m = mm.next) {
548        mm = *m;
549        ok += do_mem_probe(s, mm.base, mm.num, readable, checksum);
550    }
551    if (ok > 0)
552        return 0;
553    return -ENODEV;
554}
555
556#endif /* CONFIG_PCMCIA_PROBE */
557
558
559/**
560 * pcmcia_nonstatic_validate_mem() - try to validate iomem for PCMCIA use
561 * @s: PCMCIA socket to validate
562 *
563 * This is tricky... when we set up CIS memory, we try to validate
564 * the memory window space allocations.
565 *
566 * Locking note: Must be called with skt_mutex held!
567 */
568static int pcmcia_nonstatic_validate_mem(struct pcmcia_socket *s)
569{
570    struct socket_data *s_data = s->resource_data;
571    unsigned int probe_mask = MEM_PROBE_LOW;
572    int ret;
573
574    if (!probe_mem || !(s->state & SOCKET_PRESENT))
575        return 0;
576
577    if (s->features & SS_CAP_PAGE_REGS)
578        probe_mask = MEM_PROBE_HIGH;
579
580    ret = validate_mem(s, probe_mask);
581
582    if (s_data->mem_db_valid.next != &s_data->mem_db_valid)
583        return 0;
584
585    return ret;
586}
587
588struct pcmcia_align_data {
589    unsigned long mask;
590    unsigned long offset;
591    struct resource_map *map;
592};
593
594static resource_size_t pcmcia_common_align(struct pcmcia_align_data *align_data,
595                    resource_size_t start)
596{
597    resource_size_t ret;
598    /*
599     * Ensure that we have the correct start address
600     */
601    ret = (start & ~align_data->mask) + align_data->offset;
602    if (ret < start)
603        ret += align_data->mask + 1;
604    return ret;
605}
606
607static resource_size_t
608pcmcia_align(void *align_data, const struct resource *res,
609    resource_size_t size, resource_size_t align)
610{
611    struct pcmcia_align_data *data = align_data;
612    struct resource_map *m;
613    resource_size_t start;
614
615    start = pcmcia_common_align(data, res->start);
616
617    for (m = data->map->next; m != data->map; m = m->next) {
618        unsigned long map_start = m->base;
619        unsigned long map_end = m->base + m->num - 1;
620
621        /*
622         * If the lower resources are not available, try aligning
623         * to this entry of the resource database to see if it'll
624         * fit here.
625         */
626        if (start < map_start)
627            start = pcmcia_common_align(data, map_start);
628
629        /*
630         * If we're above the area which was passed in, there's
631         * no point proceeding.
632         */
633        if (start >= res->end)
634            break;
635
636        if ((start + size - 1) <= map_end)
637            break;
638    }
639
640    /*
641     * If we failed to find something suitable, ensure we fail.
642     */
643    if (m == data->map)
644        start = res->end;
645
646    return start;
647}
648
649/*
650 * Adjust an existing IO region allocation, but making sure that we don't
651 * encroach outside the resources which the user supplied.
652 */
653static int __nonstatic_adjust_io_region(struct pcmcia_socket *s,
654                    unsigned long r_start,
655                    unsigned long r_end)
656{
657    struct resource_map *m;
658    struct socket_data *s_data = s->resource_data;
659    int ret = -ENOMEM;
660
661    for (m = s_data->io_db.next; m != &s_data->io_db; m = m->next) {
662        unsigned long start = m->base;
663        unsigned long end = m->base + m->num - 1;
664
665        if (start > r_start || r_end > end)
666            continue;
667
668        ret = 0;
669    }
670
671    return ret;
672}
673
674/*======================================================================
675
676    These find ranges of I/O ports or memory addresses that are not
677    currently allocated by other devices.
678
679    The 'align' field should reflect the number of bits of address
680    that need to be preserved from the initial value of *base. It
681    should be a power of two, greater than or equal to 'num'. A value
682    of 0 means that all bits of *base are significant. *base should
683    also be strictly less than 'align'.
684
685======================================================================*/
686
687static struct resource *__nonstatic_find_io_region(struct pcmcia_socket *s,
688                        unsigned long base, int num,
689                        unsigned long align)
690{
691    struct resource *res = pcmcia_make_resource(0, num, IORESOURCE_IO,
692                        dev_name(&s->dev));
693    struct socket_data *s_data = s->resource_data;
694    struct pcmcia_align_data data;
695    unsigned long min = base;
696    int ret;
697
698    data.mask = align - 1;
699    data.offset = base & data.mask;
700    data.map = &s_data->io_db;
701
702#ifdef CONFIG_PCI
703    if (s->cb_dev) {
704        ret = pci_bus_alloc_resource(s->cb_dev->bus, res, num, 1,
705                         min, 0, pcmcia_align, &data);
706    } else
707#endif
708        ret = allocate_resource(&ioport_resource, res, num, min, ~0UL,
709                    1, pcmcia_align, &data);
710
711    if (ret != 0) {
712        kfree(res);
713        res = NULL;
714    }
715    return res;
716}
717
718static int nonstatic_find_io(struct pcmcia_socket *s, unsigned int attr,
719            unsigned int *base, unsigned int num,
720            unsigned int align, struct resource **parent)
721{
722    int i, ret = 0;
723
724    /* Check for an already-allocated window that must conflict with
725     * what was asked for. It is a hack because it does not catch all
726     * potential conflicts, just the most obvious ones.
727     */
728    for (i = 0; i < MAX_IO_WIN; i++) {
729        if (!s->io[i].res)
730            continue;
731
732        if (!*base)
733            continue;
734
735        if ((s->io[i].res->start & (align-1)) == *base)
736            return -EBUSY;
737    }
738
739    for (i = 0; i < MAX_IO_WIN; i++) {
740        struct resource *res = s->io[i].res;
741        unsigned int try;
742
743        if (res && (res->flags & IORESOURCE_BITS) !=
744            (attr & IORESOURCE_BITS))
745            continue;
746
747        if (!res) {
748            if (align == 0)
749                align = 0x10000;
750
751            res = s->io[i].res = __nonstatic_find_io_region(s,
752                                *base, num,
753                                align);
754            if (!res)
755                return -EINVAL;
756
757            *base = res->start;
758            s->io[i].res->flags =
759                ((res->flags & ~IORESOURCE_BITS) |
760                    (attr & IORESOURCE_BITS));
761            s->io[i].InUse = num;
762            *parent = res;
763            return 0;
764        }
765
766        /* Try to extend top of window */
767        try = res->end + 1;
768        if ((*base == 0) || (*base == try)) {
769            ret = __nonstatic_adjust_io_region(s, res->start,
770                            res->end + num);
771            if (!ret) {
772                ret = adjust_resource(s->io[i].res, res->start,
773                              resource_size(res) + num);
774                if (ret)
775                    continue;
776                *base = try;
777                s->io[i].InUse += num;
778                *parent = res;
779                return 0;
780            }
781        }
782
783        /* Try to extend bottom of window */
784        try = res->start - num;
785        if ((*base == 0) || (*base == try)) {
786            ret = __nonstatic_adjust_io_region(s,
787                            res->start - num,
788                            res->end);
789            if (!ret) {
790                ret = adjust_resource(s->io[i].res,
791                              res->start - num,
792                              resource_size(res) + num);
793                if (ret)
794                    continue;
795                *base = try;
796                s->io[i].InUse += num;
797                *parent = res;
798                return 0;
799            }
800        }
801    }
802
803    return -EINVAL;
804}
805
806
807static struct resource *nonstatic_find_mem_region(u_long base, u_long num,
808        u_long align, int low, struct pcmcia_socket *s)
809{
810    struct resource *res = pcmcia_make_resource(0, num, IORESOURCE_MEM,
811                        dev_name(&s->dev));
812    struct socket_data *s_data = s->resource_data;
813    struct pcmcia_align_data data;
814    unsigned long min, max;
815    int ret, i, j;
816
817    low = low || !(s->features & SS_CAP_PAGE_REGS);
818
819    data.mask = align - 1;
820    data.offset = base & data.mask;
821
822    for (i = 0; i < 2; i++) {
823        data.map = &s_data->mem_db_valid;
824        if (low) {
825            max = 0x100000UL;
826            min = base < max ? base : 0;
827        } else {
828            max = ~0UL;
829            min = 0x100000UL + base;
830        }
831
832        for (j = 0; j < 2; j++) {
833#ifdef CONFIG_PCI
834            if (s->cb_dev) {
835                ret = pci_bus_alloc_resource(s->cb_dev->bus,
836                            res, num, 1, min, 0,
837                            pcmcia_align, &data);
838            } else
839#endif
840            {
841                ret = allocate_resource(&iomem_resource,
842                            res, num, min, max, 1,
843                            pcmcia_align, &data);
844            }
845            if (ret == 0)
846                break;
847            data.map = &s_data->mem_db;
848        }
849        if (ret == 0 || low)
850            break;
851        low = 1;
852    }
853
854    if (ret != 0) {
855        kfree(res);
856        res = NULL;
857    }
858    return res;
859}
860
861
862static int adjust_memory(struct pcmcia_socket *s, unsigned int action, unsigned long start, unsigned long end)
863{
864    struct socket_data *data = s->resource_data;
865    unsigned long size = end - start + 1;
866    int ret = 0;
867
868    if (end < start)
869        return -EINVAL;
870
871    switch (action) {
872    case ADD_MANAGED_RESOURCE:
873        ret = add_interval(&data->mem_db, start, size);
874        if (!ret)
875            do_mem_probe(s, start, size, NULL, NULL);
876        break;
877    case REMOVE_MANAGED_RESOURCE:
878        ret = sub_interval(&data->mem_db, start, size);
879        break;
880    default:
881        ret = -EINVAL;
882    }
883
884    return ret;
885}
886
887
888static int adjust_io(struct pcmcia_socket *s, unsigned int action, unsigned long start, unsigned long end)
889{
890    struct socket_data *data = s->resource_data;
891    unsigned long size;
892    int ret = 0;
893
894#if defined(CONFIG_X86)
895    /* on x86, avoid anything < 0x100 for it is often used for
896     * legacy platform devices */
897    if (start < 0x100)
898        start = 0x100;
899#endif
900
901    size = end - start + 1;
902
903    if (end < start)
904        return -EINVAL;
905
906    if (end > IO_SPACE_LIMIT)
907        return -EINVAL;
908
909    switch (action) {
910    case ADD_MANAGED_RESOURCE:
911        if (add_interval(&data->io_db, start, size) != 0) {
912            ret = -EBUSY;
913            break;
914        }
915#ifdef CONFIG_PCMCIA_PROBE
916        if (probe_io)
917            do_io_probe(s, start, size);
918#endif
919        break;
920    case REMOVE_MANAGED_RESOURCE:
921        sub_interval(&data->io_db, start, size);
922        break;
923    default:
924        ret = -EINVAL;
925        break;
926    }
927
928    return ret;
929}
930
931
932#ifdef CONFIG_PCI
933static int nonstatic_autoadd_resources(struct pcmcia_socket *s)
934{
935    struct resource *res;
936    int i, done = 0;
937
938    if (!s->cb_dev || !s->cb_dev->bus)
939        return -ENODEV;
940
941#if defined(CONFIG_X86)
942    /* If this is the root bus, the risk of hitting some strange
943     * system devices is too high: If a driver isn't loaded, the
944     * resources are not claimed; even if a driver is loaded, it
945     * may not request all resources or even the wrong one. We
946     * can neither trust the rest of the kernel nor ACPI/PNP and
947     * CRS parsing to get it right. Therefore, use several
948     * safeguards:
949     *
950     * - Do not auto-add resources if the CardBus bridge is on
951     * the PCI root bus
952     *
953     * - Avoid any I/O ports < 0x100.
954     *
955     * - On PCI-PCI bridges, only use resources which are set up
956     * exclusively for the secondary PCI bus: the risk of hitting
957     * system devices is quite low, as they usually aren't
958     * connected to the secondary PCI bus.
959     */
960    if (s->cb_dev->bus->number == 0)
961        return -EINVAL;
962
963    for (i = 0; i < PCI_BRIDGE_RESOURCE_NUM; i++) {
964        res = s->cb_dev->bus->resource[i];
965#else
966    pci_bus_for_each_resource(s->cb_dev->bus, res, i) {
967#endif
968        if (!res)
969            continue;
970
971        if (res->flags & IORESOURCE_IO) {
972            /* safeguard against the root resource, where the
973             * risk of hitting any other device would be too
974             * high */
975            if (res == &ioport_resource)
976                continue;
977
978            dev_printk(KERN_INFO, &s->cb_dev->dev,
979                   "pcmcia: parent PCI bridge window: %pR\n",
980                   res);
981            if (!adjust_io(s, ADD_MANAGED_RESOURCE, res->start, res->end))
982                done |= IORESOURCE_IO;
983
984        }
985
986        if (res->flags & IORESOURCE_MEM) {
987            /* safeguard against the root resource, where the
988             * risk of hitting any other device would be too
989             * high */
990            if (res == &iomem_resource)
991                continue;
992
993            dev_printk(KERN_INFO, &s->cb_dev->dev,
994                   "pcmcia: parent PCI bridge window: %pR\n",
995                   res);
996            if (!adjust_memory(s, ADD_MANAGED_RESOURCE, res->start, res->end))
997                done |= IORESOURCE_MEM;
998        }
999    }
1000
1001    /* if we got at least one of IO, and one of MEM, we can be glad and
1002     * activate the PCMCIA subsystem */
1003    if (done == (IORESOURCE_MEM | IORESOURCE_IO))
1004        s->resource_setup_done = 1;
1005
1006    return 0;
1007}
1008
1009#else
1010
1011static inline int nonstatic_autoadd_resources(struct pcmcia_socket *s)
1012{
1013    return -ENODEV;
1014}
1015
1016#endif
1017
1018
1019static int nonstatic_init(struct pcmcia_socket *s)
1020{
1021    struct socket_data *data;
1022
1023    data = kzalloc(sizeof(struct socket_data), GFP_KERNEL);
1024    if (!data)
1025        return -ENOMEM;
1026
1027    data->mem_db.next = &data->mem_db;
1028    data->mem_db_valid.next = &data->mem_db_valid;
1029    data->io_db.next = &data->io_db;
1030
1031    s->resource_data = (void *) data;
1032
1033    nonstatic_autoadd_resources(s);
1034
1035    return 0;
1036}
1037
1038static void nonstatic_release_resource_db(struct pcmcia_socket *s)
1039{
1040    struct socket_data *data = s->resource_data;
1041    struct resource_map *p, *q;
1042
1043    for (p = data->mem_db_valid.next; p != &data->mem_db_valid; p = q) {
1044        q = p->next;
1045        kfree(p);
1046    }
1047    for (p = data->mem_db.next; p != &data->mem_db; p = q) {
1048        q = p->next;
1049        kfree(p);
1050    }
1051    for (p = data->io_db.next; p != &data->io_db; p = q) {
1052        q = p->next;
1053        kfree(p);
1054    }
1055}
1056
1057
1058struct pccard_resource_ops pccard_nonstatic_ops = {
1059    .validate_mem = pcmcia_nonstatic_validate_mem,
1060    .find_io = nonstatic_find_io,
1061    .find_mem = nonstatic_find_mem_region,
1062    .init = nonstatic_init,
1063    .exit = nonstatic_release_resource_db,
1064};
1065EXPORT_SYMBOL(pccard_nonstatic_ops);
1066
1067
1068/* sysfs interface to the resource database */
1069
1070static ssize_t show_io_db(struct device *dev,
1071              struct device_attribute *attr, char *buf)
1072{
1073    struct pcmcia_socket *s = dev_get_drvdata(dev);
1074    struct socket_data *data;
1075    struct resource_map *p;
1076    ssize_t ret = 0;
1077
1078    mutex_lock(&s->ops_mutex);
1079    data = s->resource_data;
1080
1081    for (p = data->io_db.next; p != &data->io_db; p = p->next) {
1082        if (ret > (PAGE_SIZE - 10))
1083            continue;
1084        ret += snprintf(&buf[ret], (PAGE_SIZE - ret - 1),
1085                "0x%08lx - 0x%08lx\n",
1086                ((unsigned long) p->base),
1087                ((unsigned long) p->base + p->num - 1));
1088    }
1089
1090    mutex_unlock(&s->ops_mutex);
1091    return ret;
1092}
1093
1094static ssize_t store_io_db(struct device *dev,
1095               struct device_attribute *attr,
1096               const char *buf, size_t count)
1097{
1098    struct pcmcia_socket *s = dev_get_drvdata(dev);
1099    unsigned long start_addr, end_addr;
1100    unsigned int add = ADD_MANAGED_RESOURCE;
1101    ssize_t ret = 0;
1102
1103    ret = sscanf(buf, "+ 0x%lx - 0x%lx", &start_addr, &end_addr);
1104    if (ret != 2) {
1105        ret = sscanf(buf, "- 0x%lx - 0x%lx", &start_addr, &end_addr);
1106        add = REMOVE_MANAGED_RESOURCE;
1107        if (ret != 2) {
1108            ret = sscanf(buf, "0x%lx - 0x%lx", &start_addr,
1109                &end_addr);
1110            add = ADD_MANAGED_RESOURCE;
1111            if (ret != 2)
1112                return -EINVAL;
1113        }
1114    }
1115    if (end_addr < start_addr)
1116        return -EINVAL;
1117
1118    mutex_lock(&s->ops_mutex);
1119    ret = adjust_io(s, add, start_addr, end_addr);
1120    mutex_unlock(&s->ops_mutex);
1121
1122    return ret ? ret : count;
1123}
1124static DEVICE_ATTR(available_resources_io, 0600, show_io_db, store_io_db);
1125
1126static ssize_t show_mem_db(struct device *dev,
1127               struct device_attribute *attr, char *buf)
1128{
1129    struct pcmcia_socket *s = dev_get_drvdata(dev);
1130    struct socket_data *data;
1131    struct resource_map *p;
1132    ssize_t ret = 0;
1133
1134    mutex_lock(&s->ops_mutex);
1135    data = s->resource_data;
1136
1137    for (p = data->mem_db_valid.next; p != &data->mem_db_valid;
1138         p = p->next) {
1139        if (ret > (PAGE_SIZE - 10))
1140            continue;
1141        ret += snprintf(&buf[ret], (PAGE_SIZE - ret - 1),
1142                "0x%08lx - 0x%08lx\n",
1143                ((unsigned long) p->base),
1144                ((unsigned long) p->base + p->num - 1));
1145    }
1146
1147    for (p = data->mem_db.next; p != &data->mem_db; p = p->next) {
1148        if (ret > (PAGE_SIZE - 10))
1149            continue;
1150        ret += snprintf(&buf[ret], (PAGE_SIZE - ret - 1),
1151                "0x%08lx - 0x%08lx\n",
1152                ((unsigned long) p->base),
1153                ((unsigned long) p->base + p->num - 1));
1154    }
1155
1156    mutex_unlock(&s->ops_mutex);
1157    return ret;
1158}
1159
1160static ssize_t store_mem_db(struct device *dev,
1161                struct device_attribute *attr,
1162                const char *buf, size_t count)
1163{
1164    struct pcmcia_socket *s = dev_get_drvdata(dev);
1165    unsigned long start_addr, end_addr;
1166    unsigned int add = ADD_MANAGED_RESOURCE;
1167    ssize_t ret = 0;
1168
1169    ret = sscanf(buf, "+ 0x%lx - 0x%lx", &start_addr, &end_addr);
1170    if (ret != 2) {
1171        ret = sscanf(buf, "- 0x%lx - 0x%lx", &start_addr, &end_addr);
1172        add = REMOVE_MANAGED_RESOURCE;
1173        if (ret != 2) {
1174            ret = sscanf(buf, "0x%lx - 0x%lx", &start_addr,
1175                &end_addr);
1176            add = ADD_MANAGED_RESOURCE;
1177            if (ret != 2)
1178                return -EINVAL;
1179        }
1180    }
1181    if (end_addr < start_addr)
1182        return -EINVAL;
1183
1184    mutex_lock(&s->ops_mutex);
1185    ret = adjust_memory(s, add, start_addr, end_addr);
1186    mutex_unlock(&s->ops_mutex);
1187
1188    return ret ? ret : count;
1189}
1190static DEVICE_ATTR(available_resources_mem, 0600, show_mem_db, store_mem_db);
1191
1192static struct attribute *pccard_rsrc_attributes[] = {
1193    &dev_attr_available_resources_io.attr,
1194    &dev_attr_available_resources_mem.attr,
1195    NULL,
1196};
1197
1198static const struct attribute_group rsrc_attributes = {
1199    .attrs = pccard_rsrc_attributes,
1200};
1201
1202static int __devinit pccard_sysfs_add_rsrc(struct device *dev,
1203                       struct class_interface *class_intf)
1204{
1205    struct pcmcia_socket *s = dev_get_drvdata(dev);
1206
1207    if (s->resource_ops != &pccard_nonstatic_ops)
1208        return 0;
1209    return sysfs_create_group(&dev->kobj, &rsrc_attributes);
1210}
1211
1212static void __devexit pccard_sysfs_remove_rsrc(struct device *dev,
1213                           struct class_interface *class_intf)
1214{
1215    struct pcmcia_socket *s = dev_get_drvdata(dev);
1216
1217    if (s->resource_ops != &pccard_nonstatic_ops)
1218        return;
1219    sysfs_remove_group(&dev->kobj, &rsrc_attributes);
1220}
1221
1222static struct class_interface pccard_rsrc_interface __refdata = {
1223    .class = &pcmcia_socket_class,
1224    .add_dev = &pccard_sysfs_add_rsrc,
1225    .remove_dev = __devexit_p(&pccard_sysfs_remove_rsrc),
1226};
1227
1228static int __init nonstatic_sysfs_init(void)
1229{
1230    return class_interface_register(&pccard_rsrc_interface);
1231}
1232
1233static void __exit nonstatic_sysfs_exit(void)
1234{
1235    class_interface_unregister(&pccard_rsrc_interface);
1236}
1237
1238module_init(nonstatic_sysfs_init);
1239module_exit(nonstatic_sysfs_exit);
1240

Archive Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9



interactive