[Testannounce] Purism Newsletter 2021-03-08

[testannounce at announce.puri.sm]

Purism February 2021 Updates

Librem 5


  OpenPGP in Your Pocket

------------------------------------------------------------------------

Access to the smart card reader on the Librem 5 is something we at
Purism have been /looking forward to
<https://puri.sm/posts/your-own-personal-enclave-the-smart-card-reader-on-the-librem-5/>/
for a long time. That day is finally here; those who have their Librem 5
can follow this guide to set up access to the smart card. Orders
shipping soon will come with the card reader already setup.

Sorry, your client doesn't seem to support embedded videos. View the
video directly here <https://videos.puri.sm/promo/pgp.mp4?_=1>

If you need to set up your smart card reader, these are the steps to
enable it:

|sudo apt install stm32flash git|

Download the scripts:

|git clone https://source.puri.sm/angus.ainslie/ttxs-firmware|

Change working directory to our newly downloaded folder.

|cd ttxs-firmware|

Upgrade the smart card reader firmware:

|./scripts/stm_reflash.sh|

And set up the smart card:

|./scripts/smartcard_setup.sh|

A more detailed version of these steps can be found here
<https://source.puri.sm/angus.ainslie/ttxs-firmware/-/blob/purism/PURISM.md>.
OpenPGP cards are available for purchase in our shop
<https://shop.puri.sm/shop/purism-openpgp-card/>.

Librem 14


  Librem 14 Update: Freed EC, Shipping Beginning in March

In our previous Librem 14 update
<https://puri.sm/posts/librem-14-update-shipping-starts-in-february-with-extended-battery/>,
we described some of the supply chain challenges we (and the rest of the
semiconductor industry) have been facing this year. In particular we
faced challenges with Intel CPU supply and most recently a few week
delay in availability of our 3-cell batteries for the Librem 14. To
expedite shipping, we decided to change the default configuration of the
Librem 14 to give everyone a free upgrade to a larger 4-cell battery
(which covers the second, typically unused M.2 storage slot) and only
fall back to the 3-cell battery in cases where a customer chooses to
populate that second M.2 slot.

Our more aggressive shipping timeline had 4-cell Librem 14s beginning to
ship in February. The Librem 14 will now begin to ship in March.
Evaluation of early manufacturing runs yielded an LCD false-alarm
“ghosting” issue that took some extra time to research and resolve.
When the evaluation step has no issue, manufacturing can stay on the
aggressive timeline, but when there is an issue that needs resolving
manufacturing “stops the presses” until we can confirm things are
accurate before mass production. We added a few weeks in our evaluation
step to confirm the highest quality standard in our products. We expect
to post final product images soon, prior to beginning shipping.


  Freed Embedded Controller

We will likely meet another major product roadmap accomplishment upon
shipping the Librem 14: a fully free software Embedded Controller (EC)
firmware included with all shipments. We have a lofty and ongoing goal
of liberating (by releasing free software source code of) proprietary
low-level firmware as much as possible, and we’ve long had our sights
set on the EC firmware.

We’ve made significant advances on the EC firmware front and are
planning on having the freed EC firmware for the Librem 14 ready before
we begin shipping in a few weeks. We will also release a follow-up post
that dives into some of the technical details behind our EC firmware.


  Thanks

We really appreciate everyone’s support as we navigate an
unprecedented year of supply chain challenges. With all of the
improvements we’ve been able to make to the Librem 14, we know it will
be worth the wait.


  Librem 14: Adding Librem EC, Freed Embedded Controller Firmware

Starting with the Librem 14 laptop we are including fully liberated
Embedded Controller (EC) firmware with all the source code available.
This is something we set as a goal a long time ago, and now we are
finally here. Let’s first start by explaining what the EC is and does.

A PC these days is a pretty complicated thing. It does not only consist
of the main CPU (in this case the Intel Core i7 10710U mobile low
voltage), but also a lot of peripherals. The main CPU is very good at
what it is supposed to do as its main task, running the main operating
system, but it is not so well tuned for lower level things like managing
a keyboard matrix or (and this is quite amazing) powering itself up.

