nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
/***************************************************************************
|
|
|
|
|
* __________ __ ___.
|
|
|
|
|
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
|
|
|
|
|
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
|
|
|
|
|
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
|
|
|
|
|
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
|
|
|
|
|
* \/ \/ \/ \/ \/
|
|
|
|
|
*
|
|
|
|
|
* Copyright (C) 2016 Amaury Pouly
|
|
|
|
|
*
|
|
|
|
|
* 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 License, or (at your option) any later version.
|
|
|
|
|
*
|
|
|
|
|
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
|
|
|
|
|
* KIND, either express or implied.
|
|
|
|
|
*
|
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
|
|
/** /!\ This file was automatically generated, DO NOT MODIFY IT DIRECTLY /!\ */
|
|
|
|
|
|
|
|
|
|
#include "nwz_db.h"
|
|
|
|
|
|
|
|
|
|
struct nwz_model_info_t nwz_model[NWZ_MODEL_COUNT] =
|
|
|
|
|
{
|
|
|
|
|
{ 0x10000, "NWZ-A815" },
|
|
|
|
|
{ 0x10001, "NWZ-A816" },
|
|
|
|
|
{ 0x10002, "NWZ-A818" },
|
|
|
|
|
{ 0x1000000, "NW-S615F" },
|
|
|
|
|
{ 0x1000001, "NW-S616F" },
|
|
|
|
|
{ 0x1010000, "NW-S715F" },
|
|
|
|
|
{ 0x1010001, "NW-S716F" },
|
|
|
|
|
{ 0x1010002, "NW-S718F" },
|
|
|
|
|
{ 0x1020000, "NWZ-S615F" },
|
|
|
|
|
{ 0x1020001, "NWZ-S616F" },
|
|
|
|
|
{ 0x1020002, "NWZ-S618F" },
|
|
|
|
|
{ 0x1030000, "NWZ-S515" },
|
|
|
|
|
{ 0x1030001, "NWZ-S516" },
|
|
|
|
|
{ 0x1040000, "NWZ-S715F" },
|
|
|
|
|
{ 0x1040001, "NWZ-S716F" },
|
|
|
|
|
{ 0x1040002, "NWZ-S718F" },
|
|
|
|
|
{ 0x2000001, "NW-A916" },
|
|
|
|
|
{ 0x2000002, "NW-A918" },
|
|
|
|
|
{ 0x2000004, "NW-A919" },
|
|
|
|
|
{ 0x3000001, "NWZ-A826" },
|
|
|
|
|
{ 0x3000002, "NWZ-A828" },
|
|
|
|
|
{ 0x3000004, "NWZ-A829" },
|
|
|
|
|
{ 0x3010001, "NW-A826" },
|
|
|
|
|
{ 0x3010002, "NW-A828" },
|
|
|
|
|
{ 0x3010004, "NW-A829" },
|
|
|
|
|
{ 0x3020001, "NWZ-A726B" },
|
|
|
|
|
{ 0x3020002, "NWZ-A728B" },
|
|
|
|
|
{ 0x3020004, "NWZ-A729B" },
|
|
|
|
|
{ 0x3030001, "NWZ-A726" },
|
|
|
|
|
{ 0x3030002, "NWZ-A728" },
|
|
|
|
|
{ 0x3030004, "NWZ-A729" },
|
|
|
|
|
{ 0x4000001, "NW-S636F" },
|
|
|
|
|
{ 0x4000002, "NW-S638F" },
|
|
|
|
|
{ 0x4000004, "NW-S639F" },
|
|
|
|
|
{ 0x4010001, "NW-S736F" },
|
|
|
|
|
{ 0x4010002, "NW-S738F" },
|
|
|
|
|
{ 0x4010004, "NW-S739F" },
|
|
|
|
|
{ 0x4020001, "NWZ-S636F" },
|
|
|
|
|
{ 0x4020002, "NWZ-S638F" },
|
|
|
|
|
{ 0x4020004, "NWZ-S639F" },
|
|
|
|
|
{ 0x4030001, "NWZ-S736F" },
|
|
|
|
|
{ 0x4030002, "NWZ-S738F" },
|
|
|
|
|
{ 0x4030004, "NWZ-S739F" },
|
|
|
|
|
{ 0x5000002, "NW-X1040" },
|
|
|
|
|
{ 0x5000004, "NW-X1050" },
|
|
|
|
|
{ 0x5000005, "NW-X1060" },
|
|
|
|
|
{ 0x5010002, "NWZ-NONAME" },
|
|
|
|
|
{ 0x5010004, "NWZ-NONAME" },
|
|
|
|
|
{ 0x5010005, "NWZ-NONAME" },
|
|
|
|
|
{ 0x5020002, "NWZ-X1040" },
|
|
|
|
|
{ 0x5020004, "NWZ-X1050" },
|
|
|
|
|
{ 0x5020005, "NWZ-X1060" },
|
|
|
|
|
{ 0x5040002, "NWZ-X1041" },
|
|
|
|
|
{ 0x5040004, "NWZ-X1051" },
|
|
|
|
|
{ 0x5040005, "NWZ-X1061" },
|
|
|
|
|
{ 0x6010002, "NW-S644" },
|
|
|
|
|
{ 0x6010004, "NW-S645" },
|
|
|
|
|
{ 0x6010005, "NW-S646" },
|
|
|
|
|
{ 0x6020002, "NWZ-S744" },
|
|
|
|
|
{ 0x6020004, "NWZ-S745" },
|
|
|
|
|
{ 0x6020005, "NWZ-S746" },
|
|
|
|
|
{ 0x6030002, "NW-S744" },
|
|
|
|
|
{ 0x6030004, "NW-S745" },
|
|
|
|
|
{ 0x6030005, "NW-S746" },
|
|
|
|
|
{ 0x7000004, "NWZ-A845" },
|
|
|
|
|
{ 0x7000005, "NWZ-A846" },
|
|
|
|
|
{ 0x7000006, "NWZ-A847" },
|
|
|
|
|
{ 0x7010004, "NW-A845" },
|
|
|
|
|
{ 0x7010005, "NW-A846" },
|
|
|
|
|
{ 0x7010006, "NW-A847" },
|
|
|
|
|
{ 0x8000000, "NW-E052" },
|
|
|
|
|
{ 0x8000001, "NW-E053" },
|
|
|
|
|
{ 0x8000002, "NW-E054" },
|
|
|
|
|
{ 0x9000002, "NW-S754" },
|
|
|
|
|
{ 0x9000004, "NW-S755" },
|
|
|
|
|
{ 0x9000005, "NW-S756" },
|
|
|
|
|
{ 0xb000001, "NWZ-E453" },
|
|
|
|
|
{ 0xb000002, "NWZ-E454" },
|
|
|
|
|
{ 0xb000004, "NWZ-E455" },
|
|
|
|
|
{ 0xc000001, "NWZ-E353" },
|
|
|
|
|
{ 0xc000002, "NWZ-E354" },
|
|
|
|
|
{ 0xc000004, "NWZ-E355" },
|
|
|
|
|
{ 0xd000001, "NWZ-E553" },
|
|
|
|
|
{ 0xd000002, "NWZ-E554" },
|
|
|
|
|
{ 0xd000004, "NWZ-E555" },
|
|
|
|
|
{ 0xd000005, "NWZ-E556" },
|
|
|
|
|
{ 0xe000004, "NWZ-A855" },
|
|
|
|
|
{ 0xe000005, "NWZ-A856" },
|
|
|
|
|
{ 0xe000006, "NWZ-A857" },
|
|
|
|
|
{ 0xf000002, "NWZ-S754" },
|
|
|
|
|
{ 0xf000004, "NWZ-S755" },
|
|
|
|
|
{ 0x10000000, "NWZ-E052" },
|
|
|
|
|
{ 0x10000001, "NWZ-E053" },
|
|
|
|
|
{ 0x11000001, "NW-A863" },
|
|
|
|
|
{ 0x11000002, "NW-A864" },
|
|
|
|
|
{ 0x11000004, "NW-A865" },
|
|
|
|
|
{ 0x11000005, "NW-A866" },
|
|
|
|
|
{ 0x11000006, "NW-A867" },
|
|
|
|
|
{ 0x11010001, "NWZ-A863" },
|
|
|
|
|
{ 0x11010002, "NWZ-A864" },
|
|
|
|
|
{ 0x11010004, "NWZ-A865" },
|
|
|
|
|
{ 0x11010005, "NWZ-A866" },
|
|
|
|
|
{ 0x11010006, "NWZ-A867" },
|
|
|
|
|
{ 0x11020001, "NWZ-A863" },
|
|
|
|
|
{ 0x11020002, "NWZ-A864" },
|
|
|
|
|
{ 0x11020004, "NWZ-A865" },
|
|
|
|
|
{ 0x11020005, "NWZ-A866" },
|
|
|
|
|
{ 0x11020006, "NWZ-A867" },
|
|
|
|
|
{ 0x12000001, "NW-S763" },
|
|
|
|
|
{ 0x12000002, "NW-S764" },
|
|
|
|
|
{ 0x12000004, "NW-S765" },
|
|
|
|
|
{ 0x12000005, "NW-S766" },
|
|
|
|
|
{ 0x12000006, "NW-S767" },
|
|
|
|
|
{ 0x12010001, "NWZ-S763" },
|
|
|
|
|
{ 0x12010002, "NWZ-S764" },
|
|
|
|
|
{ 0x12010004, "NWZ-S765" },
|
|
|
|
|
{ 0x12010005, "NWZ-S766" },
|
|
|
|
|
{ 0x12010006, "NWZ-S767" },
|
|
|
|
|
{ 0x13000001, "NWZ-E463" },
|
|
|
|
|
{ 0x13000002, "NWZ-E464" },
|
|
|
|
|
{ 0x13000004, "NWZ-E465" },
|
|
|
|
|
{ 0x14000000, "NW-E062" },
|
|
|
|
|
{ 0x14000001, "NW-E063" },
|
|
|
|
|
{ 0x14000002, "NW-E064" },
|
|
|
|
|
{ 0x14000004, "NW-E065" },
|
|
|
|
|
{ 0x14000005, "NW-E066" },
|
|
|
|
|
{ 0x15000001, "NWZ-E473" },
|
|
|
|
|
{ 0x15000002, "NWZ-E474" },
|
|
|
|
|
{ 0x15000004, "NWZ-E475" },
|
|
|
|
|
{ 0x15000005, "NWZ-E476" },
|
|
|
|
|
{ 0x15010001, "NWZ-E573" },
|
|
|
|
|
{ 0x15010002, "NWZ-E574" },
|
|
|
|
|
{ 0x15010004, "NWZ-E575" },
|
|
|
|
|
{ 0x15010005, "NWZ-E576" },
|
|
|
|
|
{ 0x16000001, "NW-S773" },
|
|
|
|
|
{ 0x16000002, "NW-S774" },
|
|
|
|
|
{ 0x16000004, "NW-S775" },
|
|
|
|
|
{ 0x16000005, "NW-S776" },
|
|
|
|
|
{ 0x16010001, "NWZ-S773" },
|
|
|
|
|
{ 0x16010002, "NWZ-S774" },
|
|
|
|
|
{ 0x16010004, "NWZ-S775" },
|
|
|
|
|
{ 0x16010005, "NWZ-S776" },
|
|
|
|
|
{ 0x19000001, "NW-S783" },
|
|
|
|
|
{ 0x19000002, "NW-S784" },
|
|
|
|
|
{ 0x19000004, "NW-S785" },
|
|
|
|
|
{ 0x19000005, "NW-S786" },
|
|
|
|
|
{ 0x19010001, "NW-E083" },
|
|
|
|
|
{ 0x19010002, "NW-E084" },
|
|
|
|
|
{ 0x19010004, "NW-E085" },
|
|
|
|
|
{ 0x19010005, "NW-E086" },
|
|
|
|
|
{ 0x19020001, "NWZ-E583" },
|
|
|
|
|
{ 0x19020002, "NWZ-E584" },
|
|
|
|
|
{ 0x19020004, "NWZ-E585" },
|
|
|
|
|
{ 0x19020005, "NWZ-E586" },
|
|
|
|
|
{ 0x1a000001, "NW-A13" },
|
|
|
|
|
{ 0x1a000002, "NW-A14" },
|
|
|
|
|
{ 0x1a000004, "NW-A15" },
|
|
|
|
|
{ 0x1a000005, "NW-A16" },
|
|
|
|
|
{ 0x1a000006, "NW-A17" },
|
|
|
|
|
{ 0x1a010001, "NWZ-A13" },
|
|
|
|
|
{ 0x1a010002, "NWZ-A14" },
|
|
|
|
|
{ 0x1a010004, "NWZ-A15" },
|
|
|
|
|
{ 0x1a010005, "NWZ-A16" },
|
|
|
|
|
{ 0x1a010006, "NWZ-A17" },
|
|
|
|
|
{ 0x1b000001, "NW-S13" },
|
|
|
|
|
{ 0x1b000002, "NW-S14" },
|
|
|
|
|
{ 0x1b000004, "NW-S15" },
|
|
|
|
|
{ 0x1b000005, "NW-S16" },
|
|
|
|
|
{ 0x1b000006, "NW-S17" },
|
|
|
|
|
{ 0x1c000001, "NW-ZX103" },
|
|
|
|
|
{ 0x1c000002, "NW-ZX104" },
|
|
|
|
|
{ 0x1c000004, "NW-ZX105" },
|
|
|
|
|
{ 0x1c000005, "NW-ZX106" },
|
|
|
|
|
{ 0x1c000006, "NW-ZX107" },
|
|
|
|
|
{ 0x1c000007, "NW-ZX100" },
|
|
|
|
|
{ 0x1d000001, "NW-A23" },
|
|
|
|
|
{ 0x1d000002, "NW-A24" },
|
|
|
|
|
{ 0x1d000004, "NW-A25" },
|
|
|
|
|
{ 0x1d000005, "NW-A26" },
|
|
|
|
|
{ 0x1d000006, "NW-A27" },
|
|
|
|
|
{ 0x1d000007, "NW-A28" },
|
2017-01-07 16:32:47 +00:00
|
|
|
{ 0x20000007, "NW-WM1A" },
|
|
|
|
|
{ 0x21000008, "NW-WM1Z" },
|
2017-01-08 11:30:46 +00:00
|
|
|
{ 0x22000004, "NW-A35" },
|
nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static int nvp_index_0ac81d[NWZ_NVP_COUNT] =
|
|
|
|
|
{
|
|
|
|
|
[NWZ_NVP_APD] = 78,
|
|
|
|
|
[NWZ_NVP_APP] = 5,
|
|
|
|
|
[NWZ_NVP_BFD] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_BFP] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_BLF] = 79,
|
|
|
|
|
[NWZ_NVP_BML] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_BOK] = 10,
|
|
|
|
|
[NWZ_NVP_BPR] = 35,
|
|
|
|
|
[NWZ_NVP_BTC] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_BTI] = 1,
|
|
|
|
|
[NWZ_NVP_CLV] = 68,
|
|
|
|
|
[NWZ_NVP_CNG] = 3,
|
|
|
|
|
[NWZ_NVP_CTR] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_DBA] = 12,
|
|
|
|
|
[NWZ_NVP_DBG] = 0,
|
|
|
|
|
[NWZ_NVP_DBI] = NWZ_NVP_INVALID,
|
2017-04-03 13:13:46 +00:00
|
|
|
[NWZ_NVP_DBS] = NWZ_NVP_INVALID,
|
nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
[NWZ_NVP_DBV] = 13,
|
|
|
|
|
[NWZ_NVP_DCC] = 7,
|
2017-04-03 13:13:46 +00:00
|
|
|
[NWZ_NVP_DG0] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_DG1] = NWZ_NVP_INVALID,
|
nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
[NWZ_NVP_DOR] = 21,
|
|
|
|
|
[NWZ_NVP_E00] = 36,
|
|
|
|
|
[NWZ_NVP_E01] = 37,
|
|
|
|
|
[NWZ_NVP_E02] = 38,
|
|
|
|
|
[NWZ_NVP_E03] = 39,
|
|
|
|
|
[NWZ_NVP_E04] = 40,
|
|
|
|
|
[NWZ_NVP_E05] = 41,
|
|
|
|
|
[NWZ_NVP_E06] = 42,
|
|
|
|
|
[NWZ_NVP_E07] = 43,
|
|
|
|
|
[NWZ_NVP_E08] = 44,
|
|
|
|
|
[NWZ_NVP_E09] = 45,
|
|
|
|
|
[NWZ_NVP_E10] = 46,
|
|
|
|
|
[NWZ_NVP_E11] = 47,
|
|
|
|
|
[NWZ_NVP_E12] = 48,
|
|
|
|
|
[NWZ_NVP_E13] = 49,
|
|
|
|
|
[NWZ_NVP_E14] = 50,
|
|
|
|
|
[NWZ_NVP_E15] = 51,
|
|
|
|
|
[NWZ_NVP_E16] = 52,
|
|
|
|
|
[NWZ_NVP_E17] = 53,
|
|
|
|
|
[NWZ_NVP_E18] = 54,
|
|
|
|
|
[NWZ_NVP_E19] = 55,
|
|
|
|
|
[NWZ_NVP_E20] = 56,
|
|
|
|
|
[NWZ_NVP_E21] = 57,
|
|
|
|
|
[NWZ_NVP_E22] = 58,
|
|
|
|
|
[NWZ_NVP_E23] = 59,
|
|
|
|
|
[NWZ_NVP_E24] = 60,
|
|
|
|
|
[NWZ_NVP_E25] = 61,
|
|
|
|
|
[NWZ_NVP_E26] = 62,
|
|
|
|
|
[NWZ_NVP_E27] = 63,
|
|
|
|
|
[NWZ_NVP_E28] = 64,
|
|
|
|
|
[NWZ_NVP_E29] = 65,
|
|
|
|
|
[NWZ_NVP_E30] = 66,
|
|
|
|
|
[NWZ_NVP_E31] = 67,
|
|
|
|
|
[NWZ_NVP_EDW] = 22,
|
2017-04-03 13:13:46 +00:00
|
|
|
[NWZ_NVP_EP0] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_EP1] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_EP2] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_EP3] = NWZ_NVP_INVALID,
|
nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
[NWZ_NVP_ERI] = 6,
|
|
|
|
|
[NWZ_NVP_EXM] = 25,
|
|
|
|
|
[NWZ_NVP_FMP] = 82,
|
|
|
|
|
[NWZ_NVP_FNI] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_FPI] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_FUI] = 19,
|
|
|
|
|
[NWZ_NVP_FUP] = 9,
|
|
|
|
|
[NWZ_NVP_FUR] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_FVI] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_GTY] = 18,
|
|
|
|
|
[NWZ_NVP_HDI] = 2,
|
|
|
|
|
[NWZ_NVP_HLD] = 80,
|
|
|
|
|
[NWZ_NVP_INS] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_IPT] = 70,
|
|
|
|
|
[NWZ_NVP_KAS] = 32,
|
|
|
|
|
[NWZ_NVP_LBI] = 20,
|
|
|
|
|
[NWZ_NVP_LYR] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_MAC] = 77,
|
|
|
|
|
[NWZ_NVP_MCR] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_MDK] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_MDL] = 8,
|
|
|
|
|
[NWZ_NVP_MID] = 16,
|
|
|
|
|
[NWZ_NVP_MLK] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_MSC] = 84,
|
|
|
|
|
[NWZ_NVP_MSO] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_MTM] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_MUK] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_NCP] = 31,
|
|
|
|
|
[NWZ_NVP_NVR] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_PCD] = 26,
|
|
|
|
|
[NWZ_NVP_PCI] = NWZ_NVP_INVALID,
|
2017-04-03 13:13:46 +00:00
|
|
|
[NWZ_NVP_PNC] = NWZ_NVP_INVALID,
|
nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
[NWZ_NVP_PRK] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_PSK] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_PTS] = 75,
|
|
|
|
|
[NWZ_NVP_RBT] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_RND] = 28,
|
|
|
|
|
[NWZ_NVP_RTC] = 34,
|
|
|
|
|
[NWZ_NVP_SDC] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_SDP] = 30,
|
|
|
|
|
[NWZ_NVP_SER] = 4,
|
|
|
|
|
[NWZ_NVP_SFI] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_SHE] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_SHP] = 11,
|
|
|
|
|
[NWZ_NVP_SID] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_SKD] = 81,
|
|
|
|
|
[NWZ_NVP_SKT] = 76,
|
|
|
|
|
[NWZ_NVP_SKU] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_SLP] = 69,
|
|
|
|
|
[NWZ_NVP_SPS] = 83,
|
|
|
|
|
[NWZ_NVP_SYI] = 24,
|
|
|
|
|
[NWZ_NVP_TR0] = 14,
|
|
|
|
|
[NWZ_NVP_TR1] = 15,
|
|
|
|
|
[NWZ_NVP_TST] = 17,
|
|
|
|
|
[NWZ_NVP_UBP] = 23,
|
|
|
|
|
[NWZ_NVP_UFN] = 29,
|
|
|
|
|
[NWZ_NVP_UMS] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_UPS] = NWZ_NVP_INVALID,
|
2017-04-03 13:13:46 +00:00
|
|
|
[NWZ_NVP_VAR] = NWZ_NVP_INVALID,
|
nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
[NWZ_NVP_VRT] = NWZ_NVP_INVALID,
|
|
|
|
|
};
|
|
|
|
|
|
2017-01-04 15:30:30 +00:00
|
|
|
static int nvp_index_28dc2c[NWZ_NVP_COUNT] =
|
nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
{
|
|
|
|
|
[NWZ_NVP_APD] = 78,
|
2017-01-04 15:30:30 +00:00
|
|
|
[NWZ_NVP_APP] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_BFD] = 21,
|
|
|
|
|
[NWZ_NVP_BFP] = 20,
|
nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
[NWZ_NVP_BLF] = 79,
|
2017-01-04 15:30:30 +00:00
|
|
|
[NWZ_NVP_BML] = 22,
|
|
|
|
|
[NWZ_NVP_BOK] = 4,
|
|
|
|
|
[NWZ_NVP_BPR] = 19,
|
|
|
|
|
[NWZ_NVP_BTC] = 85,
|
|
|
|
|
[NWZ_NVP_BTI] = 72,
|
nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
[NWZ_NVP_CLV] = 68,
|
2017-01-04 15:30:30 +00:00
|
|
|
[NWZ_NVP_CNG] = 23,
|
nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
[NWZ_NVP_CTR] = NWZ_NVP_INVALID,
|
2017-01-04 15:30:30 +00:00
|
|
|
[NWZ_NVP_DBA] = 24,
|
nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
[NWZ_NVP_DBG] = 0,
|
|
|
|
|
[NWZ_NVP_DBI] = NWZ_NVP_INVALID,
|
2017-04-03 13:13:46 +00:00
|
|
|
[NWZ_NVP_DBS] = NWZ_NVP_INVALID,
|
2017-01-04 15:30:30 +00:00
|
|
|
[NWZ_NVP_DBV] = 25,
|
|
|
|
|
[NWZ_NVP_DCC] = 31,
|
2017-04-03 13:13:46 +00:00
|
|
|
[NWZ_NVP_DG0] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_DG1] = NWZ_NVP_INVALID,
|
2017-01-04 15:30:30 +00:00
|
|
|
[NWZ_NVP_DOR] = 26,
|
nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
[NWZ_NVP_E00] = 36,
|
|
|
|
|
[NWZ_NVP_E01] = 37,
|
|
|
|
|
[NWZ_NVP_E02] = 38,
|
|
|
|
|
[NWZ_NVP_E03] = 39,
|
|
|
|
|
[NWZ_NVP_E04] = 40,
|
|
|
|
|
[NWZ_NVP_E05] = 41,
|
|
|
|
|
[NWZ_NVP_E06] = 42,
|
|
|
|
|
[NWZ_NVP_E07] = 43,
|
|
|
|
|
[NWZ_NVP_E08] = 44,
|
|
|
|
|
[NWZ_NVP_E09] = 45,
|
|
|
|
|
[NWZ_NVP_E10] = 46,
|
|
|
|
|
[NWZ_NVP_E11] = 47,
|
|
|
|
|
[NWZ_NVP_E12] = 48,
|
|
|
|
|
[NWZ_NVP_E13] = 49,
|
|
|
|
|
[NWZ_NVP_E14] = 50,
|
|
|
|
|
[NWZ_NVP_E15] = 51,
|
|
|
|
|
[NWZ_NVP_E16] = 52,
|
|
|
|
|
[NWZ_NVP_E17] = 53,
|
|
|
|
|
[NWZ_NVP_E18] = 54,
|
|
|
|
|
[NWZ_NVP_E19] = 55,
|
|
|
|
|
[NWZ_NVP_E20] = 56,
|
|
|
|
|
[NWZ_NVP_E21] = 57,
|
|
|
|
|
[NWZ_NVP_E22] = 58,
|
|
|
|
|
[NWZ_NVP_E23] = 59,
|
|
|
|
|
[NWZ_NVP_E24] = 60,
|
|
|
|
|
[NWZ_NVP_E25] = 61,
|
|
|
|
|
[NWZ_NVP_E26] = 62,
|
|
|
|
|
[NWZ_NVP_E27] = 63,
|
|
|
|
|
[NWZ_NVP_E28] = 64,
|
|
|
|
|
[NWZ_NVP_E29] = 65,
|
|
|
|
|
[NWZ_NVP_E30] = 66,
|
|
|
|
|
[NWZ_NVP_E31] = 67,
|
2017-01-04 15:30:30 +00:00
|
|
|
[NWZ_NVP_EDW] = 71,
|
2017-04-03 13:13:46 +00:00
|
|
|
[NWZ_NVP_EP0] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_EP1] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_EP2] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_EP3] = NWZ_NVP_INVALID,
|
2017-01-04 15:30:30 +00:00
|
|
|
[NWZ_NVP_ERI] = 76,
|
|
|
|
|
[NWZ_NVP_EXM] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_FMP] = 15,
|
|
|
|
|
[NWZ_NVP_FNI] = 82,
|
nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
[NWZ_NVP_FPI] = NWZ_NVP_INVALID,
|
2017-01-04 15:30:30 +00:00
|
|
|
[NWZ_NVP_FUI] = 75,
|
|
|
|
|
[NWZ_NVP_FUP] = 3,
|
nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
[NWZ_NVP_FUR] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_FVI] = NWZ_NVP_INVALID,
|
2017-01-04 15:30:30 +00:00
|
|
|
[NWZ_NVP_GTY] = 14,
|
|
|
|
|
[NWZ_NVP_HDI] = 73,
|
|
|
|
|
[NWZ_NVP_HLD] = 5,
|
nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
[NWZ_NVP_INS] = NWZ_NVP_INVALID,
|
2017-01-04 15:30:30 +00:00
|
|
|
[NWZ_NVP_IPT] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_KAS] = 11,
|
|
|
|
|
[NWZ_NVP_LBI] = 74,
|
nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
[NWZ_NVP_LYR] = NWZ_NVP_INVALID,
|
2017-01-04 15:30:30 +00:00
|
|
|
[NWZ_NVP_MAC] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_MCR] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_MDK] = 30,
|
|
|
|
|
[NWZ_NVP_MDL] = 70,
|
|
|
|
|
[NWZ_NVP_MID] = 7,
|
|
|
|
|
[NWZ_NVP_MLK] = 84,
|
|
|
|
|
[NWZ_NVP_MSC] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_MSO] = 86,
|
|
|
|
|
[NWZ_NVP_MTM] = 33,
|
|
|
|
|
[NWZ_NVP_MUK] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_NCP] = 17,
|
nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
[NWZ_NVP_NVR] = NWZ_NVP_INVALID,
|
2017-01-04 15:30:30 +00:00
|
|
|
[NWZ_NVP_PCD] = 8,
|
nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
[NWZ_NVP_PCI] = NWZ_NVP_INVALID,
|
2017-04-03 13:13:46 +00:00
|
|
|
[NWZ_NVP_PNC] = NWZ_NVP_INVALID,
|
nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
[NWZ_NVP_PRK] = NWZ_NVP_INVALID,
|
2017-01-04 15:30:30 +00:00
|
|
|
[NWZ_NVP_PSK] = 18,
|
|
|
|
|
[NWZ_NVP_PTS] = 77,
|
nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
[NWZ_NVP_RBT] = NWZ_NVP_INVALID,
|
2017-01-04 15:30:30 +00:00
|
|
|
[NWZ_NVP_RND] = 27,
|
|
|
|
|
[NWZ_NVP_RTC] = 6,
|
nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
[NWZ_NVP_SDC] = NWZ_NVP_INVALID,
|
2017-01-04 15:30:30 +00:00
|
|
|
[NWZ_NVP_SDP] = 16,
|
|
|
|
|
[NWZ_NVP_SER] = 9,
|
|
|
|
|
[NWZ_NVP_SFI] = 29,
|
nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
[NWZ_NVP_SHE] = NWZ_NVP_INVALID,
|
2017-01-04 15:30:30 +00:00
|
|
|
[NWZ_NVP_SHP] = 12,
|
|
|
|
|
[NWZ_NVP_SID] = 83,
|
|
|
|
|
[NWZ_NVP_SKD] = 28,
|
|
|
|
|
[NWZ_NVP_SKT] = 32,
|
nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
[NWZ_NVP_SKU] = NWZ_NVP_INVALID,
|
2017-01-04 15:30:30 +00:00
|
|
|
[NWZ_NVP_SLP] = 80,
|
|
|
|
|
[NWZ_NVP_SPS] = 69,
|
|
|
|
|
[NWZ_NVP_SYI] = 1,
|
|
|
|
|
[NWZ_NVP_TR0] = 34,
|
|
|
|
|
[NWZ_NVP_TR1] = 35,
|
|
|
|
|
[NWZ_NVP_TST] = 13,
|
|
|
|
|
[NWZ_NVP_UBP] = 2,
|
|
|
|
|
[NWZ_NVP_UFN] = 10,
|
nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
[NWZ_NVP_UMS] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_UPS] = NWZ_NVP_INVALID,
|
2017-04-03 13:13:46 +00:00
|
|
|
[NWZ_NVP_VAR] = NWZ_NVP_INVALID,
|
2017-01-04 15:30:30 +00:00
|
|
|
[NWZ_NVP_VRT] = 81,
|
nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static int nvp_index_398250[NWZ_NVP_COUNT] =
|
|
|
|
|
{
|
|
|
|
|
[NWZ_NVP_APD] = 78,
|
|
|
|
|
[NWZ_NVP_APP] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_BFD] = 21,
|
|
|
|
|
[NWZ_NVP_BFP] = 20,
|
|
|
|
|
[NWZ_NVP_BLF] = 79,
|
|
|
|
|
[NWZ_NVP_BML] = 22,
|
|
|
|
|
[NWZ_NVP_BOK] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_BPR] = 19,
|
|
|
|
|
[NWZ_NVP_BTC] = 85,
|
|
|
|
|
[NWZ_NVP_BTI] = 72,
|
|
|
|
|
[NWZ_NVP_CLV] = 68,
|
|
|
|
|
[NWZ_NVP_CNG] = 23,
|
|
|
|
|
[NWZ_NVP_CTR] = 90,
|
|
|
|
|
[NWZ_NVP_DBA] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_DBG] = 0,
|
|
|
|
|
[NWZ_NVP_DBI] = 88,
|
2017-04-03 13:13:46 +00:00
|
|
|
[NWZ_NVP_DBS] = NWZ_NVP_INVALID,
|
nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
[NWZ_NVP_DBV] = 25,
|
|
|
|
|
[NWZ_NVP_DCC] = NWZ_NVP_INVALID,
|
2017-04-03 13:13:46 +00:00
|
|
|
[NWZ_NVP_DG0] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_DG1] = NWZ_NVP_INVALID,
|
nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
[NWZ_NVP_DOR] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_E00] = 36,
|
|
|
|
|
[NWZ_NVP_E01] = 37,
|
|
|
|
|
[NWZ_NVP_E02] = 38,
|
|
|
|
|
[NWZ_NVP_E03] = 39,
|
|
|
|
|
[NWZ_NVP_E04] = 40,
|
|
|
|
|
[NWZ_NVP_E05] = 41,
|
|
|
|
|
[NWZ_NVP_E06] = 42,
|
|
|
|
|
[NWZ_NVP_E07] = 43,
|
|
|
|
|
[NWZ_NVP_E08] = 44,
|
|
|
|
|
[NWZ_NVP_E09] = 45,
|
|
|
|
|
[NWZ_NVP_E10] = 46,
|
|
|
|
|
[NWZ_NVP_E11] = 47,
|
|
|
|
|
[NWZ_NVP_E12] = 48,
|
|
|
|
|
[NWZ_NVP_E13] = 49,
|
|
|
|
|
[NWZ_NVP_E14] = 50,
|
|
|
|
|
[NWZ_NVP_E15] = 51,
|
|
|
|
|
[NWZ_NVP_E16] = 52,
|
|
|
|
|
[NWZ_NVP_E17] = 53,
|
|
|
|
|
[NWZ_NVP_E18] = 54,
|
|
|
|
|
[NWZ_NVP_E19] = 55,
|
|
|
|
|
[NWZ_NVP_E20] = 56,
|
|
|
|
|
[NWZ_NVP_E21] = 57,
|
|
|
|
|
[NWZ_NVP_E22] = 58,
|
|
|
|
|
[NWZ_NVP_E23] = 59,
|
|
|
|
|
[NWZ_NVP_E24] = 60,
|
|
|
|
|
[NWZ_NVP_E25] = 61,
|
|
|
|
|
[NWZ_NVP_E26] = 62,
|
|
|
|
|
[NWZ_NVP_E27] = 63,
|
|
|
|
|
[NWZ_NVP_E28] = 64,
|
|
|
|
|
[NWZ_NVP_E29] = 65,
|
|
|
|
|
[NWZ_NVP_E30] = 66,
|
|
|
|
|
[NWZ_NVP_E31] = 67,
|
|
|
|
|
[NWZ_NVP_EDW] = 71,
|
2017-04-03 13:13:46 +00:00
|
|
|
[NWZ_NVP_EP0] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_EP1] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_EP2] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_EP3] = NWZ_NVP_INVALID,
|
nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
[NWZ_NVP_ERI] = 76,
|
|
|
|
|
[NWZ_NVP_EXM] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_FMP] = 15,
|
|
|
|
|
[NWZ_NVP_FNI] = 82,
|
|
|
|
|
[NWZ_NVP_FPI] = 33,
|
|
|
|
|
[NWZ_NVP_FUI] = 75,
|
|
|
|
|
[NWZ_NVP_FUP] = 3,
|
|
|
|
|
[NWZ_NVP_FUR] = 26,
|
|
|
|
|
[NWZ_NVP_FVI] = 31,
|
|
|
|
|
[NWZ_NVP_GTY] = 14,
|
|
|
|
|
[NWZ_NVP_HDI] = 73,
|
|
|
|
|
[NWZ_NVP_HLD] = 5,
|
|
|
|
|
[NWZ_NVP_INS] = 89,
|
|
|
|
|
[NWZ_NVP_IPT] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_KAS] = 11,
|
|
|
|
|
[NWZ_NVP_LBI] = 74,
|
|
|
|
|
[NWZ_NVP_LYR] = 24,
|
|
|
|
|
[NWZ_NVP_MAC] = 32,
|
|
|
|
|
[NWZ_NVP_MCR] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_MDK] = 30,
|
|
|
|
|
[NWZ_NVP_MDL] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_MID] = 7,
|
|
|
|
|
[NWZ_NVP_MLK] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_MSC] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_MSO] = 86,
|
|
|
|
|
[NWZ_NVP_MTM] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_MUK] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_NCP] = 17,
|
|
|
|
|
[NWZ_NVP_NVR] = 77,
|
|
|
|
|
[NWZ_NVP_PCD] = 8,
|
|
|
|
|
[NWZ_NVP_PCI] = 87,
|
2017-04-03 13:13:46 +00:00
|
|
|
[NWZ_NVP_PNC] = NWZ_NVP_INVALID,
|
nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
[NWZ_NVP_PRK] = 4,
|
|
|
|
|
[NWZ_NVP_PSK] = 18,
|
|
|
|
|
[NWZ_NVP_PTS] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_RBT] = 70,
|
|
|
|
|
[NWZ_NVP_RND] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_RTC] = 6,
|
|
|
|
|
[NWZ_NVP_SDC] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_SDP] = 16,
|
|
|
|
|
[NWZ_NVP_SER] = 9,
|
|
|
|
|
[NWZ_NVP_SFI] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_SHE] = 84,
|
|
|
|
|
[NWZ_NVP_SHP] = 12,
|
|
|
|
|
[NWZ_NVP_SID] = 83,
|
|
|
|
|
[NWZ_NVP_SKD] = 28,
|
|
|
|
|
[NWZ_NVP_SKT] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_SKU] = 91,
|
|
|
|
|
[NWZ_NVP_SLP] = 80,
|
|
|
|
|
[NWZ_NVP_SPS] = 69,
|
|
|
|
|
[NWZ_NVP_SYI] = 1,
|
|
|
|
|
[NWZ_NVP_TR0] = 34,
|
|
|
|
|
[NWZ_NVP_TR1] = 35,
|
|
|
|
|
[NWZ_NVP_TST] = 13,
|
|
|
|
|
[NWZ_NVP_UBP] = 2,
|
|
|
|
|
[NWZ_NVP_UFN] = 10,
|
|
|
|
|
[NWZ_NVP_UMS] = 27,
|
|
|
|
|
[NWZ_NVP_UPS] = 29,
|
2017-04-03 13:13:46 +00:00
|
|
|
[NWZ_NVP_VAR] = NWZ_NVP_INVALID,
|
nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
[NWZ_NVP_VRT] = 81,
|
|
|
|
|
};
|
|
|
|
|
|
2017-04-03 13:13:46 +00:00
|
|
|
static int nvp_index_4edba7[NWZ_NVP_COUNT] =
|
|
|
|
|
{
|
|
|
|
|
[NWZ_NVP_APD] = 78,
|
|
|
|
|
[NWZ_NVP_APP] = 0,
|
|
|
|
|
[NWZ_NVP_BFD] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_BFP] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_BLF] = 79,
|
|
|
|
|
[NWZ_NVP_BML] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_BOK] = 10,
|
|
|
|
|
[NWZ_NVP_BPR] = 35,
|
|
|
|
|
[NWZ_NVP_BTC] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_BTI] = 1,
|
|
|
|
|
[NWZ_NVP_CLV] = 68,
|
|
|
|
|
[NWZ_NVP_CNG] = 3,
|
|
|
|
|
[NWZ_NVP_CTR] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_DBA] = 12,
|
|
|
|
|
[NWZ_NVP_DBG] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_DBI] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_DBS] = 27,
|
|
|
|
|
[NWZ_NVP_DBV] = 13,
|
|
|
|
|
[NWZ_NVP_DCC] = 7,
|
|
|
|
|
[NWZ_NVP_DG0] = 5,
|
|
|
|
|
[NWZ_NVP_DG1] = 6,
|
|
|
|
|
[NWZ_NVP_DOR] = 21,
|
|
|
|
|
[NWZ_NVP_E00] = 36,
|
|
|
|
|
[NWZ_NVP_E01] = 37,
|
|
|
|
|
[NWZ_NVP_E02] = 38,
|
|
|
|
|
[NWZ_NVP_E03] = 39,
|
|
|
|
|
[NWZ_NVP_E04] = 40,
|
|
|
|
|
[NWZ_NVP_E05] = 41,
|
|
|
|
|
[NWZ_NVP_E06] = 42,
|
|
|
|
|
[NWZ_NVP_E07] = 43,
|
|
|
|
|
[NWZ_NVP_E08] = 44,
|
|
|
|
|
[NWZ_NVP_E09] = 45,
|
|
|
|
|
[NWZ_NVP_E10] = 46,
|
|
|
|
|
[NWZ_NVP_E11] = 47,
|
|
|
|
|
[NWZ_NVP_E12] = 48,
|
|
|
|
|
[NWZ_NVP_E13] = 49,
|
|
|
|
|
[NWZ_NVP_E14] = 50,
|
|
|
|
|
[NWZ_NVP_E15] = 51,
|
|
|
|
|
[NWZ_NVP_E16] = 52,
|
|
|
|
|
[NWZ_NVP_E17] = 53,
|
|
|
|
|
[NWZ_NVP_E18] = 54,
|
|
|
|
|
[NWZ_NVP_E19] = 55,
|
|
|
|
|
[NWZ_NVP_E20] = 56,
|
|
|
|
|
[NWZ_NVP_E21] = 57,
|
|
|
|
|
[NWZ_NVP_E22] = 58,
|
|
|
|
|
[NWZ_NVP_E23] = 59,
|
|
|
|
|
[NWZ_NVP_E24] = 60,
|
|
|
|
|
[NWZ_NVP_E25] = 61,
|
|
|
|
|
[NWZ_NVP_E26] = 62,
|
|
|
|
|
[NWZ_NVP_E27] = 63,
|
|
|
|
|
[NWZ_NVP_E28] = 64,
|
|
|
|
|
[NWZ_NVP_E29] = 65,
|
|
|
|
|
[NWZ_NVP_E30] = 66,
|
|
|
|
|
[NWZ_NVP_E31] = 67,
|
|
|
|
|
[NWZ_NVP_EDW] = 22,
|
|
|
|
|
[NWZ_NVP_EP0] = 71,
|
|
|
|
|
[NWZ_NVP_EP1] = 72,
|
|
|
|
|
[NWZ_NVP_EP2] = 73,
|
|
|
|
|
[NWZ_NVP_EP3] = 74,
|
|
|
|
|
[NWZ_NVP_ERI] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_EXM] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_FMP] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_FNI] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_FPI] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_FUI] = 19,
|
|
|
|
|
[NWZ_NVP_FUP] = 9,
|
|
|
|
|
[NWZ_NVP_FUR] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_FVI] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_GTY] = 18,
|
|
|
|
|
[NWZ_NVP_HDI] = 2,
|
|
|
|
|
[NWZ_NVP_HLD] = 80,
|
|
|
|
|
[NWZ_NVP_INS] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_IPT] = 70,
|
|
|
|
|
[NWZ_NVP_KAS] = 32,
|
|
|
|
|
[NWZ_NVP_LBI] = 20,
|
|
|
|
|
[NWZ_NVP_LYR] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_MAC] = 77,
|
|
|
|
|
[NWZ_NVP_MCR] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_MDK] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_MDL] = 8,
|
|
|
|
|
[NWZ_NVP_MID] = 16,
|
|
|
|
|
[NWZ_NVP_MLK] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_MSC] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_MSO] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_MTM] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_MUK] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_NCP] = 31,
|
|
|
|
|
[NWZ_NVP_NVR] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_PCD] = 26,
|
|
|
|
|
[NWZ_NVP_PCI] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_PNC] = 33,
|
|
|
|
|
[NWZ_NVP_PRK] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_PSK] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_PTS] = 75,
|
|
|
|
|
[NWZ_NVP_RBT] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_RND] = 28,
|
|
|
|
|
[NWZ_NVP_RTC] = 34,
|
|
|
|
|
[NWZ_NVP_SDC] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_SDP] = 30,
|
|
|
|
|
[NWZ_NVP_SER] = 4,
|
|
|
|
|
[NWZ_NVP_SFI] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_SHE] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_SHP] = 11,
|
|
|
|
|
[NWZ_NVP_SID] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_SKD] = 81,
|
|
|
|
|
[NWZ_NVP_SKT] = 76,
|
|
|
|
|
[NWZ_NVP_SKU] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_SLP] = 69,
|
|
|
|
|
[NWZ_NVP_SPS] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_SYI] = 24,
|
|
|
|
|
[NWZ_NVP_TR0] = 14,
|
|
|
|
|
[NWZ_NVP_TR1] = 15,
|
|
|
|
|
[NWZ_NVP_TST] = 17,
|
|
|
|
|
[NWZ_NVP_UBP] = 23,
|
|
|
|
|
[NWZ_NVP_UFN] = 29,
|
|
|
|
|
[NWZ_NVP_UMS] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_UPS] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_VAR] = 25,
|
|
|
|
|
[NWZ_NVP_VRT] = NWZ_NVP_INVALID,
|
|
|
|
|
};
|
|
|
|
|
|
nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
static int nvp_index_6485c8[NWZ_NVP_COUNT] =
|
|
|
|
|
{
|
|
|
|
|
[NWZ_NVP_APD] = 78,
|
|
|
|
|
[NWZ_NVP_APP] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_BFD] = 21,
|
|
|
|
|
[NWZ_NVP_BFP] = 20,
|
|
|
|
|
[NWZ_NVP_BLF] = 79,
|
|
|
|
|
[NWZ_NVP_BML] = 22,
|
|
|
|
|
[NWZ_NVP_BOK] = 4,
|
|
|
|
|
[NWZ_NVP_BPR] = 19,
|
|
|
|
|
[NWZ_NVP_BTC] = 85,
|
|
|
|
|
[NWZ_NVP_BTI] = 72,
|
|
|
|
|
[NWZ_NVP_CLV] = 68,
|
|
|
|
|
[NWZ_NVP_CNG] = 23,
|
|
|
|
|
[NWZ_NVP_CTR] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_DBA] = 24,
|
|
|
|
|
[NWZ_NVP_DBG] = 0,
|
|
|
|
|
[NWZ_NVP_DBI] = 88,
|
2017-04-03 13:13:46 +00:00
|
|
|
[NWZ_NVP_DBS] = NWZ_NVP_INVALID,
|
nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
[NWZ_NVP_DBV] = 25,
|
|
|
|
|
[NWZ_NVP_DCC] = 31,
|
2017-04-03 13:13:46 +00:00
|
|
|
[NWZ_NVP_DG0] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_DG1] = NWZ_NVP_INVALID,
|
nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
[NWZ_NVP_DOR] = 26,
|
|
|
|
|
[NWZ_NVP_E00] = 36,
|
|
|
|
|
[NWZ_NVP_E01] = 37,
|
|
|
|
|
[NWZ_NVP_E02] = 38,
|
|
|
|
|
[NWZ_NVP_E03] = 39,
|
|
|
|
|
[NWZ_NVP_E04] = 40,
|
|
|
|
|
[NWZ_NVP_E05] = 41,
|
|
|
|
|
[NWZ_NVP_E06] = 42,
|
|
|
|
|
[NWZ_NVP_E07] = 43,
|
|
|
|
|
[NWZ_NVP_E08] = 44,
|
|
|
|
|
[NWZ_NVP_E09] = 45,
|
|
|
|
|
[NWZ_NVP_E10] = 46,
|
|
|
|
|
[NWZ_NVP_E11] = 47,
|
|
|
|
|
[NWZ_NVP_E12] = 48,
|
|
|
|
|
[NWZ_NVP_E13] = 49,
|
|
|
|
|
[NWZ_NVP_E14] = 50,
|
|
|
|
|
[NWZ_NVP_E15] = 51,
|
|
|
|
|
[NWZ_NVP_E16] = 52,
|
|
|
|
|
[NWZ_NVP_E17] = 53,
|
|
|
|
|
[NWZ_NVP_E18] = 54,
|
|
|
|
|
[NWZ_NVP_E19] = 55,
|
|
|
|
|
[NWZ_NVP_E20] = 56,
|
|
|
|
|
[NWZ_NVP_E21] = 57,
|
|
|
|
|
[NWZ_NVP_E22] = 58,
|
|
|
|
|
[NWZ_NVP_E23] = 59,
|
|
|
|
|
[NWZ_NVP_E24] = 60,
|
|
|
|
|
[NWZ_NVP_E25] = 61,
|
|
|
|
|
[NWZ_NVP_E26] = 62,
|
|
|
|
|
[NWZ_NVP_E27] = 63,
|
|
|
|
|
[NWZ_NVP_E28] = 64,
|
|
|
|
|
[NWZ_NVP_E29] = 65,
|
|
|
|
|
[NWZ_NVP_E30] = 66,
|
|
|
|
|
[NWZ_NVP_E31] = 67,
|
|
|
|
|
[NWZ_NVP_EDW] = 71,
|
2017-04-03 13:13:46 +00:00
|
|
|
[NWZ_NVP_EP0] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_EP1] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_EP2] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_EP3] = NWZ_NVP_INVALID,
|
nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
[NWZ_NVP_ERI] = 76,
|
|
|
|
|
[NWZ_NVP_EXM] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_FMP] = 15,
|
|
|
|
|
[NWZ_NVP_FNI] = 82,
|
|
|
|
|
[NWZ_NVP_FPI] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_FUI] = 75,
|
|
|
|
|
[NWZ_NVP_FUP] = 3,
|
|
|
|
|
[NWZ_NVP_FUR] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_FVI] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_GTY] = 14,
|
|
|
|
|
[NWZ_NVP_HDI] = 73,
|
|
|
|
|
[NWZ_NVP_HLD] = 5,
|
|
|
|
|
[NWZ_NVP_INS] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_IPT] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_KAS] = 11,
|
|
|
|
|
[NWZ_NVP_LBI] = 74,
|
|
|
|
|
[NWZ_NVP_LYR] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_MAC] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_MCR] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_MDK] = 30,
|
|
|
|
|
[NWZ_NVP_MDL] = 70,
|
|
|
|
|
[NWZ_NVP_MID] = 7,
|
|
|
|
|
[NWZ_NVP_MLK] = 84,
|
|
|
|
|
[NWZ_NVP_MSC] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_MSO] = 86,
|
|
|
|
|
[NWZ_NVP_MTM] = 33,
|
|
|
|
|
[NWZ_NVP_MUK] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_NCP] = 17,
|
|
|
|
|
[NWZ_NVP_NVR] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_PCD] = 8,
|
|
|
|
|
[NWZ_NVP_PCI] = 87,
|
2017-04-03 13:13:46 +00:00
|
|
|
[NWZ_NVP_PNC] = NWZ_NVP_INVALID,
|
nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
[NWZ_NVP_PRK] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_PSK] = 18,
|
|
|
|
|
[NWZ_NVP_PTS] = 77,
|
|
|
|
|
[NWZ_NVP_RBT] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_RND] = 27,
|
|
|
|
|
[NWZ_NVP_RTC] = 6,
|
|
|
|
|
[NWZ_NVP_SDC] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_SDP] = 16,
|
|
|
|
|
[NWZ_NVP_SER] = 9,
|
|
|
|
|
[NWZ_NVP_SFI] = 29,
|
|
|
|
|
[NWZ_NVP_SHE] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_SHP] = 12,
|
|
|
|
|
[NWZ_NVP_SID] = 83,
|
|
|
|
|
[NWZ_NVP_SKD] = 28,
|
|
|
|
|
[NWZ_NVP_SKT] = 32,
|
|
|
|
|
[NWZ_NVP_SKU] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_SLP] = 80,
|
|
|
|
|
[NWZ_NVP_SPS] = 69,
|
|
|
|
|
[NWZ_NVP_SYI] = 1,
|
|
|
|
|
[NWZ_NVP_TR0] = 34,
|
|
|
|
|
[NWZ_NVP_TR1] = 35,
|
|
|
|
|
[NWZ_NVP_TST] = 13,
|
|
|
|
|
[NWZ_NVP_UBP] = 2,
|
|
|
|
|
[NWZ_NVP_UFN] = 10,
|
|
|
|
|
[NWZ_NVP_UMS] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_UPS] = NWZ_NVP_INVALID,
|
2017-04-03 13:13:46 +00:00
|
|
|
[NWZ_NVP_VAR] = NWZ_NVP_INVALID,
|
nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
[NWZ_NVP_VRT] = 81,
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static int nvp_index_92faee[NWZ_NVP_COUNT] =
|
|
|
|
|
{
|
|
|
|
|
[NWZ_NVP_APD] = 78,
|
|
|
|
|
[NWZ_NVP_APP] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_BFD] = 21,
|
|
|
|
|
[NWZ_NVP_BFP] = 20,
|
|
|
|
|
[NWZ_NVP_BLF] = 79,
|
|
|
|
|
[NWZ_NVP_BML] = 22,
|
|
|
|
|
[NWZ_NVP_BOK] = 4,
|
|
|
|
|
[NWZ_NVP_BPR] = 19,
|
|
|
|
|
[NWZ_NVP_BTC] = 85,
|
|
|
|
|
[NWZ_NVP_BTI] = 72,
|
|
|
|
|
[NWZ_NVP_CLV] = 68,
|
|
|
|
|
[NWZ_NVP_CNG] = 23,
|
|
|
|
|
[NWZ_NVP_CTR] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_DBA] = 24,
|
|
|
|
|
[NWZ_NVP_DBG] = 0,
|
|
|
|
|
[NWZ_NVP_DBI] = 88,
|
2017-04-03 13:13:46 +00:00
|
|
|
[NWZ_NVP_DBS] = NWZ_NVP_INVALID,
|
nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
[NWZ_NVP_DBV] = 25,
|
|
|
|
|
[NWZ_NVP_DCC] = 31,
|
2017-04-03 13:13:46 +00:00
|
|
|
[NWZ_NVP_DG0] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_DG1] = NWZ_NVP_INVALID,
|
nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
[NWZ_NVP_DOR] = 26,
|
|
|
|
|
[NWZ_NVP_E00] = 36,
|
|
|
|
|
[NWZ_NVP_E01] = 37,
|
|
|
|
|
[NWZ_NVP_E02] = 38,
|
|
|
|
|
[NWZ_NVP_E03] = 39,
|
|
|
|
|
[NWZ_NVP_E04] = 40,
|
|
|
|
|
[NWZ_NVP_E05] = 41,
|
|
|
|
|
[NWZ_NVP_E06] = 42,
|
|
|
|
|
[NWZ_NVP_E07] = 43,
|
|
|
|
|
[NWZ_NVP_E08] = 44,
|
|
|
|
|
[NWZ_NVP_E09] = 45,
|
|
|
|
|
[NWZ_NVP_E10] = 46,
|
|
|
|
|
[NWZ_NVP_E11] = 47,
|
|
|
|
|
[NWZ_NVP_E12] = 48,
|
|
|
|
|
[NWZ_NVP_E13] = 49,
|
|
|
|
|
[NWZ_NVP_E14] = 50,
|
|
|
|
|
[NWZ_NVP_E15] = 51,
|
|
|
|
|
[NWZ_NVP_E16] = 52,
|
|
|
|
|
[NWZ_NVP_E17] = 53,
|
|
|
|
|
[NWZ_NVP_E18] = 54,
|
|
|
|
|
[NWZ_NVP_E19] = 55,
|
|
|
|
|
[NWZ_NVP_E20] = 56,
|
|
|
|
|
[NWZ_NVP_E21] = 57,
|
|
|
|
|
[NWZ_NVP_E22] = 58,
|
|
|
|
|
[NWZ_NVP_E23] = 59,
|
|
|
|
|
[NWZ_NVP_E24] = 60,
|
|
|
|
|
[NWZ_NVP_E25] = 61,
|
|
|
|
|
[NWZ_NVP_E26] = 62,
|
|
|
|
|
[NWZ_NVP_E27] = 63,
|
|
|
|
|
[NWZ_NVP_E28] = 64,
|
|
|
|
|
[NWZ_NVP_E29] = 65,
|
|
|
|
|
[NWZ_NVP_E30] = 66,
|
|
|
|
|
[NWZ_NVP_E31] = 67,
|
|
|
|
|
[NWZ_NVP_EDW] = 71,
|
2017-04-03 13:13:46 +00:00
|
|
|
[NWZ_NVP_EP0] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_EP1] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_EP2] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_EP3] = NWZ_NVP_INVALID,
|
nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
[NWZ_NVP_ERI] = 76,
|
|
|
|
|
[NWZ_NVP_EXM] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_FMP] = 15,
|
|
|
|
|
[NWZ_NVP_FNI] = 82,
|
|
|
|
|
[NWZ_NVP_FPI] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_FUI] = 75,
|
|
|
|
|
[NWZ_NVP_FUP] = 3,
|
|
|
|
|
[NWZ_NVP_FUR] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_FVI] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_GTY] = 14,
|
|
|
|
|
[NWZ_NVP_HDI] = 73,
|
|
|
|
|
[NWZ_NVP_HLD] = 5,
|
|
|
|
|
[NWZ_NVP_INS] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_IPT] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_KAS] = 11,
|
|
|
|
|
[NWZ_NVP_LBI] = 74,
|
|
|
|
|
[NWZ_NVP_LYR] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_MAC] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_MCR] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_MDK] = 30,
|
|
|
|
|
[NWZ_NVP_MDL] = 70,
|
|
|
|
|
[NWZ_NVP_MID] = 7,
|
|
|
|
|
[NWZ_NVP_MLK] = 84,
|
|
|
|
|
[NWZ_NVP_MSC] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_MSO] = 86,
|
|
|
|
|
[NWZ_NVP_MTM] = 33,
|
|
|
|
|
[NWZ_NVP_MUK] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_NCP] = 17,
|
|
|
|
|
[NWZ_NVP_NVR] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_PCD] = 8,
|
|
|
|
|
[NWZ_NVP_PCI] = 87,
|
2017-04-03 13:13:46 +00:00
|
|
|
[NWZ_NVP_PNC] = NWZ_NVP_INVALID,
|
nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
[NWZ_NVP_PRK] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_PSK] = 18,
|
|
|
|
|
[NWZ_NVP_PTS] = 77,
|
|
|
|
|
[NWZ_NVP_RBT] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_RND] = 27,
|
|
|
|
|
[NWZ_NVP_RTC] = 6,
|
|
|
|
|
[NWZ_NVP_SDC] = 89,
|
|
|
|
|
[NWZ_NVP_SDP] = 16,
|
|
|
|
|
[NWZ_NVP_SER] = 9,
|
|
|
|
|
[NWZ_NVP_SFI] = 29,
|
|
|
|
|
[NWZ_NVP_SHE] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_SHP] = 12,
|
|
|
|
|
[NWZ_NVP_SID] = 83,
|
|
|
|
|
[NWZ_NVP_SKD] = 28,
|
|
|
|
|
[NWZ_NVP_SKT] = 32,
|
|
|
|
|
[NWZ_NVP_SKU] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_SLP] = 80,
|
|
|
|
|
[NWZ_NVP_SPS] = 69,
|
|
|
|
|
[NWZ_NVP_SYI] = 1,
|
|
|
|
|
[NWZ_NVP_TR0] = 34,
|
|
|
|
|
[NWZ_NVP_TR1] = 35,
|
|
|
|
|
[NWZ_NVP_TST] = 13,
|
|
|
|
|
[NWZ_NVP_UBP] = 2,
|
|
|
|
|
[NWZ_NVP_UFN] = 10,
|
|
|
|
|
[NWZ_NVP_UMS] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_UPS] = NWZ_NVP_INVALID,
|
2017-04-03 13:13:46 +00:00
|
|
|
[NWZ_NVP_VAR] = NWZ_NVP_INVALID,
|
nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
[NWZ_NVP_VRT] = 81,
|
|
|
|
|
};
|
|
|
|
|
|
2017-01-04 15:30:30 +00:00
|
|
|
static int nvp_index_f505c8[NWZ_NVP_COUNT] =
|
|
|
|
|
{
|
|
|
|
|
[NWZ_NVP_APD] = 78,
|
|
|
|
|
[NWZ_NVP_APP] = 5,
|
|
|
|
|
[NWZ_NVP_BFD] = 88,
|
|
|
|
|
[NWZ_NVP_BFP] = 89,
|
|
|
|
|
[NWZ_NVP_BLF] = 79,
|
|
|
|
|
[NWZ_NVP_BML] = 87,
|
|
|
|
|
[NWZ_NVP_BOK] = 10,
|
|
|
|
|
[NWZ_NVP_BPR] = 35,
|
|
|
|
|
[NWZ_NVP_BTC] = 27,
|
|
|
|
|
[NWZ_NVP_BTI] = 1,
|
|
|
|
|
[NWZ_NVP_CLV] = 68,
|
|
|
|
|
[NWZ_NVP_CNG] = 3,
|
|
|
|
|
[NWZ_NVP_CTR] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_DBA] = 12,
|
|
|
|
|
[NWZ_NVP_DBG] = 0,
|
|
|
|
|
[NWZ_NVP_DBI] = NWZ_NVP_INVALID,
|
2017-04-03 13:13:46 +00:00
|
|
|
[NWZ_NVP_DBS] = NWZ_NVP_INVALID,
|
2017-01-04 15:30:30 +00:00
|
|
|
[NWZ_NVP_DBV] = 13,
|
|
|
|
|
[NWZ_NVP_DCC] = 7,
|
2017-04-03 13:13:46 +00:00
|
|
|
[NWZ_NVP_DG0] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_DG1] = NWZ_NVP_INVALID,
|
2017-01-04 15:30:30 +00:00
|
|
|
[NWZ_NVP_DOR] = 21,
|
|
|
|
|
[NWZ_NVP_E00] = 36,
|
|
|
|
|
[NWZ_NVP_E01] = 37,
|
|
|
|
|
[NWZ_NVP_E02] = 38,
|
|
|
|
|
[NWZ_NVP_E03] = 39,
|
|
|
|
|
[NWZ_NVP_E04] = 40,
|
|
|
|
|
[NWZ_NVP_E05] = 41,
|
|
|
|
|
[NWZ_NVP_E06] = 42,
|
|
|
|
|
[NWZ_NVP_E07] = 43,
|
|
|
|
|
[NWZ_NVP_E08] = 44,
|
|
|
|
|
[NWZ_NVP_E09] = 45,
|
|
|
|
|
[NWZ_NVP_E10] = 46,
|
|
|
|
|
[NWZ_NVP_E11] = 47,
|
|
|
|
|
[NWZ_NVP_E12] = 48,
|
|
|
|
|
[NWZ_NVP_E13] = 49,
|
|
|
|
|
[NWZ_NVP_E14] = 50,
|
|
|
|
|
[NWZ_NVP_E15] = 51,
|
|
|
|
|
[NWZ_NVP_E16] = 52,
|
|
|
|
|
[NWZ_NVP_E17] = 53,
|
|
|
|
|
[NWZ_NVP_E18] = 54,
|
|
|
|
|
[NWZ_NVP_E19] = 55,
|
|
|
|
|
[NWZ_NVP_E20] = 56,
|
|
|
|
|
[NWZ_NVP_E21] = 57,
|
|
|
|
|
[NWZ_NVP_E22] = 58,
|
|
|
|
|
[NWZ_NVP_E23] = 59,
|
|
|
|
|
[NWZ_NVP_E24] = 60,
|
|
|
|
|
[NWZ_NVP_E25] = 61,
|
|
|
|
|
[NWZ_NVP_E26] = 62,
|
|
|
|
|
[NWZ_NVP_E27] = 63,
|
|
|
|
|
[NWZ_NVP_E28] = 64,
|
|
|
|
|
[NWZ_NVP_E29] = 65,
|
|
|
|
|
[NWZ_NVP_E30] = 66,
|
|
|
|
|
[NWZ_NVP_E31] = 67,
|
|
|
|
|
[NWZ_NVP_EDW] = 22,
|
2017-04-03 13:13:46 +00:00
|
|
|
[NWZ_NVP_EP0] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_EP1] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_EP2] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_EP3] = NWZ_NVP_INVALID,
|
2017-01-04 15:30:30 +00:00
|
|
|
[NWZ_NVP_ERI] = 6,
|
|
|
|
|
[NWZ_NVP_EXM] = 25,
|
|
|
|
|
[NWZ_NVP_FMP] = 82,
|
|
|
|
|
[NWZ_NVP_FNI] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_FPI] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_FUI] = 19,
|
|
|
|
|
[NWZ_NVP_FUP] = 9,
|
|
|
|
|
[NWZ_NVP_FUR] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_FVI] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_GTY] = 18,
|
|
|
|
|
[NWZ_NVP_HDI] = 2,
|
|
|
|
|
[NWZ_NVP_HLD] = 80,
|
|
|
|
|
[NWZ_NVP_INS] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_IPT] = 70,
|
|
|
|
|
[NWZ_NVP_KAS] = 32,
|
|
|
|
|
[NWZ_NVP_LBI] = 20,
|
|
|
|
|
[NWZ_NVP_LYR] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_MAC] = 77,
|
|
|
|
|
[NWZ_NVP_MCR] = 72,
|
|
|
|
|
[NWZ_NVP_MDK] = 73,
|
|
|
|
|
[NWZ_NVP_MDL] = 8,
|
|
|
|
|
[NWZ_NVP_MID] = 16,
|
|
|
|
|
[NWZ_NVP_MLK] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_MSC] = 84,
|
|
|
|
|
[NWZ_NVP_MSO] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_MTM] = 71,
|
|
|
|
|
[NWZ_NVP_MUK] = 74,
|
|
|
|
|
[NWZ_NVP_NCP] = 31,
|
|
|
|
|
[NWZ_NVP_NVR] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_PCD] = 26,
|
|
|
|
|
[NWZ_NVP_PCI] = NWZ_NVP_INVALID,
|
2017-04-03 13:13:46 +00:00
|
|
|
[NWZ_NVP_PNC] = NWZ_NVP_INVALID,
|
2017-01-04 15:30:30 +00:00
|
|
|
[NWZ_NVP_PRK] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_PSK] = 86,
|
|
|
|
|
[NWZ_NVP_PTS] = 75,
|
|
|
|
|
[NWZ_NVP_RBT] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_RND] = 28,
|
|
|
|
|
[NWZ_NVP_RTC] = 34,
|
|
|
|
|
[NWZ_NVP_SDC] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_SDP] = 30,
|
|
|
|
|
[NWZ_NVP_SER] = 4,
|
|
|
|
|
[NWZ_NVP_SFI] = 33,
|
|
|
|
|
[NWZ_NVP_SHE] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_SHP] = 11,
|
|
|
|
|
[NWZ_NVP_SID] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_SKD] = 81,
|
|
|
|
|
[NWZ_NVP_SKT] = 76,
|
|
|
|
|
[NWZ_NVP_SKU] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_SLP] = 69,
|
|
|
|
|
[NWZ_NVP_SPS] = 83,
|
|
|
|
|
[NWZ_NVP_SYI] = 24,
|
|
|
|
|
[NWZ_NVP_TR0] = 14,
|
|
|
|
|
[NWZ_NVP_TR1] = 15,
|
|
|
|
|
[NWZ_NVP_TST] = 17,
|
|
|
|
|
[NWZ_NVP_UBP] = 23,
|
|
|
|
|
[NWZ_NVP_UFN] = 29,
|
|
|
|
|
[NWZ_NVP_UMS] = NWZ_NVP_INVALID,
|
|
|
|
|
[NWZ_NVP_UPS] = NWZ_NVP_INVALID,
|
2017-04-03 13:13:46 +00:00
|
|
|
[NWZ_NVP_VAR] = NWZ_NVP_INVALID,
|
2017-01-04 15:30:30 +00:00
|
|
|
[NWZ_NVP_VRT] = 85,
|
|
|
|
|
};
|
|
|
|
|
|
nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
struct nwz_nvp_info_t nwz_nvp[NWZ_NVP_COUNT] =
|
|
|
|
|
{
|
|
|
|
|
[NWZ_NVP_APD] = { "apd", 4, "application debug mode flag" },
|
|
|
|
|
[NWZ_NVP_APP] = { "app", 4096, "application parameter" },
|
|
|
|
|
[NWZ_NVP_BFD] = { "bfd", 512, "btmw factory scdb" },
|
|
|
|
|
[NWZ_NVP_BFP] = { "bfp", 512, "btmw factory pair info" },
|
|
|
|
|
[NWZ_NVP_BLF] = { "blf", 4, "browser log mode flag" },
|
|
|
|
|
[NWZ_NVP_BML] = { "bml", 4, "btmw log mode flag" },
|
|
|
|
|
[NWZ_NVP_BOK] = { "bok", 4, "beep ok flag" },
|
|
|
|
|
[NWZ_NVP_BPR] = { "bpr", 2048, "bluetooth address | bluetooth parameter" },
|
|
|
|
|
[NWZ_NVP_BTC] = { "btc", 4, "battery calibration" },
|
|
|
|
|
[NWZ_NVP_BTI] = { "bti", 262144, "boot image" },
|
|
|
|
|
[NWZ_NVP_CLV] = { "clv", 4, "color variation" },
|
2017-01-07 16:32:47 +00:00
|
|
|
[NWZ_NVP_CNG] = { "cng", 704, "aad key | aad/empr key" },
|
nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
[NWZ_NVP_CTR] = { "ctr", 0, "" },
|
|
|
|
|
[NWZ_NVP_DBA] = { "dba", 160, "aad icv" },
|
|
|
|
|
[NWZ_NVP_DBG] = { "dbg", 0, "" },
|
|
|
|
|
[NWZ_NVP_DBI] = { "dbi", 262144, "dead battery image" },
|
2017-04-03 13:13:46 +00:00
|
|
|
[NWZ_NVP_DBS] = { "dbs", 0, "" },
|
2017-01-07 16:32:47 +00:00
|
|
|
[NWZ_NVP_DBV] = { "dbv", 520, "empr icv | empr key" },
|
nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
[NWZ_NVP_DCC] = { "dcc", 20, "secure clock" },
|
2017-04-03 13:13:46 +00:00
|
|
|
[NWZ_NVP_DG0] = { "dg0", 0, "" },
|
|
|
|
|
[NWZ_NVP_DG1] = { "dg1", 0, "" },
|
nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
[NWZ_NVP_DOR] = { "dor", 4, "key mode (debug/release)" },
|
|
|
|
|
[NWZ_NVP_E00] = { "e00", 1024, "EMPR 0" },
|
|
|
|
|
[NWZ_NVP_E01] = { "e01", 1024, "EMPR 1" },
|
|
|
|
|
[NWZ_NVP_E02] = { "e02", 1024, "EMPR 2" },
|
|
|
|
|
[NWZ_NVP_E03] = { "e03", 1024, "EMPR 3" },
|
|
|
|
|
[NWZ_NVP_E04] = { "e04", 1024, "EMPR 4" },
|
|
|
|
|
[NWZ_NVP_E05] = { "e05", 1024, "EMPR 5" },
|
|
|
|
|
[NWZ_NVP_E06] = { "e06", 1024, "EMPR 6" },
|
|
|
|
|
[NWZ_NVP_E07] = { "e07", 1024, "EMPR 7" },
|
|
|
|
|
[NWZ_NVP_E08] = { "e08", 1024, "EMPR 8" },
|
|
|
|
|
[NWZ_NVP_E09] = { "e09", 1024, "EMPR 9" },
|
|
|
|
|
[NWZ_NVP_E10] = { "e10", 1024, "EMPR 10" },
|
|
|
|
|
[NWZ_NVP_E11] = { "e11", 1024, "EMPR 11" },
|
|
|
|
|
[NWZ_NVP_E12] = { "e12", 1024, "EMPR 12" },
|
|
|
|
|
[NWZ_NVP_E13] = { "e13", 1024, "EMPR 13" },
|
|
|
|
|
[NWZ_NVP_E14] = { "e14", 1024, "EMPR 14" },
|
|
|
|
|
[NWZ_NVP_E15] = { "e15", 1024, "EMPR 15" },
|
|
|
|
|
[NWZ_NVP_E16] = { "e16", 1024, "EMPR 16" },
|
|
|
|
|
[NWZ_NVP_E17] = { "e17", 1024, "EMPR 17" },
|
|
|
|
|
[NWZ_NVP_E18] = { "e18", 1024, "EMPR 18" },
|
|
|
|
|
[NWZ_NVP_E19] = { "e19", 1024, "EMPR 19" },
|
|
|
|
|
[NWZ_NVP_E20] = { "e20", 1024, "EMPR 20" },
|
|
|
|
|
[NWZ_NVP_E21] = { "e21", 1024, "EMPR 21" },
|
|
|
|
|
[NWZ_NVP_E22] = { "e22", 1024, "EMPR 22" },
|
|
|
|
|
[NWZ_NVP_E23] = { "e23", 1024, "EMPR 23" },
|
|
|
|
|
[NWZ_NVP_E24] = { "e24", 1024, "EMPR 24" },
|
|
|
|
|
[NWZ_NVP_E25] = { "e25", 1024, "EMPR 25" },
|
|
|
|
|
[NWZ_NVP_E26] = { "e26", 1024, "EMPR 26" },
|
|
|
|
|
[NWZ_NVP_E27] = { "e27", 1024, "EMPR 27" },
|
|
|
|
|
[NWZ_NVP_E28] = { "e28", 1024, "EMPR 28" },
|
|
|
|
|
[NWZ_NVP_E29] = { "e29", 1024, "EMPR 29" },
|
|
|
|
|
[NWZ_NVP_E30] = { "e30", 1024, "EMPR 30" },
|
|
|
|
|
[NWZ_NVP_E31] = { "e31", 1024, "EMPR 31" },
|
|
|
|
|
[NWZ_NVP_EDW] = { "edw", 4, "quick shutdown flag" },
|
2017-04-03 13:13:46 +00:00
|
|
|
[NWZ_NVP_EP0] = { "ep0", 0, "" },
|
|
|
|
|
[NWZ_NVP_EP1] = { "ep1", 0, "" },
|
|
|
|
|
[NWZ_NVP_EP2] = { "ep2", 0, "" },
|
|
|
|
|
[NWZ_NVP_EP3] = { "ep3", 0, "" },
|
nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
[NWZ_NVP_ERI] = { "eri", 262144, "update error image" },
|
|
|
|
|
[NWZ_NVP_EXM] = { "exm", 4, "exception monitor mode" },
|
|
|
|
|
[NWZ_NVP_FMP] = { "fmp", 16, "fm parameter" },
|
|
|
|
|
[NWZ_NVP_FNI] = { "fni", 4, "function information" },
|
|
|
|
|
[NWZ_NVP_FPI] = { "fpi", 0, "" },
|
|
|
|
|
[NWZ_NVP_FUI] = { "fui", 262144, "update image" },
|
|
|
|
|
[NWZ_NVP_FUP] = { "fup", 4, "firmware update flag" },
|
|
|
|
|
[NWZ_NVP_FUR] = { "fur", 0, "" },
|
|
|
|
|
[NWZ_NVP_FVI] = { "fvi", 0, "" },
|
|
|
|
|
[NWZ_NVP_GTY] = { "gty", 4, "getty mode flag" },
|
|
|
|
|
[NWZ_NVP_HDI] = { "hdi", 262144, "hold image" },
|
|
|
|
|
[NWZ_NVP_HLD] = { "hld", 4, "hold mode" },
|
|
|
|
|
[NWZ_NVP_INS] = { "ins", 0, "" },
|
|
|
|
|
[NWZ_NVP_IPT] = { "ipt", 4, "disable iptable flag" },
|
|
|
|
|
[NWZ_NVP_KAS] = { "kas", 64, "key and signature" },
|
|
|
|
|
[NWZ_NVP_LBI] = { "lbi", 262144, "low battery image" },
|
|
|
|
|
[NWZ_NVP_LYR] = { "lyr", 0, "" },
|
|
|
|
|
[NWZ_NVP_MAC] = { "mac", 6, "wifi mac address" },
|
|
|
|
|
[NWZ_NVP_MCR] = { "mcr", 16384, "marlin crl" },
|
|
|
|
|
[NWZ_NVP_MDK] = { "mdk", 33024, "marlin device key" },
|
|
|
|
|
[NWZ_NVP_MDL] = { "mdl", 8, "middleware parameter" },
|
|
|
|
|
[NWZ_NVP_MID] = { "mid", 64, "model id" },
|
|
|
|
|
[NWZ_NVP_MLK] = { "mlk", 4, "marlin key" },
|
|
|
|
|
[NWZ_NVP_MSC] = { "msc", 4, "mass storage class mode" },
|
|
|
|
|
[NWZ_NVP_MSO] = { "mso", 4, "MSC only mode flag" },
|
|
|
|
|
[NWZ_NVP_MTM] = { "mtm", 64, "marlin time" },
|
|
|
|
|
[NWZ_NVP_MUK] = { "muk", 24576, "marlin user key" },
|
|
|
|
|
[NWZ_NVP_NCP] = { "ncp", 64, "noise cancel driver parameter" },
|
|
|
|
|
[NWZ_NVP_NVR] = { "nvr", 0, "" },
|
|
|
|
|
[NWZ_NVP_PCD] = { "pcd", 5, "product code" },
|
|
|
|
|
[NWZ_NVP_PCI] = { "pci", 262144, "precharge image" },
|
2017-04-03 13:13:46 +00:00
|
|
|
[NWZ_NVP_PNC] = { "pnc", 0, "" },
|
nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
[NWZ_NVP_PRK] = { "prk", 0, "" },
|
|
|
|
|
[NWZ_NVP_PSK] = { "psk", 512, "bluetooth pskey" },
|
|
|
|
|
[NWZ_NVP_PTS] = { "pts", 4, "wifi protected setup" },
|
|
|
|
|
[NWZ_NVP_RBT] = { "rbt", 0, "" },
|
2017-01-07 16:32:47 +00:00
|
|
|
[NWZ_NVP_RND] = { "rnd", 64, "random data | wmt key" },
|
nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
[NWZ_NVP_RTC] = { "rtc", 16, "rtc alarm" },
|
|
|
|
|
[NWZ_NVP_SDC] = { "sdc", 4, "SD Card export flag" },
|
|
|
|
|
[NWZ_NVP_SDP] = { "sdp", 64, "sound driver parameter" },
|
|
|
|
|
[NWZ_NVP_SER] = { "ser", 16, "serial number" },
|
|
|
|
|
[NWZ_NVP_SFI] = { "sfi", 64, "starfish id" },
|
|
|
|
|
[NWZ_NVP_SHE] = { "she", 0, "" },
|
|
|
|
|
[NWZ_NVP_SHP] = { "shp", 32, "ship information" },
|
|
|
|
|
[NWZ_NVP_SID] = { "sid", 4, "service id" },
|
|
|
|
|
[NWZ_NVP_SKD] = { "skd", 8224, "slacker id file" },
|
|
|
|
|
[NWZ_NVP_SKT] = { "skt", 16, "slacker time" },
|
|
|
|
|
[NWZ_NVP_SKU] = { "sku", 0, "" },
|
|
|
|
|
[NWZ_NVP_SLP] = { "slp", 4, "time out to sleep" },
|
|
|
|
|
[NWZ_NVP_SPS] = { "sps", 4, "speaker ship info" },
|
|
|
|
|
[NWZ_NVP_SYI] = { "syi", 4, "system information" },
|
|
|
|
|
[NWZ_NVP_TR0] = { "tr0", 16384, "EKB 0" },
|
|
|
|
|
[NWZ_NVP_TR1] = { "tr1", 16384, "EKB 1" },
|
|
|
|
|
[NWZ_NVP_TST] = { "tst", 4, "test mode flag" },
|
|
|
|
|
[NWZ_NVP_UBP] = { "ubp", 32, "u-boot password" },
|
|
|
|
|
[NWZ_NVP_UFN] = { "ufn", 8, "update file name" },
|
|
|
|
|
[NWZ_NVP_UMS] = { "ums", 0, "" },
|
|
|
|
|
[NWZ_NVP_UPS] = { "ups", 0, "" },
|
2017-04-03 13:13:46 +00:00
|
|
|
[NWZ_NVP_VAR] = { "var", 0, "" },
|
nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
[NWZ_NVP_VRT] = { "vrt", 4, "europe vol regulation flag" },
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static unsigned long models_nwz_a10[] = { 0x1a000001, 0x1a000002, 0x1a000004,
|
|
|
|
|
0x1a000005, 0x1a000006, 0x1a010001, 0x1a010002, 0x1a010004, 0x1a010005,
|
|
|
|
|
0x1a010006 };
|
|
|
|
|
|
2017-01-08 11:03:07 +00:00
|
|
|
static unsigned long models_nw_a20[] = { 0x1d000001, 0x1d000002, 0x1d000004,
|
nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
0x1d000005, 0x1d000006, 0x1d000007 };
|
|
|
|
|
|
2017-01-08 11:30:46 +00:00
|
|
|
static unsigned long models_nw_a30[] = { 0x22000004 };
|
nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
|
|
|
|
|
static unsigned long models_nwz_a720[] = { 0x3030001, 0x3030002, 0x3030004,
|
|
|
|
|
0x3020001, 0x3020002, 0x3020004 };
|
|
|
|
|
|
|
|
|
|
static unsigned long models_nwz_a810[] = { 0x10000, 0x10001, 0x10002 };
|
|
|
|
|
|
|
|
|
|
static unsigned long models_nwz_a820[] = { 0x3010001, 0x3010002, 0x3010004,
|
|
|
|
|
0x3000001, 0x3000002, 0x3000004 };
|
|
|
|
|
|
|
|
|
|
static unsigned long models_nwz_a840[] = { 0x7010004, 0x7010005, 0x7010006,
|
|
|
|
|
0x7000004, 0x7000005, 0x7000006 };
|
|
|
|
|
|
|
|
|
|
static unsigned long models_nwz_a850[] = { 0xe000004, 0xe000005, 0xe000006 };
|
|
|
|
|
|
|
|
|
|
static unsigned long models_nwz_a860[] = { 0x11000001, 0x11000002, 0x11000004,
|
|
|
|
|
0x11000005, 0x11000006, 0x11010001, 0x11010002, 0x11010004, 0x11010005,
|
|
|
|
|
0x11010006, 0x11020001, 0x11020002, 0x11020004, 0x11020005, 0x11020006 };
|
|
|
|
|
|
|
|
|
|
static unsigned long models_nw_a910[] = { 0x2000001, 0x2000002, 0x2000004 };
|
|
|
|
|
|
|
|
|
|
static unsigned long models_nwz_e050[] = { 0x8000000, 0x8000001, 0x8000002,
|
|
|
|
|
0x10000000, 0x10000001 };
|
|
|
|
|
|
|
|
|
|
static unsigned long models_nw_e060[] = { 0x14000000, 0x14000001, 0x14000002,
|
|
|
|
|
0x14000004, 0x14000005 };
|
|
|
|
|
|
|
|
|
|
static unsigned long models_nw_e080[] = { 0x19010001, 0x19010002, 0x19010004,
|
|
|
|
|
0x19010005 };
|
|
|
|
|
|
|
|
|
|
static unsigned long models_nwz_e350[] = { 0xc000001, 0xc000002, 0xc000004 };
|
|
|
|
|
|
|
|
|
|
static unsigned long models_nwz_e450[] = { 0xb000001, 0xb000002, 0xb000004 };
|
|
|
|
|
|
|
|
|
|
static unsigned long models_nwz_e460[] = { 0x13000001, 0x13000002, 0x13000004 };
|
|
|
|
|
|
|
|
|
|
static unsigned long models_nwz_e470[] = { 0x15000001, 0x15000002, 0x15000004,
|
|
|
|
|
0x15000005 };
|
|
|
|
|
|
|
|
|
|
static unsigned long models_nwz_e550[] = { 0xd000001, 0xd000002, 0xd000004,
|
|
|
|
|
0xd000005 };
|
|
|
|
|
|
|
|
|
|
static unsigned long models_nwz_e570[] = { 0x15010001, 0x15010002, 0x15010004,
|
|
|
|
|
0x15010005 };
|
|
|
|
|
|
|
|
|
|
static unsigned long models_nwz_e580[] = { 0x19020001, 0x19020002, 0x19020004,
|
|
|
|
|
0x19020005 };
|
|
|
|
|
|
|
|
|
|
static unsigned long models_nw_s10[] = { 0x1b000001, 0x1b000002, 0x1b000004,
|
|
|
|
|
0x1b000005, 0x1b000006 };
|
|
|
|
|
|
|
|
|
|
static unsigned long models_nwz_s510[] = { 0x1030000, 0x1030001 };
|
|
|
|
|
|
|
|
|
|
static unsigned long models_nwz_s610[] = { 0x1000000, 0x1000001, 0x1020000,
|
|
|
|
|
0x1020001, 0x1020002 };
|
|
|
|
|
|
|
|
|
|
static unsigned long models_nwz_s630[] = { 0x4000001, 0x4000002, 0x4000004,
|
|
|
|
|
0x4020001, 0x4020002, 0x4020004 };
|
|
|
|
|
|
|
|
|
|
static unsigned long models_nw_s640[] = { 0x6010002, 0x6010004, 0x6010005 };
|
|
|
|
|
|
|
|
|
|
static unsigned long models_nwz_s710[] = { 0x1010000, 0x1010001, 0x1010002,
|
|
|
|
|
0x1040000, 0x1040001, 0x1040002 };
|
|
|
|
|
|
|
|
|
|
static unsigned long models_nwz_s730[] = { 0x4010001, 0x4010002, 0x4010004,
|
|
|
|
|
0x4030001, 0x4030002, 0x4030004 };
|
|
|
|
|
|
|
|
|
|
static unsigned long models_nwz_s740[] = { 0x6030002, 0x6030004, 0x6030005,
|
|
|
|
|
0x6020002, 0x6020004, 0x6020005 };
|
|
|
|
|
|
|
|
|
|
static unsigned long models_nwz_s750[] = { 0x9000002, 0x9000004, 0x9000005,
|
|
|
|
|
0xf000002, 0xf000004 };
|
|
|
|
|
|
|
|
|
|
static unsigned long models_nwz_s760[] = { 0x12000001, 0x12000002, 0x12000004,
|
|
|
|
|
0x12000005, 0x12000006, 0x12010001, 0x12010002, 0x12010004, 0x12010005,
|
|
|
|
|
0x12010006 };
|
|
|
|
|
|
|
|
|
|
static unsigned long models_nwz_s770[] = { 0x16000001, 0x16000002, 0x16000004,
|
|
|
|
|
0x16000005, 0x16010001, 0x16010002, 0x16010004, 0x16010005 };
|
|
|
|
|
|
|
|
|
|
static unsigned long models_nw_s780[] = { 0x19000001, 0x19000002, 0x19000004,
|
|
|
|
|
0x19000005 };
|
|
|
|
|
|
2017-01-07 16:32:47 +00:00
|
|
|
static unsigned long models_nw_wm1[] = { 0x20000007, 0x21000008 };
|
2017-01-04 15:30:30 +00:00
|
|
|
|
nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
static unsigned long models_nwz_x1000[] = { 0x5000002, 0x5000004, 0x5000005,
|
|
|
|
|
0x5020002, 0x5040002, 0x5020004, 0x5040004, 0x5020005, 0x5040005 };
|
|
|
|
|
|
|
|
|
|
static unsigned long models_nw_zx100[] = { 0x1c000007, 0x1c000001, 0x1c000002,
|
|
|
|
|
0x1c000004, 0x1c000005, 0x1c000006 };
|
|
|
|
|
|
|
|
|
|
static unsigned long models_nwz_noname[] = { 0x5010002, 0x5010004, 0x5010005 };
|
|
|
|
|
|
|
|
|
|
struct nwz_series_info_t nwz_series[NWZ_SERIES_COUNT] =
|
|
|
|
|
{
|
|
|
|
|
{ "nwz-a10", "NWZ-A10 Series", 10, models_nwz_a10, &nvp_index_92faee },
|
2017-01-08 11:03:07 +00:00
|
|
|
{ "nw-a20", "NW-A20 Series", 6, models_nw_a20, &nvp_index_92faee },
|
2017-01-08 11:30:46 +00:00
|
|
|
{ "nw-a30", "NW-A30 Series", 1, models_nw_a30, &nvp_index_398250 },
|
nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
{ "nwz-a720", "NWZ-A720 Series", 6, models_nwz_a720, 0 },
|
|
|
|
|
{ "nwz-a810", "NWZ-A810 Series", 3, models_nwz_a810, 0 },
|
|
|
|
|
{ "nwz-a820", "NWZ-A820 Series", 6, models_nwz_a820, 0 },
|
2017-01-08 21:28:00 +00:00
|
|
|
{ "nwz-a840", "NWZ-A840 Series", 6, models_nwz_a840, &nvp_index_0ac81d },
|
nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
{ "nwz-a850", "NWZ-A850 Series", 3, models_nwz_a850, &nvp_index_0ac81d },
|
|
|
|
|
{ "nwz-a860", "NWZ-A860 Series", 15, models_nwz_a860, &nvp_index_f505c8 },
|
|
|
|
|
{ "nw-a910", "NW-A910 Series", 3, models_nw_a910, 0 },
|
2017-01-08 21:28:00 +00:00
|
|
|
{ "nwz-e050", "NWZ-E050 Series", 5, models_nwz_e050, &nvp_index_0ac81d },
|
nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
{ "nw-e060", "NW-E060 Series", 5, models_nw_e060, &nvp_index_f505c8 },
|
|
|
|
|
{ "nw-e080", "NW-E080 Series", 4, models_nw_e080, &nvp_index_6485c8 },
|
|
|
|
|
{ "nwz-e350", "NWZ-E350 Series", 3, models_nwz_e350, &nvp_index_0ac81d },
|
|
|
|
|
{ "nwz-e450", "NWZ-E450 Series", 3, models_nwz_e450, &nvp_index_0ac81d },
|
|
|
|
|
{ "nwz-e460", "NWZ-E460 Series", 3, models_nwz_e460, &nvp_index_f505c8 },
|
|
|
|
|
{ "nwz-e470", "NWZ-E470 Series", 4, models_nwz_e470, &nvp_index_28dc2c },
|
|
|
|
|
{ "nwz-e550", "NWZ-E550 Series", 4, models_nwz_e550, 0 },
|
|
|
|
|
{ "nwz-e570", "NWZ-E570 Series", 4, models_nwz_e570, 0 },
|
|
|
|
|
{ "nwz-e580", "NWZ-E580 Series", 4, models_nwz_e580, &nvp_index_6485c8 },
|
|
|
|
|
{ "nw-s10", "NW-S10 Series", 5, models_nw_s10, 0 },
|
|
|
|
|
{ "nwz-s510", "NWZ-S510 Series", 2, models_nwz_s510, 0 },
|
|
|
|
|
{ "nwz-s610", "NWZ-S610 Series", 5, models_nwz_s610, 0 },
|
|
|
|
|
{ "nwz-s630", "NWZ-S630 Series", 6, models_nwz_s630, 0 },
|
2017-01-08 21:28:00 +00:00
|
|
|
{ "nw-s640", "NW-S640 Series", 3, models_nw_s640, &nvp_index_0ac81d },
|
nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
{ "nwz-s710", "NWZ-S710 Series", 6, models_nwz_s710, 0 },
|
|
|
|
|
{ "nwz-s730", "NWZ-S730 Series", 6, models_nwz_s730, 0 },
|
2017-01-08 21:28:00 +00:00
|
|
|
{ "nwz-s740", "NWZ-S740 Series", 6, models_nwz_s740, &nvp_index_0ac81d },
|
|
|
|
|
{ "nwz-s750", "NWZ-S750 Series", 5, models_nwz_s750, &nvp_index_0ac81d },
|
|
|
|
|
{ "nwz-s760", "NWZ-S760 Series", 10, models_nwz_s760, &nvp_index_f505c8 },
|
nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
{ "nwz-s770", "NWZ-S770 Series", 8, models_nwz_s770, 0 },
|
|
|
|
|
{ "nw-s780", "NW-S780 Series", 4, models_nw_s780, &nvp_index_6485c8 },
|
2017-01-07 16:32:47 +00:00
|
|
|
{ "nw-wm1", "NW-WM1 Series", 2, models_nw_wm1, &nvp_index_398250 },
|
2017-04-03 13:13:46 +00:00
|
|
|
{ "nwz-x1000", "NWZ-X1000 Series", 9, models_nwz_x1000, &nvp_index_4edba7 },
|
2017-01-09 20:48:43 +00:00
|
|
|
{ "nw-zx100", "NW-ZX100 Series", 6, models_nw_zx100, &nvp_index_92faee },
|
nwztools/database: add database of information on Sony NWZ linux players
There must be an evil genius in Sony's Walkman division. Someone who made sure
that each model is close enough to the previous one so that little code is needed
but different enough so that an educated guess is not enough.
Each linux-based Sony player has a model ID (mid) which is a 32-bit integer.
I was able to extract a list of all model IDs and the correspoding name of
the player (see README). This gives us 1) a nice list of all players (because
NWZ-A729 vs NWZ-A729B, really Sony?) 2) an easy way to find the name of player
programatically. It seems that the lower 8-bit of the model ID gives the storage
size but don't bet your life on it. The remaining bytes seem to follow some kind
of pattern but there are exceptions.
From this list, I was able to build a list of all Sony's series (up to quite
recent one). The only safe way to build that is by hand, with a list of series,
each series having a list of model IDs. The notion of series is very important
because all models in a series share the same firmware.
A very important concept on Sony's players is the NVP, an area of the flash
that stores data associated with keys. The README contains more information but
basically this is where is record the model ID, the destination, the boot flags,
the firmware upgrade flags, the boot image, the DRM keys, and a lot of other stuff.
Of course Sony decided to slightly tweak the index of the keys regularly over time
which means that each series has a potentially different map, and we need this map
to talk to the NVP driver. Fortunately, Sony distributes the kernel for all its
players and they contain a kernel header with this information. I wrote a script
to unpack kernel sources and parse this header, producing a bunch of nw-*.txt
files, included in this commit. This map is very specific though: it maps Sony's
3-letter names (bti) to indexes (1). This is not very useful without the
decription (bti = boot image) and its size (262144). This information is harder
to come by, and is only stored in one place: if icx_nvp_emmc.ko drivers, found
on the device. Fortunately, Sony distributes a number of firmware upgrade, that
contain the rootfs, than once extracted contain this driver. The driver is a
standard ELF files with symbols. I wrote a parsing tool (nvptool) that is able
to extract this information from the drivers. Using that, I produced a bunch
of nodes-nw*.txt files. A reasonable assumption is that nodes meaning and
size do not change over time (bti is always the boot image and is always
262144 bytes), so by merging a few of those file, we can get a complete picture
(note that some nodes that existed in older player do not exists anymore so
we really need to merge several ones from different generations).
The advantage of storing all this information in plain text files, is that it
now makes it easy to parse it and produce whatever format we want to use it.
I wrote a python script that parses all this mess and produces a C file and
header with all this information (nwz_db.{c,h}).
Change-Id: Id790581ddd527d64418fe9e4e4df8e0546117b80
2016-11-11 14:40:56 +00:00
|
|
|
{ "nwz-noname", "NONAME", 3, models_nwz_noname, 0 },
|
|
|
|
|
};
|