?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[ARM] pxa: update defconfig for Verdex Pro
[linux-2.6/verdex.git] / drivers / usb / misc / sisusbvga / sisusb.c
blob0025847743f30fc12500045e7980bd5568e4e83c
1 /*
2 * sisusb - usb kernel driver for SiS315(E) based USB2VGA dongles
3 *
4 * Main part
5 *
6 * Copyright (C) 2005 by Thomas Winischhofer, Vienna, Austria
7 *
8 * If distributed as part of the Linux kernel, this code is licensed under the
9 * terms of the GPL v2.
10 *
11 * Otherwise, the following license terms apply:
12 *
13 * * Redistribution and use in source and binary forms, with or without
14 * * modification, are permitted provided that the following conditions
15 * * are met:
16 * * 1) Redistributions of source code must retain the above copyright
17 * * notice, this list of conditions and the following disclaimer.
18 * * 2) Redistributions in binary form must reproduce the above copyright
19 * * notice, this list of conditions and the following disclaimer in the
20 * * documentation and/or other materials provided with the distribution.
21 * * 3) The name of the author may not be used to endorse or promote products
22 * * derived from this software without specific psisusbr written permission.
23 * *
24 * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESSED OR
25 * * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
26 * * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
27 * * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
28 * * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
29 * * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
30 * * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
31 * * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
32 * * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
33 * * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34 *
35 * Author: Thomas Winischhofer <thomas@winischhofer.net>
36 *
37 */
38
39 #include <linux/mutex.h>
40 #include <linux/module.h>
41 #include <linux/kernel.h>
42 #include <linux/signal.h>
43 #include <linux/errno.h>
44 #include <linux/poll.h>
45 #include <linux/init.h>
46 #include <linux/slab.h>
47 #include <linux/spinlock.h>
48 #include <linux/kref.h>
49 #include <linux/usb.h>
50 #include <linux/smp_lock.h>
51 #include <linux/vmalloc.h>
52
53 #include "sisusb.h"
54 #include "sisusb_init.h"
55
56 #ifdef INCL_SISUSB_CON
57 #include <linux/font.h>
58 #endif
59
60 #define SISUSB_DONTSYNC
61
62 /* Forward declarations / clean-up routines */
63
64 #ifdef INCL_SISUSB_CON
65 static int sisusb_first_vc = 0;
66 static int sisusb_last_vc = 0;
67 module_param_named(first, sisusb_first_vc, int, 0);
68 module_param_named(last, sisusb_last_vc, int, 0);
69 MODULE_PARM_DESC(first, "Number of first console to take over (1 - MAX_NR_CONSOLES)");
70 MODULE_PARM_DESC(last, "Number of last console to take over (1 - MAX_NR_CONSOLES)");
71 #endif
72
73 static struct usb_driver sisusb_driver;
74
75 static void
76 sisusb_free_buffers(struct sisusb_usb_data *sisusb)
77 {
78 int i;
79
80 for (i = 0; i < NUMOBUFS; i++) {
81 if (sisusb->obuf[i]) {
82 kfree(sisusb->obuf[i]);
83 sisusb->obuf[i] = NULL;
84 }
85 }
86 if (sisusb->ibuf) {
87 kfree(sisusb->ibuf);
88 sisusb->ibuf = NULL;
89 }
90 }
91
92 static void
93 sisusb_free_urbs(struct sisusb_usb_data *sisusb)
94 {
95 int i;
96
97 for (i = 0; i < NUMOBUFS; i++) {
98 usb_free_urb(sisusb->sisurbout[i]);
99 sisusb->sisurbout[i] = NULL;
100 }
101 usb_free_urb(sisusb->sisurbin);
102 sisusb->sisurbin = NULL;
103 }
104
105 /* Level 0: USB transport layer */
106
107 /* 1. out-bulks */
108
109 /* out-urb management */
110
111 /* Return 1 if all free, 0 otherwise */
112 static int
113 sisusb_all_free(struct sisusb_usb_data *sisusb)
114 {
115 int i;
116
117 for (i = 0; i < sisusb->numobufs; i++) {
118
119 if (sisusb->urbstatus[i] & SU_URB_BUSY)
120 return 0;
121
122 }
123
124 return 1;
125 }
126
127 /* Kill all busy URBs */
128 static void
129 sisusb_kill_all_busy(struct sisusb_usb_data *sisusb)
130 {
131 int i;
132
133 if (sisusb_all_free(sisusb))
134 return;
135
136 for (i = 0; i < sisusb->numobufs; i++) {
137
138 if (sisusb->urbstatus[i] & SU_URB_BUSY)
139 usb_kill_urb(sisusb->sisurbout[i]);
140
141 }
142 }
143
144 /* Return 1 if ok, 0 if error (not all complete within timeout) */
145 static int
146 sisusb_wait_all_out_complete(struct sisusb_usb_data *sisusb)
147 {
148 int timeout = 5 * HZ, i = 1;
149
150 wait_event_timeout(sisusb->wait_q,
151 (i = sisusb_all_free(sisusb)),
152 timeout);
153
154 return i;
155 }
156
157 static int
158 sisusb_outurb_available(struct sisusb_usb_data *sisusb)
159 {
160 int i;
161
162 for (i = 0; i < sisusb->numobufs; i++) {
163
164 if ((sisusb->urbstatus[i] & (SU_URB_BUSY|SU_URB_ALLOC)) == 0)
165 return i;
166
167 }
168
169 return -1;
170 }
171
172 static int
173 sisusb_get_free_outbuf(struct sisusb_usb_data *sisusb)
174 {
175 int i, timeout = 5 * HZ;
176
177 wait_event_timeout(sisusb->wait_q,
178 ((i = sisusb_outurb_available(sisusb)) >= 0),
179 timeout);
180
181 return i;
182 }
183
184 static int
185 sisusb_alloc_outbuf(struct sisusb_usb_data *sisusb)
186 {
187 int i;
188
189 i = sisusb_outurb_available(sisusb);
190
191 if (i >= 0)
192 sisusb->urbstatus[i] |= SU_URB_ALLOC;
193
194 return i;
195 }
196
197 static void
198 sisusb_free_outbuf(struct sisusb_usb_data *sisusb, int index)
199 {
200 if ((index >= 0) && (index < sisusb->numobufs))
201 sisusb->urbstatus[index] &= ~SU_URB_ALLOC;
202 }
203
204 /* completion callback */
205
206 static void
207 sisusb_bulk_completeout(struct urb *urb)
208 {
209 struct sisusb_urb_context *context = urb->context;
210 struct sisusb_usb_data *sisusb;
211
212 if (!context)
213 return;
214
215 sisusb = context->sisusb;
216
217 if (!sisusb || !sisusb->sisusb_dev || !sisusb->present)
218 return;
219
220 #ifndef SISUSB_DONTSYNC
221 if (context->actual_length)
222 *(context->actual_length) += urb->actual_length;
223 #endif
224
225 sisusb->urbstatus[context->urbindex] &= ~SU_URB_BUSY;
226 wake_up(&sisusb->wait_q);
227 }
228
229 static int
230 sisusb_bulkout_msg(struct sisusb_usb_data *sisusb, int index, unsigned int pipe, void *data,
231 int len, int *actual_length, int timeout, unsigned int tflags)
232 {
233 struct urb *urb = sisusb->sisurbout[index];
234 int retval, byteswritten = 0;
235
236 /* Set up URB */
237 urb->transfer_flags = 0;
238
239 usb_fill_bulk_urb(urb, sisusb->sisusb_dev, pipe, data, len,
240 sisusb_bulk_completeout, &sisusb->urbout_context[index]);
241
242 urb->transfer_flags |= tflags;
243 urb->actual_length = 0;
244
245 /* Set up context */
246 sisusb->urbout_context[index].actual_length = (timeout) ?
247 NULL : actual_length;
248
249 /* Declare this urb/buffer in use */
250 sisusb->urbstatus[index] |= SU_URB_BUSY;
251
252 /* Submit URB */
253 retval = usb_submit_urb(urb, GFP_ATOMIC);
254
255 /* If OK, and if timeout > 0, wait for completion */
256 if ((retval == 0) && timeout) {
257 wait_event_timeout(sisusb->wait_q,
258 (!(sisusb->urbstatus[index] & SU_URB_BUSY)),
259 timeout);
260 if (sisusb->urbstatus[index] & SU_URB_BUSY) {
261 /* URB timed out... kill it and report error */
262 usb_kill_urb(urb);
263 retval = -ETIMEDOUT;
264 } else {
265 /* Otherwise, report urb status */
266 retval = urb->status;
267 byteswritten = urb->actual_length;
268 }
269 }
270
271 if (actual_length)
272 *actual_length = byteswritten;
273
274 return retval;
275 }
276
277 /* 2. in-bulks */
278
279 /* completion callback */
280
281 static void
282 sisusb_bulk_completein(struct urb *urb)
283 {
284 struct sisusb_usb_data *sisusb = urb->context;
285
286 if (!sisusb || !sisusb->sisusb_dev || !sisusb->present)
287 return;
288
289 sisusb->completein = 1;
290 wake_up(&sisusb->wait_q);
291 }
292
293 static int
294 sisusb_bulkin_msg(struct sisusb_usb_data *sisusb, unsigned int pipe, void *data,
295 int len, int *actual_length, int timeout, unsigned int tflags)
296 {
297 struct urb *urb = sisusb->sisurbin;
298 int retval, readbytes = 0;
299
300 urb->transfer_flags = 0;
301
302 usb_fill_bulk_urb(urb, sisusb->sisusb_dev, pipe, data, len,
303 sisusb_bulk_completein, sisusb);
304
305 urb->transfer_flags |= tflags;
306 urb->actual_length = 0;
307
308 sisusb->completein = 0;
309 retval = usb_submit_urb(urb, GFP_ATOMIC);
310 if (retval == 0) {
311 wait_event_timeout(sisusb->wait_q, sisusb->completein, timeout);
312 if (!sisusb->completein) {
313 /* URB timed out... kill it and report error */
314 usb_kill_urb(urb);
315 retval = -ETIMEDOUT;
316 } else {
317 /* URB completed within timeout */
318 retval = urb->status;
319 readbytes = urb->actual_length;
320 }
321 }
322
323 if (actual_length)
324 *actual_length = readbytes;
325
326 return retval;
327 }
328
329
330 /* Level 1: */
331
332 /* Send a bulk message of variable size
333 *
334 * To copy the data from userspace, give pointer to "userbuffer",
335 * to copy from (non-DMA) kernel memory, give "kernbuffer". If
336 * both of these are NULL, it is assumed, that the transfer
337 * buffer "sisusb->obuf[index]" is set up with the data to send.
338 * Index is ignored if either kernbuffer or userbuffer is set.
339 * If async is nonzero, URBs will be sent without waiting for
340 * completion of the previous URB.
341 *
342 * (return 0 on success)
343 */
344
345 static int sisusb_send_bulk_msg(struct sisusb_usb_data *sisusb, int ep, int len,
346 char *kernbuffer, const char __user *userbuffer, int index,
347 ssize_t *bytes_written, unsigned int tflags, int async)
348 {
349 int result = 0, retry, count = len;
350 int passsize, thispass, transferred_len = 0;
351 int fromuser = (userbuffer != NULL) ? 1 : 0;
352 int fromkern = (kernbuffer != NULL) ? 1 : 0;
353 unsigned int pipe;
354 char *buffer;
355
356 (*bytes_written) = 0;
357
358 /* Sanity check */
359 if (!sisusb || !sisusb->present || !sisusb->sisusb_dev)
360 return -ENODEV;
361
362 /* If we copy data from kernel or userspace, force the
363 * allocation of a buffer/urb. If we have the data in
364 * the transfer buffer[index] already, reuse the buffer/URB
365 * if the length is > buffer size. (So, transmitting
366 * large data amounts directly from the transfer buffer
367 * treats the buffer as a ring buffer. However, we need
368 * to sync in this case.)
369 */
370 if (fromuser || fromkern)
371 index = -1;
372 else if (len > sisusb->obufsize)
373 async = 0;
374
375 pipe = usb_sndbulkpipe(sisusb->sisusb_dev, ep);
376
377 do {
378 passsize = thispass = (sisusb->obufsize < count) ?
379 sisusb->obufsize : count;
380
381 if (index < 0)
382 index = sisusb_get_free_outbuf(sisusb);
383
384 if (index < 0)
385 return -EIO;
386
387 buffer = sisusb->obuf[index];
388
389 if (fromuser) {
390
391 if (copy_from_user(buffer, userbuffer, passsize))
392 return -EFAULT;
393
394 userbuffer += passsize;
395
396 } else if (fromkern) {
397
398 memcpy(buffer, kernbuffer, passsize);
399 kernbuffer += passsize;
400
401 }
402
403 retry = 5;
404 while (thispass) {
405
406 if (!sisusb->sisusb_dev)
407 return -ENODEV;
408
409 result = sisusb_bulkout_msg(sisusb,
410 index,
411 pipe,
412 buffer,
413 thispass,
414 &transferred_len,
415 async ? 0 : 5 * HZ,
416 tflags);
417
418 if (result == -ETIMEDOUT) {
419
420 /* Will not happen if async */
421 if (!retry--)
422 return -ETIME;
423
424 continue;
425 }
426
427 if ((result == 0) && !async && transferred_len) {
428
429 thispass -= transferred_len;
430 buffer += transferred_len;
431
432 } else
433 break;
434 }
435
436 if (result)
437 return result;
438
439 (*bytes_written) += passsize;
440 count -= passsize;
441
442 /* Force new allocation in next iteration */
443 if (fromuser || fromkern)
444 index = -1;
445
446 } while (count > 0);
447
448 if (async) {
449 #ifdef SISUSB_DONTSYNC
450 (*bytes_written) = len;
451 /* Some URBs/buffers might be busy */
452 #else
453 sisusb_wait_all_out_complete(sisusb);
454 (*bytes_written) = transferred_len;
455 /* All URBs and all buffers are available */
456 #endif
457 }
458
459 return ((*bytes_written) == len) ? 0 : -EIO;
460 }
461
462 /* Receive a bulk message of variable size
463 *
464 * To copy the data to userspace, give pointer to "userbuffer",
465 * to copy to kernel memory, give "kernbuffer". One of them
466 * MUST be set. (There is no technique for letting the caller
467 * read directly from the ibuf.)
468 *
469 */
470
471 static int sisusb_recv_bulk_msg(struct sisusb_usb_data *sisusb, int ep, int len,
472 void *kernbuffer, char __user *userbuffer, ssize_t *bytes_read,
473 unsigned int tflags)
474 {
475 int result = 0, retry, count = len;
476 int bufsize, thispass, transferred_len;
477 unsigned int pipe;
478 char *buffer;
479
480 (*bytes_read) = 0;
481
482 /* Sanity check */
483 if (!sisusb || !sisusb->present || !sisusb->sisusb_dev)
484 return -ENODEV;
485
486 pipe = usb_rcvbulkpipe(sisusb->sisusb_dev, ep);
487 buffer = sisusb->ibuf;
488 bufsize = sisusb->ibufsize;
489
490 retry = 5;
491
492 #ifdef SISUSB_DONTSYNC
493 if (!(sisusb_wait_all_out_complete(sisusb)))
494 return -EIO;
495 #endif
496
497 while (count > 0) {
498
499 if (!sisusb->sisusb_dev)
500 return -ENODEV;
501
502 thispass = (bufsize < count) ? bufsize : count;
503
504 result = sisusb_bulkin_msg(sisusb,
505 pipe,
506 buffer,
507 thispass,
508 &transferred_len,
509 5 * HZ,
510 tflags);
511
512 if (transferred_len)
513 thispass = transferred_len;
514
515 else if (result == -ETIMEDOUT) {
516
517 if (!retry--)
518 return -ETIME;
519
520 continue;
521
522 } else
523 return -EIO;
524
525
526 if (thispass) {
527
528 (*bytes_read) += thispass;
529 count -= thispass;
530
531 if (userbuffer) {
532
533 if (copy_to_user(userbuffer, buffer, thispass))
534 return -EFAULT;
535
536 userbuffer += thispass;
537
538 } else {
539
540 memcpy(kernbuffer, buffer, thispass);
541 kernbuffer += thispass;
542
543 }
544
545 }
546
547 }
548
549 return ((*bytes_read) == len) ? 0 : -EIO;
550 }
551
552 static int sisusb_send_packet(struct sisusb_usb_data *sisusb, int len,
553 struct sisusb_packet *packet)
554 {
555 int ret;
556 ssize_t bytes_transferred = 0;
557 __le32 tmp;
558
559 if (len == 6)
560 packet->data = 0;
561
562 #ifdef SISUSB_DONTSYNC
563 if (!(sisusb_wait_all_out_complete(sisusb)))
564 return 1;
565 #endif
566
567 /* Eventually correct endianness */
568 SISUSB_CORRECT_ENDIANNESS_PACKET(packet);
569
570 /* 1. send the packet */
571 ret = sisusb_send_bulk_msg(sisusb, SISUSB_EP_GFX_OUT, len,
572 (char *)packet, NULL, 0, &bytes_transferred, 0, 0);
573
574 if ((ret == 0) && (len == 6)) {
575
576 /* 2. if packet len == 6, it means we read, so wait for 32bit
577 * return value and write it to packet->data
578 */
579 ret = sisusb_recv_bulk_msg(sisusb, SISUSB_EP_GFX_IN, 4,
580 (char *)&tmp, NULL, &bytes_transferred, 0);
581
582 packet->data = le32_to_cpu(tmp);
583 }
584
585 return ret;
586 }
587
588 static int sisusb_send_bridge_packet(struct sisusb_usb_data *sisusb, int len,
589 struct sisusb_packet *packet,
590 unsigned int tflags)
591 {
592 int ret;
593 ssize_t bytes_transferred = 0;
594 __le32 tmp;
595
596 if (len == 6)
597 packet->data = 0;
598
599 #ifdef SISUSB_DONTSYNC
600 if (!(sisusb_wait_all_out_complete(sisusb)))
601 return 1;
602 #endif
603
604 /* Eventually correct endianness */
605 SISUSB_CORRECT_ENDIANNESS_PACKET(packet);
606
607 /* 1. send the packet */
608 ret = sisusb_send_bulk_msg(sisusb, SISUSB_EP_BRIDGE_OUT, len,
609 (char *)packet, NULL, 0, &bytes_transferred, tflags, 0);
610
611 if ((ret == 0) && (len == 6)) {
612
613 /* 2. if packet len == 6, it means we read, so wait for 32bit
614 * return value and write it to packet->data
615 */
616 ret = sisusb_recv_bulk_msg(sisusb, SISUSB_EP_BRIDGE_IN, 4,
617 (char *)&tmp, NULL, &bytes_transferred, 0);
618
619 packet->data = le32_to_cpu(tmp);
620 }
621
622 return ret;
623 }
624
625 /* access video memory and mmio (return 0 on success) */
626
627 /* Low level */
628
629 /* The following routines assume being used to transfer byte, word,
630 * long etc.
631 * This means that
632 * - the write routines expect "data" in machine endianness format.
633 * The data will be converted to leXX in sisusb_xxx_packet.
634 * - the read routines can expect read data in machine-endianess.
635 */
636
637 static int sisusb_write_memio_byte(struct sisusb_usb_data *sisusb, int type,
638 u32 addr, u8 data)
639 {
640 struct sisusb_packet packet;
641 int ret;
642
643 packet.header = (1 << (addr & 3)) | (type << 6);
644 packet.address = addr & ~3;
645 packet.data = data << ((addr & 3) << 3);
646 ret = sisusb_send_packet(sisusb, 10, &packet);
647 return ret;
648 }
649
650 static int sisusb_write_memio_word(struct sisusb_usb_data *sisusb, int type,
651 u32 addr, u16 data)
652 {
653 struct sisusb_packet packet;
654 int ret = 0;
655
656 packet.address = addr & ~3;
657
658 switch (addr & 3) {
659 case 0:
660 packet.header = (type << 6) | 0x0003;
661 packet.data = (u32)data;
662 ret = sisusb_send_packet(sisusb, 10, &packet);
663 break;
664 case 1:
665 packet.header = (type << 6) | 0x0006;
666 packet.data = (u32)data << 8;
667 ret = sisusb_send_packet(sisusb, 10, &packet);
668 break;
669 case 2:
670 packet.header = (type << 6) | 0x000c;
671 packet.data = (u32)data << 16;
672 ret = sisusb_send_packet(sisusb, 10, &packet);
673 break;
674 case 3:
675 packet.header = (type << 6) | 0x0008;
676 packet.data = (u32)data << 24;
677 ret = sisusb_send_packet(sisusb, 10, &packet);
678 packet.header = (type << 6) | 0x0001;
679 packet.address = (addr & ~3) + 4;
680 packet.data = (u32)data >> 8;
681 ret |= sisusb_send_packet(sisusb, 10, &packet);
682 }
683
684 return ret;
685 }
686
687 static int sisusb_write_memio_24bit(struct sisusb_usb_data *sisusb, int type,
688 u32 addr, u32 data)
689 {
690 struct sisusb_packet packet;
691 int ret = 0;
692
693 packet.address = addr & ~3;
694
695 switch (addr & 3) {
696 case 0:
697 packet.header = (type << 6) | 0x0007;
698 packet.data = data & 0x00ffffff;
699 ret = sisusb_send_packet(sisusb, 10, &packet);
700 break;
701 case 1:
702 packet.header = (type << 6) | 0x000e;
703 packet.data = data << 8;
704 ret = sisusb_send_packet(sisusb, 10, &packet);
705 break;
706 case 2:
707 packet.header = (type << 6) | 0x000c;
708 packet.data = data << 16;
709 ret = sisusb_send_packet(sisusb, 10, &packet);
710 packet.header = (type << 6) | 0x0001;
711 packet.address = (addr & ~3) + 4;
712 packet.data = (data >> 16) & 0x00ff;
713 ret |= sisusb_send_packet(sisusb, 10, &packet);
714 break;
715 case 3:
716 packet.header = (type << 6) | 0x0008;
717 packet.data = data << 24;
718 ret = sisusb_send_packet(sisusb, 10, &packet);
719 packet.header = (type << 6) | 0x0003;
720 packet.address = (addr & ~3) + 4;
721 packet.data = (data >> 8) & 0xffff;
722 ret |= sisusb_send_packet(sisusb, 10, &packet);
723 }
724
725 return ret;
726 }
727
728 static int sisusb_write_memio_long(struct sisusb_usb_data *sisusb, int type,
729 u32 addr, u32 data)
730 {
731 struct sisusb_packet packet;
732 int ret = 0;
733
734 packet.address = addr & ~3;
735
736 switch (addr & 3) {
737 case 0:
738 packet.header = (type << 6) | 0x000f;
739 packet.data = data;
740 ret = sisusb_send_packet(sisusb, 10, &packet);
741 break;
742 case 1:
743 packet.header = (type << 6) | 0x000e;
744 packet.data = data << 8;
745 ret = sisusb_send_packet(sisusb, 10, &packet);
746 packet.header = (type << 6) | 0x0001;
747 packet.address = (addr & ~3) + 4;
748 packet.data = data >> 24;
749 ret |= sisusb_send_packet(sisusb, 10, &packet);
750 break;
751 case 2:
752 packet.header = (type << 6) | 0x000c;
753 packet.data = data << 16;
754 ret = sisusb_send_packet(sisusb, 10, &packet);
755 packet.header = (type << 6) | 0x0003;
756 packet.address = (addr & ~3) + 4;
757 packet.data = data >> 16;
758 ret |= sisusb_send_packet(sisusb, 10, &packet);
759 break;
760 case 3:
761 packet.header = (type << 6) | 0x0008;
762 packet.data = data << 24;
763 ret = sisusb_send_packet(sisusb, 10, &packet);
764 packet.header = (type << 6) | 0x0007;
765 packet.address = (addr & ~3) + 4;
766 packet.data = data >> 8;
767 ret |= sisusb_send_packet(sisusb, 10, &packet);
768 }
769
770 return ret;
771 }
772
773 /* The xxx_bulk routines copy a buffer of variable size. They treat the
774 * buffer as chars, therefore lsb/msb has to be corrected if using the
775 * byte/word/long/etc routines for speed-up
776 *
777 * If data is from userland, set "userbuffer" (and clear "kernbuffer"),
778 * if data is in kernel space, set "kernbuffer" (and clear "userbuffer");
779 * if neither "kernbuffer" nor "userbuffer" are given, it is assumed
780 * that the data already is in the transfer buffer "sisusb->obuf[index]".
781 */
782
783 static int sisusb_write_mem_bulk(struct sisusb_usb_data *sisusb, u32 addr,
784 char *kernbuffer, int length,
785 const char __user *userbuffer, int index,
786 ssize_t *bytes_written)
787 {
788 struct sisusb_packet packet;
789 int ret = 0;
790 static int msgcount = 0;
791 u8 swap8, fromkern = kernbuffer ? 1 : 0;
792 u16 swap16;
793 u32 swap32, flag = (length >> 28) & 1;
794 char buf[4];
795
796 /* if neither kernbuffer not userbuffer are given, assume
797 * data in obuf
798 */
799 if (!fromkern && !userbuffer)
800 kernbuffer = sisusb->obuf[index];
801
802 (*bytes_written = 0);
803
804 length &= 0x00ffffff;
805
806 while (length) {
807
808 switch (length) {
809
810 case 1:
811 if (userbuffer) {
812 if (get_user(swap8, (u8 __user *)userbuffer))
813 return -EFAULT;
814 } else
815 swap8 = kernbuffer[0];
816
817 ret = sisusb_write_memio_byte(sisusb,
818 SISUSB_TYPE_MEM,
819 addr, swap8);
820
821 if (!ret)
822 (*bytes_written)++;
823
824 return ret;
825
826 case 2:
827 if (userbuffer) {
828 if (get_user(swap16, (u16 __user *)userbuffer))
829 return -EFAULT;
830 } else
831 swap16 = *((u16 *)kernbuffer);
832
833 ret = sisusb_write_memio_word(sisusb,
834 SISUSB_TYPE_MEM,
835 addr,
836 swap16);
837
838 if (!ret)
839 (*bytes_written) += 2;
840
841 return ret;
842
843 case 3:
844 if (userbuffer) {
845 if (copy_from_user(&buf, userbuffer, 3))
846 return -EFAULT;
847 #ifdef __BIG_ENDIAN
848 swap32 = (buf[0] << 16) |
849 (buf[1] << 8) |
850 buf[2];
851 #else
852 swap32 = (buf[2] << 16) |
853 (buf[1] << 8) |
854 buf[0];
855 #endif
856 } else
857 #ifdef __BIG_ENDIAN
858 swap32 = (kernbuffer[0] << 16) |
859 (kernbuffer[1] << 8) |
860 kernbuffer[2];
861 #else
862 swap32 = (kernbuffer[2] << 16) |
863 (kernbuffer[1] << 8) |
864 kernbuffer[0];
865 #endif
866
867 ret = sisusb_write_memio_24bit(sisusb,
868 SISUSB_TYPE_MEM,
869 addr,
870 swap32);
871
872 if (!ret)
873 (*bytes_written) += 3;
874
875 return ret;
876
877 case 4:
878 if (userbuffer) {
879 if (get_user(swap32, (u32 __user *)userbuffer))
880 return -EFAULT;
881 } else
882 swap32 = *((u32 *)kernbuffer);
883
884 ret = sisusb_write_memio_long(sisusb,
885 SISUSB_TYPE_MEM,
886 addr,
887 swap32);
888 if (!ret)
889 (*bytes_written) += 4;
890
891 return ret;
892
893 default:
894 if ((length & ~3) > 0x10000) {
895
896 packet.header = 0x001f;
897 packet.address = 0x000001d4;
898 packet.data = addr;
899 ret = sisusb_send_bridge_packet(sisusb, 10,
900 &packet, 0);
901 packet.header = 0x001f;
902 packet.address = 0x000001d0;
903 packet.data = (length & ~3);
904 ret |= sisusb_send_bridge_packet(sisusb, 10,
905 &packet, 0);
906 packet.header = 0x001f;
907 packet.address = 0x000001c0;
908 packet.data = flag | 0x16;
909 ret |= sisusb_send_bridge_packet(sisusb, 10,
910 &packet, 0);
911 if (userbuffer) {
912 ret |= sisusb_send_bulk_msg(sisusb,
913 SISUSB_EP_GFX_LBULK_OUT,
914 (length & ~3),
915 NULL, userbuffer, 0,
916 bytes_written, 0, 1);
917 userbuffer += (*bytes_written);
918 } else if (fromkern) {
919 ret |= sisusb_send_bulk_msg(sisusb,
920 SISUSB_EP_GFX_LBULK_OUT,
921 (length & ~3),
922 kernbuffer, NULL, 0,
923 bytes_written, 0, 1);
924 kernbuffer += (*bytes_written);
925 } else {
926 ret |= sisusb_send_bulk_msg(sisusb,
927 SISUSB_EP_GFX_LBULK_OUT,
928 (length & ~3),
929 NULL, NULL, index,
930 bytes_written, 0, 1);
931 kernbuffer += ((*bytes_written) &
932 (sisusb->obufsize-1));
933 }
934
935 } else {
936
937 packet.header = 0x001f;
938 packet.address = 0x00000194;
939 packet.data = addr;
940 ret = sisusb_send_bridge_packet(sisusb, 10,
941 &packet, 0);
942 packet.header = 0x001f;
943 packet.address = 0x00000190;
944 packet.data = (length & ~3);
945 ret |= sisusb_send_bridge_packet(sisusb, 10,
946 &packet, 0);
947 if (sisusb->flagb0 != 0x16) {
948 packet.header = 0x001f;
949 packet.address = 0x00000180;
950 packet.data = flag | 0x16;
951 ret |= sisusb_send_bridge_packet(sisusb, 10,
952 &packet, 0);
953 sisusb->flagb0 = 0x16;
954 }
955 if (userbuffer) {
956 ret |= sisusb_send_bulk_msg(sisusb,
957 SISUSB_EP_GFX_BULK_OUT,
958 (length & ~3),
959 NULL, userbuffer, 0,
960 bytes_written, 0, 1);
961 userbuffer += (*bytes_written);
962 } else if (fromkern) {
963 ret |= sisusb_send_bulk_msg(sisusb,
964 SISUSB_EP_GFX_BULK_OUT,
965 (length & ~3),
966 kernbuffer, NULL, 0,
967 bytes_written, 0, 1);
968 kernbuffer += (*bytes_written);
969 } else {
970 ret |= sisusb_send_bulk_msg(sisusb,
971 SISUSB_EP_GFX_BULK_OUT,
972 (length & ~3),
973 NULL, NULL, index,
974 bytes_written, 0, 1);
975 kernbuffer += ((*bytes_written) &
976 (sisusb->obufsize-1));
977 }
978 }
979 if (ret) {
980 msgcount++;
981 if (msgcount < 500)
982 dev_err(&sisusb->sisusb_dev->dev, "Wrote %zd of %d bytes, error %d\n",
983 *bytes_written, length, ret);
984 else if (msgcount == 500)
985 dev_err(&sisusb->sisusb_dev->dev, "Too many errors, logging stopped\n");
986 }
987 addr += (*bytes_written);
988 length -= (*bytes_written);
989 }
990
991 if (ret)
992 break;
993
994 }
995
996 return ret ? -EIO : 0;
997 }
998
999 /* Remember: Read data in packet is in machine-endianess! So for
1000 * byte, word, 24bit, long no endian correction is necessary.
1001 */
1002
1003 static int sisusb_read_memio_byte(struct sisusb_usb_data *sisusb, int type,
1004 u32 addr, u8 *data)
1005 {
1006 struct sisusb_packet packet;
1007 int ret;
1008
1009 CLEARPACKET(&packet);
1010 packet.header = (1 << (addr & 3)) | (type << 6);
1011 packet.address = addr & ~3;
1012 ret = sisusb_send_packet(sisusb, 6, &packet);
1013 *data = (u8)(packet.data >> ((addr & 3) << 3));
1014 return ret;
1015 }
1016
1017 static int sisusb_read_memio_word(struct sisusb_usb_data *sisusb, int type,
1018 u32 addr, u16 *data)
1019 {
1020 struct sisusb_packet packet;
1021 int ret = 0;
1022
1023 CLEARPACKET(&packet);
1024
1025 packet.address = addr & ~3;
1026
1027 switch (addr & 3) {
1028 case 0:
1029 packet.header = (type << 6) | 0x0003;
1030 ret = sisusb_send_packet(sisusb, 6, &packet);
1031 *data = (u16)(packet.data);
1032 break;
1033 case 1:
1034 packet.header = (type << 6) | 0x0006;
1035 ret = sisusb_send_packet(sisusb, 6, &packet);
1036 *data = (u16)(packet.data >> 8);
1037 break;
1038 case 2:
1039 packet.header = (type << 6) | 0x000c;
1040 ret = sisusb_send_packet(sisusb, 6, &packet);
1041 *data = (u16)(packet.data >> 16);
1042 break;
1043 case 3:
1044 packet.header = (type << 6) | 0x0008;
1045 ret = sisusb_send_packet(sisusb, 6, &packet);
1046 *data = (u16)(packet.data >> 24);
1047 packet.header = (type << 6) | 0x0001;
1048 packet.address = (addr & ~3) + 4;
1049 ret |= sisusb_send_packet(sisusb, 6, &packet);
1050 *data |= (u16)(packet.data << 8);
1051 }
1052
1053 return ret;
1054 }
1055
1056 static int sisusb_read_memio_24bit(struct sisusb_usb_data *sisusb, int type,
1057 u32 addr, u32 *data)
1058 {
1059 struct sisusb_packet packet;
1060 int ret = 0;
1061
1062 packet.address = addr & ~3;
1063
1064 switch (addr & 3) {
1065 case 0:
1066 packet.header = (type << 6) | 0x0007;
1067 ret = sisusb_send_packet(sisusb, 6, &packet);
1068 *data = packet.data & 0x00ffffff;
1069 break;
1070 case 1:
1071 packet.header = (type << 6) | 0x000e;
1072 ret = sisusb_send_packet(sisusb, 6, &packet);
1073 *data = packet.data >> 8;
1074 break;
1075 case 2:
1076 packet.header = (type << 6) | 0x000c;
1077 ret = sisusb_send_packet(sisusb, 6, &packet);
1078 *data = packet.data >> 16;
1079 packet.header = (type << 6) | 0x0001;
1080 packet.address = (addr & ~3) + 4;
1081 ret |= sisusb_send_packet(sisusb, 6, &packet);
1082 *data |= ((packet.data & 0xff) << 16);
1083 break;
1084 case 3:
1085 packet.header = (type << 6) | 0x0008;
1086 ret = sisusb_send_packet(sisusb, 6, &packet);
1087 *data = packet.data >> 24;
1088 packet.header = (type << 6) | 0x0003;
1089 packet.address = (addr & ~3) + 4;
1090 ret |= sisusb_send_packet(sisusb, 6, &packet);
1091 *data |= ((packet.data & 0xffff) << 8);
1092 }
1093
1094 return ret;
1095 }
1096
1097 static int sisusb_read_memio_long(struct sisusb_usb_data *sisusb, int type,
1098 u32 addr, u32 *data)
1099 {
1100 struct sisusb_packet packet;
1101 int ret = 0;
1102
1103 packet.address = addr & ~3;
1104
1105 switch (addr & 3) {
1106 case 0:
1107 packet.header = (type << 6) | 0x000f;
1108 ret = sisusb_send_packet(sisusb, 6, &packet);
1109 *data = packet.data;
1110 break;
1111 case 1:
1112 packet.header = (type << 6) | 0x000e;
1113 ret = sisusb_send_packet(sisusb, 6, &packet);
1114 *data = packet.data >> 8;
1115 packet.header = (type << 6) | 0x0001;
1116 packet.address = (addr & ~3) + 4;
1117 ret |= sisusb_send_packet(sisusb, 6, &packet);
1118 *data |= (packet.data << 24);
1119 break;
1120 case 2:
1121 packet.header = (type << 6) | 0x000c;
1122 ret = sisusb_send_packet(sisusb, 6, &packet);
1123 *data = packet.data >> 16;
1124 packet.header = (type << 6) | 0x0003;
1125 packet.address = (addr & ~3) + 4;
1126 ret |= sisusb_send_packet(sisusb, 6, &packet);
1127 *data |= (packet.data << 16);
1128 break;
1129 case 3:
1130 packet.header = (type << 6) | 0x0008;
1131 ret = sisusb_send_packet(sisusb, 6, &packet);
1132 *data = packet.data >> 24;
1133 packet.header = (type << 6) | 0x0007;
1134 packet.address = (addr & ~3) + 4;
1135 ret |= sisusb_send_packet(sisusb, 6, &packet);
1136 *data |= (packet.data << 8);
1137 }
1138
1139 return ret;
1140 }
1141
1142 static int sisusb_read_mem_bulk(struct sisusb_usb_data *sisusb, u32 addr,
1143 char *kernbuffer, int length,
1144 char __user *userbuffer, ssize_t *bytes_read)
1145 {
1146 int ret = 0;
1147 char buf[4];
1148 u16 swap16;
1149 u32 swap32;
1150
1151 (*bytes_read = 0);
1152
1153 length &= 0x00ffffff;
1154
1155 while (length) {
1156
1157 switch (length) {
1158
1159 case 1:
1160
1161 ret |= sisusb_read_memio_byte(sisusb, SISUSB_TYPE_MEM,
1162 addr, &buf[0]);
1163 if (!ret) {
1164 (*bytes_read)++;
1165 if (userbuffer) {
1166 if (put_user(buf[0],
1167 (u8 __user *)userbuffer)) {
1168 return -EFAULT;
1169 }
1170 } else {
1171 kernbuffer[0] = buf[0];
1172 }
1173 }
1174 return ret;
1175
1176 case 2:
1177 ret |= sisusb_read_memio_word(sisusb, SISUSB_TYPE_MEM,
1178 addr, &swap16);
1179 if (!ret) {
1180 (*bytes_read) += 2;
1181 if (userbuffer) {
1182 if (put_user(swap16,
1183 (u16 __user *)userbuffer))
1184 return -EFAULT;
1185 } else {
1186 *((u16 *)kernbuffer) = swap16;
1187 }
1188 }
1189 return ret;
1190
1191 case 3:
1192 ret |= sisusb_read_memio_24bit(sisusb, SISUSB_TYPE_MEM,
1193 addr, &swap32);
1194 if (!ret) {
1195 (*bytes_read) += 3;
1196 #ifdef __BIG_ENDIAN
1197 buf[0] = (swap32 >> 16) & 0xff;
1198 buf[1] = (swap32 >> 8) & 0xff;
1199 buf[2] = swap32 & 0xff;
1200 #else
1201 buf[2] = (swap32 >> 16) & 0xff;
1202 buf[1] = (swap32 >> 8) & 0xff;
1203 buf[0] = swap32 & 0xff;
1204 #endif
1205 if (userbuffer) {
1206 if (copy_to_user(userbuffer, &buf[0], 3))
1207 return -EFAULT;
1208 } else {
1209 kernbuffer[0] = buf[0];
1210 kernbuffer[1] = buf[1];
1211 kernbuffer[2] = buf[2];
1212 }
1213 }
1214 return ret;
1215
1216 default:
1217 ret |= sisusb_read_memio_long(sisusb, SISUSB_TYPE_MEM,
1218 addr, &swap32);
1219 if (!ret) {
1220 (*bytes_read) += 4;
1221 if (userbuffer) {
1222 if (put_user(swap32,
1223 (u32 __user *)userbuffer))
1224 return -EFAULT;
1225
1226 userbuffer += 4;
1227 } else {
1228 *((u32 *)kernbuffer) = swap32;
1229 kernbuffer += 4;
1230 }
1231 addr += 4;
1232 length -= 4;
1233 }
1234 }
1235
1236 if (ret)
1237 break;
1238 }
1239
1240 return ret;
1241 }
1242
1243 /* High level: Gfx (indexed) register access */
1244
1245 #ifdef INCL_SISUSB_CON
1246 int
1247 sisusb_setreg(struct sisusb_usb_data *sisusb, int port, u8 data)
1248 {
1249 return sisusb_write_memio_byte(sisusb, SISUSB_TYPE_IO, port, data);
1250 }
1251
1252 int
1253 sisusb_getreg(struct sisusb_usb_data *sisusb, int port, u8 *data)
1254 {
1255 return sisusb_read_memio_byte(sisusb, SISUSB_TYPE_IO, port, data);
1256 }
1257 #endif
1258
1259 int
1260 sisusb_setidxreg(struct sisusb_usb_data *sisusb, int port, u8 index, u8 data)
1261 {
1262 int ret;
1263 ret = sisusb_write_memio_byte(sisusb, SISUSB_TYPE_IO, port, index);
1264 ret |= sisusb_write_memio_byte(sisusb, SISUSB_TYPE_IO, port + 1, data);
1265 return ret;
1266 }
1267
1268 int
1269 sisusb_getidxreg(struct sisusb_usb_data *sisusb, int port, u8 index, u8 *data)
1270 {
1271 int ret;
1272 ret = sisusb_write_memio_byte(sisusb, SISUSB_TYPE_IO, port, index);
1273 ret |= sisusb_read_memio_byte(sisusb, SISUSB_TYPE_IO, port + 1, data);
1274 return ret;
1275 }
1276
1277 int
1278 sisusb_setidxregandor(struct sisusb_usb_data *sisusb, int port, u8 idx,
1279 u8 myand, u8 myor)
1280 {
1281 int ret;
1282 u8 tmp;
1283
1284 ret = sisusb_write_memio_byte(sisusb, SISUSB_TYPE_IO, port, idx);
1285 ret |= sisusb_read_memio_byte(sisusb, SISUSB_TYPE_IO, port + 1, &tmp);
1286 tmp &= myand;
1287 tmp |= myor;
1288 ret |= sisusb_write_memio_byte(sisusb, SISUSB_TYPE_IO, port + 1, tmp);
1289 return ret;
1290 }
1291
1292 static int
1293 sisusb_setidxregmask(struct sisusb_usb_data *sisusb, int port, u8 idx,
1294 u8 data, u8 mask)
1295 {
1296 int ret;
1297 u8 tmp;
1298 ret = sisusb_write_memio_byte(sisusb, SISUSB_TYPE_IO, port, idx);
1299 ret |= sisusb_read_memio_byte(sisusb, SISUSB_TYPE_IO, port + 1, &tmp);
1300 tmp &= ~(mask);
1301 tmp |= (data & mask);
1302 ret |= sisusb_write_memio_byte(sisusb, SISUSB_TYPE_IO, port + 1, tmp);
1303 return ret;
1304 }
1305
1306 int
1307 sisusb_setidxregor(struct sisusb_usb_data *sisusb, int port, u8 index, u8 myor)
1308 {
1309 return(sisusb_setidxregandor(sisusb, port, index, 0xff, myor));
1310 }
1311
1312 int
1313 sisusb_setidxregand(struct sisusb_usb_data *sisusb, int port, u8 idx, u8 myand)
1314 {
1315 return(sisusb_setidxregandor(sisusb, port, idx, myand, 0x00));
1316 }
1317
1318 /* Write/read video ram */
1319
1320 #ifdef INCL_SISUSB_CON
1321 int
1322 sisusb_writeb(struct sisusb_usb_data *sisusb, u32 adr, u8 data)
1323 {
1324 return(sisusb_write_memio_byte(sisusb, SISUSB_TYPE_MEM, adr, data));
1325 }
1326
1327 int
1328 sisusb_readb(struct sisusb_usb_data *sisusb, u32 adr, u8 *data)
1329 {
1330 return(sisusb_read_memio_byte(sisusb, SISUSB_TYPE_MEM, adr, data));
1331 }
1332
1333 int
1334 sisusb_copy_memory(struct sisusb_usb_data *sisusb, char *src,
1335 u32 dest, int length, size_t *bytes_written)
1336 {
1337 return(sisusb_write_mem_bulk(sisusb, dest, src, length, NULL, 0, bytes_written));
1338 }
1339
1340 #ifdef SISUSBENDIANTEST
1341 int
1342 sisusb_read_memory(struct sisusb_usb_data *sisusb, char *dest,
1343 u32 src, int length, size_t *bytes_written)
1344 {
1345 return(sisusb_read_mem_bulk(sisusb, src, dest, length, NULL, bytes_written));
1346 }
1347 #endif
1348 #endif
1349
1350 #ifdef SISUSBENDIANTEST
1351 static void
1352 sisusb_testreadwrite(struct sisusb_usb_data *sisusb)
1353 {
1354 static char srcbuffer[] = { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77 };
1355 char destbuffer[10];
1356 size_t dummy;
1357 int i,j;
1358
1359 sisusb_copy_memory(sisusb, srcbuffer, sisusb->vrambase, 7, &dummy);
1360
1361 for(i = 1; i <= 7; i++) {
1362 dev_dbg(&sisusb->sisusb_dev->dev, "sisusb: rwtest %d bytes\n", i);
1363 sisusb_read_memory(sisusb, destbuffer, sisusb->vrambase, i, &dummy);
1364 for(j = 0; j < i; j++) {
1365 dev_dbg(&sisusb->sisusb_dev->dev, "rwtest read[%d] = %x\n", j, destbuffer[j]);
1366 }
1367 }
1368 }
1369 #endif
1370
1371 /* access pci config registers (reg numbers 0, 4, 8, etc) */
1372
1373 static int
1374 sisusb_write_pci_config(struct sisusb_usb_data *sisusb, int regnum, u32 data)
1375 {
1376 struct sisusb_packet packet;
1377 int ret;
1378
1379 packet.header = 0x008f;
1380 packet.address = regnum | 0x10000;
1381 packet.data = data;
1382 ret = sisusb_send_packet(sisusb, 10, &packet);
1383 return ret;
1384 }
1385
1386 static int
1387 sisusb_read_pci_config(struct sisusb_usb_data *sisusb, int regnum, u32 *data)
1388 {
1389 struct sisusb_packet packet;
1390 int ret;
1391
1392 packet.header = 0x008f;
1393 packet.address = (u32)regnum | 0x10000;
1394 ret = sisusb_send_packet(sisusb, 6, &packet);
1395 *data = packet.data;
1396 return ret;
1397 }
1398
1399 /* Clear video RAM */
1400
1401 static int
1402 sisusb_clear_vram(struct sisusb_usb_data *sisusb, u32 address, int length)
1403 {
1404 int ret, i;
1405 ssize_t j;
1406
1407 if (address < sisusb->vrambase)
1408 return 1;
1409
1410 if (address >= sisusb->vrambase + sisusb->vramsize)
1411 return 1;
1412
1413 if (address + length > sisusb->vrambase + sisusb->vramsize)
1414 length = sisusb->vrambase + sisusb->vramsize - address;
1415
1416 if (length <= 0)
1417 return 0;
1418
1419 /* allocate free buffer/urb and clear the buffer */
1420 if ((i = sisusb_alloc_outbuf(sisusb)) < 0)
1421 return -EBUSY;
1422
1423 memset(sisusb->obuf[i], 0, sisusb->obufsize);
1424
1425 /* We can write a length > buffer size here. The buffer
1426 * data will simply be re-used (like a ring-buffer).
1427 */
1428 ret = sisusb_write_mem_bulk(sisusb, address, NULL, length, NULL, i, &j);
1429
1430 /* Free the buffer/urb */
1431 sisusb_free_outbuf(sisusb, i);
1432
1433 return ret;
1434 }
1435
1436 /* Initialize the graphics core (return 0 on success)
1437 * This resets the graphics hardware and puts it into
1438 * a defined mode (640x480@60Hz)
1439 */
1440
1441 #define GETREG(r,d) sisusb_read_memio_byte(sisusb, SISUSB_TYPE_IO, r, d)
1442 #define SETREG(r,d) sisusb_write_memio_byte(sisusb, SISUSB_TYPE_IO, r, d)
1443 #define SETIREG(r,i,d) sisusb_setidxreg(sisusb, r, i, d)
1444 #define GETIREG(r,i,d) sisusb_getidxreg(sisusb, r, i, d)
1445 #define SETIREGOR(r,i,o) sisusb_setidxregor(sisusb, r, i, o)
1446 #define SETIREGAND(r,i,a) sisusb_setidxregand(sisusb, r, i, a)
1447 #define SETIREGANDOR(r,i,a,o) sisusb_setidxregandor(sisusb, r, i, a, o)
1448 #define READL(a,d) sisusb_read_memio_long(sisusb, SISUSB_TYPE_MEM, a, d)
1449 #define WRITEL(a,d) sisusb_write_memio_long(sisusb, SISUSB_TYPE_MEM, a, d)
1450 #define READB(a,d) sisusb_read_memio_byte(sisusb, SISUSB_TYPE_MEM, a, d)
1451 #define WRITEB(a,d) sisusb_write_memio_byte(sisusb, SISUSB_TYPE_MEM, a, d)
1452
1453 static int
1454 sisusb_triggersr16(struct sisusb_usb_data *sisusb, u8 ramtype)
1455 {
1456 int ret;
1457 u8 tmp8;
1458
1459 ret = GETIREG(SISSR, 0x16, &tmp8);
1460 if (ramtype <= 1) {
1461 tmp8 &= 0x3f;
1462 ret |= SETIREG(SISSR, 0x16, tmp8);
1463 tmp8 |= 0x80;
1464 ret |= SETIREG(SISSR, 0x16, tmp8);
1465 } else {
1466 tmp8 |= 0xc0;
1467 ret |= SETIREG(SISSR, 0x16, tmp8);
1468 tmp8 &= 0x0f;
1469 ret |= SETIREG(SISSR, 0x16, tmp8);
1470 tmp8 |= 0x80;
1471 ret |= SETIREG(SISSR, 0x16, tmp8);
1472 tmp8 &= 0x0f;
1473 ret |= SETIREG(SISSR, 0x16, tmp8);
1474 tmp8 |= 0xd0;
1475 ret |= SETIREG(SISSR, 0x16, tmp8);
1476 tmp8 &= 0x0f;
1477 ret |= SETIREG(SISSR, 0x16, tmp8);
1478 tmp8 |= 0xa0;
1479 ret |= SETIREG(SISSR, 0x16, tmp8);
1480 }
1481 return ret;
1482 }
1483
1484 static int
1485 sisusb_getbuswidth(struct sisusb_usb_data *sisusb, int *bw, int *chab)
1486 {
1487 int ret;
1488 u8 ramtype, done = 0;
1489 u32 t0, t1, t2, t3;
1490 u32 ramptr = SISUSB_PCI_MEMBASE;
1491
1492 ret = GETIREG(SISSR, 0x3a, &ramtype);
1493 ramtype &= 3;
1494
1495 ret |= SETIREG(SISSR, 0x13, 0x00);
1496
1497 if (ramtype <= 1) {
1498 ret |= SETIREG(SISSR, 0x14, 0x12);
1499 ret |= SETIREGAND(SISSR, 0x15, 0xef);
1500 } else {
1501 ret |= SETIREG(SISSR, 0x14, 0x02);
1502 }
1503
1504 ret |= sisusb_triggersr16(sisusb, ramtype);
1505 ret |= WRITEL(ramptr + 0, 0x01234567);
1506 ret |= WRITEL(ramptr + 4, 0x456789ab);
1507 ret |= WRITEL(ramptr + 8, 0x89abcdef);
1508 ret |= WRITEL(ramptr + 12, 0xcdef0123);
1509 ret |= WRITEL(ramptr + 16, 0x55555555);
1510 ret |= WRITEL(ramptr + 20, 0x55555555);
1511 ret |= WRITEL(ramptr + 24, 0xffffffff);
1512 ret |= WRITEL(ramptr + 28, 0xffffffff);
1513 ret |= READL(ramptr + 0, &t0);
1514 ret |= READL(ramptr + 4, &t1);
1515 ret |= READL(ramptr + 8, &t2);
1516 ret |= READL(ramptr + 12, &t3);
1517
1518 if (ramtype <= 1) {
1519
1520 *chab = 0; *bw = 64;
1521
1522 if ((t3 != 0xcdef0123) || (t2 != 0x89abcdef)) {
1523 if ((t1 == 0x456789ab) && (t0 == 0x01234567)) {
1524 *chab = 0; *bw = 64;
1525 ret |= SETIREGAND(SISSR, 0x14, 0xfd);
1526 }
1527 }
1528 if ((t1 != 0x456789ab) || (t0 != 0x01234567)) {
1529 *chab = 1; *bw = 64;
1530 ret |= SETIREGANDOR(SISSR, 0x14, 0xfc,0x01);
1531
1532 ret |= sisusb_triggersr16(sisusb, ramtype);
1533 ret |= WRITEL(ramptr + 0, 0x89abcdef);
1534 ret |= WRITEL(ramptr + 4, 0xcdef0123);
1535 ret |= WRITEL(ramptr + 8, 0x55555555);
1536 ret |= WRITEL(ramptr + 12, 0x55555555);
1537 ret |= WRITEL(ramptr + 16, 0xaaaaaaaa);
1538 ret |= WRITEL(ramptr + 20, 0xaaaaaaaa);
1539 ret |= READL(ramptr + 4, &t1);
1540
1541 if (t1 != 0xcdef0123) {
1542 *bw = 32;
1543 ret |= SETIREGOR(SISSR, 0x15, 0x10);
1544 }
1545 }
1546
1547 } else {
1548
1549 *chab = 0; *bw = 64; /* default: cha, bw = 64 */
1550
1551 done = 0;
1552
1553 if (t1 == 0x456789ab) {
1554 if (t0 == 0x01234567) {
1555 *chab = 0; *bw = 64;
1556 done = 1;
1557 }
1558 } else {
1559 if (t0 == 0x01234567) {
1560 *chab = 0; *bw = 32;
1561 ret |= SETIREG(SISSR, 0x14, 0x00);
1562 done = 1;
1563 }
1564 }
1565
1566 if (!done) {
1567 ret |= SETIREG(SISSR, 0x14, 0x03);
1568 ret |= sisusb_triggersr16(sisusb, ramtype);
1569
1570 ret |= WRITEL(ramptr + 0, 0x01234567);
1571 ret |= WRITEL(ramptr + 4, 0x456789ab);
1572 ret |= WRITEL(ramptr + 8, 0x89abcdef);
1573 ret |= WRITEL(ramptr + 12, 0xcdef0123);
1574 ret |= WRITEL(ramptr + 16, 0x55555555);
1575 ret |= WRITEL(ramptr + 20, 0x55555555);
1576 ret |= WRITEL(ramptr + 24, 0xffffffff);
1577 ret |= WRITEL(ramptr + 28, 0xffffffff);
1578 ret |= READL(ramptr + 0, &t0);
1579 ret |= READL(ramptr + 4, &t1);
1580
1581 if (t1 == 0x456789ab) {
1582 if (t0 == 0x01234567) {
1583 *chab = 1; *bw = 64;
1584 return ret;
1585 } /* else error */
1586 } else {
1587 if (t0 == 0x01234567) {
1588 *chab = 1; *bw = 32;
1589 ret |= SETIREG(SISSR, 0x14, 0x01);
1590 } /* else error */
1591 }
1592 }
1593 }
1594 return ret;
1595 }
1596
1597 static int
1598 sisusb_verify_mclk(struct sisusb_usb_data *sisusb)
1599 {
1600 int ret = 0;
1601 u32 ramptr = SISUSB_PCI_MEMBASE;
1602 u8 tmp1, tmp2, i, j;
1603
1604 ret |= WRITEB(ramptr, 0xaa);
1605 ret |= WRITEB(ramptr + 16, 0x55);
1606 ret |= READB(ramptr, &tmp1);
1607 ret |= READB(ramptr + 16, &tmp2);
1608 if ((tmp1 != 0xaa) || (tmp2 != 0x55)) {
1609 for (i = 0, j = 16; i < 2; i++, j += 16) {
1610 ret |= GETIREG(SISSR, 0x21, &tmp1);
1611 ret |= SETIREGAND(SISSR, 0x21, (tmp1 & 0xfb));
1612 ret |= SETIREGOR(SISSR, 0x3c, 0x01); /* not on 330 */
1613 ret |= SETIREGAND(SISSR, 0x3c, 0xfe); /* not on 330 */
1614 ret |= SETIREG(SISSR, 0x21, tmp1);
1615 ret |= WRITEB(ramptr + 16 + j, j);
1616 ret |= READB(ramptr + 16 + j, &tmp1);
1617 if (tmp1 == j) {
1618 ret |= WRITEB(ramptr + j, j);
1619 break;
1620 }
1621 }
1622 }
1623 return ret;
1624 }
1625
1626 static int
1627 sisusb_set_rank(struct sisusb_usb_data *sisusb, int *iret, int index,
1628 u8 rankno, u8 chab, const u8 dramtype[][5],
1629 int bw)
1630 {
1631 int ret = 0, ranksize;
1632 u8 tmp;
1633
1634 *iret = 0;
1635
1636 if ((rankno == 2) && (dramtype[index][0] == 2))
1637 return ret;
1638
1639 ranksize = dramtype[index][3] / 2 * bw / 32;
1640
1641 if ((ranksize * rankno) > 128)
1642 return ret;
1643
1644 tmp = 0;
1645 while ((ranksize >>= 1) > 0) tmp += 0x10;
1646 tmp |= ((rankno - 1) << 2);
1647 tmp |= ((bw / 64) & 0x02);
1648 tmp |= (chab & 0x01);
1649
1650 ret = SETIREG(SISSR, 0x14, tmp);
1651 ret |= sisusb_triggersr16(sisusb, 0); /* sic! */
1652
1653 *iret = 1;
1654
1655 return ret;
1656 }
1657
1658 static int
1659 sisusb_check_rbc(struct sisusb_usb_data *sisusb, int *iret, u32 inc, int testn)
1660 {
1661 int ret = 0, i;
1662 u32 j, tmp;
1663
1664 *iret = 0;
1665
1666 for (i = 0, j = 0; i < testn; i++) {
1667 ret |= WRITEL(sisusb->vrambase + j, j);
1668 j += inc;
1669 }
1670
1671 for (i = 0, j = 0; i < testn; i++) {
1672 ret |= READL(sisusb->vrambase + j, &tmp);
1673 if (tmp != j) return ret;
1674 j += inc;
1675 }
1676
1677 *iret = 1;
1678 return ret;
1679 }
1680
1681 static int
1682 sisusb_check_ranks(struct sisusb_usb_data *sisusb, int *iret, int rankno,
1683 int idx, int bw, const u8 rtype[][5])
1684 {
1685 int ret = 0, i, i2ret;
1686 u32 inc;
1687
1688 *iret = 0;
1689
1690 for (i = rankno; i >= 1; i--) {
1691 inc = 1 << (rtype[idx][2] +
1692 rtype[idx][1] +
1693 rtype[idx][0] +
1694 bw / 64 + i);
1695 ret |= sisusb_check_rbc(sisusb, &i2ret, inc, 2);
1696 if (!i2ret)
1697 return ret;
1698 }
1699
1700 inc = 1 << (rtype[idx][2] + bw / 64 + 2);
1701 ret |= sisusb_check_rbc(sisusb, &i2ret, inc, 4);
1702 if (!i2ret)
1703 return ret;
1704
1705 inc = 1 << (10 + bw / 64);
1706 ret |= sisusb_check_rbc(sisusb, &i2ret, inc, 2);
1707 if (!i2ret)
1708 return ret;
1709
1710 *iret = 1;
1711 return ret;
1712 }
1713
1714 static int
1715 sisusb_get_sdram_size(struct sisusb_usb_data *sisusb, int *iret, int bw,
1716 int chab)
1717 {
1718 int ret = 0, i2ret = 0, i, j;
1719 static const u8 sdramtype[13][5] = {
1720 { 2, 12, 9, 64, 0x35 },
1721 { 1, 13, 9, 64, 0x44 },
1722 { 2, 12, 8, 32, 0x31 },
1723 { 2, 11, 9, 32, 0x25 },
1724 { 1, 12, 9, 32, 0x34 },
1725 { 1, 13, 8, 32, 0x40 },
1726 { 2, 11, 8, 16, 0x21 },
1727 { 1, 12, 8, 16, 0x30 },
1728 { 1, 11, 9, 16, 0x24 },
1729 { 1, 11, 8, 8, 0x20 },
1730 { 2, 9, 8, 4, 0x01 },
1731 { 1, 10, 8, 4, 0x10 },
1732 { 1, 9, 8, 2, 0x00 }
1733 };
1734
1735 *iret = 1; /* error */
1736
1737 for (i = 0; i < 13; i++) {
1738 ret |= SETIREGANDOR(SISSR, 0x13, 0x80, sdramtype[i][4]);
1739 for (j = 2; j > 0; j--) {
1740 ret |= sisusb_set_rank(sisusb, &i2ret, i, j,
1741 chab, sdramtype, bw);
1742 if (!i2ret)
1743 continue;
1744
1745 ret |= sisusb_check_ranks(sisusb, &i2ret, j, i,
1746 bw, sdramtype);
1747 if (i2ret) {
1748 *iret = 0; /* ram size found */
1749 return ret;
1750 }
1751 }
1752 }
1753
1754 return ret;
1755 }
1756
1757 static int
1758 sisusb_setup_screen(struct sisusb_usb_data *sisusb, int clrall, int drwfr)
1759 {
1760 int ret = 0;
1761 u32 address;
1762 int i, length, modex, modey, bpp;
1763
1764 modex = 640; modey = 480; bpp = 2;
1765
1766 address = sisusb->vrambase; /* Clear video ram */
1767
1768 if (clrall)
1769 length = sisusb->vramsize;
1770 else
1771 length = modex * bpp * modey;
1772
1773 ret = sisusb_clear_vram(sisusb, address, length);
1774
1775 if (!ret && drwfr) {
1776 for (i = 0; i < modex; i++) {
1777 address = sisusb->vrambase + (i * bpp);
1778 ret |= sisusb_write_memio_word(sisusb, SISUSB_TYPE_MEM,
1779 address, 0xf100);
1780 address += (modex * (modey-1) * bpp);
1781 ret |= sisusb_write_memio_word(sisusb, SISUSB_TYPE_MEM,
1782 address, 0xf100);
1783 }
1784 for (i = 0; i < modey; i++) {
1785 address = sisusb->vrambase + ((i * modex) * bpp);
1786 ret |= sisusb_write_memio_word(sisusb, SISUSB_TYPE_MEM,
1787 address, 0xf100);
1788 address += ((modex - 1) * bpp);
1789 ret |= sisusb_write_memio_word(sisusb, SISUSB_TYPE_MEM,
1790 address, 0xf100);
1791 }
1792 }
1793
1794 return ret;
1795 }
1796
1797 static int
1798 sisusb_set_default_mode(struct sisusb_usb_data *sisusb, int touchengines)
1799 {
1800 int ret = 0, i, j, modex, modey, bpp, du;
1801 u8 sr31, cr63, tmp8;
1802 static const char attrdata[] = {
1803 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,
1804 0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,
1805 0x01,0x00,0x00,0x00
1806 };
1807 static const char crtcrdata[] = {
1808 0x5f,0x4f,0x50,0x82,0x54,0x80,0x0b,0x3e,
1809 0x00,0x40,0x00,0x00,0x00,0x00,0x00,0x00,
1810 0xea,0x8c,0xdf,0x28,0x40,0xe7,0x04,0xa3,
1811 0xff
1812 };
1813 static const char grcdata[] = {
1814 0x00,0x00,0x00,0x00,0x00,0x40,0x05,0x0f,
1815 0xff
1816 };
1817 static const char crtcdata[] = {
1818 0x5f,0x4f,0x4f,0x83,0x55,0x81,0x0b,0x3e,
1819 0xe9,0x8b,0xdf,0xe8,0x0c,0x00,0x00,0x05,
1820 0x00
1821 };
1822
1823 modex = 640; modey = 480; bpp = 2;
1824
1825 GETIREG(SISSR, 0x31, &sr31);
1826 GETIREG(SISCR, 0x63, &cr63);
1827 SETIREGOR(SISSR, 0x01, 0x20);
1828 SETIREG(SISCR, 0x63, cr63 & 0xbf);
1829 SETIREGOR(SISCR, 0x17, 0x80);
1830 SETIREGOR(SISSR, 0x1f, 0x04);
1831 SETIREGAND(SISSR, 0x07, 0xfb);
1832 SETIREG(SISSR, 0x00, 0x03); /* seq */
1833 SETIREG(SISSR, 0x01, 0x21);
1834 SETIREG(SISSR, 0x02, 0x0f);
1835 SETIREG(SISSR, 0x03, 0x00);
1836 SETIREG(SISSR, 0x04, 0x0e);
1837 SETREG(SISMISCW, 0x23); /* misc */
1838 for (i = 0; i <= 0x18; i++) { /* crtc */
1839 SETIREG(SISCR, i, crtcrdata[i]);
1840 }
1841 for (i = 0; i <= 0x13; i++) { /* att */
1842 GETREG(SISINPSTAT, &tmp8);
1843 SETREG(SISAR, i);
1844 SETREG(SISAR, attrdata[i]);
1845 }
1846 GETREG(SISINPSTAT, &tmp8);
1847 SETREG(SISAR, 0x14);
1848 SETREG(SISAR, 0x00);
1849 GETREG(SISINPSTAT, &tmp8);
1850 SETREG(SISAR, 0x20);
1851 GETREG(SISINPSTAT, &tmp8);
1852 for (i = 0; i <= 0x08; i++) { /* grc */
1853 SETIREG(SISGR, i, grcdata[i]);
1854 }
1855 SETIREGAND(SISGR, 0x05, 0xbf);
1856 for (i = 0x0A; i <= 0x0E; i++) { /* clr ext */
1857 SETIREG(SISSR, i, 0x00);
1858 }
1859 SETIREGAND(SISSR, 0x37, 0xfe);
1860 SETREG(SISMISCW, 0xef); /* sync */
1861 SETIREG(SISCR, 0x11, 0x00); /* crtc */
1862 for (j = 0x00, i = 0; i <= 7; i++, j++) {
1863 SETIREG(SISCR, j, crtcdata[i]);
1864 }
1865 for (j = 0x10; i <= 10; i++, j++) {
1866 SETIREG(SISCR, j, crtcdata[i]);
1867 }
1868 for (j = 0x15; i <= 12; i++, j++) {
1869 SETIREG(SISCR, j, crtcdata[i]);
1870 }
1871 for (j = 0x0A; i <= 15; i++, j++) {
1872 SETIREG(SISSR, j, crtcdata[i]);
1873 }
1874 SETIREG(SISSR, 0x0E, (crtcdata[16] & 0xE0));
1875 SETIREGANDOR(SISCR, 0x09, 0x5f, ((crtcdata[16] & 0x01) << 5));
1876 SETIREG(SISCR, 0x14, 0x4f);
1877 du = (modex / 16) * (bpp * 2); /* offset/pitch */
1878 if (modex % 16) du += bpp;
1879 SETIREGANDOR(SISSR, 0x0e, 0xf0, ((du >> 8) & 0x0f));
1880 SETIREG(SISCR, 0x13, (du & 0xff));
1881 du <<= 5;
1882 tmp8 = du >> 8;
1883 if (du & 0xff) tmp8++;
1884 SETIREG(SISSR, 0x10, tmp8);
1885 SETIREG(SISSR, 0x31, 0x00); /* VCLK */
1886 SETIREG(SISSR, 0x2b, 0x1b);
1887 SETIREG(SISSR, 0x2c, 0xe1);
1888 SETIREG(SISSR, 0x2d, 0x01);
1889 SETIREGAND(SISSR, 0x3d, 0xfe); /* FIFO */
1890 SETIREG(SISSR, 0x08, 0xae);
1891 SETIREGAND(SISSR, 0x09, 0xf0);
1892 SETIREG(SISSR, 0x08, 0x34);
1893 SETIREGOR(SISSR, 0x3d, 0x01);
1894 SETIREGAND(SISSR, 0x1f, 0x3f); /* mode regs */
1895 SETIREGANDOR(SISSR, 0x06, 0xc0, 0x0a);
1896 SETIREG(SISCR, 0x19, 0x00);
1897 SETIREGAND(SISCR, 0x1a, 0xfc);
1898 SETIREGAND(SISSR, 0x0f, 0xb7);
1899 SETIREGAND(SISSR, 0x31, 0xfb);
1900 SETIREGANDOR(SISSR, 0x21, 0x1f, 0xa0);
1901 SETIREGAND(SISSR, 0x32, 0xf3);
1902 SETIREGANDOR(SISSR, 0x07, 0xf8, 0x03);
1903 SETIREG(SISCR, 0x52, 0x6c);
1904
1905 SETIREG(SISCR, 0x0d, 0x00); /* adjust frame */
1906 SETIREG(SISCR, 0x0c, 0x00);
1907 SETIREG(SISSR, 0x0d, 0x00);
1908 SETIREGAND(SISSR, 0x37, 0xfe);
1909
1910 SETIREG(SISCR, 0x32, 0x20);
1911 SETIREGAND(SISSR, 0x01, 0xdf); /* enable display */
1912 SETIREG(SISCR, 0x63, (cr63 & 0xbf));
1913 SETIREG(SISSR, 0x31, (sr31 & 0xfb));
1914
1915 if (touchengines) {
1916 SETIREG(SISSR, 0x20, 0xa1); /* enable engines */
1917 SETIREGOR(SISSR, 0x1e, 0x5a);
1918
1919 SETIREG(SISSR, 0x26, 0x01); /* disable cmdqueue */
1920 SETIREG(SISSR, 0x27, 0x1f);
1921 SETIREG(SISSR, 0x26, 0x00);
1922 }
1923
1924 SETIREG(SISCR, 0x34, 0x44); /* we just set std mode #44 */
1925
1926 return ret;
1927 }
1928
1929 static int
1930 sisusb_init_gfxcore(struct sisusb_usb_data *sisusb)
1931 {
1932 int ret = 0, i, j, bw, chab, iret, retry = 3;
1933 u8 tmp8, ramtype;
1934 u32 tmp32;
1935 static const char mclktable[] = {
1936 0x3b, 0x22, 0x01, 143,
1937 0x3b, 0x22, 0x01, 143,
1938 0x3b, 0x22, 0x01, 143,
1939 0x3b, 0x22, 0x01, 143
1940 };
1941 static const char eclktable[] = {
1942 0x3b, 0x22, 0x01, 143,
1943 0x3b, 0x22, 0x01, 143,
1944 0x3b, 0x22, 0x01, 143,
1945 0x3b, 0x22, 0x01, 143
1946 };
1947 static const char ramtypetable1[] = {
1948 0x00, 0x04, 0x60, 0x60,
1949 0x0f, 0x0f, 0x1f, 0x1f,
1950 0xba, 0xba, 0xba, 0xba,
1951 0xa9, 0xa9, 0xac, 0xac,
1952 0xa0, 0xa0, 0xa0, 0xa8,
1953 0x00, 0x00, 0x02, 0x02,
1954 0x30, 0x30, 0x40, 0x40
1955 };
1956 static const char ramtypetable2[] = {
1957 0x77, 0x77, 0x44, 0x44,
1958 0x77, 0x77, 0x44, 0x44,
1959 0x00, 0x00, 0x00, 0x00,
1960 0x5b, 0x5b, 0xab, 0xab,
1961 0x00, 0x00, 0xf0, 0xf8
1962 };
1963
1964 while (retry--) {
1965
1966 /* Enable VGA */
1967 ret = GETREG(SISVGAEN, &tmp8);
1968 ret |= SETREG(SISVGAEN, (tmp8 | 0x01));
1969
1970 /* Enable GPU access to VRAM */
1971 ret |= GETREG(SISMISCR, &tmp8);
1972 ret |= SETREG(SISMISCW, (tmp8 | 0x01));
1973
1974 if (ret) continue;
1975
1976 /* Reset registers */
1977 ret |= SETIREGAND(SISCR, 0x5b, 0xdf);
1978 ret |= SETIREG(SISSR, 0x05, 0x86);
1979 ret |= SETIREGOR(SISSR, 0x20, 0x01);
1980
1981 ret |= SETREG(SISMISCW, 0x67);
1982
1983 for (i = 0x06; i <= 0x1f; i++) {
1984 ret |= SETIREG(SISSR, i, 0x00);
1985 }
1986 for (i = 0x21; i <= 0x27; i++) {
1987 ret |= SETIREG(SISSR, i, 0x00);
1988 }
1989 for (i = 0x31; i <= 0x3d; i++) {
1990 ret |= SETIREG(SISSR, i, 0x00);
1991 }
1992 for (i = 0x12; i <= 0x1b; i++) {
1993 ret |= SETIREG(SISSR, i, 0x00);
1994 }
1995 for (i = 0x79; i <= 0x7c; i++) {
1996 ret |= SETIREG(SISCR, i, 0x00);
1997 }
1998
1999 if (ret) continue;
2000
2001 ret |= SETIREG(SISCR, 0x63, 0x80);
2002
2003 ret |= GETIREG(SISSR, 0x3a, &ramtype);
2004 ramtype &= 0x03;
2005
2006 ret |= SETIREG(SISSR, 0x28, mclktable[ramtype * 4]);
2007 ret |= SETIREG(SISSR, 0x29, mclktable[(ramtype * 4) + 1]);
2008 ret |= SETIREG(SISSR, 0x2a, mclktable[(ramtype * 4) + 2]);
2009
2010 ret |= SETIREG(SISSR, 0x2e, eclktable[ramtype * 4]);
2011 ret |= SETIREG(SISSR, 0x2f, eclktable[(ramtype * 4) + 1]);
2012 ret |= SETIREG(SISSR, 0x30, eclktable[(ramtype * 4) + 2]);
2013
2014 ret |= SETIREG(SISSR, 0x07, 0x18);
2015 ret |= SETIREG(SISSR, 0x11, 0x0f);
2016
2017 if (ret) continue;
2018
2019 for (i = 0x15, j = 0; i <= 0x1b; i++, j++) {
2020 ret |= SETIREG(SISSR, i, ramtypetable1[(j*4) + ramtype]);
2021 }
2022 for (i = 0x40, j = 0; i <= 0x44; i++, j++) {
2023 ret |= SETIREG(SISCR, i, ramtypetable2[(j*4) + ramtype]);
2024 }
2025
2026 ret |= SETIREG(SISCR, 0x49, 0xaa);
2027
2028 ret |= SETIREG(SISSR, 0x1f, 0x00);
2029 ret |= SETIREG(SISSR, 0x20, 0xa0);
2030 ret |= SETIREG(SISSR, 0x23, 0xf6);
2031 ret |= SETIREG(SISSR, 0x24, 0x0d);
2032 ret |= SETIREG(SISSR, 0x25, 0x33);
2033
2034 ret |= SETIREG(SISSR, 0x11, 0x0f);
2035
2036 ret |= SETIREGOR(SISPART1, 0x2f, 0x01);
2037
2038 ret |= SETIREGAND(SISCAP, 0x3f, 0xef);
2039
2040 if (ret) continue;
2041
2042 ret |= SETIREG(SISPART1, 0x00, 0x00);
2043
2044 ret |= GETIREG(SISSR, 0x13, &tmp8);
2045 tmp8 >>= 4;
2046
2047 ret |= SETIREG(SISPART1, 0x02, 0x00);
2048 ret |= SETIREG(SISPART1, 0x2e, 0x08);
2049
2050 ret |= sisusb_read_pci_config(sisusb, 0x50, &tmp32);
2051 tmp32 &= 0x00f00000;
2052 tmp8 = (tmp32 == 0x100000) ? 0x33 : 0x03;
2053 ret |= SETIREG(SISSR, 0x25, tmp8);
2054 tmp8 = (tmp32 == 0x100000) ? 0xaa : 0x88;
2055 ret |= SETIREG(SISCR, 0x49, tmp8);
2056
2057 ret |= SETIREG(SISSR, 0x27, 0x1f);
2058 ret |= SETIREG(SISSR, 0x31, 0x00);
2059 ret |= SETIREG(SISSR, 0x32, 0x11);
2060 ret |= SETIREG(SISSR, 0x33, 0x00);
2061
2062 if (ret) continue;
2063
2064 ret |= SETIREG(SISCR, 0x83, 0x00);
2065
2066 ret |= sisusb_set_default_mode(sisusb, 0);
2067
2068 ret |= SETIREGAND(SISSR, 0x21, 0xdf);
2069 ret |= SETIREGOR(SISSR, 0x01, 0x20);
2070 ret |= SETIREGOR(SISSR, 0x16, 0x0f);
2071
2072 ret |= sisusb_triggersr16(sisusb, ramtype);
2073
2074 /* Disable refresh */
2075 ret |= SETIREGAND(SISSR, 0x17, 0xf8);
2076 ret |= SETIREGOR(SISSR, 0x19, 0x03);
2077
2078 ret |= sisusb_getbuswidth(sisusb, &bw, &chab);
2079 ret |= sisusb_verify_mclk(sisusb);
2080
2081 if (ramtype <= 1) {
2082 ret |= sisusb_get_sdram_size(sisusb, &iret, bw, chab);
2083 if (iret) {
2084 dev_err(&sisusb->sisusb_dev->dev,"RAM size detection failed, assuming 8MB video RAM\n");
2085 ret |= SETIREG(SISSR,0x14,0x31);
2086 /* TODO */
2087 }
2088 } else {
2089 dev_err(&sisusb->sisusb_dev->dev, "DDR RAM device found, assuming 8MB video RAM\n");
2090 ret |= SETIREG(SISSR,0x14,0x31);
2091 /* *** TODO *** */
2092 }
2093
2094 /* Enable refresh */
2095 ret |= SETIREG(SISSR, 0x16, ramtypetable1[4 + ramtype]);
2096 ret |= SETIREG(SISSR, 0x17, ramtypetable1[8 + ramtype]);
2097 ret |= SETIREG(SISSR, 0x19, ramtypetable1[16 + ramtype]);
2098
2099 ret |= SETIREGOR(SISSR, 0x21, 0x20);
2100
2101 ret |= SETIREG(SISSR, 0x22, 0xfb);
2102 ret |= SETIREG(SISSR, 0x21, 0xa5);
2103
2104 if (ret == 0)
2105 break;
2106 }
2107
2108 return ret;
2109 }
2110
2111 #undef SETREG
2112 #undef GETREG
2113 #undef SETIREG
2114 #undef GETIREG
2115 #undef SETIREGOR
2116 #undef SETIREGAND
2117 #undef SETIREGANDOR
2118 #undef READL
2119 #undef WRITEL
2120
2121 static void
2122 sisusb_get_ramconfig(struct sisusb_usb_data *sisusb)
2123 {
2124 u8 tmp8, tmp82, ramtype;
2125 int bw = 0;
2126 char *ramtypetext1 = NULL;
2127 const char *ramtypetext2[] = { "SDR SDRAM", "SDR SGRAM",
2128 "DDR SDRAM", "DDR SGRAM" };
2129 static const int busSDR[4] = {64, 64, 128, 128};
2130 static const int busDDR[4] = {32, 32, 64, 64};
2131 static const int busDDRA[4] = {64+32, 64+32 , (64+32)*2, (64+32)*2};
2132
2133 sisusb_getidxreg(sisusb, SISSR, 0x14, &tmp8);
2134 sisusb_getidxreg(sisusb, SISSR, 0x15, &tmp82);
2135 sisusb_getidxreg(sisusb, SISSR, 0x3a, &ramtype);
2136 sisusb->vramsize = (1 << ((tmp8 & 0xf0) >> 4)) * 1024 * 1024;
2137 ramtype &= 0x03;
2138 switch ((tmp8 >> 2) & 0x03) {
2139 case 0: ramtypetext1 = "1 ch/1 r";
2140 if (tmp82 & 0x10) {
2141 bw = 32;
2142 } else {
2143 bw = busSDR[(tmp8 & 0x03)];
2144 }
2145 break;
2146 case 1: ramtypetext1 = "1 ch/2 r";
2147 sisusb->vramsize <<= 1;
2148 bw = busSDR[(tmp8 & 0x03)];
2149 break;
2150 case 2: ramtypetext1 = "asymmeric";
2151 sisusb->vramsize += sisusb->vramsize/2;
2152 bw = busDDRA[(tmp8 & 0x03)];
2153 break;
2154 case 3: ramtypetext1 = "2 channel";
2155 sisusb->vramsize <<= 1;
2156 bw = busDDR[(tmp8 & 0x03)];
2157 break;
2158 }
2159
2160 dev_info(&sisusb->sisusb_dev->dev, "%dMB %s %s, bus width %d\n", (sisusb->vramsize >> 20), ramtypetext1,
2161 ramtypetext2[ramtype], bw);
2162 }
2163
2164 static int
2165 sisusb_do_init_gfxdevice(struct sisusb_usb_data *sisusb)
2166 {
2167 struct sisusb_packet packet;
2168 int ret;
2169 u32 tmp32;
2170
2171 /* Do some magic */
2172 packet.header = 0x001f;
2173 packet.address = 0x00000324;
2174 packet.data = 0x00000004;
2175 ret = sisusb_send_bridge_packet(sisusb, 10, &packet, 0);
2176
2177 packet.header = 0x001f;
2178 packet.address = 0x00000364;
2179 packet.data = 0x00000004;
2180 ret |= sisusb_send_bridge_packet(sisusb, 10, &packet, 0);
2181
2182 packet.header = 0x001f;
2183 packet.address = 0x00000384;
2184 packet.data = 0x00000004;
2185 ret |= sisusb_send_bridge_packet(sisusb, 10, &packet, 0);
2186
2187 packet.header = 0x001f;
2188 packet.address = 0x00000100;
2189 packet.data = 0x00000700;
2190 ret |= sisusb_send_bridge_packet(sisusb, 10, &packet, 0);
2191
2192 packet.header = 0x000f;
2193 packet.address = 0x00000004;
2194 ret |= sisusb_send_bridge_packet(sisusb, 6, &packet, 0);
2195 packet.data |= 0x17;
2196 ret |= sisusb_send_bridge_packet(sisusb, 10, &packet, 0);
2197
2198 /* Init BAR 0 (VRAM) */
2199 ret |= sisusb_read_pci_config(sisusb, 0x10, &tmp32);
2200 ret |= sisusb_write_pci_config(sisusb, 0x10, 0xfffffff0);
2201 ret |= sisusb_read_pci_config(sisusb, 0x10, &tmp32);
2202 tmp32 &= 0x0f;
2203 tmp32 |= SISUSB_PCI_MEMBASE;
2204 ret |= sisusb_write_pci_config(sisusb, 0x10, tmp32);
2205
2206 /* Init BAR 1 (MMIO) */
2207 ret |= sisusb_read_pci_config(sisusb, 0x14, &tmp32);
2208 ret |= sisusb_write_pci_config(sisusb, 0x14, 0xfffffff0);
2209 ret |= sisusb_read_pci_config(sisusb, 0x14, &tmp32);
2210 tmp32 &= 0x0f;
2211 tmp32 |= SISUSB_PCI_MMIOBASE;
2212 ret |= sisusb_write_pci_config(sisusb, 0x14, tmp32);
2213
2214 /* Init BAR 2 (i/o ports) */
2215 ret |= sisusb_read_pci_config(sisusb, 0x18, &tmp32);
2216 ret |= sisusb_write_pci_config(sisusb, 0x18, 0xfffffff0);
2217 ret |= sisusb_read_pci_config(sisusb, 0x18, &tmp32);
2218 tmp32 &= 0x0f;
2219 tmp32 |= SISUSB_PCI_IOPORTBASE;
2220 ret |= sisusb_write_pci_config(sisusb, 0x18, tmp32);
2221
2222 /* Enable memory and i/o access */
2223 ret |= sisusb_read_pci_config(sisusb, 0x04, &tmp32);
2224 tmp32 |= 0x3;
2225 ret |= sisusb_write_pci_config(sisusb, 0x04, tmp32);
2226
2227 if (ret == 0) {
2228 /* Some further magic */
2229 packet.header = 0x001f;
2230 packet.address = 0x00000050;
2231 packet.data = 0x000000ff;
2232 ret |= sisusb_send_bridge_packet(sisusb, 10, &packet, 0);
2233 }
2234
2235 return ret;
2236 }
2237
2238 /* Initialize the graphics device (return 0 on success)
2239 * This initializes the net2280 as well as the PCI registers
2240 * of the graphics board.
2241 */
2242
2243 static int
2244 sisusb_init_gfxdevice(struct sisusb_usb_data *sisusb, int initscreen)
2245 {
2246 int ret = 0, test = 0;
2247 u32 tmp32;
2248
2249 if (sisusb->devinit == 1) {
2250 /* Read PCI BARs and see if they have been set up */
2251 ret |= sisusb_read_pci_config(sisusb, 0x10, &tmp32);
2252 if (ret) return ret;
2253 if ((tmp32 & 0xfffffff0) == SISUSB_PCI_MEMBASE) test++;
2254
2255 ret |= sisusb_read_pci_config(sisusb, 0x14, &tmp32);
2256 if (ret) return ret;
2257 if ((tmp32 & 0xfffffff0) == SISUSB_PCI_MMIOBASE) test++;
2258
2259 ret |= sisusb_read_pci_config(sisusb, 0x18, &tmp32);
2260 if (ret) return ret;
2261 if ((tmp32 & 0xfffffff0) == SISUSB_PCI_IOPORTBASE) test++;
2262 }
2263
2264 /* No? So reset the device */
2265 if ((sisusb->devinit == 0) || (test != 3)) {
2266
2267 ret |= sisusb_do_init_gfxdevice(sisusb);
2268
2269 if (ret == 0)
2270 sisusb->devinit = 1;
2271
2272 }
2273
2274 if (sisusb->devinit) {
2275 /* Initialize the graphics core */
2276 if (sisusb_init_gfxcore(sisusb) == 0) {
2277 sisusb->gfxinit = 1;
2278 sisusb_get_ramconfig(sisusb);
2279 ret |= sisusb_set_default_mode(sisusb, 1);
2280 ret |= sisusb_setup_screen(sisusb, 1, initscreen);
2281 }
2282 }
2283
2284 return ret;
2285 }
2286
2287
2288 #ifdef INCL_SISUSB_CON
2289
2290 /* Set up default text mode:
2291 - Set text mode (0x03)
2292 - Upload default font
2293 - Upload user font (if available)
2294 */
2295
2296 int
2297 sisusb_reset_text_mode(struct sisusb_usb_data *sisusb, int init)
2298 {
2299 int ret = 0, slot = sisusb->font_slot, i;
2300 const struct font_desc *myfont;
2301 u8 *tempbuf;
2302 u16 *tempbufb;
2303 size_t written;
2304 static const char bootstring[] = "SiSUSB VGA text console, (C) 2005 Thomas Winischhofer.";
2305 static const char bootlogo[] = "(o_ //\\ V_/_";
2306
2307 /* sisusb->lock is down */
2308
2309 if (!sisusb->SiS_Pr)
2310 return 1;
2311
2312 sisusb->SiS_Pr->IOAddress = SISUSB_PCI_IOPORTBASE + 0x30;
2313 sisusb->SiS_Pr->sisusb = (void *)sisusb;
2314
2315 /* Set mode 0x03 */
2316 SiSUSBSetMode(sisusb->SiS_Pr, 0x03);
2317
2318 if (!(myfont = find_font("VGA8x16")))
2319 return 1;
2320
2321 if (!(tempbuf = vmalloc(8192)))
2322 return 1;
2323
2324 for (i = 0; i < 256; i++)
2325 memcpy(tempbuf + (i * 32), myfont->data + (i * 16), 16);
2326
2327 /* Upload default font */
2328 ret = sisusbcon_do_font_op(sisusb, 1, 0, tempbuf, 8192, 0, 1, NULL, 16, 0);
2329
2330 vfree(tempbuf);
2331
2332 /* Upload user font (and reset current slot) */
2333 if (sisusb->font_backup) {
2334 ret |= sisusbcon_do_font_op(sisusb, 1, 2, sisusb->font_backup,
2335 8192, sisusb->font_backup_512, 1, NULL,
2336 sisusb->font_backup_height, 0);
2337 if (slot != 2)
2338 sisusbcon_do_font_op(sisusb, 1, 0, NULL, 0, 0, 1,
2339 NULL, 16, 0);
2340 }
2341
2342 if (init && !sisusb->scrbuf) {
2343
2344 if ((tempbuf = vmalloc(8192))) {
2345
2346 i = 4096;
2347 tempbufb = (u16 *)tempbuf;
2348 while (i--)
2349 *(tempbufb++) = 0x0720;
2350
2351 i = 0;
2352 tempbufb = (u16 *)tempbuf;
2353 while (bootlogo[i]) {
2354 *(tempbufb++) = 0x0700 | bootlogo[i++];
2355 if (!(i % 4))
2356 tempbufb += 76;
2357 }
2358
2359 i = 0;
2360 tempbufb = (u16 *)tempbuf + 6;
2361 while (bootstring[i])
2362 *(tempbufb++) = 0x0700 | bootstring[i++];
2363
2364 ret |= sisusb_copy_memory(sisusb, tempbuf,
2365 sisusb->vrambase, 8192, &written);
2366
2367 vfree(tempbuf);
2368
2369 }
2370
2371 } else if (sisusb->scrbuf) {
2372
2373 ret |= sisusb_copy_memory(sisusb, (char *)sisusb->scrbuf,
2374 sisusb->vrambase, sisusb->scrbuf_size, &written);
2375
2376 }
2377
2378 if (sisusb->sisusb_cursor_size_from >= 0 &&
2379 sisusb->sisusb_cursor_size_to >= 0) {
2380 sisusb_setidxreg(sisusb, SISCR, 0x0a,
2381 sisusb->sisusb_cursor_size_from);
2382 sisusb_setidxregandor(sisusb, SISCR, 0x0b, 0xe0,
2383 sisusb->sisusb_cursor_size_to);
2384 } else {
2385 sisusb_setidxreg(sisusb, SISCR, 0x0a, 0x2d);
2386 sisusb_setidxreg(sisusb, SISCR, 0x0b, 0x0e);
2387 sisusb->sisusb_cursor_size_to = -1;
2388 }
2389
2390 slot = sisusb->sisusb_cursor_loc;
2391 if(slot < 0) slot = 0;
2392
2393 sisusb->sisusb_cursor_loc = -1;
2394 sisusb->bad_cursor_pos = 1;
2395
2396 sisusb_set_cursor(sisusb, slot);
2397
2398 sisusb_setidxreg(sisusb, SISCR, 0x0c, (sisusb->cur_start_addr >> 8));
2399 sisusb_setidxreg(sisusb, SISCR, 0x0d, (sisusb->cur_start_addr & 0xff));
2400
2401 sisusb->textmodedestroyed = 0;
2402
2403 /* sisusb->lock is down */
2404
2405 return ret;
2406 }
2407
2408 #endif
2409
2410 /* fops */
2411
2412 static int
2413 sisusb_open(struct inode *inode, struct file *file)
2414 {
2415 struct sisusb_usb_data *sisusb;
2416 struct usb_interface *interface;
2417 int subminor = iminor(inode);
2418
2419 if (!(interface = usb_find_interface(&sisusb_driver, subminor)))
2420 return -ENODEV;
2421
2422 if (!(sisusb = usb_get_intfdata(interface)))
2423 return -ENODEV;
2424
2425 mutex_lock(&sisusb->lock);
2426
2427 if (!sisusb->present || !sisusb->ready) {
2428 mutex_unlock(&sisusb->lock);
2429 return -ENODEV;
2430 }
2431
2432 if (sisusb->isopen) {
2433 mutex_unlock(&sisusb->lock);
2434 return -EBUSY;
2435 }
2436
2437 if (!sisusb->devinit) {
2438 if (sisusb->sisusb_dev->speed == USB_SPEED_HIGH) {
2439 if (sisusb_init_gfxdevice(sisusb, 0)) {
2440 mutex_unlock(&sisusb->lock);
2441 dev_err(&sisusb->sisusb_dev->dev, "Failed to initialize device\n");
2442 return -EIO;
2443 }
2444 } else {
2445 mutex_unlock(&sisusb->lock);
2446 dev_err(&sisusb->sisusb_dev->dev, "Device not attached to USB 2.0 hub\n");
2447 return -EIO;
2448 }
2449 }
2450
2451 /* Increment usage count for our sisusb */
2452 kref_get(&sisusb->kref);
2453
2454 sisusb->isopen = 1;
2455
2456 file->private_data = sisusb;
2457
2458 mutex_unlock(&sisusb->lock);
2459
2460 return 0;
2461 }
2462
2463 void
2464 sisusb_delete(struct kref *kref)
2465 {
2466 struct sisusb_usb_data *sisusb = to_sisusb_dev(kref);
2467
2468 if (!sisusb)
2469 return;
2470
2471 if (sisusb->sisusb_dev)
2472 usb_put_dev(sisusb->sisusb_dev);
2473
2474 sisusb->sisusb_dev = NULL;
2475 sisusb_free_buffers(sisusb);
2476 sisusb_free_urbs(sisusb);
2477 #ifdef INCL_SISUSB_CON
2478 kfree(sisusb->SiS_Pr);
2479 #endif
2480 kfree(sisusb);
2481 }
2482
2483 static int
2484 sisusb_release(struct inode *inode, struct file *file)
2485 {
2486 struct sisusb_usb_data *sisusb;
2487
2488 if (!(sisusb = (struct sisusb_usb_data *)file->private_data))
2489 return -ENODEV;
2490
2491 mutex_lock(&sisusb->lock);
2492
2493 if (sisusb->present) {
2494 /* Wait for all URBs to finish if device still present */
2495 if (!sisusb_wait_all_out_complete(sisusb))
2496 sisusb_kill_all_busy(sisusb);
2497 }
2498
2499 sisusb->isopen = 0;
2500 file->private_data = NULL;
2501
2502 mutex_unlock(&sisusb->lock);
2503
2504 /* decrement the usage count on our device */
2505 kref_put(&sisusb->kref, sisusb_delete);
2506
2507 return 0;
2508 }
2509
2510 static ssize_t
2511 sisusb_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
2512 {
2513 struct sisusb_usb_data *sisusb;
2514 ssize_t bytes_read = 0;
2515 int errno = 0;
2516 u8 buf8;
2517 u16 buf16;
2518 u32 buf32, address;
2519
2520 if (!(sisusb = (struct sisusb_usb_data *)file->private_data))
2521 return -ENODEV;
2522
2523 mutex_lock(&sisusb->lock);
2524
2525 /* Sanity check */
2526 if (!sisusb->present || !sisusb->ready || !sisusb->sisusb_dev) {
2527 mutex_unlock(&sisusb->lock);
2528 return -ENODEV;
2529 }
2530
2531 if ((*ppos) >= SISUSB_PCI_PSEUDO_IOPORTBASE &&
2532 (*ppos) < SISUSB_PCI_PSEUDO_IOPORTBASE + 128) {
2533
2534 address = (*ppos) -
2535 SISUSB_PCI_PSEUDO_IOPORTBASE +
2536 SISUSB_PCI_IOPORTBASE;
2537
2538 /* Read i/o ports
2539 * Byte, word and long(32) can be read. As this
2540 * emulates inX instructions, the data returned is
2541 * in machine-endianness.
2542 */
2543 switch (count) {
2544
2545 case 1:
2546 if (sisusb_read_memio_byte(sisusb,
2547 SISUSB_TYPE_IO,
2548 address, &buf8))
2549 errno = -EIO;
2550 else if (put_user(buf8, (u8 __user *)buffer))
2551 errno = -EFAULT;
2552 else
2553 bytes_read = 1;
2554
2555 break;
2556
2557 case 2:
2558 if (sisusb_read_memio_word(sisusb,
2559 SISUSB_TYPE_IO,
2560 address, &buf16))
2561 errno = -EIO;
2562 else if (put_user(buf16, (u16 __user *)buffer))
2563 errno = -EFAULT;
2564 else
2565 bytes_read = 2;
2566
2567 break;
2568
2569 case 4:
2570 if (sisusb_read_memio_long(sisusb,
2571 SISUSB_TYPE_IO,
2572 address, &buf32))
2573 errno = -EIO;
2574 else if (put_user(buf32, (u32 __user *)buffer))
2575 errno = -EFAULT;
2576 else
2577 bytes_read = 4;
2578
2579 break;
2580
2581 default:
2582 errno = -EIO;
2583
2584 }
2585
2586 } else if ((*ppos) >= SISUSB_PCI_PSEUDO_MEMBASE &&
2587 (*ppos) < SISUSB_PCI_PSEUDO_MEMBASE + sisusb->vramsize) {
2588
2589 address = (*ppos) -
2590 SISUSB_PCI_PSEUDO_MEMBASE +
2591 SISUSB_PCI_MEMBASE;
2592
2593 /* Read video ram
2594 * Remember: Data delivered is never endian-corrected
2595 */
2596 errno = sisusb_read_mem_bulk(sisusb, address,
2597 NULL, count, buffer, &bytes_read);
2598
2599 if (bytes_read)
2600 errno = bytes_read;
2601
2602 } else if ((*ppos) >= SISUSB_PCI_PSEUDO_MMIOBASE &&
2603 (*ppos) < SISUSB_PCI_PSEUDO_MMIOBASE + SISUSB_PCI_MMIOSIZE) {
2604
2605 address = (*ppos) -
2606 SISUSB_PCI_PSEUDO_MMIOBASE +
2607 SISUSB_PCI_MMIOBASE;
2608
2609 /* Read MMIO
2610 * Remember: Data delivered is never endian-corrected
2611 */
2612 errno = sisusb_read_mem_bulk(sisusb, address,
2613 NULL, count, buffer, &bytes_read);
2614
2615 if (bytes_read)
2616 errno = bytes_read;
2617
2618 } else if ((*ppos) >= SISUSB_PCI_PSEUDO_PCIBASE &&
2619 (*ppos) <= SISUSB_PCI_PSEUDO_PCIBASE + 0x5c) {
2620
2621 if (count != 4) {
2622 mutex_unlock(&sisusb->lock);
2623 return -EINVAL;
2624 }
2625
2626 address = (*ppos) - SISUSB_PCI_PSEUDO_PCIBASE;
2627
2628 /* Read PCI config register
2629 * Return value delivered in machine endianness.
2630 */
2631 if (sisusb_read_pci_config(sisusb, address, &buf32))
2632 errno = -EIO;
2633 else if (put_user(buf32, (u32 __user *)buffer))
2634 errno = -EFAULT;
2635 else
2636 bytes_read = 4;
2637
2638 } else {
2639
2640 errno = -EBADFD;
2641
2642 }
2643
2644 (*ppos) += bytes_read;
2645
2646 mutex_unlock(&sisusb->lock);
2647
2648 return errno ? errno : bytes_read;
2649 }
2650
2651 static ssize_t
2652 sisusb_write(struct file *file, const char __user *buffer, size_t count,
2653 loff_t *ppos)
2654 {
2655 struct sisusb_usb_data *sisusb;
2656 int errno = 0;
2657 ssize_t bytes_written = 0;
2658 u8 buf8;
2659 u16 buf16;
2660 u32 buf32, address;
2661
2662 if (!(sisusb = (struct sisusb_usb_data *)file->private_data))
2663 return -ENODEV;
2664
2665 mutex_lock(&sisusb->lock);
2666
2667 /* Sanity check */
2668 if (!sisusb->present || !sisusb->ready || !sisusb->sisusb_dev) {
2669 mutex_unlock(&sisusb->lock);
2670 return -ENODEV;
2671 }
2672
2673 if ((*ppos) >= SISUSB_PCI_PSEUDO_IOPORTBASE &&
2674 (*ppos) < SISUSB_PCI_PSEUDO_IOPORTBASE + 128) {
2675
2676 address = (*ppos) -
2677 SISUSB_PCI_PSEUDO_IOPORTBASE +
2678 SISUSB_PCI_IOPORTBASE;
2679
2680 /* Write i/o ports
2681 * Byte, word and long(32) can be written. As this
2682 * emulates outX instructions, the data is expected
2683 * in machine-endianness.
2684 */
2685 switch (count) {
2686
2687 case 1:
2688 if (get_user(buf8, (u8 __user *)buffer))
2689 errno = -EFAULT;
2690 else if (sisusb_write_memio_byte(sisusb,
2691 SISUSB_TYPE_IO,
2692 address, buf8))
2693 errno = -EIO;
2694 else
2695 bytes_written = 1;
2696
2697 break;
2698
2699 case 2:
2700 if (get_user(buf16, (u16 __user *)buffer))
2701 errno = -EFAULT;
2702 else if (sisusb_write_memio_word(sisusb,
2703 SISUSB_TYPE_IO,
2704 address, buf16))
2705 errno = -EIO;
2706 else
2707 bytes_written = 2;
2708
2709 break;
2710
2711 case 4:
2712 if (get_user(buf32, (u32 __user *)buffer))
2713 errno = -EFAULT;
2714 else if (sisusb_write_memio_long(sisusb,
2715 SISUSB_TYPE_IO,
2716 address, buf32))
2717 errno = -EIO;
2718 else
2719 bytes_written = 4;
2720
2721 break;
2722
2723 default:
2724 errno = -EIO;
2725 }
2726
2727 } else if ((*ppos) >= SISUSB_PCI_PSEUDO_MEMBASE &&
2728 (*ppos) < SISUSB_PCI_PSEUDO_MEMBASE + sisusb->vramsize) {
2729
2730 address = (*ppos) -
2731 SISUSB_PCI_PSEUDO_MEMBASE +
2732 SISUSB_PCI_MEMBASE;
2733
2734 /* Write video ram.
2735 * Buffer is copied 1:1, therefore, on big-endian
2736 * machines, the data must be swapped by userland
2737 * in advance (if applicable; no swapping in 8bpp
2738 * mode or if YUV data is being transferred).
2739 */
2740 errno = sisusb_write_mem_bulk(sisusb, address, NULL,
2741 count, buffer, 0, &bytes_written);
2742
2743 if (bytes_written)
2744 errno = bytes_written;
2745
2746 } else if ((*ppos) >= SISUSB_PCI_PSEUDO_MMIOBASE &&
2747 (*ppos) < SISUSB_PCI_PSEUDO_MMIOBASE + SISUSB_PCI_MMIOSIZE) {
2748
2749 address = (*ppos) -
2750 SISUSB_PCI_PSEUDO_MMIOBASE +
2751 SISUSB_PCI_MMIOBASE;
2752
2753 /* Write MMIO.
2754 * Buffer is copied 1:1, therefore, on big-endian
2755 * machines, the data must be swapped by userland
2756 * in advance.
2757 */
2758 errno = sisusb_write_mem_bulk(sisusb, address, NULL,
2759 count, buffer, 0, &bytes_written);
2760
2761 if (bytes_written)
2762 errno = bytes_written;
2763
2764 } else if ((*ppos) >= SISUSB_PCI_PSEUDO_PCIBASE &&
2765 (*ppos) <= SISUSB_PCI_PSEUDO_PCIBASE + SISUSB_PCI_PCONFSIZE) {
2766
2767 if (count != 4) {
2768 mutex_unlock(&sisusb->lock);
2769 return -EINVAL;
2770 }
2771
2772 address = (*ppos) - SISUSB_PCI_PSEUDO_PCIBASE;
2773
2774 /* Write PCI config register.
2775 * Given value expected in machine endianness.
2776 */
2777 if (get_user(buf32, (u32 __user *)buffer))
2778 errno = -EFAULT;
2779 else if (sisusb_write_pci_config(sisusb, address, buf32))
2780 errno = -EIO;
2781 else
2782 bytes_written = 4;
2783
2784
2785 } else {
2786
2787 /* Error */
2788 errno = -EBADFD;
2789
2790 }
2791
2792 (*ppos) += bytes_written;
2793
2794 mutex_unlock(&sisusb->lock);
2795
2796 return errno ? errno : bytes_written;
2797 }
2798
2799 static loff_t
2800 sisusb_lseek(struct file *file, loff_t offset, int orig)
2801 {
2802 struct sisusb_usb_data *sisusb;
2803 loff_t ret;
2804
2805 if (!(sisusb = (struct sisusb_usb_data *)file->private_data))
2806 return -ENODEV;
2807
2808 mutex_lock(&sisusb->lock);
2809
2810 /* Sanity check */
2811 if (!sisusb->present || !sisusb->ready || !sisusb->sisusb_dev) {
2812 mutex_unlock(&sisusb->lock);
2813 return -ENODEV;
2814 }
2815
2816 switch (orig) {
2817 case 0:
2818 file->f_pos = offset;
2819 ret = file->f_pos;
2820 /* never negative, no force_successful_syscall needed */
2821 break;
2822 case 1:
2823 file->f_pos += offset;
2824 ret = file->f_pos;
2825 /* never negative, no force_successful_syscall needed */
2826 break;
2827 default:
2828 /* seeking relative to "end of file" is not supported */
2829 ret = -EINVAL;
2830 }
2831
2832 mutex_unlock(&sisusb->lock);
2833 return ret;
2834 }
2835
2836 static int
2837 sisusb_handle_command(struct sisusb_usb_data *sisusb, struct sisusb_command *y,
2838 unsigned long arg)
2839 {
2840 int retval, port, length;
2841 u32 address;
2842
2843 /* All our commands require the device
2844 * to be initialized.
2845 */
2846 if (!sisusb->devinit)
2847 return -ENODEV;
2848
2849 port = y->data3 -
2850 SISUSB_PCI_PSEUDO_IOPORTBASE +
2851 SISUSB_PCI_IOPORTBASE;
2852
2853 switch (y->operation) {
2854 case SUCMD_GET:
2855 retval = sisusb_getidxreg(sisusb, port,
2856 y->data0, &y->data1);
2857 if (!retval) {
2858 if (copy_to_user((void __user *)arg, y,
2859 sizeof(*y)))
2860 retval = -EFAULT;
2861 }
2862 break;
2863
2864 case SUCMD_SET:
2865 retval = sisusb_setidxreg(sisusb, port,
2866 y->data0, y->data1);
2867 break;
2868
2869 case SUCMD_SETOR:
2870 retval = sisusb_setidxregor(sisusb, port,
2871 y->data0, y->data1);
2872 break;
2873
2874 case SUCMD_SETAND:
2875 retval = sisusb_setidxregand(sisusb, port,
2876 y->data0, y->data1);
2877 break;
2878
2879 case SUCMD_SETANDOR:
2880 retval = sisusb_setidxregandor(sisusb, port,
2881 y->data0, y->data1, y->data2);
2882 break;
2883
2884 case SUCMD_SETMASK:
2885 retval = sisusb_setidxregmask(sisusb, port,
2886 y->data0, y->data1, y->data2);
2887 break;
2888
2889 case SUCMD_CLRSCR:
2890 /* Gfx core must be initialized */
2891 if (!sisusb->gfxinit)
2892 return -ENODEV;
2893
2894 length = (y->data0 << 16) | (y->data1 << 8) | y->data2;
2895 address = y->data3 -
2896 SISUSB_PCI_PSEUDO_MEMBASE +
2897 SISUSB_PCI_MEMBASE;
2898 retval = sisusb_clear_vram(sisusb, address, length);
2899 break;
2900
2901 case SUCMD_HANDLETEXTMODE:
2902 retval = 0;
2903 #ifdef INCL_SISUSB_CON
2904 /* Gfx core must be initialized, SiS_Pr must exist */
2905 if (!sisusb->gfxinit || !sisusb->SiS_Pr)
2906 return -ENODEV;
2907
2908 switch (y->data0) {
2909 case 0:
2910 retval = sisusb_reset_text_mode(sisusb, 0);
2911 break;
2912 case 1:
2913 sisusb->textmodedestroyed = 1;
2914 break;
2915 }
2916 #endif
2917 break;
2918
2919 #ifdef INCL_SISUSB_CON
2920 case SUCMD_SETMODE:
2921 /* Gfx core must be initialized, SiS_Pr must exist */
2922 if (!sisusb->gfxinit || !sisusb->SiS_Pr)
2923 return -ENODEV;
2924
2925 retval = 0;
2926
2927 sisusb->SiS_Pr->IOAddress = SISUSB_PCI_IOPORTBASE + 0x30;
2928 sisusb->SiS_Pr->sisusb = (void *)sisusb;
2929
2930 if (SiSUSBSetMode(sisusb->SiS_Pr, y->data3))
2931 retval = -EINVAL;
2932
2933 break;
2934
2935 case SUCMD_SETVESAMODE:
2936 /* Gfx core must be initialized, SiS_Pr must exist */
2937 if (!sisusb->gfxinit || !sisusb->SiS_Pr)
2938 return -ENODEV;
2939
2940 retval = 0;
2941
2942 sisusb->SiS_Pr->IOAddress = SISUSB_PCI_IOPORTBASE + 0x30;
2943 sisusb->SiS_Pr->sisusb = (void *)sisusb;
2944
2945 if (SiSUSBSetVESAMode(sisusb->SiS_Pr, y->data3))
2946 retval = -EINVAL;
2947
2948 break;
2949 #endif
2950
2951 default:
2952 retval = -EINVAL;
2953 }
2954
2955 if (retval > 0)
2956 retval = -EIO;
2957
2958 return retval;
2959 }
2960
2961 static long
2962 sisusb_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
2963 {
2964 struct sisusb_usb_data *sisusb;
2965 struct sisusb_info x;
2966 struct sisusb_command y;
2967 int retval = 0;
2968 u32 __user *argp = (u32 __user *)arg;
2969
2970 if (!(sisusb = (struct sisusb_usb_data *)file->private_data))
2971 return -ENODEV;
2972
2973 lock_kernel();
2974 mutex_lock(&sisusb->lock);
2975
2976 /* Sanity check */
2977 if (!sisusb->present || !sisusb->ready || !sisusb->sisusb_dev) {
2978 retval = -ENODEV;
2979 goto err_out;
2980 }
2981
2982 switch (cmd) {
2983
2984 case SISUSB_GET_CONFIG_SIZE:
2985
2986 if (put_user(sizeof(x), argp))
2987 retval = -EFAULT;
2988
2989 break;
2990
2991 case SISUSB_GET_CONFIG:
2992
2993 x.sisusb_id = SISUSB_ID;
2994 x.sisusb_version = SISUSB_VERSION;
2995 x.sisusb_revision = SISUSB_REVISION;
2996 x.sisusb_patchlevel = SISUSB_PATCHLEVEL;
2997 x.sisusb_gfxinit = sisusb->gfxinit;
2998 x.sisusb_vrambase = SISUSB_PCI_PSEUDO_MEMBASE;
2999 x.sisusb_mmiobase = SISUSB_PCI_PSEUDO_MMIOBASE;
3000 x.sisusb_iobase = SISUSB_PCI_PSEUDO_IOPORTBASE;
3001 x.sisusb_pcibase = SISUSB_PCI_PSEUDO_PCIBASE;
3002 x.sisusb_vramsize = sisusb->vramsize;
3003 x.sisusb_minor = sisusb->minor;
3004 x.sisusb_fbdevactive= 0;
3005 #ifdef INCL_SISUSB_CON
3006 x.sisusb_conactive = sisusb->haveconsole ? 1 : 0;
3007 #else
3008 x.sisusb_conactive = 0;
3009 #endif
3010
3011 if (copy_to_user((void __user *)arg, &x, sizeof(x)))
3012 retval = -EFAULT;
3013
3014 break;
3015
3016 case SISUSB_COMMAND:
3017
3018 if (copy_from_user(&y, (void __user *)arg, sizeof(y)))
3019 retval = -EFAULT;
3020 else
3021 retval = sisusb_handle_command(sisusb, &y, arg);
3022
3023 break;
3024
3025 default:
3026 retval = -ENOTTY;
3027 break;
3028 }
3029
3030 err_out:
3031 mutex_unlock(&sisusb->lock);
3032 unlock_kernel();
3033 return retval;
3034 }
3035
3036 #ifdef SISUSB_NEW_CONFIG_COMPAT
3037 static long
3038 sisusb_compat_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
3039 {
3040 long retval;
3041
3042 switch (cmd) {
3043 case SISUSB_GET_CONFIG_SIZE:
3044 case SISUSB_GET_CONFIG:
3045 case SISUSB_COMMAND:
3046 retval = sisusb_ioctl(f, cmd, arg);
3047 return retval;
3048
3049 default:
3050 return -ENOIOCTLCMD;
3051 }
3052 }
3053 #endif
3054
3055 static const struct file_operations usb_sisusb_fops = {
3056 .owner = THIS_MODULE,
3057 .open = sisusb_open,
3058 .release = sisusb_release,
3059 .read = sisusb_read,
3060 .write = sisusb_write,
3061 .llseek = sisusb_lseek,
3062 #ifdef SISUSB_NEW_CONFIG_COMPAT
3063 .compat_ioctl = sisusb_compat_ioctl,
3064 #endif
3065 .unlocked_ioctl = sisusb_ioctl
3066 };
3067
3068 static struct usb_class_driver usb_sisusb_class = {
3069 .name = "sisusbvga%d",
3070 .fops = &usb_sisusb_fops,
3071 .minor_base = SISUSB_MINOR
3072 };
3073
3074 static int sisusb_probe(struct usb_interface *intf,
3075 const struct usb_device_id *id)
3076 {
3077 struct usb_device *dev = interface_to_usbdev(intf);
3078 struct sisusb_usb_data *sisusb;
3079 int retval = 0, i;
3080
3081 dev_info(&dev->dev, "USB2VGA dongle found at address %d\n",
3082 dev->devnum);
3083
3084 /* Allocate memory for our private */
3085 if (!(sisusb = kzalloc(sizeof(*sisusb), GFP_KERNEL))) {
3086 dev_err(&sisusb->sisusb_dev->dev, "Failed to allocate memory for private data\n");
3087 return -ENOMEM;
3088 }
3089 kref_init(&sisusb->kref);
3090
3091 mutex_init(&(sisusb->lock));
3092
3093 /* Register device */
3094 if ((retval = usb_register_dev(intf, &usb_sisusb_class))) {
3095 dev_err(&sisusb->sisusb_dev->dev, "Failed to get a minor for device %d\n",
3096 dev->devnum);
3097 retval = -ENODEV;
3098 goto error_1;
3099 }
3100
3101 sisusb->sisusb_dev = dev;
3102 sisusb->minor = intf->minor;
3103 sisusb->vrambase = SISUSB_PCI_MEMBASE;
3104 sisusb->mmiobase = SISUSB_PCI_MMIOBASE;
3105 sisusb->mmiosize = SISUSB_PCI_MMIOSIZE;
3106 sisusb->ioportbase = SISUSB_PCI_IOPORTBASE;
3107 /* Everything else is zero */
3108
3109 /* Allocate buffers */
3110 sisusb->ibufsize = SISUSB_IBUF_SIZE;
3111 if (!(sisusb->ibuf = kmalloc(SISUSB_IBUF_SIZE, GFP_KERNEL))) {
3112 dev_err(&sisusb->sisusb_dev->dev, "Failed to allocate memory for input buffer");
3113 retval = -ENOMEM;
3114 goto error_2;
3115 }
3116
3117 sisusb->numobufs = 0;
3118 sisusb->obufsize = SISUSB_OBUF_SIZE;
3119 for (i = 0; i < NUMOBUFS; i++) {
3120 if (!(sisusb->obuf[i] = kmalloc(SISUSB_OBUF_SIZE, GFP_KERNEL))) {
3121 if (i == 0) {
3122 dev_err(&sisusb->sisusb_dev->dev, "Failed to allocate memory for output buffer\n");
3123 retval = -ENOMEM;
3124 goto error_3;
3125 }
3126 break;
3127 } else
3128 sisusb->numobufs++;
3129
3130 }
3131
3132 /* Allocate URBs */
3133 if (!(sisusb->sisurbin = usb_alloc_urb(0, GFP_KERNEL))) {
3134 dev_err(&sisusb->sisusb_dev->dev, "Failed to allocate URBs\n");
3135 retval = -ENOMEM;
3136 goto error_3;
3137 }
3138 sisusb->completein = 1;
3139
3140 for (i = 0; i < sisusb->numobufs; i++) {
3141 if (!(sisusb->sisurbout[i] = usb_alloc_urb(0, GFP_KERNEL))) {
3142 dev_err(&sisusb->sisusb_dev->dev, "Failed to allocate URBs\n");
3143 retval = -ENOMEM;
3144 goto error_4;
3145 }
3146 sisusb->urbout_context[i].sisusb = (void *)sisusb;
3147 sisusb->urbout_context[i].urbindex = i;
3148 sisusb->urbstatus[i] = 0;
3149 }
3150
3151 dev_info(&sisusb->sisusb_dev->dev, "Allocated %d output buffers\n", sisusb->numobufs);
3152
3153 #ifdef INCL_SISUSB_CON
3154 /* Allocate our SiS_Pr */
3155 if (!(sisusb->SiS_Pr = kmalloc(sizeof(struct SiS_Private), GFP_KERNEL))) {
3156 dev_err(&sisusb->sisusb_dev->dev, "Failed to allocate SiS_Pr\n");
3157 }
3158 #endif
3159
3160 /* Do remaining init stuff */
3161
3162 init_waitqueue_head(&sisusb->wait_q);
3163
3164 usb_set_intfdata(intf, sisusb);
3165
3166 usb_get_dev(sisusb->sisusb_dev);
3167
3168 sisusb->present = 1;
3169
3170 if (dev->speed == USB_SPEED_HIGH) {
3171 int initscreen = 1;
3172 #ifdef INCL_SISUSB_CON
3173 if (sisusb_first_vc > 0 &&
3174 sisusb_last_vc > 0 &&
3175 sisusb_first_vc <= sisusb_last_vc &&
3176 sisusb_last_vc <= MAX_NR_CONSOLES)
3177 initscreen = 0;
3178 #endif
3179 if (sisusb_init_gfxdevice(sisusb, initscreen))
3180 dev_err(&sisusb->sisusb_dev->dev, "Failed to early initialize device\n");
3181
3182 } else
3183 dev_info(&sisusb->sisusb_dev->dev, "Not attached to USB 2.0 hub, deferring init\n");
3184
3185 sisusb->ready = 1;
3186
3187 #ifdef SISUSBENDIANTEST
3188 dev_dbg(&sisusb->sisusb_dev->dev, "*** RWTEST ***\n");
3189 sisusb_testreadwrite(sisusb);
3190 dev_dbg(&sisusb->sisusb_dev->dev, "*** RWTEST END ***\n");
3191 #endif
3192
3193 #ifdef INCL_SISUSB_CON
3194 sisusb_console_init(sisusb, sisusb_first_vc, sisusb_last_vc);
3195 #endif
3196
3197 return 0;
3198
3199 error_4:
3200 sisusb_free_urbs(sisusb);
3201 error_3:
3202 sisusb_free_buffers(sisusb);
3203 error_2:
3204 usb_deregister_dev(intf, &usb_sisusb_class);
3205 error_1:
3206 kfree(sisusb);
3207 return retval;
3208 }
3209
3210 static void sisusb_disconnect(struct usb_interface *intf)
3211 {
3212 struct sisusb_usb_data *sisusb;
3213
3214 /* This should *not* happen */
3215 if (!(sisusb = usb_get_intfdata(intf)))
3216 return;
3217
3218 #ifdef INCL_SISUSB_CON
3219 sisusb_console_exit(sisusb);
3220 #endif
3221
3222 usb_deregister_dev(intf, &usb_sisusb_class);
3223
3224 mutex_lock(&sisusb->lock);
3225
3226 /* Wait for all URBs to complete and kill them in case (MUST do) */
3227 if (!sisusb_wait_all_out_complete(sisusb))
3228 sisusb_kill_all_busy(sisusb);
3229
3230 usb_set_intfdata(intf, NULL);
3231
3232 sisusb->present = 0;
3233 sisusb->ready = 0;
3234
3235 mutex_unlock(&sisusb->lock);
3236
3237 /* decrement our usage count */
3238 kref_put(&sisusb->kref, sisusb_delete);
3239 }
3240
3241 static struct usb_device_id sisusb_table [] = {
3242 { USB_DEVICE(0x0711, 0x0550) },
3243 { USB_DEVICE(0x0711, 0x0900) },
3244 { USB_DEVICE(0x0711, 0x0901) },
3245 { USB_DEVICE(0x0711, 0x0902) },
3246 { USB_DEVICE(0x0711, 0x0903) },
3247 { USB_DEVICE(0x0711, 0x0918) },
3248 { USB_DEVICE(0x182d, 0x021c) },
3249 { USB_DEVICE(0x182d, 0x0269) },
3250 { }
3251 };
3252
3253 MODULE_DEVICE_TABLE (usb, sisusb_table);
3254
3255 static struct usb_driver sisusb_driver = {
3256 .name = "sisusb",
3257 .probe = sisusb_probe,
3258 .disconnect = sisusb_disconnect,
3259 .id_table = sisusb_table,
3260 };
3261
3262 static int __init usb_sisusb_init(void)
3263 {
3264
3265 #ifdef INCL_SISUSB_CON
3266 sisusb_init_concode();
3267 #endif
3268
3269 return usb_register(&sisusb_driver);
3270 }
3271
3272 static void __exit usb_sisusb_exit(void)
3273 {
3274 usb_deregister(&sisusb_driver);
3275 }
3276
3277 module_init(usb_sisusb_init);
3278 module_exit(usb_sisusb_exit);
3279
3280 MODULE_AUTHOR("Thomas Winischhofer <thomas@winischhofer.net>");
3281 MODULE_DESCRIPTION("sisusbvga - Driver for Net2280/SiS315-based USB2VGA dongles");
3282 MODULE_LICENSE("GPL");
3283
Verdex Pro support