PCs have been around since the 1980s and their hardware design still
shows this legacy. Already in early PCs there was a small helper CPU to
handle the low level dirty work for the big one and this was the
keyboard controller. The keyboard controller was a small microcontroller
on its own running a very small program that helped the power up and
down sequencing as well as managing a bespoke keyboard matrix [1]. Since
then a lot has happened. Over the years as this keyboard controller grew
and was assigned more and more tasks, it developed into the Embedded
Controller.


    Embedded Controller Tasks

With more tasks assigned to the EC, the software and its capabilities
grew which makes it a pretty essential piece these days, especially for
laptops. So the first thing the EC needs to do is to control the power
up and power down of the machine, which means to enable or disable
certain voltage domains, doing that in a controlled fashion honoring
dependencies (often some power rails are derived from others), and also
taking into account the power supply constraints of the main CPU in
certain power modes. This is especially important for low power states
like suspend to RAM where you just want to power what is needed. There
are also other very interesting peripherals attached to the EC. Of
course the EC controls the keyboard matrix, i.e. it assigns keypresses
in that matrix to key scan codes sent to the main CPU.


    Adding Extra Control to the Embedded Controller

There are also devices in the Librem 14 attached to PWMs (Pulse Width
Modulator) which we want to get control over, like the CPU fans! Yes,
there are two of them, we have 6 CPU cores with 12 threads in total.
When running at full load a second heat spreader and fan helps to keep
the CPU at acceptable temperatures, so rather than having one fan
running at full throttle we have two fans running at still reduced
speed. The main CPU communicates with the EC and tells it the CPU
package temperature. The EC then decides based on an algorithm how fast
the fans shall go. But you may not always want it the same way. Say, you
are doing light web surfing at night in your bed and don’t want to
annoy your partner. In that case you may choose to accept a bit warmer
device but therefore silent. Some other time you may want to have the
device as cool as possible, e.g. to prevent your hands from sweating
even more on a warm summer day, but can accept more noise, like in an
office. With the Libre EC we have that choice.

Also the power indicator LED is controlled by the EC. We have three
colors to choose from, orange, green and white. They all share one PWM
for common brightness control and can be turned on and off individually.
The power indicator LED is located just above the F8 key and is mirrored
additionally on the outside next to the power connector so that you can
also see the power state when the LCD lid is closed. How the colors are
used is now up to us! What I am currently implementing is this:

  * white: normal operation
  * green: charging
  * orange: low battery warning
  * steady on: powered up
  * slowly dimming on/off: standby / suspend to RAM

Librem 14 EVT2 HKS

Why green for charging you may ask? Why not orange like everyone else?
Well, actually, because I think it does not make sense. Red or orange
are warning colors, these signal a “not good” state. But charging is
a good state, while low battery warning is a bad state and I wanted to
reserve orange for signaling a bad state. And of course white is neutral
for a normal powered up state. Makes no sense to you? Well, you can
change it, the code is open!


    The Notification LED

With the Librem 14 we also announced and implemented a notification LED,
just above the F7 key. The idea behind that LED is basically the same as
with the LED found in many smartphones. If the display is off or you are
working on another virtual desktop applications can use this LED to
signal something – incoming email or message, system notifications or
whatever! We have implemented this as an RGB LED, all three channels
controlled by a separate 8 bit PWM, so 256x256x256 colors! The userspace
plumbing for this feature in PureOS has already been done for the
Librem5 where we have exactly the same thing, an RGB PWM-controlled
notification LED. I am pretty sure we will see a lot of creative use
cases for these LEDs!


    Battery Control

Another feature that has been requested frequently and which I am
personally also looking forward to is better control over the battery
charger. The EC indeed controls that and with the Libre EC firmware we
now finally can have a say over it! Lithium Ion batteries are pretty
good, they can store a lot of energy compared to their weight and they
can also sustain pretty high current loads. But they are also a bit
picky. They do not like to be deeply discharged, they do not like to be
charged more than they are specified and they also do not like to be
charged too often. So for example trying to charge them to 100% every
time you connect a power supply is not such a brilliant idea for the
overall battery lifetime.

