2 * Copyright (c) 2012 GCT Semiconductor, Inc. All rights reserved.
4 * This software is licensed under the terms of the GNU General Public
5 * License version 2, as published by the Free Software Foundation, and
6 * may be copied, distributed, and modified under those terms.
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
14 #include <linux/uaccess.h>
15 #include <linux/module.h>
16 #include <linux/kernel.h>
18 #include <linux/usb.h>
19 #include <linux/unistd.h>
20 #include <linux/slab.h>
21 #include <linux/firmware.h>
23 #include <asm/byteorder.h>
27 #define DN_KERNEL_MAGIC_NUMBER 0x10760001
28 #define DN_ROOTFS_MAGIC_NUMBER 0x10760002
30 #define DOWNLOAD_SIZE 1024
32 #define MAX_IMG_CNT 16
33 #define FW_DIR "gdm72xx/"
34 #define FW_UIMG "gdmuimg.bin"
35 #define FW_KERN "zImage"
36 #define FW_FS "ramdisk.jffs2"
47 u32 offset[MAX_IMG_CNT];
67 static void array_le32_to_cpu(u32 *arr, int num)
70 for (i = 0; i < num; i++, arr++)
71 *arr = __le32_to_cpu(*arr);
76 static int gdm_wibro_send(struct usb_device *usbdev, void *data, int len)
81 ret = usb_bulk_msg(usbdev, usb_sndbulkpipe(usbdev, 1), data, len,
85 dev_err(&usbdev->dev, "Error : usb_bulk_msg ( result = %d )\n",
92 static int gdm_wibro_recv(struct usb_device *usbdev, void *data, int len)
97 ret = usb_bulk_msg(usbdev, usb_rcvbulkpipe(usbdev, 2), data, len,
101 dev_err(&usbdev->dev,
102 "Error : usb_bulk_msg(recv) ( result = %d )\n", ret);
108 static int download_image(struct usb_device *usbdev,
109 const struct firmware *firm,
110 loff_t pos, u32 img_len, u32 magic_num)
116 size = ALIGN(img_len, DOWNLOAD_SIZE);
117 h.magic_num = __cpu_to_be32(magic_num);
118 h.file_size = __cpu_to_be32(size);
120 ret = gdm_wibro_send(usbdev, &h, sizeof(h));
124 while (img_len > 0) {
125 if (img_len > DOWNLOAD_SIZE)
126 size = DOWNLOAD_SIZE;
128 size = img_len; /* the last chunk of data */
130 memcpy(tx_buf, firm->data + pos, size);
131 ret = gdm_wibro_send(usbdev, tx_buf, size);
143 int usb_boot(struct usb_device *usbdev, u16 pid)
146 struct img_header hdr;
147 struct fw_info fw_info;
149 char *img_name = FW_DIR FW_UIMG;
150 const struct firmware *firm;
152 ret = request_firmware(&firm, img_name, &usbdev->dev);
154 dev_err(&usbdev->dev,
155 "requesting firmware %s failed with error %d\n",
160 tx_buf = kmalloc(DOWNLOAD_SIZE, GFP_KERNEL);
161 if (tx_buf == NULL) {
162 dev_err(&usbdev->dev, "Error: kmalloc\n");
166 if (firm->size < sizeof(hdr)) {
167 dev_err(&usbdev->dev, "Cannot read the image info.\n");
171 memcpy(&hdr, firm->data, sizeof(hdr));
173 array_le32_to_cpu((u32 *)&hdr, 19);
175 if (hdr.magic_code != 0x10767fff) {
176 dev_err(&usbdev->dev, "Invalid magic code 0x%08x\n",
182 if (hdr.count > MAX_IMG_CNT) {
183 dev_err(&usbdev->dev, "Too many images. %d\n", hdr.count);
188 for (i = 0; i < hdr.count; i++) {
189 if (hdr.offset[i] > hdr.len) {
190 dev_err(&usbdev->dev,
191 "Invalid offset. Entry = %d Offset = 0x%08x Image length = 0x%08x\n",
192 i, hdr.offset[i], hdr.len);
198 if (firm->size < sizeof(fw_info) + pos) {
199 dev_err(&usbdev->dev, "Cannot read the FW info.\n");
203 memcpy(&fw_info, firm->data + pos, sizeof(fw_info));
205 array_le32_to_cpu((u32 *)&fw_info, 8);
207 if ((fw_info.id & 0xfffff000) != 0x10767000) {
208 dev_err(&usbdev->dev, "Invalid FW id. 0x%08x\n",
215 if ((fw_info.id & 0xffff) != pid)
218 pos = hdr.offset[i] + fw_info.kernel_offset;
219 if (firm->size < fw_info.kernel_len + pos) {
220 dev_err(&usbdev->dev, "Kernel FW is too small.\n");
224 ret = download_image(usbdev, firm, pos,
225 fw_info.kernel_len, DN_KERNEL_MAGIC_NUMBER);
228 dev_info(&usbdev->dev, "GCT: Kernel download success.\n");
230 pos = hdr.offset[i] + fw_info.rootfs_offset;
231 if (firm->size < fw_info.rootfs_len + pos) {
232 dev_err(&usbdev->dev, "Filesystem FW is too small.\n");
235 ret = download_image(usbdev, firm, pos, fw_info.rootfs_len,
236 DN_ROOTFS_MAGIC_NUMBER);
239 dev_info(&usbdev->dev, "GCT: Filesystem download success.\n");
244 if (i == hdr.count) {
245 dev_err(&usbdev->dev, "Firmware for gsk%x is not installed.\n",
250 release_firmware(firm);
255 /*#define GDM7205_PADDING 256 */
256 #define DOWNLOAD_CHUCK 2048
257 #define KERNEL_TYPE_STRING "linux"
258 #define FS_TYPE_STRING "rootfs"
260 static int em_wait_ack(struct usb_device *usbdev, int send_zlp)
267 ret = gdm_wibro_send(usbdev, NULL, 0);
273 ret = gdm_wibro_recv(usbdev, &ack, sizeof(ack));
280 static int em_download_image(struct usb_device *usbdev, const char *img_name,
288 const struct firmware *firm;
289 #if defined(GDM7205_PADDING)
290 const int pad_size = GDM7205_PADDING;
292 const int pad_size = 0;
295 ret = request_firmware(&firm, img_name, &usbdev->dev);
297 dev_err(&usbdev->dev,
298 "requesting firmware %s failed with error %d\n",
303 buf = kmalloc(DOWNLOAD_CHUCK + pad_size, GFP_KERNEL);
305 dev_err(&usbdev->dev, "Error: kmalloc\n");
309 strcpy(buf+pad_size, type_string);
310 ret = gdm_wibro_send(usbdev, buf, strlen(type_string)+pad_size);
314 img_len = firm->size;
321 while (img_len > 0) {
322 if (img_len > DOWNLOAD_CHUCK)
323 len = DOWNLOAD_CHUCK;
325 len = img_len; /* the last chunk of data */
327 memcpy(buf+pad_size, firm->data + pos, len);
328 ret = gdm_wibro_send(usbdev, buf, len+pad_size);
333 img_len -= DOWNLOAD_CHUCK;
334 pos += DOWNLOAD_CHUCK;
336 ret = em_wait_ack(usbdev, ((len+pad_size) % 512 == 0));
341 ret = em_wait_ack(usbdev, 1);
346 release_firmware(firm);
352 static int em_fw_reset(struct usb_device *usbdev)
357 ret = gdm_wibro_send(usbdev, NULL, 0);
361 int usb_emergency(struct usb_device *usbdev)
364 const char *kern_name = FW_DIR FW_KERN;
365 const char *fs_name = FW_DIR FW_FS;
367 ret = em_download_image(usbdev, kern_name, KERNEL_TYPE_STRING);
370 dev_err(&usbdev->dev, "GCT Emergency: Kernel download success.\n");
372 ret = em_download_image(usbdev, fs_name, FS_TYPE_STRING);
375 dev_info(&usbdev->dev, "GCT Emergency: Filesystem download success.\n");
377 ret = em_fw_reset(usbdev);