Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * DRM driver for Pervasive Displays RePaper branded e-ink panels
0004  *
0005  * Copyright 2013-2017 Pervasive Displays, Inc.
0006  * Copyright 2017 Noralf Trønnes
0007  *
0008  * The driver supports:
0009  * Material Film: Aurora Mb (V231)
0010  * Driver IC: G2 (eTC)
0011  *
0012  * The controller code was taken from the userspace driver:
0013  * https://github.com/repaper/gratis
0014  */
0015 
0016 #include <linux/delay.h>
0017 #include <linux/gpio/consumer.h>
0018 #include <linux/module.h>
0019 #include <linux/property.h>
0020 #include <linux/sched/clock.h>
0021 #include <linux/spi/spi.h>
0022 #include <linux/thermal.h>
0023 
0024 #include <drm/drm_atomic_helper.h>
0025 #include <drm/drm_connector.h>
0026 #include <drm/drm_damage_helper.h>
0027 #include <drm/drm_drv.h>
0028 #include <drm/drm_fb_cma_helper.h>
0029 #include <drm/drm_fb_helper.h>
0030 #include <drm/drm_format_helper.h>
0031 #include <drm/drm_framebuffer.h>
0032 #include <drm/drm_gem_atomic_helper.h>
0033 #include <drm/drm_gem_cma_helper.h>
0034 #include <drm/drm_gem_framebuffer_helper.h>
0035 #include <drm/drm_managed.h>
0036 #include <drm/drm_modes.h>
0037 #include <drm/drm_rect.h>
0038 #include <drm/drm_probe_helper.h>
0039 #include <drm/drm_simple_kms_helper.h>
0040 
0041 #define REPAPER_RID_G2_COG_ID   0x12
0042 
0043 enum repaper_model {
0044     /* 0 is reserved to avoid clashing with NULL */
0045     E1144CS021 = 1,
0046     E1190CS021,
0047     E2200CS021,
0048     E2271CS021,
0049 };
0050 
0051 enum repaper_stage {         /* Image pixel -> Display pixel */
0052     REPAPER_COMPENSATE,  /* B -> W, W -> B (Current Image) */
0053     REPAPER_WHITE,       /* B -> N, W -> W (Current Image) */
0054     REPAPER_INVERSE,     /* B -> N, W -> B (New Image) */
0055     REPAPER_NORMAL       /* B -> B, W -> W (New Image) */
0056 };
0057 
0058 enum repaper_epd_border_byte {
0059     REPAPER_BORDER_BYTE_NONE,
0060     REPAPER_BORDER_BYTE_ZERO,
0061     REPAPER_BORDER_BYTE_SET,
0062 };
0063 
0064 struct repaper_epd {
0065     struct drm_device drm;
0066     struct drm_simple_display_pipe pipe;
0067     const struct drm_display_mode *mode;
0068     struct drm_connector connector;
0069     struct spi_device *spi;
0070 
0071     struct gpio_desc *panel_on;
0072     struct gpio_desc *border;
0073     struct gpio_desc *discharge;
0074     struct gpio_desc *reset;
0075     struct gpio_desc *busy;
0076 
0077     struct thermal_zone_device *thermal;
0078 
0079     unsigned int height;
0080     unsigned int width;
0081     unsigned int bytes_per_scan;
0082     const u8 *channel_select;
0083     unsigned int stage_time;
0084     unsigned int factored_stage_time;
0085     bool middle_scan;
0086     bool pre_border_byte;
0087     enum repaper_epd_border_byte border_byte;
0088 
0089     u8 *line_buffer;
0090     void *current_frame;
0091 
0092     bool cleared;
0093     bool partial;
0094 };
0095 
0096 static inline struct repaper_epd *drm_to_epd(struct drm_device *drm)
0097 {
0098     return container_of(drm, struct repaper_epd, drm);
0099 }
0100 
0101 static int repaper_spi_transfer(struct spi_device *spi, u8 header,
0102                 const void *tx, void *rx, size_t len)
0103 {
0104     void *txbuf = NULL, *rxbuf = NULL;
0105     struct spi_transfer tr[2] = {};
0106     u8 *headerbuf;
0107     int ret;
0108 
0109     headerbuf = kmalloc(1, GFP_KERNEL);
0110     if (!headerbuf)
0111         return -ENOMEM;
0112 
0113     headerbuf[0] = header;
0114     tr[0].tx_buf = headerbuf;
0115     tr[0].len = 1;
0116 
0117     /* Stack allocated tx? */
0118     if (tx && len <= 32) {
0119         txbuf = kmemdup(tx, len, GFP_KERNEL);
0120         if (!txbuf) {
0121             ret = -ENOMEM;
0122             goto out_free;
0123         }
0124     }
0125 
0126     if (rx) {
0127         rxbuf = kmalloc(len, GFP_KERNEL);
0128         if (!rxbuf) {
0129             ret = -ENOMEM;
0130             goto out_free;
0131         }
0132     }
0133 
0134     tr[1].tx_buf = txbuf ? txbuf : tx;
0135     tr[1].rx_buf = rxbuf;
0136     tr[1].len = len;
0137 
0138     ndelay(80);
0139     ret = spi_sync_transfer(spi, tr, 2);
0140     if (rx && !ret)
0141         memcpy(rx, rxbuf, len);
0142 
0143 out_free:
0144     kfree(headerbuf);
0145     kfree(txbuf);
0146     kfree(rxbuf);
0147 
0148     return ret;
0149 }
0150 
0151 static int repaper_write_buf(struct spi_device *spi, u8 reg,
0152                  const u8 *buf, size_t len)
0153 {
0154     int ret;
0155 
0156     ret = repaper_spi_transfer(spi, 0x70, &reg, NULL, 1);
0157     if (ret)
0158         return ret;
0159 
0160     return repaper_spi_transfer(spi, 0x72, buf, NULL, len);
0161 }
0162 
0163 static int repaper_write_val(struct spi_device *spi, u8 reg, u8 val)
0164 {
0165     return repaper_write_buf(spi, reg, &val, 1);
0166 }
0167 
0168 static int repaper_read_val(struct spi_device *spi, u8 reg)
0169 {
0170     int ret;
0171     u8 val;
0172 
0173     ret = repaper_spi_transfer(spi, 0x70, &reg, NULL, 1);
0174     if (ret)
0175         return ret;
0176 
0177     ret = repaper_spi_transfer(spi, 0x73, NULL, &val, 1);
0178 
0179     return ret ? ret : val;
0180 }
0181 
0182 static int repaper_read_id(struct spi_device *spi)
0183 {
0184     int ret;
0185     u8 id;
0186 
0187     ret = repaper_spi_transfer(spi, 0x71, NULL, &id, 1);
0188 
0189     return ret ? ret : id;
0190 }
0191 
0192 static void repaper_spi_mosi_low(struct spi_device *spi)
0193 {
0194     const u8 buf[1] = { 0 };
0195 
0196     spi_write(spi, buf, 1);
0197 }
0198 
0199 /* pixels on display are numbered from 1 so even is actually bits 1,3,5,... */
0200 static void repaper_even_pixels(struct repaper_epd *epd, u8 **pp,
0201                 const u8 *data, u8 fixed_value, const u8 *mask,
0202                 enum repaper_stage stage)
0203 {
0204     unsigned int b;
0205 
0206     for (b = 0; b < (epd->width / 8); b++) {
0207         if (data) {
0208             u8 pixels = data[b] & 0xaa;
0209             u8 pixel_mask = 0xff;
0210             u8 p1, p2, p3, p4;
0211 
0212             if (mask) {
0213                 pixel_mask = (mask[b] ^ pixels) & 0xaa;
0214                 pixel_mask |= pixel_mask >> 1;
0215             }
0216 
0217             switch (stage) {
0218             case REPAPER_COMPENSATE: /* B -> W, W -> B (Current) */
0219                 pixels = 0xaa | ((pixels ^ 0xaa) >> 1);
0220                 break;
0221             case REPAPER_WHITE:      /* B -> N, W -> W (Current) */
0222                 pixels = 0x55 + ((pixels ^ 0xaa) >> 1);
0223                 break;
0224             case REPAPER_INVERSE:    /* B -> N, W -> B (New) */
0225                 pixels = 0x55 | (pixels ^ 0xaa);
0226                 break;
0227             case REPAPER_NORMAL:     /* B -> B, W -> W (New) */
0228                 pixels = 0xaa | (pixels >> 1);
0229                 break;
0230             }
0231 
0232             pixels = (pixels & pixel_mask) | (~pixel_mask & 0x55);
0233             p1 = (pixels >> 6) & 0x03;
0234             p2 = (pixels >> 4) & 0x03;
0235             p3 = (pixels >> 2) & 0x03;
0236             p4 = (pixels >> 0) & 0x03;
0237             pixels = (p1 << 0) | (p2 << 2) | (p3 << 4) | (p4 << 6);
0238             *(*pp)++ = pixels;
0239         } else {
0240             *(*pp)++ = fixed_value;
0241         }
0242     }
0243 }
0244 
0245 /* pixels on display are numbered from 1 so odd is actually bits 0,2,4,... */
0246 static void repaper_odd_pixels(struct repaper_epd *epd, u8 **pp,
0247                    const u8 *data, u8 fixed_value, const u8 *mask,
0248                    enum repaper_stage stage)
0249 {
0250     unsigned int b;
0251 
0252     for (b = epd->width / 8; b > 0; b--) {
0253         if (data) {
0254             u8 pixels = data[b - 1] & 0x55;
0255             u8 pixel_mask = 0xff;
0256 
0257             if (mask) {
0258                 pixel_mask = (mask[b - 1] ^ pixels) & 0x55;
0259                 pixel_mask |= pixel_mask << 1;
0260             }
0261 
0262             switch (stage) {
0263             case REPAPER_COMPENSATE: /* B -> W, W -> B (Current) */
0264                 pixels = 0xaa | (pixels ^ 0x55);
0265                 break;
0266             case REPAPER_WHITE:      /* B -> N, W -> W (Current) */
0267                 pixels = 0x55 + (pixels ^ 0x55);
0268                 break;
0269             case REPAPER_INVERSE:    /* B -> N, W -> B (New) */
0270                 pixels = 0x55 | ((pixels ^ 0x55) << 1);
0271                 break;
0272             case REPAPER_NORMAL:     /* B -> B, W -> W (New) */
0273                 pixels = 0xaa | pixels;
0274                 break;
0275             }
0276 
0277             pixels = (pixels & pixel_mask) | (~pixel_mask & 0x55);
0278             *(*pp)++ = pixels;
0279         } else {
0280             *(*pp)++ = fixed_value;
0281         }
0282     }
0283 }
0284 
0285 /* interleave bits: (byte)76543210 -> (16 bit).7.6.5.4.3.2.1 */
0286 static inline u16 repaper_interleave_bits(u16 value)
0287 {
0288     value = (value | (value << 4)) & 0x0f0f;
0289     value = (value | (value << 2)) & 0x3333;
0290     value = (value | (value << 1)) & 0x5555;
0291 
0292     return value;
0293 }
0294 
0295 /* pixels on display are numbered from 1 */
0296 static void repaper_all_pixels(struct repaper_epd *epd, u8 **pp,
0297                    const u8 *data, u8 fixed_value, const u8 *mask,
0298                    enum repaper_stage stage)
0299 {
0300     unsigned int b;
0301 
0302     for (b = epd->width / 8; b > 0; b--) {
0303         if (data) {
0304             u16 pixels = repaper_interleave_bits(data[b - 1]);
0305             u16 pixel_mask = 0xffff;
0306 
0307             if (mask) {
0308                 pixel_mask = repaper_interleave_bits(mask[b - 1]);
0309 
0310                 pixel_mask = (pixel_mask ^ pixels) & 0x5555;
0311                 pixel_mask |= pixel_mask << 1;
0312             }
0313 
0314             switch (stage) {
0315             case REPAPER_COMPENSATE: /* B -> W, W -> B (Current) */
0316                 pixels = 0xaaaa | (pixels ^ 0x5555);
0317                 break;
0318             case REPAPER_WHITE:      /* B -> N, W -> W (Current) */
0319                 pixels = 0x5555 + (pixels ^ 0x5555);
0320                 break;
0321             case REPAPER_INVERSE:    /* B -> N, W -> B (New) */
0322                 pixels = 0x5555 | ((pixels ^ 0x5555) << 1);
0323                 break;
0324             case REPAPER_NORMAL:     /* B -> B, W -> W (New) */
0325                 pixels = 0xaaaa | pixels;
0326                 break;
0327             }
0328 
0329             pixels = (pixels & pixel_mask) | (~pixel_mask & 0x5555);
0330             *(*pp)++ = pixels >> 8;
0331             *(*pp)++ = pixels;
0332         } else {
0333             *(*pp)++ = fixed_value;
0334             *(*pp)++ = fixed_value;
0335         }
0336     }
0337 }
0338 
0339 /* output one line of scan and data bytes to the display */
0340 static void repaper_one_line(struct repaper_epd *epd, unsigned int line,
0341                  const u8 *data, u8 fixed_value, const u8 *mask,
0342                  enum repaper_stage stage)
0343 {
0344     u8 *p = epd->line_buffer;
0345     unsigned int b;
0346 
0347     repaper_spi_mosi_low(epd->spi);
0348 
0349     if (epd->pre_border_byte)
0350         *p++ = 0x00;
0351 
0352     if (epd->middle_scan) {
0353         /* data bytes */
0354         repaper_odd_pixels(epd, &p, data, fixed_value, mask, stage);
0355 
0356         /* scan line */
0357         for (b = epd->bytes_per_scan; b > 0; b--) {
0358             if (line / 4 == b - 1)
0359                 *p++ = 0x03 << (2 * (line & 0x03));
0360             else
0361                 *p++ = 0x00;
0362         }
0363 
0364         /* data bytes */
0365         repaper_even_pixels(epd, &p, data, fixed_value, mask, stage);
0366     } else {
0367         /*
0368          * even scan line, but as lines on display are numbered from 1,
0369          * line: 1,3,5,...
0370          */
0371         for (b = 0; b < epd->bytes_per_scan; b++) {
0372             if (0 != (line & 0x01) && line / 8 == b)
0373                 *p++ = 0xc0 >> (line & 0x06);
0374             else
0375                 *p++ = 0x00;
0376         }
0377 
0378         /* data bytes */
0379         repaper_all_pixels(epd, &p, data, fixed_value, mask, stage);
0380 
0381         /*
0382          * odd scan line, but as lines on display are numbered from 1,
0383          * line: 0,2,4,6,...
0384          */
0385         for (b = epd->bytes_per_scan; b > 0; b--) {
0386             if (0 == (line & 0x01) && line / 8 == b - 1)
0387                 *p++ = 0x03 << (line & 0x06);
0388             else
0389                 *p++ = 0x00;
0390         }
0391     }
0392 
0393     switch (epd->border_byte) {
0394     case REPAPER_BORDER_BYTE_NONE:
0395         break;
0396 
0397     case REPAPER_BORDER_BYTE_ZERO:
0398         *p++ = 0x00;
0399         break;
0400 
0401     case REPAPER_BORDER_BYTE_SET:
0402         switch (stage) {
0403         case REPAPER_COMPENSATE:
0404         case REPAPER_WHITE:
0405         case REPAPER_INVERSE:
0406             *p++ = 0x00;
0407             break;
0408         case REPAPER_NORMAL:
0409             *p++ = 0xaa;
0410             break;
0411         }
0412         break;
0413     }
0414 
0415     repaper_write_buf(epd->spi, 0x0a, epd->line_buffer,
0416               p - epd->line_buffer);
0417 
0418     /* Output data to panel */
0419     repaper_write_val(epd->spi, 0x02, 0x07);
0420 
0421     repaper_spi_mosi_low(epd->spi);
0422 }
0423 
0424 static void repaper_frame_fixed(struct repaper_epd *epd, u8 fixed_value,
0425                 enum repaper_stage stage)
0426 {
0427     unsigned int line;
0428 
0429     for (line = 0; line < epd->height; line++)
0430         repaper_one_line(epd, line, NULL, fixed_value, NULL, stage);
0431 }
0432 
0433 static void repaper_frame_data(struct repaper_epd *epd, const u8 *image,
0434                    const u8 *mask, enum repaper_stage stage)
0435 {
0436     unsigned int line;
0437 
0438     if (!mask) {
0439         for (line = 0; line < epd->height; line++) {
0440             repaper_one_line(epd, line,
0441                      &image[line * (epd->width / 8)],
0442                      0, NULL, stage);
0443         }
0444     } else {
0445         for (line = 0; line < epd->height; line++) {
0446             size_t n = line * epd->width / 8;
0447 
0448             repaper_one_line(epd, line, &image[n], 0, &mask[n],
0449                      stage);
0450         }
0451     }
0452 }
0453 
0454 static void repaper_frame_fixed_repeat(struct repaper_epd *epd, u8 fixed_value,
0455                        enum repaper_stage stage)
0456 {
0457     u64 start = local_clock();
0458     u64 end = start + (epd->factored_stage_time * 1000 * 1000);
0459 
0460     do {
0461         repaper_frame_fixed(epd, fixed_value, stage);
0462     } while (local_clock() < end);
0463 }
0464 
0465 static void repaper_frame_data_repeat(struct repaper_epd *epd, const u8 *image,
0466                       const u8 *mask, enum repaper_stage stage)
0467 {
0468     u64 start = local_clock();
0469     u64 end = start + (epd->factored_stage_time * 1000 * 1000);
0470 
0471     do {
0472         repaper_frame_data(epd, image, mask, stage);
0473     } while (local_clock() < end);
0474 }
0475 
0476 static void repaper_get_temperature(struct repaper_epd *epd)
0477 {
0478     int ret, temperature = 0;
0479     unsigned int factor10x;
0480 
0481     if (!epd->thermal)
0482         return;
0483 
0484     ret = thermal_zone_get_temp(epd->thermal, &temperature);
0485     if (ret) {
0486         DRM_DEV_ERROR(&epd->spi->dev, "Failed to get temperature (%d)\n", ret);
0487         return;
0488     }
0489 
0490     temperature /= 1000;
0491 
0492     if (temperature <= -10)
0493         factor10x = 170;
0494     else if (temperature <= -5)
0495         factor10x = 120;
0496     else if (temperature <= 5)
0497         factor10x = 80;
0498     else if (temperature <= 10)
0499         factor10x = 40;
0500     else if (temperature <= 15)
0501         factor10x = 30;
0502     else if (temperature <= 20)
0503         factor10x = 20;
0504     else if (temperature <= 40)
0505         factor10x = 10;
0506     else
0507         factor10x = 7;
0508 
0509     epd->factored_stage_time = epd->stage_time * factor10x / 10;
0510 }
0511 
0512 static int repaper_fb_dirty(struct drm_framebuffer *fb)
0513 {
0514     struct drm_gem_cma_object *cma_obj = drm_fb_cma_get_gem_obj(fb, 0);
0515     struct repaper_epd *epd = drm_to_epd(fb->dev);
0516     struct drm_rect clip;
0517     int idx, ret = 0;
0518     u8 *buf = NULL;
0519 
0520     if (!drm_dev_enter(fb->dev, &idx))
0521         return -ENODEV;
0522 
0523     /* repaper can't do partial updates */
0524     clip.x1 = 0;
0525     clip.x2 = fb->width;
0526     clip.y1 = 0;
0527     clip.y2 = fb->height;
0528 
0529     repaper_get_temperature(epd);
0530 
0531     DRM_DEBUG("Flushing [FB:%d] st=%ums\n", fb->base.id,
0532           epd->factored_stage_time);
0533 
0534     buf = kmalloc_array(fb->width, fb->height, GFP_KERNEL);
0535     if (!buf) {
0536         ret = -ENOMEM;
0537         goto out_exit;
0538     }
0539 
0540     ret = drm_gem_fb_begin_cpu_access(fb, DMA_FROM_DEVICE);
0541     if (ret)
0542         goto out_free;
0543 
0544     drm_fb_xrgb8888_to_mono(buf, 0, cma_obj->vaddr, fb, &clip);
0545 
0546     drm_gem_fb_end_cpu_access(fb, DMA_FROM_DEVICE);
0547 
0548     if (epd->partial) {
0549         repaper_frame_data_repeat(epd, buf, epd->current_frame,
0550                       REPAPER_NORMAL);
0551     } else if (epd->cleared) {
0552         repaper_frame_data_repeat(epd, epd->current_frame, NULL,
0553                       REPAPER_COMPENSATE);
0554         repaper_frame_data_repeat(epd, epd->current_frame, NULL,
0555                       REPAPER_WHITE);
0556         repaper_frame_data_repeat(epd, buf, NULL, REPAPER_INVERSE);
0557         repaper_frame_data_repeat(epd, buf, NULL, REPAPER_NORMAL);
0558 
0559         epd->partial = true;
0560     } else {
0561         /* Clear display (anything -> white) */
0562         repaper_frame_fixed_repeat(epd, 0xff, REPAPER_COMPENSATE);
0563         repaper_frame_fixed_repeat(epd, 0xff, REPAPER_WHITE);
0564         repaper_frame_fixed_repeat(epd, 0xaa, REPAPER_INVERSE);
0565         repaper_frame_fixed_repeat(epd, 0xaa, REPAPER_NORMAL);
0566 
0567         /* Assuming a clear (white) screen output an image */
0568         repaper_frame_fixed_repeat(epd, 0xaa, REPAPER_COMPENSATE);
0569         repaper_frame_fixed_repeat(epd, 0xaa, REPAPER_WHITE);
0570         repaper_frame_data_repeat(epd, buf, NULL, REPAPER_INVERSE);
0571         repaper_frame_data_repeat(epd, buf, NULL, REPAPER_NORMAL);
0572 
0573         epd->cleared = true;
0574         epd->partial = true;
0575     }
0576 
0577     memcpy(epd->current_frame, buf, fb->width * fb->height / 8);
0578 
0579     /*
0580      * An extra frame write is needed if pixels are set in the bottom line,
0581      * or else grey lines rises up from the pixels
0582      */
0583     if (epd->pre_border_byte) {
0584         unsigned int x;
0585 
0586         for (x = 0; x < (fb->width / 8); x++)
0587             if (buf[x + (fb->width * (fb->height - 1) / 8)]) {
0588                 repaper_frame_data_repeat(epd, buf,
0589                               epd->current_frame,
0590                               REPAPER_NORMAL);
0591                 break;
0592             }
0593     }
0594 
0595 out_free:
0596     kfree(buf);
0597 out_exit:
0598     drm_dev_exit(idx);
0599 
0600     return ret;
0601 }
0602 
0603 static void power_off(struct repaper_epd *epd)
0604 {
0605     /* Turn off power and all signals */
0606     gpiod_set_value_cansleep(epd->reset, 0);
0607     gpiod_set_value_cansleep(epd->panel_on, 0);
0608     if (epd->border)
0609         gpiod_set_value_cansleep(epd->border, 0);
0610 
0611     /* Ensure SPI MOSI and CLOCK are Low before CS Low */
0612     repaper_spi_mosi_low(epd->spi);
0613 
0614     /* Discharge pulse */
0615     gpiod_set_value_cansleep(epd->discharge, 1);
0616     msleep(150);
0617     gpiod_set_value_cansleep(epd->discharge, 0);
0618 }
0619 
0620 static void repaper_pipe_enable(struct drm_simple_display_pipe *pipe,
0621                 struct drm_crtc_state *crtc_state,
0622                 struct drm_plane_state *plane_state)
0623 {
0624     struct repaper_epd *epd = drm_to_epd(pipe->crtc.dev);
0625     struct spi_device *spi = epd->spi;
0626     struct device *dev = &spi->dev;
0627     bool dc_ok = false;
0628     int i, ret, idx;
0629 
0630     if (!drm_dev_enter(pipe->crtc.dev, &idx))
0631         return;
0632 
0633     DRM_DEBUG_DRIVER("\n");
0634 
0635     /* Power up sequence */
0636     gpiod_set_value_cansleep(epd->reset, 0);
0637     gpiod_set_value_cansleep(epd->panel_on, 0);
0638     gpiod_set_value_cansleep(epd->discharge, 0);
0639     if (epd->border)
0640         gpiod_set_value_cansleep(epd->border, 0);
0641     repaper_spi_mosi_low(spi);
0642     usleep_range(5000, 10000);
0643 
0644     gpiod_set_value_cansleep(epd->panel_on, 1);
0645     /*
0646      * This delay comes from the repaper.org userspace driver, it's not
0647      * mentioned in the datasheet.
0648      */
0649     usleep_range(10000, 15000);
0650     gpiod_set_value_cansleep(epd->reset, 1);
0651     if (epd->border)
0652         gpiod_set_value_cansleep(epd->border, 1);
0653     usleep_range(5000, 10000);
0654     gpiod_set_value_cansleep(epd->reset, 0);
0655     usleep_range(5000, 10000);
0656     gpiod_set_value_cansleep(epd->reset, 1);
0657     usleep_range(5000, 10000);
0658 
0659     /* Wait for COG to become ready */
0660     for (i = 100; i > 0; i--) {
0661         if (!gpiod_get_value_cansleep(epd->busy))
0662             break;
0663 
0664         usleep_range(10, 100);
0665     }
0666 
0667     if (!i) {
0668         DRM_DEV_ERROR(dev, "timeout waiting for panel to become ready.\n");
0669         power_off(epd);
0670         goto out_exit;
0671     }
0672 
0673     repaper_read_id(spi);
0674     ret = repaper_read_id(spi);
0675     if (ret != REPAPER_RID_G2_COG_ID) {
0676         if (ret < 0)
0677             dev_err(dev, "failed to read chip (%d)\n", ret);
0678         else
0679             dev_err(dev, "wrong COG ID 0x%02x\n", ret);
0680         power_off(epd);
0681         goto out_exit;
0682     }
0683 
0684     /* Disable OE */
0685     repaper_write_val(spi, 0x02, 0x40);
0686 
0687     ret = repaper_read_val(spi, 0x0f);
0688     if (ret < 0 || !(ret & 0x80)) {
0689         if (ret < 0)
0690             DRM_DEV_ERROR(dev, "failed to read chip (%d)\n", ret);
0691         else
0692             DRM_DEV_ERROR(dev, "panel is reported broken\n");
0693         power_off(epd);
0694         goto out_exit;
0695     }
0696 
0697     /* Power saving mode */
0698     repaper_write_val(spi, 0x0b, 0x02);
0699     /* Channel select */
0700     repaper_write_buf(spi, 0x01, epd->channel_select, 8);
0701     /* High power mode osc */
0702     repaper_write_val(spi, 0x07, 0xd1);
0703     /* Power setting */
0704     repaper_write_val(spi, 0x08, 0x02);
0705     /* Vcom level */
0706     repaper_write_val(spi, 0x09, 0xc2);
0707     /* Power setting */
0708     repaper_write_val(spi, 0x04, 0x03);
0709     /* Driver latch on */
0710     repaper_write_val(spi, 0x03, 0x01);
0711     /* Driver latch off */
0712     repaper_write_val(spi, 0x03, 0x00);
0713     usleep_range(5000, 10000);
0714 
0715     /* Start chargepump */
0716     for (i = 0; i < 4; ++i) {
0717         /* Charge pump positive voltage on - VGH/VDL on */
0718         repaper_write_val(spi, 0x05, 0x01);
0719         msleep(240);
0720 
0721         /* Charge pump negative voltage on - VGL/VDL on */
0722         repaper_write_val(spi, 0x05, 0x03);
0723         msleep(40);
0724 
0725         /* Charge pump Vcom on - Vcom driver on */
0726         repaper_write_val(spi, 0x05, 0x0f);
0727         msleep(40);
0728 
0729         /* check DC/DC */
0730         ret = repaper_read_val(spi, 0x0f);
0731         if (ret < 0) {
0732             DRM_DEV_ERROR(dev, "failed to read chip (%d)\n", ret);
0733             power_off(epd);
0734             goto out_exit;
0735         }
0736 
0737         if (ret & 0x40) {
0738             dc_ok = true;
0739             break;
0740         }
0741     }
0742 
0743     if (!dc_ok) {
0744         DRM_DEV_ERROR(dev, "dc/dc failed\n");
0745         power_off(epd);
0746         goto out_exit;
0747     }
0748 
0749     /*
0750      * Output enable to disable
0751      * The userspace driver sets this to 0x04, but the datasheet says 0x06
0752      */
0753     repaper_write_val(spi, 0x02, 0x04);
0754 
0755     epd->partial = false;
0756 out_exit:
0757     drm_dev_exit(idx);
0758 }
0759 
0760 static void repaper_pipe_disable(struct drm_simple_display_pipe *pipe)
0761 {
0762     struct repaper_epd *epd = drm_to_epd(pipe->crtc.dev);
0763     struct spi_device *spi = epd->spi;
0764     unsigned int line;
0765 
0766     /*
0767      * This callback is not protected by drm_dev_enter/exit since we want to
0768      * turn off the display on regular driver unload. It's highly unlikely
0769      * that the underlying SPI controller is gone should this be called after
0770      * unplug.
0771      */
0772 
0773     DRM_DEBUG_DRIVER("\n");
0774 
0775     /* Nothing frame */
0776     for (line = 0; line < epd->height; line++)
0777         repaper_one_line(epd, 0x7fffu, NULL, 0x00, NULL,
0778                  REPAPER_COMPENSATE);
0779 
0780     /* 2.7" */
0781     if (epd->border) {
0782         /* Dummy line */
0783         repaper_one_line(epd, 0x7fffu, NULL, 0x00, NULL,
0784                  REPAPER_COMPENSATE);
0785         msleep(25);
0786         gpiod_set_value_cansleep(epd->border, 0);
0787         msleep(200);
0788         gpiod_set_value_cansleep(epd->border, 1);
0789     } else {
0790         /* Border dummy line */
0791         repaper_one_line(epd, 0x7fffu, NULL, 0x00, NULL,
0792                  REPAPER_NORMAL);
0793         msleep(200);
0794     }
0795 
0796     /* not described in datasheet */
0797     repaper_write_val(spi, 0x0b, 0x00);
0798     /* Latch reset turn on */
0799     repaper_write_val(spi, 0x03, 0x01);
0800     /* Power off charge pump Vcom */
0801     repaper_write_val(spi, 0x05, 0x03);
0802     /* Power off charge pump neg voltage */
0803     repaper_write_val(spi, 0x05, 0x01);
0804     msleep(120);
0805     /* Discharge internal */
0806     repaper_write_val(spi, 0x04, 0x80);
0807     /* turn off all charge pumps */
0808     repaper_write_val(spi, 0x05, 0x00);
0809     /* Turn off osc */
0810     repaper_write_val(spi, 0x07, 0x01);
0811     msleep(50);
0812 
0813     power_off(epd);
0814 }
0815 
0816 static void repaper_pipe_update(struct drm_simple_display_pipe *pipe,
0817                 struct drm_plane_state *old_state)
0818 {
0819     struct drm_plane_state *state = pipe->plane.state;
0820     struct drm_rect rect;
0821 
0822     if (!pipe->crtc.state->active)
0823         return;
0824 
0825     if (drm_atomic_helper_damage_merged(old_state, state, &rect))
0826         repaper_fb_dirty(state->fb);
0827 }
0828 
0829 static const struct drm_simple_display_pipe_funcs repaper_pipe_funcs = {
0830     .enable = repaper_pipe_enable,
0831     .disable = repaper_pipe_disable,
0832     .update = repaper_pipe_update,
0833 };
0834 
0835 static int repaper_connector_get_modes(struct drm_connector *connector)
0836 {
0837     struct repaper_epd *epd = drm_to_epd(connector->dev);
0838     struct drm_display_mode *mode;
0839 
0840     mode = drm_mode_duplicate(connector->dev, epd->mode);
0841     if (!mode) {
0842         DRM_ERROR("Failed to duplicate mode\n");
0843         return 0;
0844     }
0845 
0846     drm_mode_set_name(mode);
0847     mode->type |= DRM_MODE_TYPE_PREFERRED;
0848     drm_mode_probed_add(connector, mode);
0849 
0850     connector->display_info.width_mm = mode->width_mm;
0851     connector->display_info.height_mm = mode->height_mm;
0852 
0853     return 1;
0854 }
0855 
0856 static const struct drm_connector_helper_funcs repaper_connector_hfuncs = {
0857     .get_modes = repaper_connector_get_modes,
0858 };
0859 
0860 static const struct drm_connector_funcs repaper_connector_funcs = {
0861     .reset = drm_atomic_helper_connector_reset,
0862     .fill_modes = drm_helper_probe_single_connector_modes,
0863     .destroy = drm_connector_cleanup,
0864     .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
0865     .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
0866 };
0867 
0868 static const struct drm_mode_config_funcs repaper_mode_config_funcs = {
0869     .fb_create = drm_gem_fb_create_with_dirty,
0870     .atomic_check = drm_atomic_helper_check,
0871     .atomic_commit = drm_atomic_helper_commit,
0872 };
0873 
0874 static const uint32_t repaper_formats[] = {
0875     DRM_FORMAT_XRGB8888,
0876 };
0877 
0878 static const struct drm_display_mode repaper_e1144cs021_mode = {
0879     DRM_SIMPLE_MODE(128, 96, 29, 22),
0880 };
0881 
0882 static const u8 repaper_e1144cs021_cs[] = { 0x00, 0x00, 0x00, 0x00,
0883                         0x00, 0x0f, 0xff, 0x00 };
0884 
0885 static const struct drm_display_mode repaper_e1190cs021_mode = {
0886     DRM_SIMPLE_MODE(144, 128, 36, 32),
0887 };
0888 
0889 static const u8 repaper_e1190cs021_cs[] = { 0x00, 0x00, 0x00, 0x03,
0890                         0xfc, 0x00, 0x00, 0xff };
0891 
0892 static const struct drm_display_mode repaper_e2200cs021_mode = {
0893     DRM_SIMPLE_MODE(200, 96, 46, 22),
0894 };
0895 
0896 static const u8 repaper_e2200cs021_cs[] = { 0x00, 0x00, 0x00, 0x00,
0897                         0x01, 0xff, 0xe0, 0x00 };
0898 
0899 static const struct drm_display_mode repaper_e2271cs021_mode = {
0900     DRM_SIMPLE_MODE(264, 176, 57, 38),
0901 };
0902 
0903 static const u8 repaper_e2271cs021_cs[] = { 0x00, 0x00, 0x00, 0x7f,
0904                         0xff, 0xfe, 0x00, 0x00 };
0905 
0906 DEFINE_DRM_GEM_CMA_FOPS(repaper_fops);
0907 
0908 static const struct drm_driver repaper_driver = {
0909     .driver_features    = DRIVER_GEM | DRIVER_MODESET | DRIVER_ATOMIC,
0910     .fops           = &repaper_fops,
0911     DRM_GEM_CMA_DRIVER_OPS_VMAP,
0912     .name           = "repaper",
0913     .desc           = "Pervasive Displays RePaper e-ink panels",
0914     .date           = "20170405",
0915     .major          = 1,
0916     .minor          = 0,
0917 };
0918 
0919 static const struct of_device_id repaper_of_match[] = {
0920     { .compatible = "pervasive,e1144cs021", .data = (void *)E1144CS021 },
0921     { .compatible = "pervasive,e1190cs021", .data = (void *)E1190CS021 },
0922     { .compatible = "pervasive,e2200cs021", .data = (void *)E2200CS021 },
0923     { .compatible = "pervasive,e2271cs021", .data = (void *)E2271CS021 },
0924     {},
0925 };
0926 MODULE_DEVICE_TABLE(of, repaper_of_match);
0927 
0928 static const struct spi_device_id repaper_id[] = {
0929     { "e1144cs021", E1144CS021 },
0930     { "e1190cs021", E1190CS021 },
0931     { "e2200cs021", E2200CS021 },
0932     { "e2271cs021", E2271CS021 },
0933     { },
0934 };
0935 MODULE_DEVICE_TABLE(spi, repaper_id);
0936 
0937 static int repaper_probe(struct spi_device *spi)
0938 {
0939     const struct drm_display_mode *mode;
0940     const struct spi_device_id *spi_id;
0941     struct device *dev = &spi->dev;
0942     enum repaper_model model;
0943     const char *thermal_zone;
0944     struct repaper_epd *epd;
0945     size_t line_buffer_size;
0946     struct drm_device *drm;
0947     const void *match;
0948     int ret;
0949 
0950     match = device_get_match_data(dev);
0951     if (match) {
0952         model = (enum repaper_model)match;
0953     } else {
0954         spi_id = spi_get_device_id(spi);
0955         model = (enum repaper_model)spi_id->driver_data;
0956     }
0957 
0958     /* The SPI device is used to allocate dma memory */
0959     if (!dev->coherent_dma_mask) {
0960         ret = dma_coerce_mask_and_coherent(dev, DMA_BIT_MASK(32));
0961         if (ret) {
0962             dev_warn(dev, "Failed to set dma mask %d\n", ret);
0963             return ret;
0964         }
0965     }
0966 
0967     epd = devm_drm_dev_alloc(dev, &repaper_driver,
0968                  struct repaper_epd, drm);
0969     if (IS_ERR(epd))
0970         return PTR_ERR(epd);
0971 
0972     drm = &epd->drm;
0973 
0974     ret = drmm_mode_config_init(drm);
0975     if (ret)
0976         return ret;
0977     drm->mode_config.funcs = &repaper_mode_config_funcs;
0978 
0979     epd->spi = spi;
0980 
0981     epd->panel_on = devm_gpiod_get(dev, "panel-on", GPIOD_OUT_LOW);
0982     if (IS_ERR(epd->panel_on)) {
0983         ret = PTR_ERR(epd->panel_on);
0984         if (ret != -EPROBE_DEFER)
0985             DRM_DEV_ERROR(dev, "Failed to get gpio 'panel-on'\n");
0986         return ret;
0987     }
0988 
0989     epd->discharge = devm_gpiod_get(dev, "discharge", GPIOD_OUT_LOW);
0990     if (IS_ERR(epd->discharge)) {
0991         ret = PTR_ERR(epd->discharge);
0992         if (ret != -EPROBE_DEFER)
0993             DRM_DEV_ERROR(dev, "Failed to get gpio 'discharge'\n");
0994         return ret;
0995     }
0996 
0997     epd->reset = devm_gpiod_get(dev, "reset", GPIOD_OUT_LOW);
0998     if (IS_ERR(epd->reset)) {
0999         ret = PTR_ERR(epd->reset);
1000         if (ret != -EPROBE_DEFER)
1001             DRM_DEV_ERROR(dev, "Failed to get gpio 'reset'\n");
1002         return ret;
1003     }
1004 
1005     epd->busy = devm_gpiod_get(dev, "busy", GPIOD_IN);
1006     if (IS_ERR(epd->busy)) {
1007         ret = PTR_ERR(epd->busy);
1008         if (ret != -EPROBE_DEFER)
1009             DRM_DEV_ERROR(dev, "Failed to get gpio 'busy'\n");
1010         return ret;
1011     }
1012 
1013     if (!device_property_read_string(dev, "pervasive,thermal-zone",
1014                      &thermal_zone)) {
1015         epd->thermal = thermal_zone_get_zone_by_name(thermal_zone);
1016         if (IS_ERR(epd->thermal)) {
1017             DRM_DEV_ERROR(dev, "Failed to get thermal zone: %s\n", thermal_zone);
1018             return PTR_ERR(epd->thermal);
1019         }
1020     }
1021 
1022     switch (model) {
1023     case E1144CS021:
1024         mode = &repaper_e1144cs021_mode;
1025         epd->channel_select = repaper_e1144cs021_cs;
1026         epd->stage_time = 480;
1027         epd->bytes_per_scan = 96 / 4;
1028         epd->middle_scan = true; /* data-scan-data */
1029         epd->pre_border_byte = false;
1030         epd->border_byte = REPAPER_BORDER_BYTE_ZERO;
1031         break;
1032 
1033     case E1190CS021:
1034         mode = &repaper_e1190cs021_mode;
1035         epd->channel_select = repaper_e1190cs021_cs;
1036         epd->stage_time = 480;
1037         epd->bytes_per_scan = 128 / 4 / 2;
1038         epd->middle_scan = false; /* scan-data-scan */
1039         epd->pre_border_byte = false;
1040         epd->border_byte = REPAPER_BORDER_BYTE_SET;
1041         break;
1042 
1043     case E2200CS021:
1044         mode = &repaper_e2200cs021_mode;
1045         epd->channel_select = repaper_e2200cs021_cs;
1046         epd->stage_time = 480;
1047         epd->bytes_per_scan = 96 / 4;
1048         epd->middle_scan = true; /* data-scan-data */
1049         epd->pre_border_byte = true;
1050         epd->border_byte = REPAPER_BORDER_BYTE_NONE;
1051         break;
1052 
1053     case E2271CS021:
1054         epd->border = devm_gpiod_get(dev, "border", GPIOD_OUT_LOW);
1055         if (IS_ERR(epd->border)) {
1056             ret = PTR_ERR(epd->border);
1057             if (ret != -EPROBE_DEFER)
1058                 DRM_DEV_ERROR(dev, "Failed to get gpio 'border'\n");
1059             return ret;
1060         }
1061 
1062         mode = &repaper_e2271cs021_mode;
1063         epd->channel_select = repaper_e2271cs021_cs;
1064         epd->stage_time = 630;
1065         epd->bytes_per_scan = 176 / 4;
1066         epd->middle_scan = true; /* data-scan-data */
1067         epd->pre_border_byte = true;
1068         epd->border_byte = REPAPER_BORDER_BYTE_NONE;
1069         break;
1070 
1071     default:
1072         return -ENODEV;
1073     }
1074 
1075     epd->mode = mode;
1076     epd->width = mode->hdisplay;
1077     epd->height = mode->vdisplay;
1078     epd->factored_stage_time = epd->stage_time;
1079 
1080     line_buffer_size = 2 * epd->width / 8 + epd->bytes_per_scan + 2;
1081     epd->line_buffer = devm_kzalloc(dev, line_buffer_size, GFP_KERNEL);
1082     if (!epd->line_buffer)
1083         return -ENOMEM;
1084 
1085     epd->current_frame = devm_kzalloc(dev, epd->width * epd->height / 8,
1086                       GFP_KERNEL);
1087     if (!epd->current_frame)
1088         return -ENOMEM;
1089 
1090     drm->mode_config.min_width = mode->hdisplay;
1091     drm->mode_config.max_width = mode->hdisplay;
1092     drm->mode_config.min_height = mode->vdisplay;
1093     drm->mode_config.max_height = mode->vdisplay;
1094 
1095     drm_connector_helper_add(&epd->connector, &repaper_connector_hfuncs);
1096     ret = drm_connector_init(drm, &epd->connector, &repaper_connector_funcs,
1097                  DRM_MODE_CONNECTOR_SPI);
1098     if (ret)
1099         return ret;
1100 
1101     ret = drm_simple_display_pipe_init(drm, &epd->pipe, &repaper_pipe_funcs,
1102                        repaper_formats, ARRAY_SIZE(repaper_formats),
1103                        NULL, &epd->connector);
1104     if (ret)
1105         return ret;
1106 
1107     drm_mode_config_reset(drm);
1108 
1109     ret = drm_dev_register(drm, 0);
1110     if (ret)
1111         return ret;
1112 
1113     spi_set_drvdata(spi, drm);
1114 
1115     DRM_DEBUG_DRIVER("SPI speed: %uMHz\n", spi->max_speed_hz / 1000000);
1116 
1117     drm_fbdev_generic_setup(drm, 0);
1118 
1119     return 0;
1120 }
1121 
1122 static void repaper_remove(struct spi_device *spi)
1123 {
1124     struct drm_device *drm = spi_get_drvdata(spi);
1125 
1126     drm_dev_unplug(drm);
1127     drm_atomic_helper_shutdown(drm);
1128 }
1129 
1130 static void repaper_shutdown(struct spi_device *spi)
1131 {
1132     drm_atomic_helper_shutdown(spi_get_drvdata(spi));
1133 }
1134 
1135 static struct spi_driver repaper_spi_driver = {
1136     .driver = {
1137         .name = "repaper",
1138         .of_match_table = repaper_of_match,
1139     },
1140     .id_table = repaper_id,
1141     .probe = repaper_probe,
1142     .remove = repaper_remove,
1143     .shutdown = repaper_shutdown,
1144 };
1145 module_spi_driver(repaper_spi_driver);
1146 
1147 MODULE_DESCRIPTION("Pervasive Displays RePaper DRM driver");
1148 MODULE_AUTHOR("Noralf Trønnes");
1149 MODULE_LICENSE("GPL");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!