4065139753b6c4b6e9e1becf06df11234bde8b5f
[sfrench/cifs-2.6.git] / drivers / pnp / quirks.c
1 /*
2  *  This file contains quirk handling code for PnP devices
3  *  Some devices do not report all their resources, and need to have extra
4  *  resources added. This is most easily accomplished at initialisation time
5  *  when building up the resource structure for the first time.
6  *
7  *  Copyright (c) 2000 Peter Denison <peterd@pnd-pc.demon.co.uk>
8  *
9  *  Heavily based on PCI quirks handling which is
10  *
11  *  Copyright (c) 1999 Martin Mares <mj@ucw.cz>
12  */
13
14 #include <linux/types.h>
15 #include <linux/kernel.h>
16 #include <linux/string.h>
17 #include <linux/slab.h>
18 #include <linux/pnp.h>
19 #include <linux/io.h>
20 #include <linux/dmi.h>
21 #include <linux/kallsyms.h>
22 #include "base.h"
23
24 static void quirk_awe32_resources(struct pnp_dev *dev)
25 {
26         struct pnp_port *port, *port2, *port3;
27         struct pnp_option *res = dev->dependent;
28
29         /*
30          * Unfortunately the isapnp_add_port_resource is too tightly bound
31          * into the PnP discovery sequence, and cannot be used. Link in the
32          * two extra ports (at offset 0x400 and 0x800 from the one given) by
33          * hand.
34          */
35         for (; res; res = res->next) {
36                 port2 = pnp_alloc(sizeof(struct pnp_port));
37                 if (!port2)
38                         return;
39                 port3 = pnp_alloc(sizeof(struct pnp_port));
40                 if (!port3) {
41                         kfree(port2);
42                         return;
43                 }
44                 port = res->port;
45                 memcpy(port2, port, sizeof(struct pnp_port));
46                 memcpy(port3, port, sizeof(struct pnp_port));
47                 port->next = port2;
48                 port2->next = port3;
49                 port2->min += 0x400;
50                 port2->max += 0x400;
51                 port3->min += 0x800;
52                 port3->max += 0x800;
53         }
54         printk(KERN_INFO "pnp: AWE32 quirk - adding two ports\n");
55 }
56
57 static void quirk_cmi8330_resources(struct pnp_dev *dev)
58 {
59         struct pnp_option *res = dev->dependent;
60         unsigned long tmp;
61
62         for (; res; res = res->next) {
63
64                 struct pnp_irq *irq;
65                 struct pnp_dma *dma;
66
67                 for (irq = res->irq; irq; irq = irq->next) {    // Valid irqs are 5, 7, 10
68                         tmp = 0x04A0;
69                         bitmap_copy(irq->map, &tmp, 16);        // 0000 0100 1010 0000
70                 }
71
72                 for (dma = res->dma; dma; dma = dma->next)      // Valid 8bit dma channels are 1,3
73                         if ((dma->flags & IORESOURCE_DMA_TYPE_MASK) ==
74                             IORESOURCE_DMA_8BIT)
75                                 dma->map = 0x000A;
76         }
77         printk(KERN_INFO "pnp: CMI8330 quirk - fixing interrupts and dma\n");
78 }
79
80 static void quirk_sb16audio_resources(struct pnp_dev *dev)
81 {
82         struct pnp_port *port;
83         struct pnp_option *res = dev->dependent;
84         int changed = 0;
85
86         /*
87          * The default range on the mpu port for these devices is 0x388-0x388.
88          * Here we increase that range so that two such cards can be
89          * auto-configured.
90          */
91
92         for (; res; res = res->next) {
93                 port = res->port;
94                 if (!port)
95                         continue;
96                 port = port->next;
97                 if (!port)
98                         continue;
99                 port = port->next;
100                 if (!port)
101                         continue;
102                 if (port->min != port->max)
103                         continue;
104                 port->max += 0x70;
105                 changed = 1;
106         }
107         if (changed)
108                 printk(KERN_INFO
109                        "pnp: SB audio device quirk - increasing port range\n");
110 }
111
112 static void quirk_supermicro_h8dce_system(struct pnp_dev *dev)
113 {
114         int i;
115         static struct dmi_system_id supermicro_h8dce[] = {
116                 {
117                         .ident = "Supermicro H8DCE",
118                         .matches = {
119                                 DMI_MATCH(DMI_SYS_VENDOR, "Supermicro"),
120                                 DMI_MATCH(DMI_PRODUCT_NAME, "H8DCE"),
121                         },
122                 },
123                 { }
124         };
125
126         if (!dmi_check_system(supermicro_h8dce))
127                 return;
128
129         /*
130          * On the Supermicro H8DCE, there's a system device with resources
131          * that overlap BAR 6 of the built-in SATA PCI adapter.  If the PNP
132          * system device claims them, the sata_nv driver won't be able to.
133          * More details at:
134          *     https://bugzilla.redhat.com/show_bug.cgi?id=280641
135          *     https://bugzilla.redhat.com/show_bug.cgi?id=313491
136          *     http://lkml.org/lkml/2008/1/9/449
137          *     http://thread.gmane.org/gmane.linux.acpi.devel/27312
138          */
139         for (i = 0; i < PNP_MAX_MEM; i++) {
140                 if (pnp_mem_valid(dev, i) && pnp_mem_len(dev, i) &&
141                     (pnp_mem_start(dev, i) & 0xdfef0000) == 0xdfef0000) {
142                         dev_warn(&dev->dev, "disabling 0x%llx-0x%llx to prevent"
143                                 " conflict with sata_nv PCI device\n",
144                                 (unsigned long long) pnp_mem_start(dev, i),
145                                 (unsigned long long) (pnp_mem_start(dev, i) +
146                                         pnp_mem_len(dev, i) - 1));
147                         pnp_mem_flags(dev, i) = 0;
148                 }
149         }
150 }
151
152 /*
153  *  PnP Quirks
154  *  Cards or devices that need some tweaking due to incomplete resource info
155  */
156
157 static struct pnp_fixup pnp_fixups[] = {
158         /* Soundblaster awe io port quirk */
159         {"CTL0021", quirk_awe32_resources},
160         {"CTL0022", quirk_awe32_resources},
161         {"CTL0023", quirk_awe32_resources},
162         /* CMI 8330 interrupt and dma fix */
163         {"@X@0001", quirk_cmi8330_resources},
164         /* Soundblaster audio device io port range quirk */
165         {"CTL0001", quirk_sb16audio_resources},
166         {"CTL0031", quirk_sb16audio_resources},
167         {"CTL0041", quirk_sb16audio_resources},
168         {"CTL0042", quirk_sb16audio_resources},
169         {"CTL0043", quirk_sb16audio_resources},
170         {"CTL0044", quirk_sb16audio_resources},
171         {"CTL0045", quirk_sb16audio_resources},
172         {"PNP0c01", quirk_supermicro_h8dce_system},
173         {"PNP0c02", quirk_supermicro_h8dce_system},
174         {""}
175 };
176
177 void pnp_fixup_device(struct pnp_dev *dev)
178 {
179         int i = 0;
180         void (*quirk)(struct pnp_dev *);
181
182         while (*pnp_fixups[i].id) {
183                 if (compare_pnp_id(dev->id, pnp_fixups[i].id)) {
184                         quirk = pnp_fixups[i].quirk_function;
185
186 #ifdef DEBUG
187                         dev_dbg(&dev->dev, "calling quirk 0x%p", quirk);
188                         print_fn_descriptor_symbol(": %s()\n",
189                                 (unsigned long) *quirk);
190 #endif
191                         (*quirk)(dev);
192                 }
193                 i++;
194         }
195 }