ECs have to make some assumptions here. Keeping it safe and extending
battery lifetime by not charging to 100% all the time will of course
result in less runtime on battery in certain situations which some users
may not appreciate. That’s why most devices by default always charge
to 100% once they reconnect to a power source. The problem is though
that users are often given no choice if they want that or not.

The EC can not know what my use case is, but I do. So I would like to be
able to tell the EC to stop it and do as I wish, eventually accepting
certain shortcomings. Most of the time my laptop runs from the charger
and if I use the battery at all it’s to carry it from one power outlet
to the next or from office to home and back. Knowing that I do not need
a full charge I am totally fine with my battery having 80%, 70% or 60%
(or less), I don’t care. And if I finally reach lower levels like 30%
then I would like it to only recharge to, say, 80%, that’s enough for
my use case and will last me weeks until I reach 30% again. Some other
day I may know that I need to go on a train ride without power outlets,
then I would like to be able to tell the EC to charge to 100% one time.

That’s what we can do now with the Libre EC. The charge controller in
the Librem 14 is connected to the EC via I2C and can be programmed, it
can be enabled and disabled, we can tell it the charging current to
allow for slow charging (better for the battery but takes longer) or
fast charging. And of course we can control the level up to which it
shall charge. This will help to extend the battery lifetime significantly.


    Userspace Control and the Future

The userspace interface for this user control of LEDs, fans, battery
etc. are still a bit in the works. Although we do not have to implement
the full EC code from scratch since we base it on the EC code developed
as free software from System76 [3], it is still a lot of work. The EC
chip used in the Librem 14 was not yet supported, our Librem 14 hardware
design is different in many details and on top we have additional
features that were not reflected by the System76 code. We are working on
adding all of that and will of course make the code public in our own
repository as well as upstreaming as much as we can, we are already in
touch with their maintainer.

And since it is the first time we have liberated EC firmware we also
have quite a steep learning curve. Like I mentioned, PCs are complicated
and so are the EC firmware requirements. But we are working hard on it!
And it is taking shape. A lot is working already, powering up/down,
charger control, PWMs.

We still need to work on main CPU sleep states as well as representation
of user controllable settings into Linux userspace. And we want to do
very thorough testing of all of that before we start shipping product.
The EC is critical, it can brick the device or worse. We will see that
the EC firmware can be recompiled and flashed in the field by
everyone(*). Some of the before-mentioned features will come as a user
serviceable firmware upgrades after shipment of the laptops has started,
for which we will of course provide pre-compiled binaries too.

So stay tuned! This will be fun!

[1] https://en.wikipedia.org/wiki/Keyboard_matrix_circuit
<https://en.wikipedia.org/wiki/Keyboard_matrix_circuit>

[2] https://en.wikipedia.org/wiki/Pulse-width_modulation
<https://en.wikipedia.org/wiki/Pulse-width_modulation>

[3] https://github.com/system76/ec/ <https://github.com/system76/ec/>

(*) a failed EC flash can brick the laptop and only be recovered using
an external flash chip programmer. We can not take responsibility for
bricked devices when flashed with improper EC firmware, unfortunately.
We will of course help to recover from flashing improper firmware, but
eventually need to ask for cost reimbursement (like shipping).


  Purism and Linux 5.11

Following up on our report for Linux 5.9 and 5.10
<https://puri.sm/posts/purism-and-linux-5-9-and-5-10/>, this summarizes
the progress on mainline support for the Librem 5 phone and its
development kit during the 5.11 development cycle.


    Librem 5 and Devkit updates

In order to maintain support for the devkit and the phone, we
continuously update the mainline default configuration:

  * arm64: defconfig: Enable more Librem 5 hardware
    <https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=eecc662ff38b498e1fcd971caec3ce448e711d0e>


    Power management

