diff options
author | Jonathan Herman <hermanjl@cs.unc.edu> | 2013-01-22 10:38:37 -0500 |
---|---|---|
committer | Jonathan Herman <hermanjl@cs.unc.edu> | 2013-01-22 10:38:37 -0500 |
commit | fcc9d2e5a6c89d22b8b773a64fb4ad21ac318446 (patch) | |
tree | a57612d1888735a2ec7972891b68c1ac5ec8faea /drivers/net/wireless/wl12xx/io.h | |
parent | 8dea78da5cee153b8af9c07a2745f6c55057fe12 (diff) |
Diffstat (limited to 'drivers/net/wireless/wl12xx/io.h')
-rw-r--r-- | drivers/net/wireless/wl12xx/io.h | 191 |
1 files changed, 191 insertions, 0 deletions
diff --git a/drivers/net/wireless/wl12xx/io.h b/drivers/net/wireless/wl12xx/io.h new file mode 100644 index 00000000000..a2fe4f506ad --- /dev/null +++ b/drivers/net/wireless/wl12xx/io.h | |||
@@ -0,0 +1,191 @@ | |||
1 | /* | ||
2 | * This file is part of wl1271 | ||
3 | * | ||
4 | * Copyright (C) 1998-2009 Texas Instruments. All rights reserved. | ||
5 | * Copyright (C) 2008-2010 Nokia Corporation | ||
6 | * | ||
7 | * Contact: Luciano Coelho <luciano.coelho@nokia.com> | ||
8 | * | ||
9 | * This program is free software; you can redistribute it and/or | ||
10 | * modify it under the terms of the GNU General Public License | ||
11 | * version 2 as published by the Free Software Foundation. | ||
12 | * | ||
13 | * This program is distributed in the hope that it will be useful, but | ||
14 | * WITHOUT ANY WARRANTY; without even the implied warranty of | ||
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
16 | * General Public License for more details. | ||
17 | * | ||
18 | * You should have received a copy of the GNU General Public License | ||
19 | * along with this program; if not, write to the Free Software | ||
20 | * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA | ||
21 | * 02110-1301 USA | ||
22 | * | ||
23 | */ | ||
24 | |||
25 | #ifndef __IO_H__ | ||
26 | #define __IO_H__ | ||
27 | |||
28 | #include <linux/irqreturn.h> | ||
29 | #include "reg.h" | ||
30 | |||
31 | #define HW_ACCESS_MEMORY_MAX_RANGE 0x1FFC0 | ||
32 | |||
33 | #define HW_PARTITION_REGISTERS_ADDR 0x1FFC0 | ||
34 | #define HW_PART0_SIZE_ADDR (HW_PARTITION_REGISTERS_ADDR) | ||
35 | #define HW_PART0_START_ADDR (HW_PARTITION_REGISTERS_ADDR + 4) | ||
36 | #define HW_PART1_SIZE_ADDR (HW_PARTITION_REGISTERS_ADDR + 8) | ||
37 | #define HW_PART1_START_ADDR (HW_PARTITION_REGISTERS_ADDR + 12) | ||
38 | #define HW_PART2_SIZE_ADDR (HW_PARTITION_REGISTERS_ADDR + 16) | ||
39 | #define HW_PART2_START_ADDR (HW_PARTITION_REGISTERS_ADDR + 20) | ||
40 | #define HW_PART3_START_ADDR (HW_PARTITION_REGISTERS_ADDR + 24) | ||
41 | |||
42 | #define HW_ACCESS_REGISTER_SIZE 4 | ||
43 | |||
44 | #define HW_ACCESS_PRAM_MAX_RANGE 0x3c000 | ||
45 | |||
46 | struct wl1271; | ||
47 | |||
48 | void wl1271_disable_interrupts(struct wl1271 *wl); | ||
49 | void wl1271_enable_interrupts(struct wl1271 *wl); | ||
50 | |||
51 | void wl1271_io_reset(struct wl1271 *wl); | ||
52 | void wl1271_io_init(struct wl1271 *wl); | ||
53 | |||
54 | static inline struct device *wl1271_wl_to_dev(struct wl1271 *wl) | ||
55 | { | ||
56 | return wl->if_ops->dev(wl); | ||
57 | } | ||
58 | |||
59 | |||
60 | /* Raw target IO, address is not translated */ | ||
61 | static inline void wl1271_raw_write(struct wl1271 *wl, int addr, void *buf, | ||
62 | size_t len, bool fixed) | ||
63 | { | ||
64 | wl->if_ops->write(wl, addr, buf, len, fixed); | ||
65 | } | ||
66 | |||
67 | static inline void wl1271_raw_read(struct wl1271 *wl, int addr, void *buf, | ||
68 | size_t len, bool fixed) | ||
69 | { | ||
70 | wl->if_ops->read(wl, addr, buf, len, fixed); | ||
71 | } | ||
72 | |||
73 | static inline u32 wl1271_raw_read32(struct wl1271 *wl, int addr) | ||
74 | { | ||
75 | wl1271_raw_read(wl, addr, &wl->buffer_32, | ||
76 | sizeof(wl->buffer_32), false); | ||
77 | |||
78 | return le32_to_cpu(wl->buffer_32); | ||
79 | } | ||
80 | |||
81 | static inline void wl1271_raw_write32(struct wl1271 *wl, int addr, u32 val) | ||
82 | { | ||
83 | wl->buffer_32 = cpu_to_le32(val); | ||
84 | wl1271_raw_write(wl, addr, &wl->buffer_32, | ||
85 | sizeof(wl->buffer_32), false); | ||
86 | } | ||
87 | |||
88 | /* Translated target IO */ | ||
89 | static inline int wl1271_translate_addr(struct wl1271 *wl, int addr) | ||
90 | { | ||
91 | /* | ||
92 | * To translate, first check to which window of addresses the | ||
93 | * particular address belongs. Then subtract the starting address | ||
94 | * of that window from the address. Then, add offset of the | ||
95 | * translated region. | ||
96 | * | ||
97 | * The translated regions occur next to each other in physical device | ||
98 | * memory, so just add the sizes of the preceding address regions to | ||
99 | * get the offset to the new region. | ||
100 | * | ||
101 | * Currently, only the two first regions are addressed, and the | ||
102 | * assumption is that all addresses will fall into either of those | ||
103 | * two. | ||
104 | */ | ||
105 | if ((addr >= wl->part.reg.start) && | ||
106 | (addr < wl->part.reg.start + wl->part.reg.size)) | ||
107 | return addr - wl->part.reg.start + wl->part.mem.size; | ||
108 | else | ||
109 | return addr - wl->part.mem.start; | ||
110 | } | ||
111 | |||
112 | static inline void wl1271_read(struct wl1271 *wl, int addr, void *buf, | ||
113 | size_t len, bool fixed) | ||
114 | { | ||
115 | int physical; | ||
116 | |||
117 | physical = wl1271_translate_addr(wl, addr); | ||
118 | |||
119 | wl1271_raw_read(wl, physical, buf, len, fixed); | ||
120 | } | ||
121 | |||
122 | static inline void wl1271_write(struct wl1271 *wl, int addr, void *buf, | ||
123 | size_t len, bool fixed) | ||
124 | { | ||
125 | int physical; | ||
126 | |||
127 | physical = wl1271_translate_addr(wl, addr); | ||
128 | |||
129 | wl1271_raw_write(wl, physical, buf, len, fixed); | ||
130 | } | ||
131 | |||
132 | static inline void wl1271_read_hwaddr(struct wl1271 *wl, int hwaddr, | ||
133 | void *buf, size_t len, bool fixed) | ||
134 | { | ||
135 | int physical; | ||
136 | int addr; | ||
137 | |||
138 | /* Addresses are stored internally as addresses to 32 bytes blocks */ | ||
139 | addr = hwaddr << 5; | ||
140 | |||
141 | physical = wl1271_translate_addr(wl, addr); | ||
142 | |||
143 | wl1271_raw_read(wl, physical, buf, len, fixed); | ||
144 | } | ||
145 | |||
146 | static inline u32 wl1271_read32(struct wl1271 *wl, int addr) | ||
147 | { | ||
148 | return wl1271_raw_read32(wl, wl1271_translate_addr(wl, addr)); | ||
149 | } | ||
150 | |||
151 | static inline void wl1271_write32(struct wl1271 *wl, int addr, u32 val) | ||
152 | { | ||
153 | wl1271_raw_write32(wl, wl1271_translate_addr(wl, addr), val); | ||
154 | } | ||
155 | |||
156 | static inline void wl1271_power_off(struct wl1271 *wl) | ||
157 | { | ||
158 | wl->if_ops->power(wl, false); | ||
159 | clear_bit(WL1271_FLAG_GPIO_POWER, &wl->flags); | ||
160 | } | ||
161 | |||
162 | static inline int wl1271_power_on(struct wl1271 *wl) | ||
163 | { | ||
164 | int ret = wl->if_ops->power(wl, true); | ||
165 | if (ret == 0) | ||
166 | set_bit(WL1271_FLAG_GPIO_POWER, &wl->flags); | ||
167 | |||
168 | return ret; | ||
169 | } | ||
170 | |||
171 | |||
172 | /* Top Register IO */ | ||
173 | void wl1271_top_reg_write(struct wl1271 *wl, int addr, u16 val); | ||
174 | u16 wl1271_top_reg_read(struct wl1271 *wl, int addr); | ||
175 | |||
176 | int wl1271_set_partition(struct wl1271 *wl, | ||
177 | struct wl1271_partition_set *p); | ||
178 | |||
179 | /* Functions from wl1271_main.c */ | ||
180 | |||
181 | int wl1271_register_hw(struct wl1271 *wl); | ||
182 | void wl1271_unregister_hw(struct wl1271 *wl); | ||
183 | int wl1271_init_ieee80211(struct wl1271 *wl); | ||
184 | struct ieee80211_hw *wl1271_alloc_hw(void); | ||
185 | int wl1271_free_hw(struct wl1271 *wl); | ||
186 | irqreturn_t wl1271_irq(int irq, void *data); | ||
187 | bool wl1271_set_block_size(struct wl1271 *wl); | ||
188 | int wl1271_tx_dummy_packet(struct wl1271 *wl); | ||
189 | void wl1271_configure_filters(struct wl1271 *wl, unsigned int filters); | ||
190 | |||
191 | #endif | ||