macusbdb/kernel_driver/macusbfb.c
2017-04-17 11:43:10 -07:00

536 lines
13 KiB
C

/*
Framebuffer driver for the USB Macintosh display adapter
Copyright (C) 2010 Jeroen Domburg
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/usb.h>
#include <linux/fb.h>
#include <linux/mm.h>
#include <linux/vmalloc.h>
#include <asm/atomic.h>
#define DRIVER_AUTHOR "Jeroen Domburg, jeroen@spritesmods.com"
#define DRIVER_DESC "Mac-display USB framebuffer driver"
#define VENDOR_ID 0x1234
#define PRODUCT_ID 0x55aa
#define MACFB_HEIGHT 342
#define MACFB_WIDTH 512
#define usb_buffer_alloc usb_alloc_coherent
#define usb_buffer_free usb_free_coherent
#define BUF_MAX_SIZE 32768
/* table of devices that work with this driver */
static struct usb_device_id id_table [] = {
{ USB_DEVICE(VENDOR_ID, PRODUCT_ID) },
{ },
};
MODULE_DEVICE_TABLE (usb, id_table);
struct macusbfbdev {
struct usb_device * udev;
struct fb_info * fbinfo;
unsigned char *fb;
unsigned char *pixels;
unsigned char *oldpixels;
unsigned char *xferbuff;
dma_addr_t xferbuffDmaAddr;
struct usb_anchor submitted;
int gpioVals;
atomic_t writeInProgress;
atomic_t changedWhileWriting;
};
static struct fb_fix_screeninfo macusbfb_fbfix __initdata = {
.id = "macusbfb",
.type = FB_TYPE_PACKED_PIXELS,
.visual = FB_VISUAL_TRUECOLOR,
.line_length = MACFB_WIDTH*2,
.accel = FB_ACCEL_NONE,
};
static struct fb_var_screeninfo macusbfb_fbvar __initdata = {
.xres = MACFB_WIDTH,
.yres = MACFB_HEIGHT,
.xres_virtual = MACFB_WIDTH,
.yres_virtual = MACFB_HEIGHT,
.bits_per_pixel = 16,
.red = { 11, 5, 0 },
.green = { 4, 6, 0 },
.blue = { 0, 5, 0 },
.left_margin = 0,
.right_margin = 0,
.upper_margin = 0,
.lower_margin = 0,
.vmode = FB_VMODE_NONINTERLACED,
};
static void sendFramebufferOver(struct fb_info *info);
static void macusbfb_write_bulk_callback(struct urb *urb)
{
struct macusbfbdev *dev;
int status = urb->status;
dev = urb->context;
// sync/async unlink faults aren't errors
if (status &&
!(status == -ENOENT ||
status == -ECONNRESET ||
status == -ESHUTDOWN)) {
dbg("USBLCD: %s - nonzero write bulk status received: %d",
__func__, status);
}
/* free up our allocated buffer */
// usb_buffer_free(urb->dev, BUF_MAX_SIZE,
// urb->transfer_buffer, urb->transfer_dma);
//Is the picture on the 'tube holy and perfect now?
if (atomic_read(&dev->changedWhileWriting)!=0) {
// *sigh,* something has changed. Let's do it again.
atomic_set(&dev->changedWhileWriting, 0);
sendFramebufferOver(dev->fbinfo);
// printk(KERN_INFO "Macusbfb: USB transfer complete but frame has changed!!\n");
return;
} else {
// printk(KERN_INFO "Macusbfb: USB transfer complete! Image is perfect now.\n");
}
atomic_set(&dev->writeInProgress, 0);
// up(&dev->limit_sem);
}
static int createCmdStream(unsigned char* newbuff, unsigned char* oldbuff, unsigned char *data) {
int p=0;
int datalen=0;
int x,y;
int starting; //If we send data, will it be in a new packet?
int sizePos; //pos of size indicator of packet
int sizeCnt; //size of packet
int addr;
for (y=0; y<342; y++) {
sizeCnt=0;
starting=1;
for (x=0; x<64; x++) {
if (newbuff[p]==oldbuff[p]) {
if (sizeCnt!=0) {
data[sizePos]=sizeCnt;
sizeCnt=0;
}
starting=1;
p++;
} else {
oldbuff[p]=newbuff[p];
if (starting) {
addr=(y*64)+x;
// printk(KERN_INFO "%i\n", addr);
data[datalen++]=0xfa;
data[datalen++]=(addr>>8);
data[datalen++]=addr&0xff;
sizePos=datalen;
sizeCnt=0;
data[datalen++]=1;
starting=0;
}
data[datalen++]=newbuff[p++];
sizeCnt++;
}
}
if (sizeCnt!=0) {
data[sizePos]=sizeCnt;
}
}
return datalen;
}
static void convert16to1bit(unsigned char* in, unsigned char* out) {
int x,y,p,tresh, val;
unsigned char *outp=out;
u16 *inp=(u16 *)in;
for (y=0; y<342; y++) {
for (x=0; x<512; x+=8) {
for (p=0; p<8; p++) {
//Tresh should start at 32 but seemingly my Xorg interprets
//the 565-mode I pass to it as 555...
tresh=16;
if (p&1) tresh-=8;
if (y&1) tresh+=4;
val=(((*inp)>>5)&0x3F);
*outp<<=1;
if (val<tresh) *outp|=1;
inp++;
}
outp++;
}
}
}
static void convert24to1bit(unsigned char* in, unsigned char* out) {
int x,y,p,tresh;
unsigned char *outp=out;
unsigned char *inp=in+1; //point at g field
for (y=0; y<342; y++) {
for (x=0; x<512; x+=8) {
for (p=0; p<8; p++) {
tresh=128;
if (p&1) tresh-=64;
if (y&1) tresh+=32;
*outp<<=1;
if (*inp<tresh) *outp|=1;
inp+=3;
}
outp++;
}
}
}
static void sendFramebufferOver(struct fb_info *info) {
struct urb *usbreq;
int retval;
int count=0;
struct macusbfbdev *dev=info->par;
unsigned char *buf=dev->xferbuff;
/* create a urb, and a buffer for it, and copy the data to the urb */
usbreq = usb_alloc_urb(0, GFP_KERNEL);
if (!usbreq) {
printk(KERN_INFO "Macusbfb: Can't allocate urb!\n");
goto err_no_buf;
}
convert16to1bit(dev->fb, dev->pixels);
count=createCmdStream(dev->pixels, dev->oldpixels, buf);
/* initialize the urb properly */
usbreq->transfer_dma=dev->xferbuffDmaAddr;
usb_fill_bulk_urb(usbreq, dev->udev,
usb_sndbulkpipe(dev->udev, 3),
buf, count, macusbfb_write_bulk_callback, dev);
usbreq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
usb_anchor_urb(usbreq, &dev->submitted);
/* send the data out the bulk port */
retval = usb_submit_urb(usbreq, GFP_KERNEL);
if (retval) {
err("macusbfb: failed submitting write urb, error %d", retval);
goto error_unanchor;
}
/* release our reference to this urb, the USB core will eventually free it entirely */
usb_free_urb(usbreq);
return;
error_unanchor:
usb_unanchor_urb(usbreq);
usb_buffer_free(dev->udev, count, buf, usbreq->transfer_dma);
usb_free_urb(usbreq);
err_no_buf:
// up(&dev->limit_sem);
return;
}
static void macusbfb_dpy_deferred_io(struct fb_info *info, struct list_head *pagelist) {
struct macusbfbdev *dev=info->par;
if (atomic_read(&dev->writeInProgress)!=0) {
// printk(KERN_INFO "Macusbfb: Deferred io handler called but write still in progress!\n");
atomic_set(&dev->changedWhileWriting, 1);
return;
}
atomic_set(&dev->writeInProgress, 1);
sendFramebufferOver(info);
}
static void macusbfb_fillrect(struct fb_info *info,
const struct fb_fillrect *rect)
{
struct macusbfbdev *dev = info->par;
return;
sys_fillrect(info, rect);
if (atomic_read(&dev->writeInProgress)!=0) {
atomic_set(&dev->changedWhileWriting, 1);
return;
}
atomic_set(&dev->writeInProgress, 1);
sendFramebufferOver(info);
}
static void macusbfb_copyarea(struct fb_info *info,
const struct fb_copyarea *area)
{
struct macusbfbdev *dev = info->par;
sys_copyarea(info, area);
if (atomic_read(&dev->writeInProgress)!=0) {
atomic_set(&dev->changedWhileWriting, 1);
return;
}
atomic_set(&dev->writeInProgress, 1);
sendFramebufferOver(info);
}
static void macusbfb_imageblit(struct fb_info *info,
const struct fb_image *image)
{
struct macusbfbdev *dev = info->par;
sys_imageblit(info, image);
if (atomic_read(&dev->writeInProgress)!=0) {
atomic_set(&dev->changedWhileWriting, 1);
return;
}
atomic_set(&dev->writeInProgress, 1);
sendFramebufferOver(info);
}
static struct fb_deferred_io macusbfb_defio = {
.delay = HZ/30,
.deferred_io = macusbfb_dpy_deferred_io,
};
static struct fb_ops macusbfb_fbops = {
.owner = THIS_MODULE,
.fb_read = fb_sys_read,
.fb_write = fb_sys_write,
.fb_fillrect = macusbfb_fillrect,
.fb_copyarea = macusbfb_copyarea,
.fb_imageblit = macusbfb_imageblit,
};
#define MYDEV_ATTR_SIMPLE_UNSIGNED(name, gpiono) \
static ssize_t show_attr_##name(struct device *dev, \
struct device_attribute *attr, char *buf) \
{ \
struct usb_interface *intf = to_usb_interface(dev); \
struct macusbfbdev *mydev = usb_get_intfdata(intf); \
\
return sprintf(buf, "%u\n", mydev->gpioVals&(1<<gpiono)?1:0); \
} \
\
static ssize_t set_attr_##name(struct device *dev, \
struct device_attribute *attr, const char *buf, size_t count) \
{ \
struct usb_interface *intf = to_usb_interface(dev); \
struct macusbfbdev *mydev = usb_get_intfdata(intf); \
\
int val = simple_strtoul(buf, NULL, 10); \
setGpio(mydev, gpiono, val); \
\
return count; \
} \
static DEVICE_ATTR(name, S_IWUGO | S_IRUGO, show_attr_##name, set_attr_##name);
static int setGpio(struct macusbfbdev *dev, int gpiono, int val) {
unsigned char *buffer;
buffer = kmalloc(8, GFP_KERNEL);
if (!buffer) {
dev_err(&dev->udev->dev, "out of memory\n");
return -1;
}
if (val) dev->gpioVals|=(1<<gpiono); else dev->gpioVals&=!(1<<gpiono);
//ToDo: This times out. See if that's the drivers or the firmwares problem.
return usb_control_msg(dev->udev,
usb_sndctrlpipe(dev->udev, 0),
0x1, //1 -> modify gpio
0x40, //vendor specific reqtype
val,
gpiono,
buffer,
8,
100);
}
MYDEV_ATTR_SIMPLE_UNSIGNED(fan, 0);
MYDEV_ATTR_SIMPLE_UNSIGNED(display, 1);
MYDEV_ATTR_SIMPLE_UNSIGNED(fddeject, 2);
MYDEV_ATTR_SIMPLE_UNSIGNED(hdled, 3);
static struct attribute *dev_attrs[] = {
&dev_attr_fan.attr,
&dev_attr_display.attr,
&dev_attr_fddeject.attr,
&dev_attr_hdled.attr,
NULL
};
static struct attribute_group dev_attr_grp = {
.attrs = dev_attrs,
};
static int macusbfb_probe(struct usb_interface *interface, const struct usb_device_id *id) {
struct usb_device *udev = interface_to_usbdev(interface);
struct macusbfbdev *dev = NULL;
int retval = -ENOMEM;
struct fb_info *info;
dev = kzalloc(sizeof(struct macusbfbdev), GFP_KERNEL);
if (dev == NULL) {
dev_err(&interface->dev, "Out of memory\n");
goto error_mem;
}
init_usb_anchor(&dev->submitted);
//ToDo: oom handling
dev->fb = vmalloc(roundup((MACFB_WIDTH*MACFB_HEIGHT)*2, PAGE_SIZE));
if (!dev->fb) goto error_mem;
dev->pixels = vmalloc((MACFB_WIDTH*MACFB_HEIGHT)/8);
if (!dev->pixels) goto error_mem;
dev->oldpixels = vmalloc((MACFB_WIDTH*MACFB_HEIGHT)/8);
if (!dev->oldpixels) goto error_mem;
dev->udev = usb_get_dev(udev);
usb_set_intfdata (interface, dev);
//Allocate fb stuff
//The display is 1bit, but nothing is compatible with that so we'll emulate a 16-bit one.
info = framebuffer_alloc(sizeof(struct macusbfbdev*), NULL);
if (!info) goto error;
dev->xferbuff=usb_buffer_alloc(dev->udev, BUF_MAX_SIZE, GFP_KERNEL, &dev->xferbuffDmaAddr);
if (!dev->xferbuff) {
printk(KERN_INFO "Macusbfb: Error alloccing xfer buff!\n");
goto error2;
}
info->par=dev;
info->screen_base = (char __force __iomem *) dev->fb;
printk("Screen base = %x\n", (int)info->screen_base);
info->screen_size = MACFB_WIDTH*MACFB_HEIGHT*2;
info->fbops = &macusbfb_fbops;
info->fix = macusbfb_fbfix;
info->fix.smem_len=(MACFB_WIDTH*MACFB_HEIGHT)*2;
info->var = macusbfb_fbvar;
info->pseudo_palette = NULL;
info->flags = FBINFO_FLAG_DEFAULT|FBINFO_VIRTFB;
//Init deferred IO
info->fbdefio = &macusbfb_defio;
fb_deferred_io_init(info);
//Klont?!?
dev->fbinfo=info;
atomic_set(&dev->writeInProgress, 0);
atomic_set(&dev->changedWhileWriting, 0);
if (sysfs_create_group(&interface->dev.kobj, &dev_attr_grp)) goto error;
if (register_framebuffer(info) < 0) goto fberr;
printk(KERN_INFO "fb%d: %s frame buffer device\n", info->node, info->fix.id);
dev_info(&interface->dev, "MacUsbFb device now attached\n");
return 0;
//ToDo: look more closely at this: this doesn;t free everything.
fberr:
framebuffer_release(info);
printk(KERN_INFO "Macusbfb: Error initing fb!\n");
error2:
error:
printk(KERN_INFO "Macusbfb: Error initing!\n");
usb_set_intfdata (interface, NULL);
usb_put_dev(dev->udev);
kfree(dev);
error_mem:
printk(KERN_INFO "Macusbfb: Couldn't allocate framebuffer or usb memory!\n");
return retval;
}
static void macusbfb_disconnect(struct usb_interface *interface)
{
//ToDo: _Really_ clean everything up!
struct macusbfbdev *dev;
struct fb_info *info;
dev = usb_get_intfdata (interface);
info=dev->fbinfo;
if (info) {
fb_deferred_io_cleanup(info);
unregister_framebuffer(info);
framebuffer_release(info);
}
sysfs_remove_group(&interface->dev.kobj, &dev_attr_grp);
/* first remove the files, then set the pointer to NULL */
usb_set_intfdata (interface, NULL);
usb_put_dev(dev->udev);
kfree(dev);
dev_info(&interface->dev, "MacUsbFb now disconnected\n");
}
static struct usb_driver macusbfb_driver = {
.name = "macusbfb",
.probe = macusbfb_probe,
.disconnect = macusbfb_disconnect,
.id_table = id_table,
};
static int __init macusbfb_init(void)
{
int retval = 0;
retval = usb_register(&macusbfb_driver);
if (retval)
err("usb_register failed. Error number %d", retval);
return retval;
}
static void __exit macusbfb_exit(void)
{
usb_deregister(&macusbfb_driver);
}
module_init (macusbfb_init);
module_exit (macusbfb_exit);
MODULE_AUTHOR(DRIVER_AUTHOR);
MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_LICENSE("GPL");