The mainline solution to dynamically scale internal bus frequencies
relies on the interconnect (and devfreq) framework. We found a small
piece that has been missing for imx8mq:

  * interconnect: imx8mq: Use icc_sync_state
    <https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=67288f74d4837b82ef937170da3389b0779c17be>


    Librem 5 LCD panel

The display panel driver saw some minor updates:

  * dt-binding: display: Require two resets on mantix panel
    <https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=1c902de389ff7cd6495e6a51e04b49ab00fca7d3>
  * drm/panel: mantix: Fix panel reset
    <https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=787099f8671c5cec6cadbb3da3713d97df5c7fd6>
  * drm/panel: mantix: Don’t dereference NULL mode
    <https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=f41b019aa5e05f8172db2e9396b5c2d2602305e2>


    Librem 5 fuel gauge

With the experience with using the phone for the last couple of months,
we could improve the battery fuel gauge driver a bit:

  * power: supply: max17042_battery: Export charge termination current
    property
    <https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=5225371e56c512abe5c5acc271256c2c390903c5>
  * power: supply: max17042_battery: Take r_sns value into account in
    charge_counter
    <https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=6dcfa009f8a96273f074032c888409ee2b26f498>
  * power: supply: max17042_battery: Improve accuracy of current_now and
    current_avg readings
    <https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=9e39ef148777727360dabebacd70d60f3e0edc48>
  * power: supply: max17042_battery: Fix current_avg,now hiding with no
    current sense
    <https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=4b0a56e692503692da6555337a697c17feabbb3e>
  * power: supply: bq25890: Use the correct range for IILIM register
    <https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=d4e9e7b6f7ae37a99bc11ce9efe6e8bdc711362f>


    Librem 5 USB Type-C and PD controller

Our work to make sure we can properly charge the phone and use its
Type-C feature like Displayport resulted in the following additions
during this development period:

  * usb: typec: tps6598x: Export some power supply properties
    <https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=10eb0b6ac63a15b80e4e9ae8b85668827a747350>
  * usb: typec: tps6598x: Select USB_ROLE_SWITCH and REGMAP_I2C
    <https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=ff62d08fd6242a3ef5aa0a7bcae6a0b0136a60ed>


    Other additions and fixes

Equally important are the changes to a regulator device that allow one
to turn off the GPU regulator, to the mxsfb display driver and to the
etnaviv GPU driver. Read the commit messages for more details.

  * regulator: bd718x7: Add enable times
    <https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=3b66e4a8e58a85af3212c7117d7a29c9ef6679a2>
  * drm: mxsfb: Silence -EPROBE_DEFER while waiting for bridge
    <https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=ee46d16d2e40bebc2aa790fd7b6a056466ff895c>
  * drm/etnaviv: Add lockdep annotations for context lock
    <https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=4612bad5701e158f3c40951f2c7aa8e64b3445eb>


    Code review

During these rounds, we contributed
6 /Reviewed-by:/ or /Tested-by:/ tags to patches by other authors. We
would also like to thank everybody who reviewed our patches and helped
us support the hardware in mainline Linux.


    Sources

Have a look at our Linux tree
<https://source.puri.sm/Librem5/linux-next> to see what is currently
being worked on and tested (or help if you feel like joining the fun).


  Charging the Librem 5

When you find yourself low on power, it’s helpful to know how long it
takes to charge your device. This video will go over the expected charge
time of the Librem 5.

Sorry, your client doesn't seem to support embedded videos. View the
video directly here <https://videos.puri.sm/promo/charge_test.mp4?_=1>

As shown in the video, you can get to 80% in about 2 hours and 12
minutes and 100% in just over 4 hours.

A full charge takes about 4 hours and gives you a run time of about 13
hours with the screen and wifi off but data-enabled over 4G. This mobile
configuration is the perfect mode to put your phone in a while you’re
out and about. You’ll still get phone calls, texts, and your
general-purpose computer is available at a moment’s notice.

If you’re in a hurry, just over 2 hours of charging can get you to 80%
yielding around 10.5 hours runtime while configured for mobile.

