← Back to branch summary

~ubuntu-branches/ubuntu/trusty/linux-armadaxp/trusty

« back to all changes in this revision

Viewing changes to drivers/staging/westbridge/astoria/include/linux/westbridge/cyanstorage.h

  • Committer: Package Import Robot
  • Author(s): Michael Casadevall, Bryan Wu, Dann Frazier, Michael Casadeall
  • Date: 2012-03-10 15:00:54 UTC
  • mfrom: (1.1.1)
  • Revision ID: package-import@ubuntu.com-20120310150054-flugb39zon8vvgwe
Tags: 3.2.0-1600.1
[ Bryan Wu ]
* UBUNTU: import debian/debian.env and debian.armadaxp

[ Dann Frazier ]
* ARM: Armada XP: remove trailing '/' in dirnames in mvRules.mk

[ Michael Casadeall ]
* tools: add some tools for Marvell Armada XP processor
* kernel: timer tick hacking from Marvell
* kernel: Sheeva Errata: add delay on Sheeva when powering down
* net: add Marvell NFP netfilter
* net: socket and skb modifications made by Marvell
* miscdevice: add minor IDs for some Marvell Armada drivers
* fs: introduce memory pool for splice()
* video: EDID detection updates from Marvell Armada XP patchset
* video: backlight: add Marvell Dove LCD backlight driver
* video: display: add THS8200 display driver
* video: framebuffer: add Marvell Dove and Armada XP processor onchip LCD controller driver
* usbtest: add Interrupt transfer testing by Marvell Armada XP code
* usb: ehci: add support for Marvell EHCI controler
* tty/serial: 8250: add support for Marvell Armada XP processor and DeviceTree work
* rtc: add support for Marvell Armada XP onchip RTC controller
* net: pppoe: add Marvell ethernet NFP hook in PPPoE networking driver
* mtd: nand: add support for Marvell Armada XP Nand Flash Controller
* mtd: maps: add Marvell Armada XP specific map driver
* mmc: add support for Marvell Armada XP MMC/SD host controller
* i2c: add support for Marvell Armada XP onchip i2c bus controller
* hwmon: add Kconfig option for Armada XP onchip thermal sensor driver
* dmaengine: add Net DMA support for splice and update Marvell XOR DMA engine driver
* ata: add support for Marvell Armada XP SATA controller and update some quirks
* ARM: add Marvell Armada XP machine to mach-types
* ARM: oprofile: add support for Marvell PJ4B core
* ARM: mm: more ARMv6 switches for Marvell Armada XP
* ARM: remove static declaration to allow compilation
* ARM: alignment access fault trick
* ARM: mm: skip some fault fixing when run on NONE SMP ARMv6 mode during early abort event
* ARM: mm: add Marvell Sheeva CPU Architecture for PJ4B
* ARM: introduce optimized copy operation for Marvell Armada XP
* ARM: SAUCE: hardware breakpoint trick for Marvell Armada XP
* ARM: big endian and little endian tricks for Marvell Armada XP
* ARM: SAUCE: Add Marvell Armada XP build rules to arch/arm/kernel/Makefile
* ARM: vfp: add special handling for Marvell Armada XP
* ARM: add support for Marvell U-Boot
* ARM: add mv_controller_num for ARM PCI drivers
* ARM: add support for local PMUs, general SMP tweaks and cache flushing
* ARM: add Marvell device identifies in glue-proc.h
* ARM: add IPC driver support for Marvell platforms
* ARM: add DMA mapping for Marvell platforms
* ARM: add Sheeva errata and PJ4B code for booting
* ARM: update Kconfig and Makefile to include Marvell Armada XP platforms
* ARM: Armada XP: import LSP from Marvell for Armada XP 3.2 kernel enablement

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/staging/westbridge/astoria/include/linux/westbridge/cyanstorage.h
1
 
