← Back to branch summary

~ubuntu-branches/ubuntu/maverick/linux-backports-modules-2.6.32/maverick

« back to all changes in this revision

Viewing changes to updates/compat-wireless-2.6/drivers/net/wireless/ath/ath9k/ahb.c

  • Committer: Bazaar Package Importer
  • Author(s): Andy Whitcroft, Andy Whitcroft
  • Date: 2010-02-04 23:15:51 UTC
  • Revision ID: james.westby@ubuntu.com-20100204231551-vjz5pkvxclukjxm1
Tags: 2.6.32-12.1
[ Andy Whitcroft ]

* initial LBM for lucid
* drop generated files
* printchanges -- rebase tree does not have stable tags use changelog
* printenv -- add revisions to printenv output
* formally rename compat-wireless to linux-backports-modules-wireless
* Update to compat-wireless-2.6.33-rc5
* update nouveau to mainline 2.6.33-rc4
* add new LBM package for nouveau
* nouveau -- fix major numbers and proc entry names
* fix up firmware installs for -wireless
* clean up UPDATE-NOVEAU
* update Nouveau to v2.6.33-rc6

Show diffs side-by-side

added added

removed removed

Lines of Context:
updates/compat-wireless-2.6/drivers/net/wireless/ath/ath9k/ahb.c
 
1
/*
 
2
 * Copyright (c) 2008-2009 Atheros Communications Inc.
 
3
 * Copyright (c) 2009 Gabor Juhos <juhosg@openwrt.org>
 
4
 * Copyright (c) 2009 Imre Kaloz <kaloz@openwrt.org>
 
5
 *
 
6
 * Permission to use, copy, modify, and/or distribute this software for any
 
7
 * purpose with or without fee is hereby granted, provided that the above
 
8
 * copyright notice and this permission notice appear in all copies.
 
9
 *
 
10
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 
11
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 
12
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 
13
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 
14
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 
15
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 
16
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
17
 */
 
18
 
 
19
#include <linux/nl80211.h>
 
20
#include <linux/platform_device.h>
 
21
#include <linux/ath9k_platform.h>
 
22
#include "ath9k.h"
 
23
 
 
24
/* return bus cachesize in 4B word units */
 
25
static void ath_ahb_read_cachesize(struct ath_common *common, int *csz)
 
26
{
 
27
        *csz = L1_CACHE_BYTES >> 2;
 
28
}
 
29
 
 
30
static void ath_ahb_cleanup(struct ath_common *common)
 
31
{
 
32
        struct ath_softc *sc = (struct ath_softc *)common->priv;
 
33
        iounmap(sc->mem);
 
34
}
 
35
 
 
36
static bool ath_ahb_eeprom_read(struct ath_common *common, u32 off, u16 *data)
 
37
{
 
38
        struct ath_softc *sc = (struct ath_softc *)common->priv;
 
39
        struct platform_device *pdev = to_platform_device(sc->dev);
 
40
        struct ath9k_platform_data *pdata;
 
41
 
 
42
        pdata = (struct ath9k_platform_data *) pdev->dev.platform_data;
 
43
        if (off >= (ARRAY_SIZE(pdata->eeprom_data))) {
 
44
                ath_print(common, ATH_DBG_FATAL,
 
45
                          "%s: flash read failed, offset %08x "
 
46
                          "is out of range\n",
 
47
                          __func__, off);
 
48
                return false;
 
49
        }
 
50
 
 
51
        *data = pdata->eeprom_data[off];
 
52
        return true;
 
53
}
 
54
 
 
55
static struct ath_bus_ops ath_ahb_bus_ops  = {
 
56
        .read_cachesize = ath_ahb_read_cachesize,
 
57
        .cleanup = ath_ahb_cleanup,
 
58
 
 
59
        .eeprom_read = ath_ahb_eeprom_read,
 
60
};
 
61
 
 
62
static int ath_ahb_probe(struct platform_device *pdev)
 