For now, charging is capped at 1.6 amps. Enabling faster and higher
amperage charging is being worked on now that mass-production batteries
can handle more current; once completed, you can expect your Librem 5 to
charge even faster.


  My First Week of Librem 5 Convergence

I talked at length in my article Investing in Real Convergence
<https://puri.sm/posts/investing-in-real-convergence/> about my
decades-long wish to have a single computer I could carry with me that
had all of my files, ran all of my favorite programs, and that I could
use as a mobile computer, laptop, or desktop. This past week I have
finally realized that dream.

I put away my personal Librem 13v1 and tested out whether I could
replace it with a Librem 5, USB-C hub, and Nexdock 2 laptop dock. I also
spent a couple hours most work days trying it out for work as well
(including writing this article from the Librem 5). In this article I
will talk about my setup, experiences and impressions from the past week.


  The Setup

First let’s talk about the hardware involved.

Librem 5 docked to a Nexdock 2 using a Baseus USB-C hub, running Tootle,
Lollypop, and Firefox

The first thing that is necessary for this setup besides the Librem 5
itself is a laptop dock. From the outside, a laptop dock looks just like
a regular laptop, but it is really only a shell with a display,
keyboard, mouse, internal battery, and a few ports on the side. A laptop
dock has no CPU, RAM, storage or networking of its own and instead is
designed to act like an all-in-one monitor, keyboard and mouse that you
can connect to a phone. The phone then extends onto the display and you
can run your phone’s applications on the larger screen and take
advantage of the physical keyboard and mouse while the dock charges your
phone.

Because the Librem 5 is designed to have Real Convergence
<https://puri.sm/posts/investing-in-real-convergence/>, it runs the same
PureOS applications as Librem laptops. All of its applications were
simply adapted to work well on the smaller display. This means when you
connect the Librem 5 to a laptop dock or monitor, you don’t just get
phone apps blown up two times their size, you get the same desktop
PureOS applications as on Librem laptops.

Sorry, your client doesn't seem to support embedded videos. View the
video directly here
<https://videos.puri.sm/promo/l5-convergence-extra.webm?_=1>

On laptop docks like the recent Nexdock Touch, you can connect the
Librem 5 directly to the dock with a USB-C cable. In the case of the
older Nexdock 2, the support isn’t completed yet so I used the
foolproof method they provide for other computers like Raspberry Pis–a
HDMI port and USB-C port–only in my case I connected them to a
Baseus-branded USB-C hub that is well-supported by the Librem 5.

This hub provided the extra benefit that it kept the Librem 5 upright,
which was particularly important to me since I actually use my laptop on
my lap. To make this work with the dock I simply attached the underside
of the hub to the underside of the laptop dock with a small metal bar
and some removable 3M tape like you’d use to mount pictures to a wall.


  Using Convergence Mode

To use the Librem 5 like a laptop, I just dock it into the USB hub and
press the power button on the laptop dock. The Librem 5 detects the
keyboard, mouse and display and automatically enters “convergence
mode” which extends the desktop to the new display and changes the
windows so that they have close buttons on them and aren’t
automatically maximized, so they can be more easily moved between desktops.

Once in convergence mode you can drag applications over to the larger
screen with a mouse, however there are also already a number of useful
key bindings using the “Super” key (the key between the left Fn and
Alt keys) that make convergence mode very keyboard friendly:

  * Super + (Left|Right): Tile the focused window to the left or right
    side of the active screen
  * Super + Shift + (Left|Right): Move the focused window to the left or
    right display
  * Super + (Up|Down): Maximize or unmaximize the focused window
  * Super + a: Open the App Launcher, where you can type in the name of
    the application to launch, or select it with arrow keys
  * Super + s: Open the App Switcher (similar to hitting the bottom
    section of the touchscreen on the phone). This allows you to switch
    between running applications using the arrow keys

While in convergence mode, the dock is keeping the phone charged. I
found the Nexdock 2 could run for about two to three hours of steady use
unplugged while powering its own display, the hub, and charging the
Librem 5. It lasted longer if I closed the display when I wasn’t using
it. Since the laptop dock is powered via its own USB-C port you could
extend this time with a large battery bank if you didn’t have access
to an outlet. Since I normally use my laptop from the same place every
day, I tend to leave it plugged in anyway.