/*  Cypress West Bridge API header file (cyanstorage.h)
2
 
 ## Header for backward compatibility with previous releases of Antioch SDK.
3
 
## ===========================
4
 
## Copyright (C) 2010  Cypress Semiconductor
5
 
##
6
 
## This program is free software; you can redistribute it and/or
7
 
## modify it under the terms of the GNU General Public License
8
 
## as published by the Free Software Foundation; either version 2
9
 
## of the License, or (at your option) any later version.
10
 
##
11
 
## This program is distributed in the hope that it will be useful,
12
 
## but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
 
## GNU General Public License for more details.
15
 
##
16
 
## You should have received a copy of the GNU General Public License
17
 
## along with this program; if not, write to the Free Software
18
 
## Foundation, Inc., 51 Franklin Street
19
 
## Fifth Floor, Boston, MA  02110-1301, USA.
20
 
## ===========================
21
 
*/
22
 
 
23
 
#ifndef _INCLUDED_CYANSTORAGE_H_
24
 
#define _INCLUDED_CYANSTORAGE_H_
25
 
#ifndef __doxygen__
26
 
 
27
 
#include "cyanmedia.h"
28
 
#include "cyanmisc.h"
29
 
#include "cyasstorage.h"
30
 
#include "cyas_cplus_start.h"
31
 
 
32
 
#define CY_AN_LUN_PHYSICAL_DEVICE (CY_AS_LUN_PHYSICAL_DEVICE)
33
 
#define CY_AN_STORAGE_EP_SIZE (CY_AS_STORAGE_EP_SIZE)
34
 
 
35
 
#define cy_an_storage_antioch   cy_as_storage_antioch
36
 
#define cy_an_storage_processor cy_as_storage_processor
37
 
#define cy_an_storage_removed   cy_as_storage_removed
38
 
#define cy_an_storage_inserted  cy_as_storage_inserted
39
 
#define cy_an_sdio_interrupt    cy_as_sdio_interrupt
40
 
typedef cy_as_storage_event     cy_an_storage_event;
41
 
 
42
 
#define cy_an_op_read    cy_as_op_read
43
 
#define cy_an_op_write   cy_as_op_write
44
 
typedef cy_as_oper_type cy_an_oper_type;
45
 
 
46
 
typedef cy_as_device_desc cy_an_device_desc;
47
 
 
48
 
typedef cy_as_unit_desc cy_an_unit_desc;
49
 
 
50
 
typedef cy_as_storage_callback_dep \
51
 
        cy_an_storage_callback;
52
 
 
53
 
typedef cy_as_storage_event_callback_dep \
54
 
        cy_an_storage_event_callback;
55
 
 
56
 
#define cy_an_sd_reg_OCR cy_as_sd_reg_OCR
57
 
#define cy_an_sd_reg_CID cy_as_sd_reg_CID
58
 
#define cy_an_sd_reg_CSD cy_as_sd_reg_CSD
59
 
typedef cy_as_sd_card_reg_type \
60
 
        cy_an_sd_card_reg_type;
61
 
 
62
 
typedef cy_as_storage_query_device_data_dep \
63
 
        cy_an_storage_query_device_data;
64
 
 
65
 
typedef cy_as_storage_query_unit_data_dep \
66
 
        cy_an_storage_query_unit_data;
67
 
 
68
 
typedef cy_as_storage_sd_reg_read_data \
69
 
        cy_an_storage_sd_reg_read_data;
70
 
 
71
 
#define CY_AN_SD_REG_OCR_LENGTH (CY_AS_SD_REG_OCR_LENGTH)
72
 
#define CY_AN_SD_REG_CID_LENGTH (CY_AS_SD_REG_CID_LENGTH)
73
 
#define CY_AN_SD_REG_CSD_LENGTH (CY_AS_SD_REG_CSD_LENGTH)
74
 
#define CY_AN_SD_REG_MAX_RESP_LENGTH \
75
 
        (CY_AS_SD_REG_MAX_RESP_LENGTH)
76
 
 
77
 
/**** API Functions ******/
78
 
 
79
 
/* Sync version of Storage Start */
80
 
EXTERN cy_an_return_status_t
81
 
cy_an_storage_start(
82
 
        cy_an_device_handle             handle
83
 
        );
84
 
#define cy_an_storage_start(handle) \
85
 
        cy_as_storage_start((cy_as_device_handle)(handle), 0, 0)