63
{
 
64
        void __iomem *mem;
 
65
        struct ath_wiphy *aphy;
 
66
        struct ath_softc *sc;
 
67
        struct ieee80211_hw *hw;
 
68
        struct resource *res;
 
69
        int irq;
 
70
        int ret = 0;
 
71
        struct ath_hw *ah;
 
72
        char hw_name[64];
 
73
 
 
74
        if (!pdev->dev.platform_data) {
 
75
                dev_err(&pdev->dev, "no platform data specified\n");
 
76
                ret = -EINVAL;
 
77
                goto err_out;
 
78
        }
 
79
 
 
80
        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 
81
        if (res == NULL) {
 
82
                dev_err(&pdev->dev, "no memory resource found\n");
 
83
                ret = -ENXIO;
 
84
                goto err_out;
 
85
        }
 
86
 
 
87
        mem = ioremap_nocache(res->start, res->end - res->start + 1);
 
88
        if (mem == NULL) {
 
89
                dev_err(&pdev->dev, "ioremap failed\n");
 
90
                ret = -ENOMEM;
 
91
                goto err_out;
 
92
        }
 
93
 
 
94
        res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
 
95
        if (res == NULL) {
 
96
                dev_err(&pdev->dev, "no IRQ resource found\n");
 
97
                ret = -ENXIO;
 
98
                goto err_iounmap;
 
99
        }
 
100
 
 
101
        irq = res->start;
 
102
 
 
103
        hw = ieee80211_alloc_hw(sizeof(struct ath_wiphy) +
 
104
                                sizeof(struct ath_softc), &ath9k_ops);
 
105
        if (hw == NULL) {
 
106
                dev_err(&pdev->dev, "no memory for ieee80211_hw\n");
 
107
                ret = -ENOMEM;
 
108
                goto err_iounmap;
 
109
        }
 
110
 
 
111
        SET_IEEE80211_DEV(hw, &pdev->dev);
 
112
        platform_set_drvdata(pdev, hw);
 
113
 
 
114
        aphy = hw->priv;
 
115
        sc = (struct ath_softc *) (aphy + 1);
 
116
        aphy->sc = sc;
 
117
        aphy->hw = hw;
 
118
        sc->pri_wiphy = aphy;
 
119
        sc->hw = hw;
 
120
        sc->dev = &pdev->dev;
 
121
        sc->mem = mem;
 
122
        sc->irq = irq;
 
123
 
 
124
        ret = ath_init_device(AR5416_AR9100_DEVID, sc, 0x0, &ath_ahb_bus_ops);
 
125
        if (ret) {
 
126
                dev_err(&pdev->dev, "failed to initialize device\n");
 
127
                goto err_free_hw;
 
128
        }
 
129
 
 
130
        ret = request_irq(irq, ath_isr, IRQF_SHARED, "ath9k", sc);
 
131
        if (ret) {
 
132
                dev_err(&pdev->dev, "request_irq failed\n");
 
133
                goto err_detach;
 
134
        }
 
135
 
 
136
        ah = sc->sc_ah;
 
137
        ath9k_hw_name(ah, hw_name, sizeof(hw_name));
 
138
        printk(KERN_INFO
 
139
               "%s: %s mem=0x%lx, irq=%d\n",
 
140
               wiphy_name(hw->wiphy),
 
141
               hw_name,
 
142
               (unsigned long)mem, irq);
 
143
 
 
144
        return 0;
 
145
 
 
146
 err_detach:
 
147
        ath_detach(sc);
 
148
 err_free_hw:
 
149
        ieee80211_free_hw(hw);
 
150
        platform_set_drvdata(pdev, NULL);
 
151
 err_iounmap:
 
152
        iounmap(mem);
 
153
 err_out:
 
154
        return ret;
 
155
}
 
156
 
 
157
static int ath_ahb_remove(struct platform_device *pdev)
 
158
{
 
159
        struct ieee80211_hw *hw = platform_get_drvdata(pdev);
 
160
 
 
161
        if (hw) {
 
162
                struct ath_wiphy *aphy = hw->priv;
 
163
                struct ath_softc *sc = aphy->sc;
 
164
 
 
165
                ath_cleanup(sc);
 
166
                platform_set_drvdata(pdev, NULL);
 
167
        }
 
168
 
 
169
        return 0;
 
170
}
 
171
 
 
172
static struct platform_driver ath_ahb_driver = {
 
173
        .probe      = ath_ahb_probe,
 
174
        .remove     = ath_ahb_remove,
 
175
        .driver         = {
 
176
                .name   = "ath9k",
 
177
                .owner  = THIS_MODULE,
 
178
        },
 
179
};
 
180
 
 
181
int ath_ahb_init(void)
 
182
{
 
183
        return platform_driver_register(&ath_ahb_driver);
 
184
}
 
185
 
 
186
void ath_ahb_exit(void)
 
187
{
 
188
        platform_driver_unregister(&ath_ahb_driver);
 
189
}