When I’m done using the Librem 5 like a laptop, I just remove it from
the hub and it automatically leaves convergence mode. All of the running
applications move back to the phone screen and resize and maximize to
fit. The laptop dock automatically powers itself down.


  My Experience

I don’t do video editing or other heavy tasks on my laptop and for the
most part my needs are pretty simple: web browsing, chatting, email,
writing, listening to audio and watching video. In many ways even before
this experiment my Librem 5 had already replaced my personal laptop. It
had already become the primary computer I used for podcasts and videos
(using gPodder and VLC), as well as for social media and light web
browsing. That said, I still found myself opening my laptop in the past
whenever I needed to type more than a few sentences in chat, an email,
or a document. I also found it a bit more convenient to do heavier web
browsing (like when researching something across multiple tabs) on a
larger display.

Given my relatively simple use case for my personal laptop, I had high
hopes that the Librem 5 could replace it and *the Librem 5 didn’t
disappoint*. In fact, what I found was that the addition of a laptop
dock made the functions I had already moved over to the Librem 5 even
more useful. With a large screen, I could more easily multitask, such as
chat in one window while a video was playing in VLC tiled to the side of
the large screen. The addition of a physical keyboard also made chat,
email, and overall writing much more convenient.

I found that I preferred the multi-monitor setup that convergence mode
defaults to and use both screens at the same time. I leave certain
applications like my social media applications or gPodder on the phone
screen. Then terminals, email, web browsers, chat applications, and
video playback would be on the laptop screen with windows tiled either
to the left or right-hand side.

Since the phone is close to my left hand, I found I use the phone touch
screen to interact with applications there instead of the mouse. It’s
convenient to reach over and scroll through new social media posts on
the phone screen instead of moving the mouse over. The fact that the
Nexdock touchpad defaults to multi-finger scroll that moves in the
opposite direction of the Librem 13 touchpad took a lot of getting used to.

I tend to be keyboard-centric on my regular laptop and this is no
different on this setup. I made heavy use of the existing keybindings
along with alt-tab to switch between and manage windows. After a short
amount of time I got used to hitting Super-a, typing the name of an
application, and hitting Enter, then hitting Super-Shift-Right or Left
depending on which screen I wanted it on. I find the keyboard to have
good tactile feedback and while it’s no Model M keyboard (but /sigh/,
what is?) it’s pleasant to type on and better than some island
keyboards I’ve tried.


  My Impressions

*The Librem 5 can definitely replace my personal laptop* and I’ve
already transferred any remaining files from my laptop over to it,
powered down my laptop, and put it away. My laptop has a faster CPU and
more RAM, so I expected when I used the Librem 5 like a laptop I might
more readily see any performance differences it might have compared to
using it like a phone.

I have to say, though, that this Librem 5 surprised me in how well in
performs, in particular how well it works when multi-tasking between
applications. Web browsing works surprisingly well, and although I do
typically keep Firefox in “mobile mode” so I get lighter weight
websites designed for a mobile browser, I actually prefer that mode on
the larger screen as it often results in cleaner, simpler web pages.

While it’s still early days for phosh acting as a full desktop shell,
it already works quite well in that mode. While it’s not as full
featured as the default GNOME shell on the desktop, many of the basic
important features are already there (since they are already there when
in phone mode) and work as you might expect on the larger screen. As
more of us use the Librem 5 in convergence mode now, we are seeing rapid
advances for the desktop use case.

My hacky USB hub mount works surprisingly well and is strong enough to
hold up the weight of the phone while the laptop dock is on my lap, but
I also make a point not to put too much extra pressure on it, just in
case. While I’ve seen other mounting options that attach a phone to
the screen, I find I like having the phone’s touchscreen within a
closer reach.