86
 
 
87
 
/* Async version of Storage Start */
88
 
EXTERN cy_an_return_status_t
89
 
cy_an_storage_start_e_x(
90
 
        cy_an_device_handle     handle,
91
 
        cy_an_function_callback cb,
92
 
        uint32_t                client
93
 
        );
94
 
#define cy_an_storage_start_e_x(h, cb, client) \
95
 
        cy_as_storage_start((cy_as_device_handle)(h), \
96
 
                (cy_as_function_callback)(cb), (client))
97
 
 
98
 
/* Sync version of Storage Stop */
99
 
EXTERN cy_an_return_status_t
100
 
cy_an_storage_stop(
101
 
        cy_an_device_handle             handle
102
 
        );
103
 
#define cy_an_storage_stop(handle) \
104
 
        cy_as_storage_stop((cy_as_device_handle)(handle), 0, 0)
105
 
 
106
 
/* Async version of Storage Stop */
107
 
EXTERN cy_an_return_status_t
108
 
cy_an_storage_stop_e_x(
109
 
        cy_an_device_handle     handle,
110
 
        cy_an_function_callback cb,
111
 
        uint32_t                client
112
 
        );
113
 
#define cy_an_storage_stop_e_x(h, cb, client)           \
114
 
        cy_as_storage_stop((cy_as_device_handle)(h), \
115
 
                (cy_as_function_callback)(cb), (client))
116
 
 
117
 
/* Register Call back api */
118
 
EXTERN cy_an_return_status_t
119
 
cy_an_storage_register_callback(
120
 
        cy_an_device_handle                     handle,
121
 
        cy_an_storage_event_callback    callback
122
 
        );
123
 
#define cy_an_storage_register_callback(h, cb)          \
124
 
        cy_as_storage_register_callback_dep((cy_as_device_handle)(h), \
125
 
        (cy_as_storage_event_callback_dep)(cb))
126
 
 
127
 
/* Sync version of Storage Claim */
128
 
EXTERN cy_an_return_status_t
129
 
cy_an_storage_claim(
130
 
        cy_an_device_handle             handle,
131
 
        cy_an_media_type                        type
132
 
        );
133
 
#define cy_an_storage_claim(h, type)                    \
134
 
        cy_as_storage_claim_dep((cy_as_device_handle)(h), \
135
 
        (cy_as_media_type)(type))
136
 
 
137
 
/* Async version of Storage Claim */
138
 
EXTERN cy_an_return_status_t
139
 
cy_an_storage_claim_e_x(
140
 
        cy_an_device_handle             handle,
141
 
        cy_an_media_type *type,
142
 
        cy_an_function_callback         cb,
143
 
        uint32_t                        client
144
 
        );
145
 
#define cy_an_storage_claim_e_x(h, type_p, cb, client)          \
146
 
        cy_as_storage_claim_dep_EX((cy_as_device_handle)(h), \
147
 
        (cy_as_media_type *)(type_p), \
148
 
        (cy_as_function_callback)(cb), (client))
149
 
 
150
 
/* Sync Version of Storage Release */
151
 
EXTERN cy_an_return_status_t
152
 
cy_an_storage_release(
153
 
        cy_an_device_handle             handle,
154
 
        cy_an_media_type                        type
155
 
        );
156
 
#define cy_an_storage_release(h, type)                  \
157
 
        cy_as_storage_release_dep((cy_as_device_handle)(h), \
158
 
        (cy_as_media_type)(type))
159
 
 
160
 
/* Async Version of Storage Release */
161
 
EXTERN cy_an_return_status_t
162
 
cy_an_storage_release_e_x(
163
 
        cy_an_device_handle             handle,
164
 
        cy_an_media_type *type,
165
 
        cy_an_function_callback         cb,
166
 
        uint32_t                        client
167
 
        );
168
 
#define cy_an_storage_release_e_x(h, type_p, cb, client)        \
169
 
        cy_as_storage_release_dep_EX((cy_as_device_handle)(h), \
170
 
        (cy_as_media_type *)(type_p), \
171
 
        (cy_as_function_callback)(cb), (client))
