Merge branch 'upstream-davem' of master.kernel.org:/pub/scm/linux/kernel/git/linville...
[sfrench/cifs-2.6.git] / drivers / media / video / ivtv / ivtv-firmware.c
1 /*
2     ivtv firmware functions.
3     Copyright (C) 2003-2004  Kevin Thayer <nufan_wfk at yahoo.com>
4     Copyright (C) 2004  Chris Kennedy <c@groovy.org>
5     Copyright (C) 2005-2007  Hans Verkuil <hverkuil@xs4all.nl>
6
7     This program is free software; you can redistribute it and/or modify
8     it under the terms of the GNU General Public License as published by
9     the Free Software Foundation; either version 2 of the License, or
10     (at your option) any later version.
11
12     This program is distributed in the hope that it will be useful,
13     but WITHOUT ANY WARRANTY; without even the implied warranty of
14     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15     GNU General Public License for more details.
16
17     You should have received a copy of the GNU General Public License
18     along with this program; if not, write to the Free Software
19     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
20  */
21
22 #include "ivtv-driver.h"
23 #include "ivtv-mailbox.h"
24 #include "ivtv-firmware.h"
25 #include <linux/firmware.h>
26
27 #define IVTV_MASK_SPU_ENABLE            0xFFFFFFFE
28 #define IVTV_MASK_VPU_ENABLE15          0xFFFFFFF6
29 #define IVTV_MASK_VPU_ENABLE16          0xFFFFFFFB
30 #define IVTV_CMD_VDM_STOP               0x00000000
31 #define IVTV_CMD_AO_STOP                0x00000005
32 #define IVTV_CMD_APU_PING               0x00000000
33 #define IVTV_CMD_VPU_STOP15             0xFFFFFFFE
34 #define IVTV_CMD_VPU_STOP16             0xFFFFFFEE
35 #define IVTV_CMD_HW_BLOCKS_RST          0xFFFFFFFF
36 #define IVTV_CMD_SPU_STOP               0x00000001
37 #define IVTV_CMD_SDRAM_PRECHARGE_INIT   0x0000001A
38 #define IVTV_CMD_SDRAM_REFRESH_INIT     0x80000640
39 #define IVTV_SDRAM_SLEEPTIME            (60 * HZ / 100) /* 600 ms */
40
41 #define IVTV_DECODE_INIT_MPEG_FILENAME  "v4l-cx2341x-init.mpg"
42 #define IVTV_DECODE_INIT_MPEG_SIZE      (152*1024)
43
44 /* Encoder/decoder firmware sizes */
45 #define IVTV_FW_ENC_SIZE                (376836)
46 #define IVTV_FW_DEC_SIZE                (256*1024)
47
48 static int load_fw_direct(const char *fn, volatile u8 __iomem *mem, struct ivtv *itv, long size)
49 {
50         const struct firmware *fw = NULL;
51         int retries = 3;
52
53 retry:
54         if (retries && request_firmware(&fw, fn, &itv->dev->dev) == 0) {
55                 int i;
56                 volatile u32 __iomem *dst = (volatile u32 __iomem *)mem;
57                 const u32 *src = (const u32 *)fw->data;
58
59                 if (fw->size != size) {
60                         /* Due to race conditions in firmware loading (esp. with udev <0.95)
61                            the wrong file was sometimes loaded. So we check filesizes to
62                            see if at least the right-sized file was loaded. If not, then we
63                            retry. */
64                         IVTV_INFO("retry: file loaded was not %s (expected size %ld, got %zd)\n", fn, size, fw->size);
65                         release_firmware(fw);
66                         retries--;
67                         goto retry;
68                 }
69                 for (i = 0; i < fw->size; i += 4) {
70                         /* no need for endianness conversion on the ppc */
71                         __raw_writel(*src, dst);
72                         dst++;
73                         src++;
74                 }
75                 release_firmware(fw);
76                 IVTV_INFO("loaded %s firmware (%zd bytes)\n", fn, fw->size);
77                 return size;
78         }
79         IVTV_ERR("unable to open firmware %s (must be %ld bytes)\n", fn, size);
80         IVTV_ERR("did you put the firmware in the hotplug firmware directory?\n");
81         return -ENOMEM;
82 }
83
84 void ivtv_halt_firmware(struct ivtv *itv)
85 {
86         IVTV_DEBUG_INFO("Preparing for firmware halt.\n");
87         if (itv->has_cx23415 && itv->dec_mbox.mbox)
88                 ivtv_vapi(itv, CX2341X_DEC_HALT_FW, 0);
89         if (itv->enc_mbox.mbox)
90                 ivtv_vapi(itv, CX2341X_ENC_HALT_FW, 0);
91
92         ivtv_sleep_timeout(HZ / 100, 0);
93         itv->enc_mbox.mbox = itv->dec_mbox.mbox = NULL;
94
95         IVTV_DEBUG_INFO("Stopping VDM\n");
96         write_reg(IVTV_CMD_VDM_STOP, IVTV_REG_VDM);
97
98         IVTV_DEBUG_INFO("Stopping AO\n");
99         write_reg(IVTV_CMD_AO_STOP, IVTV_REG_AO);
100
101         IVTV_DEBUG_INFO("pinging (?) APU\n");
102         write_reg(IVTV_CMD_APU_PING, IVTV_REG_APU);
103
104         IVTV_DEBUG_INFO("Stopping VPU\n");
105         if (!itv->has_cx23415)
106                 write_reg(IVTV_CMD_VPU_STOP16, IVTV_REG_VPU);
107         else
108                 write_reg(IVTV_CMD_VPU_STOP15, IVTV_REG_VPU);
109
110         IVTV_DEBUG_INFO("Resetting Hw Blocks\n");
111         write_reg(IVTV_CMD_HW_BLOCKS_RST, IVTV_REG_HW_BLOCKS);
112
113         IVTV_DEBUG_INFO("Stopping SPU\n");
114         write_reg(IVTV_CMD_SPU_STOP, IVTV_REG_SPU);
115
116         ivtv_sleep_timeout(HZ / 100, 0);
117
118         IVTV_DEBUG_INFO("init Encoder SDRAM pre-charge\n");
119         write_reg(IVTV_CMD_SDRAM_PRECHARGE_INIT, IVTV_REG_ENC_SDRAM_PRECHARGE);
120
121         IVTV_DEBUG_INFO("init Encoder SDRAM refresh to 1us\n");
122         write_reg(IVTV_CMD_SDRAM_REFRESH_INIT, IVTV_REG_ENC_SDRAM_REFRESH);
123
124         if (itv->has_cx23415) {
125                 IVTV_DEBUG_INFO("init Decoder SDRAM pre-charge\n");
126                 write_reg(IVTV_CMD_SDRAM_PRECHARGE_INIT, IVTV_REG_DEC_SDRAM_PRECHARGE);
127
128                 IVTV_DEBUG_INFO("init Decoder SDRAM refresh to 1us\n");
129                 write_reg(IVTV_CMD_SDRAM_REFRESH_INIT, IVTV_REG_DEC_SDRAM_REFRESH);
130         }
131
132         IVTV_DEBUG_INFO("Sleeping for %dms (600 recommended)\n",
133                    (int)(IVTV_SDRAM_SLEEPTIME * 1000 / HZ));
134         ivtv_sleep_timeout(IVTV_SDRAM_SLEEPTIME, 0);
135 }
136
137 void ivtv_firmware_versions(struct ivtv *itv)
138 {
139         u32 data[CX2341X_MBOX_MAX_DATA];
140
141         /* Encoder */
142         ivtv_vapi_result(itv, data, CX2341X_ENC_GET_VERSION, 0);
143         IVTV_INFO("Encoder revision: 0x%08x\n", data[0]);
144
145         if (data[0] != 0x02060039)
146                 IVTV_WARN("Recommended firmware version is 0x02060039.\n");
147
148         if (itv->has_cx23415) {
149                 /* Decoder */
150                 ivtv_vapi_result(itv, data, CX2341X_DEC_GET_VERSION, 0);
151                 IVTV_INFO("Decoder revision: 0x%08x\n", data[0]);
152         }
153 }
154
155 static int ivtv_firmware_copy(struct ivtv *itv)
156 {
157         IVTV_DEBUG_INFO("Loading encoder image\n");
158         if (load_fw_direct(CX2341X_FIRM_ENC_FILENAME,
159                    itv->enc_mem, itv, IVTV_FW_ENC_SIZE) != IVTV_FW_ENC_SIZE) {
160                 IVTV_DEBUG_WARN("failed loading encoder firmware\n");
161                 return -3;
162         }
163         if (!itv->has_cx23415)
164                 return 0;
165
166         IVTV_DEBUG_INFO("Loading decoder image\n");
167         if (load_fw_direct(CX2341X_FIRM_DEC_FILENAME,
168                    itv->dec_mem, itv, IVTV_FW_DEC_SIZE) != IVTV_FW_DEC_SIZE) {
169                 IVTV_DEBUG_WARN("failed loading decoder firmware\n");
170                 return -1;
171         }
172         return 0;
173 }
174
175 static volatile struct ivtv_mailbox __iomem *ivtv_search_mailbox(const volatile u8 __iomem *mem, u32 size)
176 {
177         int i;
178
179         /* mailbox is preceeded by a 16 byte 'magic cookie' starting at a 256-byte
180            address boundary */
181         for (i = 0; i < size; i += 0x100) {
182                 if (readl(mem + i)      == 0x12345678 &&
183                     readl(mem + i + 4)  == 0x34567812 &&
184                     readl(mem + i + 8)  == 0x56781234 &&
185                     readl(mem + i + 12) == 0x78123456) {
186                         return (volatile struct ivtv_mailbox __iomem *)(mem + i + 16);
187                 }
188         }
189         return NULL;
190 }
191
192 int ivtv_firmware_init(struct ivtv *itv)
193 {
194         int err;
195
196         ivtv_halt_firmware(itv);
197
198         /* load firmware */
199         err = ivtv_firmware_copy(itv);
200         if (err) {
201                 IVTV_DEBUG_WARN("Error %d loading firmware\n", err);
202                 return err;
203         }
204
205         /* start firmware */
206         write_reg(read_reg(IVTV_REG_SPU) & IVTV_MASK_SPU_ENABLE, IVTV_REG_SPU);
207         ivtv_sleep_timeout(HZ / 10, 0);
208         if (itv->has_cx23415)
209                 write_reg(read_reg(IVTV_REG_VPU) & IVTV_MASK_VPU_ENABLE15, IVTV_REG_VPU);
210         else
211                 write_reg(read_reg(IVTV_REG_VPU) & IVTV_MASK_VPU_ENABLE16, IVTV_REG_VPU);
212         ivtv_sleep_timeout(HZ / 10, 0);
213
214         /* find mailboxes and ping firmware */
215         itv->enc_mbox.mbox = ivtv_search_mailbox(itv->enc_mem, IVTV_ENCODER_SIZE);
216         if (itv->enc_mbox.mbox == NULL)
217                 IVTV_ERR("Encoder mailbox not found\n");
218         else if (ivtv_vapi(itv, CX2341X_ENC_PING_FW, 0)) {
219                 IVTV_ERR("Encoder firmware dead!\n");
220                 itv->enc_mbox.mbox = NULL;
221         }
222         if (itv->enc_mbox.mbox == NULL)
223                 return -ENODEV;
224
225         if (!itv->has_cx23415)
226                 return 0;
227
228         itv->dec_mbox.mbox = ivtv_search_mailbox(itv->dec_mem, IVTV_DECODER_SIZE);
229         if (itv->dec_mbox.mbox == NULL)
230                 IVTV_ERR("Decoder mailbox not found\n");
231         else if (itv->has_cx23415 && ivtv_vapi(itv, CX2341X_DEC_PING_FW, 0)) {
232                 IVTV_ERR("Decoder firmware dead!\n");
233                 itv->dec_mbox.mbox = NULL;
234         }
235         return itv->dec_mbox.mbox ? 0 : -ENODEV;
236 }
237
238 void ivtv_init_mpeg_decoder(struct ivtv *itv)
239 {
240         u32 data[CX2341X_MBOX_MAX_DATA];
241         long readbytes;
242         volatile u8 __iomem *mem_offset;
243
244         data[0] = 0;
245         data[1] = itv->params.width;    /* YUV source width */
246         data[2] = itv->params.height;
247         data[3] = itv->params.audio_properties; /* Audio settings to use,
248                                                            bitmap. see docs. */
249         if (ivtv_api(itv, CX2341X_DEC_SET_DECODER_SOURCE, 4, data)) {
250                 IVTV_ERR("ivtv_init_mpeg_decoder failed to set decoder source\n");
251                 return;
252         }
253
254         if (ivtv_vapi(itv, CX2341X_DEC_START_PLAYBACK, 2, 0, 1) != 0) {
255                 IVTV_ERR("ivtv_init_mpeg_decoder failed to start playback\n");
256                 return;
257         }
258         ivtv_api_get_data(&itv->dec_mbox, IVTV_MBOX_DMA, data);
259         mem_offset = itv->dec_mem + data[1];
260
261         if ((readbytes = load_fw_direct(IVTV_DECODE_INIT_MPEG_FILENAME,
262                 mem_offset, itv, IVTV_DECODE_INIT_MPEG_SIZE)) <= 0) {
263                 IVTV_DEBUG_WARN("failed to read mpeg decoder initialisation file %s\n",
264                                 IVTV_DECODE_INIT_MPEG_FILENAME);
265         } else {
266                 ivtv_vapi(itv, CX2341X_DEC_SCHED_DMA_FROM_HOST, 3, 0, readbytes, 0);
267                 ivtv_sleep_timeout(HZ / 10, 0);
268         }
269         ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 4, 0, 0, 0, 1);
270 }