One area that’s a bit less convenient is the extra step of having to
dock the Librem 5, open the laptop dock lid, and power it on to switch
to “laptop mode” compared to just opening the lid of a suspended
laptop. It’s a minor inconvenience though, since I just use the Librem
5 in “phone mode” for quick tasks anyway–if I’m breaking out the
laptop it’s for a longer session. For people who would use the phone
in “desktop mode” connected to a monitor and keyboard/mouse, it
wouldn’t be any less convenient than docking their laptop into a
docking station.


    Using the Librem 5 for Work

Something that surprised me even more was how well the Librem 5
performed to replace my work laptop. My work use case is a bit more
complicated than my personal one, mostly due to the security
requirements. Otherwise for the most part my primary work tasks involve
email, chat, and web-based tools, along with some writing and light
development work from time to time.

I should note that my work laptop is a Librem 13v4 with twice the RAM of
my personal laptop because I make heavy use of Qubes and its
compartmentation features on my work laptop to provide me extra
security. I separate chat, web browsing, email, and other functions into
separate VMs that can’t directly talk to each other. I also make heavy
use of disposable VMs whenever I have to open a potentially risky
document or website. Because of those extra compartmentation features
Qubes provides, I don’t know that the Librem 5 could replace my work
laptop, yet, but wow is it /close/.

Now that the OpenPGP smart card reader is supported
<https://puri.sm/posts/openpgp-in-your-pocket/>, I copied my Purism GPG
subkeys over to a new smart card and migrated my email settings over to
the Librem 5 along with my password manager database for work. I also
set up a new compartmentalized web browser with its own profile and
settings that I used only for work.

Email works just like it did on my work laptop. Web browsing and web
tools also work reasonably well. Chat is probably the main area that,
today at least, still needs a bit of work to replace my work laptop, due
to the fact that Matrix with e2ee support is still under heavy
development. I’m actually trying out an experimental branch of Chatty
that contains support for encrypted Matrix chat, but it’s not quite
ready to replace a traditional client.

My conclusion for work is that the Librem 5 as it is today would at
least be able to replace the need to take my work laptop with me when
traveling. Fully replacing my work laptop would probably need to wait
until we make further advancements in flatpak sandboxing using
bubblewrap, so I have some of the protections I’ve gotten used to in
Qubes that give me extra peace of mind.


  Welcome to the Future

Using a phone that has real convergence like the Librem 5 is a complete
game changer. It feels like I’m getting a sneak preview into the
future of personal computing. In many ways it’s hard to explain what
it’s like, you kind of have to see it yourself to understand why this
is so groundbreaking. Having all of the same desktop applications and
all of my files with me in my pocket, and having those same running
applications morph to a larger screen automatically, changes how you
think about phones and their potential.

Calling the Librem 5 a phone doesn’t do it service. It’s really a
mobile computer, a desktop in your pocket. Using it like a laptop or
desktop computer really opens your eyes to all of the possibilities, and
underscores to me all of the things I’ve been missing with other phones.


  Disassemble Librem 5

The Librem 5 is designed for longevity with software updates for life,
but part of longevity is also being able to repair a device outside of
warranty. We plan to stock replacement parts in our shop in case you
need to replace your modem, camera, or even the main PCB.

Disassembling your Librem 5 may risk damaging it. Any damage from
disassembly is not covered in your warranty. If your Librem 5 is under
warranty, please contact support first before you attempt this process.

Sorry, your client doesn't seem to support embedded videos. View the
video directly here <https://videos.puri.sm/promo/disassemble_1080.mp4?_=1>

As outlined in the above video, this blog will go over the steps to take
apart the Librem 5. You’ll need a screwdriver; the included sim card
tool and something like a pick or spudger.

Make sure to power down PureOS.

Pull off the back cover.

Remove the battery.

Remove 3 screws holding the modem cover. These are shorter than the rest
of the screws, so keep them separate.

Remove the sim card tray.

If you have a smart card installed, remove it now.

Disconnect the antennas and remove the modems.

Remove 8 screws holding the back frame on.

There are friction clips around the outside; a guitar pick slid around
the outside edge will free these.