172
 
 
173
 
/* Sync version of Query Media */
174
 
EXTERN cy_an_return_status_t
175
 
cy_an_storage_query_media(
176
 
        cy_an_device_handle             handle,
177
 
        cy_an_media_type                        type,
178
 
        uint32_t *count
179
 
        );
180
 
#define cy_an_storage_query_media(handle, type, count) \
181
 
        cy_as_storage_query_media((cy_as_device_handle)(handle), \
182
 
        (cy_as_media_type)(type), (count), 0, 0)
183
 
 
184
 
/* Async version of Query Media */
185
 
EXTERN cy_an_return_status_t
186
 
cy_an_storage_query_media_e_x(
187
 
        cy_an_device_handle             handle,
188
 
        cy_an_media_type                        type,
189
 
        uint32_t *count,
190
 
        cy_an_function_callback         cb,
191
 
        uint32_t                        client
192
 
        );
193
 
#define cy_an_storage_query_media_e_x(h, type, count, cb, client) \
194
 
        cy_as_storage_query_media((cy_as_device_handle)(h), \
195
 
        (cy_as_media_type)(type), (count), \
196
 
        (cy_as_function_callback)(cb), (client))
197
 
 
198
 
/* Sync version of Query device */
199
 
EXTERN cy_an_return_status_t
200
 
cy_an_storage_query_device(
201
 
        cy_an_device_handle             handle,
202
 
        cy_an_media_type                        type,
203
 
        uint32_t                        device,
204
 
        cy_an_device_desc *desc_p
205
 
        );
206
 
#define cy_an_storage_query_device(h, type, device, desc_p) \
207
 
        cy_as_storage_query_device_dep((cy_as_device_handle)(h), \
208
 
        (cy_as_media_type)(type), (device), (cy_as_device_desc *)(desc_p))
209
 
 
210
 
/* Async version of Query device */
211
 
EXTERN cy_an_return_status_t
212
 
cy_an_storage_query_device_e_x(
213
 
        cy_an_device_handle             handle,
214
 
        cy_an_storage_query_device_data *data,
215
 
        cy_an_function_callback         cb,
216
 
        uint32_t                        client
217
 
        );
218
 
#define cy_an_storage_query_device_e_x(h, data, cb, client) \
219
 
        cy_as_storage_query_device_dep_EX((cy_as_device_handle)(h), \
220
 
        (cy_as_storage_query_device_data_dep *)(data),  \
221
 
                (cy_as_function_callback)(cb), (client))
222
 
 
223
 
/* Sync version of Query Unit */
224
 
EXTERN cy_an_return_status_t
225
 
cy_an_storage_query_unit(
226
 
        cy_an_device_handle             handle,
227
 
        cy_an_media_type                        type,
228
 
        uint32_t                        device,
229
 
        uint32_t                        unit,
230
 
        cy_an_unit_desc *desc_p
231
 
        );
232
 
#define cy_an_storage_query_unit(h, type, device, unit, desc_p) \
233
 
        cy_as_storage_query_unit_dep((cy_as_device_handle)(h), \
234
 
        (cy_as_media_type)(type), (device), \
235
 
        (unit), (cy_as_unit_desc *)(desc_p))
236
 
 
237
 
/* Async version of Query Unit */
238
 
EXTERN cy_an_return_status_t
239
 
cy_an_storage_query_unit_e_x(
240
 
        cy_an_device_handle             handle,
241
 
        cy_an_storage_query_unit_data *data_p,
242
 
        cy_an_function_callback         cb,
243
 
        uint32_t                        client
244
 
        );
245
 
#define cy_an_storage_query_unit_e_x(h, data_p, cb, client)     \
246
 
        cy_as_storage_query_unit_dep_EX((cy_as_device_handle)(h), \
247
 
        (cy_as_storage_query_unit_data_dep *)(data_p),  \
248
 
        (cy_as_function_callback)(cb), (client))
249
 
 
250
 
/* Sync version of device control */
251
 
EXTERN cy_an_return_status_t
252
 
