?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Adding support for MOXA ART SoC. Testing port of linux-2.6.32.60-moxart.
[linux-3.6.7-moxart.git] / drivers / media / video / gspca / sunplus.c
blob9ccfcb1c6479917ba6bde2d0a7e3401c1d632d56
1 /*
2 * Sunplus spca504(abc) spca533 spca536 library
3 * Copyright (C) 2005 Michel Xhaard mxhaard@magic.fr
4 *
5 * V4L2 by Jean-Francois Moine <http://moinejf.free.fr>
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 * 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 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
23
24 #define MODULE_NAME "sunplus"
25
26 #include "gspca.h"
27 #include "jpeg.h"
28
29 MODULE_AUTHOR("Michel Xhaard <mxhaard@users.sourceforge.net>");
30 MODULE_DESCRIPTION("GSPCA/SPCA5xx USB Camera Driver");
31 MODULE_LICENSE("GPL");
32
33 #define QUALITY 85
34
35 /* specific webcam descriptor */
36 struct sd {
37 struct gspca_dev gspca_dev; /* !! must be the first item */
38
39 bool autogain;
40
41 u8 bridge;
42 #define BRIDGE_SPCA504 0
43 #define BRIDGE_SPCA504B 1
44 #define BRIDGE_SPCA504C 2
45 #define BRIDGE_SPCA533 3
46 #define BRIDGE_SPCA536 4
47 u8 subtype;
48 #define AiptekMiniPenCam13 1
49 #define LogitechClickSmart420 2
50 #define LogitechClickSmart820 3
51 #define MegapixV4 4
52 #define MegaImageVI 5
53
54 u8 jpeg_hdr[JPEG_HDR_SZ];
55 };
56
57 static const struct v4l2_pix_format vga_mode[] = {
58 {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
59 .bytesperline = 320,
60 .sizeimage = 320 * 240 * 3 / 8 + 590,
61 .colorspace = V4L2_COLORSPACE_JPEG,
62 .priv = 2},
63 {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
64 .bytesperline = 640,
65 .sizeimage = 640 * 480 * 3 / 8 + 590,
66 .colorspace = V4L2_COLORSPACE_JPEG,
67 .priv = 1},
68 };
69
70 static const struct v4l2_pix_format custom_mode[] = {
71 {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
72 .bytesperline = 320,
73 .sizeimage = 320 * 240 * 3 / 8 + 590,
74 .colorspace = V4L2_COLORSPACE_JPEG,
75 .priv = 2},
76 {464, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
77 .bytesperline = 464,
78 .sizeimage = 464 * 480 * 3 / 8 + 590,
79 .colorspace = V4L2_COLORSPACE_JPEG,
80 .priv = 1},
81 };
82
83 static const struct v4l2_pix_format vga_mode2[] = {
84 {176, 144, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
85 .bytesperline = 176,
86 .sizeimage = 176 * 144 * 3 / 8 + 590,
87 .colorspace = V4L2_COLORSPACE_JPEG,
88 .priv = 4},
89 {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
90 .bytesperline = 320,
91 .sizeimage = 320 * 240 * 3 / 8 + 590,
92 .colorspace = V4L2_COLORSPACE_JPEG,
93 .priv = 3},
94 {352, 288, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
95 .bytesperline = 352,
96 .sizeimage = 352 * 288 * 3 / 8 + 590,
97 .colorspace = V4L2_COLORSPACE_JPEG,
98 .priv = 2},
99 {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
100 .bytesperline = 640,
101 .sizeimage = 640 * 480 * 3 / 8 + 590,
102 .colorspace = V4L2_COLORSPACE_JPEG,
103 .priv = 1},
104 };
105
106 #define SPCA50X_OFFSET_DATA 10
107 #define SPCA504_PCCAM600_OFFSET_SNAPSHOT 3
108 #define SPCA504_PCCAM600_OFFSET_COMPRESS 4
109 #define SPCA504_PCCAM600_OFFSET_MODE 5
110 #define SPCA504_PCCAM600_OFFSET_DATA 14
111 /* Frame packet header offsets for the spca533 */
112 #define SPCA533_OFFSET_DATA 16
113 #define SPCA533_OFFSET_FRAMSEQ 15
114 /* Frame packet header offsets for the spca536 */
115 #define SPCA536_OFFSET_DATA 4
116 #define SPCA536_OFFSET_FRAMSEQ 1
117
118 struct cmd {
119 u8 req;
120 u16 val;
121 u16 idx;
122 };
123
124 /* Initialisation data for the Creative PC-CAM 600 */
125 static const struct cmd spca504_pccam600_init_data[] = {
126 /* {0xa0, 0x0000, 0x0503}, * capture mode */
127 {0x00, 0x0000, 0x2000},
128 {0x00, 0x0013, 0x2301},
129 {0x00, 0x0003, 0x2000},
130 {0x00, 0x0001, 0x21ac},
131 {0x00, 0x0001, 0x21a6},
132 {0x00, 0x0000, 0x21a7}, /* brightness */
133 {0x00, 0x0020, 0x21a8}, /* contrast */
134 {0x00, 0x0001, 0x21ac}, /* sat/hue */
135 {0x00, 0x0000, 0x21ad}, /* hue */
136 {0x00, 0x001a, 0x21ae}, /* saturation */
137 {0x00, 0x0002, 0x21a3}, /* gamma */
138 {0x30, 0x0154, 0x0008},
139 {0x30, 0x0004, 0x0006},
140 {0x30, 0x0258, 0x0009},
141 {0x30, 0x0004, 0x0000},
142 {0x30, 0x0093, 0x0004},
143 {0x30, 0x0066, 0x0005},
144 {0x00, 0x0000, 0x2000},
145 {0x00, 0x0013, 0x2301},
146 {0x00, 0x0003, 0x2000},
147 {0x00, 0x0013, 0x2301},
148 {0x00, 0x0003, 0x2000},
149 };
150
151 /* Creative PC-CAM 600 specific open data, sent before using the
152 * generic initialisation data from spca504_open_data.
153 */
154 static const struct cmd spca504_pccam600_open_data[] = {
155 {0x00, 0x0001, 0x2501},
156 {0x20, 0x0500, 0x0001}, /* snapshot mode */
157 {0x00, 0x0003, 0x2880},
158 {0x00, 0x0001, 0x2881},
159 };
160
161 /* Initialisation data for the logitech clicksmart 420 */
162 static const struct cmd spca504A_clicksmart420_init_data[] = {
163 /* {0xa0, 0x0000, 0x0503}, * capture mode */
164 {0x00, 0x0000, 0x2000},
165 {0x00, 0x0013, 0x2301},
166 {0x00, 0x0003, 0x2000},
167 {0x00, 0x0001, 0x21ac},
168 {0x00, 0x0001, 0x21a6},
169 {0x00, 0x0000, 0x21a7}, /* brightness */
170 {0x00, 0x0020, 0x21a8}, /* contrast */
171 {0x00, 0x0001, 0x21ac}, /* sat/hue */
172 {0x00, 0x0000, 0x21ad}, /* hue */
173 {0x00, 0x001a, 0x21ae}, /* saturation */
174 {0x00, 0x0002, 0x21a3}, /* gamma */
175 {0x30, 0x0004, 0x000a},
176 {0xb0, 0x0001, 0x0000},
177
178 {0xa1, 0x0080, 0x0001},
179 {0x30, 0x0049, 0x0000},
180 {0x30, 0x0060, 0x0005},
181 {0x0c, 0x0004, 0x0000},
182 {0x00, 0x0000, 0x0000},
183 {0x00, 0x0000, 0x2000},
184 {0x00, 0x0013, 0x2301},
185 {0x00, 0x0003, 0x2000},
186 };
187
188 /* clicksmart 420 open data ? */
189 static const struct cmd spca504A_clicksmart420_open_data[] = {
190 {0x00, 0x0001, 0x2501},
191 {0x20, 0x0502, 0x0000},
192 {0x06, 0x0000, 0x0000},
193 {0x00, 0x0004, 0x2880},
194 {0x00, 0x0001, 0x2881},
195
196 {0xa0, 0x0000, 0x0503},
197 };
198
199 static const u8 qtable_creative_pccam[2][64] = {
200 { /* Q-table Y-components */
201 0x05, 0x03, 0x03, 0x05, 0x07, 0x0c, 0x0f, 0x12,
202 0x04, 0x04, 0x04, 0x06, 0x08, 0x11, 0x12, 0x11,
203 0x04, 0x04, 0x05, 0x07, 0x0c, 0x11, 0x15, 0x11,
204 0x04, 0x05, 0x07, 0x09, 0x0f, 0x1a, 0x18, 0x13,
205 0x05, 0x07, 0x0b, 0x11, 0x14, 0x21, 0x1f, 0x17,
206 0x07, 0x0b, 0x11, 0x13, 0x18, 0x1f, 0x22, 0x1c,
207 0x0f, 0x13, 0x17, 0x1a, 0x1f, 0x24, 0x24, 0x1e,
208 0x16, 0x1c, 0x1d, 0x1d, 0x22, 0x1e, 0x1f, 0x1e},
209 { /* Q-table C-components */
210 0x05, 0x05, 0x07, 0x0e, 0x1e, 0x1e, 0x1e, 0x1e,
211 0x05, 0x06, 0x08, 0x14, 0x1e, 0x1e, 0x1e, 0x1e,
212 0x07, 0x08, 0x11, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
213 0x0e, 0x14, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
214 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
215 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
216 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
217 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e}
218 };
219
220 /* FIXME: This Q-table is identical to the Creative PC-CAM one,
221 * except for one byte. Possibly a typo?
222 * NWG: 18/05/2003.
223 */
224 static const u8 qtable_spca504_default[2][64] = {
225 { /* Q-table Y-components */
226 0x05, 0x03, 0x03, 0x05, 0x07, 0x0c, 0x0f, 0x12,
227 0x04, 0x04, 0x04, 0x06, 0x08, 0x11, 0x12, 0x11,
228 0x04, 0x04, 0x05, 0x07, 0x0c, 0x11, 0x15, 0x11,
229 0x04, 0x05, 0x07, 0x09, 0x0f, 0x1a, 0x18, 0x13,
230 0x05, 0x07, 0x0b, 0x11, 0x14, 0x21, 0x1f, 0x17,
231 0x07, 0x0b, 0x11, 0x13, 0x18, 0x1f, 0x22, 0x1c,
232 0x0f, 0x13, 0x17, 0x1a, 0x1f, 0x24, 0x24, 0x1e,
233 0x16, 0x1c, 0x1d, 0x1d, 0x1d /* 0x22 */ , 0x1e, 0x1f, 0x1e,
234 },
235 { /* Q-table C-components */
236 0x05, 0x05, 0x07, 0x0e, 0x1e, 0x1e, 0x1e, 0x1e,
237 0x05, 0x06, 0x08, 0x14, 0x1e, 0x1e, 0x1e, 0x1e,
238 0x07, 0x08, 0x11, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
239 0x0e, 0x14, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
240 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
241 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
242 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
243 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e}
244 };
245
246 /* read <len> bytes to gspca_dev->usb_buf */
247 static void reg_r(struct gspca_dev *gspca_dev,
248 u8 req,
249 u16 index,
250 u16 len)
251 {
252 int ret;
253
254 #ifdef GSPCA_DEBUG
255 if (len > USB_BUF_SZ) {
256 pr_err("reg_r: buffer overflow\n");
257 return;
258 }
259 #endif
260 if (gspca_dev->usb_err < 0)
261 return;
262 ret = usb_control_msg(gspca_dev->dev,
263 usb_rcvctrlpipe(gspca_dev->dev, 0),
264 req,
265 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
266 0, /* value */
267 index,
268 len ? gspca_dev->usb_buf : NULL, len,
269 500);
270 if (ret < 0) {
271 pr_err("reg_r err %d\n", ret);
272 gspca_dev->usb_err = ret;
273 }
274 }
275
276 /* write one byte */
277 static void reg_w_1(struct gspca_dev *gspca_dev,
278 u8 req,
279 u16 value,
280 u16 index,
281 u16 byte)
282 {
283 int ret;
284
285 if (gspca_dev->usb_err < 0)
286 return;
287 gspca_dev->usb_buf[0] = byte;
288 ret = usb_control_msg(gspca_dev->dev,
289 usb_sndctrlpipe(gspca_dev->dev, 0),
290 req,
291 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
292 value, index,
293 gspca_dev->usb_buf, 1,
294 500);
295 if (ret < 0) {
296 pr_err("reg_w_1 err %d\n", ret);
297 gspca_dev->usb_err = ret;
298 }
299 }
300
301 /* write req / index / value */
302 static void reg_w_riv(struct gspca_dev *gspca_dev,
303 u8 req, u16 index, u16 value)
304 {
305 struct usb_device *dev = gspca_dev->dev;
306 int ret;
307
308 if (gspca_dev->usb_err < 0)
309 return;
310 ret = usb_control_msg(dev,
311 usb_sndctrlpipe(dev, 0),
312 req,
313 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
314 value, index, NULL, 0, 500);
315 if (ret < 0) {
316 pr_err("reg_w_riv err %d\n", ret);
317 gspca_dev->usb_err = ret;
318 return;
319 }
320 PDEBUG(D_USBO, "reg_w_riv: 0x%02x,0x%04x:0x%04x",
321 req, index, value);
322 }
323
324 static void write_vector(struct gspca_dev *gspca_dev,
325 const struct cmd *data, int ncmds)
326 {
327 while (--ncmds >= 0) {
328 reg_w_riv(gspca_dev, data->req, data->idx, data->val);
329 data++;
330 }
331 }
332
333 static void setup_qtable(struct gspca_dev *gspca_dev,
334 const u8 qtable[2][64])
335 {
336 int i;
337
338 /* loop over y components */
339 for (i = 0; i < 64; i++)
340 reg_w_riv(gspca_dev, 0x00, 0x2800 + i, qtable[0][i]);
341
342 /* loop over c components */
343 for (i = 0; i < 64; i++)
344 reg_w_riv(gspca_dev, 0x00, 0x2840 + i, qtable[1][i]);
345 }
346
347 static void spca504_acknowledged_command(struct gspca_dev *gspca_dev,
348 u8 req, u16 idx, u16 val)
349 {
350 reg_w_riv(gspca_dev, req, idx, val);
351 reg_r(gspca_dev, 0x01, 0x0001, 1);
352 PDEBUG(D_FRAM, "before wait 0x%04x", gspca_dev->usb_buf[0]);
353 reg_w_riv(gspca_dev, req, idx, val);
354
355 msleep(200);
356 reg_r(gspca_dev, 0x01, 0x0001, 1);
357 PDEBUG(D_FRAM, "after wait 0x%04x", gspca_dev->usb_buf[0]);
358 }
359
360 #ifdef GSPCA_DEBUG
361 static void spca504_read_info(struct gspca_dev *gspca_dev)
362 {
363 int i;
364 u8 info[6];
365
366 for (i = 0; i < 6; i++) {
367 reg_r(gspca_dev, 0, i, 1);
368 info[i] = gspca_dev->usb_buf[0];
369 }
370 PDEBUG(D_STREAM,
371 "Read info: %d %d %d %d %d %d."
372 " Should be 1,0,2,2,0,0",
373 info[0], info[1], info[2],
374 info[3], info[4], info[5]);
375 }
376 #endif
377
378 static void spca504A_acknowledged_command(struct gspca_dev *gspca_dev,
379 u8 req,
380 u16 idx, u16 val, u8 endcode, u8 count)
381 {
382 u16 status;
383
384 reg_w_riv(gspca_dev, req, idx, val);
385 reg_r(gspca_dev, 0x01, 0x0001, 1);
386 if (gspca_dev->usb_err < 0)
387 return;
388 PDEBUG(D_FRAM, "Status 0x%02x Need 0x%02x",
389 gspca_dev->usb_buf[0], endcode);
390 if (!count)
391 return;
392 count = 200;
393 while (--count > 0) {
394 msleep(10);
395 /* gsmart mini2 write a each wait setting 1 ms is enough */
396 /* reg_w_riv(gspca_dev, req, idx, val); */
397 reg_r(gspca_dev, 0x01, 0x0001, 1);
398 status = gspca_dev->usb_buf[0];
399 if (status == endcode) {
400 PDEBUG(D_FRAM, "status 0x%04x after wait %d",
401 status, 200 - count);
402 break;
403 }
404 }
405 }
406
407 static void spca504B_PollingDataReady(struct gspca_dev *gspca_dev)
408 {
409 int count = 10;
410
411 while (--count > 0) {
412 reg_r(gspca_dev, 0x21, 0, 1);
413 if ((gspca_dev->usb_buf[0] & 0x01) == 0)
414 break;
415 msleep(10);
416 }
417 }
418
419 static void spca504B_WaitCmdStatus(struct gspca_dev *gspca_dev)
420 {
421 int count = 50;
422
423 while (--count > 0) {
424 reg_r(gspca_dev, 0x21, 1, 1);
425 if (gspca_dev->usb_buf[0] != 0) {
426 reg_w_1(gspca_dev, 0x21, 0, 1, 0);
427 reg_r(gspca_dev, 0x21, 1, 1);
428 spca504B_PollingDataReady(gspca_dev);
429 break;
430 }
431 msleep(10);
432 }
433 }
434
435 #ifdef GSPCA_DEBUG
436 static void spca50x_GetFirmware(struct gspca_dev *gspca_dev)
437 {
438 u8 *data;
439
440 data = gspca_dev->usb_buf;
441 reg_r(gspca_dev, 0x20, 0, 5);
442 PDEBUG(D_STREAM, "FirmWare: %d %d %d %d %d",
443 data[0], data[1], data[2], data[3], data[4]);
444 reg_r(gspca_dev, 0x23, 0, 64);
445 reg_r(gspca_dev, 0x23, 1, 64);
446 }
447 #endif
448
449 static void spca504B_SetSizeType(struct gspca_dev *gspca_dev)
450 {
451 struct sd *sd = (struct sd *) gspca_dev;
452 u8 Size;
453
454 Size = gspca_dev->cam.cam_mode[gspca_dev->curr_mode].priv;
455 switch (sd->bridge) {
456 case BRIDGE_SPCA533:
457 reg_w_riv(gspca_dev, 0x31, 0, 0);
458 spca504B_WaitCmdStatus(gspca_dev);
459 spca504B_PollingDataReady(gspca_dev);
460 #ifdef GSPCA_DEBUG
461 spca50x_GetFirmware(gspca_dev);
462 #endif
463 reg_w_1(gspca_dev, 0x24, 0, 8, 2); /* type */
464 reg_r(gspca_dev, 0x24, 8, 1);
465
466 reg_w_1(gspca_dev, 0x25, 0, 4, Size);
467 reg_r(gspca_dev, 0x25, 4, 1); /* size */
468 spca504B_PollingDataReady(gspca_dev);
469
470 /* Init the cam width height with some values get on init ? */
471 reg_w_riv(gspca_dev, 0x31, 0x0004, 0x00);
472 spca504B_WaitCmdStatus(gspca_dev);
473 spca504B_PollingDataReady(gspca_dev);
474 break;
475 default:
476 /* case BRIDGE_SPCA504B: */
477 /* case BRIDGE_SPCA536: */
478 reg_w_1(gspca_dev, 0x25, 0, 4, Size);
479 reg_r(gspca_dev, 0x25, 4, 1); /* size */
480 reg_w_1(gspca_dev, 0x27, 0, 0, 6);
481 reg_r(gspca_dev, 0x27, 0, 1); /* type */
482 spca504B_PollingDataReady(gspca_dev);
483 break;
484 case BRIDGE_SPCA504:
485 Size += 3;
486 if (sd->subtype == AiptekMiniPenCam13) {
487 /* spca504a aiptek */
488 spca504A_acknowledged_command(gspca_dev,
489 0x08, Size, 0,
490 0x80 | (Size & 0x0f), 1);
491 spca504A_acknowledged_command(gspca_dev,
492 1, 3, 0, 0x9f, 0);
493 } else {
494 spca504_acknowledged_command(gspca_dev, 0x08, Size, 0);
495 }
496 break;
497 case BRIDGE_SPCA504C:
498 /* capture mode */
499 reg_w_riv(gspca_dev, 0xa0, (0x0500 | (Size & 0x0f)), 0x00);
500 reg_w_riv(gspca_dev, 0x20, 0x01, 0x0500 | (Size & 0x0f));
501 break;
502 }
503 }
504
505 static void spca504_wait_status(struct gspca_dev *gspca_dev)
506 {
507 int cnt;
508
509 cnt = 256;
510 while (--cnt > 0) {
511 /* With this we get the status, when return 0 it's all ok */
512 reg_r(gspca_dev, 0x06, 0x00, 1);
513 if (gspca_dev->usb_buf[0] == 0)
514 return;
515 msleep(10);
516 }
517 }
518
519 static void spca504B_setQtable(struct gspca_dev *gspca_dev)
520 {
521 reg_w_1(gspca_dev, 0x26, 0, 0, 3);
522 reg_r(gspca_dev, 0x26, 0, 1);
523 spca504B_PollingDataReady(gspca_dev);
524 }
525
526 static void setbrightness(struct gspca_dev *gspca_dev, s32 val)
527 {
528 struct sd *sd = (struct sd *) gspca_dev;
529 u16 reg;
530
531 reg = sd->bridge == BRIDGE_SPCA536 ? 0x20f0 : 0x21a7;
532 reg_w_riv(gspca_dev, 0x00, reg, val);
533 }
534
535 static void setcontrast(struct gspca_dev *gspca_dev, s32 val)
536 {
537 struct sd *sd = (struct sd *) gspca_dev;
538 u16 reg;
539
540 reg = sd->bridge == BRIDGE_SPCA536 ? 0x20f1 : 0x21a8;
541 reg_w_riv(gspca_dev, 0x00, reg, val);
542 }
543
544 static void setcolors(struct gspca_dev *gspca_dev, s32 val)
545 {
546 struct sd *sd = (struct sd *) gspca_dev;
547 u16 reg;
548
549 reg = sd->bridge == BRIDGE_SPCA536 ? 0x20f6 : 0x21ae;
550 reg_w_riv(gspca_dev, 0x00, reg, val);
551 }
552
553 static void init_ctl_reg(struct gspca_dev *gspca_dev)
554 {
555 struct sd *sd = (struct sd *) gspca_dev;
556 int pollreg = 1;
557
558 switch (sd->bridge) {
559 case BRIDGE_SPCA504:
560 case BRIDGE_SPCA504C:
561 pollreg = 0;
562 /* fall thru */
563 default:
564 /* case BRIDGE_SPCA533: */
565 /* case BRIDGE_SPCA504B: */
566 reg_w_riv(gspca_dev, 0, 0x21ad, 0x00); /* hue */
567 reg_w_riv(gspca_dev, 0, 0x21ac, 0x01); /* sat/hue */
568 reg_w_riv(gspca_dev, 0, 0x21a3, 0x00); /* gamma */
569 break;
570 case BRIDGE_SPCA536:
571 reg_w_riv(gspca_dev, 0, 0x20f5, 0x40);
572 reg_w_riv(gspca_dev, 0, 0x20f4, 0x01);
573 reg_w_riv(gspca_dev, 0, 0x2089, 0x00);
574 break;
575 }
576 if (pollreg)
577 spca504B_PollingDataReady(gspca_dev);
578 }
579
580 /* this function is called at probe time */
581 static int sd_config(struct gspca_dev *gspca_dev,
582 const struct usb_device_id *id)
583 {
584 struct sd *sd = (struct sd *) gspca_dev;
585 struct cam *cam;
586
587 cam = &gspca_dev->cam;
588
589 sd->bridge = id->driver_info >> 8;
590 sd->subtype = id->driver_info;
591
592 if (sd->subtype == AiptekMiniPenCam13) {
593
594 /* try to get the firmware as some cam answer 2.0.1.2.2
595 * and should be a spca504b then overwrite that setting */
596 reg_r(gspca_dev, 0x20, 0, 1);
597 switch (gspca_dev->usb_buf[0]) {
598 case 1:
599 break; /* (right bridge/subtype) */
600 case 2:
601 sd->bridge = BRIDGE_SPCA504B;
602 sd->subtype = 0;
603 break;
604 default:
605 return -ENODEV;
606 }
607 }
608
609 switch (sd->bridge) {
610 default:
611 /* case BRIDGE_SPCA504B: */
612 /* case BRIDGE_SPCA504: */
613 /* case BRIDGE_SPCA536: */
614 cam->cam_mode = vga_mode;
615 cam->nmodes = ARRAY_SIZE(vga_mode);
616 break;
617 case BRIDGE_SPCA533:
618 cam->cam_mode = custom_mode;
619 if (sd->subtype == MegaImageVI) /* 320x240 only */
620 cam->nmodes = ARRAY_SIZE(custom_mode) - 1;
621 else
622 cam->nmodes = ARRAY_SIZE(custom_mode);
623 break;
624 case BRIDGE_SPCA504C:
625 cam->cam_mode = vga_mode2;
626 cam->nmodes = ARRAY_SIZE(vga_mode2);
627 break;
628 }
629 return 0;
630 }
631
632 /* this function is called at probe and resume time */
633 static int sd_init(struct gspca_dev *gspca_dev)
634 {
635 struct sd *sd = (struct sd *) gspca_dev;
636
637 switch (sd->bridge) {
638 case BRIDGE_SPCA504B:
639 reg_w_riv(gspca_dev, 0x1d, 0x00, 0);
640 reg_w_riv(gspca_dev, 0x00, 0x2306, 0x01);
641 reg_w_riv(gspca_dev, 0x00, 0x0d04, 0x00);
642 reg_w_riv(gspca_dev, 0x00, 0x2000, 0x00);
643 reg_w_riv(gspca_dev, 0x00, 0x2301, 0x13);
644 reg_w_riv(gspca_dev, 0x00, 0x2306, 0x00);
645 /* fall thru */
646 case BRIDGE_SPCA533:
647 spca504B_PollingDataReady(gspca_dev);
648 #ifdef GSPCA_DEBUG
649 spca50x_GetFirmware(gspca_dev);
650 #endif
651 break;
652 case BRIDGE_SPCA536:
653 #ifdef GSPCA_DEBUG
654 spca50x_GetFirmware(gspca_dev);
655 #endif
656 reg_r(gspca_dev, 0x00, 0x5002, 1);
657 reg_w_1(gspca_dev, 0x24, 0, 0, 0);
658 reg_r(gspca_dev, 0x24, 0, 1);
659 spca504B_PollingDataReady(gspca_dev);
660 reg_w_riv(gspca_dev, 0x34, 0, 0);
661 spca504B_WaitCmdStatus(gspca_dev);
662 break;
663 case BRIDGE_SPCA504C: /* pccam600 */
664 PDEBUG(D_STREAM, "Opening SPCA504 (PC-CAM 600)");
665 reg_w_riv(gspca_dev, 0xe0, 0x0000, 0x0000);
666 reg_w_riv(gspca_dev, 0xe0, 0x0000, 0x0001); /* reset */
667 spca504_wait_status(gspca_dev);
668 if (sd->subtype == LogitechClickSmart420)
669 write_vector(gspca_dev,
670 spca504A_clicksmart420_open_data,
671 ARRAY_SIZE(spca504A_clicksmart420_open_data));
672 else
673 write_vector(gspca_dev, spca504_pccam600_open_data,
674 ARRAY_SIZE(spca504_pccam600_open_data));
675 setup_qtable(gspca_dev, qtable_creative_pccam);
676 break;
677 default:
678 /* case BRIDGE_SPCA504: */
679 PDEBUG(D_STREAM, "Opening SPCA504");
680 if (sd->subtype == AiptekMiniPenCam13) {
681 #ifdef GSPCA_DEBUG
682 spca504_read_info(gspca_dev);
683 #endif
684
685 /* Set AE AWB Banding Type 3-> 50Hz 2-> 60Hz */
686 spca504A_acknowledged_command(gspca_dev, 0x24,
687 8, 3, 0x9e, 1);
688 /* Twice sequential need status 0xff->0x9e->0x9d */
689 spca504A_acknowledged_command(gspca_dev, 0x24,
690 8, 3, 0x9e, 0);
691
692 spca504A_acknowledged_command(gspca_dev, 0x24,
693 0, 0, 0x9d, 1);
694 /******************************/
695 /* spca504a aiptek */
696 spca504A_acknowledged_command(gspca_dev, 0x08,
697 6, 0, 0x86, 1);
698 /* reg_write (dev, 0, 0x2000, 0); */
699 /* reg_write (dev, 0, 0x2883, 1); */
700 /* spca504A_acknowledged_command (gspca_dev, 0x08,
701 6, 0, 0x86, 1); */
702 /* spca504A_acknowledged_command (gspca_dev, 0x24,
703 0, 0, 0x9D, 1); */
704 reg_w_riv(gspca_dev, 0x00, 0x270c, 0x05);
705 /* L92 sno1t.txt */
706 reg_w_riv(gspca_dev, 0x00, 0x2310, 0x05);
707 spca504A_acknowledged_command(gspca_dev, 0x01,
708 0x0f, 0, 0xff, 0);
709 }
710 /* setup qtable */
711 reg_w_riv(gspca_dev, 0, 0x2000, 0);
712 reg_w_riv(gspca_dev, 0, 0x2883, 1);
713 setup_qtable(gspca_dev, qtable_spca504_default);
714 break;
715 }
716 return gspca_dev->usb_err;
717 }
718
719 static int sd_start(struct gspca_dev *gspca_dev)
720 {
721 struct sd *sd = (struct sd *) gspca_dev;
722 int enable;
723
724 /* create the JPEG header */
725 jpeg_define(sd->jpeg_hdr, gspca_dev->height, gspca_dev->width,
726 0x22); /* JPEG 411 */
727 jpeg_set_qual(sd->jpeg_hdr, QUALITY);
728
729 if (sd->bridge == BRIDGE_SPCA504B)
730 spca504B_setQtable(gspca_dev);
731 spca504B_SetSizeType(gspca_dev);
732 switch (sd->bridge) {
733 default:
734 /* case BRIDGE_SPCA504B: */
735 /* case BRIDGE_SPCA533: */
736 /* case BRIDGE_SPCA536: */
737 switch (sd->subtype) {
738 case MegapixV4:
739 case LogitechClickSmart820:
740 case MegaImageVI:
741 reg_w_riv(gspca_dev, 0xf0, 0, 0);
742 spca504B_WaitCmdStatus(gspca_dev);
743 reg_r(gspca_dev, 0xf0, 4, 0);
744 spca504B_WaitCmdStatus(gspca_dev);
745 break;
746 default:
747 reg_w_riv(gspca_dev, 0x31, 0x0004, 0x00);
748 spca504B_WaitCmdStatus(gspca_dev);
749 spca504B_PollingDataReady(gspca_dev);
750 break;
751 }
752 break;
753 case BRIDGE_SPCA504:
754 if (sd->subtype == AiptekMiniPenCam13) {
755 #ifdef GSPCA_DEBUG
756 spca504_read_info(gspca_dev);
757 #endif
758
759 /* Set AE AWB Banding Type 3-> 50Hz 2-> 60Hz */
760 spca504A_acknowledged_command(gspca_dev, 0x24,
761 8, 3, 0x9e, 1);
762 /* Twice sequential need status 0xff->0x9e->0x9d */
763 spca504A_acknowledged_command(gspca_dev, 0x24,
764 8, 3, 0x9e, 0);
765 spca504A_acknowledged_command(gspca_dev, 0x24,
766 0, 0, 0x9d, 1);
767 } else {
768 spca504_acknowledged_command(gspca_dev, 0x24, 8, 3);
769 #ifdef GSPCA_DEBUG
770 spca504_read_info(gspca_dev);
771 #endif
772 spca504_acknowledged_command(gspca_dev, 0x24, 8, 3);
773 spca504_acknowledged_command(gspca_dev, 0x24, 0, 0);
774 }
775 spca504B_SetSizeType(gspca_dev);
776 reg_w_riv(gspca_dev, 0x00, 0x270c, 0x05);
777 /* L92 sno1t.txt */
778 reg_w_riv(gspca_dev, 0x00, 0x2310, 0x05);
779 break;
780 case BRIDGE_SPCA504C:
781 if (sd->subtype == LogitechClickSmart420) {
782 write_vector(gspca_dev,
783 spca504A_clicksmart420_init_data,
784 ARRAY_SIZE(spca504A_clicksmart420_init_data));
785 } else {
786 write_vector(gspca_dev, spca504_pccam600_init_data,
787 ARRAY_SIZE(spca504_pccam600_init_data));
788 }
789 enable = (sd->autogain ? 0x04 : 0x01);
790 reg_w_riv(gspca_dev, 0x0c, 0x0000, enable);
791 /* auto exposure */
792 reg_w_riv(gspca_dev, 0xb0, 0x0000, enable);
793 /* auto whiteness */
794
795 /* set default exposure compensation and whiteness balance */
796 reg_w_riv(gspca_dev, 0x30, 0x0001, 800); /* ~ 20 fps */
797 reg_w_riv(gspca_dev, 0x30, 0x0002, 1600);
798 spca504B_SetSizeType(gspca_dev);
799 break;
800 }
801 init_ctl_reg(gspca_dev);
802 return gspca_dev->usb_err;
803 }
804
805 static void sd_stopN(struct gspca_dev *gspca_dev)
806 {
807 struct sd *sd = (struct sd *) gspca_dev;
808
809 switch (sd->bridge) {
810 default:
811 /* case BRIDGE_SPCA533: */
812 /* case BRIDGE_SPCA536: */
813 /* case BRIDGE_SPCA504B: */
814 reg_w_riv(gspca_dev, 0x31, 0, 0);
815 spca504B_WaitCmdStatus(gspca_dev);
816 spca504B_PollingDataReady(gspca_dev);
817 break;
818 case BRIDGE_SPCA504:
819 case BRIDGE_SPCA504C:
820 reg_w_riv(gspca_dev, 0x00, 0x2000, 0x0000);
821
822 if (sd->subtype == AiptekMiniPenCam13) {
823 /* spca504a aiptek */
824 /* spca504A_acknowledged_command(gspca_dev, 0x08,
825 6, 0, 0x86, 1); */
826 spca504A_acknowledged_command(gspca_dev, 0x24,
827 0x00, 0x00, 0x9d, 1);
828 spca504A_acknowledged_command(gspca_dev, 0x01,
829 0x0f, 0x00, 0xff, 1);
830 } else {
831 spca504_acknowledged_command(gspca_dev, 0x24, 0, 0);
832 reg_w_riv(gspca_dev, 0x01, 0x000f, 0x0000);
833 }
834 break;
835 }
836 }
837
838 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
839 u8 *data, /* isoc packet */
840 int len) /* iso packet length */
841 {
842 struct sd *sd = (struct sd *) gspca_dev;
843 int i, sof = 0;
844 static u8 ffd9[] = {0xff, 0xd9};
845
846 /* frames are jpeg 4.1.1 without 0xff escape */
847 switch (sd->bridge) {
848 case BRIDGE_SPCA533:
849 if (data[0] == 0xff) {
850 if (data[1] != 0x01) { /* drop packet */
851 /* gspca_dev->last_packet_type = DISCARD_PACKET; */
852 return;
853 }
854 sof = 1;
855 data += SPCA533_OFFSET_DATA;
856 len -= SPCA533_OFFSET_DATA;
857 } else {
858 data += 1;
859 len -= 1;
860 }
861 break;
862 case BRIDGE_SPCA536:
863 if (data[0] == 0xff) {
864 sof = 1;
865 data += SPCA536_OFFSET_DATA;
866 len -= SPCA536_OFFSET_DATA;
867 } else {
868 data += 2;
869 len -= 2;
870 }
871 break;
872 default:
873 /* case BRIDGE_SPCA504: */
874 /* case BRIDGE_SPCA504B: */
875 switch (data[0]) {
876 case 0xfe: /* start of frame */
877 sof = 1;
878 data += SPCA50X_OFFSET_DATA;
879 len -= SPCA50X_OFFSET_DATA;
880 break;
881 case 0xff: /* drop packet */
882 /* gspca_dev->last_packet_type = DISCARD_PACKET; */
883 return;
884 default:
885 data += 1;
886 len -= 1;
887 break;
888 }
889 break;
890 case BRIDGE_SPCA504C:
891 switch (data[0]) {
892 case 0xfe: /* start of frame */
893 sof = 1;
894 data += SPCA504_PCCAM600_OFFSET_DATA;
895 len -= SPCA504_PCCAM600_OFFSET_DATA;
896 break;
897 case 0xff: /* drop packet */
898 /* gspca_dev->last_packet_type = DISCARD_PACKET; */
899 return;
900 default:
901 data += 1;
902 len -= 1;
903 break;
904 }
905 break;
906 }
907 if (sof) { /* start of frame */
908 gspca_frame_add(gspca_dev, LAST_PACKET,
909 ffd9, 2);
910
911 /* put the JPEG header in the new frame */
912 gspca_frame_add(gspca_dev, FIRST_PACKET,
913 sd->jpeg_hdr, JPEG_HDR_SZ);
914 }
915
916 /* add 0x00 after 0xff */
917 i = 0;
918 do {
919 if (data[i] == 0xff) {
920 gspca_frame_add(gspca_dev, INTER_PACKET,
921 data, i + 1);
922 len -= i;
923 data += i;
924 *data = 0x00;
925 i = 0;
926 }
927 i++;
928 } while (i < len);
929 gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
930 }
931
932 static int sd_s_ctrl(struct v4l2_ctrl *ctrl)
933 {
934 struct gspca_dev *gspca_dev =
935 container_of(ctrl->handler, struct gspca_dev, ctrl_handler);
936 struct sd *sd = (struct sd *)gspca_dev;
937
938 gspca_dev->usb_err = 0;
939
940 if (!gspca_dev->streaming)
941 return 0;
942
943 switch (ctrl->id) {
944 case V4L2_CID_BRIGHTNESS:
945 setbrightness(gspca_dev, ctrl->val);
946 break;
947 case V4L2_CID_CONTRAST:
948 setcontrast(gspca_dev, ctrl->val);
949 break;
950 case V4L2_CID_SATURATION:
951 setcolors(gspca_dev, ctrl->val);
952 break;
953 case V4L2_CID_AUTOGAIN:
954 sd->autogain = ctrl->val;
955 break;
956 }
957 return gspca_dev->usb_err;
958 }
959
960 static const struct v4l2_ctrl_ops sd_ctrl_ops = {
961 .s_ctrl = sd_s_ctrl,
962 };
963
964 static int sd_init_controls(struct gspca_dev *gspca_dev)
965 {
966 struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler;
967
968 gspca_dev->vdev.ctrl_handler = hdl;
969 v4l2_ctrl_handler_init(hdl, 4);
970 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
971 V4L2_CID_BRIGHTNESS, -128, 127, 1, 0);
972 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
973 V4L2_CID_CONTRAST, 0, 255, 1, 0x20);
974 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
975 V4L2_CID_SATURATION, 0, 255, 1, 0x1a);
976 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
977 V4L2_CID_AUTOGAIN, 0, 1, 1, 1);
978
979 if (hdl->error) {
980 pr_err("Could not initialize controls\n");
981 return hdl->error;
982 }
983 return 0;
984 }
985
986 /* sub-driver description */
987 static const struct sd_desc sd_desc = {
988 .name = MODULE_NAME,
989 .config = sd_config,
990 .init = sd_init,
991 .init_controls = sd_init_controls,
992 .start = sd_start,
993 .stopN = sd_stopN,
994 .pkt_scan = sd_pkt_scan,
995 };
996
997 /* -- module initialisation -- */
998 #define BS(bridge, subtype) \
999 .driver_info = (BRIDGE_ ## bridge << 8) \
1000 | (subtype)
1001 static const struct usb_device_id device_table[] = {
1002 {USB_DEVICE(0x041e, 0x400b), BS(SPCA504C, 0)},
1003 {USB_DEVICE(0x041e, 0x4012), BS(SPCA504C, 0)},
1004 {USB_DEVICE(0x041e, 0x4013), BS(SPCA504C, 0)},
1005 {USB_DEVICE(0x0458, 0x7006), BS(SPCA504B, 0)},
1006 {USB_DEVICE(0x0461, 0x0821), BS(SPCA533, 0)},
1007 {USB_DEVICE(0x046d, 0x0905), BS(SPCA533, LogitechClickSmart820)},
1008 {USB_DEVICE(0x046d, 0x0960), BS(SPCA504C, LogitechClickSmart420)},
1009 {USB_DEVICE(0x0471, 0x0322), BS(SPCA504B, 0)},
1010 {USB_DEVICE(0x04a5, 0x3003), BS(SPCA504B, 0)},
1011 {USB_DEVICE(0x04a5, 0x3008), BS(SPCA533, 0)},
1012 {USB_DEVICE(0x04a5, 0x300a), BS(SPCA533, 0)},
1013 {USB_DEVICE(0x04f1, 0x1001), BS(SPCA504B, 0)},
1014 {USB_DEVICE(0x04fc, 0x500c), BS(SPCA504B, 0)},
1015 {USB_DEVICE(0x04fc, 0x504a), BS(SPCA504, AiptekMiniPenCam13)},
1016 {USB_DEVICE(0x04fc, 0x504b), BS(SPCA504B, 0)},
1017 {USB_DEVICE(0x04fc, 0x5330), BS(SPCA533, 0)},
1018 {USB_DEVICE(0x04fc, 0x5360), BS(SPCA536, 0)},
1019 {USB_DEVICE(0x04fc, 0xffff), BS(SPCA504B, 0)},
1020 {USB_DEVICE(0x052b, 0x1507), BS(SPCA533, MegapixV4)},
1021 {USB_DEVICE(0x052b, 0x1513), BS(SPCA533, MegapixV4)},
1022 {USB_DEVICE(0x052b, 0x1803), BS(SPCA533, MegaImageVI)},
1023 {USB_DEVICE(0x0546, 0x3155), BS(SPCA533, 0)},
1024 {USB_DEVICE(0x0546, 0x3191), BS(SPCA504B, 0)},
1025 {USB_DEVICE(0x0546, 0x3273), BS(SPCA504B, 0)},
1026 {USB_DEVICE(0x055f, 0xc211), BS(SPCA536, 0)},
1027 {USB_DEVICE(0x055f, 0xc230), BS(SPCA533, 0)},
1028 {USB_DEVICE(0x055f, 0xc232), BS(SPCA533, 0)},
1029 {USB_DEVICE(0x055f, 0xc360), BS(SPCA536, 0)},
1030 {USB_DEVICE(0x055f, 0xc420), BS(SPCA504, 0)},
1031 {USB_DEVICE(0x055f, 0xc430), BS(SPCA533, 0)},
1032 {USB_DEVICE(0x055f, 0xc440), BS(SPCA533, 0)},
1033 {USB_DEVICE(0x055f, 0xc520), BS(SPCA504, 0)},
1034 {USB_DEVICE(0x055f, 0xc530), BS(SPCA533, 0)},
1035 {USB_DEVICE(0x055f, 0xc540), BS(SPCA533, 0)},
1036 {USB_DEVICE(0x055f, 0xc630), BS(SPCA533, 0)},
1037 {USB_DEVICE(0x055f, 0xc650), BS(SPCA533, 0)},
1038 {USB_DEVICE(0x05da, 0x1018), BS(SPCA504B, 0)},
1039 {USB_DEVICE(0x06d6, 0x0031), BS(SPCA533, 0)},
1040 {USB_DEVICE(0x0733, 0x1311), BS(SPCA533, 0)},
1041 {USB_DEVICE(0x0733, 0x1314), BS(SPCA533, 0)},
1042 {USB_DEVICE(0x0733, 0x2211), BS(SPCA533, 0)},
1043 {USB_DEVICE(0x0733, 0x2221), BS(SPCA533, 0)},
1044 {USB_DEVICE(0x0733, 0x3261), BS(SPCA536, 0)},
1045 {USB_DEVICE(0x0733, 0x3281), BS(SPCA536, 0)},
1046 {USB_DEVICE(0x08ca, 0x0104), BS(SPCA533, 0)},
1047 {USB_DEVICE(0x08ca, 0x0106), BS(SPCA533, 0)},
1048 {USB_DEVICE(0x08ca, 0x2008), BS(SPCA504B, 0)},
1049 {USB_DEVICE(0x08ca, 0x2010), BS(SPCA533, 0)},
1050 {USB_DEVICE(0x08ca, 0x2016), BS(SPCA504B, 0)},
1051 {USB_DEVICE(0x08ca, 0x2018), BS(SPCA504B, 0)},
1052 {USB_DEVICE(0x08ca, 0x2020), BS(SPCA533, 0)},
1053 {USB_DEVICE(0x08ca, 0x2022), BS(SPCA533, 0)},
1054 {USB_DEVICE(0x08ca, 0x2024), BS(SPCA536, 0)},
1055 {USB_DEVICE(0x08ca, 0x2028), BS(SPCA533, 0)},
1056 {USB_DEVICE(0x08ca, 0x2040), BS(SPCA536, 0)},
1057 {USB_DEVICE(0x08ca, 0x2042), BS(SPCA536, 0)},
1058 {USB_DEVICE(0x08ca, 0x2050), BS(SPCA536, 0)},
1059 {USB_DEVICE(0x08ca, 0x2060), BS(SPCA536, 0)},
1060 {USB_DEVICE(0x0d64, 0x0303), BS(SPCA536, 0)},
1061 {}
1062 };
1063 MODULE_DEVICE_TABLE(usb, device_table);
1064
1065 /* -- device connect -- */
1066 static int sd_probe(struct usb_interface *intf,
1067 const struct usb_device_id *id)
1068 {
1069 return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
1070 THIS_MODULE);
1071 }
1072
1073 static struct usb_driver sd_driver = {
1074 .name = MODULE_NAME,
1075 .id_table = device_table,
1076 .probe = sd_probe,
1077 .disconnect = gspca_disconnect,
1078 #ifdef CONFIG_PM
1079 .suspend = gspca_suspend,
1080 .resume = gspca_resume,
1081 .reset_resume = gspca_resume,
1082 #endif
1083 };
1084
1085 module_usb_driver(sd_driver);
Linux ARM platform port for MOXA ART SoC