Carefully pull the antenna cables from the plastic frame. Pulling too
hard will disconnect them from the PCB.

Remove the 2 screws holding down the center frame.

Unplug the main camera and remove the screw hidden by FPC.

The Center frame can be pried out now. There are 2 friction clips at the
top left and right of the frame. Use a spudger if you have one.

Remove PCB screws. The 3 at the top connect the antennas, so do not
forget to put them back on reassembly.

Liftoff the microphone cover; otherwise, it will fall off, and you may
lose it.

Gently pull the HKS alignment up and out.

Remove the 3 HKS switches.

Unplug the Power/Volume FPC.

When removing the PCB be careful of the spring clip against the frame.
That is part of the GNSS antenna, so you will not have GPS if it breaks off.

Lift the PCB out until you can see the Display and USB-C FPC cables.

There is a cover over the proximity sensor that is easy to lose; put it
in a safe place. If you re-assemble without this cover, the proximity
sensor triggers automatically, and it will need to be disabled.

Carefully disconnect the USB C and Display FPC cables.

After unplugging the last two FPC cables, you can altogether remove the
Librem 5 PCB.

Putting the Librem 5 back together is just a matter of doing the steps
in reverse. If the thermal paste looks good, you can begin by
reattaching the PCB to the FPC cables and adding back the proximity
sensor cover.

While most people would never need to take their phone apart, and many
phones make it almost impossible, if you (or a technician) ever do need
to repair a Librem 5 down the road, the Librem 5 has you covered. It is
a phone designed for longevity with a battery, modem and WiFi card that
are easily user-replaceable and with the remaining components also
replaceable with a bit more effort.


  Librem 5 News Summary: February 2021

February was a month of strong and steady progress behind the scenes
from operational improvements to a lot more code written and released.
Each week we ship an increasing number of Librem 5s out to backers. We
also continue to work to locate and expedite more i.MX 8M CPU supply for
future Librem 5s—the industry has an overall shortage of
components—and as we get firm dates for those secured CPU supplies we
intend on sending out shipping estimates to Librem 5 backers.

We have also made progress on the Librem 5 hardware support side. Last
month we announced we had finished support for the OpenPGP smart card
reader and this month we released a blog post and video
<https://puri.sm/posts/openpgp-in-your-pocket/> that describes how to
enable it on existing Librem 5s. We have also made a lot of advancements
on camera support and have successfully taken some initial pictures.
There is still more work to do to complete the camera driver and get the
most out of the camera hardware and we hope to have more announcements
on that front soon.

Speaking of the kernel we also published a post that describes in detail
the work we have done in the 5.11 kernel
<https://puri.sm/posts/purism-and-linux-5-11/> including progress on
mainline support for the Librem 5 as well as improvements in power
management and overall support for the Librem 5 hardware.

On the Librem 5 USA front, it has taken much longer than we have
expected to locate and secure new supply chains for all of the
components we will need to start production of the PCBA due to some of
the unprecedented issues in the electronics supply chain over the last
year. We are happy to announce that we have tracked down almost every
component now and are optimistic we can track down the one or two
remaining components soon so that we can start production on the PCBA in
the coming month. The Librem 5 USA will be manufactured at our facility
in the US with our secure supply chain and Made in USA Electronics.


  What's Next

March is proving already to be an exciting and busy month for the Librem
5 and we anticipate much of the steady progress from February is going
to culminate in big announcements in March. Check out our blog
<https://puri.sm/posts/> for more frequent updates and to see what
we’ve already been up to the first week of March.

Purism

Thanking you for your support,
— the Purism team (feedback at puri.sm)

------------------------------------------------------------------------

Note: contents of this email are CC-by-SA; feel free to forward it to
friends!

/To remove yourself from our announcements list, simply email
announce-leave at announce.puri.sm <mailto:announce-leave at announce.puri.sm>
and you will automatically be instructed how to unsubscribe./

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://announce.puri.sm/pipermail/testannounce/attachments/20210308/a6cd5be7/attachment-0001.html>