├── LICENSE
├── Makefile
├── README
├── k5_flash.raw
├── k5prog.c
├── uvk5.h
└── uvk5_original_eeprom.raw


/LICENSE:
--------------------------------------------------------------------------------
  1 |                     GNU GENERAL PUBLIC LICENSE
  2 |                        Version 3, 29 June 2007
  3 | 
  4 |  Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
  5 |  Everyone is permitted to copy and distribute verbatim copies
  6 |  of this license document, but changing it is not allowed.
  7 | 
  8 |                             Preamble
  9 | 
 10 |   The GNU General Public License is a free, copyleft license for
 11 | software and other kinds of works.
 12 | 
 13 |   The licenses for most software and other practical works are designed
 14 | to take away your freedom to share and change the works.  By contrast,
 15 | the GNU General Public License is intended to guarantee your freedom to
 16 | share and change all versions of a program--to make sure it remains free
 17 | software for all its users.  We, the Free Software Foundation, use the
 18 | GNU General Public License for most of our software; it applies also to
 19 | any other work released this way by its authors.  You can apply it to
 20 | your programs, too.
 21 | 
 22 |   When we speak of free software, we are referring to freedom, not
 23 | price.  Our General Public Licenses are designed to make sure that you
 24 | have the freedom to distribute copies of free software (and charge for
 25 | them if you wish), that you receive source code or can get it if you
 26 | want it, that you can change the software or use pieces of it in new
 27 | free programs, and that you know you can do these things.
 28 | 
 29 |   To protect your rights, we need to prevent others from denying you
 30 | these rights or asking you to surrender the rights.  Therefore, you have
 31 | certain responsibilities if you distribute copies of the software, or if
 32 | you modify it: responsibilities to respect the freedom of others.
 33 | 
 34 |   For example, if you distribute copies of such a program, whether
 35 | gratis or for a fee, you must pass on to the recipients the same
 36 | freedoms that you received.  You must make sure that they, too, receive
 37 | or can get the source code.  And you must show them these terms so they
 38 | know their rights.
 39 | 
 40 |   Developers that use the GNU GPL protect your rights with two steps:
 41 | (1) assert copyright on the software, and (2) offer you this License
 42 | giving you legal permission to copy, distribute and/or modify it.
 43 | 
 44 |   For the developers' and authors' protection, the GPL clearly explains
 45 | that there is no warranty for this free software.  For both users' and
 46 | authors' sake, the GPL requires that modified versions be marked as
 47 | changed, so that their problems will not be attributed erroneously to
 48 | authors of previous versions.
 49 | 
 50 |   Some devices are designed to deny users access to install or run
 51 | modified versions of the software inside them, although the manufacturer
 52 | can do so.  This is fundamentally incompatible with the aim of
 53 | protecting users' freedom to change the software.  The systematic
 54 | pattern of such abuse occurs in the area of products for individuals to
 55 | use, which is precisely where it is most unacceptable.  Therefore, we
 56 | have designed this version of the GPL to prohibit the practice for those
 57 | products.  If such problems arise substantially in other domains, we
 58 | stand ready to extend this provision to those domains in future versions
 59 | of the GPL, as needed to protect the freedom of users.
 60 | 
 61 |   Finally, every program is threatened constantly by software patents.
 62 | States should not allow patents to restrict development and use of
 63 | software on general-purpose computers, but in those that do, we wish to
 64 | avoid the special danger that patents applied to a free program could
 65 | make it effectively proprietary.  To prevent this, the GPL assures that
 66 | patents cannot be used to render the program non-free.
 67 | 
 68 |   The precise terms and conditions for copying, distribution and
 69 | modification follow.
 70 | 
 71 |                        TERMS AND CONDITIONS
 72 | 
 73 |   0. Definitions.
 74 | 
 75 |   "This License" refers to version 3 of the GNU General Public License.
 76 | 
 77 |   "Copyright" also means copyright-like laws that apply to other kinds of
 78 | works, such as semiconductor masks.
 79 | 
 80 |   "The Program" refers to any copyrightable work licensed under this
 81 | License.  Each licensee is addressed as "you".  "Licensees" and
 82 | "recipients" may be individuals or organizations.
 83 | 
 84 |   To "modify" a work means to copy from or adapt all or part of the work
 85 | in a fashion requiring copyright permission, other than the making of an
 86 | exact copy.  The resulting work is called a "modified version" of the
 87 | earlier work or a work "based on" the earlier work.
 88 | 
 89 |   A "covered work" means either the unmodified Program or a work based
 90 | on the Program.
 91 | 
 92 |   To "propagate" a work means to do anything with it that, without
 93 | permission, would make you directly or secondarily liable for
 94 | infringement under applicable copyright law, except executing it on a
 95 | computer or modifying a private copy.  Propagation includes copying,
 96 | distribution (with or without modification), making available to the
 97 | public, and in some countries other activities as well.
 98 | 
 99 |   To "convey" a work means any kind of propagation that enables other
