* [PATCH 11/29] video/uvesafb: rename random32() to prandom_u32()
From: Akinobu Mita @ 2012-12-24 2:13 UTC (permalink / raw)
To: linux-kernel, akpm
Cc: Akinobu Mita, Michal Januszewski, Florian Tobias Schandinat,
linux-fbdev
In-Reply-To: <1356315256-6572-1-git-send-email-akinobu.mita@gmail.com>
Use more preferable function name which implies using a pseudo-random
number generator.
Signed-off-by: Akinobu Mita <akinobu.mita@gmail.com>
Cc: Michal Januszewski <spock@gentoo.org>
Cc: Florian Tobias Schandinat <FlorianSchandinat@gmx.de>
Cc: linux-fbdev@vger.kernel.org
---
drivers/video/uvesafb.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/drivers/video/uvesafb.c b/drivers/video/uvesafb.c
index 2f8f82d..d120b11 100644
--- a/drivers/video/uvesafb.c
+++ b/drivers/video/uvesafb.c
@@ -166,7 +166,7 @@ static int uvesafb_exec(struct uvesafb_ktask *task)
memcpy(&m->id, &uvesafb_cn_id, sizeof(m->id));
m->seq = seq;
m->len = len;
- m->ack = random32();
+ m->ack = prandom_u32();
/* uvesafb_task structure */
memcpy(m + 1, &task->t, sizeof(task->t));
--
1.7.11.7
^ permalink raw reply related
* N/A
From: mrs philips Rita @ 2012-12-22 22:13 UTC (permalink / raw)
To: linux-fbdev
In-Reply-To: <20121222221114.M77589@live.com>
Dear
friend please i need your quick reply do not ignore this email for no reason
i am Mrs.Rita Philips
Thanks and God Be with you
Best Regards
^ permalink raw reply
* N/A
From: mrs philips Rita @ 2012-12-22 22:09 UTC (permalink / raw)
To: linux-fbdev
Dear
friend please i need your quick reply do not ignore this email for no reason
i am Mrs.Rita Philips
Thanks and God Be with you
Best Regards
^ permalink raw reply
* Re: [PATCHv16 0/7] of: add display helper
From: Leela Krishna Amudala @ 2012-12-21 15:48 UTC (permalink / raw)
To: Steffen Trumtrar
Cc: linux-fbdev-u79uwXL29TY76Z2rM5mHXA, David Airlie,
devicetree-discuss-uLR06cmDAlY/bJ5BZ2RsiQ,
Florian Tobias Schandinat,
dri-devel-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW, Rob Clark,
Tomi Valkeinen, Laurent Pinchart, kernel-bIcnvbaLZ9MEGnE8C9+IrQ,
Guennady Liakhovetski, linux-media-u79uwXL29TY76Z2rM5mHXA
In-Reply-To: <1355850256-16135-1-git-send-email-s.trumtrar-bIcnvbaLZ9MEGnE8C9+IrQ@public.gmane.org>
Hello All,
Any comments for this patch set..?
Best Wishes,
Leela Krishna Amudala.
On Tue, Dec 18, 2012 at 10:34 PM, Steffen Trumtrar
<s.trumtrar@pengutronix.de> wrote:
>
> Hi!
>
> Finally, right in time before the end of the world on friday, v16 of the
> display helpers.
>
> Changes since v15:
> - move include/linux/{videomode,display_timing}.h to include/video
> - move include/linux/of_{videomode,display_timing}.h to
> include/video
> - reimplement flags: add VESA flags and data flags
> - let pixelclock in struct videomode be unsigned long
> - rename of_display_timings_exists to of_display_timings_exist
> - revise logging/error messages: replace __func__ with
> np->full_name
> - rename pixelclk-inverted to pixelclk-active
> - revise comments in code
>
> Changes since v14:
> - fix "const struct *" warning
> (reported by: Leela Krishna Amudala
> <l.krishna@samsung.com>)
> - return -EINVAL when htotal or vtotal are zero
> - remove unreachable code in of_get_display_timings
> - include headers in .c files and not implicit in .h
> - sort includes alphabetically
> - fix lower/uppercase in binding documentation
> - rebase onto v3.7-rc7
>
> Changes since v13:
> - fix "const struct *" warning
> (reported by: Laurent Pinchart
> <laurent.pinchart@ideasonboard.com>)
> - prevent division by zero in fb_videomode_from_videomode
>
> Changes since v12:
> - rename struct display_timing to via_display_timing in via
> subsystem
> - fix refreshrate calculation
> - fix "const struct *" warnings
> (reported by: Manjunathappa, Prakash <prakash.pm@ti.com>)
> - some CodingStyle fixes
> - rewrite parts of commit messages and display-timings.txt
> - let display_timing_get_value get all values instead of just
> typical
>
> Changes since v11:
> - make pointers const where applicable
> - add reviewed-by Laurent Pinchart
>
> Changes since v10:
> - fix function name (drm_)display_mode_from_videomode
> - add acked-by, reviewed-by, tested-by
>
> Changes since v9:
> - don't leak memory when previous timings were correct
> - CodingStyle fixes
> - move blank lines around
>
> Changes since v8:
> - fix memory leaks
> - change API to be more consistent (foo_from_bar(struct bar,
> struct foo))
> - include headers were necessary
> - misc minor bugfixes
>
> Changes since v7:
> - move of_xxx to drivers/video
> - remove non-binding documentation from display-timings.txt
> - squash display_timings and videomode in one patch
> - misc minor fixes
>
> Changes since v6:
> - get rid of some empty lines etc.
> - move functions to their subsystems
> - split of_ from non-of_ functions
> - add at least some kerneldoc to some functions
>
> Changes since v5:
> - removed all display stuff and just describe timings
>
> Changes since v4:
> - refactored functions
>
> Changes since v3:
> - print error messages
> - free alloced memory
> - general cleanup
>
> Changes since v2:
> - use hardware-near property-names
> - provide a videomode structure
> - allow ranges for all properties (<min,typ,max>)
> - functions to get display_mode or fb_videomode
>
> Regards,
> Steffen
>
>
>
> Steffen Trumtrar (7):
> viafb: rename display_timing to via_display_timing
> video: add display_timing and videomode
> video: add of helper for display timings/videomode
> fbmon: add videomode helpers
> fbmon: add of_videomode helpers
> drm_modes: add videomode helpers
> drm_modes: add of_videomode helpers
>
> .../devicetree/bindings/video/display-timing.txt | 109 +++++++++
> drivers/gpu/drm/drm_modes.c | 70 ++++++
> drivers/video/Kconfig | 21 ++
> drivers/video/Makefile | 4 +
> drivers/video/display_timing.c | 24 ++
> drivers/video/fbmon.c | 94 ++++++++
> drivers/video/of_display_timing.c | 239
> ++++++++++++++++++++
> drivers/video/of_videomode.c | 54 +++++
> drivers/video/via/hw.c | 6 +-
> drivers/video/via/hw.h | 2 +-
> drivers/video/via/lcd.c | 2 +-
> drivers/video/via/share.h | 2 +-
> drivers/video/via/via_modesetting.c | 8 +-
> drivers/video/via/via_modesetting.h | 6 +-
> drivers/video/videomode.c | 39 ++++
> include/drm/drmP.h | 9 +
> include/linux/fb.h | 8 +
> include/video/display_timing.h | 124 ++++++++++
> include/video/of_display_timing.h | 20 ++
> include/video/of_videomode.h | 18 ++
> include/video/videomode.h | 48 ++++
> 21 files changed, 894 insertions(+), 13 deletions(-)
> create mode 100644
> Documentation/devicetree/bindings/video/display-timing.txt
> create mode 100644 drivers/video/display_timing.c
> create mode 100644 drivers/video/of_display_timing.c
> create mode 100644 drivers/video/of_videomode.c
> create mode 100644 drivers/video/videomode.c
> create mode 100644 include/video/display_timing.h
> create mode 100644 include/video/of_display_timing.h
> create mode 100644 include/video/of_videomode.h
> create mode 100644 include/video/videomode.h
>
> --
> 1.7.10.4
>
^ permalink raw reply
* Re: [RFC v2 0/5] Common Display Framework
From: Tomasz Figa @ 2012-12-21 10:00 UTC (permalink / raw)
To: dri-devel
Cc: Vikas Sajjan, Laurent Pinchart, Thomas Petazzoni, linux-fbdev,
Benjamin Gaignard, Tom Gall, Kyungmin Park, Rob Clark,
Ragesh Radhakrishnan, Tomi Valkeinen, Philipp Zabel, Bryan Wu,
Maxime Ripard, sunil joshi, Sumit Semwal, Sebastien Guiriec,
linux-media
In-Reply-To: <CAD025yQoCiNaKvaCwvUWhk_jV70CPhV35UzV9MR6HtE+1baCxg@mail.gmail.com>
Hi Vikas,
On Tuesday 18 of December 2012 08:31:30 Vikas Sajjan wrote:
> Hi Laurent,
>
> Thanks for the reply.
>
> On 17 December 2012 20:55, Laurent Pinchart <
>
> laurent.pinchart@ideasonboard.com> wrote:
> > Hi Vikas,
> >
> > Sorry for the late reply. I now have more time to work on CDF, so
> > delays should be much shorter.
> >
> > On Thursday 06 December 2012 10:51:15 Vikas Sajjan wrote:
> > > Hi Laurent,
> > >
> > > I was thinking of porting CDF to samsung EXYNOS 5250 platform, what
> > > I
> >
> > found
> >
> > > is that, the exynos display controller is MIPI DSI based controller.
> > >
> > > But if I look at CDF patches, it has only support for MIPI DBI based
> >
> > Display
> >
> > > controller.
> > >
> > > So my question is, do we have any generic framework for MIPI DSI
> > > based
> > > display controller? basically I wanted to know, how to go about
> > > porting
> >
> > CDF
> >
> > > for such kind of display controller.
> >
> > MIPI DSI support is not available yet. The only reason for that is
> > that I don't have any MIPI DSI hardware to write and test the code
> > with :-)
> >
> > The common display framework should definitely support MIPI DSI. I
> > think the
> > existing MIPI DBI code could be used as a base, so the implementation
> > shouldn't be too high.
> >
> > Yeah, i was also thinking in similar lines, below is my though for
> > MIPI
>
> DSI support in CDF.
>
> o MIPI DSI support as part of CDF framework will expose
>
> § mipi_dsi_register_device(mpi_device) (will be called mach-xxx-dt.c
> file )
>
> § mipi_dsi_register_driver(mipi_driver, bus ops) (will be called from
> platform specific init driver call )
>
> · bus ops will be
>
> o read data
>
> o write data
>
> o write command
>
> § MIPI DSI will be registered as bus_register()
>
> When MIPI DSI probe is called, it (e.g., Exynos or OMAP MIPI DSI) will
> initialize the MIPI DSI HW IP.
>
> This probe will also parse the DT file for MIPI DSI based panel, add
> the panel device (device_add() ) to kernel and register the display
> entity with its control and video ops with CDF.
>
> I can give this a try.
I am currently in progress of reworking Exynos MIPI DSIM code and s6e8ax0
LCD driver to use the v2 RFC of Common Display Framework. I have most of
the work done, I have just to solve several remaining problems.
Best regards,
--
Tomasz Figa
Samsung Poland R&D Center
SW Solution Development, Linux Platform
^ permalink raw reply
* [GIT PULL] UAPI disintegration for fbdev
From: David Howells @ 2012-12-20 17:49 UTC (permalink / raw)
To: torvalds
Cc: dhowells, FlorianSchandinat, tomi.valkeinen, linux-fbdev,
linux-kernel
Hi Linus,
Could you consider pulling my UAPI disintegration for fbdev branch please?
The maintainer (Florian Tobias Schandinat) said he didn't mind if I wanted to
push it forward.
David
---
The following changes since commit 1800098549fc310cffffefdcb3722adaad0edda8:
ARM: OMAP: Fix build breakage due to missing include in i2c.c (2012-12-20 08:43:25 -0800)
are available in the git repository at:
git://git.infradead.org/users/dhowells/linux-headers.git tags/disintegrate-fbdev-20121220
for you to fetch changes up to b889fcf63cb62e7fdb7816565e28f44dbe4a76a5:
UAPI: (Scripted) Disintegrate include/video (2012-12-20 17:14:26 +0000)
----------------------------------------------------------------
UAPI disintegration 2012-12-20
----------------------------------------------------------------
David Howells (1):
UAPI: (Scripted) Disintegrate include/video
include/uapi/video/Kbuild | 3 +
include/uapi/video/edid.h | 9 ++
include/uapi/video/sisfb.h | 209 +++++++++++++++++++++++++++++++++++++++++++
include/uapi/video/uvesafb.h | 60 +++++++++++++
include/video/Kbuild | 3 -
include/video/edid.h | 7 +-
include/video/sisfb.h | 189 +-------------------------------------
include/video/uvesafb.h | 58 +-----------
8 files changed, 284 insertions(+), 254 deletions(-)
create mode 100644 include/uapi/video/edid.h
create mode 100644 include/uapi/video/sisfb.h
create mode 100644 include/uapi/video/uvesafb.h
^ permalink raw reply
* Re: [RFC 0/6] Common Display Framework-T
From: Laurent Pinchart @ 2012-12-19 22:59 UTC (permalink / raw)
To: Tomi Valkeinen; +Cc: linux-fbdev, dri-devel
In-Reply-To: <50D1D4D6.1090308@ti.com>
[-- Attachment #1: Type: text/plain, Size: 15634 bytes --]
Hi Tomi,
On Wednesday 19 December 2012 16:53:10 Tomi Valkeinen wrote:
> On 2012-12-19 15:21, Laurent Pinchart wrote:
> > On Friday 14 December 2012 16:27:26 Tomi Valkeinen wrote:
> >> Hi,
> >>
> >> I have been testing Common Display Framework on OMAP, and making changes
> >> that I've discussed in the posts I've sent in reply to the CDF series
> >> from Laurent. While my CDF code is rather hacky and not at all ready, I
> >> wanted to post the code for comments and also as a reference code to my
> >> posts.
> >>
> >> So here is CDF-T (Tomi-edition =).
> >
> > We've discussed your approach extensively face-to-face today so I won't
> > review the patches in detail, but I will instead summarize our discussion
> > to make sure we understood each other (and let other developers jump in).
>
> I have some comments =). But mostly it looks good.
Thanks :-)
> > For the purpose of this discussion the term "display controller driver"
> > (or just "display controller") refer to both the low-level driver layer
> > that communicates directly with the display controller hardware, and to
> > the higher- level driver layer that implements and exposes the userspace
> > API (FBDEV, KMS and/or V4L). Those layers can be implemented in multiple
> > kernel modules (such as in the OMAP DSS case, with omapdss for the
> > low-level layer and omapdrm, omapfb and omapvout for the API-level layer)
> > or a single kernel module.
> >
> > Control model
> > -------------
> >
> > The figure at http://www.ideasonboard.org/media/cdf/cdf-panel-control-
> > model.png shows the CDF control model.
> >
> > The panel object depicted on the figure doesn't need to be a panel in the
> > stricter sense but could be any chain of off-SoC (both on-board or
> > off-board) display entities. It however helps thinking about it as a
> > panel and doesn't hurt the model.
>
> I don't think it needs to be off-soc. The dispc and the panel in the
> image could be any two components, in- or off-soc.
That's correct, whether the components are on-SoC or off-SoC doesn't matter
here.
> > The panel is controlled through abstract control requests. Those requests
> > are used to retrieve panel information (such as the physical size, the
> > supported video modes, EDID information, ...), set the panel
> > configuration (such as the active video timings) or control the panel
> > operation state (enabling/disabling the panel, controlling panel blanking
> > and power management, ...). They are exposed by the panel using function
> > pointers, and called by other kernel components in response to userspace
> > requests (through the FBDEV, KMS or V4L2 APIs) or in-kernel events (for
> > instance hotplug notifications).
> >
> > In response to the control requests the panel driver will communicate with
> > the panel through the panel control bus (I2C, SPI, DBI, DSI, GPIO, ...,
> > not shown on the figure) and will control the video stream it receives on
> > its input.
> >
> > The panel is connected at the hardware level to a video source (shown as a
> > green hashed rectangle) that provides it with a video stream. The video
> > stream flows from the video source to the panel and is directly
> > controlled by its source, as shown by the green arrow from the display
> > controller to the video stream. The video source exposes stream control
> > operations as function pointers that are used by the panel to control the
> > video stream, as shown by the green arrow from the panel to the video
> > source.
> >
> > The figure at http://www.ideasonboard.org/media/cdf/cdf-panel-control-
> > model-2.png shows the call flow across entities when the panel is a
> > pipeline made of more than a single entity. In this case the SoC (on the
> > left of the dashed line) outputs a video stream on a DSI bus connected to
> > a DSI to LVDS transmitter. The output of the DSI to LVDS transmitter is
> > connected to an LVDS panel (or, more accurately, an LVDS panel module
> > made of an LVDS panel controller and a panel).
>
> Here also I don't see any reason to separate in- or off-soc components.
> I think the call from DISPC, which now goes to the transmitter, should
> first go to the DPI/DSI block. Whether the DPI/DSI block is in- or
> off-soc should be irrelevant regarding CDF.
Agreed.
> > The transmitter and panel module are seen by the display controller and
> > userspace API implementations as a single entity that exposes control
> > request operations and controls its input video stream. When a control
> > request is
>
> I don't like the sound of this. I think the CDF shouldn't care how the
> userspace API is implemented. There's no reason in CDF level to separate
> in- or out-soc entities, nor expose only one entity. If DRM requires
> mapping DRM's crtc, encoder and connector to, respectively, dispc,
> DPI/DSI, the-rest, it should be able to do that, but CDF shouldn't force
> that model.
>
> Of course, the implementor of the particular SoC display driver could decide
> to use one display entity that covers both dispc and DPI/DSI blocks. But at
> least I would like to have OMAP's DISPC as a display entity (or actually
> multiple entities, one for each DISPC output), and the various in-SoC DPI-
> to-something encoders as display entities.
OK, I haven't expressed myself correctly. I tried to describe here how the
"russian doll model" of cascaded calls across entities works. I didn't want to
force any in-/off-SoC model.
> > performed (outermost green arrow) the DSI to LVDS transmitter will
> > propagate it to the panel, possibly mangling the input parameters or the
> > response. For panel operation state control requests the last entity in
> > the pipeline will likely want to control the video stream it receives on
> > its input. The video stream control calls will be propagated from right
> > to left as shown by the red arrows.
> >
> > Every entity in the call stack can communicate with its hardware device
> > through the corresponding control bus, and/or control the video stream it
> > receives on its input.
> >
> > This model allows filtering out modes and timings supported by the panel
> > but unsupported by the transmitter and mangling the modes and timings
> > according to the transmitter limitations. It has no complexity drawback
> > for simple devices, as the corresponding drivers can just forward the
> > calls directly. Similar use cases could exist for other control
> > operations than mode and information retrieval.
> >
> > Discovery
> > ---------
> >
> > Before being able to issue control requests, panel devices need to be
> > discovered and associated with the connected display controller(s).
> >
> > Panels and display controllers are cross-dependent. There is no way around
>
> Perhaps semantics, but I don't think they are cross-dependent. True,
> they will call ops in each other, but the dispc will get the pointer to
> the panel when the panel connects the dispc and the panel. And when the
> panel disconnects, dispc will lose the reference to the panel.
>
> For me, cross-dependent would mean that dispc could have a reference to
> the panel regardless of what the panel does. In our case it is not so,
> and there's no harm with the dispc's reference to the panel, as the
> panel can remove it (almost) at any time.
The panel can ask the dispc to release its reference to the panel by calling
the disconnect function, but it can't disappear all of a sudden. I will test
the model for RFCv3.
> > that, as the display controller needs a reference to the panel to call
> > control requests in response to userspace API, and the panel needs a
> > reference to the display controller to call video stream control
> > functions (in addition to requiring generic resources such as clocks,
> > GPIOs or even regulators that could be provided by the display
> > controller).
> >
> > As we can't probe the display controller and the panel together, a probe
> > order needs to be defined. The decision was to consider video sources as
> > resources and defer panel probing until all required resources (video
> > stream source, clocks, GPIOs, regulators and more) are available. Display
> > controller probing must succeed without the panel being available. This
> > mimicks the hotpluggable monitor model (VGA, HDMI, DP) that doesn't
> > prevent display controllers from being successfully probed without a
> > connected monitor.
> >
> > Our design goal is to handle panel discovery in a similar (if not
> > identical) way as HDMI/DP hotplug in order to implement a single display
> > discovery method in display controller drivers. This might not be
> > achievable, in which case we'll reconsider the design requirement.
> >
> > When the display controller driver probes the device it will register the
> > video source(s) at the output of the display controller with the CDF core.
> > Those sources will be identified by the display controller dev_name() and
> > a source integer index. A new structure, likely called
> > display_entity_port, will be used to represent a source or sink video port
> > on a display entity.
> >
> > Panel drivers will handle video sources as resources. They will retrieve
> > at probe time the video source the panel is connected to using a phandle
> > or a source name (depending on whether the platform uses DT). If the
> > source isn't available the probe function will return -EPROBE_DEFER.
> >
> > In addition to the video stream control operations mentioned above, ports
> > will also expose a connect/disconnect operation use to notify them of
> > connection/disconnection events. After retrieving the connected video
> > source panel drivers call the connect/disconnect operation on the video
> > source to notify it that the panel is available.
> >
> > When the panel is a pipeline made of more than a single entity, entities
> > are probed in video source to video sink order. Out-of-order probe will
> > result in probe deferral as explained above due to the video source not
> > being available, resulting in the source to sink probe order. Entities
> > should not call the connect operation of their video source at probe time
> > in that case, but only when their own connect operation for the video
> > source(s) they provide to the next entity is called by the next entity.
> > Connect operations will thus be called in sink to source order starting
> > at the entity at the end of the pipeline and going all the way back to
> > the display controller.
> >
> > This notification system is a hotplug mechanism that replaces the display
> > entity notifier system from my previous RFC. Alan Cox rightly objected to
> > the notification system, arguing that such system-wide notifications were
> > used by FBDEV and very subject to abuse. I agree with his argument, this
> > new mechanism should result in a cleaner implementation as video sources
> > will only be notified of connect/disconnect events for the entity they're
> > connected to.
> >
> > DBI/DSI busses
> > --------------
> >
> > My RFC introduced a DBI bus using the Linux device and bus model. Its
> > purpose was multifold:
> >
> > - Support (un)registration, matching and binding of devices and drivers.
> >
> > - Provide power management (suspend/resume) services through the standard
> > Linux PM bus/device model, to make sure that DBI devices will be
> > suspended/resumed after/before their DBI bus controller.
> >
> > - Provide bus services to access the connected devices. For DBI that took
> > the form of command read and data read/write functions.
> >
> > A DSI bus implementation using the same model was also planned.
> >
> > Tomi's patches removed the DBI bus and replaced DBI devices with platform
> > devices, moving the bus services implementation to the video source. DBI
> > and DSI busses are always either pure video or video + control busses
> > (although controlling a DPI panel through DSI is conceivable, nobody in
> > his right mind, not even a hardware engineer, would likely implement
> > that), so there will always be a video source to provide the DBI/DSI
> > control operations.
> >
> > (Un)registration, matching and binding of devices and drivers is provided
> > by the platform device bus. Bus services to access connected devices are
> > provided by the video source, wrapper functions will be used to handle
> > serialization and locking, and possibly to offer higher level services
> > (such as DCS for instance).
> >
> > One drawback of using the platform bus is that PM relationships between
> > the bus master and slaves will not be taken into account during
> > suspend/resume. However, a similar issue exists for DPI panels, and PM
> > relationships at the video bus level for DBI and DSI are not handled by
> > the DBI/DSI busses either. As we need a generic solution to handle those
> > (likely through early suspend and late resume), the same solution can be
> > used to handle DBI and DSI control bus PM relationships without requiring
> > a Linux DBI or DSI bus.
> >
> > Even though I still like the idea of DBI and DSI busses, I agree with Tomi
> > that they're not strictly needed and I will drop them.
>
> I'd like to highlight two points I made about the bus model:
>
> - If DBI is used only for video, there's no DBI bus. How to configure
> DBI in this case?
I was planning to handle DBI video configuration through video stream
operations, so we agree here.
> - If DBI is used for control and video, we have two separate APIs for
> the bus. In theory it's possible to handle this, but in practice it may
> be impossible, especially for more complex busses like DSI.
>
> I think both of those issues would make the bus model very difficult to
> implement. I have no idea how it could be done neatly. So as I see it,
> it's not only about "not strictly needed", but that the bus model
> wouldn't work without complex code.
>
> > Entity model
> > ------------
> >
> > Tomi's proposal split the display entities into video sources (struct
> > video_source) and display entities (struct display_entity). To make
> > generic pipeline operations easier, we agreed to merge the video source
> > and the display entity back. struct display_entity thus models a display
> > entity that has any number of sink and/or source ports, modeled as struct
> > display_entity_port instances.
> >
> > Video stream operations will be exposed by the display entity as function
> > pointers and will take a port reference as argument (this could take the
> > form of struct display_entity * and port index, or struct
> > display_entity_port *).
>
> I'd very much like to have only one parameter to pass, as there may be lots
> of ops for some busses. Having two parameters to refer to the source is just
> extra code that has no extra benefit when using video source ops. Then
> again, having separate port index parameter could be perhaps simpler to
> implement for the one handling the video source ops, so...
>
> > The DVI and DSI operations model proposed by Tomi in this patch series
> > will be kept.
> >
> > Points that we forgot to discuss
> > --------------------------------
> >
> > - DISPLAY_ENTITY_STREAM_SINGLE_SHOT vs. update() operation
>
> Ah, yes, we missed that. I think it's possible to use SINGLE_SHOT, but
> then it requires some kind of system to inform about finished update. Or
> we could, of course, decide that informing about the update is done in
> dispc-specific code, like handling VSYNC.
>
> Hmm, except that won't probably work, as the panel (or any DSI device) may
> need to know if the DSI bus is currently used or not.
--
Regards,
Laurent Pinchart
[-- Attachment #2: This is a digitally signed message part. --]
[-- Type: application/pgp-signature, Size: 490 bytes --]
^ permalink raw reply
* Re: [RFC v2 0/5] Common Display Framework
From: Stéphane Marchesin @ 2012-12-19 20:13 UTC (permalink / raw)
To: Inki Dae
Cc: Daniel Vetter, Thomas Petazzoni, Linux Fbdev development list,
Philipp Zabel, Tom Gall, Ragesh Radhakrishnan,
dri-devel@lists.freedesktop.org, Rob Clark, Kyungmin Park,
Tomi Valkeinen, Laurent Pinchart, Benjamin Gaignard, Bryan Wu,
Maxime Ripard, Vikas Sajjan, Sumit Semwal, Sebastien Guiriec,
linux-media@vger.kernel.org
In-Reply-To: <CAAQKjZMt+13oooEw39mOM1rF2=ss4ih1s7iVS362di-50h4+Hg@mail.gmail.com>
On Tue, Dec 18, 2012 at 1:38 AM, Inki Dae <inki.dae@samsung.com> wrote:
>
>
> 2012/12/18 Daniel Vetter <daniel@ffwll.ch>
>>
>> On Tue, Dec 18, 2012 at 7:21 AM, Rob Clark <rob.clark@linaro.org> wrote:
>> >> The other thing I'd like you guys to do is kill the idea of fbdev and
>> >> v4l drivers that are "shared" with the drm codebase, really just
>> >> implement fbdev and v4l on top of the drm layer, some people might
>> >> think this is some sort of maintainer thing, but really nothing else
>> >> makes sense, and having these shared display frameworks just to avoid
>> >> having using drm/kms drivers seems totally pointless. Fix the drm
>> >> fbdev emulation if an fbdev interface is needed. But creating a fourth
>> >> framework because our previous 3 frameworks didn't work out doesn't
>> >> seem like a situation I want to get behind too much.
>> >
>> > yeah, let's not have multiple frameworks to do the same thing.. For
>> > fbdev, it is pretty clear that it is a dead end. For v4l2
>> > (subdev+mcf), it is perhaps bit more flexible when it comes to random
>> > arbitrary hw pipelines than kms. But to take advantage of that, your
>> > userspace isn't going to be portable anyways, so you might as well use
>> > driver specific properties/ioctls. But I tend to think that is more
>> > useful for cameras. And from userspace perspective, kms planes are
>> > less painful to use for output than v4l2, so lets stick to drm/kms for
>> > output (and not try to add camera/capture support to kms).. k, thx
>>
>> Yeah, I guess having a v4l device also exported by the same driver
>> that exports the drm interface might make sense in some cases. But in
>> many cases I think the video part is just an independent IP block and
>> shuffling data around with dma-buf is all we really need. So yeah, I
>> guess sharing display resources between v4l and drm kms driver should
>> be a last resort option, since coordination (especially if it's
>> supposed to be somewhat dynamic) will be extremely hairy.
>
>
> I think the one reason that the CDF was appeared is to avoid duplicating
> codes. For example, we should duplicate mipi-dsi or dbi drivers into drm to
> avoid ordering issue. And for this, those should be re-implemented in based
> on drm framework so that those could be treated as all one device. Actually,
> in case of Exynos, some guys tried to duplicate eDP driver into exynos drm
> framework in same issue.
If you're talking about us, this is misleading, as we didn't try to
duplicate the eDP driver. What we did is remove it from driver/video
and put it in DRM.
The reason for that is that it's not needed for fbdev, since KMS
helpers let you implement fbdev. So we can just remove all the exynos
graphics support from drivers/video since it becomes obsolete with the
KMS fbdev helpers. And everything can be in DRM. And later, we can
remove the multiple platform drivers from DRM as well, since they're
not needed either.
Stéphane
> So I think the best way is to avoid duplicating
> codes and resolve ordering issue such as s/r operations between all the
> various components.
>
> And the below is my opinion,
>
>
> -----------------------------------------------------
> Display
> Controller-------------CDF---------------|MIPI-DSI/DBI---------------LCD
> Panel|
>
> -----------------------------------------------------
>
> 1. to access MIPI-DSI/DBI and LCD Panel drivers.
> - Display Controller is controlled by linux framebuffer or drm kms based
> specific drivers like now. And each driver calls some interfaces of CDF.
>
> 2. to control the power of these devices.
> - drm kms based specific driver calls dpms operation and next the dpms
> operation calls fb blank operation of linux framebuffer.
> But for this, we need some interfaces that it can connect between drm
> and linux framebuffer framework and you can refer to the below link.
>
> http://lists.freedesktop.org/archives/dri-devel/2011-July/013242.html
> - linux framebuffer based driver calls fb blank operation.
>
> fb blank(fb)------------------pm
> runtime(fb)--------------------fb_blank----------mipi and lcd
> dpms(drm kms)------------pm runtime(drm
> kms)----------fb_blank----------mipi and lcd
>
>
> 3. suspend/resume
> - pm suspend/resume are implemented only in linux framebuffer or drm kms
> based specific drivers.
> - MIPI-DSI/DBI and LCD Panel drivers are controlled only by fb blank
> interfaces.
>
> s/r(fb)-----------------------------------------------pm
> runtime(fb)----------------fb blank-------mipi and lcd
> s/r(drm kms)--------dpms(drm kms)-------pm runtime(drm
> kms)------fb_blank------mipi and lcd
>
>
> We could resolve ordering issue to suspend/resume simply duplicating
> relevant drivers but couldn't avoid duplicating codes. So I think we could
> avoid the ordering issue using fb blank interface of linux framebuffer and
> also duplicating codes.
>
> Thanks,
> Inki Dae
>
>
>>
>> -Daniel
>> --
>> Daniel Vetter
>> Software Engineer, Intel Corporation
>> +41 (0) 79 365 57 48 - http://blog.ffwll.ch
>> --
>> To unsubscribe from this list: send the line "unsubscribe linux-fbdev" in
>> the body of a message to majordomo@vger.kernel.org
>> More majordomo info at http://vger.kernel.org/majordomo-info.html
>
>
>
> _______________________________________________
> dri-devel mailing list
> dri-devel@lists.freedesktop.org
> http://lists.freedesktop.org/mailman/listinfo/dri-devel
>
^ permalink raw reply
* Re: [RFC v2 0/5] Common Display Framework
From: Stéphane Marchesin @ 2012-12-19 20:05 UTC (permalink / raw)
To: Rob Clark
Cc: Dave Airlie, Thomas Petazzoni, Linux Fbdev development list,
Benjamin Gaignard, Tom Gall, Kyungmin Park,
dri-devel@lists.freedesktop.org, Ragesh Radhakrishnan,
Tomi Valkeinen, Laurent Pinchart, Philipp Zabel, Bryan Wu,
Maxime Ripard, Vikas Sajjan, Sumit Semwal, Sebastien Guiriec,
linux-media@vger.kernel.org
In-Reply-To: <CAF6AEGsLdLasS4=j1PsX_P8miG8NcTXMUP9VYj+4gdU8Qhm2YQ@mail.gmail.com>
On Mon, Dec 17, 2012 at 10:21 PM, Rob Clark <rob.clark@linaro.org> wrote:
> On Mon, Dec 17, 2012 at 11:04 PM, Dave Airlie <airlied@gmail.com> wrote:
>>>
>>> Many developers showed interest in the first RFC, and I've had the opportunity
>>> to discuss it with most of them. I would like to thank (in no particular
>>> order) Tomi Valkeinen for all the time he spend helping me to draft v2, Marcus
>>> Lorentzon for his useful input during Linaro Connect Q4 2012, and Linaro for
>>> inviting me to Connect and providing a venue to discuss this topic.
>>>
>>
>> So this might be a bit off topic but this whole CDF triggered me
>> looking at stuff I generally avoid:
>>
>> The biggest problem I'm having currently with the whole ARM graphics
>> and output world is the proliferation of platform drivers for every
>> little thing. The whole ordering of operations with respect to things
>> like suspend/resume or dynamic power management is going to be a real
>> nightmare if there are dependencies between the drivers. How do you
>> enforce ordering of s/r operations between all the various components?
>
> I tend to think that sub-devices are useful just to have a way to
> probe hw which may or may not be there, since on ARM we often don't
> have any alternative..
You can probe the device tree from a normal DRM driver. For example in
nouveau for PPC we probe the OF device tree looking for connectors. I
don't see how sub-devices or extra platform drivers help with that, as
long as the device tree is populated upfront somehow...
Stéphane
> but beyond that, suspend/resume, and other
> life-cycle aspects, they should really be treated as all one device.
> Especially to avoid undefined suspend/resume ordering.
>
> CDF or some sort of mechanism to share panel drivers between drivers
> is useful. Keeping it within drm, is probably a good idea, if nothing
> else to simplify re-use of helper fxns (like avi-infoframe stuff, for
> example) and avoid dealing with merging changes across multiple trees.
> Treating them more like shared libraries and less like sub-devices
> which can be dynamically loaded/unloaded (ie. they should be not built
> as separate modules or suspend/resumed or probed/removed independently
> of the master driver) is a really good idea to avoid uncovering nasty
> synchronization issues later (remove vs modeset or pageflip) or
> surprising userspace in bad ways.
>
>> The other thing I'd like you guys to do is kill the idea of fbdev and
>> v4l drivers that are "shared" with the drm codebase, really just
>> implement fbdev and v4l on top of the drm layer, some people might
>> think this is some sort of maintainer thing, but really nothing else
>> makes sense, and having these shared display frameworks just to avoid
>> having using drm/kms drivers seems totally pointless. Fix the drm
>> fbdev emulation if an fbdev interface is needed. But creating a fourth
>> framework because our previous 3 frameworks didn't work out doesn't
>> seem like a situation I want to get behind too much.
>
> yeah, let's not have multiple frameworks to do the same thing.. For
> fbdev, it is pretty clear that it is a dead end. For v4l2
> (subdev+mcf), it is perhaps bit more flexible when it comes to random
> arbitrary hw pipelines than kms. But to take advantage of that, your
> userspace isn't going to be portable anyways, so you might as well use
> driver specific properties/ioctls. But I tend to think that is more
> useful for cameras. And from userspace perspective, kms planes are
> less painful to use for output than v4l2, so lets stick to drm/kms for
> output (and not try to add camera/capture support to kms).. k, thx
>
> BR,
> -R
>
>> Dave.
>> _______________________________________________
>> dri-devel mailing list
>> dri-devel@lists.freedesktop.org
>> http://lists.freedesktop.org/mailman/listinfo/dri-devel
> _______________________________________________
> dri-devel mailing list
> dri-devel@lists.freedesktop.org
> http://lists.freedesktop.org/mailman/listinfo/dri-devel
^ permalink raw reply
* UAPI patch for fbdev
From: David Howells @ 2012-12-19 16:42 UTC (permalink / raw)
To: linux-fbdev
[-- Attachment #1: Type: text/plain, Size: 21018 bytes --]
Hi Florian, Tomi,
Would it be possible to get an Acked-by or two for my UAPI disintegration
patch for fbdev (see attached)?
The patch can be merged from here if you're that way inclined:
http://git.infradead.org/users/dhowells/linux-headers.git/shortlog/refs/heads/disintegrate-fbdev
or I can send it directly to Linus now if you'd prefer?
Thanks,
David
---
commit 7e9b729bd6d076c905e91e4a48c1ea07fb1a25a7
Author: David Howells <dhowells@redhat.com>
Date: Wed Dec 19 16:07:26 2012 +0000
UAPI: (Scripted) Disintegrate include/video
Signed-off-by: David Howells <dhowells@redhat.com>
Acked-by: Arnd Bergmann <arnd@arndb.de>
Acked-by: Thomas Gleixner <tglx@linutronix.de>
Acked-by: Michael Kerrisk <mtk.manpages@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Acked-by: Dave Jones <davej@redhat.com>
diff --git a/include/uapi/video/Kbuild b/include/uapi/video/Kbuild
index aafaa5a..ac7203b 100644
--- a/include/uapi/video/Kbuild
+++ b/include/uapi/video/Kbuild
@@ -1 +1,4 @@
# UAPI Header export list
+header-y += edid.h
+header-y += sisfb.h
+header-y += uvesafb.h
diff --git a/include/uapi/video/edid.h b/include/uapi/video/edid.h
new file mode 100644
index 0000000..8c0f032
--- /dev/null
+++ b/include/uapi/video/edid.h
@@ -0,0 +1,9 @@
+#ifndef _UAPI__linux_video_edid_h__
+#define _UAPI__linux_video_edid_h__
+
+struct edid_info {
+ unsigned char dummy[128];
+};
+
+
+#endif /* _UAPI__linux_video_edid_h__ */
diff --git a/include/uapi/video/sisfb.h b/include/uapi/video/sisfb.h
new file mode 100644
index 0000000..9250b22
--- /dev/null
+++ b/include/uapi/video/sisfb.h
@@ -0,0 +1,209 @@
+/*
+ * sisfb.h - definitions for the SiS framebuffer driver
+ *
+ * Copyright (C) 2001-2005 by Thomas Winischhofer, Vienna, Austria.
+ *
+ * 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 2 of the named License,
+ * or 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, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA
+ */
+
+#ifndef _UAPI_LINUX_SISFB_H_
+#define _UAPI_LINUX_SISFB_H_
+
+#include <linux/types.h>
+#include <asm/ioctl.h>
+
+/**********************************************/
+/* PUBLIC */
+/**********************************************/
+
+/* vbflags, public (others in sis.h) */
+#define CRT2_DEFAULT 0x00000001
+#define CRT2_LCD 0x00000002
+#define CRT2_TV 0x00000004
+#define CRT2_VGA 0x00000008
+#define TV_NTSC 0x00000010
+#define TV_PAL 0x00000020
+#define TV_HIVISION 0x00000040
+#define TV_YPBPR 0x00000080
+#define TV_AVIDEO 0x00000100
+#define TV_SVIDEO 0x00000200
+#define TV_SCART 0x00000400
+#define TV_PALM 0x00001000
+#define TV_PALN 0x00002000
+#define TV_NTSCJ 0x00001000
+#define TV_CHSCART 0x00008000
+#define TV_CHYPBPR525I 0x00010000
+#define CRT1_VGA 0x00000000
+#define CRT1_LCDA 0x00020000
+#define VGA2_CONNECTED 0x00040000
+#define VB_DISPTYPE_CRT1 0x00080000 /* CRT1 connected and used */
+#define VB_SINGLE_MODE 0x20000000 /* CRT1 or CRT2; determined by DISPTYPE_CRTx */
+#define VB_MIRROR_MODE 0x40000000 /* CRT1 + CRT2 identical (mirror mode) */
+#define VB_DUALVIEW_MODE 0x80000000 /* CRT1 + CRT2 independent (dual head mode) */
+
+/* Aliases: */
+#define CRT2_ENABLE (CRT2_LCD | CRT2_TV | CRT2_VGA)
+#define TV_STANDARD (TV_NTSC | TV_PAL | TV_PALM | TV_PALN | TV_NTSCJ)
+#define TV_INTERFACE (TV_AVIDEO|TV_SVIDEO|TV_SCART|TV_HIVISION|TV_YPBPR|TV_CHSCART|TV_CHYPBPR525I)
+
+/* Only if TV_YPBPR is set: */
+#define TV_YPBPR525I TV_NTSC
+#define TV_YPBPR525P TV_PAL
+#define TV_YPBPR750P TV_PALM
+#define TV_YPBPR1080I TV_PALN
+#define TV_YPBPRALL (TV_YPBPR525I | TV_YPBPR525P | TV_YPBPR750P | TV_YPBPR1080I)
+
+#define VB_DISPTYPE_DISP2 CRT2_ENABLE
+#define VB_DISPTYPE_CRT2 CRT2_ENABLE
+#define VB_DISPTYPE_DISP1 VB_DISPTYPE_CRT1
+#define VB_DISPMODE_SINGLE VB_SINGLE_MODE
+#define VB_DISPMODE_MIRROR VB_MIRROR_MODE
+#define VB_DISPMODE_DUAL VB_DUALVIEW_MODE
+#define VB_DISPLAY_MODE (SINGLE_MODE | MIRROR_MODE | DUALVIEW_MODE)
+
+/* Structure argument for SISFB_GET_INFO ioctl */
+struct sisfb_info {
+ __u32 sisfb_id; /* for identifying sisfb */
+#ifndef SISFB_ID
+#define SISFB_ID 0x53495346 /* Identify myself with 'SISF' */
+#endif
+ __u32 chip_id; /* PCI-ID of detected chip */
+ __u32 memory; /* total video memory in KB */
+ __u32 heapstart; /* heap start offset in KB */
+ __u8 fbvidmode; /* current sisfb mode */
+
+ __u8 sisfb_version;
+ __u8 sisfb_revision;
+ __u8 sisfb_patchlevel;
+
+ __u8 sisfb_caps; /* sisfb capabilities */
+
+ __u32 sisfb_tqlen; /* turbo queue length (in KB) */
+
+ __u32 sisfb_pcibus; /* The card's PCI ID */
+ __u32 sisfb_pcislot;
+ __u32 sisfb_pcifunc;
+
+ __u8 sisfb_lcdpdc; /* PanelDelayCompensation */
+
+ __u8 sisfb_lcda; /* Detected status of LCDA for low res/text modes */
+
+ __u32 sisfb_vbflags;
+ __u32 sisfb_currentvbflags;
+
+ __u32 sisfb_scalelcd;
+ __u32 sisfb_specialtiming;
+
+ __u8 sisfb_haveemi;
+ __u8 sisfb_emi30,sisfb_emi31,sisfb_emi32,sisfb_emi33;
+ __u8 sisfb_haveemilcd;
+
+ __u8 sisfb_lcdpdca; /* PanelDelayCompensation for LCD-via-CRT1 */
+
+ __u16 sisfb_tvxpos, sisfb_tvypos; /* Warning: Values + 32 ! */
+
+ __u32 sisfb_heapsize; /* heap size (in KB) */
+ __u32 sisfb_videooffset; /* Offset of viewport in video memory (in bytes) */
+
+ __u32 sisfb_curfstn; /* currently running FSTN/DSTN mode */
+ __u32 sisfb_curdstn;
+
+ __u16 sisfb_pci_vendor; /* PCI vendor (SiS or XGI) */
+
+ __u32 sisfb_vbflags2; /* ivideo->vbflags2 */
+
+ __u8 sisfb_can_post; /* sisfb can POST this card */
+ __u8 sisfb_card_posted; /* card is POSTED */
+ __u8 sisfb_was_boot_device; /* This card was the boot video device (ie is primary) */
+
+ __u8 reserved[183]; /* for future use */
+};
+
+#define SISFB_CMD_GETVBFLAGS 0x55AA0001 /* no arg; result[1] = vbflags */
+#define SISFB_CMD_SWITCHCRT1 0x55AA0010 /* arg[0]: 99 = query, 0 = off, 1 = on */
+/* more to come */
+
+#define SISFB_CMD_ERR_OK 0x80000000 /* command succeeded */
+#define SISFB_CMD_ERR_LOCKED 0x80000001 /* sisfb is locked */
+#define SISFB_CMD_ERR_EARLY 0x80000002 /* request before sisfb took over gfx system */
+#define SISFB_CMD_ERR_NOVB 0x80000003 /* No video bridge */
+#define SISFB_CMD_ERR_NOCRT2 0x80000004 /* can't change CRT1 status, CRT2 disabled */
+/* more to come */
+#define SISFB_CMD_ERR_UNKNOWN 0x8000ffff /* Unknown command */
+#define SISFB_CMD_ERR_OTHER 0x80010000 /* Other error */
+
+/* Argument for SISFB_CMD ioctl */
+struct sisfb_cmd {
+ __u32 sisfb_cmd;
+ __u32 sisfb_arg[16];
+ __u32 sisfb_result[4];
+};
+
+/* Additional IOCTLs for communication sisfb <> X driver */
+/* If changing this, vgatypes.h must also be changed (for X driver) */
+
+/* ioctl for identifying and giving some info (esp. memory heap start) */
+#define SISFB_GET_INFO_SIZE _IOR(0xF3,0x00,__u32)
+#define SISFB_GET_INFO _IOR(0xF3,0x01,struct sisfb_info)
+
+/* ioctrl to get current vertical retrace status */
+#define SISFB_GET_VBRSTATUS _IOR(0xF3,0x02,__u32)
+
+/* ioctl to enable/disable panning auto-maximize (like nomax parameter) */
+#define SISFB_GET_AUTOMAXIMIZE _IOR(0xF3,0x03,__u32)
+#define SISFB_SET_AUTOMAXIMIZE _IOW(0xF3,0x03,__u32)
+
+/* ioctls to relocate TV output (x=D[31:16], y=D[15:0], + 32)*/
+#define SISFB_GET_TVPOSOFFSET _IOR(0xF3,0x04,__u32)
+#define SISFB_SET_TVPOSOFFSET _IOW(0xF3,0x04,__u32)
+
+/* ioctl for internal sisfb commands (sisfbctrl) */
+#define SISFB_COMMAND _IOWR(0xF3,0x05,struct sisfb_cmd)
+
+/* ioctl for locking sisfb (no register access during lock) */
+/* As of now, only used to avoid register access during
+ * the ioctls listed above.
+ */
+#define SISFB_SET_LOCK _IOW(0xF3,0x06,__u32)
+
+/* ioctls 0xF3 up to 0x3F reserved for sisfb */
+
+/****************************************************************/
+/* The following are deprecated and should not be used anymore: */
+/****************************************************************/
+/* ioctl for identifying and giving some info (esp. memory heap start) */
+#define SISFB_GET_INFO_OLD _IOR('n',0xF8,__u32)
+/* ioctrl to get current vertical retrace status */
+#define SISFB_GET_VBRSTATUS_OLD _IOR('n',0xF9,__u32)
+/* ioctl to enable/disable panning auto-maximize (like nomax parameter) */
+#define SISFB_GET_AUTOMAXIMIZE_OLD _IOR('n',0xFA,__u32)
+#define SISFB_SET_AUTOMAXIMIZE_OLD _IOW('n',0xFA,__u32)
+/****************************************************************/
+/* End of deprecated ioctl numbers */
+/****************************************************************/
+
+/* For fb memory manager (FBIO_ALLOC, FBIO_FREE) */
+struct sis_memreq {
+ __u32 offset;
+ __u32 size;
+};
+
+/**********************************************/
+/* PRIVATE */
+/* (for IN-KERNEL usage only) */
+/**********************************************/
+
+
+#endif /* _UAPI_LINUX_SISFB_H_ */
diff --git a/include/uapi/video/uvesafb.h b/include/uapi/video/uvesafb.h
new file mode 100644
index 0000000..cee063d
--- /dev/null
+++ b/include/uapi/video/uvesafb.h
@@ -0,0 +1,60 @@
+#ifndef _UAPI_UVESAFB_H
+#define _UAPI_UVESAFB_H
+
+#include <linux/types.h>
+
+struct v86_regs {
+ __u32 ebx;
+ __u32 ecx;
+ __u32 edx;
+ __u32 esi;
+ __u32 edi;
+ __u32 ebp;
+ __u32 eax;
+ __u32 eip;
+ __u32 eflags;
+ __u32 esp;
+ __u16 cs;
+ __u16 ss;
+ __u16 es;
+ __u16 ds;
+ __u16 fs;
+ __u16 gs;
+};
+
+/* Task flags */
+#define TF_VBEIB 0x01
+#define TF_BUF_ESDI 0x02
+#define TF_BUF_ESBX 0x04
+#define TF_BUF_RET 0x08
+#define TF_EXIT 0x10
+
+struct uvesafb_task {
+ __u8 flags;
+ int buf_len;
+ struct v86_regs regs;
+};
+
+/* Constants for the capabilities field
+ * in vbe_ib */
+#define VBE_CAP_CAN_SWITCH_DAC 0x01
+#define VBE_CAP_VGACOMPAT 0x02
+
+/* The VBE Info Block */
+struct vbe_ib {
+ char vbe_signature[4];
+ __u16 vbe_version;
+ __u32 oem_string_ptr;
+ __u32 capabilities;
+ __u32 mode_list_ptr;
+ __u16 total_memory;
+ __u16 oem_software_rev;
+ __u32 oem_vendor_name_ptr;
+ __u32 oem_product_name_ptr;
+ __u32 oem_product_rev_ptr;
+ __u8 reserved[222];
+ char oem_data[256];
+ char misc_data[512];
+} __attribute__ ((packed));
+
+#endif /* _UAPI_UVESAFB_H */
diff --git a/include/video/Kbuild b/include/video/Kbuild
index ad3e622..e69de29 100644
--- a/include/video/Kbuild
+++ b/include/video/Kbuild
@@ -1,3 +0,0 @@
-header-y += edid.h
-header-y += sisfb.h
-header-y += uvesafb.h
diff --git a/include/video/edid.h b/include/video/edid.h
index c5f1987..0cb8b2a 100644
--- a/include/video/edid.h
+++ b/include/video/edid.h
@@ -1,14 +1,9 @@
#ifndef __linux_video_edid_h__
#define __linux_video_edid_h__
-struct edid_info {
- unsigned char dummy[128];
-};
+#include <uapi/video/edid.h>
-#ifdef __KERNEL__
#ifdef CONFIG_X86
extern struct edid_info edid_info;
#endif
-#endif
-
#endif /* __linux_video_edid_h__ */
diff --git a/include/video/sisfb.h b/include/video/sisfb.h
index 6dc5df9..6ddff93 100644
--- a/include/video/sisfb.h
+++ b/include/video/sisfb.h
@@ -17,197 +17,12 @@
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA
*/
-
#ifndef _LINUX_SISFB_H_
#define _LINUX_SISFB_H_
-#include <linux/types.h>
-#include <asm/ioctl.h>
-
-/**********************************************/
-/* PUBLIC */
-/**********************************************/
-
-/* vbflags, public (others in sis.h) */
-#define CRT2_DEFAULT 0x00000001
-#define CRT2_LCD 0x00000002
-#define CRT2_TV 0x00000004
-#define CRT2_VGA 0x00000008
-#define TV_NTSC 0x00000010
-#define TV_PAL 0x00000020
-#define TV_HIVISION 0x00000040
-#define TV_YPBPR 0x00000080
-#define TV_AVIDEO 0x00000100
-#define TV_SVIDEO 0x00000200
-#define TV_SCART 0x00000400
-#define TV_PALM 0x00001000
-#define TV_PALN 0x00002000
-#define TV_NTSCJ 0x00001000
-#define TV_CHSCART 0x00008000
-#define TV_CHYPBPR525I 0x00010000
-#define CRT1_VGA 0x00000000
-#define CRT1_LCDA 0x00020000
-#define VGA2_CONNECTED 0x00040000
-#define VB_DISPTYPE_CRT1 0x00080000 /* CRT1 connected and used */
-#define VB_SINGLE_MODE 0x20000000 /* CRT1 or CRT2; determined by DISPTYPE_CRTx */
-#define VB_MIRROR_MODE 0x40000000 /* CRT1 + CRT2 identical (mirror mode) */
-#define VB_DUALVIEW_MODE 0x80000000 /* CRT1 + CRT2 independent (dual head mode) */
-
-/* Aliases: */
-#define CRT2_ENABLE (CRT2_LCD | CRT2_TV | CRT2_VGA)
-#define TV_STANDARD (TV_NTSC | TV_PAL | TV_PALM | TV_PALN | TV_NTSCJ)
-#define TV_INTERFACE (TV_AVIDEO|TV_SVIDEO|TV_SCART|TV_HIVISION|TV_YPBPR|TV_CHSCART|TV_CHYPBPR525I)
-
-/* Only if TV_YPBPR is set: */
-#define TV_YPBPR525I TV_NTSC
-#define TV_YPBPR525P TV_PAL
-#define TV_YPBPR750P TV_PALM
-#define TV_YPBPR1080I TV_PALN
-#define TV_YPBPRALL (TV_YPBPR525I | TV_YPBPR525P | TV_YPBPR750P | TV_YPBPR1080I)
-
-#define VB_DISPTYPE_DISP2 CRT2_ENABLE
-#define VB_DISPTYPE_CRT2 CRT2_ENABLE
-#define VB_DISPTYPE_DISP1 VB_DISPTYPE_CRT1
-#define VB_DISPMODE_SINGLE VB_SINGLE_MODE
-#define VB_DISPMODE_MIRROR VB_MIRROR_MODE
-#define VB_DISPMODE_DUAL VB_DUALVIEW_MODE
-#define VB_DISPLAY_MODE (SINGLE_MODE | MIRROR_MODE | DUALVIEW_MODE)
-
-/* Structure argument for SISFB_GET_INFO ioctl */
-struct sisfb_info {
- __u32 sisfb_id; /* for identifying sisfb */
-#ifndef SISFB_ID
-#define SISFB_ID 0x53495346 /* Identify myself with 'SISF' */
-#endif
- __u32 chip_id; /* PCI-ID of detected chip */
- __u32 memory; /* total video memory in KB */
- __u32 heapstart; /* heap start offset in KB */
- __u8 fbvidmode; /* current sisfb mode */
-
- __u8 sisfb_version;
- __u8 sisfb_revision;
- __u8 sisfb_patchlevel;
-
- __u8 sisfb_caps; /* sisfb capabilities */
-
- __u32 sisfb_tqlen; /* turbo queue length (in KB) */
-
- __u32 sisfb_pcibus; /* The card's PCI ID */
- __u32 sisfb_pcislot;
- __u32 sisfb_pcifunc;
-
- __u8 sisfb_lcdpdc; /* PanelDelayCompensation */
-
- __u8 sisfb_lcda; /* Detected status of LCDA for low res/text modes */
-
- __u32 sisfb_vbflags;
- __u32 sisfb_currentvbflags;
-
- __u32 sisfb_scalelcd;
- __u32 sisfb_specialtiming;
-
- __u8 sisfb_haveemi;
- __u8 sisfb_emi30,sisfb_emi31,sisfb_emi32,sisfb_emi33;
- __u8 sisfb_haveemilcd;
-
- __u8 sisfb_lcdpdca; /* PanelDelayCompensation for LCD-via-CRT1 */
-
- __u16 sisfb_tvxpos, sisfb_tvypos; /* Warning: Values + 32 ! */
-
- __u32 sisfb_heapsize; /* heap size (in KB) */
- __u32 sisfb_videooffset; /* Offset of viewport in video memory (in bytes) */
-
- __u32 sisfb_curfstn; /* currently running FSTN/DSTN mode */
- __u32 sisfb_curdstn;
-
- __u16 sisfb_pci_vendor; /* PCI vendor (SiS or XGI) */
-
- __u32 sisfb_vbflags2; /* ivideo->vbflags2 */
-
- __u8 sisfb_can_post; /* sisfb can POST this card */
- __u8 sisfb_card_posted; /* card is POSTED */
- __u8 sisfb_was_boot_device; /* This card was the boot video device (ie is primary) */
-
- __u8 reserved[183]; /* for future use */
-};
-
-#define SISFB_CMD_GETVBFLAGS 0x55AA0001 /* no arg; result[1] = vbflags */
-#define SISFB_CMD_SWITCHCRT1 0x55AA0010 /* arg[0]: 99 = query, 0 = off, 1 = on */
-/* more to come */
-
-#define SISFB_CMD_ERR_OK 0x80000000 /* command succeeded */
-#define SISFB_CMD_ERR_LOCKED 0x80000001 /* sisfb is locked */
-#define SISFB_CMD_ERR_EARLY 0x80000002 /* request before sisfb took over gfx system */
-#define SISFB_CMD_ERR_NOVB 0x80000003 /* No video bridge */
-#define SISFB_CMD_ERR_NOCRT2 0x80000004 /* can't change CRT1 status, CRT2 disabled */
-/* more to come */
-#define SISFB_CMD_ERR_UNKNOWN 0x8000ffff /* Unknown command */
-#define SISFB_CMD_ERR_OTHER 0x80010000 /* Other error */
-
-/* Argument for SISFB_CMD ioctl */
-struct sisfb_cmd {
- __u32 sisfb_cmd;
- __u32 sisfb_arg[16];
- __u32 sisfb_result[4];
-};
-
-/* Additional IOCTLs for communication sisfb <> X driver */
-/* If changing this, vgatypes.h must also be changed (for X driver) */
-
-/* ioctl for identifying and giving some info (esp. memory heap start) */
-#define SISFB_GET_INFO_SIZE _IOR(0xF3,0x00,__u32)
-#define SISFB_GET_INFO _IOR(0xF3,0x01,struct sisfb_info)
-
-/* ioctrl to get current vertical retrace status */
-#define SISFB_GET_VBRSTATUS _IOR(0xF3,0x02,__u32)
-
-/* ioctl to enable/disable panning auto-maximize (like nomax parameter) */
-#define SISFB_GET_AUTOMAXIMIZE _IOR(0xF3,0x03,__u32)
-#define SISFB_SET_AUTOMAXIMIZE _IOW(0xF3,0x03,__u32)
-
-/* ioctls to relocate TV output (x=D[31:16], y=D[15:0], + 32)*/
-#define SISFB_GET_TVPOSOFFSET _IOR(0xF3,0x04,__u32)
-#define SISFB_SET_TVPOSOFFSET _IOW(0xF3,0x04,__u32)
-
-/* ioctl for internal sisfb commands (sisfbctrl) */
-#define SISFB_COMMAND _IOWR(0xF3,0x05,struct sisfb_cmd)
-
-/* ioctl for locking sisfb (no register access during lock) */
-/* As of now, only used to avoid register access during
- * the ioctls listed above.
- */
-#define SISFB_SET_LOCK _IOW(0xF3,0x06,__u32)
-
-/* ioctls 0xF3 up to 0x3F reserved for sisfb */
-
-/****************************************************************/
-/* The following are deprecated and should not be used anymore: */
-/****************************************************************/
-/* ioctl for identifying and giving some info (esp. memory heap start) */
-#define SISFB_GET_INFO_OLD _IOR('n',0xF8,__u32)
-/* ioctrl to get current vertical retrace status */
-#define SISFB_GET_VBRSTATUS_OLD _IOR('n',0xF9,__u32)
-/* ioctl to enable/disable panning auto-maximize (like nomax parameter) */
-#define SISFB_GET_AUTOMAXIMIZE_OLD _IOR('n',0xFA,__u32)
-#define SISFB_SET_AUTOMAXIMIZE_OLD _IOW('n',0xFA,__u32)
-/****************************************************************/
-/* End of deprecated ioctl numbers */
-/****************************************************************/
-
-/* For fb memory manager (FBIO_ALLOC, FBIO_FREE) */
-struct sis_memreq {
- __u32 offset;
- __u32 size;
-};
-
-/**********************************************/
-/* PRIVATE */
-/* (for IN-KERNEL usage only) */
-/**********************************************/
-
-#ifdef __KERNEL__
#include <linux/pci.h>
+#include <uapi/video/sisfb.h>
#define UNKNOWN_VGA 0
#define SIS_300_VGA 1
@@ -220,5 +35,3 @@ extern void sis_malloc_new(struct pci_dev *pdev, struct sis_memreq *req);
extern void sis_free(u32 base);
extern void sis_free_new(struct pci_dev *pdev, u32 base);
#endif
-
-#endif
diff --git a/include/video/uvesafb.h b/include/video/uvesafb.h
index 0993a22..1a91850 100644
--- a/include/video/uvesafb.h
+++ b/include/video/uvesafb.h
@@ -1,63 +1,8 @@
#ifndef _UVESAFB_H
#define _UVESAFB_H
-#include <linux/types.h>
-
-struct v86_regs {
- __u32 ebx;
- __u32 ecx;
- __u32 edx;
- __u32 esi;
- __u32 edi;
- __u32 ebp;
- __u32 eax;
- __u32 eip;
- __u32 eflags;
- __u32 esp;
- __u16 cs;
- __u16 ss;
- __u16 es;
- __u16 ds;
- __u16 fs;
- __u16 gs;
-};
-
-/* Task flags */
-#define TF_VBEIB 0x01
-#define TF_BUF_ESDI 0x02
-#define TF_BUF_ESBX 0x04
-#define TF_BUF_RET 0x08
-#define TF_EXIT 0x10
-
-struct uvesafb_task {
- __u8 flags;
- int buf_len;
- struct v86_regs regs;
-};
-
-/* Constants for the capabilities field
- * in vbe_ib */
-#define VBE_CAP_CAN_SWITCH_DAC 0x01
-#define VBE_CAP_VGACOMPAT 0x02
-
-/* The VBE Info Block */
-struct vbe_ib {
- char vbe_signature[4];
- __u16 vbe_version;
- __u32 oem_string_ptr;
- __u32 capabilities;
- __u32 mode_list_ptr;
- __u16 total_memory;
- __u16 oem_software_rev;
- __u32 oem_vendor_name_ptr;
- __u32 oem_product_name_ptr;
- __u32 oem_product_rev_ptr;
- __u8 reserved[222];
- char oem_data[256];
- char misc_data[512];
-} __attribute__ ((packed));
+#include <uapi/video/uvesafb.h>
-#ifdef __KERNEL__
/* VBE CRTC Info Block */
struct vbe_crtc_ib {
@@ -191,5 +136,4 @@ struct uvesafb_par {
struct vbe_crtc_ib crtc;
};
-#endif /* __KERNEL__ */
#endif /* _UVESAFB_H */
[-- Attachment #2: Type: application/pgp-signature, Size: 827 bytes --]
^ permalink raw reply related
* Re: [RFC v2 0/5] Common Display Framework
From: Rob Clark @ 2012-12-19 16:05 UTC (permalink / raw)
To: Tomi Valkeinen
Cc: Thomas Petazzoni, Linux Fbdev development list, Benjamin Gaignard,
Tom Gall, dri-devel@lists.freedesktop.org, Kyungmin Park,
Ragesh Radhakrishnan, Laurent Pinchart, Philipp Zabel,
Maxime Ripard, Vikas Sajjan, Sumit Semwal, Sebastien Guiriec,
linux-media@vger.kernel.org
In-Reply-To: <50D1DF42.3070008@ti.com>
On Wed, Dec 19, 2012 at 9:37 AM, Tomi Valkeinen <tomi.valkeinen@ti.com> wrote:
> On 2012-12-19 17:26, Rob Clark wrote:
>>
>> And, there are also external HDMI encoders (for example connected over
>> i2c) that can also be shared between boards. So I think there will be
>> a number of cases where CDF is appropriate for HDMI drivers. Although
>> trying to keep this all independent of DRM (as opposed to just
>> something similar to what drivers/gpu/i2c is today) seems a bit
>> overkill for me. Being able to use the helpers in drm and avoiding an
>> extra layer of translation seems like the better option to me. So my
>> vote would be drivers/gpu/cdf.
>
> Well, we need to think about that. I would like to keep CDF independent
> of DRM. I don't like tying different components/frameworks together if
> there's no real need for that.
>
> Also, something that Laurent mentioned in our face-to-face discussions:
> Some IPs/chips can be used for other purposes than with DRM.
>
> He had an example of a board, that (if I understood right) gets video
> signal from somewhere outside the board, processes the signal with some
> IPs/chips, and then outputs the signal. So there's no framebuffer, and
> the image is not stored anywhere. I think the framework used in these
> cases is always v4l2.
>
> The IPs/chips in the above model may be the exact same IPs/chips that
> are used with "normal" display. If the CDF was tied to DRM, using the
> same drivers for normal and these streaming cases would probably not be
> possible.
Well, maybe there is a way, but it really seems to be
over-complicating things unnecessarily to keep CDF independent of
DRM.. there will be a lot more traditional uses of CDF compared to
one crazy use-case. So I don't really fancy making it more difficult
than in needs to be for everyone.
Probably the thing to do is take a step back and reconsider that one
crazy use-case. For example, KMS doesn't enforce that the buffer
handled passed when you create a drm framebuffer object to scan out is
a GEM buffer. So on that one crazy platform, maybe it makes sense to
have a DRM/KMS display driver that takes a handle to identify which
video stream coming from the capture end of the pipeline. Anyways,
that is just an off-the-top-of-my-head idea, probably there are other
options too.
BR,
-R
> Tomi
>
>
^ permalink raw reply
* Re: [RFC v2 0/5] Common Display Framework
From: Tomi Valkeinen @ 2012-12-19 15:37 UTC (permalink / raw)
To: Rob Clark
Cc: Jani Nikula, Laurent Pinchart, Thomas Petazzoni,
Linux Fbdev development list, Philipp Zabel, Tom Gall,
Ragesh Radhakrishnan, dri-devel@lists.freedesktop.org,
Kyungmin Park, Benjamin Gaignard, Bryan Wu, Maxime Ripard,
Vikas Sajjan, Sumit Semwal, Sebastien Guiriec,
linux-media@vger.kernel.org
In-Reply-To: <CAF6AEGuSt0CL2sFGK-PZnw6+r9zhGHO4CEjJEWaR8eGhks2=UQ@mail.gmail.com>
[-- Attachment #1: Type: text/plain, Size: 4348 bytes --]
On 2012-12-19 17:26, Rob Clark wrote:
> On Wed, Dec 19, 2012 at 8:57 AM, Jani Nikula
> <jani.nikula@linux.intel.com> wrote:
>>
>> Hi Laurent -
>>
>> On Tue, 18 Dec 2012, Laurent Pinchart <laurent.pinchart@ideasonboard.com> wrote:
>>> Hi Jani,
>>>
>>> On Monday 17 December 2012 18:53:37 Jani Nikula wrote:
>>>> I can see the need for a framework for DSI panels and such (in fact Tomi
>>>> and I have talked about it like 2-3 years ago already!) but what is the
>>>> story for HDMI and DP? In particular, what's the relationship between
>>>> DRM and CDF here? Is there a world domination plan to switch the DRM
>>>> drivers to use this framework too? ;) Do you have some rough plans how
>>>> DRM and CDF should work together in general?
>>>
>>> There's always a world domination plan, isn't there ? :-)
>>>
>>> I certainly want CDF to be used by DRM (or more accurately KMS). That's what
>>> the C stands for, common refers to sharing panel and other display entity
>>> drivers between FBDEV, KMS and V4L2.
>>>
>>> I currently have no plan to expose CDF internals to userspace through the KMS
>>> API. We might have to do so later if the hardware complexity grows in such a
>>> way that finer control than what KMS provides needs to be exposed to
>>> userspace, but I don't think we're there yet. The CDF API will thus only be
>>> used internally in the kernel by display controller drivers. The KMS core
>>> might get functions to handle common display entity operations, but the bulk
>>> of the work will be in the display controller drivers to start with. We will
>>> then see what can be abstracted in KMS helper functions.
>>>
>>> Regarding HDMI and DP, I imagine HDMI and DP drivers that would use the CDF
>>> API. That's just a thought for now, I haven't tried to implement them, but it
>>> would be nice to handle HDMI screens and DPI/DBI/DSI panels in a generic way.
>>>
>>> Do you have thoughts to share on this topic ?
>>
>> It just seems to me that, at least from a DRM/KMS perspective, adding
>> another layer (=CDF) for HDMI or DP (or legacy outputs) would be
>> overengineering it. They are pretty well standardized, and I don't see
>> there would be a need to write multiple display drivers for them. Each
>> display controller has one, and can easily handle any chip specific
>> requirements right there. It's my gut feeling that an additional
>> framework would just get in the way. Perhaps there could be more common
>> HDMI/DP helper style code in DRM to reduce overlap across KMS drivers,
>> but that's another thing.
>>
>> So is the HDMI/DP drivers using CDF a more interesting idea from a
>> non-DRM perspective? Or, put another way, is it more of an alternative
>> to using DRM? Please enlighten me if there's some real benefit here that
>> I fail to see!
>
> fwiw, I think there are at least a couple cases where multiple SoC's
> have the same HDMI IP block.
>
> And, there are also external HDMI encoders (for example connected over
> i2c) that can also be shared between boards. So I think there will be
> a number of cases where CDF is appropriate for HDMI drivers. Although
> trying to keep this all independent of DRM (as opposed to just
> something similar to what drivers/gpu/i2c is today) seems a bit
> overkill for me. Being able to use the helpers in drm and avoiding an
> extra layer of translation seems like the better option to me. So my
> vote would be drivers/gpu/cdf.
Well, we need to think about that. I would like to keep CDF independent
of DRM. I don't like tying different components/frameworks together if
there's no real need for that.
Also, something that Laurent mentioned in our face-to-face discussions:
Some IPs/chips can be used for other purposes than with DRM.
He had an example of a board, that (if I understood right) gets video
signal from somewhere outside the board, processes the signal with some
IPs/chips, and then outputs the signal. So there's no framebuffer, and
the image is not stored anywhere. I think the framework used in these
cases is always v4l2.
The IPs/chips in the above model may be the exact same IPs/chips that
are used with "normal" display. If the CDF was tied to DRM, using the
same drivers for normal and these streaming cases would probably not be
possible.
Tomi
[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 899 bytes --]
^ permalink raw reply
* Re: [RFC v2 0/5] Common Display Framework
From: Rob Clark @ 2012-12-19 15:26 UTC (permalink / raw)
To: Jani Nikula
Cc: Laurent Pinchart, Tomi Valkeinen, Thomas Petazzoni,
Linux Fbdev development list, Philipp Zabel, Tom Gall,
Ragesh Radhakrishnan, dri-devel@lists.freedesktop.org,
Kyungmin Park, Benjamin Gaignard, Bryan Wu, Maxime Ripard,
Vikas Sajjan, Sumit Semwal, Sebastien Guiriec,
linux-media@vger.kernel.org
In-Reply-To: <87pq26ay2z.fsf@intel.com>
On Wed, Dec 19, 2012 at 8:57 AM, Jani Nikula
<jani.nikula@linux.intel.com> wrote:
>
> Hi Laurent -
>
> On Tue, 18 Dec 2012, Laurent Pinchart <laurent.pinchart@ideasonboard.com> wrote:
>> Hi Jani,
>>
>> On Monday 17 December 2012 18:53:37 Jani Nikula wrote:
>>> I can see the need for a framework for DSI panels and such (in fact Tomi
>>> and I have talked about it like 2-3 years ago already!) but what is the
>>> story for HDMI and DP? In particular, what's the relationship between
>>> DRM and CDF here? Is there a world domination plan to switch the DRM
>>> drivers to use this framework too? ;) Do you have some rough plans how
>>> DRM and CDF should work together in general?
>>
>> There's always a world domination plan, isn't there ? :-)
>>
>> I certainly want CDF to be used by DRM (or more accurately KMS). That's what
>> the C stands for, common refers to sharing panel and other display entity
>> drivers between FBDEV, KMS and V4L2.
>>
>> I currently have no plan to expose CDF internals to userspace through the KMS
>> API. We might have to do so later if the hardware complexity grows in such a
>> way that finer control than what KMS provides needs to be exposed to
>> userspace, but I don't think we're there yet. The CDF API will thus only be
>> used internally in the kernel by display controller drivers. The KMS core
>> might get functions to handle common display entity operations, but the bulk
>> of the work will be in the display controller drivers to start with. We will
>> then see what can be abstracted in KMS helper functions.
>>
>> Regarding HDMI and DP, I imagine HDMI and DP drivers that would use the CDF
>> API. That's just a thought for now, I haven't tried to implement them, but it
>> would be nice to handle HDMI screens and DPI/DBI/DSI panels in a generic way.
>>
>> Do you have thoughts to share on this topic ?
>
> It just seems to me that, at least from a DRM/KMS perspective, adding
> another layer (ÍF) for HDMI or DP (or legacy outputs) would be
> overengineering it. They are pretty well standardized, and I don't see
> there would be a need to write multiple display drivers for them. Each
> display controller has one, and can easily handle any chip specific
> requirements right there. It's my gut feeling that an additional
> framework would just get in the way. Perhaps there could be more common
> HDMI/DP helper style code in DRM to reduce overlap across KMS drivers,
> but that's another thing.
>
> So is the HDMI/DP drivers using CDF a more interesting idea from a
> non-DRM perspective? Or, put another way, is it more of an alternative
> to using DRM? Please enlighten me if there's some real benefit here that
> I fail to see!
fwiw, I think there are at least a couple cases where multiple SoC's
have the same HDMI IP block.
And, there are also external HDMI encoders (for example connected over
i2c) that can also be shared between boards. So I think there will be
a number of cases where CDF is appropriate for HDMI drivers. Although
trying to keep this all independent of DRM (as opposed to just
something similar to what drivers/gpu/i2c is today) seems a bit
overkill for me. Being able to use the helpers in drm and avoiding an
extra layer of translation seems like the better option to me. So my
vote would be drivers/gpu/cdf.
BR,
-R
> For DSI panels (or DSI-to-whatever bridges) it's of course another
> story. You typically need a panel specific driver. And here I see the
> main point of the whole CDF: decoupling display controllers and the
> panel drivers, and sharing panel (and converter chip) specific drivers
> across display controllers. Making it easy to write new drivers, as
> there would be a model to follow. I'm definitely in favour of coming up
> with some framework that would tackle that.
>
>
> BR,
> Jani.
> --
> To unsubscribe from this list: send the line "unsubscribe linux-media" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply
* Re: [RFC v2 0/5] Common Display Framework
From: Tomi Valkeinen @ 2012-12-19 15:07 UTC (permalink / raw)
To: Jani Nikula
Cc: Laurent Pinchart, Thomas Petazzoni, linux-fbdev, Philipp Zabel,
Tom Gall, Ragesh Radhakrishnan, dri-devel, Rob Clark,
Kyungmin Park, Benjamin Gaignard, Bryan Wu, Maxime Ripard,
Vikas Sajjan, Sumit Semwal, Sebastien Guiriec, linux-media
In-Reply-To: <87pq26ay2z.fsf@intel.com>
[-- Attachment #1: Type: text/plain, Size: 2265 bytes --]
On 2012-12-19 16:57, Jani Nikula wrote:
> It just seems to me that, at least from a DRM/KMS perspective, adding
> another layer (=CDF) for HDMI or DP (or legacy outputs) would be
> overengineering it. They are pretty well standardized, and I don't see
> there would be a need to write multiple display drivers for them. Each
> display controller has one, and can easily handle any chip specific
> requirements right there. It's my gut feeling that an additional
> framework would just get in the way. Perhaps there could be more common
> HDMI/DP helper style code in DRM to reduce overlap across KMS drivers,
> but that's another thing.
>
> So is the HDMI/DP drivers using CDF a more interesting idea from a
> non-DRM perspective? Or, put another way, is it more of an alternative
> to using DRM? Please enlighten me if there's some real benefit here that
> I fail to see!
The use of CDF is an option, not something that has to be done. A DRM
driver developer may use it if it gives benefit for him for that
particular driver.
I don't know much about desktop display hardware, but I guess that using
CDF would not really give much there. In some cases it could, if the IPs
used on the graphics card are something that are used elsewhere also
(sounds quite unlikely, though). In that case there could be separate
drivers for the IPs.
And note that CDF is not really about the dispc side, i.e. the part that
creates the video stream from pixels in the memory. It's more about the
components after that, and how to connect those components.
> For DSI panels (or DSI-to-whatever bridges) it's of course another
> story. You typically need a panel specific driver. And here I see the
> main point of the whole CDF: decoupling display controllers and the
> panel drivers, and sharing panel (and converter chip) specific drivers
> across display controllers. Making it easy to write new drivers, as
> there would be a model to follow. I'm definitely in favour of coming up
> with some framework that would tackle that.
Right. But if you implement drivers for DSI panels with CDF for, say,
OMAP, I think it's simpler to use CDF also for HDMI/DP on OMAP.
Otherwise it'll be a mishmash with two different models.
Tomi
[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 899 bytes --]
^ permalink raw reply
* Re: [RFC v2 0/5] Common Display Framework
From: Jani Nikula @ 2012-12-19 14:57 UTC (permalink / raw)
To: Laurent Pinchart
Cc: Tomi Valkeinen, Thomas Petazzoni, linux-fbdev, Philipp Zabel,
Tom Gall, Ragesh Radhakrishnan, dri-devel, Rob Clark,
Kyungmin Park, Benjamin Gaignard, Bryan Wu, Maxime Ripard,
Vikas Sajjan, Sumit Semwal, Sebastien Guiriec, linux-media
In-Reply-To: <1671267.x0lxGrFjjV@avalon>
Hi Laurent -
On Tue, 18 Dec 2012, Laurent Pinchart <laurent.pinchart@ideasonboard.com> wrote:
> Hi Jani,
>
> On Monday 17 December 2012 18:53:37 Jani Nikula wrote:
>> I can see the need for a framework for DSI panels and such (in fact Tomi
>> and I have talked about it like 2-3 years ago already!) but what is the
>> story for HDMI and DP? In particular, what's the relationship between
>> DRM and CDF here? Is there a world domination plan to switch the DRM
>> drivers to use this framework too? ;) Do you have some rough plans how
>> DRM and CDF should work together in general?
>
> There's always a world domination plan, isn't there ? :-)
>
> I certainly want CDF to be used by DRM (or more accurately KMS). That's what
> the C stands for, common refers to sharing panel and other display entity
> drivers between FBDEV, KMS and V4L2.
>
> I currently have no plan to expose CDF internals to userspace through the KMS
> API. We might have to do so later if the hardware complexity grows in such a
> way that finer control than what KMS provides needs to be exposed to
> userspace, but I don't think we're there yet. The CDF API will thus only be
> used internally in the kernel by display controller drivers. The KMS core
> might get functions to handle common display entity operations, but the bulk
> of the work will be in the display controller drivers to start with. We will
> then see what can be abstracted in KMS helper functions.
>
> Regarding HDMI and DP, I imagine HDMI and DP drivers that would use the CDF
> API. That's just a thought for now, I haven't tried to implement them, but it
> would be nice to handle HDMI screens and DPI/DBI/DSI panels in a generic way.
>
> Do you have thoughts to share on this topic ?
It just seems to me that, at least from a DRM/KMS perspective, adding
another layer (ÍF) for HDMI or DP (or legacy outputs) would be
overengineering it. They are pretty well standardized, and I don't see
there would be a need to write multiple display drivers for them. Each
display controller has one, and can easily handle any chip specific
requirements right there. It's my gut feeling that an additional
framework would just get in the way. Perhaps there could be more common
HDMI/DP helper style code in DRM to reduce overlap across KMS drivers,
but that's another thing.
So is the HDMI/DP drivers using CDF a more interesting idea from a
non-DRM perspective? Or, put another way, is it more of an alternative
to using DRM? Please enlighten me if there's some real benefit here that
I fail to see!
For DSI panels (or DSI-to-whatever bridges) it's of course another
story. You typically need a panel specific driver. And here I see the
main point of the whole CDF: decoupling display controllers and the
panel drivers, and sharing panel (and converter chip) specific drivers
across display controllers. Making it easy to write new drivers, as
there would be a model to follow. I'm definitely in favour of coming up
with some framework that would tackle that.
BR,
Jani.
^ permalink raw reply
* Re: [RFC 0/6] Common Display Framework-T
From: Tomi Valkeinen @ 2012-12-19 14:53 UTC (permalink / raw)
To: Laurent Pinchart; +Cc: linux-fbdev, dri-devel
In-Reply-To: <5024715.KeGkjOKZ3Q@avalon>
[-- Attachment #1: Type: text/plain, Size: 14789 bytes --]
On 2012-12-19 15:21, Laurent Pinchart wrote:
> Hi Tomi,
>
> On Friday 14 December 2012 16:27:26 Tomi Valkeinen wrote:
>> Hi,
>>
>> I have been testing Common Display Framework on OMAP, and making changes
>> that I've discussed in the posts I've sent in reply to the CDF series from
>> Laurent. While my CDF code is rather hacky and not at all ready, I wanted
>> to post the code for comments and also as a reference code to my posts.
>>
>> So here is CDF-T (Tomi-edition =).
>
> We've discussed your approach extensively face-to-face today so I won't review
> the patches in detail, but I will instead summarize our discussion to make
> sure we understood each other (and let other developers jump in).
I have some comments =). But mostly it looks good.
> For the purpose of this discussion the term "display controller driver" (or
> just "display controller") refer to both the low-level driver layer that
> communicates directly with the display controller hardware, and to the higher-
> level driver layer that implements and exposes the userspace API (FBDEV, KMS
> and/or V4L). Those layers can be implemented in multiple kernel modules (such
> as in the OMAP DSS case, with omapdss for the low-level layer and omapdrm,
> omapfb and omapvout for the API-level layer) or a single kernel module.
>
> Control model
> -------------
>
> The figure at http://www.ideasonboard.org/media/cdf/cdf-panel-control-
> model.png shows the CDF control model.
>
> The panel object depicted on the figure doesn't need to be a panel in the
> stricter sense but could be any chain of off-SoC (both on-board or off-board)
> display entities. It however helps thinking about it as a panel and doesn't
> hurt the model.
I don't think it needs to be off-soc. The dispc and the panel in the
image could be any two components, in- or off-soc.
> The panel is controlled through abstract control requests. Those requests are
> used to retrieve panel information (such as the physical size, the supported
> video modes, EDID information, ...), set the panel configuration (such as the
> active video timings) or control the panel operation state (enabling/disabling
> the panel, controlling panel blanking and power management, ...). They are
> exposed by the panel using function pointers, and called by other kernel
> components in response to userspace requests (through the FBDEV, KMS or V4L2
> APIs) or in-kernel events (for instance hotplug notifications).
>
> In response to the control requests the panel driver will communicate with the
> panel through the panel control bus (I2C, SPI, DBI, DSI, GPIO, ..., not shown
> on the figure) and will control the video stream it receives on its input.
>
> The panel is connected at the hardware level to a video source (shown as a
> green hashed rectangle) that provides it with a video stream. The video stream
> flows from the video source to the panel and is directly controlled by its
> source, as shown by the green arrow from the display controller to the video
> stream. The video source exposes stream control operations as function
> pointers that are used by the panel to control the video stream, as shown by
> the green arrow from the panel to the video source.
>
> The figure at http://www.ideasonboard.org/media/cdf/cdf-panel-control-
> model-2.png shows the call flow across entities when the panel is a pipeline
> made of more than a single entity. In this case the SoC (on the left of the
> dashed line) outputs a video stream on a DSI bus connected to a DSI to LVDS
> transmitter. The output of the DSI to LVDS transmitter is connected to an LVDS
> panel (or, more accurately, an LVDS panel module made of an LVDS panel
> controller and a panel).
Here also I don't see any reason to separate in- or off-soc components.
I think the call from DISPC, which now goes to the transmitter, should
first go to the DPI/DSI block. Whether the DPI/DSI block is in- or
off-soc should be irrelevant regarding CDF.
> The transmitter and panel module are seen by the display controller and
> userspace API implementations as a single entity that exposes control request
> operations and controls its input video stream. When a control request is
I don't like the sound of this. I think the CDF shouldn't care how the
userspace API is implemented. There's no reason in CDF level to separate
in- or out-soc entities, nor expose only one entity. If DRM requires
mapping DRM's crtc, encoder and connector to, respectively, dispc,
DPI/DSI, the-rest, it should be able to do that, but CDF shouldn't force
that model.
Of course, the implementor of the particular SoC display driver could
decide to use one display entity that covers both dispc and DPI/DSI
blocks. But at least I would like to have OMAP's DISPC as a display
entity (or actually multiple entities, one for each DISPC output), and
the various in-SoC DPI-to-something encoders as display entities.
> performed (outermost green arrow) the DSI to LVDS transmitter will propagate
> it to the panel, possibly mangling the input parameters or the response. For
> panel operation state control requests the last entity in the pipeline will
> likely want to control the video stream it receives on its input. The video
> stream control calls will be propagated from right to left as shown by the red
> arrows.
>
> Every entity in the call stack can communicate with its hardware device
> through the corresponding control bus, and/or control the video stream it
> receives on its input.
>
> This model allows filtering out modes and timings supported by the panel but
> unsupported by the transmitter and mangling the modes and timings according to
> the transmitter limitations. It has no complexity drawback for simple devices,
> as the corresponding drivers can just forward the calls directly. Similar use
> cases could exist for other control operations than mode and information
> retrieval.
>
> Discovery
> ---------
>
> Before being able to issue control requests, panel devices need to be
> discovered and associated with the connected display controller(s).
>
> Panels and display controllers are cross-dependent. There is no way around
Perhaps semantics, but I don't think they are cross-dependent. True,
they will call ops in each other, but the dispc will get the pointer to
the panel when the panel connects the dispc and the panel. And when the
panel disconnects, dispc will lose the reference to the panel.
For me, cross-dependent would mean that dispc could have a reference to
the panel regardless of what the panel does. In our case it is not so,
and there's no harm with the dispc's reference to the panel, as the
panel can remove it (almost) at any time.
> that, as the display controller needs a reference to the panel to call control
> requests in response to userspace API, and the panel needs a reference to the
> display controller to call video stream control functions (in addition to
> requiring generic resources such as clocks, GPIOs or even regulators that
> could be provided by the display controller).
>
> As we can't probe the display controller and the panel together, a probe order
> needs to be defined. The decision was to consider video sources as resources
> and defer panel probing until all required resources (video stream source,
> clocks, GPIOs, regulators and more) are available. Display controller probing
> must succeed without the panel being available. This mimicks the hotpluggable
> monitor model (VGA, HDMI, DP) that doesn't prevent display controllers from
> being successfully probed without a connected monitor.
>
> Our design goal is to handle panel discovery in a similar (if not identical)
> way as HDMI/DP hotplug in order to implement a single display discovery method
> in display controller drivers. This might not be achievable, in which case
> we'll reconsider the design requirement.
>
> When the display controller driver probes the device it will register the
> video source(s) at the output of the display controller with the CDF core.
> Those sources will be identified by the display controller dev_name() and a
> source integer index. A new structure, likely called display_entity_port, will
> be used to represent a source or sink video port on a display entity.
>
> Panel drivers will handle video sources as resources. They will retrieve at
> probe time the video source the panel is connected to using a phandle or a
> source name (depending on whether the platform uses DT). If the source isn't
> available the probe function will return -EPROBE_DEFER.
>
> In addition to the video stream control operations mentioned above, ports will
> also expose a connect/disconnect operation use to notify them of
> connection/disconnection events. After retrieving the connected video source
> panel drivers call the connect/disconnect operation on the video source to
> notify it that the panel is available.
>
> When the panel is a pipeline made of more than a single entity, entities are
> probed in video source to video sink order. Out-of-order probe will result in
> probe deferral as explained above due to the video source not being available,
> resulting in the source to sink probe order. Entities should not call the
> connect operation of their video source at probe time in that case, but only
> when their own connect operation for the video source(s) they provide to the
> next entity is called by the next entity. Connect operations will thus be
> called in sink to source order starting at the entity at the end of the
> pipeline and going all the way back to the display controller.
>
> This notification system is a hotplug mechanism that replaces the display
> entity notifier system from my previous RFC. Alan Cox rightly objected to the
> notification system, arguing that such system-wide notifications were used by
> FBDEV and very subject to abuse. I agree with his argument, this new mechanism
> should result in a cleaner implementation as video sources will only be
> notified of connect/disconnect events for the entity they're connected to.
>
> DBI/DSI busses
> --------------
>
> My RFC introduced a DBI bus using the Linux device and bus model. Its purpose
> was multifold:
>
> - Support (un)registration, matching and binding of devices and drivers.
>
> - Provide power management (suspend/resume) services through the standard
> Linux PM bus/device model, to make sure that DBI devices will be
> suspended/resumed after/before their DBI bus controller.
>
> - Provide bus services to access the connected devices. For DBI that took the
> form of command read and data read/write functions.
>
> A DSI bus implementation using the same model was also planned.
>
> Tomi's patches removed the DBI bus and replaced DBI devices with platform
> devices, moving the bus services implementation to the video source. DBI and
> DSI busses are always either pure video or video + control busses (although
> controlling a DPI panel through DSI is conceivable, nobody in his right mind,
> not even a hardware engineer, would likely implement that), so there will
> always be a video source to provide the DBI/DSI control operations.
>
> (Un)registration, matching and binding of devices and drivers is provided by
> the platform device bus. Bus services to access connected devices are provided
> by the video source, wrapper functions will be used to handle serialization
> and locking, and possibly to offer higher level services (such as DCS for
> instance).
>
> One drawback of using the platform bus is that PM relationships between the
> bus master and slaves will not be taken into account during suspend/resume.
> However, a similar issue exists for DPI panels, and PM relationships at the
> video bus level for DBI and DSI are not handled by the DBI/DSI busses either.
> As we need a generic solution to handle those (likely through early suspend
> and late resume), the same solution can be used to handle DBI and DSI control
> bus PM relationships without requiring a Linux DBI or DSI bus.
>
> Even though I still like the idea of DBI and DSI busses, I agree with Tomi
> that they're not strictly needed and I will drop them.
I'd like to highlight two points I made about the bus model:
- If DBI is used only for video, there's no DBI bus. How to configure
DBI in this case?
- If DBI is used for control and video, we have two separate APIs for
the bus. In theory it's possible to handle this, but in practice it may
be impossible, especially for more complex busses like DSI.
I think both of those issues would make the bus model very difficult to
implement. I have no idea how it could be done neatly. So as I see it,
it's not only about "not strictly needed", but that the bus model
wouldn't work without complex code.
> Entity model
> ------------
>
> Tomi's proposal split the display entities into video sources (struct
> video_source) and display entities (struct display_entity). To make generic
> pipeline operations easier, we agreed to merge the video source and the
> display entity back. struct display_entity thus models a display entity that
> has any number of sink and/or source ports, modeled as struct
> display_entity_port instances.
>
> Video stream operations will be exposed by the display entity as function
> pointers and will take a port reference as argument (this could take the form
> of struct display_entity * and port index, or struct display_entity_port *).
I'd very much like to have only one parameter to pass, as there may be
lots of ops for some busses. Having two parameters to refer to the
source is just extra code that has no extra benefit when using video
source ops. Then again, having separate port index parameter could be
perhaps simpler to implement for the one handling the video source ops,
so...
> The DVI and DSI operations model proposed by Tomi in this patch series will be
> kept.
>
> Points that we forgot to discuss
> --------------------------------
>
> - DISPLAY_ENTITY_STREAM_SINGLE_SHOT vs. update() operation
Ah, yes, we missed that. I think it's possible to use SINGLE_SHOT, but
then it requires some kind of system to inform about finished update. Or
we could, of course, decide that informing about the update is done in
dispc-specific code, like handling VSYNC.
Hmm, except that won't probably work, as the panel (or any DSI device)
may need to know if the DSI bus is currently used or not.
Tomi
[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 899 bytes --]
^ permalink raw reply
* Re: [RFC 0/6] Common Display Framework-T
From: Laurent Pinchart @ 2012-12-19 13:21 UTC (permalink / raw)
To: Tomi Valkeinen; +Cc: linux-fbdev, dri-devel
In-Reply-To: <1355495252-26364-1-git-send-email-tomi.valkeinen@ti.com>
Hi Tomi,
On Friday 14 December 2012 16:27:26 Tomi Valkeinen wrote:
> Hi,
>
> I have been testing Common Display Framework on OMAP, and making changes
> that I've discussed in the posts I've sent in reply to the CDF series from
> Laurent. While my CDF code is rather hacky and not at all ready, I wanted
> to post the code for comments and also as a reference code to my posts.
>
> So here is CDF-T (Tomi-edition =).
We've discussed your approach extensively face-to-face today so I won't review
the patches in detail, but I will instead summarize our discussion to make
sure we understood each other (and let other developers jump in).
For the purpose of this discussion the term "display controller driver" (or
just "display controller") refer to both the low-level driver layer that
communicates directly with the display controller hardware, and to the higher-
level driver layer that implements and exposes the userspace API (FBDEV, KMS
and/or V4L). Those layers can be implemented in multiple kernel modules (such
as in the OMAP DSS case, with omapdss for the low-level layer and omapdrm,
omapfb and omapvout for the API-level layer) or a single kernel module.
Control model
-------------
The figure at http://www.ideasonboard.org/media/cdf/cdf-panel-control-
model.png shows the CDF control model.
The panel object depicted on the figure doesn't need to be a panel in the
stricter sense but could be any chain of off-SoC (both on-board or off-board)
display entities. It however helps thinking about it as a panel and doesn't
hurt the model.
The panel is controlled through abstract control requests. Those requests are
used to retrieve panel information (such as the physical size, the supported
video modes, EDID information, ...), set the panel configuration (such as the
active video timings) or control the panel operation state (enabling/disabling
the panel, controlling panel blanking and power management, ...). They are
exposed by the panel using function pointers, and called by other kernel
components in response to userspace requests (through the FBDEV, KMS or V4L2
APIs) or in-kernel events (for instance hotplug notifications).
In response to the control requests the panel driver will communicate with the
panel through the panel control bus (I2C, SPI, DBI, DSI, GPIO, ..., not shown
on the figure) and will control the video stream it receives on its input.
The panel is connected at the hardware level to a video source (shown as a
green hashed rectangle) that provides it with a video stream. The video stream
flows from the video source to the panel and is directly controlled by its
source, as shown by the green arrow from the display controller to the video
stream. The video source exposes stream control operations as function
pointers that are used by the panel to control the video stream, as shown by
the green arrow from the panel to the video source.
The figure at http://www.ideasonboard.org/media/cdf/cdf-panel-control-
model-2.png shows the call flow across entities when the panel is a pipeline
made of more than a single entity. In this case the SoC (on the left of the
dashed line) outputs a video stream on a DSI bus connected to a DSI to LVDS
transmitter. The output of the DSI to LVDS transmitter is connected to an LVDS
panel (or, more accurately, an LVDS panel module made of an LVDS panel
controller and a panel).
The transmitter and panel module are seen by the display controller and
userspace API implementations as a single entity that exposes control request
operations and controls its input video stream. When a control request is
performed (outermost green arrow) the DSI to LVDS transmitter will propagate
it to the panel, possibly mangling the input parameters or the response. For
panel operation state control requests the last entity in the pipeline will
likely want to control the video stream it receives on its input. The video
stream control calls will be propagated from right to left as shown by the red
arrows.
Every entity in the call stack can communicate with its hardware device
through the corresponding control bus, and/or control the video stream it
receives on its input.
This model allows filtering out modes and timings supported by the panel but
unsupported by the transmitter and mangling the modes and timings according to
the transmitter limitations. It has no complexity drawback for simple devices,
as the corresponding drivers can just forward the calls directly. Similar use
cases could exist for other control operations than mode and information
retrieval.
Discovery
---------
Before being able to issue control requests, panel devices need to be
discovered and associated with the connected display controller(s).
Panels and display controllers are cross-dependent. There is no way around
that, as the display controller needs a reference to the panel to call control
requests in response to userspace API, and the panel needs a reference to the
display controller to call video stream control functions (in addition to
requiring generic resources such as clocks, GPIOs or even regulators that
could be provided by the display controller).
As we can't probe the display controller and the panel together, a probe order
needs to be defined. The decision was to consider video sources as resources
and defer panel probing until all required resources (video stream source,
clocks, GPIOs, regulators and more) are available. Display controller probing
must succeed without the panel being available. This mimicks the hotpluggable
monitor model (VGA, HDMI, DP) that doesn't prevent display controllers from
being successfully probed without a connected monitor.
Our design goal is to handle panel discovery in a similar (if not identical)
way as HDMI/DP hotplug in order to implement a single display discovery method
in display controller drivers. This might not be achievable, in which case
we'll reconsider the design requirement.
When the display controller driver probes the device it will register the
video source(s) at the output of the display controller with the CDF core.
Those sources will be identified by the display controller dev_name() and a
source integer index. A new structure, likely called display_entity_port, will
be used to represent a source or sink video port on a display entity.
Panel drivers will handle video sources as resources. They will retrieve at
probe time the video source the panel is connected to using a phandle or a
source name (depending on whether the platform uses DT). If the source isn't
available the probe function will return -EPROBE_DEFER.
In addition to the video stream control operations mentioned above, ports will
also expose a connect/disconnect operation use to notify them of
connection/disconnection events. After retrieving the connected video source
panel drivers call the connect/disconnect operation on the video source to
notify it that the panel is available.
When the panel is a pipeline made of more than a single entity, entities are
probed in video source to video sink order. Out-of-order probe will result in
probe deferral as explained above due to the video source not being available,
resulting in the source to sink probe order. Entities should not call the
connect operation of their video source at probe time in that case, but only
when their own connect operation for the video source(s) they provide to the
next entity is called by the next entity. Connect operations will thus be
called in sink to source order starting at the entity at the end of the
pipeline and going all the way back to the display controller.
This notification system is a hotplug mechanism that replaces the display
entity notifier system from my previous RFC. Alan Cox rightly objected to the
notification system, arguing that such system-wide notifications were used by
FBDEV and very subject to abuse. I agree with his argument, this new mechanism
should result in a cleaner implementation as video sources will only be
notified of connect/disconnect events for the entity they're connected to.
DBI/DSI busses
--------------
My RFC introduced a DBI bus using the Linux device and bus model. Its purpose
was multifold:
- Support (un)registration, matching and binding of devices and drivers.
- Provide power management (suspend/resume) services through the standard
Linux PM bus/device model, to make sure that DBI devices will be
suspended/resumed after/before their DBI bus controller.
- Provide bus services to access the connected devices. For DBI that took the
form of command read and data read/write functions.
A DSI bus implementation using the same model was also planned.
Tomi's patches removed the DBI bus and replaced DBI devices with platform
devices, moving the bus services implementation to the video source. DBI and
DSI busses are always either pure video or video + control busses (although
controlling a DPI panel through DSI is conceivable, nobody in his right mind,
not even a hardware engineer, would likely implement that), so there will
always be a video source to provide the DBI/DSI control operations.
(Un)registration, matching and binding of devices and drivers is provided by
the platform device bus. Bus services to access connected devices are provided
by the video source, wrapper functions will be used to handle serialization
and locking, and possibly to offer higher level services (such as DCS for
instance).
One drawback of using the platform bus is that PM relationships between the
bus master and slaves will not be taken into account during suspend/resume.
However, a similar issue exists for DPI panels, and PM relationships at the
video bus level for DBI and DSI are not handled by the DBI/DSI busses either.
As we need a generic solution to handle those (likely through early suspend
and late resume), the same solution can be used to handle DBI and DSI control
bus PM relationships without requiring a Linux DBI or DSI bus.
Even though I still like the idea of DBI and DSI busses, I agree with Tomi
that they're not strictly needed and I will drop them.
Entity model
------------
Tomi's proposal split the display entities into video sources (struct
video_source) and display entities (struct display_entity). To make generic
pipeline operations easier, we agreed to merge the video source and the
display entity back. struct display_entity thus models a display entity that
has any number of sink and/or source ports, modeled as struct
display_entity_port instances.
Video stream operations will be exposed by the display entity as function
pointers and will take a port reference as argument (this could take the form
of struct display_entity * and port index, or struct display_entity_port *).
The DVI and DSI operations model proposed by Tomi in this patch series will be
kept.
Points that we forgot to discuss
--------------------------------
- DISPLAY_ENTITY_STREAM_SINGLE_SHOT vs. update() operation
I'll look into that.
Please let me know if I've forgotten anything.
--
Regards,
Laurent Pinchart
^ permalink raw reply
* Re: [PATCH V2 2/6] OMAPDSS: DISPC: Move DISPC specific dss_reg_fields to dispc_features
From: Chandrabhanu Mahapatra @ 2012-12-19 9:39 UTC (permalink / raw)
To: Tomi Valkeinen; +Cc: linux-omap, linux-fbdev
In-Reply-To: <50CF1202.70507@ti.com>
On Monday 17 December 2012 06:07 PM, Tomi Valkeinen wrote:
> On 2012-12-05 12:16, Chandrabhanu Mahapatra wrote:
>> The register fields in dss_reg_fields specific to DISPC are moved from struct
>> omap_dss_features to corresponding dispc_reg_fields, initialized in struct
>> dispc_features, thereby enabling local access.
>>
>> Signed-off-by: Chandrabhanu Mahapatra <cmahapatra@ti.com>
>> ---
>> drivers/video/omap2/dss/dispc.c | 114 ++++++++++++++++++++++++--------
>> drivers/video/omap2/dss/dss.h | 4 ++
>> drivers/video/omap2/dss/dss_features.c | 28 --------
>> drivers/video/omap2/dss/dss_features.h | 7 --
>> 4 files changed, 89 insertions(+), 64 deletions(-)
>>
>> diff --git a/drivers/video/omap2/dss/dispc.c b/drivers/video/omap2/dss/dispc.c
>> index bbba83f..ee4b152 100644
>> --- a/drivers/video/omap2/dss/dispc.c
>> +++ b/drivers/video/omap2/dss/dispc.c
>> @@ -80,6 +80,16 @@ struct dispc_irq_stats {
>> unsigned irqs[32];
>> };
>>
>> +struct dispc_reg_fields {
>> + struct omapdss_reg_field firhinc;
>> + struct omapdss_reg_field firvinc;
>> + struct omapdss_reg_field fifo_low_thresh;
>> + struct omapdss_reg_field fifo_high_thresh;
>> + struct omapdss_reg_field fifosize;
>> + struct omapdss_reg_field hori_accu;
>> + struct omapdss_reg_field vert_accu;
>> +};
>> +
>> struct dispc_features {
>> u8 sw_start;
>> u8 fp_start;
>> @@ -110,6 +120,8 @@ struct dispc_features {
>>
>> u32 buffer_size_unit; /* in bytes */
>> u32 burst_size_unit; /* in bytes */
>> +
>> + struct dispc_reg_fields *reg_fields;
>
> This can be pointer to const.
>
Yes, the same thing can also be done in other dispc and dsi reg_fields
and param_ranges.
>> };
>>
>> #define DISPC_MAX_NR_FIFOS 5
>> @@ -1137,17 +1149,17 @@ static void dispc_mgr_set_size(enum omap_channel channel, u16 width,
>>
>> static void dispc_init_fifos(void)
>> {
>> - u32 size;
>> + u32 size, unit;
>> int fifo;
>> - u8 start, end;
>> - u32 unit;
>> + const struct omapdss_reg_field *fifo_field;
>>
>> unit = dispc.feat->buffer_size_unit;
>>
>> - dss_feat_get_reg_field(FEAT_REG_FIFOSIZE, &start, &end);
>> + fifo_field = &dispc.feat->reg_fields->fifosize;
>>
>> for (fifo = 0; fifo < dispc.feat->num_fifos; ++fifo) {
>> - size = REG_GET(DISPC_OVL_FIFO_SIZE_STATUS(fifo), start, end);
>> + size = REG_GET(DISPC_OVL_FIFO_SIZE_STATUS(fifo),
>> + fifo_field->start, fifo_field->end);
>> size *= unit;
>> dispc.fifo_size[fifo] = size;
>>
>> @@ -1197,8 +1209,8 @@ static u32 dispc_ovl_get_fifo_size(enum omap_plane plane)
>>
>> void dispc_ovl_set_fifo_threshold(enum omap_plane plane, u32 low, u32 high)
>> {
>> - u8 hi_start, hi_end, lo_start, lo_end;
>> u32 unit;
>> + const struct omapdss_reg_field *hi_field, *lo_field;
>>
>> unit = dispc.feat->buffer_size_unit;
>>
>> @@ -1208,20 +1220,20 @@ void dispc_ovl_set_fifo_threshold(enum omap_plane plane, u32 low, u32 high)
>> low /= unit;
>> high /= unit;
>>
>> - dss_feat_get_reg_field(FEAT_REG_FIFOHIGHTHRESHOLD, &hi_start, &hi_end);
>> - dss_feat_get_reg_field(FEAT_REG_FIFOLOWTHRESHOLD, &lo_start, &lo_end);
>> + hi_field = &dispc.feat->reg_fields->fifo_high_thresh;
>> + lo_field = &dispc.feat->reg_fields->fifo_low_thresh;
>>
>> DSSDBG("fifo(%d) threshold (bytes), old %u/%u, new %u/%u\n",
>> plane,
>> REG_GET(DISPC_OVL_FIFO_THRESHOLD(plane),
>> - lo_start, lo_end) * unit,
>> + lo_field->start, lo_field->end) * unit,
>> REG_GET(DISPC_OVL_FIFO_THRESHOLD(plane),
>> - hi_start, hi_end) * unit,
>> + hi_field->start, hi_field->end) * unit,
>> low * unit, high * unit);
>>
>> dispc_write_reg(DISPC_OVL_FIFO_THRESHOLD(plane),
>> - FLD_VAL(high, hi_start, hi_end) |
>> - FLD_VAL(low, lo_start, lo_end));
>> + FLD_VAL(high, hi_field->start, hi_field->end) |
>> + FLD_VAL(low, lo_field->start, lo_field->end));
>> }
>>
>> void dispc_enable_fifomerge(bool enable)
>> @@ -1289,14 +1301,13 @@ static void dispc_ovl_set_fir(enum omap_plane plane,
>> u32 val;
>>
>> if (color_comp = DISPC_COLOR_COMPONENT_RGB_Y) {
>> - u8 hinc_start, hinc_end, vinc_start, vinc_end;
>> + const struct omapdss_reg_field *hinc_field, *vinc_field;
>>
>> - dss_feat_get_reg_field(FEAT_REG_FIRHINC,
>> - &hinc_start, &hinc_end);
>> - dss_feat_get_reg_field(FEAT_REG_FIRVINC,
>> - &vinc_start, &vinc_end);
>> - val = FLD_VAL(vinc, vinc_start, vinc_end) |
>> - FLD_VAL(hinc, hinc_start, hinc_end);
>> + hinc_field = &dispc.feat->reg_fields->firhinc;
>> + vinc_field = &dispc.feat->reg_fields->firvinc;
>> +
>> + val = FLD_VAL(vinc, vinc_field->start, vinc_field->end) |
>> + FLD_VAL(hinc, hinc_field->start, hinc_field->end);
>>
>> dispc_write_reg(DISPC_OVL_FIR(plane), val);
>> } else {
>> @@ -1308,13 +1319,13 @@ static void dispc_ovl_set_fir(enum omap_plane plane,
>> static void dispc_ovl_set_vid_accu0(enum omap_plane plane, int haccu, int vaccu)
>> {
>> u32 val;
>> - u8 hor_start, hor_end, vert_start, vert_end;
>> + const struct omapdss_reg_field *haccu_field, *vaccu_field;
>>
>> - dss_feat_get_reg_field(FEAT_REG_HORIZONTALACCU, &hor_start, &hor_end);
>> - dss_feat_get_reg_field(FEAT_REG_VERTICALACCU, &vert_start, &vert_end);
>> + haccu_field = &dispc.feat->reg_fields->hori_accu;
>> + vaccu_field = &dispc.feat->reg_fields->vert_accu;
>>
>> - val = FLD_VAL(vaccu, vert_start, vert_end) |
>> - FLD_VAL(haccu, hor_start, hor_end);
>> + val = FLD_VAL(vaccu, vaccu_field->start, vaccu_field->end) |
>> + FLD_VAL(haccu, haccu_field->start, haccu_field->end);
>>
>> dispc_write_reg(DISPC_OVL_ACCU0(plane), val);
>> }
>> @@ -1322,13 +1333,13 @@ static void dispc_ovl_set_vid_accu0(enum omap_plane plane, int haccu, int vaccu)
>> static void dispc_ovl_set_vid_accu1(enum omap_plane plane, int haccu, int vaccu)
>> {
>> u32 val;
>> - u8 hor_start, hor_end, vert_start, vert_end;
>> + const struct omapdss_reg_field *haccu_field, *vaccu_field;
>>
>> - dss_feat_get_reg_field(FEAT_REG_HORIZONTALACCU, &hor_start, &hor_end);
>> - dss_feat_get_reg_field(FEAT_REG_VERTICALACCU, &vert_start, &vert_end);
>> + haccu_field = &dispc.feat->reg_fields->hori_accu;
>> + vaccu_field = &dispc.feat->reg_fields->vert_accu;
>>
>> - val = FLD_VAL(vaccu, vert_start, vert_end) |
>> - FLD_VAL(haccu, hor_start, hor_end);
>> + val = FLD_VAL(vaccu, vaccu_field->start, vaccu_field->end) |
>> + FLD_VAL(haccu, haccu_field->start, haccu_field->end);
>>
>> dispc_write_reg(DISPC_OVL_ACCU1(plane), val);
>> }
>> @@ -4048,6 +4059,46 @@ static void _omap_dispc_initial_config(void)
>> dispc_ovl_enable_zorder_planes();
>> }
>>
>> +static struct dispc_reg_fields omap2_dispc_reg_fields = {
>> + .firhinc = { 11, 0 },
>> + .firvinc = { 27, 16 },
>> + .fifo_low_thresh = { 8, 0 },
>> + .fifo_high_thresh = { 24, 16 },
>> + .fifosize = { 8, 0 },
>> + .hori_accu = { 9, 0 },
>> + .vert_accu = { 25, 16 },
>> +};
>
> And these tables can be consts.
>
>> +static struct dispc_reg_fields omap3_dispc_reg_fields = {
>> + .firhinc = { 12, 0 },
>> + .firvinc = { 28, 16 },
>> + .fifo_low_thresh = { 11, 0 },
>> + .fifo_high_thresh = { 27, 16 },
>> + .fifosize = { 10, 0 },
>> + .hori_accu = { 9, 0 },
>> + .vert_accu = { 25, 16 },
>> +};
>> +
>> +static struct dispc_reg_fields omap4_dispc_reg_fields = {
>> + .firhinc = { 12, 0 },
>> + .firvinc = { 28, 16 },
>> + .fifo_low_thresh = { 15, 0 },
>> + .fifo_high_thresh = { 31, 16 },
>> + .fifosize = { 15, 0 },
>> + .hori_accu = { 10, 0 },
>> + .vert_accu = { 26, 16 },
>> +};
>> +
>> +static struct dispc_reg_fields omap5_dispc_reg_fields = {
>> + .firhinc = { 12, 0 },
>> + .firvinc = { 28, 16 },
>> + .fifo_low_thresh = { 15, 0 },
>> + .fifo_high_thresh = { 31, 16 },
>> + .fifosize = { 15, 0 },
>> + .hori_accu = { 10, 0 },
>> + .vert_accu = { 26, 16 },
>> +};
>> +
>> static const struct dispc_features omap24xx_dispc_feats __initconst = {
>> .sw_start = 5,
>> .fp_start = 15,
>> @@ -4065,6 +4116,7 @@ static const struct dispc_features omap24xx_dispc_feats __initconst = {
>> .no_framedone_tv = true,
>> .buffer_size_unit = 1,
>> .burst_size_unit = 8,
>> + .reg_fields = &omap2_dispc_reg_fields,
>> };
>>
>> static const struct dispc_features omap34xx_rev1_0_dispc_feats __initconst = {
>> @@ -4084,6 +4136,7 @@ static const struct dispc_features omap34xx_rev1_0_dispc_feats __initconst = {
>> .no_framedone_tv = true,
>> .buffer_size_unit = 1,
>> .burst_size_unit = 8,
>> + .reg_fields = &omap3_dispc_reg_fields,
>> };
>>
>> static const struct dispc_features omap34xx_rev3_0_dispc_feats __initconst = {
>> @@ -4103,6 +4156,7 @@ static const struct dispc_features omap34xx_rev3_0_dispc_feats __initconst = {
>> .no_framedone_tv = true,
>> .buffer_size_unit = 1,
>> .burst_size_unit = 8,
>> + .reg_fields = &omap3_dispc_reg_fields,
>> };
>>
>> static const struct dispc_features omap44xx_dispc_feats __initconst = {
>> @@ -4122,6 +4176,7 @@ static const struct dispc_features omap44xx_dispc_feats __initconst = {
>> .gfx_fifo_workaround = true,
>> .buffer_size_unit = 16,
>> .burst_size_unit = 16,
>> + .reg_fields = &omap4_dispc_reg_fields,
>> };
>>
>> static const struct dispc_features omap54xx_dispc_feats __initconst = {
>> @@ -4141,6 +4196,7 @@ static const struct dispc_features omap54xx_dispc_feats __initconst = {
>> .gfx_fifo_workaround = true,
>> .buffer_size_unit = 16,
>> .burst_size_unit = 16,
>> + .reg_fields = &omap5_dispc_reg_fields,
>> };
>
> There's one thing to note here (and the same applies to DSI patches).
> The *_dispc_feats tables above are __initconst, and we make a copy of
> the needed table at probe time, so that the unneeded tables can be
> discarded. Now you add new tables, but they are not handled the same
> way. This is not a bug, but it's a bit inconsistent.
>
> So I think we have three options:
>
> - Make the new tables also __initconst, and create a copy of the needed
> tables, and fix up the pointers to point to the copied tables.
>
> - Embed the new tables into the *_dispc_feats table, as you suggested
> previously. This would mean multiple copies of the same data in some cases.
>
> - Remove the __initconst and the copy code.
>
> I'm not sure which one to pick. The first one feels a bit complex, but
> perhaps it should be tried first to see how the actual code would look
> like. If it's just a few lines per table, I guess it's ok.
>
> Tomi
>
>
I would like to go with first approach. The code will look like this
static int __init dispc_init_features(struct platform_device *pdev)
{
.....................................
const struct dispc_param_ranges *src_param;
struct dispc_param_ranges *dst_param;
dst_param = devm_kzalloc(&pdev->dev, sizeof(*dst_param), GFP_KERNEL);
if (!dst_param) {
dev_err(&pdev->dev, "Failed to allocate DISPC Param Ranges\n");
return -ENOMEM;
}
switch (omapdss_get_version()) {
case OMAPDSS_VER_OMAP24xx:
src = &omap24xx_dispc_feats;
src_param = &omap2_dispc_param_ranges;
break;
.............................
}
memcpy(dst, src, sizeof(*dst));
memcpy(dst_param, src_param, sizeof(*dst_param));
dst->params = dst_param;
dispc.feat = dst;
return 0;
}
Yes, the code looks a bit complex but still well manageable.
--
Chandrabhanu Mahapatra
Texas Instruments India Pvt. Ltd.
^ permalink raw reply
* Re: [PATCH V2 4/6] OMAPDSS: DSI: Move DSI specific reg_fields to dsi_feats
From: Chandrabhanu Mahapatra @ 2012-12-19 9:10 UTC (permalink / raw)
To: Tomi Valkeinen; +Cc: linux-omap, linux-fbdev
In-Reply-To: <50CF0EA6.2040302@ti.com>
On Monday 17 December 2012 05:53 PM, Tomi Valkeinen wrote:
> Hi,
>
> On 2012-12-05 12:16, Chandrabhanu Mahapatra wrote:
>> The DSI specific dss_reg_fields are moved to corresponding dsi_reg_fields
>> initialized in dsi_feats. The dsi_feats structure is initialized as per
>> corresponding DSS version in dsi_init_features().
>>
>> Signed-off-by: Chandrabhanu Mahapatra <cmahapatra@ti.com>
>> ---
>> drivers/video/omap2/dss/dsi.c | 126 +++++++++++++++++++++++++++++---
>> drivers/video/omap2/dss/dss_features.c | 16 ----
>> drivers/video/omap2/dss/dss_features.h | 4 -
>> 3 files changed, 114 insertions(+), 32 deletions(-)
>>
>
>> +static int __init dsi_init_features(struct platform_device *dsidev)
>> +{
>> + const struct feats *src;
>> + struct feats *dst;
>> +
>> + dst = devm_kzalloc(&dsidev->dev, sizeof(*dst), GFP_KERNEL);
>> + if (!dst) {
>> + dev_err(&dsidev->dev, "Failed to allocate DISPC Features\n");
>> + return -ENOMEM;
>> + }
>> +
>> + switch (omapdss_get_version()) {
>> + case OMAPDSS_VER_OMAP24xx:
>> + src = &omap24xx_dsi_feats;
>> + break;
>> +
>> + case OMAPDSS_VER_OMAP34xx_ES1:
>> + case OMAPDSS_VER_OMAP34xx_ES3:
>> + case OMAPDSS_VER_OMAP3630:
>> + case OMAPDSS_VER_AM35xx:
>> + src = &omap34xx_dsi_feats;
>> + break;
>> +
>> + case OMAPDSS_VER_OMAP4430_ES1:
>> + case OMAPDSS_VER_OMAP4430_ES2:
>> + case OMAPDSS_VER_OMAP4:
>> + src = &omap44xx_dsi_feats;
>> + break;
>> +
>> + case OMAPDSS_VER_OMAP5:
>> + src = &omap54xx_dsi_feats;
>> + break;
>> +
>> + default:
>> + return -ENODEV;
>> + }
>
> There's no DSI on OMAP2, so that case can be left out.
>
> Tomi
>
>
Ok. Forgot to see that in dss_features.
--
Chandrabhanu Mahapatra
Texas Instruments India Pvt. Ltd.
^ permalink raw reply
* Fw: BUSINESS PROPOSAL, PLEASE VIEW ATTACHMENT
From: Engr @ 2012-12-18 20:09 UTC (permalink / raw)
To: linux-fbdev
[-- Attachment #1: Type: text/plain, Size: 0 bytes --]
[-- Attachment #2: BUSINESS_PROPOSAL_FROM_ENGINEER ANTHONY.doc --]
[-- Type: application/msword, Size: 40448 bytes --]
^ permalink raw reply
* [PATCHv16 7/7] drm_modes: add of_videomode helpers
From: Steffen Trumtrar @ 2012-12-18 17:04 UTC (permalink / raw)
To: devicetree-discuss
Cc: Steffen Trumtrar, Rob Herring, linux-fbdev, dri-devel,
Laurent Pinchart, Thierry Reding, Guennady Liakhovetski,
linux-media, Tomi Valkeinen, Stephen Warren, kernel,
Florian Tobias Schandinat, David Airlie, Rob Clark,
Leela Krishna Amudala
In-Reply-To: <1355850256-16135-1-git-send-email-s.trumtrar@pengutronix.de>
Add helper to get drm_display_mode from devicetree.
Signed-off-by: Steffen Trumtrar <s.trumtrar@pengutronix.de>
Reviewed-by: Thierry Reding <thierry.reding@avionic-design.de>
Acked-by: Thierry Reding <thierry.reding@avionic-design.de>
Tested-by: Thierry Reding <thierry.reding@avionic-design.de>
Tested-by: Philipp Zabel <p.zabel@pengutronix.de>
Reviewed-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Acked-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
---
drivers/gpu/drm/drm_modes.c | 33 +++++++++++++++++++++++++++++++++
include/drm/drmP.h | 4 ++++
2 files changed, 37 insertions(+)
diff --git a/drivers/gpu/drm/drm_modes.c b/drivers/gpu/drm/drm_modes.c
index 184a22d..fd53454 100644
--- a/drivers/gpu/drm/drm_modes.c
+++ b/drivers/gpu/drm/drm_modes.c
@@ -35,6 +35,7 @@
#include <linux/export.h>
#include <drm/drmP.h>
#include <drm/drm_crtc.h>
+#include <video/of_videomode.h>
#include <video/videomode.h>
/**
@@ -541,6 +542,38 @@ int drm_display_mode_from_videomode(const struct videomode *vm,
EXPORT_SYMBOL_GPL(drm_display_mode_from_videomode);
#endif
+#if IS_ENABLED(CONFIG_OF_VIDEOMODE)
+/**
+ * of_get_drm_display_mode - get a drm_display_mode from devicetree
+ * @np: device_node with the timing specification
+ * @dmode: will be set to the return value
+ * @index: index into the list of display timings in devicetree
+ *
+ * This function is expensive and should only be used, if only one mode is to be
+ * read from DT. To get multiple modes start with of_get_display_timings and
+ * work with that instead.
+ */
+int of_get_drm_display_mode(struct device_node *np,
+ struct drm_display_mode *dmode, int index)
+{
+ struct videomode vm;
+ int ret;
+
+ ret = of_get_videomode(np, &vm, index);
+ if (ret)
+ return ret;
+
+ drm_display_mode_from_videomode(&vm, dmode);
+
+ pr_debug("%s: got %dx%d display mode from %s\n",
+ of_node_full_name(np), vm.hactive, vm.vactive, np->name);
+ drm_mode_debug_printmodeline(dmode);
+
+ return 0;
+}
+EXPORT_SYMBOL_GPL(of_get_drm_display_mode);
+#endif
+
/**
* drm_mode_set_name - set the name on a mode
* @mode: name will be set in this mode
diff --git a/include/drm/drmP.h b/include/drm/drmP.h
index 5fbb0fe..e26ca59 100644
--- a/include/drm/drmP.h
+++ b/include/drm/drmP.h
@@ -85,6 +85,7 @@ struct module;
struct drm_file;
struct drm_device;
+struct device_node;
struct videomode;
#include <drm/drm_os_linux.h>
@@ -1458,6 +1459,9 @@ drm_mode_create_from_cmdline_mode(struct drm_device *dev,
extern int drm_display_mode_from_videomode(const struct videomode *vm,
struct drm_display_mode *dmode);
+extern int of_get_drm_display_mode(struct device_node *np,
+ struct drm_display_mode *dmode,
+ int index);
/* Modesetting support */
extern void drm_vblank_pre_modeset(struct drm_device *dev, int crtc);
--
1.7.10.4
^ permalink raw reply related
* [PATCHv16 6/7] drm_modes: add videomode helpers
From: Steffen Trumtrar @ 2012-12-18 17:04 UTC (permalink / raw)
To: devicetree-discuss
Cc: Steffen Trumtrar, Rob Herring, linux-fbdev, dri-devel,
Laurent Pinchart, Thierry Reding, Guennady Liakhovetski,
linux-media, Tomi Valkeinen, Stephen Warren, kernel,
Florian Tobias Schandinat, David Airlie, Rob Clark,
Leela Krishna Amudala
In-Reply-To: <1355850256-16135-1-git-send-email-s.trumtrar@pengutronix.de>
Add conversion from videomode to drm_display_mode
Signed-off-by: Steffen Trumtrar <s.trumtrar@pengutronix.de>
Reviewed-by: Thierry Reding <thierry.reding@avionic-design.de>
Acked-by: Thierry Reding <thierry.reding@avionic-design.de>
Tested-by: Thierry Reding <thierry.reding@avionic-design.de>
Tested-by: Philipp Zabel <p.zabel@pengutronix.de>
Reviewed-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Acked-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
---
drivers/gpu/drm/drm_modes.c | 37 +++++++++++++++++++++++++++++++++++++
include/drm/drmP.h | 5 +++++
2 files changed, 42 insertions(+)
diff --git a/drivers/gpu/drm/drm_modes.c b/drivers/gpu/drm/drm_modes.c
index 59450f3..184a22d 100644
--- a/drivers/gpu/drm/drm_modes.c
+++ b/drivers/gpu/drm/drm_modes.c
@@ -35,6 +35,7 @@
#include <linux/export.h>
#include <drm/drmP.h>
#include <drm/drm_crtc.h>
+#include <video/videomode.h>
/**
* drm_mode_debug_printmodeline - debug print a mode
@@ -504,6 +505,42 @@ drm_gtf_mode(struct drm_device *dev, int hdisplay, int vdisplay, int vrefresh,
}
EXPORT_SYMBOL(drm_gtf_mode);
+#if IS_ENABLED(CONFIG_VIDEOMODE)
+int drm_display_mode_from_videomode(const struct videomode *vm,
+ struct drm_display_mode *dmode)
+{
+ dmode->hdisplay = vm->hactive;
+ dmode->hsync_start = dmode->hdisplay + vm->hfront_porch;
+ dmode->hsync_end = dmode->hsync_start + vm->hsync_len;
+ dmode->htotal = dmode->hsync_end + vm->hback_porch;
+
+ dmode->vdisplay = vm->vactive;
+ dmode->vsync_start = dmode->vdisplay + vm->vfront_porch;
+ dmode->vsync_end = dmode->vsync_start + vm->vsync_len;
+ dmode->vtotal = dmode->vsync_end + vm->vback_porch;
+
+ dmode->clock = vm->pixelclock / 1000;
+
+ dmode->flags = 0;
+ if (vm->dmt_flags & VESA_DMT_HSYNC_HIGH)
+ dmode->flags |= DRM_MODE_FLAG_PHSYNC;
+ else if (vm->dmt_flags & VESA_DMT_HSYNC_LOW)
+ dmode->flags |= DRM_MODE_FLAG_NHSYNC;
+ if (vm->dmt_flags & VESA_DMT_VSYNC_HIGH)
+ dmode->flags |= DRM_MODE_FLAG_PVSYNC;
+ else if (vm->dmt_flags & VESA_DMT_VSYNC_LOW)
+ dmode->flags |= DRM_MODE_FLAG_NVSYNC;
+ if (vm->data_flags & DISPLAY_FLAGS_INTERLACED)
+ dmode->flags |= DRM_MODE_FLAG_INTERLACE;
+ if (vm->data_flags & DISPLAY_FLAGS_DOUBLESCAN)
+ dmode->flags |= DRM_MODE_FLAG_DBLSCAN;
+ drm_mode_set_name(dmode);
+
+ return 0;
+}
+EXPORT_SYMBOL_GPL(drm_display_mode_from_videomode);
+#endif
+
/**
* drm_mode_set_name - set the name on a mode
* @mode: name will be set in this mode
diff --git a/include/drm/drmP.h b/include/drm/drmP.h
index 3fd8280..5fbb0fe 100644
--- a/include/drm/drmP.h
+++ b/include/drm/drmP.h
@@ -85,6 +85,8 @@ struct module;
struct drm_file;
struct drm_device;
+struct videomode;
+
#include <drm/drm_os_linux.h>
#include <drm/drm_hashtab.h>
#include <drm/drm_mm.h>
@@ -1454,6 +1456,9 @@ extern struct drm_display_mode *
drm_mode_create_from_cmdline_mode(struct drm_device *dev,
struct drm_cmdline_mode *cmd);
+extern int drm_display_mode_from_videomode(const struct videomode *vm,
+ struct drm_display_mode *dmode);
+
/* Modesetting support */
extern void drm_vblank_pre_modeset(struct drm_device *dev, int crtc);
extern void drm_vblank_post_modeset(struct drm_device *dev, int crtc);
--
1.7.10.4
^ permalink raw reply related
* [PATCHv16 5/7] fbmon: add of_videomode helpers
From: Steffen Trumtrar @ 2012-12-18 17:04 UTC (permalink / raw)
To: devicetree-discuss
Cc: Steffen Trumtrar, Rob Herring, linux-fbdev, dri-devel,
Laurent Pinchart, Thierry Reding, Guennady Liakhovetski,
linux-media, Tomi Valkeinen, Stephen Warren, kernel,
Florian Tobias Schandinat, David Airlie, Rob Clark,
Leela Krishna Amudala
In-Reply-To: <1355850256-16135-1-git-send-email-s.trumtrar@pengutronix.de>
Add helper to get fb_videomode from devicetree.
Signed-off-by: Steffen Trumtrar <s.trumtrar@pengutronix.de>
Reviewed-by: Thierry Reding <thierry.reding@avionic-design.de>
Acked-by: Thierry Reding <thierry.reding@avionic-design.de>
Tested-by: Thierry Reding <thierry.reding@avionic-design.de>
Tested-by: Philipp Zabel <p.zabel@pengutronix.de>
Reviewed-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Acked-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
---
drivers/video/fbmon.c | 42 ++++++++++++++++++++++++++++++++++++++++++
include/linux/fb.h | 4 ++++
2 files changed, 46 insertions(+)
diff --git a/drivers/video/fbmon.c b/drivers/video/fbmon.c
index 17ce135..94ad0f7 100644
--- a/drivers/video/fbmon.c
+++ b/drivers/video/fbmon.c
@@ -31,6 +31,7 @@
#include <linux/pci.h>
#include <linux/slab.h>
#include <video/edid.h>
+#include <video/of_videomode.h>
#include <video/videomode.h>
#ifdef CONFIG_PPC_OF
#include <asm/prom.h>
@@ -1425,6 +1426,47 @@ int fb_videomode_from_videomode(const struct videomode *vm,
EXPORT_SYMBOL_GPL(fb_videomode_from_videomode);
#endif
+#if IS_ENABLED(CONFIG_OF_VIDEOMODE)
+static inline void dump_fb_videomode(const struct fb_videomode *m)
+{
+ pr_debug("fb_videomode = %ux%u@%uHz (%ukHz) %u %u %u %u %u %u %u %u %u\n",
+ m->xres, m->yres, m->refresh, m->pixclock, m->left_margin,
+ m->right_margin, m->upper_margin, m->lower_margin,
+ m->hsync_len, m->vsync_len, m->sync, m->vmode, m->flag);
+}
+
+/**
+ * of_get_fb_videomode - get a fb_videomode from devicetree
+ * @np: device_node with the timing specification
+ * @fb: will be set to the return value
+ * @index: index into the list of display timings in devicetree
+ *
+ * DESCRIPTION:
+ * This function is expensive and should only be used, if only one mode is to be
+ * read from DT. To get multiple modes start with of_get_display_timings ond
+ * work with that instead.
+ */
+int of_get_fb_videomode(struct device_node *np, struct fb_videomode *fb,
+ int index)
+{
+ struct videomode vm;
+ int ret;
+
+ ret = of_get_videomode(np, &vm, index);
+ if (ret)
+ return ret;
+
+ fb_videomode_from_videomode(&vm, fb);
+
+ pr_debug("%s: got %dx%d display mode from %s\n",
+ of_node_full_name(np), vm.hactive, vm.vactive, np->name);
+ dump_fb_videomode(fb);
+
+ return 0;
+}
+EXPORT_SYMBOL_GPL(of_get_fb_videomode);
+#endif
+
#else
int fb_parse_edid(unsigned char *edid, struct fb_var_screeninfo *var)
{
diff --git a/include/linux/fb.h b/include/linux/fb.h
index 100a176..58b9860 100644
--- a/include/linux/fb.h
+++ b/include/linux/fb.h
@@ -20,6 +20,7 @@ struct fb_info;
struct device;
struct file;
struct videomode;
+struct device_node;
/* Definitions below are used in the parsed monitor specs */
#define FB_DPMS_ACTIVE_OFF 1
@@ -715,6 +716,9 @@ extern void fb_destroy_modedb(struct fb_videomode *modedb);
extern int fb_find_mode_cvt(struct fb_videomode *mode, int margins, int rb);
extern unsigned char *fb_ddc_read(struct i2c_adapter *adapter);
+extern int of_get_fb_videomode(struct device_node *np,
+ struct fb_videomode *fb,
+ int index);
extern int fb_videomode_from_videomode(const struct videomode *vm,
struct fb_videomode *fbmode);
--
1.7.10.4
^ permalink raw reply related
* [PATCHv16 4/7] fbmon: add videomode helpers
From: Steffen Trumtrar @ 2012-12-18 17:04 UTC (permalink / raw)
To: devicetree-discuss
Cc: Steffen Trumtrar, Rob Herring, linux-fbdev, dri-devel,
Laurent Pinchart, Thierry Reding, Guennady Liakhovetski,
linux-media, Tomi Valkeinen, Stephen Warren, kernel,
Florian Tobias Schandinat, David Airlie, Rob Clark,
Leela Krishna Amudala
In-Reply-To: <1355850256-16135-1-git-send-email-s.trumtrar@pengutronix.de>
Add a function to convert from the generic videomode to a fb_videomode.
Signed-off-by: Steffen Trumtrar <s.trumtrar@pengutronix.de>
Reviewed-by: Thierry Reding <thierry.reding@avionic-design.de>
Acked-by: Thierry Reding <thierry.reding@avionic-design.de>
Tested-by: Thierry Reding <thierry.reding@avionic-design.de>
Tested-by: Philipp Zabel <p.zabel@pengutronix.de>
Reviewed-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Acked-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
---
drivers/video/fbmon.c | 52 +++++++++++++++++++++++++++++++++++++++++++++++++
include/linux/fb.h | 4 ++++
2 files changed, 56 insertions(+)
diff --git a/drivers/video/fbmon.c b/drivers/video/fbmon.c
index cef6557..17ce135 100644
--- a/drivers/video/fbmon.c
+++ b/drivers/video/fbmon.c
@@ -31,6 +31,7 @@
#include <linux/pci.h>
#include <linux/slab.h>
#include <video/edid.h>
+#include <video/videomode.h>
#ifdef CONFIG_PPC_OF
#include <asm/prom.h>
#include <asm/pci-bridge.h>
@@ -1373,6 +1374,57 @@ int fb_get_mode(int flags, u32 val, struct fb_var_screeninfo *var, struct fb_inf
kfree(timings);
return err;
}
+
+#if IS_ENABLED(CONFIG_VIDEOMODE)
+int fb_videomode_from_videomode(const struct videomode *vm,
+ struct fb_videomode *fbmode)
+{
+ unsigned int htotal, vtotal;
+
+ fbmode->xres = vm->hactive;
+ fbmode->left_margin = vm->hback_porch;
+ fbmode->right_margin = vm->hfront_porch;
+ fbmode->hsync_len = vm->hsync_len;
+
+ fbmode->yres = vm->vactive;
+ fbmode->upper_margin = vm->vback_porch;
+ fbmode->lower_margin = vm->vfront_porch;
+ fbmode->vsync_len = vm->vsync_len;
+
+ /* prevent division by zero in KHZ2PICOS macro */
+ fbmode->pixclock = vm->pixelclock ?
+ KHZ2PICOS(vm->pixelclock / 1000) : 0;
+
+ fbmode->sync = 0;
+ fbmode->vmode = 0;
+ if (vm->dmt_flags & VESA_DMT_HSYNC_HIGH)
+ fbmode->sync |= FB_SYNC_HOR_HIGH_ACT;
+ if (vm->dmt_flags & VESA_DMT_HSYNC_HIGH)
+ fbmode->sync |= FB_SYNC_VERT_HIGH_ACT;
+ if (vm->data_flags & DISPLAY_FLAGS_INTERLACED)
+ fbmode->vmode |= FB_VMODE_INTERLACED;
+ if (vm->data_flags & DISPLAY_FLAGS_DOUBLESCAN)
+ fbmode->vmode |= FB_VMODE_DOUBLE;
+ fbmode->flag = 0;
+
+ htotal = vm->hactive + vm->hfront_porch + vm->hback_porch +
+ vm->hsync_len;
+ vtotal = vm->vactive + vm->vfront_porch + vm->vback_porch +
+ vm->vsync_len;
+ /* prevent division by zero */
+ if (htotal && vtotal) {
+ fbmode->refresh = vm->pixelclock / (htotal * vtotal);
+ /* a mode must have htotal and vtotal != 0 or it is invalid */
+ } else {
+ fbmode->refresh = 0;
+ return -EINVAL;
+ }
+
+ return 0;
+}
+EXPORT_SYMBOL_GPL(fb_videomode_from_videomode);
+#endif
+
#else
int fb_parse_edid(unsigned char *edid, struct fb_var_screeninfo *var)
{
diff --git a/include/linux/fb.h b/include/linux/fb.h
index c7a9571..100a176 100644
--- a/include/linux/fb.h
+++ b/include/linux/fb.h
@@ -19,6 +19,7 @@ struct vm_area_struct;
struct fb_info;
struct device;
struct file;
+struct videomode;
/* Definitions below are used in the parsed monitor specs */
#define FB_DPMS_ACTIVE_OFF 1
@@ -714,6 +715,9 @@ extern void fb_destroy_modedb(struct fb_videomode *modedb);
extern int fb_find_mode_cvt(struct fb_videomode *mode, int margins, int rb);
extern unsigned char *fb_ddc_read(struct i2c_adapter *adapter);
+extern int fb_videomode_from_videomode(const struct videomode *vm,
+ struct fb_videomode *fbmode);
+
/* drivers/video/modedb.c */
#define VESA_MODEDB_SIZE 34
extern void fb_var_to_videomode(struct fb_videomode *mode,
--
1.7.10.4
^ permalink raw reply related
* [PATCHv16 3/7] video: add of helper for display timings/videomode
From: Steffen Trumtrar @ 2012-12-18 17:04 UTC (permalink / raw)
To: devicetree-discuss
Cc: Steffen Trumtrar, Philipp Zabel, Rob Herring, linux-fbdev,
dri-devel, Laurent Pinchart, Thierry Reding,
Guennady Liakhovetski, linux-media, Tomi Valkeinen,
Stephen Warren, kernel, Florian Tobias Schandinat, David Airlie,
Rob Clark, Leela Krishna Amudala
In-Reply-To: <1355850256-16135-1-git-send-email-s.trumtrar@pengutronix.de>
This adds support for reading display timings from DT into a struct
display_timings. The of_display_timing implementation supports multiple
subnodes. All children are read into an array, that can be queried.
If no native mode is specified, the first subnode will be used.
For cases where the graphics driver knows there can be only one
mode description or where the driver only supports one mode, a helper
function of_get_videomode is added, that gets a struct videomode from DT.
Signed-off-by: Steffen Trumtrar <s.trumtrar@pengutronix.de>
Signed-off-by: Philipp Zabel <p.zabel@pengutronix.de>
Acked-by: Stephen Warren <swarren@nvidia.com>
Reviewed-by: Thierry Reding <thierry.reding@avionic-design.de>
Acked-by: Thierry Reding <thierry.reding@avionic-design.de>
Tested-by: Thierry Reding <thierry.reding@avionic-design.de>
Tested-by: Philipp Zabel <p.zabel@pengutronix.de>
Reviewed-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Acked-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
---
.../devicetree/bindings/video/display-timing.txt | 109 +++++++++
drivers/video/Kconfig | 15 ++
drivers/video/Makefile | 2 +
drivers/video/of_display_timing.c | 239 ++++++++++++++++++++
drivers/video/of_videomode.c | 54 +++++
include/video/of_display_timing.h | 20 ++
include/video/of_videomode.h | 18 ++
7 files changed, 457 insertions(+)
create mode 100644 Documentation/devicetree/bindings/video/display-timing.txt
create mode 100644 drivers/video/of_display_timing.c
create mode 100644 drivers/video/of_videomode.c
create mode 100644 include/video/of_display_timing.h
create mode 100644 include/video/of_videomode.h
diff --git a/Documentation/devicetree/bindings/video/display-timing.txt b/Documentation/devicetree/bindings/video/display-timing.txt
new file mode 100644
index 0000000..1500385
--- /dev/null
+++ b/Documentation/devicetree/bindings/video/display-timing.txt
@@ -0,0 +1,109 @@
+display-timing bindings
+===========+
+display-timings node
+--------------------
+
+required properties:
+ - none
+
+optional properties:
+ - native-mode: The native mode for the display, in case multiple modes are
+ provided. When omitted, assume the first node is the native.
+
+timing subnode
+--------------
+
+required properties:
+ - hactive, vactive: display resolution
+ - hfront-porch, hback-porch, hsync-len: horizontal display timing parameters
+ in pixels
+ vfront-porch, vback-porch, vsync-len: vertical display timing parameters in
+ lines
+ - clock-frequency: display clock in Hz
+
+optional properties:
+ - hsync-active: hsync pulse is active low/high/ignored
+ - vsync-active: vsync pulse is active low/high/ignored
+ - de-active: data-enable pulse is active low/high/ignored
+ - pixelclk-active: with
+ - active high = drive pixel data on rising edge/
+ sample data on falling edge
+ - active low = drive pixel data on falling edge/
+ sample data on rising edge
+ - ignored = ignored
+ - interlaced (bool): boolean to enable interlaced mode
+ - doublescan (bool): boolean to enable doublescan mode
+
+All the optional properties that are not bool follow the following logic:
+ <1>: high active
+ <0>: low active
+ omitted: not used on hardware
+
+There are different ways of describing the capabilities of a display. The
+devicetree representation corresponds to the one commonly found in datasheets
+for displays. If a display supports multiple signal timings, the native-mode
+can be specified.
+
+The parameters are defined as:
+
+ +----------+-------------------------------------+----------+-------+
+ | | ↑ | | |
+ | | |vback_porch | | |
+ | | ↓ | | |
+ +----------#######################################----------+-------+
+ | # ↑ # | |
+ | # | # | |
+ | hback # | # hfront | hsync |
+ | porch # | hactive # porch | len |
+ |<-------->#<-------+--------------------------->#<-------->|<----->|
+ | # | # | |
+ | # |vactive # | |
+ | # | # | |
+ | # ↓ # | |
+ +----------#######################################----------+-------+
+ | | ↑ | | |
+ | | |vfront_porch | | |
+ | | ↓ | | |
+ +----------+-------------------------------------+----------+-------+
+ | | ↑ | | |
+ | | |vsync_len | | |
+ | | ↓ | | |
+ +----------+-------------------------------------+----------+-------+
+
+Example:
+
+ display-timings {
+ native-mode = <&timing0>;
+ timing0: 1080p24 {
+ /* 1920x1080p24 */
+ clock-frequency = <52000000>;
+ hactive = <1920>;
+ vactive = <1080>;
+ hfront-porch = <25>;
+ hback-porch = <25>;
+ hsync-len = <25>;
+ vback-porch = <2>;
+ vfront-porch = <2>;
+ vsync-len = <2>;
+ hsync-active = <1>;
+ };
+ };
+
+Every required property also supports the use of ranges, so the commonly used
+datasheet description with minimum, typical and maximum values can be used.
+
+Example:
+
+ timing1: timing {
+ /* 1920x1080p24 */
+ clock-frequency = <148500000>;
+ hactive = <1920>;
+ vactive = <1080>;
+ hsync-len = <0 44 60>;
+ hfront-porch = <80 88 95>;
+ hback-porch = <100 148 160>;
+ vfront-porch = <0 4 6>;
+ vback-porch = <0 36 50>;
+ vsync-len = <0 5 6>;
+ };
diff --git a/drivers/video/Kconfig b/drivers/video/Kconfig
index 2a23b18..c000f5a 100644
--- a/drivers/video/Kconfig
+++ b/drivers/video/Kconfig
@@ -39,6 +39,21 @@ config DISPLAY_TIMING
config VIDEOMODE
bool
+config OF_DISPLAY_TIMING
+ bool "Enable device tree display timing support"
+ depends on OF
+ select DISPLAY_TIMING
+ help
+ helper to parse display timings from the devicetree
+
+config OF_VIDEOMODE
+ bool "Enable device tree videomode support"
+ depends on OF
+ select VIDEOMODE
+ select OF_DISPLAY_TIMING
+ help
+ helper to get videomodes from the devicetree
+
menuconfig FB
tristate "Support for frame buffer devices"
---help---
diff --git a/drivers/video/Makefile b/drivers/video/Makefile
index fc30439..b936b00 100644
--- a/drivers/video/Makefile
+++ b/drivers/video/Makefile
@@ -168,4 +168,6 @@ obj-$(CONFIG_FB_VIRTUAL) += vfb.o
#video output switch sysfs driver
obj-$(CONFIG_VIDEO_OUTPUT_CONTROL) += output.o
obj-$(CONFIG_DISPLAY_TIMING) += display_timing.o
+obj-$(CONFIG_OF_DISPLAY_TIMING) += of_display_timing.o
obj-$(CONFIG_VIDEOMODE) += videomode.o
+obj-$(CONFIG_OF_VIDEOMODE) += of_videomode.o
diff --git a/drivers/video/of_display_timing.c b/drivers/video/of_display_timing.c
new file mode 100644
index 0000000..13ecd98
--- /dev/null
+++ b/drivers/video/of_display_timing.c
@@ -0,0 +1,239 @@
+/*
+ * OF helpers for parsing display timings
+ *
+ * Copyright (c) 2012 Steffen Trumtrar <s.trumtrar@pengutronix.de>, Pengutronix
+ *
+ * based on of_videomode.c by Sascha Hauer <s.hauer@pengutronix.de>
+ *
+ * This file is released under the GPLv2
+ */
+#include <linux/export.h>
+#include <linux/of.h>
+#include <linux/slab.h>
+#include <video/display_timing.h>
+#include <video/of_display_timing.h>
+
+/**
+ * parse_timing_property - parse timing_entry from device_node
+ * @np: device_node with the property
+ * @name: name of the property
+ * @result: will be set to the return value
+ *
+ * DESCRIPTION:
+ * Every display_timing can be specified with either just the typical value or
+ * a range consisting of min/typ/max. This function helps handling this
+ **/
+static int parse_timing_property(struct device_node *np, const char *name,
+ struct timing_entry *result)
+{
+ struct property *prop;
+ int length, cells, ret;
+
+ prop = of_find_property(np, name, &length);
+ if (!prop) {
+ pr_err("%s: could not find property %s\n",
+ of_node_full_name(np), name);
+ return -EINVAL;
+ }
+
+ cells = length / sizeof(u32);
+ if (cells = 1) {
+ ret = of_property_read_u32(np, name, &result->typ);
+ result->min = result->typ;
+ result->max = result->typ;
+ } else if (cells = 3) {
+ ret = of_property_read_u32_array(np, name, &result->min, cells);
+ } else {
+ pr_err("%s: illegal timing specification in %s\n",
+ of_node_full_name(np), name);
+ return -EINVAL;
+ }
+
+ return ret;
+}
+
+/**
+ * of_get_display_timing - parse display_timing entry from device_node
+ * @np: device_node with the properties
+ **/
+static struct display_timing *of_get_display_timing(struct device_node *np)
+{
+ struct display_timing *dt;
+ u32 val = 0;
+ int ret = 0;
+
+ dt = kzalloc(sizeof(*dt), GFP_KERNEL);
+ if (!dt) {
+ pr_err("%s: could not allocate display_timing struct\n",
+ of_node_full_name(np));
+ return NULL;
+ }
+
+ ret |= parse_timing_property(np, "hback-porch", &dt->hback_porch);
+ ret |= parse_timing_property(np, "hfront-porch", &dt->hfront_porch);
+ ret |= parse_timing_property(np, "hactive", &dt->hactive);
+ ret |= parse_timing_property(np, "hsync-len", &dt->hsync_len);
+ ret |= parse_timing_property(np, "vback-porch", &dt->vback_porch);
+ ret |= parse_timing_property(np, "vfront-porch", &dt->vfront_porch);
+ ret |= parse_timing_property(np, "vactive", &dt->vactive);
+ ret |= parse_timing_property(np, "vsync-len", &dt->vsync_len);
+ ret |= parse_timing_property(np, "clock-frequency", &dt->pixelclock);
+
+ dt->dmt_flags = 0;
+ dt->data_flags = 0;
+ if (!of_property_read_u32(np, "vsync-active", &val))
+ dt->dmt_flags |= val ? VESA_DMT_VSYNC_HIGH :
+ VESA_DMT_VSYNC_LOW;
+ if (!of_property_read_u32(np, "hsync-active", &val))
+ dt->dmt_flags |= val ? VESA_DMT_HSYNC_HIGH :
+ VESA_DMT_HSYNC_LOW;
+ if (!of_property_read_u32(np, "de-active", &val))
+ dt->data_flags |= val ? DISPLAY_FLAGS_DE_HIGH :
+ DISPLAY_FLAGS_DE_LOW;
+ if (!of_property_read_u32(np, "pixelclk-active", &val))
+ dt->data_flags |= val ? DISPLAY_FLAGS_PIXDATA_POSEDGE :
+ DISPLAY_FLAGS_PIXDATA_NEGEDGE;
+
+ if (of_property_read_bool(np, "interlaced"))
+ dt->data_flags |= DISPLAY_FLAGS_INTERLACED;
+ if (of_property_read_bool(np, "doublescan"))
+ dt->data_flags |= DISPLAY_FLAGS_DOUBLESCAN;
+
+ if (ret) {
+ pr_err("%s: error reading timing properties\n",
+ of_node_full_name(np));
+ kfree(dt);
+ return NULL;
+ }
+
+ return dt;
+}
+
+/**
+ * of_get_display_timings - parse all display_timing entries from a device_node
+ * @np: device_node with the subnodes
+ **/
+struct display_timings *of_get_display_timings(struct device_node *np)
+{
+ struct device_node *timings_np;
+ struct device_node *entry;
+ struct device_node *native_mode;
+ struct display_timings *disp;
+
+ if (!np) {
+ pr_err("%s: no devicenode given\n", of_node_full_name(np));
+ return NULL;
+ }
+
+ timings_np = of_find_node_by_name(np, "display-timings");
+ if (!timings_np) {
+ pr_err("%s: could not find display-timings node\n",
+ of_node_full_name(np));
+ return NULL;
+ }
+
+ disp = kzalloc(sizeof(*disp), GFP_KERNEL);
+ if (!disp) {
+ pr_err("%s: could not allocate struct disp'\n",
+ of_node_full_name(np));
+ goto dispfail;
+ }
+
+ entry = of_parse_phandle(timings_np, "native-mode", 0);
+ /* assume first child as native mode if none provided */
+ if (!entry)
+ entry = of_get_next_child(np, NULL);
+ /* if there is no child, it is useless to go on */
+ if (!entry) {
+ pr_err("%s: no timing specifications given\n",
+ of_node_full_name(np));
+ goto entryfail;
+ }
+
+ pr_debug("%s: using %s as default timing\n",
+ of_node_full_name(np), entry->name);
+
+ native_mode = entry;
+
+ disp->num_timings = of_get_child_count(timings_np);
+ if (disp->num_timings = 0) {
+ /* should never happen, as entry was already found above */
+ pr_err("%s: no timings specified\n", of_node_full_name(np));
+ goto entryfail;
+ }
+
+ disp->timings = kzalloc(sizeof(struct display_timing *) *
+ disp->num_timings, GFP_KERNEL);
+ if (!disp->timings) {
+ pr_err("%s: could not allocate timings array\n",
+ of_node_full_name(np));
+ goto entryfail;
+ }
+
+ disp->num_timings = 0;
+ disp->native_mode = 0;
+
+ for_each_child_of_node(timings_np, entry) {
+ struct display_timing *dt;
+
+ dt = of_get_display_timing(entry);
+ if (!dt) {
+ /*
+ * to not encourage wrong devicetrees, fail in case of
+ * an error
+ */
+ pr_err("%s: error in timing %d\n",
+ of_node_full_name(np), disp->num_timings + 1);
+ goto timingfail;
+ }
+
+ if (native_mode = entry)
+ disp->native_mode = disp->num_timings;
+
+ disp->timings[disp->num_timings] = dt;
+ disp->num_timings++;
+ }
+ of_node_put(timings_np);
+ /*
+ * native_mode points to the device_node returned by of_parse_phandle
+ * therefore call of_node_put on it
+ */
+ of_node_put(native_mode);
+
+ pr_debug("%s: got %d timings. Using timing #%d as default\n",
+ of_node_full_name(np), disp->num_timings,
+ disp->native_mode + 1);
+
+ return disp;
+
+timingfail:
+ if (native_mode)
+ of_node_put(native_mode);
+ display_timings_release(disp);
+entryfail:
+ kfree(disp);
+dispfail:
+ of_node_put(timings_np);
+ return NULL;
+}
+EXPORT_SYMBOL_GPL(of_get_display_timings);
+
+/**
+ * of_display_timings_exist - check if a display-timings node is provided
+ * @np: device_node with the timing
+ **/
+int of_display_timings_exist(struct device_node *np)
+{
+ struct device_node *timings_np;
+
+ if (!np)
+ return -EINVAL;
+
+ timings_np = of_parse_phandle(np, "display-timings", 0);
+ if (!timings_np)
+ return -EINVAL;
+
+ of_node_put(timings_np);
+ return 1;
+}
+EXPORT_SYMBOL_GPL(of_display_timings_exist);
diff --git a/drivers/video/of_videomode.c b/drivers/video/of_videomode.c
new file mode 100644
index 0000000..5b8066c
--- /dev/null
+++ b/drivers/video/of_videomode.c
@@ -0,0 +1,54 @@
+/*
+ * generic videomode helper
+ *
+ * Copyright (c) 2012 Steffen Trumtrar <s.trumtrar@pengutronix.de>, Pengutronix
+ *
+ * This file is released under the GPLv2
+ */
+#include <linux/errno.h>
+#include <linux/export.h>
+#include <linux/of.h>
+#include <video/display_timing.h>
+#include <video/of_display_timing.h>
+#include <video/of_videomode.h>
+#include <video/videomode.h>
+
+/**
+ * of_get_videomode - get the videomode #<index> from devicetree
+ * @np - devicenode with the display_timings
+ * @vm - set to return value
+ * @index - index into list of display_timings
+ * (Set this to OF_USE_NATIVE_MODE to use whatever mode is
+ * specified as native mode in the DT.)
+ *
+ * DESCRIPTION:
+ * Get a list of all display timings and put the one
+ * specified by index into *vm. This function should only be used, if
+ * only one videomode is to be retrieved. A driver that needs to work
+ * with multiple/all videomodes should work with
+ * of_get_display_timings instead.
+ **/
+int of_get_videomode(struct device_node *np, struct videomode *vm,
+ int index)
+{
+ struct display_timings *disp;
+ int ret;
+
+ disp = of_get_display_timings(np);
+ if (!disp) {
+ pr_err("%s: no timings specified\n", of_node_full_name(np));
+ return -EINVAL;
+ }
+
+ if (index = OF_USE_NATIVE_MODE)
+ index = disp->native_mode;
+
+ ret = videomode_from_timing(disp, vm, index);
+ if (ret)
+ return ret;
+
+ display_timings_release(disp);
+
+ return 0;
+}
+EXPORT_SYMBOL_GPL(of_get_videomode);
diff --git a/include/video/of_display_timing.h b/include/video/of_display_timing.h
new file mode 100644
index 0000000..8016eb7
--- /dev/null
+++ b/include/video/of_display_timing.h
@@ -0,0 +1,20 @@
+/*
+ * Copyright 2012 Steffen Trumtrar <s.trumtrar@pengutronix.de>
+ *
+ * display timings of helpers
+ *
+ * This file is released under the GPLv2
+ */
+
+#ifndef __LINUX_OF_DISPLAY_TIMING_H
+#define __LINUX_OF_DISPLAY_TIMING_H
+
+struct device_node;
+struct display_timings;
+
+#define OF_USE_NATIVE_MODE -1
+
+struct display_timings *of_get_display_timings(struct device_node *np);
+int of_display_timings_exist(struct device_node *np);
+
+#endif
diff --git a/include/video/of_videomode.h b/include/video/of_videomode.h
new file mode 100644
index 0000000..a07efcc
--- /dev/null
+++ b/include/video/of_videomode.h
@@ -0,0 +1,18 @@
+/*
+ * Copyright 2012 Steffen Trumtrar <s.trumtrar@pengutronix.de>
+ *
+ * videomode of-helpers
+ *
+ * This file is released under the GPLv2
+ */
+
+#ifndef __LINUX_OF_VIDEOMODE_H
+#define __LINUX_OF_VIDEOMODE_H
+
+struct device_node;
+struct videomode;
+
+int of_get_videomode(struct device_node *np, struct videomode *vm,
+ int index);
+
+#endif /* __LINUX_OF_VIDEOMODE_H */
--
1.7.10.4
^ permalink raw reply related
page: next (older) | prev (newer) | latest
- recent:[subjects (threaded)|topics (new)|topics (active)]
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox