#include <linux/init.h>

#include <linux/module.h>
#include <linux/backlight.h>
#include <linux/usb.h>

#include <linux/kernel.h>
#include <linux/slab.h>

#include "usb-pkk-backlight.h"
static void urb_out_complete(struct urb *urb)
{
    return;
}

static int pkk_bl_get_brightness(struct backlight_device *bdev)
{
    struct pkk_bl_data *data = bl_get_data(bdev);

    //uint8_t *brightness = &bdev->props.brightness; //Not sure, that this is right
    uint8_t *brightness = &data->brightness;
    printk(KERN_INFO PKK_BL_DRIVER_NAME "Brightness get function called. Current brightness: %d.\n", *brightness);
    return *brightness;
}

static int pkk_bl_set_brightness(struct backlight_device *bdev)
{
    struct pkk_bl_data *data = bl_get_data(bdev);

    //uint8_t *brightness = &bdev->props.brightness; //Not sure, that this is right
    uint8_t *brightness = &data->brightness;
    unsigned char *transfer_buffer_out = data->transfer_buffer_out;
    int error;
    *brightness = bdev->props.brightness;
    printk(KERN_INFO PKK_BL_DRIVER_NAME "Brightness set function called. New brightness: %d.\n", *brightness);
    *transfer_buffer_out = PKK_BL_CMD_SET_BRIGHTNESS;
    transfer_buffer_out++;
    *transfer_buffer_out = *brightness;
    error = usb_submit_urb(data->urb, GFP_KERNEL);
    if (data->urb->status != 0 || error != 0) {
        printk(KERN_ERR PKK_BL_DRIVER_NAME "Urb submit failled. Urb status: %d. Usb_submit_urb returned:%d.\n",
               data->urb->status, error);
    }
    return 0;
}

static const struct backlight_ops pkk_bl_blops = {
    .update_status = pkk_bl_set_brightness,
    .get_brightness = pkk_bl_get_brightness,
};

static int pkk_bl_init_backlight(struct pkk_bl_data *data)  // I'm not sure that it should be static
{
    struct device *dev = &data->intf->dev;
    struct backlight_device *bdev;
    struct backlight_properties props;
    printk(KERN_INFO PKK_BL_DRIVER_NAME "Backlight device initialization...\n");
    if (data->intf == 0) {
        printk(KERN_ERR PKK_BL_DRIVER_NAME "no such interface\n");
        return -ENODEV;
    }
    /* PicoLCD - There was sommething for hid_report */
    memset(&props, 0, sizeof(props));
    props.type = BACKLIGHT_RAW; //I don't know what is it
    props.max_brightness = PKK_BL_MAX_BRIGHTNESS;
    printk("%s(): data->intf = %p\ndev = %p\ndata = %p\n", __FUNCTION__, data->intf, (void *)dev, data);
    printk("%s(): dev_name(dev) = %s\ndev = %p\ndata = %p\n", __FUNCTION__, dev_name(dev), (void *)dev, data);
    bdev = backlight_device_register(dev_name(dev), dev, data, &pkk_bl_blops, &props);
    if (IS_ERR(bdev)) {
        printk(KERN_ERR PKK_BL_DRIVER_NAME "Failed to register backlight.\n");
        return PTR_ERR(bdev);
    }
    printk(KERN_INFO PKK_BL_DRIVER_NAME "%s():%d", __FUNCTION__, __LINE__);
    bdev->props.brightness = PKK_BL_DEFAULT_BRIGHTNESS;
    data->bdev = bdev;
    pkk_bl_set_brightness(bdev);
    printk(KERN_INFO PKK_BL_DRIVER_NAME "Backlight device initialized.\n");
    return 0;
}

static void pkk_bl_exit_backlight(struct pkk_bl_data *data) // I'm not sure that it should be static
{
    struct backlight_device *bdev = data->bdev;
    printk(KERN_INFO PKK_BL_DRIVER_NAME "Backlight device unregistering...\n");
    data->bdev = NULL;
    if (bdev)
        backlight_device_unregister(bdev);
    printk(KERN_INFO PKK_BL_DRIVER_NAME "Backlight device unregistered successfully.\n");
}