100 | parties to make or receive copies.  Mere interaction with a user through
101 | a computer network, with no transfer of a copy, is not conveying.
102 | 
103 |   An interactive user interface displays "Appropriate Legal Notices"
104 | to the extent that it includes a convenient and prominently visible
105 | feature that (1) displays an appropriate copyright notice, and (2)
106 | tells the user that there is no warranty for the work (except to the
107 | extent that warranties are provided), that licensees may convey the
108 | work under this License, and how to view a copy of this License.  If
109 | the interface presents a list of user commands or options, such as a
110 | menu, a prominent item in the list meets this criterion.
111 | 
112 |   1. Source Code.
113 | 
114 |   The "source code" for a work means the preferred form of the work
115 | for making modifications to it.  "Object code" means any non-source
116 | form of a work.
117 | 
118 |   A "Standard Interface" means an interface that either is an official
119 | standard defined by a recognized standards body, or, in the case of
120 | interfaces specified for a particular programming language, one that
121 | is widely used among developers working in that language.
122 | 
123 |   The "System Libraries" of an executable work include anything, other
124 | than the work as a whole, that (a) is included in the normal form of
125 | packaging a Major Component, but which is not part of that Major
126 | Component, and (b) serves only to enable use of the work with that
127 | Major Component, or to implement a Standard Interface for which an
128 | implementation is available to the public in source code form.  A
129 | "Major Component", in this context, means a major essential component
130 | (kernel, window system, and so on) of the specific operating system
131 | (if any) on which the executable work runs, or a compiler used to
132 | produce the work, or an object code interpreter used to run it.
133 | 
134 |   The "Corresponding Source" for a work in object code form means all
135 | the source code needed to generate, install, and (for an executable
136 | work) run the object code and to modify the work, including scripts to
137 | control those activities.  However, it does not include the work's
138 | System Libraries, or general-purpose tools or generally available free
139 | programs which are used unmodified in performing those activities but
140 | which are not part of the work.  For example, Corresponding Source
141 | includes interface definition files associated with source files for
142 | the work, and the source code for shared libraries and dynamically
143 | linked subprograms that the work is specifically designed to require,
144 | such as by intimate data communication or control flow between those
145 | subprograms and other parts of the work.
146 | 
147 |   The Corresponding Source need not include anything that users
148 | can regenerate automatically from other parts of the Corresponding
149 | Source.
150 | 
151 |   The Corresponding Source for a work in source code form is that
152 | same work.
153 | 
154 |   2. Basic Permissions.
155 | 
156 |   All rights granted under this License are granted for the term of
157 | copyright on the Program, and are irrevocable provided the stated
158 | conditions are met.  This License explicitly affirms your unlimited
159 | permission to run the unmodified Program.  The output from running a
160 | covered work is covered by this License only if the output, given its
161 | content, constitutes a covered work.  This License acknowledges your
162 | rights of fair use or other equivalent, as provided by copyright law.
163 | 
164 |   You may make, run and propagate covered works that you do not
165 | convey, without conditions so long as your license otherwise remains
166 | in force.  You may convey covered works to others for the sole purpose
167 | of having them make modifications exclusively for you, or provide you
168 | with facilities for running those works, provided that you comply with
169 | the terms of this License in conveying all material for which you do
170 | not control copyright.  Those thus making or running the covered works
171 | for you must do so exclusively on your behalf, under your direction
172 | and control, on terms that prohibit them from making any copies of
173 | your copyrighted material outside their relationship with you.
174 | 
175 |   Conveying under any other circumstances is permitted solely under
176 | the conditions stated below.  Sublicensing is not allowed; section 10
177 | makes it unnecessary.
178 | 
179 |   3. Protecting Users' Legal Rights From Anti-Circumvention Law.
180 | 
181 |   No covered work shall be deemed part of an effective technological
182 | measure under any applicable law fulfilling obligations under article
183 | 11 of the WIPO copyright treaty adopted on 20 December 1996, or
184 | similar laws prohibiting or restricting circumvention of such
185 | measures.
186 | 
187 |   When you convey a covered work, you waive any legal power to forbid
188 | circumvention of technological measures to the extent such circumvention
189 | is effected by exercising rights under this License with respect to
190 | the covered work, and you disclaim any intention to limit operation or
191 | modification of the work as a means of enforcing, against the work's
192 | users, your or third parties' legal rights to forbid circumvention of
193 | technological measures.
194 | 
195 |   4. Conveying Verbatim Copies.
196 | 
197 |   You may convey verbatim copies of the Program's source code as you
198 | receive it, in any medium, provided that you conspicuously and
199 | appropriately publish on each copy an appropriate copyright notice;
200 | keep intact all notices stating that this License and any
201 | non-permissive terms added in accord with section 7 apply to the code;
202 | keep intact all notices of the absence of any warranty; and give all
203 | recipients a copy of this License along with the Program.
204 | 
205 |   You may charge any price or no price for each copy that you convey,
206 | and you may offer support or warranty protection for a fee.
207 | 
208 |   5. Conveying Modified Source Versions.
209 | 
210 |   You may convey a work based on the Program, or the modifications to
211 | produce it from the Program, in the form of source code under the
212 | terms of section 4, provided that you also meet all of these conditions:
213 | 
214 |     a) The work must carry prominent notices stating that you modified
215 |     it, and giving a relevant date.
216 | 
217 |     b) The work must carry prominent notices stating that it is
218 |     released under this License and any conditions added under section
219 |     7.  This requirement modifies the requirement in section 4 to
220 |     "keep intact all notices".
221 | 
222 |     c) You must license the entire work, as a whole, under this
223 |     License to anyone who comes into possession of a copy.  This
224 |     License will therefore apply, along with any applicable section 7
225 |     additional terms, to the whole of the work, and all its parts,
226 |     regardless of how they are packaged.  This License gives no
227 |     permission to license the work in any other way, but it does not
228 |     invalidate such permission if you have separately received it.
229 | 
230 |     d) If the work has interactive user interfaces, each must display
231 |     Appropriate Legal Notices; however, if the Program has interactive
232 |     interfaces that do not display Appropriate Legal Notices, your
233 |     work need not make them do so.
234 | 
235 |   A compilation of a covered work with other separate and independent
236 | works, which are not by their nature extensions of the covered work,
237 | and which are not combined with it such as to form a larger program,
238 | in or on a volume of a storage or distribution medium, is called an
239 | "aggregate" if the compilation and its resulting copyright are not
240 | used to limit the access or legal rights of the compilation's users
241 | beyond what the individual works permit.  Inclusion of a covered work
242 | in an aggregate does not cause this License to apply to the other
243 | parts of the aggregate.
244 | 
245 |   6. Conveying Non-Source Forms.
246 | 
247 |   You may convey a covered work in object code form under the terms
248 | of sections 4 and 5, provided that you also convey the
249 | machine-readable Corresponding Source under the terms of this License,
250 | in one of these ways:
251 | 
252 |     a) Convey the object code in, or embodied in, a physical product
253 |     (including a physical distribution medium), accompanied by the
254 |     Corresponding Source fixed on a durable physical medium
255 |     customarily used for software interchange.
256 | 
257 |     b) Convey the object code in, or embodied in, a physical product
258 |     (including a physical distribution medium), accompanied by a
259 |     written offer, valid for at least three years and valid for as
260 |     long as you offer spare parts or customer support for that product
261 |     model, to give anyone who possesses the object code either (1) a
262 |     copy of the Corresponding Source for all the software in the
263 |     product that is covered by this License, on a durable physical
264 |     medium customarily used for software interchange, for a price no
265 |     more than your reasonable cost of physically performing this
266 |     conveying of source, or (2) access to copy the
267 |     Corresponding Source from a network server at no charge.
268 | 
269 |     c) Convey individual copies of the object code with a copy of the
270 |     written offer to provide the Corresponding Source.  This
271 |     alternative is allowed only occasionally and noncommercially, and
272 |     only if you received the object code with such an offer, in accord
273 |     with subsection 6b.
274 | 
275 |     d) Convey the object code by offering access from a designated
276 |     place (gratis or for a charge), and offer equivalent access to the
277 |     Corresponding Source in the same way through the same place at no
278 |     further charge.  You need not require recipients to copy the
279 |     Corresponding Source along with the object code.  If the place to
280 |     copy the object code is a network server, the Corresponding Source
281 |     may be on a different server (operated by you or a third party)
282 |     that supports equivalent copying facilities, provided you maintain
283 |     clear directions next to the object code saying where to find the
284 |     Corresponding Source.  Regardless of what server hosts the
285 |     Corresponding Source, you remain obligated to ensure that it is
286 |     available for as long as needed to satisfy these requirements.
287 | 
288 |     e) Convey the object code using peer-to-peer transmission, provided
289 |     you inform other peers where the object code and Corresponding
290 |     Source of the work are being offered to the general public at no
291 |     charge under subsection 6d.
292 | 
293 |   A separable portion of the object code, whose source code is excluded
294 | from the Corresponding Source as a System Library, need not be
295 | included in conveying the object code work.
296 | 
297 |   A "User Product" is either (1) a "consumer product", which means any
298 | tangible personal property which is normally used for personal, family,
299 | or household purposes, or (2) anything designed or sold for incorporation
300 | into a dwelling.  In determining whether a product is a consumer product,
301 | doubtful cases shall be resolved in favor of coverage.  For a particular
302 | product received by a particular user, "normally used" refers to a
303 | typical or common use of that class of product, regardless of the status
304 | of the particular user or of the way in which the particular user
305 | actually uses, or expects or is expected to use, the product.  A product
306 | is a consumer product regardless of whether the product has substantial
307 | commercial, industrial or non-consumer uses, unless such uses represent
308 | the only significant mode of use of the product.
309 | 
310 |   "Installation Information" for a User Product means any methods,
311 | procedures, authorization keys, or other information required to install
312 | and execute modified versions of a covered work in that User Product from
313 | a modified version of its Corresponding Source.  The information must
314 | suffice to ensure that the continued functioning of the modified object
315 | code is in no case prevented or interfered with solely because
316 | modification has been made.
317 | 
318 |   If you convey an object code work under this section in, or with, or
319 | specifically for use in, a User Product, and the conveying occurs as
320 | part of a transaction in which the right of possession and use of the
321 | User Product is transferred to the recipient in perpetuity or for a
322 | fixed term (regardless of how the transaction is characterized), the
323 | Corresponding Source conveyed under this section must be accompanied
324 | by the Installation Information.  But this requirement does not apply
325 | if neither you nor any third party retains the ability to install
326 | modified object code on the User Product (for example, the work has
327 | been installed in ROM).
328 | 
329 |   The requirement to provide Installation Information does not include a
330 | requirement to continue to provide support service, warranty, or updates
331 | for a work that has been modified or installed by the recipient, or for
332 | the User Product in which it has been modified or installed.  Access to a
333 | network may be denied when the modification itself materially and
334 | adversely affects the operation of the network or violates the rules and
335 | protocols for communication across the network.
336 | 
337 |   Corresponding Source conveyed, and Installation Information provided,
338 | in accord with this section must be in a format that is publicly
339 | documented (and with an implementation available to the public in
340 | source code form), and must require no special password or key for
341 | unpacking, reading or copying.
342 | 
343 |   7. Additional Terms.
344 | 
345 |   "Additional permissions" are terms that supplement the terms of this
346 | License by making exceptions from one or more of its conditions.
347 | Additional permissions that are applicable to the entire Program shall
348 | be treated as though they were included in this License, to the extent
349 | that they are valid under applicable law.  If additional permissions
350 | apply only to part of the Program, that part may be used separately
351 | under those permissions, but the entire Program remains governed by
352 | this License without regard to the additional permissions.
353 | 
354 |   When you convey a copy of a covered work, you may at your option
355 | remove any additional permissions from that copy, or from any part of
356 | it.  (Additional permissions may be written to require their own
357 | removal in certain cases when you modify the work.)  You may place
358 | additional permissions on material, added by you to a covered work,
359 | for which you have or can give appropriate copyright permission.
360 | 
361 |   Notwithstanding any other provision of this License, for material you
362 | add to a covered work, you may (if authorized by the copyright holders of
363 | that material) supplement the terms of this License with terms:
364 | 
365 |     a) Disclaiming warranty or limiting liability differently from the
366 |     terms of sections 15 and 16 of this License; or
367 | 
368 |     b) Requiring preservation of specified reasonable legal notices or
369 |     author attributions in that material or in the Appropriate Legal
370 |     Notices displayed by works containing it; or
371 | 
372 |     c) Prohibiting misrepresentation of the origin of that material, or
373 |     requiring that modified versions of such material be marked in
374 |     reasonable ways as different from the original version; or
375 | 
376 |     d) Limiting the use for publicity purposes of names of licensors or
377 |     authors of the material; or
378 | 
379 |     e) Declining to grant rights under trademark law for use of some
380 |     trade names, trademarks, or service marks; or
381 | 
382 |     f) Requiring indemnification of licensors and authors of that
383 |     material by anyone who conveys the material (or modified versions of
384 |     it) with contractual assumptions of liability to the recipient, for
385 |     any liability that these contractual assumptions directly impose on
386 |     those licensors and authors.
387 | 
388 |   All other non-permissive additional terms are considered "further
389 | restrictions" within the meaning of section 10.  If the Program as you
390 | received it, or any part of it, contains a notice stating that it is
391 | governed by this License along with a term that is a further
392 | restriction, you may remove that term.  If a license document contains
393 | a further restriction but permits relicensing or conveying under this
394 | License, you may add to a covered work material governed by the terms
395 | of that license document, provided that the further restriction does
396 | not survive such relicensing or conveying.
397 | 
398 |   If you add terms to a covered work in accord with this section, you
399 | must place, in the relevant source files, a statement of the
400 | additional terms that apply to those files, or a notice indicating
401 | where to find the applicable terms.
402 | 
403 |   Additional terms, permissive or non-permissive, may be stated in the
404 | form of a separately written license, or stated as exceptions;
405 | the above requirements apply either way.
406 | 
407 |   8. Termination.
408 | 
409 |   You may not propagate or modify a covered work except as expressly
410 | provided under this License.  Any attempt otherwise to propagate or
411 | modify it is void, and will automatically terminate your rights under
412 | this License (including any patent licenses granted under the third
413 | paragraph of section 11).
414 | 
415 |   However, if you cease all violation of this License, then your
416 | license from a particular copyright holder is reinstated (a)
417 | provisionally, unless and until the copyright holder explicitly and
418 | finally terminates your license, and (b) permanently, if the copyright
419 | holder fails to notify you of the violation by some reasonable means
420 | prior to 60 days after the cessation.
421 | 
422 |   Moreover, your license from a particular copyright holder is
423 | reinstated permanently if the copyright holder notifies you of the
424 | violation by some reasonable means, this is the first time you have
425 | received notice of violation of this License (for any work) from that
426 | copyright holder, and you cure the violation prior to 30 days after
427 | your receipt of the notice.
428 | 
429 |   Termination of your rights under this section does not terminate the
430 | licenses of parties who have received copies or rights from you under
431 | this License.  If your rights have been terminated and not permanently
432 | reinstated, you do not qualify to receive new licenses for the same
433 | material under section 10.
434 | 
435 |   9. Acceptance Not Required for Having Copies.
436 | 
437 |   You are not required to accept this License in order to receive or
438 | run a copy of the Program.  Ancillary propagation of a covered work
439 | occurring solely as a consequence of using peer-to-peer transmission
440 | to receive a copy likewise does not require acceptance.  However,
441 | nothing other than this License grants you permission to propagate or
442 | modify any covered work.  These actions infringe copyright if you do
443 | not accept this License.  Therefore, by modifying or propagating a
444 | covered work, you indicate your acceptance of this License to do so.
445 | 
446 |   10. Automatic Licensing of Downstream Recipients.
447 | 
448 |   Each time you convey a covered work, the recipient automatically
449 | receives a license from the original licensors, to run, modify and
450 | propagate that work, subject to this License.  You are not responsible
451 | for enforcing compliance by third parties with this License.
452 | 
453 |   An "entity transaction" is a transaction transferring control of an
454 | organization, or substantially all assets of one, or subdividing an
455 | organization, or merging organizations.  If propagation of a covered
456 | work results from an entity transaction, each party to that
457 | transaction who receives a copy of the work also receives whatever
458 | licenses to the work the party's predecessor in interest had or could
459 | give under the previous paragraph, plus a right to possession of the
460 | Corresponding Source of the work from the predecessor in interest, if
461 | the predecessor has it or can get it with reasonable efforts.
462 | 
463 |   You may not impose any further restrictions on the exercise of the
464 | rights granted or affirmed under this License.  For example, you may
465 | not impose a license fee, royalty, or other charge for exercise of
466 | rights granted under this License, and you may not initiate litigation
467 | (including a cross-claim or counterclaim in a lawsuit) alleging that
468 | any patent claim is infringed by making, using, selling, offering for
469 | sale, or importing the Program or any portion of it.
470 | 
471 |   11. Patents.
472 | 
473 |   A "contributor" is a copyright holder who authorizes use under this
474 | License of the Program or a work on which the Program is based.  The
475 | work thus licensed is called the contributor's "contributor version".
476 | 
477 |   A contributor's "essential patent claims" are all patent claims
478 | owned or controlled by the contributor, whether already acquired or
479 | hereafter acquired, that would be infringed by some manner, permitted
480 | by this License, of making, using, or selling its contributor version,
481 | but do not include claims that would be infringed only as a
482 | consequence of further modification of the contributor version.  For
483 | purposes of this definition, "control" includes the right to grant
484 | patent sublicenses in a manner consistent with the requirements of
485 | this License.
486 | 
487 |   Each contributor grants you a non-exclusive, worldwide, royalty-free
488 | patent license under the contributor's essential patent claims, to
489 | make, use, sell, offer for sale, import and otherwise run, modify and
490 | propagate the contents of its contributor version.
491 | 
492 |   In the following three paragraphs, a "patent license" is any express
493 | agreement or commitment, however denominated, not to enforce a patent
494 | (such as an express permission to practice a patent or covenant not to
495 | sue for patent infringement).  To "grant" such a patent license to a
496 | party means to make such an agreement or commitment not to enforce a
497 | patent against the party.
498 | 
499 |   If you convey a covered work, knowingly relying on a patent license,
500 | and the Corresponding Source of the work is not available for anyone
501 | to copy, free of charge and under the terms of this License, through a
502 | publicly available network server or other readily accessible means,
503 | then you must either (1) cause the Corresponding Source to be so
504 | available, or (2) arrange to deprive yourself of the benefit of the
505 | patent license for this particular work, or (3) arrange, in a manner
506 | consistent with the requirements of this License, to extend the patent
507 | license to downstream recipients.  "Knowingly relying" means you have
508 | actual knowledge that, but for the patent license, your conveying the
509 | covered work in a country, or your recipient's use of the covered work
510 | in a country, would infringe one or more identifiable patents in that
511 | country that you have reason to believe are valid.
512 | 
513 |   If, pursuant to or in connection with a single transaction or
514 | arrangement, you convey, or propagate by procuring conveyance of, a
515 | covered work, and grant a patent license to some of the parties
516 | receiving the covered work authorizing them to use, propagate, modify
517 | or convey a specific copy of the covered work, then the patent license
518 | you grant is automatically extended to all recipients of the covered
519 | work and works based on it.
520 | 
521 |   A patent license is "discriminatory" if it does not include within
522 | the scope of its coverage, prohibits the exercise of, or is
523 | conditioned on the non-exercise of one or more of the rights that are
524 | specifically granted under this License.  You may not convey a covered
525 | work if you are a party to an arrangement with a third party that is
526 | in the business of distributing software, under which you make payment
527 | to the third party based on the extent of your activity of conveying
528 | the work, and under which the third party grants, to any of the
529 | parties who would receive the covered work from you, a discriminatory
530 | patent license (a) in connection with copies of the covered work
531 | conveyed by you (or copies made from those copies), or (b) primarily
532 | for and in connection with specific products or compilations that
533 | contain the covered work, unless you entered into that arrangement,
534 | or that patent license was granted, prior to 28 March 2007.
535 | 
536 |   Nothing in this License shall be construed as excluding or limiting
537 | any implied license or other defenses to infringement that may
538 | otherwise be available to you under applicable patent law.
539 | 
540 |   12. No Surrender of Others' Freedom.
541 | 
542 |   If conditions are imposed on you (whether by court order, agreement or
543 | otherwise) that contradict the conditions of this License, they do not
544 | excuse you from the conditions of this License.  If you cannot convey a
545 | covered work so as to satisfy simultaneously your obligations under this
546 | License and any other pertinent obligations, then as a consequence you may
547 | not convey it at all.  For example, if you agree to terms that obligate you
548 | to collect a royalty for further conveying from those to whom you convey
549 | the Program, the only way you could satisfy both those terms and this
550 | License would be to refrain entirely from conveying the Program.
551 | 
552 |   13. Use with the GNU Affero General Public License.
553 | 
554 |   Notwithstanding any other provision of this License, you have
555 | permission to link or combine any covered work with a work licensed
556 | under version 3 of the GNU Affero General Public License into a single
557 | combined work, and to convey the resulting work.  The terms of this
558 | License will continue to apply to the part which is the covered work,
559 | but the special requirements of the GNU Affero General Public License,
560 | section 13, concerning interaction through a network will apply to the
561 | combination as such.
562 | 
563 |   14. Revised Versions of this License.
564 | 
565 |   The Free Software Foundation may publish revised and/or new versions of
566 | the GNU General Public License from time to time.  Such new versions will
567 | be similar in spirit to the present version, but may differ in detail to
568 | address new problems or concerns.
569 | 
570 |   Each version is given a distinguishing version number.  If the
571 | Program specifies that a certain numbered version of the GNU General
572 | Public License "or any later version" applies to it, you have the
573 | option of following the terms and conditions either of that numbered
574 | version or of any later version published by the Free Software
575 | Foundation.  If the Program does not specify a version number of the
576 | GNU General Public License, you may choose any version ever published
577 | by the Free Software Foundation.
578 | 
579 |   If the Program specifies that a proxy can decide which future
580 | versions of the GNU General Public License can be used, that proxy's
581 | public statement of acceptance of a version permanently authorizes you
582 | to choose that version for the Program.
583 | 
584 |   Later license versions may give you additional or different
585 | permissions.  However, no additional obligations are imposed on any
586 | author or copyright holder as a result of your choosing to follow a
587 | later version.
588 | 
589 |   15. Disclaimer of Warranty.
590 | 
591 |   THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
592 | APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
593 | HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
594 | OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
595 | THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
596 | PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
597 | IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
598 | ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
599 | 
600 |   16. Limitation of Liability.
601 | 
602 |   IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
603 | WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
604 | THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
605 | GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
606 | USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
607 | DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
608 | PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
609 | EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
610 | SUCH DAMAGES.
611 | 
612 |   17. Interpretation of Sections 15 and 16.
613 | 
614 |   If the disclaimer of warranty and limitation of liability provided
615 | above cannot be given local legal effect according to their terms,
616 | reviewing courts shall apply local law that most closely approximates
617 | an absolute waiver of all civil liability in connection with the
618 | Program, unless a warranty or assumption of liability accompanies a
619 | copy of the Program in return for a fee.
620 | 
621 |                      END OF TERMS AND CONDITIONS
622 | 
623 |             How to Apply These Terms to Your New Programs
624 | 
625 |   If you develop a new program, and you want it to be of the greatest
626 | possible use to the public, the best way to achieve this is to make it
627 | free software which everyone can redistribute and change under these terms.
628 | 
629 |   To do so, attach the following notices to the program.  It is safest
630 | to attach them to the start of each source file to most effectively
631 | state the exclusion of warranty; and each file should have at least
632 | the "copyright" line and a pointer to where the full notice is found.
633 | 
634 |     <one line to give the program's name and a brief idea of what it does.>
635 |     Copyright (C) <year>  <name of author>
636 | 
637 |     This program is free software: you can redistribute it and/or modify
638 |     it under the terms of the GNU General Public License as published by
639 |     the Free Software Foundation, either version 3 of the License, or
640 |     (at your option) any later version.
641 | 
642 |     This program is distributed in the hope that it will be useful,
643 |     but WITHOUT ANY WARRANTY; without even the implied warranty of
644 |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
645 |     GNU General Public License for more details.
646 | 
647 |     You should have received a copy of the GNU General Public License
648 |     along with this program.  If not, see <https://www.gnu.org/licenses/>.
649 | 
650 | Also add information on how to contact you by electronic and paper mail.
651 | 
652 |   If the program does terminal interaction, make it output a short
653 | notice like this when it starts in an interactive mode:
654 | 
655 |     <program>  Copyright (C) <year>  <name of author>
656 |     This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
657 |     This is free software, and you are welcome to redistribute it
658 |     under certain conditions; type `show c' for details.
659 | 
660 | The hypothetical commands `show w' and `show c' should show the appropriate
661 | parts of the General Public License.  Of course, your program's commands
662 | might be different; for a GUI interface, you would use an "about box".
663 | 
664 |   You should also get your employer (if you work as a programmer) or school,
665 | if any, to sign a "copyright disclaimer" for the program, if necessary.
666 | For more information on this, and how to apply and follow the GNU GPL, see
667 | <https://www.gnu.org/licenses/>.
668 | 
669 |   The GNU General Public License does not permit incorporating your program
670 | into proprietary programs.  If your program is a subroutine library, you
671 | may consider it more useful to permit linking proprietary applications with
672 | the library.  If this is what you want to do, use the GNU Lesser General
673 | Public License instead of this License.  But first, please read
674 | <https://www.gnu.org/licenses/why-not-lgpl.html>.
675 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
 1 | # Makefile for k5prog
 2 | 
 3 | CC=gcc
 4 | COPTS=-g
 5 | 
 6 | default: k5prog
 7 | 
 8 | k5prog: k5prog.c uvk5.h
 9 | 	$(CC) $(COPTS) k5prog.c -o k5prog
