diff options
author | Linus Torvalds <torvalds@ppc970.osdl.org> | 2005-04-16 18:20:36 -0400 |
---|---|---|
committer | Linus Torvalds <torvalds@ppc970.osdl.org> | 2005-04-16 18:20:36 -0400 |
commit | 1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 (patch) | |
tree | 0bba044c4ce775e45a88a51686b5d9f90697ea9d /drivers/video/hpfb.c |
Linux-2.6.12-rc2
Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.
Let it rip!
Diffstat (limited to 'drivers/video/hpfb.c')
-rw-r--r-- | drivers/video/hpfb.c | 416 |
1 files changed, 416 insertions, 0 deletions
diff --git a/drivers/video/hpfb.c b/drivers/video/hpfb.c new file mode 100644 index 00000000000..e97fe8481d5 --- /dev/null +++ b/drivers/video/hpfb.c | |||
@@ -0,0 +1,416 @@ | |||
1 | /* | ||
2 | * HP300 Topcat framebuffer support (derived from macfb of all things) | ||
3 | * Phil Blundell <philb@gnu.org> 1998 | ||
4 | * DIO-II, colour map and Catseye support by | ||
5 | * Kars de Jong <jongk@linux-m68k.org>, May 2004. | ||
6 | */ | ||
7 | |||
8 | #include <linux/module.h> | ||
9 | #include <linux/kernel.h> | ||
10 | #include <linux/sched.h> | ||
11 | #include <linux/errno.h> | ||
12 | #include <linux/string.h> | ||
13 | #include <linux/mm.h> | ||
14 | #include <linux/tty.h> | ||
15 | #include <linux/slab.h> | ||
16 | #include <linux/delay.h> | ||
17 | #include <linux/init.h> | ||
18 | #include <linux/fb.h> | ||
19 | #include <linux/dio.h> | ||
20 | |||
21 | #include <asm/io.h> | ||
22 | #include <asm/uaccess.h> | ||
23 | |||
24 | static struct fb_info fb_info = { | ||
25 | .fix = { | ||
26 | .id = "HP300 ", | ||
27 | .type = FB_TYPE_PACKED_PIXELS, | ||
28 | .visual = FB_VISUAL_PSEUDOCOLOR, | ||
29 | .accel = FB_ACCEL_NONE, | ||
30 | } | ||
31 | }; | ||
32 | |||
33 | static unsigned long fb_regs; | ||
34 | static unsigned char fb_bitmask; | ||
35 | |||
36 | #define TC_NBLANK 0x4080 | ||
37 | #define TC_WEN 0x4088 | ||
38 | #define TC_REN 0x408c | ||
39 | #define TC_FBEN 0x4090 | ||
40 | #define TC_PRR 0x40ea | ||
41 | |||
42 | /* These defines match the X window system */ | ||
43 | #define RR_CLEAR 0x0 | ||
44 | #define RR_COPY 0x3 | ||
45 | #define RR_NOOP 0x5 | ||
46 | #define RR_XOR 0x6 | ||
47 | #define RR_INVERT 0xa | ||
48 | #define RR_COPYINVERTED 0xc | ||
49 | #define RR_SET 0xf | ||
50 | |||
51 | /* blitter regs */ | ||
52 | #define BUSY 0x4044 | ||
53 | #define WMRR 0x40ef | ||
54 | #define SOURCE_X 0x40f2 | ||
55 | #define SOURCE_Y 0x40f6 | ||
56 | #define DEST_X 0x40fa | ||
57 | #define DEST_Y 0x40fe | ||
58 | #define WHEIGHT 0x4106 | ||
59 | #define WWIDTH 0x4102 | ||
60 | #define WMOVE 0x409c | ||
61 | |||
62 | static struct fb_var_screeninfo hpfb_defined = { | ||
63 | .red = { | ||
64 | .length = 8, | ||
65 | }, | ||
66 | .green = { | ||
67 | .length = 8, | ||
68 | }, | ||
69 | .blue = { | ||
70 | .length = 8, | ||
71 | }, | ||
72 | .activate = FB_ACTIVATE_NOW, | ||
73 | .height = -1, | ||
74 | .width = -1, | ||
75 | .vmode = FB_VMODE_NONINTERLACED, | ||
76 | }; | ||
77 | |||
78 | static int hpfb_setcolreg(unsigned regno, unsigned red, unsigned green, | ||
79 | unsigned blue, unsigned transp, | ||
80 | struct fb_info *info) | ||
81 | { | ||
82 | /* use MSBs */ | ||
83 | unsigned char _red =red>>8; | ||
84 | unsigned char _green=green>>8; | ||
85 | unsigned char _blue =blue>>8; | ||
86 | unsigned char _regno=regno; | ||
87 | |||
88 | /* | ||
89 | * Set a single color register. The values supplied are | ||
90 | * already rounded down to the hardware's capabilities | ||
91 | * (according to the entries in the `var' structure). Return | ||
92 | * != 0 for invalid regno. | ||
93 | */ | ||
94 | |||
95 | if (regno >= info->cmap.len) | ||
96 | return 1; | ||
97 | |||
98 | while (in_be16(fb_regs + 0x6002) & 0x4) udelay(1); | ||
99 | |||
100 | out_be16(fb_regs + 0x60ba, 0xff); | ||
101 | |||
102 | out_be16(fb_regs + 0x60b2, _red); | ||
103 | out_be16(fb_regs + 0x60b4, _green); | ||
104 | out_be16(fb_regs + 0x60b6, _blue); | ||
105 | out_be16(fb_regs + 0x60b8, ~_regno); | ||
106 | out_be16(fb_regs + 0x60f0, 0xff); | ||
107 | |||
108 | udelay(100); | ||
109 | |||
110 | while (in_be16(fb_regs + 0x6002) & 0x4) udelay(1); | ||
111 | out_be16(fb_regs + 0x60b2, 0); | ||
112 | out_be16(fb_regs + 0x60b4, 0); | ||
113 | out_be16(fb_regs + 0x60b6, 0); | ||
114 | out_be16(fb_regs + 0x60b8, 0); | ||
115 | |||
116 | return 0; | ||
117 | } | ||
118 | |||
119 | /* 0 unblank, 1 blank, 2 no vsync, 3 no hsync, 4 off */ | ||
120 | |||
121 | static int hpfb_blank(int blank, struct fb_info *info) | ||
122 | { | ||
123 | out_8(fb_regs + TC_NBLANK, (blank ? 0x00 : fb_bitmask)); | ||
124 | |||
125 | return 0; | ||
126 | } | ||
127 | |||
128 | static void topcat_blit(int x0, int y0, int x1, int y1, int w, int h, int rr) | ||
129 | { | ||
130 | if (rr >= 0) { | ||
131 | while (in_8(fb_regs + BUSY) & fb_bitmask) | ||
132 | ; | ||
133 | } | ||
134 | out_8(fb_regs + TC_FBEN, fb_bitmask); | ||
135 | if (rr >= 0) { | ||
136 | out_8(fb_regs + TC_WEN, fb_bitmask); | ||
137 | out_8(fb_regs + WMRR, rr); | ||
138 | } | ||
139 | out_be16(fb_regs + SOURCE_X, x0); | ||
140 | out_be16(fb_regs + SOURCE_Y, y0); | ||
141 | out_be16(fb_regs + DEST_X, x1); | ||
142 | out_be16(fb_regs + DEST_Y, y1); | ||
143 | out_be16(fb_regs + WWIDTH, w); | ||
144 | out_be16(fb_regs + WHEIGHT, h); | ||
145 | out_8(fb_regs + WMOVE, fb_bitmask); | ||
146 | } | ||
147 | |||
148 | static void hpfb_copyarea(struct fb_info *info, const struct fb_copyarea *area) | ||
149 | { | ||
150 | topcat_blit(area->sx, area->sy, area->dx, area->dy, area->width, area->height, RR_COPY); | ||
151 | } | ||
152 | |||
153 | static void hpfb_fillrect(struct fb_info *p, const struct fb_fillrect *region) | ||
154 | { | ||
155 | u8 clr; | ||
156 | |||
157 | clr = region->color & 0xff; | ||
158 | |||
159 | while (in_8(fb_regs + BUSY) & fb_bitmask) | ||
160 | ; | ||
161 | |||
162 | /* Foreground */ | ||
163 | out_8(fb_regs + TC_WEN, fb_bitmask & clr); | ||
164 | out_8(fb_regs + WMRR, (region->rop == ROP_COPY ? RR_SET : RR_INVERT)); | ||
165 | |||
166 | /* Background */ | ||
167 | out_8(fb_regs + TC_WEN, fb_bitmask & ~clr); | ||
168 | out_8(fb_regs + WMRR, (region->rop == ROP_COPY ? RR_CLEAR : RR_NOOP)); | ||
169 | |||
170 | topcat_blit(region->dx, region->dy, region->dx, region->dy, region->width, region->height, -1); | ||
171 | } | ||
172 | |||
173 | static int hpfb_sync(struct fb_info *info) | ||
174 | { | ||
175 | /* | ||
176 | * Since we also access the framebuffer directly, we have to wait | ||
177 | * until the block mover is finished | ||
178 | */ | ||
179 | while (in_8(fb_regs + BUSY) & fb_bitmask) | ||
180 | ; | ||
181 | |||
182 | out_8(fb_regs + TC_WEN, fb_bitmask); | ||
183 | out_8(fb_regs + TC_PRR, RR_COPY); | ||
184 | out_8(fb_regs + TC_FBEN, fb_bitmask); | ||
185 | |||
186 | return 0; | ||
187 | } | ||
188 | |||
189 | static struct fb_ops hpfb_ops = { | ||
190 | .owner = THIS_MODULE, | ||
191 | .fb_setcolreg = hpfb_setcolreg, | ||
192 | .fb_blank = hpfb_blank, | ||
193 | .fb_fillrect = hpfb_fillrect, | ||
194 | .fb_copyarea = hpfb_copyarea, | ||
195 | .fb_imageblit = cfb_imageblit, | ||
196 | .fb_cursor = soft_cursor, | ||
197 | .fb_sync = hpfb_sync, | ||
198 | }; | ||
199 | |||
200 | /* Common to all HP framebuffers */ | ||
201 | #define HPFB_FBWMSB 0x05 /* Frame buffer width */ | ||
202 | #define HPFB_FBWLSB 0x07 | ||
203 | #define HPFB_FBHMSB 0x09 /* Frame buffer height */ | ||
204 | #define HPFB_FBHLSB 0x0b | ||
205 | #define HPFB_DWMSB 0x0d /* Display width */ | ||
206 | #define HPFB_DWLSB 0x0f | ||
207 | #define HPFB_DHMSB 0x11 /* Display height */ | ||
208 | #define HPFB_DHLSB 0x13 | ||
209 | #define HPFB_NUMPLANES 0x5b /* Number of colour planes */ | ||
210 | #define HPFB_FBOMSB 0x5d /* Frame buffer offset */ | ||
211 | #define HPFB_FBOLSB 0x5f | ||
212 | |||
213 | static int __init hpfb_init_one(unsigned long phys_base, unsigned long virt_base) | ||
214 | { | ||
215 | unsigned long fboff, fb_width, fb_height, fb_start; | ||
216 | |||
217 | fb_regs = virt_base; | ||
218 | fboff = (in_8(fb_regs + HPFB_FBOMSB) << 8) | in_8(fb_regs + HPFB_FBOLSB); | ||
219 | |||
220 | fb_info.fix.smem_start = (in_8(fb_regs + fboff) << 16); | ||
221 | |||
222 | if (phys_base >= DIOII_BASE) { | ||
223 | fb_info.fix.smem_start += phys_base; | ||
224 | } | ||
225 | |||
226 | if (DIO_SECID(fb_regs) != DIO_ID2_TOPCAT) { | ||
227 | /* This is the magic incantation the HP X server uses to make Catseye boards work. */ | ||
228 | while (in_be16(fb_regs+0x4800) & 1) | ||
229 | ; | ||
230 | out_be16(fb_regs+0x4800, 0); /* Catseye status */ | ||
231 | out_be16(fb_regs+0x4510, 0); /* VB */ | ||
232 | out_be16(fb_regs+0x4512, 0); /* TCNTRL */ | ||
233 | out_be16(fb_regs+0x4514, 0); /* ACNTRL */ | ||
234 | out_be16(fb_regs+0x4516, 0); /* PNCNTRL */ | ||
235 | out_be16(fb_regs+0x4206, 0x90); /* RUG Command/Status */ | ||
236 | out_be16(fb_regs+0x60a2, 0); /* Overlay Mask */ | ||
237 | out_be16(fb_regs+0x60bc, 0); /* Ram Select */ | ||
238 | } | ||
239 | |||
240 | /* | ||
241 | * Fill in the available video resolution | ||
242 | */ | ||
243 | fb_width = (in_8(fb_regs + HPFB_FBWMSB) << 8) | in_8(fb_regs + HPFB_FBWLSB); | ||
244 | fb_info.fix.line_length = fb_width; | ||
245 | fb_height = (in_8(fb_regs + HPFB_FBHMSB) << 8) | in_8(fb_regs + HPFB_FBHLSB); | ||
246 | fb_info.fix.smem_len = fb_width * fb_height; | ||
247 | fb_start = (unsigned long)ioremap_writethrough(fb_info.fix.smem_start, | ||
248 | fb_info.fix.smem_len); | ||
249 | hpfb_defined.xres = (in_8(fb_regs + HPFB_DWMSB) << 8) | in_8(fb_regs + HPFB_DWLSB); | ||
250 | hpfb_defined.yres = (in_8(fb_regs + HPFB_DHMSB) << 8) | in_8(fb_regs + HPFB_DHLSB); | ||
251 | hpfb_defined.xres_virtual = hpfb_defined.xres; | ||
252 | hpfb_defined.yres_virtual = hpfb_defined.yres; | ||
253 | hpfb_defined.bits_per_pixel = in_8(fb_regs + HPFB_NUMPLANES); | ||
254 | |||
255 | printk(KERN_INFO "hpfb: framebuffer at 0x%lx, mapped to 0x%lx, size %dk\n", | ||
256 | fb_info.fix.smem_start, fb_start, fb_info.fix.smem_len/1024); | ||
257 | printk(KERN_INFO "hpfb: mode is %dx%dx%d, linelength=%d\n", | ||
258 | hpfb_defined.xres, hpfb_defined.yres, hpfb_defined.bits_per_pixel, fb_info.fix.line_length); | ||
259 | |||
260 | /* | ||
261 | * Give the hardware a bit of a prod and work out how many bits per | ||
262 | * pixel are supported. | ||
263 | */ | ||
264 | out_8(fb_regs + TC_WEN, 0xff); | ||
265 | out_8(fb_regs + TC_PRR, RR_COPY); | ||
266 | out_8(fb_regs + TC_FBEN, 0xff); | ||
267 | out_8(fb_start, 0xff); | ||
268 | fb_bitmask = in_8(fb_start); | ||
269 | out_8(fb_start, 0); | ||
270 | |||
271 | /* | ||
272 | * Enable reading/writing of all the planes. | ||
273 | */ | ||
274 | out_8(fb_regs + TC_WEN, fb_bitmask); | ||
275 | out_8(fb_regs + TC_PRR, RR_COPY); | ||
276 | out_8(fb_regs + TC_REN, fb_bitmask); | ||
277 | out_8(fb_regs + TC_FBEN, fb_bitmask); | ||
278 | |||
279 | /* | ||
280 | * Clear the screen. | ||
281 | */ | ||
282 | topcat_blit(0, 0, 0, 0, fb_width, fb_height, RR_CLEAR); | ||
283 | |||
284 | /* | ||
285 | * Let there be consoles.. | ||
286 | */ | ||
287 | if (DIO_SECID(fb_regs) == DIO_ID2_TOPCAT) | ||
288 | strcat(fb_info.fix.id, "Topcat"); | ||
289 | else | ||
290 | strcat(fb_info.fix.id, "Catseye"); | ||
291 | fb_info.fbops = &hpfb_ops; | ||
292 | fb_info.flags = FBINFO_DEFAULT; | ||
293 | fb_info.var = hpfb_defined; | ||
294 | fb_info.screen_base = (char *)fb_start; | ||
295 | |||
296 | fb_alloc_cmap(&fb_info.cmap, 1 << hpfb_defined.bits_per_pixel, 0); | ||
297 | |||
298 | if (register_framebuffer(&fb_info) < 0) { | ||
299 | fb_dealloc_cmap(&fb_info.cmap); | ||
300 | return 1; | ||
301 | } | ||
302 | |||
303 | printk(KERN_INFO "fb%d: %s frame buffer device\n", | ||
304 | fb_info.node, fb_info.fix.id); | ||
305 | |||
306 | return 0; | ||
307 | } | ||
308 | |||
309 | /* | ||
310 | * Check that the secondary ID indicates that we have some hope of working with this | ||
311 | * framebuffer. The catseye boards are pretty much like topcats and we can muddle through. | ||
312 | */ | ||
313 | |||
314 | #define topcat_sid_ok(x) (((x) == DIO_ID2_LRCATSEYE) || ((x) == DIO_ID2_HRCCATSEYE) \ | ||
315 | || ((x) == DIO_ID2_HRMCATSEYE) || ((x) == DIO_ID2_TOPCAT)) | ||
316 | |||
317 | /* | ||
318 | * Initialise the framebuffer | ||
319 | */ | ||
320 | static int __devinit hpfb_dio_probe(struct dio_dev * d, const struct dio_device_id * ent) | ||
321 | { | ||
322 | unsigned long paddr, vaddr; | ||
323 | |||
324 | paddr = d->resource.start; | ||
325 | if (!request_mem_region(d->resource.start, d->resource.end - d->resource.start, d->name)) | ||
326 | return -EBUSY; | ||
327 | |||
328 | if (d->scode >= DIOII_SCBASE) { | ||
329 | vaddr = (unsigned long)ioremap(paddr, d->resource.end - d->resource.start); | ||
330 | } else { | ||
331 | vaddr = paddr + DIO_VIRADDRBASE; | ||
332 | } | ||
333 | printk(KERN_INFO "Topcat found at DIO select code %d " | ||
334 | "(secondary id %02x)\n", d->scode, (d->id >> 8) & 0xff); | ||
335 | if (hpfb_init_one(paddr, vaddr)) { | ||
336 | if (d->scode >= DIOII_SCBASE) | ||
337 | iounmap((void *)vaddr); | ||
338 | return -ENOMEM; | ||
339 | } | ||
340 | return 0; | ||
341 | } | ||
342 | |||
343 | static void __devexit hpfb_remove_one(struct dio_dev *d) | ||
344 | { | ||
345 | unregister_framebuffer(&fb_info); | ||
346 | if (d->scode >= DIOII_SCBASE) | ||
347 | iounmap((void *)fb_regs); | ||
348 | release_mem_region(d->resource.start, d->resource.end - d->resource.start); | ||
349 | } | ||
350 | |||
351 | static struct dio_device_id hpfb_dio_tbl[] = { | ||
352 | { DIO_ENCODE_ID(DIO_ID_FBUFFER, DIO_ID2_LRCATSEYE) }, | ||
353 | { DIO_ENCODE_ID(DIO_ID_FBUFFER, DIO_ID2_HRCCATSEYE) }, | ||
354 | { DIO_ENCODE_ID(DIO_ID_FBUFFER, DIO_ID2_HRMCATSEYE) }, | ||
355 | { DIO_ENCODE_ID(DIO_ID_FBUFFER, DIO_ID2_TOPCAT) }, | ||
356 | { 0 } | ||
357 | }; | ||
358 | |||
359 | static struct dio_driver hpfb_driver = { | ||
360 | .name = "hpfb", | ||
361 | .id_table = hpfb_dio_tbl, | ||
362 | .probe = hpfb_dio_probe, | ||
363 | .remove = __devexit_p(hpfb_remove_one), | ||
364 | }; | ||
365 | |||
366 | int __init hpfb_init(void) | ||
367 | { | ||
368 | unsigned int sid; | ||
369 | mm_segment_t fs; | ||
370 | unsigned char i; | ||
371 | int err; | ||
372 | |||
373 | /* Topcats can be on the internal IO bus or real DIO devices. | ||
374 | * The internal variant sits at 0x560000; it has primary | ||
375 | * and secondary ID registers just like the DIO version. | ||
376 | * So we merge the two detection routines. | ||
377 | * | ||
378 | * Perhaps this #define should be in a global header file: | ||
379 | * I believe it's common to all internal fbs, not just topcat. | ||
380 | */ | ||
381 | #define INTFBVADDR 0xf0560000 | ||
382 | #define INTFBPADDR 0x560000 | ||
383 | |||
384 | if (!MACH_IS_HP300) | ||
385 | return -ENXIO; | ||
386 | |||
387 | if (fb_get_options("hpfb", NULL)) | ||
388 | return -ENODEV; | ||
389 | |||
390 | dio_module_init(&hpfb_driver); | ||
391 | |||
392 | fs = get_fs(); | ||
393 | set_fs(KERNEL_DS); | ||
394 | err = get_user(i, (unsigned char *)INTFBVADDR + DIO_IDOFF); | ||
395 | set_fs(fs); | ||
396 | |||
397 | if (!err && (i == DIO_ID_FBUFFER) && topcat_sid_ok(sid = DIO_SECID(INTFBVADDR))) { | ||
398 | if (!request_mem_region(INTFBPADDR, DIO_DEVSIZE, "Internal Topcat")) | ||
399 | return -EBUSY; | ||
400 | printk(KERN_INFO "Internal Topcat found (secondary id %02x)\n", sid); | ||
401 | if (hpfb_init_one(INTFBPADDR, INTFBVADDR)) { | ||
402 | return -ENOMEM; | ||
403 | } | ||
404 | } | ||
405 | return 0; | ||
406 | } | ||
407 | |||
408 | void __exit hpfb_cleanup_module(void) | ||
409 | { | ||
410 | dio_unregister_driver(&hpfb_driver); | ||
411 | } | ||
412 | |||
413 | module_init(hpfb_init); | ||
414 | module_exit(hpfb_cleanup_module); | ||
415 | |||
416 | MODULE_LICENSE("GPL"); | ||