cy_an_storage_device_control(
253
 
                cy_an_device_handle     handle,
254
 
                cy_bool  card_detect_en,
255
 
                cy_bool  write_prot_en
256
 
                );
257
 
#define cy_an_storage_device_control(handle, \
258
 
        card_detect_en, write_prot_en) \
259
 
        cy_as_storage_device_control_dep((cy_as_device_handle)(handle), \
260
 
        (card_detect_en), (write_prot_en), 0, 0)
261
 
 
262
 
/* Async version of device control */
263
 
EXTERN cy_an_return_status_t
264
 
cy_an_storage_device_control_e_x(
265
 
                cy_an_device_handle                             handle,
266
 
                cy_bool                 card_detect_en,
267
 
                cy_bool                 write_prot_en,
268
 
        cy_an_function_callback         cb,
269
 
        uint32_t                        client
270
 
                );
271
 
#define cy_an_storage_device_control_e_x(h, det_en, prot_en, cb, client) \
272
 
        cy_as_storage_device_control_dep((cy_as_device_handle)(h), (det_en), \
273
 
        (prot_en), (cy_as_function_callback)(cb), (client))
274
 
 
275
 
/* Sync Read */
276
 
EXTERN cy_an_return_status_t
277
 
cy_an_storage_read(
278
 
        cy_an_device_handle             handle,
279
 
        cy_an_media_type                        type,
280
 
        uint32_t                        device,
281
 
        uint32_t                        unit,
282
 
        uint32_t                        block,
283
 
        void *data_p,
284
 
        uint16_t                        num_blocks
285
 
        );
286
 
#define cy_an_storage_read(h, type, device, unit, block, data_p, nblks) \
287
 
        cy_as_storage_read_dep((cy_as_device_handle)(h), \
288
 
        (cy_as_media_type)(type), (device), (unit), \
289
 
        (block), (data_p), (nblks))
290
 
 
291
 
/* Async Read */
292
 
EXTERN cy_an_return_status_t
293
 
cy_an_storage_read_async(
294
 
        cy_an_device_handle             handle,
295
 
        cy_an_media_type                        type,
296
 
        uint32_t                        device,
297
 
        uint32_t                        unit,
298
 
        uint32_t                        block,
299
 
        void *data_p,
300
 
        uint16_t                        num_blocks,
301
 
        cy_an_storage_callback          callback
302
 
        );
303
 
#define cy_an_storage_read_async(h, type, device, unit, \
304
 
        block, data_p, nblks, cb)                               \
305
 
        cy_as_storage_read_async_dep((cy_as_device_handle)(h), \
306
 
        (cy_as_media_type)(type), (device), (unit), (block), \
307
 
                (data_p), (nblks), (cy_as_storage_callback_dep)(cb))
308
 
 
309
 
/* Sync Write */
310
 
EXTERN cy_an_return_status_t
311
 
cy_an_storage_write(
312
 
        cy_an_device_handle             handle,
313
 
        cy_an_media_type                        type,
314
 
        uint32_t                        device,
315
 
        uint32_t                        unit,
316
 
        uint32_t                        block,
317
 
        void *data_p,
318
 
        uint16_t                        num_blocks
319
 
        );
320
 
#define cy_an_storage_write(h, type, device, unit, \
321
 
        block, data_p, nblks)   \
322
 
        cy_as_storage_write_dep((cy_as_device_handle)(h), \
323
 
        (cy_as_media_type)(type), (device), (unit), \
324
 
        (block), (data_p), (nblks))
325
 
 
326
 
/* Async Write */
327
 
EXTERN cy_an_return_status_t
328
 
cy_an_storage_write_async(
329
 
        cy_an_device_handle             handle,
330
 
        cy_an_media_type                        type,
331
 
        uint32_t                        device,
332
 
        uint32_t                        unit,
333
 
        uint32_t                        block,
334
 
        void *data_p,
335
 
        uint16_t                        num_blocks,
336
 
        cy_an_storage_callback          callback
337
 
        );
338
 
#define cy_an_storage_write_async(h, type, device, unit, \
339
 
        block, data_p, nblks, cb) \