static int pkk_bl_probe(struct usb_interface *intf, const struct usb_device_id *id)
{
    struct pkk_bl_data *data;
    int error = 0;
    struct urb *urb;
    unsigned char *transfer_buffer_out;
    struct usb_device *udev = interface_to_usbdev(intf);

    if (intf == NULL) {
        printk(KERN_ERR "no such interface\n");
        error = -ENODEV;
        goto err_nodev;
    }
    printk(KERN_INFO PKK_BL_DRIVER_NAME "Hardware probe...\n");

    /* Varibles initialization and assigments */
    data = kzalloc(sizeof(struct pkk_bl_data), GFP_KERNEL);
    if (data == NULL) {
        printk(KERN_ERR PKK_BL_DRIVER_NAME "Can't allocate space for device data.\n");
        error = -ENOMEM;
        goto err_no_cleanup;
    }

    /* PicoLCD - There was synchronization elements (initialization & using) */
    dev_set_drvdata(&intf->dev, data);
    printk("pkk_bl_probe: intf = %p\n", (void *)intf);
    printk("pkk_bl_probe: &intf->dev = %p\n", (void *)&intf->dev);

    /* Filling data structure */
    data->udev_id = (struct usb_device_id *)id;
    data->udev = udev;

    /* Modules initialization */
    error = pkk_bl_init_backlight(data);
    if (error) {
        pkk_bl_exit_backlight(data);
        printk(KERN_ERR PKK_BL_DRIVER_NAME "Can't initializate backlight device.\n");
        goto err_cleanup_data;
    }
    urb = usb_alloc_urb(0, GFP_KERNEL);
    if (urb == NULL) {
        printk(KERN_ERR PKK_BL_DRIVER_NAME "Can't initializate urb.\n");
        goto err_exit_backlight;
    }
    data->urb = urb;
    transfer_buffer_out = kzalloc(sizeof(unsigned char) * PKK_BL_TRANSFER_BUFFER_OUT_SIZE, GFP_KERNEL);
    if (transfer_buffer_out == NULL) {
        printk(KERN_ERR PKK_BL_DRIVER_NAME "Can't allocate space for transfer buffer (out).\n");
        error = -ENOMEM;
        goto err_urb_cleanup;
    }
    data->transfer_buffer_out = transfer_buffer_out;

    usb_fill_int_urb(urb, udev, usb_rcvintpipe(to_usb_device(&intf->dev), PKK_BL_OUT_ENDPOINT), transfer_buffer_out, PKK_BL_TRANSFER_BUFFER_OUT_SIZE, urb_out_complete, data, PKK_BL_OUT_INTERVAL);
    printk(KERN_INFO PKK_BL_DRIVER_NAME "Device activated and initialized.\n");
    return 0;
 err_urb_cleanup:usb_free_urb(urb);
 err_exit_backlight:pkk_bl_exit_backlight(data);
 err_cleanup_data:kfree(data);
 err_no_cleanup:
    //dev_set_drvdata(&intf->dev, NULL); - intf->dev->data Wasn't assigned in this step(dev_setdrvdata wasn't called
 err_nodev:
    return error;
}

static void pkk_bl_disconnect(struct usb_interface *intf)
{
    struct pkk_bl_data *data = dev_get_drvdata(&intf->dev);
    printk(KERN_INFO PKK_BL_DRIVER_NAME "Hardware remove...\n");

    /* PicoLCD - There was synchronization elements (removing & using) */
    pkk_bl_exit_backlight(data);
    dev_set_drvdata(&intf->dev, NULL);
    usb_free_urb(data->urb);
    kfree(data->transfer_buffer_out);
    kfree(data);
    printk(KERN_INFO PKK_BL_DRIVER_NAME "Device disconnected successfully.\n");
} static struct usb_device_id pkk_bl_devices[] = { {USB_DEVICE(USB_VENDOR_ID_PKK_BL, USB_DEVICE_ID_PKK_BL)}, {}
};

MODULE_DEVICE_TABLE(usb, pkk_bl_devices);
static struct usb_driver pkk_bl_driver = {.name = "usb_pkk_backlight",.id_table = pkk_bl_devices,.probe =
        pkk_bl_probe,.disconnect = pkk_bl_disconnect,
};

module_usb_driver(pkk_bl_driver);
MODULE_DESCRIPTION("PKK USB backlight driver");
MODULE_LICENSE("GPL v2");
MODULE_AUTHOR("Dmitry Chepurovskiy <dm3chip@gmail.com>");