10 | 
11 | clean:
12 | 	rm k5prog
13 | 


--------------------------------------------------------------------------------
/README:
--------------------------------------------------------------------------------
  1 | k5prog - Quansheng UV-K5 EEPROM programmer v0.1
  2 | (c) 2023 Jacek Lipkowski <sq5bpf@lipkowski.org>
  3 | 
  4 | This program can read and write the eeprom of Quansheng UV-K5.
  5 | It can read/write arbitrary data, and might be useful for making backups of
  6 | the configuration, mass programming of radios or reverse engineering of 
  7 | the radio configuration. Please note that it is probably possible to break 
  8 | your radio by writing a bad configuration to it, so please use at your own 
  9 | risk. 
 10 | 
 11 | Note that this program does not edit the contents of the eeprom. Use an
 12 | external hex editor.
 13 | 
 14 | 
 15 | The program is written to (hopefully) run on POSIX systems. Testing was done 
 16 | on GNU/Linux, but MacOS X and windows under cygwin should work too. 
 17 | 
 18 | For licensing see the file LICENSE.
 19 | 
 20 | 
 21 | ---- Usage ----
 22 | 
 23 | For a basic usage use -r to read eeprom, -w to write eeprom. The -v option
 24 | gives more verbosity.
 25 | 
 26 | Read configuration:
 27 | 
 28 | sq5bpf@chronos:~/k5prog$ ./k5prog -r -v
 29 | Quansheng UV-K5 EEPROM programmer v0.2 (c) 2023 Jacek Lipkowski <sq5bpf@lipkowski.org>
 30 | 
 31 | k5_prepare: try 0
 32 | ******  Connected to firmware version: [k5_2.01.23]
 33 | Sucessfuly read eeprom
 34 | 
 35 | 
 36 | The eeprom contents are written to the file k5_eeprom.raw, this can be
 37 | changed with the -f option.
 38 | 
 39 | 
 40 | Write configuration from file k5_eeprom.raw:
 41 | 
 42 | sq5bpf@chronos:~/chirp/k5prog$ ./k5prog -w -v
 43 | Quansheng UV-K5 EEPROM programmer v0.2 (c) 2023 Jacek Lipkowski <sq5bpf@lipkowski.org>
 44 | 
 45 | k5_prepare: try 0
 46 | ******  Connected to firmware version: [k5_2.01.23]
 47 | Read file k5_eeprom.raw success
 48 | Sucessfuly wrote eeprom
 49 | 
 50 | 
 51 | 
 52 | The -w option writes only the memory blocks which are written by the original
 53 | radio software, in the same order. 
 54 | 
 55 | The -W option is a bit more brave, it writes all memory upto 0x1d00. I _think_
 56 | that the radio has calibration data above this address, but of course this is
 57 | not certain, because this knowledge is a result of reverse engineering, and not
 58 | information from the manufacturer.
 59 | 
 60 | 
 61 | The -B option is the "brick my radio" mode. It writes all memory, possibly 
 62 | allowing overwriting of calibration data (if there is any) or other data which
 63 | may be critical to the proper functioning of your radio. I have used this on
 64 | my radio, and it still works but please be extra-careful.
 65 | 
 66 | 
 67 | 
 68 | Other configuration options are:
 69 | 
 70 | Quansheng UV-K5 EEPROM programmer v0.2 (c) 2023 Jacek Lipkowski <sq5bpf@lipkowski.org>
 71 | 
 72 | cmdline opts:
 73 | -f <file>       filename that contains the eeprom dump (default: k5_eeprom.raw)
 74 | -r      read eeprom
 75 | -w      write eeprom like the original software does
 76 | -W      write most of the eeprom (but without what i think is calibration data)
 77 | -B      write ALL of the eeprom (the "brick my radio" mode)
 78 | -p <port>       device name (default: /dev/ttyUSB0)
 79 | -s <speed>      serial speed (default: 38400, the UV-K5 doesn't accept any other speed)
 80 | -h      print this help
 81 | -v      be verbose, use multiple times for more verbosity
 82 | 
 83 | 
 84 | 
 85 | ---- Compiling ----
 86 | 
 87 | This software was tested to compile using gcc on GNU/Linux systems, using a
 88 | simple makefile:
 89 | 
 90 | sq5bpf@dellix:~/k5prog-0.1$ make
 91 | gcc -O2 k5prog.c -o k5prog
 92 | 
 93 | Other POSIX platforms should work also, including MacOS X. 
 94 | 
 95 | The software compiles under Cygwin/Microsoft Windows, but has not been tested.
 96 | According to the cygwin documentation you should use /dev/comX to use port comX
 97 | (for example using com6: k5prog.exe -v -r -p /dev/com6)
 98 | 
 99 | 
100 | If port this to another platform, or do anything interesting with this
101 | software, tell me about it.
102 | 
103 | ---- Other uses ----
104 | 
105 | The file uvk5_original_eeprom.raw contains an eeprom downloaded from a UV-K5
106 | radio.  Maybe it can be used to resurrect another radio of the same type 
107 | if it was broken (perhaps by the use of this software :).
108 | 
109 | 
110 | 
111 | 
112 | ---- Protocol ----
113 | 
114 | The programming protocol used by this software has been reverse engineered
115 | by observing communications between the radio and the original programming
116 | software. It is not a variation of the typical Baofeng-like protocol.
117 | 
118 | 
119 | The format of the datagram sent to the radio is:
120 | 
121 | 0xAB 0xCD len 0x00 <data bytes> <2 bytes CRC> 0xDC 0xBA
122 | 
123 | The length is the length od the data bytes.
124 | 
125 | The data is protected by a typical CRC-16 xmodem algorithm.
126 | The data bytes and the CRC are obfuscated by xor-in it with an 8-byte 
127 | sequence.
128 | 
129 | Fortunately the eeprom data contains a lot of 0xFF and 0x00 bytes, so the XOR
130 | sequence is easy to find by observing the traffic.
131 | 
132 | 
133 | The datagram sent from the radio is the same, but the CRC field is set to
134 | 0xFFFF. This shows that the CRC is not for data integrity, but for further
135 | obfuscation (same as the XOR).
136 | 
137 | 
138 | I intend to publish a further description of the protocol, and the eeprom
139 | contents, meanwhile the sources can be used as documentation.
140 | 
141 | 
142 | VY 73
143 | 
144 | Jacek / SQ5BPF
145 | 
146 | 


--------------------------------------------------------------------------------
/k5_flash.raw:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/piotr022/k5prog/ef73378ec80d9e0351100bfd649d9189f4502fd4/k5_flash.raw


--------------------------------------------------------------------------------
/k5prog.c:
--------------------------------------------------------------------------------
   1 | /* Quansheng UV-K5 EEPROM programmer v0.4 
   2 |  * (c) 2023 Jacek Lipkowski <sq5bpf@lipkowski.org>
   3 |  *
   4 |  * This program can read and write the eeprom of Quansheng UVK5 Mark II 
   5 |  * and probably other similar radios via the serial port. 
   6 |  *
   7 |  * It can read/write arbitrary data, and might be useful for reverse
   8 |  * engineering the radio configuration.
   9 |  *
  10 |  * It can also flash you radio, which has a very high probability of
  11 |  * permanently breaking your radio. The flash image is an unencrypted
  12 |  * image, without the version inserted at 0x2000.
  13 |  *
  14 |  * Use at your own risk. 
  15 |  *
  16 |  *
  17 |  * This program is licensed under the GNU GENERAL PUBLIC LICENSE v3
  18 |  * License text avaliable at: http://www.gnu.org/copyleft/gpl.html 
  19 |  */
  20 | 
  21 | /*
  22 |  *
  23 |  * This program is free software: you can redistribute it and/or modify
  24 |  * it under the terms of the GNU General Public License as published by
  25 |  * the Free Software Foundation, either version 3 of the License, or
  26 |  * (at your option) any later version.
  27 |  *
  28 |  * This program is distributed in the hope that it will be useful,
  29 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  30 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  31 |  * GNU General Public License for more details.
  32 |  *
  33 |  * You should have received a copy of the GNU General Public License
  34 |  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  35 |  *
  36 |  */
  37 | 
  38 | #include <sys/types.h>
  39 | #include <sys/stat.h>
  40 | #include <sys/select.h>
  41 | #include <fcntl.h>
  42 | #include <string.h>
  43 | #include <errno.h>
  44 | #include <stdlib.h>
  45 | #include <termios.h>
  46 | #include <unistd.h>
  47 | #include <stdio.h>
  48 | #include <getopt.h>
  49 | #include <ctype.h>
  50 | #include <stdint.h>
  51 | #include "uvk5.h"
  52 | 
  53 | #define VERSION "Quansheng UV-K5 EEPROM programmer v0.4 (c) 2023 Jacek Lipkowski <sq5bpf@lipkowski.org>"
  54 | 
  55 | #define MODE_NONE 0
  56 | #define MODE_READ 1
  57 | #define MODE_WRITE 2
  58 | #define MODE_WRITE_MOST 3
  59 | #define MODE_WRITE_ALL 4
  60 | #define MODE_FLASH_DEBUG 5
  61 | #define MODE_FLASH 6
  62 | 
  63 | 
  64 | #define UVK5_EEPROM_SIZE 0x2000
  65 | #define UVK5_EEPROM_SIZE_WITHOUT_CALIBRATION 0x1d00
  66 | #define UVK5_EEPROM_BLOCKSIZE 0x80
  67 | #define UVK5_PREPARE_TRIES 10
  68 | 
  69 | /* actually the flash is bigger, but there is a bootloader at 0xf000 that we don't want to overwrite 
  70 |  * if you're really brave, then you can modify the code by changing UVK5_MAX_FLASH_SIZE to 0x10000
  71 |  * and probably flash the bootloader too, but i would really advise against doing this
  72 |  *
  73 |  * maybe at some point i will make a command line flag for this
  74 |  */
  75 | #define UVK5_MAX_FLASH_SIZE 0xf000 
  76 | #define UVK5_FLASH_BLOCKSIZE 0x100
  77 | 
  78 | #define DEFAULT_SERIAL_PORT "/dev/ttyUSB0"
  79 | #define DEFAULT_FILE_NAME "k5_eeprom.raw"
  80 | #define DEFAULT_FLASH_NAME "k5_flash.raw"
  81 | 
  82 | /* globals */
  83 | speed_t ser_speed=B38400;
  84 | char *ser_port=DEFAULT_SERIAL_PORT;
  85 | int verbose=0;
  86 | int mode=MODE_NONE;
  87 | char *file=DEFAULT_FILE_NAME;
  88 | char *flash_file=DEFAULT_FLASH_NAME;
  89 | 
  90 | int write_offset=0;
  91 | int write_length=-1;
  92 | 
  93 | int i_know_what_im_doing=0; /* flag the user sets to confirm that he thinks he knows what he's doing */
  94 | 
  95 | struct k5_command {
  96 | 	unsigned char *cmd;
  97 | 	int len;
  98 | 	unsigned char *obfuscated_cmd;
  99 | 	int obfuscated_len;
 100 | 	int crcok;
 101 | };
 102 | 
 103 | /**** commands ********/
 104 | unsigned char uvk5_hello2[]={0x14, 0x05, 0x04, 0x00, 0x9f, 0x25, 0x5a, 0x64}; 
 105 | 
 106 | /* commands:
 107 |  * 0x14 - hello
 108 |  * 0x1b - read eeprom
 109 |  * 0x1d - write eeprom
 110 |  * 0xdd - reset radio
 111 |  */
 112 | 
 113 | /*
 114 |  * flash commands:
 115 |  * 0x30 - say hello to the radio and present the version (reply is also 0x18)
 116 |  * 0x19 - send flash block (reply from radio is 0x1a)
 117 |  *
 118 |  * from the radio:
 119 |  * 0x18 - broadcast from the radio when flash mode is enabled
 120 |  * 
 121 |  *
 122 |  */
 123 | 
 124 | /* the last 6 bytes have to be the same for each "session" */
 125 | unsigned char uvk5_hello[]={ 0x14,  0x5,  0x4,  0x0,  0x6a,  0x39,  0x57,  0x64 };
 126 | unsigned char uvk5_readmem1[]={ 0x1b,  0x5,  0x8,  0x0,  0x80,  0xe,  0x80,  0x0,  0x6a,  0x39,  0x57,  0x64 }; /* byte6 - length (max 0x80), byte 4 (lsb) ,5 (msb)  address */
 127 | unsigned char uvk5_writemem1[]={ 0x1d, 0x5, 0x18, 0x0, 0x50, 0xf, 0x10, 0x0, 0x14, 0xad, 0x5c, 0x64, 0x43, 0x48, 0x30, 0x30, 0x31, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 }; /* byte3 - command length, byte6 - data to be written length, byte4 - (lsb) byte5( msb) address, byte12-end data */
 128 | 
 129 | unsigned char uvk5_reset[]={ 0xdd,  0x5,  0x0,  0x0 };
 130 | 
 131 | /* terrible hexdump ripped from some old code, please don't look */
 132 | void hdump(unsigned char *buf,int len)
 133 | {
 134 | 	int tmp1;
 135 | 	char adump[80];
 136 | 	int tmp2=0;
 137 | 	int tmp3=0;
 138 | 	unsigned char sss;
 139 | 	char hexz[]="0123456789abcdef";
 140 | 
 141 | 	int lasttmp;
 142 | 
 143 | 	printf("\n0x%6.6x |0 |1 |2 |3 |4 |5 |6 |7 |8 |9 |a |b |c |d |e |f |\n",len);
 144 | 	printf("---------+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+------------\n");
 145 | 
 146 | 	memset(&adump,' ',78);
 147 | 	adump[78]=0;
 148 | 
 149 | 	for (tmp1=0; tmp1<len; tmp1++)
 150 | 	{
 151 | 		tmp2=tmp1%16;
 152 | 		if (tmp2==0) {
 153 | 			if (tmp1!=0)  { printf("0x%6.6x: %.69s\n",tmp3,adump); lasttmp=tmp1; }
 154 | 			memset(&adump,' ',78);
 155 | 			adump[78]=0;
 156 | 			tmp3=tmp1;
 157 | 		}
 158 | 		sss=buf[tmp1];
 159 | 		adump[tmp2*3]=hexz[sss/16];
 160 | 		adump[tmp2*3+1]=hexz[sss%16];
 161 | 
 162 | 		if (isprint(sss)) { adump[tmp2+50]=sss; } else adump[tmp2+50]='.';
 163 | 	}
 164 | 	//if (((tmp1%16)!=0)||(len==16)) printf("0x%6.6x: %.69s\n",tmp3,adump);
 165 | 	if (lasttmp!=tmp1) printf("0x%6.6x: %.69s\n",tmp3,adump);
 166 | }
 167 | 
 168 | int openport(char *port,speed_t speed)
 169 | {
 170 | 	int fd;
 171 | 	struct termios my_termios;
 172 | 
 173 | 	fd = open(port, O_RDWR | O_NOCTTY);
 174 | 
 175 | 	if (fd < 0)
 176 | 	{
 177 | 		printf("open error %d %s\n", errno, strerror(errno));
 178 | 		return(-1);
 179 | 	}
 180 | 
 181 | 	if (tcgetattr(fd, &my_termios))
 182 | 	{
 183 | 		printf("tcgetattr error %d %s\n", errno, strerror(errno));
 184 | 		return(-1);
 185 | 	}
 186 | 
 187 | 	if (tcflush(fd, TCIFLUSH))
 188 | 	{
 189 | 		printf("tcgetattr error %d %s\n", errno, strerror(errno));
 190 | 		return(-1);
 191 | 	}
 192 | 
 193 | 
 194 | 	my_termios.c_cflag =  CS8 |CREAD | CLOCAL | HUPCL;
 195 | 	cfmakeraw(&my_termios);
 196 | 	cfsetospeed(&my_termios, speed);
 197 | 	if (	tcsetattr(fd, TCSANOW, &my_termios))
 198 | 	{
 199 | 		printf("tcsetattr error %d %s\n", errno, strerror(errno));
 200 | 		return(-1);
 201 | 	}
 202 | 
 203 | 
 204 | 	return(fd);
 205 | 
 206 | }
 207 | 
 208 | /* read with timeout */
 209 | int read_timeout(int fd, unsigned char *buf, int maxlen, int timeout)
 210 | {
 211 | 	fd_set rfd;
 212 | 	int len=0;
 213 | 	int ret;
 214 | 	struct timeval tv;
 215 | 	int nr;
 216 | 	unsigned char *buf2;
 217 | 	buf2=buf;
 218 | 	FD_ZERO(&rfd);
 219 | 
 220 | 	while(1) {
 221 | 		FD_SET(fd,&rfd);
 222 | 		tv.tv_sec=timeout/1000;
 223 | 		tv.tv_usec=(timeout%1000)/1000;
 224 | 
 225 | 		ret=select(fd+1,&rfd,0,0,&tv);
 226 | 
 227 | 		if (FD_ISSET(fd,&rfd)) {
 228 | 			nr=read(fd,buf,maxlen);
 229 | 
 230 | 			len=len+nr;
 231 | 			buf=buf+nr;
 232 | 			if (nr>=0) maxlen=maxlen-nr;
 233 | 			if (maxlen==0) break;
 234 | 		} 
 235 | 
 236 | 
 237 | 		if (ret==0)  {
 238 | 			fprintf(stderr,"read_timeout\n");
 239 | 			/* error albo timeout */
 240 | 			break;
 241 | 		}
 242 | 
 243 | 	}
 244 | 	if (verbose>2) {
 245 | 		printf("RXRXRX:\n");
 246 | 		hdump(buf2,len);
 247 | 	}
 248 | 
 249 | 	return(len);
 250 | }
 251 | 
 252 | 
 253 | 
 254 | void destroy_k5_struct(struct k5_command *cmd)
 255 | {
 256 | 	if (cmd->cmd) { free(cmd->cmd); }
 257 | 	if (cmd->obfuscated_cmd) { free(cmd->obfuscated_cmd); }
 258 | 	free(cmd);
 259 | }
 260 | 
 261 | /* ripped from https://mdfs.net/Info/Comp/Comms/CRC16.htm */
 262 | uint16_t crc16xmodem(char *addr, int num, int crc)
 263 | {
 264 | #define poly 0x1021
 265 | 	int i;
 266 | 
 267 | 	for (; num>0; num--)               /* Step through bytes in memory */
 268 | 	{
 269 | 		crc = crc ^ (*addr++ << 8);      /* Fetch byte from memory, XOR into CRC top byte*/
 270 | 		for (i=0; i<8; i++)              /* Prepare to rotate 8 bits */
 271 | 		{
 272 | 			crc = crc << 1;                /* rotate */
 273 | 			if (crc & 0x10000)             /* bit 15 was set (now bit 16)... */
 274 | 				crc = (crc ^ poly) & 0xFFFF; /* XOR with XMODEM polynomic */
 275 | 			/* and ensure CRC remains 16-bit value */
 276 | 		}                              /* Loop for 8 bits */
 277 | 	}                                /* Loop until num=0 */
 278 | 
 279 | 	return(crc);                     /* Return updated CRC */
 280 | }
 281 | 
 282 | 
 283 | /* (de)obfuscate the string using xor */
 284 | void xorarr(unsigned char *inarr,int len)
 285 | {
 286 | 	int len2=0;
 287 | 	unsigned char k5_xor_array[16]= { 
 288 | 		0x16 , 0x6c , 0x14 , 0xe6 , 0x2e , 0x91 , 0x0d , 0x40 ,
 289 | 		0x21 , 0x35 , 0xd5 , 0x40 , 0x13 , 0x03 , 0xe9 , 0x80 };
 290 | 
 291 | 	while (len2<len) {
 292 | 		*inarr=*inarr^k5_xor_array[len2%sizeof(k5_xor_array)];
 293 | 		len2++;
 294 | 		inarr++;
 295 | 	}
 296 | }
 297 | 
 298 | /* hexdump a k5_command struct */
 299 | void k5_hexdump(struct k5_command *cmd) {
 300 | 	printf ("********  k5 command hexdump [obf_len:%i clear_len:%i crc_ok:%i **********\n",cmd->obfuscated_len,cmd->len,cmd->crcok);
 301 | 	if (cmd->obfuscated_cmd) {
 302 | 		printf("## obfuscated ##\n");
 303 | 		hdump(cmd->obfuscated_cmd,cmd->obfuscated_len);
 304 | 	}
 305 | 	if (cmd->cmd) {
 306 | 		printf("## cleartext ##\n");
 307 | 		hdump(cmd->cmd,cmd->len);
 308 | 	}
 309 | 	printf("*****************\n");
 310 | }
 311 | 
 312 | 
 313 | /* obfuscate a k5 datagram */
 314 | int k5_obfuscate(struct k5_command *cmd)
 315 | {
 316 | 	uint16_t c;
 317 | 	if (!cmd->cmd) return(0);
 318 | 	if (cmd->obfuscated_cmd) { free (cmd->obfuscated_cmd); }
 319 | 	cmd->obfuscated_len=cmd->len+8; /* header  + length + data + crc + footer */
 320 | 	cmd->obfuscated_cmd=calloc(cmd->obfuscated_len,1);
 321 | 	cmd->obfuscated_cmd[0]=0xab;
 322 | 	cmd->obfuscated_cmd[1]=0xcd;
 323 | 	cmd->obfuscated_cmd[2]=(cmd->len)&0xff;
 324 | 	cmd->obfuscated_cmd[3]=(cmd->len>>8)&0xff;
 325 | 	memcpy((cmd->obfuscated_cmd)+4,cmd->cmd,cmd->len);
 326 | 	c=crc16xmodem((cmd->obfuscated_cmd)+4,cmd->len,0);
 327 | 	cmd->obfuscated_cmd[cmd->len+4]=c&0xff;
 328 | 	cmd->obfuscated_cmd[cmd->len+5]=(c>>8)&0xff;
 329 | 	xorarr((cmd->obfuscated_cmd)+4,cmd->len+2);
 330 | 	cmd->obfuscated_cmd[cmd->len+6]=0xdc;
 331 | 	cmd->obfuscated_cmd[cmd->len+7]=0xba;
 332 | 	cmd->crcok=1;
 333 | 	return(1);
 334 | }
 335 | 
 336 | /* deobfuscate a k5 datagram and verify it */
 337 | int k5_deobfuscate(struct k5_command *cmd)
 338 | {
 339 | 	uint16_t c,d;
 340 | 
 341 | 	if (!cmd->obfuscated_cmd) return(0);
 342 | 	if (cmd->cmd) { free (cmd->cmd); }
 343 | 	/* check the obfuscated datagram */
 344 | 	if ((cmd->obfuscated_cmd[0]!=0xab)||(cmd->obfuscated_cmd[1]!=0xcd)) { 
 345 | 		//bad header
 346 | 		if (verbose>2)	{ printf("bad header\n"); k5_hexdump(cmd); }
 347 | 		return(0); 
 348 | 	} 
 349 | 	if ((cmd->obfuscated_cmd[cmd->obfuscated_len-2]!=0xdc)||(cmd->obfuscated_cmd[cmd->obfuscated_len-1]!=0xba)) { 
 350 | 		//bad footer
 351 | 		if (verbose>2)	{ printf("bad footer\n"); k5_hexdump(cmd); }
 352 | 		return(0); 
 353 | 	} 
 354 | 	cmd->len=cmd->obfuscated_len-6; /* header  + length + data + crc + footer */
 355 | 	cmd->cmd=calloc(cmd->len,1);
 356 | 	memcpy(cmd->cmd,cmd->obfuscated_cmd+4,cmd->len);
 357 | 	xorarr(cmd->cmd,cmd->len);
 358 | 	c=crc16xmodem(cmd->cmd,cmd->len-2,0);
 359 | 	d=(cmd->cmd[cmd->len-2])|(cmd->cmd[cmd->len-1]<<8);
 360 | 	//if ((*cmd->cmd[*cmd->cmd-2]==(c&0xff))&&(*cmd->cmd[*cmd->cmd-2]==((c<<8)&0xff)))
 361 | 	/* the protocol looks like it would use crc from the radio to the pc, but instead the radio sends 0xffff */
 362 | 	if (d==0xffff)
 363 | 	{
 364 | 		cmd->crcok=1;
 365 | 		cmd->len=cmd->len-2; /* skip crc */
 366 | 	} else {
 367 | 		if (d==c) {
 368 | 			printf("** the protocol actually uses proper crc on datagrams from the radio, please inform the author of the radio/firmware version\n");
 369 | 			k5_hexdump(cmd);
 370 | 		} 
 371 | 		cmd->crcok=0;
 372 | 		if (verbose>2)	{ printf("bad crc 0x%4.4x (should be 0x%4.4x)\n",d,c); k5_hexdump(cmd); }
 373 | 		cmd->len=cmd->len-2; /* skip crc */
 374 | 		return(0); 
 375 | 
 376 | 	}
 377 | 	return(1);
 378 | }
 379 | 
 380 | /* obfuscate a command, send it */
 381 | int k5_send_cmd(int fd,struct k5_command *cmd) {
 382 | 	int l;
 383 | 
 384 | 	if (!k5_obfuscate(cmd)) { 
 385 | 		fprintf(stderr,"obfuscate error!\n");
 386 | 		return(0);
 387 | 	}
 388 | 
 389 | 	if (verbose>1) k5_hexdump(cmd);
 390 | 
 391 | 	l=write(fd,cmd->obfuscated_cmd,cmd->obfuscated_len);
 392 | 	if (verbose>2) printf("write %i\n",l);
 393 | 	return(1);
 394 | }
 395 | 
 396 | int k5_send_buf(int fd,unsigned char *buf,int len) {
 397 | 	int l;
 398 | 	struct k5_command *cmd;
 399 | 
 400 | 	cmd=calloc(sizeof(struct k5_command),1);
 401 | 	cmd->len=len;
 402 | 	cmd->cmd=malloc(cmd->len);
 403 | 	memcpy(cmd->cmd,buf,len);
 404 | 	l=k5_send_cmd(fd,cmd);
 405 | 	destroy_k5_struct(cmd);
 406 | 	return(l);
 407 | }
 408 | 
 409 | /* receive a response, deobfuscate it */
 410 | struct k5_command *k5_receive(int fd,int tmout) {
 411 | 	unsigned char buf[4];
 412 | 	unsigned char buf2[2048];
 413 | 	struct k5_command *cmd;
 414 | 	int len;
 415 | 
 416 | 	len=read_timeout(fd,(unsigned char *)&buf,sizeof(buf),10000); /* wait 500ms */
 417 | 
 418 | 	if (len>0) {
 419 | 		if (verbose>2)	{ printf("magic:\n"); hdump((unsigned char *)&buf,len); }
 420 | 	} else
 421 | 	{
 422 | 		fprintf(stderr,"k5_receive: err read1\n");
 423 | 		return(0);
 424 | 	}
 425 | 
 426 | 
 427 | 	if ((buf[0]!=0xab)||(buf[1]!=0xcd)) {
 428 | 		fprintf(stderr,"k5_receive: bad magic number\n");
 429 | 		return(0);
 430 | 	}
 431 | 
 432 | 	if (buf[3]!=0) {
 433 | 		fprintf(stderr,"k5_receive: it seems that byte 3 can be something else than 0, please notify the author\n");
 434 | 		return(0);
 435 | 	}
 436 | 
 437 | 	cmd=calloc(sizeof(struct k5_command),1);
 438 | 	cmd->obfuscated_len=buf[2]+8;
 439 | 	cmd->obfuscated_cmd=calloc(cmd->obfuscated_len,1);
 440 | 	memcpy(cmd->obfuscated_cmd,buf,4);
 441 | 	len=read_timeout(fd,cmd->obfuscated_cmd+4,buf[2]+4,tmout); /* wait 500ms */
 442 | 	if ((len+4)!=(cmd->obfuscated_len)) {
 443 | 		fprintf(stderr,"k5_receive err read1 len=%i wanted=%i\n",len,cmd->obfuscated_len);
 444 | 		return(0);
 445 | 	}
 446 | 
 447 | 
 448 | 	/* deobfuscate */
 449 | 	k5_deobfuscate(cmd);
 450 | 	if (verbose>2)	k5_hexdump(cmd);
 451 | 	return(cmd);
 452 | }
 453 | /******************************/
 454 | /*  eeprom read/write support */
 455 | /******************************/
 456 | int k5_readmem(int fd, unsigned char *buf, unsigned char maxlen, int offset)
 457 | {
 458 | 	int l;
 459 | 	unsigned char readmem[sizeof(uvk5_readmem1)];
 460 | 
 461 | 
 462 | 	int r;
 463 | 	struct k5_command *cmd;
 464 | 
 465 | 	if (verbose>1) 	printf("@@@@@@@@@@@@@@@@@@     readmem offset=0x%4.4x len=0x%2.2x\n",offset,maxlen);
 466 | 	/* byte6 - length (max 0x80), byte 4 (lsb) ,5 (msb)  address */
 467 | 	memcpy(readmem,uvk5_readmem1,sizeof(uvk5_readmem1));
 468 | 	readmem[6]=maxlen;
 469 | 	readmem[4]=offset&0xff;
 470 | 	readmem[5]=(offset>>8)&0xff;
 471 | 
 472 | 
 473 | 	r=k5_send_buf(fd,readmem,sizeof(readmem));
 474 | 	if (!r) return(0);
 475 | 	cmd=k5_receive(fd,10000);
 476 | 	if (!cmd) return(0);
 477 | 
 478 | 
 479 | 	if (verbose>2) k5_hexdump(cmd);
 480 | 
 481 | 	memcpy(buf,cmd->cmd+8,cmd->len-8);
 482 | 	destroy_k5_struct(cmd);
 483 | 	return(1);
 484 | 
 485 | }
 486 | 
 487 | int k5_writemem(int fd, unsigned char *buf, unsigned char len, int offset)
 488 | {
 489 | 	int l;
 490 | 	unsigned char writemem[512];
 491 | 
 492 | 
 493 | 	int r;
 494 | 	struct k5_command *cmd;
 495 | 
 496 | 	if (verbose>1) printf("@@@@@@@@@@@@@@@@@@     writemem offset=0x%4.4x len=0x%2.2x\n",offset,len);
 497 | 	/* byte6 - length (max 0x80), byte 4 (lsb) ,5 (msb)  address */
 498 | 
 499 | 
 500 | 	writemem[0]=0x1d;
 501 | 	writemem[1]=0x5;
 502 | 	writemem[2]=len+8;
 503 | 	writemem[3]=0;
 504 | 	writemem[4]=offset&0xff;
 505 | 	writemem[5]=(offset>>8)&0xff;
 506 | 	writemem[6]=len;
 507 | 	writemem[7]=1;
 508 | 
 509 | 	writemem[8]=0x6a;
 510 | 	writemem[9]=0x39;
 511 | 	writemem[10]=0x57;
 512 | 	writemem[11]=0x64;
 513 | 
 514 | 	memcpy((void *)&writemem+12,buf,len);
 515 | 
 516 | 	r=k5_send_buf(fd,writemem,len+12);
 517 | 	if (!r) return(0);
 518 | 
 519 | 	cmd=k5_receive(fd,10000);
 520 | 	if (!cmd) return(0);
 521 | 
 522 | 	if (verbose>2) k5_hexdump(cmd);
 523 | 
 524 | 	if (((cmd->cmd[0])!=0x1e)||((cmd->cmd[4])!=writemem[4])||((cmd->cmd[5])!=writemem[5])) {
 525 | 		fprintf(stderr,"bad write confirmation\n");
 526 | 		destroy_k5_struct(cmd);
 527 | 		return(0);
 528 | 	}
 529 | 
 530 | 	destroy_k5_struct(cmd);
 531 | 	return(1);
 532 | }
 533 | 
 534 | /* reset the radio */
 535 | int k5_reset(int fd)
 536 | {
 537 | 	int l;
 538 | 	int r;
 539 | 	struct k5_command *cmd;
 540 | 
 541 | 	if (verbose>1) printf("@@@@@@@@@@@@@@@@@@    reset\n");
 542 | 	r=k5_send_buf(fd,uvk5_reset,sizeof(uvk5_reset));
 543 | 	return(r);
 544 | }	
 545 | /*  end of eeprom read/write support */
 546 | 
 547 | 
 548 | /******************************/
 549 | /*  flash read/write support */
 550 | /******************************/
 551 | 
 552 | /* wait for a "i'm in flashing mode" message */
 553 | int wait_flash_message(int fd,int ntimes) {
 554 | 	struct k5_command *cmd;
 555 | 	int ok=0;
 556 | 	char buf[17];
 557 | 	int i,j;
 558 | 
 559 | 	while(ntimes) {
 560 | 		ntimes--;
 561 | 
 562 | 		if (verbose>1) { printf("wait_flash_message try %i\n",ntimes); }
 563 | 
 564 | 		cmd=k5_receive(fd,10000);
 565 | 
 566 | 		if (!cmd) {
 567 | 			printf("wait_flash_message: timeout\n");
 568 | 			continue; 
 569 | 		}
 570 | 
 571 | 		k5_hexdump(cmd);
 572 | 
 573 | 		if (!cmd->cmd) {
 574 | 			printf("wait_flash_message: received malformed packet\n");
 575 | 			destroy_k5_struct(cmd);
 576 | 			continue;
 577 | 		}
 578 | 
 579 | 		if (cmd->cmd[0]!=0x18) {
 580 | 			printf("wait_flash_message: got unexpected command type 0x%2.2x\n",cmd->cmd[0]);
 581 | 			destroy_k5_struct(cmd);
 582 | 			continue;
 583 | 		}
 584 | 		if (cmd->len!=36) {
 585 | 			printf("wait_flash_message: got unexpected command length %i\n",cmd->len);
 586 | 			destroy_k5_struct(cmd);
 587 | 			continue;
 588 | 		}
 589 | 
 590 | 		/*
 591 | 		 * this is what a "i'm in flashing mode" packet looks like
 592 | 		 *
 593 | 		 * 
 594 | 		 *  0x000024 |0 |1 |2 |3 |4 |5 |6 |7 |8 |9 |a |b |c |d |e |f |
 595 | 		 *  ---------+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+------------
 596 | 		 *  0x000000: 18 05 20 00 01 02 02 06 1c 53 50 4a 37 47 ff 0f   .. ......SPJ7G..   
 597 | 		 *  0x000010: 8c 00 53 00 32 2e 30 30 2e 30 36 00 34 0a 00 00   ..S.2.00.06.4...   
 598 | 		 *  0x000020: 00 00 00 20                                       ...                
 599 | 		 */
 600 | 
 601 | 		if ((cmd->cmd[2]!=0x20)||(cmd->cmd[3]!=0x0)||(cmd->cmd[4]!=0x1)||(cmd->cmd[5]!=0x2)||(cmd->cmd[6]!=0x2)) {
 602 | 			printf("wait_flash_message: got unexpected packet contents\n");
 603 | 			destroy_k5_struct(cmd);
 604 | 			continue;
 605 | 		}
 606 | 
 607 | 		/* all is good, so break */
 608 | 		ok=1; 	break;
 609 | 
 610 | 
 611 | 	}
 612 | 
 613 | 	if (!ok) {
 614 | 		printf("wait_flash_message: no flash message from radio\n");
 615 | 		return(0);
 616 | 	}
 617 | 
 618 | 	for (i=0;i<(sizeof(buf)-1);i++) {
 619 | 		j=i+0x14;
 620 | 		if (j>=cmd->len) break;
 621 | 		if (!isprint(cmd->cmd[j])) break;
 622 | 		buf[i]=cmd->cmd[j];
 623 | 	}
 624 | 	buf[i]=0;
 625 | 	printf("Flasher version is: [%s]\n",buf);
 626 | 	destroy_k5_struct(cmd);
 627 | 	return(1);
 628 | }
 629 | 
 630 | /* sends the version of firmware that we will be flashing, 
 631 |  * unobfuscated firmware will have the version number in 16 bytes at 0x2000
 632 |  * probably these bytes are sent.
 633 |  *
 634 |  * currently this is hardcoded to 2.01.23
 635 |  */
 636 | int k5_send_flash_version_message(int fd) {
 637 | 
 638 | 	int r;
 639 | 	struct k5_command *cmd;
 640 | 	unsigned char uvk5_flash_version[]={ 0x30, 0x5, 0x10, 0x0, '2', '.', '0', '1', '.', '2', '3', 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
 641 | 	r=k5_send_buf(fd,uvk5_flash_version,sizeof(uvk5_flash_version));
 642 | 	if (!r) return(0);
 643 | 
 644 | 	/* check if we're still getting packets, usually this is a 0x18 type packet, but not sure what else the radio can send  */
 645 | 	cmd=k5_receive(fd,10000);
 646 | 	if (!cmd) return(0);
 647 | 
 648 | 	if (verbose>1) k5_hexdump(cmd);
 649 | 	destroy_k5_struct(cmd);
 650 | 
 651 | 	return(1);
 652 | }
 653 | 
 654 | int k5_writeflash(int fd, unsigned char *buf, int  len, int offset, int fw_size_blocks)
 655 | {
 656 | 	int l;
 657 | 	unsigned char writeflash[512];
 658 | 
 659 | 	int ok=0;
 660 | 
 661 | 	int r;
 662 | 	struct k5_command *cmd;
 663 | 
 664 | 	if (verbose>1) printf("@@@@@@@@@@@@@@@@@@     writeflash offset=0x%4.4x len=0x%2.2x\n",offset,len);
 665 | 	memset(writeflash,0,sizeof(writeflash));
 666 | 
 667 | 	/* 0x19  0x5  0xc  0x1  0x8a  0x8d  0x9f  0x1d  
 668 | 	 * address_msb  address_lsb  0xe6  0x0  length_msb  length_lsb  0x0  0x0 
 669 | 	 * [0x100 bytes of data, if length is <0x100 then fill the rest with zeroes] */
 670 | 	writeflash[0]=0x19;
 671 | 	writeflash[1]=0x5;
 672 | 	/* bytes 2,3: length is 0x10c */
 673 | 	writeflash[2]=0xc;
 674 | 	writeflash[3]=1; 
 675 | 	writeflash[4]=0x8a;
 676 | 	writeflash[5]=0x8d;
 677 | 	writeflash[6]=0x9f;
 678 | 	writeflash[7]=0x1d;
 679 | 
 680 | 	writeflash[8]=(offset>>8)&0xff;
 681 | 	writeflash[9]=offset&0xff;
 682 | 	writeflash[10]=fw_size_blocks&0xff; // bootloader probably uses this to determinate total fw len (in flash pages)
 683 | 	writeflash[11]=0x00;
 684 | 	writeflash[12]=len&0xff;
 685 | 	writeflash[13]=(len>>8)&0xff;
 686 | 	writeflash[14]=0x00;
 687 | 	writeflash[15]=0x00;
 688 | 
 689 | 	memcpy((void *)&writeflash+16,buf,len);
 690 | 
 691 | 	r=k5_send_buf(fd,writeflash,0x100+16); /* we always send 0x100 bytes, header is 16 bytes */
 692 | 	if (!r) return(0);
 693 | 
 694 | 	/* wait for a reply packet */
 695 | 	l=5;
 696 | 	while(l) {
 697 | 		cmd=k5_receive(fd,10000);
 698 | 		l--;
 699 | 		if (!cmd) { 
 700 | 			usleep(1000); 
 701 | 			continue;
 702 | 		}
 703 | 
 704 | 		if (verbose>1) {
 705 | 			printf("|||||  reply packet after flash command\n");
 706 | 			k5_hexdump(cmd);
 707 | 		}
 708 | 		/* we're still getting "i'm in flash mode packets", can happen after the first flash command, ignore it */
 709 | 		if ((cmd->cmd[0]==0x18)&&(cmd->cmd[1]==0x05)&&(cmd->cmd[2]==0x20)&&(cmd->cmd[3]==0x0)&&(cmd->cmd[4]==0x1)&&(cmd->cmd[5]==0x2)&&(cmd->cmd[6]==0x2)) {
 710 | 		if (verbose>1)  printf("&&&&|  ignoring \"i'm in flash mode\" packet\n");
 711 | 			destroy_k5_struct(cmd);
 712 | 			continue;
 713 | 		}
 714 | 
 715 | 
 716 | 		/* reply packet:
 717 | 		 * 0x1a  0x5  0x8  0x0  0x8a  0x8d  0x9f  0x1d  0x0  0x0  0x0  0x0
 718 | 		 */
 719 | 		if (((cmd->cmd[0])!=0x1a)||((cmd->cmd[8])!=writeflash[8])||((cmd->cmd[9])!=writeflash[9])) {
 720 | 			fprintf(stderr,"bad write confirmation\n");
 721 | 			destroy_k5_struct(cmd);
 722 | 			continue;
 723 | 		}
 724 | 		ok=1; 
 725 | 		destroy_k5_struct(cmd);
 726 | 		break;
 727 | 	}
 728 | 
 729 | 	if (!ok) {
 730 | 		printf("\n\nERROR: no confirmation for flash block 0x%4.4x, length 0x%4.4x\n\n",offset,len);
 731 | 		/* TODO: what do we do if there wasn't a proper confirmation? retry maybe? */
 732 | 	}
 733 | 	return(ok);
 734 | }
 735 | 
 736 | 
 737 | void helpme()
 738 | {
 739 | 	printf( 
 740 | 			"cmdline opts:\n"
 741 | 			"-f <file>\tfilename that contains the eeprom dump (default: " DEFAULT_FILE_NAME ")\n"
 742 | 			"-b <file>\tfilename that contains the raw flash image (default " DEFAULT_FLASH_NAME ")\n"
 743 | 			"-Y \tincrease \"I know what i'm doing\" value, to enable functionality likely to break the radio\n"
 744 | 			"-D\twait for the message from the radio flasher, print it's version\n"
 745 | 			"-F\tflash firmware, WARNING: this will likely brick your radio!\n"
 746 | 			"-r \tread eeprom\n"
 747 | 			"-w \twrite eeprom like the original software does\n"
 748 | 			"-W \twrite most of the eeprom (but without what i think is calibration data)\n"
 749 | 			"-B \twrite ALL of the eeprom (the \"brick my radio\" mode)\n"
 750 | 			"-p <port>\tdevice name (default: " DEFAULT_SERIAL_PORT ")\n"
 751 | 			"-s <speed>\tserial speed (default: 38400, the UV-K5 doesn't accept any other speed)\n"
 752 | 			"-h \tprint this help\n"
 753 | 			"-v \tbe verbose, use multiple times for more verbosity\n"
 754 | 
 755 | 	      );
 756 | }
 757 | 
 758 | 
 759 | static speed_t baud_to_speed_t(int baud)
 760 | {
 761 | 	switch (baud) {
 762 | 		case 0:
 763 | 			return B0;
 764 | 		case 50:
 765 | 			return B50;
 766 | 		case 75:
 767 | 			return B75;
 768 | 		case 110:
 769 | 			return B110;
 770 | 		case 150:
 771 | 			return B150;
 772 | 		case 200:
 773 | 			return B200;
 774 | 		case 300:
 775 | 			return B300;
 776 | 		case 600:
 777 | 			return B600;
 778 | 		case 1200:
 779 | 			return B1200;
 780 | 		case 1800:
 781 | 			return B1800;
 782 | 		case 2400:
 783 | 			return B2400;
 784 | 		case 4800:
 785 | 			return B4800;
 786 | 		case 9600:
 787 | 			return B9600;
 788 | 		case 19200:
 789 | 			return B19200;
 790 | 		case 38400:
 791 | 			return B38400;
 792 | 		case 57600:
 793 | 			return B57600;
 794 | 		case 115200:
 795 | 			return B115200;
 796 | 		default:
 797 | 			return B0;
 798 | 	}
 799 | 
 800 | 
 801 | }
 802 | 
 803 | void parse_cmdline(int argc, char **argv)
 804 | {
 805 | 	int opt;
 806 | 	int tmpval;
 807 | 
 808 | int res;
 809 | 	/* cmdline opts:
 810 | 	 * -f <file>
 811 | 	 * -b <flash file>
 812 | 	 * -F (flash firmware)
 813 | 	 * -O (hex offset)
 814 | 	 * -L (hex length)
 815 | 	 * -r (read)
 816 | 	 * -w (write)
 817 | 	 * -p <port>
 818 | 	 * -s <speed>
 819 | 	 * -h (help)
 820 | 	 * -v (verbose)
 821 | 	 * -D (flashdebug)
 822 | 	 * -F (flash)
 823 | 	 * -Y (i know what i'm doing)
 824 | 	 */
 825 | 
 826 | 	while ((opt=getopt(argc,argv,"f:rwWBp:s:hvDFYb:L:O:"))!=EOF)
 827 | 	{
 828 | 		switch (opt)
 829 | 		{
 830 | 			case 'h':
 831 | 				helpme();
 832 | 				exit(0);
 833 | 				break;
 834 | 			case 'v':
 835 | 				verbose++;
 836 | 				break;
 837 | 			case 'Y':
 838 | 				i_know_what_im_doing++;
 839 | 				break;
 840 | 			case 'r':
 841 | 				mode=MODE_READ;
 842 | 				break;
 843 | 			case 'w':
 844 | 				mode=MODE_WRITE;
 845 | 				break;
 846 | 			case 'D':
 847 | 				mode=MODE_FLASH_DEBUG;
 848 | 				break;
 849 | 			case 'F':
 850 | 				mode=MODE_FLASH;
 851 | 				break;
 852 | 			case 'b':
 853 | 				flash_file=optarg;
 854 | 				break;
 855 | 			case 'O':
 856 | 				res=sscanf(optarg,"%x",&write_offset);
 857 | 				if (res!=1) {
 858 | 					fprintf(stderr,"ERROR, could not parse offset %s\n",optarg);
 859 | 					exit(1);
 860 | 				}
 861 | 				break;
 862 | 			case 'L':
 863 | 				res=sscanf(optarg,"%x",&write_length);
 864 | 				if (res!=1) {
 865 | 					fprintf(stderr,"ERROR, could not parse length %s\n",optarg);
 866 | 					exit(1);
 867 | 				}
 868 | 				break;
 869 | 			case 'W':
 870 | 				mode=MODE_WRITE_MOST;
 871 | 				break;
 872 | 			case 'B':
 873 | 				mode=MODE_WRITE_ALL;
 874 | 				break;
 875 | 			case 'f':
 876 | 				file=optarg;
 877 | 				break;
 878 | 			case 'p':
 879 | 				ser_port=optarg;
 880 | 				break;
 881 | 			case 's':
 882 | 
 883 | 				ser_speed=baud_to_speed_t(atoi(optarg));
 884 | 				if (ser_speed==B0) {
 885 | 					fprintf(stderr,"ERROR, unknown speed %s\n",optarg);
 886 | 					exit(1);
 887 | 					break;
 888 | 
 889 | 					default:
 890 | 					fprintf(stderr,"Unknown command line option %s\n",optarg);
 891 | 					exit(1);
 892 | 					break;
 893 | 				}
 894 | 		}
 895 | 	}
 896 | 	if ((mode==MODE_FLASH)&&(write_offset%UVK5_FLASH_BLOCKSIZE!=0))
 897 | 	{
 898 | 		fprintf(stderr,"ERROR: write offset has to be a multiple of %x\n",UVK5_FLASH_BLOCKSIZE);
 899 | 		exit(1);
 900 | 	}
 901 | 	if ((mode==MODE_WRITE)&&(write_offset%UVK5_EEPROM_BLOCKSIZE!=0))
 902 | 	{
 903 | 		fprintf(stderr,"ERROR: write offset has to be a multiple of %x\n",UVK5_EEPROM_BLOCKSIZE);
 904 | 		exit(1);
 905 | 	}
 906 | }
 907 | 
 908 | int write_file(char *name, unsigned char *buffer, int len)
 909 | {
 910 | 	int fd;
 911 | 	int l;
 912 | 
 913 | 	fd=open(name,O_WRONLY|O_CREAT|O_TRUNC,0600);
 914 | 	if (fd<0) {
 915 | 		printf("open %s error %d %s\n", name,errno, strerror(errno));
 916 | 		return(-1);
 917 | 	}
 918 | 
 919 | 	l=write(fd,buffer,len);
 920 | 
 921 | 	if (l!=len) {
 922 | 		printf("short write (%i) error %d %s\n", l,errno, strerror(errno));
 923 | 		return(-1);
 924 | 	}
 925 | 
 926 | 	close(fd);
 927 | 	return(1);
 928 | }
 929 | int k5_prepare(int fd) {
 930 | 	int r;
 931 | 	struct k5_command *cmd;
 932 | 
 933 | 	r=k5_send_buf(fd,uvk5_hello,sizeof(uvk5_hello));
 934 | 	if (!r) return(0);
 935 | 	cmd=k5_receive(fd,10000);
 936 | 	if (!cmd) return(0);
 937 | 
 938 | 	printf("******  Connected to firmware version: [%s]\n",(cmd->cmd)+4);
 939 | 	destroy_k5_struct(cmd);
 940 | 
 941 | 	return(1);
 942 | }
 943 | 
 944 | int main(int argc,char **argv)
 945 | {
 946 | 	int fd,ffd;
 947 | 	unsigned char eeprom[UVK5_EEPROM_SIZE];
 948 | 	unsigned char flash[UVK5_MAX_FLASH_SIZE];
 949 | 	int flash_length;
 950 | 	int flash_length2;
 951 | 	int i,r,j,len;
 952 | 
 953 | 	printf (VERSION "\n\n"); 
 954 | 
 955 | 	parse_cmdline(argc,argv);
 956 | 
 957 | 	if (mode==MODE_NONE) {
 958 | 		fprintf(stderr,"No operating mode selected, use -w or -r\n");
 959 | 		helpme();
 960 | 		exit(1);
 961 | 	}
 962 | 
 963 | 
 964 | 	fd=openport(ser_port,ser_speed);
 965 | 
 966 | 	if (fd<0) {
 967 | 		fprintf(stderr,"Open %s failed\n",ser_port);
 968 | 		exit(1);
 969 | 	}
 970 | 
 971 | 	if (i_know_what_im_doing) {
 972 | 		printf("\"I know what i'm doing\" value set to %i\n",i_know_what_im_doing);
 973 | 	}
 974 | 
 975 | 
 976 | 
 977 | 	/* flash mode */
 978 | 	switch(mode)
 979 | 	{
 980 | 
 981 | 		case MODE_FLASH_DEBUG:
 982 | 			if (i_know_what_im_doing<1) {
 983 | 				printf("ERROR: the \"I know what i'm doing\" value has to be at least 1 to confirm that you know what you're doing\n");
 984 | 				exit(0);
 985 | 			}
 986 | 			wait_flash_message(fd,10000);
 987 | 			exit(0);
 988 | 			break;
 989 | 
 990 | 		case MODE_FLASH:
 991 | 			if (i_know_what_im_doing<3) {
 992 | 				printf("ERROR: the \"I know what i'm doing\" value has to be at least 3, to confirm that you really know what you're doing\n");
 993 | 				exit(0);
 994 | 			}
 995 | 
 996 | 			ffd=open(flash_file,O_RDONLY);
 997 | 			if (ffd<0) {
 998 | 				fprintf(stderr,"open %s error %d %s\n", file, errno, strerror(errno));
 999 | 				exit(1);
1000 | 			}
1001 | 			flash_length=read(ffd,(unsigned char *)&flash,UVK5_MAX_FLASH_SIZE);
1002 | 			/* arbitrary limit do that someone doesn't flash some random short file */
1003 | 			if (flash_length<50000) {
1004 | 				fprintf(stderr,"Failed to read whole eeprom from file %s (read %i), file too short or some other error\n",file,flash_length);
1005 | 				exit(1);
1006 | 			}
1007 | 			if ((write_length>0)&&((write_length+write_offset)>=UVK5_MAX_FLASH_SIZE))  {
1008 | 				fprintf(stderr,"write_length (%d) + write_offset (%d) is bigger than the flash size (%d)\n", write_length, write_offset, UVK5_MAX_FLASH_SIZE);
1009 | 				exit(1);
1010 | 			}
1011 | 			close(ffd);
1012 | 
1013 | 			if (verbose>0) { printf ("Read file %s success\n",flash_file); }
1014 | 
1015 | 
1016 | 			r=wait_flash_message(fd,10000);
1017 | 			if (!r) exit(0);
1018 | 
1019 | 			k5_send_flash_version_message(fd);
1020 | 
1021 | 			/* for(i=0; i<flash_length; i+=UVK5_FLASH_BLOCKSIZE) */
1022 | 			flash_length2=flash_length;
1023 | 			if (write_length>0) {
1024 | 				flash_length2=write_offset+write_length;
1025 | 				if (flash_length2%UVK5_FLASH_BLOCKSIZE>0) { 
1026 | 					flash_length2=flash_length2-flash_length2%UVK5_FLASH_BLOCKSIZE+UVK5_FLASH_BLOCKSIZE; 
1027 | 				}
1028 | 				if (flash_length2>flash_length) flash_length2=flash_length;
1029 | 				printf("Writing blocks from address 0x%x until 0x%x\n",write_offset,flash_length2);
1030 | 			}
1031 | 			for(i=write_offset; i<flash_length2; i+=UVK5_FLASH_BLOCKSIZE)
1032 | 			{
1033 | 				len=flash_length-i;
1034 | 				if (len>UVK5_FLASH_BLOCKSIZE) len=UVK5_FLASH_BLOCKSIZE;
1035 | 
1036 | 				r=k5_writeflash(fd, (unsigned char *)&flash+i,len,i,(flash_length+0xFF)/0x100);
1037 | 
1038 | 				printf("*** FLASH at 0x%4.4x length 0x%4.4x  result=%i\n",i,len,r);
1039 | 				if (!r) {
1040 | 					printf("Stopping flash due to ERROR!!!\n");
1041 | 					break;
1042 | 				}
1043 | 			}
1044 | 			exit(0);
1045 | 
1046 | 	}
1047 | 
1048 | 
1049 | 
1050 | 	for (i=0;i<UVK5_PREPARE_TRIES;i++)
1051 | 	{
1052 | 		if (verbose>0) { printf("k5_prepare: try %i\n",i); }
1053 | 		r=k5_prepare(fd);
1054 | 		if (r) break;
1055 | 	}
1056 | 
1057 | 	if (!r)
1058 | 	{
1059 | 		fprintf(stderr,"Failed to init radio\n");
1060 | 		exit(1);
1061 | 	}
1062 | 
1063 | 	switch(mode)
1064 | 	{
1065 | 
1066 | 
1067 | 		case MODE_READ:
1068 | 
1069 | 			for(i=0;i<UVK5_EEPROM_SIZE; i=i+UVK5_EEPROM_BLOCKSIZE) {
1070 | 				if (!k5_readmem(fd,(unsigned char *)&eeprom[i],UVK5_EEPROM_BLOCKSIZE,i))
1071 | 				{
1072 | 					fprintf(stderr,"Failed to read block 0x%4.4X\n",i);
1073 | 					exit(1);
1074 | 				}
1075 | 				if (verbose>0) { 
1076 | 					printf("\rread block 0x%4.4X  %i%%",i,(100*i/UVK5_EEPROM_SIZE)); 
1077 | 					fflush(stdout); 
1078 | 				}
1079 | 			}
1080 | 			close(fd);
1081 | 			if (verbose>0) { printf("\rSucessfuly read eeprom\n"); }
1082 | 			if (verbose>2) { hdump((unsigned char *)&eeprom,UVK5_EEPROM_SIZE); }
1083 | 
1084 | 			write_file(file,(unsigned char *)&eeprom,UVK5_EEPROM_SIZE);
1085 | 
1086 | 			break;
1087 | 
1088 | 		case MODE_WRITE:
1089 | 		case MODE_WRITE_MOST:
1090 | 		case MODE_WRITE_ALL:
1091 | 			if ((mode==MODE_WRITE_ALL)&&(i_know_what_im_doing<1)) {
1092 | 				printf("ERROR: the \"I know what i'm doing\" value has to be at least 1 to confirm that you know what you're doing\n");
1093 | 				exit(0);
1094 | 			}
1095 | 
1096 | 			/* read file */
1097 | 			ffd=open(file,O_RDONLY);
1098 | 			if (ffd<0) {
1099 | 				fprintf(stderr,"open %s error %d %s\n", file, errno, strerror(errno));
1100 | 				exit(1);
1101 | 			}
1102 | 			r=read(ffd,(unsigned char *)&eeprom[i],UVK5_EEPROM_SIZE);
1103 | 			if (r!=UVK5_EEPROM_SIZE) {
1104 | 				fprintf(stderr,"Failed to read whole eeprom from file %s, file too short?\n",file);
1105 | 				exit(1);
1106 | 			}
1107 | 			close(ffd);
1108 | 			if (verbose>0) { printf ("Read file %s success\n",file); }
1109 | 			if ((mode==MODE_WRITE_ALL) || (mode==MODE_WRITE_MOST)) {
1110 | 				j=UVK5_EEPROM_SIZE_WITHOUT_CALIBRATION;
1111 | 				if (mode==MODE_WRITE_ALL) j=UVK5_EEPROM_SIZE;
1112 | 
1113 | 				/* write to radio */
1114 | 				for(i=0;i<j; i=i+UVK5_EEPROM_BLOCKSIZE) {
1115 | 					if (!k5_writemem(fd,(unsigned char *)&eeprom[i],UVK5_EEPROM_BLOCKSIZE,i))
1116 | 					{
1117 | 						fprintf(stderr,"Failed to write block 0x%4.4X\n",i);
1118 | 						exit(1);
1119 | 					}
1120 | 					if (verbose>0) { 
1121 | 						printf("\rwrite block 0x%4.4X  %i%%",i,(100*i/j)); 
1122 | 						fflush(stdout); 
1123 | 					}
1124 | 
1125 | 				} 
1126 | 			} else {
1127 | 				/* write to radio */
1128 | 
1129 | 				i=0;
1130 | 				while (uvk5_writes[i][1]) { i++; }
1131 | 				j=i;
1132 | 
1133 | 				i=0;
1134 | 				while (uvk5_writes[i][1]) {
1135 | 					if (!k5_writemem(fd,(unsigned char *)&eeprom[uvk5_writes[i][0]],uvk5_writes[i][1],uvk5_writes[i][0]))
1136 | 					{
1137 | 						fprintf(stderr,"Failed to write block 0x%4.4X length 0x%2.2x\n",uvk5_writes[i][0],uvk5_writes[i][1]);
1138 | 						exit(1);
1139 | 					}
1140 | 					if (verbose>0) { 
1141 | 						printf("\rwrite block 0x%4.4X  %i%%",i,(100*i/j)); 
1142 | 						fflush(stdout); 
1143 | 					}
1144 | 					i++;
1145 | 				}
1146 | 			}
1147 | 			k5_reset(fd);
1148 | 			if (verbose>0) { printf("\rSucessfuly wrote eeprom\n"); }
1149 | 
1150 | 
1151 | 			break;
1152 | 		default:
1153 | 			fprintf(stderr,"this shouldn't happen :)\n");
1154 | 			break;
1155 | 	}
1156 | 
1157 | 	return(0); /* silence gcc */
1158 | }
1159 | 


--------------------------------------------------------------------------------
/uvk5.h:
--------------------------------------------------------------------------------
  1 | /* UV-K5 eeprom programmer */
  2 | 
  3 | #ifndef UVK5_INCLUDE_H
  4 | #define UVK5_INCLUDE_H
  5 | 
  6 | int uvk5_writesx[][2]={
  7 | //{ 0x0e70 , 0x60 },
  8 | { 0x0eb0 , 0x08 },
  9 | {0,0}
 10 | 	};
 11 | 
 12 | int uvk5_writes[][2]={
 13 | { 0x0e70 , 0x60 },
 14 | { 0x0000 , 0x10 },
 15 | { 0x0f50 , 0x10 },
 16 | { 0x0010 , 0x10 },
 17 | { 0x0f60 , 0x10 },
 18 | { 0x0020 , 0x10 },
 19 | { 0x0f70 , 0x10 },
 20 | { 0x0030 , 0x10 },
 21 | { 0x0f80 , 0x10 },
 22 | { 0x0040 , 0x10 },
 23 | { 0x0f90 , 0x10 },
 24 | { 0x0050 , 0x10 },
 25 | { 0x0fa0 , 0x10 },
 26 | { 0x0060 , 0x10 },
 27 | { 0x0fb0 , 0x10 },
 28 | { 0x0070 , 0x10 },
 29 | { 0x0fc0 , 0x10 },
 30 | { 0x0080 , 0x10 },
 31 | { 0x0fd0 , 0x10 },
 32 | { 0x0090 , 0x10 },
 33 | { 0x0fe0 , 0x10 },
 34 | { 0x00a0 , 0x10 },
 35 | { 0x0ff0 , 0x10 },
 36 | { 0x00b0 , 0x10 },
 37 | { 0x1000 , 0x10 },
 38 | { 0x00c0 , 0x10 },
 39 | { 0x1010 , 0x10 },
 40 | { 0x00d0 , 0x10 },
 41 | { 0x1020 , 0x10 },
 42 | { 0x00e0 , 0x10 },
 43 | { 0x1030 , 0x10 },
 44 | { 0x00f0 , 0x10 },
 45 | { 0x1040 , 0x10 },
 46 | { 0x0100 , 0x10 },
 47 | { 0x1050 , 0x10 },
 48 | { 0x0110 , 0x10 },
 49 | { 0x1060 , 0x10 },
 50 | { 0x0120 , 0x10 },
 51 | { 0x1070 , 0x10 },
 52 | { 0x0130 , 0x10 },
 53 | { 0x1080 , 0x10 },
 54 | { 0x0140 , 0x10 },
 55 | { 0x1090 , 0x10 },
 56 | { 0x0150 , 0x10 },
 57 | { 0x10a0 , 0x10 },
 58 | { 0x0160 , 0x10 },
 59 | { 0x10b0 , 0x10 },
 60 | { 0x0170 , 0x10 },
 61 | { 0x10c0 , 0x10 },
 62 | { 0x0180 , 0x10 },
 63 | { 0x10d0 , 0x10 },
 64 | { 0x0190 , 0x10 },
 65 | { 0x10e0 , 0x10 },
 66 | { 0x01a0 , 0x10 },
 67 | { 0x10f0 , 0x10 },
 68 | { 0x01b0 , 0x10 },
 69 | { 0x1100 , 0x10 },
 70 | { 0x01c0 , 0x10 },
 71 | { 0x1110 , 0x10 },
 72 | { 0x01d0 , 0x10 },
 73 | { 0x1120 , 0x10 },
 74 | { 0x01e0 , 0x10 },
 75 | { 0x1130 , 0x10 },
 76 | { 0x01f0 , 0x10 },
 77 | { 0x1140 , 0x10 },
 78 | { 0x0200 , 0x10 },
 79 | { 0x1150 , 0x10 },
 80 | { 0x0210 , 0x10 },
 81 | { 0x1160 , 0x10 },
 82 | { 0x0220 , 0x10 },
 83 | { 0x1170 , 0x10 },
 84 | { 0x0230 , 0x10 },
 85 | { 0x1180 , 0x10 },
 86 | { 0x0240 , 0x10 },
 87 | { 0x1190 , 0x10 },
 88 | { 0x0250 , 0x10 },
 89 | { 0x11a0 , 0x10 },
 90 | { 0x0260 , 0x10 },
 91 | { 0x11b0 , 0x10 },
 92 | { 0x0270 , 0x10 },
 93 | { 0x11c0 , 0x10 },
 94 | { 0x0280 , 0x10 },
 95 | { 0x11d0 , 0x10 },
 96 | { 0x0290 , 0x10 },
 97 | { 0x11e0 , 0x10 },
 98 | { 0x02a0 , 0x10 },
 99 | { 0x11f0 , 0x10 },
100 | { 0x02b0 , 0x10 },
101 | { 0x1200 , 0x10 },
102 | { 0x02c0 , 0x10 },
103 | { 0x1210 , 0x10 },
104 | { 0x02d0 , 0x10 },
105 | { 0x1220 , 0x10 },
106 | { 0x02e0 , 0x10 },
107 | { 0x1230 , 0x10 },
108 | { 0x02f0 , 0x10 },
109 | { 0x1240 , 0x10 },
110 | { 0x0300 , 0x10 },
111 | { 0x1250 , 0x10 },
112 | { 0x0310 , 0x10 },
113 | { 0x1260 , 0x10 },
114 | { 0x0320 , 0x10 },
115 | { 0x1270 , 0x10 },
116 | { 0x0330 , 0x10 },
117 | { 0x1280 , 0x10 },
118 | { 0x0340 , 0x10 },
119 | { 0x1290 , 0x10 },
120 | { 0x0350 , 0x10 },
121 | { 0x12a0 , 0x10 },
122 | { 0x0360 , 0x10 },
123 | { 0x12b0 , 0x10 },
124 | { 0x0370 , 0x10 },
125 | { 0x12c0 , 0x10 },
126 | { 0x0380 , 0x10 },
127 | { 0x12d0 , 0x10 },
128 | { 0x0390 , 0x10 },
129 | { 0x12e0 , 0x10 },
130 | { 0x03a0 , 0x10 },
131 | { 0x12f0 , 0x10 },
132 | { 0x03b0 , 0x10 },
133 | { 0x1300 , 0x10 },
134 | { 0x03c0 , 0x10 },
135 | { 0x1310 , 0x10 },
136 | { 0x03d0 , 0x10 },
137 | { 0x1320 , 0x10 },
138 | { 0x03e0 , 0x10 },
139 | { 0x1330 , 0x10 },
140 | { 0x03f0 , 0x10 },
141 | { 0x1340 , 0x10 },
142 | { 0x0400 , 0x10 },
143 | { 0x1350 , 0x10 },
144 | { 0x0410 , 0x10 },
145 | { 0x1360 , 0x10 },
146 | { 0x0420 , 0x10 },
147 | { 0x1370 , 0x10 },
148 | { 0x0430 , 0x10 },
149 | { 0x1380 , 0x10 },
150 | { 0x0440 , 0x10 },
151 | { 0x1390 , 0x10 },
152 | { 0x0450 , 0x10 },
153 | { 0x13a0 , 0x10 },
154 | { 0x0460 , 0x10 },
155 | { 0x13b0 , 0x10 },
156 | { 0x0470 , 0x10 },
157 | { 0x13c0 , 0x10 },
158 | { 0x0480 , 0x10 },
159 | { 0x13d0 , 0x10 },
160 | { 0x0490 , 0x10 },
161 | { 0x13e0 , 0x10 },
162 | { 0x04a0 , 0x10 },
163 | { 0x13f0 , 0x10 },
164 | { 0x04b0 , 0x10 },
165 | { 0x1400 , 0x10 },
166 | { 0x04c0 , 0x10 },
167 | { 0x1410 , 0x10 },
168 | { 0x04d0 , 0x10 },
169 | { 0x1420 , 0x10 },
170 | { 0x04e0 , 0x10 },
171 | { 0x1430 , 0x10 },
172 | { 0x04f0 , 0x10 },
173 | { 0x1440 , 0x10 },
174 | { 0x0500 , 0x10 },
175 | { 0x1450 , 0x10 },
176 | { 0x0510 , 0x10 },
177 | { 0x1460 , 0x10 },
178 | { 0x0520 , 0x10 },
179 | { 0x1470 , 0x10 },
180 | { 0x0530 , 0x10 },
181 | { 0x1480 , 0x10 },
182 | { 0x0540 , 0x10 },
183 | { 0x1490 , 0x10 },
184 | { 0x0550 , 0x10 },
185 | { 0x14a0 , 0x10 },
186 | { 0x0560 , 0x10 },
187 | { 0x14b0 , 0x10 },
188 | { 0x0570 , 0x10 },
189 | { 0x14c0 , 0x10 },
190 | { 0x0580 , 0x10 },
191 | { 0x14d0 , 0x10 },
192 | { 0x0590 , 0x10 },
193 | { 0x14e0 , 0x10 },
194 | { 0x05a0 , 0x10 },
195 | { 0x14f0 , 0x10 },
196 | { 0x05b0 , 0x10 },
197 | { 0x1500 , 0x10 },
198 | { 0x05c0 , 0x10 },
199 | { 0x1510 , 0x10 },
200 | { 0x05d0 , 0x10 },
201 | { 0x1520 , 0x10 },
202 | { 0x05e0 , 0x10 },
203 | { 0x1530 , 0x10 },
204 | { 0x05f0 , 0x10 },
205 | { 0x1540 , 0x10 },
206 | { 0x0600 , 0x10 },
207 | { 0x1550 , 0x10 },
208 | { 0x0610 , 0x10 },
209 | { 0x1560 , 0x10 },
210 | { 0x0620 , 0x10 },
211 | { 0x1570 , 0x10 },
212 | { 0x0630 , 0x10 },
213 | { 0x1580 , 0x10 },
214 | { 0x0640 , 0x10 },
215 | { 0x1590 , 0x10 },
216 | { 0x0650 , 0x10 },
217 | { 0x15a0 , 0x10 },
218 | { 0x0660 , 0x10 },
219 | { 0x15b0 , 0x10 },
220 | { 0x0670 , 0x10 },
221 | { 0x15c0 , 0x10 },
222 | { 0x0680 , 0x10 },
223 | { 0x15d0 , 0x10 },
224 | { 0x0690 , 0x10 },
225 | { 0x15e0 , 0x10 },
226 | { 0x06a0 , 0x10 },
227 | { 0x15f0 , 0x10 },
228 | { 0x06b0 , 0x10 },
229 | { 0x1600 , 0x10 },
230 | { 0x06c0 , 0x10 },
231 | { 0x1610 , 0x10 },
232 | { 0x06d0 , 0x10 },
233 | { 0x1620 , 0x10 },
234 | { 0x06e0 , 0x10 },
235 | { 0x1630 , 0x10 },
236 | { 0x06f0 , 0x10 },
237 | { 0x1640 , 0x10 },
238 | { 0x0700 , 0x10 },
239 | { 0x1650 , 0x10 },
240 | { 0x0710 , 0x10 },
241 | { 0x1660 , 0x10 },
242 | { 0x0720 , 0x10 },
243 | { 0x1670 , 0x10 },
244 | { 0x0730 , 0x10 },
245 | { 0x1680 , 0x10 },
246 | { 0x0740 , 0x10 },
247 | { 0x1690 , 0x10 },
248 | { 0x0750 , 0x10 },
249 | { 0x16a0 , 0x10 },
250 | { 0x0760 , 0x10 },
251 | { 0x16b0 , 0x10 },
252 | { 0x0770 , 0x10 },
253 | { 0x16c0 , 0x10 },
254 | { 0x0780 , 0x10 },
255 | { 0x16d0 , 0x10 },
256 | { 0x0790 , 0x10 },
257 | { 0x16e0 , 0x10 },
258 | { 0x07a0 , 0x10 },
259 | { 0x16f0 , 0x10 },
260 | { 0x07b0 , 0x10 },
261 | { 0x1700 , 0x10 },
262 | { 0x07c0 , 0x10 },
263 | { 0x1710 , 0x10 },
264 | { 0x07d0 , 0x10 },
265 | { 0x1720 , 0x10 },
266 | { 0x07e0 , 0x10 },
267 | { 0x1730 , 0x10 },
268 | { 0x07f0 , 0x10 },
269 | { 0x1740 , 0x10 },
270 | { 0x0800 , 0x10 },
271 | { 0x1750 , 0x10 },
272 | { 0x0810 , 0x10 },
273 | { 0x1760 , 0x10 },
274 | { 0x0820 , 0x10 },
275 | { 0x1770 , 0x10 },
276 | { 0x0830 , 0x10 },
277 | { 0x1780 , 0x10 },
278 | { 0x0840 , 0x10 },
279 | { 0x1790 , 0x10 },
280 | { 0x0850 , 0x10 },
281 | { 0x17a0 , 0x10 },
282 | { 0x0860 , 0x10 },
283 | { 0x17b0 , 0x10 },
284 | { 0x0870 , 0x10 },
285 | { 0x17c0 , 0x10 },
286 | { 0x0880 , 0x10 },
287 | { 0x17d0 , 0x10 },
288 | { 0x0890 , 0x10 },
289 | { 0x17e0 , 0x10 },
290 | { 0x08a0 , 0x10 },
291 | { 0x17f0 , 0x10 },
292 | { 0x08b0 , 0x10 },
293 | { 0x1800 , 0x10 },
294 | { 0x08c0 , 0x10 },
295 | { 0x1810 , 0x10 },
296 | { 0x08d0 , 0x10 },
297 | { 0x1820 , 0x10 },
298 | { 0x08e0 , 0x10 },
299 | { 0x1830 , 0x10 },
300 | { 0x08f0 , 0x10 },
301 | { 0x1840 , 0x10 },
302 | { 0x0900 , 0x10 },
303 | { 0x1850 , 0x10 },
304 | { 0x0910 , 0x10 },
305 | { 0x1860 , 0x10 },
306 | { 0x0920 , 0x10 },
307 | { 0x1870 , 0x10 },
308 | { 0x0930 , 0x10 },
309 | { 0x1880 , 0x10 },
310 | { 0x0940 , 0x10 },
311 | { 0x1890 , 0x10 },
312 | { 0x0950 , 0x10 },
313 | { 0x18a0 , 0x10 },
314 | { 0x0960 , 0x10 },
315 | { 0x18b0 , 0x10 },
316 | { 0x0970 , 0x10 },
317 | { 0x18c0 , 0x10 },
318 | { 0x0980 , 0x10 },
319 | { 0x18d0 , 0x10 },
320 | { 0x0990 , 0x10 },
321 | { 0x18e0 , 0x10 },
322 | { 0x09a0 , 0x10 },
323 | { 0x18f0 , 0x10 },
324 | { 0x09b0 , 0x10 },
325 | { 0x1900 , 0x10 },
326 | { 0x09c0 , 0x10 },
327 | { 0x1910 , 0x10 },
328 | { 0x09d0 , 0x10 },
329 | { 0x1920 , 0x10 },
330 | { 0x09e0 , 0x10 },
331 | { 0x1930 , 0x10 },
332 | { 0x09f0 , 0x10 },
333 | { 0x1940 , 0x10 },
334 | { 0x0a00 , 0x10 },
335 | { 0x1950 , 0x10 },
336 | { 0x0a10 , 0x10 },
337 | { 0x1960 , 0x10 },
338 | { 0x0a20 , 0x10 },
339 | { 0x1970 , 0x10 },
340 | { 0x0a30 , 0x10 },
341 | { 0x1980 , 0x10 },
342 | { 0x0a40 , 0x10 },
343 | { 0x1990 , 0x10 },
344 | { 0x0a50 , 0x10 },
345 | { 0x19a0 , 0x10 },
346 | { 0x0a60 , 0x10 },
347 | { 0x19b0 , 0x10 },
348 | { 0x0a70 , 0x10 },
349 | { 0x19c0 , 0x10 },
350 | { 0x0a80 , 0x10 },
351 | { 0x19d0 , 0x10 },
352 | { 0x0a90 , 0x10 },
353 | { 0x19e0 , 0x10 },
354 | { 0x0aa0 , 0x10 },
355 | { 0x19f0 , 0x10 },
356 | { 0x0ab0 , 0x10 },
357 | { 0x1a00 , 0x10 },
358 | { 0x0ac0 , 0x10 },
359 | { 0x1a10 , 0x10 },
360 | { 0x0ad0 , 0x10 },
361 | { 0x1a20 , 0x10 },
362 | { 0x0ae0 , 0x10 },
363 | { 0x1a30 , 0x10 },
364 | { 0x0af0 , 0x10 },
365 | { 0x1a40 , 0x10 },
366 | { 0x0b00 , 0x10 },
367 | { 0x1a50 , 0x10 },
368 | { 0x0b10 , 0x10 },
369 | { 0x1a60 , 0x10 },
370 | { 0x0b20 , 0x10 },
371 | { 0x1a70 , 0x10 },
372 | { 0x0b30 , 0x10 },
373 | { 0x1a80 , 0x10 },
374 | { 0x0b40 , 0x10 },
375 | { 0x1a90 , 0x10 },
376 | { 0x0b50 , 0x10 },
377 | { 0x1aa0 , 0x10 },
378 | { 0x0b60 , 0x10 },
379 | { 0x1ab0 , 0x10 },
380 | { 0x0b70 , 0x10 },
381 | { 0x1ac0 , 0x10 },
382 | { 0x0b80 , 0x10 },
383 | { 0x1ad0 , 0x10 },
384 | { 0x0b90 , 0x10 },
385 | { 0x1ae0 , 0x10 },
386 | { 0x0ba0 , 0x10 },
387 | { 0x1af0 , 0x10 },
388 | { 0x0bb0 , 0x10 },
389 | { 0x1b00 , 0x10 },
390 | { 0x0bc0 , 0x10 },
391 | { 0x1b10 , 0x10 },
392 | { 0x0bd0 , 0x10 },
393 | { 0x1b20 , 0x10 },
394 | { 0x0be0 , 0x10 },
395 | { 0x1b30 , 0x10 },
396 | { 0x0bf0 , 0x10 },
397 | { 0x1b40 , 0x10 },
398 | { 0x0c00 , 0x10 },
399 | { 0x1b50 , 0x10 },
400 | { 0x0c10 , 0x10 },
401 | { 0x1b60 , 0x10 },
402 | { 0x0c20 , 0x10 },
403 | { 0x1b70 , 0x10 },
404 | { 0x0c30 , 0x10 },
405 | { 0x1b80 , 0x10 },
406 | { 0x0c40 , 0x10 },
407 | { 0x1b90 , 0x10 },
408 | { 0x0c50 , 0x10 },
409 | { 0x1ba0 , 0x10 },
410 | { 0x0c60 , 0x10 },
411 | { 0x1bb0 , 0x10 },
412 | { 0x0c70 , 0x10 },
413 | { 0x1bc0 , 0x10 },
414 | { 0x0c80 , 0x10 },
415 | { 0x0c90 , 0x10 },
416 | { 0x0ca0 , 0x10 },
417 | { 0x0cb0 , 0x10 },
418 | { 0x0cc0 , 0x10 },
419 | { 0x0cd0 , 0x10 },
420 | { 0x0ce0 , 0x10 },
421 | { 0x0cf0 , 0x10 },
422 | { 0x0d00 , 0x10 },
423 | { 0x0d10 , 0x10 },
424 | { 0x0d20 , 0x10 },
425 | { 0x0d30 , 0x10 },
426 | { 0x0d40 , 0x10 },
427 | { 0x0d50 , 0x10 },
428 | { 0x0d60 , 0x80 },
429 | { 0x0de0 , 0x50 },
430 | { 0x0e40 , 0x28 },
431 | { 0x0ed0 , 0x48 },
432 | { 0x1c00 , 0x80 },
433 | { 0x1c80 , 0x80 },
434 | { 0x0f18 , 0x08 },
435 | {0,0}
436 | };
437 | 
438 | #endif
439 | 
440 | 


--------------------------------------------------------------------------------
/uvk5_original_eeprom.raw:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/piotr022/k5prog/ef73378ec80d9e0351100bfd649d9189f4502fd4/uvk5_original_eeprom.raw


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