340
 
        cy_as_storage_write_async_dep((cy_as_device_handle)(h), \
341
 
        (cy_as_media_type)(type), (device), (unit), (block), \
342
 
                (data_p), (nblks), (cy_as_storage_callback_dep)(cb))
343
 
 
344
 
/* Cancel Async */
345
 
EXTERN cy_an_return_status_t
346
 
cy_an_storage_cancel_async(
347
 
        cy_an_device_handle             handle
348
 
        );
349
 
#define cy_an_storage_cancel_async(h) \
350
 
        cy_as_storage_cancel_async((cy_as_device_handle)(h))
351
 
 
352
 
/* Sync SD Register Read*/
353
 
EXTERN cy_an_return_status_t
354
 
cy_an_storage_sd_register_read(
355
 
                cy_an_device_handle               handle,
356
 
        cy_an_media_type                  type,
357
 
        uint8_t                           device,
358
 
        cy_an_sd_card_reg_type           reg_type,
359
 
        uint8_t                            read_len,
360
 
        uint8_t                           *data_p
361
 
                );
362
 
#define cy_an_storage_sd_register_read(h, type, device, \
363
 
        reg_type, len, data_p) \
364
 
        cy_as_storage_sd_register_read_dep((cy_as_device_handle)(h), \
365
 
        (cy_as_media_type)(type), (device),      \
366
 
        (cy_as_sd_card_reg_type)(reg_type), (len), (data_p))
367
 
 
368
 
/*Async SD Register Read*/
369
 
EXTERN cy_an_return_status_t
370
 
cy_an_storage_sd_register_read_e_x(
371
 
                cy_an_device_handle               handle,
372
 
        cy_an_media_type                  type,
373
 
        uint8_t                           device,
374
 
        cy_an_sd_card_reg_type           reg_type,
375
 
        cy_an_storage_sd_reg_read_data *data_p,
376
 
        cy_an_function_callback   cb,
377
 
        uint32_t                                  client
378
 
                );
379
 
#define cy_an_storage_sd_register_read_e_x(h, type, device, \
380
 
        reg_type, data_p, cb, client) \
381
 
        cy_as_storage_sd_register_read_dep_EX((cy_as_device_handle)(h), \
382
 
        (cy_as_media_type)(type), (device),     \
383
 
        (cy_as_sd_card_reg_type)(reg_type), \
384
 
        (cy_as_storage_sd_reg_read_data *)(data_p),     \
385
 
        (cy_as_function_callback)(cb), (client))
386
 
 
387
 
/* Create partition on storage device */
388
 
EXTERN cy_an_return_status_t
389
 
cy_an_storage_create_p_partition(
390
 
                cy_an_device_handle      handle,
391
 
                cy_an_media_type                media,
392
 
                uint32_t                         device,
393
 
                uint32_t                         size,
394
 
                cy_an_function_callback cb,
395
 
                uint32_t                         client);
396
 
#define cy_an_storage_create_p_partition(h, media, dev, \
397
 
        size, cb, client) \
398
 
        cy_as_storage_create_p_partition_dep((cy_as_device_handle)(h), \
399
 
        (cy_as_media_type)(media), (dev), \
400
 
        (size), (cy_as_function_callback)(cb), (client))
401
 
 
402
 
/* Remove partition on storage device */
403
 
EXTERN cy_an_return_status_t
404
 
cy_an_storage_remove_p_partition(
405
 
                cy_an_device_handle             handle,
406
 
                cy_an_media_type                   media,
407
 
                uint32_t                                device,
408
 
                cy_an_function_callback cb,
409
 
                uint32_t                                client);
410
 
#define cy_an_storage_remove_p_partition\
411
 
(h, media, dev, cb, client)      \
412
 
        cy_as_storage_remove_p_partition_dep((cy_as_device_handle)(h), \
413
 
        (cy_as_media_type)(media), (dev),          \
414
 
                        (cy_as_function_callback)(cb), (client))
415
 
 
416
 
#include "cyas_cplus_end.h"
417
 
#endif /*__doxygen__ */
418
 
 
419
 
#endif